This book is a rarity in the market right now: a tutorial on how to use the popular GCC family of compilers. Given the remarkably large user base of GCC (which is due to it's quality, it's open source licencing model, and - probably most significantly - it's price), it's surprising how few books there are about it. Hagen provides a fairly comprehensive "howto" for GCC; this is not a language tutorial.
There is already a large body of adequate free documentation on the net about GCC, and all the answers are usually available for patient people who are competent with Google. But it's always useful to have this information collected into one well-organised authoritative source, and that's what we have here.
This is a large, comprehensive book. It's easy to read: well written with a clear layout and sensible organisation. It has a useful index, which is very important in a reference book like this.
Unfortunately, it's fairly Linux-specific. It's a real shame not to include more information of the flavours of GCC installation available on Windows, and this limits the book's market somewhat.
This book is now in its 2nd edition. It has been updated to cover the GCC 4.x series of compilers (which are vastly improved over the 3.x series described in the first edition). This update strips out all coverage of the previous versions, which is actually a shame; some details on older GCC versions might have been a useful aside - they still see a lot of use in specific installations and will for some time yet.
This edition contains new material, and presents the content in a far better order (for example: the chapters on building and installing GCC have moved from the very beginning towards the end of the book; most people have GCC available, or can install it very easily, without needing to build manually anyway).
Unlike first edition, there is a separate chapter for language supported by GCC (C, C++, Fortran, Java - the book pragmatically skips Ada coverage). Whilst this is undoubtedly simpler for someone who is only interested in a particular language, there's an amount of duplication inherent in this approach, and this is where a lot of the book's bulk (literally) is held.
The two chapters on autotools (autoconf, automake, and libtool) have moved over from the first edition. I think that these really shouldn't have been included at all. This is a book about GCC, not about the arcane twists involved in packaging software for random Unix-like operating systems. The information just isn't relevant and is mostly fluff. There are better books on autotools than the 46 pages of coverage provided here.
However, the second edition adds some advanced topics that are genuinely useful: building and using cross compilers and alternative C libraries. These chapters are good forays into the subject, as far as they go. But if you're doing anything so complicated that you need to read up on this (usually some form of embedded work) then these chapters alone will not be sufficient. They do, though, serve as a very good introduction and will set up for some more intelligent web searching and experimentation afterwards.
If you're using GCC 4.x (but not for Ada) and would like a printed reference then this book comes recommended. If you're happy with the documentation that comes with GCC then this book isn't a must-have. If you're considering GCC for embedded applications then this book might provide some useful insights to get you going.