//----------------------------------------------------------------------------
//
// Abstraction of processor-specific information.
//
// Copyright (C) Microsoft Corporation, 1999-2001.
//
//----------------------------------------------------------------------------

#ifndef __MACHINE_HPP__
#define __MACHINE_HPP__

// These context information states are intended to be shared among
// processors so they may not all apply to each processor.  The important
// thing is that they are ordered from less information to more.
// Each state includes all the information from the states that precede it.
// More states can be inserted anywhere as new processors require them.
#define MCTX_NONE         0     // No context information.
#define MCTX_PC           1     // Program counter.
#define MCTX_DR67_REPORT  2     // X86: DR6,7 control report.
#define MCTX_REPORT       3     // Control report.
#define MCTX_CONTEXT      4     // Kernel protocol context information.
#define MCTX_FULL         5     // All possible information.
#define MCTX_DIRTY        6     // Dirty context, implies full information.

// Constant offset value returned from GetNextOffset to indicate the
// trace flag should be used.
#define OFFSET_TRACE ((ULONG64)(LONG64)-1)
#define OFFSET_TRACE_32 ((ULONG)OFFSET_TRACE)

// Distinguished error code for GetVirtualTranslationPhysicalOffsets
// to indicate that all translations were successful but
// the page was not present.  In this case the LastVal value
// will contain the page file offset and PfIndex will contain
// the page file number.
#define HR_PAGE_IN_PAGE_FILE  HRESULT_FROM_NT(STATUS_PAGE_FAULT_PAGING_FILE)
// Translation could not complete and a page file location
// for the data could not be determined.
#define HR_PAGE_NOT_AVAILABLE HRESULT_FROM_NT(STATUS_NO_PAGEFILE)

#define MAX_PAGING_FILE_MASK 0xf

//
// Segment register access.
// Processors which do not support segment registers return
// zero for the segment register number.
//

enum
{
    // Descriptor table pseudo-segments.  The GDT does
    // not have a specific register number.
    // These pseudo-segments should be first so that
    // index zero is not used for a normal segreg.
    SEGREG_GDT,
    SEGREG_LDT,

    // Generic segments.
    SEGREG_CODE,
    SEGREG_DATA,
    SEGREG_STACK,
    
    // Extended segments.
    SEGREG_ES,
    SEGREG_FS,
    SEGREG_GS,
    
    SEGREG_COUNT
};

//
// Segment descriptor values.
// Due to the descriptor caching that x86 processors
// do this may differ from the actual in-memory descriptor and
// may be retrieved in a much different way.
//

// Special flags value that marks a descriptor as invalid.
#define SEGDESC_INVALID 0xffffffff

#define X86_DESC_TYPE(Flags) ((Flags) & 0x1f)

#define X86_DESC_PRIVILEGE_SHIFT 5
#define X86_DESC_PRIVILEGE(Flags) (((Flags) >> X86_DESC_PRIVILEGE_SHIFT) & 3)

#define X86_DESC_PRESENT     0x80
#define X86_DESC_LONG_MODE   0x200
#define X86_DESC_DEFAULT_BIG 0x400
#define X86_DESC_GRANULARITY 0x800

typedef struct _DESCRIPTOR64
{
    ULONG64 Base;
    ULONG64 Limit;
    ULONG Flags;
} DESCRIPTOR64, *PDESCRIPTOR64;

#define FORM_VM86       0x00000001
#define FORM_CODE       0x00000002
#define FORM_SEGREG     0x00000004

#define X86_FORM_VM86(Efl) \
    (X86_IS_VM86(Efl) ? FORM_VM86 : 0)
    
//----------------------------------------------------------------------------
//
// Abstract interface for machine information.  All possible
// machine-specific implementations of this interface exist at
// all times.  The effective implementation is selected when
// SetEffMachine is called.  For generic access the abstract
// interface should be used.  In machine-specific code the
// specific implementation classes can be used.
//
// IMPORTANT: Be very careful when using machine-specific header files
// such as nt<plat>.h.  The machine implementation class is
// compiled for all platforms so the nt<plat>.h file will be the
// one for the build platform, not necessarily the platform
// of the machine implementation.  ntdbg.h contains many cross-platform
// types and definitions that can be used to avoid problems.
//
//----------------------------------------------------------------------------

extern BOOL g_PrefixSymbols;
extern BOOL g_ContextChanged;
extern DEBUG_PROCESSOR_IDENTIFICATION_ALL g_InitProcessorId;

struct RegisterGroup
{
    RegisterGroup* Next;
    // Counted automatically.
    ULONG NumberRegs;
    // Regs is assumed to be non-NULL in all groups.
    // SubRegs and AllExtraDesc may be NULL in any group.
    REGDEF* Regs;
    REGSUBDEF* SubRegs;
    REGALLDESC* AllExtraDesc;
};

// Trace modes used by SetTraceMode/GetTraceMode functions
typedef enum 
{
    TRACE_NONE, 
    TRACE_INSTRUCTION,
    TRACE_TAKEN_BRANCH
} TRACEMODE;

// These enumerants are abstract values but currently
// only IA64 actually has different page directories
// so set them up to match the IA64 mapping for convenience.
enum
{
    PAGE_DIR_USER,
    PAGE_DIR_SESSION,
    PAGE_DIR_KERNEL = 7,
    PAGE_DIR_COUNT
};

// For machines which only support a single page directory
// take it from the kernel slot.  All will be updated so
// this is an arbitrary choice.
#define PAGE_DIR_SINGLE PAGE_DIR_KERNEL

// All directories bit mask.
#define PAGE_DIR_ALL ((1 << PAGE_DIR_COUNT) - 1)

// Flags for GetPrefixedSymbolOffset.
#define GETPREF_VERBOSE 0x00000001

class MachineInfo
{
public:
    // Descriptive information.
    PCSTR m_FullName;
    PCSTR m_AbbrevName;
    ULONG m_PageSize;
    ULONG m_PageShift;
    ULONG m_NumExecTypes;
    // First ExecTypes entry must be the actual processor type.
    PULONG m_ExecTypes;
    BOOL m_Ptr64;
    
    // Automatically counted from regs in base Initialize.
    ULONG m_NumberRegs;
    RegisterGroup* m_Groups;
    ULONG m_AllMask;
    // Collected automatically from groups.
    ULONG m_AllMaskBits;
    ULONG m_MaxDataBreakpoints;
    PCSTR m_SymPrefix;
    // Computed automatically.
    ULONG m_SymPrefixLen;

    // Hard-coded type information for machine and platform version.
    ULONG m_OffsetPrcbProcessorState;
    ULONG m_OffsetPrcbNumber;
    ULONG64 m_TriagePrcbOffset;
    ULONG m_SizePrcb;
    ULONG m_OffsetKThreadApcProcess;
    ULONG m_OffsetKThreadTeb;
    ULONG m_OffsetKThreadInitialStack;
    ULONG m_OffsetEprocessPeb;
    ULONG m_OffsetEprocessDirectoryTableBase;
    ULONG m_OffsetKThreadNextProcessor;
    // Size of the native context for the target machine.
    ULONG m_SizeTargetContext;
    // Offset of the flags ULONG in the native context.
    ULONG m_OffsetTargetContextFlags;
    // Control space offset for special registers.
    ULONG m_OffsetSpecialRegisters;
    // Size of the canonical context kept in the MachineInfo.
    ULONG m_SizeCanonicalContext;
    // System version of the canonical context.  Can be compared
    // against g_SystemVersion to see if the target provides
    // canonical contexts or not.
    ULONG m_SverCanonicalContext;
    ULONG m_SizeControlReport;
    ULONG m_SizeEThread;
    ULONG m_SizeEProcess;
    ULONG m_SizeKspecialRegisters;
    // Size of the debugger's *_THREAD partial structure.
    ULONG m_SizePartialKThread;
    ULONG64 m_SharedUserDataOffset;

    // Context could be kept per-thread
    // so that several can be around at once for a cache.
    // That would also make the save/restore stuff unnecessary.
    ULONG m_ContextState;
    CROSS_PLATFORM_CONTEXT m_Context;

    // Segment register descriptors.  These will only
    // be valid on processors that support them, otherwise
    // they will be marked invalid.
    DESCRIPTOR64 m_SegRegDesc[SEGREG_COUNT];
    DESCRIPTOR64 m_SavedSegRegDesc[SEGREG_COUNT];
    
    // Holds the current page directory offsets.
    ULONG64 m_PageDirectories[PAGE_DIR_COUNT];
    BOOL m_Translating;
    
    BOOL m_ContextIsReadOnly;

    // InitializeConstants initializes information which is
    // fixed and unaffected by the type of target being debugged.
    // InitializeForTarget initializes information which
    // varies according to the particular type of target being debugged.
    // InitializeForProcessor initializes information which
    // varies according to the particular type of processor that's
    // present in the target as described by g_InitProcessorId.
    // Derived classes should call base Initialize* after
    // their own initialization.
    virtual HRESULT InitializeConstants(void);
    virtual HRESULT InitializeForTarget(void);
    virtual HRESULT InitializeForProcessor(void);

    virtual void InitializeContext
        (ULONG64 Pc, PDBGKD_ANY_CONTROL_REPORT ControlReport) = 0;
    HRESULT GetContextState(ULONG State);
    HRESULT SetContext(void);
    // Base implementations use Get/SetThreadContext for
    // any request.
    virtual HRESULT UdGetContextState(ULONG State);
    virtual HRESULT UdSetContext(void);
    virtual HRESULT KdGetContextState(ULONG State) = 0;
    virtual HRESULT KdSetContext(void) = 0;
    // Base implementation sets ContextState to NONE.
    virtual void InvalidateContext(void);
    // Context conversion is version-based rather than size-based
    // as the size is ambiguous in certain cases.  For example,
    // ALPHA_CONTEXT and ALPHA_NT5_CONTEXT are the same size
    // so additional information is necessary to distinguish them.
    virtual HRESULT ConvertContextFrom(PCROSS_PLATFORM_CONTEXT Context,
                                       ULONG FromSver,
                                       ULONG FromSize, PVOID From) = 0;
    virtual HRESULT ConvertContextTo(PCROSS_PLATFORM_CONTEXT Context,
                                     ULONG ToSver, ULONG ToSize, PVOID To) = 0;
    virtual void InitializeContextFlags(PCROSS_PLATFORM_CONTEXT Context,
                                        ULONG Version) = 0;
    virtual HRESULT GetContextFromThreadStack(ULONG64 ThreadBase,
                                              PCROSS_PLATFORM_THREAD Thread,
                                              PCROSS_PLATFORM_CONTEXT Context,
                                              PDEBUG_STACK_FRAME Frame,
                                              PULONG RunningOnProc) = 0;

    // Base implementations return E_NOTIMPL.
    virtual HRESULT GetExdiContext(IUnknown* Exdi, PEXDI_CONTEXT Context);
    virtual HRESULT SetExdiContext(IUnknown* Exdi, PEXDI_CONTEXT Context);
    virtual void ConvertExdiContextFromContext(PCROSS_PLATFORM_CONTEXT Context,
                                               PEXDI_CONTEXT ExdiContext);
    virtual void ConvertExdiContextToContext(PEXDI_CONTEXT ExdiContext,
                                             PCROSS_PLATFORM_CONTEXT Context);
    virtual void ConvertExdiContextToSegDescs(PEXDI_CONTEXT ExdiContext,
                                              ULONG Start, ULONG Count,
                                              PDESCRIPTOR64 Descs);
    virtual void ConvertExdiContextFromSpecial
        (PCROSS_PLATFORM_KSPECIAL_REGISTERS Special,
         PEXDI_CONTEXT ExdiContext);
    virtual void ConvertExdiContextToSpecial
        (PEXDI_CONTEXT ExdiContext,
         PCROSS_PLATFORM_KSPECIAL_REGISTERS Special);
             
    // A simple one-deep temporary save stack for CONTEXT information.
    // Useful when you want to swap in an arbitrary context for
    // some machine operation.  This uses the same save area
    // as KdSave/RestoreProcessorState so the two should
    // not be used together.
    void PushContext(PCROSS_PLATFORM_CONTEXT Context)
    {
        DBG_ASSERT (!m_ContextIsReadOnly);
        m_SavedContextState = m_ContextState;
        m_SavedContext = m_Context;
        memcpy(m_SavedSegRegDesc, m_SegRegDesc, sizeof(m_SegRegDesc));
        m_Context = *Context;
        m_ContextState = MCTX_FULL;
        m_ContextIsReadOnly = TRUE;
    }
    void PopContext(void)
    {
        DBG_ASSERT((m_ContextState != MCTX_DIRTY) && (m_ContextIsReadOnly));
        m_Context = m_SavedContext;
        m_ContextState = m_SavedContextState;
        memcpy(m_SegRegDesc, m_SavedSegRegDesc, sizeof(m_SegRegDesc));
        m_ContextIsReadOnly = FALSE;
    }
        
    virtual int  GetType(ULONG index) = 0;
    virtual BOOL GetVal(ULONG index, REGVAL *val) = 0;
    virtual BOOL SetVal(ULONG index, REGVAL *val) = 0;

    virtual void GetPC(PADDR Address) = 0;
    virtual void SetPC(PADDR Address) = 0;
    virtual void GetFP(PADDR Address) = 0;
    virtual void GetSP(PADDR Address) = 0;
    virtual ULONG64 GetArgReg(void) = 0;
    // Base implementations return zero and FALSE.
    virtual ULONG GetSegRegNum(ULONG SegReg);
    virtual HRESULT GetSegRegDescriptor(ULONG SegReg, PDESCRIPTOR64 Desc);

    virtual void OutputAll(ULONG Mask, ULONG OutMask) = 0;

    virtual TRACEMODE GetTraceMode(void) = 0;
    virtual void SetTraceMode(TRACEMODE Mode) = 0;

    // Returns true if trace mode appropriate to specified execution status 
    // (e.g. DEBUG_STATUS_STEP_OVER, DEBUG_STATUS_STEP_INTO,
    // DEBUG_STATUS_STEP_BRANCH...) supported by the machine.
    virtual BOOL IsStepStatusSupported(ULONG Status) = 0;

    void QuietSetTraceMode(TRACEMODE Mode)
    {
        BOOL ContextChangedOrg = g_ContextChanged;
        SetTraceMode(Mode);
        g_ContextChanged = ContextChangedOrg;
    }

    // Base implementation does nothing.
    virtual void KdUpdateControlSet
        (PDBGKD_ANY_CONTROL_SET ControlSet);

    // Base implementations save and restore m_Context and m_ContextState.
    virtual void KdSaveProcessorState(void);
    virtual void KdRestoreProcessorState(void);

    virtual ULONG ExecutingMachine(void) = 0;

    virtual HRESULT SetPageDirectory(ULONG Idx, ULONG64 PageDir,
                                     PULONG NextIdx) = 0;
    HRESULT SetDefaultPageDirectories(ULONG Mask);
    virtual HRESULT GetVirtualTranslationPhysicalOffsets
        (ULONG64 Virt, PULONG64 Offsets, ULONG OffsetsSize,
         PULONG Levels, PULONG PfIndex, PULONG64 LastVal) = 0;
    virtual HRESULT GetBaseTranslationVirtualOffset(PULONG64 Offset) = 0;

    virtual void Assemble(PADDR Addr, PSTR Input) = 0;
    virtual BOOL Disassemble(PADDR Addr, PSTR Buffer, BOOL EffAddr) = 0;

    // Creates new Breakpoint object compatible with specific machine
    virtual HRESULT NewBreakpoint(DebugClient* Client, 
                                  ULONG Type, 
                                  ULONG Id, 
                                  Breakpoint** RetBp);

    virtual BOOL IsBreakpointInstruction(PADDR Addr) = 0;
    virtual HRESULT InsertBreakpointInstruction(PUSER_DEBUG_SERVICES Services,
                                                ULONG64 Process,
                                                ULONG64 Offset,
                                                PUCHAR SaveInstr,
                                                PULONG64 ChangeStart,
                                                PULONG ChangeLen) = 0;
    virtual HRESULT RemoveBreakpointInstruction(PUSER_DEBUG_SERVICES Services,
                                                ULONG64 Process,
                                                ULONG64 Offset,
                                                PUCHAR SaveInstr,
                                                PULONG64 ChangeStart,
                                                PULONG ChangeLen) = 0;
    virtual void AdjustPCPastBreakpointInstruction(PADDR Addr,
                                                   ULONG BreakType) = 0;
    // Base implementations do nothing for platforms which
    // do not support data breakpoints.
    virtual void InsertAllDataBreakpoints(void);
    virtual void RemoveAllDataBreakpoints(void);
    // Base implementation returns EXCEPTION_BRAKEPOINT_ANY
    // for STATUS_BREAKPOINT.
    virtual ULONG IsBreakpointOrStepException(PEXCEPTION_RECORD64 Record,
                                              ULONG FirstChance,
                                              PADDR BpAddr,
                                              PADDR RelAddr);

    virtual BOOL IsCallDisasm(PCSTR Disasm) = 0;
    virtual BOOL IsReturnDisasm(PCSTR Disasm) = 0;
    virtual BOOL IsSystemCallDisasm(PCSTR Disasm) = 0;
    
    virtual BOOL IsDelayInstruction(PADDR Addr) = 0;
    virtual void GetEffectiveAddr(PADDR Addr) = 0;
    // Some processors, such as IA64, have instructions which
    // switch between instruction sets, thus the machine type
    // of the next offset may be different from the current machine.
    // If the NextAddr is OFFSET_TRACE the NextMachine is ignored.
    virtual void GetNextOffset(BOOL StepOver,
                               PADDR NextAddr, PULONG NextMachine) = 0;
    // Base implementation returns the value from StackWalk.
    virtual void GetRetAddr(PADDR Addr);
    // Base implementation does nothing for machines which
    // do not have symbol prefixing.
    virtual BOOL GetPrefixedSymbolOffset(ULONG64 SymOffset,
                                         ULONG Flags,
                                         PULONG64 PrefixedSymOffset);

    virtual void IncrementBySmallestInstruction(PADDR Addr) = 0;
    virtual void DecrementBySmallestInstruction(PADDR Addr) = 0;

    virtual BOOL DisplayTrapFrame(ULONG64 FrameAddress,
                                  PCROSS_PLATFORM_CONTEXT Context) = 0;
    virtual void ValidateCxr(PCROSS_PLATFORM_CONTEXT Context) = 0;

    // Output function entry information for the given entry.
    virtual void OutputFunctionEntry(PVOID RawEntry) = 0;
    // Base implementation returns E_UNEXPECTED.
    virtual HRESULT ReadDynamicFunctionTable(ULONG64 Table,
                                             PULONG64 NextTable,
                                             PULONG64 MinAddress,
                                             PULONG64 MaxAddress,
                                             PULONG64 BaseAddress,
                                             PULONG64 TableData,
                                             PULONG TableSize,
                                             PWSTR OutOfProcessDll,
                                             PCROSS_PLATFORM_DYNAMIC_FUNCTION_TABLE RawTable);
    // Base implementation returns NULL.
    virtual PVOID FindDynamicFunctionEntry(PCROSS_PLATFORM_DYNAMIC_FUNCTION_TABLE Table,
                                           ULONG64 Address,
                                           PVOID TableData,
                                           ULONG TableSize);

    virtual HRESULT ReadKernelProcessorId
        (ULONG Processor, PDEBUG_PROCESSOR_IDENTIFICATION_ALL Id) = 0;

    // Base implementation discards page directory entries.
    virtual void FlushPerExecutionCaches(void);
    
    // Stack output functions
    virtual void PrintStackFrameAddressesTitle(ULONG Flags);
    virtual void PrintStackFrameAddresses(ULONG Flags, 
                                          PDEBUG_STACK_FRAME StackFrame);
    virtual void PrintStackArgumentsTitle(ULONG Flags);
    virtual void PrintStackArguments(ULONG Flags, 
                                     PDEBUG_STACK_FRAME StackFrame);
    virtual void PrintStackCallSiteTitle(ULONG Flags);
    virtual void PrintStackCallSite(ULONG Flags, 
                                    PDEBUG_STACK_FRAME StackFrame, 
                                    CHAR SymBuf[], DWORD64 Displacement, 
                                    USHORT StdCallArgs);
    virtual void PrintStackNonvolatileRegisters(ULONG Flags, 
                                                PDEBUG_STACK_FRAME StackFrame,
                                                PCROSS_PLATFORM_CONTEXT Context,
                                                ULONG FrameNum);

    //
    // IMPORTANT
    //
    // Helpers for convenient value access.  When in machine code
    // these helpers are preferred to Get/SetRegVal* because
    // they stay in the same machine whereas the generic code
    // always uses g_Machine.  If a caller makes a direct call
    // on a specific machine g_Machine may not match so the
    // generic code will not work properly.
    //
    // Note that the set methods here do not get the register
    // type as is done in the generic code.  All of these methods
    // assume that the proper call is being made for the register.
    // The Get/SetReg methods also only operate on real registers, not
    // subregisters.  Use the Get/SetSubReg methods when dealing
    // with subregisters.
    //
    
    USHORT GetReg16(ULONG Reg)
    {
        REGVAL RegVal;
        RegVal.i64 = 0;
        GetVal(Reg, &RegVal);
        return RegVal.i16;
    }
    ULONG GetReg32(ULONG Reg)
    {
        REGVAL RegVal;
        RegVal.i64 = 0;
        GetVal(Reg, &RegVal);
        return RegVal.i32;
    }
    void SetReg32(ULONG Reg, ULONG Val)
    {
        REGVAL RegVal;
        RegVal.type = REGVAL_INT32;
        RegVal.i64 = 0;
        RegVal.i32 = Val;
        SetVal(Reg, &RegVal);
    }
    ULONG64 GetReg64(ULONG Reg)
    {
        REGVAL RegVal;
        RegVal.i64 = 0;
        GetVal(Reg, &RegVal);
        return RegVal.i64;
    }
    void SetReg64(ULONG Reg, ULONG64 Val)
    {
        REGVAL RegVal;
        RegVal.type = REGVAL_INT64;
        RegVal.i64 = Val;
        RegVal.Nat = FALSE;
        SetVal(Reg, &RegVal);
    }
    ULONG GetSubReg32(ULONG SubReg)
    {
        REGVAL RegVal;
        REGSUBDEF* SubDef = RegSubDefFromIndex(SubReg);

        if (!SubDef) 
        {
            return 0;
        }

        RegVal.i64 = 0;
        GetVal(SubDef->fullreg, &RegVal);
        return (ULONG)((RegVal.i64 >> SubDef->shift) & SubDef->mask);
    }

    // Helper function to initialize an ADDR given a flat
    // offset from a known segment or segment register.
    void FormAddr(ULONG SegOrReg, ULONG64 Off, ULONG Flags,
                  PADDR Address);

protected:
    TRACEMODE m_TraceMode;

    // KdSave/Restore state.
    ULONG m_SavedContextState;
    CROSS_PLATFORM_CONTEXT m_SavedContext;

    // Common helpers for disassembly.
    PCHAR m_Buf, m_BufStart;
    
    void BufferHex(ULONG64 Value, ULONG Length, BOOL Signed);
    void BufferBlanks(ULONG BufferPos);
    void BufferString(PCSTR String);

    void PrintMultiPtrTitle(const CHAR* Title, USHORT PtrNum);
};

// Effective machine settings.
extern ULONG g_EffMachine;
extern MachineIndex g_EffMachineIndex;
extern MachineInfo* g_Machine;

// Target machine settings.
extern MachineInfo* g_TargetMachine;

extern MachineInfo* g_AllMachines[];

HRESULT InitializeMachines(ULONG TargetMachine);
MachineIndex MachineTypeIndex(ULONG Machine);

// g_AllMachines has a NULL at MACHIDX_COUNT to handle errors.
#define MachineTypeInfo(Machine) g_AllMachines[MachineTypeIndex(Machine)]

void CacheReportInstructions(ULONG64 Pc, ULONG Count, PUCHAR Stream);
void FlushMachinePerExecutionCaches(void);

extern CHAR g_F0[], g_F1[], g_F2[], g_F3[], g_F4[], g_F5[];
extern CHAR g_F6[], g_F7[], g_F8[], g_F9[], g_F10[], g_F11[];
extern CHAR g_F12[], g_F13[], g_F14[], g_F15[], g_F16[], g_F17[];
extern CHAR g_F18[], g_F19[], g_F20[], g_F21[], g_F22[], g_F23[];
extern CHAR g_F24[], g_F25[], g_F26[], g_F27[], g_F28[], g_F29[];
extern CHAR g_F30[], g_F31[];

extern CHAR g_R0[], g_R1[], g_R2[], g_R3[], g_R4[], g_R5[];
extern CHAR g_R6[], g_R7[], g_R8[], g_R9[], g_R10[], g_R11[];
extern CHAR g_R12[], g_R13[], g_R14[], g_R15[], g_R16[], g_R17[];
extern CHAR g_R18[], g_R19[], g_R20[], g_R21[], g_R22[], g_R23[];
extern CHAR g_R24[], g_R25[], g_R26[], g_R27[], g_R28[], g_R29[];
extern CHAR g_R30[], g_R31[];

#endif // #ifndef __MACHINE_HPP__