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

lib/Bitcode/NaCl/Reader/NaClBitcodeReader.h

 //===- NaClBitcodeReader.h ------------------------------------*- C++ -*-===//
 //     Internal NaClBitcodeReader implementation
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This header defines the NaClBitcodeReader class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef NACL_BITCODE_READER_H
 #define NACL_BITCODE_READER_H
 
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/Analysis/NaCl/PNaClABIProps.h"
 #include "llvm/Analysis/NaCl/PNaClAllowedIntrinsics.h"
 #include "llvm/Bitcode/NaCl/NaClBitcodeHeader.h"
 #include "llvm/Bitcode/NaCl/NaClBitstreamReader.h"
 #include "llvm/Bitcode/NaCl/NaClLLVMBitCodes.h"
 #include "llvm/Bitcode/NaCl/NaClReaderWriter.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/GVMaterializer.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/OperandTraits.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/ValueHandle.h"
+#include "llvm/Support/raw_ostream.h"
 #include <vector>
 
 namespace llvm {
   class MemoryBuffer;
   class LLVMContext;
   class CastInst;
 
 // Models a Cast.  Used to cache casts created in a basic block by the
 // PNaCl bitcode reader.
 struct NaClBitcodeReaderCast {
@@ skipping 201 matching lines @@
     return std::error_code(E, BitcodeErrorCategory());
   }
 
   /// Generates the corresponding verbose Message, then generates error.
   std::error_code Error(ErrorType E, const std::string &Message) const;
 
   /// @brief Main interface to parsing a bitcode buffer.
   /// @returns true if an error occurred.
   std::error_code ParseBitcodeInto(Module *M);
 
+  /// 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 corresponding error code.
+  std::error_code getAlignmentValue(uint64_t Exponent, unsigned &Alignment);
+
 private:
   // Returns false if Header is acceptable.
   bool AcceptHeader() const {
     return !(Header.IsSupported() ||
              (!AcceptSupportedBitcodeOnly && Header.IsReadable()));
   }
   uint32_t GetPNaClVersion() const {
     return Header.GetPNaClVersion();
   }
   Type *getTypeByID(unsigned ID);
@@ skipping 32 matching lines @@
   /// getValueSigned -- Like getValue, but decodes signed VBRs.
   Value *getValueSigned(const SmallVector<uint64_t, 64> &Record, unsigned Slot,
                         unsigned InstNum) {
     if (Slot == Record.size()) return 0;
     // ValNo is encoded relative to the InstNum.
     unsigned ValNo = InstNum -
         (unsigned) NaClDecodeSignRotatedValue(Record[Slot]);
     return getFnValueByID(ValNo);
   }
 
+  /// Convert alignment exponent (i.e. power of two (or zero)) to the
+  /// corresponding load/store alignment to use. If alignment is not
+  /// allowed for the load/store, it generates an error message and
+  /// returns the corresponding error code.
+  std::error_code getLoadStoreAlignmentValue(
+      uint64_t Exponent, const DataLayout *DL, Type *MemType,
+      const char *InstName, unsigned &Alignment) {
+    std::error_code EC = getAlignmentValue(Exponent, Alignment);
+    if (EC)
+      return EC;
+    if (!PNaClABIProps::isAllowedAlignment(DL, Alignment, MemType)) {
+      std::string Buffer;
+      raw_string_ostream StrBuf(Buffer);
+      StrBuf << "Invalid alignment for " << InstName << " of type "
+             << *MemType << ": " << Alignment;
+      return Error(InvalidValue, StrBuf.str());
+    }
+    // Successful!
+    return EC;
+  }
+
   /// \brief Create an (elided) cast instruction for basic block
   /// BBIndex.  Op is the type of cast.  V is the value to cast.  CT
   /// is the type to convert V to.  DeferInsertion defines whether the
   /// generated conversion should also be installed into basic block
   /// BBIndex.  Note: For PHI nodes, we don't insert when created
   /// (i.e. DeferInsertion=true), since they must be inserted at the end
   /// of the corresponding incoming basic block.
   CastInst *CreateCast(unsigned BBIndex, Instruction::CastOps Op,
                        Type *CT, Value *V, bool DeferInsertion = false);
 
@@ skipping 31 matching lines @@
   std::error_code InitStreamFromBuffer();
   std::error_code InitLazyStream();
   std::error_code FindFunctionInStream(
       Function *F,
       DenseMap<Function*, uint64_t>::iterator DeferredFunctionInfoIterator);
 };
 
 } // End llvm namespace
 
 #endif