Linux компиляция с библиотеками

Основы компиляции программ из исходного кода в Linux

Оригинал: Basics Of Compiling Software From Source Code In Linux
Автор: LinuxAndUbuntu
Дата публикации: 16 мая 2018 года
Перевод: А. Кривошей
Дата перевода: июнь 2018 г.

Время от времени вам может понадобиться скомпилировать программу из исходного кода. Это включает компиляцию кода C или C++ во что-то, что мы можем запустить в Linux. В зависимости от программного обеспечения, которое вы хотите скомпилировать, часто делать это необязательно, так как ваш дистрибутив, скорее всего, уже будет иметь двоичный пакет программы в репозиториях программного обеспечения. Фактически, вы должны выбрать бинарные пакеты или компиляцию из исходного кода. Однако, если когда-либо вам нужно будет скомпилировать исходный код, это руководство даст вам некоторые основные знания данного процесса.

Типичный пример

Возьмем программу, написанную на C или C++. Загрузка исходного кода часто связана с загрузкой и распаковкой пакета или клонированием репозитория git. Типичным является выполнение этих трех команд:

Первая команда запускает скрипт configure, который анализирует библиотеки, установленные в вашей системе. Если требуемая для компиляции библиотека не установлена, он сообщит об этом, и вам нужно будет установить ее. Вам понадобится не только библиотека, но и файлы разработчика. Файлы с исходным кодом используют функции, имеющиеся в этих библиотеках.

После выполнения команды configure у вас должен быть создан файл Makefile. При запуске make, эта утилита будет читать Makefile в текущем каталоге и запустит компилятор (gcc для C или g ++ для C++) для компиляции программного обеспечения.

Третья команда не является строго необходимой, но рекомендуется для обеспечения общесистемного доступа к вашей программе, чтобы запускать исполняемый файл в терминале из любого места. Эта команда говорит «make» запустить инструкции по установке программы в систему.

Файлы INSTALL или README

Могут иметься дополнительные инструкции, которые должны быть выполнены до начала компиляции. Чтение этого файла (как правило, INSTALL) также поможет узнать, какие библиотеки разработчиков, возможно, потребуется установить в первую очередь. Такие пакеты будут содержать суффикс «-dev», чтобы показать, что они относятся к разработке и должны быть установлены для компиляции. Сценарий configure также может потребовать дополнительных параметров. README содержат любую другую информацию.

Вы даже можете обнаружить, что ни одна из трех команд не запускается. Вместо этого может использоваться другой вариант make, например qmake (для проектов Qt) или cmake.

Установка программы с GitHub

Начнем с установки текстового редактора wxMEdit, найденного на GitHub. Здесь я демонстрирую, как установить программу путем компиляции из исходного кода. Это типичный пример. Если вы посетите репозиторий GitHub, вы увидите, что файл readme содержит сведения о приложении. Никаких инструкций по компиляции нет, поэтому применяется стандартная последовательность с одной разницей: autogen.sh.

Сначала мы переходим в каталог, где хотим хранить репозиторий, и клонируем его:

Autogen.sh

Если вы найдете этот файл в исходном коде, вы должны запустить его перед “./configure”, так как он выполнит задачи, которые позволят вам успешно скомпилировать программное обеспечение. Если он отработал успешно, вы можете запустить “./configure”, “make”, а затем «sudo make install» и это все, что вам нужно запустить (в данном случае ничего больше).

В выводе make не должно быть ошибок.

Решение проблем

Если вы делаете это регулярно, вы должны столкнуться с определенными проблемами при компиляции из исходного кода.

Отсутствующие библиотеки

Помните, недостаточно установленных бинарных библиотек; также должны быть установлены исходные файлы или заголовки для разработчиков . Сценарий configure вместе с документацией обычно предупреждает вас о любых библиотеках (заголовках), которые необходимо установить для успешной компиляции. Убедитесь, что они установлены в вашей системе.

Заключение

Компиляция программного обеспечения может быть довольно простой или довольно болезненной. К счастью, многие дистрибутивы Linux предоставляют двоичные пакеты, готовые к установке, поэтому компиляция из исходного кода обычно не требуется. Лучше придерживаться бинарных пакетов, предоставляемых репозиториями, если они доступны.

Другие статьи о компиляции программ из исходного кода на нашем сайте:

Источник

Компиляция программ Linux

Все программы для компьютера представляют собой набор команд процессора, которые состоят из определенного набора бит. Этих команд несколько сотен и с помощью них выполняются все действия на вашем компьютере. Но писать программы непосредственно с помощью этих команд сложно. Поэтому были придуманы различные языки программирования, которые проще для восприятия человеку.

Для подготовки программы к выполнению, специальная программа собирает ее из исходного кода на языке программирования в машинный код — команды процессора. Этот процесс называется компиляция. Linux — это свободное программное обеспечение, а поэтому исходные коды программ доступны всем желающим. Если программы нет в репозитории или вы хотите сделать что-то нестандартное, то вы можете выполнить компиляцию программы.

В этой статье мы рассмотрим, как выполняется компиляция программ Linux, как происходит процесс компиляции, а также рассмотрим насколько гибко вы сможете все настроить.

Подготовка системы

Мы будем компилировать программы, написанные на Си или С++, так как это наиболее используемый язык для программ, которые требуют компиляции. Мы уже немного рассматривали эту тему в статье установка из tar.gz в Linux, но та статья ориентирована больше на новичков, которым нужно не столько разобраться, сколько получить готовую программу.

В этой же статье тема рассмотрена более детально. Как вы понимаете, для превращения исходного кода в команды процессора нужно специальное программное обеспечение. Мы будем использовать компилятор GCC. Для установки его и всех необходимых инструментов в Ubuntu выполните:

sudo apt install build-essential manpages-dev git automake autoconf

Затем вы можете проверить правильность установки и версию компилятора:

Но перед тем как переходить к самой компиляции программ рассмотрим более подробно составляющие этого процесса.

Как выполняется компиляция?

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

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

Дальше идет синтаксический анализ и преобразование исходного кода в объектный код, без этого этапа можно было бы и обойтись, но это необходимо, чтобы компилятор мог выполнить различные оптимизации, сделать размер конечной программы меньше, а команды процессора эффективнее.

Затем все объектные файлы собираются в одну программу, связываются с системными библиотеками. После завершения этого этапа программу остается только установить в файловую систему и все. Вот такие основные фазы компиляции программы, а теперь перейдем ближе к практике.

Компиляция программ Linux

Первое что нам понадобиться — это исходники самой программы. В этом примере мы будем собирать самую последнюю версию vim. Это вполне нейтральная программа, достаточно простая и нужная всем, поэтому она отлично подойдет для примера.

Получение исходников

Первое что нам понадобиться, это исходные коды программы, которые можно взять на GitHub. Вы можете найти исходники для большинства программ Linux на GitHub. Кроме того, там же есть инструкции по сборке:

Давайте загрузим сами исходники нашей программы с помощью утилиты git:

git clone https://github.com/vim/vim

Также, можно было скачать архив на сайте, и затем распаковать его в нужную папку, но так будет удобнее. Утилита создаст папку с именем программы, нам нужно сделать ее рабочей:

Настройка configure

Дальше нам нужно запустить скрипт, который проверит нашу программу на совместимость с системой и настроит параметры компиляции. Он называется configure и поставляется разработчиками программы вместе с исходниками. Весь процесс компиляции описан в файле Makefile, его будет создавать эта утилита.

Если configure нет в папке с исходниками, вы можете попытаться выполнить такие скрипты чтобы его создать:

Также для создания этого скрипта можно воспользоваться утилитой automake:

aclocal
autoheader
automake —gnu —add-missing —copy —foreign
autoconf -f -Wall

Утилита automake и другие из ее набора генерируют необходимые файлы на основе файла Mackefile.am. Этот файл обязательно есть в большинстве проектов.

После того как вы получили configure мы можем переходить к настройке. Одним из огромных плюсов ручной сборки программ есть то, что вы можете сами выбрать с какими опциями собирать программу, где она будет размещена и какие дополнительные возможности стоит включить. Все это настраивается с помощью configure. Полный набор опций можно посмотреть, выполнив:

Рассмотрим наиболее часто используемые, стандартные для всех программ опции:

• —prefix=PREFIX — папка для установки программы, вместо /, например, может быть /usr/local/, тогда все файлы будут распространены не по основной файловой системе, а в /usr/local;
• —bindir=DIR — папка для размещения исполняемых файлов, должна находится в PREFIX;
• —libdir=DIR — папка для размещения и поиска библиотек по умолчанию, тоже в PREFIX;
• —includedir=DIR — папка для размещения man страниц;
• —disable-возможность — отключить указанную возможность;
• —enable-возможность — включить возможность;
• —with-библиотека — подобно enable активирует указанную библиотеку или заголовочный файл;
• —without-библиотека — подобное disable отключает использование библиотеки.

Вы можете выполнить configure без опций, чтобы использовать значения по умолчанию, но также можете вручную указать нужные пути. В нашем случае ./configure есть, и мы можем его использовать:

Во время настройки утилита будет проверять, есть ли все необходимые библиотеки в системе, и если нет, вам придется их установить или отключить эту функцию, если это возможно. Например, может возникнуть такая ошибка: no terminal library found checking for tgetent(). configure: error: NOT FOUND!

В таком случае нам необходимо установить требуемую библиотеку. Например, программа предлагает ncurses, поэтому ставим:

sudo apt install libncurces-dev

Приставка lib всегда добавляется перед библиотеками, а -dev — означает, что нам нужна библиотека со всеми заголовочными файлами. После удовлетворения всех зависимостей настройка пройдет успешно.

Сборка программы

Когда настройка будет завершена и Makefile будет готов, вы сможете перейти непосредственно к сборке программы. На этом этапе выполняется непосредственно преобразование исходного кода в машинный. Утилита make на основе Makefile сделает все необходимые действия:

Дальше осталось установить саму программу, если вы использовали опцию prefix, чтобы не устанавливать программу в основную файловую систему, то можно применить стандартную опцию make:

После этого программа будет установлена в указанную вами папку, и вы сможете ее использовать. Но более правильный путь — создавать пакет для установки программы, это делается с помощью утилиты checkinstall, она позволяет создавать как deb, так и rpm пакеты, поэтому может использоваться не только в Ubuntu. Вместо make install выполните:

Затем просто установите получившийся пакет с помощью dpkg:

sudo dpkg install vim.deb

После этого сборка программы полностью завершена и установлена, так что вы можете переходить к полноценному использованию.

Если вы устанавливали программу с помощью make install, то удалить ее можно выполнив в той же папке обратную команду:

sudo make uninstall

Команда удалит все файлы, которые были скопированы в файловую систему.

Выводы

В этой статье мы рассмотрели, как выполняется компиляция программы Linux. Этот процесс может быть сложным для новичков, но в целом, все возможно, если потратить на решение задачи несколько часов. Если у вас остались вопросы, спрашивайте в комментариях!

На завершение видео о том, что такое компилятор и интерпретатор:

Источник

Блог радиста

Блог о Linux в частности и Open Source в общем, о программировании и немного о M$ Windows

Статические и динамические библиотеки в Linux

Статические и динамические библиотеки в Linux

Сегодня мы поговорим о библиотеках в Linux (подозреваю также, что многие описанные здесь вещи возможны и в других *nix-операционных системах, но это требует проверки 🙂 ).

1) Статические библиотеки (создание с помощью Assembler, C/C++; подключение и использование в программах на Assembler,C/C++);
2) Динамические библиотеки (создание с помощью Assembler, C/C++; подключение и использование в программах на C/C++l, Python).

1) Статическая библиотека — это такая библиотека, которая связывается (линкуется) с программой в момент компиляции оной. При этом объектный код библиотеки помещается в исполняемый файл программы. С этой точки зрения статическая библиотека похожа на исходный код программы, с которой она связывается, за исключением того, что библиотека компилируется «кем-то еще» и программист, использующий библиотеку, имеет дело исключительно только с результатом этой компиляции.

В Linux, как правило, файл-статическая_библиотека имеет расширение «.a»

2) Статические библиотеки на языке C.

Исходный код библиотеки:

Сохраните его в файле static.c

Ключевое слово extern необходимо для того, чтобы функция была видна в программе.

Теперь скомпилируем (! без линковки) библиотеку:

gcc -c static.c -o static.o
(на выходе имеем файл static.o, содержащий объектный код нашей библиотеки)

ar rc libMY_STATIC.a static.o

ar упаковывает несколько (! Это важно. Дело не ограничивается только одним объектным файлом) объектных файлов в одну статическую библиотеку. Статическая библиотека имеет расширение «.a», при этом ее название должно начинаться с «lib» (дань традиции).
Параметры ar:
r — предписывает заменять старые версии объектных файлов новыми — необходим для переупаковки библиотеки;
c — создать статическую библиотеку, если та еще не существует.

Проиндексируем функции внутри библиотеки для более быстрой линковки:

Итак, мы получили статическую библиотеку libMY_STATIC.a.

Теперь попытаемся использовать библиотеку в нашей программе:

Исходный текст программы (C):

Сохраните его в файле program1.c

Способы связывания библиотеки и программы:

— Скомпилируем и слинкуем (в том числе с нашей библиотекой) нашу программу:

gcc program1.c libMY_STATIC.a

(предполагается, что в качестве аргумента gcc будут переданы полные пути (!) к вашим библиотекам)

На выходе получим:

Hello world! I’m static library
Return code: 0

— Скомпилируйте с помощью команды:

gcc program1.c -L. -lMY_STATIC -o a1.out

— путь к каталогу, содержащему наши библиотек (используйте «-L

— название нашей библиотеки (это важно — название (!), а не имя файла — собственно, если библиотека имеет своим именем «libBLABLABLA.a», то ее названием будет «BLABLABLA» — т.е. имя без приставки «lib» и расширения «.a») (для нескольких библиотек используйте «-l -l . «)

Запустите файл a1.out на выполнение и удостовертесь, что результаты те же, что и в предыдущем пункте.

— Видоизменим предыдущий способ — уберем аргументы «-L»:

В начале проверим значение переменной LD_LIBRARY_PATH и содержимое файла /etc/ld.so.conf:

echo $LD_LIBRARY_PATH ; cat /etc/ld.so.conf

На экране появился некоторый список каталогов — это те каталоги, в которых система ищет библиотеки при их линковке с программой (еще к таким каталогам относятся:
/lib
/usr/lib
. Поместите libMY_STATIC.a в один из этих каталогов:

(Я, к примеру, засуну нашу библиотеку в каталог /usr/lib):

su -c ‘cp libMY_STATIC.a /usr/lib’
(в Ubuntu — sudo cp libMY_STATIC.a /usr/lib )
ldconfig
(ldconfig обновляет кеш данных о библиотеках линковщика)

Теперь скомпилируем и запустим нашу программу:

gcc program1.c -lMY_STATIC -o a2.out
./a2.out

Hello world! I’m static library
Return code: 0

Бинго! Кстати, таким вот способом вы можете подключать к своей программе любые статические библиотеки из приведенных выше каталогов.

* Бывает полезно определить все прототипы функций библиотеки в некотором заголовочном файле, который будет потом включаться в вашу программу. Это не обязательно, но удобно.

3) Статические библиотеки на языке Assembler.

Представьте, что вам необходимо оптимизировать выполнение некоторых действий в вашей программе. Разумеется, вы может применить ключевое слово asm (если пишите программу на C/C++), но лучшим решением будет создание оптимизированной вами библиотеки на языке Assembler и подключение ее к вашей программе. Давайте попробуем:

*Кстати, углубляться в процесс компиляции библиотеки и ее линковки с вашей программой я не буду (!). Этот процесс идентичен полностью (!) тому же процессу для библиотек, написанных на языке C.

Итак, имеем вот такую программу:

Сохраните ее в файле program2.c

Скомпилируйте ее и запустите:

Я привел этот пример, чтобы показать действительно возможность оптимизации программы с помощью библиотеки на Assembler’е. Вы можете заметить, что вызов printf в main() не оптимален, т.к. printf, по крайней мере, один раз использует цикл while для поиска вхождений конструкций «%. » в строку. Это не оптимально, т.к. очевидно, что таковых символов у нас нет. Оптимизируем нашу программу с помощью библиотеки на Assebmler’е:

my_printf:
movl $4,%eax
xorl %ebx,%ebx
incl %ebx
movl $hw,%ecx
movl $hw_e,%edx
int $0x80
xorl %eax,%eax
ret

Сохраните исходный код библиотеки в файле static2.s

Это AT&T наречие Assembler’а.

.globl my_printf — «my_printf» описывается как глобальная (видимая в других объектных файлах) последовательность
my_printf: — начало описание функции my_printf
movl $4,%eax — поместим 4 в eax (4 — номер системного вызова write)
xorl %ebx,%ebx и incl %ebx — поместим в ebx единицу — номер STDOUT
movl $message,%ecx — в ecx запишем адрес начала сообщения
movl $message_l,%edx — в edx поместим адрес конца сообщения
int $0x80 — произведем системный вызов write
xorl %eax,%eax — в eax — код возврата (0)
ret — вернемся в вызывающую процедуру
.data — секция данных (разумеется, мы могли бы передавать выводимую строку как параметр, но тогда вычисление ее конца потребовало бы от нас дополнительных усилий, что, согласитесь, лениво 🙂 )

Теперь получим библиотеку:

gcc -c static2.s -o static2.o
ar rc static2.a static2.o
ranlib static2.a

На выходе имеем статическую библиотеку static2.a

Теперь напишем программу, использующую эту статическую библиотеку (язык C):

Сохраните текст программы в файле program3.c

Заметьте, я добавил прототип библиотечной функции для удобства.

Скомпилируем и слинкуем программу с библиотекой, после чего запустим программу на выполнение:

gcc program3.c static2.a
./a.out

На выходе получим:

* Принцип линкования статических библиотек с программами на Assembler’е аналогичен принципу для программ на C. Просто, когда будете использовать статические библиотеки в Assembler’е, помните о соглашениях C по передаче аргументов в функцию и возвращению результата.

4) Статические библиотеки на языке C++.

Принцип создания аналогичен статическим библиотекам на C, но перед каждой экспортируемой функцией не забывайте добавлять:

(экспортировать как функцию на C — т.е. без расширения имен).

* Кстати, используйте g++ вместо gcc, если захотите протестировать приведенные выше примеры.

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

extern «C» PROTOTYPE

Где PROTOTYPE — прототип импортируемой функции.

* При подключении статических библиотек на C++ к программе на C сопряжено с некоторыми трудностями — т.к. при компиляции и линковки программы необходимо будет также вручную подключить системные библиотеки для реализации функционала, предоставляемого библиотекой Standart C++ сверх того, что предоставляет библиотека Standart C.

Динамические библиотеки (shared).

1) Динамическая библиотека — библиотека, подключаемая к программе в момент выполнения. Это означает, что при создании библиотеки производится не только ее компиляция, но и линковка с другими, нужными ей, библиотеками (!).

Динамические библиотеки полезны в случаях, если:
— Важно не перекомпилировать всю программу, а только перекомпилировать ту часть, которая реализует определенные функции — тогда эти функции выносятся в динамическую библиотеку;
— Важно использовать в программах на C библиотеки, подготовленные на C++ и при этом избежать лишних трудностей с линковкой программы;
— Кроме того, динамические библиотеки позволяют экономить место на жестком диске и в оперативной памяти, если одна и таже библиотека используется несколькими программами.

В Linux, обычно, динамические библиотеки имеют расширение «.so».

2) Подготовим исходный код динамической библиотеки (пример на C++).

Исходный код динамической библиотеки по принципам создания ничем (!) не отличается от исходного кода статических библиотек.

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

Итак, исходный код библиотеки (C++):

extern «C» int hello()
<
cout 3) Компиляция и линковка динамических библиотек.

Давайте получим динамическую библиотеку:

Получим файл с объектным кодом:

g++ -fPIC -c dynamic.cpp -o dynamic.o

(используйте gcc для программ на С и Assembler’е)

-fPIC — использовать относительную адресацию в переходах подпрограмм — во избежание конфликтов при динамическом связывании

А теперь из объектного файла получим библиотеку:

g++ -shared -olibdynamic.so dynamic.o

(используйте gcc для программ на С и Assembler’е)

libdynamic.so — имя результирующей библиотеки;
-shared — предписывает создать динамическую (т.е. «разделяемую») библиотеку.

* Именуйте динамические библиотеки следующим способом:

Итак, на выходе мы имеем libdynamic.so — нашу динамическую библиотеку.

4) Использование динамической библиотеки в программе на C/C++.

— Связывание с библиотекой во время компиляции программы (C/C++):

—— Подготовим исходный код нашей программы:

Сохраните его в файле Dprogram1.c

extern «C» int hello();

Сохраните его в файле Dprogram1.cpp

(единственное отличие, как вы можете заметить, в ключевом слове extern — см. часть 1 пункт 4)

—— Теперь добьемся того, чтобы система смогла найти нашу библиотеку. Поместим libdynamic.so в один из каталогов:

cat /etc/ld.so.conf
и выполните потом » ldconfig «

—— И, наконец, скомпилируем программу и слинкуем ее с библиотекой:

gcc ИСХОДНИК -lИМЯ_БИБЛИОТЕКИ -o РЕЗУЛЬТИРУЮЩИЙ_БИНАРИК

В нашем случае: gcc Dprogram1.c -L/home/amv/c/libs/ -ldynamic

(используйте g++ для программы на C++)

Запустим на исполнение полученный файл:

В итоге должно получится:

— Связывание с библиотекой во время исполнения программы (C/C++):

Разумеется, предыдущий пример неплох. Однако бывает необходимо подключать библиотеку во время выполнения программы. Для этого можно использовать функционал из заголовочного файла .

Исходный код примера (C):

int main()
<
void *handle = dlopen(«libdynamic.so»,RTLD_LAZY);
int(*fun)(void) = dlsym(handle,»hello»);
int x = (*fun)();
dlclose(handle);
printf(«Return code: %d\n»,x);
return 0;
>;

######################

Сохраните его в файле Dprogram2.c

В dlfcn.h определены следующие функции:

void* dlopen(«PATH_AND_NAME»,FLAG) — загружает в память динамическую библиотеку с полным именем PATH_AND_NAME и возвращает ее описатель (HANDLE) (NULL в случае неудачи). FLAG — флаги, описанные в «man dlopen»;
void* dlsym(HANDLE,»NAME») — возвращает указатель на функцию/переменную, импортируемую из библиотеки;
int dlclose(HANDLE) — выгружает библиотеку из памяти;
const char *dlerror() — получить сообщение о последней возникшей ошибке (NULL — если ошибок не произошло с момента последнего вызова dlerror).

* Посмотрите на досуге вот этот перевод «man dlopen»: Привет, OpenNET

gcc -ldl Dprogram2.c

(используйте g++ для программы на C++)

Запустим на исполнение полученный файл:

В итоге должно получится:

* Важно! Нет необходимости помещать библиотеку в один из специальных каталогов, модифицировать переменные окружения и выполнять «ldconfig»

— Использование динамической библиотеки в программе на Python:

Все предельно просто.

—— Поместим libdynamic.so в один из каталогов:

cat /etc/ld.so.conf
и выполните потом «ldconfig»

Исходный текст программы на python’е:

Модуль ctypes входит в стандартную поставку модулей python версии 2.5 и выше.

Фуф. Мы проделали довольно большую работу, но ведь это только верхушка айсберга.

Источник