Common Intermediate Language

Поток инструкций языка CIL

Язык CIL (Common Intermediate Language) является независимым от аппаратной платформы объектно-ориентированным ассемблером, используемым на платформе .NET для представления исполняемого кода. Для выполнения сборки .NET содержащийся в ней CIL-код переводится JIT-компилятором, входящим в состав CLR, в код конкретного процессора.

Инструкции CIL можно разделить на четыре основные группы. В первую группу входят инструкции общего назначения, которые служат для организации вычислений. Вторая группа содержит инструкции для работы с объектной моделью. Третья служит для генерации и обработки исключений. В четвертую мы относим неверифицируемые инструкции, которые генерируются, главным образом, компилятором языка C для представления небезопасных конструкций языка.

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

Формат потока инструкций

Тело метода в сборке .NET закодировано в виде потока инструкций языка CIL. Поток инструкций представляет собой массив байт, в котором размещены последовательности байт, кодирующие каждую инструкцию. При этом инструкции размещаются последовательно друг за другом без промежутков.

Если сравнить поток инструкций CIL с потоком инструкций обычного процессора, можно заметить одно очень существенное отличие. Дело в том, что обычный процессор занимается непосредственным выполнением инструкций, то есть в каждый конкретный момент времени его интересует только та инструкция, которую он в этот момент выполняет. Это означает, что поток инструкций для обычного процессора может содержать последовательности байт, не являющиеся правильными кодами инструкций, при условии, что на эти последовательности никогда не будет передано управление. Такие "неправильные" последовательности зачастую представляют собой некоторые данные (или места, зарезервированные для данных), используемые программой. Так как поток инструкций CIL предназначен для JIT-компиляции, он не может содержать "неправильных" последовательностей байт. То есть даже если поток инструкций CIL содержит "мертвые" участки, которые никогда не получат управление, эти участки должны представлять собой правильную последовательность инструкций CIL.

Разные инструкции CIL кодируются последовательностями байт различной длины. Размер каждой инструкции, а также порядок и смысл составляющих ее байт определяется описанием инструкции, которое можно найти в [3].

Формат инструкции

Последовательность байт, кодирующая инструкцию CIL, начинается с кода инструкции. Часто используемые инструкции имеют однобайтовые коды. Инструкции, которые используются реже, имеют двухбайтовые коды (при этом первый байт всегда равен 0xFE).

В разделе, посвященном виртуальной системе выполнения VES, говорилось о том, что операнды инструкций CIL размещаются на стеке вычислений. Тем не менее, многие инструкции имеют дополнительные встроенные операнды (inline operands), которые находятся прямо в потоке инструкций. Например, инструкция ldloc, загружающая на стек вычислений значение локальной переменной, имеет встроенный операнд, задающий номер переменной. А инструкция call, вызывающая метод, имеет встроенный операнд, задающий токен метаданных, по которому можно найти описание вызываемого метода. Встроенные операнды размещаются в потоке инструкций сразу после кода инструкции. В таблице 3.1 перечислены все варианты встроенных операндов. Для кодирования встроенных операндов, занимающих более одного байта и не являющихся токенами метаданных, используется порядок байт, при котором младший байт идет первым ("little-endian").

Особого внимания заслуживает встроенный операнд для инструкции switch. Эта инструкция осуществляет множественный условный переход в зависимости от некоторого целого значения, которое берется из стека вычислений. Ее встроенный операнд представляет собой массив адресов переходов. Он кодируется следующим образом: сначала идет 32-разрядное целое число без знака, обозначающее количество адресов переходов (размер массива), затем следуют сами адреса. При этом каждый адрес кодируется в виде 32-разрядного целого числа со знаком.

Рассмотрим примеры кодирования инструкций CIL:

/* 02 */ ldarg.0

/* FE 00 */ arglist

/* 1F | 10 */ ldc.i4.s 16

/* 22 | 0000803F */ ldc.r4 1.0

/* 75 | (02)00000F */ isinst System.String

/* 28 | (06)0000CD */ call System.String::Compare

Адреса переходов

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

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

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

...
target_addr:	add		; цель перехода
       		...
	        br rel_addr	; инструкция перехода
next_addr:  	...

Здесь используется инструкция безусловного перехода br. При этом в качестве цели перехода выступает инструкция add, расположенная по абсолютному адресу target_addr. Если инструкция, следующая за инструкцией br, имеет абсолютный адрес next_addr, то адрес перехода rel_addr вычисляется следующим образом:

reladdr := target_addr - next_addr

Адреса переходов кодируются во встроенных операндах инструкций перехода в виде 8-битных или 32-битных целых чисел со знаком. При этом 8-битные адреса используются в сокращенных вариантах инструкций перехода.

Ограничения на последовательности инструкций

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

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

Давайте сформулируем эти ограничения:

...
		    	br L2
		L1: 	ldc.0  ; здесь стек считается пустым
	                ...
		L2: 	br L1  ; обратный переход на L1
	                ...

Язык CIL: инструкции общего назначения

В этом разделе мы рассмотрим ту часть инструкций языка CIL, которая служит для организации вычислений, а именно:

Инструкции для загрузки и сохранения значений

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

Загрузка констант

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

Диаграмма стека для всех инструкций этой группы выглядит следующим образом:

... -> ... , constant

Работа с переменными и параметрами методов

Локальные переменные и параметры методов имеют номера от 0 до 65534. Существуют три варианта инструкций для работы с переменными и параметрами:

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

... -> ... , value

Кроме инструкций, загружающих значения переменных и параметров, существуют инструкции, загружающие на вершину стека вычислений адреса переменных и параметров (см. таблицу 3.4). Загружаемые адреса имеют тип управляемых указателей. Диаграмма стека для этих инструкций выглядит следующим образом:

... -> ... , address

Инструкции, представленные в таблице 3.5, выполняют сохранение значения на вершине стека в переменную или параметр. Они имеют следующую диаграмму стека:

... , value -> ...

Косвенная загрузка и сохранение значений

При косвенной загрузке и сохранении значений работа с памятью осуществляется через адреса (управляемые и неуправляемые указатели).

Особенностью инструкций данной группы является наличие разных инструкций для работы со значениями разных типов. Причина в том, что при загрузке или сохранении значения бывает необходимо выполнить его преобразование к другому типу, а так как JIT-компилятор в процессе компиляции не собирает информацию о типах управляемых указателей, ему надо явно указывать тип загружаемых и сохраняемых значений. Необходимость выполнения преобразований объясняется тем, что не все примитивные типы могут находиться на стеке вычислений (поэтому, например, значение типа int8 при загрузке на стек расширяется до int32 ).

В таблице 3.6 перечислены инструкции для косвенной загрузки значений. Обратите внимание, что инструкции ldind.i8 и ldind.u8 являются псевдонимами (имеют один и тот же код). Дело в том, что загрузка любых 64-разрядных целых значений на стек не вызывает их преобразования, ибо хотя на стеке не предусмотрено наличие беззнаковых 64-разрядных значений, их загрузка все равно сводится к простому побитовому копированию. Вышесказанное справедливо также и для 32-разрядных целых значений, но для их загрузки зачем-то зарезервировано сразу две инструкции.

Диаграмма стека для инструкций косвенной загрузки выглядит следующим образом:

... , address -> ... , value

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

Диаграмма стека для инструкций косвенного сохранения выглядит следующим образом:

... , address , value -> ...

Специальные инструкции для работы со стеком

В отличие от "железных" стековых процессоров, CLI не содержит развитой системы инструкций для чисто стековых манипуляций. В таблице 3.8 представлены две имеющиеся в наличии инструкции.

Арифметические инструкции

Арифметические инструкции можно разделить на четыре категории:

Бинарные арифметические операции

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

... , value1 , value2 -> ... , result

Действие бинарных операций можно записать как

result := value1 op value2,

то есть например, если op соответствует операции вычитания, то из value1 вычитается value2.

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

Тип результата бинарной операции зависит от типов операндов. Если операнды целые, то и результат будет целый. Если операнды представляют собой числа с плавающей запятой, то результатом будет являться число с плавающей запятой.

В таблице 3.9 представлены базовые инструкции, выполняющие бинарные операции.

Инструкции, представленные в таблице 3.10, используются только для целочисленных операндов. Они отличаются от базовых бинарных операций тем, что осуществляют контроль переполнения (при переполнении генерируется исключение OverflowException ).

Операции сдвига (см. таблицу 3.11) выполняют сдвиг значения первого операнда ( value1 ) в нужную сторону на количество бит, указанное во втором операнде ( value2 ).

Операции, приведенные в таблице 3.12, выполняют сравнение значений своих операндов. Результатом сравнения являются числа 0 или 1 (типа int32 ). Число 0 обозначает ложь, а число 1 - истину.

I ceq I => 1,

+inf ceq +inf => 1,
-inf ceq -inf => 1,
A ceq A => 1,

J cgt I => 1,

A cgt -inf => 1,
+inf cgt A => 1,
+inf cgt -inf => 1,
B cgt A => 1,

I clt J => 1,

A clt +inf => 1,
-inf clt A => 1,
-inf clt +inf => 1,
A clt B => 1,

L cgt.un K => 1,

NaN cgt.un C => 1,
C cgt.un NaN => 1,
A cgt.un -inf => 1,
+inf cgt.un A => 1,
+inf cgt.un -inf => 1,
B cgt.un A => 1,

K clt.un L => 1,

NaN clt.un C => 1,
C clt.un NaN => 1,
A clt.un +inf => 1,
-inf clt.un A => 1,
-inf clt.un +inf => 1,
A clt.un B => 1,

Семантика операций сравнения для чисел с плавающей запятой существенно отличается от их семантики для целых чисел. Дело в том, что числа с плавающей запятой могут дополнительно принимать значения +inf (положительная бесконечность), -inf (отрицательная бесконечность) и NaN (Not a Number - не число). Поэтому описание каждой инструкции содержит две части: для целых чисел и для чисел с плавающей запятой. При этом в описании используются следующие обозначения:

Унарные арифметические операции

В таблице 3.13 приведены две инструкции, выполняющие унарные арифметические операции. Диаграмма стека для унарных операций выглядит следующим образом:

... , value -> ... , result

Инструкция neg применима как для целых чисел, так и для чисел с плавающей запятой и обладает двумя особенностями:

Инструкция ckfinite

Инструкция ckfinite (см. таблицу 3.14) генерирует исключение ArithmeticException, если число с плавающей запятой, находящееся на вершине стека вычислений, равно NaN, +inf или -inf. Если исключение не генерируется, то стек вычислений не меняется, поэтому диаграмма стека выглядит следующим образом:

... , value -> ... , value

Преобразование значений

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

... , value -> ... , result

Базовые инструкции преобразования представлены в таблице 3.15. Они обладают следующими особенностями:

В таблице 3.16 приведены инструкции для преобразования значений, имеющих знак, к целым типам с контролем переполнения. В случае возникновения переполнения эти инструкции генерируют исключение OverflowException.

Инструкции, представленные в таблице 3.17, используются для преобразования беззнаковых значений к нужному типу и генерируют исключение OverflowException в случае переполнения.