Cross compiling/ru: what changed

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

Old	New		Line
1	1		## Предисловие
2	2
3	3		Это краткое введение для новичков. В следующих разделах описывается, как настроить систему для кросскомпиляции, что означает создание двоичных файлов (исполняемых файлов) для платформы, отличной от той, которая используется для компиляции, напр., работающих под Linux и создающих исполняемые файлы Win32 (или для FreeBSD или Darwin и т.д.). В этом случае платформу, используемую для компиляции, обычно называют "хостом" \[(host)\] (Linux в приведенном выше примере), а платформа, в которой вы хотите запускать созданные двоичные файлы, является вашей "целью" \[(target)\]. FreePascal является компилятором и в основном преобразует исходный код в двоичные файлы (машинный язык). Эти двоичные файлы также содержат информацию о том, как операционная система запускает исполняемые файлы. Более того, двоичные файлы относятся к API-интерфейсам, предоставляемым конкретной операционной системой, поэтому для разных операционных систем необходима другая реализация нашей библиотеки времени выполнения. Следовательно, эти двоичные файлы являются специфичными для платформы. Сам FreePascal не нуждается в большой настройке. Он может создавать двоичные файлы для многих платформ. Таким образом, просто прикажите \[компилятору\] сделать это.
4	4
5	5		## Хост и цель на одном процессоре
6	6
7	7		FPC разработан таким образом, что распределенный компилятор может создавать машинный код для определенного процессора \[(CPU)\] (поскольку разные процессоры нуждаются в разном компьютерном коде), и он знает конкретные требования для всех поддерживаемых платформ (операционных систем), доступных на этом конкретном процессоре. Это означает, что вы можете выполнять кросс-компиляцию с тем же компилятором, который используется для встроенной компиляции, если вы придерживаетесь одного и того же CPU.
8	8
9	9		## Хост и цель на разных процессорах
10	10
11	11		Если необходимо создать двоичные файлы для другого процессора, вам нужен специальный кросскомпилятор, то есть компилятор, работающий на платформе хоста, но способный создавать машинный код для другого процессора (в случае FPC такой кросс-компилятор снова можно нацелить на все поддерживаемые платформы, доступные в _target_ CPU). Этот кросс-компилятор обычно сохраняется в том же каталоге, что и собственный компилятор. Такой кросс-компилятор может быть либо скомпилирован вами, либо вы можете использовать готовый распределенный кросс-компилятор, предоставляемый для некоторых платформ непосредственно командой \[разработчиков\] FPC (обычно это платформы, которые в основном используются в портативных устройствах, таких как arm-linux или arm-wince, потому что они обычно не используются в качестве хост-платформ). Затем двоичный файл Fpc может выбрать правильный компилятор (собственный компилятор или кросскомпилятор) для целевого CPU, выбранного с использованием параметра -P.
12	12
13	13		## Ассемблер и компоновщик
14	14
15	15		Компилятор - это только одна часть. Нам также нужен ассемблер и компоновщик. FPC предоставляет внутренний ассемблер и/или компоновщик для некоторых платформ, но для других платформ нужны внешние инструменты. Обычно эти инструменты не могут создавать двоичные файлы для разных платформ. Вот почему мы должны использовать разные специальные компоновщики 'ld' и ассемблер 'as' для каждой целевой платформы. Это \[и есть\] binutils.
16	16
17	17		См. [[Binutils/ru\|Binutils]]
18	18
19	19		## Модули, \[необходимые\] для целевой платформы
20	20
21	21		После создания (или наличия/установки) кросс-инструментов требуется FPC RTL и другие модули, скомпилированные для выбранной целевой платформы. Например, каждая целевая платформа нуждается в другом файле system.ppu (модуль System) и т.д. Эти модули могут быть скомпилированы с использованием вашего компилятора, настроенного для компиляции на целевую платформу, или вы можете использовать официально распространяемые модули, скомпилированные (и распространяемые) с точно такой же версией FPC (если она доступна в формате, доступном для конкретной платформы хоста).
22	22
23	23		## Конфигурация
24	24
25	25		Затем будет настроен ваш конфигурационный файл fpc так, что кросс-компиляция станет настолько простой, что вы сможете забыть все скучные детали. То же самое будет сделано для LCL - библиотеки компонентов lazarus (при использовании Lazarus). И после этого вы можете перекрестно скомпилировать программы паскаля для (другой) целевой платформы. Полученные двоичные файлы затем могут быть скопированы на машину с запущенной целевой платформой или запущены под эмулятором (например, в Wine для Win32 двоичные файлы под Linux и т.д.).
26	26
27	27		## Основные шаги
28	28
29	29		Есть несколько общих шагов, связанных с кросс-компиляцией, которые вы должны делать в каждом случае:
30	30
31	31		- Уже иметь компилятор FreePascal для платформы, из которой вы хотите компилировать.
32	32		- У вас должен быть исходный код FreePascal (за исключением специальных случаев, когда все \[было\] подготовлено кем-то другим).
33	33		- Вам нужно \[будет\] либо собрать из исходного кода, либо получить двоичные файлы cross-binutils (см. [[Binutils/ru\|Binutils]]), которые \[будут\] запускаться на платформе, на которой вы находитесь \[(хост-платформе)\], и \[будут\] предназначены для создания программ для вашей целевой платформы.
34	34		- Иногда вам \[будут\] нужны некоторые файлы из целевой \[платформы\], \[под\] которую вы компилируете.
35	35
36	36		# Из Linux
37	37
38	38		## Из Linux x64 на Linux i386
39	39
40	40		Скорее всего, ваш 64-разрядный дистрибутив Linux уже способен компилировать 32-битные программы, но из-за того, \[что\] процесс сборки fpc \[так\] разработан, есть несколько вещей, которые вам, возможно, придется сделать.
41	41
42	42		- На мультиархитектурном debian/ubuntu вы должны установить пакет libc6-dev-i386
43	43
44	44		- Сначала проверьте, есть ли у вас файлы i386-linux-ld и i386-linux-as:
45	45
46	46		``` bash
47	47		$ which i386-linux-ld
48	48		```
49	49
50	50		``` bash
51	51		$ which i386-linux-as
52	52		```
53	53
54	54		Если у вас есть эти файлы, пропустите заголовок "Compile FPC" \[("Компилировать FPC")\]. Оба \[файла\] могут быть созданы с использованием следующего сценария:
55	55
56	56		``` bash
57	57		#!/bin/bash
58	58
59	59		# Создаем /usr/bin/i386-linux-ld
60	60		cat >/usr/bin/i386-linux-ld << EOF
61	61		#!/bin/bash
62	62		ld -A elf32-i386 \$@
63	63		EOF
64	64		chmod +x /usr/bin/i386-linux-ld
65	65
66	66		# Создаем /usr/bin/i386-linux-as
67	67		cat >/usr/bin/i386-linux-as << EOF
68	68		#!/bin/bash
69	69		as --32 \$@
70	70		EOF
71	71		chmod +x /usr/bin/i386-linux-as
72	72		```
73	73
74	74		- Компилируем FPC:
75	75
76	76		``` bash
77	77		cd /usr/share/fpcsrc/<version>
78	78		sudo make all CPU_TARGET=i386
79	79		```
80	80
81	81		затем:
82	82
83	83		``` bash
84	84		sudo make crossinstall CPU_TARGET=i386
85	85		```
86	86
87	87		Вот и все. Отредактируйте ваш файл /etc/fpc.cfg при необходимости. Обратите внимание, что, по крайней мере, \[начиная с версии fpc\] 3.0.4, выше упомянутая кроссинсталляция помещает файлы в /usr/local/lib/fpc/3.0.4/units/i386-linux и оставшуюся часть системы fpc помещается в /usr/lib/... \[Это\] легко фиксируется символической ссылкой, но гораздо приятнее сделать так:
88	88
89	89		``` bash
90	90		sudo make crossinstall CPU_TARGET=i386 INSTALL_PREFIX=/usr
91	91		```
92	92
93	93		Обратите внимание: если вы видите сообщения о том, что не удалось найти файлы, такие как crtn.o, и о прогнозируемых сбоях линковки, это \[происходит\], вероятно, потому, что ваш дистрибутив Linux любит хранить свои 32-битные библиотеки gcc в /usr/lib32. Проверьте, если недостающие файлы и в самом деле \[находятся\] в /usr/lib32, сделайте небольшое изменение в вашем \[конфигурационном\] файле /etc/fpc.cfg, напр., в строке \#177 есть раздел, который выглядит следующим образом:
94	94
95	95		``` bash
96	96		#ifdef cpui386
97	97		-Fl/usr/lib/gcc/x86_64-linux-gnu/6/32
98	98		#endif
99	99		```
100	100
101	101		Сделайте это так, \[добавьте\] еще одну строку:
102	102
103	103		``` bash
104	104		#ifdef cpui386
105	105		-Fl/usr/lib/gcc/x86_64-linux-gnu/6/32
106	106		-Fl/usr/lib32
107	107		#endif
108	108		```
109	109
110	110		## Из Linux на ARM Linux
111	111
112	112		Сведения о таргетинге на Linux, запущенном на ARM (напр., Zaurus), можно найти в [[Setup Cross Compile For ARM/ru\|Setup Cross Compile For ARM]].
113	113
114	114		## Из Linux на Windows
115	115
116	116		Информацию о кросс-компиляции с Lazarus можно найти в [[Cross compiling for Windows under Linux/ru\|Cross compiling for Windows under Linux]]
117	117
118	118		## Из Linux на Darwin или macOS
119	119
120	120		Пожалуйста, см. [[Cross compiling OSX on Linux]].
121	121
122	122		# Из Windows
123	123
124	124		## Из Windows на Linux
125	125
126	126		Это менее тривиально \[, чем на Linux'е\], есть некоторая информация в [[buildfaq/ru\|buildfaq]]
127	127
128	128		См. также [[fpcup]] для описания работы binutils и того, какие библиотеки/файлы нужно копировать.
129	129
130	130		------------------------------------------------------------------------
131	131
132	132		Прим.перев.: Вместо fpcup я бы настоятельно рекомендовал использовать ее более продвинутый форк [fpcupdeluxe](https://github.com/newpascal/fpcupdeluxe/releases).\
133	133		Русскоязычной аудитории, возможно, будет интересен некоторый мой собственный опыт его использования [тут](http://leybabronstain.ucoz.com/blog/ispolzovanie_krosskompiljacii_v_lazarus/2018-03-03-24). И я не буду возражать, если кто-то, сочтя это за рекламу, удалит ссылку на блог :Р''.
134	134
135	135		------------------------------------------------------------------------
136	136
137	137		Как объясняется в FAQ по сборке, вам понадобятся файлы библиотеки (.so-файлы) из целевой системы, напр., из /lib и /user/lib (но может быть больше мест). В некоторых системах некоторые .so-файлы на самом деле являются скриптами; проверьте \[это командой\]
138	138
139	139		```dos
140	140		grep -i "ld script" *
141	141		```
142	142
143	143		Удалите эти .so-файлы и скопируйте поверх .so.x-файлы (или симлинки), которые вам нужно использовать, чтобы компоновщик их нашел.
144	144
145	145		## Из Windows на GO32v2
146	146
147	147		Подробная информация может быть найдена в [[Cross-compilation from Win32 to GO32v2]].
148	148
149	149		## Из Windows на wince
150	150
151	151		[[arm-wince]] описывает, как настроить кросс-компилятор для arm CPU\
152	152		[[i386-wince]] описывает, как настроить компиляцию для i386 CPU (без кросскомпиляции)\
153	153
154	154		> Note: У инсталлятора Lazarus есть установщик, который автоматически добавляет Windows к настройкам кросскомпиляции Wince
155	155
156	156		## Из win32 на win64
157	157
158	158		Если вы компилируете ветку fpc 2.1.1 или старше, вы можете просто сделать:
159	159
160	160		``` bash
161	161		$ make all OS_TARGET=win64 CPU_TARGET=x86_64
162	162		```
163	163
164	164		и затем
165	165
166	166		``` bash
167	167		$ make crossinstall OS_TARGET=win64 CPU_TARGET=x86_64
168	168		```
169	169
170	170		## Из win64 на win32
171	171
172	172		Установите lazarus-1.6.0-fpc-3.0.0-cross-i386-win32-win64.exe, затем настройте параметры проекта \[таким образом\], чтобы \[стало\]:
173	173
174	174		- Target OS : Win32
175	175		- Target CPU : i386
176	176
177	177		Неправильная установка CPU (по умолчанию) приведет к неправильной платформе win32-x86_64!
178	178
179	179		# Из Darwin (macOS)
180	180
181	181		## Из Darwin i386 на powerpc
182	182
183	183		Официальный установщик FPC для macOS/i386 включает в себя кросс-компилятор PowerPC и все модули, необходимые для компиляции программ PowerPC (используйте "ppcppc" вместо "ppc386" для компиляции ваших программ). Приведенные ниже инструкции необходимы только в том случае, если вы хотите скомпилировать и установить новую версию из svn.
184	184
185	185		- Компилируем FPC:
186	186
187	187		``` bash
188	188		$ cd fpc
189	189		$ make all CPU_TARGET=powerpc -j 2
190	190		```
191	191
192	192		Это создаст компилятор powerpc cross-compiler (fpc/compiler/ppcrosspcc) и все модули. Вы можете установить их, используя следующие команды:
193	193
194	194		``` bash
195	195		$ sudo make FPC=`pwd`/compiler/ppc386 install CPU_TARGET=powerpc CROSSINSTALL=1
196	196		$ INSTALLED_VERSION=`./compiler/ppc386 -iV`
197	197		$ sudo mv /usr/local/lib/fpc/$INSTALLED_VERSION/ppcrossppc /usr/local/lib/fpc/$INSTALLED_VERSION/ppcppc
198	198		```
199	199
200	200		Памятка: универсальные двоичные файлы создаются из отдельных (i386 и powerpc) двоичных файлов с использованием \[команды\] lipo.
201	201
202	202		## Из Darwin i386 на x86_64
203	203
204	204		Официальный установщик FPC для macOS/i386 включает компилятор x86_64 и все модули, необходимые для компиляции программ x86_64 (используйте ppcx64 вместо ppc386 для компиляции ваших программ или использования fpc -Px86_64). Приведенные ниже инструкции необходимы только в том случае, если вы хотите скомпилировать и установить новую версию из svn.
205	205
206	206		- Компилируем FPC:
207	207
208	208		``` bash
209	209		$ cd fpc
210	210		$ make all CPU_TARGET=x86_64
211	211		```
212	212
213	213		Этот \[код\] создает кросс-компилятор x86_64 (fpc/compiler/ppcrossx64) и все модули. Вы можете установить их, используя следующие команды:
214	214
215	215		``` bash
216	216		$ sudo make crossinstall CPU_TARGET=x86_64
217	217		$ sudo mv /usr/local/lib/fpc/2.7.1/ppcrossx64 /usr/local/lib/fpc/2.7.1/ppcx64
218	218		```
219	219
220	220		Если вы хотите сделать этот недавно установленный компилятор версией по умолчанию (это *не* рекомендуется, т.к. это нарушит вашу способность создавать новые версии FPC 2.7.1 без явного указания пути к последнему официальному FPC), также выполните следующую команду:
221	221
222	222		``` bash
223	223		$ sudo ln -sf /usr/local/lib/fpc/2.7.1/ppcx64 /usr/local/bin/ppcx64
224	224		```
225	225
226	226		Предполагая, что все компоненты LCL, используемые вашим проектом, поддерживаются с помощью [Cocoa widgetset](http://wiki.lazarus.freepascal.org/Roadmap#Status_of_features_on_each_LCL_Interface), вы можете скомпилировать проект Lazarus из командной строки, используя такую команду (возможно необходим полный путь к компилятору):
227	227
228	228		``` bash
229	229		$ lazbuild -B project1.lpr --ws=cocoa --cpu=x86_64 --os=darwin --compiler=/usr/local/bin/ppcx64
230	230		```
231	231
232	232		Вы можете проверить, что ваш исполняемый файл является 64-битным, использует команду "file":
233	233
234	234		``` bash
235	235		$ file ./project1
236	236		$ ./project1: Mach-O 64-bit executable x86_64
237	237		```
238	238
239	239		Кроме того, вы можете настроить свой проект на компиляцию как 64-бит с помощью графического интерфейса Lazarus:
240	240
241		-	~~`a.) Выберите пункт меню Project/ProjectOptions`\~~
242		-	~~`b.) В [пункте] CompilerOptions/ConfigAndTarget установите "Target CPU family" в "x86_64"`\~~
243		-	~~`c.) В [пункте] CompilerOptions/AdditionsAndOverrides сохраните "LCLWidgetType := cocoa" в LPI`~~
	241	+	``` pascal
	242	+	a.) Выберите пункт меню Project/ProjectOptions
	243	+	b.) В [пункте] CompilerOptions/ConfigAndTarget установите "Target CPU family" в "x86_64"
	244	+	c.) В [пункте] CompilerOptions/AdditionsAndOverrides сохраните "LCLWidgetType := cocoa" в LPI
	245	+	```
244	246
245	247		Обратите внимание, что 64-разрядный компьютер macOS может работать с 32-разрядными исполняемыми файлами. Однако, если вы хотите создать бинарник, который выполняется на 32-разрядном Intel также хорошо, как и в 64-битном режиме на 64-битном компьютере Intel, вы можете использовать команду "lipo". Это позволило бы 64-разрядному компьютеру получить доступ к большему количеству памяти и теоретически возможно немного улучшиться (например, различные оптимизации компилятора, больше регистров, но с большими указателями). Предполагается, что вы создали отдельные 32-разрядные ("project32") и 64-разрядные ("project64") исполняемые файлы на Lazarus.
246	248
247	249		``` bash
248	250		$ lipo -create project32 project64 -o projectUniversal
249	251		```
250	252
251	253		## Из Darwin x86_64 на i386
252	254
253	255		Как и выше, \[только вместо\] CPU_TARGET используйте CPU_SOURCE .
254	256
255	257		## Из Darwin на Windows, Linux и другие \[OC\]
256	258
257	259		В пакете fpc менеджера пакетов [fink](http://finkproject.org/) имеется 64-разрядный компилятор. Кроме того, \[там\] есть список пакетов для кросскомпиляции на windows, linux, freebsd на разных процессорах.
258	260
259	261		Примеры установки кросскомпилятора:
260	262
261	263		``` bash
262	264		$ fink install fpc-cross-i386-win32
263	265		```
264	266
265	267		или
266	268
267	269		``` bash
268	270		$ fink install fpc-cross-arm-linux
269	271		```
270	272
271	273		Для компиляции используйте эти команды:
272	274
273	275		``` bash
274	276		fpc -Pi386 -Twin32 FILENAME
275	277		fpc -Parm -Tlinux FILENAME
276	278		```
277	279
278	280		Эта команда дает список кросскомпиляторов:
279	281
280	282		``` bash
281	283		$ fink list fpc-cross
282	284		```
283	285
284	286		Текущий (fpc 3.0.4) выдает \[следующий список\]:
285	287
286	288		``` bash
287	289		fpc-cross-arm-gba
288	290		fpc-cross-arm-linux
289	291		fpc-cross-arm-nds
290	292		fpc-cross-arm-wince
291	293		fpc-cross-arm-armv4t-embedded
292	294		fpc-cross-arm-armv7m-embedded
293	295		fpc-cross-i386-darwin
294	296		fpc-cross-i386-freebsd
295	297		fpc-cross-i386-go32v2
296	298		fpc-cross-i386-linux
297	299		fpc-cross-i386-nativent
298	300		fpc-cross-i386-netbsd
299	301		fpc-cross-i386-solaris
300	302		fpc-cross-i386-win32
301	303		fpc-cross-i386-wince
302	304		fpc-cross-jvm-android
303	305		fpc-cross-jvm-java
304	306		fpc-cross-m68k-linux
305	307		fpc-cross-mipsel-linux
306	308		fpc-cross-powerpc-linux
307	309		fpc-cross-sparc-linux
308	310		fpc-cross-x86-64-dragonfly
309	311		fpc-cross-x86-64-freebsd
310	312		fpc-cross-x86-64-linux
311	313		fpc-cross-x86-64-win64
312	314		```
313	315
314	316		Для других платформ (процессоров и систем) вы должны самостоятельно выполнить настройку. Это в основном та же схема: во-первых, вам нужны соответствующие binutils (см. [[Binutils/ru\|Binutils]]), а во-вторых, кросскомпилятор и библиотека времени выполнения. Более подробную информацию о процедуре сборки можно узнать из файлов описания пакетов кросскомпилятора [fink](http://finkproject.org/) выше.
315	317
316	318		# Из FreeBSD
317	319
318	320		## Из FreeBSD на SPARC
319	321
320	322		> Warning: Этот раздел, существует примерно с 2005 года и, вероятно, может быть неактуальным. Обновления приветствуются.
321	323
322	324		Я управился с компилятором из x86 на Sparc Solaris 9. Однако результат \[оказался\] не совсем удовлетворительный, и вот моя строка cmd:
323	325
324	326		в компиляторе/ выполняется:
325	327
326	328		``` bash
327	329		gmake cycle CPU_TARGET=sparc OS_TARGET=solaris CROSSBINUTILPREFIX=solaris-sparc- CROSSOPT='-Xd -Fl~/src/sollib'
328	330		```
329	331
330	332		~/src/sollib это каталог, содержащий:
331	333
332	334		- набор .o's из /usr/local/gcc-3.3-32bit/lib/gcc-lib/sparc-sun-solaris/3.3
333	335		- libgcc.a из /usr/local/gcc-3.3-32bit/lib/gcc-lib/sparc-sun-solaris/3.3
334	336		- набор библиотек *.so из /usr/lib: libaio.so libmd5.so libc.so libelf.so librt.so libdl.so libm.so
335	337
336	338		Проблема иллюстрируется следующим двоичным кодом.
337	339
338		-	~~` Free Pascal Compiler version 2.1.1 [2006/03/17] for sparc`\~~
339		-	~~` Copyright (c) 1993-2005 by Florian Klaempfl`\~~
340		-	~~` Target OS: Solaris for SPARC`\~~
341		-	~~` Compiling system.pp`\~~
342		-	~~` system.pp(15,1) Fatal: Syntax error, "BEGIN" expected but "identifier UNIT" found`~~
	340	+	``` pascal
	341	+	Free Pascal Compiler version 2.1.1 [2006/03/17] for sparc
	342	+	Copyright (c) 1993-2005 by Florian Klaempfl
	343	+	Target OS: Solaris for SPARC
	344	+	Compiling system.pp
	345	+	system.pp(15,1) Fatal: Syntax error, "BEGIN" expected but "identifier UNIT" found
	346	+	```
343	347
344	348		I suspect wrong .o's are taken. Я подозреваю, что взяты неправильные .o-файлы.
345	349
346	350		# Из контейнера Docker
347	351
348	352		Кросскомпиляция "hello world" с \[использованием\] образа Docker и Free Pascal Compiler 3.0.4
349	353
350	354		1\. извлекаем образ docker:
351	355
352	356		``` bash
353	357		sudo docker pull taraworks/lazarus-cross:0.0.2 #(do not use latest)
354	358		```
355	359
356	360		2\. создаем контейнер с виртуальным томом на основе извлеченного образа:
357	361
358	362		a\. идентифицируем ID образа (необходимы первые 4 цифры):
359	363
360	364		``` bash
361	365		sudo docker images
362	366		```
363	367
364	368		b\. используем образ для контейнера, маппируем виртуальный том из хоста:
365	369
366	370		``` bash
367	371		sudo docker create --name pascalContainer -v /home/tudi/pascal_files:/home/tudi/pascal_files -ti image ID
368	372		```
369	373
370	374		3\. запускаем контейнер
371	375
372	376		a\. идентифицируем ID контейнера (необходимы первые 4 цифры):
373	377
374	378		``` bash
375	379		sudo docker ps -a
376	380		```
377	381
378	382		b\. запускаем контейнер:
379	383
380	384		``` bash
381	385		sudo docker start container ID
382	386		```
383	387
384	388		4\. компилируем файл
385	389
386	390		a\. копируем паскаль-файл hello.pas из <https://github.com/taraworks/lazarus-cross> в папку /home/tudi/pascal_files на хосте:
387	391
388	392		запускаем на хосте:
389	393
390	394		``` bash
391	395		cd /home/tudi/pascal_files
392	396
393	397		git clone https://github.com/taraworks/lazarus-cross.git
394	398		```
395	399
396	400		b\. прикрепляем к контейнеру для проверки клонированного репо:
397	401
398	402		запускаем на хосте:
399	403
400	404		``` bash
401	405		sudo docker attach container ID
402	406		```
403	407
404	408		press enter one more time and check hello.pas is in container folder. do not detach with exit from container as container will stop. нажимаем "enter" еще раз и проверяем, что hello.pas находится в папке с контейнером. не отсоединяйте с выходом из контейнера, пока контейнер остановится.
405	409
406	410		c\. компилируем из контейнер; меняем каталог до папки, содержащей hello.pas:
407	411
408	412		для Windows:
409	413
410	414		``` bash
411	415		PATH=$PATH:/opt/clang/bin:/opt/osxcross/target/bin /opt/windows/lib/fpc/3.0.4/ppcross386 -Twin32 -va hello.pas
412	416		```
413	417
414	418		для OSX:
415	419
416	420		``` bash
417	421		PATH=$PATH:/opt/clang/bin:/opt/osxcross/target/bin /opt/darwin/lib/fpc/3.0.4/ppcross386 -Tdarwin -XR/opt/osxcross/target/SDK/MacOSX10.11.sdk -va hello.pas
418	422		```
419	423
420	424		d\. компилируем из хоста
421	425
422	426		``` bash
423	427		sudo docker exec pascalContainer bash -c "cd ${CI_PROJECT_DIR} && PATH=$PATH:/opt/clang/bin:/opt/osxcross/target/bin /opt/windows/lib/fpc/3.0.4/ppcross386 -Twin32 -va /home/tudi/pascal_files/lazarus-cross/hello.pas"
424	428		```
425	429
426	430		# Общие примечания к Unix/Linux
427	431
428	432		Опция -XLA используется для переименования зависимостей библиотек, указанных в модулях паскаля. Формат -XLAold=new, чтобы изменить параметр ld link -l\<old\> на -l\<new\>.
429	433
430	434		Опция -XR\<sysroot\> (недавний trunk) может использоваться для указания системного root целевой \[платформы\]. Он используется для:
431	435
432	436		- добавления префикса к путям добавленной библиотеки по умолчанию; в прошлом вы указывали -Xd и эти пути вручную. Напр., для i386-linux вместо передачи /lib, /usr/lib и /usr/X11R6/lib в ld, он будет передан \<sysroot\>/lib, \<sysroot\>/usr/lib и \<sysroot\>/usr/X11R6/lib в ld.
433	437		- обнаружения библиотеки C (специфической для Linux): glibc или uclibc. Напр., для попытки обнаружения uclibc '\<sysroot\>/lib/ld-uClibc.so.0'.
434	438
435	439		# Кросскомпиляция LCL
436	440
437	441		Начиная с \[версии\] 0.9.31, LCL является обычным пакетом Lazarus, и среда IDE автоматически \[сделает\] кросскомпиляцию всех необходимых пакетов при изменении целевой платформы вашего проекта.
438	442
439	443		Если что-то пойдет не так, то вот несколько советов, которые могли бы помочь выяснить, в чем причина:
440	444
441	445		## Тест кросскомпилятора
442	446
443	447		Проверьте, правильно ли установлен кросскомпилированный fpc:
444	448
445	449		Создайте программу \[в духе\] "hello world" в test.pas:
446	450
447	451		``` pascal
448	452		program test;
449	453		begin
450	454		writeln('DATE ',{$i %DATE%});
451	455		writeln('FPCTARGET ',{$i %FPCTARGET%});
452	456		writeln('FPCTARGETCPU ',{$i %FPCTARGETCPU%});
453	457		writeln('FPCTARGETOS ',{$i %FPCTARGETOS%});
454	458		writeln('FPCVERSION ',{$i %FPCVERSION%});
455	459		end.
456	460		```
457	461
458	462		И скомпилируйте его с исходной/оригинальной платформой. Пример для x86 Windows:
459	463
460	464		``` bash
461	465		fpc -Twin32 -Pi386 test.pas
462	466		```
463	467
464	468		Затем проверьте исходный компилятор:
465	469
466	470		``` bash
467	471		test
468	472		```
469	473
470	474		Замените win32 и i386 своими целями \[(имеется ввиду, "своими" ОС и CPU)\]. Пример для целевой Windows 64 бит:
471	475
472	476		``` bash
473	477		fpc -Twin64 -Px86_64 test.pas
474	478		```
475	479
476	480		Затем проверьте кросскомпилятор:
477	481
478	482		``` bash
479	483		test
480	484		```
481	485
482	486		Программа fpc представляет собой оболочку, которая ищет правильный компилятор (напр., ppcrossx64) для цели и выполняет его.
483	487
484	488		If this does not work, your cross compiler was not installed correctly. When this works you can cross compile the LCL. Если это не сработает, ваш кросскомпилятор был установлен неправильно. Когда это работает, вы можете \[выполнять\] кросскомпиляцию \[посредством\] LCL.
485	489
486	490		## Кросскомпиляция LCL в Lazarus 0.9.30 и ниже
487	491
488	492		Если вы уверены, что ваш кросскомпилятор работает, вы можете выполнить настоящую кросскомпиляцию.
489	493
490	494		Выполните следующие шаги в IDE Lazarus, чтобы выполнить кросскомпиляцию LCL:
491	495
492	496		В более старых IDE:
493	497
494	498		- Определите в Tools -\> Options -\> Environment -\> Files \[ в строке\] Compiler path путь к fpc. Обычно это уже сделано.
495	499		- Затем откройте Tools -\> Configure Build Lazarus.
496	500		- Установите Target OS (напр., в Win64) и Target CPU (напр., в x86_64)
497	501		- Нажмите кнопку Build.
498	502
499	503		### Командная строка
500	504
501	505		Помимо IDE, командная строка также позволяет создавать кросскомпилер LCL.
502	506
503	507		> Note: Начиная с \[версии Lazarus\] 0.9.31, вы должны использовать утилиту `lazbuild` для кросскомпиляции пакетов Lazarus. См. `Lazbuild -h` для \[получения\] списка опций.
504	508
505	509		Пример: вы желаете скомпилировать Windows 64, используя кросскомпилятор: сначала тщательно очистите 64-битные остатки \[пакетов\]. Это не касается вашей 32-битной среды:
506	510
507	511		``` bash
508	512		make distclean LCL_PLATFORM=win32 CPU_TARGET=x86_64 OS_TARGET=win64
509	513		```
510	514
511	515		Затем соберите LCL и необходимые ей зависимости. Нами используется LCL_PLATFORM, поскольку он, по-видимому, по-прежнему является Windows 32 даже в Windows 64 (виджеты одинаковы).
512	516
513	517		``` bash
514	518		make packager/registration lazutils lcl LCL_PLATFORM=win32 CPU_TARGET=x86_64 OS_TARGET=win64
515	519		```
516	520
517	521		Как и в предыдущем разделе, LCL для вашей нормальной ОС не затрагивается.
518	522
519	523		# Кросскомпиляция приложений LCL
520	524
521	525		Сначала вам нужно скомпилировать LCL. См. выше.
522	526
523	527		Кросскомпиляция приложений означает: компиляция + связывание. Когда вы \[сделали\] кросскомпиляцию LCL, компиляционная часть \[остального\] проста. Просто установите в параметрах компилятора IDE целевую ОС и целевой CPU. Трудная часть - это связывание. Если вы \[сделаете\] кросскомпиляцию проекта, вы можете увидеть что-то вроде этого:
524	528
525		-	~~`/usr/local/bin/arm-linux-ld: cannot find -lX11`~~
	529	+	```text
	530	+	/usr/local/bin/arm-linux-ld: cannot find -lX11
	531	+	```
526	532
527	533		Это означает, что вам необходимо установить графические библиотеки целевой системы. Это не имеет ничего общего с FPC/Lazarus, но \[связано\] с библиотеками кросскомпиляции. Некоторые дистрибутивы предоставляют для этого предварительно скомпилированные пакеты. Например, Microsoft предоставляет кросскомпилированные библиотеки WinCE для Windows. В Linux вы можете установить Wine для кросскомпиляции из Linux на Windows. Некоторые дистрибутивы Linux предоставляют 64-битные библиотеки для 32-битных систем.
528	534
529	535		# FAQ по кросскомпиляции
530	536
531	537		## Почему кросскомпиляция?
532	538
533	539		Так вы можете разработать программу для одной ОС/CPU и скомпилировать ее для другой ОС/CPU без перезагрузки или переключения компьютеров.
534	540
535	541		## Почему без кросскомпиляции?
536	542
537	543		Во многих случаях вы хотите протестировать полученную программу на собственной платформе. Компиляция приложения на этой платформе может быть проще в настройке.
538	544
539	545		## Почему \[предпочтительнее\] кросскомпиляция из Unix на Windows, а не наоборот?
540	546
541	547		См. [[Cross compiling for Windows under Linux/ru\|Cross compiling for Win32 under Linux]]
542	548
543	549		## Я хочу получить дополнительную информацию о сборках на Freepascal. Где это?
544	550
545	551		Существует общий FAQ в формате pdf о том, как создавать и настраивать FPC: [[buildfaq]]
546	552
547	553		## Ошибки, такие как компилятор "/usr/bin/fpc", не поддерживает целевой arm-linux
548	554
549	555		Помимо других причин, эта ошибка может возникнуть, если вы отредактировали fpc.cfg с неправильными параметрами для кросскомпилятора (напр., указав все параметры в одну строку вместо одной через строку).
550	556
551	557		# См. также
552	558
553	559		- [crossnotes](http://www.stack.nl/~marcov/crossnotes.txt) Заметки о кросскомпиляции
554	560		- [[Cross compiling for Windows under Linux]]
555	561		- [GetLazarus - Сделай сам](http://web.archive.org/web/20160927181920/http://www.getlazarus.org/setup/making/) (Сохраненная копия от 27.09.2016)
556	562
557	563		---
558	564		From the Free Pascal wiki, page "Cross compiling/ru", as it stood on 2021-07-20 after a change by Dbannon, 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