Subzero: Use a "known" version of clang-format.

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.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the PNaCl bitcode file to Ice, to machine code
@@ skipping 24 matching lines @@
 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.
 class ExtendedType {
   ExtendedType &operator=(const ExtendedType &Ty) = delete;
+
 public:
   /// Discriminator for LLVM-style RTTI.
   enum TypeKind { Undefined, Simple, FuncSig };
 
   ExtendedType() : Kind(Undefined) {}
   ExtendedType(const ExtendedType &Ty) = default;
 
   virtual ~ExtendedType() {}
 
   ExtendedType::TypeKind getKind() const { return Kind; }
@@ skipping 44 matching lines @@
     Stream << "FuncSig";
     break;
   }
   return Stream;
 }
 
 // Models an ICE type as an extended type.
 class SimpleExtendedType : public ExtendedType {
   SimpleExtendedType(const SimpleExtendedType &) = delete;
   SimpleExtendedType &operator=(const SimpleExtendedType &) = delete;
+
 public:
   Ice::Type getType() const { return Signature.getReturnType(); }
 
   static bool classof(const ExtendedType *Ty) {
     return Ty->getKind() == Simple;
   }
 };
 
 // Models a function signature as an extended type.
 class FuncSigExtendedType : public ExtendedType {
   FuncSigExtendedType(const FuncSigExtendedType &) = delete;
   FuncSigExtendedType &operator=(const FuncSigExtendedType &) = delete;
+
 public:
   const Ice::FuncSigType &getSignature() const { return Signature; }
   void setReturnType(Ice::Type ReturnType) {
     Signature.setReturnType(ReturnType);
   }
   void appendArgType(Ice::Type ArgType) { Signature.appendArgType(ArgType); }
   static bool classof(const ExtendedType *Ty) {
     return Ty->getKind() == FuncSig;
   }
 };
@@ skipping 63 matching lines @@
 
   /// Returns the undefined type associated with type ID.
   /// Note: Returns extended type ready to be defined.
   ExtendedType *getTypeByIDForDefining(unsigned ID) {
     // 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())
-      TypeIDValues.resize(ID+1);
+      TypeIDValues.resize(ID + 1);
     return &TypeIDValues[ID];
   }
 
   /// Returns the type associated with the given index.
   Ice::Type getSimpleTypeByID(unsigned ID) {
     const ExtendedType *Ty = getTypeByIDAsKind(ID, ExtendedType::Simple);
     if (Ty == nullptr)
       // Return error recovery value.
       return Ice::IceType_void;
     return cast<SimpleExtendedType>(Ty)->getType();
@@ skipping 784 matching lines @@
 protected:
   typedef SmallString<128> StringType;
 
   // Associates Name with the value defined by the given Index.
   virtual void setValueName(uint64_t Index, StringType &Name) = 0;
 
   // Associates Name with the value defined by the given Index;
   virtual void setBbName(uint64_t Index, StringType &Name) = 0;
 
 private:
-
   void ProcessRecord() override;
 
   void ConvertToString(StringType &ConvertedName) {
     const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
     for (size_t i = 1, e = Values.size(); i != e; ++i) {
       ConvertedName += static_cast<char>(Values[i]);
     }
   }
 };
 
@@ skipping 65 matching lines @@
       for (Ice::Type ArgType : Signature.getArgList()) {
         Func->addArg(getNextInstVar(ArgType));
       }
     }
   }
 
   ~FunctionParser() final {}
 
   const char *getBlockName() const override { return "function"; }
 
-  Ice::Cfg *getFunc() const {
-    return Func;
-  }
+  Ice::Cfg *getFunc() const { return Func; }
 
-  uint32_t getNumGlobalIDs() const {
-    return CachedNumGlobalValueIDs;
-  }
+  uint32_t getNumGlobalIDs() const { return CachedNumGlobalValueIDs; }
 
   void setNextLocalInstIndex(Ice::Operand *Op) {
     setOperand(NextLocalInstIndex++, Op);
   }
 
   // Set the next constant ID to the given constant C.
   void setNextConstantID(Ice::Constant *C) { setNextLocalInstIndex(C); }
 
   // Returns the value referenced by the given value Index.
   Ice::Operand *getOperand(uint32_t Index) {
@@ skipping 459 matching lines @@
     if (typeNumElements(Type1) != typeNumElements(Type2))
       return false;
     Type1 = typeElementType(Type1);
     Type2 = typeElementType(Type2);
     return true;
   }
 
   /// Returns true iff an integer truncation from SourceType to TargetType is
   /// valid.
   static bool isIntTruncCastValid(Ice::Type SourceType, Ice::Type TargetType) {
-    return Ice::isIntegerType(SourceType)
-        && Ice::isIntegerType(TargetType)
-        && simplifyOutCommonVectorType(SourceType, TargetType)
-        && getScalarIntBitWidth(SourceType) > getScalarIntBitWidth(TargetType);
+    return Ice::isIntegerType(SourceType) && Ice::isIntegerType(TargetType) &&
+           simplifyOutCommonVectorType(SourceType, TargetType) &&
+           getScalarIntBitWidth(SourceType) > getScalarIntBitWidth(TargetType);
   }
 
   /// Returns true iff a floating type truncation from SourceType to TargetType
   /// is valid.
   static bool isFloatTruncCastValid(Ice::Type SourceType,
                                     Ice::Type TargetType) {
-    return simplifyOutCommonVectorType(SourceType, TargetType)
-        && SourceType == Ice::IceType_f64
-        && TargetType == Ice::IceType_f32;
+    return simplifyOutCommonVectorType(SourceType, TargetType) &&
+           SourceType == Ice::IceType_f64 && TargetType == Ice::IceType_f32;
   }
 
   /// Returns true iff an integer extension from SourceType to TargetType is
   /// valid.
   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.
@@ skipping 385 matching lines @@
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Select condition type " << CondType
                << " not allowed for values of type " << ThenType;
         Error(StrBuf.str());
         appendErrorInstruction(ThenType);
         return;
       }
     } else if (CondVal->getType() != Ice::IceType_i1) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
-      StrBuf << "Select condition " << CondVal << " not type i1. Found: "
-             << CondVal->getType();
+      StrBuf << "Select condition " << CondVal
+             << " not type i1. Found: " << CondVal->getType();
       Error(StrBuf.str());
       appendErrorInstruction(ThenType);
       return;
     }
     CurrentNode->appendInst(Ice::InstSelect::create(
         Func, getNextInstVar(ThenType), CondVal, ThenVal, ElseVal));
     return;
   }
   case naclbitc::FUNC_CODE_INST_EXTRACTELT: {
     // EXTRACTELT: [opval, opval]
@@ skipping 61 matching lines @@
       assert(Op1 == nullptr && Op2 == nullptr);
       setNextLocalInstIndex(nullptr);
       return;
     }
     Ice::Type Op1Type = Op1->getType();
     Ice::Type Op2Type = Op2->getType();
     Ice::Type DestType = getCompareResultType(Op1Type);
     if (Op1Type != Op2Type) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
-      StrBuf << "Compare argument types differ: " << Op1Type
-             << " and " << Op2Type;
+      StrBuf << "Compare argument types differ: " << Op1Type << " and "
+             << Op2Type;
       Error(StrBuf.str());
       appendErrorInstruction(DestType);
       Op2 = Op1;
     }
     if (DestType == Ice::IceType_void) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Compare not defined for type " << Op1Type;
       Error(StrBuf.str());
       return;
     }
     Ice::Variable *Dest = getNextInstVar(DestType);
     if (isIntegerType(Op1Type)) {
       Ice::InstIcmp::ICond Cond;
       if (!convertNaClBitcICmpOpToIce(Values[2], Cond)) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Compare record contains unknown integer predicate index: "
                << Values[2];
         Error(StrBuf.str());
         appendErrorInstruction(DestType);
       }
       CurrentNode->appendInst(
           Ice::InstIcmp::create(Func, Cond, Dest, Op1, Op2));
-    } else if (isFloatingType(Op1Type)){
+    } else if (isFloatingType(Op1Type)) {
       Ice::InstFcmp::FCond Cond;
       if (!convertNaClBitcFCompOpToIce(Values[2], Cond)) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Compare record contains unknown float predicate index: "
                << Values[2];
         Error(StrBuf.str());
         appendErrorInstruction(DestType);
       }
       CurrentNode->appendInst(
@@ skipping 42 matching lines @@
       if (!isValidRecordSize(3, "branch"))
         return;
       Ice::Operand *Cond = getRelativeOperand(Values[2], BaseIndex);
       if (isIRGenerationDisabled()) {
         assert(Cond == nullptr);
         return;
       }
       if (Cond->getType() != Ice::IceType_i1) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
-        StrBuf << "Branch condition " << *Cond << " not i1. Found: "
-               << Cond->getType();
+        StrBuf << "Branch condition " << *Cond
+               << " not i1. Found: " << Cond->getType();
         Error(StrBuf.str());
         return;
       }
       Ice::CfgNode *ThenBlock = getBranchBasicBlock(Values[0]);
       Ice::CfgNode *ElseBlock = getBranchBasicBlock(Values[1]);
       if (ThenBlock == nullptr || ElseBlock == nullptr)
         return;
       CurrentNode->appendInst(
           Ice::InstBr::create(Func, Cond, ThenBlock, ElseBlock));
     }
@@ skipping 37 matching lines @@
     Ice::CfgNode *DefaultLabel =
         isIRGenDisabled ? nullptr : getBranchBasicBlock(Values[2]);
     unsigned NumCases = Values[3];
 
     // Now recognize each of the cases.
     if (!isValidRecordSize(4 + NumCases * 4, "switch"))
       return;
     Ice::InstSwitch *Switch =
         isIRGenDisabled ? nullptr : Ice::InstSwitch::create(Func, NumCases,
                                                             Cond, DefaultLabel);
-    unsigned ValCaseIndex = 4;  // index to beginning of case entry.
+    unsigned ValCaseIndex = 4; // index to beginning of case entry.
     for (unsigned CaseIndex = 0; CaseIndex < NumCases;
          ++CaseIndex, ValCaseIndex += 4) {
-      if (Values[ValCaseIndex] != 1 || Values[ValCaseIndex+1] != 1) {
+      if (Values[ValCaseIndex] != 1 || Values[ValCaseIndex + 1] != 1) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Sequence [1, 1, value, label] expected for case entry "
                << "in switch record. (at index" << ValCaseIndex << ")";
         Error(StrBuf.str());
         return;
       }
       Ice::APInt Value(BitWidth,
                        NaClDecodeSignRotatedValue(Values[ValCaseIndex + 2]));
       if (isIRGenDisabled)
         continue;
       Ice::CfgNode *Label = getBranchBasicBlock(Values[ValCaseIndex + 3]);
       Switch->addBranch(CaseIndex, Value.getSExtValue(), Label);
     }
     if (isIRGenDisabled)
       return;
     CurrentNode->appendInst(Switch);
     InstIsTerminating = true;
     return;
   }
   case naclbitc::FUNC_CODE_INST_UNREACHABLE: {
     // UNREACHABLE: []
     if (!isValidRecordSize(0, "unreachable"))
       return;
     if (isIRGenerationDisabled())
       return;
-    CurrentNode->appendInst(
-        Ice::InstUnreachable::create(Func));
+    CurrentNode->appendInst(Ice::InstUnreachable::create(Func));
     InstIsTerminating = true;
     return;
   }
   case naclbitc::FUNC_CODE_INST_PHI: {
     // PHI: [ty, val1, bb1, ..., valN, bbN] for n >= 2.
     if (!isValidRecordSizeAtLeast(3, "phi"))
       return;
     Ice::Type Ty = Context->getSimpleTypeByID(Values[0]);
     if ((Values.size() & 0x1) == 0) {
       // Not an odd number of values.
@@ skipping 185 matching lines @@
         setNextLocalInstIndex(nullptr);
       return;
     }
 
     // Create the call instruction.
     Ice::Variable *Dest = (ReturnType == Ice::IceType_void)
                               ? nullptr
                               : getNextInstVar(ReturnType);
     Ice::InstCall *Inst = nullptr;
     if (IntrinsicInfo) {
-      Inst =
-          Ice::InstIntrinsicCall::create(Func, NumParams, Dest, Callee,
-                                         IntrinsicInfo->Info);
+      Inst = Ice::InstIntrinsicCall::create(Func, NumParams, Dest, Callee,
+                                            IntrinsicInfo->Info);
     } else {
       Inst = Ice::InstCall::create(Func, NumParams, Dest, Callee, IsTailCall);
     }
 
     // Add parameters.
     for (Ice::SizeT ParamIndex = 0; ParamIndex < NumParams; ++ParamIndex) {
       Inst->addArg(
           getRelativeOperand(Values[ParamsStartIndex + ParamIndex], BaseIndex));
     }
 
@@ skipping 321 matching lines @@
     if (!Decl->hasName()) {
       Decl->setName(Trans.createUnnamedName(Prefix, NameIndex));
       ++NameIndex;
     } else {
       Trans.checkIfUnnamedNameSafe(Decl->getName(), Context, Prefix);
     }
   }
 
   bool ParseBlock(unsigned BlockID) override;
 
-  void ExitBlock() override {
-    InstallGlobalNamesAndGlobalVarInitializers();
-  }
+  void ExitBlock() override { InstallGlobalNamesAndGlobalVarInitializers(); }
 
   void ProcessRecord() override;
 };
 
 class ModuleValuesymtabParser : public ValuesymtabParser {
   ModuleValuesymtabParser(const ModuleValuesymtabParser &) = delete;
   void operator=(const ModuleValuesymtabParser &) = delete;
 
 public:
   ModuleValuesymtabParser(unsigned BlockID, ModuleParser *MP)
@@ skipping 162 matching lines @@
 
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus.assign(EC_Bitcode);
   }
 }
 
 } // end of namespace Ice