#include "llvm/AbstractTypeUser.h"
#include "llvm/DerivedTypes.h"
+#include "llvm/ParameterAttributes.h"
#include "llvm/Constants.h"
#include "llvm/ADT/DepthFirstIterator.h"
#include "llvm/ADT/StringExtras.h"
Result += " ";
Result += getTypeDescription(FTy->getReturnType(), TypeStack) + " (";
unsigned Idx = 1;
+ const ParamAttrsList *Attrs = FTy->getParamAttrs();
for (FunctionType::param_iterator I = FTy->param_begin(),
E = FTy->param_end(); I != E; ++I) {
if (I != FTy->param_begin())
Result += ", ";
- Result += FunctionType::getParamAttrsText(FTy->getParamAttrs(Idx));
+ if (Attrs && Attrs->getParamAttrs(Idx) != ParamAttr::None)
+ Result += Attrs->getParamAttrsTextByIndex(Idx);
Idx++;
Result += getTypeDescription(*I, TypeStack);
}
Result += "...";
}
Result += ")";
- if (FTy->getParamAttrs(0)) {
- Result += " " + FunctionType::getParamAttrsText(FTy->getParamAttrs(0));
+ if (Attrs && Attrs->getParamAttrs(0) != ParamAttr::None) {
+ Result += " " + Attrs->getParamAttrsTextByIndex(0);
}
break;
}
FunctionType::FunctionType(const Type *Result,
const std::vector<const Type*> &Params,
- bool IsVarArgs, const ParamAttrsList &Attrs)
- : DerivedType(FunctionTyID), isVarArgs(IsVarArgs), ParamAttrs(0) {
+ bool IsVarArgs, ParamAttrsList *Attrs)
+ : DerivedType(FunctionTyID), isVarArgs(IsVarArgs), ParamAttrs(Attrs) {
ContainedTys = reinterpret_cast<PATypeHandle*>(this+1);
NumContainedTys = Params.size() + 1; // + 1 for result type
assert((Result->isFirstClassType() || Result == Type::VoidTy ||
isAbstract |= Params[i]->isAbstract();
}
- // Set the ParameterAttributes
- if (!Attrs.empty())
- ParamAttrs = new ParamAttrsList(Attrs);
- else
- ParamAttrs = 0;
-
// Calculate whether or not this type is abstract
setAbstract(isAbstract);
const FunctionType *FTy2 = cast<FunctionType>(Ty2);
if (FTy->isVarArg() != FTy2->isVarArg() ||
FTy->getNumParams() != FTy2->getNumParams() ||
- FTy->getNumAttrs() != FTy2->getNumAttrs() ||
- FTy->getParamAttrs(0) != FTy2->getParamAttrs(0) ||
!TypesEqual(FTy->getReturnType(), FTy2->getReturnType(), EqTypes))
return false;
+ const ParamAttrsList *Attrs1 = FTy->getParamAttrs();
+ const ParamAttrsList *Attrs2 = FTy2->getParamAttrs();
+ if ((!Attrs1 && Attrs2 && !Attrs2->empty()) ||
+ (!Attrs2 && Attrs1 && !Attrs1->empty()) ||
+ (Attrs1 && Attrs2 && (Attrs1->size() != Attrs2->size() ||
+ (Attrs1->size() > 0 &&
+ Attrs1->getParamAttrs(0) != Attrs2->getParamAttrs(0)))))
+ return false;
+ ParamAttrsList PAL1;
+ if (Attrs1)
+ PAL1 = *Attrs1;
+ ParamAttrsList PAL2;
+ if (Attrs2)
+ PAL2 = *Attrs2;
for (unsigned i = 0, e = FTy2->getNumParams(); i != e; ++i) {
- if (FTy->getParamAttrs(i+1) != FTy->getParamAttrs(i+1))
+ if (PAL1.getParamAttrs(i+1) != PAL2.getParamAttrs(i+1))
return false;
if (!TypesEqual(FTy->getParamType(i), FTy2->getParamType(i), EqTypes))
return false;
class FunctionValType {
const Type *RetTy;
std::vector<const Type*> ArgTypes;
- std::vector<FunctionType::ParameterAttributes> ParamAttrs;
+ const ParamAttrsList *ParamAttrs;
bool isVarArg;
public:
FunctionValType(const Type *ret, const std::vector<const Type*> &args,
- bool IVA, const FunctionType::ParamAttrsList &attrs)
- : RetTy(ret), isVarArg(IVA) {
+ bool IVA, const ParamAttrsList *attrs)
+ : RetTy(ret), ParamAttrs(attrs), isVarArg(IVA) {
for (unsigned i = 0; i < args.size(); ++i)
ArgTypes.push_back(args[i]);
- for (unsigned i = 0; i < attrs.size(); ++i)
- ParamAttrs.push_back(attrs[i]);
}
static FunctionValType get(const FunctionType *FT);
static unsigned hashTypeStructure(const FunctionType *FT) {
- return FT->getNumParams()*64+FT->getNumAttrs()*2+FT->isVarArg();
+ unsigned Result = FT->getNumParams()*64 + FT->isVarArg();
+ if (FT->getParamAttrs())
+ Result += FT->getParamAttrs()->size()*2;
+ return Result;
}
inline bool operator<(const FunctionValType &MTV) const {
if (isVarArg < MTV.isVarArg) return true;
if (isVarArg > MTV.isVarArg) return false;
if (ArgTypes < MTV.ArgTypes) return true;
- return ArgTypes == MTV.ArgTypes && ParamAttrs < MTV.ParamAttrs;
+ if (ArgTypes > MTV.ArgTypes) return false;
+ if (ParamAttrs)
+ if (MTV.ParamAttrs)
+ return *ParamAttrs < *MTV.ParamAttrs;
+ else if (ParamAttrs->empty())
+ return true;
+ else
+ return false;
+ else if (MTV.ParamAttrs)
+ if (MTV.ParamAttrs->empty())
+ return false;
+ else
+ return true;
+ return false;
}
};
}
FunctionValType FunctionValType::get(const FunctionType *FT) {
// Build up a FunctionValType
std::vector<const Type *> ParamTypes;
- std::vector<FunctionType::ParameterAttributes> ParamAttrs;
ParamTypes.reserve(FT->getNumParams());
for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i)
ParamTypes.push_back(FT->getParamType(i));
- for (unsigned i = 0, e = FT->getNumAttrs(); i != e; ++i)
- ParamAttrs.push_back(FT->getParamAttrs(i));
return FunctionValType(FT->getReturnType(), ParamTypes, FT->isVarArg(),
- ParamAttrs);
+ FT->getParamAttrs());
}
FunctionType *FunctionType::get(const Type *ReturnType,
const std::vector<const Type*> &Params,
bool isVarArg,
- const std::vector<ParameterAttributes> &Attrs) {
- bool noAttrs = true;
- for (unsigned i = 0, e = Attrs.size(); i < e; ++i)
- if (Attrs[i] != FunctionType::NoAttributeSet) {
- noAttrs = false;
- break;
- }
- const std::vector<FunctionType::ParameterAttributes> NullAttrs;
- const std::vector<FunctionType::ParameterAttributes> *TheAttrs = &Attrs;
- if (noAttrs)
- TheAttrs = &NullAttrs;
- FunctionValType VT(ReturnType, Params, isVarArg, *TheAttrs);
+ ParamAttrsList *Attrs) {
+
+ FunctionValType VT(ReturnType, Params, isVarArg, Attrs);
FunctionType *MT = FunctionTypes->get(VT);
- if (MT) return MT;
+ if (MT) {
+ delete Attrs; // not needed any more
+ return MT;
+ }
+
MT = (FunctionType*) new char[sizeof(FunctionType) +
sizeof(PATypeHandle)*(Params.size()+1)];
- new (MT) FunctionType(ReturnType, Params, isVarArg, *TheAttrs);
+ new (MT) FunctionType(ReturnType, Params, isVarArg, Attrs);
FunctionTypes->add(VT, MT);
#ifdef DEBUG_MERGE_TYPES
return MT;
}
-FunctionType::ParameterAttributes
-FunctionType::getParamAttrs(unsigned Idx) const {
- if (!ParamAttrs)
- return NoAttributeSet;
- if (Idx >= ParamAttrs->size())
- return NoAttributeSet;
- return (*ParamAttrs)[Idx];
+FunctionType::~FunctionType() {
+ delete ParamAttrs;
}
-std::string FunctionType::getParamAttrsText(ParameterAttributes Attr) {
- std::string Result;
- if (Attr & ZExtAttribute)
- Result += "zext ";
- if (Attr & SExtAttribute)
- Result += "sext ";
- if (Attr & NoReturnAttribute)
- Result += "noreturn ";
- if (Attr & NoUnwindAttribute)
- Result += "nounwind ";
- if (Attr & InRegAttribute)
- Result += "inreg ";
- if (Attr & StructRetAttribute)
- Result += "sret ";
- return Result;
+bool FunctionType::isStructReturn() const {
+ if (ParamAttrs)
+ return ParamAttrs->paramHasAttr(1, ParamAttr::StructRet);
+ return false;
}
//===----------------------------------------------------------------------===//
projects / oota-llvm.git / blobdiff