improve the APIs for creating struct and function types with no arguments/elements

to not have to create a temporary vector (in the API at least).  Patch by Jay Foad!

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

diff --git a/examples/ModuleMaker/ModuleMaker.cpp b/examples/ModuleMaker/ModuleMaker.cpp
index 154e24065c0a82cef9b0a5fadb932d97f0e6671b..e2584e7ff34dd57198960502f2108aca3e19b7e9 100644 (file)
--- a/examples/ModuleMaker/ModuleMaker.cpp
+++ b/examples/ModuleMaker/ModuleMaker.cpp
@@ -27,8 +27,7 @@ int main() {
   Module *M = new Module("test");
 
   // Create the main function: first create the type 'int ()'
-  FunctionType *FT = FunctionType::get(Type::Int32Ty, std::vector<const Type*>(),
-                                       /*not vararg*/false);
+  FunctionType *FT = FunctionType::get(Type::Int32Ty, /*not vararg*/false);
 
   // By passing a module as the last parameter to the Function constructor,
   // it automatically gets appended to the Module.

diff --git a/include/llvm/DerivedTypes.h b/include/llvm/DerivedTypes.h
index b5824f8f81563dad80a7cd783c76c8c8349e96ee..053091b86fe16be30787c410c56ed2de53538666 100644 (file)
--- a/include/llvm/DerivedTypes.h
+++ b/include/llvm/DerivedTypes.h
@@ -159,6 +159,15 @@ public:
     bool isVarArg  ///< Whether this is a variable argument length function
   );
 
+  /// FunctionType::get - Create a FunctionType taking no parameters.
+  ///
+  static FunctionType *get(
+    const Type *Result, ///< The result type
+    bool isVarArg  ///< Whether this is a variable argument length function
+  ) {
+    return get(Result, std::vector<const Type *>(), isVarArg);
+  }
+
   /// isValidReturnType - Return true if the specified type is valid as a return
   /// type.
   static bool isValidReturnType(const Type *RetTy);
@@ -234,6 +243,12 @@ public:
   static StructType *get(const std::vector<const Type*> &Params,
                          bool isPacked=false);
 
+  /// StructType::get - Create an empty structure type.
+  ///
+  static StructType *get(bool isPacked=false) {
+    return get(std::vector<const Type*>(), isPacked);
+  }
+
   /// StructType::get - This static method is a convenience method for
   /// creating structure types by specifying the elements as arguments.
   /// Note that this method always returns a non-packed struct.  To get

diff --git a/include/llvm/Support/TypeBuilder.h b/include/llvm/Support/TypeBuilder.h
index 5198c8173998893d1a6401185c62941509abd3f9..b0ae516b815c969c285499702aa602885738961c 100644 (file)
--- a/include/llvm/Support/TypeBuilder.h
+++ b/include/llvm/Support/TypeBuilder.h
@@ -253,8 +253,7 @@ public:
 
 private:
   static const FunctionType *create() {
-    std::vector<const Type*> params;
-    return FunctionType::get(TypeBuilder<R, cross>::get(), params, false);
+    return FunctionType::get(TypeBuilder<R, cross>::get(), false);
   }
 };
 template<typename R, typename A1, bool cross> class TypeBuilder<R(A1), cross> {
@@ -360,8 +359,7 @@ public:
 
 private:
   static const FunctionType *create() {
-    std::vector<const Type*> params;
-    return FunctionType::get(TypeBuilder<R, cross>::get(), params, true);
+    return FunctionType::get(TypeBuilder<R, cross>::get(), true);
   }
 };
 template<typename R, typename A1, bool cross>

diff --git a/lib/Analysis/DebugInfo.cpp b/lib/Analysis/DebugInfo.cpp
index 6b27cf41624f1b427913cb7d3818e93943b823e3..dbc3ae8a9788ba89e05049ef0b6be6cf4e5f67f0 100644 (file)
--- a/lib/Analysis/DebugInfo.cpp
+++ b/lib/Analysis/DebugInfo.cpp
@@ -327,7 +327,7 @@ bool DISubprogram::describes(const Function *F) {
 DIFactory::DIFactory(Module &m)
   : M(m), StopPointFn(0), FuncStartFn(0), RegionStartFn(0), RegionEndFn(0),
     DeclareFn(0) {
-  EmptyStructPtr = PointerType::getUnqual(StructType::get(NULL, NULL));
+  EmptyStructPtr = PointerType::getUnqual(StructType::get());
 }
 
 /// getCastToEmpty - Return this descriptor as a Constant* with type '{}*'.

diff --git a/lib/AsmParser/LLParser.cpp b/lib/AsmParser/LLParser.cpp
index 909370cb669dca3916da9d861aeef08c35b28562..83ed401ef4be09c479803f8c293c7abedeed6021 100644 (file)
--- a/lib/AsmParser/LLParser.cpp
+++ b/lib/AsmParser/LLParser.cpp
@@ -1244,7 +1244,7 @@ bool LLParser::ParseStructType(PATypeHolder &Result, bool Packed) {
   Lex.Lex(); // Consume the '{'
   
   if (EatIfPresent(lltok::rbrace)) {
-    Result = StructType::get(std::vector<const Type*>(), Packed);
+    Result = StructType::get(Packed);
     return false;
   }
 

diff --git a/lib/Debugger/ProgramInfo.cpp b/lib/Debugger/ProgramInfo.cpp
index 125ff556dd50057bd8c7008313dcaf53df59c7e5..e58b3d58e6d1ccc43723817319e6c3bd9f7bef29 100644 (file)
--- a/lib/Debugger/ProgramInfo.cpp
+++ b/lib/Debugger/ProgramInfo.cpp
@@ -271,8 +271,7 @@ ProgramInfo::getSourceFiles(bool RequiresCompleteMap) {
   // should be on the use list of the llvm.dbg.translation_units global.
   //
   GlobalVariable *Units =
-    M->getGlobalVariable("llvm.dbg.translation_units",
-                         StructType::get(std::vector<const Type*>()));
+    M->getGlobalVariable("llvm.dbg.translation_units", StructType::get());
   if (Units == 0)
     throw "Program contains no debugging information!";
 
@@ -354,8 +353,7 @@ ProgramInfo::getSourceFunctions(bool RequiresCompleteMap) {
   // should be on the use list of the llvm.dbg.translation_units global.
   //
   GlobalVariable *Units =
-    M->getGlobalVariable("llvm.dbg.globals",
-                         StructType::get(std::vector<const Type*>()));
+    M->getGlobalVariable("llvm.dbg.globals", StructType::get());
   if (Units == 0)
     throw "Program contains no debugging information!";
 

diff --git a/lib/ExecutionEngine/JIT/JIT.cpp b/lib/ExecutionEngine/JIT/JIT.cpp
index db5a306badc472131f68b3a9f35116edb0e69ac9..1d8312f76298a699b60affda9e1a0eda2f974b0d 100644 (file)
--- a/lib/ExecutionEngine/JIT/JIT.cpp
+++ b/lib/ExecutionEngine/JIT/JIT.cpp
@@ -453,7 +453,7 @@ GenericValue JIT::runFunction(Function *F,
   // arguments.  Make this function and return.
 
   // First, create the function.
-  FunctionType *STy=FunctionType::get(RetTy, std::vector<const Type*>(), false);
+  FunctionType *STy=FunctionType::get(RetTy, false);
   Function *Stub = Function::Create(STy, Function::InternalLinkage, "",
                                     F->getParent());
 

diff --git a/lib/Transforms/IPO/GlobalOpt.cpp b/lib/Transforms/IPO/GlobalOpt.cpp
index cbf3a1d827a97090898c661c0f9bd9923122322f..7fe097c7c5763505fee9d4cf6bc31c26828aac0a 100644 (file)
--- a/lib/Transforms/IPO/GlobalOpt.cpp
+++ b/lib/Transforms/IPO/GlobalOpt.cpp
@@ -1928,8 +1928,7 @@ static GlobalVariable *InstallGlobalCtors(GlobalVariable *GCL,
     if (Ctors[i]) {
       CSVals[1] = Ctors[i];
     } else {
-      const Type *FTy = FunctionType::get(Type::VoidTy,
-                                          std::vector<const Type*>(), false);
+      const Type *FTy = FunctionType::get(Type::VoidTy, false);
       const PointerType *PFTy = PointerType::getUnqual(FTy);
       CSVals[1] = Constant::getNullValue(PFTy);
       CSVals[0] = ConstantInt::get(Type::Int32Ty, 2147483647);

diff --git a/lib/Transforms/IPO/RaiseAllocations.cpp b/lib/Transforms/IPO/RaiseAllocations.cpp
index 8c97b5d17c08fcfa741519250d8369f5a24d5c86..99003689fb1f52b225152f53b02cf66ebb997a25 100644 (file)
--- a/lib/Transforms/IPO/RaiseAllocations.cpp
+++ b/lib/Transforms/IPO/RaiseAllocations.cpp
@@ -92,8 +92,7 @@ void RaiseAllocations::doInitialization(Module &M) {
         // i8*(...) * malloc
         // This handles the common declaration of: 'void *malloc();'
         const FunctionType *Malloc3Type = 
-          FunctionType::get(PointerType::getUnqual(Type::Int8Ty),
-                            std::vector<const Type*>(), true);
+          FunctionType::get(PointerType::getUnqual(Type::Int8Ty), true);
         if (TyWeHave != Malloc3Type)
           // Give up
           MallocFunc = 0;
@@ -113,14 +112,12 @@ void RaiseAllocations::doInitialization(Module &M) {
       // Check to see if the prototype was forgotten, giving us 
       // void (...) * free
       // This handles the common forward declaration of: 'void free();'
-      const FunctionType* Free2Type = FunctionType::get(Type::VoidTy, 
-        std::vector<const Type*>(),true);
+      const FunctionType* Free2Type = FunctionType::get(Type::VoidTy, true);
 
       if (TyWeHave != Free2Type) {
         // One last try, check to see if we can find free as 
         // int (...)* free.  This handles the case where NOTHING was declared.
-        const FunctionType* Free3Type = FunctionType::get(Type::Int32Ty, 
-          std::vector<const Type*>(),true);
+        const FunctionType* Free3Type = FunctionType::get(Type::Int32Ty, true);
         
         if (TyWeHave != Free3Type) {
           // Give up.

diff --git a/lib/Transforms/Utils/LowerAllocations.cpp b/lib/Transforms/Utils/LowerAllocations.cpp
index 9af47f56ef3d831ff41b34461fcb0c71f22b2cb8..74e7028d127cb9697b3c73d46bc5e249edf192d2 100644 (file)
--- a/lib/Transforms/Utils/LowerAllocations.cpp
+++ b/lib/Transforms/Utils/LowerAllocations.cpp
@@ -89,7 +89,7 @@ bool LowerAllocations::doInitialization(Module &M) {
   const Type *BPTy = PointerType::getUnqual(Type::Int8Ty);
   // Prototype malloc as "char* malloc(...)", because we don't know in
   // doInitialization whether size_t is int or long.
-  FunctionType *FT = FunctionType::get(BPTy, std::vector<const Type*>(), true);
+  FunctionType *FT = FunctionType::get(BPTy, true);
   MallocFunc = M.getOrInsertFunction("malloc", FT);
   FreeFunc = M.getOrInsertFunction("free"  , Type::VoidTy, BPTy, (Type *)0);
   return true;

diff --git a/utils/TableGen/IntrinsicEmitter.cpp b/utils/TableGen/IntrinsicEmitter.cpp
index 2d28fb72e343a766252f122337bf123896985a88..8c34e68ac6dfb69dd1dbcaa37e90b7aa32f29b82 100644 (file)
--- a/utils/TableGen/IntrinsicEmitter.cpp
+++ b/utils/TableGen/IntrinsicEmitter.cpp
@@ -146,7 +146,7 @@ static void EmitTypeForValueType(std::ostream &OS, MVT::SimpleValueType VT) {
     OS << "IntegerType::get(" << BitWidth << ")";
   } else if (VT == MVT::Other) {
     // MVT::OtherVT is used to mean the empty struct type here.
-    OS << "StructType::get(std::vector<const Type *>())";
+    OS << "StructType::get()";
   } else if (VT == MVT::f32) {
     OS << "Type::FloatTy";
   } else if (VT == MVT::f64) {