keywords = (trace-based) JIT compilation, static (online) analysis, abstract interpretation In contrast to traditional, static, ahead-of-time compilers, trace-based just-in-time (JIT) compilers do not compile an entire program upfront, but rather start by interpreting the program and identifying its frequently executed loops at run time. Instructions of these loops are recorded into a trace. Once one iteration of such a loop has been traced, the compiler compiles and optimises the resulting trace. Subsequent iterations will execute the optimised trace rather than interpret the original loop. As the JIT compiler has intricate knowledge of the run-time behaviour of the program, it can employ this knowledge to enable optimisations that would remain inaccessible to static compilers. However, current trace-based JIT compilers only employ information that is available within the trace and neglect to use any information that lies outside of the scope of the trace. We hypothesise that this information may nevertheless be useful for optimising traces, as it hints at the global behaviour of the program. To access this information, we propose to launch whole-program static analyses over the program at run time. This would enable us to incorporate concrete information about the execution of the program into the analyses, thereby increasing their precision. Publications available here