Convert Subzero's bitcode reader to generate ICE types.

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 28 matching lines @@
 using namespace llvm;
 
 namespace {
 
 // TODO(kschimpf) Remove error recovery once implementation complete.
 static cl::opt<bool> AllowErrorRecovery(
     "allow-pnacl-reader-error-recovery",
     cl::desc("Allow error recovery when reading PNaCl bitcode."),
     cl::init(false));
 
+// Models elements in the list of types defined in the types block.
+// These elements can be undefined, a (simple) type, or a function type
+// signature. Note that an extended type is undefined on construction.
+// Use methods setAsSimpleType and setAsFuncSigType to define
+// the extended type.
+class ExtendedType {
+  // ExtendedType(const ExtendedType &Ty) = delete;
+  ExtendedType &operator=(const ExtendedType &Ty) = delete;
+public:
+  /// Discriminator for LLVM-style RTTI.
+  enum TypeKind { Undefined, Simple, FuncSig };
+
+  ExtendedType() : Kind(Undefined) {}
+
+  virtual ~ExtendedType() {}
+
+  ExtendedType::TypeKind getKind() const { return Kind; }
+  void Dump(Ice::Ostream &Stream) const;
+
+  /// Changes the extended type to a simple type with the given
+  /// value.
+  void setAsSimpleType(Ice::Type Ty) {
+    assert(Kind == Undefined);
+    Kind = Simple;
+    Signature.setReturnType(Ty);
+  }
+
+  /// Changes the extended type to an (empty) function signature type.
+  void setAsFunctionType() {
+    assert(Kind == Undefined);
+    Kind = FuncSig;
+  }
+
+protected:
+  // Note: For simple types, the return type of the signature will
+  // be used to hold the simple type.
+  Ice::FuncSigType Signature;
+
+private:
+  ExtendedType::TypeKind Kind;
+};
+
+Ice::Ostream &operator<<(Ice::Ostream &Stream, const ExtendedType &Ty) {
+  Ty.Dump(Stream);
+  return Stream;
+}
+
+Ice::Ostream &operator<<(Ice::Ostream &Stream, ExtendedType::TypeKind Kind) {
+  Stream << "ExtendedType::";
+  switch (Kind) {
+  case ExtendedType::Undefined:
+    Stream << "Undefined";
+    break;
+  case ExtendedType::Simple:
+    Stream << "Simple";
+    break;
+  case ExtendedType::FuncSig:
+    Stream << "FuncSig";
+    break;
+  default:
+    Stream << "??";
+    break;
+  }
+  return Stream;
+}
+
+// Models an ICE type as an extended type.
+class SimpleExtendedType : public ExtendedType {
+  SimpleExtendedType(const SimpleExtendedType &) = delete;
+  SimpleExtendedType &operator=(const SimpleExtendedType &) = delete;
+public:
+  Ice::Type getType() const { return Signature.getReturnType(); }
+
+  static bool classof(const ExtendedType *Ty) {
+    return Ty->getKind() == Simple;
+  }
+};
+
+// Models a function signature as an extended type.
+class FuncSigExtendedType : public ExtendedType {
+  FuncSigExtendedType(const FuncSigExtendedType &) = delete;
+  FuncSigExtendedType &operator=(const FuncSigExtendedType &) = delete;
+public:
+  const Ice::FuncSigType &getSignature() const { return Signature; }
+  void setReturnType(Ice::Type ReturnType) {
+    Signature.setReturnType(ReturnType);
+  }
+  void appendArgType(Ice::Type ArgType) { Signature.appendArgType(ArgType); }
+  static bool classof(const ExtendedType *Ty) {
+    return Ty->getKind() == FuncSig;
+  }
+};
+
+void ExtendedType::Dump(Ice::Ostream &Stream) const {
+  Stream << Kind;
+  switch (Kind) {
+  case Simple: {
+    Stream << " " << Signature.getReturnType();
+    break;
+  }
+  case FuncSig: {
+    Stream << " " << Signature;
+  }
+  default:
+    break;
+  }
+}
+
 // 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:
   TopLevelParser(Ice::Translator &Translator, const std::string &InputName,
                  NaClBitcodeHeader &Header, NaClBitstreamCursor &Cursor,
                  bool &ErrorStatus)
       : NaClBitcodeParser(Cursor), Translator(Translator),
@@ skipping 30 matching lines @@
 
   /// 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.
-  Type *getTypeByID(unsigned ID) {
-    // Note: method resizeTypeIDValues expands TypeIDValues
-    // to the specified size, and fills elements with nullptr.
-    Type *Ty = ID < TypeIDValues.size() ? TypeIDValues[ID] : nullptr;
+  /// Returns the undefined type associated with type ID.
+  /// Note: Returns extended type ready to be defined.
+  ExtendedType *getTypeByIDForDefining(unsigned ID) {
+    // Get corresponding element, verifying the value is still undefined
+    // (and hence allowed to be defined).
+    ExtendedType *Ty = getTypeByIDAsKind(ID, ExtendedType::Undefined);
     if (Ty)
       return Ty;
-    return reportTypeIDAsUndefined(ID);
+    if (ID >= TypeIDValues.size())
+      TypeIDValues.resize(ID+1);
+    return &TypeIDValues[ID];
   }
 
-  /// Defines type for ID.
-  void setTypeID(unsigned ID, Type *Ty) {
-    if (ID < TypeIDValues.size() && TypeIDValues[ID] == nullptr) {
-      TypeIDValues[ID] = Ty;
-      return;
-    }
-    reportBadSetTypeID(ID, Ty);
+  /// Returns the type associated with the given index.
+  Ice::Type getSimpleTypeByID(unsigned ID) {
+    const ExtendedType *Ty = getTypeByIDAsKind(ID, ExtendedType::Simple);
+    if (Ty == nullptr)
+      // Return error recovery value.
+      return Ice::IceType_void;
+    return cast<SimpleExtendedType>(Ty)->getType();
+  }
+
+  /// Returns the type signature associated with the given index.
+  const Ice::FuncSigType &getFuncSigTypeByID(unsigned ID) {
+    const ExtendedType *Ty = getTypeByIDAsKind(ID, ExtendedType::FuncSig);
+    if (Ty == nullptr)
+      // Return error recovery value.
+      return UndefinedFuncSigType;
+    return cast<FuncSigExtendedType>(Ty)->getSignature();
   }
 
   /// Sets the next function ID to the given LLVM function.
   void setNextFunctionID(Function *Fcn) {
     ++NumFunctionIds;
     FunctionIDValues.push_back(Fcn);
   }
 
   /// Defines the next function ID as one that has an implementation
   /// (i.e a corresponding function block in the bitcode).
   void setNextValueIDAsImplementedFunction() {
     DefiningFunctionsList.push_back(FunctionIDValues.size());
   }
 
   /// Returns the value id that should be associated with the the
   /// current function block. Increments internal counters during call
   /// so that it will be in correct position for next function block.
   unsigned getNextFunctionBlockValueID() {
     if (NumFunctionBlocks >= DefiningFunctionsList.size())
       report_fatal_error(
           "More function blocks than defined function addresses");
     return DefiningFunctionsList[NumFunctionBlocks++];
   }
 
-  /// Returns the LLVM IR value associatd with the global value ID.
+  /// Returns the LLVM Function address associated with ID.
   Function *getFunctionByID(unsigned ID) const {
     if (ID >= FunctionIDValues.size())
       return nullptr;
     Value *V = FunctionIDValues[ID];
     return cast<Function>(V);
   }
 
   /// Returns the corresponding constant associated with a global value
   /// (i.e. relocatable).
   Ice::Constant *getOrCreateGlobalConstantByID(unsigned ID) {
@@ skipping 83 matching lines @@
       return convertToIceTypeError(LLVMTy);
     }
     return IceTy;
   }
 
   /// Returns the corresponding LLVM type for IceTy.
   Type *convertToLLVMType(Ice::Type IceTy) const {
     return TypeConverter.convertToLLVMType(IceTy);
   }
 
-  /// Returns the LLVM integer type with the given number of Bits.  If
-  /// Bits is not a valid PNaCl type, returns nullptr.
-  Type *getLLVMIntegerType(unsigned Bits) const {
-    return TypeConverter.getLLVMIntegerType(Bits);
-  }
-
-  /// Returns the LLVM vector with the given Size and Ty. If not a
-  /// valid PNaCl vector type, returns nullptr.
-  Type *getLLVMVectorType(unsigned Size, Ice::Type Ty) const {
-    return TypeConverter.getLLVMVectorType(Size, Ty);
-  }
-
   /// 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 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;
+  std::vector<ExtendedType> TypeIDValues;
   // The set of function value IDs.
   std::vector<WeakVH> FunctionIDValues;
   // The set of global addresses IDs.
   Ice::Translator::GlobalAddressList GlobalIDAddresses;
   // Relocatable constants associated with FunctionIDValues and
   // GlobalIDAddresses.
   std::vector<Ice::Constant *> ValueIDConstants;
   // The number of function IDs.
   unsigned NumFunctionIds;
   // The number of function blocks (processed so far).
   unsigned NumFunctionBlocks;
   // The list of value IDs (in the order found) of defining function
   // addresses.
   std::vector<unsigned> DefiningFunctionsList;
+  // Error recovery value to use when getFuncSigTypeByID fails.
+  Ice::FuncSigType UndefinedFuncSigType;
 
   bool ParseBlock(unsigned BlockID) override;
 
-  /// Reports that type ID is undefined, and then returns
-  /// the void type.
-  Type *reportTypeIDAsUndefined(unsigned ID);
+  // Gets extended type associated with the given index, assuming the
+  // extended type is of the WantedKind. Generates error message if
+  // corresponding extended type of WantedKind can't be found, and
+  // returns nullptr.
+  ExtendedType *getTypeByIDAsKind(unsigned ID,
+                                  ExtendedType::TypeKind WantedKind) {
+    ExtendedType *Ty = nullptr;
+    if (ID < TypeIDValues.size()) {
+      Ty = &TypeIDValues[ID];
+      if (Ty->getKind() == WantedKind)
+        return Ty;
+    }
+    // Generate an error message and set ErrorStatus.
+    this->reportBadTypeIDAs(ID, Ty, WantedKind);
+    return nullptr;
+  }
 
-  /// Reports error about bad call to setTypeID.
-  void reportBadSetTypeID(unsigned ID, Type *Ty);
+  // Reports that type ID is undefined, or not of the WantedType.
+  void reportBadTypeIDAs(unsigned ID, const ExtendedType *Ty,
+                         ExtendedType::TypeKind WantedType);
 
   // Reports that there is no corresponding ICE type for LLVMTy, and
   // returns ICE::IceType_void.
   Ice::Type convertToIceTypeError(Type *LLVMTy);
 };
 
-Type *TopLevelParser::reportTypeIDAsUndefined(unsigned ID) {
+void TopLevelParser::reportBadTypeIDAs(unsigned ID, const ExtendedType *Ty,
+                                       ExtendedType::TypeKind WantedType) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
-  StrBuf << "Can't find type for type id: " << ID;
-  Error(StrBuf.str());
-  // TODO(kschimpf) Remove error recovery once implementation complete.
-  Type *Ty = TypeConverter.convertToLLVMType(Ice::IceType_void);
-  // To reduce error messages, update type list if possible.
-  if (ID < TypeIDValues.size())
-    TypeIDValues[ID] = Ty;
-  return Ty;
-}
-
-void TopLevelParser::reportBadSetTypeID(unsigned ID, Type *Ty) {
-  std::string Buffer;
-  raw_string_ostream StrBuf(Buffer);
-  if (ID >= TypeIDValues.size()) {
-    StrBuf << "Type index " << ID << " out of range: can't install.";
+  if (Ty == nullptr) {
+    StrBuf << "Can't find extended type for type id: " << ID;
   } else {
-    // Must be case that index already defined.
-    StrBuf << "Type index " << ID << " defined as " << *TypeIDValues[ID]
-           << " and " << *Ty << ".";
+    StrBuf << "Type id " << ID << " not " << WantedType << ". Found: " << *Ty;
   }
   Error(StrBuf.str());
 }
 
 Ice::Type TopLevelParser::convertToIceTypeError(Type *LLVMTy) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Invalid LLVM type: " << *LLVMTy;
   Error(StrBuf.str());
   return Ice::IceType_void;
@@ skipping 136 matching lines @@
       : BlockParserBaseClass(BlockID, EnclosingParser), NextTypeId(0) {}
 
   ~TypesParser() override {}
 
 private:
   // The type ID that will be associated with the next type defining
   // record in the types block.
   unsigned NextTypeId;
 
   void ProcessRecord() override;
+
+  void setNextTypeIDAsSimpleType(Ice::Type Ty) {
+    Context->getTypeByIDForDefining(NextTypeId++)->setAsSimpleType(Ty);
+  }
 };
 
 void TypesParser::ProcessRecord() {
-  Type *Ty = nullptr;
   const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
   switch (Record.GetCode()) {
   case naclbitc::TYPE_CODE_NUMENTRY:
     // NUMENTRY: [numentries]
     if (!isValidRecordSize(1, "Type count"))
       return;
     Context->resizeTypeIDValues(Values[0]);
     return;
   case naclbitc::TYPE_CODE_VOID:
     // VOID
     if (!isValidRecordSize(0, "Type void"))
       return;
-    Ty = Context->convertToLLVMType(Ice::IceType_void);
-    break;
+    setNextTypeIDAsSimpleType(Ice::IceType_void);
+    return;
   case naclbitc::TYPE_CODE_FLOAT:
     // FLOAT
     if (!isValidRecordSize(0, "Type float"))
       return;
-    Ty = Context->convertToLLVMType(Ice::IceType_f32);
-    break;
+    setNextTypeIDAsSimpleType(Ice::IceType_f32);
+    return;
   case naclbitc::TYPE_CODE_DOUBLE:
     // DOUBLE
     if (!isValidRecordSize(0, "Type double"))
       return;
-    Ty = Context->convertToLLVMType(Ice::IceType_f64);
-    break;
+    setNextTypeIDAsSimpleType(Ice::IceType_f64);
+    return;
   case naclbitc::TYPE_CODE_INTEGER:
     // INTEGER: [width]
     if (!isValidRecordSize(1, "Type integer"))
       return;
-    Ty = Context->getLLVMIntegerType(Values[0]);
-    if (Ty == nullptr) {
+    switch (Values[0]) {
+    case 1:
+      setNextTypeIDAsSimpleType(Ice::IceType_i1);
+      return;
+    case 8:
+      setNextTypeIDAsSimpleType(Ice::IceType_i8);
+      return;
+    case 16:
+      setNextTypeIDAsSimpleType(Ice::IceType_i16);
+      return;
+    case 32:
+      setNextTypeIDAsSimpleType(Ice::IceType_i32);
+      return;
+    case 64:
+      setNextTypeIDAsSimpleType(Ice::IceType_i64);
+      return;
+    default:
+      break;
+    }
+    {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Type integer record with invalid bitsize: " << Values[0];
       Error(StrBuf.str());
-      // TODO(kschimpf) Remove error recovery once implementation complete.
-      // Fix type so that we can continue.
-      Ty = Context->convertToLLVMType(Ice::IceType_i32);
     }
-    break;
+    return;
   case naclbitc::TYPE_CODE_VECTOR: {
     // VECTOR: [numelts, eltty]
     if (!isValidRecordSize(2, "Type vector"))
       return;
-    Type *BaseTy = Context->getTypeByID(Values[1]);
-    Ty = Context->getLLVMVectorType(Values[0],
-                                    Context->convertToIceType(BaseTy));
-    if (Ty == nullptr) {
+    Ice::Type BaseTy = Context->getSimpleTypeByID(Values[1]);
+    Ice::SizeT Size = Values[0];
+    switch (BaseTy) {
+    case Ice::IceType_i1:
+      switch (Size) {
+      case 4:
+        setNextTypeIDAsSimpleType(Ice::IceType_v4i1);
+        return;
+      case 8:
+        setNextTypeIDAsSimpleType(Ice::IceType_v8i1);
+        return;
+      case 16:
+        setNextTypeIDAsSimpleType(Ice::IceType_v16i1);
+        return;
+      default:
+        break;
+      }
+      break;
+    case Ice::IceType_i8:
+      if (Size == 16) {
+        setNextTypeIDAsSimpleType(Ice::IceType_v16i8);
+        return;
+      }
+      break;
+    case Ice::IceType_i16:
+      if (Size == 8) {
+        setNextTypeIDAsSimpleType(Ice::IceType_v8i16);
+        return;
+      }
+      break;
+    case Ice::IceType_i32:
+      if (Size == 4) {
+        setNextTypeIDAsSimpleType(Ice::IceType_v4i32);
+        return;
+      }
+      break;
+    case Ice::IceType_f32:
+      if (Size == 4) {
+        setNextTypeIDAsSimpleType(Ice::IceType_v4f32);
+        return;
+      }
+      break;
+    default:
+      break;
+    }
+    {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
-      StrBuf << "Invalid type vector record: <" << Values[0] << " x " << *BaseTy
+      StrBuf << "Invalid type vector record: <" << Values[0] << " x " << BaseTy
              << ">";
       Error(StrBuf.str());
-      Ty = Context->convertToLLVMType(Ice::IceType_void);
     }
-    break;
+    return;
   }
   case naclbitc::TYPE_CODE_FUNCTION: {
     // FUNCTION: [vararg, retty, paramty x N]
     if (!isValidRecordSizeAtLeast(2, "Type signature"))
       return;
-    SmallVector<Type *, 8> ArgTys;
+    if (Values[0])
+      Error("Function type can't define varargs");
+    ExtendedType *Ty = Context->getTypeByIDForDefining(NextTypeId++);
+    Ty->setAsFunctionType();
+    FuncSigExtendedType *FuncTy = cast<FuncSigExtendedType>(Ty);
+    FuncTy->setReturnType(Context->getSimpleTypeByID(Values[1]));
     for (unsigned i = 2, e = Values.size(); i != e; ++i) {
-      ArgTys.push_back(Context->getTypeByID(Values[i]));
+      // Check that type void not used as argument type.
+      // Note: PNaCl restrictions can't be checked until we
+      // know the name, because we have to check for intrinsic signatures.
+      Ice::Type ArgTy = Context->getSimpleTypeByID(Values[i]);
+      if (ArgTy == Ice::IceType_void) {
+        std::string Buffer;
+        raw_string_ostream StrBuf(Buffer);
+        StrBuf << "Type for parameter " << (i - 1)
+               << " not valid. Found: " << ArgTy;
+        // TODO(kschimpf) Remove error recovery once implementation complete.
+        ArgTy = Ice::IceType_i32;
+      }
+      FuncTy->appendArgType(ArgTy);
     }
-    Ty = FunctionType::get(Context->getTypeByID(Values[1]), ArgTys, Values[0]);
-    break;
+    return;
   }
   default:
     BlockParserBaseClass::ProcessRecord();
     return;
   }
-  // If Ty not defined, assume error. Use void as filler.
-  if (Ty == nullptr)
-    Ty = Context->convertToLLVMType(Ice::IceType_void);
-  Context->setTypeID(NextTypeId++, Ty);
+  llvm_unreachable("Unknown type block record not processed!");
 }
 
 /// Parses the globals block (i.e. global variables).
 class GlobalsParser : public BlockParserBaseClass {
 public:
   GlobalsParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : BlockParserBaseClass(BlockID, EnclosingParser), InitializersNeeded(0),
         NextGlobalID(0), CurrentAddress(&DummyAddress) {}
 
   ~GlobalsParser() override {}
@@ skipping 844 matching lines @@
       return;
     CurrentNode->appendInst(Ice::InstArithmetic::create(
         Func, Opcode, getNextInstVar(Type1), Op1, Op2));
     break;
   }
   case naclbitc::FUNC_CODE_INST_CAST: {
     // CAST: [opval, destty, castopc]
     if (!isValidRecordSize(3, "function block cast"))
       return;
     Ice::Operand *Src = getRelativeOperand(Values[0], BaseIndex);
-    Type *CastType = Context->getTypeByID(Values[1]);
+    Ice::Type CastType = Context->getSimpleTypeByID(Values[1]);
     Instruction::CastOps LLVMCastOp;
     Ice::InstCast::OpKind CastKind;
     if (!naclbitc::DecodeCastOpcode(Values[2], LLVMCastOp) ||
         !convertLLVMCastOpToIceOp(LLVMCastOp, CastKind)) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Cast opcode not understood: " << Values[2];
       Error(StrBuf.str());
       return;
     }
-    Type *SrcType = Context->convertToLLVMType(Src->getType());
-    if (!CastInst::castIsValid(LLVMCastOp, SrcType, CastType)) {
+    Ice::Type SrcType = Src->getType();
+    if (!CastInst::castIsValid(LLVMCastOp, Context->convertToLLVMType(SrcType),
+                               Context->convertToLLVMType(CastType))) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Illegal cast: " << Instruction::getOpcodeName(LLVMCastOp)
-             << " " << *SrcType << " to " << *CastType;
+             << " " << SrcType << " to " << CastType;
       Error(StrBuf.str());
       return;
     }
-    CurrentNode->appendInst(Ice::InstCast::create(
-        Func, CastKind, getNextInstVar(Context->convertToIceType(CastType)),
-        Src));
+    CurrentNode->appendInst(
+        Ice::InstCast::create(Func, CastKind, getNextInstVar(CastType), Src));
     break;
   }
   case naclbitc::FUNC_CODE_INST_VSELECT: {
     // VSELECT: [opval, opval, pred]
     Ice::Operand *ThenVal = getRelativeOperand(Values[0], BaseIndex);
     Ice::Type ThenType = ThenVal->getType();
     Ice::Operand *ElseVal = getRelativeOperand(Values[1], BaseIndex);
     Ice::Type ElseType = ElseVal->getType();
     if (ThenType != ElseType) {
       std::string Buffer;
@@ skipping 199 matching lines @@
     // SWITCH: [Condty, Cond, BbIndex, NumCases Case ...]
     // where Case = [1, 1, Value, BbIndex].
     //
     // Note: Unlike most instructions, we don't infer the type of
     // Cond, but provide it as a separate field. There are also
     // unnecesary data fields (i.e. constants 1).  These were not
     // cleaned up in PNaCl bitcode because the bitcode format was
     // already frozen when the problem was noticed.
     if (!isValidRecordSizeAtLeast(4, "function block switch"))
       return;
-    Ice::Type CondTy =
-        Context->convertToIceType(Context->getTypeByID(Values[0]));
+    Ice::Type CondTy = Context->getSimpleTypeByID(Values[0]);
     if (!Ice::isScalarIntegerType(CondTy)) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Case condition must be non-wide integer. Found: " << CondTy;
       Error(StrBuf.str());
       return;
     }
     Ice::SizeT BitWidth = Ice::getScalarIntBitWidth(CondTy);
     Ice::Operand *Cond = getRelativeOperand(Values[1], BaseIndex);
     if (CondTy != Cond->getType()) {
@@ skipping 47 matching lines @@
     if (!isValidRecordSizeAtLeast(3, "function block phi"))
       return;
     if ((Values.size() & 0x1) == 0) {
       // Not an odd number of values.
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "function block phi record size not valid: " << Values.size();
       Error(StrBuf.str());
       return;
     }
-    Ice::Type Ty = Context->convertToIceType(Context->getTypeByID(Values[0]));
+    Ice::Type Ty = Context->getSimpleTypeByID(Values[0]);
     if (Ty == Ice::IceType_void) {
       Error("Phi record using type void not allowed");
       return;
     }
     Ice::Variable *Dest = getNextInstVar(Ty);
     Ice::InstPhi *Phi = Ice::InstPhi::create(Func, Values.size() >> 1, Dest);
     for (unsigned i = 1; i < Values.size(); i += 2) {
       Ice::Operand *Op =
           getRelativeOperand(NaClDecodeSignRotatedValue(Values[i]), BaseIndex);
       if (Op->getType() != Ty) {
@@ skipping 30 matching lines @@
   }
   case naclbitc::FUNC_CODE_INST_LOAD: {
     // LOAD: [address, align, ty]
     if (!isValidRecordSize(3, "function block load"))
       return;
     Ice::Operand *Address = getRelativeOperand(Values[0], BaseIndex);
     if (!isValidPointerType(Address, "Load"))
       return;
     unsigned Alignment;
     extractAlignment("Load", Values[1], Alignment);
-    Ice::Type Ty = Context->convertToIceType(Context->getTypeByID(Values[2]));
+    Ice::Type Ty = Context->getSimpleTypeByID(Values[2]);
     if (!isValidLoadStoreAlignment(Alignment, Ty, "Load"))
       return;
     CurrentNode->appendInst(
         Ice::InstLoad::create(Func, getNextInstVar(Ty), Address, Alignment));
     break;
   }
   case naclbitc::FUNC_CODE_INST_STORE: {
     // STORE: [address, value, align]
     if (!isValidRecordSize(3, "function block store"))
       return;
@@ skipping 71 matching lines @@
             getTranslator().getContext()->getIntrinsicsInfo().find(Suffix);
         if (!IntrinsicInfo) {
           std::string Buffer;
           raw_string_ostream StrBuf(Buffer);
           StrBuf << "Invalid PNaCl intrinsic call to " << Name;
           Error(StrBuf.str());
           return;
         }
       }
     } else {
-      ReturnType = Context->convertToIceType(Context->getTypeByID(Values[2]));
+      ReturnType = Context->getSimpleTypeByID(Values[2]);
     }
 
     // Create the call instruction.
     Ice::Variable *Dest = (ReturnType == Ice::IceType_void)
                               ? nullptr
                               : getNextInstVar(ReturnType);
     Ice::SizeT NumParams = Values.size() - ParamsStartIndex;
     Ice::InstCall *Inst = nullptr;
     if (IntrinsicInfo) {
       Inst =
@@ skipping 51 matching lines @@
       }
     }
 
     CurrentNode->appendInst(Inst);
     return;
   }
   case naclbitc::FUNC_CODE_INST_FORWARDTYPEREF: {
     // FORWARDTYPEREF: [opval, ty]
     if (!isValidRecordSize(2, "function block forward type ref"))
       return;
-    setOperand(Values[0], createInstVar(Context->convertToIceType(
-                              Context->getTypeByID(Values[1]))));
+    setOperand(Values[0], createInstVar(Context->getSimpleTypeByID(Values[1])));
     break;
   }
   default:
     // Generate error message!
     BlockParserBaseClass::ProcessRecord();
     break;
   }
 }
 
 /// Parses constants within a function block.
@@ skipping 28 matching lines @@
   }
 };
 
 void ConstantsParser::ProcessRecord() {
   const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
   switch (Record.GetCode()) {
   case naclbitc::CST_CODE_SETTYPE: {
     // SETTYPE: [typeid]
     if (!isValidRecordSize(1, "constants block set type"))
       return;
-    NextConstantType =
-        Context->convertToIceType(Context->getTypeByID(Values[0]));
+    NextConstantType = Context->getSimpleTypeByID(Values[0]);
     if (NextConstantType == Ice::IceType_void)
       Error("constants block set type not allowed for void type");
     return;
   }
   case naclbitc::CST_CODE_UNDEF: {
     // UNDEF
     if (!isValidRecordSize(0, "constants block undef"))
       return;
     if (!isValidNextConstantType())
       return;
@@ skipping 273 matching lines @@
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Unknown bitstream version: " << Version;
       Error(StrBuf.str());
     }
     return;
   }
   case naclbitc::MODULE_CODE_FUNCTION: {
     // FUNCTION:  [type, callingconv, isproto, linkage]
     if (!isValidRecordSize(4, "Function heading"))
       return;
-    Type *Ty = Context->getTypeByID(Values[0]);
-    FunctionType *FTy = dyn_cast<FunctionType>(Ty);
-    if (FTy == nullptr) {
-      std::string Buffer;
-      raw_string_ostream StrBuf(Buffer);
-      StrBuf << "Function heading expects function type. Found: " << Ty;
-      Error(StrBuf.str());
-      return;
-    }
+    const Ice::FuncSigType &Ty = Context->getFuncSigTypeByID(Values[0]);
     CallingConv::ID CallingConv;
     if (!naclbitc::DecodeCallingConv(Values[1], CallingConv)) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Function heading has unknown calling convention: "
              << Values[1];
       Error(StrBuf.str());
       return;
     }
     GlobalValue::LinkageTypes Linkage;
     if (!naclbitc::DecodeLinkage(Values[3], Linkage)) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Function heading has unknown linkage. Found " << Values[3];
       Error(StrBuf.str());
       return;
     }
-    Function *Func = Function::Create(FTy, Linkage, "", Context->getModule());
+    SmallVector<Type *, 8> ArgTys;
+    for (Ice::Type ArgType : Ty.getArgList()) {
+      ArgTys.push_back(Context->convertToLLVMType(ArgType));
+    }
+    Function *Func = Function::Create(
+        FunctionType::get(Context->convertToLLVMType(Ty.getReturnType()),
+                          ArgTys, false),
+        Linkage, "", Context->getModule());
     Func->setCallingConv(CallingConv);
     if (Values[2] == 0)
       Context->setNextValueIDAsImplementedFunction();
     Context->setNextFunctionID(Func);
     // TODO(kschimpf) verify if Func matches PNaCl ABI.
     return;
   }
   default:
     BlockParserBaseClass::ProcessRecord();
     return;
@@ skipping 58 matching lines @@
 
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus = true;
   }
 }
 
 } // end of namespace Ice