From the lessons we learned in Section 3, we know that even though we want to compile classes ahead of time, we cannot afford to build the vtables statically. The information we get during the ahead-of-time compilation is not sufficient to determine the vtable layout. Besides, we need to handle our compilation carefully so that we can detect binary-incompatible changes and emit error messages gracefully.
We solve this problem by building vtables during class loading. Once loaded, a class is considered fixed. Further changes to this class can be ignored, according to the JLS. Thus we can safely determine the layout of the vtables.
A minor complication is that vtable layouts have to be consistent between a
superclass and a subclass. In other words, a method 
is located at the same
position in the vtable of a subclass as in the vtable of a superclass.
Luckily, the loading of a superclass precedes the loading of a subclass, which
makes it possible to construct the vtable of the subclass based on the vtable
layout of the superclass. In our solution, we maintain this consistency with
the help of a global allocation table which reflects the layout of the vtables
of all the loaded classes. During the loading of a class, we check the global
allocation table to learn the vtable layout of the superclass. Then we follow
the layout of the superclass and construct the class's vtable by appending
fresh entries at the end. We also record the newly determined layout in the
global allocation table so that any subclasses can access it.
The problem now is how to statically compile a virtual method invocation when the vtable layout is not determined statically. We handle this by introducing an extra level of indirection by compiling virtual method invocations to fetch an offset table entry before accessing the vtable. The offset table maps a virtual method to the offset of the method in the vtable. Its entries are filled in at run time when the corresponding class is loaded.
The idea of our approach is shown in Figure 5. To enable this approach, we need to make changes to both the compiler and the class loader.
