Linkers and Loaders (The Morgan Kaufmann Series in Software Engineering and Programming) 1st Edition

I've been around compilers, code generation, and object formats enough that this was mostly a refresher - but I did like some of the historical references and notes on atypical processors. I think this works at a good level of detail for experienced programmers who can fill in the blanks for things like relocation records that identify which bit positions need to be set. An experienced programmer will also have used symbolic debuggers, and will have a fair idea of what those tools expect to find in an executable image.I found discussion of linker scripts a bit thin, though - on one embedded application, I think I wrote more lines of linker scripts than of assembler. The author does mention things like linking a piece of code to run at address X but storing it in memory at address Y. You'll need this, for example, when your processor has a small but fast on-chip RAM (address X), and you have a few different code fragments (stored at addresses Y) you'll be loading into that buffer at different times.It also doesn't mention useful things like defining a symbol at the linker instead of the application code - helpful when coding to a memory mapped device that might live at different addresses in different application configurations. I also used this this feature with the GNU linker and this command line option: "-defsym,buildDateTime=$(shell date +%s)". That embeds the build time in the application - not as a value stored in memory, but as the address of the buildDateTime symbol which then gets cast to a time value.This does mention overlays, which can still be life-savers when coding a large application for a small (e.g. 16-bit) address space. I saw only 'tree-structured' overlays described, though, the kind found in DEC's RSX-11 operating system. I did not see mention of 'band-structured' overlays, as found in DEC's RT-11 system. That disappointed me because I've found the concept helpful in small address spaces with larger ROMs where, for example, something like overlays could be used for internationalization. With a helpful bus controller, you could swap between UI messages in different languages by choosing which languages' message overlay appears in the address space at any given time.No text can cover everything. For example, this omits the "cmpexe" compound executable format used in the Apollo Domain system. The one runnable file actually held code in two different instruction sets, so one program file could be used on both the 680x0 or the "Prism" processor architectures - the loader just chose which side of the program to run. Heterogeneous environments like that have been rarities, but the idea remains interesting. I was also involved in design of a microcode linker, where addresses were not numbers but bit-strings. Since sequential addresses had little meaning, individual instructions from different input segments could be interleaved, subject to bit pattern constraints on micro-addresses.Historical exotica aside, this gives a strong foundation in the basic concepts of linking and loading. It offers just enough of a look at CPU hardware to show how instruction formats and memory characteristics affect the process. It also presents a nice progression from simpler to more complex object formats, and the reasons for them. I imagine this as a useful adjunct to a college course in compilers or operating systems, and helpful to professionals self-teaching about what's "under the hood" in familiar programming tools. Highly recommended, but you might outgrow it quickly once you start working on the tools yourself.-- wiredweird

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 with objects, libraries, debug information, dependencies, and so on, and not just header-file + source file = program. This provides that missing... link.See what I just did there?Seriously though, it's far from an exhaustive reference of every build structure for every platform (good luck finding one that is), but it covers most of the things necessary to string a real project together of greater scope than a semester project. An understanding of compilers is fairly important for getting this book. If you put together anything more complex than "link UI to database and you're done here," read this book so someone doesn't have to explain why your project isn't building.

Delivered as promised. The book is a bit dated, but its still a great treatment of the subject matter.

Well worth reading if you want to understand many of the ideas that went into the design of loadable and executable binaries.

Careful introduction to linking and loading based on the simplest up to very sophisticated processor architectures.

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. I bought this book to help me understand how compilers and linkers work. Thus far it's been a good education. I can certainly look at my iOS\Objective-C coding and have some understanding of what's going on under the hood, which helps with understanding the language. I am finding that I need to read each section several times over. But, this is normal for a completely new topic of learning. I give this book 4 starts because I"m not completely confident that I'm not learning a few things that are outdated. But, a history lesson doesn't hurt either.

Really solid coverage of the topics.

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.