Reflow comments to use the full width.

src/IceTargetLowering.cpp

 //===- subzero/src/IceTargetLowering.cpp - Basic lowering 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 skeleton of the TargetLowering class,
-/// specifically invoking the appropriate lowering method for a given
-/// instruction kind and driving global register allocation.  It also
-/// implements the non-deleted instruction iteration in
-/// LoweringContext.
+/// This file implements the skeleton of the TargetLowering class, specifically
+/// invoking the appropriate lowering method for a given instruction kind and
+/// driving global register allocation. It also implements the non-deleted
+/// instruction iteration in LoweringContext.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "IceTargetLowering.h"
 
 #include "IceAssemblerARM32.h"
 #include "IceAssemblerMIPS32.h"
 #include "IceAssemblerX8632.h"
 #include "IceAssemblerX8664.h"
 #include "IceCfg.h" // setError()
@@ skipping 84 matching lines @@
                     llvm::isa<InstFakeKill>(I) || I->isRedundantAssign() ||
                     I->isDeleted();
   if (!ShouldSkip) {
     int Probability = Ctx->getFlags().getNopProbabilityAsPercentage();
     for (int I = 0; I < Ctx->getFlags().getMaxNopsPerInstruction(); ++I) {
       randomlyInsertNop(Probability / 100.0, RNG);
     }
   }
 }
 
-// Lowers a single instruction according to the information in
-// Context, by checking the Context.Cur instruction kind and calling
-// the appropriate lowering method.  The lowering method should insert
-// target instructions at the Cur.Next insertion point, and should not
-// delete the Context.Cur instruction or advance Context.Cur.
+// Lowers a single instruction according to the information in Context, by
+// checking the Context.Cur instruction kind and calling the appropriate
+// lowering method. The lowering method should insert target instructions at
+// the Cur.Next insertion point, and should not delete the Context.Cur
+// instruction or advance Context.Cur.
 //
-// The lowering method may look ahead in the instruction stream as
-// desired, and lower additional instructions in conjunction with the
-// current one, for example fusing a compare and branch.  If it does,
-// it should advance Context.Cur to point to the next non-deleted
-// instruction to process, and it should delete any additional
-// instructions it consumes.
+// The lowering method may look ahead in the instruction stream as desired, and
+// lower additional instructions in conjunction with the current one, for
+// example fusing a compare and branch. If it does, it should advance
+// Context.Cur to point to the next non-deleted instruction to process, and it
+// should delete any additional instructions it consumes.
 void TargetLowering::lower() {
   assert(!Context.atEnd());
   Inst *Inst = Context.getCur();
   Inst->deleteIfDead();
   if (!Inst->isDeleted() && !llvm::isa<InstFakeDef>(Inst) &&
       !llvm::isa<InstFakeUse>(Inst)) {
-    // Mark the current instruction as deleted before lowering,
-    // otherwise the Dest variable will likely get marked as non-SSA.
-    // See Variable::setDefinition().  However, just pass-through
-    // FakeDef and FakeUse instructions that might have been inserted
-    // prior to lowering.
+    // Mark the current instruction as deleted before lowering, otherwise the
+    // Dest variable will likely get marked as non-SSA. See
+    // Variable::setDefinition(). However, just pass-through FakeDef and
+    // FakeUse instructions that might have been inserted prior to lowering.
     Inst->setDeleted();
     switch (Inst->getKind()) {
     case Inst::Alloca:
       lowerAlloca(llvm::cast<InstAlloca>(Inst));
       break;
     case Inst::Arithmetic:
       lowerArithmetic(llvm::cast<InstArithmetic>(Inst));
       break;
     case Inst::Assign:
       lowerAssign(llvm::cast<InstAssign>(Inst));
@@ skipping 71 matching lines @@
   assert(&*Next == Instr);
   Context.setCur(Next);
   lower();
 }
 
 void TargetLowering::lowerOther(const Inst *Instr) {
   (void)Instr;
   Func->setError("Can't lower unsupported instruction type");
 }
 
-// Drives register allocation, allowing all physical registers (except
-// perhaps for the frame pointer) to be allocated.  This set of
-// registers could potentially be parameterized if we want to restrict
-// registers e.g. for performance testing.
+// Drives register allocation, allowing all physical registers (except perhaps
+// for the frame pointer) to be allocated. This set of registers could
+// potentially be parameterized if we want to restrict registers e.g. for
+// performance testing.
 void TargetLowering::regAlloc(RegAllocKind Kind) {
   TimerMarker T(TimerStack::TT_regAlloc, Func);
   LinearScan LinearScan(Func);
   RegSetMask RegInclude = RegSet_None;
   RegSetMask RegExclude = RegSet_None;
   RegInclude |= RegSet_CallerSave;
   RegInclude |= RegSet_CalleeSave;
   if (hasFramePointer())
     RegExclude |= RegSet_FramePointer;
   LinearScan.init(Kind);
   llvm::SmallBitVector RegMask = getRegisterSet(RegInclude, RegExclude);
   LinearScan.scan(RegMask, Ctx->getFlags().shouldRandomizeRegAlloc());
 }
 
 void TargetLowering::inferTwoAddress() {
-  // Find two-address non-SSA instructions where Dest==Src0, and set
-  // the DestNonKillable flag to keep liveness analysis consistent.
+  // Find two-address non-SSA instructions where Dest==Src0, and set the
+  // DestNonKillable flag to keep liveness analysis consistent.
   for (auto Inst = Context.getCur(), E = Context.getNext(); Inst != E; ++Inst) {
     if (Inst->isDeleted())
       continue;
     if (Variable *Dest = Inst->getDest()) {
-      // TODO(stichnot): We may need to consider all source
-      // operands, not just the first one, if using 3-address
-      // instructions.
+      // TODO(stichnot): We may need to consider all source operands, not just
+      // the first one, if using 3-address instructions.
       if (Inst->getSrcSize() > 0 && Inst->getSrc(0) == Dest)
         Inst->setDestNonKillable();
     }
   }
 }
 
 void TargetLowering::sortVarsByAlignment(VarList &Dest,
                                          const VarList &Source) const {
   Dest = Source;
-  // Instead of std::sort, we could do a bucket sort with log2(alignment)
-  // as the buckets, if performance is an issue.
+  // Instead of std::sort, we could do a bucket sort with log2(alignment) as
+  // the buckets, if performance is an issue.
   std::sort(Dest.begin(), Dest.end(),
             [this](const Variable *V1, const Variable *V2) {
               return typeWidthInBytesOnStack(V1->getType()) >
                      typeWidthInBytesOnStack(V2->getType());
             });
 }
 
 void TargetLowering::getVarStackSlotParams(
     VarList &SortedSpilledVariables, llvm::SmallBitVector &RegsUsed,
     size_t *GlobalsSize, size_t *SpillAreaSizeBytes,
     uint32_t *SpillAreaAlignmentBytes, uint32_t *LocalsSlotsAlignmentBytes,
     std::function<bool(Variable *)> TargetVarHook) {
   const VariablesMetadata *VMetadata = Func->getVMetadata();
   llvm::BitVector IsVarReferenced(Func->getNumVariables());
   for (CfgNode *Node : Func->getNodes()) {
     for (Inst &Inst : Node->getInsts()) {
       if (Inst.isDeleted())
         continue;
       if (const Variable *Var = Inst.getDest())
         IsVarReferenced[Var->getIndex()] = true;
       FOREACH_VAR_IN_INST(Var, Inst) {
         IsVarReferenced[Var->getIndex()] = true;
       }
     }
   }
 
-  // If SimpleCoalescing is false, each variable without a register
-  // gets its own unique stack slot, which leads to large stack
-  // frames.  If SimpleCoalescing is true, then each "global" variable
-  // without a register gets its own slot, but "local" variable slots
-  // are reused across basic blocks.  E.g., if A and B are local to
-  // block 1 and C is local to block 2, then C may share a slot with A or B.
+  // If SimpleCoalescing is false, each variable without a register gets its
+  // own unique stack slot, which leads to large stack frames. If
+  // SimpleCoalescing is true, then each "global" variable without a register
+  // gets its own slot, but "local" variable slots are reused across basic
+  // blocks. E.g., if A and B are local to block 1 and C is local to block 2,
+  // then C may share a slot with A or B.
   //
   // We cannot coalesce stack slots if this function calls a "returns twice"
-  // function. In that case, basic blocks may be revisited, and variables
-  // local to those basic blocks are actually live until after the
-  // called function returns a second time.
+  // function. In that case, basic blocks may be revisited, and variables local
+  // to those basic blocks are actually live until after the called function
+  // returns a second time.
   const bool SimpleCoalescing = !callsReturnsTwice();
 
   std::vector<size_t> LocalsSize(Func->getNumNodes());
   const VarList &Variables = Func->getVariables();
   VarList SpilledVariables;
   for (Variable *Var : Variables) {
     if (Var->hasReg()) {
       RegsUsed[Var->getRegNum()] = true;
       continue;
     }
-    // An argument either does not need a stack slot (if passed in a
-    // register) or already has one (if passed on the stack).
+    // An argument either does not need a stack slot (if passed in a register)
+    // or already has one (if passed on the stack).
     if (Var->getIsArg())
       continue;
     // An unreferenced variable doesn't need a stack slot.
     if (!IsVarReferenced[Var->getIndex()])
       continue;
-    // Check a target-specific variable (it may end up sharing stack slots)
-    // and not need accounting here.
+    // Check a target-specific variable (it may end up sharing stack slots) and
+    // not need accounting here.
     if (TargetVarHook(Var))
       continue;
     SpilledVariables.push_back(Var);
   }
 
   SortedSpilledVariables.reserve(SpilledVariables.size());
   sortVarsByAlignment(SortedSpilledVariables, SpilledVariables);
 
   for (Variable *Var : SortedSpilledVariables) {
     size_t Increment = typeWidthInBytesOnStack(Var->getType());
-    // We have sorted by alignment, so the first variable we encounter that
-    // is located in each area determines the max alignment for the area.
+    // We have sorted by alignment, so the first variable we encounter that is
+    // located in each area determines the max alignment for the area.
     if (!*SpillAreaAlignmentBytes)
       *SpillAreaAlignmentBytes = Increment;
     if (SimpleCoalescing && VMetadata->isTracked(Var)) {
       if (VMetadata->isMultiBlock(Var)) {
         *GlobalsSize += Increment;
       } else {
         SizeT NodeIndex = VMetadata->getLocalUseNode(Var)->getIndex();
         LocalsSize[NodeIndex] += Increment;
         if (LocalsSize[NodeIndex] > *SpillAreaSizeBytes)
           *SpillAreaSizeBytes = LocalsSize[NodeIndex];
@@ skipping 15 matching lines @@
                                           uint32_t LocalsSlotsAlignmentBytes,
                                           uint32_t *SpillAreaPaddingBytes,
                                           uint32_t *LocalsSlotsPaddingBytes) {
   if (SpillAreaAlignmentBytes) {
     uint32_t PaddingStart = SpillAreaStartOffset;
     uint32_t SpillAreaStart =
         Utils::applyAlignment(PaddingStart, SpillAreaAlignmentBytes);
     *SpillAreaPaddingBytes = SpillAreaStart - PaddingStart;
   }
 
-  // If there are separate globals and locals areas, make sure the
-  // locals area is aligned by padding the end of the globals area.
+  // If there are separate globals and locals areas, make sure the locals area
+  // is aligned by padding the end of the globals area.
   if (LocalsSlotsAlignmentBytes) {
     uint32_t GlobalsAndSubsequentPaddingSize = GlobalsSize;
     GlobalsAndSubsequentPaddingSize =
         Utils::applyAlignment(GlobalsSize, LocalsSlotsAlignmentBytes);
     *LocalsSlotsPaddingBytes = GlobalsAndSubsequentPaddingSize - GlobalsSize;
   }
 }
 
 void TargetLowering::assignVarStackSlots(VarList &SortedSpilledVariables,
                                          size_t SpillAreaPaddingBytes,
                                          size_t SpillAreaSizeBytes,
                                          size_t GlobalsAndSubsequentPaddingSize,
                                          bool UsesFramePointer) {
   const VariablesMetadata *VMetadata = Func->getVMetadata();
   // For testing legalization of large stack offsets on targets with limited
   // offset bits in instruction encodings, add some padding. This assumes that
-  // SpillAreaSizeBytes has accounted for the extra test padding.
-  // When UseFramePointer is true, the offset depends on the padding,
-  // not just the SpillAreaSizeBytes. On the other hand, when UseFramePointer
-  // is false, the offsets depend on the gap between SpillAreaSizeBytes
-  // and SpillAreaPaddingBytes, so we don't increment that.
+  // SpillAreaSizeBytes has accounted for the extra test padding. When
+  // UseFramePointer is true, the offset depends on the padding, not just the
+  // SpillAreaSizeBytes. On the other hand, when UseFramePointer is false, the
+  // offsets depend on the gap between SpillAreaSizeBytes and
+  // SpillAreaPaddingBytes, so we don't increment that.
   size_t TestPadding = Ctx->getFlags().getTestStackExtra();
   if (UsesFramePointer)
     SpillAreaPaddingBytes += TestPadding;
   size_t GlobalsSpaceUsed = SpillAreaPaddingBytes;
   size_t NextStackOffset = SpillAreaPaddingBytes;
   std::vector<size_t> LocalsSize(Func->getNumNodes());
   const bool SimpleCoalescing = !callsReturnsTwice();
 
   for (Variable *Var : SortedSpilledVariables) {
     size_t Increment = typeWidthInBytesOnStack(Var->getType());
@@ skipping 90 matching lines @@
   return "." + SectionSuffix;
 }
 
 } // end of anonymous namespace
 
 void TargetDataLowering::emitGlobal(const VariableDeclaration &Var,
                                     const IceString &SectionSuffix) {
   if (!BuildDefs::dump())
     return;
 
-  // If external and not initialized, this must be a cross test.
-  // Don't generate a declaration for such cases.
+  // If external and not initialized, this must be a cross test. Don't generate
+  // a declaration for such cases.
   const bool IsExternal =
       Var.isExternal() || Ctx->getFlags().getDisableInternal();
   if (IsExternal && !Var.hasInitializer())
     return;
 
   Ostream &Str = Ctx->getStrEmit();
   const bool HasNonzeroInitializer = Var.hasNonzeroInitializer();
   const bool IsConstant = Var.getIsConstant();
   const SizeT Size = Var.getNumBytes();
   const IceString MangledName = Var.mangleName(Ctx);
@@ skipping 49 matching lines @@
             Str << " + " << Offset;
           else
             Str << " - " << -Offset;
         }
         Str << "\n";
         break;
       }
       }
     }
   } else {
-    // NOTE: for non-constant zero initializers, this is BSS (no bits),
-    // so an ELF writer would not write to the file, and only track
-    // virtual offsets, but the .s writer still needs this .zero and
-    // cannot simply use the .size to advance offsets.
+    // NOTE: for non-constant zero initializers, this is BSS (no bits), so an
+    // ELF writer would not write to the file, and only track virtual offsets,
+    // but the .s writer still needs this .zero and cannot simply use the .size
+    // to advance offsets.
     Str << "\t.zero\t" << Size << "\n";
   }
 
   Str << "\t.size\t" << MangledName << ", " << Size << "\n";
 }
 
 std::unique_ptr<TargetHeaderLowering>
 TargetHeaderLowering::createLowering(GlobalContext *Ctx) {
   TargetArch Target = Ctx->getFlags().getTargetArch();
 #define SUBZERO_TARGET(X)                                                      \
   if (Target == Target_##X)                                                    \
     return TargetHeader##X::create(Ctx);
 #include "llvm/Config/SZTargets.def"
 
   llvm::report_fatal_error("Unsupported target header lowering");
 }
 
 TargetHeaderLowering::~TargetHeaderLowering() = default;
 
 } // end of namespace Ice