Subzero: Simplify the FakeKill instruction.

src/IceInst.cpp

 //===- subzero/src/IceInst.cpp - High-level instruction implementation ----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Inst class, primarily the various
@@ skipping 96 matching lines @@
         if (Mask == 0)
           return false; // another early-exit optimization
       }
     }
   }
   return false;
 }
 
 void Inst::livenessLightweight(Cfg *Func, LivenessBV &Live) {
   assert(!isDeleted());
-  if (llvm::isa<InstFakeKill>(this))
-    return;
   resetLastUses();
   VariablesMetadata *VMetadata = Func->getVMetadata();
   SizeT VarIndex = 0;
   for (SizeT I = 0; I < getSrcSize(); ++I) {
     Operand *Src = getSrc(I);
     SizeT NumVars = Src->getNumVars();
     for (SizeT J = 0; J < NumVars; ++J, ++VarIndex) {
       const Variable *Var = Src->getVar(J);
       if (VMetadata->isMultiBlock(Var))
         continue;
       SizeT Index = Var->getIndex();
       if (Live[Index])
         continue;
       Live[Index] = true;
       setLastUse(VarIndex);
     }
   }
 }
 
 bool Inst::liveness(InstNumberT InstNumber, LivenessBV &Live,
                     Liveness *Liveness, LiveBeginEndMap *LiveBegin,
                     LiveBeginEndMap *LiveEnd) {
   assert(!isDeleted());
-  if (llvm::isa<InstFakeKill>(this))
-    return true;
 
   Dead = false;
   if (Dest) {
     SizeT VarNum = Liveness->getLiveIndex(Dest->getIndex());
     if (Live[VarNum]) {
       if (!isDestNonKillable()) {
         Live[VarNum] = false;
         if (LiveBegin) {
           LiveBegin->push_back(std::make_pair(VarNum, InstNumber));
         }
@@ skipping 20 matching lines @@
         setLastUse(VarIndex);
         if (!IsPhi) {
           Live[VarNum] = true;
           // For a variable in SSA form, its live range can end at
           // most once in a basic block.  However, after lowering to
           // two-address instructions, we end up with sequences like
           // "t=b;t+=c;a=t" where t's live range begins and ends
           // twice.  ICE only allows a variable to have a single
           // liveness interval in a basic block (except for blocks
           // where a variable is live-in and live-out but there is a
-          // gap in the middle, and except for the special
-          // InstFakeKill instruction that can appear multiple
-          // times in the same block).  Therefore, this lowered
-          // sequence needs to represent a single conservative live
-          // range for t.  Since the instructions are being traversed
-          // backwards, we make sure LiveEnd is only set once by
-          // setting it only when LiveEnd[VarNum]==0 (sentinel value).
-          // Note that it's OK to set LiveBegin multiple times because
-          // of the backwards traversal.
+          // gap in the middle).  Therefore, this lowered sequence
+          // needs to represent a single conservative live range for
+          // t.  Since the instructions are being traversed backwards,
+          // we make sure LiveEnd is only set once by setting it only
+          // when LiveEnd[VarNum]==0 (sentinel value).  Note that it's
+          // OK to set LiveBegin multiple times because of the
+          // backwards traversal.
           if (LiveEnd) {
             // Ideally, we would verify that VarNum wasn't already
             // added in this block, but this can't be done very
             // efficiently with LiveEnd as a vector.  Instead,
             // livenessPostprocess() verifies this after the vector
             // has been sorted.
             LiveEnd->push_back(std::make_pair(VarNum, InstNumber));
           }
         }
       }
@@ skipping 242 matching lines @@
   if (Src)
     addSource(Src);
 }
 
 InstFakeUse::InstFakeUse(Cfg *Func, Variable *Src)
     : InstHighLevel(Func, Inst::FakeUse, 1, NULL) {
   assert(Src);
   addSource(Src);
 }
 
-InstFakeKill::InstFakeKill(Cfg *Func, const VarList &KilledRegs,
-                           const Inst *Linked)
-    : InstHighLevel(Func, Inst::FakeKill, 0, NULL), KilledRegs(KilledRegs),
-      Linked(Linked) {}
+InstFakeKill::InstFakeKill(Cfg *Func, const Inst *Linked)
+    : InstHighLevel(Func, Inst::FakeKill, 0, NULL), Linked(Linked) {}
 
 // ======================== Dump routines ======================== //
 
 void Inst::dumpDecorated(const Cfg *Func) const {
   Ostream &Str = Func->getContext()->getStrDump();
   if (!Func->getContext()->isVerbose(IceV_Deleted) &&
       (isDeleted() || isRedundantAssign()))
     return;
   if (Func->getContext()->isVerbose(IceV_InstNumbers)) {
     char buf[30];
@@ skipping 281 matching lines @@
   Str << "use.pseudo ";
   dumpSources(Func);
 }
 
 void InstFakeKill::emit(const Cfg *Func) const { (void)Func; }
 
 void InstFakeKill::dump(const Cfg *Func) const {
   Ostream &Str = Func->getContext()->getStrDump();
   if (Linked->isDeleted())
     Str << "// ";
-  Str << "kill.pseudo ";
-  bool First = true;
-  for (Variable *Var : KilledRegs) {
-    if (!First)
-      Str << ", ";
-    First = false;
-    Var->dump(Func);
-  }
+  Str << "kill.pseudo scratch_regs";
 }
 
 void InstTarget::dump(const Cfg *Func) const {
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "[TARGET] ";
   Inst::dump(Func);
 }
 
 } // end of namespace Ice