assertionprop.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 AssertionProp XX
XX XX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
*/

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

/*****************************************************************************
 *
 * Helper passed to Compiler::fgWalkTreePre() to find the Asgn node for optAddCopies()
*/

/* static */
Compiler::fgWalkResult Compiler::optAddCopiesCallback(GenTree** pTree, fgWalkData* data)
{
 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;
}

/*****************************************************************************
 *
 * Add new copies before Assertion Prop.
*/

voidCompiler::optAddCopies()
{
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(falseDEBUGARG("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
 }
}

//------------------------------------------------------------------------------
// GetAssertionDep: Retrieve the assertions on this local variable
//
// Arguments:
// lclNum - The local var id.
//
// Return Value:
// The dependent assertions (assertions using the value of the local var)
// of the local var.
//

ASSERT_TP& Compiler::GetAssertionDep(unsigned lclNum)
{
 JitExpandArray<ASSERT_TP>& dep = *optAssertionDep;
if (dep[lclNum] == nullptr)
 {
 dep[lclNum] = BitVecOps::MakeEmpty(apTraits);
 }
return dep[lclNum];
}

/*****************************************************************************
 *
 * Initialize the assertion prop bitset traits and the default bitsets.
*/

voidCompiler::optAssertionTraitsInit(AssertionIndex assertionCount)
{
 apTraits = new (this, CMK_AssertionProp) BitVecTraits(assertionCount, this);
 apFull = BitVecOps::MakeFull(apTraits);
}

/*****************************************************************************
 *
 * Initialize the assertion prop tracking logic.
*/

voidCompiler::optAssertionInit(bool isLocalProp)
{
// 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.
staticconst AssertionIndex countFunc[] = {64, 128, 256, 64};
staticconstunsigned lowerBound = 0;
staticconstunsigned upperBound = _countof(countFunc) - 1;
constunsigned 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;
}

#ifdef DEBUG
voidCompiler::optPrintAssertion(AssertionDsc* curAssertion, AssertionIndex assertionIndex /* =0 */)
{
if (curAssertion->op1.kind == O1K_EXACT_TYPE)
 {
printf("Type ");
 }
elseif (curAssertion->op1.kind == O1K_ARR_BND)
 {
printf("ArrBnds ");
 }
elseif (curAssertion->op1.kind == O1K_SUBTYPE)
 {
printf("Subtype ");
 }
elseif (curAssertion->op2.kind == O2K_LCLVAR_COPY)
 {
printf("Copy ");
 }
elseif ((curAssertion->op2.kind == O2K_CONST_INT) || (curAssertion->op2.kind == O2K_CONST_LONG) ||
 (curAssertion->op2.kind == O2K_CONST_DOUBLE))
 {
printf("Constant ");
 }
elseif (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);
 }
 }
elseif (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("]");
 }
elseif (curAssertion->op1.kind == O1K_BOUND_OPER_BND)
 {
printf("Oper_Bnd");
 vnStore->vnDump(this, curAssertion->op1.vn);
 }
elseif (curAssertion->op1.kind == O1K_BOUND_LOOP_BND)
 {
printf("Loop_Bnd");
 vnStore->vnDump(this, curAssertion->op1.vn);
 }
elseif (curAssertion->op1.kind == O1K_CONSTANT_LOOP_BND)
 {
printf("Const_Loop_Bnd");
 vnStore->vnDump(this, curAssertion->op1.vn);
 }
elseif (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 ");
 }
elseif (curAssertion->assertionKind == OAK_EQUAL)
 {
if (curAssertion->op1.kind == O1K_LCLVAR)
 {
printf(" == ");
 }
else
 {
printf(" is ");
 }
 }
elseif (curAssertion->assertionKind == OAK_NO_THROW)
 {
printf(" in range ");
 }
elseif (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);
 }
elseif (curAssertion->op1.kind == O1K_SUBTYPE)
 {
printf("MT(%08X)", dspPtr(curAssertion->op2.u1.iconVal));
assert(curAssertion->op2.u1.iconFlags != 0);
 }
elseif (curAssertion->op1.kind == O1K_BOUND_OPER_BND)
 {
assert(!optLocalAssertionProp);
 vnStore->vnDump(this, curAssertion->op2.vn);
 }
elseif (curAssertion->op1.kind == O1K_BOUND_LOOP_BND)
 {
assert(!optLocalAssertionProp);
 vnStore->vnDump(this, curAssertion->op2.vn);
 }
elseif (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");
}
#endif// DEBUG

/******************************************************************************
 *
 * Helper to retrieve the "assertIndex" assertion. Note that assertIndex 0
 * is NO_ASSERTION_INDEX and "optAssertionCount" is the last valid index.
 *
*/
Compiler::AssertionDsc* Compiler::optGetAssertion(AssertionIndex assertIndex)
{
assert(NO_ASSERTION_INDEX == 0);
assert(assertIndex != NO_ASSERTION_INDEX);
assert(assertIndex <= optAssertionCount);
 AssertionDsc* assertion = &optAssertionTabPrivate[assertIndex - 1];
#ifdef DEBUG
optDebugCheckAssertion(assertion);
#endif

return assertion;
}

//------------------------------------------------------------------------
// optCreateAssertion: Create an (op1 assertionKind op2) assertion.
//
// Arguments:
// op1 - the first assertion operand
// op2 - the second assertion operand
// assertionKind - the assertion kind
// helperCallArgs - when true this indicates that the assertion operands
// are the arguments of a type cast helper call such as
// CORINFO_HELP_ISINSTANCEOFCLASS
// Return Value:
// The new assertion index or NO_ASSERTION_INDEX if a new assertion
// was not created.
//
// Notes:
// Assertion creation may fail either because the provided assertion
// operands aren't supported or because the assertion table is full.
//
AssertionIndex Compiler::optCreateAssertion(GenTree* op1,
 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();
 }
elseif (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];
 }
elseif (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?
//
elseif (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