671 читатель, 36 постов
Администрация
Модераторы
Популярным языкам — по блогу. Остальным посвящается…
Языки программирования whois
- индекс
- 130,38
Обзор LLVM
LLVM (Low Level Virtual Machine) — это универсальная система анализа, трансформации и оптимизации программ или, как её называют разработчики, «compiler infrastucture».
LLVM — не просто очередной академический проект. Его история началась в 2000 году в Университете Иллинойса, а теперь LLVM используют такие гиганты индустрии как Apple и Adobe. В частности, на LLVM основана подсистема OpenGL в MacOS X 10.5, а iPhone SDK использует GCC с бэкэндом на LLVM. Apple является одним из основных спонсоров проекта, а вдохновитель LLVM — Крис Латтнер — теперь работает в Apple.
В основе LLVM лежит промежуточное представление кода (intermediate representation, IR), над которым можно производить трансформации во время компиляции, компоновки (linking) и выполнения. Из этого представления генерируется оптимизированный машинный код для целого ряда платформ, как статически, так и динамически (JIT-компиляция). LLVM поддерживает генерацию кода для x86, x86-64, ARM, PowerPC, SPARC, MIPS, IA-64, Alpha.
LLVM написана на C++ и портирована на большинство *nix-систем и Windows. Система имеет модульную структуру и может расширяться дополнительными алгоритмами трансформации (compiler passes) и кодогенераторами для новых аппаратных платформ. Пользовательский фронтенд, как правило, линкуется с LLVM и использует C++ API для генерации кода и его преобразований. Однако LLVM включает в себя и standalone утилиты.
Для тех, кто не без оснований считает C++ не лучшим языком для написания компиляторов, с недавних пор в LLVM включена обертка API для OCaml.
Чтобы понять, что можно сделать с помощью LLVM, и на каком уровне придётся работать, давайте разберёмся, что из себя представляет LLVM IR. В одном предложении его можно охарактеризовать как типизированный трёхадресный код в SSA-форме.
Здесь и далее мы будем использовать текстовую форму записи промежуточного кода, своеобразный «ассемблер» LLVM. На практике для хранения кода используется эффективное бинарное представление (bitcode). Генерировать же код обычно удобнее всего не в текстовой форме, и тем более не в бинарной, а с помощью специального API. До биткода в этом случае может и не доходить: код формируется в виде внтуренних структур в памяти, над которыми и проводятся все операции, вплоть до генерации машинного кода.
В LLVM поддерживаются следующие примитивные типы:
Большинство инструкций в LLVM принимают два аргумента (операнда) и возвращают одно значение (трёхадресный код). Значения определяются текстовым идентификатором. Локальные значения обозначаются префиксом
Вместо утомительного перечисления инструкций (всего их 52) скажем, что LLVM поддерживает полный набор арифметических операций, побитовых логических операций и операций сдвига, а также специальные инструкции для работы с векторами.
LLVM IR строго типизирован, поэтому не обойтись без приведений типов, которые явно кодируются специальными инструкциями. Набор из 9 инструкций покрывает всевозможные приведения между различными числовыми типами: целыми и с плавающей точкой, со знаком и без, различной разрядности и пр. Кроме этого есть инструкции преобразования между целыми и указателями, а так же инструкция
Теперь должно быть понятно, как компилировать в LLVM простые выражения: каждый узел дерева выражения кроме листьев (констант и переменных) заменяется промежуточным значением-регистром — результатом инструкции, операндами которой являются дочерние узлы.
SSA (static single assignment form) — это такая форма промежуточного представления кода, в которой любое значение присваивается только один раз. Таким образом, нельзя написать:
Начнём немного издалека. Код в SSA-форме удобно рассматривать не как линейную последовательность инструкций, а как граф потока управления (control flow graph, CFG). Вершины этого графа — так называемые базовые блоки (basic blocks), содержащие последовательность инструкций, заканчивающуюся инструкцией-терминатором, явно передающей управление в другой блок. Базовые блоки в LLVM обозначаются метками, а терминаторами являются следующие инструкции:
В LLVM этой функции соответствует инструкция phi, которая имеет следующую форму:
Здесь, наверное, многие воскликнут: но это же ужасно неудобно! Действительно, хотя SSA-форма позволяет производить много полезных трансформаций, непосредственно генерировать её из кода на императивном языке затруднительно, хотя есть хорошо известные алгоритмы преобразования в SSA. К счастью, при написании компилятора на основе LLVM нет никакой необходимости заниматься этим, потому что система умеет генерировать SSA самостоятельно. Как и из чего, мы сейчас узнаем.
Помимо значений-регистров, в LLVM есть и работа с памятью. Значения в памяти адресуются типизированными указателями, о которых мы говорили выше. Обратиться к памяти можно только с помощью двух инструкций, названия которых говорят сами за себя:
Инструкция
А вот инструкция alloca незаменима и очень важна. Она имеет такой же формат, но выделяет память на стеке.
С помощью
Хорошая новость в том, что из подобного кода LLVM умеет строить SSA-форму. Этот процесс называется «promote memory to register». Вот что получится из функции
Массивы в LLVM очень похожи на таковые в Си, но адресной арифметики, как в Си, нет. То есть нельзя написать:
Есть очень похожая на
Ряд примитивов представляются в LLVM не инструкциями, а встроенными функциями (intrinsic functions). Например, некоторые математические функции:
Интересно то, что вызовы этих функций в промежуточном коде вовсе не обязаны превращаться в вызовы функций в машинном коде, или даже в инлайн-подстановки функций. Они могут просто нести служебную информацию для какой-то подсистемы компилятора. Например, так организована генерация отладочной информации в формате DWARF: в IR вставляются вызовы функций
Аналогичным образом реализована поддержка сборки мусора. LLVM не содержит какого-либо алгоритма сборки мусора, вместо этого предоставляя интерфейс для написания собственного точного GC. Примитивы
Просто перечислим часть алгоритмов. Все они платформо-независимы и преобразуют IR. Проходы оптимизатора могут быть вызваны независимо в нужном порядке.
Из этого краткого обзора видно, что промежуточное представление LLVM достаточно близко соответствует коду на низкоуровневых процедурных языках вроде Си. Транслятор Си на основе LLVM будет достаточно прост и прямолинеен, но при этом сгенерированный им машинный код по производительности сможет тягаться с последними версиями GCC.
При трансляции высокоуровневых языков — объектно-ориентированных, функциональных, динамических — придётся выполнить гораздо больше промежуточных преобразований, а также написать специализированный рантайм. Но и в этом случае LLVM снимает с разработчика компилятора проблемы кодогенерации для конкретной платформы, берёт на себя большинство независимых от языка оптимизаций — и делает их качественно. Помимо этого, мы получаем готовую инфраструктуру для JIT-компиляции и возможность link-time оптимизации между различными языками, компилируемыми в LLVM.
LLVM пытается достичь баланса между удобством и гибкостью, не навязывая какую-то конкретную парадигму программирования, не ограничивая систему типов.
Полноценный фронтенд на сегодняшний день существуют только для C, C++, Ada и Fortran — это llvm-gcc. Идёт работа по созданию независимого от GCC компилятора C/C++ — clang. Оба проекта поддерживаются основной командой LLVM.
Остальные проекты компиляторов известных языков на базе LLVM пока не достигли уровня практической применимости. Но перспективы заманчивы. Увидим ли мы компилятор современного функционального или динамического (PyPy?) языка на LLVM — покажет время.
продолжение следует…
LLVM — не просто очередной академический проект. Его история началась в 2000 году в Университете Иллинойса, а теперь LLVM используют такие гиганты индустрии как Apple и Adobe. В частности, на LLVM основана подсистема OpenGL в MacOS X 10.5, а iPhone SDK использует GCC с бэкэндом на LLVM. Apple является одним из основных спонсоров проекта, а вдохновитель LLVM — Крис Латтнер — теперь работает в Apple.
В основе LLVM лежит промежуточное представление кода (intermediate representation, IR), над которым можно производить трансформации во время компиляции, компоновки (linking) и выполнения. Из этого представления генерируется оптимизированный машинный код для целого ряда платформ, как статически, так и динамически (JIT-компиляция). LLVM поддерживает генерацию кода для x86, x86-64, ARM, PowerPC, SPARC, MIPS, IA-64, Alpha.
LLVM написана на C++ и портирована на большинство *nix-систем и Windows. Система имеет модульную структуру и может расширяться дополнительными алгоритмами трансформации (compiler passes) и кодогенераторами для новых аппаратных платформ. Пользовательский фронтенд, как правило, линкуется с LLVM и использует C++ API для генерации кода и его преобразований. Однако LLVM включает в себя и standalone утилиты.
Для тех, кто не без оснований считает C++ не лучшим языком для написания компиляторов, с недавних пор в LLVM включена обертка API для OCaml.
Чтобы понять, что можно сделать с помощью LLVM, и на каком уровне придётся работать, давайте разберёмся, что из себя представляет LLVM IR. В одном предложении его можно охарактеризовать как типизированный трёхадресный код в SSA-форме.
Здесь и далее мы будем использовать текстовую форму записи промежуточного кода, своеобразный «ассемблер» LLVM. На практике для хранения кода используется эффективное бинарное представление (bitcode). Генерировать же код обычно удобнее всего не в текстовой форме, и тем более не в бинарной, а с помощью специального API. До биткода в этом случае может и не доходить: код формируется в виде внтуренних структур в памяти, над которыми и проводятся все операции, вплоть до генерации машинного кода.
Типы данных
В LLVM поддерживаются следующие примитивные типы:
- Целые числа произвольной разрядности:
Генерация машинного кода для типов очень большой разрядности не поддерживается. Например, для x86 вам придётся ограничитьсяi1 ; булево значение — 0 или 1
i32 ; 32-разрядное целое
i17 ; даже так
i256 ; ого!i64, а для x86-64 и других 64-разрядных платформ — 128-битными целыми. Но для промежуточного представления никаких ограничений нет.
Числа считаются представленными в дополнительном коде. Различий между знаковыми и беззнаковыми целыми на уровне типов не делается: в тех случаях, когда это имеет значение, с ними работают разные инструкции.
- Числа с плавающей точкой:
float,double, а также ряд типов, специфичных для конкретной платформы (например,x86_fp80). void— пустое значение.
- Указатели
тип*
i32* ; указатель на 32-битное целое
- Массивы
[число элементов x тип]
[10 x i32]
[8 x double]
- Структуры
{ i32, i32, double } - Вектор — специальный тип для упрощения SIMD-операций. Вектор состоит из 2n значений примитивного типа — целого или с плавающей точкой.
< число элементов x тип >
< 4 x float >
- Функции
i32 (i32, i32)
float ({ float, float }, { float, float })
Операции
Большинство инструкций в LLVM принимают два аргумента (операнда) и возвращают одно значение (трёхадресный код). Значения определяются текстовым идентификатором. Локальные значения обозначаются префиксом
%, а глобальные — @. Локальные значения также называют регистрами, а LLVM — виртуальной машиной с бесконечным числом регистров. Пример:%sum = add i32 %n, 5
%diff = sub double %a, %b
%z = add <4 x float> %v1, %v2 ; поэлементное сложение
%cond = icmp eq %x, %y ; Сравнение целых чисел. Результат имеет тип i1.
%success = call i32 @puts(i8* %str)
Вместо утомительного перечисления инструкций (всего их 52) скажем, что LLVM поддерживает полный набор арифметических операций, побитовых логических операций и операций сдвига, а также специальные инструкции для работы с векторами.
LLVM IR строго типизирован, поэтому не обойтись без приведений типов, которые явно кодируются специальными инструкциями. Набор из 9 инструкций покрывает всевозможные приведения между различными числовыми типами: целыми и с плавающей точкой, со знаком и без, различной разрядности и пр. Кроме этого есть инструкции преобразования между целыми и указателями, а так же инструкция
bitcast, которая приведёт всё ко всему, но за результат вы отвечаете сами.Теперь должно быть понятно, как компилировать в LLVM простые выражения: каждый узел дерева выражения кроме листьев (констант и переменных) заменяется промежуточным значением-регистром — результатом инструкции, операндами которой являются дочерние узлы.
; x = (a + b) * c - d / e
%tmp1 = add float %a, %b
%tmp2 = mul float %tmp1, %c
%tmp3 = fdiv float %d, %e
%x = sub float %tmp2, %tmp3
SSA
SSA (static single assignment form) — это такая форма промежуточного представления кода, в которой любое значение присваивается только один раз. Таким образом, нельзя написать:
%z = sum i32 %x, %y
%z = sum i32 %z, 5
%z.1 = sum i32 %z, 5 Начнём немного издалека. Код в SSA-форме удобно рассматривать не как линейную последовательность инструкций, а как граф потока управления (control flow graph, CFG). Вершины этого графа — так называемые базовые блоки (basic blocks), содержащие последовательность инструкций, заканчивающуюся инструкцией-терминатором, явно передающей управление в другой блок. Базовые блоки в LLVM обозначаются метками, а терминаторами являются следующие инструкции:
ret тип значение— возврат значения из функции
br i1 условие, label метка_1, label метка_2— условный переход. Например:
(Синтаксис определения функции, думаю, очевиден).define float @max(float %x, float %y)
{
%cond = fcmp ogt float %x, %y
br i1 %cond, label %IfTrue, label %IfFalse
IfTrue:
ret float %x
IfFalse:
ret float %y
}
Есть также форма безусловного перехода:
br label меткаswitch— обобщениеbr, позволяет организовать таблицу переходов:
switch i32 %n, label %Default, [i32 0, label %IfZero i32 5, label %IfFive]invokeиunwind— используются для организации исключений, в этой статье останавливаться на них мы не будем.
unreachable— специальная инструкция, показывающая компилятору, что выполнение никогда не достигнет этой точки. Например, эта инструкция может быть вставлена после вызова системной функции завершения процесса.
В LLVM этой функции соответствует инструкция phi, которая имеет следующую форму:
phi тип, [значение_1, label метка_1], ..., [значение_N, label метка_N] int factorial(int n)
{
int result = n;
int i;
for (i = n - 1; i > 1; --i)
result *= i;
return result;
}
%0.define i32 @factorial(i32 %n)
{
%i.start = sub i32 %n, 1
br label %LoopEntry
LoopEntry:
%result = phi i32 [%n, %0], [%result.next, %LoopBody]
%i = phi i32 [%i.start, %0], [%i.next, %LoopBody]
%cond = icmp sle i32 %i, 1
br i1 %cond, label %Exit, label %LoopBody
LoopBody:
%result.next = mul i32 %result, %i
%i.next = sub i32 %i, 1
br label %LoopEntry
Exit:
ret i32 %result
} Здесь, наверное, многие воскликнут: но это же ужасно неудобно! Действительно, хотя SSA-форма позволяет производить много полезных трансформаций, непосредственно генерировать её из кода на императивном языке затруднительно, хотя есть хорошо известные алгоритмы преобразования в SSA. К счастью, при написании компилятора на основе LLVM нет никакой необходимости заниматься этим, потому что система умеет генерировать SSA самостоятельно. Как и из чего, мы сейчас узнаем.
Память
Помимо значений-регистров, в LLVM есть и работа с памятью. Значения в памяти адресуются типизированными указателями, о которых мы говорили выше. Обратиться к памяти можно только с помощью двух инструкций, названия которых говорят сами за себя:
load и store. Например:%x = load i32* %x.ptr ; загрузили значение типа i32 по указателю %x.ptr
%tmp = add i32 %x, 5 ; прибавили 5
store i32 %tmp, i32* %x.ptr ; и положили обратно
Инструкция
malloc транслируется в вызов одноименной системной функции и выделяет память на куче, возвращая значение — указатель определенного типа. В паре с ней конечно же идёт инструкция free.%struct.ptr = malloc { double, double }
%string = malloc i8, i32 %length
%array = malloc [16 x i32]
free i8* %string
malloc нет, но разработчики признаются, что особого смысла в её существовании сейчас не имеется. Вы можете вызвать вместо неё функцию @malloc или написать свою собственную функцию-аллокатор, отвечающую каким-то особым требованиям.А вот инструкция alloca незаменима и очень важна. Она имеет такой же формат, но выделяет память на стеке.
%x.ptr = alloca double ; %x.ptr имеет тип double*
%array = alloca float, i32 8 ; %array имеет тип float*, а не [8 x float]!
alloca, автоматически освобождается при выходе из функции при помощи инструкций ret или unwind.С помощью
alloca, load и store мы можем пользоваться локальными переменными так же, как и в любом императивном языке. Например, наша многострадальная функция факториала:define i32 @factorial(i32 %n)
{
%result.ptr = alloca i32 ; выделить память под result
%i.ptr = alloca i32 ; и под i
store i32 %n, i32* %result.ptr ; инициализация result = n
%tmp1 = sub i32 %n, 1
store i32 %tmp1, i32* %i.ptr ; i = n - 1
br label %Loop
Loop:
%i = load i32* %i.ptr ; загружаем значение i
%cond = icmp sle i32 %i, 1 ; и проверяем условие i <= 1
br i1 %cond, label %Exit, label %LoopBody ; если да, переход к возврату значения
LoopBody:
%tmp2 = load i32* %result.ptr
%tmp3 = mul i32 %tmp2, %i
store i32 %tmp3, i32* %result.ptr ; result *= i
%i.next = sub i32 %i, 1
store i32 %i.next, i32* %i.ptr ; --i
br label %Loop
Exit:
%result = load i32* %result.ptr
ret i32 %result ; return result
}
Хорошая новость в том, что из подобного кода LLVM умеет строить SSA-форму. Этот процесс называется «promote memory to register». Вот что получится из функции
factorial после прохода этого алгоритма:define i32 @factorial(i32 %n) {
; <label>:0
%tmp1 = sub i32 %n, 1
br label %Loop
Loop:
%i.ptr.0 = phi i32 [ %tmp1, %0 ], [ %i.next, %LoopBody ]
%result.ptr.0 = phi i32 [ %n, %0 ], [ %tmp3, %LoopBody ]
%cond = icmp sle i32 %i.ptr.0, 1
br i1 %cond, label %Exit, label %LoopBody
LoopBody:
%tmp3 = mul i32 %result.ptr.0, %i.ptr.0
%i.next = sub i32 %i.ptr.0, 1
br label %Loop
Exit:
ret i32 %result.ptr.0
}
Операции с указателями
Массивы в LLVM очень похожи на таковые в Си, но адресной арифметики, как в Си, нет. То есть нельзя написать:
%ptr = add i32* %array, i32 %index getelementptr.%array = alloca i32, i32 %size
%ptr = getelementptr i32* %array, i32 %index ; значение типа i32*
getelementptr только вычисляет адрес, но не обращается к памяти. Инструкция принимает произвольное количество индексов и может разыменовывать структуры любой вложенности. Например, из следующего кода на Си:struct s {
int n;
char *a[4];
};
struct *s = ...;
char c = s->a[2][5];
%ptr = getelementptr { i32, [4 x i8*] }* %s, i32 1, i32 2, i32 5
%c = load i8* %ptr
Есть очень похожая на
getelementptr пара инструкций extractvalue и insertvalue. Они отличаются тем, что принимают не указатель на агрегатный тип данных (массив или структуру), а самое значение такого типа. extractvalue возвращает соответственное значение подэлемента, а не указатель на него, а insertvalue порождает новое значение агрегатного типа.%n = extractvalue { i32, [4 x i8*] } %s, 0
%tmp = add i32 %n, 1
%s.1 = insertvalue { i32, [4 x i8*] } %s, i32 %tmp, 0
Встроенные функции и аннотации
Ряд примитивов представляются в LLVM не инструкциями, а встроенными функциями (intrinsic functions). Например, некоторые математические функции:
@llvm.sqrt.*, @llvm.sin.* и т. д. Есть также примитивы для атомарных операций и некоторые другие.Интересно то, что вызовы этих функций в промежуточном коде вовсе не обязаны превращаться в вызовы функций в машинном коде, или даже в инлайн-подстановки функций. Они могут просто нести служебную информацию для какой-то подсистемы компилятора. Например, так организована генерация отладочной информации в формате DWARF: в IR вставляются вызовы функций
%llvm.dbg.stoppoint (задаёт соответствие между строками исходного кода и генерируемым кодом), %llvm.dbg.declare (задаёт описание локальной переменной) и др., в качестве аргументов которым передаются указатели на специальные структуры.Аналогичным образом реализована поддержка сборки мусора. LLVM не содержит какого-либо алгоритма сборки мусора, вместо этого предоставляя интерфейс для написания собственного точного GC. Примитивы
@llvm.gcroot, @llvm.gcread и @llvm.gc.write позволяют закодировать информацию, необходимую для работы GC, а интерфейс плагина к компилятору LLVM — сгенерировать по этой информации нужные структуры данных и вставить обращения к рантайму.Что умеет оптимизатор LLVM
Просто перечислим часть алгоритмов. Все они платформо-независимы и преобразуют IR. Проходы оптимизатора могут быть вызваны независимо в нужном порядке.
- Удаление неиспользуемого кода (dead code elimination).
- Выделение одинаковых подвыражений (common subexpression elimination).
- Распространение констант (constant propagation, condition propagation).
- Инлайн-подстановка функций.
- Разворот хвостовой рекурсии. LLVM также умеет в некоторых случаях разворачивать не хвостовые рекурсивные вызовы за счёт ввода дополнительной переменной-аккумулятора, как это зачастую делают в функциональных языках. Например, в этой функции рекурсивный вызов будет успешно заменён условным переходом.
int factorial(int n)
{
if (n < 2) return 1;
return n * factorial(n - 1);
}
- Раскрутка и размыкание циклов, вынос инвариантов за пределы цикла.
Вместо заключения
Из этого краткого обзора видно, что промежуточное представление LLVM достаточно близко соответствует коду на низкоуровневых процедурных языках вроде Си. Транслятор Си на основе LLVM будет достаточно прост и прямолинеен, но при этом сгенерированный им машинный код по производительности сможет тягаться с последними версиями GCC.
При трансляции высокоуровневых языков — объектно-ориентированных, функциональных, динамических — придётся выполнить гораздо больше промежуточных преобразований, а также написать специализированный рантайм. Но и в этом случае LLVM снимает с разработчика компилятора проблемы кодогенерации для конкретной платформы, берёт на себя большинство независимых от языка оптимизаций — и делает их качественно. Помимо этого, мы получаем готовую инфраструктуру для JIT-компиляции и возможность link-time оптимизации между различными языками, компилируемыми в LLVM.
LLVM пытается достичь баланса между удобством и гибкостью, не навязывая какую-то конкретную парадигму программирования, не ограничивая систему типов.
Полноценный фронтенд на сегодняшний день существуют только для C, C++, Ada и Fortran — это llvm-gcc. Идёт работа по созданию независимого от GCC компилятора C/C++ — clang. Оба проекта поддерживаются основной командой LLVM.
Остальные проекты компиляторов известных языков на базе LLVM пока не достигли уровня практической применимости. Но перспективы заманчивы. Увидим ли мы компилятор современного функционального или динамического (PyPy?) языка на LLVM — покажет время.
продолжение следует…
комментарии (20)
В среднем одинаково с GCC 4.
В их собственной системе «ночного» тестирования есть тесты из SPEC CPU, но самих результатов SPEC я не видел.
То есть, в трёх словах, конечный пользователь имеет возможность код на С/С++ компилить сразу под несколько архитектур с оптимизацией, которая учитывает особенности этих архитектур. Я правильно всё понял?
Сорри, что много вопросов — вещь интересная, копать некогда :-)
llvm-gcc — это мощнейший стресс-тест для LLVM и способ интеграции существующего кода на C/C++. Просто как компилятор C++ особых преимуществ перед GCC он не имеет.
С помощью LLVM можно оптимизировать программы не только при развёртывании, но и в рантайме — оптимизация «горячих» участков кода. Это особенно актуально для динамических языков.
или LLVM непригодно для JIT-компилятора?
P.S. а что не в тематическом блоге?
Судя по всему, когда Mono начинал развиваться, возможности LLVM были неадекватными: комент на LtU разработчика Mono.
Сейчас идёт работа над реализацией CLR и JVM поверх LLVM: VMKit
> или LLVM непригодно для JIT-компилятора?
Ещё как пригодно, возможность заложена изначально.
> а что не в тематическом блоге?
Не придумал в какой.
просто топики в личных блогах на главную не попадают
от себя могу добавить что именно через LLVM идет компиляция C/C++ в AS3 в адобовской алхимии и там действительно все очень поразительно шоколадно получается.
В общем штука офигительно перспективная. И есть надежда что адобе продвинет ее достаточно далеко. Дажешь ОШЕ любому скриптовому языку за 5 копеек! :)
connect.microsoft.com/Phoenix
Взять тот же кэш процессора — он как-то задействуется?
Теории по JIT'у навалом, но это либо радостные возгласы, либо констатация фактов: «теперь у нас есть такая крутая штука», более никаких подробностей. Да, есть исходники, но их разбор шибко тяжкий труд.
Instruction cache задействуется в любом случае, какие тут нужны дополнительные телодвижения?
>>Instruction cache задействуется в любом случае, какие тут нужны дополнительные телодвижения?
Понятия не имею, поэтому и спросил.
Насчёт исключений: invoke позволяет вызвать функцию, задав две точки продолжения: нормальную и ту, куда попадёт управление, если где-то в цепочке вызовов встретится unwind. Всё остальное — забота рантайма. Помимо документации здесь бывает полезно посмотреть на вывод llvm-g++ --emit-llvm — во что он превращает те или иные конструкции.