Reflow comments to use the full width.

src/IceCfg.h

 //===- subzero/src/IceCfg.h - Control flow graph ----------------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
-/// This file declares the Cfg class, which represents the control flow
-/// graph and the overall per-function compilation context.
+/// This file declares the Cfg class, which represents the control flow graph
+/// and the overall per-function compilation context.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICECFG_H
 #define SUBZERO_SRC_ICECFG_H
 
 #include "IceAssembler.h"
 #include "IceClFlags.h"
 #include "IceDefs.h"
 #include "IceGlobalContext.h"
@@ skipping 20 matching lines @@
   }
   /// Gets a pointer to the current thread's Cfg's allocator.
   static ArenaAllocator<> *getCurrentCfgAllocator() {
     assert(ICE_TLS_GET_FIELD(CurrentCfg));
     return ICE_TLS_GET_FIELD(CurrentCfg)->Allocator.get();
   }
 
   GlobalContext *getContext() const { return Ctx; }
   uint32_t getSequenceNumber() const { return SequenceNumber; }
 
-  /// Returns true if any of the specified options in the verbose mask
-  /// are set.  If the argument is omitted, it checks if any verbose
-  /// options at all are set.
+  /// Returns true if any of the specified options in the verbose mask are set.
+  /// If the argument is omitted, it checks if any verbose options at all are
+  /// set.
   bool isVerbose(VerboseMask Mask = IceV_All) const { return VMask & Mask; }
   void setVerbose(VerboseMask Mask) { VMask = Mask; }
 
   /// \name Manage the name and return type of the function being translated.
   /// @{
   void setFunctionName(const IceString &Name) { FunctionName = Name; }
   IceString getFunctionName() const { return FunctionName; }
   void setReturnType(Type Ty) { ReturnType = Ty; }
   /// @}
 
   /// \name Manage the "internal" attribute of the function.
   /// @{
   void setInternal(bool Internal) { IsInternalLinkage = Internal; }
   bool getInternal() const { return IsInternalLinkage; }
   /// @}
 
   /// \name Manage errors.
   /// @{
 
-  /// Translation error flagging.  If support for some construct is
-  /// known to be missing, instead of an assertion failure, setError()
-  /// should be called and the error should be propagated back up.
-  /// This way, we can gracefully fail to translate and let a fallback
-  /// translator handle the function.
+  /// Translation error flagging. If support for some construct is known to be
+  /// missing, instead of an assertion failure, setError() should be called and
+  /// the error should be propagated back up. This way, we can gracefully fail
+  /// to translate and let a fallback translator handle the function.
   void setError(const IceString &Message);
   bool hasError() const { return HasError; }
   IceString getError() const { return ErrorMessage; }
   /// @}
 
   /// \name Manage nodes (a.k.a. basic blocks, CfgNodes).
   /// @{
   void setEntryNode(CfgNode *EntryNode) { Entry = EntryNode; }
   CfgNode *getEntryNode() const { return Entry; }
   /// Create a node and append it to the end of the linearized list. The loop
   /// nest depth of the new node may not be valid if it is created after
   /// computeLoopNestDepth.
   CfgNode *makeNode();
   SizeT getNumNodes() const { return Nodes.size(); }
   const NodeList &getNodes() const { return Nodes; }
   /// Swap nodes of Cfg with given list of nodes.  The number of nodes must
   /// remain unchanged.
   void swapNodes(NodeList &NewNodes);
   /// @}
 
   using IdentifierIndexType = int32_t;
-  /// Adds a name to the list and returns its index, suitable for the
-  /// argument to getIdentifierName().  No checking for duplicates is
-  /// done.  This is generally used for node names and variable names
-  /// to avoid embedding a std::string inside an arena-allocated
-  /// object.
+  /// Adds a name to the list and returns its index, suitable for the argument
+  /// to getIdentifierName(). No checking for duplicates is done. This is
+  /// generally used for node names and variable names to avoid embedding a
+  /// std::string inside an arena-allocated object.
   IdentifierIndexType addIdentifierName(const IceString &Name) {
     IdentifierIndexType Index = IdentifierNames.size();
     IdentifierNames.push_back(Name);
     return Index;
   }
   const IceString &getIdentifierName(IdentifierIndexType Index) const {
     return IdentifierNames[Index];
   }
   enum { IdentifierIndexInvalid = -1 };
 
   /// \name Manage instruction numbering.
   /// @{
   InstNumberT newInstNumber() { return NextInstNumber++; }
   InstNumberT getNextInstNumber() const { return NextInstNumber; }
   /// @}
 
   /// \name Manage Variables.
   /// @{
 
-  /// Create a new Variable with a particular type and an optional
-  /// name.  The Node argument is the node where the variable is defined.
+  /// Create a new Variable with a particular type and an optional name. The
+  /// Node argument is the node where the variable is defined.
   // TODO(jpp): untemplate this with separate methods: makeVariable,
   // makeSpillVariable, and makeStackVariable.
   template <typename T = Variable> T *makeVariable(Type Ty) {
     SizeT Index = Variables.size();
     T *Var = T::create(this, Ty, Index);
     Variables.push_back(Var);
     return Var;
   }
   SizeT getNumVariables() const { return Variables.size(); }
   const VarList &getVariables() const { return Variables; }
@@ skipping 32 matching lines @@
   void setFocusedTiming() { FocusedTiming = true; }
   uint32_t getConstantBlindingCookie() const { return ConstantBlindingCookie; }
   /// @}
 
   /// Returns true if Var is a global variable that is used by the profiling
   /// code.
   static bool isProfileGlobal(const VariableDeclaration &Var);
 
   /// Passes over the CFG.
   void translate();
-  /// After the CFG is fully constructed, iterate over the nodes and
-  /// compute the predecessor and successor edges, in the form of
-  /// CfgNode::InEdges[] and CfgNode::OutEdges[].
+  /// After the CFG is fully constructed, iterate over the nodes and compute the
+  /// predecessor and successor edges, in the form of CfgNode::InEdges[] and
+  /// CfgNode::OutEdges[].
   void computeInOutEdges();
   void renumberInstructions();
   void placePhiLoads();
   void placePhiStores();
   void deletePhis();
   void advancedPhiLowering();
   void reorderNodes();
   void shuffleNodes();
   void doAddressOpt();
   void doArgLowering();
@@ skipping 78 matching lines @@
   VarList ImplicitArgs; /// subset of Variables
   std::unique_ptr<ArenaAllocator<>> Allocator;
   std::unique_ptr<Liveness> Live;
   std::unique_ptr<TargetLowering> Target;
   std::unique_ptr<VariablesMetadata> VMetadata;
   std::unique_ptr<Assembler> TargetAssembler;
   /// Globals required by this CFG. Mostly used for the profiler's globals.
   std::unique_ptr<VariableDeclarationList> GlobalInits;
   std::vector<InstJumpTable *> JumpTables;
 
-  /// CurrentNode is maintained during dumping/emitting just for
-  /// validating Variable::DefNode.  Normally, a traversal over
-  /// CfgNodes maintains this, but before global operations like
-  /// register allocation, resetCurrentNode() should be called to avoid
-  /// spurious validation failures.
+  /// CurrentNode is maintained during dumping/emitting just for validating
+  /// Variable::DefNode. Normally, a traversal over CfgNodes maintains this, but
+  /// before global operations like register allocation, resetCurrentNode()
+  /// should be called to avoid spurious validation failures.
   const CfgNode *CurrentNode = nullptr;
 
-  /// Maintain a pointer in TLS to the current Cfg being translated.
-  /// This is primarily for accessing its allocator statelessly, but
-  /// other uses are possible.
+  /// Maintain a pointer in TLS to the current Cfg being translated. This is
+  /// primarily for accessing its allocator statelessly, but other uses are
+  /// possible.
   ICE_TLS_DECLARE_FIELD(const Cfg *, CurrentCfg);
 
 public:
   static void TlsInit() { ICE_TLS_INIT_FIELD(CurrentCfg); }
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICECFG_H