Skip to content

Commit f010010

Browse files
MikeHolmanMikeHolman
committed
change FindRegUse to HasSymUse
1 parent 5aed68b commit f010010

5 files changed

Lines changed: 79 additions & 53 deletions

File tree

‎lib/Backend/FlowGraph.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2994,7 +2994,7 @@ FlowGraph::PeepCm(IR::Instr *instr)
29942994
if (instrLd3->GetByteCodeOffset() > instrBr->GetByteCodeOffset())
29952995
{
29962996
StackSym *symLd3 = instrLd3->GetDst()->AsRegOpnd()->m_sym;
2997-
if (IR::Instr::FindRegUseInRange(symLd3, instrBr->m_next, instrLd3))
2997+
if (IR::Instr::HasSymUseInRange(symLd3, instrBr->m_next, instrLd3))
29982998
{
29992999
return nullptr;
30003000
}

‎lib/Backend/GlobOpt.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2338,7 +2338,7 @@ GlobOpt::CollectMemOpInfo(IR::Instr *instrBegin, IR::Instr *instr, Value *src1Va
23382338
Loop::MemCopyCandidate* memcopyCandidate = prevCandidate->AsMemCopy();
23392339
if (memcopyCandidate->base == Js::Constants::InvalidSymID)
23402340
{
2341-
if (chkInstr->FindRegUse(memcopyCandidate->transferSym))
2341+
if (chkInstr->HasSymUse(memcopyCandidate->transferSym))
23422342
{
23432343
loop->doMemOp = false;
23442344
TRACE_MEMOP_PHASE_VERBOSE(MemCopy, loop, chkInstr, _u("Found illegal use of LdElemI value(s%d)"), GetVarSymID(memcopyCandidate->transferSym));

‎lib/Backend/IR.cpp‎

Lines changed: 71 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -2858,129 +2858,155 @@ Instr::GetOrCreateContinueLabel(const bool isHelper)
28582858
return label;
28592859
}
28602860

2861-
2862-
IR::RegOpnd * Instr::FindRegUseSrc(StackSym *sym, IR::Opnd* src)
2861+
bool
2862+
Instr::HasSymUseSrc(StackSym *sym, IR::Opnd* src)
28632863
{
28642864
if (!src)
28652865
{
2866-
return nullptr;
2866+
return false;
28672867
}
28682868
if (src->IsRegOpnd())
28692869
{
28702870
RegOpnd *regOpnd = src->AsRegOpnd();
28712871

28722872
if (regOpnd->m_sym == sym)
28732873
{
2874-
return regOpnd;
2874+
return true;
28752875
}
28762876
}
28772877
else if (src->IsIndirOpnd())
28782878
{
28792879
IR::IndirOpnd *indirOpnd = src->AsIndirOpnd();
2880+
if (indirOpnd->GetStackSym() == sym)
2881+
{
2882+
return true;
2883+
}
28802884
RegOpnd * baseOpnd = indirOpnd->GetBaseOpnd();
28812885
if (baseOpnd != nullptr && baseOpnd->m_sym == sym)
28822886
{
2883-
return baseOpnd;
2887+
return true;
28842888
}
28852889
else if (indirOpnd->GetIndexOpnd() && indirOpnd->GetIndexOpnd()->m_sym == sym)
28862890
{
2887-
return indirOpnd->GetIndexOpnd();
2891+
return true;
28882892
}
28892893
}
28902894
else if (src->IsListOpnd())
28912895
{
28922896
IR::ListOpnd* list = src->AsListOpnd();
2893-
for (int i = 0; i < list->Count(); ++i)
2897+
if (list->GetStackSym() == sym)
28942898
{
2895-
IR::RegOpnd* reg = FindRegUseSrc(sym, list->Item(i));
2896-
if (reg)
2899+
for (int i = 0; i < list->Count(); ++i)
28972900
{
2898-
return reg;
2901+
if (HasSymUseSrc(sym, list->Item(i)))
2902+
{
2903+
return true;
2904+
}
28992905
}
29002906
}
29012907
}
2902-
return nullptr;
2908+
else if (src->IsSymOpnd())
2909+
{
2910+
SymOpnd* symOpnd = src->AsSymOpnd();
2911+
if (symOpnd->GetSym() == sym)
2912+
{
2913+
return true;
2914+
}
2915+
if (symOpnd->IsPropertySymOpnd())
2916+
{
2917+
PropertySymOpnd* propertySymOpnd = symOpnd->AsPropertySymOpnd();
2918+
if (propertySymOpnd->GetPropertySym()->m_stackSym == sym)
2919+
{
2920+
return true;
2921+
}
2922+
if (propertySymOpnd->GetObjectSym() == sym)
2923+
{
2924+
return true;
2925+
}
2926+
}
2927+
}
2928+
return false;
29032929
}
29042930

29052931

2906-
IR::RegOpnd * Instr::FindRegUseDst(StackSym *sym, IR::Opnd* dst)
2932+
bool
2933+
Instr::HasSymUseDst(StackSym *sym, IR::Opnd* dst)
29072934
{
29082935
if (!dst)
29092936
{
2910-
return nullptr;
2937+
return false;
29112938
}
29122939
if (dst->IsIndirOpnd())
29132940
{
29142941
IR::IndirOpnd *indirOpnd = dst->AsIndirOpnd();
29152942
RegOpnd * baseOpnd = indirOpnd->GetBaseOpnd();
29162943
if (baseOpnd != nullptr && baseOpnd->m_sym == sym)
29172944
{
2918-
return baseOpnd;
2945+
return true;
29192946
}
29202947
else if (indirOpnd->GetIndexOpnd() && indirOpnd->GetIndexOpnd()->m_sym == sym)
29212948
{
2922-
return indirOpnd->GetIndexOpnd();
2949+
return true;
29232950
}
29242951
}
29252952
else if (dst->IsListOpnd())
29262953
{
29272954
IR::ListOpnd* list = dst->AsListOpnd();
29282955
for (int i = 0; i < list->Count(); ++i)
29292956
{
2930-
IR::RegOpnd* reg = FindRegUseDst(sym, list->Item(i));
2931-
if (reg)
2957+
if (HasSymUseDst(sym, list->Item(i)))
29322958
{
2933-
return reg;
2959+
return true;
29342960
}
29352961
}
29362962
}
2937-
return nullptr;
2963+
else if (dst->IsSymOpnd() && dst->AsSymOpnd()->IsPropertySymOpnd())
2964+
{
2965+
PropertySymOpnd* propertySymOpnd = dst->AsSymOpnd()->AsPropertySymOpnd();
2966+
if (propertySymOpnd->GetPropertySym()->m_stackSym == sym)
2967+
{
2968+
return true;
2969+
}
2970+
if (propertySymOpnd->GetObjectSym() == sym)
2971+
{
2972+
return true;
2973+
}
2974+
}
2975+
return false;
29382976
}
29392977

2940-
///----------------------------------------------------------------------------
2941-
///
2942-
/// Instr::FindRegUse
2943-
///
2944-
/// Search a reg use of the given sym. Return the RegOpnd that uses it.
2945-
///
2946-
///----------------------------------------------------------------------------
2947-
2948-
IR::RegOpnd *
2949-
Instr::FindRegUse(StackSym *sym)
2978+
bool
2979+
Instr::HasSymUse(StackSym *sym)
29502980
{
2951-
IR::RegOpnd* reg = FindRegUseSrc(sym, this->GetSrc1());
2952-
if (reg)
2981+
if (HasSymUseSrc(sym, this->GetSrc1()))
29532982
{
2954-
return reg;
2983+
return true;
29552984
}
2956-
reg = FindRegUseSrc(sym, this->GetSrc2());
2957-
if (reg)
2985+
if (HasSymUseSrc(sym, this->GetSrc2()))
29582986
{
2959-
return reg;
2987+
return true;
29602988
}
2961-
reg = FindRegUseDst(sym, this->GetDst());
2962-
if (reg)
2989+
if (HasSymUseSrc(sym, this->GetDst()))
29632990
{
2964-
return reg;
2991+
return true;
29652992
}
2966-
return nullptr;
2993+
return false;
29672994
}
29682995

2969-
IR::RegOpnd *
2970-
Instr::FindRegUseInRange(StackSym *sym, IR::Instr *instrBegin, IR::Instr *instrEnd)
2996+
bool
2997+
Instr::HasSymUseInRange(StackSym *sym, IR::Instr *instrBegin, IR::Instr *instrEnd)
29712998
{
29722999
FOREACH_INSTR_IN_RANGE(instr, instrBegin, instrEnd)
29733000
{
29743001
Assert(instr);
2975-
IR::RegOpnd *opnd = instr->FindRegUse(sym);
2976-
if (opnd)
3002+
if (instr->HasSymUse(sym))
29773003
{
2978-
return opnd;
3004+
return true;
29793005
}
29803006
}
29813007
NEXT_INSTR_IN_RANGE;
29823008

2983-
return nullptr;
3009+
return false;
29843010
}
29853011

29863012
///----------------------------------------------------------------------------

‎lib/Backend/IR.h‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -272,10 +272,10 @@ class Instr
272272
IR::Instr * GetPrevRealInstrOrLabel() const;
273273
IR::Instr * GetInsertBeforeByteCodeUsesInstr();
274274
IR::LabelInstr *GetOrCreateContinueLabel(const bool isHelper = false);
275-
static RegOpnd *FindRegUseSrc(StackSym *sym, IR::Opnd*);
276-
static RegOpnd *FindRegUseDst(StackSym *sym, IR::Opnd*);
277-
RegOpnd * FindRegUse(StackSym *sym);
278-
static RegOpnd *FindRegUseInRange(StackSym *sym, Instr *instrBegin, Instr *instrEnd);
275+
static bool HasSymUseSrc(StackSym *sym, IR::Opnd*);
276+
static bool HasSymUseDst(StackSym *sym, IR::Opnd*);
277+
bool HasSymUse(StackSym *sym);
278+
static bool HasSymUseInRange(StackSym *sym, Instr *instrBegin, Instr *instrEnd);
279279
RegOpnd * FindRegDef(StackSym *sym);
280280
static Instr* FindSingleDefInstr(Js::OpCode opCode, Opnd* src);
281281

‎lib/Backend/PreLowerPeeps.cpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -115,7 +115,7 @@ Lowerer::TryShiftAdd(IR::Instr *instrAdd, IR::Opnd * opndFold, IR::Opnd * opndAd
115115
{
116116
return instrAdd;
117117
}
118-
if (instrIter->FindRegUse(foldSym))
118+
if (instrIter->HasSymUse(foldSym))
119119
{
120120
return instrAdd;
121121
}
@@ -250,7 +250,7 @@ IR::Instr *Lowerer::PeepShl(IR::Instr *instrShl)
250250
{
251251
return instrShl;
252252
}
253-
if (instrIter->FindRegUse(src1->AsRegOpnd()->m_sym))
253+
if (instrIter->HasSymUse(src1->AsRegOpnd()->m_sym))
254254
{
255255
return instrShl;
256256
}

0 commit comments

Comments
 (0)