Кросскомпиляция для windows под линукс

Кросс-компиляция из Windows под Linux. Получение бинарных файлов под Linux

Мне поставили задачу — разобраться с кросскомпиляцией C и C++ приложений из под Windows для Linux.

Я попробовал использовать Cygwin для этих целей. Установил эту оболочку, запустил её. Установил компилятор cygwin-gcc-3.3.6-glibc-2.3.2-linux (старый правда). И попробовал из него скомпилировать обычный HelloWorld и запустить его под Linux всё получилось.

Но задача стоит чтобы из нашего Windows-приложения запускать кросс-компилятор, который будет компилировать некоторые файлы. Как вообще это можно реализовать? Просто в данном случае приходится запускать Cygwin, а уже из него gcc-linux или g++-linux. Пока не вижу путей запуска из нашего приложения Windows Cygwin и далее уже в нём запуска компилятора.

Может быть какие-то есть другие выходы из ситуации? Как-то можно настроить вообще отдельный компилятор по Windows, который будет компилить бинарники под Linux?

Все равно же для запуска в линуксе придется компилять в линуксе.

Зачем эти извращения? На крайняк поставьте в виртуалбоксе линукс и компиляйте себе на здоровье.

Кстати, наоборот (в линуксе под мастдай) компиляние работает.

если скомпилить под Cygwin, а потом запустить скомпиленное под Linux, то всё норм. Перекомпиляцию делать не надо.

да, тут я согласен с вами. А мне нужно наоборот. И это не извращения. VirtualBox ставить — плохой вариант. У нас файлы *.c генерятся в программе.

А конфликта библиотек не будет?

Ладно, я ничего не понял, поэтому отваливаю.

Линкуйся статикой со всем, кроме glibc. Тогда не будет.

И получится бинарник на много сотен мегабайт =)

// и вообще, у нас сайт про СПО, так что все равно исходники придется распространять. А отлаживать лучше в линуксе, а не в цигвине.

не нужно будет ничего отлаживать. Программа генерирует си-шный код, файлы *.c, который нужно просто собрать, а потом это должно запускаться под linux

Ну и зачем геморрой с компилянием в мастдае? Собираете тарбол, а в линуксе устанавливаете.

Источник

Cross compiling for Win32 under Linux/ru

Contents

Заметки по кросс-компиляции исполняемых файлов Win32 из Linux

Начиная с 0.9.10 существует rpm ‘fpc-crosswin32’, который устанавливает необходимые утилиты binutils (например кросс ассемблер, кросс линкер), fpc .ppu файлы скомпилированные для win32 и вносит изменения в /etc/fpc.cfg.

Он не включает кросс-скомпилированные LCL .ppu файлы. Вам нужно скомпилировать их самостоятельно после установки, fpc-crosswin32.

Lazarus и Free Pascal Compiler

О кросс-компиляции — понимайте то что вы делаете

Это короткое введение для новичков. В последующих разделах описывается как настроить систему для кросс-компиляции, имеется ввиду работая под linux создавать исполняемые файлы win32 (или freebsd, или dawin, или. ) Почему кросс-компиляция: FreePascal это компилятор, преобразующий исходный код в исполняемые файлы (на машинном языке). Эти исполняемые файлы, кроме всего прочего, содержат информацию о том как операционная система запускает их на выполнение. Поэтому исполняемые файлы являются платформенно-зависимыми. Сам FreePascal не требует различных дистрибутивов. Он может создавать исполняемые файлы для многих платформ. Просто укажите ему это. Но компилятор — это только одна часть. Существует ещё ассемблер и линкер. И эти утилиты не способны создавать кроссплатформенный код. Поэтому были созданы специальные утилиты линкер ‘ld’ и ассемблер ‘as’ для каждой целевой платформы. Это binutils. После создания кроссплатформенных утилит все модули fpc pascal будут кросс-компилированы. Например, для каждой из целевых платформ существует отдельный файл system.ppu. Затем ваш конфигурационный файл fpc.cfg будет перенастроен, таким образом кросс-компиляция станет настолько лёгкой, что вы сможете забыть обо всех мелочах. То же самое нужно проделать и с LCL — lazarus component library. И после этого вы сможете кросс-компилировать программы на паскале для win32. Затем проверить их при помощи wine или скопировать на машину с Windows и протестировать на ней.

Почему из *nix в windows а не по-другому.

Основная причина — генерирование unix-бинарников на другой платформе (другой unix или Linux) более сложно. Более сложное статическое связывание, не говоря уж об остальном.

Придется использовать библиотеки из целевой платформы (gtk, glib, libc и т.д.), и множество дополнительных настроек для ld. (пути к библиотекам, путь к линкеру и т.д.)

Это было частично сделано (в статическом случае), но это сложно т.к. требует внесения изменений в файлы линкера и командную строку линкера, а также глубокого понимания о сборке бинарников Unix.

Скачивание исходных кодов FPC

Исполняемых файлов недостаточно, вам потребуются все исходники fpc. Обратитесь к www.freepascal.org. Вы можете использовать SVN или ежедневные сборки. Для следующих примеров исходники fpc были скачены в папку

Скачивание gnu binutils.

Например, binutils-2.18.tar.gz скачайте в

Кроссплатформенная сборка binutils

В репозитории fpcbuild существует скрипт для сборки binutils для всех поддерживаемых целевых платформ: install/cross/buildcrossbinutils

Скачиваем инсталлятор fpcbuild:

Создаём копию скрипта:

Правим переменные в начале нового скрипта.

Переменная BASE указывает на директорию сборки и установки. Директория должна быть пустой. Например:

Теперь разберёмся со скачанным файлом binutils. Если путь к скачанному файлу

/download/binutils-2.18.tar.gz то укажем

Скрипт будет автоматически соберёт это в

/download/binutils-2.18.tar.gz. Остальные переменные определяют какие целевые платформы мы имеем. По умолчанию их довольно много, поэтому компиляция может занять много времени (часы на слабых машинах). Для кросс-компиляции для Windows вам потребуется только

и закомментировать все остальные:

Затем запустите скрипт:

Скрипт создаст поддиректорию ‘logs’ с соответствующим содержимым. В случае чего, начните поиски оттуда.

Заметьте что для некоторых платформ (Linux,FreeBSD, win32) утилиты доступны в скомпилированном виде. Смотрите ftp://freepascal.stack.nl/pub/fpc/contrib/cross/

Кроссплатформенная сборка FPC

В рекозитории fpcbuild существует скрипт для сборки fpc под все поддерживаемые целевые платформы: install/cross/buildcrosssnapshot Создайте копию скрипта

Исправьте переменные в начале нового скрипта.

Вам потребуется изменить всего лишь CROSSTOOLSROOT, FPCCVS, DESTDIR, TARGETS_OS и TARGETS_CPU. Например:

Затем запустите скрипт:

После этого вы получите кросс-компилированные модули в

Конфигурирование вашего fpc.cfg

Откройте с правами рута /etc/fpc.cfg или создайте копию /etc/fpc.cfg to

/fpc.cfg и отредактируйте этот файл. Найдите в файле пути поиска модулей.

Примечание: В более старых версиях FPC вместо $fpcversion и $fpctarget использовались $version и $target.

Замените их специальными путями для других платформ. Например, для linux и кросс-компилированной win32:

Выполните: тестирование и устранение неполадок.

Кросс-компиляция LCL и компонентов lazarus

В коммандной строке:

Таким образом всё скомпилируется для win32 (включая IDE, что необязательно, но это сокращает объём манипуляций).

Или в IDE Сервис->Параметры сборки: отметим LCL, Synedit, Codetools, Регистрация пакетов и Интерфейс IDE как Очистить+Собрать, установми в поле Библиотека виджетов LCL значение win32/win64, а Целевая ОС — win32. Затем нажмём ‘Собрать’. Ваши файлы .ppu/.o скомпилированные для linux не будут перезаписаны и вам не нужно будет перекомпилировать их каждый раз, т.к. в рабочей папке будут созданы специальные директории для других целевых систем.

Коросс-компиляция проекта

Выберите Проект->Параметры проекта->Параметры компилятора->Генерация кода Целевая ОС=’win32′ и Проект->Параметры проекта->Параметры компилятора->Пути Библиотека виджетов LCL=’win32′. Вот и всё. При следующей компиляции будет создан исполняемый файл win32. IDE произведёт поиск утилит win32, поэтому компилятор будет работать с rtl для win32 вместо rtl для linux. Когда вы откроете другой проект или закроете текущий и откроете его вновь IDE автоматически установит настройки.

Подсказки по кросс-компиляции и Lazarus

Если вы создаете приложение/пакет для различных целевых ОС, вам необходимо действовать следующим образом: устранить баги, скомпилировать и протестировать приложение под linux, затем скомпилировать и протестировать его под win32, .. . Потому что обычно вы перезаписываете ваши .ppu файлы, и вам придётся перекомпилировать всё, каждый раз когда вы переключаете захотите изменить целевую ОС. Но это не обязательно. Lazarus поддреживает макросы.

Пример 1: Кросс-компиляция проекта для linux и win32.

Установите значение Проект-> Параметры компилятора->Пути->Каталог вывода модулей = $(TargetOS). Этот макрос будет заменён названием целевой ОС в нижнем регистре (например ‘linux’ для Linux, ‘win32’ для Win32). Каталог вывода модулей находится в директории вашего проекта (директории где расположен файл .lpi). Создайте директории с именами ‘linux’ и ‘win32’ в директории вашего проекта. Когда вы кликните на кнопке ‘Показать параметры’ в самом низу окна Параметры проекта, вы увидите -FElinux/ или -FEwin32/. Эта опция сообщает компилятору куда записать создаваемые файлы (файлы .ppu/.o).

Пример 2: Кросс-компиляция проекта для различных платформ и наборов виджетов.

Укажите Каталог вывода модулей следующим образом $(TargetCPU)/$(TargetOS)/$(LCLWidgetType) и создайте поддиректории для всех целей. Этот путь также используется LCL.

То же самое можно проделать и для пакетов.

Кросс-компиляция и пакеты Lazarus

Пакеты Lazarus не ограничены библиотеками. Они могут быть использованы для компиляции практически чего угодно. И IDE автоматически перекомпилирует их при необходимости. Пакеты могут наследовать опции компилятора. Например: проект, использующий пакет, наследует каталог вывода пакета. Другими словами: каталог вывода пакета добавляется в пути поиска модулей проекта. Посмотрите в IDE: Проект->Параметры проекта->Параметры компилятора->Унаследованные.

Наследование срабатывает единажды. Но существуют исключения: Целевая платформа (ОС и CPU) проекта переопределяет цель для всех используемых пакетов. Это значит, если вы укажете Целевую ОС в проекте = ‘win32’ и скомпилируете проект, IDE выполнит проверку на предмет необходимости перекомпиляции пакетов для Целевой ОС.

Пакет А имеет директорию вывода: lib/$(TargetOS) Проект использует А.

Проект собирается для linux. IDE компилирует А для linux в

/lib/linux/, затем компилирует проект для linux.
Проект собирается для win32. IDE компилирует А для win32 в

/lib/win32/, затем компилирует проект для win32.

Проект снова собирается для linux. IDE проверяет, существует ли А для linux. Затем компилирует проект для linux.

Таким образом, использование макросов экономит много времени.

Для Unix (в общих чертах)

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

на -l .

Опция -XR (recent trunk) может быть использована для указания корня Целевой ОС. Она используется для:

• добавления префикса к указанным по-умолчанию путям библиотек, в прошлом вы использовали -Xd и эти пути вручную. Например для i386-linux

вместо следования в /lib, /usr/lib, и /usr/X11R6/lib к ld, будет следовать в /lib, /usr/lib, и /usr/X11R6/lib к ld.

• определение местоположения библиотек С (linux-версий): glibc или uclibc. Например для uclibc будет принята попытка поиска по пути ‘ /lib/ld-uClibc.so.0’

Для Linux под Win32

Это просто, есть некоторая информация в buildfaq

FreeBSD для sparc

Я пытался кросс-компилировать из х86 для Sparc Solaris 9. Несмотря на то что результат не работал должным образом привожу мою командную строку:

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

/src/sollib директория которая содержит:

• набор файлов .o из /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
• набор файлов lib*.so из /usr/lib: libaio.so libmd5.so libc.so libelf.so librt.so libdl.so libm.so

Иллюстрация проблемы при компиляции:

Я подозреваю что ошибся с выбранными .o файлами.

Для Mac OS X

Авторы

Эта страница была конвертирована из epikwiki version.

Источник

Cross compiling/ru

Contents

Предисловие

Это краткое введение для новичков. В следующих разделах описывается, как настроить систему для кросскомпиляции, что означает создание двоичных файлов (исполняемых файлов) для платформы, отличной от той, которая используется для компиляции, напр., работающих под 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.

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

После создания (или наличия/установки) кросс-инструментов требуется 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:

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

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

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

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

Из Linux на ARM Linux

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

Из Linux на Windows

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

Из Linux на Darwin или macOS

Из Windows

Из Windows на Linux

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

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

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

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

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

Из Windows на GO32v2

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

Из Windows на wince

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

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

Из win32 на win64

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

Из 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.

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

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

Из Darwin i386 на x86_64

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

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

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

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

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

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

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

Из Darwin x86_64 на i386

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

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

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

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

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

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

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

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

Из FreeBSD

Из FreeBSD на SPARC

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

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

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

/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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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:

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

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

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

на -l .

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

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

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

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

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

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

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

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

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

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

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

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

Программа 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Источник