There are relatively few books on the market covering assembly programming on Linux; this work is a welcome newcomer for this niche. The book is a very gentle introduction to assembly programming, which goes into great detail to make understanding assembly programming under Linux easy. Although the IA-32 assembly language is operating system independent, several Linux specifics (such as the AT&T syntax, system calls usage, and external libraries usage) make it difficult for beginners to get used to it. I found this slow-paced introduction to assembly programming to be an ideal starting point for this category of readers. The book starts with a high-level presentation of assembly language programming and the IA-32 computer architecture, providing a brief refresher on topics like assembly mnemonics, bus, memory, stack, control unit, memory cache, and debugging.
Most readers who have taken an undergraduate-level course in programming can skip or skim the first section, and start directly at chapter 4, which covers real assembly programming. Basic Linux assembly programming is smoothly introduced. First, the book covers the structure and sections of an assembly program, and shows the multiple ways data can be moved between registers and memory. Controlling the execution flow of a program makes for a chapter in itself (chapter 6), where the basic programming building blocks used for loops and if-then-else constructs are described. In this chapter, I did not find coverage of more complex “switch” type multiple choice constructs, which are frequently used in programming.
The next chapter delves into the representation of both integer numbers (signed/unsigned) and floating point numbers, as well as associated operations (sign extension; moving multimedia extensions (MMX) registers; and streaming single instruction, multiple data (SIMD) extensions-2 (SSE2) and SSE3 instructions). While this chapter covers the topic well, I wish it had preceded the one on flow control (chapter 6), since conditional jumps in assembly based on comparing signed versus unsigned typed arguments are frequently the source of major programming flaws. I think that, for a novice reader, it might have been easier to learn these topics in the reverse order.
The next two chapters (8 and 9) focus entirely on mathematic operations. The basic operations (addition, subtraction, multiplication, and division) are addressed in chapter 8, while chapter 9 goes into advanced floating point unit (FPU) programming. This is one of the most valuable chapters in this book, since very few other assembly programming books address these topics.
The remainder of the book addresses standard topics for an assembly programming book: using string-specific instructions, implementing and calling functions, using Linux system calls, writing inline assembly with the GNU C compiler (GCC), calling external functions, and file processing in assembly. The last chapter is dedicated to advanced mathematical processing capabilities (MMX, SSE, SSE2, and SSE3) on the IA-32 platform.
Although I liked this book overall, and the chapters related to mathematic and advanced IA-32 operations (chapters 8, 9, and 17) could themselves justify reading it, there were some minor shortcomings in the structure of the book, and in its lack of coverage of more advanced topics. I wish the book would have had more complex examples (recursion, data structures, and device-level code) and a deeper technical difficulty level, such that more advanced readers would have been challenged.
I strongly recommend the book to any reader interested in learning assembly programming in a gentle, smooth, and easy way. The slow-paced rhythm and simple examples do gradually lead a novice reader to an intermediate level of knowledge in assembly programming. You will not be able to develop a device driver after reading this book, but you will be able to easily debug and understand assembly language code.
