Reflow comments to use the full width.

src/PNaClTranslator.cpp

 //===- subzero/src/PNaClTranslator.cpp - ICE from bitcode -----------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 23 matching lines @@
 #include "llvm/Bitcode/NaCl/NaClBitcodeParser.h"
 #include "llvm/Bitcode/NaCl/NaClReaderWriter.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 #pragma clang diagnostic pop
 
 namespace {
 using namespace llvm;
 
-// Models elements in the list of types defined in the types block.
-// These elements can be undefined, a (simple) type, or a function type
-// signature. Note that an extended type is undefined on construction.
-// Use methods setAsSimpleType and setAsFuncSigType to define
-// the extended type.
+// Models elements in the list of types defined in the types block. These
+// elements can be undefined, a (simple) type, or a function type signature.
+// Note that an extended type is undefined on construction. Use methods
+// setAsSimpleType and setAsFuncSigType to define the extended type.
 class ExtendedType {
   ExtendedType &operator=(const ExtendedType &Ty) = delete;
 
 public:
   /// Discriminator for LLVM-style RTTI.
   enum TypeKind { Undefined, Simple, FuncSig };
 
   ExtendedType() = default;
   ExtendedType(const ExtendedType &Ty) = default;
 
   virtual ~ExtendedType() = default;
 
   ExtendedType::TypeKind getKind() const { return Kind; }
   void dump(Ice::Ostream &Stream) const;
 
-  /// Changes the extended type to a simple type with the given
-  /// value.
+  /// Changes the extended type to a simple type with the given / value.
   void setAsSimpleType(Ice::Type Ty) {
     assert(Kind == Undefined);
     Kind = Simple;
     Signature.setReturnType(Ty);
   }
 
   /// Changes the extended type to an (empty) function signature type.
   void setAsFunctionType() {
     assert(Kind == Undefined);
     Kind = FuncSig;
   }
 
 protected:
-  // Note: For simple types, the return type of the signature will
-  // be used to hold the simple type.
+  // Note: For simple types, the return type of the signature will be used to
+  // hold the simple type.
   Ice::FuncSigType Signature;
 
 private:
   ExtendedType::TypeKind Kind = Undefined;
 };
 
 Ice::Ostream &operator<<(Ice::Ostream &Stream, const ExtendedType &Ty) {
   if (!Ice::BuildDefs::dump())
     return Stream;
   Ty.dump(Stream);
@@ skipping 82 matching lines @@
         VariableDeclarations(new Ice::VariableDeclarationList()) {}
 
   ~TopLevelParser() override = default;
 
   Ice::Translator &getTranslator() const { return Translator; }
 
   void setBlockParser(BlockParserBaseClass *NewBlockParser) {
     BlockParser = NewBlockParser;
   }
 
-  /// Generates error with given Message, occurring at BitPosition
-  /// within the bitcode file. Always returns true.
+  /// Generates error with given Message, occurring at BitPosition within the
+  /// bitcode file. Always returns true.
   bool ErrorAt(naclbitc::ErrorLevel Level, uint64_t BitPosition,
                const std::string &Message) final;
 
   /// Generates error message with respect to the current block parser.
   bool blockError(const std::string &Message);
 
-  /// Returns the number of errors found while parsing the bitcode
-  /// file.
+  /// Returns the number of errors found while parsing the bitcode file.
   unsigned getNumErrors() const { return NumErrors; }
 
   /// Changes the size of the type list to the given size.
   void resizeTypeIDValues(size_t NewSize) { TypeIDValues.resize(NewSize); }
 
   size_t getNumTypeIDValues() const { return TypeIDValues.size(); }
 
   /// Returns true if generation of Subzero IR is disabled.
   bool isIRGenerationDisabled() const {
     return Translator.getFlags().getDisableIRGeneration();
   }
 
-  /// Returns the undefined type associated with type ID.
-  /// Note: Returns extended type ready to be defined.
+  /// Returns the undefined type associated with type ID. Note: Returns extended
+  /// type ready to be defined.
   ExtendedType *getTypeByIDForDefining(NaClBcIndexSize_t ID) {
-    // Get corresponding element, verifying the value is still undefined
-    // (and hence allowed to be defined).
+    // Get corresponding element, verifying the value is still undefined (and
+    // hence allowed to be defined).
     ExtendedType *Ty = getTypeByIDAsKind(ID, ExtendedType::Undefined);
     if (Ty)
       return Ty;
     if (ID >= TypeIDValues.size()) {
       if (ID >= NaClBcIndexSize_t_Max) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Can't define more than " << NaClBcIndexSize_t_Max
                << " types\n";
         blockError(StrBuf.str());
@@ skipping 21 matching lines @@
       // Return error recovery value.
       return UndefinedFuncSigType;
     return cast<FuncSigExtendedType>(Ty)->getSignature();
   }
 
   /// Sets the next function ID to the given LLVM function.
   void setNextFunctionID(Ice::FunctionDeclaration *Fcn) {
     FunctionDeclarations.push_back(Fcn);
   }
 
-  /// Returns the value id that should be associated with the the
-  /// current function block. Increments internal counters during call
-  /// so that it will be in correct position for next function block.
+  /// Returns the value id that should be associated with the the current
+  /// function block. Increments internal counters during call so that it will
+  /// be in correct position for next function block.
   NaClBcIndexSize_t getNextFunctionBlockValueID() {
     size_t NumDeclaredFunctions = FunctionDeclarations.size();
     while (NextDefiningFunctionID < NumDeclaredFunctions &&
            FunctionDeclarations[NextDefiningFunctionID]->isProto())
       ++NextDefiningFunctionID;
     if (NextDefiningFunctionID >= NumDeclaredFunctions)
       Fatal("More function blocks than defined function addresses");
     return NextDefiningFunctionID++;
   }
 
   /// Returns the function associated with ID.
   Ice::FunctionDeclaration *getFunctionByID(NaClBcIndexSize_t ID) {
     if (ID < FunctionDeclarations.size())
       return FunctionDeclarations[ID];
     return reportGetFunctionByIDError(ID);
   }
 
   /// Returns the constant associated with the given global value ID.
   Ice::Constant *getGlobalConstantByID(NaClBcIndexSize_t ID) {
     assert(ID < ValueIDConstants.size());
     return ValueIDConstants[ID];
   }
 
-  /// Install names for all global values without names. Called after
-  /// the global value symbol table is processed, but before any
-  /// function blocks are processed.
+  /// Install names for all global values without names. Called after the global
+  /// value symbol table is processed, but before any function blocks are
+  /// processed.
   void installGlobalNames() {
     assert(VariableDeclarations);
     installGlobalVarNames();
     installFunctionNames();
   }
 
   void createValueIDs() {
     assert(VariableDeclarations);
     ValueIDConstants.reserve(VariableDeclarations->size() +
                              FunctionDeclarations.size());
     createValueIDsForFunctions();
     createValueIDsForGlobalVars();
   }
 
   /// Returns the number of function declarations in the bitcode file.
   size_t getNumFunctionIDs() const { return FunctionDeclarations.size(); }
 
-  /// Returns the number of global declarations (i.e. IDs) defined in
-  /// the bitcode file.
+  /// Returns the number of global declarations (i.e. IDs) defined in the
+  /// bitcode file.
   size_t getNumGlobalIDs() const {
     if (VariableDeclarations) {
       return FunctionDeclarations.size() + VariableDeclarations->size();
     } else {
       return ValueIDConstants.size();
     }
   }
 
   /// Adds the given global declaration to the end of the list of global
   /// declarations.
   void addGlobalDeclaration(Ice::VariableDeclaration *Decl) {
     assert(VariableDeclarations);
     VariableDeclarations->push_back(Decl);
   }
 
   /// Returns the global variable declaration with the given index.
   Ice::VariableDeclaration *getGlobalVariableByID(NaClBcIndexSize_t Index) {
     assert(VariableDeclarations);
     if (Index < VariableDeclarations->size())
       return VariableDeclarations->at(Index);
     return reportGetGlobalVariableByIDError(Index);
   }
 
-  /// Returns the global declaration (variable or function) with the
-  /// given Index.
+  /// Returns the global declaration (variable or function) with the given
+  /// Index.
   Ice::GlobalDeclaration *getGlobalDeclarationByID(NaClBcIndexSize_t Index) {
     size_t NumFunctionIds = FunctionDeclarations.size();
     if (Index < NumFunctionIds)
       return getFunctionByID(Index);
     else
       return getGlobalVariableByID(Index - NumFunctionIds);
   }
 
-  /// Returns the list of parsed global variable
-  /// declarations. Releases ownership of the current list of global
-  /// variables. Note: only returns non-null pointer on first
-  /// call. All successive calls return a null pointer.
+  /// Returns the list of parsed global variable declarations. Releases
+  /// ownership of the current list of global variables. Note: only returns
+  /// non-null pointer on first call. All successive calls return a null
+  /// pointer.
   std::unique_ptr<Ice::VariableDeclarationList> getGlobalVariables() {
-    // Before returning, check that ValidIDConstants has already been
-    // built.
+    // Before returning, check that ValidIDConstants has already been built.
     assert(!VariableDeclarations ||
            VariableDeclarations->size() <= ValueIDConstants.size());
     return std::move(VariableDeclarations);
   }
 
 private:
   // The translator associated with the parser.
   Ice::Translator &Translator;
   // The exit status that should be set to true if an error occurs.
   Ice::ErrorCode &ErrorStatus;
   // The number of errors reported.
   unsigned NumErrors = 0;
   // The types associated with each type ID.
   std::vector<ExtendedType> TypeIDValues;
   // The set of functions (prototype and defined).
   Ice::FunctionDeclarationList FunctionDeclarations;
   // The ID of the next possible defined function ID in FunctionDeclarations.
   // FunctionDeclarations is filled first. It's the set of functions (either
   // defined or isproto). Then function definitions are encountered/parsed and
   // NextDefiningFunctionID is incremented to track the next actually-defined
   // function.
   size_t NextDefiningFunctionID = 0;
   // The set of global variables.
   std::unique_ptr<Ice::VariableDeclarationList> VariableDeclarations;
   // Relocatable constants associated with global declarations.
   Ice::ConstantList ValueIDConstants;
   // Error recovery value to use when getFuncSigTypeByID fails.
   Ice::FuncSigType UndefinedFuncSigType;
-  // The block parser currently being applied. Used for error
-  // reporting.
+  // The block parser currently being applied. Used for error reporting.
   BlockParserBaseClass *BlockParser = nullptr;
 
   bool ParseBlock(unsigned BlockID) override;
 
-  // Gets extended type associated with the given index, assuming the
-  // extended type is of the WantedKind. Generates error message if
-  // corresponding extended type of WantedKind can't be found, and
-  // returns nullptr.
+  // Gets extended type associated with the given index, assuming the extended
+  // type is of the WantedKind. Generates error message if corresponding
+  // extended type of WantedKind can't be found, and returns nullptr.
   ExtendedType *getTypeByIDAsKind(NaClBcIndexSize_t ID,
                                   ExtendedType::TypeKind WantedKind) {
     ExtendedType *Ty = nullptr;
     if (ID < TypeIDValues.size()) {
       Ty = &TypeIDValues[ID];
       if (Ty->getKind() == WantedKind)
         return Ty;
     }
     // Generate an error message and set ErrorStatus.
     this->reportBadTypeIDAs(ID, Ty, WantedKind);
     return nullptr;
   }
 
-  // Gives Decl a name if it doesn't already have one. Prefix and
-  // NameIndex are used to generate the name. NameIndex is
-  // automatically incremented if a new name is created.  DeclType is
-  // literal text describing the type of name being created. Also
-  // generates warning if created names may conflict with named
-  // declarations.
+  // Gives Decl a name if it doesn't already have one. Prefix and NameIndex are
+  // used to generate the name. NameIndex is automatically incremented if a new
+  // name is created. DeclType is literal text describing the type of name
+  // being created. Also generates warning if created names may conflict with
+  // named declarations.
   void installDeclarationName(Ice::GlobalDeclaration *Decl,
                               const Ice::IceString &Prefix,
                               const char *DeclType,
                               NaClBcIndexSize_t &NameIndex) {
     if (Decl->hasName()) {
       Translator.checkIfUnnamedNameSafe(Decl->getName(), DeclType, Prefix);
     } else {
       Decl->setName(Translator.createUnnamedName(Prefix, NameIndex));
       ++NameIndex;
     }
@@ skipping 18 matching lines @@
         getTranslator().getFlags().getDefaultFunctionPrefix();
     if (!FunctionPrefix.empty()) {
       NaClBcIndexSize_t NameIndex = 0;
       for (Ice::FunctionDeclaration *Func : FunctionDeclarations) {
         installDeclarationName(Func, FunctionPrefix, "function", NameIndex);
       }
     }
   }
 
   // Builds a constant symbol named Name, suppressing name mangling if
-  // SuppressMangling.  IsExternal is true iff the symbol is external.
+  // SuppressMangling. IsExternal is true iff the symbol is external.
   Ice::Constant *getConstantSym(const Ice::IceString &Name,
                                 bool SuppressMangling, bool IsExternal) const {
     if (IsExternal) {
       return getTranslator().getContext()->getConstantExternSym(Name);
     } else {
       const Ice::RelocOffsetT Offset = 0;
       return getTranslator().getContext()->getConstantSym(Offset, Name,
                                                           SuppressMangling);
     }
   }
@@ skipping 19 matching lines @@
                            !Decl->hasInitializer());
       }
       ValueIDConstants.push_back(C);
     }
   }
 
   // Reports that type ID is undefined, or not of the WantedType.
   void reportBadTypeIDAs(NaClBcIndexSize_t ID, const ExtendedType *Ty,
                          ExtendedType::TypeKind WantedType);
 
-  // Reports that there is no function declaration for ID. Returns an
-  // error recovery value to use.
+  // Reports that there is no function declaration for ID. Returns an error
+  // recovery value to use.
   Ice::FunctionDeclaration *reportGetFunctionByIDError(NaClBcIndexSize_t ID);
 
-  // Reports that there is not global variable declaration for
-  // ID. Returns an error recovery value to use.
+  // Reports that there is not global variable declaration for ID. Returns an
+  // error recovery value to use.
   Ice::VariableDeclaration *
   reportGetGlobalVariableByIDError(NaClBcIndexSize_t Index);
 
-  // Reports that there is no corresponding ICE type for LLVMTy, and
-  // returns Ice::IceType_void.
+  // Reports that there is no corresponding ICE type for LLVMTy, and returns
+  // Ice::IceType_void.
   Ice::Type convertToIceTypeError(Type *LLVMTy);
 };
 
 bool TopLevelParser::ErrorAt(naclbitc::ErrorLevel Level, uint64_t Bit,
                              const std::string &Message) {
   ErrorStatus.assign(Ice::EC_Bitcode);
   ++NumErrors;
   Ice::GlobalContext *Context = Translator.getContext();
   { // Lock while printing out error message.
     Ice::OstreamLocker L(Context);
@@ skipping 47 matching lines @@
 }
 
 Ice::Type TopLevelParser::convertToIceTypeError(Type *LLVMTy) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Invalid LLVM type: " << *LLVMTy;
   Error(StrBuf.str());
   return Ice::IceType_void;
 }
 
-// Base class for parsing blocks within the bitcode file.  Note:
-// Because this is the base class of block parsers, we generate error
-// messages if ParseBlock or ParseRecord is not overridden in derived
-// classes.
+// Base class for parsing blocks within the bitcode file. Note: Because this is
+// the base class of block parsers, we generate error messages if ParseBlock or
+// ParseRecord is not overridden in derived classes.
 class BlockParserBaseClass : public NaClBitcodeParser {
   BlockParserBaseClass() = delete;
   BlockParserBaseClass(const BlockParserBaseClass &) = delete;
   BlockParserBaseClass &operator=(const BlockParserBaseClass &) = delete;
 
 public:
   // Constructor for the top-level module block parser.
   BlockParserBaseClass(unsigned BlockID, TopLevelParser *Context)
       : NaClBitcodeParser(BlockID, Context), Context(Context) {
     Context->setBlockParser(this);
@@ skipping 22 matching lines @@
 
   // Gets the translator associated with the bitcode parser.
   Ice::Translator &getTranslator() const { return Context->getTranslator(); }
 
   const Ice::ClFlags &getFlags() const { return getTranslator().getFlags(); }
 
   bool isIRGenerationDisabled() const {
     return getTranslator().getFlags().getDisableIRGeneration();
   }
 
-  // Default implementation. Reports that block is unknown and skips
-  // its contents.
+  // Default implementation. Reports that block is unknown and skips its
+  // contents.
   bool ParseBlock(unsigned BlockID) override;
 
-  // Default implementation. Reports that the record is not
-  // understood.
+  // Default implementation. Reports that the record is not understood.
   void ProcessRecord() override;
 
-  // Checks if the size of the record is Size.  Return true if valid.
-  // Otherwise generates an error and returns false.
+  // Checks if the size of the record is Size. Return true if valid. Otherwise
+  // generates an error and returns false.
   bool isValidRecordSize(size_t Size, const char *RecordName) {
     const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
     if (Values.size() == Size)
       return true;
     reportRecordSizeError(Size, RecordName, nullptr);
     return false;
   }
 
-  // Checks if the size of the record is at least as large as the
-  // LowerLimit. Returns true if valid.  Otherwise generates an error
-  // and returns false.
+  // Checks if the size of the record is at least as large as the LowerLimit.
+  // Returns true if valid. Otherwise generates an error and returns false.
   bool isValidRecordSizeAtLeast(size_t LowerLimit, const char *RecordName) {
     const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
     if (Values.size() >= LowerLimit)
       return true;
     reportRecordSizeError(LowerLimit, RecordName, "at least");
     return false;
   }
 
   // Checks if the size of the record is no larger than the
-  // UpperLimit.  Returns true if valid.  Otherwise generates an error
-  // and returns false.
+  // UpperLimit.  Returns true if valid. Otherwise generates an error and
+  // returns false.
   bool isValidRecordSizeAtMost(size_t UpperLimit, const char *RecordName) {
     const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
     if (Values.size() <= UpperLimit)
       return true;
     reportRecordSizeError(UpperLimit, RecordName, "no more than");
     return false;
   }
 
-  // Checks if the size of the record is at least as large as the
-  // LowerLimit, and no larger than the UpperLimit.  Returns true if
-  // valid.  Otherwise generates an error and returns false.
+  // Checks if the size of the record is at least as large as the LowerLimit,
+  // and no larger than the UpperLimit. Returns true if valid. Otherwise
+  // generates an error and returns false.
   bool isValidRecordSizeInRange(size_t LowerLimit, size_t UpperLimit,
                                 const char *RecordName) {
     return isValidRecordSizeAtLeast(LowerLimit, RecordName) ||
            isValidRecordSizeAtMost(UpperLimit, RecordName);
   }
 
 private:
-  /// Generates a record size error. ExpectedSize is the number
-  /// of elements expected. RecordName is the name of the kind of
-  /// record that has incorrect size. ContextMessage (if not nullptr)
-  /// is appended to "record expects" to describe how ExpectedSize
-  /// should be interpreted.
+  /// Generates a record size error. ExpectedSize is the number of elements
+  /// expected. RecordName is the name of the kind of record that has incorrect
+  /// size. ContextMessage (if not nullptr) is appended to "record expects" to
+  /// describe how ExpectedSize should be interpreted.
   void reportRecordSizeError(size_t ExpectedSize, const char *RecordName,
                              const char *ContextMessage);
 };
 
 bool TopLevelParser::blockError(const std::string &Message) {
   if (BlockParser)
     return BlockParser->Error(Message);
   else
     return Error(Message);
 }
 
 // Generates an error Message with the bit address prefixed to it.
 bool BlockParserBaseClass::ErrorAt(naclbitc::ErrorLevel Level, uint64_t Bit,
                                    const std::string &Message) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
-  // Note: If dump routines have been turned off, the error messages
-  // will not be readable. Hence, replace with simple error. We also
-  // use the simple form for unit tests.
+  // Note: If dump routines have been turned off, the error messages will not
+  // be readable. Hence, replace with simple error. We also use the simple form
+  // for unit tests.
   if (getFlags().getGenerateUnitTestMessages()) {
     StrBuf << "Invalid " << getBlockName() << " record: <" << Record.GetCode();
     for (const uint64_t Val : Record.GetValues()) {
       StrBuf << " " << Val;
     }
     StrBuf << ">";
   } else {
     StrBuf << Message;
   }
   return Context->ErrorAt(Level, Bit, StrBuf.str());
@@ skipping 11 matching lines @@
   if (ContextMessage)
     StrBuf << " " << ContextMessage;
   StrBuf << " " << ExpectedSize << " argument";
   if (ExpectedSize > 1)
     StrBuf << "s";
   StrBuf << ". Found: " << Record.GetValues().size();
   Error(StrBuf.str());
 }
 
 bool BlockParserBaseClass::ParseBlock(unsigned BlockID) {
-  // If called, derived class doesn't know how to handle block.
-  // Report error and skip.
+  // If called, derived class doesn't know how to handle block. Report error
+  // and skip.
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Don't know how to parse block id: " << BlockID;
   Error(StrBuf.str());
   SkipBlock();
   return false;
 }
 
 void BlockParserBaseClass::ProcessRecord() {
   // If called, derived class doesn't know how to handle.
@@ skipping 20 matching lines @@
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Types block expected " << ExpectedNumTypes
              << " types but found: " << NextTypeId;
       Error(StrBuf.str());
     }
   }
 
 private:
   Ice::TimerMarker Timer;
-  // The type ID that will be associated with the next type defining
-  // record in the types block.
+  // The type ID that will be associated with the next type defining record in
+  // the types block.
   NaClBcIndexSize_t NextTypeId = 0;
 
   // The expected number of types, based on record TYPE_CODE_NUMENTRY.
   NaClBcIndexSize_t ExpectedNumTypes = 0;
 
   void ProcessRecord() override;
 
   const char *getBlockName() const override { return "type"; }
 
   void setNextTypeIDAsSimpleType(Ice::Type Ty) {
     Context->getTypeByIDForDefining(NextTypeId++)->setAsSimpleType(Ty);
   }
 };
 
 void TypesParser::ProcessRecord() {
   const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
   switch (Record.GetCode()) {
   case naclbitc::TYPE_CODE_NUMENTRY: {
     // NUMENTRY: [numentries]
     if (!isValidRecordSize(1, "count"))
       return;
     uint64_t Size = Values[0];
     if (Size > NaClBcIndexSize_t_Max) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Size to big for count record: " << Size;
       Error(StrBuf.str());
       ExpectedNumTypes = NaClBcIndexSize_t_Max;
     }
-    // The code double checks that Expected size and the actual size
-    // at the end of the block. To reduce allocations we preallocate
-    // the space.
+    // The code double checks that Expected size and the actual size at the end
+    // of the block. To reduce allocations we preallocate the space.
     //
-    // However, if the number is large, we suspect that the number
-    // is (possibly) incorrect. In that case, we preallocate a
-    // smaller space.
+    // However, if the number is large, we suspect that the number is
+    // (possibly) incorrect. In that case, we preallocate a smaller space.
     constexpr uint64_t DefaultLargeResizeValue = 1000000;
     Context->resizeTypeIDValues(std::min(Size, DefaultLargeResizeValue));
     ExpectedNumTypes = Size;
     return;
   }
   case naclbitc::TYPE_CODE_VOID:
     // VOID
     if (!isValidRecordSize(0, "void"))
       return;
     setNextTypeIDAsSimpleType(Ice::IceType_void);
@@ skipping 102 matching lines @@
     // FUNCTION: [vararg, retty, paramty x N]
     if (!isValidRecordSizeAtLeast(2, "signature"))
       return;
     if (Values[0])
       Error("Function type can't define varargs");
     ExtendedType *Ty = Context->getTypeByIDForDefining(NextTypeId++);
     Ty->setAsFunctionType();
     FuncSigExtendedType *FuncTy = cast<FuncSigExtendedType>(Ty);
     FuncTy->setReturnType(Context->getSimpleTypeByID(Values[1]));
     for (size_t i = 2, e = Values.size(); i != e; ++i) {
-      // Check that type void not used as argument type.
-      // Note: PNaCl restrictions can't be checked until we
-      // know the name, because we have to check for intrinsic signatures.
+      // Check that type void not used as argument type. Note: PNaCl
+      // restrictions can't be checked until we know the name, because we have
+      // to check for intrinsic signatures.
       Ice::Type ArgTy = Context->getSimpleTypeByID(Values[i]);
       if (ArgTy == Ice::IceType_void) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Type for parameter " << (i - 1)
                << " not valid. Found: " << ArgTy;
         ArgTy = Ice::IceType_i32;
       }
       FuncTy->appendArgType(ArgTy);
     }
@@ skipping 31 matching lines @@
       std::unordered_map<NaClBcIndexSize_t, Ice::VariableDeclaration *>;
 
   Ice::TimerMarker Timer;
 
   // Holds global variables generated/referenced in the global variables block.
   GlobalVarsMapType GlobalVarsMap;
 
   // Holds the number of defined function IDs.
   NaClBcIndexSize_t NumFunctionIDs;
 
-  // Holds the specified number of global variables by the count record in
-  // the global variables block.
+  // Holds the specified number of global variables by the count record in the
+  // global variables block.
   NaClBcIndexSize_t SpecifiedNumberVars = 0;
 
   // Keeps track of how many initializers are expected for the global variable
   // declaration being built.
   NaClBcIndexSize_t InitializersNeeded = 0;
 
   // The index of the next global variable declaration.
   NaClBcIndexSize_t NextGlobalID = 0;
 
-  // Dummy global variable declaration to guarantee CurGlobalVar is
-  // always defined (allowing code to not need to check if
-  // CurGlobalVar is nullptr).
+  // Dummy global variable declaration to guarantee CurGlobalVar is always
+  // defined (allowing code to not need to check if CurGlobalVar is nullptr).
   Ice::VariableDeclaration *DummyGlobalVar;
 
   // Holds the current global variable declaration being built.
   Ice::VariableDeclaration *CurGlobalVar;
 
   // Returns the global variable associated with the given Index.
   Ice::VariableDeclaration *getGlobalVarByID(NaClBcIndexSize_t Index) {
     Ice::VariableDeclaration *&Decl = GlobalVarsMap[Index];
     if (Decl == nullptr)
       Decl = Ice::VariableDeclaration::create(getTranslator().getContext());
@@ skipping 240 matching lines @@
   bool convertFunction() {
     const Ice::TimerStackIdT StackID = Ice::GlobalContext::TSK_Funcs;
     Ice::TimerIdT TimerID = 0;
     const bool TimeThisFunction = getFlags().getTimeEachFunction();
     if (TimeThisFunction) {
       TimerID = getTranslator().getContext()->getTimerID(StackID,
                                                          FuncDecl->getName());
       getTranslator().getContext()->pushTimer(TimerID, StackID);
     }
 
-    // Note: The Cfg is created, even when IR generation is disabled. This
-    // is done to install a CfgLocalAllocator for various internal containers.
+    // Note: The Cfg is created, even when IR generation is disabled. This is
+    // done to install a CfgLocalAllocator for various internal containers.
     Func = Ice::Cfg::create(getTranslator().getContext(),
                             getTranslator().getNextSequenceNumber());
     Ice::Cfg::setCurrentCfg(Func.get());
 
-    // TODO(kschimpf) Clean up API to add a function signature to
-    // a CFG.
+    // TODO(kschimpf) Clean up API to add a function signature to a CFG.
     const Ice::FuncSigType &Signature = FuncDecl->getSignature();
     if (isIRGenerationDisabled()) {
       CurrentNode = nullptr;
       for (Ice::Type ArgType : Signature.getArgList()) {
         (void)ArgType;
         setNextLocalInstIndex(nullptr);
       }
     } else {
       Func->setFunctionName(FuncDecl->getName());
       Func->setReturnType(Signature.getReturnType());
       Func->setInternal(FuncDecl->getLinkage() == GlobalValue::InternalLinkage);
       CurrentNode = installNextBasicBlock();
       Func->setEntryNode(CurrentNode);
       for (Ice::Type ArgType : Signature.getArgList()) {
         Func->addArg(getNextInstVar(ArgType));
       }
     }
     bool ParserResult = ParseThisBlock();
 
-    // Temporarily end per-function timing, which will be resumed by
-    // the translator function.  This is because translation may be
-    // done asynchronously in a separate thread.
+    // Temporarily end per-function timing, which will be resumed by the
+    // translator function. This is because translation may be done
+    // asynchronously in a separate thread.
     if (TimeThisFunction)
       getTranslator().getContext()->popTimer(TimerID, StackID);
 
     Ice::Cfg::setCurrentCfg(nullptr);
-    // Note: Once any errors have been found, we turn off all
-    // translation of all remaining functions. This allows successive
-    // parsing errors to be reported, without adding extra checks to
-    // the translator for such parsing errors.
+    // Note: Once any errors have been found, we turn off all translation of
+    // all remaining functions. This allows successive parsing errors to be
+    // reported, without adding extra checks to the translator for such parsing
+    // errors.
     if (Context->getNumErrors() == 0 && Func) {
       getTranslator().translateFcn(std::move(Func));
       // The translator now has ownership of Func.
     } else {
       Func.reset();
     }
 
     return ParserResult;
   }
 
@@ skipping 44 matching lines @@
   // The number of basic blocks declared for the function block.
   NaClBcIndexSize_t DeclaredNumberBbs = 0;
   // The basic block being built.
   Ice::CfgNode *CurrentNode = nullptr;
   // The ID for the function.
   NaClBcIndexSize_t FcnId;
   // The corresponding function declaration.
   Ice::FunctionDeclaration *FuncDecl;
   // Holds the dividing point between local and global absolute value indices.
   size_t CachedNumGlobalValueIDs;
-  // Holds operands local to the function block, based on indices
-  // defined in the bitcode file.
+  // Holds operands local to the function block, based on indices defined in
+  // the bitcode file.
   Ice::OperandList LocalOperands;
-  // Holds the index within LocalOperands corresponding to the next
-  // instruction that generates a value.
+  // Holds the index within LocalOperands corresponding to the next instruction
+  // that generates a value.
   NaClBcIndexSize_t NextLocalInstIndex;
-  // True if the last processed instruction was a terminating
-  // instruction.
+  // True if the last processed instruction was a terminating instruction.
   bool InstIsTerminating = false;
   // Upper limit of alignment power allowed by LLVM
   static const uint32_t AlignPowerLimit = 29;
 
-  // Extracts the corresponding Alignment to use, given the AlignPower
-  // (i.e. 2**(AlignPower-1), or 0 if AlignPower == 0). InstName is the
-  // name of the instruction the alignment appears in.
+  // Extracts the corresponding Alignment to use, given the AlignPower (i.e.
+  // 2**(AlignPower-1), or 0 if AlignPower == 0). InstName is the name of the
+  // instruction the alignment appears in.
   void extractAlignment(const char *InstName, uint32_t AlignPower,
                         uint32_t &Alignment) {
     if (AlignPower <= AlignPowerLimit + 1) {
       Alignment = (1 << AlignPower) >> 1;
       return;
     }
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << InstName << " alignment greater than 2**" << AlignPowerLimit
            << ". Found: 2**" << (AlignPower - 1);
@@ skipping 29 matching lines @@
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Reference to basic block " << Index
              << " not found. Must be less than " << Func->getNumNodes();
       Error(StrBuf.str());
       Index = 0;
     }
     return Func->getNodes()[Index];
   }
 
-  // Returns the Index-th basic block in the list of basic blocks.
-  // Assumes Index corresponds to a branch instruction. Hence, if
-  // the branch references the entry block, it also generates a
-  // corresponding error.
+  // Returns the Index-th basic block in the list of basic blocks. Assumes
+  // Index corresponds to a branch instruction. Hence, if the branch references
+  // the entry block, it also generates a corresponding error.
   Ice::CfgNode *getBranchBasicBlock(NaClBcIndexSize_t Index) {
     assert(!isIRGenerationDisabled());
     if (Index == 0) {
       Error("Branch to entry block not allowed");
     }
     return getBasicBlock(Index);
   }
 
   // Generate an instruction variable with type Ty.
   Ice::Variable *createInstVar(Ice::Type Ty) {
@@ skipping 28 matching lines @@
         Error(StrBuf.str());
         ++NextLocalInstIndex;
         return createInstVar(Ty);
       }
     }
     Ice::Variable *Var = createInstVar(Ty);
     setOperand(NextLocalInstIndex++, Var);
     return Var;
   }
 
-  // Converts a relative index (wrt to BaseIndex) to an absolute value
-  // index.
+  // Converts a relative index (wrt to BaseIndex) to an absolute value index.
   NaClBcIndexSize_t convertRelativeToAbsIndex(NaClRelBcIndexSize_t Id,
                                               NaClRelBcIndexSize_t BaseIndex) {
     if (BaseIndex < Id) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Invalid relative value id: " << Id
              << " (must be <= " << BaseIndex << ")";
       Error(StrBuf.str());
       return 0;
     }
@@ skipping 38 matching lines @@
 
     // Error has occurred.
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << "Multiple definitions for index " << Index << ": " << *Op
            << " and " << *OldOp;
     Error(StrBuf.str());
     LocalOperands[LocalIndex] = Op;
   }
 
-  // Returns the relative operand (wrt to BaseIndex) referenced by
-  // the given value Index.
+  // Returns the relative operand (wrt to BaseIndex) referenced by the given
+  // value Index.
   Ice::Operand *getRelativeOperand(NaClBcIndexSize_t Index,
                                    NaClBcIndexSize_t BaseIndex) {
     return getOperand(convertRelativeToAbsIndex(Index, BaseIndex));
   }
 
   // Returns the absolute index of the next value generating instruction.
   NaClBcIndexSize_t getNextInstIndex() const { return NextLocalInstIndex; }
 
-  // Generates type error message for binary operator Op
-  // operating on Type OpTy.
+  // Generates type error message for binary operator Op operating on Type
+  // OpTy.
   void reportInvalidBinaryOp(Ice::InstArithmetic::OpKind Op, Ice::Type OpTy);
 
-  // Validates if integer logical Op, for type OpTy, is valid.
-  // Returns true if valid. Otherwise generates error message and
-  // returns false.
+  // Validates if integer logical Op, for type OpTy, is valid. Returns true if
+  // valid. Otherwise generates error message and returns false.
   bool isValidIntegerLogicalOp(Ice::InstArithmetic::OpKind Op, Ice::Type OpTy) {
     if (Ice::isIntegerType(OpTy))
       return true;
     reportInvalidBinaryOp(Op, OpTy);
     return false;
   }
 
-  // Validates if integer (or vector of integers) arithmetic Op, for type
-  // OpTy, is valid.  Returns true if valid. Otherwise generates
-  // error message and returns false.
+  // Validates if integer (or vector of integers) arithmetic Op, for type OpTy,
+  // is valid. Returns true if valid. Otherwise generates error message and
+  // returns false.
   bool isValidIntegerArithOp(Ice::InstArithmetic::OpKind Op, Ice::Type OpTy) {
     if (Ice::isIntegerArithmeticType(OpTy))
       return true;
     reportInvalidBinaryOp(Op, OpTy);
     return false;
   }
 
-  // Checks if floating arithmetic Op, for type OpTy, is valid.
-  // Returns true if valid. Otherwise generates an error message and
-  // returns false;
+  // Checks if floating arithmetic Op, for type OpTy, is valid. Returns true if
+  // valid. Otherwise generates an error message and returns false;
   bool isValidFloatingArithOp(Ice::InstArithmetic::OpKind Op, Ice::Type OpTy) {
     if (Ice::isFloatingType(OpTy))
       return true;
     reportInvalidBinaryOp(Op, OpTy);
     return false;
   }
 
-  // Checks if the type of operand Op is the valid pointer type, for
-  // the given InstructionName. Returns true if valid. Otherwise
-  // generates an error message and returns false.
+  // Checks if the type of operand Op is the valid pointer type, for the given
+  // InstructionName. Returns true if valid. Otherwise generates an error
+  // message and returns false.
   bool isValidPointerType(Ice::Operand *Op, const char *InstructionName) {
     Ice::Type PtrType = Ice::getPointerType();
     if (Op->getType() == PtrType)
       return true;
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << InstructionName << " address not " << PtrType
            << ". Found: " << *Op;
     Error(StrBuf.str());
     return false;
   }
 
-  // Checks if loading/storing a value of type Ty is allowed.
-  // Returns true if Valid. Otherwise generates an error message and
-  // returns false.
+  // Checks if loading/storing a value of type Ty is allowed. Returns true if
+  // Valid. Otherwise generates an error message and returns false.
   bool isValidLoadStoreType(Ice::Type Ty, const char *InstructionName) {
     if (isLoadStoreType(Ty))
       return true;
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << InstructionName << " type not allowed: " << Ty << "*";
     Error(StrBuf.str());
     return false;
   }
 
-  // Checks if loading/storing a value of type Ty is allowed for
-  // the given Alignment. Otherwise generates an error message and
-  // returns false.
+  // Checks if loading/storing a value of type Ty is allowed for the given
+  // Alignment. Otherwise generates an error message and returns false.
   bool isValidLoadStoreAlignment(size_t Alignment, Ice::Type Ty,
                                  const char *InstructionName) {
     if (!isValidLoadStoreType(Ty, InstructionName))
       return false;
     if (isAllowedAlignment(Alignment, Ty))
       return true;
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << InstructionName << " " << Ty << "*: not allowed for alignment "
            << Alignment;
     Error(StrBuf.str());
     return false;
   }
 
   // Defines if the given alignment is valid for the given type. Simplified
-  // version of PNaClABIProps::isAllowedAlignment, based on API's offered
-  // for Ice::Type.
+  // version of PNaClABIProps::isAllowedAlignment, based on API's offered for
+  // Ice::Type.
   bool isAllowedAlignment(size_t Alignment, Ice::Type Ty) const {
     return Alignment == typeAlignInBytes(Ty) ||
            (Alignment == 1 && !isVectorType(Ty));
   }
 
   // Types of errors that can occur for insertelement and extractelement
   // instructions.
   enum VectorIndexCheckValue {
     VectorIndexNotVector,
     VectorIndexNotConstant,
@@ skipping 35 matching lines @@
     const auto *C = dyn_cast<Ice::ConstantInteger32>(Index);
     if (C == nullptr)
       return VectorIndexNotConstant;
     if (static_cast<size_t>(C->getValue()) >= typeNumElements(VecType))
       return VectorIndexNotInRange;
     if (Index->getType() != Ice::IceType_i32)
       return VectorIndexNotI32;
     return VectorIndexValid;
   }
 
-  // Takes the PNaCl bitcode binary operator Opcode, and the opcode
-  // type Ty, and sets Op to the corresponding ICE binary
-  // opcode. Returns true if able to convert, false otherwise.
+  // Takes the PNaCl bitcode binary operator Opcode, and the opcode type Ty,
+  // and sets Op to the corresponding ICE binary opcode. Returns true if able
+  // to convert, false otherwise.
   bool convertBinopOpcode(unsigned Opcode, Ice::Type Ty,
                           Ice::InstArithmetic::OpKind &Op) {
     switch (Opcode) {
     default: {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Binary opcode " << Opcode << "not understood for type " << Ty;
       Error(StrBuf.str());
       Op = Ice::InstArithmetic::Add;
       return false;
@@ skipping 58 matching lines @@
       return isValidIntegerLogicalOp(Op, Ty);
     case naclbitc::BINOP_OR:
       Op = Ice::InstArithmetic::Or;
       return isValidIntegerLogicalOp(Op, Ty);
     case naclbitc::BINOP_XOR:
       Op = Ice::InstArithmetic::Xor;
       return isValidIntegerLogicalOp(Op, Ty);
     }
   }
 
-  /// Simplifies out vector types from Type1 and Type2, if both are vectors
-  /// of the same size. Returns true iff both are vectors of the same size,
-  /// or are both scalar types.
+  /// Simplifies out vector types from Type1 and Type2, if both are vectors of
+  /// the same size. Returns true iff both are vectors of the same size, or are
+  /// both scalar types.
   static bool simplifyOutCommonVectorType(Ice::Type &Type1, Ice::Type &Type2) {
     bool IsType1Vector = isVectorType(Type1);
     bool IsType2Vector = isVectorType(Type2);
     if (IsType1Vector != IsType2Vector)
       return false;
     if (!IsType1Vector)
       return true;
     if (typeNumElements(Type1) != typeNumElements(Type2))
       return false;
     Type1 = typeElementType(Type1);
@@ skipping 22 matching lines @@
   static bool isIntExtCastValid(Ice::Type SourceType, Ice::Type TargetType) {
     return isIntTruncCastValid(TargetType, SourceType);
   }
 
   /// Returns true iff a floating type extension from SourceType to TargetType
   /// is valid.
   static bool isFloatExtCastValid(Ice::Type SourceType, Ice::Type TargetType) {
     return isFloatTruncCastValid(TargetType, SourceType);
   }
 
-  /// Returns true iff a cast from floating type SourceType to integer
-  /// type TargetType is valid.
+  /// Returns true iff a cast from floating type SourceType to integer type
+  /// TargetType is valid.
   static bool isFloatToIntCastValid(Ice::Type SourceType,
                                     Ice::Type TargetType) {
     if (!(Ice::isFloatingType(SourceType) && Ice::isIntegerType(TargetType)))
       return false;
     bool IsSourceVector = isVectorType(SourceType);
     bool IsTargetVector = isVectorType(TargetType);
     if (IsSourceVector != IsTargetVector)
       return false;
     if (IsSourceVector) {
       return typeNumElements(SourceType) == typeNumElements(TargetType);
     }
     return true;
   }
 
-  /// Returns true iff a cast from integer type SourceType to floating
-  /// type TargetType is valid.
+  /// Returns true iff a cast from integer type SourceType to floating type
+  /// TargetType is valid.
   static bool isIntToFloatCastValid(Ice::Type SourceType,
                                     Ice::Type TargetType) {
     return isFloatToIntCastValid(TargetType, SourceType);
   }
 
-  /// Returns the number of bits used to model type Ty when defining the
-  /// bitcast instruction.
+  /// Returns the number of bits used to model type Ty when defining the bitcast
+  /// instruction.
   static Ice::SizeT bitcastSizeInBits(Ice::Type Ty) {
     if (Ice::isVectorType(Ty))
       return Ice::typeNumElements(Ty) *
              bitcastSizeInBits(Ice::typeElementType(Ty));
     if (Ty == Ice::IceType_i1)
       return 1;
     return Ice::typeWidthInBytes(Ty) * CHAR_BIT;
   }
 
   /// Returns true iff a bitcast from SourceType to TargetType is allowed.
   static bool isBitcastValid(Ice::Type SourceType, Ice::Type TargetType) {
     return bitcastSizeInBits(SourceType) == bitcastSizeInBits(TargetType);
   }
 
-  /// Returns true iff the NaCl bitcode Opcode is a valid cast opcode
-  /// for converting SourceType to TargetType. Updates CastKind to the
-  /// corresponding instruction cast opcode. Also generates an error
-  /// message when this function returns false.
+  /// Returns true iff the NaCl bitcode Opcode is a valid cast opcode for
+  /// converting SourceType to TargetType. Updates CastKind to the corresponding
+  /// instruction cast opcode. Also generates an error message when this
+  /// function returns false.
   bool convertCastOpToIceOp(uint64_t Opcode, Ice::Type SourceType,
                             Ice::Type TargetType,
                             Ice::InstCast::OpKind &CastKind) {
     bool Result;
     switch (Opcode) {
     default: {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Cast opcode " << Opcode << " not understood.\n";
       Error(StrBuf.str());
@@ skipping 44 matching lines @@
     if (!Result) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Illegal cast: " << Ice::InstCast::getCastName(CastKind) << " "
              << SourceType << " to " << TargetType;
       Error(StrBuf.str());
     }
     return Result;
   }
 
-  // Converts PNaCl bitcode Icmp operator to corresponding ICE op.
-  // Returns true if able to convert, false otherwise.
+  // Converts PNaCl bitcode Icmp operator to corresponding ICE op. Returns true
+  // if able to convert, false otherwise.
   bool convertNaClBitcICmpOpToIce(uint64_t Op,
                                   Ice::InstIcmp::ICond &Cond) const {
     switch (Op) {
     case naclbitc::ICMP_EQ:
       Cond = Ice::InstIcmp::Eq;
       return true;
     case naclbitc::ICMP_NE:
       Cond = Ice::InstIcmp::Ne;
       return true;
     case naclbitc::ICMP_UGT:
@@ skipping 20 matching lines @@
     case naclbitc::ICMP_SLE:
       Cond = Ice::InstIcmp::Sle;
       return true;
     default:
       // Make sure Cond is always initialized.
       Cond = static_cast<Ice::InstIcmp::ICond>(0);
       return false;
     }
   }
 
-  // Converts PNaCl bitcode Fcmp operator to corresponding ICE op.
-  // Returns true if able to convert, false otherwise.
+  // Converts PNaCl bitcode Fcmp operator to corresponding ICE op. Returns true
+  // if able to convert, false otherwise.
   bool convertNaClBitcFCompOpToIce(uint64_t Op,
                                    Ice::InstFcmp::FCond &Cond) const {
     switch (Op) {
     case naclbitc::FCMP_FALSE:
       Cond = Ice::InstFcmp::False;
       return true;
     case naclbitc::FCMP_OEQ:
       Cond = Ice::InstFcmp::Oeq;
       return true;
     case naclbitc::FCMP_OGT:
@@ skipping 38 matching lines @@
     case naclbitc::FCMP_TRUE:
       Cond = Ice::InstFcmp::True;
       return true;
     default:
       // Make sure Cond is always initialized.
       Cond = static_cast<Ice::InstFcmp::FCond>(0);
       return false;
     }
   }
 
-  // Creates an error instruction, generating a value of type Ty, and
-  // adds a placeholder so that instruction indices line up.
-  // Some instructions, such as a call, will not generate a value
-  // if the return type is void. In such cases, a placeholder value
-  // for the badly formed instruction is not needed. Hence, if Ty is
-  // void, an error instruction is not appended.
+  // Creates an error instruction, generating a value of type Ty, and adds a
+  // placeholder so that instruction indices line up. Some instructions, such
+  // as a call, will not generate a value if the return type is void. In such
+  // cases, a placeholder value for the badly formed instruction is not needed.
+  // Hence, if Ty is void, an error instruction is not appended.
   void appendErrorInstruction(Ice::Type Ty) {
-    // Note: we don't worry about downstream translation errors because
-    // the function will not be translated if any errors occur.
+    // Note: we don't worry about downstream translation errors because the
+    // function will not be translated if any errors occur.
     if (Ty == Ice::IceType_void)
       return;
     Ice::Variable *Var = getNextInstVar(Ty);
     CurrentNode->appendInst(Ice::InstAssign::create(Func.get(), Var, Var));
   }
 };
 
 void FunctionParser::ExitBlock() {
   // Check if the last instruction in the function was terminating.
   if (!InstIsTerminating) {
     Error("Last instruction in function not terminator");
     if (isIRGenerationDisabled())
       return;
     // Recover by inserting an unreachable instruction.
     CurrentNode->appendInst(Ice::InstUnreachable::create(Func.get()));
   }
   ++CurrentBbIndex;
   if (CurrentBbIndex != DeclaredNumberBbs) {
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << "Function declared " << DeclaredNumberBbs
            << " basic blocks, but defined " << CurrentBbIndex << ".";
     Error(StrBuf.str());
   }
   if (isIRGenerationDisabled())
     return;
-  // Before translating, check for blocks without instructions, and
-  // insert unreachable. This shouldn't happen, but be safe.
+  // Before translating, check for blocks without instructions, and insert
+  // unreachable. This shouldn't happen, but be safe.
   size_t Index = 0;
   for (Ice::CfgNode *Node : Func->getNodes()) {
     if (Node->getInsts().empty()) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Basic block " << Index << " contains no instructions";
       Error(StrBuf.str());
       Node->appendInst(Ice::InstUnreachable::create(Func.get()));
     }
     ++Index;
   }
   Func->computeInOutEdges();
 }
 
 void FunctionParser::reportInvalidBinaryOp(Ice::InstArithmetic::OpKind Op,
                                            Ice::Type OpTy) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Invalid operator type for " << Ice::InstArithmetic::getOpName(Op)
          << ". Found " << OpTy;
   Error(StrBuf.str());
 }
 
 void FunctionParser::ProcessRecord() {
-  // Note: To better separate parse/IR generation times, when IR generation
-  // is disabled we do the following:
+  // Note: To better separate parse/IR generation times, when IR generation is
+  // disabled we do the following:
   // 1) Delay exiting until after we extract operands.
   // 2) return before we access operands, since all operands will be a nullptr.
   const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
   if (InstIsTerminating) {
     InstIsTerminating = false;
     ++CurrentBbIndex;
     if (!isIRGenerationDisabled())
       CurrentNode = getBasicBlock(CurrentBbIndex);
   }
   // The base index for relative indexing.
@@ skipping 309 matching lines @@
         return;
       CurrentNode->appendInst(
           Ice::InstBr::create(Func.get(), Cond, ThenBlock, ElseBlock));
     }
     return;
   }
   case naclbitc::FUNC_CODE_INST_SWITCH: {
     // SWITCH: [Condty, Cond, BbIndex, NumCases Case ...]
     // where Case = [1, 1, Value, BbIndex].
     //
-    // Note: Unlike most instructions, we don't infer the type of
-    // Cond, but provide it as a separate field. There are also
-    // unnecesary data fields (i.e. constants 1).  These were not
-    // cleaned up in PNaCl bitcode because the bitcode format was
-    // already frozen when the problem was noticed.
+    // Note: Unlike most instructions, we don't infer the type of Cond, but
+    // provide it as a separate field. There are also unnecessary data fields
+    // (i.e. constants 1). These were not cleaned up in PNaCl bitcode because
+    // the bitcode format was already frozen when the problem was noticed.
     InstIsTerminating = true;
     if (!isValidRecordSizeAtLeast(4, "switch"))
       return;
 
     Ice::Type CondTy = Context->getSimpleTypeByID(Values[0]);
     if (!Ice::isScalarIntegerType(CondTy)) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Case condition must be non-wide integer. Found: " << CondTy;
       Error(StrBuf.str());
@@ skipping 184 matching lines @@
       return;
     CurrentNode->appendInst(
         Ice::InstStore::create(Func.get(), Value, Address, Alignment));
     return;
   }
   case naclbitc::FUNC_CODE_INST_CALL:
   case naclbitc::FUNC_CODE_INST_CALL_INDIRECT: {
     // CALL: [cc, fnid, arg0, arg1...]
     // CALL_INDIRECT: [cc, fn, returnty, args...]
     //
-    // Note: The difference between CALL and CALL_INDIRECT is that
-    // CALL has a reference to an explicit function declaration, while
-    // the CALL_INDIRECT is just an address. For CALL, we can infer
-    // the return type by looking up the type signature associated
-    // with the function declaration. For CALL_INDIRECT we can only
-    // infer the type signature via argument types, and the
-    // corresponding return type stored in CALL_INDIRECT record.
+    // Note: The difference between CALL and CALL_INDIRECT is that CALL has a
+    // reference to an explicit function declaration, while the CALL_INDIRECT
+    // is just an address. For CALL, we can infer the return type by looking up
+    // the type signature associated with the function declaration. For
+    // CALL_INDIRECT we can only infer the type signature via argument types,
+    // and the corresponding return type stored in CALL_INDIRECT record.
     Ice::SizeT ParamsStartIndex = 2;
     if (Record.GetCode() == naclbitc::FUNC_CODE_INST_CALL) {
       if (!isValidRecordSizeAtLeast(2, "call"))
         return;
     } else {
       if (!isValidRecordSizeAtLeast(3, "call indirect"))
         return;
       ParamsStartIndex = 3;
     }
 
@@ skipping 145 matching lines @@
   Ice::TimerMarker Timer;
   // The parser of the function block this constants block appears in.
   FunctionParser *FuncParser;
   // The type to use for succeeding constants.
   Ice::Type NextConstantType = Ice::IceType_void;
 
   void ProcessRecord() override;
 
   Ice::GlobalContext *getContext() { return getTranslator().getContext(); }
 
-  // Returns true if the type to use for succeeding constants is defined.
-  // If false, also generates an error message.
+  // Returns true if the type to use for succeeding constants is defined. If
+  // false, also generates an error message.
   bool isValidNextConstantType() {
     if (NextConstantType != Ice::IceType_void)
       return true;
     Error("Constant record not preceded by set type record");
     return false;
   }
 };
 
 void ConstantsParser::ProcessRecord() {
   const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
@@ skipping 102 matching lines @@
 private:
   Ice::TimerMarker Timer;
   // Returns the enclosing function parser.
   FunctionParser *getFunctionParser() const {
     return reinterpret_cast<FunctionParser *>(GetEnclosingParser());
   }
 
   void setValueName(NaClBcIndexSize_t Index, StringType &Name) override;
   void setBbName(NaClBcIndexSize_t Index, StringType &Name) override;
 
-  // Reports that the assignment of Name to the value associated with
-  // index is not possible, for the given Context.
+  // Reports that the assignment of Name to the value associated with index is
+  // not possible, for the given Context.
   void reportUnableToAssign(const char *Context, NaClBcIndexSize_t Index,
                             StringType &Name) {
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << "Function-local " << Context << " name '" << Name
            << "' can't be associated with index " << Index;
     Error(StrBuf.str());
   }
 };
 
@@ skipping 67 matching lines @@
   ~ModuleParser() override = default;
 
   const char *getBlockName() const override { return "module"; }
 
 private:
   Ice::TimerMarker Timer;
   // True if we have already installed names for unnamed global declarations,
   // and have generated global constant initializers.
   bool GlobalDeclarationNamesAndInitializersInstalled = false;
 
-  // Generates names for unnamed global addresses (i.e. functions and
-  // global variables). Then lowers global variable declaration
-  // initializers to the target. May be called multiple times. Only
-  // the first call will do the installation.
+  // Generates names for unnamed global addresses (i.e. functions and global
+  // variables). Then lowers global variable declaration initializers to the
+  // target. May be called multiple times. Only the first call will do the
+  // installation.
   void installGlobalNamesAndGlobalVarInitializers() {
     if (!GlobalDeclarationNamesAndInitializersInstalled) {
       Context->installGlobalNames();
       Context->createValueIDs();
       getTranslator().lowerGlobals(Context->getGlobalVariables());
       GlobalDeclarationNamesAndInitializersInstalled = true;
     }
   }
   bool ParseBlock(unsigned BlockID) override;
 
@@ skipping 130 matching lines @@
 void PNaClTranslator::translateBuffer(const std::string &IRFilename,
                                       MemoryBuffer *MemBuf) {
   std::unique_ptr<MemoryObject> MemObj(getNonStreamedMemoryObject(
       reinterpret_cast<const unsigned char *>(MemBuf->getBufferStart()),
       reinterpret_cast<const unsigned char *>(MemBuf->getBufferEnd())));
   translate(IRFilename, std::move(MemObj));
 }
 
 void PNaClTranslator::translate(const std::string &IRFilename,
                                 std::unique_ptr<MemoryObject> &&MemObj) {
-  // On error, we report_fatal_error to avoid destroying the MemObj.
-  // That may still be in use by IceBrowserCompileServer. Otherwise,
-  // we need to change the MemObj to be ref-counted, or have a wrapper,
-  // or simply leak. We also need a hook to tell the IceBrowserCompileServer
-  // to unblock its QueueStreamer.
+  // On error, we report_fatal_error to avoid destroying the MemObj. That may
+  // still be in use by IceBrowserCompileServer. Otherwise, we need to change
+  // the MemObj to be ref-counted, or have a wrapper, or simply leak. We also
+  // need a hook to tell the IceBrowserCompileServer to unblock its
+  // QueueStreamer.
   // https://code.google.com/p/nativeclient/issues/detail?id=4163
   Ostream &ErrStream = getContext()->getStrError();
   // Read header and verify it is good.
   NaClBitcodeHeader Header;
   if (Header.Read(MemObj.get())) {
     llvm::report_fatal_error("Invalid PNaCl bitcode header");
   }
   if (!Header.IsSupported()) {
     ErrStream << Header.Unsupported();
     if (!Header.IsReadable()) {
@@ skipping 23 matching lines @@
   }
   if (InputStreamFile.getBitcodeBytes().getExtent() % 4 != 0) {
     ErrStream
         << IRFilename
         << ": Bitcode stream should be a multiple of 4 bytes in length.\n";
     llvm::report_fatal_error("Bitcode stream should be a multiple of 4 bytes");
   }
 }
 
 } // end of namespace Ice