Low-level programming language

<h2 id="machine-code">Machine code</h2>

Main article: <a href="/facts/Machine_code/bgdQ1Fxf">Machine code</a>
Machine code is the form in which code that can be directly executed is stored on a computer. It consists of machine language <a href="/facts/Instruction_set_architecture/8p8vwUeE">instructions</a>, stored in memory, that perform operations such as moving values in and out of memory locations, arithmetic and Boolean logic, and testing values and, based on the test, either executing the next instruction in memory or executing an instruction at another location.
Machine code is usually stored in memory as <a href="/facts/Binary_code/v5YF0sQl">binary</a> data. Programmers almost never write programs directly in machine code; instead, they write code in <a href="/facts/Assembly_language/7XuV0cla">assembly language</a> or higher-level programming languages.<a class="footnote-ref" id="fnref:8" href="#fn:8">8</a>
Although few programs are written in machine languages, programmers often become adept at reading it through working with <a href="/facts/Core_dump/rnhaVc2f">core dumps</a> or debugging from the front panel.
Example of a function in hexadecimal representation of <a href="/facts/X86-64/cyWvUFlP">x86-64</a> machine code to calculate the nth <a href="/facts/Fibonacci_number/mqxpAUQD">Fibonacci number</a>, with 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

<h2 id="assembly-language">Assembly language</h2>
Main article: <a href="/facts/Assembly_language/7XuV0cla">Assembly language</a>
Second-generation languages provide one abstraction level on top of the machine code. In the early days of coding on computers like <a href="/facts/TX-0/8Bau5eqq">TX-0</a> and <a href="/facts/PDP-1/PSeIBDJU">PDP-1</a>, the first thing <a href="/facts/MIT/Xk49vNA8">MIT</a> <a href="/facts/Hacker_culture/8ww6P79y">hackers</a> did was to write assemblers.<a class="footnote-ref" id="fnref:9" href="#fn:9">9</a>
Assembly language has little <a href="/facts/Semantics_(computer_science)/JEP1zyBv">semantics</a> or formal specification, being only a mapping of human-readable symbols, including symbolic addresses, to <a href="/facts/Opcode/UaLMp56C">opcodes</a>, <a href="/facts/Memory_address/7EsUmbea">addresses</a>, numeric constants, <a href="/facts/String_(computer_science)/4ChJu5WS">strings</a> and so on. Typically, one <a href="/facts/Machine_instruction_(computing)/bgdQ1Fxf">machine instruction</a> is represented as one line of assembly code, commonly called a mnemonic.<a class="footnote-ref" id="fnref:10" href="#fn:10">10</a> Assemblers produce <a href="/facts/Object_file/sFBvosE4">object files</a> that can <a href="/facts/Linker_(computing)/pn1hztYe">link</a> with other object files or be <a href="/facts/Loader_(computing)/eIK4f2xB">loaded</a> on their own.
Most assemblers provide <a href="/facts/Macro_(computer_science)/7abAsm1o">macros</a> to generate common sequences of instructions.
Example: The same <a href="/facts/Fibonacci_number/mqxpAUQD">Fibonacci number</a> calculator as above, but in <a href="/facts/X86_assembly_language/GTUtvkMm">x86-64 assembly language</a> using <a href="/facts/Intel_syntax/GTUtvkMm">Intel syntax</a>:

fib:
 mov rax, rdi ; The argument is stored in rdi, put it into rax
 test rdi, rdi ; Is the argument zero?
 je .return_from_fib ; Yes - return 0, which is already in rax
 cmp rdi, 2 ; No - compare the argument to 2
 jbe .return_1_from_fib ; If it is less than or equal to 2, return 1
 mov rcx, rdi ; Otherwise, put it in rcx, for use as a counter
 mov rdx, 1 ; The first previous number starts out as 1, put it in rdx
 mov rsi, 1 ; The second previous number also starts out as 1, put it in rsi
.fib_loop:
 lea rax, [rsi + rdx] ; Put the sum of the previous two numbers into rax
 cmp rcx, 2 ; Is the counter 2?
 je .return_from_fib ; Yes - rax contains the result
 mov rsi, rdx ; No - make the first previous number the second previous number
 dec rcx ; Decrement the counter
 mov rdx, rax ; Make the current number the first previous number
 jmp .fib_loop ; Keep going
.return_1_from_fib:
 mov rax, 1 ; Set the return value to 1
.return_from_fib:
 ret ; Return

In this code example, the <a href="/facts/Processor_register/32RvbUdz">registers</a> of the x86-64 processor are named and manipulated directly. The function loads its 64-bit argument from rdi in accordance to the <a href="/facts/X86_calling_conventions/0qf1FDvV">System V application binary interface for x86-64</a> 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 <a href="/facts/Stack-based_memory_allocation/Wem3dQa6">stack</a> 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 <a href="/facts/Application_binary_interface/wc6pmKKb">application binary interface</a> (ABI), such as the System V ABI for a particular instruction set.
Compare this with the same function in <a href="/facts/C_(programming_language)/Ky2No763">C</a>:

unsigned int fib(unsigned int n)
{
 if (!n)
 {
 return 0;
 }
 else if (n <= 2)
 {
 return 1;
 }
 else
 {
 unsigned int f_nminus2, f_nminus1, f_n; 
 for (f_nminus2 = f_nminus1 = 1, f_n = 0; ; --n)
 {
 f_n = f_nminus2 + f_nminus1;
 if (n <= 2)
 {
 return f_n;
 }
 f_nminus2 = f_nminus1;
 }
 }
}

This code is similar in structure to the assembly language example but there are significant differences in terms of abstraction:

<ul><li>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 <a href="/facts/Calling_convention/FtzN2BKj">calling conventions</a> to determine a storage location for the input.</li>
<li>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.</li>
<li>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).</li></ul>
These abstractions make the C code compilable without modification on any architecture for which a C compiler has been written, whereas the assembly language code above will only run on processors using the x86-64 architecture.

<h2 id="c-programming-language">C programming language</h2>
Main article: <a href="/facts/C_(programming_language)/Ky2No763">C (programming language)</a>
C has variously been described as low-level and high-level.<a class="footnote-ref" id="fnref:11" href="#fn:11">11</a> Traditionally considered high-level, C’s level of abstraction from the hardware is far lower than many subsequently developed languages, particularly interpreted languages. The direct interface C provides between the programmer and hardware memory allocation and management make C the lowest-level language of <a href="/facts/Programming_language/cWTYbgWa">the 10 most popular languages currently in use</a>.
C is architecture independent — the same C code may, in most cases, be compiled (by different machine-specific compilers) for use on a wide breadth of machine platforms. In many respects (including directory operations and memory allocation), C provides “an interface to system-dependent objects that is itself relatively system independent”.<a class="footnote-ref" id="fnref:12" href="#fn:12">12</a> This feature is considered “high-level” in comparison of platform-specific assembly languages.

<h2 id="low-level-programming-in-high-level-languages">Low-level programming in high-level languages</h2>
During the late 1960s and 1970s, <a href="/facts/High-level_programming_language/smjECUhx">high-level languages</a> that included some degree of access to low-level programming functions, such as <a href="/facts/IBM_PL/S/aeMNxKVl">PL/S</a>, <a href="/facts/BLISS/xm2Msp6c">BLISS</a>, <a href="/facts/BCPL/GkBV2hXy">BCPL</a>, extended <a href="/facts/ALGOL/wlFJGNEx">ALGOL</a> and <a href="/facts/NEWP/VNnIszLD">NEWP</a> (for <a href="/facts/Burroughs_large_systems/FwY7EqrB">Burroughs large systems</a>/Unisys Clearpath MCP systems), and <a href="/facts/C_(programming_language)/Ky2No763">C</a>, were introduced. One method for this is <a href="/facts/Inline_assembly/Dn60Jm44">inline assembly</a>, in which assembly code is embedded in a high-level language that supports this feature. Some of these languages also allow architecture-dependent <a href="/facts/Optimizing_compiler/JXnv4LUd">compiler optimization directives</a> to adjust the way a compiler uses the target processor architecture.

Furthermore, as referenced above, the following block of C is from the GNU Compiler and shows the inline assembly ability of C. Per the GCC documentation this is a simple copy and addition code. This code displays the interaction between a generally high level language like C and its middle/low level counter part Assembly. Although this may not make C a natively low level language these facilities express the interactions in a more direct way.<a class="footnote-ref" id="fnref:13" href="#fn:13">13</a> int src = 1;
int dst;

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

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

<h2 id="bibliography">Bibliography</h2>
<ul><li>Zhirkov, Igor (2017). Low-level programming: C, assembly, and program execution on Intel 64 architecture. California: Apress. <a href="/facts/ISBN_(identifier)/15AdSPa9">ISBN</a> 978-1-4842-2402-1.</li></ul>

<h2 id="references">References</h2>

<ol>
<li id="fn:1">"3.1: Structure of low-level programs". Workforce LibreTexts. 2021-03-05. Retrieved 2023-04-03. <a href="https://workforce.libretexts.org/Bookshelves/Information_Technology/Information_Technology_Hardware/Advanced_Computer_Organization_Architecture_(Njoroge)/03%3A_Computer_Organization_and_low-level_Programming/3.01%3A_Structure_of_low-level_programs" target="_blank">https://workforce.libretexts.org/Bookshelves/Information_Technology/Information_Technology_Hardware/Advanced_Computer_Organization_Architecture_(Njoroge)/03%3A_Computer_Organization_and_low-level_Programming/3.01%3A_Structure_of_low-level_programs</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></li>
<li id="fn:2">"What is a Low Level Language?". GeeksforGeeks. 2023-11-19. Retrieved 2024-04-27. <a href="https://www.geeksforgeeks.org/what-is-a-low-level-language/" target="_blank">https://www.geeksforgeeks.org/what-is-a-low-level-language/</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></li>
<li id="fn:3">"Low Level Language? What You Need to Know | Lenovo US". www.lenovo.com. Retrieved 2024-04-27. <a href="https://www.lenovo.com/us/en/glossary/low-level-language/" target="_blank">https://www.lenovo.com/us/en/glossary/low-level-language/</a> <a href="#fnref:3" class="footnote-back-ref">↩</a></li>
<li id="fn:4">"Low-level languages - Classifying programming languages and translators - AQA - GCSE Computer Science Revision - AQA". BBC Bitesize. Retrieved 2024-04-27. <a href="https://www.bbc.co.uk/bitesize/guides/z4cck2p/revision/2" target="_blank">https://www.bbc.co.uk/bitesize/guides/z4cck2p/revision/2</a> <a href="#fnref:4" class="footnote-back-ref">↩</a></li>
<li id="fn:5">"Generation of Programming Languages". GeeksforGeeks. 2017-10-22. Retrieved 2024-04-27. <a href="https://www.geeksforgeeks.org/generation-programming-languages/" target="_blank">https://www.geeksforgeeks.org/generation-programming-languages/</a> <a href="#fnref:5" class="footnote-back-ref">↩</a></li>
<li id="fn:6">"What is a Generation Languages?". www.computerhope.com. Retrieved 2024-04-27. <a href="https://www.computerhope.com/jargon/num/1gl.htm" target="_blank">https://www.computerhope.com/jargon/num/1gl.htm</a> <a href="#fnref:6" class="footnote-back-ref">↩</a></li>
<li id="fn:7">"3.1: Structure of low-level programs". Workforce LibreTexts. 2021-03-05. Retrieved 2023-04-03. <a href="https://workforce.libretexts.org/Bookshelves/Information_Technology/Information_Technology_Hardware/Advanced_Computer_Organization_Architecture_(Njoroge)/03%3A_Computer_Organization_and_low-level_Programming/3.01%3A_Structure_of_low-level_programs" target="_blank">https://workforce.libretexts.org/Bookshelves/Information_Technology/Information_Technology_Hardware/Advanced_Computer_Organization_Architecture_(Njoroge)/03%3A_Computer_Organization_and_low-level_Programming/3.01%3A_Structure_of_low-level_programs</a> <a href="#fnref:7" class="footnote-back-ref">↩</a></li>
<li id="fn:8">"3.1: Structure of low-level programs". Workforce LibreTexts. 2021-03-05. Retrieved 2023-04-03. <a href="https://workforce.libretexts.org/Bookshelves/Information_Technology/Information_Technology_Hardware/Advanced_Computer_Organization_Architecture_(Njoroge)/03%3A_Computer_Organization_and_low-level_Programming/3.01%3A_Structure_of_low-level_programs" target="_blank">https://workforce.libretexts.org/Bookshelves/Information_Technology/Information_Technology_Hardware/Advanced_Computer_Organization_Architecture_(Njoroge)/03%3A_Computer_Organization_and_low-level_Programming/3.01%3A_Structure_of_low-level_programs</a> <a href="#fnref:8" class="footnote-back-ref">↩</a></li>
<li id="fn:9">Levy, Stephen (1994). Hackers: Heroes of the Computer Revolution. Penguin Books. p. 32. ISBN 0-14-100051-1. <a href="0-14-100051-1" target="_blank">0-14-100051-1</a> <a href="#fnref:9" class="footnote-back-ref">↩</a></li>
<li id="fn:10">"Machine Language/Assembly Language/High Level Language". www.cs.mtsu.edu. Archived from the original on 2024-12-14. Retrieved 2024-04-27. <a href="https://web.archive.org/web/20241214053921/https://www.cs.mtsu.edu/~xyang/2170/computerLanguages.html" target="_blank">https://web.archive.org/web/20241214053921/https://www.cs.mtsu.edu/~xyang/2170/computerLanguages.html</a> <a href="#fnref:10" class="footnote-back-ref">↩</a></li>
<li id="fn:11">Jindal, G.; Khurana, P.; Goel, T. (January 2013). "Comparative study of C, Objective C, C++ programming language". International Journal of Advanced Trends in Computer Science and Engineering. 2 (1): 203. <a href="#fnref:11" class="footnote-back-ref">↩</a></li>
<li id="fn:12">Kernighan, B.; Ritchie, D. (1988). The C Programming Language, 2nd Edition. p. 163. <a href="/wiki/Brian_Kernighan" target="_blank">/wiki/Brian_Kernighan</a> <a href="#fnref:12" class="footnote-back-ref">↩</a></li>
<li id="fn:13">"Extended Asm (Using the GNU Compiler Collection (GCC))". gcc.gnu.org. Retrieved 2024-04-27. <a href="https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html" target="_blank">https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html</a> <a href="#fnref:13" class="footnote-back-ref">↩</a></li>
</ol>

Low-level programming language open-in-new

Low-level programming language