Add a dereferencable attribute

[hfinkel]

Summary

This patch adds a dereferencable attribute. In some sense, this is a companion to the nonnull attribute, but specifies that the pointer is known to be dereferencable in the same sense as a pointer generated by alloca is known to be dereferencable.

My primary use case for this is C++ references that are passes as function parameters and used in loops. For example,

void foo(int * restrict a, int * restrict b, int &c, int n) {

for (int i = 0; i < n; ++i)
  if (a[i] > 0)
    a[i] = c*b[i];

}

Currently, we generate a load of 'c' in every loop iteration because we can't prove that there is no control dependence on the dereferencability of 'c' from the if condition. But because 'c' is a reference, we know it must point to something, and since nothing else in the loop can alias it, it is safe to load it in the preheader.

(there is a simple companion Clang patch, which I'll also post.)

[hfinkel]

Updated per Nick's comment to include an explicit size (number of bytes). I currently picked 12 bits for the size, I'm not sure if that is a good choice (I did not want to use too many bits, are there only 64 in total?).

Also, I renamed the AlignAttr class to IntAttr (along with all associated functions) because these are now just integer-carrying attributes (not specifically some kind of alignment).

[jmolloy]

Hi Hal,

Sorry I'm getting to this late, but I have a comment:

/// \brief If this argument has the dereferencable attribute on it in its
/// containing function, return the number of bytes known to be
/// dereferencable.
unsigned getDereferencableBytes() const;

You are later on assuming this function returns zero if the dereferencable attribute is not set, but you do not specify this behaviour in the documentation. Could you please add it?

Cheers,

James

[reames]

I like the overall direction, but am not crazy about certain parts of the implementation. Specially:

• the 4096 byte restriction
• is there any value to a partial pointer to a partially dereferencable pointer? deref(2) i32* doesn't seem to make sense.
• the consumption of so many bits in the attribute bitmask
• the documentation
• the combination of a refactoring and a functional change

docs/LangRef.rst

977

The obvious question left by the documentation is what's the difference between 'nonnull' and 'dereferencable'? Spelling this out explicitly would be helpful.

include/llvm/IR/Argument.h

65

Naming here could be improved.. possibly, getBytesKnownSafeToDereference?

The current name doesn't convey the meaning of the result.

Also, what is returned if the attribute is not present? Zero? Add to the documentation.

include/llvm/IR/Attributes.h

148

This rename should be a separate change.

186

Same issues as before.

Since you have similar accessors throughout, pretend I repeated those comments for each.

lib/AsmParser/LLParser.cpp

1630

This doesn't seem right. It seems like this should only be called from situations where you already have identified the dereferencable keyword. Should this be an assert?

lib/Bitcode/Reader/BitcodeReader.cpp

688

comment update.

lib/IR/Attributes.cpp

430

This encoding seems "unpleasant". We already except string attributes from the masking scheme, would it make sense to separate integer attributes as well? You'd need to leave handling for the existing two, but that might be least ugly option.

Also, 4096 is a fairly arbitrary limit. I could see cases where a array passed by reference would be useful larger than this. Why not have the units be in units of element size? i.e. i32* dereferencable(3) would be 12 bytes. This might make the restricted range much more powerful. (e.g. [i32 x 20000]* dereferencable(1) is a pointer to a array of 20000 elements all of which are dereferencable.)

1029

It might be time to extract an isIntAttrKind(...) function..

1138

What happens if I try to add this twice with different sizes?

test/Transforms/LICM/hoist-deref-load.ll

4

This is a pretty high level test. Could you add a couple of smaller examples? Actually, thinking about this a bit, that might be hard. Feel free to ignore this comment if you can't find smaller examples.

[hfinkel]

• Original Message -----

From: "Philip Reames" <[e-mail]>
To: [e-mail], [e-mail], [e-mail], [e-mail], [e-mail],
[e-mail]
Cc: "james molloy" <[e-mail]>, [e-mail]
Sent: Thursday, July 10, 2014 5:00:15 PM
Subject: Re: [PATCH] Add a dereferencable attribute

I like the overall direction, but am not crazy about certain parts of
the implementation. Specially:

• the 4096 byte restriction

I'm not crazy about this either.

• is there any value to a partial pointer to a partially

dereferencable pointer? deref(2) i32* doesn't seem to make sense.

As Nick pointed out initially, this actually does make sense. Many targets fool with the actual parameter types for ABI reasons (including "padding" them), and it is important to be able to specify that only part of the type size is dereferenceable.

• the consumption of so many bits in the attribute bitmask

Yep.

• the documentation

Okay.

• the combination of a refactoring and a functional change

There really isn't any (aside from the one renaming, which I can certainly commit separately).

Comment at: docs/LangRef.rst:977
@@ +976,3 @@
+ trapping. The number of bytes known to be dereferencable must be
provided
+ in parentheses (only 12-bit values supported).

+

The obvious question left by the documentation is what's the
difference between 'nonnull' and 'dereferencable'? Spelling this
out explicitly would be helpful.

Agreed.

Comment at: include/llvm/IR/Argument.h:65
@@ +64,3 @@
+ /// dereferencable.
+ unsigned getDereferencableBytes() const;

+

Naming here could be improved.. possibly,
getBytesKnownSafeToDereference?

The current name doesn't convey the meaning of the result.

Also, what is returned if the attribute is not present? Zero? Add
to the documentation.

Comment at: include/llvm/IR/Attributes.h:148
@@ -146,1 +147,3 @@
+ /// \brief Return true if the attribute is an integer attribute.
+ bool isIntAttribute() const;

----------------

This rename should be a separate change.

Yea, I'm happy to commit this separately.

Comment at: include/llvm/IR/Attributes.h:186
@@ +185,3 @@
+ /// dereferencable attribute.
+ unsigned getDereferencableBytes() const;

+

Same issues as before.

Since you have similar accessors throughout, pretend I repeated those
comments for each.

Comment at: lib/AsmParser/LLParser.cpp:1630
@@ +1629,3 @@
+ if (!EatIfPresent(lltok::kw_dereferencable))
+ return false;

+ LocTy ParenLoc = Lex.getLoc();

This doesn't seem right. It seems like this should only be called
from situations where you already have identified the dereferencable
keyword. Should this be an assert?

This is done in exactly the same way as the other parametrized attributes. Maybe all of them need some work, but that's a separate issue.

Comment at: lib/Bitcode/Reader/BitcodeReader.cpp:688
@@ -685,3 +687,3 @@

  B.addAttribute(Kind);
} else if (Record[i] == 1) { // Align attribute
  Attribute::AttrKind Kind;

---

comment update.

Thanks.

Comment at: lib/IR/Attributes.cpp:430
@@ -400,2 +429,3 @@

case Attribute::JumpTable:       return 1ULL << 45;

+ case Attribute::Dereferencable: return 4095ULL << 46;

}

---

This encoding seems "unpleasant". We already except string
attributes from the masking scheme, would it make sense to separate
integer attributes as well? You'd need to leave handling for the
existing two, but that might be least ugly option.

I'm not sure, and as I recall, we don't actually accept string attributes on parameters, so some more-general changes would be needed.

Also, 4096 is a fairly arbitrary limit. I could see cases where a
array passed by reference would be useful larger than this. Why not
have the units be in units of element size? i.e. i32*
dereferencable(3) would be 12 bytes. This might make the restricted
range much more powerful. (e.g. [i32 x 20000]* dereferencable(1) is
a pointer to a array of 20000 elements all of which are
dereferencable.)

You don't need to convince me to not like the limit, I don't like it. Someone with a better understanding of the bitcode format, I hope, will be able to suggest something better.

Comment at: lib/IR/Attributes.cpp:1029
@@ -980,2 +1028,3 @@

assert((unsigned)Val < Attribute::EndAttrKinds && "Attribute out
of range!");
assert(Val != Attribute::Alignment && Val !=
Attribute::StackAlignment &&

+ Val != Attribute::Dereferencable &&

It might be time to extract an isIntAttrKind(...) function..

Agreed.

Comment at: lib/IR/Attributes.cpp:1138
@@ +1137,3 @@
+AttrBuilder &AttrBuilder::addDereferencableAttr(unsigned Bytes) {
+ if (Bytes == 0) return *this;

+

What happens if I try to add this twice with different sizes?

The same thing as happens for an alignment (it replaces the previous one, IIRC).

Comment at: test/Transforms/LICM/hoist-deref-load.ll:4
@@ +3,3 @@
+target triple = "x86_64-unknown-linux-gnu"
+

+; This test represents the following function:

This is a pretty high level test. Could you add a couple of smaller
examples? Actually, thinking about this a bit, that might be hard.
Feel free to ignore this comment if you can't find smaller
examples.

I don't know of any either.

Thanks again,
Hal

http://reviews.llvm.org/D4449

[hfinkel]

I believe that this should address everyone's suggestions. Notably:

• We're no longer limited to 12 bits (a full 64-bit unsigned value is accepted). The only downside is that we cannot use this attribute with the bitmask scheme used by older bitcode (and perhaps uses of the older associated C API?), but I don't think this is a major problem.
• For addrspace(0), this attribute also implies nonnull (so we don't need to have both).

[hfinkel]

Added a test that the dereferenceable attribute on a non-addrspace(0) pointer does not imply nonnull.

[jfb]

Looks good to me, besides two small comments.

include/llvm/IR/Attributes.h

91

You'll make some people sad (not PNaCl, but Renderscript and others) by adding the attribute here in the enum instead of at the end, since it changes bitcode slightly.

lib/IR/Attributes.cpp

93

Math bikeshed: "non-zero" seems better than "positive".

[jvoung]

include/llvm/Bitcode/LLVMBitCodes.h

378

DEFERERENCEABLE -> DEREFERENCEABLE ?

include/llvm/IR/Attributes.h

91

I think the enum in the bitc:: namespace is the one that affects serialized bitcode and not this enum?

[reames]

I'm happy with the new encodings. Some of my previous comments still stand (naming, comments, etc..), but the overall structure looks good.

I am uncomfortable with the coupling of dereferenceable and nonnull. I don't have an actual counter example, but could we separate that from the current patch and revisit it separately?

Thinking out loud, I wonder about a truly perverse runtime system that wanted to use loads from null+offset to represent calls to runtime functions. The signal handler could advance the PC and parse the load instruction to "return" a value in the right register. This would be a "dereferenceable" load (very indirectly!), but not non-null. I don't think you could represent this in LLVM for other reasons, but it's the best I could do on the spot. :)

[hfinkel]

• Original Message -----

From: "Philip Reames" <[e-mail]>
To: [e-mail], [e-mail], [e-mail], [e-mail], [e-mail],
[e-mail]
Cc: [e-mail], [e-mail], "james molloy" <[e-mail]>, [e-mail]
Sent: Friday, July 11, 2014 4:27:10 PM
Subject: Re: [PATCH] Add a dereferencable attribute

I'm happy with the new encodings.

Good, I like it better too :-)

Some of my previous comments still
stand (naming, comments, etc..), but the overall structure looks
good.

Alright, I want to be clear about this, because I thought that I had addressed your comments...

• I will commit separately the AlignAttr -> IntAttr renaming
• Regarding getDereferenceableBytes -> getBytesKnownSafeToDereference (or similar), I'm not thrilled by the idea of making a long name even longer, and I think that Dereferenceable implies safety. Would getDereferenceableByteCount be better?
• If there is anything else under "naming", please clarify.
• There is now some note on every getDereferenceableBytes function stating that zero is returned when the answer is unknown, and the LangRef text has been updated based on your comments.
• Is there anything else under 'etc.'?

I am uncomfortable with the coupling of dereferenceable and nonnull.
I don't have an actual counter example, but could we separate that
from the current patch and revisit it separately?

We could, but it would cause a lot of test-case churn (on the Clang side) and I'd rather not. Realistically, the fact that dereferenceablility imples nonnull (only for addrspace(0)) is baked into several pieces of LLVM and specified in the language reference.

Thanks again,
Hal

Thinking out loud, I wonder about a truly perverse runtime system
that wanted to use loads from null+offset to represent calls to
runtime functions. The signal handler could advance the PC and
parse the load instruction to "return" a value in the right
register. This would be a "dereferenceable" load (very
indirectly!), but not non-null. I don't think you could represent
this in LLVM for other reasons, but it's the best I could do on the
spot. :)

http://reviews.llvm.org/D4449

[hfinkel]

include/llvm/Bitcode/LLVMBitCodes.h

378

Indeed :-)

include/llvm/IR/Attributes.h

91

Correct, the bitc:: ones are encoded.

lib/IR/Attributes.cpp

93

Agreed (the number is unsigned).

[hfinkel]

Reviewers approved, will close.

[hfinkel]

r213385, thanks!

docs/LangRef.rst

 
 ``nonnull``
     This indicates that the parameter or return pointer is not null. This
     attribute may only be applied to pointer typed parameters. This is not
     checked or enforced by LLVM, the caller must ensure that the pointer
     passed in is non-null, or the callee must ensure that the returned pointer 
     is non-null.
 
+``dereferencable(<n>)``
+    This indicates that the parameter or return pointer is dereferencable. This
+    attribute may only be applied to pointer typed parameters. A pointer that
+    is dereferencable can be loaded from speculatively without a risk of
+    trapping. The number of bytes known to be dereferencable must be provided
+    in parentheses (only 12-bit values supported).
+
 .. _gc:
 
 Garbage Collector Names
 -----------------------
 
 Each function may specify a garbage collector name, which is simply a
 string:
 

include/llvm-c/Core.h

/* FIXME: These attributes are currently not included in the C API as
        and the path forward agreed upon.
     LLVMAddressSafety = 1ULL << 32,
     LLVMStackProtectStrongAttribute = 1ULL<<33,
     LLVMCold = 1ULL << 34,
     LLVMOptimizeNone = 1ULL << 35,
     LLVMInAllocaAttribute = 1ULL << 36,
     LLVMNonNullAttribute = 1ULL << 37,
     LLVMJumpTableAttribute = 1ULL << 38,
+    LLVMDereferencableAttribute = 1ULL << 39,
     */
 } LLVMAttribute;
 
 typedef enum {
   /* Terminator Instructions */
   LLVMRet            = 1,
   LLVMBr             = 2,
   LLVMSwitch         = 3,

include/llvm/Bitcode/LLVMBitCodes.h

enum AttributeKindCodes {
     ATTR_KIND_SANITIZE_MEMORY = 32,
     ATTR_KIND_UW_TABLE = 33,
     ATTR_KIND_Z_EXT = 34,
     ATTR_KIND_BUILTIN = 35,
     ATTR_KIND_COLD = 36,
     ATTR_KIND_OPTIMIZE_NONE = 37,
     ATTR_KIND_IN_ALLOCA = 38,
     ATTR_KIND_NON_NULL = 39,
-    ATTR_KIND_JUMP_TABLE = 40
+    ATTR_KIND_JUMP_TABLE = 40,
+    ATTR_KIND_DEREFERENCABLE = 41
   };
 
   enum ComdatSelectionKindCodes {
     COMDAT_SELECTION_KIND_ANY = 1,
     COMDAT_SELECTION_KIND_EXACT_MATCH = 2,
     COMDAT_SELECTION_KIND_LARGEST = 3,
     COMDAT_SELECTION_KIND_NO_DUPLICATES = 4,
     COMDAT_SELECTION_KIND_SAME_SIZE = 5,
   };
 
 } // End bitc namespace
 } // End llvm namespace
 
 #endif

include/llvm/IR/Argument.h

public:
   ///
   /// For example in "void foo(int a, float b)" a is 0 and b is 1.
   unsigned getArgNo() const;
 
   /// \brief Return true if this argument has the nonnull attribute on it in
   /// its containing function.
   bool hasNonNullAttr() const;
 
+  /// \brief If this argument has the dereferencable attribute on it in its
+  /// containing function, return the number of bytes known to be
+  /// dereferencable.
+  unsigned getDereferencableBytes() const;
+
   /// \brief Return true if this argument has the byval attribute on it in its
   /// containing function.
   bool hasByValAttr() const;
 
   /// \brief Return true if this argument has the byval attribute or inalloca
   /// attribute on it in its containing function.  These attributes both
   /// represent arguments being passed by value.
   bool hasByValOrInAllocaAttr() const;

include/llvm/IR/Attributes.h

enum AttrKind {
     NoBuiltin,             ///< Callee isn't recognized as a builtin
     NoCapture,             ///< Function creates no aliases of pointer
     NoDuplicate,           ///< Call cannot be duplicated
     NoImplicitFloat,       ///< Disable implicit floating point insts
     NoInline,              ///< inline=never
     NonLazyBind,           ///< Function is called early and/or
                            ///< often, so lazy binding isn't worthwhile
     NonNull,               ///< Pointer is known to be not null
+    Dereferencable,        ///< Pointer is known to be dereferencable (12 bits)
     NoRedZone,             ///< Disable redzone
     NoReturn,              ///< Mark the function as not returning
     NoUnwind,              ///< Function doesn't unwind stack
     OptimizeForSize,       ///< opt_size
     OptimizeNone,          ///< Function must not be optimized.
     ReadNone,              ///< Function does not access memory
     ReadOnly,              ///< Function only reads from memory
     Returned,              ///< Return value is always equal to this argument
public:
   static Attribute get(LLVMContext &Context, AttrKind Kind, uint64_t Val = 0);
   static Attribute get(LLVMContext &Context, StringRef Kind,
                        StringRef Val = StringRef());
 
   /// \brief Return a uniquified Attribute object that has the specific
   /// alignment set.
   static Attribute getWithAlignment(LLVMContext &Context, uint64_t Align);
   static Attribute getWithStackAlignment(LLVMContext &Context, uint64_t Align);
+  static Attribute getWithDereferencableBytes(LLVMContext &Context,
+                                              uint64_t Bytes);
 
   //===--------------------------------------------------------------------===//
   // Attribute Accessors
   //===--------------------------------------------------------------------===//
 
   /// \brief Return true if the attribute is an Attribute::AttrKind type.
   bool isEnumAttribute() const;
 
-  /// \brief Return true if the attribute is an alignment attribute.
-  bool isAlignAttribute() const;
+  /// \brief Return true if the attribute is an integer attribute.
+  bool isIntAttribute() const;
 
   /// \brief Return true if the attribute is a string (target-dependent)
   /// attribute.
   bool isStringAttribute() const;
 
   /// \brief Return true if the attribute is present.
   bool hasAttribute(AttrKind Val) const;
 
public:
   /// \brief Returns the alignment field of an attribute as a byte alignment
   /// value.
   unsigned getAlignment() const;
 
   /// \brief Returns the stack alignment field of an attribute as a byte
   /// alignment value.
   unsigned getStackAlignment() const;
 
+  /// \brief Returns the number of dereferencable bytes from the
+  /// dereferencable attribute.
+  unsigned getDereferencableBytes() const;
+
   /// \brief The Attribute is converted to a string of equivalent mnemonic. This
   /// is, presumably, for writing out the mnemonics for the assembly writer.
   std::string getAsString(bool InAttrGrp = false) const;
 
   /// \brief Equality and non-equality operators.
   bool operator==(Attribute A) const { return pImpl == A.pImpl; }
   bool operator!=(Attribute A) const { return pImpl != A.pImpl; }
 
public:
   Attribute getAttribute(unsigned Index, StringRef Kind) const;
 
   /// \brief Return the alignment for the specified function parameter.
   unsigned getParamAlignment(unsigned Index) const;
 
   /// \brief Get the stack alignment.
   unsigned getStackAlignment(unsigned Index) const;
 
+  /// \brief Get the number of dereferencable bytes.
+  unsigned getDereferencableBytes(unsigned Index) const;
+
   /// \brief Return the attributes at the index as a string.
   std::string getAsString(unsigned Index, bool InAttrGrp = false) const;
 
   typedef ArrayRef<Attribute>::iterator iterator;
 
   iterator begin(unsigned Slot) const;
   iterator end(unsigned Slot) const;
 

 /// create an Attribute object. The object itself is uniquified. The Builder's
 /// value, however, is not. So this can be used as a quick way to test for
 /// equality, presence of attributes, etc.
 class AttrBuilder {
   std::bitset<Attribute::EndAttrKinds> Attrs;
   std::map<std::string, std::string> TargetDepAttrs;
   uint64_t Alignment;
   uint64_t StackAlignment;
+  uint64_t DerefBytes;
 public:
-  AttrBuilder() : Attrs(0), Alignment(0), StackAlignment(0) {}
+  AttrBuilder() : Attrs(0), Alignment(0), StackAlignment(0), DerefBytes(0) {}
   explicit AttrBuilder(uint64_t Val)
-    : Attrs(0), Alignment(0), StackAlignment(0) {
+    : Attrs(0), Alignment(0), StackAlignment(0), DerefBytes(0) {
     addRawValue(Val);
   }
-  AttrBuilder(const Attribute &A) : Attrs(0), Alignment(0), StackAlignment(0) {
+  AttrBuilder(const Attribute &A)
+    : Attrs(0), Alignment(0), StackAlignment(0), DerefBytes(0) {
     addAttribute(A);
   }
   AttrBuilder(AttributeSet AS, unsigned Idx);
 
   void clear();
 
   /// \brief Add an attribute to the builder.
   AttrBuilder &addAttribute(Attribute::AttrKind Val);
public:
   bool hasAlignmentAttr() const;
 
   /// \brief Retrieve the alignment attribute, if it exists.
   uint64_t getAlignment() const { return Alignment; }
 
   /// \brief Retrieve the stack alignment attribute, if it exists.
   uint64_t getStackAlignment() const { return StackAlignment; }
 
+  /// \brief Retrieve the number of dereferencable bytes, if the dereferencable
+  /// attribute exists.
+  uint64_t getDereferencableBytes() const { return DerefBytes; }
+
   /// \brief This turns an int alignment (which must be a power of 2) into the
   /// form used internally in Attribute.
   AttrBuilder &addAlignmentAttr(unsigned Align);
 
   /// \brief This turns an int stack alignment (which must be a power of 2) into
   /// the form used internally in Attribute.
   AttrBuilder &addStackAlignmentAttr(unsigned Align);
 
+  /// \brief This turns the number of dereferencable bytes into the form used
+  /// internally in Attribute.
+  AttrBuilder &addDereferencableAttr(unsigned Bytes);
+
   /// \brief Return true if the builder contains no target-independent
   /// attributes.
   bool empty() const { return Attrs.none(); }
 
   // Iterators for target-dependent attributes.
   typedef std::pair<std::string, std::string>                td_type;
   typedef std::map<std::string, std::string>::iterator       td_iterator;
   typedef std::map<std::string, std::string>::const_iterator td_const_iterator;

include/llvm/IR/CallSite.h

bool paramHasAttr(unsigned i, Attribute::AttrKind A) const {
     CALLSITE_DELEGATE_GETTER(paramHasAttr(i, A));
   }
 
   /// @brief Extract the alignment for a call or parameter (0=unknown).
   uint16_t getParamAlignment(uint16_t i) const {
     CALLSITE_DELEGATE_GETTER(getParamAlignment(i));
   }
 
+  /// @brief Extract the number of dereferencable bytes for a call or
+  /// parameter (0=unknown).
+  unsigned getDereferencableBytes(uint16_t i) const {
+    CALLSITE_DELEGATE_GETTER(getDereferencableBytes(i));
+  }
+
   /// \brief Return true if the call should not be treated as a call to a
   /// builtin.
   bool isNoBuiltin() const {
     CALLSITE_DELEGATE_GETTER(isNoBuiltin());
   }
 
   /// @brief Return true if the call should not be inlined.
   bool isNoInline() const {

include/llvm/IR/Function.h

public:
   /// @brief removes the attributes from the list of attributes.
   void removeAttributes(unsigned i, AttributeSet attr);
 
   /// @brief Extract the alignment for a call or parameter (0=unknown).
   unsigned getParamAlignment(unsigned i) const {
     return AttributeSets.getParamAlignment(i);
   }
 
+  /// @brief Extract the number of dereferencable bytes for a call or
+  /// parameter (0=unknown).
+  unsigned getDereferencableBytes(unsigned i) const {
+    return AttributeSets.getDereferencableBytes(i);
+  }
+
   /// @brief Determine if the function does not access memory.
   bool doesNotAccessMemory() const {
     return AttributeSets.hasAttribute(AttributeSet::FunctionIndex,
                                       Attribute::ReadNone);
   }
   void setDoesNotAccessMemory() {
     addFnAttr(Attribute::ReadNone);
   }

include/llvm/IR/Instructions.h

public:
   /// \brief Determine whether the call or the callee has the given attributes.
   bool paramHasAttr(unsigned i, Attribute::AttrKind A) const;
 
   /// \brief Extract the alignment for a call or parameter (0=unknown).
   unsigned getParamAlignment(unsigned i) const {
     return AttributeList.getParamAlignment(i);
   }
 
+  /// \brief Extract the number of dereferencable bytes for a call or
+  /// parameter (0=unknown).
+  unsigned getDereferencableBytes(unsigned i) const {
+    return AttributeList.getDereferencableBytes(i);
+  }
+
   /// \brief Return true if the call should not be treated as a call to a
   /// builtin.
   bool isNoBuiltin() const {
     return hasFnAttrImpl(Attribute::NoBuiltin) &&
       !hasFnAttrImpl(Attribute::Builtin);
   }
 
   /// \brief Return true if the call should not be inlined.
public:
   /// \brief Determine whether the call or the callee has the given attributes.
   bool paramHasAttr(unsigned i, Attribute::AttrKind A) const;
 
   /// \brief Extract the alignment for a call or parameter (0=unknown).
   unsigned getParamAlignment(unsigned i) const {
     return AttributeList.getParamAlignment(i);
   }
 
+  /// \brief Extract the number of dereferencable bytes for a call or
+  /// parameter (0=unknown).
+  unsigned getDereferencableBytes(unsigned i) const {
+    return AttributeList.getDereferencableBytes(i);
+  }
+
   /// \brief Return true if the call should not be treated as a call to a
   /// builtin.
   bool isNoBuiltin() const {
     // We assert in hasFnAttr if one passes in Attribute::NoBuiltin, so we have
     // to check it by hand.
     return hasFnAttrImpl(Attribute::NoBuiltin) &&
       !hasFnAttrImpl(Attribute::Builtin);
   }

lib/AsmParser/LLLexer.cpp

#define KEYWORD(STR)                                                    \
 
   KEYWORD(attributes);
 
   KEYWORD(alwaysinline);
   KEYWORD(builtin);
   KEYWORD(byval);
   KEYWORD(inalloca);
   KEYWORD(cold);
+  KEYWORD(dereferencable);
   KEYWORD(inlinehint);
   KEYWORD(inreg);
   KEYWORD(jumptable);
   KEYWORD(minsize);
   KEYWORD(naked);
   KEYWORD(nest);
   KEYWORD(noalias);
   KEYWORD(nobuiltin);

lib/AsmParser/LLParser.h

private:
     bool ParseOptionalLinkage(unsigned &Linkage, bool &HasLinkage);
     bool ParseOptionalLinkage(unsigned &Linkage) {
       bool HasLinkage; return ParseOptionalLinkage(Linkage, HasLinkage);
     }
     bool ParseOptionalVisibility(unsigned &Visibility);
     bool ParseOptionalDLLStorageClass(unsigned &DLLStorageClass);
     bool ParseOptionalCallingConv(CallingConv::ID &CC);
     bool ParseOptionalAlignment(unsigned &Alignment);
+    bool ParseOptionalDereferencableBytes(unsigned &Bytes);
     bool ParseScopeAndOrdering(bool isAtomic, SynchronizationScope &Scope,
                                AtomicOrdering &Ordering);
     bool ParseOrdering(AtomicOrdering &Ordering);
     bool ParseOptionalStackAlignment(unsigned &Alignment);
     bool ParseOptionalCommaAlign(unsigned &Alignment, bool &AteExtraComma);
     bool ParseOptionalCommaInAlloca(bool &IsInAlloca);
     bool ParseIndexList(SmallVectorImpl<unsigned> &Indices,bool &AteExtraComma);
     bool ParseIndexList(SmallVectorImpl<unsigned> &Indices) {

lib/AsmParser/LLParser.cpp

while (true) {
     case lltok::kw_inreg:
     case lltok::kw_signext:
     case lltok::kw_zeroext:
       HaveError |=
         Error(Lex.getLoc(),
               "invalid use of attribute on a function");
       break;
     case lltok::kw_byval:
+    case lltok::kw_dereferencable:
     case lltok::kw_inalloca:
     case lltok::kw_nest:
     case lltok::kw_noalias:
     case lltok::kw_nocapture:
     case lltok::kw_nonnull:
     case lltok::kw_returned:
     case lltok::kw_sret:
       HaveError |=
while (1) {
     case lltok::kw_align: {
       unsigned Alignment;
       if (ParseOptionalAlignment(Alignment))
         return true;
       B.addAlignmentAttr(Alignment);
       continue;
     }
     case lltok::kw_byval:           B.addAttribute(Attribute::ByVal); break;
+    case lltok::kw_dereferencable: {
+      unsigned Bytes;
+      if (ParseOptionalDereferencableBytes(Bytes))
+        return true;
+      B.addDereferencableAttr(Bytes);
+      continue;
+    }
     case lltok::kw_inalloca:        B.addAttribute(Attribute::InAlloca); break;
     case lltok::kw_inreg:           B.addAttribute(Attribute::InReg); break;
     case lltok::kw_nest:            B.addAttribute(Attribute::Nest); break;
     case lltok::kw_noalias:         B.addAttribute(Attribute::NoAlias); break;
     case lltok::kw_nocapture:       B.addAttribute(Attribute::NoCapture); break;
     case lltok::kw_nonnull:         B.addAttribute(Attribute::NonNull); break;
     case lltok::kw_readnone:        B.addAttribute(Attribute::ReadNone); break;
     case lltok::kw_readonly:        B.addAttribute(Attribute::ReadOnly); break;
bool LLParser::ParseOptionalReturnAttrs(AttrBuilder &B) {
 
   B.clear();
 
   while (1) {
     lltok::Kind Token = Lex.getKind();
     switch (Token) {
     default:  // End of attributes.
       return HaveError;
+    case lltok::kw_dereferencable: {
+      unsigned Bytes;
+      if (ParseOptionalDereferencableBytes(Bytes))
+        return true;
+      B.addDereferencableAttr(Bytes);
+      continue;
+    }
     case lltok::kw_inreg:           B.addAttribute(Attribute::InReg); break;
     case lltok::kw_noalias:         B.addAttribute(Attribute::NoAlias); break;
     case lltok::kw_nonnull:         B.addAttribute(Attribute::NonNull); break;
     case lltok::kw_signext:         B.addAttribute(Attribute::SExt); break;
     case lltok::kw_zeroext:         B.addAttribute(Attribute::ZExt); break;
 
     // Error handling.
     case lltok::kw_align:
bool LLParser::ParseOptionalAlignment(unsigned &Alignment) {
   if (ParseUInt32(Alignment)) return true;
   if (!isPowerOf2_32(Alignment))
     return Error(AlignLoc, "alignment is not a power of two");
   if (Alignment > Value::MaximumAlignment)
     return Error(AlignLoc, "huge alignments are not supported yet");
   return false;
 }
 
+/// ParseOptionalDereferencableBytes
+///   ::= /* empty */
+///   ::= 'dereferencable' '(' 4 ')'
+bool LLParser::ParseOptionalDereferencableBytes(unsigned &Bytes) {
+  Bytes = 0;
+  if (!EatIfPresent(lltok::kw_dereferencable))
+    return false;
+  LocTy ParenLoc = Lex.getLoc();
+  if (!EatIfPresent(lltok::lparen))
+    return Error(ParenLoc, "expected '('");
+  LocTy DerefLoc = Lex.getLoc();
+  if (ParseUInt32(Bytes)) return true;
+  ParenLoc = Lex.getLoc();
+  if (!EatIfPresent(lltok::rparen))
+    return Error(ParenLoc, "expected ')'");
+  if (!Bytes)
+    return Error(DerefLoc, "dereferencable bytes must be non-zero");
+  if (Bytes > 4095)
+    return Error(DerefLoc, "only 12-bit dereferencable-byte counts are supported");
+  return false;
+}
+
 /// ParseOptionalCommaAlign
 ///   ::=
 ///   ::= ',' align 4
 ///
 /// This returns with AteExtraComma set to true if it ate an excess comma at the
 /// end.
 bool LLParser::ParseOptionalCommaAlign(unsigned &Alignment,
                                        bool &AteExtraComma) {

lib/AsmParser/LLToken.h

enum Kind {
     // Attributes:
     kw_attributes,
     kw_alwaysinline,
     kw_sanitize_address,
     kw_builtin,
     kw_byval,
     kw_inalloca,
     kw_cold,
+    kw_dereferencable,
     kw_inlinehint,
     kw_inreg,
     kw_jumptable,
     kw_minsize,
     kw_naked,
     kw_nest,
     kw_noalias,
     kw_nobuiltin,

lib/Bitcode/Reader/BitcodeReader.cpp

static Attribute::AttrKind GetAttrFromCode(uint64_t Code) {
   case bitc::ATTR_KIND_NO_IMPLICIT_FLOAT:
     return Attribute::NoImplicitFloat;
   case bitc::ATTR_KIND_NO_INLINE:
     return Attribute::NoInline;
   case bitc::ATTR_KIND_NON_LAZY_BIND:
     return Attribute::NonLazyBind;
   case bitc::ATTR_KIND_NON_NULL:
     return Attribute::NonNull;
+  case bitc::ATTR_KIND_DEREFERENCABLE:
+    return Attribute::Dereferencable;
   case bitc::ATTR_KIND_NO_RED_ZONE:
     return Attribute::NoRedZone;
   case bitc::ATTR_KIND_NO_RETURN:
     return Attribute::NoReturn;
   case bitc::ATTR_KIND_NO_UNWIND:
     return Attribute::NoUnwind;
   case bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE:
     return Attribute::OptimizeForSize;
case bitc::PARAMATTR_GRP_CODE_ENTRY: { // ENTRY: [grpid, idx, a0, a1, ...]
       AttrBuilder B;
       for (unsigned i = 2, e = Record.size(); i != e; ++i) {
         if (Record[i] == 0) {        // Enum attribute
           Attribute::AttrKind Kind;
           if (std::error_code EC = ParseAttrKind(Record[++i], &Kind))
             return EC;
 
           B.addAttribute(Kind);
         } else if (Record[i] == 1) { // Align attribute
           Attribute::AttrKind Kind;
           if (std::error_code EC = ParseAttrKind(Record[++i], &Kind))
             return EC;
           if (Kind == Attribute::Alignment)
             B.addAlignmentAttr(Record[++i]);
-          else
+          else if (Kind == Attribute::StackAlignment)
             B.addStackAlignmentAttr(Record[++i]);
+          else if (Kind == Attribute::Dereferencable)
+            B.addDereferencableAttr(Record[++i]);
+          else
+            llvm_unreachable("Unknown integer attribute type");
         } else {                     // String attribute
           assert((Record[i] == 3 || Record[i] == 4) &&
                  "Invalid attribute group entry");
           bool HasValue = (Record[i++] == 4);
           SmallString<64> KindStr;
           SmallString<64> ValStr;
 
           while (Record[i] != 0 && i != e)

lib/Bitcode/Writer/BitcodeWriter.cpp

static uint64_t getAttrKindEncoding(Attribute::AttrKind Kind) {
   case Attribute::NoImplicitFloat:
     return bitc::ATTR_KIND_NO_IMPLICIT_FLOAT;
   case Attribute::NoInline:
     return bitc::ATTR_KIND_NO_INLINE;
   case Attribute::NonLazyBind:
     return bitc::ATTR_KIND_NON_LAZY_BIND;
   case Attribute::NonNull:
     return bitc::ATTR_KIND_NON_NULL;
+  case Attribute::Dereferencable:
+    return bitc::ATTR_KIND_DEREFERENCABLE;
   case Attribute::NoRedZone:
     return bitc::ATTR_KIND_NO_RED_ZONE;
   case Attribute::NoReturn:
     return bitc::ATTR_KIND_NO_RETURN;
   case Attribute::NoUnwind:
     return bitc::ATTR_KIND_NO_UNWIND;
   case Attribute::OptimizeForSize:
     return bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE;
for (unsigned i = 0, e = AS.getNumSlots(); i != e; ++i) {
       Record.push_back(AS.getSlotIndex(i));
 
       for (AttributeSet::iterator I = AS.begin(0), E = AS.end(0);
            I != E; ++I) {
         Attribute Attr = *I;
         if (Attr.isEnumAttribute()) {
           Record.push_back(0);
           Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));
-        } else if (Attr.isAlignAttribute()) {
+        } else if (Attr.isIntAttribute()) {
           Record.push_back(1);
           Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));
           Record.push_back(Attr.getValueAsInt());
         } else {
           StringRef Kind = Attr.getKindAsString();
           StringRef Val = Attr.getValueAsString();
 
           Record.push_back(Val.empty() ? 3 : 4);

lib/IR/AttributeImpl.h

class AttributeImpl : public FoldingSetNode {
 
   // AttributesImpl is uniqued, these should not be publicly available.
   void operator=(const AttributeImpl &) LLVM_DELETED_FUNCTION;
   AttributeImpl(const AttributeImpl &) LLVM_DELETED_FUNCTION;
 
 protected:
   enum AttrEntryKind {
     EnumAttrEntry,
-    AlignAttrEntry,
+    IntAttrEntry,
     StringAttrEntry
   };
 
   AttributeImpl(AttrEntryKind KindID) : KindID(KindID) {}
 
 public:
   virtual ~AttributeImpl();
 
   bool isEnumAttribute() const { return KindID == EnumAttrEntry; }
-  bool isAlignAttribute() const { return KindID == AlignAttrEntry; }
+  bool isIntAttribute() const { return KindID == IntAttrEntry; }
   bool isStringAttribute() const { return KindID == StringAttrEntry; }
 
   bool hasAttribute(Attribute::AttrKind A) const;
   bool hasAttribute(StringRef Kind) const;
 
   Attribute::AttrKind getKindAsEnum() const;
   uint64_t getValueAsInt() const;
 
   StringRef getKindAsString() const;
   StringRef getValueAsString() const;
 
   /// \brief Used when sorting the attributes.
   bool operator<(const AttributeImpl &AI) const;
 
   void Profile(FoldingSetNodeID &ID) const {
     if (isEnumAttribute())
       Profile(ID, getKindAsEnum(), 0);
-    else if (isAlignAttribute())
+    else if (isIntAttribute())
       Profile(ID, getKindAsEnum(), getValueAsInt());
     else
       Profile(ID, getKindAsString(), getValueAsString());
   }
   static void Profile(FoldingSetNodeID &ID, Attribute::AttrKind Kind,
                       uint64_t Val) {
     ID.AddInteger(Kind);
     if (Val) ID.AddInteger(Val);

 
 public:
   EnumAttributeImpl(Attribute::AttrKind Kind)
       : AttributeImpl(EnumAttrEntry), Kind(Kind) {}
 
   Attribute::AttrKind getEnumKind() const { return Kind; }
 };
 
-class AlignAttributeImpl : public EnumAttributeImpl {
+class IntAttributeImpl : public EnumAttributeImpl {
   void anchor() override;
-  unsigned Align;
+  unsigned Val;
 
 public:
-  AlignAttributeImpl(Attribute::AttrKind Kind, unsigned Align)
-      : EnumAttributeImpl(AlignAttrEntry, Kind), Align(Align) {
+  IntAttributeImpl(Attribute::AttrKind Kind, unsigned Val)
+      : EnumAttributeImpl(IntAttrEntry, Kind), Val(Val) {
     assert(
-        (Kind == Attribute::Alignment || Kind == Attribute::StackAlignment) &&
-        "Wrong kind for alignment attribute!");
+        (Kind == Attribute::Alignment || Kind == Attribute::StackAlignment ||
+         Kind == Attribute::Dereferencable) &&
+        "Wrong kind for int attribute!");
   }
 
-  unsigned getAlignment() const { return Align; }
+  unsigned getValue() const { return Val; }
 };
 
 class StringAttributeImpl : public AttributeImpl {
   virtual void anchor();
   std::string Kind;
   std::string Val;
 
 public:
public:
   bool hasAttribute(StringRef Kind) const;
   bool hasAttributes() const { return NumAttrs != 0; }
 
   Attribute getAttribute(Attribute::AttrKind Kind) const;
   Attribute getAttribute(StringRef Kind) const;
 
   unsigned getAlignment() const;
   unsigned getStackAlignment() const;
+  unsigned getDereferencableBytes() const;
   std::string getAsString(bool InAttrGrp) const;
 
   typedef const Attribute *iterator;
   iterator begin() const { return reinterpret_cast<iterator>(this + 1); }
   iterator end() const { return begin() + NumAttrs; }
 
   void Profile(FoldingSetNodeID &ID) const {
     Profile(ID, makeArrayRef(begin(), end()));

lib/IR/Attributes.cpp

Attribute Attribute::get(LLVMContext &Context, Attribute::AttrKind Kind,
   AttributeImpl *PA = pImpl->AttrsSet.FindNodeOrInsertPos(ID, InsertPoint);
 
   if (!PA) {
     // If we didn't find any existing attributes of the same shape then create a
     // new one and insert it.
     if (!Val)
       PA = new EnumAttributeImpl(Kind);
     else
-      PA = new AlignAttributeImpl(Kind, Val);
+      PA = new IntAttributeImpl(Kind, Val);
     pImpl->AttrsSet.InsertNode(PA, InsertPoint);
   }
 
   // Return the Attribute that we found or created.
   return Attribute(PA);
 }
 
 Attribute Attribute::get(LLVMContext &Context, StringRef Kind, StringRef Val) {

 
 Attribute Attribute::getWithStackAlignment(LLVMContext &Context,
                                            uint64_t Align) {
   assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
   assert(Align <= 0x100 && "Alignment too large.");
   return get(Context, StackAlignment, Align);
 }
 
+Attribute Attribute::getWithDereferencableBytes(LLVMContext &Context,
+                                                uint64_t Bytes) {
+  assert(Bytes && "Bytes must be positive.");
+  assert(Bytes < 4096 && "Bytes is limited to 12 bits.");
+  return get(Context, Dereferencable, Bytes);
+}
+
 //===----------------------------------------------------------------------===//
 // Attribute Accessor Methods
 //===----------------------------------------------------------------------===//
 
 bool Attribute::isEnumAttribute() const {
   return pImpl && pImpl->isEnumAttribute();
 }
 
-bool Attribute::isAlignAttribute() const {
-  return pImpl && pImpl->isAlignAttribute();
+bool Attribute::isIntAttribute() const {
+  return pImpl && pImpl->isIntAttribute();
 }
 
 bool Attribute::isStringAttribute() const {
   return pImpl && pImpl->isStringAttribute();
 }
 
 Attribute::AttrKind Attribute::getKindAsEnum() const {
   if (!pImpl) return None;
-  assert((isEnumAttribute() || isAlignAttribute()) &&
+  assert((isEnumAttribute() || isIntAttribute()) &&
          "Invalid attribute type to get the kind as an enum!");
   return pImpl ? pImpl->getKindAsEnum() : None;
 }
 
 uint64_t Attribute::getValueAsInt() const {
   if (!pImpl) return 0;
-  assert(isAlignAttribute() &&
-         "Expected the attribute to be an alignment attribute!");
+  assert(isIntAttribute() &&
+         "Expected the attribute to be an integer attribute!");
   return pImpl ? pImpl->getValueAsInt() : 0;
 }
 
 StringRef Attribute::getKindAsString() const {
   if (!pImpl) return StringRef();
   assert(isStringAttribute() &&
          "Invalid attribute type to get the kind as a string!");
   return pImpl ? pImpl->getKindAsString() : StringRef();

 /// This returns the stack alignment field of an attribute as a byte alignment
 /// value.
 unsigned Attribute::getStackAlignment() const {
   assert(hasAttribute(Attribute::StackAlignment) &&
          "Trying to get alignment from non-alignment attribute!");
   return pImpl->getValueAsInt();
 }
 
+/// This returns the number of dereferencable bytes.
+unsigned Attribute::getDereferencableBytes() const {
+  assert(hasAttribute(Attribute::Dereferencable) &&
+         "Trying to get dereferencable bytes from "
+         "non-dereferencable attribute!");
+  return pImpl->getValueAsInt();
+}
+
 std::string Attribute::getAsString(bool InAttrGrp) const {
   if (!pImpl) return "";
 
   if (hasAttribute(Attribute::SanitizeAddress))
     return "sanitize_address";
   if (hasAttribute(Attribute::AlwaysInline))
     return "alwaysinline";
   if (hasAttribute(Attribute::Builtin))
if (hasAttribute(Attribute::StackAlignment)) {
     } else {
       Result += "(";
       Result += utostr(getValueAsInt());
       Result += ")";
     }
     return Result;
   }
 
+  if (hasAttribute(Attribute::Dereferencable)) {
+    std::string Result;
+    Result += "dereferencable";
+    if (InAttrGrp) {
+      Result += "=";
+      Result += utostr(getValueAsInt());
+    } else {
+      Result += "(";
+      Result += utostr(getValueAsInt());
+      Result += ")";
+    }
+    return Result;
+  }
+
   // Convert target-dependent attributes to strings of the form:
   //
   //   "kind"
   //   "kind" = "value"
   //
   if (isStringAttribute()) {
     std::string Result;
     Result += '\"' + getKindAsString().str() + '"';

 
 //===----------------------------------------------------------------------===//
 // AttributeImpl Definition
 //===----------------------------------------------------------------------===//
 
 // Pin the vtables to this file.
 AttributeImpl::~AttributeImpl() {}
 void EnumAttributeImpl::anchor() {}
-void AlignAttributeImpl::anchor() {}
+void IntAttributeImpl::anchor() {}
 void StringAttributeImpl::anchor() {}
 
 bool AttributeImpl::hasAttribute(Attribute::AttrKind A) const {
   if (isStringAttribute()) return false;
   return getKindAsEnum() == A;
 }
 
 bool AttributeImpl::hasAttribute(StringRef Kind) const {
   if (!isStringAttribute()) return false;
   return getKindAsString() == Kind;
 }
 
 Attribute::AttrKind AttributeImpl::getKindAsEnum() const {
-  assert(isEnumAttribute() || isAlignAttribute());
+  assert(isEnumAttribute() || isIntAttribute());
   return static_cast<const EnumAttributeImpl *>(this)->getEnumKind();
 }
 
 uint64_t AttributeImpl::getValueAsInt() const {
-  assert(isAlignAttribute());
-  return static_cast<const AlignAttributeImpl *>(this)->getAlignment();
+  assert(isIntAttribute());
+  return static_cast<const IntAttributeImpl *>(this)->getValue();
 }
 
 StringRef AttributeImpl::getKindAsString() const {
   assert(isStringAttribute());
   return static_cast<const StringAttributeImpl *>(this)->getStringKind();
 }
 
 StringRef AttributeImpl::getValueAsString() const {
   assert(isStringAttribute());
   return static_cast<const StringAttributeImpl *>(this)->getStringValue();
 }
 
 bool AttributeImpl::operator<(const AttributeImpl &AI) const {
   // This sorts the attributes with Attribute::AttrKinds coming first (sorted
   // relative to their enum value) and then strings.
   if (isEnumAttribute()) {
     if (AI.isEnumAttribute()) return getKindAsEnum() < AI.getKindAsEnum();
-    if (AI.isAlignAttribute()) return true;
+    if (AI.isIntAttribute()) return true;
     if (AI.isStringAttribute()) return true;
   }
 
-  if (isAlignAttribute()) {
+  if (isIntAttribute()) {
     if (AI.isEnumAttribute()) return false;
-    if (AI.isAlignAttribute()) return getValueAsInt() < AI.getValueAsInt();
+    if (AI.isIntAttribute()) return getValueAsInt() < AI.getValueAsInt();
     if (AI.isStringAttribute()) return true;
   }
 
   if (AI.isEnumAttribute()) return false;
-  if (AI.isAlignAttribute()) return false;
+  if (AI.isIntAttribute()) return false;
   if (getKindAsString() == AI.getKindAsString())
     return getValueAsString() < AI.getValueAsString();
   return getKindAsString() < AI.getKindAsString();
 }
 
 uint64_t AttributeImpl::getAttrMask(Attribute::AttrKind Val) {
   // FIXME: Remove this.
   switch (Val) {
uint64_t AttributeImpl::getAttrMask(Attribute::AttrKind Val) {
   case Attribute::NoBuiltin:       return 1ULL << 38;
   case Attribute::Returned:        return 1ULL << 39;
   case Attribute::Cold:            return 1ULL << 40;
   case Attribute::Builtin:         return 1ULL << 41;
   case Attribute::OptimizeNone:    return 1ULL << 42;
   case Attribute::InAlloca:        return 1ULL << 43;
   case Attribute::NonNull:         return 1ULL << 44;
   case Attribute::JumpTable:       return 1ULL << 45;
+  case Attribute::Dereferencable:  return 4095ULL << 46;
   }
   llvm_unreachable("Unsupported attribute type");
 }
 
 //===----------------------------------------------------------------------===//
 // AttributeSetNode Definition
 //===----------------------------------------------------------------------===//
 

 
 unsigned AttributeSetNode::getStackAlignment() const {
   for (iterator I = begin(), E = end(); I != E; ++I)
     if (I->hasAttribute(Attribute::StackAlignment))
       return I->getStackAlignment();
   return 0;
 }
 
+unsigned AttributeSetNode::getDereferencableBytes() const {
+  for (iterator I = begin(), E = end(); I != E; ++I)
+    if (I->hasAttribute(Attribute::Dereferencable))
+      return I->getDereferencableBytes();
+  return 0;
+}
+
 std::string AttributeSetNode::getAsString(bool InAttrGrp) const {
   std::string Str;
   for (iterator I = begin(), E = end(); I != E; ++I) {
     if (I != begin())
       Str += ' ';
     Str += I->getAsString(InAttrGrp);
   }
   return Str;
for (AttributeSetNode::iterator II = ASN->begin(),
       if (Attr.isStringAttribute()) continue;
 
       Attribute::AttrKind Kind = Attr.getKindAsEnum();
 
       if (Kind == Attribute::Alignment)
         Mask |= (Log2_32(ASN->getAlignment()) + 1) << 16;
       else if (Kind == Attribute::StackAlignment)
         Mask |= (Log2_32(ASN->getStackAlignment()) + 1) << 26;
+      else if (Kind == Attribute::Dereferencable)
+        Mask |= uint64_t(ASN->getDereferencableBytes()) << 46;
       else
         Mask |= AttributeImpl::getAttrMask(Kind);
     }
 
     return Mask;
   }
 
   return 0;
if (!B.contains(Kind))
       continue;
 
     if (Kind == Attribute::Alignment)
       Attrs.push_back(std::make_pair(Index, Attribute::
                                      getWithAlignment(C, B.getAlignment())));
     else if (Kind == Attribute::StackAlignment)
       Attrs.push_back(std::make_pair(Index, Attribute::
                               getWithStackAlignment(C, B.getStackAlignment())));
+    else if (Kind == Attribute::Dereferencable)
+      Attrs.push_back(std::make_pair(Index,
+                                     Attribute::getWithDereferencableBytes(C,
+                                       B.getDereferencableBytes())));
     else
       Attrs.push_back(std::make_pair(Index, Attribute::get(C, Kind)));
   }
 
   // Add target-dependent (string) attributes.
   for (const AttrBuilder::td_type &TDA : B.td_attrs())
     Attrs.push_back(
         std::make_pair(Index, Attribute::get(C, TDA.first, TDA.second)));
unsigned AttributeSet::getParamAlignment(unsigned Index) const {
   return ASN ? ASN->getAlignment() : 0;
 }
 
 unsigned AttributeSet::getStackAlignment(unsigned Index) const {
   AttributeSetNode *ASN = getAttributes(Index);
   return ASN ? ASN->getStackAlignment() : 0;
 }
 
+unsigned AttributeSet::getDereferencableBytes(unsigned Index) const {
+  AttributeSetNode *ASN = getAttributes(Index);
+  return ASN ? ASN->getDereferencableBytes() : 0;
+}
+
 std::string AttributeSet::getAsString(unsigned Index,
                                       bool InAttrGrp) const {
   AttributeSetNode *ASN = getAttributes(Index);
   return ASN ? ASN->getAsString(InAttrGrp) : std::string("");
 }
 
 /// \brief The attributes for the specified index are returned.
 AttributeSetNode *AttributeSet::getAttributes(unsigned Index) const {
void AttributeSet::dump() const {
   dbgs() << "]\n";
 }
 
 //===----------------------------------------------------------------------===//
 // AttrBuilder Method Implementations
 //===----------------------------------------------------------------------===//
 
 AttrBuilder::AttrBuilder(AttributeSet AS, unsigned Index)
-  : Attrs(0), Alignment(0), StackAlignment(0) {
+  : Attrs(0), Alignment(0), StackAlignment(0), DerefBytes(0) {
   AttributeSetImpl *pImpl = AS.pImpl;
   if (!pImpl) return;
 
   for (unsigned I = 0, E = pImpl->getNumAttributes(); I != E; ++I) {
     if (pImpl->getSlotIndex(I) != Index) continue;
 
     for (AttributeSetImpl::iterator II = pImpl->begin(I),
            IE = pImpl->end(I); II != IE; ++II)
       addAttribute(*II);
 
     break;
   }
 }
 
 void AttrBuilder::clear() {
   Attrs.reset();
-  Alignment = StackAlignment = 0;
+  Alignment = StackAlignment = DerefBytes = 0;
 }
 
 AttrBuilder &AttrBuilder::addAttribute(Attribute::AttrKind Val) {
   assert((unsigned)Val < Attribute::EndAttrKinds && "Attribute out of range!");
   assert(Val != Attribute::Alignment && Val != Attribute::StackAlignment &&
-         "Adding alignment attribute without adding alignment value!");
+         Val != Attribute::Dereferencable &&
+         "Adding integer attribute without adding a value!");
   Attrs[Val] = true;
   return *this;
 }
 
 AttrBuilder &AttrBuilder::addAttribute(Attribute Attr) {
   if (Attr.isStringAttribute()) {
     addAttribute(Attr.getKindAsString(), Attr.getValueAsString());
     return *this;
   }
 
   Attribute::AttrKind Kind = Attr.getKindAsEnum();
   Attrs[Kind] = true;
 
   if (Kind == Attribute::Alignment)
     Alignment = Attr.getAlignment();
   else if (Kind == Attribute::StackAlignment)
     StackAlignment = Attr.getStackAlignment();
+  else if (Kind == Attribute::Dereferencable)
+    DerefBytes = Attr.getDereferencableBytes();
   return *this;
 }
 
 AttrBuilder &AttrBuilder::addAttribute(StringRef A, StringRef V) {
   TargetDepAttrs[A] = V;
   return *this;
 }
 
 AttrBuilder &AttrBuilder::removeAttribute(Attribute::AttrKind Val) {
   assert((unsigned)Val < Attribute::EndAttrKinds && "Attribute out of range!");
   Attrs[Val] = false;
 
   if (Val == Attribute::Alignment)
     Alignment = 0;
   else if (Val == Attribute::StackAlignment)
     StackAlignment = 0;
+  else if (Val == Attribute::Dereferencable)
+    DerefBytes = 0;
 
   return *this;
 }
 
 AttrBuilder &AttrBuilder::removeAttributes(AttributeSet A, uint64_t Index) {
   unsigned Slot = ~0U;
   for (unsigned I = 0, E = A.getNumSlots(); I != E; ++I)
     if (A.getSlotIndex(I) == Index) {
       Slot = I;
       break;
     }
 
   assert(Slot != ~0U && "Couldn't find index in AttributeSet!");
 
   for (AttributeSet::iterator I = A.begin(Slot), E = A.end(Slot); I != E; ++I) {
     Attribute Attr = *I;
-    if (Attr.isEnumAttribute() || Attr.isAlignAttribute()) {
+    if (Attr.isEnumAttribute() || Attr.isIntAttribute()) {
       Attribute::AttrKind Kind = I->getKindAsEnum();
       Attrs[Kind] = false;
 
       if (Kind == Attribute::Alignment)
         Alignment = 0;
       else if (Kind == Attribute::StackAlignment)
         StackAlignment = 0;
+      else if (Kind == Attribute::Dereferencable)
+        DerefBytes = 0;
     } else {
       assert(Attr.isStringAttribute() && "Invalid attribute type!");
       std::map<std::string, std::string>::iterator
         Iter = TargetDepAttrs.find(Attr.getKindAsString());
       if (Iter != TargetDepAttrs.end())
         TargetDepAttrs.erase(Iter);
     }
   }
AttrBuilder &AttrBuilder::addStackAlignmentAttr(unsigned Align) {
   assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
   assert(Align <= 0x100 && "Alignment too large.");
 
   Attrs[Attribute::StackAlignment] = true;
   StackAlignment = Align;
   return *this;
 }
 
+AttrBuilder &AttrBuilder::addDereferencableAttr(unsigned Bytes) {
+  if (Bytes == 0) return *this;
+
+  assert(Bytes <= 4095 && "Too many bytes.");
+
+  Attrs[Attribute::Dereferencable] = true;
+  DerefBytes = Bytes;
+  return *this;
+}
+
 AttrBuilder &AttrBuilder::merge(const AttrBuilder &B) {
   // FIXME: What if both have alignments, but they don't match?!
   if (!Alignment)
     Alignment = B.Alignment;
 
   if (!StackAlignment)
     StackAlignment = B.StackAlignment;
 
+  if (!DerefBytes)
+    DerefBytes = B.DerefBytes;
+
   Attrs |= B.Attrs;
 
   for (td_const_iterator I = B.TargetDepAttrs.begin(),
          E = B.TargetDepAttrs.end(); I != E; ++I)
     TargetDepAttrs[I->first] = I->second;
 
   return *this;
 }
if (A.getSlotIndex(I) == Index) {
       break;
     }
 
   assert(Slot != ~0U && "Couldn't find the index!");
 
   for (AttributeSet::iterator I = A.begin(Slot), E = A.end(Slot);
        I != E; ++I) {
     Attribute Attr = *I;
-    if (Attr.isEnumAttribute() || Attr.isAlignAttribute()) {
+    if (Attr.isEnumAttribute() || Attr.isIntAttribute()) {
       if (Attrs[I->getKindAsEnum()])
         return true;
     } else {
       assert(Attr.isStringAttribute() && "Invalid attribute kind!");
       return TargetDepAttrs.find(Attr.getKindAsString())!=TargetDepAttrs.end();
     }
   }
 
   return false;
 }
 
 bool AttrBuilder::hasAlignmentAttr() const {
   return Alignment != 0;
 }
 
 bool AttrBuilder::operator==(const AttrBuilder &B) {
   if (Attrs != B.Attrs)
     return false;
 
   for (td_const_iterator I = TargetDepAttrs.begin(),
          E = TargetDepAttrs.end(); I != E; ++I)
     if (B.TargetDepAttrs.find(I->first) == B.TargetDepAttrs.end())
       return false;
 
-  return Alignment == B.Alignment && StackAlignment == B.StackAlignment;
+  return Alignment == B.Alignment && StackAlignment == B.StackAlignment &&
+         DerefBytes == B.DerefBytes;
 }
 
 AttrBuilder &AttrBuilder::addRawValue(uint64_t Val) {
   // FIXME: Remove this in 4.0.
   if (!Val) return *this;
 
   for (Attribute::AttrKind I = Attribute::None; I != Attribute::EndAttrKinds;
        I = Attribute::AttrKind(I + 1)) {
     if (uint64_t A = (Val & AttributeImpl::getAttrMask(I))) {
       Attrs[I] = true;
  
       if (I == Attribute::Alignment)
         Alignment = 1ULL << ((A >> 16) - 1);
       else if (I == Attribute::StackAlignment)
         StackAlignment = 1ULL << ((A >> 26)-1);
+      else if (I == Attribute::Dereferencable)
+        DerefBytes = A >> 46;
     }
   }
  
   return *this;
 }
 
 //===----------------------------------------------------------------------===//
 // AttributeFuncs Function Defintions
AttributeSet AttributeFuncs::typeIncompatible(Type *Ty, uint64_t Index) {
 
   if (!Ty->isPointerTy())
     // Attribute that only apply to pointers.
     Incompatible.addAttribute(Attribute::ByVal)
       .addAttribute(Attribute::Nest)
       .addAttribute(Attribute::NoAlias)
       .addAttribute(Attribute::NoCapture)
       .addAttribute(Attribute::NonNull)
+      .addDereferencableAttr(1) // the int here is ignored
       .addAttribute(Attribute::ReadNone)
       .addAttribute(Attribute::ReadOnly)
       .addAttribute(Attribute::StructRet)
       .addAttribute(Attribute::InAlloca);
 
   return AttributeSet::get(Ty->getContext(), Index, Incompatible);
 }

lib/IR/Function.cpp

 }
 
 unsigned Argument::getParamAlignment() const {
   assert(getType()->isPointerTy() && "Only pointers have alignments");
   return getParent()->getParamAlignment(getArgNo()+1);
 
 }
 
+unsigned Argument::getDereferencableBytes() const {
+  assert(getType()->isPointerTy() &&
+         "Only pointers have dereferencable bytes");
+  return getParent()->getDereferencableBytes(getArgNo()+1);
+}
+
 /// hasNestAttr - Return true if this argument has the nest attribute on
 /// it in its containing function.
 bool Argument::hasNestAttr() const {
   if (!getType()->isPointerTy()) return false;
   return getParent()->getAttributes().
     hasAttribute(getArgNo()+1, Attribute::Nest);
 }
 

lib/IR/Value.cpp

 // This file implements the Value, ValueHandle, and User classes.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/Value.h"
 #include "LLVMContextImpl.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/IR/CallSite.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LeakDetector.h"
if (const BitCastInst* BC = dyn_cast<BitCastInst>(V)) {
            DL->getABITypeAlignment(DTy)))
         return isDereferenceablePointer(BC->getOperand(0), DL, Visited);
     }
 
   // Global variables which can't collapse to null are ok.
   if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V))
     return !GV->hasExternalWeakLinkage();
 
-  // byval arguments are ok.
-  if (const Argument *A = dyn_cast<Argument>(V))
-    return A->hasByValAttr();
+  // byval arguments are okay. Arguments specifically marked as
+  // dereferencable are okay too.
+  if (const Argument *A = dyn_cast<Argument>(V)) {
+    if (A->hasByValAttr())
+      return true;
+    else if (unsigned Bytes = A->getDereferencableBytes()) {
+      Type *Ty = V->getType()->getPointerElementType();
+      if (Ty->isSized() && DL && DL->getTypeStoreSize(Ty) <= Bytes)
+        return true;
+    }
+
+    return false;
+  }
+
+  // Return values from call sites specifically marked as dereferencable are
+  // also okay.
+  if (ImmutableCallSite CS = V) {
+    if (unsigned Bytes = CS.getDereferencableBytes(0)) {
+      Type *Ty = V->getType()->getPointerElementType();
+      if (Ty->isSized() && DL && DL->getTypeStoreSize(Ty) <= Bytes)
+        return true;
+    }
+  }
 
   // For GEPs, determine if the indexing lands within the allocated object.
   if (const GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
     // Conservatively require that the base pointer be fully dereferenceable.
     if (!Visited.insert(GEP->getOperand(0)))
       return false;
     if (!isDereferenceablePointer(GEP->getOperand(0), DL, Visited))
       return false;

test/Bitcode/attributes.ll

 }
 
 define void @f38() unnamed_addr jumptable {
 ; CHECK: define void @f38() unnamed_addr #24
     call void bitcast (void (i8*)* @f36 to void ()*)()
     unreachable
 }
 
+define dereferencable(2) i8* @f39(i8* dereferencable(1) %a) {
+; CHECK: define dereferencable(2) i8* @f39(i8* dereferencable(1) %a) {
+        ret i8* %a
+}
+
 ; CHECK: attributes #0 = { noreturn }
 ; CHECK: attributes #1 = { nounwind }
 ; CHECK: attributes #2 = { readnone }
 ; CHECK: attributes #3 = { readonly }
 ; CHECK: attributes #4 = { noinline }
 ; CHECK: attributes #5 = { alwaysinline }
 ; CHECK: attributes #6 = { optsize }
 ; CHECK: attributes #7 = { ssp }

test/Transforms/LICM/hoist-deref-load.ll

+; RUN: opt -S -basicaa -licm < %s | FileCheck %s
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; This test represents the following function:
+; void test1(int * __restrict__ a, int * __restrict__ b, int &c, int n) {
+;   for (int i = 0; i < n; ++i)
+;     if (a[i] > 0)
+;       a[i] = c*b[i];
+; }
+; and we want to hoist the load of %c out of the loop. This can be done only
+; because the dereferencable attribute is on %c.
+
+; CHECK-LABEL: @test1
+; CHECK: load i32* %c, align 4
+; CHECK: for.body:
+
+define void @test1(i32* noalias nocapture %a, i32* noalias nocapture readonly %b, i32* nocapture readonly nonnull dereferencable(4) %c, i32 %n) #0 {
+entry:
+  %cmp11 = icmp sgt i32 %n, 0
+  br i1 %cmp11, label %for.body, label %for.end
+
+for.body:                                         ; preds = %entry, %for.inc
+  %indvars.iv = phi i64 [ %indvars.iv.next, %for.inc ], [ 0, %entry ]
+  %arrayidx = getelementptr inbounds i32* %a, i64 %indvars.iv
+  %0 = load i32* %arrayidx, align 4
+  %cmp1 = icmp sgt i32 %0, 0
+  br i1 %cmp1, label %if.then, label %for.inc
+
+if.then:                                          ; preds = %for.body
+  %1 = load i32* %c, align 4
+  %arrayidx3 = getelementptr inbounds i32* %b, i64 %indvars.iv
+  %2 = load i32* %arrayidx3, align 4
+  %mul = mul nsw i32 %2, %1
+  store i32 %mul, i32* %arrayidx, align 4
+  br label %for.inc
+
+for.inc:                                          ; preds = %for.body, %if.then
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+  %lftr.wideiv = trunc i64 %indvars.iv.next to i32
+  %exitcond = icmp eq i32 %lftr.wideiv, %n
+  br i1 %exitcond, label %for.end, label %for.body
+
+for.end:                                          ; preds = %for.inc, %entry
+  ret void
+}
+
+; This is the same as @test1, but without the dereferencable attribute on %c.
+; Without this attribute, we should not hoist the load of %c.
+
+; CHECK-LABEL: @test2
+; CHECK: if.then:
+; CHECK: load i32* %c, align 4
+
+define void @test2(i32* noalias nocapture %a, i32* noalias nocapture readonly %b, i32* nocapture readonly nonnull %c, i32 %n) #0 {
+entry:
+  %cmp11 = icmp sgt i32 %n, 0
+  br i1 %cmp11, label %for.body, label %for.end
+
+for.body:                                         ; preds = %entry, %for.inc
+  %indvars.iv = phi i64 [ %indvars.iv.next, %for.inc ], [ 0, %entry ]
+  %arrayidx = getelementptr inbounds i32* %a, i64 %indvars.iv
+  %0 = load i32* %arrayidx, align 4
+  %cmp1 = icmp sgt i32 %0, 0
+  br i1 %cmp1, label %if.then, label %for.inc
+
+if.then:                                          ; preds = %for.body
+  %1 = load i32* %c, align 4
+  %arrayidx3 = getelementptr inbounds i32* %b, i64 %indvars.iv
+  %2 = load i32* %arrayidx3, align 4
+  %mul = mul nsw i32 %2, %1
+  store i32 %mul, i32* %arrayidx, align 4
+  br label %for.inc
+
+for.inc:                                          ; preds = %for.body, %if.then
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+  %lftr.wideiv = trunc i64 %indvars.iv.next to i32
+  %exitcond = icmp eq i32 %lftr.wideiv, %n
+  br i1 %exitcond, label %for.end, label %for.body
+
+for.end:                                          ; preds = %for.inc, %entry
+  ret void
+}
+
+attributes #0 = { nounwind uwtable }
+