test: genmips.c File Reference

Main Page | Class Hierarchy | Class List | File List | Class Members | File Members

# genmips.c File Reference

`#include "ki.h"`
`#include "excpt.h"`
`#include "ntdef.h"`
`#include "ntkeapi.h"`
`#include "ntmips.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 "kxmips.h"`
`#include "stdarg.h"`
`#include "setjmp.h"`
`#include "..\genxx.inc"`

Go to the source code of this file.

## Defines

#define | HEADER_FILE
#define | genAlt(Name, Type, Member) dumpf("#define " #Name " 0x%lx\n", OFFSET(Type, Member))
#define | genCom(Comment)
#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 | OFFSET(type, field) ((LONG)(&((type *)0)->field))
#define | EnableInc(a) OutputEnabled |= a;
#define | DisableInc(a) OutputEnabled &= ~a;
#define | KSMIPS 0x01
#define | HALMIPS 0x02
#define | KERNEL KSMIPS
#define | HAL HALMIPS

## Functions

VOID | dumpf (const char *format,...)
LONG | t (IN ULONG z)
VOID | main (int argc, argv)

## Variables

FILE * | KsMips
FILE * | HalMips
ULONG | OutputEnabled

## Define Documentation

#define DisableInc | ( | a |  | ) | OutputEnabled &= ~a;

| Definition at line 91 of file genmips.c.

#define EnableInc | ( | a |  | ) | OutputEnabled |= a;

| Definition at line 85 of file genmips.c.

#define genAlt | ( | Name,
|  | Type,
|  | Member |  | ) | dumpf("#define " #Name " 0x%lx\n", OFFSET(Type, Member))

| Definition at line 54 of file genmips.c.

#define genCom | ( | Comment |  | ) |

Value:

    dumpf("\n");               \
        dumpf("//\n");             \
        dumpf("// " Comment "\n"); \
        dumpf("//\n");             \
        dumpf("\n")

Definition at line 57 of file genmips.c.

#define genDef | ( | Prefix,
|  | Type,
|  | Member |  | ) | dumpf("#define " #Prefix #Member " 0x%lx\n", OFFSET(Type, Member))

| Definition at line 64 of file genmips.c.

#define genSpc | (

)

dumpf("\n");

| Definition at line 70 of file genmips.c.

#define genVal | ( | Name,
|  | Value |  | ) | dumpf("#define " #Name " 0x%lx\n", Value)

| Definition at line 67 of file genmips.c.

#define HAL HALMIPS

| Definition at line 99 of file genmips.c.

#define HALMIPS 0x02

| Definition at line 96 of file genmips.c. Referenced by dumpf(), and main().

#define HEADER_FILE

| Definition at line 25 of file genmips.c.

#define KERNEL KSMIPS

| Definition at line 98 of file genmips.c.

#define KSMIPS 0x01

| Definition at line 95 of file genmips.c. Referenced by dumpf(), and main().

#define OFFSET | ( | type,
|  | field |  | ) | ((LONG)(&((type *)0)->field))

| Definition at line 76 of file genmips.c.

## Function Documentation

VOID dumpf | ( | const char * | format,
|  |  | ...
| ) |

Definition at line 993 of file genmips.c.

References format, HalMips, HALMIPS, KsMips, KSMIPS, NULL, and OutputEnabled.

    00998 {
    00999
    01000     va_list(arglist);
    01001
    01002     va_start(arglist, format);
    01003
    01004     if (((OutputEnabled & KSMIPS) != 0) && (KsMips != NULL)) {
    01005         vfprintf (KsMips, format, arglist);
    01006     }
    01007
    01008     if (((OutputEnabled & HALMIPS) != 0) && (HalMips != NULL)) {
    01009         vfprintf (HalMips, format, arglist);
    01010     }
    01011
    01012     va_end(arglist);
    01013 }

VOID main | ( | int | argc,
|  | argv |
| ) |

Definition at line 130 of file genmips.c.

References A1, APC_INTERRUPT, APC_LEVEL, BASE_PRIORITY_THRESHOLD, BREAKIN_BREAKPOINT, Buffer, ChangeColor, CLOCK_QUANTUM_DECREMENT, CONTEXT_CONTROL, CONTEXT_EXTENDED_FLOAT, CONTEXT_EXTENDED_INTEGER, CONTEXT_FLOATING_POINT, CONTEXT_FULL, CONTEXT_INTEGER, ContextFrameLength, DisableInc, DISPATCH_INTERRUPT, DISPATCH_LEVEL, dumpf(), EnableInc, EVENT_PAIR_INCREMENT, ExArgs, ExceptionFrameLength, Executive, FALSE, genAlt, genCom, genDef, genSpc, genVal, HALMIPS, HalMips, IPI_APC, IPI_DPC, IPI_FREEZE, IPI_PACKET_READY, KeDcacheFlushCount, KeIcacheFlushCount, KERNEL_BREAKPOINT, KernelMode, KiPcr, KiPcr2, KIPI_COUNTS, KSEG0_BASE, KSEG1_BASE, KSEG2_BASE, KSMIPS, KsMips, KUSEG_BASE, NULL, OFFSET, PAGE_SHIFT, PAGE_SIZE, PCR_MAJOR_VERSION, PCR_MINOR_VERSION, PDI_SHIFT, PRCB_MAJOR_VERSION, PRCB_MINOR_VERSION, PTI_SHIFT, READY_SKIP_QUANTUM, ROUND_TRIP_DECREMENT_COUNT, SetMember, THREAD_QUANTUM, TrapFrameArguments, TrapFrameLength, TrArgs, TrOnInterruptStack, TrTrapFrame, TRUE, UNCACHED_POLICY, USER_BREAKPOINT, and WAIT_QUANTUM_DECREMENT.

    00133 {
    00134
    00135     char *outName;
    00136     LONG EventOffset;
    00137
    00138     //
    00139     // Create file for output.
    00140     //
    00141
    00142     if (argc == 2) {
    00143         outName = argv[ 1 ];
    00144     } else {
    00145         outName = "\\nt\\public\\sdk\\inc\\ksmips.h";
    00146     }
    00147
    00148     outName = argc >= 2 ? argv[1] : "\\nt\\public\\sdk\\inc\\ksmips.h";
    00149     KsMips = fopen( outName, "w" );
    00150     if (KsMips == NULL) {
    00151         fprintf( stderr, "GENMIPS: Cannot open %s for writing.\n", outName);
    00152
    00153     } else {
    00154         fprintf(stderr, "GENMIPS: Writing %s header file.\n", outName);
    00155     }
    00156
    00157     outName = argc >= 3 ? argv[2] : "\\nt\\private\\ntos\\inc\\halmips.h";
    00158     HalMips = fopen( outName, "w" );
    00159     if (HalMips == NULL) {
    00160         fprintf( stderr, "GENMIPS: Cannot open %s for writing.\n", outName);
    00161
    00162     } else {
    00163         fprintf(stderr, "GENMIPS: Writing %s header file.\n", outName);
    00164     }
    00165
    00166     //
    00167     // Include statement for MIPS architecture static definitions.
    00168     //
    00169
    00170     EnableInc (KSMIPS | HALMIPS);
    00171     dumpf("#include \"kxmips.h\"\n");
    00172     DisableInc (HALMIPS);
    00173
    00174     //
    00175     // Include architecture independent definitions.
    00176     //
    00177
    00178 #include "..\genxx.inc"
    00179
    00180     //
    00181     // Generate architecture dependent definitions.
    00182     //
    00183     // Processor block structure definitions.
    00184     //
    00185
    00186     EnableInc(HALMIPS);
    00187
    00188     genCom("Processor Block Structure Offset Definitions");
    00189
    00190     genVal(PRCB_MINOR_VERSION, PRCB_MINOR_VERSION);
    00191     genVal(PRCB_MAJOR_VERSION, PRCB_MAJOR_VERSION);
    00192
    00193     genSpc();
    00194
    00195     genDef(Pb, KPRCB, MinorVersion);
    00196     genDef(Pb, KPRCB, MajorVersion);
    00197     genDef(Pb, KPRCB, CurrentThread);
    00198     genDef(Pb, KPRCB, NextThread);
    00199     genDef(Pb, KPRCB, IdleThread);
    00200     genDef(Pb, KPRCB, Number);
    00201     genDef(Pb, KPRCB, SetMember);
    00202     genDef(Pb, KPRCB, RestartBlock);
    00203     genDef(Pb, KPRCB, SystemReserved);
    00204     genDef(Pb, KPRCB, HalReserved);
    00205
    00206     DisableInc(HALMIPS);
    00207
    00208     genDef(Pb, KPRCB, DpcTime);
    00209     genDef(Pb, KPRCB, InterruptTime);
    00210     genDef(Pb, KPRCB, KernelTime);
    00211     genDef(Pb, KPRCB, UserTime);
    00212     genDef(Pb, KPRCB, AdjustDpcThreshold);
    00213     genDef(Pb, KPRCB, InterruptCount);
    00214     genDef(Pb, KPRCB, ApcBypassCount);
    00215     genDef(Pb, KPRCB, DpcBypassCount);
    00216     genDef(Pb, KPRCB, IpiFrozen);
    00217     genDef(Pb, KPRCB, ProcessorState);
    00218     genAlt(PbAlignmentFixupCount, KPRCB, KeAlignmentFixupCount);
    00219     genAlt(PbContextSwitches, KPRCB, KeContextSwitches);
    00220     genAlt(PbDcacheFlushCount, KPRCB, KeDcacheFlushCount);
    00221     genAlt(PbExceptionDispatchCount, KPRCB, KeExceptionDispatchCount);
    00222     genAlt(PbFirstLevelTbFills, KPRCB, KeFirstLevelTbFills);
    00223     genAlt(PbFloatingEmulationCount, KPRCB, KeFloatingEmulationCount);
    00224     genAlt(PbIcacheFlushCount, KPRCB, KeIcacheFlushCount);
    00225     genAlt(PbSecondLevelTbFills, KPRCB, KeSecondLevelTbFills);
    00226     genAlt(PbSystemCalls, KPRCB, KeSystemCalls);
    00227     genDef(Pb, KPRCB, CurrentPacket);
    00228     genDef(Pb, KPRCB, TargetSet);
    00229     genDef(Pb, KPRCB, WorkerRoutine);
    00230     genDef(Pb, KPRCB, RequestSummary);
    00231     genDef(Pb, KPRCB, SignalDone);
    00232     genDef(Pb, KPRCB, DpcInterruptRequested);
    00233     genDef(Pb, KPRCB, MaximumDpcQueueDepth);
    00234     genDef(Pb, KPRCB, MinimumDpcRate);
    00235     genDef(Pb, KPRCB, IpiCounts);
    00236     genDef(Pb, KPRCB, StartCount);
    00237     genDef(Pb, KPRCB, DpcLock);
    00238     genDef(Pb, KPRCB, DpcListHead);
    00239     genDef(Pb, KPRCB, DpcQueueDepth);
    00240     genDef(Pb, KPRCB, DpcCount);
    00241     genDef(Pb, KPRCB, DpcLastCount);
    00242     genDef(Pb, KPRCB, DpcRequestRate);
    00243     genDef(Pb, KPRCB, DpcRoutineActive);
    00244     genVal(ProcessorBlockLength, ((sizeof(KPRCB) + 15) & ~15));
    00245
    00246     //
    00247     // Processor control register structure definitions.
    00248     //
    00249
    00250 #if defined(_MIPS_)
    00251
    00252     EnableInc(HALMIPS);
    00253
    00254     genCom("Processor Control Registers Structure Offset Definitions");
    00255
    00256     genVal(PCR_MINOR_VERSION, PCR_MINOR_VERSION);
    00257     genVal(PCR_MAJOR_VERSION, PCR_MAJOR_VERSION);
    00258
    00259     genSpc();
    00260
    00261     genDef(Pc, KPCR, MinorVersion);
    00262     genDef(Pc, KPCR, MajorVersion);
    00263     genDef(Pc, KPCR, InterruptRoutine);
    00264     genDef(Pc, KPCR, XcodeDispatch);
    00265     genDef(Pc, KPCR, FirstLevelDcacheSize);
    00266     genDef(Pc, KPCR, FirstLevelDcacheFillSize);
    00267     genDef(Pc, KPCR, FirstLevelIcacheSize);
    00268     genDef(Pc, KPCR, FirstLevelIcacheFillSize);
    00269     genDef(Pc, KPCR, SecondLevelDcacheSize);
    00270     genDef(Pc, KPCR, SecondLevelDcacheFillSize);
    00271     genDef(Pc, KPCR, SecondLevelIcacheSize);
    00272     genDef(Pc, KPCR, SecondLevelIcacheFillSize);
    00273     genDef(Pc, KPCR, Prcb);
    00274     genDef(Pc, KPCR, Teb);
    00275     genDef(Pc, KPCR, TlsArray);
    00276     genDef(Pc, KPCR, DcacheFillSize);
    00277     genDef(Pc, KPCR, IcacheAlignment);
    00278     genDef(Pc, KPCR, IcacheFillSize);
    00279     genDef(Pc, KPCR, ProcessorId);
    00280     genDef(Pc, KPCR, ProfileInterval);
    00281     genDef(Pc, KPCR, ProfileCount);
    00282     genDef(Pc, KPCR, StallExecutionCount);
    00283     genDef(Pc, KPCR, StallScaleFactor);
    00284     genDef(Pc, KPCR, Number);
    00285     genDef(Pc, KPCR, DataBusError);
    00286     genDef(Pc, KPCR, InstructionBusError);
    00287     genDef(Pc, KPCR, CachePolicy);
    00288     genDef(Pc, KPCR, IrqlMask);
    00289     genDef(Pc, KPCR, IrqlTable);
    00290     genDef(Pc, KPCR, CurrentIrql);
    00291     genDef(Pc, KPCR, SetMember);
    00292     genDef(Pc, KPCR, CurrentThread);
    00293     genDef(Pc, KPCR, AlignedCachePolicy);
    00294     genDef(Pc, KPCR, NotMember);
    00295     genDef(Pc, KPCR, SystemReserved);
    00296     genDef(Pc, KPCR, DcacheAlignment);
    00297     genDef(Pc, KPCR, HalReserved);
    00298
    00299     DisableInc(HALMIPS);
    00300
    00301     genDef(Pc, KPCR, FirstLevelActive);
    00302     genDef(Pc, KPCR, DpcRoutineActive);
    00303     genDef(Pc, KPCR, CurrentPid);
    00304     genDef(Pc, KPCR, OnInterruptStack);
    00305     genDef(Pc, KPCR, SavedInitialStack);
    00306     genDef(Pc, KPCR, SavedStackLimit);
    00307     genDef(Pc, KPCR, SystemServiceDispatchStart);
    00308     genDef(Pc, KPCR, SystemServiceDispatchEnd);
    00309     genDef(Pc, KPCR, InterruptStack);
    00310     genDef(Pc, KPCR, PanicStack);
    00311     genDef(Pc, KPCR, InitialStack);
    00312     genDef(Pc, KPCR, StackLimit);
    00313     genDef(Pc, KPCR, SavedEpc);
    00314     genDef(Pc, KPCR, SavedT7);
    00315     genDef(Pc, KPCR, SavedT8);
    00316     genDef(Pc, KPCR, SavedT9);
    00317     genDef(Pc, KPCR, SystemGp);
    00318     genDef(Pc, KPCR, QuantumEnd);
    00319     genDef(Pc, KPCR, BadVaddr);
    00320     genDef(Pc, KPCR, TmpVaddr);
    00321     genVal(ProcessorControlRegisterLength, ((sizeof(KPCR) + 15) & ~15));
    00322
    00323     genSpc();
    00324
    00325     genDef(Pc2, KUSER_SHARED_DATA, TickCountLow);
    00326     genDef(Pc2, KUSER_SHARED_DATA, TickCountMultiplier);
    00327     genDef(Pc2, KUSER_SHARED_DATA, InterruptTime);
    00328     genDef(Pc2, KUSER_SHARED_DATA, SystemTime);
    00329
    00330 #endif
    00331
    00332     //
    00333     // TB entry structure offset definitions.
    00334     //
    00335
    00336 #if defined(_MIPS_)
    00337
    00338     genCom("TB Entry Structure Offset Definitions");
    00339
    00340     genDef(Tb, TB_ENTRY, Entrylo0);
    00341     genDef(Tb, TB_ENTRY, Entrylo1);
    00342     genDef(Tb, TB_ENTRY, Entryhi);
    00343     genDef(Tb, TB_ENTRY, Pagemask);
    00344
    00345 #endif
    00346
    00347     //
    00348     //
    00349     // Interprocessor command definitions.
    00350     //
    00351
    00352     genCom("Immediate Interprocessor Command Definitions");
    00353
    00354     genVal(IPI_APC, IPI_APC);
    00355     genVal(IPI_DPC, IPI_DPC);
    00356     genVal(IPI_FREEZE, IPI_FREEZE);
    00357     genVal(IPI_PACKET_READY, IPI_PACKET_READY);
    00358
    00359     //
    00360     // Interprocessor interrupt count structure offset definitions.
    00361     //
    00362
    00363     genCom("Interprocessor Interrupt Count Structure Offset Definitions");
    00364
    00365     genDef(Ic, KIPI_COUNTS, Freeze);
    00366     genDef(Ic, KIPI_COUNTS, Packet);
    00367     genDef(Ic, KIPI_COUNTS, DPC);
    00368     genDef(Ic, KIPI_COUNTS, APC);
    00369     genDef(Ic, KIPI_COUNTS, FlushSingleTb);
    00370     genDef(Ic, KIPI_COUNTS, FlushMultipleTb);
    00371     genDef(Ic, KIPI_COUNTS, FlushEntireTb);
    00372     genDef(Ic, KIPI_COUNTS, GenericCall);
    00373     genDef(Ic, KIPI_COUNTS, ChangeColor);
    00374     genDef(Ic, KIPI_COUNTS, SweepDcache);
    00375     genDef(Ic, KIPI_COUNTS, SweepIcache);
    00376     genDef(Ic, KIPI_COUNTS, SweepIcacheRange);
    00377     genDef(Ic, KIPI_COUNTS, FlushIoBuffers);
    00378     genDef(Ic, KIPI_COUNTS, GratuitousDPC);
    00379
    00380     //
    00381     // Context frame offset definitions and flag definitions.
    00382     //
    00383
    00384     EnableInc (HALMIPS);
    00385
    00386     genCom("Context Frame Offset and Flag Definitions");
    00387
    00388     genVal(CONTEXT_FULL, CONTEXT_FULL);
    00389     genVal(CONTEXT_CONTROL, CONTEXT_CONTROL);
    00390     genVal(CONTEXT_FLOATING_POINT, CONTEXT_FLOATING_POINT);
    00391     genVal(CONTEXT_INTEGER, CONTEXT_INTEGER);
    00392     genVal(CONTEXT_EXTENDED_FLOAT, CONTEXT_EXTENDED_FLOAT);
    00393     genVal(CONTEXT_EXTENDED_INTEGER, CONTEXT_EXTENDED_INTEGER);
    00394
    00395     genCom("32-bit Context Frame Offset Definitions");
    00396
    00397     genDef(Cx, CONTEXT, FltF0);
    00398     genDef(Cx, CONTEXT, FltF1);
    00399     genDef(Cx, CONTEXT, FltF2);
    00400     genDef(Cx, CONTEXT, FltF3);
    00401     genDef(Cx, CONTEXT, FltF4);
    00402     genDef(Cx, CONTEXT, FltF5);
    00403     genDef(Cx, CONTEXT, FltF6);
    00404     genDef(Cx, CONTEXT, FltF7);
    00405     genDef(Cx, CONTEXT, FltF8);
    00406     genDef(Cx, CONTEXT, FltF9);
    00407     genDef(Cx, CONTEXT, FltF10);
    00408     genDef(Cx, CONTEXT, FltF11);
    00409     genDef(Cx, CONTEXT, FltF12);
    00410     genDef(Cx, CONTEXT, FltF13);
    00411     genDef(Cx, CONTEXT, FltF14);
    00412     genDef(Cx, CONTEXT, FltF15);
    00413     genDef(Cx, CONTEXT, FltF16);
    00414     genDef(Cx, CONTEXT, FltF17);
    00415     genDef(Cx, CONTEXT, FltF18);
    00416     genDef(Cx, CONTEXT, FltF19);
    00417     genDef(Cx, CONTEXT, FltF20);
    00418     genDef(Cx, CONTEXT, FltF21);
    00419     genDef(Cx, CONTEXT, FltF22);
    00420     genDef(Cx, CONTEXT, FltF23);
    00421     genDef(Cx, CONTEXT, FltF24);
    00422     genDef(Cx, CONTEXT, FltF25);
    00423     genDef(Cx, CONTEXT, FltF26);
    00424     genDef(Cx, CONTEXT, FltF27);
    00425     genDef(Cx, CONTEXT, FltF28);
    00426     genDef(Cx, CONTEXT, FltF29);
    00427     genDef(Cx, CONTEXT, FltF30);
    00428     genDef(Cx, CONTEXT, FltF31);
    00429     genDef(Cx, CONTEXT, IntZero);
    00430     genDef(Cx, CONTEXT, IntAt);
    00431     genDef(Cx, CONTEXT, IntV0);
    00432     genDef(Cx, CONTEXT, IntV1);
    00433     genDef(Cx, CONTEXT, IntA0);
    00434     genDef(Cx, CONTEXT, IntA1);
    00435     genDef(Cx, CONTEXT, IntA2);
    00436     genDef(Cx, CONTEXT, IntA3);
    00437     genDef(Cx, CONTEXT, IntT0);
    00438     genDef(Cx, CONTEXT, IntT1);
    00439     genDef(Cx, CONTEXT, IntT2);
    00440     genDef(Cx, CONTEXT, IntT3);
    00441     genDef(Cx, CONTEXT, IntT4);
    00442     genDef(Cx, CONTEXT, IntT5);
    00443     genDef(Cx, CONTEXT, IntT6);
    00444     genDef(Cx, CONTEXT, IntT7);
    00445     genDef(Cx, CONTEXT, IntS0);
    00446     genDef(Cx, CONTEXT, IntS1);
    00447     genDef(Cx, CONTEXT, IntS2);
    00448     genDef(Cx, CONTEXT, IntS3);
    00449     genDef(Cx, CONTEXT, IntS4);
    00450     genDef(Cx, CONTEXT, IntS5);
    00451     genDef(Cx, CONTEXT, IntS6);
    00452     genDef(Cx, CONTEXT, IntS7);
    00453     genDef(Cx, CONTEXT, IntT8);
    00454     genDef(Cx, CONTEXT, IntT9);
    00455     genDef(Cx, CONTEXT, IntK0);
    00456     genDef(Cx, CONTEXT, IntK1);
    00457     genDef(Cx, CONTEXT, IntGp);
    00458     genDef(Cx, CONTEXT, IntSp);
    00459     genDef(Cx, CONTEXT, IntS8);
    00460     genDef(Cx, CONTEXT, IntRa);
    00461     genDef(Cx, CONTEXT, IntLo);
    00462     genDef(Cx, CONTEXT, IntHi);
    00463     genDef(Cx, CONTEXT, Fsr);
    00464     genDef(Cx, CONTEXT, Fir);
    00465     genDef(Cx, CONTEXT, Psr);
    00466     genDef(Cx, CONTEXT, ContextFlags);
    00467
    00468     genCom("64-bit Context Frame Offset Definitions");
    00469
    00470     genDef(Cx, CONTEXT, XFltF0);
    00471     genDef(Cx, CONTEXT, XFltF1);
    00472     genDef(Cx, CONTEXT, XFltF2);
    00473     genDef(Cx, CONTEXT, XFltF3);
    00474     genDef(Cx, CONTEXT, XFltF4);
    00475     genDef(Cx, CONTEXT, XFltF5);
    00476     genDef(Cx, CONTEXT, XFltF6);
    00477     genDef(Cx, CONTEXT, XFltF7);
    00478     genDef(Cx, CONTEXT, XFltF8);
    00479     genDef(Cx, CONTEXT, XFltF9);
    00480     genDef(Cx, CONTEXT, XFltF10);
    00481     genDef(Cx, CONTEXT, XFltF11);
    00482     genDef(Cx, CONTEXT, XFltF12);
    00483     genDef(Cx, CONTEXT, XFltF13);
    00484     genDef(Cx, CONTEXT, XFltF14);
    00485     genDef(Cx, CONTEXT, XFltF15);
    00486     genDef(Cx, CONTEXT, XFltF16);
    00487     genDef(Cx, CONTEXT, XFltF17);
    00488     genDef(Cx, CONTEXT, XFltF18);
    00489     genDef(Cx, CONTEXT, XFltF19);
    00490     genDef(Cx, CONTEXT, XFltF20);
    00491     genDef(Cx, CONTEXT, XFltF21);
    00492     genDef(Cx, CONTEXT, XFltF22);
    00493     genDef(Cx, CONTEXT, XFltF23);
    00494     genDef(Cx, CONTEXT, XFltF24);
    00495     genDef(Cx, CONTEXT, XFltF25);
    00496     genDef(Cx, CONTEXT, XFltF26);
    00497     genDef(Cx, CONTEXT, XFltF27);
    00498     genDef(Cx, CONTEXT, XFltF28);
    00499     genDef(Cx, CONTEXT, XFltF29);
    00500     genDef(Cx, CONTEXT, XFltF30);
    00501     genDef(Cx, CONTEXT, XFltF31);
    00502     genDef(Cx, CONTEXT, XFsr);
    00503     genDef(Cx, CONTEXT, XFir);
    00504     genDef(Cx, CONTEXT, XPsr);
    00505     genDef(Cx, CONTEXT, XContextFlags);
    00506     genDef(Cx, CONTEXT, XIntZero);
    00507     genDef(Cx, CONTEXT, XIntAt);
    00508     genDef(Cx, CONTEXT, XIntV0);
    00509     genDef(Cx, CONTEXT, XIntV1);
    00510     genDef(Cx, CONTEXT, XIntA0);
    00511     genDef(Cx, CONTEXT, XIntA1);
    00512     genDef(Cx, CONTEXT, XIntA2);
    00513     genDef(Cx, CONTEXT, XIntA3);
    00514     genDef(Cx, CONTEXT, XIntT0);
    00515     genDef(Cx, CONTEXT, XIntT1);
    00516     genDef(Cx, CONTEXT, XIntT2);
    00517     genDef(Cx, CONTEXT, XIntT3);
    00518     genDef(Cx, CONTEXT, XIntT4);
    00519     genDef(Cx, CONTEXT, XIntT5);
    00520     genDef(Cx, CONTEXT, XIntT6);
    00521     genDef(Cx, CONTEXT, XIntT7);
    00522     genDef(Cx, CONTEXT, XIntS0);
    00523     genDef(Cx, CONTEXT, XIntS1);
    00524     genDef(Cx, CONTEXT, XIntS2);
    00525     genDef(Cx, CONTEXT, XIntS3);
    00526     genDef(Cx, CONTEXT, XIntS4);
    00527     genDef(Cx, CONTEXT, XIntS5);
    00528     genDef(Cx, CONTEXT, XIntS6);
    00529     genDef(Cx, CONTEXT, XIntS7);
    00530     genDef(Cx, CONTEXT, XIntT8);
    00531     genDef(Cx, CONTEXT, XIntT9);
    00532     genDef(Cx, CONTEXT, XIntK0);
    00533     genDef(Cx, CONTEXT, XIntK1);
    00534     genDef(Cx, CONTEXT, XIntGp);
    00535     genDef(Cx, CONTEXT, XIntSp);
    00536     genDef(Cx, CONTEXT, XIntS8);
    00537     genDef(Cx, CONTEXT, XIntRa);
    00538     genDef(Cx, CONTEXT, XIntLo);
    00539     genDef(Cx, CONTEXT, XIntHi);
    00540     genVal(ContextFrameLength, sizeof(CONTEXT));
    00541
    00542     //
    00543     // Exception frame offset definitions.
    00544     //
    00545
    00546     genCom("Exception Frame Offset Definitions and Length");
    00547
    00548     genAlt(ExArgs, KEXCEPTION_FRAME, Argument);
    00549
    00550     genCom("32-bit Nonvolatile Floating State");
    00551
    00552     genDef(Ex, KEXCEPTION_FRAME, FltF20);
    00553     genDef(Ex, KEXCEPTION_FRAME, FltF21);
    00554     genDef(Ex, KEXCEPTION_FRAME, FltF22);
    00555     genDef(Ex, KEXCEPTION_FRAME, FltF23);
    00556     genDef(Ex, KEXCEPTION_FRAME, FltF24);
    00557     genDef(Ex, KEXCEPTION_FRAME, FltF25);
    00558     genDef(Ex, KEXCEPTION_FRAME, FltF26);
    00559     genDef(Ex, KEXCEPTION_FRAME, FltF27);
    00560     genDef(Ex, KEXCEPTION_FRAME, FltF28);
    00561     genDef(Ex, KEXCEPTION_FRAME, FltF29);
    00562     genDef(Ex, KEXCEPTION_FRAME, FltF30);
    00563     genDef(Ex, KEXCEPTION_FRAME, FltF31);
    00564
    00565     genCom("64-bit Nonvolatile Floating State");
    00566
    00567     genDef(Ex, KEXCEPTION_FRAME, XFltF20);
    00568     genDef(Ex, KEXCEPTION_FRAME, XFltF22);
    00569     genDef(Ex, KEXCEPTION_FRAME, XFltF24);
    00570     genDef(Ex, KEXCEPTION_FRAME, XFltF26);
    00571     genDef(Ex, KEXCEPTION_FRAME, XFltF28);
    00572     genDef(Ex, KEXCEPTION_FRAME, XFltF30);
    00573
    00574     genCom("32-bit Nonvolatile Integer State");
    00575
    00576     genDef(Ex, KEXCEPTION_FRAME, IntS0);
    00577     genDef(Ex, KEXCEPTION_FRAME, IntS1);
    00578     genDef(Ex, KEXCEPTION_FRAME, IntS2);
    00579     genDef(Ex, KEXCEPTION_FRAME, IntS3);
    00580     genDef(Ex, KEXCEPTION_FRAME, IntS4);
    00581     genDef(Ex, KEXCEPTION_FRAME, IntS5);
    00582     genDef(Ex, KEXCEPTION_FRAME, IntS6);
    00583     genDef(Ex, KEXCEPTION_FRAME, IntS7);
    00584     genDef(Ex, KEXCEPTION_FRAME, IntS8);
    00585     genDef(Ex, KEXCEPTION_FRAME, SwapReturn);
    00586     genDef(Ex, KEXCEPTION_FRAME, IntRa);
    00587     genVal(ExceptionFrameLength, sizeof(KEXCEPTION_FRAME));
    00588
    00589     //
    00590     // Jump buffer offset definitions.
    00591     //
    00592
    00593   DisableInc (HALMIPS);
    00594
    00595     genCom("Jump Offset Definitions and Length");
    00596
    00597     genDef(Jb, _JUMP_BUFFER, FltF20);
    00598     genDef(Jb, _JUMP_BUFFER, FltF21);
    00599     genDef(Jb, _JUMP_BUFFER, FltF22);
    00600     genDef(Jb, _JUMP_BUFFER, FltF23);
    00601     genDef(Jb, _JUMP_BUFFER, FltF24);
    00602     genDef(Jb, _JUMP_BUFFER, FltF25);
    00603     genDef(Jb, _JUMP_BUFFER, FltF26);
    00604     genDef(Jb, _JUMP_BUFFER, FltF27);
    00605     genDef(Jb, _JUMP_BUFFER, FltF28);
    00606     genDef(Jb, _JUMP_BUFFER, FltF29);
    00607     genDef(Jb, _JUMP_BUFFER, FltF30);
    00608     genDef(Jb, _JUMP_BUFFER, FltF31);
    00609     genDef(Jb, _JUMP_BUFFER, IntS0);
    00610     genDef(Jb, _JUMP_BUFFER, IntS1);
    00611     genDef(Jb, _JUMP_BUFFER, IntS2);
    00612     genDef(Jb, _JUMP_BUFFER, IntS3);
    00613     genDef(Jb, _JUMP_BUFFER, IntS4);
    00614     genDef(Jb, _JUMP_BUFFER, IntS5);
    00615     genDef(Jb, _JUMP_BUFFER, IntS6);
    00616     genDef(Jb, _JUMP_BUFFER, IntS7);
    00617     genDef(Jb, _JUMP_BUFFER, IntS8);
    00618     genDef(Jb, _JUMP_BUFFER, IntSp);
    00619     genDef(Jb, _JUMP_BUFFER, Type);
    00620     genDef(Jb, _JUMP_BUFFER, Fir);
    00621
    00622     //
    00623     // Trap frame offset definitions.
    00624     //
    00625
    00626   EnableInc (HALMIPS);
    00627
    00628     genCom("Trap Frame Offset Definitions and Length");
    00629
    00630     genAlt(TrArgs, KTRAP_FRAME, Argument);
    00631
    00632     genCom("32-bit Volatile Floating State");
    00633
    00634     genDef(Tr, KTRAP_FRAME, FltF0);
    00635     genDef(Tr, KTRAP_FRAME, FltF1);
    00636     genDef(Tr, KTRAP_FRAME, FltF2);
    00637     genDef(Tr, KTRAP_FRAME, FltF3);
    00638     genDef(Tr, KTRAP_FRAME, FltF4);
    00639     genDef(Tr, KTRAP_FRAME, FltF5);
    00640     genDef(Tr, KTRAP_FRAME, FltF6);
    00641     genDef(Tr, KTRAP_FRAME, FltF7);
    00642     genDef(Tr, KTRAP_FRAME, FltF8);
    00643     genDef(Tr, KTRAP_FRAME, FltF9);
    00644     genDef(Tr, KTRAP_FRAME, FltF10);
    00645     genDef(Tr, KTRAP_FRAME, FltF11);
    00646     genDef(Tr, KTRAP_FRAME, FltF12);
    00647     genDef(Tr, KTRAP_FRAME, FltF13);
    00648     genDef(Tr, KTRAP_FRAME, FltF14);
    00649     genDef(Tr, KTRAP_FRAME, FltF15);
    00650     genDef(Tr, KTRAP_FRAME, FltF16);
    00651     genDef(Tr, KTRAP_FRAME, FltF17);
    00652     genDef(Tr, KTRAP_FRAME, FltF18);
    00653     genDef(Tr, KTRAP_FRAME, FltF19);
    00654
    00655     genCom("64-bit Volatile Floating State");
    00656
    00657     genDef(Tr, KTRAP_FRAME, XFltF0);
    00658     genDef(Tr, KTRAP_FRAME, XFltF1);
    00659     genDef(Tr, KTRAP_FRAME, XFltF2);
    00660     genDef(Tr, KTRAP_FRAME, XFltF3);
    00661     genDef(Tr, KTRAP_FRAME, XFltF4);
    00662     genDef(Tr, KTRAP_FRAME, XFltF5);
    00663     genDef(Tr, KTRAP_FRAME, XFltF6);
    00664     genDef(Tr, KTRAP_FRAME, XFltF7);
    00665     genDef(Tr, KTRAP_FRAME, XFltF8);
    00666     genDef(Tr, KTRAP_FRAME, XFltF9);
    00667     genDef(Tr, KTRAP_FRAME, XFltF10);
    00668     genDef(Tr, KTRAP_FRAME, XFltF11);
    00669     genDef(Tr, KTRAP_FRAME, XFltF12);
    00670     genDef(Tr, KTRAP_FRAME, XFltF13);
    00671     genDef(Tr, KTRAP_FRAME, XFltF14);
    00672     genDef(Tr, KTRAP_FRAME, XFltF15);
    00673     genDef(Tr, KTRAP_FRAME, XFltF16);
    00674     genDef(Tr, KTRAP_FRAME, XFltF17);
    00675     genDef(Tr, KTRAP_FRAME, XFltF18);
    00676     genDef(Tr, KTRAP_FRAME, XFltF19);
    00677     genDef(Tr, KTRAP_FRAME, XFltF21);
    00678     genDef(Tr, KTRAP_FRAME, XFltF23);
    00679     genDef(Tr, KTRAP_FRAME, XFltF25);
    00680     genDef(Tr, KTRAP_FRAME, XFltF27);
    00681     genDef(Tr, KTRAP_FRAME, XFltF29);
    00682     genDef(Tr, KTRAP_FRAME, XFltF31);
    00683
    00684     genCom("64-bit Volatile Integer State");
    00685
    00686     genDef(Tr, KTRAP_FRAME, XIntZero);
    00687     genDef(Tr, KTRAP_FRAME, XIntAt);
    00688     genDef(Tr, KTRAP_FRAME, XIntV0);
    00689     genDef(Tr, KTRAP_FRAME, XIntV1);
    00690     genDef(Tr, KTRAP_FRAME, XIntA0);
    00691     genDef(Tr, KTRAP_FRAME, XIntA1);
    00692     genDef(Tr, KTRAP_FRAME, XIntA2);
    00693     genDef(Tr, KTRAP_FRAME, XIntA3);
    00694     genDef(Tr, KTRAP_FRAME, XIntT0);
    00695     genDef(Tr, KTRAP_FRAME, XIntT1);
    00696     genDef(Tr, KTRAP_FRAME, XIntT2);
    00697     genDef(Tr, KTRAP_FRAME, XIntT3);
    00698     genDef(Tr, KTRAP_FRAME, XIntT4);
    00699     genDef(Tr, KTRAP_FRAME, XIntT5);
    00700     genDef(Tr, KTRAP_FRAME, XIntT6);
    00701     genDef(Tr, KTRAP_FRAME, XIntT7);
    00702     genDef(Tr, KTRAP_FRAME, XIntS0);
    00703     genDef(Tr, KTRAP_FRAME, XIntS1);
    00704     genDef(Tr, KTRAP_FRAME, XIntS2);
    00705     genDef(Tr, KTRAP_FRAME, XIntS3);
    00706     genDef(Tr, KTRAP_FRAME, XIntS4);
    00707     genDef(Tr, KTRAP_FRAME, XIntS5);
    00708     genDef(Tr, KTRAP_FRAME, XIntS6);
    00709     genDef(Tr, KTRAP_FRAME, XIntS7);
    00710     genDef(Tr, KTRAP_FRAME, XIntT8);
    00711     genDef(Tr, KTRAP_FRAME, XIntT9);
    00712     genDef(Tr, KTRAP_FRAME, XIntGp);
    00713     genDef(Tr, KTRAP_FRAME, XIntSp);
    00714     genDef(Tr, KTRAP_FRAME, XIntS8);
    00715     genDef(Tr, KTRAP_FRAME, XIntRa);
    00716     genDef(Tr, KTRAP_FRAME, XIntLo);
    00717     genDef(Tr, KTRAP_FRAME, XIntHi);
    00718
    00719     genSpc();
    00720
    00721     genDef(Tr, KTRAP_FRAME, Fir);
    00722     genDef(Tr, KTRAP_FRAME, Fsr);
    00723     genDef(Tr, KTRAP_FRAME, Psr);
    00724     genDef(Tr, KTRAP_FRAME, ExceptionRecord);
    00725     genDef(Tr, KTRAP_FRAME, OldIrql);
    00726     genDef(Tr, KTRAP_FRAME, PreviousMode);
    00727     genDef(Tr, KTRAP_FRAME, SavedFlag);
    00728     genAlt(TrOnInterruptStack, KTRAP_FRAME, u.OnInterruptStack);
    00729     genAlt(TrTrapFrame, KTRAP_FRAME, u.TrapFrame);
    00730
    00731     genVal(TrapFrameLength, sizeof(KTRAP_FRAME));
    00732     genVal(TrapFrameArguments, KTRAP_FRAME_ARGUMENTS);
    00733
    00734     //
    00735     // Usermode callout kernel frame definitions
    00736     //
    00737
    00738     DisableInc(HALMIPS);
    00739
    00740     genCom("Usermode callout kernel frame definitions");
    00741
    00742     genDef(Cu, KCALLOUT_FRAME, F20);
    00743     genDef(Cu, KCALLOUT_FRAME, F21);
    00744     genDef(Cu, KCALLOUT_FRAME, F22);
    00745     genDef(Cu, KCALLOUT_FRAME, F23);
    00746     genDef(Cu, KCALLOUT_FRAME, F24);
    00747     genDef(Cu, KCALLOUT_FRAME, F25);
    00748     genDef(Cu, KCALLOUT_FRAME, F26);
    00749     genDef(Cu, KCALLOUT_FRAME, F27);
    00750     genDef(Cu, KCALLOUT_FRAME, F28);
    00751     genDef(Cu, KCALLOUT_FRAME, F29);
    00752     genDef(Cu, KCALLOUT_FRAME, F30);
    00753     genDef(Cu, KCALLOUT_FRAME, F31);
    00754     genDef(Cu, KCALLOUT_FRAME, S0);
    00755     genDef(Cu, KCALLOUT_FRAME, S1);
    00756     genDef(Cu, KCALLOUT_FRAME, S2);
    00757     genDef(Cu, KCALLOUT_FRAME, S3);
    00758     genDef(Cu, KCALLOUT_FRAME, S4);
    00759     genDef(Cu, KCALLOUT_FRAME, S5);
    00760     genDef(Cu, KCALLOUT_FRAME, S6);
    00761     genDef(Cu, KCALLOUT_FRAME, S7);
    00762     genDef(Cu, KCALLOUT_FRAME, S8);
    00763     genDef(Cu, KCALLOUT_FRAME, CbStk);
    00764     genDef(Cu, KCALLOUT_FRAME, TrFr);
    00765     genDef(Cu, KCALLOUT_FRAME, Fsr);
    00766     genDef(Cu, KCALLOUT_FRAME, InStk);
    00767     genDef(Cu, KCALLOUT_FRAME, Ra);
    00768     genVal(CuFrameLength, OFFSET(KCALLOUT_FRAME, A0));
    00769     genDef(Cu, KCALLOUT_FRAME, A0);
    00770     genDef(Cu, KCALLOUT_FRAME, A1);
    00771
    00772     //
    00773     // Usermode callout user frame definitions.
    00774     //
    00775
    00776     genCom("Usermode callout user frame definitions");
    00777
    00778     genDef(Ck, UCALLOUT_FRAME, Buffer);
    00779     genDef(Ck, UCALLOUT_FRAME, Length);
    00780     genDef(Ck, UCALLOUT_FRAME, ApiNumber);
    00781     genDef(Ck, UCALLOUT_FRAME, Sp);
    00782     genDef(Ck, UCALLOUT_FRAME, Ra);
    00783
    00784     EnableInc(HALMIPS);
    00785
    00786     //
    00787     // Loader Parameter Block offset definitions.
    00788     //
    00789
    00790     dumpf("\n");
    00791     dumpf("//\n");
    00792     dumpf("// Loader Parameter Block Offset Definitions\n");
    00793     dumpf("//\n");
    00794     dumpf("\n");
    00795
    00796     dumpf("#define LpbLoadOrderListHead 0x%lx\n",
    00797           OFFSET(LOADER_PARAMETER_BLOCK, LoadOrderListHead));
    00798
    00799     dumpf("#define LpbMemoryDescriptorListHead 0x%lx\n",
    00800           OFFSET(LOADER_PARAMETER_BLOCK, MemoryDescriptorListHead));
    00801
    00802     dumpf("#define LpbKernelStack 0x%lx\n",
    00803           OFFSET(LOADER_PARAMETER_BLOCK, KernelStack));
    00804
    00805     dumpf("#define LpbPrcb 0x%lx\n",
    00806           OFFSET(LOADER_PARAMETER_BLOCK, Prcb));
    00807
    00808     dumpf("#define LpbProcess 0x%lx\n",
    00809           OFFSET(LOADER_PARAMETER_BLOCK, Process));
    00810
    00811     dumpf("#define LpbThread 0x%lx\n",
    00812           OFFSET(LOADER_PARAMETER_BLOCK, Thread));
    00813
    00814     dumpf("#define LpbInterruptStack 0x%lx\n",
    00815           OFFSET(LOADER_PARAMETER_BLOCK, u.Mips.InterruptStack));
    00816
    00817     dumpf("#define LpbFirstLevelDcacheSize 0x%lx\n",
    00818           OFFSET(LOADER_PARAMETER_BLOCK, u.Mips.FirstLevelDcacheSize));
    00819
    00820     dumpf("#define LpbFirstLevelDcacheFillSize 0x%lx\n",
    00821           OFFSET(LOADER_PARAMETER_BLOCK, u.Mips.FirstLevelDcacheFillSize));
    00822
    00823     dumpf("#define LpbFirstLevelIcacheSize 0x%lx\n",
    00824           OFFSET(LOADER_PARAMETER_BLOCK, u.Mips.FirstLevelIcacheSize));
    00825
    00826     dumpf("#define LpbFirstLevelIcacheFillSize 0x%lx\n",
    00827           OFFSET(LOADER_PARAMETER_BLOCK, u.Mips.FirstLevelIcacheFillSize));
    00828
    00829     dumpf("#define LpbGpBase 0x%lx\n",
    00830           OFFSET(LOADER_PARAMETER_BLOCK, u.Mips.GpBase));
    00831
    00832     dumpf("#define LpbPanicStack 0x%lx\n",
    00833           OFFSET(LOADER_PARAMETER_BLOCK, u.Mips.PanicStack));
    00834
    00835     dumpf("#define LpbPcrPage 0x%lx\n",
    00836           OFFSET(LOADER_PARAMETER_BLOCK, u.Mips.PcrPage));
    00837
    00838     dumpf("#define LpbPdrPage 0x%lx\n",
    00839           OFFSET(LOADER_PARAMETER_BLOCK, u.Mips.PdrPage));
    00840
    00841     dumpf("#define LpbSecondLevelDcacheSize 0x%lx\n",
    00842           OFFSET(LOADER_PARAMETER_BLOCK, u.Mips.SecondLevelDcacheSize));
    00843
    00844     dumpf("#define LpbSecondLevelDcacheFillSize 0x%lx\n",
    00845           OFFSET(LOADER_PARAMETER_BLOCK, u.Mips.SecondLevelDcacheFillSize));
    00846
    00847     dumpf("#define LpbSecondLevelIcacheSize 0x%lx\n",
    00848           OFFSET(LOADER_PARAMETER_BLOCK, u.Mips.SecondLevelIcacheSize));
    00849
    00850     dumpf("#define LpbSecondLevelIcacheFillSize 0x%lx\n",
    00851           OFFSET(LOADER_PARAMETER_BLOCK, u.Mips.SecondLevelIcacheFillSize));
    00852
    00853     dumpf("#define LpbPcrPage2 0x%lx\n",
    00854           OFFSET(LOADER_PARAMETER_BLOCK, u.Mips.PcrPage2));
    00855
    00856     dumpf("#define LpbRegistryLength 0x%lx\n",
    00857           OFFSET(LOADER_PARAMETER_BLOCK, RegistryLength));
    00858
    00859     dumpf("#define LpbRegistryBase 0x%lx\n",
    00860           OFFSET(LOADER_PARAMETER_BLOCK, RegistryBase));
    00861
    00862     DisableInc (HALMIPS);
    00863
    00864     //
    00865     // Define Client/Server data structure definitions.
    00866     //
    00867
    00868     genCom("Client/Server Structure Definitions");
    00869
    00870     genDef(Cid, CLIENT_ID, UniqueProcess);
    00871     genDef(Cid, CLIENT_ID, UniqueThread);
    00872
    00873     //
    00874     // Address space layout definitions
    00875     //
    00876
    00877     EnableInc(HALMIPS);
    00878
    00879     genCom("Address Space Layout Definitions");
    00880
    00881     genVal(KUSEG_BASE, KUSEG_BASE);
    00882     genVal(KSEG0_BASE, KSEG0_BASE);
    00883     genVal(KSEG1_BASE, KSEG1_BASE);
    00884     genVal(KSEG2_BASE, KSEG2_BASE);
    00885
    00886     DisableInc(HALMIPS);
    00887
    00888     genVal(CACHE_ERROR_VECTOR, CACHE_ERROR_VECTOR);
    00889     genVal(SYSTEM_BASE, SYSTEM_BASE);
    00890     genVal(PDE_BASE, PDE_BASE);
    00891     genVal(PTE_BASE, PTE_BASE);
    00892     genVal(PDE64_BASE, PDE64_BASE);
    00893     genVal(PTE64_BASE, PTE64_BASE);
    00894
    00895     //
    00896     // Page table and page directory entry definitions
    00897     //
    00898
    00899     EnableInc(HALMIPS);
    00900
    00901     genCom("Page Table and Directory Entry Definitions");
    00902
    00903     genVal(PAGE_SIZE, PAGE_SIZE);
    00904     genVal(PAGE_SHIFT, PAGE_SHIFT);
    00905     genVal(PDI_SHIFT, PDI_SHIFT);
    00906     genVal(PTI_SHIFT, PTI_SHIFT);
    00907
    00908     //
    00909     // Software interrupt request mask definitions
    00910     //
    00911
    00912     genCom("Software Interrupt Request Mask Definitions");
    00913
    00914     genVal(APC_INTERRUPT, (1 << (APC_LEVEL + CAUSE_INTPEND - 1)));
    00915     genVal(DISPATCH_INTERRUPT, (1 << (DISPATCH_LEVEL + CAUSE_INTPEND - 1)));
    00916
    00917     DisableInc(HALMIPS);
    00918
    00919     //
    00920     // Breakpoint instruction definitions
    00921     //
    00922
    00923     EnableInc(HALMIPS);
    00924
    00925     genCom("Breakpoint Definitions");
    00926
    00927     genVal(USER_BREAKPOINT, USER_BREAKPOINT);
    00928     genVal(KERNEL_BREAKPOINT, KERNEL_BREAKPOINT);
    00929     genVal(BREAKIN_BREAKPOINT, BREAKIN_BREAKPOINT);
    00930
    00931     DisableInc(HALMIPS);
    00932
    00933     genVal(BRANCH_TAKEN_BREAKPOINT, BRANCH_TAKEN_BREAKPOINT);
    00934     genVal(BRANCH_NOT_TAKEN_BREAKPOINT, BRANCH_NOT_TAKEN_BREAKPOINT);
    00935     genVal(SINGLE_STEP_BREAKPOINT, SINGLE_STEP_BREAKPOINT);
    00936     genVal(DIVIDE_OVERFLOW_BREAKPOINT, DIVIDE_OVERFLOW_BREAKPOINT);
    00937     genVal(DIVIDE_BY_ZERO_BREAKPOINT, DIVIDE_BY_ZERO_BREAKPOINT);
    00938     genVal(RANGE_CHECK_BREAKPOINT, RANGE_CHECK_BREAKPOINT);
    00939     genVal(STACK_OVERFLOW_BREAKPOINT, STACK_OVERFLOW_BREAKPOINT);
    00940     genVal(MULTIPLY_OVERFLOW_BREAKPOINT, MULTIPLY_OVERFLOW_BREAKPOINT);
    00941     genVal(DEBUG_PRINT_BREAKPOINT, DEBUG_PRINT_BREAKPOINT);
    00942     genVal(DEBUG_PROMPT_BREAKPOINT, DEBUG_PROMPT_BREAKPOINT);
    00943     genVal(DEBUG_STOP_BREAKPOINT, DEBUG_STOP_BREAKPOINT);
    00944     genVal(DEBUG_LOAD_SYMBOLS_BREAKPOINT, DEBUG_LOAD_SYMBOLS_BREAKPOINT);
    00945     genVal(DEBUG_UNLOAD_SYMBOLS_BREAKPOINT, DEBUG_UNLOAD_SYMBOLS_BREAKPOINT);
    00946
    00947     //
    00948     // Miscellaneous definitions
    00949     //
    00950
    00951     EnableInc(HALMIPS);
    00952
    00953     genCom("Miscellaneous Definitions");
    00954
    00955     genVal(Executive, Executive);
    00956     genVal(KernelMode, KernelMode);
    00957     genVal(FALSE, FALSE);
    00958     genVal(TRUE, TRUE);
    00959     genVal(UNCACHED_POLICY, UNCACHED_POLICY);
    00960     genVal(KiPcr, KIPCR);
    00961     genVal(KiPcr2, KIPCR2);
    00962
    00963     DisableInc(HALMIPS);
    00964
    00965     genVal(UsPcr, USPCR);
    00966     genVal(UsPcr2, USPCR2);
    00967     genVal(BASE_PRIORITY_THRESHOLD, BASE_PRIORITY_THRESHOLD);
    00968     genVal(EVENT_PAIR_INCREMENT, EVENT_PAIR_INCREMENT);
    00969     genVal(LOW_REALTIME_PRIORITY, LOW_REALTIME_PRIORITY);
    00970     genVal(KERNEL_STACK_SIZE, KERNEL_STACK_SIZE);
    00971     genVal(KERNEL_LARGE_STACK_COMMIT, KERNEL_LARGE_STACK_COMMIT);
    00972     genVal(XCODE_VECTOR_LENGTH, XCODE_VECTOR_LENGTH);
    00973     genVal(MM_USER_PROBE_ADDRESS, MM_USER_PROBE_ADDRESS);
    00974     genVal(ROUND_TO_NEAREST, ROUND_TO_NEAREST);
    00975     genVal(ROUND_TO_ZERO, ROUND_TO_ZERO);
    00976     genVal(ROUND_TO_PLUS_INFINITY, ROUND_TO_PLUS_INFINITY);
    00977     genVal(ROUND_TO_MINUS_INFINITY, ROUND_TO_MINUS_INFINITY);
    00978     genVal(CLOCK_QUANTUM_DECREMENT, CLOCK_QUANTUM_DECREMENT);
    00979     genVal(READY_SKIP_QUANTUM, READY_SKIP_QUANTUM);
    00980     genVal(THREAD_QUANTUM, THREAD_QUANTUM);
    00981     genVal(WAIT_QUANTUM_DECREMENT, WAIT_QUANTUM_DECREMENT);
    00982     genVal(ROUND_TRIP_DECREMENT_COUNT, ROUND_TRIP_DECREMENT_COUNT);
    00983
    00984     //
    00985     // Close header file.
    00986     //
    00987
    00988     fprintf(stderr, "         Finished\n");
    00989     return;
    00990 }

LONG t | ( | IN ULONG | z | ) |

Definition at line 109 of file genmips.c.

Referenced by CmpQueryKeyName(), HvCheckHive(), HvpAddBin(), HvpAllocateMap(), HvpBuildMapAndCopy(), HvpInitMap(), HvRefreshHive(), KdpReadControlSpace(), and KiGetFloatRegisterValue().

    00113 {
    00114     LONG i;
    00115
    00116     for (i = 0; i < 32; i += 1) {
    00117         if ((z >> i) & 1) {
    00118             break;
    00119         }
    00120     }
    00121     return i;
    00122 }

## Variable Documentation

FILE* HalMips

| Definition at line 79 of file genmips.c. Referenced by dumpf(), and main().

FILE* KsMips

| Definition at line 78 of file genmips.c. Referenced by dumpf(), and main().

ULONG OutputEnabled

| Definition at line 93 of file genmips.c. Referenced by dumpf().