[llvm-commits] [llvm] r148553 - in /llvm/trunk: docs/LangRef.html include/llvm-c/Core.h include/llvm/Attributes.h lib/AsmParser/LLLexer.cpp lib/AsmParser/LLParser.cpp lib/AsmParser/LLParser.h lib/AsmParser/LLToken.h lib/Bitcode/Reader/BitcodeRead

Kostya Serebryany kcc at google.com
Fri Jan 20 12:52:42 CST 2012


On Fri, Jan 20, 2012 at 10:31 AM, David Blaikie <dblaikie at gmail.com> wrote:

> On Fri, Jan 20, 2012 at 9:56 AM, Kostya Serebryany <kcc at google.com> wrote:
> > Author: kcc
> > Date: Fri Jan 20 11:56:17 2012
> > New Revision: 148553
> >
> > URL: http://llvm.org/viewvc/llvm-project?rev=148553&view=rev
> > Log:
> > Extend Attributes to 64 bits
> >
> > Problem: LLVM needs more function attributes than currently available
> (32 bits).
> > One such proposed attribute is "address_safety", which shows that a
> function is being checked for address safety (by AddressSanitizer,
> SAFECode, etc).
> >
> > Solution:
> > - extend the Attributes from 32 bits to 64-bits
> > - wrap the object into a class so that unsigned is never erroneously
> used instead
> > - change "unsigned" to "Attributes" throughout the code, including one
> place in clang.
> > - the class has no "operator uint64 ()", but it has "uint64_t Raw() " to
> support packing/unpacking.
> > - the class has "safe operator bool()" to support the common idiom:  if
> (Attributes attr = getAttrs()) useAttrs(attr);
>
> Oh, I didn't notice you'd done anything like this in the CR version.
> Just for the record - your implementation isn't terribly safe. It's
> safer than 'bool', that's for sure, but still has some limitations.
>
> In case it's of interest, I had included in a previous CR (that was
> never signed off) a full implementation of the Safe Bool style
> documented here ( http://www.artima.com/cppsource/safebool.html ) to
>

Yea, I've read this document. Impressive!
I've chosen void* as the simplest and safe enough idiom.
I don't think that code like
   Attributes attr;
   delete attr;
is likely to appear. Even if so, it will be detected by the run-time
library.

If/when we have a reusable safe bool class, we can use it here,
but I thought that adding such class into this patch would be an overkill.

--kcc


> be used by StringRef (or Twine) or something... if that'd be of
> interest I can pry it out as a separate patch.
>
> (to find my original patch you can probably look for something from
> this email address with twine and stringref in the title and a file
> attachment - it was sent out probably 6-9 months ago. I've been
> meaning to update it recently to get it back up to mainline
> compatibility)
>
> - David
>
> > - The CTOR from uint64_t is marked explicit, so I had to add a few
> explicit CTOR calls
> > - Add the new attribute "address_safety". Doing it in the same commit to
> check that attributes beyond first 32 bits actually work.
> > - Some of the functions from the Attribute namespace are worth moving
> inside the class, but I'd prefer to have it as a separate commit.
> >
> > Tested:
> > "make check" on Linux (32-bit and 64-bit) and Mac (10.6)
> > built/run spec CPU 2006 on Linux with clang -O2.
> >
> >
> > This change will break clang build in lib/CodeGen/CGCall.cpp.
> > The following patch will fix it.
> >
> > Modified:
> >    llvm/trunk/docs/LangRef.html
> >    llvm/trunk/include/llvm-c/Core.h
> >    llvm/trunk/include/llvm/Attributes.h
> >    llvm/trunk/lib/AsmParser/LLLexer.cpp
> >    llvm/trunk/lib/AsmParser/LLParser.cpp
> >    llvm/trunk/lib/AsmParser/LLParser.h
> >    llvm/trunk/lib/AsmParser/LLToken.h
> >    llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp
> >    llvm/trunk/lib/Bitcode/Writer/BitcodeWriter.cpp
> >    llvm/trunk/lib/CodeGen/Analysis.cpp
> >    llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp
> >    llvm/trunk/lib/Transforms/Scalar/CodeGenPrepare.cpp
> >    llvm/trunk/lib/VMCore/Attributes.cpp
> >    llvm/trunk/lib/VMCore/Core.cpp
> >    llvm/trunk/lib/VMCore/Verifier.cpp
> >    llvm/trunk/utils/llvm.grm
> >
> > Modified: llvm/trunk/docs/LangRef.html
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/docs/LangRef.html?rev=148553&r1=148552&r2=148553&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/docs/LangRef.html (original)
> > +++ llvm/trunk/docs/LangRef.html Fri Jan 20 11:56:17 2012
> > @@ -1143,6 +1143,10 @@
> >  </pre>
> >
> >  <dl>
> > +  <dt><tt><b>address_safety</b></tt></dt>
> > +  <dd>This attribute indicates that the address safety analysis
> > +  is enabled for this function.  </dd>
> > +
> >   <dt><tt><b>alignstack(&lt;<em>n</em>&gt;)</b></tt></dt>
> >   <dd>This attribute indicates that, when emitting the prologue and
> epilogue,
> >       the backend should forcibly align the stack pointer. Specify the
> >
> > Modified: llvm/trunk/include/llvm-c/Core.h
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm-c/Core.h?rev=148553&r1=148552&r2=148553&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/include/llvm-c/Core.h (original)
> > +++ llvm/trunk/include/llvm-c/Core.h Fri Jan 20 11:56:17 2012
> > @@ -118,7 +118,8 @@
> >     LLVMStackAlignment = 7<<26,
> >     LLVMReturnsTwice = 1 << 29,
> >     LLVMUWTable = 1 << 30,
> > -    LLVMNonLazyBind = 1 << 31
> > +    LLVMNonLazyBind = 1U << 31,
> > +    LLVMAddressSafety = 1ULL << 32,
> >  } LLVMAttribute;
> >
> >  typedef enum {
> >
> > Modified: llvm/trunk/include/llvm/Attributes.h
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Attributes.h?rev=148553&r1=148552&r2=148553&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/include/llvm/Attributes.h (original)
> > +++ llvm/trunk/include/llvm/Attributes.h Fri Jan 20 11:56:17 2012
> > @@ -23,7 +23,47 @@
> >  class Type;
> >
> >  /// Attributes - A bitset of attributes.
> > -typedef unsigned Attributes;
> > +class Attributes {
> > + public:
> > +  Attributes() : Bits(0) { }
> > +  explicit Attributes(uint64_t Val) : Bits(Val) { }
> > +  Attributes(const Attributes &Attrs) : Bits(Attrs.Bits) { }
> > +  // This is a "safe bool() operator".
> > +  operator const void *() const { return Bits ? this : 0; }
> > +  bool isEmptyOrSingleton() const { return (Bits & (Bits - 1)) == 0; }
> > +  Attributes &operator = (const Attributes &Attrs) {
> > +    Bits = Attrs.Bits;
> > +    return *this;
> > +  }
> > +  bool operator == (const Attributes &Attrs) const {
> > +    return Bits == Attrs.Bits;
> > +  }
> > +  bool operator != (const Attributes &Attrs) const {
> > +    return Bits != Attrs.Bits;
> > +  }
> > +  Attributes operator | (const Attributes &Attrs) const {
> > +    return Attributes(Bits | Attrs.Bits);
> > +  }
> > +  Attributes operator & (const Attributes &Attrs) const {
> > +    return Attributes(Bits & Attrs.Bits);
> > +  }
> > +  Attributes operator ^ (const Attributes &Attrs) const {
> > +    return Attributes(Bits ^ Attrs.Bits);
> > +  }
> > +  Attributes &operator |= (const Attributes &Attrs) {
> > +    Bits |= Attrs.Bits;
> > +    return *this;
> > +  }
> > +  Attributes &operator &= (const Attributes &Attrs) {
> > +    Bits &= Attrs.Bits;
> > +    return *this;
> > +  }
> > +  Attributes operator ~ () const { return Attributes(~Bits); }
> > +  uint64_t Raw() const { return Bits; }
> > + private:
> > +  // Currently, we need less than 64 bits.
> > +  uint64_t Bits;
> > +};
> >
> >  namespace Attribute {
> >
> > @@ -33,44 +73,45 @@
> >  /// results or the function itself.
> >  /// @brief Function attributes.
> >
> > -const Attributes None      = 0;     ///< No attributes have been set
> > -const Attributes ZExt      = 1<<0;  ///< Zero extended before/after call
> > -const Attributes SExt      = 1<<1;  ///< Sign extended before/after call
> > -const Attributes NoReturn  = 1<<2;  ///< Mark the function as not
> returning
> > -const Attributes InReg     = 1<<3;  ///< Force argument to be passed in
> register
> > -const Attributes StructRet = 1<<4;  ///< Hidden pointer to structure to
> return
> > -const Attributes NoUnwind  = 1<<5;  ///< Function doesn't unwind stack
> > -const Attributes NoAlias   = 1<<6;  ///< Considered to not alias after
> call
> > -const Attributes ByVal     = 1<<7;  ///< Pass structure by value
> > -const Attributes Nest      = 1<<8;  ///< Nested function static chain
> > -const Attributes ReadNone  = 1<<9;  ///< Function does not access memory
> > -const Attributes ReadOnly  = 1<<10; ///< Function only reads from memory
> > -const Attributes NoInline        = 1<<11; ///< inline=never
> > -const Attributes AlwaysInline    = 1<<12; ///< inline=always
> > -const Attributes OptimizeForSize = 1<<13; ///< opt_size
> > -const Attributes StackProtect    = 1<<14; ///< Stack protection.
> > -const Attributes StackProtectReq = 1<<15; ///< Stack protection
> required.
> > -const Attributes Alignment = 31<<16; ///< Alignment of parameter (5
> bits)
> > +const Attributes None      (0);     ///< No attributes have been set
> > +const Attributes ZExt      (1<<0);  ///< Zero extended before/after call
> > +const Attributes SExt      (1<<1);  ///< Sign extended before/after call
> > +const Attributes NoReturn  (1<<2);  ///< Mark the function as not
> returning
> > +const Attributes InReg     (1<<3);  ///< Force argument to be passed in
> register
> > +const Attributes StructRet (1<<4);  ///< Hidden pointer to structure to
> return
> > +const Attributes NoUnwind  (1<<5);  ///< Function doesn't unwind stack
> > +const Attributes NoAlias   (1<<6);  ///< Considered to not alias after
> call
> > +const Attributes ByVal     (1<<7);  ///< Pass structure by value
> > +const Attributes Nest      (1<<8);  ///< Nested function static chain
> > +const Attributes ReadNone  (1<<9);  ///< Function does not access memory
> > +const Attributes ReadOnly  (1<<10); ///< Function only reads from memory
> > +const Attributes NoInline        (1<<11); ///< inline=never
> > +const Attributes AlwaysInline    (1<<12); ///< inline=always
> > +const Attributes OptimizeForSize (1<<13); ///< opt_size
> > +const Attributes StackProtect    (1<<14); ///< Stack protection.
> > +const Attributes StackProtectReq (1<<15); ///< Stack protection
> required.
> > +const Attributes Alignment (31<<16); ///< Alignment of parameter (5
> bits)
> >                                      // stored as log2 of alignment with
> +1 bias
> >                                      // 0 means unaligned different from
> align 1
> > -const Attributes NoCapture = 1<<21; ///< Function creates no aliases of
> pointer
> > -const Attributes NoRedZone = 1<<22; /// disable redzone
> > -const Attributes NoImplicitFloat = 1<<23; /// disable implicit floating
> point
> > +const Attributes NoCapture (1<<21); ///< Function creates no aliases of
> pointer
> > +const Attributes NoRedZone (1<<22); /// disable redzone
> > +const Attributes NoImplicitFloat (1<<23); /// disable implicit floating
> point
> >                                           /// instructions.
> > -const Attributes Naked           = 1<<24; ///< Naked function
> > -const Attributes InlineHint      = 1<<25; ///< source said inlining was
> > +const Attributes Naked           (1<<24); ///< Naked function
> > +const Attributes InlineHint      (1<<25); ///< source said inlining was
> >                                           ///desirable
> > -const Attributes StackAlignment  = 7<<26; ///< Alignment of stack for
> > +const Attributes 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))
> > -const Attributes ReturnsTwice    = 1<<29; ///< Function can return twice
> > -const Attributes UWTable     = 1<<30;     ///< Function must be in a
> unwind
> > +const Attributes ReturnsTwice    (1<<29); ///< Function can return twice
> > +const Attributes UWTable     (1<<30);     ///< Function must be in a
> unwind
> >                                           ///table
> > -const Attributes NonLazyBind = 1U<<31;    ///< Function is called early
> and/or
> > +const Attributes NonLazyBind (1U<<31);    ///< Function is called early
> and/or
> >                                           ///  often, so lazy binding
> isn't
> >                                           ///  worthwhile.
> > +const Attributes AddressSafety(1ULL<<32); ///< Address safety checking
> is on.
> >
> >  /// Note that uwtable is about the ABI or the user mandating an entry
> in the
> >  /// unwind table. The nounwind attribute is about an exception passing
> by the
> > @@ -92,7 +133,7 @@
> >  const Attributes FunctionOnly = NoReturn | NoUnwind | ReadNone |
> ReadOnly |
> >   NoInline | AlwaysInline | OptimizeForSize | StackProtect |
> StackProtectReq |
> >   NoRedZone | NoImplicitFloat | Naked | InlineHint | StackAlignment |
> > -  UWTable | NonLazyBind | ReturnsTwice;
> > +  UWTable | NonLazyBind | ReturnsTwice | AddressSafety;
> >
> >  /// @brief Parameter attributes that do not apply to vararg call
> arguments.
> >  const Attributes VarArgsIncompatible = StructRet;
> > @@ -113,20 +154,20 @@
> >  inline Attributes constructAlignmentFromInt(unsigned i) {
> >   // Default alignment, allow the target to define how to align it.
> >   if (i == 0)
> > -    return 0;
> > +    return None;
> >
> >   assert(isPowerOf2_32(i) && "Alignment must be a power of two.");
> >   assert(i <= 0x40000000 && "Alignment too large.");
> > -  return (Log2_32(i)+1) << 16;
> > +  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) {
> >   Attributes Align = A & Attribute::Alignment;
> > -  if (Align == 0)
> > +  if (!Align)
> >     return 0;
> >
> > -  return 1U << ((Align >> 16) - 1);
> > +  return 1U << ((Align.Raw() >> 16) - 1);
> >  }
> >
> >  /// This turns an int stack alignment (which must be a power of 2) into
> > @@ -134,21 +175,21 @@
> >  inline Attributes constructStackAlignmentFromInt(unsigned i) {
> >   // Default alignment, allow the target to define how to align it.
> >   if (i == 0)
> > -    return 0;
> > +    return None;
> >
> >   assert(isPowerOf2_32(i) && "Alignment must be a power of two.");
> >   assert(i <= 0x100 && "Alignment too large.");
> > -  return (Log2_32(i)+1) << 26;
> > +  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) {
> >   Attributes StackAlign = A & Attribute::StackAlignment;
> > -  if (StackAlign == 0)
> > +  if (!StackAlign)
> >     return 0;
> >
> > -  return 1U << ((StackAlign >> 26) - 1);
> > +  return 1U << ((StackAlign.Raw() >> 26) - 1);
> >  }
> >
> >
> > @@ -242,7 +283,7 @@
> >   /// paramHasAttr - Return true if the specified parameter index has the
> >   /// specified attribute set.
> >   bool paramHasAttr(unsigned Idx, Attributes Attr) const {
> > -    return (getAttributes(Idx) & Attr) != 0;
> > +    return getAttributes(Idx) & Attr;
> >   }
> >
> >   /// getParamAlignment - Return the alignment for the specified function
> >
> > Modified: llvm/trunk/lib/AsmParser/LLLexer.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/AsmParser/LLLexer.cpp?rev=148553&r1=148552&r2=148553&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/lib/AsmParser/LLLexer.cpp (original)
> > +++ llvm/trunk/lib/AsmParser/LLLexer.cpp Fri Jan 20 11:56:17 2012
> > @@ -548,6 +548,7 @@
> >   KEYWORD(noimplicitfloat);
> >   KEYWORD(naked);
> >   KEYWORD(nonlazybind);
> > +  KEYWORD(address_safety);
> >
> >   KEYWORD(type);
> >   KEYWORD(opaque);
> >
> > Modified: llvm/trunk/lib/AsmParser/LLParser.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/AsmParser/LLParser.cpp?rev=148553&r1=148552&r2=148553&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/lib/AsmParser/LLParser.cpp (original)
> > +++ llvm/trunk/lib/AsmParser/LLParser.cpp Fri Jan 20 11:56:17 2012
> > @@ -874,7 +874,7 @@
> >  /// 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(unsigned &Attrs, unsigned AttrKind) {
> > +bool LLParser::ParseOptionalAttrs(Attributes &Attrs, unsigned AttrKind)
> {
> >   Attrs = Attribute::None;
> >   LocTy AttrLoc = Lex.getLoc();
> >
> > @@ -919,6 +919,7 @@
> >     case lltok::kw_noimplicitfloat: Attrs |= Attribute::NoImplicitFloat;
> break;
> >     case lltok::kw_naked:           Attrs |= Attribute::Naked; break;
> >     case lltok::kw_nonlazybind:     Attrs |= Attribute::NonLazyBind;
> break;
> > +    case lltok::kw_address_safety:  Attrs |= Attribute::AddressSafety;
> break;
> >
> >     case lltok::kw_alignstack: {
> >       unsigned Alignment;
> > @@ -1353,8 +1354,8 @@
> >     // Parse the argument.
> >     LocTy ArgLoc;
> >     Type *ArgTy = 0;
> > -    unsigned ArgAttrs1 = Attribute::None;
> > -    unsigned ArgAttrs2 = Attribute::None;
> > +    Attributes ArgAttrs1;
> > +    Attributes ArgAttrs2;
> >     Value *V;
> >     if (ParseType(ArgTy, ArgLoc))
> >       return true;
> > @@ -1394,7 +1395,7 @@
> >   } else {
> >     LocTy TypeLoc = Lex.getLoc();
> >     Type *ArgTy = 0;
> > -    unsigned Attrs;
> > +    Attributes Attrs;
> >     std::string Name;
> >
> >     if (ParseType(ArgTy) ||
> > @@ -1461,7 +1462,7 @@
> >   for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
> >     if (!ArgList[i].Name.empty())
> >       return Error(ArgList[i].Loc, "argument name invalid in function
> type");
> > -    if (ArgList[i].Attrs != 0)
> > +    if (ArgList[i].Attrs)
> >       return Error(ArgList[i].Loc,
> >                    "argument attributes invalid in function type");
> >   }
> > @@ -2586,7 +2587,8 @@
> >   LocTy LinkageLoc = Lex.getLoc();
> >   unsigned Linkage;
> >
> > -  unsigned Visibility, RetAttrs;
> > +  unsigned Visibility;
> > +  Attributes RetAttrs;
> >   CallingConv::ID CC;
> >   Type *RetType = 0;
> >   LocTy RetTypeLoc = Lex.getLoc();
> > @@ -2650,7 +2652,7 @@
> >
> >   SmallVector<ArgInfo, 8> ArgList;
> >   bool isVarArg;
> > -  unsigned FuncAttrs;
> > +  Attributes FuncAttrs;
> >   std::string Section;
> >   unsigned Alignment;
> >   std::string GC;
> > @@ -3162,7 +3164,7 @@
> >  ///       OptionalAttrs 'to' TypeAndValue 'unwind' TypeAndValue
> >  bool LLParser::ParseInvoke(Instruction *&Inst, PerFunctionState &PFS) {
> >   LocTy CallLoc = Lex.getLoc();
> > -  unsigned RetAttrs, FnAttrs;
> > +  Attributes RetAttrs, FnAttrs;
> >   CallingConv::ID CC;
> >   Type *RetType = 0;
> >   LocTy RetTypeLoc;
> > @@ -3561,7 +3563,7 @@
> >  ///       ParameterList OptionalAttrs
> >  bool LLParser::ParseCall(Instruction *&Inst, PerFunctionState &PFS,
> >                          bool isTail) {
> > -  unsigned RetAttrs, FnAttrs;
> > +  Attributes RetAttrs, FnAttrs;
> >   CallingConv::ID CC;
> >   Type *RetType = 0;
> >   LocTy RetTypeLoc;
> >
> > Modified: llvm/trunk/lib/AsmParser/LLParser.h
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/AsmParser/LLParser.h?rev=148553&r1=148552&r2=148553&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/lib/AsmParser/LLParser.h (original)
> > +++ llvm/trunk/lib/AsmParser/LLParser.h Fri Jan 20 11:56:17 2012
> > @@ -15,6 +15,7 @@
> >  #define LLVM_ASMPARSER_LLPARSER_H
> >
> >  #include "LLLexer.h"
> > +#include "llvm/Attributes.h"
> >  #include "llvm/Instructions.h"
> >  #include "llvm/Module.h"
> >  #include "llvm/Type.h"
> > @@ -171,7 +172,7 @@
> >       return ParseUInt32(Val);
> >     }
> >     bool ParseOptionalAddrSpace(unsigned &AddrSpace);
> > -    bool ParseOptionalAttrs(unsigned &Attrs, unsigned AttrKind);
> > +    bool ParseOptionalAttrs(Attributes &Attrs, unsigned AttrKind);
> >     bool ParseOptionalLinkage(unsigned &Linkage, bool &HasLinkage);
> >     bool ParseOptionalLinkage(unsigned &Linkage) {
> >       bool HasLinkage; return ParseOptionalLinkage(Linkage, HasLinkage);
> > @@ -304,8 +305,8 @@
> >     struct ParamInfo {
> >       LocTy Loc;
> >       Value *V;
> > -      unsigned Attrs;
> > -      ParamInfo(LocTy loc, Value *v, unsigned attrs)
> > +      Attributes Attrs;
> > +      ParamInfo(LocTy loc, Value *v, Attributes attrs)
> >         : Loc(loc), V(v), Attrs(attrs) {}
> >     };
> >     bool ParseParameterList(SmallVectorImpl<ParamInfo> &ArgList,
> > @@ -325,9 +326,9 @@
> >     struct ArgInfo {
> >       LocTy Loc;
> >       Type *Ty;
> > -      unsigned Attrs;
> > +      Attributes Attrs;
> >       std::string Name;
> > -      ArgInfo(LocTy L, Type *ty, unsigned Attr, const std::string &N)
> > +      ArgInfo(LocTy L, Type *ty, Attributes Attr, const std::string &N)
> >         : Loc(L), Ty(ty), Attrs(Attr), Name(N) {}
> >     };
> >     bool ParseArgumentList(SmallVectorImpl<ArgInfo> &ArgList, bool
> &isVarArg);
> >
> > Modified: llvm/trunk/lib/AsmParser/LLToken.h
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/AsmParser/LLToken.h?rev=148553&r1=148552&r2=148553&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/lib/AsmParser/LLToken.h (original)
> > +++ llvm/trunk/lib/AsmParser/LLToken.h Fri Jan 20 11:56:17 2012
> > @@ -102,6 +102,7 @@
> >     kw_noimplicitfloat,
> >     kw_naked,
> >     kw_nonlazybind,
> > +    kw_address_safety,
> >
> >     kw_type,
> >     kw_opaque,
> >
> > Modified: llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp?rev=148553&r1=148552&r2=148553&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp (original)
> > +++ llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp Fri Jan 20 11:56:17
> 2012
> > @@ -461,8 +461,8 @@
> >       // If Function attributes are using index 0 then transfer them
> >       // to index ~0. Index 0 is used for return value attributes but
> used to be
> >       // used for function attributes.
> > -      Attributes RetAttribute = Attribute::None;
> > -      Attributes FnAttribute = Attribute::None;
> > +      Attributes RetAttribute;
> > +      Attributes FnAttribute;
> >       for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
> >         // FIXME: remove in LLVM 3.0
> >         // The alignment is stored as a 16-bit raw value from bits
> 31--16.
> > @@ -472,23 +472,24 @@
> >         if (Alignment && !isPowerOf2_32(Alignment))
> >           return Error("Alignment is not a power of two.");
> >
> > -        Attributes ReconstitutedAttr = Record[i+1] & 0xffff;
> > +        Attributes ReconstitutedAttr(Record[i+1] & 0xffff);
> >         if (Alignment)
> >           ReconstitutedAttr |=
> Attribute::constructAlignmentFromInt(Alignment);
> > -        ReconstitutedAttr |= (Record[i+1] & (0xffffull << 32)) >> 11;
> > -        Record[i+1] = ReconstitutedAttr;
> > +        ReconstitutedAttr |=
> > +            Attributes((Record[i+1] & (0xffffull << 32)) >> 11);
> >
> > +        Record[i+1] = ReconstitutedAttr.Raw();
> >         if (Record[i] == 0)
> > -          RetAttribute = Record[i+1];
> > +          RetAttribute = ReconstitutedAttr;
> >         else if (Record[i] == ~0U)
> > -          FnAttribute = Record[i+1];
> > +          FnAttribute = ReconstitutedAttr;
> >       }
> >
> > -      unsigned OldRetAttrs = (Attribute::NoUnwind|Attribute::NoReturn|
> > +      Attributes OldRetAttrs = (Attribute::NoUnwind|Attribute::NoReturn|
> >                               Attribute::ReadOnly|Attribute::ReadNone);
> >
> >       if (FnAttribute == Attribute::None && RetAttribute !=
> Attribute::None &&
> > -          (RetAttribute & OldRetAttrs) != 0) {
> > +          (RetAttribute & OldRetAttrs)) {
> >         if (FnAttribute == Attribute::None) { // add a slot so they get
> added.
> >           Record.push_back(~0U);
> >           Record.push_back(0);
> > @@ -505,8 +506,9 @@
> >         } else if (Record[i] == ~0U) {
> >           if (FnAttribute != Attribute::None)
> >             Attrs.push_back(AttributeWithIndex::get(~0U, FnAttribute));
> > -        } else if (Record[i+1] != Attribute::None)
> > -          Attrs.push_back(AttributeWithIndex::get(Record[i],
> Record[i+1]));
> > +        } else if (Attributes(Record[i+1]) != Attribute::None)
> > +          Attrs.push_back(AttributeWithIndex::get(Record[i],
> > +
>  Attributes(Record[i+1])));
> >       }
> >
> >       MAttributes.push_back(AttrListPtr::get(Attrs.begin(),
> Attrs.end()));
> >
> > Modified: llvm/trunk/lib/Bitcode/Writer/BitcodeWriter.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Bitcode/Writer/BitcodeWriter.cpp?rev=148553&r1=148552&r2=148553&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/lib/Bitcode/Writer/BitcodeWriter.cpp (original)
> > +++ llvm/trunk/lib/Bitcode/Writer/BitcodeWriter.cpp Fri Jan 20 11:56:17
> 2012
> > @@ -179,10 +179,11 @@
> >       // Store the alignment in the bitcode as a 16-bit raw value
> instead of a
> >       // 5-bit log2 encoded value. Shift the bits above the alignment up
> by
> >       // 11 bits.
> > -      uint64_t FauxAttr = PAWI.Attrs & 0xffff;
> > +      uint64_t FauxAttr = PAWI.Attrs.Raw() & 0xffff;
> >       if (PAWI.Attrs & Attribute::Alignment)
> > -        FauxAttr |= (1ull<<16)<<(((PAWI.Attrs &
> Attribute::Alignment)-1) >> 16);
> > -      FauxAttr |= (PAWI.Attrs & (0x3FFull << 21)) << 11;
> > +        FauxAttr |= (1ull<<16)<<
> > +            (((PAWI.Attrs & Attribute::Alignment).Raw()-1) >> 16);
> > +      FauxAttr |= (PAWI.Attrs.Raw() & (0x3FFull << 21)) << 11;
> >
> >       Record.push_back(FauxAttr);
> >     }
> >
> > Modified: llvm/trunk/lib/CodeGen/Analysis.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/Analysis.cpp?rev=148553&r1=148552&r2=148553&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/lib/CodeGen/Analysis.cpp (original)
> > +++ llvm/trunk/lib/CodeGen/Analysis.cpp Fri Jan 20 11:56:17 2012
> > @@ -259,7 +259,7 @@
> >   // Conservatively require the attributes of the call to match those of
> >   // the return. Ignore noalias because it doesn't affect the call
> sequence.
> >   const Function *F = ExitBB->getParent();
> > -  unsigned CallerRetAttr = F->getAttributes().getRetAttributes();
> > +  Attributes CallerRetAttr = F->getAttributes().getRetAttributes();
> >   if ((CalleeRetAttr ^ CallerRetAttr) & ~Attribute::NoAlias)
> >     return false;
> >
> > @@ -299,7 +299,7 @@
> >
> >   // Conservatively require the attributes of the call to match those of
> >   // the return. Ignore noalias because it doesn't affect the call
> sequence.
> > -  unsigned CallerRetAttr = F->getAttributes().getRetAttributes();
> > +  Attributes CallerRetAttr = F->getAttributes().getRetAttributes();
> >   if (CallerRetAttr & ~Attribute::NoAlias)
> >     return false;
> >
> >
> > Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp?rev=148553&r1=148552&r2=148553&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp (original)
> > +++ llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp Fri Jan
> 20 11:56:17 2012
> > @@ -1063,7 +1063,7 @@
> >     if (!CastInst::isCastable(ActTy, ParamTy))
> >       return false;   // Cannot transform this parameter value.
> >
> > -    unsigned Attrs = CallerPAL.getParamAttributes(i + 1);
> > +    Attributes Attrs = CallerPAL.getParamAttributes(i + 1);
> >     if (Attrs & Attribute::typeIncompatible(ParamTy))
> >       return false;   // Attribute not compatible with transformed value.
> >
> > @@ -1392,4 +1392,3 @@
> >   CS.setCalledFunction(NewCallee);
> >   return CS.getInstruction();
> >  }
> > -
> >
> > Modified: llvm/trunk/lib/Transforms/Scalar/CodeGenPrepare.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/CodeGenPrepare.cpp?rev=148553&r1=148552&r2=148553&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/lib/Transforms/Scalar/CodeGenPrepare.cpp (original)
> > +++ llvm/trunk/lib/Transforms/Scalar/CodeGenPrepare.cpp Fri Jan 20
> 11:56:17 2012
> > @@ -619,7 +619,7 @@
> >   // It's not safe to eliminate the sign / zero extension of the return
> value.
> >   // See llvm::isInTailCallPosition().
> >   const Function *F = BB->getParent();
> > -  unsigned CallerRetAttr = F->getAttributes().getRetAttributes();
> > +  Attributes CallerRetAttr = F->getAttributes().getRetAttributes();
> >   if ((CallerRetAttr & Attribute::ZExt) || (CallerRetAttr &
> Attribute::SExt))
> >     return false;
> >
> > @@ -674,7 +674,7 @@
> >
> >     // Conservatively require the attributes of the call to match those
> of the
> >     // return. Ignore noalias because it doesn't affect the call
> sequence.
> > -    unsigned CalleeRetAttr = CS.getAttributes().getRetAttributes();
> > +    Attributes CalleeRetAttr = CS.getAttributes().getRetAttributes();
> >     if ((CalleeRetAttr ^ CallerRetAttr) & ~Attribute::NoAlias)
> >       continue;
> >
> >
> > Modified: llvm/trunk/lib/VMCore/Attributes.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/VMCore/Attributes.cpp?rev=148553&r1=148552&r2=148553&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/lib/VMCore/Attributes.cpp (original)
> > +++ llvm/trunk/lib/VMCore/Attributes.cpp Fri Jan 20 11:56:17 2012
> > @@ -76,6 +76,8 @@
> >     Result += "naked ";
> >   if (Attrs & Attribute::NonLazyBind)
> >     Result += "nonlazybind ";
> > +  if (Attrs & Attribute::AddressSafety)
> > +    Result += "address_safety ";
> >   if (Attrs & Attribute::StackAlignment) {
> >     Result += "alignstack(";
> >     Result += utostr(Attribute::getStackAlignmentFromAttrs(Attrs));
> > @@ -152,8 +154,10 @@
> >   }
> >   static void Profile(FoldingSetNodeID &ID, const AttributeWithIndex
> *Attr,
> >                       unsigned NumAttrs) {
> > -    for (unsigned i = 0; i != NumAttrs; ++i)
> > -      ID.AddInteger(uint64_t(Attr[i].Attrs) << 32 |
> unsigned(Attr[i].Index));
> > +    for (unsigned i = 0; i != NumAttrs; ++i) {
> > +      ID.AddInteger(Attr[i].Attrs.Raw());
> > +      ID.AddInteger(Attr[i].Index);
> > +    }
> >   }
> >  };
> >  }
> >
> > Modified: llvm/trunk/lib/VMCore/Core.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/VMCore/Core.cpp?rev=148553&r1=148552&r2=148553&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/lib/VMCore/Core.cpp (original)
> > +++ llvm/trunk/lib/VMCore/Core.cpp Fri Jan 20 11:56:17 2012
> > @@ -13,6 +13,7 @@
> >
>  //===----------------------------------------------------------------------===//
> >
> >  #include "llvm-c/Core.h"
> > +#include "llvm/Attributes.h"
> >  #include "llvm/Bitcode/ReaderWriter.h"
> >  #include "llvm/Constants.h"
> >  #include "llvm/DerivedTypes.h"
> > @@ -1350,14 +1351,14 @@
> >  void LLVMAddFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA) {
> >   Function *Func = unwrap<Function>(Fn);
> >   const AttrListPtr PAL = Func->getAttributes();
> > -  const AttrListPtr PALnew = PAL.addAttr(~0U, PA);
> > +  const AttrListPtr PALnew = PAL.addAttr(~0U, Attributes(PA));
> >   Func->setAttributes(PALnew);
> >  }
> >
> >  void LLVMRemoveFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA) {
> >   Function *Func = unwrap<Function>(Fn);
> >   const AttrListPtr PAL = Func->getAttributes();
> > -  const AttrListPtr PALnew = PAL.removeAttr(~0U, PA);
> > +  const AttrListPtr PALnew = PAL.removeAttr(~0U, Attributes(PA));
> >   Func->setAttributes(PALnew);
> >  }
> >
> > @@ -1365,7 +1366,7 @@
> >   Function *Func = unwrap<Function>(Fn);
> >   const AttrListPtr PAL = Func->getAttributes();
> >   Attributes attr = PAL.getFnAttributes();
> > -  return (LLVMAttribute)attr;
> > +  return (LLVMAttribute)attr.Raw();
> >  }
> >
> >  /*--.. Operations on parameters
> ............................................--*/
> > @@ -1427,18 +1428,18 @@
> >  }
> >
> >  void LLVMAddAttribute(LLVMValueRef Arg, LLVMAttribute PA) {
> > -  unwrap<Argument>(Arg)->addAttr(PA);
> > +  unwrap<Argument>(Arg)->addAttr(Attributes(PA));
> >  }
> >
> >  void LLVMRemoveAttribute(LLVMValueRef Arg, LLVMAttribute PA) {
> > -  unwrap<Argument>(Arg)->removeAttr(PA);
> > +  unwrap<Argument>(Arg)->removeAttr(Attributes(PA));
> >  }
> >
> >  LLVMAttribute LLVMGetAttribute(LLVMValueRef Arg) {
> >   Argument *A = unwrap<Argument>(Arg);
> >   Attributes attr = A->getParent()->getAttributes().getParamAttributes(
> >     A->getArgNo()+1);
> > -  return (LLVMAttribute)attr;
> > +  return (LLVMAttribute)attr.Raw();
> >  }
> >
> >
> > @@ -1635,14 +1636,14 @@
> >                            LLVMAttribute PA) {
> >   CallSite Call = CallSite(unwrap<Instruction>(Instr));
> >   Call.setAttributes(
> > -    Call.getAttributes().addAttr(index, PA));
> > +    Call.getAttributes().addAttr(index, Attributes(PA)));
> >  }
> >
> >  void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index,
> >                               LLVMAttribute PA) {
> >   CallSite Call = CallSite(unwrap<Instruction>(Instr));
> >   Call.setAttributes(
> > -    Call.getAttributes().removeAttr(index, PA));
> > +    Call.getAttributes().removeAttr(index, Attributes(PA)));
> >  }
> >
> >  void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index,
> >
> > Modified: llvm/trunk/lib/VMCore/Verifier.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/VMCore/Verifier.cpp?rev=148553&r1=148552&r2=148553&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/lib/VMCore/Verifier.cpp (original)
> > +++ llvm/trunk/lib/VMCore/Verifier.cpp Fri Jan 20 11:56:17 2012
> > @@ -547,7 +547,7 @@
> >   for (unsigned i = 0;
> >        i < array_lengthof(Attribute::MutuallyIncompatible); ++i) {
> >     Attributes MutI = Attrs & Attribute::MutuallyIncompatible[i];
> > -    Assert1(!(MutI & (MutI - 1)), "Attributes " +
> > +    Assert1(MutI.isEmptyOrSingleton(), "Attributes " +
> >             Attribute::getAsString(MutI) + " are incompatible!", V);
> >   }
> >
> > @@ -607,7 +607,7 @@
> >   for (unsigned i = 0;
> >        i < array_lengthof(Attribute::MutuallyIncompatible); ++i) {
> >     Attributes MutI = FAttrs & Attribute::MutuallyIncompatible[i];
> > -    Assert1(!(MutI & (MutI - 1)), "Attributes " +
> > +    Assert1(MutI.isEmptyOrSingleton(), "Attributes " +
> >             Attribute::getAsString(MutI) + " are incompatible!", V);
> >   }
> >  }
> >
> > Modified: llvm/trunk/utils/llvm.grm
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/llvm.grm?rev=148553&r1=148552&r2=148553&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/utils/llvm.grm (original)
> > +++ llvm/trunk/utils/llvm.grm Fri Jan 20 11:56:17 2012
> > @@ -174,6 +174,7 @@
> >  | sspreq
> >  | returns_twice
> >  | nonlazybind
> > + | address_safety
> >  ;
> >
> >  OptFuncAttrs  ::= + _ | OptFuncAttrs FuncAttr ;
> >
> >
> > _______________________________________________
> > llvm-commits mailing list
> > llvm-commits at cs.uiuc.edu
> > http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://lists.cs.uiuc.edu/pipermail/llvm-commits/attachments/20120120/6c982b91/attachment-0001.html 


More information about the llvm-commits mailing list