Other Assemblers

Linux Assembly HOWTO
Prev | Chapter 3. Assemblers | Next

# 3.4. Other Assemblers

There are other assemblers with various interesting and outstanding features which may be of your interest as well.

| They can be in various stages of development, and can be non-classic/high-level/whatever else.

## 3.4.1. AS86

AS86 is a 80x86 assembler (16-bit and 32-bit) with integrated macro support. It has mostly Intel-syntax, though it differs slightly as for addressing modes. Some time ago it was used in a several projects, including the Linux kernel, but eventually most of those projects have moved to GAS or NASM. AFAIK, only ELKS continues to use it.

AS86 can be found at http://www.cix.co.uk/~mayday/, in bin86 package with linker (ld86), or as separate archive. Documentation is available as the man page and as.doc from the source package. When in doubt, the source code itself is often a good doc: though it is not very well commented, the programming style is straightforward. You might try to see how as86 is(was) used in ELKS, LILO, or Tunes 0.0.0.25...

| A completely outdated version 0.4 of AS86 is distributed by HJLu just to compile the Linux kernel versions prior to 2.4, in a package named bin86, available in any Linux GCC repository. But I advise no one to use it for anything else but compiling Linux. This version supports only a hacked minix object file format, which is not supported by the GNU binutils or anything, and it has a few bugs in 32-bit mode, so you really should better keep it only for compiling Linux.

| Using AS86 with BCC
| Here's the GNU Makefile entry for using BCC to transform `.s` asm into both a.out `.o` object and `.l` listing:
    %.o %.l:	%.s
    	bcc -3 -G -c -A-d -A-l -A$*.l -o $*.o $<
Remove the `%.l`, `-A-l`, and `-A$*.l`, if you don't want any listing. If you want something else than a.out, you can examine BCC docs about the other supported formats, and/or use the objcopy utility from the GNU binutils package.

## 3.4.2. YASM

YASM is a complete rewrite of the NASM assembler under the GNU GPL (some portions are under the "new" BSD License). It is designed from the ground up to allow for multiple syntaxes to be supported (eg, NASM, TASM, GAS, etc.) in addition to multiple output object formats. Another primary module of the overall design is an optimizer module.

It looks promising; it is under heavy development, and you may want to take part. See http://www.tortall.net/projects/yasm/.

## 3.4.3. FASM

FASM (flat assembler) is a fast, efficient 80x86 assembler that runs in 'flat real mode'. Unlike many other 80x86 assemblers, FASM only requires the source code to include the information it really needs. It is written in itself and is very small and fast. It runs on DOS/Windows/Linux and can produce flat binary, DOS EXE, Win32 PE, COFF and Linux ELF output. See http://flatassembler.net.

## 3.4.4. OSIMPA (SHASM)

osimpa is an assembler for Intel 80386 processors and subsequent, written entirely in the GNU Bash command interpreter shell. The predecessor of osimpa was shasm. osimpa is much cleaned up, can create useful Linux ELF executables, and has various HLL-like extensions and programmer convenience commands.

It is (of course) slower than other assemblers. It has its own syntax (and uses its own names for x86 opcodes) Fairly good documentation is included. Check it out: ftp://linux01.gwdg.de/pub/cLIeNUX/interim/. Probably you'll not use it on regular basis, but at least it deserves your interest as an interesting idea.

## 3.4.5. AASM

Aasm is an advanced assembler designed to support several target architectures. It has been designed to be easily extended and, should be considered as a good alternative to monolithic assembler development for each new target CPUs and binary file formats.

Aasm should make assembly programming easier for developer, by providing a set of advanced features including symbol scopes, an expressions engine, big integer support, macro capability, numerous and accurate warning messages... Its dynamic modular architecture enables Aasm to extend its set of features with plug-ins by taking advantages of dynamic libraries.

The input module supports Intel syntax (like nasm, tasm, masm, etc.). The x86 assembler module supports all opcodes up to P6 including MMX, SSE and 3DNow! extensions. F-CPU and SPARC assembler modules are under development. Several output modules are available for ELF, COFF, IntelHex, and raw binary formats.

http://savannah.nongnu.org/projects/aasm/

## 3.4.6. TDASM

The Table Driven Assembler (TDASM) is a free portable cross assembler for any kind of assembly language. It should be possible to use it as a compiler to any target microprocessor using a table that defines the compilation process.

It is available from http://www.penguin.cz/~niki/tdasm/.

## 3.4.7. HLA

HLA is a High Level Assembly language. It uses a high level language like syntax (similar to Pascal, C/C++, and other HLLs) for variable declarations, procedure declarations, and procedure calls. It uses a modified assembly language syntax for the standard machine instructions. It also provides several high level language style control structures (if, while, repeat..until, etc.) that help you write much more readable code.

HLA is free and comes with source, Linux and Win32 versions available. On Win32 you need MASM and a 32-bit version of MS-link on Win32, on Linux you nee GAS, because HLA produces specified assembler code and uses that assembler for final assembling and linking.

## 3.4.8. TALC

TALC is another free MASM/Win32 based compiler (however it supports ELF output, does it?).

TAL stands for Typed Assembly Language. It extends traditional untyped assembly languages with typing annotations, memory management primitives, and a sound set of typing rules, to guarantee the memory safety, control flow safety,and type safety of TAL programs. Moreover, the typing constructs are expressive enough to encode most source language programming features including records and structures, arrays, higher-order and polymorphic functions, exceptions, abstract data types, subtyping, and modules. Just as importantly, TAL is flexible enough to admit many low-level compiler optimizations. Consequently, TAL is an ideal target platform for type-directed compilers that want to produce verifiably safe code for use in secure mobile code applications or extensible operating system kernels.

## 3.4.9. Free Pascal

Free Pascal has an internal 32-bit assembler (based on NASM tables) and a switchable output that allows:

- Binary (ELF and coff when crosscompiled .o) output

- NASM

- MASM

- TASM

- AS (aout,coff, elf32)

The MASM and TASM output are not as good debugged as the other two, but can be handy sometimes.

The assembler's look and feel are based on Turbo Pascal's internal BASM, and the IDE supports similar highlighting, and FPC can fully integrate with gcc (on C level, not C++).

Using a dummy RTL, one can even generate pure assembler programs.

## 3.4.10. Win32Forth assembler

Win32Forth is a free 32-bit ANS FORTH system that successfully runs under Win32s, Win95, Win/NT. It includes a free 32-bit assembler (either prefix or postfix syntax) integrated into the reflective FORTH language. Macro processing is done with the full power of the reflective language FORTH; however, the only supported input and output contexts is Win32For itself (no dumping of `.obj` file, but you could add that feature yourself, of course). Find it at ftp://ftp.forth.org/pub/Forth/Compilers/native/windows/Win32For/.

## 3.4.11. Terse

Terse is a programming tool that provides THE most compact assembler syntax for the x86 family! However, it is evil proprietary software. It is said that there was a project for a free clone somewhere, that was abandoned after worthless pretenses that the syntax would be owned by the original author. Thus, if you're looking for a nifty programming project related to assembly hacking, I invite you to develop a terse-syntax frontend to NASM, if you like that syntax.

As an interesting historic remark, on comp.compilers,

1999/07/11 19:36:51, the moderator wrote:
"There's no reason that assemblers have to have awful syntax. About
30 years ago I used Niklaus Wirth's PL360, which was basically a S/360
assembler with Algol syntax and a a little syntactic sugar like while
loops that turned into the obvious branches. It really was an
assembler, e.g., you had to write out your expressions with explicit
assignments of values to registers, but it was nice. Wirth used it to
write Algol W, a small fast Algol subset, which was a predecessor to
Pascal. As is so often the case, Algol W was a significant
improvement over many of its successors. -John"

## 3.4.12. Non-free and/or Non-32bit x86 assemblers

You may find more about them, together with the basics of x86 assembly programming, in the Raymond Moon's x86 assembly FAQ.

Note that all DOS-based assemblers should work inside the Linux DOS Emulator, as well as other similar emulators, so that if you already own one, you can still use it inside a real OS. Recent DOS-based assemblers also support COFF and/or other object file formats that are supported by the GNU BFD library, so that you can use them together with your free 32-bit tools, perhaps using GNU objcopy (part of the binutils) as a conversion filter.

Prev | Home | Next
NASM | Up | Metaprogramming