Add load and store instructions 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
 // translator.
 //
 //===----------------------------------------------------------------------===//
 
 #include "PNaClTranslator.h"
 #include "IceCfg.h"
 #include "IceCfgNode.h"
 #include "IceClFlags.h"
 #include "IceDefs.h"
 #include "IceInst.h"
 #include "IceOperand.h"
 #include "IceTypeConverter.h"
+#include "llvm/Analysis/NaCl/PNaClABIProps.h"
 #include "llvm/Bitcode/NaCl/NaClBitcodeDecoders.h"
 #include "llvm/Bitcode/NaCl/NaClBitcodeHeader.h"
 #include "llvm/Bitcode/NaCl/NaClBitcodeParser.h"
 #include "llvm/Bitcode/NaCl/NaClReaderWriter.h"
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/DataLayout.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/ValueHandle.h"
 
 #include <vector>
 #include <cassert>
 
@@ skipping 10 matching lines @@
 // Top-level class to read PNaCl bitcode files, and translate to ICE.
 class TopLevelParser : public NaClBitcodeParser {
   TopLevelParser(const TopLevelParser &) LLVM_DELETED_FUNCTION;
   TopLevelParser &operator=(const TopLevelParser &) LLVM_DELETED_FUNCTION;
 
 public:
   TopLevelParser(Ice::Translator &Translator, const std::string &InputName,
                  NaClBitcodeHeader &Header, NaClBitstreamCursor &Cursor,
                  bool &ErrorStatus)
       : NaClBitcodeParser(Cursor), Translator(Translator),
-        Mod(new Module(InputName, getGlobalContext())), Header(Header),
-        TypeConverter(getLLVMContext()), ErrorStatus(ErrorStatus), NumErrors(0),
-        NumFunctionIds(0), NumFunctionBlocks(0),
+        Mod(new Module(InputName, getGlobalContext())), DL(PNaClDataLayout),
+        Header(Header), TypeConverter(getLLVMContext()),
+        ErrorStatus(ErrorStatus), NumErrors(0), NumFunctionIds(0),
+        NumFunctionBlocks(0),
         GlobalVarPlaceHolderType(convertToLLVMType(Ice::IceType_i8)) {
     Mod->setDataLayout(PNaClDataLayout);
   }
 
   virtual ~TopLevelParser() {}
   LLVM_OVERRIDE;
 
   Ice::Translator &getTranslator() { return Translator; }
 
   // Generates error with given Message. Always returns true.
   virtual bool Error(const std::string &Message) LLVM_OVERRIDE {
     ErrorStatus = true;
     ++NumErrors;
     NaClBitcodeParser::Error(Message);
     if (!AllowErrorRecovery)
       report_fatal_error("Unable to continue");
     return true;
   }
 
   /// Returns the number of errors found while parsing the bitcode
   /// file.
   unsigned getNumErrors() const { return NumErrors; }
 
   /// Returns the LLVM module associated with the translation.
   Module *getModule() const { return Mod.get(); }
 
+  const DataLayout &getDataLayout() const { return DL; }
+
   /// Returns the number of bytes in the bitcode header.
   size_t getHeaderSize() const { return Header.getHeaderSize(); }
 
   /// Returns the llvm context to use.
   LLVMContext &getLLVMContext() const { return Mod->getContext(); }
 
   /// Changes the size of the type list to the given size.
   void resizeTypeIDValues(unsigned NewSize) { TypeIDValues.resize(NewSize); }
 
   /// Returns the type associated with the given index.
@@ skipping 124 matching lines @@
   /// Returns the model for pointer types in ICE.
   Ice::Type getIcePointerType() const {
     return TypeConverter.getIcePointerType();
   }
 
 private:
   // The translator associated with the parser.
   Ice::Translator &Translator;
   // The parsed module.
   OwningPtr<Module> Mod;
+  // The data layout to use.
+  DataLayout DL;
   // The bitcode header.
   NaClBitcodeHeader &Header;
   // Converter between LLVM and ICE types.
   Ice::TypeConverter TypeConverter;
   // The exit status that should be set to true if an error occurs.
   bool &ErrorStatus;
   // The number of errors reported.
   unsigned NumErrors;
   // The types associated with each type ID.
   std::vector<Type *> TypeIDValues;
@@ skipping 600 matching lines @@
   // 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;
 
+  // Extracts the corresponding Alignment to use, given the AlignPower
+  // (i.e. 2**AlignPower, or 0 if AlignPower == 0). InstName is the
+  // name of the instruction the alignment appears in.
+  void extractAlignment(const char *InstName, uint64_t AlignPower,
+                        unsigned &Alignment) {
+    if (AlignPower <= AlignPowerLimit) {
+      Alignment = (1 << static_cast<unsigned>(AlignPower)) >> 1;
+      return;
+    }
+    std::string Buffer;
+    raw_string_ostream StrBuf(Buffer);
+    StrBuf << InstName << " alignment greater than 2**" << AlignPowerLimit
+           << ". Found: 2**" << AlignPower;
+    Error(StrBuf.str());
+    // Error recover with value that is always acceptable.
+    Alignment = 1;
+  }
+
   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(); }
 
   // Returns the Index-th basic block in the list of basic blocks.
@@ skipping 91 matching lines @@
   // OpTy, is valid.  Returns true if valid. Otherwise generates
   // error message and returns false.
   bool isValidIntegerArithOp(Ice::InstArithmetic::OpKind Op, Ice::Type OpTy) {
     if (Ice::isIntegerArithmeticType(OpTy))
       return true;
     ReportInvalidBinaryOp(Op, OpTy);
     return false;
   }
 
   // Checks if floating arithmetic Op, for type OpTy, is valid.
-  // Returns false if valid. Otherwise generates an error message and
-  // returns true.
+  // Returns true if valid. Otherwise generates an error message and
+  // returns false;
   bool isValidFloatingArithOp(Ice::InstArithmetic::OpKind Op, Ice::Type OpTy) {
     if (Ice::isFloatingType(OpTy))
       return true;
     ReportInvalidBinaryOp(Op, OpTy);
     return false;
   }
 
+  // Checks if the type of operand Op is the valid pointer type, for
+  // the given InstructionName. Returns true if valid. Otherwise
+  // generates an error message and returns false.
+  bool isValidPointerType(Ice::Operand *Op, const char *InstructionName) {
+    Ice::Type PtrType = Context->getIcePointerType();
+    if (Op->getType() == PtrType)
+      return true;
+    std::string Buffer;
+    raw_string_ostream StrBuf(Buffer);
+    StrBuf << InstructionName << " address not " << PtrType
+           << ". Found: " << Op;
+    Error(StrBuf.str());
+    return false;
+  }
+
+  // Checks if loading/storing a value of type Ty is allowed.
+  // Returns true if Valid. Otherwise generates an error message and
+  // returns false.
+  bool isValidLoadStoreType(Ice::Type Ty, const char *InstructionName) {
+    if (isLoadStoreType(Ty))
+      return true;
+    std::string Buffer;
+    raw_string_ostream StrBuf(Buffer);
+    StrBuf << InstructionName << " type not allowed: " << Ty << "*";
+    Error(StrBuf.str());
+    return false;
+  }
+
+  // Checks if loading/storing a value of type Ty is allowed for
+  // the given Alignment. Otherwise generates an error message and
+  // returns false.
+  bool isValidLoadStoreAlignment(unsigned Alignment, Ice::Type Ty,
+                                 const char *InstructionName) {
+    if (!isValidLoadStoreType(Ty, InstructionName))
+      return false;
+    if (PNaClABIProps::isAllowedAlignment(&Context->getDataLayout(), Alignment,
+                                          Context->convertToLLVMType(Ty)))
+      return true;
+    std::string Buffer;
+    raw_string_ostream StrBuf(Buffer);
+    StrBuf << InstructionName << " " << Ty << "*: not allowed for alignment "
+           << Alignment;
+    Error(StrBuf.str());
+    return false;
+  }
+
   // Reports that the given binary Opcode, for the given type Ty,
   // is not understood.
   void ReportInvalidBinopOpcode(unsigned Opcode, Ice::Type Ty);
 
   // Takes the PNaCl bitcode binary operator Opcode, and the opcode
   // type Ty, and sets Op to the corresponding ICE binary
   // opcode. Returns true if able to convert, false otherwise.
   bool convertBinopOpcode(unsigned Opcode, Ice::Type Ty,
                           Ice::InstArithmetic::OpKind &Op) {
     Instruction::BinaryOps LLVMOpcode;
@@ skipping 541 matching lines @@
     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.
-    }
+    unsigned Alignment;
+    extractAlignment("Alloca", Values[1], Alignment);
     Ice::Variable *Dest = NextInstVar(Context->getIcePointerType());
     Inst = Ice::InstAlloca::create(Func, ByteCount, Alignment, Dest);
     break;
   }
+  case naclbitc::FUNC_CODE_INST_LOAD: {
+    // LOAD: [address, align, ty]
+    if (!isValidRecordSize(3, "function block load"))
+      return;
+    Ice::Operand *Address = getRelativeOperand(Values[0]);
+    if (!isValidPointerType(Address, "Load"))
+      return;
+    unsigned Alignment;
+    extractAlignment("Load", Values[1], Alignment);
+    Ice::Type Ty = Context->convertToIceType(Context->getTypeByID(Values[2]));
+    if (!isValidLoadStoreAlignment(Alignment, Ty, "Load"))
+      return;
+    Ice::Variable *Dest = NextInstVar(Ty);
+    Inst = Ice::InstLoad::create(Func, Dest, Address, Alignment);
+    break;
+  }
+  case naclbitc::FUNC_CODE_INST_STORE: {
+    // STORE: [address, value, align]
+    if (!isValidRecordSize(3, "function block store"))
+      return;
+    Ice::Operand *Address = getRelativeOperand(Values[0]);
+    if (!isValidPointerType(Address, "Store"))
+      return;
+    Ice::Operand *Value = getRelativeOperand(Values[1]);
+    unsigned Alignment;
+    if (!extractAlignment("Store", Values[2], Alignment)) {
+      // TODO(kschimpf) Remove error recovery once implementation complete.
+      Alignment = 1;
+    }
+    if (!isValidLoadStoreAlignment(Alignment, Value->getType(), "Store"))
+      return;
+    Inst = Ice::InstStore::create(Func, Value, Address, Alignment);
+    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