Don't allow instructions/globals to use alignment > 2**29.

lib/Bitcode/NaCl/Analysis/NaClObjDump.cpp

 //===-- NaClObjDump.cpp - Dump PNaCl bitcode contents ---------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/STLExtras.h"
@@ skipping 21 matching lines @@
 namespace {
 
 using namespace llvm;
 
 static cl::opt<bool>
 ReportWarningsAsErrors(
     "Werror",
     cl::desc("Report warnings as errors."),
     cl::init(false));
 
+static cl::opt<bool>
+IgnorePNaClABIChecks(
+    "ignore-pnaclabi-checks",
+    cl::desc("Ignore checking bitcode for PNaCl ABI violations"),
+    cl::init(false));
+
 /// Class to handle sign rotations in a human readable form. That is,
 /// the sign is in the low bit. The two special cases are:
 /// 1) -1 is true for i1.
 /// 2) The representation allows -0 (which is different than 0).
 class SignRotatedInt {
 public:
   SignRotatedInt(uint64_t Value, Type* ValueType)
       : SignedValue(Value >> 1),
         IsNegated((Value & 0x1)
                   && !(ValueType->isIntegerTy()
@@ skipping 874 matching lines @@
   }
 
   /// Increments the current number of defined global abbreviations.
   void IncNumGlobalAbbreviations(unsigned BlockID) {
     ++GlobalAbbrevsCountMap[BlockID];
   }
 
   /// Verifies the given integer operator has the right type.  Returns
   /// the operator.
   const char *VerifyIntArithmeticOp(const char *Op, Type *OpTy) {
-    if (!PNaClABITypeChecker::isValidIntArithmeticType(OpTy)) {
+    if (!IgnorePNaClABIChecks &&
+        !PNaClABITypeChecker::isValidIntArithmeticType(OpTy)) {
       Errors() << Op << ": Invalid integer arithmetic type: " << *OpTy;
     }
     return Op;
   }
 
   // Checks the Alignment for loading/storing a value of type Ty. If
   // invalid, generates an appropriate error message.
   void VerifyMemoryAccessAlignment(const char *Op, Type *Ty,
-                                   uint64_t Alignment) {
+                                   unsigned Alignment) {
+    if (IgnorePNaClABIChecks) return;
     if (!PNaClABIProps::isAllowedAlignment(&DL, Alignment, Ty)) {
       if (unsigned Expected = NaClGetExpectedLoadStoreAlignment(DL, Ty)) {
         Errors() << Op << ": Illegal alignment for " << *Ty
                  << ". Expects: " << Expected << "\n";
       } else {
         Errors() << Op << ": Not allowed for type: " << *Ty << "\n";
       }
     }
   }
 
@@ skipping 834 matching lines @@
       Errors() << "Integer record should have one argument. Found: "
                << Values.size() << "\n";
       Size = 32;
     }
     switch (Size) {
       case 1:
       case 8:
       case 16:
       case 32:
       case 64: {
-          break;
+        break;
+      }
+      default:
+        if (!IgnorePNaClABIChecks) {
+          Errors() << "Integer record contains bad integer size: "
+                   << Size << "\n";
+          Size = 32;
         }
-      default:
-        Errors() << "Integer record contains bad integer size: "
-                 << Size << "\n";
-        Size = 32;
         break;
     }
     Type *IntType = GetIntegerType(Size);
     Tokens() << NextTypeId() << Space() << "=" << Space()
              << TokenizeType(IntType) << Semicolon()
              << TokenizeAbbrevIndex() << Endline();
     InstallType(IntType);
     break;
   }
   case naclbitc::TYPE_CODE_VECTOR: {
     // VECTOR: [numelts, eltty]
     if (Values.size() != 2) {
       Errors() << "Vector record should contain two arguments. Found: "
                << Values.size() << "\n";
       InstallUnknownTypeForNextId();
       break;
     }
     Type *BaseType = GetType(Values[1]);
     if (!(BaseType->isIntegerTy()
           || BaseType->isFloatTy()
           || BaseType->isDoubleTy())) {
       Type *ErrorRecoveryTy = GetIntegerType(32);
       Errors() << "Vectors can only be defined on primitive types. Found "
                << *BaseType << ". Assuming " << *ErrorRecoveryTy
                << " instead.\n";
       BaseType = ErrorRecoveryTy;
     }
     uint64_t NumElements = Values[0];
     Type *VecType = VectorType::get(BaseType, NumElements);
-    if (!PNaClABITypeChecker::isValidVectorType(VecType)) {
+    if (!IgnorePNaClABIChecks &&
+        !PNaClABITypeChecker::isValidVectorType(VecType)) {
       Errors() << "Vector type " << *VecType << " not allowed.\n";
     }
     Tokens() << NextTypeId() << Space() << "=" << Space()
              << TokenizeType(VecType) << Semicolon()
              << TokenizeAbbrevIndex() << Endline();
     InstallType(VecType);
     break;
   }
   case naclbitc::TYPE_CODE_FUNCTION: {
     // FUNCTION: [vararg, retty, paramty x N]
@@ skipping 354 matching lines @@
       // Verify that expected intrinsic function type matches declared
       // type signature.
       FunctionType *FcnTy = GetFunctionType(ValID);
       if (FcnTy->getNumParams() != IntrinTy->getNumParams()) {
         Errors() << "Intrinsic " << Name
                  << " expects " << IntrinTy->getNumParams()
                  << " arguments. Found: " << FcnTy->getNumParams()
                  << "\n";
         break;
       }
-      if (!PNaClABITypeChecker::IsPointerEquivType(
+      if (!IgnorePNaClABIChecks && !PNaClABITypeChecker::IsPointerEquivType(
               IntrinTy->getReturnType(), FcnTy->getReturnType())) {
         Errors() << "Intrinsic " << Name
                  << " expects return type " << *IntrinTy->getReturnType()
                  << ". Found: " << *FcnTy->getReturnType() << "\n";
         break;
       }
       for (size_t i = 0; i < FcnTy->getNumParams(); ++i) {
-        if (!PNaClABITypeChecker::IsPointerEquivType(
+        if (!IgnorePNaClABIChecks && !PNaClABITypeChecker::IsPointerEquivType(
                 IntrinTy->getParamType(i),
                 FcnTy->getParamType(i))) {
           Errors() << "Intrinsic " << Name
                    << " expects " << *IntrinTy->getParamType(i)
                    << " for argument " << (i+1) << ". Found: "
                    << *FcnTy->getParamType(i) << "\n";
           break;
         }
       }
     }
@@ skipping 227 matching lines @@
 
   bool isFloatingType(Type *Ty) {
     return Ty->isFloatTy() || Ty->isDoubleTy();
   }
 
   /// Verifies that OpTy is an integer, or a vector of integers, for
   /// operator Op. Generates error messages if appropriate. Returns Op.
   const char *VerifyIntegerOrVectorOp(const char *Op, Type *OpTy) {
     Type *BaseTy = OpTy;
     if (OpTy->isVectorTy()) {
-      if (!PNaClABITypeChecker::isValidVectorType(OpTy)) {
+      if (!IgnorePNaClABIChecks &&
+          !PNaClABITypeChecker::isValidVectorType(OpTy)) {
         Errors() << Op << ": invalid vector type: " << *OpTy << "\n";
         return Op;
       }
       BaseTy = OpTy->getVectorElementType();
     }
     if (BaseTy->isIntegerTy()) {
-      if (PNaClABITypeChecker::isValidScalarType(BaseTy)) return Op;
+      if (IgnorePNaClABIChecks ||
+          PNaClABITypeChecker::isValidScalarType(BaseTy)) {
+        return Op;
+      }
       Errors() << Op << ": Invalid integer type: " << *OpTy << "\n";
     } else {
       Errors() << Op << ": Expects integer type. Found: " << *OpTy << "\n";
     }
     return Op;
   }
 
   /// Verifies that Opty is a floating point type, or a vector of a
   /// floating points, for operator Op. Generates error messages if
   /// appropriate. Returns Op.
   const char *VerifyFloatingOrVectorOp(const char *Op, Type *OpTy) {
     Type *BaseTy = OpTy;
     if (OpTy->isVectorTy()) {
-      if (!PNaClABITypeChecker::isValidVectorType(OpTy)) {
+      if (!IgnorePNaClABIChecks &&
+          !PNaClABITypeChecker::isValidVectorType(OpTy)) {
         Errors() << Op << ": invalid vector type: " << *OpTy << "\n";
         return Op;
       }
       BaseTy = OpTy->getVectorElementType();
     }
     if (!isFloatingType(BaseTy)) {
       Errors() << Op << ": Expects floating point. Found "
                << OpTy << "\n";
       return Op;
     }
-    if (!PNaClABITypeChecker::isValidScalarType(BaseTy)) {
+    if (!IgnorePNaClABIChecks &&
+        !PNaClABITypeChecker::isValidScalarType(BaseTy)) {
       Errors() << Op << ": type not allowed: " << OpTy << "\n";
     }
     return Op;
   }
 
   /// Op is the name of the operation that called this.  Checks if
   /// OpTy is either a (non-void) scalar, or a vector of scalars. If
   /// not, generates an appropriate error message. Always returns Op.
   const char *VerifyScalarOrVectorOp(const char *Op, Type *OpTy) {
+    if (IgnorePNaClABIChecks) return Op;
     if (PNaClABITypeChecker::isValidScalarType(OpTy)) {
       if (OpTy->isVoidTy())
         Errors() << Op << ": Type void not allowed\n";
     } else if (!PNaClABITypeChecker::isValidVectorType(OpTy)) {
       Errors() << Op << ": Expects scalar/vector type. Found: "
                << OpTy << "\n";
     }
     return Op;
   }
 
   void VerifyIndexedVector(const char *Op, uint32_t VecValue,
                            uint32_t IdxValue) {
     Type *VecType = GetValueType(VecValue);
     Type *IdxType = GetValueType(IdxValue);
-    if (!PNaClABITypeChecker::isValidVectorType(VecType)){
+    if (!IgnorePNaClABIChecks &&
+        !PNaClABITypeChecker::isValidVectorType(VecType)){
       if (VecType->isVectorTy())
         Errors() << Op << ": Vector type " << *VecType << " not allowed\n";
       else
         Errors() << Op << ": Vector type expected. Found: " << *VecType << "\n";
     }
     // Note: This restriction appears to be LLVM specific.
     if (!IdxType->isIntegerTy(32)) {
       Errors() << Op << ": Index not i32. Found: " << *IdxType << "\n";
     }
     BitcodeId IdxId(GetBitcodeId(IdxValue));
     if (IdxId.GetKind() != 'c') {
       Errors() << Op << ": Vector index not constant: " << IdxId << "\n";
       // TODO(kschimpf): We should check that Idx is a constant with
       // valid access. However, we currently don't store constant
       // values, so it can't be tested.
     }
   }
 
   /// Checks if block Value is a valid branch target for the current
   /// function block. If not, generates an appropriate error message.
   void VerifyBranchRange(uint64_t Value) {
     if (0 == Value || Value >= ExpectedNumBbs) {
       Errors() << "Branch " << BitcodeId('b', Value)
                << " out of range. Not in [1," << ExpectedNumBbs << "]\n";
     }
   }
+
+  /// Convert alignment exponent (i.e. power of two (or zero)) to the
+  /// corresponding alignment to use. If alignment is too large, it generates
+  /// an error message and returns 0.
+  unsigned getAlignmentValue(uint64_t Exponent);
 };
 
 NaClDisFunctionParser::NaClDisFunctionParser(
     unsigned BlockID,
     NaClDisBlockParser *EnclosingParser)
     : NaClDisBlockParser(BlockID, EnclosingParser),
       CurrentBbIndex(-1),
       ExpectedNumBbs(0),
       InstIsTerminating(false) {
   Context->ResetLocalCounters();
@@ skipping 12 matching lines @@
 
   // Now install parameters.
   for (size_t Index = 0; Index < FcnTy->getFunctionNumParams(); ++Index) {
     InstallParamType(FcnTy->getFunctionParamType(Index));
   }
 }
 
 void NaClDisFunctionParser::PrintBlockHeader() {
   Tokens() << "function" << Space();
   BitcodeId FunctionId('f', FcnId);
-  if (!(Context->IsFunctionIntrinsic(FcnId)
-        || PNaClABITypeChecker::isValidFunctionType(FcnTy))) {
+  bool InvalidSignature = true; // until proven otherwise.
+  if (Context->IsFunctionIntrinsic(FcnId))
+    InvalidSignature = false;
+  else if (IgnorePNaClABIChecks ||
+           PNaClABITypeChecker::isValidFunctionType(FcnTy)) {
+      InvalidSignature = false;
+  }
+  if (InvalidSignature) {
     Errors() << "Invalid type signature for "
              << BitcodeId('f', FcnId) << ": " << *FcnTy << "\n";
   }
   Tokens() << TokenizeFunctionSignature(FcnTy, &FunctionId)
            << Space() << OpenCurly()
            << Space() << Space() << "// BlockID = " << GetBlockID()
            << Endline();
 }
 
 const char *NaClDisFunctionParser::GetBinop(uint32_t Opcode, Type *Ty) {
@@ skipping 166 matching lines @@
     return "ult";
   case CmpInst::FCMP_ULE:
     return "ule";
   case CmpInst::FCMP_UNE:
     return "une";
   case CmpInst::FCMP_TRUE:
     return "true";
   }
 }
 
+namespace {
+
+static const unsigned MaxAlignmentExponent = 29;
+static_assert(
+    (1u << MaxAlignmentExponent) == Value::MaximumAlignment,
+    "Inconsistency between Value.MaxAlignment and PNaCl alignment limit");
+}
+
+unsigned NaClDisFunctionParser::getAlignmentValue(uint64_t Exponent) {
+  if (Exponent > MaxAlignmentExponent + 1) {
+    Errors() << "Alignment can't be greater than 2**" << MaxAlignmentExponent
+             << ". Found: 2**" << (Exponent - 1) << "\n";
+    return 0;
+  }
+  return (1 << static_cast<unsigned>(Exponent)) >> 1;
+}
+
 bool NaClDisFunctionParser::ParseBlock(unsigned BlockID) {
   ObjDumpSetRecordBitAddress(GetBlock().GetStartBit());
   switch (BlockID) {
   case naclbitc::CONSTANTS_BLOCK_ID: {
     NaClDisConstantsParser Parser(BlockID, this);
     return Parser.ParseThisBlock();
   }
   case naclbitc::VALUE_SYMTAB_BLOCK_ID: {
     if (!PNaClAllowLocalSymbolTables) break;
     NaClDisValueSymtabParser Parser(BlockID, this);
@@ skipping 128 matching lines @@
           << "Function switch record expects at least 4 arguments. Found: "
           << Values.size() << "\n";
       break;
     }
     Type *OpType = GetType(Values[0]);
     uint32_t CondId = RelativeToAbsId(Values[1]);
     Type *CondType = GetValueType(CondId);
     if (OpType != CondType)
       Errors() << "Specified select type " << *OpType << " but found: "
                << *CondType << "\n";
-    if (!PNaClABITypeChecker::isValidSwitchConditionType(CondType))
+    if (!IgnorePNaClABIChecks &&
+        !PNaClABITypeChecker::isValidSwitchConditionType(CondType)) {
       Errors() << PNaClABITypeChecker::ExpectedSwitchConditionType(CondType)
                << "\n";
+    }
     uint32_t DefaultBb = Values[2];
     unsigned NumCases = Values[3];
     VerifyBranchRange(DefaultBb);
     Tokens() << "switch" << Space() << StartCluster() << StartCluster()
              << TokenizeType(OpType) << Space() <<  GetBitcodeId(CondId)
              << FinishCluster() << Space() << "{" << FinishCluster()
              << Endline();
     IncAssemblyIndent();
     Tokens() << StartCluster() << "default" << ":" << Space()
              << FinishCluster() << StartCluster() << "br" << Space() << "label"
@@ skipping 58 matching lines @@
   case naclbitc::FUNC_CODE_INST_ALLOCA: {
     // ALLOCA:     [size, align]
     if (Values.size() != 2) {
       Errors() << "Function alloca record expects 2 arguments. Found: "
                << Values.size() << "\n";
       break;
     }
     uint32_t SizeOp = RelativeToAbsId(Values[0]);
     Type* SizeType = GetValueType(SizeOp);
     BitcodeId SizeId(GetBitcodeId(SizeOp));
-    uint64_t Alignment = (1 << Values[1]) >> 1;
-    if (!PNaClABIProps::isAllocaSizeType(SizeType))
+    unsigned Alignment = getAlignmentValue(Values[1]);
+    if (!IgnorePNaClABIChecks && !PNaClABIProps::isAllocaSizeType(SizeType))
       Errors() << PNaClABIProps::ExpectedAllocaSizeType() << "\n";
     // TODO(kschimpf) Are there any constraints on alignment?
     Tokens() << NextInstId() << Space() << "=" << Space() << StartCluster()
              << "alloca" << Space() << "i8" << Comma() << FinishCluster()
              << Space() << StartCluster() << TokenizeType(SizeType) << Space()
              << SizeId << Comma() << FinishCluster() << Space()
              << StartCluster() <<"align" << Space() << Alignment << Semicolon()
              << FinishCluster();
     InstallInstType(GetPointerType());
     break;
   }
   case naclbitc::FUNC_CODE_INST_LOAD: {
     // LOAD: [op, align, ty]
     if (Values.size() != 3) {
       Errors() << "Function load record expects 3 arguments. Found: "
                << Values.size() << "\n";
       break;
     }
-    uint64_t Alignment = (1 << Values[1]) >> 1;
+    unsigned Alignment = getAlignmentValue(Values[1]);
     Type *LoadType = GetType(Values[2]);
     VerifyScalarOrVectorOp("load", LoadType);
     Context->VerifyMemoryAccessAlignment("load", LoadType, Alignment);
     Tokens() << NextInstId() << Space() << "=" << Space() << StartCluster()
              << "load" << Space() << TokenizeType(LoadType) << "*" << Space()
              << GetBitcodeId(RelativeToAbsId(Values[0])) << Comma()
              << FinishCluster() << Space() << StartCluster()
              << "align" << Space() << Alignment << Semicolon()
              << FinishCluster();
     InstallInstType(LoadType);
     break;
   }
   case naclbitc::FUNC_CODE_INST_STORE: {
     // STORE: [ptr, val, align]
     if (Values.size() != 3) {
       Errors() << "Function store record expects 3 arguments. Found: "
                << Values.size() << "\n";
       break;
     }
-    uint64_t Alignment = (1 << Values[2]) >> 1;
+    unsigned Alignment = getAlignmentValue(Values[2]);
     uint32_t Val = RelativeToAbsId(Values[1]);
     Type *ValType = GetValueType(Val);
     VerifyScalarOrVectorOp("store", ValType);
     Context->VerifyMemoryAccessAlignment("store", ValType, Alignment);
     Tokens() << StartCluster() << "store" << Space() << TokenizeType(ValType)
              << Space() << GetBitcodeId(Val) << Comma() << FinishCluster()
              << Space() << StartCluster() << TokenizeType(ValType) << "*"
              << Space() << GetBitcodeId(RelativeToAbsId(Values[0])) << Comma()
              << FinishCluster() << Space() << StartCluster() << "align"
              << Space() << Alignment << Semicolon() << FinishCluster();
@@ skipping 130 matching lines @@
         Errors() << "Call indirect record expects at least 3 arguments. Found: "
                  << Values.size() << "\n";
         break;
       }
     }
     unsigned IsTailCall = (Values[0] & 0x1);
     CallingConv::ID CallingConv;
     uint32_t FcnId = RelativeToAbsId(Values[1]);
     if (!naclbitc::DecodeCallingConv(Values[0]>>1, CallingConv))
       Errors() << "Call unknown calling convention:" << (Values[0]>>1) << "\n";
-    if (!PNaClABIProps::isValidCallingConv(CallingConv)) {
+    if (!IgnorePNaClABIChecks &&
+        !PNaClABIProps::isValidCallingConv(CallingConv)) {
       Errors() << "Call uses disallowed calling convention: "
                << PNaClABIProps::CallingConvName(CallingConv) << "("
                << CallingConv << ")\n";
     }
     FunctionType *FcnType = 0;
     Type *ReturnType = 0;
     size_t ArgIndex = 2;
     // Flag defining if type checking should be done on argument/return
     // types.
     bool CheckArgRetTypes = true;
@@ skipping 13 matching lines @@
     } else {
       ReturnType = GetType(Values[2]);
       ArgIndex = 3;
     }
     if (!ReturnType->isVoidTy()) {
       Tokens() << NextInstId() << Space() << "=" << Space();
     }
     if (IsTailCall) {
       Tokens() << "tail" << Space();
     }
-    if (CheckArgRetTypes && !PNaClABITypeChecker::isValidParamType(ReturnType))
+    if (CheckArgRetTypes &&
+        !IgnorePNaClABIChecks &&
+        !PNaClABITypeChecker::isValidParamType(ReturnType)) {
       Errors() << "Invalid return type: " << *ReturnType << "\n";
+    }
     Tokens() << "call" << Space();
     if (CallingConv != CallingConv::C) {
       Tokens() << PNaClABIProps::CallingConvName(CallingConv) << Space();
     }
     Tokens() << TokenizeType(ReturnType) << Space()
              << StartCluster() << GetBitcodeId(FcnId) << OpenParen()
              << StartCluster();
     unsigned ParamIndex = 0;
     unsigned NumParams = Values.size() + 1 - ArgIndex;
     for (size_t i = ArgIndex; i < Values.size(); ++i, ++ParamIndex) {
       uint32_t ParamId = RelativeToAbsId(Values[i]);
       Type *ParamType = GetValueType(ParamId);
-      if (CheckArgRetTypes && !PNaClABITypeChecker::isValidParamType(ParamType))
+      if (CheckArgRetTypes &&
+          !IgnorePNaClABIChecks &&
+          !PNaClABITypeChecker::isValidParamType(ParamType)) {
         Errors() << "invalid type for parameter " << i << ": "
                  << *ParamType << "\n";
+      }
       if (FcnType) {
         if (ParamIndex < FcnType->getNumParams()) {
           Type *ExpectedType = FcnType->getParamType(ParamIndex);
           if (ParamType != ExpectedType) {
             Warnings() << "Parameter " << (ParamIndex + 1) << " mismatch: "
                        << *ParamType << " and " << *ExpectedType << "\n";
           }
         }
         else if (ParamIndex == FcnType->getNumParams()) {
           Warnings() << "Call expects " << FcnType->getNumParams()
@@ skipping 59 matching lines @@
     // was checked in method ProcessRecord.
     // Note: If the function was defined, the type was checked in
     // NaClDisFunctionParser::PrintBlockHeader.
     if (Context->HasDefinedFunctionIndex(NextFcnDefinedId)
         && i == Context->GetDefinedFunctionIndex(NextFcnDefinedId)) {
       ++NextFcnDefinedId;
       continue;
     }
     if (FunctionType *FcnTy = dyn_cast<FunctionType>(GetFunctionValueType(i))) {
       if (!Context->IsFunctionIntrinsic(i) &&
+          !IgnorePNaClABIChecks &&
           !PNaClABITypeChecker::isValidFunctionType(FcnTy)) {
         Context->SetRecordAddressToFunctionIdAddress(i);
         Errors() << "Invalid type signature for "
                  << BitcodeId('f', i) << ": " << *FcnTy << "\n";
       }
     }
   }
 }
 
 bool NaClDisModuleParser::ParseBlock(unsigned BlockID) {
@@ skipping 53 matching lines @@
     }
     bool IsProto = (Values[2] != 0);
     Tokens() << StartCluster() << (IsProto ? "declare" : "define");
     uint32_t FcnId = GetNumFunctions();
     BitcodeId FcnName('f', FcnId);
     std::string FcnStrName(FcnName.GetName());
     GlobalValue::LinkageTypes Linkage;
     if (!naclbitc::DecodeLinkage(Values[3], Linkage)) {
       Errors() << "Unknown linkage value: " << Values[3] << "\n";
     } else {
-      if (!PNaClABIProps::isValidGlobalLinkage(Linkage))
+      if (!IgnorePNaClABIChecks &&
+          !PNaClABIProps::isValidGlobalLinkage(Linkage)) {
         Errors() << "Disallowed linkage type: "
                  << PNaClABIProps::LinkageName(Linkage) << "\n";
+      }
       Tokens() << Space() << PNaClABIProps::LinkageName(Linkage);
     }
     CallingConv::ID CallingConv;
     if (!naclbitc::DecodeCallingConv(Values[1], CallingConv)) {
       Errors() << "Unknown calling convention value: " << Values[1] << "\n";
     } else if (PNaClABIProps::isValidCallingConv(CallingConv)) {
       if (CallingConv != CallingConv::C) {
         Tokens() << Space() << PNaClABIProps::CallingConvName(CallingConv);
       }
     } else {
@@ skipping 110 matching lines @@
     ObjDump.Error() << "Expected 1 top level block in bitcode: Found:"
                     << NumBlocksRead << "\n";
     ErrorsFound = true;
   }
 
   ObjDump.Flush();
   return ErrorsFound || Parser.GetNumErrors() > 0;
 }
 
 }