#3 Mastering GAS: A Complete Guide to the GNU Assembler

Series for explaining and teaching GNU GAS Assembler using AT&T syntax – all codes are reviewed and tested daily on

Fedora Linux 42

GNU Assembler version 2.44-6

Differences between GAS and Other Assemblers (NASM, MASM, FASM)

When writing low-level code in assembly language, the assembler chosen plays a vital role in defining the developer's experience, capabilities, and final output. The GNU Assembler (GAS), part of the GNU toolchain, is one of the most widely used assemblers in open-source environments, especially in Unix-like systems. However, many other assemblers, including NASM (Netwide Assembler), MASM (Microsoft Macro Assembler), and FASM (Flat Assembler), also serve as popular alternatives in specific contexts. These assemblers differ in terms of syntax, features, platforms, and the overall approach to assembly programming.

In this section, we will discuss the fundamental differences between GAS, NASM, MASM, and FASM. Understanding these differences helps developers choose the right assembler depending on their target platform, development needs, and familiarity with specific assembly languages.

Syntax Differences

The most significant distinction between assemblers lies in the syntax they employ for writing assembly code. Syntax defines how instructions are written and structured, and different assemblers can interpret the same instruction differently depending on their syntax rules. This has a profound effect on ease of use, readability, and the type of assembly language used in programming. The two main types of syntax in use are AT&T syntax and Intel syntax, which are adopted by GAS and other assemblers, such as NASM, MASM, and FASM.

GAS: AT&T Syntax (Default)

The GNU Assembler uses AT&T syntax by default. AT&T syntax is often seen as less intuitive for beginners due to its strict and unconventional conventions compared to Intel syntax. It originated from the early days of Unix and is heavily influenced by the Berkeley Software Distribution (BSD). Some important characteristics of the AT&T syntax include:

• Operand Order (Source First): In AT&T syntax, the source operand comes before the destination operand. This is contrary to Intel syntax, where the destination is listed first. For instance, in AT&T syntax:

This instruction adds the contents of %ebx (source) to %eax (destination). This is the opposite of what is expected in Intel syntax, where the destination operand would be listed first.

• Registers Prefixed with %: In AT&T syntax, all registers are prefixed with a % sign. This helps distinguish between registers and memory operands. For example, the accumulator register in 32-bit systems is represented as %eax instead of just eax.

• Instruction Suffixes for Operand Size: AT&T syntax uses size suffixes to specify the operand's size. For example, b stands for byte (8-bit), w stands for word (16-bit), and l stands for long (32-bit). This suffix must be attached to the instruction itself. For example:

• addb for an 8-bit addition

• addw for a 16-bit addition

• addl for a 32-bit addition

This can sometimes feel cumbersome compared to Intel syntax, which determines operand size automatically.

NASM: Intel Syntax

NASM (Netwide Assembler) is one of the most commonly used assemblers in the world of x86 assembly, and it employs Intel syntax, which is more familiar and widely used in the broader assembly programming community. The key differences in the Intel syntax include:

• Operand Order (Destination First): Intel syntax places the destination operand first and the source operand second. In the example of an addition operation:

This instruction adds the contents of ebx (source) to eax (destination), which is the standard format in Intel syntax. This syntax convention is arguably more intuitive for most assembly programmers, as it aligns with the logical order of the operation (destination = source + something).

• No Register Prefix: Unlike AT&T syntax, Intel syntax does not require a % prefix for registers. For instance, eax represents the register directly without any special notation, which makes it look cleaner and simpler.

• Size Determination: Intel syntax does not require explicit suffixes to define operand sizes in the same way that AT&T syntax does. The size of the operand is typically determined by the instruction itself or the operands used. For instance, add eax, ebx implies a 32-bit operation because eax and ebx are 32-bit registers.

MASM: Microsoft Macro Assembler

MASM (Microsoft Macro Assembler) is primarily used on Windows systems and adopts a variant of Intel syntax. MASM has several unique features and capabilities that set it apart from GAS and NASM, particularly its integration with Microsoft's development tools. Some distinctive elements of MASM include:

• Macros: MASM supports a rich and powerful macro system, allowing developers to define reusable patterns of code. These macros can abstract away complex assembly constructs and make the code more readable and easier to maintain. The macro system in MASM is more advanced than that of GAS, providing more flexibility.

• Pseudoinstructions and High-Level Constructs: MASM includes numerous pseudoinstructions that allow developers to use more advanced, high-level constructs that simplify the development of complex programs. For instance, MASM provides ways to define strings, structures, and other complex data types in a higher-level, more human-readable format.

• Debugging and Symbols: MASM integrates well with Windows debuggers like WinDbg and Visual Studio. MASM has extensive support for debugging and provides capabilities for symbolic debugging. This makes it easier to track down bugs in larger applications written in assembly.

FASM: Flat Assembler

FASM (Flat Assembler) is a minimalist and extremely fast assembler. It is known for its simplicity, lightweight nature, and the ability to produce highly efficient machine code. FASM uses Intel syntax like NASM but distinguishes itself with its own specific set of features:

• Self-contained and Compact: FASM is a self-contained assembler, which means it doesn’t rely on external libraries, linking systems, or dependencies. The assembler can be run directly and can even be used to compile itself, making it particularly suited for embedded systems and scenarios where minimal overhead is desired.

• Inline Assembly and Optimization: FASM is highly optimized and capable of producing minimal and efficient code. This makes it ideal for applications that require low memory usage or need to run on constrained devices. FASM offers fine-grained control over memory and hardware-level instructions, allowing developers to write high- performance code.

• Lightweight and Speed: FASM’s lightweight design allows it to run extremely fast, which is particularly useful in scenarios where rapid iteration and performance are critical.

Platform Support

Each assembler is designed with a particular set of platforms and operating systems in mind. The support for various platforms can significantly influence the choice of assembler depending on the developer’s environment and goals. Let's take a closer look at the platform support for GAS, NASM, MASM, and FASM.

GAS Platform Support

GAS is highly portable and is part of the GNU toolchain, which is available across many platforms. Some key platforms supported by GAS include:

• Linux: GAS is most commonly used on Linux systems and is integrated with the GCC (GNU Compiler Collection) toolchain. It provides excellent support for 32-bit and 64- bit architectures, including x86, ARM, PowerPC, and more.

• macOS: GAS is also available on macOS, often in conjunction with development environments that require low-level programming or OS kernel development.

• BSD Systems: GAS is commonly used on FreeBSD, OpenBSD, and other BSD-derived systems.

• Cross-Platform Development: GAS is frequently used for cross-platform assembly, especially in open-source development projects that target multiple Unix-like operating systems.

NASM Platform Support

NASM is well-known for its cross-platform capabilities. It supports a wide range of platforms:

• Linux: NASM is widely used on Linux for both kernel and user-level applications, offering extensive support for Linux-based systems.

• Windows: NASM also runs on Windows, and many Windows-based developers prefer NASM for its compatibility with Windows’ x86 architecture.

• macOS: NASM works on macOS, where it can be used to develop low-level programs that interact with the system's native libraries and kernel.

• Other Platforms: NASM supports various other platforms, including embedded systems, DOS, and even some older systems, making it highly versatile.

MASM Platform Support

MASM is primarily targeted toward Windows and integrates directly into the Microsoft ecosystem. It’s specifically designed for developers working with the Windows operating system and has limited support on other platforms. Some key points about MASM’s platform support include:

• Windows: MASM is fully optimized for Windows development and is integrated with Microsoft’s Visual Studio and other development tools. It is heavily used for writing low-level Windows applications, including system drivers and Windows API calls.

• DOS: MASM was originally designed for MS-DOS and early Windows operating systems. While its modern usage is focused on Windows, legacy MASM code often targets DOS environments.

FASM Platform Support

FASM is a highly portable and cross-platform assembler, though it is most commonly used in lightweight embedded systems or minimal applications. Key platforms supported by FASM include:

• Linux: FASM works on Linux systems and is often used by developers working on embedded systems or other performance-critical applications.

• Windows: FASM also works well on Windows, especially in scenarios where minimalistic, small, and fast applications need to be written.

• macOS: Although not as common as on Linux and Windows, FASM can also be run on macOS, particularly for small, low-level programs.

• Cross-Platform Use: The minimalist and self-contained nature of FASM makes it suitable for cross-platform development, especially in embedded systems and real- time applications.

Key Features and Capabilities

The following table compares some of the key features offered by GAS, NASM, MASM, and FASM. These features determine how effective each assembler is for different types of development tasks, such as debugging support, macro capabilities, and memory optimizations.

Conclusion

In conclusion, each of these assemblers—GAS, NASM, MASM, and FASM—is suited to different types of development tasks, platforms, and user preferences. The choice of assembler largely depends on factors such as:

• The platform: If you’re working on Windows, MASM might be the best choice. If you're developing cross-platform applications, NASM and GAS would be more suitable.

• Familiarity with syntax: Developers coming from an Intel background will likely find NASM or MASM more intuitive, while those from a Unix/Linux environment will feel more comfortable using GAS.

• Development needs: If you require powerful macros and high-level abstractions, MASM is a great option. If you're focused on performance optimization and embedded systems, FASM shines due to its compactness and speed.

The assembler you choose depends on your development context, whether you need to write low-level system software, create high-performance applications, or integrate with specific toolchains.