<p>What is the difference between different optimization levels in GCC?  Assuming I don't care to have any debug hooks, why wouldn't I just use the highest level of optimization available to me?  does a higher level of optimization necessarily (i.e. provably) generate a faster program?</p>

Generally optimization levels higher than
```
-O2
```
(just
```
-O3
```
for gcc but other compilers have higher ones) include optimizations that can increase the size of your code.  This includes things like loop unrolling, lots of inlining, padding for alignment regardless of size, etc.  Other compilers offer vectorization and inter-procedural optimization at levels higher than
```
-O3
```
, as well as certain optimizations that can improve speed a lot at the cost of correctness (e.g., using faster, less accurate math routines).  Check the docs before you use these things.
As for performance, it's a tradeoff.  In general, compiler designers try to tune these things so that they don't decrease the performance of your code, so
```
-O3
```
will usually help (at least in my experience) but your mileage may vary.  It's not always the case that really aggressive size-altering optimizations will improve performance (e.g. really aggressive inlining can get you cache pollution).