Язык C с двумя минусами, или Как ассемблер стал портабельным

Андрей Кухар, Издательский Дом "КОМИЗДАТ"

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

In abstracto

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

Что ж, выполнив виртуальную функцию ассоциации и тем самым преобразовав популярное биологическое понятие к теме нашего сегодняшнего разговора о новой, уникальной и по-своему революционной разработке, попробуем просеять через "сито объективности и краткости" доступную документацию и оставить лишь как можно более яркие концептуальные особенности нашего гибрида.

Отдаленная гибридизация двух различных технологий программирования произвела на этот информационный свет C-- - новый язык программирования, специально спроектированный как портабельный ассемблер, квинтэссенция обычного "сборщика" (первоначальное перевод слова assembler) и С.

Ab initio

Сначала - вкратце о причинах, мотивациях, побуждениях и, разумеется, проблемах, приведших к появлению этого языка. Короче говоря: почему и зачем сдалось обычно крайне занятым западным буржуазным умам (читай - программистам) тратить свое драгоценное время, измеряемое в человеко-годах (man-year), на разработку очередного мало кому известного языка программирования электронно-вычислительных машин с приблизительным порядковым номером в "несколько_(десятков) тысяч_с_чем-то".

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

Другие "творцы" пробуют использовать язык С в роли портабельного ассемблера. К сожалению, С никогда не претендовал на такую роль - он язык программирования, а не язык ассемблера. Разница есть - и довольно основательная. C ограничивает реализацию в конкретном соглашении вызовов, делает невозможными вычисления целей переходов (targets of jumps), не обеспечивает поддержку сборки мусора (garbage collection) и владеет весьма скудной поддержкой исключений (exception handling) или отладки. (Приведенные утверждения не стоит понимать как критику C - просто этот язык разрабатывался для несколько других целей.)

Слова эти не были пустым звуком для гарвардской команды исследователей: Джона Диаса (John Dias), Рубена Олински (Reuben Olinsky), Кристиана Лайндига (Christian Lindig), Кэвина Ридуайна (Kevin Redwine), Нормана Рэмзи (Norman Ramsey), работавших в сотрудничестве с Саймоном Пэйтоном Джонсом (Simon Peyton Jones) из Microsoft Research в Кембридже,- которые успешно запустили в свет концепцию совершенно нового портабельного ассемблера.

Ad rem

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

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

Управляющие конструкции goto (по отношению к C-- стоит пересмотреть свои убеждения, продиктованные чистой верой в непогрешимость Великого Эдсгера В. Дэйкстры (Edsger W. Dijkstra) насчет вреда данного оператора) и if - абстракции потока управления. Последняя скрывает машинные "коды условий"; расширенные условия представляют собой произвольные булевы (логические) выражения.

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

Переменные C-- выступают в роли абстракций регистров. C-- пытается, насколько это возможно, хранить все переменные в регистрах CPU, если же они туда не помещаются (ввиду превышения лимита дозволенного объема), то идут в основную память. Абстракция скрывает количество и метод использования стандартных регистров вычислительной системы.

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

Клиент C-- состоит из двух частей: компилятора с языка высокого уровня - front-end, и перенастраиваемого (retargetable) генератора кода - back-end. Предполагается, что исполняемая программа разделена на три составляющие, каждая из которых может размещаться в объектных файлах, библиотеках или их комбинациях.

Компилятор front-end транслирует высокоуровневый исходный текст программы в один или более модулей C--, которые после сепаратно транслируются компилятором C-- в генерируемый объектный код. Front-end входит в front-end run-time систему, включающую сборщик мусора, обработчик исключений и другие средства, которые необходимы исходному языку. Сама программа пишется на языке программирования, предназначенном для людей, а не на C--.

С каждой реализацией C-- поставляется run-time система; основная цель системы - поддержка и обеспечение доступа к информации, которая может быть известна только генератору кода. Она делает доступной эту информацию для front-end run-time системы посредством C-- run-time интерфейса. Различные front-ends могут взаимодействовать с одной C-- run-time системой. Для формирования исполняемой программы сгенерированный объектный код связывается с обеими run-time системами.

В общих чертах, C-- может поддерживать высокоуровневые run-time сервисы, к примеру сборки мусора, следующим образом. Сначала управление передается front-end run-time системе. Сборщик мусора проходит стек C--, вызывая программы доступа (процедуры) из run-time системы языка; в каждой активизационной записи стека он, используя дальнейшие процедуры (представляемые C-- run-time), находит размещение каждой переменной. (Хотя следует отметить, что C-- run-time не известно, в какой из переменных хранится указатель.)

Front-end компилятор формирует статически распределяемый блок данных, идентифицирующий переменные указателей, и использует директиву span, чтобы ассоциировать этот блок данных с соответствующей областью процедуры программных счетчиков. Сборщик мусора совмещает эти два источника информации для выбора процедурной переменной как корня.

Используя run-time интерфейс, front-end run-time система может проверять и модифицировать состояние приостановленных вычислений. Вместо определения представительств приостановленных вычислений или активизационных записей, они скрыты за простыми абстракциями. Эти абстракции присутствуют в front-end run-time системе в виде набора C-процедур (подпрограмм, написанных на языке C).

Камнем преткновения для разработчиков языка стала легкость в перенастройке front-ends, а не в возможности запуска всех программ на C-- везде. Несмотря на то, что любая C-- программа имеет, независимо от машины, отчетливо выраженную семантику, высокоуровневому компилятору, транслирующему исходную программу для двух целевых архитектур, необходимо сгенерировать две разные C-- программы. Например, программа, сгенерированная для машины с командами с плавающей запятой, будет отличаться от программы, сгенерированной для машины без плавающей запятой.

Вышеописанный камень сильно контрастирует с моделью "write-once, run-anywhere" (в свободном переводе: однократная компиляция с возможностью выполнения на различных архитектурах) и форматами распространения наподобие Java class files, Juice files и ANDF или TenDRA. Такие форматы представляют собой абстракции высокоуровневых языков, а не используемых машин. Их цель состоит в бинарной портабельности, они удерживают достаточно семантик высокоуровневого языка для разрешения эффективной компиляции на удаленной точке инсталляции.

Даже если C-- и обличает некоторые архитектуро-специфические детали, вроде размера слов, вся конструкция все же направлена на скрытие этих деталей. В результате задание front-end части, в целом и общем, не зависит от целевой архитектуры. Следовательно, пригодная реализация C-- должна делать надежную архитектуро-независимую работу:

• распределение регистров;
• выборка команд, использование сложных команд и режимов адресации;
• планирование команд;
• формат стекового фрейма;
• классические back-end оптимизации, наподобие устранения общих подвыражений и распространения копий;
• "условная" конструкция if для утвержденных архитектур.

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

Differentia specifica

Чтобы более детально разобраться с некоторыми отличительными особенностями C--, рассмотрим пример трех процедур (sp1, sp2, sp3), вычисляющих сумму и произведение целых чисел от 1 до n.

/* Обычная рекурсия */
sp1(word4 n) {
word4 s, p;
if n == 1 {
return (1, 1);
} else {
s, p = sp1(n-1);
return (s+n, p*n);
}
}

/* Tail-рекурсия */
sp2(word4 n) {
jump sp2_help (n, 1, 1);
}

sp2_help (word4 n, word4 s, word4 p) {
if n==1 {
return (s, p);
} else {
jump sp2_help (n-1, s+n, p*n)
}
}

/* Циклы */
sp3(word4 n) {
word4 s, p;
s = 1; p = 1;

loop:
if n==1 {
return (s, p);
} else {
s = s+n;
p = p*n;
n = n-1;
goto loop;
}
}

Процедуры. Несмотря на то, что подпрограммы C-- могут возвращать значения, для них используется термин "процедуры", а не "функции". Термин "функция" более соответствует чистым математическим функциям, т. е. соответствию y=f (x) между переменными величинами, в силу которого каждому рассматриваемому значению некоторой величины x - аргумента (или независимой переменной) соответствует определенное значение другой величины y - функции (или зависимой переменной).

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

Пример возвращения множественных результатов: все sp-процедуры примера возвращают два результата: сумму - s+n и произведение - p (n. Оператор return получает ноль или более параметров, просто как процедурный вызов; и вызов может передавать множественные результаты, как видно в рекурсивном вызове sp1. Такая способность множественных результатов довольно полезна и, к тому же, легка в реализации.

Начальный вызов. Процедура main (), которая первой вызывается при исполнении кода в C, здесь отсутствует (NB). Взамен: каждая компиляционная единица C-- (файл, содержащий полную C-- программу, которая может быть скомпилирована и пригодна для компоновки) рассматривается как набор процедур и меток. Процедуры, описанные внутри компиляционной единицы, не имеют иерархии и могут вызываться за ее пределами при условии, что они экспортированы и что соглашение о вызове известно. Тогда способ ввода кода C-- состоит в вызове процедур C-- из программ, написанных на других языках. Метки допускают доступ к распределяемым данным другим программам.

Типы. По сравнению со стандартными ассемблерами, C-- выделяется очень слабой и по-своему ненадежной системой типизации, исключительная цель которой состоит в сообщении генератору кода того, насколько велико каждое значение и какой класс операций может над ним выполняться. C-- поддерживает лишь минимум типов данных: семейство word-типов (word8, word16, word32, word64) и семейство типов с плавающей запятой (или, как их чаще величают по-математически, "действительными": float32, float64, float80). Эти типы кодируют только размер (в битах) и тип регистра (общего назначения или с плавающей запятой), необходимых для размещения/хранения данных. Значения с плавающей запятой могут размещаться в различных банках регистров. Не все типы данных доступны для каждой машины. Word-типы используются для символов, битовых векторов, целых чисел и указателей. На каждой машине один из word-типов (типично word32 или word64) определяется native-размером слов машины. Второй тип данных также определяется native-указателем типов. Экспортируемые и импортируемые имена должны иметь native-указатель на тип.

Tail-вызовы. C-- обеспечивает оптимизацию tail-вызовов - даже между отдельно скомпилированными модулями. В процедуре sp2_help, к примеру, tail-вызовы реализуют простой цикл без стекового прироста. Процедура sp2 вызывает sp2_help, которая возвращается непосредственно к вызывающему оператору sp2. Tail-вызов может рассматриваться как "параметры отправки jump-операторов".

Локальные переменные. C-- допускает объявление произвольного количества локальных переменных (именуемых также виртуальными регистрами). Объявления очень схожи на таковые в C: список однотипных имен переменных предваряется типом.

Предполагается, что, если локальных переменных не слишком много, то все они отображаются на регистры. В sp3, например, локальные переменные s и p - определенно регистро-размещаемые, и для них никогда не резервируются стековые слоты.

Метки. C-- работает с локальными метками и операторами goto (см. sp3). Метка находится не в любом месте области, а лишь в теле собственной процедуры, и она не является значением первого класса. Метка может использоваться только как объект оператора goto, и только метка может быть аргументом goto. Для всех других переходов используются tail-вызовы.

Условности. В C-- есть поддержка выражений условий, но, в отличие от C, здесь нет булевого (логического) типа (в C как булев тип используется int). Взамен, условности синтаксически включают операции сравнения, вроде ==,!=, <, <=, >, >= и т.п. (они названы операциями а не операторами - потому что им дозволено появляться лишь в условных тестах if, а не внутри выражений - как операторам C - - ).

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

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

Импорт/экспорт. В общем, любая процедура или метка, объявленная в компиляционной единице C--, может вызывать или ссылаться на, соответственно, прочие единицы или подпрограммы других языков программирования. Все имена, используемые за пределами компиляционной единицы C--, должны явно экспортироваться. Подобно этому, имена, используемые, но не объявленные в компиляционной единице, должны явно импортироваться. За импорт и экспорт имен отвечают объявления import и export соответственно.

Ad examplar:

/* program1.c-- */
import f, la;
export g;

g (bits8 x) {
x = f (la+4);
return (x);
}

/* program2.c-- */
export f, la, lb;
data {la: bits32{0};
lb: bits8{'\n'};
lc: bits8;
}
import g;
f (bits8 x) {return (x);}

Здесь: компиляционная единица program1.c-- импортирует из program2.c-- имя процедуры f и имя метки la - оба используются в операторе вызова. Импорт успешен, поскольку оба f и la были экспортированы из program2.c--. Стоит отметить, что program1.c-- не сможет импортировать метку lc из program2.c-- - вследствие того что имя g импортировано program2.c--, но не используется, а lb экспортировано program2.c--, но не импортировано program1.c--.

Гибрид дает возможность ассоциировать высокоуровневый компилятор с ипостасью проинициализированных данных и диапазоном исходных областей C-- и определять альтернативные продолжения (alternate continuations) для вызовов подпрограмм, которые могут допускать исключения. Взятая на вооружение поддержка run-time представляет собой интерфейс (который определен в C), способный использовать сборщик мусора, механизм исключений и отладчик - для получения доступа как к высоко-, так и к низкоуровневой информации. Как результат: программа на C-- приостанавливается в безопасной точке. Высоко- и низкоуровневая информация согласовывается со значениями диапазонов C-- и общей нумерацией переменных. Наконец, оптимизатор C-- действует над ограничениями, так что, пока исполнение приостановлено, отладчик или сборщик мусора могут изменять значения локальных переменных, и процедурный вызов с альтернативными продолжениями может возвращаться более чем в одну позицию. Трехуровневое решение проблемы также обеспечивает требуемую поддержку для параллелизма.

Ad usum

Сегодня наиболее активные работы ведутся над компилятором и интерпретатором Quick C--. Компилятор написан на языке функционального программирования Objective Caml и инструментальном средстве так называемого грамотного (literate) программирования Noweb. Документация Quick C-- представлена в формате системы допечатной подготовки LaTeX. Процесс сборки Quick C-- управляется портом программы mk (аналог make в операционных системах Plan 9 и Inferno).

Для сборки компилятора из исходных текстов (ибо лишь в таком виде он распространяется) требуется наличие таких пакетов, как: Objective Caml 3.04 или выше, Noweb 2.9 или выше, LaTeX и POD-утилиты Perl (точнее - pod2man).

Дабы получить интерпретатор, реализованный на C, вам дополнительно потребуются компилятор ANSI C (стандарт de facto - GCC - подходит) и пакет языка программирования Lua 4.0, включая библиотеку и заголовочные файлы.

Quick C-- доступен как в виде tarball-файлов, так и в виде исходного дерева посредством анонимного Rsync-сервера.

Кроме Quick C--, есть еще несколько проектов компиляторов:

cmmc Фермина Рэйга (Fermin Reig), написанный на языке Standard ML;

Trampoline C-- Compiler Сергея Егорова (Sergei Egorov);

Oregon C-- Compiler - первый прототип реализации C--.

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

Panem et circenses

Вот и еще одна серебряная пуля нашла свое место в барабане шестизарядного револьвера Одинокого Странника. Время покажет, суждено ли этой пуле вылететь из ствола оружия и покончить с оборотнем - или же она будет заменена другой, более, так сказать, "серебристой".

Dixi.

Post Scriptum

In abstracto (лат.) - отвлеченно, в абстракции, вообще.
Ab initio (лат.) - с начала.
Ad rem (лат.) - к делу.
Differentia specifica (лат.) - отличительный признак; характерная особенность.
Ad examplar (лат.) - пример, образец.
Ad usum (лат.) - к употреблению.
Panem et circenses (лат.) - хлеба и зрелищ.
Dixi (лат.) - я сказал, я высказался.