RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-24 11:42:57 +01:00
Code Issues Projects Releases Wiki Activity

Revert SmallVector ctor variants.

Browse Source 
llvm-svn: 47908
This commit is contained in:
Devang Patel 2008-03-04 21:54:56 +00:00
parent 84e9abbb60
commit 26d0fac377
2 changed files with 0 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
include/llvm/DerivedTypes.h
View File

@ -19,7 +19,6 @@
#define LLVM_DERIVED_TYPES_H
#include "llvm/Type.h"
#include "llvm/ADT/SmallVector.h"
namespace llvm {
@ -145,8 +144,6 @@ 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
@ -158,12 +155,6 @@ 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,30 +460,6 @@ 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);
@ -1079,12 +1055,6 @@ 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) {
@ -1138,27 +1108,6 @@ 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...
//