maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/llvm/lib/IR/Attributes.cpp

1512 lines
49 KiB
C++
Raw Normal View History

Remove the AttributeWithIndex class. The AttributeWithIndex class exposed the interior structure of the AttributeSet class. That was gross. Remove it and all of the code that relied upon it. llvm-svn: 173722
2013-01-29 05:55:20 +08:00
//===-- Attributes.cpp - Implement AttributesList -------------------------===//
Split param attr implementation out from Function.cpp into its own file. Don't #include ParameterAttributes.h into any major public header files: just move methods out of line as appropriate. llvm-svn: 45517
2008-01-03 07:42:30 +08:00
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
Remove the AttributeWithIndex class. The AttributeWithIndex class exposed the interior structure of the AttributeSet class. That was gross. Remove it and all of the code that relied upon it. llvm-svn: 173722
2013-01-29 05:55:20 +08:00
// \file
// \brief This file implements the Attribute, AttributeImpl, AttrBuilder,
s/AttributeListImpl/AttributeSetImpl/g to match the namechange of AttributeList. llvm-svn: 170600
2012-12-20 06:42:22 +08:00
// AttributeSetImpl, and AttributeSet classes.
Split param attr implementation out from Function.cpp into its own file. Don't #include ParameterAttributes.h into any major public header files: just move methods out of line as appropriate. llvm-svn: 45517
2008-01-03 07:42:30 +08:00
//
//===----------------------------------------------------------------------===//
Move all of the header files which are involved in modelling the LLVM IR into their new header subdirectory: include/llvm/IR. This matches the directory structure of lib, and begins to correct a long standing point of file layout clutter in LLVM. There are still more header files to move here, but I wanted to handle them in separate commits to make tracking what files make sense at each layer easier. The only really questionable files here are the target intrinsic tablegen files. But that's a battle I'd rather not fight today. I've updated both CMake and Makefile build systems (I think, and my tests think, but I may have missed something). I've also re-sorted the includes throughout the project. I'll be committing updates to Clang, DragonEgg, and Polly momentarily. llvm-svn: 171366
2013-01-02 19:36:10 +08:00
#include "llvm/IR/Attributes.h"
Provide a way to specify inliner's attribute compatibility and merging. This reapplies r256277 with two changes: - In emitFnAttrCompatCheck, change FuncName's type to std::string to fix a use-after-free bug. - Remove an unnecessary install-local target in lib/IR/Makefile. Original commit message for r252949: Provide a way to specify inliner's attribute compatibility and merging rules using table-gen. NFC. This commit adds new classes CompatRule and MergeRule to Attributes.td, which are used to generate code to check attribute compatibility and merge attributes of the caller and callee. rdar://problem/19836465 llvm-svn: 256304
2015-12-23 07:57:37 +08:00
#include "llvm/IR/Function.h"
s/AttributesImpl/AttributeImpl/g This is going to apply to Attribute, not Attributes. llvm-svn: 170631
2012-12-20 09:36:59 +08:00
#include "AttributeImpl.h"
Initial commit for the AttributesImpl class. This opaque class will contain all of the attributes. All attribute queries will go through this object. This object will also be uniqued in the LLVMContext. Currently not used, so no implementation change. llvm-svn: 164722
2012-09-27 05:07:29 +08:00
#include "LLVMContextImpl.h"
Retire llvm::array_endof in favor of non-member std::end. While there make array_lengthof constexpr if we have support for it. llvm-svn: 206112
2014-04-13 00:15:53 +08:00
#include "llvm/ADT/STLExtras.h"
Use the new script to sort the includes of every file under lib. Sooooo many of these had incorrect or strange main module includes. I have manually inspected all of these, and fixed the main module include to be the nearest plausible thing I could find. If you own or care about any of these source files, I encourage you to take some time and check that these edits were sensible. I can't have broken anything (I strictly added headers, and reordered them, never removed), but they may not be the headers you'd really like to identify as containing the API being implemented. Many forward declarations and missing includes were added to a header files to allow them to parse cleanly when included first. The main module rule does in fact have its merits. =] llvm-svn: 169131
2012-12-04 00:50:05 +08:00
#include "llvm/ADT/StringExtras.h"
Move all of the header files which are involved in modelling the LLVM IR into their new header subdirectory: include/llvm/IR. This matches the directory structure of lib, and begins to correct a long standing point of file layout clutter in LLVM. There are still more header files to move here, but I wanted to handle them in separate commits to make tracking what files make sense at each layer easier. The only really questionable files here are the target intrinsic tablegen files. But that's a battle I'd rather not fight today. I've updated both CMake and Makefile build systems (I think, and my tests think, but I may have missed something). I've also re-sorted the includes throughout the project. I'll be committing updates to Clang, DragonEgg, and Polly momentarily. llvm-svn: 171366
2013-01-02 19:36:10 +08:00
#include "llvm/IR/Type.h"
Revert "[C++11] Replace LLVM atomics with std::atomic." Breaks the MSVC build. DataStream.cpp(44): error C2552: 'llvm::Statistic::Value' : non-aggregates cannot be initialized with initializer list llvm-svn: 202731
2014-03-04 02:02:34 +08:00
#include "llvm/Support/Atomic.h"
Change errs() to dbgs(). llvm-svn: 92658
2010-01-05 09:29:58 +08:00
#include "llvm/Support/Debug.h"
Split param attr implementation out from Function.cpp into its own file. Don't #include ParameterAttributes.h into any major public header files: just move methods out of line as appropriate. llvm-svn: 45517
2008-01-03 07:42:30 +08:00
#include "llvm/Support/ManagedStatic.h"
Use the new script to sort the includes of every file under lib. Sooooo many of these had incorrect or strange main module includes. I have manually inspected all of these, and fixed the main module include to be the nearest plausible thing I could find. If you own or care about any of these source files, I encourage you to take some time and check that these edits were sensible. I can't have broken anything (I strictly added headers, and reordered them, never removed), but they may not be the headers you'd really like to identify as containing the API being implemented. Many forward declarations and missing includes were added to a header files to allow them to parse cleanly when included first. The main module rule does in fact have its merits. =] llvm-svn: 169131
2012-12-04 00:50:05 +08:00
#include "llvm/Support/Mutex.h"
Kill off more cerr/cout uses and prune includes a bit. llvm-svn: 79852
2009-08-23 19:37:21 +08:00
#include "llvm/Support/raw_ostream.h"
Create a new class: AttributeSetNode. This is a helper class for the AttributeSetImpl class. It holds a set of attributes that apply to a single element: function, return type, or parameter. These are uniqued. llvm-svn: 173310
2013-01-24 08:06:56 +08:00
#include <algorithm>
Split param attr implementation out from Function.cpp into its own file. Don't #include ParameterAttributes.h into any major public header files: just move methods out of line as appropriate. llvm-svn: 45517
2008-01-03 07:42:30 +08:00
using namespace llvm;
Reimplement the parameter attributes support, phase #1. hilights: 1. There is now a "PAListPtr" class, which is a smart pointer around the underlying uniqued parameter attribute list object, and manages its refcount. It is now impossible to mess up the refcount. 2. PAListPtr is now the main interface to the underlying object, and the underlying object is now completely opaque. 3. Implementation details like SmallVector and FoldingSet are now no longer part of the interface. 4. You can create a PAListPtr with an arbitrary sequence of ParamAttrsWithIndex's, no need to make a SmallVector of a specific size (you can just use an array or scalar or vector if you wish). 5. All the client code that had to check for a null pointer before dereferencing the pointer is simplified to just access the PAListPtr directly. 6. The interfaces for adding attrs to a list and removing them is a bit simpler. Phase #2 will rename some stuff (e.g. PAListPtr) and do other less invasive changes. llvm-svn: 48289
2008-03-13 01:45:29 +08:00
//===----------------------------------------------------------------------===//
S'more small non-functional changes in comments and #includes. llvm-svn: 173738
2013-01-29 08:48:16 +08:00
// Attribute Construction Methods
Reimplement the parameter attributes support, phase #1. hilights: 1. There is now a "PAListPtr" class, which is a smart pointer around the underlying uniqued parameter attribute list object, and manages its refcount. It is now impossible to mess up the refcount. 2. PAListPtr is now the main interface to the underlying object, and the underlying object is now completely opaque. 3. Implementation details like SmallVector and FoldingSet are now no longer part of the interface. 4. You can create a PAListPtr with an arbitrary sequence of ParamAttrsWithIndex's, no need to make a SmallVector of a specific size (you can just use an array or scalar or vector if you wish). 5. All the client code that had to check for a null pointer before dereferencing the pointer is simplified to just access the PAListPtr directly. 6. The interfaces for adding attrs to a list and removing them is a bit simpler. Phase #2 will rename some stuff (e.g. PAListPtr) and do other less invasive changes. llvm-svn: 48289
2008-03-13 01:45:29 +08:00
//===----------------------------------------------------------------------===//
I noticed that the trampoline straightening transformation could drop attributes on varargs call arguments. Also, it could generate invalid IR if the transformed call already had the 'nest' attribute somewhere (this can never happen for code coming from llvm-gcc, but it's a theoretical possibility). Fix both problems. llvm-svn: 45973
2008-01-15 03:52:09 +08:00
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
Attribute Attribute::get(LLVMContext &Context, Attribute::AttrKind Kind,
uint64_t Val) {
Begin the transition to using the AttributesImpl object for the Attributes ivar. Start using the AttributesImpl object to hold the value of the attributes. All queries go through the interfaces now. This has one unfortunate consequence. I needed to move the AttributesImpl.h file into include/llvm. But this is only temporary! Otherwise, the changes needed to support this would be too large. llvm-svn: 165433
2012-10-09 05:47:17 +08:00
LLVMContextImpl *pImpl = Context.pImpl;
FoldingSetNodeID ID;
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
ID.AddInteger(Kind);
Revert accidentally committed r217107 "Don't treat 0 as a special value for int attributes." llvm-svn: 217110
2014-09-04 07:38:05 +08:00
if (Val) ID.AddInteger(Val);
Begin the transition to using the AttributesImpl object for the Attributes ivar. Start using the AttributesImpl object to hold the value of the attributes. All queries go through the interfaces now. This has one unfortunate consequence. I needed to move the AttributesImpl.h file into include/llvm. But this is only temporary! Otherwise, the changes needed to support this would be too large. llvm-svn: 165433
2012-10-09 05:47:17 +08:00
void *InsertPoint;
s/AttributesImpl/AttributeImpl/g This is going to apply to Attribute, not Attributes. llvm-svn: 170631
2012-12-20 09:36:59 +08:00
AttributeImpl *PA = pImpl->AttrsSet.FindNodeOrInsertPos(ID, InsertPoint);
Begin the transition to using the AttributesImpl object for the Attributes ivar. Start using the AttributesImpl object to hold the value of the attributes. All queries go through the interfaces now. This has one unfortunate consequence. I needed to move the AttributesImpl.h file into include/llvm. But this is only temporary! Otherwise, the changes needed to support this would be too large. llvm-svn: 165433
2012-10-09 05:47:17 +08:00
if (!PA) {
// If we didn't find any existing attributes of the same shape then create a
// new one and insert it.
Revert accidentally committed r217107 "Don't treat 0 as a special value for int attributes." llvm-svn: 217110
2014-09-04 07:38:05 +08:00
if (!Val)
PA = new EnumAttributeImpl(Kind);
else
PA = new IntAttributeImpl(Kind, Val);
Begin the transition to using the AttributesImpl object for the Attributes ivar. Start using the AttributesImpl object to hold the value of the attributes. All queries go through the interfaces now. This has one unfortunate consequence. I needed to move the AttributesImpl.h file into include/llvm. But this is only temporary! Otherwise, the changes needed to support this would be too large. llvm-svn: 165433
2012-10-09 05:47:17 +08:00
pImpl->AttrsSet.InsertNode(PA, InsertPoint);
}
Add target-dependent versions of addAttribute/removeAttribute to AttrBuilder. llvm-svn: 174356
2013-02-05 16:09:32 +08:00
// Return the Attribute that we found or created.
Rename the 'Attributes' class to 'Attribute'. It's going to represent a single attribute in the future. llvm-svn: 170502
2012-12-19 15:18:57 +08:00
return Attribute(PA);
Begin the transition to using the AttributesImpl object for the Attributes ivar. Start using the AttributesImpl object to hold the value of the attributes. All queries go through the interfaces now. This has one unfortunate consequence. I needed to move the AttributesImpl.h file into include/llvm. But this is only temporary! Otherwise, the changes needed to support this would be too large. llvm-svn: 165433
2012-10-09 05:47:17 +08:00
}
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
Attribute Attribute::get(LLVMContext &Context, StringRef Kind, StringRef Val) {
LLVMContextImpl *pImpl = Context.pImpl;
FoldingSetNodeID ID;
ID.AddString(Kind);
if (!Val.empty()) ID.AddString(Val);
void *InsertPoint;
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.
Reduce the number of indirections in the attributes implementation. - Coallocate entires for AttributeSetImpls and Nodes after the class itself. - Remove mutable iterators from immutable classes. - Remove unused context field from AttributeImpl. - Derive Enum/Align/String attribute implementations from AttributeImpl instead of having a whole new inheritance tree for them. - Derive AlignAttributeImpl from EnumAttributeImpl. llvm-svn: 186075
2013-07-11 20:13:16 +08:00
PA = new StringAttributeImpl(Kind, Val);
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
pImpl->AttrsSet.InsertNode(PA, InsertPoint);
}
// Return the Attribute that we found or created.
return Attribute(PA);
Remove the AttrBuilder form of the Attribute::get creators. The AttrBuilder is for building a collection of attributes. The Attribute object holds only one attribute. So it's not really useful for the Attribute object to have a creator which takes an AttrBuilder. This has two fallouts: 1. The AttrBuilder no longer holds its internal attributes in a bit-mask form. 2. The attributes are now ordered alphabetically (hence why the tests have changed). llvm-svn: 174110
2013-02-01 07:16:25 +08:00
}
Add special 'get' methods to create an Attribute with an alignment. Also do some random cleanup. No functionality change. llvm-svn: 173635
2013-01-28 06:43:04 +08:00
Attribute Attribute::getWithAlignment(LLVMContext &Context, uint64_t Align) {
Remove the AttrBuilder form of the Attribute::get creators. The AttrBuilder is for building a collection of attributes. The Attribute object holds only one attribute. So it's not really useful for the Attribute object to have a creator which takes an AttrBuilder. This has two fallouts: 1. The AttrBuilder no longer holds its internal attributes in a bit-mask form. 2. The attributes are now ordered alphabetically (hence why the tests have changed). llvm-svn: 174110
2013-02-01 07:16:25 +08:00
assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
assert(Align <= 0x40000000 && "Alignment too large.");
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
return get(Context, Alignment, Align);
Add special 'get' methods to create an Attribute with an alignment. Also do some random cleanup. No functionality change. llvm-svn: 173635
2013-01-28 06:43:04 +08:00
}
Attribute Attribute::getWithStackAlignment(LLVMContext &Context,
uint64_t Align) {
Remove the AttrBuilder form of the Attribute::get creators. The AttrBuilder is for building a collection of attributes. The Attribute object holds only one attribute. So it's not really useful for the Attribute object to have a creator which takes an AttrBuilder. This has two fallouts: 1. The AttrBuilder no longer holds its internal attributes in a bit-mask form. 2. The attributes are now ordered alphabetically (hence why the tests have changed). llvm-svn: 174110
2013-02-01 07:16:25 +08:00
assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
assert(Align <= 0x100 && "Alignment too large.");
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
return get(Context, StackAlignment, Align);
Add special 'get' methods to create an Attribute with an alignment. Also do some random cleanup. No functionality change. llvm-svn: 173635
2013-01-28 06:43:04 +08:00
}
Add a dereferenceable attribute This attribute indicates that the parameter or return pointer is dereferenceable. Practically speaking, loads from such a pointer within the associated byte range are safe to speculatively execute. Such pointer parameters are common in source languages (C++ references, for example). llvm-svn: 213385
2014-07-18 23:51:28 +08:00
Attribute Attribute::getWithDereferenceableBytes(LLVMContext &Context,
uint64_t Bytes) {
assert(Bytes && "Bytes must be non-zero.");
return get(Context, Dereferenceable, Bytes);
}
[IR] Introduce a dereferenceable_or_null(N) attribute. Summary: If a pointer is marked as dereferenceable_or_null(N), LLVM assumes it is either `null` or `dereferenceable(N)` or both. This change only introduces the attribute and adds a token test case for the `llvm-as` / `llvm-dis`. It does not hook up other parts of the optimizer to actually exploit the attribute -- those changes will come later. For pointers in address space 0, `dereferenceable(N)` is now exactly equivalent to `dereferenceable_or_null(N)` && `nonnull`. For other address spaces, `dereferenceable(N)` is potentially weaker than `dereferenceable_or_null(N)` && `nonnull` (since we could have a null `dereferenceable(N)` pointer). The motivating case for this change is Java (and other managed languages), where pointers are either `null` or dereferenceable up to some usually known-at-compile-time constant offset. Reviewers: rafael, hfinkel Reviewed By: hfinkel Subscribers: nicholas, llvm-commits Differential Revision: http://reviews.llvm.org/D8650 llvm-svn: 235132
2015-04-17 04:29:50 +08:00
Attribute Attribute::getWithDereferenceableOrNullBytes(LLVMContext &Context,
uint64_t Bytes) {
assert(Bytes && "Bytes must be non-zero.");
return get(Context, DereferenceableOrNull, Bytes);
}
S'more small non-functional changes in comments and #includes. llvm-svn: 173738
2013-01-29 08:48:16 +08:00
//===----------------------------------------------------------------------===//
// Attribute Accessor Methods
//===----------------------------------------------------------------------===//
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
bool Attribute::isEnumAttribute() const {
return pImpl && pImpl->isEnumAttribute();
Move methods out-of-line. The internal representation of the Attributes class will be opaque. All of the query methods will need to query the opaque class. Therefore, these methods need to be out-of-line. No functionality change intended. llvm-svn: 165305
2012-10-05 14:44:41 +08:00
}
Rename AlignAttribute to IntAttribute Currently the only kind of integer IR attributes that we have are alignment attributes, and so the attribute kind that takes an integer parameter is called AlignAttr, but that will change (we'll soon be adding a dereferenceable attribute that also takes an integer value). Accordingly, rename AlignAttribute to IntAttribute (class names, enums, etc.). No functionality change intended. llvm-svn: 213352
2014-07-18 14:51:55 +08:00
bool Attribute::isIntAttribute() const {
return pImpl && pImpl->isIntAttribute();
Add a couple of accessor methods to get the kind and values of an attribute. llvm-svn: 173828
2013-01-30 04:45:34 +08:00
}
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
bool Attribute::isStringAttribute() const {
return pImpl && pImpl->isStringAttribute();
}
Attribute::AttrKind Attribute::getKindAsEnum() const {
Replace the "NoFramePointerElimNonLeaf" target option with a function attribute. There's no need to specify a flag to omit frame pointer elimination on non-leaf nodes...(Honestly, I can't parse that option out.) Use the function attribute stuff instead. llvm-svn: 187093
2013-07-25 08:34:29 +08:00
if (!pImpl) return None;
Rename AlignAttribute to IntAttribute Currently the only kind of integer IR attributes that we have are alignment attributes, and so the attribute kind that takes an integer parameter is called AlignAttr, but that will change (we'll soon be adding a dereferenceable attribute that also takes an integer value). Accordingly, rename AlignAttribute to IntAttribute (class names, enums, etc.). No functionality change intended. llvm-svn: 213352
2014-07-18 14:51:55 +08:00
assert((isEnumAttribute() || isIntAttribute()) &&
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
"Invalid attribute type to get the kind as an enum!");
Minor cleanup of Attribute code. NFC. llvm-svn: 255751
2015-12-16 13:21:02 +08:00
return pImpl->getKindAsEnum();
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
}
uint64_t Attribute::getValueAsInt() const {
Replace the "NoFramePointerElimNonLeaf" target option with a function attribute. There's no need to specify a flag to omit frame pointer elimination on non-leaf nodes...(Honestly, I can't parse that option out.) Use the function attribute stuff instead. llvm-svn: 187093
2013-07-25 08:34:29 +08:00
if (!pImpl) return 0;
Rename AlignAttribute to IntAttribute Currently the only kind of integer IR attributes that we have are alignment attributes, and so the attribute kind that takes an integer parameter is called AlignAttr, but that will change (we'll soon be adding a dereferenceable attribute that also takes an integer value). Accordingly, rename AlignAttribute to IntAttribute (class names, enums, etc.). No functionality change intended. llvm-svn: 213352
2014-07-18 14:51:55 +08:00
assert(isIntAttribute() &&
"Expected the attribute to be an integer attribute!");
Minor cleanup of Attribute code. NFC. llvm-svn: 255751
2015-12-16 13:21:02 +08:00
return pImpl->getValueAsInt();
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
}
StringRef Attribute::getKindAsString() const {
Replace the "NoFramePointerElimNonLeaf" target option with a function attribute. There's no need to specify a flag to omit frame pointer elimination on non-leaf nodes...(Honestly, I can't parse that option out.) Use the function attribute stuff instead. llvm-svn: 187093
2013-07-25 08:34:29 +08:00
if (!pImpl) return StringRef();
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
assert(isStringAttribute() &&
"Invalid attribute type to get the kind as a string!");
Minor cleanup of Attribute code. NFC. llvm-svn: 255751
2015-12-16 13:21:02 +08:00
return pImpl->getKindAsString();
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
}
StringRef Attribute::getValueAsString() const {
Replace the "NoFramePointerElimNonLeaf" target option with a function attribute. There's no need to specify a flag to omit frame pointer elimination on non-leaf nodes...(Honestly, I can't parse that option out.) Use the function attribute stuff instead. llvm-svn: 187093
2013-07-25 08:34:29 +08:00
if (!pImpl) return StringRef();
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
assert(isStringAttribute() &&
"Invalid attribute type to get the value as a string!");
Minor cleanup of Attribute code. NFC. llvm-svn: 255751
2015-12-16 13:21:02 +08:00
return pImpl->getValueAsString();
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
}
Add the target-dependent (string) attributes from the AttrBuilder to the AttributeSet. llvm-svn: 174467
2013-02-06 07:48:36 +08:00
bool Attribute::hasAttribute(AttrKind Kind) const {
return (pImpl && pImpl->hasAttribute(Kind)) || (!pImpl && Kind == None);
}
bool Attribute::hasAttribute(StringRef Kind) const {
if (!isStringAttribute()) return false;
return pImpl && pImpl->hasAttribute(Kind);
Add a couple of accessor methods to get the kind and values of an attribute. llvm-svn: 173828
2013-01-30 04:45:34 +08:00
}
Rename the 'Attributes' class to 'Attribute'. It's going to represent a single attribute in the future. llvm-svn: 170502
2012-12-19 15:18:57 +08:00
unsigned Attribute::getAlignment() const {
Remove some dead code, improve some asserts, and other assorted changes. No functionality change. llvm-svn: 174132
2013-02-01 09:04:27 +08:00
assert(hasAttribute(Attribute::Alignment) &&
"Trying to get alignment from non-alignment attribute!");
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
return pImpl->getValueAsInt();
Move methods out-of-line. The internal representation of the Attributes class will be opaque. All of the query methods will need to query the opaque class. Therefore, these methods need to be out-of-line. No functionality change intended. llvm-svn: 165305
2012-10-05 14:44:41 +08:00
}
Rename the 'Attributes' class to 'Attribute'. It's going to represent a single attribute in the future. llvm-svn: 170502
2012-12-19 15:18:57 +08:00
unsigned Attribute::getStackAlignment() const {
Remove some dead code, improve some asserts, and other assorted changes. No functionality change. llvm-svn: 174132
2013-02-01 09:04:27 +08:00
assert(hasAttribute(Attribute::StackAlignment) &&
"Trying to get alignment from non-alignment attribute!");
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
return pImpl->getValueAsInt();
Move methods out-of-line. The internal representation of the Attributes class will be opaque. All of the query methods will need to query the opaque class. Therefore, these methods need to be out-of-line. No functionality change intended. llvm-svn: 165305
2012-10-05 14:44:41 +08:00
}
Add a dereferenceable attribute This attribute indicates that the parameter or return pointer is dereferenceable. Practically speaking, loads from such a pointer within the associated byte range are safe to speculatively execute. Such pointer parameters are common in source languages (C++ references, for example). llvm-svn: 213385
2014-07-18 23:51:28 +08:00
uint64_t Attribute::getDereferenceableBytes() const {
assert(hasAttribute(Attribute::Dereferenceable) &&
"Trying to get dereferenceable bytes from "
"non-dereferenceable attribute!");
return pImpl->getValueAsInt();
}
[IR] Introduce a dereferenceable_or_null(N) attribute. Summary: If a pointer is marked as dereferenceable_or_null(N), LLVM assumes it is either `null` or `dereferenceable(N)` or both. This change only introduces the attribute and adds a token test case for the `llvm-as` / `llvm-dis`. It does not hook up other parts of the optimizer to actually exploit the attribute -- those changes will come later. For pointers in address space 0, `dereferenceable(N)` is now exactly equivalent to `dereferenceable_or_null(N)` && `nonnull`. For other address spaces, `dereferenceable(N)` is potentially weaker than `dereferenceable_or_null(N)` && `nonnull` (since we could have a null `dereferenceable(N)` pointer). The motivating case for this change is Java (and other managed languages), where pointers are either `null` or dereferenceable up to some usually known-at-compile-time constant offset. Reviewers: rafael, hfinkel Reviewed By: hfinkel Subscribers: nicholas, llvm-commits Differential Revision: http://reviews.llvm.org/D8650 llvm-svn: 235132
2015-04-17 04:29:50 +08:00
uint64_t Attribute::getDereferenceableOrNullBytes() const {
assert(hasAttribute(Attribute::DereferenceableOrNull) &&
"Trying to get dereferenceable bytes from "
"non-dereferenceable attribute!");
return pImpl->getValueAsInt();
}
Add support for printing out the attribute groups. This emits the attribute groups that are used by the functions. (It currently doesn't print out return type or parameter attributes within attribute groups.) Note: The functions still retrieve their attributes from the "old" bitcode format (using the deprecated 'Raw()' method). This means that string attributes within an attribute group will not show up during a disassembly. This will be addressed in a future commit. llvm-svn: 174867
2013-02-11 16:43:33 +08:00
std::string Attribute::getAsString(bool InAttrGrp) const {
Add support for emitting a string attribute. Attributes that are strings are typically target-dependent attributes. They are of this form in the IR: "attr" "attr" = "val" llvm-svn: 174090
2013-02-01 04:59:05 +08:00
if (!pImpl) return "";
Unify clang/llvm attributes for asan/tsan/msan (LLVM part) These are two related changes (one in llvm, one in clang). LLVM: - rename address_safety => sanitize_address (the enum value is the same, so we preserve binary compatibility with old bitcode) - rename thread_safety => sanitize_thread - rename no_uninitialized_checks -> sanitize_memory CLANG: - add __attribute__((no_sanitize_address)) as a synonym for __attribute__((no_address_safety_analysis)) - add __attribute__((no_sanitize_thread)) - add __attribute__((no_sanitize_memory)) for S in address thread memory If -fsanitize=S is present and __attribute__((no_sanitize_S)) is not set llvm attribute sanitize_S llvm-svn: 176075
2013-02-26 14:58:09 +08:00
if (hasAttribute(Attribute::SanitizeAddress))
return "sanitize_address";
Add support for emitting a string attribute. Attributes that are strings are typically target-dependent attributes. They are of this form in the IR: "attr" "attr" = "val" llvm-svn: 174090
2013-02-01 04:59:05 +08:00
if (hasAttribute(Attribute::AlwaysInline))
return "alwaysinline";
Add argmemonly attribute. This change adds new attribute called "argmemonly". Function marked with this attribute can only access memory through it's argument pointers. This attribute directly corresponds to the "OnlyAccessesArgumentPointees" ModRef behaviour in alias analysis. Differential Revision: http://reviews.llvm.org/D10398 llvm-svn: 241979
2015-07-11 18:30:36 +08:00
if (hasAttribute(Attribute::ArgMemOnly))
return "argmemonly";
Added support for the Builtin attribute. The Builtin attribute is an attribute that can be placed on function call site that signal that even though a function is declared as being a builtin, rdar://problem/13727199 llvm-svn: 185049
2013-06-27 08:25:01 +08:00
if (hasAttribute(Attribute::Builtin))
return "builtin";
Add support for emitting a string attribute. Attributes that are strings are typically target-dependent attributes. They are of this form in the IR: "attr" "attr" = "val" llvm-svn: 174090
2013-02-01 04:59:05 +08:00
if (hasAttribute(Attribute::ByVal))
return "byval";
Add initial support for the convergent attribute. llvm-svn: 238264
2015-05-27 07:48:40 +08:00
if (hasAttribute(Attribute::Convergent))
return "convergent";
Swift Calling Convention: add swifterror attribute. A ``swifterror`` attribute can be applied to a function parameter or an AllocaInst. This commit does not include any target-specific change. The target-specific optimization will come as a follow-up patch. Differential Revision: http://reviews.llvm.org/D18092 llvm-svn: 265189
2016-04-02 05:41:15 +08:00
if (hasAttribute(Attribute::SwiftError))
return "swifterror";
Swift Calling Convention: add swiftself attribute. Differential Revision: http://reviews.llvm.org/D17866 llvm-svn: 264754
2016-03-30 01:37:21 +08:00
if (hasAttribute(Attribute::SwiftSelf))
return "swiftself";
Add InaccessibleMemOnly and inaccessibleMemOrArgMemOnly attributes Summary: This patch introduces two new function attributes InaccessibleMemOnly: This attribute indicates that the function may only access memory that is not accessible by the program/IR being compiled. This is a weaker form of ReadNone. inaccessibleMemOrArgMemOnly: This attribute indicates that the function may only access memory that is either not accessible by the program/IR being compiled, or is pointed to by its pointer arguments. This is a weaker form of ArgMemOnly Test cases have been updated. This revision uses this (https://github.com/llvm-mirror/llvm/commit/d001932f3a8aa1ebd1555162fdce365f011bc292) as reference. Reviewers: jmolloy, hfinkel Subscribers: reames, joker.eph, llvm-commits Differential Revision: http://reviews.llvm.org/D15499 llvm-svn: 255778
2015-12-17 00:16:19 +08:00
if (hasAttribute(Attribute::InaccessibleMemOnly))
return "inaccessiblememonly";
if (hasAttribute(Attribute::InaccessibleMemOrArgMemOnly))
return "inaccessiblemem_or_argmemonly";
Begin adding docs and IR-level support for the inalloca attribute The inalloca attribute is designed to support passing C++ objects by value in the Microsoft C++ ABI. It behaves the same as byval, except that it always implies that the argument is in memory and that the bytes are never copied. This attribute allows the caller to take the address of an outgoing argument's memory and execute arbitrary code to store into it. This patch adds basic IR support, docs, and verification. It does not attempt to implement any lowering or fix any possibly broken transforms. When this patch lands, a complete description of this feature should appear at http://llvm.org/docs/InAlloca.html . Differential Revision: http://llvm-reviews.chandlerc.com/D2173 llvm-svn: 197645
2013-12-19 10:14:12 +08:00
if (hasAttribute(Attribute::InAlloca))
return "inalloca";
Add support for emitting a string attribute. Attributes that are strings are typically target-dependent attributes. They are of this form in the IR: "attr" "attr" = "val" llvm-svn: 174090
2013-02-01 04:59:05 +08:00
if (hasAttribute(Attribute::InlineHint))
return "inlinehint";
Rename the 'Attributes' class to 'Attribute'. It's going to represent a single attribute in the future. llvm-svn: 170502
2012-12-19 15:18:57 +08:00
if (hasAttribute(Attribute::InReg))
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
return "inreg";
Add a new attribute called 'jumptable' that creates jump-instruction tables for functions marked with this attribute. It includes a pass that rewrites all indirect calls to jumptable functions to pass through these tables. This also adds backend support for generating the jump-instruction tables on ARM and X86. Note that since the jumptable attribute creates a second function pointer for a function, any function marked with jumptable must also be marked with unnamed_addr. llvm-svn: 210280
2014-06-06 03:29:43 +08:00
if (hasAttribute(Attribute::JumpTable))
return "jumptable";
Add support for emitting a string attribute. Attributes that are strings are typically target-dependent attributes. They are of this form in the IR: "attr" "attr" = "val" llvm-svn: 174090
2013-02-01 04:59:05 +08:00
if (hasAttribute(Attribute::MinSize))
return "minsize";
if (hasAttribute(Attribute::Naked))
return "naked";
if (hasAttribute(Attribute::Nest))
return "nest";
Rename the 'Attributes' class to 'Attribute'. It's going to represent a single attribute in the future. llvm-svn: 170502
2012-12-19 15:18:57 +08:00
if (hasAttribute(Attribute::NoAlias))
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
return "noalias";
Implement the NoBuiltin attribute. The 'nobuiltin' attribute is applied to call sites to indicate that LLVM should not treat the callee function as a built-in function. I.e., it shouldn't try to replace that function with different code. llvm-svn: 175835
2013-02-22 08:12:35 +08:00
if (hasAttribute(Attribute::NoBuiltin))
return "nobuiltin";
Rename the 'Attributes' class to 'Attribute'. It's going to represent a single attribute in the future. llvm-svn: 170502
2012-12-19 15:18:57 +08:00
if (hasAttribute(Attribute::NoCapture))
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
return "nocapture";
Add support for emitting a string attribute. Attributes that are strings are typically target-dependent attributes. They are of this form in the IR: "attr" "attr" = "val" llvm-svn: 174090
2013-02-01 04:59:05 +08:00
if (hasAttribute(Attribute::NoDuplicate))
return "noduplicate";
if (hasAttribute(Attribute::NoImplicitFloat))
return "noimplicitfloat";
if (hasAttribute(Attribute::NoInline))
return "noinline";
if (hasAttribute(Attribute::NonLazyBind))
return "nonlazybind";
Add 'nonnull', a new parameter and return attribute which indicates that the pointer is not null. Instcombine will elide comparisons between these and null. Patch by Luqman Aden! llvm-svn: 209185
2014-05-20 09:23:40 +08:00
if (hasAttribute(Attribute::NonNull))
return "nonnull";
Add support for emitting a string attribute. Attributes that are strings are typically target-dependent attributes. They are of this form in the IR: "attr" "attr" = "val" llvm-svn: 174090
2013-02-01 04:59:05 +08:00
if (hasAttribute(Attribute::NoRedZone))
return "noredzone";
if (hasAttribute(Attribute::NoReturn))
return "noreturn";
Add a new attribute: norecurse This attribute allows the compiler to assume that the function never recurses into itself, either directly or indirectly (transitively). This can be used among other things to demote global variables to locals. llvm-svn: 252282
2015-11-06 18:32:53 +08:00
if (hasAttribute(Attribute::NoRecurse))
return "norecurse";
Add support for emitting a string attribute. Attributes that are strings are typically target-dependent attributes. They are of this form in the IR: "attr" "attr" = "val" llvm-svn: 174090
2013-02-01 04:59:05 +08:00
if (hasAttribute(Attribute::NoUnwind))
return "nounwind";
Add function attribute 'optnone'. This function attribute indicates that the function is not optimized by any optimization or code generator passes with the exception of interprocedural optimization passes. llvm-svn: 189101
2013-08-23 19:53:55 +08:00
if (hasAttribute(Attribute::OptimizeNone))
return "optnone";
Add support for emitting a string attribute. Attributes that are strings are typically target-dependent attributes. They are of this form in the IR: "attr" "attr" = "val" llvm-svn: 174090
2013-02-01 04:59:05 +08:00
if (hasAttribute(Attribute::OptimizeForSize))
return "optsize";
Rename the 'Attributes' class to 'Attribute'. It's going to represent a single attribute in the future. llvm-svn: 170502
2012-12-19 15:18:57 +08:00
if (hasAttribute(Attribute::ReadNone))
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
return "readnone";
Rename the 'Attributes' class to 'Attribute'. It's going to represent a single attribute in the future. llvm-svn: 170502
2012-12-19 15:18:57 +08:00
if (hasAttribute(Attribute::ReadOnly))
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
return "readonly";
Add CodeGen support for functions that always return arguments via a new parameter attribute 'returned', which is taken advantage of in target-independent tail call opportunity detection and in ARM call lowering (when placed on an integral first parameter). llvm-svn: 179925
2013-04-20 13:14:40 +08:00
if (hasAttribute(Attribute::Returned))
return "returned";
Add support for emitting a string attribute. Attributes that are strings are typically target-dependent attributes. They are of this form in the IR: "attr" "attr" = "val" llvm-svn: 174090
2013-02-01 04:59:05 +08:00
if (hasAttribute(Attribute::ReturnsTwice))
return "returns_twice";
if (hasAttribute(Attribute::SExt))
return "signext";
Rename the 'Attributes' class to 'Attribute'. It's going to represent a single attribute in the future. llvm-svn: 170502
2012-12-19 15:18:57 +08:00
if (hasAttribute(Attribute::StackProtect))
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
return "ssp";
Rename the 'Attributes' class to 'Attribute'. It's going to represent a single attribute in the future. llvm-svn: 170502
2012-12-19 15:18:57 +08:00
if (hasAttribute(Attribute::StackProtectReq))
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
return "sspreq";
Add the IR attribute 'sspstrong'. SSPStrong applies a heuristic to insert stack protectors in these situations: * A Protector is required for functions which contain an array, regardless of type or length. * A Protector is required for functions which contain a structure/union which contains an array, regardless of type or length. Note, there is no limit to the depth of nesting. * A protector is required when the address of a local variable (i.e., stack based variable) is exposed. (E.g., such as through a local whose address is taken as part of the RHS of an assignment or a local whose address is taken as part of a function argument.) This patch implements the SSPString attribute to be equivalent to SSPRequired. This will change in a subsequent patch. llvm-svn: 173230
2013-01-23 14:41:41 +08:00
if (hasAttribute(Attribute::StackProtectStrong))
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
return "sspstrong";
Protection against stack-based memory corruption errors using SafeStack This patch adds the safe stack instrumentation pass to LLVM, which separates the program stack into a safe stack, which stores return addresses, register spills, and local variables that are statically verified to be accessed in a safe way, and the unsafe stack, which stores everything else. Such separation makes it much harder for an attacker to corrupt objects on the safe stack, including function pointers stored in spilled registers and return addresses. You can find more information about the safe stack, as well as other parts of or control-flow hijack protection technique in our OSDI paper on code-pointer integrity (http://dslab.epfl.ch/pubs/cpi.pdf) and our project website (http://levee.epfl.ch). The overhead of our implementation of the safe stack is very close to zero (0.01% on the Phoronix benchmarks). This is lower than the overhead of stack cookies, which are supported by LLVM and are commonly used today, yet the security guarantees of the safe stack are strictly stronger than stack cookies. In some cases, the safe stack improves performance due to better cache locality. Our current implementation of the safe stack is stable and robust, we used it to recompile multiple projects on Linux including Chromium, and we also recompiled the entire FreeBSD user-space system and more than 100 packages. We ran unit tests on the FreeBSD system and many of the packages and observed no errors caused by the safe stack. The safe stack is also fully binary compatible with non-instrumented code and can be applied to parts of a program selectively. This patch is our implementation of the safe stack on top of LLVM. The patches make the following changes: - Add the safestack function attribute, similar to the ssp, sspstrong and sspreq attributes. - Add the SafeStack instrumentation pass that applies the safe stack to all functions that have the safestack attribute. This pass moves all unsafe local variables to the unsafe stack with a separate stack pointer, whereas all safe variables remain on the regular stack that is managed by LLVM as usual. - Invoke the pass as the last stage before code generation (at the same time the existing cookie-based stack protector pass is invoked). - Add unit tests for the safe stack. Original patch by Volodymyr Kuznetsov and others at the Dependable Systems Lab at EPFL; updates and upstreaming by myself. Differential Revision: http://reviews.llvm.org/D6094 llvm-svn: 239761
2015-06-16 05:07:11 +08:00
if (hasAttribute(Attribute::SafeStack))
return "safestack";
Add support for emitting a string attribute. Attributes that are strings are typically target-dependent attributes. They are of this form in the IR: "attr" "attr" = "val" llvm-svn: 174090
2013-02-01 04:59:05 +08:00
if (hasAttribute(Attribute::StructRet))
return "sret";
Unify clang/llvm attributes for asan/tsan/msan (LLVM part) These are two related changes (one in llvm, one in clang). LLVM: - rename address_safety => sanitize_address (the enum value is the same, so we preserve binary compatibility with old bitcode) - rename thread_safety => sanitize_thread - rename no_uninitialized_checks -> sanitize_memory CLANG: - add __attribute__((no_sanitize_address)) as a synonym for __attribute__((no_address_safety_analysis)) - add __attribute__((no_sanitize_thread)) - add __attribute__((no_sanitize_memory)) for S in address thread memory If -fsanitize=S is present and __attribute__((no_sanitize_S)) is not set llvm attribute sanitize_S llvm-svn: 176075
2013-02-26 14:58:09 +08:00
if (hasAttribute(Attribute::SanitizeThread))
return "sanitize_thread";
if (hasAttribute(Attribute::SanitizeMemory))
return "sanitize_memory";
Add support for emitting a string attribute. Attributes that are strings are typically target-dependent attributes. They are of this form in the IR: "attr" "attr" = "val" llvm-svn: 174090
2013-02-01 04:59:05 +08:00
if (hasAttribute(Attribute::UWTable))
return "uwtable";
if (hasAttribute(Attribute::ZExt))
return "zeroext";
Add a new function attribute 'cold' to functions. Other than recognizing the attribute, the patch does little else. It changes the branch probability analyzer so that edges into blocks postdominated by a cold function are given low weight. Added analysis and code generation tests. Added documentation for the new attribute. llvm-svn: 182638
2013-05-24 20:26:52 +08:00
if (hasAttribute(Attribute::Cold))
return "cold";
Add support for emitting a string attribute. Attributes that are strings are typically target-dependent attributes. They are of this form in the IR: "attr" "attr" = "val" llvm-svn: 174090
2013-02-01 04:59:05 +08:00
// FIXME: These should be output like this:
//
// align=4
// alignstack=8
//
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
if (hasAttribute(Attribute::Alignment)) {
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
std::string Result;
Add support for printing out the attribute groups. This emits the attribute groups that are used by the functions. (It currently doesn't print out return type or parameter attributes within attribute groups.) Note: The functions still retrieve their attributes from the "old" bitcode format (using the deprecated 'Raw()' method). This means that string attributes within an attribute group will not show up during a disassembly. This will be addressed in a future commit. llvm-svn: 174867
2013-02-11 16:43:33 +08:00
Result += "align";
Result += (InAttrGrp) ? "=" : " ";
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
Result += utostr(getValueAsInt());
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
return Result;
Add a new function attribute, 'alignstack'. It will indicate (when the backends implement support for it) that the stack should be forcibly realigned in the prologue (and the process reversed in the epilogue). llvm-svn: 95945
2010-02-12 08:31:15 +08:00
}
Add support for printing out the attribute groups. This emits the attribute groups that are used by the functions. (It currently doesn't print out return type or parameter attributes within attribute groups.) Note: The functions still retrieve their attributes from the "old" bitcode format (using the deprecated 'Raw()' method). This means that string attributes within an attribute group will not show up during a disassembly. This will be addressed in a future commit. llvm-svn: 174867
2013-02-11 16:43:33 +08:00
[IR] Introduce a dereferenceable_or_null(N) attribute. Summary: If a pointer is marked as dereferenceable_or_null(N), LLVM assumes it is either `null` or `dereferenceable(N)` or both. This change only introduces the attribute and adds a token test case for the `llvm-as` / `llvm-dis`. It does not hook up other parts of the optimizer to actually exploit the attribute -- those changes will come later. For pointers in address space 0, `dereferenceable(N)` is now exactly equivalent to `dereferenceable_or_null(N)` && `nonnull`. For other address spaces, `dereferenceable(N)` is potentially weaker than `dereferenceable_or_null(N)` && `nonnull` (since we could have a null `dereferenceable(N)` pointer). The motivating case for this change is Java (and other managed languages), where pointers are either `null` or dereferenceable up to some usually known-at-compile-time constant offset. Reviewers: rafael, hfinkel Reviewed By: hfinkel Subscribers: nicholas, llvm-commits Differential Revision: http://reviews.llvm.org/D8650 llvm-svn: 235132
2015-04-17 04:29:50 +08:00
auto AttrWithBytesToString = [&](const char *Name) {
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
std::string Result;
[IR] Introduce a dereferenceable_or_null(N) attribute. Summary: If a pointer is marked as dereferenceable_or_null(N), LLVM assumes it is either `null` or `dereferenceable(N)` or both. This change only introduces the attribute and adds a token test case for the `llvm-as` / `llvm-dis`. It does not hook up other parts of the optimizer to actually exploit the attribute -- those changes will come later. For pointers in address space 0, `dereferenceable(N)` is now exactly equivalent to `dereferenceable_or_null(N)` && `nonnull`. For other address spaces, `dereferenceable(N)` is potentially weaker than `dereferenceable_or_null(N)` && `nonnull` (since we could have a null `dereferenceable(N)` pointer). The motivating case for this change is Java (and other managed languages), where pointers are either `null` or dereferenceable up to some usually known-at-compile-time constant offset. Reviewers: rafael, hfinkel Reviewed By: hfinkel Subscribers: nicholas, llvm-commits Differential Revision: http://reviews.llvm.org/D8650 llvm-svn: 235132
2015-04-17 04:29:50 +08:00
Result += Name;
Add support for printing out the attribute groups. This emits the attribute groups that are used by the functions. (It currently doesn't print out return type or parameter attributes within attribute groups.) Note: The functions still retrieve their attributes from the "old" bitcode format (using the deprecated 'Raw()' method). This means that string attributes within an attribute group will not show up during a disassembly. This will be addressed in a future commit. llvm-svn: 174867
2013-02-11 16:43:33 +08:00
if (InAttrGrp) {
Result += "=";
Result += utostr(getValueAsInt());
} else {
Result += "(";
Result += utostr(getValueAsInt());
Result += ")";
}
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
return Result;
[IR] Introduce a dereferenceable_or_null(N) attribute. Summary: If a pointer is marked as dereferenceable_or_null(N), LLVM assumes it is either `null` or `dereferenceable(N)` or both. This change only introduces the attribute and adds a token test case for the `llvm-as` / `llvm-dis`. It does not hook up other parts of the optimizer to actually exploit the attribute -- those changes will come later. For pointers in address space 0, `dereferenceable(N)` is now exactly equivalent to `dereferenceable_or_null(N)` && `nonnull`. For other address spaces, `dereferenceable(N)` is potentially weaker than `dereferenceable_or_null(N)` && `nonnull` (since we could have a null `dereferenceable(N)` pointer). The motivating case for this change is Java (and other managed languages), where pointers are either `null` or dereferenceable up to some usually known-at-compile-time constant offset. Reviewers: rafael, hfinkel Reviewed By: hfinkel Subscribers: nicholas, llvm-commits Differential Revision: http://reviews.llvm.org/D8650 llvm-svn: 235132
2015-04-17 04:29:50 +08:00
};
Add support for emitting a string attribute. Attributes that are strings are typically target-dependent attributes. They are of this form in the IR: "attr" "attr" = "val" llvm-svn: 174090
2013-02-01 04:59:05 +08:00
[IR] Introduce a dereferenceable_or_null(N) attribute. Summary: If a pointer is marked as dereferenceable_or_null(N), LLVM assumes it is either `null` or `dereferenceable(N)` or both. This change only introduces the attribute and adds a token test case for the `llvm-as` / `llvm-dis`. It does not hook up other parts of the optimizer to actually exploit the attribute -- those changes will come later. For pointers in address space 0, `dereferenceable(N)` is now exactly equivalent to `dereferenceable_or_null(N)` && `nonnull`. For other address spaces, `dereferenceable(N)` is potentially weaker than `dereferenceable_or_null(N)` && `nonnull` (since we could have a null `dereferenceable(N)` pointer). The motivating case for this change is Java (and other managed languages), where pointers are either `null` or dereferenceable up to some usually known-at-compile-time constant offset. Reviewers: rafael, hfinkel Reviewed By: hfinkel Subscribers: nicholas, llvm-commits Differential Revision: http://reviews.llvm.org/D8650 llvm-svn: 235132
2015-04-17 04:29:50 +08:00
if (hasAttribute(Attribute::StackAlignment))
return AttrWithBytesToString("alignstack");
if (hasAttribute(Attribute::Dereferenceable))
return AttrWithBytesToString("dereferenceable");
if (hasAttribute(Attribute::DereferenceableOrNull))
return AttrWithBytesToString("dereferenceable_or_null");
Add a dereferenceable attribute This attribute indicates that the parameter or return pointer is dereferenceable. Practically speaking, loads from such a pointer within the associated byte range are safe to speculatively execute. Such pointer parameters are common in source languages (C++ references, for example). llvm-svn: 213385
2014-07-18 23:51:28 +08:00
Add support for emitting a string attribute. Attributes that are strings are typically target-dependent attributes. They are of this form in the IR: "attr" "attr" = "val" llvm-svn: 174090
2013-02-01 04:59:05 +08:00
// Convert target-dependent attributes to strings of the form:
//
// "kind"
// "kind" = "value"
//
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
if (isStringAttribute()) {
Add support for emitting a string attribute. Attributes that are strings are typically target-dependent attributes. They are of this form in the IR: "attr" "attr" = "val" llvm-svn: 174090
2013-02-01 04:59:05 +08:00
std::string Result;
Remove more superfluous .str() and replace std::string concatenation with Twine. Following r233392, http://llvm.org/viewvc/llvm-project?rev=233392&view=rev. llvm-svn: 233555
2015-03-30 23:42:36 +08:00
Result += (Twine('"') + getKindAsString() + Twine('"')).str();
Add support for emitting a string attribute. Attributes that are strings are typically target-dependent attributes. They are of this form in the IR: "attr" "attr" = "val" llvm-svn: 174090
2013-02-01 04:59:05 +08:00
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
StringRef Val = pImpl->getValueAsString();
if (Val.empty()) return Result;
Change the AttributeImpl to hold a single Constant* for the values. This Constant could be an aggregate to represent multiple values. llvm-svn: 174228
2013-02-02 06:32:30 +08:00
Remove more superfluous .str() and replace std::string concatenation with Twine. Following r233392, http://llvm.org/viewvc/llvm-project?rev=233392&view=rev. llvm-svn: 233555
2015-03-30 23:42:36 +08:00
Result += ("=\"" + Val + Twine('"')).str();
Remove some dead code, improve some asserts, and other assorted changes. No functionality change. llvm-svn: 174132
2013-02-01 09:04:27 +08:00
return Result;
Add support for emitting a string attribute. Attributes that are strings are typically target-dependent attributes. They are of this form in the IR: "attr" "attr" = "val" llvm-svn: 174090
2013-02-01 04:59:05 +08:00
}
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
llvm_unreachable("Unknown attribute");
Split param attr implementation out from Function.cpp into its own file. Don't #include ParameterAttributes.h into any major public header files: just move methods out of line as appropriate. llvm-svn: 45517
2008-01-03 07:42:30 +08:00
}
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
bool Attribute::operator<(Attribute A) const {
if (!pImpl && !A.pImpl) return false;
if (!pImpl) return true;
if (!A.pImpl) return false;
return *pImpl < *A.pImpl;
Use the Attributes::Builder to build the attributes in the parser. llvm-svn: 165458
2012-10-09 07:27:46 +08:00
}
Initial commit for the AttributesImpl class. This opaque class will contain all of the attributes. All attribute queries will go through this object. This object will also be uniqued in the LLVMContext. Currently not used, so no implementation change. llvm-svn: 164722
2012-09-27 05:07:29 +08:00
//===----------------------------------------------------------------------===//
// AttributeImpl Definition
//===----------------------------------------------------------------------===//
Fix typos. llvm-svn: 212228
2014-07-03 06:05:40 +08:00
// Pin the vtables to this file.
Revert r194865 and r194874. This change is incorrect. If you delete virtual destructor of both a base class and a subclass, then the following code: Base *foo = new Child(); delete foo; will not cause the destructor for members of Child class. As a result, I observe plently of memory leaks. Notable examples I investigated are: ObjectBuffer and ObjectBufferStream, AttributeImpl and StringSAttributeImpl. llvm-svn: 194997
2013-11-18 17:31:53 +08:00
AttributeImpl::~AttributeImpl() {}
[weak vtables] Remove a bunch of weak vtables This patch removes most of the trivial cases of weak vtables by pinning them to a single object file. The memory leaks in this version have been fixed. Thanks Alexey for pointing them out. Differential Revision: http://llvm-reviews.chandlerc.com/D2068 Reviewed by Andy llvm-svn: 195064
2013-11-19 08:57:56 +08:00
void EnumAttributeImpl::anchor() {}
Rename AlignAttribute to IntAttribute Currently the only kind of integer IR attributes that we have are alignment attributes, and so the attribute kind that takes an integer parameter is called AlignAttr, but that will change (we'll soon be adding a dereferenceable attribute that also takes an integer value). Accordingly, rename AlignAttribute to IntAttribute (class names, enums, etc.). No functionality change intended. llvm-svn: 213352
2014-07-18 14:51:55 +08:00
void IntAttributeImpl::anchor() {}
[weak vtables] Remove a bunch of weak vtables This patch removes most of the trivial cases of weak vtables by pinning them to a single object file. The memory leaks in this version have been fixed. Thanks Alexey for pointing them out. Differential Revision: http://llvm-reviews.chandlerc.com/D2068 Reviewed by Andy llvm-svn: 195064
2013-11-19 08:57:56 +08:00
void StringAttributeImpl::anchor() {}
Revert r194865 and r194874. This change is incorrect. If you delete virtual destructor of both a base class and a subclass, then the following code: Base *foo = new Child(); delete foo; will not cause the destructor for members of Child class. As a result, I observe plently of memory leaks. Notable examples I investigated are: ObjectBuffer and ObjectBufferStream, AttributeImpl and StringSAttributeImpl. llvm-svn: 194997
2013-11-18 17:31:53 +08:00
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
bool AttributeImpl::hasAttribute(Attribute::AttrKind A) const {
if (isStringAttribute()) return false;
return getKindAsEnum() == A;
Add a few (as yet unused) query methods to determine if the attribute that's stored here is of a certain kind. This is in preparation for when an Attribute object represents a single attribute, instead of a bitmask of attributes. llvm-svn: 171247
2012-12-30 09:38:39 +08:00
}
Create a new class: AttributeSetNode. This is a helper class for the AttributeSetImpl class. It holds a set of attributes that apply to a single element: function, return type, or parameter. These are uniqued. llvm-svn: 173310
2013-01-24 08:06:56 +08:00
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
bool AttributeImpl::hasAttribute(StringRef Kind) const {
if (!isStringAttribute()) return false;
return getKindAsString() == Kind;
General cleanups. * Remove dead methods. * Use the 'operator==' method instead of 'contains', which isn't needed. * Fix some comments. No functionality change. llvm-svn: 171523
2013-01-05 04:54:35 +08:00
}
Add a few (as yet unused) query methods to determine if the attribute that's stored here is of a certain kind. This is in preparation for when an Attribute object represents a single attribute, instead of a bitmask of attributes. llvm-svn: 171247
2012-12-30 09:38:39 +08:00
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
Attribute::AttrKind AttributeImpl::getKindAsEnum() const {
Rename AlignAttribute to IntAttribute Currently the only kind of integer IR attributes that we have are alignment attributes, and so the attribute kind that takes an integer parameter is called AlignAttr, but that will change (we'll soon be adding a dereferenceable attribute that also takes an integer value). Accordingly, rename AlignAttribute to IntAttribute (class names, enums, etc.). No functionality change intended. llvm-svn: 213352
2014-07-18 14:51:55 +08:00
assert(isEnumAttribute() || isIntAttribute());
Reduce the number of indirections in the attributes implementation. - Coallocate entires for AttributeSetImpls and Nodes after the class itself. - Remove mutable iterators from immutable classes. - Remove unused context field from AttributeImpl. - Derive Enum/Align/String attribute implementations from AttributeImpl instead of having a whole new inheritance tree for them. - Derive AlignAttributeImpl from EnumAttributeImpl. llvm-svn: 186075
2013-07-11 20:13:16 +08:00
return static_cast<const EnumAttributeImpl *>(this)->getEnumKind();
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
}
Remove some dead code, improve some asserts, and other assorted changes. No functionality change. llvm-svn: 174132
2013-02-01 09:04:27 +08:00
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
uint64_t AttributeImpl::getValueAsInt() const {
Rename AlignAttribute to IntAttribute Currently the only kind of integer IR attributes that we have are alignment attributes, and so the attribute kind that takes an integer parameter is called AlignAttr, but that will change (we'll soon be adding a dereferenceable attribute that also takes an integer value). Accordingly, rename AlignAttribute to IntAttribute (class names, enums, etc.). No functionality change intended. llvm-svn: 213352
2014-07-18 14:51:55 +08:00
assert(isIntAttribute());
return static_cast<const IntAttributeImpl *>(this)->getValue();
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
}
Create a new class: AttributeSetNode. This is a helper class for the AttributeSetImpl class. It holds a set of attributes that apply to a single element: function, return type, or parameter. These are uniqued. llvm-svn: 173310
2013-01-24 08:06:56 +08:00
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
StringRef AttributeImpl::getKindAsString() const {
Reduce the number of indirections in the attributes implementation. - Coallocate entires for AttributeSetImpls and Nodes after the class itself. - Remove mutable iterators from immutable classes. - Remove unused context field from AttributeImpl. - Derive Enum/Align/String attribute implementations from AttributeImpl instead of having a whole new inheritance tree for them. - Derive AlignAttributeImpl from EnumAttributeImpl. llvm-svn: 186075
2013-07-11 20:13:16 +08:00
assert(isStringAttribute());
return static_cast<const StringAttributeImpl *>(this)->getStringKind();
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
}
Create a new class: AttributeSetNode. This is a helper class for the AttributeSetImpl class. It holds a set of attributes that apply to a single element: function, return type, or parameter. These are uniqued. llvm-svn: 173310
2013-01-24 08:06:56 +08:00
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
StringRef AttributeImpl::getValueAsString() const {
Reduce the number of indirections in the attributes implementation. - Coallocate entires for AttributeSetImpls and Nodes after the class itself. - Remove mutable iterators from immutable classes. - Remove unused context field from AttributeImpl. - Derive Enum/Align/String attribute implementations from AttributeImpl instead of having a whole new inheritance tree for them. - Derive AlignAttributeImpl from EnumAttributeImpl. llvm-svn: 186075
2013-07-11 20:13:16 +08:00
assert(isStringAttribute());
return static_cast<const StringAttributeImpl *>(this)->getStringValue();
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
}
Create a new class: AttributeSetNode. This is a helper class for the AttributeSetImpl class. It holds a set of attributes that apply to a single element: function, return type, or parameter. These are uniqued. llvm-svn: 173310
2013-01-24 08:06:56 +08:00
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
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.
Simplify the 'operator<' for the attribute object. llvm-svn: 175252
2013-02-15 13:25:26 +08:00
if (isEnumAttribute()) {
if (AI.isEnumAttribute()) return getKindAsEnum() < AI.getKindAsEnum();
Rename AlignAttribute to IntAttribute Currently the only kind of integer IR attributes that we have are alignment attributes, and so the attribute kind that takes an integer parameter is called AlignAttr, but that will change (we'll soon be adding a dereferenceable attribute that also takes an integer value). Accordingly, rename AlignAttribute to IntAttribute (class names, enums, etc.). No functionality change intended. llvm-svn: 213352
2014-07-18 14:51:55 +08:00
if (AI.isIntAttribute()) return true;
Simplify the 'operator<' for the attribute object. llvm-svn: 175252
2013-02-15 13:25:26 +08:00
if (AI.isStringAttribute()) return true;
Revert "Simplify the attributes '<' comparison function." This reverts commit 82c101153fe7b35bce48781fab038e1b8f31a7bd. llvm-svn: 175250
2013-02-15 12:15:55 +08:00
}
Rename AlignAttribute to IntAttribute Currently the only kind of integer IR attributes that we have are alignment attributes, and so the attribute kind that takes an integer parameter is called AlignAttr, but that will change (we'll soon be adding a dereferenceable attribute that also takes an integer value). Accordingly, rename AlignAttribute to IntAttribute (class names, enums, etc.). No functionality change intended. llvm-svn: 213352
2014-07-18 14:51:55 +08:00
if (isIntAttribute()) {
Simplify the 'operator<' for the attribute object. llvm-svn: 175252
2013-02-15 13:25:26 +08:00
if (AI.isEnumAttribute()) return false;
Fix non-determinism in order of LLVM attributes We were using array_pod_sort on an array of type 'Attribute', which wraps a pointer to AttributeImpl. For the most part this didn't matter because the printing code prints enum attributes in a defined order, but integer attributes such as 'align' and 'dereferenceable' were not ordered. Furthermore, AttributeImpl::operator< was broken for integer attributes. An integer attribute is a kind and an integer value, and both pieces need to be compared. By fixing the comparison operator, we can go back to std::sort, and things look good now. This should fix clang arm-swiftcall.c test failures on Windows. llvm-svn: 265361
2016-04-05 07:06:05 +08:00
if (AI.isIntAttribute()) {
if (getKindAsEnum() == AI.getKindAsEnum())
return getValueAsInt() < AI.getValueAsInt();
return getKindAsEnum() < AI.getKindAsEnum();
}
Simplify the 'operator<' for the attribute object. llvm-svn: 175252
2013-02-15 13:25:26 +08:00
if (AI.isStringAttribute()) return true;
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
}
Create a new class: AttributeSetNode. This is a helper class for the AttributeSetImpl class. It holds a set of attributes that apply to a single element: function, return type, or parameter. These are uniqued. llvm-svn: 173310
2013-01-24 08:06:56 +08:00
Simplify the 'operator<' for the attribute object. llvm-svn: 175252
2013-02-15 13:25:26 +08:00
if (AI.isEnumAttribute()) return false;
Rename AlignAttribute to IntAttribute Currently the only kind of integer IR attributes that we have are alignment attributes, and so the attribute kind that takes an integer parameter is called AlignAttr, but that will change (we'll soon be adding a dereferenceable attribute that also takes an integer value). Accordingly, rename AlignAttribute to IntAttribute (class names, enums, etc.). No functionality change intended. llvm-svn: 213352
2014-07-18 14:51:55 +08:00
if (AI.isIntAttribute()) return false;
Simplify the 'operator<' for the attribute object. llvm-svn: 175252
2013-02-15 13:25:26 +08:00
if (getKindAsString() == AI.getKindAsString())
return getValueAsString() < AI.getValueAsString();
return getKindAsString() < AI.getKindAsString();
Create a new class: AttributeSetNode. This is a helper class for the AttributeSetImpl class. It holds a set of attributes that apply to a single element: function, return type, or parameter. These are uniqued. llvm-svn: 173310
2013-01-24 08:06:56 +08:00
}
General cleanups. * Remove dead methods. * Use the 'operator==' method instead of 'contains', which isn't needed. * Fix some comments. No functionality change. llvm-svn: 171523
2013-01-05 04:54:35 +08:00
uint64_t AttributeImpl::getAttrMask(Attribute::AttrKind Val) {
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
// FIXME: Remove this.
Create enums for the different attributes. We use the enums to query whether an Attributes object has that attribute. The opaque layer is responsible for knowing where that specific attribute is stored. llvm-svn: 165488
2012-10-09 15:45:08 +08:00
switch (Val) {
Switch the empty and tombstone key enumerators to not have explicit values -- that's not required to fix the bug that was cropping up, and the values selected made the enumeration's underlying type signed and introduced some warnings. This fixes the -Werror build. The underlying issue here was that the DenseMapInfo was casting values completely outside the range of the underlying storage of the enumeration to the enumeration's type. GCC went and "optimized" that into infloops and other misbehavior. By providing designated special values for these keys in the dense map, we ensure they are indeed representable and that they won't be used for anything else. It might be better to reuse None for the empty key and have the tombstone share the value of the sentinel enumerator, but honestly having 2 extra enumerators seemed not to matter and this seems a bit simpler. I'll let Bill shuffle this around (or ask me to shuffle it around) if he prefers it to look a different way. I also made the switch a bit more clear (and produce a better assert) that the enumerators are *never* going to show up and are errors if they do. llvm-svn: 171614
2013-01-05 16:47:26 +08:00
case Attribute::EndAttrKinds:
llvm_unreachable("Synthetic enumerators which should never get here");
Rename the 'Attributes' class to 'Attribute'. It's going to represent a single attribute in the future. llvm-svn: 170502
2012-12-19 15:18:57 +08:00
case Attribute::None: return 0;
case Attribute::ZExt: return 1 << 0;
case Attribute::SExt: return 1 << 1;
case Attribute::NoReturn: return 1 << 2;
case Attribute::InReg: return 1 << 3;
case Attribute::StructRet: return 1 << 4;
case Attribute::NoUnwind: return 1 << 5;
case Attribute::NoAlias: return 1 << 6;
case Attribute::ByVal: return 1 << 7;
case Attribute::Nest: return 1 << 8;
case Attribute::ReadNone: return 1 << 9;
case Attribute::ReadOnly: return 1 << 10;
case Attribute::NoInline: return 1 << 11;
case Attribute::AlwaysInline: return 1 << 12;
case Attribute::OptimizeForSize: return 1 << 13;
case Attribute::StackProtect: return 1 << 14;
case Attribute::StackProtectReq: return 1 << 15;
case Attribute::Alignment: return 31 << 16;
case Attribute::NoCapture: return 1 << 21;
case Attribute::NoRedZone: return 1 << 22;
case Attribute::NoImplicitFloat: return 1 << 23;
case Attribute::Naked: return 1 << 24;
case Attribute::InlineHint: return 1 << 25;
case Attribute::StackAlignment: return 7 << 26;
case Attribute::ReturnsTwice: return 1 << 29;
case Attribute::UWTable: return 1 << 30;
case Attribute::NonLazyBind: return 1U << 31;
Unify clang/llvm attributes for asan/tsan/msan (LLVM part) These are two related changes (one in llvm, one in clang). LLVM: - rename address_safety => sanitize_address (the enum value is the same, so we preserve binary compatibility with old bitcode) - rename thread_safety => sanitize_thread - rename no_uninitialized_checks -> sanitize_memory CLANG: - add __attribute__((no_sanitize_address)) as a synonym for __attribute__((no_address_safety_analysis)) - add __attribute__((no_sanitize_thread)) - add __attribute__((no_sanitize_memory)) for S in address thread memory If -fsanitize=S is present and __attribute__((no_sanitize_S)) is not set llvm attribute sanitize_S llvm-svn: 176075
2013-02-26 14:58:09 +08:00
case Attribute::SanitizeAddress: return 1ULL << 32;
Rename the 'Attributes' class to 'Attribute'. It's going to represent a single attribute in the future. llvm-svn: 170502
2012-12-19 15:18:57 +08:00
case Attribute::MinSize: return 1ULL << 33;
Add a new attribute, 'noduplicate'. If a function contains a noduplicate call, the call cannot be duplicated - Jump threading, loop unrolling, loop unswitching, and loop rotation are inhibited if they would duplicate the call. Similarly inlining of the function is inhibited, if that would duplicate the call (in particular inlining is still allowed when there is only one callsite and the function has internal linkage). llvm-svn: 170704
2012-12-21 00:04:27 +08:00
case Attribute::NoDuplicate: return 1ULL << 34;
Add the IR attribute 'sspstrong'. SSPStrong applies a heuristic to insert stack protectors in these situations: * A Protector is required for functions which contain an array, regardless of type or length. * A Protector is required for functions which contain a structure/union which contains an array, regardless of type or length. Note, there is no limit to the depth of nesting. * A protector is required when the address of a local variable (i.e., stack based variable) is exposed. (E.g., such as through a local whose address is taken as part of the RHS of an assignment or a local whose address is taken as part of a function argument.) This patch implements the SSPString attribute to be equivalent to SSPRequired. This will change in a subsequent patch. llvm-svn: 173230
2013-01-23 14:41:41 +08:00
case Attribute::StackProtectStrong: return 1ULL << 35;
Unify clang/llvm attributes for asan/tsan/msan (LLVM part) These are two related changes (one in llvm, one in clang). LLVM: - rename address_safety => sanitize_address (the enum value is the same, so we preserve binary compatibility with old bitcode) - rename thread_safety => sanitize_thread - rename no_uninitialized_checks -> sanitize_memory CLANG: - add __attribute__((no_sanitize_address)) as a synonym for __attribute__((no_address_safety_analysis)) - add __attribute__((no_sanitize_thread)) - add __attribute__((no_sanitize_memory)) for S in address thread memory If -fsanitize=S is present and __attribute__((no_sanitize_S)) is not set llvm attribute sanitize_S llvm-svn: 176075
2013-02-26 14:58:09 +08:00
case Attribute::SanitizeThread: return 1ULL << 36;
case Attribute::SanitizeMemory: return 1ULL << 37;
Add a bitmask for NoBuiltin. This should *not* be used. llvm-svn: 175843
2013-02-22 08:40:12 +08:00
case Attribute::NoBuiltin: return 1ULL << 38;
Add CodeGen support for functions that always return arguments via a new parameter attribute 'returned', which is taken advantage of in target-independent tail call opportunity detection and in ARM call lowering (when placed on an integral first parameter). llvm-svn: 179925
2013-04-20 13:14:40 +08:00
case Attribute::Returned: return 1ULL << 39;
Add a new function attribute 'cold' to functions. Other than recognizing the attribute, the patch does little else. It changes the branch probability analyzer so that edges into blocks postdominated by a cold function are given low weight. Added analysis and code generation tests. Added documentation for the new attribute. llvm-svn: 182638
2013-05-24 20:26:52 +08:00
case Attribute::Cold: return 1ULL << 40;
Added support for the Builtin attribute. The Builtin attribute is an attribute that can be placed on function call site that signal that even though a function is declared as being a builtin, rdar://problem/13727199 llvm-svn: 185049
2013-06-27 08:25:01 +08:00
case Attribute::Builtin: return 1ULL << 41;
Add function attribute 'optnone'. This function attribute indicates that the function is not optimized by any optimization or code generator passes with the exception of interprocedural optimization passes. llvm-svn: 189101
2013-08-23 19:53:55 +08:00
case Attribute::OptimizeNone: return 1ULL << 42;
Begin adding docs and IR-level support for the inalloca attribute The inalloca attribute is designed to support passing C++ objects by value in the Microsoft C++ ABI. It behaves the same as byval, except that it always implies that the argument is in memory and that the bytes are never copied. This attribute allows the caller to take the address of an outgoing argument's memory and execute arbitrary code to store into it. This patch adds basic IR support, docs, and verification. It does not attempt to implement any lowering or fix any possibly broken transforms. When this patch lands, a complete description of this feature should appear at http://llvm.org/docs/InAlloca.html . Differential Revision: http://llvm-reviews.chandlerc.com/D2173 llvm-svn: 197645
2013-12-19 10:14:12 +08:00
case Attribute::InAlloca: return 1ULL << 43;
Add 'nonnull', a new parameter and return attribute which indicates that the pointer is not null. Instcombine will elide comparisons between these and null. Patch by Luqman Aden! llvm-svn: 209185
2014-05-20 09:23:40 +08:00
case Attribute::NonNull: return 1ULL << 44;
Add a new attribute called 'jumptable' that creates jump-instruction tables for functions marked with this attribute. It includes a pass that rewrites all indirect calls to jumptable functions to pass through these tables. This also adds backend support for generating the jump-instruction tables on ARM and X86. Note that since the jumptable attribute creates a second function pointer for a function, any function marked with jumptable must also be marked with unnamed_addr. llvm-svn: 210280
2014-06-06 03:29:43 +08:00
case Attribute::JumpTable: return 1ULL << 45;
Add initial support for the convergent attribute. llvm-svn: 238264
2015-05-27 07:48:40 +08:00
case Attribute::Convergent: return 1ULL << 46;
Protection against stack-based memory corruption errors using SafeStack This patch adds the safe stack instrumentation pass to LLVM, which separates the program stack into a safe stack, which stores return addresses, register spills, and local variables that are statically verified to be accessed in a safe way, and the unsafe stack, which stores everything else. Such separation makes it much harder for an attacker to corrupt objects on the safe stack, including function pointers stored in spilled registers and return addresses. You can find more information about the safe stack, as well as other parts of or control-flow hijack protection technique in our OSDI paper on code-pointer integrity (http://dslab.epfl.ch/pubs/cpi.pdf) and our project website (http://levee.epfl.ch). The overhead of our implementation of the safe stack is very close to zero (0.01% on the Phoronix benchmarks). This is lower than the overhead of stack cookies, which are supported by LLVM and are commonly used today, yet the security guarantees of the safe stack are strictly stronger than stack cookies. In some cases, the safe stack improves performance due to better cache locality. Our current implementation of the safe stack is stable and robust, we used it to recompile multiple projects on Linux including Chromium, and we also recompiled the entire FreeBSD user-space system and more than 100 packages. We ran unit tests on the FreeBSD system and many of the packages and observed no errors caused by the safe stack. The safe stack is also fully binary compatible with non-instrumented code and can be applied to parts of a program selectively. This patch is our implementation of the safe stack on top of LLVM. The patches make the following changes: - Add the safestack function attribute, similar to the ssp, sspstrong and sspreq attributes. - Add the SafeStack instrumentation pass that applies the safe stack to all functions that have the safestack attribute. This pass moves all unsafe local variables to the unsafe stack with a separate stack pointer, whereas all safe variables remain on the regular stack that is managed by LLVM as usual. - Invoke the pass as the last stage before code generation (at the same time the existing cookie-based stack protector pass is invoked). - Add unit tests for the safe stack. Original patch by Volodymyr Kuznetsov and others at the Dependable Systems Lab at EPFL; updates and upstreaming by myself. Differential Revision: http://reviews.llvm.org/D6094 llvm-svn: 239761
2015-06-16 05:07:11 +08:00
case Attribute::SafeStack: return 1ULL << 47;
Add a new attribute: norecurse This attribute allows the compiler to assume that the function never recurses into itself, either directly or indirectly (transitively). This can be used among other things to demote global variables to locals. llvm-svn: 252282
2015-11-06 18:32:53 +08:00
case Attribute::NoRecurse: return 1ULL << 48;
Add InaccessibleMemOnly and inaccessibleMemOrArgMemOnly attributes Summary: This patch introduces two new function attributes InaccessibleMemOnly: This attribute indicates that the function may only access memory that is not accessible by the program/IR being compiled. This is a weaker form of ReadNone. inaccessibleMemOrArgMemOnly: This attribute indicates that the function may only access memory that is either not accessible by the program/IR being compiled, or is pointed to by its pointer arguments. This is a weaker form of ArgMemOnly Test cases have been updated. This revision uses this (https://github.com/llvm-mirror/llvm/commit/d001932f3a8aa1ebd1555162fdce365f011bc292) as reference. Reviewers: jmolloy, hfinkel Subscribers: reames, joker.eph, llvm-commits Differential Revision: http://reviews.llvm.org/D15499 llvm-svn: 255778
2015-12-17 00:16:19 +08:00
case Attribute::InaccessibleMemOnly: return 1ULL << 49;
case Attribute::InaccessibleMemOrArgMemOnly: return 1ULL << 50;
Swift Calling Convention: add swiftself attribute. Differential Revision: http://reviews.llvm.org/D17866 llvm-svn: 264754
2016-03-30 01:37:21 +08:00
case Attribute::SwiftSelf: return 1ULL << 51;
Swift Calling Convention: add swifterror attribute. A ``swifterror`` attribute can be applied to a function parameter or an AllocaInst. This commit does not include any target-specific change. The target-specific optimization will come as a follow-up patch. Differential Revision: http://reviews.llvm.org/D18092 llvm-svn: 265189
2016-04-02 05:41:15 +08:00
case Attribute::SwiftError: return 1ULL << 52;
Add a dereferenceable attribute This attribute indicates that the parameter or return pointer is dereferenceable. Practically speaking, loads from such a pointer within the associated byte range are safe to speculatively execute. Such pointer parameters are common in source languages (C++ references, for example). llvm-svn: 213385
2014-07-18 23:51:28 +08:00
case Attribute::Dereferenceable:
llvm_unreachable("dereferenceable attribute not supported in raw format");
[IR] Introduce a dereferenceable_or_null(N) attribute. Summary: If a pointer is marked as dereferenceable_or_null(N), LLVM assumes it is either `null` or `dereferenceable(N)` or both. This change only introduces the attribute and adds a token test case for the `llvm-as` / `llvm-dis`. It does not hook up other parts of the optimizer to actually exploit the attribute -- those changes will come later. For pointers in address space 0, `dereferenceable(N)` is now exactly equivalent to `dereferenceable_or_null(N)` && `nonnull`. For other address spaces, `dereferenceable(N)` is potentially weaker than `dereferenceable_or_null(N)` && `nonnull` (since we could have a null `dereferenceable(N)` pointer). The motivating case for this change is Java (and other managed languages), where pointers are either `null` or dereferenceable up to some usually known-at-compile-time constant offset. Reviewers: rafael, hfinkel Reviewed By: hfinkel Subscribers: nicholas, llvm-commits Differential Revision: http://reviews.llvm.org/D8650 llvm-svn: 235132
2015-04-17 04:29:50 +08:00
break;
case Attribute::DereferenceableOrNull:
llvm_unreachable("dereferenceable_or_null attribute not supported in raw "
"format");
break;
Add argmemonly attribute. This change adds new attribute called "argmemonly". Function marked with this attribute can only access memory through it's argument pointers. This attribute directly corresponds to the "OnlyAccessesArgumentPointees" ModRef behaviour in alias analysis. Differential Revision: http://reviews.llvm.org/D10398 llvm-svn: 241979
2015-07-11 18:30:36 +08:00
case Attribute::ArgMemOnly:
llvm_unreachable("argmemonly attribute not supported in raw format");
break;
Remove warning about default covering no cases. llvm-svn: 175846
2013-02-22 08:50:09 +08:00
}
llvm_unreachable("Unsupported attribute type");
Create enums for the different attributes. We use the enums to query whether an Attributes object has that attribute. The opaque layer is responsible for knowing where that specific attribute is stored. llvm-svn: 165488
2012-10-09 15:45:08 +08:00
}
Create a new class: AttributeSetNode. This is a helper class for the AttributeSetImpl class. It holds a set of attributes that apply to a single element: function, return type, or parameter. These are uniqued. llvm-svn: 173310
2013-01-24 08:06:56 +08:00
//===----------------------------------------------------------------------===//
// AttributeSetNode Definition
//===----------------------------------------------------------------------===//
AttributeSetNode *AttributeSetNode::get(LLVMContext &C,
ArrayRef<Attribute> Attrs) {
if (Attrs.empty())
[C++11] More 'nullptr' conversion or in some cases just using a boolean check instead of comparing to nullptr. llvm-svn: 205831
2014-04-09 14:08:46 +08:00
return nullptr;
Create a new class: AttributeSetNode. This is a helper class for the AttributeSetImpl class. It holds a set of attributes that apply to a single element: function, return type, or parameter. These are uniqued. llvm-svn: 173310
2013-01-24 08:06:56 +08:00
// Otherwise, build a key to look up the existing attributes.
LLVMContextImpl *pImpl = C.pImpl;
FoldingSetNodeID ID;
SmallVector<Attribute, 8> SortedAttrs(Attrs.begin(), Attrs.end());
Fix non-determinism in order of LLVM attributes We were using array_pod_sort on an array of type 'Attribute', which wraps a pointer to AttributeImpl. For the most part this didn't matter because the printing code prints enum attributes in a defined order, but integer attributes such as 'align' and 'dereferenceable' were not ordered. Furthermore, AttributeImpl::operator< was broken for integer attributes. An integer attribute is a kind and an integer value, and both pieces need to be compared. By fixing the comparison operator, we can go back to std::sort, and things look good now. This should fix clang arm-swiftcall.c test failures on Windows. llvm-svn: 265361
2016-04-05 07:06:05 +08:00
std::sort(SortedAttrs.begin(), SortedAttrs.end());
Create a new class: AttributeSetNode. This is a helper class for the AttributeSetImpl class. It holds a set of attributes that apply to a single element: function, return type, or parameter. These are uniqued. llvm-svn: 173310
2013-01-24 08:06:56 +08:00
Minor cleanup of Attribute code. NFC. llvm-svn: 255751
2015-12-16 13:21:02 +08:00
for (Attribute Attr : SortedAttrs)
Attr.Profile(ID);
Create a new class: AttributeSetNode. This is a helper class for the AttributeSetImpl class. It holds a set of attributes that apply to a single element: function, return type, or parameter. These are uniqued. llvm-svn: 173310
2013-01-24 08:06:56 +08:00
void *InsertPoint;
AttributeSetNode *PA =
pImpl->AttrsSetNodes.FindNodeOrInsertPos(ID, InsertPoint);
// If we didn't find any existing attributes of the same shape then create a
// new one and insert it.
if (!PA) {
Reduce the number of indirections in the attributes implementation. - Coallocate entires for AttributeSetImpls and Nodes after the class itself. - Remove mutable iterators from immutable classes. - Remove unused context field from AttributeImpl. - Derive Enum/Align/String attribute implementations from AttributeImpl instead of having a whole new inheritance tree for them. - Derive AlignAttributeImpl from EnumAttributeImpl. llvm-svn: 186075
2013-07-11 20:13:16 +08:00
// Coallocate entries after the AttributeSetNode itself.
Add a TrailingObjects template class. This is intended to help support the idiom of a class that has some other objects (or multiple arrays of different types of objects) appended on the end, which is used quite heavily in clang. Differential Revision: http://reviews.llvm.org/D11272 llvm-svn: 244164
2015-08-06 06:57:34 +08:00
void *Mem = ::operator new(totalSizeToAlloc<Attribute>(SortedAttrs.size()));
Reduce the number of indirections in the attributes implementation. - Coallocate entires for AttributeSetImpls and Nodes after the class itself. - Remove mutable iterators from immutable classes. - Remove unused context field from AttributeImpl. - Derive Enum/Align/String attribute implementations from AttributeImpl instead of having a whole new inheritance tree for them. - Derive AlignAttributeImpl from EnumAttributeImpl. llvm-svn: 186075
2013-07-11 20:13:16 +08:00
PA = new (Mem) AttributeSetNode(SortedAttrs);
Create a new class: AttributeSetNode. This is a helper class for the AttributeSetImpl class. It holds a set of attributes that apply to a single element: function, return type, or parameter. These are uniqued. llvm-svn: 173310
2013-01-24 08:06:56 +08:00
pImpl->AttrsSetNodes.InsertNode(PA, InsertPoint);
}
// Return the AttributesListNode that we found or created.
return PA;
}
Add some accessor and query methods for retrieving Attribute objects and such. llvm-svn: 175046
2013-02-13 16:42:21 +08:00
bool AttributeSetNode::hasAttribute(StringRef Kind) const {
Reduce the number of indirections in the attributes implementation. - Coallocate entires for AttributeSetImpls and Nodes after the class itself. - Remove mutable iterators from immutable classes. - Remove unused context field from AttributeImpl. - Derive Enum/Align/String attribute implementations from AttributeImpl instead of having a whole new inheritance tree for them. - Derive AlignAttributeImpl from EnumAttributeImpl. llvm-svn: 186075
2013-07-11 20:13:16 +08:00
for (iterator I = begin(), E = end(); I != E; ++I)
Add some accessor and query methods for retrieving Attribute objects and such. llvm-svn: 175046
2013-02-13 16:42:21 +08:00
if (I->hasAttribute(Kind))
return true;
return false;
}
Attribute AttributeSetNode::getAttribute(Attribute::AttrKind Kind) const {
AttributeSetNode: Summarize existing attributes in a bitset. The majority of queries just checks for the existince of an enum attribute. We only have 48 of those and can summaryiz them in an uint64_t bitfield so we can avoid searching the list. This improves "opt" compile time by 1-4% in my measurements. Differential Revision: http://reviews.llvm.org/D16617 llvm-svn: 259251
2016-01-30 06:25:13 +08:00
if (hasAttribute(Kind)) {
for (iterator I = begin(), E = end(); I != E; ++I)
if (I->hasAttribute(Kind))
return *I;
}
Add some accessor and query methods for retrieving Attribute objects and such. llvm-svn: 175046
2013-02-13 16:42:21 +08:00
return Attribute();
}
Attribute AttributeSetNode::getAttribute(StringRef Kind) const {
Reduce the number of indirections in the attributes implementation. - Coallocate entires for AttributeSetImpls and Nodes after the class itself. - Remove mutable iterators from immutable classes. - Remove unused context field from AttributeImpl. - Derive Enum/Align/String attribute implementations from AttributeImpl instead of having a whole new inheritance tree for them. - Derive AlignAttributeImpl from EnumAttributeImpl. llvm-svn: 186075
2013-07-11 20:13:16 +08:00
for (iterator I = begin(), E = end(); I != E; ++I)
Add some accessor and query methods for retrieving Attribute objects and such. llvm-svn: 175046
2013-02-13 16:42:21 +08:00
if (I->hasAttribute(Kind))
return *I;
return Attribute();
}
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
unsigned AttributeSetNode::getAlignment() const {
Reduce the number of indirections in the attributes implementation. - Coallocate entires for AttributeSetImpls and Nodes after the class itself. - Remove mutable iterators from immutable classes. - Remove unused context field from AttributeImpl. - Derive Enum/Align/String attribute implementations from AttributeImpl instead of having a whole new inheritance tree for them. - Derive AlignAttributeImpl from EnumAttributeImpl. llvm-svn: 186075
2013-07-11 20:13:16 +08:00
for (iterator I = begin(), E = end(); I != E; ++I)
Revert r174026, "Remove Attribute::hasAttributes() and make Attribute::hasAttribute() private." It broke many hosts to crash. llvm-svn: 174035
2013-01-31 11:47:28 +08:00
if (I->hasAttribute(Attribute::Alignment))
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
return I->getAlignment();
return 0;
}
unsigned AttributeSetNode::getStackAlignment() const {
Reduce the number of indirections in the attributes implementation. - Coallocate entires for AttributeSetImpls and Nodes after the class itself. - Remove mutable iterators from immutable classes. - Remove unused context field from AttributeImpl. - Derive Enum/Align/String attribute implementations from AttributeImpl instead of having a whole new inheritance tree for them. - Derive AlignAttributeImpl from EnumAttributeImpl. llvm-svn: 186075
2013-07-11 20:13:16 +08:00
for (iterator I = begin(), E = end(); I != E; ++I)
Revert r174026, "Remove Attribute::hasAttributes() and make Attribute::hasAttribute() private." It broke many hosts to crash. llvm-svn: 174035
2013-01-31 11:47:28 +08:00
if (I->hasAttribute(Attribute::StackAlignment))
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
return I->getStackAlignment();
return 0;
}
Add a dereferenceable attribute This attribute indicates that the parameter or return pointer is dereferenceable. Practically speaking, loads from such a pointer within the associated byte range are safe to speculatively execute. Such pointer parameters are common in source languages (C++ references, for example). llvm-svn: 213385
2014-07-18 23:51:28 +08:00
uint64_t AttributeSetNode::getDereferenceableBytes() const {
for (iterator I = begin(), E = end(); I != E; ++I)
if (I->hasAttribute(Attribute::Dereferenceable))
return I->getDereferenceableBytes();
return 0;
}
Add missing dereferenceable_or_null getters Summary: Add missing dereferenceable_or_null getters required for http://reviews.llvm.org/D9253 change. Separated from the D9253 review. Patch by Artur Pilipenko! Reviewers: sanjoy Reviewed By: sanjoy Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D9499 llvm-svn: 236615
2015-05-07 01:41:54 +08:00
uint64_t AttributeSetNode::getDereferenceableOrNullBytes() const {
for (iterator I = begin(), E = end(); I != E; ++I)
if (I->hasAttribute(Attribute::DereferenceableOrNull))
return I->getDereferenceableOrNullBytes();
return 0;
}
Now that the underlying issue is fixed, revert r180750 and r180722. The cause of the windows failures was fixed by r180791. Revert to the state after Sabre's original revert. Original message: revert r179735, it has no testcases, and doesn't really make sense. llvm-svn: 180844
2013-05-01 21:07:03 +08:00
std::string AttributeSetNode::getAsString(bool InAttrGrp) const {
Attributes: Don't print trailing whitespace on the function attribute comment. llvm-svn: 179849
2013-04-19 19:43:21 +08:00
std::string Str;
Reduce the number of indirections in the attributes implementation. - Coallocate entires for AttributeSetImpls and Nodes after the class itself. - Remove mutable iterators from immutable classes. - Remove unused context field from AttributeImpl. - Derive Enum/Align/String attribute implementations from AttributeImpl instead of having a whole new inheritance tree for them. - Derive AlignAttributeImpl from EnumAttributeImpl. llvm-svn: 186075
2013-07-11 20:13:16 +08:00
for (iterator I = begin(), E = end(); I != E; ++I) {
if (I != begin())
Now that the underlying issue is fixed, revert r180750 and r180722. The cause of the windows failures was fixed by r180791. Revert to the state after Sabre's original revert. Original message: revert r179735, it has no testcases, and doesn't really make sense. llvm-svn: 180844
2013-05-01 21:07:03 +08:00
Str += ' ';
Str += I->getAsString(InAttrGrp);
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
}
return Str;
}
Reimplement the parameter attributes support, phase #1. hilights: 1. There is now a "PAListPtr" class, which is a smart pointer around the underlying uniqued parameter attribute list object, and manages its refcount. It is now impossible to mess up the refcount. 2. PAListPtr is now the main interface to the underlying object, and the underlying object is now completely opaque. 3. Implementation details like SmallVector and FoldingSet are now no longer part of the interface. 4. You can create a PAListPtr with an arbitrary sequence of ParamAttrsWithIndex's, no need to make a SmallVector of a specific size (you can just use an array or scalar or vector if you wish). 5. All the client code that had to check for a null pointer before dereferencing the pointer is simplified to just access the PAListPtr directly. 6. The interfaces for adding attrs to a list and removing them is a bit simpler. Phase #2 will rename some stuff (e.g. PAListPtr) and do other less invasive changes. llvm-svn: 48289
2008-03-13 01:45:29 +08:00
//===----------------------------------------------------------------------===//
s/AttributeListImpl/AttributeSetImpl/g to match the namechange of AttributeList. llvm-svn: 170600
2012-12-20 06:42:22 +08:00
// AttributeSetImpl Definition
Reimplement the parameter attributes support, phase #1. hilights: 1. There is now a "PAListPtr" class, which is a smart pointer around the underlying uniqued parameter attribute list object, and manages its refcount. It is now impossible to mess up the refcount. 2. PAListPtr is now the main interface to the underlying object, and the underlying object is now completely opaque. 3. Implementation details like SmallVector and FoldingSet are now no longer part of the interface. 4. You can create a PAListPtr with an arbitrary sequence of ParamAttrsWithIndex's, no need to make a SmallVector of a specific size (you can just use an array or scalar or vector if you wish). 5. All the client code that had to check for a null pointer before dereferencing the pointer is simplified to just access the PAListPtr directly. 6. The interfaces for adding attrs to a list and removing them is a bit simpler. Phase #2 will rename some stuff (e.g. PAListPtr) and do other less invasive changes. llvm-svn: 48289
2008-03-13 01:45:29 +08:00
//===----------------------------------------------------------------------===//
Change getSlotIndex to return unsigned. The actual storage was already using unsigned, but the interface was using uint64_t. This is wasteful on 32 bits and looks to be the root causes of a miscompilation on Windows where a value was being sign extended to 64bits to compare with the result of getSlotIndex. Patch by Pasi Parviainen! llvm-svn: 180791
2013-05-01 00:53:38 +08:00
uint64_t AttributeSetImpl::Raw(unsigned Index) const {
Push the calculation of the 'Raw' attribute mask down into the implementation. It in turn uses the correct list for calculating the 'Raw' value. llvm-svn: 173637
2013-01-28 07:41:29 +08:00
for (unsigned I = 0, E = getNumAttributes(); I != E; ++I) {
if (getSlotIndex(I) != Index) continue;
Reduce the number of indirections in the attributes implementation. - Coallocate entires for AttributeSetImpls and Nodes after the class itself. - Remove mutable iterators from immutable classes. - Remove unused context field from AttributeImpl. - Derive Enum/Align/String attribute implementations from AttributeImpl instead of having a whole new inheritance tree for them. - Derive AlignAttributeImpl from EnumAttributeImpl. llvm-svn: 186075
2013-07-11 20:13:16 +08:00
const AttributeSetNode *ASN = getSlotNode(I);
Remove AttrBuilder::Raw(). llvm-svn: 174251
2013-02-02 08:52:44 +08:00
uint64_t Mask = 0;
Push the calculation of the 'Raw' attribute mask down into the implementation. It in turn uses the correct list for calculating the 'Raw' value. llvm-svn: 173637
2013-01-28 07:41:29 +08:00
Reduce the number of indirections in the attributes implementation. - Coallocate entires for AttributeSetImpls and Nodes after the class itself. - Remove mutable iterators from immutable classes. - Remove unused context field from AttributeImpl. - Derive Enum/Align/String attribute implementations from AttributeImpl instead of having a whole new inheritance tree for them. - Derive AlignAttributeImpl from EnumAttributeImpl. llvm-svn: 186075
2013-07-11 20:13:16 +08:00
for (AttributeSetNode::iterator II = ASN->begin(),
Remove AttrBuilder::Raw(). llvm-svn: 174251
2013-02-02 08:52:44 +08:00
IE = ASN->end(); II != IE; ++II) {
Attribute Attr = *II;
The 'Raw' method cannot handle 'string' attributes. Don't even try. llvm-svn: 174848
2013-02-11 07:18:05 +08:00
// This cannot handle string attributes.
if (Attr.isStringAttribute()) continue;
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
Attribute::AttrKind Kind = Attr.getKindAsEnum();
Remove AttrBuilder::Raw(). llvm-svn: 174251
2013-02-02 08:52:44 +08:00
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
if (Kind == Attribute::Alignment)
Remove AttrBuilder::Raw(). llvm-svn: 174251
2013-02-02 08:52:44 +08:00
Mask |= (Log2_32(ASN->getAlignment()) + 1) << 16;
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
else if (Kind == Attribute::StackAlignment)
Remove AttrBuilder::Raw(). llvm-svn: 174251
2013-02-02 08:52:44 +08:00
Mask |= (Log2_32(ASN->getStackAlignment()) + 1) << 26;
Add a dereferenceable attribute This attribute indicates that the parameter or return pointer is dereferenceable. Practically speaking, loads from such a pointer within the associated byte range are safe to speculatively execute. Such pointer parameters are common in source languages (C++ references, for example). llvm-svn: 213385
2014-07-18 23:51:28 +08:00
else if (Kind == Attribute::Dereferenceable)
llvm_unreachable("dereferenceable not supported in bit mask");
Remove AttrBuilder::Raw(). llvm-svn: 174251
2013-02-02 08:52:44 +08:00
else
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
Mask |= AttributeImpl::getAttrMask(Kind);
Remove AttrBuilder::Raw(). llvm-svn: 174251
2013-02-02 08:52:44 +08:00
}
return Mask;
Push the calculation of the 'Raw' attribute mask down into the implementation. It in turn uses the correct list for calculating the 'Raw' value. llvm-svn: 173637
2013-01-28 07:41:29 +08:00
}
return 0;
}
Annotate dump() methods with LLVM_DUMP_METHOD, addressing Richard Smith r259192 post commit comment. clang part in r259232, this is the LLVM part of the patch. llvm-svn: 259240
2016-01-30 04:50:44 +08:00
LLVM_DUMP_METHOD void AttributeSetImpl::dump() const {
Add a AttributeSetImpl::dump function. This is for the benefit of those of us with inferior debuggers which do not permit member function calls on value types. llvm-svn: 187685
2013-08-03 06:34:30 +08:00
AttributeSet(const_cast<AttributeSetImpl *>(this)).dump();
}
In the AttributeSetImpl c'tor, fill in the AttrNodes data structure with the attributes being passed in. llvm-svn: 173618
2013-01-27 20:50:02 +08:00
//===----------------------------------------------------------------------===//
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
// AttributeSet Construction and Mutation Methods
In the AttributeSetImpl c'tor, fill in the AttrNodes data structure with the attributes being passed in. llvm-svn: 173618
2013-01-27 20:50:02 +08:00
//===----------------------------------------------------------------------===//
Use an AttrBuilder to generate the correct AttributeSet. We no longer accept an encoded integer as representing all of the attributes. Convert this via the AttrBuilder class into an AttributeSet with the correct representation (an AttributeSetImpl that holds a list of Attribute objects). llvm-svn: 173750
2013-01-29 09:43:29 +08:00
AttributeSet
AttributeSet::getImpl(LLVMContext &C,
ArrayRef<std::pair<unsigned, AttributeSetNode*> > Attrs) {
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
LLVMContextImpl *pImpl = C.pImpl;
FoldingSetNodeID ID;
AttributeSetImpl::Profile(ID, Attrs);
Cleanup whitespace. llvm-svn: 166013
2012-10-16 14:01:44 +08:00
Make the AttrListPtr object a part of the LLVMContext. When code deletes the context, the AttributeImpls that the AttrListPtr points to are now invalid. Therefore, instead of keeping a separate managed static for the AttrListPtrs that's reference counted, move it into the LLVMContext and delete it when deleting the AttributeImpls. llvm-svn: 168354
2012-11-20 13:09:20 +08:00
void *InsertPoint;
Add a method to create an AttributeSet from an AttrBuilder. The Attribute class is eventually going to represent one attribute. So we need this class to create the set of attributes. Add some iterator methods to the builder to access its internal bits in a nice way. llvm-svn: 171586
2013-01-05 09:36:54 +08:00
AttributeSetImpl *PA = pImpl->AttrsLists.FindNodeOrInsertPos(ID, InsertPoint);
Cleanup whitespace. llvm-svn: 166013
2012-10-16 14:01:44 +08:00
Split param attr implementation out from Function.cpp into its own file. Don't #include ParameterAttributes.h into any major public header files: just move methods out of line as appropriate. llvm-svn: 45517
2008-01-03 07:42:30 +08:00
// If we didn't find any existing attributes of the same shape then
// create a new one and insert it.
Make the AttrListPtr object a part of the LLVMContext. When code deletes the context, the AttributeImpls that the AttrListPtr points to are now invalid. Therefore, instead of keeping a separate managed static for the AttrListPtrs that's reference counted, move it into the LLVMContext and delete it when deleting the AttributeImpls. llvm-svn: 168354
2012-11-20 13:09:20 +08:00
if (!PA) {
Reduce the number of indirections in the attributes implementation. - Coallocate entires for AttributeSetImpls and Nodes after the class itself. - Remove mutable iterators from immutable classes. - Remove unused context field from AttributeImpl. - Derive Enum/Align/String attribute implementations from AttributeImpl instead of having a whole new inheritance tree for them. - Derive AlignAttributeImpl from EnumAttributeImpl. llvm-svn: 186075
2013-07-11 20:13:16 +08:00
// Coallocate entries after the AttributeSetImpl itself.
Add a TrailingObjects template class. This is intended to help support the idiom of a class that has some other objects (or multiple arrays of different types of objects) appended on the end, which is used quite heavily in clang. Differential Revision: http://reviews.llvm.org/D11272 llvm-svn: 244164
2015-08-06 06:57:34 +08:00
void *Mem = ::operator new(
AttributeSetImpl::totalSizeToAlloc<IndexAttrPair>(Attrs.size()));
Reduce the number of indirections in the attributes implementation. - Coallocate entires for AttributeSetImpls and Nodes after the class itself. - Remove mutable iterators from immutable classes. - Remove unused context field from AttributeImpl. - Derive Enum/Align/String attribute implementations from AttributeImpl instead of having a whole new inheritance tree for them. - Derive AlignAttributeImpl from EnumAttributeImpl. llvm-svn: 186075
2013-07-11 20:13:16 +08:00
PA = new (Mem) AttributeSetImpl(C, Attrs);
Make the AttrListPtr object a part of the LLVMContext. When code deletes the context, the AttributeImpls that the AttrListPtr points to are now invalid. Therefore, instead of keeping a separate managed static for the AttrListPtrs that's reference counted, move it into the LLVMContext and delete it when deleting the AttributeImpls. llvm-svn: 168354
2012-11-20 13:09:20 +08:00
pImpl->AttrsLists.InsertNode(PA, InsertPoint);
Split param attr implementation out from Function.cpp into its own file. Don't #include ParameterAttributes.h into any major public header files: just move methods out of line as appropriate. llvm-svn: 45517
2008-01-03 07:42:30 +08:00
}
Cleanup whitespace. llvm-svn: 166013
2012-10-16 14:01:44 +08:00
Large mechanical patch. s/ParamAttr/Attribute/g s/PAList/AttrList/g s/FnAttributeWithIndex/AttributeWithIndex/g s/FnAttr/Attribute/g This sets the stage - to implement function notes as function attributes and - to distinguish between function attributes and return value attributes. This requires corresponding changes in llvm-gcc and clang. llvm-svn: 56622
2008-09-26 05:00:45 +08:00
// Return the AttributesList that we found or created.
s/AttrListPtr/AttributeSet/g to better label what this class is going to be in the near future. llvm-svn: 169651
2012-12-08 07:16:57 +08:00
return AttributeSet(PA);
Split param attr implementation out from Function.cpp into its own file. Don't #include ParameterAttributes.h into any major public header files: just move methods out of line as appropriate. llvm-svn: 45517
2008-01-03 07:42:30 +08:00
}
Remove the AttributeWithIndex class. The AttributeWithIndex class exposed the interior structure of the AttributeSet class. That was gross. Remove it and all of the code that relied upon it. llvm-svn: 173722
2013-01-29 05:55:20 +08:00
AttributeSet AttributeSet::get(LLVMContext &C,
Try to appease some broken compilers by using 'unsigned' instead of 'uint64_t'. llvm-svn: 173725
2013-01-29 06:33:39 +08:00
ArrayRef<std::pair<unsigned, Attribute> > Attrs){
Remove the AttributeWithIndex class. The AttributeWithIndex class exposed the interior structure of the AttributeSet class. That was gross. Remove it and all of the code that relied upon it. llvm-svn: 173722
2013-01-29 05:55:20 +08:00
// If there are no attributes then return a null AttributesList pointer.
if (Attrs.empty())
return AttributeSet();
Use std::is_sorted and std::none_of instead of manual loops. NFC llvm-svn: 256719
2016-01-04 03:43:40 +08:00
assert(std::is_sorted(Attrs.begin(), Attrs.end(),
[](const std::pair<unsigned, Attribute> &LHS,
const std::pair<unsigned, Attribute> &RHS) {
return LHS.first < RHS.first;
}) && "Misordered Attributes list!");
assert(std::none_of(Attrs.begin(), Attrs.end(),
[](const std::pair<unsigned, Attribute> &Pair) {
return Pair.second.hasAttribute(Attribute::None);
}) && "Pointless attribute!");
Remove the AttributeWithIndex class. The AttributeWithIndex class exposed the interior structure of the AttributeSet class. That was gross. Remove it and all of the code that relied upon it. llvm-svn: 173722
2013-01-29 05:55:20 +08:00
Try to appease some broken compilers by using 'unsigned' instead of 'uint64_t'. llvm-svn: 173725
2013-01-29 06:33:39 +08:00
// Create a vector if (unsigned, AttributeSetNode*) pairs from the attributes
Remove the AttributeWithIndex class. The AttributeWithIndex class exposed the interior structure of the AttributeSet class. That was gross. Remove it and all of the code that relied upon it. llvm-svn: 173722
2013-01-29 05:55:20 +08:00
// list.
Try to appease some broken compilers by using 'unsigned' instead of 'uint64_t'. llvm-svn: 173725
2013-01-29 06:33:39 +08:00
SmallVector<std::pair<unsigned, AttributeSetNode*>, 8> AttrPairVec;
for (ArrayRef<std::pair<unsigned, Attribute> >::iterator I = Attrs.begin(),
Remove the AttributeWithIndex class. The AttributeWithIndex class exposed the interior structure of the AttributeSet class. That was gross. Remove it and all of the code that relied upon it. llvm-svn: 173722
2013-01-29 05:55:20 +08:00
E = Attrs.end(); I != E; ) {
Try to appease some broken compilers by using 'unsigned' instead of 'uint64_t'. llvm-svn: 173725
2013-01-29 06:33:39 +08:00
unsigned Index = I->first;
Remove the AttributeWithIndex class. The AttributeWithIndex class exposed the interior structure of the AttributeSet class. That was gross. Remove it and all of the code that relied upon it. llvm-svn: 173722
2013-01-29 05:55:20 +08:00
SmallVector<Attribute, 4> AttrVec;
AttributeSet::get(): Fix a valgrind error. It doesn't affect actual behavior, though. Don't touch I->first on the end iterator, I == E! llvm-svn: 173804
2013-01-29 23:18:16 +08:00
while (I != E && I->first == Index) {
Remove the AttributeWithIndex class. The AttributeWithIndex class exposed the interior structure of the AttributeSet class. That was gross. Remove it and all of the code that relied upon it. llvm-svn: 173722
2013-01-29 05:55:20 +08:00
AttrVec.push_back(I->second);
++I;
}
AttrPairVec.push_back(std::make_pair(Index,
AttributeSetNode::get(C, AttrVec)));
}
return getImpl(C, AttrPairVec);
}
AttributeSet AttributeSet::get(LLVMContext &C,
Try to appease some broken compilers by using 'unsigned' instead of 'uint64_t'. llvm-svn: 173725
2013-01-29 06:33:39 +08:00
ArrayRef<std::pair<unsigned,
Remove the AttributeWithIndex class. The AttributeWithIndex class exposed the interior structure of the AttributeSet class. That was gross. Remove it and all of the code that relied upon it. llvm-svn: 173722
2013-01-29 05:55:20 +08:00
AttributeSetNode*> > Attrs) {
// If there are no attributes then return a null AttributesList pointer.
if (Attrs.empty())
return AttributeSet();
return getImpl(C, Attrs);
}
IR: Cleanup AttributeSet::get for AttrBuilder We don't modify the AttrBuilder in AttributeSet::get, make the reference argument const. llvm-svn: 207924
2014-05-04 07:00:35 +08:00
AttributeSet AttributeSet::get(LLVMContext &C, unsigned Index,
const AttrBuilder &B) {
Have AttributeSet::getRetAttributes() return an AttributeSet instead of Attribute. This further restricts the use of the Attribute class to the Attribute family of classes. llvm-svn: 173098
2013-01-22 06:44:49 +08:00
if (!B.hasAttributes())
return AttributeSet();
Convert the AttrBuilder into a list of Attributes instead of one Attribute object that holds all of its attributes. llvm-svn: 173742
2013-01-29 09:02:03 +08:00
Add the target-dependent (string) attributes from the AttrBuilder to the AttributeSet. llvm-svn: 174467
2013-02-06 07:48:36 +08:00
// Add target-independent attributes.
Convert the AttrBuilder into a list of Attributes instead of one Attribute object that holds all of its attributes. llvm-svn: 173742
2013-01-29 09:02:03 +08:00
SmallVector<std::pair<unsigned, Attribute>, 8> Attrs;
Turn the enum attributes DenseSet in AttrBuilder into a set of bits. Avoids malloc and is a lot denser. We lose iteration over target independent attributes, but that's a strange interface anyways and didn't have any users outside of AttrBuilder. llvm-svn: 175370
2013-02-17 03:13:18 +08:00
for (Attribute::AttrKind Kind = Attribute::None;
GCC doesn't like ++ on enums. llvm-svn: 175373
2013-02-17 03:22:28 +08:00
Kind != Attribute::EndAttrKinds; Kind = Attribute::AttrKind(Kind + 1)) {
Turn the enum attributes DenseSet in AttrBuilder into a set of bits. Avoids malloc and is a lot denser. We lose iteration over target independent attributes, but that's a strange interface anyways and didn't have any users outside of AttrBuilder. llvm-svn: 175370
2013-02-17 03:13:18 +08:00
if (!B.contains(Kind))
continue;
Minor cleanup of Attribute code. NFC. llvm-svn: 255751
2015-12-16 13:21:02 +08:00
Attribute Attr;
switch (Kind) {
case Attribute::Alignment:
Attr = Attribute::getWithAlignment(C, B.getAlignment());
break;
case Attribute::StackAlignment:
Attr = Attribute::getWithStackAlignment(C, B.getStackAlignment());
break;
case Attribute::Dereferenceable:
Attr = Attribute::getWithDereferenceableBytes(
C, B.getDereferenceableBytes());
break;
case Attribute::DereferenceableOrNull:
Attr = Attribute::getWithDereferenceableOrNullBytes(
C, B.getDereferenceableOrNullBytes());
break;
default:
Attr = Attribute::get(C, Kind);
}
Attrs.push_back(std::make_pair(Index, Attr));
Convert the AttrBuilder into a list of Attributes instead of one Attribute object that holds all of its attributes. llvm-svn: 173742
2013-01-29 09:02:03 +08:00
}
Add the target-dependent (string) attributes from the AttrBuilder to the AttributeSet. llvm-svn: 174467
2013-02-06 07:48:36 +08:00
// Add target-dependent (string) attributes.
IR: Cleanup AttributeSet::get for AttrBuilder We don't modify the AttrBuilder in AttributeSet::get, make the reference argument const. llvm-svn: 207924
2014-05-04 07:00:35 +08:00
for (const AttrBuilder::td_type &TDA : B.td_attrs())
Attrs.push_back(
std::make_pair(Index, Attribute::get(C, TDA.first, TDA.second)));
Add the target-dependent (string) attributes from the AttrBuilder to the AttributeSet. llvm-svn: 174467
2013-02-06 07:48:36 +08:00
Convert the AttrBuilder into a list of Attributes instead of one Attribute object that holds all of its attributes. llvm-svn: 173742
2013-01-29 09:02:03 +08:00
return get(C, Attrs);
Add a method to create an AttributeSet from an AttrBuilder. The Attribute class is eventually going to represent one attribute. So we need this class to create the set of attributes. Add some iterator methods to the builder to access its internal bits in a nice way. llvm-svn: 171586
2013-01-05 09:36:54 +08:00
}
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
AttributeSet AttributeSet::get(LLVMContext &C, unsigned Index,
Convert BuildLibCalls.cpp to using the AttributeSet methods instead of AttributeWithIndex. llvm-svn: 173536
2013-01-26 08:03:11 +08:00
ArrayRef<Attribute::AttrKind> Kind) {
Try to appease some broken compilers by using 'unsigned' instead of 'uint64_t'. llvm-svn: 173725
2013-01-29 06:33:39 +08:00
SmallVector<std::pair<unsigned, Attribute>, 8> Attrs;
Minor cleanup of Attribute code. NFC. llvm-svn: 255751
2015-12-16 13:21:02 +08:00
for (Attribute::AttrKind K : Kind)
Attrs.push_back(std::make_pair(Index, Attribute::get(C, K)));
Remove the AttributeWithIndex class. The AttributeWithIndex class exposed the interior structure of the AttributeSet class. That was gross. Remove it and all of the code that relied upon it. llvm-svn: 173722
2013-01-29 05:55:20 +08:00
return get(C, Attrs);
Remove the last of uses that use the Attribute object as a collection of attributes. Collections of attributes are handled via the AttributeSet class now. This finally frees us up to make significant changes to how attributes are structured. llvm-svn: 173228
2013-01-23 14:14:59 +08:00
}
Remove some introspection functions. The 'getSlot' function and its ilk allow introspection into the AttributeSet class. However, that class should be opaque. Allow access through accessor methods instead. llvm-svn: 173522
2013-01-26 07:09:36 +08:00
AttributeSet AttributeSet::get(LLVMContext &C, ArrayRef<AttributeSet> Attrs) {
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
if (Attrs.empty()) return AttributeSet();
Make one of the AttributeSet ctors maintain the invariant that the attribute list is ordered by index. Differential Revision: http://llvm-reviews.chandlerc.com/D1265 llvm-svn: 187682
2013-08-03 06:29:40 +08:00
if (Attrs.size() == 1) return Attrs[0];
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
Try to appease some broken compilers by using 'unsigned' instead of 'uint64_t'. llvm-svn: 173725
2013-01-29 06:33:39 +08:00
SmallVector<std::pair<unsigned, AttributeSetNode*>, 8> AttrNodeVec;
Make one of the AttributeSet ctors maintain the invariant that the attribute list is ordered by index. Differential Revision: http://llvm-reviews.chandlerc.com/D1265 llvm-svn: 187682
2013-08-03 06:29:40 +08:00
AttributeSetImpl *A0 = Attrs[0].pImpl;
if (A0)
AttrNodeVec.append(A0->getNode(0), A0->getNode(A0->getNumAttributes()));
// Copy all attributes from Attrs into AttrNodeVec while keeping AttrNodeVec
// ordered by index. Because we know that each list in Attrs is ordered by
// index we only need to merge each successive list in rather than doing a
// full sort.
for (unsigned I = 1, E = Attrs.size(); I != E; ++I) {
Reduce the number of indirections in the attributes implementation. - Coallocate entires for AttributeSetImpls and Nodes after the class itself. - Remove mutable iterators from immutable classes. - Remove unused context field from AttributeImpl. - Derive Enum/Align/String attribute implementations from AttributeImpl instead of having a whole new inheritance tree for them. - Derive AlignAttributeImpl from EnumAttributeImpl. llvm-svn: 186075
2013-07-11 20:13:16 +08:00
AttributeSetImpl *AS = Attrs[I].pImpl;
if (!AS) continue;
Make one of the AttributeSet ctors maintain the invariant that the attribute list is ordered by index. Differential Revision: http://llvm-reviews.chandlerc.com/D1265 llvm-svn: 187682
2013-08-03 06:29:40 +08:00
SmallVector<std::pair<unsigned, AttributeSetNode *>, 8>::iterator
ANVI = AttrNodeVec.begin(), ANVE;
Add a TrailingObjects template class. This is intended to help support the idiom of a class that has some other objects (or multiple arrays of different types of objects) appended on the end, which is used quite heavily in clang. Differential Revision: http://reviews.llvm.org/D11272 llvm-svn: 244164
2015-08-06 06:57:34 +08:00
for (const IndexAttrPair *AI = AS->getNode(0),
*AE = AS->getNode(AS->getNumAttributes());
Make one of the AttributeSet ctors maintain the invariant that the attribute list is ordered by index. Differential Revision: http://llvm-reviews.chandlerc.com/D1265 llvm-svn: 187682
2013-08-03 06:29:40 +08:00
AI != AE; ++AI) {
ANVE = AttrNodeVec.end();
while (ANVI != ANVE && ANVI->first <= AI->first)
++ANVI;
ANVI = AttrNodeVec.insert(ANVI, *AI) + 1;
}
Remove some introspection functions. The 'getSlot' function and its ilk allow introspection into the AttributeSet class. However, that class should be opaque. Allow access through accessor methods instead. llvm-svn: 173522
2013-01-26 07:09:36 +08:00
}
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
return getImpl(C, AttrNodeVec);
Split param attr implementation out from Function.cpp into its own file. Don't #include ParameterAttributes.h into any major public header files: just move methods out of line as appropriate. llvm-svn: 45517
2008-01-03 07:42:30 +08:00
}
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
AttributeSet AttributeSet::addAttribute(LLVMContext &C, unsigned Index,
More encapsulation work. Use the AttributeSet when we're talking about more than one attribute. Add a function that adds a single attribute. No functionality change intended. llvm-svn: 173196
2013-01-23 05:15:51 +08:00
Attribute::AttrKind Attr) const {
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
if (hasAttribute(Index, Attr)) return *this;
return addAttributes(C, Index, AttributeSet::get(C, Index, Attr));
More encapsulation work. Use the AttributeSet when we're talking about more than one attribute. Add a function that adds a single attribute. No functionality change intended. llvm-svn: 173196
2013-01-23 05:15:51 +08:00
}
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
AttributeSet AttributeSet::addAttribute(LLVMContext &C, unsigned Index,
Add some additonal attribute helper functions. Test will be on follow up putback to clang for mips16. llvm-svn: 176968
2013-03-14 04:20:08 +08:00
StringRef Kind) const {
llvm::AttrBuilder B;
B.addAttribute(Kind);
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
return addAttributes(C, Index, AttributeSet::get(C, Index, B));
Add some additonal attribute helper functions. Test will be on follow up putback to clang for mips16. llvm-svn: 176968
2013-03-14 04:20:08 +08:00
}
Add a way to add a kind-value string pair to an attribute. llvm-svn: 187138
2013-07-26 02:34:24 +08:00
AttributeSet AttributeSet::addAttribute(LLVMContext &C, unsigned Index,
StringRef Kind, StringRef Value) const {
llvm::AttrBuilder B;
B.addAttribute(Kind, Value);
return addAttributes(C, Index, AttributeSet::get(C, Index, B));
}
[AttributeSet] Overload AttributeSet::addAttribute to reduce compile time. The new overloaded function is used when an attribute is added to a large number of slots of an AttributeSet (for example, to function parameters). This is much faster than calling AttributeSet::addAttribute once per slot, because AttributeSet::getImpl (which calls FoldingSet::FIndNodeOrInsertPos) is called only once per function instead of once per slot. With this commit, clang compiles a file which used to take over 22 minutes in just 13 seconds. rdar://problem/23581000 Differential Revision: http://reviews.llvm.org/D15085 llvm-svn: 254491
2015-12-02 14:58:49 +08:00
AttributeSet AttributeSet::addAttribute(LLVMContext &C,
ArrayRef<unsigned> Indices,
Attribute A) const {
unsigned I = 0, E = pImpl ? pImpl->getNumAttributes() : 0;
auto IdxI = Indices.begin(), IdxE = Indices.end();
SmallVector<AttributeSet, 4> AttrSet;
while (I != E && IdxI != IdxE) {
if (getSlotIndex(I) < *IdxI)
AttrSet.emplace_back(getSlotAttributes(I++));
else if (getSlotIndex(I) > *IdxI)
AttrSet.emplace_back(AttributeSet::get(C, std::make_pair(*IdxI++, A)));
else {
AttrBuilder B(getSlotAttributes(I), *IdxI);
B.addAttribute(A);
AttrSet.emplace_back(AttributeSet::get(C, *IdxI, B));
++I;
++IdxI;
}
}
while (I != E)
AttrSet.emplace_back(getSlotAttributes(I++));
while (IdxI != IdxE)
AttrSet.emplace_back(AttributeSet::get(C, std::make_pair(*IdxI++, A)));
return get(C, AttrSet);
}
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
AttributeSet AttributeSet::addAttributes(LLVMContext &C, unsigned Index,
Add a new method that adds the AttributeSet at the given index. No functional change. llvm-svn: 173109
2013-01-22 08:53:12 +08:00
AttributeSet Attrs) const {
Rewrite the addAttr() method. This now uses the AttributeSet object instead of the Attribute / AttributeWithIndex objects. It's fairly simple now. It goes through all of the subsets before the one we're modifying, adds them to the new set. It then adds the modified subset. And then adds the rest of the subsets. llvm-svn: 173659
2013-01-28 13:23:28 +08:00
if (!pImpl) return Attrs;
if (!Attrs.pImpl) return *this;
Add Alignment field to ParameterAttributes and treat more or less rationally in interface functions, subject to change. No functional change. llvm-svn: 47352
2008-02-20 07:51:49 +08:00
#ifndef NDEBUG
Rewrite the addAttr() method. This now uses the AttributeSet object instead of the Attribute / AttributeWithIndex objects. It's fairly simple now. It goes through all of the subsets before the one we're modifying, adds them to the new set. It then adds the modified subset. And then adds the rest of the subsets. llvm-svn: 173659
2013-01-28 13:23:28 +08:00
// FIXME it is not obvious how this should work for alignment. For now, say
// we can't change a known alignment.
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
unsigned OldAlign = getParamAlignment(Index);
unsigned NewAlign = Attrs.getParamAlignment(Index);
Fix newly-introduced 4.3 warnings llvm-svn: 47375
2008-02-20 20:07:57 +08:00
assert((!OldAlign || !NewAlign || OldAlign == NewAlign) &&
Add Alignment field to ParameterAttributes and treat more or less rationally in interface functions, subject to change. No functional change. llvm-svn: 47352
2008-02-20 07:51:49 +08:00
"Attempt to change alignment!");
#endif
Cleanup whitespace. llvm-svn: 166013
2012-10-16 14:01:44 +08:00
Rewrite the addAttr() method. This now uses the AttributeSet object instead of the Attribute / AttributeWithIndex objects. It's fairly simple now. It goes through all of the subsets before the one we're modifying, adds them to the new set. It then adds the modified subset. And then adds the rest of the subsets. llvm-svn: 173659
2013-01-28 13:23:28 +08:00
// Add the attribute slots before the one we're trying to add.
SmallVector<AttributeSet, 4> AttrSet;
uint64_t NumAttrs = pImpl->getNumAttributes();
AttributeSet AS;
uint64_t LastIndex = 0;
for (unsigned I = 0, E = NumAttrs; I != E; ++I) {
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
if (getSlotIndex(I) >= Index) {
if (getSlotIndex(I) == Index) AS = getSlotAttributes(LastIndex++);
Rewrite the addAttr() method. This now uses the AttributeSet object instead of the Attribute / AttributeWithIndex objects. It's fairly simple now. It goes through all of the subsets before the one we're modifying, adds them to the new set. It then adds the modified subset. And then adds the rest of the subsets. llvm-svn: 173659
2013-01-28 13:23:28 +08:00
break;
Reimplement the parameter attributes support, phase #1. hilights: 1. There is now a "PAListPtr" class, which is a smart pointer around the underlying uniqued parameter attribute list object, and manages its refcount. It is now impossible to mess up the refcount. 2. PAListPtr is now the main interface to the underlying object, and the underlying object is now completely opaque. 3. Implementation details like SmallVector and FoldingSet are now no longer part of the interface. 4. You can create a PAListPtr with an arbitrary sequence of ParamAttrsWithIndex's, no need to make a SmallVector of a specific size (you can just use an array or scalar or vector if you wish). 5. All the client code that had to check for a null pointer before dereferencing the pointer is simplified to just access the PAListPtr directly. 6. The interfaces for adding attrs to a list and removing them is a bit simpler. Phase #2 will rename some stuff (e.g. PAListPtr) and do other less invasive changes. llvm-svn: 48289
2008-03-13 01:45:29 +08:00
}
Rewrite the addAttr() method. This now uses the AttributeSet object instead of the Attribute / AttributeWithIndex objects. It's fairly simple now. It goes through all of the subsets before the one we're modifying, adds them to the new set. It then adds the modified subset. And then adds the rest of the subsets. llvm-svn: 173659
2013-01-28 13:23:28 +08:00
LastIndex = I + 1;
AttrSet.push_back(getSlotAttributes(I));
}
Cleanup whitespace. llvm-svn: 166013
2012-10-16 14:01:44 +08:00
Rewrite the addAttr() method. This now uses the AttributeSet object instead of the Attribute / AttributeWithIndex objects. It's fairly simple now. It goes through all of the subsets before the one we're modifying, adds them to the new set. It then adds the modified subset. And then adds the rest of the subsets. llvm-svn: 173659
2013-01-28 13:23:28 +08:00
// Now add the attribute into the correct slot. There may already be an
// AttributeSet there.
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
AttrBuilder B(AS, Index);
Cleanup whitespace. llvm-svn: 166013
2012-10-16 14:01:44 +08:00
Rewrite the addAttr() method. This now uses the AttributeSet object instead of the Attribute / AttributeWithIndex objects. It's fairly simple now. It goes through all of the subsets before the one we're modifying, adds them to the new set. It then adds the modified subset. And then adds the rest of the subsets. llvm-svn: 173659
2013-01-28 13:23:28 +08:00
for (unsigned I = 0, E = Attrs.pImpl->getNumAttributes(); I != E; ++I)
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
if (Attrs.getSlotIndex(I) == Index) {
Reduce the number of indirections in the attributes implementation. - Coallocate entires for AttributeSetImpls and Nodes after the class itself. - Remove mutable iterators from immutable classes. - Remove unused context field from AttributeImpl. - Derive Enum/Align/String attribute implementations from AttributeImpl instead of having a whole new inheritance tree for them. - Derive AlignAttributeImpl from EnumAttributeImpl. llvm-svn: 186075
2013-07-11 20:13:16 +08:00
for (AttributeSetImpl::iterator II = Attrs.pImpl->begin(I),
Rewrite the addAttr() method. This now uses the AttributeSet object instead of the Attribute / AttributeWithIndex objects. It's fairly simple now. It goes through all of the subsets before the one we're modifying, adds them to the new set. It then adds the modified subset. And then adds the rest of the subsets. llvm-svn: 173659
2013-01-28 13:23:28 +08:00
IE = Attrs.pImpl->end(I); II != IE; ++II)
s/AttrBuilder::addAttributes/AttrBuilder::addAttribute/g because that's more descriptive of what it actually is. llvm-svn: 174116
2013-02-01 07:38:01 +08:00
B.addAttribute(*II);
Rewrite the addAttr() method. This now uses the AttributeSet object instead of the Attribute / AttributeWithIndex objects. It's fairly simple now. It goes through all of the subsets before the one we're modifying, adds them to the new set. It then adds the modified subset. And then adds the rest of the subsets. llvm-svn: 173659
2013-01-28 13:23:28 +08:00
break;
}
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
AttrSet.push_back(AttributeSet::get(C, Index, B));
Rewrite the addAttr() method. This now uses the AttributeSet object instead of the Attribute / AttributeWithIndex objects. It's fairly simple now. It goes through all of the subsets before the one we're modifying, adds them to the new set. It then adds the modified subset. And then adds the rest of the subsets. llvm-svn: 173659
2013-01-28 13:23:28 +08:00
// Add the remaining attribute slots.
for (unsigned I = LastIndex, E = NumAttrs; I < E; ++I)
AttrSet.push_back(getSlotAttributes(I));
Cleanup whitespace. llvm-svn: 166013
2012-10-16 14:01:44 +08:00
Rewrite the addAttr() method. This now uses the AttributeSet object instead of the Attribute / AttributeWithIndex objects. It's fairly simple now. It goes through all of the subsets before the one we're modifying, adds them to the new set. It then adds the modified subset. And then adds the rest of the subsets. llvm-svn: 173659
2013-01-28 13:23:28 +08:00
return get(C, AttrSet);
Split param attr implementation out from Function.cpp into its own file. Don't #include ParameterAttributes.h into any major public header files: just move methods out of line as appropriate. llvm-svn: 45517
2008-01-03 07:42:30 +08:00
}
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
AttributeSet AttributeSet::removeAttribute(LLVMContext &C, unsigned Index,
Use the AttributeSet when removing multiple attributes. Use Attribute::AttrKind when removing one attribute. This further encapsulates the use of the attributes. llvm-svn: 173214
2013-01-23 08:45:55 +08:00
Attribute::AttrKind Attr) const {
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
if (!hasAttribute(Index, Attr)) return *this;
return removeAttributes(C, Index, AttributeSet::get(C, Index, Attr));
Use the AttributeSet when removing multiple attributes. Use Attribute::AttrKind when removing one attribute. This further encapsulates the use of the attributes. llvm-svn: 173214
2013-01-23 08:45:55 +08:00
}
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
AttributeSet AttributeSet::removeAttributes(LLVMContext &C, unsigned Index,
Use the AttributeSet when removing multiple attributes. Use Attribute::AttrKind when removing one attribute. This further encapsulates the use of the attributes. llvm-svn: 173214
2013-01-23 08:45:55 +08:00
AttributeSet Attrs) const {
Rewrite the removeAttr() method. This now uses the AttributeSet object instead of the Attribute / AttributeWithIndex objects. It's fairly simple now. It goes through all of the subsets before the one we're modifying, adds them to the new set. It then adds the modified subset (with the requested attributes removed). And then adds the rest of the subsets. llvm-svn: 173660
2013-01-28 13:44:14 +08:00
if (!pImpl) return AttributeSet();
if (!Attrs.pImpl) return *this;
Use the AttributeSet when removing multiple attributes. Use Attribute::AttrKind when removing one attribute. This further encapsulates the use of the attributes. llvm-svn: 173214
2013-01-23 08:45:55 +08:00
Revert "Change memcpy/memset/memmove to have dest and source alignments." This reverts commit r253511. This likely broke the bots in http://lab.llvm.org:8011/builders/clang-ppc64-elf-linux2/builds/20202 http://bb.pgr.jp/builders/clang-3stage-i686-linux/builds/3787 llvm-svn: 253543
2015-11-19 13:56:52 +08:00
// FIXME it is not obvious how this should work for alignment.
// For now, say we can't pass in alignment, which no current use does.
assert(!Attrs.hasAttribute(Index, Attribute::Alignment) &&
"Attempt to change alignment!");
Rewrite the removeAttr() method. This now uses the AttributeSet object instead of the Attribute / AttributeWithIndex objects. It's fairly simple now. It goes through all of the subsets before the one we're modifying, adds them to the new set. It then adds the modified subset (with the requested attributes removed). And then adds the rest of the subsets. llvm-svn: 173660
2013-01-28 13:44:14 +08:00
// Add the attribute slots before the one we're trying to add.
SmallVector<AttributeSet, 4> AttrSet;
uint64_t NumAttrs = pImpl->getNumAttributes();
AttributeSet AS;
uint64_t LastIndex = 0;
for (unsigned I = 0, E = NumAttrs; I != E; ++I) {
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
if (getSlotIndex(I) >= Index) {
if (getSlotIndex(I) == Index) AS = getSlotAttributes(LastIndex++);
Rewrite the removeAttr() method. This now uses the AttributeSet object instead of the Attribute / AttributeWithIndex objects. It's fairly simple now. It goes through all of the subsets before the one we're modifying, adds them to the new set. It then adds the modified subset (with the requested attributes removed). And then adds the rest of the subsets. llvm-svn: 173660
2013-01-28 13:44:14 +08:00
break;
}
LastIndex = I + 1;
AttrSet.push_back(getSlotAttributes(I));
}
Convert typeIncompatible to return an AttributeSet. There are still places which treat the Attribute object as a collection of attributes. I'm systematically removing them. llvm-svn: 173990
2013-01-31 07:07:40 +08:00
// Now remove the attribute from the correct slot. There may already be an
Rewrite the removeAttr() method. This now uses the AttributeSet object instead of the Attribute / AttributeWithIndex objects. It's fairly simple now. It goes through all of the subsets before the one we're modifying, adds them to the new set. It then adds the modified subset (with the requested attributes removed). And then adds the rest of the subsets. llvm-svn: 173660
2013-01-28 13:44:14 +08:00
// AttributeSet there.
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
AttrBuilder B(AS, Index);
Rewrite the removeAttr() method. This now uses the AttributeSet object instead of the Attribute / AttributeWithIndex objects. It's fairly simple now. It goes through all of the subsets before the one we're modifying, adds them to the new set. It then adds the modified subset (with the requested attributes removed). And then adds the rest of the subsets. llvm-svn: 173660
2013-01-28 13:44:14 +08:00
for (unsigned I = 0, E = Attrs.pImpl->getNumAttributes(); I != E; ++I)
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
if (Attrs.getSlotIndex(I) == Index) {
B.removeAttributes(Attrs.pImpl->getSlotAttributes(I), Index);
Rewrite the removeAttr() method. This now uses the AttributeSet object instead of the Attribute / AttributeWithIndex objects. It's fairly simple now. It goes through all of the subsets before the one we're modifying, adds them to the new set. It then adds the modified subset (with the requested attributes removed). And then adds the rest of the subsets. llvm-svn: 173660
2013-01-28 13:44:14 +08:00
break;
}
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
AttrSet.push_back(AttributeSet::get(C, Index, B));
Rewrite the removeAttr() method. This now uses the AttributeSet object instead of the Attribute / AttributeWithIndex objects. It's fairly simple now. It goes through all of the subsets before the one we're modifying, adds them to the new set. It then adds the modified subset (with the requested attributes removed). And then adds the rest of the subsets. llvm-svn: 173660
2013-01-28 13:44:14 +08:00
// Add the remaining attribute slots.
for (unsigned I = LastIndex, E = NumAttrs; I < E; ++I)
AttrSet.push_back(getSlotAttributes(I));
return get(C, AttrSet);
Split param attr implementation out from Function.cpp into its own file. Don't #include ParameterAttributes.h into any major public header files: just move methods out of line as appropriate. llvm-svn: 45517
2008-01-03 07:42:30 +08:00
}
Add remove method to operate on AttrBuilder instead of AttributeSet. Prior to this change we would have to construct a temporary AttributeSet (which isn't temporary at all given that its allocated on the context), just to contain the attributes in the builder, then call remove on that. Now we can just remove any attributes from the (lightweight and really temporary) builder itself. Will be used in a future commit to remove some temporary attributes sets. llvm-svn: 236666
2015-05-07 07:19:43 +08:00
AttributeSet AttributeSet::removeAttributes(LLVMContext &C, unsigned Index,
const AttrBuilder &Attrs) const {
if (!pImpl) return AttributeSet();
// FIXME it is not obvious how this should work for alignment.
// For now, say we can't pass in alignment, which no current use does.
assert(!Attrs.hasAlignmentAttr() && "Attempt to change alignment!");
// Add the attribute slots before the one we're trying to add.
SmallVector<AttributeSet, 4> AttrSet;
uint64_t NumAttrs = pImpl->getNumAttributes();
AttributeSet AS;
uint64_t LastIndex = 0;
for (unsigned I = 0, E = NumAttrs; I != E; ++I) {
if (getSlotIndex(I) >= Index) {
if (getSlotIndex(I) == Index) AS = getSlotAttributes(LastIndex++);
break;
}
LastIndex = I + 1;
AttrSet.push_back(getSlotAttributes(I));
}
// Now remove the attribute from the correct slot. There may already be an
// AttributeSet there.
AttrBuilder B(AS, Index);
B.remove(Attrs);
AttrSet.push_back(AttributeSet::get(C, Index, B));
// Add the remaining attribute slots.
for (unsigned I = LastIndex, E = NumAttrs; I < E; ++I)
AttrSet.push_back(getSlotAttributes(I));
return get(C, AttrSet);
}
InstCombine: propagate deref via new addDereferenceableAttr The "dereferenceable" attribute cannot be added via .addAttribute(), since it also expects a size in bytes. AttrBuilder#addAttribute or AttributeSet#addAttribute is wrapped by classes Function, InvokeInst, and CallInst. Add corresponding wrappers to AttrBuilder#addDereferenceableAttr. Having done this, propagate the dereferenceable attribute via gc.relocate, adding a test to exercise it. Note that -datalayout is required during execution over and above -instcombine, because InstCombine only optionally requires DataLayoutPass. Differential Revision: http://reviews.llvm.org/D7510 llvm-svn: 229265
2015-02-15 03:37:54 +08:00
AttributeSet AttributeSet::addDereferenceableAttr(LLVMContext &C, unsigned Index,
uint64_t Bytes) const {
llvm::AttrBuilder B;
B.addDereferenceableAttr(Bytes);
return addAttributes(C, Index, AttributeSet::get(C, Index, B));
}
[IR] Introduce a dereferenceable_or_null(N) attribute. Summary: If a pointer is marked as dereferenceable_or_null(N), LLVM assumes it is either `null` or `dereferenceable(N)` or both. This change only introduces the attribute and adds a token test case for the `llvm-as` / `llvm-dis`. It does not hook up other parts of the optimizer to actually exploit the attribute -- those changes will come later. For pointers in address space 0, `dereferenceable(N)` is now exactly equivalent to `dereferenceable_or_null(N)` && `nonnull`. For other address spaces, `dereferenceable(N)` is potentially weaker than `dereferenceable_or_null(N)` && `nonnull` (since we could have a null `dereferenceable(N)` pointer). The motivating case for this change is Java (and other managed languages), where pointers are either `null` or dereferenceable up to some usually known-at-compile-time constant offset. Reviewers: rafael, hfinkel Reviewed By: hfinkel Subscribers: nicholas, llvm-commits Differential Revision: http://reviews.llvm.org/D8650 llvm-svn: 235132
2015-04-17 04:29:50 +08:00
AttributeSet AttributeSet::addDereferenceableOrNullAttr(LLVMContext &C,
unsigned Index,
uint64_t Bytes) const {
llvm::AttrBuilder B;
B.addDereferenceableOrNullAttr(Bytes);
return addAttributes(C, Index, AttributeSet::get(C, Index, B));
}
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
//===----------------------------------------------------------------------===//
// AttributeSet Accessor Methods
//===----------------------------------------------------------------------===//
Add accessor for the LLVMContext. llvm-svn: 174824
2013-02-10 13:00:40 +08:00
LLVMContext &AttributeSet::getContext() const {
return pImpl->getContext();
}
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
AttributeSet AttributeSet::getParamAttributes(unsigned Index) const {
return pImpl && hasAttributes(Index) ?
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
AttributeSet::get(pImpl->getContext(),
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
ArrayRef<std::pair<unsigned, AttributeSetNode*> >(
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
std::make_pair(Index, getAttributes(Index)))) :
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
AttributeSet();
}
AttributeSet AttributeSet::getRetAttributes() const {
return pImpl && hasAttributes(ReturnIndex) ?
AttributeSet::get(pImpl->getContext(),
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
ArrayRef<std::pair<unsigned, AttributeSetNode*> >(
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
std::make_pair(ReturnIndex,
getAttributes(ReturnIndex)))) :
AttributeSet();
}
AttributeSet AttributeSet::getFnAttributes() const {
return pImpl && hasAttributes(FunctionIndex) ?
AttributeSet::get(pImpl->getContext(),
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
ArrayRef<std::pair<unsigned, AttributeSetNode*> >(
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
std::make_pair(FunctionIndex,
getAttributes(FunctionIndex)))) :
AttributeSet();
}
bool AttributeSet::hasAttribute(unsigned Index, Attribute::AttrKind Kind) const{
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
AttributeSetNode *ASN = getAttributes(Index);
Minor cleanup of Attribute code. NFC. llvm-svn: 255751
2015-12-16 13:21:02 +08:00
return ASN && ASN->hasAttribute(Kind);
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
}
Add some accessor and query methods for retrieving Attribute objects and such. llvm-svn: 175046
2013-02-13 16:42:21 +08:00
bool AttributeSet::hasAttribute(unsigned Index, StringRef Kind) const {
AttributeSetNode *ASN = getAttributes(Index);
Minor cleanup of Attribute code. NFC. llvm-svn: 255751
2015-12-16 13:21:02 +08:00
return ASN && ASN->hasAttribute(Kind);
Add some accessor and query methods for retrieving Attribute objects and such. llvm-svn: 175046
2013-02-13 16:42:21 +08:00
}
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
bool AttributeSet::hasAttributes(unsigned Index) const {
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
AttributeSetNode *ASN = getAttributes(Index);
Minor cleanup of Attribute code. NFC. llvm-svn: 255751
2015-12-16 13:21:02 +08:00
return ASN && ASN->hasAttributes();
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
}
AttributeSetImpl: Summarize existing function attributes in a bitset. The majority of attribute queries checks for the existence of an enum attribute in the FunctionIndex slot. We only have 48 of those and can therefore summarize them in an uint64_t bitset which measurably improves compile time. Differential Revision: http://reviews.llvm.org/D16618 llvm-svn: 259252
2016-01-30 06:25:19 +08:00
bool AttributeSet::hasFnAttribute(Attribute::AttrKind Kind) const {
return pImpl && pImpl->hasFnAttribute(Kind);
}
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
bool AttributeSet::hasAttrSomewhere(Attribute::AttrKind Attr) const {
[C++11] More 'nullptr' conversion or in some cases just using a boolean check instead of comparing to nullptr. llvm-svn: 205831
2014-04-09 14:08:46 +08:00
if (!pImpl) return false;
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
for (unsigned I = 0, E = pImpl->getNumAttributes(); I != E; ++I)
Reduce the number of indirections in the attributes implementation. - Coallocate entires for AttributeSetImpls and Nodes after the class itself. - Remove mutable iterators from immutable classes. - Remove unused context field from AttributeImpl. - Derive Enum/Align/String attribute implementations from AttributeImpl instead of having a whole new inheritance tree for them. - Derive AlignAttributeImpl from EnumAttributeImpl. llvm-svn: 186075
2013-07-11 20:13:16 +08:00
for (AttributeSetImpl::iterator II = pImpl->begin(I),
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
IE = pImpl->end(I); II != IE; ++II)
Revert r174026, "Remove Attribute::hasAttributes() and make Attribute::hasAttribute() private." It broke many hosts to crash. llvm-svn: 174035
2013-01-31 11:47:28 +08:00
if (II->hasAttribute(Attr))
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
return true;
return false;
}
Add some accessor and query methods for retrieving Attribute objects and such. llvm-svn: 175046
2013-02-13 16:42:21 +08:00
Attribute AttributeSet::getAttribute(unsigned Index,
Attribute::AttrKind Kind) const {
AttributeSetNode *ASN = getAttributes(Index);
return ASN ? ASN->getAttribute(Kind) : Attribute();
}
Attribute AttributeSet::getAttribute(unsigned Index,
StringRef Kind) const {
AttributeSetNode *ASN = getAttributes(Index);
return ASN ? ASN->getAttribute(Kind) : Attribute();
}
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
unsigned AttributeSet::getParamAlignment(unsigned Index) const {
AttributeSetNode *ASN = getAttributes(Index);
return ASN ? ASN->getAlignment() : 0;
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
}
unsigned AttributeSet::getStackAlignment(unsigned Index) const {
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
AttributeSetNode *ASN = getAttributes(Index);
return ASN ? ASN->getStackAlignment() : 0;
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
}
Add a dereferenceable attribute This attribute indicates that the parameter or return pointer is dereferenceable. Practically speaking, loads from such a pointer within the associated byte range are safe to speculatively execute. Such pointer parameters are common in source languages (C++ references, for example). llvm-svn: 213385
2014-07-18 23:51:28 +08:00
uint64_t AttributeSet::getDereferenceableBytes(unsigned Index) const {
AttributeSetNode *ASN = getAttributes(Index);
return ASN ? ASN->getDereferenceableBytes() : 0;
}
Add missing dereferenceable_or_null getters Summary: Add missing dereferenceable_or_null getters required for http://reviews.llvm.org/D9253 change. Separated from the D9253 review. Patch by Artur Pilipenko! Reviewers: sanjoy Reviewed By: sanjoy Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D9499 llvm-svn: 236615
2015-05-07 01:41:54 +08:00
uint64_t AttributeSet::getDereferenceableOrNullBytes(unsigned Index) const {
AttributeSetNode *ASN = getAttributes(Index);
return ASN ? ASN->getDereferenceableOrNullBytes() : 0;
}
Now that the underlying issue is fixed, revert r180750 and r180722. The cause of the windows failures was fixed by r180791. Revert to the state after Sabre's original revert. Original message: revert r179735, it has no testcases, and doesn't really make sense. llvm-svn: 180844
2013-05-01 21:07:03 +08:00
std::string AttributeSet::getAsString(unsigned Index,
Add support for printing out the attribute groups. This emits the attribute groups that are used by the functions. (It currently doesn't print out return type or parameter attributes within attribute groups.) Note: The functions still retrieve their attributes from the "old" bitcode format (using the deprecated 'Raw()' method). This means that string attributes within an attribute group will not show up during a disassembly. This will be addressed in a future commit. llvm-svn: 174867
2013-02-11 16:43:33 +08:00
bool InAttrGrp) const {
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
AttributeSetNode *ASN = getAttributes(Index);
Now that the underlying issue is fixed, revert r180750 and r180722. The cause of the windows failures was fixed by r180791. Revert to the state after Sabre's original revert. Original message: revert r179735, it has no testcases, and doesn't really make sense. llvm-svn: 180844
2013-05-01 21:07:03 +08:00
return ASN ? ASN->getAsString(InAttrGrp) : std::string("");
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
}
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
AttributeSetNode *AttributeSet::getAttributes(unsigned Index) const {
[C++11] More 'nullptr' conversion or in some cases just using a boolean check instead of comparing to nullptr. llvm-svn: 205831
2014-04-09 14:08:46 +08:00
if (!pImpl) return nullptr;
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
// Loop through to find the attribute node we want.
for (unsigned I = 0, E = pImpl->getNumAttributes(); I != E; ++I)
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
if (pImpl->getSlotIndex(I) == Index)
Convert getAttributes() to return an AttributeSetNode. The AttributeSetNode contains all of the attributes. This removes one (hopefully last) use of the Attribute class as a container of multiple attributes. llvm-svn: 173761
2013-01-29 11:20:31 +08:00
return pImpl->getSlotNode(I);
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
[C++11] More 'nullptr' conversion or in some cases just using a boolean check instead of comparing to nullptr. llvm-svn: 205831
2014-04-09 14:08:46 +08:00
return nullptr;
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
}
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
AttributeSet::iterator AttributeSet::begin(unsigned Slot) const {
Add iterators to the AttributeSet class so that we can access the Attributes in a nice way. llvm-svn: 174120
2013-02-01 07:53:05 +08:00
if (!pImpl)
return ArrayRef<Attribute>().begin();
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
return pImpl->begin(Slot);
Add iterators to the AttributeSet class so that we can access the Attributes in a nice way. llvm-svn: 174120
2013-02-01 07:53:05 +08:00
}
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
AttributeSet::iterator AttributeSet::end(unsigned Slot) const {
Add iterators to the AttributeSet class so that we can access the Attributes in a nice way. llvm-svn: 174120
2013-02-01 07:53:05 +08:00
if (!pImpl)
return ArrayRef<Attribute>().end();
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
return pImpl->end(Slot);
Add iterators to the AttributeSet class so that we can access the Attributes in a nice way. llvm-svn: 174120
2013-02-01 07:53:05 +08:00
}
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
//===----------------------------------------------------------------------===//
// AttributeSet Introspection Methods
//===----------------------------------------------------------------------===//
unsigned AttributeSet::getNumSlots() const {
return pImpl ? pImpl->getNumAttributes() : 0;
}
Change getSlotIndex to return unsigned. The actual storage was already using unsigned, but the interface was using uint64_t. This is wasteful on 32 bits and looks to be the root causes of a miscompilation on Windows where a value was being sign extended to 64bits to compare with the result of getSlotIndex. Patch by Pasi Parviainen! llvm-svn: 180791
2013-05-01 00:53:38 +08:00
unsigned AttributeSet::getSlotIndex(unsigned Slot) const {
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
assert(pImpl && Slot < pImpl->getNumAttributes() &&
"Slot # out of range!");
return pImpl->getSlotIndex(Slot);
}
AttributeSet AttributeSet::getSlotAttributes(unsigned Slot) const {
assert(pImpl && Slot < pImpl->getNumAttributes() &&
"Slot # out of range!");
return pImpl->getSlotAttributes(Slot);
}
uint64_t AttributeSet::Raw(unsigned Index) const {
// FIXME: Remove this.
return pImpl ? pImpl->Raw(Index) : 0;
}
Annotate dump() methods with LLVM_DUMP_METHOD, addressing Richard Smith r259192 post commit comment. clang part in r259232, this is the LLVM part of the patch. llvm-svn: 259240
2016-01-30 04:50:44 +08:00
LLVM_DUMP_METHOD void AttributeSet::dump() const {
Remove a use of AttributeWithIndex. We want to remove AttributeWithIndex because it provides a non-encapsulated view of the AttributeSetImpl object. Instead, use accessor methods and iterators. Eventually, this code can be simplified because the Attribute object will hold only one attribute instead of multiple attributes. llvm-svn: 173641
2013-01-28 08:21:34 +08:00
dbgs() << "PAL[\n";
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
Remove a use of AttributeWithIndex. We want to remove AttributeWithIndex because it provides a non-encapsulated view of the AttributeSetImpl object. Instead, use accessor methods and iterators. Eventually, this code can be simplified because the Attribute object will hold only one attribute instead of multiple attributes. llvm-svn: 173641
2013-01-28 08:21:34 +08:00
for (unsigned i = 0, e = getNumSlots(); i < e; ++i) {
Improve the debug output a bit. llvm-svn: 173640
2013-01-28 07:53:56 +08:00
uint64_t Index = getSlotIndex(i);
dbgs() << " { ";
if (Index == ~0U)
dbgs() << "~0U";
else
dbgs() << Index;
dbgs() << " => " << getAsString(Index) << " }\n";
Reimplement the parameter attributes support, phase #1. hilights: 1. There is now a "PAListPtr" class, which is a smart pointer around the underlying uniqued parameter attribute list object, and manages its refcount. It is now impossible to mess up the refcount. 2. PAListPtr is now the main interface to the underlying object, and the underlying object is now completely opaque. 3. Implementation details like SmallVector and FoldingSet are now no longer part of the interface. 4. You can create a PAListPtr with an arbitrary sequence of ParamAttrsWithIndex's, no need to make a SmallVector of a specific size (you can just use an array or scalar or vector if you wish). 5. All the client code that had to check for a null pointer before dereferencing the pointer is simplified to just access the PAListPtr directly. 6. The interfaces for adding attrs to a list and removing them is a bit simpler. Phase #2 will rename some stuff (e.g. PAListPtr) and do other less invasive changes. llvm-svn: 48289
2008-03-13 01:45:29 +08:00
}
Cleanup whitespace. llvm-svn: 166013
2012-10-16 14:01:44 +08:00
Change errs() to dbgs(). llvm-svn: 92658
2010-01-05 09:29:58 +08:00
dbgs() << "]\n";
The transform that tries to turn calls to bitcast functions into direct calls bails out unless caller and callee have essentially equivalent parameter attributes. This is illogical - the callee's attributes should be of no relevance here. Rework the logic, which incidentally fixes a crash when removed arguments have attributes. llvm-svn: 45658
2008-01-07 02:27:01 +08:00
}
Remove some introspection functions. The 'getSlot' function and its ilk allow introspection into the AttributeSet class. However, that class should be opaque. Allow access through accessor methods instead. llvm-svn: 173522
2013-01-26 07:09:36 +08:00
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
//===----------------------------------------------------------------------===//
// AttrBuilder Method Implementations
//===----------------------------------------------------------------------===//
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
AttrBuilder::AttrBuilder(AttributeSet AS, unsigned Index)
[IR] Introduce a dereferenceable_or_null(N) attribute. Summary: If a pointer is marked as dereferenceable_or_null(N), LLVM assumes it is either `null` or `dereferenceable(N)` or both. This change only introduces the attribute and adds a token test case for the `llvm-as` / `llvm-dis`. It does not hook up other parts of the optimizer to actually exploit the attribute -- those changes will come later. For pointers in address space 0, `dereferenceable(N)` is now exactly equivalent to `dereferenceable_or_null(N)` && `nonnull`. For other address spaces, `dereferenceable(N)` is potentially weaker than `dereferenceable_or_null(N)` && `nonnull` (since we could have a null `dereferenceable(N)` pointer). The motivating case for this change is Java (and other managed languages), where pointers are either `null` or dereferenceable up to some usually known-at-compile-time constant offset. Reviewers: rafael, hfinkel Reviewed By: hfinkel Subscribers: nicholas, llvm-commits Differential Revision: http://reviews.llvm.org/D8650 llvm-svn: 235132
2015-04-17 04:29:50 +08:00
: Attrs(0), Alignment(0), StackAlignment(0), DerefBytes(0),
DerefOrNullBytes(0) {
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
AttributeSetImpl *pImpl = AS.pImpl;
if (!pImpl) return;
for (unsigned I = 0, E = pImpl->getNumAttributes(); I != E; ++I) {
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
if (pImpl->getSlotIndex(I) != Index) continue;
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
Reduce the number of indirections in the attributes implementation. - Coallocate entires for AttributeSetImpls and Nodes after the class itself. - Remove mutable iterators from immutable classes. - Remove unused context field from AttributeImpl. - Derive Enum/Align/String attribute implementations from AttributeImpl instead of having a whole new inheritance tree for them. - Derive AlignAttributeImpl from EnumAttributeImpl. llvm-svn: 186075
2013-07-11 20:13:16 +08:00
for (AttributeSetImpl::iterator II = pImpl->begin(I),
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
IE = pImpl->end(I); II != IE; ++II)
s/AttrBuilder::addAttributes/AttrBuilder::addAttribute/g because that's more descriptive of what it actually is. llvm-svn: 174116
2013-02-01 07:38:01 +08:00
addAttribute(*II);
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
break;
}
}
void AttrBuilder::clear() {
Futureproof AttrBuild if we ever have more than 64 attr enum values. Currently we're at 34. Bitset should compile into virtually the same code as uint64_t here. llvm-svn: 175437
2013-02-18 20:09:51 +08:00
Attrs.reset();
[IR] Have AttrBuilder::clear clear `TargetDepAttrs`. Test case attached -- currently the parser smears the "foo bar" to all of the formal arguments. llvm-svn: 246812
2015-09-04 06:27:42 +08:00
TargetDepAttrs.clear();
[IR] Introduce a dereferenceable_or_null(N) attribute. Summary: If a pointer is marked as dereferenceable_or_null(N), LLVM assumes it is either `null` or `dereferenceable(N)` or both. This change only introduces the attribute and adds a token test case for the `llvm-as` / `llvm-dis`. It does not hook up other parts of the optimizer to actually exploit the attribute -- those changes will come later. For pointers in address space 0, `dereferenceable(N)` is now exactly equivalent to `dereferenceable_or_null(N)` && `nonnull`. For other address spaces, `dereferenceable(N)` is potentially weaker than `dereferenceable_or_null(N)` && `nonnull` (since we could have a null `dereferenceable(N)` pointer). The motivating case for this change is Java (and other managed languages), where pointers are either `null` or dereferenceable up to some usually known-at-compile-time constant offset. Reviewers: rafael, hfinkel Reviewed By: hfinkel Subscribers: nicholas, llvm-commits Differential Revision: http://reviews.llvm.org/D8650 llvm-svn: 235132
2015-04-17 04:29:50 +08:00
Alignment = StackAlignment = DerefBytes = DerefOrNullBytes = 0;
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
}
AttrBuilder &AttrBuilder::addAttribute(Attribute::AttrKind Val) {
Futureproof AttrBuild if we ever have more than 64 attr enum values. Currently we're at 34. Bitset should compile into virtually the same code as uint64_t here. llvm-svn: 175437
2013-02-18 20:09:51 +08:00
assert((unsigned)Val < Attribute::EndAttrKinds && "Attribute out of range!");
Remove the AttrBuilder form of the Attribute::get creators. The AttrBuilder is for building a collection of attributes. The Attribute object holds only one attribute. So it's not really useful for the Attribute object to have a creator which takes an AttrBuilder. This has two fallouts: 1. The AttrBuilder no longer holds its internal attributes in a bit-mask form. 2. The attributes are now ordered alphabetically (hence why the tests have changed). llvm-svn: 174110
2013-02-01 07:16:25 +08:00
assert(Val != Attribute::Alignment && Val != Attribute::StackAlignment &&
Add a dereferenceable attribute This attribute indicates that the parameter or return pointer is dereferenceable. Practically speaking, loads from such a pointer within the associated byte range are safe to speculatively execute. Such pointer parameters are common in source languages (C++ references, for example). llvm-svn: 213385
2014-07-18 23:51:28 +08:00
Val != Attribute::Dereferenceable &&
"Adding integer attribute without adding a value!");
Futureproof AttrBuild if we ever have more than 64 attr enum values. Currently we're at 34. Bitset should compile into virtually the same code as uint64_t here. llvm-svn: 175437
2013-02-18 20:09:51 +08:00
Attrs[Val] = true;
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
return *this;
}
s/AttrBuilder::addAttributes/AttrBuilder::addAttribute/g because that's more descriptive of what it actually is. llvm-svn: 174116
2013-02-01 07:38:01 +08:00
AttrBuilder &AttrBuilder::addAttribute(Attribute Attr) {
Handle string attributes in the AttrBuilder. llvm-svn: 174834
2013-02-10 18:13:23 +08:00
if (Attr.isStringAttribute()) {
addAttribute(Attr.getKindAsString(), Attr.getValueAsString());
return *this;
}
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
Attribute::AttrKind Kind = Attr.getKindAsEnum();
Futureproof AttrBuild if we ever have more than 64 attr enum values. Currently we're at 34. Bitset should compile into virtually the same code as uint64_t here. llvm-svn: 175437
2013-02-18 20:09:51 +08:00
Attrs[Kind] = true;
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
if (Kind == Attribute::Alignment)
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
Alignment = Attr.getAlignment();
Convert to storing the attribute's internals as enums, integers, and strings. The stuff we're handing are all enums (Attribute::AttrKind), integers and strings. Don't convert them to Constants, which is an unnecessary step here. The rest of the changes are mostly mechanical. llvm-svn: 174456
2013-02-06 06:37:24 +08:00
else if (Kind == Attribute::StackAlignment)
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
StackAlignment = Attr.getStackAlignment();
Add a dereferenceable attribute This attribute indicates that the parameter or return pointer is dereferenceable. Practically speaking, loads from such a pointer within the associated byte range are safe to speculatively execute. Such pointer parameters are common in source languages (C++ references, for example). llvm-svn: 213385
2014-07-18 23:51:28 +08:00
else if (Kind == Attribute::Dereferenceable)
DerefBytes = Attr.getDereferenceableBytes();
[IR] Introduce a dereferenceable_or_null(N) attribute. Summary: If a pointer is marked as dereferenceable_or_null(N), LLVM assumes it is either `null` or `dereferenceable(N)` or both. This change only introduces the attribute and adds a token test case for the `llvm-as` / `llvm-dis`. It does not hook up other parts of the optimizer to actually exploit the attribute -- those changes will come later. For pointers in address space 0, `dereferenceable(N)` is now exactly equivalent to `dereferenceable_or_null(N)` && `nonnull`. For other address spaces, `dereferenceable(N)` is potentially weaker than `dereferenceable_or_null(N)` && `nonnull` (since we could have a null `dereferenceable(N)` pointer). The motivating case for this change is Java (and other managed languages), where pointers are either `null` or dereferenceable up to some usually known-at-compile-time constant offset. Reviewers: rafael, hfinkel Reviewed By: hfinkel Subscribers: nicholas, llvm-commits Differential Revision: http://reviews.llvm.org/D8650 llvm-svn: 235132
2015-04-17 04:29:50 +08:00
else if (Kind == Attribute::DereferenceableOrNull)
DerefOrNullBytes = Attr.getDereferenceableOrNullBytes();
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
return *this;
}
Add target-dependent versions of addAttribute/removeAttribute to AttrBuilder. llvm-svn: 174356
2013-02-05 16:09:32 +08:00
AttrBuilder &AttrBuilder::addAttribute(StringRef A, StringRef V) {
TargetDepAttrs[A] = V;
return *this;
}
s/AttrBuilder::addAttributes/AttrBuilder::addAttribute/g because that's more descriptive of what it actually is. llvm-svn: 174116
2013-02-01 07:38:01 +08:00
AttrBuilder &AttrBuilder::removeAttribute(Attribute::AttrKind Val) {
Futureproof AttrBuild if we ever have more than 64 attr enum values. Currently we're at 34. Bitset should compile into virtually the same code as uint64_t here. llvm-svn: 175437
2013-02-18 20:09:51 +08:00
assert((unsigned)Val < Attribute::EndAttrKinds && "Attribute out of range!");
Attrs[Val] = false;
s/AttrBuilder::addAttributes/AttrBuilder::addAttribute/g because that's more descriptive of what it actually is. llvm-svn: 174116
2013-02-01 07:38:01 +08:00
if (Val == Attribute::Alignment)
Alignment = 0;
else if (Val == Attribute::StackAlignment)
StackAlignment = 0;
Add a dereferenceable attribute This attribute indicates that the parameter or return pointer is dereferenceable. Practically speaking, loads from such a pointer within the associated byte range are safe to speculatively execute. Such pointer parameters are common in source languages (C++ references, for example). llvm-svn: 213385
2014-07-18 23:51:28 +08:00
else if (Val == Attribute::Dereferenceable)
DerefBytes = 0;
[IR] Introduce a dereferenceable_or_null(N) attribute. Summary: If a pointer is marked as dereferenceable_or_null(N), LLVM assumes it is either `null` or `dereferenceable(N)` or both. This change only introduces the attribute and adds a token test case for the `llvm-as` / `llvm-dis`. It does not hook up other parts of the optimizer to actually exploit the attribute -- those changes will come later. For pointers in address space 0, `dereferenceable(N)` is now exactly equivalent to `dereferenceable_or_null(N)` && `nonnull`. For other address spaces, `dereferenceable(N)` is potentially weaker than `dereferenceable_or_null(N)` && `nonnull` (since we could have a null `dereferenceable(N)` pointer). The motivating case for this change is Java (and other managed languages), where pointers are either `null` or dereferenceable up to some usually known-at-compile-time constant offset. Reviewers: rafael, hfinkel Reviewed By: hfinkel Subscribers: nicholas, llvm-commits Differential Revision: http://reviews.llvm.org/D8650 llvm-svn: 235132
2015-04-17 04:29:50 +08:00
else if (Val == Attribute::DereferenceableOrNull)
DerefOrNullBytes = 0;
s/AttrBuilder::addAttributes/AttrBuilder::addAttribute/g because that's more descriptive of what it actually is. llvm-svn: 174116
2013-02-01 07:38:01 +08:00
return *this;
}
Convert typeIncompatible to return an AttributeSet. There are still places which treat the Attribute object as a collection of attributes. I'm systematically removing them. llvm-svn: 173990
2013-01-31 07:07:40 +08:00
AttrBuilder &AttrBuilder::removeAttributes(AttributeSet A, uint64_t Index) {
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
unsigned Slot = ~0U;
Use iterators instead of relying upon a bitmask of attributes to remove attributes from an AttrBuilder. llvm-svn: 174123
2013-02-01 08:13:50 +08:00
for (unsigned I = 0, E = A.getNumSlots(); I != E; ++I)
if (A.getSlotIndex(I) == Index) {
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
Slot = I;
Use iterators instead of relying upon a bitmask of attributes to remove attributes from an AttrBuilder. llvm-svn: 174123
2013-02-01 08:13:50 +08:00
break;
}
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
assert(Slot != ~0U && "Couldn't find index in AttributeSet!");
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
for (AttributeSet::iterator I = A.begin(Slot), E = A.end(Slot); I != E; ++I) {
Support string attributes in the AttrBuilder. llvm-svn: 174948
2013-02-12 15:56:49 +08:00
Attribute Attr = *I;
Rename AlignAttribute to IntAttribute Currently the only kind of integer IR attributes that we have are alignment attributes, and so the attribute kind that takes an integer parameter is called AlignAttr, but that will change (we'll soon be adding a dereferenceable attribute that also takes an integer value). Accordingly, rename AlignAttribute to IntAttribute (class names, enums, etc.). No functionality change intended. llvm-svn: 213352
2014-07-18 14:51:55 +08:00
if (Attr.isEnumAttribute() || Attr.isIntAttribute()) {
Minor cleanup of Attribute code. NFC. llvm-svn: 255751
2015-12-16 13:21:02 +08:00
removeAttribute(Attr.getKindAsEnum());
Support string attributes in the AttrBuilder. llvm-svn: 174948
2013-02-12 15:56:49 +08:00
} else {
assert(Attr.isStringAttribute() && "Invalid attribute type!");
Minor cleanup of Attribute code. NFC. llvm-svn: 255751
2015-12-16 13:21:02 +08:00
removeAttribute(Attr.getKindAsString());
Support string attributes in the AttrBuilder. llvm-svn: 174948
2013-02-12 15:56:49 +08:00
}
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
}
return *this;
}
Add target-dependent versions of addAttribute/removeAttribute to AttrBuilder. llvm-svn: 174356
2013-02-05 16:09:32 +08:00
AttrBuilder &AttrBuilder::removeAttribute(StringRef A) {
std::map<std::string, std::string>::iterator I = TargetDepAttrs.find(A);
if (I != TargetDepAttrs.end())
TargetDepAttrs.erase(I);
return *this;
}
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
AttrBuilder &AttrBuilder::addAlignmentAttr(unsigned Align) {
if (Align == 0) return *this;
assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
assert(Align <= 0x40000000 && "Alignment too large.");
Futureproof AttrBuild if we ever have more than 64 attr enum values. Currently we're at 34. Bitset should compile into virtually the same code as uint64_t here. llvm-svn: 175437
2013-02-18 20:09:51 +08:00
Attrs[Attribute::Alignment] = true;
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
Alignment = Align;
return *this;
}
AttrBuilder &AttrBuilder::addStackAlignmentAttr(unsigned Align) {
// Default alignment, allow the target to define how to align it.
if (Align == 0) return *this;
assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
assert(Align <= 0x100 && "Alignment too large.");
Futureproof AttrBuild if we ever have more than 64 attr enum values. Currently we're at 34. Bitset should compile into virtually the same code as uint64_t here. llvm-svn: 175437
2013-02-18 20:09:51 +08:00
Attrs[Attribute::StackAlignment] = true;
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
StackAlignment = Align;
return *this;
}
Add a dereferenceable attribute This attribute indicates that the parameter or return pointer is dereferenceable. Practically speaking, loads from such a pointer within the associated byte range are safe to speculatively execute. Such pointer parameters are common in source languages (C++ references, for example). llvm-svn: 213385
2014-07-18 23:51:28 +08:00
AttrBuilder &AttrBuilder::addDereferenceableAttr(uint64_t Bytes) {
if (Bytes == 0) return *this;
Attrs[Attribute::Dereferenceable] = true;
DerefBytes = Bytes;
return *this;
}
[IR] Introduce a dereferenceable_or_null(N) attribute. Summary: If a pointer is marked as dereferenceable_or_null(N), LLVM assumes it is either `null` or `dereferenceable(N)` or both. This change only introduces the attribute and adds a token test case for the `llvm-as` / `llvm-dis`. It does not hook up other parts of the optimizer to actually exploit the attribute -- those changes will come later. For pointers in address space 0, `dereferenceable(N)` is now exactly equivalent to `dereferenceable_or_null(N)` && `nonnull`. For other address spaces, `dereferenceable(N)` is potentially weaker than `dereferenceable_or_null(N)` && `nonnull` (since we could have a null `dereferenceable(N)` pointer). The motivating case for this change is Java (and other managed languages), where pointers are either `null` or dereferenceable up to some usually known-at-compile-time constant offset. Reviewers: rafael, hfinkel Reviewed By: hfinkel Subscribers: nicholas, llvm-commits Differential Revision: http://reviews.llvm.org/D8650 llvm-svn: 235132
2015-04-17 04:29:50 +08:00
AttrBuilder &AttrBuilder::addDereferenceableOrNullAttr(uint64_t Bytes) {
if (Bytes == 0)
return *this;
Attrs[Attribute::DereferenceableOrNull] = true;
DerefOrNullBytes = Bytes;
return *this;
}
Add methods to merge an AttrBuilder into another builder. This is useful when parsing an object that references multiple attribute groups. N.B. If both builders have alignments specified, then they should match! llvm-svn: 174480
2013-02-06 09:16:00 +08:00
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;
Add a dereferenceable attribute This attribute indicates that the parameter or return pointer is dereferenceable. Practically speaking, loads from such a pointer within the associated byte range are safe to speculatively execute. Such pointer parameters are common in source languages (C++ references, for example). llvm-svn: 213385
2014-07-18 23:51:28 +08:00
if (!DerefBytes)
DerefBytes = B.DerefBytes;
Add remove method to operate on AttrBuilder instead of AttributeSet. Prior to this change we would have to construct a temporary AttributeSet (which isn't temporary at all given that its allocated on the context), just to contain the attributes in the builder, then call remove on that. Now we can just remove any attributes from the (lightweight and really temporary) builder itself. Will be used in a future commit to remove some temporary attributes sets. llvm-svn: 236666
2015-05-07 07:19:43 +08:00
if (!DerefOrNullBytes)
DerefOrNullBytes = B.DerefOrNullBytes;
Turn the enum attributes DenseSet in AttrBuilder into a set of bits. Avoids malloc and is a lot denser. We lose iteration over target independent attributes, but that's a strange interface anyways and didn't have any users outside of AttrBuilder. llvm-svn: 175370
2013-02-17 03:13:18 +08:00
Attrs |= B.Attrs;
Add methods to merge an AttrBuilder into another builder. This is useful when parsing an object that references multiple attribute groups. N.B. If both builders have alignments specified, then they should match! llvm-svn: 174480
2013-02-06 09:16:00 +08:00
Add remove method to operate on AttrBuilder instead of AttributeSet. Prior to this change we would have to construct a temporary AttributeSet (which isn't temporary at all given that its allocated on the context), just to contain the attributes in the builder, then call remove on that. Now we can just remove any attributes from the (lightweight and really temporary) builder itself. Will be used in a future commit to remove some temporary attributes sets. llvm-svn: 236666
2015-05-07 07:19:43 +08:00
for (auto I : B.td_attrs())
TargetDepAttrs[I.first] = I.second;
Add methods to merge an AttrBuilder into another builder. This is useful when parsing an object that references multiple attribute groups. N.B. If both builders have alignments specified, then they should match! llvm-svn: 174480
2013-02-06 09:16:00 +08:00
return *this;
}
Add remove method to operate on AttrBuilder instead of AttributeSet. Prior to this change we would have to construct a temporary AttributeSet (which isn't temporary at all given that its allocated on the context), just to contain the attributes in the builder, then call remove on that. Now we can just remove any attributes from the (lightweight and really temporary) builder itself. Will be used in a future commit to remove some temporary attributes sets. llvm-svn: 236666
2015-05-07 07:19:43 +08:00
AttrBuilder &AttrBuilder::remove(const AttrBuilder &B) {
// FIXME: What if both have alignments, but they don't match?!
if (B.Alignment)
Alignment = 0;
if (B.StackAlignment)
StackAlignment = 0;
if (B.DerefBytes)
DerefBytes = 0;
if (B.DerefOrNullBytes)
DerefOrNullBytes = 0;
Attrs &= ~B.Attrs;
for (auto I : B.td_attrs())
TargetDepAttrs.erase(I.first);
return *this;
}
bool AttrBuilder::overlaps(const AttrBuilder &B) const {
// First check if any of the target independent attributes overlap.
if ((Attrs & B.Attrs).any())
return true;
// Then check if any target dependent ones do.
for (auto I : td_attrs())
if (B.contains(I.first))
return true;
return false;
}
Add a 'StringRef' version of hasAttribute. Fix the 'operator==' and 'hasAttributes' queries to take into account target-dependent attributes. llvm-svn: 174481
2013-02-06 09:33:42 +08:00
bool AttrBuilder::contains(StringRef A) const {
return TargetDepAttrs.find(A) != TargetDepAttrs.end();
}
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
bool AttrBuilder::hasAttributes() const {
Futureproof AttrBuild if we ever have more than 64 attr enum values. Currently we're at 34. Bitset should compile into virtually the same code as uint64_t here. llvm-svn: 175437
2013-02-18 20:09:51 +08:00
return !Attrs.none() || !TargetDepAttrs.empty();
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
}
Convert typeIncompatible to return an AttributeSet. There are still places which treat the Attribute object as a collection of attributes. I'm systematically removing them. llvm-svn: 173990
2013-01-31 07:07:40 +08:00
bool AttrBuilder::hasAttributes(AttributeSet A, uint64_t Index) const {
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
unsigned Slot = ~0U;
Use the AttributeSet's iterators. Use the AttributeSet's iterators in AttrBuilder::hasAttributes() when determining of the intersection of the AttrBuilder and AttributeSet is non-null. llvm-svn: 174250
2013-02-02 08:42:06 +08:00
for (unsigned I = 0, E = A.getNumSlots(); I != E; ++I)
if (A.getSlotIndex(I) == Index) {
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
Slot = I;
Use the AttributeSet's iterators. Use the AttributeSet's iterators in AttrBuilder::hasAttributes() when determining of the intersection of the AttrBuilder and AttributeSet is non-null. llvm-svn: 174250
2013-02-02 08:42:06 +08:00
break;
}
Cleanup patch: Semantics of parameters named Index and Idx were inconsistent between "include/llvm/IR/Attributes.h", "lib/IR/AttributeImpl.h" and "lib/IR/Attributes.cpp": sometimes these were fixed 1-based indexes of IR parameters (or AttributeSet::ReturnIndex for IR return values or AttributeSet::FunctionIndex for IR functions), other times they were the internal slot for storage in the underlying AttributeSetImpl. I renamed usage of the former to "Index" and usage of the latter to "Slot" ("Slot" was already being used consistently for the latter in a subset of cases) Patch by Stephen Lin! llvm-svn: 179791
2013-04-19 04:17:28 +08:00
assert(Slot != ~0U && "Couldn't find the index!");
Use the AttributeSet's iterators. Use the AttributeSet's iterators in AttrBuilder::hasAttributes() when determining of the intersection of the AttrBuilder and AttributeSet is non-null. llvm-svn: 174250
2013-02-02 08:42:06 +08:00
Minor cleanup of Attribute code. NFC. llvm-svn: 255751
2015-12-16 13:21:02 +08:00
for (AttributeSet::iterator I = A.begin(Slot), E = A.end(Slot); I != E; ++I) {
Support string attributes in the AttrBuilder. llvm-svn: 174948
2013-02-12 15:56:49 +08:00
Attribute Attr = *I;
Rename AlignAttribute to IntAttribute Currently the only kind of integer IR attributes that we have are alignment attributes, and so the attribute kind that takes an integer parameter is called AlignAttr, but that will change (we'll soon be adding a dereferenceable attribute that also takes an integer value). Accordingly, rename AlignAttribute to IntAttribute (class names, enums, etc.). No functionality change intended. llvm-svn: 213352
2014-07-18 14:51:55 +08:00
if (Attr.isEnumAttribute() || Attr.isIntAttribute()) {
Futureproof AttrBuild if we ever have more than 64 attr enum values. Currently we're at 34. Bitset should compile into virtually the same code as uint64_t here. llvm-svn: 175437
2013-02-18 20:09:51 +08:00
if (Attrs[I->getKindAsEnum()])
Support string attributes in the AttrBuilder. llvm-svn: 174948
2013-02-12 15:56:49 +08:00
return true;
} else {
assert(Attr.isStringAttribute() && "Invalid attribute kind!");
return TargetDepAttrs.find(Attr.getKindAsString())!=TargetDepAttrs.end();
}
}
Use the AttributeSet's iterators. Use the AttributeSet's iterators in AttrBuilder::hasAttributes() when determining of the intersection of the AttrBuilder and AttributeSet is non-null. llvm-svn: 174250
2013-02-02 08:42:06 +08:00
return false;
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
}
bool AttrBuilder::hasAlignmentAttr() const {
return Alignment != 0;
}
bool AttrBuilder::operator==(const AttrBuilder &B) {
Turn the enum attributes DenseSet in AttrBuilder into a set of bits. Avoids malloc and is a lot denser. We lose iteration over target independent attributes, but that's a strange interface anyways and didn't have any users outside of AttrBuilder. llvm-svn: 175370
2013-02-17 03:13:18 +08:00
if (Attrs != B.Attrs)
return false;
Add a 'StringRef' version of hasAttribute. Fix the 'operator==' and 'hasAttributes' queries to take into account target-dependent attributes. llvm-svn: 174481
2013-02-06 09:33:42 +08:00
for (td_const_iterator I = TargetDepAttrs.begin(),
E = TargetDepAttrs.end(); I != E; ++I)
if (B.TargetDepAttrs.find(I->first) == B.TargetDepAttrs.end())
return false;
Add a dereferenceable attribute This attribute indicates that the parameter or return pointer is dereferenceable. Practically speaking, loads from such a pointer within the associated byte range are safe to speculatively execute. Such pointer parameters are common in source languages (C++ references, for example). llvm-svn: 213385
2014-07-18 23:51:28 +08:00
return Alignment == B.Alignment && StackAlignment == B.StackAlignment &&
DerefBytes == B.DerefBytes;
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
}
AttrBuilder &AttrBuilder::addRawValue(uint64_t Val) {
Initial cleanups of the param-attribute code in the bitcode reader/writer. Rename the PARAMATTR_CODE_ENTRY to PARAMATTR_CODE_ENTRY_OLD. It will be replaced by another encoding. Keep around the current LLVM attribute encoder/decoder code, but move it to the bitcode directories so that no one's tempted to use them. llvm-svn: 174335
2013-02-05 07:32:23 +08:00
// FIXME: Remove this in 4.0.
Use an AttrBuilder to generate the correct AttributeSet. We no longer accept an encoded integer as representing all of the attributes. Convert this via the AttrBuilder class into an AttributeSet with the correct representation (an AttributeSetImpl that holds a list of Attribute objects). llvm-svn: 173750
2013-01-29 09:43:29 +08:00
if (!Val) return *this;
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
for (Attribute::AttrKind I = Attribute::None; I != Attribute::EndAttrKinds;
I = Attribute::AttrKind(I + 1)) {
[IR] Introduce a dereferenceable_or_null(N) attribute. Summary: If a pointer is marked as dereferenceable_or_null(N), LLVM assumes it is either `null` or `dereferenceable(N)` or both. This change only introduces the attribute and adds a token test case for the `llvm-as` / `llvm-dis`. It does not hook up other parts of the optimizer to actually exploit the attribute -- those changes will come later. For pointers in address space 0, `dereferenceable(N)` is now exactly equivalent to `dereferenceable_or_null(N)` && `nonnull`. For other address spaces, `dereferenceable(N)` is potentially weaker than `dereferenceable_or_null(N)` && `nonnull` (since we could have a null `dereferenceable(N)` pointer). The motivating case for this change is Java (and other managed languages), where pointers are either `null` or dereferenceable up to some usually known-at-compile-time constant offset. Reviewers: rafael, hfinkel Reviewed By: hfinkel Subscribers: nicholas, llvm-commits Differential Revision: http://reviews.llvm.org/D8650 llvm-svn: 235132
2015-04-17 04:29:50 +08:00
if (I == Attribute::Dereferenceable ||
Add argmemonly attribute. This change adds new attribute called "argmemonly". Function marked with this attribute can only access memory through it's argument pointers. This attribute directly corresponds to the "OnlyAccessesArgumentPointees" ModRef behaviour in alias analysis. Differential Revision: http://reviews.llvm.org/D10398 llvm-svn: 241979
2015-07-11 18:30:36 +08:00
I == Attribute::DereferenceableOrNull ||
I == Attribute::ArgMemOnly)
Add a dereferenceable attribute This attribute indicates that the parameter or return pointer is dereferenceable. Practically speaking, loads from such a pointer within the associated byte range are safe to speculatively execute. Such pointer parameters are common in source languages (C++ references, for example). llvm-svn: 213385
2014-07-18 23:51:28 +08:00
continue;
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
if (uint64_t A = (Val & AttributeImpl::getAttrMask(I))) {
Futureproof AttrBuild if we ever have more than 64 attr enum values. Currently we're at 34. Bitset should compile into virtually the same code as uint64_t here. llvm-svn: 175437
2013-02-18 20:09:51 +08:00
Attrs[I] = true;
Reorder some functions and add comments. No functionality change. llvm-svn: 173733
2013-01-29 08:34:06 +08:00
if (I == Attribute::Alignment)
Alignment = 1ULL << ((A >> 16) - 1);
else if (I == Attribute::StackAlignment)
StackAlignment = 1ULL << ((A >> 26)-1);
}
}
return *this;
}
Remove some introspection functions. The 'getSlot' function and its ilk allow introspection into the AttributeSet class. However, that class should be opaque. Allow access through accessor methods instead. llvm-svn: 173522
2013-01-26 07:09:36 +08:00
//===----------------------------------------------------------------------===//
// AttributeFuncs Function Defintions
//===----------------------------------------------------------------------===//
Remove some dead code, improve some asserts, and other assorted changes. No functionality change. llvm-svn: 174132
2013-02-01 09:04:27 +08:00
/// \brief Which attributes cannot be applied to a type.
De-constify pointers to Type since they can't be modified. NFC This was already done in most places a while ago. This just fixes the ones that crept in over time. llvm-svn: 243842
2015-08-02 06:20:21 +08:00
AttrBuilder AttributeFuncs::typeIncompatible(Type *Ty) {
Remove some introspection functions. The 'getSlot' function and its ilk allow introspection into the AttributeSet class. However, that class should be opaque. Allow access through accessor methods instead. llvm-svn: 173522
2013-01-26 07:09:36 +08:00
AttrBuilder Incompatible;
if (!Ty->isIntegerTy())
// Attribute that only apply to integers.
Incompatible.addAttribute(Attribute::SExt)
.addAttribute(Attribute::ZExt);
if (!Ty->isPointerTy())
// Attribute that only apply to pointers.
Incompatible.addAttribute(Attribute::ByVal)
.addAttribute(Attribute::Nest)
.addAttribute(Attribute::NoAlias)
.addAttribute(Attribute::NoCapture)
Add 'nonnull', a new parameter and return attribute which indicates that the pointer is not null. Instcombine will elide comparisons between these and null. Patch by Luqman Aden! llvm-svn: 209185
2014-05-20 09:23:40 +08:00
.addAttribute(Attribute::NonNull)
Add a dereferenceable attribute This attribute indicates that the parameter or return pointer is dereferenceable. Practically speaking, loads from such a pointer within the associated byte range are safe to speculatively execute. Such pointer parameters are common in source languages (C++ references, for example). llvm-svn: 213385
2014-07-18 23:51:28 +08:00
.addDereferenceableAttr(1) // the int here is ignored
[IR] Introduce a dereferenceable_or_null(N) attribute. Summary: If a pointer is marked as dereferenceable_or_null(N), LLVM assumes it is either `null` or `dereferenceable(N)` or both. This change only introduces the attribute and adds a token test case for the `llvm-as` / `llvm-dis`. It does not hook up other parts of the optimizer to actually exploit the attribute -- those changes will come later. For pointers in address space 0, `dereferenceable(N)` is now exactly equivalent to `dereferenceable_or_null(N)` && `nonnull`. For other address spaces, `dereferenceable(N)` is potentially weaker than `dereferenceable_or_null(N)` && `nonnull` (since we could have a null `dereferenceable(N)` pointer). The motivating case for this change is Java (and other managed languages), where pointers are either `null` or dereferenceable up to some usually known-at-compile-time constant offset. Reviewers: rafael, hfinkel Reviewed By: hfinkel Subscribers: nicholas, llvm-commits Differential Revision: http://reviews.llvm.org/D8650 llvm-svn: 235132
2015-04-17 04:29:50 +08:00
.addDereferenceableOrNullAttr(1) // the int here is ignored
Extend 'readonly' and 'readnone' to work on function arguments as well as functions. Make the function attributes pass add it to known library functions and when it can deduce it. llvm-svn: 185735
2013-07-06 08:29:58 +08:00
.addAttribute(Attribute::ReadNone)
.addAttribute(Attribute::ReadOnly)
Begin adding docs and IR-level support for the inalloca attribute The inalloca attribute is designed to support passing C++ objects by value in the Microsoft C++ ABI. It behaves the same as byval, except that it always implies that the argument is in memory and that the bytes are never copied. This attribute allows the caller to take the address of an outgoing argument's memory and execute arbitrary code to store into it. This patch adds basic IR support, docs, and verification. It does not attempt to implement any lowering or fix any possibly broken transforms. When this patch lands, a complete description of this feature should appear at http://llvm.org/docs/InAlloca.html . Differential Revision: http://llvm-reviews.chandlerc.com/D2173 llvm-svn: 197645
2013-12-19 10:14:12 +08:00
.addAttribute(Attribute::StructRet)
.addAttribute(Attribute::InAlloca);
Remove some introspection functions. The 'getSlot' function and its ilk allow introspection into the AttributeSet class. However, that class should be opaque. Allow access through accessor methods instead. llvm-svn: 173522
2013-01-26 07:09:36 +08:00
Change typeIncompatible to return an AttrBuilder instead of new-ing an AttributeSet. This makes use of the new API which can remove attributes from a set given a builder. This is much faster than creating a temporary set and reduces llc time by about 0.3% which was all spent creating temporary attributes sets on the context. llvm-svn: 236668
2015-05-07 07:19:56 +08:00
return Incompatible;
Remove some introspection functions. The 'getSlot' function and its ilk allow introspection into the AttributeSet class. However, that class should be opaque. Allow access through accessor methods instead. llvm-svn: 173522
2013-01-26 07:09:36 +08:00
}
Provide a way to specify inliner's attribute compatibility and merging. This reapplies r256277 with two changes: - In emitFnAttrCompatCheck, change FuncName's type to std::string to fix a use-after-free bug. - Remove an unnecessary install-local target in lib/IR/Makefile. Original commit message for r252949: Provide a way to specify inliner's attribute compatibility and merging rules using table-gen. NFC. This commit adds new classes CompatRule and MergeRule to Attributes.td, which are used to generate code to check attribute compatibility and merge attributes of the caller and callee. rdar://problem/19836465 llvm-svn: 256304
2015-12-23 07:57:37 +08:00
template<typename AttrClass>
static bool isEqual(const Function &Caller, const Function &Callee) {
return Caller.getFnAttribute(AttrClass::getKind()) ==
Callee.getFnAttribute(AttrClass::getKind());
}
/// \brief Compute the logical AND of the attributes of the caller and the
/// callee.
///
/// This function sets the caller's attribute to false if the callee's attribute
/// is false.
template<typename AttrClass>
static void setAND(Function &Caller, const Function &Callee) {
if (AttrClass::isSet(Caller, AttrClass::getKind()) &&
!AttrClass::isSet(Callee, AttrClass::getKind()))
AttrClass::set(Caller, AttrClass::getKind(), false);
}
/// \brief Compute the logical OR of the attributes of the caller and the
/// callee.
///
/// This function sets the caller's attribute to true if the callee's attribute
/// is true.
template<typename AttrClass>
static void setOR(Function &Caller, const Function &Callee) {
if (!AttrClass::isSet(Caller, AttrClass::getKind()) &&
AttrClass::isSet(Callee, AttrClass::getKind()))
AttrClass::set(Caller, AttrClass::getKind(), true);
}
/// \brief If the inlined function had a higher stack protection level than the
/// calling function, then bump up the caller's stack protection level.
static void adjustCallerSSPLevel(Function &Caller, const Function &Callee) {
// If upgrading the SSP attribute, clear out the old SSP Attributes first.
// Having multiple SSP attributes doesn't actually hurt, but it adds useless
// clutter to the IR.
AttrBuilder B;
B.addAttribute(Attribute::StackProtect)
.addAttribute(Attribute::StackProtectStrong)
.addAttribute(Attribute::StackProtectReq);
AttributeSet OldSSPAttr = AttributeSet::get(Caller.getContext(),
AttributeSet::FunctionIndex,
B);
if (Callee.hasFnAttribute(Attribute::SafeStack)) {
Caller.removeAttributes(AttributeSet::FunctionIndex, OldSSPAttr);
Caller.addFnAttr(Attribute::SafeStack);
} else if (Callee.hasFnAttribute(Attribute::StackProtectReq) &&
!Caller.hasFnAttribute(Attribute::SafeStack)) {
Caller.removeAttributes(AttributeSet::FunctionIndex, OldSSPAttr);
Caller.addFnAttr(Attribute::StackProtectReq);
} else if (Callee.hasFnAttribute(Attribute::StackProtectStrong) &&
!Caller.hasFnAttribute(Attribute::SafeStack) &&
!Caller.hasFnAttribute(Attribute::StackProtectReq)) {
Caller.removeAttributes(AttributeSet::FunctionIndex, OldSSPAttr);
Caller.addFnAttr(Attribute::StackProtectStrong);
} else if (Callee.hasFnAttribute(Attribute::StackProtect) &&
!Caller.hasFnAttribute(Attribute::SafeStack) &&
!Caller.hasFnAttribute(Attribute::StackProtectReq) &&
!Caller.hasFnAttribute(Attribute::StackProtectStrong))
Caller.addFnAttr(Attribute::StackProtect);
}
#define GET_ATTR_COMPAT_FUNC
#include "AttributesCompatFunc.inc"
bool AttributeFuncs::areInlineCompatible(const Function &Caller,
const Function &Callee) {
return hasCompatibleFnAttrs(Caller, Callee);
}
void AttributeFuncs::mergeAttributesForInlining(Function &Caller,
const Function &Callee) {
mergeFnAttrs(Caller, Callee);
}