PowerPC64 Port: what changed

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

Old	New		Line
1	1		The PowerPC64 port supports code generation for 64-bit [[PowerPC]] systems. Historically it started as entry for the [Linux On Power](http://www.linuxonpower.com/) contest.
2	2
3	3		This page contains a rough outline of what is working and especially what not, some notes about the port and several other related information. More, detailed information (about calling conventions and so on) later.
4	4
5	5		## Status
6	6
7	7		- 2.1.x compiler support
8	8		- Supports POWER4 and derivative (G5) for Linux at the moment.
9	9		- Not all instructions of the instruction set are recognized by the compiler yet, including missing support for all AltiVec (VMX) instructions.
10	10		- The compiler can be built via the standard procedure, e.g. a `make build`
11	11		- Failed test suite program count is around 20. See the [test suite results](http://www.freepascal.org/cgi-bin/testsuite.cgi) for yourselves for the latest numbers. Note that the results for the PowerPC64 compiler are not automatically created every day, but manually every now and then.
12	12		- The IDE is okay now, except for the missing debugging support.
13	13		- Many packages and their examples which are 64 bit big-endian safe already do work (OpenGL, threading, GTK, GTK2, ...)
14	14		- Default debugger information type is DWARF. Stabs are not supported and generation has been disabled. Note that DWARF support is not complete, and hence compiling some code with debugging support fails (e.g. Lazarus)
15	15
16	16		## Installing and Building
17	17
18	18		Although the current compiler is still beta, and still has a few bugs, it can already be used by interested people. To get a recent working compiler, it is easiest to start on a G5 using a snapshot, and then update it to the latest version using the development sources. Simply download one for the current development version (2.1.1 at the time of writing this) from the [FTP](ftp://ftp.freepascal.org/pub/fpc/snapshot/v21/). The snapshot for the compiler is located in the `powerpc64-linux` subdirectory.
19	19
20	20		### Installing the snapshot
21	21
22	22		Installing the snapshot is easy: Extract it somewhere (e.g. in `/usr`, the FreePascal default installation base directory), and if necessary set your `PATH` environment variable to point to the `bin` directory. Additionally, you need to add a symlink called `ppcppc64` pointing to the `ppcppc64` binary in the `lib` directory of the extracted snapshot directory. For example type
23	23
24		-	~~` ln -s /usr/lib/fpc/2.1.1/ppcppc64 ppcppc64`~~
	24	+	```text
	25	+	ln -s /usr/lib/fpc/2.1.1/ppcppc64 ppcppc64
	26	+	```
25	27
26	28		if you are in the `/usr/bin` directory.
27	29
28	30		To be able to use the latest features, it is recommened to update to the most current version using the source code, see below for more information on how to do this.
29	31
30	32		### Updating to the latest version
31	33
32	34		Another way, in particular if you do not want to install the compiler before updating to the latest version, get the `ppcppc64` binary from the snapshot file and use it to cycle the sources. Then do the following: Change into the directory where you have stored the current SVN sources from the current development branch, and enter the following command:
33	35
34		-	~~` make build PP=<path_to_ppcppc64>/ppcppc64`~~
	36	+	```text
	37	+	make build PP=<path_to_ppcppc64>/ppcppc64
	38	+	```
35	39
36	40		Take care that the given path must be an absolute path, otherwise the compilation process immediately aborts. For the people which want a much faster binary, add `OPT=-O2` to the command line. After a while (and lots of compilation) it should leave you with an empty commandline, and you are ready for installing the compiler. Assuming that you compiled as non-root, do the following:
37	41
38		-	~~` su (You will be asked for your root password)`\~~
39		-	~~` make install`\~~
40		-	~~` exit (To give up root access again)`~~
	42	+	```text
	43	+	su (You will be asked for your root password)
	44	+	make install
	45	+	exit (To give up root access again)
	46	+	```
41	47
42	48		It is possible that compiling the compiler with the `-O2` or other additional options you specified in the `OPT` parameter does not successfully cycle. In that case, first compile and install a current compiler without any additional options, and retry with that one.
43	49
44	50		### Compiling a program
45	51
46	52		Compiling a Pascal program should be as easy as typing
47	53
48		-	~~` fpc <pascal_sourcefile>`~~
	54	+	```text
	55	+	fpc <pascal_sourcefile>
	56	+	```
49	57
50	58		after installation completed successfully. If the `fpc` complains about not finding the ppcppc binary, you have to set a symbolic link to the actual binary in the installation directory as described above.
51	59
52	60		For further information please also read the offical documentation ([PDF](ftp://ftp.freepascal.org/pub/fpc/docs-pdf)) ([HTML](http://community.freepascal.org:10000/docs-html/fpctoc.html)).
53	61
54	62		## Register usage
55	63
56	64		The table below shows how the compiler uses the registers for code generation and their meaning. The „volatile“ column indicates whether this register (or register set) is volatile or not, i.e. if a register is marked as volatile, the value is not preserved across function calls, otherwise they are automatically saved and restored by the function prolog and epilog. A value of „N/A“ means that the register is handled in a special way, and in general should not be modified by the programmer. This table basically contains a summary of the information in chapter 3.2.1 of the ABI specification.
57	65
58	66		Register
59	67
60	68		Volatile
61	69
62	70		Description
63	71
64	72		r0
65	73
66	74		Y
67	75
68	76		Volatile register used in function prologs and constant loading (i.e. scratch register)
69	77
70	78		r1
71	79
72	80		N/A
73	81
74	82		Stack frame pointer. The stack must always be quadword (16 byte) aligned
75	83
76	84		r2
77	85
78	86		N/A
79	87
80	88		TOC pointer. Used for the GOT/TOC when enabling generation of PIC code (with `-Cg`), otherwise unused by Pascal programs.
81	89
82	90		r3
83	91
84	92		Y
85	93
86	94		Parameter register and return value register
87	95
88	96		r4-r10
89	97
90	98		Y
91	99
92	100		Registers used for function parameters
93	101
94	102		r11
95	103
96	104		Y
97	105
98	106		Register used in calls by pointer, otherwise used as scratch register
99	107
100	108		r12
101	109
102	110		Y
103	111
104	112		Register used for glink code and scratch register
105	113
106	114		r13
107	115
108	116		N/A
109	117
110	118		Reserved for use as system thread ID. Never touched by the FreePascal compiler
111	119
112	120		r14-r31
113	121
114	122		N
115	123
116	124		Registers used for local variables
117	125
118	126		f0
119	127
120	128		Y
121	129
122	130		Scratch register
123	131
124	132		f1
125	133
126	134		Y
127	135
128	136		Floating point parameter and return value register
129	137
130	138		f2-f13
131	139
132	140		Y
133	141
134	142		Floating point parameter registers
135	143
136	144		f14-f31
137	145
138	146		N
139	147
140	148		Registers used for local variables
141	149
142	150		LR
143	151
144	152		Y
145	153
146	154		Link register
147	155
148	156		CTR
149	157
150	158		Y
151	159
152	160		Loop counter register. FreePascal uses it for special code patterns, but not in common code
153	161
154	162		XER
155	163
156	164		Y
157	165
158	166		Fixed point exception register
159	167
160	168		FPSCR
161	169
162	170		Y
163	171
164	172		Floating point status and control register
165	173
166	174		CR0-CR3
167	175
168	176		Y
169	177
170	178		Condition code register fields
171	179
172	180		CR2-CR4
173	181
174	182		N
175	183
176	184		Nonvolatile condition code register fields
177	185
178	186		CR5-CR7
179	187
180	188		Y
181	189
182	190		Volatile condition code register fields
183	191
184	192		### Notes
185	193
186	194		- The condition register is never saved to the stack in a function prolog, because FreePascal and its RTL only uses the volatile parts of this register.
187	195		- There is no support for VMX (AltiVec) extensions in FreePascal, so no register usage is given.
188	196		- r0, r2, r11 and r12 may be destroyed during a function call, i.e. you cannot pass a value to the callee using these registers.
189	197		- do not change r2 at any time, it is used to access the GOT/TOC and is managed automatically by the program loader and linker.
190	198		- The stack is always aligned to 16 bytes as per ABI convention.
191	199
192	200		## 32 bit compatibility
193	201
194	202		During porting several compatibility problems of 32 bit PowerPC programs with the 32 bit emulation layer of Linux were found. They are:
195	203
196	204		- the default cache line size is 128 byte instead of 32 byte. This affects some RTL routines which assume 32 byte cache line length, i.e. the assembly fillchar() and move() methods. For this reason, most (except very trivial) FPC compiled programs immediately segfault on PowerPC64. Fixing this involves selecting cache line aware fillchar() and move() methods at program startup.
197	205
198	206		There may (and I think there are) more issues. These are only those which I could reproducably pinpoint at this time.
199	207
200	208		## Optimizing for PowerPC64
201	209
202	210		There are a few rules of thumb to make PowerPC64 programs perform well. This section will present at least some of them. Of course, these are rather low-level, often a better algorithm is more advantageous than to do this sort of bean-counting.
203	211
204	212		- Use at least the `-O2` (level 2 optimizations) compiler switch which enables register variables to minimize stores and loads to memory. As a side effect this also results in smaller executables. PowerPC64 is a RISC platform, and as such, does not have the complex instructions which can take memory operands. For example, using `-O2` more than halves the time required for cycling the compiler.
205	213		- Align your data if possible. Unaligned access (especially for 64 bit loads and stores on addresses not divisble by four) performs poorly. This basically means, do not use the `packed` modifier for records unless required. See also below for more information about misalignment costs.
206	214		- Use the appropriate data type, preferring 32 bit integers over 64 bit integers due to reduced memory bandwidth requirements. Using a data type less than 32 bits does not give any speed advantage (except maybe if you are bandwidth constrained) because there are only 32 and 64 bit variants of the "slow" integer arithmetic instructions (div, mul). (*)
207	215		- The compiler automatically replaces integer divisions and integer modulo operation with a constant by faster multiplication. Additionally it does proper replacement by shifts if possible, so you do not need to care too much about it. This can be activated using the `-O2` compiler switch.
208	216		- If you enable `-Os` (Optimize for size) the compiler does not inline function prolog and epilog, and uses a stub for calling methods by pointer. This decreases the size of these parts of the code at the expense of additional calls, maybe helping in situations where there are problems with instruction fetch bandwidth.
209	217		- Enable PIC code generation (with `-Cg`), resulting in smaller and faster code. The reason is that on the 64 bit PowerPC platform address loading takes five instructions, while when enabling this switch this instruction sequences are replaced by a single memory load.
210	218
211	219		(*) Although these optimizations are not implemented yet for the PowerPC64 platform, they surely will be =). Maybe these optimizations will require setting some optimization switch though, or will be disabled for some settings.
212	220
213	221		### Alignment rules
214	222
215	223		Some rules and information on alignment penalties on the PPC970 processor, taken from the manuals. These are mainly of interest for assembly programmers though:
216	224
217	225		- A memory reference is misaligned if its address is not divisible by the size of the access.
218	226		- The hardware handles all misaligned memory references, i.e. loads and stores. However, it does so with different penalties depending on the memory boundary crossed and the size of the memory access. The interesting boundary granularities are 32, 64 and 4096 bytes.
219	227		- In general the processor does a reasonable job of handling unaligned loads/stores which do not cross a lower than 32 byte boundary.
220	228		- Doubleword (8 byte) should be at least aligned on a word (4 byte) boundary. If you are sure to do a misaligned doubleword load/store, use two word sized operations.
221	229		- When using the loads and stores to copy data, and both source and destination are misaligned, align the source. Loads get penalties on misaligned 32/64 and 4k boundaries, while stores only on 4k boundaries. One can avoid both penalties in this case by aligning on one address, and constructing an aligned access to the other address by clever shifts.
222	230		- VMX memory loads/stores require 16 byte alignment. If you load/store from an unaligned address, the processor silently aligns the address, i.e. it works as if the lower 4 bits of the effective address are zero.
223	231
224	232		## Debugging and Profiling
225	233
226	234		This section contains some information on tools to debug and test applications for the PowerPC64 platform generated by the FreePascal compiler.
227	235
228	236		In general, the FreePascal standard debugging facilities, i.e. enabling debug code generation (`-g` switch) in conjunction with line information (`-gl`) and heap tracing (`-gh`) works. See the FreePascal manual for more information about these things.
229	237
230	238		Currently FreePascal the integrated debugger in the IDE does not work. You either have to resort to the [GNU GDB](http://www.gnu.org/software/gdb) commandline debugger and any of the backends (for example [DDD](http://www.gnu.org/software/ddd)). Make sure that debugging for the 64 bit PowerPC platform has been compiled in - some Linux distributions only provide a GDB capable of debugging 32 bit applications.
231	239
232	240		Using the latest FreePascal compiler version, basic profiling can be done with [GNU gprof](http://www.gnu.org/software/binutils/). See the manual on how to enable generation of required code (Note: try the `-pg` compiler switch). Since gprof seems to be pretty basic and the technique used rather intrusive, requiring some additional code in the executable, make sure to also try the profilers mentioned in the subsection below.
233	241
234	242		### Additional resources
235	243
236	244		This subsection contains some information for additional debugging or profiling resources on the PowerPC64/Linux platform:
237	245
238	246		- The current source tree of [Valgrind](http://www.valgrind.org) (3.2.0) supports the PowerPC64 processor on the Linux platform. Valgrind provides a set of tools for memory debugging, memory leak detection and profiling.\
239	247		Since PowerPC64 support is only available in the source tree, you have to get the latest version from the SVN tree and compile it yourselves. The Valgrind homepage contains instructions for all these steps (see the [Valgrind Code Repository](http://valgrind.org/downloads/repository.html)).
240	248		- Another profiling tool available for profiling PowerPC64 applications is [OProfile](http://oprofile.sourceforge.net). Depending on your Linux distribution, it may or may not already be installed. Next to the introduction on the OProfile homepage, IBM provides some examples [here](http://www-128.ibm.com/developerworks/linux/library/l-oprof.html) and [here](http://www-128.ibm.com/developerworks/library/l-pow-oprofile/).
241	249
242	250		## Troubleshooting
243	251
244	252		This section contains some hints for solving mysterious behaviour of compiled code
245	253
246	254		Problem: When linking to some C library, the code sometimes crashes.
247	255
248	256		Solution: Some C libraries (for example OpenGL) sometimes give an "Invalid Floating Point Operation" (Underflow, Overflow) or similar when used in Pascal. This is due to bugs in the C library which are not detected there, because C by default disables these exceptions. Try adding the following assembly code to your main program: `asm mtfsfi 6, 1 end;`. This disables these exceptions globally (also in the Pascal program). To fix this, tell the maintainers of the library about this bug.
249	257
250	258		Problem: The compiler gives strange errors, especially after updating to a new version
251	259
252	260		Solution: Make sure that there are not any stale (old) compiled units lying around, and make sure that the compiler actually uses the recent ones (use the `-vt` switch to display tried files)
253	261
254	262		Problem: Debugging information is displayed incorrectly or not at all.
255	263
256	264		Solution: Enable debugging support using the `-g` switch to enable generation of debugging information.
257	265
258	266		## More information
259	267
260	268		This section contains links and notes to further information about the PowerPC64 architecture. This includes links to the ABI specification, general processor descriptions, instruction set documentation and general compiler notes.
261	269
262	270		- Ian Lance Taylor, 64-bit PowerPC ELF Application Binary Interface Supplement 1.7, Zenbu Labs IBM, 2004 ([HTML](http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html)) ([PDF](http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi-1.7.pdf)) - This was the original ABI specification the PowerPC64 compiler was developed with.
263	271
264	272		- Ian Lance Taylor, 64-bit PowerPC ELF Application Binary Interface Supplement 1.9, Zenbu Labs IBM, 2004 ([HTML](http://www.linuxbase.org/spec/ELF/ppc64/spec/)) (No PDF) - An update to the previous ABI specification. However, it only seems to add some clarifications compared to 1.7.
265	273
266	274		- [PowerPC 970 and 970FX microprocessor documentation](http://www-306.ibm.com/chips/techlib/techlib.nsf/products/PowerPC_970_and_970FX_Microprocessors) - This website contains lots of information about the 970 and 970FX microprocessors. The (imo) most interesting references from this page are summarized below.
267	275
268	276		- [IBM PowerPC 970FX RISC Microprocessor User's Manual](http://www-306.ibm.com/chips/techlib/techlib.nsf/techdocs/AE818B5D1DBB02EC87256DDE00007821) - This website contains a manual which contains the technical description of the 970FX (G5) processor with (mainly) interesting information about the storage and memory subsystem.
269	277
270	278		- [Developing Embedded Software For The IBM PowerPC™ 970FX Processor](http://www-306.ibm.com/chips/techlib/techlib.nsf/techdocs/AB70A3470F9CC0E287256ECC006D6A54) - Contains an application note which describes the differences between PowerPC32 and PowerPC64, and the issues which need to be handled when porting from the PowerPC32 to the PowerPC64 architecture
271	279
272	280		- [The Programming Environments Manual for 64-bit Microprocessors](http://www-306.ibm.com/chips/techlib/techlib.nsf/techdocs/F7E732FF811F783187256FDD004D3797) - This website contains a manual which summarizes the features and pecularities of the 64 bit processor from a programmer's point of view, including overview of the processor, instruction set and so on.
273	281
274	282		- [PowerPC Architecture Book](http://www-128.ibm.com/developerworks/eserver/articles/archguide.html) - This website contains links to the PowerPC architecture manuals, i.e. a complete description of the instruction sets, containing both privileged and unprivileged instructions. The next links are direct references to the three books: Book I ([PDF](ftp://www6.software.ibm.com/software/developer/library/es-archpub1.zip)), Book I I ([PDF](ftp://www6.software.ibm.com/software/developer/library/es-archpub2.zip)), Book III ([PDF](ftp://www6.software.ibm.com/software/developer/library/es-archpub3.zip))
275	283
276	284		- [PowerPC Compiler Writer's Guide](http://www-3.ibm.com/chips/techlib/techlib.nsf/techdocs/852569B20050FF7785256996007558C6) - This website contains useful information for writing compilers for the PowerPC architecture, i.e. optimized code examples for common patterns. This manual has been written for the PowerPC32 architecture, but the techniques presented there can be easily ported over to the PowerPC64 platform.
277	285
278	286		- [GNU C/C++ toolchain for Linux on POWER](http://www-128.ibm.com/developerworks/library/l-pow-gnutool/) page - Introductory text about the GNU C/C++ toolchain. Although this page seems to be totally unrelated to FreePascal, it also contains a short overview of the GOT and TOC sections.
279	287
280	288		## Contact
281	289
282	290		Message to the fpc-devel mailing list, or look for "tom_at_work" in the IRC channel (or of course discuss it here).
283	291
284	292		---
285	293		From the Free Pascal wiki, page "PowerPC64 Port", as it stood on 2016-11-27 after a change by Jwdietrich, 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).
286	294		Category: PowerPC

Back to history