Reflow comments to use the full width.

src/IceConverter.cpp

 //===- subzero/src/IceConverter.cpp - Converts LLVM to Ice  ---------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 34 matching lines @@
 // Debugging helper
 template <typename T> static std::string LLVMObjectAsString(const T *O) {
   std::string Dump;
   raw_string_ostream Stream(Dump);
   O->print(Stream);
   return Stream.str();
 }
 
 // Base class for converting LLVM to ICE.
 // TODO(stichnot): Redesign Converter, LLVM2ICEConverter,
-// LLVM2ICEFunctionConverter, and LLVM2ICEGlobalsConverter with
-// respect to Translator.  In particular, the unique_ptr ownership
-// rules in LLVM2ICEFunctionConverter.
+// LLVM2ICEFunctionConverter, and LLVM2ICEGlobalsConverter with respect to
+// Translator.  In particular, the unique_ptr ownership rules in
+// LLVM2ICEFunctionConverter.
 class LLVM2ICEConverter {
   LLVM2ICEConverter() = delete;
   LLVM2ICEConverter(const LLVM2ICEConverter &) = delete;
   LLVM2ICEConverter &operator=(const LLVM2ICEConverter &) = delete;
 
 public:
   explicit LLVM2ICEConverter(Ice::Converter &Converter)
       : Converter(Converter), Ctx(Converter.getContext()),
         TypeConverter(Converter.getModule()->getContext()) {}
 
   Ice::Converter &getConverter() const { return Converter; }
 
 protected:
   Ice::Converter &Converter;
   Ice::GlobalContext *Ctx;
   const Ice::TypeConverter TypeConverter;
 };
 
-// Converter from LLVM functions to ICE. The entry point is the
-// convertFunction method.
+// Converter from LLVM functions to ICE. The entry point is the convertFunction
+// method.
 //
-// Note: this currently assumes that the given IR was verified to be
-// valid PNaCl bitcode. Otherwise, the behavior is undefined.
+// Note: this currently assumes that the given IR was verified to be valid
+// PNaCl bitcode. Otherwise, the behavior is undefined.
 class LLVM2ICEFunctionConverter : LLVM2ICEConverter {
   LLVM2ICEFunctionConverter() = delete;
   LLVM2ICEFunctionConverter(const LLVM2ICEFunctionConverter &) = delete;
   LLVM2ICEFunctionConverter &
   operator=(const LLVM2ICEFunctionConverter &) = delete;
 
 public:
   explicit LLVM2ICEFunctionConverter(Ice::Converter &Converter)
       : LLVM2ICEConverter(Converter), Func(nullptr) {}
 
   void convertFunction(const Function *F) {
     if (Ctx->isIRGenerationDisabled())
       return;
     Func = Ice::Cfg::create(Ctx, Converter.getNextSequenceNumber());
     Ice::Cfg::setCurrentCfg(Func.get());
 
     VarMap.clear();
     NodeMap.clear();
     Func->setFunctionName(F->getName());
     Func->setReturnType(convertToIceType(F->getReturnType()));
     Func->setInternal(F->hasInternalLinkage());
     Ice::TimerMarker T(Ice::TimerStack::TT_llvmConvert, Func.get());
 
     // The initial definition/use of each arg is the entry node.
     for (auto ArgI = F->arg_begin(), ArgE = F->arg_end(); ArgI != ArgE;
          ++ArgI) {
       Func->addArg(mapValueToIceVar(ArgI));
     }
 
-    // Make an initial pass through the block list just to resolve the
-    // blocks in the original linearized order.  Otherwise the ICE
-    // linearized order will be affected by branch targets in
-    // terminator instructions.
+    // Make an initial pass through the block list just to resolve the blocks
+    // in the original linearized order. Otherwise the ICE linearized order
+    // will be affected by branch targets in terminator instructions.
     for (const BasicBlock &BBI : *F)
       mapBasicBlockToNode(&BBI);
     for (const BasicBlock &BBI : *F)
       convertBasicBlock(&BBI);
     Func->setEntryNode(mapBasicBlockToNode(&F->getEntryBlock()));
     Func->computeInOutEdges();
 
     Ice::Cfg::setCurrentCfg(nullptr);
     Converter.translateFcn(std::move(Func));
   }
 
-  // convertConstant() does not use Func or require it to be a valid
-  // Ice::Cfg pointer.  As such, it's suitable for e.g. constructing
-  // global initializers.
+  // convertConstant() does not use Func or require it to be a valid Ice::Cfg
+  // pointer. As such, it's suitable for e.g. constructing global initializers.
   Ice::Constant *convertConstant(const Constant *Const) {
     if (const auto GV = dyn_cast<GlobalValue>(Const)) {
       Ice::GlobalDeclaration *Decl = getConverter().getGlobalDeclaration(GV);
       bool IsUndefined = false;
       if (const auto *Func = llvm::dyn_cast<Ice::FunctionDeclaration>(Decl))
         IsUndefined = Func->isProto();
       else if (const auto *Var = llvm::dyn_cast<Ice::VariableDeclaration>(Decl))
         IsUndefined = !Var->hasInitializer();
       else
         report_fatal_error("Unhandled GlobalDeclaration type");
@@ skipping 52 matching lines @@
   }
 
   Ice::Type convertToIceType(Type *LLVMTy) const {
     Ice::Type IceTy = TypeConverter.convertToIceType(LLVMTy);
     if (IceTy == Ice::IceType_NUM)
       report_fatal_error(std::string("Invalid PNaCl type ") +
                          LLVMObjectAsString(LLVMTy));
     return IceTy;
   }
 
-  // Given an LLVM instruction and an operand number, produce the
-  // Ice::Operand this refers to. If there's no such operand, return
-  // nullptr.
+  // Given an LLVM instruction and an operand number, produce the Ice::Operand
+  // this refers to. If there's no such operand, return nullptr.
   Ice::Operand *convertOperand(const Instruction *Inst, unsigned OpNum) {
     if (OpNum >= Inst->getNumOperands()) {
       return nullptr;
     }
     const Value *Op = Inst->getOperand(OpNum);
     return convertValue(Op);
   }
 
   Ice::Operand *convertValue(const Value *Op) {
     if (const auto Const = dyn_cast<Constant>(Op)) {
@@ skipping 331 matching lines @@
       Ice::CfgNode *CaseSuccessor = mapBasicBlockToNode(I.getCaseSuccessor());
       Switch->addBranch(CurrentCase, CaseValue, CaseSuccessor);
     }
     return Switch;
   }
 
   Ice::Inst *convertCallInstruction(const CallInst *Inst) {
     Ice::Variable *Dest = mapValueToIceVar(Inst);
     Ice::Operand *CallTarget = convertValue(Inst->getCalledValue());
     unsigned NumArgs = Inst->getNumArgOperands();
-    // Note: Subzero doesn't (yet) do anything special with the Tail
-    // flag in the bitcode, i.e. CallInst::isTailCall().
+    // Note: Subzero doesn't (yet) do anything special with the Tail flag in
+    // the bitcode, i.e. CallInst::isTailCall().
     Ice::InstCall *NewInst = nullptr;
     const Ice::Intrinsics::FullIntrinsicInfo *Info = nullptr;
 
     if (const auto Target = dyn_cast<Ice::ConstantRelocatable>(CallTarget)) {
       // Check if this direct call is to an Intrinsic (starts with "llvm.")
       bool BadIntrinsic;
       Info = Ctx->getIntrinsicsInfo().find(Target->getName(), BadIntrinsic);
       if (BadIntrinsic) {
         report_fatal_error(std::string("Invalid PNaCl intrinsic call: ") +
                            LLVMObjectAsString(Inst));
@@ skipping 76 matching lines @@
 private:
   // Data
   std::unique_ptr<Ice::Cfg> Func;
   std::map<const Value *, Ice::Variable *> VarMap;
   std::map<const BasicBlock *, Ice::CfgNode *> NodeMap;
 };
 
 // Converter from LLVM global variables to ICE. The entry point is the
 // convertGlobalsToIce method.
 //
-// Note: this currently assumes that the given IR was verified to be
-// valid PNaCl bitcode. Othewise, the behavior is undefined.
+// Note: this currently assumes that the given IR was verified to be valid
+// PNaCl bitcode. Otherwise, the behavior is undefined.
 class LLVM2ICEGlobalsConverter : public LLVM2ICEConverter {
   LLVM2ICEGlobalsConverter() = delete;
   LLVM2ICEGlobalsConverter(const LLVM2ICEGlobalsConverter &) = delete;
   LLVM2ICEGlobalsConverter &
   operator=(const LLVM2ICEGlobalsConverter &) = delete;
 
 public:
   explicit LLVM2ICEGlobalsConverter(Ice::Converter &Converter)
       : LLVM2ICEConverter(Converter) {}
 
-  /// Converts global variables, and their initializers into ICE
-  /// global variable declarations, for module Mod. Returns the set of
-  /// converted declarations.
+  /// Converts global variables, and their initializers into ICE global variable
+  /// declarations, for module Mod. Returns the set of converted declarations.
   std::unique_ptr<Ice::VariableDeclarationList>
   convertGlobalsToIce(Module *Mod);
 
 private:
-  // Adds the Initializer to the list of initializers for the Global
-  // variable declaraation.
+  // Adds the Initializer to the list of initializers for the Global variable
+  // declaration.
   void addGlobalInitializer(Ice::VariableDeclaration &Global,
                             const Constant *Initializer) {
     const bool HasOffset = false;
     const Ice::RelocOffsetT Offset = 0;
     addGlobalInitializer(Global, Initializer, HasOffset, Offset);
   }
 
   // Adds Initializer to the list of initializers for Global variable
-  // declaration.  HasOffset is true only if Initializer is a
-  // relocation initializer and Offset should be added to the
-  // relocation.
+  // declaration. HasOffset is true only if Initializer is a relocation
+  // initializer and Offset should be added to the relocation.
   void addGlobalInitializer(Ice::VariableDeclaration &Global,
                             const Constant *Initializer, bool HasOffset,
                             Ice::RelocOffsetT Offset);
 
-  // Converts the given constant C to the corresponding integer
-  // literal it contains.
+  // Converts the given constant C to the corresponding integer literal it
+  // contains.
   Ice::RelocOffsetT getIntegerLiteralConstant(const Value *C) {
     const auto CI = dyn_cast<ConstantInt>(C);
     if (CI && CI->getType()->isIntegerTy(32))
       return CI->getSExtValue();
 
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << "Constant not i32 literal: " << *C;
     report_fatal_error(StrBuf.str());
     return 0;
@@ skipping 205 matching lines @@
       Ctx->pushTimer(TimerID, StackID);
     }
     LLVM2ICEFunctionConverter FunctionConverter(*this);
     FunctionConverter.convertFunction(&I);
     if (TimeThisFunction)
       Ctx->popTimer(TimerID, StackID);
   }
 }
 
 } // end of namespace Ice