// 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.

/*XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

XX XX

XX emit.cpp XX

XX XX

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

*/

#include "jitpch.h"

#ifdef _MSC_VER

#pragma hdrstop

#endif

#include "hostallocator.h"

#include "instr.h"

#include "emit.h"

#include "codegen.h"

/*****************************************************************************

*

* Represent an emitter location.

*/

void emitLocation::CaptureLocation(emitter* emit)

{

ig = emit->emitCurIG;

codePos = emit->emitCurOffset();

assert(Valid());

}

bool emitLocation::IsCurrentLocation(emitter* emit) const

{

assert(Valid());

return (ig == emit->emitCurIG) && (codePos == emit->emitCurOffset());

}

UNATIVE_OFFSET emitLocation::CodeOffset(emitter* emit) const

{

assert(Valid());

return emit->emitCodeOffset(ig, codePos);

}

int emitLocation::GetInsNum() const

{

return emitGetInsNumFromCodePos(codePos);

}

// Get the instruction offset in the current instruction group, which must be a funclet prolog group.

// This is used to find an instruction offset used in unwind data.

// TODO-AMD64-Bug?: We only support a single main function prolog group, but allow for multiple funclet prolog

// groups (not that we actually use that flexibility, since the funclet prolog will be small). How to

// handle that?

UNATIVE_OFFSET emitLocation::GetFuncletPrologOffset(emitter* emit) const

{

assert(ig->igFuncIdx != 0);

assert((ig->igFlags & IGF_FUNCLET_PROLOG) != 0);

assert(ig == emit->emitCurIG);

return emit->emitCurIGsize;

}

#ifdef DEBUG

void emitLocation::Print() const

{

unsigned insNum = emitGetInsNumFromCodePos(codePos);

unsigned insOfs = emitGetInsOfsFromCodePos(codePos);

printf("(G_M%03u_IG%02u,ins#%d,ofs#%d)", Compiler::s_compMethodsCount, ig->igNum, insNum, insOfs);

}

#endif // DEBUG

/*****************************************************************************

*

* Return the name of an instruction format.

*/

#if defined(DEBUG) || EMITTER_STATS

const char* emitter::emitIfName(unsigned f)

{

static const char* const ifNames[] = {

#define IF_DEF(en, op1, op2) "IF_" #en,

#include "emitfmts.h"

};

static char errBuff[32];

if (f < _countof(ifNames))

{

return ifNames[f];

}

sprintf_s(errBuff, sizeof(errBuff), "??%u??", f);

return errBuff;

}

#endif

/*****************************************************************************/

#if EMITTER_STATS

static unsigned totAllocdSize;

static unsigned totActualSize;

unsigned emitter::emitIFcounts[emitter::IF_COUNT];

static unsigned emitSizeBuckets[] = {100, 1024 * 1, 1024 * 2, 1024 * 3, 1024 * 4, 1024 * 5, 1024 * 10, 0};

static Histogram emitSizeTable(emitSizeBuckets);

static unsigned GCrefsBuckets[] = {0, 1, 2, 5, 10, 20, 50, 128, 256, 512, 1024, 0};

static Histogram GCrefsTable(GCrefsBuckets);

static unsigned stkDepthBuckets[] = {0, 1, 2, 5, 10, 16, 32, 128, 1024, 0};

static Histogram stkDepthTable(stkDepthBuckets);

size_t emitter::emitSizeMethod;

size_t emitter::emitTotMemAlloc;

unsigned emitter::emitTotalInsCnt;

unsigned emitter::emitCurPrologInsCnt;

size_t emitter::emitCurPrologIGSize;

unsigned emitter::emitMaxPrologInsCnt;

size_t emitter::emitMaxPrologIGSize;

unsigned emitter::emitTotalIGcnt;

unsigned emitter::emitTotalPhIGcnt;

unsigned emitter::emitTotalIGjmps;

unsigned emitter::emitTotalIGptrs;

unsigned emitter::emitTotalIGicnt;

size_t emitter::emitTotalIGsize;

unsigned emitter::emitTotalIGmcnt;

unsigned emitter::emitTotalIGextend;

unsigned emitter::emitTotalIDescSmallCnt;

unsigned emitter::emitTotalIDescCnt;

unsigned emitter::emitTotalIDescJmpCnt;

#if !defined(_TARGET_ARM64_)

unsigned emitter::emitTotalIDescLblCnt;

#endif // !defined(_TARGET_ARM64_)

unsigned emitter::emitTotalIDescCnsCnt;

unsigned emitter::emitTotalIDescDspCnt;

unsigned emitter::emitTotalIDescCnsDspCnt;

#ifdef _TARGET_XARCH_

unsigned emitter::emitTotalIDescAmdCnt;

unsigned emitter::emitTotalIDescCnsAmdCnt;

#endif // _TARGET_XARCH_

unsigned emitter::emitTotalIDescCGCACnt;

#ifdef _TARGET_ARM_

unsigned emitter::emitTotalIDescRelocCnt;

#endif // _TARGET_ARM_

unsigned emitter::emitSmallDspCnt;

unsigned emitter::emitLargeDspCnt;

unsigned emitter::emitSmallCnsCnt;

unsigned emitter::emitLargeCnsCnt;

unsigned emitter::emitSmallCns[SMALL_CNS_TSZ];

void emitterStaticStats(FILE* fout)

{

// insGroup members

insGroup* igDummy = nullptr;

fprintf(fout, "\n");

fprintf(fout, "insGroup:\n");

fprintf(fout, "Offset / size of igNext = %2u / %2u\n", offsetof(insGroup, igNext),

sizeof(igDummy->igNext));

#ifdef DEBUG

fprintf(fout, "Offset / size of igSelf = %2u / %2u\n", offsetof(insGroup, igSelf),

sizeof(igDummy->igSelf));

#endif

fprintf(fout, "Offset / size of igNum = %2u / %2u\n", offsetof(insGroup, igNum),

sizeof(igDummy->igNum));

fprintf(fout, "Offset / size of igOffs = %2u / %2u\n", offsetof(insGroup, igOffs),

sizeof(igDummy->igOffs));

fprintf(fout, "Offset / size of igFuncIdx = %2u / %2u\n", offsetof(insGroup, igFuncIdx),

sizeof(igDummy->igFuncIdx));

fprintf(fout, "Offset / size of igFlags = %2u / %2u\n", offsetof(insGroup, igFlags),

sizeof(igDummy->igFlags));

fprintf(fout, "Offset / size of igSize = %2u / %2u\n", offsetof(insGroup, igSize),

sizeof(igDummy->igSize));

fprintf(fout, "Offset / size of igData = %2u / %2u\n", offsetof(insGroup, igData),

sizeof(igDummy->igData));

fprintf(fout, "Offset / size of igPhData = %2u / %2u\n", offsetof(insGroup, igPhData),

sizeof(igDummy->igPhData));

#if EMIT_TRACK_STACK_DEPTH

fprintf(fout, "Offset / size of igStkLvl = %2u / %2u\n", offsetof(insGroup, igStkLvl),

sizeof(igDummy->igStkLvl));

#endif

fprintf(fout, "Offset / size of igGCregs = %2u / %2u\n", offsetof(insGroup, igGCregs),

sizeof(igDummy->igGCregs));

fprintf(fout, "Offset / size of igInsCnt = %2u / %2u\n", offsetof(insGroup, igInsCnt),

sizeof(igDummy->igInsCnt));

fprintf(fout, "\n");

fprintf(fout, "Size of insGroup = %u\n", sizeof(insGroup));

// insPlaceholderGroupData members

fprintf(fout, "\n");

fprintf(fout, "insPlaceholderGroupData:\n");

fprintf(fout, "Offset of igPhNext = %2u\n", offsetof(insPlaceholderGroupData, igPhNext));

fprintf(fout, "Offset of igPhBB = %2u\n", offsetof(insPlaceholderGroupData, igPhBB));

fprintf(fout, "Offset of igPhInitGCrefVars = %2u\n", offsetof(insPlaceholderGroupData, igPhInitGCrefVars));

fprintf(fout, "Offset of igPhInitGCrefRegs = %2u\n", offsetof(insPlaceholderGroupData, igPhInitGCrefRegs));

fprintf(fout, "Offset of igPhInitByrefRegs = %2u\n", offsetof(insPlaceholderGroupData, igPhInitByrefRegs));

fprintf(fout, "Offset of igPhPrevGCrefVars = %2u\n", offsetof(insPlaceholderGroupData, igPhPrevGCrefVars));

fprintf(fout, "Offset of igPhPrevGCrefRegs = %2u\n", offsetof(insPlaceholderGroupData, igPhPrevGCrefRegs));

fprintf(fout, "Offset of igPhPrevByrefRegs = %2u\n", offsetof(insPlaceholderGroupData, igPhPrevByrefRegs));

fprintf(fout, "Offset of igPhType = %2u\n", offsetof(insPlaceholderGroupData, igPhType));

fprintf(fout, "Size of insPlaceholderGroupData = %u\n", sizeof(insPlaceholderGroupData));

fprintf(fout, "\n");

fprintf(fout, "SMALL_IDSC_SIZE = %2u\n", SMALL_IDSC_SIZE);

fprintf(fout, "Size of instrDesc = %2u\n", sizeof(emitter::instrDesc));

// fprintf(fout, "Offset of _idIns = %2u\n", offsetof(emitter::instrDesc, _idIns ));

// fprintf(fout, "Offset of _idInsFmt = %2u\n", offsetof(emitter::instrDesc, _idInsFmt ));

// fprintf(fout, "Offset of _idOpSize = %2u\n", offsetof(emitter::instrDesc, _idOpSize ));

// fprintf(fout, "Offset of idSmallCns = %2u\n", offsetof(emitter::instrDesc, idSmallCns ));

// fprintf(fout, "Offset of _idAddrUnion= %2u\n", offsetof(emitter::instrDesc, _idAddrUnion));

// fprintf(fout, "\n");

// fprintf(fout, "Size of _idAddrUnion= %2u\n", sizeof(((emitter::instrDesc*)0)->_idAddrUnion));

fprintf(fout, "Size of instrDescJmp = %2u\n", sizeof(emitter::instrDescJmp));

#if !defined(_TARGET_ARM64_)

fprintf(fout, "Size of instrDescLbl = %2u\n", sizeof(emitter::instrDescLbl));

#endif // !defined(_TARGET_ARM64_)

fprintf(fout, "Size of instrDescCns = %2u\n", sizeof(emitter::instrDescCns));

fprintf(fout, "Size of instrDescDsp = %2u\n", sizeof(emitter::instrDescDsp));

fprintf(fout, "Size of instrDescCnsDsp = %2u\n", sizeof(emitter::instrDescCnsDsp));

#ifdef _TARGET_XARCH_

fprintf(fout, "Size of instrDescAmd = %2u\n", sizeof(emitter::instrDescAmd));

fprintf(fout, "Size of instrDescCnsAmd = %2u\n", sizeof(emitter::instrDescCnsAmd));

#endif // _TARGET_XARCH_

fprintf(fout, "Size of instrDescCGCA = %2u\n", sizeof(emitter::instrDescCGCA));

#ifdef _TARGET_ARM_

fprintf(fout, "Size of instrDescReloc = %2u\n", sizeof(emitter::instrDescReloc));

#endif // _TARGET_ARM_

fprintf(fout, "\n");

fprintf(fout, "SC_IG_BUFFER_SIZE = %2u\n", SC_IG_BUFFER_SIZE);

fprintf(fout, "SMALL_IDSC_SIZE per IG buffer = %2u\n", SC_IG_BUFFER_SIZE / SMALL_IDSC_SIZE);

fprintf(fout, "instrDesc per IG buffer = %2u\n", SC_IG_BUFFER_SIZE / sizeof(emitter::instrDesc));

fprintf(fout, "instrDescJmp per IG buffer = %2u\n", SC_IG_BUFFER_SIZE / sizeof(emitter::instrDescJmp));

#if !defined(_TARGET_ARM64_)

fprintf(fout, "instrDescLbl per IG buffer = %2u\n", SC_IG_BUFFER_SIZE / sizeof(emitter::instrDescLbl));

#endif // !defined(_TARGET_ARM64_)

fprintf(fout, "instrDescCns per IG buffer = %2u\n", SC_IG_BUFFER_SIZE / sizeof(emitter::instrDescCns));

fprintf(fout, "instrDescDsp per IG buffer = %2u\n", SC_IG_BUFFER_SIZE / sizeof(emitter::instrDescDsp));

fprintf(fout, "instrDescCnsDsp per IG buffer = %2u\n", SC_IG_BUFFER_SIZE / sizeof(emitter::instrDescCnsDsp));

#ifdef _TARGET_XARCH_

fprintf(fout, "instrDescAmd per IG buffer = %2u\n", SC_IG_BUFFER_SIZE / sizeof(emitter::instrDescAmd));

fprintf(fout, "instrDescCnsAmd per IG buffer = %2u\n", SC_IG_BUFFER_SIZE / sizeof(emitter::instrDescCnsAmd));

#endif // _TARGET_XARCH_

fprintf(fout, "instrDescCGCA per IG buffer = %2u\n", SC_IG_BUFFER_SIZE / sizeof(emitter::instrDescCGCA));

#ifdef _TARGET_ARM_

fprintf(fout, "instrDescReloc per IG buffer = %2u\n", SC_IG_BUFFER_SIZE / sizeof(emitter::instrDescReloc));

#endif // _TARGET_ARM_

fprintf(fout, "\n");

fprintf(fout, "GCInfo::regPtrDsc:\n");

fprintf(fout, "Offset of rpdNext = %2u\n", offsetof(GCInfo::regPtrDsc, rpdNext));

fprintf(fout, "Offset of rpdOffs = %2u\n", offsetof(GCInfo::regPtrDsc, rpdOffs));

fprintf(fout, "Offset of <union> = %2u\n", offsetof(GCInfo::regPtrDsc, rpdPtrArg));

fprintf(fout, "Size of GCInfo::regPtrDsc = %2u\n", sizeof(GCInfo::regPtrDsc));

fprintf(fout, "\n");

}

void emitterStats(FILE* fout)

{

if (totAllocdSize > 0)

{

assert(totActualSize <= totAllocdSize);

fprintf(fout, "\nTotal allocated code size = %u\n", totAllocdSize);

if (totActualSize < totAllocdSize)

{

fprintf(fout, "Total generated code size = %u ", totActualSize);

fprintf(fout, "(%4.3f%% waste)", 100 * ((totAllocdSize - totActualSize) / (double)totActualSize));

fprintf(fout, "\n");

}

assert(emitter::emitTotalInsCnt > 0);

fprintf(fout, "Average of %4.2f bytes of code generated per instruction\n",

(double)totActualSize / emitter::emitTotalInsCnt);

}

fprintf(fout, "\nInstruction format frequency table:\n\n");

unsigned f, ic = 0, dc = 0;

for (f = 0; f < emitter::IF_COUNT; f++)

{

ic += emitter::emitIFcounts[f];

}

for (f = 0; f < emitter::IF_COUNT; f++)

{

unsigned c = emitter::emitIFcounts[f];

if ((c > 0) && (1000 * c >= ic))

{

dc += c;

fprintf(fout, " %-14s %8u (%5.2f%%)\n", emitter::emitIfName(f), c, 100.0 * c / ic);

}

}

fprintf(fout, " ---------------------------------\n");

fprintf(fout, " %-14s %8u (%5.2f%%)\n", "Total shown", dc, 100.0 * dc / ic);

if (emitter::emitTotalIGmcnt > 0)

{

fprintf(fout, "\n");

fprintf(fout, "Total of %8u methods\n", emitter::emitTotalIGmcnt);

fprintf(fout, "Total of %8u insGroup\n", emitter::emitTotalIGcnt);

fprintf(fout, "Total of %8u insPlaceholderGroupData\n", emitter::emitTotalPhIGcnt);

fprintf(fout, "Total of %8u extend insGroup\n", emitter::emitTotalIGextend);

fprintf(fout, "Total of %8u instructions\n", emitter::emitTotalIGicnt);

fprintf(fout, "Total of %8u jumps\n", emitter::emitTotalIGjmps);

fprintf(fout, "Total of %8u GC livesets\n", emitter::emitTotalIGptrs);

fprintf(fout, "\n");

fprintf(fout, "Max prolog instrDesc count: %8u\n", emitter::emitMaxPrologInsCnt);

fprintf(fout, "Max prolog insGroup size : %8u\n", emitter::emitMaxPrologIGSize);

fprintf(fout, "\n");

fprintf(fout, "Average of %8.1lf insGroup per method\n",

(double)emitter::emitTotalIGcnt / emitter::emitTotalIGmcnt);

fprintf(fout, "Average of %8.1lf insPhGroup per method\n",

(double)emitter::emitTotalPhIGcnt / emitter::emitTotalIGmcnt);

fprintf(fout, "Average of %8.1lf extend IG per method\n",

(double)emitter::emitTotalIGExtend / emitter::emitTotalIGmcnt);

fprintf(fout, "Average of %8.1lf instructions per method\n",

(double)emitter::emitTotalIGicnt / emitter::emitTotalIGmcnt);

fprintf(fout, "Average of %8.1lf desc. bytes per method\n",

(double)emitter::emitTotalIGsize / emitter::emitTotalIGmcnt);

fprintf(fout, "Average of %8.1lf jumps per method\n",

(double)emitter::emitTotalIGjmps / emitter::emitTotalIGmcnt);

fprintf(fout, "Average of %8.1lf GC livesets per method\n",

(double)emitter::emitTotalIGptrs / emitter::emitTotalIGmcnt);

fprintf(fout, "\n");

fprintf(fout, "Average of %8.1lf instructions per group \n",

(double)emitter::emitTotalIGicnt / emitter::emitTotalIGcnt);

fprintf(fout, "Average of %8.1lf desc. bytes per group \n",

(double)emitter::emitTotalIGsize / emitter::emitTotalIGcnt);

fprintf(fout, "Average of %8.1lf jumps per group \n",

(double)emitter::emitTotalIGjmps / emitter::emitTotalIGcnt);

fprintf(fout, "\n");

fprintf(fout, "Average of %8.1lf bytes per instrDesc\n",

(double)emitter::emitTotalIGsize / emitter::emitTotalIGicnt);

fprintf(fout, "\n");

fprintf(fout, "A total of %8u desc. bytes\n", emitter::emitTotalIGsize);

fprintf(fout, "\n");

fprintf(fout, "Total instructions: %8u\n", emitter::emitTotalInsCnt);

fprintf(fout, "Total small instrDesc: %8u (%5.2f%%)\n", emitter::emitTotalIDescSmallCnt,

100.0 * emitter::emitTotalIDescSmallCnt / emitter::emitTotalInsCnt);

fprintf(fout, "Total instrDesc: %8u (%5.2f%%)\n", emitter::emitTotalIDescCnt,

100.0 * emitter::emitTotalIDescCnt / emitter::emitTotalInsCnt);

fprintf(fout, "Total instrDescJmp: %8u (%5.2f%%)\n", emitter::emitTotalIDescJmpCnt,

100.0 * emitter::emitTotalIDescJmpCnt / emitter::emitTotalInsCnt);

#if !defined(_TARGET_ARM64_)

fprintf(fout, "Total instrDescLbl: %8u (%5.2f%%)\n", emitter::emitTotalIDescLblCnt,

100.0 * emitter::emitTotalIDescLblCnt / emitter::emitTotalInsCnt);

#endif // !defined(_TARGET_ARM64_)

fprintf(fout, "Total instrDescCns: %8u (%5.2f%%)\n", emitter::emitTotalIDescCnsCnt,

100.0 * emitter::emitTotalIDescCnsCnt / emitter::emitTotalInsCnt);

fprintf(fout, "Total instrDescDsp: %8u (%5.2f%%)\n", emitter::emitTotalIDescDspCnt,

100.0 * emitter::emitTotalIDescDspCnt / emitter::emitTotalInsCnt);

fprintf(fout, "Total instrDescCnsDsp: %8u (%5.2f%%)\n", emitter::emitTotalIDescCnsDspCnt,

100.0 * emitter::emitTotalIDescCnsDspCnt / emitter::emitTotalInsCnt);

#ifdef _TARGET_XARCH_

fprintf(fout, "Total instrDescAmd: %8u (%5.2f%%)\n", emitter::emitTotalIDescAmdCnt,

100.0 * emitter::emitTotalIDescAmdCnt / emitter::emitTotalInsCnt);

fprintf(fout, "Total instrDescCnsAmd: %8u (%5.2f%%)\n", emitter::emitTotalIDescCnsAmdCnt,

100.0 * emitter::emitTotalIDescCnsAmdCnt / emitter::emitTotalInsCnt);

#endif // _TARGET_XARCH_

fprintf(fout, "Total instrDescCGCA: %8u (%5.2f%%)\n", emitter::emitTotalIDescCGCACnt,

100.0 * emitter::emitTotalIDescCGCACnt / emitter::emitTotalInsCnt);

#ifdef _TARGET_ARM_

fprintf(fout, "Total instrDescReloc: %8u (%5.2f%%)\n", emitter::emitTotalIDescRelocCnt,

100.0 * emitter::emitTotalIDescRelocCnt / emitter::emitTotalInsCnt);

#endif // _TARGET_ARM_

fprintf(fout, "\n");

}

fprintf(fout, "Descriptor size distribution:\n");

emitSizeTable.dump(fout);

fprintf(fout, "\n");

fprintf(fout, "GC ref frame variable counts:\n");

GCrefsTable.dump(fout);

fprintf(fout, "\n");

fprintf(fout, "Max. stack depth distribution:\n");

stkDepthTable.dump(fout);

fprintf(fout, "\n");

if ((emitter::emitSmallCnsCnt > 0) || (emitter::emitLargeCnsCnt > 0))

{

fprintf(fout, "SmallCnsCnt = %6u\n", emitter::emitSmallCnsCnt);

fprintf(fout, "LargeCnsCnt = %6u (%3u %% of total)\n", emitter::emitLargeCnsCnt,

100 * emitter::emitLargeCnsCnt / (emitter::emitLargeCnsCnt + emitter::emitSmallCnsCnt));

}

// Print out the most common small constants.

if (emitter::emitSmallCnsCnt > 0)

{

fprintf(fout, "\n\n");

fprintf(fout, "Common small constants >= %2u, <= %2u\n", ID_MIN_SMALL_CNS, ID_MAX_SMALL_CNS);

unsigned m = emitter::emitSmallCnsCnt / 1000 + 1;

for (int i = ID_MIN_SMALL_CNS; (i <= ID_MAX_SMALL_CNS) && (i < SMALL_CNS_TSZ); i++)

{

unsigned c = emitter::emitSmallCns[i - ID_MIN_SMALL_CNS];

if (c >= m)

{

if (i == SMALL_CNS_TSZ - 1)

{

fprintf(fout, "cns[>=%4d] = %u\n", i, c);

}

else

{

fprintf(fout, "cns[%4d] = %u\n", i, c);

}

}

}

}

fprintf(fout, "%8u bytes allocated in the emitter\n", emitter::emitTotMemAlloc);

}

#endif // EMITTER_STATS

/*****************************************************************************/

const unsigned short emitTypeSizes[] = {

#define DEF_TP(tn, nm, jitType, verType, sz, sze, asze, st, al, tf, howUsed) sze,

#include "typelist.h"

#undef DEF_TP

};

const unsigned short emitTypeActSz[] = {

#define DEF_TP(tn, nm, jitType, verType, sz, sze, asze, st, al, tf, howUsed) asze,

#include "typelist.h"

#undef DEF_TP

};

/*****************************************************************************/

/*****************************************************************************

*

* Initialize the emitter - called once, at DLL load time.

*/

void emitter::emitInit()

{

}

/*****************************************************************************

*

* Shut down the emitter - called once, at DLL exit time.

*/

void emitter::emitDone()

{

}

/*****************************************************************************

*

* Allocate memory.

*/

void* emitter::emitGetMem(size_t sz)

{

assert(sz % sizeof(int) == 0);

#if EMITTER_STATS

emitTotMemAlloc += sz;

#endif

return emitComp->getAllocator(CMK_InstDesc).allocate<char>(sz);

}

/*****************************************************************************

*

* emitLclVarAddr support methods

*/

void emitLclVarAddr::initLclVarAddr(int varNum, unsigned offset)

{

if (varNum < 32768)

{

if (varNum >= 0)

{

if (offset < 32768)

{

_lvaTag = LVA_STANDARD_ENCODING;

_lvaExtra = offset; // offset known to be in [0..32767]

_lvaVarNum = (unsigned)varNum; // varNum known to be in [0..32767]

}

else // offset >= 32768

{

// We could support larger local offsets here at the cost of less varNums

if (offset >= 65536)

{

IMPL_LIMITATION("JIT doesn't support offsets larger than 65535 into valuetypes\n");

}

_lvaTag = LVA_LARGE_OFFSET;

_lvaExtra = (offset - 32768); // (offset-32768) is known to be in [0..32767]

_lvaVarNum = (unsigned)varNum; // varNum known to be in [0..32767]

}

}

else // varNum < 0, These are used for Compiler spill temps

{

if (varNum < -32767)

{

IMPL_LIMITATION("JIT doesn't support more than 32767 Compiler Spill temps\n");

}

if (offset > 32767)

{

IMPL_LIMITATION(

"JIT doesn't support offsets larger than 32767 into valuetypes for Compiler Spill temps\n");

}

_lvaTag = LVA_COMPILER_TEMP;

_lvaExtra = offset; // offset known to be in [0..32767]

_lvaVarNum = (unsigned)(-varNum); // -varNum known to be in [1..32767]

}

}

else // varNum >= 32768

{

if (offset >= 256)

{

IMPL_LIMITATION("JIT doesn't support offsets larger than 255 into valuetypes for local vars > 32767\n");

}

if (varNum >= 0x00400000)

{ // 0x00400000 == 2^22

IMPL_LIMITATION("JIT doesn't support more than 2^22 variables\n");

}

_lvaTag = LVA_LARGE_VARNUM;

_lvaVarNum = varNum & 0x00007FFF; // varNum bits 14 to 0

_lvaExtra = (varNum & 0x003F8000) >> 15; // varNum bits 21 to 15 in _lvaExtra bits 6 to 0, 7 bits total

_lvaExtra |= (offset << 7); // offset bits 7 to 0 in _lvaExtra bits 14 to 7, 8 bits total

}

}

// Returns the variable to access. Note that it returns a negative number for compiler spill temps.

int emitLclVarAddr::lvaVarNum()

{

switch (_lvaTag)

{

case LVA_COMPILER_TEMP:

return -((int)_lvaVarNum);

case LVA_LARGE_VARNUM:

return (int)(((_lvaExtra & 0x007F) << 15) + _lvaVarNum);

default: // LVA_STANDARD_ENCODING or LVA_LARGE_OFFSET

assert((_lvaTag == LVA_STANDARD_ENCODING) || (_lvaTag == LVA_LARGE_OFFSET));

return (int)_lvaVarNum;

}

}

unsigned emitLclVarAddr::lvaOffset() // returns the offset into the variable to access

{

switch (_lvaTag)

{

case LVA_LARGE_OFFSET:

return (32768 + _lvaExtra);

case LVA_LARGE_VARNUM:

return (_lvaExtra & 0x7F80) >> 7;

default: // LVA_STANDARD_ENCODING or LVA_COMPILER_TEMP

assert((_lvaTag == LVA_STANDARD_ENCODING) || (_lvaTag == LVA_COMPILER_TEMP));

return _lvaExtra;

}

}

/*****************************************************************************

*

* Record some info about the method about to be emitted.

*/

void emitter::emitBegCG(Compiler* comp, COMP_HANDLE cmpHandle)

{

emitComp = comp;

emitCmpHandle = cmpHandle;

}

void emitter::emitEndCG()

{

}

/*****************************************************************************

*

* Prepare the given IG for emission of code.

*/

void emitter::emitGenIG(insGroup* ig)

{

/* Set the "current IG" value */

emitCurIG = ig;

#if EMIT_TRACK_STACK_DEPTH

/* Record the stack level on entry to this group */

ig->igStkLvl = emitCurStackLvl;

// If we don't have enough bits in igStkLvl, refuse to compile

if (ig->igStkLvl != emitCurStackLvl)

{

IMPL_LIMITATION("Too many arguments pushed on stack");

}

// printf("Start IG #%02u [stk=%02u]\n", ig->igNum, emitCurStackLvl);

#endif

if (emitNoGCIG)

{

ig->igFlags |= IGF_NOGCINTERRUPT;

}

/* Prepare to issue instructions */

emitCurIGinsCnt = 0;

emitCurIGsize = 0;

assert(emitCurIGjmpList == nullptr);

/* Allocate the temp instruction buffer if we haven't done so */

if (emitCurIGfreeBase == nullptr)

{

emitIGbuffSize = SC_IG_BUFFER_SIZE;

emitCurIGfreeBase = (BYTE*)emitGetMem(emitIGbuffSize);

}

emitCurIGfreeNext = emitCurIGfreeBase;

emitCurIGfreeEndp = emitCurIGfreeBase + emitIGbuffSize;

}

/*****************************************************************************

*

* Finish and save the current IG.

*/

insGroup* emitter::emitSavIG(bool emitAdd)

{

insGroup* ig;

BYTE* id;

size_t sz;

size_t gs;

assert(emitCurIGfreeNext <= emitCurIGfreeEndp);

// Get hold of the IG descriptor

ig = emitCurIG;

assert(ig);

// Compute how much code we've generated

sz = emitCurIGfreeNext - emitCurIGfreeBase;

// Compute the total size we need to allocate

gs = roundUp(sz);

// Do we need space for GC?

if (!(ig->igFlags & IGF_EXTEND))

{

// Is the initial set of live GC vars different from the previous one?

if (emitForceStoreGCState || !VarSetOps::Equal(emitComp, emitPrevGCrefVars, emitInitGCrefVars))

{

// Remember that we will have a new set of live GC variables

ig->igFlags |= IGF_GC_VARS;

#if EMITTER_STATS

emitTotalIGptrs++;

#endif

// We'll allocate extra space to record the liveset

gs += sizeof(VARSET_TP);

}

// Is the initial set of live Byref regs different from the previous one?

// Remember that we will have a new set of live GC variables

ig->igFlags |= IGF_BYREF_REGS;

// We'll allocate extra space (DWORD aligned) to record the GC regs

gs += sizeof(int);

}

// Allocate space for the instructions and optional liveset

id = (BYTE*)emitGetMem(gs);

// Do we need to store the byref regs

if (ig->igFlags & IGF_BYREF_REGS)

{

// Record the byref regs in front the of the instructions

*castto(id, unsigned*)++ = (unsigned)emitInitByrefRegs;

}

// Do we need to store the liveset?

if (ig->igFlags & IGF_GC_VARS)

{

// Record the liveset in front the of the instructions

VarSetOps::AssignNoCopy(emitComp, (*castto(id, VARSET_TP*)), VarSetOps::MakeEmpty(emitComp));

VarSetOps::Assign(emitComp, (*castto(id, VARSET_TP*)++), emitInitGCrefVars);

}

// Record the collected instructions

assert((ig->igFlags & IGF_PLACEHOLDER) == 0);

ig->igData = id;

memcpy(id, emitCurIGfreeBase, sz);

#ifdef DEBUG

if (false && emitComp->verbose) // this is not useful in normal dumps (hence it is normally under if (false)

{

// If there's an error during emission, we may want to connect the post-copy address

// of an instrDesc with the pre-copy address (the one that was originally created). This

// printing enables that.

printf("copying instruction group from [0x%x..0x%x) to [0x%x..0x%x).\n", dspPtr(emitCurIGfreeBase),

dspPtr(emitCurIGfreeBase + sz), dspPtr(id), dspPtr(id + sz));

}

#endif

// Record how many instructions and bytes of code this group contains

noway_assert((BYTE)emitCurIGinsCnt == emitCurIGinsCnt);

noway_assert((unsigned short)emitCurIGsize == emitCurIGsize);

ig->igInsCnt = (BYTE)emitCurIGinsCnt;

ig->igSize = (unsigned short)emitCurIGsize;

emitCurCodeOffset += emitCurIGsize;

assert(IsCodeAligned(emitCurCodeOffset));

#if EMITTER_STATS

emitTotalIGicnt += emitCurIGinsCnt;

emitTotalIGsize += sz;

emitSizeMethod += sz;

if (emitIGisInProlog(ig))

{

emitCurPrologInsCnt += emitCurIGinsCnt;

emitCurPrologIGSize += sz;

// Keep track of the maximums.

if (emitCurPrologInsCnt > emitMaxPrologInsCnt)

{

emitMaxPrologInsCnt = emitCurPrologInsCnt;

}

if (emitCurPrologIGSize > emitMaxPrologIGSize)

{

emitMaxPrologIGSize = emitCurPrologIGSize;

}

}

#endif

// Record the live GC register set - if and only if it is not an extension

// block, in which case the GC register sets are inherited from the previous

// block.

if (!(ig->igFlags & IGF_EXTEND))

{

ig->igGCregs = (regMaskSmall)emitInitGCrefRegs;

}

if (!emitAdd)

{

// Update the previous recorded live GC ref sets, but not if if we are

// starting an "overflow" buffer. Note that this is only used to

// determine whether we need to store or not store the GC ref sets for

// the next IG, which is dependent on exactly what the state of the

// emitter GC ref sets will be when the next IG is processed in the

// emitter.

VarSetOps::Assign(emitComp, emitPrevGCrefVars, emitThisGCrefVars);

emitPrevGCrefRegs = emitThisGCrefRegs;

emitPrevByrefRegs = emitThisByrefRegs;

emitForceStoreGCState = false;

}

#ifdef DEBUG

if (emitComp->opts.dspCode)

{

printf("\n G_M%03u_IG%02u:", Compiler::s_compMethodsCount, ig->igNum);

if (emitComp->verbose)

{

printf(" ; offs=%06XH, funclet=%02u, bbWeight=%s", ig->igOffs, ig->igFuncIdx,

refCntWtd2str(ig->igWeight));

}

else

{

printf(" ; funclet=%02u", ig->igFuncIdx);

}

printf("\n");

}

#endif

// Did we have any jumps in this group?

if (emitCurIGjmpList)

{

instrDescJmp* list = nullptr;

instrDescJmp* last = nullptr;

// Move jumps to the global list, update their 'next' links

do

{

// Grab the jump and remove it from the list

instrDescJmp* oj = emitCurIGjmpList;

emitCurIGjmpList = oj->idjNext;

// Figure out the address of where the jump got copied

size_t of = (BYTE*)oj - emitCurIGfreeBase;

instrDescJmp* nj = (instrDescJmp*)(ig->igData + of);

assert(nj->idjIG == ig);

assert(nj->idIns() == oj->idIns());

assert(nj->idjNext == oj->idjNext);

// Make sure the jumps are correctly ordered

assert(last == nullptr || last->idjOffs > nj->idjOffs);

if (ig->igFlags & IGF_FUNCLET_PROLOG)

{

// Our funclet prologs have short jumps, if the prolog would ever have

// long jumps, then we'd have to insert the list in sorted order than

// just append to the emitJumpList.

noway_assert(nj->idjShort);

if (nj->idjShort)

{

continue;

}

}

// Append the new jump to the list

nj->idjNext = list;

list = nj;

if (last == nullptr)

{

last = nj;

}

} while (emitCurIGjmpList);

if (last != nullptr)

{

// Append the jump(s) from this IG to the global list

bool prologJump = (ig == emitPrologIG);

if ((emitJumpList == nullptr) || prologJump)

{

last->idjNext = emitJumpList;

emitJumpList = list;

}

else

{

last->idjNext = nullptr;

emitJumpLast->idjNext = list;

}

if (!prologJump || (emitJumpLast == nullptr))

{

emitJumpLast = last;

}

}

}

// Fix the last instruction field

if (sz != 0)

{

assert(emitLastIns != nullptr);

assert(emitCurIGfreeBase <= (BYTE*)emitLastIns);

assert((BYTE*)emitLastIns < emitCurIGfreeBase + sz);

emitLastIns = (instrDesc*)((BYTE*)id + ((BYTE*)emitLastIns - (BYTE*)emitCurIGfreeBase));

}

// Reset the buffer free pointers

emitCurIGfreeNext = emitCurIGfreeBase;

return ig;

}

/*****************************************************************************

*

* Start generating code to be scheduled; called once per method.

*/

void emitter::emitBegFN(bool hasFramePtr

#if defined(DEBUG)

,

bool chkAlign

#endif

,

unsigned maxTmpSize)

{

insGroup* ig;

/* Assume we won't need the temp instruction buffer */

emitCurIGfreeBase = nullptr;

emitIGbuffSize = 0;

/* Record stack frame info (the temp size is just an estimate) */

emitHasFramePtr = hasFramePtr;

emitMaxTmpSize = maxTmpSize;

#ifdef DEBUG

emitChkAlign = chkAlign;

#endif

/* We have no epilogs yet */

emitEpilogSize = 0;

emitEpilogCnt = 0;

#ifdef _TARGET_XARCH_

emitExitSeqBegLoc.Init();

emitExitSeqSize = INT_MAX;

#endif // _TARGET_XARCH_

emitPlaceholderList = emitPlaceholderLast = nullptr;

#ifdef JIT32_GCENCODER

emitEpilogList = emitEpilogLast = nullptr;

#endif // JIT32_GCENCODER

/* We don't have any jumps */

emitJumpList = emitJumpLast = nullptr;

emitCurIGjmpList = nullptr;

emitFwdJumps = false;

emitNoGCIG = false;

emitForceNewIG = false;

/* We have not recorded any live sets */

assert(VarSetOps::IsEmpty(emitComp, emitThisGCrefVars));

assert(VarSetOps::IsEmpty(emitComp, emitInitGCrefVars));

assert(VarSetOps::IsEmpty(emitComp, emitPrevGCrefVars));

emitThisGCrefRegs = RBM_NONE;

emitInitGCrefRegs = RBM_NONE;

emitPrevGCrefRegs = RBM_NONE;

emitThisByrefRegs = RBM_NONE;

emitInitByrefRegs = RBM_NONE;

emitPrevByrefRegs = RBM_NONE;

emitForceStoreGCState = false;

#ifdef DEBUG

emitIssuing = false;

#endif

/* Assume there will be no GC ref variables */

emitGCrFrameOffsMin = emitGCrFrameOffsMax = emitGCrFrameOffsCnt = 0;

#ifdef DEBUG

emitGCrFrameLiveTab = nullptr;

#endif

/* We have no groups / code at this point */