{

GenTree* tree = *pTree;

if (tree->OperIs(GT_ASG))

{

GenTree* op1 = tree->AsOp()->gtOp1;

Compiler* comp = data->compiler;

if ((op1->gtOper == GT_LCL_VAR) && (op1->AsLclVarCommon()->GetLclNum() == comp->optAddCopyLclNum))

{

comp->optAddCopyAsgnNode = tree;

return WALK_ABORT;

}

}

return WALK_CONTINUE;

{

unsigned lclNum;

LclVarDsc* varDsc;

#ifdef DEBUG

if (verbose)

{

printf("\n*************** In optAddCopies()\n\n");

}

if (verboseTrees)

{

printf("Blocks/Trees at start of phase\n");

fgDispBasicBlocks(true);

}

#endif

// Don't add any copies if we have reached the tracking limit.

if (lvaHaveManyLocals())

{

return;

}

for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)

{

var_types typ = varDsc->TypeGet();

// We only add copies for non temp local variables

// that have a single def and that can possibly be enregistered

if (varDsc->lvIsTemp || !varDsc->lvSingleDef || !varTypeIsEnregisterable(typ))

{

continue;

}

/* For lvNormalizeOnLoad(), we need to add a cast to the copy-assignment

like "copyLclNum = int(varDsc)" and optAssertionGen() only

tracks simple assignments. The same goes for lvNormalizedOnStore as

the cast is generated in fgMorphSmpOpAsg. This boils down to not having

a copy until optAssertionGen handles this*/

if (varDsc->lvNormalizeOnLoad() || varDsc->lvNormalizeOnStore())

{

continue;

}

if (varTypeIsSmall(varDsc->TypeGet()) || typ == TYP_BOOL)

{

continue;

}

// If locals must be initialized to zero, that initialization counts as a second definition.

// VB in particular allows usage of variables not explicitly initialized.

// Note that this effectively disables this optimization for all local variables

// as C# sets InitLocals all the time starting in Whidbey.

if (!varDsc->lvIsParam && info.compInitMem)

{

continue;

}

// On x86 we may want to add a copy for an incoming double parameter

// because we can ensure that the copy we make is double aligned

// where as we can never ensure the alignment of an incoming double parameter

//

// On all other platforms we will never need to make a copy

// for an incoming double parameter

bool isFloatParam = false;

#ifdef _TARGET_X86_

isFloatParam = varDsc->lvIsParam && varTypeIsFloating(typ);

#endif

if (!isFloatParam && !varDsc->lvVolatileHint)

{

continue;

}

// We don't want to add a copy for a variable that is part of a struct

if (varDsc->lvIsStructField)

{

continue;

}

// We require that the weighted ref count be significant.

if (varDsc->lvRefCntWtd() <= (BB_LOOP_WEIGHT * BB_UNITY_WEIGHT / 2))

{

continue;

}

// For parameters, we only want to add a copy for the heavier-than-average

// uses instead of adding a copy to cover every single use.

// 'paramImportantUseDom' is the set of blocks that dominate the

// heavier-than-average uses of a parameter.

// Initial value is all blocks.

BlockSet paramImportantUseDom(BlockSetOps::MakeFull(this));

// This will be threshold for determining heavier-than-average uses

unsigned paramAvgWtdRefDiv2 = (varDsc->lvRefCntWtd() + varDsc->lvRefCnt() / 2) / (varDsc->lvRefCnt() * 2);

bool paramFoundImportantUse = false;

#ifdef DEBUG

if (verbose)

{

printf("Trying to add a copy for V%02u %s, avg_wtd = %s\n", lclNum,

varDsc->lvIsParam ? "an arg" : "a local", refCntWtd2str(paramAvgWtdRefDiv2));

}

#endif

//

// We must have a ref in a block that is dominated only by the entry block

//

if (BlockSetOps::MayBeUninit(varDsc->lvRefBlks))

{

// No references

continue;

}

bool isDominatedByFirstBB = false;

BlockSetOps::Iter iter(this, varDsc->lvRefBlks);

unsigned bbNum = 0;

while (iter.NextElem(&bbNum))

{

/* Find the block 'bbNum' */

BasicBlock* block = fgFirstBB;

while (block && (block->bbNum != bbNum))

{

block = block->bbNext;

}

noway_assert(block && (block->bbNum == bbNum));

bool importantUseInBlock = (varDsc->lvIsParam) && (block->getBBWeight(this) > paramAvgWtdRefDiv2);

bool isPreHeaderBlock = ((block->bbFlags & BBF_LOOP_PREHEADER) != 0);

BlockSet blockDom(BlockSetOps::UninitVal());

BlockSet blockDomSub0(BlockSetOps::UninitVal());

if (block->bbIDom == nullptr && isPreHeaderBlock)

{

// Loop Preheader blocks that we insert will have a bbDom set that is nullptr

// but we can instead use the bNext successor block's dominator information

noway_assert(block->bbNext != nullptr);

BlockSetOps::AssignNoCopy(this, blockDom, fgGetDominatorSet(block->bbNext));

}

else

{

BlockSetOps::AssignNoCopy(this, blockDom, fgGetDominatorSet(block));

}

if (!BlockSetOps::IsEmpty(this, blockDom))

{

BlockSetOps::Assign(this, blockDomSub0, blockDom);

if (isPreHeaderBlock)

{

// We must clear bbNext block number from the dominator set

BlockSetOps::RemoveElemD(this, blockDomSub0, block->bbNext->bbNum);

}

/* Is this block dominated by fgFirstBB? */

if (BlockSetOps::IsMember(this, blockDomSub0, fgFirstBB->bbNum))

{

isDominatedByFirstBB = true;

}

}

#ifdef DEBUG

if (verbose)

{

printf(" Referenced in " FMT_BB ", bbWeight is %s", bbNum,

refCntWtd2str(block->getBBWeight(this)));

if (isDominatedByFirstBB)

{

printf(", which is dominated by BB01");

}

if (importantUseInBlock)

{

printf(", ImportantUse");

}

printf("\n");

}

#endif

/* If this is a heavier-than-average block, then track which

blocks dominate this use of the parameter. */

if (importantUseInBlock)

{

paramFoundImportantUse = true;

BlockSetOps::IntersectionD(this, paramImportantUseDom,

blockDomSub0); // Clear blocks that do not dominate

}

}

// We should have found at least one heavier-than-averageDiv2 block.

if (varDsc->lvIsParam)

{

if (!paramFoundImportantUse)

{

continue;

}

}

// For us to add a new copy:

// we require that we have a floating point parameter

// or a lvVolatile variable that is always reached from the first BB

// and we have at least one block available in paramImportantUseDom

//

bool doCopy = (isFloatParam || (isDominatedByFirstBB && varDsc->lvVolatileHint)) &&

!BlockSetOps::IsEmpty(this, paramImportantUseDom);

// Under stress mode we expand the number of candidates

// to include parameters of any type

// or any variable that is always reached from the first BB

//

if (compStressCompile(STRESS_GENERIC_VARN, 30))

{

// Ensure that we preserve the invariants required by the subsequent code.

if (varDsc->lvIsParam || isDominatedByFirstBB)

{

doCopy = true;

}

}

if (!doCopy)

{

continue;

}

Statement* stmt;

unsigned copyLclNum = lvaGrabTemp(false DEBUGARG("optAddCopies"));

// Because lvaGrabTemp may have reallocated the lvaTable, ensure varDsc

// is still in sync with lvaTable[lclNum];

varDsc = &lvaTable[lclNum];

// Set lvType on the new Temp Lcl Var

lvaTable[copyLclNum].lvType = typ;

#ifdef DEBUG

if (verbose)

{

printf("\n Finding the best place to insert the assignment V%02i=V%02i\n", copyLclNum, lclNum);

}

#endif

if (varDsc->lvIsParam)

{

noway_assert(varDsc->lvDefStmt == nullptr || varDsc->lvIsStructField);

// Create a new copy assignment tree

GenTree* copyAsgn = gtNewTempAssign(copyLclNum, gtNewLclvNode(lclNum, typ));

/* Find the best block to insert the new assignment */

/* We will choose the lowest weighted block, and within */

/* those block, the highest numbered block which */

/* dominates all the uses of the local variable */

/* Our default is to use the first block */

BasicBlock* bestBlock = fgFirstBB;

unsigned bestWeight = bestBlock->getBBWeight(this);

BasicBlock* block = bestBlock;

#ifdef DEBUG

if (verbose)

{

printf(" Starting at " FMT_BB ", bbWeight is %s", block->bbNum,

refCntWtd2str(block->getBBWeight(this)));

printf(", bestWeight is %s\n", refCntWtd2str(bestWeight));

}

#endif

/* We have already calculated paramImportantUseDom above. */

BlockSetOps::Iter iter(this, paramImportantUseDom);

unsigned bbNum = 0;

while (iter.NextElem(&bbNum))

{

/* Advance block to point to 'bbNum' */

/* This assumes that the iterator returns block number is increasing lexical order. */

while (block && (block->bbNum != bbNum))

{

block = block->bbNext;

}

noway_assert(block && (block->bbNum == bbNum));

#ifdef DEBUG

if (verbose)

{

printf(" Considering " FMT_BB ", bbWeight is %s", block->bbNum,

refCntWtd2str(block->getBBWeight(this)));

printf(", bestWeight is %s\n", refCntWtd2str(bestWeight));

}

#endif

// Does this block have a smaller bbWeight value?

if (block->getBBWeight(this) > bestWeight)

{

#ifdef DEBUG

if (verbose)

{

printf("bbWeight too high\n");

}

#endif

continue;

}

// Don't use blocks that are exception handlers because

// inserting a new first statement will interface with

// the CATCHARG

if (handlerGetsXcptnObj(block->bbCatchTyp))

{

#ifdef DEBUG

if (verbose)

{

printf("Catch block\n");

}

#endif

continue;

}

// Don't use the BBJ_ALWAYS block marked with BBF_KEEP_BBJ_ALWAYS. These

// are used by EH code. The JIT can not generate code for such a block.

if (block->bbFlags & BBF_KEEP_BBJ_ALWAYS)

{

#if defined(FEATURE_EH_FUNCLETS)

// With funclets, this is only used for BBJ_CALLFINALLY/BBJ_ALWAYS pairs. For x86, it is also used

// as the "final step" block for leaving finallys.

assert((block->bbPrev != nullptr) && block->bbPrev->isBBCallAlwaysPair());

#endif // FEATURE_EH_FUNCLETS

#ifdef DEBUG

if (verbose)

{

printf("Internal EH BBJ_ALWAYS block\n");

}

#endif

continue;

}

// This block will be the new candidate for the insert point

// for the new assignment

CLANG_FORMAT_COMMENT_ANCHOR;

#ifdef DEBUG

if (verbose)

{

printf("new bestBlock\n");

}

#endif

bestBlock = block;

bestWeight = block->getBBWeight(this);

}

// If there is a use of the variable in this block

// then we insert the assignment at the beginning

// otherwise we insert the statement at the end

CLANG_FORMAT_COMMENT_ANCHOR;

#ifdef DEBUG

if (verbose)

{

printf(" Insert copy at the %s of " FMT_BB "\n",

(BlockSetOps::IsEmpty(this, paramImportantUseDom) ||

BlockSetOps::IsMember(this, varDsc->lvRefBlks, bestBlock->bbNum))

? "start"

: "end",

bestBlock->bbNum);

}

#endif

if (BlockSetOps::IsEmpty(this, paramImportantUseDom) ||

BlockSetOps::IsMember(this, varDsc->lvRefBlks, bestBlock->bbNum))

{

stmt = fgNewStmtAtBeg(bestBlock, copyAsgn);

}

else

{

stmt = fgNewStmtNearEnd(bestBlock, copyAsgn);

}

}

else

{

noway_assert(varDsc->lvDefStmt != nullptr);

/* Locate the assignment to varDsc in the lvDefStmt */

stmt = varDsc->lvDefStmt;

optAddCopyLclNum = lclNum; // in

optAddCopyAsgnNode = nullptr; // out

fgWalkTreePre(stmt->GetRootNodePointer(), Compiler::optAddCopiesCallback, (void*)this, false);

noway_assert(optAddCopyAsgnNode);

GenTree* tree = optAddCopyAsgnNode;

GenTree* op1 = tree->AsOp()->gtOp1;

noway_assert(tree && op1 && tree->OperIs(GT_ASG) && (op1->gtOper == GT_LCL_VAR) &&

(op1->AsLclVarCommon()->GetLclNum() == lclNum));

/* Assign the old expression into the new temp */

GenTree* newAsgn = gtNewTempAssign(copyLclNum, tree->AsOp()->gtOp2);

/* Copy the new temp to op1 */

GenTree* copyAsgn = gtNewAssignNode(op1, gtNewLclvNode(copyLclNum, typ));

/* Change the tree to a GT_COMMA with the two assignments as child nodes */

tree->gtBashToNOP();

tree->ChangeOper(GT_COMMA);

tree->AsOp()->gtOp1 = newAsgn;

tree->AsOp()->gtOp2 = copyAsgn;

tree->gtFlags |= (newAsgn->gtFlags & GTF_ALL_EFFECT);

tree->gtFlags |= (copyAsgn->gtFlags & GTF_ALL_EFFECT);

}

#ifdef DEBUG

if (verbose)

{

printf("\nIntroducing a new copy for V%02u\n", lclNum);

gtDispTree(stmt->GetRootNode());

printf("\n");

}

#endif

}

{

apTraits = new (this, CMK_AssertionProp) BitVecTraits(assertionCount, this);

apFull = BitVecOps::MakeFull(apTraits);

{

// Use a function countFunc to determine a proper maximum assertion count for the

// method being compiled. The function is linear to the IL size for small and

// moderate methods. For large methods, considering throughput impact, we track no

// more than 64 assertions.

// Note this tracks at most only 256 assertions.

static const AssertionIndex countFunc[] = {64, 128, 256, 64};

static const unsigned lowerBound = 0;

static const unsigned upperBound = _countof(countFunc) - 1;

const unsigned codeSize = info.compILCodeSize / 512;

optMaxAssertionCount = countFunc[isLocalProp ? lowerBound : min(upperBound, codeSize)];

optLocalAssertionProp = isLocalProp;

optAssertionTabPrivate = new (this, CMK_AssertionProp) AssertionDsc[optMaxAssertionCount];

optComplementaryAssertionMap =

new (this, CMK_AssertionProp) AssertionIndex[optMaxAssertionCount + 1](); // zero-inited (NO_ASSERTION_INDEX)

assert(NO_ASSERTION_INDEX == 0);

if (!isLocalProp)

{

optValueNumToAsserts = new (getAllocator()) ValueNumToAssertsMap(getAllocator());

}

if (optAssertionDep == nullptr)

{

optAssertionDep = new (this, CMK_AssertionProp) JitExpandArray<ASSERT_TP>(getAllocator(), max(1, lvaCount));

}

optAssertionTraitsInit(optMaxAssertionCount);

optAssertionCount = 0;

optAssertionPropagated = false;

bbJtrueAssertionOut = nullptr;

{

if (curAssertion->op1.kind == O1K_EXACT_TYPE)

{

printf("Type ");

}

else if (curAssertion->op1.kind == O1K_ARR_BND)

{

printf("ArrBnds ");

}

else if (curAssertion->op1.kind == O1K_SUBTYPE)

{

printf("Subtype ");

}

else if (curAssertion->op2.kind == O2K_LCLVAR_COPY)

{

printf("Copy ");

}

else if ((curAssertion->op2.kind == O2K_CONST_INT) || (curAssertion->op2.kind == O2K_CONST_LONG) ||

(curAssertion->op2.kind == O2K_CONST_DOUBLE))

{

printf("Constant ");

}

else if (curAssertion->op2.kind == O2K_SUBRANGE)

{

printf("Subrange ");

}

else

{

printf("?assertion classification? ");

}

printf("Assertion: ");

if (!optLocalAssertionProp)

{

printf("(%d, %d) ", curAssertion->op1.vn, curAssertion->op2.vn);

}

if (!optLocalAssertionProp)

{

printf("(" FMT_VN "," FMT_VN ") ", curAssertion->op1.vn, curAssertion->op2.vn);

}

if ((curAssertion->op1.kind == O1K_LCLVAR) || (curAssertion->op1.kind == O1K_EXACT_TYPE) ||

(curAssertion->op1.kind == O1K_SUBTYPE))

{

printf("V%02u", curAssertion->op1.lcl.lclNum);

if (curAssertion->op1.lcl.ssaNum != SsaConfig::RESERVED_SSA_NUM)

{

printf(".%02u", curAssertion->op1.lcl.ssaNum);

}

}

else if (curAssertion->op1.kind == O1K_ARR_BND)

{

printf("[idx:");

vnStore->vnDump(this, curAssertion->op1.bnd.vnIdx);

printf(";len:");

vnStore->vnDump(this, curAssertion->op1.bnd.vnLen);

printf("]");

}

else if (curAssertion->op1.kind == O1K_BOUND_OPER_BND)

{

printf("Oper_Bnd");

vnStore->vnDump(this, curAssertion->op1.vn);

}

else if (curAssertion->op1.kind == O1K_BOUND_LOOP_BND)

{

printf("Loop_Bnd");

vnStore->vnDump(this, curAssertion->op1.vn);

}

else if (curAssertion->op1.kind == O1K_CONSTANT_LOOP_BND)

{

printf("Const_Loop_Bnd");

vnStore->vnDump(this, curAssertion->op1.vn);

}

else if (curAssertion->op1.kind == O1K_VALUE_NUMBER)

{

printf("Value_Number");

vnStore->vnDump(this, curAssertion->op1.vn);

}

else

{

printf("?op1.kind?");

}

if (curAssertion->assertionKind == OAK_SUBRANGE)

{

printf(" in ");

}

else if (curAssertion->assertionKind == OAK_EQUAL)

{

if (curAssertion->op1.kind == O1K_LCLVAR)

{

printf(" == ");

}

else

{

printf(" is ");

}

}

else if (curAssertion->assertionKind == OAK_NO_THROW)

{

printf(" in range ");

}

else if (curAssertion->assertionKind == OAK_NOT_EQUAL)

{

if (curAssertion->op1.kind == O1K_LCLVAR)

{

printf(" != ");

}

else

{

printf(" is not ");

}

}

else

{

printf(" ?assertionKind? ");

}

if (curAssertion->op1.kind != O1K_ARR_BND)

{

switch (curAssertion->op2.kind)

{

case O2K_LCLVAR_COPY:

printf("V%02u", curAssertion->op2.lcl.lclNum);

if (curAssertion->op1.lcl.ssaNum != SsaConfig::RESERVED_SSA_NUM)

{

printf(".%02u", curAssertion->op1.lcl.ssaNum);

}

break;

case O2K_CONST_INT:

case O2K_IND_CNS_INT:

if (curAssertion->op1.kind == O1K_EXACT_TYPE)

{

printf("Exact Type MT(%08X)", dspPtr(curAssertion->op2.u1.iconVal));

assert(curAssertion->op2.u1.iconFlags != 0);

}

else if (curAssertion->op1.kind == O1K_SUBTYPE)

{

printf("MT(%08X)", dspPtr(curAssertion->op2.u1.iconVal));

assert(curAssertion->op2.u1.iconFlags != 0);

}

else if (curAssertion->op1.kind == O1K_BOUND_OPER_BND)

{

assert(!optLocalAssertionProp);

vnStore->vnDump(this, curAssertion->op2.vn);

}

else if (curAssertion->op1.kind == O1K_BOUND_LOOP_BND)

{

assert(!optLocalAssertionProp);

vnStore->vnDump(this, curAssertion->op2.vn);

}

else if (curAssertion->op1.kind == O1K_CONSTANT_LOOP_BND)

{

assert(!optLocalAssertionProp);

vnStore->vnDump(this, curAssertion->op2.vn);

}

else

{

var_types op1Type;

if (curAssertion->op1.kind == O1K_VALUE_NUMBER)

{

op1Type = vnStore->TypeOfVN(curAssertion->op1.vn);

}

else

{

unsigned lclNum = curAssertion->op1.lcl.lclNum;

assert(lclNum < lvaCount);

LclVarDsc* varDsc = lvaTable + lclNum;

op1Type = varDsc->lvType;

}

if (op1Type == TYP_REF)

{

assert(curAssertion->op2.u1.iconVal == 0);

printf("null");

}

else

{

if ((curAssertion->op2.u1.iconFlags & GTF_ICON_HDL_MASK) != 0)

{

printf("[%08p]", dspPtr(curAssertion->op2.u1.iconVal));

}

else

{

printf("%d", curAssertion->op2.u1.iconVal);

}

}

}

break;

case O2K_CONST_LONG:

printf("0x%016llx", curAssertion->op2.lconVal);

break;

case O2K_CONST_DOUBLE:

if (*((__int64*)&curAssertion->op2.dconVal) == (__int64)I64(0x8000000000000000))

{

printf("-0.00000");

}

else

{

printf("%#lg", curAssertion->op2.dconVal);

}

break;

case O2K_SUBRANGE:

printf("[%d..%d]", curAssertion->op2.u2.loBound, curAssertion->op2.u2.hiBound);

break;

default:

printf("?op2.kind?");

break;

}

}

if (assertionIndex > 0)

{

printf(" index=#%02u, mask=", assertionIndex);

printf("%s", BitVecOps::ToString(apTraits, BitVecOps::MakeSingleton(apTraits, assertionIndex - 1)));

}

printf("\n");

GenTree* op2,

optAssertionKind assertionKind,

bool helperCallArgs)

{

assert((op1 != nullptr) && !op1->OperIs(GT_LIST));

assert((op2 == nullptr) || !op2->OperIs(GT_LIST));

assert(!helperCallArgs || (op2 != nullptr));

AssertionDsc assertion;

memset(&assertion, 0, sizeof(AssertionDsc));

assert(assertion.assertionKind == OAK_INVALID);

var_types toType;

if (op1->gtOper == GT_ARR_BOUNDS_CHECK)

{

if (assertionKind == OAK_NO_THROW)

{

GenTreeBoundsChk* arrBndsChk = op1->AsBoundsChk();

assertion.assertionKind = assertionKind;

assertion.op1.kind = O1K_ARR_BND;

assertion.op1.bnd.vnIdx = vnStore->VNConservativeNormalValue(arrBndsChk->gtIndex->gtVNPair);

assertion.op1.bnd.vnLen = vnStore->VNConservativeNormalValue(arrBndsChk->gtArrLen->gtVNPair);

goto DONE_ASSERTION;

}

}

//

// Are we trying to make a non-null assertion?

//

if (op2 == nullptr)

{

//

// Must an OAK_NOT_EQUAL assertion

//

noway_assert(assertionKind == OAK_NOT_EQUAL);

//

// Set op1 to the instance pointer of the indirection

//

ssize_t offset = 0;

while ((op1->gtOper == GT_ADD) && (op1->gtType == TYP_BYREF))

{

if (op1->gtGetOp2()->IsCnsIntOrI())

{

offset += op1->gtGetOp2()->AsIntCon()->gtIconVal;

op1 = op1->gtGetOp1();

}

else if (op1->gtGetOp1()->IsCnsIntOrI())

{

offset += op1->gtGetOp1()->AsIntCon()->gtIconVal;

op1 = op1->gtGetOp2();

}

else

{

break;

}

}

if (fgIsBigOffset(offset) || op1->gtOper != GT_LCL_VAR)

{

goto DONE_ASSERTION; // Don't make an assertion

}

unsigned lclNum = op1->AsLclVarCommon()->GetLclNum();

noway_assert(lclNum < lvaCount);

LclVarDsc* lclVar = &lvaTable[lclNum];

ValueNum vn;

//

// We only perform null-checks on GC refs

// so only make non-null assertions about GC refs or byrefs if we can't determine

// the corresponding ref.

//

if (lclVar->TypeGet() != TYP_REF)

{

if (optLocalAssertionProp || (lclVar->TypeGet() != TYP_BYREF))

{

goto DONE_ASSERTION; // Don't make an assertion

}

vn = vnStore->VNConservativeNormalValue(op1->gtVNPair);

VNFuncApp funcAttr;

// Try to get value number corresponding to the GC ref of the indirection

while (vnStore->GetVNFunc(vn, &funcAttr) && (funcAttr.m_func == (VNFunc)GT_ADD) &&

(vnStore->TypeOfVN(vn) == TYP_BYREF))

{

if (vnStore->IsVNConstant(funcAttr.m_args[1]) &&

varTypeIsIntegral(vnStore->TypeOfVN(funcAttr.m_args[1])))

{

offset += vnStore->CoercedConstantValue<ssize_t>(funcAttr.m_args[1]);

vn = funcAttr.m_args[0];

}

else if (vnStore->IsVNConstant(funcAttr.m_args[0]) &&

varTypeIsIntegral(vnStore->TypeOfVN(funcAttr.m_args[0])))

{

offset += vnStore->CoercedConstantValue<ssize_t>(funcAttr.m_args[0]);

vn = funcAttr.m_args[1];

}

else

{

break;

}

}

if (fgIsBigOffset(offset))

{

goto DONE_ASSERTION; // Don't make an assertion

}

assertion.op1.kind = O1K_VALUE_NUMBER;

}

else

{

// If the local variable has its address exposed then bail

if (lclVar->lvAddrExposed)

{

goto DONE_ASSERTION; // Don't make an assertion

}

assertion.op1.kind = O1K_LCLVAR;

assertion.op1.lcl.lclNum = lclNum;

assertion.op1.lcl.ssaNum = op1->AsLclVarCommon()->GetSsaNum();

vn = vnStore->VNConservativeNormalValue(op1->gtVNPair);

}

assertion.op1.vn = vn;

assertion.assertionKind = assertionKind;

assertion.op2.kind = O2K_CONST_INT;

assertion.op2.vn = ValueNumStore::VNForNull();

assertion.op2.u1.iconVal = 0;

assertion.op2.u1.iconFlags = 0;

#ifdef _TARGET_64BIT_

assertion.op2.u1.iconFlags |= 1; // Signify that this is really TYP_LONG

#endif // _TARGET_64BIT_

}

//

// Are we making an assertion about a local variable?

//

else if (op1->gtOper == GT_LCL_VAR)

{

unsigned lclNum = op1->AsLclVarCommon()->GetLclNum();

noway_assert(lclNum < lvaCount);

LclVarDsc* lclVar = &lvaTable[lclNum];

// If the local variable has its address exposed then bail

if (lclVar->lvAddrExposed)

{

goto DONE_ASSERTION; // Don't make an assertion

}

if (helperCallArgs)

{

//

// Must either be an OAK_EQUAL or an OAK_NOT_EQUAL assertion

//

if ((assertionKind != OAK_EQUAL) && (assertionKind != OAK_NOT_EQUAL))

{

goto DONE_ASSERTION; // Don't make an assertion

}

if (op2->gtOper == GT_IND)

{

op2 = op2->AsOp()->gtOp1;

assertion.op2.kind = O2K_IND_CNS_INT;

}

else

{

assertion.op2.kind = O2K_CONST_INT;

}

if (op2->gtOper != GT_CNS_INT)

{

goto DONE_ASSERTION; // Don't make an assertion