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

Make AttributeSet::getFnAttributes() return an AttributeSet instead of an Attribute.

Browse Source 
This is more code to isolate the use of the Attribute class to that of just
holding one attribute instead of a collection of attributes.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@173094 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Bill Wendling 2013-01-21 21:57:28 +00:00
parent 8e528100d2
commit c5f1bc88a2
6 changed files with 80 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
include/llvm/IR/Attributes.h
View File

@ -183,43 +183,13 @@ template<> struct DenseMapInfo<Attribute::AttrKind> {
}
};
//===----------------------------------------------------------------------===//
/// \class
/// \brief This is just a pair of values to associate a set of attributes with
/// an index.
struct AttributeWithIndex {
Attribute Attrs; ///< The attributes that are set, or'd together.
Constant *Val; ///< Value attached to attribute, e.g. alignment.
unsigned Index; ///< Index of the parameter for which the attributes apply.
///< Index 0 is used for return value attributes.
///< Index ~0U is used for function attributes.
static AttributeWithIndex get(LLVMContext &C, unsigned Idx,
ArrayRef<Attribute::AttrKind> Attrs) {
return get(Idx, Attribute::get(C, Attrs));
}
static AttributeWithIndex get(unsigned Idx, Attribute Attrs) {
AttributeWithIndex P;
P.Index = Idx;
P.Attrs = Attrs;
P.Val = 0;
return P;
}
static AttributeWithIndex get(unsigned Idx, Attribute Attrs, Constant *Val) {
AttributeWithIndex P;
P.Index = Idx;
P.Attrs = Attrs;
P.Val = Val;
return P;
}
};
//===----------------------------------------------------------------------===//
// AttributeSet Smart Pointer
//===----------------------------------------------------------------------===//
class AttrBuilder;
class AttributeSetImpl;
struct AttributeWithIndex;
//===----------------------------------------------------------------------===//
/// \class
@ -289,9 +259,7 @@ public:
}
/// \brief The function attributes are returned.
Attribute getFnAttributes() const {
return getAttributes(FunctionIndex);
}
AttributeSet getFnAttributes() const;
/// \brief Return the alignment for the specified function parameter.
unsigned getParamAlignment(unsigned Idx) const;
@ -352,6 +320,39 @@ public:
void dump() const;
};
//===----------------------------------------------------------------------===//
/// \class
/// \brief This is just a pair of values to associate a set of attributes with
/// an index.
struct AttributeWithIndex {
Attribute Attrs; ///< The attributes that are set, or'd together.
Constant *Val; ///< Value attached to attribute, e.g. alignment.
unsigned Index; ///< Index of the parameter for which the attributes apply.
///< Index 0 is used for return value attributes.
///< Index ~0U is used for function attributes.
// FIXME: These methods all need to be revised. The first one is temporary.
static AttributeWithIndex get(LLVMContext &C, unsigned Idx, AttributeSet AS);
static AttributeWithIndex get(LLVMContext &C, unsigned Idx,
ArrayRef<Attribute::AttrKind> Attrs) {
return get(Idx, Attribute::get(C, Attrs));
}
static AttributeWithIndex get(unsigned Idx, Attribute Attrs) {
AttributeWithIndex P;
P.Index = Idx;
P.Attrs = Attrs;
P.Val = 0;
return P;
}
static AttributeWithIndex get(unsigned Idx, Attribute Attrs, Constant *Val) {
AttributeWithIndex P;
P.Index = Idx;
P.Attrs = Attrs;
P.Val = Val;
return P;
}
};
//===----------------------------------------------------------------------===//
/// \class
/// \brief This class is used in conjunction with the Attribute::get method to

2
lib/IR/AttributeImpl.h
View File

@ -39,6 +39,8 @@ public:
ArrayRef<Constant*> values);
AttributeImpl(LLVMContext &C, StringRef data);
LLVMContext &getContext() { return Context; }
ArrayRef<Constant*> getValues() const { return Vals; }
bool hasAttribute(Attribute::AttrKind A) const;

20
lib/IR/Attributes.cpp
View File

@ -529,10 +529,30 @@ void AttributeImpl::Profile(FoldingSetNodeID &ID, Constant *Data,
#endif
}
//===----------------------------------------------------------------------===//
// AttributeWithIndex Definition
//===----------------------------------------------------------------------===//
AttributeWithIndex AttributeWithIndex::get(LLVMContext &C, unsigned Idx,
AttributeSet AS) {
// FIXME: This is temporary, but necessary for the conversion.
AttrBuilder B(AS, Idx);
return get(Idx, Attribute::get(C, B));
}
//===----------------------------------------------------------------------===//
// AttributeSetImpl Definition
//===----------------------------------------------------------------------===//
AttributeSet AttributeSet::getFnAttributes() const {
// FIXME: Remove.
return AttrList ?
AttributeSet::get(AttrList->getContext(),
AttributeWithIndex::get(FunctionIndex,
getAttributes(FunctionIndex))) :
AttributeSet();
}
AttributeSet AttributeSet::get(LLVMContext &C,
ArrayRef<AttributeWithIndex> Attrs) {
// If there are no attributes then return a null AttributesList pointer.

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

@ -591,7 +591,8 @@ CallGraphNode *ArgPromotion::DoPromotion(Function *F,
// Add any function attributes.
if (PAL.hasAttributes(AttributeSet::FunctionIndex))
AttributesVec.push_back(AttributeWithIndex::get(AttributeSet::FunctionIndex,
AttributesVec.push_back(AttributeWithIndex::get(FTy->getContext(),
AttributeSet::FunctionIndex,
PAL.getFnAttributes()));
Type *RetTy = FTy->getReturnType();
@ -719,7 +720,8 @@ CallGraphNode *ArgPromotion::DoPromotion(Function *F,
// Add any function attributes.
if (CallPAL.hasAttributes(AttributeSet::FunctionIndex))
AttributesVec.push_back(AttributeWithIndex::get(AttributeSet::FunctionIndex,
AttributesVec.push_back(AttributeWithIndex::get(Call->getContext(),
AttributeSet::FunctionIndex,
CallPAL.getFnAttributes()));
Instruction *New;

24
lib/Transforms/IPO/DeadArgumentElimination.cpp
View File

@ -276,10 +276,10 @@ bool DAE::DeleteDeadVarargs(Function &Fn) {
SmallVector<AttributeWithIndex, 8> AttributesVec;
for (unsigned i = 0; PAL.getSlot(i).Index <= NumArgs; ++i)
AttributesVec.push_back(PAL.getSlot(i));
Attribute FnAttrs = PAL.getFnAttributes();
if (PAL.hasAttributes(AttributeSet::FunctionIndex))
AttributesVec.push_back(AttributeWithIndex::get(AttributeSet::FunctionIndex,
FnAttrs));
AttributesVec.push_back(AttributeWithIndex::get(Fn.getContext(),
AttributeSet::FunctionIndex,
PAL.getFnAttributes()));
PAL = AttributeSet::get(Fn.getContext(), AttributesVec);
}
@ -702,10 +702,8 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) {
// The existing function return attributes.
Attribute RAttrs = PAL.getRetAttributes();
Attribute FnAttrs = PAL.getFnAttributes();
// Find out the new return value.
Type *RetTy = FTy->getReturnType();
Type *NRetTy = NULL;
unsigned RetCount = NumRetVals(F);
@ -801,9 +799,10 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) {
}
}
if (FnAttrs.hasAttributes())
AttributesVec.push_back(AttributeWithIndex::get(AttributeSet::FunctionIndex,
FnAttrs));
if (PAL.hasAttributes(AttributeSet::FunctionIndex))
AttributesVec.push_back(AttributeWithIndex::get(F->getContext(),
AttributeSet::FunctionIndex,
PAL.getFnAttributes()));
// Reconstruct the AttributesList based on the vector we constructed.
AttributeSet NewPAL = AttributeSet::get(F->getContext(), AttributesVec);
@ -837,7 +836,7 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) {
// The call return attributes.
Attribute RAttrs = CallPAL.getRetAttributes();
Attribute FnAttrs = CallPAL.getFnAttributes();
// Adjust in case the function was changed to return void.
RAttrs =
Attribute::get(NF->getContext(), AttrBuilder(RAttrs).
@ -869,9 +868,10 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) {
AttributesVec.push_back(AttributeWithIndex::get(Args.size(), Attrs));
}
if (FnAttrs.hasAttributes())
AttributesVec.push_back(AttributeWithIndex::get(AttributeSet::FunctionIndex,
FnAttrs));
if (CallPAL.hasAttributes(AttributeSet::FunctionIndex))
AttributesVec.push_back(AttributeWithIndex::get(Call->getContext(),
AttributeSet::FunctionIndex,
CallPAL.getFnAttributes()));
// Reconstruct the AttributesList based on the vector we constructed.
AttributeSet NewCallPAL = AttributeSet::get(F->getContext(), AttributesVec);

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

@ -1175,16 +1175,17 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) {
}
}
Attribute FnAttrs = CallerPAL.getFnAttributes();
AttributeSet FnAttrs = CallerPAL.getFnAttributes();
if (CallerPAL.hasAttributes(AttributeSet::FunctionIndex))
attrVec.push_back(AttributeWithIndex::get(AttributeSet::FunctionIndex,
attrVec.push_back(AttributeWithIndex::get(Callee->getContext(),
AttributeSet::FunctionIndex,
FnAttrs));
if (NewRetTy->isVoidTy())
Caller->setName(""); // Void type should not have a name.
const AttributeSet &NewCallerPAL = AttributeSet::get(Callee->getContext(),
attrVec);
attrVec);
Instruction *NC;
if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) {
@ -1319,10 +1320,10 @@ InstCombiner::transformCallThroughTrampoline(CallSite CS,
}
// Add any function attributes.
Attr = Attrs.getFnAttributes();
if (Attrs.hasAttributes(AttributeSet::FunctionIndex))
NewAttrs.push_back(AttributeWithIndex::get(AttributeSet::FunctionIndex,
Attr));
NewAttrs.push_back(AttributeWithIndex::get(FTy->getContext(),
AttributeSet::FunctionIndex,
Attrs.getFnAttributes()));
// The trampoline may have been bitcast to a bogus type (FTy).
// Handle this by synthesizing a new function type, equal to FTy