Low-level programming language

Assembly language

An assembly language, classified as a second-generation programming language, provides a level of abstraction on top of machine code. A program written in assembly language is non-portable, due to being written and optimized for a particular architecture.

Assembly language has little semantics or formal specification, being only a mapping of human-readable symbols, including symbolic addresses, to opcodes, addresses, numeric constants, strings and so on. Typically, one machine instruction is represented as one line of assembly code, commonly called a mnemonic. Assemblers produce object files that can link with other object files or be loaded on their own. Most assemblers provide macros to generate common sequences of instructions.

In the early days of coding on computers like TX-0 and PDP-1, the first thing MIT hackers did was to write assemblers.

Machine-oriented languages

Several languages referred to as machine-oriented languages, mid-level languages or half-way languages, and quarter-way languages have been developed such as:

• MOL940 for the SDS 940;
• MOL-360, PL360, and PL/S for the IBM System/360 line, and its successors;
• ESPOL and NEWP for the Burroughs Large Systems;
• PL-11 for the PDP-11 series;
• PL516 for the DDP-516;
• PS440 for the Telefunken TR 440.

C programming language

The C programming language, a third-generation programming language, is sometimes classified as high or low depending on what one means by high versus low level. The syntax of C is inherently higher level than that of an assembly language since an assembly language is syntactically platform-dependent whereas the C syntax is platform-independent. C does support low-level programming – directly accessing computer hardware – but other languages, sometimes considered higher-level than C, can also access hardware directly. With C, developers might need to handle relatively low-level aspects that other languages abstract (provide higher-level support for), such as memory management and pointer arithmetic. But C can encode abstractions that hide details such as hardware access, memory management and pointer arithmetic such that at least part of a C codebase might be as conceptually high-level as if constructed in any other language. Whether C is classified as high or low level language is contended, but it is higher level than assembly languages (especially syntactically) and is lower level than many other languages in some aspects.

Although C is not architecture independent, it can be used to write code that is cross-platform even though doing so can be technically challenging. An aspect of C that facilitates cross-platform development is the C standard library that provides “an interface to system-dependent objects that is itself relatively system independent”.

Comparison

The following is x86-64 machine code for an algorithm to calculate the nth Fibonacci number, with values in hexadecimal representation and each line corresponding to one instruction:

89 f8 85 ff 74 26 83 ff 02 76 1c 89 f9 ba 01 00 00 00 be 01 00 00 00 8d 04 16 83 f9 02 74 0d 89 d6 ff c9 89 c2 eb f0 b8 01 00 00 c3

The following is the same algorithm written in x86-64 assembly language using Intel syntax. The registers of the x86-64 processor are named and manipulated directly. The function loads its 64-bit argument from rdi in accordance to the System V application binary interface for x86-64 and performs its calculation by manipulating values in the rax, rcx, rsi, and rdi registers until it has finished and returns. Note that in this assembly language, there is no concept of returning a value. The result having been stored in the rax register, again in accordance with System V application binary interface, the ret instruction simply removes the top 64-bit element on the stack and causes the next instruction to be fetched from that location (that instruction is usually the instruction immediately after the one that called this function), with the result of the function being stored in rax. x86-64 assembly language imposes no standard for passing values to a function or returning values from a function (and in fact, has no concept of a function); those are defined by an application binary interface (ABI), such as the System V ABI for a particular instruction set.

<span id="mwxw"></span><span class="nl" id="mwyA">fib:</span> <span class="w" id="mwyQ"> </span><span class="nf" id="mwyg">mov</span><span class="w" id="mwyw"> </span><span class="no" id="mwzA">rax</span><span class="p" id="mwzQ">,</span><span class="w" id="mwzg"> </span><span class="no" id="mwzw">rdi</span><span class="w" id="mw0A"> </span><span class="c1" id="mw0Q">; The argument is stored in rdi, put it into rax</span> <span class="w" id="mw0g"> </span><span class="nf" id="mw0w">test</span><span class="w" id="mw1A"> </span><span class="no" id="mw1Q">rdi</span><span class="p" id="mw1g">,</span><span class="w" id="mw1w"> </span><span class="no" id="mw2A">rdi</span><span class="w" id="mw2Q"> </span><span class="c1" id="mw2g">; Is the argument zero?</span> <span class="w" id="mw2w"> </span><span class="nf" id="mw3A">je</span><span class="w" id="mw3Q"> </span><span class="no" id="mw3g">.return_from_fib</span><span class="w" id="mw3w"> </span><span class="c1" id="mw4A">; Yes - return 0, which is already in rax</span> <span class="w" id="mw4Q"> </span><span class="nf" id="mw4g">cmp</span><span class="w" id="mw4w"> </span><span class="no" id="mw5A">rdi</span><span class="p" id="mw5Q">,</span><span class="w" id="mw5g"> </span><span class="mi" id="mw5w">2</span><span class="w" id="mw6A"> </span><span class="c1" id="mw6Q">; No - compare the argument to 2</span> <span class="w" id="mw6g"> </span><span class="nf" id="mw6w">jbe</span><span class="w" id="mw7A"> </span><span class="no" id="mw7Q">.return_1_from_fib</span><span class="w" id="mw7g"> </span><span class="c1" id="mw7w">; If it is less than or equal to 2, return 1</span> <span class="w" id="mw8A"> </span><span class="nf" id="mw8Q">mov</span><span class="w" id="mw8g"> </span><span class="no" id="mw8w">rcx</span><span class="p" id="mw9A">,</span><span class="w" id="mw9Q"> </span><span class="no" id="mw9g">rdi</span><span class="w" id="mw9w"> </span><span class="c1" id="mw-A">; Otherwise, put it in rcx, for use as a counter</span> <span class="w" id="mw-Q"> </span><span class="nf" id="mw-g">mov</span><span class="w" id="mw-w"> </span><span class="no" id="mw_A">rdx</span><span class="p" id="mw_Q">,</span><span class="w" id="mw_g"> </span><span class="mi" id="mw_w">1</span><span class="w" id="mwAQA"> </span><span class="c1" id="mwAQE">; The first previous number starts out as 1, put it in rdx</span> <span class="w" id="mwAQI"> </span><span class="nf" id="mwAQM">mov</span><span class="w" id="mwAQQ"> </span><span class="no" id="mwAQU">rsi</span><span class="p" id="mwAQY">,</span><span class="w" id="mwAQc"> </span><span class="mi" id="mwAQg">1</span><span class="w" id="mwAQk"> </span><span class="c1" id="mwAQo">; The second previous number also starts out as 1, put it in rsi</span> <span class="nl" id="mwAQs">.fib_loop:</span> <span class="w" id="mwAQw"> </span><span class="nf" id="mwAQ0">lea</span><span class="w" id="mwAQ4"> </span><span class="no" id="mwAQ8">rax</span><span class="p" id="mwARA">,</span><span class="w" id="mwARE"> </span><span class="p" id="mwARI">[</span><span class="no" id="mwARM">rsi</span><span class="w" id="mwARQ"> </span><span class="err" id="mwARU">+</span><span class="w" id="mwARY"> </span><span class="no" id="mwARc">rdx</span><span class="p" id="mwARg">]</span><span class="w" id="mwARk"> </span><span class="c1" id="mwARo">; Put the sum of the previous two numbers into rax</span> <span class="w" id="mwARs"> </span><span class="nf" id="mwARw">cmp</span><span class="w" id="mwAR0"> </span><span class="no" id="mwAR4">rcx</span><span class="p" id="mwAR8">,</span><span class="w" id="mwASA"> </span><span class="mi" id="mwASE">2</span><span class="w" id="mwASI"> </span><span class="c1" id="mwASM">; Is the counter 2?</span> <span class="w" id="mwASQ"> </span><span class="nf" id="mwASU">je</span><span class="w" id="mwASY"> </span><span class="no" id="mwASc">.return_from_fib</span><span class="w" id="mwASg"> </span><span class="c1" id="mwASk">; Yes - rax contains the result</span> <span class="w" id="mwASo"> </span><span class="nf" id="mwASs">mov</span><span class="w" id="mwASw"> </span><span class="no" id="mwAS0">rsi</span><span class="p" id="mwAS4">,</span><span class="w" id="mwAS8"> </span><span class="no" id="mwATA">rdx</span><span class="w" id="mwATE"> </span><span class="c1" id="mwATI">; No - make the first previous number the second previous number</span> <span class="w" id="mwATM"> </span><span class="nf" id="mwATQ">dec</span><span class="w" id="mwATU"> </span><span class="no" id="mwATY">rcx</span><span class="w" id="mwATc"> </span><span class="c1" id="mwATg">; Decrement the counter</span> <span class="w" id="mwATk"> </span><span class="nf" id="mwATo">mov</span><span class="w" id="mwATs"> </span><span class="no" id="mwATw">rdx</span><span class="p" id="mwAT0">,</span><span class="w" id="mwAT4"> </span><span class="no" id="mwAT8">rax</span><span class="w" id="mwAUA"> </span><span class="c1" id="mwAUE">; Make the current number the first previous number</span> <span class="w" id="mwAUI"> </span><span class="nf" id="mwAUM">jmp</span><span class="w" id="mwAUQ"> </span><span class="no" id="mwAUU">.fib_loop</span><span class="w" id="mwAUY"> </span><span class="c1" id="mwAUc">; Keep going</span> <span class="nl" id="mwAUg">.return_1_from_fib:</span> <span class="w" id="mwAUk"> </span><span class="nf" id="mwAUo">mov</span><span class="w" id="mwAUs"> </span><span class="no" id="mwAUw">rax</span><span class="p" id="mwAU0">,</span><span class="w" id="mwAU4"> </span><span class="mi" id="mwAU8">1</span><span class="w" id="mwAVA"> </span><span class="c1" id="mwAVE">; Set the return value to 1</span> <span class="nl" id="mwAVI">.return_from_fib:</span> <span class="w" id="mwAVM"> </span><span class="nf" id="mwAVQ">ret</span><span class="w" id="mwAVU"> </span><span class="c1" id="mwAVY">; Return</span>

The following is the same algorithm again, but in C. This is similar in structure to the assembly example but there are significant differences in abstraction:

• The input (parameter n) is an abstraction that does not specify any storage location on the hardware. In practice, the C compiler follows one of many possible calling conventions to determine a storage location for the input.
• The local variables f_nminus2, f_nminus1, and f_n are abstractions that do not specify any specific storage location on the hardware. The C compiler decides how to actually store them for the target architecture.
• The return function specifies the value to return, but does not dictate how it is returned. The C compiler for any specific architecture implements a standard mechanism for returning the value. Compilers for the x86-64 architecture typically (but not always) use the rax register to return a value, as in the assembly language example (the author of the assembly language example has chosen to use the System V application binary interface for x86-64 convention but assembly language does not require this).

These abstractions make the C code compilable without modification for any architecture that is supported by a C compiler; whereas the assembly code above only runs on processors using the x86-64 architecture.

<span id="mwAWg"></span><span class="kt" id="mwAWk">unsigned</span><span class="w" id="mwAWo"> </span><span class="kt" id="mwAWs">int</span><span class="w" id="mwAWw"> </span><span class="nf" id="mwAW0">fib</span><span class="p" id="mwAW4">(</span><span class="kt" id="mwAW8">unsigned</span><span class="w" id="mwAXA"> </span><span class="kt" id="mwAXE">int</span><span class="w" id="mwAXI"> </span><span class="n" id="mwAXM">n</span><span class="p" id="mwAXQ">)</span> <span class="p" id="mwAXU">{</span> <span class="w" id="mwAXY"> </span><span class="k" id="mwAXc">if</span><span class="w" id="mwAXg"> </span><span class="p" id="mwAXk">(</span><span class="o" id="mwAXo">!</span><span class="n" id="mwAXs">n</span><span class="p" id="mwAXw">)</span> <span class="w" id="mwAX0"> </span><span class="p" id="mwAX4">{</span> <span class="w" id="mwAX8"> </span><span class="k" id="mwAYA">return</span><span class="w" id="mwAYE"> </span><span class="mi" id="mwAYI">0</span><span class="p" id="mwAYM">;</span> <span class="w" id="mwAYQ"> </span><span class="p" id="mwAYU">}</span> <span class="w" id="mwAYY"> </span><span class="k" id="mwAYc">else</span><span class="w" id="mwAYg"> </span><span class="k" id="mwAYk">if</span><span class="w" id="mwAYo"> </span><span class="p" id="mwAYs">(</span><span class="n" id="mwAYw">n</span><span class="w" id="mwAY0"> </span><span class="o" id="mwAY4"><=</span><span class="w" id="mwAY8"> </span><span class="mi" id="mwAZA">2</span><span class="p" id="mwAZE">)</span> <span class="w" id="mwAZI"> </span><span class="p" id="mwAZM">{</span> <span class="w" id="mwAZQ"> </span><span class="k" id="mwAZU">return</span><span class="w" id="mwAZY"> </span><span class="mi" id="mwAZc">1</span><span class="p" id="mwAZg">;</span> <span class="w" id="mwAZk"> </span><span class="p" id="mwAZo">}</span> <span class="w" id="mwAZs"> </span><span class="k" id="mwAZw">else</span> <span class="w" id="mwAZ0"> </span><span class="p" id="mwAZ4">{</span> <span class="w" id="mwAZ8"> </span><span class="kt" id="mwAaA">unsigned</span><span class="w" id="mwAaE"> </span><span class="kt" id="mwAaI">int</span><span class="w" id="mwAaM"> </span><span class="n" id="mwAaQ">f_nminus2</span><span class="p" id="mwAaU">,</span><span class="w" id="mwAaY"> </span><span class="n" id="mwAac">f_nminus1</span><span class="p" id="mwAag">,</span><span class="w" id="mwAak"> </span><span class="n" id="mwAao">f_n</span><span class="p" id="mwAas">;</span><span class="w" id="mwAaw"> </span> <span class="w" id="mwAa0"> </span><span class="k" id="mwAa4">for</span><span class="w" id="mwAa8"> </span><span class="p" id="mwAbA">(</span><span class="n" id="mwAbE">f_nminus2</span><span class="w" id="mwAbI"> </span><span class="o" id="mwAbM">=</span><span class="w" id="mwAbQ"> </span><span class="n" id="mwAbU">f_nminus1</span><span class="w" id="mwAbY"> </span><span class="o" id="mwAbc">=</span><span class="w" id="mwAbg"> </span><span class="mi" id="mwAbk">1</span><span class="p" id="mwAbo">,</span><span class="w" id="mwAbs"> </span><span class="n" id="mwAbw">f_n</span><span class="w" id="mwAb0"> </span><span class="o" id="mwAb4">=</span><span class="w" id="mwAb8"> </span><span class="mi" id="mwAcA">0</span><span class="p" id="mwAcE">;</span><span class="w" id="mwAcI"> </span><span class="p" id="mwAcM">;</span><span class="w" id="mwAcQ"> </span><span class="o" id="mwAcU">--</span><span class="n" id="mwAcY">n</span><span class="p" id="mwAcc">)</span> <span class="w" id="mwAcg"> </span><span class="p" id="mwAck">{</span> <span class="w" id="mwAco"> </span><span class="n" id="mwAcs">f_n</span><span class="w" id="mwAcw"> </span><span class="o" id="mwAc0">=</span><span class="w" id="mwAc4"> </span><span class="n" id="mwAc8">f_nminus2</span><span class="w" id="mwAdA"> </span><span class="o" id="mwAdE">+</span><span class="w" id="mwAdI"> </span><span class="n" id="mwAdM">f_nminus1</span><span class="p" id="mwAdQ">;</span> <span class="w" id="mwAdU"> </span><span class="k" id="mwAdY">if</span><span class="w" id="mwAdc"> </span><span class="p" id="mwAdg">(</span><span class="n" id="mwAdk">n</span><span class="w" id="mwAdo"> </span><span class="o" id="mwAds"><=</span><span class="w" id="mwAdw"> </span><span class="mi" id="mwAd0">2</span><span class="p" id="mwAd4">)</span> <span class="w" id="mwAd8"> </span><span class="p" id="mwAeA">{</span> <span class="w" id="mwAeE"> </span><span class="k" id="mwAeI">return</span><span class="w" id="mwAeM"> </span><span class="n" id="mwAeQ">f_n</span><span class="p" id="mwAeU">;</span> <span class="w" id="mwAeY"> </span><span class="p" id="mwAec">}</span> <span class="w" id="mwAeg"> </span><span class="n" id="mwAek">f_nminus2</span><span class="w" id="mwAeo"> </span><span class="o" id="mwAes">=</span><span class="w" id="mwAew"> </span><span class="n" id="mwAe0">f_nminus1</span><span class="p" id="mwAe4">;</span> <span class="w" id="mwAe8"> </span><span class="n" id="mwAfA">f_nminus1</span><span class="w" id="mwAfE"> </span><span class="o" id="mwAfI">=</span><span class="w" id="mwAfM"> </span><span class="n" id="mwAfQ">f_n</span><span class="p" id="mwAfU">;</span> <span class="w" id="mwAfY"> </span><span class="p" id="mwAfc">}</span> <span class="w" id="mwAfg"> </span><span class="p" id="mwAfk">}</span> <span class="p" id="mwAfo">}</span>

Low-level programming in high-level languages

Some high-level languages, such as PL/S, BLISS, BCPL, extended ALGOL and NEWP, and C, can access lower-level programming languages. One method for doing this is inline assembly, in which assembly code is embedded in the high-level language code. Some of these languages also allow architecture-dependent compiler optimization directives to adjust the way a compiler uses the target processor architecture.

The following block of C code from the GNU C Compiler (GCC) demonstrates its inline assembly feature.

<span id="mwAg0"></span><span class="kt" id="mwAg4">int</span><span class="w" id="mwAg8"> </span><span class="n" id="mwAhA">src</span><span class="w" id="mwAhE"> </span><span class="o" id="mwAhI">=</span><span class="w" id="mwAhM"> </span><span class="mi" id="mwAhQ">1</span><span class="p" id="mwAhU">;</span> <span class="kt" id="mwAhY">int</span><span class="w" id="mwAhc"> </span><span class="n" id="mwAhg">dst</span><span class="p" id="mwAhk">;</span><span class="w" id="mwAho"> </span> <span class="k" id="mwAhs">asm</span><span class="w" id="mwAhw"> </span><span class="p" id="mwAh0">(</span><span class="s" id="mwAh4">"mov %1, %0</span><span class="se" id="mwAh8">\n\t</span><span class="s" id="mwAiA">"</span> <span class="w" id="mwAiE"> </span><span class="s" id="mwAiI">"add $1, %0"</span> <span class="w" id="mwAiM"> </span><span class="o" id="mwAiQ">:</span><span class="w" id="mwAiU"> </span><span class="s" id="mwAiY">"=r"</span><span class="w" id="mwAic"> </span><span class="p" id="mwAig">(</span><span class="n" id="mwAik">dst</span><span class="p" id="mwAio">)</span><span class="w" id="mwAis"> </span> <span class="w" id="mwAiw"> </span><span class="o" id="mwAi0">:</span><span class="w" id="mwAi4"> </span><span class="s" id="mwAi8">"r"</span><span class="w" id="mwAjA"> </span><span class="p" id="mwAjE">(</span><span class="n" id="mwAjI">src</span><span class="p" id="mwAjM">));</span> <span class="n" id="mwAjQ">printf</span><span class="p" id="mwAjU">(</span><span class="s" id="mwAjY">"%d</span><span class="se" id="mwAjc">\n</span><span class="s" id="mwAjg">"</span><span class="p" id="mwAjk">,</span><span class="w" id="mwAjo"> </span><span class="n" id="mwAjs">dst</span><span class="p" id="mwAjw">);</span>