Add alloca instruction to Subzero bitcode reader.

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 827 matching lines @@
   // The corresponding LLVM function.
   Function *LLVMFunc;
   // Holds operands local to the function block, based on indices
   // defined in the bitcode file.
   std::vector<Ice::Operand *> LocalOperands;
   // Holds the dividing point between local and global absolute value indices.
   uint32_t CachedNumGlobalValueIDs;
   // True if the last processed instruction was a terminating
   // instruction.
   bool InstIsTerminating;
+  // Upper limit of alignment power allowed by LLVM
+  static const uint64_t AlignPowerLimit = 29;
 
   virtual bool ParseBlock(unsigned BlockID) LLVM_OVERRIDE;
 
   virtual void ProcessRecord() LLVM_OVERRIDE;
 
   virtual void ExitBlock() LLVM_OVERRIDE;
 
   // Creates and appends a new basic block to the list of basic blocks.
   Ice::CfgNode *InstallNextBasicBlock() { return Func->makeNode(); }
 
@@ skipping 650 matching lines @@
       }
       Ice::CfgNode *ThenBlock = getBranchBasicBlock(Values[0]);
       Ice::CfgNode *ElseBlock = getBranchBasicBlock(Values[1]);
       if (ThenBlock == NULL || ElseBlock == NULL)
         return;
       Inst = Ice::InstBr::create(Func, Cond, ThenBlock, ElseBlock);
     }
     InstIsTerminating = true;
     break;
   }
+  case naclbitc::FUNC_CODE_INST_ALLOCA: {
+    // ALLOCA: [Size, align]
+    if (!isValidRecordSize(2, "function block alloca"))
+      return;
+    Ice::Operand *ByteCount = getRelativeOperand(Values[0]);
+    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());
+      return;
+    }
+    uint64_t AlignPower = Values[1];
+    unsigned Alignment = 1;
+    if (AlignPower <= AlignPowerLimit) {
+      Alignment = (1 << static_cast<unsigned>(AlignPower)) >> 1;
+    } else {
+      std::string Buffer;
+      raw_string_ostream StrBuf(Buffer);
+      StrBuf << "Alloca on alignment greater than 2**" << AlignPowerLimit
+             << ". Found: 2**" << AlignPower;
+      Error(StrBuf.str());
+      // TODO(kschimpf) Remove error recovery once implementation complete.
+    }
+    Ice::Variable *Dest = NextInstVar(Context->getIcePointerType());
+    Inst = Ice::InstAlloca::create(Func, ByteCount, Alignment, Dest);
+    break;
+  }
   default:
     // Generate error message!
     BlockParserBaseClass::ProcessRecord();
     break;
   }
   if (Inst)
     CurrentNode->appendInst(Inst);
 }
 
 /// Parses constants within a function block.
@@ skipping 278 matching lines @@
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus = true;
   }
   return;
 }
 
 } // end of namespace Ice