emit.cpp

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

voidemitLocation::CaptureLocation(emitter* emit)
{
 ig = emit->emitCurIG;
 codePos = emit->emitCurOffset();

assert(Valid());
}

boolemitLocation::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);
}

intemitLocation::GetInsNum() const
{
returnemitGetInsNumFromCodePos(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
voidemitLocation::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

constchar* emitter::emitIfName(unsigned f)
{
staticconstchar* const ifNames[] = {
#defineIF_DEF(en, op1, op2) "IF_" #en,
#include"emitfmts.h"
 };

staticchar errBuff[32];

if (f < _countof(ifNames))
 {
return ifNames[f];
 }

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

#endif

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

#if EMITTER_STATS

staticunsigned totAllocdSize;
staticunsigned totActualSize;

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

staticunsigned emitSizeBuckets[] = {100, 1024 * 1, 1024 * 2, 1024 * 3, 1024 * 4, 1024 * 5, 1024 * 10, 0};
static Histogram emitSizeTable(emitSizeBuckets);

staticunsigned GCrefsBuckets[] = {0, 1, 2, 5, 10, 20, 50, 128, 256, 512, 1024, 0};
static Histogram GCrefsTable(GCrefsBuckets);

staticunsigned 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];

voidemitterStaticStats(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");
}

voidemitterStats(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

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

constunsignedshort emitTypeSizes[] = {
#defineDEF_TP(tn, nm, jitType, verType, sz, sze, asze, st, al, tf, howUsed) sze,
#include"typelist.h"
#undef DEF_TP
};

constunsignedshort emitTypeActSz[] = {
#defineDEF_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.
*/

voidemitter::emitInit()
{
}

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

voidemitter::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
*/
voidemitLclVarAddr::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.
intemitLclVarAddr::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;
 }
}

unsignedemitLclVarAddr::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.
*/

voidemitter::emitBegCG(Compiler* comp, COMP_HANDLE cmpHandle)
{
 emitComp = comp;
 emitCmpHandle = cmpHandle;
}

voidemitter::emitEndCG()
{
}

/*****************************************************************************
 *
 * Prepare the given IG for emission of code.
*/

voidemitter::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((unsignedshort)emitCurIGsize == emitCurIGsize);

 ig->igInsCnt = (BYTE)emitCurIGinsCnt;
 ig->igSize = (unsignedshort)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.
*/

voidemitter::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 */