/*++
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);
}