6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-01-08 18:31:23 +00:00
Code Issues Projects Releases Wiki Activity

Add FunctionType ctor variant that takes SmallVector params.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@47895 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Devang Patel 2008-03-04 18:57:05 +00:00
parent df1d15c52e
commit 52f8ed8368
2 changed files with 60 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
include/llvm/DerivedTypes.h
View File

@ -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]; }

51
lib/VMCore/Type.cpp
View File

@ -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...
//