Content deleted Content added
Stevebroshar (talk | contribs) →Machine code: Get to the point; brevity; accuracy |
Guy Harris (talk | contribs) Most of the references for the statement about non-portability are talking about assembly language as the only example of a low-level language; move that to the section about assembly language. |
||
| (9 intermediate revisions by 2 users not shown) | |||
Line 1:
{{Short description |Programming
{{multiple issues|
{{original research|date=March 2017}}
Line 5:
}}
A '''low-level programming language''' is a [[programming language]] that provides little or no [[Abstraction (computer science)|abstraction]] from a computer's [[instruction set architecture]], memory or underlying physical hardware; commands or functions in the language are structurally similar to a processor's instructions. These languages provide the programmer with full control over program memory and the underlying machine code instructions. Because of the low level of abstraction (hence the term "low-level") between the language and machine language, low-level languages are sometimes described as being "close to the hardware".
Low-level languages are directly converted to machine code with or without a [[compiler]] or [[Interpreter (computing)|interpreter]]—[[second-generation programming language]]s<ref name=":3">{{Cite web |date=2017-10-22 |title=Generation of Programming Languages |url=https://www.geeksforgeeks.org/generation-programming-languages/ |access-date=2024-04-27 |website=GeeksforGeeks |language=en-US}}</ref><ref name=":4">{{Cite web |title=What is a Generation Languages? |url=https://www.computerhope.com/jargon/num/1gl.htm |access-date=2024-04-27 |website=www.computerhope.com |language=en}}</ref> depending on programming language. A program written in a low-level language can be made to run very quickly, with a small [[memory footprint]]. Such programs may be architecture dependent or operating system dependent, due to using low level [[API]]s.<ref name=":0" />▼
== Machine code ==
[[File:Digital pdp8-e2.jpg|thumb|Front panel of a [[PDP-8/e]] minicomputer. The row of switches at the bottom can be used to toggle in machine code.]]
▲
Programmers almost never program directly in machine code; instead, they use an [[assembly language]] or a higher-level programming language.<ref name=":0" /> Although few programs are written in machine languages, some programmers
== Assembly language ==▼
Example of a function in hexadecimal representation of [[x86-64]] machine code to calculate the ''n''th [[Fibonacci number]], with each line corresponding to one instruction:▼
An [[assembly language]], classified as a [[second-generation programming language]],<ref name=":3"/><ref name=":4"/> provides a level of abstraction on top of machine code. A program written in assembly language is [[Software portability |non-portable]], due to being written and optimized for a particular architecture.<ref name=":0">{{Cite web |date=2021-03-05 |title=3.1: Structure of low-level programs |url=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 |access-date=2023-04-03 |website=Workforce LibreTexts |language=en}}</ref><ref>{{Cite web |date=2023-11-19 |title=What is a Low Level Language? |url=https://www.geeksforgeeks.org/what-is-a-low-level-language/ |access-date=2024-04-27 |website=GeeksforGeeks |language=en-US}}</ref><ref>{{Cite web |title=Low Level Language? What You Need to Know {{!}} Lenovo US |url=https://www.lenovo.com/us/en/glossary/low-level-language/ |access-date=2024-04-27 |website=www.lenovo.com |language=en |url-status=dead |archive-url=https://web.archive.org/web/20240724093734/https://www.lenovo.com/us/en/glossary/low-level-language/ |archive-date=2024-07-24}}</ref><ref>{{Cite web |title=Low-level languages - Classifying programming languages and translators - AQA - GCSE Computer Science Revision - AQA |url=https://www.bbc.co.uk/bitesize/guides/z4cck2p/revision/2 |access-date=2024-04-27 |website=BBC Bitesize |language=en-GB}}</ref>
Assembly language has little [[Semantics (computer science)|semantics]] or formal specification, being only a mapping of human-readable symbols, including symbolic addresses, to [[opcode]]s, [[memory address|addresses]], numeric constants, [[string (computer science)|strings]] and so on. Typically, one [[machine instruction (computing)|machine instruction]] is represented as one line of assembly code, commonly called a ''mnemonic''.<ref>{{Cite web |title=Machine Language/Assembly Language/High Level Language |url=https://www.cs.mtsu.edu/~xyang/2170/computerLanguages.html |access-date=2024-04-27 |website=www.cs.mtsu.edu |archive-url=https://web.archive.org/web/20241214053921/https://www.cs.mtsu.edu/~xyang/2170/computerLanguages.html |archive-date=2024-12-14 |url-status=dead}}</ref> Assemblers produce [[object file]]s that can [[linker (computing)|link]] with other object files or be [[loader (computing)|loaded]] on their own. Most assemblers provide [[macro (computer science)|macros]] to generate common sequences of instructions.▼
== C programming language ==▼
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 (computing)|interface]] to system-dependent objects that is itself relatively system independent”.<ref>{{cite book |last=Kernighan |first=B. |author-link1=Brian Kernighan |last2=Ritchie |first2=D. |author-link2=Dennis Ritchie |date=1988 |title=The C Programming Language, 2nd Edition |page=163}}</ref>▼
==Comparison==
▲
<pre>
Line 39 ⟶ 49:
</pre>
▲== Assembly language ==
▲Second-generation languages provide one abstraction level on top of the machine code. In the early days of coding on computers like [[TX-0]] and [[PDP-1]], the first thing [[MIT]] [[Hacker culture|hackers]] did was to write assemblers.<ref name=":1">{{cite book|last=Levy|first=Stephen|year=1994|title=Hackers: Heroes of the Computer Revolution|title-link=Hackers: Heroes of the Computer Revolution|publisher=Penguin Books|page=32|isbn=0-14-100051-1}}</ref>
▲Assembly language has little [[Semantics (computer science)|semantics]] or formal specification, being only a mapping of human-readable symbols, including symbolic addresses, to [[opcode]]s, [[memory address|addresses]], numeric constants, [[string (computer science)|strings]] and so on. Typically, one [[machine instruction (computing)|machine instruction]] is represented as one line of assembly code, commonly called a ''mnemonic''.<ref>{{Cite web |title=Machine Language/Assembly Language/High Level Language |url=https://www.cs.mtsu.edu/~xyang/2170/computerLanguages.html |access-date=2024-04-27 |website=www.cs.mtsu.edu |archive-url=https://web.archive.org/web/20241214053921/https://www.cs.mtsu.edu/~xyang/2170/computerLanguages.html |archive-date=2024-12-14 |url-status=dead}}</ref> Assemblers produce [[object file]]s that can [[linker (computing)|link]] with other object files or be [[loader (computing)|loaded]] on their own.
<syntaxhighlight lang="asm">
Line 72 ⟶ 75:
</syntaxhighlight>
▲In this code example, the [[Processor register|registers]] of the x86-64 processor are named and manipulated directly. The function loads its 64-bit argument from {{code|rdi}} in accordance to the [[x86 calling conventions#System V AMD64 ABI|System V application binary interface for x86-64]] and performs its calculation by manipulating values in the {{code|rax}}, {{code|rcx}}, {{code|rsi}}, and {{code|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 {{code|rax}} register, again in accordance with System V application binary interface, the {{code|ret}} instruction simply removes the top 64-bit element on the [[Stack-based memory allocation|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 {{code|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.
* The input (parameter {{code |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 convention]]s to determine a storage ___location for the input.▼
* The local variables {{code|f_nminus2}}, {{code|f_nminus1}}, and {{code|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 {{code |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
<syntaxhighlight lang="c">
Line 104 ⟶ 110:
</syntaxhighlight>
▲This code is similar in structure to the assembly language example but there are significant differences in terms of abstraction:
▲* The input (parameter {{code|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 convention]]s to determine a storage ___location for the input.
▲* The local variables {{code|f_nminus2}}, {{code|f_nminus1}}, and {{code|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 {{code|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 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.
▲== C programming language ==
▲Depending on what one means by high vs. low level language, C is sometimes classified as one or the other.<ref>{{cite journal |last1=Jindal |first1=G. |first2=P. |last2=Khurana |first3=T. |last3=Goel |date=January 2013 |title=Comparative study of C, Objective C, C++ programming language |journal=International Journal of Advanced Trends in Computer Science and Engineering |volume=2 |issue=1 |page=203}}</ref> 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 {{endash}} directly accessing computer hardware {{endash}} but other languages, sometimes considered higher level than C, also can 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 (computing)|interface]] to system-dependent objects that is itself relatively system independent”.<ref>{{cite book |last=Kernighan |first=B. |author-link1=Brian Kernighan |last2=Ritchie |first2=D. |author-link2=Dennis Ritchie |date=1988 |title=The C Programming Language, 2nd Edition |page=163}}</ref>
▲== Low-level programming in high-level languages ==
▲During the late 1960s and 1970s, [[High-level programming language|high-level languages]] that included some degree of access to low-level programming functions, such as [[IBM PL/S|PL/S]], [[BLISS]], [[BCPL]], extended [[ALGOL]] and [[NEWP]] (for [[Burroughs large systems]]/Unisys Clearpath MCP systems), and [[C (programming language)|C]], were introduced. One method for this is [[inline assembly]], in which assembly code is embedded in a high-level language that supports this feature. Some of these languages also allow architecture-dependent [[Optimizing compiler|compiler optimization directives]] to adjust the way a compiler uses the target processor architecture.
int src = 1;
int dst;
| |||