Cross compiling/ru

From Free Pascal wiki
Jump to navigationJump to search

│ Deutsch (de) │ English (en) │ español (es) │ français (fr) │ magyar (hu) │ português (pt) │ русский (ru) │ 中文（中国大陆） (zh_CN) │ 中文（臺灣） (zh_TW) │


Предисловие

Это краткое введение для новичков. В следующих разделах описывается, как настроить систему для кросскомпиляции, что означает создание двоичных файлов (исполняемых файлов) для платформы, отличной от той, которая используется для компиляции, напр., работающих под Linux и создающих исполняемые файлы Win32 (или для FreeBSD или Darwin и т.д.). В этом случае платформу, используемую для компиляции, обычно называют "хостом" [(host)] (Linux в приведенном выше примере), а платформа, в которой вы хотите запускать созданные двоичные файлы, является вашей "целью" [(target)]. FreePascal является компилятором и в основном преобразует исходный код в двоичные файлы (машинный язык). Эти двоичные файлы также содержат информацию о том, как операционная система запускает исполняемые файлы. Более того, двоичные файлы относятся к API-интерфейсам, предоставляемым конкретной операционной системой, поэтому для разных операционных систем необходима другая реализация нашей библиотеки времени выполнения. Следовательно, эти двоичные файлы являются специфичными для платформы. Сам FreePascal не нуждается в большой настройке. Он может создавать двоичные файлы для многих платформ. Таким образом, просто прикажите [компилятору] сделать это.

Хост и цель на одном процессоре

FPC разработан таким образом, что распределенный компилятор может создавать машинный код для определенного процессора [(CPU)] (поскольку разные процессоры нуждаются в разном компьютерном коде), и он знает конкретные требования для всех поддерживаемых платформ (операционных систем), доступных на этом конкретном процессоре. Это означает, что вы можете выполнять кросс-компиляцию с тем же компилятором, который используется для встроенной компиляции, если вы придерживаетесь одного и того же CPU.

Хост и цель на разных процессорах

Если необходимо создать двоичные файлы для другого процессора, вам нужен специальный кросскомпилятор, то есть компилятор, работающий на платформе хоста, но способный создавать машинный код для другого процессора (в случае FPC такой кросс-компилятор снова можно нацелить на все поддерживаемые платформы, доступные в _target_ CPU). Этот кросс-компилятор обычно сохраняется в том же каталоге, что и собственный компилятор. Такой кросс-компилятор может быть либо скомпилирован вами, либо вы можете использовать готовый распределенный кросс-компилятор, предоставляемый для некоторых платформ непосредственно командой [разработчиков] FPC (обычно это платформы, которые в основном используются в портативных устройствах, таких как arm-linux или arm-wince, потому что они обычно не используются в качестве хост-платформ). Затем двоичный файл Fpc может выбрать правильный компилятор (собственный компилятор или кросскомпилятор) для целевого CPU, выбранного с использованием параметра -P.

Ассемблер и компоновщик

Компилятор - это только одна часть. Нам также нужен ассемблер и компоновщик. FPC предоставляет внутренний ассемблер и/или компоновщик для некоторых платформ, но для других платформ нужны внешние инструменты. Обычно эти инструменты не могут создавать двоичные файлы для разных платформ. Вот почему мы должны использовать разные специальные компоновщики 'ld' и ассемблер 'as' для каждой целевой платформы. Это [и есть] binutils.

См. Binutils

Модули, [необходимые] для целевой платформы

После создания (или наличия/установки) кросс-инструментов требуется FPC RTL и другие модули, скомпилированные для выбранной целевой платформы. Например, каждая целевая платформа нуждается в другом файле system.ppu (модуль System) и т.д. Эти модули могут быть скомпилированы с использованием вашего компилятора, настроенного для компиляции на целевую платформу, или вы можете использовать официально распространяемые модули, скомпилированные (и распространяемые) с точно такой же версией FPC (если она доступна в формате, доступном для конкретной платформы хоста).

Конфигурация

Затем будет настроен ваш конфигурационный файл fpc так, что кросс-компиляция станет настолько простой, что вы сможете забыть все скучные детали. То же самое будет сделано для LCL - библиотеки компонентов lazarus (при использовании Lazarus). И после этого вы можете перекрестно скомпилировать программы паскаля для (другой) целевой платформы. Полученные двоичные файлы затем могут быть скопированы на машину с запущенной целевой платформой или запущены под эмулятором (например, в Wine для Win32 двоичные файлы под Linux и т.д.).

Основные шаги

Есть несколько общих шагов, связанных с кросс-компиляцией, которые вы должны делать в каждом случае:

  • Уже иметь компилятор FreePascal для платформы, из которой вы хотите компилировать.
  • У вас должен быть исходный код FreePascal (за исключением специальных случаев, когда все [было] подготовлено кем-то другим).
  • Вам нужно [будет] либо собрать из исходного кода, либо получить двоичные файлы cross-binutils (см. Binutils), которые [будут] запускаться на платформе, на которой вы находитесь [(хост-платформе)], и [будут] предназначены для создания программ для вашей целевой платформы.
  • Иногда вам [будут] нужны некоторые файлы из целевой [платформы], [под] которую вы компилируете.

Из Linux

Из Linux x64 на Linux i386

Скорее всего, ваш 64-разрядный дистрибутив Linux уже способен компилировать 32-битные программы, но из-за того, [что] процесс сборки fpc [так] разработан, есть несколько вещей, которые вам, возможно, придется сделать.

  • На мультиархитектурном debian/ubuntu вы должны установить пакет libc6-dev-i386
  • Сначала проверьте, есть ли у вас файлы i386-linux-ld и i386-linux-as:
$ which i386-linux-ld

$ which i386-linux-as

Если у вас есть эти файлы, пропустите заголовок "Compile FPC" [("Компилировать FPC")]. Оба [файла] могут быть созданы с использованием следующего сценария: 

#!/bin/bash

# Создаем /usr/bin/i386-linux-ld
cat >/usr/bin/i386-linux-ld << EOF
#!/bin/bash
ld -A elf32-i386 \$@
EOF
chmod +x /usr/bin/i386-linux-ld

# Создаем /usr/bin/i386-linux-as
cat >/usr/bin/i386-linux-as << EOF
#!/bin/bash
as --32 \$@
EOF
chmod +x /usr/bin/i386-linux-as
  • Компилируем FPC:
cd /usr/share/fpcsrc/<version>
sudo make all CPU_TARGET=i386

затем: 

sudo make crossinstall CPU_TARGET=i386

Вот и все. Отредактируйте ваш файл /etc/fpc.cfg при необходимости. Обратите внимание, что, по крайней мере, [начиная с версии fpc] 3.0.4, выше упомянутая кроссинсталляция помещает файлы в /usr/local/lib/fpc/3.0.4/units/i386-linux и оставшуюся часть системы fpc помещается в /usr/lib/... [Это] легко фиксируется символической ссылкой, но гораздо приятнее сделать так: 

sudo make crossinstall CPU_TARGET=i386 INSTALL_PREFIX=/usr

Обратите внимание: если вы видите сообщения о том, что не удалось найти файлы, такие как crtn.o, и о прогнозируемых сбоях линковки, это [происходит], вероятно, потому, что ваш дистрибутив Linux любит хранить свои 32-битные библиотеки gcc в /usr/lib32. Проверьте, если недостающие файлы и в самом деле [находятся] в /usr/lib32, сделайте небольшое изменение в вашем [конфигурационном] файле /etc/fpc.cfg, напр., в строке #177 есть раздел, который выглядит следующим образом: 

#ifdef cpui386
-Fl/usr/lib/gcc/x86_64-linux-gnu/6/32
#endif

Сделайте это так, [добавьте] еще одну строку: 

#ifdef cpui386
-Fl/usr/lib/gcc/x86_64-linux-gnu/6/32
-Fl/usr/lib32
#endif

Из Linux на ARM Linux

Сведения о таргетинге на Linux, запущенном на ARM (напр., Zaurus), можно найти в Setup Cross Compile For ARM.

Из Linux на Windows

Информацию о кросс-компиляции с Lazarus можно найти в Cross compiling for Windows under Linux

Из Linux на Darwin или macOS

Пожалуйста, см. Cross compiling OSX on Linux.

Из Windows

Из Windows на Linux

Это менее тривиально [, чем на Linux'е], есть некоторая информация в buildfaq

См. также fpcup для описания работы binutils и того, какие библиотеки/файлы нужно копировать.

Прим.перев.: Вместо fpcup я бы настоятельно рекомендовал использовать ее более продвинутый форк fpcupdeluxe.
Русскоязычной аудитории, возможно, будет интересен некоторый мой собственный опыт его использования тут. И я не буду возражать, если кто-то, сочтя это за рекламу, удалит ссылку на блог :Р.

Как объясняется в FAQ по сборке, вам понадобятся файлы библиотеки (.so-файлы) из целевой системы, напр., из /lib и /user/lib (но может быть больше мест). В некоторых системах некоторые .so-файлы на самом деле являются скриптами; проверьте [это командой] 

grep -i "ld script" *

Удалите эти .so-файлы и скопируйте поверх .so.x-файлы (или симлинки), которые вам нужно использовать, чтобы компоновщик их нашел.

Из Windows на GO32v2

Подробная информация может быть найдена в Cross-compilation from Win32 to GO32v2.

Из Windows на wince

arm-wince описывает, как настроить кросс-компилятор для arm CPU
i386-wince описывает, как настроить компиляцию для i386 CPU (без кросскомпиляции)

Light bulb  Примечание: У инсталлятора Lazarus есть установщик, который автоматически добавляет Windows к настройкам кросскомпиляции Wince

Из win32 на win64

Если вы компилируете ветку fpc 2.1.1 или старше, вы можете просто сделать: 

$ make all OS_TARGET=win64 CPU_TARGET=x86_64

и затем 

$ make crossinstall OS_TARGET=win64 CPU_TARGET=x86_64

Из win64 на win32

Установите lazarus-1.6.0-fpc-3.0.0-cross-i386-win32-win64.exe, затем настройте параметры проекта [таким образом], чтобы [стало]:

  • Target OS : Win32
  • Target CPU : i386

Неправильная установка CPU (по умолчанию) приведет к неправильной платформе win32-x86_64!

Из Darwin (macOS)

Из Darwin i386 на powerpc

Официальный установщик FPC для macOS/i386 включает в себя кросс-компилятор PowerPC и все модули, необходимые для компиляции программ PowerPC (используйте "ppcppc" вместо "ppc386" для компиляции ваших программ). Приведенные ниже инструкции необходимы только в том случае, если вы хотите скомпилировать и установить новую версию из svn.

  • Компилируем FPC:
$ cd fpc
$ make all CPU_TARGET=powerpc -j 2

Это создаст компилятор powerpc cross-compiler (fpc/compiler/ppcrosspcc) и все модули. Вы можете установить их, используя следующие команды: 

$ sudo make FPC=`pwd`/compiler/ppc386 install CPU_TARGET=powerpc CROSSINSTALL=1
$ INSTALLED_VERSION=`./compiler/ppc386 -iV`
$ sudo mv /usr/local/lib/fpc/$INSTALLED_VERSION/ppcrossppc /usr/local/lib/fpc/$INSTALLED_VERSION/ppcppc

Памятка: универсальные двоичные файлы создаются из отдельных (i386 и powerpc) двоичных файлов с использованием [команды] lipo.

Из Darwin i386 на x86_64

Официальный установщик FPC для macOS/i386 включает компилятор x86_64 и все модули, необходимые для компиляции программ x86_64 (используйте ppcx64 вместо ppc386 для компиляции ваших программ или использования fpc -Px86_64). Приведенные ниже инструкции необходимы только в том случае, если вы хотите скомпилировать и установить новую версию из svn.

  • Компилируем FPC:
$ cd fpc
$ make all CPU_TARGET=x86_64

Этот [код] создает кросс-компилятор x86_64 (fpc/compiler/ppcrossx64) и все модули. Вы можете установить их, используя следующие команды: 

$ sudo make crossinstall CPU_TARGET=x86_64
$ sudo mv /usr/local/lib/fpc/2.7.1/ppcrossx64 /usr/local/lib/fpc/2.7.1/ppcx64

Если вы хотите сделать этот недавно установленный компилятор версией по умолчанию (это не рекомендуется, т.к. это нарушит вашу способность создавать новые версии FPC 2.7.1 без явного указания пути к последнему официальному FPC), также выполните следующую команду: 

$ sudo ln -sf /usr/local/lib/fpc/2.7.1/ppcx64 /usr/local/bin/ppcx64

Предполагая, что все компоненты LCL, используемые вашим проектом, поддерживаются с помощью Cocoa widgetset, вы можете скомпилировать проект Lazarus из командной строки, используя такую команду (возможно необходим полный путь к компилятору): 

$ lazbuild -B project1.lpr --ws=cocoa --cpu=x86_64 --os=darwin --compiler=/usr/local/bin/ppcx64

Вы можете проверить, что ваш исполняемый файл является 64-битным, использует команду "file": 

$ file ./project1
$ ./project1: Mach-O 64-bit executable x86_64

Кроме того, вы можете настроить свой проект на компиляцию как 64-бит с помощью графического интерфейса Lazarus: 

a.) Выберите пункт меню Project/ProjectOptions
b.) В [пункте] CompilerOptions/ConfigAndTarget установите "Target CPU family" в "x86_64"
c.) В [пункте] CompilerOptions/AdditionsAndOverrides сохраните "LCLWidgetType := cocoa" в LPI

Обратите внимание, что 64-разрядный компьютер macOS может работать с 32-разрядными исполняемыми файлами. Однако, если вы хотите создать бинарник, который выполняется на 32-разрядном Intel также хорошо, как и в 64-битном режиме на 64-битном компьютере Intel, вы можете использовать команду "lipo". Это позволило бы 64-разрядному компьютеру получить доступ к большему количеству памяти и теоретически возможно немного улучшиться (например, различные оптимизации компилятора, больше регистров, но с большими указателями). Предполагается, что вы создали отдельные 32-разрядные ("project32") и 64-разрядные ("project64") исполняемые файлы на Lazarus. 

$ lipo -create project32 project64 -o projectUniversal

Из Darwin x86_64 на i386

Как и выше, [только вместо] CPU_TARGET используйте CPU_SOURCE .

Из Darwin на Windows, Linux и другие [OC]

В пакете fpc менеджера пакетов fink имеется 64-разрядный компилятор. Кроме того, [там] есть список пакетов для кросскомпиляции на windows, linux, freebsd на разных процессорах.

Примеры установки кросскомпилятора: 

$ fink install fpc-cross-i386-win32

или 

$ fink install fpc-cross-arm-linux

Для компиляции используйте эти команды: 

fpc -Pi386 -Twin32 FILENAME
fpc -Parm -Tlinux FILENAME

Эта команда дает список кросскомпиляторов: 

$ fink list fpc-cross

Текущий (fpc 3.0.4) выдает [следующий список]: 

fpc-cross-arm-gba
fpc-cross-arm-linux
fpc-cross-arm-nds
fpc-cross-arm-wince
fpc-cross-arm-armv4t-embedded
fpc-cross-arm-armv7m-embedded
fpc-cross-i386-darwin
fpc-cross-i386-freebsd
fpc-cross-i386-go32v2
fpc-cross-i386-linux
fpc-cross-i386-nativent
fpc-cross-i386-netbsd
fpc-cross-i386-solaris
fpc-cross-i386-win32
fpc-cross-i386-wince
fpc-cross-jvm-android
fpc-cross-jvm-java
fpc-cross-m68k-linux
fpc-cross-mipsel-linux
fpc-cross-powerpc-linux
fpc-cross-sparc-linux
fpc-cross-x86-64-dragonfly
fpc-cross-x86-64-freebsd
fpc-cross-x86-64-linux
fpc-cross-x86-64-win64

Для других платформ (процессоров и систем) вы должны самостоятельно выполнить настройку. Это в основном та же схема: во-первых, вам нужны соответствующие binutils (см. Binutils), а во-вторых, кросскомпилятор и библиотека времени выполнения. Более подробную информацию о процедуре сборки можно узнать из файлов описания пакетов кросскомпилятора fink выше.

Из FreeBSD

Из FreeBSD на SPARC

Warning-icon.png

Предупреждение: Этот раздел, существует примерно с 2005 года и, вероятно, может быть неактуальным. Обновления приветствуются.

Я управился с компилятором из x86 на Sparc Solaris 9. Однако результат [оказался] не совсем удовлетворительный, и вот моя строка cmd:

в компиляторе/ выполняется: 

gmake cycle CPU_TARGET=sparc OS_TARGET=solaris CROSSBINUTILPREFIX=solaris-sparc- CROSSOPT='-Xd -Fl~/src/sollib'

~/src/sollib это каталог, содержащий:

  • набор .o's из /usr/local/gcc-3.3-32bit/lib/gcc-lib/sparc-sun-solaris/3.3
  • libgcc.a из /usr/local/gcc-3.3-32bit/lib/gcc-lib/sparc-sun-solaris/3.3
  • набор библиотек *.so из /usr/lib: libaio.so libmd5.so libc.so libelf.so librt.so libdl.so libm.so

Проблема иллюстрируется следующим двоичным кодом. 

 Free Pascal Compiler version 2.1.1 [2006/03/17] for sparc
 Copyright (c) 1993-2005 by Florian Klaempfl
 Target OS: Solaris for SPARC
 Compiling system.pp
 system.pp(15,1) Fatal: Syntax error, "BEGIN" expected but "identifier UNIT" found

I suspect wrong .o's are taken. Я подозреваю, что взяты неправильные .o-файлы.

Из контейнера Docker

Кросскомпиляция "hello world" с [использованием] образа Docker и Free Pascal Compiler 3.0.4

1. извлекаем образ docker: 

sudo docker pull taraworks/lazarus-cross:0.0.2 #(do not use latest)

2. создаем контейнер с виртуальным томом на основе извлеченного образа:

a. идентифицируем ID образа (необходимы первые 4 цифры): 

sudo docker images

b. используем образ для контейнера, маппируем виртуальный том из хоста: 

sudo docker create --name pascalContainer -v /home/tudi/pascal_files:/home/tudi/pascal_files -ti image ID

3. запускаем контейнер

a. идентифицируем ID контейнера (необходимы первые 4 цифры): 

sudo docker ps -a

b. запускаем контейнер: 

sudo docker start container ID

4. компилируем файл

a. копируем паскаль-файл hello.pas из https://github.com/taraworks/lazarus-cross в папку /home/tudi/pascal_files на хосте:

запускаем на хосте: 

cd /home/tudi/pascal_files

git clone https://github.com/taraworks/lazarus-cross.git

b. прикрепляем к контейнеру для проверки клонированного репо:

запускаем на хосте: 

sudo docker attach container ID

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 находится в папке с контейнером. не отсоединяйте с выходом из контейнера, пока контейнер остановится.

c. компилируем из контейнер; меняем каталог до папки, содержащей hello.pas:

для Windows: 

PATH=$PATH:/opt/clang/bin:/opt/osxcross/target/bin /opt/windows/lib/fpc/3.0.4/ppcross386 -Twin32 -va hello.pas

для OSX: 

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

d. компилируем из хоста 

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"


Общие примечания к Unix/Linux

Опция -XLA используется для переименования зависимостей библиотек, указанных в модулях паскаля. Формат -XLAold=new, чтобы изменить параметр ld link -l<old> на -l<new>.

Опция -XR<sysroot> (недавний trunk) может использоваться для указания системного root целевой [платформы]. Он используется для:

  • добавления префикса к путям добавленной библиотеки по умолчанию; в прошлом вы указывали -Xd и эти пути вручную. Напр., для i386-linux вместо передачи /lib, /usr/lib и /usr/X11R6/lib в ld, он будет передан <sysroot>/lib, <sysroot>/usr/lib и <sysroot>/usr/X11R6/lib в ld.
  • обнаружения библиотеки C (специфической для Linux): glibc или uclibc. Напр., для попытки обнаружения uclibc '<sysroot>/lib/ld-uClibc.so.0'.

Кросскомпиляция LCL

Начиная с [версии] 0.9.31, LCL является обычным пакетом Lazarus, и среда IDE автоматически [сделает] кросскомпиляцию всех необходимых пакетов при изменении целевой платформы вашего проекта.

Если что-то пойдет не так, то вот несколько советов, которые могли бы помочь выяснить, в чем причина:

Тест кросскомпилятора

Проверьте, правильно ли установлен кросскомпилированный fpc:

Создайте программу [в духе] "hello world" в test.pas: 

program test;
begin
  writeln('DATE ',{$i %DATE%});
  writeln('FPCTARGET ',{$i %FPCTARGET%});
  writeln('FPCTARGETCPU ',{$i %FPCTARGETCPU%});
  writeln('FPCTARGETOS ',{$i %FPCTARGETOS%});
  writeln('FPCVERSION ',{$i %FPCVERSION%});
end.

И скомпилируйте его с исходной/оригинальной платформой. Пример для x86 Windows: 

fpc -Twin32 -Pi386 test.pas

Затем проверьте исходный компилятор: 

test

Замените win32 и i386 своими целями [(имеется ввиду, "своими" ОС и CPU)]. Пример для целевой Windows 64 бит: 

fpc -Twin64 -Px86_64 test.pas

Затем проверьте кросскомпилятор: 

test

Программа fpc представляет собой оболочку, которая ищет правильный компилятор (напр., ppcrossx64) для цели и выполняет его.

If this does not work, your cross compiler was not installed correctly. When this works you can cross compile the LCL. Если это не сработает, ваш кросскомпилятор был установлен неправильно. Когда это работает, вы можете [выполнять] кросскомпиляцию [посредством] LCL.

Кросскомпиляция LCL в Lazarus 0.9.30 и ниже

Если вы уверены, что ваш кросскомпилятор работает, вы можете выполнить настоящую кросскомпиляцию.

Выполните следующие шаги в IDE Lazarus, чтобы выполнить кросскомпиляцию LCL:

В более старых IDE:

  • Определите в Tools -> Options -> Environment -> Files [ в строке] Compiler path путь к fpc. Обычно это уже сделано.
  • Затем откройте Tools -> Configure Build Lazarus.
  • Установите Target OS (напр., в Win64) и Target CPU (напр., в x86_64)
  • Нажмите кнопку Build.

Командная строка

Помимо IDE, командная строка также позволяет создавать кросскомпилер LCL.

Light bulb  Примечание: Начиная с [версии Lazarus] 0.9.31, вы должны использовать утилиту lazbuild для кросскомпиляции пакетов Lazarus. См. Lazbuild -h для [получения] списка опций.

Пример: вы желаете скомпилировать Windows 64, используя кросскомпилятор: сначала тщательно очистите 64-битные остатки [пакетов]. Это не касается вашей 32-битной среды: 

make distclean LCL_PLATFORM=win32 CPU_TARGET=x86_64 OS_TARGET=win64

Затем соберите LCL и необходимые ей зависимости. Нами используется LCL_PLATFORM, поскольку он, по-видимому, по-прежнему является Windows 32 даже в Windows 64 (виджеты одинаковы). 

make packager/registration lazutils lcl LCL_PLATFORM=win32 CPU_TARGET=x86_64 OS_TARGET=win64

Как и в предыдущем разделе, LCL для вашей нормальной ОС не затрагивается.

Кросскомпиляция приложений LCL

Сначала вам нужно скомпилировать LCL. См. выше.

Кросскомпиляция приложений означает: компиляция + связывание. Когда вы [сделали] кросскомпиляцию LCL, компиляционная часть [остального] проста. Просто установите в параметрах компилятора IDE целевую ОС и целевой CPU. Трудная часть - это связывание. Если вы [сделаете] кросскомпиляцию проекта, вы можете увидеть что-то вроде этого: 

/usr/local/bin/arm-linux-ld: cannot find -lX11

Это означает, что вам необходимо установить графические библиотеки целевой системы. Это не имеет ничего общего с FPC/Lazarus, но [связано] с библиотеками кросскомпиляции. Некоторые дистрибутивы предоставляют для этого предварительно скомпилированные пакеты. Например, Microsoft предоставляет кросскомпилированные библиотеки WinCE для Windows. В Linux вы можете установить Wine для кросскомпиляции из Linux на Windows. Некоторые дистрибутивы Linux предоставляют 64-битные библиотеки для 32-битных систем.

FAQ по кросскомпиляции

Почему кросскомпиляция?

Так вы можете разработать программу для одной ОС/CPU и скомпилировать ее для другой ОС/CPU без перезагрузки или переключения компьютеров.

Почему без кросскомпиляции?

Во многих случаях вы хотите протестировать полученную программу на собственной платформе. Компиляция приложения на этой платформе может быть проще в настройке.

Почему [предпочтительнее] кросскомпиляция из Unix на Windows, а не наоборот?

См. Cross compiling for Win32 under Linux

Я хочу получить дополнительную информацию о сборках на Freepascal. Где это?

Существует общий FAQ в формате pdf о том, как создавать и настраивать FPC: buildfaq

Ошибки, такие как компилятор "/usr/bin/fpc", не поддерживает целевой arm-linux

Помимо других причин, эта ошибка может возникнуть, если вы отредактировали fpc.cfg с неправильными параметрами для кросскомпилятора (напр., указав все параметры в одну строку вместо одной через строку).

См. также

Retrieved from "https://wiki.freepascal.org/index.php?title=Cross_compiling/ru&oldid=145899"