Convert Subzero's bitcode reader to generate ICE types.

src/IceTypes.h

 //===- subzero/src/IceTypes.h - Primitive ICE types -------------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares a few properties of the primitive types allowed
@@ skipping 85 matching lines @@
   assert(result || Ty == IceType_f64);
   return result;
 }
 
 template <typename StreamType>
 inline StreamType &operator<<(StreamType &Str, const Type &Ty) {
   Str << typeString(Ty);
   return Str;
 }
 
+/// Models a type signature for a function.

[Jim Stichnoth, 2014/10/05 15:35:47]

IceIntrinsics uses something similar to this for intrinsic signature validation.
 The main difference is that it uses an explicit array and length instead of a
vector (which may be necessary for static initialization?).  Is it practical to
switch IceIntrinsics to use this class?

[Karl, 2014/10/06 21:15:54]

After looking at this some more, it appears that we don't want to change the way
intrinsic signatures are represented to maintain POD representation.

Currently, we don't ever compare signatures accross these two models. So I
suggest that we don't worry about this till it becomes an issue. If it does, I
believe that a simple template compare function can be introduced.

+class FcnSigType {

[Jim Stichnoth, 2014/10/05 15:35:47]

A little bikeshedding here... Most of the code base (thanks to me, I know) uses
"Func" as an abbreviation for Function, it would be good to keep that
consistent.

[Karl, 2014/10/06 21:15:54]

Renamed to FuncSigType.

+  FcnSigType(const FcnSigType&) = delete;
+  FcnSigType &operator=(const FcnSigType&) = delete;
+public:
+  typedef std::vector<Type> ArgListType;
+
+  // Creates a function signature type with the given return type.
+  // Parameter types should be added using calls to appendArgType.
+  explicit FcnSigType(Ice::Type ReturnType) : ReturnType(ReturnType) {}

[Jim Stichnoth, 2014/10/05 15:35:47]

drop the Ice::

[Karl, 2014/10/06 21:15:54]

Done.

+
+  void appendArgType(Type ArgType) { ArgList.push_back(ArgType); }
+
+  Type getReturnType() const { return ReturnType; }
+  SizeT getNumArgs() const { return ArgList.size(); }
+  Type getArgType(SizeT Index) const {
+    assert(Index < ArgList.size());
+    return ArgList[Index];
+  }
+  const ArgListType &getArgList() const { return ArgList; }
+  void Print(Ostream &Stream) const;

[Jim Stichnoth, 2014/10/05 15:35:47]

For consistency with the other dump routines:

  void dump(Ostream &Str) const;

[Karl, 2014/10/06 21:15:54]

Done.

+
+private:
+  // The return type.
+  Type ReturnType;
+  // The list of parameters.
+  ArgListType ArgList;
+};
+
+inline Ostream &operator<<(Ostream &Stream, const FcnSigType &Sig) {
+  Sig.Print(Stream);
+  return Stream;
+}
+
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETYPES_H