Remove TypeConverter and Module from minimal subzero build.

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 "llvm/ADT/SmallString.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/LLVMContext.h"
-#include "llvm/IR/Module.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include "IceAPInt.h"
 #include "IceAPFloat.h"
 #include "IceCfg.h"
 #include "IceCfgNode.h"
 #include "IceClFlags.h"
 #include "IceDefs.h"
 #include "IceGlobalInits.h"
 #include "IceInst.h"
 #include "IceOperand.h"
-#include "IceTypeConverter.h"
 #include "PNaClTranslator.h"
 
 #include <memory>
 
 namespace {
 using namespace llvm;
 
 // TODO(kschimpf) Remove error recovery once implementation complete.
 static cl::opt<bool> AllowErrorRecovery(
     "allow-pnacl-reader-error-recovery",
@@ skipping 117 matching lines @@
 class BlockParserBaseClass;
 
 // Top-level class to read PNaCl bitcode files, and translate to ICE.
 class TopLevelParser : public NaClBitcodeParser {
   TopLevelParser(const TopLevelParser &) = delete;
   TopLevelParser &operator=(const TopLevelParser &) = delete;
 
 public:
   typedef std::vector<Ice::FunctionDeclaration *> FunctionDeclarationListType;
 
-  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(Mod->getContext()), ErrorStatus(ErrorStatus),
-        NumErrors(0), NumFunctionIds(0), NumFunctionBlocks(0),
-        BlockParser(nullptr) {
+  TopLevelParser(Ice::Translator &Translator, NaClBitcodeHeader &Header,
+                 NaClBitstreamCursor &Cursor, bool &ErrorStatus)
+      : NaClBitcodeParser(Cursor), Translator(Translator), Header(Header),
+        ErrorStatus(ErrorStatus), NumErrors(0), NumFunctionIds(0),
+        NumFunctionBlocks(0), BlockParser(nullptr) {
     setErrStream(Translator.getContext()->getStrDump());
   }
 
   ~TopLevelParser() override {}
 
   Ice::Translator &getTranslator() { return Translator; }
 
   void setBlockParser(BlockParserBaseClass *NewBlockParser) {
     BlockParser = NewBlockParser;
   }
 
   // Generates error with given Message. Always returns true.
   bool Error(const std::string &Message) override;
 
   // Generates error message with respect to the current block parser.
   bool BlockError(const std::string &Message);
 
   /// 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(); }
-
   /// Returns the number of bytes in the bitcode header.
   size_t getHeaderSize() const { return Header.getHeaderSize(); }
 
   /// Changes the size of the type list to the given size.
   void resizeTypeIDValues(unsigned NewSize) { TypeIDValues.resize(NewSize); }
 
   /// Returns true if generation of Subzero IR is disabled.
   bool isIRGenerationDisabled() const {
     return ALLOW_DISABLE_IR_GEN ? Translator.getFlags().DisableIRGeneration
                                 : false;
@@ skipping 155 matching lines @@
       return getFunctionByID(Index);
     else
       return getGlobalVariableByID(Index - NumFunctionIds);
   }
 
   /// Returns the list of parsed global variable declarations.
   const Ice::Translator::VariableDeclarationListType &getGlobalVariables() {
     return VariableDeclarations;
   }
 
-  /// Returns the corresponding ICE type for LLVMTy.
-  Ice::Type convertToIceType(Type *LLVMTy) {
-    Ice::Type IceTy = TypeConverter.convertToIceType(LLVMTy);
-    if (IceTy >= Ice::IceType_NUM) {
-      return convertToIceTypeError(LLVMTy);
-    }
-    return IceTy;
-  }
-
-  /// Returns the corresponding LLVM type for IceTy.
-  Type *convertToLLVMType(Ice::Type IceTy) const {
-    return TypeConverter.convertToLLVMType(IceTy);
-  }
-
-  /// 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.
-  std::unique_ptr<Module> Mod;
   // 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<ExtendedType> TypeIDValues;
   // The set of functions.
   FunctionDeclarationListType FunctionDeclarationList;
   // The set of global variables.
   Ice::Translator::VariableDeclarationListType VariableDeclarations;
@@ skipping 982 matching lines @@
     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();
+    Ice::Type PtrType = Ice::getPointerType();
     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;
   }
 
@@ skipping 937 matching lines @@
     if (!isValidRecordSize(2, "alloca"))
       return;
     Ice::Operand *ByteCount = getRelativeOperand(Values[0], BaseIndex);
     uint32_t Alignment;
     extractAlignment("Alloca", Values[1], Alignment);
     if (isIRGenerationDisabled()) {
       assert(ByteCount == nullptr);
       setNextLocalInstIndex(nullptr);
       return;
     }
-    Ice::Type PtrTy = Context->getIcePointerType();
+    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, ByteCount, Alignment,
                                                     getNextInstVar(PtrTy)));
@@ skipping 269 matching lines @@
   case naclbitc::CST_CODE_INTEGER: {
     // INTEGER: [intval]
     if (!isValidRecordSize(1, "integer"))
       return;
     if (!isValidNextConstantType())
       return;
     if (isIRGenerationDisabled()) {
       FuncParser->setNextConstantID(nullptr);
       return;
     }
-    if (auto IType = dyn_cast<IntegerType>(
-            Context->convertToLLVMType(NextConstantType))) {
-      Ice::APInt Value(IType->getBitWidth(),
+    if (Ice::isScalarIntegerType(NextConstantType)) {
+      Ice::APInt Value(Ice::getScalarIntBitWidth(NextConstantType),
                        NaClDecodeSignRotatedValue(Values[0]));
       if (Ice::Constant *C = getContext()->getConstantInt(
               NextConstantType, Value.getSExtValue())) {
         FuncParser->setNextConstantID(C);
         return;
       }
     }
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << "constant block integer record for non-integer type "
@@ skipping 344 matching lines @@
   if (Header.Read(BufPtr, EndBufPtr) || !Header.IsSupported()) {
     errs() << "Invalid PNaCl bitcode header.\n";
     ErrorStatus = true;
     return;
   }
 
   // Create a bitstream reader to read the bitcode file.
   NaClBitstreamReader InputStreamFile(BufPtr, EndBufPtr);
   NaClBitstreamCursor InputStream(InputStreamFile);
 
-  TopLevelParser Parser(*this, MemBuf->getBufferIdentifier(), Header,
-                        InputStream, ErrorStatus);
+  TopLevelParser Parser(*this, Header, InputStream, ErrorStatus);
   int TopLevelBlocks = 0;
   while (!InputStream.AtEndOfStream()) {
     if (Parser.Parse()) {
       ErrorStatus = true;
       return;
     }
     ++TopLevelBlocks;
   }
 
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus = true;
   }
 }
 
 } // end of namespace Ice