Reflow comments to use the full width.

src/IceDefs.h

 //===- subzero/src/IceDefs.h - Common Subzero declarations ------*- 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 various useful types and classes that have widespread use
-/// across Subzero.  Every Subzero source file is expected to include IceDefs.h.
+/// across Subzero. Every Subzero source file is expected to include IceDefs.h.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEDEFS_H
 #define SUBZERO_SRC_ICEDEFS_H
 
 #include "IceBuildDefs.h" // TODO(stichnot): move into individual files
 #include "IceTLS.h"
 
 #include "llvm/ADT/ArrayRef.h"
@@ skipping 69 matching lines @@
                        const CfgLocalAllocator<U> &) {
   return true;
 }
 template <typename T, typename U>
 inline bool operator!=(const CfgLocalAllocator<T> &,
                        const CfgLocalAllocator<U> &) {
   return false;
 }
 
 // makeUnique should be used when memory is expected to be allocated from the
-// heap (as opposed to allocated from some Allocator.) It is intended to be used
-// instead of new.
+// heap (as opposed to allocated from some Allocator.) It is intended to be
+// used instead of new.
 //
 // The expected usage is as follows
 //
 // class MyClass {
 // public:
 //   static std::unique_ptr<MyClass> create(<ctor_args>) {
 //     return makeUnique<MyClass>(<ctor_args>);
 //   }
 //
 // private:
@@ skipping 19 matching lines @@
 template <class T, class... Args>
 static std::unique_ptr<T> makeUnique(Args &&... TheArgs) {
   return ::Ice::Internal::MakeUniqueEnabler::create<T>(
       std::forward<Args>(TheArgs)...);
 }
 
 #define ENABLE_MAKE_UNIQUE friend struct ::Ice::Internal::MakeUniqueEnabler
 
 using IceString = std::string;
 using InstList = llvm::ilist<Inst>;
-// Ideally PhiList would be llvm::ilist<InstPhi>, and similar for
-// AssignList, but this runs into issues with SFINAE.
+// Ideally PhiList would be llvm::ilist<InstPhi>, and similar for AssignList,
+// but this runs into issues with SFINAE.
 using PhiList = InstList;
 using AssignList = InstList;
 
 // Containers that are arena-allocated from the Cfg's allocator.
 using OperandList = std::vector<Operand *, CfgLocalAllocator<Operand *>>;
 using VarList = std::vector<Variable *, CfgLocalAllocator<Variable *>>;
 using NodeList = std::vector<CfgNode *, CfgLocalAllocator<CfgNode *>>;
 
 // Contains that use the default (global) allocator.
 using ConstantList = std::vector<Constant *>;
 using FunctionDeclarationList = std::vector<FunctionDeclaration *>;
 using VariableDeclarationList = std::vector<VariableDeclaration *>;
 
-/// SizeT is for holding small-ish limits like number of source
-/// operands in an instruction.  It is used instead of size_t (which
-/// may be 64-bits wide) when we want to save space.
+/// SizeT is for holding small-ish limits like number of source operands in an
+/// instruction. It is used instead of size_t (which may be 64-bits wide) when
+/// we want to save space.
 using SizeT = uint32_t;
 
-/// InstNumberT is for holding an instruction number.  Instruction
-/// numbers are used for representing Variable live ranges.
+/// InstNumberT is for holding an instruction number. Instruction numbers are
+/// used for representing Variable live ranges.
 using InstNumberT = int32_t;
 
-/// A LiveBeginEndMapEntry maps a Variable::Number value to an
-/// Inst::Number value, giving the instruction number that begins or
-/// ends a variable's live range.
+/// A LiveBeginEndMapEntry maps a Variable::Number value to an Inst::Number
+/// value, giving the instruction number that begins or ends a variable's live
+/// range.
 using LiveBeginEndMapEntry = std::pair<SizeT, InstNumberT>;
 using LiveBeginEndMap =
     std::vector<LiveBeginEndMapEntry, CfgLocalAllocator<LiveBeginEndMapEntry>>;
 using LivenessBV = llvm::BitVector;
 
 using TimerStackIdT = uint32_t;
 using TimerIdT = uint32_t;
 
-/// Use alignas(MaxCacheLineSize) to isolate variables/fields that
-/// might be contended while multithreading.  Assumes the maximum cache
-/// line size is 64.
+/// Use alignas(MaxCacheLineSize) to isolate variables/fields that might be
+/// contended while multithreading. Assumes the maximum cache line size is 64.
 enum { MaxCacheLineSize = 64 };
 // Use ICE_CACHELINE_BOUNDARY to force the next field in a declaration
 // list to be aligned to the next cache line.
 // Note: zero is added to work around the following GCC 4.8 bug (fixed in 4.9):
 //       https://gcc.gnu.org/bugzilla/show_bug.cgi?id=55382
 #define ICE_CACHELINE_BOUNDARY                                                 \
   __attribute__((aligned(MaxCacheLineSize + 0))) int : 0
 
 /// PNaCl is ILP32, so theoretically we should only need 32-bit offsets.
 using RelocOffsetT = int32_t;
 enum { RelocAddrSize = 4 };
 
 enum LivenessMode {
-  /// Basic version of live-range-end calculation.  Marks the last uses
-  /// of variables based on dataflow analysis.  Records the set of
-  /// live-in and live-out variables for each block.  Identifies and
-  /// deletes dead instructions (primarily stores).
+  /// Basic version of live-range-end calculation. Marks the last uses of
+  /// variables based on dataflow analysis. Records the set of live-in and
+  /// live-out variables for each block. Identifies and deletes dead
+  /// instructions (primarily stores).
   Liveness_Basic,
 
-  /// In addition to Liveness_Basic, also calculate the complete
-  /// live range for each variable in a form suitable for interference
-  /// calculation and register allocation.
+  /// In addition to Liveness_Basic, also calculate the complete live range for
+  /// each variable in a form suitable for interference calculation and register
+  /// allocation.
   Liveness_Intervals
 };
 
 enum RegAllocKind {
   RAK_Unknown,
   RAK_Global, /// full, global register allocation
   RAK_Phi,    /// infinite-weight Variables with active spilling/filling
   RAK_InfOnly /// allocation only for infinite-weight Variables
 };
 
@@ skipping 24 matching lines @@
   FT_Iasm /// "Integrated assembler" .byte-style .s file
 };
 
 using Ostream = llvm::raw_ostream;
 using Fdstream = llvm::raw_fd_ostream;
 
 using GlobalLockType = std::mutex;
 
 enum ErrorCodes { EC_None = 0, EC_Args, EC_Bitcode, EC_Translation };
 
-/// Wrapper around std::error_code for allowing multiple errors to be
-/// folded into one.  The current implementation keeps track of the
-/// first error, which is likely to be the most useful one, and this
-/// could be extended to e.g. collect a vector of errors.
+/// Wrapper around std::error_code for allowing multiple errors to be folded
+/// into one. The current implementation keeps track of the first error, which
+/// is likely to be the most useful one, and this could be extended to e.g.
+/// collect a vector of errors.
 class ErrorCode : public std::error_code {
   ErrorCode(const ErrorCode &) = delete;
   ErrorCode &operator=(const ErrorCode &) = delete;
 
 public:
   ErrorCode() = default;
   void assign(ErrorCodes Code) {
     if (!HasError) {
       HasError = true;
       std::error_code::assign(Code, std::generic_category());
@@ skipping 27 matching lines @@
   RPE_GlobalVariableReordering,
   RPE_NopInsertion,
   RPE_PooledConstantReordering,
   RPE_RegAllocRandomization,
   RPE_num
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEDEFS_H