UEFI: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		## Motivations behind this target
2	2
3	3		The Unified Extensible Firmware Interface (UEFI) now replaces BIOS in most current PCs.
4	4
5	5		Currently, there are two main options to develop UEFI applications:
6	6
7	7		- [Tianocore](http://www.tianocore.org/)
8	8		- [gnu-efi](http://sourceforge.net/projects/gnu-efi/)
9	9
10	10		Both solutions require a tedious setup process.
11	11
12	12		Thank to its internal linker, Free Pascal can become the easiest option to develop UEFI applications, as no external tools would be required to start hacking.
13	13
14	14		## Technical requirements
15	15
16	16		UEFI applications are PE binaries like the Windows target, which Free Pascal already supports. The only difference is the subsystem in the PE header.
17	17
18	18		Calling conventions under UEFI are identical to the ones under Windows on the same architecture, which Free Pascal already supports, too.
19	19
20	20		## Current state
21	21
22	22		My current patch against trunk is here : <http://nan.tf/download/uefi_all_03_01_2016.diff>.
23	23
24	24		It is not yet a clean patch : lots of debug output inside.
25	25
26	26		I have resume my work on this target. Here is my updated patch against trunk : <http://nan.tf/download/fpc_uefi_28_04_2017.diff>
27	27
28	28		Currently, I am focusing on UEFI32 because i have a few cheap atom machines with that version (see <https://software.intel.com/en-us/blogs/2015/07/22/why-cheap-systems-run-32-bit-uefi-on-x64-systems>) and because i use Haiku as my main development platform, without a 64 bits freepascal yet.
29	29
30	30		But UEFI64 support should be easy to had with careful API declarations.
31	31
32	32		A branch is now available with the current development state at <https://svn.freepascal.org/cgi-bin/viewvc.cgi/branches/olivier/uefi/>
33	33
34	34		## Build instructions
35	35
36	36		For UEFI 32 target, the build command line is :
37	37
38		-	~~`make all OS_TARGET=uefi CPU_TARGET=i386`~~
	38	+	```text
	39	+	make all OS_TARGET=uefi CPU_TARGET=i386
	40	+	```
39	41
40	42		For UEFI 64 target, the build command line is :
41	43
42		-	~~`make all OS_TARGET=uefi CPU_TARGET=x86_64`~~
	44	+	```text
	45	+	make all OS_TARGET=uefi CPU_TARGET=x86_64
	46	+	```
43	47
44	48		If you want to cross compile from a different architecture, it might be necessary to specify OS_SOURCE and CPU_SOURCE. Here is for example the command line for Haiku 32 bits.
45	49
46		-	~~`make all OS_TARGET=uefi CPU_TARGET=x86_64 OS_SOURCE=haiku CPU_SOURCE=i386`~~
	50	+	```text
	51	+	make all OS_TARGET=uefi CPU_TARGET=x86_64 OS_SOURCE=haiku CPU_SOURCE=i386
	52	+	```
47	53
48	54		## Known problems
49	55
50	56		Affectation of string constant to string variable does not work. It is currently necessary to create strings through an array of WideChar.
51	57
52	58		``` pascal
53	59		var
54	60		s : string;
55	61		begin
56	62		s := 'Hello world !';
57	63		end;
58	64		```
59	65
60	66		Maybe it is related to Position Independent Code generation in the case of PE executables ?
61	67
62	68		Any hints in this area are welcome ;-)
63	69
64	70		With current trunk (3.1.1), this bug has been fixed. It helps a lot to be able to use WriteLn('Something to write') instead of constructing an array of WideChar and call UEFI functions as before ;-).
65	71
66	72		Other known problem :
67	73
68	74		``` pascal
69	75		list := TStringList.Create;
70	76		```
71	77
72	78		While constructing other kind of object works as expected, this one currently crash the program... I will have to investigate.
73	79
74	80		Update : it seems related to uses : without any uses in my program, it just works... With only one, it crash.
75	81
76	82		Update 2 : I have finally found the problem : SysUtils initialize some static constructions BEFORE unit initialization. That is why it was always crashing when adding a uses to SysUtils in a simple program, but before the initialization section. That explain why my debugging messages in SysUtils where never displayed...
77	83
78	84		## Testing UEFI applications with qemu
79	85
80	86		See [OSDev UEFI Emulation with QEMU and OVMF](http://wiki.osdev.org/UEFI#Emulation_with_QEMU_and_OVMF)
81	87
82	88		To avoid creating an image, i use FAT emulation to a local directory where my UEFI application is located :
83	89
84	90		``` bash
85	91		qemu-system-i386-x86 -pflash /path/to/OVMF.fd -hda fat:local_directory -net none
86	92		```
87	93
88	94		"-net none" avoid net booting to save a few seconds in the boot process.
89	95
90	96		From UEFI shell, then write :
91	97
92		-	~~`fs0:`~~
	98	+	```text
	99	+	fs0:
	100	+	```
93	101
94	102		to switch to the directory where are located your application then you can launch it :
95	103
96		-	~~`app.efi`~~
	104	+	```text
	105	+	app.efi
	106	+	```
97	107
98	108		## History
99	109
100	110		Everything has started after reading this article while i was lurking about UEFI development : <http://blog.theincredibleholk.org/blog/2013/11/18/booting-to-rust/>
101	111
102	112		What about doing that in Freepascal as well ?
103	113
104	114		It appears that Freepascal is even a better target for such a project because of its internal linker for PE targets : no need to install and configure an external one.
105	115
106	116		August 2014
107	117
108	118		Proof of concept : Freepascal is able to output a PE binary that can run in an UEFI environment. It can output a static text and the version of the firmware to the screen using an UEFI method.
109	119
110	120		April 2017
111	121
112	122		After observing that an annoying bug about string constant was fixed, i have resumed my work on this target.
113	123
114	124		Currently, here are the features that are implemented :
115	125
116		-	~~`- WriteLn support (no more awkward array of WideChar allocation required)`\~~
117		-	~~`- Memory allocation`~~
	126	+	```text
	127	+	- WriteLn support (no more awkward array of WideChar allocation required)
	128	+	- Memory allocation
	129	+	```
118	130
119	131		May 2017
120	132
121	133		Start of x86_64 support (not functional yet). The idea is to check if the 'uses' problem is related to the use of PE32 binary format. UEFI is supposed to use PE32+ (with 64 bits relocations). UEFI specifications are not clear whether this variant is also used for UEFI32. With a x86_64 CPU and the win64 linker, this uncertainty should disappear...
122	134
123	135		Update : after a binary comparison between two different binaries compiled with the official UEFI tools, UEFI32 binaries are plain PE32 ones, with an IMAGE_OPTIONAL_HEADER with a size of 224 bytes while an UEFI64 binary contains an IMAGE_OPTIONAL_HEADER with a size of 240 bytes (some fields are 64 bits instead of 32 bits). This is confirmed in <https://msdn.microsoft.com/en-us/library/windows/desktop/ms680339(v=vs.85>).aspx. Afterthought, it make sense : i suspect Intel has chosen PE binary format and Application Binary Interface (ABI) like the corresponding ones in Windows to minimize the work at Microsoft and make sure they will adopt the UEFI specifications...
124	136
125	137		August 2017
126	138
127	139		## External resources
128	140
129	141		Some interesting development resources around UEFI :
130	142
131	143		- [UEFI specifications](http://www.uefi.org/)
132	144		- [OS development under UEFI](http://wiki.osdev.org/UEFI)
133	145		- [Managing EFI Boot Loaders for Linux: Basic Principles](http://www.rodsbooks.com/efi-bootloaders/principles.html)
134	146
135	147		---
136	148		From the Free Pascal wiki, page "UEFI", as it stood on 2020-03-01 after a change by Trev, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).
137	149		Category: Operating Systems and Platforms

Back to history