Optimisations existed back then. But what Pascal did differently to a lot of modern languages was it only required a single-pass compiler and no macros.
On slow systems of the era, that vastly reduced the amount of work a compiler had to do to turn ASCII into machine code.
These days, compilers run macros, multiple passes of the source code. Often then building their own byte code or an interim machine representation, before turning that into machine code.
Those layers of abstraction aren’t without benefit. You get greater composability of code, greater portability, and so on and so forth. So they exist for a reason.
I often wonder how much benefit we get from most of those optimizations. I rarely felt that Turbo Pascal's runtime was slow or slow enough to cause frustration over something like C.
I think we could do something similar today - very fast compilation, and straightforward but efficient machine code. And perhaps bolt on the heavy duty optimizations where it is needed. Many JIT's work similar to this, but it seems like you could do it in an AOT style too.