Add check to verify alignment on global variables.

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.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 334 matching lines @@
   /// ownership of the current list of global variables. Note: only returns
   /// non-null pointer on first call. All successive calls return a null
   /// pointer.
   std::unique_ptr<Ice::VariableDeclarationList> getGlobalVariables() {
     // Before returning, check that ValidIDConstants has already been built.
     assert(!VariableDeclarations ||
            VariableDeclarations->size() <= ValueIDConstants.size());
     return std::move(VariableDeclarations);
   }
 
+  // Upper limit of alignment power allowed by LLVM
+  static constexpr uint32_t AlignPowerLimit = 29;
+
+  // Extracts the corresponding Alignment to use, given the AlignPower (i.e.
+  // 2**(AlignPower-1), or 0 if AlignPower == 0). Parser defines the block
+  // context the alignment check appears in, and Prefix defines the context the
+  // alignment appears in.
+  uint32_t extractAlignment(NaClBitcodeParser *Parser, const char *Prefix,
+                            uint32_t AlignPower) {
+    if (AlignPower <= AlignPowerLimit + 1)
+      return (1 << AlignPower) >> 1;
+    std::string Buffer;
+    raw_string_ostream StrBuf(Buffer);
+    StrBuf << Prefix << " alignment greater than 2**" << AlignPowerLimit
+           << ". Found: 2**" << (AlignPower - 1);
+    Parser->Error(StrBuf.str());
+    // Error recover with value that is always acceptable.
+    return 1;
+  }
+
 private:
   // The translator associated with the parser.
   Ice::Translator &Translator;
   // The exit status that should be set to true if an error occurs.
   Ice::ErrorCode &ErrorStatus;
   // The number of errors reported.
   unsigned NumErrors = 0;
   // The types associated with each type ID.
   std::vector<ExtendedType> TypeIDValues;
   // The set of functions (prototype and defined).
@@ skipping 689 matching lines @@
     SpecifiedNumberVars = Values[0];
     return;
   case naclbitc::GLOBALVAR_VAR: {
     // VAR: [align, isconst]
     if (!isValidRecordSize(2, "variable"))
       return;
     verifyNoMissingInitializers();
     // Always build the global variable, even if IR generation is turned off.
     // This is needed because we need a placeholder in the top-level context
     // when no IR is generated.
+    uint32_t Alignment =
+        Context->extractAlignment(this, "Global variable", Values[0]);
     CurGlobalVar = getGlobalVarByID(NextGlobalID);
     if (!isIRGenerationDisabled()) {
       InitializersNeeded = 1;
-      CurGlobalVar->setAlignment((1 << Values[0]) >> 1);
+      CurGlobalVar->setAlignment(Alignment);
       CurGlobalVar->setIsConstant(Values[1] != 0);
     }
     ++NextGlobalID;
     return;
   }
   case naclbitc::GLOBALVAR_COMPOUND:
     // COMPOUND: [size]
     if (!isValidRecordSize(1, "compound"))
       return;
     if (!CurGlobalVar->getInitializers().empty()) {
@@ skipping 296 matching lines @@
   // Holds the dividing point between local and global absolute value indices.
   size_t CachedNumGlobalValueIDs;
   // Holds operands local to the function block, based on indices defined in
   // the bitcode file.
   Ice::OperandList LocalOperands;
   // Holds the index within LocalOperands corresponding to the next instruction
   // that generates a value.
   NaClBcIndexSize_t NextLocalInstIndex;
   // True if the last processed instruction was a terminating instruction.
   bool InstIsTerminating = false;
-  // Upper limit of alignment power allowed by LLVM
-  static const uint32_t AlignPowerLimit = 29;
-
-  // Extracts the corresponding Alignment to use, given the AlignPower (i.e.
-  // 2**(AlignPower-1), or 0 if AlignPower == 0). InstName is the name of the
-  // instruction the alignment appears in.
-  void extractAlignment(const char *InstName, uint32_t AlignPower,
-                        uint32_t &Alignment) {
-    if (AlignPower <= AlignPowerLimit + 1) {
-      Alignment = (1 << AlignPower) >> 1;
-      return;
-    }
-    std::string Buffer;
-    raw_string_ostream StrBuf(Buffer);
-    StrBuf << InstName << " alignment greater than 2**" << AlignPowerLimit
-           << ". Found: 2**" << (AlignPower - 1);
-    Error(StrBuf.str());
-    // Error recover with value that is always acceptable.
-    Alignment = 1;
-  }
 
   bool ParseBlock(unsigned BlockID) override;
 
   void ProcessRecord() override;
 
   void EnterBlock(unsigned NumWords) final {
     // Note: Bitstream defines words as 32-bit values.
     NumBytesDefiningFunction = NumWords * sizeof(uint32_t);
     // We know that all records are minimally defined by a two-bit abreviation.
     MaxRecordsInBlock = NumBytesDefiningFunction * (CHAR_BIT >> 1);
@@ skipping 1171 matching lines @@
       Phi->addArgument(Op, getBasicBlock(Values[i + 1]));
     }
     CurrentNode->appendInst(Phi);
     return;
   }
   case naclbitc::FUNC_CODE_INST_ALLOCA: {
     // ALLOCA: [Size, align]
     if (!isValidRecordSize(2, "alloca"))
       return;
     Ice::Operand *ByteCount = getRelativeOperand(Values[0], BaseIndex);
-    uint32_t Alignment;
-    extractAlignment("Alloca", Values[1], Alignment);
+    uint32_t Alignment = Context->extractAlignment(this, "Alloca", Values[1]);
     if (isIRGenerationDisabled()) {
       assert(ByteCount == nullptr);
       setNextLocalInstIndex(nullptr);
       return;
     }
     Ice::Type PtrTy = Ice::getPointerType();
     if (ByteCount->getType() != Ice::IceType_i32) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Alloca on non-i32 value. Found: " << *ByteCount;
       Error(StrBuf.str());
       appendErrorInstruction(PtrTy);
       return;
     }
     CurrentNode->appendInst(Ice::InstAlloca::create(
         Func.get(), ByteCount, Alignment, getNextInstVar(PtrTy)));
     return;
   }
   case naclbitc::FUNC_CODE_INST_LOAD: {
     // LOAD: [address, align, ty]
     if (!isValidRecordSize(3, "load"))
       return;
     Ice::Operand *Address = getRelativeOperand(Values[0], BaseIndex);
     Ice::Type Ty = Context->getSimpleTypeByID(Values[2]);
-    uint32_t Alignment;
-    extractAlignment("Load", Values[1], Alignment);
+    uint32_t Alignment = Context->extractAlignment(this, "Load", Values[1]);
     if (isIRGenerationDisabled()) {
       assert(Address == nullptr);
       setNextLocalInstIndex(nullptr);
       return;
     }
     if (!isValidPointerType(Address, "Load")) {
       appendErrorInstruction(Ty);
       return;
     }
     if (!isValidLoadStoreAlignment(Alignment, Ty, "Load")) {
       appendErrorInstruction(Ty);
       return;
     }
     CurrentNode->appendInst(Ice::InstLoad::create(
         Func.get(), getNextInstVar(Ty), Address, Alignment));
     return;
   }
   case naclbitc::FUNC_CODE_INST_STORE: {
     // STORE: [address, value, align]
     if (!isValidRecordSize(3, "store"))
       return;
     Ice::Operand *Address = getRelativeOperand(Values[0], BaseIndex);
     Ice::Operand *Value = getRelativeOperand(Values[1], BaseIndex);
-    uint32_t Alignment;
-    extractAlignment("Store", Values[2], Alignment);
+    uint32_t Alignment = Context->extractAlignment(this, "Store", Values[2]);
     if (isIRGenerationDisabled()) {
       assert(Address == nullptr && Value == nullptr);
       return;
     }
     if (!isValidPointerType(Address, "Store"))
       return;
     if (!isValidLoadStoreAlignment(Alignment, Value->getType(), "Store"))
       return;
     CurrentNode->appendInst(
         Ice::InstStore::create(Func.get(), Value, Address, Alignment));
@@ skipping 624 matching lines @@
     raw_string_ostream StrBuf(Buffer);
     StrBuf << IRFilename << ": Does not contain a module!";
     llvm::report_fatal_error(StrBuf.str());
   }
   if (InputStreamFile.getBitcodeBytes().getExtent() % 4 != 0) {
     llvm::report_fatal_error("Bitcode stream should be a multiple of 4 bytes");
   }
 }
 
 } // end of namespace Ice