Reflow comments to use the full width.

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.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
-/// This file implements the Inst class, primarily the various
-/// subclass constructors and dump routines.
+/// This file implements the Inst class, primarily the various subclass
+/// constructors and dump routines.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "IceInst.h"
 
 #include "IceCfg.h"
 #include "IceCfgNode.h"
 #include "IceInstVarIter.h"
 #include "IceLiveness.h"
 #include "IceOperand.h"
@@ skipping 52 matching lines @@
 
 Inst::Inst(Cfg *Func, InstKind Kind, SizeT MaxSrcs, Variable *Dest)
     : Kind(Kind), Number(Func->newInstNumber()), Dest(Dest), MaxSrcs(MaxSrcs),
       Srcs(Func->allocateArrayOf<Operand *>(MaxSrcs)), LiveRangesEnded(0) {}
 
 // Assign the instruction a new number.
 void Inst::renumber(Cfg *Func) {
   Number = isDeleted() ? NumberDeleted : Func->newInstNumber();
 }
 
-// Delete the instruction if its tentative Dead flag is still set
-// after liveness analysis.
+// Delete the instruction if its tentative Dead flag is still set after
+// liveness analysis.
 void Inst::deleteIfDead() {
   if (Dead)
     setDeleted();
 }
 
-// If Src is a Variable, it returns true if this instruction ends
-// Src's live range.  Otherwise, returns false.
+// If Src is a Variable, it returns true if this instruction ends Src's live
+// range. Otherwise, returns false.
 bool Inst::isLastUse(const Operand *TestSrc) const {
   if (LiveRangesEnded == 0)
     return false; // early-exit optimization
   if (const Variable *TestVar = llvm::dyn_cast<const Variable>(TestSrc)) {
     LREndedBits Mask = LiveRangesEnded;
     FOREACH_VAR_IN_INST(Var, *this) {
       if (Var == TestVar) {
         // We've found where the variable is used in the instruction.
         return Mask & 1;
       }
       Mask >>= 1;
       if (Mask == 0)
         return false; // another early-exit optimization
     }
   }
   return false;
 }
 
 // Given an instruction like:
 //   a = b + c + [x,y] + e
 // which was created from OrigInst:
 //   a = b + c + d + e
 // with SpliceAssn spliced in:
 //   d = [x,y]
 //
-// Reconstruct the LiveRangesEnded bitmask in this instruction by
-// combining the LiveRangesEnded values of OrigInst and SpliceAssn.
-// If operands d and [x,y] contain a different number of variables,
-// then the bitmask position for e may be different in OrigInst and
-// the current instruction, requiring extra shifts and masks in the
-// computation.  In the example above, OrigInst has variable e in bit
-// position 3, whereas the current instruction has e in bit position 4
+// Reconstruct the LiveRangesEnded bitmask in this instruction by combining the
+// LiveRangesEnded values of OrigInst and SpliceAssn. If operands d and [x,y]
+// contain a different number of variables, then the bitmask position for e may
+// be different in OrigInst and the current instruction, requiring extra shifts
+// and masks in the computation. In the example above, OrigInst has variable e
+// in bit position 3, whereas the current instruction has e in bit position 4
 // because [x,y] consumes 2 bitmask slots while d only consumed 1.
 //
-// Additionally, set HasSideEffects if either OrigInst or SpliceAssn
-// have HasSideEffects set.
+// Additionally, set HasSideEffects if either OrigInst or SpliceAssn have
+// HasSideEffects set.
 void Inst::spliceLivenessInfo(Inst *OrigInst, Inst *SpliceAssn) {
   HasSideEffects |= OrigInst->HasSideEffects;
   HasSideEffects |= SpliceAssn->HasSideEffects;
   // Find the bitmask index of SpliceAssn's dest within OrigInst.
   Variable *SpliceDest = SpliceAssn->getDest();
   SizeT Index = 0;
   for (SizeT I = 0; I < OrigInst->getSrcSize(); ++I) {
     Operand *Src = OrigInst->getSrc(I);
     if (Src == SpliceDest) {
       LREndedBits LeftMask = OrigInst->LiveRangesEnded & ((1 << Index) - 1);
@@ skipping 37 matching lines @@
           LiveBegin->push_back(std::make_pair(VarNum, InstNumber));
         }
       }
     } else {
       if (!hasSideEffects())
         Dead = true;
     }
   }
   if (Dead)
     return false;
-  // Phi arguments only get added to Live in the predecessor node, but
-  // we still need to update LiveRangesEnded.
+  // Phi arguments only get added to Live in the predecessor node, but we still
+  // need to update LiveRangesEnded.
   bool IsPhi = llvm::isa<InstPhi>(this);
   resetLastUses();
   FOREACH_VAR_IN_INST(Var, *this) {
     SizeT VarNum = Liveness->getLiveIndex(Var->getIndex());
     if (!Live[VarNum]) {
       setLastUse(IndexOfVarInInst(Var));
       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).  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.
+        // 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).
+        // 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 && Liveness->getRangeMask(Var->getIndex())) {
           // 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. Instead, livenessPostprocess() verifies this after the
           // vector has been sorted.
           LiveEnd->push_back(std::make_pair(VarNum, InstNumber));
         }
       }
     }
   }
   return true;
 }
 
 InstAlloca::InstAlloca(Cfg *Func, Operand *ByteCount, uint32_t AlignInBytes,
@@ skipping 20 matching lines @@
 
 bool InstArithmetic::isCommutative() const {
   return InstArithmeticAttributes[getOp()].IsCommutative;
 }
 
 InstAssign::InstAssign(Cfg *Func, Variable *Dest, Operand *Source)
     : InstHighLevel(Func, Inst::Assign, 1, Dest) {
   addSource(Source);
 }
 
-// If TargetTrue==TargetFalse, we turn it into an unconditional
-// branch.  This ensures that, along with the 'switch' instruction
-// semantics, there is at most one edge from one node to another.
+// If TargetTrue==TargetFalse, we turn it into an unconditional branch. This
+// ensures that, along with the 'switch' instruction semantics, there is at
+// most one edge from one node to another.
 InstBr::InstBr(Cfg *Func, Operand *Source, CfgNode *TargetTrue_,
                CfgNode *TargetFalse_)
     : InstHighLevel(Func, Inst::Br, 1, nullptr), TargetFalse(TargetFalse_),
       TargetTrue(TargetTrue_) {
   if (TargetTrue == TargetFalse) {
     TargetTrue = nullptr; // turn into unconditional version
   } else {
     addSource(Source);
   }
 }
@@ skipping 62 matching lines @@
 InstLoad::InstLoad(Cfg *Func, Variable *Dest, Operand *SourceAddr)
     : InstHighLevel(Func, Inst::Load, 1, Dest) {
   addSource(SourceAddr);
 }
 
 InstPhi::InstPhi(Cfg *Func, SizeT MaxSrcs, Variable *Dest)
     : InstHighLevel(Func, Phi, MaxSrcs, Dest) {
   Labels = Func->allocateArrayOf<CfgNode *>(MaxSrcs);
 }
 
-// TODO: A Switch instruction (and maybe others) can add duplicate
-// edges.  We may want to de-dup Phis and validate consistency (i.e.,
-// the source operands are the same for duplicate edges), though it
-// seems the current lowering code is OK with this situation.
+// TODO: A Switch instruction (and maybe others) can add duplicate edges. We
+// may want to de-dup Phis and validate consistency (i.e., the source operands
+// are the same for duplicate edges), though it seems the current lowering code
+// is OK with this situation.
 void InstPhi::addArgument(Operand *Source, CfgNode *Label) {
   Labels[getSrcSize()] = Label;
   addSource(Source);
 }
 
-// Find the source operand corresponding to the incoming edge for the
-// given node.  TODO: This uses a linear-time search, which could be
-// improved if it becomes a problem.
+// Find the source operand corresponding to the incoming edge for the given
+// node. TODO: This uses a linear-time search, which could be improved if it
+// becomes a problem.
 Operand *InstPhi::getOperandForTarget(CfgNode *Target) const {
   for (SizeT I = 0; I < getSrcSize(); ++I) {
     if (Labels[I] == Target)
       return getSrc(I);
   }
   llvm_unreachable("Phi target not found");
   return nullptr;
 }
 
-// Updates liveness for a particular operand based on the given
-// predecessor edge.  Doesn't mark the operand as live if the Phi
-// instruction is dead or deleted.
+// Updates liveness for a particular operand based on the given predecessor
+// edge. Doesn't mark the operand as live if the Phi instruction is dead or
+// deleted.
 void InstPhi::livenessPhiOperand(LivenessBV &Live, CfgNode *Target,
                                  Liveness *Liveness) {
   if (isDeleted() || Dead)
     return;
   for (SizeT I = 0; I < getSrcSize(); ++I) {
     if (Labels[I] == Target) {
       if (Variable *Var = llvm::dyn_cast<Variable>(getSrc(I))) {
         SizeT SrcIndex = Liveness->getLiveIndex(Var->getIndex());
         if (!Live[SrcIndex]) {
           setLastUse(I);
           Live[SrcIndex] = true;
         }
       }
       return;
     }
   }
   llvm_unreachable("Phi operand not found for specified target node");
 }
 
-// Change "a=phi(...)" to "a_phi=phi(...)" and return a new
-// instruction "a=a_phi".
+// Change "a=phi(...)" to "a_phi=phi(...)" and return a new instruction
+// "a=a_phi".
 Inst *InstPhi::lower(Cfg *Func) {
   Variable *Dest = getDest();
   assert(Dest);
   Variable *NewSrc = Func->makeVariable(Dest->getType());
   if (BuildDefs::dump())
     NewSrc->setName(Func, Dest->getName(Func) + "_phi");
   this->Dest = NewSrc;
   return InstAssign::create(Func, Dest, NewSrc);
 }
 
@@ skipping 163 matching lines @@
   dumpDest(Func);
   Str << " =~ ";
   dumpSources(Func);
 }
 
 void Inst::dumpExtras(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   bool First = true;
-  // Print "LIVEEND={a,b,c}" for all source operands whose live ranges
-  // are known to end at this instruction.
+  // Print "LIVEEND={a,b,c}" for all source operands whose live ranges are
+  // known to end at this instruction.
   if (Func->isVerbose(IceV_Liveness)) {
     FOREACH_VAR_IN_INST(Var, *this) {
       if (isLastUse(Var)) {
         if (First)
           Str << " // LIVEEND={";
         else
           Str << ",";
         Var->dump(Func);
         First = false;
       }
@@ skipping 302 matching lines @@
 void InstBundleUnlock::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "bundle_unlock";
 }
 
 void InstFakeDef::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
-  // Go ahead and "emit" these for now, since they are relatively
-  // rare.
+  // Go ahead and "emit" these for now, since they are relatively rare.
   Ostream &Str = Func->getContext()->getStrEmit();
   Str << "\t# ";
   getDest()->emit(Func);
   Str << " = def.pseudo ";
   emitSources(Func);
 }
 
 void InstFakeDef::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
@@ skipping 40 matching lines @@
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "[TARGET] ";
   Inst::dump(Func);
 }
 
 bool checkForRedundantAssign(const Variable *Dest, const Operand *Source) {
   const auto SrcVar = llvm::dyn_cast<const Variable>(Source);
   if (!SrcVar)
     return false;
   if (Dest->hasReg() && Dest->getRegNum() == SrcVar->getRegNum()) {
-    // TODO: On x86-64, instructions like "mov eax, eax" are used to
-    // clear the upper 32 bits of rax.  We need to recognize and
-    // preserve these.
+    // TODO: On x86-64, instructions like "mov eax, eax" are used to clear the
+    // upper 32 bits of rax. We need to recognize and preserve these.
     return true;
   }
   if (!Dest->hasReg() && !SrcVar->hasReg() &&
       Dest->getStackOffset() == SrcVar->getStackOffset())
     return true;
   return false;
 }
 
 } // end of namespace Ice