JIT: Run full liveness in MinOpts for async

src/coreclr/jit/async.cpp

@@ -397,14 +397,12 @@ BasicBlock* Compiler::CreateReturnBB(unsigned* mergedReturnLcl)
 class AsyncLiveness
 {
  Compiler* m_compiler;
- bool m_hasLiveness;
  TreeLifeUpdater<false> m_updater;
  unsigned m_numVars;
 
 public:
- AsyncLiveness(Compiler* comp, bool hasLiveness)
+ AsyncLiveness(Compiler* comp)
  : m_compiler(comp)
- , m_hasLiveness(hasLiveness)
  , m_updater(comp)
  , m_numVars(comp->lvaCount)
  {
@@ -430,9 +428,6 @@ class AsyncLiveness
 //
 void AsyncLiveness::StartBlock(BasicBlock* block)
 {
- if (!m_hasLiveness)
- return;
-
  VarSetOps::Assign(m_compiler, m_compiler->compCurLife, block->bbLiveIn);
 }
 
@@ -446,9 +441,6 @@ void AsyncLiveness::StartBlock(BasicBlock* block)
 //
 void AsyncLiveness::Update(GenTree* node)
 {
- if (!m_hasLiveness)
- return;
-
  m_updater.UpdateLife(node);
 }
 
@@ -539,8 +531,9 @@ bool AsyncLiveness::IsLive(unsigned lclNum)
  return false;
  }
 
- if (!m_hasLiveness)
+ if (m_compiler->opts.compDbgCode && (lclNum < m_compiler->info.compLocalsCount))
  {
+ // Keep all IL locals in debug codegen
  return true;
  }
 
@@ -701,21 +694,18 @@ PhaseStatus AsyncTransformation::Run()
 #endif
 
  // Compute liveness to be used for determining what must be captured on
- // suspension. In unoptimized codegen we capture everything.
- if (m_compiler->opts.OptimizationEnabled())
+ // suspension.
+ if (m_compiler->m_dfsTree == nullptr)
  {
- if (m_compiler->m_dfsTree == nullptr)
- {
- m_compiler->m_dfsTree = m_compiler->fgComputeDfs<false>();
- }
-
- m_compiler->lvaComputeRefCounts(true, false);
- m_compiler->fgAsyncLiveness();
- INDEBUG(m_compiler->mostRecentlyActivePhase = PHASE_ASYNC);
- VarSetOps::AssignNoCopy(m_compiler, m_compiler->compCurLife, VarSetOps::MakeEmpty(m_compiler));
+ m_compiler->m_dfsTree = m_compiler->fgComputeDfs<false>();
  }
 
- AsyncLiveness liveness(m_compiler, m_compiler->opts.OptimizationEnabled());
+ m_compiler->lvaComputePreciseRefCounts(/* isRecompute */ true, /* setSlotNumbers */ false);
+ m_compiler->fgAsyncLiveness();
+ INDEBUG(m_compiler->mostRecentlyActivePhase = PHASE_ASYNC);
+ VarSetOps::AssignNoCopy(m_compiler, m_compiler->compCurLife, VarSetOps::MakeEmpty(m_compiler));
+
+ AsyncLiveness liveness(m_compiler);
 
  // Now walk the IR for all the blocks that contain async calls. Keep track
  // of liveness and outstanding LIR edges as we go; the LIR edges that cross
@@ -783,6 +773,28 @@ PhaseStatus AsyncTransformation::Run()
 
  m_compiler->fgInvalidateDfsTree();
 
+ if (m_compiler->opts.OptimizationDisabled())
+ {
+ // Rest of the compiler does not expect that we started tracking locals, so reset that state.
+ for (unsigned i = 0; i < m_compiler->lvaTrackedCount; i++)
+ {
+ m_compiler->lvaGetDesc(m_compiler->lvaTrackedToVarNum[i])->lvTracked = false;
+ }
+
+ m_compiler->lvaCurEpoch++;
+ m_compiler->lvaTrackedCount = 0;
+ m_compiler->lvaTrackedCountInSizeTUnits = 0;
+
+ for (BasicBlock* block : m_compiler->Blocks())
+ {
+ block->bbLiveIn = VarSetOps::UninitVal();
+ block->bbLiveOut = VarSetOps::UninitVal();
+ block->bbVarUse = VarSetOps::UninitVal();
+ block->bbVarDef = VarSetOps::UninitVal();
+ }
+ m_compiler->fgBBVarSetsInited = false;
+ }
+
  return PhaseStatus::MODIFIED_EVERYTHING;
 }
 

src/coreclr/jit/compiler.h

@@ -4214,6 +4214,7 @@ class Compiler
 
  PhaseStatus lvaMarkLocalVars(); // Local variable ref-counting
  void lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers);
+ void lvaComputePreciseRefCounts(bool isRecompute, bool setSlotNumbers);
  void lvaMarkLocalVars(BasicBlock* block);
 
  void lvaAllocOutgoingArgSpaceVar(); // Set up lvaOutgoingArgSpaceVar

src/coreclr/jit/lclvars.cpp

@@ -3415,8 +3415,6 @@ PhaseStatus Compiler::lvaMarkLocalVars()
 void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
 {
  JITDUMP("\n*** lvaComputeRefCounts ***\n");
- unsigned lclNum = 0;
- LclVarDsc* varDsc = nullptr;
 
  // Fast path for minopts and debug codegen.
  //
@@ -3430,8 +3428,9 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
 #if defined(DEBUG)
  // All local vars should be marked as implicitly referenced
  // and not tracked.
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  const bool isSpecialVarargsParam = varDsc->lvIsParam && lvaIsArgAccessedViaVarArgsCookie(lclNum);
 
  if (isSpecialVarargsParam)
@@ -3451,8 +3450,9 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  }
 
  // First compute.
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  // Using lvImplicitlyReferenced here ensures that we can't
  // accidentally make locals be unreferenced later by decrementing
  // the ref count to zero.
@@ -3488,11 +3488,28 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  return;
  }
 
- // Slower path we take when optimizing, to get accurate counts.
- //
+ lvaComputePreciseRefCounts(isRecompute, setSlotNumbers);
+}
+
+//------------------------------------------------------------------------
+// lvaComputePreciseRefCounts: compute precise ref counts for locals by IR traversal
+//
+// Arguments:
+// isRecompute -- true if we just want ref counts and no other side effects;
+// false means to also look for true boolean locals, lay
+// groundwork for assertion prop, check type consistency, etc.
+// See lvaMarkLclRefs for details on what else goes on.
+// setSlotNumbers -- true if local slot numbers should be assigned.
+//
+// Notes:
+// See notes on lvaComputeRefCounts.
+//
+void Compiler::lvaComputePreciseRefCounts(bool isRecompute, bool setSlotNumbers)
+{
  // First, reset all explicit ref counts and weights.
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  varDsc->setLvRefCnt(0);
  varDsc->setLvRefCntWtd(BB_ZERO_WEIGHT);
 
@@ -3519,7 +3536,7 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  const bool oldLvaGenericsContextInUse = lvaGenericsContextInUse;
  lvaGenericsContextInUse = false;
 
- JITDUMP("\n*** lvaComputeRefCounts -- explicit counts ***\n");
+ JITDUMP("\n*** lvaComputePreciseRefCounts -- explicit counts ***\n");
 
  // Second, account for all explicit local variable references
  for (BasicBlock* const block : Blocks())
@@ -3577,11 +3594,12 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  assert(!"unexpected new use of generics context");
  }
 
- JITDUMP("\n*** lvaComputeRefCounts -- implicit counts ***\n");
+ JITDUMP("\n*** lvaComputePreciseRefCounts -- implicit counts ***\n");
 
  // Third, bump ref counts for some implicit prolog references
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  // Todo: review justification for these count bumps.
  if (varDsc->lvIsRegArg)
  {

src/coreclr/jit/liveness.cpp

@@ -55,6 +55,7 @@ class Liveness
  ComputeMemoryLiveness = false,
  IsLIR = false,
  IsEarly = false,
+ EliminateDeadCode = false,
  };
 
  Liveness(Compiler* compiler)
@@ -1965,16 +1966,19 @@ bool Liveness<TLiveness>::ComputeLifeTrackedLocalDef(VARSET_TP& life,
  // Dead store
  node->gtFlags |= GTF_VAR_DEATH;
 
- // keepAliveVars always stay alive
- noway_assert(!VarSetOps::IsMember(m_compiler, keepAliveVars, varIndex));
+ if (TLiveness::EliminateDeadCode)
+ {
+ // keepAliveVars always stay alive
+ noway_assert(!VarSetOps::IsMember(m_compiler, keepAliveVars, varIndex));
 
- // Do not consider this store dead if the target local variable represents
- // a promoted struct field of an address exposed local or if the address
- // of the variable has been exposed. Improved alias analysis could allow
- // stores to these sorts of variables to be removed at the cost of compile
- // time.
- return !varDsc.IsAddressExposed() &&
- !(varDsc.lvIsStructField && m_compiler->lvaTable[varDsc.lvParentLcl].IsAddressExposed());
+ // Do not consider this store dead if the target local variable represents
+ // a promoted struct field of an address exposed local or if the address
+ // of the variable has been exposed. Improved alias analysis could allow
+ // stores to these sorts of variables to be removed at the cost of compile
+ // time.
+ return !varDsc.IsAddressExposed() &&
+ !(varDsc.lvIsStructField && m_compiler->lvaTable[varDsc.lvParentLcl].IsAddressExposed());
+ }
  }
 
  return false;
@@ -2011,7 +2015,7 @@ bool Liveness<TLiveness>::ComputeLifeUntrackedLocal(VARSET_TP& life,
 
  // We have accurate ref counts when running late liveness so we can eliminate
  // some stores if the lhs local has a ref count of 1.
- if (isDef && TLiveness::IsLIR && (varDsc.lvRefCnt() == 1) && !varDsc.lvPinned)
+ if (TLiveness::EliminateDeadCode && TLiveness::IsLIR && isDef && (varDsc.lvRefCnt() == 1) && !varDsc.lvPinned)
  {
  if (varDsc.lvIsStructField)
  {
@@ -2083,7 +2087,7 @@ bool Liveness<TLiveness>::ComputeLifeUntrackedLocal(VARSET_TP& life,
  }
  }
 
- if (isDef && !anyFieldLive)
+ if (TLiveness::EliminateDeadCode && isDef && !anyFieldLive)
  {
  // Do not consider this store dead if the parent local variable is an address exposed local or
  // if the struct has any significant padding we must retain the value of.
@@ -2328,7 +2332,8 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  case GT_CALL:
  {
  GenTreeCall* const call = node->AsCall();
- if ((call->TypeIs(TYP_VOID) || call->IsUnusedValue()) && !call->HasSideEffects(m_compiler))
+ if (TLiveness::EliminateDeadCode && (call->TypeIs(TYP_VOID) || call->IsUnusedValue()) &&
+ !call->HasSideEffects(m_compiler))
  {
  JITDUMP("Removing dead call:\n");
  DISPNODE(call);
@@ -2375,13 +2380,13 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  GenTreeLclVarCommon* const lclVarNode = node->AsLclVarCommon();
  LclVarDsc& varDsc = m_compiler->lvaTable[lclVarNode->GetLclNum()];
 
- if (node->IsUnusedValue())
+ if (TLiveness::EliminateDeadCode && node->IsUnusedValue())
  {
  JITDUMP("Removing dead LclVar use:\n");
  DISPNODE(lclVarNode);
 
  blockRange.Delete(m_compiler, block, node);
- if (varDsc.lvTracked && !m_compiler->opts.MinOpts())
+ if (varDsc.lvTracked)
  {
  m_compiler->fgStmtRemoved = true;
  }
@@ -2398,14 +2403,14 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  }
 
  case GT_LCL_ADDR:
- if (node->IsUnusedValue())
+ if (TLiveness::EliminateDeadCode && node->IsUnusedValue())
  {
  JITDUMP("Removing dead LclVar address:\n");
  DISPNODE(node);
 
  const bool isTracked = m_compiler->lvaTable[node->AsLclVarCommon()->GetLclNum()].lvTracked;
  blockRange.Delete(m_compiler, block, node);
- if (isTracked && !m_compiler->opts.MinOpts())
+ if (isTracked)
  {
  m_compiler->fgStmtRemoved = true;
  }
@@ -2423,7 +2428,7 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  }
 
  isDeadStore = ComputeLifeLocal(life, keepAliveVars, node);
- if (isDeadStore)
+ if (TLiveness::EliminateDeadCode && isDeadStore)
  {
  LIR::Use addrUse;
  if (blockRange.TryGetUse(node, &addrUse) && addrUse.User()->OperIs(GT_STOREIND, GT_STORE_BLK))
@@ -2464,7 +2469,7 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  isDeadStore = ComputeLifeUntrackedLocal(life, keepAliveVars, varDsc, lclVarNode);
  }
 
- if (isDeadStore && TryRemoveDeadStoreLIR(node, lclVarNode, block))
+ if (TLiveness::EliminateDeadCode && isDeadStore && TryRemoveDeadStoreLIR(node, lclVarNode, block))
  {
  GenTree* value = lclVarNode->Data();
  value->SetUnusedValue();
@@ -2491,7 +2496,7 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
 #endif // FEATURE_MASKED_HW_INTRINSICS
  case GT_PHYSREG:
  // These are all side-effect-free leaf nodes.
- if (node->IsUnusedValue())
+ if (TLiveness::EliminateDeadCode && node->IsUnusedValue())
  {
  JITDUMP("Removing dead node:\n");
  DISPNODE(node);
@@ -2693,6 +2698,11 @@ bool Liveness<TLiveness>::TryRemoveDeadStoreLIR(GenTree* store, GenTreeLclVarCom
 template <typename TLiveness>
 bool Liveness<TLiveness>::TryRemoveNonLocalLIR(GenTree* node, LIR::Range* blockRange)
 {
+ if (!TLiveness::EliminateDeadCode)
+ {
+ return false;
+ }
+
  assert(!node->OperIsLocal());
  if (!node->IsValue() || node->IsUnusedValue())
  {
@@ -2816,6 +2826,7 @@ void Compiler::fgSsaLiveness()
  ComputeMemoryLiveness = true,
  IsLIR = false,
  IsEarly = false,
+ EliminateDeadCode = true,
  };
 
  SsaLivenessClass(Compiler* comp)
@@ -2841,6 +2852,7 @@ void Compiler::fgAsyncLiveness()
  ComputeMemoryLiveness = false,
  IsLIR = true,
  IsEarly = false,
+ EliminateDeadCode = false,
  };
 
  AsyncLiveness(Compiler* comp)
@@ -2866,6 +2878,7 @@ void Compiler::fgPostLowerLiveness()
  ComputeMemoryLiveness = false,
  IsLIR = true,
  IsEarly = false,
+ EliminateDeadCode = true,
  };
 
  PostLowerLiveness(Compiler* comp)
@@ -2909,6 +2922,7 @@ PhaseStatus Compiler::fgEarlyLiveness()
  ComputeMemoryLiveness = false,
  IsLIR = false,
  IsEarly = true,
+ EliminateDeadCode = true,
  };
 
  EarlyLiveness(Compiler* comp)

src/coreclr/jit/async.cpp

@@ -397,14 +397,12 @@ BasicBlock* Compiler::CreateReturnBB(unsigned* mergedReturnLcl)
 class AsyncLiveness
 {
  Compiler* m_compiler;
- bool m_hasLiveness;
  TreeLifeUpdater<false> m_updater;
  unsigned m_numVars;
 
 public:
- AsyncLiveness(Compiler* comp, bool hasLiveness)
+ AsyncLiveness(Compiler* comp)
  : m_compiler(comp)
- , m_hasLiveness(hasLiveness)
  , m_updater(comp)
  , m_numVars(comp->lvaCount)
  {
@@ -430,9 +428,6 @@ class AsyncLiveness
 //
 void AsyncLiveness::StartBlock(BasicBlock* block)
 {
- if (!m_hasLiveness)
- return;
-
  VarSetOps::Assign(m_compiler, m_compiler->compCurLife, block->bbLiveIn);
 }
 
@@ -446,9 +441,6 @@ void AsyncLiveness::StartBlock(BasicBlock* block)
 //
 void AsyncLiveness::Update(GenTree* node)
 {
- if (!m_hasLiveness)
- return;
-
  m_updater.UpdateLife(node);
 }
 
@@ -539,8 +531,9 @@ bool AsyncLiveness::IsLive(unsigned lclNum)
  return false;
  }
 
- if (!m_hasLiveness)
+ if (m_compiler->opts.compDbgCode && (lclNum < m_compiler->info.compLocalsCount))
  {
+ // Keep all IL locals in debug codegen
  return true;
  }
 
@@ -701,21 +694,18 @@ PhaseStatus AsyncTransformation::Run()
 #endif
 
  // Compute liveness to be used for determining what must be captured on
- // suspension. In unoptimized codegen we capture everything.
- if (m_compiler->opts.OptimizationEnabled())
+ // suspension.
+ if (m_compiler->m_dfsTree == nullptr)
  {
- if (m_compiler->m_dfsTree == nullptr)
- {
- m_compiler->m_dfsTree = m_compiler->fgComputeDfs<false>();
- }
-
- m_compiler->lvaComputeRefCounts(true, false);
- m_compiler->fgAsyncLiveness();
- INDEBUG(m_compiler->mostRecentlyActivePhase = PHASE_ASYNC);
- VarSetOps::AssignNoCopy(m_compiler, m_compiler->compCurLife, VarSetOps::MakeEmpty(m_compiler));
+ m_compiler->m_dfsTree = m_compiler->fgComputeDfs<false>();
  }
 
- AsyncLiveness liveness(m_compiler, m_compiler->opts.OptimizationEnabled());
+ m_compiler->lvaComputePreciseRefCounts(/* isRecompute */ true, /* setSlotNumbers */ false);
+ m_compiler->fgAsyncLiveness();
+ INDEBUG(m_compiler->mostRecentlyActivePhase = PHASE_ASYNC);
+ VarSetOps::AssignNoCopy(m_compiler, m_compiler->compCurLife, VarSetOps::MakeEmpty(m_compiler));
+
+ AsyncLiveness liveness(m_compiler);
 
  // Now walk the IR for all the blocks that contain async calls. Keep track
  // of liveness and outstanding LIR edges as we go; the LIR edges that cross
@@ -783,6 +773,28 @@ PhaseStatus AsyncTransformation::Run()
 
  m_compiler->fgInvalidateDfsTree();
 
+ if (m_compiler->opts.OptimizationDisabled())
+ {
+ // Rest of the compiler does not expect that we started tracking locals, so reset that state.
+ for (unsigned i = 0; i < m_compiler->lvaTrackedCount; i++)
+ {
+ m_compiler->lvaGetDesc(m_compiler->lvaTrackedToVarNum[i])->lvTracked = false;
+ }
+
+ m_compiler->lvaCurEpoch++;
+ m_compiler->lvaTrackedCount = 0;
+ m_compiler->lvaTrackedCountInSizeTUnits = 0;
+
+ for (BasicBlock* block : m_compiler->Blocks())
+ {
+ block->bbLiveIn = VarSetOps::UninitVal();
+ block->bbLiveOut = VarSetOps::UninitVal();
+ block->bbVarUse = VarSetOps::UninitVal();
+ block->bbVarDef = VarSetOps::UninitVal();
+ }
+ m_compiler->fgBBVarSetsInited = false;
+ }
+
  return PhaseStatus::MODIFIED_EVERYTHING;
 }
 

src/coreclr/jit/compiler.h

@@ -4214,6 +4214,7 @@ class Compiler
 
  PhaseStatus lvaMarkLocalVars(); // Local variable ref-counting
  void lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers);
+ void lvaComputePreciseRefCounts(bool isRecompute, bool setSlotNumbers);
  void lvaMarkLocalVars(BasicBlock* block);
 
  void lvaAllocOutgoingArgSpaceVar(); // Set up lvaOutgoingArgSpaceVar

src/coreclr/jit/lclvars.cpp

@@ -3415,8 +3415,6 @@ PhaseStatus Compiler::lvaMarkLocalVars()
 void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
 {
  JITDUMP("\n*** lvaComputeRefCounts ***\n");
- unsigned lclNum = 0;
- LclVarDsc* varDsc = nullptr;
 
  // Fast path for minopts and debug codegen.
  //
@@ -3430,8 +3428,9 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
 #if defined(DEBUG)
  // All local vars should be marked as implicitly referenced
  // and not tracked.
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  const bool isSpecialVarargsParam = varDsc->lvIsParam && lvaIsArgAccessedViaVarArgsCookie(lclNum);
 
  if (isSpecialVarargsParam)
@@ -3451,8 +3450,9 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  }
 
  // First compute.
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  // Using lvImplicitlyReferenced here ensures that we can't
  // accidentally make locals be unreferenced later by decrementing
  // the ref count to zero.
@@ -3488,11 +3488,28 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  return;
  }
 
- // Slower path we take when optimizing, to get accurate counts.
- //
+ lvaComputePreciseRefCounts(isRecompute, setSlotNumbers);
+}
+
+//------------------------------------------------------------------------
+// lvaComputePreciseRefCounts: compute precise ref counts for locals by IR traversal
+//
+// Arguments:
+// isRecompute -- true if we just want ref counts and no other side effects;
+// false means to also look for true boolean locals, lay
+// groundwork for assertion prop, check type consistency, etc.
+// See lvaMarkLclRefs for details on what else goes on.
+// setSlotNumbers -- true if local slot numbers should be assigned.
+//
+// Notes:
+// See notes on lvaComputeRefCounts.
+//
+void Compiler::lvaComputePreciseRefCounts(bool isRecompute, bool setSlotNumbers)
+{
  // First, reset all explicit ref counts and weights.
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  varDsc->setLvRefCnt(0);
  varDsc->setLvRefCntWtd(BB_ZERO_WEIGHT);
 
@@ -3519,7 +3536,7 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  const bool oldLvaGenericsContextInUse = lvaGenericsContextInUse;
  lvaGenericsContextInUse = false;
 
- JITDUMP("\n*** lvaComputeRefCounts -- explicit counts ***\n");
+ JITDUMP("\n*** lvaComputePreciseRefCounts -- explicit counts ***\n");
 
  // Second, account for all explicit local variable references
  for (BasicBlock* const block : Blocks())
@@ -3577,11 +3594,12 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  assert(!"unexpected new use of generics context");
  }
 
- JITDUMP("\n*** lvaComputeRefCounts -- implicit counts ***\n");
+ JITDUMP("\n*** lvaComputePreciseRefCounts -- implicit counts ***\n");
 
  // Third, bump ref counts for some implicit prolog references
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  // Todo: review justification for these count bumps.
  if (varDsc->lvIsRegArg)
  {

src/coreclr/jit/liveness.cpp

@@ -55,6 +55,7 @@ class Liveness
  ComputeMemoryLiveness = false,
  IsLIR = false,
  IsEarly = false,
+ EliminateDeadCode = false,
  };
 
  Liveness(Compiler* compiler)
@@ -1965,16 +1966,19 @@ bool Liveness<TLiveness>::ComputeLifeTrackedLocalDef(VARSET_TP& life,
  // Dead store
  node->gtFlags |= GTF_VAR_DEATH;
 
- // keepAliveVars always stay alive
- noway_assert(!VarSetOps::IsMember(m_compiler, keepAliveVars, varIndex));
+ if (TLiveness::EliminateDeadCode)
+ {
+ // keepAliveVars always stay alive
+ noway_assert(!VarSetOps::IsMember(m_compiler, keepAliveVars, varIndex));
 
- // Do not consider this store dead if the target local variable represents
- // a promoted struct field of an address exposed local or if the address
- // of the variable has been exposed. Improved alias analysis could allow
- // stores to these sorts of variables to be removed at the cost of compile
- // time.
- return !varDsc.IsAddressExposed() &&
- !(varDsc.lvIsStructField && m_compiler->lvaTable[varDsc.lvParentLcl].IsAddressExposed());
+ // Do not consider this store dead if the target local variable represents
+ // a promoted struct field of an address exposed local or if the address
+ // of the variable has been exposed. Improved alias analysis could allow
+ // stores to these sorts of variables to be removed at the cost of compile
+ // time.
+ return !varDsc.IsAddressExposed() &&
+ !(varDsc.lvIsStructField && m_compiler->lvaTable[varDsc.lvParentLcl].IsAddressExposed());
+ }
  }
 
  return false;
@@ -2011,7 +2015,7 @@ bool Liveness<TLiveness>::ComputeLifeUntrackedLocal(VARSET_TP& life,
 
  // We have accurate ref counts when running late liveness so we can eliminate
  // some stores if the lhs local has a ref count of 1.
- if (isDef && TLiveness::IsLIR && (varDsc.lvRefCnt() == 1) && !varDsc.lvPinned)
+ if (TLiveness::EliminateDeadCode && TLiveness::IsLIR && isDef && (varDsc.lvRefCnt() == 1) && !varDsc.lvPinned)
  {
  if (varDsc.lvIsStructField)
  {
@@ -2083,7 +2087,7 @@ bool Liveness<TLiveness>::ComputeLifeUntrackedLocal(VARSET_TP& life,
  }
  }
 
- if (isDef && !anyFieldLive)
+ if (TLiveness::EliminateDeadCode && isDef && !anyFieldLive)
  {
  // Do not consider this store dead if the parent local variable is an address exposed local or
  // if the struct has any significant padding we must retain the value of.
@@ -2328,7 +2332,8 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  case GT_CALL:
  {
  GenTreeCall* const call = node->AsCall();
- if ((call->TypeIs(TYP_VOID) || call->IsUnusedValue()) && !call->HasSideEffects(m_compiler))
+ if (TLiveness::EliminateDeadCode && (call->TypeIs(TYP_VOID) || call->IsUnusedValue()) &&
+ !call->HasSideEffects(m_compiler))
  {
  JITDUMP("Removing dead call:\n");
  DISPNODE(call);
@@ -2375,13 +2380,13 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  GenTreeLclVarCommon* const lclVarNode = node->AsLclVarCommon();
  LclVarDsc& varDsc = m_compiler->lvaTable[lclVarNode->GetLclNum()];
 
- if (node->IsUnusedValue())
+ if (TLiveness::EliminateDeadCode && node->IsUnusedValue())
  {
  JITDUMP("Removing dead LclVar use:\n");
  DISPNODE(lclVarNode);
 
  blockRange.Delete(m_compiler, block, node);
- if (varDsc.lvTracked && !m_compiler->opts.MinOpts())
+ if (varDsc.lvTracked)
  {
  m_compiler->fgStmtRemoved = true;
  }
@@ -2398,14 +2403,14 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  }
 
  case GT_LCL_ADDR:
- if (node->IsUnusedValue())
+ if (TLiveness::EliminateDeadCode && node->IsUnusedValue())
  {
  JITDUMP("Removing dead LclVar address:\n");
  DISPNODE(node);
 
  const bool isTracked = m_compiler->lvaTable[node->AsLclVarCommon()->GetLclNum()].lvTracked;
  blockRange.Delete(m_compiler, block, node);
- if (isTracked && !m_compiler->opts.MinOpts())
+ if (isTracked)
  {
  m_compiler->fgStmtRemoved = true;
  }
@@ -2423,7 +2428,7 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  }
 
  isDeadStore = ComputeLifeLocal(life, keepAliveVars, node);
- if (isDeadStore)
+ if (TLiveness::EliminateDeadCode && isDeadStore)
  {
  LIR::Use addrUse;
  if (blockRange.TryGetUse(node, &addrUse) && addrUse.User()->OperIs(GT_STOREIND, GT_STORE_BLK))
@@ -2464,7 +2469,7 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  isDeadStore = ComputeLifeUntrackedLocal(life, keepAliveVars, varDsc, lclVarNode);
  }
 
- if (isDeadStore && TryRemoveDeadStoreLIR(node, lclVarNode, block))
+ if (TLiveness::EliminateDeadCode && isDeadStore && TryRemoveDeadStoreLIR(node, lclVarNode, block))
  {
  GenTree* value = lclVarNode->Data();
  value->SetUnusedValue();
@@ -2491,7 +2496,7 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
 #endif // FEATURE_MASKED_HW_INTRINSICS
  case GT_PHYSREG:
  // These are all side-effect-free leaf nodes.
- if (node->IsUnusedValue())
+ if (TLiveness::EliminateDeadCode && node->IsUnusedValue())
  {
  JITDUMP("Removing dead node:\n");
  DISPNODE(node);
@@ -2693,6 +2698,11 @@ bool Liveness<TLiveness>::TryRemoveDeadStoreLIR(GenTree* store, GenTreeLclVarCom
 template <typename TLiveness>
 bool Liveness<TLiveness>::TryRemoveNonLocalLIR(GenTree* node, LIR::Range* blockRange)
 {
+ if (!TLiveness::EliminateDeadCode)
+ {
+ return false;
+ }
+
  assert(!node->OperIsLocal());
  if (!node->IsValue() || node->IsUnusedValue())
  {
@@ -2816,6 +2826,7 @@ void Compiler::fgSsaLiveness()
  ComputeMemoryLiveness = true,
  IsLIR = false,
  IsEarly = false,
+ EliminateDeadCode = true,
  };
 
  SsaLivenessClass(Compiler* comp)
@@ -2841,6 +2852,7 @@ void Compiler::fgAsyncLiveness()
  ComputeMemoryLiveness = false,
  IsLIR = true,
  IsEarly = false,
+ EliminateDeadCode = false,
  };
 
  AsyncLiveness(Compiler* comp)
@@ -2866,6 +2878,7 @@ void Compiler::fgPostLowerLiveness()
  ComputeMemoryLiveness = false,
  IsLIR = true,
  IsEarly = false,
+ EliminateDeadCode = true,
  };
 
  PostLowerLiveness(Compiler* comp)
@@ -2909,6 +2922,7 @@ PhaseStatus Compiler::fgEarlyLiveness()
  ComputeMemoryLiveness = false,
  IsLIR = false,
  IsEarly = true,
+ EliminateDeadCode = true,
  };
 
  EarlyLiveness(Compiler* comp)

src/coreclr/jit/async.cpp

@@ -397,14 +397,12 @@ BasicBlock* Compiler::CreateReturnBB(unsigned* mergedReturnLcl)
 class AsyncLiveness
 {
  Compiler* m_compiler;
- bool m_hasLiveness;
  TreeLifeUpdater<false> m_updater;
  unsigned m_numVars;
 
 public:
- AsyncLiveness(Compiler* comp, bool hasLiveness)
+ AsyncLiveness(Compiler* comp)
  : m_compiler(comp)
- , m_hasLiveness(hasLiveness)
  , m_updater(comp)
  , m_numVars(comp->lvaCount)
  {
@@ -430,9 +428,6 @@ class AsyncLiveness
 //
 void AsyncLiveness::StartBlock(BasicBlock* block)
 {
- if (!m_hasLiveness)
- return;
-
  VarSetOps::Assign(m_compiler, m_compiler->compCurLife, block->bbLiveIn);
 }
 
@@ -446,9 +441,6 @@ void AsyncLiveness::StartBlock(BasicBlock* block)
 //
 void AsyncLiveness::Update(GenTree* node)
 {
- if (!m_hasLiveness)
- return;
-
  m_updater.UpdateLife(node);
 }
 
@@ -539,8 +531,9 @@ bool AsyncLiveness::IsLive(unsigned lclNum)
  return false;
  }
 
- if (!m_hasLiveness)
+ if (m_compiler->opts.compDbgCode && (lclNum < m_compiler->info.compLocalsCount))
  {
+ // Keep all IL locals in debug codegen
  return true;
  }
 
@@ -701,21 +694,18 @@ PhaseStatus AsyncTransformation::Run()
 #endif
 
  // Compute liveness to be used for determining what must be captured on
- // suspension. In unoptimized codegen we capture everything.
- if (m_compiler->opts.OptimizationEnabled())
+ // suspension.
+ if (m_compiler->m_dfsTree == nullptr)
  {
- if (m_compiler->m_dfsTree == nullptr)
- {
- m_compiler->m_dfsTree = m_compiler->fgComputeDfs<false>();
- }
-
- m_compiler->lvaComputeRefCounts(true, false);
- m_compiler->fgAsyncLiveness();
- INDEBUG(m_compiler->mostRecentlyActivePhase = PHASE_ASYNC);
- VarSetOps::AssignNoCopy(m_compiler, m_compiler->compCurLife, VarSetOps::MakeEmpty(m_compiler));
+ m_compiler->m_dfsTree = m_compiler->fgComputeDfs<false>();
  }
 
- AsyncLiveness liveness(m_compiler, m_compiler->opts.OptimizationEnabled());
+ m_compiler->lvaComputePreciseRefCounts(/* isRecompute */ true, /* setSlotNumbers */ false);
+ m_compiler->fgAsyncLiveness();
+ INDEBUG(m_compiler->mostRecentlyActivePhase = PHASE_ASYNC);
+ VarSetOps::AssignNoCopy(m_compiler, m_compiler->compCurLife, VarSetOps::MakeEmpty(m_compiler));
+
+ AsyncLiveness liveness(m_compiler);
 
  // Now walk the IR for all the blocks that contain async calls. Keep track
  // of liveness and outstanding LIR edges as we go; the LIR edges that cross
@@ -783,6 +773,28 @@ PhaseStatus AsyncTransformation::Run()
 
  m_compiler->fgInvalidateDfsTree();
 
+ if (m_compiler->opts.OptimizationDisabled())
+ {
+ // Rest of the compiler does not expect that we started tracking locals, so reset that state.
+ for (unsigned i = 0; i < m_compiler->lvaTrackedCount; i++)
+ {
+ m_compiler->lvaGetDesc(m_compiler->lvaTrackedToVarNum[i])->lvTracked = false;
+ }
+
+ m_compiler->lvaCurEpoch++;
+ m_compiler->lvaTrackedCount = 0;
+ m_compiler->lvaTrackedCountInSizeTUnits = 0;
+
+ for (BasicBlock* block : m_compiler->Blocks())
+ {
+ block->bbLiveIn = VarSetOps::UninitVal();
+ block->bbLiveOut = VarSetOps::UninitVal();
+ block->bbVarUse = VarSetOps::UninitVal();
+ block->bbVarDef = VarSetOps::UninitVal();
+ }
+ m_compiler->fgBBVarSetsInited = false;
+ }
+
  return PhaseStatus::MODIFIED_EVERYTHING;
 }
 

src/coreclr/jit/compiler.h

@@ -4214,6 +4214,7 @@ class Compiler
 
  PhaseStatus lvaMarkLocalVars(); // Local variable ref-counting
  void lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers);
+ void lvaComputePreciseRefCounts(bool isRecompute, bool setSlotNumbers);
  void lvaMarkLocalVars(BasicBlock* block);
 
  void lvaAllocOutgoingArgSpaceVar(); // Set up lvaOutgoingArgSpaceVar

src/coreclr/jit/lclvars.cpp

@@ -3415,8 +3415,6 @@ PhaseStatus Compiler::lvaMarkLocalVars()
 void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
 {
  JITDUMP("\n*** lvaComputeRefCounts ***\n");
- unsigned lclNum = 0;
- LclVarDsc* varDsc = nullptr;
 
  // Fast path for minopts and debug codegen.
  //
@@ -3430,8 +3428,9 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
 #if defined(DEBUG)
  // All local vars should be marked as implicitly referenced
  // and not tracked.
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  const bool isSpecialVarargsParam = varDsc->lvIsParam && lvaIsArgAccessedViaVarArgsCookie(lclNum);
 
  if (isSpecialVarargsParam)
@@ -3451,8 +3450,9 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  }
 
  // First compute.
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  // Using lvImplicitlyReferenced here ensures that we can't
  // accidentally make locals be unreferenced later by decrementing
  // the ref count to zero.
@@ -3488,11 +3488,28 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  return;
  }
 
- // Slower path we take when optimizing, to get accurate counts.
- //
+ lvaComputePreciseRefCounts(isRecompute, setSlotNumbers);
+}
+
+//------------------------------------------------------------------------
+// lvaComputePreciseRefCounts: compute precise ref counts for locals by IR traversal
+//
+// Arguments:
+// isRecompute -- true if we just want ref counts and no other side effects;
+// false means to also look for true boolean locals, lay
+// groundwork for assertion prop, check type consistency, etc.
+// See lvaMarkLclRefs for details on what else goes on.
+// setSlotNumbers -- true if local slot numbers should be assigned.
+//
+// Notes:
+// See notes on lvaComputeRefCounts.
+//
+void Compiler::lvaComputePreciseRefCounts(bool isRecompute, bool setSlotNumbers)
+{
  // First, reset all explicit ref counts and weights.
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  varDsc->setLvRefCnt(0);
  varDsc->setLvRefCntWtd(BB_ZERO_WEIGHT);
 
@@ -3519,7 +3536,7 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  const bool oldLvaGenericsContextInUse = lvaGenericsContextInUse;
  lvaGenericsContextInUse = false;
 
- JITDUMP("\n*** lvaComputeRefCounts -- explicit counts ***\n");
+ JITDUMP("\n*** lvaComputePreciseRefCounts -- explicit counts ***\n");
 
  // Second, account for all explicit local variable references
  for (BasicBlock* const block : Blocks())
@@ -3577,11 +3594,12 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  assert(!"unexpected new use of generics context");
  }
 
- JITDUMP("\n*** lvaComputeRefCounts -- implicit counts ***\n");
+ JITDUMP("\n*** lvaComputePreciseRefCounts -- implicit counts ***\n");
 
  // Third, bump ref counts for some implicit prolog references
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  // Todo: review justification for these count bumps.
  if (varDsc->lvIsRegArg)
  {

src/coreclr/jit/liveness.cpp

@@ -55,6 +55,7 @@ class Liveness
  ComputeMemoryLiveness = false,
  IsLIR = false,
  IsEarly = false,
+ EliminateDeadCode = false,
  };
 
  Liveness(Compiler* compiler)
@@ -1965,16 +1966,19 @@ bool Liveness<TLiveness>::ComputeLifeTrackedLocalDef(VARSET_TP& life,
  // Dead store
  node->gtFlags |= GTF_VAR_DEATH;
 
- // keepAliveVars always stay alive
- noway_assert(!VarSetOps::IsMember(m_compiler, keepAliveVars, varIndex));
+ if (TLiveness::EliminateDeadCode)
+ {
+ // keepAliveVars always stay alive
+ noway_assert(!VarSetOps::IsMember(m_compiler, keepAliveVars, varIndex));
 
- // Do not consider this store dead if the target local variable represents
- // a promoted struct field of an address exposed local or if the address
- // of the variable has been exposed. Improved alias analysis could allow
- // stores to these sorts of variables to be removed at the cost of compile
- // time.
- return !varDsc.IsAddressExposed() &&
- !(varDsc.lvIsStructField && m_compiler->lvaTable[varDsc.lvParentLcl].IsAddressExposed());
+ // Do not consider this store dead if the target local variable represents
+ // a promoted struct field of an address exposed local or if the address
+ // of the variable has been exposed. Improved alias analysis could allow
+ // stores to these sorts of variables to be removed at the cost of compile
+ // time.
+ return !varDsc.IsAddressExposed() &&
+ !(varDsc.lvIsStructField && m_compiler->lvaTable[varDsc.lvParentLcl].IsAddressExposed());
+ }
  }
 
  return false;
@@ -2011,7 +2015,7 @@ bool Liveness<TLiveness>::ComputeLifeUntrackedLocal(VARSET_TP& life,
 
  // We have accurate ref counts when running late liveness so we can eliminate
  // some stores if the lhs local has a ref count of 1.
- if (isDef && TLiveness::IsLIR && (varDsc.lvRefCnt() == 1) && !varDsc.lvPinned)
+ if (TLiveness::EliminateDeadCode && TLiveness::IsLIR && isDef && (varDsc.lvRefCnt() == 1) && !varDsc.lvPinned)
  {
  if (varDsc.lvIsStructField)
  {
@@ -2083,7 +2087,7 @@ bool Liveness<TLiveness>::ComputeLifeUntrackedLocal(VARSET_TP& life,
  }
  }
 
- if (isDef && !anyFieldLive)
+ if (TLiveness::EliminateDeadCode && isDef && !anyFieldLive)
  {
  // Do not consider this store dead if the parent local variable is an address exposed local or
  // if the struct has any significant padding we must retain the value of.
@@ -2328,7 +2332,8 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  case GT_CALL:
  {
  GenTreeCall* const call = node->AsCall();
- if ((call->TypeIs(TYP_VOID) || call->IsUnusedValue()) && !call->HasSideEffects(m_compiler))
+ if (TLiveness::EliminateDeadCode && (call->TypeIs(TYP_VOID) || call->IsUnusedValue()) &&
+ !call->HasSideEffects(m_compiler))
  {
  JITDUMP("Removing dead call:\n");
  DISPNODE(call);
@@ -2375,13 +2380,13 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  GenTreeLclVarCommon* const lclVarNode = node->AsLclVarCommon();
  LclVarDsc& varDsc = m_compiler->lvaTable[lclVarNode->GetLclNum()];
 
- if (node->IsUnusedValue())
+ if (TLiveness::EliminateDeadCode && node->IsUnusedValue())
  {
  JITDUMP("Removing dead LclVar use:\n");
  DISPNODE(lclVarNode);
 
  blockRange.Delete(m_compiler, block, node);
- if (varDsc.lvTracked && !m_compiler->opts.MinOpts())
+ if (varDsc.lvTracked)
  {
  m_compiler->fgStmtRemoved = true;
  }
@@ -2398,14 +2403,14 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  }
 
  case GT_LCL_ADDR:
- if (node->IsUnusedValue())
+ if (TLiveness::EliminateDeadCode && node->IsUnusedValue())
  {
  JITDUMP("Removing dead LclVar address:\n");
  DISPNODE(node);
 
  const bool isTracked = m_compiler->lvaTable[node->AsLclVarCommon()->GetLclNum()].lvTracked;
  blockRange.Delete(m_compiler, block, node);
- if (isTracked && !m_compiler->opts.MinOpts())
+ if (isTracked)
  {
  m_compiler->fgStmtRemoved = true;
  }
@@ -2423,7 +2428,7 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  }
 
  isDeadStore = ComputeLifeLocal(life, keepAliveVars, node);
- if (isDeadStore)
+ if (TLiveness::EliminateDeadCode && isDeadStore)
  {
  LIR::Use addrUse;
  if (blockRange.TryGetUse(node, &addrUse) && addrUse.User()->OperIs(GT_STOREIND, GT_STORE_BLK))
@@ -2464,7 +2469,7 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  isDeadStore = ComputeLifeUntrackedLocal(life, keepAliveVars, varDsc, lclVarNode);
  }
 
- if (isDeadStore && TryRemoveDeadStoreLIR(node, lclVarNode, block))
+ if (TLiveness::EliminateDeadCode && isDeadStore && TryRemoveDeadStoreLIR(node, lclVarNode, block))
  {
  GenTree* value = lclVarNode->Data();
  value->SetUnusedValue();
@@ -2491,7 +2496,7 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
 #endif // FEATURE_MASKED_HW_INTRINSICS
  case GT_PHYSREG:
  // These are all side-effect-free leaf nodes.
- if (node->IsUnusedValue())
+ if (TLiveness::EliminateDeadCode && node->IsUnusedValue())
  {
  JITDUMP("Removing dead node:\n");
  DISPNODE(node);
@@ -2693,6 +2698,11 @@ bool Liveness<TLiveness>::TryRemoveDeadStoreLIR(GenTree* store, GenTreeLclVarCom
 template <typename TLiveness>
 bool Liveness<TLiveness>::TryRemoveNonLocalLIR(GenTree* node, LIR::Range* blockRange)
 {
+ if (!TLiveness::EliminateDeadCode)
+ {
+ return false;
+ }
+
  assert(!node->OperIsLocal());
  if (!node->IsValue() || node->IsUnusedValue())
  {
@@ -2816,6 +2826,7 @@ void Compiler::fgSsaLiveness()
  ComputeMemoryLiveness = true,
  IsLIR = false,
  IsEarly = false,
+ EliminateDeadCode = true,
  };
 
  SsaLivenessClass(Compiler* comp)
@@ -2841,6 +2852,7 @@ void Compiler::fgAsyncLiveness()
  ComputeMemoryLiveness = false,
  IsLIR = true,
  IsEarly = false,
+ EliminateDeadCode = false,
  };
 
  AsyncLiveness(Compiler* comp)
@@ -2866,6 +2878,7 @@ void Compiler::fgPostLowerLiveness()
  ComputeMemoryLiveness = false,
  IsLIR = true,
  IsEarly = false,
+ EliminateDeadCode = true,
  };
 
  PostLowerLiveness(Compiler* comp)
@@ -2909,6 +2922,7 @@ PhaseStatus Compiler::fgEarlyLiveness()
  ComputeMemoryLiveness = false,
  IsLIR = false,
  IsEarly = true,
+ EliminateDeadCode = true,
  };
 
  EarlyLiveness(Compiler* comp)

src/coreclr/jit/async.cpp

@@ -397,14 +397,12 @@ BasicBlock* Compiler::CreateReturnBB(unsigned* mergedReturnLcl)
 class AsyncLiveness
 {
  Compiler* m_compiler;
- bool m_hasLiveness;
  TreeLifeUpdater<false> m_updater;
  unsigned m_numVars;
 
 public:
- AsyncLiveness(Compiler* comp, bool hasLiveness)
+ AsyncLiveness(Compiler* comp)
  : m_compiler(comp)
- , m_hasLiveness(hasLiveness)
  , m_updater(comp)
  , m_numVars(comp->lvaCount)
  {
@@ -430,9 +428,6 @@ class AsyncLiveness
 //
 void AsyncLiveness::StartBlock(BasicBlock* block)
 {
- if (!m_hasLiveness)
- return;
-
  VarSetOps::Assign(m_compiler, m_compiler->compCurLife, block->bbLiveIn);
 }
 
@@ -446,9 +441,6 @@ void AsyncLiveness::StartBlock(BasicBlock* block)
 //
 void AsyncLiveness::Update(GenTree* node)
 {
- if (!m_hasLiveness)
- return;
-
  m_updater.UpdateLife(node);
 }
 
@@ -539,8 +531,9 @@ bool AsyncLiveness::IsLive(unsigned lclNum)
  return false;
  }
 
- if (!m_hasLiveness)
+ if (m_compiler->opts.compDbgCode && (lclNum < m_compiler->info.compLocalsCount))
  {
+ // Keep all IL locals in debug codegen
  return true;
  }
 
@@ -701,21 +694,18 @@ PhaseStatus AsyncTransformation::Run()
 #endif
 
  // Compute liveness to be used for determining what must be captured on
- // suspension. In unoptimized codegen we capture everything.
- if (m_compiler->opts.OptimizationEnabled())
+ // suspension.
+ if (m_compiler->m_dfsTree == nullptr)
  {
- if (m_compiler->m_dfsTree == nullptr)
- {
- m_compiler->m_dfsTree = m_compiler->fgComputeDfs<false>();
- }
-
- m_compiler->lvaComputeRefCounts(true, false);
- m_compiler->fgAsyncLiveness();
- INDEBUG(m_compiler->mostRecentlyActivePhase = PHASE_ASYNC);
- VarSetOps::AssignNoCopy(m_compiler, m_compiler->compCurLife, VarSetOps::MakeEmpty(m_compiler));
+ m_compiler->m_dfsTree = m_compiler->fgComputeDfs<false>();
  }
 
- AsyncLiveness liveness(m_compiler, m_compiler->opts.OptimizationEnabled());
+ m_compiler->lvaComputePreciseRefCounts(/* isRecompute */ true, /* setSlotNumbers */ false);
+ m_compiler->fgAsyncLiveness();
+ INDEBUG(m_compiler->mostRecentlyActivePhase = PHASE_ASYNC);
+ VarSetOps::AssignNoCopy(m_compiler, m_compiler->compCurLife, VarSetOps::MakeEmpty(m_compiler));
+
+ AsyncLiveness liveness(m_compiler);
 
  // Now walk the IR for all the blocks that contain async calls. Keep track
  // of liveness and outstanding LIR edges as we go; the LIR edges that cross
@@ -783,6 +773,28 @@ PhaseStatus AsyncTransformation::Run()
 
  m_compiler->fgInvalidateDfsTree();
 
+ if (m_compiler->opts.OptimizationDisabled())
+ {
+ // Rest of the compiler does not expect that we started tracking locals, so reset that state.
+ for (unsigned i = 0; i < m_compiler->lvaTrackedCount; i++)
+ {
+ m_compiler->lvaGetDesc(m_compiler->lvaTrackedToVarNum[i])->lvTracked = false;
+ }
+
+ m_compiler->lvaCurEpoch++;
+ m_compiler->lvaTrackedCount = 0;
+ m_compiler->lvaTrackedCountInSizeTUnits = 0;
+
+ for (BasicBlock* block : m_compiler->Blocks())
+ {
+ block->bbLiveIn = VarSetOps::UninitVal();
+ block->bbLiveOut = VarSetOps::UninitVal();
+ block->bbVarUse = VarSetOps::UninitVal();
+ block->bbVarDef = VarSetOps::UninitVal();
+ }
+ m_compiler->fgBBVarSetsInited = false;
+ }
+
  return PhaseStatus::MODIFIED_EVERYTHING;
 }
 

src/coreclr/jit/compiler.h

@@ -4214,6 +4214,7 @@ class Compiler
 
  PhaseStatus lvaMarkLocalVars(); // Local variable ref-counting
  void lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers);
+ void lvaComputePreciseRefCounts(bool isRecompute, bool setSlotNumbers);
  void lvaMarkLocalVars(BasicBlock* block);
 
  void lvaAllocOutgoingArgSpaceVar(); // Set up lvaOutgoingArgSpaceVar

src/coreclr/jit/lclvars.cpp

@@ -3415,8 +3415,6 @@ PhaseStatus Compiler::lvaMarkLocalVars()
 void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
 {
  JITDUMP("\n*** lvaComputeRefCounts ***\n");
- unsigned lclNum = 0;
- LclVarDsc* varDsc = nullptr;
 
  // Fast path for minopts and debug codegen.
  //
@@ -3430,8 +3428,9 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
 #if defined(DEBUG)
  // All local vars should be marked as implicitly referenced
  // and not tracked.
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  const bool isSpecialVarargsParam = varDsc->lvIsParam && lvaIsArgAccessedViaVarArgsCookie(lclNum);
 
  if (isSpecialVarargsParam)
@@ -3451,8 +3450,9 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  }
 
  // First compute.
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  // Using lvImplicitlyReferenced here ensures that we can't
  // accidentally make locals be unreferenced later by decrementing
  // the ref count to zero.
@@ -3488,11 +3488,28 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  return;
  }
 
- // Slower path we take when optimizing, to get accurate counts.
- //
+ lvaComputePreciseRefCounts(isRecompute, setSlotNumbers);
+}
+
+//------------------------------------------------------------------------
+// lvaComputePreciseRefCounts: compute precise ref counts for locals by IR traversal
+//
+// Arguments:
+// isRecompute -- true if we just want ref counts and no other side effects;
+// false means to also look for true boolean locals, lay
+// groundwork for assertion prop, check type consistency, etc.
+// See lvaMarkLclRefs for details on what else goes on.
+// setSlotNumbers -- true if local slot numbers should be assigned.
+//
+// Notes:
+// See notes on lvaComputeRefCounts.
+//
+void Compiler::lvaComputePreciseRefCounts(bool isRecompute, bool setSlotNumbers)
+{
  // First, reset all explicit ref counts and weights.
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  varDsc->setLvRefCnt(0);
  varDsc->setLvRefCntWtd(BB_ZERO_WEIGHT);
 
@@ -3519,7 +3536,7 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  const bool oldLvaGenericsContextInUse = lvaGenericsContextInUse;
  lvaGenericsContextInUse = false;
 
- JITDUMP("\n*** lvaComputeRefCounts -- explicit counts ***\n");
+ JITDUMP("\n*** lvaComputePreciseRefCounts -- explicit counts ***\n");
 
  // Second, account for all explicit local variable references
  for (BasicBlock* const block : Blocks())
@@ -3577,11 +3594,12 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  assert(!"unexpected new use of generics context");
  }
 
- JITDUMP("\n*** lvaComputeRefCounts -- implicit counts ***\n");
+ JITDUMP("\n*** lvaComputePreciseRefCounts -- implicit counts ***\n");
 
  // Third, bump ref counts for some implicit prolog references
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  // Todo: review justification for these count bumps.
  if (varDsc->lvIsRegArg)
  {

src/coreclr/jit/liveness.cpp

@@ -55,6 +55,7 @@ class Liveness
  ComputeMemoryLiveness = false,
  IsLIR = false,
  IsEarly = false,
+ EliminateDeadCode = false,
  };
 
  Liveness(Compiler* compiler)
@@ -1965,16 +1966,19 @@ bool Liveness<TLiveness>::ComputeLifeTrackedLocalDef(VARSET_TP& life,
  // Dead store
  node->gtFlags |= GTF_VAR_DEATH;
 
- // keepAliveVars always stay alive
- noway_assert(!VarSetOps::IsMember(m_compiler, keepAliveVars, varIndex));
+ if (TLiveness::EliminateDeadCode)
+ {
+ // keepAliveVars always stay alive
+ noway_assert(!VarSetOps::IsMember(m_compiler, keepAliveVars, varIndex));
 
- // Do not consider this store dead if the target local variable represents
- // a promoted struct field of an address exposed local or if the address
- // of the variable has been exposed. Improved alias analysis could allow
- // stores to these sorts of variables to be removed at the cost of compile
- // time.
- return !varDsc.IsAddressExposed() &&
- !(varDsc.lvIsStructField && m_compiler->lvaTable[varDsc.lvParentLcl].IsAddressExposed());
+ // Do not consider this store dead if the target local variable represents
+ // a promoted struct field of an address exposed local or if the address
+ // of the variable has been exposed. Improved alias analysis could allow
+ // stores to these sorts of variables to be removed at the cost of compile
+ // time.
+ return !varDsc.IsAddressExposed() &&
+ !(varDsc.lvIsStructField && m_compiler->lvaTable[varDsc.lvParentLcl].IsAddressExposed());
+ }
  }
 
  return false;
@@ -2011,7 +2015,7 @@ bool Liveness<TLiveness>::ComputeLifeUntrackedLocal(VARSET_TP& life,
 
  // We have accurate ref counts when running late liveness so we can eliminate
  // some stores if the lhs local has a ref count of 1.
- if (isDef && TLiveness::IsLIR && (varDsc.lvRefCnt() == 1) && !varDsc.lvPinned)
+ if (TLiveness::EliminateDeadCode && TLiveness::IsLIR && isDef && (varDsc.lvRefCnt() == 1) && !varDsc.lvPinned)
  {
  if (varDsc.lvIsStructField)
  {
@@ -2083,7 +2087,7 @@ bool Liveness<TLiveness>::ComputeLifeUntrackedLocal(VARSET_TP& life,
  }
  }
 
- if (isDef && !anyFieldLive)
+ if (TLiveness::EliminateDeadCode && isDef && !anyFieldLive)
  {
  // Do not consider this store dead if the parent local variable is an address exposed local or
  // if the struct has any significant padding we must retain the value of.
@@ -2328,7 +2332,8 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  case GT_CALL:
  {
  GenTreeCall* const call = node->AsCall();
- if ((call->TypeIs(TYP_VOID) || call->IsUnusedValue()) && !call->HasSideEffects(m_compiler))
+ if (TLiveness::EliminateDeadCode && (call->TypeIs(TYP_VOID) || call->IsUnusedValue()) &&
+ !call->HasSideEffects(m_compiler))
  {
  JITDUMP("Removing dead call:\n");
  DISPNODE(call);
@@ -2375,13 +2380,13 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  GenTreeLclVarCommon* const lclVarNode = node->AsLclVarCommon();
  LclVarDsc& varDsc = m_compiler->lvaTable[lclVarNode->GetLclNum()];
 
- if (node->IsUnusedValue())
+ if (TLiveness::EliminateDeadCode && node->IsUnusedValue())
  {
  JITDUMP("Removing dead LclVar use:\n");
  DISPNODE(lclVarNode);
 
  blockRange.Delete(m_compiler, block, node);
- if (varDsc.lvTracked && !m_compiler->opts.MinOpts())
+ if (varDsc.lvTracked)
  {
  m_compiler->fgStmtRemoved = true;
  }
@@ -2398,14 +2403,14 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  }
 
  case GT_LCL_ADDR:
- if (node->IsUnusedValue())
+ if (TLiveness::EliminateDeadCode && node->IsUnusedValue())
  {
  JITDUMP("Removing dead LclVar address:\n");
  DISPNODE(node);
 
  const bool isTracked = m_compiler->lvaTable[node->AsLclVarCommon()->GetLclNum()].lvTracked;
  blockRange.Delete(m_compiler, block, node);
- if (isTracked && !m_compiler->opts.MinOpts())
+ if (isTracked)
  {
  m_compiler->fgStmtRemoved = true;
  }
@@ -2423,7 +2428,7 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  }
 
  isDeadStore = ComputeLifeLocal(life, keepAliveVars, node);
- if (isDeadStore)
+ if (TLiveness::EliminateDeadCode && isDeadStore)
  {
  LIR::Use addrUse;
  if (blockRange.TryGetUse(node, &addrUse) && addrUse.User()->OperIs(GT_STOREIND, GT_STORE_BLK))
@@ -2464,7 +2469,7 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  isDeadStore = ComputeLifeUntrackedLocal(life, keepAliveVars, varDsc, lclVarNode);
  }
 
- if (isDeadStore && TryRemoveDeadStoreLIR(node, lclVarNode, block))
+ if (TLiveness::EliminateDeadCode && isDeadStore && TryRemoveDeadStoreLIR(node, lclVarNode, block))
  {
  GenTree* value = lclVarNode->Data();
  value->SetUnusedValue();
@@ -2491,7 +2496,7 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
 #endif // FEATURE_MASKED_HW_INTRINSICS
  case GT_PHYSREG:
  // These are all side-effect-free leaf nodes.
- if (node->IsUnusedValue())
+ if (TLiveness::EliminateDeadCode && node->IsUnusedValue())
  {
  JITDUMP("Removing dead node:\n");
  DISPNODE(node);
@@ -2693,6 +2698,11 @@ bool Liveness<TLiveness>::TryRemoveDeadStoreLIR(GenTree* store, GenTreeLclVarCom
 template <typename TLiveness>
 bool Liveness<TLiveness>::TryRemoveNonLocalLIR(GenTree* node, LIR::Range* blockRange)
 {
+ if (!TLiveness::EliminateDeadCode)
+ {
+ return false;
+ }
+
  assert(!node->OperIsLocal());
  if (!node->IsValue() || node->IsUnusedValue())
  {
@@ -2816,6 +2826,7 @@ void Compiler::fgSsaLiveness()
  ComputeMemoryLiveness = true,
  IsLIR = false,
  IsEarly = false,
+ EliminateDeadCode = true,
  };
 
  SsaLivenessClass(Compiler* comp)
@@ -2841,6 +2852,7 @@ void Compiler::fgAsyncLiveness()
  ComputeMemoryLiveness = false,
  IsLIR = true,
  IsEarly = false,
+ EliminateDeadCode = false,
  };
 
  AsyncLiveness(Compiler* comp)
@@ -2866,6 +2878,7 @@ void Compiler::fgPostLowerLiveness()
  ComputeMemoryLiveness = false,
  IsLIR = true,
  IsEarly = false,
+ EliminateDeadCode = true,
  };
 
  PostLowerLiveness(Compiler* comp)
@@ -2909,6 +2922,7 @@ PhaseStatus Compiler::fgEarlyLiveness()
  ComputeMemoryLiveness = false,
  IsLIR = false,
  IsEarly = true,
+ EliminateDeadCode = true,
  };
 
  EarlyLiveness(Compiler* comp)

src/coreclr/jit/async.cpp

@@ -397,14 +397,12 @@ BasicBlock* Compiler::CreateReturnBB(unsigned* mergedReturnLcl)
 class AsyncLiveness
 {
  Compiler* m_compiler;
- bool m_hasLiveness;
  TreeLifeUpdater<false> m_updater;
  unsigned m_numVars;
 
 public:
- AsyncLiveness(Compiler* comp, bool hasLiveness)
+ AsyncLiveness(Compiler* comp)
  : m_compiler(comp)
- , m_hasLiveness(hasLiveness)
  , m_updater(comp)
  , m_numVars(comp->lvaCount)
  {
@@ -430,9 +428,6 @@ class AsyncLiveness
 //
 void AsyncLiveness::StartBlock(BasicBlock* block)
 {
- if (!m_hasLiveness)
- return;
-
  VarSetOps::Assign(m_compiler, m_compiler->compCurLife, block->bbLiveIn);
 }
 
@@ -446,9 +441,6 @@ void AsyncLiveness::StartBlock(BasicBlock* block)
 //
 void AsyncLiveness::Update(GenTree* node)
 {
- if (!m_hasLiveness)
- return;
-
  m_updater.UpdateLife(node);
 }
 
@@ -539,8 +531,9 @@ bool AsyncLiveness::IsLive(unsigned lclNum)
  return false;
  }
 
- if (!m_hasLiveness)
+ if (m_compiler->opts.compDbgCode && (lclNum < m_compiler->info.compLocalsCount))
  {
+ // Keep all IL locals in debug codegen
  return true;
  }
 
@@ -701,21 +694,18 @@ PhaseStatus AsyncTransformation::Run()
 #endif
 
  // Compute liveness to be used for determining what must be captured on
- // suspension. In unoptimized codegen we capture everything.
- if (m_compiler->opts.OptimizationEnabled())
+ // suspension.
+ if (m_compiler->m_dfsTree == nullptr)
  {
- if (m_compiler->m_dfsTree == nullptr)
- {
- m_compiler->m_dfsTree = m_compiler->fgComputeDfs<false>();
- }
-
- m_compiler->lvaComputeRefCounts(true, false);
- m_compiler->fgAsyncLiveness();
- INDEBUG(m_compiler->mostRecentlyActivePhase = PHASE_ASYNC);
- VarSetOps::AssignNoCopy(m_compiler, m_compiler->compCurLife, VarSetOps::MakeEmpty(m_compiler));
+ m_compiler->m_dfsTree = m_compiler->fgComputeDfs<false>();
  }
 
- AsyncLiveness liveness(m_compiler, m_compiler->opts.OptimizationEnabled());
+ m_compiler->lvaComputePreciseRefCounts(/* isRecompute */ true, /* setSlotNumbers */ false);
+ m_compiler->fgAsyncLiveness();
+ INDEBUG(m_compiler->mostRecentlyActivePhase = PHASE_ASYNC);
+ VarSetOps::AssignNoCopy(m_compiler, m_compiler->compCurLife, VarSetOps::MakeEmpty(m_compiler));
+
+ AsyncLiveness liveness(m_compiler);
 
  // Now walk the IR for all the blocks that contain async calls. Keep track
  // of liveness and outstanding LIR edges as we go; the LIR edges that cross
@@ -783,6 +773,28 @@ PhaseStatus AsyncTransformation::Run()
 
  m_compiler->fgInvalidateDfsTree();
 
+ if (m_compiler->opts.OptimizationDisabled())
+ {
+ // Rest of the compiler does not expect that we started tracking locals, so reset that state.
+ for (unsigned i = 0; i < m_compiler->lvaTrackedCount; i++)
+ {
+ m_compiler->lvaGetDesc(m_compiler->lvaTrackedToVarNum[i])->lvTracked = false;
+ }
+
+ m_compiler->lvaCurEpoch++;
+ m_compiler->lvaTrackedCount = 0;
+ m_compiler->lvaTrackedCountInSizeTUnits = 0;
+
+ for (BasicBlock* block : m_compiler->Blocks())
+ {
+ block->bbLiveIn = VarSetOps::UninitVal();
+ block->bbLiveOut = VarSetOps::UninitVal();
+ block->bbVarUse = VarSetOps::UninitVal();
+ block->bbVarDef = VarSetOps::UninitVal();
+ }
+ m_compiler->fgBBVarSetsInited = false;
+ }
+
  return PhaseStatus::MODIFIED_EVERYTHING;
 }
 

src/coreclr/jit/compiler.h

@@ -4214,6 +4214,7 @@ class Compiler
 
  PhaseStatus lvaMarkLocalVars(); // Local variable ref-counting
  void lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers);
+ void lvaComputePreciseRefCounts(bool isRecompute, bool setSlotNumbers);
  void lvaMarkLocalVars(BasicBlock* block);
 
  void lvaAllocOutgoingArgSpaceVar(); // Set up lvaOutgoingArgSpaceVar

src/coreclr/jit/lclvars.cpp

@@ -3415,8 +3415,6 @@ PhaseStatus Compiler::lvaMarkLocalVars()
 void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
 {
  JITDUMP("\n*** lvaComputeRefCounts ***\n");
- unsigned lclNum = 0;
- LclVarDsc* varDsc = nullptr;
 
  // Fast path for minopts and debug codegen.
  //
@@ -3430,8 +3428,9 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
 #if defined(DEBUG)
  // All local vars should be marked as implicitly referenced
  // and not tracked.
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  const bool isSpecialVarargsParam = varDsc->lvIsParam && lvaIsArgAccessedViaVarArgsCookie(lclNum);
 
  if (isSpecialVarargsParam)
@@ -3451,8 +3450,9 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  }
 
  // First compute.
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  // Using lvImplicitlyReferenced here ensures that we can't
  // accidentally make locals be unreferenced later by decrementing
  // the ref count to zero.
@@ -3488,11 +3488,28 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  return;
  }
 
- // Slower path we take when optimizing, to get accurate counts.
- //
+ lvaComputePreciseRefCounts(isRecompute, setSlotNumbers);
+}
+
+//------------------------------------------------------------------------
+// lvaComputePreciseRefCounts: compute precise ref counts for locals by IR traversal
+//
+// Arguments:
+// isRecompute -- true if we just want ref counts and no other side effects;
+// false means to also look for true boolean locals, lay
+// groundwork for assertion prop, check type consistency, etc.
+// See lvaMarkLclRefs for details on what else goes on.
+// setSlotNumbers -- true if local slot numbers should be assigned.
+//
+// Notes:
+// See notes on lvaComputeRefCounts.
+//
+void Compiler::lvaComputePreciseRefCounts(bool isRecompute, bool setSlotNumbers)
+{
  // First, reset all explicit ref counts and weights.
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  varDsc->setLvRefCnt(0);
  varDsc->setLvRefCntWtd(BB_ZERO_WEIGHT);
 
@@ -3519,7 +3536,7 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  const bool oldLvaGenericsContextInUse = lvaGenericsContextInUse;
  lvaGenericsContextInUse = false;
 
- JITDUMP("\n*** lvaComputeRefCounts -- explicit counts ***\n");
+ JITDUMP("\n*** lvaComputePreciseRefCounts -- explicit counts ***\n");
 
  // Second, account for all explicit local variable references
  for (BasicBlock* const block : Blocks())
@@ -3577,11 +3594,12 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  assert(!"unexpected new use of generics context");
  }
 
- JITDUMP("\n*** lvaComputeRefCounts -- implicit counts ***\n");
+ JITDUMP("\n*** lvaComputePreciseRefCounts -- implicit counts ***\n");
 
  // Third, bump ref counts for some implicit prolog references
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  // Todo: review justification for these count bumps.
  if (varDsc->lvIsRegArg)
  {

src/coreclr/jit/liveness.cpp

@@ -55,6 +55,7 @@ class Liveness
  ComputeMemoryLiveness = false,
  IsLIR = false,
  IsEarly = false,
+ EliminateDeadCode = false,
  };
 
  Liveness(Compiler* compiler)
@@ -1965,16 +1966,19 @@ bool Liveness<TLiveness>::ComputeLifeTrackedLocalDef(VARSET_TP& life,
  // Dead store
  node->gtFlags |= GTF_VAR_DEATH;
 
- // keepAliveVars always stay alive
- noway_assert(!VarSetOps::IsMember(m_compiler, keepAliveVars, varIndex));
+ if (TLiveness::EliminateDeadCode)
+ {
+ // keepAliveVars always stay alive
+ noway_assert(!VarSetOps::IsMember(m_compiler, keepAliveVars, varIndex));
 
- // Do not consider this store dead if the target local variable represents
- // a promoted struct field of an address exposed local or if the address
- // of the variable has been exposed. Improved alias analysis could allow
- // stores to these sorts of variables to be removed at the cost of compile
- // time.
- return !varDsc.IsAddressExposed() &&
- !(varDsc.lvIsStructField && m_compiler->lvaTable[varDsc.lvParentLcl].IsAddressExposed());
+ // Do not consider this store dead if the target local variable represents
+ // a promoted struct field of an address exposed local or if the address
+ // of the variable has been exposed. Improved alias analysis could allow
+ // stores to these sorts of variables to be removed at the cost of compile
+ // time.
+ return !varDsc.IsAddressExposed() &&
+ !(varDsc.lvIsStructField && m_compiler->lvaTable[varDsc.lvParentLcl].IsAddressExposed());
+ }
  }
 
  return false;
@@ -2011,7 +2015,7 @@ bool Liveness<TLiveness>::ComputeLifeUntrackedLocal(VARSET_TP& life,
 
  // We have accurate ref counts when running late liveness so we can eliminate
  // some stores if the lhs local has a ref count of 1.
- if (isDef && TLiveness::IsLIR && (varDsc.lvRefCnt() == 1) && !varDsc.lvPinned)
+ if (TLiveness::EliminateDeadCode && TLiveness::IsLIR && isDef && (varDsc.lvRefCnt() == 1) && !varDsc.lvPinned)
  {
  if (varDsc.lvIsStructField)
  {
@@ -2083,7 +2087,7 @@ bool Liveness<TLiveness>::ComputeLifeUntrackedLocal(VARSET_TP& life,
  }
  }
 
- if (isDef && !anyFieldLive)
+ if (TLiveness::EliminateDeadCode && isDef && !anyFieldLive)
  {
  // Do not consider this store dead if the parent local variable is an address exposed local or
  // if the struct has any significant padding we must retain the value of.
@@ -2328,7 +2332,8 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  case GT_CALL:
  {
  GenTreeCall* const call = node->AsCall();
- if ((call->TypeIs(TYP_VOID) || call->IsUnusedValue()) && !call->HasSideEffects(m_compiler))
+ if (TLiveness::EliminateDeadCode && (call->TypeIs(TYP_VOID) || call->IsUnusedValue()) &&
+ !call->HasSideEffects(m_compiler))
  {
  JITDUMP("Removing dead call:\n");
  DISPNODE(call);
@@ -2375,13 +2380,13 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  GenTreeLclVarCommon* const lclVarNode = node->AsLclVarCommon();
  LclVarDsc& varDsc = m_compiler->lvaTable[lclVarNode->GetLclNum()];
 
- if (node->IsUnusedValue())
+ if (TLiveness::EliminateDeadCode && node->IsUnusedValue())
  {
  JITDUMP("Removing dead LclVar use:\n");
  DISPNODE(lclVarNode);
 
  blockRange.Delete(m_compiler, block, node);
- if (varDsc.lvTracked && !m_compiler->opts.MinOpts())
+ if (varDsc.lvTracked)
  {
  m_compiler->fgStmtRemoved = true;
  }
@@ -2398,14 +2403,14 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  }
 
  case GT_LCL_ADDR:
- if (node->IsUnusedValue())
+ if (TLiveness::EliminateDeadCode && node->IsUnusedValue())
  {
  JITDUMP("Removing dead LclVar address:\n");
  DISPNODE(node);
 
  const bool isTracked = m_compiler->lvaTable[node->AsLclVarCommon()->GetLclNum()].lvTracked;
  blockRange.Delete(m_compiler, block, node);
- if (isTracked && !m_compiler->opts.MinOpts())
+ if (isTracked)
  {
  m_compiler->fgStmtRemoved = true;
  }
@@ -2423,7 +2428,7 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  }
 
  isDeadStore = ComputeLifeLocal(life, keepAliveVars, node);
- if (isDeadStore)
+ if (TLiveness::EliminateDeadCode && isDeadStore)
  {
  LIR::Use addrUse;
  if (blockRange.TryGetUse(node, &addrUse) && addrUse.User()->OperIs(GT_STOREIND, GT_STORE_BLK))
@@ -2464,7 +2469,7 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  isDeadStore = ComputeLifeUntrackedLocal(life, keepAliveVars, varDsc, lclVarNode);
  }
 
- if (isDeadStore && TryRemoveDeadStoreLIR(node, lclVarNode, block))
+ if (TLiveness::EliminateDeadCode && isDeadStore && TryRemoveDeadStoreLIR(node, lclVarNode, block))
  {
  GenTree* value = lclVarNode->Data();
  value->SetUnusedValue();
@@ -2491,7 +2496,7 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
 #endif // FEATURE_MASKED_HW_INTRINSICS
  case GT_PHYSREG:
  // These are all side-effect-free leaf nodes.
- if (node->IsUnusedValue())
+ if (TLiveness::EliminateDeadCode && node->IsUnusedValue())
  {
  JITDUMP("Removing dead node:\n");
  DISPNODE(node);
@@ -2693,6 +2698,11 @@ bool Liveness<TLiveness>::TryRemoveDeadStoreLIR(GenTree* store, GenTreeLclVarCom
 template <typename TLiveness>
 bool Liveness<TLiveness>::TryRemoveNonLocalLIR(GenTree* node, LIR::Range* blockRange)
 {
+ if (!TLiveness::EliminateDeadCode)
+ {
+ return false;
+ }
+
  assert(!node->OperIsLocal());
  if (!node->IsValue() || node->IsUnusedValue())
  {
@@ -2816,6 +2826,7 @@ void Compiler::fgSsaLiveness()
  ComputeMemoryLiveness = true,
  IsLIR = false,
  IsEarly = false,
+ EliminateDeadCode = true,
  };
 
  SsaLivenessClass(Compiler* comp)
@@ -2841,6 +2852,7 @@ void Compiler::fgAsyncLiveness()
  ComputeMemoryLiveness = false,
  IsLIR = true,
  IsEarly = false,
+ EliminateDeadCode = false,
  };
 
  AsyncLiveness(Compiler* comp)
@@ -2866,6 +2878,7 @@ void Compiler::fgPostLowerLiveness()
  ComputeMemoryLiveness = false,
  IsLIR = true,
  IsEarly = false,
+ EliminateDeadCode = true,
  };
 
  PostLowerLiveness(Compiler* comp)
@@ -2909,6 +2922,7 @@ PhaseStatus Compiler::fgEarlyLiveness()
  ComputeMemoryLiveness = false,
  IsLIR = false,
  IsEarly = true,
+ EliminateDeadCode = true,
  };
 
  EarlyLiveness(Compiler* comp)

src/coreclr/jit/async.cpp

@@ -397,14 +397,12 @@ BasicBlock* Compiler::CreateReturnBB(unsigned* mergedReturnLcl)
 class AsyncLiveness
 {
  Compiler* m_compiler;
- bool m_hasLiveness;
  TreeLifeUpdater<false> m_updater;
  unsigned m_numVars;
 
 public:
- AsyncLiveness(Compiler* comp, bool hasLiveness)
+ AsyncLiveness(Compiler* comp)
  : m_compiler(comp)
- , m_hasLiveness(hasLiveness)
  , m_updater(comp)
  , m_numVars(comp->lvaCount)
  {
@@ -430,9 +428,6 @@ class AsyncLiveness
 //
 void AsyncLiveness::StartBlock(BasicBlock* block)
 {
- if (!m_hasLiveness)
- return;
-
  VarSetOps::Assign(m_compiler, m_compiler->compCurLife, block->bbLiveIn);
 }
 
@@ -446,9 +441,6 @@ void AsyncLiveness::StartBlock(BasicBlock* block)
 //
 void AsyncLiveness::Update(GenTree* node)
 {
- if (!m_hasLiveness)
- return;
-
  m_updater.UpdateLife(node);
 }
 
@@ -539,8 +531,9 @@ bool AsyncLiveness::IsLive(unsigned lclNum)
  return false;
  }
 
- if (!m_hasLiveness)
+ if (m_compiler->opts.compDbgCode && (lclNum < m_compiler->info.compLocalsCount))
  {
+ // Keep all IL locals in debug codegen
  return true;
  }
 
@@ -701,21 +694,18 @@ PhaseStatus AsyncTransformation::Run()
 #endif
 
  // Compute liveness to be used for determining what must be captured on
- // suspension. In unoptimized codegen we capture everything.
- if (m_compiler->opts.OptimizationEnabled())
+ // suspension.
+ if (m_compiler->m_dfsTree == nullptr)
  {
- if (m_compiler->m_dfsTree == nullptr)
- {
- m_compiler->m_dfsTree = m_compiler->fgComputeDfs<false>();
- }
-
- m_compiler->lvaComputeRefCounts(true, false);
- m_compiler->fgAsyncLiveness();
- INDEBUG(m_compiler->mostRecentlyActivePhase = PHASE_ASYNC);
- VarSetOps::AssignNoCopy(m_compiler, m_compiler->compCurLife, VarSetOps::MakeEmpty(m_compiler));
+ m_compiler->m_dfsTree = m_compiler->fgComputeDfs<false>();
  }
 
- AsyncLiveness liveness(m_compiler, m_compiler->opts.OptimizationEnabled());
+ m_compiler->lvaComputePreciseRefCounts(/* isRecompute */ true, /* setSlotNumbers */ false);
+ m_compiler->fgAsyncLiveness();
+ INDEBUG(m_compiler->mostRecentlyActivePhase = PHASE_ASYNC);
+ VarSetOps::AssignNoCopy(m_compiler, m_compiler->compCurLife, VarSetOps::MakeEmpty(m_compiler));
+
+ AsyncLiveness liveness(m_compiler);
 
  // Now walk the IR for all the blocks that contain async calls. Keep track
  // of liveness and outstanding LIR edges as we go; the LIR edges that cross
@@ -783,6 +773,28 @@ PhaseStatus AsyncTransformation::Run()
 
  m_compiler->fgInvalidateDfsTree();
 
+ if (m_compiler->opts.OptimizationDisabled())
+ {
+ // Rest of the compiler does not expect that we started tracking locals, so reset that state.
+ for (unsigned i = 0; i < m_compiler->lvaTrackedCount; i++)
+ {
+ m_compiler->lvaGetDesc(m_compiler->lvaTrackedToVarNum[i])->lvTracked = false;
+ }
+
+ m_compiler->lvaCurEpoch++;
+ m_compiler->lvaTrackedCount = 0;
+ m_compiler->lvaTrackedCountInSizeTUnits = 0;
+
+ for (BasicBlock* block : m_compiler->Blocks())
+ {
+ block->bbLiveIn = VarSetOps::UninitVal();
+ block->bbLiveOut = VarSetOps::UninitVal();
+ block->bbVarUse = VarSetOps::UninitVal();
+ block->bbVarDef = VarSetOps::UninitVal();
+ }
+ m_compiler->fgBBVarSetsInited = false;
+ }
+
  return PhaseStatus::MODIFIED_EVERYTHING;
 }
 

src/coreclr/jit/compiler.h

@@ -4214,6 +4214,7 @@ class Compiler
 
  PhaseStatus lvaMarkLocalVars(); // Local variable ref-counting
  void lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers);
+ void lvaComputePreciseRefCounts(bool isRecompute, bool setSlotNumbers);
  void lvaMarkLocalVars(BasicBlock* block);
 
  void lvaAllocOutgoingArgSpaceVar(); // Set up lvaOutgoingArgSpaceVar

src/coreclr/jit/lclvars.cpp

@@ -3415,8 +3415,6 @@ PhaseStatus Compiler::lvaMarkLocalVars()
 void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
 {
  JITDUMP("\n*** lvaComputeRefCounts ***\n");
- unsigned lclNum = 0;
- LclVarDsc* varDsc = nullptr;
 
  // Fast path for minopts and debug codegen.
  //
@@ -3430,8 +3428,9 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
 #if defined(DEBUG)
  // All local vars should be marked as implicitly referenced
  // and not tracked.
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  const bool isSpecialVarargsParam = varDsc->lvIsParam && lvaIsArgAccessedViaVarArgsCookie(lclNum);
 
  if (isSpecialVarargsParam)
@@ -3451,8 +3450,9 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  }
 
  // First compute.
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  // Using lvImplicitlyReferenced here ensures that we can't
  // accidentally make locals be unreferenced later by decrementing
  // the ref count to zero.
@@ -3488,11 +3488,28 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  return;
  }
 
- // Slower path we take when optimizing, to get accurate counts.
- //
+ lvaComputePreciseRefCounts(isRecompute, setSlotNumbers);
+}
+
+//------------------------------------------------------------------------
+// lvaComputePreciseRefCounts: compute precise ref counts for locals by IR traversal
+//
+// Arguments:
+// isRecompute -- true if we just want ref counts and no other side effects;
+// false means to also look for true boolean locals, lay
+// groundwork for assertion prop, check type consistency, etc.
+// See lvaMarkLclRefs for details on what else goes on.
+// setSlotNumbers -- true if local slot numbers should be assigned.
+//
+// Notes:
+// See notes on lvaComputeRefCounts.
+//
+void Compiler::lvaComputePreciseRefCounts(bool isRecompute, bool setSlotNumbers)
+{
  // First, reset all explicit ref counts and weights.
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  varDsc->setLvRefCnt(0);
  varDsc->setLvRefCntWtd(BB_ZERO_WEIGHT);
 
@@ -3519,7 +3536,7 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  const bool oldLvaGenericsContextInUse = lvaGenericsContextInUse;
  lvaGenericsContextInUse = false;
 
- JITDUMP("\n*** lvaComputeRefCounts -- explicit counts ***\n");
+ JITDUMP("\n*** lvaComputePreciseRefCounts -- explicit counts ***\n");
 
  // Second, account for all explicit local variable references
  for (BasicBlock* const block : Blocks())
@@ -3577,11 +3594,12 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  assert(!"unexpected new use of generics context");
  }
 
- JITDUMP("\n*** lvaComputeRefCounts -- implicit counts ***\n");
+ JITDUMP("\n*** lvaComputePreciseRefCounts -- implicit counts ***\n");
 
  // Third, bump ref counts for some implicit prolog references
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  // Todo: review justification for these count bumps.
  if (varDsc->lvIsRegArg)
  {

src/coreclr/jit/liveness.cpp

@@ -55,6 +55,7 @@ class Liveness
  ComputeMemoryLiveness = false,
  IsLIR = false,
  IsEarly = false,
+ EliminateDeadCode = false,
  };
 
  Liveness(Compiler* compiler)
@@ -1965,16 +1966,19 @@ bool Liveness<TLiveness>::ComputeLifeTrackedLocalDef(VARSET_TP& life,
  // Dead store
  node->gtFlags |= GTF_VAR_DEATH;
 
- // keepAliveVars always stay alive
- noway_assert(!VarSetOps::IsMember(m_compiler, keepAliveVars, varIndex));
+ if (TLiveness::EliminateDeadCode)
+ {
+ // keepAliveVars always stay alive
+ noway_assert(!VarSetOps::IsMember(m_compiler, keepAliveVars, varIndex));
 
- // Do not consider this store dead if the target local variable represents
- // a promoted struct field of an address exposed local or if the address
- // of the variable has been exposed. Improved alias analysis could allow
- // stores to these sorts of variables to be removed at the cost of compile
- // time.
- return !varDsc.IsAddressExposed() &&
- !(varDsc.lvIsStructField && m_compiler->lvaTable[varDsc.lvParentLcl].IsAddressExposed());
+ // Do not consider this store dead if the target local variable represents
+ // a promoted struct field of an address exposed local or if the address
+ // of the variable has been exposed. Improved alias analysis could allow
+ // stores to these sorts of variables to be removed at the cost of compile
+ // time.
+ return !varDsc.IsAddressExposed() &&
+ !(varDsc.lvIsStructField && m_compiler->lvaTable[varDsc.lvParentLcl].IsAddressExposed());
+ }
  }
 
  return false;
@@ -2011,7 +2015,7 @@ bool Liveness<TLiveness>::ComputeLifeUntrackedLocal(VARSET_TP& life,
 
  // We have accurate ref counts when running late liveness so we can eliminate
  // some stores if the lhs local has a ref count of 1.
- if (isDef && TLiveness::IsLIR && (varDsc.lvRefCnt() == 1) && !varDsc.lvPinned)
+ if (TLiveness::EliminateDeadCode && TLiveness::IsLIR && isDef && (varDsc.lvRefCnt() == 1) && !varDsc.lvPinned)
  {
  if (varDsc.lvIsStructField)
  {
@@ -2083,7 +2087,7 @@ bool Liveness<TLiveness>::ComputeLifeUntrackedLocal(VARSET_TP& life,
  }
  }
 
- if (isDef && !anyFieldLive)
+ if (TLiveness::EliminateDeadCode && isDef && !anyFieldLive)
  {
  // Do not consider this store dead if the parent local variable is an address exposed local or
  // if the struct has any significant padding we must retain the value of.
@@ -2328,7 +2332,8 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  case GT_CALL:
  {
  GenTreeCall* const call = node->AsCall();
- if ((call->TypeIs(TYP_VOID) || call->IsUnusedValue()) && !call->HasSideEffects(m_compiler))
+ if (TLiveness::EliminateDeadCode && (call->TypeIs(TYP_VOID) || call->IsUnusedValue()) &&
+ !call->HasSideEffects(m_compiler))
  {
  JITDUMP("Removing dead call:\n");
  DISPNODE(call);
@@ -2375,13 +2380,13 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  GenTreeLclVarCommon* const lclVarNode = node->AsLclVarCommon();
  LclVarDsc& varDsc = m_compiler->lvaTable[lclVarNode->GetLclNum()];
 
- if (node->IsUnusedValue())
+ if (TLiveness::EliminateDeadCode && node->IsUnusedValue())
  {
  JITDUMP("Removing dead LclVar use:\n");
  DISPNODE(lclVarNode);
 
  blockRange.Delete(m_compiler, block, node);
- if (varDsc.lvTracked && !m_compiler->opts.MinOpts())
+ if (varDsc.lvTracked)
  {
  m_compiler->fgStmtRemoved = true;
  }
@@ -2398,14 +2403,14 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  }
 
  case GT_LCL_ADDR:
- if (node->IsUnusedValue())
+ if (TLiveness::EliminateDeadCode && node->IsUnusedValue())
  {
  JITDUMP("Removing dead LclVar address:\n");
  DISPNODE(node);
 
  const bool isTracked = m_compiler->lvaTable[node->AsLclVarCommon()->GetLclNum()].lvTracked;
  blockRange.Delete(m_compiler, block, node);
- if (isTracked && !m_compiler->opts.MinOpts())
+ if (isTracked)
  {
  m_compiler->fgStmtRemoved = true;
  }
@@ -2423,7 +2428,7 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  }
 
  isDeadStore = ComputeLifeLocal(life, keepAliveVars, node);
- if (isDeadStore)
+ if (TLiveness::EliminateDeadCode && isDeadStore)
  {
  LIR::Use addrUse;
  if (blockRange.TryGetUse(node, &addrUse) && addrUse.User()->OperIs(GT_STOREIND, GT_STORE_BLK))
@@ -2464,7 +2469,7 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  isDeadStore = ComputeLifeUntrackedLocal(life, keepAliveVars, varDsc, lclVarNode);
  }
 
- if (isDeadStore && TryRemoveDeadStoreLIR(node, lclVarNode, block))
+ if (TLiveness::EliminateDeadCode && isDeadStore && TryRemoveDeadStoreLIR(node, lclVarNode, block))
  {
  GenTree* value = lclVarNode->Data();
  value->SetUnusedValue();
@@ -2491,7 +2496,7 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
 #endif // FEATURE_MASKED_HW_INTRINSICS
  case GT_PHYSREG:
  // These are all side-effect-free leaf nodes.
- if (node->IsUnusedValue())
+ if (TLiveness::EliminateDeadCode && node->IsUnusedValue())
  {
  JITDUMP("Removing dead node:\n");
  DISPNODE(node);
@@ -2693,6 +2698,11 @@ bool Liveness<TLiveness>::TryRemoveDeadStoreLIR(GenTree* store, GenTreeLclVarCom
 template <typename TLiveness>
 bool Liveness<TLiveness>::TryRemoveNonLocalLIR(GenTree* node, LIR::Range* blockRange)
 {
+ if (!TLiveness::EliminateDeadCode)
+ {
+ return false;
+ }
+
  assert(!node->OperIsLocal());
  if (!node->IsValue() || node->IsUnusedValue())
  {
@@ -2816,6 +2826,7 @@ void Compiler::fgSsaLiveness()
  ComputeMemoryLiveness = true,
  IsLIR = false,
  IsEarly = false,
+ EliminateDeadCode = true,
  };
 
  SsaLivenessClass(Compiler* comp)
@@ -2841,6 +2852,7 @@ void Compiler::fgAsyncLiveness()
  ComputeMemoryLiveness = false,
  IsLIR = true,
  IsEarly = false,
+ EliminateDeadCode = false,
  };
 
  AsyncLiveness(Compiler* comp)
@@ -2866,6 +2878,7 @@ void Compiler::fgPostLowerLiveness()
  ComputeMemoryLiveness = false,
  IsLIR = true,
  IsEarly = false,
+ EliminateDeadCode = true,
  };
 
  PostLowerLiveness(Compiler* comp)
@@ -2909,6 +2922,7 @@ PhaseStatus Compiler::fgEarlyLiveness()
  ComputeMemoryLiveness = false,
  IsLIR = false,
  IsEarly = true,
+ EliminateDeadCode = true,
  };
 
  EarlyLiveness(Compiler* comp)

src/coreclr/jit/async.cpp

@@ -397,14 +397,12 @@ BasicBlock* Compiler::CreateReturnBB(unsigned* mergedReturnLcl)
 class AsyncLiveness
 {
  Compiler* m_compiler;
- bool m_hasLiveness;
  TreeLifeUpdater<false> m_updater;
  unsigned m_numVars;
 
 public:
- AsyncLiveness(Compiler* comp, bool hasLiveness)
+ AsyncLiveness(Compiler* comp)
  : m_compiler(comp)
- , m_hasLiveness(hasLiveness)
  , m_updater(comp)
  , m_numVars(comp->lvaCount)
  {
@@ -430,9 +428,6 @@ class AsyncLiveness
 //
 void AsyncLiveness::StartBlock(BasicBlock* block)
 {
- if (!m_hasLiveness)
- return;
-
  VarSetOps::Assign(m_compiler, m_compiler->compCurLife, block->bbLiveIn);
 }
 
@@ -446,9 +441,6 @@ void AsyncLiveness::StartBlock(BasicBlock* block)
 //
 void AsyncLiveness::Update(GenTree* node)
 {
- if (!m_hasLiveness)
- return;
-
  m_updater.UpdateLife(node);
 }
 
@@ -539,8 +531,9 @@ bool AsyncLiveness::IsLive(unsigned lclNum)
  return false;
  }
 
- if (!m_hasLiveness)
+ if (m_compiler->opts.compDbgCode && (lclNum < m_compiler->info.compLocalsCount))
  {
+ // Keep all IL locals in debug codegen
  return true;
  }
 
@@ -701,21 +694,18 @@ PhaseStatus AsyncTransformation::Run()
 #endif
 
  // Compute liveness to be used for determining what must be captured on
- // suspension. In unoptimized codegen we capture everything.
- if (m_compiler->opts.OptimizationEnabled())
+ // suspension.
+ if (m_compiler->m_dfsTree == nullptr)
  {
- if (m_compiler->m_dfsTree == nullptr)
- {
- m_compiler->m_dfsTree = m_compiler->fgComputeDfs<false>();
- }
-
- m_compiler->lvaComputeRefCounts(true, false);
- m_compiler->fgAsyncLiveness();
- INDEBUG(m_compiler->mostRecentlyActivePhase = PHASE_ASYNC);
- VarSetOps::AssignNoCopy(m_compiler, m_compiler->compCurLife, VarSetOps::MakeEmpty(m_compiler));
+ m_compiler->m_dfsTree = m_compiler->fgComputeDfs<false>();
  }
 
- AsyncLiveness liveness(m_compiler, m_compiler->opts.OptimizationEnabled());
+ m_compiler->lvaComputePreciseRefCounts(/* isRecompute */ true, /* setSlotNumbers */ false);
+ m_compiler->fgAsyncLiveness();
+ INDEBUG(m_compiler->mostRecentlyActivePhase = PHASE_ASYNC);
+ VarSetOps::AssignNoCopy(m_compiler, m_compiler->compCurLife, VarSetOps::MakeEmpty(m_compiler));
+
+ AsyncLiveness liveness(m_compiler);
 
  // Now walk the IR for all the blocks that contain async calls. Keep track
  // of liveness and outstanding LIR edges as we go; the LIR edges that cross
@@ -783,6 +773,28 @@ PhaseStatus AsyncTransformation::Run()
 
  m_compiler->fgInvalidateDfsTree();
 
+ if (m_compiler->opts.OptimizationDisabled())
+ {
+ // Rest of the compiler does not expect that we started tracking locals, so reset that state.
+ for (unsigned i = 0; i < m_compiler->lvaTrackedCount; i++)
+ {
+ m_compiler->lvaGetDesc(m_compiler->lvaTrackedToVarNum[i])->lvTracked = false;
+ }
+
+ m_compiler->lvaCurEpoch++;
+ m_compiler->lvaTrackedCount = 0;
+ m_compiler->lvaTrackedCountInSizeTUnits = 0;
+
+ for (BasicBlock* block : m_compiler->Blocks())
+ {
+ block->bbLiveIn = VarSetOps::UninitVal();
+ block->bbLiveOut = VarSetOps::UninitVal();
+ block->bbVarUse = VarSetOps::UninitVal();
+ block->bbVarDef = VarSetOps::UninitVal();
+ }
+ m_compiler->fgBBVarSetsInited = false;
+ }
+
  return PhaseStatus::MODIFIED_EVERYTHING;
 }
 

src/coreclr/jit/compiler.h

@@ -4214,6 +4214,7 @@ class Compiler
 
  PhaseStatus lvaMarkLocalVars(); // Local variable ref-counting
  void lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers);
+ void lvaComputePreciseRefCounts(bool isRecompute, bool setSlotNumbers);
  void lvaMarkLocalVars(BasicBlock* block);
 
  void lvaAllocOutgoingArgSpaceVar(); // Set up lvaOutgoingArgSpaceVar

src/coreclr/jit/lclvars.cpp

@@ -3415,8 +3415,6 @@ PhaseStatus Compiler::lvaMarkLocalVars()
 void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
 {
  JITDUMP("\n*** lvaComputeRefCounts ***\n");
- unsigned lclNum = 0;
- LclVarDsc* varDsc = nullptr;
 
  // Fast path for minopts and debug codegen.
  //
@@ -3430,8 +3428,9 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
 #if defined(DEBUG)
  // All local vars should be marked as implicitly referenced
  // and not tracked.
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  const bool isSpecialVarargsParam = varDsc->lvIsParam && lvaIsArgAccessedViaVarArgsCookie(lclNum);
 
  if (isSpecialVarargsParam)
@@ -3451,8 +3450,9 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  }
 
  // First compute.
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  // Using lvImplicitlyReferenced here ensures that we can't
  // accidentally make locals be unreferenced later by decrementing
  // the ref count to zero.
@@ -3488,11 +3488,28 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  return;
  }
 
- // Slower path we take when optimizing, to get accurate counts.
- //
+ lvaComputePreciseRefCounts(isRecompute, setSlotNumbers);
+}
+
+//------------------------------------------------------------------------
+// lvaComputePreciseRefCounts: compute precise ref counts for locals by IR traversal
+//
+// Arguments:
+// isRecompute -- true if we just want ref counts and no other side effects;
+// false means to also look for true boolean locals, lay
+// groundwork for assertion prop, check type consistency, etc.
+// See lvaMarkLclRefs for details on what else goes on.
+// setSlotNumbers -- true if local slot numbers should be assigned.
+//
+// Notes:
+// See notes on lvaComputeRefCounts.
+//
+void Compiler::lvaComputePreciseRefCounts(bool isRecompute, bool setSlotNumbers)
+{
  // First, reset all explicit ref counts and weights.
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  varDsc->setLvRefCnt(0);
  varDsc->setLvRefCntWtd(BB_ZERO_WEIGHT);
 
@@ -3519,7 +3536,7 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  const bool oldLvaGenericsContextInUse = lvaGenericsContextInUse;
  lvaGenericsContextInUse = false;
 
- JITDUMP("\n*** lvaComputeRefCounts -- explicit counts ***\n");
+ JITDUMP("\n*** lvaComputePreciseRefCounts -- explicit counts ***\n");
 
  // Second, account for all explicit local variable references
  for (BasicBlock* const block : Blocks())
@@ -3577,11 +3594,12 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  assert(!"unexpected new use of generics context");
  }
 
- JITDUMP("\n*** lvaComputeRefCounts -- implicit counts ***\n");
+ JITDUMP("\n*** lvaComputePreciseRefCounts -- implicit counts ***\n");
 
  // Third, bump ref counts for some implicit prolog references
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  // Todo: review justification for these count bumps.
  if (varDsc->lvIsRegArg)
  {

src/coreclr/jit/liveness.cpp

@@ -55,6 +55,7 @@ class Liveness
  ComputeMemoryLiveness = false,
  IsLIR = false,
  IsEarly = false,
+ EliminateDeadCode = false,
  };
 
  Liveness(Compiler* compiler)
@@ -1965,16 +1966,19 @@ bool Liveness<TLiveness>::ComputeLifeTrackedLocalDef(VARSET_TP& life,
  // Dead store
  node->gtFlags |= GTF_VAR_DEATH;
 
- // keepAliveVars always stay alive
- noway_assert(!VarSetOps::IsMember(m_compiler, keepAliveVars, varIndex));
+ if (TLiveness::EliminateDeadCode)
+ {
+ // keepAliveVars always stay alive
+ noway_assert(!VarSetOps::IsMember(m_compiler, keepAliveVars, varIndex));
 
- // Do not consider this store dead if the target local variable represents
- // a promoted struct field of an address exposed local or if the address
- // of the variable has been exposed. Improved alias analysis could allow
- // stores to these sorts of variables to be removed at the cost of compile
- // time.
- return !varDsc.IsAddressExposed() &&
- !(varDsc.lvIsStructField && m_compiler->lvaTable[varDsc.lvParentLcl].IsAddressExposed());
+ // Do not consider this store dead if the target local variable represents
+ // a promoted struct field of an address exposed local or if the address
+ // of the variable has been exposed. Improved alias analysis could allow
+ // stores to these sorts of variables to be removed at the cost of compile
+ // time.
+ return !varDsc.IsAddressExposed() &&
+ !(varDsc.lvIsStructField && m_compiler->lvaTable[varDsc.lvParentLcl].IsAddressExposed());
+ }
  }
 
  return false;
@@ -2011,7 +2015,7 @@ bool Liveness<TLiveness>::ComputeLifeUntrackedLocal(VARSET_TP& life,
 
  // We have accurate ref counts when running late liveness so we can eliminate
  // some stores if the lhs local has a ref count of 1.
- if (isDef && TLiveness::IsLIR && (varDsc.lvRefCnt() == 1) && !varDsc.lvPinned)
+ if (TLiveness::EliminateDeadCode && TLiveness::IsLIR && isDef && (varDsc.lvRefCnt() == 1) && !varDsc.lvPinned)
  {
  if (varDsc.lvIsStructField)
  {
@@ -2083,7 +2087,7 @@ bool Liveness<TLiveness>::ComputeLifeUntrackedLocal(VARSET_TP& life,
  }
  }
 
- if (isDef && !anyFieldLive)
+ if (TLiveness::EliminateDeadCode && isDef && !anyFieldLive)
  {
  // Do not consider this store dead if the parent local variable is an address exposed local or
  // if the struct has any significant padding we must retain the value of.
@@ -2328,7 +2332,8 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  case GT_CALL:
  {
  GenTreeCall* const call = node->AsCall();
- if ((call->TypeIs(TYP_VOID) || call->IsUnusedValue()) && !call->HasSideEffects(m_compiler))
+ if (TLiveness::EliminateDeadCode && (call->TypeIs(TYP_VOID) || call->IsUnusedValue()) &&
+ !call->HasSideEffects(m_compiler))
  {
  JITDUMP("Removing dead call:\n");
  DISPNODE(call);
@@ -2375,13 +2380,13 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  GenTreeLclVarCommon* const lclVarNode = node->AsLclVarCommon();
  LclVarDsc& varDsc = m_compiler->lvaTable[lclVarNode->GetLclNum()];
 
- if (node->IsUnusedValue())
+ if (TLiveness::EliminateDeadCode && node->IsUnusedValue())
  {
  JITDUMP("Removing dead LclVar use:\n");
  DISPNODE(lclVarNode);
 
  blockRange.Delete(m_compiler, block, node);
- if (varDsc.lvTracked && !m_compiler->opts.MinOpts())
+ if (varDsc.lvTracked)
  {
  m_compiler->fgStmtRemoved = true;
  }
@@ -2398,14 +2403,14 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  }
 
  case GT_LCL_ADDR:
- if (node->IsUnusedValue())
+ if (TLiveness::EliminateDeadCode && node->IsUnusedValue())
  {
  JITDUMP("Removing dead LclVar address:\n");
  DISPNODE(node);
 
  const bool isTracked = m_compiler->lvaTable[node->AsLclVarCommon()->GetLclNum()].lvTracked;
  blockRange.Delete(m_compiler, block, node);
- if (isTracked && !m_compiler->opts.MinOpts())
+ if (isTracked)
  {
  m_compiler->fgStmtRemoved = true;
  }
@@ -2423,7 +2428,7 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  }
 
  isDeadStore = ComputeLifeLocal(life, keepAliveVars, node);
- if (isDeadStore)
+ if (TLiveness::EliminateDeadCode && isDeadStore)
  {
  LIR::Use addrUse;
  if (blockRange.TryGetUse(node, &addrUse) && addrUse.User()->OperIs(GT_STOREIND, GT_STORE_BLK))
@@ -2464,7 +2469,7 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  isDeadStore = ComputeLifeUntrackedLocal(life, keepAliveVars, varDsc, lclVarNode);
  }
 
- if (isDeadStore && TryRemoveDeadStoreLIR(node, lclVarNode, block))
+ if (TLiveness::EliminateDeadCode && isDeadStore && TryRemoveDeadStoreLIR(node, lclVarNode, block))
  {
  GenTree* value = lclVarNode->Data();
  value->SetUnusedValue();
@@ -2491,7 +2496,7 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
 #endif // FEATURE_MASKED_HW_INTRINSICS
  case GT_PHYSREG:
  // These are all side-effect-free leaf nodes.
- if (node->IsUnusedValue())
+ if (TLiveness::EliminateDeadCode && node->IsUnusedValue())
  {
  JITDUMP("Removing dead node:\n");
  DISPNODE(node);
@@ -2693,6 +2698,11 @@ bool Liveness<TLiveness>::TryRemoveDeadStoreLIR(GenTree* store, GenTreeLclVarCom
 template <typename TLiveness>
 bool Liveness<TLiveness>::TryRemoveNonLocalLIR(GenTree* node, LIR::Range* blockRange)
 {
+ if (!TLiveness::EliminateDeadCode)
+ {
+ return false;
+ }
+
  assert(!node->OperIsLocal());
  if (!node->IsValue() || node->IsUnusedValue())
  {
@@ -2816,6 +2826,7 @@ void Compiler::fgSsaLiveness()
  ComputeMemoryLiveness = true,
  IsLIR = false,
  IsEarly = false,
+ EliminateDeadCode = true,
  };
 
  SsaLivenessClass(Compiler* comp)
@@ -2841,6 +2852,7 @@ void Compiler::fgAsyncLiveness()
  ComputeMemoryLiveness = false,
  IsLIR = true,
  IsEarly = false,
+ EliminateDeadCode = false,
  };
 
  AsyncLiveness(Compiler* comp)
@@ -2866,6 +2878,7 @@ void Compiler::fgPostLowerLiveness()
  ComputeMemoryLiveness = false,
  IsLIR = true,
  IsEarly = false,
+ EliminateDeadCode = true,
  };
 
  PostLowerLiveness(Compiler* comp)
@@ -2909,6 +2922,7 @@ PhaseStatus Compiler::fgEarlyLiveness()
  ComputeMemoryLiveness = false,
  IsLIR = false,
  IsEarly = true,
+ EliminateDeadCode = true,
  };
 
  EarlyLiveness(Compiler* comp)

src/coreclr/jit/async.cpp

@@ -397,14 +397,12 @@ BasicBlock* Compiler::CreateReturnBB(unsigned* mergedReturnLcl)
 class AsyncLiveness
 {
  Compiler* m_compiler;
- bool m_hasLiveness;
  TreeLifeUpdater<false> m_updater;
  unsigned m_numVars;
 
 public:
- AsyncLiveness(Compiler* comp, bool hasLiveness)
+ AsyncLiveness(Compiler* comp)
  : m_compiler(comp)
- , m_hasLiveness(hasLiveness)
  , m_updater(comp)
  , m_numVars(comp->lvaCount)
  {
@@ -430,9 +428,6 @@ class AsyncLiveness
 //
 void AsyncLiveness::StartBlock(BasicBlock* block)
 {
- if (!m_hasLiveness)
- return;
-
  VarSetOps::Assign(m_compiler, m_compiler->compCurLife, block->bbLiveIn);
 }
 
@@ -446,9 +441,6 @@ void AsyncLiveness::StartBlock(BasicBlock* block)
 //
 void AsyncLiveness::Update(GenTree* node)
 {
- if (!m_hasLiveness)
- return;
-
  m_updater.UpdateLife(node);
 }
 
@@ -539,8 +531,9 @@ bool AsyncLiveness::IsLive(unsigned lclNum)
  return false;
  }
 
- if (!m_hasLiveness)
+ if (m_compiler->opts.compDbgCode && (lclNum < m_compiler->info.compLocalsCount))
  {
+ // Keep all IL locals in debug codegen
  return true;
  }
 
@@ -701,21 +694,18 @@ PhaseStatus AsyncTransformation::Run()
 #endif
 
  // Compute liveness to be used for determining what must be captured on
- // suspension. In unoptimized codegen we capture everything.
- if (m_compiler->opts.OptimizationEnabled())
+ // suspension.
+ if (m_compiler->m_dfsTree == nullptr)
  {
- if (m_compiler->m_dfsTree == nullptr)
- {
- m_compiler->m_dfsTree = m_compiler->fgComputeDfs<false>();
- }
-
- m_compiler->lvaComputeRefCounts(true, false);
- m_compiler->fgAsyncLiveness();
- INDEBUG(m_compiler->mostRecentlyActivePhase = PHASE_ASYNC);
- VarSetOps::AssignNoCopy(m_compiler, m_compiler->compCurLife, VarSetOps::MakeEmpty(m_compiler));
+ m_compiler->m_dfsTree = m_compiler->fgComputeDfs<false>();
  }
 
- AsyncLiveness liveness(m_compiler, m_compiler->opts.OptimizationEnabled());
+ m_compiler->lvaComputePreciseRefCounts(/* isRecompute */ true, /* setSlotNumbers */ false);
+ m_compiler->fgAsyncLiveness();
+ INDEBUG(m_compiler->mostRecentlyActivePhase = PHASE_ASYNC);
+ VarSetOps::AssignNoCopy(m_compiler, m_compiler->compCurLife, VarSetOps::MakeEmpty(m_compiler));
+
+ AsyncLiveness liveness(m_compiler);
 
  // Now walk the IR for all the blocks that contain async calls. Keep track
  // of liveness and outstanding LIR edges as we go; the LIR edges that cross
@@ -783,6 +773,28 @@ PhaseStatus AsyncTransformation::Run()
 
  m_compiler->fgInvalidateDfsTree();
 
+ if (m_compiler->opts.OptimizationDisabled())
+ {
+ // Rest of the compiler does not expect that we started tracking locals, so reset that state.
+ for (unsigned i = 0; i < m_compiler->lvaTrackedCount; i++)
+ {
+ m_compiler->lvaGetDesc(m_compiler->lvaTrackedToVarNum[i])->lvTracked = false;
+ }
+
+ m_compiler->lvaCurEpoch++;
+ m_compiler->lvaTrackedCount = 0;
+ m_compiler->lvaTrackedCountInSizeTUnits = 0;
+
+ for (BasicBlock* block : m_compiler->Blocks())
+ {
+ block->bbLiveIn = VarSetOps::UninitVal();
+ block->bbLiveOut = VarSetOps::UninitVal();
+ block->bbVarUse = VarSetOps::UninitVal();
+ block->bbVarDef = VarSetOps::UninitVal();
+ }
+ m_compiler->fgBBVarSetsInited = false;
+ }
+
  return PhaseStatus::MODIFIED_EVERYTHING;
 }
 

src/coreclr/jit/compiler.h

@@ -4214,6 +4214,7 @@ class Compiler
 
  PhaseStatus lvaMarkLocalVars(); // Local variable ref-counting
  void lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers);
+ void lvaComputePreciseRefCounts(bool isRecompute, bool setSlotNumbers);
  void lvaMarkLocalVars(BasicBlock* block);
 
  void lvaAllocOutgoingArgSpaceVar(); // Set up lvaOutgoingArgSpaceVar

src/coreclr/jit/lclvars.cpp

@@ -3415,8 +3415,6 @@ PhaseStatus Compiler::lvaMarkLocalVars()
 void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
 {
  JITDUMP("\n*** lvaComputeRefCounts ***\n");
- unsigned lclNum = 0;
- LclVarDsc* varDsc = nullptr;
 
  // Fast path for minopts and debug codegen.
  //
@@ -3430,8 +3428,9 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
 #if defined(DEBUG)
  // All local vars should be marked as implicitly referenced
  // and not tracked.
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  const bool isSpecialVarargsParam = varDsc->lvIsParam && lvaIsArgAccessedViaVarArgsCookie(lclNum);
 
  if (isSpecialVarargsParam)
@@ -3451,8 +3450,9 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  }
 
  // First compute.
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  // Using lvImplicitlyReferenced here ensures that we can't
  // accidentally make locals be unreferenced later by decrementing
  // the ref count to zero.
@@ -3488,11 +3488,28 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  return;
  }
 
- // Slower path we take when optimizing, to get accurate counts.
- //
+ lvaComputePreciseRefCounts(isRecompute, setSlotNumbers);
+}
+
+//------------------------------------------------------------------------
+// lvaComputePreciseRefCounts: compute precise ref counts for locals by IR traversal
+//
+// Arguments:
+// isRecompute -- true if we just want ref counts and no other side effects;
+// false means to also look for true boolean locals, lay
+// groundwork for assertion prop, check type consistency, etc.
+// See lvaMarkLclRefs for details on what else goes on.
+// setSlotNumbers -- true if local slot numbers should be assigned.
+//
+// Notes:
+// See notes on lvaComputeRefCounts.
+//
+void Compiler::lvaComputePreciseRefCounts(bool isRecompute, bool setSlotNumbers)
+{
  // First, reset all explicit ref counts and weights.
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  varDsc->setLvRefCnt(0);
  varDsc->setLvRefCntWtd(BB_ZERO_WEIGHT);
 
@@ -3519,7 +3536,7 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  const bool oldLvaGenericsContextInUse = lvaGenericsContextInUse;
  lvaGenericsContextInUse = false;
 
- JITDUMP("\n*** lvaComputeRefCounts -- explicit counts ***\n");
+ JITDUMP("\n*** lvaComputePreciseRefCounts -- explicit counts ***\n");
 
  // Second, account for all explicit local variable references
  for (BasicBlock* const block : Blocks())
@@ -3577,11 +3594,12 @@ void Compiler::lvaComputeRefCounts(bool isRecompute, bool setSlotNumbers)
  assert(!"unexpected new use of generics context");
  }
 
- JITDUMP("\n*** lvaComputeRefCounts -- implicit counts ***\n");
+ JITDUMP("\n*** lvaComputePreciseRefCounts -- implicit counts ***\n");
 
  // Third, bump ref counts for some implicit prolog references
- for (lclNum = 0, varDsc = lvaTable; lclNum < lvaCount; lclNum++, varDsc++)
+ for (unsigned lclNum = 0; lclNum < lvaCount; lclNum++)
  {
+ LclVarDsc* varDsc = lvaGetDesc(lclNum);
  // Todo: review justification for these count bumps.
  if (varDsc->lvIsRegArg)
  {

src/coreclr/jit/liveness.cpp

@@ -55,6 +55,7 @@ class Liveness
  ComputeMemoryLiveness = false,
  IsLIR = false,
  IsEarly = false,
+ EliminateDeadCode = false,
  };
 
  Liveness(Compiler* compiler)
@@ -1965,16 +1966,19 @@ bool Liveness<TLiveness>::ComputeLifeTrackedLocalDef(VARSET_TP& life,
  // Dead store
  node->gtFlags |= GTF_VAR_DEATH;
 
- // keepAliveVars always stay alive
- noway_assert(!VarSetOps::IsMember(m_compiler, keepAliveVars, varIndex));
+ if (TLiveness::EliminateDeadCode)
+ {
+ // keepAliveVars always stay alive
+ noway_assert(!VarSetOps::IsMember(m_compiler, keepAliveVars, varIndex));
 
- // Do not consider this store dead if the target local variable represents
- // a promoted struct field of an address exposed local or if the address
- // of the variable has been exposed. Improved alias analysis could allow
- // stores to these sorts of variables to be removed at the cost of compile
- // time.
- return !varDsc.IsAddressExposed() &&
- !(varDsc.lvIsStructField && m_compiler->lvaTable[varDsc.lvParentLcl].IsAddressExposed());
+ // Do not consider this store dead if the target local variable represents
+ // a promoted struct field of an address exposed local or if the address
+ // of the variable has been exposed. Improved alias analysis could allow
+ // stores to these sorts of variables to be removed at the cost of compile
+ // time.
+ return !varDsc.IsAddressExposed() &&
+ !(varDsc.lvIsStructField && m_compiler->lvaTable[varDsc.lvParentLcl].IsAddressExposed());
+ }
  }
 
  return false;
@@ -2011,7 +2015,7 @@ bool Liveness<TLiveness>::ComputeLifeUntrackedLocal(VARSET_TP& life,
 
  // We have accurate ref counts when running late liveness so we can eliminate
  // some stores if the lhs local has a ref count of 1.
- if (isDef && TLiveness::IsLIR && (varDsc.lvRefCnt() == 1) && !varDsc.lvPinned)
+ if (TLiveness::EliminateDeadCode && TLiveness::IsLIR && isDef && (varDsc.lvRefCnt() == 1) && !varDsc.lvPinned)
  {
  if (varDsc.lvIsStructField)
  {
@@ -2083,7 +2087,7 @@ bool Liveness<TLiveness>::ComputeLifeUntrackedLocal(VARSET_TP& life,
  }
  }
 
- if (isDef && !anyFieldLive)
+ if (TLiveness::EliminateDeadCode && isDef && !anyFieldLive)
  {
  // Do not consider this store dead if the parent local variable is an address exposed local or
  // if the struct has any significant padding we must retain the value of.
@@ -2328,7 +2332,8 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  case GT_CALL:
  {
  GenTreeCall* const call = node->AsCall();
- if ((call->TypeIs(TYP_VOID) || call->IsUnusedValue()) && !call->HasSideEffects(m_compiler))
+ if (TLiveness::EliminateDeadCode && (call->TypeIs(TYP_VOID) || call->IsUnusedValue()) &&
+ !call->HasSideEffects(m_compiler))
  {
  JITDUMP("Removing dead call:\n");
  DISPNODE(call);
@@ -2375,13 +2380,13 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  GenTreeLclVarCommon* const lclVarNode = node->AsLclVarCommon();
  LclVarDsc& varDsc = m_compiler->lvaTable[lclVarNode->GetLclNum()];
 
- if (node->IsUnusedValue())
+ if (TLiveness::EliminateDeadCode && node->IsUnusedValue())
  {
  JITDUMP("Removing dead LclVar use:\n");
  DISPNODE(lclVarNode);
 
  blockRange.Delete(m_compiler, block, node);
- if (varDsc.lvTracked && !m_compiler->opts.MinOpts())
+ if (varDsc.lvTracked)
  {
  m_compiler->fgStmtRemoved = true;
  }
@@ -2398,14 +2403,14 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  }
 
  case GT_LCL_ADDR:
- if (node->IsUnusedValue())
+ if (TLiveness::EliminateDeadCode && node->IsUnusedValue())
  {
  JITDUMP("Removing dead LclVar address:\n");
  DISPNODE(node);
 
  const bool isTracked = m_compiler->lvaTable[node->AsLclVarCommon()->GetLclNum()].lvTracked;
  blockRange.Delete(m_compiler, block, node);
- if (isTracked && !m_compiler->opts.MinOpts())
+ if (isTracked)
  {
  m_compiler->fgStmtRemoved = true;
  }
@@ -2423,7 +2428,7 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  }
 
  isDeadStore = ComputeLifeLocal(life, keepAliveVars, node);
- if (isDeadStore)
+ if (TLiveness::EliminateDeadCode && isDeadStore)
  {
  LIR::Use addrUse;
  if (blockRange.TryGetUse(node, &addrUse) && addrUse.User()->OperIs(GT_STOREIND, GT_STORE_BLK))
@@ -2464,7 +2469,7 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
  isDeadStore = ComputeLifeUntrackedLocal(life, keepAliveVars, varDsc, lclVarNode);
  }
 
- if (isDeadStore && TryRemoveDeadStoreLIR(node, lclVarNode, block))
+ if (TLiveness::EliminateDeadCode && isDeadStore && TryRemoveDeadStoreLIR(node, lclVarNode, block))
  {
  GenTree* value = lclVarNode->Data();
  value->SetUnusedValue();
@@ -2491,7 +2496,7 @@ void Liveness<TLiveness>::ComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VAR
 #endif // FEATURE_MASKED_HW_INTRINSICS
  case GT_PHYSREG:
  // These are all side-effect-free leaf nodes.
- if (node->IsUnusedValue())
+ if (TLiveness::EliminateDeadCode && node->IsUnusedValue())
  {
  JITDUMP("Removing dead node:\n");
  DISPNODE(node);
@@ -2693,6 +2698,11 @@ bool Liveness<TLiveness>::TryRemoveDeadStoreLIR(GenTree* store, GenTreeLclVarCom
 template <typename TLiveness>
 bool Liveness<TLiveness>::TryRemoveNonLocalLIR(GenTree* node, LIR::Range* blockRange)
 {
+ if (!TLiveness::EliminateDeadCode)
+ {
+ return false;
+ }
+
  assert(!node->OperIsLocal());
  if (!node->IsValue() || node->IsUnusedValue())
  {
@@ -2816,6 +2826,7 @@ void Compiler::fgSsaLiveness()
  ComputeMemoryLiveness = true,
  IsLIR = false,
  IsEarly = false,
+ EliminateDeadCode = true,
  };
 
  SsaLivenessClass(Compiler* comp)
@@ -2841,6 +2852,7 @@ void Compiler::fgAsyncLiveness()
  ComputeMemoryLiveness = false,
  IsLIR = true,
  IsEarly = false,
+ EliminateDeadCode = false,
  };
 
  AsyncLiveness(Compiler* comp)
@@ -2866,6 +2878,7 @@ void Compiler::fgPostLowerLiveness()
  ComputeMemoryLiveness = false,
  IsLIR = true,
  IsEarly = false,
+ EliminateDeadCode = true,
  };
 
  PostLowerLiveness(Compiler* comp)
@@ -2909,6 +2922,7 @@ PhaseStatus Compiler::fgEarlyLiveness()
  ComputeMemoryLiveness = false,
  IsLIR = false,
  IsEarly = true,
+ EliminateDeadCode = true,
  };
 
  EarlyLiveness(Compiler* comp)