/*++ Copyright (c) 1990 Microsoft Corporation Copyright (c) 1992, 1993 Digital Equipment Corporation Module Name: genalpha.c Abstract: This module implements a program which generates ALPHA machine dependent structure offset definitions for kernel structures that are accessed in assembly code. Author: David N. Cutler (davec) 27-Mar-1990 Joe Notarangelo 26-Mar-1992 Revision History: Thomas Van Baak (tvb) 10-Jul-1992 Modified CONTEXT, TRAP, and EXCEPTION frames according to the new Alpha calling standard. --*/ #include "ki.h" #pragma hdrstop #define HEADER_FILE #include "excpt.h" #include "ntdef.h" #include "ntkeapi.h" #include "ntalpha.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 "nturtl.h" #include "ntcsrmsg.h" #include "ntcsrsrv.h" #include "ntxcapi.h" #include "arc.h" #include "ntstatus.h" #include "kxalpha.h" #include "stdarg.h" #include "setjmp.h" // // 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 *KsAlpha; FILE *HalAlpha; // // EnableInc(a) - Enable output to go to specified include file // #define EnableInc(a) OutputEnabled |= a; // // DisableInc(a) - Disable out from going to specified include file // #define DisableInc(a) OutputEnabled &= ~a; ULONG OutputEnabled; #define KSALPHA 0x1 #define HALALPHA 0x2 #define KERNEL KSALPHA #define HAL HALALPHA VOID GenerateCallPalNames( VOID ); 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 routine returns the first bit set of a longword // (assumes at least one bit set ) LONG v ( IN ULONG m ) { LONG i; for( i=0; i < 32; i++ ){ if( (m & (1 << i)) != 0 ){ goto done; /* break was not working */ } } done: return i; } // // This program generates the ALPHA machine dependent assembler offset // definitions. // VOID main (argc, argv) int argc; char *argv[]; { char *outName; LONG Bo; union { ULONG foo; } x; union { ULONG mask; HARDWARE_PTE p; } pte; union { ULONG mask; PSR p; } psr; union { ULONG mask; IE i; } ie; union { ULONG mask; MCHK_STATUS m; } mchk; union { ULONG mask; MCES m; } mces; union { ULONG mask; EXC_SUM e; } excsum; // // Create files for output. // outName = (argc >= 2) ? argv[1] : "\\nt\\public\\sdk\\inc\\ksalpha.h"; KsAlpha = fopen( outName, "w" ); if( KsAlpha == NULL ){ fprintf( stderr, "GENALPHA: Cannot open %s for writing.\n", outName ); perror( "GENALPHA" ); exit(1); } fprintf( stderr, "GENALPHA: Writing %s header file.\n", outName ); outName = (argc >= 3) ? argv[2] : "\\nt\\private\\ntos\\inc\\halalpha.h"; HalAlpha = fopen( outName, "w" ); if( HalAlpha == NULL ){ fprintf( stderr, "GENALPHA: Cannot open %s for writing.\n", outName ); perror( "GENALPHA" ); exit(1); } fprintf( stderr, "GENALPHA: Writing %s header file.\n", outName ); // // Include statement for ALPHA architecture static definitions. // EnableInc( KSALPHA | HALALPHA ); dumpf("#include \"kxalpha.h\"\n"); DisableInc( HALALPHA ); // // Include architecture independent definitions. // #include "..\genxx.inc" // // Generate architecture dependent definitions. // // Processor control register structure definitions. // EnableInc(HAL); dumpf("\n"); dumpf("//\n"); dumpf("// Processor Control Registers Structure Offset Definitions\n"); dumpf("//\n"); dumpf("\n"); dumpf("#define PCR_MINOR_VERSION 0x%lx\n", PCR_MINOR_VERSION); dumpf("#define PCR_MAJOR_VERSION 0x%lx\n", PCR_MAJOR_VERSION); dumpf("#define PcMinorVersion 0x%lx\n", OFFSET(KPCR, MinorVersion)); dumpf("#define PcMajorVersion 0x%lx\n", OFFSET(KPCR, MajorVersion)); dumpf("#define PcPalBaseAddress 0x%lx\n", OFFSET(KPCR, PalBaseAddress)); dumpf("#define PcPalMajorVersion 0x%lx\n", OFFSET(KPCR, PalMajorVersion)); dumpf("#define PcPalMinorVersion 0x%lx\n", OFFSET(KPCR, PalMinorVersion)); dumpf("#define PcPalSequenceVersion 0x%lx\n", OFFSET(KPCR, PalSequenceVersion)); dumpf("#define PcPalMajorSpecification 0x%lx\n", OFFSET(KPCR, PalMajorSpecification)); dumpf("#define PcPalMinorSpecification 0x%lx\n", OFFSET(KPCR, PalMinorSpecification)); dumpf("#define PcFirmwareRestartAddress 0x%lx\n", OFFSET(KPCR, FirmwareRestartAddress)); dumpf("#define PcRestartBlock 0x%lx\n", OFFSET(KPCR, RestartBlock)); dumpf("#define PcPalReserved 0x%lx\n", OFFSET(KPCR, PalReserved)); dumpf("#define PcPanicStack 0x%lx\n", OFFSET(KPCR, PanicStack)); dumpf("#define PcProcessorType 0x%lx\n", OFFSET(KPCR, ProcessorType)); dumpf("#define PcProcessorRevision 0x%lx\n", OFFSET(KPCR, ProcessorRevision)); dumpf("#define PcPhysicalAddressBits 0x%lx\n", OFFSET(KPCR, PhysicalAddressBits)); dumpf("#define PcMaximumAddressSpaceNumber 0x%lx\n", OFFSET(KPCR, MaximumAddressSpaceNumber)); dumpf("#define PcPageSize 0x%lx\n", OFFSET(KPCR, PageSize)); dumpf("#define PcFirstLevelDcacheSize 0x%lx\n", OFFSET(KPCR, FirstLevelDcacheSize)); dumpf("#define PcFirstLevelDcacheFillSize 0x%lx\n", OFFSET(KPCR, FirstLevelDcacheFillSize)); dumpf("#define PcFirstLevelIcacheSize 0x%lx\n", OFFSET(KPCR, FirstLevelIcacheSize)); dumpf("#define PcFirstLevelIcacheFillSize 0x%lx\n", OFFSET(KPCR, FirstLevelIcacheFillSize)); dumpf("#define PcFirmwareRevisionId 0x%lx\n", OFFSET(KPCR, FirmwareRevisionId)); dumpf("#define PcSystemType 0x%lx\n", OFFSET(KPCR, SystemType[0])); dumpf("#define PcSystemVariant 0x%lx\n", OFFSET(KPCR, SystemVariant)); dumpf("#define PcSystemRevision 0x%lx\n", OFFSET(KPCR, SystemRevision)); dumpf("#define PcSystemSerialNumber 0x%lx\n", OFFSET(KPCR, SystemSerialNumber[0])); dumpf("#define PcCycleClockPeriod 0x%lx\n", OFFSET(KPCR, CycleClockPeriod)); dumpf("#define PcSecondLevelCacheSize 0x%lx\n", OFFSET(KPCR, SecondLevelCacheSize)); dumpf("#define PcSecondLevelCacheFillSize 0x%lx\n", OFFSET(KPCR, SecondLevelCacheFillSize)); dumpf("#define PcThirdLevelCacheSize 0x%lx\n", OFFSET(KPCR, ThirdLevelCacheSize)); dumpf("#define PcThirdLevelCacheFillSize 0x%lx\n", OFFSET(KPCR, ThirdLevelCacheFillSize)); dumpf("#define PcFourthLevelCacheSize 0x%lx\n", OFFSET(KPCR, FourthLevelCacheSize)); dumpf("#define PcFourthLevelCacheFillSize 0x%lx\n", OFFSET(KPCR, FourthLevelCacheFillSize)); dumpf("#define PcPrcb 0x%lx\n", OFFSET(KPCR, Prcb)); dumpf("#define PcNumber 0x%lx\n", OFFSET(KPCR, Number)); dumpf("#define PcSetMember 0x%lx\n", OFFSET(KPCR, SetMember)); dumpf("#define PcHalReserved 0x%lx\n", OFFSET(KPCR, HalReserved[0])); dumpf("#define PcIrqlTable 0x%lx\n", OFFSET(KPCR, IrqlTable[0])); dumpf("#define PcIrqlMask 0x%lx\n", OFFSET(KPCR, IrqlMask[0])); dumpf("#define PcInterruptRoutine 0x%lx\n", OFFSET(KPCR, InterruptRoutine)); dumpf("#define PcReservedVectors 0x%lx\n", OFFSET(KPCR, ReservedVectors)); dumpf("#define PcMachineCheckError 0x%lx\n", OFFSET(KPCR, MachineCheckError)); dumpf("#define PcDpcStack 0x%lx\n", OFFSET(KPCR, DpcStack)); dumpf("#define PcNotMember 0x%lx\n", OFFSET(KPCR, NotMember)); dumpf("#define PcCurrentPid 0x%lx\n", OFFSET(KPCR, CurrentPid)); dumpf("#define PcSystemServiceDispatchStart 0x%lx\n", OFFSET(KPCR, SystemServiceDispatchStart)); dumpf("#define PcSystemServiceDispatchEnd 0x%lx\n", OFFSET(KPCR, SystemServiceDispatchEnd)); dumpf("#define PcIdleThread 0x%lx\n", OFFSET(KPCR, IdleThread)); dumpf("#define ProcessorControlRegisterLength 0x%lx\n", ((sizeof(KPCR) + 15) & ~15)); dumpf("#define SharedUserData 0x%lx\n", SharedUserData); dumpf("#define UsTickCountLow 0x%lx\n", OFFSET(KUSER_SHARED_DATA, TickCountLow)); dumpf("#define UsTickCountMultiplier 0x%lx\n", OFFSET(KUSER_SHARED_DATA, TickCountMultiplier)); dumpf("#define UsInterruptTime 0x%lx\n", OFFSET(KUSER_SHARED_DATA, InterruptTime)); dumpf("#define UsSystemTime 0x%lx\n", OFFSET(KUSER_SHARED_DATA, SystemTime)); // // Processor block structure definitions. // dumpf("\n"); dumpf("//\n"); dumpf("// Processor Block Structure Offset Definitions\n"); dumpf("//\n"); dumpf("\n"); dumpf("#define PRCB_MINOR_VERSION 0x%lx\n", PRCB_MINOR_VERSION); dumpf("#define PRCB_MAJOR_VERSION 0x%lx\n", PRCB_MAJOR_VERSION); dumpf("#define PbMinorVersion 0x%lx\n", OFFSET(KPRCB, MinorVersion)); dumpf("#define PbMajorVersion 0x%lx\n", OFFSET(KPRCB, MajorVersion)); dumpf("#define PbCurrentThread 0x%lx\n", OFFSET(KPRCB, CurrentThread)); dumpf("#define PbNextThread 0x%lx\n", OFFSET(KPRCB, NextThread)); dumpf("#define PbIdleThread 0x%lx\n", OFFSET(KPRCB, IdleThread)); dumpf("#define PbNumber 0x%lx\n", OFFSET(KPRCB, Number)); dumpf("#define PbBuildType 0x%lx\n", OFFSET(KPRCB, BuildType)); dumpf("#define PbSetMember 0x%lx\n", OFFSET(KPRCB, SetMember)); dumpf("#define PbRestartBlock 0x%lx\n", OFFSET(KPRCB, RestartBlock)); DisableInc( HALALPHA ); dumpf("#define PbInterruptCount 0x%lx\n", OFFSET(KPRCB, InterruptCount)); dumpf("#define PbDpcTime 0x%lx\n", OFFSET(KPRCB, DpcTime)); dumpf("#define PbInterruptTime 0x%lx\n", OFFSET(KPRCB, InterruptTime)); dumpf("#define PbKernelTime 0x%lx\n", OFFSET(KPRCB, KernelTime)); dumpf("#define PbUserTime 0x%lx\n", OFFSET(KPRCB, UserTime)); dumpf("#define PbQuantumEndDpc 0x%lx\n", OFFSET(KPRCB, QuantumEndDpc)); dumpf("#define PbIpiFrozen 0x%lx\n", OFFSET(KPRCB, IpiFrozen)); dumpf("#define PbIpiCounts 0x%lx\n", OFFSET(KPRCB, IpiCounts)); dumpf("#define PbProcessorState 0x%lx\n", OFFSET(KPRCB, ProcessorState)); dumpf("#define PbAlignmentFixupCount 0x%lx\n", OFFSET(KPRCB, KeAlignmentFixupCount)); dumpf("#define PbContextSwitches 0x%lx\n", OFFSET(KPRCB, KeContextSwitches)); dumpf("#define PbDcacheFlushCount 0x%lx\n", OFFSET(KPRCB, KeDcacheFlushCount)); dumpf("#define PbExceptionDispatchcount 0x%lx\n", OFFSET(KPRCB, KeExceptionDispatchCount)); dumpf("#define PbFirstLevelTbFills 0x%lx\n", OFFSET(KPRCB, KeFirstLevelTbFills)); dumpf("#define PbFloatingEmulationCount 0x%lx\n", OFFSET(KPRCB, KeFloatingEmulationCount)); dumpf("#define PbIcacheFlushCount 0x%lx\n", OFFSET(KPRCB, KeIcacheFlushCount)); dumpf("#define PbSecondLevelTbFills 0x%lx\n", OFFSET(KPRCB, KeSecondLevelTbFills)); dumpf("#define PbSystemCalls 0x%lx\n", OFFSET(KPRCB, KeSystemCalls)); genDef(Pb, KPRCB, CurrentPacket); genDef(Pb, KPRCB, TargetSet); genDef(Pb, KPRCB, WorkerRoutine); genDef(Pb, KPRCB, RequestSummary); genDef(Pb, KPRCB, SignalDone); dumpf("#define PbDpcListHead 0x%lx\n", OFFSET(KPRCB, DpcListHead)); dumpf("#define PbDpcLock 0x%lx\n", OFFSET(KPRCB, DpcLock)); dumpf("#define PbDpcCount 0x%lx\n", OFFSET(KPRCB, DpcCount)); dumpf("#define PbLastDpcCount 0x%lx\n", OFFSET(KPRCB, LastDpcCount)); dumpf("#define PbQuantumEnd 0x%lx\n", OFFSET(KPRCB, QuantumEnd)); dumpf("#define PbStartCount 0x%lx\n", OFFSET(KPRCB, StartCount)); dumpf("#define PbSoftwareInterrupts 0x%lx\n", OFFSET(KPRCB, SoftwareInterrupts)); dumpf("#define PbInterruptActive 0x%lx\n", OFFSET(KPRCB, InterruptActive)); dumpf("#define PbDpcRoutineActive 0x%lx\n", OFFSET(KPRCB, DpcRoutineActive)); dumpf("#define PbDpcQueueDepth 0x%lx\n", OFFSET(KPRCB, DpcQueueDepth)); dumpf("#define PbDpcRequestRate 0x%lx\n", OFFSET(KPRCB, DpcRequestRate)); dumpf("#define PbDpcBypassCount 0x%lx\n", OFFSET(KPRCB, DpcBypassCount)); dumpf("#define PbApcBypassCount 0x%lx\n", OFFSET(KPRCB, ApcBypassCount)); dumpf("#define PbDispatchInterruptCount 0x%lx\n", OFFSET(KPRCB, DispatchInterruptCount)); dumpf("#define PbDpcInterruptRequested 0x%lx\n", OFFSET(KPRCB, DpcInterruptRequested)); dumpf("#define PbMaximumDpcQueueDepth 0x%lx\n", OFFSET(KPRCB, MaximumDpcQueueDepth)); dumpf("#define PbMinimumDpcRate 0x%lx\n", OFFSET(KPRCB, MinimumDpcRate)); dumpf("#define PbAdjustDpcThreshold 0x%lx\n", OFFSET(KPRCB, AdjustDpcThreshold)); dumpf("#define ProcessorBlockLength 0x%lx\n", ((sizeof(KPRCB) + 15) & ~15)); // // Immediate interprocessor command definitions. // dumpf("\n"); dumpf("//\n"); dumpf("// Immediate Interprocessor Command Definitions\n"); dumpf("//\n"); dumpf("\n"); dumpf("#define IPI_APC 0x%lx\n", IPI_APC ); dumpf("#define IPI_DPC 0x%lx\n", IPI_DPC ); dumpf("#define IPI_FREEZE 0x%lx\n", IPI_FREEZE ); dumpf("#define IPI_PACKET_READY 0x%lx\n", IPI_PACKET_READY ); // // Interprocessor interrupt count structure offset definitions. // dumpf("\n"); dumpf("//\n"); dumpf("// Interprocessor Interrupt Count Structure Offset Definitions\n"); dumpf("//\n" ); dumpf("\n" ); dumpf("#define IcFreeze 0x%lx\n", OFFSET(KIPI_COUNTS, Freeze) ); dumpf("#define IcPacket 0x%lx\n", OFFSET(KIPI_COUNTS, Packet) ); dumpf("#define IcDPC 0x%lx\n", OFFSET(KIPI_COUNTS, DPC) ); dumpf("#define IcAPC 0x%lx\n", OFFSET(KIPI_COUNTS, APC) ); dumpf("#define IcFlushSingleTb 0x%lx\n", OFFSET(KIPI_COUNTS, FlushSingleTb) ); dumpf("#define IcFlushEntireTb 0x%lx\n", OFFSET(KIPI_COUNTS, FlushEntireTb) ); dumpf("#define IcChangeColor 0x%lx\n", OFFSET(KIPI_COUNTS, ChangeColor) ); dumpf("#define IcSweepDcache 0x%lx\n", OFFSET(KIPI_COUNTS, SweepDcache) ); dumpf("#define IcSweepIcache 0x%lx\n", OFFSET(KIPI_COUNTS, SweepIcache) ); dumpf("#define IcSweepIcacheRange 0x%lx\n", OFFSET(KIPI_COUNTS, SweepIcacheRange) ); dumpf("#define IcFlushIoBuffers 0x%lx\n", OFFSET(KIPI_COUNTS, FlushIoBuffers) ); // // Context frame offset definitions and flag definitions. // EnableInc( HALALPHA ); dumpf("\n"); dumpf("//\n"); dumpf("// Context Frame Offset and Flag Definitions\n"); dumpf("//\n"); dumpf("\n"); dumpf("#define CONTEXT_FULL 0x%lx\n", CONTEXT_FULL); dumpf("#define CONTEXT_CONTROL 0x%lx\n", CONTEXT_CONTROL); dumpf("#define CONTEXT_FLOATING_POINT 0x%lx\n", CONTEXT_FLOATING_POINT); dumpf("#define CONTEXT_INTEGER 0x%lx\n", CONTEXT_INTEGER); dumpf("\n"); dumpf("#define CxFltF0 0x%lx\n", OFFSET(CONTEXT, FltF0)); dumpf("#define CxFltF1 0x%lx\n", OFFSET(CONTEXT, FltF1)); dumpf("#define CxFltF2 0x%lx\n", OFFSET(CONTEXT, FltF2)); dumpf("#define CxFltF3 0x%lx\n", OFFSET(CONTEXT, FltF3)); dumpf("#define CxFltF4 0x%lx\n", OFFSET(CONTEXT, FltF4)); dumpf("#define CxFltF5 0x%lx\n", OFFSET(CONTEXT, FltF5)); dumpf("#define CxFltF6 0x%lx\n", OFFSET(CONTEXT, FltF6)); dumpf("#define CxFltF7 0x%lx\n", OFFSET(CONTEXT, FltF7)); dumpf("#define CxFltF8 0x%lx\n", OFFSET(CONTEXT, FltF8)); dumpf("#define CxFltF9 0x%lx\n", OFFSET(CONTEXT, FltF9)); dumpf("#define CxFltF10 0x%lx\n", OFFSET(CONTEXT, FltF10)); dumpf("#define CxFltF11 0x%lx\n", OFFSET(CONTEXT, FltF11)); dumpf("#define CxFltF12 0x%lx\n", OFFSET(CONTEXT, FltF12)); dumpf("#define CxFltF13 0x%lx\n", OFFSET(CONTEXT, FltF13)); dumpf("#define CxFltF14 0x%lx\n", OFFSET(CONTEXT, FltF14)); dumpf("#define CxFltF15 0x%lx\n", OFFSET(CONTEXT, FltF15)); dumpf("#define CxFltF16 0x%lx\n", OFFSET(CONTEXT, FltF16)); dumpf("#define CxFltF17 0x%lx\n", OFFSET(CONTEXT, FltF17)); dumpf("#define CxFltF18 0x%lx\n", OFFSET(CONTEXT, FltF18)); dumpf("#define CxFltF19 0x%lx\n", OFFSET(CONTEXT, FltF19)); dumpf("#define CxFltF20 0x%lx\n", OFFSET(CONTEXT, FltF20)); dumpf("#define CxFltF21 0x%lx\n", OFFSET(CONTEXT, FltF21)); dumpf("#define CxFltF22 0x%lx\n", OFFSET(CONTEXT, FltF22)); dumpf("#define CxFltF23 0x%lx\n", OFFSET(CONTEXT, FltF23)); dumpf("#define CxFltF24 0x%lx\n", OFFSET(CONTEXT, FltF24)); dumpf("#define CxFltF25 0x%lx\n", OFFSET(CONTEXT, FltF25)); dumpf("#define CxFltF26 0x%lx\n", OFFSET(CONTEXT, FltF26)); dumpf("#define CxFltF27 0x%lx\n", OFFSET(CONTEXT, FltF27)); dumpf("#define CxFltF28 0x%lx\n", OFFSET(CONTEXT, FltF28)); dumpf("#define CxFltF29 0x%lx\n", OFFSET(CONTEXT, FltF29)); dumpf("#define CxFltF30 0x%lx\n", OFFSET(CONTEXT, FltF30)); dumpf("#define CxFltF31 0x%lx\n", OFFSET(CONTEXT, FltF31)); dumpf("#define CxIntV0 0x%lx\n", OFFSET(CONTEXT, IntV0)); dumpf("#define CxIntT0 0x%lx\n", OFFSET(CONTEXT, IntT0)); dumpf("#define CxIntT1 0x%lx\n", OFFSET(CONTEXT, IntT1)); dumpf("#define CxIntT2 0x%lx\n", OFFSET(CONTEXT, IntT2)); dumpf("#define CxIntT3 0x%lx\n", OFFSET(CONTEXT, IntT3)); dumpf("#define CxIntT4 0x%lx\n", OFFSET(CONTEXT, IntT4)); dumpf("#define CxIntT5 0x%lx\n", OFFSET(CONTEXT, IntT5)); dumpf("#define CxIntT6 0x%lx\n", OFFSET(CONTEXT, IntT6)); dumpf("#define CxIntT7 0x%lx\n", OFFSET(CONTEXT, IntT7)); dumpf("#define CxIntS0 0x%lx\n", OFFSET(CONTEXT, IntS0)); dumpf("#define CxIntS1 0x%lx\n", OFFSET(CONTEXT, IntS1)); dumpf("#define CxIntS2 0x%lx\n", OFFSET(CONTEXT, IntS2)); dumpf("#define CxIntS3 0x%lx\n", OFFSET(CONTEXT, IntS3)); dumpf("#define CxIntS4 0x%lx\n", OFFSET(CONTEXT, IntS4)); dumpf("#define CxIntS5 0x%lx\n", OFFSET(CONTEXT, IntS5)); dumpf("#define CxIntFp 0x%lx\n", OFFSET(CONTEXT, IntFp)); dumpf("#define CxIntA0 0x%lx\n", OFFSET(CONTEXT, IntA0)); dumpf("#define CxIntA1 0x%lx\n", OFFSET(CONTEXT, IntA1)); dumpf("#define CxIntA2 0x%lx\n", OFFSET(CONTEXT, IntA2)); dumpf("#define CxIntA3 0x%lx\n", OFFSET(CONTEXT, IntA3)); dumpf("#define CxIntA4 0x%lx\n", OFFSET(CONTEXT, IntA4)); dumpf("#define CxIntA5 0x%lx\n", OFFSET(CONTEXT, IntA5)); dumpf("#define CxIntT8 0x%lx\n", OFFSET(CONTEXT, IntT8)); dumpf("#define CxIntT9 0x%lx\n", OFFSET(CONTEXT, IntT9)); dumpf("#define CxIntT10 0x%lx\n", OFFSET(CONTEXT, IntT10)); dumpf("#define CxIntT11 0x%lx\n", OFFSET(CONTEXT, IntT11)); dumpf("#define CxIntRa 0x%lx\n", OFFSET(CONTEXT, IntRa)); dumpf("#define CxIntT12 0x%lx\n", OFFSET(CONTEXT, IntT12)); dumpf("#define CxIntAt 0x%lx\n", OFFSET(CONTEXT, IntAt)); dumpf("#define CxIntGp 0x%lx\n", OFFSET(CONTEXT, IntGp)); dumpf("#define CxIntSp 0x%lx\n", OFFSET(CONTEXT, IntSp)); dumpf("#define CxIntZero 0x%lx\n", OFFSET(CONTEXT, IntZero)); dumpf("#define CxFpcr 0x%lx\n", OFFSET(CONTEXT, Fpcr)); dumpf("#define CxSoftFpcr 0x%lx\n", OFFSET(CONTEXT, SoftFpcr)); dumpf("#define CxFir 0x%lx\n", OFFSET(CONTEXT, Fir)); dumpf("#define CxPsr 0x%lx\n", OFFSET(CONTEXT, Psr)); dumpf("#define CxContextFlags 0x%lx\n", OFFSET(CONTEXT, ContextFlags)); dumpf("#define ContextFrameLength 0x%lx\n", (sizeof(CONTEXT) + 15) & (~15)); // // Exception frame offset definitions. // dumpf("\n"); dumpf("//\n"); dumpf("// Exception Frame Offset Definitions and Length\n"); dumpf("//\n"); dumpf("\n"); dumpf("#define ExFltF2 0x%lx\n", OFFSET(KEXCEPTION_FRAME, FltF2)); dumpf("#define ExFltF3 0x%lx\n", OFFSET(KEXCEPTION_FRAME, FltF3)); dumpf("#define ExFltF4 0x%lx\n", OFFSET(KEXCEPTION_FRAME, FltF4)); dumpf("#define ExFltF5 0x%lx\n", OFFSET(KEXCEPTION_FRAME, FltF5)); dumpf("#define ExFltF6 0x%lx\n", OFFSET(KEXCEPTION_FRAME, FltF6)); dumpf("#define ExFltF7 0x%lx\n", OFFSET(KEXCEPTION_FRAME, FltF7)); dumpf("#define ExFltF8 0x%lx\n", OFFSET(KEXCEPTION_FRAME, FltF8)); dumpf("#define ExFltF9 0x%lx\n", OFFSET(KEXCEPTION_FRAME, FltF9)); dumpf("#define ExIntS0 0x%lx\n", OFFSET(KEXCEPTION_FRAME, IntS0)); dumpf("#define ExIntS1 0x%lx\n", OFFSET(KEXCEPTION_FRAME, IntS1)); dumpf("#define ExIntS2 0x%lx\n", OFFSET(KEXCEPTION_FRAME, IntS2)); dumpf("#define ExIntS3 0x%lx\n", OFFSET(KEXCEPTION_FRAME, IntS3)); dumpf("#define ExIntS4 0x%lx\n", OFFSET(KEXCEPTION_FRAME, IntS4)); dumpf("#define ExIntS5 0x%lx\n", OFFSET(KEXCEPTION_FRAME, IntS5)); dumpf("#define ExIntFp 0x%lx\n", OFFSET(KEXCEPTION_FRAME, IntFp)); dumpf("#define ExPsr 0x%lx\n", OFFSET(KEXCEPTION_FRAME, Psr)); dumpf("#define ExSwapReturn 0x%lx\n", OFFSET(KEXCEPTION_FRAME, SwapReturn)); dumpf("#define ExIntRa 0x%lx\n", OFFSET(KEXCEPTION_FRAME, IntRa)); dumpf("#define ExceptionFrameLength 0x%lx\n", (sizeof(KEXCEPTION_FRAME) + 15) & (~15)); // // Jump buffer offset definitions. // dumpf("\n"); dumpf("//\n"); dumpf("// Jump Offset Definitions and Length\n"); dumpf("//\n"); dumpf("\n"); dumpf("#define JbFp 0x%lx\n", OFFSET(_JUMP_BUFFER, Fp)); dumpf("#define JbPc 0x%lx\n", OFFSET(_JUMP_BUFFER, Pc)); dumpf("#define JbSeb 0x%lx\n", OFFSET(_JUMP_BUFFER, Seb)); dumpf("#define JbType 0x%lx\n", OFFSET(_JUMP_BUFFER, Type)); dumpf("#define JbFltF2 0x%lx\n", OFFSET(_JUMP_BUFFER, FltF2)); dumpf("#define JbFltF3 0x%lx\n", OFFSET(_JUMP_BUFFER, FltF3)); dumpf("#define JbFltF4 0x%lx\n", OFFSET(_JUMP_BUFFER, FltF4)); dumpf("#define JbFltF5 0x%lx\n", OFFSET(_JUMP_BUFFER, FltF5)); dumpf("#define JbFltF6 0x%lx\n", OFFSET(_JUMP_BUFFER, FltF6)); dumpf("#define JbFltF7 0x%lx\n", OFFSET(_JUMP_BUFFER, FltF7)); dumpf("#define JbFltF8 0x%lx\n", OFFSET(_JUMP_BUFFER, FltF8)); dumpf("#define JbFltF9 0x%lx\n", OFFSET(_JUMP_BUFFER, FltF9)); dumpf("#define JbIntS0 0x%lx\n", OFFSET(_JUMP_BUFFER, IntS0)); dumpf("#define JbIntS1 0x%lx\n", OFFSET(_JUMP_BUFFER, IntS1)); dumpf("#define JbIntS2 0x%lx\n", OFFSET(_JUMP_BUFFER, IntS2)); dumpf("#define JbIntS3 0x%lx\n", OFFSET(_JUMP_BUFFER, IntS3)); dumpf("#define JbIntS4 0x%lx\n", OFFSET(_JUMP_BUFFER, IntS4)); dumpf("#define JbIntS5 0x%lx\n", OFFSET(_JUMP_BUFFER, IntS5)); dumpf("#define JbIntS6 0x%lx\n", OFFSET(_JUMP_BUFFER, IntS6)); dumpf("#define JbIntSp 0x%lx\n", OFFSET(_JUMP_BUFFER, IntSp)); dumpf("#define JbFir 0x%lx\n", OFFSET(_JUMP_BUFFER, Fir)); // // Trap frame offset definitions. // dumpf("\n"); dumpf("//\n"); dumpf("// Trap Frame Offset Definitions and Length\n"); dumpf("//\n"); dumpf("\n"); dumpf("#define TrFltF0 0x%lx\n", OFFSET(KTRAP_FRAME, FltF0)); dumpf("#define TrFltF1 0x%lx\n", OFFSET(KTRAP_FRAME, FltF1)); dumpf("#define TrFltF10 0x%lx\n", OFFSET(KTRAP_FRAME, FltF10)); dumpf("#define TrFltF11 0x%lx\n", OFFSET(KTRAP_FRAME, FltF11)); dumpf("#define TrFltF12 0x%lx\n", OFFSET(KTRAP_FRAME, FltF12)); dumpf("#define TrFltF13 0x%lx\n", OFFSET(KTRAP_FRAME, FltF13)); dumpf("#define TrFltF14 0x%lx\n", OFFSET(KTRAP_FRAME, FltF14)); dumpf("#define TrFltF15 0x%lx\n", OFFSET(KTRAP_FRAME, FltF15)); dumpf("#define TrFltF16 0x%lx\n", OFFSET(KTRAP_FRAME, FltF16)); dumpf("#define TrFltF17 0x%lx\n", OFFSET(KTRAP_FRAME, FltF17)); dumpf("#define TrFltF18 0x%lx\n", OFFSET(KTRAP_FRAME, FltF18)); dumpf("#define TrFltF19 0x%lx\n", OFFSET(KTRAP_FRAME, FltF19)); dumpf("#define TrFltF20 0x%lx\n", OFFSET(KTRAP_FRAME, FltF20)); dumpf("#define TrFltF21 0x%lx\n", OFFSET(KTRAP_FRAME, FltF21)); dumpf("#define TrFltF22 0x%lx\n", OFFSET(KTRAP_FRAME, FltF22)); dumpf("#define TrFltF23 0x%lx\n", OFFSET(KTRAP_FRAME, FltF23)); dumpf("#define TrFltF24 0x%lx\n", OFFSET(KTRAP_FRAME, FltF24)); dumpf("#define TrFltF25 0x%lx\n", OFFSET(KTRAP_FRAME, FltF25)); dumpf("#define TrFltF26 0x%lx\n", OFFSET(KTRAP_FRAME, FltF26)); dumpf("#define TrFltF27 0x%lx\n", OFFSET(KTRAP_FRAME, FltF27)); dumpf("#define TrFltF28 0x%lx\n", OFFSET(KTRAP_FRAME, FltF28)); dumpf("#define TrFltF29 0x%lx\n", OFFSET(KTRAP_FRAME, FltF29)); dumpf("#define TrFltF30 0x%lx\n", OFFSET(KTRAP_FRAME, FltF30)); dumpf("#define TrIntV0 0x%lx\n", OFFSET(KTRAP_FRAME, IntV0)); dumpf("#define TrIntT0 0x%lx\n", OFFSET(KTRAP_FRAME, IntT0)); dumpf("#define TrIntT1 0x%lx\n", OFFSET(KTRAP_FRAME, IntT1)); dumpf("#define TrIntT2 0x%lx\n", OFFSET(KTRAP_FRAME, IntT2)); dumpf("#define TrIntT3 0x%lx\n", OFFSET(KTRAP_FRAME, IntT3)); dumpf("#define TrIntT4 0x%lx\n", OFFSET(KTRAP_FRAME, IntT4)); dumpf("#define TrIntT5 0x%lx\n", OFFSET(KTRAP_FRAME, IntT5)); dumpf("#define TrIntT6 0x%lx\n", OFFSET(KTRAP_FRAME, IntT6)); dumpf("#define TrIntT7 0x%lx\n", OFFSET(KTRAP_FRAME, IntT7)); dumpf("#define TrIntFp 0x%lx\n", OFFSET(KTRAP_FRAME, IntFp)); dumpf("#define TrIntA0 0x%lx\n", OFFSET(KTRAP_FRAME, IntA0)); dumpf("#define TrIntA1 0x%lx\n", OFFSET(KTRAP_FRAME, IntA1)); dumpf("#define TrIntA2 0x%lx\n", OFFSET(KTRAP_FRAME, IntA2)); dumpf("#define TrIntA3 0x%lx\n", OFFSET(KTRAP_FRAME, IntA3)); dumpf("#define TrIntA4 0x%lx\n", OFFSET(KTRAP_FRAME, IntA4)); dumpf("#define TrIntA5 0x%lx\n", OFFSET(KTRAP_FRAME, IntA5)); dumpf("#define TrIntT8 0x%lx\n", OFFSET(KTRAP_FRAME, IntT8)); dumpf("#define TrIntT9 0x%lx\n", OFFSET(KTRAP_FRAME, IntT9)); dumpf("#define TrIntT10 0x%lx\n", OFFSET(KTRAP_FRAME, IntT10)); dumpf("#define TrIntT11 0x%lx\n", OFFSET(KTRAP_FRAME, IntT11)); dumpf("#define TrIntT12 0x%lx\n", OFFSET(KTRAP_FRAME, IntT12)); dumpf("#define TrIntAt 0x%lx\n", OFFSET(KTRAP_FRAME, IntAt)); dumpf("#define TrIntGp 0x%lx\n", OFFSET(KTRAP_FRAME, IntGp)); dumpf("#define TrIntSp 0x%lx\n", OFFSET(KTRAP_FRAME, IntSp)); dumpf("#define TrFpcr 0x%lx\n", OFFSET(KTRAP_FRAME, Fpcr)); dumpf("#define TrPsr 0x%lx\n", OFFSET(KTRAP_FRAME, Psr)); dumpf("#define TrPreviousKsp 0x%lx\n", OFFSET(KTRAP_FRAME, PreviousKsp)); dumpf("#define TrFir 0x%lx\n", OFFSET(KTRAP_FRAME, Fir)); dumpf("#define TrExceptionRecord 0x%lx\n", OFFSET(KTRAP_FRAME, ExceptionRecord[0])); dumpf("#define TrOldIrql 0x%lx\n", OFFSET(KTRAP_FRAME, OldIrql)); dumpf("#define TrPreviousMode 0x%lx\n", OFFSET(KTRAP_FRAME, PreviousMode)); dumpf("#define TrIntRa 0x%lx\n", OFFSET(KTRAP_FRAME, IntRa)); dumpf("#define TrTrapFrame 0x%lx\n",OFFSET(KTRAP_FRAME, TrapFrame)); dumpf("#define TrapFrameLength 0x%lx\n", (sizeof(KTRAP_FRAME) + 15) & (~15)); // // Usermode callout frame definitions // DisableInc(HALALPHA); genCom("Usermode callout frame definitions"); genDef(Cu, KCALLOUT_FRAME, F2); genDef(Cu, KCALLOUT_FRAME, F3); genDef(Cu, KCALLOUT_FRAME, F4); genDef(Cu, KCALLOUT_FRAME, F5); genDef(Cu, KCALLOUT_FRAME, F6); genDef(Cu, KCALLOUT_FRAME, F7); genDef(Cu, KCALLOUT_FRAME, F8); genDef(Cu, KCALLOUT_FRAME, F9); genDef(Cu, KCALLOUT_FRAME, S0); genDef(Cu, KCALLOUT_FRAME, S1); genDef(Cu, KCALLOUT_FRAME, S2); genDef(Cu, KCALLOUT_FRAME, S3); genDef(Cu, KCALLOUT_FRAME, S4); genDef(Cu, KCALLOUT_FRAME, S5); genDef(Cu, KCALLOUT_FRAME, FP); genDef(Cu, KCALLOUT_FRAME, CbStk); genDef(Cu, KCALLOUT_FRAME, InStk); genDef(Cu, KCALLOUT_FRAME, TrFr); genDef(Cu, KCALLOUT_FRAME, TrFir); genDef(Cu, KCALLOUT_FRAME, Ra); genDef(Cu, KCALLOUT_FRAME, A0); genDef(Cu, KCALLOUT_FRAME, A1); dumpf("#define CuFrameLength 0x%lx\n", sizeof(KCALLOUT_FRAME)); // // Usermode callout user frame definitions. // genCom("Usermode callout user frame definitions"); genDef(Ck, UCALLOUT_FRAME, Buffer); genDef(Ck, UCALLOUT_FRAME, Length); genDef(Ck, UCALLOUT_FRAME, ApiNumber); genDef(Ck, UCALLOUT_FRAME, Sp); genDef(Ck, UCALLOUT_FRAME, Ra); EnableInc(HALALPHA); // // Loader Parameter Block offset definitions. // dumpf("\n"); dumpf("//\n"); dumpf("// Loader Parameter Block Offset Definitions\n"); dumpf("//\n"); dumpf("\n"); dumpf("#define LpbLoadOrderListHead 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, LoadOrderListHead)); dumpf("#define LpbMemoryDescriptorListHead 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, MemoryDescriptorListHead)); dumpf("#define LpbKernelStack 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, KernelStack)); dumpf( "#define LpbPrcb 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, Prcb)); dumpf("#define LpbProcess 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, Process)); dumpf("#define LpbThread 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, Thread)); dumpf("#define LpbRegistryLength 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, RegistryLength)); dumpf("#define LpbRegistryBase 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, RegistryBase)); dumpf("#define LpbDpcStack 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.DpcStack)); dumpf("#define LpbFirstLevelDcacheSize 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.FirstLevelDcacheSize)); dumpf("#define LpbFirstLevelDcacheFillSize 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.FirstLevelDcacheFillSize)); dumpf("#define LpbFirstLevelIcacheSize 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.FirstLevelIcacheSize)); dumpf("#define LpbFirstLevelIcacheFillSize 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.FirstLevelIcacheFillSize)); dumpf("#define LpbGpBase 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.GpBase)); dumpf("#define LpbPanicStack 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.PanicStack)); dumpf("#define LpbPcrPage 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.PcrPage)); dumpf("#define LpbPdrPage 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.PdrPage)); dumpf("#define LpbSecondLevelDcacheSize 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.SecondLevelDcacheSize)); dumpf("#define LpbSecondLevelDcacheFillSize 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.SecondLevelDcacheFillSize)); dumpf("#define LpbSecondLevelIcacheSize 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.SecondLevelIcacheSize)); dumpf("#define LpbSecondLevelIcacheFillSize 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.SecondLevelIcacheFillSize)); dumpf("#define LpbPhysicalAddressBits 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.PhysicalAddressBits)); dumpf("#define LpbMaximumAddressSpaceNumber 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.MaximumAddressSpaceNumber)); dumpf("#define LpbSystemSerialNumber 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.SystemSerialNumber[0])); dumpf("#define LpbSystemType 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.SystemType[0])); dumpf("#define LpbSystemVariant 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.SystemVariant)); dumpf("#define LpbSystemRevision 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.SystemRevision)); dumpf("#define LpbProcessorType 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.ProcessorType)); dumpf("#define LpbProcessorRevision 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.ProcessorRevision)); dumpf("#define LpbCycleClockPeriod 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.CycleClockPeriod)); dumpf("#define LpbPageSize 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.PageSize)); dumpf("#define LpbRestartBlock 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.RestartBlock)); dumpf("#define LpbFirmwareRestartAddress 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.FirmwareRestartAddress)); dumpf("#define LpbFirmwareRevisionId 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.FirmwareRevisionId)); dumpf("#define LpbPalBaseAddress 0x%lx\n", OFFSET(LOADER_PARAMETER_BLOCK, u.Alpha.PalBaseAddress)); DisableInc( HALALPHA ); // // Restart Block Structure and Alpha Save Area Structure. // // N.B. - The Alpha Save Area Structure Offsets are written as though // they were offsets from the beginning of the Restart block. // EnableInc( HALALPHA ); dumpf("\n"); dumpf("//\n"); dumpf("// Restart Block Structure Definitions\n"); dumpf("//\n"); dumpf("\n"); dumpf("#define RbSignature 0x%lx\n", OFFSET(RESTART_BLOCK, Signature)); dumpf("#define RbLength 0x%lx\n", OFFSET(RESTART_BLOCK, Length)); dumpf("#define RbVersion 0x%lx\n", OFFSET(RESTART_BLOCK, Version)); dumpf("#define RbRevision 0x%lx\n", OFFSET(RESTART_BLOCK, Revision)); dumpf("#define RbNextRestartBlock 0x%lx\n", OFFSET(RESTART_BLOCK, NextRestartBlock)); dumpf("#define RbRestartAddress 0x%lx\n", OFFSET(RESTART_BLOCK, RestartAddress)); dumpf("#define RbBootMasterId 0x%lx\n", OFFSET(RESTART_BLOCK, BootMasterId)); dumpf("#define RbProcessorId 0x%lx\n", OFFSET(RESTART_BLOCK, ProcessorId)); dumpf("#define RbBootStatus 0x%lx\n", OFFSET(RESTART_BLOCK, BootStatus)); dumpf("#define RbCheckSum 0x%lx\n", OFFSET(RESTART_BLOCK, CheckSum)); dumpf("#define RbSaveAreaLength 0x%lx\n", OFFSET(RESTART_BLOCK, SaveAreaLength)); dumpf("#define RbSaveArea 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea)); dumpf("#define RbHaltReason 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, HaltReason) ); dumpf("#define RbLogoutFrame 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, LogoutFrame) ); dumpf("#define RbPalBase 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, PalBase) ); dumpf("#define RbIntV0 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntV0) ); dumpf("#define RbIntT0 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntT0) ); dumpf("#define RbIntT1 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntT1) ); dumpf("#define RbIntT2 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntT2) ); dumpf("#define RbIntT3 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntT3) ); dumpf("#define RbIntT4 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntT4) ); dumpf("#define RbIntT5 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntT5) ); dumpf("#define RbIntT6 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntT6) ); dumpf("#define RbIntT7 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntT7) ); dumpf("#define RbIntS0 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntS0) ); dumpf("#define RbIntS1 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntS1) ); dumpf("#define RbIntS2 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntS2) ); dumpf("#define RbIntS3 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntS3) ); dumpf("#define RbIntS4 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntS4) ); dumpf("#define RbIntS5 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntS5) ); dumpf("#define RbIntFp 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntFp) ); dumpf("#define RbIntA0 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntA0) ); dumpf("#define RbIntA1 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntA1) ); dumpf("#define RbIntA2 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntA2) ); dumpf("#define RbIntA3 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntA3) ); dumpf("#define RbIntA4 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntA4) ); dumpf("#define RbIntA5 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntA5) ); dumpf("#define RbIntT8 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntT8) ); dumpf("#define RbIntT9 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntT9) ); dumpf("#define RbIntT10 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntT10) ); dumpf("#define RbIntT11 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntT11) ); dumpf("#define RbIntRa 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntRa) ); dumpf("#define RbIntT12 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntT12) ); dumpf("#define RbIntAT 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntAT) ); dumpf("#define RbIntGp 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntGp) ); dumpf("#define RbIntSp 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntSp) ); dumpf("#define RbIntZero 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, IntZero) ); dumpf("#define RbFpcr 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, Fpcr) ); dumpf("#define RbFltF0 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF0) ); dumpf("#define RbFltF1 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF1) ); dumpf("#define RbFltF2 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF2) ); dumpf("#define RbFltF3 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF3) ); dumpf("#define RbFltF4 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF4) ); dumpf("#define RbFltF5 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF5) ); dumpf("#define RbFltF6 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF6) ); dumpf("#define RbFltF7 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF7) ); dumpf("#define RbFltF8 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF8) ); dumpf("#define RbFltF9 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF9) ); dumpf("#define RbFltF10 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF10) ); dumpf("#define RbFltF11 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF11) ); dumpf("#define RbFltF12 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF12) ); dumpf("#define RbFltF13 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF13) ); dumpf("#define RbFltF14 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF14) ); dumpf("#define RbFltF15 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF15) ); dumpf("#define RbFltF16 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF16) ); dumpf("#define RbFltF17 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF17) ); dumpf("#define RbFltF18 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF18) ); dumpf("#define RbFltF19 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF19) ); dumpf("#define RbFltF20 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF20) ); dumpf("#define RbFltF21 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF21) ); dumpf("#define RbFltF22 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF22) ); dumpf("#define RbFltF23 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF23) ); dumpf("#define RbFltF24 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF24) ); dumpf("#define RbFltF25 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF25) ); dumpf("#define RbFltF26 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF26) ); dumpf("#define RbFltF27 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF27) ); dumpf("#define RbFltF28 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF28) ); dumpf("#define RbFltF29 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF29) ); dumpf("#define RbFltF30 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF30) ); dumpf("#define RbFltF31 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, FltF31) ); dumpf("#define RbAsn 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, Asn) ); dumpf("#define RbGeneralEntry 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, GeneralEntry) ); dumpf("#define RbIksp 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, Iksp) ); dumpf("#define RbInterruptEntry 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, InterruptEntry) ); dumpf("#define RbKgp 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, Kgp) ); dumpf("#define RbMces 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, Mces) ); dumpf("#define RbMemMgmtEntry 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, MemMgmtEntry) ); dumpf("#define RbPanicEntry 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, PanicEntry) ); dumpf("#define RbPcr 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, Pcr) ); dumpf("#define RbPdr 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, Pdr) ); dumpf("#define RbPsr 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, Psr) ); dumpf("#define RbReiRestartAddress 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, ReiRestartAddress) ); dumpf("#define RbSirr 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, Sirr) ); dumpf("#define RbSyscallEntry 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, SyscallEntry) ); dumpf("#define RbTeb 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, Teb) ); dumpf("#define RbThread 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, Thread) ); dumpf("#define RbPerProcessorState 0x%lx\n", OFFSET(RESTART_BLOCK, u.SaveArea) + OFFSET(ALPHA_RESTART_SAVE_AREA, PerProcessorState) ); // // Address space layout definitions // dumpf("\n"); dumpf("//\n"); dumpf("// Address Space Layout Definitions\n"); dumpf("//\n"); dumpf("\n"); dumpf("#define KSEG0_BASE 0x%lx\n", KSEG0_BASE ); dumpf("#define KSEG2_BASE 0x%lx\n", KSEG2_BASE ); DisableInc( HALALPHA ); dumpf("#define SYSTEM_BASE 0x%lx\n", SYSTEM_BASE); dumpf("#define PDE_BASE 0x%lx\n", PDE_BASE); dumpf("#define PTE_BASE 0x%lx\n", PTE_BASE); // // Page table and page directory entry definitions // EnableInc( HALALPHA ); dumpf("\n"); dumpf("//\n"); dumpf("// Page Table and Directory Entry Definitions\n"); dumpf("//\n"); dumpf("\n"); dumpf("#define PAGE_SIZE 0x%lx\n", PAGE_SIZE); dumpf("#define PAGE_SHIFT 0x%lx\n", PAGE_SHIFT); dumpf("#define PDI_SHIFT 0x%lx\n", PDI_SHIFT); dumpf("#define PTI_SHIFT 0x%lx\n", PTI_SHIFT); DisableInc( HALALPHA ); // // Breakpoint instruction definitions // EnableInc( HALALPHA ); dumpf("\n"); dumpf("//\n"); dumpf("// Breakpoint Definitions\n"); dumpf("//\n"); dumpf("\n"); dumpf("#define USER_BREAKPOINT 0x%lx\n", USER_BREAKPOINT); dumpf("#define KERNEL_BREAKPOINT 0x%lx\n", KERNEL_BREAKPOINT); dumpf("#define BREAKIN_BREAKPOINT 0x%lx\n", BREAKIN_BREAKPOINT); dumpf("#define DEBUG_PRINT_BREAKPOINT 0x%lx\n", DEBUG_PRINT_BREAKPOINT); dumpf("#define DEBUG_PROMPT_BREAKPOINT 0x%lx\n", DEBUG_PROMPT_BREAKPOINT); dumpf("#define DEBUG_STOP_BREAKPOINT 0x%lx\n", DEBUG_STOP_BREAKPOINT); dumpf("#define DEBUG_LOAD_SYMBOLS_BREAKPOINT 0x%lx\n", DEBUG_LOAD_SYMBOLS_BREAKPOINT); dumpf("#define DEBUG_UNLOAD_SYMBOLS_BREAKPOINT 0x%lx\n", DEBUG_UNLOAD_SYMBOLS_BREAKPOINT); DisableInc( HALALPHA ); // // // Trap code definitions // dumpf("\n"); dumpf("//\n"); dumpf("// Trap Code Definitions\n"); dumpf("//\n"); dumpf("\n"); dumpf("#define GENTRAP_INTEGER_OVERFLOW 0x%lx\n", GENTRAP_INTEGER_OVERFLOW); dumpf("#define GENTRAP_INTEGER_DIVIDE_BY_ZERO 0x%lx\n", GENTRAP_INTEGER_DIVIDE_BY_ZERO); dumpf("#define GENTRAP_FLOATING_OVERFLOW 0x%lx\n", GENTRAP_FLOATING_OVERFLOW); dumpf("#define GENTRAP_FLOATING_DIVIDE_BY_ZERO 0x%lx\n", GENTRAP_FLOATING_DIVIDE_BY_ZERO); dumpf("#define GENTRAP_FLOATING_UNDERFLOW 0x%lx\n", GENTRAP_FLOATING_UNDERFLOW); dumpf("#define GENTRAP_FLOATING_INVALID_OPERAND 0x%lx\n", GENTRAP_FLOATING_INVALID_OPERAND); dumpf("#define GENTRAP_FLOATING_INEXACT_RESULT 0x%lx\n", GENTRAP_FLOATING_INEXACT_RESULT); // // Miscellaneous definitions // EnableInc( HALALPHA ); dumpf("\n"); dumpf("//\n"); dumpf("// Miscellaneous Definitions\n"); dumpf("//\n"); dumpf("\n"); dumpf("#define Executive 0x%lx\n", Executive); dumpf("#define KernelMode 0x%lx\n", KernelMode); dumpf("#define FALSE 0x%lx\n", FALSE); dumpf("#define TRUE 0x%lx\n", TRUE); DisableInc( HALALPHA ); dumpf("#define BASE_PRIORITY_THRESHOLD 0x%lx\n", BASE_PRIORITY_THRESHOLD); dumpf("#define EVENT_PAIR_INCREMENT 0x%lx\n", EVENT_PAIR_INCREMENT); dumpf("#define LOW_REALTIME_PRIORITY 0x%lx\n", LOW_REALTIME_PRIORITY); dumpf("#define MM_USER_PROBE_ADDRESS 0x%lx\n", MM_USER_PROBE_ADDRESS); dumpf("#define KERNEL_STACK_SIZE 0x%lx\n", KERNEL_STACK_SIZE); dumpf("#define KERNEL_LARGE_STACK_COMMIT 0x%lx\n", KERNEL_LARGE_STACK_COMMIT); dumpf("#define SET_LOW_WAIT_HIGH 0x%lx\n", SET_LOW_WAIT_HIGH); dumpf("#define SET_HIGH_WAIT_LOW 0x%lx\n", SET_HIGH_WAIT_LOW); dumpf("#define CLOCK_QUANTUM_DECREMENT 0x%lx\n", CLOCK_QUANTUM_DECREMENT); dumpf("#define READY_SKIP_QUANTUM 0x%lx\n", READY_SKIP_QUANTUM); dumpf("#define THREAD_QUANTUM 0x%lx\n", THREAD_QUANTUM); dumpf("#define WAIT_QUANTUM_DECREMENT 0x%lx\n", WAIT_QUANTUM_DECREMENT); dumpf("#define ROUND_TRIP_DECREMENT_COUNT 0x%lx\n", ROUND_TRIP_DECREMENT_COUNT); // // Generate processor type definitions. // EnableInc( HALALPHA ); dumpf("#define PROCESSOR_ALPHA_21064 0x%lx\n", PROCESSOR_ALPHA_21064); dumpf("#define PROCESSOR_ALPHA_21164 0x%lx\n", PROCESSOR_ALPHA_21164); dumpf("#define PROCESSOR_ALPHA_21066 0x%lx\n", PROCESSOR_ALPHA_21066); dumpf("#define PROCESSOR_ALPHA_21068 0x%lx\n", PROCESSOR_ALPHA_21068); DisableInc( HALALPHA ); // // Generate pte masks and offsets // pte.mask = 0; pte.p.Valid = 0xffffffff; dumpf( "#define PTE_VALID_MASK 0x%lx\n", pte.mask ); dumpf( "#define PTE_VALID 0x%lx\n", v(pte.mask) ); pte.p.Valid = 0; pte.p.Owner = 0xffffffff; dumpf( "#define PTE_OWNER_MASK 0x%lx\n", pte.mask ); dumpf( "#define PTE_OWNER 0x%lx\n", v(pte.mask) ); pte.p.Owner = 0; pte.p.Dirty = 0xffffffff; dumpf( "#define PTE_DIRTY_MASK 0x%lx\n", pte.mask ); dumpf( "#define PTE_DIRTY 0x%lx\n", v(pte.mask) ); pte.p.Dirty = 0; pte.p.Global = 0xffffffff; dumpf( "#define PTE_GLOBAL_MASK 0x%lx\n", pte.mask ); dumpf( "#define PTE_GLOBAL 0x%lx\n", v(pte.mask) ); pte.p.Global = 0; pte.p.Write = 0xffffffff; dumpf( "#define PTE_WRITE_MASK 0x%lx\n", pte.mask ); dumpf( "#define PTE_WRITE 0x%lx\n", v(pte.mask) ); pte.p.Write = 0; pte.p.CopyOnWrite = 0xffffffff; dumpf( "#define PTE_COPYONWRITE_MASK 0x%lx\n", pte.mask ); dumpf( "#define PTE_COPYONWRITE 0x%lx\n", v(pte.mask) ); pte.p.CopyOnWrite = 0; pte.p.PageFrameNumber = 0xffffffff; dumpf( "#define PTE_PFN_MASK 0x%lx\n", pte.mask ); dumpf( "#define PTE_PFN 0x%lx\n", v(pte.mask) ); pte.p.PageFrameNumber = 0; psr.mask = 0; psr.p.MODE = 0xffffffff; dumpf( "#define PSR_MODE_MASK 0x%lx\n", psr.mask ); dumpf( "#define PSR_USER_MODE 0x%lx\n", psr.mask ); dumpf( "#define PSR_MODE 0x%lx\n", v(psr.mask) ); psr.p.MODE = 0; psr.p.INTERRUPT_ENABLE = 0xffffffff; dumpf( "#define PSR_IE_MASK 0x%lx\n", psr.mask ); dumpf( "#define PSR_IE 0x%lx\n", v(psr.mask) ); psr.p.INTERRUPT_ENABLE = 0; psr.p.IRQL = 0xffffffff; dumpf( "#define PSR_IRQL_MASK 0x%lx\n", psr.mask ); dumpf( "#define PSR_IRQL 0x%lx\n", v(psr.mask) ); psr.p.IRQL = 0; ie.mask = 0; ie.i.SoftwareInterruptEnables = 0xffffffff; dumpf( "#define IE_SFW_MASK 0x%lx\n", ie.mask ); dumpf( "#define IE_SFW 0x%lx\n", v(ie.mask) ); ie.i.SoftwareInterruptEnables = 0; ie.i.HardwareInterruptEnables = 0xffffffff; dumpf( "#define IE_HDW_MASK 0x%lx\n", ie.mask ); dumpf( "#define IE_HDW 0x%lx\n", v(ie.mask) ); ie.i.HardwareInterruptEnables = 0; EnableInc( HALALPHA ); mchk.mask = 0; mchk.m.Correctable = 0xffffffff; dumpf( "#define MCHK_CORRECTABLE_MASK 0x%lx\n", mchk.mask ); dumpf( "#define MCHK_CORRECTABLE 0x%lx\n", v(mchk.mask)); mchk.m.Correctable = 0; mchk.m.Retryable = 0xffffffff; dumpf( "#define MCHK_RETRYABLE_MASK 0x%lx\n", mchk.mask ); dumpf( "#define MCHK_RETRYABLE 0x%lx\n", v(mchk.mask) ); mchk.m.Retryable = 0; mces.mask = 0; mces.m.MachineCheck = 0xffffffff; dumpf( "#define MCES_MCK_MASK 0x%lx\n", mces.mask ); dumpf( "#define MCES_MCK 0x%lx\n", v(mces.mask) ); mces.m.MachineCheck = 0; mces.m.SystemCorrectable = 0xffffffff; dumpf( "#define MCES_SCE_MASK 0x%lx\n", mces.mask ); dumpf( "#define MCES_SCE 0x%lx\n", v(mces.mask) ); mces.m.SystemCorrectable = 0; mces.m.ProcessorCorrectable = 0xffffffff; dumpf( "#define MCES_PCE_MASK 0x%lx\n", mces.mask ); dumpf( "#define MCES_PCE 0x%lx\n", v(mces.mask) ); mces.m.ProcessorCorrectable = 0; mces.m.DisableProcessorCorrectable = 0xffffffff; dumpf( "#define MCES_DPC_MASK 0x%lx\n", mces.mask ); dumpf( "#define MCES_DPC 0x%lx\n", v(mces.mask) ); mces.m.DisableProcessorCorrectable = 0; mces.m.DisableSystemCorrectable = 0xffffffff; dumpf( "#define MCES_DSC_MASK 0x%lx\n", mces.mask ); dumpf( "#define MCES_DSC 0x%lx\n", v(mces.mask) ); mces.m.DisableSystemCorrectable = 0; mces.m.DisableMachineChecks = 0xffffffff; dumpf( "#define MCES_DMCK_MASK 0x%lx\n", mces.mask ); dumpf( "#define MCES_DMCK 0x%lx\n", v(mces.mask) ); mces.m.DisableMachineChecks = 0; DisableInc( HALALPHA ); excsum.mask = 0; excsum.e.SoftwareCompletion = 0xffffffff; dumpf( "#define EXCSUM_SWC_MASK 0x%lx\n", excsum.mask ); dumpf( "#define EXCSUM_SWC 0x%lx\n", v(excsum.mask) ); excsum.e.SoftwareCompletion = 0; excsum.e.InvalidOperation = 0xffffffff; dumpf( "#define EXCSUM_INV_MASK 0x%lx\n", excsum.mask ); dumpf( "#define EXCSUM_INV 0x%lx\n", v(excsum.mask) ); excsum.e.InvalidOperation = 0; excsum.e.DivisionByZero = 0xffffffff; dumpf( "#define EXCSUM_DZE_MASK 0x%lx\n", excsum.mask ); dumpf( "#define EXCSUM_DZE 0x%lx\n", v(excsum.mask) ); excsum.e.DivisionByZero = 0; excsum.e.Overflow = 0xffffffff; dumpf( "#define EXCSUM_OVF_MASK 0x%lx\n", excsum.mask ); dumpf( "#define EXCSUM_OVF 0x%lx\n", v(excsum.mask) ); excsum.e.Overflow = 0; excsum.e.Underflow = 0xffffffff; dumpf( "#define EXCSUM_UNF_MASK 0x%lx\n", excsum.mask ); dumpf( "#define EXCSUM_UNF 0x%lx\n", v(excsum.mask) ); excsum.e.Underflow = 0; excsum.e.InexactResult = 0xffffffff; dumpf( "#define EXCSUM_INE_MASK 0x%lx\n", excsum.mask ); dumpf( "#define EXCSUM_INE 0x%lx\n", v(excsum.mask) ); excsum.e.InexactResult = 0; excsum.e.IntegerOverflow = 0xffffffff; dumpf( "#define EXCSUM_IOV_MASK 0x%lx\n", excsum.mask ); dumpf( "#define EXCSUM_IOV 0x%lx\n", v(excsum.mask) ); excsum.e.IntegerOverflow = 0; // // Generate the call pal mnemonic to opcode definitions. // EnableInc( HALALPHA ); GenerateCallPalNames(); // // Close header file. // fprintf(stderr, " Finished\n"); return; } #include "alphaops.h" // // N.B. any new call pal functions must be added to both alphaops.h // and to the call pal entry table below. // struct _CALLPAL_ENTRY{ SHORT CallPalFunction; char *CallPalMnemonic; } CallPals[] = { // Unprivileged Call Pals { BPT_FUNC, BPT_FUNC_STR }, { CALLSYS_FUNC, CALLSYS_FUNC_STR }, { IMB_FUNC, IMB_FUNC_STR }, { GENTRAP_FUNC, GENTRAP_FUNC_STR }, { RDTEB_FUNC, RDTEB_FUNC_STR }, { KBPT_FUNC, KBPT_FUNC_STR }, { CALLKD_FUNC, CALLKD_FUNC_STR }, // Privileged Call Pals { HALT_FUNC, HALT_FUNC_STR }, { RESTART_FUNC, RESTART_FUNC_STR }, { DRAINA_FUNC, DRAINA_FUNC_STR }, { REBOOT_FUNC, REBOOT_FUNC_STR }, { INITPAL_FUNC, INITPAL_FUNC_STR }, { WRENTRY_FUNC, WRENTRY_FUNC_STR }, { SWPIRQL_FUNC, SWPIRQL_FUNC_STR }, { RDIRQL_FUNC, RDIRQL_FUNC_STR }, { DI_FUNC, DI_FUNC_STR }, { EI_FUNC, EI_FUNC_STR }, { SWPPAL_FUNC, SWPPAL_FUNC_STR }, { SSIR_FUNC, SSIR_FUNC_STR }, { CSIR_FUNC, CSIR_FUNC_STR }, { RFE_FUNC, RFE_FUNC_STR }, { RETSYS_FUNC, RETSYS_FUNC_STR }, { SWPCTX_FUNC, SWPCTX_FUNC_STR }, { SWPPROCESS_FUNC, SWPPROCESS_FUNC_STR }, { RDMCES_FUNC, RDMCES_FUNC_STR }, { WRMCES_FUNC, WRMCES_FUNC_STR }, { TBIA_FUNC, TBIA_FUNC_STR }, { TBIS_FUNC, TBIS_FUNC_STR }, { TBISASN_FUNC, TBISASN_FUNC_STR }, { DTBIS_FUNC, DTBIS_FUNC_STR }, { RDKSP_FUNC, RDKSP_FUNC_STR }, { SWPKSP_FUNC, SWPKSP_FUNC_STR }, { RDPSR_FUNC, RDPSR_FUNC_STR }, { RDPCR_FUNC, RDPCR_FUNC_STR }, { RDTHREAD_FUNC, RDTHREAD_FUNC_STR }, { TBIM_FUNC, TBIM_FUNC_STR }, { TBIMASN_FUNC, TBIMASN_FUNC_STR }, { RDCOUNTERS_FUNC, RDCOUNTERS_FUNC_STR }, { RDSTATE_FUNC, RDSTATE_FUNC_STR }, { WRPERFMON_FUNC, WRPERFMON_FUNC_STR }, // 21064 (EV4) - specific functions { INITPCR_FUNC, INITPCR_FUNC_STR }, // End of structure indicator { -1, "" }, }; VOID GenerateCallPalNames( VOID ) { struct _CALLPAL_ENTRY *CallPal = CallPals; dumpf("\n"); dumpf("//\n"); dumpf("// Call PAL mnemonics\n"); dumpf("//\n"); dumpf("\n"); dumpf("// begin callpal\n" ); dumpf("\n" ); while( CallPal->CallPalFunction != -1 ){ dumpf( "#define %s 0x%lx\n", CallPal->CallPalMnemonic, CallPal->CallPalFunction ); CallPal++; } dumpf("\n" ); dumpf("// end callpal\n" ); dumpf("\n" ); } VOID dumpf( const char *format, ... ) { va_list(arglist); va_start(arglist, format); if( OutputEnabled & KSALPHA ){ vfprintf( KsAlpha, format, arglist ); } if( OutputEnabled & HALALPHA ){ vfprintf( HalAlpha, format, arglist ); } va_end(arglist); }