RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2024-12-11 05:35:11 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Move the 'ParameterOnly' variable inside of the Attributes class and make it a method.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165497 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Bill Wendling 2012-10-09 09:51:10 +00:00
parent 15c3789763
commit 943c29135e
2 changed files with 28 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
include/llvm/Attributes.h
View File

@ -110,10 +110,6 @@ DECLARE_LLVM_ATTRIBUTE(AddressSafety,1ULL<<32) ///< Address safety checking is o
/// an exception might pass by.
/// uwtable + nounwind = Needs an entry because the ABI says so.
/// @brief Attributes that only apply to function parameters.
const AttrConst ParameterOnly = {ByVal_i | Nest_i |
StructRet_i | NoCapture_i};
/// @brief Attributes that may be applied to the function itself. These cannot
/// be used on return values or function parameters.
const AttrConst FunctionOnly = {NoReturn_i | NoUnwind_i | ReadNone_i |
@ -215,11 +211,6 @@ public:
static Attributes get(Builder &B);
static Attributes get(LLVMContext &Context, Builder &B);
/// @brief Parameter attributes that do not apply to vararg call arguments.
bool hasIncompatibleWithVarArgsAttrs() const {
return hasAttribute(Attributes::StructRet);
}
/// @brief Return true if the attribute is present.
bool hasAttribute(AttrVal Val) const;
@ -231,14 +222,27 @@ public:
/// @brief Return true if the attributes are a non-null intersection.
bool hasAttributes(const Attributes &A) const;
/// This returns the alignment field of an attribute as a byte alignment
/// @brief Returns the alignment field of an attribute as a byte alignment
/// value.
unsigned getAlignment() const;
/// This returns the stack alignment field of an attribute as a byte alignment
/// value.
/// @brief Returns the stack alignment field of an attribute as a byte
/// alignment value.
unsigned getStackAlignment() const;
/// @brief Parameter attributes that do not apply to vararg call arguments.
bool hasIncompatibleWithVarArgsAttrs() const {
return hasAttribute(Attributes::StructRet);
}
/// @brief Attributes that only apply to function parameters.
bool hasParameterOnlyAttrs() const {
return hasAttribute(Attributes::ByVal) ||
hasAttribute(Attributes::Nest) ||
hasAttribute(Attributes::StructRet) ||
hasAttribute(Attributes::NoCapture);
}
bool isEmptyOrSingleton() const;
// This is a "safe bool() operator".

27
lib/VMCore/Verifier.cpp
View File

@ -533,11 +533,10 @@ void Verifier::VerifyParameterAttrs(Attributes Attrs, Type *Ty,
Assert1(!FnCheckAttr, "Attribute " + FnCheckAttr.getAsString() +
" only applies to the function!", V);
if (isReturnValue) {
Attributes RetI = Attrs & Attribute::ParameterOnly;
Assert1(!RetI, "Attribute " + RetI.getAsString() +
" does not apply to return values!", V);
}
if (isReturnValue)
Assert1(!Attrs.hasParameterOnlyAttrs(),
"Attributes 'byval', 'nest', 'sret', and 'nocapture' "
"do not apply to return values!", V);
for (unsigned i = 0;
i < array_lengthof(Attribute::MutuallyIncompatible); ++i) {
@ -550,16 +549,14 @@ void Verifier::VerifyParameterAttrs(Attributes Attrs, Type *Ty,
Assert1(!TypeI, "Wrong type for attribute " +
TypeI.getAsString(), V);
Attributes ByValI = Attrs & Attribute::ByVal;
if (PointerType *PTy = dyn_cast<PointerType>(Ty)) {
Assert1(!ByValI || PTy->getElementType()->isSized(),
"Attribute " + ByValI.getAsString() +
" does not support unsized types!", V);
} else {
Assert1(!ByValI,
"Attribute " + ByValI.getAsString() +
" only applies to parameters with pointer type!", V);
}
if (PointerType *PTy = dyn_cast<PointerType>(Ty))
Assert1(!Attrs.hasAttribute(Attributes::ByVal) ||
PTy->getElementType()->isSized(),
"Attribute 'byval' does not support unsized types!", V);
else
Assert1(!Attrs.hasAttribute(Attributes::ByVal),
"Attribute 'byval' only applies to parameters with pointer type!",
V);
}
// VerifyFunctionAttrs - Check parameter attributes against a function type.