}
// Compute the data flow values for all tracked expressions
// IN and OUT never change for the initial basic block B1
- BitVecOps::OldStyleClearD(apTraits, fgFirstBB->bbAssertionIn);
+ BitVecOps::ClearD(apTraits, fgFirstBB->bbAssertionIn);
return jumpDestOut;
}
// be copied into the lhs.
static void AssignNoCopy(Env env, BitSetType& lhs, BitSetValueArgType rhs);
- // Destructively set "bs" to be the empty set. This method is unique, in that it does *not*
- // require "bs" to be a bitset of the current epoch. It ensures that it is after, however.
- // (If the representation is indirect, this requires allocating a new, empty representation.
- // If this is a performance issue, we could provide a new version of OldStyleClearD that assumes/asserts
- // that the rep is for the current epoch -- this would be useful if a given bitset were repeatedly
- // cleared within an epoch.)
- // TODO #11263: delete it.
- static void OldStyleClearD(Env env, BitSetType& bs);
-
// Destructively set "bs" to be the empty set.
static void ClearD(Env env, BitSetType& bs);
BitSetTraits::GetOpCounter(env)->RecordOp(BitSetSupport::BSOP_AssignNocopy);
BSO::AssignNoCopy(env, lhs, rhs);
}
- static void OldStyleClearD(Env env, BitSetType& bs)
- {
- BitSetTraits::GetOpCounter(env)->RecordOp(BitSetSupport::BSOP_OldStyleClearD);
- BSO::OldStyleClearD(env, bs);
- }
static void ClearD(Env env, BitSetType& bs)
{
BitSetTraits::GetOpCounter(env)->RecordOp(BitSetSupport::BSOP_ClearD);
static void DiffDLong(Env env, BitSetShortLongRep& bs1, BitSetShortLongRep bs2);
static void AddElemDLong(Env env, BitSetShortLongRep& bs, unsigned i);
static void RemoveElemDLong(Env env, BitSetShortLongRep& bs, unsigned i);
- static void OldStyleClearDLong(Env env, BitSetShortLongRep& bs);
static void ClearDLong(Env env, BitSetShortLongRep& bs);
static BitSetShortLongRep MakeUninitArrayBits(Env env);
static BitSetShortLongRep MakeEmptyArrayBits(Env env);
lhs = rhs;
}
- static void OldStyleClearD(Env env, BitSetShortLongRep& bs)
- {
- if (IsShort(env))
- {
- bs = (BitSetShortLongRep) nullptr;
- }
- else
- {
- assert(bs != UninitVal());
- OldStyleClearDLong(env, bs);
- }
- }
-
static void ClearD(Env env, BitSetShortLongRep& bs)
{
if (IsShort(env))
void BitSetOps</*BitSetType*/ BitSetShortLongRep,
/*Brand*/ BSShortLong,
/*Env*/ Env,
- /*BitSetTraits*/ BitSetTraits>::OldStyleClearDLong(Env env, BitSetShortLongRep& bs)
-{
- assert(!IsShort(env));
- // Recall that OldStyleClearD does *not* require "bs" to be of the current epoch.
- // Therefore, we must allocate a new representation.
- bs = MakeEmptyArrayBits(env);
-}
-
-template <typename Env, typename BitSetTraits>
-void BitSetOps</*BitSetType*/ BitSetShortLongRep,
- /*Brand*/ BSShortLong,
- /*Env*/ Env,
/*BitSetTraits*/ BitSetTraits>::ClearDLong(Env env, BitSetShortLongRep& bs)
{
assert(!IsShort(env));
lhs = rhs;
}
- static void OldStyleClearD(Env env, UINT64& bs)
- {
- bs = 0;
- }
-
static void ClearD(Env env, UINT64& bs)
{
bs = 0;
return res;
}
- inline void OldStyleClearD(Env env)
- {
- // Recall that OldStyleClearD does *not* require "*this" to be of the current epoch.
- Uint64BitSetOps::OldStyleClearD(env, m_bits);
-#ifdef DEBUG
- // But it updates it to of the current epoch.
- m_epoch = BitSetTraits::GetEpoch(env);
-#endif
- }
-
inline void ClearD(Env env)
{
assert(m_epoch == BitSetTraits::GetEpoch(env));
lhs = rhs;
}
- static void OldStyleClearD(Env env, BST& bs)
- {
- bs.OldStyleClearD(env);
- }
-
static void ClearD(Env env, BST& bs)
{
bs.ClearD(env);
VarSetOps::Assign(this, compCurLife, block->bbLiveIn);
for (GenTreePtr stmt = block->bbTreeList; stmt; stmt = stmt->gtNext)
{
- VarSetOps::OldStyleClearD(this, optCopyPropKillSet);
+ VarSetOps::ClearD(this, optCopyPropKillSet);
// Walk the tree to find if any local variable can be replaced with current live definitions.
for (GenTreePtr tree = stmt->gtStmt.gtStmtList; tree; tree = tree->gtNext)
/* Nothing is live on entry to the prolog */
// These were initialized to Empty at the start of compilation.
- VarSetOps::OldStyleClearD(emitComp, emitInitGCrefVars);
- VarSetOps::OldStyleClearD(emitComp, emitPrevGCrefVars);
+ VarSetOps::ClearD(emitComp, emitInitGCrefVars);
+ VarSetOps::ClearD(emitComp, emitPrevGCrefVars);
emitInitGCrefRegs = RBM_NONE;
emitPrevGCrefRegs = RBM_NONE;
emitInitByrefRegs = RBM_NONE;
/* Assume no live GC ref variables on entry */
- VarSetOps::OldStyleClearD(emitComp, emitThisGCrefVars); // This is initialized to Empty at the start of codegen.
+ VarSetOps::ClearD(emitComp, emitThisGCrefVars); // This is initialized to Empty at the start of codegen.
emitThisGCrefRegs = emitThisByrefRegs = RBM_NONE;
emitThisGCrefVset = true;
if (fgDomsComputed && block->bbNum > fgDomBBcount)
{
BlockSetOps::Assign(this, block->bbReach, bNext->bbReach);
- BlockSetOps::OldStyleClearD(this, bNext->bbReach);
+ BlockSetOps::ClearD(this, bNext->bbReach);
block->bbIDom = bNext->bbIDom;
bNext->bbIDom = nullptr;
while (iter.NextElem(&varNum))
{
// We'll need this for one of the calls...
- VarSetOps::OldStyleClearD(this, varAsSet);
+ VarSetOps::ClearD(this, varAsSet);
VarSetOps::AddElemD(this, varAsSet, varNum);
// If this varBit and lastUse?
/* Zero the variable/register interference graph */
for (unsigned i = 0; i < REG_COUNT; i++)
{
- VarSetOps::OldStyleClearD(this, raLclRegIntf[i]);
+ VarSetOps::ClearD(this, raLclRegIntf[i]);
}
// if there are PInvoke calls and compLvFrameListRoot is enregistered,