codegeninterface.h

// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

//
// This file declares the types that constitute the interface between the
// code generator (CodeGen class) and the rest of the JIT.
//
// RegState
//
// CodeGenInterface includes only the public methods that are called by
// the Compiler.
//
// CodeGenContext contains the shared context between the code generator
// and other phases of the JIT, especially the register allocator and
// GC encoder. It is distinct from CodeGenInterface so that it can be
// included in the Compiler object, and avoid an extra indirection when
// accessed from members of Compiler.
//

#ifndef _CODEGEN_INTERFACE_H_
#define_CODEGEN_INTERFACE_H_

#include"regset.h"
#include"jitgcinfo.h"
#include"treelifeupdater.h"
#include"emit.h"

#if1
// Enable USING_SCOPE_INFO flag to use psiScope/siScope info to report variables' locations.
#defineUSING_SCOPE_INFO
#endif
#if0
// Enable USING_VARIABLE_LIVE_RANGE flag to use VariableLiveRange info to report variables' locations.
// Note: if both USING_SCOPE_INFO and USING_VARIABLE_LIVE_RANGE are defined, then USING_SCOPE_INFO
// information is reported to the debugger.
#define USING_VARIABLE_LIVE_RANGE
#endif

// Forward reference types

classCodeGenInterface;
classemitter;

// Small helper types

//-------------------- Register selection ---------------------------------

structRegState
{
 regMaskTP rsCalleeRegArgMaskLiveIn; // mask of register arguments (live on entry to method)
unsigned rsCalleeRegArgCount; // total number of incoming register arguments of this kind (int or float)
bool rsIsFloat; // true for float argument registers, false for integer argument registers
};

//-------------------- CodeGenInterface ---------------------------------
// interface to hide the full CodeGen implementation from rest of Compiler

CodeGenInterface* getCodeGenerator(Compiler* comp);

classCodeGenInterface
{
friendclassemitter;

public:
CodeGenInterface(Compiler* theCompiler);
virtualvoidgenGenerateCode(void** codePtr, ULONG* nativeSizeOfCode) = 0;

// genSpillVar is called by compUpdateLifeVar.
// TODO-Cleanup: We should handle the spill directly in CodeGen, rather than
// calling it from compUpdateLifeVar. Then this can be non-virtual.

virtualvoidgenSpillVar(GenTree* tree) = 0;

//-------------------------------------------------------------------------
// The following property indicates whether to align loops.
// (Used to avoid effects of loop alignment when diagnosing perf issues.)

boolShouldAlignLoops()
 {
return m_genAlignLoops;
 }
voidSetAlignLoops(bool value)
 {
 m_genAlignLoops = value;
 }

// TODO-Cleanup: Abstract out the part of this that finds the addressing mode, and
// move it to Lower
virtualboolgenCreateAddrMode(GenTree* addr,
bool fold,
bool* revPtr,
 GenTree** rv1Ptr,
 GenTree** rv2Ptr,
#if SCALED_ADDR_MODES
unsigned* mulPtr,
#endif// SCALED_ADDR_MODES
ssize_t* cnsPtr) = 0;

 GCInfo gcInfo;

 RegSet regSet;
 RegState intRegState;
 RegState floatRegState;

protected:
 Compiler* compiler;
bool m_genAlignLoops;

private:
#if defined(_TARGET_XARCH_)
staticconst insFlags instInfo[INS_count];
#elif defined(_TARGET_ARM_) || defined(_TARGET_ARM64_)
staticconst BYTE instInfo[INS_count];
#else
#error Unsupported target architecture
#endif

#defineINST_FP0x01// is it a FP instruction?
public:
staticboolinstIsFP(instruction ins);

//-------------------------------------------------------------------------
// Liveness-related fields & methods
public:
voidgenUpdateRegLife(const LclVarDsc* varDsc, bool isBorn, bool isDying DEBUGARG(GenTree* tree));
voidgenUpdateVarReg(LclVarDsc* varDsc, GenTree* tree);

protected:
#ifdef DEBUG
 VARSET_TP genTempOldLife;
bool genTempLiveChg;
#endif

 VARSET_TP genLastLiveSet; // A one element map (genLastLiveSet-> genLastLiveMask)
 regMaskTP genLastLiveMask; // these two are used in genLiveMask

 regMaskTP genGetRegMask(const LclVarDsc* varDsc);
 regMaskTP genGetRegMask(GenTree* tree);

voidgenUpdateLife(GenTree* tree);
voidgenUpdateLife(VARSET_VALARG_TP newLife);

 TreeLifeUpdater<true>* treeLifeUpdater;

public:
boolgenUseOptimizedWriteBarriers(GCInfo::WriteBarrierForm wbf);
boolgenUseOptimizedWriteBarriers(GenTree* tgt, GenTree* assignVal);
 CorInfoHelpFunc genWriteBarrierHelperForWriteBarrierForm(GenTree* tgt, GCInfo::WriteBarrierForm wbf);

// The following property indicates whether the current method sets up
// an explicit stack frame or not.
private:
 PhasedVar<bool> m_cgFramePointerUsed;

public:
boolisFramePointerUsed() const
 {
return m_cgFramePointerUsed;
 }
voidsetFramePointerUsed(bool value)
 {
 m_cgFramePointerUsed = value;
 }
voidresetFramePointerUsedWritePhase()
 {
 m_cgFramePointerUsed.ResetWritePhase();
 }

// The following property indicates whether the current method requires
// an explicit frame. Does not prohibit double alignment of the stack.
private:
 PhasedVar<bool> m_cgFrameRequired;

public:
boolisFrameRequired() const
 {
return m_cgFrameRequired;
 }
voidsetFrameRequired(bool value)
 {
 m_cgFrameRequired = value;
 }

public:
intgenCallerSPtoFPdelta() const;
intgenCallerSPtoInitialSPdelta() const;
intgenSPtoFPdelta() const;
intgenTotalFrameSize() const;

#ifdef _TARGET_ARM64_
virtualvoidSetSaveFpLrWithAllCalleeSavedRegisters(bool value) = 0;
virtualboolIsSaveFpLrWithAllCalleeSavedRegisters() const = 0;
#endif// _TARGET_ARM64_

 regNumber genGetThisArgReg(GenTreeCall* call) const;

#ifdef _TARGET_XARCH_
#ifdef _TARGET_AMD64_
// There are no reloc hints on x86
unsignedshortgenAddrRelocTypeHint(size_t addr);
#endif
boolgenDataIndirAddrCanBeEncodedAsPCRelOffset(size_t addr);
boolgenCodeIndirAddrCanBeEncodedAsPCRelOffset(size_t addr);
boolgenCodeIndirAddrCanBeEncodedAsZeroRelOffset(size_t addr);
boolgenCodeIndirAddrNeedsReloc(size_t addr);
boolgenCodeAddrNeedsReloc(size_t addr);
#endif

// If both isFramePointerRequired() and isFrameRequired() are false, the method is eligible
// for Frame-Pointer-Omission (FPO).

// The following property indicates whether the current method requires
// an explicit stack frame, and all arguments and locals to be
// accessible relative to the Frame Pointer. Prohibits double alignment
// of the stack.
private:
 PhasedVar<bool> m_cgFramePointerRequired;

public:
boolisFramePointerRequired() const
 {
return m_cgFramePointerRequired;
 }

voidsetFramePointerRequired(bool value)
 {
 m_cgFramePointerRequired = value;
 }

//------------------------------------------------------------------------
// resetWritePhaseForFramePointerRequired: Return m_cgFramePointerRequired into the write phase.
// It is used only before the first phase, that locks this value, currently it is LSRA.
// Use it if you want to skip checks that set this value to true if the value is already true.
voidresetWritePhaseForFramePointerRequired()
 {
 m_cgFramePointerRequired.ResetWritePhase();
 }

voidsetFramePointerRequiredEH(bool value);

voidsetFramePointerRequiredGCInfo(bool value)
 {
#ifdef JIT32_GCENCODER
 m_cgFramePointerRequired = value;
#endif
 }

#if DOUBLE_ALIGN
// The following property indicates whether we going to double-align the frame.
// Arguments are accessed relative to the Frame Pointer (EBP), and
// locals are accessed relative to the Stack Pointer (ESP).
public:
booldoDoubleAlign() const
 {
return m_cgDoubleAlign;
 }
voidsetDoubleAlign(bool value)
 {
 m_cgDoubleAlign = value;
 }
booldoubleAlignOrFramePointerUsed() const
 {
returnisFramePointerUsed() || doDoubleAlign();
 }

private:
bool m_cgDoubleAlign;
#else// !DOUBLE_ALIGN

public:
booldoubleAlignOrFramePointerUsed() const
 {
returnisFramePointerUsed();
 }

#endif// !DOUBLE_ALIGN

#ifdef DEBUG
// The following is used to make sure the value of 'GetInterruptible()' isn't
// changed after it's been used by any logic that depends on its value.
public:
boolisGCTypeFixed()
 {
return genInterruptibleUsed;
 }

protected:
bool genInterruptibleUsed;
#endif

public:
unsignedInferStructOpSizeAlign(GenTree* op, unsigned* alignmentWB);
unsignedInferOpSizeAlign(GenTree* op, unsigned* alignmentWB);

voidgenMarkTreeInReg(GenTree* tree, regNumber reg);

// Methods to abstract target information

boolvalidImmForInstr(instruction ins, target_ssize_t val, insFlags flags = INS_FLAGS_DONT_CARE);
boolvalidDispForLdSt(target_ssize_t disp, var_types type);
boolvalidImmForAdd(target_ssize_t imm, insFlags flags);
boolvalidImmForAlu(target_ssize_t imm);
boolvalidImmForMov(target_ssize_t imm);
boolvalidImmForBL(ssize_t addr);

 instruction ins_Load(var_types srcType, bool aligned = false);
 instruction ins_Store(var_types dstType, bool aligned = false);
static instruction ins_FloatLoad(var_types type = TYP_DOUBLE);

// Methods for spilling - used by RegSet
voidspillReg(var_types type, TempDsc* tmp, regNumber reg);
voidreloadReg(var_types type, TempDsc* tmp, regNumber reg);

// The following method is used by xarch emitter for handling contained tree temps.
 TempDsc* getSpillTempDsc(GenTree* tree);

public:
 emitter* GetEmitter() const
 {
return m_cgEmitter;
 }

protected:
 emitter* m_cgEmitter;

#ifdef LATE_DISASM
public:
 DisAssembler& getDisAssembler()
 {
return m_cgDisAsm;
 }

protected:
 DisAssembler m_cgDisAsm;
#endif// LATE_DISASM

public:
#ifdef DEBUG
voidsetVerbose(bool value)
 {
 verbose = value;
 }
bool verbose;
#endif// DEBUG

// The following is set to true if we've determined that the current method
// is to be fully interruptible.
//
public:
boolGetInterruptible()
 {
return m_cgInterruptible;
 }
voidSetInterruptible(bool value)
 {
 m_cgInterruptible = value;
 }

#ifdef _TARGET_ARMARCH_

boolGetHasTailCalls()
 {
return m_cgHasTailCalls;
 }
voidSetHasTailCalls(bool value)
 {
 m_cgHasTailCalls = value;
 }
#endif// _TARGET_ARMARCH_

private:
bool m_cgInterruptible;
#ifdef _TARGET_ARMARCH_
bool m_cgHasTailCalls;
#endif// _TARGET_ARMARCH_

// The following will be set to true if we've determined that we need to
// generate a full-blown pointer register map for the current method.
// Currently it is equal to (GetInterruptible() || !isFramePointerUsed())
// (i.e. We generate the full-blown map for EBP-less methods and
// for fully interruptible methods)
//
public:
boolIsFullPtrRegMapRequired()
 {
return m_cgFullPtrRegMap;
 }
voidSetFullPtrRegMapRequired(bool value)
 {
 m_cgFullPtrRegMap = value;
 }

private:
bool m_cgFullPtrRegMap;

public:
#ifdef USING_SCOPE_INFO
virtualvoidsiUpdate() = 0;
#endif// USING_SCOPE_INFO

/* These are the different addressing modes used to access a local var.
 * The JIT has to report the location of the locals back to the EE
 * for debugging purposes.
*/

enum siVarLocType
 {
 VLT_REG,
 VLT_REG_BYREF, // this type is currently only used for value types on X64
 VLT_REG_FP,
 VLT_STK,
 VLT_STK_BYREF, // this type is currently only used for value types on X64
 VLT_REG_REG,
 VLT_REG_STK,
 VLT_STK_REG,
 VLT_STK2,
 VLT_FPSTK,
 VLT_FIXED_VA,

 VLT_COUNT,
 VLT_INVALID
 };

structsiVarLoc
 {
 siVarLocType vlType;

union {
// VLT_REG/VLT_REG_FP -- Any pointer-sized enregistered value (TYP_INT, TYP_REF, etc)
// eg. EAX
// VLT_REG_BYREF -- the specified register contains the address of the variable
// eg. [EAX]

struct
 {
 regNumber vlrReg;
 } vlReg;

// VLT_STK -- Any 32 bit value which is on the stack
// eg. [ESP+0x20], or [EBP-0x28]
// VLT_STK_BYREF -- the specified stack location contains the address of the variable
// eg. mov EAX, [ESP+0x20]; [EAX]

struct
 {
 regNumber vlsBaseReg;
 NATIVE_OFFSET vlsOffset;
 } vlStk;

// VLT_REG_REG -- TYP_LONG/TYP_DOUBLE with both DWords enregistered
// eg. RBM_EAXEDX

struct
 {
 regNumber vlrrReg1;
 regNumber vlrrReg2;
 } vlRegReg;

// VLT_REG_STK -- Partly enregistered TYP_LONG/TYP_DOUBLE
// eg { LowerDWord=EAX UpperDWord=[ESP+0x8] }

struct
 {
 regNumber vlrsReg;

struct
 {
 regNumber vlrssBaseReg;
 NATIVE_OFFSET vlrssOffset;
 } vlrsStk;
 } vlRegStk;

// VLT_STK_REG -- Partly enregistered TYP_LONG/TYP_DOUBLE
// eg { LowerDWord=[ESP+0x8] UpperDWord=EAX }

struct
 {
struct
 {
 regNumber vlsrsBaseReg;
 NATIVE_OFFSET vlsrsOffset;
 } vlsrStk;

 regNumber vlsrReg;
 } vlStkReg;

// VLT_STK2 -- Any 64 bit value which is on the stack, in 2 successsive DWords
// eg 2 DWords at [ESP+0x10]

struct
 {
 regNumber vls2BaseReg;
 NATIVE_OFFSET vls2Offset;
 } vlStk2;

// VLT_FPSTK -- enregisterd TYP_DOUBLE (on the FP stack)
// eg. ST(3). Actually it is ST("FPstkHeight - vpFpStk")

struct
 {
unsigned vlfReg;
 } vlFPstk;

// VLT_FIXED_VA -- fixed argument of a varargs function.
// The argument location depends on the size of the variable
// arguments (...). Inspecting the VARARGS_HANDLE indicates the
// location of the first arg. This argument can then be accessed
// relative to the position of the first arg

struct
 {
unsigned vlfvOffset;
 } vlFixedVarArg;

// VLT_MEMORY

struct
 {
void* rpValue; // pointer to the in-process
// location of the value.
 } vlMemory;
 };

// Helper functions

boolvlIsInReg(regNumber reg) const;
boolvlIsOnStack(regNumber reg, signed offset) const;
boolvlIsOnStack() const;

voidstoreVariableInRegisters(regNumber reg, regNumber otherReg);
voidstoreVariableOnStack(regNumber stackBaseReg, NATIVE_OFFSET variableStackOffset);

siVarLoc(const LclVarDsc* varDsc, regNumber baseReg, int offset, bool isFramePointerUsed);
siVarLoc(){};

// An overload for the equality comparator
staticboolEquals(const siVarLoc* lhs, const siVarLoc* rhs);

private:
// Fill "siVarLoc" properties indicating the register position of the variable
// using "LclVarDsc" and "baseReg"/"offset" if it has a part in the stack (x64 bit float or long).
voidsiFillRegisterVarLoc(
const LclVarDsc* varDsc, var_types type, regNumber baseReg, int offset, bool isFramePointerUsed);

// Fill "siVarLoc" properties indicating the register position of the variable
// using "LclVarDsc" and "baseReg"/"offset" if it is a variable with part in a register and
// part in thestack
voidsiFillStackVarLoc(
const LclVarDsc* varDsc, var_types type, regNumber baseReg, int offset, bool isFramePointerUsed);
 };

public:
 siVarLoc getSiVarLoc(const LclVarDsc* varDsc, unsignedint stackLevel) const;

#ifdef DEBUG
voiddumpSiVarLoc(const siVarLoc* varLoc) const;
#endif

unsignedgetCurrentStackLevel() const;

protected:
// Keeps track of how many bytes we've pushed on the processor's stack.
unsigned genStackLevel;

public:
#ifdef USING_VARIABLE_LIVE_RANGE
//--------------------------------------------
//
// VariableLiveKeeper: Holds an array of "VariableLiveDescriptor", one for each variable
// whose location we track. It provides start/end/update/count operations over the
// "LiveRangeList" of any variable.
//
// Notes:
// This method could be implemented on Compiler class too, but the intention is to move code
// out of that class, which is huge. With this solution the only code needed in Compiler is
// a getter and an initializer of this class.
// The index of each variable in this array corresponds to the one in "compiler->lvaTable".
// We care about tracking the variable locations of arguments, special arguments, and local IL
// variables, and we ignore any other variable (like JIT temporary variables).
//
classVariableLiveKeeper
 {
public:
//--------------------------------------------
//
// VariableLiveRange: Represent part of the life of a variable. A
// variable lives in a location (represented with struct "siVarLoc")
// between two native offsets.
//
// Notes:
// We use emitLocation and not NATTIVE_OFFSET because location
// is captured when code is being generated (genCodeForBBList
// and genGeneratePrologsAndEpilogs) but only after the whole
// method's code is generated can we obtain a final, fixed
// NATIVE_OFFSET representing the actual generated code offset.
// There is also a IL_OFFSET, but this is more accurate and the
// debugger is expecting assembly offsets.
// This class doesn't have behaviour attached to itself, it is
// just putting a name to a representation. It is used to build
// typedefs LiveRangeList and LiveRangeListIterator, which are
// basically a list of this class and a const_iterator of that
// list.
//
classVariableLiveRange
 {
public:
 emitLocation m_StartEmitLocation; // first position from where "m_VarLocation" becomes valid
 emitLocation m_EndEmitLocation; // last position where "m_VarLocation" is valid
 CodeGenInterface::siVarLoc m_VarLocation; // variable location

VariableLiveRange(CodeGenInterface::siVarLoc varLocation,
 emitLocation startEmitLocation,
 emitLocation endEmitLocation)
 : m_StartEmitLocation(startEmitLocation), m_EndEmitLocation(endEmitLocation), m_VarLocation(varLocation)
 {
 }

#ifdef DEBUG
// Dump "VariableLiveRange" when code has not been generated. We don't have the native code offset,
// but we do have "emitLocation"s and "siVarLoc".
voiddumpVariableLiveRange(const CodeGenInterface* codeGen) const;

// Dump "VariableLiveRange" when code has been generated and we have the native code offset of each
// "emitLocation"
voiddumpVariableLiveRange(emitter* emit, const CodeGenInterface* codeGen) const;
#endif// DEBUG
 };

typedef jitstd::list<VariableLiveRange> LiveRangeList;
typedef LiveRangeList::const_iterator LiveRangeListIterator;

private:
#ifdef DEBUG
//--------------------------------------------
//
// LiveRangeDumper: Used for debugging purposes during code
// generation on genCodeForBBList. Keeps an iterator to the first
// edited/added "VariableLiveRange" of a variable during the
// generation of code of one block.
//
// Notes:
// The first "VariableLiveRange" reported for a variable during
// a BasicBlock is sent to "setDumperStartAt" so we can dump all
// the "VariableLiveRange"s from that one.
// After we dump all the "VariableLiveRange"s we call "reset" with
// the "liveRangeList" to set the barrier to nullptr or the last
// "VariableLiveRange" if it is opened.
// If no "VariableLiveRange" was edited/added during block,
// the iterator points to the end of variable's LiveRangeList.
//
classLiveRangeDumper
 {
// Iterator to the first edited/added position during actual block code generation. If last
// block had a closed "VariableLiveRange" (with a valid "m_EndEmitLocation") and not changes
// were applied to variable liveness, it points to the end of variable's LiveRangeList.
 LiveRangeListIterator m_StartingLiveRange;
bool m_hasLiveRangestoDump; // True if a live range for this variable has been
// reported from last call to EndBlock

public:
LiveRangeDumper(const LiveRangeList* liveRanges)
 : m_StartingLiveRange(liveRanges->end()), m_hasLiveRangestoDump(false){};

// Make the dumper point to the last "VariableLiveRange" opened or nullptr if all are closed
voidresetDumper(const LiveRangeList* list);

// Make "LiveRangeDumper" instance points the last "VariableLiveRange" added so we can
// start dumping from there after the actual "BasicBlock"s code is generated.
voidsetDumperStartAt(const LiveRangeListIterator liveRangeIt);

// Return an iterator to the first "VariableLiveRange" edited/added during the current
// "BasicBlock"
 LiveRangeListIterator getStartForDump() const;

// Return whether at least a "VariableLiveRange" was alive during the current "BasicBlock"'s
// code generation
boolhasLiveRangesToDump() const;
 };
#endif // DEBUG

//--------------------------------------------
//
// VariableLiveDescriptor: This class persist and update all the changes
// to the home of a variable. It has an instance of "LiveRangeList"
// and methods to report the start/end of a VariableLiveRange.
//
classVariableLiveDescriptor
 {
 LiveRangeList* m_VariableLiveRanges; // the variable locations of this variable
INDEBUG(LiveRangeDumper* m_VariableLifeBarrier);

public:
VariableLiveDescriptor(CompAllocator allocator);

boolhasVariableLiveRangeOpen() const;
 LiveRangeList* getLiveRanges() const;

voidstartLiveRangeFromEmitter(CodeGenInterface::siVarLoc varLocation, emitter* emit) const;
voidendLiveRangeAtEmitter(emitter* emit) const;
voidupdateLiveRangeAtEmitter(CodeGenInterface::siVarLoc varLocation, emitter* emit) const;

#ifdef DEBUG
voiddumpAllRegisterLiveRangesForBlock(emitter* emit, const CodeGenInterface* codeGen) const;
voiddumpRegisterLiveRangesForBlockBeforeCodeGenerated(const CodeGenInterface* codeGen) const;
boolhasVarLiveRangesToDump() const;
boolhasVarLiveRangesFromLastBlockToDump() const;
voidendBlockLiveRanges();
#endif// DEBUG
 };

unsignedint m_LiveDscCount; // count of args, special args, and IL local variables to report home
unsignedint m_LiveArgsCount; // count of arguments to report home

 Compiler* m_Compiler;

 VariableLiveDescriptor* m_vlrLiveDsc; // Array of descriptors that manage VariableLiveRanges.
// Its indices correspond to lvaTable indexes (or lvSlotNum).

 VariableLiveDescriptor* m_vlrLiveDscForProlog; // Array of descriptors that manage VariableLiveRanges.
// Its indices correspond to lvaTable indexes (or lvSlotNum).

bool m_LastBasicBlockHasBeenEmited; // When true no more siEndVariableLiveRange is considered.
// No update/start happens when code has been generated.

public:
VariableLiveKeeper(unsignedint totalLocalCount,
unsignedint argsCount,
 Compiler* compiler,
 CompAllocator allocator);

// For tracking locations during code generation
voidsiStartOrCloseVariableLiveRange(const LclVarDsc* varDsc, unsignedint varNum, bool isBorn, bool isDying);
voidsiStartOrCloseVariableLiveRanges(VARSET_VALARG_TP varsIndexSet, bool isBorn, bool isDying);
voidsiStartVariableLiveRange(const LclVarDsc* varDsc, unsignedint varNum);
voidsiEndVariableLiveRange(unsignedint varNum);
voidsiUpdateVariableLiveRange(const LclVarDsc* varDsc, unsignedint varNum);
voidsiEndAllVariableLiveRange(VARSET_VALARG_TP varsToClose);
voidsiEndAllVariableLiveRange();

 LiveRangeList* getLiveRangesForVarForBody(unsignedint varNum) const;
 LiveRangeList* getLiveRangesForVarForProlog(unsignedint varNum) const;
size_tgetLiveRangesCount() const;

// For parameters locations on prolog
voidpsiStartVariableLiveRange(CodeGenInterface::siVarLoc varLocation, unsignedint varNum);
voidpsiClosePrologVariableRanges();

#ifdef DEBUG
voiddumpBlockVariableLiveRanges(const BasicBlock* block);
voiddumpLvaVariableLiveRanges() const;
#endif// DEBUG
 };

voidinitializeVariableLiveKeeper();

 VariableLiveKeeper* getVariableLiveKeeper() const;

protected:
 VariableLiveKeeper* varLiveKeeper; // Used to manage VariableLiveRanges of variables
#endif // USING_VARIABLE_LIVE_RANGE

#ifdef LATE_DISASM
public:
virtualconstchar* siRegVarName(size_t offs, size_t size, unsigned reg) = 0;

virtualconstchar* siStackVarName(size_t offs, size_t size, unsigned reg, unsigned stkOffs) = 0;
#endif// LATE_DISASM
};

#endif // _CODEGEN_INTERFACE_H_