/*++ Copyright (c) 1995 Microsoft Corporation Module Name: genxx.inc Abstract: This file contains common code to generate assembler definitions. Author: David N. Cutler (davec) 9-Aug-1995 Revision History: --*/ // // Process state enumerated type definitions. // genCom("Process State Enumerated Type Values"); genVal(ProcessInMemory, ProcessInMemory); genVal(ProcessOutOfMemory, ProcessOutOfMemory); genVal(ProcessInTransition, ProcessInTransition); // // Thread state enumerated type definitions. // genCom("Thread State Enumerated Type Values"); genVal(Initialized, Initialized); genVal(Ready, Ready); genVal(Running, Running); genVal(Standby, Standby); genVal(Terminated, Terminated); genVal(Waiting, Waiting); // // Wait reason and wait type enumerated type definitions. // EnableInc(HAL); genCom("Wait Reason and Wait Type Enumerated Type Values"); genVal(WrExecutive, Executive); DisableInc(HAL); genVal(WrEventPair, WrEventPair); genVal(WaitAny, WaitAny); genVal(WaitAll, WaitAll); // // APC state structure offset definitions. // genCom("Apc State Structure Offset Definitions"); genDef(As, KAPC_STATE, ApcListHead); genDef(As, KAPC_STATE, Process); genDef(As, KAPC_STATE, KernelApcInProgress); genDef(As, KAPC_STATE, KernelApcPending); genDef(As, KAPC_STATE, UserApcPending); // // Bug check code definitions // EnableInc(HAL); genCom("Bug Check Code Definitions"); genVal(APC_INDEX_MISMATCH, APC_INDEX_MISMATCH); genVal(DATA_BUS_ERROR, DATA_BUS_ERROR); genVal(DATA_COHERENCY_EXCEPTION, DATA_COHERENCY_EXCEPTION); genVal(HAL1_INITIALIZATION_FAILED, HAL1_INITIALIZATION_FAILED); genVal(INSTRUCTION_BUS_ERROR, INSTRUCTION_BUS_ERROR); genVal(INSTRUCTION_COHERENCY_EXCEPTION, INSTRUCTION_COHERENCY_EXCEPTION); genVal(INTERRUPT_EXCEPTION_NOT_HANDLED, INTERRUPT_EXCEPTION_NOT_HANDLED); genVal(INTERRUPT_UNWIND_ATTEMPTED, INTERRUPT_UNWIND_ATTEMPTED); genVal(INVALID_AFFINITY_SET, INVALID_AFFINITY_SET); genVal(INVALID_DATA_ACCESS_TRAP, INVALID_DATA_ACCESS_TRAP); genVal(IRQL_GT_ZERO_AT_SYSTEM_SERVICE, IRQL_GT_ZERO_AT_SYSTEM_SERVICE); genVal(IRQL_NOT_LESS_OR_EQUAL, IRQL_NOT_LESS_OR_EQUAL); genVal(KMODE_EXCEPTION_NOT_HANDLED, KMODE_EXCEPTION_NOT_HANDLED); genVal(NMI_HARDWARE_FAILURE, NMI_HARDWARE_FAILURE); genVal(NO_USER_MODE_CONTEXT, NO_USER_MODE_CONTEXT); genVal(PAGE_FAULT_WITH_INTERRUPTS_OFF, PAGE_FAULT_WITH_INTERRUPTS_OFF); genVal(PANIC_STACK_SWITCH, PANIC_STACK_SWITCH); genVal(SPIN_LOCK_INIT_FAILURE, SPIN_LOCK_INIT_FAILURE); genVal(SYSTEM_EXIT_OWNED_MUTEX, SYSTEM_EXIT_OWNED_MUTEX); genVal(SYSTEM_SERVICE_EXCEPTION, SYSTEM_SERVICE_EXCEPTION); genVal(SYSTEM_UNWIND_PREVIOUS_USER, SYSTEM_UNWIND_PREVIOUS_USER); genVal(TRAP_CAUSE_UNKNOWN, TRAP_CAUSE_UNKNOWN); genVal(UNEXPECTED_KERNEL_MODE_TRAP, UNEXPECTED_KERNEL_MODE_TRAP); DisableInc(HAL); // // Breakpoint types // EnableInc(HAL); genCom("Breakpoint type definitions"); genVal(DBG_STATUS_CONTROL_C, DBG_STATUS_CONTROL_C); DisableInc(HAL); // // Client Id structure offset definitions. // genCom("Client Id Structure Offset Definitions"); genDef(Cid, CLIENT_ID, UniqueProcess); genDef(Cid, CLIENT_ID, UniqueThread); // // Critical section structure offset definitions. // genCom("Critical Section Structure Offset Definitions"); genDef(Cs, RTL_CRITICAL_SECTION, DebugInfo); genDef(Cs, RTL_CRITICAL_SECTION, LockCount); genDef(Cs, RTL_CRITICAL_SECTION, RecursionCount); genDef(Cs, RTL_CRITICAL_SECTION, OwningThread); genDef(Cs, RTL_CRITICAL_SECTION, LockSemaphore); // // Critical section debug information structure offset definitions. // genCom("Critical Section Debug Information Structure Offset Definitions"); genDef(Cs, RTL_CRITICAL_SECTION_DEBUG, Type); genDef(Cs, RTL_CRITICAL_SECTION_DEBUG, CreatorBackTraceIndex); genDef(Cs, RTL_CRITICAL_SECTION_DEBUG, CriticalSection); genDef(Cs, RTL_CRITICAL_SECTION_DEBUG, ProcessLocksList); genDef(Cs, RTL_CRITICAL_SECTION_DEBUG, EntryCount); genDef(Cs, RTL_CRITICAL_SECTION_DEBUG, ContentionCount); // // Exception dispatcher context structure offset definitions. // #if defined(_ALPHA_) || defined(_MIPS_) || defined(_PPC_) genCom("Dispatcher Context Structure Offset Definitions"); genDef(Dc, DISPATCHER_CONTEXT, ControlPc); genDef(Dc, DISPATCHER_CONTEXT, FunctionEntry); genDef(Dc, DISPATCHER_CONTEXT, EstablisherFrame); genDef(Dc, DISPATCHER_CONTEXT, ContextRecord); #endif // // Exception record offset, flag, and enumerated type definitions. // EnableInc(HAL); genCom("Exception Record Offset, Flag, and Enumerated Type Definitions"); genVal(EXCEPTION_NONCONTINUABLE, EXCEPTION_NONCONTINUABLE); genVal(EXCEPTION_UNWINDING, EXCEPTION_UNWINDING); genVal(EXCEPTION_EXIT_UNWIND, EXCEPTION_EXIT_UNWIND); genVal(EXCEPTION_STACK_INVALID, EXCEPTION_STACK_INVALID); genVal(EXCEPTION_NESTED_CALL, EXCEPTION_NESTED_CALL); genVal(EXCEPTION_TARGET_UNWIND, EXCEPTION_TARGET_UNWIND); genVal(EXCEPTION_COLLIDED_UNWIND, EXCEPTION_COLLIDED_UNWIND); genVal(EXCEPTION_UNWIND, EXCEPTION_UNWIND); genVal(EXCEPTION_EXECUTE_HANDLER, EXCEPTION_EXECUTE_HANDLER); genVal(EXCEPTION_CONTINUE_SEARCH, EXCEPTION_CONTINUE_SEARCH); genVal(EXCEPTION_CONTINUE_EXECUTION, EXCEPTION_CONTINUE_EXECUTION); #if defined(_X86_) genVal(EXCEPTION_CHAIN_END, (ULONG)EXCEPTION_CHAIN_END); #endif genSpc(); genVal(ExceptionContinueExecution, ExceptionContinueExecution); genVal(ExceptionContinueSearch, ExceptionContinueSearch); genVal(ExceptionNestedException, ExceptionNestedException); genVal(ExceptionCollidedUnwind, ExceptionCollidedUnwind); genSpc(); genDef(Er, EXCEPTION_RECORD, ExceptionCode); genDef(Er, EXCEPTION_RECORD, ExceptionFlags); genDef(Er, EXCEPTION_RECORD, ExceptionRecord); genDef(Er, EXCEPTION_RECORD, ExceptionAddress); genDef(Er, EXCEPTION_RECORD, NumberParameters); genDef(Er, EXCEPTION_RECORD, ExceptionInformation); genVal(ExceptionRecordLength, (sizeof(EXCEPTION_RECORD) + 15) & (~15)); DisableInc(HAL); // // Fast Mutex structure offset definitions. // EnableInc(HAL); genCom("Fast Mutex Structure Offset Definitions"); genDef(Fm, FAST_MUTEX, Count); genDef(Fm, FAST_MUTEX, Owner); genDef(Fm, FAST_MUTEX, Contention); genDef(Fm, FAST_MUTEX, Event); genDef(Fm, FAST_MUTEX, OldIrql); // // Interrupt priority request level definitions // genCom("Interrupt Priority Request Level Definitions"); genVal(APC_LEVEL, APC_LEVEL); genVal(DISPATCH_LEVEL, DISPATCH_LEVEL); #if defined(_X86_) genVal(CLOCK1_LEVEL, CLOCK1_LEVEL); genVal(CLOCK2_LEVEL, CLOCK2_LEVEL); #endif genVal(IPI_LEVEL, IPI_LEVEL); genVal(POWER_LEVEL, POWER_LEVEL); genVal(PROFILE_LEVEL, PROFILE_LEVEL); genVal(HIGH_LEVEL, HIGH_LEVEL); genVal(SYNCH_LEVEL, SYNCH_LEVEL); // // Large integer structure offset definitions. // genCom("Large Integer Structure Offset Definitions"); genDef(Li, LARGE_INTEGER, LowPart); genDef(Li, LARGE_INTEGER, HighPart); // // List entry structure offset definitions. // genCom("List Entry Structure Offset Definitions"); genDef(Ls, LIST_ENTRY, Flink); genDef(Ls, LIST_ENTRY, Blink); // // String structure offset definitions. // genCom("String Structure Offset Definitions"); genDef(Str, STRING, Length); genDef(Str, STRING, MaximumLength); genDef(Str, STRING, Buffer); // // System time structure offset definitions. // #if defined(_MIPS_) || defined(_PPC_) || defined(_X86_) genCom("System Time Structure Offset Definitions"); genAlt(StLowTime, KSYSTEM_TIME, LowPart); genDef(St, KSYSTEM_TIME, High1Time); genDef(St, KSYSTEM_TIME, High2Time); #endif // // Time structure offset definitions. // genCom("Time Structure Offset Definitions"); genAlt(TmLowTime, LARGE_INTEGER, LowPart); genAlt(TmHighTime, LARGE_INTEGER , HighPart); DisableInc(HAL); // // Thread switch counter structure offset definitions. // genCom("Thread Switch Counter Offset Definitions"); genDef(Tw, KTHREAD_SWITCH_COUNTERS, FindAny); genDef(Tw, KTHREAD_SWITCH_COUNTERS, FindIdeal); genDef(Tw, KTHREAD_SWITCH_COUNTERS, FindLast); genDef(Tw, KTHREAD_SWITCH_COUNTERS, IdleAny); genDef(Tw, KTHREAD_SWITCH_COUNTERS, IdleCurrent); genDef(Tw, KTHREAD_SWITCH_COUNTERS, IdleIdeal); genDef(Tw, KTHREAD_SWITCH_COUNTERS, IdleLast); genDef(Tw, KTHREAD_SWITCH_COUNTERS, PreemptAny); genDef(Tw, KTHREAD_SWITCH_COUNTERS, PreemptCurrent); genDef(Tw, KTHREAD_SWITCH_COUNTERS, PreemptLast); genDef(Tw, KTHREAD_SWITCH_COUNTERS, SwitchToIdle); // // Status code definitions // genCom("Status Code Definitions"); #if defined(_ALPHA_) genVal(STATUS_ALPHA_ARITHMETIC_EXCEPTION, STATUS_ALPHA_ARITHMETIC_EXCEPTION); genVal(STATUS_ALPHA_BAD_VIRTUAL_ADDRESS, STATUS_ALPHA_BAD_VIRTUAL_ADDRESS); genVal(STATUS_ALPHA_FLOATING_NOT_IMPLEMENTED, STATUS_ALPHA_FLOATING_NOT_IMPLEMENTED); genVal(STATUS_ALPHA_GENTRAP, STATUS_ALPHA_GENTRAP); genVal(STATUS_ALPHA_MACHINE_CHECK, (DATA_BUS_ERROR | 0xdfff0000)); #endif genVal(STATUS_ACCESS_VIOLATION, STATUS_ACCESS_VIOLATION); genVal(STATUS_ARRAY_BOUNDS_EXCEEDED, STATUS_ARRAY_BOUNDS_EXCEEDED); genVal(STATUS_BAD_COMPRESSION_BUFFER, STATUS_BAD_COMPRESSION_BUFFER); genVal(STATUS_BREAKPOINT, STATUS_BREAKPOINT); genVal(STATUS_DATATYPE_MISALIGNMENT, STATUS_DATATYPE_MISALIGNMENT); genVal(STATUS_FLOAT_DENORMAL_OPERAND, STATUS_FLOAT_DENORMAL_OPERAND); genVal(STATUS_FLOAT_DIVIDE_BY_ZERO, STATUS_FLOAT_DIVIDE_BY_ZERO); genVal(STATUS_FLOAT_INEXACT_RESULT, STATUS_FLOAT_INEXACT_RESULT); genVal(STATUS_FLOAT_INVALID_OPERATION, STATUS_FLOAT_INVALID_OPERATION); genVal(STATUS_FLOAT_OVERFLOW, STATUS_FLOAT_OVERFLOW); genVal(STATUS_FLOAT_STACK_CHECK, STATUS_FLOAT_STACK_CHECK); genVal(STATUS_FLOAT_UNDERFLOW, STATUS_FLOAT_UNDERFLOW); genVal(STATUS_GUARD_PAGE_VIOLATION, STATUS_GUARD_PAGE_VIOLATION); genVal(STATUS_ILLEGAL_FLOAT_CONTEXT, STATUS_ILLEGAL_FLOAT_CONTEXT); genVal(STATUS_ILLEGAL_INSTRUCTION, STATUS_ILLEGAL_INSTRUCTION); genVal(STATUS_INSTRUCTION_MISALIGNMENT, STATUS_INSTRUCTION_MISALIGNMENT); genVal(STATUS_INVALID_HANDLE, STATUS_INVALID_HANDLE); genVal(STATUS_INVALID_LOCK_SEQUENCE, STATUS_INVALID_LOCK_SEQUENCE); genVal(STATUS_INVALID_OWNER, STATUS_INVALID_OWNER); genVal(STATUS_INVALID_PARAMETER_1, STATUS_INVALID_PARAMETER_1); genVal(STATUS_INVALID_SYSTEM_SERVICE, STATUS_INVALID_SYSTEM_SERVICE); genVal(STATUS_INTEGER_DIVIDE_BY_ZERO, STATUS_INTEGER_DIVIDE_BY_ZERO); genVal(STATUS_INTEGER_OVERFLOW, STATUS_INTEGER_OVERFLOW); genVal(STATUS_IN_PAGE_ERROR, STATUS_IN_PAGE_ERROR); genVal(STATUS_KERNEL_APC, STATUS_KERNEL_APC); genVal(STATUS_LONGJUMP, STATUS_LONGJUMP); genVal(STATUS_NO_CALLBACK_ACTIVE, STATUS_NO_CALLBACK_ACTIVE); genVal(STATUS_NO_EVENT_PAIR, STATUS_NO_EVENT_PAIR); genVal(STATUS_PRIVILEGED_INSTRUCTION, STATUS_PRIVILEGED_INSTRUCTION); genVal(STATUS_SINGLE_STEP, STATUS_SINGLE_STEP); genVal(STATUS_STACK_OVERFLOW, STATUS_STACK_OVERFLOW); genVal(STATUS_SUCCESS, STATUS_SUCCESS); genVal(STATUS_THREAD_IS_TERMINATING, STATUS_THREAD_IS_TERMINATING); genVal(STATUS_TIMEOUT, STATUS_TIMEOUT); genVal(STATUS_UNWIND, STATUS_UNWIND); genVal(STATUS_WAKE_SYSTEM_DEBUGGER, STATUS_WAKE_SYSTEM_DEBUGGER); // // Define kernel object structure definitions. // // APC object structure defintions. // genCom("APC Object Structure Offset Definitions"); genDef(Ap, KAPC, Type); genDef(Ap, KAPC, Size); genDef(Ap, KAPC, Thread); genDef(Ap, KAPC, ApcListEntry); genDef(Ap, KAPC, KernelRoutine); genDef(Ap, KAPC, RundownRoutine); genDef(Ap, KAPC, NormalRoutine); genDef(Ap, KAPC, NormalContext); genDef(Ap, KAPC, SystemArgument1); genDef(Ap, KAPC, SystemArgument2); genDef(Ap, KAPC, ApcStateIndex); genDef(Ap, KAPC, ApcMode); genDef(Ap, KAPC, Inserted); genVal(ApcObjectLength, sizeof(KAPC)); // // DPC Object structure definitions. // EnableInc(HAL); genCom("DPC object Structure Offset Definitions"); genDef(Dp, KDPC, Type); genDef(Dp, KDPC, Number); genDef(Dp, KDPC, Importance); genDef(Dp, KDPC, DpcListEntry); genDef(Dp, KDPC, DeferredRoutine); genDef(Dp, KDPC, DeferredContext); genDef(Dp, KDPC, SystemArgument1); genDef(Dp, KDPC, SystemArgument2); genDef(Dp, KDPC, Lock); genVal(DpcObjectLength, sizeof(KDPC)); DisableInc(HAL); // // Device queue object structure definitions. // genCom("Device Queue Object Structure Offset Definitions"); genDef(Dv, KDEVICE_QUEUE, Type); genDef(Dv, KDEVICE_QUEUE, Size); genDef(Dv, KDEVICE_QUEUE, DeviceListHead); genAlt(DvSpinLock, KDEVICE_QUEUE, Lock); genDef(Dv, KDEVICE_QUEUE, Busy); genVal(DeviceQueueObjectLength, sizeof(KDEVICE_QUEUE)); // // Device object entry structure definitions. // genCom("Device Queue Entry Structure Offset Definitions"); genDef(De, KDEVICE_QUEUE_ENTRY, DeviceListEntry); genDef(De, KDEVICE_QUEUE_ENTRY, SortKey); genDef(De, KDEVICE_QUEUE_ENTRY, Inserted); genVal(DeviceQueueEntryLength, sizeof(KDEVICE_QUEUE_ENTRY)); // // Event object structure definitions. // genCom("Event Object Structure Offset Definitions"); genDef(Ev, DISPATCHER_HEADER, Type); genDef(Ev, DISPATCHER_HEADER, Size); genDef(Ev, DISPATCHER_HEADER, SignalState); genAlt(EvWaitListHead, KEVENT, Header.WaitListHead); genVal(EventObjectLength, sizeof(KEVENT)); // // Event pair object structure definitions. // genCom("Event Pair Object Structure Offset Definitions"); genDef(Ep, KEVENT_PAIR, Type); genDef(Ep, KEVENT_PAIR, Size); genDef(Ep, KEVENT_PAIR, EventLow); genDef(Ep, KEVENT_PAIR, EventHigh); #if defined(_MIPS_) || defined(_PPC_) EventOffset = OFFSET(KEVENT_PAIR, EventHigh) - OFFSET(KEVENT_PAIR, EventLow); if ((EventOffset & (EventOffset - 1)) != 0) { fprintf(stderr, "GENXX: Event offset not log2N\n"); } genVal(SET_LOW_WAIT_HIGH, - (EventOffset * 2)); genVal(SET_HIGH_WAIT_LOW, - EventOffset); genVal(SET_EVENT_PAIR_MASK, EventOffset); #endif // // Interrupt object structure definitions. // #if defined(_ALPHA_) || defined(_MIPS_) || defined(_PPC_) EnableInc(HAL); #endif genCom("Interrupt Object Structure Offset Definitions"); genVal(InLevelSensitive, LevelSensitive); genVal(InLatched, Latched); genSpc(); genDef(In, KINTERRUPT, Type); genDef(In, KINTERRUPT, Size); genDef(In, KINTERRUPT, InterruptListEntry); genDef(In, KINTERRUPT, ServiceRoutine); genDef(In, KINTERRUPT, ServiceContext); genDef(In, KINTERRUPT, SpinLock); genDef(In, KINTERRUPT, ActualLock); genDef(In, KINTERRUPT, DispatchAddress); genDef(In, KINTERRUPT, Vector); genDef(In, KINTERRUPT, Irql); genDef(In, KINTERRUPT, SynchronizeIrql); genDef(In, KINTERRUPT, FloatingSave); genDef(In, KINTERRUPT, Connected); genDef(In, KINTERRUPT, Number); genDef(In, KINTERRUPT, Mode); genDef(In, KINTERRUPT, ShareVector); genDef(In, KINTERRUPT, DispatchCode); genVal(InterruptObjectLength, sizeof(KINTERRUPT)); #if defined(_X86_) genSpc(); genVal(NORMAL_DISPATCH_LENGTH, NORMAL_DISPATCH_LENGTH * sizeof(ULONG)); genVal(DISPATCH_LENGTH, DISPATCH_LENGTH * sizeof(ULONG)); #endif #if defined(_ALPHA_) || defined(_MIPS_) || defined(_PPC_) DisableInc(HAL); #endif // // Process object structure offset definitions. // genCom("Process Object Structure Offset Definitions"); genDef(Pr, DISPATCHER_HEADER, Type); genDef(Pr, DISPATCHER_HEADER, Size); genDef(Pr, DISPATCHER_HEADER, SignalState); genDef(Pr, KPROCESS, ProfileListHead); genDef(Pr, KPROCESS, DirectoryTableBase); #if defined(_X86_) genDef(Pr, KPROCESS, LdtDescriptor); genDef(Pr, KPROCESS, Int21Descriptor); genDef(Pr, KPROCESS, IopmOffset); genDef(Pr, KPROCESS, Iopl); genDef(Pr, KPROCESS, VdmFlag); #endif #if defined(_PPC_) genDef(Pr, KPROCESS, ProcessPid); genDef(Pr, KPROCESS, ProcessSequence); #endif genDef(Pr, KPROCESS, ActiveProcessors); genDef(Pr, KPROCESS, KernelTime); genDef(Pr, KPROCESS, UserTime); genDef(Pr, KPROCESS, ReadyListHead); genDef(Pr, KPROCESS, SwapListEntry); genDef(Pr, KPROCESS, ThreadListHead); genDef(Pr, KPROCESS, ProcessLock); genDef(Pr, KPROCESS, Affinity); genDef(Pr, KPROCESS, StackCount); genDef(Pr, KPROCESS, BasePriority); genDef(Pr, KPROCESS, ThreadQuantum); genDef(Pr, KPROCESS, AutoAlignment); genDef(Pr, KPROCESS, State); genVal(ProcessObjectLength, ((sizeof(KPROCESS) + 15) & ~15)); genVal(ExtendedProcessObjectLength, ((sizeof(EPROCESS) + 15) & ~15)); // // Profile object structure offset definitions. // genCom("Profile Object Structure Offset Definitions"); genDef(Pf, KPROFILE, Type); genDef(Pf, KPROFILE, Size); genDef(Pf, KPROFILE, ProfileListEntry); genDef(Pf, KPROFILE, Process); genDef(Pf, KPROFILE, RangeBase); genDef(Pf, KPROFILE, RangeLimit); genDef(Pf, KPROFILE, BucketShift); genDef(Pf, KPROFILE, Buffer); genDef(Pf, KPROFILE, Segment); genDef(Pf, KPROFILE, Affinity); genDef(Pf, KPROFILE, Source); genDef(Pf, KPROFILE, Started); genVal(ProfileObjectLength, sizeof(KPROFILE)); // // Queue object structure offset definitions. // genCom("Queue Object Structure Offset Definitions"); genDef(Qu, DISPATCHER_HEADER, Type); genDef(Qu, DISPATCHER_HEADER, Size); genDef(Qu, DISPATCHER_HEADER, SignalState); genDef(Qu, KQUEUE, EntryListHead); genDef(Qu, KQUEUE, CurrentCount); genDef(Qu, KQUEUE, MaximumCount); genDef(Qu, KQUEUE, ThreadListHead); genVal(QueueObjectLength, sizeof(KQUEUE)); // // Thread object structure offset definitions // genCom("Thread Object Structure Offset Definitions"); genDef(Ee, EEVENT_PAIR, KernelEventPair); genDef(Et, ETHREAD, Cid); genDef(Et, ETHREAD, EventPair); genDef(Et, ETHREAD, PerformanceCountLow); genDef(Et, ETHREAD, PerformanceCountHigh); genVal(EtEthreadLength, ((sizeof(ETHREAD) + 15) & ~15)); genSpc(); genDef(Th, DISPATCHER_HEADER, Type); genDef(Th, DISPATCHER_HEADER, Size); genDef(Th, DISPATCHER_HEADER, SignalState); genDef(Th, KTHREAD, MutantListHead); genDef(Th, KTHREAD, InitialStack); genDef(Th, KTHREAD, StackLimit); genDef(Th, KTHREAD, Teb); genDef(Th, KTHREAD, TlsArray); genDef(Th, KTHREAD, KernelStack); genDef(Th, KTHREAD, DebugActive); genDef(Th, KTHREAD, State); genDef(Th, KTHREAD, Alerted); genDef(Th, KTHREAD, Iopl); genDef(Th, KTHREAD, NpxState); genDef(Th, KTHREAD, Saturation); genDef(Th, KTHREAD, Priority); genDef(Th, KTHREAD, ApcState); genDef(Th, KTHREAD, ContextSwitches); genDef(Th, KTHREAD, WaitStatus); genDef(Th, KTHREAD, WaitIrql); genDef(Th, KTHREAD, WaitMode); genDef(Th, KTHREAD, WaitNext); genDef(Th, KTHREAD, WaitReason); genDef(Th, KTHREAD, WaitBlockList); genDef(Th, KTHREAD, WaitListEntry); genDef(Th, KTHREAD, WaitTime); genDef(Th, KTHREAD, BasePriority); genDef(Th, KTHREAD, DecrementCount); genDef(Th, KTHREAD, PriorityDecrement); genDef(Th, KTHREAD, Quantum); genDef(Th, KTHREAD, WaitBlock); genDef(Th, KTHREAD, KernelApcDisable); genDef(Th, KTHREAD, UserAffinity); genDef(Th, KTHREAD, SystemAffinityActive); genDef(Th, KTHREAD, ServiceTable); // genDef(Th, KTHREAD, Channel); // genDef(Th, KTHREAD, Section); // genDef(Th, KTHREAD, SystemView); // genDef(Th, KTHREAD, ThreadView); genDef(Th, KTHREAD, Queue); genDef(Th, KTHREAD, ApcQueueLock); genDef(Th, KTHREAD, Timer); genDef(Th, KTHREAD, QueueListEntry); genDef(Th, KTHREAD, Affinity); genDef(Th, KTHREAD, Preempted); genDef(Th, KTHREAD, ProcessReadyQueue); genDef(Th, KTHREAD, KernelStackResident); genDef(Th, KTHREAD, NextProcessor); genDef(Th, KTHREAD, CallbackStack); genDef(Th, KTHREAD, Win32Thread); genDef(Th, KTHREAD, TrapFrame); genDef(Th, KTHREAD, ApcStatePointer); genDef(Th, KTHREAD, PreviousMode); genDef(Th, KTHREAD, EnableStackSwap); genDef(Th, KTHREAD, LargeStack); genDef(Th, KTHREAD, KernelTime); genDef(Th, KTHREAD, UserTime); genDef(Th, KTHREAD, SavedApcState); genDef(Th, KTHREAD, Alertable); genDef(Th, KTHREAD, ApcStateIndex); genDef(Th, KTHREAD, ApcQueueable); genDef(Th, KTHREAD, AutoAlignment); genDef(Th, KTHREAD, StackBase); genDef(Th, KTHREAD, SuspendApc); genDef(Th, KTHREAD, SuspendSemaphore); genDef(Th, KTHREAD, ThreadListEntry); genDef(Th, KTHREAD, FreezeCount); genDef(Th, KTHREAD, SuspendCount); genDef(Th, KTHREAD, IdealProcessor); genDef(Th, KTHREAD, DisableBoost); genVal(ThreadObjectLength, ((sizeof(KTHREAD) + 15) & ~15)); genVal(ExtendedThreadObjectLength, ((sizeof(ETHREAD) + 15) & ~15)); genSpc(); genVal(EVENT_WAIT_BLOCK_OFFSET, OFFSET(KTHREAD, WaitBlock) + (sizeof(KWAIT_BLOCK) * EVENT_WAIT_BLOCK)); #if defined(_X86_) genVal(NPX_STATE_NOT_LOADED, NPX_STATE_NOT_LOADED); genVal(NPX_STATE_LOADED, NPX_STATE_LOADED); #endif // // Timer object structure offset definitions // genCom("Timer object Structure Offset Definitions"); genDef(Ti, DISPATCHER_HEADER, Type); genDef(Ti, DISPATCHER_HEADER, Size); genDef(Ti, DISPATCHER_HEADER, Inserted); genDef(Ti, DISPATCHER_HEADER, SignalState); genDef(Ti, KTIMER, DueTime); genDef(Ti, KTIMER, TimerListEntry); genDef(Ti, KTIMER, Dpc); genDef(Ti, KTIMER, Period); genVal(TimerObjectLength, sizeof(KTIMER)); genSpc(); genVal(TIMER_TABLE_SIZE, TIMER_TABLE_SIZE); // // Wait block structure offset definitions // genCom("Wait Block Structure Offset Definitions"); genDef(Wb, KWAIT_BLOCK, WaitListEntry); genDef(Wb, KWAIT_BLOCK, Thread); genDef(Wb, KWAIT_BLOCK, Object); genDef(Wb, KWAIT_BLOCK, NextWaitBlock); genDef(Wb, KWAIT_BLOCK, WaitKey); genDef(Wb, KWAIT_BLOCK, WaitType); // // Fiber structure offset definitions. // genCom("Fiber Structure Offset Definitions"); genDef(Fb, FIBER, FiberData); genDef(Fb, FIBER, ExceptionList); genDef(Fb, FIBER, StackBase); genDef(Fb, FIBER, StackLimit); genDef(Fb, FIBER, DeallocationStack); genDef(Fb, FIBER, FiberContext); // // Process environment block structure offset definitions. // genCom("Process Environment Block Structure Offset Definitions"); genDef(Pe, PEB, KernelCallbackTable); // // Define System Service Descriptor Table structures. // genCom("System Service Descriptor Table Structure Definitions"); genVal(NUMBER_SERVICE_TABLES, NUMBER_SERVICE_TABLES); genVal(SERVICE_NUMBER_MASK, SERVICE_NUMBER_MASK); genVal(SERVICE_TABLE_SHIFT, SERVICE_TABLE_SHIFT); genVal(SERVICE_TABLE_MASK, SERVICE_TABLE_MASK); genVal(SERVICE_TABLE_TEST, SERVICE_TABLE_TEST); genSpc(); genDef(Sd, KSERVICE_TABLE_DESCRIPTOR, Base); genDef(Sd, KSERVICE_TABLE_DESCRIPTOR, Count); genDef(Sd, KSERVICE_TABLE_DESCRIPTOR, Limit); genDef(Sd, KSERVICE_TABLE_DESCRIPTOR, Number); // // Common TEB structure offset definitions // genCom("Thread Environment Block Structure Offset Definitions"); genDef(Te, NT_TIB, StackBase); genDef(Te, NT_TIB, StackLimit); genDef(Te, NT_TIB, FiberData); genDef(Te, TEB, EnvironmentPointer); genDef(Te, TEB, ClientId); genDef(Te, TEB, ActiveRpcHandle); genDef(Te, TEB, ThreadLocalStoragePointer); genAlt(TePeb, TEB, ProcessEnvironmentBlock); genDef(Te, TEB, CsrClientThread); genAlt(TeSoftFpcr, TEB, FpSoftwareStatusRegister); genDef(Te, TEB, GdiClientPID); genDef(Te, TEB, GdiClientTID); genDef(Te, TEB, GdiThreadLocalInfo); genDef(Te, TEB, glDispatchTable); genDef(Te, TEB, glSectionInfo); genDef(Te, TEB, glSection); genDef(Te, TEB, glTable); genDef(Te, TEB, glCurrentRC); genDef(Te, TEB, glContext); genDef(Te, TEB, DeallocationStack); genDef(Te, TEB, GdiBatchCount); genDef(Te, TEB, Instrumentation);