RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2024-12-12 06:06:32 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Create enums for the different attributes.

Browse Source 
We use the enums to query whether an Attributes object has that attribute. The
opaque layer is responsible for knowing where that specific attribute is stored.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165488 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Bill Wendling 2012-10-09 07:45:08 +00:00
parent 50cf36351c
commit 6765834754
48 changed files with 319 additions and 306 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

71
include/llvm/Attributes.h
View File

@ -142,8 +142,47 @@ class AttributesImpl;
/// Attributes - A bitset of attributes.
class Attributes {
public:
enum AttrVal {
None = 0, ///< No attributes have been set
ZExt = 1, ///< Zero extended before/after call
SExt = 2, ///< Sign extended before/after call
NoReturn = 3, ///< Mark the function as not returning
InReg = 4, ///< Force argument to be passed in register
StructRet = 5, ///< Hidden pointer to structure to return
NoUnwind = 6, ///< Function doesn't unwind stack
NoAlias = 7, ///< Considered to not alias after call
ByVal = 8, ///< Pass structure by value
Nest = 9, ///< Nested function static chain
ReadNone = 10, ///< Function does not access memory
ReadOnly = 11, ///< Function only reads from memory
NoInline = 12, ///< inline=never
AlwaysInline = 13, ///< inline=always
OptimizeForSize = 14, ///< opt_size
StackProtect = 15, ///< Stack protection.
StackProtectReq = 16, ///< Stack protection required.
Alignment = 17, ///< Alignment of parameter (5 bits)
///< stored as log2 of alignment with +1 bias
///< 0 means unaligned different from align 1
NoCapture = 18, ///< Function creates no aliases of pointer
NoRedZone = 19, ///< Disable redzone
NoImplicitFloat = 20, ///< Disable implicit floating point insts
Naked = 21, ///< Naked function
InlineHint = 22, ///< Source said inlining was desirable
StackAlignment = 23, ///< Alignment of stack for function (3 bits)
///< stored as log2 of alignment with +1 bias 0
///< means unaligned (different from
///< alignstack={1))
ReturnsTwice = 24, ///< Function can return twice
UWTable = 25, ///< Function must be in a unwind table
NonLazyBind = 26, ///< Function is called early and/or
///< often, so lazy binding isn't worthwhile
AddressSafety = 27 ///< Address safety checking is on.
};
private:
// Currently, we need less than 64 bits.
AttributesImpl Attrs;
explicit Attributes(AttributesImpl *A);
public:
Attributes() : Attrs(0) {}
@ -234,7 +273,7 @@ public:
/// @brief Parameter attributes that do not apply to vararg call arguments.
bool hasIncompatibleWithVarArgsAttrs() const {
return hasStructRetAttr();
return hasAttribute(Attributes::StructRet);
}
// Attribute query methods.
@ -243,33 +282,7 @@ public:
return Attrs.hasAttributes();
}
bool hasAttributes(const Attributes &A) const;
bool hasAddressSafetyAttr() const;
bool hasAlignmentAttr() const;
bool hasAlwaysInlineAttr() const;
bool hasByValAttr() const;
bool hasInRegAttr() const;
bool hasInlineHintAttr() const;
bool hasNakedAttr() const;
bool hasNestAttr() const;
bool hasNoAliasAttr() const;
bool hasNoCaptureAttr() const;
bool hasNoImplicitFloatAttr() const;
bool hasNoInlineAttr() const;
bool hasNonLazyBindAttr() const;
bool hasNoRedZoneAttr() const;
bool hasNoReturnAttr() const;
bool hasNoUnwindAttr() const;
bool hasOptimizeForSizeAttr() const;
bool hasReadNoneAttr() const;
bool hasReadOnlyAttr() const;
bool hasReturnsTwiceAttr() const;
bool hasSExtAttr() const;
bool hasStackAlignmentAttr() const;
bool hasStackProtectAttr() const;
bool hasStackProtectReqAttr() const;
bool hasStructRetAttr() const;
bool hasUWTableAttr() const;
bool hasZExtAttr() const;
bool hasAttribute(AttrVal Val) const;
/// This returns the alignment field of an attribute as a byte alignment
/// value.
@ -341,7 +354,7 @@ public:
// 5-bit log2 encoded value. Shift the bits above the alignment up by 11
// bits.
uint64_t EncodedAttrs = Attrs.Raw() & 0xffff;
if (Attrs.hasAlignmentAttr())
if (Attrs.hasAttribute(Attributes::Alignment))
EncodedAttrs |= (1ULL << 16) <<
(((Attrs.Raw() & Attribute::Alignment_i) - 1) >> 16);
EncodedAttrs |= (Attrs.Raw() & (0xfffULL << 21)) << 11;

4
include/llvm/AttributesImpl.h
View File

@ -23,12 +23,14 @@ class Attributes;
class AttributesImpl : public FoldingSetNode {
friend class Attributes;
uint64_t Bits; // FIXME: We will be expanding this.
uint64_t getAttrMask(uint64_t Val) const;
public:
AttributesImpl(uint64_t bits) : Bits(bits) {}
bool hasAttribute(uint64_t A) const;
bool hasAttributes() const;
bool hasAttributes(const Attributes &A) const;

18
include/llvm/Function.h
View File

@ -219,7 +219,7 @@ public:
/// @brief Determine if the function does not access memory.
bool doesNotAccessMemory() const {
return getFnAttributes().hasReadNoneAttr();
return getFnAttributes().hasAttribute(Attributes::ReadNone);
}
void setDoesNotAccessMemory(bool DoesNotAccessMemory = true) {
if (DoesNotAccessMemory) addFnAttr(Attribute::ReadNone);
@ -228,7 +228,8 @@ public:
/// @brief Determine if the function does not access or only reads memory.
bool onlyReadsMemory() const {
return doesNotAccessMemory() || getFnAttributes().hasReadOnlyAttr();
return doesNotAccessMemory() ||
getFnAttributes().hasAttribute(Attributes::ReadOnly);
}
void setOnlyReadsMemory(bool OnlyReadsMemory = true) {
if (OnlyReadsMemory) addFnAttr(Attribute::ReadOnly);
@ -237,7 +238,7 @@ public:
/// @brief Determine if the function cannot return.
bool doesNotReturn() const {
return getFnAttributes().hasNoReturnAttr();
return getFnAttributes().hasAttribute(Attributes::NoReturn);
}
void setDoesNotReturn(bool DoesNotReturn = true) {
if (DoesNotReturn) addFnAttr(Attribute::NoReturn);
@ -246,7 +247,7 @@ public:
/// @brief Determine if the function cannot unwind.
bool doesNotThrow() const {
return getFnAttributes().hasNoUnwindAttr();
return getFnAttributes().hasAttribute(Attributes::NoUnwind);
}
void setDoesNotThrow(bool DoesNotThrow = true) {
if (DoesNotThrow) addFnAttr(Attribute::NoUnwind);
@ -256,7 +257,7 @@ public:
/// @brief True if the ABI mandates (or the user requested) that this
/// function be in a unwind table.
bool hasUWTable() const {
return getFnAttributes().hasUWTableAttr();
return getFnAttributes().hasAttribute(Attributes::UWTable);
}
void setHasUWTable(bool HasUWTable = true) {
if (HasUWTable)
@ -273,14 +274,13 @@ public:
/// @brief Determine if the function returns a structure through first
/// pointer argument.
bool hasStructRetAttr() const {
return getParamAttributes(1).hasStructRetAttr();
return getParamAttributes(1).hasAttribute(Attributes::StructRet);
}
/// @brief Determine if the parameter does not alias other parameters.
/// @param n The parameter to check. 1 is the first parameter, 0 is the return
bool doesNotAlias(unsigned n) const {
return n != 0 ? getParamAttributes(n).hasNoAliasAttr() :
AttributeList.getRetAttributes().hasNoAliasAttr();
return getParamAttributes(n).hasAttribute(Attributes::NoAlias);
}
void setDoesNotAlias(unsigned n, bool DoesNotAlias = true) {
if (DoesNotAlias) addAttribute(n, Attribute::NoAlias);
@ -290,7 +290,7 @@ public:
/// @brief Determine if the parameter can be captured.
/// @param n The parameter to check. 1 is the first parameter, 0 is the return
bool doesNotCapture(unsigned n) const {
return getParamAttributes(n).hasNoCaptureAttr();
return getParamAttributes(n).hasAttribute(Attributes::NoCapture);
}
void setDoesNotCapture(unsigned n, bool DoesNotCapture = true) {
if (DoesNotCapture) addAttribute(n, Attribute::NoCapture);

4
include/llvm/Instructions.h
View File

@ -1349,7 +1349,7 @@ public:
/// @brief Determine if any call argument is an aggregate passed by value.
bool hasByValArgument() const {
for (unsigned I = 0, E = AttributeList.getNumAttrs(); I != E; ++I)
if (AttributeList.getAttributesAtIndex(I).hasByValAttr())
if (AttributeList.getAttributesAtIndex(I).hasAttribute(Attributes::ByVal))
return true;
return false;
}
@ -3116,7 +3116,7 @@ public:
/// @brief Determine if any call argument is an aggregate passed by value.
bool hasByValArgument() const {
for (unsigned I = 0, E = AttributeList.getNumAttrs(); I != E; ++I)
if (AttributeList.getAttributesAtIndex(I).hasByValAttr())
if (AttributeList.getAttributesAtIndex(I).hasAttribute(Attributes::ByVal))
return true;
return false;
}

2
lib/Analysis/CodeMetrics.cpp
View File

@ -196,7 +196,7 @@ void CodeMetrics::analyzeFunction(Function *F, const DataLayout *TD) {
// as volatile if they are live across a setjmp call, and they probably
// won't do this in callers.
exposesReturnsTwice = F->callsFunctionThatReturnsTwice() &&
!F->getFnAttributes().hasReturnsTwiceAttr();
!F->getFnAttributes().hasAttribute(Attributes::ReturnsTwice);
// Look at the size of the callee.
for (Function::const_iterator BB = F->begin(), E = F->end(); BB != E; ++BB)

7
lib/Analysis/InlineCost.cpp
View File

@ -128,7 +128,7 @@ class CallAnalyzer : public InstVisitor<CallAnalyzer, bool> {
public:
CallAnalyzer(const DataLayout *TD, Function &Callee, int Threshold)
: TD(TD), F(Callee), Threshold(Threshold), Cost(0),
AlwaysInline(F.getFnAttributes().hasAlwaysInlineAttr()),
AlwaysInline(F.getFnAttributes().hasAttribute(Attributes::AlwaysInline)),
IsCallerRecursive(false), IsRecursiveCall(false),
ExposesReturnsTwice(false), HasDynamicAlloca(false), AllocatedSize(0),
NumInstructions(0), NumVectorInstructions(0),
@ -614,7 +614,7 @@ bool CallAnalyzer::visitStore(StoreInst &I) {
bool CallAnalyzer::visitCallSite(CallSite CS) {
if (CS.isCall() && cast<CallInst>(CS.getInstruction())->canReturnTwice() &&
!F.getFnAttributes().hasReturnsTwiceAttr()) {
!F.getFnAttributes().hasAttribute(Attributes::ReturnsTwice)) {
// This aborts the entire analysis.
ExposesReturnsTwice = true;
return false;
@ -1044,7 +1044,8 @@ InlineCost InlineCostAnalyzer::getInlineCost(CallSite CS, Function *Callee,
// something else. Don't inline functions marked noinline or call sites
// marked noinline.
if (!Callee || Callee->mayBeOverridden() ||
Callee->getFnAttributes().hasNoInlineAttr() || CS.isNoInline())
Callee->getFnAttributes().hasAttribute(Attributes::NoInline) ||
CS.isNoInline())
return llvm::InlineCost::getNever();
DEBUG(llvm::dbgs() << " Analyzing call of " << Callee->getName()

4
lib/Analysis/MemoryDependenceAnalysis.cpp
View File

@ -327,12 +327,12 @@ getLoadLoadClobberFullWidthSize(const Value *MemLocBase, int64_t MemLocOffs,
return 0;
if (LIOffs+NewLoadByteSize > MemLocEnd &&
LI->getParent()->getParent()->getFnAttributes().hasAddressSafetyAttr()){
LI->getParent()->getParent()->getFnAttributes().
hasAttribute(Attributes::AddressSafety))
// We will be reading past the location accessed by the original program.
// While this is safe in a regular build, Address Safety analysis tools
// may start reporting false warnings. So, don't do widening.
return 0;
}
// If a load of this width would include all of MemLoc, then we succeed.
if (LIOffs+NewLoadByteSize >= MemLocEnd)

3
lib/AsmParser/LLParser.cpp
View File

@ -2779,7 +2779,8 @@ bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
AttrListPtr PAL = AttrListPtr::get(Attrs);
if (PAL.getParamAttributes(1).hasStructRetAttr() && !RetType->isVoidTy())
if (PAL.getParamAttributes(1).hasAttribute(Attributes::StructRet) &&
!RetType->isVoidTy())
return Error(RetTypeLoc, "functions with 'sret' argument must return void");
FunctionType *FT =

6
lib/CodeGen/Analysis.cpp
View File

@ -318,7 +318,8 @@ bool llvm::isInTailCallPosition(ImmutableCallSite CS, Attributes CalleeRetAttr,
return false;
// It's not safe to eliminate the sign / zero extension of the return value.
if (CallerRetAttr.hasZExtAttr() || CallerRetAttr.hasSExtAttr())
if (CallerRetAttr.hasAttribute(Attributes::ZExt) ||
CallerRetAttr.hasAttribute(Attributes::SExt))
return false;
// Otherwise, make sure the unmodified return value of I is the return value.
@ -358,7 +359,8 @@ bool llvm::isInTailCallPosition(SelectionDAG &DAG, SDNode *Node,
return false;
// It's not safe to eliminate the sign / zero extension of the return value.
if (CallerRetAttr.hasZExtAttr() || CallerRetAttr.hasSExtAttr())
if (CallerRetAttr.hasAttribute(Attributes::ZExt) ||
CallerRetAttr.hasAttribute(Attributes::SExt))
return false;
// Check if the only use is a function return node.

3
lib/CodeGen/BranchFolding.cpp
View File

@ -571,7 +571,8 @@ static bool ProfitableToMerge(MachineBasicBlock *MBB1,
// instructions that would be deleted in the merge.
MachineFunction *MF = MBB1->getParent();
if (EffectiveTailLen >= 2 &&
MF->getFunction()->getFnAttributes().hasOptimizeForSizeAttr() &&
MF->getFunction()->getFnAttributes().
hasAttribute(Attributes::OptimizeForSize) &&
(I1 == MBB1->begin() || I2 == MBB2->begin()))
return true;

2
lib/CodeGen/CodePlacementOpt.cpp
View File

@ -373,7 +373,7 @@ bool CodePlacementOpt::OptimizeIntraLoopEdges(MachineFunction &MF) {
///
bool CodePlacementOpt::AlignLoops(MachineFunction &MF) {
const Function *F = MF.getFunction();
if (F->getFnAttributes().hasOptimizeForSizeAttr())
if (F->getFnAttributes().hasAttribute(Attributes::OptimizeForSize))
return false;
unsigned Align = TLI->getPrefLoopAlignment();

3
lib/CodeGen/MachineBlockPlacement.cpp
View File

@ -1013,7 +1013,8 @@ void MachineBlockPlacement::buildCFGChains(MachineFunction &F) {
// exclusively on the loop info here so that we can align backedges in
// unnatural CFGs and backedges that were introduced purely because of the
// loop rotations done during this layout pass.
if (F.getFunction()->getFnAttributes().hasOptimizeForSizeAttr())
if (F.getFunction()->getFnAttributes().
hasAttribute(Attributes::OptimizeForSize))
return;
unsigned Align = TLI->getPrefLoopAlignment();
if (!Align)

4
lib/CodeGen/MachineFunction.cpp
View File

@ -59,13 +59,13 @@ MachineFunction::MachineFunction(const Function *F, const TargetMachine &TM,
RegInfo = 0;
MFInfo = 0;
FrameInfo = new (Allocator) MachineFrameInfo(*TM.getFrameLowering());
if (Fn->getFnAttributes().hasStackAlignmentAttr())
if (Fn->getFnAttributes().hasAttribute(Attributes::StackAlignment))
FrameInfo->ensureMaxAlignment(Fn->getAttributes().
getFnAttributes().getStackAlignment());
ConstantPool = new (Allocator) MachineConstantPool(TM.getDataLayout());
Alignment = TM.getTargetLowering()->getMinFunctionAlignment();
// FIXME: Shouldn't use pref alignment if explicit alignment is set on Fn.
if (!Fn->getFnAttributes().hasOptimizeForSizeAttr())
if (!Fn->getFnAttributes().hasAttribute(Attributes::OptimizeForSize))
Alignment = std::max(Alignment,
TM.getTargetLowering()->getPrefFunctionAlignment());
FunctionNumber = FunctionNum;

6
lib/CodeGen/PrologEpilogInserter.cpp
View File

@ -96,7 +96,7 @@ bool PEI::runOnMachineFunction(MachineFunction &Fn) {
placeCSRSpillsAndRestores(Fn);
// Add the code to save and restore the callee saved registers
if (!F->getFnAttributes().hasNakedAttr())
if (!F->getFnAttributes().hasAttribute(Attributes::Naked))
insertCSRSpillsAndRestores(Fn);
// Allow the target machine to make final modifications to the function
@ -111,7 +111,7 @@ bool PEI::runOnMachineFunction(MachineFunction &Fn) {
// called functions. Because of this, calculateCalleeSavedRegisters()
// must be called before this function in order to set the AdjustsStack
// and MaxCallFrameSize variables.
if (!F->getFnAttributes().hasNakedAttr())
if (!F->getFnAttributes().hasAttribute(Attributes::Naked))
insertPrologEpilogCode(Fn);
// Replace all MO_FrameIndex operands with physical register references
@ -221,7 +221,7 @@ void PEI::calculateCalleeSavedRegisters(MachineFunction &Fn) {
return;
// In Naked functions we aren't going to save any registers.
if (Fn.getFunction()->getFnAttributes().hasNakedAttr())
if (Fn.getFunction()->getFnAttributes().hasAttribute(Attributes::Naked))
return;
std::vector<CalleeSavedInfo> CSI;

10
lib/CodeGen/SelectionDAG/SelectionDAG.cpp
View File

@ -3519,7 +3519,9 @@ static SDValue getMemcpyLoadsAndStores(SelectionDAG &DAG, DebugLoc dl,
bool DstAlignCanChange = false;
MachineFunction &MF = DAG.getMachineFunction();
MachineFrameInfo *MFI = MF.getFrameInfo();
bool OptSize = MF.getFunction()->getFnAttributes().hasOptimizeForSizeAttr();
bool OptSize =
MF.getFunction()->getFnAttributes().
hasAttribute(Attributes::OptimizeForSize);
FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(Dst);
if (FI && !MFI->isFixedObjectIndex(FI->getIndex()))
DstAlignCanChange = true;
@ -3612,7 +3614,8 @@ static SDValue getMemmoveLoadsAndStores(SelectionDAG &DAG, DebugLoc dl,
bool DstAlignCanChange = false;
MachineFunction &MF = DAG.getMachineFunction();
MachineFrameInfo *MFI = MF.getFrameInfo();
bool OptSize = MF.getFunction()->getFnAttributes().hasOptimizeForSizeAttr();
bool OptSize = MF.getFunction()->getFnAttributes().
hasAttribute(Attributes::OptimizeForSize);
FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(Dst);
if (FI && !MFI->isFixedObjectIndex(FI->getIndex()))
DstAlignCanChange = true;
@ -3690,7 +3693,8 @@ static SDValue getMemsetStores(SelectionDAG &DAG, DebugLoc dl,
bool DstAlignCanChange = false;
MachineFunction &MF = DAG.getMachineFunction();
MachineFrameInfo *MFI = MF.getFrameInfo();
bool OptSize = MF.getFunction()->getFnAttributes().hasOptimizeForSizeAttr();
bool OptSize = MF.getFunction()->getFnAttributes().
hasAttribute(Attributes::OptimizeForSize);
FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(Dst);
if (FI && !MFI->isFixedObjectIndex(FI->getIndex()))
DstAlignCanChange = true;

24
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
View File

@ -1227,9 +1227,9 @@ void SelectionDAGBuilder::visitRet(const ReturnInst &I) {
ISD::NodeType ExtendKind = ISD::ANY_EXTEND;
const Function *F = I.getParent()->getParent();
if (F->getRetAttributes().hasSExtAttr())
if (F->getRetAttributes().hasAttribute(Attributes::SExt))
ExtendKind = ISD::SIGN_EXTEND;
else if (F->getRetAttributes().hasZExtAttr())
else if (F->getRetAttributes().hasAttribute(Attributes::ZExt))
ExtendKind = ISD::ZERO_EXTEND;
if (ExtendKind != ISD::ANY_EXTEND && VT.isInteger())
@ -1244,7 +1244,7 @@ void SelectionDAGBuilder::visitRet(const ReturnInst &I) {
// 'inreg' on function refers to return value
ISD::ArgFlagsTy Flags = ISD::ArgFlagsTy();
if (F->getRetAttributes().hasInRegAttr())
if (F->getRetAttributes().hasAttribute(Attributes::InReg))
Flags.setInReg();
// Propagate extension type if any
@ -4400,7 +4400,7 @@ static SDValue ExpandPowI(DebugLoc DL, SDValue LHS, SDValue RHS,
return DAG.getConstantFP(1.0, LHS.getValueType());
const Function *F = DAG.getMachineFunction().getFunction();
if (!F->getFnAttributes().hasOptimizeForSizeAttr() ||
if (!F->getFnAttributes().hasAttribute(Attributes::OptimizeForSize) ||
// If optimizing for size, don't insert too many multiplies. This
// inserts up to 5 multiplies.
CountPopulation_32(Val)+Log2_32(Val) < 7) {
@ -6700,15 +6700,15 @@ void SelectionDAGISel::LowerArguments(const BasicBlock *LLVMBB) {
unsigned OriginalAlignment =
TD->getABITypeAlignment(ArgTy);
if (F.getParamAttributes(Idx).hasZExtAttr())
if (F.getParamAttributes(Idx).hasAttribute(Attributes::ZExt))
Flags.setZExt();
if (F.getParamAttributes(Idx).hasSExtAttr())
if (F.getParamAttributes(Idx).hasAttribute(Attributes::SExt))
Flags.setSExt();
if (F.getParamAttributes(Idx).hasInRegAttr())
if (F.getParamAttributes(Idx).hasAttribute(Attributes::InReg))
Flags.setInReg();
if (F.getParamAttributes(Idx).hasStructRetAttr())
if (F.getParamAttributes(Idx).hasAttribute(Attributes::StructRet))
Flags.setSRet();
if (F.getParamAttributes(Idx).hasByValAttr()) {
if (F.getParamAttributes(Idx).hasAttribute(Attributes::ByVal)) {
Flags.setByVal();
PointerType *Ty = cast<PointerType>(I->getType());
Type *ElementTy = Ty->getElementType();
@ -6722,7 +6722,7 @@ void SelectionDAGISel::LowerArguments(const BasicBlock *LLVMBB) {
FrameAlign = TLI.getByValTypeAlignment(ElementTy);
Flags.setByValAlign(FrameAlign);
}
if (F.getParamAttributes(Idx).hasNestAttr())
if (F.getParamAttributes(Idx).hasAttribute(Attributes::Nest))
Flags.setNest();
Flags.setOrigAlign(OriginalAlignment);
@ -6809,9 +6809,9 @@ void SelectionDAGISel::LowerArguments(const BasicBlock *LLVMBB) {
if (!I->use_empty()) {
ISD::NodeType AssertOp = ISD::DELETED_NODE;
if (F.getParamAttributes(Idx).hasSExtAttr())
if (F.getParamAttributes(Idx).hasAttribute(Attributes::SExt))
AssertOp = ISD::AssertSext;
else if (F.getParamAttributes(Idx).hasZExtAttr())
else if (F.getParamAttributes(Idx).hasAttribute(Attributes::ZExt))
AssertOp = ISD::AssertZext;
ArgValues.push_back(getCopyFromParts(DAG, dl, &InVals[i],

10
lib/CodeGen/SelectionDAG/TargetLowering.cpp
View File

@ -997,9 +997,9 @@ void llvm::GetReturnInfo(Type* ReturnType, Attributes attr,
EVT VT = ValueVTs[j];
ISD::NodeType ExtendKind = ISD::ANY_EXTEND;
if (attr.hasSExtAttr())
if (attr.hasAttribute(Attributes::SExt))
ExtendKind = ISD::SIGN_EXTEND;
else if (attr.hasZExtAttr())
else if (attr.hasAttribute(Attributes::ZExt))
ExtendKind = ISD::ZERO_EXTEND;
// FIXME: C calling convention requires the return type to be promoted to
@ -1017,13 +1017,13 @@ void llvm::GetReturnInfo(Type* ReturnType, Attributes attr,
// 'inreg' on function refers to return value
ISD::ArgFlagsTy Flags = ISD::ArgFlagsTy();
if (attr.hasInRegAttr())
if (attr.hasAttribute(Attributes::InReg))
Flags.setInReg();
// Propagate extension type if any
if (attr.hasSExtAttr())
if (attr.hasAttribute(Attributes::SExt))
Flags.setSExt();
else if (attr.hasZExtAttr())
else if (attr.hasAttribute(Attributes::ZExt))
Flags.setZExt();
for (unsigned i = 0; i < NumParts; ++i)

4
lib/CodeGen/StackProtector.cpp
View File

@ -137,10 +137,10 @@ bool StackProtector::ContainsProtectableArray(Type *Ty, bool InStruct) const {
/// add a guard variable to functions that call alloca, and functions with
/// buffers larger than SSPBufferSize bytes.
bool StackProtector::RequiresStackProtector() const {
if (F->getFnAttributes().hasStackProtectReqAttr())
if (F->getFnAttributes().hasAttribute(Attributes::StackProtectReq))
return true;
if (!F->getFnAttributes().hasStackProtectAttr())
if (!F->getFnAttributes().hasAttribute(Attributes::StackProtect))
return false;
for (Function::iterator I = F->begin(), E = F->end(); I != E; ++I) {

3
lib/CodeGen/TailDuplication.cpp
View File

@ -552,7 +552,8 @@ TailDuplicatePass::shouldTailDuplicate(const MachineFunction &MF,
// compensate for the duplication.
unsigned MaxDuplicateCount;
if (TailDuplicateSize.getNumOccurrences() == 0 &&
MF.getFunction()->getFnAttributes().hasOptimizeForSizeAttr())
MF.getFunction()->getFnAttributes().
hasAttribute(Attributes::OptimizeForSize))
MaxDuplicateCount = 1;
else
MaxDuplicateCount = TailDuplicateSize;

3
lib/Target/ARM/ARMBaseInstrInfo.cpp
View File

@ -3302,7 +3302,8 @@ ARMBaseInstrInfo::getOperandLatency(const InstrItineraryData *ItinData,
// instructions).
if (Latency > 0 && Subtarget.isThumb2()) {
const MachineFunction *MF = DefMI->getParent()->getParent();
if (MF->getFunction()->getFnAttributes().hasOptimizeForSizeAttr())
if (MF->getFunction()->getFnAttributes().
hasAttribute(Attributes::OptimizeForSize))
--Latency;
}
return Latency;

5
lib/Target/ARM/ARMBaseRegisterInfo.cpp
View File

@ -561,8 +561,9 @@ needsStackRealignment(const MachineFunction &MF) const {
const MachineFrameInfo *MFI = MF.getFrameInfo();
const Function *F = MF.getFunction();
unsigned StackAlign = MF.getTarget().getFrameLowering()->getStackAlignment();
bool requiresRealignment = ((MFI->getMaxAlignment() > StackAlign) ||
F->getFnAttributes().hasStackAlignmentAttr());
bool requiresRealignment =
((MFI->getMaxAlignment() > StackAlign) ||
F->getFnAttributes().hasAttribute(Attributes::StackAlignment));
return requiresRealignment && canRealignStack(MF);
}

2
lib/Target/ARM/ARMFrameLowering.cpp
View File

@ -1151,7 +1151,7 @@ static void checkNumAlignedDPRCS2Regs(MachineFunction &MF) {
return;
// Naked functions don't spill callee-saved registers.
if (MF.getFunction()->getFnAttributes().hasNakedAttr())
if (MF.getFunction()->getFnAttributes().hasAttribute(Attributes::Naked))
return;
// We are planning to use NEON instructions vst1 / vld1.

5
lib/Target/ARM/ARMISelLowering.cpp
View File

@ -6326,7 +6326,8 @@ EmitStructByval(MachineInstr *MI, MachineBasicBlock *BB) const {
UnitSize = 2;
} else {
// Check whether we can use NEON instructions.
if (!MF->getFunction()->getFnAttributes().hasNoImplicitFloatAttr() &&
if (!MF->getFunction()->getFnAttributes().
hasAttribute(Attributes::NoImplicitFloat) &&
Subtarget->hasNEON()) {
if ((Align % 16 == 0) && SizeVal >= 16) {
ldrOpc = ARM::VLD1q32wb_fixed;
@ -9060,7 +9061,7 @@ EVT ARMTargetLowering::getOptimalMemOpType(uint64_t Size,
// See if we can use NEON instructions for this...
if (IsZeroVal &&
!F->getFnAttributes().hasNoImplicitFloatAttr() &&
!F->getFnAttributes().hasAttribute(Attributes::NoImplicitFloat) &&
Subtarget->hasNEON()) {
if (memOpAlign(SrcAlign, DstAlign, 16) && Size >= 16) {
return MVT::v4i32;

2
lib/Target/Hexagon/HexagonRemoveSZExtArgs.cpp
View File

@ -50,7 +50,7 @@ bool HexagonRemoveExtendArgs::runOnFunction(Function &F) {
unsigned Idx = 1;
for (Function::arg_iterator AI = F.arg_begin(), AE = F.arg_end(); AI != AE;
++AI, ++Idx) {
if (F.getParamAttributes(Idx).hasSExtAttr()) {
if (F.getParamAttributes(Idx).hasAttribute(Attributes::SExt)) {
Argument* Arg = AI;
if (!isa<PointerType>(Arg->getType())) {
for (Instruction::use_iterator UI = Arg->use_begin();

3
lib/Target/NVPTX/NVPTXAsmPrinter.cpp
View File

@ -1456,7 +1456,8 @@ void NVPTXAsmPrinter::emitFunctionParamList(const Function *F,
continue;
}
if (PAL.getParamAttributes(paramIndex+1).hasByValAttr() == false) {
if (PAL.getParamAttributes(paramIndex+1).
hasAttribute(Attributes::ByVal) == false) {
// Just a scalar
const PointerType *PTy = dyn_cast<PointerType>(Ty);
if (isKernelFunc) {

2
lib/Target/NVPTX/NVPTXISelLowering.cpp
View File

@ -965,7 +965,7 @@ NVPTXTargetLowering::LowerFormalArguments(SDValue Chain,
// to newly created nodes. The SDNOdes for params have to
// appear in the same order as their order of appearance
// in the original function. "idx+1" holds that order.
if (PAL.getParamAttributes(i+1).hasByValAttr() == false) {
if (PAL.getParamAttributes(i+1).hasAttribute(Attributes::ByVal) == false) {
// A plain scalar.
if (isABI || isKernel) {
// If ABI, load from the param symbol

5
lib/Target/PowerPC/PPCFrameLowering.cpp
View File

@ -193,7 +193,8 @@ void PPCFrameLowering::determineFrameLayout(MachineFunction &MF) const {
// to adjust the stack pointer (we fit in the Red Zone). For 64-bit
// SVR4, we also require a stack frame if we need to spill the CR,
// since this spill area is addressed relative to the stack pointer.
bool DisableRedZone = MF.getFunction()->getFnAttributes().hasNoRedZoneAttr();
bool DisableRedZone = MF.getFunction()->getFnAttributes().
hasAttribute(Attributes::NoRedZone);
// FIXME SVR4 The 32-bit SVR4 ABI has no red zone. However, it can
// still generate stackless code if all local vars are reg-allocated.
// Try: (FrameSize <= 224
@ -255,7 +256,7 @@ bool PPCFrameLowering::needsFP(const MachineFunction &MF) const {
// Naked functions have no stack frame pushed, so we don't have a frame
// pointer.
if (MF.getFunction()->getFnAttributes().hasNakedAttr())
if (MF.getFunction()->getFnAttributes().hasAttribute(Attributes::Naked))
return false;
return MF.getTarget().Options.DisableFramePointerElim(MF) ||

3
lib/Target/PowerPC/PPCISelLowering.cpp
View File

@ -6286,7 +6286,8 @@ SDValue PPCTargetLowering::LowerFRAMEADDR(SDValue Op,
bool is31 = (getTargetMachine().Options.DisableFramePointerElim(MF) ||
MFI->hasVarSizedObjects()) &&
MFI->getStackSize() &&
!MF.getFunction()->getFnAttributes().hasNakedAttr();
!MF.getFunction()->getFnAttributes().
hasAttribute(Attributes::Naked);
unsigned FrameReg = isPPC64 ? (is31 ? PPC::X31 : PPC::X1) :
(is31 ? PPC::R31 : PPC::R1);
SDValue FrameAddr = DAG.getCopyFromReg(DAG.getEntryNode(), dl, FrameReg,

2
lib/Target/PowerPC/PPCRegisterInfo.cpp
View File

@ -596,7 +596,7 @@ PPCRegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
// to Offset to get the correct offset.
// Naked functions have stack size 0, although getStackSize may not reflect that
// because we didn't call all the pieces that compute it for naked functions.
if (!MF.getFunction()->getFnAttributes().hasNakedAttr())
if (!MF.getFunction()->getFnAttributes().hasAttribute(Attributes::Naked))
Offset += MFI->getStackSize();
// If we can, encode the offset directly into the instruction. If this is a

2
lib/Target/X86/X86FrameLowering.cpp
View File

@ -674,7 +674,7 @@ void X86FrameLowering::emitPrologue(MachineFunction &MF) const {
// function, and use up to 128 bytes of stack space, don't have a frame
// pointer, calls, or dynamic alloca then we do not need to adjust the
// stack pointer (we fit in the Red Zone).
if (Is64Bit && !Fn->getFnAttributes().hasNoRedZoneAttr() &&
if (Is64Bit && !Fn->getFnAttributes().hasAttribute(Attributes::NoRedZone) &&
!RegInfo->needsStackRealignment(MF) &&
!MFI->hasVarSizedObjects() && // No dynamic alloca.
!MFI->adjustsStack() && // No calls.

3
lib/Target/X86/X86ISelDAGToDAG.cpp
View File

@ -434,7 +434,8 @@ static bool isCalleeLoad(SDValue Callee, SDValue &Chain, bool HasCallSeq) {
void X86DAGToDAGISel::PreprocessISelDAG() {
// OptForSize is used in pattern predicates that isel is matching.
OptForSize = MF->getFunction()->getFnAttributes().hasOptimizeForSizeAttr();
OptForSize = MF->getFunction()->getFnAttributes().
hasAttribute(Attributes::OptimizeForSize);
for (SelectionDAG::allnodes_iterator I = CurDAG->allnodes_begin(),
E = CurDAG->allnodes_end(); I != E; ) {

19
lib/Target/X86/X86ISelLowering.cpp
View File

@ -1342,7 +1342,7 @@ X86TargetLowering::getOptimalMemOpType(uint64_t Size,
// cases like PR2962. This should be removed when PR2962 is fixed.
const Function *F = MF.getFunction();
if (IsZeroVal &&
!F->getFnAttributes().hasNoImplicitFloatAttr()) {
!F->getFnAttributes().hasAttribute(Attributes::NoImplicitFloat)) {
if (Size >= 16 &&
(Subtarget->isUnalignedMemAccessFast() ||
((DstAlign == 0 || DstAlign >= 16) &&
@ -2010,7 +2010,8 @@ X86TargetLowering::LowerFormalArguments(SDValue Chain,
unsigned NumIntRegs = CCInfo.getFirstUnallocated(GPR64ArgRegs,
TotalNumIntRegs);
bool NoImplicitFloatOps = Fn->getFnAttributes().hasNoImplicitFloatAttr();
bool NoImplicitFloatOps = Fn->getFnAttributes().
hasAttribute(Attributes::NoImplicitFloat);
assert(!(NumXMMRegs && !Subtarget->hasSSE1()) &&
"SSE register cannot be used when SSE is disabled!");
assert(!(NumXMMRegs && MF.getTarget().Options.UseSoftFloat &&
@ -2486,7 +2487,8 @@ X86TargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI,
OpFlags = X86II::MO_DARWIN_STUB;
} else if (Subtarget->isPICStyleRIPRel() &&
isa<Function>(GV) &&
cast<Function>(GV)->getFnAttributes().hasNonLazyBindAttr()) {
cast<Function>(GV)->getFnAttributes().
hasAttribute(Attributes::NonLazyBind)) {
// If the function is marked as non-lazy, generate an indirect call
// which loads from the GOT directly. This avoids runtime overhead
// at the cost of eager binding (and one extra byte of encoding).
@ -6629,7 +6631,8 @@ X86TargetLowering::LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) const {
bool HasAVX = Subtarget->hasAVX();
bool HasAVX2 = Subtarget->hasAVX2();
MachineFunction &MF = DAG.getMachineFunction();
bool OptForSize = MF.getFunction()->getFnAttributes().hasOptimizeForSizeAttr();
bool OptForSize = MF.getFunction()->getFnAttributes().
hasAttribute(Attributes::OptimizeForSize);
assert(VT.getSizeInBits() != 64 && "Can't lower MMX shuffles");
@ -9669,7 +9672,8 @@ SDValue X86TargetLowering::LowerVAARG(SDValue Op, SelectionDAG &DAG) const {
// Sanity Check: Make sure using fp_offset makes sense.
assert(!getTargetMachine().Options.UseSoftFloat &&
!(DAG.getMachineFunction()
.getFunction()->getFnAttributes().hasNoImplicitFloatAttr()) &&
.getFunction()->getFnAttributes()
.hasAttribute(Attributes::NoImplicitFloat)) &&
Subtarget->hasSSE1());
}
@ -10495,7 +10499,7 @@ SDValue X86TargetLowering::LowerINIT_TRAMPOLINE(SDValue Op,
for (FunctionType::param_iterator I = FTy->param_begin(),
E = FTy->param_end(); I != E; ++I, ++Idx)
if (Attrs.getParamAttributes(Idx).hasInRegAttr())
if (Attrs.getParamAttributes(Idx).hasAttribute(Attributes::InReg))
// FIXME: should only count parameters that are lowered to integers.
InRegCount += (TD->getTypeSizeInBits(*I) + 31) / 32;
@ -15439,7 +15443,8 @@ static SDValue PerformSTORECombine(SDNode *N, SelectionDAG &DAG,
return SDValue();
const Function *F = DAG.getMachineFunction().getFunction();
bool NoImplicitFloatOps = F->getFnAttributes().hasNoImplicitFloatAttr();
bool NoImplicitFloatOps = F->getFnAttributes().
hasAttribute(Attributes::NoImplicitFloat);
bool F64IsLegal = !DAG.getTarget().Options.UseSoftFloat && !NoImplicitFloatOps
&& Subtarget->hasSSE2();
if ((VT.isVector() ||

6
lib/Target/X86/X86InstrInfo.cpp
View File

@ -3828,7 +3828,8 @@ MachineInstr* X86InstrInfo::foldMemoryOperandImpl(MachineFunction &MF,
// Unless optimizing for size, don't fold to avoid partial
// register update stalls
if (!MF.getFunction()->getFnAttributes().hasOptimizeForSizeAttr() &&
if (!MF.getFunction()->getFnAttributes().
hasAttribute(Attributes::OptimizeForSize) &&
hasPartialRegUpdate(MI->getOpcode()))
return 0;
@ -3869,7 +3870,8 @@ MachineInstr* X86InstrInfo::foldMemoryOperandImpl(MachineFunction &MF,
// Unless optimizing for size, don't fold to avoid partial
// register update stalls
if (!MF.getFunction()->getFnAttributes().hasOptimizeForSizeAttr() &&
if (!MF.getFunction()->getFnAttributes().
hasAttribute(Attributes::OptimizeForSize) &&
hasPartialRegUpdate(MI->getOpcode()))
return 0;

5
lib/Target/X86/X86RegisterInfo.cpp
View File

@ -382,8 +382,9 @@ bool X86RegisterInfo::needsStackRealignment(const MachineFunction &MF) const {
const MachineFrameInfo *MFI = MF.getFrameInfo();
const Function *F = MF.getFunction();
unsigned StackAlign = TM.getFrameLowering()->getStackAlignment();
bool requiresRealignment = ((MFI->getMaxAlignment() > StackAlign) ||
F->getFnAttributes().hasStackAlignmentAttr());
bool requiresRealignment =
((MFI->getMaxAlignment() > StackAlign) ||
F->getFnAttributes().hasAttribute(Attributes::StackAlignment));
// If we've requested that we force align the stack do so now.
if (ForceStackAlign)

2
lib/Target/XCore/XCoreFrameLowering.cpp
View File

@ -101,7 +101,7 @@ void XCoreFrameLowering::emitPrologue(MachineFunction &MF) const {
const AttrListPtr &PAL = MF.getFunction()->getAttributes();
for (unsigned I = 0, E = PAL.getNumAttrs(); I != E; ++I)
if (PAL.getAttributesAtIndex(I).hasNestAttr()) {
if (PAL.getAttributesAtIndex(I).hasAttribute(Attributes::Nest)) {
loadFromStack(MBB, MBBI, XCore::R11, 0, dl, TII);
break;
}

3
lib/Transforms/IPO/ArgumentPromotion.cpp
View File

@ -153,7 +153,8 @@ CallGraphNode *ArgPromotion::PromoteArguments(CallGraphNode *CGN) {
SmallPtrSet<Argument*, 8> ArgsToPromote;
SmallPtrSet<Argument*, 8> ByValArgsToTransform;
for (unsigned i = 0; i != PointerArgs.size(); ++i) {
bool isByVal=F->getParamAttributes(PointerArgs[i].second+1).hasByValAttr();
bool isByVal=F->getParamAttributes(PointerArgs[i].second+1).
hasAttribute(Attributes::ByVal);
Argument *PtrArg = PointerArgs[i].first;
Type *AgTy = cast<PointerType>(PtrArg->getType())->getElementType();

2
lib/Transforms/IPO/GlobalOpt.cpp
View File

@ -2063,7 +2063,7 @@ static void ChangeCalleesToFastCall(Function *F) {
static AttrListPtr StripNest(const AttrListPtr &Attrs) {
for (unsigned i = 0, e = Attrs.getNumSlots(); i != e; ++i) {
if (!Attrs.getSlot(i).Attrs.hasNestAttr())
if (!Attrs.getSlot(i).Attrs.hasAttribute(Attributes::Nest))
continue;
// There can be only one.

4
lib/Transforms/IPO/InlineAlways.cpp
View File

@ -65,7 +65,7 @@ Pass *llvm::createAlwaysInlinerPass(bool InsertLifetime) {
/// \brief Minimal filter to detect invalid constructs for inlining.
static bool isInlineViable(Function &F) {
bool ReturnsTwice = F.getFnAttributes().hasReturnsTwiceAttr();
bool ReturnsTwice =F.getFnAttributes().hasAttribute(Attributes::ReturnsTwice);
for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE; ++BI) {
// Disallow inlining of functions which contain an indirect branch.
if (isa<IndirectBrInst>(BI->getTerminator()))
@ -114,7 +114,7 @@ InlineCost AlwaysInliner::getInlineCost(CallSite CS) {
if (Callee->isDeclaration()) return InlineCost::getNever();
// Return never for anything not marked as always inline.
if (!Callee->getFnAttributes().hasAlwaysInlineAttr())
if (!Callee->getFnAttributes().hasAttribute(Attributes::AlwaysInline))
return InlineCost::getNever();
// Do some minimal analysis to preclude non-viable functions.

13
lib/Transforms/IPO/Inliner.cpp
View File

@ -93,10 +93,10 @@ static bool InlineCallIfPossible(CallSite CS, InlineFunctionInfo &IFI,
// If the inlined function had a higher stack protection level than the
// calling function, then bump up the caller's stack protection level.
if (Callee->getFnAttributes().hasStackProtectReqAttr())
if (Callee->getFnAttributes().hasAttribute(Attributes::StackProtectReq))
Caller->addFnAttr(Attribute::StackProtectReq);
else if (Callee->getFnAttributes().hasStackProtectAttr() &&
!Caller->getFnAttributes().hasStackProtectReqAttr())
else if (Callee->getFnAttributes().hasAttribute(Attributes::StackProtect) &&
!Caller->getFnAttributes().hasAttribute(Attributes::StackProtectReq))
Caller->addFnAttr(Attribute::StackProtect);
// Look at all of the allocas that we inlined through this call site. If we
@ -209,7 +209,7 @@ unsigned Inliner::getInlineThreshold(CallSite CS) const {
// would decrease the threshold.
Function *Caller = CS.getCaller();
bool OptSize = Caller && !Caller->isDeclaration() &&
Caller->getFnAttributes().hasOptimizeForSizeAttr();
Caller->getFnAttributes().hasAttribute(Attributes::OptimizeForSize);
if (!(InlineLimit.getNumOccurrences() > 0) && OptSize &&
OptSizeThreshold < thres)
thres = OptSizeThreshold;
@ -217,7 +217,7 @@ unsigned Inliner::getInlineThreshold(CallSite CS) const {
// Listen to the inlinehint attribute when it would increase the threshold.
Function *Callee = CS.getCalledFunction();
bool InlineHint = Callee && !Callee->isDeclaration() &&
Callee->getFnAttributes().hasInlineHintAttr();
Callee->getFnAttributes().hasAttribute(Attributes::InlineHint);
if (InlineHint && HintThreshold > thres)
thres = HintThreshold;
@ -533,7 +533,8 @@ bool Inliner::removeDeadFunctions(CallGraph &CG, bool AlwaysInlineOnly) {
// Handle the case when this function is called and we only want to care
// about always-inline functions. This is a bit of a hack to share code
// between here and the InlineAlways pass.
if (AlwaysInlineOnly && !F->getFnAttributes().hasAlwaysInlineAttr())
if (AlwaysInlineOnly &&
!F->getFnAttributes().hasAttribute(Attributes::AlwaysInline))
continue;
// If the only remaining users of the function are dead constants, remove

6
lib/Transforms/InstCombine/InstCombineCalls.cpp
View File

@ -1072,7 +1072,7 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) {
// If the parameter is passed as a byval argument, then we have to have a
// sized type and the sized type has to have the same size as the old type.
if (ParamTy != ActTy && Attrs.hasByValAttr()) {
if (ParamTy != ActTy && Attrs.hasAttribute(Attributes::ByVal)) {
PointerType *ParamPTy = dyn_cast<PointerType>(ParamTy);
if (ParamPTy == 0 || !ParamPTy->getElementType()->isSized() || TD == 0)
return false;
@ -1264,7 +1264,7 @@ InstCombiner::transformCallThroughTrampoline(CallSite CS,
// If the call already has the 'nest' attribute somewhere then give up -
// otherwise 'nest' would occur twice after splicing in the chain.
for (unsigned I = 0, E = Attrs.getNumAttrs(); I != E; ++I)
if (Attrs.getAttributesAtIndex(I).hasNestAttr())
if (Attrs.getAttributesAtIndex(I).hasAttribute(Attributes::Nest))
return 0;
assert(Tramp &&
@ -1283,7 +1283,7 @@ InstCombiner::transformCallThroughTrampoline(CallSite CS,
// Look for a parameter marked with the 'nest' attribute.
for (FunctionType::param_iterator I = NestFTy->param_begin(),
E = NestFTy->param_end(); I != E; ++NestIdx, ++I)
if (NestAttrs.getParamAttributes(NestIdx).hasNestAttr()) {
if (NestAttrs.getParamAttributes(NestIdx).hasAttribute(Attributes::Nest)){
// Record the parameter type and any other attributes.
NestTy = *I;
NestAttr = NestAttrs.getParamAttributes(NestIdx);

8
lib/Transforms/Instrumentation/AddressSanitizer.cpp
View File

@ -854,12 +854,14 @@ bool AddressSanitizer::handleFunction(Module &M, Function &F) {
// If needed, insert __asan_init before checking for AddressSafety attr.
maybeInsertAsanInitAtFunctionEntry(F);
if (!F.getFnAttributes().hasAddressSafetyAttr()) return false;
if (!F.getFnAttributes().hasAttribute(Attributes::AddressSafety))
return false;
if (!ClDebugFunc.empty() && ClDebugFunc != F.getName())
return false;
// We want to instrument every address only once per basic block
// (unless there are calls between uses).
// We want to instrument every address only once per basic block (unless there
// are calls between uses).
SmallSet<Value*, 16> TempsToInstrument;
SmallVector<Instruction*, 16> ToInstrument;
SmallVector<Instruction*, 8> NoReturnCalls;

5
lib/Transforms/Scalar/CodeGenPrepare.cpp
View File

@ -149,7 +149,7 @@ bool CodeGenPrepare::runOnFunction(Function &F) {
TLInfo = &getAnalysis<TargetLibraryInfo>();
DT = getAnalysisIfAvailable<DominatorTree>();
PFI = getAnalysisIfAvailable<ProfileInfo>();
OptSize = F.getFnAttributes().hasOptimizeForSizeAttr();
OptSize = F.getFnAttributes().hasAttribute(Attributes::OptimizeForSize);
/// This optimization identifies DIV instructions that can be
/// profitably bypassed and carried out with a shorter, faster divide.
@ -715,7 +715,8 @@ bool CodeGenPrepare::DupRetToEnableTailCallOpts(ReturnInst *RI) {
// See llvm::isInTailCallPosition().
const Function *F = BB->getParent();
Attributes CallerRetAttr = F->getAttributes().getRetAttributes();
if (CallerRetAttr.hasZExtAttr() || CallerRetAttr.hasSExtAttr())
if (CallerRetAttr.hasAttribute(Attributes::ZExt) ||
CallerRetAttr.hasAttribute(Attributes::SExt))
return false;
// Make sure there are no instructions between the PHI and return, or that the

3
lib/Transforms/Scalar/LoopUnrollPass.cpp
View File

@ -145,7 +145,8 @@ bool LoopUnroll::runOnLoop(Loop *L, LPPassManager &LPM) {
// not user specified.
unsigned Threshold = CurrentThreshold;
if (!UserThreshold &&
Header->getParent()->getFnAttributes().hasOptimizeForSizeAttr())
Header->getParent()->getFnAttributes().
hasAttribute(Attributes::OptimizeForSize))
Threshold = OptSizeUnrollThreshold;
// Find trip count and trip multiple if count is not available

3
lib/Transforms/Scalar/LoopUnswitch.cpp
View File

@ -638,7 +638,8 @@ bool LoopUnswitch::UnswitchIfProfitable(Value *LoopCond, Constant *Val) {
// Check to see if it would be profitable to unswitch current loop.
// Do not do non-trivial unswitch while optimizing for size.
if (OptimizeForSize || F->getFnAttributes().hasOptimizeForSizeAttr())
if (OptimizeForSize ||
F->getFnAttributes().hasAttribute(Attributes::OptimizeForSize))
return false;
UnswitchNontrivialCondition(LoopCond, Val, currentLoop);

180
lib/VMCore/Attributes.cpp
View File

@ -68,91 +68,14 @@ Attributes Attributes::get(LLVMContext &Context, Attributes::Builder &B) {
bool Attributes::hasAttributes(const Attributes &A) const {
return Attrs.hasAttributes(A);
}
bool Attributes::hasAddressSafetyAttr() const {
return Attrs.hasAttribute(Attribute::AddressSafety_i);
}
bool Attributes::hasAlignmentAttr() const {
return Attrs.hasAttribute(Attribute::Alignment_i);
}
bool Attributes::hasAlwaysInlineAttr() const {
return Attrs.hasAttribute(Attribute::AlwaysInline_i);
}
bool Attributes::hasByValAttr() const {
return Attrs.hasAttribute(Attribute::ByVal_i);
}
bool Attributes::hasInlineHintAttr() const {
return Attrs.hasAttribute(Attribute::InlineHint_i);
}
bool Attributes::hasInRegAttr() const {
return Attrs.hasAttribute(Attribute::InReg_i);
}
bool Attributes::hasNakedAttr() const {
return Attrs.hasAttribute(Attribute::Naked_i);
}
bool Attributes::hasNestAttr() const {
return Attrs.hasAttribute(Attribute::Nest_i);
}
bool Attributes::hasNoAliasAttr() const {
return Attrs.hasAttribute(Attribute::NoAlias_i);
}
bool Attributes::hasNoCaptureAttr() const {
return Attrs.hasAttribute(Attribute::NoCapture_i);
}
bool Attributes::hasNoImplicitFloatAttr() const {
return Attrs.hasAttribute(Attribute::NoImplicitFloat_i);
}
bool Attributes::hasNoInlineAttr() const {
return Attrs.hasAttribute(Attribute::NoInline_i);
}
bool Attributes::hasNonLazyBindAttr() const {
return Attrs.hasAttribute(Attribute::NonLazyBind_i);
}
bool Attributes::hasNoRedZoneAttr() const {
return Attrs.hasAttribute(Attribute::NoRedZone_i);
}
bool Attributes::hasNoReturnAttr() const {
return Attrs.hasAttribute(Attribute::NoReturn_i);
}
bool Attributes::hasNoUnwindAttr() const {
return Attrs.hasAttribute(Attribute::NoUnwind_i);
}
bool Attributes::hasOptimizeForSizeAttr() const {
return Attrs.hasAttribute(Attribute::OptimizeForSize_i);
}
bool Attributes::hasReadNoneAttr() const {
return Attrs.hasAttribute(Attribute::ReadNone_i);
}
bool Attributes::hasReadOnlyAttr() const {
return Attrs.hasAttribute(Attribute::ReadOnly_i);
}
bool Attributes::hasReturnsTwiceAttr() const {
return Attrs.hasAttribute(Attribute::ReturnsTwice_i);
}
bool Attributes::hasSExtAttr() const {
return Attrs.hasAttribute(Attribute::SExt_i);
}
bool Attributes::hasStackAlignmentAttr() const {
return Attrs.hasAttribute(Attribute::StackAlignment_i);
}
bool Attributes::hasStackProtectAttr() const {
return Attrs.hasAttribute(Attribute::StackProtect_i);
}
bool Attributes::hasStackProtectReqAttr() const {
return Attrs.hasAttribute(Attribute::StackProtectReq_i);
}
bool Attributes::hasStructRetAttr() const {
return Attrs.hasAttribute(Attribute::StructRet_i);
}
bool Attributes::hasUWTableAttr() const {
return Attrs.hasAttribute(Attribute::UWTable_i);
}
bool Attributes::hasZExtAttr() const {
return Attrs.hasAttribute(Attribute::ZExt_i);
bool Attributes::hasAttribute(AttrVal Val) const {
return Attrs.hasAttribute(Val);
}
/// This returns the alignment field of an attribute as a byte alignment value.
unsigned Attributes::getAlignment() const {
if (!hasAlignmentAttr())
if (!hasAttribute(Attributes::Alignment))
return 0;
return 1U << ((Attrs.getAlignment() >> 16) - 1);
}
@ -160,7 +83,7 @@ unsigned Attributes::getAlignment() const {
/// This returns the stack alignment field of an attribute as a byte alignment
/// value.
unsigned Attributes::getStackAlignment() const {
if (!hasStackAlignmentAttr())
if (!hasAttribute(Attributes::StackAlignment))
return 0;
return 1U << ((Attrs.getStackAlignment() >> 26) - 1);
}
@ -217,62 +140,62 @@ Attributes Attributes::typeIncompatible(Type *Ty) {
std::string Attributes::getAsString() const {
std::string Result;
if (hasZExtAttr())
if (hasAttribute(Attributes::ZExt))
Result += "zeroext ";
if (hasSExtAttr())
if (hasAttribute(Attributes::SExt))
Result += "signext ";
if (hasNoReturnAttr())
if (hasAttribute(Attributes::NoReturn))
Result += "noreturn ";
if (hasNoUnwindAttr())
if (hasAttribute(Attributes::NoUnwind))
Result += "nounwind ";
if (hasUWTableAttr())
if (hasAttribute(Attributes::UWTable))
Result += "uwtable ";
if (hasReturnsTwiceAttr())
if (hasAttribute(Attributes::ReturnsTwice))
Result += "returns_twice ";
if (hasInRegAttr())
if (hasAttribute(Attributes::InReg))
Result += "inreg ";
if (hasNoAliasAttr())
if (hasAttribute(Attributes::NoAlias))
Result += "noalias ";
if (hasNoCaptureAttr())
if (hasAttribute(Attributes::NoCapture))
Result += "nocapture ";
if (hasStructRetAttr())
if (hasAttribute(Attributes::StructRet))
Result += "sret ";
if (hasByValAttr())
if (hasAttribute(Attributes::ByVal))
Result += "byval ";
if (hasNestAttr())
if (hasAttribute(Attributes::Nest))
Result += "nest ";
if (hasReadNoneAttr())
if (hasAttribute(Attributes::ReadNone))
Result += "readnone ";
if (hasReadOnlyAttr())
if (hasAttribute(Attributes::ReadOnly))
Result += "readonly ";
if (hasOptimizeForSizeAttr())
if (hasAttribute(Attributes::OptimizeForSize))
Result += "optsize ";
if (hasNoInlineAttr())
if (hasAttribute(Attributes::NoInline))
Result += "noinline ";
if (hasInlineHintAttr())
if (hasAttribute(Attributes::InlineHint))
Result += "inlinehint ";
if (hasAlwaysInlineAttr())
if (hasAttribute(Attributes::AlwaysInline))
Result += "alwaysinline ";
if (hasStackProtectAttr())
if (hasAttribute(Attributes::StackProtect))
Result += "ssp ";
if (hasStackProtectReqAttr())
if (hasAttribute(Attributes::StackProtectReq))
Result += "sspreq ";
if (hasNoRedZoneAttr())
if (hasAttribute(Attributes::NoRedZone))
Result += "noredzone ";
if (hasNoImplicitFloatAttr())
if (hasAttribute(Attributes::NoImplicitFloat))
Result += "noimplicitfloat ";
if (hasNakedAttr())
if (hasAttribute(Attributes::Naked))
Result += "naked ";
if (hasNonLazyBindAttr())
if (hasAttribute(Attributes::NonLazyBind))
Result += "nonlazybind ";
if (hasAddressSafetyAttr())
if (hasAttribute(Attributes::AddressSafety))
Result += "address_safety ";
if (hasStackAlignmentAttr()) {
if (hasAttribute(Attributes::StackAlignment)) {
Result += "alignstack(";
Result += utostr(getStackAlignment());
Result += ") ";
}
if (hasAlignmentAttr()) {
if (hasAttribute(Attributes::Alignment)) {
Result += "align ";
Result += utostr(getAlignment());
Result += " ";
@ -484,8 +407,42 @@ uint64_t Attributes::Builder::getAlignment() const {
// AttributeImpl Definition
//===----------------------------------------------------------------------===//
uint64_t AttributesImpl::getAttrMask(uint64_t Val) const {
switch (Val) {
case Attributes::None: return 0;
case Attributes::ZExt: return 1 << 0;
case Attributes::SExt: return 1 << 1;
case Attributes::NoReturn: return 1 << 2;
case Attributes::InReg: return 1 << 3;
case Attributes::StructRet: return 1 << 4;
case Attributes::NoUnwind: return 1 << 5;
case Attributes::NoAlias: return 1 << 6;
case Attributes::ByVal: return 1 << 7;
case Attributes::Nest: return 1 << 8;
case Attributes::ReadNone: return 1 << 9;
case Attributes::ReadOnly: return 1 << 10;
case Attributes::NoInline: return 1 << 11;
case Attributes::AlwaysInline: return 1 << 12;
case Attributes::OptimizeForSize: return 1 << 13;
case Attributes::StackProtect: return 1 << 14;
case Attributes::StackProtectReq: return 1 << 15;
case Attributes::Alignment: return 31 << 16;
case Attributes::NoCapture: return 1 << 21;
case Attributes::NoRedZone: return 1 << 22;
case Attributes::NoImplicitFloat: return 1 << 23;
case Attributes::Naked: return 1 << 24;
case Attributes::InlineHint: return 1 << 25;
case Attributes::StackAlignment: return 7 << 26;
case Attributes::ReturnsTwice: return 1 << 29;
case Attributes::UWTable: return 1 << 30;
case Attributes::NonLazyBind: return 1U << 31;
case Attributes::AddressSafety: return 1ULL << 32;
}
llvm_unreachable("Unsupported attribute type");
}
bool AttributesImpl::hasAttribute(uint64_t A) const {
return (Bits & A) != 0;
return (Bits & getAttrMask(A)) != 0;
}
bool AttributesImpl::hasAttributes() const {
@ -724,7 +681,8 @@ AttrListPtr AttrListPtr::removeAttr(unsigned Idx, Attributes Attrs) const {
#ifndef NDEBUG
// FIXME it is not obvious how this should work for alignment.
// For now, say we can't pass in alignment, which no current use does.
assert(!Attrs.hasAlignmentAttr() && "Attempt to exclude alignment!");
assert(!Attrs.hasAttribute(Attributes::Alignment) &&
"Attempt to exclude alignment!");
#endif
if (AttrList == 0) return AttrListPtr();

15
lib/VMCore/Function.cpp
View File

@ -78,7 +78,8 @@ unsigned Argument::getArgNo() const {
/// in its containing function.
bool Argument::hasByValAttr() const {
if (!getType()->isPointerTy()) return false;
return getParent()->getParamAttributes(getArgNo()+1).hasByValAttr();
return getParent()->getParamAttributes(getArgNo()+1).
hasAttribute(Attributes::ByVal);
}
unsigned Argument::getParamAlignment() const {
@ -91,21 +92,24 @@ unsigned Argument::getParamAlignment() const {
/// it in its containing function.
bool Argument::hasNestAttr() const {
if (!getType()->isPointerTy()) return false;
return getParent()->getParamAttributes(getArgNo()+1).hasNestAttr();
return getParent()->getParamAttributes(getArgNo()+1).
hasAttribute(Attributes::Nest);
}
/// hasNoAliasAttr - Return true if this argument has the noalias attribute on
/// it in its containing function.
bool Argument::hasNoAliasAttr() const {
if (!getType()->isPointerTy()) return false;
return getParent()->getParamAttributes(getArgNo()+1).hasNoAliasAttr();
return getParent()->getParamAttributes(getArgNo()+1).
hasAttribute(Attributes::NoAlias);
}
/// hasNoCaptureAttr - Return true if this argument has the nocapture attribute
/// on it in its containing function.
bool Argument::hasNoCaptureAttr() const {
if (!getType()->isPointerTy()) return false;
return getParent()->getParamAttributes(getArgNo()+1).hasNoCaptureAttr();
return getParent()->getParamAttributes(getArgNo()+1).
hasAttribute(Attributes::NoCapture);
}
/// hasSRetAttr - Return true if this argument has the sret attribute on
@ -114,7 +118,8 @@ bool Argument::hasStructRetAttr() const {
if (!getType()->isPointerTy()) return false;
if (this != getParent()->arg_begin())
return false; // StructRet param must be first param
return getParent()->getParamAttributes(1).hasStructRetAttr();
return getParent()->getParamAttributes(1).
hasAttribute(Attributes::StructRet);
}
/// addAttr - Add a Attribute to an argument

122
lib/VMCore/Instructions.cpp
View File

@ -343,116 +343,117 @@ void CallInst::removeAttribute(unsigned i, Attributes attr) {
}
bool CallInst::fnHasNoAliasAttr() const {
if (AttributeList.getParamAttributes(~0U).hasNoAliasAttr())
if (AttributeList.getParamAttributes(~0U).hasAttribute(Attributes::NoAlias))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(~0U).hasNoAliasAttr();
return F->getParamAttributes(~0U).hasAttribute(Attributes::NoAlias);
return false;
}
bool CallInst::fnHasNoInlineAttr() const {
if (AttributeList.getParamAttributes(~0U).hasNoInlineAttr())
if (AttributeList.getParamAttributes(~0U).hasAttribute(Attributes::NoInline))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(~0U).hasNoInlineAttr();
return F->getParamAttributes(~0U).hasAttribute(Attributes::NoInline);
return false;
}
bool CallInst::fnHasNoReturnAttr() const {
if (AttributeList.getParamAttributes(~0U).hasNoReturnAttr())
if (AttributeList.getParamAttributes(~0U).hasAttribute(Attributes::NoReturn))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(~0U).hasNoReturnAttr();
return F->getParamAttributes(~0U).hasAttribute(Attributes::NoReturn);
return false;
}
bool CallInst::fnHasNoUnwindAttr() const {
if (AttributeList.getParamAttributes(~0U).hasNoUnwindAttr())
if (AttributeList.getParamAttributes(~0U).hasAttribute(Attributes::NoUnwind))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(~0U).hasNoUnwindAttr();
return F->getParamAttributes(~0U).hasAttribute(Attributes::NoUnwind);
return false;
}
bool CallInst::fnHasReadNoneAttr() const {
if (AttributeList.getParamAttributes(~0U).hasReadNoneAttr())
if (AttributeList.getParamAttributes(~0U).hasAttribute(Attributes::ReadNone))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(~0U).hasReadNoneAttr();
return F->getParamAttributes(~0U).hasAttribute(Attributes::ReadNone);
return false;
}
bool CallInst::fnHasReadOnlyAttr() const {
if (AttributeList.getParamAttributes(~0U).hasReadOnlyAttr())
if (AttributeList.getParamAttributes(~0U).hasAttribute(Attributes::ReadOnly))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(~0U).hasReadOnlyAttr();
return F->getParamAttributes(~0U).hasAttribute(Attributes::ReadOnly);
return false;
}
bool CallInst::fnHasReturnsTwiceAttr() const {
if (AttributeList.getParamAttributes(~0U).hasReturnsTwiceAttr())
if (AttributeList.getParamAttributes(~0U).
hasAttribute(Attributes::ReturnsTwice))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(~0U).hasReturnsTwiceAttr();
return F->getParamAttributes(~0U).hasAttribute(Attributes::ReturnsTwice);
return false;
}
bool CallInst::paramHasSExtAttr(unsigned i) const {
if (AttributeList.getParamAttributes(i).hasSExtAttr())
if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::SExt))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(i).hasSExtAttr();
return F->getParamAttributes(i).hasAttribute(Attributes::SExt);
return false;
}
bool CallInst::paramHasZExtAttr(unsigned i) const {
if (AttributeList.getParamAttributes(i).hasZExtAttr())
if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::ZExt))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(i).hasZExtAttr();
return F->getParamAttributes(i).hasAttribute(Attributes::ZExt);
return false;
}
bool CallInst::paramHasInRegAttr(unsigned i) const {
if (AttributeList.getParamAttributes(i).hasInRegAttr())
if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::InReg))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(i).hasInRegAttr();
return F->getParamAttributes(i).hasAttribute(Attributes::InReg);
return false;
}
bool CallInst::paramHasStructRetAttr(unsigned i) const {
if (AttributeList.getParamAttributes(i).hasStructRetAttr())
if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::StructRet))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(i).hasStructRetAttr();
return F->getParamAttributes(i).hasAttribute(Attributes::StructRet);
return false;
}
bool CallInst::paramHasNestAttr(unsigned i) const {
if (AttributeList.getParamAttributes(i).hasNestAttr())
if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::Nest))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(i).hasNestAttr();
return F->getParamAttributes(i).hasAttribute(Attributes::Nest);
return false;
}
bool CallInst::paramHasByValAttr(unsigned i) const {
if (AttributeList.getParamAttributes(i).hasByValAttr())
if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::ByVal))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(i).hasByValAttr();
return F->getParamAttributes(i).hasAttribute(Attributes::ByVal);
return false;
}
bool CallInst::paramHasNoAliasAttr(unsigned i) const {
if (AttributeList.getParamAttributes(i).hasNoAliasAttr())
if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::NoAlias))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(i).hasNoAliasAttr();
return F->getParamAttributes(i).hasAttribute(Attributes::NoAlias);
return false;
}
bool CallInst::paramHasNoCaptureAttr(unsigned i) const {
if (AttributeList.getParamAttributes(i).hasNoCaptureAttr())
if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::NoCapture))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(i).hasNoCaptureAttr();
return F->getParamAttributes(i).hasAttribute(Attributes::NoCapture);
return false;
}
@ -669,116 +670,117 @@ void InvokeInst::setSuccessorV(unsigned idx, BasicBlock *B) {
}
bool InvokeInst::fnHasNoAliasAttr() const {
if (AttributeList.getParamAttributes(~0U).hasNoAliasAttr())
if (AttributeList.getParamAttributes(~0U).hasAttribute(Attributes::NoAlias))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(~0U).hasNoAliasAttr();
return F->getParamAttributes(~0U).hasAttribute(Attributes::NoAlias);
return false;
}
bool InvokeInst::fnHasNoInlineAttr() const {
if (AttributeList.getParamAttributes(~0U).hasNoInlineAttr())
if (AttributeList.getParamAttributes(~0U).hasAttribute(Attributes::NoInline))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(~0U).hasNoInlineAttr();
return F->getParamAttributes(~0U).hasAttribute(Attributes::NoInline);
return false;
}
bool InvokeInst::fnHasNoReturnAttr() const {
if (AttributeList.getParamAttributes(~0U).hasNoReturnAttr())
if (AttributeList.getParamAttributes(~0U).hasAttribute(Attributes::NoReturn))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(~0U).hasNoReturnAttr();
return F->getParamAttributes(~0U).hasAttribute(Attributes::NoReturn);
return false;
}
bool InvokeInst::fnHasNoUnwindAttr() const {
if (AttributeList.getParamAttributes(~0U).hasNoUnwindAttr())
if (AttributeList.getParamAttributes(~0U).hasAttribute(Attributes::NoUnwind))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(~0U).hasNoUnwindAttr();
return F->getParamAttributes(~0U).hasAttribute(Attributes::NoUnwind);
return false;
}
bool InvokeInst::fnHasReadNoneAttr() const {
if (AttributeList.getParamAttributes(~0U).hasReadNoneAttr())
if (AttributeList.getParamAttributes(~0U).hasAttribute(Attributes::ReadNone))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(~0U).hasReadNoneAttr();
return F->getParamAttributes(~0U).hasAttribute(Attributes::ReadNone);
return false;
}
bool InvokeInst::fnHasReadOnlyAttr() const {
if (AttributeList.getParamAttributes(~0U).hasReadOnlyAttr())
if (AttributeList.getParamAttributes(~0U).hasAttribute(Attributes::ReadOnly))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(~0U).hasReadOnlyAttr();
return F->getParamAttributes(~0U).hasAttribute(Attributes::ReadOnly);
return false;
}
bool InvokeInst::fnHasReturnsTwiceAttr() const {
if (AttributeList.getParamAttributes(~0U).hasReturnsTwiceAttr())
if (AttributeList.getParamAttributes(~0U).
hasAttribute(Attributes::ReturnsTwice))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(~0U).hasReturnsTwiceAttr();
return F->getParamAttributes(~0U).hasAttribute(Attributes::ReturnsTwice);
return false;
}
bool InvokeInst::paramHasSExtAttr(unsigned i) const {
if (AttributeList.getParamAttributes(i).hasSExtAttr())
if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::SExt))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(i).hasSExtAttr();
return F->getParamAttributes(i).hasAttribute(Attributes::SExt);
return false;
}
bool InvokeInst::paramHasZExtAttr(unsigned i) const {
if (AttributeList.getParamAttributes(i).hasZExtAttr())
if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::ZExt))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(i).hasZExtAttr();
return F->getParamAttributes(i).hasAttribute(Attributes::ZExt);
return false;
}
bool InvokeInst::paramHasInRegAttr(unsigned i) const {
if (AttributeList.getParamAttributes(i).hasInRegAttr())
if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::InReg))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(i).hasInRegAttr();
return F->getParamAttributes(i).hasAttribute(Attributes::InReg);
return false;
}
bool InvokeInst::paramHasStructRetAttr(unsigned i) const {
if (AttributeList.getParamAttributes(i).hasStructRetAttr())
if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::StructRet))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(i).hasStructRetAttr();
return F->getParamAttributes(i).hasAttribute(Attributes::StructRet);
return false;
}
bool InvokeInst::paramHasNestAttr(unsigned i) const {
if (AttributeList.getParamAttributes(i).hasNestAttr())
if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::Nest))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(i).hasNestAttr();
return F->getParamAttributes(i).hasAttribute(Attributes::Nest);
return false;
}
bool InvokeInst::paramHasByValAttr(unsigned i) const {
if (AttributeList.getParamAttributes(i).hasByValAttr())
if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::ByVal))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(i).hasByValAttr();
return F->getParamAttributes(i).hasAttribute(Attributes::ByVal);
return false;
}
bool InvokeInst::paramHasNoAliasAttr(unsigned i) const {
if (AttributeList.getParamAttributes(i).hasNoAliasAttr())
if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::NoAlias))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(i).hasNoAliasAttr();
return F->getParamAttributes(i).hasAttribute(Attributes::NoAlias);
return false;
}
bool InvokeInst::paramHasNoCaptureAttr(unsigned i) const {
if (AttributeList.getParamAttributes(i).hasNoCaptureAttr())
if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::NoCapture))
return true;
if (const Function *F = getCalledFunction())
return F->getParamAttributes(i).hasNoCaptureAttr();
return F->getParamAttributes(i).hasAttribute(Attributes::NoCapture);
return false;
}

4
lib/VMCore/Verifier.cpp
View File

@ -585,12 +585,12 @@ void Verifier::VerifyFunctionAttrs(FunctionType *FT,
VerifyParameterAttrs(Attr.Attrs, Ty, Attr.Index == 0, V);
if (Attr.Attrs.hasNestAttr()) {
if (Attr.Attrs.hasAttribute(Attributes::Nest)) {
Assert1(!SawNest, "More than one parameter has attribute nest!", V);
SawNest = true;
}
if (Attr.Attrs.hasStructRetAttr())
if (Attr.Attrs.hasAttribute(Attributes::StructRet))
Assert1(Attr.Index == 1, "Attribute sret not on first parameter!", V);
}