регулярный (S_REGULAR)

A regular раздел может содержать любой вид данных и не получает специальной обработки от редактора связей. Это - тип раздела по умолчанию. Примеры regular разделы включают инструкции программы или инициализируемые данные.

cstring_literals (S_CSTRING_LITERALS)

A cstring_literals раздел содержит завершенные нулем литеральные символьные строки языка C. Редактор связей помещает только одну копию каждого литерала в раздел выходного файла и перемещает ссылки на различные копии того же литерала к одной копии в выходном файле. Не может быть никаких записей перемещения для раздела этого типа, и все ссылки на литералы в этом разделе должны быть в диапазоне адресов для определенного ссылаемого литерала. Последний байт в разделе этого типа должен быть нулевым байтом, и строки не могут содержать нулевые байты в своих организациях. Пример a cstring_literals раздел один для литеральных строк, появляющихся в организации функции ANSI C, где компилятор принимает решение сделать такие строки только для чтения.

4byte_literals (S_4BYTE_LITERALS)

A 4byte_literals раздел содержит 4-байтовые литеральные константы. Редактор связей помещает только одну копию каждого литерала в раздел выходного файла и перемещает ссылки на различные копии того же литерала к одной копии в выходном файле. Не может быть никаких записей перемещения для раздела этого типа, и все ссылки на литералы в этом разделе должны быть в диапазоне адресов для определенного ссылаемого литерала. Пример a 4byte_literals раздел - тот, в которой одинарной точности константы с плавающей точкой сохранены для машины RISC (они обычно были бы сохранены как immediates в машинном коде CISC).

8byte_literals (S_8BYTE_LITERALS)

8byte_literals раздел содержит 8-байтовые литеральные константы. Редактор связей помещает только одну копию каждого литерала в раздел выходного файла и перемещает ссылки на различные копии того же литерала к одной копии в выходном файле. Не может быть никаких записей перемещения для раздела этого типа, и все ссылки на литералы в этом разделе должны быть в диапазоне адресов для определенного ссылаемого литерала. Пример a 8byte_literals раздел - тот, в которой двойной точности константы с плавающей точкой сохранены для машины RISC (они обычно были бы сохранены как immediates в машинном коде CISC).

literal_pointers (S_LITERAL_POINTERS)

A literal_pointers раздел содержит 4-байтовые указатели на литералы в литеральном разделе. Редактор связей помещает только одну копию указателя в раздел выходного файла для каждого указателя на литерал с тем же содержанием. Редактор связей также перемещает ссылки на каждый литеральный указатель на одну копию в выходном файле. Должна быть точно одна запись перемещения для каждого литерального указателя в этом разделе, и все ссылки на литералы в этом разделе должны быть в диапазоне адресов для определенного ссылаемого литерала. Если те символы идентифицируют литералы в другом объектном файле, записи перемещения могут быть внешними записями перемещения, относящимися к неопределенным символам. Пример a literal_pointers раздел - один содержащий селекторные ссылки, сгенерированные компилятором Objective C.

symbol_stubs (S_SYMBOL_STUBS)

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

    .text

    .align 2

    .globl _func

 _func:

    b L_foo$stub

    .symbol_stub

 L_foo$stub:                            ;

    .indirect_symbol _foo               ;

    lis r11,ha16(L_foo$lazy_ptr)        ;

    lwz r12,lo16(L_foo$lazy_ptr)(r11)   ; the symbol stub

    mtctr r12                           ;

    addi r11,r11,lo16(L_foo$lazy_ptr)   ;

    bctr                                ;

    .lazy_symbol_pointer

 L_foo$lazy_ptr:                        ;

    .indirect_symbol _foo               ; the symbol pointer

    .long dyld_stub_binding_helper      ; to be replaced by _foo's address

Тупиковые символом разделы в архитектуре IA-32 — вместо того, чтобы использовать тупик и ленивый указатель — используют одну команду перехода, указывающую цель. Это - соответствующий ассемблерный код IA-32:

    .text

    .align 2

    .globl _func

_func:

    pushl   %ebp

    movl    %esp, %ebp

    subl    $8, %esp

    call    L_foo$stub

    leave

    ret

    .symbol_stub

L_foo$stub:

     .indirect_symbol _foo

     hlt ; hlt ; hlt ; hlt ; hlt

В ассемблерном коде, _func ответвления к L_foo$stub, который ответственен за нахождение определения функции foo(). На PPC (и PPC64), L_foo$stub переходы к содержанию L_foo$lazy_ptr. Это значение является первоначально адресом dyld_stub_binding_helper код, после выполнения заставляющий его перезаписывать содержание L_foo$lazy_ptr с адресом реальной функции, _foo, и переход к _foo.

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

Косвенные записи символа для _foo предоставьте информацию статическим и динамическим компоновщикам для привязки тупика символа. Каждый символ тупиковая и ленивая запись указателя должен иметь точно один такой косвенный символ, связанный с первым адресом в записи указателя или тупике. См. .indirect_symbol для получения дополнительной информации.

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

На PPC тупик может относиться только к себе, один ленивый указатель символа (именующий тот же косвенный символ как тупик), и dyld_stub_binding_helper() функция.

lazy_symbol_pointers (S_LAZY_SYMBOL_POINTERS)

A lazy_symbol_pointers раздел содержит 4-байтовые указатели символа, в конечном счете содержащие значение косвенного символа, связанного с указателем. Эти указатели используются тупиками символа для ленивой привязки неопределенных вызовов функции во время выполнения. Ленивый указатель символа первоначально содержит адрес в тупике символа инструкций, заставляющих указатель символа быть связанным с функциональным определением (в примере в symbol_stubs (S_SYMBOL_STUBS), ленивый указатель L_foo$lazy_ptr первоначально содержит адрес для dyld_stub_binding_helper но перезаписывается с адресом для _foo). Редактор динамического канала связывает косвенный символ, связанный с ленивым указателем символа путем перезаписи его со значением символа.

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

non_lazy_symbol_pointers (S_NON_LAZY_SYMBOL_POINTERS)

A non_lazy_symbol_pointers раздел содержит 4-байтовые указатели символа, содержащие значение косвенного символа, связанного с указателем, который может быть установлен в любое время, прежде чем любой код делает ссылку на него. Эти указатели используются кодом для ссылки на неопределенные символы. Первоначально эти указатели не имеют никакого интересного значения, но перезаписываются редактором динамического канала со значением символа для связанного косвенного символа, прежде чем любой код сможет сделать ссылку на него.

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

Вот пример ассемблерного кода, ссылающегося на элемент в неопределенной структуре. Соответствующий код C был бы:

struct s {

        int member1, member2;

    };

    extern struct s bar;

    int func()

    {

        return(bar.member2);

    }

Ассемблерный код PowerPC мог бы быть похожим на это:

    .text

    .align 2

    .globl _func

 _func:

    lis r3,ha16(L_bar$non_lazy_ptr)

    lwz r2,lo16(L_bar$non_lazy_ptr)(r3)

    lwz r3,4(r2)

    blr

    .non_lazy_symbol_pointer

 L_bar$non_lazy_ptr:

    .indirect_symbol _bar

    .long 0

mod_init_funcs (S_MOD_INIT_FUNC_POINTERS)

A mod_init_funcs раздел содержит 4-байтовые указатели на функции, которые должны быть вызваны сразу после того, как модуль, содержащий указатель, связывается в программу редактора динамического канала. Статический редактор связей не делает никакой специальной обработки для этого типа раздела за исключением запрещения упорядочивания раздела. Это сделано для поддержания порядка, функции вызваны (который является порядком, их указатели появляются в исходном модуле). Должна быть точно одна запись перемещения для каждого указателя в этом разделе. Пример a mod_init_funcs раздел - тот, в котором компилятор генерировал код для вызова конструкторов C++ для модулей, динамично связывающихся во время выполнения.

mod_term_funcs (S_MOD_TERM_FUNC_POINTERS)

A mod_term_funcs раздел содержит 4-байтовые указатели на функции, которые должны быть вызваны непосредственно перед тем, как модуль, содержащий указатель, разгружен редактором динамического канала, или программа завершается. Статический редактор связей не делает никакой специальной обработки для этого типа раздела за исключением запрещения упорядочивания раздела. Это сделано для поддержания порядка, функции вызваны (который является порядком, их указатели появляются в исходном модуле). Должна быть точно одна запись перемещения для каждого указателя в этом разделе. Пример a mod_term_funcs раздел - тот, в котором компилятор генерировал код для вызова деструкторов C++ для модулей, динамично связывающихся во время выполнения.

объединенный (S_COALESCED)

A coalesced когда больше чем одно определение символа могло быть определено в многократных соединяемых объектных файлах, раздел может содержать любые инструкции или данные и используется. Статический редактор связей сохраняет данные связанными с объединенным символом от первого объектного файла, это соединяет и тихо отбрасывает данные от других объектных файлов. Пример a coalesced раздел - тот, в котором компилятор генерировал код для неявных инстанцирований шаблонов C++.

ни один (0)

Никакие атрибуты для этого раздела. Это - атрибут раздела по умолчанию.

S_ATTR_SOME_INSTRUCTIONS

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

no_dead_strip (S_ATTR_NO_DEAD_STRIP)

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

no_toc (S_ATTR_NO_TOC)

no_toc разделите средние значения атрибута, что глобальные символы в этом разделе не должны использоваться в оглавлении статической библиотеки, как произведено программой ranlib(1). Это обычно используется с a coalesced разделите, когда ожидается, что каждый объектный файл имеет определение символов, которые это использует.

live_support (S_ATTR_LIVE_SUPPORT)

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

pure_instructions (S_ATTR_PURE_INSTRUCTIONS)

pure_instructions припишите означает, что этот раздел содержит только машинные команды. Этот атрибут использовался бы для (__TEXT,__text) раздел компиляторов OS X и разделы, имеющие тип раздела symbol_stubs.

strip_static_syms (S_ATTR_STRIP_STATIC_SYMS)

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

self_modifying_code (S_ATTR_SELF_MODIFYING_CODE)

self_modifying_code атрибут раздела идентифицирует раздел с кодом, который может быть изменен динамическим компоновщиком. Например, тупики символа IA-32 реализованы как команды перехода, первоначально указывающие динамическому компоновщику, но изменяющиеся динамическим компоновщиком для указания на реальный символ.

.text

Это эквивалентно .section __TEXT,__text,regular,pure_instructions когда значение по умолчанию -dynamic флаг имеет силу и эквивалентный .section __TEXT,__text,regular когда -static флаг указан.

Компилятор помещает только машинные команды в (__TEXT,__text) раздел (никакие данные только для чтения, таблицы переходов или что-либо еще). С этим, все (__TEXT,__text) раздел является чистыми инструкциями и инструментами, воздействующими на объектные файлы. Время выполнения может использовать в своих интересах это, чтобы определить местоположение инструкций программы и не запутаться с данными, которые, возможно, были смешаны в. Для создания этой работы весь код поддержки во время выполнения, соединенный в программу, должен также соблюсти это правило (весь код библиотеки OS X соблюдает это правило).

.const

Это эквивалентно .section __TEXT,__const

Компилятор помещает все объявленные данные const и все таблицы переходов это генерирует для операторов переключения в этом разделе.

.static_const

Это эквивалентно .section __TEXT,__static_const

Это в настоящее время не используется компилятором. Это было добавлено к ассемблеру так, чтобы компилятор мог разделить глобальную переменную и static const данные в отдельные участки, если это хотело.

.cstring

Это эквивалентно .section __TEXT,__cstring, cstring_literals

Этот раздел отмечен с типом раздела cstring_literals, который распознает редактор связей. Редактор связей объединяет подобные литеральные струны до во всех файлах входного объекта к одной уникальной струне до в выходном файле. Поэтому этот раздел должен содержать только струны до (струна до в последовательности байтов, заканчивающейся в нулевом байте, \0, и не содержит никакие другие нулевые байты кроме его разделителя). Компилятор помещает литеральные струны до, найденные в код, которые не являются инициализаторами и не содержат, любой встроенный обнуляет в этом разделе.

.literal4

Это эквивалентно .section __TEXT,__literal4,4byte_literals

Этот раздел отмечен с типом раздела 4byte_literals, который распознает редактор связей. Редактор связей может тогда объединить подобные 4-байтовые литералы во всех файлах входного объекта к одному уникальному 4-байтовому литералу в выходном файле. Поэтому этот раздел должен содержать только 4-байтовые литералы. Это обычно предназначается для одинарной точности, константы с плавающей точкой и компилятор используют этот раздел с этой целью. На некоторой архитектуре более эффективно поместить эти константы в строку как immediates как часть инструкции.

.literal8

Это эквивалентно .section __TEXT,__literal8,8byte_literals

Этот раздел отмечен с типом раздела 8byte_literals, который распознает редактор связей. Редактор связей тогда может объединить подобные 8-байтовые литералы во всех файлах входного объекта к одному уникальному 8-байтовому литералу в выходном файле. Поэтому этот раздел должен содержать только 8-байтовые литералы. Это обычно предназначается для двойной точности, константы с плавающей точкой и компилятор используют этот раздел с этой целью. На некоторой архитектуре более эффективно поместить эти константы в строку как immediates как часть инструкции.

.literal16

Это эквивалентно .section __TEXT,__literal16,16byte_literals

Этот раздел отмечен с типом раздела 16byte_literals, который распознает редактор связей. Редактор связей может тогда объединить подобные 16-байтовые литералы во всех файлах входного объекта к одному уникальному 16-байтовому литералу в выходном файле. Поэтому этот раздел должен содержать только 16-байтовые литералы. Это обычно предназначается для векторных констант, и компилятор использует этот раздел с этой целью.

.constructor

Это эквивалентно .section __TEXT,__constructor

.destructor

Это эквивалентно .section __TEXT,__destructor

.constructor и .destructor разделы используются системой времени выполнения C++ и резервируются исключительно для компилятора C++.

.fvmlib_init0

Это эквивалентно .section __TEXT,__fvmlib_init0

.fvmlib_init1

Это эквивалентно .section __TEXT,__fvmlib_init1

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

.symbol_stub

Этот раздел имеет тип symbol_stubs и имеет атрибут pure_instructions. Компилятор помещает тупики символа в этот раздел для неопределенных функций, вызванных в модуле. Это - раздел тупика стандартного символа для непозиционно-независимого кода.

Тупики символа реализованы по-другому на PPC (и PPC64) и на IA-32. Следующие разделы описывают каждую реализацию.

        .symbol_stub

L_foo$stub:

        .indirect_symbol _foo

        lis     r11,ha16(L_foo$lazy_ptr)

        lwz     r12,lo16(L_foo$lazy_ptr)(r11)

        mtctr   r12

        addi    r11,r11,lo16(L_foo$lazy_ptr)

        bctr

        .lazy_symbol_pointer

L_foo$lazy_ptr:

        .indirect_symbol _foo

        .long   dyld_stub_binding_helper

        .section __IMPORT,__jump_table,symbol_stubs,self_modifying_code+pure_instructions,5

L_foo$stub:

        .indirect_symbol _foo

        hlt ; hlt ; hlt ; hlt ; hlt

.picsymbol_stub

В PowerPC эта директива переводит в .section __TEXT, __picsymbolstub1, symbol_stubs, pure_instructions, NBYTES.

Этот раздел имеет тип symbol_stubs и имеет атрибут pure_instructions. Компилятор помещает тупики символа в этот раздел для неопределенных функций, вызванных в модуле. Это - раздел тупика стандартного символа для позиционно-независимого кода. Значение NBYTES зависит от целевой архитектуры.

Стандартный позиционно-независимый тупик символа для PowerPC составляет 36 байтов и имеет выравнивание 4 байтов (.align 2). Например, тупик длясимвол _foo был бы (использование ленивого указателя символа L_foo$lazy_ptr):

    .picsymbol_stub

 L_foo$stub:

    .indirect_symbol _foo

    mflr r0

    bcl 20,31,L0$_foo

 L0$_foo:

    mflr r11

    addis r11,r11,ha16(L_foo$lazy_ptr - L0$_foo)

    mtlr r0

    lwz r12,lo16(L_foo$lazy_ptr - L0$_foo)(r11)

    mtctr r12

    addi r11,r11,lo16(L_foo$lazy_ptr - L0$_foo)

    bctr

.data

Это эквивалентно.section __DATA, __data

Компилятор помещает все не -const инициализируемые данные (даже инициализированный для обнуления) в этом разделе.

.static_data

Это эквивалентно.section __DATA, __static_data

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

.const_data

Это эквивалентно .section __DATA, __const, regular.

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

.lazy_symbol_pointer

Это эквивалентно.section __DATA, __la_symbol_ptr,lazy_symbol_pointers

Этот раздел имеет тип lazy_symbol_pointers и не имеет никаких атрибутов. Компилятор помещает ленивый указатель символа в этот раздел для каждого тупика символа, который это создает для неопределенных функций, вызванных в модуле. (См. .symbol_stub для примеров.) Этот раздел имеет выравнивание 4 байтов (.align 2).

.non_lazy_symbol_pointer

Это эквивалентно .section __DATA, __nl_symbol_ptr,non_lazy_symbol_pointers

Этот раздел имеет тип non_lazy_symbol_pointers и не имеет никаких атрибутов. Компилятор помещает неленивый указатель символа в этот раздел для каждого неопределенного символа, на который ссылается модуль (за исключением вызовов функции). Этот раздел имеет выравнивание 4 байтов (.align 2).

.mod_init_func

Это эквивалентно .section __DATA, __mod_init_func, mod_init_funcs

Этот раздел имеет тип mod_init_funcs и не имеет никаких атрибутов. Компилятор C++ помещает указатель на функцию в этом разделе для каждой функции, которую это создает для вызова конструкторов (если модуль имеет их).

.mod_term_func

Это эквивалентно .section __DATA, __mod_term_func, mod_term_funcs

Этот раздел имеет тип mod_term_funcs и не имеет никаких атрибутов. Компилятор C++ помещает указатель на функцию в этом разделе для каждой функции, которую это создает для вызова деструкторов (если модуль имеет их).

.dyld

Это эквивалентно .section __DATA, __dyld,regular

Этот раздел имеет тип regular и не имеет никаких атрибутов. Этот раздел используется редактором динамического канала. Компилятор ничего не помещает в этот раздел, поскольку это резервируется исключительно для редактора динамического канала.