/// for the result are denoted with Idx = 0.
Attribute getAttributes(unsigned Idx) const;
+ /// \brief Add the specified attribute at the specified index to this
+ /// attribute list. Since attribute lists are immutable, this returns the new
+ /// list.
+ AttributeSet addAttr(LLVMContext &C, unsigned Idx, Attribute Attrs) const;
+
explicit AttributeSet(AttributeSetImpl *LI) : AttrList(LI) {}
public:
AttributeSet() : AttrList(0) {}
static AttributeSet get(LLVMContext &C, ArrayRef<AttributeWithIndex> Attrs);
static AttributeSet get(LLVMContext &C, unsigned Idx, AttrBuilder &B);
- /// \brief Add the specified attribute at the specified index to this
- /// attribute list. Since attribute lists are immutable, this returns the new
- /// list.
- AttributeSet addAttr(LLVMContext &C, unsigned Idx, Attribute Attrs) const;
+ /// \brief Add an attribute to the attribute set at the given index. Since
+ /// attribute sets are immutable, this returns a new set.
+ AttributeSet addAttribute(LLVMContext &C, unsigned Idx,
+ Attribute::AttrKind Attr) const;
/// \brief Add attributes to the attribute set at the given index. Since
/// attribute sets are immutable, this returns a new set.
/// the LLVM attributes that have been decoded from the given integer. This
/// function must stay in sync with 'encodeLLVMAttributesForBitcode'.
Attribute Attribute::decodeLLVMAttributesForBitcode(LLVMContext &C,
- uint64_t EncodedAttrs) {
+ uint64_t EncodedAttrs) {
// The alignment is stored as a 16-bit raw value from bits 31--16. We shift
// the bits above 31 down by 11 bits.
unsigned Alignment = (EncodedAttrs & (0xffffULL << 16)) >> 16;
I = Attribute::AttrKind(I + 1)) {
if (uint64_t A = (Val & AttributeImpl::getAttrMask(I))) {
Attrs.insert(I);
-
+
if (I == Attribute::Alignment)
Alignment = 1ULL << ((A >> 16) - 1);
else if (I == Attribute::StackAlignment)
StackAlignment = 1ULL << ((A >> 26)-1);
}
}
-
+
return *this;
}
-AttrBuilder &AttrBuilder::addAttributes(const Attribute &A) {
- uint64_t Mask = A.Raw();
+AttrBuilder &AttrBuilder::addAttributes(const Attribute &Attr) {
+ uint64_t Mask = Attr.Raw();
for (Attribute::AttrKind I = Attribute::None; I != Attribute::EndAttrKinds;
- I = Attribute::AttrKind(I + 1)) {
- if (uint64_t A = (Mask & AttributeImpl::getAttrMask(I))) {
+ I = Attribute::AttrKind(I + 1))
+ if ((Mask & AttributeImpl::getAttrMask(I)) != 0)
Attrs.insert(I);
- if (I == Attribute::Alignment)
- Alignment = 1ULL << ((A >> 16) - 1);
- else if (I == Attribute::StackAlignment)
- StackAlignment = 1ULL << ((A >> 26)-1);
- }
- }
-
+ if (Attr.getAlignment())
+ Alignment = Attr.getAlignment();
+ if (Attr.getStackAlignment())
+ StackAlignment = Attr.getStackAlignment();
return *this;
}
// AttributeWithIndexes that then are used to create the AttributeSet.
if (!B.hasAttributes())
return AttributeSet();
-
- uint64_t Mask = 0;
-
- for (AttrBuilder::iterator I = B.begin(), E = B.end(); I != E; ++I)
- Mask |= AttributeImpl::getAttrMask(*I);
-
- Attribute A = Attribute::decodeLLVMAttributesForBitcode(C, Mask);
- if (B.getAlignment())
- A.setAlignment(B.getAlignment());
- if (B.getStackAlignment())
- A.setStackAlignment(B.getStackAlignment());
- return get(C, AttributeWithIndex::get(Idx, A));
+ return get(C, AttributeWithIndex::get(Idx, Attribute::get(C, B)));
}
//===----------------------------------------------------------------------===//
}
/// getAttributes - The attributes for the specified index are returned.
-/// Attributes for the result are denoted with Idx = 0. Function attributes are
-/// denoted with Idx = ~0.
Attribute AttributeSet::getAttributes(unsigned Idx) const {
if (AttrList == 0) return Attribute();
return false;
}
+AttributeSet AttributeSet::addAttribute(LLVMContext &C, unsigned Idx,
+ Attribute::AttrKind Attr) const {
+ return addAttr(C, Idx, Attribute::get(C, Attr));
+}
+
AttributeSet AttributeSet::addAttributes(LLVMContext &C, unsigned Idx,
AttributeSet Attrs) const {
return addAttr(C, Idx, Attrs.getAttributes(Idx));
const AttributeSet PAL = Func->getAttributes();
AttrBuilder B(PA);
const AttributeSet PALnew =
- PAL.addAttr(Func->getContext(), AttributeSet::FunctionIndex,
- Attribute::get(Func->getContext(), B));
+ PAL.addFnAttributes(Func->getContext(),
+ AttributeSet::get(Func->getContext(),
+ AttributeSet::FunctionIndex, B));
Func->setAttributes(PALnew);
}
CallSite Call = CallSite(unwrap<Instruction>(Instr));
AttrBuilder B(PA);
Call.setAttributes(
- Call.getAttributes().addAttr(Call->getContext(), index,
- Attribute::get(Call->getContext(), B)));
+ Call.getAttributes().addAttributes(Call->getContext(), index,
+ AttributeSet::get(Call->getContext(),
+ index, B)));
}
void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index,
CallSite Call = CallSite(unwrap<Instruction>(Instr));
AttrBuilder B;
B.addAlignmentAttr(align);
- Call.setAttributes(Call.getAttributes().addAttr(Call->getContext(), index,
- Attribute::get(Call->getContext(), B)));
+ Call.setAttributes(Call.getAttributes()
+ .addAttributes(Call->getContext(), index,
+ AttributeSet::get(Call->getContext(),
+ index, B)));
}
/*--.. Operations on call instructions (only) ..............................--*/
void Function::addAttribute(unsigned i, Attribute attr) {
AttributeSet PAL = getAttributes();
- PAL = PAL.addAttr(getContext(), i, attr);
+ AttrBuilder B(attr);
+ PAL = PAL.addAttributes(getContext(), i,
+ AttributeSet::get(getContext(), i, B));
setAttributes(PAL);
}
void CallInst::addAttribute(unsigned i, Attribute attr) {
AttributeSet PAL = getAttributes();
- PAL = PAL.addAttr(getContext(), i, attr);
+ AttrBuilder B(attr);
+ PAL = PAL.addAttributes(getContext(), i,
+ AttributeSet::get(getContext(), i, B));
setAttributes(PAL);
}
void InvokeInst::addAttribute(unsigned i, Attribute attr) {
AttributeSet PAL = getAttributes();
- PAL = PAL.addAttr(getContext(), i, attr);
+ AttrBuilder B(attr);
+ PAL = PAL.addAttributes(getContext(), i,
+ AttributeSet::get(getContext(), i, B));
setAttributes(PAL);
}
Function *F = (*I)->getFunction();
const AttributeSet &PAL = F->getAttributes();
- const AttributeSet &NPAL = PAL.addAttr(F->getContext(), ~0,
- Attribute::get(F->getContext(),
- NewAttributes));
+ const AttributeSet &NPAL =
+ PAL.addFnAttributes(F->getContext(),
+ AttributeSet::get(F->getContext(),
+ AttributeSet::FunctionIndex,
+ NewAttributes));
if (PAL != NPAL) {
MadeChange = true;
F->setAttributes(NPAL);
Type *Params[] = { I8X };
FunctionType *FTy = FunctionType::get(I8X, Params, /*isVarArg=*/false);
AttributeSet Attribute =
- AttributeSet().addAttr(M->getContext(), AttributeSet::FunctionIndex,
- Attribute::get(C, Attribute::NoUnwind));
+ AttributeSet().addAttribute(M->getContext(), AttributeSet::FunctionIndex,
+ Attribute::NoUnwind);
RetainRVCallee =
M->getOrInsertFunction("objc_retainAutoreleasedReturnValue", FTy,
Attribute);
Type *Params[] = { I8X };
FunctionType *FTy = FunctionType::get(I8X, Params, /*isVarArg=*/false);
AttributeSet Attribute =
- AttributeSet().addAttr(M->getContext(), AttributeSet::FunctionIndex,
- Attribute::get(C, Attribute::NoUnwind));
+ AttributeSet().addAttribute(M->getContext(), AttributeSet::FunctionIndex,
+ Attribute::NoUnwind);
AutoreleaseRVCallee =
M->getOrInsertFunction("objc_autoreleaseReturnValue", FTy,
Attribute);
LLVMContext &C = M->getContext();
Type *Params[] = { PointerType::getUnqual(Type::getInt8Ty(C)) };
AttributeSet Attribute =
- AttributeSet().addAttr(M->getContext(), AttributeSet::FunctionIndex,
- Attribute::get(C, Attribute::NoUnwind));
+ AttributeSet().addAttribute(M->getContext(), AttributeSet::FunctionIndex,
+ Attribute::NoUnwind);
ReleaseCallee =
M->getOrInsertFunction(
"objc_release",
LLVMContext &C = M->getContext();
Type *Params[] = { PointerType::getUnqual(Type::getInt8Ty(C)) };
AttributeSet Attribute =
- AttributeSet().addAttr(M->getContext(), AttributeSet::FunctionIndex,
- Attribute::get(C, Attribute::NoUnwind));
+ AttributeSet().addAttribute(M->getContext(), AttributeSet::FunctionIndex,
+ Attribute::NoUnwind);
RetainCallee =
M->getOrInsertFunction(
"objc_retain",
LLVMContext &C = M->getContext();
Type *Params[] = { PointerType::getUnqual(Type::getInt8Ty(C)) };
AttributeSet Attribute =
- AttributeSet().addAttr(M->getContext(), AttributeSet::FunctionIndex,
- Attribute::get(C, Attribute::NoUnwind));
+ AttributeSet().addAttribute(M->getContext(), AttributeSet::FunctionIndex,
+ Attribute::NoUnwind);
AutoreleaseCallee =
M->getOrInsertFunction(
"objc_autorelease",
Type *I8XX = PointerType::getUnqual(I8X);
Type *Params[] = { I8XX, I8X };
- AttributeSet Attribute = AttributeSet()
- .addAttr(M->getContext(), AttributeSet::FunctionIndex,
- Attribute::get(C, Attribute::NoUnwind))
- .addAttr(M->getContext(), 1, Attribute::get(C, Attribute::NoCapture));
+ AttributeSet Attr = AttributeSet()
+ .addAttribute(M->getContext(), AttributeSet::FunctionIndex,
+ Attribute::NoUnwind)
+ .addAttribute(M->getContext(), 1, Attribute::NoCapture);
StoreStrongCallee =
M->getOrInsertFunction(
"objc_storeStrong",
FunctionType::get(Type::getVoidTy(C), Params, /*isVarArg=*/false),
- Attribute);
+ Attr);
}
return StoreStrongCallee;
}
Type *Params[] = { I8X };
FunctionType *FTy = FunctionType::get(I8X, Params, /*isVarArg=*/false);
AttributeSet Attribute =
- AttributeSet().addAttr(M->getContext(), AttributeSet::FunctionIndex,
- Attribute::get(C, Attribute::NoUnwind));
+ AttributeSet().addAttribute(M->getContext(), AttributeSet::FunctionIndex,
+ Attribute::NoUnwind);
RetainAutoreleaseCallee =
M->getOrInsertFunction("objc_retainAutorelease", FTy, Attribute);
}
Type *Params[] = { I8X };
FunctionType *FTy = FunctionType::get(I8X, Params, /*isVarArg=*/false);
AttributeSet Attribute =
- AttributeSet().addAttr(M->getContext(), AttributeSet::FunctionIndex,
- Attribute::get(C, Attribute::NoUnwind));
+ AttributeSet().addAttribute(M->getContext(), AttributeSet::FunctionIndex,
+ Attribute::NoUnwind);
RetainAutoreleaseRVCallee =
M->getOrInsertFunction("objc_retainAutoreleaseReturnValue", FTy,
Attribute);