X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/0b4e3aa066abc0728aacb4bbeb86f53f9737156e..4a3eedf9ecc9bbe3f3a5c6ce5e53ad199d639d32:/osfmk/ppc/genassym.c diff --git a/osfmk/ppc/genassym.c b/osfmk/ppc/genassym.c index 0d8dd2416..8207aeb55 100644 --- 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, - * 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@ @@ -37,21 +43,18 @@ * the values, but we cannot run anything on the target machine. */ -#include -#include #include #include #include -#include #include #include +#include #include #include -#include +#include #include #include -#include #include #include #include @@ -60,14 +63,23 @@ #include #include #include -#include #include -#include #include #include #include +#include #include +#include +#include +#include + +#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) \ @@ -76,113 +88,51 @@ 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("bbNoMachSCbit",bbNoMachSCbit); DECLARE("runningVM", runningVM); + DECLARE("runningVMbit", runningVMbit); DECLARE("floatCng", floatCng); - DECLARE("vectorCng", vectorCng); DECLARE("floatCngbit", floatCngbit); + DECLARE("vectorCng", vectorCng); DECLARE("vectorCngbit", vectorCngbit); - DECLARE("bbThreadbit", bbThreadbit); - DECLARE("bbPreemptivebit", bbPreemptivebit); + DECLARE("userProtKey", userProtKey); + DECLARE("userProtKeybit", userProtKeybit); + DECLARE("bbThread", bbThread); + DECLARE("bbThreadbit", bbThreadbit); + DECLARE("bbNoMachSC", bbNoMachSC); + DECLARE("bbNoMachSCbit",bbNoMachSCbit); DECLARE("bbPreemptive", bbPreemptive); + DECLARE("bbPreemptivebit", bbPreemptivebit); + 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)); @@ -191,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_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("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("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)); @@ -231,24 +175,16 @@ int main(int argc, char *argv[]) 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("pfLClck", pfLClck); - DECLARE("pfLClckb", pfLClckb); - DECLARE("pfWillNap", pfWillNap); - DECLARE("pfWillNapb", pfWillNapb); - DECLARE("pfNoMSRir", pfNoMSRir); - DECLARE("pfNoMSRirb", pfNoMSRirb); - DECLARE("pfL1nnc", pfL1nnc); - DECLARE("pfL1nncb", pfL1nncb); - DECLARE("pfL1i", pfL1i); - DECLARE("pfL1ib", pfL1ib); - DECLARE("pfL1d", pfL1d); - DECLARE("pfL1db", pfL1db); + DECLARE("pfSlowNap", pfSlowNap); + DECLARE("pfSlowNapb", pfSlowNapb); + DECLARE("pfNoMuMMCK", pfNoMuMMCK); + DECLARE("pfNoMuMMCKb", pfNoMuMMCKb); + 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); @@ -257,6 +193,20 @@ int main(int argc, char *argv[]) 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); @@ -275,22 +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("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("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("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("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)); @@ -360,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("skipListPrev", offsetof(struct per_proc_info *, skipListPrev)); 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("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 @@ -373,50 +476,41 @@ int main(int argc, char *argv[]) #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 - DECLARE("CTHREAD_SELF", offsetof(struct thread_activation *, mact.cthread_self)); + DECLARE("CTHREAD_SELF", offsetof(thread_t, machine.cthread_self)); #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); @@ -432,8 +526,26 @@ int main(int argc, char *argv[]) DECLARE("kVmmGetFloatState", kVmmGetFloatState); DECLARE("kVmmGetVectorState", kVmmGetVectorState); DECLARE("kVmmSetTimer", kVmmSetTimer); + DECLARE("kVmmGetTimer", kVmmGetTimer); 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); @@ -444,6 +556,7 @@ int main(int argc, char *argv[]) DECLARE("kVmmReturnProgramException", kVmmReturnProgramException); DECLARE("kVmmReturnSystemCall", kVmmReturnSystemCall); DECLARE("kVmmReturnTraceException", kVmmReturnTraceException); + DECLARE("kVmmInvalidAdSpace", kVmmInvalidAdSpace); DECLARE("kVmmProtXtnd", kVmmProtXtnd); DECLARE("kVmmProtNARW", kVmmProtNARW); @@ -452,39 +565,176 @@ int main(int argc, char *argv[]) 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("vmmPmap", offsetof(struct vmmCntrlEntry *, vmmPmap)); DECLARE("vmmContextKern", offsetof(struct vmmCntrlEntry *, vmmContextKern)); + DECLARE("vmmContextPhys", offsetof(struct vmmCntrlEntry *, vmmContextPhys)); 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("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("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_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)); +#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("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("vmmMapDone", vmmMapDone); - DECLARE("vmmMapDoneb", vmmMapDoneb); + DECLARE("vmmFAMmode", vmmFAMmode); + DECLARE("vmmFAMmodeb", vmmFAMmodeb); DECLARE("vmmSpfSave", vmmSpfSave); DECLARE("vmmSpfSaveb", vmmSpfSaveb); DECLARE("vmmFloatLoad", vmmFloatLoad); @@ -501,137 +751,184 @@ int main(int argc, char *argv[]) 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 */ - 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 */ - DECLARE("VMMAP_PMAP", offsetof(struct vm_map *, pmap)); + DECLARE("VMMAP_PMAP", offsetof(struct _vm_map *, pmap)); /* 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 */ - 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("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); + 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 */ - 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); -#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)); @@ -641,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_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)); @@ -650,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_r6", offsetof(struct LowTraceRecord *, LTR_r6)); DECLARE("LTR_size", sizeof(struct LowTraceRecord)); /* Values from pexpert.h */ @@ -657,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("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("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("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("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)); @@ -719,9 +1148,6 @@ int main(int argc, char *argv[]) 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); @@ -730,12 +1156,16 @@ int main(int argc, char *argv[]) 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("disLkNmSimp", disLkNmSimp); - DECLARE("disLkNmSimpb", disLkNmSimpb); + DECLARE("enaLkExtStck", enaLkExtStck); + DECLARE("enaLkExtStckb",enaLkExtStckb); DECLARE("disLkMyLck", disLkMyLck); DECLARE("disLkMyLckb", disLkMyLckb); DECLARE("dgMisc1", offsetof(struct diagWork *, dgMisc1)); @@ -744,45 +1174,67 @@ int main(int argc, char *argv[]) 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("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("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("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)); @@ -816,92 +1268,72 @@ int main(int argc, char *argv[]) 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)); @@ -942,21 +1374,65 @@ int main(int argc, char *argv[]) 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_970", CPU_SUBTYPE_POWERPC_970); + 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 :-) */ }