--- initial
+++ final
@@ -1,121 +1,121 @@
 void __init lguest_arch_host_init(void) {
   int i;
   /*
    * Most of the x86/switcher_32.S doesn't care that it's been moved; on
    * Intel, jumps are relative, and it doesn't access any references to
    * external code or data.
    *
    * The only exception is the interrupt handlers in switcher.S: their
    * addresses are placed in a table (default_idt_entries), so we need to
    * update the table with the new addresses.  switcher_offset() is a
    * convenience function which returns the distance between the
    * compiled-in switcher code and the high-mapped copy we just made.
    */
   for (i = 0; i < IDT_ENTRIES; i++)
     default_idt_entries[i] += switcher_offset();
   /*
    * Set up the Switcher's per-cpu areas.
    *
    * Each CPU gets two pages of its own within the high-mapped region
    * (aka. "struct lguest_pages").  Much of this can be initialized now,
    * but some depends on what Guest we are running (which is set up in
    * copy_in_guest_info()).
    */
   for_each_possible_cpu(i) {
     /* lguest_pages() returns this CPU's two pages. */
     struct lguest_pages *pages = lguest_pages(i);
     /* This is a convenience pointer to make the code neater. */
     struct lguest_ro_state *state = &pages->state;
     /*
      * The Global Descriptor Table: the Host has a different one
      * for each CPU.  We keep a descriptor for the GDT which says
      * where it is and how big it is (the size is actually the last
      * byte, not the size, hence the "-1").
      */
     state->host_gdt_desc.size = GDT_SIZE - 1;
-    state->host_gdt_desc.address = (long)get_cpu_gdt_table(i);
+    state->host_gdt_desc.address = (long)get_cpu_gdt_rw(i);
     /*
      * All CPUs on the Host use the same Interrupt Descriptor
      * Table, so we just use store_idt(), which gets this CPU's IDT
      * descriptor.
      */
     store_idt(&state->host_idt_desc);
     /*
      * The descriptors for the Guest's GDT and IDT can be filled
      * out now, too.  We copy the GDT & IDT into ->guest_gdt and
      * ->guest_idt before actually running the Guest.
      */
     state->guest_idt_desc.size = sizeof(state->guest_idt) - 1;
     state->guest_idt_desc.address = (long)&state->guest_idt;
     state->guest_gdt_desc.size = sizeof(state->guest_gdt) - 1;
     state->guest_gdt_desc.address = (long)&state->guest_gdt;
     /*
      * We know where we want the stack to be when the Guest enters
      * the Switcher: in pages->regs.  The stack grows upwards, so
      * we start it at the end of that structure.
      */
     state->guest_tss.sp0 = (long)(&pages->regs + 1);
     /*
      * And this is the GDT entry to use for the stack: we keep a
      * couple of special LGUEST entries.
      */
     state->guest_tss.ss0 = LGUEST_DS;
     /*
      * x86 can have a finegrained bitmap which indicates what I/O
      * ports the process can use.  We set it to the end of our
      * structure, meaning "none".
      */
     state->guest_tss.io_bitmap_base = sizeof(state->guest_tss);
     /*
      * Some GDT entries are the same across all Guests, so we can
      * set them up now.
      */
     setup_default_gdt_entries(state);
     /* Most IDT entries are the same for all Guests, too.*/
     setup_default_idt_entries(state, default_idt_entries);
     /*
      * The Host needs to be able to use the LGUEST segments on this
      * CPU, too, so put them in the Host GDT.
      */
-    get_cpu_gdt_table(i)[GDT_ENTRY_LGUEST_CS] = FULL_EXEC_SEGMENT;
-    get_cpu_gdt_table(i)[GDT_ENTRY_LGUEST_DS] = FULL_SEGMENT;
+    get_cpu_gdt_rw(i)[GDT_ENTRY_LGUEST_CS] = FULL_EXEC_SEGMENT;
+    get_cpu_gdt_rw(i)[GDT_ENTRY_LGUEST_DS] = FULL_SEGMENT;
   }
   /*
    * In the Switcher, we want the %cs segment register to use the
    * LGUEST_CS GDT entry: we've put that in the Host and Guest GDTs, so
    * it will be undisturbed when we switch.  To change %cs and jump we
    * need this structure to feed to Intel's "lcall" instruction.
    */
   lguest_entry.offset = (long)switch_to_guest + switcher_offset();
   lguest_entry.segment = LGUEST_CS;
   /*
    * Finally, we need to turn off "Page Global Enable".  PGE is an
    * optimization where page table entries are specially marked to show
    * they never change.  The Host kernel marks all the kernel pages this
    * way because it's always present, even when userspace is running.
    *
    * Lguest breaks this: unbeknownst to the rest of the Host kernel, we
    * switch to the Guest kernel.  If you don't disable this on all CPUs,
    * you'll get really weird bugs that you'll chase for two days.
    *
    * I used to turn PGE off every time we switched to the Guest and back
    * on when we return, but that slowed the Switcher down noticibly.
    */
   /*
    * We don't need the complexity of CPUs coming and going while we're
    * doing this.
    */
   get_online_cpus();
   if (boot_cpu_has(X86_FEATURE_PGE)) { /* We have a broader idea of "global". */
     /* Remember that this was originally set (for cleanup). */
     cpu_had_pge = 1;
     /*
      * adjust_pge is a helper function which sets or unsets the PGE
      * bit on its CPU, depending on the argument (0 == unset).
      */
     on_each_cpu(adjust_pge, (void *)0, 1);
     /* Turn off the feature in the global feature set. */
     clear_cpu_cap(&boot_cpu_data, X86_FEATURE_PGE);
   }
   put_online_cpus();
 }<sep>@@
expression e;
@@

- get_cpu_gdt_table
+ get_cpu_gdt_rw
    (e)