gcencode.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 GCEncode XX
XX XX
XX Logic to encode the JIT method header and GC pointer tables XX
XX XX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
*/

#include"jitpch.h"
#ifdef _MSC_VER
#pragma hdrstop

#pragma warning(disable : 4244) // loss of data int -> char ..

#endif

#include"gcinfotypes.h"

ReturnKind GCTypeToReturnKind(CorInfoGCType gcType)
{
switch (gcType)
 {
case TYPE_GC_NONE:
return RT_Scalar;
case TYPE_GC_REF:
return RT_Object;
case TYPE_GC_BYREF:
return RT_ByRef;
default:
_ASSERTE(!"TYP_GC_OTHER is unexpected");
return RT_Illegal;
 }
}

ReturnKind GCInfo::getReturnKind()
{
switch (compiler->info.compRetType)
 {
case TYP_REF:
return RT_Object;
case TYP_BYREF:
return RT_ByRef;
case TYP_STRUCT:
 {
 CORINFO_CLASS_HANDLE structType = compiler->info.compMethodInfo->args.retTypeClass;
 var_types retType = compiler->getReturnTypeForStruct(structType);

switch (retType)
 {
case TYP_REF:
return RT_Object;

case TYP_BYREF:
return RT_ByRef;

case TYP_STRUCT:
if (compiler->IsHfa(structType))
 {
#ifdef _TARGET_X86_
_ASSERTE(false && "HFAs not expected for X86");
#endif// _TARGET_X86_

return RT_Scalar;
 }
else
 {
// Multi-reg return
 BYTE gcPtrs[2] = {TYPE_GC_NONE, TYPE_GC_NONE};
 compiler->info.compCompHnd->getClassGClayout(structType, gcPtrs);

 ReturnKind first = GCTypeToReturnKind((CorInfoGCType)gcPtrs[0]);
 ReturnKind second = GCTypeToReturnKind((CorInfoGCType)gcPtrs[1]);

returnGetStructReturnKind(first, second);
 }

#ifdef _TARGET_X86_
case TYP_FLOAT:
case TYP_DOUBLE:
return RT_Float;
#endif// _TARGET_X86_
default:
return RT_Scalar;
 }
 }

#ifdef _TARGET_X86_
case TYP_FLOAT:
case TYP_DOUBLE:
return RT_Float;
#endif// _TARGET_X86_

default:
return RT_Scalar;
 }
}

#if !defined(JIT32_GCENCODER) || defined(FEATURE_EH_FUNCLETS)

// gcMarkFilterVarsPinned - Walk all lifetimes and make it so that anything
// live in a filter is marked as pinned (often by splitting the lifetime
// so that *only* the filter region is pinned). This should only be
// called once (after generating all lifetimes, but before slot ids are
// finalized.
//
// DevDiv 376329 - The VM has to double report filters and their parent frame
// because they occur during the 1st pass and the parent frame doesn't go dead
// until we start unwinding in the 2nd pass.
//
// Untracked locals will only be reported in non-filter funclets and the
// parent.
// Registers can't be double reported by 2 frames since they're different.
// That just leaves stack variables which might be double reported.
//
// Technically double reporting is only a problem when the GC has to relocate a
// reference. So we avoid that problem by marking all live tracked stack
// variables as pinned inside the filter. Thus if they are double reported, it
// won't be a problem since they won't be double relocated.
//
voidGCInfo::gcMarkFilterVarsPinned()
{
assert(compiler->ehAnyFunclets());
const EHblkDsc* endHBtab = &(compiler->compHndBBtab[compiler->compHndBBtabCount]);

for (EHblkDsc* HBtab = compiler->compHndBBtab; HBtab < endHBtab; HBtab++)
 {
if (HBtab->HasFilter())
 {
const UNATIVE_OFFSET filterBeg = compiler->ehCodeOffset(HBtab->ebdFilter);
const UNATIVE_OFFSET filterEnd = compiler->ehCodeOffset(HBtab->ebdHndBeg);

for (varPtrDsc* varTmp = gcVarPtrList; varTmp != nullptr; varTmp = varTmp->vpdNext)
 {
// Get hold of the variable's flags.
constunsigned lowBits = varTmp->vpdVarNum & OFFSET_MASK;

// Compute the actual lifetime offsets.
constunsigned begOffs = varTmp->vpdBegOfs;
constunsigned endOffs = varTmp->vpdEndOfs;

// Special case: skip any 0-length lifetimes.
if (endOffs == begOffs)
 {
continue;
 }

// Skip lifetimes with no overlap with the filter
if ((endOffs <= filterBeg) || (begOffs >= filterEnd))
 {
continue;
 }

#ifndef JIT32_GCENCODER
// Because there is no nesting within filters, nothing
// should be already pinned.
// For JIT32_GCENCODER, we should not do this check as gcVarPtrList are always sorted by vpdBegOfs
// which means that we could see some varPtrDsc that were already pinned by previous splitting.
assert((lowBits & pinned_OFFSET_FLAG) == 0);
#endif// JIT32_GCENCODER

if (begOffs < filterBeg)
 {
if (endOffs > filterEnd)
 {
// The variable lifetime is starts before AND ends after
// the filter, so we need to create 2 new lifetimes:
// (1) a pinned one for the filter
// (2) a regular one for after the filter
// and then adjust the original lifetime to end before
// the filter.
 CLANG_FORMAT_COMMENT_ANCHOR;

#ifdef DEBUG
if (compiler->verbose)
 {
printf("Splitting lifetime for filter: [%04X, %04X).\nOld: ", filterBeg, filterEnd);
gcDumpVarPtrDsc(varTmp);
 }
#endif// DEBUG

 varPtrDsc* desc1 = new (compiler, CMK_GC) varPtrDsc;
 desc1->vpdVarNum = varTmp->vpdVarNum | pinned_OFFSET_FLAG;
 desc1->vpdBegOfs = filterBeg;
 desc1->vpdEndOfs = filterEnd;

 varPtrDsc* desc2 = new (compiler, CMK_GC) varPtrDsc;
 desc2->vpdVarNum = varTmp->vpdVarNum;
 desc2->vpdBegOfs = filterEnd;
 desc2->vpdEndOfs = endOffs;

 varTmp->vpdEndOfs = filterBeg;

gcInsertVarPtrDscSplit(desc1, varTmp);
gcInsertVarPtrDscSplit(desc2, varTmp);

#ifdef DEBUG
if (compiler->verbose)
 {
printf("New (1 of 3): ");
gcDumpVarPtrDsc(varTmp);
printf("New (2 of 3): ");
gcDumpVarPtrDsc(desc1);
printf("New (3 of 3): ");
gcDumpVarPtrDsc(desc2);
 }
#endif// DEBUG
 }
else
 {
// The variable lifetime started before the filter and ends
// somewhere inside it, so we only create 1 new lifetime,
// and then adjust the original lifetime to end before
// the filter.
 CLANG_FORMAT_COMMENT_ANCHOR;

#ifdef DEBUG
if (compiler->verbose)
 {
printf("Splitting lifetime for filter.\nOld: ");
gcDumpVarPtrDsc(varTmp);
 }
#endif// DEBUG

 varPtrDsc* desc = new (compiler, CMK_GC) varPtrDsc;
 desc->vpdVarNum = varTmp->vpdVarNum | pinned_OFFSET_FLAG;
 desc->vpdBegOfs = filterBeg;
 desc->vpdEndOfs = endOffs;

 varTmp->vpdEndOfs = filterBeg;

gcInsertVarPtrDscSplit(desc, varTmp);

#ifdef DEBUG
if (compiler->verbose)
 {
printf("New (1 of 2): ");
gcDumpVarPtrDsc(varTmp);
printf("New (2 of 2): ");
gcDumpVarPtrDsc(desc);
 }
#endif// DEBUG
 }
 }
else
 {
if (endOffs > filterEnd)
 {
// The variable lifetime starts inside the filter and
// ends somewhere after it, so we create 1 new
// lifetime for the part inside the filter and adjust
// the start of the original lifetime to be the end
// of the filter
 CLANG_FORMAT_COMMENT_ANCHOR;
#ifdef DEBUG
if (compiler->verbose)
 {
printf("Splitting lifetime for filter.\nOld: ");
gcDumpVarPtrDsc(varTmp);
 }
#endif// DEBUG

 varPtrDsc* desc = new (compiler, CMK_GC) varPtrDsc;
#ifndef JIT32_GCENCODER
 desc->vpdVarNum = varTmp->vpdVarNum | pinned_OFFSET_FLAG;
 desc->vpdBegOfs = begOffs;
 desc->vpdEndOfs = filterEnd;

 varTmp->vpdBegOfs = filterEnd;
#else
// Mark varTmp as pinned and generated use varPtrDsc(desc) as non-pinned
// since gcInsertVarPtrDscSplit requires that varTmp->vpdBegOfs must precede desc->vpdBegOfs
 desc->vpdVarNum = varTmp->vpdVarNum;
 desc->vpdBegOfs = filterEnd;
 desc->vpdEndOfs = endOffs;

 varTmp->vpdVarNum = varTmp->vpdVarNum | pinned_OFFSET_FLAG;
 varTmp->vpdEndOfs = filterEnd;
#endif

gcInsertVarPtrDscSplit(desc, varTmp);

#ifdef DEBUG
if (compiler->verbose)
 {
printf("New (1 of 2): ");
gcDumpVarPtrDsc(desc);
printf("New (2 of 2): ");
gcDumpVarPtrDsc(varTmp);
 }
#endif// DEBUG
 }
else
 {
// The variable lifetime is completely within the filter,
// so just add the pinned flag.
 CLANG_FORMAT_COMMENT_ANCHOR;
#ifdef DEBUG
if (compiler->verbose)
 {
printf("Pinning lifetime for filter.\nOld: ");
gcDumpVarPtrDsc(varTmp);
 }
#endif// DEBUG

 varTmp->vpdVarNum |= pinned_OFFSET_FLAG;
#ifdef DEBUG
if (compiler->verbose)
 {
printf("New : ");
gcDumpVarPtrDsc(varTmp);
 }
#endif// DEBUG
 }
 }
 }
 } // HasFilter
 } // Foreach EH
}

// gcInsertVarPtrDscSplit - Insert varPtrDsc that were created by splitting lifetimes
// From gcMarkFilterVarsPinned, we may have created one or two `varPtrDsc`s due to splitting lifetimes
// and these newly created `varPtrDsc`s should be inserted in gcVarPtrList.
// However the semantics of this call depend on the architecture.
//
// x86-GCInfo requires gcVarPtrList to be sorted by vpdBegOfs.
// Every time inserting an entry we should keep the order of entries.
// So this function searches for a proper insertion point from "begin" then "desc" gets inserted.
//
// For other architectures(ones that uses GCInfo{En|De}coder), we don't need any sort.
// So the argument "begin" is unused and "desc" will be inserted at the front of the list.

voidGCInfo::gcInsertVarPtrDscSplit(varPtrDsc* desc, varPtrDsc* begin)
{
#ifndef JIT32_GCENCODER
 (void)begin;
 desc->vpdNext = gcVarPtrList;
 gcVarPtrList = desc;
#else// JIT32_GCENCODER
// "desc" and "begin" must not be null
assert(desc != nullptr);
assert(begin != nullptr);

// The caller must guarantee that desc's BegOfs is equal or greater than begin's
// since we will search for insertion point from "begin"
assert(desc->vpdBegOfs >= begin->vpdBegOfs);

 varPtrDsc* varTmp = begin->vpdNext;
 varPtrDsc* varInsert = begin;

while (varTmp != nullptr && varTmp->vpdBegOfs < desc->vpdBegOfs)
 {
 varInsert = varTmp;
 varTmp = varTmp->vpdNext;
 }

// Insert point cannot be null
assert(varInsert != nullptr);

 desc->vpdNext = varInsert->vpdNext;
 varInsert->vpdNext = desc;
#endif// JIT32_GCENCODER
}

#ifdef DEBUG

voidGCInfo::gcDumpVarPtrDsc(varPtrDsc* desc)
{
constint offs = (desc->vpdVarNum & ~OFFSET_MASK);
const GCtype gcType = (desc->vpdVarNum & byref_OFFSET_FLAG) ? GCT_BYREF : GCT_GCREF;
constbool isPin = (desc->vpdVarNum & pinned_OFFSET_FLAG) != 0;

printf("[%08X] %s%s var at [%s", dspPtr(desc), GCtypeStr(gcType), isPin ? "pinned-ptr" : "",
 compiler->isFramePointerUsed() ? STR_FPBASE : STR_SPBASE);

if (offs < 0)
 {
printf("-%02XH", -offs);
 }
elseif (offs > 0)
 {
printf("+%02XH", +offs);
 }

printf("] live from %04X to %04X\n", desc->vpdBegOfs, desc->vpdEndOfs);
}

#endif// DEBUG

#endif// !defined(JIT32_GCENCODER) || defined(FEATURE_EH_FUNCLETS)

#ifdef JIT32_GCENCODER

#include"emit.h"

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

/*****************************************************************************/
// (see jit.h) #define REGEN_SHORTCUTS 0
// To Regenerate the compressed info header shortcuts, define REGEN_SHORTCUTS
// and use the following command line pipe/filter to give you the 128
// most useful encodings.
//
// find . -name regen.txt | xargs cat | grep InfoHdr | sort | uniq -c | sort -r | head -128

// (see jit.h) #define REGEN_CALLPAT 0
// To Regenerate the compressed info header shortcuts, define REGEN_CALLPAT
// and use the following command line pipe/filter to give you the 80
// most useful encodings.
//
// find . -name regen.txt | xargs cat | grep CallSite | sort | uniq -c | sort -r | head -80

#if REGEN_SHORTCUTS || REGEN_CALLPAT
static FILE* logFile = NULL;
CRITICAL_SECTION logFileLock;
#endif

#if REGEN_CALLPAT
staticvoidregenLog(unsigned codeDelta,
unsigned argMask,
unsigned regMask,
unsigned argCnt,
unsigned byrefArgMask,
unsigned byrefRegMask,
 BYTE* base,
unsigned enSize)
{
 CallPattern pat;

 pat.fld.argCnt = (argCnt < 0xff) ? argCnt : 0xff;
 pat.fld.regMask = (regMask < 0xff) ? regMask : 0xff;
 pat.fld.argMask = (argMask < 0xff) ? argMask : 0xff;
 pat.fld.codeDelta = (codeDelta < 0xff) ? codeDelta : 0xff;

if (logFile == NULL)
 {
 logFile = fopen("regen.txt", "a");
InitializeCriticalSection(&logFileLock);
 }

assert(((enSize > 0) && (enSize < 256)) && ((pat.val & 0xffffff) != 0xffffff));

EnterCriticalSection(&logFileLock);

fprintf(logFile, "CallSite( 0x%08x, 0x%02x%02x, 0x", pat.val, byrefArgMask, byrefRegMask);

while (enSize > 0)
 {
fprintf(logFile, "%02x", *base++);
 enSize--;
 }
fprintf(logFile, "),\n");
fflush(logFile);

LeaveCriticalSection(&logFileLock);
}
#endif

#if REGEN_SHORTCUTS
staticvoidregenLog(unsigned encoding, InfoHdr* header, InfoHdr* state)
{
if (logFile == NULL)
 {
 logFile = fopen("regen.txt", "a");
InitializeCriticalSection(&logFileLock);
 }

EnterCriticalSection(&logFileLock);

fprintf(logFile, "InfoHdr( %2d, %2d, %1d, %1d, %1d,"
" %1d, %1d, %1d, %1d, %1d,"
" %1d, %1d, %1d, %1d, %1d, %1d,"
" %1d, %1d, %1d,"
" %1d, %2d, %2d,"
" %2d, %2d, %2d, %2d, %2d, %2d), \n",
 state->prologSize, state->epilogSize, state->epilogCount, state->epilogAtEnd, state->ediSaved,
 state->esiSaved, state->ebxSaved, state->ebpSaved, state->ebpFrame, state->interruptible,
 state->doubleAlign, state->security, state->handlers, state->localloc, state->editNcontinue, state->varargs,
 state->profCallbacks, state->genericsContext, state->genericsContextIsMethodDesc, state->returnKind,
 state->argCount, state->frameSize,
 (state->untrackedCnt <= SET_UNTRACKED_MAX) ? state->untrackedCnt : HAS_UNTRACKED,
 (state->varPtrTableSize == 0) ? 0 : HAS_VARPTR,
 (state->gsCookieOffset == INVALID_GS_COOKIE_OFFSET) ? 0 : HAS_GS_COOKIE_OFFSET,
 (state->syncStartOffset == INVALID_SYNC_OFFSET) ? 0 : HAS_SYNC_OFFSET,
 (state->syncStartOffset == INVALID_SYNC_OFFSET) ? 0 : HAS_SYNC_OFFSET,
 (state->revPInvokeOffset == INVALID_REV_PINVOKE_OFFSET) ? 0 : HAS_REV_PINVOKE_FRAME_OFFSET);

fflush(logFile);

LeaveCriticalSection(&logFileLock);
}
#endif

/*****************************************************************************
 *
 * Given the four parameters return the index into the callPatternTable[]
 * that is used to encoding these four items. If an exact match cannot
 * found then ignore the codeDelta and search the table again for a near
 * match.
 * Returns 0..79 for an exact match or
 * (delta<<8) | (0..79) for a near match.
 * A near match will be encoded using two bytes, the first byte will
 * skip the adjustment delta that prevented an exact match and the
 * rest of the delta plus the other three items are encoded in the
 * second byte.
*/
int FASTCALL lookupCallPattern(unsigned argCnt, unsigned regMask, unsigned argMask, unsigned codeDelta)
{
if ((argCnt <= CP_MAX_ARG_CNT) && (argMask <= CP_MAX_ARG_MASK))
 {
 CallPattern pat;

 pat.fld.argCnt = argCnt;
 pat.fld.regMask = regMask; // EBP,EBX,ESI,EDI
 pat.fld.argMask = argMask;
 pat.fld.codeDelta = codeDelta;

bool codeDeltaOK = (pat.fld.codeDelta == codeDelta);
unsigned bestDelta2 = 0xff;
unsigned bestPattern = 0xff;
unsigned patval = pat.val;
assert(sizeof(CallPattern) == sizeof(unsigned));

constunsigned* curp = &callPatternTable[0];
for (unsigned inx = 0; inx < 80; inx++, curp++)
 {
unsigned curval = *curp;
if ((patval == curval) && codeDeltaOK)
return inx;

if (((patval ^ curval) & 0xffffff) == 0)
 {
unsigned delta2 = codeDelta - (curval >> 24);
if (delta2 < bestDelta2)
 {
 bestDelta2 = delta2;
 bestPattern = inx;
 }
 }
 }

if (bestPattern != 0xff)
 {
return (bestDelta2 << 8) | bestPattern;
 }
 }
return -1;
}

staticboolinitNeeded3(unsigned cur, unsigned tgt, unsigned max, unsigned* hint)
{
assert(cur != tgt);

unsigned tmp = tgt;
unsigned nib = 0;
unsigned cnt = 0;

while (tmp > max)
 {
 nib = tmp & 0x07;
 tmp >>= 3;
if (tmp == cur)
 {
 *hint = nib;
returnfalse;
 }
 cnt++;
 }

 *hint = tmp;
returntrue;
}

staticboolinitNeeded4(unsigned cur, unsigned tgt, unsigned max, unsigned* hint)
{
assert(cur != tgt);

unsigned tmp = tgt;
unsigned nib = 0;
unsigned cnt = 0;

while (tmp > max)
 {
 nib = tmp & 0x0f;
 tmp >>= 4;
if (tmp == cur)
 {
 *hint = nib;
returnfalse;
 }
 cnt++;
 }

 *hint = tmp;
returntrue;
}

staticintbigEncoding3(unsigned cur, unsigned tgt, unsigned max)
{
assert(cur != tgt);

unsigned tmp = tgt;
unsigned nib = 0;
unsigned cnt = 0;

while (tmp > max)
 {
 nib = tmp & 0x07;
 tmp >>= 3;
if (tmp == cur)
break;
 cnt++;
 }
return cnt;
}

staticintbigEncoding4(unsigned cur, unsigned tgt, unsigned max)
{
assert(cur != tgt);

unsigned tmp = tgt;
unsigned nib = 0;
unsigned cnt = 0;

while (tmp > max)
 {
 nib = tmp & 0x0f;
 tmp >>= 4;
if (tmp == cur)
break;
 cnt++;
 }
return cnt;
}

BYTE FASTCALL encodeHeaderNext(const InfoHdr& header, InfoHdr* state, BYTE& codeSet)
{
 BYTE encoding = 0xff;
 codeSet = 1; // codeSet is 1 or 2, depending on whether the returned encoding
// corresponds to InfoHdrAdjust, or InfoHdrAdjust2 enumerations.

if (state->argCount != header.argCount)
 {
// We have one-byte encodings for 0..8
if (header.argCount <= SET_ARGCOUNT_MAX)
 {
 state->argCount = header.argCount;
 encoding = SET_ARGCOUNT + header.argCount;
goto DO_RETURN;
 }
else
 {
unsigned hint;
if (initNeeded4(state->argCount, header.argCount, SET_ARGCOUNT_MAX, &hint))
 {
assert(hint <= SET_ARGCOUNT_MAX);
 state->argCount = hint;
 encoding = SET_ARGCOUNT + hint;
goto DO_RETURN;
 }
else
 {
assert(hint <= 0xf);
 state->argCount <<= 4;
 state->argCount += hint;
 encoding = NEXT_FOUR_ARGCOUNT + hint;
goto DO_RETURN;
 }
 }
 }

if (state->frameSize != header.frameSize)
 {
// We have one-byte encodings for 0..7
if (header.frameSize <= SET_FRAMESIZE_MAX)
 {
 state->frameSize = header.frameSize;
 encoding = SET_FRAMESIZE + header.frameSize;
goto DO_RETURN;
 }
else
 {
unsigned hint;
if (initNeeded4(state->frameSize, header.frameSize, SET_FRAMESIZE_MAX, &hint))
 {
assert(hint <= SET_FRAMESIZE_MAX);
 state->frameSize = hint;
 encoding = SET_FRAMESIZE + hint;
goto DO_RETURN;
 }
else
 {
assert(hint <= 0xf);
 state->frameSize <<= 4;
 state->frameSize += hint;
 encoding = NEXT_FOUR_FRAMESIZE + hint;
goto DO_RETURN;
 }
 }
 }

if ((state->epilogCount != header.epilogCount) || (state->epilogAtEnd != header.epilogAtEnd))
 {
if (header.epilogCount > SET_EPILOGCNT_MAX)
IMPL_LIMITATION("More than SET_EPILOGCNT_MAX epilogs");

 state->epilogCount = header.epilogCount;
 state->epilogAtEnd = header.epilogAtEnd;
 encoding = SET_EPILOGCNT + header.epilogCount * 2;
if (header.epilogAtEnd)
 encoding++;
goto DO_RETURN;
 }

if (state->varPtrTableSize != header.varPtrTableSize)
 {
assert(state->varPtrTableSize == 0 || state->varPtrTableSize == HAS_VARPTR);

if (state->varPtrTableSize == 0)
 {
 state->varPtrTableSize = HAS_VARPTR;
 encoding = FLIP_VAR_PTR_TABLE_SZ;
goto DO_RETURN;
 }
elseif (header.varPtrTableSize == 0)
 {
 state->varPtrTableSize = 0;
 encoding = FLIP_VAR_PTR_TABLE_SZ;
goto DO_RETURN;
 }
 }

if (state->untrackedCnt != header.untrackedCnt)
 {
assert(state->untrackedCnt <= SET_UNTRACKED_MAX || state->untrackedCnt == HAS_UNTRACKED);

// We have one-byte encodings for 0..3
if (header.untrackedCnt <= SET_UNTRACKED_MAX)
 {
 state->untrackedCnt = header.untrackedCnt;
 encoding = SET_UNTRACKED + header.untrackedCnt;
goto DO_RETURN;
 }
elseif (state->untrackedCnt != HAS_UNTRACKED)
 {
 state->untrackedCnt = HAS_UNTRACKED;
 encoding = FFFF_UNTRACKED_CNT;
goto DO_RETURN;
 }
 }

if (state->epilogSize != header.epilogSize)
 {
// We have one-byte encodings for 0..10
if (header.epilogSize <= SET_EPILOGSIZE_MAX)
 {
 state->epilogSize = header.epilogSize;
 encoding = SET_EPILOGSIZE + header.epilogSize;
goto DO_RETURN;
 }
else
 {
unsigned hint;
if (initNeeded3(state->epilogSize, header.epilogSize, SET_EPILOGSIZE_MAX, &hint))
 {
assert(hint <= SET_EPILOGSIZE_MAX);
 state->epilogSize = hint;
 encoding = SET_EPILOGSIZE + hint;
goto DO_RETURN;
 }
else
 {
assert(hint <= 0x7);
 state->epilogSize <<= 3;
 state->epilogSize += hint;
 encoding = NEXT_THREE_EPILOGSIZE + hint;
goto DO_RETURN;
 }
 }
 }

if (state->prologSize != header.prologSize)
 {
// We have one-byte encodings for 0..16
if (header.prologSize <= SET_PROLOGSIZE_MAX)
 {
 state->prologSize = header.prologSize;
 encoding = SET_PROLOGSIZE + header.prologSize;
goto DO_RETURN;
 }
else
 {
unsigned hint;
assert(SET_PROLOGSIZE_MAX > 15);
if (initNeeded3(state->prologSize, header.prologSize, 15, &hint))
 {
assert(hint <= 15);
 state->prologSize = hint;
 encoding = SET_PROLOGSIZE + hint;
goto DO_RETURN;
 }
else
 {
assert(hint <= 0x7);
 state->prologSize <<= 3;
 state->prologSize += hint;
 encoding = NEXT_THREE_PROLOGSIZE + hint;
goto DO_RETURN;
 }
 }
 }

if (state->ediSaved != header.ediSaved)
 {
 state->ediSaved = header.ediSaved;
 encoding = FLIP_EDI_SAVED;
goto DO_RETURN;
 }

if (state->esiSaved != header.esiSaved)
 {
 state->esiSaved = header.esiSaved;
 encoding = FLIP_ESI_SAVED;
goto DO_RETURN;
 }

if (state->ebxSaved != header.ebxSaved)
 {
 state->ebxSaved = header.ebxSaved;
 encoding = FLIP_EBX_SAVED;
goto DO_RETURN;
 }

if (state->ebpSaved != header.ebpSaved)
 {
 state->ebpSaved = header.ebpSaved;
 encoding = FLIP_EBP_SAVED;
goto DO_RETURN;
 }

if (state->ebpFrame != header.ebpFrame)
 {
 state->ebpFrame = header.ebpFrame;
 encoding = FLIP_EBP_FRAME;
goto DO_RETURN;
 }

if (state->interruptible != header.interruptible)
 {
 state->interruptible = header.interruptible;
 encoding = FLIP_INTERRUPTIBLE;
goto DO_RETURN;
 }

#if DOUBLE_ALIGN
if (state->doubleAlign != header.doubleAlign)
 {
 state->doubleAlign = header.doubleAlign;
 encoding = FLIP_DOUBLE_ALIGN;
goto DO_RETURN;
 }
#endif

if (state->security != header.security)
 {
 state->security = header.security;
 encoding = FLIP_SECURITY;
goto DO_RETURN;
 }

if (state->handlers != header.handlers)
 {
 state->handlers = header.handlers;
 encoding = FLIP_HANDLERS;
goto DO_RETURN;
 }

if (state->localloc != header.localloc)
 {
 state->localloc = header.localloc;
 encoding = FLIP_LOCALLOC;
goto DO_RETURN;
 }

if (state->editNcontinue != header.editNcontinue)
 {
 state->editNcontinue = header.editNcontinue;
 encoding = FLIP_EDITnCONTINUE;
goto DO_RETURN;
 }

if (state->varargs != header.varargs)
 {
 state->varargs = header.varargs;
 encoding = FLIP_VARARGS;
goto DO_RETURN;
 }

if (state->profCallbacks != header.profCallbacks)
 {
 state->profCallbacks = header.profCallbacks;
 encoding = FLIP_PROF_CALLBACKS;
goto DO_RETURN;
 }

if (state->genericsContext != header.genericsContext)
 {
 state->genericsContext = header.genericsContext;
 encoding = FLIP_HAS_GENERICS_CONTEXT;
goto DO_RETURN;
 }

if (state->genericsContextIsMethodDesc != header.genericsContextIsMethodDesc)
 {
 state->genericsContextIsMethodDesc = header.genericsContextIsMethodDesc;
 encoding = FLIP_GENERICS_CONTEXT_IS_METHODDESC;
goto DO_RETURN;
 }

if (GCInfoEncodesReturnKind() && (state->returnKind != header.returnKind))
 {
 state->returnKind = header.returnKind;
 codeSet = 2; // Two byte encoding
 encoding = header.returnKind;
_ASSERTE(encoding < SET_RET_KIND_MAX);
goto DO_RETURN;
 }

if (state->gsCookieOffset != header.gsCookieOffset)
 {
assert(state->gsCookieOffset == INVALID_GS_COOKIE_OFFSET || state->gsCookieOffset == HAS_GS_COOKIE_OFFSET);

if (state->gsCookieOffset == INVALID_GS_COOKIE_OFFSET)
 {
// header.gsCookieOffset is non-zero. We can set it
// to zero using FLIP_HAS_GS_COOKIE
 state->gsCookieOffset = HAS_GS_COOKIE_OFFSET;
 encoding = FLIP_HAS_GS_COOKIE;
goto DO_RETURN;
 }
elseif (header.gsCookieOffset == INVALID_GS_COOKIE_OFFSET)
 {
 state->gsCookieOffset = INVALID_GS_COOKIE_OFFSET;
 encoding = FLIP_HAS_GS_COOKIE;
goto DO_RETURN;
 }
 }

if (state->syncStartOffset != header.syncStartOffset)
 {
assert(state->syncStartOffset == INVALID_SYNC_OFFSET || state->syncStartOffset == HAS_SYNC_OFFSET);

if (state->syncStartOffset == INVALID_SYNC_OFFSET)
 {
// header.syncStartOffset is non-zero. We can set it
// to zero using FLIP_SYNC
 state->syncStartOffset = HAS_SYNC_OFFSET;
 encoding = FLIP_SYNC;
goto DO_RETURN;
 }
elseif (header.syncStartOffset == INVALID_SYNC_OFFSET)
 {
 state->syncStartOffset = INVALID_SYNC_OFFSET;
 encoding = FLIP_SYNC;
goto DO_RETURN;
 }
 }

if (GCInfoEncodesRevPInvokeFrame() && (state->revPInvokeOffset != header.revPInvokeOffset))
 {
assert(state->revPInvokeOffset == INVALID_REV_PINVOKE_OFFSET ||
 state->revPInvokeOffset == HAS_REV_PINVOKE_FRAME_OFFSET);

if (state->revPInvokeOffset == INVALID_REV_PINVOKE_OFFSET)
 {
// header.revPInvokeOffset is non-zero.
 state->revPInvokeOffset = HAS_REV_PINVOKE_FRAME_OFFSET;
 encoding = FLIP_REV_PINVOKE_FRAME;
goto DO_RETURN;
 }
elseif (header.revPInvokeOffset == INVALID_REV_PINVOKE_OFFSET)
 {
 state->revPInvokeOffset = INVALID_REV_PINVOKE_OFFSET;
 encoding = FLIP_REV_PINVOKE_FRAME;
goto DO_RETURN;
 }
 }

DO_RETURN:
_ASSERTE(encoding < MORE_BYTES_TO_FOLLOW);
if (!state->isHeaderMatch(header))
 encoding |= MORE_BYTES_TO_FOLLOW;