Add FunctionType ctor variant that takes SmallVector params.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@47895 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/DerivedTypes.h

@@ -19,6 +19,7 @@
 #define LLVM_DERIVED_TYPES_H
 
 #include "llvm/Type.h"
+#include "llvm/ADT/SmallVector.h"
 
 namespace llvm {
 
@@ -144,6 +145,8 @@ class FunctionType : public DerivedType {
   const FunctionType &operator=(const FunctionType &);  // Do not implement
   FunctionType(const Type *Result, const std::vector<const Type*> &Params,
                bool IsVarArgs);
+  FunctionType(const Type *Result, const SmallVectorImpl<const Type*> &Params,
+               bool IsVarArgs);
 
 public:
   /// FunctionType::get - This static method is the primary way of constructing
@@ -155,6 +158,12 @@ public:
     bool isVarArg  ///< Whether this is a variable argument length function
   );
 
+  static FunctionType *get(
+    const Type *Result, ///< The result type
+    const SmallVectorImpl<const Type*> &Params, ///< The types of the parameters
+    bool isVarArg  ///< Whether this is a variable argument length function
+  );
+
   inline bool isVarArg() const { return isVarArgs; }
   inline const Type *getReturnType() const { return ContainedTys[0]; }
 

lib/VMCore/Type.cpp

@@ -460,6 +460,30 @@ FunctionType::FunctionType(const Type *Result,
   setAbstract(isAbstract);
 }
 
+FunctionType::FunctionType(const Type *Result,
+                           const SmallVectorImpl<const Type *> &Params,
+                           bool IsVarArgs)
+  : DerivedType(FunctionTyID), isVarArgs(IsVarArgs) {
+  ContainedTys = reinterpret_cast<PATypeHandle*>(this+1);
+  NumContainedTys = Params.size() + 1; // + 1 for result type
+  assert((Result->isFirstClassType() || Result == Type::VoidTy ||
+          Result->getTypeID() == Type::StructTyID ||
+          isa<OpaqueType>(Result)) &&
+         "LLVM functions cannot return aggregates");
+  bool isAbstract = Result->isAbstract();
+  new (&ContainedTys[0]) PATypeHandle(Result, this);
+
+  for (unsigned i = 0; i != Params.size(); ++i) {
+    assert((Params[i]->isFirstClassType() || isa<OpaqueType>(Params[i])) &&
+           "Function arguments must be value types!");
+    new (&ContainedTys[i+1]) PATypeHandle(Params[i],this);
+    isAbstract |= Params[i]->isAbstract();
+  }
+
+  // Calculate whether or not this type is abstract
+  setAbstract(isAbstract);
+}
+
 StructType::StructType(const std::vector<const Type*> &Types, bool isPacked)
   : CompositeType(StructTyID) {
   ContainedTys = reinterpret_cast<PATypeHandle*>(this + 1);
@@ -1055,6 +1079,12 @@ public:
       ArgTypes.push_back(args[i]);
   }
 
+  FunctionValType(const Type *ret, const SmallVectorImpl<const Type*> &args,
+                  bool isVA) : RetTy(ret), isVarArg(isVA) {
+    for (unsigned i = 0; i < args.size(); ++i)
+      ArgTypes.push_back(args[i]);
+  }
+
   static FunctionValType get(const FunctionType *FT);
 
   static unsigned hashTypeStructure(const FunctionType *FT) {
@@ -1108,6 +1138,27 @@ FunctionType *FunctionType::get(const Type *ReturnType,
   return FT;
 }
 
+// FunctionType::get - The factory function for the FunctionType class...
+FunctionType *FunctionType::get(const Type *ReturnType,
+                                const SmallVectorImpl<const Type*> &Params,
+                                bool isVarArg) {
+  FunctionValType VT(ReturnType, Params, isVarArg);
+  FunctionType *FT = FunctionTypes->get(VT);
+  if (FT) { 
+    return FT;
+  }
+
+  FT = (FunctionType*) new char[sizeof(FunctionType) + 
+                                sizeof(PATypeHandle)*(Params.size()+1)];
+  new (FT) FunctionType(ReturnType, Params, isVarArg);
+  FunctionTypes->add(VT, FT);
+
+#ifdef DEBUG_MERGE_TYPES
+  DOUT << "Derived new type: " << FT << "\n";
+#endif
+  return FT;
+}
+
 //===----------------------------------------------------------------------===//
 // Array Type Factory...
 //