Programming Books C Java PHP Python Learn more Browse Programming Books
Linkers and Loaders and over one million other books are available for Amazon Kindle. Learn more

Sorry, this item is not available in
Image not available for
Image not available

To view this video download Flash Player


Sign in to turn on 1-Click ordering
Sell Us Your Item
For a $10.67 Gift Card
Trade in
More Buying Choices
Have one to sell? Sell yours here
Start reading Linkers and Loaders on your Kindle in under a minute.

Don't have a Kindle? Get your Kindle here, or download a FREE Kindle Reading App.

Linkers and Loaders (The Morgan Kaufmann Series in Software Engineering and Programming) [Paperback]

John R. Levine
3.9 out of 5 stars  See all reviews (23 customer reviews)

List Price: $67.95
Price: $46.44 & FREE Shipping. Details
You Save: $21.51 (32%)
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
In Stock.
Ships from and sold by Gift-wrap available.
Want it Tuesday, July 15? Choose One-Day Shipping at checkout. Details
Free Two-Day Shipping for College Students with Amazon Student


Amazon Price New from Used from
Kindle Edition $44.12  
Tankobon Hardcover --  
Paperback $46.44  
Unknown Binding --  
Shop the New Digital Design Bookstore
Check out the Digital Design Bookstore, a new hub for photographers, art directors, illustrators, web developers, and other creative individuals to find highly rated and highly relevant career resources. Shop books on web development and graphic design, or check out blog posts by authors and thought-leaders in the design industry. Shop now

Book Description

October 25, 1999 1558604960 978-1558604964 1
Whatever your programming language, whatever your platform, you probably tap into linker and loader functions all the time. But do you know how to use them to their greatest possible advantage? Only now, with the publication of Linkers & Loaders, is there an authoritative book devoted entirely to these deep-seated compile-time and run-time processes.
The book begins with a detailed and comparative account of linking and loading that illustrates the differences among various compilers and operating systems. On top of this foundation, the author presents clear practical advice to help you create faster, cleaner code. You'll learn to avoid the pitfalls associated with Windows DLLs, take advantage of the space-saving, performance-improving techniques supported by many modern linkers, make the best use of the UNIX ELF library scheme, and much more. If you're serious about programming, you'll devour this unique guide to one of the field's least understood topics. Linkers & Loaders is also an ideal supplementary text for compiler and operating systems courses.

*Includes a linker construction project written in Perl, with project files available for download. *Covers dynamic linking in Windows, UNIX, Linux, BeOS, and other operating systems.
*Explains the Java linking model and how it figures in network applets and extensible Java code.
*Helps you write more elegant and effective code, and build applications that compile, load, and run more efficiently.

Frequently Bought Together

Linkers and Loaders (The Morgan Kaufmann Series in Software Engineering and Programming) + How Debuggers Work: Algorithms, Data Structures, and Architecture + Reversing: Secrets of Reverse Engineering
Price for all three: $112.01

Buy the selected items together

Editorial Reviews Review

Written for any programmer who works with compiled code, Linkers and Loaders surveys today's hardware platforms with a tour of how code is linked and executed on IBM mainframes, Unix, and Windows. This handy title fills a valuable niche for anyone who wants to understand how programs are built and run on today's computing systems.

It's the cross-platform perspective that distinguishes this book. The author's wide-ranging perspective on IBM 370 mainframes, RISC platforms like the SUN SPARC and, of course, Microsoft Windows makes this book a commendable reference on the internals of linkers and program execution in each environment. There's also a digestible guide to the computer architecture (including registers, instruction formats, and memory addressing) for each platform. (Unix programmers will be pleased that the book has more information on non-Windows platforms than on Windows itself.) For C++ programmers, this text gives you a glimpse into the internals of such language features as macros, templates, and name mangling, and how linkers deal with them at build time.

The book closes with useful material on static libraries and dynamic linking, plus a short tour of Java and its class loader (which can resolve classes on the fly as they are downloaded over the Internet). Short exercises are provided for each chapter, making this a useful resource for both classroom and self-study on what is an often overlooked topic. --Richard Dragan

Topics covered: History of linkers and loaders, application binary interfaces (ABIs), computer architecture basics, big- and little-endian memory addresses, register and instruction formats for IBM 370, SPARC and Intel x86, paging and virtual memory, position independent code (PIC), Intel x86 segmentation, embedded architectures, object files for DOS COM and EXE files, Unix a.out, Unix ELF, IBM 360 object format, Microsoft Portable Executable (PE) format, Intel Object Module Format (OMF), storage allocation, linking details for C++, symbol management, name mangling, weak and strong references, debugging information, library formats, COFF and ELF formats, relocation, loading and overlays, bootstrap loading, shared libraries, dynamic linking for Unix ELF and Microsoft Windows DLLs, advanced linking techniques for C++, and linking in Java.


"I enjoyed reading this useful overview of the techniques and challenges of implementing linkers and loaders. While most of the examples are focused on three computer architectures that are widely used today, there are also many side comments about interesting and quirky computer architectures of the past. I can tell from these war stories that the author really has been there himself and survived to tell the tale."-Guy Steele

Product Details

  • Series: The Morgan Kaufmann Series in Software Engineering and Programming
  • Paperback: 256 pages
  • Publisher: Morgan Kaufmann; 1 edition (October 25, 1999)
  • Language: English
  • ISBN-10: 1558604960
  • ISBN-13: 978-1558604964
  • Product Dimensions: 0.6 x 7.2 x 9 inches
  • Shipping Weight: 1 pounds (View shipping rates and policies)
  • Average Customer Review: 3.9 out of 5 stars  See all reviews (23 customer reviews)
  • Amazon Best Sellers Rank: #234,025 in Books (See Top 100 in Books)

More About the Author

See my tediously corporate home page at and my blog at Then rush back and buy lots of books, please.

Customer Reviews

Most Helpful Customer Reviews
45 of 46 people found the following review helpful
5.0 out of 5 stars Shines a light on an obscure subject January 11, 2000
I picked up this book to delve into interesting problems with a loader that I work with and was amazed at the great story told of what happens to your code after it goes through that compiler and becomes an object. It's not done yet, folks.
This book covers a broad range of topics, after first explaining the basics and architecture gotchas, to all the phases from the back end of the compiler to a program running in memory. Three example platforms are used to illustrate this journey: Intel x86 and 32-bit Windows, UltraSPARC and Solaris, and the IBM 360/370. However, it touches upon a great deal other challenges and formats.
Some might consider the symbolic journey from source code to running program to be equivalent to Conrad's "Heart of Darkness" but Levine's book makes it more like a guided tour at a Disney Theme park. There are wonderful examples and code snippets. Clear diagrams and excellent writing.
My only complaint about this book is that the back cover makes a lot of noise about Java, but the material inside is pretty paltry alongside the more developed material on C, FORTRAN, and C++ issues. Java is really not that complicated or important to Linkers and Loaders.
Comment | 
Was this review helpful to you?
22 of 22 people found the following review helpful
4.0 out of 5 stars not exactly what I was expecting. January 4, 2005
For what this book is, it is good. but, for what I expected it to be, it is a little lackluster. I was expecting a book that would explain linking and loading, provide code examples, and teach the subject systematically. What this book is however, is a simple technical reference. It talks about what things are, and the particulars of all the different file formats and architectures. It provides no code (and no pseudo-code) to demonstrate any of the concepts.

The book does however provide several excercises at the end of each chapter that will test the programmer, and it also has a main project: each chapter prompts the reader to construct, and add to a sample linker, which the book claims should be written in Perl, although perl is never talked about in the book, and no perl code is ever provided. Since Perl code is never used in the problems, and no solutions in perl are provided in the book (they are on the website, however), it would work just as well for a programmer to use any language that they felt comfortable with, such as C/C++ or Java.

my feelings are mixed. on one hand this book is an excellent reference on a subject that rarely sees any light. if I may quote a passage: "But all the linker writers in the world could probably fit in one room, and half of them already have copies [of this book]." Clearly the audience for this topic isnt particularly large, and so it seems that linkers and loaders will remain a bit of a black art, even though this book does shed some light on the most basic concepts involved. However, this book only contains concepts, and it asks the reader to view external sources for the specifics, and it asks the programmer to have a firm grasp on their knowledge of programming, but also computer architecture.
Read more ›
Comment | 
Was this review helpful to you?
33 of 37 people found the following review helpful
If you're just looking for a piece of literature to get you started thinking about understanding linkers, this is the book for you. However, if you actually want to write your own linker, you'd best find another book. This book covers all of the popular object and executable file formats such as COFF, ELF, and OMF, but it never really goes in depth or gives any example code, which is exactly what a programmer needs to really get what's going on. Even some pseudocode would've been nice. The only thing I particularly enjoyed about this book was the author's sense of humor, which is a rare thing in the realm of technical books. John Levine pokes fun at himself several times throughout the book, acknowledging that linker programmers are a rare breed indeed - Too bad he couldn't have written a more complete book on linkers, I would've given him a much better review.
Was this review helpful to you?
11 of 11 people found the following review helpful
The description of linking, loading, and various object formats is very informative. The style of writing is such that I was able to read it at one sitting (quite an accomplishment for a technical book :) ). But the book is seriously incomplete without a discussions of IBM's LX 32-bit executable, object, and DLL formats, and the differences between LX and PE, especially as it pertains to dynamic linking. Also, if you're going to discuss OMF objects, it seems impossible to me to skip NE executables, objects, and DLL formats--the jump from DOS 2.0 (OMF) to Windows NT (PE) is simply too great without a parallel discussion of NE. Finally, more coverage of incremental linking would be good. But, if you confine yourself to a.out, COFF, PE, or pre-NE OMF, this book's contents will interest you.
Comment | 
Was this review helpful to you?
23 of 29 people found the following review helpful
Despite its name and cover copy, this book is simply an introduction to object file formats. The actual discussion of linkers and loaders explains only the basic concepts (as others have pointed out, the coverage of advanced concepts such as dynamic linking is scant.) Thereafter, Levine traipses through a variety of object file formats and explains their layouts and superficially their differences.
Linking in Java is given a mere couple of pages--a clear afterthought. This despite being a topic of some complexity and uniquely different from traditional linking and loading.
Finally, a serious complaint: the book and its cover both trumpet a "linker construction project in Perl" that you can download from the author's website. A year after publication, this code is still not posted. When I contacted the author, he said he had been "too busy" to write the code and doubted he would ever get it posted. I find this kind of thing really dishonest.
But even that notwithstanding, this book is just not very good.
Comment | 
Was this review helpful to you?
Most Recent Customer Reviews
5.0 out of 5 stars Excellent Coverage of Underexplained Concepts
I've yet to come across someone who wrote software who didn't learn most of this material the hard way; most software-related education neglects that real projects need to be built... Read more
Published 1 month ago by Anonymous Customer
4.0 out of 5 stars Really Cool Knowledge
It's true that this book is a few years old. But, I emailed the author and he said not much as changed so it's safe to read the book and know you are still learning good stuff. Read more
Published 11 months ago by Student_of_Life
4.0 out of 5 stars Great
gives a very good understanding to the novice programmer of how loaders work and how they are associated with linkers
Published 15 months ago by A. Tavoularis
4.0 out of 5 stars its a good book - learning tools are a bit weak
I like the book as there doesn't seem to be a plethora of information on the subject... However, the learning projects are kind of weak. Read more
Published 22 months ago by R. Tkatch
4.0 out of 5 stars knowledgeable author but
the verbose, tedious, and non-self-contained litany of the nuances among every hardware architecture, every operation system, and every object file format on every linker concept... Read more
Published on January 12, 2011 by X. Lu
5.0 out of 5 stars Spot on
It's rare to find a book on such an obscure subject, much less such a well-written inclusive one. It is succinct, so don't feel daunted that you'll have to wade through hundreds... Read more
Published on December 31, 2009 by Ryan Joseph
4.0 out of 5 stars Best reference of its kind
I haven't found any better explanations of how linkers and loaders work. The book does a great job describing exactly what it is that linkers/loaders need to do and how they do... Read more
Published on November 18, 2009 by J. A. Sandoval
4.0 out of 5 stars decent
Overall this book provides decent coverage on linker technology, covering several popular object formats. Read more
Published on November 25, 2007 by Clark
5.0 out of 5 stars A must-have book
As far as I'm aware, this is the only book on the market that covers this subject. Clearly this book will be of use to someone that is starting on writing a link editor (or any... Read more
Published on September 2, 2007 by Paul Floyd
3.0 out of 5 stars too abstract
maybe it's not the book's fault and instead it's my lack of sufficient background, but this book is hard to understand because of its lack of examples.
Published on February 14, 2006 by Xu Ke
Search Customer Reviews
Search these reviews only

What Other Items Do Customers Buy After Viewing This Item?


There are no discussions about this product yet.
Be the first to discuss this product with the community.
Start a new discussion
First post:
Prompts for sign-in

Look for Similar Items by Category

Want to discover more products? You may find many from loaders for sale shopping list.