A86 (software)

Last updated
A86
Developer(s) Eric Isaacson
Stable release
4.05 / 14 January 2000
Operating system MS-DOS
Platform x86
Type Assembler
License Proprietary
Website eji.com/a86

A86 is an assembler for MS-DOS which generates code for the Intel x86 family of microprocessors. Written by Eric Isaacson, it was first made available as shareware in June 1986. The assembler is contained in one 32K executable and can directly produce a COM file or an object file for use with a standard linker. It comes with a debugger, D86. [1] [2]

Contents

While supporting expected x86 syntax, A86 allows simpler shorthand in some cases and does not require directives, such as ASSUME, SEGMENT, and PROC, which Microsoft Macro Assembler and other contemporaries rely on. Speed of assembly is a primary selling point. Isaacson claimed that A86 could assemble 100,000 lines of source per second on a Pentium II or better. [3]

A86 and D86 target 16-bit x86 platforms. Isaacson added 32-bit support in the mid 1990s in the form of A386 and D386. [1] [2] These were not distributed as shareware, but were provided to users who registered A86. The A86 family of products was never ported to Microsoft Windows, but it is possible to use the object files created by A386 with a Windows linker. [4] The assembler does not support 64-bit code.

A86-specific features

Any label consisting of one letter followed by one or more digits is local and can be redefined as needed, with each definition replacing the prior. The manual recommends using L1 through L9 for normal code and M1 through M9 in macros. Branches to local labels are assumed to be backward, but a forward branch can be specified by prefixing the label reference with the greater than symbol (e.g.,>L2).

Numbers starting with a zero are hexadecimal, such as 00FF, instead of using a prefix such as "0x" or "$". A trailing "K" indicates kibibytes. [5] 16K is the same as 16*1024 or 16384.

Multiple registers can be pushed or popped on the same source line. push eax, edx, ebp generates one instruction for each of the three operands.

There's shorthand for conditionally executing a single instruction. if z mov ax,bx outputs two instructions: a conditional branch followed by the move.

If ret is specified as the label for a conditional branch, it automatically targets a return instruction within the 8-bit branch range (e.g., jz ret).

Macros use a different syntax than contemporaneous assemblers.

Code fingerprint

The assembler was designed to use particular instruction encodings which are functionally equivalent, but together create a fingerprint that's embedded in the executable file. This is mentioned in the legal terms section of the manual. The fingerprint makes it possible to tell if code was assembled with A86 and also to distinguish between registered and unregistered versions of the assembler. This analysis requires access to the source code. [6]

Related Research Articles

<span class="mw-page-title-main">Assembly language</span> Low-level programming language

In computer programming, assembly language, often referred to simply as assembly and commonly abbreviated as ASM or asm, is any low-level programming language with a very strong correspondence between the instructions in the language and the architecture's machine code instructions. Assembly language usually has one statement per machine instruction (1:1), but constants, comments, assembler directives, symbolic labels of, e.g., memory locations, registers, and macros are generally also supported.

<span class="mw-page-title-main">Macro (computer science)</span> Rule for substituting a set input with a set output

In computer programming, a macro is a rule or pattern that specifies how a certain input should be mapped to a replacement output. Applying a macro to an input is known as macro expansion. The input and output may be a sequence of lexical tokens or characters, or a syntax tree. Character macros are supported in software applications to make it easy to invoke common command sequences. Token and tree macros are supported in some programming languages to enable code reuse or to extend the language, sometimes for domain-specific languages.

A disassembler is a computer program that translates machine language into assembly language—the inverse operation to that of an assembler. Disassembly, the output of a disassembler, is often formatted for human-readability rather than suitability for input to an assembler, making it principally a reverse-engineering tool. Common uses of disassemblers include analyzing high-level programing language compilers output and their optimizations, recovering source code of a program whose original source was lost, malware analysis, modifying software, and software cracking.

<span class="mw-page-title-main">FASM</span> Open source assembler for x86 processors

FASM is an assembler for x86 processors. It supports Intel-style assembly language on the IA-32 and x86-64 computer architectures. It claims high speed, size optimizations, operating system (OS) portability, and macro abilities. It is a low-level assembler and intentionally uses very few command-line options. It is free and open-source software.

In software development, Make is a build automation tool that builds executable programs and libraries from source code by reading files called makefiles which specify how to derive the target program. Though integrated development environments and language-specific compiler features can also be used to manage a build process, Make remains widely used, especially in Unix and Unix-like operating systems.

A low-level programming language is a programming language that provides little or no abstraction from a computer's instruction set architecture—commands or functions in the language map that are structurally similar to processor's instructions. Generally, this refers to either machine code or assembly language. Because of the low abstraction between the language and machine language, low-level languages are sometimes described as being "close to the hardware". Programs written in low-level languages tend to be relatively non-portable, due to being optimized for a certain type of system architecture.

x86 assembly language is the name for the family of assembly languages which provide some level of backward compatibility with CPUs back to the Intel 8008 microprocessor, which was launched in April 1972. It is used to produce object code for the x86 class of processors.

INT is an assembly language instruction for x86 processors that generates a software interrupt. It takes the interrupt number formatted as a byte value.

The C preprocessor is the macro preprocessor for several computer programming languages, such as C, Objective-C, C++, and a variety of Fortran languages. The preprocessor provides inclusion of header files, macro expansions, conditional compilation, and line control.

CodeView is a standalone debugger created by David Norris at Microsoft in 1985 as part of its development toolset. It originally shipped with Microsoft C 4.0 and later. It also shipped with Visual Basic for MS-DOS, Microsoft BASIC PDS, and a number of other Microsoft language products. It was one of the first debuggers for MS-DOS to be full-screen oriented, rather than line-oriented.

High Level Assembly (HLA) is a language developed by Randall Hyde that allows the use of higher-level language constructs to aid both beginners and advanced assembly developers. It fully supports advanced data types and object-oriented programming. It uses a syntax loosely based on several high-level programming languages (HLLs), such as Pascal, Ada, Modula-2, and C++, to allow the creation of readable assembly language programs, and to allow HLL programmers to learn HLA as fast as possible.

Turbo Assembler is an assembler for software development published by Borland in 1989. It runs on and produces code for 16- or 32-bit x86 MS-DOS and compatible on Microsoft Windows. It can be used with Borland's other language products: Turbo Pascal, Turbo Basic, Turbo C, and Turbo C++. The Turbo Assembler package is bundled with Turbo Linker and is interoperable with Turbo Debugger.

In computer programming, an inline assembler is a feature of some compilers that allows low-level code written in assembly language to be embedded within a program, among code that otherwise has been compiled from a higher-level language such as C or Ada.

The Microsoft Macro Assembler (MASM) is an x86 assembler that uses the Intel syntax for MS-DOS and Microsoft Windows. Beginning with MASM 8.0, there are two versions of the assembler: One for 16-bit & 32-bit assembly sources, and another (ML64) for 64-bit sources only.

The IBM Basic assembly language and successors is a series of assembly languages and assemblers made for the IBM System/360 mainframe system and its successors through the IBM Z.

<span class="mw-page-title-main">Debug (command)</span> Line-oriented debug utility in DOS

The line-oriented debugger DEBUG.EXE is an external command in operating systems such as DOS, OS/2 and Windows.

<span class="mw-page-title-main">Cosmos (operating system)</span> Toolkit for building GUI and command-line based operating systems

C# Open Source Managed Operating System (Cosmos) is a toolkit for building GUI and command-line based operating systems, written mostly in the programming language C# and small amounts of a high level assembly language named X#. Cosmos is a backronym, in that the acronym was chosen before the meaning. It is open-source software released under a BSD license.

Open Watcom Assembler or WASM is an x86 assembler produced by Watcom, based on the Watcom Assembler found in Watcom C/C++ compiler and Watcom FORTRAN 77. Further development is being done on the 32- and 64-bit JWASM project, which more closely matches the syntax of Microsoft's assembler.

<span class="mw-page-title-main">MAC/65</span> Atari 8-bit family 6502 assembler

MAC/65 is a 6502 assembler written by Stephen D. Lawrow for the Atari 8-bit family of home computers. MAC/65 was first released on disk by Optimized Systems Software in 1982, with the program requiring 16 KB RAM. A bank switched "SuperCartridge" from OSS followed in January 1984 for US$99, occupying only 8 KB.

In computing, Java bytecode is the bytecode-structured instruction set of the Java virtual machine (JVM), a virtual machine that enables a computer to run programs written in the Java programming language and several other programming languages, see List of JVM languages.

References

  1. 1 2 Isaacson, Eric (2008). "A86/A386 assembler and D86/D386 debugger". Archived from the original on 2 July 2008. Retrieved 2008-07-02.
  2. 1 2 Randall Hyde. "Which Assembler is the Best?". Archived from the original on 15 May 2008. Retrieved 2008-05-18.
  3. ↑ Isaacson, Eric (2006). "A86/A386 and D86/D386 features".
  4. ↑ Isaacson, Eric (2006). "A386 and Win32 Programming".
  5. ↑ Hague, James (July 20, 2008). "Kilobyte Constants, a Simple and Beautiful Idea that Hasn't Caught On". Programming in the 21st Century.
  6. ↑ El-Khalil, Rakan; Keromyti, Angelos D. (2004). "Hydan: Hiding Information in Program Binaries" (PDF). In Lopez, Javier; Qing, Sihan; Okamoto, Eiji (eds.). Information and communications security: 6th International Conference, ICICS 2004, Malaga, Spain, October 27–29, 2004 : Proceedings. Lecture Notes in Computer Science. Vol. 3269. Springer. p. 190. ISBN   3-540-23563-9.
This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.