Setup Cross Compile For ARM: what changed

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

Old	New		Line
1	1		## How To setup Lazarus/FPC for arm-linux cross compiling.
2	2
3	3		With this tutorial you can make a binary file that runs on arm-linux devices. This is tested with a Nokia N900 with "[Maemo 5 OS](http://maemo.org/)" (the gnu/linux Debian based OS, developed by [Nokia](http://maemo.nokia.com/videos/introducing-maemo-5/). It is an arm-linux device that runs GTK2 and QT4.6).
4	4
5	5		If you need a simple "command prompt"/"terminal" program, after #FPC for ARM section skip to #APPENDIX A: Testing console programs.
6	6
7	7		NOTE 1: All procedures are tested on a Virtual Machine with Ubuntu 9.10 - x86 with Windows 7 as host and VirtualBox 3.0.12 as virtual machine. It is a fresh install, with all updates up to date.
8	8
9	9		NOTE 2: Replace every /home/user/ with your real user path. All other paths are simply for explanation. If you use "[Maemo SDK Virtual Image](http://maemovmware.garage.maemo.org/2nd_edition/)", replace every /home/user/ with /home/maemo/
10	10
11	11		## Automated Script
12	12
13	13		The previously provided scripts are obsolete. Please see [HERE](http://wiki.lazarus.freepascal.org/Lazarus_Manager) (see discussion page for alternative.
14	14
15	15		## Generic things to do
16	16
17	17		> Warning: These instructions are quite old - they refer to 2.2.4 while the current (December 2013) stable FPC is 2.6.2. Please adjust as you follow these and update the page. Thanks.
18	18
19	19		### Downloads
20	20
21	21		- any starting compiler from the 2.2.4 branch (e.g. fpc-2.2.4-20091214.i386.rpm) from [HERE](http://www.hu.freepascal.org/lazarus) or [HERE](http://snapshots.lazarus.shikami.org/)). It is needed to compile \>= 2.2.4 fpc sources
22	22		- latest binutils.tar.gz (e.g. binutils-2.20.tar.gz) from [HERE](http://ftp.gnu.org/gnu/binutils/)
23	23		- latest [fpc.zip](http://ftp//ftp.freepascal.org/pub/fpc/snapshot/trunk/source/fpc.zip) from [HERE](http://www.freepascal.org/develop.var)
24	24		- latest Lazarus source zip (e.g. lazarus-0.9.29-23129-20091214-src.zip) from [HERE](http://www.hu.freepascal.org/lazarus) or [HERE](http://snapshots.lazarus.shikami.org/) (faster for me)
25	25		- target libs (You can grab from SDK or from arm-device. See "#APPENDIX A: Testing console programs")
26	26
27	27		### Unpack/copy all files in the respective directories
28	28
29	29		FPC 2.2.4 installer:
30	30
31		-	~~`~/fpc_tools/fpc_2.2.4/fpc-2.2.4-20091214.i386.rpm`~~
	31	+	```text
	32	+	~/fpc_tools/fpc_2.2.4/fpc-2.2.4-20091214.i386.rpm
	33	+	```
32	34
33	35		Binutils sources:
34	36
35		-	~~`~/fpc_tools/binutils-2.20/`~~
	37	+	```text
	38	+	~/fpc_tools/binutils-2.20/
	39	+	```
36	40
37	41		Lazarus sources:
38	42
39		-	~~`~/lazarus/`~~
	43	+	```text
	44	+	~/lazarus/
	45	+	```
40	46
41	47		FPC 2.5.1 sources:
42	48
43		-	~~`~/lazarus/fpc/2.5.1/`~~
	49	+	```text
	50	+	~/lazarus/fpc/2.5.1/
	51	+	```
44	52
45	53		### Prepare Target Libs
46	54
47	55		- See "#APPENDIX A: Testing console programs" to know how/where to find target libs
48	56		- Copy all target libs to ~/lazarus/fpc/libcross
49	57
50	58		### Install dependencies
51	59
52	60		``` bash
53	61		sudo apt-get install -y alien libncurses5-dev libXp-dev libgtk2.0-dev
54	62		```
55	63
56	64		## Install & Configure Binutils
57	65
58	66		### Compile binutils for arm-linux
59	67
60	68		- If not already done, extract binutils-2.20.tar.gz in ~/fpc_tools/binutils-2.20
61	69		- Then type:
62	70
63	71		``` bash
64	72		cd ~/fpc_tools/binutils-2.20
65	73		./configure --target=arm-linux --disable-werror
66	74		make
67	75		sudo make install
68	76		mkdir ~/lazarus/fpc/binutils
69	77		ln -s /usr/local/bin/arm-linux-ar ~/lazarus/fpc/binutils/ar
70	78		ln -s /usr/local/bin/arm-linux-ld ~/lazarus/fpc/binutils/ld
71	79		sudo mv /usr/local/bin/arm-linux-as /usr/local/bin/arm-linux-as_org
72	80
73	81		sudo gedit /usr/local/bin/arm-linux-as
74	82		```
75	83
76	84		- Paste:
77	85
78	86		``` bash
79	87		#!/bin/sh
80	88		/usr/local/bin/arm-linux-as_org -meabi=5 $@
81	89		```
82	90
83	91		NOTE: option -meabi=5 force assembler to make binary eabi v5 compatible. E.g. if you need eabi v4 you will change it in -meabi=4.
84	92
85	93		- Save and close gedit
86	94		- Type:
87	95
88	96		``` bash
89	97		sudo chmod +x /usr/local/bin/arm-linux-as
90	98		ln -s /usr/local/bin/arm-linux-as ~/lazarus/fpc/binutils/as
91	99		```
92	100
93	101		## FPC
94	102
95	103		### Install precompiled fpc 2.2.4 branch
96	104
97	105		REMEMBER TO CHANGE EVERY/home/user/WITH YOUR OWN USER PATH!
98	106
99	107		- Type:
100	108
101	109		``` bash
102	110		sudo alien -i -c /home/user/fpc_tools/fpc_2.2.4/fpc-2.2.4-20091214.i386.rpm
103	111		```
104	112
105	113		- Be sure that ppc386 is right installed, type:
106	114
107	115		``` bash
108	116		which ppc386
109	117		```
110	118
111	119		if ppc386 is in the path it returns the path (e.g. /usr/bin/ppc386)
112	120
113	121		### Compile FPC from sources
114	122
115	123		- Type:
116	124
117	125		``` bash
118	126		cd ~/lazarus/fpc/2.5.1
119	127		make all OPT='-gl -O3p3' PP=/usr/bin/ppc386 (add NOGDB=1 at the end if asked)
120	128		sudo make install PP=/usr/bin/ppc386 PREFIX=/usr/ (add NOGDB=1 at the end if asked)
121	129		sudo rm /usr/bin/ppc386
122	130		sudo ln -s /usr/lib/fpc/2.5.1/ppc386 /usr/bin/ppc386
123	131		sudo mkdir /usr/share/fpcsrc/
124	132		sudo ln -sf ~/lazarus/fpc/2.5.1/ /usr/share/fpcsrc/
125	133		sudo /usr/lib/fpc/2.5.1/samplecfg /usr/lib/fpc/2.5.1/ /etc
126	134		```
127	135
128	136		## FPC for ARM
129	137
130	138		### Make FPC able to cross compile for arm-linux
131	139
132	140		- Type:
133	141
134	142		``` bash
135	143		cd ~/lazarus/fpc/2.5.1/
136	144		sudo make crossinstall CPU_TARGET=arm OS_TARGET=linux CROSSBINDIR=/home/user/lazarus/fpc/binutils/ OPT=-dFPC_ARMEL INSTALL_PREFIX=/usr
137	145		```
138	146
139	147		### Create custom fpc.cfg
140	148
141	149		REMEMBER TO CHANGE EVERY/home/user/WITH YOUR OWN USER PATH!
142	150
143	151		- Type:
144	152
145	153		``` bash
146	154		gedit ~/.fpc.cfg
147	155		```
148	156
149	157		- Paste in ~/.fpc.cfg:
150	158
151	159		#INCLUDE /etc/fpc.cfg
152	160		#IFDEF CPUARM
153	161		-Fu/usr/lib/fpc/2.5.1/units/$fpctarget/*
154	162		-Fl/usr/lib/fpc/2.5.1/units/$fpctarget/rtl/
155	163		-XP/home/user/lazarus/fpc/binutils/
156	164		-Xr/usr/lib/fpc/2.5.1/units/arm-linux/rtl/
157	165		-Xr/home/user/lazarus/fpc/libcross
158	166		-XR/home/user/lazarus/fpc/
159	167		-darm
160	168		-Tlinux
161	169		#ENDIF
162	170
163	171		- save and close gedit
164	172		- Type:
165	173
166	174		``` bash
167	175		sudo ln -sf /usr/lib/fpc/2.5.1/ppcrossarm /usr/local/bin/ppcarm
168	176		```
169	177
170	178		## Lazarus
171	179
172	180		If you don't need graphical programs, you can skip this section and go directly to #Appendix B: Target libs
173	181
174	182		### Compile Lazarus
175	183
176	184		- Type:
177	185
178	186		``` bash
179	187		cd ~/lazarus
180	188		make clean all
181	189		```
182	190
183	191		### Start Lazarus
184	192
185	193		- Start Lazarus to see that everything is ok and then to compile LCL and Package Registration
186	194		- Type:
187	195
188	196		``` bash
189	197		./lazarus
190	198		```
191	199
192	200		### Configure Lazarus for cross Compile
193	201
194	202		- Now you must cross compile the LCL and Package Registration, this part comes from [HERE](http://wiki.lazarus.freepascal.org/Cross_compiling#Cross_compiling_the_LCL).
195	203		- From the IDE:
196	204		1. In Tools -\> Options -\> Environment -\> Files, set the Compiler path to the path to fpc. Normally this is already done.
197	205		2. Then open Tools / Configure Build Lazarus / Advanced Build Options.
198	206		3. Set Target OS as linux and Target CPU as arm.
199	207		4. Set LCL and Package registration to Build (the middle radio button) and all other to None (left radio buttons).
200	208		5. Click the Build button.
201	209
202	210		## Make your first arm-linux project in Lazarus
203	211
204	212		### New Project
205	213
206	214		- Start new project as application
207	215		- Put some component in main form to test (like button, memo and few other things)
208	216
209	217		### Set Targets
210	218
211	219		- From the IDE:
212	220		1. Set in Project / Compiler Options / Code generation / Target OS (-T): Linux
213	221		2. Set in Project / Compiler Options / Code generation / Target CPU family (-P): arm
214	222		3. Set in Project / Compiler Options / Other / Custom Option: enter -XParm-linux- into textbox
215	223
216	224		### Add target libs to your project
217	225
218	226		REMEMBER TO CHANGE EVERY/home/user/WITH YOUR OWN USER PATH!
219	227
220	228		- From the IDE:
221	229		1. Set in Project / Compiler Options / Linking / Options (-k): -L/home/user/lazarus/fpc/libcross
222	230		2. Set in Project / Compiler Options / Compilation / Execute after / Command: arm-linux-strip -s /path/to/your/project/binary (where "binary" is the executable builded with Lazarus)
223	231
224	232		### Build Project
225	233
226	234		- Build Project as normal:
227	235		1. Hit keys Ctrl+F9
228	236		2. Run / Build
229	237
230	238		### Time to run
231	239
232	240		- Transfer the binary of your project on device
233	241		- Generally you must give executable permission to the binary directly on the device. If you work in terminal type:
234	242
235	243		``` bash
236	244		chmod +x /path/where/is/YourProject
237	245		./path/where/is/YourProject
238	246		```
239	247
240	248		![](/wiki-images/0/08/Kjow_hello-world.png)
241	249
242	250		## APPENDIX A: Testing console programs
243	251
244	252		### Create a TestARM.pas
245	253
246	254		- Type:
247	255
248	256		``` bash
249	257		mkdir ~/dev/TestARM/
250	258		gedit ~/dev/TestARM/TestARM.pas
251	259		```
252	260
253	261		- Paste this code:
254	262
255	263		``` pascal
256	264		program test;
257	265		begin
258	266		writeln('DATE ',{$i %DATE%});
259	267		writeln('FPCTARGET ',{$i %FPCTARGET%});
260	268		writeln('FPCTARGETCPU ',{$i %FPCTARGETCPU%});
261	269		writeln('FPCTARGETOS ',{$i %FPCTARGETOS%});
262	270		writeln('FPCVERSION ',{$i %FPCVERSION%});
263	271		end.
264	272		```
265	273
266	274		- Type:
267	275
268	276		``` bash
269	277		cd ~/dev/TestARM/
270	278		fpc -Tlinux -Parm -XParm-linux- TestARM.pas
271	279		```
272	280
273	281		### Time to run
274	282
275	283		- Transfer TestARM on device
276	284		- Generally you must give executable permission to TestARM directly on the device:
277	285
278	286		``` bash
279	287		chmod +x /path/where/is/TestAMR
280	288		./path/where/is/TestAMR
281	289		```
282	290
283	291		## Appendix B: Target libs
284	292
285	293		You need target libs to assemble and link binary file. You can find them into the SDK of your device or into the device itself.
286	294
287	295		E.g. for Nokia N900 you need to copy /lib/* and /usr/lib/* (no subdirs needed) that are present in the Nokia N900 root and you must merge all files to ~/lazarus/fpc/libcross/\
288	296		Finally, you need to rename each library not found by linker (ld) to the file name searched by linker itself.\
289	297		E.g. if you got this error
290	298
291		-	~~`libX11.so not found (or incompatible)`~~
	299	+	```text
	300	+	libX11.so not found (or incompatible)
	301	+	```
292	302
293	303		and you have a file called libX11.so.6.2.0, then you need to rename it into libX11.so
294	304
295	305		## See also
296	306
297	307		- [[Android]] Article on setting up cross-compiling on Windows for Android on ARM
298	308		- [[Cross compiling]] for cross compiling from Linux, macOS and Windows along with other useful cross-compilation information.
299	309
300	310		---
301	311		From the Free Pascal wiki, page "Setup Cross Compile For ARM", as it stood on 2020-11-26 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).

Back to history