Proebsting's Law asserts that improvements to compiler technology double the performance of typical programs every 18 years, but even granted that this is somewhat tongue-in-cheek, it's not really accurate; what tends to happen in practice is that each compiler that has serious effort put into optimization, spends a few years implementing those optimizations we know how to do, and further progress trails off asymptotically.
This is illustrated by the very first compiler, the original FORTRAN, proposed in 1953, specified in 1954 and shipped in 1957. Much of the development time was accounted for by the fact that computers were scarce and expensive and the developers believed (probably correctly) that the compiler would not be accepted unless it generated code that was reasonably competitive with handwritten assembly, so they put a lot of effort into implementing an optimizer that by all accounts would be considered pretty decent even by today's standards.
Perhaps the best-known example of a modern optimizing compiler collection is LLVM, which uses a language-specific front end to parse source code to an SSA intermediate format where most of the optimization is done, before generating machine code with a platform-specific back end. The intermediate format is primarily designed for C++, which means it has issues with Fortran which makes different default assumptions about pointer aliasing.
But the original FORTRAN could not have been designed that way; there was no thought at the time of making any of the code portable between different source languages or target platforms, SSA was not yet invented, and memory was much more constrained. On the other hand, it must've used some kind of intermediate representation; you cannot do heavy optimization in a single pass.
What kind of intermediate representation did it use?