Reflow comments to use the full width.

src/IceOperand.cpp

 //===- subzero/src/IceOperand.cpp - High-level operand implementation -----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 30 matching lines @@
     InstNumberT CurrentEnd = Range.back().second;
     assert(Start >= CurrentEnd);
     if (Start == CurrentEnd) {
       Range.back().second = End;
       return;
     }
   }
   Range.push_back(RangeElementType(Start, End));
 }
 
-// Returns true if this live range ends before Other's live range
-// starts.  This means that the highest instruction number in this
-// live range is less than or equal to the lowest instruction number
-// of the Other live range.
+// Returns true if this live range ends before Other's live range starts. This
+// means that the highest instruction number in this live range is less than or
+// equal to the lowest instruction number of the Other live range.
 bool LiveRange::endsBefore(const LiveRange &Other) const {
   // Neither range should be empty, but let's be graceful.
   if (Range.empty() || Other.Range.empty())
     return true;
   InstNumberT MyEnd = (*Range.rbegin()).second;
   InstNumberT OtherStart = (*Other.Range.begin()).first;
   return MyEnd <= OtherStart;
 }
 
 // Returns true if there is any overlap between the two live ranges.
@@ skipping 22 matching lines @@
        I != E; ++I) {
     if (OtherBegin < I->first) {
       Result = false;
       break;
     }
     if (OtherBegin < I->second) {
       Result = true;
       break;
     }
   }
-  // This is an equivalent but less inefficient implementation.  It's
-  // expensive enough that we wouldn't want to run it under any build,
-  // but it could be enabled if e.g. the LiveRange implementation
-  // changes and extra testing is needed.
+  // This is an equivalent but less inefficient implementation. It's expensive
+  // enough that we wouldn't want to run it under any build, but it could be
+  // enabled if e.g. the LiveRange implementation changes and extra testing is
+  // needed.
   if (BuildDefs::extraValidation()) {
     LiveRange Temp;
     Temp.addSegment(OtherBegin, OtherBegin + 1);
     bool Validation = overlaps(Temp);
     (void)Validation;
     assert(Result == Validation);
   }
   return Result;
 }
 
-// Returns true if the live range contains the given instruction
-// number.  This is only used for validating the live range
-// calculation.  The IsDest argument indicates whether the Variable
-// being tested is used in the Dest position (as opposed to a Src
-// position).
+// Returns true if the live range contains the given instruction number. This
+// is only used for validating the live range calculation. The IsDest argument
+// indicates whether the Variable being tested is used in the Dest position (as
+// opposed to a Src position).
 bool LiveRange::containsValue(InstNumberT Value, bool IsDest) const {
   for (const RangeElementType &I : Range) {
     if (I.first <= Value &&
         (Value < I.second || (!IsDest && Value == I.second)))
       return true;
   }
   return false;
 }
 
 void LiveRange::trim(InstNumberT Lower) {
   while (TrimmedBegin != Range.end() && TrimmedBegin->second <= Lower)
     ++TrimmedBegin;
 }
 
 IceString Variable::getName(const Cfg *Func) const {
   if (Func && NameIndex >= 0)
     return Func->getIdentifierName(NameIndex);
   return "__" + std::to_string(getIndex());
 }
 
 Variable *Variable::asType(Type Ty) {
-  // Note: This returns a Variable, even if the "this" object is a
-  // subclass of Variable.
+  // Note: This returns a Variable, even if the "this" object is a subclass of
+  // Variable.
   if (!BuildDefs::dump() || getType() == Ty)
     return this;
   Variable *V = new (getCurrentCfgAllocator()->Allocate<Variable>())
       Variable(kVariable, Ty, Number);
   V->NameIndex = NameIndex;
   V->RegNum = RegNum;
   V->StackOffset = StackOffset;
   return V;
 }
 
@@ skipping 15 matching lines @@
   constexpr SizeT MaxShift = sizeof(uint32_t) * CHAR_BIT - 1;
   constexpr SizeT MaxLoopNestDepth = MaxShift / LogLoopTripCountEstimate;
   const uint32_t LoopNestDepth =
       std::min(Node->getLoopNestDepth(), MaxLoopNestDepth);
   const uint32_t ThisUseWeight = uint32_t(1)
                                  << LoopNestDepth * LogLoopTripCountEstimate;
   UseWeight.addWeight(ThisUseWeight);
 
   if (MultiBlock == MBS_MultiBlock)
     return;
-  // TODO(stichnot): If the use occurs as a source operand in the
-  // first instruction of the block, and its definition is in this
-  // block's only predecessor, we might consider not marking this as a
-  // separate use.  This may also apply if it's the first instruction
-  // of the block that actually uses a Variable.
+  // TODO(stichnot): If the use occurs as a source operand in the first
+  // instruction of the block, and its definition is in this block's only
+  // predecessor, we might consider not marking this as a separate use. This
+  // may also apply if it's the first instruction of the block that actually
+  // uses a Variable.
   assert(Node);
   bool MakeMulti = false;
   if (IsImplicit)
     MakeMulti = true;
-  // A phi source variable conservatively needs to be marked as
-  // multi-block, even if its definition is in the same block.  This
-  // is because there can be additional control flow before branching
-  // back to this node, and the variable is live throughout those
-  // nodes.
+  // A phi source variable conservatively needs to be marked as multi-block,
+  // even if its definition is in the same block. This is because there can be
+  // additional control flow before branching back to this node, and the
+  // variable is live throughout those nodes.
   if (Instr && llvm::isa<InstPhi>(Instr))
     MakeMulti = true;
 
   if (!MakeMulti) {
     switch (MultiBlock) {
     case MBS_Unknown:
       MultiBlock = MBS_SingleBlock;
       SingleUseNode = Node;
       break;
     case MBS_SingleBlock:
       if (SingleUseNode != Node)
         MakeMulti = true;
       break;
     case MBS_MultiBlock:
       break;
     }
   }
 
   if (MakeMulti) {
     MultiBlock = MBS_MultiBlock;
     SingleUseNode = nullptr;
   }
 }
 
 void VariableTracking::markDef(MetadataKind TrackingKind, const Inst *Instr,
                                CfgNode *Node) {
-  // TODO(stichnot): If the definition occurs in the last instruction
-  // of the block, consider not marking this as a separate use.  But
-  // be careful not to omit all uses of the variable if markDef() and
-  // markUse() both use this optimization.
+  // TODO(stichnot): If the definition occurs in the last instruction of the
+  // block, consider not marking this as a separate use. But be careful not to
+  // omit all uses of the variable if markDef() and markUse() both use this
+  // optimization.
   assert(Node);
 // Verify that instructions are added in increasing order.
 #ifndef NDEBUG
   if (TrackingKind == VMK_All) {
     const Inst *LastInstruction =
         Definitions.empty() ? FirstOrSingleDefinition : Definitions.back();
     assert(LastInstruction == nullptr ||
            Instr->getNumber() >= LastInstruction->getNumber());
   }
 #endif
@@ skipping 282 matching lines @@
     return Str;
   if (W.getWeight() == RegWeight::Inf)
     Str << "Inf";
   else
     Str << W.getWeight();
   return Str;
 }
 
 // =========== Immediate Randomization and Pooling routines ==============
 // Specialization of the template member function for ConstantInteger32
-// TODO(stichnot): try to move this specialization into a target-specific
-// file.
+// TODO(stichnot): try to move this specialization into a target-specific file.
 template <>
 bool ConstantInteger32::shouldBeRandomizedOrPooled(const GlobalContext *Ctx) {
   uint32_t Threshold = Ctx->getFlags().getRandomizeAndPoolImmediatesThreshold();
   if (Ctx->getFlags().getRandomizeAndPoolImmediatesOption() == RPI_None)
     return false;
   if (getType() != IceType_i32 && getType() != IceType_i16 &&
       getType() != IceType_i8)
     return false;
   // The Following checks if the signed representation of Value is between
   // -Threshold/2 and +Threshold/2
   bool largerThanThreshold = Threshold / 2 + Value >= Threshold;
   return largerThanThreshold;
 }
 
 } // end of namespace Ice