Customer Reviews

The Definitive Guide to GCC

5 star:		(5)
4 star:		(3)
3 star:		(1)
2 star:		(2)
1 star:		(0)

 

 

The Definitive Guide to GCC covers the ways to use the GCC Compiler to compile programs written in C, C++, Fortran, and Java. For each of these languages the author discusses how it is implemented within the GCC compiler. While all the sections of the book are good the parts I found the best were the ones on optimizing and analyzing code as well as troubleshooting GCC. These are very well done sections and cover stuff that is often left out of other texts or not explained nearly as well.

This can be a dauntingly technical book for those unfamiliar with programming and compiling but that is also what makes it so perfect for the experienced user. It is an extensive reference that includes not only the common options but also some of the more obscure options and switches that can be highly useful in the right circumstances.

The Definitive Guide to GCC is typical of the "Definitive Guide" series by Apress and does not disappoint in terms of expertise, detail, and easy to follow explanations. If you want to know the GCC compiler, the details of how to use it, and troubleshoot compilation problems you will find this book to be one of the best resources you can find. The Definitive Guide to GCC is highly recommended.

Actually, this book does cover the FORTRAN and Java aspects of GCC for a couple of chapters, but yes it is mostly for C/C++ programmers. Anyway, if you want to learn about all of GCC's different switches, optimization techniques, and warnings then this book has it all. It also covers the "helper" tools like gcov.

Wow. Von Hagen hit a home run with this one. Most programming books are a great answer for insomnia but the well written style of this book almost makes it a "page turner" and that says something for this man's style. I typically shy away from such subjects but was sufficiently impressed enough to delve deeper.
It is apparent from the very beginning when the discussion opens with C compilers that this guy knows just about everything there is to know about GCC.
I don't agree with the Beginner to Intermediate level as I think it is probably an Intermediate book. You really should know something about programming to be successful in understanding and enjoying the book.
Apress is known for highly technical and very well-written books and this one is no different. They certainly seem to find the experts in the field to write their books.
GCC will certainly put you one up on the competition but you may have to read it twice because it is very packed with information. Keep it handy as an invaluable reference.

This is fine book, it's well written and easy to follow.. My only grip is with inaccuracies in the compile option appendix. The defined effect of certain options is the reverse from there actual effect. This caused me a bit of trouble when I tried to use the options and wasn't getting the results I expected. The online documentation was consistent with my results. My suggestion is double check the options against the gnu online reference. Hopefully in the following editions (if there will be any) this will be cleared up.

Informative, both basic and more advanced uses. However the plethora of tags that gcc takes can leave you with a headache if you don't know what your looking for. I had hoped there was a chapter on frontend/backend use, and how to build an interface to call GCC. Doesn't get into GAS or GDB at all.

If your looking for in depth knowledge of GCC the compiler this is the book. It covers multiple opperating systems and multiple versions of GCC. Starting with the history of GCC up to current versions of 4.x. A must read for any C or C++ even Objective-C developers (GCC compiles many more languages). Its a great reference to have in your war chest!

I'm not a big fan of GCC, and I don't think that opensource is the be all and end all. I'll try to be objective and not let my likes and dislikes colour this review.

The book seems to have a fairly good coverage of the main languages that GCC supports (C, C++, Java, Fortran, Objective C and Objective C++). I liked the coverage on optimisation and building GCC.

Now for some bad points. There is some annoying repetition - we get told far too many times that -pg is not the same as -p -g. The author proseletizes GNU software, and urges us to install GNU sed, awk, tar etc. In particular, I would not recommend GNU tar due to its nonstandard treatment of long filenames. I felt that the chapters on automake, autoconf, libtool and glibc were out of place in a book about a compiler suite. I try to avoid automake, autoconf and libtool (or autohell as they are collectively known as) like the plague as they are slow, unreliable when using platforms/compilers other than Linux/GCC and suffer chronic version dependency problems. I don't see any "amazing beauty" whatsoever (p. 185) in these three tools. I found the occasional digs at platforms such as VMS [which I've never used] somewhat unprofessional.

The glibc coverage adds to an overly Linux centric feel to the book (I learnt almost as much about Linux disaster recovery as I learnt about GCC on reading this book).

Rather than covering libtool, I would have preferred coverage of GNU ld (with a mention that the system link editor may be used on platforms that don't have GNU ld as the link editor).

There is no real comparison of GCC with other compilers. In particular, I think that it should have been mentioned that on platforms where GCC is not the 'native' compiler (Windows, Solaris and HP-UX, for instance), then generally GCC is both much slower at compiling, and compiles object code that runs much slower than the 'native' compiler (much slower being up to a factor of two slower). I've no experience with non-GCC compilers on *BSD and have only used the Intel compiler a few times, so I can't say whether GCC is also poor on home ground.

Last annoyance. Whilst I liked the alphabetical listing of options, there is not always a description of the default if no option is specified.

The ubiquitous GNU Compiler Collection is one of the fundamental underpinnings of Open Source and after a quarter of a century of development it is a formidable development tool. William von Hagen has done a masterful job in the second edition of the Definitive Guide to GCC in showing how to make the most of Richard Stallman's gift to the world. Occasionally the Author's sense of humour breaks up what can be a rather dry subject.

After a brief introduction to GCC, the author gets right into how to use GCC to compile C, C++, Fortran and Java respectively in the first four chapters of the book. While most of the book uses C code in examples of compiler usage, the Java chapter contains a good section on creating and using Jar files and Shared Libraries along with a brief section on how GCC supports Java and C++ interoperability. You quickly learn how to correctly use compiler flags to get the results you intend with these languages and gain an understanding of how they should be used. Importantly, without this understanding, it is easy to define flags that do not work as you expect, so the right off, this book can prove its worth. If you don't know what options are being passed to the gcc compiler in your makefile or know exactly what they do, then you aren't really in control of the build process for your code.

A significant change to the first edition was moving the first chapter of that edition, which covers the general use of the GCC compilers, into Appendix A. At 81 pages, this is the real meat in this book and I'm not sure that this was a good move, but it does align better with Appendix B, which covers machine and processor-specific options for GCC and hence can be considered an extension of Appendix A. The appendixes are rounded out with one on how to use GCC's On Line Help plus additional GCC support resources are provided in chapter 10.

My recommendations on how to get the most out of this book:
Read Appendix A, then check out Appendix B for the use of GCC extensions relevant to your particular machine/processor, then read the relevant chapter of the first four chapters for your specific language of interest. If you need to optimise or wish to debug your code using GCC's debugger and the use of gcov and gprof, check out chapters 5 and 6 respectively; I found these chapters particularly interesting. If you have problems that you suspect may be compiler related, chapter 9 covers troubleshooting. If your use of GCC isn't on an x86 IBM PC based computer, then check out Chapter 14, which covers building cross compilers with GCC and use Appendix B as necessary. If your target is an embedded design, this chapter, plus the optimisation chapter 5 along with chapter 13, which covers using alternate C libraries, will give you the background you need to use GCC for your project. Autoconf, automake and Libtool are covered in detail in chapters 7 and 8 and if you are interested in compiling GCC and building and installing Glibc (the author includes some valid reasons to do this), then these are covered in chapters 11 and 12.

Personally, I found the index frustrating to use, which I guess isn't surprising given the difficulty of covering the "1.3 zillion options" provided by GCC. If you heavily use the book, you may be better off purchasing the eBook, so you can search the book directly.

I found this book to be very helpful when I need to look up gcc command line options.

If you want to know more about the gcc compiler this is the right book. Some alreade gcc experienced people could argue that the information could be found by searching the internet but I do not think so.