Язык программирования низкого уровня

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

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

Машинный код

Передняя панель миникомпьютера PDP-8/E. Ряд переключателей внизу можно использовать для переключения программы на машинном языке.

Основная статья: Машинный код

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

Машинный код обычно хранится в памяти в виде двоичных данных. Программисты почти никогда не пишут программы непосредственно в машинном коде; вместо этого они пишут код на языке ассемблера или языках программирования более высокого уровня.

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

Пример функции в шестнадцатеричном представлении машинного кода x86-64 для вычисления n-го числа Фибоначчи , где каждая строка соответствует одной инструкции:

89 ф8
 85 и далее
 74 26
 83 и далее 02
 76 1с
 89 ф9
 ба 01 00 00 00
 быть 01 00 00 00
 8д 04 16
 83 f9 02
 74 0д
 89 д6
 фф с9
 89 с2
 еб f0
 б8 01 00 00
 с3
 

Язык ассемблера

Основная статья: Язык ассемблера

Языки второго поколения предоставляют один уровень абстракции поверх машинного кода. На заре программирования на таких компьютерах, как TX-0 и PDP-1 , первое, MIT что сделали хакеры , — это написали ассемблеры. В языке ассемблера мало семантики или формальной спецификации, поскольку он представляет собой лишь отображение удобочитаемых символов, включая символические адреса, в коды операций , адреса , числовые константы, строки и так далее. Обычно одна машинная инструкция представлена ​​как одна строка ассемблерного кода, обычно называемая мнемоникой. Ассемблер создает объектные файлы , которые могут связываться с другими объектными файлами или загружаться самостоятельно.

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

Пример: Тот же калькулятор чисел Фибоначчи, что и выше, но на языке ассемблера x86-64 с использованием синтаксиса AT&T :

фиб: 
     movl   %edi  ,   %eax              ;   поместите аргумент в %eax 
     testl   %edi  ,   %edi             ;   это ноль? 
      je   .return_from_fib          ;   да — вернуть 0, который уже есть в %eax 
     cmpl   $2  ,   %edi                ;   2 больше или равно ему? 
      jbe   .return_1_from_fib       ;   да (т.е. это 1 или 2) — вернуть 1 
     movl   %edi  ,   %ecx              ;   нет - поместите его в %ecx для использования в качестве счетчика 
     movl   $1  ,   %edx                ;   предыдущий номер в последовательности, который начинается как 1 
     movl   $1  ,   %esi                ;   число перед этим, которое также начинается с 1 
 .fib_loop: 
     leal   (  %rsi  ,  %rdx  ),   %eax       ;   поместите сумму двух предыдущих чисел в %eax 
     cmpl   $2  ,   %ecx                ;   счетчик 2? 
      je   .return_from_fib          ;   да - %eax содержит результат 
     movl   %edx  ,   %esi              ;   сделать предыдущее число числом перед предыдущим 
     decl   %ecx                    ;   уменьшить счетчик 
     movl   %eax  ,   %edx              ;   сделать текущий номер предыдущим номером 
     jmp   .fib_loop                ;   продолжайте 
 .return_1_from_fib: 
     movl   $1  ,   %eax                ;   установите возвращаемое значение равным 1 
 .return_from_fib: 
     ret                          ;   возвращаться 

В этом примере кода регистрам процессора x86-64 присваиваются имена и ими можно управлять напрямую. Функция загружает свой 32-битный аргумент из %edi в соответствии с бинарным интерфейсом приложения System V для x86-64 и выполняет его расчет, манипулируя значениями в %eax, %ecx, %esi, и %ediрегистрируется до тех пор, пока не завершится и не вернется. Обратите внимание, что в этом языке ассемблера нет понятия возврата значения. Результат сохраняется в %eax зарегистрируйте, опять же в соответствии с двоичным интерфейсом приложения System V, ret Инструкция просто удаляет верхний 64-битный элемент стека и вызывает выборку следующей инструкции из этого места (этой инструкцией обычно является инструкция, следующая сразу за той, которая вызвала эту функцию), при этом результат функции сохраняется в %eax. Язык ассемблера x86-64 не налагает никаких стандартов на передачу значений в функцию или возврат значений из функции (и фактически не имеет понятия функции); они определяются двоичным интерфейсом приложения , таким как System V ABI для определенного набора команд.

Сравните это с той же функцией в C :

unsigned   int   fib  (  unsigned   int   n  ) 
 { 
     if   (  !  n  ) 
     { 
         return   0  ; 
      } 
     Еще   если   (  п   <=   2  ) 
     { 
         возвращение   1  ; 
      } 
     Еще 
     { 
         unsigned   int   f_nminus2  ,   f_nminus1  ,   f_n  ;        
          для   (  f_nminus2   =   f_nminus1   =   1  ,   f_n   =   0  ;   ;   --  n  ) 
         { 
             f_n   =   f_nminus2   +   f_nminus1  ; 
              если   (  n   <=   2  ) 
             { 
                 return   f_n  ; 
              } 
             f_nminus2   =   f_nminus1  ; 
          } 
     } 
 } 

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

• Входные данные (параметр n) — это абстракция, не определяющая место хранения на оборудовании. На практике компилятор C следует одному из многих возможных соглашений о вызовах, чтобы определить место хранения входных данных.
• Локальные переменные f_nminus2, f_nminus1, и f_nпредставляют собой абстракции, которые не определяют какое-либо конкретное место хранения на оборудовании. Компилятор C решает, как их хранить для целевой архитектуры.
• Функция return указывает возвращаемое значение, но не определяет, как оно возвращается. Компилятор C для любой конкретной архитектуры реализует стандартный механизм возврата значения. Компиляторы для архитектуры x86 обычно (но не всегда) используют %eax зарегистрируйтесь для возврата значения, как в примере с языком ассемблера (автор примера с языком ассемблера решил использовать двоичный интерфейс приложения System V для соглашения x86-64, но язык ассемблера этого не требует).

Эти абстракции делают код C компилируемым без изменений на любой архитектуре, для которой написан компилятор C. Код языка ассемблера x86 специфичен для архитектуры x86-64 и двоичного интерфейса приложения System V для этой архитектуры.

Низкоуровневое программирование на языках высокого уровня

В конце 1960-х и 1970-х годах языки высокого уровня , которые включали некоторую степень доступа к функциям низкоуровневого программирования, такие как PL/S , BLISS , BCPL , расширенный ALGOL и ESPOL (для больших систем Берроуза ) и C. были введены . Одним из методов для этого является встроенная ассемблерная программа , в которой ассемблерный код встроен в язык высокого уровня, поддерживающий эту функцию. Некоторые из этих языков также позволяют директивам оптимизации компилятора в зависимости от архитектуры регулировать способ использования компилятором архитектуры целевого процессора.

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

Кроме того, как упоминалось выше, следующий блок C взят из компилятора GNU и показывает возможность встроенной сборки C. Согласно документации GCC, это простое копирование и добавление кода. Этот код отображает взаимодействие между языком высокого уровня, например C, и его аналогом ассемблера среднего/низкого уровня. Хотя это не делает C изначально языком низкого уровня, эти средства выражают взаимодействие более прямым способом.

интервал   источника   =   1  ; 
  интервал   времени  ;    

  asm   (  "mov %1, %0  \n\t  " 
     "add $1, %0" 
     :   "=r"   (  dst  )  
     :   "r"   (  src  )); 

  printf  (  "%d  \n  "  ,   dst  );