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,
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
17:
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
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
18: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.