Linux Assembly Language Programming (Prentice Hall Open Source Technology) (Paperback)

by Bob Neveln (Author)

Editorial Reviews

Product Description
Explains all the key features of c86 assembly language in the context of Linux operating system and the C language. Uses a step-by-step, one-concept-at-a-time coverage to help the user master essentials skills. CD-ROM includes the Open Source assembler NASM, edinas, and sample device drivers from the text. Softcover.

From the Inside Flap
Preface

Assembly language is language which gives the programmer direct control over the computer. That is what appeals to people about assembly language. It is like using a stick shift. Programming with other languages, high-level languages, is like using an automatic.

Many people who use computers simply run programs. To them a program is a canned software package. People who like to write programs like to be able to shape the behavior of the machine the way metalsmiths shape metal into useful mechanical tools. Amongst all the programs on a computer, there is one program which runs the machine: the operating system. It controls everything. It offers "services" to the other programs. Most operating systems force programmers to leave their programming skills behind as they approach the operating system and to use it as they would a canned software package. That is because its source code is a secret. Linux portends the end of secret code in computing. Because the Linux source code and a compiler for it are right there on the computer along with the other source code, it allows programmers to work with the operating system as they do with programs they have written.

Operating systems were once written by programmers employed by computer manufacturers. Revolutions in hardware produced corresponding revolutions in the software. When Linus Torvalds rewrote Linux so that it would run on the Alpha architecture, his goal was not to increase its hardware base from one platform to two, but to make Linux platform-independent. The subsequent ports of Linux, to everything from a Sparc to a PowerPC, demonstrate the success of his rewrite.

The chief value of it is that it provides us with confidence that Linux is here to stay. We don't have to fear a PowerPC revolution coming along and forcing us to dump all of our old software.

Assembly code, on the other hand, is intrinsically platform-dependent and is justifiably regarded with caution for just this reason. It will have to be redone when the next hardware revolution takes place. Furthermore, people who compare the machine language of the 386 with other machine languages, both real and ideal, inevitably end up regarding the 386 language as a historical accident. On the other hand, the genetic code is sometimes referred to as a frozen accident. The term is based on the idea that the genetic code ceased its evolution when the number of proteins whose code would be "broken" by a mutation in the genetic code became so large that such mutations became lethal, and so the code became fixed. It remains to be seen whether 386 machine code has been "frozen" into place by the size of its software base. The threat of a PowerPC revolution has passed. On the other hand, many Linux enthusiasts anticipate an Alpha revolution.

But the Alpha revolution has not happened and it may not happen. The 386 language has been around for a long time. With many RISC machines now emulating the 386 architecture, isn't it time to consider programming in 386 assembly language? Assembly language is more work but it has its advantages. A very nice feature of assembly language code, which it shares with Linux itself incidentally, is that from a crass performance standpoint, it functions beautifully. Relying on compilers to produce good code is usually justifiable as a time saving measure.

But to get the best possible code, there is still no better option than to use assembly language. When high-level languages were still a novelty and referred to as automatic programming, many programmers were greatly offended by them. They were convinced that no compiler program could write code as well as they could. They were right of course. Compilers produce cheaper code but not better code. To get the full measure of speed and grace that a machine is capable of, there is no substitute for assembly language.

Furthermore, even if the Alpha revolution arrives on schedule tomorrow, there will remain in the world millions of processors running a 386 language that work beautifully and need to be put to a socially responsible use.

Computers can be programmed to report on our buying habits or to send off nuclear missiles. But they can also be programmed to communicate with privacy or to support medical research. As siliconsmiths, our job is to shape the behavior of the machine towards a human agenda.

This book assumes that the reader has some knowledge of C, but it makes no other assumptions.

Starred sections of the book are not needed subsequently and may be skipped when they are not of intrinsic interest.

Many errors undoubtedly remain. To those readers who notify me of them at [e-mail] I shall be grateful.

See all Editorial Reviews

Product Details

• Paperback: 272 pages
• Publisher: Prentice Hall PTR (July 30, 2000)
• Language: English
• ISBN-10: 0130879401
• ISBN-13: 978-0130879400
• Product Dimensions: 9.2 x 7 x 0.8 inches
• Shipping Weight: 1.3 pounds (View shipping rates and policies)
• Average Customer Review: 2.6 out of 5 stars See all reviews (13 customer reviews)
• Amazon.com Sales Rank: #1,046,241 in Books (See Bestsellers in Books)

Customer Reviews

Most Helpful Customer Reviews

14 of 14 people found the following review helpful:

1.0 out of 5 stars Avoid This Book, April 22, 2001

By	anderson (Pasadena, CA United States) - See all my reviews

I found this book to be almost completely worthless. Despite previous claims, neither the beginner nor the advanced programmer will have much use for this poorly written disappointment. The book's confusing organization and lack of coherency limits it's value to the beginning programmer while the advanced programmer will find nothing new. Intel's online IA32 manuals provide much better documentation at no cost. While those writing Linux device drivers may find the examples interesting, their money would be better spent on the Rubini book.

13 of 14 people found the following review helpful:

1.0 out of 5 stars This book is not what its title suggests., April 7, 2001

By	Martin Wilck (Leipzig, Germany) - See all my reviews

Since there are many introductory texts on general Intel assembly programming out there, I expected a book specifically focussed on Linux aspects. This book is rather a first course in assembly language. It does not go deep enough to really get the Reader going with assembly programming under Linux. It is extremely badly structured - the explanation of some instructions is spread over 3 to 4 sections with other aspects constantly interfering and confusing the reader. The worst thing about the book is that it does not even have a short reference on the AT&T assembly syntax which is most frequently used under Linux. Instead, the author just mentions that this syntax exists, remarks that it is "unusual" for programmers used to Intel syntax, and illustrates the difference to Intel syntax with 2 examples. An introduction to using inline assembly with gcc is also missng. For the most obvious application - kernel/driver programming, which requires understanding AT&T assembly code in the kernel -, the book is therefore almost useless. Instead, it comes with a superfluous chapter on DOS assembly programming.

12 of 13 people found the following review helpful:

3.0 out of 5 stars OK, but not really as good as it promised to be., November 4, 2000

By	"ishikyo" (Menlo Park, CA USA) - See all my reviews

GAS (the Gnu Compiler Assembler) with the AT&T format is what I use, so all the examples felt really short with their NASM syntax. Sorry I didn't bother switching to a different tool, already familiar with the one I use. I suspect that Linux is here in the title to attract wannabe gurus, because the in-depth treatment of the kernel is really light. I recommend Linux kernel internals and the Intel (free) Pentium manuals for a better coverage. If you are novice, then this book may be a way to motivate you to go further in your device driver writer journey. The book doesn't have too many typos/errors and makes up for a pleasant reading.