Reflow comments to use the full width.

src/IceGlobalInits.h

 //===- subzero/src/IceGlobalInits.h - Global 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 the representation of function declarations,
-/// global variable declarations, and the corresponding variable
-/// initializers in Subzero. Global variable initializers are
-/// represented as a sequence of simple initializers.
+/// This file declares the representation of function declarations, global
+/// variable declarations, and the corresponding variable initializers in
+/// Subzero. Global variable initializers are represented as a sequence of
+/// simple initializers.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEGLOBALINITS_H
 #define SUBZERO_SRC_ICEGLOBALINITS_H
 
 #include "IceDefs.h"
 #include "IceGlobalContext.h"
 #include "IceTypes.h"
 
@@ skipping 49 matching lines @@
   void dump(Ostream &Stream) const {
     if (!BuildDefs::dump())
       return;
     GlobalContext *const Ctx = nullptr;
     dump(Ctx, Stream);
   }
 
   /// Returns true if when emitting names, we should suppress mangling.
   virtual bool getSuppressMangling() const = 0;
 
-  /// Mangles name for cross tests, unless external and not defined locally
-  /// (so that relocations accross pnacl-sz and pnacl-llc will work).
+  /// Mangles name for cross tests, unless external and not defined locally (so
+  /// that relocations accross pnacl-sz and pnacl-llc will work).

[Jim Stichnoth, 2015/09/16 00:01:29]

across

[ascull, 2015/09/16 18:30:09]

Done.

   virtual IceString mangleName(GlobalContext *Ctx) const {
     return getSuppressMangling() ? Name : Ctx->mangleName(Name);
   }
 
 protected:
   GlobalDeclaration(GlobalDeclarationKind Kind,
                     llvm::GlobalValue::LinkageTypes Linkage)
       : Kind(Kind), Linkage(Linkage) {}
 
   const GlobalDeclarationKind Kind;
   IceString Name;
   llvm::GlobalValue::LinkageTypes Linkage;
 };
 
-/// Models a function declaration. This includes the type signature of
-/// the function, its calling conventions, and its linkage.
+/// Models a function declaration. This includes the type signature of the
+/// function, its calling conventions, and its linkage.
 class FunctionDeclaration : public GlobalDeclaration {
   FunctionDeclaration() = delete;
   FunctionDeclaration(const FunctionDeclaration &) = delete;
   FunctionDeclaration &operator=(const FunctionDeclaration &) = delete;
 
 public:
   static FunctionDeclaration *create(GlobalContext *Context,
                                      const FuncSigType &Signature,
                                      llvm::CallingConv::ID CallingConv,
                                      llvm::GlobalValue::LinkageTypes Linkage,
@@ skipping 167 matching lines @@
   bool getIsConstant() const { return IsConstant; }
   void setIsConstant(bool NewValue) { IsConstant = NewValue; }
   uint32_t getAlignment() const { return Alignment; }
   void setAlignment(uint32_t NewAlignment) { Alignment = NewAlignment; }
   bool hasInitializer() const { return HasInitializer; }
   bool hasNonzeroInitializer() const {
     return !(Initializers->size() == 1 &&
              llvm::isa<ZeroInitializer>((*Initializers)[0].get()));
   }
 
-  /// Returns the number of bytes for the initializer of the global
-  /// address.
+  /// Returns the number of bytes for the initializer of the global address.
   SizeT getNumBytes() const {
     SizeT Count = 0;
     for (const std::unique_ptr<Initializer> &Init : *Initializers) {
       Count += Init->getNumBytes();
     }
     return Count;
   }
 
-  /// Adds Initializer to the list of initializers. Takes ownership of
-  /// the initializer.
+  /// Adds Initializer to the list of initializers. Takes ownership of the
+  /// initializer.
   void addInitializer(std::unique_ptr<Initializer> Initializer) {
     Initializers->emplace_back(std::move(Initializer));
     HasInitializer = true;
   }
 
-  /// Prints out type for initializer associated with the declaration
-  /// to Stream.
+  /// Prints out type for initializer associated with the declaration to Stream.
   void dumpType(Ostream &Stream) const final;
 
-  /// Prints out the definition of the global variable declaration
-  /// (including initialization).
+  /// Prints out the definition of the global variable declaration (including
+  /// initialization).
   void dump(GlobalContext *Ctx, Ostream &Stream) const final;
 
   static bool classof(const GlobalDeclaration *Addr) {
     return Addr->getKind() == VariableDeclarationKind;
   }
 
   bool getSuppressMangling() const final {
     if (ForceSuppressMangling)
       return true;
     return isExternal() && !hasInitializer();
@@ skipping 31 matching lines @@
 template <class StreamType>
 inline StreamType &operator<<(StreamType &Stream,
                               const GlobalDeclaration &Addr) {
   Addr.dump(Stream);
   return Stream;
 }
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEGLOBALINITS_H