From f2e89e00b4c4ecfa5a092a479ccab1ed8677eede Mon Sep 17 00:00:00 2001 From: Bill Wendling Date: Thu, 20 Sep 2012 16:27:05 +0000 Subject: [PATCH] Make the 'get*AlignmentFromAttr' functions into member functions within the Attributes class. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@164308 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Attributes.h | 40 +++++++++++++++------------- lib/AsmParser/LLParser.cpp | 2 +- lib/CodeGen/MachineFunction.cpp | 4 +-- lib/Target/CppBackend/CPPBackend.cpp | 2 +- lib/VMCore/Attributes.cpp | 15 ++++++----- 5 files changed, 33 insertions(+), 30 deletions(-) diff --git a/include/llvm/Attributes.h b/include/llvm/Attributes.h index 01b3be8cb60..2a7e0dea4fd 100644 --- a/include/llvm/Attributes.h +++ b/include/llvm/Attributes.h @@ -205,6 +205,24 @@ public: return Bits & Attribute::StackAlignment_i; } + /// This returns the alignment field of an attribute as a byte alignment + /// value. + unsigned getAlignment() const { + if (!hasAlignmentAttr()) + return 0; + + return 1U << ((getRawAlignment() >> 16) - 1); + } + + /// This returns the stack alignment field of an attribute as a byte alignment + /// value. + unsigned getStackAlignment() const { + if (!hasStackAlignmentAttr()) + return 0; + + return 1U << ((getRawStackAlignment() >> 26) - 1); + } + // This is a "safe bool() operator". operator const void *() const { return Bits ? this : 0; } bool isEmptyOrSingleton() const { return (Bits & (Bits - 1)) == 0; } @@ -212,8 +230,9 @@ public: return Bits == Attrs.Bits; } bool operator != (const Attributes &Attrs) const { - return Bits != Attrs.Bits; + return !(this == Attrs); } + Attributes operator | (const Attributes &Attrs) const { return Attributes(Bits | Attrs.Bits); } @@ -294,14 +313,6 @@ inline Attributes constructAlignmentFromInt(unsigned i) { return Attributes((Log2_32(i)+1) << 16); } -/// This returns the alignment field of an attribute as a byte alignment value. -inline unsigned getAlignmentFromAttrs(Attributes A) { - if (!A.hasAlignmentAttr()) - return 0; - - return 1U << ((A.getRawAlignment() >> 16) - 1); -} - /// This turns an int stack alignment (which must be a power of 2) into /// the form used internally in Attributes. inline Attributes constructStackAlignmentFromInt(unsigned i) { @@ -314,15 +325,6 @@ inline Attributes constructStackAlignmentFromInt(unsigned i) { return Attributes((Log2_32(i)+1) << 26); } -/// This returns the stack alignment field of an attribute as a byte alignment -/// value. -inline unsigned getStackAlignmentFromAttrs(Attributes A) { - if (!A.hasStackAlignmentAttr()) - return 0; - - return 1U << ((A.getRawStackAlignment() >> 26) - 1); -} - /// This returns an integer containing an encoding of all the /// LLVM attributes found in the given attribute bitset. Any /// change to this encoding is a breaking change to bitcode @@ -450,7 +452,7 @@ public: /// getParamAlignment - Return the alignment for the specified function /// parameter. unsigned getParamAlignment(unsigned Idx) const { - return Attribute::getAlignmentFromAttrs(getAttributes(Idx)); + return getAttributes(Idx).getAlignment(); } /// hasAttrSomewhere - Return true if the specified attribute is set for at diff --git a/lib/AsmParser/LLParser.cpp b/lib/AsmParser/LLParser.cpp index 2e4af3abb76..c1d5272ca50 100644 --- a/lib/AsmParser/LLParser.cpp +++ b/lib/AsmParser/LLParser.cpp @@ -2717,7 +2717,7 @@ bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) { // If the alignment was parsed as an attribute, move to the alignment field. if (FuncAttrs & Attribute::Alignment) { - Alignment = Attribute::getAlignmentFromAttrs(FuncAttrs); + Alignment = FuncAttrs.getAlignment(); FuncAttrs &= ~Attribute::Alignment; } diff --git a/lib/CodeGen/MachineFunction.cpp b/lib/CodeGen/MachineFunction.cpp index 328722bad48..304e39e1592 100644 --- a/lib/CodeGen/MachineFunction.cpp +++ b/lib/CodeGen/MachineFunction.cpp @@ -60,8 +60,8 @@ MachineFunction::MachineFunction(const Function *F, const TargetMachine &TM, MFInfo = 0; FrameInfo = new (Allocator) MachineFrameInfo(*TM.getFrameLowering()); if (Fn->hasFnAttr(Attribute::StackAlignment)) - FrameInfo->ensureMaxAlignment(Attribute::getStackAlignmentFromAttrs( - Fn->getAttributes().getFnAttributes())); + FrameInfo->ensureMaxAlignment(Fn->getAttributes(). + getFnAttributes().getStackAlignment()); ConstantPool = new (Allocator) MachineConstantPool(TM.getTargetData()); Alignment = TM.getTargetLowering()->getMinFunctionAlignment(); // FIXME: Shouldn't use pref alignment if explicit alignment is set on Fn. diff --git a/lib/Target/CppBackend/CPPBackend.cpp b/lib/Target/CppBackend/CPPBackend.cpp index 4ddcd38aca6..444da2bb21e 100644 --- a/lib/Target/CppBackend/CPPBackend.cpp +++ b/lib/Target/CppBackend/CPPBackend.cpp @@ -508,7 +508,7 @@ void CppWriter::printAttributes(const AttrListPtr &PAL, #undef HANDLE_ATTR if (attrs & Attribute::StackAlignment) Out << " | Attribute::constructStackAlignmentFromInt(" - << Attribute::getStackAlignmentFromAttrs(attrs) + << attrs.getStackAlignment() << ")"; attrs &= ~Attribute::StackAlignment; assert(attrs == 0 && "Unhandled attribute!"); diff --git a/lib/VMCore/Attributes.cpp b/lib/VMCore/Attributes.cpp index 3a87da44dd1..af8163fd40e 100644 --- a/lib/VMCore/Attributes.cpp +++ b/lib/VMCore/Attributes.cpp @@ -80,12 +80,12 @@ std::string Attributes::getAsString() const { Result += "address_safety "; if (hasStackAlignmentAttr()) { Result += "alignstack("; - Result += utostr(Attribute::getStackAlignmentFromAttrs(*this)); + Result += utostr(getStackAlignment()); Result += ") "; } if (hasAlignmentAttr()) { Result += "align "; - Result += utostr(Attribute::getAlignmentFromAttrs(*this)); + Result += utostr(getAlignment()); Result += " "; } // Trim the trailing space. @@ -174,7 +174,7 @@ AttrListPtr AttrListPtr::get(ArrayRef Attrs) { #ifndef NDEBUG for (unsigned i = 0, e = Attrs.size(); i != e; ++i) { - assert(Attrs[i].Attrs != Attribute::None && + assert(Attrs[i].Attrs.hasAttributes() && "Pointless attribute!"); assert((!i || Attrs[i-1].Index < Attrs[i].Index) && "Misordered AttributesList!"); @@ -247,13 +247,14 @@ const AttributeWithIndex &AttrListPtr::getSlot(unsigned Slot) const { /// returned. Attributes for the result are denoted with Idx = 0. /// Function notes are denoted with idx = ~0. Attributes AttrListPtr::getAttributes(unsigned Idx) const { - if (AttrList == 0) return Attribute::None; + if (AttrList == 0) return Attributes(); const SmallVector &Attrs = AttrList->Attrs; for (unsigned i = 0, e = Attrs.size(); i != e && Attrs[i].Index <= Idx; ++i) if (Attrs[i].Index == Idx) return Attrs[i].Attrs; - return Attribute::None; + + return Attributes(); } /// hasAttrSomewhere - Return true if the specified attribute is set for at @@ -274,8 +275,8 @@ AttrListPtr AttrListPtr::addAttr(unsigned Idx, Attributes Attrs) const { #ifndef NDEBUG // FIXME it is not obvious how this should work for alignment. // For now, say we can't change a known alignment. - unsigned OldAlign = Attribute::getAlignmentFromAttrs(OldAttrs); - unsigned NewAlign = Attribute::getAlignmentFromAttrs(Attrs); + unsigned OldAlign = OldAttrs.getAlignment(); + unsigned NewAlign = Attrs.getAlignment(); assert((!OldAlign || !NewAlign || OldAlign == NewAlign) && "Attempt to change alignment!"); #endif -- 2.34.1