Cross compiling/es: what changed

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

Old	New		Line
1	1		## Introducción
2	2
3	3		Esta es una breve introducción para los nuevos en esta temática. Las siguientes secciones describen cómo configurar un sistema para realizar compilación cruzada ( - e.g. trabajar bajo linux y generar ejecutables Win32 desde el mismo (o esto mismo para FreeBSD o Darwin, etc.). En este caso la plataforma usada para la compilación a menudo se refiere como "host" o anfitrión (Linux en el ejemplo anterior), mientras que la plataforma para la que queremos crear los binaros ejecutables es el "target" u objetivo. FreePascal es un compilador y básicamente convierte el código fuente en binario (lenguaje máquina). Estos binarios además contienen información sobre cómo los inicia el sistema operativo. Además, los binarios referencian a las APIs aportadas por un sistema operativo en particular, siendo esta la razón por la que es necesaria una implementación diferente de la Run Time Library (RTL) para cada sistema operativo. Por tanto, tales binarios son específicos de cada plataforma. FreePascal por sí mismo no necesita demasiados ajustes. Puede crear binarios para muchas plataformas. Simplemente indíqueselo.
4	4
5	5		## "Host" y "Target" en la misma CPU
6	6
7	7		FPC se ha diseñado de manera que el compilador distribuido pueda generar código de máquina para determinada CPU (debido a que diferentes CPUs necesitan diferentes códigos de máquina) y sepa de los requerimientos específicos para todas las plataformas soportadas (Sistemas Operativos) disponibles en una CPU en particular. Esto significa que se puede realizar compilación cruzada (cross-compilation) con un mismo compilador usado para compilación nativa siempre que te mantengas en la misma CPU.
8	8
9	9		## "Host" y "Target" en diferentes CPUs
10	10
11	11		Si se necesita crear binarios para una CPU diferente entonces necesitará un compilador "cruzado" especial, p.e. un compilador ejecutándose en la plataforma host, pero que sea capaz de crear código de máquina para una CPU distinta (en el caso de FPC, tal compilador-cruzado debería ser nuevamente capaz de establecer como objetivo final _target_ todas las plataformas disponibles en la CPU que deseemos). Este compilador cruzado se ubica por lo general en el mismo directorio que el compilador nativo. Tal compilador cruzado podría ser compilado por usted, o puede usar uno ya construido provisto por el equipo FPC (usualmente plataformas que en su mayoría se usan en dispositivos portables tales como arm-linux o arm-wince, debido a que no se usan por lo general como plataformas host). El binario FPC puede entonces elegir el compilador correcto (tanto el compilador nativo como el compilador cruzado) para la CPU objetivo usando el parámetro -P.
12	12
13	13		## Targets soportados
14	14
15	15		Revise el [[Free Pascal supported targets\|artículo sobre sistemas operativos soportados de Target]] para la lista completa.
16	16
17	17		## Ensamblador y enlazador
18	18
19	19		El compilador es sólo una parte. También necesitamos el ensamblador y el enlazador. FPC provee un ensamblador interno y/o enlazador para ciertas plataformas, pero otras plataformas necesitan herramientas externas. Por lo general estas herramientas no son capaces de crear binarios para distintas plataformas. Es por lo que tenemos que utilizar un enlazador especial '-ld' y un ensamblador '-as' para cada plataforma objetivo. Estas son las utilidades binarias (binutils). Ver[[Binutils]]
20	20
21	21		## Unidades para objetivos (target)
22	22
23	23		Después de crear (o tener/instalar) las utilidades cruzadas, se necesita el FPC RTL y otras unidades compiladas para la plataforma objetivo escogida. Por ejemplo, cada plataforma objetivo necesita un archivo system.ppu diferente (unidad System), etc. Estas unidades pueden ser tanto compiladas utilizando tu compilador configurado para compilar conforme a la plataforma objetivo, o puede usar de forma potencial las unidades oficialmente compiladas (y distribuidas) con la misma versión de FPC (si están disponibles en formato usable bajo la plataforma host en particular).
24	24
25	25		No valdrá que no necesite un nuevo compilador cruzado para cada combinación entre CPU y sistema operativo, pero realmente necesita las Unidades FPC. Por ejemplo, en una configuración de host para Linux que compile hacia Windows y Raspberri Pi, el directorio /usr/lib/fpc/3.2.2/units puede contener los siguientes directorios:
26	26
27	27		arm-linux i386-linux i386-win32 x86_64-linux x86_64-win64
28	28
29	29		Cada directorio de estos contendrá un directorio para cada una de las unidades FPC, cada una con archivos .o y .ppu.
30	30
31	31		## Configuración
32	32
33	33		Entonces hay que adaptar el archivo de configuración de FPC, de manera que la compilación cruzada resulte fácil y nos podamos olvidar de todos los aburridos detalles. Lo mismo hay que hacer para el LCL - la Librería de Componentes de Lazarus (en caso de utilizar Lazarus) - Y después de esto ya se puede realizar compilación cruzada para las (distintas)plataformas objetivo. Los binarios resultantes deben a continuación ser copiados a una máquina corriendo la plataforma objetivo, o copiarlas a un sistema virtualizado/emulado (e.g. Wine para binarios Win32 bajo Linux, etc.).
34	34
35	35		## Pasos básicos
36	36
37	37		Hay unos cuantos pasos comunes relacionados con la compilación cruzada que hay que realizar en todos los casos:
38	38
39	39		- Tener un compilador de FreePascal para la plataforma desde la que se desea compilar.
40	40		- Tener el código fuente de FreePascal (excepto para el caso especial de tener todo preparado por alguien previamente).
41	41		- Necesita además construir a partir del código fuente u obtener las utilidades binarias cruzadas (cross-binutils) que corran en la plataforma actual y estén diseñadas para construir programas para la plataforma objetivo deseada.
42	42		- Algunas veces necesitarás algunos archivos objetivo para el que se está compilando.
43	43
44	44		# Desde Linux
45	45
46	46		## Desde Linux x64 a Linux i386
47	47
48	48		Para las ocasiones en que la distribución de Linux de 64 bits sea capaz de compilar programas de 32 bits pero debido al modo en el que el proceso de construcción de FPC fue diseñado existen unas cuantas cosas que se deben hacer.
49	49
50	50		- Primero compruebe si ya tiene los archivos i386-linux-ld y i386-linux-as:
51	51
52	52		``` bash
53	53		$ which i386-linux-ld
54	54		```
55	55
56	56		``` bash
57	57		$ which i386-linux-as
58	58		```
59	59
60	60		- Si ya tiene estos archivos salte a la cabecera "Compilar FPC". En caso contrario ambos se pueden crear utilizando los siguientes script:
61	61
62	62		``` bash
63	63
64	64		#!/bin/bash
65	65
66	66		# Create /usr/bin/i386-linux-ld
67	67		cat >/usr/bin/i386-linux-ld << EOF
68	68		#!/bin/bash
69	69		ld -A elf32-i386 $@
70	70		EOF
71	71		chmod +x /usr/bin/i386-linux-ld
72	72
73	73		# Create /usr/bin/i386-linux-as
74	74		cat >/usr/bin/i386-linux-as << EOF
75	75		#!/bin/bash
76	76		as --32 $@
77	77		EOF
78	78		chmod +x /usr/bin/i386-linux-as
79	79		```
80	80
81	81		- Compilar FPC:
82	82
83	83		``` bash
84	84		cd /usr/share/fpcsrc/<version>
85	85		sudo make all CPU_TARGET=i386
86	86		```
87	87
88	88		- Entonces:
89	89
90	90		``` bash
91	91		sudo make crossinstall CPU_TARGET=i386
92	92		```
93	93
94	94		- Esto es. Edita tu fichero /etc/fpc.cfg file según necesites.
95	95
96	96		## Desde Linux a ARM Linux
97	97
98	98		Puedes encontrar información sobre como hacer la configuración para un objetivo ARM Linux (e.g. Zaurus) en [[Setup Cross Compile For ARM]].
99	99
100	100		## Desde Linux hacia Windows
101	101
102	102		La información sobre compilación cruzada con Lazarus se puede encontrar en [[Cross compiling for Windows under Linux]]
103	103
104	104		## Desde Linux a Darwin o Mac OS X
105	105
106	106		Por favor echa un vistazo a [[Cross compiling OSX on Linux\|aquí]].
107	107
108	108		# Desde Windows
109	109
110	110		## Desde Windows a Linux
111	111
112	112		Esto es menos trivial, hay algo de información en el [[buildfaq]]
113	113
114	114		ver también [[fpcup]] para descripciones sobre las binutils que funcionan y que librerías/ficheros copiar.
115	115
116	116		Tal como las Build FAQ (Preguntas Frecuentes) explican, necesitarás librerías (ficheros .so) para el sistema objetivo, e.g. desde /lib y /userTal/lib (pero pueden ser más ubicaciones). En algunos sistemas, algunos ficheros .so son actualmente scripts; verifícalos con
117	117
118	118		```dos
119	119		grep -i "ld script" *
120	120		```
121	121
122	122		Remueva los archivos .so y cópielos encima (o symlink) de los archivos .so.x que debería tener .so para que el enlazador los encuentre.
123	123
124	124		## Desde Windows a GO32v2
125	125
126	126		Puedes encontrar información detallada en [[Cross-compilation from Win32 to GO32v2]].
127	127
128	128		## Desde Windows a WinCE
129	129
130	130		[[arm-wince]] Describe como configurar un compilador cruzado para ARM CPU\
131	131		[[i386-wince]] Describe como configurar compilación para i386 CPU (sin compilación cruzada)\
132	132
133	133		## Desde Win32 a Win64
134	134
135	135		Si estás compilando la rama 2.1.1 o superior de FPC puedes hacer:
136	136
137	137		``` bash
138	138		$ make all OS_TARGET=win64 CPU_TARGET=x86_64
139	139		```
140	140
141	141		y entonces:
142	142
143	143		``` bash
144	144		$ make crossinstall OS_TARGET=win64 CPU_TARGET=x86_64
145	145		```
146	146
147	147		## Desde win64 a win32
148	148
149	149		Instala el fichero lazarus-1.6.0-fpc-3.0.0-cross-i386-win32-win64.exe y a continuación configura las opciones de proyecto a:
150	150
151	151		- Target OS : Win32
152	152		- Target CPU : i386
153	153
154	154		¡ Errando al establecer la CPU (Por defecto) conduce a una plataforma win32-x86_64 incorrecta !
155	155
156	156		# Desde Darwin (Mac OS X) i386
157	157
158	158		## Desde Darwin i386 hacia powerpc
159	159
160	160		El instalador FPC oficial para Mac OS X/i386 incluye un compilador cruzado PowerPC y todas las unidades necesarias para compilar programas PowerPC (use ppcppc en vez de ppc386 para compilar sus programas). Las instrucciones abajo descritas son necesarias si quiere compilar e instalar una nueva versión desde svn.
161	161
162	162		- Compilar FPC:
163	163
164	164		``` bash
165	165		$ cd fpc
166	166		$ make all CPU_TARGET=powerpc -j 2
167	167		```
168	168
169	169		Esto crea el compilador cruzado powerpc (fpc/compiler/ppcrosspcc) y todas las unidades. Puede instalarlos usando los siguientes comandos:
170	170
171	171		``` bash
172	172		$ sudo make FPC=`pwd`/compiler/ppc386 install CPU_TARGET=powerpc CROSSINSTALL=1
173	173		$ INSTALLED_VERSION=`./compiler/ppc386 -iV`
174	174		$ sudo mv /usr/local/lib/fpc/$INSTALLED_VERSION/ppcrossppc /usr/local/lib/fpc/$INSTALLED_VERSION/ppcppc
175	175		```
176	176
177	177		Recordatorio: Los binarios universales se crean desde los binarios individuales (i386 y powerpc) usando lipo.
178	178
179	179		## Desde Darwin i386 hacia x86_64
180	180
181	181		El instalador FPC para Mac OS X/i386 incluye un compilador x86_64 y todas las unidades necesarias para compilar programas x86_64 (use ppcx64 en vez de ppc386 para compilar sus programas o use fpc -x86_64). Las instrucciones abajo son sólo necesarias si quiere compilar e instalar una nueva versión desde el svn.
182	182
183	183		- Compilar FPC:
184	184
185	185		``` bash
186	186		$ cd fpc
187	187		$ make all CPU_TARGET=x86_64
188	188		```
189	189
190	190		Esto crea el compilador cruzado x86_64 (fpc/compiler/ppcrossx64) y todas las unidades. Puede instalarlas usando los siguientes comandos:
191	191
192	192		``` bash
193	193		$ sudo make crossinstall CPU_TARGET=x86_64
194	194		$ sudo mv /usr/local/lib/fpc/2.7.1/ppcrossx64 /usr/local/lib/fpc/2.7.1/ppcx64
195	195		```
196	196
197	197		Si quiere crear este compilador recientemente instalado la versión por defecto (*no* es recomendada, y terminará con su habilidad de construir versiones nuevas de FPC 2.7.1 sin especificar explícitamente la ruta a la versión oficial más reciente de FPC), también ejecute el siguiente comando:
198	198
199	199		``` bash
200	200		$ sudo ln -sf /usr/local/lib/fpc/2.7.1/ppcx64 /usr/local/bin/ppcx64
201	201		```
202	202
203	203		Asumiendo que todos los componentes LCL que usa su proyecto sean soportados por [\\| Cocoa widgetset](https://wiki.freepascal.org/Roadmap#Status_of_features_on_each_LCL_Interface), puede compilar un proyecto Lazarus desde la línea de comandos, usando un comando como este (ruta completa al compilador se ve necesaria):
204	204
205	205		``` bash
206	206		$ lazbuild -B project1.lpr --ws=cocoa --cpu=x86_64 --os=darwin --compiler=/usr/local/bin/ppcx64
207	207		```
208	208
209	209		Se puede revisar si el ejecutable es de 64 bits usando el comando "file":
210	210
211	211		``` bash
212	212		$ file ./project1
213	213		$ ./project1: Mach-O 64-bit executable x86_64
214	214		```
215	215
216	216		Alternativamente, puede ajustar su proyecto para compilar en 64 bits usando la interfaz gráfica de Lazarus:
217	217
218		-	~~`a.) Elija en el menú Project/Project Options`\~~
219		-	~~`b.) En Compiler Options/Compiler Commands escriba en el campo de Compiler Command lo siguiente: "/usr/local/bin/ppcx64"`\~~
220		-	~~`c.) Para Compiler Options/Config And Target abra "Target CPU family" y escoja "x86_64"`\~~
221		-	~~`d.) Para Compiler Options/Additions And Overrides guarde "LCLWidgetType := cocoa" en el LPI`~~
	218	+	``` pascal
	219	+	a.) Elija en el menú Project/Project Options
	220	+	b.) En Compiler Options/Compiler Commands escriba en el campo de Compiler Command lo siguiente: "/usr/local/bin/ppcx64"
	221	+	c.) Para Compiler Options/Config And Target abra "Target CPU family" y escoja "x86_64"
	222	+	d.) Para Compiler Options/Additions And Overrides guarde "LCLWidgetType := cocoa" en el LPI
	223	+	```
222	224
223	225		Note que un computador con OSX de 64 bits puede ejecutar bien sobre 32 bits. Sin embargo, si quiere crear un binario universal que ejecute en Intel de 32 bits como tambén en modo de 64 bits en un computador de 64 bits de Intel puede usar el comando "lipo". Esto podría permitir al computador de 64 bits acceder a más memoria y en teoría podría desarrollares un poco mejor (e.g. distintas optimizaciones del compilador, más registros aunque con punteros más grandes). Asumiendo que tenga separados los ejecutables de 32 bits ("project32") y de 64 bits ("project64") con Lazarus.
224	226
225	227		``` bash
226	228		$ lipo -create project32 project64 -o projectUniversal
227	229		```
228	230
229	231		## Desde Darwin hacia Windows, Linux y otros
230	232
231	233		El administrador de paquetes [fink](http://finkproject.org/) tiene paquetes para compilación cruzada hacia windows, linux, freebsd principalmente para Macs basados en Intel, como también para algunos Macs basados en PowerPC Macs.
232	234
233	235		``` bash
234	236		$ fink install fpc-cross-i386-win32
235	237		```
236	238
237	239		or
238	240
239	241		``` bash
240	242		$ fink install fpc-cross-arm-linux
241	243		```
242	244
243	245		instalando los compiladores cruzados.
244	246
245	247		Para compilar use estos comandos:
246	248
247	249		``` bash
248	250		fpc -Twin32 FILENAME
249	251		fpc -Parm -Tlinux FILENAME
250	252		```
251	253
252	254		La lista actual con fpc 2.6.4 es:
253	255
254	256		``` bash
255	257		fpc-cross-arm-gba
256	258		fpc-cross-arm-linux
257	259		fpc-cross-arm-nds
258	260		fpc-cross-arm-wince
259	261		fpc-cross-arm-armv4t-embedded
260	262		fpc-cross-arm-armv7m-embedded
261	263		fpc-cross-i386-darwin
262	264		fpc-cross-i386-freebsd
263	265		fpc-cross-i386-go32v2
264	266		fpc-cross-i386-linux
265	267		fpc-cross-i386-solaris
266	268		fpc-cross-i386-win32
267	269		fpc-cross-i386-wince
268	270		fpc-cross-powerpc-darwin
269	271		fpc-cross-powerpc-linux
270	272		fpc-cross-sparc-linux
271	273		fpc-cross-x86-64-darwin
272	274		fpc-cross-x86-64-freebsd
273	275		fpc-cross-x86-64-linux
274	276		fpc-cross-x86-64-win64
275	277		```
276	278
277	279		Para otras plataformas (procesadores y sistemas) tiene que hacer la configuración por sí mismo. Es básicamente siempre el mismo esquema: Primero, necesita el binutils correspondiente, el compilador cruzado y la biblioteca de tiempo de ejecución RTL. Más detalles del procedimiento de construcción se puede aprender desde los archivos de descripción del paquete fink o de los compiladores cruzados de arriba.
278	280
279	281		# From FreeBSD
280	282
281	283		## FreeBSD to SPARC
282	284
283	285		> Warning: This section appears to date from around 2005 and may not be relevant anymore. Updates are welcome.
284	286
285	287		I managed to crosscompile from x86 to Sparc Solaris 9. However the result doesn't work very well, but here is my cmdline:
286	288
287	289		in compiler/ execute:
288	290
289	291		``` bash
290	292		gmake cycle CPU_TARGET=sparc OS_TARGET=solaris CROSSBINUTILPREFIX=solaris-sparc- CROSSOPT='-Xd -Fl~/src/sollib'
291	293		```
292	294
293	295		~/src/sollib is a directory that contains:
294	296
295	297		- a set of .o's from /usr/local/gcc-3.3-32bit/lib/gcc-lib/sparc-sun-solaris/3.3
296	298		- libgcc.a from /usr/local/gcc-3.3-32bit/lib/gcc-lib/sparc-sun-solaris/3.3
297	299		- a set of lib*.so from /usr/lib: libaio.so libmd5.so libc.so libelf.so librt.so libdl.so libm.so
298	300
299	301		Problem is illustrated by the following binary.
300	302
301		-	~~` Free Pascal Compiler version 2.1.1 [2006/03/17] for sparc`\~~
302		-	~~` Copyright (c) 1993-2005 by Florian Klaempfl`\~~
303		-	~~` Target OS: Solaris for SPARC`\~~
304		-	~~` Compiling system.pp`\~~
305		-	~~` system.pp(15,1) Fatal: Syntax error, "BEGIN" expected but "identifier UNIT" found`~~
	303	+	``` pascal
	304	+	Free Pascal Compiler version 2.1.1 [2006/03/17] for sparc
	305	+	Copyright (c) 1993-2005 by Florian Klaempfl
	306	+	Target OS: Solaris for SPARC
	307	+	Compiling system.pp
	308	+	system.pp(15,1) Fatal: Syntax error, "BEGIN" expected but "identifier UNIT" found
	309	+	```
306	310
307	311		I suspect wrong .o's are taken.
308	312
309	313		# General Unix/Linux notes
310	314
311	315		Option -XLA is used to rename library dependencies specified in pascal units. Format is -XLAold=new, to modify ld link option -l\<old\> to -l\<new\>.
312	316
313	317		Option -XR\<sysroot\> (recent trunk) that can be used to specify the target system root. It's used for:
314	318
315	319		- adding a prefix to the default added library paths; in the past you used to specify -Xd and these paths manually. E.g. for i386-linux instead of passing /lib, /usr/lib, and /usr/X11R6/lib to ld, it will pass \<sysroot\>/lib, \<sysroot\>/usr/lib, and \<sysroot\>/usr/X11R6/lib to ld.
316	320		- detecting the C library (linux specific): glibc or uclibc. E.g. for uclibc detection '\<sysroot\>/lib/ld-uClibc.so.0' is tried.
317	321
318	322		# Cross compiling the LCL
319	323
320	324		Since 0.9.31 the LCL is a normal Lazarus package and the IDE will automatically cross compile all needed packages, when you change the target platform of your project.
321	325
322	326		If something goes wrong, here are some hints that might help to find out why:
323	327
324	328		## Test cross compiler
325	329
326	330		Test if you have installed the cross compiled fpc correctly:
327	331
328	332		Create a hello world program test.pas:
329	333
330	334		``` pascal
331	335		program test;
332	336		begin
333	337		writeln('DATE ',{$i %DATE%});
334	338		writeln('FPCTARGET ',{$i %FPCTARGET%});
335	339		writeln('FPCTARGETCPU ',{$i %FPCTARGETCPU%});
336	340		writeln('FPCTARGETOS ',{$i %FPCTARGETOS%});
337	341		writeln('FPCVERSION ',{$i %FPCVERSION%});
338	342		end.
339	343		```
340	344
341	345		And compile it with your source/original platform. Example for x86 Windows:
342	346
343	347		``` bash
344	348		fpc -Twin32 -Pi386 test.pas
345	349		```
346	350
347	351		Then test source compiler:
348	352
349	353		``` bash
350	354		test
351	355		```
352	356
353	357		Replace win32 and i386 with your targets. Example for target Windows 64 bit:
354	358
355	359		``` bash
356	360		fpc -Twin64 -Px86_64 test.pas
357	361		```
358	362
359	363		Then test cross compiler:
360	364
361	365		``` bash
362	366		test
363	367		```
364	368
365	369		The program fpc is a wrapper that searches the right compiler (e.g. ppcrossx64) for the target and executes it.
366	370
367	371		If this does not work, your cross compiler was not installed correctly. When this works you can cross compile the LCL.
368	372
369	373		## Cross compiling the LCL in Lazarus 0.9.30 and below
370	374
371	375		If you are sure your cross compiler works, you can do the actual cross compile.
372	376
373	377		Perform the following steps in the Lazarus IDE to do an LCL cross compile: In older IDEs:
374	378
375	379		- Set in Tools -\> Options -\> Environment -\> Files the Compiler path to the path to fpc. Normally this is already done.
376	380		- Then open Tools -\> Configure Build Lazarus.
377	381		- Set Target OS (e.g. to Win64) and Target CPU (e.g. to x86_64)
378	382		- Click the Build button.
379	383
380	384		### Command line
381	385
382	386		Apart from the IDE, the command line also allows you to build a cross compiled LCL.
383	387
384	388		> Note: Since 0.9.31 you should use lazbuild to cross compile Lazarus packages. See lazbuild -h for a list of options.
385	389
386	390		An example: you would cross compile a Windows 64 cross compiler using: First thoroughly clean any 64 bit leftovers. This does not touch your 32 bit environment:
387	391
388	392		``` bash
389	393		make distclean LCL_PLATFORM=win32 CPU_TARGET=x86_64 OS_TARGET=win64
390	394		```
391	395
392	396		Then build LCL and its required dependencies. We're using LCL_PLATFORM as that presumably corresponds to the widgetset, which is still Windows 32 even on Windows 64 (the widgetsets are the same).
393	397
394	398		``` bash
395	399		make packager/registration lazutils lcl LCL_PLATFORM=win32 CPU_TARGET=x86_64 OS_TARGET=win64
396	400		```
397	401
398	402		As in the previous section, the LCL for your normal OS is untouched.
399	403
400	404		# Cross compiling LCL applications
401	405
402	406		You first need to cross compile the LCL. See above.
403	407
404	408		Cross compiling applications means: compiling plus linking. When you have cross compiled the LCL the compilation part is easy. Just set in the compiler options of the IDE the Target OS and Target CPU. The tricky part is the linking. If you cross compile a project you may see something like this:
405	409
406		-	~~`/usr/local/bin/arm-linux-ld: cannot find -lX11`~~
	410	+	```text
	411	+	/usr/local/bin/arm-linux-ld: cannot find -lX11
	412	+	```
407	413
408	414		This means you have to install the graphical libraries of the target system. This has nothing to do with FPC/Lazarus, but with cross compiling a library. Some distributions provides pre compiled packages for this. For example Microsoft provides cross compiled libraries for WinCE for Windows. Under Linux you can install Wine to cross compile from Linux to Windows. Some Linux distributions provide 64bit libraries for 32bit systems.
409	415
410	416		# Preguntas Frecuentes sobre compilación cruzada
411	417
412	418		## Por qué compilar en cruzado?
413	419
414	420		Para que pueda desarrollar un programa para un S.O./CPU y compilarlo para otro S.O./CPU sin necesidad de reiniciar o cambiar de computador.
415	421
416	422		## Por qué no compilar en cruzado?
417	423
418	424		En muchos casos, querrá probar el programa resultante en la plataforma nativa. Compilar la aplicación en esa plataforma puede ser más fácil de configurar.
419	425
420	426		## Por qué compilar desde Unix a Windows y no al revés?
421	427
422	428		Ver [[Cross compiling for Win32 under Linux]]
423	429
424	430		## Necesito más información sobre como construir FreePascal. ¿Donde la encuentro?
425	431
426	432		Hay un archivo en formato PDF sobre las FAQ generales sobre como construir y configurar FPC: [[buildfaq]]
427	433
428	434		## Errores como que el compilador "/usr/bin/fpc" no soporta arm-linux
429	435
430	436		Aparte de otras causas, este error puede ocurrir si ha editado fpc.cfg con opciones incorrectas para el compilador cruzado (e.g. especificando todos los parámetros en una línea en vez de línea por línea).
431	437
432	438		# Ver además
433	439
434	440		- [crossnotes](http://www.stack.nl/~marcov/crossnotes.txt) Notas sobre compilación cruzada.
435	441		- [[Cross compiling for Windows under Linux]]
436	442
437	443		---
438	444		From the Free Pascal wiki, page "Cross compiling/es", as it stood on 2023-02-21 after a change by Edgardager, 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