cls.getClassForType();
  public static void boot() throws Exception {    VM.writingBootImage = false;    VM.runningVM        = true;    VM.runningAsSubsystem = false;    // 0. Set up the current VM_Processor object.  The bootstrap program    // has placed a pointer to the current VM_Processor in a special    // register.    VM_ProcessorLocalState.boot();        // 1. Finish thread initialization that couldn't be done in boot image.    //    The "stackLimit" must be set before any method calls,     //    because it's accessed    //    by compiler-generated stack overflow checks.    //    VM_Thread currentThread  = VM_Scheduler.threads[VM_Magic.getThreadId() >>> OBJECT_THREAD_ID_SHIFT];    currentThread.stackLimit = VM_Magic.objectAsAddress(currentThread.stack) + STACK_SIZE_GUARD;    VM_Processor.getCurrentProcessor().activeThreadStackLimit = currentThread.stackLimit;    // get pthread_id from OS and store into vm_processor field    //     if (!BuildForSingleVirtualProcessor)      VM_Processor.getCurrentProcessor().pthread_id =         VM.sysCall0(VM_BootRecord.the_boot_record.sysPthreadSelfIP);             // 2. Initialize memory manager's write barrier.    //    This must happen before any putfield or arraystore of object refs    //    because the buffer is accessed by compiler-generated write barrier code.    //    if (VM_Collector.NEEDS_WRITE_BARRIER) {      VM_Collector.setupProcessor( VM_Processor.getCurrentProcessor() );    }         //-#if RVM_WITH_CONCURRENT_GC    // call setupProcessor to initialize increment/decrement buffer    // and set localEpoch to -1    //    // if reference counting set NEEDS_WRITE_BARRIER this call to    // setupProcessor would occur above...ie remove this ifdef    //    VM_Collector.setupProcessor( VM_Processor.getCurrentProcessor() );    //-#endif        // 3. Initialize memory manager.    //    This must happen before any uses of "new".    //    VM_Collector.boot(VM_BootRecord.the_boot_record);        VM.sysWrite("vm: booting\n");        // 4. Reset timers, so they don't inherit values from boot image.    //    VM_Timer.reset();    // 5. Fetch arguments from program command line.    //    VM_CommandLineArgs.fetchCommandLineArguments();    // 6. Initialize class loader.    //    String vmClasses = VM_CommandLineArgs.getVMClasses();    VM_ClassLoader.boot(vmClasses);    //    // At this point the virtual machine is running as a single thread     // that can perform dynamic compilation and linking (by compiler/linker     // that's part of boot image).  All that remains is to initialize the     // java class libraries, start up the thread subsystem, and launch    // the user level "main" thread.    //    //  Start up the baseline compiler's options before any compilations happen    //    VM_Compiler.bootOptions();         // Initialize statics that couldn't be placed in bootimage, either     // because they refer to external state (open files), or because they     // appear in fields that are unique to RVM implementation of     // standard class library (not part of standard jdk).    // We discover the latter by observing "host has no field" and     // "object not part of bootimage" messages printed out by bootimage     // writer.    //    runClassInitializer("java.io.FileDescriptor");    runClassInitializer("java.io.FileDescriptor");    runClassInitializer("java.lang.Runtime");    runClassInitializer("java.lang.System");    System.boot();    runClassInitializer("java.io.File");    runClassInitializer("java.lang.Boolean");    runClassInitializer("java.lang.Byte");    runClassInitializer("java.lang.Short");    runClassInitializer("java.lang.Integer");    runClassInitializer("java.lang.Long");    runClassInitializer("java.lang.Float");    runClassInitializer("java.lang.Double");    runClassInitializer("java.lang.Character");    runClassInitializer("com.ibm.oti.io.CharacterConverter");    runClassInitializer("java.util.Hashtable");    runClassInitializer("java.lang.Class");    //-#if RVM_WITH_JAZZLIB    runClassInitializer("java.lang.Math");    runClassInitializer("java.lang.RuntimePermission");    runClassInitializer("java.util.TimeZone");    runClassInitializer("java.util.Locale");    runClassInitializer("java.util.Calendar");    runClassInitializer("java.util.GregorianCalendar");    runClassInitializer("java.util.ResourceBundle");    runClassInitializer("java.util.zip.ZipEntry");    runClassInitializer("java.util.zip.Inflater");    runClassInitializer("java.util.zip.DeflaterHuffman");    runClassInitializer("java.util.zip.InflaterDynHeader");    runClassInitializer("java.util.zip.InflaterHuffmanTree");    //-#endif    // Initialize compiler.    //    VM_RuntimeCompiler.boot();         // 7. Process virtual machine directives.    //    String[] applicationArguments = VM_CommandLineArgs.processCommandLineArguments();    if (applicationArguments.length == 0) {        VM.sysWrite("vm: please specify a class to execute\n");      VM.sysExit(1);    }    // 8. Allow Baseline compiler to respond to command line arguments    //      // The baseline compiler ignores command line arguments until all are processed    // otherwise printing may occur because of compilations ahead of processing the    // method_to_print restriction    VM_Compiler.postBootOptions();    // 9. Allow Collector to respond to command line arguments    //    VM_Collector.postBoot();    // Work around class incompatibilities in boot image writer    // (JDK's java.lang.Thread does not extend VM_Thread) [--IP].    Thread    xx         = new MainThread(applicationArguments);    int       yy         = VM_Magic.objectAsAddress(xx);    VM_Thread mainThread = (VM_Thread)VM_Magic.addressAsObject(yy);    // record the main thread and the name of the main application class.    _mainApplicationClassName = applicationArguments[0];    _mainThread = mainThread;             //Ensure that all classes in the boot image that have static synchronized methods have their class objects loaded:    (VM_ClassLoader.findOrCreateType(VM_Atom.findOrCreateAsciiAtom("Ljava/lang/Thread;")).asClass()).getClassForType();         // Begin multiprocessing.    //    VM_Scheduler.boot(mainThread);    if (VM.VerifyAssertions)       VM.assert(VM.NOT_REACHED);  }     /**   * Run <clinit> method of specified class, if that class appears    * in bootimage.   * @param className   */  private static void runClassInitializer(String className) {    VM_Atom  classDescriptor =        VM_Atom.findOrCreateAsciiAtom(className.replace('.','/')).descriptorFromClassName();    VM_Class cls = VM_ClassLoader.findOrCreateType(classDescriptor).asClass();    if (cls.isInBootImage()) {      VM_Magic.invokeClassInitializer(cls.getClassInitializerMethod().getMostRecentlyGeneratedInstructions());      cls.setAllFinalStaticJTOCEntries();    }  }