Assembly language - Knowledge

1690:(and repeatedly re-definable) macros involving sequences of text lines in which variables and constants are embedded. The macro definition is most commonly a mixture of assembler statements, e.g., directives, symbolic machine instructions, and templates for assembler statements. This sequence of text lines may include opcodes or directives. Once a macro has been defined its name may be used in place of a mnemonic. When the assembler processes such a statement, it replaces the statement with the text lines associated with that macro, then processes them as if they existed in the source code file (including, in some assemblers, expansion of any macros existing in the replacement text). Macros in this sense date to IBM 1747:" loops, for example, or could generate entire algorithms based on complex parameters. For instance, a "sort" macro could accept the specification of a complex sort key and generate code crafted for that specific key, not needing the run-time tests that would be required for a general procedure interpreting the specification. An organization using assembly language that has been heavily extended using such a macro suite can be considered to be working in a higher-level language since such programmers are not working with a computer's lowest-level conceptual elements. Underlining this point, macros were used to implement an early 40: 1743:. Some assemblers include quite sophisticated macro languages, incorporating such high-level language elements as optional parameters, symbolic variables, conditionals, string manipulation, and arithmetic operations, all usable during the execution of a given macro, and allowing macros to save context or exchange information. Thus a macro might generate numerous assembly language instructions or data definitions, based on the macro arguments. This could be used to generate record-style data structures or " 6003: 2776: 1305:(essentially macros) which expand into several machine language instructions to provide commonly needed functionality. For example, for a machine that lacks a "branch if greater or equal" instruction, an assembler may provide a pseudoinstruction that expands to the machine's "set if less than" and "branch if zero (on the result of the set instruction)". Most full-featured assemblers also provide a rich 1310:

pseudoinstruction invocations but can only disassemble the actual machine instructions that the assembler generated from those abstract assembly-language entities. Likewise, since comments in the assembly language source file are ignored by the assembler and have no effect on the object code it generates, a disassembler is always completely unable to recover source comments.

1917:, and memory references; but it incorporated an expression syntax to indicate execution order. Parentheses and other special symbols, along with block-oriented structured programming constructs, controlled the sequence of the generated instructions. A-natural was built as the object language of a C compiler, rather than for hand-coding, but its logical syntax won some fans. 1458:. Most instructions refer to a single value or a pair of values. Operands can be immediate (value coded in the instruction itself), registers specified in the instruction or implied, or the addresses of data located elsewhere in storage. This is determined by the underlying processor architecture: the assembler merely reflects how this architecture works. 1625:

The names of pseudo-ops often start with a dot to distinguish them from machine instructions. Pseudo-ops can make the assembly of the program dependent on parameters input by a programmer, so that one program can be assembled in different ways, perhaps for different applications. Or, a pseudo-op can

1386:

CPUs, enhanced copies of the Intel 8086 and 8088, respectively. Like Zilog with the Z80, NEC invented new mnemonics for all of the 8086 and 8088 instructions, to avoid accusations of infringement of Intel's copyright. (It is questionable whether such copyrights can be valid, and later CPU companies

1070:

In some assembly languages (including this one) the same mnemonic, such as MOV, may be used for a family of related instructions for loading, copying and moving data, whether these are immediate values, values in registers, or memory locations pointed to by values in registers or by immediate (a.k.a.

1836:

Macro parameter substitution is strictly by name: at macro processing time, the value of a parameter is textually substituted for its name. The most famous class of bugs resulting was the use of a parameter that itself was an expression and not a simple name when the macro writer expected a name. In

1413:

There is a large degree of diversity in the way the authors of assemblers categorize statements and in the nomenclature that they use. In particular, some describe anything other than a machine mnemonic or extended mnemonic as a pseudo-operation (pseudo-op). A typical assembly language consists of 3

535:

is "a program that accepts the syntactic and semantic description of an assembly language, and generates an assembler for that language", or that accepts an assembler source file along with such a description and assembles the source file in accordance with that description. "Meta-Symbol" assemblers

341:

summarised the effects of the switch away from assembly language programming: "Surely the most powerful stroke for software productivity, reliability, and simplicity has been the progressive use of high-level languages for programming. Most observers credit that development with at least a factor of

2862:

This is one of two redundant forms of this instruction that operate identically. The 8086 and several other CPUs from the late 1970s/early 1980s have redundancies in their instruction sets, because it was simpler for engineers to design these CPUs (to fit on silicon chips of limited sizes) with the

1762:

Macros were used to customize large scale software systems for specific customers in the mainframe era and were also used by customer personnel to satisfy their employers' needs by making specific versions of manufacturer operating systems. This was done, for example, by systems programmers working

1128:

Assembly languages are always designed so that this sort of lack of ambiguity is universally enforced by their syntax. For example, in the Intel x86 assembly language, a hexadecimal constant must start with a numeral digit, so that the hexadecimal number 'A' (equal to decimal ten) would be written

2880:

AMD manufactured second-source Intel 8086, 8088, and 80286 CPUs, and perhaps 8080A and 8085A CPUs, under license from Intel, but starting with the 80386, Intel refused to share their x86 CPU designs with anyone—AMD sued about this for breach of contract—and AMD designed, made, and sold

1317:

has its own machine language. Computers differ in the number and type of operations they support, in the different sizes and numbers of registers, and in the representations of data in storage. While most general-purpose computers are able to carry out essentially the same functionality, the ways

1309:

language (discussed below) which is used by vendors and programmers to generate more complex code and data sequences. Since the information about pseudoinstructions and macros defined in the assembler environment is not present in the object program, a disassembler cannot reconstruct the macro and

784:

In both cases, the assembler must be able to determine the size of each instruction on the initial passes in order to calculate the addresses of subsequent symbols. This means that if the size of an operation referring to an operand defined later depends on the type or distance of the operand, the

3314:

Assembly language (or Assembler) is a compiled, low-level computer language. It is processor-dependent since it basically translates the Assembler's mnemonics directly into the commands a particular CPU understands, on a one-to-one basis. These Assembler mnemonics are the instruction set for that

2421:

are claimed to render high-level languages into code that can run as fast as hand-written assembly, despite the counter-examples that can be found. The complexity of modern processors and memory sub-systems makes effective optimization increasingly difficult for compilers, as well as for assembly

2267:

programming needed with the earliest computers, freeing programmers from tedium such as remembering numeric codes and calculating addresses. They were once widely used for all sorts of programming. However, by the late 1950s, their use had largely been supplanted by higher-level languages, in the

1920:

There has been little apparent demand for more sophisticated assemblers since the decline of large-scale assembly language development. In spite of that, they are still being developed and applied in cases where resource constraints or peculiarities in the target system's architecture prevent the

1617:

Assembly directives, also called pseudo-opcodes, pseudo-operations or pseudo-ops, are commands given to an assembler "directing it to perform operations other than assembling instructions". Directives affect how the assembler operates and "may affect the object code, the symbol table, the listing

1673:

that will be ignored during assembly. Judicious commenting is essential in assembly language programs, as the meaning and purpose of a sequence of binary machine instructions can be difficult to determine. The "raw" (uncommented) assembly language generated by compilers or disassemblers is quite

1735:

Since macros can have 'short' names but expand to several or indeed many lines of code, they can be used to make assembly language programs appear to be far shorter, requiring fewer lines of source code, as with higher level languages. They can also be used to add higher levels of structure to

345:

Today, it is typical to use small amounts of assembly language code within larger systems implemented in a higher-level language, for performance reasons or to interact directly with hardware in ways unsupported by the higher-level language. For instance, just under 2% of version 4.9 of the

2341:

dialects on these systems offer insufficient execution speed and insufficient facilities to take full advantage of the available hardware. These systems have severe resource constraints, idiosyncratic memory and display architectures, and provide limited system services. There are also few

1395:

republished Intel's x86/IA-32 instruction mnemonics exactly with neither permission nor legal penalty.) It is doubtful whether in practice many people who programmed the V20 and V30 actually wrote in NEC's assembly language rather than Intel's; since any two assembly languages for the same

2675:

design would be hard to study in detail without a grasp of how a computer operates at the hardware level. Since a computer's behavior is fundamentally defined by its instruction set, the logical way to learn such concepts is to study an assembly language. Most modern computers have similar

1817:

This is because, as was realized in the 1960s, the concept of "macro processing" is independent of the concept of "assembly", the former being in modern terms more word processing, text processing, than generating object code. The concept of macro processing appeared, and appears, in the C

962:, which might be a list of data, arguments or parameters. Some instructions may be "implied", which means the data upon which the instruction operates is implicitly defined by the instruction itself—such an instruction does not take an operand. The resulting statement is translated by an 1329:

Two examples of CPUs that have two different sets of mnemonics are the Intel 8080 family and the Intel 8086/8088. Because Intel claimed copyright on its assembly language mnemonics (on each page of their documentation published in the 1970s and early 1980s, at least), some companies that

2676:

instruction sets. Therefore, studying a single assembly language is sufficient to learn: I) the basic concepts; II) to recognize situations where the use of assembly language might be appropriate; and III) to see how efficient executable code can be created from high-level languages.

1484:

are often used to support specialized uses of instructions, often for purposes not obvious from the instruction name. For example, many CPU's do not have an explicit NOP instruction, but do have instructions that can be used for the purpose. In 8086 CPUs the instruction

1700:

typically have directives to, e.g., define macros, define variables, set variables to the result of an arithmetic, logical or string expression, iterate, conditionally generate code. Some of those directives may be restricted to use within a macro definition, e.g.,

649:, most of them are able to perform jump-instruction replacements (long jumps replaced by short or relative jumps) in any number of passes, on request. Others may even do simple rearrangement or insertion of instructions, such as some assemblers for 4168:

The non-original ideas, contained in the following text, have been derived from a number of sources, ... It is felt, however, that acknowledgement should be made to Prof. John von Neumann and to Dr. Herman Goldstein for many fruitful discussions

1325:

or assembly-language syntax may exist for a single instruction set, typically instantiated in different assembler programs. In these cases, the most popular one is usually that supplied by the CPU manufacturer and used in its documentation.

398:

for operands. Thus, programmers are freed from tedious repetitive calculations and assembler programs are much more readable than machine code. Depending on the architecture, these elements may also be combined for specific instructions or

1608:

of data. These instructions can also define whether the data is available to outside programs (programs assembled separately) or only to the program in which the data section is defined. Some assemblers classify these as pseudo-ops.

1071:

direct) addresses. Other assemblers may use separate opcode mnemonics such as L for "move memory to register", ST for "move register to memory", LR for "move register to register", MVI for "move immediate operand to memory", etc.

1096:

The first byte, 88h, identifies a move between a byte-sized register and either another register or memory, and the second byte, E0h, is encoded (with three bit-fields) to specify that both operands are registers, the source is

812:. Later computers with much larger memories (especially disc storage), had the space to perform all necessary processing without such re-reading. The advantage of the multi-pass assembler is that the absence of errata makes the 1338:, supports all the 8080A instructions plus many more; Zilog invented an entirely new assembly language, not only for the new instructions but also for all of the 8080A instructions. For example, where Intel uses the mnemonics 953:

processor instructions and meta-statements (known variously as declarative operations, directives, pseudo-instructions, pseudo-operations and pseudo-ops), comments and data. Assembly language instructions usually consist of an

1626:

be used to manipulate presentation of a program to make it easier to read and maintain. Another common use of pseudo-ops is to reserve storage areas for run-time data and optionally initialize their contents to known values.

1871:(March 1970), and implemented by Marvin Kessler at IBM's Federal Systems Division, which provided IF/ELSE/ENDIF and similar control flow blocks for OS/360 assembler programs. This was a way to reduce or eliminate the use of 1048:) for instructions such as this, so the machine code above can be written as follows in assembly language, complete with an explanatory comment if required, after the semicolon. This is much easier to read and to remember. 2626:

that may or may not have originally been written in a high-level language, for example when trying to recreate programs for which source code is not available or has been lost, or cracking copy protection of proprietary

614:

for memory locations and other entities. The use of symbolic references is a key feature of assemblers, saving tedious calculations and manual address updates after program modifications. Most assemblers also include

1818:

programming language, which supports "preprocessor instructions" to set variables, and make conditional tests on their values. Unlike certain previous macro processors inside assemblers, the C preprocessor is not

2537:

system, telemetry must be interpreted and acted upon within strict time constraints. Such systems must eliminate sources of unpredictable delays, which may be created by (some) interpreted languages, automatic

1108:

In a case like this where the same mnemonic can represent more than one binary instruction, the assembler determines which instruction to generate by examining the operands. In the first example, the operand

2252:, who is credited by the IEEE Computer Society as the creator of the first "assembler". Reports on the EDSAC introduced the term "assembly" for the process of combining fields into an instruction word. SOAP ( 494:(when the read-only memory is integrated in the device, as in microcontrollers), or a data link using either an exact bit-by-bit copy of the object code or a text-based representation of that code (such as 1666:, and assign labels that refer to literal values or the result of simple computations performed by the assembler. Labels can also be used to initialize constants and variables with relocatable addresses. 5932: 2757:

make extensive use of disassembly for such a purpose. This technique is used by hackers to crack commercial software, and competitors to produce software with similar results from competing companies.

4005: 3950: 1286:

In each case, the MOV mnemonic is translated directly into one of the opcodes 88-8C, 8E, A0-A3, B0-BF, C6 or C7 by an assembler, and the programmer normally does not have to know or remember which.

1879:

in assembly language. This approach was widely accepted in the early 1980s (the latter days of large-scale assembly language use). IBM's High Level Assembler Toolkit includes such a macro package.

333:

to take place entirely in assembly language. While still irreplaceable for some purposes, the majority of programming is now conducted in higher-level interpreted and compiled languages. In "

4600: 1790:

It is also possible to use solely the macro processing abilities of an assembler to generate code written in completely different languages, for example, to generate a version of a program in

2497:

associated with a high-level language. Examples have included firmware for telephones, automobile fuel and ignition systems, air-conditioning control systems, security systems, and sensors.

5198: 3407: 1755:(1967), which was written in the SNOBOL Implementation Language (SIL), an assembly language for a virtual machine. The target machine would translate this to its native code using a 2272:. Today, assembly language is still used for direct hardware manipulation, access to specialized processor instructions, or to address critical performance issues. Typical uses are 4931: 1851:

occurs. To avoid any possible ambiguity, users of macro processors can parenthesize formal parameters inside macro definitions, or callers can parenthesize the input parameters.

1843:

the intention was that the caller would provide the name of a variable, and the "global" variable or constant b would be used to multiply "a". If foo is called with the parameter

422:. Some assemblers are hybrid, with, e.g., labels, in a specific column and other fields separated by delimiters; this became more common than column-oriented syntax in the 1960s. 2712:, which cannot rely on the availability of pre-existing system calls and must indeed implement them for the particular processor architecture on which the system will be running. 2500:

Programs with performance-sensitive inner loops, where assembly language provides optimization opportunities that are difficult to achieve in a high-level language. For example,

4108: 2422:

programmers. Moreover, increasing processor performance has meant that most CPUs sit idle most of the time, with delays caused by predictable bottlenecks such as cache misses,

264:, who, however, used the term to mean "a program that assembles another program consisting of several sections into a single program". The conversion process is referred to as 5054: 3260: 796:

The original reason for the use of one-pass assemblers was memory size and speed of assembly – often a second pass would require storing the symbol table in memory (to handle

298:

for operating system calls, and most assembly languages can be used universally with any operating system, as the language provides access to all the real capabilities of the

260: 3343:

Assembly language is often specific to a particular computer architecture so there are multiple types of assembly languages. ARM is an increasingly popular assembly language.

2209:

was introduced. Programs were written in absolute machine code, and loaded into the computer from punched paper tape, or toggled directly into memory from console switches.

1924:

Assemblers with a strong macro engine allow structured programming via macros, such as the switch macro provided with the Masm32 package (this code is a complete program):

2311:

and some PL/I eventually displaced much of this work, although a number of large organizations retained assembly-language application infrastructures well into the 1990s.

1639:) with memory locations and various constants. Usually, every constant and variable is given a name so instructions can reference those locations by name, thus promoting 1074:

If the same mnemonic is used for different instructions, that means that the mnemonic corresponds to several different binary instruction codes, excluding data (e.g. the

3219: 1573:

Some assemblers also support simple built-in macro-instructions that generate two or more machine instructions. For instance, with some Z80 assemblers the instruction

759:

There are two types of assemblers based on how many passes through the source are needed (how many times the assembler reads the source) to produce the object file.

407:

or other data as well as fixed addresses. Many assemblers offer additional mechanisms to facilitate program development, to control the assembly process, and to aid

2949: 5393: 4967: 4374: 2890:

In 7070 Autocoder, a macro definition is a 7070 macro generator program that the assembler calls; Autocoder provides special macros for macro generators to use.

3475: 2651:

programs. Although few programmers today regularly work with assembly language as a tool, the underlying concepts remain important. Such fundamental topics as

1864: 2523:

Programs that create vectorized functions for programs in higher-level languages such as C. In the higher-level language this is sometimes aided by compiler

739:. A single assembler may also have different modes in order to support variations in syntactic forms as well as their exact semantic interpretations (such as 3453:

Used as a meta-assembler, it enables the user to design his own programming languages and to generate processors for such languages with a minimum of effort.

3144: 1794:

using a pure macro assembler program containing lines of COBOL code inside assembly time operators instructing the assembler to generate arbitrary code. IBM

439:

facility so that (parameterized) assembly language text can be represented by a name, and that name can be used to insert the expanded text into other code.

2763:

Assemblers can be used to generate blocks of data, with no high-level language overhead, from formatted and commented source code, to be used by other code.

2546:. However, some higher-level languages incorporate run-time components and operating system interfaces that can introduce such delays. Choosing assembly or 4813: 4017: 3687: 1643:. In executable code, the name of each subroutine is associated with its entry point, so any calls to a subroutine can use its name. Inside subroutines, 564:) is assembler code contained within a high-level language program. This is most often used in systems programs which need direct access to the hardware. 3438: 3690: 4903: 4742: 1593: 3692: 470:). Cross-assembling facilitates the development of programs for systems that do not have the resources to support software development, such as an 6028: 2479:, high-repetition interrupts require the shortest number of cycles per interrupt, such as an interrupt that occurs 1000 or 10000 times a second. 2342:

high-level language compilers suitable for microcomputer use. Similarly, assembly language is the default choice for 8-bit consoles such as the

6048: 2369:

spreadsheet. As computer speed grew exponentially, assembly language became a tool for speeding up parts of programs, such as the rendering of

1078:

in this example), depending on the operands that follow the mnemonic. For example, for the x86/IA-32 CPUs, the Intel assembly language syntax

4683: 4873: 4792: 4420: 3857: 3710: 793:, addresses may be recalculated between passes to allow replacing pessimistic code with code tailored to the exact distance from the target. 2734:). Programs using such facilities can then construct abstractions using different assembly language on each hardware platform. The system's 6043: 5386: 4048: 2527:

which map directly to SIMD mnemonics, but nevertheless result in a one-to-one assembly conversion specific for the given vector processor.

5083: 4924: 4708: 3980: 2296: 1883: 846:

may be undefined. A two-pass assembler would determine both addresses in pass 1, so they would be known when generating code in pass 2.

5564: 1811: 511:

is a program that provides language abstractions more often associated with high-level languages, such as advanced control structures (

4996: 3898:

The following minor restriction or limitation is in effect with regard to the use of 1401 Autocoder when coding macro instructions ...

3119: 2760:

Assembly language is used to enhance speed of execution, especially in early personal computers with limited processing power and RAM.

2715:

Some compilers translate high-level languages into assembly first before fully compiling, allowing the assembly code to be viewed for

2375:, rather than a dominant development language. In the 1990s, assembly language was used to get performance out of systems such as the 1444:), and there is at least one opcode mnemonic defined for each machine language instruction. Each instruction typically consists of an 512: 4104: 3756: 2689:

code, the low-level code that initializes and tests the system hardware prior to booting the operating system and is often stored in

1289:

Transforming assembly language into machine code is the job of an assembler, and the reverse can at least partially be achieved by a

931: 4767: 4314: 3248: 6038: 3984: 3654: 2914: 2299:(ESPOL), an Algol dialect. Many commercial applications were written in assembly language as well, including a large amount of the 4621: 2637:), which is possible via several methods. The most widely employed method is altering program code at the assembly language level. 2486:

instruction at the core of many encryption algorithms, as well as querying the parity of a byte or the 4-bit carry of an addition.

1604:

There are instructions used to define data elements to hold data and variables. They define the type of data, the length and the

5587: 5379: 4848: 4650: 4226: 4186: 3558: 3544: 1728:, where its #define directive typically is used to create short single line macros. Assembler macro instructions, like macros in 5317:("An online book full of helpful ASM info, tutorials and code examples" by the ASM Community, archived at the internet archive.) 1732:

and some other languages, can be lengthy "programs" by themselves, executed by interpretation by the assembler during assembly.

1720:

In assembly language, the term "macro" represents a more comprehensive concept than it does in some other contexts, such as the

5970: 5486: 5476: 3123: 2918: 2295:(1961) was the first computer for which an operating system was not developed entirely in assembly language; it was written in 4500: 2406:

Although assembly language has specific niche uses where it is important (see below), there are other tools for optimization.

5534: 5491: 5481: 5471: 3530:

Salomon, David (February 1993) . Written at California State University, Northridge, California, US. Chivers, Ian D. (ed.).

3024: 2988: 2539: 785:

assembler will make a pessimistic estimate when first encountering the operation, and if necessary, pad it with one or more "

418:

in the 1950s and early 1960s. Some assemblers have free-form syntax, with fields separated by delimiters, e.g., punctuation,

17: 3227: 2745:. Many programs are distributed only in machine code form which is straightforward to translate into assembly language by a 1301:

between many simple assembly statements and machine language instructions. However, in some cases, an assembler may provide

5448: 4470: 3194: 2417:, for example. Assembler can be used to optimize for speed or optimize for size. In the case of speed optimization, modern 1596:

published Standard 694 for a uniform set of mnemonics to be used by all assemblers. The standard has since been withdrawn.

780:

create a table with all symbols and their values in the first passes, then use the table in later passes to generate code.

2938: 5171: 4512:... design changes tend to affect performance more than ... one should not skip straight to assembly language until ... 2980: 2249: 251: 5042: 4956: 1400:), there is no requirement to use a manufacturer's own published assembly language with that manufacturer's products. 5291: 5268: 5152: 5106: 5072: 5036: 3926: 3668: 3604: 3583:

Finlayson, Ian; Davis, Brandon; Gavin, Peter; Uh, Gang-Ryung; Whalley, David; Själander, Magnus; Tyson, Gary (2013).

3552: 3466: 3307: 3098: 2513: 2253: 826:

in the following code snippet, a one-pass assembler would be able to determine the address of the backward reference

4562: 5463: 4153: 3777: 2505: 1740: 290:

Sometimes there is more than one assembler for the same architecture, and sometimes an assembler is specific to an

3328: 1462:

are often used to specify a combination of an opcode with a specific operand, e.g., the System/360 assemblers use

5887: 5715: 5443: 2482:

Programs that need to use processor-specific instructions not implemented in a compiler. A common example is the

2403:

There has been debate over the usefulness and performance of assembly language relative to high-level languages.

2385: 2213:"is credited with inventing assembly language" based on theoretical work she began in 1947, while working on the 1780: 1437: 1294: 982: 927: 665: 307: 5194: 4532: 2578:

Situations where complete control over the environment is required, in extremely high-security situations where

1825:

Despite the power of macro processing, it fell into disuse in many high level languages (major exceptions being

1121:

is a valid register name and not a valid numeric constant (hexadecimal, decimal, octal, or binary), so only the

598:

for operations and addressing modes into their numerical equivalents. This representation typically includes an

5557: 5523: 5438: 5301: 4136: 3821: 3047:

Programming in assembly language has the same benefits as programming in machine language, except it is easier.

2547: 2218: 993:

for this instruction is 10110 followed by a 3-bit identifier for which register to use. The identifier for the

923: 696: 595: 295: 198: 180: 4458:

Windows Assembly Language and Systems Programming: 16- and 32-Bit Low-Level Programming for the PC and Windows

3429: 896:

Sophisticated macro processing (although available on ordinary assemblers since the late 1950s for, e.g., the

283:

Because assembly depends on the machine code instructions, each assembly language is specific to a particular

5632: 5453: 4441: 2723: 2579: 2347: 619:

facilities for performing textual substitution – e.g., to generate common short sequences of instructions as

515:, DO CASE, etc.) and high-level abstract data types, including structures/records, unions, classes, and sets. 395: 5360: 4082: 3589:

Proceedings of the 14th ACM SIGPLAN/SIGBED conference on Languages, compilers and tools for embedded systems

414:

Some are column oriented, with specific fields in specific columns; this was very common for machines using

5975: 5099: 4895: 3374: 3060: 2809: 2234: 1736:

assembly programs, optionally introduce embedded debugging code via parameters and other similar features.

915: 704: 634: 194: 190: 1802:. The user specifies options by coding a series of assembler macros. Assembling these macros generates a 6023: 6007: 3653:(September 2003) . "Foreword ("Why would anyone learn this stuff?") / Chapter 12 – Classes and Objects". 3499: 2867:). Each assembler will typically generate only one of two or more redundant instruction encodings, but a 2781: 1784: 1776: 963: 911: 681: 379: 86: 4738: 1651:

which are often lexically distinct from normal symbols (e.g., the use of "10$ " as a GOTO destination).

386:, etc. Some of the mnemonics may be built-in and some user-defined. Many operations require one or more 5993: 5922: 5892: 5512: 5260: 2660: 801: 685: 224:

The first assembly code in which a language is used to represent machine code instructions is found in

2314:

Assembly language has long been the primary development language for 8-bit home computers such as the

1330:

independently produced CPUs compatible with Intel instruction sets invented their own mnemonics. The

6033: 5877: 5869: 5622: 5550: 4483:

Always the debate rages about the applicability of assembly language in our modern programming world.

3942: 3918: 3539:. Ellis Horwood Series In Computers And Their Applications (1 ed.). Chicester, West Sussex, UK: 2599: 2509: 2391: 2264: 919: 404: 342:

five in productivity, and with concomitant gains in reliability, simplicity, and comprehensibility."

5330: 1440:. Generally, a mnemonic is a symbolic name for a single executable machine language instruction (an 664:

Assemblers have been available since the 1950s, as the first step above machine language and before

5902: 5882: 4687: 4149: 2853:

However, that does not mean that the assembler programs implementing those languages are universal.

2794: 2754: 2727: 2476: 2269: 1909:). The language was classified as an assembler because it worked with raw machine elements such as 1903: 1899: 1826: 1725: 1631: 1605: 1306: 616: 436: 391: 351: 206: 78: 70: 4869: 4838: 4817: 4788: 4590: 3723: 2533:

programs such as simulations, flight navigation systems, and medical equipment. For example, in a

5730: 4988: 2825: 2709: 2543: 2335: 2206: 1771:) and with IBM's "real time transaction processing" add-ons, Customer Information Control System 766:

process the source code once. For symbols used before they are defined, the assembler will emit

700: 549: 375: 330: 315: 202: 4056: 390:

in order to form a complete instruction. Most assemblers permit named constants, registers, and

5720: 4267: 3881: 3752: 3277: 3170: 2648: 2609:

Situations where no high-level language exists, on a new or specialized processor for which no

2569: 2489:

A stand-alone executable of compact size is required that must execute without recourse to the

2371: 1860: 1161:

and otherwise contains only characters that are hexadecimal digits, such as the word "BEACH".)

735:. Despite different appearances, different syntactic forms generally generate the same numeric 654: 587: 82: 66: 4716: 1822:

because it lacks the ability to either loop or "go to", the latter allowing programs to loop.

1669:

Assembly languages, like most other computer languages, allow comments to be added to program

5652: 5592: 5024:

Programming from the Ground Up - An introduction to programming using linux assembly language

4221: 4181: 3846: 3540: 3273: 2945: 2553:

Cryptographic algorithms that must always take strictly the same time to execute, preventing

2319: 1795: 1768: 1640: 1314: 1041: 790: 748: 638: 491: 299: 284: 242: 184: 5098:. Computer software engineering series (1st printing, 1st ed.). Potomac, Maryland, US: 4253: 4224:(1980). "Programming the EDSAC: Early Programming Activity at the University of Cambridge". 5980: 5914: 5693: 5602: 5431: 5402: 5247: 4586: 4279: 4079:"NESHLA: The High Level, Open Source, 6502 Assembler for the Nintendo Entertainment System" 3973:"*Concept* Report 14 - Implementation of Macros To Permit Structured Programming in OS/360" 3674: 3125:

High Level Assembler for z/OS & z/VM & z/VSE Language Reference Version 1 Release 6

2920:

High Level Assembler for z/OS & z/VM & z/VSE Language Reference Version 1 Release 6

2735: 1807: 880: 507: 419: 152: 61: 3748: 3399: 2550:

for such systems gives programmers greater visibility and control over processing details.

2453:. Programs for these computers of the 1970s and 1980s are often written in the context of 1436:

Instructions (statements) in assembly language are generally very simple, unlike those in

8: 5778: 5710: 5617: 5028: 4763: 4310: 4132: 3784: 3747:

Ferrari, Adam; Batson, Alan; Lack, Mike; Jones, Anita (2018-11-19) . Evans, David (ed.).

3280:

vs. VM/CMS; the binary/executable formats for different operating systems may also vary.)

3256: 2814: 2742: 2730:, allow the programmer to embed assembly language directly in the source code (so called 2616: 2530: 2494: 2450: 2418: 2281: 2222: 1819: 901: 897: 326: 229: 4283: 3972: 1622:

is reserved for directives that generate object code, such as those that generate data.

5637: 4629: 4595: 4306: 4203: 3610: 3299: 3174: 3038: 2864: 2524: 1914: 986: 893:

High-level abstract data types, including structures/records, unions, classes, and sets

817: 813: 771: 650: 466:

system) of a different type from the system on which the resulting code is to run (the

214: 121: 4658: 4591:"Writing the Fastest Code, by Hand, for Fun: A Human Computer Keeps Speeding Up Chips" 4396: 4369: 4291: 3531: 1113:

is a valid hexadecimal numeric constant and is not a valid register name, so only the

774:

or the loader to patch the locations where the as yet undefined symbols had been used.

5849: 5735: 5627: 5612: 5426: 5355: 5287: 5264: 5167: 5148: 5144: 5120: 5112: 5102: 5092: 5068: 5032: 4466: 4435: 4401: 4344: 3922: 3910: 3719: 3664: 3600: 3584: 3548: 3303: 3200: 3190: 3186: 3070: 3042: 3030: 3020: 2984: 2698: 2656: 2652: 2469: 2433:

There are some situations in which developers might choose to use assembly language:

2354: 1799: 1655: 797: 499: 218: 4336: 4207: 1863:

elements to encode execution flow. The earliest example of this approach was in the

1709:, while others may be permitted within open code (outside macro definitions), e.g., 1374:

for various data transfer instructions, the Z80 assembly language uses the mnemonic

294:

or to particular operating systems. Most assembly languages do not provide specific

5816: 5725: 5664: 5642: 4496: 4391: 4383: 4287: 4235: 4195: 4184:(April 1982). "The Development of Computer Programming in Britain (1945 to 1955)". 3712:

Intel Architecture Software Developer's Manual, Volume 2: Instruction Set Reference

3614: 3592: 3295: 3012: 2690: 2644: 2230: 2226: 1318:

they do so differ; the corresponding assembly languages reflect these differences.

967: 620: 556: 541: 483: 459: 334: 291: 237: 183:

with a very strong correspondence between the instructions in the language and the

5344: 4142:

General considerations in the design of an all purpose electronic digital computer

2263:

Assembly languages eliminate much of the error-prone, tedious, and time-consuming

959: 387: 39: 5700: 5688: 5647: 5573: 5371: 5334: 4456: 3946: 3660: 3178: 2731: 2490: 2277: 1783:, the airline/financial system that began in the 1970s and still runs many large 1756: 1748: 475: 471: 400: 210: 74: 4387: 5942: 5824: 5796: 5745: 5607: 5283: 5215:"Introduction to Assembly Language Programming: From Soup to Nuts: ARM Edition" 5087: 4528: 4254:"1985 Computer Pioneer Award 'For assembly language programming' David Wheeler" 3633: 2610: 2585: 2501: 2483: 2210: 1876: 1744: 1663: 1547: 1543: 905: 727: 520: 455: 247: 225: 4032: 3431:

Xerox Meta-Symbol Sigma 5-9 Computers Language and Operations Reference Manual

3016: 1011:

This binary computer code can be made more human-readable by expressing it in

6017: 5947: 5859: 5182: 5116: 5064: 4962: 4348: 3883:

1401 Autocoder System, Program #1401-AU-037, Version 3, Modification Level 11

3204: 3066: 3034: 2974: 2738:

can then use these processor-specific components through a uniform interface.

2664: 2593: 2554: 2465: 2427: 2300: 2292: 2273: 1721: 732: 545: 276:. The computational step when an assembler is processing a program is called 5022: 4966:(2.08 ed.), FILESPEC.TXT, NECPINW.ASM, EUROFONT.INC from NECPI208.ZIP, 4239: 4199: 3596: 1414:

types of instruction statements that are used to define program operations:

5844: 5657: 5416: 5226: 4679: 4148:(2 ed.). The Institute for Advanced Study, Princeton, New Jersey, US: 3842: 3650: 2799: 2746: 2446: 2430:. This has made raw code execution speed a non-issue for many programmers. 2423: 2414: 2413:

of programming language popularity ranks assembly language at 11, ahead of

2362: 2331: 1868: 1658:, provide flexible symbol management, letting programmers manage different 1618:

file, and the values of internal assembler parameters". Sometimes the term

1290: 1240:

The syntax of MOV can also be more complex as the following examples show.

998: 809: 805: 736: 717: 658: 537: 415: 367: 347: 255: 187: 48:

from an assembler—showing original assembly language (right) for the

4405: 3094: 2596:, or other items very close to the hardware or low-level operating system. 834:, but would not be able to determine the address of the forward reference 610:

and data. The assembler also calculates constant expressions and resolves

5957: 5897: 5705: 4554: 3468:

Sperry Univac Computer Systems Meta-Assembler (MASM) Programmer Reference

3358:(1986). "No Silver Bullet—Essence and Accident in Software Engineering". 3355: 2804: 2749:, but more difficult to translate into a higher-level language through a 2634: 2623: 2564:) and dav1d (the reference decoder for AV1) contain assembly to leverage 2534: 2458: 2410: 2376: 2366: 2327: 1891: 1670: 1335: 1012: 990: 684:. There have also been several classes of translators and semi-automatic 646: 583: 479: 338: 303: 273: 111: 4140: 4006:"High Level Assembler Toolkit Feature Increases Programmer Productivity" 3788: 688:

with properties similar to both assembly and high-level languages, with

5937: 5763: 5597: 5230: 5214: 2750: 2630: 2589: 2442: 2343: 2291:

Numerous programs have been written entirely in assembly language. The

1803: 1396:

instruction set architecture are isomorphic (somewhat like English and

786: 627: 611: 3585:"Improving processor efficiency by statically pipelining instructions" 2881:

32-bit and 64-bit x86-family CPUs without Intel's help or endorsement.

2244:(EDSAC) had an assembler (named "initial orders") integrated into its 1145:. (The same rule also prevents ambiguity with the names of registers 1033:

is a hexadecimal representation of the value 01100001, which is 97 in

5834: 4462: 4105:"Kathleen Booth: Assembling Early Computers While Inventing Assembly" 2716: 2708:

Assembly language is often used for low-level code, for instance for

2668: 2603: 2454: 1887: 1691: 1659: 1397: 1331: 1298: 1254:; Move the 4 bytes in memory at the address contained in EBX into EAX 707:. For instance, an instruction to add memory data to a register in a 689: 525: 495: 408: 383: 6002: 5305: 3813: 2775: 1157:, as well as with any user-defined symbol that ends with the letter 306:

mechanisms ultimately rest. In contrast to assembly languages, most

5791: 5683: 5674: 5542: 4524: 2789: 2672: 2464:

Code that must interact directly with the hardware, for example in

2380: 2315: 1906: 1902:

operating system, and what was reported to be the first commercial

1322: 1141:, specifically so that it cannot appear to be the name of register 1117:

instruction can be applicable. In the second example, the operand

1038: 950: 789:" instructions in a later pass or the errata. In an assembler with 591: 363: 319: 49: 2575:

Modify and extend legacy code written for IBM mainframe computers.

1164:

Returning to the original example, while the x86 opcode 10110000 (

5952: 5839: 5829: 5768: 5755: 4925:"z/OS Version 2 Release 3 DFSMS Macro Instructions for Data Sets" 4078: 2686: 2308: 2257: 2245: 1752: 1566:

with zero masks. For the SPARC architecture, these are known as

1454: 1383: 1379: 1034: 767: 669: 633:

Some assemblers may also be able to perform some simple types of

311: 5124: 4041: 3074: 3062:

Programming the IBM 1401, a self-instructional programmed manual

2817:– an educational computer model with a base-10 assembly language 350:

source code is written in assembly; more than 97% is written in

5854: 5786: 5244:

PDP-11. Assembler Language Programming and Machine Organization

4843: 3095:"High Level Assembler – Opcodes overview, Assembler Directives" 2820: 2358: 1910: 1629:

Symbolic assemblers let programmers associate arbitrary names (

1441: 1418: 955: 949:

A program written in assembly language consists of a series of

603: 371: 325:

In the first decades of computing, it was commonplace for both

236:. Assembly code is converted into executable machine code by a 52: 5339: 4049:"assembly language: Definition and Much More from Answers.com" 3464: 3183:

The preparation of programs for an electronic digital computer

1082:

represents an instruction that moves the contents of register

261:

The Preparation of Programs for an Electronic Digital Computer

4337:"Oct. 15, 1956: Fortran Forever Changes Computing's Fortunes" 3290:

Austerlitz, Howard (2003). "Computer Programming Languages".

3220:"History of Computer Languages - The Classical Decade, 1950s" 2944:. Computer Science and Engineering. College of Engineering, 2379:

and as the primary language for arcade hardware based on the

2338: 2304: 2241: 2214: 1875:

operations in assembly code, one of the main factors causing

1830: 1791: 1706: 1392: 978: 677: 673: 487: 5365: 820:

if the assembler directly produces executable code) faster.

445:

refers to any assembler input outside of a macro definition.

5806: 5801: 5740: 3751:. Computer Science CS216: Program and Data Representation. 3283: 2995:

Assembly language may also be called symbolic machine code.

2722:

Some compilers for relatively low-level languages, such as

2702: 2694: 2565: 2517: 2205:

Assembly languages were not available at the time when the

1895: 1872: 1772: 1729: 1644: 744: 740: 2560:

Video encoders and decoders such as rav1e (an encoder for

2441:

that have limited high-level language options such as the

1759:. This allowed a high degree of portability for the time. 1431: 1266:; Move the contents of CL into the byte at address ESI+EAX 970:

instructions that can be loaded into memory and executed.

887:

High-level procedure/function declarations and invocations

5327: 4270:(1949). "The EDSAC – an Electronic Calculating Machine". 4013: 3366: 3129: 2924: 2561: 2323: 1764: 1388: 974: 708: 642: 607: 3360:

Proceedings of the IFIP Tenth World Computing Conference

3249:"How do assembly languages depend on operating systems?" 1523:. Some disassemblers recognize this and will decode the 4957:"Specification and reference documentation for NECPINW" 4375:

Journal of the American Medical Informatics Association

3630:

System Software: An Introduction to Systems Programming

3007:

Streib, James T. (2020). "Guide to Assembly Language".

1647:

destinations are given labels. Some assemblers support

5349: 3746: 1833:

and PL/I) while remaining a perennial for assemblers.

5991: 3943:"Macros (C/C++), MSDN Library for Visual Studio 2008" 3935: 3582: 2028:; the Masm32 switch allows "variable cases" 1854: 1037:. Assembly language for the 8086 family provides the 641:. One concrete example of this may be the ubiquitous 5235:

Peter Norton's Assembly Language Book for the IBM PC

5195:"Introduction to MIPS Assembly Language Programming" 2771: 1767:'s Conversational Monitor System / Virtual Machine ( 394:

for program and memory locations, and can calculate

5361:

Authoring Windows Applications In Assembly Language

4214: 4174: 2248:program. It used one-letter mnemonics developed by 5401: 5280:Introduction to RISC Assembly Language Programming 5183:"x86-64 Assembly Language Programming with Ubuntu" 5091: 3847:"Chapter 8. MASM: Directives & Pseudo-Opcodes" 3427: 2685:Assembly language is typically used in a system's 2019:; in contrast to most other programming languages, 1281:; Move the contents of DX into segment register DS 890:Advanced control structures (IF/THEN/ELSE, SWITCH) 747:-syntax, ideal mode, etc., in the special case of 246:. The term "assembler" is generally attributed to 4961:NECPINW.CPI - DOS code page switching driver for 4948: 4309:. Computing History - A Chronology of Computing. 3169: 800:), rewinding and rereading the program source on 528:to control the low level operation of a computer. 6015: 4070: 1508:being a pseudo-opcode to encode the instruction 4701: 4581: 4579: 4030: 3525: 3523: 3521: 3519: 3500:"How to Use Inline Assembly Language in C Code" 3348: 2606:where additional overhead is kept to a minimum. 1859:Packages of macros have been written providing 1474:("NO OPeration" – do nothing for one step) for 1188:. Assembly language examples for these follow. 1090:. The hexadecimal form of this instruction is: 1025:means "Move a copy of the following value into 695:There may be several assemblers with different 458:) is an assembler that is run on a computer or 322:, much more complicated tasks than assembling. 197:per machine instruction (1:1), but constants, 5094:Assemblers, Compilers, and Program Translation 4816:. git.videolan.org. 2010-09-29. Archived from 4220: 4180: 3329:"Learn Assembly Language Programming with ARM" 3143:Booth, Andrew D; Britten, Kathleen HV (1947). 2909: 2907: 482:must be transferred to the target system, via 5558: 5387: 4980: 4887: 4806: 4127: 4125: 4096: 3903: 3705: 3703: 3701: 3699: 3391: 3211: 3112: 3000: 2242:Electronic Delay Storage Automatic Calculator 1674:difficult to read when changes must be made. 1592:Mnemonics are arbitrary symbols; in 1985 the 692:as perhaps one of the better-known examples. 145:and several others depending on the assembler 4576: 4546: 4246: 4131: 3964: 3645: 3643: 3516: 3142: 3086: 3059:Saxon, James A.; Plette, William S. (1962). 2863:redundant codes than to eliminate them (see 1739:Macro assemblers often allow macros to take 973:For example, the instruction below tells an 5225: 5084:University of North Carolina at Chapel Hill 4448: 4412: 4260: 4076: 3981:International Business Machines Corporation 3805: 3320: 3058: 3011:. Cham: Springer International Publishing. 2904: 2297:Executive Systems Problem Oriented Language 2195: 770:after the eventual definition, telling the 357: 5565: 5551: 5394: 5380: 5081: 4756: 4730: 4488: 4423:. Archived from the original on 2008-07-13 4122: 3778:"The SPARC Architecture Manual, Version 8" 3770: 3740: 3696: 3289: 3241: 3163: 2966: 2643:Assembly language is still taught in most 2357:was written in assembly language, such as 314:across multiple architectures but require 5138: 4896:"Chapter 1 – Why Study Assembly Language" 4781: 4672: 4614: 4395: 4298: 3874: 3835: 3640: 3621: 3375:"linux kernel mainline 4.9 sloccount.txt" 3152:. Institute for Advanced Study, Princeton 3052: 2200: 1921:effective use of higher-level languages. 1886:, a "stream-oriented" assembler for 8080/ 1662:, automatically calculate offsets within 5254: 5020: 4893: 4643: 4102: 3909: 3545:Simon & Schuster International Group 3397: 3217: 3092: 3009:Undergraduate Topics in Computer Science 2979:. North Charleston, South Carolina, US: 2931: 2303:software written by large corporations. 2260:computer written by Stan Poley in 1955. 1378:for all of them. A similar case is the 874: 645:assemblers from various vendors. Called 5277: 5082:Calingaert, Peter (1979) . Written at 5058: 4585: 4552: 4304: 4227:IEEE Annals of the History of Computing 4187:IEEE Annals of the History of Computing 3970: 3529: 3465:Sperry Univac Computer Systems (1977). 3272:(NB. System calls often vary, e.g. for 2679: 2225:(later her husband) with mathematician 1432:Opcode mnemonics and extended mnemonics 883:provide language abstractions such as: 548:also provided a Meta-Assembler for the 14: 6029:Computer-related introductions in 1949 6016: 5356:Assembly Language Programming Examples 5241: 4870:"README.md · 1.1.0 · VideoLAN / dav1d" 4736: 4454: 4418: 4368:Collen, Morris F. (March–April 1994). 4367: 4307:"The IBM 650 Magnetic Drum Calculator" 4266: 4016:. 1995-12-12. A95-1432. Archived from 3811: 3326: 3006: 2972: 1612: 6049:Programming languages created in 1949 5546: 5375: 5180: 4517: 4494: 3292:Data Acquisition Techniques Using PCs 2619:and modifying program files such as: 1787:(CRS) and credit card systems today. 838:when assembling the branch statement 5572: 5212: 5192: 5161: 4986: 4954: 3649: 3627: 3372: 3065:. Englewood Cliffs, New Jersey, US: 944: 938: 193:. Assembly language usually has one 6044:Programming language implementation 4791:. eigen.tuxfamily.org. 2008-08-01. 4739:"A Crash Course in Modern Hardware" 4034:A-Natural Language Reference Manual 3915:The Macro Implementation of SNOBOL4 2884: 2874: 2871:will usually recognize any of them. 2856: 2256:) was an assembly language for the 1986:; generate a number between 0 and 8 754: 366:to represent, e.g., each low-level 24: 5328:Unix Assembly Language Programming 5061:MIPS Assembly Language Programming 5014: 2981:CreateSpace Independent Publishing 2973:Archer, Benjamin (November 2016). 2285: 1855:Support for structured programming 1599: 1403: 1065:; Load AL with 97 decimal (61 hex) 997:register is 000, so the following 653:that can help optimize a sensible 544:of computers are meta-assemblers. 524:is a program that helps prepare a 25: 6060: 5321: 5166:(2nd ed.). No Starch Press. 4334: 4272:Journal of Scientific Instruments 4077:Provinciano, Brian (2005-04-17). 3971:Kessler, Marvin M. (1970-12-18). 3917:. San Francisco, California, US: 2254:Symbolic Optimal Assembly Program 2154:; loop until the sign flag is set 1408: 1168:) copies an 8-bit value into the 1005:register with the data 01100001. 6001: 4987:Paul, Matthias R. (2002-05-13). 4814:"x264.git/common/x86/dct-32.asm" 4678: 3841: 3300:10.1016/b978-012068377-2/50013-9 2774: 2580:nothing can be taken for granted 2398: 1542:. Similarly, IBM assemblers for 1235:; Load DL with immediate value 3 1220:; Load CL with immediate value 2 1205:; Load AL with immediate value 1 908:(S/360), amongst other machines) 721:, whereas this would be written 666:high-level programming languages 478:. In such a case, the resulting 435:is an assembler that includes a 308:high-level programming languages 38: 6039:Low-level programming languages 5888:Light-weight Linux distribution 5716:Hacking of consumer electronics 5345:PPR: Learning Assembly Language 5201:from the original on 2020-03-24 5045:from the original on 2020-03-24 4999:from the original on 2018-09-10 4970:from the original on 2017-09-10 4937:from the original on 2021-06-25 4917: 4906:from the original on 2020-03-24 4876:from the original on 2023-02-22 4862: 4851:from the original on 2023-02-22 4831: 4795:from the original on 2020-03-24 4770:from the original on 2008-07-02 4745:from the original on 2020-03-24 4603:from the original on 2020-03-23 4565:from the original on 2020-03-24 4535:from the original on 2020-03-24 4503:from the original on 2020-03-24 4361: 4328: 4317:from the original on 2020-02-15 4159:from the original on 2020-03-24 4137:Britten, Kathleen Hylda Valerie 4111:from the original on 2020-03-24 4103:Dufresne, Steven (2018-08-21). 4085:from the original on 2020-03-24 4024: 3998: 3987:from the original on 2020-03-24 3977:MVS Software: Concept 14 Macros 3953:from the original on 2020-03-24 3863:from the original on 2020-03-24 3854:The Art of Computer Programming 3824:from the original on 2020-03-24 3759:from the original on 2020-03-24 3576: 3564:from the original on 2020-03-23 3492: 3481:from the original on 2022-10-09 3458: 3444:from the original on 2022-10-09 3428:Xerox Data Systems (Oct 1975). 3421: 3410:from the original on 2020-03-24 3354: 3263:from the original on 2020-03-24 3101:from the original on 2020-03-24 2955:from the original on 2020-03-24 2847: 2838: 2741:Assembly language is useful in 2085:"cases 1 to 3: other" 1806:to build the system, including 1585:. These are sometimes known as 1582: 1578: 1574: 1563: 1559: 1555: 1551: 1539: 1524: 1509: 1505: 1501: 1486: 1475: 1471: 1467: 1463: 1125:instruction can be applicable. 568: 167:), often referred to simply as 5403:Types of programming languages 5141:Assembly Language Step-by-Step 4031:Whitesmiths Ltd (1980-07-15). 3979:. Gaithersburg, Maryland, US: 3294:. Elsevier. pp. 326–360. 3218:Fairhead, Harry (2017-11-16). 3136: 2976:Assembly Language For Students 2510:discrete cosine transformation 2437:Writing code for systems with 2219:Birkbeck, University of London 425: 221:are generally also supported. 181:low-level programming language 27:Low-level programming language 13: 1: 5503: 4764:"68K Programming in Fargo II" 4305:da Cruz, Frank (2019-05-17). 3628:Beck, Leland L. (1996). "2". 2897: 2348:Nintendo Entertainment System 5976:List of open-source hardware 5535:Programming paradigms navbox 5350:NASM – The Netwide Assembler 5237:. New York, US: Brady Books. 5164:The Art of Assembly Language 5100:Computer Science Press, Inc. 4737:Click, Cliff; Goetz, Brian. 4715:. 2010-01-30. Archived from 4657:. 2009-05-13. Archived from 4628:. 2010-01-30. Archived from 4455:Kauler, Barry (1997-01-09). 4421:"SegaBase Volume 6 - Saturn" 4370:"The Origins of Informatics" 3656:The Art of Assembly Language 3398:Daintith, John, ed. (2019). 2810:Instruction set architecture 2602:for monitoring, tracing and 2572:instructions when available. 2475:In an embedded processor or 2235:Institute for Advanced Study 1785:computer reservation systems 1466:as an extended mnemonic for 705:instruction set architecture 661:as efficiently as possible. 606:") as well as other control 573: 171:and commonly abbreviated as 7: 5021:Bartlett, Jonathan (2004). 4955:Paul, Matthias R. (2001) , 4839:"rav1e/README.md at v0.6.3" 4789:"BLAS Benchmark-August2008" 4709:"Code sourcery fails again" 4599:. Seattle, Washington, US. 4555:"Chapter 2 Software Basics" 4553:Rusling, David A. (1999) . 4495:Hsieh, Paul (2020-03-24) . 4388:10.1136/jamia.1994.95236152 4292:10.1088/0950-7671/26/12/301 3327:Carnes, Beau (2022-04-27). 2782:Computer programming portal 2767: 2383:integrated CPU/GPU such as 2112:"cases 4, 6 or 8" 1550:use the extended mnemonics 1334:CPU, an enhancement of the 912:Object-oriented programming 711:-family processor might be 98:; 77 years ago 10: 6065: 5893:Real-time operating system 5366:Assembly Optimization Tips 5352:BSD-licensed x86 assembler 5261:Morgan Kaufmann Publishers 5255:Sweetman, Dominic (1999). 5219:Open Educational Resources 4497:"Programming Optimization" 4419:Pettus, Sam (2008-01-10). 2844:Other than meta-assemblers 2719:and optimization purposes. 2600:Instruction set simulators 2409:As of July 2017, the 2221:following consultation by 1577:is recognized to generate 904:, and since the 1960s for 830:when assembling statement 81:), certain assemblers are 5966: 5913: 5878:Linux on embedded systems 5868: 5815: 5777: 5754: 5673: 5580: 5462: 5409: 5213:Kann, Charles W. (2021). 5193:Kann, Charles W. (2015). 4894:Bosworth, Edward (2016). 4440:: CS1 maint: unfit URL ( 3919:W. H. Freeman and Company 3404:A Dictionary of Computing 3185:(Reprint 1982 ed.). 3093:Kornelis, A. F. (2010) . 3017:10.1007/978-3-030-35639-2 1867:, originally proposed by 1847:, the macro expansion of 1677: 1654:Some assemblers, such as 1299:one-to-one correspondence 1101:, and the destination is 804:, or rereading a deck of 362:Assembly language uses a 120: 110: 92: 60: 37: 5883:Linux for mobile devices 5242:Singer, Michael (1980). 5139:Duntemann, Jeff (2000). 5059:Britton, Robert (2003). 4989:"[fd-dev] mkeyb" 4150:Birkbeck College, London 2831: 2795:Comparison of assemblers 2755:Interactive Disassembler 2710:operating system kernels 2542:, paging operations, or 2270:programming productivity 2196:Use of assembly language 1950:; use the Masm32 library 1926: 1682:Many assemblers support 1242: 1190: 1050: 958:mnemonic followed by an 941:below for more details. 358:Assembly language syntax 5731:PlayStation 3 Jailbreak 4268:Wilkes, Maurice Vincent 4240:10.1109/MAHC.1980.10009 4200:10.1109/MAHC.1982.10016 3597:10.1145/2465554.2465559 3547:. pp. 7, 237–238. 3171:Wilkes, Maurice Vincent 2826:Typed assembly language 2544:preemptive multitasking 2207:stored-program computer 1798:uses macros to perform 550:UNIVAC 1100/2200 series 331:application programming 5721:Homebrew (video games) 5304:. 2009. Archived from 5278:Waldron, John (1998). 5162:Hyde, Randall (2010). 4900:www.edwardbosworth.com 4222:Campbell-Kelly, Martin 4182:Campbell-Kelly, Martin 3814:"ZINT Z80 Interpreter" 3812:Moxham, James (1996). 3787:. 1992. Archived from 3753:University of Virginia 3722:. 1999. Archived from 3533:Assemblers and Loaders 3132:. 2014 . SC26-4940-06. 2927:. 2014 . SC26-4940-06. 2649:electronic engineering 2516:assembly version from 2201:Historical perspective 1861:structured programming 1840:foo: macro a load a*b 1726:C programming language 1568:synthetic instructions 1470:with a mask of 15 and 655:instruction scheduling 380:architectural register 378:, typically also each 55:and the assembled form 5915:Programming languages 5653:Single-board computer 5593:Board support package 5524:Programming languages 5248:John Wiley & Sons 4587:Markoff, John Gregory 3913:(1972). "Chapter 1". 3818:Z80 Op Codes for ZINT 3541:Ellis Horwood Limited 3362:. pp. 1069–1076. 3079:(NB. Use of the term 2946:Ohio State University 2548:lower-level languages 2320:Atari 8-bit computers 1686:, and others support 1641:self-documenting code 1315:computer architecture 983:immediate 8-bit value 981:processor to move an 881:high-level assemblers 875:High-level assemblers 791:peephole optimization 778:Multi-pass assemblers 285:computer architecture 165:symbolic machine code 18:Assembler (computing) 6008:Computer programming 5981:Open-source robotics 5971:Lightweight browsers 5694:Proprietary firmware 5603:Consumer electronics 5302:"ASM Community Book" 4133:Booth, Andrew Donald 4010:Announcement Letters 3749:"x86 Assembly Guide" 3356:Brooks, Frederick P. 3120:"Macro instructions" 2915:"Assembler language" 2753:. Tools such as the 2680:Typical applications 2451:graphing calculators 2419:optimizing compilers 2286:§ Current usage 2268:search for improved 1865:Concept-14 macro set 1814:control statements. 1808:job control language 1438:high-level languages 1295:high-level languages 1172:register, 10110001 ( 1044:(an abbreviation of 508:high-level assembler 153:computer programming 5711:Defective by Design 5618:Embedded hypervisor 5135:(2+xiv+270+6 pages) 5029:Bartlett Publishing 4930:. IBM. 2019-02-15. 4622:"Bit-field-badness" 4311:Columbia University 4284:1949JScI...26..385W 4139:(September 1947) . 3785:SPARC International 3373:Anguiano, Ricardo. 3257:Stack Exchange Inc. 3175:Wheeler, David John 2815:Little man computer 2743:reverse engineering 2617:Reverse engineering 2525:intrinsic functions 1894:(developers of the 1882:Another design was 1613:Assembly directives 1427:Assembly directives 879:More sophisticated 764:One-pass assemblers 368:machine instruction 327:systems programming 258:in their 1951 book 230:Andrew Donald Booth 122:Filename extensions 93:First appeared 34: 6024:Assembly languages 5779:Software libraries 5333:2020-02-17 at the 4684:"The Great Debate" 4651:"GCC makes a mess" 4596:The New York Times 3911:Griswold, Ralph E. 3591:. pp. 33–44. 2939:"Assembly: Review" 2540:garbage collection 2470:interrupt handlers 2355:IBM PC compatibles 2240:In late 1948, the 2076:"case 2" 2058:"case 1" 2025:"case 7" 2010:"case 0" 1688:programmer-defined 1482:Extended mnemonics 1478:with a mask of 0. 1460:Extended mnemonics 1452:plus zero or more 1303:pseudoinstructions 1008:10110000 01100001 810:punched paper tape 798:forward references 651:RISC architectures 562:embedded assembler 240:referred to as an 161:assembler language 32: 5989: 5988: 5928:Assembly language 5870:Operating systems 5850:Stand-alone shell 5817:Programming tools 5736:Rooting (Android) 5628:Embedded software 5613:Embedded database 5513:Computer language 5500: 5499: 3720:Intel Corporation 3573:(xiv+294+4 pages) 3187:Tomash Publishers 3146:Coding for A.R.C. 3026:978-3-030-35638-5 2990:978-1-5403-7071-6 2699:IBM-compatible PC 2657:memory allocation 2653:binary arithmetic 2353:Key software for 1800:system generation 1684:predefined macros 1321:Multiple sets of 945:Assembly language 914:features such as 699:for a particular 500:Motorola S-record 302:, upon which all 234:Coding for A.R.C. 157:assembly language 149: 148: 112:Typing discipline 33:Assembly language 16:(Redirected from 6056: 6034:Embedded systems 6006: 6005: 5997: 5726:iOS jailbreaking 5643:Memory footprint 5574:Embedded systems 5567: 5560: 5553: 5544: 5543: 5539: 5533: 5528: 5522: 5517: 5511: 5396: 5389: 5382: 5373: 5372: 5316: 5314: 5313: 5297: 5274: 5251: 5246:. New York, US: 5238: 5222: 5209: 5207: 5206: 5189: 5187: 5177: 5158: 5134: 5132: 5131: 5097: 5078: 5053: 5051: 5050: 5008: 5007: 5005: 5004: 4984: 4978: 4977: 4976: 4975: 4952: 4946: 4945: 4943: 4942: 4936: 4929: 4921: 4915: 4914: 4912: 4911: 4891: 4885: 4884: 4882: 4881: 4866: 4860: 4859: 4857: 4856: 4835: 4829: 4828: 4826: 4825: 4810: 4804: 4803: 4801: 4800: 4785: 4779: 4778: 4776: 4775: 4760: 4754: 4753: 4751: 4750: 4734: 4728: 4727: 4725: 4724: 4705: 4699: 4698: 4696: 4695: 4686:. Archived from 4676: 4670: 4669: 4667: 4666: 4647: 4641: 4640: 4638: 4637: 4618: 4612: 4611: 4609: 4608: 4583: 4574: 4573: 4571: 4570: 4559:The Linux Kernel 4550: 4544: 4543: 4541: 4540: 4521: 4515: 4514: 4509: 4508: 4492: 4486: 4485: 4480: 4479: 4472:978-1-48227572-8 4452: 4446: 4445: 4439: 4431: 4429: 4428: 4416: 4410: 4409: 4399: 4365: 4359: 4358: 4356: 4355: 4332: 4326: 4325: 4323: 4322: 4302: 4296: 4295: 4264: 4258: 4257: 4250: 4244: 4243: 4218: 4212: 4211: 4178: 4172: 4171: 4165: 4164: 4158: 4147: 4129: 4120: 4119: 4117: 4116: 4100: 4094: 4093: 4091: 4090: 4074: 4068: 4067: 4065: 4064: 4055:. Archived from 4045: 4039: 4038: 4028: 4022: 4021: 4002: 3996: 3995: 3993: 3992: 3968: 3962: 3961: 3959: 3958: 3939: 3933: 3932: 3907: 3901: 3900: 3895: 3894: 3888: 3878: 3872: 3871: 3869: 3868: 3862: 3851: 3839: 3833: 3832: 3830: 3829: 3809: 3803: 3802: 3800: 3799: 3793: 3782: 3774: 3768: 3767: 3765: 3764: 3744: 3738: 3737: 3735: 3734: 3728: 3717: 3707: 3694: 3685: 3683: 3682: 3673:. Archived from 3647: 3638: 3637: 3625: 3619: 3618: 3580: 3574: 3572: 3570: 3569: 3563: 3538: 3527: 3514: 3513: 3511: 3510: 3496: 3490: 3489: 3487: 3486: 3480: 3473: 3462: 3456: 3455: 3450: 3449: 3443: 3436: 3425: 3419: 3418: 3416: 3415: 3400:"meta-assembler" 3395: 3389: 3388: 3386: 3385: 3370: 3364: 3363: 3352: 3346: 3345: 3340: 3339: 3333:freeCodeCamp.org 3324: 3318: 3317: 3287: 3281: 3271: 3269: 3268: 3245: 3239: 3238: 3236: 3235: 3226:. Archived from 3215: 3209: 3208: 3196:978-0-93822803-5 3179:Gill, Stanley J. 3167: 3161: 3160: 3158: 3157: 3151: 3140: 3134: 3133: 3116: 3110: 3109: 3107: 3106: 3090: 3084: 3081:assembly program 3078: 3056: 3050: 3049: 3004: 2998: 2997: 2970: 2964: 2963: 2961: 2960: 2954: 2943: 2935: 2929: 2928: 2911: 2891: 2888: 2882: 2878: 2872: 2865:don't-care terms 2860: 2854: 2851: 2845: 2842: 2784: 2779: 2778: 2671:processing, and 2661:stack processing 2645:computer science 2586:Computer viruses 2484:bitwise rotation 2440: 2439:older processors 2278:embedded systems 2265:first-generation 2231:Herman Goldstine 2227:John von Neumann 2191: 2188: 2185: 2182: 2179: 2176: 2173: 2170: 2167: 2164: 2161: 2158: 2155: 2152: 2149: 2146: 2143: 2140: 2137: 2134: 2131: 2130:; print 20 stars 2128: 2125: 2122: 2119: 2116: 2113: 2110: 2107: 2104: 2101: 2098: 2095: 2092: 2089: 2086: 2083: 2080: 2077: 2074: 2071: 2068: 2065: 2062: 2059: 2056: 2053: 2050: 2047: 2044: 2041: 2038: 2035: 2032: 2029: 2026: 2023: 2020: 2017: 2014: 2011: 2008: 2005: 2002: 1999: 1996: 1993: 1990: 1987: 1984: 1981: 1978: 1975: 1972: 1969: 1966: 1963: 1960: 1957: 1954: 1951: 1948: 1945: 1942: 1939: 1936: 1933: 1930: 1892:Whitesmiths Ltd. 1890:processors from 1850: 1846: 1698:Macro assemblers 1584: 1580: 1576: 1565: 1561: 1557: 1553: 1541: 1537: 1536: 1533: 1530: 1527: 1522: 1521: 1518: 1515: 1512: 1507: 1503: 1499: 1498: 1495: 1492: 1489: 1477: 1473: 1469: 1465: 1424:Data definitions 1282: 1279: 1276: 1273: 1270: 1267: 1264: 1261: 1258: 1255: 1252: 1249: 1246: 1236: 1233: 1230: 1227: 1224: 1221: 1218: 1215: 1212: 1209: 1206: 1203: 1200: 1197: 1194: 1183: 1176:) moves it into 1175: 1167: 1140: 1136: 1132: 1124: 1120: 1116: 1112: 1081: 1077: 1066: 1063: 1060: 1057: 1054: 1032: 1024: 968:machine language 755:Number of passes 724: 723:addl (%ebx),%eax 714: 590:combinations of 582:program creates 557:inline assembler 542:SDS Sigma series 484:read-only memory 460:operating system 437:macroinstruction 401:addressing modes 335:No Silver Bullet 292:operating system 211:memory locations 144: 140: 136: 132: 128: 106: 104: 99: 46:secondary output 42: 35: 31: 21: 6064: 6063: 6059: 6058: 6057: 6055: 6054: 6053: 6014: 6013: 6012: 6000: 5992: 5990: 5985: 5962: 5909: 5864: 5811: 5773: 5750: 5701:Closed platform 5689:Custom firmware 5669: 5648:Microcontroller 5576: 5571: 5537: 5531: 5526: 5520: 5515: 5509: 5506: 5501: 5496: 5458: 5449:Very high-level 5405: 5400: 5335:Wayback Machine 5324: 5311: 5309: 5300: 5294: 5271: 5204: 5202: 5185: 5181:Jorgensen, Ed. 5174: 5155: 5129: 5127: 5109: 5088:Horowitz, Ellis 5075: 5048: 5046: 5039: 5017: 5015:Further reading 5012: 5011: 5002: 5000: 4985: 4981: 4973: 4971: 4953: 4949: 4940: 4938: 4934: 4927: 4923: 4922: 4918: 4909: 4907: 4892: 4888: 4879: 4877: 4868: 4867: 4863: 4854: 4852: 4837: 4836: 4832: 4823: 4821: 4812: 4811: 4807: 4798: 4796: 4787: 4786: 4782: 4773: 4771: 4762: 4761: 4757: 4748: 4746: 4735: 4731: 4722: 4720: 4713:hardwarebug.org 4707: 4706: 4702: 4693: 4691: 4677: 4673: 4664: 4662: 4655:hardwarebug.org 4649: 4648: 4644: 4635: 4633: 4626:hardwarebug.org 4620: 4619: 4615: 4606: 4604: 4584: 4577: 4568: 4566: 4551: 4547: 4538: 4536: 4523: 4522: 4518: 4506: 4504: 4493: 4489: 4477: 4475: 4473: 4453: 4449: 4433: 4432: 4426: 4424: 4417: 4413: 4366: 4362: 4353: 4351: 4335:Abell, John C. 4333: 4329: 4320: 4318: 4303: 4299: 4278:(12): 385–391. 4265: 4261: 4252: 4251: 4247: 4219: 4215: 4179: 4175: 4162: 4160: 4156: 4145: 4130: 4123: 4114: 4112: 4101: 4097: 4088: 4086: 4075: 4071: 4062: 4060: 4047: 4046: 4042: 4029: 4025: 4004: 4003: 3999: 3990: 3988: 3969: 3965: 3956: 3954: 3947:Microsoft Corp. 3941: 3940: 3936: 3929: 3908: 3904: 3892: 3890: 3886: 3880: 3879: 3875: 3866: 3864: 3860: 3849: 3840: 3836: 3827: 3825: 3810: 3806: 3797: 3795: 3791: 3780: 3776: 3775: 3771: 3762: 3760: 3745: 3741: 3732: 3730: 3726: 3718:. Vol. 2. 3715: 3709: 3708: 3697: 3680: 3678: 3671: 3661:No Starch Press 3648: 3641: 3626: 3622: 3607: 3581: 3577: 3567: 3565: 3561: 3555: 3536: 3528: 3517: 3508: 3506: 3498: 3497: 3493: 3484: 3482: 3478: 3471: 3463: 3459: 3447: 3445: 3441: 3434: 3426: 3422: 3413: 3411: 3396: 3392: 3383: 3381: 3371: 3367: 3353: 3349: 3337: 3335: 3325: 3321: 3310: 3288: 3284: 3266: 3264: 3247: 3246: 3242: 3233: 3231: 3216: 3212: 3197: 3168: 3164: 3155: 3153: 3149: 3141: 3137: 3118: 3117: 3113: 3104: 3102: 3091: 3087: 3057: 3053: 3027: 3005: 3001: 2991: 2971: 2967: 2958: 2956: 2952: 2941: 2937: 2936: 2932: 2913: 2912: 2905: 2900: 2895: 2894: 2889: 2885: 2879: 2875: 2861: 2857: 2852: 2848: 2843: 2839: 2834: 2780: 2773: 2770: 2732:inline assembly 2705:is an example.) 2682: 2438: 2426:operations and 2401: 2203: 2198: 2193: 2192: 2189: 2186: 2183: 2180: 2177: 2174: 2171: 2168: 2165: 2162: 2159: 2156: 2153: 2150: 2147: 2144: 2141: 2138: 2135: 2132: 2129: 2126: 2123: 2120: 2117: 2114: 2111: 2108: 2105: 2102: 2099: 2096: 2093: 2090: 2087: 2084: 2081: 2078: 2075: 2072: 2069: 2066: 2063: 2060: 2057: 2054: 2051: 2048: 2045: 2042: 2039: 2036: 2033: 2030: 2027: 2024: 2021: 2018: 2015: 2012: 2009: 2006: 2003: 2000: 1997: 1994: 1991: 1988: 1985: 1982: 1979: 1976: 1973: 1970: 1967: 1964: 1961: 1958: 1955: 1952: 1949: 1946: 1943: 1940: 1937: 1934: 1931: 1928: 1857: 1848: 1844: 1841: 1820:Turing-complete 1757:macro assembler 1749:virtual machine 1680: 1664:data structures 1615: 1602: 1600:Data directives 1538:instruction as 1534: 1531: 1528: 1525: 1519: 1516: 1513: 1510: 1496: 1493: 1490: 1487: 1434: 1411: 1406: 1404:Language design 1284: 1283: 1280: 1277: 1274: 1271: 1268: 1265: 1262: 1259: 1256: 1253: 1250: 1247: 1244: 1238: 1237: 1234: 1231: 1228: 1225: 1222: 1219: 1216: 1213: 1210: 1207: 1204: 1201: 1198: 1195: 1192: 1184:) does so into 1181: 1173: 1165: 1138: 1134: 1130: 1122: 1118: 1114: 1110: 1094: 1079: 1075: 1068: 1067: 1064: 1061: 1058: 1055: 1052: 1030: 1022: 1019: 1009: 947: 939:Language design 902:IBM 7000 series 877: 872: 871: 867: 863: 859: 855: 851: 845: 841: 837: 833: 829: 814:linking process 757: 728:AT&T syntax 722: 712: 686:code generators 657:to exploit the 635:instruction set 576: 571: 476:microcontroller 472:embedded system 452:cross assembler 433:macro assembler 428: 360: 238:utility program 159:(alternatively 142: 138: 134: 130: 126: 102: 100: 97: 87:object-oriented 75:metaprogramming 56: 28: 23: 22: 15: 12: 11: 5: 6062: 6052: 6051: 6046: 6041: 6036: 6031: 6026: 6011: 6010: 5987: 5986: 5984: 5983: 5978: 5973: 5967: 5964: 5963: 5961: 5960: 5955: 5950: 5945: 5940: 5935: 5930: 5925: 5919: 5917: 5911: 5910: 5908: 5907: 5906: 5905: 5895: 5890: 5885: 5880: 5874: 5872: 5866: 5865: 5863: 5862: 5857: 5852: 5847: 5842: 5837: 5832: 5827: 5825:Almquist shell 5821: 5819: 5813: 5812: 5810: 5809: 5804: 5799: 5797:Embedded GLIBC 5794: 5789: 5783: 5781: 5775: 5774: 5772: 5771: 5766: 5760: 5758: 5752: 5751: 5749: 5748: 5746:Vendor lock-in 5743: 5738: 5733: 5728: 5723: 5718: 5713: 5708: 5703: 5698: 5697: 5696: 5691: 5680: 5678: 5671: 5670: 5668: 5667: 5662: 5661: 5660: 5650: 5645: 5640: 5635: 5630: 5625: 5620: 5615: 5610: 5608:Cross compiler 5605: 5600: 5595: 5590: 5584: 5582: 5578: 5577: 5570: 5569: 5562: 5555: 5547: 5541: 5540: 5529: 5518: 5505: 5502: 5498: 5497: 5495: 5494: 5489: 5484: 5479: 5474: 5468: 5466: 5460: 5459: 5457: 5456: 5451: 5446: 5441: 5435: 5434: 5429: 5424: 5419: 5413: 5411: 5407: 5406: 5399: 5398: 5391: 5384: 5376: 5370: 5369: 5368:by Mark Larson 5363: 5358: 5353: 5347: 5342: 5340:Linux Assembly 5337: 5323: 5322:External links 5320: 5319: 5318: 5298: 5292: 5284:Addison Wesley 5275: 5269: 5252: 5239: 5223: 5210: 5190: 5178: 5173:978-1593272074 5172: 5159: 5153: 5136: 5107: 5079: 5073: 5056: 5037: 5016: 5013: 5010: 5009: 4979: 4963:NEC Pinwriters 4947: 4916: 4886: 4872:. 2023-02-13. 4861: 4830: 4805: 4780: 4755: 4729: 4700: 4671: 4642: 4613: 4589:(2005-11-28). 4575: 4545: 4529:TIOBE Software 4516: 4487: 4471: 4447: 4411: 4360: 4327: 4297: 4259: 4245: 4213: 4194:(2): 121–139. 4173: 4121: 4095: 4069: 4040: 4023: 4020:on 2023-03-07. 3997: 3963: 3934: 3927: 3902: 3873: 3834: 3804: 3769: 3739: 3695: 3669: 3659:(2 ed.). 3639: 3634:Addison Wesley 3620: 3605: 3575: 3553: 3515: 3491: 3457: 3437:. p. vi. 3420: 3390: 3365: 3347: 3319: 3308: 3282: 3253:Stack Exchange 3240: 3210: 3195: 3162: 3135: 3111: 3085: 3051: 3025: 2999: 2989: 2965: 2930: 2902: 2901: 2899: 2896: 2893: 2892: 2883: 2873: 2855: 2846: 2836: 2835: 2833: 2830: 2829: 2828: 2823: 2818: 2812: 2807: 2802: 2797: 2792: 2786: 2785: 2769: 2766: 2765: 2764: 2761: 2758: 2739: 2720: 2713: 2706: 2681: 2678: 2641: 2640: 2639: 2638: 2628: 2614: 2611:cross compiler 2607: 2597: 2594:device drivers 2583: 2576: 2573: 2558: 2555:timing attacks 2551: 2528: 2521: 2502:linear algebra 2498: 2493:components or 2487: 2480: 2473: 2466:device drivers 2462: 2400: 2397: 2274:device drivers 2229:and physicist 2211:Kathleen Booth 2202: 2199: 2197: 2194: 1927: 1877:spaghetti code 1856: 1853: 1839: 1694:of the 1950s. 1679: 1676: 1614: 1611: 1601: 1598: 1587:pseudo-opcodes 1433: 1430: 1429: 1428: 1425: 1422: 1410: 1409:Basic elements 1407: 1405: 1402: 1243: 1191: 1180:and 10110010 ( 1092: 1086:into register 1051: 1017: 1007: 946: 943: 935: 934: 909: 906:IBM System/360 898:IBM 700 series 894: 891: 888: 876: 873: 869: 865: 861: 857: 853: 849: 848: 843: 839: 835: 831: 827: 782: 781: 775: 756: 753: 751:programming). 715:, in original 612:symbolic names 600:operation code 575: 572: 570: 567: 566: 565: 553: 533:meta-assembler 529: 521:microassembler 516: 503: 456:cross compiler 448: 447: 446: 427: 424: 359: 356: 310:are generally 232:'s 1947 work, 185:architecture's 147: 146: 124: 118: 117: 114: 108: 107: 94: 90: 89: 64: 58: 57: 43: 26: 9: 6: 4: 3: 2: 6061: 6050: 6047: 6045: 6042: 6040: 6037: 6035: 6032: 6030: 6027: 6025: 6022: 6021: 6019: 6009: 6004: 5999: 5998: 5995: 5982: 5979: 5977: 5974: 5972: 5969: 5968: 5965: 5959: 5956: 5954: 5951: 5949: 5948:Embedded Java 5946: 5944: 5941: 5939: 5936: 5934: 5931: 5929: 5926: 5924: 5921: 5920: 5918: 5916: 5912: 5904: 5901: 5900: 5899: 5896: 5894: 5891: 5889: 5886: 5884: 5881: 5879: 5876: 5875: 5873: 5871: 5867: 5861: 5860:Yocto Project 5858: 5856: 5853: 5851: 5848: 5846: 5843: 5841: 5838: 5836: 5833: 5831: 5828: 5826: 5823: 5822: 5820: 5818: 5814: 5808: 5805: 5803: 5800: 5798: 5795: 5793: 5790: 5788: 5785: 5784: 5782: 5780: 5776: 5770: 5767: 5765: 5762: 5761: 5759: 5757: 5753: 5747: 5744: 5742: 5739: 5737: 5734: 5732: 5729: 5727: 5724: 5722: 5719: 5717: 5714: 5712: 5709: 5707: 5704: 5702: 5699: 5695: 5692: 5690: 5687: 5686: 5685: 5682: 5681: 5679: 5676: 5672: 5666: 5663: 5659: 5656: 5655: 5654: 5651: 5649: 5646: 5644: 5641: 5639: 5636: 5634: 5631: 5629: 5626: 5624: 5621: 5619: 5616: 5614: 5611: 5609: 5606: 5604: 5601: 5599: 5596: 5594: 5591: 5589: 5586: 5585: 5583: 5581:General terms 5579: 5575: 5568: 5563: 5561: 5556: 5554: 5549: 5548: 5545: 5536: 5530: 5525: 5519: 5514: 5508: 5507: 5493: 5490: 5488: 5485: 5483: 5480: 5478: 5475: 5473: 5470: 5469: 5467: 5465: 5461: 5455: 5452: 5450: 5447: 5445: 5442: 5440: 5437: 5436: 5433: 5430: 5428: 5425: 5423: 5420: 5418: 5415: 5414: 5412: 5408: 5404: 5397: 5392: 5390: 5385: 5383: 5378: 5377: 5374: 5367: 5364: 5362: 5359: 5357: 5354: 5351: 5348: 5346: 5343: 5341: 5338: 5336: 5332: 5329: 5326: 5325: 5308:on 2013-05-30 5307: 5303: 5299: 5295: 5293:0-201-39828-1 5289: 5285: 5281: 5276: 5272: 5270:1-55860-410-3 5266: 5262: 5258: 5253: 5249: 5245: 5240: 5236: 5232: 5228: 5227:Norton, Peter 5224: 5220: 5216: 5211: 5200: 5196: 5191: 5184: 5179: 5175: 5169: 5165: 5160: 5156: 5154:0-471-37523-3 5150: 5146: 5142: 5137: 5126: 5122: 5118: 5114: 5110: 5108:0-914894-23-4 5104: 5101: 5096: 5095: 5089: 5085: 5080: 5076: 5074:0-13-142044-5 5070: 5066: 5065:Prentice Hall 5062: 5057: 5055: 5044: 5040: 5038:0-9752838-4-7 5034: 5030: 5026: 5025: 5019: 5018: 4998: 4994: 4990: 4983: 4969: 4965: 4964: 4958: 4951: 4933: 4926: 4920: 4905: 4901: 4897: 4890: 4875: 4871: 4865: 4850: 4846: 4845: 4840: 4834: 4820:on 2012-03-04 4819: 4815: 4809: 4794: 4790: 4784: 4769: 4765: 4759: 4744: 4740: 4733: 4719:on 2010-04-02 4718: 4714: 4710: 4704: 4690:on 2008-06-16 4689: 4685: 4681: 4680:Hyde, Randall 4675: 4661:on 2010-03-16 4660: 4656: 4652: 4646: 4632:on 2010-02-05 4631: 4627: 4623: 4617: 4602: 4598: 4597: 4592: 4588: 4582: 4580: 4564: 4560: 4556: 4549: 4534: 4530: 4526: 4525:"TIOBE Index" 4520: 4513: 4502: 4498: 4491: 4484: 4474: 4468: 4464: 4460: 4459: 4451: 4443: 4437: 4422: 4415: 4407: 4403: 4398: 4393: 4389: 4385: 4381: 4377: 4376: 4371: 4364: 4350: 4346: 4342: 4338: 4331: 4316: 4312: 4308: 4301: 4293: 4289: 4285: 4281: 4277: 4273: 4269: 4263: 4256:. 2018-03-27. 4255: 4249: 4241: 4237: 4233: 4229: 4228: 4223: 4217: 4209: 4205: 4201: 4197: 4193: 4189: 4188: 4183: 4177: 4170: 4155: 4151: 4144: 4143: 4138: 4134: 4128: 4126: 4110: 4106: 4099: 4084: 4080: 4073: 4059:on 2009-06-08 4058: 4054: 4050: 4044: 4036: 4035: 4027: 4019: 4015: 4011: 4007: 4001: 3986: 3982: 3978: 3974: 3967: 3952: 3948: 3944: 3938: 3930: 3928:0-7167-0447-1 3924: 3920: 3916: 3912: 3906: 3899: 3885: 3884: 3877: 3859: 3855: 3848: 3844: 3843:Hyde, Randall 3838: 3823: 3819: 3815: 3808: 3794:on 2011-12-10 3790: 3786: 3779: 3773: 3758: 3754: 3750: 3743: 3729:on 2009-06-11 3725: 3721: 3714: 3713: 3706: 3704: 3702: 3700: 3693: 3691: 3688: 3677:on 2010-05-06 3676: 3672: 3670:1-886411-97-2 3666: 3662: 3658: 3657: 3652: 3651:Hyde, Randall 3646: 3644: 3635: 3631: 3624: 3616: 3612: 3608: 3606:9781450320856 3602: 3598: 3594: 3590: 3586: 3579: 3560: 3556: 3554:0-13-052564-2 3550: 3546: 3542: 3535: 3534: 3526: 3524: 3522: 3520: 3505: 3501: 3495: 3477: 3470: 3469: 3461: 3454: 3440: 3433: 3432: 3424: 3409: 3405: 3401: 3394: 3380: 3376: 3369: 3361: 3357: 3351: 3344: 3334: 3330: 3323: 3316: 3311: 3309:9780120683772 3305: 3301: 3297: 3293: 3286: 3279: 3275: 3262: 3258: 3254: 3250: 3244: 3230:on 2020-01-02 3229: 3225: 3221: 3214: 3206: 3202: 3198: 3192: 3188: 3184: 3180: 3176: 3172: 3166: 3148: 3147: 3139: 3131: 3127: 3126: 3121: 3115: 3100: 3096: 3089: 3082: 3076: 3072: 3068: 3067:Prentice-Hall 3064: 3063: 3055: 3048: 3044: 3040: 3036: 3032: 3028: 3022: 3018: 3014: 3010: 3003: 2996: 2992: 2986: 2982: 2978: 2977: 2969: 2951: 2947: 2940: 2934: 2926: 2922: 2921: 2916: 2910: 2908: 2903: 2887: 2877: 2870: 2866: 2859: 2850: 2841: 2837: 2827: 2824: 2822: 2819: 2816: 2813: 2811: 2808: 2806: 2803: 2801: 2798: 2796: 2793: 2791: 2788: 2787: 2783: 2777: 2772: 2762: 2759: 2756: 2752: 2748: 2744: 2740: 2737: 2736:portable code 2733: 2729: 2725: 2721: 2718: 2714: 2711: 2707: 2704: 2700: 2696: 2692: 2688: 2684: 2683: 2677: 2674: 2670: 2666: 2665:character set 2662: 2658: 2654: 2650: 2646: 2636: 2633:(also termed 2632: 2629: 2625: 2621: 2620: 2618: 2615: 2613:is available. 2612: 2608: 2605: 2601: 2598: 2595: 2591: 2587: 2584: 2581: 2577: 2574: 2571: 2567: 2563: 2559: 2556: 2552: 2549: 2545: 2541: 2536: 2532: 2529: 2526: 2522: 2519: 2515: 2511: 2507: 2503: 2499: 2496: 2492: 2488: 2485: 2481: 2478: 2474: 2471: 2467: 2463: 2460: 2456: 2452: 2448: 2444: 2436: 2435: 2434: 2431: 2429: 2425: 2420: 2416: 2412: 2407: 2404: 2399:Current usage 2396: 2394: 2393: 2388: 2387: 2386:Mortal Kombat 2382: 2378: 2374: 2373: 2368: 2364: 2360: 2356: 2351: 2349: 2345: 2340: 2337: 2333: 2329: 2325: 2321: 2317: 2312: 2310: 2306: 2302: 2301:IBM mainframe 2298: 2294: 2293:Burroughs MCP 2289: 2287: 2284:systems (see 2283: 2279: 2275: 2271: 2266: 2261: 2259: 2255: 2251: 2250:David Wheeler 2247: 2243: 2238: 2236: 2232: 2228: 2224: 2220: 2216: 2212: 2208: 2139:"*" 1925: 1922: 1918: 1916: 1912: 1908: 1905: 1901: 1897: 1893: 1889: 1885: 1880: 1878: 1874: 1870: 1866: 1862: 1852: 1838: 1834: 1832: 1828: 1823: 1821: 1815: 1813: 1809: 1805: 1801: 1797: 1793: 1788: 1786: 1782: 1778: 1774: 1770: 1766: 1760: 1758: 1754: 1750: 1746: 1742: 1737: 1733: 1731: 1727: 1723: 1722:pre-processor 1718: 1716: 1712: 1708: 1704: 1699: 1695: 1693: 1689: 1685: 1675: 1672: 1667: 1665: 1661: 1657: 1652: 1650: 1649:local symbols 1646: 1642: 1638: 1634: 1633: 1627: 1623: 1621: 1620:pseudo-opcode 1610: 1607: 1597: 1595: 1590: 1588: 1571: 1569: 1549: 1545: 1483: 1479: 1461: 1457: 1456: 1451: 1447: 1443: 1439: 1426: 1423: 1420: 1417: 1416: 1415: 1401: 1399: 1394: 1390: 1385: 1381: 1377: 1373: 1369: 1365: 1361: 1357: 1353: 1349: 1345: 1341: 1337: 1333: 1327: 1324: 1319: 1316: 1311: 1308: 1304: 1300: 1297:, there is a 1296: 1292: 1287: 1241: 1189: 1187: 1179: 1171: 1162: 1160: 1156: 1152: 1148: 1144: 1126: 1106: 1104: 1100: 1091: 1089: 1085: 1072: 1049: 1047: 1043: 1040: 1036: 1028: 1016: 1014: 1006: 1004: 1000: 996: 992: 988: 984: 980: 976: 971: 969: 965: 961: 957: 952: 942: 940: 933: 929: 925: 921: 917: 913: 910: 907: 903: 899: 895: 892: 889: 886: 885: 884: 882: 847: 825: 821: 819: 815: 811: 807: 803: 799: 794: 792: 788: 779: 776: 773: 769: 765: 762: 761: 760: 752: 750: 746: 742: 738: 734: 733:GNU Assembler 730: 729: 720: 719: 710: 706: 702: 698: 693: 691: 687: 683: 679: 675: 671: 667: 662: 660: 656: 652: 648: 644: 640: 639:optimizations 636: 631: 629: 626: 623:, instead of 622: 618: 613: 609: 605: 601: 597: 593: 589: 585: 581: 563: 559: 558: 554: 551: 547: 546:Sperry Univac 543: 539: 534: 530: 527: 523: 522: 517: 514: 510: 509: 504: 501: 497: 493: 489: 485: 481: 477: 473: 469: 468:target system 465: 461: 457: 453: 449: 444: 441: 440: 438: 434: 430: 429: 423: 421: 417: 416:punched cards 412: 410: 406: 402: 397: 393: 389: 385: 381: 377: 373: 369: 365: 355: 353: 349: 343: 340: 336: 332: 328: 323: 321: 317: 313: 309: 305: 301: 297: 293: 288: 286: 281: 279: 278:assembly time 275: 271: 267: 263: 262: 257: 253: 249: 245: 244: 239: 235: 231: 227: 222: 220: 216: 212: 208: 204: 200: 196: 192: 189: 186: 182: 178: 174: 170: 166: 162: 158: 154: 125: 123: 119: 115: 113: 109: 95: 91: 88: 84: 80: 76: 72: 68: 65: 63: 59: 54: 51: 47: 41: 36: 30: 19: 5943:Embedded C++ 5927: 5845:OpenEmbedded 5756:Boot loaders 5677:and controls 5658:Raspberry Pi 5538:}} 5532:{{ 5527:}} 5521:{{ 5516:}} 5510:{{ 5421: 5310:. Retrieved 5306:the original 5279: 5257:See MIPS Run 5256: 5243: 5234: 5218: 5203:. Retrieved 5163: 5140: 5128:. Retrieved 5093: 5060: 5047:. Retrieved 5023: 5001:. Retrieved 4992: 4982: 4972:, retrieved 4960: 4950: 4939:. Retrieved 4919: 4908:. Retrieved 4899: 4889: 4878:. Retrieved 4864: 4853:. Retrieved 4842: 4833: 4822:. Retrieved 4818:the original 4808: 4797:. Retrieved 4783: 4772:. Retrieved 4758: 4747:. Retrieved 4732: 4721:. Retrieved 4717:the original 4712: 4703: 4692:. Retrieved 4688:the original 4674: 4663:. Retrieved 4659:the original 4654: 4645: 4634:. Retrieved 4630:the original 4625: 4616: 4605:. Retrieved 4594: 4567:. Retrieved 4558: 4548: 4537:. Retrieved 4519: 4511: 4505:. Retrieved 4490: 4482: 4476:. Retrieved 4457: 4450: 4425:. Retrieved 4414: 4382:(2): 96–97. 4379: 4373: 4363: 4352:. Retrieved 4340: 4330: 4319:. Retrieved 4300: 4275: 4271: 4262: 4248: 4231: 4225: 4216: 4191: 4185: 4176: 4167: 4161:. Retrieved 4141: 4113:. Retrieved 4098: 4087:. Retrieved 4072: 4061:. Retrieved 4057:the original 4052: 4043: 4033: 4026: 4018:the original 4009: 4000: 3989:. Retrieved 3976: 3966: 3955:. Retrieved 3949:2012-11-16. 3937: 3914: 3905: 3897: 3891:. Retrieved 3889:. 1965-12-07 3882: 3876: 3865:. Retrieved 3853: 3837: 3826:. Retrieved 3817: 3807: 3796:. Retrieved 3789:the original 3772: 3761:. Retrieved 3742: 3731:. Retrieved 3724:the original 3711: 3689:(928 pages) 3679:. Retrieved 3675:the original 3655: 3629: 3623: 3588: 3578: 3566:. Retrieved 3532: 3507:. Retrieved 3503: 3494: 3483:. Retrieved 3467: 3460: 3452: 3446:. Retrieved 3430: 3423: 3412:. Retrieved 3403: 3393: 3382:. Retrieved 3378: 3368: 3359: 3350: 3342: 3336:. Retrieved 3332: 3322: 3313: 3291: 3285: 3265:. Retrieved 3259:2011-07-28. 3252: 3243: 3232:. Retrieved 3228:the original 3224:I Programmer 3223: 3213: 3182: 3165: 3154:. Retrieved 3145: 3138: 3124: 3114: 3103:. Retrieved 3088: 3080: 3061: 3054: 3046: 3008: 3002: 2994: 2975: 2968: 2957:. Retrieved 2933: 2919: 2886: 2876: 2869:disassembler 2868: 2858: 2849: 2840: 2800:Disassembler 2747:disassembler 2701:systems and 2642: 2461:subcultures. 2447:Commodore 64 2432: 2415:Visual Basic 2408: 2405: 2402: 2390: 2384: 2370: 2363:Turbo Pascal 2352: 2332:Commodore 64 2313: 2290: 2276:, low-level 2262: 2239: 2223:Andrew Booth 2204: 1947:masm32rt.inc 1923: 1919: 1881: 1869:Harlan Mills 1858: 1842: 1835: 1824: 1816: 1789: 1761: 1738: 1734: 1719: 1714: 1710: 1702: 1697: 1696: 1687: 1683: 1681: 1668: 1653: 1648: 1636: 1630: 1628: 1624: 1619: 1616: 1603: 1591: 1586: 1581:followed by 1572: 1567: 1500:is used for 1481: 1480: 1459: 1453: 1449: 1445: 1435: 1412: 1375: 1371: 1367: 1363: 1359: 1355: 1351: 1347: 1343: 1339: 1328: 1320: 1312: 1302: 1291:disassembler 1288: 1285: 1239: 1185: 1177: 1169: 1163: 1158: 1154: 1150: 1146: 1142: 1127: 1107: 1102: 1098: 1095: 1087: 1083: 1073: 1069: 1045: 1026: 1020: 1015:as follows. 1010: 1002: 999:machine code 994: 972: 948: 936: 928:polymorphism 878: 864:EQU * ... 860:EQU * ... 823: 822: 818:program load 795: 787:no-operation 783: 777: 763: 758: 749:x86 assembly 737:machine code 731:used by the 726: 718:Intel syntax 716: 694: 663: 659:CPU pipeline 632: 624: 599: 579: 577: 569:Key concepts 561: 555: 538:SDS 9 Series 532: 526:microprogram 519: 513:IF/THEN/ELSE 506: 467: 463: 451: 442: 432: 413: 361: 348:Linux kernel 344: 324: 316:interpreting 289: 282: 277: 269: 265: 259: 241: 233: 223: 201:, assembler 191:instructions 188:machine code 176: 172: 168: 164: 160: 156: 150: 71:unstructured 45: 29: 5958:MicroPython 5898:Windows IoT 5706:Crippleware 5623:Embedded OS 5432:Interpreted 5231:Socha, John 4993:freedos-dev 4234:(1): 7–36. 4053:answers.com 2805:Hexadecimal 2635:ROM hacking 2631:Video games 2590:bootloaders 2535:fly-by-wire 2459:retrogaming 2411:TIOBE index 2377:Sega Saturn 2367:Lotus 1-2-3 2336:Interpreted 2328:ZX Spectrum 1837:the macro: 1671:source code 1336:Intel 8080A 1013:hexadecimal 991:binary code 932:inheritance 924:abstraction 647:jump-sizing 628:subroutines 588:translating 584:object code 490:, etc.), a 480:object code 426:Terminology 420:white space 396:expressions 339:Fred Brooks 304:system call 274:source code 205:, symbolic 6018:Categories 5938:Embedded C 5598:Bootloader 5464:Generation 5444:High-level 5312:2013-05-30 5205:2020-03-24 5130:2020-03-20 5049:2020-03-24 5003:2018-09-10 4974:2013-04-22 4941:2021-09-14 4910:2016-06-01 4880:2023-02-21 4855:2023-02-21 4824:2010-09-29 4799:2010-03-04 4774:2008-07-03 4749:2014-05-01 4723:2010-03-04 4694:2008-07-03 4665:2010-03-04 4636:2010-03-04 4607:2010-03-04 4569:2012-03-11 4539:2020-03-24 4507:2020-03-24 4478:2020-03-24 4427:2008-07-25 4354:2024-03-02 4321:2012-01-17 4163:2019-02-10 4115:2019-02-10 4089:2020-03-24 4063:2008-06-19 3991:2009-05-25 3957:2010-06-22 3893:2024-01-21 3867:2011-03-19 3828:2013-07-21 3798:2011-12-10 3763:2010-11-18 3733:2010-11-18 3681:2020-06-22 3568:2008-10-01 3509:2020-11-05 3485:2020-06-07 3448:2020-06-07 3414:2020-03-24 3384:2022-05-04 3338:2022-06-21 3315:processor. 3267:2020-03-24 3234:2020-03-06 3156:2022-11-04 3105:2020-03-24 2959:2020-03-24 2898:References 2751:decompiler 2667:encoding, 2592:, certain 2443:Atari 2600 2365:, and the 2344:Atari 2600 1849:load a-c*b 1804:job stream 1741:parameters 1717:in HLASM. 1692:autocoders 1660:namespaces 1548:System/370 1544:System/360 1080:MOV AL, AH 1001:loads the 842:; indeed, 637:-specific 492:programmer 454:(see also 270:assembling 209:of, e.g., 203:directives 83:structured 67:Imperative 5835:Buildroot 5439:Low-level 5117:0888-2088 4463:CRC Press 4349:1059-1028 3205:313593586 3043:195930813 3035:1863-7310 2717:debugging 2669:interrupt 2627:software. 2622:existing 2604:debugging 2531:Real-time 2495:libraries 2455:demoscene 2282:real-time 2246:bootstrap 1956:demomain: 1915:registers 1884:A-Natural 1606:alignment 1446:operation 1421:mnemonics 1398:Pig Latin 1332:Zilog Z80 1323:mnemonics 1293:. Unlike 964:assembler 743:-syntax, 690:Speedcode 592:mnemonics 580:assembler 574:Assembler 496:Intel hex 443:Open code 409:debugging 376:directive 320:compiling 300:processor 243:assembler 215:registers 195:statement 179:, is any 77:(through 5792:dietlibc 5684:Firmware 5675:Firmware 5504:See also 5454:Esoteric 5427:Compiled 5422:Assembly 5331:Archived 5233:(1986). 5199:Archived 5125:78-21905 5043:Archived 4997:Archived 4968:archived 4932:Archived 4904:Archived 4874:Archived 4849:Archived 4793:Archived 4768:Archived 4743:Archived 4601:Archived 4563:Archived 4533:Archived 4501:Archived 4436:cite web 4315:Archived 4208:14861159 4154:Archived 4109:Archived 4083:Archived 3985:Archived 3951:Archived 3858:Archived 3822:Archived 3757:Archived 3686:Errata: 3559:Archived 3476:Archived 3439:Archived 3408:Archived 3261:Archived 3181:(1951). 3099:Archived 3075:62-20615 2950:Archived 2948:. 2016. 2790:Compiler 2768:See also 2673:compiler 2624:binaries 2570:ARM Neon 2491:run-time 2381:TMS34010 2316:Apple II 2190:demomain 1907:compiler 1745:unrolled 1575:ld hl,bc 1455:operands 1387:such as 1039:mnemonic 987:register 951:mnemonic 824:Example: 816:(or the 768:"errata" 713:add eax, 668:such as 536:for the 388:operands 364:mnemonic 312:portable 268:, as in 266:assembly 226:Kathleen 199:comments 169:assembly 73:, often 62:Paradigm 50:Motorola 44:Typical 5953:MISRA C 5840:BusyBox 5830:BitBake 5769:Barebox 5417:Machine 5090:(ed.). 4406:7719803 4280:Bibcode 3615:8015812 3504:gnu.org 2392:NBA Jam 2309:FORTRAN 2258:IBM 650 2233:at the 2133:.Repeat 2115:default 2061:.elseif 1974:nrandom 1941:include 1929:include 1911:opcodes 1812:utility 1753:SNOBOL4 1724:in the 1637:symbols 1504:, with 1380:NEC V20 1035:decimal 1029:", and 985:into a 960:operand 920:objects 916:classes 725:in the 670:Fortran 405:offsets 374:, each 252:Wheeler 101: ( 5994:Portal 5903:Win CE 5855:Toybox 5787:uClibc 5764:U-Boot 5487:Fourth 5477:Second 5290: 5267: 5170: 5151: 5123: 5115: 5105: 5071: 5035: 4844:GitHub 4469: 4404: 4397:116189 4394: 4347: 4206: 3925: 3667: 3613: 3603: 3551: 3306: 3203: 3193: 3073: 3041: 3033: 3023: 2987: 2821:Nibble 2724:Pascal 2512:(e.g. 2449:, and 2428:paging 2359:MS-DOS 2330:, and 2280:, and 2148:.Until 2088:.endif 1965:switch 1959:REPEAT 1935:masm32 1898:-like 1796:OS/360 1775:, and 1769:VM/CMS 1678:Macros 1632:labels 1583:ld h,b 1579:ld l,c 1450:opcode 1442:opcode 1419:Opcode 1370:, and 1153:, and 1137:, not 1093:88 E0 1021:Here, 1018:B0 61 989:. The 956:opcode 930:, and 772:linker 697:syntax 625:called 621:inline 604:opcode 596:syntax 486:(ROM, 403:using 392:labels 372:opcode 296:syntax 248:Wilkes 219:macros 217:, and 207:labels 79:macros 53:MC6800 5492:Fifth 5482:Third 5472:First 5410:Level 5186:(PDF) 5145:Wiley 4935:(PDF) 4928:(PDF) 4341:Wired 4204:S2CID 4157:(PDF) 4146:(PDF) 3887:(PDF) 3861:(PDF) 3850:(PDF) 3792:(PDF) 3781:(PDF) 3727:(PDF) 3716:(PDF) 3611:S2CID 3562:(PDF) 3537:(PDF) 3479:(PDF) 3472:(PDF) 3442:(PDF) 3435:(PDF) 3150:(PDF) 3039:S2CID 2953:(PDF) 2942:(PDF) 2832:Notes 2504:with 2339:BASIC 2305:COBOL 2163:chr$ 2160:print 2157:endsw 2151:Sign? 2136:print 2109:print 2082:print 2079:.else 2073:print 2055:print 2022:print 2007:print 1953:.code 1900:Idris 1792:COBOL 1763:with 1707:HLASM 1703:MEXIT 1393:Cyrix 1313:Each 1307:macro 979:IA-32 966:into 852:B 806:cards 678:COBOL 674:Algol 617:macro 488:EPROM 474:or a 462:(the 5933:CAPL 5807:musl 5802:lwIP 5741:UEFI 5633:FPGA 5588:ASIC 5288:ISBN 5265:ISBN 5168:ISBN 5149:ISBN 5121:LCCN 5113:ISSN 5103:ISBN 5069:ISBN 5033:ISBN 4467:ISBN 4442:link 4402:PMID 4345:ISSN 3923:ISBN 3665:ISBN 3601:ISBN 3549:ISBN 3379:Gist 3304:ISBN 3276:vs. 3201:OCLC 3191:ISBN 3071:LCCN 3031:ISSN 3021:ISBN 2985:ISBN 2703:CP/M 2695:BIOS 2687:boot 2647:and 2568:and 2566:AVX2 2518:x264 2514:SIMD 2506:BLAS 2468:and 2389:and 2372:Doom 2346:and 2215:ARC2 2184:exit 2181:ENDM 2091:case 2031:case 2013:case 2001:case 1896:Unix 1873:GOTO 1810:and 1773:CICS 1730:PL/I 1715:COPY 1713:and 1656:NASM 1645:GOTO 1594:IEEE 1562:and 1558:for 1556:NOPR 1554:and 1546:and 1526:xchg 1511:xchg 1488:xchg 1391:and 1382:and 1372:SHLD 1368:LHLD 1364:STAX 1360:LDAX 1046:move 937:See 900:and 870:BKWD 868:B 862:BKWD 856:... 828:BKWD 802:tape 745:TASM 741:FASM 682:Lisp 680:and 608:bits 594:and 560:(or 540:and 464:host 384:flag 329:and 272:the 256:Gill 254:and 228:and 143:.SRC 139:.wla 135:.inc 127:.asm 116:None 103:1947 96:1947 5923:Ada 5665:SoC 5638:IoT 4392:PMC 4384:doi 4288:doi 4236:doi 4196:doi 4169:... 4014:IBM 3593:doi 3296:doi 3278:VSE 3274:MVS 3130:IBM 3013:doi 2925:IBM 2726:or 2697:on 2693:. ( 2691:ROM 2562:AV1 2508:or 2477:DSP 2457:or 2424:I/O 2324:MSX 2288:). 2217:at 2187:end 2145:ebx 2142:dec 2121:ebx 2118:mov 2064:eax 2046:eax 2043:.if 2016:ecx 1992:ecx 1989:mov 1888:Z80 1845:a-c 1831:C++ 1781:TPF 1777:ACP 1765:IBM 1751:in 1711:AIF 1705:in 1635:or 1564:BCR 1552:NOP 1540:nop 1506:nop 1502:nop 1472:NOP 1448:or 1389:AMD 1384:V30 1356:LXI 1352:STA 1348:LDA 1344:MVI 1340:MOV 1269:MOV 1257:MOV 1248:EAX 1245:MOV 1223:MOV 1208:MOV 1193:MOV 1135:0AH 1133:or 1131:0Ah 1129:as 1111:61h 1076:61h 1062:61h 1053:MOV 1042:MOV 975:x86 858:FWD 854:FWD 844:FWD 836:FWD 808:or 709:x86 703:or 701:CPU 643:x86 586:by 578:An 498:or 370:or 337:", 318:or 177:asm 175:or 173:ASM 163:or 155:, 151:In 85:or 6020:: 5286:. 5282:. 5263:. 5259:. 5229:; 5217:. 5197:. 5147:. 5143:. 5119:. 5111:. 5086:. 5067:. 5063:. 5041:. 5031:. 5027:. 4995:. 4991:. 4959:, 4902:. 4898:. 4847:. 4841:. 4766:. 4741:. 4711:. 4682:. 4653:. 4624:. 4593:. 4578:^ 4561:. 4557:. 4531:. 4527:. 4510:. 4499:. 4481:. 4465:. 4461:. 4438:}} 4434:{{ 4400:. 4390:. 4378:. 4372:. 4343:. 4339:. 4313:. 4286:. 4276:26 4274:. 4230:. 4202:. 4190:. 4166:. 4152:. 4135:; 4124:^ 4107:. 4081:. 4051:. 4012:. 4008:. 3983:. 3975:. 3945:. 3921:. 3896:. 3856:. 3852:. 3845:. 3820:. 3816:. 3783:. 3755:. 3698:^ 3663:. 3642:^ 3632:. 3609:. 3599:. 3587:. 3557:. 3543:/ 3518:^ 3502:. 3474:. 3451:. 3406:. 3402:. 3377:. 3341:. 3331:. 3312:. 3302:. 3255:. 3251:. 3222:. 3199:. 3189:. 3177:; 3173:; 3128:. 3122:. 3097:. 3083:.) 3069:. 3045:. 3037:. 3029:. 3019:. 2993:. 2983:. 2923:. 2917:. 2906:^ 2663:, 2659:, 2655:, 2588:, 2520:). 2445:, 2395:. 2361:, 2350:. 2334:. 2326:, 2322:, 2318:, 2307:, 2237:. 2175:10 2169:13 2127:19 2067:== 2049:== 2037:.. 1968:rv 1962:20 1913:, 1829:, 1589:. 1570:. 1560:BC 1535:ax 1529:ax 1520:ax 1514:ax 1497:ax 1491:ax 1476:BC 1468:BC 1376:LD 1366:, 1362:, 1358:, 1354:, 1350:, 1346:, 1342:, 1278:DX 1272:DS 1263:CL 1232:3h 1226:DL 1217:2h 1211:CL 1202:1h 1196:AL 1186:DL 1182:B2 1178:CL 1174:B1 1170:AL 1166:B0 1155:DH 1151:CH 1149:, 1147:BH 1143:AH 1139:AH 1123:88 1119:AH 1115:B0 1105:. 1103:AL 1099:AH 1088:AL 1084:AH 1056:AL 1031:61 1027:AL 1023:B0 1003:AL 995:AL 926:, 922:, 918:, 866:S2 850:S1 840:S1 832:S2 676:, 672:, 630:. 602:(" 531:A 518:A 505:A 502:). 450:A 431:A 411:. 382:, 354:. 287:. 280:. 250:, 213:, 141:, 137:, 133:, 131:.s 129:, 69:, 5996:: 5566:e 5559:t 5552:v 5395:e 5388:t 5381:v 5315:. 5296:. 5273:. 5250:. 5221:. 5208:. 5188:. 5176:. 5157:. 5133:. 5077:. 5052:. 5006:. 4944:. 4913:. 4883:. 4858:. 4827:. 4802:. 4777:. 4752:. 4726:. 4697:. 4668:. 4639:. 4610:. 4572:. 4542:. 4444:) 4430:. 4408:. 4386:: 4380:1 4357:. 4324:. 4294:. 4290:: 4282:: 4242:. 4238:: 4232:2 4210:. 4198:: 4192:4 4118:. 4092:. 4066:. 4037:. 3994:. 3960:. 3931:. 3870:. 3831:. 3801:. 3766:. 3736:. 3684:. 3636:. 3617:. 3595:: 3571:. 3512:. 3488:. 3417:. 3387:. 3298:: 3270:. 3237:. 3207:. 3159:. 3108:. 3077:. 3015:: 2962:. 2728:C 2582:. 2557:. 2472:. 2178:) 2172:, 2166:( 2124:, 2106:8 2103:, 2100:6 2097:, 2094:4 2070:2 2052:1 2040:3 2034:1 2004:0 1998:7 1995:, 1983:) 1980:9 1977:, 1971:( 1944:\ 1938:\ 1932:\ 1904:C 1827:C 1779:/ 1532:, 1517:, 1494:, 1464:B 1275:, 1260:, 1251:, 1229:, 1214:, 1199:, 1159:H 1059:, 977:/ 552:. 352:C 105:) 20:)

Text is available under the Creative Commons Attribution-ShareAlike License. Additional terms may apply.