xnu-1228.3.13.tar.gz

[apple/xnu.git] / osfmk / ppc / genassym.c

diff --git a/osfmk/ppc/genassym.c b/osfmk/ppc/genassym.c
index 059d57174dfe316ff6e092100e7b20a24955e007..8207aeb555c4de4b6743be98f2c11d6f4dec3974 100644 (file)
--- a/osfmk/ppc/genassym.c
+++ b/osfmk/ppc/genassym.c
@@ -1,23 +1,29 @@
 /*
 /*

- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2007 Apple Computer, Inc. All rights reserved.

  *
  *

- * @APPLE_LICENSE_HEADER_START@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@

  * 
  * 

- * The contents of this file constitute Original Code as defined in and
- * are subject to the Apple Public Source License Version 1.1 (the
- * "License").  You may not use this file except in compliance with the
- * License.  Please obtain a copy of the License at
- * http://www.apple.com/publicsource and read it before using this file.
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.

  * 
  * 

- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ * 
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER

  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
- * License for the specific language governing rights and limitations
- * under the License.
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.

  * 
  * 

- * @APPLE_LICENSE_HEADER_END@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@

  */
 /*
  * @OSF_COPYRIGHT@
  */
 /*
  * @OSF_COPYRIGHT@


@@ -37,21 +43,18 @@
  * the values, but we cannot run anything on the target machine.
  */
 
  * the values, but we cannot run anything on the target machine.
  */
 

-#include <cpus.h>
-#include <va_list.h>

 #include <types.h>
 
 #include <kern/task.h>
 #include <kern/thread.h>
 #include <types.h>
 
 #include <kern/task.h>
 #include <kern/thread.h>

-#include <kern/thread_act.h>

 #include <kern/host.h>
 #include <kern/lock.h>
 #include <kern/host.h>
 #include <kern/lock.h>

+#include <kern/locks.h>

 #include <kern/processor.h>
 #include <ppc/exception.h>
 #include <kern/processor.h>
 #include <ppc/exception.h>

-#include <ppc/thread_act.h>
+#include <ppc/thread.h>

 #include <ppc/misc_protos.h>
 #include <kern/syscall_sw.h>
 #include <ppc/misc_protos.h>
 #include <kern/syscall_sw.h>

-#include <kern/ast.h>

 #include <ppc/low_trace.h>
 #include <ppc/PseudoKernel.h>
 #include <ppc/mappings.h>
 #include <ppc/low_trace.h>
 #include <ppc/PseudoKernel.h>
 #include <ppc/mappings.h>


@@ -60,15 +63,23 @@
 #include <vm/vm_map.h>
 #include <vm/pmap.h>
 #include <ppc/pmap.h>
 #include <vm/vm_map.h>
 #include <vm/pmap.h>
 #include <ppc/pmap.h>

-#include <ppc/pmap_internals.h>

 #include <ppc/Diagnostics.h>
 #include <ppc/Diagnostics.h>

-#include <ppc/POWERMAC/mp/MPPlugIn.h>

 #include <pexpert/pexpert.h>
 #include <mach/machine.h>
 #include <ppc/vmachmon.h>
 #include <pexpert/pexpert.h>
 #include <mach/machine.h>
 #include <ppc/vmachmon.h>

+#include <ppc/hw_perfmon.h>

 #include <ppc/PPCcalls.h>
 #include <ppc/mem.h>
 #include <ppc/PPCcalls.h>
 #include <ppc/mem.h>

+#include <ppc/boot.h>
+#include <ppc/lowglobals.h>
+
+#if    CONFIG_DTRACE
+#define NEED_DTRACE_DEFS
+#include <../bsd/sys/lockstat.h>
+#endif

 
 

+/* Undefine standard offsetof because it is different than the one here */
+#undef offsetof

 #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE)0)->MEMBER)
 
 #define DECLARE(SYM,VAL) \
 #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE)0)->MEMBER)
 
 #define DECLARE(SYM,VAL) \


@@ -77,113 +88,51 @@
 int main(int argc, char *argv[])
 {
        /* Process Control Block */
 int main(int argc, char *argv[])
 {
        /* Process Control Block */

-
-       DECLARE("PCB_FLOAT_STATE", offsetof(struct pcb *, fs));
-
-       /* Floating point state */
-
-       DECLARE("PCB_FS_F0",    offsetof(struct pcb *, fs.fpregs[0]));
-       DECLARE("PCB_FS_F1",    offsetof(struct pcb *, fs.fpregs[1]));
-       DECLARE("PCB_FS_F2",    offsetof(struct pcb *, fs.fpregs[2]));
-       DECLARE("PCB_FS_F3",    offsetof(struct pcb *, fs.fpregs[3]));
-       DECLARE("PCB_FS_F4",    offsetof(struct pcb *, fs.fpregs[4]));
-       DECLARE("PCB_FS_F5",    offsetof(struct pcb *, fs.fpregs[5]));
-       DECLARE("PCB_FS_F6",    offsetof(struct pcb *, fs.fpregs[6]));
-       DECLARE("PCB_FS_F7",    offsetof(struct pcb *, fs.fpregs[7]));
-       DECLARE("PCB_FS_F8",    offsetof(struct pcb *, fs.fpregs[8]));
-       DECLARE("PCB_FS_F9",    offsetof(struct pcb *, fs.fpregs[9]));
-       DECLARE("PCB_FS_F10",   offsetof(struct pcb *, fs.fpregs[10]));
-       DECLARE("PCB_FS_F11",   offsetof(struct pcb *, fs.fpregs[11]));
-       DECLARE("PCB_FS_F12",   offsetof(struct pcb *, fs.fpregs[12]));
-       DECLARE("PCB_FS_F13",   offsetof(struct pcb *, fs.fpregs[13]));
-       DECLARE("PCB_FS_F14",   offsetof(struct pcb *, fs.fpregs[14]));
-       DECLARE("PCB_FS_F15",   offsetof(struct pcb *, fs.fpregs[15]));
-       DECLARE("PCB_FS_F16",   offsetof(struct pcb *, fs.fpregs[16]));
-       DECLARE("PCB_FS_F17",   offsetof(struct pcb *, fs.fpregs[17]));
-       DECLARE("PCB_FS_F18",   offsetof(struct pcb *, fs.fpregs[18]));
-       DECLARE("PCB_FS_F19",   offsetof(struct pcb *, fs.fpregs[19]));
-       DECLARE("PCB_FS_F20",   offsetof(struct pcb *, fs.fpregs[20]));
-       DECLARE("PCB_FS_F21",   offsetof(struct pcb *, fs.fpregs[21]));
-       DECLARE("PCB_FS_F22",   offsetof(struct pcb *, fs.fpregs[22]));
-       DECLARE("PCB_FS_F23",   offsetof(struct pcb *, fs.fpregs[23]));
-       DECLARE("PCB_FS_F24",   offsetof(struct pcb *, fs.fpregs[24]));
-       DECLARE("PCB_FS_F25",   offsetof(struct pcb *, fs.fpregs[25]));
-       DECLARE("PCB_FS_F26",   offsetof(struct pcb *, fs.fpregs[26]));
-       DECLARE("PCB_FS_F27",   offsetof(struct pcb *, fs.fpregs[27]));
-       DECLARE("PCB_FS_F28",   offsetof(struct pcb *, fs.fpregs[28]));
-       DECLARE("PCB_FS_F29",   offsetof(struct pcb *, fs.fpregs[29]));
-       DECLARE("PCB_FS_F30",   offsetof(struct pcb *, fs.fpregs[30]));
-       DECLARE("PCB_FS_F31",   offsetof(struct pcb *, fs.fpregs[31]));
-       DECLARE("PCB_FS_FPSCR", offsetof(struct pcb *, fs.fpscr_pad));
-
-       DECLARE("PCB_SAVED_STATE",offsetof(struct pcb *, ss));
-       DECLARE("ACT_MACT_KSP", offsetof(struct thread_activation *, mact.ksp));
-       DECLARE("ACT_MACT_BEDA", offsetof(struct thread_activation *, mact.bbDescAddr));
-       DECLARE("ACT_MACT_BTS", offsetof(struct thread_activation *, mact.bbTableStart));
-       DECLARE("ACT_MACT_BTE", offsetof(struct thread_activation *, mact.bbTaskEnv));
-       DECLARE("ACT_MACT_SPF", offsetof(struct thread_activation *, mact.specFlags));
-       DECLARE("qactTimer",    offsetof(struct thread_activation *, mact.qactTimer));
+       DECLARE("ACT_MACT_KSP", offsetof(thread_t, machine.ksp));
+       DECLARE("ACT_MACT_BEDA", offsetof(thread_t, machine.bbDescAddr));
+       DECLARE("ACT_MACT_BTS", offsetof(thread_t, machine.bbTableStart));
+       DECLARE("ACT_MACT_BTE", offsetof(thread_t, machine.bbTaskEnv));
+       DECLARE("ACT_MACT_SPF", offsetof(thread_t, machine.specFlags));
+       DECLARE("ACT_PREEMPT_CNT",      offsetof(thread_t, machine.preemption_count));
+       DECLARE("ACT_PER_PROC", offsetof(thread_t, machine.PerProc));
+       DECLARE("qactTimer",    offsetof(thread_t, machine.qactTimer));
+       DECLARE("umwSpace",     offsetof(thread_t, machine.umwSpace));
+       DECLARE("umwRelo",      offsetof(thread_t, machine.umwRelo));
+       DECLARE("umwSwitchAway",        umwSwitchAway);
+       DECLARE("umwSwitchAwayb",       umwSwitchAwayb);
+       DECLARE("bbTrap",               offsetof(thread_t, machine.bbTrap));
+       DECLARE("bbSysCall",    offsetof(thread_t, machine.bbSysCall));
+       DECLARE("bbInterrupt",  offsetof(thread_t, machine.bbInterrupt));
+       DECLARE("bbPending",    offsetof(thread_t, machine.bbPending));
+       

        DECLARE("floatUsed",    floatUsed);
        DECLARE("vectorUsed",   vectorUsed);
        DECLARE("floatUsed",    floatUsed);
        DECLARE("vectorUsed",   vectorUsed);

-       DECLARE("bbNoMachSCbit",bbNoMachSCbit);

        DECLARE("runningVM",    runningVM);
        DECLARE("runningVM",    runningVM);

+       DECLARE("runningVMbit", runningVMbit);

        DECLARE("floatCng",             floatCng);
        DECLARE("floatCng",             floatCng);

-       DECLARE("vectorCng",    vectorCng);

        DECLARE("floatCngbit",  floatCngbit);
        DECLARE("floatCngbit",  floatCngbit);

+       DECLARE("vectorCng",    vectorCng);

        DECLARE("vectorCngbit", vectorCngbit);
        DECLARE("vectorCngbit", vectorCngbit);

-       DECLARE("bbThreadbit",  bbThreadbit);
-       DECLARE("bbPreemptivebit",      bbPreemptivebit);
+       DECLARE("userProtKey",  userProtKey);
+       DECLARE("userProtKeybit",       userProtKeybit);
+

        DECLARE("bbThread",             bbThread);
        DECLARE("bbThread",             bbThread);

+       DECLARE("bbThreadbit",  bbThreadbit);
+       DECLARE("bbNoMachSC",   bbNoMachSC);
+       DECLARE("bbNoMachSCbit",bbNoMachSCbit);

        DECLARE("bbPreemptive", bbPreemptive);
        DECLARE("bbPreemptive", bbPreemptive);

+       DECLARE("bbPreemptivebit",      bbPreemptivebit);
+

        DECLARE("fvChkb",               fvChkb);
        DECLARE("fvChk",                fvChk);
        DECLARE("fvChkb",               fvChkb);
        DECLARE("fvChk",                fvChk);

-       DECLARE("userProtKeybit",       userProtKeybit);
-       DECLARE("userProtKey",  userProtKey);
-
-       DECLARE("PCB_SIZE",     sizeof(struct pcb));
-
-       /* Save State Structure */
-       DECLARE("SS_R0",        offsetof(struct ppc_saved_state *, r0));
-       DECLARE("SS_R1",        offsetof(struct ppc_saved_state *, r1));
-       DECLARE("SS_R2",        offsetof(struct ppc_saved_state *, r2));
-       DECLARE("SS_R3",        offsetof(struct ppc_saved_state *, r3));
-       DECLARE("SS_R4",        offsetof(struct ppc_saved_state *, r4));
-       DECLARE("SS_R5",        offsetof(struct ppc_saved_state *, r5));
-       DECLARE("SS_R6",        offsetof(struct ppc_saved_state *, r6));
-       DECLARE("SS_R7",        offsetof(struct ppc_saved_state *, r7));
-       DECLARE("SS_R8",        offsetof(struct ppc_saved_state *, r8));
-       DECLARE("SS_R9",        offsetof(struct ppc_saved_state *, r9));
-       DECLARE("SS_R10",       offsetof(struct ppc_saved_state *, r10));
-       DECLARE("SS_R11",       offsetof(struct ppc_saved_state *, r11));
-       DECLARE("SS_R12",       offsetof(struct ppc_saved_state *, r12));
-       DECLARE("SS_R13",       offsetof(struct ppc_saved_state *, r13));
-       DECLARE("SS_R14",       offsetof(struct ppc_saved_state *, r14));
-       DECLARE("SS_R15",       offsetof(struct ppc_saved_state *, r15));
-       DECLARE("SS_R16",       offsetof(struct ppc_saved_state *, r16));
-       DECLARE("SS_R17",       offsetof(struct ppc_saved_state *, r17));
-       DECLARE("SS_R18",       offsetof(struct ppc_saved_state *, r18));
-       DECLARE("SS_R19",       offsetof(struct ppc_saved_state *, r19));
-       DECLARE("SS_R20",       offsetof(struct ppc_saved_state *, r20));
-       DECLARE("SS_R21",       offsetof(struct ppc_saved_state *, r21));
-       DECLARE("SS_R22",       offsetof(struct ppc_saved_state *, r22));
-       DECLARE("SS_R23",       offsetof(struct ppc_saved_state *, r23));
-       DECLARE("SS_R24",       offsetof(struct ppc_saved_state *, r24));
-       DECLARE("SS_R25",       offsetof(struct ppc_saved_state *, r25));
-       DECLARE("SS_R26",       offsetof(struct ppc_saved_state *, r26));
-       DECLARE("SS_R27",       offsetof(struct ppc_saved_state *, r27));
-       DECLARE("SS_R28",       offsetof(struct ppc_saved_state *, r28));
-       DECLARE("SS_R29",       offsetof(struct ppc_saved_state *, r29));
-       DECLARE("SS_R30",       offsetof(struct ppc_saved_state *, r30));
-       DECLARE("SS_R31",       offsetof(struct ppc_saved_state *, r31));
-       DECLARE("SS_CR",        offsetof(struct ppc_saved_state *, cr));
-       DECLARE("SS_XER",       offsetof(struct ppc_saved_state *, xer));
-       DECLARE("SS_LR",        offsetof(struct ppc_saved_state *, lr));
-       DECLARE("SS_CTR",       offsetof(struct ppc_saved_state *, ctr));
-       DECLARE("SS_SRR0",      offsetof(struct ppc_saved_state *, srr0));
-       DECLARE("SS_SRR1",      offsetof(struct ppc_saved_state *, srr1));
-       DECLARE("SS_MQ",        offsetof(struct ppc_saved_state *, mq));
-       DECLARE("SS_SR_COPYIN", offsetof(struct ppc_saved_state *, sr_copyin));
-       DECLARE("SS_SIZE",      sizeof(struct ppc_saved_state));
+       DECLARE("FamVMena",             FamVMena);
+       DECLARE("FamVMenabit",          FamVMenabit);
+       DECLARE("FamVMmode",            FamVMmode);
+       DECLARE("FamVMmodebit",         FamVMmodebit);
+       DECLARE("perfMonitor",          perfMonitor);
+       DECLARE("perfMonitorbit",       perfMonitorbit);
+       DECLARE("OnProc",               OnProc);
+       DECLARE("OnProcbit",            OnProcbit);

 
        /* Per Proc info structure */
        DECLARE("PP_CPU_NUMBER",                offsetof(struct per_proc_info *, cpu_number));
 
        /* Per Proc info structure */
        DECLARE("PP_CPU_NUMBER",                offsetof(struct per_proc_info *, cpu_number));


@@ -192,27 +141,21 @@ int main(int argc, char *argv[])
        DECLARE("PP_INTSTACK_TOP_SS",   offsetof(struct per_proc_info *, intstack_top_ss));
        DECLARE("PP_DEBSTACKPTR",               offsetof(struct per_proc_info *, debstackptr));
        DECLARE("PP_DEBSTACK_TOP_SS",   offsetof(struct per_proc_info *, debstack_top_ss));
        DECLARE("PP_INTSTACK_TOP_SS",   offsetof(struct per_proc_info *, intstack_top_ss));
        DECLARE("PP_DEBSTACKPTR",               offsetof(struct per_proc_info *, debstackptr));
        DECLARE("PP_DEBSTACK_TOP_SS",   offsetof(struct per_proc_info *, debstack_top_ss));

-       DECLARE("PP_TEMPWORK1",                 offsetof(struct per_proc_info *, tempwork1));
-       DECLARE("PP_USERSPACE",                 offsetof(struct per_proc_info *, userspace));
-       DECLARE("PP_USERPMAP",                  offsetof(struct per_proc_info *, userpmap));
-       DECLARE("PP_LASTPMAP",                  offsetof(struct per_proc_info *, Lastpmap));
-       DECLARE("savedSave",                    offsetof(struct per_proc_info *, savedSave));
-
-       DECLARE("PP_SAVE_EXCEPTION_TYPE", offsetof(struct per_proc_info *, save_exception_type));
-       DECLARE("PP_CPU_DATA",                  offsetof(struct per_proc_info *, cpu_data));
-       DECLARE("PP_ACTIVE_KLOADED",    offsetof(struct per_proc_info *, active_kloaded));
-       DECLARE("PP_ACTIVE_STACKS",     offsetof(struct per_proc_info *, active_stacks));
-       DECLARE("PP_NEED_AST",                  offsetof(struct per_proc_info *, need_ast));
-       DECLARE("PP_FPU_THREAD",                offsetof(struct per_proc_info *, FPU_thread));
-       DECLARE("FPU_vmmCtx",                   offsetof(struct per_proc_info *, FPU_vmmCtx));
-       DECLARE("PP_VMX_THREAD",                offsetof(struct per_proc_info *, VMX_thread));
-       DECLARE("VMX_vmmCtx",                   offsetof(struct per_proc_info *, VMX_vmmCtx));
-       DECLARE("PP_QUICKFRET",                 offsetof(struct per_proc_info *, quickfret));
+       DECLARE("PP_HIBERNATE", offsetof(struct per_proc_info *, hibernate));
+       DECLARE("FPUowner",                             offsetof(struct per_proc_info *, FPU_owner));
+       DECLARE("VMXowner",                             offsetof(struct per_proc_info *, VMX_owner));
+       DECLARE("holdQFret",                    offsetof(struct per_proc_info *, holdQFret));
+       DECLARE("rtcPop",                               offsetof(struct per_proc_info *, rtcPop));
+
+       DECLARE("PP_PENDING_AST",               offsetof(struct per_proc_info *, pending_ast));
+       DECLARE("quickfret",                    offsetof(struct per_proc_info *, quickfret));
+       DECLARE("lclfree",                              offsetof(struct per_proc_info *, lclfree));
+       DECLARE("lclfreecnt",                   offsetof(struct per_proc_info *, lclfreecnt));

        DECLARE("PP_INTS_ENABLED",              offsetof(struct per_proc_info *, interrupts_enabled));
        DECLARE("UAW",                                  offsetof(struct per_proc_info *, Uassist));
        DECLARE("PP_INTS_ENABLED",              offsetof(struct per_proc_info *, interrupts_enabled));
        DECLARE("UAW",                                  offsetof(struct per_proc_info *, Uassist));

+       DECLARE("next_savearea",                offsetof(struct per_proc_info *, next_savearea));

        DECLARE("ppbbTaskEnv",                  offsetof(struct per_proc_info *, ppbbTaskEnv));
        DECLARE("liveVRS",                              offsetof(struct per_proc_info *, liveVRSave));
        DECLARE("ppbbTaskEnv",                  offsetof(struct per_proc_info *, ppbbTaskEnv));
        DECLARE("liveVRS",                              offsetof(struct per_proc_info *, liveVRSave));

-       DECLARE("liveFPSCR",                    offsetof(struct per_proc_info *, liveFPSCR));

        DECLARE("spcFlags",                     offsetof(struct per_proc_info *, spcFlags));
        DECLARE("spcTRc",                               offsetof(struct per_proc_info *, spcTRc));
        DECLARE("spcTRp",                               offsetof(struct per_proc_info *, spcTRp));
        DECLARE("spcFlags",                     offsetof(struct per_proc_info *, spcFlags));
        DECLARE("spcTRc",                               offsetof(struct per_proc_info *, spcTRc));
        DECLARE("spcTRp",                               offsetof(struct per_proc_info *, spcTRp));


@@ -232,28 +175,16 @@ int main(int argc, char *argv[])
        DECLARE("pfCanNapb",                    pfCanNapb);
        DECLARE("pfCanDoze",                    pfCanDoze);
        DECLARE("pfCanDozeb",                   pfCanDozeb);
        DECLARE("pfCanNapb",                    pfCanNapb);
        DECLARE("pfCanDoze",                    pfCanDoze);
        DECLARE("pfCanDozeb",                   pfCanDozeb);

-       DECLARE("pfCanDoze",                    pfCanDoze);
-       DECLARE("pfCanDozeb",                   pfCanDozeb);
-       DECLARE("pfThermal",                    pfThermal);
-       DECLARE("pfThermalb",                   pfThermalb);
-       DECLARE("pfThermInt",                   pfThermInt);
-       DECLARE("pfThermIntb",                  pfThermIntb);
-       DECLARE("pfWillNap",                    pfWillNap);
-       DECLARE("pfWillNapb",                   pfWillNapb);
-       DECLARE("pfNoMSRir",                    pfNoMSRir);
-       DECLARE("pfNoMSRirb",                   pfNoMSRirb);

        DECLARE("pfSlowNap",                            pfSlowNap);
        DECLARE("pfSlowNapb",                           pfSlowNapb);
        DECLARE("pfNoMuMMCK",                           pfNoMuMMCK);
        DECLARE("pfNoMuMMCKb",                          pfNoMuMMCKb);
        DECLARE("pfSlowNap",                            pfSlowNap);
        DECLARE("pfSlowNapb",                           pfSlowNapb);
        DECLARE("pfNoMuMMCK",                           pfNoMuMMCK);
        DECLARE("pfNoMuMMCKb",                          pfNoMuMMCKb);

-       DECLARE("pfLClck",                              pfLClck);
-       DECLARE("pfLClckb",                             pfLClckb);
-       DECLARE("pfL3pdet",                             pfL3pdet);
-       DECLARE("pfL3pdetb",                            pfL3pdetb);
-       DECLARE("pfL1i",                                pfL1i);
-       DECLARE("pfL1ib",                               pfL1ib);
-       DECLARE("pfL1d",                                pfL1d);
-       DECLARE("pfL1db",                               pfL1db);
+       DECLARE("pfNoL2PFNap",                          pfNoL2PFNap);
+       DECLARE("pfNoL2PFNapb",                         pfNoL2PFNapb);
+       DECLARE("pfSCOMFixUp",                          pfSCOMFixUp);
+       DECLARE("pfSCOMFixUpb",                         pfSCOMFixUpb);
+    DECLARE("pfHasDcba",                       pfHasDcba);
+       DECLARE("pfHasDcbab",                   pfHasDcbab);

        DECLARE("pfL1fa",                               pfL1fa);
        DECLARE("pfL1fab",                              pfL1fab);
        DECLARE("pfL2",                                 pfL2);
        DECLARE("pfL1fa",                               pfL1fa);
        DECLARE("pfL1fab",                              pfL1fab);
        DECLARE("pfL2",                                 pfL2);


@@ -262,6 +193,20 @@ int main(int argc, char *argv[])
        DECLARE("pfL2fab",                              pfL2fab);
        DECLARE("pfL2i",                                pfL2i);
        DECLARE("pfL2ib",                               pfL2ib);
        DECLARE("pfL2fab",                              pfL2fab);
        DECLARE("pfL2i",                                pfL2i);
        DECLARE("pfL2ib",                               pfL2ib);

+       DECLARE("pfLClck",                              pfLClck);
+       DECLARE("pfLClckb",                             pfLClckb);
+       DECLARE("pfWillNap",                    pfWillNap);
+       DECLARE("pfWillNapb",                   pfWillNapb);
+       DECLARE("pfNoMSRir",                    pfNoMSRir);
+       DECLARE("pfNoMSRirb",                   pfNoMSRirb);
+       DECLARE("pfL3pdet",                             pfL3pdet);
+       DECLARE("pfL3pdetb",                    pfL3pdetb);
+    DECLARE("pf128Byte",                       pf128Byte);
+    DECLARE("pf128Byteb",                      pf128Byteb);
+    DECLARE("pf32Byte",                                pf32Byte);
+    DECLARE("pf32Byteb",                       pf32Byteb);
+    DECLARE("pf64Bit",                         pf64Bit);
+    DECLARE("pf64Bitb",                                pf64Bitb);

        DECLARE("pfL3",                                 pfL3);
        DECLARE("pfL3b",                                pfL3b);
        DECLARE("pfL3fa",                               pfL3fa);
        DECLARE("pfL3",                                 pfL3);
        DECLARE("pfL3b",                                pfL3b);
        DECLARE("pfL3fa",                               pfL3fa);


@@ -280,25 +225,76 @@ int main(int argc, char *argv[])
        DECLARE("pfHID1",                               offsetof(struct per_proc_info *, pf.pfHID1));
        DECLARE("pfHID2",                               offsetof(struct per_proc_info *, pf.pfHID2));
        DECLARE("pfHID3",                               offsetof(struct per_proc_info *, pf.pfHID3));
        DECLARE("pfHID1",                               offsetof(struct per_proc_info *, pf.pfHID1));
        DECLARE("pfHID2",                               offsetof(struct per_proc_info *, pf.pfHID2));
        DECLARE("pfHID3",                               offsetof(struct per_proc_info *, pf.pfHID3));

+       DECLARE("pfHID4",                               offsetof(struct per_proc_info *, pf.pfHID4));
+       DECLARE("pfHID5",                               offsetof(struct per_proc_info *, pf.pfHID5));

        DECLARE("pfMSSCR0",                     offsetof(struct per_proc_info *, pf.pfMSSCR0));
        DECLARE("pfMSSCR1",                     offsetof(struct per_proc_info *, pf.pfMSSCR1));
        DECLARE("pfMSSCR0",                     offsetof(struct per_proc_info *, pf.pfMSSCR0));
        DECLARE("pfMSSCR1",                     offsetof(struct per_proc_info *, pf.pfMSSCR1));

-       DECLARE("pfICTRL",                      offsetof(struct per_proc_info *, pf.pfICTRL));
+       DECLARE("pfICTRL",                              offsetof(struct per_proc_info *, pf.pfICTRL));

        DECLARE("pfLDSTCR",                     offsetof(struct per_proc_info *, pf.pfLDSTCR));
        DECLARE("pfLDSTDB",                     offsetof(struct per_proc_info *, pf.pfLDSTDB));
        DECLARE("pfl2crOriginal",               offsetof(struct per_proc_info *, pf.l2crOriginal));
        DECLARE("pfl3crOriginal",               offsetof(struct per_proc_info *, pf.l3crOriginal));
        DECLARE("pfLDSTCR",                     offsetof(struct per_proc_info *, pf.pfLDSTCR));
        DECLARE("pfLDSTDB",                     offsetof(struct per_proc_info *, pf.pfLDSTDB));
        DECLARE("pfl2crOriginal",               offsetof(struct per_proc_info *, pf.l2crOriginal));
        DECLARE("pfl3crOriginal",               offsetof(struct per_proc_info *, pf.l3crOriginal));

-       DECLARE("pfBootConfig",                 offsetof(struct per_proc_info *, pf.pfBootConfig));
+       DECLARE("pfBootConfig",                 offsetof(struct per_proc_info *, pf.pfBootConfig));
+       DECLARE("pfPowerModes",                 offsetof(struct per_proc_info *, pf.pfPowerModes));
+       DECLARE("pfPowerTune0",                 offsetof(struct per_proc_info *, pf.pfPowerTune0));
+       DECLARE("pfPowerTune1",                 offsetof(struct per_proc_info *, pf.pfPowerTune1));
+       DECLARE("pmType",                               pmType);
+       DECLARE("pmDPLLVmin",                   pmDPLLVmin);
+       DECLARE("pmDPLLVminb",                  pmDPLLVminb);
+       DECLARE("pmPowerTune",                  pmPowerTune);
+       DECLARE("pmDFS",                                pmDFS);
+       DECLARE("pmDualPLL",                    pmDualPLL);
+       DECLARE("pfPTEG",                               offsetof(struct per_proc_info *, pf.pfPTEG));
+       DECLARE("pfMaxVAddr",                   offsetof(struct per_proc_info *, pf.pfMaxVAddr));
+       DECLARE("pfMaxPAddr",                   offsetof(struct per_proc_info *, pf.pfMaxPAddr));

        DECLARE("pfSize",                               sizeof(procFeatures));
        
        DECLARE("pfSize",                               sizeof(procFeatures));
        

-       DECLARE("thrmmaxTemp",                  offsetof(struct per_proc_info *, thrm.maxTemp));
-       DECLARE("thrmthrottleTemp",     offsetof(struct per_proc_info *, thrm.throttleTemp));
-       DECLARE("thrmlowTemp",                  offsetof(struct per_proc_info *, thrm.lowTemp));
-       DECLARE("thrmhighTemp",                 offsetof(struct per_proc_info *, thrm.highTemp));
-       DECLARE("thrm3val",                     offsetof(struct per_proc_info *, thrm.thrm3val));
-       DECLARE("thrmSize",                     sizeof(thrmControl));
-
-       DECLARE("napStamp",                     offsetof(struct per_proc_info *, napStamp));
-       DECLARE("napTotal",                     offsetof(struct per_proc_info *, napTotal));
+       DECLARE("validSegs",                    offsetof(struct per_proc_info *, validSegs));
+       DECLARE("ppUserPmapVirt",               offsetof(struct per_proc_info *, ppUserPmapVirt));
+       DECLARE("ppUserPmap",                   offsetof(struct per_proc_info *, ppUserPmap));
+       DECLARE("ppMapFlags",                   offsetof(struct per_proc_info *, ppMapFlags));
+       DECLARE("ppInvSeg",                     offsetof(struct per_proc_info *, ppInvSeg));
+       DECLARE("ppCurSeg",                     offsetof(struct per_proc_info *, ppCurSeg));
+       DECLARE("ppSegSteal",                   offsetof(struct per_proc_info *, ppSegSteal));
+
+       DECLARE("VMMareaPhys",                  offsetof(struct per_proc_info *, VMMareaPhys));
+       DECLARE("VMMXAFlgs",                    offsetof(struct per_proc_info *, VMMXAFlgs));
+       DECLARE("FAMintercept",                 offsetof(struct per_proc_info *, FAMintercept));
+
+       DECLARE("ppUMWmp",                              offsetof(struct per_proc_info *, ppUMWmp));
+
+       DECLARE("tempr0",                               offsetof(struct per_proc_info *, tempr0));
+       DECLARE("tempr1",                               offsetof(struct per_proc_info *, tempr1));
+       DECLARE("tempr2",                               offsetof(struct per_proc_info *, tempr2));
+       DECLARE("tempr3",                               offsetof(struct per_proc_info *, tempr3));
+       DECLARE("tempr4",                               offsetof(struct per_proc_info *, tempr4));
+       DECLARE("tempr5",                               offsetof(struct per_proc_info *, tempr5));
+       DECLARE("tempr6",                               offsetof(struct per_proc_info *, tempr6));
+       DECLARE("tempr7",                               offsetof(struct per_proc_info *, tempr7));
+       DECLARE("tempr8",                               offsetof(struct per_proc_info *, tempr8));
+       DECLARE("tempr9",                               offsetof(struct per_proc_info *, tempr9));
+       DECLARE("tempr10",                              offsetof(struct per_proc_info *, tempr10));
+       DECLARE("tempr11",                              offsetof(struct per_proc_info *, tempr11));
+       DECLARE("tempr12",                              offsetof(struct per_proc_info *, tempr12));
+       DECLARE("tempr13",                              offsetof(struct per_proc_info *, tempr13));
+       DECLARE("tempr14",                              offsetof(struct per_proc_info *, tempr14));
+       DECLARE("tempr15",                              offsetof(struct per_proc_info *, tempr15));
+       DECLARE("tempr16",                              offsetof(struct per_proc_info *, tempr16));
+       DECLARE("tempr17",                              offsetof(struct per_proc_info *, tempr17));
+       DECLARE("tempr18",                              offsetof(struct per_proc_info *, tempr18));
+       DECLARE("tempr19",                              offsetof(struct per_proc_info *, tempr19));
+       DECLARE("tempr20",                              offsetof(struct per_proc_info *, tempr20));
+       DECLARE("tempr21",                              offsetof(struct per_proc_info *, tempr21));
+       DECLARE("tempr22",                              offsetof(struct per_proc_info *, tempr22));
+       DECLARE("tempr23",                              offsetof(struct per_proc_info *, tempr23));
+       DECLARE("tempr24",                              offsetof(struct per_proc_info *, tempr24));
+       DECLARE("tempr25",                              offsetof(struct per_proc_info *, tempr25));
+       DECLARE("tempr26",                              offsetof(struct per_proc_info *, tempr26));
+       DECLARE("tempr27",                              offsetof(struct per_proc_info *, tempr27));
+       DECLARE("tempr28",                              offsetof(struct per_proc_info *, tempr28));
+       DECLARE("tempr29",                              offsetof(struct per_proc_info *, tempr29));
+       DECLARE("tempr30",                              offsetof(struct per_proc_info *, tempr30));
+       DECLARE("tempr31",                              offsetof(struct per_proc_info *, tempr31));

 
        DECLARE("emfp0",                                offsetof(struct per_proc_info *, emfp0));
        DECLARE("emfp1",                                offsetof(struct per_proc_info *, emfp1));
 
        DECLARE("emfp0",                                offsetof(struct per_proc_info *, emfp0));
        DECLARE("emfp1",                                offsetof(struct per_proc_info *, emfp1));


@@ -368,12 +364,111 @@ int main(int argc, char *argv[])
        DECLARE("emvr30",                               offsetof(struct per_proc_info *, emvr30));
        DECLARE("emvr31",                               offsetof(struct per_proc_info *, emvr31));
        DECLARE("empadvr",                              offsetof(struct per_proc_info *, empadvr));
        DECLARE("emvr30",                               offsetof(struct per_proc_info *, emvr30));
        DECLARE("emvr31",                               offsetof(struct per_proc_info *, emvr31));
        DECLARE("empadvr",                              offsetof(struct per_proc_info *, empadvr));

+       DECLARE("skipListPrev",                 offsetof(struct per_proc_info *, skipListPrev));

        DECLARE("ppSize",                               sizeof(struct per_proc_info));
        DECLARE("ppSize",                               sizeof(struct per_proc_info));

+       DECLARE("ppe_paddr",                            offsetof(struct per_proc_entry *, ppe_paddr));
+       DECLARE("ppe_vaddr",                            offsetof(struct per_proc_entry *, ppe_vaddr));
+       DECLARE("ppeSize",                              sizeof(struct per_proc_entry));
+       DECLARE("MAX_CPUS",                             MAX_CPUS);

        DECLARE("patcharea",                    offsetof(struct per_proc_info *, patcharea));
 
        DECLARE("patcharea",                    offsetof(struct per_proc_info *, patcharea));
 

-       DECLARE("RESETHANDLER_TYPE",                    offsetof(struct resethandler *, type));
-       DECLARE("RESETHANDLER_CALL",                    offsetof(struct resethandler *, call_paddr));
-       DECLARE("RESETHANDLER_ARG",                     offsetof(struct resethandler *, arg__paddr));
+       DECLARE("hwCounts",                             offsetof(struct per_proc_info *, hwCtr));
+       DECLARE("hwInVains",                    offsetof(struct per_proc_info *, hwCtr.hwInVains));
+       DECLARE("hwResets",                             offsetof(struct per_proc_info *, hwCtr.hwResets));
+       DECLARE("hwMachineChecks",              offsetof(struct per_proc_info *, hwCtr.hwMachineChecks));
+       DECLARE("hwDSIs",                               offsetof(struct per_proc_info *, hwCtr.hwDSIs));
+       DECLARE("hwISIs",                               offsetof(struct per_proc_info *, hwCtr.hwISIs));
+       DECLARE("hwExternals",                  offsetof(struct per_proc_info *, hwCtr.hwExternals));
+       DECLARE("hwAlignments",                 offsetof(struct per_proc_info *, hwCtr.hwAlignments));
+       DECLARE("hwPrograms",                   offsetof(struct per_proc_info *, hwCtr.hwPrograms));
+       DECLARE("hwFloatPointUnavailable",      offsetof(struct per_proc_info *, hwCtr.hwFloatPointUnavailable));
+       DECLARE("hwDecrementers",               offsetof(struct per_proc_info *, hwCtr.hwDecrementers));
+       DECLARE("hwIOErrors",                   offsetof(struct per_proc_info *, hwCtr.hwIOErrors));
+       DECLARE("hwrsvd0",                              offsetof(struct per_proc_info *, hwCtr.hwrsvd0));
+       DECLARE("hwSystemCalls",                offsetof(struct per_proc_info *, hwCtr.hwSystemCalls));
+       DECLARE("hwTraces",                             offsetof(struct per_proc_info *, hwCtr.hwTraces));
+       DECLARE("hwFloatingPointAssists",       offsetof(struct per_proc_info *, hwCtr.hwFloatingPointAssists));
+       DECLARE("hwPerformanceMonitors",        offsetof(struct per_proc_info *, hwCtr.hwPerformanceMonitors));
+       DECLARE("hwAltivecs",                   offsetof(struct per_proc_info *, hwCtr.hwAltivecs));
+       DECLARE("hwrsvd1",                              offsetof(struct per_proc_info *, hwCtr.hwrsvd1));
+       DECLARE("hwrsvd2",                              offsetof(struct per_proc_info *, hwCtr.hwrsvd2));
+       DECLARE("hwrsvd3",                              offsetof(struct per_proc_info *, hwCtr.hwrsvd3));
+       DECLARE("hwInstBreakpoints",    offsetof(struct per_proc_info *, hwCtr.hwInstBreakpoints));
+       DECLARE("hwSystemManagements",  offsetof(struct per_proc_info *, hwCtr.hwSystemManagements));
+       DECLARE("hwAltivecAssists",             offsetof(struct per_proc_info *, hwCtr.hwAltivecAssists));
+       DECLARE("hwThermal",                    offsetof(struct per_proc_info *, hwCtr.hwThermal));
+       DECLARE("hwrsvd5",                              offsetof(struct per_proc_info *, hwCtr.hwrsvd5));
+       DECLARE("hwrsvd6",                              offsetof(struct per_proc_info *, hwCtr.hwrsvd6));
+       DECLARE("hwrsvd7",                              offsetof(struct per_proc_info *, hwCtr.hwrsvd7));
+       DECLARE("hwrsvd8",                              offsetof(struct per_proc_info *, hwCtr.hwrsvd8));
+       DECLARE("hwrsvd9",                              offsetof(struct per_proc_info *, hwCtr.hwrsvd9));
+       DECLARE("hwrsvd10",                             offsetof(struct per_proc_info *, hwCtr.hwrsvd10));
+       DECLARE("hwrsvd11",                             offsetof(struct per_proc_info *, hwCtr.hwrsvd11));
+       DECLARE("hwrsvd12",                             offsetof(struct per_proc_info *, hwCtr.hwrsvd12));
+       DECLARE("hwrsvd13",                             offsetof(struct per_proc_info *, hwCtr.hwrsvd13));
+       DECLARE("hwTrace601",                   offsetof(struct per_proc_info *, hwCtr.hwTrace601));
+       DECLARE("hwSIGPs",                              offsetof(struct per_proc_info *, hwCtr.hwSIGPs));
+       DECLARE("hwPreemptions",                offsetof(struct per_proc_info *, hwCtr.hwPreemptions));
+       DECLARE("hwContextSwitchs",             offsetof(struct per_proc_info *, hwCtr.hwContextSwitchs));
+       DECLARE("hwShutdowns",                  offsetof(struct per_proc_info *, hwCtr.hwShutdowns));
+       DECLARE("hwChokes",                             offsetof(struct per_proc_info *, hwCtr.hwChokes));
+       DECLARE("hwDataSegments",               offsetof(struct per_proc_info *, hwCtr.hwDataSegments));
+       DECLARE("hwInstructionSegments",        offsetof(struct per_proc_info *, hwCtr.hwInstructionSegments));
+       DECLARE("hwSoftPatches",                offsetof(struct per_proc_info *, hwCtr.hwSoftPatches));
+       DECLARE("hwMaintenances",               offsetof(struct per_proc_info *, hwCtr.hwMaintenances));
+       DECLARE("hwInstrumentations",   offsetof(struct per_proc_info *, hwCtr.hwInstrumentations));
+       DECLARE("hwRedrives",                   offsetof(struct per_proc_info *, hwCtr.hwRedrives));
+       DECLARE("hwIgnored",                    offsetof(struct per_proc_info *, hwCtr.hwIgnored));
+       DECLARE("hwhdec",                               offsetof(struct per_proc_info *, hwCtr.hwhdec));
+       DECLARE("hwSteals",                             offsetof(struct per_proc_info *, hwCtr.hwSteals));
+       
+       DECLARE("hwWalkPhys",                   offsetof(struct per_proc_info *, hwCtr.hwWalkPhys));
+       DECLARE("hwWalkFull",                   offsetof(struct per_proc_info *, hwCtr.hwWalkFull));
+       DECLARE("hwWalkMerge",                  offsetof(struct per_proc_info *, hwCtr.hwWalkMerge));
+       DECLARE("hwWalkQuick",                  offsetof(struct per_proc_info *, hwCtr.hwWalkQuick));
+
+       DECLARE("hwMckHang",                    offsetof(struct per_proc_info *, hwCtr.hwMckHang));
+       DECLARE("hwMckSLBPE",                   offsetof(struct per_proc_info *, hwCtr.hwMckSLBPE));
+       DECLARE("hwMckTLBPE",                   offsetof(struct per_proc_info *, hwCtr.hwMckTLBPE));
+       DECLARE("hwMckERCPE",                   offsetof(struct per_proc_info *, hwCtr.hwMckERCPE));
+       DECLARE("hwMckL1DPE",                   offsetof(struct per_proc_info *, hwCtr.hwMckL1DPE));
+       DECLARE("hwMckL1TPE",                   offsetof(struct per_proc_info *, hwCtr.hwMckL1TPE));
+       DECLARE("hwMckUE",                              offsetof(struct per_proc_info *, hwCtr.hwMckUE));
+       DECLARE("hwMckIUE",                             offsetof(struct per_proc_info *, hwCtr.hwMckIUE));
+       DECLARE("hwMckIUEr",                    offsetof(struct per_proc_info *, hwCtr.hwMckIUEr));
+       DECLARE("hwMckDUE",                             offsetof(struct per_proc_info *, hwCtr.hwMckDUE));
+       DECLARE("hwMckDTW",                             offsetof(struct per_proc_info *, hwCtr.hwMckDTW));
+       DECLARE("hwMckUnk",                             offsetof(struct per_proc_info *, hwCtr.hwMckUnk));
+       DECLARE("hwMckExt",                             offsetof(struct per_proc_info *, hwCtr.hwMckExt));
+       DECLARE("hwMckICachePE",                offsetof(struct per_proc_info *, hwCtr.hwMckICachePE));
+       DECLARE("hwMckITagPE",                  offsetof(struct per_proc_info *, hwCtr.hwMckITagPE));
+       DECLARE("hwMckIEratPE",                 offsetof(struct per_proc_info *, hwCtr.hwMckIEratPE));
+       DECLARE("hwMckDEratPE",                 offsetof(struct per_proc_info *, hwCtr.hwMckDEratPE));
+
+       DECLARE("ijsave",                               offsetof(struct per_proc_info *, ijsave));
+
+       DECLARE("napStamp",                     offsetof(struct per_proc_info *, hwCtr.napStamp));
+       DECLARE("napTotal",                     offsetof(struct per_proc_info *, hwCtr.napTotal));
+       DECLARE("PP_PROCESSOR",                 offsetof(struct per_proc_info *, processor[0]));
+       DECLARE("PP_PROCESSOR_SIZE",    sizeof(((struct per_proc_info *)0)->processor));
+       DECLARE("PROCESSOR_SIZE",               sizeof (struct processor));
+
+       DECLARE("patchAddr",                    offsetof(struct patch_entry *, addr));
+       DECLARE("patchData",                    offsetof(struct patch_entry *, data));
+       DECLARE("patchType",                    offsetof(struct patch_entry *, type));
+       DECLARE("patchValue",                   offsetof(struct patch_entry *, value));
+       DECLARE("peSize",                               sizeof(patch_entry_t));
+       DECLARE("PATCH_PROCESSOR",              PATCH_PROCESSOR);
+       DECLARE("PATCH_FEATURE",                PATCH_FEATURE);
+    DECLARE("PATCH_END_OF_TABLE",   PATCH_END_OF_TABLE);
+       DECLARE("PatchExt32",                   PatchExt32);
+       DECLARE("PatchExt32b",                  PatchExt32b);
+       DECLARE("PatchLwsync",                  PatchLwsync);
+       DECLARE("PatchLwsyncb",                 PatchLwsyncb);
+
+       DECLARE("RESETHANDLER_TYPE",    offsetof(struct resethandler *, type));
+       DECLARE("RESETHANDLER_CALL",    offsetof(struct resethandler *, call_paddr));
+       DECLARE("RESETHANDLER_ARG",     offsetof(struct resethandler *, arg__paddr));

 
        /* we want offset from
         * bottom of kernel stack, not offset into structure
 
        /* we want offset from
         * bottom of kernel stack, not offset into structure


@@ -381,50 +476,41 @@ int main(int argc, char *argv[])
 #define IKSBASE (u_int)STACK_IKS(0)
 
        /* values from kern/thread.h */
 #define IKSBASE (u_int)STACK_IKS(0)
 
        /* values from kern/thread.h */

-       DECLARE("THREAD_TOP_ACT",
-               offsetof(struct thread_shuttle *, top_act));
-       DECLARE("THREAD_KERNEL_STACK",
-               offsetof(struct thread_shuttle *, kernel_stack));
-       DECLARE("THREAD_CONTINUATION",
-               offsetof(struct thread_shuttle *, continuation));
-       DECLARE("THREAD_RECOVER",
-               offsetof(struct thread_shuttle *, recover));
-#if    MACH_LDEBUG
-       DECLARE("THREAD_MUTEX_COUNT",
-               offsetof(struct thread_shuttle *, mutex_count));
-#endif /* MACH_LDEBUG */
-       DECLARE("THREAD_PSET", offsetof(struct thread_shuttle *, processor_set));
-       DECLARE("THREAD_LINKS", offsetof(struct thread_shuttle *, links));
-       DECLARE("THREAD_PSTHRN", offsetof(struct thread_shuttle *, pset_threads.next));
-
-       /* values from kern/thread_act.h */
-       DECLARE("ACT_TASK",    offsetof(struct thread_activation *, task));
-       DECLARE("ACT_THREAD",    offsetof(struct thread_activation *, thread));
-       DECLARE("ACT_LOWER",    offsetof(struct thread_activation *, lower));
-       DECLARE("ACT_MACT_PCB",offsetof(struct thread_activation *, mact.pcb));
-       DECLARE("ACT_MACT_FPU",offsetof(struct thread_activation *, mact.FPU_pcb));
-       DECLARE("ACT_MACT_FPUlvl",offsetof(struct thread_activation *, mact.FPU_lvl));
-       DECLARE("ACT_MACT_FPUcpu",offsetof(struct thread_activation *, mact.FPU_cpu));
-       DECLARE("ACT_MACT_VMX",offsetof(struct thread_activation *, mact.VMX_pcb));
-       DECLARE("ACT_MACT_VMXlvl",offsetof(struct thread_activation *, mact.VMX_lvl));
-       DECLARE("ACT_MACT_VMXcpu",offsetof(struct thread_activation *, mact.VMX_cpu));
-       DECLARE("ACT_AST",     offsetof(struct thread_activation *, ast));
-       DECLARE("ACT_VMMAP",   offsetof(struct thread_activation *, map));
-       DECLARE("runningVM",    runningVM);
-       DECLARE("runningVMbit", runningVMbit);
-       DECLARE("ACT_KLOADED",
-               offsetof(struct thread_activation *, kernel_loaded));
-       DECLARE("ACT_KLOADING",
-               offsetof(struct thread_activation *, kernel_loading));
-       DECLARE("ACT_MACH_EXC_PORT",
-               offsetof(struct thread_activation *,
-               exc_actions[EXC_MACH_SYSCALL].port));
-       DECLARE("vmmCEntry",    offsetof(struct thread_activation *, mact.vmmCEntry));
-       DECLARE("vmmControl",   offsetof(struct thread_activation *, mact.vmmControl));
+       DECLARE("THREAD_STATE",         offsetof(thread_t, state));
+       DECLARE("TH_IDLE",                              TH_IDLE);
+       DECLARE("THREAD_KERNEL_STACK",  offsetof(thread_t, kernel_stack));
+       DECLARE("THREAD_RECOVER",               offsetof(thread_t, recover));
+       DECLARE("THREAD_FUNNEL_LOCK",
+                       offsetof(thread_t, funnel_lock));
+       DECLARE("THREAD_FUNNEL_STATE",
+                       offsetof(thread_t, funnel_state));
+       DECLARE("LOCK_FNL_MUTEX",
+                       offsetof(struct funnel_lock *, fnl_mutex));
+
+       DECLARE("ACT_TASK",                             offsetof(thread_t, task));
+       DECLARE("ACT_MACT_PCB",                 offsetof(thread_t, machine.pcb));
+       DECLARE("ACT_MACT_UPCB",                offsetof(thread_t, machine.upcb));
+       DECLARE("ACT_AST",                              offsetof(thread_t, ast));
+       DECLARE("ACT_VMMAP",                    offsetof(thread_t, map));
+       DECLARE("vmmCEntry",                    offsetof(thread_t, machine.vmmCEntry));
+       DECLARE("vmmControl",                   offsetof(thread_t, machine.vmmControl));
+       DECLARE("curctx",                               offsetof(thread_t, machine.curctx));
+       DECLARE("deferctx",                             offsetof(thread_t, machine.deferctx));
+       DECLARE("facctx",                               offsetof(thread_t, machine.facctx));

 #ifdef MACH_BSD
 #ifdef MACH_BSD

-       DECLARE("CTHREAD_SELF", offsetof(struct thread_activation *, mact.cthread_self));
+       DECLARE("CTHREAD_SELF",                 offsetof(thread_t, machine.cthread_self));

 #endif  
 
 #endif  
 

+       DECLARE("FPUsave",                              offsetof(struct facility_context *,FPUsave));
+       DECLARE("FPUlevel",                             offsetof(struct facility_context *,FPUlevel));
+       DECLARE("FPUcpu",                               offsetof(struct facility_context *,FPUcpu));
+       DECLARE("FPUsync",                              offsetof(struct facility_context *,FPUsync));
+       DECLARE("VMXsave",                              offsetof(struct facility_context *,VMXsave));
+       DECLARE("VMXlevel",                             offsetof(struct facility_context *,VMXlevel));
+       DECLARE("VMXcpu",                               offsetof(struct facility_context *,VMXcpu));
+       DECLARE("VMXsync",                              offsetof(struct facility_context *,VMXsync));
+       DECLARE("facAct",                               offsetof(struct facility_context *,facAct));
+

        /* Values from vmachmon.h */
        
        DECLARE("kVmmGetVersion",               kVmmGetVersion);
        /* Values from vmachmon.h */
        
        DECLARE("kVmmGetVersion",               kVmmGetVersion);


@@ -440,8 +526,26 @@ int main(int argc, char *argv[])
        DECLARE("kVmmGetFloatState",    kVmmGetFloatState);
        DECLARE("kVmmGetVectorState",   kVmmGetVectorState);
        DECLARE("kVmmSetTimer",                 kVmmSetTimer);
        DECLARE("kVmmGetFloatState",    kVmmGetFloatState);
        DECLARE("kVmmGetVectorState",   kVmmGetVectorState);
        DECLARE("kVmmSetTimer",                 kVmmSetTimer);

+       DECLARE("kVmmGetTimer",                 kVmmGetTimer);

        DECLARE("kVmmExecuteVM",                kVmmExecuteVM);
        DECLARE("kVmmProtectPage",              kVmmProtectPage);
        DECLARE("kVmmExecuteVM",                kVmmExecuteVM);
        DECLARE("kVmmProtectPage",              kVmmProtectPage);

+       DECLARE("kVmmMapList",                  kVmmMapList);
+       DECLARE("kVmmUnmapList",                kVmmUnmapList);
+       DECLARE("kVmmActivateXA",               kVmmActivateXA);
+       DECLARE("kVmmDeactivateXA",     kVmmDeactivateXA);
+       DECLARE("kVmmGetXA",                    kVmmGetXA);
+       DECLARE("kVmmMapPage64",                kVmmMapPage64);
+       DECLARE("kVmmGetPageMapping64", kVmmGetPageMapping64);
+       DECLARE("kVmmUnmapPage64",              kVmmUnmapPage64);
+       DECLARE("kVmmGetPageDirtyFlag64",       kVmmGetPageDirtyFlag64);
+       DECLARE("kVmmMapExecute64",     kVmmMapExecute64);
+       DECLARE("kVmmProtectExecute64", kVmmProtectExecute64);
+       DECLARE("kVmmMapList64",                kVmmMapList64);
+       DECLARE("kVmmUnmapList64",              kVmmUnmapList64);
+       DECLARE("kvmmExitToHost",               kvmmExitToHost);
+       DECLARE("kvmmResumeGuest",              kvmmResumeGuest);
+       DECLARE("kvmmGetGuestRegister", kvmmGetGuestRegister);
+       DECLARE("kvmmSetGuestRegister", kvmmSetGuestRegister);

 
        DECLARE("kVmmReturnNull",               kVmmReturnNull);
        DECLARE("kVmmStopped",                  kVmmStopped);
 
        DECLARE("kVmmReturnNull",               kVmmReturnNull);
        DECLARE("kVmmStopped",                  kVmmStopped);


@@ -452,6 +556,7 @@ int main(int argc, char *argv[])
        DECLARE("kVmmReturnProgramException",   kVmmReturnProgramException);
        DECLARE("kVmmReturnSystemCall",         kVmmReturnSystemCall);
        DECLARE("kVmmReturnTraceException",     kVmmReturnTraceException);
        DECLARE("kVmmReturnProgramException",   kVmmReturnProgramException);
        DECLARE("kVmmReturnSystemCall",         kVmmReturnSystemCall);
        DECLARE("kVmmReturnTraceException",     kVmmReturnTraceException);

+       DECLARE("kVmmInvalidAdSpace",   kVmmInvalidAdSpace);

 
        DECLARE("kVmmProtXtnd",                 kVmmProtXtnd);
        DECLARE("kVmmProtNARW",                 kVmmProtNARW);
 
        DECLARE("kVmmProtXtnd",                 kVmmProtXtnd);
        DECLARE("kVmmProtNARW",                 kVmmProtNARW);


@@ -460,39 +565,176 @@ int main(int argc, char *argv[])
        DECLARE("kVmmProtRORO",                 kVmmProtRORO);
        
        DECLARE("vmmFlags",                             offsetof(struct vmmCntrlEntry *, vmmFlags));
        DECLARE("kVmmProtRORO",                 kVmmProtRORO);
        
        DECLARE("vmmFlags",                             offsetof(struct vmmCntrlEntry *, vmmFlags));

+       DECLARE("vmmXAFlgs",                    offsetof(struct vmmCntrlEntry *, vmmXAFlgs));
+       DECLARE("vmmPmap",                              offsetof(struct vmmCntrlEntry *, vmmPmap));

        DECLARE("vmmInUseb",                    vmmInUseb);
        DECLARE("vmmInUse",                             vmmInUse);
        DECLARE("vmmInUseb",                    vmmInUseb);
        DECLARE("vmmInUse",                             vmmInUse);

-       DECLARE("vmmPmap",                              offsetof(struct vmmCntrlEntry *, vmmPmap));

        DECLARE("vmmContextKern",               offsetof(struct vmmCntrlEntry *, vmmContextKern));
        DECLARE("vmmContextKern",               offsetof(struct vmmCntrlEntry *, vmmContextKern));

+       DECLARE("vmmContextPhys",               offsetof(struct vmmCntrlEntry *, vmmContextPhys));

        DECLARE("vmmContextUser",               offsetof(struct vmmCntrlEntry *, vmmContextUser));
        DECLARE("vmmContextUser",               offsetof(struct vmmCntrlEntry *, vmmContextUser));

-       DECLARE("vmmFPU_pcb",                   offsetof(struct vmmCntrlEntry *, vmmFPU_pcb));
-       DECLARE("vmmFPU_cpu",                   offsetof(struct vmmCntrlEntry *, vmmFPU_cpu));
-       DECLARE("vmmVMX_pcb",                   offsetof(struct vmmCntrlEntry *, vmmVMX_pcb));
-       DECLARE("vmmVMX_cpu",                   offsetof(struct vmmCntrlEntry *, vmmVMX_cpu));
-       DECLARE("vmmLastMap",                   offsetof(struct vmmCntrlEntry *, vmmLastMap));
+       DECLARE("vmmFacCtx",                    offsetof(struct vmmCntrlEntry *, vmmFacCtx));
+       DECLARE("vmmLastMap",                   offsetof(struct vmmCntrlTable *, vmmLastMap));
+       DECLARE("vmmGFlags",                    offsetof(struct vmmCntrlTable *, vmmGFlags));
+       DECLARE("vmmc",                                 offsetof(struct vmmCntrlTable *, vmmc));
+       DECLARE("vmmAdsp",                              offsetof(struct vmmCntrlTable *, vmmAdsp));
+       DECLARE("vmmLastAdSp",                  vmmLastAdSp);
+       DECLARE("vmmFAMintercept",              offsetof(struct vmmCntrlEntry *, vmmFAMintercept));

        DECLARE("vmmCEntrySize",                sizeof(struct vmmCntrlEntry));
        DECLARE("vmmCEntrySize",                sizeof(struct vmmCntrlEntry));

-       DECLARE("kVmmMaxContextsPerThread",             kVmmMaxContextsPerThread);
+       DECLARE("kVmmMaxContexts",              kVmmMaxContexts);

        
        DECLARE("interface_version",    offsetof(struct vmm_state_page_t *, interface_version));
        DECLARE("thread_index",                 offsetof(struct vmm_state_page_t *, thread_index));
        DECLARE("vmmStat",                              offsetof(struct vmm_state_page_t *, vmmStat));
        DECLARE("vmmCntrl",                             offsetof(struct vmm_state_page_t *, vmmCntrl));
        
        DECLARE("interface_version",    offsetof(struct vmm_state_page_t *, interface_version));
        DECLARE("thread_index",                 offsetof(struct vmm_state_page_t *, thread_index));
        DECLARE("vmmStat",                              offsetof(struct vmm_state_page_t *, vmmStat));
        DECLARE("vmmCntrl",                             offsetof(struct vmm_state_page_t *, vmmCntrl));

+       DECLARE("vmm_proc_state",               offsetof(struct vmm_state_page_t *, vmm_proc_state));
+

        DECLARE("return_code",                  offsetof(struct vmm_state_page_t *, return_code));
        DECLARE("return_code",                  offsetof(struct vmm_state_page_t *, return_code));

+
+       DECLARE("return_params",                offsetof(struct vmm_state_page_t *, vmmRet.vmmrp32.return_params));
+       DECLARE("return_paramsX",               offsetof(struct vmm_state_page_t *, vmmRet.vmmrp64.return_params));
+
+#if 0

        DECLARE("return_params",                offsetof(struct vmm_state_page_t *, return_params));
        DECLARE("vmm_proc_state",               offsetof(struct vmm_state_page_t *, vmm_proc_state));
        DECLARE("return_params",                offsetof(struct vmm_state_page_t *, return_params));
        DECLARE("vmm_proc_state",               offsetof(struct vmm_state_page_t *, vmm_proc_state));

-       DECLARE("return_params",                offsetof(struct vmm_state_page_t *, return_params));
+#endif

        DECLARE("vmmppcVRs",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcVRs));
        DECLARE("vmmppcVSCR",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcVSCR));
        DECLARE("vmmppcFPRs",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcFPRs));
        DECLARE("vmmppcFPSCR",                  offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcFPSCR));
        DECLARE("vmmppcVRs",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcVRs));
        DECLARE("vmmppcVSCR",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcVSCR));
        DECLARE("vmmppcFPRs",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcFPRs));
        DECLARE("vmmppcFPSCR",                  offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcFPSCR));

+
+       DECLARE("vmmppcpc",                             offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcPC));
+       DECLARE("vmmppcmsr",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcMSR));
+       DECLARE("vmmppcr0",                             offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x00));
+       DECLARE("vmmppcr1",                             offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x04));
+       DECLARE("vmmppcr2",                             offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x08));
+       DECLARE("vmmppcr3",                             offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x0C));
+       DECLARE("vmmppcr4",                             offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x10));
+       DECLARE("vmmppcr5",                             offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x14));
+
+       DECLARE("vmmppcr6",                             offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x18));
+       DECLARE("vmmppcr7",                             offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x1C));
+       DECLARE("vmmppcr8",                             offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x20));
+       DECLARE("vmmppcr9",                             offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x24));
+       DECLARE("vmmppcr10",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x28));
+       DECLARE("vmmppcr11",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x2C));
+       DECLARE("vmmppcr12",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x30));
+       DECLARE("vmmppcr13",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x34));
+
+       DECLARE("vmmppcr14",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x38));
+       DECLARE("vmmppcr15",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x3C));
+       DECLARE("vmmppcr16",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x40));
+       DECLARE("vmmppcr17",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x44));
+       DECLARE("vmmppcr18",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x48));
+       DECLARE("vmmppcr19",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x4C));
+       DECLARE("vmmppcr20",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x50));
+       DECLARE("vmmppcr21",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x54));
+
+       DECLARE("vmmppcr22",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x58));
+       DECLARE("vmmppcr23",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x5C));
+       DECLARE("vmmppcr24",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x60));
+       DECLARE("vmmppcr25",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x64));
+       DECLARE("vmmppcr26",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x68));
+       DECLARE("vmmppcr27",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x6C));
+       DECLARE("vmmppcr28",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x70));
+       DECLARE("vmmppcr29",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x74));
+
+       DECLARE("vmmppcr30",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x78));
+       DECLARE("vmmppcr31",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcGPRs+0x7C));
+       DECLARE("vmmppccr",                             offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcCR));
+       DECLARE("vmmppcxer",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcXER));
+       DECLARE("vmmppclr",                             offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcLR));
+       DECLARE("vmmppcctr",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcCTR));
+       DECLARE("vmmppcmq",                             offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcMQ));
+       DECLARE("vmmppcvrsave",                 offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs32.ppcVRSave));       
+
+       DECLARE("vmmppcXpc",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcPC));
+       DECLARE("vmmppcXmsr",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcMSR));
+       DECLARE("vmmppcXr0",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0x00));
+       DECLARE("vmmppcXr1",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0x08));
+       DECLARE("vmmppcXr2",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0x10));
+       DECLARE("vmmppcXr3",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0x18));
+       DECLARE("vmmppcXr4",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0x20));
+       DECLARE("vmmppcXr5",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0x28));
+
+       DECLARE("vmmppcXr6",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0x30));
+       DECLARE("vmmppcXr7",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0x38));
+       DECLARE("vmmppcXr8",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0x40));
+       DECLARE("vmmppcXr9",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0x48));
+       DECLARE("vmmppcXr10",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0x50));
+       DECLARE("vmmppcXr11",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0x58));
+       DECLARE("vmmppcXr12",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0x60));
+       DECLARE("vmmppcXr13",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0x68));
+
+       DECLARE("vmmppcXr14",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0x70));
+       DECLARE("vmmppcXr15",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0x78));
+       DECLARE("vmmppcXr16",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0x80));
+       DECLARE("vmmppcXr17",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0x88));
+       DECLARE("vmmppcXr18",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0x90));
+       DECLARE("vmmppcXr19",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0x98));
+       DECLARE("vmmppcXr20",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0xA0));
+       DECLARE("vmmppcXr21",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0xA8));
+
+       DECLARE("vmmppcXr22",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0xB0));
+       DECLARE("vmmppcXr23",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0xB8));
+       DECLARE("vmmppcXr24",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0xC0));
+       DECLARE("vmmppcXr25",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0xC8));
+       DECLARE("vmmppcXr26",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0xD0));
+       DECLARE("vmmppcXr27",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0xD8));
+       DECLARE("vmmppcXr28",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0xE0));
+       DECLARE("vmmppcXr29",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0xE8));
+
+       DECLARE("vmmppcXr30",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0xF0));
+       DECLARE("vmmppcXr31",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcGPRs+0xF8));
+       DECLARE("vmmppcXcr",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcCR));
+       DECLARE("vmmppcXxer",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcXER));
+       DECLARE("vmmppcXlr",                    offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcLR));
+       DECLARE("vmmppcXctr",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcCTR));
+       DECLARE("vmmppcXvrsave",                offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcRegs.ppcRegs64.ppcVRSave));       
+
+       DECLARE("vmmppcvscr",                   offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcVSCR+0x00));      
+       DECLARE("vmmppcfpscrpad",               offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcFPSCR));
+       DECLARE("vmmppcfpscr",                  offsetof(struct vmm_state_page_t *, vmm_proc_state.ppcFPSCR+4));
+
+       DECLARE("famguestr0",                   offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs32.guest_register));
+       DECLARE("famguestr1",                   offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs32.guest_register+0x4));
+       DECLARE("famguestr2",                   offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs32.guest_register+0x8));
+       DECLARE("famguestr3",                   offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs32.guest_register+0xC));
+       DECLARE("famguestr4",                   offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs32.guest_register+0x10));
+       DECLARE("famguestr5",                   offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs32.guest_register+0x14));
+       DECLARE("famguestr6",                   offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs32.guest_register+0x18));
+       DECLARE("famguestr7",                   offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs32.guest_register+0x1C));
+       DECLARE("famguestpc",                   offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs32.guest_pc));
+       DECLARE("famguestmsr",                  offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs32.guest_msr));
+       DECLARE("famdispcode",                  offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs32.fastassist_dispatch_code));
+       DECLARE("famrefcon",                    offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs32.fastassist_refcon));
+       DECLARE("famparam",                             offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs32.fastassist_parameter));
+       DECLARE("famhandler",                   offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs32.fastassist_dispatch));
+       DECLARE("famintercepts",                offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs32.fastassist_intercepts));
+
+       DECLARE("famguestXr0",                  offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs64.guest_register));
+       DECLARE("famguestXr1",                  offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs64.guest_register+0x8));
+       DECLARE("famguestXr2",                  offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs64.guest_register+0x10));
+       DECLARE("famguestXr3",                  offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs64.guest_register+0x18));
+       DECLARE("famguestXr4",                  offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs64.guest_register+0x20));
+       DECLARE("famguestXr5",                  offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs64.guest_register+0x28));
+       DECLARE("famguestXr6",                  offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs64.guest_register+0x30));
+       DECLARE("famguestXr7",                  offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs64.guest_register+0x38));
+       DECLARE("famguestXpc",                  offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs64.guest_pc));
+       DECLARE("famguestXmsr",                 offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs64.guest_msr));
+       DECLARE("famdispcodeX",                 offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs64.fastassist_dispatch_code));
+       DECLARE("famrefconX",                   offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs64.fastassist_refcon));
+       DECLARE("famparamX",                            offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs64.fastassist_parameter));
+       DECLARE("famhandlerX",                  offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs64.fastassist_dispatch));
+       DECLARE("faminterceptsX",               offsetof(struct vmm_state_page_t *, vmm_fastassist_state.vmmfs64.fastassist_intercepts));
+

        DECLARE("vmmFloatCngd",                 vmmFloatCngd);
        DECLARE("vmmFloatCngdb",                vmmFloatCngdb);
        DECLARE("vmmVectCngd",                  vmmVectCngd);
        DECLARE("vmmVectCngdb",                 vmmVectCngdb);
        DECLARE("vmmTimerPop",                  vmmTimerPop);
        DECLARE("vmmTimerPopb",                 vmmTimerPopb);
        DECLARE("vmmFloatCngd",                 vmmFloatCngd);
        DECLARE("vmmFloatCngdb",                vmmFloatCngdb);
        DECLARE("vmmVectCngd",                  vmmVectCngd);
        DECLARE("vmmVectCngdb",                 vmmVectCngdb);
        DECLARE("vmmTimerPop",                  vmmTimerPop);
        DECLARE("vmmTimerPopb",                 vmmTimerPopb);

-       DECLARE("vmmMapDone",                   vmmMapDone);
-       DECLARE("vmmMapDoneb",                  vmmMapDoneb);
+       DECLARE("vmmFAMmode",                   vmmFAMmode);
+       DECLARE("vmmFAMmodeb",                  vmmFAMmodeb);

        DECLARE("vmmSpfSave",                   vmmSpfSave);
        DECLARE("vmmSpfSaveb",                  vmmSpfSaveb);
        DECLARE("vmmFloatLoad",                 vmmFloatLoad);
        DECLARE("vmmSpfSave",                   vmmSpfSave);
        DECLARE("vmmSpfSaveb",                  vmmSpfSaveb);
        DECLARE("vmmFloatLoad",                 vmmFloatLoad);


@@ -509,137 +751,184 @@ int main(int argc, char *argv[])
        DECLARE("vmmXStopb",                    vmmXStopb);
        DECLARE("vmmKey",                               vmmKey);
        DECLARE("vmmKeyb",                              vmmKeyb);
        DECLARE("vmmXStopb",                    vmmXStopb);
        DECLARE("vmmKey",                               vmmKey);
        DECLARE("vmmKeyb",                              vmmKeyb);

+       DECLARE("vmmFamSet",                    vmmFamSet);
+       DECLARE("vmmFamSetb",                   vmmFamSetb);
+       DECLARE("vmmFamEna",                    vmmFamEna);
+       DECLARE("vmmFamEnab",                   vmmFamEnab);
+       DECLARE("vmm64Bit",                             vmm64Bit);

 
        /* values from kern/task.h */
 
        /* values from kern/task.h */

-       DECLARE("TASK_MACH_EXC_PORT",
-               offsetof(struct task *, exc_actions[EXC_MACH_SYSCALL].port));
-       DECLARE("TASK_SYSCALLS_MACH",
-               offsetof(struct task *, syscalls_mach));
+       DECLARE("TASK_SYSCALLS_MACH",   offsetof(struct task *, syscalls_mach));
+       DECLARE("TASK_SYSCALLS_UNIX",   offsetof(struct task *, syscalls_unix));
+
+       DECLARE("TASK_VTIMERS",                 offsetof(struct task *, vtimers));

 
        /* values from vm/vm_map.h */
 
        /* values from vm/vm_map.h */

-       DECLARE("VMMAP_PMAP",   offsetof(struct vm_map *, pmap));
+       DECLARE("VMMAP_PMAP",   offsetof(struct _vm_map *, pmap));

 
        /* values from machine/pmap.h */
 
        /* values from machine/pmap.h */

-       DECLARE("PMAP_SPACE",   offsetof(struct pmap *, space));
-       DECLARE("PMAP_BMAPS",   offsetof(struct pmap *, bmaps));
-       DECLARE("PMAP_PMAPVR",  offsetof(struct pmap *, pmapvr));
-       DECLARE("PMAP_VFLAGS",  offsetof(struct pmap *, vflags));
-       DECLARE("PMAP_USAGE",   offsetof(struct pmap *, pmapUsage));
-       DECLARE("PMAP_SEGS",    offsetof(struct pmap *, pmapSegs));
-       DECLARE("PMAP_SIZE",    pmapSize);
+       DECLARE("pmapSpace",                    offsetof(struct pmap *, space));
+       DECLARE("spaceNum",                             offsetof(struct pmap *, spaceNum));
+       DECLARE("pmapSXlk",                             offsetof(struct pmap *, pmapSXlk));
+       DECLARE("pmapCCtl",                             offsetof(struct pmap *, pmapCCtl));
+    DECLARE("pmapCCtlVal",                     pmapCCtlVal);
+    DECLARE("pmapCCtlLck",                     pmapCCtlLck);
+    DECLARE("pmapCCtlLckb",                    pmapCCtlLckb);
+    DECLARE("pmapCCtlGen",                     pmapCCtlGen);
+    DECLARE("pmapSegCacheCnt",         pmapSegCacheCnt);
+    DECLARE("pmapSegCacheUse",         pmapSegCacheUse);
+       DECLARE("pmapvr",                               offsetof(struct pmap *, pmapvr));
+       DECLARE("pmapFlags",                    offsetof(struct pmap *, pmapFlags));
+    DECLARE("pmapKeys",                                pmapKeys);
+    DECLARE("pmapKeyDef",                      pmapKeyDef);
+       DECLARE("pmapSCSubTag",                 offsetof(struct pmap *, pmapSCSubTag));
+       DECLARE("pmapVmmExt",                   offsetof(struct pmap *, pmapVmmExt));
+       DECLARE("pmapVmmExtPhys",               offsetof(struct pmap *, pmapVmmExtPhys));
+       DECLARE("pmapVMhost",                   pmapVMhost);
+       DECLARE("pmapVMgsaa",                   pmapVMgsaa);
+       DECLARE("pmapSegCache",                 offsetof(struct pmap *, pmapSegCache));
+       DECLARE("pmapCurLists",                 offsetof(struct pmap *, pmapCurLists));
+       DECLARE("pmapRandNum",                  offsetof(struct pmap *, pmapRandNum));
+       DECLARE("pmapSkipLists",                offsetof(struct pmap *, pmapSkipLists));
+       DECLARE("pmapSearchVisits",             offsetof(struct pmap *, pmapSearchVisits));
+       DECLARE("pmapSearchCnt",                offsetof(struct pmap *, pmapSearchCnt));
+       DECLARE("pmapSize",                             pmapSize);
+    DECLARE("kSkipListFanoutShift",    kSkipListFanoutShift);
+    DECLARE("kSkipListMaxLists",       kSkipListMaxLists);
+    DECLARE("invalSpace",                      invalSpace);
+
+       DECLARE("sgcESID",                              offsetof(struct sgc *, sgcESID));
+       DECLARE("sgcESmsk",                             sgcESmsk);
+       DECLARE("sgcVSID",                              offsetof(struct sgc *, sgcVSID));
+       DECLARE("sgcVSmsk",                             sgcVSmsk);
+       DECLARE("sgcVSKeys",                    sgcVSKeys);
+       DECLARE("sgcVSKeyUsr",                  sgcVSKeyUsr);
+       DECLARE("sgcVSNoEx",                    sgcVSNoEx);
+       DECLARE("pmapPAddr",                    offsetof(struct pmapTransTab *, pmapPAddr));
+       DECLARE("pmapVAddr",                    offsetof(struct pmapTransTab *, pmapVAddr));
+       DECLARE("pmapTransSize",                sizeof(pmapTransTab));
+       DECLARE("pmapResidentCnt",              offsetof(struct pmap *, stats.resident_count));
+       DECLARE("pmapResidentMax",              offsetof(struct pmap *, stats.resident_max));
+
+       DECLARE("maxAdrSp",                             maxAdrSp);
+       DECLARE("maxAdrSpb",                    maxAdrSpb);

        
        

+       DECLARE("cppvPsnkb",                    cppvPsnkb);
+       DECLARE("cppvPsrcb",                    cppvPsrcb);
+       DECLARE("cppvFsnkb",                    cppvFsnkb);
+       DECLARE("cppvFsrcb",                    cppvFsrcb);
+       DECLARE("cppvNoModSnkb",                cppvNoModSnkb);
+       DECLARE("cppvNoRefSrcb",                cppvNoRefSrcb);
+       DECLARE("cppvKmapb",                    cppvKmapb);
+       
+       DECLARE("vmxSalt",                              offsetof(struct pmap_vmm_ext *, vmxSalt));
+       DECLARE("vmxHostPmapPhys",              offsetof(struct pmap_vmm_ext *, vmxHostPmapPhys));
+       DECLARE("vmxHostPmap",                  offsetof(struct pmap_vmm_ext *, vmxHostPmap));
+       DECLARE("vmxHashPgIdx",                 offsetof(struct pmap_vmm_ext *, vmxHashPgIdx));
+       DECLARE("vmxHashPgList",                offsetof(struct pmap_vmm_ext *, vmxHashPgList));
+       DECLARE("vmxStats",                             offsetof(struct pmap_vmm_ext *, vmxStats));
+       DECLARE("vmxSize",                              sizeof(struct pmap_vmm_ext));
+       DECLARE("VMX_HPIDX_OFFSET",             VMX_HPIDX_OFFSET);
+       DECLARE("VMX_HPLIST_OFFSET",    VMX_HPLIST_OFFSET);
+       DECLARE("VMX_ACTMAP_OFFSET",    VMX_ACTMAP_OFFSET);
+       DECLARE("vxsGpf",                               offsetof(struct pmap_vmm_ext *, vmxStats.vxsGpf));
+       DECLARE("vxsGpfMiss",                   offsetof(struct pmap_vmm_ext *, vmxStats.vxsGpfMiss));
+       DECLARE("vxsGrm",                               offsetof(struct pmap_vmm_ext *, vmxStats.vxsGrm));
+       DECLARE("vxsGrmMiss",                   offsetof(struct pmap_vmm_ext *, vmxStats.vxsGrmMiss));
+       DECLARE("vxsGrmActive",                 offsetof(struct pmap_vmm_ext *, vmxStats.vxsGrmActive));
+       DECLARE("vxsGra",                               offsetof(struct pmap_vmm_ext *, vmxStats.vxsGra));
+       DECLARE("vxsGraHits",                   offsetof(struct pmap_vmm_ext *, vmxStats.vxsGraHits));
+       DECLARE("vxsGraActive",                 offsetof(struct pmap_vmm_ext *, vmxStats.vxsGraActive));
+       DECLARE("vxsGrl",                               offsetof(struct pmap_vmm_ext *, vmxStats.vxsGrl));
+       DECLARE("vxsGrlActive",                 offsetof(struct pmap_vmm_ext *, vmxStats.vxsGrlActive));
+       DECLARE("vxsGrs",                               offsetof(struct pmap_vmm_ext *, vmxStats.vxsGrs));
+       DECLARE("vxsGrsHitAct",                 offsetof(struct pmap_vmm_ext *, vmxStats.vxsGrsHitAct));
+       DECLARE("vxsGrsHitSusp",                offsetof(struct pmap_vmm_ext *, vmxStats.vxsGrsHitSusp));
+       DECLARE("vxsGrsMissGV",                 offsetof(struct pmap_vmm_ext *, vmxStats.vxsGrsMissGV));
+       DECLARE("vxsGrsHitPE",                  offsetof(struct pmap_vmm_ext *, vmxStats.vxsGrsHitPE));
+       DECLARE("vxsGrsMissPE",                 offsetof(struct pmap_vmm_ext *, vmxStats.vxsGrsMissPE));
+       DECLARE("vxsGad",                               offsetof(struct pmap_vmm_ext *, vmxStats.vxsGad));
+       DECLARE("vxsGadHit",                    offsetof(struct pmap_vmm_ext *, vmxStats.vxsGadHit));
+       DECLARE("vxsGadFree",                   offsetof(struct pmap_vmm_ext *, vmxStats.vxsGadFree));
+       DECLARE("vxsGadDormant",                offsetof(struct pmap_vmm_ext *, vmxStats.vxsGadDormant));
+       DECLARE("vxsGadSteal",                  offsetof(struct pmap_vmm_ext *, vmxStats.vxsGadSteal));
+       DECLARE("vxsGsu",                               offsetof(struct pmap_vmm_ext *, vmxStats.vxsGsu));
+       DECLARE("vxsGsuHit",                    offsetof(struct pmap_vmm_ext *, vmxStats.vxsGsuHit));
+       DECLARE("vxsGsuMiss",                   offsetof(struct pmap_vmm_ext *, vmxStats.vxsGsuMiss));
+       DECLARE("vxsGtd",                               offsetof(struct pmap_vmm_ext *, vmxStats.vxsGtd));
+       DECLARE("vxsGtdHit",                    offsetof(struct pmap_vmm_ext *, vmxStats.vxsGtdHit));
+       DECLARE("vxsGtdMiss",                   offsetof(struct pmap_vmm_ext *, vmxStats.vxsGtdMiss));
+
+       /* values from kern/timer.h */
+       DECLARE("TIMER_LOW",            offsetof(struct timer *, low_bits));
+       DECLARE("TIMER_HIGH",           offsetof(struct timer *, high_bits));
+       DECLARE("TIMER_HIGHCHK",        offsetof(struct timer *, high_bits_check));
+       DECLARE("TIMER_TSTAMP",         offsetof(struct timer *, tstamp));
+
+       DECLARE("THREAD_TIMER",         offsetof(struct processor *, processor_data.thread_timer));
+       DECLARE("KERNEL_TIMER",         offsetof(struct processor *, processor_data.kernel_timer));
+       DECLARE("SYSTEM_TIMER",         offsetof(struct thread *, system_timer));
+       DECLARE("USER_TIMER",           offsetof(struct thread *, user_timer));
+       DECLARE("SYSTEM_STATE",         offsetof(struct processor *, processor_data.system_state));
+       DECLARE("USER_STATE",           offsetof(struct processor *, processor_data.user_state));
+       DECLARE("CURRENT_STATE",        offsetof(struct processor *, processor_data.current_state));

 
        /* Constants from pmap.h */
        DECLARE("PPC_SID_KERNEL", PPC_SID_KERNEL);
 
        /* values for accessing mach_trap table */
 
        /* Constants from pmap.h */
        DECLARE("PPC_SID_KERNEL", PPC_SID_KERNEL);
 
        /* values for accessing mach_trap table */

-       DECLARE("MACH_TRAP_OFFSET_POW2",        4);
-
+       DECLARE("MACH_TRAP_ARG_MUNGE32",
+               offsetof(mach_trap_t *, mach_trap_arg_munge32));
+       DECLARE("MACH_TRAP_ARG_MUNGE64",
+               offsetof(mach_trap_t *, mach_trap_arg_munge64));

        DECLARE("MACH_TRAP_ARGC",
                offsetof(mach_trap_t *, mach_trap_arg_count));
        DECLARE("MACH_TRAP_FUNCTION",
                offsetof(mach_trap_t *, mach_trap_function));
 
        DECLARE("MACH_TRAP_ARGC",
                offsetof(mach_trap_t *, mach_trap_arg_count));
        DECLARE("MACH_TRAP_FUNCTION",
                offsetof(mach_trap_t *, mach_trap_function));
 

-       DECLARE("HOST_SELF", offsetof(host_t, host_self));
-       
-       DECLARE("PPCcallmax", sizeof(PPCcalls));
+       DECLARE("MACH_TRAP_TABLE_COUNT", MACH_TRAP_TABLE_COUNT);

 
 

-       /* values from cpu_data.h */
-       DECLARE("CPU_ACTIVE_THREAD", offsetof(cpu_data_t *, active_thread));
-       DECLARE("CPU_PREEMPTION_LEVEL", offsetof(cpu_data_t *, preemption_level));
-       DECLARE("CPU_SIMPLE_LOCK_COUNT",
-               offsetof(cpu_data_t *, simple_lock_count));
-       DECLARE("CPU_INTERRUPT_LEVEL",offsetof(cpu_data_t *, interrupt_level));
+       DECLARE("PPCcallmax", sizeof(PPCcalls));

 
        /* Misc values used by assembler */
        DECLARE("AST_ALL", AST_ALL);
        DECLARE("AST_URGENT", AST_URGENT);
 
        /* Misc values used by assembler */
        DECLARE("AST_ALL", AST_ALL);
        DECLARE("AST_URGENT", AST_URGENT);

+       DECLARE("AST_BSD", AST_BSD);

 
 

-       /* Simple Lock structure */
-       DECLARE("SLOCK_ILK",    offsetof(simple_lock_t, interlock));
-#if    MACH_LDEBUG
-       DECLARE("SLOCK_TYPE",   offsetof(simple_lock_t, lock_type));
-       DECLARE("SLOCK_PC",     offsetof(simple_lock_t, debug.lock_pc));
-       DECLARE("SLOCK_THREAD", offsetof(simple_lock_t, debug.lock_thread));
-       DECLARE("SLOCK_DURATIONH",offsetof(simple_lock_t, debug.duration[0]));
-       DECLARE("SLOCK_DURATIONL",offsetof(simple_lock_t, debug.duration[1]));
-       DECLARE("USLOCK_TAG",   USLOCK_TAG);
-#endif /* MACH_LDEBUG */
+       /* Spin Lock structure */
+       DECLARE("SLOCK_ILK",    offsetof(lck_spin_t *, interlock));

 
        /* Mutex structure */
 
        /* Mutex structure */

-       DECLARE("LOCK_DATA",    offsetof(mutex_t *, interlock));
-       DECLARE("MUTEX_WAITERS",offsetof(mutex_t *, waiters));
-#if    MACH_LDEBUG
-       DECLARE("MUTEX_TYPE",   offsetof(mutex_t *, type));
-       DECLARE("MUTEX_PC",     offsetof(mutex_t *, pc));
-       DECLARE("MUTEX_THREAD", offsetof(mutex_t *, thread));
+       DECLARE("MUTEX_DATA",   offsetof(lck_mtx_t *, lck_mtx_data));
+       DECLARE("MUTEX_WAITERS",offsetof(lck_mtx_t *, lck_mtx_waiters));
+       DECLARE("MUTEX_PROMOTED_PRI",offsetof(lck_mtx_t *, lck_mtx_pri));
+       DECLARE("MUTEX_TYPE",   offsetof(lck_mtx_ext_t *, lck_mtx_deb.type));
+       DECLARE("MUTEX_STACK",  offsetof(lck_mtx_ext_t *, lck_mtx_deb.stack));
+       DECLARE("MUTEX_FRAMES", LCK_FRAMES_MAX);
+       DECLARE("MUTEX_THREAD", offsetof(lck_mtx_ext_t *, lck_mtx_deb.thread));
+       DECLARE("MUTEX_ATTR",   offsetof(lck_mtx_ext_t *, lck_mtx_attr));
+       DECLARE("MUTEX_ATTR_DEBUG", LCK_MTX_ATTR_DEBUG);
+       DECLARE("MUTEX_ATTR_DEBUGb", LCK_MTX_ATTR_DEBUGb);
+       DECLARE("MUTEX_ATTR_STAT", LCK_MTX_ATTR_STAT);
+       DECLARE("MUTEX_ATTR_STATb", LCK_MTX_ATTR_STATb);
+       DECLARE("MUTEX_GRP",    offsetof(lck_mtx_ext_t *, lck_mtx_grp));

        DECLARE("MUTEX_TAG",    MUTEX_TAG);
        DECLARE("MUTEX_TAG",    MUTEX_TAG);

-#endif /* MACH_LDEBUG */
+       DECLARE("MUTEX_IND",    LCK_MTX_TAG_INDIRECT);
+       DECLARE("MUTEX_ITAG",offsetof(lck_mtx_t *, lck_mtx_tag));
+       DECLARE("MUTEX_PTR",offsetof(lck_mtx_t *, lck_mtx_ptr));
+       DECLARE("MUTEX_ASSERT_OWNED",   LCK_MTX_ASSERT_OWNED);
+       DECLARE("MUTEX_ASSERT_NOTOWNED",LCK_MTX_ASSERT_NOTOWNED);
+       DECLARE("GRP_MTX_STAT_UTIL",    offsetof(lck_grp_t *, lck_grp_stat.lck_grp_mtx_stat.lck_grp_mtx_util_cnt));
+       DECLARE("GRP_MTX_STAT_MISS",    offsetof(lck_grp_t *, lck_grp_stat.lck_grp_mtx_stat.lck_grp_mtx_miss_cnt));
+       DECLARE("GRP_MTX_STAT_WAIT",    offsetof(lck_grp_t *, lck_grp_stat.lck_grp_mtx_stat.lck_grp_mtx_wait_cnt));
+
+       /* RW lock structure */
+       DECLARE("RW_IND",       LCK_RW_TAG_INDIRECT);
+       DECLARE("RW_PTR",       offsetof(lck_rw_t *, lck_rw_ptr));
+       DECLARE("RW_SHARED",    LCK_RW_TYPE_SHARED);
+       DECLARE("RW_EXCL",      LCK_RW_TYPE_EXCLUSIVE);
+       DECLARE("RW_EVENT",     (((sizeof(lck_rw_t)-1))/sizeof(unsigned int))*sizeof(unsigned int));

 
 

-#if    NCPUS > 1
-       /* values from mp/PlugIn.h */
-       
-       DECLARE("MPSversionID", offsetof(struct MPPlugInSpec *, versionID));
-       DECLARE("MPSareaAddr",  offsetof(struct MPPlugInSpec *, areaAddr));
-       DECLARE("MPSareaSize",  offsetof(struct MPPlugInSpec *, areaSize));
-       DECLARE("MPSoffsetTableAddr", offsetof(struct MPPlugInSpec *, offsetTableAddr));
-       DECLARE("MPSbaseAddr",  offsetof(struct MPPlugInSpec *, baseAddr));
-       DECLARE("MPSdataArea",  offsetof(struct MPPlugInSpec *, dataArea));
-       DECLARE("MPSCPUArea",   offsetof(struct MPPlugInSpec *, CPUArea));
-       DECLARE("MPSSIGPhandler",       offsetof(struct MPPlugInSpec *, SIGPhandler));
-
-       DECLARE("CSAstate",     offsetof(struct CPUStatusArea *, state));
-       DECLARE("CSAregsAreValid", offsetof(struct CPUStatusArea *,
-                                           regsAreValid));
-       DECLARE("CSAgpr",       offsetof(struct CPUStatusArea *, gpr));
-       DECLARE("CSAfpr",       offsetof(struct CPUStatusArea *, fpr));
-       DECLARE("CSAcr",        offsetof(struct CPUStatusArea *, cr));
-       DECLARE("CSAfpscr",     offsetof(struct CPUStatusArea *, fpscr));
-       DECLARE("CSAxer",       offsetof(struct CPUStatusArea *, xer));
-       DECLARE("CSAlr",        offsetof(struct CPUStatusArea *, lr));
-       DECLARE("CSActr",       offsetof(struct CPUStatusArea *, ctr));
-       DECLARE("CSAtbu",       offsetof(struct CPUStatusArea *, tbu));
-       DECLARE("CSAtbl",       offsetof(struct CPUStatusArea *, tbl));
-       DECLARE("CSApvr",       offsetof(struct CPUStatusArea *, pvr));
-       DECLARE("CSAibat",      offsetof(struct CPUStatusArea *, ibat));
-       DECLARE("CSAdbat",      offsetof(struct CPUStatusArea *, dbat));
-       DECLARE("CSAsdr1",      offsetof(struct CPUStatusArea *, sdr1));
-       DECLARE("CSAsr",        offsetof(struct CPUStatusArea *, sr));
-       DECLARE("CSAdar",       offsetof(struct CPUStatusArea *, dar));
-       DECLARE("CSAdsisr",     offsetof(struct CPUStatusArea *, dsisr));
-       DECLARE("CSAsprg",      offsetof(struct CPUStatusArea *, sprg));
-       DECLARE("CSAsrr0",      offsetof(struct CPUStatusArea *, srr0));
-       DECLARE("CSAsrr1",      offsetof(struct CPUStatusArea *, srr1));
-       DECLARE("CSAdec",       offsetof(struct CPUStatusArea *, dec));
-       DECLARE("CSAdabr",      offsetof(struct CPUStatusArea *, dabr));
-       DECLARE("CSAiabr",      offsetof(struct CPUStatusArea *, iabr));
-       DECLARE("CSAear",       offsetof(struct CPUStatusArea *, ear));
-       DECLARE("CSAhid",       offsetof(struct CPUStatusArea *, hid));
-       DECLARE("CSAmmcr",      offsetof(struct CPUStatusArea *, mmcr));
-       DECLARE("CSApmc",       offsetof(struct CPUStatusArea *, pmc));
-       DECLARE("CSApir",       offsetof(struct CPUStatusArea *, pir));
-       DECLARE("CSAsda",       offsetof(struct CPUStatusArea *, sda));
-       DECLARE("CSAsia",       offsetof(struct CPUStatusArea *, sia));
-       DECLARE("CSAmq",        offsetof(struct CPUStatusArea *, mq));
-       DECLARE("CSAmsr",       offsetof(struct CPUStatusArea *, msr));
-       DECLARE("CSApc",        offsetof(struct CPUStatusArea *, pc));
-       DECLARE("CSAsysregs",   offsetof(struct CPUStatusArea *, sysregs));
-       DECLARE("CSAsize",      sizeof(struct CPUStatusArea));
-
-
-       DECLARE("MPPICStat",    offsetof(struct MPPInterface *, MPPICStat));
-       DECLARE("MPPICParm0",   offsetof(struct MPPInterface *, MPPICParm0));
-       DECLARE("MPPICParm1",   offsetof(struct MPPInterface *, MPPICParm1));
-       DECLARE("MPPICParm2",   offsetof(struct MPPInterface *, MPPICParm2));
-       DECLARE("MPPICspare0",  offsetof(struct MPPInterface *, MPPICspare0));
-       DECLARE("MPPICspare1",  offsetof(struct MPPInterface *, MPPICspare1));
-       DECLARE("MPPICParm0BU", offsetof(struct MPPInterface *, MPPICParm0BU));
-       DECLARE("MPPICPriv",    offsetof(struct MPPInterface *, MPPICPriv));
-
-
-
-#endif /* NCPUS > 1 */
-                                                

        /* values from low_trace.h */
        DECLARE("LTR_cpu",      offsetof(struct LowTraceRecord *, LTR_cpu));
        DECLARE("LTR_excpt",    offsetof(struct LowTraceRecord *, LTR_excpt));
        /* values from low_trace.h */
        DECLARE("LTR_cpu",      offsetof(struct LowTraceRecord *, LTR_cpu));
        DECLARE("LTR_excpt",    offsetof(struct LowTraceRecord *, LTR_excpt));


@@ -649,6 +938,8 @@ int main(int argc, char *argv[])
        DECLARE("LTR_srr0",     offsetof(struct LowTraceRecord *, LTR_srr0));
        DECLARE("LTR_srr1",     offsetof(struct LowTraceRecord *, LTR_srr1));
        DECLARE("LTR_dar",      offsetof(struct LowTraceRecord *, LTR_dar));
        DECLARE("LTR_srr0",     offsetof(struct LowTraceRecord *, LTR_srr0));
        DECLARE("LTR_srr1",     offsetof(struct LowTraceRecord *, LTR_srr1));
        DECLARE("LTR_dar",      offsetof(struct LowTraceRecord *, LTR_dar));

+       DECLARE("LTR_dsisr",    offsetof(struct LowTraceRecord *, LTR_dsisr));
+       DECLARE("LTR_rsvd0",    offsetof(struct LowTraceRecord *, LTR_rsvd0));

        DECLARE("LTR_save",     offsetof(struct LowTraceRecord *, LTR_save));
        DECLARE("LTR_lr",       offsetof(struct LowTraceRecord *, LTR_lr));
        DECLARE("LTR_ctr",      offsetof(struct LowTraceRecord *, LTR_ctr));
        DECLARE("LTR_save",     offsetof(struct LowTraceRecord *, LTR_save));
        DECLARE("LTR_lr",       offsetof(struct LowTraceRecord *, LTR_lr));
        DECLARE("LTR_ctr",      offsetof(struct LowTraceRecord *, LTR_ctr));


@@ -658,6 +949,7 @@ int main(int argc, char *argv[])
        DECLARE("LTR_r3",       offsetof(struct LowTraceRecord *, LTR_r3));
        DECLARE("LTR_r4",       offsetof(struct LowTraceRecord *, LTR_r4));
        DECLARE("LTR_r5",       offsetof(struct LowTraceRecord *, LTR_r5));
        DECLARE("LTR_r3",       offsetof(struct LowTraceRecord *, LTR_r3));
        DECLARE("LTR_r4",       offsetof(struct LowTraceRecord *, LTR_r4));
        DECLARE("LTR_r5",       offsetof(struct LowTraceRecord *, LTR_r5));

+       DECLARE("LTR_r6",       offsetof(struct LowTraceRecord *, LTR_r6));

        DECLARE("LTR_size",     sizeof(struct LowTraceRecord));
 
 /*     Values from pexpert.h */
        DECLARE("LTR_size",     sizeof(struct LowTraceRecord));
 
 /*     Values from pexpert.h */


@@ -665,49 +957,178 @@ int main(int argc, char *argv[])
        DECLARE("PECFIbusrate", offsetof(struct clock_frequency_info_t *, bus_clock_rate_hz));
 
 /*     Values from pmap_internals.h and mappings.h */
        DECLARE("PECFIbusrate", offsetof(struct clock_frequency_info_t *, bus_clock_rate_hz));
 
 /*     Values from pmap_internals.h and mappings.h */

-       DECLARE("mmnext",               offsetof(struct mapping *, next));
-       DECLARE("mmhashnext",   offsetof(struct mapping *, hashnext));
-       DECLARE("mmPTEhash",    offsetof(struct mapping *, PTEhash));
-       DECLARE("mmPTEent",             offsetof(struct mapping *, PTEent));
-       DECLARE("mmPTEv",               offsetof(struct mapping *, PTEv));
-       DECLARE("mmPTEr",               offsetof(struct mapping *, PTEr));
-       DECLARE("mmphysent",    offsetof(struct mapping *, physent));
-       DECLARE("mmpmap",               offsetof(struct mapping *, pmap));
-       
-       DECLARE("bmnext",               offsetof(struct blokmap *, next));
-       DECLARE("bmstart",              offsetof(struct blokmap *, start));
-       DECLARE("bmend",                offsetof(struct blokmap *, end));
-       DECLARE("bmPTEr",               offsetof(struct blokmap *, PTEr));
-       DECLARE("bmspace",              offsetof(struct blokmap *, space));
-       DECLARE("blkFlags",             offsetof(struct blokmap *, blkFlags));
-       DECLARE("blkPerm",              blkPerm);
-       DECLARE("blkPermbit",   blkPermbit);
-       
+
+       DECLARE("mpFlags",              offsetof(struct mapping *, mpFlags));
+       DECLARE("mpBusy",               mpBusy);
+       DECLARE("mpPrevious",   mpPrevious);
+       DECLARE("mpNext",               mpNext);
+       DECLARE("mpPIndex",             mpPIndex);
+       DECLARE("mpType",               mpType);
+       DECLARE("mpNormal",             mpNormal);
+       DECLARE("mpBlock",              mpBlock);
+       DECLARE("mpMinSpecial", mpMinSpecial);
+       DECLARE("mpNest",               mpNest);
+       DECLARE("mpLinkage",    mpLinkage);
+       DECLARE("mpACID",               mpACID);
+       DECLARE("mpGuest",              mpGuest);
+       DECLARE("mpFIP",                mpFIP);
+       DECLARE("mpFIPb",               mpFIPb);
+       DECLARE("mpPcfg",               mpPcfg);
+       DECLARE("mpPcfgb",              mpPcfgb);
+       DECLARE("mpRIP",                mpRIP);
+       DECLARE("mpRIPb",               mpRIPb);
+       DECLARE("mpPerm",               mpPerm);
+       DECLARE("mpPermb",              mpPermb);
+       DECLARE("mpBSu",                mpBSu);
+       DECLARE("mpBSub",               mpBSub);
+       DECLARE("mpLists",              mpLists);
+       DECLARE("mpListsb",             mpListsb);
+       DECLARE("mpgFlags",             mpgFlags);
+       DECLARE("mpgFree",              mpgFree);
+       DECLARE("mpgGlobal",    mpgGlobal);
+       DECLARE("mpgDormant",   mpgDormant);
+
+       DECLARE("mpSpace",              offsetof(struct mapping *, mpSpace));
+       DECLARE("mpBSize",              offsetof(struct mapping *, u.mpBSize));
+       DECLARE("mpgCursor",    offsetof(struct mapping *, u.mpgCursor));
+       DECLARE("mpPte",                offsetof(struct mapping *, mpPte));
+       DECLARE("mpHValid",             mpHValid);
+       DECLARE("mpHValidb",    mpHValidb);
+
+       DECLARE("mpPAddr",              offsetof(struct mapping *, mpPAddr));
+       DECLARE("mpVAddr",              offsetof(struct mapping *, mpVAddr));
+       DECLARE("mpHWFlags",    mpHWFlags);
+       DECLARE("mpHWFlagsb",   mpHWFlagsb);
+       DECLARE("mpN",                  mpN);
+       DECLARE("mpNb",                 mpNb);
+       DECLARE("mpPP",                 mpPP);
+       DECLARE("mpPPb",                mpPPb);
+       DECLARE("mpPPe",                mpPPe);
+       DECLARE("mpKKN",                mpKKN);
+       DECLARE("mpKKNb",               mpKKNb);
+       DECLARE("mpWIMG",               mpWIMG);
+       DECLARE("mpWIMGb",              mpWIMGb);
+       DECLARE("mpW",                  mpW);
+       DECLARE("mpWb",                 mpWb);
+       DECLARE("mpI",                  mpI);
+       DECLARE("mpIb",                 mpIb);
+       DECLARE("mpM",                  mpM);
+       DECLARE("mpMb",                 mpMb);
+       DECLARE("mpG",                  mpG);
+       DECLARE("mpGb",                 mpGb);
+       DECLARE("mpWIMGe",              mpWIMGe);
+       DECLARE("mpC",                  mpC);
+       DECLARE("mpCb",                 mpCb);
+       DECLARE("mpR",                  mpR);
+       DECLARE("mpRb",                 mpRb);
+       DECLARE("mpAlias",              offsetof(struct mapping *, mpAlias));
+       DECLARE("mpNestReloc",  offsetof(struct mapping *, mpNestReloc));       
+       DECLARE("mpBlkRemCur",  offsetof(struct mapping *, mpBlkRemCur));       
+       DECLARE("mpList0",              offsetof(struct mapping *, mpList0));
+       DECLARE("mpList ",              offsetof(struct mapping *, mpList));
+       DECLARE("mpBasicSize",  mpBasicSize);
+       DECLARE("mpBasicLists", mpBasicLists);
+

        DECLARE("mbvrswap",             offsetof(struct mappingblok *, mapblokvrswap));
        DECLARE("mbfree",               offsetof(struct mappingblok *, mapblokfree));
        DECLARE("mapcsize",             sizeof(struct mappingctl));
        DECLARE("mbvrswap",             offsetof(struct mappingblok *, mapblokvrswap));
        DECLARE("mbfree",               offsetof(struct mappingblok *, mapblokfree));
        DECLARE("mapcsize",             sizeof(struct mappingctl));

+       
+       DECLARE("hwpPurgePTE",  hwpPurgePTE);
+       DECLARE("hwpMergePTE",  hwpMergePTE);
+       DECLARE("hwpNoopPTE",   hwpNoopPTE);
+
+// DANGER WIL ROBINSON!!! This wonderfully magical tool doesn't seem to handle 64-bit constants,
+// leaving us with only the cold ash of a zero. ppI, ppG, and who knows what else is affected.
+       DECLARE("ppLink",               offsetof(struct phys_entry *, ppLink));
+       DECLARE("ppLock",               ppLock);
+       DECLARE("ppFlags",              ppFlags);
+//     DECLARE("ppI",                  ppI);
+       DECLARE("ppIb",                 ppIb);
+//     DECLARE("ppG",                  ppG);
+       DECLARE("ppGb",                 ppGb);
+       DECLARE("ppR",                  ppR);
+       DECLARE("ppRb",                 ppRb);
+       DECLARE("ppC",                  ppC);
+       DECLARE("ppCb",                 ppCb);
+       DECLARE("physEntrySize",physEntrySize);
+       DECLARE("ppLFAmask",    ppLFAmask);
+       DECLARE("ppLFArrot",    ppLFArrot);
+
+       DECLARE("pcfFlags",             offsetof(struct pcfg *, pcfFlags));
+       DECLARE("pcfEncode",    offsetof(struct pcfg *, pcfEncode));
+       DECLARE("pcfPSize",             offsetof(struct pcfg *, pcfPSize));
+       DECLARE("pcfShift",             offsetof(struct pcfg *, pcfShift));
+       DECLARE("pcfValid",             pcfValid);
+       DECLARE("pcfLarge",             pcfLarge);
+       DECLARE("pcfDedSeg",    pcfDedSeg);
+       DECLARE("pcfSize",              sizeof(struct pcfg));
+       DECLARE("pcfDefPcfg",   pcfDefPcfg);
+       DECLARE("pcfLargePcfg", pcfLargePcfg);

 
 

-       DECLARE("pephyslink",   offsetof(struct phys_entry *, phys_link));
-       DECLARE("pepte1",               offsetof(struct phys_entry *, pte1));
-
-       DECLARE("PCAlock",              offsetof(struct PCA *, PCAlock));

        DECLARE("PCAallo",              offsetof(struct PCA *, flgs.PCAallo));
        DECLARE("PCAfree",              offsetof(struct PCA *, flgs.PCAalflgs.PCAfree));
        DECLARE("PCAauto",              offsetof(struct PCA *, flgs.PCAalflgs.PCAauto));
        DECLARE("PCAallo",              offsetof(struct PCA *, flgs.PCAallo));
        DECLARE("PCAfree",              offsetof(struct PCA *, flgs.PCAalflgs.PCAfree));
        DECLARE("PCAauto",              offsetof(struct PCA *, flgs.PCAalflgs.PCAauto));

-       DECLARE("PCAslck",              offsetof(struct PCA *, flgs.PCAalflgs.PCAslck));
+       DECLARE("PCAmisc",              offsetof(struct PCA *, flgs.PCAalflgs.PCAmisc));
+       DECLARE("PCAlock",              PCAlock);
+       DECLARE("PCAlockb",             PCAlockb);

        DECLARE("PCAsteal",             offsetof(struct PCA *, flgs.PCAalflgs.PCAsteal));
        DECLARE("PCAsteal",             offsetof(struct PCA *, flgs.PCAalflgs.PCAsteal));

-       DECLARE("PCAgas",               offsetof(struct PCA *, PCAgas));
-       DECLARE("PCAhash",              offsetof(struct PCA *, PCAhash));
-
-       DECLARE("SVlock",               offsetof(struct Saveanchor *, savelock));
-       DECLARE("SVcount",              offsetof(struct Saveanchor *, savecount));
-       DECLARE("SVinuse",              offsetof(struct Saveanchor *, saveinuse));
-       DECLARE("SVmin",                offsetof(struct Saveanchor *, savemin));
-       DECLARE("SVneghyst",    offsetof(struct Saveanchor *, saveneghyst));
-       DECLARE("SVtarget",             offsetof(struct Saveanchor *, savetarget));
-       DECLARE("SVposhyst",    offsetof(struct Saveanchor *, saveposhyst));
-       DECLARE("SVfree",               offsetof(struct Saveanchor *, savefree));
-       DECLARE("SVsize",               sizeof(struct Saveanchor));
+
+       DECLARE("mrPhysTab",    offsetof(struct mem_region *, mrPhysTab));
+       DECLARE("mrStart",              offsetof(struct mem_region *, mrStart));
+       DECLARE("mrEnd",                offsetof(struct mem_region *, mrEnd));
+       DECLARE("mrAStart",             offsetof(struct mem_region *, mrAStart));
+       DECLARE("mrAEnd",               offsetof(struct mem_region *, mrAEnd));
+       DECLARE("mrSize",               sizeof(struct mem_region));
+
+       DECLARE("mapRemChunk",  mapRemChunk);
+
+       DECLARE("mapRetCode",   mapRetCode);
+       DECLARE("mapRtOK",              mapRtOK);
+       DECLARE("mapRtBadLk",   mapRtBadLk);
+       DECLARE("mapRtPerm",    mapRtPerm);
+       DECLARE("mapRtNotFnd",  mapRtNotFnd);
+       DECLARE("mapRtBlock",   mapRtBlock);
+       DECLARE("mapRtNest",    mapRtNest);
+       DECLARE("mapRtRemove",  mapRtRemove);
+       DECLARE("mapRtMapDup",  mapRtMapDup);
+       DECLARE("mapRtGuest",   mapRtGuest);
+       DECLARE("mapRtEmpty",   mapRtEmpty);
+       DECLARE("mapRtSmash",   mapRtSmash);
+
+#if 0
+       DECLARE("MFpcaptr",             offsetof(struct mappingflush *, pcaptr));
+       DECLARE("MFmappingcnt",         offsetof(struct mappingflush *, mappingcnt));
+       DECLARE("MFmapping",            offsetof(struct mappingflush *, mapping));
+       DECLARE("MFmappingSize",        sizeof(struct mfmapping));
+#endif
+
+       DECLARE("GV_GROUPS_LG2",        GV_GROUPS_LG2);
+       DECLARE("GV_GROUPS",            GV_GROUPS);
+       DECLARE("GV_SLOT_SZ_LG2",       GV_SLOT_SZ_LG2);
+       DECLARE("GV_SLOT_SZ",           GV_SLOT_SZ);
+       DECLARE("GV_SLOTS_LG2",         GV_SLOTS_LG2);
+       DECLARE("GV_SLOTS",                     GV_SLOTS);
+       DECLARE("GV_PGIDX_SZ_LG2",      GV_PGIDX_SZ_LG2);
+       DECLARE("GV_PAGE_SZ_LG2",       GV_PAGE_SZ_LG2);
+       DECLARE("GV_PAGE_SZ",           GV_PAGE_SZ);
+       DECLARE("GV_PAGE_MASK",         GV_PAGE_MASK);
+       DECLARE("GV_HPAGES",            GV_HPAGES);
+       DECLARE("GV_GRPS_PPG_LG2",      GV_GRPS_PPG_LG2);
+       DECLARE("GV_GRPS_PPG",          GV_GRPS_PPG);
+       DECLARE("GV_GRP_MASK",          GV_GRP_MASK);
+       DECLARE("GV_SLOT_MASK",         GV_SLOT_MASK);
+       DECLARE("GV_HPAGE_SHIFT",       GV_HPAGE_SHIFT);
+       DECLARE("GV_HPAGE_MASK",        GV_HPAGE_MASK);
+       DECLARE("GV_HGRP_SHIFT",        GV_HGRP_SHIFT);
+       DECLARE("GV_HGRP_MASK",         GV_HGRP_MASK);
+       DECLARE("GV_MAPWD_BITS_LG2",GV_MAPWD_BITS_LG2);
+       DECLARE("GV_MAPWD_SZ_LG2",      GV_MAPWD_SZ_LG2);
+       DECLARE("GV_MAP_WORDS",         GV_MAP_WORDS);
+       DECLARE("GV_MAP_MASK",          GV_MAP_MASK);
+       DECLARE("GV_MAP_SHIFT",         GV_MAP_SHIFT);
+       DECLARE("GV_BAND_SHIFT",        GV_BAND_SHIFT);
+       DECLARE("GV_BAND_SZ_LG2",       GV_BAND_SZ_LG2);
+       DECLARE("GV_BAND_MASK",         GV_BAND_MASK);

 
 #if 1
        DECLARE("GDsave",               offsetof(struct GDWorkArea *, GDsave));
 
 #if 1
        DECLARE("GDsave",               offsetof(struct GDWorkArea *, GDsave));


@@ -727,9 +1148,6 @@ int main(int argc, char *argv[])
        DECLARE("GDrowbuf2",    offsetof(struct GDWorkArea *, GDrowbuf2));
 #endif
 
        DECLARE("GDrowbuf2",    offsetof(struct GDWorkArea *, GDrowbuf2));
 #endif
 

-       DECLARE("dgLock",               offsetof(struct diagWork *, dgLock));
-       DECLARE("dgFlags",              offsetof(struct diagWork *, dgFlags));
-       DECLARE("dgMisc0",              offsetof(struct diagWork *, dgMisc0));

        DECLARE("enaExpTrace",  enaExpTrace);
        DECLARE("enaExpTraceb", enaExpTraceb);
        DECLARE("enaUsrFCall",  enaUsrFCall);
        DECLARE("enaExpTrace",  enaExpTrace);
        DECLARE("enaExpTraceb", enaExpTraceb);
        DECLARE("enaUsrFCall",  enaUsrFCall);


@@ -738,12 +1156,16 @@ int main(int argc, char *argv[])
        DECLARE("enaUsrPhyMpb", enaUsrPhyMpb);
        DECLARE("enaDiagSCs",   enaDiagSCs);
        DECLARE("enaDiagSCsb",  enaDiagSCsb);
        DECLARE("enaUsrPhyMpb", enaUsrPhyMpb);
        DECLARE("enaDiagSCs",   enaDiagSCs);
        DECLARE("enaDiagSCsb",  enaDiagSCsb);

+       DECLARE("enaDiagEM",    enaDiagEM);
+       DECLARE("enaDiagEMb",   enaDiagEMb);
+       DECLARE("enaNotifyEM",  enaNotifyEM);
+       DECLARE("enaNotifyEMb", enaNotifyEMb);

        DECLARE("disLkType",    disLkType);
        DECLARE("disLktypeb",   disLktypeb);
        DECLARE("disLkThread",  disLkThread);
        DECLARE("disLkThreadb", disLkThreadb);
        DECLARE("disLkType",    disLkType);
        DECLARE("disLktypeb",   disLktypeb);
        DECLARE("disLkThread",  disLkThread);
        DECLARE("disLkThreadb", disLkThreadb);

-       DECLARE("disLkNmSimp",  disLkNmSimp);
-       DECLARE("disLkNmSimpb", disLkNmSimpb);
+       DECLARE("enaLkExtStck", enaLkExtStck);
+       DECLARE("enaLkExtStckb",enaLkExtStckb);

        DECLARE("disLkMyLck",   disLkMyLck);
        DECLARE("disLkMyLckb",  disLkMyLckb);
        DECLARE("dgMisc1",              offsetof(struct diagWork *, dgMisc1));
        DECLARE("disLkMyLck",   disLkMyLck);
        DECLARE("disLkMyLckb",  disLkMyLckb);
        DECLARE("dgMisc1",              offsetof(struct diagWork *, dgMisc1));


@@ -752,45 +1174,67 @@ int main(int argc, char *argv[])
        DECLARE("dgMisc4",              offsetof(struct diagWork *, dgMisc4));
        DECLARE("dgMisc5",              offsetof(struct diagWork *, dgMisc5));
 
        DECLARE("dgMisc4",              offsetof(struct diagWork *, dgMisc4));
        DECLARE("dgMisc5",              offsetof(struct diagWork *, dgMisc5));
 

-       DECLARE("traceMask",    offsetof(struct traceWork *, traceMask));
-       DECLARE("traceCurr",    offsetof(struct traceWork *, traceCurr));
-       DECLARE("traceStart",   offsetof(struct traceWork *, traceStart));
-       DECLARE("traceEnd",             offsetof(struct traceWork *, traceEnd));
-       DECLARE("traceMsnd",    offsetof(struct traceWork *, traceMsnd));
-
-       DECLARE("SACsize",              sizeof(struct savectl));                                
-       DECLARE("SACspot",              4096-sizeof(struct savectl));           
-       DECLARE("SACnext",              offsetof(struct savectl *, sac_next)+4096-sizeof(struct savectl));
-       DECLARE("SACvrswap",    offsetof(struct savectl *, sac_vrswap)+4096-sizeof(struct savectl));
-       DECLARE("SACalloc",             offsetof(struct savectl *, sac_alloc)+4096-sizeof(struct savectl));
-       DECLARE("SACflags",             offsetof(struct savectl *, sac_flags)+4096-sizeof(struct savectl));
-
-       DECLARE("SAVprev",              offsetof(struct savearea *, save_prev));
-       DECLARE("SAVprefp",             offsetof(struct savearea *, save_prev_float));
-       DECLARE("SAVprevec",    offsetof(struct savearea *, save_prev_vector));
-       DECLARE("SAVphys",              offsetof(struct savearea *, save_phys));
-       DECLARE("SAVqfret",             offsetof(struct savearea *, save_qfret));
-       DECLARE("SAVact",               offsetof(struct savearea *, save_act));
-       DECLARE("SAVflags",             offsetof(struct savearea *, save_flags));
-       DECLARE("SAVlvlfp",             offsetof(struct savearea *, save_level_fp));
-       DECLARE("SAVlvlvec",    offsetof(struct savearea *, save_level_vec));
-       DECLARE("SAVsize",              sizeof(struct savearea));
+       DECLARE("SACnext",              offsetof(struct savearea_comm *, sac_next));
+       DECLARE("SACprev",              offsetof(struct savearea_comm *, sac_prev));
+       DECLARE("SACvrswap",    offsetof(struct savearea_comm *, sac_vrswap));
+       DECLARE("SACalloc",             offsetof(struct savearea_comm *, sac_alloc));
+       DECLARE("SACflags",             offsetof(struct savearea_comm *, sac_flags));
+       DECLARE("sac_cnt",              sac_cnt);
+       DECLARE("sac_empty",    sac_empty);
+       DECLARE("sac_perm",             sac_perm);
+       DECLARE("sac_permb",    sac_permb);
+
+       DECLARE("LocalSaveTarget",              LocalSaveTarget);
+       DECLARE("LocalSaveMin",                 LocalSaveMin);
+       DECLARE("LocalSaveMax",                 LocalSaveMax);
+       DECLARE("FreeListMin",                  FreeListMin);
+       DECLARE("SaveLowHysteresis",    SaveLowHysteresis);
+       DECLARE("SaveHighHysteresis",   SaveHighHysteresis);
+       DECLARE("InitialSaveAreas",             InitialSaveAreas);
+       DECLARE("InitialSaveTarget",    InitialSaveTarget);
+       DECLARE("InitialSaveBloks",             InitialSaveBloks);
+
+       DECLARE("SAVprev",              offsetof(struct savearea_comm *, save_prev));
+       DECLARE("SAVact",               offsetof(struct savearea_comm *, save_act));
+       DECLARE("SAVflags",             offsetof(struct savearea_comm *, save_flags));
+       DECLARE("SAVlevel",             offsetof(struct savearea_comm *, save_level));
+       DECLARE("SAVtime",              offsetof(struct savearea_comm *, save_time));
+       DECLARE("savemisc0",    offsetof(struct savearea_comm *, save_misc0));
+       DECLARE("savemisc1",    offsetof(struct savearea_comm *, save_misc1));
+       DECLARE("savemisc2",    offsetof(struct savearea_comm *, save_misc2));
+       DECLARE("savemisc3",    offsetof(struct savearea_comm *, save_misc3));

 
 

+       DECLARE("SAVsize",              sizeof(struct savearea));
+       DECLARE("SAVsizefpu",   sizeof(struct savearea_vec));
+       DECLARE("SAVsizevec",   sizeof(struct savearea_fpu));
+       DECLARE("SAVcommsize",  sizeof(struct savearea_comm));
+       

        DECLARE("savesrr0",             offsetof(struct savearea *, save_srr0));
        DECLARE("savesrr1",             offsetof(struct savearea *, save_srr1));
        DECLARE("savecr",               offsetof(struct savearea *, save_cr));
        DECLARE("savexer",              offsetof(struct savearea *, save_xer));
        DECLARE("savelr",               offsetof(struct savearea *, save_lr));
        DECLARE("savectr",              offsetof(struct savearea *, save_ctr));
        DECLARE("savesrr0",             offsetof(struct savearea *, save_srr0));
        DECLARE("savesrr1",             offsetof(struct savearea *, save_srr1));
        DECLARE("savecr",               offsetof(struct savearea *, save_cr));
        DECLARE("savexer",              offsetof(struct savearea *, save_xer));
        DECLARE("savelr",               offsetof(struct savearea *, save_lr));
        DECLARE("savectr",              offsetof(struct savearea *, save_ctr));

-       DECLARE("savemq",               offsetof(struct savearea *, save_mq));
-       DECLARE("savecopyin",   offsetof(struct savearea *, save_sr_copyin));

        DECLARE("savedar",              offsetof(struct savearea *, save_dar));
        DECLARE("savedsisr",    offsetof(struct savearea *, save_dsisr));
        DECLARE("saveexception",        offsetof(struct savearea *, save_exception));
        DECLARE("savedar",              offsetof(struct savearea *, save_dar));
        DECLARE("savedsisr",    offsetof(struct savearea *, save_dsisr));
        DECLARE("saveexception",        offsetof(struct savearea *, save_exception));

-       DECLARE("savexfpscrpad",        offsetof(struct savearea *, save_xfpscrpad));
-       DECLARE("savexfpscr",   offsetof(struct savearea *, save_xfpscr));
+       DECLARE("savefpscrpad", offsetof(struct savearea *, save_fpscrpad));
+       DECLARE("savefpscr",    offsetof(struct savearea *, save_fpscr));

        DECLARE("savevrsave",   offsetof(struct savearea *, save_vrsave));      
        DECLARE("savevrsave",   offsetof(struct savearea *, save_vrsave));      

+       DECLARE("savevscr",             offsetof(struct savearea *, save_vscr));        

 
 

+       DECLARE("savemmcr0",    offsetof(struct savearea *, save_mmcr0));
+       DECLARE("savemmcr1",    offsetof(struct savearea *, save_mmcr1));
+       DECLARE("savemmcr2",    offsetof(struct savearea *, save_mmcr2));
+       DECLARE("savepmc",              offsetof(struct savearea *, save_pmc));
+       
+       DECLARE("saveinstr",    offsetof(struct savearea *, save_instr));
+
+       DECLARE("savexdat0",    offsetof(struct savearea *, save_xdat0));
+       DECLARE("savexdat1",    offsetof(struct savearea *, save_xdat1));
+       DECLARE("savexdat2",    offsetof(struct savearea *, save_xdat2));
+       DECLARE("savexdat3",    offsetof(struct savearea *, save_xdat3));
+       

        DECLARE("saver0",               offsetof(struct savearea *, save_r0));
        DECLARE("saver1",               offsetof(struct savearea *, save_r1));
        DECLARE("saver2",               offsetof(struct savearea *, save_r2));
        DECLARE("saver0",               offsetof(struct savearea *, save_r0));
        DECLARE("saver1",               offsetof(struct savearea *, save_r1));
        DECLARE("saver2",               offsetof(struct savearea *, save_r2));


@@ -824,92 +1268,72 @@ int main(int argc, char *argv[])
        DECLARE("saver30",              offsetof(struct savearea *, save_r30));
        DECLARE("saver31",              offsetof(struct savearea *, save_r31));
 
        DECLARE("saver30",              offsetof(struct savearea *, save_r30));
        DECLARE("saver31",              offsetof(struct savearea *, save_r31));
 

-       DECLARE("savefp0",              offsetof(struct savearea *, save_fp0));
-       DECLARE("savefp1",              offsetof(struct savearea *, save_fp1));
-       DECLARE("savefp2",              offsetof(struct savearea *, save_fp2));
-       DECLARE("savefp3",              offsetof(struct savearea *, save_fp3));
-       DECLARE("savefp4",              offsetof(struct savearea *, save_fp4));
-       DECLARE("savefp5",              offsetof(struct savearea *, save_fp5));
-       DECLARE("savefp6",              offsetof(struct savearea *, save_fp6));
-       DECLARE("savefp7",              offsetof(struct savearea *, save_fp7));
-       DECLARE("savefp8",              offsetof(struct savearea *, save_fp8));
-       DECLARE("savefp9",              offsetof(struct savearea *, save_fp9));
-       DECLARE("savefp10",             offsetof(struct savearea *, save_fp10));
-       DECLARE("savefp11",             offsetof(struct savearea *, save_fp11));
-       DECLARE("savefp12",             offsetof(struct savearea *, save_fp12));
-       DECLARE("savefp13",             offsetof(struct savearea *, save_fp13));
-       DECLARE("savefp14",             offsetof(struct savearea *, save_fp14));
-       DECLARE("savefp15",             offsetof(struct savearea *, save_fp15));
-       DECLARE("savefp16",             offsetof(struct savearea *, save_fp16));
-       DECLARE("savefp17",             offsetof(struct savearea *, save_fp17));
-       DECLARE("savefp18",             offsetof(struct savearea *, save_fp18));
-       DECLARE("savefp19",             offsetof(struct savearea *, save_fp19));
-       DECLARE("savefp20",             offsetof(struct savearea *, save_fp20));
-       DECLARE("savefp21",             offsetof(struct savearea *, save_fp21));
-       DECLARE("savefp22",             offsetof(struct savearea *, save_fp22));
-       DECLARE("savefp23",             offsetof(struct savearea *, save_fp23));
-       DECLARE("savefp24",             offsetof(struct savearea *, save_fp24));
-       DECLARE("savefp25",             offsetof(struct savearea *, save_fp25));
-       DECLARE("savefp26",             offsetof(struct savearea *, save_fp26));
-       DECLARE("savefp27",             offsetof(struct savearea *, save_fp27));
-       DECLARE("savefp28",             offsetof(struct savearea *, save_fp28));
-       DECLARE("savefp29",             offsetof(struct savearea *, save_fp29));
-       DECLARE("savefp30",             offsetof(struct savearea *, save_fp30));
-       DECLARE("savefp31",             offsetof(struct savearea *, save_fp31));
-       DECLARE("savefpscrpad", offsetof(struct savearea *, save_fpscr_pad));
-       DECLARE("savefpscr",    offsetof(struct savearea *, save_fpscr));
-
-       DECLARE("savesr0",              offsetof(struct savearea *, save_sr0));
-       DECLARE("savesr1",              offsetof(struct savearea *, save_sr1));
-       DECLARE("savesr2",              offsetof(struct savearea *, save_sr2));
-       DECLARE("savesr3",              offsetof(struct savearea *, save_sr3));
-       DECLARE("savesr4",              offsetof(struct savearea *, save_sr4));
-       DECLARE("savesr5",              offsetof(struct savearea *, save_sr5));
-       DECLARE("savesr6",              offsetof(struct savearea *, save_sr6));
-       DECLARE("savesr7",              offsetof(struct savearea *, save_sr7));
-       DECLARE("savesr8",              offsetof(struct savearea *, save_sr8));
-       DECLARE("savesr9",              offsetof(struct savearea *, save_sr9));
-       DECLARE("savesr10",             offsetof(struct savearea *, save_sr10));
-       DECLARE("savesr11",             offsetof(struct savearea *, save_sr11));
-       DECLARE("savesr12",             offsetof(struct savearea *, save_sr12));
-       DECLARE("savesr13",             offsetof(struct savearea *, save_sr13));
-       DECLARE("savesr14",             offsetof(struct savearea *, save_sr14));
-       DECLARE("savesr15",             offsetof(struct savearea *, save_sr15));
+       DECLARE("savefp0",              offsetof(struct savearea_fpu *, save_fp0));
+       DECLARE("savefp1",              offsetof(struct savearea_fpu *, save_fp1));
+       DECLARE("savefp2",              offsetof(struct savearea_fpu *, save_fp2));
+       DECLARE("savefp3",              offsetof(struct savearea_fpu *, save_fp3));
+       DECLARE("savefp4",              offsetof(struct savearea_fpu *, save_fp4));
+       DECLARE("savefp5",              offsetof(struct savearea_fpu *, save_fp5));
+       DECLARE("savefp6",              offsetof(struct savearea_fpu *, save_fp6));
+       DECLARE("savefp7",              offsetof(struct savearea_fpu *, save_fp7));
+       DECLARE("savefp8",              offsetof(struct savearea_fpu *, save_fp8));
+       DECLARE("savefp9",              offsetof(struct savearea_fpu *, save_fp9));
+       DECLARE("savefp10",             offsetof(struct savearea_fpu *, save_fp10));
+       DECLARE("savefp11",             offsetof(struct savearea_fpu *, save_fp11));
+       DECLARE("savefp12",             offsetof(struct savearea_fpu *, save_fp12));
+       DECLARE("savefp13",             offsetof(struct savearea_fpu *, save_fp13));
+       DECLARE("savefp14",             offsetof(struct savearea_fpu *, save_fp14));
+       DECLARE("savefp15",             offsetof(struct savearea_fpu *, save_fp15));
+       DECLARE("savefp16",             offsetof(struct savearea_fpu *, save_fp16));
+       DECLARE("savefp17",             offsetof(struct savearea_fpu *, save_fp17));
+       DECLARE("savefp18",             offsetof(struct savearea_fpu *, save_fp18));
+       DECLARE("savefp19",             offsetof(struct savearea_fpu *, save_fp19));
+       DECLARE("savefp20",             offsetof(struct savearea_fpu *, save_fp20));
+       DECLARE("savefp21",             offsetof(struct savearea_fpu *, save_fp21));
+       DECLARE("savefp22",             offsetof(struct savearea_fpu *, save_fp22));
+       DECLARE("savefp23",             offsetof(struct savearea_fpu *, save_fp23));
+       DECLARE("savefp24",             offsetof(struct savearea_fpu *, save_fp24));
+       DECLARE("savefp25",             offsetof(struct savearea_fpu *, save_fp25));
+       DECLARE("savefp26",             offsetof(struct savearea_fpu *, save_fp26));
+       DECLARE("savefp27",             offsetof(struct savearea_fpu *, save_fp27));
+       DECLARE("savefp28",             offsetof(struct savearea_fpu *, save_fp28));
+       DECLARE("savefp29",             offsetof(struct savearea_fpu *, save_fp29));
+       DECLARE("savefp30",             offsetof(struct savearea_fpu *, save_fp30));
+       DECLARE("savefp31",             offsetof(struct savearea_fpu *, save_fp31));

        
        

-       DECLARE("savevr0",              offsetof(struct savearea *, save_vr0));
-       DECLARE("savevr1",              offsetof(struct savearea *, save_vr1));
-       DECLARE("savevr2",              offsetof(struct savearea *, save_vr2));
-       DECLARE("savevr3",              offsetof(struct savearea *, save_vr3));
-       DECLARE("savevr4",              offsetof(struct savearea *, save_vr4));
-       DECLARE("savevr5",              offsetof(struct savearea *, save_vr5));
-       DECLARE("savevr6",              offsetof(struct savearea *, save_vr6));
-       DECLARE("savevr7",              offsetof(struct savearea *, save_vr7));
-       DECLARE("savevr8",              offsetof(struct savearea *, save_vr8));
-       DECLARE("savevr9",              offsetof(struct savearea *, save_vr9));
-       DECLARE("savevr10",             offsetof(struct savearea *, save_vr10));
-       DECLARE("savevr11",             offsetof(struct savearea *, save_vr11));
-       DECLARE("savevr12",             offsetof(struct savearea *, save_vr12));
-       DECLARE("savevr13",             offsetof(struct savearea *, save_vr13));
-       DECLARE("savevr14",             offsetof(struct savearea *, save_vr14));
-       DECLARE("savevr15",             offsetof(struct savearea *, save_vr15));
-       DECLARE("savevr16",             offsetof(struct savearea *, save_vr16));
-       DECLARE("savevr17",             offsetof(struct savearea *, save_vr17));
-       DECLARE("savevr18",             offsetof(struct savearea *, save_vr18));
-       DECLARE("savevr19",             offsetof(struct savearea *, save_vr19));
-       DECLARE("savevr20",             offsetof(struct savearea *, save_vr20));
-       DECLARE("savevr21",             offsetof(struct savearea *, save_vr21));
-       DECLARE("savevr22",             offsetof(struct savearea *, save_vr22));
-       DECLARE("savevr23",             offsetof(struct savearea *, save_vr23));
-       DECLARE("savevr24",             offsetof(struct savearea *, save_vr24));
-       DECLARE("savevr25",             offsetof(struct savearea *, save_vr25));
-       DECLARE("savevr26",             offsetof(struct savearea *, save_vr26));
-       DECLARE("savevr27",             offsetof(struct savearea *, save_vr27));
-       DECLARE("savevr28",             offsetof(struct savearea *, save_vr28));
-       DECLARE("savevr29",             offsetof(struct savearea *, save_vr29));
-       DECLARE("savevr30",             offsetof(struct savearea *, save_vr30));
-       DECLARE("savevr31",             offsetof(struct savearea *, save_vr31));
-       DECLARE("savevscr",             offsetof(struct savearea *, save_vscr));        
-       DECLARE("savevrvalid",  offsetof(struct savearea *, save_vrvalid));     
+       DECLARE("savevr0",              offsetof(struct savearea_vec *, save_vr0));
+       DECLARE("savevr1",              offsetof(struct savearea_vec *, save_vr1));
+       DECLARE("savevr2",              offsetof(struct savearea_vec *, save_vr2));
+       DECLARE("savevr3",              offsetof(struct savearea_vec *, save_vr3));
+       DECLARE("savevr4",              offsetof(struct savearea_vec *, save_vr4));
+       DECLARE("savevr5",              offsetof(struct savearea_vec *, save_vr5));
+       DECLARE("savevr6",              offsetof(struct savearea_vec *, save_vr6));
+       DECLARE("savevr7",              offsetof(struct savearea_vec *, save_vr7));
+       DECLARE("savevr8",              offsetof(struct savearea_vec *, save_vr8));
+       DECLARE("savevr9",              offsetof(struct savearea_vec *, save_vr9));
+       DECLARE("savevr10",             offsetof(struct savearea_vec *, save_vr10));
+       DECLARE("savevr11",             offsetof(struct savearea_vec *, save_vr11));
+       DECLARE("savevr12",             offsetof(struct savearea_vec *, save_vr12));
+       DECLARE("savevr13",             offsetof(struct savearea_vec *, save_vr13));
+       DECLARE("savevr14",             offsetof(struct savearea_vec *, save_vr14));
+       DECLARE("savevr15",             offsetof(struct savearea_vec *, save_vr15));
+       DECLARE("savevr16",             offsetof(struct savearea_vec *, save_vr16));
+       DECLARE("savevr17",             offsetof(struct savearea_vec *, save_vr17));
+       DECLARE("savevr18",             offsetof(struct savearea_vec *, save_vr18));
+       DECLARE("savevr19",             offsetof(struct savearea_vec *, save_vr19));
+       DECLARE("savevr20",             offsetof(struct savearea_vec *, save_vr20));
+       DECLARE("savevr21",             offsetof(struct savearea_vec *, save_vr21));
+       DECLARE("savevr22",             offsetof(struct savearea_vec *, save_vr22));
+       DECLARE("savevr23",             offsetof(struct savearea_vec *, save_vr23));
+       DECLARE("savevr24",             offsetof(struct savearea_vec *, save_vr24));
+       DECLARE("savevr25",             offsetof(struct savearea_vec *, save_vr25));
+       DECLARE("savevr26",             offsetof(struct savearea_vec *, save_vr26));
+       DECLARE("savevr27",             offsetof(struct savearea_vec *, save_vr27));
+       DECLARE("savevr28",             offsetof(struct savearea_vec *, save_vr28));
+       DECLARE("savevr29",             offsetof(struct savearea_vec *, save_vr29));
+       DECLARE("savevr30",             offsetof(struct savearea_vec *, save_vr30));
+       DECLARE("savevr31",             offsetof(struct savearea_vec *, save_vr31));
+       DECLARE("savevrvalid",  offsetof(struct savearea_vec *, save_vrvalid)); 

 
        /* PseudoKernel Exception Descriptor info */
        DECLARE("BEDA_SRR0",    offsetof(BEDA_t *, srr0));
 
        /* PseudoKernel Exception Descriptor info */
        DECLARE("BEDA_SRR0",    offsetof(BEDA_t *, srr0));


@@ -950,23 +1374,65 @@ int main(int argc, char *argv[])
        DECLARE("procState",            offsetof(struct processor *, state));
        
        DECLARE("CPU_SUBTYPE_POWERPC_ALL",              CPU_SUBTYPE_POWERPC_ALL);
        DECLARE("procState",            offsetof(struct processor *, state));
        
        DECLARE("CPU_SUBTYPE_POWERPC_ALL",              CPU_SUBTYPE_POWERPC_ALL);

-       DECLARE("CPU_SUBTYPE_POWERPC_601",              CPU_SUBTYPE_POWERPC_601);
-       DECLARE("CPU_SUBTYPE_POWERPC_602",              CPU_SUBTYPE_POWERPC_602);
-       DECLARE("CPU_SUBTYPE_POWERPC_603",              CPU_SUBTYPE_POWERPC_603);
-       DECLARE("CPU_SUBTYPE_POWERPC_603e",             CPU_SUBTYPE_POWERPC_603e);
-       DECLARE("CPU_SUBTYPE_POWERPC_603ev",    CPU_SUBTYPE_POWERPC_603ev);
-       DECLARE("CPU_SUBTYPE_POWERPC_604",              CPU_SUBTYPE_POWERPC_604);
-       DECLARE("CPU_SUBTYPE_POWERPC_604e",             CPU_SUBTYPE_POWERPC_604e);
-       DECLARE("CPU_SUBTYPE_POWERPC_620",              CPU_SUBTYPE_POWERPC_620);

        DECLARE("CPU_SUBTYPE_POWERPC_750",              CPU_SUBTYPE_POWERPC_750);
        DECLARE("CPU_SUBTYPE_POWERPC_7400",             CPU_SUBTYPE_POWERPC_7400);
        DECLARE("CPU_SUBTYPE_POWERPC_7450",             CPU_SUBTYPE_POWERPC_7450);
        DECLARE("CPU_SUBTYPE_POWERPC_750",              CPU_SUBTYPE_POWERPC_750);
        DECLARE("CPU_SUBTYPE_POWERPC_7400",             CPU_SUBTYPE_POWERPC_7400);
        DECLARE("CPU_SUBTYPE_POWERPC_7450",             CPU_SUBTYPE_POWERPC_7450);

+       DECLARE("CPU_SUBTYPE_POWERPC_970",              CPU_SUBTYPE_POWERPC_970);

 
        DECLARE("shdIBAT",      offsetof(struct shadowBAT *, IBATs));   
        DECLARE("shdDBAT",      offsetof(struct shadowBAT *, DBATs));   
        
 
        DECLARE("shdIBAT",      offsetof(struct shadowBAT *, IBATs));   
        DECLARE("shdDBAT",      offsetof(struct shadowBAT *, DBATs));   
        

-       return(0);  /* For ANSI C :-) */
+       /* Low Memory Globals */
+
+       DECLARE("lgVerCode",                    offsetof(struct lowglo *, lgVerCode));
+       DECLARE("lgPPStart",                    offsetof(struct lowglo *, lgPPStart));
+       DECLARE("maxDec",                               offsetof(struct lowglo *, lgMaxDec));
+       DECLARE("mckFlags",                     offsetof(struct lowglo *, lgMckFlags));
+       DECLARE("lgPMWvaddr",                   offsetof(struct lowglo *, lgPMWvaddr));
+       DECLARE("lgUMWvaddr",                   offsetof(struct lowglo *, lgUMWvaddr));
+       DECLARE("trcWork",                              offsetof(struct lowglo *, lgTrcWork));
+       DECLARE("traceMask",                    offsetof(struct lowglo *, lgTrcWork.traceMask));
+       DECLARE("traceCurr",                    offsetof(struct lowglo *, lgTrcWork.traceCurr));
+       DECLARE("traceStart",                   offsetof(struct lowglo *, lgTrcWork.traceStart));
+       DECLARE("traceEnd",                             offsetof(struct lowglo *, lgTrcWork.traceEnd));
+       DECLARE("traceMsnd",                    offsetof(struct lowglo *, lgTrcWork.traceMsnd));
+
+       DECLARE("Zero",                                 offsetof(struct lowglo *, lgZero));
+       DECLARE("saveanchor",                   offsetof(struct lowglo *, lgSaveanchor));
+
+       DECLARE("SVlock",                               offsetof(struct lowglo *, lgSaveanchor.savelock));
+       DECLARE("SVpoolfwd",                    offsetof(struct lowglo *, lgSaveanchor.savepoolfwd));
+       DECLARE("SVpoolbwd",                    offsetof(struct lowglo *, lgSaveanchor.savepoolbwd));
+       DECLARE("SVfree",                               offsetof(struct lowglo *, lgSaveanchor.savefree));
+       DECLARE("SVfreecnt",                    offsetof(struct lowglo *, lgSaveanchor.savefreecnt));
+       DECLARE("SVadjust",                             offsetof(struct lowglo *, lgSaveanchor.saveadjust));
+       DECLARE("SVinuse",                              offsetof(struct lowglo *, lgSaveanchor.saveinuse));
+       DECLARE("SVtarget",                             offsetof(struct lowglo *, lgSaveanchor.savetarget));
+       DECLARE("SVsaveinusesnapshot",          offsetof(struct lowglo *, lgSaveanchor.saveinusesnapshot));
+       DECLARE("SVsavefreesnapshot",           offsetof(struct lowglo *, lgSaveanchor.savefreesnapshot));
+       DECLARE("SVsize",                               sizeof(struct Saveanchor));
+
+       DECLARE("tlbieLock",                    offsetof(struct lowglo *, lgTlbieLck));
+
+       DECLARE("dgFlags",                              offsetof(struct lowglo *, lgdgWork.dgFlags));
+       DECLARE("dgLock",                               offsetof(struct lowglo *, lgdgWork.dgLock));
+       DECLARE("dgMisc0",                              offsetof(struct lowglo *, lgdgWork.dgMisc0));
+       
+       DECLARE("lglcksWork",                   offsetof(struct lowglo *, lglcksWork));
+       DECLARE("lgKillResv",                   offsetof(struct lowglo *, lgKillResv));
+       DECLARE("lgpPcfg",                              offsetof(struct lowglo *, lgpPcfg));

 
 
 
 

+       DECLARE("scomcpu",                              offsetof(struct scomcomm *, scomcpu));
+       DECLARE("scomfunc",                             offsetof(struct scomcomm *, scomfunc));
+       DECLARE("scomreg",                              offsetof(struct scomcomm *, scomreg));
+       DECLARE("scomstat",                             offsetof(struct scomcomm *, scomstat));
+       DECLARE("scomdata",                             offsetof(struct scomcomm *, scomdata));

 
 

+#if    CONFIG_DTRACE
+       DECLARE("LS_LCK_MTX_UNLOCK_RELEASE", LS_LCK_MTX_UNLOCK_RELEASE);
+       DECLARE("LS_LCK_MTX_LOCK_ACQUIRE", LS_LCK_MTX_LOCK_ACQUIRE);
+#endif
+
+       return(0);  /* For ANSI C :-) */

 }
 }