991 lines
29 KiB
C
991 lines
29 KiB
C
/*++
|
||
|
||
Copyright (c) 1990 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
genppc.c
|
||
|
||
Abstract:
|
||
|
||
This module implements a program which generates PPC machine dependent
|
||
structure offset definitions for kernel structures that are accessed in
|
||
assembly code.
|
||
|
||
Author:
|
||
|
||
David N. Cutler (davec) 27-Mar-1990
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
#include "ki.h"
|
||
#pragma hdrstop
|
||
|
||
#define HEADER_FILE
|
||
|
||
#include "excpt.h"
|
||
#include "ctype.h"
|
||
#include "stdio.h"
|
||
#include "stdarg.h"
|
||
#include "stdlib.h"
|
||
|
||
#if defined(_M_IX86) // IBMCDB
|
||
|
||
#define _RESTORE_P386_DEF _M_IX86
|
||
#define _M_PPC 1
|
||
#define R4000 1
|
||
#undef i386
|
||
#undef _X86_
|
||
#undef _M_IX86
|
||
|
||
#endif
|
||
|
||
#include "nt.h"
|
||
#include "ntdef.h"
|
||
#include "ntkeapi.h"
|
||
#include "ntppc.h"
|
||
#include "ntimage.h"
|
||
#include "ntseapi.h"
|
||
#include "ntobapi.h"
|
||
#include "ntlpcapi.h"
|
||
#include "ntioapi.h"
|
||
#include "ntmmapi.h"
|
||
#include "ntldr.h"
|
||
#include "ntpsapi.h"
|
||
#include "ntexapi.h"
|
||
#include "ntnls.h"
|
||
#include "ntrtl.h"
|
||
#include "nturtl.h"
|
||
#include "ntcsrmsg.h"
|
||
#include "ntcsrsrv.h"
|
||
#include "ntosdef.h"
|
||
#include "ntxcapi.h"
|
||
#include "ppc.h"
|
||
#include "arc.h"
|
||
#include "ke.h"
|
||
#include "ex.h"
|
||
#include "ps.h"
|
||
#include "bugcodes.h"
|
||
#include "ntstatus.h"
|
||
#include "exboosts.h"
|
||
#include "ppcdef.h"
|
||
#include "setjmp.h"
|
||
|
||
#if defined(RESTORE_P386_DEF) // IBMCDB
|
||
|
||
#undef _MSC_VER 800
|
||
#define _M_IX86 RESTORE_P386_DEF
|
||
|
||
#endif
|
||
|
||
//
|
||
// Define architecture specific generation macros.
|
||
//
|
||
|
||
#define genAlt(Name, Type, Member) \
|
||
dumpf("#define " #Name " 0x%lx\n", OFFSET(Type, Member))
|
||
|
||
#define genCom(Comment) \
|
||
dumpf("\n"); \
|
||
dumpf("//\n"); \
|
||
dumpf("// " Comment "\n"); \
|
||
dumpf("//\n"); \
|
||
dumpf("\n")
|
||
|
||
#define genDef(Prefix, Type, Member) \
|
||
dumpf("#define " #Prefix #Member " 0x%lx\n", OFFSET(Type, Member))
|
||
|
||
#define genVal(Name, Value) \
|
||
dumpf("#define " #Name " 0x%lx\n", Value)
|
||
|
||
#define genSpc() dumpf("\n");
|
||
|
||
//
|
||
// Define member offset computation macro.
|
||
//
|
||
|
||
#define OFFSET(type, field) ((LONG)(&((type *)0)->field))
|
||
|
||
FILE *KsPpc;
|
||
FILE *HalPpc;
|
||
|
||
//
|
||
// EnableInc(a) - Enables output to goto specified include file
|
||
//
|
||
|
||
#define EnableInc(a) OutputEnabled |= a;
|
||
|
||
//
|
||
// DisableInc(a) - Disables output to goto specified include file
|
||
//
|
||
|
||
#define DisableInc(a) OutputEnabled &= ~a;
|
||
|
||
ULONG OutputEnabled;
|
||
|
||
#define KSPPC 0x01
|
||
#define HALPPC 0x02
|
||
|
||
#define KERNEL KSPPC
|
||
#define HAL HALPPC
|
||
|
||
VOID dumpf (const char *format, ...);
|
||
|
||
|
||
//
|
||
// This routine returns the bit number right to left of a field.
|
||
//
|
||
|
||
LONG
|
||
t (
|
||
IN ULONG z
|
||
)
|
||
|
||
{
|
||
LONG i;
|
||
|
||
for (i = 0; i < 32; i += 1) {
|
||
if ((z >> i) & 1) {
|
||
break;
|
||
}
|
||
}
|
||
return i;
|
||
}
|
||
|
||
//
|
||
// This program generates the PPC machine dependent assembler offset
|
||
// definitions.
|
||
//
|
||
|
||
VOID
|
||
main (argc, argv)
|
||
int argc;
|
||
char *argv[];
|
||
{
|
||
|
||
char *outName;
|
||
LONG EventOffset;
|
||
|
||
//
|
||
// Create file for output.
|
||
//
|
||
|
||
if (argc == 2) {
|
||
outName = argv[ 1 ];
|
||
} else {
|
||
outName = "\\nt\\public\\sdk\\inc\\ksppc.h";
|
||
}
|
||
outName = argc >= 2 ? argv[1] : "\\nt\\public\\sdk\\inc\\ksppc.h";
|
||
KsPpc = fopen( outName, "w" );
|
||
|
||
if (KsPpc == NULL) {
|
||
fprintf( stderr, "GENPPC: Cannot open %s for writing.\n", outName);
|
||
perror("GENPPC");
|
||
exit(1);
|
||
}
|
||
|
||
fprintf( stderr, "GENPPC: Writing %s header file.\n", outName );
|
||
|
||
outName = argc >= 3 ? argv[2] : "\\nt\\private\\ntos\\inc\\halppc.h";
|
||
|
||
HalPpc = fopen( outName, "w" );
|
||
|
||
if (HalPpc == NULL) {
|
||
fprintf( stderr, "GENPPC: Cannot open %s for writing.\n", outName);
|
||
perror("GENPPC");
|
||
exit(1);
|
||
}
|
||
|
||
fprintf( stderr, "GENPPC: Writing %s header file.\n", outName );
|
||
|
||
//
|
||
// Include statement for PPC architecture static definitions.
|
||
//
|
||
|
||
EnableInc (KSPPC | HALPPC);
|
||
|
||
dumpf("#include \"kxppc.h\"\n");
|
||
|
||
DisableInc (HALPPC);
|
||
|
||
//
|
||
// Include architecture independent definitions.
|
||
//
|
||
|
||
#include "..\genxx.inc"
|
||
|
||
//
|
||
// Generate architecture dependent definitions.
|
||
//
|
||
// Processor control register structure definitions.
|
||
//
|
||
|
||
EnableInc (HALPPC);
|
||
|
||
genCom("Processor Control Registers Structure Offset Definitions");
|
||
|
||
genVal(PCR_MINOR_VERSION, PCR_MINOR_VERSION);
|
||
genVal(PCR_MAJOR_VERSION, PCR_MAJOR_VERSION);
|
||
|
||
genSpc();
|
||
|
||
genDef(Pc, KPCR, MinorVersion);
|
||
genDef(Pc, KPCR, MajorVersion);
|
||
genDef(Pc, KPCR, InterruptRoutine);
|
||
genDef(Pc, KPCR, PcrPage2);
|
||
genDef(Pc, KPCR, Kseg0Top);
|
||
genDef(Pc, KPCR, FirstLevelDcacheSize);
|
||
genDef(Pc, KPCR, FirstLevelDcacheFillSize);
|
||
genDef(Pc, KPCR, FirstLevelIcacheSize);
|
||
genDef(Pc, KPCR, FirstLevelIcacheFillSize);
|
||
genDef(Pc, KPCR, SecondLevelDcacheSize);
|
||
genDef(Pc, KPCR, SecondLevelDcacheFillSize);
|
||
genDef(Pc, KPCR, SecondLevelIcacheSize);
|
||
genDef(Pc, KPCR, SecondLevelIcacheFillSize);
|
||
genDef(Pc, KPCR, Prcb);
|
||
genDef(Pc, KPCR, Teb);
|
||
genDef(Pc, KPCR, DcacheAlignment);
|
||
genDef(Pc, KPCR, DcacheFillSize);
|
||
genDef(Pc, KPCR, IcacheAlignment);
|
||
genDef(Pc, KPCR, IcacheFillSize);
|
||
genDef(Pc, KPCR, ProcessorVersion);
|
||
genDef(Pc, KPCR, ProcessorRevision);
|
||
genDef(Pc, KPCR, ProfileInterval);
|
||
genDef(Pc, KPCR, ProfileCount);
|
||
genDef(Pc, KPCR, StallExecutionCount);
|
||
genDef(Pc, KPCR, StallScaleFactor);
|
||
genDef(Pc, KPCR, CachePolicy);
|
||
genDef(Pc, KPCR, IcacheMode);
|
||
genDef(Pc, KPCR, DcacheMode);
|
||
genDef(Pc, KPCR, IrqlMask);
|
||
genDef(Pc, KPCR, IrqlTable);
|
||
genDef(Pc, KPCR, CurrentIrql);
|
||
genDef(Pc, KPCR, Number);
|
||
genDef(Pc, KPCR, SetMember);
|
||
genDef(Pc, KPCR, CurrentThread);
|
||
genDef(Pc, KPCR, AlignedCachePolicy);
|
||
genDef(Pc, KPCR, SoftwareInterrupt);
|
||
genDef(Pc, KPCR, ApcInterrupt);
|
||
genDef(Pc, KPCR, DispatchInterrupt);
|
||
genDef(Pc, KPCR, NotMember);
|
||
genDef(Pc, KPCR, SystemReserved);
|
||
genDef(Pc, KPCR, HalReserved);
|
||
|
||
DisableInc (HALPPC);
|
||
|
||
genDef(Pc, KPCR, FirstLevelActive);
|
||
genDef(Pc, KPCR, SystemServiceDispatchStart);
|
||
genDef(Pc, KPCR, SystemServiceDispatchEnd);
|
||
genDef(Pc, KPCR, InterruptStack);
|
||
genDef(Pc, KPCR, QuantumEnd);
|
||
genDef(Pc, KPCR, InitialStack);
|
||
genDef(Pc, KPCR, PanicStack);
|
||
genDef(Pc, KPCR, BadVaddr);
|
||
genDef(Pc, KPCR, StackLimit);
|
||
genDef(Pc, KPCR, SavedStackLimit);
|
||
genDef(Pc, KPCR, SavedV0);
|
||
genDef(Pc, KPCR, SavedV1);
|
||
genDef(Pc, KPCR, DebugActive);
|
||
genDef(Pc, KPCR, GprSave);
|
||
genDef(Pc, KPCR, SiR0);
|
||
genDef(Pc, KPCR, SiR2);
|
||
genDef(Pc, KPCR, SiR3);
|
||
genDef(Pc, KPCR, SiR4);
|
||
genDef(Pc, KPCR, SiR5);
|
||
genDef(Pc, KPCR, PgDirRa);
|
||
genDef(Pc, KPCR, OnInterruptStack);
|
||
genDef(Pc, KPCR, SavedInitialStack);
|
||
|
||
genVal(ProcessorControlRegisterLength, ((sizeof(KPCR) + 15) & ~15));
|
||
|
||
genSpc();
|
||
|
||
genDef(Pc2, KUSER_SHARED_DATA, TickCountLow);
|
||
genDef(Pc2, KUSER_SHARED_DATA, TickCountMultiplier);
|
||
genDef(Pc2, KUSER_SHARED_DATA, InterruptTime);
|
||
genDef(Pc2, KUSER_SHARED_DATA, SystemTime);
|
||
|
||
//
|
||
// Offsets to elements within the InterruptRoutine table.
|
||
//
|
||
|
||
genSpc();
|
||
|
||
genVal(IrPmiVector, sizeof(unsigned) * PMI_VECTOR);
|
||
genVal(IrMachineCheckVector, sizeof(unsigned) * MACHINE_CHECK_VECTOR);
|
||
genVal(IrDeviceVector, sizeof(unsigned) * EXTERNAL_INTERRUPT_VECTOR);
|
||
genVal(IrDecrementVector, sizeof(unsigned) * DECREMENT_VECTOR);
|
||
|
||
//
|
||
// Processor block structure definitions.
|
||
//
|
||
|
||
EnableInc (HALPPC);
|
||
|
||
genCom("Processor Block Structure Offset Definitions");
|
||
|
||
genVal(PRCB_MINOR_VERSION, PRCB_MINOR_VERSION);
|
||
genVal(PRCB_MAJOR_VERSION, PRCB_MAJOR_VERSION);
|
||
|
||
genSpc();
|
||
|
||
genDef(Pb, KPRCB, MinorVersion);
|
||
genDef(Pb, KPRCB, MajorVersion);
|
||
genDef(Pb, KPRCB, CurrentThread);
|
||
genDef(Pb, KPRCB, NextThread);
|
||
genDef(Pb, KPRCB, IdleThread);
|
||
genDef(Pb, KPRCB, Number);
|
||
genDef(Pb, KPRCB, SetMember);
|
||
genDef(Pb, KPRCB, RestartBlock);
|
||
genDef(Pb, KPRCB, PcrPage);
|
||
genDef(Pb, KPRCB, SystemReserved);
|
||
genDef(Pb, KPRCB, HalReserved);
|
||
|
||
DisableInc (HALPPC);
|
||
|
||
genDef(Pb, KPRCB, DpcTime);
|
||
genDef(Pb, KPRCB, InterruptTime);
|
||
genDef(Pb, KPRCB, KernelTime);
|
||
genDef(Pb, KPRCB, UserTime);
|
||
genDef(Pb, KPRCB, AdjustDpcThreshold);
|
||
genDef(Pb, KPRCB, InterruptCount);
|
||
genDef(Pb, KPRCB, ApcBypassCount);
|
||
genDef(Pb, KPRCB, DpcBypassCount);
|
||
genDef(Pb, KPRCB, IpiFrozen);
|
||
genDef(Pb, KPRCB, ProcessorState);
|
||
genAlt(PbAlignmentFixupCount, KPRCB, KeAlignmentFixupCount);
|
||
genAlt(PbContextSwitches, KPRCB, KeContextSwitches);
|
||
genAlt(PbDcacheFlushCount, KPRCB, KeDcacheFlushCount);
|
||
genAlt(PbExceptionDispatchCount, KPRCB, KeExceptionDispatchCount);
|
||
genAlt(PbFirstLevelTbFills, KPRCB, KeFirstLevelTbFills);
|
||
genAlt(PbFloatingEmulationCount, KPRCB, KeFloatingEmulationCount);
|
||
genAlt(PbIcacheFlushCount, KPRCB, KeIcacheFlushCount);
|
||
genAlt(PbSecondLevelTbFills, KPRCB, KeSecondLevelTbFills);
|
||
genAlt(PbSystemCalls, KPRCB, KeSystemCalls);
|
||
genDef(Pb, KPRCB, CurrentPacket);
|
||
genDef(Pb, KPRCB, TargetSet);
|
||
genDef(Pb, KPRCB, WorkerRoutine);
|
||
genDef(Pb, KPRCB, RequestSummary);
|
||
genDef(Pb, KPRCB, SignalDone);
|
||
genDef(Pb, KPRCB, DpcInterruptRequested);
|
||
genDef(Pb, KPRCB, MaximumDpcQueueDepth);
|
||
genDef(Pb, KPRCB, MinimumDpcRate);
|
||
genDef(Pb, KPRCB, IpiCounts);
|
||
genDef(Pb, KPRCB, StartCount);
|
||
genDef(Pb, KPRCB, DpcLock);
|
||
genDef(Pb, KPRCB, DpcListHead);
|
||
genDef(Pb, KPRCB, DpcQueueDepth);
|
||
genDef(Pb, KPRCB, DpcCount);
|
||
genDef(Pb, KPRCB, DpcLastCount);
|
||
genDef(Pb, KPRCB, DpcRequestRate);
|
||
genDef(Pb, KPRCB, DpcRoutineActive);
|
||
genVal(ProcessorBlockLength, ((sizeof(KPRCB) + 15) & ~15));
|
||
|
||
//
|
||
// Immediate interprocessor command definitions.
|
||
//
|
||
|
||
genCom("Immediate Interprocessor Command Definitions");
|
||
|
||
genVal(IPI_APC, IPI_APC);
|
||
genVal(IPI_DPC, IPI_DPC);
|
||
genVal(IPI_FREEZE, IPI_FREEZE);
|
||
genVal(IPI_PACKET_READY, IPI_PACKET_READY);
|
||
|
||
//
|
||
// Interprocessor interrupt count structure offset definitions.
|
||
//
|
||
|
||
genCom("Interprocessor Interrupt Count Structure Offset Definitions");
|
||
|
||
genDef(Ic, KIPI_COUNTS, Freeze);
|
||
genDef(Ic, KIPI_COUNTS, Packet);
|
||
genDef(Ic, KIPI_COUNTS, DPC);
|
||
genDef(Ic, KIPI_COUNTS, APC);
|
||
genDef(Ic, KIPI_COUNTS, FlushSingleTb);
|
||
genDef(Ic, KIPI_COUNTS, FlushEntireTb);
|
||
genDef(Ic, KIPI_COUNTS, ChangeColor);
|
||
genDef(Ic, KIPI_COUNTS, SweepDcache);
|
||
genDef(Ic, KIPI_COUNTS, SweepIcache);
|
||
genDef(Ic, KIPI_COUNTS, SweepIcacheRange);
|
||
genDef(Ic, KIPI_COUNTS, FlushIoBuffers);
|
||
|
||
//
|
||
// Context frame offset definitions and flag definitions.
|
||
//
|
||
|
||
EnableInc (HALPPC);
|
||
|
||
genCom("Context Frame Offset and Flag Definitions");
|
||
|
||
genVal(CONTEXT_FULL, CONTEXT_FULL);
|
||
genVal(CONTEXT_CONTROL, CONTEXT_CONTROL);
|
||
genVal(CONTEXT_FLOATING_POINT, CONTEXT_FLOATING_POINT);
|
||
genVal(CONTEXT_INTEGER, CONTEXT_INTEGER);
|
||
|
||
genSpc();
|
||
|
||
genDef(Cx, CONTEXT, Fpr0);
|
||
genDef(Cx, CONTEXT, Fpr1);
|
||
genDef(Cx, CONTEXT, Fpr2);
|
||
genDef(Cx, CONTEXT, Fpr3);
|
||
genDef(Cx, CONTEXT, Fpr4);
|
||
genDef(Cx, CONTEXT, Fpr5);
|
||
genDef(Cx, CONTEXT, Fpr6);
|
||
genDef(Cx, CONTEXT, Fpr7);
|
||
genDef(Cx, CONTEXT, Fpr8);
|
||
genDef(Cx, CONTEXT, Fpr9);
|
||
genDef(Cx, CONTEXT, Fpr10);
|
||
genDef(Cx, CONTEXT, Fpr11);
|
||
genDef(Cx, CONTEXT, Fpr12);
|
||
genDef(Cx, CONTEXT, Fpr13);
|
||
genDef(Cx, CONTEXT, Fpr14);
|
||
genDef(Cx, CONTEXT, Fpr15);
|
||
genDef(Cx, CONTEXT, Fpr16);
|
||
genDef(Cx, CONTEXT, Fpr17);
|
||
genDef(Cx, CONTEXT, Fpr18);
|
||
genDef(Cx, CONTEXT, Fpr19);
|
||
genDef(Cx, CONTEXT, Fpr20);
|
||
genDef(Cx, CONTEXT, Fpr21);
|
||
genDef(Cx, CONTEXT, Fpr22);
|
||
genDef(Cx, CONTEXT, Fpr23);
|
||
genDef(Cx, CONTEXT, Fpr24);
|
||
genDef(Cx, CONTEXT, Fpr25);
|
||
genDef(Cx, CONTEXT, Fpr26);
|
||
genDef(Cx, CONTEXT, Fpr27);
|
||
genDef(Cx, CONTEXT, Fpr28);
|
||
genDef(Cx, CONTEXT, Fpr29);
|
||
genDef(Cx, CONTEXT, Fpr30);
|
||
genDef(Cx, CONTEXT, Fpr31);
|
||
genDef(Cx, CONTEXT, Fpscr);
|
||
genDef(Cx, CONTEXT, Gpr0);
|
||
genDef(Cx, CONTEXT, Gpr1);
|
||
genDef(Cx, CONTEXT, Gpr2);
|
||
genDef(Cx, CONTEXT, Gpr3);
|
||
genDef(Cx, CONTEXT, Gpr4);
|
||
genDef(Cx, CONTEXT, Gpr5);
|
||
genDef(Cx, CONTEXT, Gpr6);
|
||
genDef(Cx, CONTEXT, Gpr7);
|
||
genDef(Cx, CONTEXT, Gpr8);
|
||
genDef(Cx, CONTEXT, Gpr9);
|
||
genDef(Cx, CONTEXT, Gpr10);
|
||
genDef(Cx, CONTEXT, Gpr11);
|
||
genDef(Cx, CONTEXT, Gpr12);
|
||
genDef(Cx, CONTEXT, Gpr13);
|
||
genDef(Cx, CONTEXT, Gpr14);
|
||
genDef(Cx, CONTEXT, Gpr15);
|
||
genDef(Cx, CONTEXT, Gpr16);
|
||
genDef(Cx, CONTEXT, Gpr17);
|
||
genDef(Cx, CONTEXT, Gpr18);
|
||
genDef(Cx, CONTEXT, Gpr19);
|
||
genDef(Cx, CONTEXT, Gpr20);
|
||
genDef(Cx, CONTEXT, Gpr21);
|
||
genDef(Cx, CONTEXT, Gpr22);
|
||
genDef(Cx, CONTEXT, Gpr23);
|
||
genDef(Cx, CONTEXT, Gpr24);
|
||
genDef(Cx, CONTEXT, Gpr25);
|
||
genDef(Cx, CONTEXT, Gpr26);
|
||
genDef(Cx, CONTEXT, Gpr27);
|
||
genDef(Cx, CONTEXT, Gpr28);
|
||
genDef(Cx, CONTEXT, Gpr29);
|
||
genDef(Cx, CONTEXT, Gpr30);
|
||
genDef(Cx, CONTEXT, Gpr31);
|
||
genDef(Cx, CONTEXT, Cr);
|
||
genDef(Cx, CONTEXT, Xer);
|
||
genDef(Cx, CONTEXT, Msr);
|
||
genDef(Cx, CONTEXT, Iar);
|
||
genDef(Cx, CONTEXT, Lr);
|
||
genDef(Cx, CONTEXT, Ctr);
|
||
genDef(Cx, CONTEXT, ContextFlags);
|
||
genDef(Cx, CONTEXT, Dr0);
|
||
genDef(Cx, CONTEXT, Dr1);
|
||
genDef(Cx, CONTEXT, Dr2);
|
||
genDef(Cx, CONTEXT, Dr3);
|
||
genDef(Cx, CONTEXT, Dr4);
|
||
genDef(Cx, CONTEXT, Dr5);
|
||
genDef(Cx, CONTEXT, Dr6);
|
||
genDef(Cx, CONTEXT, Dr7);
|
||
|
||
genVal(ContextFrameLength, (sizeof(CONTEXT) + 15) & (~15));
|
||
|
||
//
|
||
// Call/return stack frame header offset definitions.
|
||
//
|
||
|
||
genCom("Call/Return Stack Frame Header Offset Definitions and Length");
|
||
|
||
genDef(Cr, STACK_FRAME_HEADER, BackChain);
|
||
genDef(Cr, STACK_FRAME_HEADER, GlueSaved1);
|
||
genDef(Cr, STACK_FRAME_HEADER, GlueSaved2);
|
||
genDef(Cr, STACK_FRAME_HEADER, Reserved1);
|
||
genDef(Cr, STACK_FRAME_HEADER, Spare1);
|
||
genDef(Cr, STACK_FRAME_HEADER, Spare2);
|
||
|
||
genDef(Cr, STACK_FRAME_HEADER, Parameter0);
|
||
genDef(Cr, STACK_FRAME_HEADER, Parameter1);
|
||
genDef(Cr, STACK_FRAME_HEADER, Parameter2);
|
||
genDef(Cr, STACK_FRAME_HEADER, Parameter3);
|
||
genDef(Cr, STACK_FRAME_HEADER, Parameter4);
|
||
genDef(Cr, STACK_FRAME_HEADER, Parameter5);
|
||
genDef(Cr, STACK_FRAME_HEADER, Parameter6);
|
||
genDef(Cr, STACK_FRAME_HEADER, Parameter7);
|
||
|
||
genVal(StackFrameHeaderLength, (sizeof(STACK_FRAME_HEADER) + 7) & (~7));
|
||
|
||
//
|
||
// Exception frame offset definitions.
|
||
//
|
||
|
||
genCom("Exception Frame Offset Definitions and Length");
|
||
|
||
genDef(Ex, KEXCEPTION_FRAME, Gpr13);
|
||
genDef(Ex, KEXCEPTION_FRAME, Gpr14);
|
||
genDef(Ex, KEXCEPTION_FRAME, Gpr15);
|
||
genDef(Ex, KEXCEPTION_FRAME, Gpr16);
|
||
genDef(Ex, KEXCEPTION_FRAME, Gpr17);
|
||
genDef(Ex, KEXCEPTION_FRAME, Gpr18);
|
||
genDef(Ex, KEXCEPTION_FRAME, Gpr19);
|
||
genDef(Ex, KEXCEPTION_FRAME, Gpr20);
|
||
genDef(Ex, KEXCEPTION_FRAME, Gpr21);
|
||
genDef(Ex, KEXCEPTION_FRAME, Gpr22);
|
||
genDef(Ex, KEXCEPTION_FRAME, Gpr23);
|
||
genDef(Ex, KEXCEPTION_FRAME, Gpr24);
|
||
genDef(Ex, KEXCEPTION_FRAME, Gpr25);
|
||
genDef(Ex, KEXCEPTION_FRAME, Gpr26);
|
||
genDef(Ex, KEXCEPTION_FRAME, Gpr27);
|
||
genDef(Ex, KEXCEPTION_FRAME, Gpr28);
|
||
genDef(Ex, KEXCEPTION_FRAME, Gpr29);
|
||
genDef(Ex, KEXCEPTION_FRAME, Gpr30);
|
||
genDef(Ex, KEXCEPTION_FRAME, Gpr31);
|
||
|
||
genDef(Ex, KEXCEPTION_FRAME, Fpr14);
|
||
genDef(Ex, KEXCEPTION_FRAME, Fpr15);
|
||
genDef(Ex, KEXCEPTION_FRAME, Fpr16);
|
||
genDef(Ex, KEXCEPTION_FRAME, Fpr17);
|
||
genDef(Ex, KEXCEPTION_FRAME, Fpr18);
|
||
genDef(Ex, KEXCEPTION_FRAME, Fpr19);
|
||
genDef(Ex, KEXCEPTION_FRAME, Fpr20);
|
||
genDef(Ex, KEXCEPTION_FRAME, Fpr21);
|
||
genDef(Ex, KEXCEPTION_FRAME, Fpr22);
|
||
genDef(Ex, KEXCEPTION_FRAME, Fpr23);
|
||
genDef(Ex, KEXCEPTION_FRAME, Fpr24);
|
||
genDef(Ex, KEXCEPTION_FRAME, Fpr25);
|
||
genDef(Ex, KEXCEPTION_FRAME, Fpr26);
|
||
genDef(Ex, KEXCEPTION_FRAME, Fpr27);
|
||
genDef(Ex, KEXCEPTION_FRAME, Fpr28);
|
||
genDef(Ex, KEXCEPTION_FRAME, Fpr29);
|
||
genDef(Ex, KEXCEPTION_FRAME, Fpr30);
|
||
genDef(Ex, KEXCEPTION_FRAME, Fpr31);
|
||
|
||
genVal(ExceptionFrameLength, (sizeof(KEXCEPTION_FRAME) + 7) & (~7));
|
||
|
||
//
|
||
// Swap Frame offset definitions.
|
||
//
|
||
|
||
DisableInc (HALPPC);
|
||
|
||
genCom("Swap Frame Definitions and Length");
|
||
|
||
genDef(Sw, KSWAP_FRAME, ConditionRegister);
|
||
genDef(Sw, KSWAP_FRAME, SwapReturn);
|
||
|
||
genVal(SwapFrameLength, (sizeof(KSWAP_FRAME) + 7) & (~7));
|
||
|
||
EnableInc (HALPPC);
|
||
|
||
//
|
||
// Jump buffer offset definitions.
|
||
//
|
||
|
||
DisableInc (HALPPC);
|
||
|
||
genCom("Jump Offset Definitions and Length");
|
||
|
||
genDef(Jb, _JUMP_BUFFER, Fpr14);
|
||
genDef(Jb, _JUMP_BUFFER, Fpr15);
|
||
genDef(Jb, _JUMP_BUFFER, Fpr16);
|
||
genDef(Jb, _JUMP_BUFFER, Fpr17);
|
||
genDef(Jb, _JUMP_BUFFER, Fpr18);
|
||
genDef(Jb, _JUMP_BUFFER, Fpr19);
|
||
genDef(Jb, _JUMP_BUFFER, Fpr20);
|
||
genDef(Jb, _JUMP_BUFFER, Fpr21);
|
||
genDef(Jb, _JUMP_BUFFER, Fpr22);
|
||
genDef(Jb, _JUMP_BUFFER, Fpr23);
|
||
genDef(Jb, _JUMP_BUFFER, Fpr24);
|
||
genDef(Jb, _JUMP_BUFFER, Fpr25);
|
||
genDef(Jb, _JUMP_BUFFER, Fpr26);
|
||
genDef(Jb, _JUMP_BUFFER, Fpr27);
|
||
genDef(Jb, _JUMP_BUFFER, Fpr28);
|
||
genDef(Jb, _JUMP_BUFFER, Fpr29);
|
||
genDef(Jb, _JUMP_BUFFER, Fpr30);
|
||
genDef(Jb, _JUMP_BUFFER, Fpr31);
|
||
|
||
genDef(Jb, _JUMP_BUFFER, Gpr1);
|
||
genDef(Jb, _JUMP_BUFFER, Gpr2);
|
||
genDef(Jb, _JUMP_BUFFER, Gpr13);
|
||
genDef(Jb, _JUMP_BUFFER, Gpr14);
|
||
genDef(Jb, _JUMP_BUFFER, Gpr15);
|
||
genDef(Jb, _JUMP_BUFFER, Gpr16);
|
||
genDef(Jb, _JUMP_BUFFER, Gpr17);
|
||
genDef(Jb, _JUMP_BUFFER, Gpr18);
|
||
genDef(Jb, _JUMP_BUFFER, Gpr19);
|
||
genDef(Jb, _JUMP_BUFFER, Gpr20);
|
||
genDef(Jb, _JUMP_BUFFER, Gpr21);
|
||
genDef(Jb, _JUMP_BUFFER, Gpr22);
|
||
genDef(Jb, _JUMP_BUFFER, Gpr23);
|
||
genDef(Jb, _JUMP_BUFFER, Gpr24);
|
||
genDef(Jb, _JUMP_BUFFER, Gpr25);
|
||
genDef(Jb, _JUMP_BUFFER, Gpr26);
|
||
genDef(Jb, _JUMP_BUFFER, Gpr27);
|
||
genDef(Jb, _JUMP_BUFFER, Gpr28);
|
||
genDef(Jb, _JUMP_BUFFER, Gpr29);
|
||
genDef(Jb, _JUMP_BUFFER, Gpr30);
|
||
genDef(Jb, _JUMP_BUFFER, Gpr31);
|
||
|
||
genDef(Jb, _JUMP_BUFFER, Cr);
|
||
genDef(Jb, _JUMP_BUFFER, Iar);
|
||
genDef(Jb, _JUMP_BUFFER, Type);
|
||
|
||
//
|
||
// Trap frame offset definitions.
|
||
//
|
||
|
||
EnableInc (HALPPC);
|
||
|
||
genCom("Trap Frame Offset Definitions and Length");
|
||
|
||
genDef(Tr, KTRAP_FRAME, TrapFrame);
|
||
genDef(Tr, KTRAP_FRAME, OldIrql);
|
||
genDef(Tr, KTRAP_FRAME, PreviousMode);
|
||
genDef(Tr, KTRAP_FRAME, SavedApcStateIndex);
|
||
genDef(Tr, KTRAP_FRAME, SavedKernelApcDisable);
|
||
genDef(Tr, KTRAP_FRAME, ExceptionRecord);
|
||
|
||
genDef(Tr, KTRAP_FRAME, Gpr0);
|
||
genDef(Tr, KTRAP_FRAME, Gpr1);
|
||
genDef(Tr, KTRAP_FRAME, Gpr2);
|
||
genDef(Tr, KTRAP_FRAME, Gpr3);
|
||
genDef(Tr, KTRAP_FRAME, Gpr4);
|
||
genDef(Tr, KTRAP_FRAME, Gpr5);
|
||
genDef(Tr, KTRAP_FRAME, Gpr6);
|
||
genDef(Tr, KTRAP_FRAME, Gpr7);
|
||
genDef(Tr, KTRAP_FRAME, Gpr8);
|
||
genDef(Tr, KTRAP_FRAME, Gpr9);
|
||
genDef(Tr, KTRAP_FRAME, Gpr10);
|
||
genDef(Tr, KTRAP_FRAME, Gpr11);
|
||
genDef(Tr, KTRAP_FRAME, Gpr12);
|
||
|
||
genDef(Tr, KTRAP_FRAME, Fpr0);
|
||
genDef(Tr, KTRAP_FRAME, Fpr1);
|
||
genDef(Tr, KTRAP_FRAME, Fpr2);
|
||
genDef(Tr, KTRAP_FRAME, Fpr3);
|
||
genDef(Tr, KTRAP_FRAME, Fpr4);
|
||
genDef(Tr, KTRAP_FRAME, Fpr5);
|
||
genDef(Tr, KTRAP_FRAME, Fpr6);
|
||
genDef(Tr, KTRAP_FRAME, Fpr7);
|
||
genDef(Tr, KTRAP_FRAME, Fpr8);
|
||
genDef(Tr, KTRAP_FRAME, Fpr9);
|
||
genDef(Tr, KTRAP_FRAME, Fpr10);
|
||
genDef(Tr, KTRAP_FRAME, Fpr11);
|
||
genDef(Tr, KTRAP_FRAME, Fpr12);
|
||
genDef(Tr, KTRAP_FRAME, Fpr13);
|
||
|
||
genDef(Tr, KTRAP_FRAME, Fpscr);
|
||
genDef(Tr, KTRAP_FRAME, Cr);
|
||
genDef(Tr, KTRAP_FRAME, Xer);
|
||
genDef(Tr, KTRAP_FRAME, Msr);
|
||
genDef(Tr, KTRAP_FRAME, Iar);
|
||
genDef(Tr, KTRAP_FRAME, Lr);
|
||
genDef(Tr, KTRAP_FRAME, Ctr);
|
||
|
||
genDef(Tr, KTRAP_FRAME, Dr0);
|
||
genDef(Tr, KTRAP_FRAME, Dr1);
|
||
genDef(Tr, KTRAP_FRAME, Dr2);
|
||
genDef(Tr, KTRAP_FRAME, Dr3);
|
||
genDef(Tr, KTRAP_FRAME, Dr4);
|
||
genDef(Tr, KTRAP_FRAME, Dr5);
|
||
genDef(Tr, KTRAP_FRAME, Dr6);
|
||
genDef(Tr, KTRAP_FRAME, Dr7);
|
||
|
||
genVal(TrapFrameLength, (sizeof(KTRAP_FRAME) + 7) & (~7));
|
||
|
||
//
|
||
// Usermode callout frame definitions
|
||
//
|
||
|
||
DisableInc (HALPPC);
|
||
|
||
genCom("Usermode callout frame definitions");
|
||
|
||
genDef(Cu, KCALLOUT_FRAME, Frame);
|
||
genDef(Cu, KCALLOUT_FRAME, CbStk);
|
||
genDef(Cu, KCALLOUT_FRAME, TrFr);
|
||
genDef(Cu, KCALLOUT_FRAME, InStk);
|
||
genDef(Cu, KCALLOUT_FRAME, TrIar);
|
||
genDef(Cu, KCALLOUT_FRAME, TrToc);
|
||
genDef(Cu, KCALLOUT_FRAME, R3);
|
||
genDef(Cu, KCALLOUT_FRAME, R4);
|
||
genDef(Cu, KCALLOUT_FRAME, Lr);
|
||
genDef(Cu, KCALLOUT_FRAME, Gpr);
|
||
genDef(Cu, KCALLOUT_FRAME, Fpr);
|
||
|
||
genVal(CuFrameLength, sizeof(KCALLOUT_FRAME));
|
||
|
||
genCom("Usermode callout user frame definitions");
|
||
|
||
genDef(Ck, UCALLOUT_FRAME, Frame);
|
||
genDef(Ck, UCALLOUT_FRAME, Buffer);
|
||
genDef(Ck, UCALLOUT_FRAME, Length);
|
||
genDef(Ck, UCALLOUT_FRAME, ApiNumber);
|
||
genDef(Ck, UCALLOUT_FRAME, Lr);
|
||
genDef(Ck, UCALLOUT_FRAME, Toc);
|
||
|
||
genVal(CkFrameLength, sizeof(UCALLOUT_FRAME));
|
||
|
||
//
|
||
// Exception stack frame definitions
|
||
//
|
||
|
||
genCom("Exception stack frame frame definitions");
|
||
|
||
genVal(STK_SLACK_SPACE, STK_SLACK_SPACE);
|
||
genAlt(TF_BASE, KEXCEPTION_STACK_FRAME, TrapFrame);
|
||
genAlt(KERN_SYS_CALL_FRAME, KEXCEPTION_STACK_FRAME, ExceptionFrame);
|
||
genAlt(EF_BASE, KEXCEPTION_STACK_FRAME, ExceptionFrame);
|
||
genDef(Ef, KEXCEPTION_STACK_FRAME, Lr);
|
||
genDef(Ef, KEXCEPTION_STACK_FRAME, Cr);
|
||
genAlt(USER_SYS_CALL_FRAME, KEXCEPTION_STACK_FRAME, SlackSpace);
|
||
genAlt(STACK_DELTA_NEWSTK, KEXCEPTION_STACK_FRAME, SlackSpace);
|
||
genVal(STACK_DELTA, sizeof(KEXCEPTION_STACK_FRAME));
|
||
|
||
EnableInc (HALPPC);
|
||
|
||
//
|
||
// Processor State Frame offsets relative to base
|
||
//
|
||
|
||
genCom("Processor State Frame Offset Definitions");
|
||
|
||
genDef(Ps, KPROCESSOR_STATE, ContextFrame);
|
||
genDef(Ps, KPROCESSOR_STATE, SpecialRegisters);
|
||
genDef(Sr, KSPECIAL_REGISTERS, KernelDr0);
|
||
genDef(Sr, KSPECIAL_REGISTERS, KernelDr1);
|
||
genDef(Sr, KSPECIAL_REGISTERS, KernelDr2);
|
||
genDef(Sr, KSPECIAL_REGISTERS, KernelDr3);
|
||
genDef(Sr, KSPECIAL_REGISTERS, KernelDr4);
|
||
genDef(Sr, KSPECIAL_REGISTERS, KernelDr5);
|
||
genDef(Sr, KSPECIAL_REGISTERS, KernelDr6);
|
||
genDef(Sr, KSPECIAL_REGISTERS, KernelDr7);
|
||
genDef(Sr, KSPECIAL_REGISTERS, Sprg0);
|
||
genDef(Sr, KSPECIAL_REGISTERS, Sprg1);
|
||
genDef(Sr, KSPECIAL_REGISTERS, Sr0);
|
||
genDef(Sr, KSPECIAL_REGISTERS, Sr1);
|
||
genDef(Sr, KSPECIAL_REGISTERS, Sr2);
|
||
genDef(Sr, KSPECIAL_REGISTERS, Sr3);
|
||
genDef(Sr, KSPECIAL_REGISTERS, Sr4);
|
||
genDef(Sr, KSPECIAL_REGISTERS, Sr5);
|
||
genDef(Sr, KSPECIAL_REGISTERS, Sr6);
|
||
genDef(Sr, KSPECIAL_REGISTERS, Sr7);
|
||
genDef(Sr, KSPECIAL_REGISTERS, Sr8);
|
||
genDef(Sr, KSPECIAL_REGISTERS, Sr9);
|
||
genDef(Sr, KSPECIAL_REGISTERS, Sr10);
|
||
genDef(Sr, KSPECIAL_REGISTERS, Sr11);
|
||
genDef(Sr, KSPECIAL_REGISTERS, Sr12);
|
||
genDef(Sr, KSPECIAL_REGISTERS, Sr13);
|
||
genDef(Sr, KSPECIAL_REGISTERS, Sr14);
|
||
genDef(Sr, KSPECIAL_REGISTERS, Sr15);
|
||
genDef(Sr, KSPECIAL_REGISTERS, DBAT0L);
|
||
genDef(Sr, KSPECIAL_REGISTERS, DBAT0U);
|
||
genDef(Sr, KSPECIAL_REGISTERS, DBAT1L);
|
||
genDef(Sr, KSPECIAL_REGISTERS, DBAT1U);
|
||
genDef(Sr, KSPECIAL_REGISTERS, DBAT2L);
|
||
genDef(Sr, KSPECIAL_REGISTERS, DBAT2U);
|
||
genDef(Sr, KSPECIAL_REGISTERS, DBAT3L);
|
||
genDef(Sr, KSPECIAL_REGISTERS, DBAT3U);
|
||
genDef(Sr, KSPECIAL_REGISTERS, IBAT0L);
|
||
genDef(Sr, KSPECIAL_REGISTERS, IBAT0U);
|
||
genDef(Sr, KSPECIAL_REGISTERS, IBAT1L);
|
||
genDef(Sr, KSPECIAL_REGISTERS, IBAT1U);
|
||
genDef(Sr, KSPECIAL_REGISTERS, IBAT2L);
|
||
genDef(Sr, KSPECIAL_REGISTERS, IBAT2U);
|
||
genDef(Sr, KSPECIAL_REGISTERS, IBAT3L);
|
||
genDef(Sr, KSPECIAL_REGISTERS, IBAT3U);
|
||
genDef(Sr, KSPECIAL_REGISTERS, Sdr1);
|
||
|
||
genVal(ProcessorStateLength, ((sizeof(KPROCESSOR_STATE) + 15) & ~15));
|
||
|
||
//
|
||
// Loader Parameter Block offset definitions.
|
||
//
|
||
|
||
genCom("Loader Parameter Block Offset Definitions");
|
||
|
||
genDef(Lpb, LOADER_PARAMETER_BLOCK, LoadOrderListHead);
|
||
genDef(Lpb, LOADER_PARAMETER_BLOCK, MemoryDescriptorListHead);
|
||
genDef(Lpb, LOADER_PARAMETER_BLOCK, KernelStack);
|
||
genDef(Lpb, LOADER_PARAMETER_BLOCK, Prcb);
|
||
genDef(Lpb, LOADER_PARAMETER_BLOCK, Process);
|
||
genDef(Lpb, LOADER_PARAMETER_BLOCK, Thread);
|
||
genDef(Lpb, LOADER_PARAMETER_BLOCK, RegistryLength);
|
||
genDef(Lpb, LOADER_PARAMETER_BLOCK, RegistryBase);
|
||
genAlt(LpbInterruptStack, LOADER_PARAMETER_BLOCK, u.Ppc.InterruptStack);
|
||
genAlt(LpbFirstLevelDcacheSize, LOADER_PARAMETER_BLOCK, u.Ppc.FirstLevelDcacheSize);
|
||
genAlt(LpbFirstLevelDcacheFillSize, LOADER_PARAMETER_BLOCK, u.Ppc.FirstLevelDcacheFillSize);
|
||
genAlt(LpbFirstLevelIcacheSize, LOADER_PARAMETER_BLOCK, u.Ppc.FirstLevelIcacheSize);
|
||
genAlt(LpbFirstLevelIcacheFillSize, LOADER_PARAMETER_BLOCK, u.Ppc.FirstLevelIcacheFillSize);
|
||
genAlt(LpbHashedPageTable, LOADER_PARAMETER_BLOCK, u.Ppc.HashedPageTable);
|
||
genAlt(LpbPanicStack, LOADER_PARAMETER_BLOCK, u.Ppc.PanicStack);
|
||
genAlt(LpbPcrPage, LOADER_PARAMETER_BLOCK, u.Ppc.PcrPage);
|
||
genAlt(LpbPdrPage, LOADER_PARAMETER_BLOCK, u.Ppc.PdrPage);
|
||
genAlt(LpbSecondLevelDcacheSize, LOADER_PARAMETER_BLOCK, u.Ppc.SecondLevelDcacheSize);
|
||
genAlt(LpbSecondLevelDcacheFillSize, LOADER_PARAMETER_BLOCK, u.Ppc.SecondLevelDcacheFillSize);
|
||
genAlt(LpbSecondLevelIcacheSize, LOADER_PARAMETER_BLOCK, u.Ppc.SecondLevelIcacheSize);
|
||
genAlt(LpbSecondLevelIcacheFillSize, LOADER_PARAMETER_BLOCK, u.Ppc.SecondLevelIcacheFillSize);
|
||
genAlt(LpbPcrPage2, LOADER_PARAMETER_BLOCK, u.Ppc.PcrPage2);
|
||
genAlt(LpbIcacheMode, LOADER_PARAMETER_BLOCK, u.Ppc.IcacheMode);
|
||
genAlt(LpbDcacheMode, LOADER_PARAMETER_BLOCK, u.Ppc.DcacheMode);
|
||
genAlt(LpbNumberCongruenceClasses, LOADER_PARAMETER_BLOCK, u.Ppc.NumberCongruenceClasses);
|
||
genAlt(LpbKseg0Top, LOADER_PARAMETER_BLOCK, u.Ppc.Kseg0Top);
|
||
genAlt(LpbHashedPageTableSize, LOADER_PARAMETER_BLOCK, u.Ppc.HashedPageTableSize);
|
||
genAlt(LpbKernelKseg0PagesDescriptor, LOADER_PARAMETER_BLOCK, u.Ppc.KernelKseg0PagesDescriptor);
|
||
genAlt(LpbMinimumBlockLength, LOADER_PARAMETER_BLOCK, u.Ppc.MinimumBlockLength);
|
||
genAlt(LpbMaximumBlockLength, LOADER_PARAMETER_BLOCK, u.Ppc.MaximumBlockLength);
|
||
|
||
//
|
||
// Memory Allocation Descriptor offset definitions.
|
||
//
|
||
|
||
genCom("Memory Allocation Descriptor Offset Definitions");
|
||
|
||
genDef(Mad, MEMORY_ALLOCATION_DESCRIPTOR, ListEntry);
|
||
genDef(Mad, MEMORY_ALLOCATION_DESCRIPTOR, MemoryType);
|
||
genDef(Mad, MEMORY_ALLOCATION_DESCRIPTOR, BasePage);
|
||
genDef(Mad, MEMORY_ALLOCATION_DESCRIPTOR, PageCount);
|
||
|
||
DisableInc (HALPPC);
|
||
|
||
//
|
||
// Address space layout definitions
|
||
//
|
||
|
||
EnableInc (HALPPC);
|
||
|
||
genCom("Address Space Layout Definitions");
|
||
|
||
genVal(KUSEG_BASE, KUSEG_BASE);
|
||
genVal(KSEG0_BASE, KSEG0_BASE);
|
||
dumpf("#define KSEG1_BASE PCR->Kseg0Top\n");
|
||
dumpf("#define KSEG2_BASE KSEG1_BASE\n");
|
||
|
||
DisableInc (HALPPC);
|
||
|
||
genVal(SYSTEM_BASE, SYSTEM_BASE);
|
||
genVal(PDE_BASE, PDE_BASE);
|
||
genVal(PTE_BASE, PTE_BASE);
|
||
|
||
//
|
||
// Page table and page directory entry definitions
|
||
//
|
||
|
||
EnableInc (HALPPC);
|
||
|
||
genCom("Page Table and Directory Entry Definitions");
|
||
|
||
genVal(PAGE_SIZE, PAGE_SIZE);
|
||
genVal(PAGE_SHIFT, PAGE_SHIFT);
|
||
genVal(PDI_SHIFT, PDI_SHIFT);
|
||
genVal(PTI_SHIFT, PTI_SHIFT);
|
||
|
||
DisableInc (HALPPC);
|
||
|
||
//
|
||
// Breakpoint instruction definitions
|
||
//
|
||
|
||
EnableInc (HALPPC);
|
||
|
||
genCom("Breakpoint Definitions");
|
||
|
||
genVal(USER_BREAKPOINT, USER_BREAKPOINT);
|
||
genVal(KERNEL_BREAKPOINT, KERNEL_BREAKPOINT);
|
||
genVal(BREAKIN_BREAKPOINT, BREAKIN_BREAKPOINT);
|
||
|
||
DisableInc (HALPPC);
|
||
|
||
genVal(BRANCH_TAKEN_BREAKPOINT, BRANCH_TAKEN_BREAKPOINT);
|
||
genVal(BRANCH_NOT_TAKEN_BREAKPOINT, BRANCH_NOT_TAKEN_BREAKPOINT);
|
||
genVal(SINGLE_STEP_BREAKPOINT, SINGLE_STEP_BREAKPOINT);
|
||
genVal(DIVIDE_OVERFLOW_BREAKPOINT, DIVIDE_OVERFLOW_BREAKPOINT);
|
||
genVal(DIVIDE_BY_ZERO_BREAKPOINT, DIVIDE_BY_ZERO_BREAKPOINT);
|
||
genVal(RANGE_CHECK_BREAKPOINT, RANGE_CHECK_BREAKPOINT);
|
||
genVal(STACK_OVERFLOW_BREAKPOINT, STACK_OVERFLOW_BREAKPOINT);
|
||
genVal(MULTIPLY_OVERFLOW_BREAKPOINT, MULTIPLY_OVERFLOW_BREAKPOINT);
|
||
genVal(DEBUG_PRINT_BREAKPOINT, DEBUG_PRINT_BREAKPOINT);
|
||
genVal(DEBUG_PROMPT_BREAKPOINT, DEBUG_PROMPT_BREAKPOINT);
|
||
genVal(DEBUG_STOP_BREAKPOINT, DEBUG_STOP_BREAKPOINT);
|
||
genVal(DEBUG_LOAD_SYMBOLS_BREAKPOINT, DEBUG_LOAD_SYMBOLS_BREAKPOINT);
|
||
genVal(DEBUG_UNLOAD_SYMBOLS_BREAKPOINT, DEBUG_UNLOAD_SYMBOLS_BREAKPOINT);
|
||
|
||
//
|
||
// Miscellaneous definitions
|
||
//
|
||
|
||
EnableInc (HALPPC);
|
||
|
||
genCom("Miscellaneous Definitions");
|
||
|
||
genVal(Executive, Executive);
|
||
genVal(KernelMode, KernelMode);
|
||
genVal(FALSE, FALSE);
|
||
genVal(TRUE, TRUE);
|
||
genVal(UNCACHED_POLICY, UNCACHED_POLICY);
|
||
genVal(KiPcr, KIPCR);
|
||
genVal(KiPcr2, KIPCR2);
|
||
|
||
DisableInc (HALPPC);
|
||
|
||
genVal(BASE_PRIORITY_THRESHOLD, BASE_PRIORITY_THRESHOLD);
|
||
genVal(EVENT_PAIR_INCREMENT, EVENT_PAIR_INCREMENT);
|
||
genVal(LOW_REALTIME_PRIORITY, LOW_REALTIME_PRIORITY);
|
||
genVal(KERNEL_STACK_SIZE, KERNEL_STACK_SIZE);
|
||
genVal(KERNEL_LARGE_STACK_COMMIT, KERNEL_LARGE_STACK_COMMIT);
|
||
genVal(MM_USER_PROBE_ADDRESS, MM_USER_PROBE_ADDRESS);
|
||
genVal(ROUND_TO_NEAREST, ROUND_TO_NEAREST);
|
||
genVal(ROUND_TO_ZERO, ROUND_TO_ZERO);
|
||
genVal(ROUND_TO_PLUS_INFINITY, ROUND_TO_PLUS_INFINITY);
|
||
genVal(ROUND_TO_MINUS_INFINITY, ROUND_TO_MINUS_INFINITY);
|
||
genVal(CLOCK_QUANTUM_DECREMENT, CLOCK_QUANTUM_DECREMENT);
|
||
genVal(READY_SKIP_QUANTUM, READY_SKIP_QUANTUM);
|
||
genVal(THREAD_QUANTUM, THREAD_QUANTUM);
|
||
genVal(WAIT_QUANTUM_DECREMENT, WAIT_QUANTUM_DECREMENT);
|
||
genVal(ROUND_TRIP_DECREMENT_COUNT, ROUND_TRIP_DECREMENT_COUNT);
|
||
|
||
//
|
||
// Close header file.
|
||
//
|
||
|
||
fprintf(stderr, " Finished\n");
|
||
return;
|
||
}
|
||
|
||
VOID
|
||
dumpf (const char *format, ...)
|
||
{
|
||
va_list(arglist);
|
||
|
||
va_start(arglist, format);
|
||
|
||
if (OutputEnabled & KSPPC) {
|
||
vfprintf (KsPpc, format, arglist);
|
||
}
|
||
|
||
if (OutputEnabled & HALPPC) {
|
||
vfprintf (HalPpc, format, arglist);
|
||
}
|
||
|
||
va_end(arglist);
|
||
}
|