class Attributes {
// Currently, we need less than 64 bits.
AttributesImpl Attrs;
-
+#if 0
+ enum Attribute {
+ None = 0, ///< No attributes have been set
+ ZExt = 1 << 0, ///< Zero extended before/after call
+ SExt = 1 << 1, ///< Sign extended before/after call
+ NoReturn = 1 << 2, ///< Mark the function as not returning
+ InReg = 1 << 3, ///< Force argument to be passed in register
+ StructRet = 1 << 4, ///< Hidden pointer to structure to return
+ NoUnwind = 1 << 5, ///< Function doesn't unwind stack
+ NoAlias = 1 << 6, ///< Considered to not alias after call
+ ByVal = 1 << 7, ///< Pass structure by value
+ Nest = 1 << 8, ///< Nested function static chain
+ ReadNone = 1 << 9, ///< Function does not access memory
+ ReadOnly = 1 << 10, ///< Function only reads from memory
+ NoInline = 1 << 11, ///< inline=never
+ AlwaysInline = 1 << 12, ///< inline=always
+ OptimizeForSize = 1 << 13, ///< opt_size
+ StackProtect = 1 << 14, ///< Stack protection.
+ StackProtectReq = 1 << 15, ///< Stack protection required.
+ Alignment = 31 << 16, ///< Alignment of parameter (5 bits)
+ ///< stored as log2 of alignment with +1 bias
+ ///< 0 means unaligned different from align 1
+ NoCapture = 1 << 21, ///< Function creates no aliases of pointer
+ NoRedZone = 1 << 22, ///< Disable redzone
+ NoImplicitFloat = 1 << 23, ///< Disable implicit floating point insts
+ Naked = 1 << 24, ///< Naked function
+ InlineHint = 1 << 25, ///< Source said inlining was desirable
+ StackAlignment = 7 << 26, ///< Alignment of stack for function (3 bits)
+ ///< stored as log2 of alignment with +1 bias 0
+ ///< means unaligned (different from
+ ///< alignstack={1))
+ ReturnsTwice = 1 << 29, ///< Function can return twice
+ UWTable = 1 << 30, ///< Function must be in a unwind table
+ NonLazyBind = 1U << 31, ///< Function is called early and/or
+ ///< often, so lazy binding isn't worthwhile
+ AddressSafety = 1ULL << 32 ///< Address safety checking is on.
+ };
+#endif
explicit Attributes(AttributesImpl *A);
public:
Attributes() : Attrs(0) {}
explicit Attributes(uint64_t Val);
/*implicit*/ Attributes(Attribute::AttrConst Val);
+ Attributes(const Attributes &A);
class Builder {
friend class Attributes;
Builder() : Bits(0) {}
Builder(const Attributes &A) : Bits(A.Raw()) {}
+ void clear() { Bits = 0; }
+
+ bool hasAttributes() const;
+ bool hasAlignmentAttr() const;
+
+ uint64_t getAlignment() const;
+
void addAddressSafetyAttr();
void addAlwaysInlineAttr();
void addByValAttr();
void removeStructRetAttr();
void removeUWTableAttr();
void removeZExtAttr();
+
+ void removeAlignmentAttr();
+ void removeStackAlignmentAttr();
};
/// get - Return a uniquified Attributes object. This takes the uniquified
/// ParseOptionalAttrs - Parse a potentially empty attribute list. AttrKind
/// indicates what kind of attribute list this is: 0: function arg, 1: result,
/// 2: function attr.
-bool LLParser::ParseOptionalAttrs(Attributes &Attrs, unsigned AttrKind) {
- Attributes::Builder B;
+bool LLParser::ParseOptionalAttrs(Attributes::Builder &B, unsigned AttrKind) {
LocTy AttrLoc = Lex.getLoc();
bool HaveError = false;
+ B.clear();
+
while (1) {
lltok::Kind Token = Lex.getKind();
switch (Token) {
default: // End of attributes.
- Attrs = Attributes::get(B); // FIXME: Use the other version of get().
return HaveError;
case lltok::kw_zeroext: B.addZExtAttr(); break;
case lltok::kw_signext: B.addSExtAttr(); break;
// Parse the argument.
LocTy ArgLoc;
Type *ArgTy = 0;
- Attributes ArgAttrs;
+ Attributes::Builder ArgAttrs;
Value *V;
if (ParseType(ArgTy, ArgLoc))
return true;
// Otherwise, handle normal operands.
if (ParseOptionalAttrs(ArgAttrs, 0) || ParseValue(ArgTy, V, PFS))
return true;
- ArgList.push_back(ParamInfo(ArgLoc, V, ArgAttrs));
+ ArgList.push_back(ParamInfo(ArgLoc, V, Attributes::get(ArgAttrs)));
}
Lex.Lex(); // Lex the ')'.
} else {
LocTy TypeLoc = Lex.getLoc();
Type *ArgTy = 0;
- Attributes Attrs;
+ Attributes::Builder Attrs;
std::string Name;
if (ParseType(ArgTy) ||
if (!FunctionType::isValidArgumentType(ArgTy))
return Error(TypeLoc, "invalid type for function argument");
- ArgList.push_back(ArgInfo(TypeLoc, ArgTy, Attrs, Name));
+ ArgList.push_back(ArgInfo(TypeLoc, ArgTy, Attributes::get(Attrs), Name));
while (EatIfPresent(lltok::comma)) {
// Handle ... at end of arg list.
if (!ArgTy->isFirstClassType())
return Error(TypeLoc, "invalid type for function argument");
- ArgList.push_back(ArgInfo(TypeLoc, ArgTy, Attrs, Name));
+ ArgList.push_back(ArgInfo(TypeLoc, ArgTy, Attributes::get(Attrs), Name));
}
}
unsigned Linkage;
unsigned Visibility;
- Attributes RetAttrs;
+ Attributes::Builder RetAttrs;
CallingConv::ID CC;
Type *RetType = 0;
LocTy RetTypeLoc = Lex.getLoc();
SmallVector<ArgInfo, 8> ArgList;
bool isVarArg;
- Attributes FuncAttrs;
+ Attributes::Builder FuncAttrs;
std::string Section;
unsigned Alignment;
std::string GC;
return true;
// If the alignment was parsed as an attribute, move to the alignment field.
- if (FuncAttrs & Attribute::Alignment) {
+ if (FuncAttrs.hasAlignmentAttr()) {
Alignment = FuncAttrs.getAlignment();
- FuncAttrs &= ~Attribute::Alignment;
+ FuncAttrs.removeAlignmentAttr();
}
// Okay, if we got here, the function is syntactically valid. Convert types
SmallVector<AttributeWithIndex, 8> Attrs;
if (RetAttrs.hasAttributes())
- Attrs.push_back(AttributeWithIndex::get(0, RetAttrs));
+ Attrs.push_back(AttributeWithIndex::get(0, Attributes::get(RetAttrs)));
for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
ParamTypeList.push_back(ArgList[i].Ty);
}
if (FuncAttrs.hasAttributes())
- Attrs.push_back(AttributeWithIndex::get(~0, FuncAttrs));
+ Attrs.push_back(AttributeWithIndex::get(~0, Attributes::get(FuncAttrs)));
AttrListPtr PAL = AttrListPtr::get(Attrs);
/// OptionalAttrs 'to' TypeAndValue 'unwind' TypeAndValue
bool LLParser::ParseInvoke(Instruction *&Inst, PerFunctionState &PFS) {
LocTy CallLoc = Lex.getLoc();
- Attributes RetAttrs, FnAttrs;
+ Attributes::Builder RetAttrs, FnAttrs;
CallingConv::ID CC;
Type *RetType = 0;
LocTy RetTypeLoc;
// Set up the Attributes for the function.
SmallVector<AttributeWithIndex, 8> Attrs;
if (RetAttrs.hasAttributes())
- Attrs.push_back(AttributeWithIndex::get(0, RetAttrs));
+ Attrs.push_back(AttributeWithIndex::get(0, Attributes::get(RetAttrs)));
SmallVector<Value*, 8> Args;
return Error(CallLoc, "not enough parameters specified for call");
if (FnAttrs.hasAttributes())
- Attrs.push_back(AttributeWithIndex::get(~0, FnAttrs));
+ Attrs.push_back(AttributeWithIndex::get(~0, Attributes::get(FnAttrs)));
// Finish off the Attributes and check them
AttrListPtr PAL = AttrListPtr::get(Attrs);
/// ParameterList OptionalAttrs
bool LLParser::ParseCall(Instruction *&Inst, PerFunctionState &PFS,
bool isTail) {
- Attributes RetAttrs, FnAttrs;
+ Attributes::Builder RetAttrs, FnAttrs;
CallingConv::ID CC;
Type *RetType = 0;
LocTy RetTypeLoc;
// Set up the Attributes for the function.
SmallVector<AttributeWithIndex, 8> Attrs;
if (RetAttrs.hasAttributes())
- Attrs.push_back(AttributeWithIndex::get(0, RetAttrs));
+ Attrs.push_back(AttributeWithIndex::get(0, Attributes::get(RetAttrs)));
SmallVector<Value*, 8> Args;
return Error(CallLoc, "not enough parameters specified for call");
if (FnAttrs.hasAttributes())
- Attrs.push_back(AttributeWithIndex::get(~0, FnAttrs));
+ Attrs.push_back(AttributeWithIndex::get(~0, Attributes::get(FnAttrs)));
// Finish off the Attributes and check them
AttrListPtr PAL = AttrListPtr::get(Attrs);