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

lib/Bitcode/NaCl/Reader/NaClBitcodeReader.cpp

 //===- NaClBitcodeReader.cpp ----------------------------------------------===//
 //     Internal NaClBitcodeReader implementation
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ skipping 159 matching lines @@
   // named struct.  Just create a placeholder for now.
   return TypeList[ID] = StructType::create(Context);
 }
 
 
 //===----------------------------------------------------------------------===//
 //  Functions for parsing blocks from the bitcode file
 //===----------------------------------------------------------------------===//
 
 
+namespace {
+
+static const unsigned MaxAlignmentExponent = 29;
+static_assert(
+    (1u << MaxAlignmentExponent) == Value::MaximumAlignment,
+    "Inconsistency between Value.MaxAlignment and PNaCl alignment limit");
+}
+
 std::error_code NaClBitcodeReader::Error(ErrorType E,
                                          const std::string &Message) const {
-  if (Verbose)
-    *Verbose << "Error: " << Message << "\n";
+  if (Verbose) {
+    uint64_t Bit = Stream.GetCurrentBitNo();
+    *Verbose << "Error: (" <<  (Bit / CHAR_BIT) << ":"
+             << static_cast<unsigned>(Bit % CHAR_BIT)
+             << ") " << Message << "\n";
+  }
   return Error(E);
 }
 
+std::error_code NaClBitcodeReader::getAlignmentValue(
+    uint64_t Exponent, unsigned &Alignment) {
+  if (Exponent > MaxAlignmentExponent + 1) {
+    std::string Buffer;
+    raw_string_ostream StrBuf(Buffer);
+    StrBuf << "Alignment can't be greater than 2**" << MaxAlignmentExponent
+           << ". Found: 2**" << (Exponent - 1);
+    return Error(InvalidValue, StrBuf.str());
+  }
+  Alignment = (1 << static_cast<unsigned>(Exponent)) >> 1;
+  return std::error_code();
+}
+
 std::error_code NaClBitcodeReader::ParseTypeTable() {
   DEBUG(dbgs() << "-> ParseTypeTable\n");
   if (Stream.EnterSubBlock(naclbitc::TYPE_BLOCK_ID_NEW))
     return Error(InvalidRecord, "Malformed block record");
 
   std::error_code result = ParseTypeTableBody();
   if (!result)
     DEBUG(dbgs() << "<- ParseTypeTable\n");
   return result;
 }
@@ skipping 198 matching lines @@
       switch (Bitcode) {
       default:
         return Reader.Error(NaClBitcodeReader::InvalidValue,
                             "Unknown global variable entry");
       case naclbitc::GLOBALVAR_VAR:
         // Start the definition of a global variable.
         if (ProcessingGlobal || Record.size() != 2)
           return Reader.Error(NaClBitcodeReader::InvalidRecord,
                               "Bad GLOBALVAR_VAR record");
         ProcessingGlobal = true;
-        VarAlignment = (1 << Record[0]) >> 1;
+        if (std::error_code EC =
+            Reader.getAlignmentValue(Record[0], VarAlignment))
+          return EC;
         VarIsConstant = Record[1] != 0;
         // Assume (by default) there is a single initializer.
         VarInitializersNeeded = 1;
         break;
       case naclbitc::GLOBALVAR_COMPOUND:
         // Global variable has multiple initializers. Changes the
         // default number of initializers to the given value in
         // Record[0].
         if (!ProcessingGlobal || !VarType.empty() ||
             VarInitializersNeeded != 1 || Record.size() != 1)
@@ skipping 1057 matching lines @@
       break;
     }
 
     case naclbitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [op, align]
       if (Record.size() != 2)
         return Error(InvalidRecord, "Invalid ALLOCA record");
       Value *Size;
       unsigned OpNum = 0;
       if (popValue(Record, &OpNum, NextValueNo, &Size))
         return Error(InvalidRecord, "Invalid ALLOCA record");
-      unsigned Align = Record[1];
-      I = new AllocaInst(Type::getInt8Ty(Context), Size, (1 << Align) >> 1);
+      unsigned Alignment;
+      if (std::error_code EC = getAlignmentValue(Record[1], Alignment))
+        return EC;
+      I = new AllocaInst(Type::getInt8Ty(Context), Size, Alignment);
       break;
     }
     case naclbitc::FUNC_CODE_INST_LOAD: {
       // LOAD: [op, align, ty]
       unsigned OpNum = 0;
       Value *Op;
       if (popValue(Record, &OpNum, NextValueNo, &Op) ||
           Record.size() != 3)
         return Error(InvalidRecord, "Invalid LOAD record");
 
       // Add pointer cast to op.
       Type *T = getTypeByID(Record[2]);
       if (T == nullptr)
         return Error(InvalidType, "Invalid type for load instruction");
       Op = ConvertOpToType(Op, T->getPointerTo(), CurBBNo);
       if (Op == nullptr)
         return Error(InvalidTypeForValue, "Can't convert cast to type");
-      I = new LoadInst(Op, "", false, (1 << Record[OpNum]) >> 1);
+      unsigned Alignment;
+      if (std::error_code EC = getAlignmentValue(Record[OpNum], Alignment))
+        return EC;
+      I = new LoadInst(Op, "", false, Alignment);
       break;
     }
     case naclbitc::FUNC_CODE_INST_STORE: {
       // STORE: [ptr, val, align]
       unsigned OpNum = 0;
       Value *Val, *Ptr;
       if (popValue(Record, &OpNum, NextValueNo, &Ptr) ||
           popValue(Record, &OpNum, NextValueNo, &Val) ||
           OpNum+1 != Record.size())
         return Error(InvalidRecord, "Invalid STORE record");
       Val = ConvertOpToScalar(Val, CurBBNo);
       Ptr = ConvertOpToType(Ptr, Val->getType()->getPointerTo(), CurBBNo);
       if (Ptr == nullptr)
         return Error(InvalidTypeForValue, "Can't convert cast to type");
-      I = new StoreInst(Val, Ptr, false, (1 << Record[OpNum]) >> 1);
+      unsigned Alignment;
+      if (std::error_code EC = getAlignmentValue(Record[OpNum], Alignment))
+       return EC;
+      I = new StoreInst(Val, Ptr, false, Alignment);
       break;
     }
     case naclbitc::FUNC_CODE_INST_CALL:
     case naclbitc::FUNC_CODE_INST_CALL_INDIRECT: {
       // CALL: [cc, fnid, arg0, arg1...]
       // CALL_INDIRECT: [cc, fnid, returnty, args...]
       if ((Record.size() < 2) ||
           (BitCode == naclbitc::FUNC_CODE_INST_CALL_INDIRECT &&
            Record.size() < 3))
         return Error(InvalidRecord, "Invalid CALL record");
@@ skipping 369 matching lines @@
       Materializer->releaseBuffer();
     delete M;
     return EC;
   }
 
   // TODO: Restore the use-lists to the in-memory state when the bitcode was
   // written.  We must defer until the Module has been fully materialized.
 
   return M;
 }