Index: src/IceVariableSplitting.cpp |
diff --git a/src/IceVariableSplitting.cpp b/src/IceVariableSplitting.cpp |
new file mode 100644 |
index 0000000000000000000000000000000000000000..8680adabed4d6c2b9d784847e63e0f8a6d14c434 |
--- /dev/null |
+++ b/src/IceVariableSplitting.cpp |
@@ -0,0 +1,608 @@ |
+//===- subzero/src/IceVariableSplitting.cpp - Local variable splitting ----===// |
+// |
+// The Subzero Code Generator |
+// |
+// This file is distributed under the University of Illinois Open Source |
+// License. See LICENSE.TXT for details. |
+// |
+//===----------------------------------------------------------------------===// |
+/// |
+/// \file |
+/// \brief Aggressive block-local variable splitting to improve linear-scan |
+/// register allocation. |
+/// |
+//===----------------------------------------------------------------------===// |
+ |
+#include "IceVariableSplitting.h" |
+ |
+#include "IceCfg.h" |
+#include "IceCfgNode.h" |
+#include "IceClFlags.h" |
+#include "IceInst.h" |
+#include "IceOperand.h" |
+#include "IceTargetLowering.h" |
+ |
+namespace Ice { |
+ |
+namespace { |
+ |
+/// A Variable is "allocable" if it is a register allocation candidate but |
+/// doesn't already have a register. |
+bool isAllocable(const Variable *Var) { |
+ if (Var == nullptr) |
+ return false; |
+ return !Var->hasReg() && Var->mayHaveReg(); |
+} |
+ |
+/// A Variable is "inf" if it already has a register or is infinite-weight. |
+bool isInf(const Variable *Var) { |
+ if (Var == nullptr) |
+ return false; |
+ return Var->hasReg() || Var->mustHaveReg(); |
+} |
+ |
+/// VariableMap is a simple helper class that keeps track of the latest split |
+/// version of the original Variables, as well as the instruction containing the |
+/// last use of the Variable within the current block. For each entry, the |
+/// Variable is tagged with the CfgNode that it is valid in, so that we don't |
+/// need to clear the entire Map[] vector for each block. |
+class VariableMap { |
+private: |
+ VariableMap() = delete; |
+ VariableMap(const VariableMap &) = delete; |
+ VariableMap &operator=(const VariableMap &) = delete; |
+ |
+ struct VarInfo { |
+ /// MappedVar is the latest mapped/split version of the Variable. |
+ Variable *MappedVar = nullptr; |
+ /// MappedVarNode is the block in which MappedVar is valid. |
+ const CfgNode *MappedVarNode = nullptr; |
+ /// LastUseInst is the last instruction in the block that uses the Variable |
+ /// as a source operand. |
+ const Inst *LastUseInst = nullptr; |
+ /// LastUseNode is the block in which LastUseInst is valid. |
+ const CfgNode *LastUseNode = nullptr; |
+ VarInfo() = default; |
+ |
+ private: |
+ VarInfo(const VarInfo &) = delete; |
+ VarInfo &operator=(const VarInfo &) = delete; |
+ }; |
+ |
+public: |
+ explicit VariableMap(Cfg *Func) |
+ : Func(Func), NumVars(Func->getNumVariables()), Map(NumVars) {} |
+ /// Reset the mappings at the start of a block. |
+ void reset(const CfgNode *CurNode) { |
+ Node = CurNode; |
+ // Do a prepass through all the instructions, marking which instruction is |
+ // the last use of each Variable within the block. |
+ for (const Inst &Instr : Node->getInsts()) { |
+ if (Instr.isDeleted()) |
+ continue; |
+ for (SizeT i = 0; i < Instr.getSrcSize(); ++i) { |
+ if (auto *SrcVar = llvm::dyn_cast<Variable>(Instr.getSrc(i))) { |
+ const SizeT VarNum = getVarNum(SrcVar); |
+ Map[VarNum].LastUseInst = &Instr; |
+ Map[VarNum].LastUseNode = Node; |
+ } |
+ } |
+ } |
+ } |
+ /// Get Var's current mapping (or Var itself if it has no mapping yet). |
+ Variable *get(Variable *Var) const { |
+ const SizeT VarNum = getVarNum(Var); |
+ Variable *MappedVar = Map[VarNum].MappedVar; |
+ if (MappedVar == nullptr) |
+ return Var; |
+ if (Map[VarNum].MappedVarNode != Node) |
+ return Var; |
+ return MappedVar; |
+ } |
+ /// Create a new linked Variable in the LinkedTo chain, and set it as Var's |
+ /// latest mapping. |
+ Variable *makeLinked(Variable *Var) { |
+ Variable *NewVar = Func->makeVariable(Var->getType()); |
+ NewVar->setRegClass(Var->getRegClass()); |
+ NewVar->setLinkedTo(get(Var)); |
+ const SizeT VarNum = getVarNum(Var); |
+ Map[VarNum].MappedVar = NewVar; |
+ Map[VarNum].MappedVarNode = Node; |
+ return NewVar; |
+ } |
+ /// Given Var that is LinkedTo some other variable, re-splice it into the |
+ /// LinkedTo chain so that the chain is ordered by Variable::getIndex(). |
+ void spliceBlockLocalLinkedToChain(Variable *Var) { |
+ Variable *LinkedTo = Var->getLinkedTo(); |
+ assert(LinkedTo != nullptr); |
+ assert(Var->getIndex() > LinkedTo->getIndex()); |
+ const SizeT VarNum = getVarNum(LinkedTo); |
+ Variable *Link = Map[VarNum].MappedVar; |
+ if (Link == nullptr || Map[VarNum].MappedVarNode != Node) |
+ return; |
+ Variable *LinkParent = Link->getLinkedTo(); |
+ while (LinkParent != nullptr && LinkParent->getIndex() >= Var->getIndex()) { |
+ Link = LinkParent; |
+ LinkParent = Link->getLinkedTo(); |
+ } |
+ Var->setLinkedTo(LinkParent); |
+ Link->setLinkedTo(Var); |
+ } |
+ /// Return whether the given Variable has any uses as a source operand within |
+ /// the current block. If it has no source operand uses, but is assigned as a |
+ /// dest variable in some instruction in the block, then we needn't bother |
+ /// splitting it. |
+ bool isDestUsedInBlock(const Variable *Dest) const { |
+ return Map[getVarNum(Dest)].LastUseNode == Node; |
+ } |
+ /// Return whether the given instruction is the last use of the given Variable |
+ /// within the current block. If it is, then we needn't bother splitting the |
+ /// Variable at this instruction. |
+ bool isInstLastUseOfVar(const Variable *Var, const Inst *Instr) { |
+ return Map[getVarNum(Var)].LastUseInst == Instr; |
+ } |
+ |
+private: |
+ Cfg *const Func; |
+ // NumVars is for the size of the Map array. It can be const because any new |
+ // Variables created during the splitting pass don't need to be mapped. |
+ const SizeT NumVars; |
+ CfgVector<VarInfo> Map; |
+ const CfgNode *Node = nullptr; |
+ /// Get Var's VarNum, and do some validation. |
+ SizeT getVarNum(const Variable *Var) const { |
+ const SizeT VarNum = Var->getIndex(); |
+ assert(VarNum < NumVars); |
+ return VarNum; |
+ } |
+}; |
+ |
+/// LocalVariableSplitter tracks the necessary splitting state across |
+/// instructions. |
+class LocalVariableSplitter { |
+ LocalVariableSplitter() = delete; |
+ LocalVariableSplitter(const LocalVariableSplitter &) = delete; |
+ LocalVariableSplitter &operator=(const LocalVariableSplitter &) = delete; |
+ |
+public: |
+ explicit LocalVariableSplitter(Cfg *Func) |
+ : Target(Func->getTarget()), VarMap(Func) {} |
+ /// setNode() is called before processing the instructions of a block. |
+ void setNode(CfgNode *CurNode) { |
+ Node = CurNode; |
+ VarMap.reset(Node); |
+ LinkedToFixups.clear(); |
+ } |
+ /// finalizeNode() is called after all instructions in the block are |
+ /// processed. |
+ void finalizeNode() { |
+ // Splice in any preexisting LinkedTo links into the single chain. These |
+ // are the ones that were recorded during setInst(). |
+ for (Variable *Var : LinkedToFixups) { |
+ VarMap.spliceBlockLocalLinkedToChain(Var); |
+ } |
+ } |
+ /// setInst() is called before processing the next instruction. The iterators |
+ /// are the insertion points for a new instructions, depending on whether the |
+ /// new instruction should be inserted before or after the current |
+ /// instruction. |
+ void setInst(Inst *CurInst, InstList::iterator Cur, InstList::iterator Next) { |
+ Instr = CurInst; |
+ Dest = Instr->getDest(); |
+ IterCur = Cur; |
+ IterNext = Next; |
+ ShouldSkipRemainingInstructions = false; |
+ // Note any preexisting LinkedTo relationships that were created during |
+ // target lowering. Record them in LinkedToFixups which is then processed |
+ // in finalizeNode(). |
+ if (Dest != nullptr && Dest->getLinkedTo() != nullptr) { |
+ LinkedToFixups.emplace_back(Dest); |
+ } |
+ } |
+ bool shouldSkipRemainingInstructions() const { |
+ return ShouldSkipRemainingInstructions; |
+ } |
+ bool isUnconditionallyExecuted() const { return WaitingForLabel == nullptr; } |
+ |
+ /// Note: the handle*() functions return true to indicate that the instruction |
+ /// has now been handled and that the instruction loop should continue to the |
+ /// next instruction in the block (and return false otherwise). In addition, |
+ /// they set the ShouldSkipRemainingInstructions flag to indicate that no more |
+ /// instructions in the block should be processed. |
+ |
+ /// Handle an "unwanted" instruction by returning true; |
+ bool handleUnwantedInstruction() { |
+ // We can limit the splitting to an arbitrary subset of the instructions, |
+ // and still expect correct code. As such, we can do instruction-subset |
+ // bisection to help debug any problems in this pass. |
+ static constexpr char AnInstructionHasNoName[] = ""; |
+ if (!BuildDefs::minimal() && |
+ !getFlags().matchSplitInsts(AnInstructionHasNoName, |
+ Instr->getNumber())) { |
+ return true; |
+ } |
+ if (!llvm::isa<InstTarget>(Instr)) { |
+ // Ignore non-lowered instructions like FakeDef/FakeUse. |
+ return true; |
+ } |
+ return false; |
+ } |
+ |
+ /// Process a potential label instruction. |
+ bool handleLabel() { |
+ if (!Instr->isLabel()) |
+ return false; |
+ // A Label instruction shouldn't have any operands, so it can be handled |
+ // right here and then move on. |
+ assert(Dest == nullptr); |
+ assert(Instr->getSrcSize() == 0); |
+ if (Instr == WaitingForLabel) { |
+ // If we found the forward-branch-target Label instruction we're waiting |
+ // for, then clear the WaitingForLabel state. |
+ WaitingForLabel = nullptr; |
+ } else if (WaitingForLabel == nullptr && WaitingForBranchTo == nullptr) { |
+ // If we found a new Label instruction while the WaitingFor* state is |
+ // clear, then set things up for this being a backward branch target. |
+ WaitingForBranchTo = Instr; |
+ } else { |
+ // We see something we don't understand, so skip to the next block. |
+ ShouldSkipRemainingInstructions = true; |
+ } |
+ return true; |
+ } |
+ |
+ /// Process a potential intra-block branch instruction. |
+ bool handleIntraBlockBranch() { |
+ const Inst *Label = Instr->getIntraBlockBranchTarget(); |
+ if (Label == nullptr) |
+ return false; |
+ // An intra-block branch instruction shouldn't have any operands, so it can |
+ // be handled right here and then move on. |
+ assert(Dest == nullptr); |
+ assert(Instr->getSrcSize() == 0); |
+ if (WaitingForBranchTo == Label && WaitingForLabel == nullptr) { |
+ WaitingForBranchTo = nullptr; |
+ } else if (WaitingForBranchTo == nullptr && |
+ (WaitingForLabel == nullptr || WaitingForLabel == Label)) { |
+ WaitingForLabel = Label; |
+ } else { |
+ // We see something we don't understand, so skip to the next block. |
+ ShouldSkipRemainingInstructions = true; |
+ } |
+ return true; |
+ } |
+ |
+ /// Specially process a potential "Variable=Variable" assignment instruction, |
+ /// when it conforms to certain patterns. |
+ bool handleSimpleVarAssign() { |
+ if (!Instr->isVarAssign()) |
+ return false; |
+ const bool DestIsInf = isInf(Dest); |
+ const bool DestIsAllocable = isAllocable(Dest); |
+ auto *SrcVar = llvm::cast<Variable>(Instr->getSrc(0)); |
+ const bool SrcIsInf = isInf(SrcVar); |
+ const bool SrcIsAllocable = isAllocable(SrcVar); |
+ if (DestIsInf && SrcIsInf) { |
+ // The instruction: |
+ // t:inf = u:inf |
+ // No transformation is needed. |
+ return true; |
+ } |
+ if (DestIsInf && SrcIsAllocable && Dest->getType() == SrcVar->getType()) { |
+ // The instruction: |
+ // t:inf = v |
+ // gets transformed to: |
+ // t:inf = v1 |
+ // v2 = t:inf |
+ // where: |
+ // v1 := map[v] |
+ // v2 := linkTo(v) |
+ // map[v] := v2 |
+ // |
+ // If both v2 and its linkedToStackRoot get a stack slot, then "v2=t:inf" |
+ // is recognized as a redundant assignment and elided. |
+ // |
+ // Note that if the dest and src types are different, then this is |
+ // actually a truncation operation, which would make "v2=t:inf" an invalid |
+ // instruction. In this case, the type test will make it fall through to |
+ // the general case below. |
+ Variable *OldMapped = VarMap.get(SrcVar); |
+ Instr->replaceSource(0, OldMapped); |
+ if (isUnconditionallyExecuted()) { |
+ // Only create new mapping state if the instruction is unconditionally |
+ // executed. |
+ if (!VarMap.isInstLastUseOfVar(SrcVar, Instr)) { |
+ Variable *NewMapped = VarMap.makeLinked(SrcVar); |
+ Inst *Mov = Target->createLoweredMove(NewMapped, Dest); |
+ Node->getInsts().insert(IterNext, Mov); |
+ } |
+ } |
+ return true; |
+ } |
+ if (DestIsAllocable && SrcIsInf) { |
+ if (!VarMap.isDestUsedInBlock(Dest)) { |
+ return true; |
+ } |
+ // The instruction: |
+ // v = t:inf |
+ // gets transformed to: |
+ // v = t:inf |
+ // v2 = t:inf |
+ // where: |
+ // v2 := linkTo(v) |
+ // map[v] := v2 |
+ // |
+ // If both v2 and v get a stack slot, then "v2=t:inf" is recognized as a |
+ // redundant assignment and elided. |
+ if (isUnconditionallyExecuted()) { |
+ // Only create new mapping state if the instruction is unconditionally |
+ // executed. |
+ Variable *NewMapped = VarMap.makeLinked(Dest); |
+ Inst *Mov = Target->createLoweredMove(NewMapped, SrcVar); |
+ Node->getInsts().insert(IterNext, Mov); |
+ } else { |
+ // For a conditionally executed instruction, add a redefinition of the |
+ // original Dest mapping, without creating a new linked variable. |
+ Variable *OldMapped = VarMap.get(Dest); |
+ Inst *Mov = Target->createLoweredMove(OldMapped, SrcVar); |
+ Mov->setDestRedefined(); |
+ Node->getInsts().insert(IterNext, Mov); |
+ } |
+ return true; |
+ } |
+ assert(!ShouldSkipRemainingInstructions); |
+ return false; |
+ } |
+ |
+ /// Process the dest Variable of a Phi instruction. |
+ bool handlePhi() { |
+ assert(llvm::isa<InstPhi>(Instr)); |
+ const bool DestIsAllocable = isAllocable(Dest); |
+ if (!DestIsAllocable) |
+ return true; |
+ if (!VarMap.isDestUsedInBlock(Dest)) |
+ return true; |
+ Variable *NewMapped = VarMap.makeLinked(Dest); |
+ Inst *Mov = Target->createLoweredMove(NewMapped, Dest); |
+ Node->getInsts().insert(IterCur, Mov); |
+ return true; |
+ } |
+ |
+ /// Process an arbitrary instruction. |
+ bool handleGeneralInst() { |
+ const bool DestIsAllocable = isAllocable(Dest); |
+ // The (non-variable-assignment) instruction: |
+ // ... = F(v) |
+ // where v is not infinite-weight, gets transformed to: |
+ // v2 = v1 |
+ // ... = F(v1) |
+ // where: |
+ // v1 := map[v] |
+ // v2 := linkTo(v) |
+ // map[v] := v2 |
+ // After that, if the "..." dest=u is not infinite-weight, append: |
+ // u2 = u |
+ // where: |
+ // u2 := linkTo(u) |
+ // map[u] := u2 |
+ for (SizeT i = 0; i < Instr->getSrcSize(); ++i) { |
+ // Iterate over the top-level src vars. Don't bother to dig into |
+ // e.g. MemOperands because their vars should all be infinite-weight. |
+ // (This assumption would need to change if the pass were done |
+ // pre-lowering.) |
+ if (auto *SrcVar = llvm::dyn_cast<Variable>(Instr->getSrc(i))) { |
+ const bool SrcIsAllocable = isAllocable(SrcVar); |
+ if (SrcIsAllocable) { |
+ Variable *OldMapped = VarMap.get(SrcVar); |
+ if (isUnconditionallyExecuted()) { |
+ if (!VarMap.isInstLastUseOfVar(SrcVar, Instr)) { |
+ Variable *NewMapped = VarMap.makeLinked(SrcVar); |
+ Inst *Mov = Target->createLoweredMove(NewMapped, OldMapped); |
+ Node->getInsts().insert(IterCur, Mov); |
+ } |
+ } |
+ Instr->replaceSource(i, OldMapped); |
+ } |
+ } |
+ } |
+ // Transformation of Dest is the same as the "v=t:inf" case above. |
+ if (DestIsAllocable && VarMap.isDestUsedInBlock(Dest)) { |
+ if (isUnconditionallyExecuted()) { |
+ Variable *NewMapped = VarMap.makeLinked(Dest); |
+ Inst *Mov = Target->createLoweredMove(NewMapped, Dest); |
+ Node->getInsts().insert(IterNext, Mov); |
+ } else { |
+ Variable *OldMapped = VarMap.get(Dest); |
+ Inst *Mov = Target->createLoweredMove(OldMapped, Dest); |
+ Mov->setDestRedefined(); |
+ Node->getInsts().insert(IterNext, Mov); |
+ } |
+ } |
+ return true; |
+ } |
+ |
+private: |
+ TargetLowering *Target; |
+ CfgNode *Node = nullptr; |
+ Inst *Instr = nullptr; |
+ Variable *Dest = nullptr; |
+ InstList::iterator IterCur; |
+ InstList::iterator IterNext; |
+ bool ShouldSkipRemainingInstructions = false; |
+ VariableMap VarMap; |
+ CfgVector<Variable *> LinkedToFixups; |
+ /// WaitingForLabel and WaitingForBranchTo are for tracking intra-block |
+ /// control flow. |
+ const Inst *WaitingForLabel = nullptr; |
+ const Inst *WaitingForBranchTo = nullptr; |
+}; |
+ |
+} // end of anonymous namespace |
+ |
+/// Within each basic block, rewrite Variable references in terms of chained |
+/// copies of the original Variable. For example: |
+/// A = B + C |
+/// might be rewritten as: |
+/// B1 = B |
+/// C1 = C |
+/// A = B + C |
+/// A1 = A |
+/// and then: |
+/// D = A + B |
+/// might be rewritten as: |
+/// A2 = A1 |
+/// B2 = B1 |
+/// D = A1 + B1 |
+/// D1 = D |
+/// |
+/// The purpose is to present the linear-scan register allocator with smaller |
+/// live ranges, to help mitigate its "all or nothing" allocation strategy, |
+/// while counting on its preference mechanism to keep the split versions in the |
+/// same register when possible. |
+/// |
+/// When creating new Variables, A2 is linked to A1 which is linked to A, and |
+/// similar for the other Variable linked-to chains. Rewrites apply only to |
+/// Variables where mayHaveReg() is true. |
+/// |
+/// At code emission time, redundant linked-to stack assignments will be |
+/// recognized and elided. To illustrate using the above example, if A1 gets a |
+/// register but A and A2 are on the stack, the "A2=A1" store instruction is |
+/// redundant since A and A2 share the same stack slot and A1 originated from A. |
+/// |
+/// Simple assignment instructions are rewritten slightly differently, to take |
+/// maximal advantage of Variables known to have registers. |
+/// |
+/// In general, there may be several valid ways to rewrite an instruction: add |
+/// the new assignment instruction either before or after the original |
+/// instruction, and rewrite the original instruction with either the old or the |
+/// new variable mapping. We try to pick a strategy most likely to avoid |
+/// potential performance problems. For example, try to avoid storing to the |
+/// stack and then immediately reloading from the same location. One |
+/// consequence is that code might be generated that loads a register from a |
+/// stack location, followed almost immediately by another use of the same stack |
+/// location, despite its value already being available in a register as a |
+/// result of the first instruction. However, the performance impact here is |
+/// likely to be negligible, and a simple availability peephole optimization |
+/// could clean it up. |
+/// |
+/// This pass potentially adds a lot of new instructions and variables, and as |
+/// such there are compile-time performance concerns, particularly with liveness |
+/// analysis and register allocation. Note that for liveness analysis, the new |
+/// variables have single-block liveness, so they don't increase the size of the |
+/// liveness bit vectors that need to be merged across blocks. As a result, the |
+/// performance impact is likely to be linearly related to the number of new |
+/// instructions, rather than number of new variables times number of blocks |
+/// which would be the case if they were multi-block variables. |
+void splitBlockLocalVariables(Cfg *Func) { |
+ if (!getFlags().getSplitLocalVars()) |
+ return; |
+ TimerMarker _(TimerStack::TT_splitLocalVars, Func); |
+ LocalVariableSplitter Splitter(Func); |
+ // TODO(stichnot): Fix this mechanism for LinkedTo variables and stack slot |
+ // assignment. |
+ // |
+ // To work around shortcomings with stack frame mapping, we want to arrange |
+ // LinkedTo structure such that within one block, the LinkedTo structure |
+ // leading to a root forms a list, not a tree. A LinkedTo root can have |
+ // multiple children linking to it, but only one per block. Furthermore, |
+ // because stack slot mapping processes variables in numerical order, the |
+ // LinkedTo chain needs to be ordered such that when A->getLinkedTo() == B, |
+ // then A->getIndex() > B->getIndex(). |
+ // |
+ // To effect this, while processing a block we keep track of preexisting |
+ // LinkedTo relationships via the LinkedToFixups vector, and at the end of the |
+ // block we splice them in such that the block has a single chain for each |
+ // root, ordered by getIndex() value. |
+ CfgVector<Variable *> LinkedToFixups; |
+ for (CfgNode *Node : Func->getNodes()) { |
+ // Clear the VarMap and LinkedToFixups at the start of every block. |
+ LinkedToFixups.clear(); |
+ Splitter.setNode(Node); |
+ auto &Insts = Node->getInsts(); |
+ auto Iter = Insts.begin(); |
+ auto IterEnd = Insts.end(); |
+ // TODO(stichnot): Figure out why Phi processing usually degrades |
+ // performance. Disable for now. |
+ static constexpr bool ProcessPhis = false; |
+ if (ProcessPhis) { |
+ for (Inst &Instr : Node->getPhis()) { |
+ if (Instr.isDeleted()) |
+ continue; |
+ Splitter.setInst(&Instr, Iter, Iter); |
+ Splitter.handlePhi(); |
+ } |
+ } |
+ InstList::iterator NextIter; |
+ for (; Iter != IterEnd && !Splitter.shouldSkipRemainingInstructions(); |
+ Iter = NextIter) { |
+ NextIter = Iter; |
+ ++NextIter; |
+ Inst *Instr = iteratorToInst(Iter); |
+ if (Instr->isDeleted()) |
+ continue; |
+ Splitter.setInst(Instr, Iter, NextIter); |
+ |
+ // Before doing any transformations, take care of the bookkeeping for |
+ // intra-block branching. |
+ // |
+ // This is tricky because the transformation for one instruction may |
+ // depend on a transformation for a previous instruction, but if that |
+ // previous instruction is not dynamically executed due to intra-block |
+ // control flow, it may lead to an inconsistent state and incorrect code. |
+ // |
+ // We want to handle some simple cases, and reject some others: |
+ // |
+ // 1. For something like a select instruction, we could have: |
+ // test cond |
+ // dest = src_false |
+ // branch conditionally to label |
+ // dest = src_true |
+ // label: |
+ // |
+ // Between the conditional branch and the label, we need to treat dest and |
+ // src variables specially, specifically not creating any new state. |
+ // |
+ // 2. Some 64-bit atomic instructions may be lowered to a loop: |
+ // label: |
+ // ... |
+ // branch conditionally to label |
+ // |
+ // No special treatment is needed, but it's worth tracking so that case #1 |
+ // above can also be handled. |
+ // |
+ // 3. Advanced switch lowering can create really complex intra-block |
+ // control flow, so when we recognize this, we should just stop splitting |
+ // for the remainder of the block (which isn't much since a switch |
+ // instruction is a terminator). |
+ // |
+ // 4. Other complex lowering, e.g. an i64 icmp on a 32-bit architecture, |
+ // can result in an if/then/else like structure with two labels. One |
+ // possibility would be to suspect splitting for the remainder of the |
+ // lowered instruction, and then resume for the remainder of the block, |
+ // but since we don't have high-level instruction markers, we might as |
+ // well just stop splitting for the remainder of the block. |
+ if (Splitter.handleLabel()) |
+ continue; |
+ if (Splitter.handleIntraBlockBranch()) |
+ continue; |
+ if (Splitter.handleUnwantedInstruction()) |
+ continue; |
+ |
+ // Intra-block bookkeeping is complete, now do the transformations. |
+ |
+ // Determine the transformation based on the kind of instruction, and |
+ // whether its Variables are infinite-weight. New instructions can be |
+ // inserted before the current instruction via Iter, or after the current |
+ // instruction via NextIter. |
+ if (Splitter.handleSimpleVarAssign()) |
+ continue; |
+ if (Splitter.handleGeneralInst()) |
+ continue; |
+ } |
+ Splitter.finalizeNode(); |
+ } |
+ |
+ Func->dump("After splitting local variables"); |
+} |
+ |
+} // end of namespace Ice |