This is an archive of the discontinued LLVM Phabricator instance.

Differential D31102

Rename AttributeSet to AttributeList
ClosedPublic

Authored by rnk on Mar 17 2017, 2:07 PM.

Details

Reviewers
chandlerc
pete
sanjoy
javed.absar
Commits
rGb518054b87c4: Rename AttributeSet to AttributeList
rL298393: Rename AttributeSet to AttributeList
Summary

This class is a list of AttributeSetNodes corresponding the function
prototype of a call or function declaration. This class used to be
called ParamAttrListPtr, then AttrListPtr, then AttributeSet. It is
typically accessed by parameter and return value index, so
"AttributeList" seems like a more intuitive name.

Rename AttributeSetImpl to AttributeListImpl to follow suit.

It's useful to rename this class so that we can rename AttributeSetNode
to AttributeSet later. AttributeSet is the set of attributes that apply
to a single function, argument, or return value.

Diff Detail

Repository
rL LLVM

Event Timeline

rnk created this revision.Mar 17 2017, 2:07 PM
Herald added a reviewer: javed.absar. · View Herald TranscriptMar 17 2017, 2:07 PM
Herald added subscribers: sbc100, nhaehnle, jfb and 4 others. · View Herald Transcript
chandlerc edited edge metadata.Mar 17 2017, 2:51 PM

I think it'd be good to send a quick RFC / heads up email to the dev list about the refactorings you're planning here just so that folks know what the roadmap is. I'll review this in the mean time.

rnk added a comment.Mar 20 2017, 3:12 PM

I sent an RFC: http://lists.llvm.org/pipermail/llvm-dev/2017-March/111326.html

Maybe it was too long, I haven't gotten any responses yet. =)

pete accepted this revision.Mar 20 2017, 11:26 PM
pete added a subscriber: pete.

I scrolled through fairly quickly, but everything looked fine. Looks like basically renaming and fixing formatting along the way.

So LGTM, and thanks for cleaning this up!

This revision is now accepted and ready to land.Mar 20 2017, 11:26 PM
Closed by commit rL298393: Rename AttributeSet to AttributeList (authored by rnk). · Explain WhyMar 21 2017, 10:10 AM
This revision was automatically updated to reflect the committed changes.
oren_ben_simhon added a subscriber: oren_ben_simhon.Mar 28 2017, 8:15 AM

If i understand correctly AttributeSet is a list of attribute sets. If this is correct why not changing the name to AttributeSetList?

rnk added a comment.Mar 29 2017, 10:41 AM
In D31102#712144, @oren_ben_simhon wrote:

If i understand correctly AttributeSet is a list of attribute sets. If this is correct why not changing the name to AttributeSetList?

That's correct, I just felt AttributeSetList was too long.

Revision Contents

PathSize
llvm/
trunk/
docs/
35 lines
include/
llvm/
CodeGen/
20 lines
IR/
8 lines
148 lines
4 lines
26 lines
84 lines
4 lines
5 lines
2 lines
Target/
6 lines
Transforms/
Utils/
4 lines
2 lines
lib/
Analysis/
2 lines
AsmParser/
12 lines
98 lines
Bitcode/
Reader/
22 lines
Writer/
14 lines
22 lines
4 lines
CodeGen/
5 lines
4 lines
10 lines
GlobalISel/
4 lines
2 lines
SelectionDAG/
6 lines
8 lines
18 lines
13 lines
12 lines
ExecutionEngine/
2 lines
IR/
81 lines
24 lines
9 lines
313 lines
15 lines
38 lines
36 lines
2 lines
7 lines
16 lines
7 lines
2 lines
93 lines
Target/
AArch64/
2 lines
2 lines
2 lines
6 lines
AMDGPU/
4 lines
6 lines
ARM/
2 lines
AVR/
2 lines
Hexagon/
2 lines
6 lines
Mips/
16 lines
NVPTX/
2 lines
2 lines
WebAssembly/
4 lines
2 lines
3 lines
19 lines
X86/
2 lines
2 lines
8 lines
XCore/
2 lines
Transforms/
Coroutines/
6 lines
6 lines
IPO/
36 lines
71 lines
31 lines
2 lines
4 lines
InstCombine/
70 lines
Instrumentation/
56 lines
14 lines
5 lines
ObjCARC/
14 lines
Scalar/
2 lines
2 lines
33 lines
Utils/
22 lines
15 lines
4 lines
8 lines
2 lines
4 lines
4 lines
unittests/
ExecutionEngine/
Orc/
16 lines
IR/
20 lines
8 lines
17 lines
6 lines
Transforms/
Utils/
2 lines
utils/
TableGen/
20 lines

Diff 92506

llvm/trunk/docs/HowToUseAttributes.rst

Show All 32 Lines
``Attribute`` ``Attribute``
============= =============
An ``Attribute`` object is designed to be passed around by value. An ``Attribute`` object is designed to be passed around by value.
Because attributes are no longer represented as a bit mask, you will need to Because attributes are no longer represented as a bit mask, you will need to
convert any code which does treat them as a bit mask to use the new query convert any code which does treat them as a bit mask to use the new query
methods on the Attribute class. methods on the Attribute class.
``AttributeSet`` ``AttributeList``
================ ================
The ``AttributeSet`` class replaces the old ``AttributeList`` class. The The ``AttributeList`` stores a collection of Attribute objects for each kind of
``AttributeSet`` stores a collection of Attribute objects for each kind of object that may have an attribute associated with it: the function as a whole,
object that may have an attribute associated with it: the function as a the return type, or the function's parameters. A function's attributes are at
whole, the return type, or the function's parameters. A function's attributes index ``AttributeList::FunctionIndex``; the return type's attributes are at
are at index ``AttributeSet::FunctionIndex``; the return type's attributes are index ``AttributeList::ReturnIndex``; and the function's parameters' attributes
at index ``AttributeSet::ReturnIndex``; and the function's parameters' are at indices 1, ..., n (where 'n' is the number of parameters). Most methods
attributes are at indices 1, ..., n (where 'n' is the number of parameters). on the ``AttributeList`` class take an index parameter.
Most methods on the ``AttributeSet`` class take an index parameter.
An ``AttributeList`` is also a uniqued and immutable object. You create an
An ``AttributeSet`` is also a uniqued and immutable object. You create an ``AttributeList`` through the ``AttributeList::get`` methods. You can add and
``AttributeSet`` through the ``AttributeSet::get`` methods. You can add and remove attributes, which result in the creation of a new ``AttributeList``.
remove attributes, which result in the creation of a new ``AttributeSet``.
An ``AttributeSet`` object is designed to be passed around by value. An ``AttributeList`` object is designed to be passed around by value.
Note: It is advised that you do *not* use the ``AttributeSet`` "introspection" Note: It is advised that you do *not* use the ``AttributeList`` "introspection"
methods (e.g. ``Raw``, ``getRawPointer``, etc.). These methods break methods (e.g. ``Raw``, ``getRawPointer``, etc.). These methods break
encapsulation, and may be removed in a future release (i.e. LLVM 4.0). encapsulation, and may be removed in a future release (i.e. LLVM 4.0).
``AttrBuilder`` ``AttrBuilder``
=============== ===============
Lastly, we have a "builder" class to help create the ``AttributeSet`` object Lastly, we have a "builder" class to help create the ``AttributeList`` object
without having to create several different intermediate uniqued without having to create several different intermediate uniqued
``AttributeSet`` objects. The ``AttrBuilder`` class allows you to add and ``AttributeList`` objects. The ``AttrBuilder`` class allows you to add and
remove attributes at will. The attributes won't be uniqued until you call the remove attributes at will. The attributes won't be uniqued until you call the
appropriate ``AttributeSet::get`` method. appropriate ``AttributeList::get`` method.
An ``AttrBuilder`` object is *not* designed to be passed around by value. It An ``AttrBuilder`` object is *not* designed to be passed around by value. It
should be passed by reference. should be passed by reference.
Note: It is advised that you do *not* use the ``AttrBuilder::addRawValue()`` Note: It is advised that you do *not* use the ``AttrBuilder::addRawValue()``
method or the ``AttrBuilder(uint64_t Val)`` constructor. These are for method or the ``AttrBuilder(uint64_t Val)`` constructor. These are for
backwards compatibility and may be removed in a future release (i.e. LLVM 4.0). backwards compatibility and may be removed in a future release (i.e. LLVM 4.0).
And that's basically it! A lot of functionality is hidden behind these classes, And that's basically it! A lot of functionality is hidden behind these classes,
but the interfaces are pretty straight forward. but the interfaces are pretty straight forward.

llvm/trunk/include/llvm/CodeGen/CommandFlags.h

Show First 20 Lines • Show All 340 Lines • ▼ Show 20 Lines
} }
/// \brief Set function attributes of functions in Module M based on CPU, /// \brief Set function attributes of functions in Module M based on CPU,
/// Features, and command line flags. /// Features, and command line flags.
static inline void setFunctionAttributes(StringRef CPU, StringRef Features, static inline void setFunctionAttributes(StringRef CPU, StringRef Features,
Module &M) { Module &M) {
for (auto &F : M) { for (auto &F : M) {
auto &Ctx = F.getContext(); auto &Ctx = F.getContext();
AttributeSet Attrs = F.getAttributes(), NewAttrs; AttributeList Attrs = F.getAttributes(), NewAttrs;
if (!CPU.empty()) if (!CPU.empty())
NewAttrs = NewAttrs.addAttribute(Ctx, AttributeSet::FunctionIndex, NewAttrs = NewAttrs.addAttribute(Ctx, AttributeList::FunctionIndex,
"target-cpu", CPU); "target-cpu", CPU);
if (!Features.empty()) if (!Features.empty())
NewAttrs = NewAttrs.addAttribute(Ctx, AttributeSet::FunctionIndex, NewAttrs = NewAttrs.addAttribute(Ctx, AttributeList::FunctionIndex,
"target-features", Features); "target-features", Features);
if (DisableFPElim.getNumOccurrences() > 0) if (DisableFPElim.getNumOccurrences() > 0)
NewAttrs = NewAttrs.addAttribute(Ctx, AttributeSet::FunctionIndex, NewAttrs = NewAttrs.addAttribute(Ctx, AttributeList::FunctionIndex,
"no-frame-pointer-elim", "no-frame-pointer-elim",
DisableFPElim ? "true" : "false"); DisableFPElim ? "true" : "false");
if (DisableTailCalls.getNumOccurrences() > 0) if (DisableTailCalls.getNumOccurrences() > 0)
NewAttrs = NewAttrs.addAttribute(Ctx, AttributeSet::FunctionIndex, NewAttrs = NewAttrs.addAttribute(Ctx, AttributeList::FunctionIndex,
"disable-tail-calls", "disable-tail-calls",
toStringRef(DisableTailCalls)); toStringRef(DisableTailCalls));
if (StackRealign) if (StackRealign)
NewAttrs = NewAttrs.addAttribute(Ctx, AttributeSet::FunctionIndex, NewAttrs = NewAttrs.addAttribute(Ctx, AttributeList::FunctionIndex,
"stackrealign"); "stackrealign");
if (TrapFuncName.getNumOccurrences() > 0) if (TrapFuncName.getNumOccurrences() > 0)
for (auto &B : F) for (auto &B : F)
for (auto &I : B) for (auto &I : B)
if (auto *Call = dyn_cast<CallInst>(&I)) if (auto *Call = dyn_cast<CallInst>(&I))
if (const auto *F = Call->getCalledFunction()) if (const auto *F = Call->getCalledFunction())
if (F->getIntrinsicID() == Intrinsic::debugtrap || if (F->getIntrinsicID() == Intrinsic::debugtrap ||
F->getIntrinsicID() == Intrinsic::trap) F->getIntrinsicID() == Intrinsic::trap)
Call->addAttribute(llvm::AttributeSet::FunctionIndex, Call->addAttribute(
Attribute::get(Ctx, "trap-func-name", llvm::AttributeList::FunctionIndex,
TrapFuncName)); Attribute::get(Ctx, "trap-func-name", TrapFuncName));
// Let NewAttrs override Attrs. // Let NewAttrs override Attrs.
NewAttrs = Attrs.addAttributes(Ctx, AttributeSet::FunctionIndex, NewAttrs); NewAttrs = Attrs.addAttributes(Ctx, AttributeList::FunctionIndex, NewAttrs);
F.setAttributes(NewAttrs); F.setAttributes(NewAttrs);
} }
} }
#endif #endif

llvm/trunk/include/llvm/IR/Argument.h

Show First 20 Lines • Show All 102 Lines • ▼ Show 20 Linespublic:
/// Return true if this argument has the zext attribute. /// Return true if this argument has the zext attribute.
bool hasZExtAttr() const; bool hasZExtAttr() const;
/// Return true if this argument has the sext attribute. /// Return true if this argument has the sext attribute.
bool hasSExtAttr() const; bool hasSExtAttr() const;
/// Add attributes to an argument. /// Add attributes to an argument.
void addAttr(AttributeSet AS); void addAttr(AttributeList AS);
void addAttr(Attribute::AttrKind Kind) { void addAttr(Attribute::AttrKind Kind) {
addAttr(AttributeSet::get(getContext(), getArgNo() + 1, Kind)); addAttr(AttributeList::get(getContext(), getArgNo() + 1, Kind));
} }
/// Remove attributes from an argument. /// Remove attributes from an argument.
void removeAttr(AttributeSet AS); void removeAttr(AttributeList AS);
void removeAttr(Attribute::AttrKind Kind) { void removeAttr(Attribute::AttrKind Kind) {
removeAttr(AttributeSet::get(getContext(), getArgNo() + 1, Kind)); removeAttr(AttributeList::get(getContext(), getArgNo() + 1, Kind));
} }
/// Check if an argument has a given attribute. /// Check if an argument has a given attribute.
bool hasAttribute(Attribute::AttrKind Kind) const; bool hasAttribute(Attribute::AttrKind Kind) const;
/// Method for support type inquiry through isa, cast, and dyn_cast. /// Method for support type inquiry through isa, cast, and dyn_cast.
static inline bool classof(const Value *V) { static inline bool classof(const Value *V) {
return V->getValueID() == ArgumentVal; return V->getValueID() == ArgumentVal;
} }
}; };
} // End llvm namespace } // End llvm namespace
#endif #endif

llvm/trunk/include/llvm/IR/Attributes.h

Show All 28 Lines
#include <map> #include <map>
#include <string> #include <string>
#include <utility> #include <utility>
namespace llvm { namespace llvm {
class AttrBuilder; class AttrBuilder;
class AttributeImpl; class AttributeImpl;
class AttributeSetImpl; class AttributeListImpl;
class AttributeSetNode; class AttributeSetNode;
template<typename T> struct DenseMapInfo; template<typename T> struct DenseMapInfo;
class Function; class Function;
class LLVMContext; class LLVMContext;
class Type; class Type;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// \class /// \class
▲ Show 20 Lines • Show All 148 Lines • ▼ Show 20 Lines
inline Attribute unwrap(LLVMAttributeRef Attr) { inline Attribute unwrap(LLVMAttributeRef Attr) {
return Attribute::fromRawPointer(Attr); return Attribute::fromRawPointer(Attr);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// \class /// \class
/// \brief This class holds the attributes for a function, its return value, and /// \brief This class holds the attributes for a function, its return value, and
/// its parameters. You access the attributes for each of them via an index into /// its parameters. You access the attributes for each of them via an index into
/// the AttributeSet object. The function attributes are at index /// the AttributeList object. The function attributes are at index
/// `AttributeSet::FunctionIndex', the return value is at index /// `AttributeList::FunctionIndex', the return value is at index
/// `AttributeSet::ReturnIndex', and the attributes for the parameters start at /// `AttributeList::ReturnIndex', and the attributes for the parameters start at
/// index `1'. /// index `1'.
class AttributeSet { class AttributeList {
public: public:
enum AttrIndex : unsigned { enum AttrIndex : unsigned {
ReturnIndex = 0U, ReturnIndex = 0U,
FunctionIndex = ~0U FunctionIndex = ~0U
}; };
private: private:
friend class AttrBuilder; friend class AttrBuilder;
friend class AttributeSetImpl; friend class AttributeListImpl;
friend class AttributeSetNode; friend class AttributeSetNode;
template <typename Ty> friend struct DenseMapInfo; template <typename Ty> friend struct DenseMapInfo;
/// \brief The attributes that we are managing. This can be null to represent /// \brief The attributes that we are managing. This can be null to represent
/// the empty attributes list. /// the empty attributes list.
AttributeSetImpl *pImpl = nullptr; AttributeListImpl *pImpl = nullptr;
/// \brief The attributes for the specified index are returned. /// \brief The attributes for the specified index are returned.
AttributeSetNode *getAttributes(unsigned Index) const; AttributeSetNode *getAttributes(unsigned Index) const;
/// \brief Create an AttributeSet with the specified parameters in it. /// \brief Create an AttributeList with the specified parameters in it.
static AttributeSet get(LLVMContext &C, static AttributeList get(LLVMContext &C,
ArrayRef<std::pair<unsigned, Attribute>> Attrs); ArrayRef<std::pair<unsigned, Attribute>> Attrs);
static AttributeSet get(LLVMContext &C, static AttributeList
ArrayRef<std::pair<unsigned, get(LLVMContext &C, ArrayRef<std::pair<unsigned, AttributeSetNode *>> Attrs);
AttributeSetNode*>> Attrs);
static AttributeSet getImpl(LLVMContext &C,
ArrayRef<std::pair<unsigned,
AttributeSetNode*>> Attrs);
explicit AttributeSet(AttributeSetImpl *LI) : pImpl(LI) {} static AttributeList
getImpl(LLVMContext &C,
ArrayRef<std::pair<unsigned, AttributeSetNode *>> Attrs);
explicit AttributeList(AttributeListImpl *LI) : pImpl(LI) {}
public: public:
AttributeSet() = default; AttributeList() = default;
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
// AttributeSet Construction and Mutation // AttributeList Construction and Mutation
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
/// \brief Return an AttributeSet with the specified parameters in it. /// \brief Return an AttributeList with the specified parameters in it.
static AttributeSet get(LLVMContext &C, ArrayRef<AttributeSet> Attrs); static AttributeList get(LLVMContext &C, ArrayRef<AttributeList> Attrs);
static AttributeSet get(LLVMContext &C, unsigned Index, static AttributeList get(LLVMContext &C, unsigned Index,
ArrayRef<Attribute::AttrKind> Kinds); ArrayRef<Attribute::AttrKind> Kinds);
static AttributeSet get(LLVMContext &C, unsigned Index, static AttributeList get(LLVMContext &C, unsigned Index,
ArrayRef<StringRef> Kind); ArrayRef<StringRef> Kind);
static AttributeSet get(LLVMContext &C, unsigned Index, const AttrBuilder &B); static AttributeList get(LLVMContext &C, unsigned Index,
const AttrBuilder &B);
/// \brief Add an attribute to the attribute set at the given index. Because /// \brief Add an attribute to the attribute set at the given index. Because
/// attribute sets are immutable, this returns a new set. /// attribute sets are immutable, this returns a new set.
AttributeSet addAttribute(LLVMContext &C, unsigned Index, AttributeList addAttribute(LLVMContext &C, unsigned Index,
Attribute::AttrKind Kind) const; Attribute::AttrKind Kind) const;
/// \brief Add an attribute to the attribute set at the given index. Because /// \brief Add an attribute to the attribute set at the given index. Because
/// attribute sets are immutable, this returns a new set. /// attribute sets are immutable, this returns a new set.
AttributeSet addAttribute(LLVMContext &C, unsigned Index, StringRef Kind, AttributeList addAttribute(LLVMContext &C, unsigned Index, StringRef Kind,
StringRef Value = StringRef()) const; StringRef Value = StringRef()) const;
/// Add an attribute to the attribute set at the given indices. Because /// Add an attribute to the attribute set at the given indices. Because
/// attribute sets are immutable, this returns a new set. /// attribute sets are immutable, this returns a new set.
AttributeSet addAttribute(LLVMContext &C, ArrayRef<unsigned> Indices, AttributeList addAttribute(LLVMContext &C, ArrayRef<unsigned> Indices,
Attribute A) const; Attribute A) const;
/// \brief Add attributes to the attribute set at the given index. Because /// \brief Add attributes to the attribute set at the given index. Because
/// attribute sets are immutable, this returns a new set. /// attribute sets are immutable, this returns a new set.
AttributeSet addAttributes(LLVMContext &C, unsigned Index, AttributeList addAttributes(LLVMContext &C, unsigned Index,
AttributeSet Attrs) const; AttributeList Attrs) const;
/// \brief Remove the specified attribute at the specified index from this /// \brief Remove the specified attribute at the specified index from this
/// attribute list. Because attribute lists are immutable, this returns the /// attribute list. Because attribute lists are immutable, this returns the
/// new list. /// new list.
AttributeSet removeAttribute(LLVMContext &C, unsigned Index, AttributeList removeAttribute(LLVMContext &C, unsigned Index,
Attribute::AttrKind Kind) const; Attribute::AttrKind Kind) const;
/// \brief Remove the specified attribute at the specified index from this /// \brief Remove the specified attribute at the specified index from this
/// attribute list. Because attribute lists are immutable, this returns the /// attribute list. Because attribute lists are immutable, this returns the
/// new list. /// new list.
AttributeSet removeAttribute(LLVMContext &C, unsigned Index, AttributeList removeAttribute(LLVMContext &C, unsigned Index,
StringRef Kind) const; StringRef Kind) const;
/// \brief Remove the specified attributes at the specified index from this /// \brief Remove the specified attributes at the specified index from this
/// attribute list. Because attribute lists are immutable, this returns the /// attribute list. Because attribute lists are immutable, this returns the
/// new list. /// new list.
AttributeSet removeAttributes(LLVMContext &C, unsigned Index, AttributeList removeAttributes(LLVMContext &C, unsigned Index,
AttributeSet Attrs) const; AttributeList Attrs) const;
/// \brief Remove the specified attributes at the specified index from this /// \brief Remove the specified attributes at the specified index from this
/// attribute list. Because attribute lists are immutable, this returns the /// attribute list. Because attribute lists are immutable, this returns the
/// new list. /// new list.
AttributeSet removeAttributes(LLVMContext &C, unsigned Index, AttributeList removeAttributes(LLVMContext &C, unsigned Index,
const AttrBuilder &Attrs) const; const AttrBuilder &Attrs) const;
/// \brief Add the dereferenceable attribute to the attribute set at the given /// \brief Add the dereferenceable attribute to the attribute set at the given
/// index. Because attribute sets are immutable, this returns a new set. /// index. Because attribute sets are immutable, this returns a new set.
AttributeSet addDereferenceableAttr(LLVMContext &C, unsigned Index, AttributeList addDereferenceableAttr(LLVMContext &C, unsigned Index,
uint64_t Bytes) const; uint64_t Bytes) const;
/// \brief Add the dereferenceable_or_null attribute to the attribute set at /// \brief Add the dereferenceable_or_null attribute to the attribute set at
/// the given index. Because attribute sets are immutable, this returns a new /// the given index. Because attribute sets are immutable, this returns a new
/// set. /// set.
AttributeSet addDereferenceableOrNullAttr(LLVMContext &C, unsigned Index, AttributeList addDereferenceableOrNullAttr(LLVMContext &C, unsigned Index,
uint64_t Bytes) const; uint64_t Bytes) const;
/// Add the allocsize attribute to the attribute set at the given index. /// Add the allocsize attribute to the attribute set at the given index.
/// Because attribute sets are immutable, this returns a new set. /// Because attribute sets are immutable, this returns a new set.
AttributeSet addAllocSizeAttr(LLVMContext &C, unsigned Index, AttributeList addAllocSizeAttr(LLVMContext &C, unsigned Index,
unsigned ElemSizeArg, unsigned ElemSizeArg,
const Optional<unsigned> &NumElemsArg); const Optional<unsigned> &NumElemsArg);
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
// AttributeSet Accessors // AttributeList Accessors
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
/// \brief Retrieve the LLVM context. /// \brief Retrieve the LLVM context.
LLVMContext &getContext() const; LLVMContext &getContext() const;
/// \brief The attributes for the specified index are returned. /// \brief The attributes for the specified index are returned.
AttributeSet getParamAttributes(unsigned Index) const; AttributeList getParamAttributes(unsigned Index) const;
/// \brief The attributes for the ret value are returned. /// \brief The attributes for the ret value are returned.
AttributeSet getRetAttributes() const; AttributeList getRetAttributes() const;
/// \brief The function attributes are returned. /// \brief The function attributes are returned.
AttributeSet getFnAttributes() const; AttributeList getFnAttributes() const;
/// \brief Return true if the attribute exists at the given index. /// \brief Return true if the attribute exists at the given index.
bool hasAttribute(unsigned Index, Attribute::AttrKind Kind) const; bool hasAttribute(unsigned Index, Attribute::AttrKind Kind) const;
/// \brief Return true if the attribute exists at the given index. /// \brief Return true if the attribute exists at the given index.
bool hasAttribute(unsigned Index, StringRef Kind) const; bool hasAttribute(unsigned Index, StringRef Kind) const;
/// \brief Return true if attribute exists at the given index. /// \brief Return true if attribute exists at the given index.
bool hasAttributes(unsigned Index) const; bool hasAttributes(unsigned Index) const;
/// \brief Equivalent to hasAttribute(AttributeSet::FunctionIndex, Kind) but /// \brief Equivalent to hasAttribute(AttributeList::FunctionIndex, Kind) but
/// may be faster. /// may be faster.
bool hasFnAttribute(Attribute::AttrKind Kind) const; bool hasFnAttribute(Attribute::AttrKind Kind) const;
/// \brief Equivalent to hasAttribute(AttributeSet::FunctionIndex, Kind) but /// \brief Equivalent to hasAttribute(AttributeList::FunctionIndex, Kind) but
/// may be faster. /// may be faster.
bool hasFnAttribute(StringRef Kind) const; bool hasFnAttribute(StringRef Kind) const;
/// \brief Return true if the specified attribute is set for at least one /// \brief Return true if the specified attribute is set for at least one
/// parameter or for the return value. If Index is not nullptr, the index /// parameter or for the return value. If Index is not nullptr, the index
/// of a parameter with the specified attribute is provided. /// of a parameter with the specified attribute is provided.
bool hasAttrSomewhere(Attribute::AttrKind Kind, bool hasAttrSomewhere(Attribute::AttrKind Kind,
unsigned *Index = nullptr) const; unsigned *Index = nullptr) const;
Show All 25 Linespublic:
std::string getAsString(unsigned Index, bool InAttrGrp = false) const; std::string getAsString(unsigned Index, bool InAttrGrp = false) const;
typedef ArrayRef<Attribute>::iterator iterator; typedef ArrayRef<Attribute>::iterator iterator;
iterator begin(unsigned Slot) const; iterator begin(unsigned Slot) const;
iterator end(unsigned Slot) const; iterator end(unsigned Slot) const;
/// operator==/!= - Provide equality predicates. /// operator==/!= - Provide equality predicates.
bool operator==(const AttributeSet &RHS) const { bool operator==(const AttributeList &RHS) const { return pImpl == RHS.pImpl; }
return pImpl == RHS.pImpl; bool operator!=(const AttributeList &RHS) const { return pImpl != RHS.pImpl; }
}
bool operator!=(const AttributeSet &RHS) const {
return pImpl != RHS.pImpl;
}
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
// AttributeSet Introspection // AttributeList Introspection
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
/// \brief Return a raw pointer that uniquely identifies this attribute list. /// \brief Return a raw pointer that uniquely identifies this attribute list.
void *getRawPointer() const { void *getRawPointer() const {
return pImpl; return pImpl;
} }
/// \brief Return true if there are no attributes. /// \brief Return true if there are no attributes.
bool isEmpty() const { bool isEmpty() const {
return getNumSlots() == 0; return getNumSlots() == 0;
} }
/// \brief Return the number of slots used in this attribute list. This is /// \brief Return the number of slots used in this attribute list. This is
/// the number of arguments that have an attribute set on them (including the /// the number of arguments that have an attribute set on them (including the
/// function itself). /// function itself).
unsigned getNumSlots() const; unsigned getNumSlots() const;
/// \brief Return the index for the given slot. /// \brief Return the index for the given slot.
unsigned getSlotIndex(unsigned Slot) const; unsigned getSlotIndex(unsigned Slot) const;
/// \brief Return the attributes at the given slot. /// \brief Return the attributes at the given slot.
AttributeSet getSlotAttributes(unsigned Slot) const; AttributeList getSlotAttributes(unsigned Slot) const;
void dump() const; void dump() const;
}; };
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// \class /// \class
/// \brief Provide DenseMapInfo for AttributeSet. /// \brief Provide DenseMapInfo for AttributeList.
template<> struct DenseMapInfo<AttributeSet> { template <> struct DenseMapInfo<AttributeList> {
static inline AttributeSet getEmptyKey() { static inline AttributeList getEmptyKey() {
uintptr_t Val = static_cast<uintptr_t>(-1); uintptr_t Val = static_cast<uintptr_t>(-1);
Val <<= PointerLikeTypeTraits<void*>::NumLowBitsAvailable; Val <<= PointerLikeTypeTraits<void*>::NumLowBitsAvailable;
return AttributeSet(reinterpret_cast<AttributeSetImpl*>(Val)); return AttributeList(reinterpret_cast<AttributeListImpl *>(Val));
} }
static inline AttributeSet getTombstoneKey() { static inline AttributeList getTombstoneKey() {
uintptr_t Val = static_cast<uintptr_t>(-2); uintptr_t Val = static_cast<uintptr_t>(-2);
Val <<= PointerLikeTypeTraits<void*>::NumLowBitsAvailable; Val <<= PointerLikeTypeTraits<void*>::NumLowBitsAvailable;
return AttributeSet(reinterpret_cast<AttributeSetImpl*>(Val)); return AttributeList(reinterpret_cast<AttributeListImpl *>(Val));
} }
static unsigned getHashValue(AttributeSet AS) { static unsigned getHashValue(AttributeList AS) {
return (unsigned((uintptr_t)AS.pImpl) >> 4) ^ return (unsigned((uintptr_t)AS.pImpl) >> 4) ^
(unsigned((uintptr_t)AS.pImpl) >> 9); (unsigned((uintptr_t)AS.pImpl) >> 9);
} }
static bool isEqual(AttributeSet LHS, AttributeSet RHS) { return LHS == RHS; } static bool isEqual(AttributeList LHS, AttributeList RHS) {
return LHS == RHS;
}
}; };
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// \class /// \class
/// \brief This class is used in conjunction with the Attribute::get method to /// \brief This class is used in conjunction with the Attribute::get method to
/// create an Attribute object. The object itself is uniquified. The Builder's /// create an Attribute object. The object itself is uniquified. The Builder's
/// value, however, is not. So this can be used as a quick way to test for /// value, however, is not. So this can be used as a quick way to test for
/// equality, presence of attributes, etc. /// equality, presence of attributes, etc.
class AttrBuilder { class AttrBuilder {
std::bitset<Attribute::EndAttrKinds> Attrs; std::bitset<Attribute::EndAttrKinds> Attrs;
std::map<std::string, std::string> TargetDepAttrs; std::map<std::string, std::string> TargetDepAttrs;
uint64_t Alignment = 0; uint64_t Alignment = 0;
uint64_t StackAlignment = 0; uint64_t StackAlignment = 0;
uint64_t DerefBytes = 0; uint64_t DerefBytes = 0;
uint64_t DerefOrNullBytes = 0; uint64_t DerefOrNullBytes = 0;
uint64_t AllocSizeArgs = 0; uint64_t AllocSizeArgs = 0;
public: public:
AttrBuilder() = default; AttrBuilder() = default;
AttrBuilder(const Attribute &A) { AttrBuilder(const Attribute &A) {
addAttribute(A); addAttribute(A);
} }
AttrBuilder(AttributeSet AS, unsigned Idx); AttrBuilder(AttributeList AS, unsigned Idx);
void clear(); void clear();
/// \brief Add an attribute to the builder. /// \brief Add an attribute to the builder.
AttrBuilder &addAttribute(Attribute::AttrKind Val); AttrBuilder &addAttribute(Attribute::AttrKind Val);
/// \brief Add the Attribute object to the builder. /// \brief Add the Attribute object to the builder.
AttrBuilder &addAttribute(Attribute A); AttrBuilder &addAttribute(Attribute A);
/// \brief Add the target-dependent attribute to the builder. /// \brief Add the target-dependent attribute to the builder.
AttrBuilder &addAttribute(StringRef A, StringRef V = StringRef()); AttrBuilder &addAttribute(StringRef A, StringRef V = StringRef());
/// \brief Remove an attribute from the builder. /// \brief Remove an attribute from the builder.
AttrBuilder &removeAttribute(Attribute::AttrKind Val); AttrBuilder &removeAttribute(Attribute::AttrKind Val);
/// \brief Remove the attributes from the builder. /// \brief Remove the attributes from the builder.
AttrBuilder &removeAttributes(AttributeSet A, uint64_t Index); AttrBuilder &removeAttributes(AttributeList A, uint64_t Index);
/// \brief Remove the target-dependent attribute to the builder. /// \brief Remove the target-dependent attribute to the builder.
AttrBuilder &removeAttribute(StringRef A); AttrBuilder &removeAttribute(StringRef A);
/// \brief Add the attributes from the builder. /// \brief Add the attributes from the builder.
AttrBuilder &merge(const AttrBuilder &B); AttrBuilder &merge(const AttrBuilder &B);
/// \brief Remove the attributes from the builder. /// \brief Remove the attributes from the builder.
Show All 13 Linespublic:
/// attribute. /// attribute.
bool contains(StringRef A) const; bool contains(StringRef A) const;
/// \brief Return true if the builder has IR-level attributes. /// \brief Return true if the builder has IR-level attributes.
bool hasAttributes() const; bool hasAttributes() const;
/// \brief Return true if the builder has any attribute that's in the /// \brief Return true if the builder has any attribute that's in the
/// specified attribute. /// specified attribute.
bool hasAttributes(AttributeSet A, uint64_t Index) const; bool hasAttributes(AttributeList A, uint64_t Index) const;
/// \brief Return true if the builder has an alignment attribute. /// \brief Return true if the builder has an alignment attribute.
bool hasAlignmentAttr() const; bool hasAlignmentAttr() const;
/// \brief Retrieve the alignment attribute, if it exists. /// \brief Retrieve the alignment attribute, if it exists.
uint64_t getAlignment() const { return Alignment; } uint64_t getAlignment() const { return Alignment; }
/// \brief Retrieve the stack alignment attribute, if it exists. /// \brief Retrieve the stack alignment attribute, if it exists.
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

llvm/trunk/include/llvm/IR/CallSite.h

Show First 20 Lines • Show All 317 Lines • ▼ Show 20 Lines FunctionType *getFunctionType() const {
CALLSITE_DELEGATE_GETTER(getFunctionType()); CALLSITE_DELEGATE_GETTER(getFunctionType());
} }
void mutateFunctionType(FunctionType *Ty) const { void mutateFunctionType(FunctionType *Ty) const {
CALLSITE_DELEGATE_SETTER(mutateFunctionType(Ty)); CALLSITE_DELEGATE_SETTER(mutateFunctionType(Ty));
} }
/// Get the parameter attributes of the call. /// Get the parameter attributes of the call.
AttributeSet getAttributes() const { AttributeList getAttributes() const {
CALLSITE_DELEGATE_GETTER(getAttributes()); CALLSITE_DELEGATE_GETTER(getAttributes());
} }
/// Set the parameter attributes of the call. /// Set the parameter attributes of the call.
void setAttributes(AttributeSet PAL) { void setAttributes(AttributeList PAL) {
CALLSITE_DELEGATE_SETTER(setAttributes(PAL)); CALLSITE_DELEGATE_SETTER(setAttributes(PAL));
} }
void addAttribute(unsigned i, Attribute::AttrKind Kind) { void addAttribute(unsigned i, Attribute::AttrKind Kind) {
CALLSITE_DELEGATE_SETTER(addAttribute(i, Kind)); CALLSITE_DELEGATE_SETTER(addAttribute(i, Kind));
} }
void addAttribute(unsigned i, Attribute Attr) { void addAttribute(unsigned i, Attribute Attr) {
▲ Show 20 Lines • Show All 345 Lines • Show Last 20 Lines

llvm/trunk/include/llvm/IR/Function.h

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines
private: private:
// Important things that make up a function! // Important things that make up a function!
BasicBlockListType BasicBlocks; ///< The basic blocks BasicBlockListType BasicBlocks; ///< The basic blocks
mutable Argument *Arguments; ///< The formal arguments mutable Argument *Arguments; ///< The formal arguments
size_t NumArgs; size_t NumArgs;
std::unique_ptr<ValueSymbolTable> std::unique_ptr<ValueSymbolTable>
SymTab; ///< Symbol table of args/instructions SymTab; ///< Symbol table of args/instructions
AttributeSet AttributeSets; ///< Parameter attributes AttributeList AttributeSets; ///< Parameter attributes
/* /*
* Value::SubclassData * Value::SubclassData
* *
* bit 0 : HasLazyArguments * bit 0 : HasLazyArguments
* bit 1 : HasPrefixData * bit 1 : HasPrefixData
* bit 2 : HasPrologueData * bit 2 : HasPrologueData
* bit 3 : HasPersonalityFn * bit 3 : HasPersonalityFn
▲ Show 20 Lines • Show All 103 Lines • ▼ Show 20 Linespublic:
} }
void setCallingConv(CallingConv::ID CC) { void setCallingConv(CallingConv::ID CC) {
auto ID = static_cast<unsigned>(CC); auto ID = static_cast<unsigned>(CC);
assert(!(ID & ~CallingConv::MaxID) && "Unsupported calling convention"); assert(!(ID & ~CallingConv::MaxID) && "Unsupported calling convention");
setValueSubclassData((getSubclassDataFromValue() & 0xc00f) | (ID << 4)); setValueSubclassData((getSubclassDataFromValue() & 0xc00f) | (ID << 4));
} }
/// @brief Return the attribute list for this Function. /// @brief Return the attribute list for this Function.
AttributeSet getAttributes() const { return AttributeSets; } AttributeList getAttributes() const { return AttributeSets; }
/// @brief Set the attribute list for this Function. /// @brief Set the attribute list for this Function.
void setAttributes(AttributeSet Attrs) { AttributeSets = Attrs; } void setAttributes(AttributeList Attrs) { AttributeSets = Attrs; }
/// @brief Add function attributes to this function. /// @brief Add function attributes to this function.
void addFnAttr(Attribute::AttrKind Kind) { void addFnAttr(Attribute::AttrKind Kind) {
addAttribute(AttributeSet::FunctionIndex, Kind); addAttribute(AttributeList::FunctionIndex, Kind);
} }
/// @brief Add function attributes to this function. /// @brief Add function attributes to this function.
void addFnAttr(StringRef Kind, StringRef Val = StringRef()) { void addFnAttr(StringRef Kind, StringRef Val = StringRef()) {
addAttribute(AttributeSet::FunctionIndex, addAttribute(AttributeList::FunctionIndex,
Attribute::get(getContext(), Kind, Val)); Attribute::get(getContext(), Kind, Val));
} }
void addFnAttr(Attribute Attr) { void addFnAttr(Attribute Attr) {
addAttribute(AttributeSet::FunctionIndex, Attr); addAttribute(AttributeList::FunctionIndex, Attr);
} }
/// @brief Remove function attributes from this function. /// @brief Remove function attributes from this function.
void removeFnAttr(Attribute::AttrKind Kind) { void removeFnAttr(Attribute::AttrKind Kind) {
removeAttribute(AttributeSet::FunctionIndex, Kind); removeAttribute(AttributeList::FunctionIndex, Kind);
} }
/// @brief Remove function attribute from this function. /// @brief Remove function attribute from this function.
void removeFnAttr(StringRef Kind) { void removeFnAttr(StringRef Kind) {
setAttributes(AttributeSets.removeAttribute( setAttributes(AttributeSets.removeAttribute(
getContext(), AttributeSet::FunctionIndex, Kind)); getContext(), AttributeList::FunctionIndex, Kind));
} }
/// \brief Set the entry count for this function. /// \brief Set the entry count for this function.
/// ///
/// Entry count is the number of times this function was executed based on /// Entry count is the number of times this function was executed based on
/// pgo data. \p Imports points to a set of GUIDs that needs to be imported /// pgo data. \p Imports points to a set of GUIDs that needs to be imported
/// by the function for sample PGO, to enable the same inlines as the /// by the function for sample PGO, to enable the same inlines as the
/// profiled optimized binary. /// profiled optimized binary.
Show All 21 Lines bool hasFnAttribute(Attribute::AttrKind Kind) const {
return AttributeSets.hasFnAttribute(Kind); return AttributeSets.hasFnAttribute(Kind);
} }
bool hasFnAttribute(StringRef Kind) const { bool hasFnAttribute(StringRef Kind) const {
return AttributeSets.hasFnAttribute(Kind); return AttributeSets.hasFnAttribute(Kind);
} }
/// @brief Return the attribute for the given attribute kind. /// @brief Return the attribute for the given attribute kind.
Attribute getFnAttribute(Attribute::AttrKind Kind) const { Attribute getFnAttribute(Attribute::AttrKind Kind) const {
return getAttribute(AttributeSet::FunctionIndex, Kind); return getAttribute(AttributeList::FunctionIndex, Kind);
} }
Attribute getFnAttribute(StringRef Kind) const { Attribute getFnAttribute(StringRef Kind) const {
return getAttribute(AttributeSet::FunctionIndex, Kind); return getAttribute(AttributeList::FunctionIndex, Kind);
} }
/// \brief Return the stack alignment for the function. /// \brief Return the stack alignment for the function.
unsigned getFnStackAlignment() const { unsigned getFnStackAlignment() const {
if (!hasFnAttribute(Attribute::StackAlignment)) if (!hasFnAttribute(Attribute::StackAlignment))
return 0; return 0;
return AttributeSets.getStackAlignment(AttributeSet::FunctionIndex); return AttributeSets.getStackAlignment(AttributeList::FunctionIndex);
} }
/// hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm /// hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm
/// to use during code generation. /// to use during code generation.
bool hasGC() const { bool hasGC() const {
return getSubclassDataFromValue() & (1<<14); return getSubclassDataFromValue() & (1<<14);
} }
const std::string &getGC() const; const std::string &getGC() const;
void setGC(std::string Str); void setGC(std::string Str);
void clearGC(); void clearGC();
/// @brief adds the attribute to the list of attributes. /// @brief adds the attribute to the list of attributes.
void addAttribute(unsigned i, Attribute::AttrKind Kind); void addAttribute(unsigned i, Attribute::AttrKind Kind);
/// @brief adds the attribute to the list of attributes. /// @brief adds the attribute to the list of attributes.
void addAttribute(unsigned i, Attribute Attr); void addAttribute(unsigned i, Attribute Attr);
/// @brief adds the attributes to the list of attributes. /// @brief adds the attributes to the list of attributes.
void addAttributes(unsigned i, AttributeSet Attrs); void addAttributes(unsigned i, AttributeList Attrs);
/// @brief removes the attribute from the list of attributes. /// @brief removes the attribute from the list of attributes.
void removeAttribute(unsigned i, Attribute::AttrKind Kind); void removeAttribute(unsigned i, Attribute::AttrKind Kind);
/// @brief removes the attribute from the list of attributes. /// @brief removes the attribute from the list of attributes.
void removeAttribute(unsigned i, StringRef Kind); void removeAttribute(unsigned i, StringRef Kind);
/// @brief removes the attributes from the list of attributes. /// @brief removes the attributes from the list of attributes.
void removeAttributes(unsigned i, AttributeSet Attrs); void removeAttributes(unsigned i, AttributeList Attrs);
/// @brief check if an attributes is in the list of attributes. /// @brief check if an attributes is in the list of attributes.
bool hasAttribute(unsigned i, Attribute::AttrKind Kind) const { bool hasAttribute(unsigned i, Attribute::AttrKind Kind) const {
return getAttributes().hasAttribute(i, Kind); return getAttributes().hasAttribute(i, Kind);
} }
Attribute getAttribute(unsigned i, Attribute::AttrKind Kind) const { Attribute getAttribute(unsigned i, Attribute::AttrKind Kind) const {
return AttributeSets.getAttribute(i, Kind); return AttributeSets.getAttribute(i, Kind);
▲ Show 20 Lines • Show All 402 Lines • Show Last 20 Lines

llvm/trunk/include/llvm/IR/Instructions.h

Show First 20 Lines • Show All 1,356 Lines • ▼ Show 20 Lines
/// machine's calling convention. This class uses low bit of the SubClassData /// machine's calling convention. This class uses low bit of the SubClassData
/// field to indicate whether or not this is a tail call. The rest of the bits /// field to indicate whether or not this is a tail call. The rest of the bits
/// hold the calling convention of the call. /// hold the calling convention of the call.
/// ///
class CallInst : public Instruction, class CallInst : public Instruction,
public OperandBundleUser<CallInst, User::op_iterator> { public OperandBundleUser<CallInst, User::op_iterator> {
friend class OperandBundleUser<CallInst, User::op_iterator>; friend class OperandBundleUser<CallInst, User::op_iterator>;
AttributeSet AttributeList; ///< parameter attributes for call AttributeList Attrs; ///< parameter attributes for call
FunctionType *FTy; FunctionType *FTy;
CallInst(const CallInst &CI); CallInst(const CallInst &CI);
/// Construct a CallInst given a range of arguments. /// Construct a CallInst given a range of arguments.
/// Construct a CallInst from a range of arguments /// Construct a CallInst from a range of arguments
inline CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args, inline CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr, ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
▲ Show 20 Lines • Show All 262 Lines • ▼ Show 20 Lines void setCallingConv(CallingConv::ID CC) {
auto ID = static_cast<unsigned>(CC); auto ID = static_cast<unsigned>(CC);
assert(!(ID & ~CallingConv::MaxID) && "Unsupported calling convention"); assert(!(ID & ~CallingConv::MaxID) && "Unsupported calling convention");
setInstructionSubclassData((getSubclassDataFromInstruction() & 3) | setInstructionSubclassData((getSubclassDataFromInstruction() & 3) |
(ID << 2)); (ID << 2));
} }
/// Return the parameter attributes for this call. /// Return the parameter attributes for this call.
/// ///
AttributeSet getAttributes() const { return AttributeList; } AttributeList getAttributes() const { return Attrs; }
/// Set the parameter attributes for this call. /// Set the parameter attributes for this call.
/// ///
void setAttributes(AttributeSet Attrs) { AttributeList = Attrs; } void setAttributes(AttributeList A) { Attrs = A; }
/// adds the attribute to the list of attributes. /// adds the attribute to the list of attributes.
void addAttribute(unsigned i, Attribute::AttrKind Kind); void addAttribute(unsigned i, Attribute::AttrKind Kind);
/// adds the attribute to the list of attributes. /// adds the attribute to the list of attributes.
void addAttribute(unsigned i, Attribute Attr); void addAttribute(unsigned i, Attribute Attr);
/// removes the attribute from the list of attributes. /// removes the attribute from the list of attributes.
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Linespublic:
/// \p i == Attribute::ReturnIndex -> the return value /// \p i == Attribute::ReturnIndex -> the return value
/// \p i in [1, arg_size + 1) -> argument number (\p i - 1) /// \p i in [1, arg_size + 1) -> argument number (\p i - 1)
/// \p i in [arg_size + 1, data_operand_size + 1) -> bundle operand at index /// \p i in [arg_size + 1, data_operand_size + 1) -> bundle operand at index
/// (\p i - 1) in the operand list. /// (\p i - 1) in the operand list.
bool dataOperandHasImpliedAttr(unsigned i, Attribute::AttrKind Kind) const; bool dataOperandHasImpliedAttr(unsigned i, Attribute::AttrKind Kind) const;
/// Extract the alignment for a call or parameter (0=unknown). /// Extract the alignment for a call or parameter (0=unknown).
unsigned getParamAlignment(unsigned i) const { unsigned getParamAlignment(unsigned i) const {
return AttributeList.getParamAlignment(i); return Attrs.getParamAlignment(i);
} }
/// Extract the number of dereferenceable bytes for a call or /// Extract the number of dereferenceable bytes for a call or
/// parameter (0=unknown). /// parameter (0=unknown).
uint64_t getDereferenceableBytes(unsigned i) const { uint64_t getDereferenceableBytes(unsigned i) const {
return AttributeList.getDereferenceableBytes(i); return Attrs.getDereferenceableBytes(i);
} }
/// Extract the number of dereferenceable_or_null bytes for a call or /// Extract the number of dereferenceable_or_null bytes for a call or
/// parameter (0=unknown). /// parameter (0=unknown).
uint64_t getDereferenceableOrNullBytes(unsigned i) const { uint64_t getDereferenceableOrNullBytes(unsigned i) const {
return AttributeList.getDereferenceableOrNullBytes(i); return Attrs.getDereferenceableOrNullBytes(i);
} }
/// @brief Determine if the parameter or return value is marked with NoAlias /// @brief Determine if the parameter or return value is marked with NoAlias
/// attribute. /// attribute.
/// @param n The parameter to check. 1 is the first parameter, 0 is the return /// @param n The parameter to check. 1 is the first parameter, 0 is the return
bool doesNotAlias(unsigned n) const { bool doesNotAlias(unsigned n) const {
return AttributeList.hasAttribute(n, Attribute::NoAlias); return Attrs.hasAttribute(n, Attribute::NoAlias);
} }
/// Return true if the call should not be treated as a call to a /// Return true if the call should not be treated as a call to a
/// builtin. /// builtin.
bool isNoBuiltin() const { bool isNoBuiltin() const {
return hasFnAttrImpl(Attribute::NoBuiltin) && return hasFnAttrImpl(Attribute::NoBuiltin) &&
!hasFnAttrImpl(Attribute::Builtin); !hasFnAttrImpl(Attribute::Builtin);
} }
/// Return true if the call should not be inlined. /// Return true if the call should not be inlined.
bool isNoInline() const { return hasFnAttr(Attribute::NoInline); } bool isNoInline() const { return hasFnAttr(Attribute::NoInline); }
void setIsNoInline() { void setIsNoInline() {
addAttribute(AttributeSet::FunctionIndex, Attribute::NoInline); addAttribute(AttributeList::FunctionIndex, Attribute::NoInline);
} }
/// Return true if the call can return twice /// Return true if the call can return twice
bool canReturnTwice() const { bool canReturnTwice() const {
return hasFnAttr(Attribute::ReturnsTwice); return hasFnAttr(Attribute::ReturnsTwice);
} }
void setCanReturnTwice() { void setCanReturnTwice() {
addAttribute(AttributeSet::FunctionIndex, Attribute::ReturnsTwice); addAttribute(AttributeList::FunctionIndex, Attribute::ReturnsTwice);
} }
/// Determine if the call does not access memory. /// Determine if the call does not access memory.
bool doesNotAccessMemory() const { bool doesNotAccessMemory() const {
return hasFnAttr(Attribute::ReadNone); return hasFnAttr(Attribute::ReadNone);
} }
void setDoesNotAccessMemory() { void setDoesNotAccessMemory() {
addAttribute(AttributeSet::FunctionIndex, Attribute::ReadNone); addAttribute(AttributeList::FunctionIndex, Attribute::ReadNone);
} }
/// Determine if the call does not access or only reads memory. /// Determine if the call does not access or only reads memory.
bool onlyReadsMemory() const { bool onlyReadsMemory() const {
return doesNotAccessMemory() || hasFnAttr(Attribute::ReadOnly); return doesNotAccessMemory() || hasFnAttr(Attribute::ReadOnly);
} }
void setOnlyReadsMemory() { void setOnlyReadsMemory() {
addAttribute(AttributeSet::FunctionIndex, Attribute::ReadOnly); addAttribute(AttributeList::FunctionIndex, Attribute::ReadOnly);
} }
/// Determine if the call does not access or only writes memory. /// Determine if the call does not access or only writes memory.
bool doesNotReadMemory() const { bool doesNotReadMemory() const {
return doesNotAccessMemory() || hasFnAttr(Attribute::WriteOnly); return doesNotAccessMemory() || hasFnAttr(Attribute::WriteOnly);
} }
void setDoesNotReadMemory() { void setDoesNotReadMemory() {
addAttribute(AttributeSet::FunctionIndex, Attribute::WriteOnly); addAttribute(AttributeList::FunctionIndex, Attribute::WriteOnly);
} }
/// @brief Determine if the call can access memmory only using pointers based /// @brief Determine if the call can access memmory only using pointers based
/// on its arguments. /// on its arguments.
bool onlyAccessesArgMemory() const { bool onlyAccessesArgMemory() const {
return hasFnAttr(Attribute::ArgMemOnly); return hasFnAttr(Attribute::ArgMemOnly);
} }
void setOnlyAccessesArgMemory() { void setOnlyAccessesArgMemory() {
addAttribute(AttributeSet::FunctionIndex, Attribute::ArgMemOnly); addAttribute(AttributeList::FunctionIndex, Attribute::ArgMemOnly);
} }
/// Determine if the call cannot return. /// Determine if the call cannot return.
bool doesNotReturn() const { return hasFnAttr(Attribute::NoReturn); } bool doesNotReturn() const { return hasFnAttr(Attribute::NoReturn); }
void setDoesNotReturn() { void setDoesNotReturn() {
addAttribute(AttributeSet::FunctionIndex, Attribute::NoReturn); addAttribute(AttributeList::FunctionIndex, Attribute::NoReturn);
} }
/// Determine if the call cannot unwind. /// Determine if the call cannot unwind.
bool doesNotThrow() const { return hasFnAttr(Attribute::NoUnwind); } bool doesNotThrow() const { return hasFnAttr(Attribute::NoUnwind); }
void setDoesNotThrow() { void setDoesNotThrow() {
addAttribute(AttributeSet::FunctionIndex, Attribute::NoUnwind); addAttribute(AttributeList::FunctionIndex, Attribute::NoUnwind);
} }
/// Determine if the call cannot be duplicated. /// Determine if the call cannot be duplicated.
bool cannotDuplicate() const {return hasFnAttr(Attribute::NoDuplicate); } bool cannotDuplicate() const {return hasFnAttr(Attribute::NoDuplicate); }
void setCannotDuplicate() { void setCannotDuplicate() {
addAttribute(AttributeSet::FunctionIndex, Attribute::NoDuplicate); addAttribute(AttributeList::FunctionIndex, Attribute::NoDuplicate);
} }
/// Determine if the call is convergent /// Determine if the call is convergent
bool isConvergent() const { return hasFnAttr(Attribute::Convergent); } bool isConvergent() const { return hasFnAttr(Attribute::Convergent); }
void setConvergent() { void setConvergent() {
addAttribute(AttributeSet::FunctionIndex, Attribute::Convergent); addAttribute(AttributeList::FunctionIndex, Attribute::Convergent);
} }
void setNotConvergent() { void setNotConvergent() {
removeAttribute(AttributeSet::FunctionIndex, Attribute::Convergent); removeAttribute(AttributeList::FunctionIndex, Attribute::Convergent);
} }
/// Determine if the call returns a structure through first /// Determine if the call returns a structure through first
/// pointer argument. /// pointer argument.
bool hasStructRetAttr() const { bool hasStructRetAttr() const {
if (getNumArgOperands() == 0) if (getNumArgOperands() == 0)
return false; return false;
// Be friendly and also check the callee. // Be friendly and also check the callee.
return paramHasAttr(1, Attribute::StructRet); return paramHasAttr(1, Attribute::StructRet);
} }
/// Determine if any call argument is an aggregate passed by value. /// Determine if any call argument is an aggregate passed by value.
bool hasByValArgument() const { bool hasByValArgument() const {
return AttributeList.hasAttrSomewhere(Attribute::ByVal); return Attrs.hasAttrSomewhere(Attribute::ByVal);
} }
/// Return the function called, or null if this is an /// Return the function called, or null if this is an
/// indirect function invocation. /// indirect function invocation.
/// ///
Function *getCalledFunction() const { Function *getCalledFunction() const {
return dyn_cast<Function>(Op<-1>()); return dyn_cast<Function>(Op<-1>());
} }
Show All 26 Lines static inline bool classof(const Instruction *I) {
return I->getOpcode() == Instruction::Call; return I->getOpcode() == Instruction::Call;
} }
static inline bool classof(const Value *V) { static inline bool classof(const Value *V) {
return isa<Instruction>(V) && classof(cast<Instruction>(V)); return isa<Instruction>(V) && classof(cast<Instruction>(V));
} }
private: private:
template <typename AttrKind> bool hasFnAttrImpl(AttrKind Kind) const { template <typename AttrKind> bool hasFnAttrImpl(AttrKind Kind) const {
if (AttributeList.hasAttribute(AttributeSet::FunctionIndex, Kind)) if (Attrs.hasAttribute(AttributeList::FunctionIndex, Kind))
return true; return true;
// Operand bundles override attributes on the called function, but don't // Operand bundles override attributes on the called function, but don't
// override attributes directly present on the call instruction. // override attributes directly present on the call instruction.
if (isFnAttrDisallowedByOpBundle(Kind)) if (isFnAttrDisallowedByOpBundle(Kind))
return false; return false;
if (const Function *F = getCalledFunction()) if (const Function *F = getCalledFunction())
return F->getAttributes().hasAttribute(AttributeSet::FunctionIndex, Kind); return F->getAttributes().hasAttribute(AttributeList::FunctionIndex,
Kind);
return false; return false;
} }
// Shadow Instruction::setInstructionSubclassData with a private forwarding // Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it. // method so that subclasses cannot accidentally use it.
void setInstructionSubclassData(unsigned short D) { void setInstructionSubclassData(unsigned short D) {
Instruction::setInstructionSubclassData(D); Instruction::setInstructionSubclassData(D);
} }
▲ Show 20 Lines • Show All 1,581 Lines • ▼ Show 20 Lines
/// Invoke instruction. The SubclassData field is used to hold the /// Invoke instruction. The SubclassData field is used to hold the
/// calling convention of the call. /// calling convention of the call.
/// ///
class InvokeInst : public TerminatorInst, class InvokeInst : public TerminatorInst,
public OperandBundleUser<InvokeInst, User::op_iterator> { public OperandBundleUser<InvokeInst, User::op_iterator> {
friend class OperandBundleUser<InvokeInst, User::op_iterator>; friend class OperandBundleUser<InvokeInst, User::op_iterator>;
AttributeSet AttributeList; AttributeList Attrs;
FunctionType *FTy; FunctionType *FTy;
InvokeInst(const InvokeInst &BI); InvokeInst(const InvokeInst &BI);
/// Construct an InvokeInst given a range of arguments. /// Construct an InvokeInst given a range of arguments.
/// ///
/// Construct an InvokeInst from a range of arguments /// Construct an InvokeInst from a range of arguments
inline InvokeInst(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException, inline InvokeInst(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
▲ Show 20 Lines • Show All 187 Lines • ▼ Show 20 Linespublic:
void setCallingConv(CallingConv::ID CC) { void setCallingConv(CallingConv::ID CC) {
auto ID = static_cast<unsigned>(CC); auto ID = static_cast<unsigned>(CC);
assert(!(ID & ~CallingConv::MaxID) && "Unsupported calling convention"); assert(!(ID & ~CallingConv::MaxID) && "Unsupported calling convention");
setInstructionSubclassData(ID); setInstructionSubclassData(ID);
} }
/// Return the parameter attributes for this invoke. /// Return the parameter attributes for this invoke.
/// ///
AttributeSet getAttributes() const { return AttributeList; } AttributeList getAttributes() const { return Attrs; }
/// Set the parameter attributes for this invoke. /// Set the parameter attributes for this invoke.
/// ///
void setAttributes(AttributeSet Attrs) { AttributeList = Attrs; } void setAttributes(AttributeList A) { Attrs = A; }
/// adds the attribute to the list of attributes. /// adds the attribute to the list of attributes.
void addAttribute(unsigned i, Attribute::AttrKind Kind); void addAttribute(unsigned i, Attribute::AttrKind Kind);
/// adds the attribute to the list of attributes. /// adds the attribute to the list of attributes.
void addAttribute(unsigned i, Attribute Attr); void addAttribute(unsigned i, Attribute Attr);
/// removes the attribute from the list of attributes. /// removes the attribute from the list of attributes.
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Linespublic:
/// \p i == Attribute::ReturnIndex -> the return value /// \p i == Attribute::ReturnIndex -> the return value
/// \p i in [1, arg_size + 1) -> argument number (\p i - 1) /// \p i in [1, arg_size + 1) -> argument number (\p i - 1)
/// \p i in [arg_size + 1, data_operand_size + 1) -> bundle operand at index /// \p i in [arg_size + 1, data_operand_size + 1) -> bundle operand at index
/// (\p i - 1) in the operand list. /// (\p i - 1) in the operand list.
bool dataOperandHasImpliedAttr(unsigned i, Attribute::AttrKind Kind) const; bool dataOperandHasImpliedAttr(unsigned i, Attribute::AttrKind Kind) const;
/// Extract the alignment for a call or parameter (0=unknown). /// Extract the alignment for a call or parameter (0=unknown).
unsigned getParamAlignment(unsigned i) const { unsigned getParamAlignment(unsigned i) const {
return AttributeList.getParamAlignment(i); return Attrs.getParamAlignment(i);
} }
/// Extract the number of dereferenceable bytes for a call or /// Extract the number of dereferenceable bytes for a call or
/// parameter (0=unknown). /// parameter (0=unknown).
uint64_t getDereferenceableBytes(unsigned i) const { uint64_t getDereferenceableBytes(unsigned i) const {
return AttributeList.getDereferenceableBytes(i); return Attrs.getDereferenceableBytes(i);
} }
/// Extract the number of dereferenceable_or_null bytes for a call or /// Extract the number of dereferenceable_or_null bytes for a call or
/// parameter (0=unknown). /// parameter (0=unknown).
uint64_t getDereferenceableOrNullBytes(unsigned i) const { uint64_t getDereferenceableOrNullBytes(unsigned i) const {
return AttributeList.getDereferenceableOrNullBytes(i); return Attrs.getDereferenceableOrNullBytes(i);
} }
/// @brief Determine if the parameter or return value is marked with NoAlias /// @brief Determine if the parameter or return value is marked with NoAlias
/// attribute. /// attribute.
/// @param n The parameter to check. 1 is the first parameter, 0 is the return /// @param n The parameter to check. 1 is the first parameter, 0 is the return
bool doesNotAlias(unsigned n) const { bool doesNotAlias(unsigned n) const {
return AttributeList.hasAttribute(n, Attribute::NoAlias); return Attrs.hasAttribute(n, Attribute::NoAlias);
} }
/// Return true if the call should not be treated as a call to a /// Return true if the call should not be treated as a call to a
/// builtin. /// builtin.
bool isNoBuiltin() const { bool isNoBuiltin() const {
// We assert in hasFnAttr if one passes in Attribute::NoBuiltin, so we have // We assert in hasFnAttr if one passes in Attribute::NoBuiltin, so we have
// to check it by hand. // to check it by hand.
return hasFnAttrImpl(Attribute::NoBuiltin) && return hasFnAttrImpl(Attribute::NoBuiltin) &&
!hasFnAttrImpl(Attribute::Builtin); !hasFnAttrImpl(Attribute::Builtin);
} }
/// Return true if the call should not be inlined. /// Return true if the call should not be inlined.
bool isNoInline() const { return hasFnAttr(Attribute::NoInline); } bool isNoInline() const { return hasFnAttr(Attribute::NoInline); }
void setIsNoInline() { void setIsNoInline() {
addAttribute(AttributeSet::FunctionIndex, Attribute::NoInline); addAttribute(AttributeList::FunctionIndex, Attribute::NoInline);
} }
/// Determine if the call does not access memory. /// Determine if the call does not access memory.
bool doesNotAccessMemory() const { bool doesNotAccessMemory() const {
return hasFnAttr(Attribute::ReadNone); return hasFnAttr(Attribute::ReadNone);
} }
void setDoesNotAccessMemory() { void setDoesNotAccessMemory() {
addAttribute(AttributeSet::FunctionIndex, Attribute::ReadNone); addAttribute(AttributeList::FunctionIndex, Attribute::ReadNone);
} }
/// Determine if the call does not access or only reads memory. /// Determine if the call does not access or only reads memory.
bool onlyReadsMemory() const { bool onlyReadsMemory() const {
return doesNotAccessMemory() || hasFnAttr(Attribute::ReadOnly); return doesNotAccessMemory() || hasFnAttr(Attribute::ReadOnly);
} }
void setOnlyReadsMemory() { void setOnlyReadsMemory() {
addAttribute(AttributeSet::FunctionIndex, Attribute::ReadOnly); addAttribute(AttributeList::FunctionIndex, Attribute::ReadOnly);
} }
/// Determine if the call does not access or only writes memory. /// Determine if the call does not access or only writes memory.
bool doesNotReadMemory() const { bool doesNotReadMemory() const {
return doesNotAccessMemory() || hasFnAttr(Attribute::WriteOnly); return doesNotAccessMemory() || hasFnAttr(Attribute::WriteOnly);
} }
void setDoesNotReadMemory() { void setDoesNotReadMemory() {
addAttribute(AttributeSet::FunctionIndex, Attribute::WriteOnly); addAttribute(AttributeList::FunctionIndex, Attribute::WriteOnly);
} }
/// @brief Determine if the call access memmory only using it's pointer /// @brief Determine if the call access memmory only using it's pointer
/// arguments. /// arguments.
bool onlyAccessesArgMemory() const { bool onlyAccessesArgMemory() const {
return hasFnAttr(Attribute::ArgMemOnly); return hasFnAttr(Attribute::ArgMemOnly);
} }
void setOnlyAccessesArgMemory() { void setOnlyAccessesArgMemory() {
addAttribute(AttributeSet::FunctionIndex, Attribute::ArgMemOnly); addAttribute(AttributeList::FunctionIndex, Attribute::ArgMemOnly);
} }
/// Determine if the call cannot return. /// Determine if the call cannot return.
bool doesNotReturn() const { return hasFnAttr(Attribute::NoReturn); } bool doesNotReturn() const { return hasFnAttr(Attribute::NoReturn); }
void setDoesNotReturn() { void setDoesNotReturn() {
addAttribute(AttributeSet::FunctionIndex, Attribute::NoReturn); addAttribute(AttributeList::FunctionIndex, Attribute::NoReturn);
} }
/// Determine if the call cannot unwind. /// Determine if the call cannot unwind.
bool doesNotThrow() const { return hasFnAttr(Attribute::NoUnwind); } bool doesNotThrow() const { return hasFnAttr(Attribute::NoUnwind); }
void setDoesNotThrow() { void setDoesNotThrow() {
addAttribute(AttributeSet::FunctionIndex, Attribute::NoUnwind); addAttribute(AttributeList::FunctionIndex, Attribute::NoUnwind);
} }
/// Determine if the invoke cannot be duplicated. /// Determine if the invoke cannot be duplicated.
bool cannotDuplicate() const {return hasFnAttr(Attribute::NoDuplicate); } bool cannotDuplicate() const {return hasFnAttr(Attribute::NoDuplicate); }
void setCannotDuplicate() { void setCannotDuplicate() {
addAttribute(AttributeSet::FunctionIndex, Attribute::NoDuplicate); addAttribute(AttributeList::FunctionIndex, Attribute::NoDuplicate);
} }
/// Determine if the invoke is convergent /// Determine if the invoke is convergent
bool isConvergent() const { return hasFnAttr(Attribute::Convergent); } bool isConvergent() const { return hasFnAttr(Attribute::Convergent); }
void setConvergent() { void setConvergent() {
addAttribute(AttributeSet::FunctionIndex, Attribute::Convergent); addAttribute(AttributeList::FunctionIndex, Attribute::Convergent);
} }
void setNotConvergent() { void setNotConvergent() {
removeAttribute(AttributeSet::FunctionIndex, Attribute::Convergent); removeAttribute(AttributeList::FunctionIndex, Attribute::Convergent);
} }
/// Determine if the call returns a structure through first /// Determine if the call returns a structure through first
/// pointer argument. /// pointer argument.
bool hasStructRetAttr() const { bool hasStructRetAttr() const {
if (getNumArgOperands() == 0) if (getNumArgOperands() == 0)
return false; return false;
// Be friendly and also check the callee. // Be friendly and also check the callee.
return paramHasAttr(1, Attribute::StructRet); return paramHasAttr(1, Attribute::StructRet);
} }
/// Determine if any call argument is an aggregate passed by value. /// Determine if any call argument is an aggregate passed by value.
bool hasByValArgument() const { bool hasByValArgument() const {
return AttributeList.hasAttrSomewhere(Attribute::ByVal); return Attrs.hasAttrSomewhere(Attribute::ByVal);
} }
/// Return the function called, or null if this is an /// Return the function called, or null if this is an
/// indirect function invocation. /// indirect function invocation.
/// ///
Function *getCalledFunction() const { Function *getCalledFunction() const {
return dyn_cast<Function>(Op<-3>()); return dyn_cast<Function>(Op<-3>());
} }
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Linespublic:
} }
private: private:
BasicBlock *getSuccessorV(unsigned idx) const override; BasicBlock *getSuccessorV(unsigned idx) const override;
unsigned getNumSuccessorsV() const override; unsigned getNumSuccessorsV() const override;
void setSuccessorV(unsigned idx, BasicBlock *B) override; void setSuccessorV(unsigned idx, BasicBlock *B) override;
template <typename AttrKind> bool hasFnAttrImpl(AttrKind Kind) const { template <typename AttrKind> bool hasFnAttrImpl(AttrKind Kind) const {
if (AttributeList.hasAttribute(AttributeSet::FunctionIndex, Kind)) if (Attrs.hasAttribute(AttributeList::FunctionIndex, Kind))
return true; return true;
// Operand bundles override attributes on the called function, but don't // Operand bundles override attributes on the called function, but don't
// override attributes directly present on the invoke instruction. // override attributes directly present on the invoke instruction.
if (isFnAttrDisallowedByOpBundle(Kind)) if (isFnAttrDisallowedByOpBundle(Kind))
return false; return false;
if (const Function *F = getCalledFunction()) if (const Function *F = getCalledFunction())
return F->getAttributes().hasAttribute(AttributeSet::FunctionIndex, Kind); return F->getAttributes().hasAttribute(AttributeList::FunctionIndex,
Kind);
return false; return false;
} }
// Shadow Instruction::setInstructionSubclassData with a private forwarding // Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it. // method so that subclasses cannot accidentally use it.
void setInstructionSubclassData(unsigned short D) { void setInstructionSubclassData(unsigned short D) {
Instruction::setInstructionSubclassData(D); Instruction::setInstructionSubclassData(D);
} }
▲ Show 20 Lines • Show All 1,123 Lines • Show Last 20 Lines

llvm/trunk/include/llvm/IR/Intrinsics.h

Show All 22 Lines
namespace llvm { namespace llvm {
class Type; class Type;
class FunctionType; class FunctionType;
class Function; class Function;
class LLVMContext; class LLVMContext;
class Module; class Module;
class AttributeSet; class AttributeList;
/// This namespace contains an enum with a value for every intrinsic/builtin /// This namespace contains an enum with a value for every intrinsic/builtin
/// function known by LLVM. The enum values are returned by /// function known by LLVM. The enum values are returned by
/// Function::getIntrinsicID(). /// Function::getIntrinsicID().
namespace Intrinsic { namespace Intrinsic {
enum ID : unsigned { enum ID : unsigned {
not_intrinsic = 0, // Must be zero not_intrinsic = 0, // Must be zero
Show All 24 Lines#undef GET_INTRINSIC_ENUM_VALUES
bool isOverloaded(ID id); bool isOverloaded(ID id);
/// Returns true if the intrinsic is a leaf, i.e. it does not make any calls /// Returns true if the intrinsic is a leaf, i.e. it does not make any calls
/// itself. Most intrinsics are leafs, the exceptions being the patchpoint /// itself. Most intrinsics are leafs, the exceptions being the patchpoint
/// and statepoint intrinsics. These call (or invoke) their "target" argument. /// and statepoint intrinsics. These call (or invoke) their "target" argument.
bool isLeaf(ID id); bool isLeaf(ID id);
/// Return the attributes for an intrinsic. /// Return the attributes for an intrinsic.
AttributeSet getAttributes(LLVMContext &C, ID id); AttributeList getAttributes(LLVMContext &C, ID id);
/// Create or insert an LLVM Function declaration for an intrinsic, and return /// Create or insert an LLVM Function declaration for an intrinsic, and return
/// it. /// it.
/// ///
/// The Tys parameter is for intrinsics with overloaded types (e.g., those /// The Tys parameter is for intrinsics with overloaded types (e.g., those
/// using iAny, fAny, vAny, or iPTRAny). For a declaration of an overloaded /// using iAny, fAny, vAny, or iPTRAny). For a declaration of an overloaded
/// intrinsic, Tys must provide exactly one type for each overloaded type in /// intrinsic, Tys must provide exactly one type for each overloaded type in
/// the intrinsic. /// the intrinsic.
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

llvm/trunk/include/llvm/IR/Module.h

Show First 20 Lines • Show All 305 Lines • ▼ Show 20 Lines/// @{
/// 1. If it does not exist, add a prototype for the function and return it. /// 1. If it does not exist, add a prototype for the function and return it.
/// 2. If it exists, and has a local linkage, the existing function is /// 2. If it exists, and has a local linkage, the existing function is
/// renamed and a new one is inserted. /// renamed and a new one is inserted.
/// 3. Otherwise, if the existing function has the correct prototype, return /// 3. Otherwise, if the existing function has the correct prototype, return
/// the existing function. /// the existing function.
/// 4. Finally, the function exists but has the wrong prototype: return the /// 4. Finally, the function exists but has the wrong prototype: return the
/// function with a constantexpr cast to the right prototype. /// function with a constantexpr cast to the right prototype.
Constant *getOrInsertFunction(StringRef Name, FunctionType *T, Constant *getOrInsertFunction(StringRef Name, FunctionType *T,
AttributeSet AttributeList); AttributeList AttributeList);
Constant *getOrInsertFunction(StringRef Name, FunctionType *T); Constant *getOrInsertFunction(StringRef Name, FunctionType *T);
/// Look up the specified function in the module symbol table. If it does not /// Look up the specified function in the module symbol table. If it does not
/// exist, add a prototype for the function and return it. This function /// exist, add a prototype for the function and return it. This function
/// guarantees to return a constant of pointer to the specified function type /// guarantees to return a constant of pointer to the specified function type
/// or a ConstantExpr BitCast of that type if the named function has a /// or a ConstantExpr BitCast of that type if the named function has a
/// different type. This version of the method takes a null terminated list of /// different type. This version of the method takes a null terminated list of
/// function arguments, which makes it easier for clients to use. /// function arguments, which makes it easier for clients to use.
Constant *getOrInsertFunction(StringRef Name, Constant *getOrInsertFunction(StringRef Name, AttributeList AttributeList,
AttributeSet AttributeList,
Type *RetTy, ...) LLVM_END_WITH_NULL; Type *RetTy, ...) LLVM_END_WITH_NULL;
/// Same as above, but without the attributes. /// Same as above, but without the attributes.
Constant *getOrInsertFunction(StringRef Name, Type *RetTy, ...) Constant *getOrInsertFunction(StringRef Name, Type *RetTy, ...)
LLVM_END_WITH_NULL; LLVM_END_WITH_NULL;
/// Look up the specified function in the module symbol table. If it does not /// Look up the specified function in the module symbol table. If it does not
/// exist, return null. /// exist, return null.
▲ Show 20 Lines • Show All 467 Lines • Show Last 20 Lines

llvm/trunk/include/llvm/IR/Statepoint.h

Show First 20 Lines • Show All 448 Lines • ▼ Show 20 Linesstruct StatepointDirectives {
Optional<uint64_t> StatepointID; Optional<uint64_t> StatepointID;
static const uint64_t DefaultStatepointID = 0xABCDEF00; static const uint64_t DefaultStatepointID = 0xABCDEF00;
static const uint64_t DeoptBundleStatepointID = 0xABCDEF0F; static const uint64_t DeoptBundleStatepointID = 0xABCDEF0F;
}; };
/// Parse out statepoint directives from the function attributes present in \p /// Parse out statepoint directives from the function attributes present in \p
/// AS. /// AS.
StatepointDirectives parseStatepointDirectivesFromAttrs(AttributeSet AS); StatepointDirectives parseStatepointDirectivesFromAttrs(AttributeList AS);
/// Return \c true if the the \p Attr is an attribute that is a statepoint /// Return \c true if the the \p Attr is an attribute that is a statepoint
/// directive. /// directive.
bool isStatepointDirectiveAttr(Attribute Attr); bool isStatepointDirectiveAttr(Attribute Attr);
} // end namespace llvm } // end namespace llvm
#endif // LLVM_IR_STATEPOINT_H #endif // LLVM_IR_STATEPOINT_H

llvm/trunk/include/llvm/Target/TargetLowering.h

Show First 20 Lines • Show All 278 Lines • ▼ Show 20 Lines shouldExpandBuildVectorWithShuffles(EVT /* VT */,
unsigned DefinedValues) const { unsigned DefinedValues) const {
return DefinedValues < 3; return DefinedValues < 3;
} }
/// Return true if integer divide is usually cheaper than a sequence of /// Return true if integer divide is usually cheaper than a sequence of
/// several shifts, adds, and multiplies for this target. /// several shifts, adds, and multiplies for this target.
/// The definition of "cheaper" may depend on whether we're optimizing /// The definition of "cheaper" may depend on whether we're optimizing
/// for speed or for size. /// for speed or for size.
virtual bool isIntDivCheap(EVT VT, AttributeSet Attr) const { virtual bool isIntDivCheap(EVT VT, AttributeList Attr) const { return false; }
return false;
}
/// Return true if the target can handle a standalone remainder operation. /// Return true if the target can handle a standalone remainder operation.
virtual bool hasStandaloneRem(EVT VT) const { virtual bool hasStandaloneRem(EVT VT) const {
return true; return true;
} }
/// Return true if SQRT(X) shouldn't be replaced with X*RSQRT(X). /// Return true if SQRT(X) shouldn't be replaced with X*RSQRT(X).
virtual bool isFsqrtCheap(SDValue X, SelectionDAG &DAG) const { virtual bool isFsqrtCheap(SDValue X, SelectionDAG &DAG) const {
▲ Show 20 Lines • Show All 2,914 Lines • ▼ Show 20 Linesprivate:
SDValue simplifySetCCWithAnd(EVT VT, SDValue N0, SDValue N1, SDValue simplifySetCCWithAnd(EVT VT, SDValue N0, SDValue N1,
ISD::CondCode Cond, DAGCombinerInfo &DCI, ISD::CondCode Cond, DAGCombinerInfo &DCI,
const SDLoc &DL) const; const SDLoc &DL) const;
}; };
/// Given an LLVM IR type and return type attributes, compute the return value /// Given an LLVM IR type and return type attributes, compute the return value
/// EVTs and flags, and optionally also the offsets, if the return value is /// EVTs and flags, and optionally also the offsets, if the return value is
/// being lowered to memory. /// being lowered to memory.
void GetReturnInfo(Type *ReturnType, AttributeSet attr, void GetReturnInfo(Type *ReturnType, AttributeList attr,
SmallVectorImpl<ISD::OutputArg> &Outs, SmallVectorImpl<ISD::OutputArg> &Outs,
const TargetLowering &TLI, const DataLayout &DL); const TargetLowering &TLI, const DataLayout &DL);
} // end namespace llvm } // end namespace llvm
#endif // LLVM_TARGET_TARGETLOWERING_H #endif // LLVM_TARGET_TARGETLOWERING_H

llvm/trunk/include/llvm/Transforms/Utils/BuildLibCalls.h

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Linesnamespace llvm {
Value *emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B, Value *emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
const DataLayout &DL, const TargetLibraryInfo *TLI); const DataLayout &DL, const TargetLibraryInfo *TLI);
/// Emit a call to the unary function named 'Name' (e.g. 'floor'). This /// Emit a call to the unary function named 'Name' (e.g. 'floor'). This
/// function is known to take a single of type matching 'Op' and returns one /// function is known to take a single of type matching 'Op' and returns one
/// value with the same type. If 'Op' is a long double, 'l' is added as the /// value with the same type. If 'Op' is a long double, 'l' is added as the
/// suffix of name, if 'Op' is a float, we add a 'f' suffix. /// suffix of name, if 'Op' is a float, we add a 'f' suffix.
Value *emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilder<> &B, Value *emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilder<> &B,
const AttributeSet &Attrs); const AttributeList &Attrs);
/// Emit a call to the binary function named 'Name' (e.g. 'fmin'). This /// Emit a call to the binary function named 'Name' (e.g. 'fmin'). This
/// function is known to take type matching 'Op1' and 'Op2' and return one /// function is known to take type matching 'Op1' and 'Op2' and return one
/// value with the same type. If 'Op1/Op2' are long double, 'l' is added as /// value with the same type. If 'Op1/Op2' are long double, 'l' is added as
/// the suffix of name, if 'Op1/Op2' are float, we add a 'f' suffix. /// the suffix of name, if 'Op1/Op2' are float, we add a 'f' suffix.
Value *emitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name, Value *emitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name,
IRBuilder<> &B, const AttributeSet &Attrs); IRBuilder<> &B, const AttributeList &Attrs);
/// Emit a call to the putchar function. This assumes that Char is an integer. /// Emit a call to the putchar function. This assumes that Char is an integer.
Value *emitPutChar(Value *Char, IRBuilder<> &B, const TargetLibraryInfo *TLI); Value *emitPutChar(Value *Char, IRBuilder<> &B, const TargetLibraryInfo *TLI);
/// Emit a call to the puts function. This assumes that Str is some pointer. /// Emit a call to the puts function. This assumes that Str is some pointer.
Value *emitPutS(Value *Str, IRBuilder<> &B, const TargetLibraryInfo *TLI); Value *emitPutS(Value *Str, IRBuilder<> &B, const TargetLibraryInfo *TLI);
/// Emit a call to the fputc function. This assumes that Char is an i32, and /// Emit a call to the fputc function. This assumes that Char is an i32, and
Show All 16 Lines

llvm/trunk/include/llvm/Transforms/Utils/FunctionComparator.h

Show First 20 Lines • Show All 308 Lines • ▼ Show 20 Linesprotected:
int cmpMem(StringRef L, StringRef R) const; int cmpMem(StringRef L, StringRef R) const;
// The two functions undergoing comparison. // The two functions undergoing comparison.
const Function *FnL, *FnR; const Function *FnL, *FnR;
private: private:
int cmpOrderings(AtomicOrdering L, AtomicOrdering R) const; int cmpOrderings(AtomicOrdering L, AtomicOrdering R) const;
int cmpInlineAsm(const InlineAsm *L, const InlineAsm *R) const; int cmpInlineAsm(const InlineAsm *L, const InlineAsm *R) const;
int cmpAttrs(const AttributeSet L, const AttributeSet R) const; int cmpAttrs(const AttributeList L, const AttributeList R) const;
int cmpRangeMetadata(const MDNode *L, const MDNode *R) const; int cmpRangeMetadata(const MDNode *L, const MDNode *R) const;
int cmpOperandBundlesSchema(const Instruction *L, const Instruction *R) const; int cmpOperandBundlesSchema(const Instruction *L, const Instruction *R) const;
/// Compare two GEPs for equivalent pointer arithmetic. /// Compare two GEPs for equivalent pointer arithmetic.
/// Parts to be compared for each comparison stage, /// Parts to be compared for each comparison stage,
/// most significant stage first: /// most significant stage first:
/// 1. Address space. As numbers. /// 1. Address space. As numbers.
/// 2. Constant offset, (using GEPOperator::accumulateConstantOffset method). /// 2. Constant offset, (using GEPOperator::accumulateConstantOffset method).
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

llvm/trunk/lib/Analysis/MemoryBuiltins.cpp

Show First 20 Lines • Show All 177 Lines • ▼ Show 20 Linesstatic Optional<AllocFnsTy> getAllocationSize(const Value *V,
Result.NumParams = Callee->getNumOperands(); Result.NumParams = Callee->getNumOperands();
Result.FstParam = Args.first; Result.FstParam = Args.first;
Result.SndParam = Args.second.getValueOr(-1); Result.SndParam = Args.second.getValueOr(-1);
return Result; return Result;
} }
static bool hasNoAliasAttr(const Value *V, bool LookThroughBitCast) { static bool hasNoAliasAttr(const Value *V, bool LookThroughBitCast) {
ImmutableCallSite CS(LookThroughBitCast ? V->stripPointerCasts() : V); ImmutableCallSite CS(LookThroughBitCast ? V->stripPointerCasts() : V);
return CS && CS.paramHasAttr(AttributeSet::ReturnIndex, Attribute::NoAlias); return CS && CS.paramHasAttr(AttributeList::ReturnIndex, Attribute::NoAlias);
} }
/// \brief Tests if a value is a call or invoke to a library function that /// \brief Tests if a value is a call or invoke to a library function that
/// allocates or reallocates memory (either malloc, calloc, realloc, or strdup /// allocates or reallocates memory (either malloc, calloc, realloc, or strdup
/// like). /// like).
bool llvm::isAllocationFn(const Value *V, const TargetLibraryInfo *TLI, bool llvm::isAllocationFn(const Value *V, const TargetLibraryInfo *TLI,
bool LookThroughBitCast) { bool LookThroughBitCast) {
▲ Show 20 Lines • Show All 707 Lines • Show Last 20 Lines

llvm/trunk/lib/AsmParser/LLParser.h

Show First 20 Lines • Show All 385 Lines • ▼ Show 20 Lines bool ParseTypeAndBasicBlock(BasicBlock *&BB, PerFunctionState &PFS) {
LocTy Loc; LocTy Loc;
return ParseTypeAndBasicBlock(BB, Loc, PFS); return ParseTypeAndBasicBlock(BB, Loc, PFS);
} }
struct ParamInfo { struct ParamInfo {
LocTy Loc; LocTy Loc;
Value *V; Value *V;
AttributeSet Attrs; AttributeList Attrs;
ParamInfo(LocTy loc, Value *v, AttributeSet attrs) ParamInfo(LocTy loc, Value *v, AttributeList attrs)
: Loc(loc), V(v), Attrs(attrs) {} : Loc(loc), V(v), Attrs(attrs) {}
}; };
bool ParseParameterList(SmallVectorImpl<ParamInfo> &ArgList, bool ParseParameterList(SmallVectorImpl<ParamInfo> &ArgList,
PerFunctionState &PFS, PerFunctionState &PFS,
bool IsMustTailCall = false, bool IsMustTailCall = false,
bool InVarArgsFunc = false); bool InVarArgsFunc = false);
bool bool
ParseOptionalOperandBundles(SmallVectorImpl<OperandBundleDef> &BundleList, ParseOptionalOperandBundles(SmallVectorImpl<OperandBundleDef> &BundleList,
Show All 34 Lines
#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \ #define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \
bool Parse##CLASS(MDNode *&Result, bool IsDistinct); bool Parse##CLASS(MDNode *&Result, bool IsDistinct);
#include "llvm/IR/Metadata.def" #include "llvm/IR/Metadata.def"
// Function Parsing. // Function Parsing.
struct ArgInfo { struct ArgInfo {
LocTy Loc; LocTy Loc;
Type *Ty; Type *Ty;
AttributeSet Attrs; AttributeList Attrs;
std::string Name; std::string Name;
ArgInfo(LocTy L, Type *ty, AttributeSet Attr, const std::string &N) ArgInfo(LocTy L, Type *ty, AttributeList Attr, const std::string &N)
: Loc(L), Ty(ty), Attrs(Attr), Name(N) {} : Loc(L), Ty(ty), Attrs(Attr), Name(N) {}
}; };
bool ParseArgumentList(SmallVectorImpl<ArgInfo> &ArgList, bool &isVarArg); bool ParseArgumentList(SmallVectorImpl<ArgInfo> &ArgList, bool &isVarArg);
bool ParseFunctionHeader(Function *&Fn, bool isDefine); bool ParseFunctionHeader(Function *&Fn, bool isDefine);
bool ParseFunctionBody(Function &Fn); bool ParseFunctionBody(Function &Fn);
bool ParseBasicBlock(PerFunctionState &PFS); bool ParseBasicBlock(PerFunctionState &PFS);
enum TailCallType { TCT_None, TCT_Tail, TCT_MustTail }; enum TailCallType { TCT_None, TCT_Tail, TCT_MustTail };
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

llvm/trunk/lib/AsmParser/LLParser.cpp

Show First 20 Lines • Show All 124 Lines • ▼ Show 20 Lines for (const auto &RAG : ForwardRefAttrGroups) {
Value *V = RAG.first; Value *V = RAG.first;
const std::vector<unsigned> &Attrs = RAG.second; const std::vector<unsigned> &Attrs = RAG.second;
AttrBuilder B; AttrBuilder B;
for (const auto &Attr : Attrs) for (const auto &Attr : Attrs)
B.merge(NumberedAttrBuilders[Attr]); B.merge(NumberedAttrBuilders[Attr]);
if (Function *Fn = dyn_cast<Function>(V)) { if (Function *Fn = dyn_cast<Function>(V)) {
AttributeSet AS = Fn->getAttributes(); AttributeList AS = Fn->getAttributes();
AttrBuilder FnAttrs(AS.getFnAttributes(), AttributeSet::FunctionIndex); AttrBuilder FnAttrs(AS.getFnAttributes(), AttributeList::FunctionIndex);
AS = AS.removeAttributes(Context, AttributeSet::FunctionIndex, AS = AS.removeAttributes(Context, AttributeList::FunctionIndex,
AS.getFnAttributes()); AS.getFnAttributes());
FnAttrs.merge(B); FnAttrs.merge(B);
// If the alignment was parsed as an attribute, move to the alignment // If the alignment was parsed as an attribute, move to the alignment
// field. // field.
if (FnAttrs.hasAlignmentAttr()) { if (FnAttrs.hasAlignmentAttr()) {
Fn->setAlignment(FnAttrs.getAlignment()); Fn->setAlignment(FnAttrs.getAlignment());
FnAttrs.removeAttribute(Attribute::Alignment); FnAttrs.removeAttribute(Attribute::Alignment);
} }
AS = AS.addAttributes(Context, AttributeSet::FunctionIndex, AS = AS.addAttributes(
AttributeSet::get(Context, Context, AttributeList::FunctionIndex,
AttributeSet::FunctionIndex, AttributeList::get(Context, AttributeList::FunctionIndex, FnAttrs));
FnAttrs));
Fn->setAttributes(AS); Fn->setAttributes(AS);
} else if (CallInst *CI = dyn_cast<CallInst>(V)) { } else if (CallInst *CI = dyn_cast<CallInst>(V)) {
AttributeSet AS = CI->getAttributes(); AttributeList AS = CI->getAttributes();
AttrBuilder FnAttrs(AS.getFnAttributes(), AttributeSet::FunctionIndex); AttrBuilder FnAttrs(AS.getFnAttributes(), AttributeList::FunctionIndex);
AS = AS.removeAttributes(Context, AttributeSet::FunctionIndex, AS = AS.removeAttributes(Context, AttributeList::FunctionIndex,
AS.getFnAttributes()); AS.getFnAttributes());
FnAttrs.merge(B); FnAttrs.merge(B);
AS = AS.addAttributes(Context, AttributeSet::FunctionIndex, AS = AS.addAttributes(
AttributeSet::get(Context, Context, AttributeList::FunctionIndex,
AttributeSet::FunctionIndex, AttributeList::get(Context, AttributeList::FunctionIndex, FnAttrs));
FnAttrs));
CI->setAttributes(AS); CI->setAttributes(AS);
} else if (InvokeInst *II = dyn_cast<InvokeInst>(V)) { } else if (InvokeInst *II = dyn_cast<InvokeInst>(V)) {
AttributeSet AS = II->getAttributes(); AttributeList AS = II->getAttributes();
AttrBuilder FnAttrs(AS.getFnAttributes(), AttributeSet::FunctionIndex); AttrBuilder FnAttrs(AS.getFnAttributes(), AttributeList::FunctionIndex);
AS = AS.removeAttributes(Context, AttributeSet::FunctionIndex, AS = AS.removeAttributes(Context, AttributeList::FunctionIndex,
AS.getFnAttributes()); AS.getFnAttributes());
FnAttrs.merge(B); FnAttrs.merge(B);
AS = AS.addAttributes(Context, AttributeSet::FunctionIndex, AS = AS.addAttributes(
AttributeSet::get(Context, Context, AttributeList::FunctionIndex,
AttributeSet::FunctionIndex, AttributeList::get(Context, AttributeList::FunctionIndex, FnAttrs));
FnAttrs));
II->setAttributes(AS); II->setAttributes(AS);
} else { } else {
llvm_unreachable("invalid object with forward attribute group reference"); llvm_unreachable("invalid object with forward attribute group reference");
} }
} }
// If there are entries in ForwardRefBlockAddresses at this point, the // If there are entries in ForwardRefBlockAddresses at this point, the
// function was never defined. // function was never defined.
▲ Show 20 Lines • Show All 1,946 Lines • ▼ Show 20 Lines while (Lex.getKind() != lltok::rparen) {
if (ArgTy->isMetadataTy()) { if (ArgTy->isMetadataTy()) {
if (ParseMetadataAsValue(V, PFS)) if (ParseMetadataAsValue(V, PFS))
return true; return true;
} else { } else {
// Otherwise, handle normal operands. // Otherwise, handle normal operands.
if (ParseOptionalParamAttrs(ArgAttrs) || ParseValue(ArgTy, V, PFS)) if (ParseOptionalParamAttrs(ArgAttrs) || ParseValue(ArgTy, V, PFS))
return true; return true;
} }
ArgList.push_back(ParamInfo(ArgLoc, V, AttributeSet::get(V->getContext(), ArgList.push_back(ParamInfo(
AttrIndex++, ArgLoc, V, AttributeList::get(V->getContext(), AttrIndex++, ArgAttrs)));
ArgAttrs)));
} }
if (IsMustTailCall && InVarArgsFunc) if (IsMustTailCall && InVarArgsFunc)
return TokError("expected '...' at end of argument list for musttail call " return TokError("expected '...' at end of argument list for musttail call "
"in varargs function"); "in varargs function");
Lex.Lex(); // Lex the ')'. Lex.Lex(); // Lex the ')'.
return false; return false;
▲ Show 20 Lines • Show All 89 Lines • ▼ Show 20 Lines if (Lex.getKind() == lltok::LocalVar) {
Name = Lex.getStrVal(); Name = Lex.getStrVal();
Lex.Lex(); Lex.Lex();
} }
if (!FunctionType::isValidArgumentType(ArgTy)) if (!FunctionType::isValidArgumentType(ArgTy))
return Error(TypeLoc, "invalid type for function argument"); return Error(TypeLoc, "invalid type for function argument");
unsigned AttrIndex = 1; unsigned AttrIndex = 1;
ArgList.emplace_back(TypeLoc, ArgTy, AttributeSet::get(ArgTy->getContext(), ArgList.emplace_back(TypeLoc, ArgTy, AttributeList::get(ArgTy->getContext(),
AttrIndex++, Attrs), AttrIndex++, Attrs),
std::move(Name)); std::move(Name));
while (EatIfPresent(lltok::comma)) { while (EatIfPresent(lltok::comma)) {
// Handle ... at end of arg list. // Handle ... at end of arg list.
if (EatIfPresent(lltok::dotdotdot)) { if (EatIfPresent(lltok::dotdotdot)) {
isVarArg = true; isVarArg = true;
break; break;
} }
Show All 12 Lines while (EatIfPresent(lltok::comma)) {
Name = ""; Name = "";
} }
if (!ArgTy->isFirstClassType()) if (!ArgTy->isFirstClassType())
return Error(TypeLoc, "invalid type for function argument"); return Error(TypeLoc, "invalid type for function argument");
ArgList.emplace_back( ArgList.emplace_back(
TypeLoc, ArgTy, TypeLoc, ArgTy,
AttributeSet::get(ArgTy->getContext(), AttrIndex++, Attrs), AttributeList::get(ArgTy->getContext(), AttrIndex++, Attrs),
std::move(Name)); std::move(Name));
} }
} }
return ParseToken(lltok::rparen, "expected ')' at end of argument list"); return ParseToken(lltok::rparen, "expected ')' at end of argument list");
} }
/// ParseFunctionType /// ParseFunctionType
▲ Show 20 Lines • Show All 2,454 Lines • ▼ Show 20 Linesbool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
if (FuncAttrs.hasAlignmentAttr()) { if (FuncAttrs.hasAlignmentAttr()) {
Alignment = FuncAttrs.getAlignment(); Alignment = FuncAttrs.getAlignment();
FuncAttrs.removeAttribute(Attribute::Alignment); FuncAttrs.removeAttribute(Attribute::Alignment);
} }
// Okay, if we got here, the function is syntactically valid. Convert types // Okay, if we got here, the function is syntactically valid. Convert types
// and do semantic checks. // and do semantic checks.
std::vector<Type*> ParamTypeList; std::vector<Type*> ParamTypeList;
SmallVector<AttributeSet, 8> Attrs; SmallVector<AttributeList, 8> Attrs;
if (RetAttrs.hasAttributes()) if (RetAttrs.hasAttributes())
Attrs.push_back(AttributeSet::get(RetType->getContext(), Attrs.push_back(AttributeList::get(RetType->getContext(),
AttributeSet::ReturnIndex, AttributeList::ReturnIndex, RetAttrs));
RetAttrs));
for (unsigned i = 0, e = ArgList.size(); i != e; ++i) { for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
ParamTypeList.push_back(ArgList[i].Ty); ParamTypeList.push_back(ArgList[i].Ty);
if (ArgList[i].Attrs.hasAttributes(i + 1)) { if (ArgList[i].Attrs.hasAttributes(i + 1)) {
AttrBuilder B(ArgList[i].Attrs, i + 1); AttrBuilder B(ArgList[i].Attrs, i + 1);
Attrs.push_back(AttributeSet::get(RetType->getContext(), i + 1, B)); Attrs.push_back(AttributeList::get(RetType->getContext(), i + 1, B));
} }
} }
if (FuncAttrs.hasAttributes()) if (FuncAttrs.hasAttributes())
Attrs.push_back(AttributeSet::get(RetType->getContext(), Attrs.push_back(AttributeList::get(
AttributeSet::FunctionIndex, RetType->getContext(), AttributeList::FunctionIndex, FuncAttrs));
FuncAttrs));
AttributeSet PAL = AttributeSet::get(Context, Attrs); AttributeList PAL = AttributeList::get(Context, Attrs);
if (PAL.hasAttribute(1, Attribute::StructRet) && !RetType->isVoidTy()) if (PAL.hasAttribute(1, Attribute::StructRet) && !RetType->isVoidTy())
return Error(RetTypeLoc, "functions with 'sret' argument must return void"); return Error(RetTypeLoc, "functions with 'sret' argument must return void");
FunctionType *FT = FunctionType *FT =
FunctionType::get(RetType, ParamTypeList, isVarArg); FunctionType::get(RetType, ParamTypeList, isVarArg);
PointerType *PFT = PointerType::getUnqual(FT); PointerType *PFT = PointerType::getUnqual(FT);
▲ Show 20 Lines • Show All 593 Lines • ▼ Show 20 Linesbool LLParser::ParseInvoke(Instruction *&Inst, PerFunctionState &PFS) {
CalleeID.FTy = Ty; CalleeID.FTy = Ty;
// Look up the callee. // Look up the callee.
Value *Callee; Value *Callee;
if (ConvertValIDToValue(PointerType::getUnqual(Ty), CalleeID, Callee, &PFS)) if (ConvertValIDToValue(PointerType::getUnqual(Ty), CalleeID, Callee, &PFS))
return true; return true;
// Set up the Attribute for the function. // Set up the Attribute for the function.
SmallVector<AttributeSet, 8> Attrs; SmallVector<AttributeList, 8> Attrs;
if (RetAttrs.hasAttributes()) if (RetAttrs.hasAttributes())
Attrs.push_back(AttributeSet::get(RetType->getContext(), Attrs.push_back(AttributeList::get(RetType->getContext(),
AttributeSet::ReturnIndex, AttributeList::ReturnIndex, RetAttrs));
RetAttrs));
SmallVector<Value*, 8> Args; SmallVector<Value*, 8> Args;
// Loop through FunctionType's arguments and ensure they are specified // Loop through FunctionType's arguments and ensure they are specified
// correctly. Also, gather any parameter attributes. // correctly. Also, gather any parameter attributes.
FunctionType::param_iterator I = Ty->param_begin(); FunctionType::param_iterator I = Ty->param_begin();
FunctionType::param_iterator E = Ty->param_end(); FunctionType::param_iterator E = Ty->param_end();
for (unsigned i = 0, e = ArgList.size(); i != e; ++i) { for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
Type *ExpectedTy = nullptr; Type *ExpectedTy = nullptr;
if (I != E) { if (I != E) {
ExpectedTy = *I++; ExpectedTy = *I++;
} else if (!Ty->isVarArg()) { } else if (!Ty->isVarArg()) {
return Error(ArgList[i].Loc, "too many arguments specified"); return Error(ArgList[i].Loc, "too many arguments specified");
} }
if (ExpectedTy && ExpectedTy != ArgList[i].V->getType()) if (ExpectedTy && ExpectedTy != ArgList[i].V->getType())
return Error(ArgList[i].Loc, "argument is not of expected type '" + return Error(ArgList[i].Loc, "argument is not of expected type '" +
getTypeString(ExpectedTy) + "'"); getTypeString(ExpectedTy) + "'");
Args.push_back(ArgList[i].V); Args.push_back(ArgList[i].V);
if (ArgList[i].Attrs.hasAttributes(i + 1)) { if (ArgList[i].Attrs.hasAttributes(i + 1)) {
AttrBuilder B(ArgList[i].Attrs, i + 1); AttrBuilder B(ArgList[i].Attrs, i + 1);
Attrs.push_back(AttributeSet::get(RetType->getContext(), i + 1, B)); Attrs.push_back(AttributeList::get(RetType->getContext(), i + 1, B));
} }
} }
if (I != E) if (I != E)
return Error(CallLoc, "not enough parameters specified for call"); return Error(CallLoc, "not enough parameters specified for call");
if (FnAttrs.hasAttributes()) { if (FnAttrs.hasAttributes()) {
if (FnAttrs.hasAlignmentAttr()) if (FnAttrs.hasAlignmentAttr())
return Error(CallLoc, "invoke instructions may not have an alignment"); return Error(CallLoc, "invoke instructions may not have an alignment");
Attrs.push_back(AttributeSet::get(RetType->getContext(), Attrs.push_back(AttributeList::get(RetType->getContext(),
AttributeSet::FunctionIndex, AttributeList::FunctionIndex, FnAttrs));
FnAttrs));
} }
// Finish off the Attribute and check them // Finish off the Attribute and check them
AttributeSet PAL = AttributeSet::get(Context, Attrs); AttributeList PAL = AttributeList::get(Context, Attrs);
InvokeInst *II = InvokeInst *II =
InvokeInst::Create(Ty, Callee, NormalBB, UnwindBB, Args, BundleList); InvokeInst::Create(Ty, Callee, NormalBB, UnwindBB, Args, BundleList);
II->setCallingConv(CC); II->setCallingConv(CC);
II->setAttributes(PAL); II->setAttributes(PAL);
ForwardRefAttrGroups[II] = FwdRefAttrGrps; ForwardRefAttrGroups[II] = FwdRefAttrGrps;
Inst = II; Inst = II;
return false; return false;
▲ Show 20 Lines • Show All 544 Lines • ▼ Show 20 Linesbool LLParser::ParseCall(Instruction *&Inst, PerFunctionState &PFS,
CalleeID.FTy = Ty; CalleeID.FTy = Ty;
// Look up the callee. // Look up the callee.
Value *Callee; Value *Callee;
if (ConvertValIDToValue(PointerType::getUnqual(Ty), CalleeID, Callee, &PFS)) if (ConvertValIDToValue(PointerType::getUnqual(Ty), CalleeID, Callee, &PFS))
return true; return true;
// Set up the Attribute for the function. // Set up the Attribute for the function.
SmallVector<AttributeSet, 8> Attrs; SmallVector<AttributeList, 8> Attrs;
if (RetAttrs.hasAttributes()) if (RetAttrs.hasAttributes())
Attrs.push_back(AttributeSet::get(RetType->getContext(), Attrs.push_back(AttributeList::get(RetType->getContext(),
AttributeSet::ReturnIndex, AttributeList::ReturnIndex, RetAttrs));
RetAttrs));
SmallVector<Value*, 8> Args; SmallVector<Value*, 8> Args;
// Loop through FunctionType's arguments and ensure they are specified // Loop through FunctionType's arguments and ensure they are specified
// correctly. Also, gather any parameter attributes. // correctly. Also, gather any parameter attributes.
FunctionType::param_iterator I = Ty->param_begin(); FunctionType::param_iterator I = Ty->param_begin();
FunctionType::param_iterator E = Ty->param_end(); FunctionType::param_iterator E = Ty->param_end();
for (unsigned i = 0, e = ArgList.size(); i != e; ++i) { for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
Type *ExpectedTy = nullptr; Type *ExpectedTy = nullptr;
if (I != E) { if (I != E) {
ExpectedTy = *I++; ExpectedTy = *I++;
} else if (!Ty->isVarArg()) { } else if (!Ty->isVarArg()) {
return Error(ArgList[i].Loc, "too many arguments specified"); return Error(ArgList[i].Loc, "too many arguments specified");
} }
if (ExpectedTy && ExpectedTy != ArgList[i].V->getType()) if (ExpectedTy && ExpectedTy != ArgList[i].V->getType())
return Error(ArgList[i].Loc, "argument is not of expected type '" + return Error(ArgList[i].Loc, "argument is not of expected type '" +
getTypeString(ExpectedTy) + "'"); getTypeString(ExpectedTy) + "'");
Args.push_back(ArgList[i].V); Args.push_back(ArgList[i].V);
if (ArgList[i].Attrs.hasAttributes(i + 1)) { if (ArgList[i].Attrs.hasAttributes(i + 1)) {
AttrBuilder B(ArgList[i].Attrs, i + 1); AttrBuilder B(ArgList[i].Attrs, i + 1);
Attrs.push_back(AttributeSet::get(RetType->getContext(), i + 1, B)); Attrs.push_back(AttributeList::get(RetType->getContext(), i + 1, B));
} }
} }
if (I != E) if (I != E)
return Error(CallLoc, "not enough parameters specified for call"); return Error(CallLoc, "not enough parameters specified for call");
if (FnAttrs.hasAttributes()) { if (FnAttrs.hasAttributes()) {
if (FnAttrs.hasAlignmentAttr()) if (FnAttrs.hasAlignmentAttr())
return Error(CallLoc, "call instructions may not have an alignment"); return Error(CallLoc, "call instructions may not have an alignment");
Attrs.push_back(AttributeSet::get(RetType->getContext(), Attrs.push_back(AttributeList::get(RetType->getContext(),
AttributeSet::FunctionIndex, AttributeList::FunctionIndex, FnAttrs));
FnAttrs));
} }
// Finish off the Attribute and check them // Finish off the Attribute and check them
AttributeSet PAL = AttributeSet::get(Context, Attrs); AttributeList PAL = AttributeList::get(Context, Attrs);
CallInst *CI = CallInst::Create(Ty, Callee, Args, BundleList); CallInst *CI = CallInst::Create(Ty, Callee, Args, BundleList);
CI->setTailCallKind(TCK); CI->setTailCallKind(TCK);
CI->setCallingConv(CC); CI->setCallingConv(CC);
if (FMF.any()) if (FMF.any())
CI->setFastMathFlags(FMF); CI->setFastMathFlags(FMF);
CI->setAttributes(PAL); CI->setAttributes(PAL);
ForwardRefAttrGroups[CI] = FwdRefAttrGrps; ForwardRefAttrGroups[CI] = FwdRefAttrGrps;
▲ Show 20 Lines • Show All 540 Lines • Show Last 20 Lines

llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp

Show First 20 Lines • Show All 413 Lines • ▼ Show 20 Linesclass BitcodeReader : public BitcodeReaderBase, public GVMaterializer {
std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInits; std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInits;
std::vector<std::pair<GlobalIndirectSymbol*, unsigned> > IndirectSymbolInits; std::vector<std::pair<GlobalIndirectSymbol*, unsigned> > IndirectSymbolInits;
std::vector<std::pair<Function*, unsigned> > FunctionPrefixes; std::vector<std::pair<Function*, unsigned> > FunctionPrefixes;
std::vector<std::pair<Function*, unsigned> > FunctionPrologues; std::vector<std::pair<Function*, unsigned> > FunctionPrologues;
std::vector<std::pair<Function*, unsigned> > FunctionPersonalityFns; std::vector<std::pair<Function*, unsigned> > FunctionPersonalityFns;
/// The set of attributes by index. Index zero in the file is for null, and /// The set of attributes by index. Index zero in the file is for null, and
/// is thus not represented here. As such all indices are off by one. /// is thus not represented here. As such all indices are off by one.
std::vector<AttributeSet> MAttributes; std::vector<AttributeList> MAttributes;
/// The set of attribute groups. /// The set of attribute groups.
std::map<unsigned, AttributeSet> MAttributeGroups; std::map<unsigned, AttributeList> MAttributeGroups;
/// While parsing a function body, this is a list of the basic blocks for the /// While parsing a function body, this is a list of the basic blocks for the
/// function. /// function.
std::vector<BasicBlock*> FunctionBBs; std::vector<BasicBlock*> FunctionBBs;
// When reading the module header, this list is populated with functions that // When reading the module header, this list is populated with functions that
// have bodies later in the file. // have bodies later in the file.
std::vector<Function*> FunctionsWithBodies; std::vector<Function*> FunctionsWithBodies;
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Lines Metadata *getFnMetadataByID(unsigned ID) {
return MDLoader->getMetadataFwdRefOrLoad(ID); return MDLoader->getMetadataFwdRefOrLoad(ID);
} }
BasicBlock *getBasicBlock(unsigned ID) const { BasicBlock *getBasicBlock(unsigned ID) const {
if (ID >= FunctionBBs.size()) return nullptr; // Invalid ID if (ID >= FunctionBBs.size()) return nullptr; // Invalid ID
return FunctionBBs[ID]; return FunctionBBs[ID];
} }
AttributeSet getAttributes(unsigned i) const { AttributeList getAttributes(unsigned i) const {
if (i-1 < MAttributes.size()) if (i-1 < MAttributes.size())
return MAttributes[i-1]; return MAttributes[i-1];
return AttributeSet(); return AttributeList();
} }
/// Read a value/type pair out of the specified record from slot 'Slot'. /// Read a value/type pair out of the specified record from slot 'Slot'.
/// Increment Slot past the number of slots used in the record. Return true on /// Increment Slot past the number of slots used in the record. Return true on
/// failure. /// failure.
bool getValueTypePair(SmallVectorImpl<uint64_t> &Record, unsigned &Slot, bool getValueTypePair(SmallVectorImpl<uint64_t> &Record, unsigned &Slot,
unsigned InstNum, Value *&ResVal) { unsigned InstNum, Value *&ResVal) {
if (Slot == Record.size()) return true; if (Slot == Record.size()) return true;
▲ Show 20 Lines • Show All 592 Lines • ▼ Show 20 LinesError BitcodeReader::parseAttributeBlock() {
if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID)) if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID))
return error("Invalid record"); return error("Invalid record");
if (!MAttributes.empty()) if (!MAttributes.empty())
return error("Invalid multiple blocks"); return error("Invalid multiple blocks");
SmallVector<uint64_t, 64> Record; SmallVector<uint64_t, 64> Record;
SmallVector<AttributeSet, 8> Attrs; SmallVector<AttributeList, 8> Attrs;
// Read all the records. // Read all the records.
while (true) { while (true) {
BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
switch (Entry.Kind) { switch (Entry.Kind) {
case BitstreamEntry::SubBlock: // Handled for us already. case BitstreamEntry::SubBlock: // Handled for us already.
case BitstreamEntry::Error: case BitstreamEntry::Error:
Show All 13 Lines while (true) {
case bitc::PARAMATTR_CODE_ENTRY_OLD: { // ENTRY: [paramidx0, attr0, ...] case bitc::PARAMATTR_CODE_ENTRY_OLD: { // ENTRY: [paramidx0, attr0, ...]
// FIXME: Remove in 4.0. // FIXME: Remove in 4.0.
if (Record.size() & 1) if (Record.size() & 1)
return error("Invalid record"); return error("Invalid record");
for (unsigned i = 0, e = Record.size(); i != e; i += 2) { for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
AttrBuilder B; AttrBuilder B;
decodeLLVMAttributesForBitcode(B, Record[i+1]); decodeLLVMAttributesForBitcode(B, Record[i+1]);
Attrs.push_back(AttributeSet::get(Context, Record[i], B)); Attrs.push_back(AttributeList::get(Context, Record[i], B));
} }
MAttributes.push_back(AttributeSet::get(Context, Attrs)); MAttributes.push_back(AttributeList::get(Context, Attrs));
Attrs.clear(); Attrs.clear();
break; break;
} }
case bitc::PARAMATTR_CODE_ENTRY: { // ENTRY: [attrgrp0, attrgrp1, ...] case bitc::PARAMATTR_CODE_ENTRY: { // ENTRY: [attrgrp0, attrgrp1, ...]
for (unsigned i = 0, e = Record.size(); i != e; ++i) for (unsigned i = 0, e = Record.size(); i != e; ++i)
Attrs.push_back(MAttributeGroups[Record[i]]); Attrs.push_back(MAttributeGroups[Record[i]]);
MAttributes.push_back(AttributeSet::get(Context, Attrs)); MAttributes.push_back(AttributeList::get(Context, Attrs));
Attrs.clear(); Attrs.clear();
break; break;
} }
} }
} }
} }
// Returns Attribute::None on unrecognized codes. // Returns Attribute::None on unrecognized codes.
▲ Show 20 Lines • Show All 201 Lines • ▼ Show 20 Lines case bitc::PARAMATTR_GRP_CODE_ENTRY: { // ENTRY: [grpid, idx, a0, a1, ...]
ValStr += Record[i++]; ValStr += Record[i++];
assert(Record[i] == 0 && "Value string not null terminated"); assert(Record[i] == 0 && "Value string not null terminated");
} }
B.addAttribute(KindStr.str(), ValStr.str()); B.addAttribute(KindStr.str(), ValStr.str());
} }
} }
MAttributeGroups[GrpID] = AttributeSet::get(Context, Idx, B); MAttributeGroups[GrpID] = AttributeList::get(Context, Idx, B);
break; break;
} }
} }
} }
} }
Error BitcodeReader::parseTypeTable() { Error BitcodeReader::parseTypeTable() {
if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW)) if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW))
▲ Show 20 Lines • Show All 2,432 Lines • ▼ Show 20 Lines case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...]
break; break;
} }
case bitc::FUNC_CODE_INST_INVOKE: { case bitc::FUNC_CODE_INST_INVOKE: {
// INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...] // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...]
if (Record.size() < 4) if (Record.size() < 4)
return error("Invalid record"); return error("Invalid record");
unsigned OpNum = 0; unsigned OpNum = 0;
AttributeSet PAL = getAttributes(Record[OpNum++]); AttributeList PAL = getAttributes(Record[OpNum++]);
unsigned CCInfo = Record[OpNum++]; unsigned CCInfo = Record[OpNum++];
BasicBlock *NormalBB = getBasicBlock(Record[OpNum++]); BasicBlock *NormalBB = getBasicBlock(Record[OpNum++]);
BasicBlock *UnwindBB = getBasicBlock(Record[OpNum++]); BasicBlock *UnwindBB = getBasicBlock(Record[OpNum++]);
FunctionType *FTy = nullptr; FunctionType *FTy = nullptr;
if (CCInfo >> 13 & 1 && if (CCInfo >> 13 & 1 &&
!(FTy = dyn_cast<FunctionType>(getTypeByID(Record[OpNum++])))) !(FTy = dyn_cast<FunctionType>(getTypeByID(Record[OpNum++]))))
return error("Explicit invoke type is not a function type"); return error("Explicit invoke type is not a function type");
▲ Show 20 Lines • Show All 368 Lines • ▼ Show 20 Lines case bitc::FUNC_CODE_INST_FENCE: { // FENCE:[ordering, synchscope]
break; break;
} }
case bitc::FUNC_CODE_INST_CALL: { case bitc::FUNC_CODE_INST_CALL: {
// CALL: [paramattrs, cc, fmf, fnty, fnid, arg0, arg1...] // CALL: [paramattrs, cc, fmf, fnty, fnid, arg0, arg1...]
if (Record.size() < 3) if (Record.size() < 3)
return error("Invalid record"); return error("Invalid record");
unsigned OpNum = 0; unsigned OpNum = 0;
AttributeSet PAL = getAttributes(Record[OpNum++]); AttributeList PAL = getAttributes(Record[OpNum++]);
unsigned CCInfo = Record[OpNum++]; unsigned CCInfo = Record[OpNum++];
FastMathFlags FMF; FastMathFlags FMF;
if ((CCInfo >> bitc::CALL_FMF) & 1) { if ((CCInfo >> bitc::CALL_FMF) & 1) {
FMF = getDecodedFastMathFlags(Record[OpNum++]); FMF = getDecodedFastMathFlags(Record[OpNum++]);
if (!FMF.any()) if (!FMF.any())
return error("Fast math flags indicator set for call with no FMF"); return error("Fast math flags indicator set for call with no FMF");
} }
▲ Show 20 Lines • Show All 1,216 Lines • Show Last 20 Lines

llvm/trunk/lib/Bitcode/Writer/BitcodeWriter.cpp

Show First 20 Lines • Show All 703 Lines • ▼ Show 20 Linesstatic uint64_t getAttrKindEncoding(Attribute::AttrKind Kind) {
case Attribute::None: case Attribute::None:
llvm_unreachable("Can not encode none-attribute."); llvm_unreachable("Can not encode none-attribute.");
} }
llvm_unreachable("Trying to encode unknown attribute"); llvm_unreachable("Trying to encode unknown attribute");
} }
void ModuleBitcodeWriter::writeAttributeGroupTable() { void ModuleBitcodeWriter::writeAttributeGroupTable() {
const std::vector<AttributeSet> &AttrGrps = VE.getAttributeGroups(); const std::vector<AttributeList> &AttrGrps = VE.getAttributeGroups();
if (AttrGrps.empty()) return; if (AttrGrps.empty()) return;
Stream.EnterSubblock(bitc::PARAMATTR_GROUP_BLOCK_ID, 3); Stream.EnterSubblock(bitc::PARAMATTR_GROUP_BLOCK_ID, 3);
SmallVector<uint64_t, 64> Record; SmallVector<uint64_t, 64> Record;
for (unsigned i = 0, e = AttrGrps.size(); i != e; ++i) { for (unsigned i = 0, e = AttrGrps.size(); i != e; ++i) {
AttributeSet AS = AttrGrps[i]; AttributeList AS = AttrGrps[i];
for (unsigned i = 0, e = AS.getNumSlots(); i != e; ++i) { for (unsigned i = 0, e = AS.getNumSlots(); i != e; ++i) {
AttributeSet A = AS.getSlotAttributes(i); AttributeList A = AS.getSlotAttributes(i);
Record.push_back(VE.getAttributeGroupID(A)); Record.push_back(VE.getAttributeGroupID(A));
Record.push_back(AS.getSlotIndex(i)); Record.push_back(AS.getSlotIndex(i));
for (AttributeSet::iterator I = AS.begin(0), E = AS.end(0); for (AttributeList::iterator I = AS.begin(0), E = AS.end(0); I != E;
I != E; ++I) { ++I) {
Attribute Attr = *I; Attribute Attr = *I;
if (Attr.isEnumAttribute()) { if (Attr.isEnumAttribute()) {
Record.push_back(0); Record.push_back(0);
Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum())); Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));
} else if (Attr.isIntAttribute()) { } else if (Attr.isIntAttribute()) {
Record.push_back(1); Record.push_back(1);
Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum())); Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));
Record.push_back(Attr.getValueAsInt()); Record.push_back(Attr.getValueAsInt());
Show All 15 Lines for (unsigned i = 0, e = AS.getNumSlots(); i != e; ++i) {
Record.clear(); Record.clear();
} }
} }
Stream.ExitBlock(); Stream.ExitBlock();
} }
void ModuleBitcodeWriter::writeAttributeTable() { void ModuleBitcodeWriter::writeAttributeTable() {
const std::vector<AttributeSet> &Attrs = VE.getAttributes(); const std::vector<AttributeList> &Attrs = VE.getAttributes();
if (Attrs.empty()) return; if (Attrs.empty()) return;
Stream.EnterSubblock(bitc::PARAMATTR_BLOCK_ID, 3); Stream.EnterSubblock(bitc::PARAMATTR_BLOCK_ID, 3);
SmallVector<uint64_t, 64> Record; SmallVector<uint64_t, 64> Record;
for (unsigned i = 0, e = Attrs.size(); i != e; ++i) { for (unsigned i = 0, e = Attrs.size(); i != e; ++i) {
const AttributeSet &A = Attrs[i]; const AttributeList &A = Attrs[i];
for (unsigned i = 0, e = A.getNumSlots(); i != e; ++i) for (unsigned i = 0, e = A.getNumSlots(); i != e; ++i)
Record.push_back(VE.getAttributeGroupID(A.getSlotAttributes(i))); Record.push_back(VE.getAttributeGroupID(A.getSlotAttributes(i)));
Stream.EmitRecord(bitc::PARAMATTR_CODE_ENTRY, Record); Stream.EmitRecord(bitc::PARAMATTR_CODE_ENTRY, Record);
Record.clear(); Record.clear();
} }
Stream.ExitBlock(); Stream.ExitBlock();
▲ Show 20 Lines • Show All 3,243 Lines • Show Last 20 Lines

llvm/trunk/lib/Bitcode/Writer/ValueEnumerator.h

Show All 30 Lines
class Comdat; class Comdat;
class Function; class Function;
class Module; class Module;
class Metadata; class Metadata;
class LocalAsMetadata; class LocalAsMetadata;
class MDNode; class MDNode;
class MDOperand; class MDOperand;
class NamedMDNode; class NamedMDNode;
class AttributeSet; class AttributeList;
class ValueSymbolTable; class ValueSymbolTable;
class MDSymbolTable; class MDSymbolTable;
class raw_ostream; class raw_ostream;
class ValueEnumerator { class ValueEnumerator {
public: public:
typedef std::vector<Type*> TypeList; typedef std::vector<Type*> TypeList;
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines struct MDRange {
MDRange() {} MDRange() {}
explicit MDRange(unsigned First) : First(First) {} explicit MDRange(unsigned First) : First(First) {}
}; };
SmallDenseMap<unsigned, MDRange, 1> FunctionMDInfo; SmallDenseMap<unsigned, MDRange, 1> FunctionMDInfo;
bool ShouldPreserveUseListOrder; bool ShouldPreserveUseListOrder;
typedef DenseMap<AttributeSet, unsigned> AttributeGroupMapType; typedef DenseMap<AttributeList, unsigned> AttributeGroupMapType;
AttributeGroupMapType AttributeGroupMap; AttributeGroupMapType AttributeGroupMap;
std::vector<AttributeSet> AttributeGroups; std::vector<AttributeList> AttributeGroups;
typedef DenseMap<AttributeSet, unsigned> AttributeMapType; typedef DenseMap<AttributeList, unsigned> AttributeMapType;
AttributeMapType AttributeMap; AttributeMapType AttributeMap;
std::vector<AttributeSet> Attribute; std::vector<AttributeList> Attribute;
/// GlobalBasicBlockIDs - This map memoizes the basic block ID's referenced by /// GlobalBasicBlockIDs - This map memoizes the basic block ID's referenced by
/// the "getGlobalBasicBlockID" method. /// the "getGlobalBasicBlockID" method.
mutable DenseMap<const BasicBlock*, unsigned> GlobalBasicBlockIDs; mutable DenseMap<const BasicBlock*, unsigned> GlobalBasicBlockIDs;
typedef DenseMap<const Instruction*, unsigned> InstructionMapType; typedef DenseMap<const Instruction*, unsigned> InstructionMapType;
InstructionMapType InstructionMap; InstructionMapType InstructionMap;
unsigned InstructionCount; unsigned InstructionCount;
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines unsigned getTypeID(Type *T) const {
TypeMapType::const_iterator I = TypeMap.find(T); TypeMapType::const_iterator I = TypeMap.find(T);
assert(I != TypeMap.end() && "Type not in ValueEnumerator!"); assert(I != TypeMap.end() && "Type not in ValueEnumerator!");
return I->second-1; return I->second-1;
} }
unsigned getInstructionID(const Instruction *I) const; unsigned getInstructionID(const Instruction *I) const;
void setInstructionID(const Instruction *I); void setInstructionID(const Instruction *I);
unsigned getAttributeID(AttributeSet PAL) const { unsigned getAttributeID(AttributeList PAL) const {
if (PAL.isEmpty()) return 0; // Null maps to zero. if (PAL.isEmpty()) return 0; // Null maps to zero.
AttributeMapType::const_iterator I = AttributeMap.find(PAL); AttributeMapType::const_iterator I = AttributeMap.find(PAL);
assert(I != AttributeMap.end() && "Attribute not in ValueEnumerator!"); assert(I != AttributeMap.end() && "Attribute not in ValueEnumerator!");
return I->second; return I->second;
} }
unsigned getAttributeGroupID(AttributeSet PAL) const { unsigned getAttributeGroupID(AttributeList PAL) const {
if (PAL.isEmpty()) return 0; // Null maps to zero. if (PAL.isEmpty()) return 0; // Null maps to zero.
AttributeGroupMapType::const_iterator I = AttributeGroupMap.find(PAL); AttributeGroupMapType::const_iterator I = AttributeGroupMap.find(PAL);
assert(I != AttributeGroupMap.end() && "Attribute not in ValueEnumerator!"); assert(I != AttributeGroupMap.end() && "Attribute not in ValueEnumerator!");
return I->second; return I->second;
} }
/// getFunctionConstantRange - Return the range of values that corresponds to /// getFunctionConstantRange - Return the range of values that corresponds to
/// function-local constants. /// function-local constants.
Show All 16 Linespublic:
ArrayRef<const Metadata *> getNonMDStrings() const { ArrayRef<const Metadata *> getNonMDStrings() const {
return makeArrayRef(MDs).slice(NumModuleMDs).slice(NumMDStrings); return makeArrayRef(MDs).slice(NumModuleMDs).slice(NumMDStrings);
} }
const TypeList &getTypes() const { return Types; } const TypeList &getTypes() const { return Types; }
const std::vector<const BasicBlock*> &getBasicBlocks() const { const std::vector<const BasicBlock*> &getBasicBlocks() const {
return BasicBlocks; return BasicBlocks;
} }
const std::vector<AttributeSet> &getAttributes() const { const std::vector<AttributeList> &getAttributes() const { return Attribute; }
return Attribute; const std::vector<AttributeList> &getAttributeGroups() const {
}
const std::vector<AttributeSet> &getAttributeGroups() const {
return AttributeGroups; return AttributeGroups;
} }
const ComdatSetType &getComdats() const { return Comdats; } const ComdatSetType &getComdats() const { return Comdats; }
unsigned getComdatID(const Comdat *C) const; unsigned getComdatID(const Comdat *C) const;
/// getGlobalBasicBlockID - This returns the function-specific ID for the /// getGlobalBasicBlockID - This returns the function-specific ID for the
/// specified basic block. This is relatively expensive information, so it /// specified basic block. This is relatively expensive information, so it
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Linesprivate:
void EnumerateFunctionLocalMetadata(const Function &F, void EnumerateFunctionLocalMetadata(const Function &F,
const LocalAsMetadata *Local); const LocalAsMetadata *Local);
void EnumerateFunctionLocalMetadata(unsigned F, const LocalAsMetadata *Local); void EnumerateFunctionLocalMetadata(unsigned F, const LocalAsMetadata *Local);
void EnumerateNamedMDNode(const NamedMDNode *NMD); void EnumerateNamedMDNode(const NamedMDNode *NMD);
void EnumerateValue(const Value *V); void EnumerateValue(const Value *V);
void EnumerateType(Type *T); void EnumerateType(Type *T);
void EnumerateOperandType(const Value *V); void EnumerateOperandType(const Value *V);
void EnumerateAttributes(AttributeSet PAL); void EnumerateAttributes(AttributeList PAL);
void EnumerateValueSymbolTable(const ValueSymbolTable &ST); void EnumerateValueSymbolTable(const ValueSymbolTable &ST);
void EnumerateNamedMetadata(const Module &M); void EnumerateNamedMetadata(const Module &M);
}; };
} // End llvm namespace } // End llvm namespace
#endif #endif

llvm/trunk/lib/Bitcode/Writer/ValueEnumerator.cpp

Show First 20 Lines • Show All 881 Lines • ▼ Show 20 Lines for (const Value *Op : C->operands()) {
// blockaddress. // blockaddress.
if (isa<BasicBlock>(Op)) if (isa<BasicBlock>(Op))
continue; continue;
EnumerateOperandType(Op); EnumerateOperandType(Op);
} }
} }
void ValueEnumerator::EnumerateAttributes(AttributeSet PAL) { void ValueEnumerator::EnumerateAttributes(AttributeList PAL) {
if (PAL.isEmpty()) return; // null is always 0. if (PAL.isEmpty()) return; // null is always 0.
// Do a lookup. // Do a lookup.
unsigned &Entry = AttributeMap[PAL]; unsigned &Entry = AttributeMap[PAL];
if (Entry == 0) { if (Entry == 0) {
// Never saw this before, add it. // Never saw this before, add it.
Attribute.push_back(PAL); Attribute.push_back(PAL);
Entry = Attribute.size(); Entry = Attribute.size();
} }
// Do lookups for all attribute groups. // Do lookups for all attribute groups.
for (unsigned i = 0, e = PAL.getNumSlots(); i != e; ++i) { for (unsigned i = 0, e = PAL.getNumSlots(); i != e; ++i) {
AttributeSet AS = PAL.getSlotAttributes(i); AttributeList AS = PAL.getSlotAttributes(i);
unsigned &Entry = AttributeGroupMap[AS]; unsigned &Entry = AttributeGroupMap[AS];
if (Entry == 0) { if (Entry == 0) {
AttributeGroups.push_back(AS); AttributeGroups.push_back(AS);
Entry = AttributeGroups.size(); Entry = AttributeGroups.size();
} }
} }
} }
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

llvm/trunk/lib/CodeGen/Analysis.cpp

Show First 20 Lines • Show All 510 Lines • ▼ Show 20 Linesbool llvm::attributesPermitTailCall(const Function *F, const Instruction *I,
const ReturnInst *Ret, const ReturnInst *Ret,
const TargetLoweringBase &TLI, const TargetLoweringBase &TLI,
bool *AllowDifferingSizes) { bool *AllowDifferingSizes) {
// ADS may be null, so don't write to it directly. // ADS may be null, so don't write to it directly.
bool DummyADS; bool DummyADS;
bool &ADS = AllowDifferingSizes ? *AllowDifferingSizes : DummyADS; bool &ADS = AllowDifferingSizes ? *AllowDifferingSizes : DummyADS;
ADS = true; ADS = true;
AttrBuilder CallerAttrs(F->getAttributes(), AttrBuilder CallerAttrs(F->getAttributes(), AttributeList::ReturnIndex);
AttributeSet::ReturnIndex);
AttrBuilder CalleeAttrs(cast<CallInst>(I)->getAttributes(), AttrBuilder CalleeAttrs(cast<CallInst>(I)->getAttributes(),
AttributeSet::ReturnIndex); AttributeList::ReturnIndex);
// Noalias is completely benign as far as calling convention goes, it // Noalias is completely benign as far as calling convention goes, it
// shouldn't affect whether the call is a tail call. // shouldn't affect whether the call is a tail call.
CallerAttrs.removeAttribute(Attribute::NoAlias); CallerAttrs.removeAttribute(Attribute::NoAlias);
CalleeAttrs.removeAttribute(Attribute::NoAlias); CalleeAttrs.removeAttribute(Attribute::NoAlias);
if (CallerAttrs.contains(Attribute::ZExt)) { if (CallerAttrs.contains(Attribute::ZExt)) {
if (!CalleeAttrs.contains(Attribute::ZExt)) if (!CalleeAttrs.contains(Attribute::ZExt))
▲ Show 20 Lines • Show All 196 Lines • Show Last 20 Lines

llvm/trunk/lib/CodeGen/AtomicExpandPass.cpp

Show First 20 Lines • Show All 1,526 Lines • ▼ Show 20 Linesbool AtomicExpand::expandAtomicOpToLibcall(
Value *AllocaCASExpected_i8 = nullptr; Value *AllocaCASExpected_i8 = nullptr;
AllocaInst *AllocaValue = nullptr; AllocaInst *AllocaValue = nullptr;
Value *AllocaValue_i8 = nullptr; Value *AllocaValue_i8 = nullptr;
AllocaInst *AllocaResult = nullptr; AllocaInst *AllocaResult = nullptr;
Value *AllocaResult_i8 = nullptr; Value *AllocaResult_i8 = nullptr;
Type *ResultTy; Type *ResultTy;
SmallVector<Value *, 6> Args; SmallVector<Value *, 6> Args;
AttributeSet Attr; AttributeList Attr;
// 'size' argument. // 'size' argument.
if (!UseSizedLibcall) { if (!UseSizedLibcall) {
// Note, getIntPtrType is assumed equivalent to size_t. // Note, getIntPtrType is assumed equivalent to size_t.
Args.push_back(ConstantInt::get(DL.getIntPtrType(Ctx), Size)); Args.push_back(ConstantInt::get(DL.getIntPtrType(Ctx), Size));
} }
// 'ptr' argument. // 'ptr' argument.
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linesbool AtomicExpand::expandAtomicOpToLibcall(
// 'failure_order' argument, if present. // 'failure_order' argument, if present.
if (Ordering2Val) if (Ordering2Val)
Args.push_back(Ordering2Val); Args.push_back(Ordering2Val);
// Now, the return type. // Now, the return type.
if (CASExpected) { if (CASExpected) {
ResultTy = Type::getInt1Ty(Ctx); ResultTy = Type::getInt1Ty(Ctx);
Attr = Attr.addAttribute(Ctx, AttributeSet::ReturnIndex, Attribute::ZExt); Attr = Attr.addAttribute(Ctx, AttributeList::ReturnIndex, Attribute::ZExt);
} else if (HasResult && UseSizedLibcall) } else if (HasResult && UseSizedLibcall)
ResultTy = SizedIntTy; ResultTy = SizedIntTy;
else else
ResultTy = Type::getVoidTy(Ctx); ResultTy = Type::getVoidTy(Ctx);
// Done with setting up arguments and return types, create the call: // Done with setting up arguments and return types, create the call:
SmallVector<Type *, 6> ArgTys; SmallVector<Type *, 6> ArgTys;
for (Value *Arg : Args) for (Value *Arg : Args)
Show All 36 Lines

llvm/trunk/lib/CodeGen/CodeGenPrepare.cpp

Show First 20 Lines • Show All 2,394 Lines • ▼ Show 20 Linesbool CodeGenPrepare::dupRetToEnableTailCallOpts(BasicBlock *BB) {
bool Changed = false; bool Changed = false;
for (unsigned i = 0, e = TailCalls.size(); i != e; ++i) { for (unsigned i = 0, e = TailCalls.size(); i != e; ++i) {
CallInst *CI = TailCalls[i]; CallInst *CI = TailCalls[i];
CallSite CS(CI); CallSite CS(CI);
// Conservatively require the attributes of the call to match those of the // Conservatively require the attributes of the call to match those of the
// return. Ignore noalias because it doesn't affect the call sequence. // return. Ignore noalias because it doesn't affect the call sequence.
AttributeSet CalleeAttrs = CS.getAttributes(); AttributeList CalleeAttrs = CS.getAttributes();
if (AttrBuilder(CalleeAttrs, AttributeSet::ReturnIndex). if (AttrBuilder(CalleeAttrs, AttributeList::ReturnIndex)
removeAttribute(Attribute::NoAlias) != .removeAttribute(Attribute::NoAlias) !=
AttrBuilder(CalleeAttrs, AttributeSet::ReturnIndex). AttrBuilder(CalleeAttrs, AttributeList::ReturnIndex)
removeAttribute(Attribute::NoAlias)) .removeAttribute(Attribute::NoAlias))
continue; continue;
// Make sure the call instruction is followed by an unconditional branch to // Make sure the call instruction is followed by an unconditional branch to
// the return block. // the return block.
BasicBlock *CallBB = CI->getParent(); BasicBlock *CallBB = CI->getParent();
BranchInst *BI = dyn_cast<BranchInst>(CallBB->getTerminator()); BranchInst *BI = dyn_cast<BranchInst>(CallBB->getTerminator());
if (!BI || !BI->isUnconditional() || BI->getSuccessor(0) != BB) if (!BI || !BI->isUnconditional() || BI->getSuccessor(0) != BB)
continue; continue;
▲ Show 20 Lines • Show All 3,774 Lines • Show Last 20 Lines

llvm/trunk/lib/CodeGen/GlobalISel/CallLowering.cpp

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Linesbool CallLowering::lowerCall(
MachineOperand Callee = MachineOperand::CreateImm(0); MachineOperand Callee = MachineOperand::CreateImm(0);
if (const Function *F = CS.getCalledFunction()) if (const Function *F = CS.getCalledFunction())
Callee = MachineOperand::CreateGA(F, 0); Callee = MachineOperand::CreateGA(F, 0);
else else
Callee = MachineOperand::CreateReg(GetCalleeReg(), false); Callee = MachineOperand::CreateReg(GetCalleeReg(), false);
ArgInfo OrigRet{ResReg, CS.getType(), ISD::ArgFlagsTy{}}; ArgInfo OrigRet{ResReg, CS.getType(), ISD::ArgFlagsTy{}};
if (!OrigRet.Ty->isVoidTy()) if (!OrigRet.Ty->isVoidTy())
setArgFlags(OrigRet, AttributeSet::ReturnIndex, DL, CS); setArgFlags(OrigRet, AttributeList::ReturnIndex, DL, CS);
return lowerCall(MIRBuilder, CS.getCallingConv(), Callee, OrigRet, OrigArgs); return lowerCall(MIRBuilder, CS.getCallingConv(), Callee, OrigRet, OrigArgs);
} }
template <typename FuncInfoTy> template <typename FuncInfoTy>
void CallLowering::setArgFlags(CallLowering::ArgInfo &Arg, unsigned OpIdx, void CallLowering::setArgFlags(CallLowering::ArgInfo &Arg, unsigned OpIdx,
const DataLayout &DL, const DataLayout &DL,
const FuncInfoTy &FuncInfo) const { const FuncInfoTy &FuncInfo) const {
const AttributeSet &Attrs = FuncInfo.getAttributes(); const AttributeList &Attrs = FuncInfo.getAttributes();
if (Attrs.hasAttribute(OpIdx, Attribute::ZExt)) if (Attrs.hasAttribute(OpIdx, Attribute::ZExt))
Arg.Flags.setZExt(); Arg.Flags.setZExt();
if (Attrs.hasAttribute(OpIdx, Attribute::SExt)) if (Attrs.hasAttribute(OpIdx, Attribute::SExt))
Arg.Flags.setSExt(); Arg.Flags.setSExt();
if (Attrs.hasAttribute(OpIdx, Attribute::InReg)) if (Attrs.hasAttribute(OpIdx, Attribute::InReg))
Arg.Flags.setInReg(); Arg.Flags.setInReg();
if (Attrs.hasAttribute(OpIdx, Attribute::StructRet)) if (Attrs.hasAttribute(OpIdx, Attribute::StructRet))
Arg.Flags.setSRet(); Arg.Flags.setSRet();
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines

llvm/trunk/lib/CodeGen/MachinePipeliner.cpp

Show First 20 Lines • Show All 727 Lines • ▼ Show 20 Lines
bool MachinePipeliner::runOnMachineFunction(MachineFunction &mf) { bool MachinePipeliner::runOnMachineFunction(MachineFunction &mf) {
if (skipFunction(*mf.getFunction())) if (skipFunction(*mf.getFunction()))
return false; return false;
if (!EnableSWP) if (!EnableSWP)
return false; return false;
if (mf.getFunction()->getAttributes().hasAttribute( if (mf.getFunction()->getAttributes().hasAttribute(
AttributeSet::FunctionIndex, Attribute::OptimizeForSize) && AttributeList::FunctionIndex, Attribute::OptimizeForSize) &&
!EnableSWPOptSize.getPosition()) !EnableSWPOptSize.getPosition())
return false; return false;
MF = &mf; MF = &mf;
MLI = &getAnalysis<MachineLoopInfo>(); MLI = &getAnalysis<MachineLoopInfo>();
MDT = &getAnalysis<MachineDominatorTree>(); MDT = &getAnalysis<MachineDominatorTree>();
TII = MF->getSubtarget().getInstrInfo(); TII = MF->getSubtarget().getInstrInfo();
RegClassInfo.runOnMachineFunction(*MF); RegClassInfo.runOnMachineFunction(*MF);
▲ Show 20 Lines • Show All 3,237 Lines • Show Last 20 Lines

llvm/trunk/lib/CodeGen/SelectionDAG/DAGCombiner.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 2,611 Lines • ▼ Show 20 Lines if (N1C && !N1C->isNullValue() && !N1C->isOpaque() &&
AddToWorklist(SRA.getNode()); AddToWorklist(SRA.getNode());
return DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), SRA); return DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), SRA);
} }
// If integer divide is expensive and we satisfy the requirements, emit an // If integer divide is expensive and we satisfy the requirements, emit an
// alternate sequence. Targets may check function attributes for size/speed // alternate sequence. Targets may check function attributes for size/speed
// trade-offs. // trade-offs.
AttributeSet Attr = DAG.getMachineFunction().getFunction()->getAttributes(); AttributeList Attr = DAG.getMachineFunction().getFunction()->getAttributes();
if (N1C && !TLI.isIntDivCheap(N->getValueType(0), Attr)) if (N1C && !TLI.isIntDivCheap(N->getValueType(0), Attr))
if (SDValue Op = BuildSDIV(N)) if (SDValue Op = BuildSDIV(N))
return Op; return Op;
// sdiv, srem -> sdivrem // sdiv, srem -> sdivrem
// If the divisor is constant, then return DIVREM only if isIntDivCheap() is // If the divisor is constant, then return DIVREM only if isIntDivCheap() is
// true. Otherwise, we break the simplification logic in visitREM(). // true. Otherwise, we break the simplification logic in visitREM().
if (!N1C || TLI.isIntDivCheap(N->getValueType(0), Attr)) if (!N1C || TLI.isIntDivCheap(N->getValueType(0), Attr))
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines if (isConstantOrConstantVector(N10, /*NoOpaques*/ true) &&
AddToWorklist(Trunc.getNode()); AddToWorklist(Trunc.getNode());
SDValue Add = DAG.getNode(ISD::ADD, DL, ADDVT, N1.getOperand(1), Trunc); SDValue Add = DAG.getNode(ISD::ADD, DL, ADDVT, N1.getOperand(1), Trunc);
AddToWorklist(Add.getNode()); AddToWorklist(Add.getNode());
return DAG.getNode(ISD::SRL, DL, VT, N0, Add); return DAG.getNode(ISD::SRL, DL, VT, N0, Add);
} }
} }
// fold (udiv x, c) -> alternate // fold (udiv x, c) -> alternate
AttributeSet Attr = DAG.getMachineFunction().getFunction()->getAttributes(); AttributeList Attr = DAG.getMachineFunction().getFunction()->getAttributes();
if (N1C && !TLI.isIntDivCheap(N->getValueType(0), Attr)) if (N1C && !TLI.isIntDivCheap(N->getValueType(0), Attr))
if (SDValue Op = BuildUDIV(N)) if (SDValue Op = BuildUDIV(N))
return Op; return Op;
// sdiv, srem -> sdivrem // sdiv, srem -> sdivrem
// If the divisor is constant, then return DIVREM only if isIntDivCheap() is // If the divisor is constant, then return DIVREM only if isIntDivCheap() is
// true. Otherwise, we break the simplification logic in visitREM(). // true. Otherwise, we break the simplification logic in visitREM().
if (!N1C || TLI.isIntDivCheap(N->getValueType(0), Attr)) if (!N1C || TLI.isIntDivCheap(N->getValueType(0), Attr))
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines if (N1.getOpcode() == ISD::SHL &&
DAG.isKnownToBeAPowerOfTwo(N1.getOperand(0))) { DAG.isKnownToBeAPowerOfTwo(N1.getOperand(0))) {
// fold (urem x, (shl pow2, y)) -> (and x, (add (shl pow2, y), -1)) // fold (urem x, (shl pow2, y)) -> (and x, (add (shl pow2, y), -1))
SDValue Add = DAG.getNode(ISD::ADD, DL, VT, N1, NegOne); SDValue Add = DAG.getNode(ISD::ADD, DL, VT, N1, NegOne);
AddToWorklist(Add.getNode()); AddToWorklist(Add.getNode());
return DAG.getNode(ISD::AND, DL, VT, N0, Add); return DAG.getNode(ISD::AND, DL, VT, N0, Add);
} }
} }
AttributeSet Attr = DAG.getMachineFunction().getFunction()->getAttributes(); AttributeList Attr = DAG.getMachineFunction().getFunction()->getAttributes();
// If X/C can be simplified by the division-by-constant logic, lower // If X/C can be simplified by the division-by-constant logic, lower
// X%C to the equivalent of X-X/C*C. // X%C to the equivalent of X-X/C*C.
// To avoid mangling nodes, this simplification requires that the combine() // To avoid mangling nodes, this simplification requires that the combine()
// call for the speculative DIV must not cause a DIVREM conversion. We guard // call for the speculative DIV must not cause a DIVREM conversion. We guard
// against this by skipping the simplification if isIntDivCheap(). When // against this by skipping the simplification if isIntDivCheap(). When
// div is not cheap, combine will not return a DIVREM. Regardless, // div is not cheap, combine will not return a DIVREM. Regardless,
// checking cheapness here makes sense since the simplification results in // checking cheapness here makes sense since the simplification results in
▲ Show 20 Lines • Show All 13,562 Lines • Show Last 20 Lines

llvm/trunk/lib/CodeGen/SelectionDAG/FastISel.cpp

Show First 20 Lines • Show All 857 Lines • ▼ Show 20 Linesbool FastISel::selectPatchpoint(const CallInst *I) {
// Inform the Frame Information that we have a patchpoint in this function. // Inform the Frame Information that we have a patchpoint in this function.
FuncInfo.MF->getFrameInfo().setHasPatchPoint(); FuncInfo.MF->getFrameInfo().setHasPatchPoint();
if (CLI.NumResultRegs) if (CLI.NumResultRegs)
updateValueMap(I, CLI.ResultReg, CLI.NumResultRegs); updateValueMap(I, CLI.ResultReg, CLI.NumResultRegs);
return true; return true;
} }
/// Returns an AttributeSet representing the attributes applied to the return /// Returns an AttributeList representing the attributes applied to the return
/// value of the given call. /// value of the given call.
static AttributeSet getReturnAttrs(FastISel::CallLoweringInfo &CLI) { static AttributeList getReturnAttrs(FastISel::CallLoweringInfo &CLI) {
SmallVector<Attribute::AttrKind, 2> Attrs; SmallVector<Attribute::AttrKind, 2> Attrs;
if (CLI.RetSExt) if (CLI.RetSExt)
Attrs.push_back(Attribute::SExt); Attrs.push_back(Attribute::SExt);
if (CLI.RetZExt) if (CLI.RetZExt)
Attrs.push_back(Attribute::ZExt); Attrs.push_back(Attribute::ZExt);
if (CLI.IsInReg) if (CLI.IsInReg)
Attrs.push_back(Attribute::InReg); Attrs.push_back(Attribute::InReg);
return AttributeSet::get(CLI.RetTy->getContext(), AttributeSet::ReturnIndex, return AttributeList::get(CLI.RetTy->getContext(), AttributeList::ReturnIndex,
Attrs); Attrs);
} }
bool FastISel::lowerCallTo(const CallInst *CI, const char *SymName, bool FastISel::lowerCallTo(const CallInst *CI, const char *SymName,
unsigned NumArgs) { unsigned NumArgs) {
MCContext &Ctx = MF->getContext(); MCContext &Ctx = MF->getContext();
SmallString<32> MangledName; SmallString<32> MangledName;
Mangler::getNameWithPrefix(MangledName, SymName, DL); Mangler::getNameWithPrefix(MangledName, SymName, DL);
MCSymbol *Sym = Ctx.getOrCreateSymbol(MangledName); MCSymbol *Sym = Ctx.getOrCreateSymbol(MangledName);
▲ Show 20 Lines • Show All 1,351 Lines • Show Last 20 Lines

llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 1,367 Lines • ▼ Show 20 Lines if (!FuncInfo.CanLowerReturn) {
ComputeValueVTs(TLI, DL, I.getOperand(0)->getType(), ValueVTs); ComputeValueVTs(TLI, DL, I.getOperand(0)->getType(), ValueVTs);
unsigned NumValues = ValueVTs.size(); unsigned NumValues = ValueVTs.size();
if (NumValues) { if (NumValues) {
SDValue RetOp = getValue(I.getOperand(0)); SDValue RetOp = getValue(I.getOperand(0));
const Function *F = I.getParent()->getParent(); const Function *F = I.getParent()->getParent();
ISD::NodeType ExtendKind = ISD::ANY_EXTEND; ISD::NodeType ExtendKind = ISD::ANY_EXTEND;
if (F->getAttributes().hasAttribute(AttributeSet::ReturnIndex, if (F->getAttributes().hasAttribute(AttributeList::ReturnIndex,
Attribute::SExt)) Attribute::SExt))
ExtendKind = ISD::SIGN_EXTEND; ExtendKind = ISD::SIGN_EXTEND;
else if (F->getAttributes().hasAttribute(AttributeSet::ReturnIndex, else if (F->getAttributes().hasAttribute(AttributeList::ReturnIndex,
Attribute::ZExt)) Attribute::ZExt))
ExtendKind = ISD::ZERO_EXTEND; ExtendKind = ISD::ZERO_EXTEND;
LLVMContext &Context = F->getContext(); LLVMContext &Context = F->getContext();
bool RetInReg = F->getAttributes().hasAttribute(AttributeSet::ReturnIndex, bool RetInReg = F->getAttributes().hasAttribute(
Attribute::InReg); AttributeList::ReturnIndex, Attribute::InReg);
for (unsigned j = 0; j != NumValues; ++j) { for (unsigned j = 0; j != NumValues; ++j) {
EVT VT = ValueVTs[j]; EVT VT = ValueVTs[j];
if (ExtendKind != ISD::ANY_EXTEND && VT.isInteger()) if (ExtendKind != ISD::ANY_EXTEND && VT.isInteger())
VT = TLI.getTypeForExtReturn(Context, VT, ExtendKind); VT = TLI.getTypeForExtReturn(Context, VT, ExtendKind);
unsigned NumParts = TLI.getNumRegisters(Context, VT); unsigned NumParts = TLI.getNumRegisters(Context, VT);
▲ Show 20 Lines • Show All 4,126 Lines • ▼ Show 20 Lines case Intrinsic::expect: {
setValue(&I, getValue(I.getArgOperand(0))); setValue(&I, getValue(I.getArgOperand(0)));
return nullptr; return nullptr;
} }
case Intrinsic::debugtrap: case Intrinsic::debugtrap:
case Intrinsic::trap: { case Intrinsic::trap: {
StringRef TrapFuncName = StringRef TrapFuncName =
I.getAttributes() I.getAttributes()
.getAttribute(AttributeSet::FunctionIndex, "trap-func-name") .getAttribute(AttributeList::FunctionIndex, "trap-func-name")
.getValueAsString(); .getValueAsString();
if (TrapFuncName.empty()) { if (TrapFuncName.empty()) {
ISD::NodeType Op = (Intrinsic == Intrinsic::trap) ? ISD::NodeType Op = (Intrinsic == Intrinsic::trap) ?
ISD::TRAP : ISD::DEBUGTRAP; ISD::TRAP : ISD::DEBUGTRAP;
DAG.setRoot(DAG.getNode(Op, sdl,MVT::Other, getRoot())); DAG.setRoot(DAG.getNode(Op, sdl,MVT::Other, getRoot()));
return nullptr; return nullptr;
} }
TargetLowering::ArgListTy Args; TargetLowering::ArgListTy Args;
▲ Show 20 Lines • Show All 2,061 Lines • ▼ Show 20 Linesvoid SelectionDAGBuilder::visitPatchpoint(ImmutableCallSite CS,
} else } else
DAG.ReplaceAllUsesWith(Call, MN); DAG.ReplaceAllUsesWith(Call, MN);
DAG.DeleteNode(Call); DAG.DeleteNode(Call);
// Inform the Frame Information that we have a patchpoint in this function. // Inform the Frame Information that we have a patchpoint in this function.
FuncInfo.MF->getFrameInfo().setHasPatchPoint(); FuncInfo.MF->getFrameInfo().setHasPatchPoint();
} }
/// Returns an AttributeSet representing the attributes applied to the return /// Returns an AttributeList representing the attributes applied to the return
/// value of the given call. /// value of the given call.
static AttributeSet getReturnAttrs(TargetLowering::CallLoweringInfo &CLI) { static AttributeList getReturnAttrs(TargetLowering::CallLoweringInfo &CLI) {
SmallVector<Attribute::AttrKind, 2> Attrs; SmallVector<Attribute::AttrKind, 2> Attrs;
if (CLI.RetSExt) if (CLI.RetSExt)
Attrs.push_back(Attribute::SExt); Attrs.push_back(Attribute::SExt);
if (CLI.RetZExt) if (CLI.RetZExt)
Attrs.push_back(Attribute::ZExt); Attrs.push_back(Attribute::ZExt);
if (CLI.IsInReg) if (CLI.IsInReg)
Attrs.push_back(Attribute::InReg); Attrs.push_back(Attribute::InReg);
return AttributeSet::get(CLI.RetTy->getContext(), AttributeSet::ReturnIndex, return AttributeList::get(CLI.RetTy->getContext(), AttributeList::ReturnIndex,
Attrs); Attrs);
} }
/// TargetLowering::LowerCallTo - This is the default LowerCallTo /// TargetLowering::LowerCallTo - This is the default LowerCallTo
/// implementation, which just calls LowerCall. /// implementation, which just calls LowerCall.
/// FIXME: When all targets are /// FIXME: When all targets are
/// migrated to using LowerCall, this hook should be integrated into SDISel. /// migrated to using LowerCall, this hook should be integrated into SDISel.
std::pair<SDValue, SDValue> std::pair<SDValue, SDValue>
TargetLowering::LowerCallTo(TargetLowering::CallLoweringInfo &CLI) const { TargetLowering::LowerCallTo(TargetLowering::CallLoweringInfo &CLI) const {
▲ Show 20 Lines • Show All 1,908 Lines • Show Last 20 Lines

llvm/trunk/lib/CodeGen/SelectionDAG/TargetLowering.cpp

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
/// Check whether a given call node is in tail position within its function. If /// Check whether a given call node is in tail position within its function. If
/// so, it sets Chain to the input chain of the tail call. /// so, it sets Chain to the input chain of the tail call.
bool TargetLowering::isInTailCallPosition(SelectionDAG &DAG, SDNode *Node, bool TargetLowering::isInTailCallPosition(SelectionDAG &DAG, SDNode *Node,
SDValue &Chain) const { SDValue &Chain) const {
const Function *F = DAG.getMachineFunction().getFunction(); const Function *F = DAG.getMachineFunction().getFunction();
// Conservatively require the attributes of the call to match those of // Conservatively require the attributes of the call to match those of
// the return. Ignore noalias because it doesn't affect the call sequence. // the return. Ignore noalias because it doesn't affect the call sequence.
AttributeSet CallerAttrs = F->getAttributes(); AttributeList CallerAttrs = F->getAttributes();
if (AttrBuilder(CallerAttrs, AttributeSet::ReturnIndex) if (AttrBuilder(CallerAttrs, AttributeList::ReturnIndex)
.removeAttribute(Attribute::NoAlias).hasAttributes()) .removeAttribute(Attribute::NoAlias)
.hasAttributes())
return false; return false;
// It's not safe to eliminate the sign / zero extension of the return value. // It's not safe to eliminate the sign / zero extension of the return value.
if (CallerAttrs.hasAttribute(AttributeSet::ReturnIndex, Attribute::ZExt) || if (CallerAttrs.hasAttribute(AttributeList::ReturnIndex, Attribute::ZExt) ||
CallerAttrs.hasAttribute(AttributeSet::ReturnIndex, Attribute::SExt)) CallerAttrs.hasAttribute(AttributeList::ReturnIndex, Attribute::SExt))
return false; return false;
// Check if the only use is a function return node. // Check if the only use is a function return node.
return isUsedByReturnOnly(Node, Chain); return isUsedByReturnOnly(Node, Chain);
} }
bool TargetLowering::parametersInCSRMatch(const MachineRegisterInfo &MRI, bool TargetLowering::parametersInCSRMatch(const MachineRegisterInfo &MRI,
const uint32_t *CallerPreservedMask, const uint32_t *CallerPreservedMask,
▲ Show 20 Lines • Show All 2,902 Lines • ▼ Show 20 Linesstatic SDValue BuildExactSDIV(const TargetLowering &TLI, SDValue Op1, APInt d,
SDValue Mul = DAG.getNode(ISD::MUL, dl, Op1.getValueType(), Op1, Op2); SDValue Mul = DAG.getNode(ISD::MUL, dl, Op1.getValueType(), Op1, Op2);
Created.push_back(Mul.getNode()); Created.push_back(Mul.getNode());
return Mul; return Mul;
} }
SDValue TargetLowering::BuildSDIVPow2(SDNode *N, const APInt &Divisor, SDValue TargetLowering::BuildSDIVPow2(SDNode *N, const APInt &Divisor,
SelectionDAG &DAG, SelectionDAG &DAG,
std::vector<SDNode *> *Created) const { std::vector<SDNode *> *Created) const {
AttributeSet Attr = DAG.getMachineFunction().getFunction()->getAttributes(); AttributeList Attr = DAG.getMachineFunction().getFunction()->getAttributes();
const TargetLowering &TLI = DAG.getTargetLoweringInfo(); const TargetLowering &TLI = DAG.getTargetLoweringInfo();
if (TLI.isIntDivCheap(N->getValueType(0), Attr)) if (TLI.isIntDivCheap(N->getValueType(0), Attr))
return SDValue(N,0); // Lower SDIV as SDIV return SDValue(N,0); // Lower SDIV as SDIV
return SDValue(); return SDValue();
} }
/// \brief Given an ISD::SDIV node expressing a divide by constant, /// \brief Given an ISD::SDIV node expressing a divide by constant,
/// return a DAG expression to select that will generate the same value by /// return a DAG expression to select that will generate the same value by
▲ Show 20 Lines • Show All 904 Lines • Show Last 20 Lines

llvm/trunk/lib/CodeGen/TargetLoweringBase.cpp

Show First 20 Lines • Show All 1,583 Lines • ▼ Show 20 Linesunsigned TargetLoweringBase::getVectorTypeBreakdown(LLVMContext &Context, EVT VT,
// the vector decimated to the appropriate level. // the vector decimated to the appropriate level.
return NumVectorRegs; return NumVectorRegs;
} }
/// Get the EVTs and ArgFlags collections that represent the legalized return /// Get the EVTs and ArgFlags collections that represent the legalized return
/// type of the given function. This does not require a DAG or a return value, /// type of the given function. This does not require a DAG or a return value,
/// and is suitable for use before any DAGs for the function are constructed. /// and is suitable for use before any DAGs for the function are constructed.
/// TODO: Move this out of TargetLowering.cpp. /// TODO: Move this out of TargetLowering.cpp.
void llvm::GetReturnInfo(Type *ReturnType, AttributeSet attr, void llvm::GetReturnInfo(Type *ReturnType, AttributeList attr,
SmallVectorImpl<ISD::OutputArg> &Outs, SmallVectorImpl<ISD::OutputArg> &Outs,
const TargetLowering &TLI, const DataLayout &DL) { const TargetLowering &TLI, const DataLayout &DL) {
SmallVector<EVT, 4> ValueVTs; SmallVector<EVT, 4> ValueVTs;
ComputeValueVTs(TLI, DL, ReturnType, ValueVTs); ComputeValueVTs(TLI, DL, ReturnType, ValueVTs);
unsigned NumValues = ValueVTs.size(); unsigned NumValues = ValueVTs.size();
if (NumValues == 0) return; if (NumValues == 0) return;
for (unsigned j = 0, f = NumValues; j != f; ++j) { for (unsigned j = 0, f = NumValues; j != f; ++j) {
EVT VT = ValueVTs[j]; EVT VT = ValueVTs[j];
ISD::NodeType ExtendKind = ISD::ANY_EXTEND; ISD::NodeType ExtendKind = ISD::ANY_EXTEND;
if (attr.hasAttribute(AttributeSet::ReturnIndex, Attribute::SExt)) if (attr.hasAttribute(AttributeList::ReturnIndex, Attribute::SExt))
ExtendKind = ISD::SIGN_EXTEND; ExtendKind = ISD::SIGN_EXTEND;
else if (attr.hasAttribute(AttributeSet::ReturnIndex, Attribute::ZExt)) else if (attr.hasAttribute(AttributeList::ReturnIndex, Attribute::ZExt))
ExtendKind = ISD::ZERO_EXTEND; ExtendKind = ISD::ZERO_EXTEND;
// FIXME: C calling convention requires the return type to be promoted to // FIXME: C calling convention requires the return type to be promoted to
// at least 32-bit. But this is not necessary for non-C calling // at least 32-bit. But this is not necessary for non-C calling
// conventions. The frontend should mark functions whose return values // conventions. The frontend should mark functions whose return values
// require promoting with signext or zeroext attributes. // require promoting with signext or zeroext attributes.
if (ExtendKind != ISD::ANY_EXTEND && VT.isInteger()) { if (ExtendKind != ISD::ANY_EXTEND && VT.isInteger()) {
MVT MinVT = TLI.getRegisterType(ReturnType->getContext(), MVT::i32); MVT MinVT = TLI.getRegisterType(ReturnType->getContext(), MVT::i32);
if (VT.bitsLT(MinVT)) if (VT.bitsLT(MinVT))
VT = MinVT; VT = MinVT;
} }
unsigned NumParts = TLI.getNumRegisters(ReturnType->getContext(), VT); unsigned NumParts = TLI.getNumRegisters(ReturnType->getContext(), VT);
MVT PartVT = TLI.getRegisterType(ReturnType->getContext(), VT); MVT PartVT = TLI.getRegisterType(ReturnType->getContext(), VT);
// 'inreg' on function refers to return value // 'inreg' on function refers to return value
ISD::ArgFlagsTy Flags = ISD::ArgFlagsTy(); ISD::ArgFlagsTy Flags = ISD::ArgFlagsTy();
if (attr.hasAttribute(AttributeSet::ReturnIndex, Attribute::InReg)) if (attr.hasAttribute(AttributeList::ReturnIndex, Attribute::InReg))
Flags.setInReg(); Flags.setInReg();
// Propagate extension type if any // Propagate extension type if any
if (attr.hasAttribute(AttributeSet::ReturnIndex, Attribute::SExt)) if (attr.hasAttribute(AttributeList::ReturnIndex, Attribute::SExt))
Flags.setSExt(); Flags.setSExt();
else if (attr.hasAttribute(AttributeSet::ReturnIndex, Attribute::ZExt)) else if (attr.hasAttribute(AttributeList::ReturnIndex, Attribute::ZExt))
Flags.setZExt(); Flags.setZExt();
for (unsigned i = 0; i < NumParts; ++i) for (unsigned i = 0; i < NumParts; ++i)
Outs.push_back(ISD::OutputArg(Flags, PartVT, VT, /*isFixed=*/true, 0, 0)); Outs.push_back(ISD::OutputArg(Flags, PartVT, VT, /*isFixed=*/true, 0, 0));
} }
} }
/// getByValTypeAlignment - Return the desired alignment for ByVal aggregate /// getByValTypeAlignment - Return the desired alignment for ByVal aggregate
▲ Show 20 Lines • Show All 457 Lines • Show Last 20 Lines

llvm/trunk/lib/ExecutionEngine/ExecutionEngineBindings.cpp

Show First 20 Lines • Show All 182 Lines • ▼ Show 20 LinesLLVMBool LLVMCreateMCJITCompilerForModule(
std::unique_ptr<Module> Mod(unwrap(M)); std::unique_ptr<Module> Mod(unwrap(M));
if (Mod) if (Mod)
// Set function attribute "no-frame-pointer-elim" based on // Set function attribute "no-frame-pointer-elim" based on
// NoFramePointerElim. // NoFramePointerElim.
for (auto &F : *Mod) { for (auto &F : *Mod) {
auto Attrs = F.getAttributes(); auto Attrs = F.getAttributes();
StringRef Value(options.NoFramePointerElim ? "true" : "false"); StringRef Value(options.NoFramePointerElim ? "true" : "false");
Attrs = Attrs.addAttribute(F.getContext(), AttributeSet::FunctionIndex, Attrs = Attrs.addAttribute(F.getContext(), AttributeList::FunctionIndex,
"no-frame-pointer-elim", Value); "no-frame-pointer-elim", Value);
F.setAttributes(Attrs); F.setAttributes(Attrs);
} }
std::string Error; std::string Error;
EngineBuilder builder(std::move(Mod)); EngineBuilder builder(std::move(Mod));
builder.setEngineKind(EngineKind::JIT) builder.setEngineKind(EngineKind::JIT)
.setErrorStr(&Error) .setErrorStr(&Error)
▲ Show 20 Lines • Show All 212 Lines • Show Last 20 Lines

llvm/trunk/lib/IR/AsmWriter.cpp

Show First 20 Lines • Show All 598 Lines • ▼ Show 20 Linesprivate:
ValueMap fMap; ValueMap fMap;
unsigned fNext; unsigned fNext;
/// mdnMap - Map for MDNodes. /// mdnMap - Map for MDNodes.
DenseMap<const MDNode*, unsigned> mdnMap; DenseMap<const MDNode*, unsigned> mdnMap;
unsigned mdnNext; unsigned mdnNext;
/// asMap - The slot map for attribute sets. /// asMap - The slot map for attribute sets.
DenseMap<AttributeSet, unsigned> asMap; DenseMap<AttributeList, unsigned> asMap;
unsigned asNext; unsigned asNext;
public: public:
/// Construct from a module. /// Construct from a module.
/// ///
/// If \c ShouldInitializeAllMetadata, initializes all metadata in all /// If \c ShouldInitializeAllMetadata, initializes all metadata in all
/// functions, giving correct numbering for metadata referenced only from /// functions, giving correct numbering for metadata referenced only from
/// within a function (even if no functions have been initialized). /// within a function (even if no functions have been initialized).
explicit SlotTracker(const Module *M, explicit SlotTracker(const Module *M,
bool ShouldInitializeAllMetadata = false); bool ShouldInitializeAllMetadata = false);
/// Construct from a function, starting out in incorp state. /// Construct from a function, starting out in incorp state.
/// ///
/// If \c ShouldInitializeAllMetadata, initializes all metadata in all /// If \c ShouldInitializeAllMetadata, initializes all metadata in all
/// functions, giving correct numbering for metadata referenced only from /// functions, giving correct numbering for metadata referenced only from
/// within a function (even if no functions have been initialized). /// within a function (even if no functions have been initialized).
explicit SlotTracker(const Function *F, explicit SlotTracker(const Function *F,
bool ShouldInitializeAllMetadata = false); bool ShouldInitializeAllMetadata = false);
/// Return the slot number of the specified value in it's type /// Return the slot number of the specified value in it's type
/// plane. If something is not in the SlotTracker, return -1. /// plane. If something is not in the SlotTracker, return -1.
int getLocalSlot(const Value *V); int getLocalSlot(const Value *V);
int getGlobalSlot(const GlobalValue *V); int getGlobalSlot(const GlobalValue *V);
int getMetadataSlot(const MDNode *N); int getMetadataSlot(const MDNode *N);
int getAttributeGroupSlot(AttributeSet AS); int getAttributeGroupSlot(AttributeList AS);
/// If you'd like to deal with a function instead of just a module, use /// If you'd like to deal with a function instead of just a module, use
/// this method to get its data into the SlotTracker. /// this method to get its data into the SlotTracker.
void incorporateFunction(const Function *F) { void incorporateFunction(const Function *F) {
TheFunction = F; TheFunction = F;
FunctionProcessed = false; FunctionProcessed = false;
} }
const Function *getFunction() const { return TheFunction; } const Function *getFunction() const { return TheFunction; }
/// After calling incorporateFunction, use this method to remove the /// After calling incorporateFunction, use this method to remove the
/// most recently incorporated function from the SlotTracker. This /// most recently incorporated function from the SlotTracker. This
/// will reset the state of the machine back to just the module contents. /// will reset the state of the machine back to just the module contents.
void purgeFunction(); void purgeFunction();
/// MDNode map iterators. /// MDNode map iterators.
typedef DenseMap<const MDNode*, unsigned>::iterator mdn_iterator; typedef DenseMap<const MDNode*, unsigned>::iterator mdn_iterator;
mdn_iterator mdn_begin() { return mdnMap.begin(); } mdn_iterator mdn_begin() { return mdnMap.begin(); }
mdn_iterator mdn_end() { return mdnMap.end(); } mdn_iterator mdn_end() { return mdnMap.end(); }
unsigned mdn_size() const { return mdnMap.size(); } unsigned mdn_size() const { return mdnMap.size(); }
bool mdn_empty() const { return mdnMap.empty(); } bool mdn_empty() const { return mdnMap.empty(); }
/// AttributeSet map iterators. /// AttributeList map iterators.
typedef DenseMap<AttributeSet, unsigned>::iterator as_iterator; typedef DenseMap<AttributeList, unsigned>::iterator as_iterator;
as_iterator as_begin() { return asMap.begin(); } as_iterator as_begin() { return asMap.begin(); }
as_iterator as_end() { return asMap.end(); } as_iterator as_end() { return asMap.end(); }
unsigned as_size() const { return asMap.size(); } unsigned as_size() const { return asMap.size(); }
bool as_empty() const { return asMap.empty(); } bool as_empty() const { return asMap.empty(); }
/// This function does the actual initialization. /// This function does the actual initialization.
inline void initialize(); inline void initialize();
// Implementation Details // Implementation Details
private: private:
/// CreateModuleSlot - Insert the specified GlobalValue* into the slot table. /// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
void CreateModuleSlot(const GlobalValue *V); void CreateModuleSlot(const GlobalValue *V);
/// CreateMetadataSlot - Insert the specified MDNode* into the slot table. /// CreateMetadataSlot - Insert the specified MDNode* into the slot table.
void CreateMetadataSlot(const MDNode *N); void CreateMetadataSlot(const MDNode *N);
/// CreateFunctionSlot - Insert the specified Value* into the slot table. /// CreateFunctionSlot - Insert the specified Value* into the slot table.
void CreateFunctionSlot(const Value *V); void CreateFunctionSlot(const Value *V);
/// \brief Insert the specified AttributeSet into the slot table. /// \brief Insert the specified AttributeList into the slot table.
void CreateAttributeSetSlot(AttributeSet AS); void CreateAttributeSetSlot(AttributeList AS);
/// Add all of the module level global variables (and their initializers) /// Add all of the module level global variables (and their initializers)
/// and function declarations, but not the contents of those functions. /// and function declarations, but not the contents of those functions.
void processModule(); void processModule();
/// Add all of the functions arguments, basic blocks, and instructions. /// Add all of the functions arguments, basic blocks, and instructions.
void processFunction(); void processFunction();
▲ Show 20 Lines • Show All 142 Lines • ▼ Show 20 Lines if (!F.hasName())
// Add all the unnamed functions to the table. // Add all the unnamed functions to the table.
CreateModuleSlot(&F); CreateModuleSlot(&F);
if (ShouldInitializeAllMetadata) if (ShouldInitializeAllMetadata)
processFunctionMetadata(F); processFunctionMetadata(F);
// Add all the function attributes to the table. // Add all the function attributes to the table.
// FIXME: Add attributes of other objects? // FIXME: Add attributes of other objects?
AttributeSet FnAttrs = F.getAttributes().getFnAttributes(); AttributeList FnAttrs = F.getAttributes().getFnAttributes();
if (FnAttrs.hasAttributes(AttributeSet::FunctionIndex)) if (FnAttrs.hasAttributes(AttributeList::FunctionIndex))
CreateAttributeSetSlot(FnAttrs); CreateAttributeSetSlot(FnAttrs);
} }
ST_DEBUG("end processModule!\n"); ST_DEBUG("end processModule!\n");
} }
// Process the arguments, basic blocks, and instructions of a function. // Process the arguments, basic blocks, and instructions of a function.
void SlotTracker::processFunction() { void SlotTracker::processFunction() {
Show All 20 Lines for (auto &BB : *TheFunction) {
for (auto &I : BB) { for (auto &I : BB) {
if (!I.getType()->isVoidTy() && !I.hasName()) if (!I.getType()->isVoidTy() && !I.hasName())
CreateFunctionSlot(&I); CreateFunctionSlot(&I);
// We allow direct calls to any llvm.foo function here, because the // We allow direct calls to any llvm.foo function here, because the
// target may not be linked into the optimizer. // target may not be linked into the optimizer.
if (const CallInst *CI = dyn_cast<CallInst>(&I)) { if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
// Add all the call attributes to the table. // Add all the call attributes to the table.
AttributeSet Attrs = CI->getAttributes().getFnAttributes(); AttributeList Attrs = CI->getAttributes().getFnAttributes();
if (Attrs.hasAttributes(AttributeSet::FunctionIndex)) if (Attrs.hasAttributes(AttributeList::FunctionIndex))
CreateAttributeSetSlot(Attrs); CreateAttributeSetSlot(Attrs);
} else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) { } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
// Add all the call attributes to the table. // Add all the call attributes to the table.
AttributeSet Attrs = II->getAttributes().getFnAttributes(); AttributeList Attrs = II->getAttributes().getFnAttributes();
if (Attrs.hasAttributes(AttributeSet::FunctionIndex)) if (Attrs.hasAttributes(AttributeList::FunctionIndex))
CreateAttributeSetSlot(Attrs); CreateAttributeSetSlot(Attrs);
} }
} }
} }
FunctionProcessed = true; FunctionProcessed = true;
ST_DEBUG("end processFunction!\n"); ST_DEBUG("end processFunction!\n");
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Linesint SlotTracker::getLocalSlot(const Value *V) {
// Check for uninitialized state and do lazy initialization. // Check for uninitialized state and do lazy initialization.
initialize(); initialize();
ValueMap::iterator FI = fMap.find(V); ValueMap::iterator FI = fMap.find(V);
return FI == fMap.end() ? -1 : (int)FI->second; return FI == fMap.end() ? -1 : (int)FI->second;
} }
int SlotTracker::getAttributeGroupSlot(AttributeSet AS) { int SlotTracker::getAttributeGroupSlot(AttributeList AS) {
// Check for uninitialized state and do lazy initialization. // Check for uninitialized state and do lazy initialization.
initialize(); initialize();
// Find the AttributeSet in the module map. // Find the AttributeList in the module map.
as_iterator AI = asMap.find(AS); as_iterator AI = asMap.find(AS);
return AI == asMap.end() ? -1 : (int)AI->second; return AI == asMap.end() ? -1 : (int)AI->second;
} }
/// CreateModuleSlot - Insert the specified GlobalValue* into the slot table. /// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
void SlotTracker::CreateModuleSlot(const GlobalValue *V) { void SlotTracker::CreateModuleSlot(const GlobalValue *V) {
assert(V && "Can't insert a null Value into SlotTracker!"); assert(V && "Can't insert a null Value into SlotTracker!");
assert(!V->getType()->isVoidTy() && "Doesn't need a slot!"); assert(!V->getType()->isVoidTy() && "Doesn't need a slot!");
Show All 33 Linesvoid SlotTracker::CreateMetadataSlot(const MDNode *N) {
++mdnNext; ++mdnNext;
// Recursively add any MDNodes referenced by operands. // Recursively add any MDNodes referenced by operands.
for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
if (const MDNode *Op = dyn_cast_or_null<MDNode>(N->getOperand(i))) if (const MDNode *Op = dyn_cast_or_null<MDNode>(N->getOperand(i)))
CreateMetadataSlot(Op); CreateMetadataSlot(Op);
} }
void SlotTracker::CreateAttributeSetSlot(AttributeSet AS) { void SlotTracker::CreateAttributeSetSlot(AttributeList AS) {
assert(AS.hasAttributes(AttributeSet::FunctionIndex) && assert(AS.hasAttributes(AttributeList::FunctionIndex) &&
"Doesn't need a slot!"); "Doesn't need a slot!");
as_iterator I = asMap.find(AS); as_iterator I = asMap.find(AS);
if (I != asMap.end()) if (I != asMap.end())
return; return;
unsigned DestSlot = asNext++; unsigned DestSlot = asNext++;
asMap[AS] = DestSlot; asMap[AS] = DestSlot;
▲ Show 20 Lines • Show All 1,055 Lines • ▼ Show 20 Lines AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac, const Module *M,
bool ShouldPreserveUseListOrder = false); bool ShouldPreserveUseListOrder = false);
void printMDNodeBody(const MDNode *MD); void printMDNodeBody(const MDNode *MD);
void printNamedMDNode(const NamedMDNode *NMD); void printNamedMDNode(const NamedMDNode *NMD);
void printModule(const Module *M); void printModule(const Module *M);
void writeOperand(const Value *Op, bool PrintType); void writeOperand(const Value *Op, bool PrintType);
void writeParamOperand(const Value *Operand, AttributeSet Attrs,unsigned Idx); void writeParamOperand(const Value *Operand, AttributeList Attrs,
unsigned Idx);
void writeOperandBundles(ImmutableCallSite CS); void writeOperandBundles(ImmutableCallSite CS);
void writeAtomic(AtomicOrdering Ordering, SynchronizationScope SynchScope); void writeAtomic(AtomicOrdering Ordering, SynchronizationScope SynchScope);
void writeAtomicCmpXchg(AtomicOrdering SuccessOrdering, void writeAtomicCmpXchg(AtomicOrdering SuccessOrdering,
AtomicOrdering FailureOrdering, AtomicOrdering FailureOrdering,
SynchronizationScope SynchScope); SynchronizationScope SynchScope);
void writeAllMDNodes(); void writeAllMDNodes();
void writeMDNode(unsigned Slot, const MDNode *Node); void writeMDNode(unsigned Slot, const MDNode *Node);
void writeAllAttributeGroups(); void writeAllAttributeGroups();
void printTypeIdentities(); void printTypeIdentities();
void printGlobal(const GlobalVariable *GV); void printGlobal(const GlobalVariable *GV);
void printIndirectSymbol(const GlobalIndirectSymbol *GIS); void printIndirectSymbol(const GlobalIndirectSymbol *GIS);
void printComdat(const Comdat *C); void printComdat(const Comdat *C);
void printFunction(const Function *F); void printFunction(const Function *F);
void printArgument(const Argument *FA, AttributeSet Attrs, unsigned Idx); void printArgument(const Argument *FA, AttributeList Attrs, unsigned Idx);
void printBasicBlock(const BasicBlock *BB); void printBasicBlock(const BasicBlock *BB);
void printInstructionLine(const Instruction &I); void printInstructionLine(const Instruction &I);
void printInstruction(const Instruction &I); void printInstruction(const Instruction &I);
void printUseListOrder(const UseListOrder &Order); void printUseListOrder(const UseListOrder &Order);
void printUseLists(const Function *F); void printUseLists(const Function *F);
private: private:
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Linesvoid AssemblyWriter::writeAtomicCmpXchg(AtomicOrdering SuccessOrdering,
case CrossThread: break; case CrossThread: break;
} }
Out << " " << toIRString(SuccessOrdering); Out << " " << toIRString(SuccessOrdering);
Out << " " << toIRString(FailureOrdering); Out << " " << toIRString(FailureOrdering);
} }
void AssemblyWriter::writeParamOperand(const Value *Operand, void AssemblyWriter::writeParamOperand(const Value *Operand,
AttributeSet Attrs, unsigned Idx) { AttributeList Attrs, unsigned Idx) {
if (!Operand) { if (!Operand) {
Out << "<null operand!>"; Out << "<null operand!>";
return; return;
} }
// Print the type // Print the type
TypePrinter.print(Operand->getType(), Out); TypePrinter.print(Operand->getType(), Out);
// Print parameter attributes list // Print parameter attributes list
▲ Show 20 Lines • Show All 401 Lines • ▼ Show 20 Linesvoid AssemblyWriter::printFunction(const Function *F) {
// Print out the return type and name. // Print out the return type and name.
Out << '\n'; Out << '\n';
if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out); if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out);
if (F->isMaterializable()) if (F->isMaterializable())
Out << "; Materializable\n"; Out << "; Materializable\n";
const AttributeSet &Attrs = F->getAttributes(); const AttributeList &Attrs = F->getAttributes();
if (Attrs.hasAttributes(AttributeSet::FunctionIndex)) { if (Attrs.hasAttributes(AttributeList::FunctionIndex)) {
AttributeSet AS = Attrs.getFnAttributes(); AttributeList AS = Attrs.getFnAttributes();
std::string AttrStr; std::string AttrStr;
unsigned Idx = 0; unsigned Idx = 0;
for (unsigned E = AS.getNumSlots(); Idx != E; ++Idx) for (unsigned E = AS.getNumSlots(); Idx != E; ++Idx)
if (AS.getSlotIndex(Idx) == AttributeSet::FunctionIndex) if (AS.getSlotIndex(Idx) == AttributeList::FunctionIndex)
break; break;
for (AttributeSet::iterator I = AS.begin(Idx), E = AS.end(Idx); for (AttributeList::iterator I = AS.begin(Idx), E = AS.end(Idx); I != E;
I != E; ++I) { ++I) {
Attribute Attr = *I; Attribute Attr = *I;
if (!Attr.isStringAttribute()) { if (!Attr.isStringAttribute()) {
if (!AttrStr.empty()) AttrStr += ' '; if (!AttrStr.empty()) AttrStr += ' ';
AttrStr += Attr.getAsString(); AttrStr += Attr.getAsString();
} }
} }
if (!AttrStr.empty()) if (!AttrStr.empty())
Show All 17 Linesvoid AssemblyWriter::printFunction(const Function *F) {
// Print the calling convention. // Print the calling convention.
if (F->getCallingConv() != CallingConv::C) { if (F->getCallingConv() != CallingConv::C) {
PrintCallingConv(F->getCallingConv(), Out); PrintCallingConv(F->getCallingConv(), Out);
Out << " "; Out << " ";
} }
FunctionType *FT = F->getFunctionType(); FunctionType *FT = F->getFunctionType();
if (Attrs.hasAttributes(AttributeSet::ReturnIndex)) if (Attrs.hasAttributes(AttributeList::ReturnIndex))
Out << Attrs.getAsString(AttributeSet::ReturnIndex) << ' '; Out << Attrs.getAsString(AttributeList::ReturnIndex) << ' ';
TypePrinter.print(F->getReturnType(), Out); TypePrinter.print(F->getReturnType(), Out);
Out << ' '; Out << ' ';
WriteAsOperandInternal(Out, F, &TypePrinter, &Machine, F->getParent()); WriteAsOperandInternal(Out, F, &TypePrinter, &Machine, F->getParent());
Out << '('; Out << '(';
// Loop over the arguments, printing them... // Loop over the arguments, printing them...
if (F->isDeclaration() && !IsForDebug) { if (F->isDeclaration() && !IsForDebug) {
// We're only interested in the type here - don't print argument names. // We're only interested in the type here - don't print argument names.
Show All 22 Linesvoid AssemblyWriter::printFunction(const Function *F) {
if (FT->isVarArg()) { if (FT->isVarArg()) {
if (FT->getNumParams()) Out << ", "; if (FT->getNumParams()) Out << ", ";
Out << "..."; // Output varargs portion of signature! Out << "..."; // Output varargs portion of signature!
} }
Out << ')'; Out << ')';
StringRef UA = getUnnamedAddrEncoding(F->getUnnamedAddr()); StringRef UA = getUnnamedAddrEncoding(F->getUnnamedAddr());
if (!UA.empty()) if (!UA.empty())
Out << ' ' << UA; Out << ' ' << UA;
if (Attrs.hasAttributes(AttributeSet::FunctionIndex)) if (Attrs.hasAttributes(AttributeList::FunctionIndex))
Out << " #" << Machine.getAttributeGroupSlot(Attrs.getFnAttributes()); Out << " #" << Machine.getAttributeGroupSlot(Attrs.getFnAttributes());
if (F->hasSection()) { if (F->hasSection()) {
Out << " section \""; Out << " section \"";
PrintEscapedString(F->getSection(), Out); PrintEscapedString(F->getSection(), Out);
Out << '"'; Out << '"';
} }
maybePrintComdat(Out, *F); maybePrintComdat(Out, *F);
if (F->getAlignment()) if (F->getAlignment())
Show All 32 Linesvoid AssemblyWriter::printFunction(const Function *F) {
} }
Machine.purgeFunction(); Machine.purgeFunction();
} }
/// printArgument - This member is called for every argument that is passed into /// printArgument - This member is called for every argument that is passed into
/// the function. Simply print it out /// the function. Simply print it out
/// ///
void AssemblyWriter::printArgument(const Argument *Arg, void AssemblyWriter::printArgument(const Argument *Arg, AttributeList Attrs,
AttributeSet Attrs, unsigned Idx) { unsigned Idx) {
// Output type... // Output type...
TypePrinter.print(Arg->getType(), Out); TypePrinter.print(Arg->getType(), Out);
// Output parameter attributes list // Output parameter attributes list
if (Attrs.hasAttributes(Idx)) if (Attrs.hasAttributes(Idx))
Out << ' ' << Attrs.getAsString(Idx); Out << ' ' << Attrs.getAsString(Idx);
// Output name, if available... // Output name, if available...
▲ Show 20 Lines • Show All 267 Lines • ▼ Show 20 Lines if (isa<BranchInst>(I) && cast<BranchInst>(I).isConditional()) {
if (CI->getCallingConv() != CallingConv::C) { if (CI->getCallingConv() != CallingConv::C) {
Out << " "; Out << " ";
PrintCallingConv(CI->getCallingConv(), Out); PrintCallingConv(CI->getCallingConv(), Out);
} }
Operand = CI->getCalledValue(); Operand = CI->getCalledValue();
FunctionType *FTy = CI->getFunctionType(); FunctionType *FTy = CI->getFunctionType();
Type *RetTy = FTy->getReturnType(); Type *RetTy = FTy->getReturnType();
const AttributeSet &PAL = CI->getAttributes(); const AttributeList &PAL = CI->getAttributes();
if (PAL.hasAttributes(AttributeSet::ReturnIndex)) if (PAL.hasAttributes(AttributeList::ReturnIndex))
Out << ' ' << PAL.getAsString(AttributeSet::ReturnIndex); Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);
// If possible, print out the short form of the call instruction. We can // If possible, print out the short form of the call instruction. We can
// only do this if the first argument is a pointer to a nonvararg function, // only do this if the first argument is a pointer to a nonvararg function,
// and if the return type is not a pointer to a function. // and if the return type is not a pointer to a function.
// //
Out << ' '; Out << ' ';
TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out); TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
Out << ' '; Out << ' ';
writeOperand(Operand, false); writeOperand(Operand, false);
Out << '('; Out << '(';
for (unsigned op = 0, Eop = CI->getNumArgOperands(); op < Eop; ++op) { for (unsigned op = 0, Eop = CI->getNumArgOperands(); op < Eop; ++op) {
if (op > 0) if (op > 0)
Out << ", "; Out << ", ";
writeParamOperand(CI->getArgOperand(op), PAL, op + 1); writeParamOperand(CI->getArgOperand(op), PAL, op + 1);
} }
// Emit an ellipsis if this is a musttail call in a vararg function. This // Emit an ellipsis if this is a musttail call in a vararg function. This
// is only to aid readability, musttail calls forward varargs by default. // is only to aid readability, musttail calls forward varargs by default.
if (CI->isMustTailCall() && CI->getParent() && if (CI->isMustTailCall() && CI->getParent() &&
CI->getParent()->getParent() && CI->getParent()->getParent() &&
CI->getParent()->getParent()->isVarArg()) CI->getParent()->getParent()->isVarArg())
Out << ", ..."; Out << ", ...";
Out << ')'; Out << ')';
if (PAL.hasAttributes(AttributeSet::FunctionIndex)) if (PAL.hasAttributes(AttributeList::FunctionIndex))
Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes()); Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes());
writeOperandBundles(CI); writeOperandBundles(CI);
} else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) { } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
Operand = II->getCalledValue(); Operand = II->getCalledValue();
FunctionType *FTy = II->getFunctionType(); FunctionType *FTy = II->getFunctionType();
Type *RetTy = FTy->getReturnType(); Type *RetTy = FTy->getReturnType();
const AttributeSet &PAL = II->getAttributes(); const AttributeList &PAL = II->getAttributes();
// Print the calling convention being used. // Print the calling convention being used.
if (II->getCallingConv() != CallingConv::C) { if (II->getCallingConv() != CallingConv::C) {
Out << " "; Out << " ";
PrintCallingConv(II->getCallingConv(), Out); PrintCallingConv(II->getCallingConv(), Out);
} }
if (PAL.hasAttributes(AttributeSet::ReturnIndex)) if (PAL.hasAttributes(AttributeList::ReturnIndex))
Out << ' ' << PAL.getAsString(AttributeSet::ReturnIndex); Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);
// If possible, print out the short form of the invoke instruction. We can // If possible, print out the short form of the invoke instruction. We can
// only do this if the first argument is a pointer to a nonvararg function, // only do this if the first argument is a pointer to a nonvararg function,
// and if the return type is not a pointer to a function. // and if the return type is not a pointer to a function.
// //
Out << ' '; Out << ' ';
TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out); TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
Out << ' '; Out << ' ';
writeOperand(Operand, false); writeOperand(Operand, false);
Out << '('; Out << '(';
for (unsigned op = 0, Eop = II->getNumArgOperands(); op < Eop; ++op) { for (unsigned op = 0, Eop = II->getNumArgOperands(); op < Eop; ++op) {
if (op) if (op)
Out << ", "; Out << ", ";
writeParamOperand(II->getArgOperand(op), PAL, op + 1); writeParamOperand(II->getArgOperand(op), PAL, op + 1);
} }
Out << ')'; Out << ')';
if (PAL.hasAttributes(AttributeSet::FunctionIndex)) if (PAL.hasAttributes(AttributeList::FunctionIndex))
Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes()); Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes());
writeOperandBundles(II); writeOperandBundles(II);
Out << "\n to "; Out << "\n to ";
writeOperand(II->getNormalDest(), true); writeOperand(II->getNormalDest(), true);
Out << " unwind "; Out << " unwind ";
writeOperand(II->getUnwindDest(), true); writeOperand(II->getUnwindDest(), true);
▲ Show 20 Lines • Show All 146 Lines • ▼ Show 20 Linesvoid AssemblyWriter::writeAllMDNodes() {
} }
} }
void AssemblyWriter::printMDNodeBody(const MDNode *Node) { void AssemblyWriter::printMDNodeBody(const MDNode *Node) {
WriteMDNodeBodyInternal(Out, Node, &TypePrinter, &Machine, TheModule); WriteMDNodeBodyInternal(Out, Node, &TypePrinter, &Machine, TheModule);
} }
void AssemblyWriter::writeAllAttributeGroups() { void AssemblyWriter::writeAllAttributeGroups() {
std::vector<std::pair<AttributeSet, unsigned> > asVec; std::vector<std::pair<AttributeList, unsigned>> asVec;
asVec.resize(Machine.as_size()); asVec.resize(Machine.as_size());
for (SlotTracker::as_iterator I = Machine.as_begin(), E = Machine.as_end(); for (SlotTracker::as_iterator I = Machine.as_begin(), E = Machine.as_end();
I != E; ++I) I != E; ++I)
asVec[I->second] = *I; asVec[I->second] = *I;
for (const auto &I : asVec) for (const auto &I : asVec)
Out << "attributes #" << I.second << " = { " Out << "attributes #" << I.second << " = { "
<< I.first.getAsString(AttributeSet::FunctionIndex, true) << " }\n"; << I.first.getAsString(AttributeList::FunctionIndex, true) << " }\n";
} }
void AssemblyWriter::printUseListOrder(const UseListOrder &Order) { void AssemblyWriter::printUseListOrder(const UseListOrder &Order) {
bool IsInFunction = Machine.getFunction(); bool IsInFunction = Machine.getFunction();
if (IsInFunction) if (IsInFunction)
Out << " "; Out << " ";
Out << "uselistorder"; Out << "uselistorder";
▲ Show 20 Lines • Show All 308 Lines • Show Last 20 Lines

llvm/trunk/lib/IR/AttributeImpl.h

Show First 20 Lines • Show All 144 Lines • ▼ Show 20 Lines
}; };
typedef std::pair<unsigned, AttributeSetNode *> IndexAttrPair; typedef std::pair<unsigned, AttributeSetNode *> IndexAttrPair;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// \class /// \class
/// \brief This class represents a set of attributes that apply to the function, /// \brief This class represents a set of attributes that apply to the function,
/// return type, and parameters. /// return type, and parameters.
class AttributeSetImpl final class AttributeListImpl final
: public FoldingSetNode, : public FoldingSetNode,
private TrailingObjects<AttributeSetImpl, IndexAttrPair> { private TrailingObjects<AttributeListImpl, IndexAttrPair> {
friend class AttributeSet; friend class AttributeList;
friend TrailingObjects; friend TrailingObjects;
private: private:
LLVMContext &Context; LLVMContext &Context;
unsigned NumSlots; ///< Number of entries in this set. unsigned NumSlots; ///< Number of entries in this set.
/// Bitset with a bit for each available attribute Attribute::AttrKind. /// Bitset with a bit for each available attribute Attribute::AttrKind.
uint64_t AvailableFunctionAttrs; uint64_t AvailableFunctionAttrs;
// Helper fn for TrailingObjects class. // Helper fn for TrailingObjects class.
size_t numTrailingObjects(OverloadToken<IndexAttrPair>) { return NumSlots; } size_t numTrailingObjects(OverloadToken<IndexAttrPair>) { return NumSlots; }
/// \brief Return a pointer to the IndexAttrPair for the specified slot. /// \brief Return a pointer to the IndexAttrPair for the specified slot.
const IndexAttrPair *getNode(unsigned Slot) const { const IndexAttrPair *getNode(unsigned Slot) const {
return getTrailingObjects<IndexAttrPair>() + Slot; return getTrailingObjects<IndexAttrPair>() + Slot;
} }
public: public:
AttributeSetImpl(LLVMContext &C, AttributeListImpl(LLVMContext &C,
ArrayRef<std::pair<unsigned, AttributeSetNode *>> Slots) ArrayRef<std::pair<unsigned, AttributeSetNode *>> Slots)
: Context(C), NumSlots(Slots.size()), AvailableFunctionAttrs(0) { : Context(C), NumSlots(Slots.size()), AvailableFunctionAttrs(0) {
static_assert(Attribute::EndAttrKinds <= static_assert(Attribute::EndAttrKinds <=
sizeof(AvailableFunctionAttrs) * CHAR_BIT, sizeof(AvailableFunctionAttrs) * CHAR_BIT,
"Too many attributes"); "Too many attributes");
#ifndef NDEBUG #ifndef NDEBUG
if (Slots.size() >= 2) { if (Slots.size() >= 2) {
for (const std::pair<unsigned, AttributeSetNode *> *i = Slots.begin() + 1, for (const std::pair<unsigned, AttributeSetNode *> *i = Slots.begin() + 1,
*e = Slots.end(); *e = Slots.end();
i != e; ++i) { i != e; ++i) {
assert((i-1)->first <= i->first && "Attribute set not ordered!"); assert((i-1)->first <= i->first && "Attribute set not ordered!");
} }
} }
#endif #endif
// There's memory after the node where we can store the entries in. // There's memory after the node where we can store the entries in.
std::copy(Slots.begin(), Slots.end(), getTrailingObjects<IndexAttrPair>()); std::copy(Slots.begin(), Slots.end(), getTrailingObjects<IndexAttrPair>());
// Initialize AvailableFunctionAttrs summary bitset. // Initialize AvailableFunctionAttrs summary bitset.
if (NumSlots > 0) { if (NumSlots > 0) {
static_assert(AttributeSet::FunctionIndex == ~0u, static_assert(AttributeList::FunctionIndex == ~0u,
"FunctionIndex should be biggest possible index"); "FunctionIndex should be biggest possible index");
const std::pair<unsigned, AttributeSetNode *> &Last = Slots.back(); const std::pair<unsigned, AttributeSetNode *> &Last = Slots.back();
if (Last.first == AttributeSet::FunctionIndex) { if (Last.first == AttributeList::FunctionIndex) {
const AttributeSetNode *Node = Last.second; const AttributeSetNode *Node = Last.second;
for (Attribute I : *Node) { for (Attribute I : *Node) {
if (!I.isStringAttribute()) if (!I.isStringAttribute())
AvailableFunctionAttrs |= ((uint64_t)1) << I.getKindAsEnum(); AvailableFunctionAttrs |= ((uint64_t)1) << I.getKindAsEnum();
} }
} }
} }
} }
// AttributesSetImpt is uniqued, these should not be available. // AttributesSetImpt is uniqued, these should not be available.
AttributeSetImpl(const AttributeSetImpl &) = delete; AttributeListImpl(const AttributeListImpl &) = delete;
AttributeSetImpl &operator=(const AttributeSetImpl &) = delete; AttributeListImpl &operator=(const AttributeListImpl &) = delete;
void operator delete(void *p) { ::operator delete(p); } void operator delete(void *p) { ::operator delete(p); }
/// \brief Get the context that created this AttributeSetImpl. /// \brief Get the context that created this AttributeListImpl.
LLVMContext &getContext() { return Context; } LLVMContext &getContext() { return Context; }
/// \brief Return the number of slots used in this attribute list. This is /// \brief Return the number of slots used in this attribute list. This is
/// the number of arguments that have an attribute set on them (including the /// the number of arguments that have an attribute set on them (including the
/// function itself). /// function itself).
unsigned getNumSlots() const { return NumSlots; } unsigned getNumSlots() const { return NumSlots; }
/// \brief Get the index of the given "slot" in the AttrNodes list. This index /// \brief Get the index of the given "slot" in the AttrNodes list. This index
/// is the index of the return, parameter, or function object that the /// is the index of the return, parameter, or function object that the
/// attributes are applied to, not the index into the AttrNodes list where the /// attributes are applied to, not the index into the AttrNodes list where the
/// attributes reside. /// attributes reside.
unsigned getSlotIndex(unsigned Slot) const { unsigned getSlotIndex(unsigned Slot) const {
return getNode(Slot)->first; return getNode(Slot)->first;
} }
/// \brief Retrieve the attributes for the given "slot" in the AttrNode list. /// \brief Retrieve the attributes for the given "slot" in the AttrNode list.
/// \p Slot is an index into the AttrNodes list, not the index of the return / /// \p Slot is an index into the AttrNodes list, not the index of the return /
/// parameter/ function which the attributes apply to. /// parameter/ function which the attributes apply to.
AttributeSet getSlotAttributes(unsigned Slot) const { AttributeList getSlotAttributes(unsigned Slot) const {
return AttributeSet::get(Context, *getNode(Slot)); return AttributeList::get(Context, *getNode(Slot));
} }
/// \brief Retrieve the attribute set node for the given "slot" in the /// \brief Retrieve the attribute set node for the given "slot" in the
/// AttrNode list. /// AttrNode list.
AttributeSetNode *getSlotNode(unsigned Slot) const { AttributeSetNode *getSlotNode(unsigned Slot) const {
return getNode(Slot)->second; return getNode(Slot)->second;
} }
Show All 27 Lines

llvm/trunk/lib/IR/AttributeSetNode.h

//===-- AttributeSetNode.h - AttributeSet Internal Node ---------*- C++ -*-===// //===-- AttributeSetNode.h - AttributeList Internal Node ---------*- C++
//-*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// ///
/// \file /// \file
/// \brief This file defines the node class used internally by AttributeSet. /// \brief This file defines the node class used internally by AttributeList.
/// ///
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_IR_ATTRIBUTESETNODE_H #ifndef LLVM_IR_ATTRIBUTESETNODE_H
#define LLVM_IR_ATTRIBUTESETNODE_H #define LLVM_IR_ATTRIBUTESETNODE_H
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/FoldingSet.h" #include "llvm/ADT/FoldingSet.h"
Show All 40 Linespublic:
// AttributesSetNode is uniqued, these should not be available. // AttributesSetNode is uniqued, these should not be available.
AttributeSetNode(const AttributeSetNode &) = delete; AttributeSetNode(const AttributeSetNode &) = delete;
AttributeSetNode &operator=(const AttributeSetNode &) = delete; AttributeSetNode &operator=(const AttributeSetNode &) = delete;
void operator delete(void *p) { ::operator delete(p); } void operator delete(void *p) { ::operator delete(p); }
static AttributeSetNode *get(LLVMContext &C, ArrayRef<Attribute> Attrs); static AttributeSetNode *get(LLVMContext &C, ArrayRef<Attribute> Attrs);
static AttributeSetNode *get(AttributeSet AS, unsigned Index) { static AttributeSetNode *get(AttributeList AS, unsigned Index) {
return AS.getAttributes(Index); return AS.getAttributes(Index);
} }
/// \brief Return the number of attributes this AttributeSet contains. /// \brief Return the number of attributes this AttributeList contains.
unsigned getNumAttributes() const { return NumAttrs; } unsigned getNumAttributes() const { return NumAttrs; }
bool hasAttribute(Attribute::AttrKind Kind) const { bool hasAttribute(Attribute::AttrKind Kind) const {
return AvailableAttrs & ((uint64_t)1) << Kind; return AvailableAttrs & ((uint64_t)1) << Kind;
} }
bool hasAttribute(StringRef Kind) const; bool hasAttribute(StringRef Kind) const;
bool hasAttributes() const { return NumAttrs != 0; } bool hasAttributes() const { return NumAttrs != 0; }
Show All 26 Lines

llvm/trunk/lib/IR/Attributes.cpp

//===- Attributes.cpp - Implement AttributesList --------------------------===// //===- Attributes.cpp - Implement AttributesList --------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// \file // \file
// \brief This file implements the Attribute, AttributeImpl, AttrBuilder, // \brief This file implements the Attribute, AttributeImpl, AttrBuilder,
// AttributeSetImpl, and AttributeSet classes. // AttributeListImpl, and AttributeList classes.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "AttributeImpl.h" #include "AttributeImpl.h"
#include "AttributeSetNode.h" #include "AttributeSetNode.h"
#include "LLVMContextImpl.h" #include "LLVMContextImpl.h"
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/FoldingSet.h" #include "llvm/ADT/FoldingSet.h"
▲ Show 20 Lines • Show All 497 Lines • ▼ Show 20 LinesAttributeSetNode *AttributeSetNode::get(LLVMContext &C,
// new one and insert it. // new one and insert it.
if (!PA) { if (!PA) {
// Coallocate entries after the AttributeSetNode itself. // Coallocate entries after the AttributeSetNode itself.
void *Mem = ::operator new(totalSizeToAlloc<Attribute>(SortedAttrs.size())); void *Mem = ::operator new(totalSizeToAlloc<Attribute>(SortedAttrs.size()));
PA = new (Mem) AttributeSetNode(SortedAttrs); PA = new (Mem) AttributeSetNode(SortedAttrs);
pImpl->AttrsSetNodes.InsertNode(PA, InsertPoint); pImpl->AttrsSetNodes.InsertNode(PA, InsertPoint);
} }
// Return the AttributesListNode that we found or created. // Return the AttributeSetNode that we found or created.
return PA; return PA;
} }
bool AttributeSetNode::hasAttribute(StringRef Kind) const { bool AttributeSetNode::hasAttribute(StringRef Kind) const {
for (Attribute I : *this) for (Attribute I : *this)
if (I.hasAttribute(Kind)) if (I.hasAttribute(Kind))
return true; return true;
return false; return false;
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines for (iterator I = begin(), E = end(); I != E; ++I) {
if (I != begin()) if (I != begin())
Str += ' '; Str += ' ';
Str += I->getAsString(InAttrGrp); Str += I->getAsString(InAttrGrp);
} }
return Str; return Str;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// AttributeSetImpl Definition // AttributeListImpl Definition
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
LLVM_DUMP_METHOD void AttributeSetImpl::dump() const { LLVM_DUMP_METHOD void AttributeListImpl::dump() const {
AttributeSet(const_cast<AttributeSetImpl *>(this)).dump(); AttributeList(const_cast<AttributeListImpl *>(this)).dump();
} }
#endif #endif
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// AttributeSet Construction and Mutation Methods // AttributeList Construction and Mutation Methods
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
AttributeSet AttributeList AttributeList::getImpl(
AttributeSet::getImpl(LLVMContext &C, LLVMContext &C, ArrayRef<std::pair<unsigned, AttributeSetNode *>> Attrs) {
ArrayRef<std::pair<unsigned, AttributeSetNode*>> Attrs) {
LLVMContextImpl *pImpl = C.pImpl; LLVMContextImpl *pImpl = C.pImpl;
FoldingSetNodeID ID; FoldingSetNodeID ID;
AttributeSetImpl::Profile(ID, Attrs); AttributeListImpl::Profile(ID, Attrs);
void *InsertPoint; void *InsertPoint;
AttributeSetImpl *PA = pImpl->AttrsLists.FindNodeOrInsertPos(ID, InsertPoint); AttributeListImpl *PA =
pImpl->AttrsLists.FindNodeOrInsertPos(ID, InsertPoint);
// If we didn't find any existing attributes of the same shape then // If we didn't find any existing attributes of the same shape then
// create a new one and insert it. // create a new one and insert it.
if (!PA) { if (!PA) {
// Coallocate entries after the AttributeSetImpl itself. // Coallocate entries after the AttributeListImpl itself.
void *Mem = ::operator new( void *Mem = ::operator new(
AttributeSetImpl::totalSizeToAlloc<IndexAttrPair>(Attrs.size())); AttributeListImpl::totalSizeToAlloc<IndexAttrPair>(Attrs.size()));
PA = new (Mem) AttributeSetImpl(C, Attrs); PA = new (Mem) AttributeListImpl(C, Attrs);
pImpl->AttrsLists.InsertNode(PA, InsertPoint); pImpl->AttrsLists.InsertNode(PA, InsertPoint);
} }
// Return the AttributesList that we found or created. // Return the AttributesList that we found or created.
return AttributeSet(PA); return AttributeList(PA);
} }
AttributeSet AttributeSet::get(LLVMContext &C, AttributeList
AttributeList::get(LLVMContext &C,
ArrayRef<std::pair<unsigned, Attribute>> Attrs) { ArrayRef<std::pair<unsigned, Attribute>> Attrs) {
// If there are no attributes then return a null AttributesList pointer. // If there are no attributes then return a null AttributesList pointer.
if (Attrs.empty()) if (Attrs.empty())
return AttributeSet(); return AttributeList();
assert(std::is_sorted(Attrs.begin(), Attrs.end(), assert(std::is_sorted(Attrs.begin(), Attrs.end(),
[](const std::pair<unsigned, Attribute> &LHS, [](const std::pair<unsigned, Attribute> &LHS,
const std::pair<unsigned, Attribute> &RHS) { const std::pair<unsigned, Attribute> &RHS) {
return LHS.first < RHS.first; return LHS.first < RHS.first;
}) && "Misordered Attributes list!"); }) && "Misordered Attributes list!");
assert(none_of(Attrs, assert(none_of(Attrs,
[](const std::pair<unsigned, Attribute> &Pair) { [](const std::pair<unsigned, Attribute> &Pair) {
Show All 14 Lines for (ArrayRef<std::pair<unsigned, Attribute>>::iterator I = Attrs.begin(),
} }
AttrPairVec.emplace_back(Index, AttributeSetNode::get(C, AttrVec)); AttrPairVec.emplace_back(Index, AttributeSetNode::get(C, AttrVec));
} }
return getImpl(C, AttrPairVec); return getImpl(C, AttrPairVec);
} }
AttributeSet AttributeSet::get(LLVMContext &C, AttributeList
ArrayRef<std::pair<unsigned, AttributeList::get(LLVMContext &C,
AttributeSetNode*>> Attrs) { ArrayRef<std::pair<unsigned, AttributeSetNode *>> Attrs) {
// If there are no attributes then return a null AttributesList pointer. // If there are no attributes then return a null AttributesList pointer.
if (Attrs.empty()) if (Attrs.empty())
return AttributeSet(); return AttributeList();
return getImpl(C, Attrs); return getImpl(C, Attrs);
} }
AttributeSet AttributeSet::get(LLVMContext &C, unsigned Index, AttributeList AttributeList::get(LLVMContext &C, unsigned Index,
const AttrBuilder &B) { const AttrBuilder &B) {
if (!B.hasAttributes()) if (!B.hasAttributes())
return AttributeSet(); return AttributeList();
// Add target-independent attributes. // Add target-independent attributes.
SmallVector<std::pair<unsigned, Attribute>, 8> Attrs; SmallVector<std::pair<unsigned, Attribute>, 8> Attrs;
for (Attribute::AttrKind Kind = Attribute::None; for (Attribute::AttrKind Kind = Attribute::None;
Kind != Attribute::EndAttrKinds; Kind = Attribute::AttrKind(Kind + 1)) { Kind != Attribute::EndAttrKinds; Kind = Attribute::AttrKind(Kind + 1)) {
if (!B.contains(Kind)) if (!B.contains(Kind))
continue; continue;
Show All 26 LinesAttributeList AttributeList::get(LLVMContext &C, unsigned Index,
// Add target-dependent (string) attributes. // Add target-dependent (string) attributes.
for (const auto &TDA : B.td_attrs()) for (const auto &TDA : B.td_attrs())
Attrs.emplace_back(Index, Attribute::get(C, TDA.first, TDA.second)); Attrs.emplace_back(Index, Attribute::get(C, TDA.first, TDA.second));
return get(C, Attrs); return get(C, Attrs);
} }
AttributeSet AttributeSet::get(LLVMContext &C, unsigned Index, AttributeList AttributeList::get(LLVMContext &C, unsigned Index,
ArrayRef<Attribute::AttrKind> Kinds) { ArrayRef<Attribute::AttrKind> Kinds) {
SmallVector<std::pair<unsigned, Attribute>, 8> Attrs; SmallVector<std::pair<unsigned, Attribute>, 8> Attrs;
for (Attribute::AttrKind K : Kinds) for (Attribute::AttrKind K : Kinds)
Attrs.emplace_back(Index, Attribute::get(C, K)); Attrs.emplace_back(Index, Attribute::get(C, K));
return get(C, Attrs); return get(C, Attrs);
} }
AttributeSet AttributeSet::get(LLVMContext &C, unsigned Index, AttributeList AttributeList::get(LLVMContext &C, unsigned Index,
ArrayRef<StringRef> Kinds) { ArrayRef<StringRef> Kinds) {
SmallVector<std::pair<unsigned, Attribute>, 8> Attrs; SmallVector<std::pair<unsigned, Attribute>, 8> Attrs;
for (StringRef K : Kinds) for (StringRef K : Kinds)
Attrs.emplace_back(Index, Attribute::get(C, K)); Attrs.emplace_back(Index, Attribute::get(C, K));
return get(C, Attrs); return get(C, Attrs);
} }
AttributeSet AttributeSet::get(LLVMContext &C, ArrayRef<AttributeSet> Attrs) { AttributeList AttributeList::get(LLVMContext &C,
if (Attrs.empty()) return AttributeSet(); ArrayRef<AttributeList> Attrs) {
if (Attrs.empty())
return AttributeList();
if (Attrs.size() == 1) return Attrs[0]; if (Attrs.size() == 1) return Attrs[0];
SmallVector<std::pair<unsigned, AttributeSetNode*>, 8> AttrNodeVec; SmallVector<std::pair<unsigned, AttributeSetNode*>, 8> AttrNodeVec;
AttributeSetImpl *A0 = Attrs[0].pImpl; AttributeListImpl *A0 = Attrs[0].pImpl;
if (A0) if (A0)
AttrNodeVec.append(A0->getNode(0), A0->getNode(A0->getNumSlots())); AttrNodeVec.append(A0->getNode(0), A0->getNode(A0->getNumSlots()));
// Copy all attributes from Attrs into AttrNodeVec while keeping AttrNodeVec // Copy all attributes from Attrs into AttrNodeVec while keeping AttrNodeVec
// ordered by index. Because we know that each list in Attrs is ordered by // 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 // index we only need to merge each successive list in rather than doing a
// full sort. // full sort.
for (unsigned I = 1, E = Attrs.size(); I != E; ++I) { for (unsigned I = 1, E = Attrs.size(); I != E; ++I) {
AttributeSetImpl *AS = Attrs[I].pImpl; AttributeListImpl *AS = Attrs[I].pImpl;
if (!AS) continue; if (!AS) continue;
SmallVector<std::pair<unsigned, AttributeSetNode *>, 8>::iterator SmallVector<std::pair<unsigned, AttributeSetNode *>, 8>::iterator
ANVI = AttrNodeVec.begin(), ANVE; ANVI = AttrNodeVec.begin(), ANVE;
for (const IndexAttrPair *AI = AS->getNode(0), for (const IndexAttrPair *AI = AS->getNode(0),
*AE = AS->getNode(AS->getNumSlots()); *AE = AS->getNode(AS->getNumSlots());
AI != AE; ++AI) { AI != AE; ++AI) {
ANVE = AttrNodeVec.end(); ANVE = AttrNodeVec.end();
while (ANVI != ANVE && ANVI->first <= AI->first) while (ANVI != ANVE && ANVI->first <= AI->first)
++ANVI; ++ANVI;
ANVI = AttrNodeVec.insert(ANVI, *AI) + 1; ANVI = AttrNodeVec.insert(ANVI, *AI) + 1;
} }
} }
return getImpl(C, AttrNodeVec); return getImpl(C, AttrNodeVec);
} }
AttributeSet AttributeSet::addAttribute(LLVMContext &C, unsigned Index, AttributeList AttributeList::addAttribute(LLVMContext &C, unsigned Index,
Attribute::AttrKind Kind) const { Attribute::AttrKind Kind) const {
if (hasAttribute(Index, Kind)) return *this; if (hasAttribute(Index, Kind)) return *this;
return addAttributes(C, Index, AttributeSet::get(C, Index, Kind)); return addAttributes(C, Index, AttributeList::get(C, Index, Kind));
} }
AttributeSet AttributeSet::addAttribute(LLVMContext &C, unsigned Index, AttributeList AttributeList::addAttribute(LLVMContext &C, unsigned Index,
StringRef Kind, StringRef Value) const { StringRef Kind,
StringRef Value) const {
AttrBuilder B; AttrBuilder B;
B.addAttribute(Kind, Value); B.addAttribute(Kind, Value);
return addAttributes(C, Index, AttributeSet::get(C, Index, B)); return addAttributes(C, Index, AttributeList::get(C, Index, B));
} }
AttributeSet AttributeSet::addAttribute(LLVMContext &C, AttributeList AttributeList::addAttribute(LLVMContext &C,
ArrayRef<unsigned> Indices, ArrayRef<unsigned> Indices,
Attribute A) const { Attribute A) const {
unsigned I = 0, E = pImpl ? pImpl->getNumSlots() : 0; unsigned I = 0, E = pImpl ? pImpl->getNumSlots() : 0;
auto IdxI = Indices.begin(), IdxE = Indices.end(); auto IdxI = Indices.begin(), IdxE = Indices.end();
SmallVector<AttributeSet, 4> AttrSet; SmallVector<AttributeList, 4> AttrSet;
while (I != E && IdxI != IdxE) { while (I != E && IdxI != IdxE) {
if (getSlotIndex(I) < *IdxI) if (getSlotIndex(I) < *IdxI)
AttrSet.emplace_back(getSlotAttributes(I++)); AttrSet.emplace_back(getSlotAttributes(I++));
else if (getSlotIndex(I) > *IdxI) else if (getSlotIndex(I) > *IdxI)
AttrSet.emplace_back(AttributeSet::get(C, std::make_pair(*IdxI++, A))); AttrSet.emplace_back(AttributeList::get(C, std::make_pair(*IdxI++, A)));
else { else {
AttrBuilder B(getSlotAttributes(I), *IdxI); AttrBuilder B(getSlotAttributes(I), *IdxI);
B.addAttribute(A); B.addAttribute(A);
AttrSet.emplace_back(AttributeSet::get(C, *IdxI, B)); AttrSet.emplace_back(AttributeList::get(C, *IdxI, B));
++I; ++I;
++IdxI; ++IdxI;
} }
} }
while (I != E) while (I != E)
AttrSet.emplace_back(getSlotAttributes(I++)); AttrSet.emplace_back(getSlotAttributes(I++));
while (IdxI != IdxE) while (IdxI != IdxE)
AttrSet.emplace_back(AttributeSet::get(C, std::make_pair(*IdxI++, A))); AttrSet.emplace_back(AttributeList::get(C, std::make_pair(*IdxI++, A)));
return get(C, AttrSet); return get(C, AttrSet);
} }
AttributeSet AttributeSet::addAttributes(LLVMContext &C, unsigned Index, AttributeList AttributeList::addAttributes(LLVMContext &C, unsigned Index,
AttributeSet Attrs) const { AttributeList Attrs) const {
if (!pImpl) return Attrs; if (!pImpl) return Attrs;
if (!Attrs.pImpl) return *this; if (!Attrs.pImpl) return *this;
#ifndef NDEBUG #ifndef NDEBUG
// FIXME it is not obvious how this should work for alignment. For now, say // FIXME it is not obvious how this should work for alignment. For now, say
// we can't change a known alignment. // we can't change a known alignment.
unsigned OldAlign = getParamAlignment(Index); unsigned OldAlign = getParamAlignment(Index);
unsigned NewAlign = Attrs.getParamAlignment(Index); unsigned NewAlign = Attrs.getParamAlignment(Index);
assert((!OldAlign || !NewAlign || OldAlign == NewAlign) && assert((!OldAlign || !NewAlign || OldAlign == NewAlign) &&
"Attempt to change alignment!"); "Attempt to change alignment!");
#endif #endif
// Add the attribute slots before the one we're trying to add. // Add the attribute slots before the one we're trying to add.
SmallVector<AttributeSet, 4> AttrSet; SmallVector<AttributeList, 4> AttrSet;
uint64_t NumAttrs = pImpl->getNumSlots(); uint64_t NumAttrs = pImpl->getNumSlots();
AttributeSet AS; AttributeList AS;
uint64_t LastIndex = 0; uint64_t LastIndex = 0;
for (unsigned I = 0, E = NumAttrs; I != E; ++I) { for (unsigned I = 0, E = NumAttrs; I != E; ++I) {
if (getSlotIndex(I) >= Index) { if (getSlotIndex(I) >= Index) {
if (getSlotIndex(I) == Index) AS = getSlotAttributes(LastIndex++); if (getSlotIndex(I) == Index) AS = getSlotAttributes(LastIndex++);
break; break;
} }
LastIndex = I + 1; LastIndex = I + 1;
AttrSet.push_back(getSlotAttributes(I)); AttrSet.push_back(getSlotAttributes(I));
} }
// Now add the attribute into the correct slot. There may already be an // Now add the attribute into the correct slot. There may already be an
// AttributeSet there. // AttributeList there.
AttrBuilder B(AS, Index); AttrBuilder B(AS, Index);
for (unsigned I = 0, E = Attrs.pImpl->getNumSlots(); I != E; ++I) for (unsigned I = 0, E = Attrs.pImpl->getNumSlots(); I != E; ++I)
if (Attrs.getSlotIndex(I) == Index) { if (Attrs.getSlotIndex(I) == Index) {
for (AttributeSetImpl::iterator II = Attrs.pImpl->begin(I), for (AttributeListImpl::iterator II = Attrs.pImpl->begin(I),
IE = Attrs.pImpl->end(I); II != IE; ++II) IE = Attrs.pImpl->end(I);
II != IE; ++II)
B.addAttribute(*II); B.addAttribute(*II);
break; break;
} }
AttrSet.push_back(AttributeSet::get(C, Index, B)); AttrSet.push_back(AttributeList::get(C, Index, B));
// Add the remaining attribute slots. // Add the remaining attribute slots.
for (unsigned I = LastIndex, E = NumAttrs; I < E; ++I) for (unsigned I = LastIndex, E = NumAttrs; I < E; ++I)
AttrSet.push_back(getSlotAttributes(I)); AttrSet.push_back(getSlotAttributes(I));
return get(C, AttrSet); return get(C, AttrSet);
} }
AttributeSet AttributeSet::removeAttribute(LLVMContext &C, unsigned Index, AttributeList AttributeList::removeAttribute(LLVMContext &C, unsigned Index,
Attribute::AttrKind Kind) const { Attribute::AttrKind Kind) const {
if (!hasAttribute(Index, Kind)) return *this; if (!hasAttribute(Index, Kind)) return *this;
return removeAttributes(C, Index, AttributeSet::get(C, Index, Kind)); return removeAttributes(C, Index, AttributeList::get(C, Index, Kind));
} }
AttributeSet AttributeSet::removeAttribute(LLVMContext &C, unsigned Index, AttributeList AttributeList::removeAttribute(LLVMContext &C, unsigned Index,
StringRef Kind) const { StringRef Kind) const {
if (!hasAttribute(Index, Kind)) return *this; if (!hasAttribute(Index, Kind)) return *this;
return removeAttributes(C, Index, AttributeSet::get(C, Index, Kind)); return removeAttributes(C, Index, AttributeList::get(C, Index, Kind));
} }
AttributeSet AttributeSet::removeAttributes(LLVMContext &C, unsigned Index, AttributeList AttributeList::removeAttributes(LLVMContext &C, unsigned Index,
AttributeSet Attrs) const { AttributeList Attrs) const {
if (!pImpl) return AttributeSet(); if (!pImpl)
return AttributeList();
if (!Attrs.pImpl) return *this; if (!Attrs.pImpl) return *this;
// FIXME it is not obvious how this should work for alignment. // 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. // For now, say we can't pass in alignment, which no current use does.
assert(!Attrs.hasAttribute(Index, Attribute::Alignment) && assert(!Attrs.hasAttribute(Index, Attribute::Alignment) &&
"Attempt to change alignment!"); "Attempt to change alignment!");
// Add the attribute slots before the one we're trying to add. // Add the attribute slots before the one we're trying to add.
SmallVector<AttributeSet, 4> AttrSet; SmallVector<AttributeList, 4> AttrSet;
uint64_t NumAttrs = pImpl->getNumSlots(); uint64_t NumAttrs = pImpl->getNumSlots();
AttributeSet AS; AttributeList AS;
uint64_t LastIndex = 0; uint64_t LastIndex = 0;
for (unsigned I = 0, E = NumAttrs; I != E; ++I) { for (unsigned I = 0, E = NumAttrs; I != E; ++I) {
if (getSlotIndex(I) >= Index) { if (getSlotIndex(I) >= Index) {
if (getSlotIndex(I) == Index) AS = getSlotAttributes(LastIndex++); if (getSlotIndex(I) == Index) AS = getSlotAttributes(LastIndex++);
break; break;
} }
LastIndex = I + 1; LastIndex = I + 1;
AttrSet.push_back(getSlotAttributes(I)); AttrSet.push_back(getSlotAttributes(I));
} }
// Now remove the attribute from the correct slot. There may already be an // Now remove the attribute from the correct slot. There may already be an
// AttributeSet there. // AttributeList there.
AttrBuilder B(AS, Index); AttrBuilder B(AS, Index);
for (unsigned I = 0, E = Attrs.pImpl->getNumSlots(); I != E; ++I) for (unsigned I = 0, E = Attrs.pImpl->getNumSlots(); I != E; ++I)
if (Attrs.getSlotIndex(I) == Index) { if (Attrs.getSlotIndex(I) == Index) {
B.removeAttributes(Attrs.pImpl->getSlotAttributes(I), Index); B.removeAttributes(Attrs.pImpl->getSlotAttributes(I), Index);
break; break;
} }
AttrSet.push_back(AttributeSet::get(C, Index, B)); AttrSet.push_back(AttributeList::get(C, Index, B));
// Add the remaining attribute slots. // Add the remaining attribute slots.
for (unsigned I = LastIndex, E = NumAttrs; I < E; ++I) for (unsigned I = LastIndex, E = NumAttrs; I < E; ++I)
AttrSet.push_back(getSlotAttributes(I)); AttrSet.push_back(getSlotAttributes(I));
return get(C, AttrSet); return get(C, AttrSet);
} }
AttributeSet AttributeSet::removeAttributes(LLVMContext &C, unsigned Index, AttributeList AttributeList::removeAttributes(LLVMContext &C, unsigned Index,
const AttrBuilder &Attrs) const { const AttrBuilder &Attrs) const {
if (!pImpl) return AttributeSet(); if (!pImpl)
return AttributeList();
// FIXME it is not obvious how this should work for alignment. // 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. // For now, say we can't pass in alignment, which no current use does.
assert(!Attrs.hasAlignmentAttr() && "Attempt to change alignment!"); assert(!Attrs.hasAlignmentAttr() && "Attempt to change alignment!");
// Add the attribute slots before the one we're trying to add. // Add the attribute slots before the one we're trying to add.
SmallVector<AttributeSet, 4> AttrSet; SmallVector<AttributeList, 4> AttrSet;
uint64_t NumAttrs = pImpl->getNumSlots(); uint64_t NumAttrs = pImpl->getNumSlots();
AttributeSet AS; AttributeList AS;
uint64_t LastIndex = 0; uint64_t LastIndex = 0;
for (unsigned I = 0, E = NumAttrs; I != E; ++I) { for (unsigned I = 0, E = NumAttrs; I != E; ++I) {
if (getSlotIndex(I) >= Index) { if (getSlotIndex(I) >= Index) {
if (getSlotIndex(I) == Index) AS = getSlotAttributes(LastIndex++); if (getSlotIndex(I) == Index) AS = getSlotAttributes(LastIndex++);
break; break;
} }
LastIndex = I + 1; LastIndex = I + 1;
AttrSet.push_back(getSlotAttributes(I)); AttrSet.push_back(getSlotAttributes(I));
} }
// Now remove the attribute from the correct slot. There may already be an // Now remove the attribute from the correct slot. There may already be an
// AttributeSet there. // AttributeList there.
AttrBuilder B(AS, Index); AttrBuilder B(AS, Index);
B.remove(Attrs); B.remove(Attrs);
AttrSet.push_back(AttributeSet::get(C, Index, B)); AttrSet.push_back(AttributeList::get(C, Index, B));
// Add the remaining attribute slots. // Add the remaining attribute slots.
for (unsigned I = LastIndex, E = NumAttrs; I < E; ++I) for (unsigned I = LastIndex, E = NumAttrs; I < E; ++I)
AttrSet.push_back(getSlotAttributes(I)); AttrSet.push_back(getSlotAttributes(I));
return get(C, AttrSet); return get(C, AttrSet);
} }
AttributeSet AttributeSet::addDereferenceableAttr(LLVMContext &C, unsigned Index, AttributeList AttributeList::addDereferenceableAttr(LLVMContext &C,
unsigned Index,
uint64_t Bytes) const { uint64_t Bytes) const {
AttrBuilder B; AttrBuilder B;
B.addDereferenceableAttr(Bytes); B.addDereferenceableAttr(Bytes);
return addAttributes(C, Index, AttributeSet::get(C, Index, B)); return addAttributes(C, Index, AttributeList::get(C, Index, B));
} }
AttributeSet AttributeSet::addDereferenceableOrNullAttr(LLVMContext &C, AttributeList
unsigned Index, AttributeList::addDereferenceableOrNullAttr(LLVMContext &C, unsigned Index,
uint64_t Bytes) const { uint64_t Bytes) const {
AttrBuilder B; AttrBuilder B;
B.addDereferenceableOrNullAttr(Bytes); B.addDereferenceableOrNullAttr(Bytes);
return addAttributes(C, Index, AttributeSet::get(C, Index, B)); return addAttributes(C, Index, AttributeList::get(C, Index, B));
} }
AttributeSet AttributeList
AttributeSet::addAllocSizeAttr(LLVMContext &C, unsigned Index, AttributeList::addAllocSizeAttr(LLVMContext &C, unsigned Index,
unsigned ElemSizeArg, unsigned ElemSizeArg,
const Optional<unsigned> &NumElemsArg) { const Optional<unsigned> &NumElemsArg) {
AttrBuilder B; AttrBuilder B;
B.addAllocSizeAttr(ElemSizeArg, NumElemsArg); B.addAllocSizeAttr(ElemSizeArg, NumElemsArg);
return addAttributes(C, Index, AttributeSet::get(C, Index, B)); return addAttributes(C, Index, AttributeList::get(C, Index, B));
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// AttributeSet Accessor Methods // AttributeList Accessor Methods
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
LLVMContext &AttributeSet::getContext() const { LLVMContext &AttributeList::getContext() const { return pImpl->getContext(); }
return pImpl->getContext();
}
AttributeSet AttributeSet::getParamAttributes(unsigned Index) const { AttributeList AttributeList::getParamAttributes(unsigned Index) const {
return pImpl && hasAttributes(Index) ? return pImpl && hasAttributes(Index)
AttributeSet::get(pImpl->getContext(), ? AttributeList::get(
pImpl->getContext(),
ArrayRef<std::pair<unsigned, AttributeSetNode*>>( ArrayRef<std::pair<unsigned, AttributeSetNode *>>(
std::make_pair(Index, getAttributes(Index)))) : std::make_pair(Index, getAttributes(Index))))
AttributeSet(); : AttributeList();
} }
AttributeSet AttributeSet::getRetAttributes() const { AttributeList AttributeList::getRetAttributes() const {
return pImpl && hasAttributes(ReturnIndex) ? return pImpl && hasAttributes(ReturnIndex)
AttributeSet::get(pImpl->getContext(), ? AttributeList::get(
pImpl->getContext(),
ArrayRef<std::pair<unsigned, AttributeSetNode*>>( ArrayRef<std::pair<unsigned, AttributeSetNode *>>(
std::make_pair(ReturnIndex, std::make_pair(ReturnIndex, getAttributes(ReturnIndex))))
getAttributes(ReturnIndex)))) : : AttributeList();
AttributeSet();
} }
AttributeSet AttributeSet::getFnAttributes() const { AttributeList AttributeList::getFnAttributes() const {
return pImpl && hasAttributes(FunctionIndex) ? return pImpl && hasAttributes(FunctionIndex)
AttributeSet::get(pImpl->getContext(), ? AttributeList::get(
pImpl->getContext(),
ArrayRef<std::pair<unsigned, AttributeSetNode*>>( ArrayRef<std::pair<unsigned, AttributeSetNode *>>(
std::make_pair(FunctionIndex, std::make_pair(FunctionIndex,
getAttributes(FunctionIndex)))) : getAttributes(FunctionIndex))))
AttributeSet(); : AttributeList();
} }
bool AttributeSet::hasAttribute(unsigned Index, Attribute::AttrKind Kind) const{ bool AttributeList::hasAttribute(unsigned Index,
Attribute::AttrKind Kind) const {
AttributeSetNode *ASN = getAttributes(Index); AttributeSetNode *ASN = getAttributes(Index);
return ASN && ASN->hasAttribute(Kind); return ASN && ASN->hasAttribute(Kind);
} }
bool AttributeSet::hasAttribute(unsigned Index, StringRef Kind) const { bool AttributeList::hasAttribute(unsigned Index, StringRef Kind) const {
AttributeSetNode *ASN = getAttributes(Index); AttributeSetNode *ASN = getAttributes(Index);
return ASN && ASN->hasAttribute(Kind); return ASN && ASN->hasAttribute(Kind);
} }
bool AttributeSet::hasAttributes(unsigned Index) const { bool AttributeList::hasAttributes(unsigned Index) const {
AttributeSetNode *ASN = getAttributes(Index); AttributeSetNode *ASN = getAttributes(Index);
return ASN && ASN->hasAttributes(); return ASN && ASN->hasAttributes();
} }
bool AttributeSet::hasFnAttribute(Attribute::AttrKind Kind) const { bool AttributeList::hasFnAttribute(Attribute::AttrKind Kind) const {
return pImpl && pImpl->hasFnAttribute(Kind); return pImpl && pImpl->hasFnAttribute(Kind);
} }
bool AttributeSet::hasFnAttribute(StringRef Kind) const { bool AttributeList::hasFnAttribute(StringRef Kind) const {
return hasAttribute(AttributeSet::FunctionIndex, Kind); return hasAttribute(AttributeList::FunctionIndex, Kind);
} }
bool AttributeSet::hasAttrSomewhere(Attribute::AttrKind Attr, bool AttributeList::hasAttrSomewhere(Attribute::AttrKind Attr,
unsigned *Index) const { unsigned *Index) const {
if (!pImpl) return false; if (!pImpl) return false;
for (unsigned I = 0, E = pImpl->getNumSlots(); I != E; ++I) for (unsigned I = 0, E = pImpl->getNumSlots(); I != E; ++I)
for (AttributeSetImpl::iterator II = pImpl->begin(I), for (AttributeListImpl::iterator II = pImpl->begin(I), IE = pImpl->end(I);
IE = pImpl->end(I); II != IE; ++II) II != IE; ++II)
if (II->hasAttribute(Attr)) { if (II->hasAttribute(Attr)) {
if (Index) *Index = pImpl->getSlotIndex(I); if (Index) *Index = pImpl->getSlotIndex(I);
return true; return true;
} }
return false; return false;
} }
Attribute AttributeSet::getAttribute(unsigned Index, Attribute AttributeList::getAttribute(unsigned Index,
Attribute::AttrKind Kind) const { Attribute::AttrKind Kind) const {
AttributeSetNode *ASN = getAttributes(Index); AttributeSetNode *ASN = getAttributes(Index);
return ASN ? ASN->getAttribute(Kind) : Attribute(); return ASN ? ASN->getAttribute(Kind) : Attribute();
} }
Attribute AttributeSet::getAttribute(unsigned Index, Attribute AttributeList::getAttribute(unsigned Index, StringRef Kind) const {
StringRef Kind) const {
AttributeSetNode *ASN = getAttributes(Index); AttributeSetNode *ASN = getAttributes(Index);
return ASN ? ASN->getAttribute(Kind) : Attribute(); return ASN ? ASN->getAttribute(Kind) : Attribute();
} }
unsigned AttributeSet::getParamAlignment(unsigned Index) const { unsigned AttributeList::getParamAlignment(unsigned Index) const {
AttributeSetNode *ASN = getAttributes(Index); AttributeSetNode *ASN = getAttributes(Index);
return ASN ? ASN->getAlignment() : 0; return ASN ? ASN->getAlignment() : 0;
} }
unsigned AttributeSet::getStackAlignment(unsigned Index) const { unsigned AttributeList::getStackAlignment(unsigned Index) const {
AttributeSetNode *ASN = getAttributes(Index); AttributeSetNode *ASN = getAttributes(Index);
return ASN ? ASN->getStackAlignment() : 0; return ASN ? ASN->getStackAlignment() : 0;
} }
uint64_t AttributeSet::getDereferenceableBytes(unsigned Index) const { uint64_t AttributeList::getDereferenceableBytes(unsigned Index) const {
AttributeSetNode *ASN = getAttributes(Index); AttributeSetNode *ASN = getAttributes(Index);
return ASN ? ASN->getDereferenceableBytes() : 0; return ASN ? ASN->getDereferenceableBytes() : 0;
} }
uint64_t AttributeSet::getDereferenceableOrNullBytes(unsigned Index) const { uint64_t AttributeList::getDereferenceableOrNullBytes(unsigned Index) const {
AttributeSetNode *ASN = getAttributes(Index); AttributeSetNode *ASN = getAttributes(Index);
return ASN ? ASN->getDereferenceableOrNullBytes() : 0; return ASN ? ASN->getDereferenceableOrNullBytes() : 0;
} }
std::pair<unsigned, Optional<unsigned>> std::pair<unsigned, Optional<unsigned>>
AttributeSet::getAllocSizeArgs(unsigned Index) const { AttributeList::getAllocSizeArgs(unsigned Index) const {
AttributeSetNode *ASN = getAttributes(Index); AttributeSetNode *ASN = getAttributes(Index);
return ASN ? ASN->getAllocSizeArgs() : std::make_pair(0u, Optional<unsigned>(0u)); return ASN ? ASN->getAllocSizeArgs() : std::make_pair(0u, Optional<unsigned>(0u));
} }
std::string AttributeSet::getAsString(unsigned Index, bool InAttrGrp) const { std::string AttributeList::getAsString(unsigned Index, bool InAttrGrp) const {
AttributeSetNode *ASN = getAttributes(Index); AttributeSetNode *ASN = getAttributes(Index);
return ASN ? ASN->getAsString(InAttrGrp) : std::string(""); return ASN ? ASN->getAsString(InAttrGrp) : std::string("");
} }
AttributeSetNode *AttributeSet::getAttributes(unsigned Index) const { AttributeSetNode *AttributeList::getAttributes(unsigned Index) const {
if (!pImpl) return nullptr; if (!pImpl) return nullptr;
// Loop through to find the attribute node we want. // Loop through to find the attribute node we want.
for (unsigned I = 0, E = pImpl->getNumSlots(); I != E; ++I) for (unsigned I = 0, E = pImpl->getNumSlots(); I != E; ++I)
if (pImpl->getSlotIndex(I) == Index) if (pImpl->getSlotIndex(I) == Index)
return pImpl->getSlotNode(I); return pImpl->getSlotNode(I);
return nullptr; return nullptr;
} }
AttributeSet::iterator AttributeSet::begin(unsigned Slot) const { AttributeList::iterator AttributeList::begin(unsigned Slot) const {
if (!pImpl) if (!pImpl)
return ArrayRef<Attribute>().begin(); return ArrayRef<Attribute>().begin();
return pImpl->begin(Slot); return pImpl->begin(Slot);
} }
AttributeSet::iterator AttributeSet::end(unsigned Slot) const { AttributeList::iterator AttributeList::end(unsigned Slot) const {
if (!pImpl) if (!pImpl)
return ArrayRef<Attribute>().end(); return ArrayRef<Attribute>().end();
return pImpl->end(Slot); return pImpl->end(Slot);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// AttributeSet Introspection Methods // AttributeList Introspection Methods
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
unsigned AttributeSet::getNumSlots() const { unsigned AttributeList::getNumSlots() const {
return pImpl ? pImpl->getNumSlots() : 0; return pImpl ? pImpl->getNumSlots() : 0;
} }
unsigned AttributeSet::getSlotIndex(unsigned Slot) const { unsigned AttributeList::getSlotIndex(unsigned Slot) const {
assert(pImpl && Slot < pImpl->getNumSlots() && assert(pImpl && Slot < pImpl->getNumSlots() &&
"Slot # out of range!"); "Slot # out of range!");
return pImpl->getSlotIndex(Slot); return pImpl->getSlotIndex(Slot);
} }
AttributeSet AttributeSet::getSlotAttributes(unsigned Slot) const { AttributeList AttributeList::getSlotAttributes(unsigned Slot) const {
assert(pImpl && Slot < pImpl->getNumSlots() && assert(pImpl && Slot < pImpl->getNumSlots() &&
"Slot # out of range!"); "Slot # out of range!");
return pImpl->getSlotAttributes(Slot); return pImpl->getSlotAttributes(Slot);
} }
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
LLVM_DUMP_METHOD void AttributeSet::dump() const { LLVM_DUMP_METHOD void AttributeList::dump() const {
dbgs() << "PAL[\n"; dbgs() << "PAL[\n";
for (unsigned i = 0, e = getNumSlots(); i < e; ++i) { for (unsigned i = 0, e = getNumSlots(); i < e; ++i) {
uint64_t Index = getSlotIndex(i); uint64_t Index = getSlotIndex(i);
dbgs() << " { "; dbgs() << " { ";
if (Index == ~0U) if (Index == ~0U)
dbgs() << "~0U"; dbgs() << "~0U";
else else
dbgs() << Index; dbgs() << Index;
dbgs() << " => " << getAsString(Index) << " }\n"; dbgs() << " => " << getAsString(Index) << " }\n";
} }
dbgs() << "]\n"; dbgs() << "]\n";
} }
#endif #endif
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// AttrBuilder Method Implementations // AttrBuilder Method Implementations
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
AttrBuilder::AttrBuilder(AttributeSet AS, unsigned Index) { AttrBuilder::AttrBuilder(AttributeList AS, unsigned Index) {
AttributeSetImpl *pImpl = AS.pImpl; AttributeListImpl *pImpl = AS.pImpl;
if (!pImpl) return; if (!pImpl) return;
for (unsigned I = 0, E = pImpl->getNumSlots(); I != E; ++I) { for (unsigned I = 0, E = pImpl->getNumSlots(); I != E; ++I) {
if (pImpl->getSlotIndex(I) != Index) continue; if (pImpl->getSlotIndex(I) != Index) continue;
for (AttributeSetImpl::iterator II = pImpl->begin(I), for (AttributeListImpl::iterator II = pImpl->begin(I), IE = pImpl->end(I);
IE = pImpl->end(I); II != IE; ++II) II != IE; ++II)
addAttribute(*II); addAttribute(*II);
break; break;
} }
} }
void AttrBuilder::clear() { void AttrBuilder::clear() {
Attrs.reset(); Attrs.reset();
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 LinesAttrBuilder &AttrBuilder::removeAttribute(Attribute::AttrKind Val) {
else if (Val == Attribute::DereferenceableOrNull) else if (Val == Attribute::DereferenceableOrNull)
DerefOrNullBytes = 0; DerefOrNullBytes = 0;
else if (Val == Attribute::AllocSize) else if (Val == Attribute::AllocSize)
AllocSizeArgs = 0; AllocSizeArgs = 0;
return *this; return *this;
} }
AttrBuilder &AttrBuilder::removeAttributes(AttributeSet A, uint64_t Index) { AttrBuilder &AttrBuilder::removeAttributes(AttributeList A, uint64_t Index) {
unsigned Slot = ~0U; unsigned Slot = ~0U;
for (unsigned I = 0, E = A.getNumSlots(); I != E; ++I) for (unsigned I = 0, E = A.getNumSlots(); I != E; ++I)
if (A.getSlotIndex(I) == Index) { if (A.getSlotIndex(I) == Index) {
Slot = I; Slot = I;
break; break;
} }
assert(Slot != ~0U && "Couldn't find index in AttributeSet!"); assert(Slot != ~0U && "Couldn't find index in AttributeList!");
for (AttributeSet::iterator I = A.begin(Slot), E = A.end(Slot); I != E; ++I) { for (AttributeList::iterator I = A.begin(Slot), E = A.end(Slot); I != E;
++I) {
Attribute Attr = *I; Attribute Attr = *I;
if (Attr.isEnumAttribute() || Attr.isIntAttribute()) { if (Attr.isEnumAttribute() || Attr.isIntAttribute()) {
removeAttribute(Attr.getKindAsEnum()); removeAttribute(Attr.getKindAsEnum());
} else { } else {
assert(Attr.isStringAttribute() && "Invalid attribute type!"); assert(Attr.isStringAttribute() && "Invalid attribute type!");
removeAttribute(Attr.getKindAsString()); removeAttribute(Attr.getKindAsString());
} }
} }
▲ Show 20 Lines • Show All 134 Lines • ▼ Show 20 Lines
bool AttrBuilder::contains(StringRef A) const { bool AttrBuilder::contains(StringRef A) const {
return TargetDepAttrs.find(A) != TargetDepAttrs.end(); return TargetDepAttrs.find(A) != TargetDepAttrs.end();
} }
bool AttrBuilder::hasAttributes() const { bool AttrBuilder::hasAttributes() const {
return !Attrs.none() || !TargetDepAttrs.empty(); return !Attrs.none() || !TargetDepAttrs.empty();
} }
bool AttrBuilder::hasAttributes(AttributeSet A, uint64_t Index) const { bool AttrBuilder::hasAttributes(AttributeList A, uint64_t Index) const {
unsigned Slot = ~0U; unsigned Slot = ~0U;
for (unsigned I = 0, E = A.getNumSlots(); I != E; ++I) for (unsigned I = 0, E = A.getNumSlots(); I != E; ++I)
if (A.getSlotIndex(I) == Index) { if (A.getSlotIndex(I) == Index) {
Slot = I; Slot = I;
break; break;
} }
assert(Slot != ~0U && "Couldn't find the index!"); assert(Slot != ~0U && "Couldn't find the index!");
for (AttributeSet::iterator I = A.begin(Slot), E = A.end(Slot); I != E; ++I) { for (AttributeList::iterator I = A.begin(Slot), E = A.end(Slot); I != E;
++I) {
Attribute Attr = *I; Attribute Attr = *I;
if (Attr.isEnumAttribute() || Attr.isIntAttribute()) { if (Attr.isEnumAttribute() || Attr.isIntAttribute()) {
if (Attrs[I->getKindAsEnum()]) if (Attrs[I->getKindAsEnum()])
return true; return true;
} else { } else {
assert(Attr.isStringAttribute() && "Invalid attribute kind!"); assert(Attr.isStringAttribute() && "Invalid attribute kind!");
return TargetDepAttrs.find(Attr.getKindAsString())!=TargetDepAttrs.end(); return TargetDepAttrs.find(Attr.getKindAsString())!=TargetDepAttrs.end();
} }
▲ Show 20 Lines • Show All 84 Lines • ▼ Show 20 Lines
static void adjustCallerSSPLevel(Function &Caller, const Function &Callee) { static void adjustCallerSSPLevel(Function &Caller, const Function &Callee) {
// If upgrading the SSP attribute, clear out the old SSP Attributes first. // If upgrading the SSP attribute, clear out the old SSP Attributes first.
// Having multiple SSP attributes doesn't actually hurt, but it adds useless // Having multiple SSP attributes doesn't actually hurt, but it adds useless
// clutter to the IR. // clutter to the IR.
AttrBuilder B; AttrBuilder B;
B.addAttribute(Attribute::StackProtect) B.addAttribute(Attribute::StackProtect)
.addAttribute(Attribute::StackProtectStrong) .addAttribute(Attribute::StackProtectStrong)
.addAttribute(Attribute::StackProtectReq); .addAttribute(Attribute::StackProtectReq);
AttributeSet OldSSPAttr = AttributeSet::get(Caller.getContext(), AttributeList OldSSPAttr =
AttributeSet::FunctionIndex, AttributeList::get(Caller.getContext(), AttributeList::FunctionIndex, B);
B);
if (Callee.hasFnAttribute(Attribute::StackProtectReq)) { if (Callee.hasFnAttribute(Attribute::StackProtectReq)) {
Caller.removeAttributes(AttributeSet::FunctionIndex, OldSSPAttr); Caller.removeAttributes(AttributeList::FunctionIndex, OldSSPAttr);
Caller.addFnAttr(Attribute::StackProtectReq); Caller.addFnAttr(Attribute::StackProtectReq);
} else if (Callee.hasFnAttribute(Attribute::StackProtectStrong) && } else if (Callee.hasFnAttribute(Attribute::StackProtectStrong) &&
!Caller.hasFnAttribute(Attribute::StackProtectReq)) { !Caller.hasFnAttribute(Attribute::StackProtectReq)) {
Caller.removeAttributes(AttributeSet::FunctionIndex, OldSSPAttr); Caller.removeAttributes(AttributeList::FunctionIndex, OldSSPAttr);
Caller.addFnAttr(Attribute::StackProtectStrong); Caller.addFnAttr(Attribute::StackProtectStrong);
} else if (Callee.hasFnAttribute(Attribute::StackProtect) && } else if (Callee.hasFnAttribute(Attribute::StackProtect) &&
!Caller.hasFnAttribute(Attribute::StackProtectReq) && !Caller.hasFnAttribute(Attribute::StackProtectReq) &&
!Caller.hasFnAttribute(Attribute::StackProtectStrong)) !Caller.hasFnAttribute(Attribute::StackProtectStrong))
Caller.addFnAttr(Attribute::StackProtect); Caller.addFnAttr(Attribute::StackProtect);
} }
#define GET_ATTR_COMPAT_FUNC #define GET_ATTR_COMPAT_FUNC
Show All 11 Lines

llvm/trunk/lib/IR/Core.cpp

Show First 20 Lines • Show All 1,882 Lines • ▼ Show 20 Lines
void LLVMRemoveStringAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, void LLVMRemoveStringAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
const char *K, unsigned KLen) { const char *K, unsigned KLen) {
unwrap<Function>(F)->removeAttribute(Idx, StringRef(K, KLen)); unwrap<Function>(F)->removeAttribute(Idx, StringRef(K, KLen));
} }
void LLVMAddTargetDependentFunctionAttr(LLVMValueRef Fn, const char *A, void LLVMAddTargetDependentFunctionAttr(LLVMValueRef Fn, const char *A,
const char *V) { const char *V) {
Function *Func = unwrap<Function>(Fn); Function *Func = unwrap<Function>(Fn);
AttributeSet::AttrIndex Idx = AttributeList::AttrIndex Idx =
AttributeSet::AttrIndex(AttributeSet::FunctionIndex); AttributeList::AttrIndex(AttributeList::FunctionIndex);
AttrBuilder B; AttrBuilder B;
B.addAttribute(A, V); B.addAttribute(A, V);
AttributeSet Set = AttributeSet::get(Func->getContext(), Idx, B); AttributeList Set = AttributeList::get(Func->getContext(), Idx, B);
Func->addAttributes(Idx, Set); Func->addAttributes(Idx, Set);
} }
/*--.. Operations on parameters ............................................--*/ /*--.. Operations on parameters ............................................--*/
unsigned LLVMCountParams(LLVMValueRef FnRef) { unsigned LLVMCountParams(LLVMValueRef FnRef) {
// This function is strictly redundant to // This function is strictly redundant to
// LLVMCountParamTypes(LLVMGetElementType(LLVMTypeOf(FnRef))) // LLVMCountParamTypes(LLVMGetElementType(LLVMTypeOf(FnRef)))
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines if (A->getArgNo() == 0)
return nullptr; return nullptr;
return wrap(&A->getParent()->arg_begin()[A->getArgNo() - 1]); return wrap(&A->getParent()->arg_begin()[A->getArgNo() - 1]);
} }
void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align) { void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align) {
Argument *A = unwrap<Argument>(Arg); Argument *A = unwrap<Argument>(Arg);
AttrBuilder B; AttrBuilder B;
B.addAlignmentAttr(align); B.addAlignmentAttr(align);
A->addAttr(AttributeSet::get(A->getContext(),A->getArgNo() + 1, B)); A->addAttr(AttributeList::get(A->getContext(), A->getArgNo() + 1, B));
} }
/*--.. Operations on basic blocks ..........................................--*/ /*--.. Operations on basic blocks ..........................................--*/
LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB) { LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB) {
return wrap(static_cast<Value*>(unwrap(BB))); return wrap(static_cast<Value*>(unwrap(BB)));
} }
▲ Show 20 Lines • Show All 192 Lines • ▼ Show 20 Lines return CallSite(unwrap<Instruction>(Instr))
.setCallingConv(static_cast<CallingConv::ID>(CC)); .setCallingConv(static_cast<CallingConv::ID>(CC));
} }
void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index, void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index,
unsigned align) { unsigned align) {
CallSite Call = CallSite(unwrap<Instruction>(Instr)); CallSite Call = CallSite(unwrap<Instruction>(Instr));
AttrBuilder B; AttrBuilder B;
B.addAlignmentAttr(align); B.addAlignmentAttr(align);
Call.setAttributes(Call.getAttributes() Call.setAttributes(Call.getAttributes().addAttributes(
.addAttributes(Call->getContext(), index, Call->getContext(), index,
AttributeSet::get(Call->getContext(), AttributeList::get(Call->getContext(), index, B)));
index, B)));
} }
void LLVMAddCallSiteAttribute(LLVMValueRef C, LLVMAttributeIndex Idx, void LLVMAddCallSiteAttribute(LLVMValueRef C, LLVMAttributeIndex Idx,
LLVMAttributeRef A) { LLVMAttributeRef A) {
CallSite(unwrap<Instruction>(C)).addAttribute(Idx, unwrap(A)); CallSite(unwrap<Instruction>(C)).addAttribute(Idx, unwrap(A));
} }
unsigned LLVMGetCallSiteAttributeCount(LLVMValueRef C, unsigned LLVMGetCallSiteAttributeCount(LLVMValueRef C,
▲ Show 20 Lines • Show All 1,043 Lines • Show Last 20 Lines

llvm/trunk/lib/IR/Function.cpp

Show First 20 Lines • Show All 74 Lines • ▼ Show 20 Lines
bool Argument::hasInAllocaAttr() const { bool Argument::hasInAllocaAttr() const {
if (!getType()->isPointerTy()) return false; if (!getType()->isPointerTy()) return false;
return hasAttribute(Attribute::InAlloca); return hasAttribute(Attribute::InAlloca);
} }
bool Argument::hasByValOrInAllocaAttr() const { bool Argument::hasByValOrInAllocaAttr() const {
if (!getType()->isPointerTy()) return false; if (!getType()->isPointerTy()) return false;
AttributeSet Attrs = getParent()->getAttributes(); AttributeList Attrs = getParent()->getAttributes();
return Attrs.hasAttribute(getArgNo() + 1, Attribute::ByVal) || return Attrs.hasAttribute(getArgNo() + 1, Attribute::ByVal) ||
Attrs.hasAttribute(getArgNo() + 1, Attribute::InAlloca); Attrs.hasAttribute(getArgNo() + 1, Attribute::InAlloca);
} }
unsigned Argument::getParamAlignment() const { unsigned Argument::getParamAlignment() const {
assert(getType()->isPointerTy() && "Only pointers have alignments"); assert(getType()->isPointerTy() && "Only pointers have alignments");
return getParent()->getParamAlignment(getArgNo()+1); return getParent()->getParamAlignment(getArgNo()+1);
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
bool Argument::onlyReadsMemory() const { bool Argument::onlyReadsMemory() const {
return getParent()->getAttributes(). return getParent()->getAttributes().
hasAttribute(getArgNo()+1, Attribute::ReadOnly) || hasAttribute(getArgNo()+1, Attribute::ReadOnly) ||
getParent()->getAttributes(). getParent()->getAttributes().
hasAttribute(getArgNo()+1, Attribute::ReadNone); hasAttribute(getArgNo()+1, Attribute::ReadNone);
} }
void Argument::addAttr(AttributeSet AS) { void Argument::addAttr(AttributeList AS) {
assert(AS.getNumSlots() <= 1 && assert(AS.getNumSlots() <= 1 &&
"Trying to add more than one attribute set to an argument!"); "Trying to add more than one attribute set to an argument!");
AttrBuilder B(AS, AS.getSlotIndex(0)); AttrBuilder B(AS, AS.getSlotIndex(0));
getParent()->addAttributes(getArgNo() + 1, getParent()->addAttributes(
AttributeSet::get(Parent->getContext(), getArgNo() + 1,
getArgNo() + 1, B)); AttributeList::get(Parent->getContext(), getArgNo() + 1, B));
} }
void Argument::removeAttr(AttributeSet AS) { void Argument::removeAttr(AttributeList AS) {
assert(AS.getNumSlots() <= 1 && assert(AS.getNumSlots() <= 1 &&
"Trying to remove more than one attribute set from an argument!"); "Trying to remove more than one attribute set from an argument!");
AttrBuilder B(AS, AS.getSlotIndex(0)); AttrBuilder B(AS, AS.getSlotIndex(0));
getParent()->removeAttributes(getArgNo() + 1, getParent()->removeAttributes(
AttributeSet::get(Parent->getContext(), getArgNo() + 1,
getArgNo() + 1, B)); AttributeList::get(Parent->getContext(), getArgNo() + 1, B));
} }
bool Argument::hasAttribute(Attribute::AttrKind Kind) const { bool Argument::hasAttribute(Attribute::AttrKind Kind) const {
return getParent()->hasAttribute(getArgNo() + 1, Kind); return getParent()->hasAttribute(getArgNo() + 1, Kind);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Helper Methods in Function // Helper Methods in Function
▲ Show 20 Lines • Show All 148 Lines • ▼ Show 20 Lines if (getNumOperands()) {
setValueSubclassData(getSubclassDataFromValue() & ~0xe); setValueSubclassData(getSubclassDataFromValue() & ~0xe);
} }
// Metadata is stored in a side-table. // Metadata is stored in a side-table.
clearMetadata(); clearMetadata();
} }
void Function::addAttribute(unsigned i, Attribute::AttrKind Kind) { void Function::addAttribute(unsigned i, Attribute::AttrKind Kind) {
AttributeSet PAL = getAttributes(); AttributeList PAL = getAttributes();
PAL = PAL.addAttribute(getContext(), i, Kind); PAL = PAL.addAttribute(getContext(), i, Kind);
setAttributes(PAL); setAttributes(PAL);
} }
void Function::addAttribute(unsigned i, Attribute Attr) { void Function::addAttribute(unsigned i, Attribute Attr) {
AttributeSet PAL = getAttributes(); AttributeList PAL = getAttributes();
PAL = PAL.addAttribute(getContext(), i, Attr); PAL = PAL.addAttribute(getContext(), i, Attr);
setAttributes(PAL); setAttributes(PAL);
} }
void Function::addAttributes(unsigned i, AttributeSet Attrs) { void Function::addAttributes(unsigned i, AttributeList Attrs) {
AttributeSet PAL = getAttributes(); AttributeList PAL = getAttributes();
PAL = PAL.addAttributes(getContext(), i, Attrs); PAL = PAL.addAttributes(getContext(), i, Attrs);
setAttributes(PAL); setAttributes(PAL);
} }
void Function::removeAttribute(unsigned i, Attribute::AttrKind Kind) { void Function::removeAttribute(unsigned i, Attribute::AttrKind Kind) {
AttributeSet PAL = getAttributes(); AttributeList PAL = getAttributes();
PAL = PAL.removeAttribute(getContext(), i, Kind); PAL = PAL.removeAttribute(getContext(), i, Kind);
setAttributes(PAL); setAttributes(PAL);
} }
void Function::removeAttribute(unsigned i, StringRef Kind) { void Function::removeAttribute(unsigned i, StringRef Kind) {
AttributeSet PAL = getAttributes(); AttributeList PAL = getAttributes();
PAL = PAL.removeAttribute(getContext(), i, Kind); PAL = PAL.removeAttribute(getContext(), i, Kind);
setAttributes(PAL); setAttributes(PAL);
} }
void Function::removeAttributes(unsigned i, AttributeSet Attrs) { void Function::removeAttributes(unsigned i, AttributeList Attrs) {
AttributeSet PAL = getAttributes(); AttributeList PAL = getAttributes();
PAL = PAL.removeAttributes(getContext(), i, Attrs); PAL = PAL.removeAttributes(getContext(), i, Attrs);
setAttributes(PAL); setAttributes(PAL);
} }
void Function::addDereferenceableAttr(unsigned i, uint64_t Bytes) { void Function::addDereferenceableAttr(unsigned i, uint64_t Bytes) {
AttributeSet PAL = getAttributes(); AttributeList PAL = getAttributes();
PAL = PAL.addDereferenceableAttr(getContext(), i, Bytes); PAL = PAL.addDereferenceableAttr(getContext(), i, Bytes);
setAttributes(PAL); setAttributes(PAL);
} }
void Function::addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes) { void Function::addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes) {
AttributeSet PAL = getAttributes(); AttributeList PAL = getAttributes();
PAL = PAL.addDereferenceableOrNullAttr(getContext(), i, Bytes); PAL = PAL.addDereferenceableOrNullAttr(getContext(), i, Bytes);
setAttributes(PAL); setAttributes(PAL);
} }
const std::string &Function::getGC() const { const std::string &Function::getGC() const {
assert(hasGC() && "Function has no collector"); assert(hasGC() && "Function has no collector");
return getContext().getGC(*this); return getContext().getGC(*this);
} }
▲ Show 20 Lines • Show All 922 Lines • Show Last 20 Lines

llvm/trunk/lib/IR/Instructions.cpp

Show First 20 Lines • Show All 301 Lines • ▼ Show 20 Lines : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType())
1, InsertAtEnd) { 1, InsertAtEnd) {
init(Func, Name); init(Func, Name);
} }
CallInst::CallInst(const CallInst &CI) CallInst::CallInst(const CallInst &CI)
: Instruction(CI.getType(), Instruction::Call, : Instruction(CI.getType(), Instruction::Call,
OperandTraits<CallInst>::op_end(this) - CI.getNumOperands(), OperandTraits<CallInst>::op_end(this) - CI.getNumOperands(),
CI.getNumOperands()), CI.getNumOperands()),
AttributeList(CI.AttributeList), FTy(CI.FTy) { Attrs(CI.Attrs), FTy(CI.FTy) {
setTailCallKind(CI.getTailCallKind()); setTailCallKind(CI.getTailCallKind());
setCallingConv(CI.getCallingConv()); setCallingConv(CI.getCallingConv());
std::copy(CI.op_begin(), CI.op_end(), op_begin()); std::copy(CI.op_begin(), CI.op_end(), op_begin());
std::copy(CI.bundle_op_info_begin(), CI.bundle_op_info_end(), std::copy(CI.bundle_op_info_begin(), CI.bundle_op_info_end(),
bundle_op_info_begin()); bundle_op_info_begin());
SubclassOptionalData = CI.SubclassOptionalData; SubclassOptionalData = CI.SubclassOptionalData;
} }
Show All 10 LinesCallInst *CallInst::Create(CallInst *CI, ArrayRef<OperandBundleDef> OpB,
NewCI->setAttributes(CI->getAttributes()); NewCI->setAttributes(CI->getAttributes());
NewCI->setDebugLoc(CI->getDebugLoc()); NewCI->setDebugLoc(CI->getDebugLoc());
return NewCI; return NewCI;
} }
Value *CallInst::getReturnedArgOperand() const { Value *CallInst::getReturnedArgOperand() const {
unsigned Index; unsigned Index;
if (AttributeList.hasAttrSomewhere(Attribute::Returned, &Index) && Index) if (Attrs.hasAttrSomewhere(Attribute::Returned, &Index) && Index)
return getArgOperand(Index-1); return getArgOperand(Index-1);
if (const Function *F = getCalledFunction()) if (const Function *F = getCalledFunction())
if (F->getAttributes().hasAttrSomewhere(Attribute::Returned, &Index) && if (F->getAttributes().hasAttrSomewhere(Attribute::Returned, &Index) &&
Index) Index)
return getArgOperand(Index-1); return getArgOperand(Index-1);
return nullptr; return nullptr;
} }
void CallInst::addAttribute(unsigned i, Attribute::AttrKind Kind) { void CallInst::addAttribute(unsigned i, Attribute::AttrKind Kind) {
AttributeSet PAL = getAttributes(); AttributeList PAL = getAttributes();
PAL = PAL.addAttribute(getContext(), i, Kind); PAL = PAL.addAttribute(getContext(), i, Kind);
setAttributes(PAL); setAttributes(PAL);
} }
void CallInst::addAttribute(unsigned i, Attribute Attr) { void CallInst::addAttribute(unsigned i, Attribute Attr) {
AttributeSet PAL = getAttributes(); AttributeList PAL = getAttributes();
PAL = PAL.addAttribute(getContext(), i, Attr); PAL = PAL.addAttribute(getContext(), i, Attr);
setAttributes(PAL); setAttributes(PAL);
} }
void CallInst::removeAttribute(unsigned i, Attribute::AttrKind Kind) { void CallInst::removeAttribute(unsigned i, Attribute::AttrKind Kind) {
AttributeSet PAL = getAttributes(); AttributeList PAL = getAttributes();
PAL = PAL.removeAttribute(getContext(), i, Kind); PAL = PAL.removeAttribute(getContext(), i, Kind);
setAttributes(PAL); setAttributes(PAL);
} }
void CallInst::removeAttribute(unsigned i, StringRef Kind) { void CallInst::removeAttribute(unsigned i, StringRef Kind) {
AttributeSet PAL = getAttributes(); AttributeList PAL = getAttributes();
PAL = PAL.removeAttribute(getContext(), i, Kind); PAL = PAL.removeAttribute(getContext(), i, Kind);
setAttributes(PAL); setAttributes(PAL);
} }
void CallInst::addDereferenceableAttr(unsigned i, uint64_t Bytes) { void CallInst::addDereferenceableAttr(unsigned i, uint64_t Bytes) {
AttributeSet PAL = getAttributes(); AttributeList PAL = getAttributes();
PAL = PAL.addDereferenceableAttr(getContext(), i, Bytes); PAL = PAL.addDereferenceableAttr(getContext(), i, Bytes);
setAttributes(PAL); setAttributes(PAL);
} }
void CallInst::addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes) { void CallInst::addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes) {
AttributeSet PAL = getAttributes(); AttributeList PAL = getAttributes();
PAL = PAL.addDereferenceableOrNullAttr(getContext(), i, Bytes); PAL = PAL.addDereferenceableOrNullAttr(getContext(), i, Bytes);
setAttributes(PAL); setAttributes(PAL);
} }
bool CallInst::paramHasAttr(unsigned i, Attribute::AttrKind Kind) const { bool CallInst::paramHasAttr(unsigned i, Attribute::AttrKind Kind) const {
assert(i < (getNumArgOperands() + 1) && "Param index out of bounds!"); assert(i < (getNumArgOperands() + 1) && "Param index out of bounds!");
if (AttributeList.hasAttribute(i, Kind)) if (Attrs.hasAttribute(i, Kind))
return true; return true;
if (const Function *F = getCalledFunction()) if (const Function *F = getCalledFunction())
return F->getAttributes().hasAttribute(i, Kind); return F->getAttributes().hasAttribute(i, Kind);
return false; return false;
} }
bool CallInst::dataOperandHasImpliedAttr(unsigned i, bool CallInst::dataOperandHasImpliedAttr(unsigned i,
Attribute::AttrKind Kind) const { Attribute::AttrKind Kind) const {
▲ Show 20 Lines • Show All 246 Lines • ▼ Show 20 Lines#endif
setName(NameStr); setName(NameStr);
} }
InvokeInst::InvokeInst(const InvokeInst &II) InvokeInst::InvokeInst(const InvokeInst &II)
: TerminatorInst(II.getType(), Instruction::Invoke, : TerminatorInst(II.getType(), Instruction::Invoke,
OperandTraits<InvokeInst>::op_end(this) - OperandTraits<InvokeInst>::op_end(this) -
II.getNumOperands(), II.getNumOperands(),
II.getNumOperands()), II.getNumOperands()),
AttributeList(II.AttributeList), FTy(II.FTy) { Attrs(II.Attrs), FTy(II.FTy) {
setCallingConv(II.getCallingConv()); setCallingConv(II.getCallingConv());
std::copy(II.op_begin(), II.op_end(), op_begin()); std::copy(II.op_begin(), II.op_end(), op_begin());
std::copy(II.bundle_op_info_begin(), II.bundle_op_info_end(), std::copy(II.bundle_op_info_begin(), II.bundle_op_info_end(),
bundle_op_info_begin()); bundle_op_info_begin());
SubclassOptionalData = II.SubclassOptionalData; SubclassOptionalData = II.SubclassOptionalData;
} }
InvokeInst *InvokeInst::Create(InvokeInst *II, ArrayRef<OperandBundleDef> OpB, InvokeInst *InvokeInst::Create(InvokeInst *II, ArrayRef<OperandBundleDef> OpB,
Show All 18 Lines
} }
void InvokeInst::setSuccessorV(unsigned idx, BasicBlock *B) { void InvokeInst::setSuccessorV(unsigned idx, BasicBlock *B) {
return setSuccessor(idx, B); return setSuccessor(idx, B);
} }
Value *InvokeInst::getReturnedArgOperand() const { Value *InvokeInst::getReturnedArgOperand() const {
unsigned Index; unsigned Index;
if (AttributeList.hasAttrSomewhere(Attribute::Returned, &Index) && Index) if (Attrs.hasAttrSomewhere(Attribute::Returned, &Index) && Index)
return getArgOperand(Index-1); return getArgOperand(Index-1);
if (const Function *F = getCalledFunction()) if (const Function *F = getCalledFunction())
if (F->getAttributes().hasAttrSomewhere(Attribute::Returned, &Index) && if (F->getAttributes().hasAttrSomewhere(Attribute::Returned, &Index) &&
Index) Index)
return getArgOperand(Index-1); return getArgOperand(Index-1);
return nullptr; return nullptr;
} }
bool InvokeInst::paramHasAttr(unsigned i, Attribute::AttrKind Kind) const { bool InvokeInst::paramHasAttr(unsigned i, Attribute::AttrKind Kind) const {
assert(i < (getNumArgOperands() + 1) && "Param index out of bounds!"); assert(i < (getNumArgOperands() + 1) && "Param index out of bounds!");
if (AttributeList.hasAttribute(i, Kind)) if (Attrs.hasAttribute(i, Kind))
return true; return true;
if (const Function *F = getCalledFunction()) if (const Function *F = getCalledFunction())
return F->getAttributes().hasAttribute(i, Kind); return F->getAttributes().hasAttribute(i, Kind);
return false; return false;
} }
bool InvokeInst::dataOperandHasImpliedAttr(unsigned i, bool InvokeInst::dataOperandHasImpliedAttr(unsigned i,
Attribute::AttrKind Kind) const { Attribute::AttrKind Kind) const {
Show All 9 Lines if (i < (getNumArgOperands() + 1))
return paramHasAttr(i, Kind); return paramHasAttr(i, Kind);
assert(hasOperandBundles() && i >= (getBundleOperandsStartIndex() + 1) && assert(hasOperandBundles() && i >= (getBundleOperandsStartIndex() + 1) &&
"Must be either an invoke argument or an operand bundle!"); "Must be either an invoke argument or an operand bundle!");
return bundleOperandHasAttr(i - 1, Kind); return bundleOperandHasAttr(i - 1, Kind);
} }
void InvokeInst::addAttribute(unsigned i, Attribute::AttrKind Kind) { void InvokeInst::addAttribute(unsigned i, Attribute::AttrKind Kind) {
AttributeSet PAL = getAttributes(); AttributeList PAL = getAttributes();
PAL = PAL.addAttribute(getContext(), i, Kind); PAL = PAL.addAttribute(getContext(), i, Kind);
setAttributes(PAL); setAttributes(PAL);
} }
void InvokeInst::addAttribute(unsigned i, Attribute Attr) { void InvokeInst::addAttribute(unsigned i, Attribute Attr) {
AttributeSet PAL = getAttributes(); AttributeList PAL = getAttributes();
PAL = PAL.addAttribute(getContext(), i, Attr); PAL = PAL.addAttribute(getContext(), i, Attr);
setAttributes(PAL); setAttributes(PAL);
} }
void InvokeInst::removeAttribute(unsigned i, Attribute::AttrKind Kind) { void InvokeInst::removeAttribute(unsigned i, Attribute::AttrKind Kind) {
AttributeSet PAL = getAttributes(); AttributeList PAL = getAttributes();
PAL = PAL.removeAttribute(getContext(), i, Kind); PAL = PAL.removeAttribute(getContext(), i, Kind);
setAttributes(PAL); setAttributes(PAL);
} }
void InvokeInst::removeAttribute(unsigned i, StringRef Kind) { void InvokeInst::removeAttribute(unsigned i, StringRef Kind) {
AttributeSet PAL = getAttributes(); AttributeList PAL = getAttributes();
PAL = PAL.removeAttribute(getContext(), i, Kind); PAL = PAL.removeAttribute(getContext(), i, Kind);
setAttributes(PAL); setAttributes(PAL);
} }
void InvokeInst::addDereferenceableAttr(unsigned i, uint64_t Bytes) { void InvokeInst::addDereferenceableAttr(unsigned i, uint64_t Bytes) {
AttributeSet PAL = getAttributes(); AttributeList PAL = getAttributes();
PAL = PAL.addDereferenceableAttr(getContext(), i, Bytes); PAL = PAL.addDereferenceableAttr(getContext(), i, Bytes);
setAttributes(PAL); setAttributes(PAL);
} }
void InvokeInst::addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes) { void InvokeInst::addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes) {
AttributeSet PAL = getAttributes(); AttributeList PAL = getAttributes();
PAL = PAL.addDereferenceableOrNullAttr(getContext(), i, Bytes); PAL = PAL.addDereferenceableOrNullAttr(getContext(), i, Bytes);
setAttributes(PAL); setAttributes(PAL);
} }
LandingPadInst *InvokeInst::getLandingPadInst() const { LandingPadInst *InvokeInst::getLandingPadInst() const {
return cast<LandingPadInst>(getUnwindDest()->getFirstNonPHI()); return cast<LandingPadInst>(getUnwindDest()->getFirstNonPHI());
} }
▲ Show 20 Lines • Show All 3,236 Lines • Show Last 20 Lines

llvm/trunk/lib/IR/LLVMContextImpl.h

Show First 20 Lines • Show All 1,113 Lines • ▼ Show 20 Lines typedef DenseMap<APInt, std::unique_ptr<ConstantInt>, DenseMapAPIntKeyInfo>
IntMapTy; IntMapTy;
IntMapTy IntConstants; IntMapTy IntConstants;
typedef DenseMap<APFloat, std::unique_ptr<ConstantFP>, DenseMapAPFloatKeyInfo> typedef DenseMap<APFloat, std::unique_ptr<ConstantFP>, DenseMapAPFloatKeyInfo>
FPMapTy; FPMapTy;
FPMapTy FPConstants; FPMapTy FPConstants;
FoldingSet<AttributeImpl> AttrsSet; FoldingSet<AttributeImpl> AttrsSet;
FoldingSet<AttributeSetImpl> AttrsLists; FoldingSet<AttributeListImpl> AttrsLists;
FoldingSet<AttributeSetNode> AttrsSetNodes; FoldingSet<AttributeSetNode> AttrsSetNodes;
StringMap<MDString, BumpPtrAllocator> MDStringCache; StringMap<MDString, BumpPtrAllocator> MDStringCache;
DenseMap<Value *, ValueAsMetadata *> ValuesAsMetadata; DenseMap<Value *, ValueAsMetadata *> ValuesAsMetadata;
DenseMap<Metadata *, MetadataAsValue *> MetadataAsValues; DenseMap<Metadata *, MetadataAsValue *> MetadataAsValues;
DenseMap<const Value*, ValueName*> ValueNames; DenseMap<const Value*, ValueName*> ValueNames;
▲ Show 20 Lines • Show All 130 Lines • Show Last 20 Lines

llvm/trunk/lib/IR/LLVMContextImpl.cpp

Show First 20 Lines • Show All 108 Lines • ▼ Show 20 Lines#include "llvm/IR/Metadata.def"
// Destroy attributes. // Destroy attributes.
for (FoldingSetIterator<AttributeImpl> I = AttrsSet.begin(), for (FoldingSetIterator<AttributeImpl> I = AttrsSet.begin(),
E = AttrsSet.end(); I != E; ) { E = AttrsSet.end(); I != E; ) {
FoldingSetIterator<AttributeImpl> Elem = I++; FoldingSetIterator<AttributeImpl> Elem = I++;
delete &*Elem; delete &*Elem;
} }
// Destroy attribute lists. // Destroy attribute lists.
for (FoldingSetIterator<AttributeSetImpl> I = AttrsLists.begin(), for (FoldingSetIterator<AttributeListImpl> I = AttrsLists.begin(),
E = AttrsLists.end(); I != E; ) { E = AttrsLists.end();
FoldingSetIterator<AttributeSetImpl> Elem = I++; I != E;) {
FoldingSetIterator<AttributeListImpl> Elem = I++;
delete &*Elem; delete &*Elem;
} }
// Destroy attribute node lists. // Destroy attribute node lists.
for (FoldingSetIterator<AttributeSetNode> I = AttrsSetNodes.begin(), for (FoldingSetIterator<AttributeSetNode> I = AttrsSetNodes.begin(),
E = AttrsSetNodes.end(); I != E; ) { E = AttrsSetNodes.end(); I != E; ) {
FoldingSetIterator<AttributeSetNode> Elem = I++; FoldingSetIterator<AttributeSetNode> Elem = I++;
delete &*Elem; delete &*Elem;
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

llvm/trunk/lib/IR/Module.cpp

Show First 20 Lines • Show All 114 Lines • ▼ Show 20 Lines
// Methods for easy access to the functions in the module. // Methods for easy access to the functions in the module.
// //
// getOrInsertFunction - Look up the specified function in the module symbol // getOrInsertFunction - Look up the specified function in the module symbol
// table. If it does not exist, add a prototype for the function and return // table. If it does not exist, add a prototype for the function and return
// it. This is nice because it allows most passes to get away with not handling // it. This is nice because it allows most passes to get away with not handling
// the symbol table directly for this common task. // the symbol table directly for this common task.
// //
Constant *Module::getOrInsertFunction(StringRef Name, Constant *Module::getOrInsertFunction(StringRef Name, FunctionType *Ty,
FunctionType *Ty, AttributeList AttributeList) {
AttributeSet AttributeList) {
// See if we have a definition for the specified function already. // See if we have a definition for the specified function already.
GlobalValue *F = getNamedValue(Name); GlobalValue *F = getNamedValue(Name);
if (!F) { if (!F) {
// Nope, add it // Nope, add it
Function *New = Function::Create(Ty, GlobalVariable::ExternalLinkage, Name); Function *New = Function::Create(Ty, GlobalVariable::ExternalLinkage, Name);
if (!New->isIntrinsic()) // Intrinsics get attrs set on construction if (!New->isIntrinsic()) // Intrinsics get attrs set on construction
New->setAttributes(AttributeList); New->setAttributes(AttributeList);
FunctionList.push_back(New); FunctionList.push_back(New);
return New; // Return the new prototype. return New; // Return the new prototype.
} }
// If the function exists but has the wrong type, return a bitcast to the // If the function exists but has the wrong type, return a bitcast to the
// right type. // right type.
if (F->getType() != PointerType::getUnqual(Ty)) if (F->getType() != PointerType::getUnqual(Ty))
return ConstantExpr::getBitCast(F, PointerType::getUnqual(Ty)); return ConstantExpr::getBitCast(F, PointerType::getUnqual(Ty));
// Otherwise, we just found the existing function or a prototype. // Otherwise, we just found the existing function or a prototype.
return F; return F;
} }
Constant *Module::getOrInsertFunction(StringRef Name, Constant *Module::getOrInsertFunction(StringRef Name,
FunctionType *Ty) { FunctionType *Ty) {
return getOrInsertFunction(Name, Ty, AttributeSet()); return getOrInsertFunction(Name, Ty, AttributeList());
} }
// getOrInsertFunction - Look up the specified function in the module symbol // getOrInsertFunction - Look up the specified function in the module symbol
// table. If it does not exist, add a prototype for the function and return it. // table. If it does not exist, add a prototype for the function and return it.
// This version of the method takes a null terminated list of function // This version of the method takes a null terminated list of function
// arguments, which makes it easier for clients to use. // arguments, which makes it easier for clients to use.
// //
Constant *Module::getOrInsertFunction(StringRef Name, Constant *Module::getOrInsertFunction(StringRef Name,
AttributeSet AttributeList, AttributeList AttributeList, Type *RetTy,
Type *RetTy, ...) { ...) {
va_list Args; va_list Args;
va_start(Args, RetTy); va_start(Args, RetTy);
// Build the list of argument types... // Build the list of argument types...
std::vector<Type*> ArgTys; std::vector<Type*> ArgTys;
while (Type *ArgTy = va_arg(Args, Type*)) while (Type *ArgTy = va_arg(Args, Type*))
ArgTys.push_back(ArgTy); ArgTys.push_back(ArgTy);
Show All 13 LinesConstant *Module::getOrInsertFunction(StringRef Name,
// Build the list of argument types... // Build the list of argument types...
std::vector<Type*> ArgTys; std::vector<Type*> ArgTys;
while (Type *ArgTy = va_arg(Args, Type*)) while (Type *ArgTy = va_arg(Args, Type*))
ArgTys.push_back(ArgTy); ArgTys.push_back(ArgTy);
va_end(Args); va_end(Args);
// Build the function type and chain to the other getOrInsertFunction... // Build the function type and chain to the other getOrInsertFunction...
return getOrInsertFunction(Name, return getOrInsertFunction(Name, FunctionType::get(RetTy, ArgTys, false),
FunctionType::get(RetTy, ArgTys, false), AttributeList());
AttributeSet());
} }
// getFunction - Look up the specified function in the module symbol table. // getFunction - Look up the specified function in the module symbol table.
// If it does not exist, return null. // If it does not exist, return null.
// //
Function *Module::getFunction(StringRef Name) const { Function *Module::getFunction(StringRef Name) const {
return dyn_cast_or_null<Function>(getNamedValue(Name)); return dyn_cast_or_null<Function>(getNamedValue(Name));
} }
▲ Show 20 Lines • Show All 351 Lines • Show Last 20 Lines

llvm/trunk/lib/IR/Statepoint.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Linesbool llvm::isGCResult(ImmutableCallSite CS) {
return CS.getInstruction() && isa<GCResultInst>(CS.getInstruction()); return CS.getInstruction() && isa<GCResultInst>(CS.getInstruction());
} }
bool llvm::isStatepointDirectiveAttr(Attribute Attr) { bool llvm::isStatepointDirectiveAttr(Attribute Attr) {
return Attr.hasAttribute("statepoint-id") || return Attr.hasAttribute("statepoint-id") ||
Attr.hasAttribute("statepoint-num-patch-bytes"); Attr.hasAttribute("statepoint-num-patch-bytes");
} }
StatepointDirectives llvm::parseStatepointDirectivesFromAttrs(AttributeSet AS) { StatepointDirectives
llvm::parseStatepointDirectivesFromAttrs(AttributeList AS) {
StatepointDirectives Result; StatepointDirectives Result;
Attribute AttrID = Attribute AttrID =
AS.getAttribute(AttributeSet::FunctionIndex, "statepoint-id"); AS.getAttribute(AttributeList::FunctionIndex, "statepoint-id");
uint64_t StatepointID; uint64_t StatepointID;
if (AttrID.isStringAttribute()) if (AttrID.isStringAttribute())
if (!AttrID.getValueAsString().getAsInteger(10, StatepointID)) if (!AttrID.getValueAsString().getAsInteger(10, StatepointID))
Result.StatepointID = StatepointID; Result.StatepointID = StatepointID;
uint32_t NumPatchBytes; uint32_t NumPatchBytes;
Attribute AttrNumPatchBytes = AS.getAttribute(AttributeSet::FunctionIndex, Attribute AttrNumPatchBytes = AS.getAttribute(AttributeList::FunctionIndex,
"statepoint-num-patch-bytes"); "statepoint-num-patch-bytes");
if (AttrNumPatchBytes.isStringAttribute()) if (AttrNumPatchBytes.isStringAttribute())
if (!AttrNumPatchBytes.getValueAsString().getAsInteger(10, NumPatchBytes)) if (!AttrNumPatchBytes.getValueAsString().getAsInteger(10, NumPatchBytes))
Result.NumPatchBytes = NumPatchBytes; Result.NumPatchBytes = NumPatchBytes;
return Result; return Result;
} }

llvm/trunk/lib/IR/Value.cpp

Show First 20 Lines • Show All 627 Lines • ▼ Show 20 Linesunsigned Value::getPointerAlignment(const DataLayout &DL) const {
} else if (const AllocaInst *AI = dyn_cast<AllocaInst>(this)) { } else if (const AllocaInst *AI = dyn_cast<AllocaInst>(this)) {
Align = AI->getAlignment(); Align = AI->getAlignment();
if (Align == 0) { if (Align == 0) {
Type *AllocatedType = AI->getAllocatedType(); Type *AllocatedType = AI->getAllocatedType();
if (AllocatedType->isSized()) if (AllocatedType->isSized())
Align = DL.getPrefTypeAlignment(AllocatedType); Align = DL.getPrefTypeAlignment(AllocatedType);
} }
} else if (auto CS = ImmutableCallSite(this)) } else if (auto CS = ImmutableCallSite(this))
Align = CS.getAttributes().getParamAlignment(AttributeSet::ReturnIndex); Align = CS.getAttributes().getParamAlignment(AttributeList::ReturnIndex);
else if (const LoadInst *LI = dyn_cast<LoadInst>(this)) else if (const LoadInst *LI = dyn_cast<LoadInst>(this))
if (MDNode *MD = LI->getMetadata(LLVMContext::MD_align)) { if (MDNode *MD = LI->getMetadata(LLVMContext::MD_align)) {
ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0)); ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
Align = CI->getLimitedValue(); Align = CI->getLimitedValue();
} }
return Align; return Align;
} }
▲ Show 20 Lines • Show All 257 Lines • Show Last 20 Lines

llvm/trunk/lib/IR/Verifier.cpp

Show First 20 Lines • Show All 483 Lines • ▼ Show 20 Lines#include "llvm/IR/Metadata.def"
void visitCleanupReturnInst(CleanupReturnInst &CRI); void visitCleanupReturnInst(CleanupReturnInst &CRI);
void verifyCallSite(CallSite CS); void verifyCallSite(CallSite CS);
void verifySwiftErrorCallSite(CallSite CS, const Value *SwiftErrorVal); void verifySwiftErrorCallSite(CallSite CS, const Value *SwiftErrorVal);
void verifySwiftErrorValue(const Value *SwiftErrorVal); void verifySwiftErrorValue(const Value *SwiftErrorVal);
void verifyMustTailCall(CallInst &CI); void verifyMustTailCall(CallInst &CI);
bool performTypeCheck(Intrinsic::ID ID, Function *F, Type *Ty, int VT, bool performTypeCheck(Intrinsic::ID ID, Function *F, Type *Ty, int VT,
unsigned ArgNo, std::string &Suffix); unsigned ArgNo, std::string &Suffix);
bool verifyAttributeCount(AttributeSet Attrs, unsigned Params); bool verifyAttributeCount(AttributeList Attrs, unsigned Params);
void verifyAttributeTypes(AttributeSet Attrs, unsigned Idx, bool isFunction, void verifyAttributeTypes(AttributeList Attrs, unsigned Idx, bool isFunction,
const Value *V); const Value *V);
void verifyParameterAttrs(AttributeSet Attrs, unsigned Idx, Type *Ty, void verifyParameterAttrs(AttributeList Attrs, unsigned Idx, Type *Ty,
bool isReturnValue, const Value *V); bool isReturnValue, const Value *V);
void verifyFunctionAttrs(FunctionType *FT, AttributeSet Attrs, void verifyFunctionAttrs(FunctionType *FT, AttributeList Attrs,
const Value *V); const Value *V);
void verifyFunctionMetadata(ArrayRef<std::pair<unsigned, MDNode *>> MDs); void verifyFunctionMetadata(ArrayRef<std::pair<unsigned, MDNode *>> MDs);
void visitConstantExprsRecursively(const Constant *EntryC); void visitConstantExprsRecursively(const Constant *EntryC);
void visitConstantExpr(const ConstantExpr *CE); void visitConstantExpr(const ConstantExpr *CE);
void verifyStatepoint(ImmutableCallSite CS); void verifyStatepoint(ImmutableCallSite CS);
void verifyFrameRecoverIndices(); void verifyFrameRecoverIndices();
void verifySiblingFuncletUnwinds(); void verifySiblingFuncletUnwinds();
▲ Show 20 Lines • Show All 820 Lines • ▼ Show 20 LinesVerifier::visitModuleFlag(const MDNode *Op,
// Unless this is a "requires" flag, check the ID is unique. // Unless this is a "requires" flag, check the ID is unique.
if (MFB != Module::Require) { if (MFB != Module::Require) {
bool Inserted = SeenIDs.insert(std::make_pair(ID, Op)).second; bool Inserted = SeenIDs.insert(std::make_pair(ID, Op)).second;
Assert(Inserted, Assert(Inserted,
"module flag identifiers must be unique (or of 'require' type)", ID); "module flag identifiers must be unique (or of 'require' type)", ID);
} }
} }
void Verifier::verifyAttributeTypes(AttributeSet Attrs, unsigned Idx, void Verifier::verifyAttributeTypes(AttributeList Attrs, unsigned Idx,
bool isFunction, const Value *V) { bool isFunction, const Value *V) {
unsigned Slot = ~0U; unsigned Slot = ~0U;
for (unsigned I = 0, E = Attrs.getNumSlots(); I != E; ++I) for (unsigned I = 0, E = Attrs.getNumSlots(); I != E; ++I)
if (Attrs.getSlotIndex(I) == Idx) { if (Attrs.getSlotIndex(I) == Idx) {
Slot = I; Slot = I;
break; break;
} }
assert(Slot != ~0U && "Attribute set inconsistency!"); assert(Slot != ~0U && "Attribute set inconsistency!");
for (AttributeSet::iterator I = Attrs.begin(Slot), E = Attrs.end(Slot); for (AttributeList::iterator I = Attrs.begin(Slot), E = Attrs.end(Slot);
I != E; ++I) { I != E; ++I) {
if (I->isStringAttribute()) if (I->isStringAttribute())
continue; continue;
if (I->getKindAsEnum() == Attribute::NoReturn || if (I->getKindAsEnum() == Attribute::NoReturn ||
I->getKindAsEnum() == Attribute::NoUnwind || I->getKindAsEnum() == Attribute::NoUnwind ||
I->getKindAsEnum() == Attribute::NoInline || I->getKindAsEnum() == Attribute::NoInline ||
I->getKindAsEnum() == Attribute::AlwaysInline || I->getKindAsEnum() == Attribute::AlwaysInline ||
I->getKindAsEnum() == Attribute::OptimizeForSize || I->getKindAsEnum() == Attribute::OptimizeForSize ||
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines if (I->getKindAsEnum() == Attribute::NoReturn ||
"' does not apply to functions!", V); "' does not apply to functions!", V);
return; return;
} }
} }
} }
// VerifyParameterAttrs - Check the given attributes for an argument or return // VerifyParameterAttrs - Check the given attributes for an argument or return
// value of the specified type. The value V is printed in error messages. // value of the specified type. The value V is printed in error messages.
void Verifier::verifyParameterAttrs(AttributeSet Attrs, unsigned Idx, Type *Ty, void Verifier::verifyParameterAttrs(AttributeList Attrs, unsigned Idx, Type *Ty,
bool isReturnValue, const Value *V) { bool isReturnValue, const Value *V) {
if (!Attrs.hasAttributes(Idx)) if (!Attrs.hasAttributes(Idx))
return; return;
verifyAttributeTypes(Attrs, Idx, false, V); verifyAttributeTypes(Attrs, Idx, false, V);
if (isReturnValue) if (isReturnValue)
Assert(!Attrs.hasAttribute(Idx, Attribute::ByVal) && Assert(!Attrs.hasAttribute(Idx, Attribute::ByVal) &&
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Lines Assert(!(Attrs.hasAttribute(Idx, Attribute::NoInline) &&
Attrs.hasAttribute(Idx, Attribute::AlwaysInline)), Attrs.hasAttribute(Idx, Attribute::AlwaysInline)),
"Attributes " "Attributes "
"'noinline and alwaysinline' are incompatible!", "'noinline and alwaysinline' are incompatible!",
V); V);
Assert( Assert(
!AttrBuilder(Attrs, Idx).overlaps(AttributeFuncs::typeIncompatible(Ty)), !AttrBuilder(Attrs, Idx).overlaps(AttributeFuncs::typeIncompatible(Ty)),
"Wrong types for attribute: " + "Wrong types for attribute: " +
AttributeSet::get(Context, Idx, AttributeFuncs::typeIncompatible(Ty)) AttributeList::get(Context, Idx, AttributeFuncs::typeIncompatible(Ty))
.getAsString(Idx), .getAsString(Idx),
V); V);
if (PointerType *PTy = dyn_cast<PointerType>(Ty)) { if (PointerType *PTy = dyn_cast<PointerType>(Ty)) {
SmallPtrSet<Type*, 4> Visited; SmallPtrSet<Type*, 4> Visited;
if (!PTy->getElementType()->isSized(&Visited)) { if (!PTy->getElementType()->isSized(&Visited)) {
Assert(!Attrs.hasAttribute(Idx, Attribute::ByVal) && Assert(!Attrs.hasAttribute(Idx, Attribute::ByVal) &&
!Attrs.hasAttribute(Idx, Attribute::InAlloca), !Attrs.hasAttribute(Idx, Attribute::InAlloca),
Show All 13 Lines Assert(!Attrs.hasAttribute(Idx, Attribute::SwiftError),
"Attribute 'swifterror' only applies to parameters " "Attribute 'swifterror' only applies to parameters "
"with pointer type!", "with pointer type!",
V); V);
} }
} }
// Check parameter attributes against a function type. // Check parameter attributes against a function type.
// The value V is printed in error messages. // The value V is printed in error messages.
void Verifier::verifyFunctionAttrs(FunctionType *FT, AttributeSet Attrs, void Verifier::verifyFunctionAttrs(FunctionType *FT, AttributeList Attrs,
const Value *V) { const Value *V) {
if (Attrs.isEmpty()) if (Attrs.isEmpty())
return; return;
bool SawNest = false; bool SawNest = false;
bool SawReturned = false; bool SawReturned = false;
bool SawSRet = false; bool SawSRet = false;
bool SawSwiftSelf = false; bool SawSwiftSelf = false;
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines for (unsigned i = 0, e = Attrs.getNumSlots(); i != e; ++i) {
} }
if (Attrs.hasAttribute(Idx, Attribute::InAlloca)) { if (Attrs.hasAttribute(Idx, Attribute::InAlloca)) {
Assert(Idx == FT->getNumParams(), "inalloca isn't on the last parameter!", Assert(Idx == FT->getNumParams(), "inalloca isn't on the last parameter!",
V); V);
} }
} }
if (!Attrs.hasAttributes(AttributeSet::FunctionIndex)) if (!Attrs.hasAttributes(AttributeList::FunctionIndex))
return; return;
verifyAttributeTypes(Attrs, AttributeSet::FunctionIndex, true, V); verifyAttributeTypes(Attrs, AttributeList::FunctionIndex, true, V);
Assert( Assert(
!(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::ReadNone) && !(Attrs.hasAttribute(AttributeList::FunctionIndex, Attribute::ReadNone) &&
Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::ReadOnly)), Attrs.hasAttribute(AttributeList::FunctionIndex, Attribute::ReadOnly)),
"Attributes 'readnone and readonly' are incompatible!", V); "Attributes 'readnone and readonly' are incompatible!", V);
Assert( Assert(
!(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::ReadNone) && !(Attrs.hasAttribute(AttributeList::FunctionIndex, Attribute::ReadNone) &&
Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::WriteOnly)), Attrs.hasAttribute(AttributeList::FunctionIndex, Attribute::WriteOnly)),
"Attributes 'readnone and writeonly' are incompatible!", V); "Attributes 'readnone and writeonly' are incompatible!", V);
Assert( Assert(
!(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::ReadOnly) && !(Attrs.hasAttribute(AttributeList::FunctionIndex, Attribute::ReadOnly) &&
Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::WriteOnly)), Attrs.hasAttribute(AttributeList::FunctionIndex, Attribute::WriteOnly)),
"Attributes 'readonly and writeonly' are incompatible!", V); "Attributes 'readonly and writeonly' are incompatible!", V);
Assert( Assert(
!(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::ReadNone) && !(Attrs.hasAttribute(AttributeList::FunctionIndex, Attribute::ReadNone) &&
Attrs.hasAttribute(AttributeSet::FunctionIndex, Attrs.hasAttribute(AttributeList::FunctionIndex,
Attribute::InaccessibleMemOrArgMemOnly)), Attribute::InaccessibleMemOrArgMemOnly)),
"Attributes 'readnone and inaccessiblemem_or_argmemonly' are incompatible!", V); "Attributes 'readnone and inaccessiblemem_or_argmemonly' are "
"incompatible!",
V);
Assert( Assert(
!(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::ReadNone) && !(Attrs.hasAttribute(AttributeList::FunctionIndex, Attribute::ReadNone) &&
Attrs.hasAttribute(AttributeSet::FunctionIndex, Attrs.hasAttribute(AttributeList::FunctionIndex,
Attribute::InaccessibleMemOnly)), Attribute::InaccessibleMemOnly)),
"Attributes 'readnone and inaccessiblememonly' are incompatible!", V); "Attributes 'readnone and inaccessiblememonly' are incompatible!", V);
Assert( Assert(
!(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::NoInline) && !(Attrs.hasAttribute(AttributeList::FunctionIndex, Attribute::NoInline) &&
Attrs.hasAttribute(AttributeSet::FunctionIndex, Attrs.hasAttribute(AttributeList::FunctionIndex,
Attribute::AlwaysInline)), Attribute::AlwaysInline)),
"Attributes 'noinline and alwaysinline' are incompatible!", V); "Attributes 'noinline and alwaysinline' are incompatible!", V);
if (Attrs.hasAttribute(AttributeSet::FunctionIndex, if (Attrs.hasAttribute(AttributeList::FunctionIndex,
Attribute::OptimizeNone)) { Attribute::OptimizeNone)) {
Assert(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::NoInline), Assert(
Attrs.hasAttribute(AttributeList::FunctionIndex, Attribute::NoInline),
"Attribute 'optnone' requires 'noinline'!", V); "Attribute 'optnone' requires 'noinline'!", V);
Assert(!Attrs.hasAttribute(AttributeSet::FunctionIndex, Assert(!Attrs.hasAttribute(AttributeList::FunctionIndex,
Attribute::OptimizeForSize), Attribute::OptimizeForSize),
"Attributes 'optsize and optnone' are incompatible!", V); "Attributes 'optsize and optnone' are incompatible!", V);
Assert(!Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::MinSize), Assert(
!Attrs.hasAttribute(AttributeList::FunctionIndex, Attribute::MinSize),
"Attributes 'minsize and optnone' are incompatible!", V); "Attributes 'minsize and optnone' are incompatible!", V);
} }
if (Attrs.hasAttribute(AttributeSet::FunctionIndex, if (Attrs.hasAttribute(AttributeList::FunctionIndex, Attribute::JumpTable)) {
Attribute::JumpTable)) {
const GlobalValue *GV = cast<GlobalValue>(V); const GlobalValue *GV = cast<GlobalValue>(V);
Assert(GV->hasGlobalUnnamedAddr(), Assert(GV->hasGlobalUnnamedAddr(),
"Attribute 'jumptable' requires 'unnamed_addr'", V); "Attribute 'jumptable' requires 'unnamed_addr'", V);
} }
if (Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::AllocSize)) { if (Attrs.hasAttribute(AttributeList::FunctionIndex, Attribute::AllocSize)) {
std::pair<unsigned, Optional<unsigned>> Args = std::pair<unsigned, Optional<unsigned>> Args =
Attrs.getAllocSizeArgs(AttributeSet::FunctionIndex); Attrs.getAllocSizeArgs(AttributeList::FunctionIndex);
auto CheckParam = [&](StringRef Name, unsigned ParamNo) { auto CheckParam = [&](StringRef Name, unsigned ParamNo) {
if (ParamNo >= FT->getNumParams()) { if (ParamNo >= FT->getNumParams()) {
CheckFailed("'allocsize' " + Name + " argument is out of bounds", V); CheckFailed("'allocsize' " + Name + " argument is out of bounds", V);
return false; return false;
} }
if (!FT->getParamType(ParamNo)->isIntegerTy()) { if (!FT->getParamType(ParamNo)->isIntegerTy()) {
▲ Show 20 Lines • Show All 90 Lines • ▼ Show 20 Lines StringRef Msg = CE->getOpcode() == Instruction::IntToPtr
? "inttoptr not supported for non-integral pointers" ? "inttoptr not supported for non-integral pointers"
: "ptrtoint not supported for non-integral pointers"; : "ptrtoint not supported for non-integral pointers";
Assert( Assert(
!DL.isNonIntegralPointerType(cast<PointerType>(PtrTy->getScalarType())), !DL.isNonIntegralPointerType(cast<PointerType>(PtrTy->getScalarType())),
Msg); Msg);
} }
} }
bool Verifier::verifyAttributeCount(AttributeSet Attrs, unsigned Params) { bool Verifier::verifyAttributeCount(AttributeList Attrs, unsigned Params) {
if (Attrs.getNumSlots() == 0) if (Attrs.getNumSlots() == 0)
return true; return true;
unsigned LastSlot = Attrs.getNumSlots() - 1; unsigned LastSlot = Attrs.getNumSlots() - 1;
unsigned LastIndex = Attrs.getSlotIndex(LastSlot); unsigned LastIndex = Attrs.getSlotIndex(LastSlot);
if (LastIndex <= Params if (LastIndex <= Params ||
|| (LastIndex == AttributeSet::FunctionIndex (LastIndex == AttributeList::FunctionIndex &&
&& (LastSlot == 0 || Attrs.getSlotIndex(LastSlot - 1) <= Params))) (LastSlot == 0 || Attrs.getSlotIndex(LastSlot - 1) <= Params)))
return true; return true;
return false; return false;
} }
/// Verify that statepoint intrinsic is well formed. /// Verify that statepoint intrinsic is well formed.
void Verifier::verifyStatepoint(ImmutableCallSite CS) { void Verifier::verifyStatepoint(ImmutableCallSite CS) {
assert(CS.getCalledFunction() && assert(CS.getCalledFunction() &&
▲ Show 20 Lines • Show All 213 Lines • ▼ Show 20 Lines Assert(FT->getNumParams() == NumArgs,
FT); FT);
Assert(F.getReturnType()->isFirstClassType() || Assert(F.getReturnType()->isFirstClassType() ||
F.getReturnType()->isVoidTy() || F.getReturnType()->isStructTy(), F.getReturnType()->isVoidTy() || F.getReturnType()->isStructTy(),
"Functions cannot return aggregate values!", &F); "Functions cannot return aggregate values!", &F);
Assert(!F.hasStructRetAttr() || F.getReturnType()->isVoidTy(), Assert(!F.hasStructRetAttr() || F.getReturnType()->isVoidTy(),
"Invalid struct return type!", &F); "Invalid struct return type!", &F);
AttributeSet Attrs = F.getAttributes(); AttributeList Attrs = F.getAttributes();
Assert(verifyAttributeCount(Attrs, FT->getNumParams()), Assert(verifyAttributeCount(Attrs, FT->getNumParams()),
"Attribute after last parameter!", &F); "Attribute after last parameter!", &F);
// Check function attributes. // Check function attributes.
verifyFunctionAttrs(FT, Attrs, &F); verifyFunctionAttrs(FT, Attrs, &F);
// On function declarations/definitions, we do not support the builtin // On function declarations/definitions, we do not support the builtin
// attribute. We do not check this in VerifyFunctionAttrs since that is // attribute. We do not check this in VerifyFunctionAttrs since that is
// checking for Attributes that can/can not ever be on functions. // checking for Attributes that can/can not ever be on functions.
Assert(!Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::Builtin), Assert(!Attrs.hasAttribute(AttributeList::FunctionIndex, Attribute::Builtin),
"Attribute 'builtin' can only be applied to a callsite.", &F); "Attribute 'builtin' can only be applied to a callsite.", &F);
// Check that this function meets the restrictions on this calling convention. // Check that this function meets the restrictions on this calling convention.
// Sometimes varargs is used for perfectly forwarding thunks, so some of these // Sometimes varargs is used for perfectly forwarding thunks, so some of these
// restrictions can be lifted. // restrictions can be lifted.
switch (F.getCallingConv()) { switch (F.getCallingConv()) {
default: default:
case CallingConv::C: case CallingConv::C:
▲ Show 20 Lines • Show All 609 Lines • ▼ Show 20 Lines Assert(CS.arg_size() == FTy->getNumParams(),
"Incorrect number of arguments passed to called function!", I); "Incorrect number of arguments passed to called function!", I);
// Verify that all arguments to the call match the function type. // Verify that all arguments to the call match the function type.
for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
Assert(CS.getArgument(i)->getType() == FTy->getParamType(i), Assert(CS.getArgument(i)->getType() == FTy->getParamType(i),
"Call parameter type does not match function signature!", "Call parameter type does not match function signature!",
CS.getArgument(i), FTy->getParamType(i), I); CS.getArgument(i), FTy->getParamType(i), I);
AttributeSet Attrs = CS.getAttributes(); AttributeList Attrs = CS.getAttributes();
Assert(verifyAttributeCount(Attrs, CS.arg_size()), Assert(verifyAttributeCount(Attrs, CS.arg_size()),
"Attribute after last parameter!", I); "Attribute after last parameter!", I);
// Verify call attributes. // Verify call attributes.
verifyFunctionAttrs(FTy, Attrs, I); verifyFunctionAttrs(FTy, Attrs, I);
// Conservatively check the inalloca argument. // Conservatively check the inalloca argument.
▲ Show 20 Lines • Show All 127 Lines • ▼ Show 20 Lines if (L == R)
return true; return true;
PointerType *PL = dyn_cast<PointerType>(L); PointerType *PL = dyn_cast<PointerType>(L);
PointerType *PR = dyn_cast<PointerType>(R); PointerType *PR = dyn_cast<PointerType>(R);
if (!PL || !PR) if (!PL || !PR)
return false; return false;
return PL->getAddressSpace() == PR->getAddressSpace(); return PL->getAddressSpace() == PR->getAddressSpace();
} }
static AttrBuilder getParameterABIAttributes(int I, AttributeSet Attrs) { static AttrBuilder getParameterABIAttributes(int I, AttributeList Attrs) {
static const Attribute::AttrKind ABIAttrs[] = { static const Attribute::AttrKind ABIAttrs[] = {
Attribute::StructRet, Attribute::ByVal, Attribute::InAlloca, Attribute::StructRet, Attribute::ByVal, Attribute::InAlloca,
Attribute::InReg, Attribute::Returned, Attribute::SwiftSelf, Attribute::InReg, Attribute::Returned, Attribute::SwiftSelf,
Attribute::SwiftError}; Attribute::SwiftError};
AttrBuilder Copy; AttrBuilder Copy;
for (auto AK : ABIAttrs) { for (auto AK : ABIAttrs) {
if (Attrs.hasAttribute(I + 1, AK)) if (Attrs.hasAttribute(I + 1, AK))
Copy.addAttribute(AK); Copy.addAttribute(AK);
Show All 25 Linesvoid Verifier::verifyMustTailCall(CallInst &CI) {
} }
// - The calling conventions of the caller and callee must match. // - The calling conventions of the caller and callee must match.
Assert(F->getCallingConv() == CI.getCallingConv(), Assert(F->getCallingConv() == CI.getCallingConv(),
"cannot guarantee tail call due to mismatched calling conv", &CI); "cannot guarantee tail call due to mismatched calling conv", &CI);
// - All ABI-impacting function attributes, such as sret, byval, inreg, // - All ABI-impacting function attributes, such as sret, byval, inreg,
// returned, and inalloca, must match. // returned, and inalloca, must match.
AttributeSet CallerAttrs = F->getAttributes(); AttributeList CallerAttrs = F->getAttributes();
AttributeSet CalleeAttrs = CI.getAttributes(); AttributeList CalleeAttrs = CI.getAttributes();
for (int I = 0, E = CallerTy->getNumParams(); I != E; ++I) { for (int I = 0, E = CallerTy->getNumParams(); I != E; ++I) {
AttrBuilder CallerABIAttrs = getParameterABIAttributes(I, CallerAttrs); AttrBuilder CallerABIAttrs = getParameterABIAttributes(I, CallerAttrs);
AttrBuilder CalleeABIAttrs = getParameterABIAttributes(I, CalleeAttrs); AttrBuilder CalleeABIAttrs = getParameterABIAttributes(I, CalleeAttrs);
Assert(CallerABIAttrs == CalleeABIAttrs, Assert(CallerABIAttrs == CalleeABIAttrs,
"cannot guarantee tail call due to mismatched ABI impacting " "cannot guarantee tail call due to mismatched ABI impacting "
"function attributes", "function attributes",
&CI, CI.getOperand(I)); &CI, CI.getOperand(I));
} }
▲ Show 20 Lines • Show All 2,086 Lines • Show Last 20 Lines

llvm/trunk/lib/Target/AArch64/AArch64CallLowering.cpp

Show First 20 Lines • Show All 213 Lines • ▼ Show 20 Linesbool AArch64CallLowering::lowerReturn(MachineIRBuilder &MIRBuilder,
bool Success = true; bool Success = true;
if (VReg) { if (VReg) {
const AArch64TargetLowering &TLI = *getTLI<AArch64TargetLowering>(); const AArch64TargetLowering &TLI = *getTLI<AArch64TargetLowering>();
CCAssignFn *AssignFn = TLI.CCAssignFnForReturn(F.getCallingConv()); CCAssignFn *AssignFn = TLI.CCAssignFnForReturn(F.getCallingConv());
MachineRegisterInfo &MRI = MF.getRegInfo(); MachineRegisterInfo &MRI = MF.getRegInfo();
auto &DL = F.getParent()->getDataLayout(); auto &DL = F.getParent()->getDataLayout();
ArgInfo OrigArg{VReg, Val->getType()}; ArgInfo OrigArg{VReg, Val->getType()};
setArgFlags(OrigArg, AttributeSet::ReturnIndex, DL, F); setArgFlags(OrigArg, AttributeList::ReturnIndex, DL, F);
SmallVector<ArgInfo, 8> SplitArgs; SmallVector<ArgInfo, 8> SplitArgs;
splitToValueTypes(OrigArg, SplitArgs, DL, MRI, splitToValueTypes(OrigArg, SplitArgs, DL, MRI,
[&](unsigned Reg, uint64_t Offset) { [&](unsigned Reg, uint64_t Offset) {
MIRBuilder.buildExtract(Reg, VReg, Offset); MIRBuilder.buildExtract(Reg, VReg, Offset);
}); });
OutgoingArgHandler Handler(MIRBuilder, MRI, MIB, AssignFn, AssignFn); OutgoingArgHandler Handler(MIRBuilder, MRI, MIB, AssignFn, AssignFn);
▲ Show 20 Lines • Show All 159 Lines • Show Last 20 Lines

llvm/trunk/lib/Target/AArch64/AArch64FrameLowering.cpp

Show First 20 Lines • Show All 877 Lines • ▼ Show 20 Linesstatic unsigned getPrologueDeath(MachineFunction &MF, unsigned Reg) {
// Omitting the kill flags is conservatively correct even if the live-in // Omitting the kill flags is conservatively correct even if the live-in
// is not used after all. // is not used after all.
bool IsLiveIn = MF.getRegInfo().isLiveIn(Reg); bool IsLiveIn = MF.getRegInfo().isLiveIn(Reg);
return getKillRegState(!IsLiveIn); return getKillRegState(!IsLiveIn);
} }
static bool produceCompactUnwindFrame(MachineFunction &MF) { static bool produceCompactUnwindFrame(MachineFunction &MF) {
const AArch64Subtarget &Subtarget = MF.getSubtarget<AArch64Subtarget>(); const AArch64Subtarget &Subtarget = MF.getSubtarget<AArch64Subtarget>();
AttributeSet Attrs = MF.getFunction()->getAttributes(); AttributeList Attrs = MF.getFunction()->getAttributes();
return Subtarget.isTargetMachO() && return Subtarget.isTargetMachO() &&
!(Subtarget.getTargetLowering()->supportSwiftError() && !(Subtarget.getTargetLowering()->supportSwiftError() &&
Attrs.hasAttrSomewhere(Attribute::SwiftError)); Attrs.hasAttrSomewhere(Attribute::SwiftError));
} }
namespace { namespace {
struct RegPairInfo { struct RegPairInfo {
▲ Show 20 Lines • Show All 330 Lines • Show Last 20 Lines

llvm/trunk/lib/Target/AArch64/AArch64ISelLowering.h

Show First 20 Lines • Show All 396 Lines • ▼ Show 20 Linespublic:
/// If a physical register, this returns the register that receives the /// If a physical register, this returns the register that receives the
/// exception typeid on entry to a landing pad. /// exception typeid on entry to a landing pad.
unsigned unsigned
getExceptionSelectorRegister(const Constant *PersonalityFn) const override { getExceptionSelectorRegister(const Constant *PersonalityFn) const override {
// FIXME: This is a guess. Has this been defined yet? // FIXME: This is a guess. Has this been defined yet?
return AArch64::X1; return AArch64::X1;
} }
bool isIntDivCheap(EVT VT, AttributeSet Attr) const override; bool isIntDivCheap(EVT VT, AttributeList Attr) const override;
bool isCheapToSpeculateCttz() const override { bool isCheapToSpeculateCttz() const override {
return true; return true;
} }
bool isCheapToSpeculateCtlz() const override { bool isCheapToSpeculateCtlz() const override {
return true; return true;
} }
▲ Show 20 Lines • Show All 199 Lines • Show Last 20 Lines

llvm/trunk/lib/Target/AArch64/AArch64ISelLowering.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 7,756 Lines • ▼ Show 20 Linesstatic SDValue performXorCombine(SDNode *N, SelectionDAG &DAG,
return performIntegerAbsCombine(N, DAG); return performIntegerAbsCombine(N, DAG);
} }
SDValue SDValue
AArch64TargetLowering::BuildSDIVPow2(SDNode *N, const APInt &Divisor, AArch64TargetLowering::BuildSDIVPow2(SDNode *N, const APInt &Divisor,
SelectionDAG &DAG, SelectionDAG &DAG,
std::vector<SDNode *> *Created) const { std::vector<SDNode *> *Created) const {
AttributeSet Attr = DAG.getMachineFunction().getFunction()->getAttributes(); AttributeList Attr = DAG.getMachineFunction().getFunction()->getAttributes();
if (isIntDivCheap(N->getValueType(0), Attr)) if (isIntDivCheap(N->getValueType(0), Attr))
return SDValue(N,0); // Lower SDIV as SDIV return SDValue(N,0); // Lower SDIV as SDIV
// fold (sdiv X, pow2) // fold (sdiv X, pow2)
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
if ((VT != MVT::i32 && VT != MVT::i64) || if ((VT != MVT::i32 && VT != MVT::i64) ||
!(Divisor.isPowerOf2() || (-Divisor).isPowerOf2())) !(Divisor.isPowerOf2() || (-Divisor).isPowerOf2()))
return SDValue(); return SDValue();
▲ Show 20 Lines • Show All 3,015 Lines • ▼ Show 20 Lines for (const MCPhysReg *I = IStart; *I; ++I) {
// Insert the copy-back instructions right before the terminator. // Insert the copy-back instructions right before the terminator.
for (auto *Exit : Exits) for (auto *Exit : Exits)
BuildMI(*Exit, Exit->getFirstTerminator(), DebugLoc(), BuildMI(*Exit, Exit->getFirstTerminator(), DebugLoc(),
TII->get(TargetOpcode::COPY), *I) TII->get(TargetOpcode::COPY), *I)
.addReg(NewVR); .addReg(NewVR);
} }
} }
bool AArch64TargetLowering::isIntDivCheap(EVT VT, AttributeSet Attr) const { bool AArch64TargetLowering::isIntDivCheap(EVT VT, AttributeList Attr) const {
// Integer division on AArch64 is expensive. However, when aggressively // Integer division on AArch64 is expensive. However, when aggressively
// optimizing for code size, we prefer to use a div instruction, as it is // optimizing for code size, we prefer to use a div instruction, as it is
// usually smaller than the alternative sequence. // usually smaller than the alternative sequence.
// The exception to this is vector division. Since AArch64 doesn't have vector // The exception to this is vector division. Since AArch64 doesn't have vector
// integer division, leaving the division as-is is a loss even in terms of // integer division, leaving the division as-is is a loss even in terms of
// size, because it will have to be scalarized, while the alternative code // size, because it will have to be scalarized, while the alternative code
// sequence can be performed in vector form. // sequence can be performed in vector form.
bool OptSize = bool OptSize =
Attr.hasAttribute(AttributeSet::FunctionIndex, Attribute::MinSize); Attr.hasAttribute(AttributeList::FunctionIndex, Attribute::MinSize);
return OptSize && !VT.isVector(); return OptSize && !VT.isVector();
} }
unsigned unsigned
AArch64TargetLowering::getVaListSizeInBits(const DataLayout &DL) const { AArch64TargetLowering::getVaListSizeInBits(const DataLayout &DL) const {
if (Subtarget->isTargetDarwin()) if (Subtarget->isTargetDarwin())
return getPointerTy(DL).getSizeInBits(); return getPointerTy(DL).getSizeInBits();
return 3 * getPointerTy(DL).getSizeInBits() + 2 * 32; return 3 * getPointerTy(DL).getSizeInBits() + 2 * 32;
} }

llvm/trunk/lib/Target/AMDGPU/AMDGPUIntrinsicInfo.cpp

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 Lines
} }
Function *AMDGPUIntrinsicInfo::getDeclaration(Module *M, unsigned IntrID, Function *AMDGPUIntrinsicInfo::getDeclaration(Module *M, unsigned IntrID,
ArrayRef<Type *> Tys) const { ArrayRef<Type *> Tys) const {
FunctionType *FTy = getType(M->getContext(), IntrID, Tys); FunctionType *FTy = getType(M->getContext(), IntrID, Tys);
Function *F Function *F
= cast<Function>(M->getOrInsertFunction(getName(IntrID, Tys), FTy)); = cast<Function>(M->getOrInsertFunction(getName(IntrID, Tys), FTy));
AttributeSet AS = getAttributes(M->getContext(), AttributeList AS =
static_cast<AMDGPUIntrinsic::ID>(IntrID)); getAttributes(M->getContext(), static_cast<AMDGPUIntrinsic::ID>(IntrID));
F->setAttributes(AS); F->setAttributes(AS);
return F; return F;
} }
Function *AMDGPUIntrinsicInfo::getDeclaration(Module *M, unsigned IntrID, Function *AMDGPUIntrinsicInfo::getDeclaration(Module *M, unsigned IntrID,
Type **Tys, Type **Tys,
unsigned NumTys) const { unsigned NumTys) const {
return getDeclaration(M, IntrID, makeArrayRef(Tys, NumTys)); return getDeclaration(M, IntrID, makeArrayRef(Tys, NumTys));
} }

llvm/trunk/lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp

Show First 20 Lines • Show All 303 Lines • ▼ Show 20 LinesAMDGPUPromoteAlloca::getLocalSizeYZ(IRBuilder<> &Builder) {
// uint64_t reserved2; // uint64_t reserved2;
// hsa_signal_t completion_signal; // uint64_t wrapper // hsa_signal_t completion_signal; // uint64_t wrapper
// } hsa_kernel_dispatch_packet_t // } hsa_kernel_dispatch_packet_t
// //
Function *DispatchPtrFn Function *DispatchPtrFn
= Intrinsic::getDeclaration(Mod, Intrinsic::amdgcn_dispatch_ptr); = Intrinsic::getDeclaration(Mod, Intrinsic::amdgcn_dispatch_ptr);
CallInst *DispatchPtr = Builder.CreateCall(DispatchPtrFn, {}); CallInst *DispatchPtr = Builder.CreateCall(DispatchPtrFn, {});
DispatchPtr->addAttribute(AttributeSet::ReturnIndex, Attribute::NoAlias); DispatchPtr->addAttribute(AttributeList::ReturnIndex, Attribute::NoAlias);
DispatchPtr->addAttribute(AttributeSet::ReturnIndex, Attribute::NonNull); DispatchPtr->addAttribute(AttributeList::ReturnIndex, Attribute::NonNull);
// Size of the dispatch packet struct. // Size of the dispatch packet struct.
DispatchPtr->addDereferenceableAttr(AttributeSet::ReturnIndex, 64); DispatchPtr->addDereferenceableAttr(AttributeList::ReturnIndex, 64);
Type *I32Ty = Type::getInt32Ty(Mod->getContext()); Type *I32Ty = Type::getInt32Ty(Mod->getContext());
Value *CastDispatchPtr = Builder.CreateBitCast( Value *CastDispatchPtr = Builder.CreateBitCast(
DispatchPtr, PointerType::get(I32Ty, AMDGPUAS::CONSTANT_ADDRESS)); DispatchPtr, PointerType::get(I32Ty, AMDGPUAS::CONSTANT_ADDRESS));
// We could do a single 64-bit load here, but it's likely that the basic // We could do a single 64-bit load here, but it's likely that the basic
// 32-bit and extract sequence is already present, and it is probably easier // 32-bit and extract sequence is already present, and it is probably easier
// to CSE this. The loads should be mergable later anyway. // to CSE this. The loads should be mergable later anyway.
▲ Show 20 Lines • Show All 549 Lines • Show Last 20 Lines

llvm/trunk/lib/Target/ARM/ARMCallLowering.cpp

Show First 20 Lines • Show All 179 Lines • ▼ Show 20 Linesbool ARMCallLowering::lowerReturnVal(MachineIRBuilder &MIRBuilder,
auto DL = MF.getDataLayout(); auto DL = MF.getDataLayout();
auto &TLI = *getTLI<ARMTargetLowering>(); auto &TLI = *getTLI<ARMTargetLowering>();
if (!isSupportedType(DL, TLI, Val->getType())) if (!isSupportedType(DL, TLI, Val->getType()))
return false; return false;
SmallVector<ArgInfo, 4> SplitVTs; SmallVector<ArgInfo, 4> SplitVTs;
ArgInfo RetInfo(VReg, Val->getType()); ArgInfo RetInfo(VReg, Val->getType());
setArgFlags(RetInfo, AttributeSet::ReturnIndex, DL, F); setArgFlags(RetInfo, AttributeList::ReturnIndex, DL, F);
splitToValueTypes(RetInfo, SplitVTs, DL, MF.getRegInfo()); splitToValueTypes(RetInfo, SplitVTs, DL, MF.getRegInfo());
CCAssignFn *AssignFn = CCAssignFn *AssignFn =
TLI.CCAssignFnForReturn(F.getCallingConv(), F.isVarArg()); TLI.CCAssignFnForReturn(F.getCallingConv(), F.isVarArg());
OutgoingValueHandler RetHandler(MIRBuilder, MF.getRegInfo(), Ret, AssignFn); OutgoingValueHandler RetHandler(MIRBuilder, MF.getRegInfo(), Ret, AssignFn);
return handleAssignments(MIRBuilder, SplitVTs, RetHandler); return handleAssignments(MIRBuilder, SplitVTs, RetHandler);
} }
▲ Show 20 Lines • Show All 242 Lines • Show Last 20 Lines

llvm/trunk/lib/Target/AVR/AVRISelLowering.cpp

Show First 20 Lines • Show All 1,375 Lines • ▼ Show 20 Lines for (unsigned i = 0; i != e; ++i) {
// Guarantee that all emitted copies are stuck together with flags. // Guarantee that all emitted copies are stuck together with flags.
Flag = Chain.getValue(1); Flag = Chain.getValue(1);
RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT())); RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT()));
} }
// Don't emit the ret/reti instruction when the naked attribute is present in // Don't emit the ret/reti instruction when the naked attribute is present in
// the function being compiled. // the function being compiled.
if (MF.getFunction()->getAttributes().hasAttribute( if (MF.getFunction()->getAttributes().hasAttribute(
AttributeSet::FunctionIndex, Attribute::Naked)) { AttributeList::FunctionIndex, Attribute::Naked)) {
return Chain; return Chain;
} }
unsigned RetOpc = unsigned RetOpc =
(CallConv == CallingConv::AVR_INTR || CallConv == CallingConv::AVR_SIGNAL) (CallConv == CallingConv::AVR_INTR || CallConv == CallingConv::AVR_SIGNAL)
? AVRISD::RETI_FLAG ? AVRISD::RETI_FLAG
: AVRISD::RET_FLAG; : AVRISD::RET_FLAG;
▲ Show 20 Lines • Show All 593 Lines • Show Last 20 Lines

llvm/trunk/lib/Target/Hexagon/HexagonBitTracker.cpp

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Lines for (arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E; ++I) {
if (ATy->isIntegerTy()) if (ATy->isIntegerTy())
Width = ATy->getIntegerBitWidth(); Width = ATy->getIntegerBitWidth();
else if (ATy->isPointerTy()) else if (ATy->isPointerTy())
Width = 32; Width = 32;
// If pointer size is not set through target data, it will default to // If pointer size is not set through target data, it will default to
// Module::AnyPointerSize. // Module::AnyPointerSize.
if (Width == 0 || Width > 64) if (Width == 0 || Width > 64)
break; break;
AttributeSet Attrs = F.getAttributes(); AttributeList Attrs = F.getAttributes();
if (Attrs.hasAttribute(AttrIdx, Attribute::ByVal)) if (Attrs.hasAttribute(AttrIdx, Attribute::ByVal))
continue; continue;
InPhysReg = getNextPhysReg(InPhysReg, Width); InPhysReg = getNextPhysReg(InPhysReg, Width);
if (!InPhysReg) if (!InPhysReg)
break; break;
InVirtReg = getVirtRegFor(InPhysReg); InVirtReg = getVirtRegFor(InPhysReg);
if (!InVirtReg) if (!InVirtReg)
continue; continue;
▲ Show 20 Lines • Show All 1,138 Lines • Show Last 20 Lines

llvm/trunk/lib/Target/Hexagon/HexagonTargetMachine.cpp

Show First 20 Lines • Show All 170 Lines • ▼ Show 20 Lines : LLVMTargetMachine(
(HexagonNoOpt ? CodeGenOpt::None : OL)), (HexagonNoOpt ? CodeGenOpt::None : OL)),
TLOF(make_unique<HexagonTargetObjectFile>()) { TLOF(make_unique<HexagonTargetObjectFile>()) {
initializeHexagonExpandCondsetsPass(*PassRegistry::getPassRegistry()); initializeHexagonExpandCondsetsPass(*PassRegistry::getPassRegistry());
initAsmInfo(); initAsmInfo();
} }
const HexagonSubtarget * const HexagonSubtarget *
HexagonTargetMachine::getSubtargetImpl(const Function &F) const { HexagonTargetMachine::getSubtargetImpl(const Function &F) const {
AttributeSet FnAttrs = F.getAttributes(); AttributeList FnAttrs = F.getAttributes();
Attribute CPUAttr = Attribute CPUAttr =
FnAttrs.getAttribute(AttributeSet::FunctionIndex, "target-cpu"); FnAttrs.getAttribute(AttributeList::FunctionIndex, "target-cpu");
Attribute FSAttr = Attribute FSAttr =
FnAttrs.getAttribute(AttributeSet::FunctionIndex, "target-features"); FnAttrs.getAttribute(AttributeList::FunctionIndex, "target-features");
std::string CPU = !CPUAttr.hasAttribute(Attribute::None) std::string CPU = !CPUAttr.hasAttribute(Attribute::None)
? CPUAttr.getValueAsString().str() ? CPUAttr.getValueAsString().str()
: TargetCPU; : TargetCPU;
std::string FS = !FSAttr.hasAttribute(Attribute::None) std::string FS = !FSAttr.hasAttribute(Attribute::None)
? FSAttr.getValueAsString().str() ? FSAttr.getValueAsString().str()
: TargetFS; : TargetFS;
▲ Show 20 Lines • Show All 166 Lines • Show Last 20 Lines

llvm/trunk/lib/Target/Mips/Mips16HardFloat.cpp

Show First 20 Lines • Show All 399 Lines • ▼ Show 20 Lines for (auto &I: BB) {
Type *T = RVal->getType(); Type *T = RVal->getType();
FPReturnVariant RV = whichFPReturnVariant(T); FPReturnVariant RV = whichFPReturnVariant(T);
if (RV == NoFPRet) continue; if (RV == NoFPRet) continue;
static const char *const Helper[NoFPRet] = { static const char *const Helper[NoFPRet] = {
"__mips16_ret_sf", "__mips16_ret_df", "__mips16_ret_sc", "__mips16_ret_sf", "__mips16_ret_df", "__mips16_ret_sc",
"__mips16_ret_dc" "__mips16_ret_dc"
}; };
const char *Name = Helper[RV]; const char *Name = Helper[RV];
AttributeSet A; AttributeList A;
Value *Params[] = {RVal}; Value *Params[] = {RVal};
Modified = true; Modified = true;
// //
// These helper functions have a different calling ABI so // These helper functions have a different calling ABI so
// this __Mips16RetHelper indicates that so that later // this __Mips16RetHelper indicates that so that later
// during call setup, the proper call lowering to the helper // during call setup, the proper call lowering to the helper
// functions will take place. // functions will take place.
// //
A = A.addAttribute(C, AttributeSet::FunctionIndex, A = A.addAttribute(C, AttributeList::FunctionIndex,
"__Mips16RetHelper"); "__Mips16RetHelper");
A = A.addAttribute(C, AttributeSet::FunctionIndex, A = A.addAttribute(C, AttributeList::FunctionIndex,
Attribute::ReadNone); Attribute::ReadNone);
A = A.addAttribute(C, AttributeSet::FunctionIndex, A = A.addAttribute(C, AttributeList::FunctionIndex,
Attribute::NoInline); Attribute::NoInline);
Value *F = (M->getOrInsertFunction(Name, A, MyVoid, T, nullptr)); Value *F = (M->getOrInsertFunction(Name, A, MyVoid, T, nullptr));
CallInst::Create(F, Params, "", &I); CallInst::Create(F, Params, "", &I);
} else if (const CallInst *CI = dyn_cast<CallInst>(&I)) { } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
FunctionType *FT = CI->getFunctionType(); FunctionType *FT = CI->getFunctionType();
Function *F_ = CI->getCalledFunction(); Function *F_ = CI->getCalledFunction();
if (needsFPReturnHelper(*FT) && if (needsFPReturnHelper(*FT) &&
!(F_ && isIntrinsicInline(F_))) { !(F_ && isIntrinsicInline(F_))) {
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Linesstatic void createFPFnStub(Function *F, Module *M, FPParamVariant PV,
new UnreachableInst(FStub->getContext(), BB); new UnreachableInst(FStub->getContext(), BB);
} }
// //
// remove the use-soft-float attribute // remove the use-soft-float attribute
// //
static void removeUseSoftFloat(Function &F) { static void removeUseSoftFloat(Function &F) {
AttributeSet A; AttributeList A;
DEBUG(errs() << "removing -use-soft-float\n"); DEBUG(errs() << "removing -use-soft-float\n");
A = A.addAttribute(F.getContext(), AttributeSet::FunctionIndex, A = A.addAttribute(F.getContext(), AttributeList::FunctionIndex,
"use-soft-float", "false"); "use-soft-float", "false");
F.removeAttributes(AttributeSet::FunctionIndex, A); F.removeAttributes(AttributeList::FunctionIndex, A);
if (F.hasFnAttribute("use-soft-float")) { if (F.hasFnAttribute("use-soft-float")) {
DEBUG(errs() << "still has -use-soft-float\n"); DEBUG(errs() << "still has -use-soft-float\n");
} }
F.addAttributes(AttributeSet::FunctionIndex, A); F.addAttributes(AttributeList::FunctionIndex, A);
} }
// //
// This pass only makes sense when the underlying chip has floating point but // This pass only makes sense when the underlying chip has floating point but
// we are compiling as mips16. // we are compiling as mips16.
// For all mips16 functions (that are not stubs we have already generated), or // For all mips16 functions (that are not stubs we have already generated), or
// declared via attributes as nomips16, we must: // declared via attributes as nomips16, we must:
Show All 38 Lines

llvm/trunk/lib/Target/NVPTX/NVPTXAsmPrinter.cpp

Show First 20 Lines • Show All 1,487 Lines • ▼ Show 20 Lines
void NVPTXAsmPrinter::printParamName(Function::const_arg_iterator I, void NVPTXAsmPrinter::printParamName(Function::const_arg_iterator I,
int paramIndex, raw_ostream &O) { int paramIndex, raw_ostream &O) {
getSymbol(I->getParent())->print(O, MAI); getSymbol(I->getParent())->print(O, MAI);
O << "_param_" << paramIndex; O << "_param_" << paramIndex;
} }
void NVPTXAsmPrinter::emitFunctionParamList(const Function *F, raw_ostream &O) { void NVPTXAsmPrinter::emitFunctionParamList(const Function *F, raw_ostream &O) {
const DataLayout &DL = getDataLayout(); const DataLayout &DL = getDataLayout();
const AttributeSet &PAL = F->getAttributes(); const AttributeList &PAL = F->getAttributes();
const TargetLowering *TLI = nvptxSubtarget->getTargetLowering(); const TargetLowering *TLI = nvptxSubtarget->getTargetLowering();
Function::const_arg_iterator I, E; Function::const_arg_iterator I, E;
unsigned paramIndex = 0; unsigned paramIndex = 0;
bool first = true; bool first = true;
bool isKernelFunc = isKernelFunction(*F); bool isKernelFunc = isKernelFunction(*F);
bool isABI = (nvptxSubtarget->getSmVersion() >= 20); bool isABI = (nvptxSubtarget->getSmVersion() >= 20);
MVT thePointerTy = TLI->getPointerTy(DL); MVT thePointerTy = TLI->getPointerTy(DL);
▲ Show 20 Lines • Show All 945 Lines • Show Last 20 Lines

llvm/trunk/lib/Target/NVPTX/NVPTXISelLowering.cpp

Show First 20 Lines • Show All 2,309 Lines • ▼ Show 20 LinesSDValue NVPTXTargetLowering::LowerFormalArguments(
SDValue Chain, CallingConv::ID CallConv, bool isVarArg, SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &dl, const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &dl,
SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals) const { SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals) const {
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
const DataLayout &DL = DAG.getDataLayout(); const DataLayout &DL = DAG.getDataLayout();
auto PtrVT = getPointerTy(DAG.getDataLayout()); auto PtrVT = getPointerTy(DAG.getDataLayout());
const Function *F = MF.getFunction(); const Function *F = MF.getFunction();
const AttributeSet &PAL = F->getAttributes(); const AttributeList &PAL = F->getAttributes();
const TargetLowering *TLI = STI.getTargetLowering(); const TargetLowering *TLI = STI.getTargetLowering();
SDValue Root = DAG.getRoot(); SDValue Root = DAG.getRoot();
std::vector<SDValue> OutChains; std::vector<SDValue> OutChains;
bool isABI = (STI.getSmVersion() >= 20); bool isABI = (STI.getSmVersion() >= 20);
assert(isABI && "Non-ABI compilation is not supported"); assert(isABI && "Non-ABI compilation is not supported");
if (!isABI) if (!isABI)
▲ Show 20 Lines • Show All 2,335 Lines • Show Last 20 Lines

llvm/trunk/lib/Target/WebAssembly/WebAssemblyFastISel.cpp

Show First 20 Lines • Show All 590 Lines • ▼ Show 20 Lines if (!FuncInfo.CanLowerReturn)
return false; return false;
const Function *F = FuncInfo.Fn; const Function *F = FuncInfo.Fn;
if (F->isVarArg()) if (F->isVarArg())
return false; return false;
unsigned i = 0; unsigned i = 0;
for (auto const &Arg : F->args()) { for (auto const &Arg : F->args()) {
const AttributeSet &Attrs = F->getAttributes(); const AttributeList &Attrs = F->getAttributes();
if (Attrs.hasAttribute(i+1, Attribute::ByVal) || if (Attrs.hasAttribute(i+1, Attribute::ByVal) ||
Attrs.hasAttribute(i+1, Attribute::SwiftSelf) || Attrs.hasAttribute(i+1, Attribute::SwiftSelf) ||
Attrs.hasAttribute(i+1, Attribute::SwiftError) || Attrs.hasAttribute(i+1, Attribute::SwiftError) ||
Attrs.hasAttribute(i+1, Attribute::InAlloca) || Attrs.hasAttribute(i+1, Attribute::InAlloca) ||
Attrs.hasAttribute(i+1, Attribute::Nest)) Attrs.hasAttribute(i+1, Attribute::Nest))
return false; return false;
Type *ArgTy = Arg.getType(); Type *ArgTy = Arg.getType();
▲ Show 20 Lines • Show All 133 Lines • ▼ Show 20 Linesbool WebAssemblyFastISel::selectCall(const Instruction *I) {
SmallVector<unsigned, 8> Args; SmallVector<unsigned, 8> Args;
for (unsigned i = 0, e = Call->getNumArgOperands(); i < e; ++i) { for (unsigned i = 0, e = Call->getNumArgOperands(); i < e; ++i) {
Value *V = Call->getArgOperand(i); Value *V = Call->getArgOperand(i);
MVT::SimpleValueType ArgTy = getSimpleType(V->getType()); MVT::SimpleValueType ArgTy = getSimpleType(V->getType());
if (ArgTy == MVT::INVALID_SIMPLE_VALUE_TYPE) if (ArgTy == MVT::INVALID_SIMPLE_VALUE_TYPE)
return false; return false;
const AttributeSet &Attrs = Call->getAttributes(); const AttributeList &Attrs = Call->getAttributes();
if (Attrs.hasAttribute(i+1, Attribute::ByVal) || if (Attrs.hasAttribute(i+1, Attribute::ByVal) ||
Attrs.hasAttribute(i+1, Attribute::SwiftSelf) || Attrs.hasAttribute(i+1, Attribute::SwiftSelf) ||
Attrs.hasAttribute(i+1, Attribute::SwiftError) || Attrs.hasAttribute(i+1, Attribute::SwiftError) ||
Attrs.hasAttribute(i+1, Attribute::InAlloca) || Attrs.hasAttribute(i+1, Attribute::InAlloca) ||
Attrs.hasAttribute(i+1, Attribute::Nest)) Attrs.hasAttribute(i+1, Attribute::Nest))
return false; return false;
unsigned Reg; unsigned Reg;
▲ Show 20 Lines • Show All 522 Lines • Show Last 20 Lines

llvm/trunk/lib/Target/WebAssembly/WebAssemblyISelLowering.h

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines std::pair<unsigned, const TargetRegisterClass *> getRegForInlineAsmConstraint(
const TargetRegisterInfo *TRI, StringRef Constraint, const TargetRegisterInfo *TRI, StringRef Constraint,
MVT VT) const override; MVT VT) const override;
bool isCheapToSpeculateCttz() const override; bool isCheapToSpeculateCttz() const override;
bool isCheapToSpeculateCtlz() const override; bool isCheapToSpeculateCtlz() const override;
bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM, Type *Ty, bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM, Type *Ty,
unsigned AS) const override; unsigned AS) const override;
bool allowsMisalignedMemoryAccesses(EVT, unsigned AddrSpace, unsigned Align, bool allowsMisalignedMemoryAccesses(EVT, unsigned AddrSpace, unsigned Align,
bool *Fast) const override; bool *Fast) const override;
bool isIntDivCheap(EVT VT, AttributeSet Attr) const override; bool isIntDivCheap(EVT VT, AttributeList Attr) const override;
SDValue LowerCall(CallLoweringInfo &CLI, SDValue LowerCall(CallLoweringInfo &CLI,
SmallVectorImpl<SDValue> &InVals) const override; SmallVectorImpl<SDValue> &InVals) const override;
bool CanLowerReturn(CallingConv::ID CallConv, MachineFunction &MF, bool CanLowerReturn(CallingConv::ID CallConv, MachineFunction &MF,
bool isVarArg, bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
LLVMContext &Context) const override; LLVMContext &Context) const override;
SDValue LowerReturn(SDValue Chain, CallingConv::ID CallConv, bool isVarArg, SDValue LowerReturn(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
Show All 29 Lines

llvm/trunk/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

Show First 20 Lines • Show All 252 Lines • ▼ Show 20 Linesbool WebAssemblyTargetLowering::allowsMisalignedMemoryAccesses(
// may be a performance impact. We tell LLVM they're "fast" because // may be a performance impact. We tell LLVM they're "fast" because
// for the kinds of things that LLVM uses this for (merging adjacent stores // for the kinds of things that LLVM uses this for (merging adjacent stores
// of constants, etc.), WebAssembly implementations will either want the // of constants, etc.), WebAssembly implementations will either want the
// unaligned access or they'll split anyway. // unaligned access or they'll split anyway.
if (Fast) *Fast = true; if (Fast) *Fast = true;
return true; return true;
} }
bool WebAssemblyTargetLowering::isIntDivCheap(EVT VT, AttributeSet Attr) const { bool WebAssemblyTargetLowering::isIntDivCheap(EVT VT,
AttributeList Attr) const {
// The current thinking is that wasm engines will perform this optimization, // The current thinking is that wasm engines will perform this optimization,
// so we can save on code size. // so we can save on code size.
return true; return true;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// WebAssembly Lowering private implementation. // WebAssembly Lowering private implementation.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 443 Lines • Show Last 20 Lines

llvm/trunk/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

Show First 20 Lines • Show All 406 Lines • ▼ Show 20 LinesValue *WebAssemblyLowerEmscriptenEHSjLj::wrapInvoke(CallOrInvoke *CI) {
LLVMContext &C = CI->getModule()->getContext(); LLVMContext &C = CI->getModule()->getContext();
// If we are calling a function that is noreturn, we must remove that // If we are calling a function that is noreturn, we must remove that
// attribute. The code we insert here does expect it to return, after we // attribute. The code we insert here does expect it to return, after we
// catch the exception. // catch the exception.
if (CI->doesNotReturn()) { if (CI->doesNotReturn()) {
if (auto *F = dyn_cast<Function>(CI->getCalledValue())) if (auto *F = dyn_cast<Function>(CI->getCalledValue()))
F->removeFnAttr(Attribute::NoReturn); F->removeFnAttr(Attribute::NoReturn);
CI->removeAttribute(AttributeSet::FunctionIndex, Attribute::NoReturn); CI->removeAttribute(AttributeList::FunctionIndex, Attribute::NoReturn);
} }
IRBuilder<> IRB(C); IRBuilder<> IRB(C);
IRB.SetInsertPoint(CI); IRB.SetInsertPoint(CI);
// Pre-invoke // Pre-invoke
// __THREW__ = 0; // __THREW__ = 0;
IRB.CreateStore(IRB.getInt32(0), ThrewGV); IRB.CreateStore(IRB.getInt32(0), ThrewGV);
// Invoke function wrapper in JavaScript // Invoke function wrapper in JavaScript
SmallVector<Value *, 16> Args; SmallVector<Value *, 16> Args;
// Put the pointer to the callee as first argument, so it can be called // Put the pointer to the callee as first argument, so it can be called
// within the invoke wrapper later // within the invoke wrapper later
Args.push_back(CI->getCalledValue()); Args.push_back(CI->getCalledValue());
Args.append(CI->arg_begin(), CI->arg_end()); Args.append(CI->arg_begin(), CI->arg_end());
CallInst *NewCall = IRB.CreateCall(getInvokeWrapper(CI), Args); CallInst *NewCall = IRB.CreateCall(getInvokeWrapper(CI), Args);
NewCall->takeName(CI); NewCall->takeName(CI);
NewCall->setCallingConv(CI->getCallingConv()); NewCall->setCallingConv(CI->getCallingConv());
NewCall->setDebugLoc(CI->getDebugLoc()); NewCall->setDebugLoc(CI->getDebugLoc());
// Because we added the pointer to the callee as first argument, all // Because we added the pointer to the callee as first argument, all
// argument attribute indices have to be incremented by one. // argument attribute indices have to be incremented by one.
SmallVector<AttributeSet, 8> AttributesVec; SmallVector<AttributeList, 8> AttributesVec;
const AttributeSet &InvokePAL = CI->getAttributes(); const AttributeList &InvokePAL = CI->getAttributes();
CallSite::arg_iterator AI = CI->arg_begin(); CallSite::arg_iterator AI = CI->arg_begin();
unsigned i = 1; // Argument attribute index starts from 1 unsigned i = 1; // Argument attribute index starts from 1
for (unsigned e = CI->getNumArgOperands(); i <= e; ++AI, ++i) { for (unsigned e = CI->getNumArgOperands(); i <= e; ++AI, ++i) {
if (InvokePAL.hasAttributes(i)) { if (InvokePAL.hasAttributes(i)) {
AttrBuilder B(InvokePAL, i); AttrBuilder B(InvokePAL, i);
AttributesVec.push_back(AttributeSet::get(C, i + 1, B)); AttributesVec.push_back(AttributeList::get(C, i + 1, B));
} }
} }
// Add any return attributes. // Add any return attributes.
if (InvokePAL.hasAttributes(AttributeSet::ReturnIndex)) if (InvokePAL.hasAttributes(AttributeList::ReturnIndex))
AttributesVec.push_back(AttributeSet::get(C, InvokePAL.getRetAttributes())); AttributesVec.push_back(
AttributeList::get(C, InvokePAL.getRetAttributes()));
// Add any function attributes. // Add any function attributes.
if (InvokePAL.hasAttributes(AttributeSet::FunctionIndex)) if (InvokePAL.hasAttributes(AttributeList::FunctionIndex))
AttributesVec.push_back(AttributeSet::get(C, InvokePAL.getFnAttributes())); AttributesVec.push_back(AttributeList::get(C, InvokePAL.getFnAttributes()));
// Reconstruct the AttributesList based on the vector we constructed. // Reconstruct the AttributesList based on the vector we constructed.
AttributeSet NewCallPAL = AttributeSet::get(C, AttributesVec); AttributeList NewCallPAL = AttributeList::get(C, AttributesVec);
NewCall->setAttributes(NewCallPAL); NewCall->setAttributes(NewCallPAL);
CI->replaceAllUsesWith(NewCall); CI->replaceAllUsesWith(NewCall);
// Post-invoke // Post-invoke
// %__THREW__.val = __THREW__; __THREW__ = 0; // %__THREW__.val = __THREW__; __THREW__ = 0;
Value *Threw = IRB.CreateLoad(ThrewGV, ThrewGV->getName() + ".val"); Value *Threw = IRB.CreateLoad(ThrewGV, ThrewGV->getName() + ".val");
IRB.CreateStore(IRB.getInt32(0), ThrewGV); IRB.CreateStore(IRB.getInt32(0), ThrewGV);
▲ Show 20 Lines • Show All 721 Lines • Show Last 20 Lines

llvm/trunk/lib/Target/X86/X86CallLowering.cpp

Show First 20 Lines • Show All 101 Lines • ▼ Show 20 Linesbool X86CallLowering::lowerReturn(MachineIRBuilder &MIRBuilder,
if (VReg) { if (VReg) {
MachineFunction &MF = MIRBuilder.getMF(); MachineFunction &MF = MIRBuilder.getMF();
MachineRegisterInfo &MRI = MF.getRegInfo(); MachineRegisterInfo &MRI = MF.getRegInfo();
auto &DL = MF.getDataLayout(); auto &DL = MF.getDataLayout();
const Function &F = *MF.getFunction(); const Function &F = *MF.getFunction();
ArgInfo OrigArg{VReg, Val->getType()}; ArgInfo OrigArg{VReg, Val->getType()};
setArgFlags(OrigArg, AttributeSet::ReturnIndex, DL, F); setArgFlags(OrigArg, AttributeList::ReturnIndex, DL, F);
SmallVector<ArgInfo, 8> SplitArgs; SmallVector<ArgInfo, 8> SplitArgs;
splitToValueTypes(OrigArg, SplitArgs, DL, MRI, splitToValueTypes(OrigArg, SplitArgs, DL, MRI,
[&](unsigned Reg, uint64_t Offset) { [&](unsigned Reg, uint64_t Offset) {
MIRBuilder.buildExtract(Reg, VReg, Offset); MIRBuilder.buildExtract(Reg, VReg, Offset);
}); });
FuncReturnHandler Handler(MIRBuilder, MRI, MIB, RetCC_X86); FuncReturnHandler Handler(MIRBuilder, MRI, MIB, RetCC_X86);
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

llvm/trunk/lib/Target/X86/X86ISelLowering.h

Show First 20 Lines • Show All 1,040 Lines • ▼ Show 20 Lines public:
SDValue BuildFILD(SDValue Op, EVT SrcVT, SDValue Chain, SDValue StackSlot, SDValue BuildFILD(SDValue Op, EVT SrcVT, SDValue Chain, SDValue StackSlot,
SelectionDAG &DAG) const; SelectionDAG &DAG) const;
bool isNoopAddrSpaceCast(unsigned SrcAS, unsigned DestAS) const override; bool isNoopAddrSpaceCast(unsigned SrcAS, unsigned DestAS) const override;
/// \brief Customize the preferred legalization strategy for certain types. /// \brief Customize the preferred legalization strategy for certain types.
LegalizeTypeAction getPreferredVectorAction(EVT VT) const override; LegalizeTypeAction getPreferredVectorAction(EVT VT) const override;
bool isIntDivCheap(EVT VT, AttributeSet Attr) const override; bool isIntDivCheap(EVT VT, AttributeList Attr) const override;
bool supportSwiftError() const override; bool supportSwiftError() const override;
unsigned getMaxSupportedInterleaveFactor() const override { return 4; } unsigned getMaxSupportedInterleaveFactor() const override { return 4; }
/// \brief Lower interleaved load(s) into target specific /// \brief Lower interleaved load(s) into target specific
/// instructions/intrinsics. /// instructions/intrinsics.
bool lowerInterleavedLoad(LoadInst *LI, bool lowerInterleavedLoad(LoadInst *LI,
▲ Show 20 Lines • Show All 337 Lines • Show Last 20 Lines

llvm/trunk/lib/Target/X86/X86ISelLowering.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 20,775 Lines • ▼ Show 20 Lines if (Subtarget.is64Bit()) {
case CallingConv::C: case CallingConv::C:
case CallingConv::X86_StdCall: { case CallingConv::X86_StdCall: {
// Pass 'nest' parameter in ECX. // Pass 'nest' parameter in ECX.
// Must be kept in sync with X86CallingConv.td // Must be kept in sync with X86CallingConv.td
NestReg = X86::ECX; NestReg = X86::ECX;
// Check that ECX wasn't needed by an 'inreg' parameter. // Check that ECX wasn't needed by an 'inreg' parameter.
FunctionType *FTy = Func->getFunctionType(); FunctionType *FTy = Func->getFunctionType();
const AttributeSet &Attrs = Func->getAttributes(); const AttributeList &Attrs = Func->getAttributes();
if (!Attrs.isEmpty() && !Func->isVarArg()) { if (!Attrs.isEmpty() && !Func->isVarArg()) {
unsigned InRegCount = 0; unsigned InRegCount = 0;
unsigned Idx = 1; unsigned Idx = 1;
for (FunctionType::param_iterator I = FTy->param_begin(), for (FunctionType::param_iterator I = FTy->param_begin(),
E = FTy->param_end(); I != E; ++I, ++Idx) E = FTy->param_end(); I != E; ++I, ++Idx)
if (Attrs.hasAttribute(Idx, Attribute::InReg)) { if (Attrs.hasAttribute(Idx, Attribute::InReg)) {
▲ Show 20 Lines • Show All 15,003 Lines • ▼ Show 20 Linesint X86TargetLowering::getScalingFactorCost(const DataLayout &DL,
// vmovaps %ymm1, (%r8) can use port 2, 3, or 7. // vmovaps %ymm1, (%r8) can use port 2, 3, or 7.
if (isLegalAddressingMode(DL, AM, Ty, AS)) if (isLegalAddressingMode(DL, AM, Ty, AS))
// Scale represents reg2 * scale, thus account for 1 // Scale represents reg2 * scale, thus account for 1
// as soon as we use a second register. // as soon as we use a second register.
return AM.Scale != 0; return AM.Scale != 0;
return -1; return -1;
} }
bool X86TargetLowering::isIntDivCheap(EVT VT, AttributeSet Attr) const { bool X86TargetLowering::isIntDivCheap(EVT VT, AttributeList Attr) const {
// Integer division on x86 is expensive. However, when aggressively optimizing // Integer division on x86 is expensive. However, when aggressively optimizing
// for code size, we prefer to use a div instruction, as it is usually smaller // for code size, we prefer to use a div instruction, as it is usually smaller
// than the alternative sequence. // than the alternative sequence.
// The exception to this is vector division. Since x86 doesn't have vector // The exception to this is vector division. Since x86 doesn't have vector
// integer division, leaving the division as-is is a loss even in terms of // integer division, leaving the division as-is is a loss even in terms of
// size, because it will have to be scalarized, while the alternative code // size, because it will have to be scalarized, while the alternative code
// sequence can be performed in vector form. // sequence can be performed in vector form.
bool OptSize = Attr.hasAttribute(AttributeSet::FunctionIndex, bool OptSize =
Attribute::MinSize); Attr.hasAttribute(AttributeList::FunctionIndex, Attribute::MinSize);
return OptSize && !VT.isVector(); return OptSize && !VT.isVector();
} }
void X86TargetLowering::initializeSplitCSR(MachineBasicBlock *Entry) const { void X86TargetLowering::initializeSplitCSR(MachineBasicBlock *Entry) const {
if (!Subtarget.is64Bit()) if (!Subtarget.is64Bit())
return; return;
// Update IsSplitCSR in X86MachineFunctionInfo. // Update IsSplitCSR in X86MachineFunctionInfo.
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

llvm/trunk/lib/Target/XCore/XCoreFrameLowering.cpp

Show First 20 Lines • Show All 232 Lines • ▼ Show 20 Linesvoid XCoreFrameLowering::emitPrologue(MachineFunction &MF,
// Debug location must be unknown since the first debug location is used // Debug location must be unknown since the first debug location is used
// to determine the end of the prologue. // to determine the end of the prologue.
DebugLoc dl; DebugLoc dl;
if (MFI.getMaxAlignment() > getStackAlignment()) if (MFI.getMaxAlignment() > getStackAlignment())
report_fatal_error("emitPrologue unsupported alignment: " report_fatal_error("emitPrologue unsupported alignment: "
+ Twine(MFI.getMaxAlignment())); + Twine(MFI.getMaxAlignment()));
const AttributeSet &PAL = MF.getFunction()->getAttributes(); const AttributeList &PAL = MF.getFunction()->getAttributes();
if (PAL.hasAttrSomewhere(Attribute::Nest)) if (PAL.hasAttrSomewhere(Attribute::Nest))
BuildMI(MBB, MBBI, dl, TII.get(XCore::LDWSP_ru6), XCore::R11).addImm(0); BuildMI(MBB, MBBI, dl, TII.get(XCore::LDWSP_ru6), XCore::R11).addImm(0);
// FIX: Needs addMemOperand() but can't use getFixedStack() or getStack(). // FIX: Needs addMemOperand() but can't use getFixedStack() or getStack().
// Work out frame sizes. // Work out frame sizes.
// We will adjust the SP in stages towards the final FrameSize. // We will adjust the SP in stages towards the final FrameSize.
assert(MFI.getStackSize()%4 == 0 && "Misaligned frame size"); assert(MFI.getStackSize()%4 == 0 && "Misaligned frame size");
const int FrameSize = MFI.getStackSize() / 4; const int FrameSize = MFI.getStackSize() / 4;
▲ Show 20 Lines • Show All 343 Lines • Show Last 20 Lines

llvm/trunk/lib/Transforms/Coroutines/CoroSplit.cpp

Show First 20 Lines • Show All 238 Lines • ▼ Show 20 Linesstatic Function *createClone(Function &F, Twine Suffix, coro::Shape &Shape,
CloneFunctionInto(NewF, &F, VMap, /*ModuleLevelChanges=*/true, Returns); CloneFunctionInto(NewF, &F, VMap, /*ModuleLevelChanges=*/true, Returns);
// Remove old returns. // Remove old returns.
for (ReturnInst *Return : Returns) for (ReturnInst *Return : Returns)
changeToUnreachable(Return, /*UseLLVMTrap=*/false); changeToUnreachable(Return, /*UseLLVMTrap=*/false);
// Remove old return attributes. // Remove old return attributes.
NewF->removeAttributes( NewF->removeAttributes(
AttributeSet::ReturnIndex, AttributeList::ReturnIndex,
AttributeSet::get( AttributeList::get(
NewF->getContext(), AttributeSet::ReturnIndex, NewF->getContext(), AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NewF->getReturnType()))); AttributeFuncs::typeIncompatible(NewF->getReturnType())));
// Make AllocaSpillBlock the new entry block. // Make AllocaSpillBlock the new entry block.
auto *SwitchBB = cast<BasicBlock>(VMap[ResumeEntry]); auto *SwitchBB = cast<BasicBlock>(VMap[ResumeEntry]);
auto *Entry = cast<BasicBlock>(VMap[Shape.AllocaSpillBlock]); auto *Entry = cast<BasicBlock>(VMap[Shape.AllocaSpillBlock]);
Entry->moveBefore(&NewF->getEntryBlock()); Entry->moveBefore(&NewF->getEntryBlock());
Entry->getTerminator()->eraseFromParent(); Entry->getTerminator()->eraseFromParent();
BranchInst::Create(SwitchBB, Entry); BranchInst::Create(SwitchBB, Entry);
▲ Show 20 Lines • Show All 417 Lines • Show Last 20 Lines

llvm/trunk/lib/Transforms/Coroutines/Coroutines.cpp

Show First 20 Lines • Show All 239 Lines • ▼ Show 20 Lines if (auto II = dyn_cast<IntrinsicInst>(&I)) {
} }
break; break;
case Intrinsic::coro_begin: { case Intrinsic::coro_begin: {
auto CB = cast<CoroBeginInst>(II); auto CB = cast<CoroBeginInst>(II);
if (CB->getId()->getInfo().isPreSplit()) { if (CB->getId()->getInfo().isPreSplit()) {
if (CoroBegin) if (CoroBegin)
report_fatal_error( report_fatal_error(
"coroutine should have exactly one defining @llvm.coro.begin"); "coroutine should have exactly one defining @llvm.coro.begin");
CB->addAttribute(AttributeSet::ReturnIndex, Attribute::NonNull); CB->addAttribute(AttributeList::ReturnIndex, Attribute::NonNull);
CB->addAttribute(AttributeSet::ReturnIndex, Attribute::NoAlias); CB->addAttribute(AttributeList::ReturnIndex, Attribute::NoAlias);
CB->removeAttribute(AttributeSet::FunctionIndex, CB->removeAttribute(AttributeList::FunctionIndex,
Attribute::NoDuplicate); Attribute::NoDuplicate);
CoroBegin = CB; CoroBegin = CB;
} }
break; break;
} }
case Intrinsic::coro_end: case Intrinsic::coro_end:
CoroEnds.push_back(cast<CoroEndInst>(II)); CoroEnds.push_back(cast<CoroEndInst>(II));
if (CoroEnds.back()->isFallthrough()) { if (CoroEnds.back()->isFallthrough()) {
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

llvm/trunk/lib/Transforms/IPO/ArgumentPromotion.cpp

Show First 20 Lines • Show All 96 Lines • ▼ Show 20 LinesdoPromotion(Function *F, SmallPtrSetImpl<Argument *> &ArgsToPromote,
// what the new GEP/Load instructions we are inserting look like. // what the new GEP/Load instructions we are inserting look like.
// We need to keep the original loads for each argument and the elements // We need to keep the original loads for each argument and the elements
// of the argument that are accessed. // of the argument that are accessed.
std::map<std::pair<Argument *, IndicesVector>, LoadInst *> OriginalLoads; std::map<std::pair<Argument *, IndicesVector>, LoadInst *> OriginalLoads;
// Attribute - Keep track of the parameter attributes for the arguments // Attribute - Keep track of the parameter attributes for the arguments
// that we are *not* promoting. For the ones that we do promote, the parameter // that we are *not* promoting. For the ones that we do promote, the parameter
// attributes are lost // attributes are lost
SmallVector<AttributeSet, 8> AttributesVec; SmallVector<AttributeList, 8> AttributesVec;
const AttributeSet &PAL = F->getAttributes(); const AttributeList &PAL = F->getAttributes();
// Add any return attributes. // Add any return attributes.
if (PAL.hasAttributes(AttributeSet::ReturnIndex)) if (PAL.hasAttributes(AttributeList::ReturnIndex))
AttributesVec.push_back( AttributesVec.push_back(
AttributeSet::get(F->getContext(), PAL.getRetAttributes())); AttributeList::get(F->getContext(), PAL.getRetAttributes()));
// First, determine the new argument list // First, determine the new argument list
unsigned ArgIndex = 1; unsigned ArgIndex = 1;
for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E;
++I, ++ArgIndex) { ++I, ++ArgIndex) {
if (ByValArgsToTransform.count(&*I)) { if (ByValArgsToTransform.count(&*I)) {
// Simple byval argument? Just add all the struct element types. // Simple byval argument? Just add all the struct element types.
Type *AgTy = cast<PointerType>(I->getType())->getElementType(); Type *AgTy = cast<PointerType>(I->getType())->getElementType();
StructType *STy = cast<StructType>(AgTy); StructType *STy = cast<StructType>(AgTy);
Params.insert(Params.end(), STy->element_begin(), STy->element_end()); Params.insert(Params.end(), STy->element_begin(), STy->element_end());
++NumByValArgsPromoted; ++NumByValArgsPromoted;
} else if (!ArgsToPromote.count(&*I)) { } else if (!ArgsToPromote.count(&*I)) {
// Unchanged argument // Unchanged argument
Params.push_back(I->getType()); Params.push_back(I->getType());
AttributeSet attrs = PAL.getParamAttributes(ArgIndex); AttributeList attrs = PAL.getParamAttributes(ArgIndex);
if (attrs.hasAttributes(ArgIndex)) { if (attrs.hasAttributes(ArgIndex)) {
AttrBuilder B(attrs, ArgIndex); AttrBuilder B(attrs, ArgIndex);
AttributesVec.push_back( AttributesVec.push_back(
AttributeSet::get(F->getContext(), Params.size(), B)); AttributeList::get(F->getContext(), Params.size(), B));
} }
} else if (I->use_empty()) { } else if (I->use_empty()) {
// Dead argument (which are always marked as promotable) // Dead argument (which are always marked as promotable)
++NumArgumentsDead; ++NumArgumentsDead;
} else { } else {
// Okay, this is being promoted. This means that the only uses are loads // Okay, this is being promoted. This means that the only uses are loads
// or GEPs which are only used by loads // or GEPs which are only used by loads
Show All 40 Lines if (ByValArgsToTransform.count(&*I)) {
if (ArgIndices.size() == 1 && ArgIndices.begin()->second.empty()) if (ArgIndices.size() == 1 && ArgIndices.begin()->second.empty())
++NumArgumentsPromoted; ++NumArgumentsPromoted;
else else
++NumAggregatesPromoted; ++NumAggregatesPromoted;
} }
} }
// Add any function attributes. // Add any function attributes.
if (PAL.hasAttributes(AttributeSet::FunctionIndex)) if (PAL.hasAttributes(AttributeList::FunctionIndex))
AttributesVec.push_back( AttributesVec.push_back(
AttributeSet::get(FTy->getContext(), PAL.getFnAttributes())); AttributeList::get(FTy->getContext(), PAL.getFnAttributes()));
Type *RetTy = FTy->getReturnType(); Type *RetTy = FTy->getReturnType();
// Construct the new function type using the new arguments. // Construct the new function type using the new arguments.
FunctionType *NFTy = FunctionType::get(RetTy, Params, FTy->isVarArg()); FunctionType *NFTy = FunctionType::get(RetTy, Params, FTy->isVarArg());
// Create the new function body and insert it into the module. // Create the new function body and insert it into the module.
Function *NF = Function::Create(NFTy, F->getLinkage(), F->getName()); Function *NF = Function::Create(NFTy, F->getLinkage(), F->getName());
NF->copyAttributesFrom(F); NF->copyAttributesFrom(F);
// Patch the pointer to LLVM function in debug info descriptor. // Patch the pointer to LLVM function in debug info descriptor.
NF->setSubprogram(F->getSubprogram()); NF->setSubprogram(F->getSubprogram());
F->setSubprogram(nullptr); F->setSubprogram(nullptr);
DEBUG(dbgs() << "ARG PROMOTION: Promoting to:" << *NF << "\n" DEBUG(dbgs() << "ARG PROMOTION: Promoting to:" << *NF << "\n"
<< "From: " << *F); << "From: " << *F);
// Recompute the parameter attributes list based on the new arguments for // Recompute the parameter attributes list based on the new arguments for
// the function. // the function.
NF->setAttributes(AttributeSet::get(F->getContext(), AttributesVec)); NF->setAttributes(AttributeList::get(F->getContext(), AttributesVec));
AttributesVec.clear(); AttributesVec.clear();
F->getParent()->getFunctionList().insert(F->getIterator(), NF); F->getParent()->getFunctionList().insert(F->getIterator(), NF);
NF->takeName(F); NF->takeName(F);
// Loop over all of the callers of the function, transforming the call sites // Loop over all of the callers of the function, transforming the call sites
// to pass in the loaded pointers. // to pass in the loaded pointers.
// //
SmallVector<Value *, 16> Args; SmallVector<Value *, 16> Args;
while (!F->use_empty()) { while (!F->use_empty()) {
CallSite CS(F->user_back()); CallSite CS(F->user_back());
assert(CS.getCalledFunction() == F); assert(CS.getCalledFunction() == F);
Instruction *Call = CS.getInstruction(); Instruction *Call = CS.getInstruction();
const AttributeSet &CallPAL = CS.getAttributes(); const AttributeList &CallPAL = CS.getAttributes();
// Add any return attributes. // Add any return attributes.
if (CallPAL.hasAttributes(AttributeSet::ReturnIndex)) if (CallPAL.hasAttributes(AttributeList::ReturnIndex))
AttributesVec.push_back( AttributesVec.push_back(
AttributeSet::get(F->getContext(), CallPAL.getRetAttributes())); AttributeList::get(F->getContext(), CallPAL.getRetAttributes()));
// Loop over the operands, inserting GEP and loads in the caller as // Loop over the operands, inserting GEP and loads in the caller as
// appropriate. // appropriate.
CallSite::arg_iterator AI = CS.arg_begin(); CallSite::arg_iterator AI = CS.arg_begin();
ArgIndex = 1; ArgIndex = 1;
for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E;
++I, ++AI, ++ArgIndex) ++I, ++AI, ++ArgIndex)
if (!ArgsToPromote.count(&*I) && !ByValArgsToTransform.count(&*I)) { if (!ArgsToPromote.count(&*I) && !ByValArgsToTransform.count(&*I)) {
Args.push_back(*AI); // Unmodified argument Args.push_back(*AI); // Unmodified argument
if (CallPAL.hasAttributes(ArgIndex)) { if (CallPAL.hasAttributes(ArgIndex)) {
AttrBuilder B(CallPAL, ArgIndex); AttrBuilder B(CallPAL, ArgIndex);
AttributesVec.push_back( AttributesVec.push_back(
AttributeSet::get(F->getContext(), Args.size(), B)); AttributeList::get(F->getContext(), Args.size(), B));
} }
} else if (ByValArgsToTransform.count(&*I)) { } else if (ByValArgsToTransform.count(&*I)) {
// Emit a GEP and load for each element of the struct. // Emit a GEP and load for each element of the struct.
Type *AgTy = cast<PointerType>(I->getType())->getElementType(); Type *AgTy = cast<PointerType>(I->getType())->getElementType();
StructType *STy = cast<StructType>(AgTy); StructType *STy = cast<StructType>(AgTy);
Value *Idxs[2] = { Value *Idxs[2] = {
ConstantInt::get(Type::getInt32Ty(F->getContext()), 0), nullptr}; ConstantInt::get(Type::getInt32Ty(F->getContext()), 0), nullptr};
for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) { for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E;
} }
// Push any varargs arguments on the list. // Push any varargs arguments on the list.
for (; AI != CS.arg_end(); ++AI, ++ArgIndex) { for (; AI != CS.arg_end(); ++AI, ++ArgIndex) {
Args.push_back(*AI); Args.push_back(*AI);
if (CallPAL.hasAttributes(ArgIndex)) { if (CallPAL.hasAttributes(ArgIndex)) {
AttrBuilder B(CallPAL, ArgIndex); AttrBuilder B(CallPAL, ArgIndex);
AttributesVec.push_back( AttributesVec.push_back(
AttributeSet::get(F->getContext(), Args.size(), B)); AttributeList::get(F->getContext(), Args.size(), B));
} }
} }
// Add any function attributes. // Add any function attributes.
if (CallPAL.hasAttributes(AttributeSet::FunctionIndex)) if (CallPAL.hasAttributes(AttributeList::FunctionIndex))
AttributesVec.push_back( AttributesVec.push_back(
AttributeSet::get(Call->getContext(), CallPAL.getFnAttributes())); AttributeList::get(Call->getContext(), CallPAL.getFnAttributes()));
SmallVector<OperandBundleDef, 1> OpBundles; SmallVector<OperandBundleDef, 1> OpBundles;
CS.getOperandBundlesAsDefs(OpBundles); CS.getOperandBundlesAsDefs(OpBundles);
Instruction *New; Instruction *New;
if (InvokeInst *II = dyn_cast<InvokeInst>(Call)) { if (InvokeInst *II = dyn_cast<InvokeInst>(Call)) {
New = InvokeInst::Create(NF, II->getNormalDest(), II->getUnwindDest(), New = InvokeInst::Create(NF, II->getNormalDest(), II->getUnwindDest(),
Args, OpBundles, "", Call); Args, OpBundles, "", Call);
cast<InvokeInst>(New)->setCallingConv(CS.getCallingConv()); cast<InvokeInst>(New)->setCallingConv(CS.getCallingConv());
cast<InvokeInst>(New)->setAttributes( cast<InvokeInst>(New)->setAttributes(
AttributeSet::get(II->getContext(), AttributesVec)); AttributeList::get(II->getContext(), AttributesVec));
} else { } else {
New = CallInst::Create(NF, Args, OpBundles, "", Call); New = CallInst::Create(NF, Args, OpBundles, "", Call);
cast<CallInst>(New)->setCallingConv(CS.getCallingConv()); cast<CallInst>(New)->setCallingConv(CS.getCallingConv());
cast<CallInst>(New)->setAttributes( cast<CallInst>(New)->setAttributes(
AttributeSet::get(New->getContext(), AttributesVec)); AttributeList::get(New->getContext(), AttributesVec));
cast<CallInst>(New)->setTailCallKind( cast<CallInst>(New)->setTailCallKind(
cast<CallInst>(Call)->getTailCallKind()); cast<CallInst>(Call)->getTailCallKind());
} }
New->setDebugLoc(Call->getDebugLoc()); New->setDebugLoc(Call->getDebugLoc());
Args.clear(); Args.clear();
AttributesVec.clear(); AttributesVec.clear();
// Update the callgraph to know that the callsite has been transformed. // Update the callgraph to know that the callsite has been transformed.
▲ Show 20 Lines • Show All 747 Lines • Show Last 20 Lines

llvm/trunk/lib/Transforms/IPO/DeadArgumentElimination.cpp

Show First 20 Lines • Show All 160 Lines • ▼ Show 20 Lines for (Value::user_iterator I = Fn.user_begin(), E = Fn.user_end(); I != E; ) {
if (!CS) if (!CS)
continue; continue;
Instruction *Call = CS.getInstruction(); Instruction *Call = CS.getInstruction();
// Pass all the same arguments. // Pass all the same arguments.
Args.assign(CS.arg_begin(), CS.arg_begin() + NumArgs); Args.assign(CS.arg_begin(), CS.arg_begin() + NumArgs);
// Drop any attributes that were on the vararg arguments. // Drop any attributes that were on the vararg arguments.
AttributeSet PAL = CS.getAttributes(); AttributeList PAL = CS.getAttributes();
if (!PAL.isEmpty() && PAL.getSlotIndex(PAL.getNumSlots() - 1) > NumArgs) { if (!PAL.isEmpty() && PAL.getSlotIndex(PAL.getNumSlots() - 1) > NumArgs) {
SmallVector<AttributeSet, 8> AttributesVec; SmallVector<AttributeList, 8> AttributesVec;
for (unsigned i = 0; PAL.getSlotIndex(i) <= NumArgs; ++i) for (unsigned i = 0; PAL.getSlotIndex(i) <= NumArgs; ++i)
AttributesVec.push_back(PAL.getSlotAttributes(i)); AttributesVec.push_back(PAL.getSlotAttributes(i));
if (PAL.hasAttributes(AttributeSet::FunctionIndex)) if (PAL.hasAttributes(AttributeList::FunctionIndex))
AttributesVec.push_back(AttributeSet::get(Fn.getContext(), AttributesVec.push_back(
PAL.getFnAttributes())); AttributeList::get(Fn.getContext(), PAL.getFnAttributes()));
PAL = AttributeSet::get(Fn.getContext(), AttributesVec); PAL = AttributeList::get(Fn.getContext(), AttributesVec);
} }
SmallVector<OperandBundleDef, 1> OpBundles; SmallVector<OperandBundleDef, 1> OpBundles;
CS.getOperandBundlesAsDefs(OpBundles); CS.getOperandBundlesAsDefs(OpBundles);
Instruction *New; Instruction *New;
if (InvokeInst *II = dyn_cast<InvokeInst>(Call)) { if (InvokeInst *II = dyn_cast<InvokeInst>(Call)) {
New = InvokeInst::Create(NF, II->getNormalDest(), II->getUnwindDest(), New = InvokeInst::Create(NF, II->getNormalDest(), II->getUnwindDest(),
▲ Show 20 Lines • Show All 490 Lines • ▼ Show 20 Linesbool DeadArgumentEliminationPass::RemoveDeadStuffFromFunction(Function *F) {
// the old function, but has fewer arguments and a different return type. // the old function, but has fewer arguments and a different return type.
FunctionType *FTy = F->getFunctionType(); FunctionType *FTy = F->getFunctionType();
std::vector<Type*> Params; std::vector<Type*> Params;
// Keep track of if we have a live 'returned' argument // Keep track of if we have a live 'returned' argument
bool HasLiveReturnedArg = false; bool HasLiveReturnedArg = false;
// Set up to build a new list of parameter attributes. // Set up to build a new list of parameter attributes.
SmallVector<AttributeSet, 8> AttributesVec; SmallVector<AttributeList, 8> AttributesVec;
const AttributeSet &PAL = F->getAttributes(); const AttributeList &PAL = F->getAttributes();
// Remember which arguments are still alive. // Remember which arguments are still alive.
SmallVector<bool, 10> ArgAlive(FTy->getNumParams(), false); SmallVector<bool, 10> ArgAlive(FTy->getNumParams(), false);
// Construct the new parameter list from non-dead arguments. Also construct // Construct the new parameter list from non-dead arguments. Also construct
// a new set of parameter attributes to correspond. Skip the first parameter // a new set of parameter attributes to correspond. Skip the first parameter
// attribute, since that belongs to the return value. // attribute, since that belongs to the return value.
unsigned i = 0; unsigned i = 0;
for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end();
I != E; ++I, ++i) { I != E; ++I, ++i) {
RetOrArg Arg = CreateArg(F, i); RetOrArg Arg = CreateArg(F, i);
if (LiveValues.erase(Arg)) { if (LiveValues.erase(Arg)) {
Params.push_back(I->getType()); Params.push_back(I->getType());
ArgAlive[i] = true; ArgAlive[i] = true;
// Get the original parameter attributes (skipping the first one, that is // Get the original parameter attributes (skipping the first one, that is
// for the return value. // for the return value.
if (PAL.hasAttributes(i + 1)) { if (PAL.hasAttributes(i + 1)) {
AttrBuilder B(PAL, i + 1); AttrBuilder B(PAL, i + 1);
if (B.contains(Attribute::Returned)) if (B.contains(Attribute::Returned))
HasLiveReturnedArg = true; HasLiveReturnedArg = true;
AttributesVec. AttributesVec.push_back(
push_back(AttributeSet::get(F->getContext(), Params.size(), B)); AttributeList::get(F->getContext(), Params.size(), B));
} }
} else { } else {
++NumArgumentsEliminated; ++NumArgumentsEliminated;
DEBUG(dbgs() << "DeadArgumentEliminationPass - Removing argument " << i DEBUG(dbgs() << "DeadArgumentEliminationPass - Removing argument " << i
<< " (" << I->getName() << ") from " << F->getName() << " (" << I->getName() << ") from " << F->getName()
<< "\n"); << "\n");
} }
} }
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines if (RetTy->isVoidTy() || HasLiveReturnedArg) {
else if (RetTypes.size() == 0) else if (RetTypes.size() == 0)
// No return types? Make it void, but only if we didn't use to return {}. // No return types? Make it void, but only if we didn't use to return {}.
NRetTy = Type::getVoidTy(F->getContext()); NRetTy = Type::getVoidTy(F->getContext());
} }
assert(NRetTy && "No new return type found?"); assert(NRetTy && "No new return type found?");
// The existing function return attributes. // The existing function return attributes.
AttributeSet RAttrs = PAL.getRetAttributes(); AttributeList RAttrs = PAL.getRetAttributes();
// Remove any incompatible attributes, but only if we removed all return // Remove any incompatible attributes, but only if we removed all return
// values. Otherwise, ensure that we don't have any conflicting attributes // values. Otherwise, ensure that we don't have any conflicting attributes
// here. Currently, this should not be possible, but special handling might be // here. Currently, this should not be possible, but special handling might be
// required when new return value attributes are added. // required when new return value attributes are added.
if (NRetTy->isVoidTy()) if (NRetTy->isVoidTy())
RAttrs = RAttrs.removeAttributes(NRetTy->getContext(), RAttrs = RAttrs.removeAttributes(NRetTy->getContext(),
AttributeSet::ReturnIndex, AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NRetTy)); AttributeFuncs::typeIncompatible(NRetTy));
else else
assert(!AttrBuilder(RAttrs, AttributeSet::ReturnIndex). assert(!AttrBuilder(RAttrs, AttributeList::ReturnIndex)
overlaps(AttributeFuncs::typeIncompatible(NRetTy)) && .overlaps(AttributeFuncs::typeIncompatible(NRetTy)) &&
"Return attributes no longer compatible?"); "Return attributes no longer compatible?");
if (RAttrs.hasAttributes(AttributeSet::ReturnIndex)) if (RAttrs.hasAttributes(AttributeList::ReturnIndex))
AttributesVec.push_back(AttributeSet::get(NRetTy->getContext(), RAttrs)); AttributesVec.push_back(AttributeList::get(NRetTy->getContext(), RAttrs));
if (PAL.hasAttributes(AttributeSet::FunctionIndex)) if (PAL.hasAttributes(AttributeList::FunctionIndex))
AttributesVec.push_back(AttributeSet::get(F->getContext(), AttributesVec.push_back(
PAL.getFnAttributes())); AttributeList::get(F->getContext(), PAL.getFnAttributes()));
// Reconstruct the AttributesList based on the vector we constructed. // Reconstruct the AttributesList based on the vector we constructed.
AttributeSet NewPAL = AttributeSet::get(F->getContext(), AttributesVec); AttributeList NewPAL = AttributeList::get(F->getContext(), AttributesVec);
// Create the new function type based on the recomputed parameters. // Create the new function type based on the recomputed parameters.
FunctionType *NFTy = FunctionType::get(NRetTy, Params, FTy->isVarArg()); FunctionType *NFTy = FunctionType::get(NRetTy, Params, FTy->isVarArg());
// No change? // No change?
if (NFTy == FTy) if (NFTy == FTy)
return false; return false;
Show All 11 Linesbool DeadArgumentEliminationPass::RemoveDeadStuffFromFunction(Function *F) {
// to pass in a smaller number of arguments into the new function. // to pass in a smaller number of arguments into the new function.
// //
std::vector<Value*> Args; std::vector<Value*> Args;
while (!F->use_empty()) { while (!F->use_empty()) {
CallSite CS(F->user_back()); CallSite CS(F->user_back());
Instruction *Call = CS.getInstruction(); Instruction *Call = CS.getInstruction();
AttributesVec.clear(); AttributesVec.clear();
const AttributeSet &CallPAL = CS.getAttributes(); const AttributeList &CallPAL = CS.getAttributes();
// The call return attributes. // The call return attributes.
AttributeSet RAttrs = CallPAL.getRetAttributes(); AttributeList RAttrs = CallPAL.getRetAttributes();
// Adjust in case the function was changed to return void. // Adjust in case the function was changed to return void.
RAttrs = RAttrs.removeAttributes(NRetTy->getContext(), RAttrs = RAttrs.removeAttributes(
AttributeSet::ReturnIndex, NRetTy->getContext(), AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NF->getReturnType())); AttributeFuncs::typeIncompatible(NF->getReturnType()));
if (RAttrs.hasAttributes(AttributeSet::ReturnIndex)) if (RAttrs.hasAttributes(AttributeList::ReturnIndex))
AttributesVec.push_back(AttributeSet::get(NF->getContext(), RAttrs)); AttributesVec.push_back(AttributeList::get(NF->getContext(), RAttrs));
// Declare these outside of the loops, so we can reuse them for the second // Declare these outside of the loops, so we can reuse them for the second
// loop, which loops the varargs. // loop, which loops the varargs.
CallSite::arg_iterator I = CS.arg_begin(); CallSite::arg_iterator I = CS.arg_begin();
unsigned i = 0; unsigned i = 0;
// Loop over those operands, corresponding to the normal arguments to the // Loop over those operands, corresponding to the normal arguments to the
// original function, and add those that are still alive. // original function, and add those that are still alive.
for (unsigned e = FTy->getNumParams(); i != e; ++I, ++i) for (unsigned e = FTy->getNumParams(); i != e; ++I, ++i)
if (ArgAlive[i]) { if (ArgAlive[i]) {
Args.push_back(*I); Args.push_back(*I);
// Get original parameter attributes, but skip return attributes. // Get original parameter attributes, but skip return attributes.
if (CallPAL.hasAttributes(i + 1)) { if (CallPAL.hasAttributes(i + 1)) {
AttrBuilder B(CallPAL, i + 1); AttrBuilder B(CallPAL, i + 1);
// If the return type has changed, then get rid of 'returned' on the // If the return type has changed, then get rid of 'returned' on the
// call site. The alternative is to make all 'returned' attributes on // call site. The alternative is to make all 'returned' attributes on
// call sites keep the return value alive just like 'returned' // call sites keep the return value alive just like 'returned'
// attributes on function declaration but it's less clearly a win // attributes on function declaration but it's less clearly a win
// and this is not an expected case anyway // and this is not an expected case anyway
if (NRetTy != RetTy && B.contains(Attribute::Returned)) if (NRetTy != RetTy && B.contains(Attribute::Returned))
B.removeAttribute(Attribute::Returned); B.removeAttribute(Attribute::Returned);
AttributesVec. AttributesVec.push_back(
push_back(AttributeSet::get(F->getContext(), Args.size(), B)); AttributeList::get(F->getContext(), Args.size(), B));
} }
} }
// Push any varargs arguments on the list. Don't forget their attributes. // Push any varargs arguments on the list. Don't forget their attributes.
for (CallSite::arg_iterator E = CS.arg_end(); I != E; ++I, ++i) { for (CallSite::arg_iterator E = CS.arg_end(); I != E; ++I, ++i) {
Args.push_back(*I); Args.push_back(*I);
if (CallPAL.hasAttributes(i + 1)) { if (CallPAL.hasAttributes(i + 1)) {
AttrBuilder B(CallPAL, i + 1); AttrBuilder B(CallPAL, i + 1);
AttributesVec. AttributesVec.push_back(
push_back(AttributeSet::get(F->getContext(), Args.size(), B)); AttributeList::get(F->getContext(), Args.size(), B));
} }
} }
if (CallPAL.hasAttributes(AttributeSet::FunctionIndex)) if (CallPAL.hasAttributes(AttributeList::FunctionIndex))
AttributesVec.push_back(AttributeSet::get(Call->getContext(), AttributesVec.push_back(
CallPAL.getFnAttributes())); AttributeList::get(Call->getContext(), CallPAL.getFnAttributes()));
// Reconstruct the AttributesList based on the vector we constructed. // Reconstruct the AttributesList based on the vector we constructed.
AttributeSet NewCallPAL = AttributeSet::get(F->getContext(), AttributesVec); AttributeList NewCallPAL =
AttributeList::get(F->getContext(), AttributesVec);
SmallVector<OperandBundleDef, 1> OpBundles; SmallVector<OperandBundleDef, 1> OpBundles;
CS.getOperandBundlesAsDefs(OpBundles); CS.getOperandBundlesAsDefs(OpBundles);
Instruction *New; Instruction *New;
if (InvokeInst *II = dyn_cast<InvokeInst>(Call)) { if (InvokeInst *II = dyn_cast<InvokeInst>(Call)) {
New = InvokeInst::Create(NF, II->getNormalDest(), II->getUnwindDest(), New = InvokeInst::Create(NF, II->getNormalDest(), II->getUnwindDest(),
Args, OpBundles, "", Call->getParent()); Args, OpBundles, "", Call->getParent());
▲ Show 20 Lines • Show All 180 Lines • Show Last 20 Lines

llvm/trunk/lib/Transforms/IPO/FunctionAttrs.cpp

Show First 20 Lines • Show All 219 Lines • ▼ Show 20 Lines if (F->onlyReadsMemory() && ReadsMemory)
continue; continue;
MadeChange = true; MadeChange = true;
// Clear out any existing attributes. // Clear out any existing attributes.
AttrBuilder B; AttrBuilder B;
B.addAttribute(Attribute::ReadOnly).addAttribute(Attribute::ReadNone); B.addAttribute(Attribute::ReadOnly).addAttribute(Attribute::ReadNone);
F->removeAttributes( F->removeAttributes(
AttributeSet::FunctionIndex, AttributeList::FunctionIndex,
AttributeSet::get(F->getContext(), AttributeSet::FunctionIndex, B)); AttributeList::get(F->getContext(), AttributeList::FunctionIndex, B));
// Add in the new attribute. // Add in the new attribute.
F->addAttribute(AttributeSet::FunctionIndex, F->addAttribute(AttributeList::FunctionIndex,
ReadsMemory ? Attribute::ReadOnly : Attribute::ReadNone); ReadsMemory ? Attribute::ReadOnly : Attribute::ReadNone);
if (ReadsMemory) if (ReadsMemory)
++NumReadOnly; ++NumReadOnly;
else else
++NumReadNone; ++NumReadNone;
} }
▲ Show 20 Lines • Show All 289 Lines • ▼ Show 20 Lines auto FindRetArg = [&]() -> Value * {
return nullptr; return nullptr;
} }
return RetArg; return RetArg;
}; };
if (Value *RetArg = FindRetArg()) { if (Value *RetArg = FindRetArg()) {
auto *A = cast<Argument>(RetArg); auto *A = cast<Argument>(RetArg);
A->addAttr(AttributeSet::get(F->getContext(), A->getArgNo() + 1, B)); A->addAttr(AttributeList::get(F->getContext(), A->getArgNo() + 1, B));
++NumReturned; ++NumReturned;
Changed = true; Changed = true;
} }
} }
return Changed; return Changed;
} }
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines for (Function *F : SCCNodes) {
// Functions that are readonly (or readnone) and nounwind and don't return // Functions that are readonly (or readnone) and nounwind and don't return
// a value can't capture arguments. Don't analyze them. // a value can't capture arguments. Don't analyze them.
if (F->onlyReadsMemory() && F->doesNotThrow() && if (F->onlyReadsMemory() && F->doesNotThrow() &&
F->getReturnType()->isVoidTy()) { F->getReturnType()->isVoidTy()) {
for (Function::arg_iterator A = F->arg_begin(), E = F->arg_end(); A != E; for (Function::arg_iterator A = F->arg_begin(), E = F->arg_end(); A != E;
++A) { ++A) {
if (A->getType()->isPointerTy() && !A->hasNoCaptureAttr()) { if (A->getType()->isPointerTy() && !A->hasNoCaptureAttr()) {
A->addAttr(AttributeSet::get(F->getContext(), A->getArgNo() + 1, B)); A->addAttr(AttributeList::get(F->getContext(), A->getArgNo() + 1, B));
++NumNoCapture; ++NumNoCapture;
Changed = true; Changed = true;
} }
} }
continue; continue;
} }
for (Function::arg_iterator A = F->arg_begin(), E = F->arg_end(); A != E; for (Function::arg_iterator A = F->arg_begin(), E = F->arg_end(); A != E;
++A) { ++A) {
if (!A->getType()->isPointerTy()) if (!A->getType()->isPointerTy())
continue; continue;
bool HasNonLocalUses = false; bool HasNonLocalUses = false;
if (!A->hasNoCaptureAttr()) { if (!A->hasNoCaptureAttr()) {
ArgumentUsesTracker Tracker(SCCNodes); ArgumentUsesTracker Tracker(SCCNodes);
PointerMayBeCaptured(&*A, &Tracker); PointerMayBeCaptured(&*A, &Tracker);
if (!Tracker.Captured) { if (!Tracker.Captured) {
if (Tracker.Uses.empty()) { if (Tracker.Uses.empty()) {
// If it's trivially not captured, mark it nocapture now. // If it's trivially not captured, mark it nocapture now.
A->addAttr( A->addAttr(
AttributeSet::get(F->getContext(), A->getArgNo() + 1, B)); AttributeList::get(F->getContext(), A->getArgNo() + 1, B));
++NumNoCapture; ++NumNoCapture;
Changed = true; Changed = true;
} else { } else {
// If it's not trivially captured and not trivially not captured, // If it's not trivially captured and not trivially not captured,
// then it must be calling into another function in our SCC. Save // then it must be calling into another function in our SCC. Save
// its particulars for Argument-SCC analysis later. // its particulars for Argument-SCC analysis later.
ArgumentGraphNode *Node = AG[&*A]; ArgumentGraphNode *Node = AG[&*A];
for (Argument *Use : Tracker.Uses) { for (Argument *Use : Tracker.Uses) {
Show All 11 Lines for (Function::arg_iterator A = F->arg_begin(), E = F->arg_end(); A != E;
// will be dependent on the iteration order through the functions in the // will be dependent on the iteration order through the functions in the
// SCC. // SCC.
SmallPtrSet<Argument *, 8> Self; SmallPtrSet<Argument *, 8> Self;
Self.insert(&*A); Self.insert(&*A);
Attribute::AttrKind R = determinePointerReadAttrs(&*A, Self); Attribute::AttrKind R = determinePointerReadAttrs(&*A, Self);
if (R != Attribute::None) { if (R != Attribute::None) {
AttrBuilder B; AttrBuilder B;
B.addAttribute(R); B.addAttribute(R);
A->addAttr(AttributeSet::get(A->getContext(), A->getArgNo() + 1, B)); A->addAttr(AttributeList::get(A->getContext(), A->getArgNo() + 1, B));
Changed = true; Changed = true;
R == Attribute::ReadOnly ? ++NumReadOnlyArg : ++NumReadNoneArg; R == Attribute::ReadOnly ? ++NumReadOnlyArg : ++NumReadNoneArg;
} }
} }
} }
} }
// The graph we've collected is partial because we stopped scanning for // The graph we've collected is partial because we stopped scanning for
// argument uses once we solved the argument trivially. These partial nodes // argument uses once we solved the argument trivially. These partial nodes
// show up as ArgumentGraphNode objects with an empty Uses list, and for // show up as ArgumentGraphNode objects with an empty Uses list, and for
// these nodes the final decision about whether they capture has already been // these nodes the final decision about whether they capture has already been
// made. If the definition doesn't have a 'nocapture' attribute by now, it // made. If the definition doesn't have a 'nocapture' attribute by now, it
// captures. // captures.
for (scc_iterator<ArgumentGraph *> I = scc_begin(&AG); !I.isAtEnd(); ++I) { for (scc_iterator<ArgumentGraph *> I = scc_begin(&AG); !I.isAtEnd(); ++I) {
const std::vector<ArgumentGraphNode *> &ArgumentSCC = *I; const std::vector<ArgumentGraphNode *> &ArgumentSCC = *I;
if (ArgumentSCC.size() == 1) { if (ArgumentSCC.size() == 1) {
if (!ArgumentSCC[0]->Definition) if (!ArgumentSCC[0]->Definition)
continue; // synthetic root node continue; // synthetic root node
// eg. "void f(int* x) { if (...) f(x); }" // eg. "void f(int* x) { if (...) f(x); }"
if (ArgumentSCC[0]->Uses.size() == 1 && if (ArgumentSCC[0]->Uses.size() == 1 &&
ArgumentSCC[0]->Uses[0] == ArgumentSCC[0]) { ArgumentSCC[0]->Uses[0] == ArgumentSCC[0]) {
Argument *A = ArgumentSCC[0]->Definition; Argument *A = ArgumentSCC[0]->Definition;
A->addAttr(AttributeSet::get(A->getContext(), A->getArgNo() + 1, B)); A->addAttr(AttributeList::get(A->getContext(), A->getArgNo() + 1, B));
++NumNoCapture; ++NumNoCapture;
Changed = true; Changed = true;
} }
continue; continue;
} }
bool SCCCaptured = false; bool SCCCaptured = false;
for (auto I = ArgumentSCC.begin(), E = ArgumentSCC.end(); for (auto I = ArgumentSCC.begin(), E = ArgumentSCC.end();
Show All 25 Lines for (auto I = ArgumentSCC.begin(), E = ArgumentSCC.end();
break; break;
} }
} }
if (SCCCaptured) if (SCCCaptured)
continue; continue;
for (unsigned i = 0, e = ArgumentSCC.size(); i != e; ++i) { for (unsigned i = 0, e = ArgumentSCC.size(); i != e; ++i) {
Argument *A = ArgumentSCC[i]->Definition; Argument *A = ArgumentSCC[i]->Definition;
A->addAttr(AttributeSet::get(A->getContext(), A->getArgNo() + 1, B)); A->addAttr(AttributeList::get(A->getContext(), A->getArgNo() + 1, B));
++NumNoCapture; ++NumNoCapture;
Changed = true; Changed = true;
} }
// We also want to compute readonly/readnone. With a small number of false // We also want to compute readonly/readnone. With a small number of false
// negatives, we can assume that any pointer which is captured isn't going // negatives, we can assume that any pointer which is captured isn't going
// to be provably readonly or readnone, since by definition we can't // to be provably readonly or readnone, since by definition we can't
// analyze all uses of a captured pointer. // analyze all uses of a captured pointer.
Show All 20 Lines for (scc_iterator<ArgumentGraph *> I = scc_begin(&AG); !I.isAtEnd(); ++I) {
if (ReadAttr != Attribute::None) { if (ReadAttr != Attribute::None) {
AttrBuilder B, R; AttrBuilder B, R;
B.addAttribute(ReadAttr); B.addAttribute(ReadAttr);
R.addAttribute(Attribute::ReadOnly).addAttribute(Attribute::ReadNone); R.addAttribute(Attribute::ReadOnly).addAttribute(Attribute::ReadNone);
for (unsigned i = 0, e = ArgumentSCC.size(); i != e; ++i) { for (unsigned i = 0, e = ArgumentSCC.size(); i != e; ++i) {
Argument *A = ArgumentSCC[i]->Definition; Argument *A = ArgumentSCC[i]->Definition;
// Clear out existing readonly/readnone attributes // Clear out existing readonly/readnone attributes
A->removeAttr(AttributeSet::get(A->getContext(), A->getArgNo() + 1, R)); A->removeAttr(
A->addAttr(AttributeSet::get(A->getContext(), A->getArgNo() + 1, B)); AttributeList::get(A->getContext(), A->getArgNo() + 1, R));
A->addAttr(AttributeList::get(A->getContext(), A->getArgNo() + 1, B));
ReadAttr == Attribute::ReadOnly ? ++NumReadOnlyArg : ++NumReadNoneArg; ReadAttr == Attribute::ReadOnly ? ++NumReadOnlyArg : ++NumReadNoneArg;
Changed = true; Changed = true;
} }
} }
} }
return Changed; return Changed;
} }
▲ Show 20 Lines • Show All 179 Lines • ▼ Show 20 Linesstatic bool addNonNullAttrs(const SCCNodeSet &SCCNodes) {
bool SCCReturnsNonNull = true; bool SCCReturnsNonNull = true;
bool MadeChange = false; bool MadeChange = false;
// Check each function in turn, determining which functions return nonnull // Check each function in turn, determining which functions return nonnull
// pointers. // pointers.
for (Function *F : SCCNodes) { for (Function *F : SCCNodes) {
// Already nonnull. // Already nonnull.
if (F->getAttributes().hasAttribute(AttributeSet::ReturnIndex, if (F->getAttributes().hasAttribute(AttributeList::ReturnIndex,
Attribute::NonNull)) Attribute::NonNull))
continue; continue;
// We can infer and propagate function attributes only when we know that the // We can infer and propagate function attributes only when we know that the
// definition we'll get at link time is *exactly* the definition we see now. // definition we'll get at link time is *exactly* the definition we see now.
// For more details, see GlobalValue::mayBeDerefined. // For more details, see GlobalValue::mayBeDerefined.
if (!F->hasExactDefinition()) if (!F->hasExactDefinition())
return false; return false;
// We annotate nonnull return values, which are only applicable to // We annotate nonnull return values, which are only applicable to
// pointer types. // pointer types.
if (!F->getReturnType()->isPointerTy()) if (!F->getReturnType()->isPointerTy())
continue; continue;
bool Speculative = false; bool Speculative = false;
if (isReturnNonNull(F, SCCNodes, Speculative)) { if (isReturnNonNull(F, SCCNodes, Speculative)) {
if (!Speculative) { if (!Speculative) {
// Mark the function eagerly since we may discover a function // Mark the function eagerly since we may discover a function
// which prevents us from speculating about the entire SCC // which prevents us from speculating about the entire SCC
DEBUG(dbgs() << "Eagerly marking " << F->getName() << " as nonnull\n"); DEBUG(dbgs() << "Eagerly marking " << F->getName() << " as nonnull\n");
F->addAttribute(AttributeSet::ReturnIndex, Attribute::NonNull); F->addAttribute(AttributeList::ReturnIndex, Attribute::NonNull);
++NumNonNullReturn; ++NumNonNullReturn;
MadeChange = true; MadeChange = true;
} }
continue; continue;
} }
// At least one function returns something which could be null, can't // At least one function returns something which could be null, can't
// speculate any more. // speculate any more.
SCCReturnsNonNull = false; SCCReturnsNonNull = false;
} }
if (SCCReturnsNonNull) { if (SCCReturnsNonNull) {
for (Function *F : SCCNodes) { for (Function *F : SCCNodes) {
if (F->getAttributes().hasAttribute(AttributeSet::ReturnIndex, if (F->getAttributes().hasAttribute(AttributeList::ReturnIndex,
Attribute::NonNull) || Attribute::NonNull) ||
!F->getReturnType()->isPointerTy()) !F->getReturnType()->isPointerTy())
continue; continue;
DEBUG(dbgs() << "SCC marking " << F->getName() << " as nonnull\n"); DEBUG(dbgs() << "SCC marking " << F->getName() << " as nonnull\n");
F->addAttribute(AttributeSet::ReturnIndex, Attribute::NonNull); F->addAttribute(AttributeList::ReturnIndex, Attribute::NonNull);
++NumNonNullReturn; ++NumNonNullReturn;
MadeChange = true; MadeChange = true;
} }
} }
return MadeChange; return MadeChange;
} }
▲ Show 20 Lines • Show All 316 Lines • Show Last 20 Lines

llvm/trunk/lib/Transforms/IPO/GlobalOpt.cpp

Show First 20 Lines • Show All 1,971 Lines • ▼ Show 20 Linesstatic void ChangeCalleesToFastCall(Function *F) {
for (User *U : F->users()) { for (User *U : F->users()) {
if (isa<BlockAddress>(U)) if (isa<BlockAddress>(U))
continue; continue;
CallSite CS(cast<Instruction>(U)); CallSite CS(cast<Instruction>(U));
CS.setCallingConv(CallingConv::Fast); CS.setCallingConv(CallingConv::Fast);
} }
} }
static AttributeSet StripNest(LLVMContext &C, const AttributeSet &Attrs) { static AttributeList StripNest(LLVMContext &C, const AttributeList &Attrs) {
for (unsigned i = 0, e = Attrs.getNumSlots(); i != e; ++i) { for (unsigned i = 0, e = Attrs.getNumSlots(); i != e; ++i) {
unsigned Index = Attrs.getSlotIndex(i); unsigned Index = Attrs.getSlotIndex(i);
if (!Attrs.getSlotAttributes(i).hasAttribute(Index, Attribute::Nest)) if (!Attrs.getSlotAttributes(i).hasAttribute(Index, Attribute::Nest))
continue; continue;
// There can be only one. // There can be only one.
return Attrs.removeAttribute(C, Index, Attribute::Nest); return Attrs.removeAttribute(C, Index, Attribute::Nest);
} }
▲ Show 20 Lines • Show All 613 Lines • Show Last 20 Lines

llvm/trunk/lib/Transforms/IPO/MergeFunctions.cpp

Show First 20 Lines • Show All 430 Lines • ▼ Show 20 Lines if (CS && CS.isCallee(U)) {
// always have matching ABI, so no attributes need to be changed. // always have matching ABI, so no attributes need to be changed.
// Transferring other attributes may help other optimizations, but that // Transferring other attributes may help other optimizations, but that
// should be done uniformly and not in this ad-hoc way. // should be done uniformly and not in this ad-hoc way.
auto &Context = New->getContext(); auto &Context = New->getContext();
auto NewFuncAttrs = New->getAttributes(); auto NewFuncAttrs = New->getAttributes();
auto CallSiteAttrs = CS.getAttributes(); auto CallSiteAttrs = CS.getAttributes();
CallSiteAttrs = CallSiteAttrs.addAttributes( CallSiteAttrs = CallSiteAttrs.addAttributes(
Context, AttributeSet::ReturnIndex, NewFuncAttrs.getRetAttributes()); Context, AttributeList::ReturnIndex, NewFuncAttrs.getRetAttributes());
for (unsigned argIdx = 0; argIdx < CS.arg_size(); argIdx++) { for (unsigned argIdx = 0; argIdx < CS.arg_size(); argIdx++) {
AttributeSet Attrs = NewFuncAttrs.getParamAttributes(argIdx); AttributeList Attrs = NewFuncAttrs.getParamAttributes(argIdx);
if (Attrs.getNumSlots()) if (Attrs.getNumSlots())
CallSiteAttrs = CallSiteAttrs.addAttributes(Context, argIdx, Attrs); CallSiteAttrs = CallSiteAttrs.addAttributes(Context, argIdx, Attrs);
} }
CS.setAttributes(CallSiteAttrs); CS.setAttributes(CallSiteAttrs);
remove(CS.getInstruction()->getParent()->getParent()); remove(CS.getInstruction()->getParent()->getParent());
U->set(BitcastNew); U->set(BitcastNew);
▲ Show 20 Lines • Show All 440 Lines • Show Last 20 Lines

llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp

Show First 20 Lines • Show All 3,586 Lines • ▼ Show 20 Lines if (auto *PT = dyn_cast<PointerType>(II->getType())) {
// TODO: provide a hook for this in GCStrategy. There might be some // TODO: provide a hook for this in GCStrategy. There might be some
// weird collector this property does not hold for. // weird collector this property does not hold for.
if (isa<ConstantPointerNull>(DerivedPtr)) if (isa<ConstantPointerNull>(DerivedPtr))
// Use null-pointer of gc_relocate's type to replace it. // Use null-pointer of gc_relocate's type to replace it.
return replaceInstUsesWith(*II, ConstantPointerNull::get(PT)); return replaceInstUsesWith(*II, ConstantPointerNull::get(PT));
// isKnownNonNull -> nonnull attribute // isKnownNonNull -> nonnull attribute
if (isKnownNonNullAt(DerivedPtr, II, &DT)) if (isKnownNonNullAt(DerivedPtr, II, &DT))
II->addAttribute(AttributeSet::ReturnIndex, Attribute::NonNull); II->addAttribute(AttributeList::ReturnIndex, Attribute::NonNull);
} }
// TODO: bitcast(relocate(p)) -> relocate(bitcast(p)) // TODO: bitcast(relocate(p)) -> relocate(bitcast(p))
// Canonicalize on the type from the uses to the defs // Canonicalize on the type from the uses to the defs
// TODO: relocate((gep p, C, C2, ...)) -> gep(relocate(p), C, C2, ...) // TODO: relocate((gep p, C, C2, ...)) -> gep(relocate(p), C, C2, ...)
break; break;
} }
▲ Show 20 Lines • Show All 179 Lines • ▼ Show 20 Lines if (V->getType()->isPointerTy() &&
isKnownNonNullAt(V, CS.getInstruction(), &DT)) isKnownNonNullAt(V, CS.getInstruction(), &DT))
Indices.push_back(ArgNo + 1); Indices.push_back(ArgNo + 1);
ArgNo++; ArgNo++;
} }
assert(ArgNo == CS.arg_size() && "sanity check"); assert(ArgNo == CS.arg_size() && "sanity check");
if (!Indices.empty()) { if (!Indices.empty()) {
AttributeSet AS = CS.getAttributes(); AttributeList AS = CS.getAttributes();
LLVMContext &Ctx = CS.getInstruction()->getContext(); LLVMContext &Ctx = CS.getInstruction()->getContext();
AS = AS.addAttribute(Ctx, Indices, AS = AS.addAttribute(Ctx, Indices,
Attribute::get(Ctx, Attribute::NonNull)); Attribute::get(Ctx, Attribute::NonNull));
CS.setAttributes(AS); CS.setAttributes(AS);
Changed = true; Changed = true;
} }
// If the callee is a pointer to a function, attempt to move any casts to the // If the callee is a pointer to a function, attempt to move any casts to the
▲ Show 20 Lines • Show All 105 Lines • ▼ Show 20 Linesbool InstCombiner::transformConstExprCastCall(CallSite CS) {
if (!Callee) if (!Callee)
return false; return false;
// The prototype of a thunk is a lie. Don't directly call such a function. // The prototype of a thunk is a lie. Don't directly call such a function.
if (Callee->hasFnAttribute("thunk")) if (Callee->hasFnAttribute("thunk"))
return false; return false;
Instruction *Caller = CS.getInstruction(); Instruction *Caller = CS.getInstruction();
const AttributeSet &CallerPAL = CS.getAttributes(); const AttributeList &CallerPAL = CS.getAttributes();
// Okay, this is a cast from a function to a different type. Unless doing so // Okay, this is a cast from a function to a different type. Unless doing so
// would cause a type conversion of one of our arguments, change this call to // would cause a type conversion of one of our arguments, change this call to
// be a direct call with arguments casted to the appropriate types. // be a direct call with arguments casted to the appropriate types.
// //
FunctionType *FT = Callee->getFunctionType(); FunctionType *FT = Callee->getFunctionType();
Type *OldRetTy = Caller->getType(); Type *OldRetTy = Caller->getType();
Type *NewRetTy = FT->getReturnType(); Type *NewRetTy = FT->getReturnType();
Show All 10 Lines if (!CastInst::isBitOrNoopPointerCastable(NewRetTy, OldRetTy, DL)) {
if (!Caller->use_empty() && if (!Caller->use_empty() &&
// void -> non-void is handled specially // void -> non-void is handled specially
!NewRetTy->isVoidTy()) !NewRetTy->isVoidTy())
return false; // Cannot transform this return value. return false; // Cannot transform this return value.
} }
if (!CallerPAL.isEmpty() && !Caller->use_empty()) { if (!CallerPAL.isEmpty() && !Caller->use_empty()) {
AttrBuilder RAttrs(CallerPAL, AttributeSet::ReturnIndex); AttrBuilder RAttrs(CallerPAL, AttributeList::ReturnIndex);
if (RAttrs.overlaps(AttributeFuncs::typeIncompatible(NewRetTy))) if (RAttrs.overlaps(AttributeFuncs::typeIncompatible(NewRetTy)))
return false; // Attribute not compatible with transformed value. return false; // Attribute not compatible with transformed value.
} }
// If the callsite is an invoke instruction, and the return value is used by // If the callsite is an invoke instruction, and the return value is used by
// a PHI node in a successor, we cannot change the return type of the call // a PHI node in a successor, we cannot change the return type of the call
// because there is no place to put the cast instruction (without breaking // because there is no place to put the cast instruction (without breaking
// the critical edge). Bail out in this case. // the critical edge). Bail out in this case.
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Lines if (FT->getNumParams() < NumActualArgs && FT->isVarArg() &&
// won't be dropping them. Check that these extra arguments have attributes // won't be dropping them. Check that these extra arguments have attributes
// that are compatible with being a vararg call argument. // that are compatible with being a vararg call argument.
for (unsigned i = CallerPAL.getNumSlots(); i; --i) { for (unsigned i = CallerPAL.getNumSlots(); i; --i) {
unsigned Index = CallerPAL.getSlotIndex(i - 1); unsigned Index = CallerPAL.getSlotIndex(i - 1);
if (Index <= FT->getNumParams()) if (Index <= FT->getNumParams())
break; break;
// Check if it has an attribute that's incompatible with varargs. // Check if it has an attribute that's incompatible with varargs.
AttributeSet PAttrs = CallerPAL.getSlotAttributes(i - 1); AttributeList PAttrs = CallerPAL.getSlotAttributes(i - 1);
if (PAttrs.hasAttribute(Index, Attribute::StructRet)) if (PAttrs.hasAttribute(Index, Attribute::StructRet))
return false; return false;
} }
// Okay, we decided that this is a safe thing to do: go ahead and start // Okay, we decided that this is a safe thing to do: go ahead and start
// inserting cast instructions as necessary. // inserting cast instructions as necessary.
std::vector<Value*> Args; std::vector<Value*> Args;
Args.reserve(NumActualArgs); Args.reserve(NumActualArgs);
SmallVector<AttributeSet, 8> attrVec; SmallVector<AttributeList, 8> attrVec;
attrVec.reserve(NumCommonArgs); attrVec.reserve(NumCommonArgs);
// Get any return attributes. // Get any return attributes.
AttrBuilder RAttrs(CallerPAL, AttributeSet::ReturnIndex); AttrBuilder RAttrs(CallerPAL, AttributeList::ReturnIndex);
// If the return value is not being used, the type may not be compatible // If the return value is not being used, the type may not be compatible
// with the existing attributes. Wipe out any problematic attributes. // with the existing attributes. Wipe out any problematic attributes.
RAttrs.remove(AttributeFuncs::typeIncompatible(NewRetTy)); RAttrs.remove(AttributeFuncs::typeIncompatible(NewRetTy));
// Add the new return attributes. // Add the new return attributes.
if (RAttrs.hasAttributes()) if (RAttrs.hasAttributes())
attrVec.push_back(AttributeSet::get(Caller->getContext(), attrVec.push_back(AttributeList::get(Caller->getContext(),
AttributeSet::ReturnIndex, RAttrs)); AttributeList::ReturnIndex, RAttrs));
AI = CS.arg_begin(); AI = CS.arg_begin();
for (unsigned i = 0; i != NumCommonArgs; ++i, ++AI) { for (unsigned i = 0; i != NumCommonArgs; ++i, ++AI) {
Type *ParamTy = FT->getParamType(i); Type *ParamTy = FT->getParamType(i);
if ((*AI)->getType() == ParamTy) { if ((*AI)->getType() == ParamTy) {
Args.push_back(*AI); Args.push_back(*AI);
} else { } else {
Args.push_back(Builder->CreateBitOrPointerCast(*AI, ParamTy)); Args.push_back(Builder->CreateBitOrPointerCast(*AI, ParamTy));
} }
// Add any parameter attributes. // Add any parameter attributes.
AttrBuilder PAttrs(CallerPAL.getParamAttributes(i + 1), i + 1); AttrBuilder PAttrs(CallerPAL.getParamAttributes(i + 1), i + 1);
if (PAttrs.hasAttributes()) if (PAttrs.hasAttributes())
attrVec.push_back(AttributeSet::get(Caller->getContext(), i + 1, attrVec.push_back(
PAttrs)); AttributeList::get(Caller->getContext(), i + 1, PAttrs));
} }
// If the function takes more arguments than the call was taking, add them // If the function takes more arguments than the call was taking, add them
// now. // now.
for (unsigned i = NumCommonArgs; i != FT->getNumParams(); ++i) for (unsigned i = NumCommonArgs; i != FT->getNumParams(); ++i)
Args.push_back(Constant::getNullValue(FT->getParamType(i))); Args.push_back(Constant::getNullValue(FT->getParamType(i)));
// If we are removing arguments to the function, emit an obnoxious warning. // If we are removing arguments to the function, emit an obnoxious warning.
Show All 10 Lines if (FT->isVarArg()) {
Args.push_back(Builder->CreateCast(opcode, *AI, PTy)); Args.push_back(Builder->CreateCast(opcode, *AI, PTy));
} else { } else {
Args.push_back(*AI); Args.push_back(*AI);
} }
// Add any parameter attributes. // Add any parameter attributes.
AttrBuilder PAttrs(CallerPAL.getParamAttributes(i + 1), i + 1); AttrBuilder PAttrs(CallerPAL.getParamAttributes(i + 1), i + 1);
if (PAttrs.hasAttributes()) if (PAttrs.hasAttributes())
attrVec.push_back(AttributeSet::get(FT->getContext(), i + 1, attrVec.push_back(
PAttrs)); AttributeList::get(FT->getContext(), i + 1, PAttrs));
} }
} }
} }
AttributeSet FnAttrs = CallerPAL.getFnAttributes(); AttributeList FnAttrs = CallerPAL.getFnAttributes();
if (CallerPAL.hasAttributes(AttributeSet::FunctionIndex)) if (CallerPAL.hasAttributes(AttributeList::FunctionIndex))
attrVec.push_back(AttributeSet::get(Callee->getContext(), FnAttrs)); attrVec.push_back(AttributeList::get(Callee->getContext(), FnAttrs));
if (NewRetTy->isVoidTy()) if (NewRetTy->isVoidTy())
Caller->setName(""); // Void type should not have a name. Caller->setName(""); // Void type should not have a name.
const AttributeSet &NewCallerPAL = AttributeSet::get(Callee->getContext(), const AttributeList &NewCallerPAL =
attrVec); AttributeList::get(Callee->getContext(), attrVec);
SmallVector<OperandBundleDef, 1> OpBundles; SmallVector<OperandBundleDef, 1> OpBundles;
CS.getOperandBundlesAsDefs(OpBundles); CS.getOperandBundlesAsDefs(OpBundles);
Instruction *NC; Instruction *NC;
if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) { if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) {
NC = Builder->CreateInvoke(Callee, II->getNormalDest(), II->getUnwindDest(), NC = Builder->CreateInvoke(Callee, II->getNormalDest(), II->getUnwindDest(),
Args, OpBundles); Args, OpBundles);
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
/// Turn a call to a function created by init_trampoline / adjust_trampoline /// Turn a call to a function created by init_trampoline / adjust_trampoline
/// intrinsic pair into a direct call to the underlying function. /// intrinsic pair into a direct call to the underlying function.
Instruction * Instruction *
InstCombiner::transformCallThroughTrampoline(CallSite CS, InstCombiner::transformCallThroughTrampoline(CallSite CS,
IntrinsicInst *Tramp) { IntrinsicInst *Tramp) {
Value *Callee = CS.getCalledValue(); Value *Callee = CS.getCalledValue();
PointerType *PTy = cast<PointerType>(Callee->getType()); PointerType *PTy = cast<PointerType>(Callee->getType());
FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
const AttributeSet &Attrs = CS.getAttributes(); const AttributeList &Attrs = CS.getAttributes();
// If the call already has the 'nest' attribute somewhere then give up - // If the call already has the 'nest' attribute somewhere then give up -
// otherwise 'nest' would occur twice after splicing in the chain. // otherwise 'nest' would occur twice after splicing in the chain.
if (Attrs.hasAttrSomewhere(Attribute::Nest)) if (Attrs.hasAttrSomewhere(Attribute::Nest))
return nullptr; return nullptr;
assert(Tramp && assert(Tramp &&
"transformCallThroughTrampoline called with incorrect CallSite."); "transformCallThroughTrampoline called with incorrect CallSite.");
Function *NestF =cast<Function>(Tramp->getArgOperand(1)->stripPointerCasts()); Function *NestF =cast<Function>(Tramp->getArgOperand(1)->stripPointerCasts());
FunctionType *NestFTy = cast<FunctionType>(NestF->getValueType()); FunctionType *NestFTy = cast<FunctionType>(NestF->getValueType());
const AttributeSet &NestAttrs = NestF->getAttributes(); const AttributeList &NestAttrs = NestF->getAttributes();
if (!NestAttrs.isEmpty()) { if (!NestAttrs.isEmpty()) {
unsigned NestIdx = 1; unsigned NestIdx = 1;
Type *NestTy = nullptr; Type *NestTy = nullptr;
AttributeSet NestAttr; AttributeList NestAttr;
// Look for a parameter marked with the 'nest' attribute. // Look for a parameter marked with the 'nest' attribute.
for (FunctionType::param_iterator I = NestFTy->param_begin(), for (FunctionType::param_iterator I = NestFTy->param_begin(),
E = NestFTy->param_end(); I != E; ++NestIdx, ++I) E = NestFTy->param_end(); I != E; ++NestIdx, ++I)
if (NestAttrs.hasAttribute(NestIdx, Attribute::Nest)) { if (NestAttrs.hasAttribute(NestIdx, Attribute::Nest)) {
// Record the parameter type and any other attributes. // Record the parameter type and any other attributes.
NestTy = *I; NestTy = *I;
NestAttr = NestAttrs.getParamAttributes(NestIdx); NestAttr = NestAttrs.getParamAttributes(NestIdx);
break; break;
} }
if (NestTy) { if (NestTy) {
Instruction *Caller = CS.getInstruction(); Instruction *Caller = CS.getInstruction();
std::vector<Value*> NewArgs; std::vector<Value*> NewArgs;
NewArgs.reserve(CS.arg_size() + 1); NewArgs.reserve(CS.arg_size() + 1);
SmallVector<AttributeSet, 8> NewAttrs; SmallVector<AttributeList, 8> NewAttrs;
NewAttrs.reserve(Attrs.getNumSlots() + 1); NewAttrs.reserve(Attrs.getNumSlots() + 1);
// Insert the nest argument into the call argument list, which may // Insert the nest argument into the call argument list, which may
// mean appending it. Likewise for attributes. // mean appending it. Likewise for attributes.
// Add any result attributes. // Add any result attributes.
if (Attrs.hasAttributes(AttributeSet::ReturnIndex)) if (Attrs.hasAttributes(AttributeList::ReturnIndex))
NewAttrs.push_back(AttributeSet::get(Caller->getContext(), NewAttrs.push_back(
Attrs.getRetAttributes())); AttributeList::get(Caller->getContext(), Attrs.getRetAttributes()));
{ {
unsigned Idx = 1; unsigned Idx = 1;
CallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end(); CallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end();
do { do {
if (Idx == NestIdx) { if (Idx == NestIdx) {
// Add the chain argument and attributes. // Add the chain argument and attributes.
Value *NestVal = Tramp->getArgOperand(2); Value *NestVal = Tramp->getArgOperand(2);
if (NestVal->getType() != NestTy) if (NestVal->getType() != NestTy)
NestVal = Builder->CreateBitCast(NestVal, NestTy, "nest"); NestVal = Builder->CreateBitCast(NestVal, NestTy, "nest");
NewArgs.push_back(NestVal); NewArgs.push_back(NestVal);
NewAttrs.push_back(AttributeSet::get(Caller->getContext(), NewAttrs.push_back(
NestAttr)); AttributeList::get(Caller->getContext(), NestAttr));
} }
if (I == E) if (I == E)
break; break;
// Add the original argument and attributes. // Add the original argument and attributes.
NewArgs.push_back(*I); NewArgs.push_back(*I);
AttributeSet Attr = Attrs.getParamAttributes(Idx); AttributeList Attr = Attrs.getParamAttributes(Idx);
if (Attr.hasAttributes(Idx)) { if (Attr.hasAttributes(Idx)) {
AttrBuilder B(Attr, Idx); AttrBuilder B(Attr, Idx);
NewAttrs.push_back(AttributeSet::get(Caller->getContext(), NewAttrs.push_back(AttributeList::get(Caller->getContext(),
Idx + (Idx >= NestIdx), B)); Idx + (Idx >= NestIdx), B));
} }
++Idx; ++Idx;
++I; ++I;
} while (true); } while (true);
} }
// Add any function attributes. // Add any function attributes.
if (Attrs.hasAttributes(AttributeSet::FunctionIndex)) if (Attrs.hasAttributes(AttributeList::FunctionIndex))
NewAttrs.push_back(AttributeSet::get(FTy->getContext(), NewAttrs.push_back(
Attrs.getFnAttributes())); AttributeList::get(FTy->getContext(), Attrs.getFnAttributes()));
// The trampoline may have been bitcast to a bogus type (FTy). // The trampoline may have been bitcast to a bogus type (FTy).
// Handle this by synthesizing a new function type, equal to FTy // Handle this by synthesizing a new function type, equal to FTy
// with the chain parameter inserted. // with the chain parameter inserted.
std::vector<Type*> NewTypes; std::vector<Type*> NewTypes;
NewTypes.reserve(FTy->getNumParams()+1); NewTypes.reserve(FTy->getNumParams()+1);
Show All 23 Lines if (NestTy) {
// Replace the trampoline call with a direct call. Let the generic // Replace the trampoline call with a direct call. Let the generic
// code sort out any function type mismatches. // code sort out any function type mismatches.
FunctionType *NewFTy = FunctionType::get(FTy->getReturnType(), NewTypes, FunctionType *NewFTy = FunctionType::get(FTy->getReturnType(), NewTypes,
FTy->isVarArg()); FTy->isVarArg());
Constant *NewCallee = Constant *NewCallee =
NestF->getType() == PointerType::getUnqual(NewFTy) ? NestF->getType() == PointerType::getUnqual(NewFTy) ?
NestF : ConstantExpr::getBitCast(NestF, NestF : ConstantExpr::getBitCast(NestF,
PointerType::getUnqual(NewFTy)); PointerType::getUnqual(NewFTy));
const AttributeSet &NewPAL = const AttributeList &NewPAL =
AttributeSet::get(FTy->getContext(), NewAttrs); AttributeList::get(FTy->getContext(), NewAttrs);
SmallVector<OperandBundleDef, 1> OpBundles; SmallVector<OperandBundleDef, 1> OpBundles;
CS.getOperandBundlesAsDefs(OpBundles); CS.getOperandBundlesAsDefs(OpBundles);
Instruction *NewCaller; Instruction *NewCaller;
if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) { if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) {
NewCaller = InvokeInst::Create(NewCallee, NewCaller = InvokeInst::Create(NewCallee,
II->getNormalDest(), II->getUnwindDest(), II->getNormalDest(), II->getUnwindDest(),
Show All 25 Lines

llvm/trunk/lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

Show First 20 Lines • Show All 248 Lines • ▼ Show 20 Linesclass DataFlowSanitizer : public ModulePass {
Constant *DFSanUnionLoadFn; Constant *DFSanUnionLoadFn;
Constant *DFSanUnimplementedFn; Constant *DFSanUnimplementedFn;
Constant *DFSanSetLabelFn; Constant *DFSanSetLabelFn;
Constant *DFSanNonzeroLabelFn; Constant *DFSanNonzeroLabelFn;
Constant *DFSanVarargWrapperFn; Constant *DFSanVarargWrapperFn;
MDNode *ColdCallWeights; MDNode *ColdCallWeights;
DFSanABIList ABIList; DFSanABIList ABIList;
DenseMap<Value *, Function *> UnwrappedFnMap; DenseMap<Value *, Function *> UnwrappedFnMap;
AttributeSet ReadOnlyNoneAttrs; AttributeList ReadOnlyNoneAttrs;
bool DFSanRuntimeShadowMask; bool DFSanRuntimeShadowMask;
Value *getShadowAddress(Value *Addr, Instruction *Pos); Value *getShadowAddress(Value *Addr, Instruction *Pos);
bool isInstrumented(const Function *F); bool isInstrumented(const Function *F);
bool isInstrumented(const GlobalAlias *GA); bool isInstrumented(const GlobalAlias *GA);
FunctionType *getArgsFunctionType(FunctionType *T); FunctionType *getArgsFunctionType(FunctionType *T);
FunctionType *getTrampolineFunctionType(FunctionType *T); FunctionType *getTrampolineFunctionType(FunctionType *T);
FunctionType *getCustomFunctionType(FunctionType *T); FunctionType *getCustomFunctionType(FunctionType *T);
▲ Show 20 Lines • Show All 268 Lines • ▼ Show 20 Lines
DataFlowSanitizer::buildWrapperFunction(Function *F, StringRef NewFName, DataFlowSanitizer::buildWrapperFunction(Function *F, StringRef NewFName,
GlobalValue::LinkageTypes NewFLink, GlobalValue::LinkageTypes NewFLink,
FunctionType *NewFT) { FunctionType *NewFT) {
FunctionType *FT = F->getFunctionType(); FunctionType *FT = F->getFunctionType();
Function *NewF = Function::Create(NewFT, NewFLink, NewFName, Function *NewF = Function::Create(NewFT, NewFLink, NewFName,
F->getParent()); F->getParent());
NewF->copyAttributesFrom(F); NewF->copyAttributesFrom(F);
NewF->removeAttributes( NewF->removeAttributes(
AttributeSet::ReturnIndex, AttributeList::ReturnIndex,
AttributeSet::get(F->getContext(), AttributeSet::ReturnIndex, AttributeList::get(
F->getContext(), AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NewFT->getReturnType()))); AttributeFuncs::typeIncompatible(NewFT->getReturnType())));
BasicBlock *BB = BasicBlock::Create(*Ctx, "entry", NewF); BasicBlock *BB = BasicBlock::Create(*Ctx, "entry", NewF);
if (F->isVarArg()) { if (F->isVarArg()) {
NewF->removeAttributes( NewF->removeAttributes(
AttributeSet::FunctionIndex, AttributeList::FunctionIndex,
AttributeSet().addAttribute(*Ctx, AttributeSet::FunctionIndex, AttributeList().addAttribute(*Ctx, AttributeList::FunctionIndex,
"split-stack")); "split-stack"));
CallInst::Create(DFSanVarargWrapperFn, CallInst::Create(DFSanVarargWrapperFn,
IRBuilder<>(BB).CreateGlobalStringPtr(F->getName()), "", IRBuilder<>(BB).CreateGlobalStringPtr(F->getName()), "",
BB); BB);
new UnreachableInst(*Ctx, BB); new UnreachableInst(*Ctx, BB);
} else { } else {
std::vector<Value *> Args; std::vector<Value *> Args;
unsigned n = FT->getNumParams(); unsigned n = FT->getNumParams();
for (Function::arg_iterator ai = NewF->arg_begin(); n != 0; ++ai, --n) for (Function::arg_iterator ai = NewF->arg_begin(); n != 0; ++ai, --n)
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines if (GlobalVariable *G = dyn_cast<GlobalVariable>(RetvalTLS))
G->setThreadLocalMode(GlobalVariable::InitialExecTLSModel); G->setThreadLocalMode(GlobalVariable::InitialExecTLSModel);
} }
ExternalShadowMask = ExternalShadowMask =
Mod->getOrInsertGlobal(kDFSanExternShadowPtrMask, IntptrTy); Mod->getOrInsertGlobal(kDFSanExternShadowPtrMask, IntptrTy);
DFSanUnionFn = Mod->getOrInsertFunction("__dfsan_union", DFSanUnionFnTy); DFSanUnionFn = Mod->getOrInsertFunction("__dfsan_union", DFSanUnionFnTy);
if (Function *F = dyn_cast<Function>(DFSanUnionFn)) { if (Function *F = dyn_cast<Function>(DFSanUnionFn)) {
F->addAttribute(AttributeSet::FunctionIndex, Attribute::NoUnwind); F->addAttribute(AttributeList::FunctionIndex, Attribute::NoUnwind);
F->addAttribute(AttributeSet::FunctionIndex, Attribute::ReadNone); F->addAttribute(AttributeList::FunctionIndex, Attribute::ReadNone);
F->addAttribute(AttributeSet::ReturnIndex, Attribute::ZExt); F->addAttribute(AttributeList::ReturnIndex, Attribute::ZExt);
F->addAttribute(1, Attribute::ZExt); F->addAttribute(1, Attribute::ZExt);
F->addAttribute(2, Attribute::ZExt); F->addAttribute(2, Attribute::ZExt);
} }
DFSanCheckedUnionFn = Mod->getOrInsertFunction("dfsan_union", DFSanUnionFnTy); DFSanCheckedUnionFn = Mod->getOrInsertFunction("dfsan_union", DFSanUnionFnTy);
if (Function *F = dyn_cast<Function>(DFSanCheckedUnionFn)) { if (Function *F = dyn_cast<Function>(DFSanCheckedUnionFn)) {
F->addAttribute(AttributeSet::FunctionIndex, Attribute::NoUnwind); F->addAttribute(AttributeList::FunctionIndex, Attribute::NoUnwind);
F->addAttribute(AttributeSet::FunctionIndex, Attribute::ReadNone); F->addAttribute(AttributeList::FunctionIndex, Attribute::ReadNone);
F->addAttribute(AttributeSet::ReturnIndex, Attribute::ZExt); F->addAttribute(AttributeList::ReturnIndex, Attribute::ZExt);
F->addAttribute(1, Attribute::ZExt); F->addAttribute(1, Attribute::ZExt);
F->addAttribute(2, Attribute::ZExt); F->addAttribute(2, Attribute::ZExt);
} }
DFSanUnionLoadFn = DFSanUnionLoadFn =
Mod->getOrInsertFunction("__dfsan_union_load", DFSanUnionLoadFnTy); Mod->getOrInsertFunction("__dfsan_union_load", DFSanUnionLoadFnTy);
if (Function *F = dyn_cast<Function>(DFSanUnionLoadFn)) { if (Function *F = dyn_cast<Function>(DFSanUnionLoadFn)) {
F->addAttribute(AttributeSet::FunctionIndex, Attribute::NoUnwind); F->addAttribute(AttributeList::FunctionIndex, Attribute::NoUnwind);
F->addAttribute(AttributeSet::FunctionIndex, Attribute::ReadOnly); F->addAttribute(AttributeList::FunctionIndex, Attribute::ReadOnly);
F->addAttribute(AttributeSet::ReturnIndex, Attribute::ZExt); F->addAttribute(AttributeList::ReturnIndex, Attribute::ZExt);
} }
DFSanUnimplementedFn = DFSanUnimplementedFn =
Mod->getOrInsertFunction("__dfsan_unimplemented", DFSanUnimplementedFnTy); Mod->getOrInsertFunction("__dfsan_unimplemented", DFSanUnimplementedFnTy);
DFSanSetLabelFn = DFSanSetLabelFn =
Mod->getOrInsertFunction("__dfsan_set_label", DFSanSetLabelFnTy); Mod->getOrInsertFunction("__dfsan_set_label", DFSanSetLabelFnTy);
if (Function *F = dyn_cast<Function>(DFSanSetLabelFn)) { if (Function *F = dyn_cast<Function>(DFSanSetLabelFn)) {
F->addAttribute(1, Attribute::ZExt); F->addAttribute(1, Attribute::ZExt);
} }
Show All 38 Lines if (auto F = dyn_cast<Function>(GA->getBaseObject())) {
GA->eraseFromParent(); GA->eraseFromParent();
FnsToInstrument.push_back(NewF); FnsToInstrument.push_back(NewF);
} }
} }
} }
AttrBuilder B; AttrBuilder B;
B.addAttribute(Attribute::ReadOnly).addAttribute(Attribute::ReadNone); B.addAttribute(Attribute::ReadOnly).addAttribute(Attribute::ReadNone);
ReadOnlyNoneAttrs = AttributeSet::get(*Ctx, AttributeSet::FunctionIndex, B); ReadOnlyNoneAttrs = AttributeList::get(*Ctx, AttributeList::FunctionIndex, B);
// First, change the ABI of every function in the module. ABI-listed // First, change the ABI of every function in the module. ABI-listed
// functions keep their original ABI and get a wrapper function. // functions keep their original ABI and get a wrapper function.
for (std::vector<Function *>::iterator i = FnsToInstrument.begin(), for (std::vector<Function *>::iterator i = FnsToInstrument.begin(),
e = FnsToInstrument.end(); e = FnsToInstrument.end();
i != e; ++i) { i != e; ++i) {
Function &F = **i; Function &F = **i;
FunctionType *FT = F.getFunctionType(); FunctionType *FT = F.getFunctionType();
bool IsZeroArgsVoidRet = (FT->getNumParams() == 0 && !FT->isVarArg() && bool IsZeroArgsVoidRet = (FT->getNumParams() == 0 && !FT->isVarArg() &&
FT->getReturnType()->isVoidTy()); FT->getReturnType()->isVoidTy());
if (isInstrumented(&F)) { if (isInstrumented(&F)) {
// Instrumented functions get a 'dfs$' prefix. This allows us to more // Instrumented functions get a 'dfs$' prefix. This allows us to more
// easily identify cases of mismatching ABIs. // easily identify cases of mismatching ABIs.
if (getInstrumentedABI() == IA_Args && !IsZeroArgsVoidRet) { if (getInstrumentedABI() == IA_Args && !IsZeroArgsVoidRet) {
FunctionType *NewFT = getArgsFunctionType(FT); FunctionType *NewFT = getArgsFunctionType(FT);
Function *NewF = Function::Create(NewFT, F.getLinkage(), "", &M); Function *NewF = Function::Create(NewFT, F.getLinkage(), "", &M);
NewF->copyAttributesFrom(&F); NewF->copyAttributesFrom(&F);
NewF->removeAttributes( NewF->removeAttributes(
AttributeSet::ReturnIndex, AttributeList::ReturnIndex,
AttributeSet::get(NewF->getContext(), AttributeSet::ReturnIndex, AttributeList::get(
NewF->getContext(), AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NewFT->getReturnType()))); AttributeFuncs::typeIncompatible(NewFT->getReturnType())));
for (Function::arg_iterator FArg = F.arg_begin(), for (Function::arg_iterator FArg = F.arg_begin(),
NewFArg = NewF->arg_begin(), NewFArg = NewF->arg_begin(),
FArgEnd = F.arg_end(); FArgEnd = F.arg_end();
FArg != FArgEnd; ++FArg, ++NewFArg) { FArg != FArgEnd; ++FArg, ++NewFArg) {
FArg->replaceAllUsesWith(&*NewFArg); FArg->replaceAllUsesWith(&*NewFArg);
} }
NewF->getBasicBlockList().splice(NewF->begin(), F.getBasicBlockList()); NewF->getBasicBlockList().splice(NewF->begin(), F.getBasicBlockList());
Show All 22 Lines if (isInstrumented(&F)) {
// WrapperKind is done in the second pass below. // WrapperKind is done in the second pass below.
FunctionType *NewFT = getInstrumentedABI() == IA_Args FunctionType *NewFT = getInstrumentedABI() == IA_Args
? getArgsFunctionType(FT) ? getArgsFunctionType(FT)
: FT; : FT;
Function *NewF = buildWrapperFunction( Function *NewF = buildWrapperFunction(
&F, std::string("dfsw$") + std::string(F.getName()), &F, std::string("dfsw$") + std::string(F.getName()),
GlobalValue::LinkOnceODRLinkage, NewFT); GlobalValue::LinkOnceODRLinkage, NewFT);
if (getInstrumentedABI() == IA_TLS) if (getInstrumentedABI() == IA_TLS)
NewF->removeAttributes(AttributeSet::FunctionIndex, ReadOnlyNoneAttrs); NewF->removeAttributes(AttributeList::FunctionIndex, ReadOnlyNoneAttrs);
Value *WrappedFnCst = Value *WrappedFnCst =
ConstantExpr::getBitCast(NewF, PointerType::getUnqual(FT)); ConstantExpr::getBitCast(NewF, PointerType::getUnqual(FT));
F.replaceAllUsesWith(WrappedFnCst); F.replaceAllUsesWith(WrappedFnCst);
UnwrappedFnMap[WrappedFnCst] = &F; UnwrappedFnMap[WrappedFnCst] = &F;
*i = NewF; *i = NewF;
▲ Show 20 Lines • Show All 208 Lines • ▼ Show 20 Lines if (V1 > V2)
std::swap(Key.first, Key.second); std::swap(Key.first, Key.second);
CachedCombinedShadow &CCS = CachedCombinedShadows[Key]; CachedCombinedShadow &CCS = CachedCombinedShadows[Key];
if (CCS.Block && DT.dominates(CCS.Block, Pos->getParent())) if (CCS.Block && DT.dominates(CCS.Block, Pos->getParent()))
return CCS.Shadow; return CCS.Shadow;
IRBuilder<> IRB(Pos); IRBuilder<> IRB(Pos);
if (AvoidNewBlocks) { if (AvoidNewBlocks) {
CallInst *Call = IRB.CreateCall(DFS.DFSanCheckedUnionFn, {V1, V2}); CallInst *Call = IRB.CreateCall(DFS.DFSanCheckedUnionFn, {V1, V2});
Call->addAttribute(AttributeSet::ReturnIndex, Attribute::ZExt); Call->addAttribute(AttributeList::ReturnIndex, Attribute::ZExt);
Call->addAttribute(1, Attribute::ZExt); Call->addAttribute(1, Attribute::ZExt);
Call->addAttribute(2, Attribute::ZExt); Call->addAttribute(2, Attribute::ZExt);
CCS.Block = Pos->getParent(); CCS.Block = Pos->getParent();
CCS.Shadow = Call; CCS.Shadow = Call;
} else { } else {
BasicBlock *Head = Pos->getParent(); BasicBlock *Head = Pos->getParent();
Value *Ne = IRB.CreateICmpNE(V1, V2); Value *Ne = IRB.CreateICmpNE(V1, V2);
BranchInst *BI = cast<BranchInst>(SplitBlockAndInsertIfThen( BranchInst *BI = cast<BranchInst>(SplitBlockAndInsertIfThen(
Ne, Pos, /*Unreachable=*/false, DFS.ColdCallWeights, &DT)); Ne, Pos, /*Unreachable=*/false, DFS.ColdCallWeights, &DT));
IRBuilder<> ThenIRB(BI); IRBuilder<> ThenIRB(BI);
CallInst *Call = ThenIRB.CreateCall(DFS.DFSanUnionFn, {V1, V2}); CallInst *Call = ThenIRB.CreateCall(DFS.DFSanUnionFn, {V1, V2});
Call->addAttribute(AttributeSet::ReturnIndex, Attribute::ZExt); Call->addAttribute(AttributeList::ReturnIndex, Attribute::ZExt);
Call->addAttribute(1, Attribute::ZExt); Call->addAttribute(1, Attribute::ZExt);
Call->addAttribute(2, Attribute::ZExt); Call->addAttribute(2, Attribute::ZExt);
BasicBlock *Tail = BI->getSuccessor(0); BasicBlock *Tail = BI->getSuccessor(0);
PHINode *Phi = PHINode::Create(DFS.ShadowTy, 2, "", &Tail->front()); PHINode *Phi = PHINode::Create(DFS.ShadowTy, 2, "", &Tail->front());
Phi->addIncoming(Call, Call->getParent()); Phi->addIncoming(Call, Call->getParent());
Phi->addIncoming(V1, Head); Phi->addIncoming(V1, Head);
▲ Show 20 Lines • Show All 86 Lines • ▼ Show 20 Lines if (!AvoidNewBlocks && Size % (64 / DFS.ShadowWidth) == 0) {
// Fast path for the common case where each byte has identical shadow: load // Fast path for the common case where each byte has identical shadow: load
// shadow 64 bits at a time, fall out to a __dfsan_union_load call if any // shadow 64 bits at a time, fall out to a __dfsan_union_load call if any
// shadow is non-equal. // shadow is non-equal.
BasicBlock *FallbackBB = BasicBlock::Create(*DFS.Ctx, "", F); BasicBlock *FallbackBB = BasicBlock::Create(*DFS.Ctx, "", F);
IRBuilder<> FallbackIRB(FallbackBB); IRBuilder<> FallbackIRB(FallbackBB);
CallInst *FallbackCall = FallbackIRB.CreateCall( CallInst *FallbackCall = FallbackIRB.CreateCall(
DFS.DFSanUnionLoadFn, DFS.DFSanUnionLoadFn,
{ShadowAddr, ConstantInt::get(DFS.IntptrTy, Size)}); {ShadowAddr, ConstantInt::get(DFS.IntptrTy, Size)});
FallbackCall->addAttribute(AttributeSet::ReturnIndex, Attribute::ZExt); FallbackCall->addAttribute(AttributeList::ReturnIndex, Attribute::ZExt);
// Compare each of the shadows stored in the loaded 64 bits to each other, // Compare each of the shadows stored in the loaded 64 bits to each other,
// by computing (WideShadow rotl ShadowWidth) == WideShadow. // by computing (WideShadow rotl ShadowWidth) == WideShadow.
IRBuilder<> IRB(Pos); IRBuilder<> IRB(Pos);
Value *WideAddr = Value *WideAddr =
IRB.CreateBitCast(ShadowAddr, Type::getInt64PtrTy(*DFS.Ctx)); IRB.CreateBitCast(ShadowAddr, Type::getInt64PtrTy(*DFS.Ctx));
Value *WideShadow = IRB.CreateAlignedLoad(WideAddr, ShadowAlign); Value *WideShadow = IRB.CreateAlignedLoad(WideAddr, ShadowAlign);
Value *TruncShadow = IRB.CreateTrunc(WideShadow, DFS.ShadowTy); Value *TruncShadow = IRB.CreateTrunc(WideShadow, DFS.ShadowTy);
Show All 40 Lines if (!AvoidNewBlocks && Size % (64 / DFS.ShadowWidth) == 0) {
Shadow->addIncoming(FallbackCall, FallbackBB); Shadow->addIncoming(FallbackCall, FallbackBB);
Shadow->addIncoming(TruncShadow, LastBr->getParent()); Shadow->addIncoming(TruncShadow, LastBr->getParent());
return Shadow; return Shadow;
} }
IRBuilder<> IRB(Pos); IRBuilder<> IRB(Pos);
CallInst *FallbackCall = IRB.CreateCall( CallInst *FallbackCall = IRB.CreateCall(
DFS.DFSanUnionLoadFn, {ShadowAddr, ConstantInt::get(DFS.IntptrTy, Size)}); DFS.DFSanUnionLoadFn, {ShadowAddr, ConstantInt::get(DFS.IntptrTy, Size)});
FallbackCall->addAttribute(AttributeSet::ReturnIndex, Attribute::ZExt); FallbackCall->addAttribute(AttributeList::ReturnIndex, Attribute::ZExt);
return FallbackCall; return FallbackCall;
} }
void DFSanVisitor::visitLoadInst(LoadInst &LI) { void DFSanVisitor::visitLoadInst(LoadInst &LI) {
auto &DL = LI.getModule()->getDataLayout(); auto &DL = LI.getModule()->getDataLayout();
uint64_t Size = DL.getTypeStoreSize(LI.getType()); uint64_t Size = DL.getTypeStoreSize(LI.getType());
if (Size == 0) { if (Size == 0) {
DFSF.setShadow(&LI, DFSF.DFS.ZeroShadow); DFSF.setShadow(&LI, DFSF.DFS.ZeroShadow);
▲ Show 20 Lines • Show All 273 Lines • ▼ Show 20 Lines case DataFlowSanitizer::WK_Custom: {
CustomFName += F->getName(); CustomFName += F->getName();
Constant *CustomF = Constant *CustomF =
DFSF.DFS.Mod->getOrInsertFunction(CustomFName, CustomFT); DFSF.DFS.Mod->getOrInsertFunction(CustomFName, CustomFT);
if (Function *CustomFn = dyn_cast<Function>(CustomF)) { if (Function *CustomFn = dyn_cast<Function>(CustomF)) {
CustomFn->copyAttributesFrom(F); CustomFn->copyAttributesFrom(F);
// Custom functions returning non-void will write to the return label. // Custom functions returning non-void will write to the return label.
if (!FT->getReturnType()->isVoidTy()) { if (!FT->getReturnType()->isVoidTy()) {
CustomFn->removeAttributes(AttributeSet::FunctionIndex, CustomFn->removeAttributes(AttributeList::FunctionIndex,
DFSF.DFS.ReadOnlyNoneAttrs); DFSF.DFS.ReadOnlyNoneAttrs);
} }
} }
std::vector<Value *> Args; std::vector<Value *> Args;
CallSite::arg_iterator i = CS.arg_begin(); CallSite::arg_iterator i = CS.arg_begin();
for (unsigned n = FT->getNumParams(); n != 0; ++i, --n) { for (unsigned n = FT->getNumParams(); n != 0; ++i, --n) {
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines if (DFSF.DFS.getInstrumentedABI() == DataFlowSanitizer::IA_Args) {
if (InvokeInst *II = dyn_cast<InvokeInst>(CS.getInstruction())) { if (InvokeInst *II = dyn_cast<InvokeInst>(CS.getInstruction())) {
NewCS = IRB.CreateInvoke(Func, II->getNormalDest(), II->getUnwindDest(), NewCS = IRB.CreateInvoke(Func, II->getNormalDest(), II->getUnwindDest(),
Args); Args);
} else { } else {
NewCS = IRB.CreateCall(Func, Args); NewCS = IRB.CreateCall(Func, Args);
} }
NewCS.setCallingConv(CS.getCallingConv()); NewCS.setCallingConv(CS.getCallingConv());
NewCS.setAttributes(CS.getAttributes().removeAttributes( NewCS.setAttributes(CS.getAttributes().removeAttributes(
*DFSF.DFS.Ctx, AttributeSet::ReturnIndex, *DFSF.DFS.Ctx, AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NewCS.getInstruction()->getType()))); AttributeFuncs::typeIncompatible(NewCS.getInstruction()->getType())));
if (Next) { if (Next) {
ExtractValueInst *ExVal = ExtractValueInst *ExVal =
ExtractValueInst::Create(NewCS.getInstruction(), 0, "", Next); ExtractValueInst::Create(NewCS.getInstruction(), 0, "", Next);
DFSF.SkipInsts.insert(ExVal); DFSF.SkipInsts.insert(ExVal);
ExtractValueInst *ExShadow = ExtractValueInst *ExShadow =
ExtractValueInst::Create(NewCS.getInstruction(), 1, "", Next); ExtractValueInst::Create(NewCS.getInstruction(), 1, "", Next);
Show All 25 Lines

llvm/trunk/lib/Transforms/Instrumentation/MemorySanitizer.cpp

Show First 20 Lines • Show All 2,601 Lines • ▼ Show 20 Lines if (CS.isCall()) {
// will become a non-readonly function after it is instrumented by us. To // will become a non-readonly function after it is instrumented by us. To
// prevent this code from being optimized out, mark that function // prevent this code from being optimized out, mark that function
// non-readonly in advance. // non-readonly in advance.
if (Function *Func = Call->getCalledFunction()) { if (Function *Func = Call->getCalledFunction()) {
// Clear out readonly/readnone attributes. // Clear out readonly/readnone attributes.
AttrBuilder B; AttrBuilder B;
B.addAttribute(Attribute::ReadOnly) B.addAttribute(Attribute::ReadOnly)
.addAttribute(Attribute::ReadNone); .addAttribute(Attribute::ReadNone);
Func->removeAttributes(AttributeSet::FunctionIndex, Func->removeAttributes(AttributeList::FunctionIndex,
AttributeSet::get(Func->getContext(), AttributeList::get(Func->getContext(),
AttributeSet::FunctionIndex, AttributeList::FunctionIndex,
B)); B));
} }
maybeMarkSanitizerLibraryCallNoBuiltin(Call, TLI); maybeMarkSanitizerLibraryCallNoBuiltin(Call, TLI);
} }
IRBuilder<> IRB(&I); IRBuilder<> IRB(&I);
unsigned ArgOffset = 0; unsigned ArgOffset = 0;
DEBUG(dbgs() << " CallSite: " << I << "\n"); DEBUG(dbgs() << " CallSite: " << I << "\n");
▲ Show 20 Lines • Show All 1,032 Lines • ▼ Show 20 Linesbool MemorySanitizer::runOnFunction(Function &F) {
if (&F == MsanCtorFunction) if (&F == MsanCtorFunction)
return false; return false;
MemorySanitizerVisitor Visitor(F, *this); MemorySanitizerVisitor Visitor(F, *this);
// Clear out readonly/readnone attributes. // Clear out readonly/readnone attributes.
AttrBuilder B; AttrBuilder B;
B.addAttribute(Attribute::ReadOnly) B.addAttribute(Attribute::ReadOnly)
.addAttribute(Attribute::ReadNone); .addAttribute(Attribute::ReadNone);
F.removeAttributes(AttributeSet::FunctionIndex, F.removeAttributes(
AttributeSet::get(F.getContext(), AttributeList::FunctionIndex,
AttributeSet::FunctionIndex, B)); AttributeList::get(F.getContext(), AttributeList::FunctionIndex, B));
return Visitor.runOnFunction(); return Visitor.runOnFunction();
} }

llvm/trunk/lib/Transforms/Instrumentation/ThreadSanitizer.cpp

Show First 20 Lines • Show All 149 Lines • ▼ Show 20 Lines
} }
FunctionPass *llvm::createThreadSanitizerPass() { FunctionPass *llvm::createThreadSanitizerPass() {
return new ThreadSanitizer(); return new ThreadSanitizer();
} }
void ThreadSanitizer::initializeCallbacks(Module &M) { void ThreadSanitizer::initializeCallbacks(Module &M) {
IRBuilder<> IRB(M.getContext()); IRBuilder<> IRB(M.getContext());
AttributeSet Attr; AttributeList Attr;
Attr = Attr.addAttribute(M.getContext(), AttributeSet::FunctionIndex, Attribute::NoUnwind); Attr = Attr.addAttribute(M.getContext(), AttributeList::FunctionIndex,
Attribute::NoUnwind);
// Initialize the callbacks. // Initialize the callbacks.
TsanFuncEntry = checkSanitizerInterfaceFunction(M.getOrInsertFunction( TsanFuncEntry = checkSanitizerInterfaceFunction(M.getOrInsertFunction(
"__tsan_func_entry", Attr, IRB.getVoidTy(), IRB.getInt8PtrTy(), nullptr)); "__tsan_func_entry", Attr, IRB.getVoidTy(), IRB.getInt8PtrTy(), nullptr));
TsanFuncExit = checkSanitizerInterfaceFunction( TsanFuncExit = checkSanitizerInterfaceFunction(
M.getOrInsertFunction("__tsan_func_exit", Attr, IRB.getVoidTy(), nullptr)); M.getOrInsertFunction("__tsan_func_exit", Attr, IRB.getVoidTy(), nullptr));
TsanIgnoreBegin = checkSanitizerInterfaceFunction(M.getOrInsertFunction( TsanIgnoreBegin = checkSanitizerInterfaceFunction(M.getOrInsertFunction(
"__tsan_ignore_thread_begin", Attr, IRB.getVoidTy(), nullptr)); "__tsan_ignore_thread_begin", Attr, IRB.getVoidTy(), nullptr));
TsanIgnoreEnd = checkSanitizerInterfaceFunction(M.getOrInsertFunction( TsanIgnoreEnd = checkSanitizerInterfaceFunction(M.getOrInsertFunction(
▲ Show 20 Lines • Show All 533 Lines • Show Last 20 Lines

llvm/trunk/lib/Transforms/ObjCARC/ARCRuntimeEntryPoints.h

Show First 20 Lines • Show All 121 Lines • ▼ Show 20 Linesprivate:
Constant *RetainAutoreleaseRV; Constant *RetainAutoreleaseRV;
Constant *getVoidRetI8XEntryPoint(Constant *&Decl, StringRef Name) { Constant *getVoidRetI8XEntryPoint(Constant *&Decl, StringRef Name) {
if (Decl) if (Decl)
return Decl; return Decl;
LLVMContext &C = TheModule->getContext(); LLVMContext &C = TheModule->getContext();
Type *Params[] = { PointerType::getUnqual(Type::getInt8Ty(C)) }; Type *Params[] = { PointerType::getUnqual(Type::getInt8Ty(C)) };
AttributeSet Attr = AttributeList Attr = AttributeList().addAttribute(
AttributeSet().addAttribute(C, AttributeSet::FunctionIndex, C, AttributeList::FunctionIndex, Attribute::NoUnwind);
Attribute::NoUnwind);
FunctionType *Fty = FunctionType::get(Type::getVoidTy(C), Params, FunctionType *Fty = FunctionType::get(Type::getVoidTy(C), Params,
/*isVarArg=*/false); /*isVarArg=*/false);
return Decl = TheModule->getOrInsertFunction(Name, Fty, Attr); return Decl = TheModule->getOrInsertFunction(Name, Fty, Attr);
} }
Constant *getI8XRetI8XEntryPoint(Constant *&Decl, StringRef Name, Constant *getI8XRetI8XEntryPoint(Constant *&Decl, StringRef Name,
bool NoUnwind = false) { bool NoUnwind = false) {
if (Decl) if (Decl)
return Decl; return Decl;
LLVMContext &C = TheModule->getContext(); LLVMContext &C = TheModule->getContext();
Type *I8X = PointerType::getUnqual(Type::getInt8Ty(C)); Type *I8X = PointerType::getUnqual(Type::getInt8Ty(C));
Type *Params[] = { I8X }; Type *Params[] = { I8X };
FunctionType *Fty = FunctionType::get(I8X, Params, /*isVarArg=*/false); FunctionType *Fty = FunctionType::get(I8X, Params, /*isVarArg=*/false);
AttributeSet Attr = AttributeSet(); AttributeList Attr = AttributeList();
if (NoUnwind) if (NoUnwind)
Attr = Attr.addAttribute(C, AttributeSet::FunctionIndex, Attr = Attr.addAttribute(C, AttributeList::FunctionIndex,
Attribute::NoUnwind); Attribute::NoUnwind);
return Decl = TheModule->getOrInsertFunction(Name, Fty, Attr); return Decl = TheModule->getOrInsertFunction(Name, Fty, Attr);
} }
Constant *getI8XRetI8XXI8XEntryPoint(Constant *&Decl, StringRef Name) { Constant *getI8XRetI8XXI8XEntryPoint(Constant *&Decl, StringRef Name) {
if (Decl) if (Decl)
return Decl; return Decl;
LLVMContext &C = TheModule->getContext(); LLVMContext &C = TheModule->getContext();
Type *I8X = PointerType::getUnqual(Type::getInt8Ty(C)); Type *I8X = PointerType::getUnqual(Type::getInt8Ty(C));
Type *I8XX = PointerType::getUnqual(I8X); Type *I8XX = PointerType::getUnqual(I8X);
Type *Params[] = { I8XX, I8X }; Type *Params[] = { I8XX, I8X };
AttributeSet Attr = AttributeList Attr = AttributeList().addAttribute(
AttributeSet().addAttribute(C, AttributeSet::FunctionIndex, C, AttributeList::FunctionIndex, Attribute::NoUnwind);
Attribute::NoUnwind);
Attr = Attr.addAttribute(C, 1, Attribute::NoCapture); Attr = Attr.addAttribute(C, 1, Attribute::NoCapture);
FunctionType *Fty = FunctionType::get(Type::getVoidTy(C), Params, FunctionType *Fty = FunctionType::get(Type::getVoidTy(C), Params,
/*isVarArg=*/false); /*isVarArg=*/false);
return Decl = TheModule->getOrInsertFunction(Name, Fty, Attr); return Decl = TheModule->getOrInsertFunction(Name, Fty, Attr);
} }
}; // class ARCRuntimeEntryPoints }; // class ARCRuntimeEntryPoints
} // namespace objcarc } // namespace objcarc
} // namespace llvm } // namespace llvm
#endif #endif

llvm/trunk/lib/Transforms/Scalar/CorrelatedValuePropagation.cpp

Show First 20 Lines • Show All 316 Lines • ▼ Show 20 Lines for (Value *V : CS.args()) {
ArgNo++; ArgNo++;
} }
assert(ArgNo == CS.arg_size() && "sanity check"); assert(ArgNo == CS.arg_size() && "sanity check");
if (Indices.empty()) if (Indices.empty())
return false; return false;
AttributeSet AS = CS.getAttributes(); AttributeList AS = CS.getAttributes();
LLVMContext &Ctx = CS.getInstruction()->getContext(); LLVMContext &Ctx = CS.getInstruction()->getContext();
AS = AS.addAttribute(Ctx, Indices, Attribute::get(Ctx, Attribute::NonNull)); AS = AS.addAttribute(Ctx, Indices, Attribute::get(Ctx, Attribute::NonNull));
CS.setAttributes(AS); CS.setAttributes(AS);
return true; return true;
} }
// Helper function to rewrite srem and sdiv. As a policy choice, we choose not // Helper function to rewrite srem and sdiv. As a policy choice, we choose not
▲ Show 20 Lines • Show All 245 Lines • Show Last 20 Lines

llvm/trunk/lib/Transforms/Scalar/PartiallyInlineLibCalls.cpp

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Linesstatic bool optimizeSQRT(CallInst *Call, Function *CalledFunc,
Builder.SetInsertPoint(LibCallBB); Builder.SetInsertPoint(LibCallBB);
Instruction *LibCall = Call->clone(); Instruction *LibCall = Call->clone();
Builder.Insert(LibCall); Builder.Insert(LibCall);
Builder.CreateBr(JoinBB); Builder.CreateBr(JoinBB);
// Add attribute "readnone" so that backend can use a native sqrt instruction // Add attribute "readnone" so that backend can use a native sqrt instruction
// for this call. Insert a FP compare instruction and a conditional branch // for this call. Insert a FP compare instruction and a conditional branch
// at the end of CurrBB. // at the end of CurrBB.
Call->addAttribute(AttributeSet::FunctionIndex, Attribute::ReadNone); Call->addAttribute(AttributeList::FunctionIndex, Attribute::ReadNone);
CurrBB.getTerminator()->eraseFromParent(); CurrBB.getTerminator()->eraseFromParent();
Builder.SetInsertPoint(&CurrBB); Builder.SetInsertPoint(&CurrBB);
Value *FCmp = Builder.CreateFCmpOEQ(Call, Call); Value *FCmp = Builder.CreateFCmpOEQ(Call, Call);
Builder.CreateCondBr(FCmp, JoinBB, LibCallBB); Builder.CreateCondBr(FCmp, JoinBB, LibCallBB);
// Add phi operands. // Add phi operands.
Phi->addIncoming(Call, &CurrBB); Phi->addIncoming(Call, &CurrBB);
Phi->addIncoming(LibCall, LibCallBB); Phi->addIncoming(LibCall, LibCallBB);
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines

llvm/trunk/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

Show First 20 Lines • Show All 1,122 Lines • ▼ Show 20 LinesnormalizeForInvokeSafepoint(BasicBlock *BB, BasicBlock *InvokeParent,
// At this point, we can safely insert a gc.relocate or gc.result as the first // At this point, we can safely insert a gc.relocate or gc.result as the first
// instruction in Ret if needed. // instruction in Ret if needed.
return Ret; return Ret;
} }
// Create new attribute set containing only attributes which can be transferred // Create new attribute set containing only attributes which can be transferred
// from original call to the safepoint. // from original call to the safepoint.
static AttributeSet legalizeCallAttributes(AttributeSet AS) { static AttributeList legalizeCallAttributes(AttributeList AS) {
AttributeSet Ret; AttributeList Ret;
for (unsigned Slot = 0; Slot < AS.getNumSlots(); Slot++) { for (unsigned Slot = 0; Slot < AS.getNumSlots(); Slot++) {
unsigned Index = AS.getSlotIndex(Slot); unsigned Index = AS.getSlotIndex(Slot);
if (Index == AttributeSet::ReturnIndex || if (Index == AttributeList::ReturnIndex ||
Index == AttributeSet::FunctionIndex) { Index == AttributeList::FunctionIndex) {
for (Attribute Attr : make_range(AS.begin(Slot), AS.end(Slot))) { for (Attribute Attr : make_range(AS.begin(Slot), AS.end(Slot))) {
// Do not allow certain attributes - just skip them // Do not allow certain attributes - just skip them
// Safepoint can not be read only or read none. // Safepoint can not be read only or read none.
if (Attr.hasAttribute(Attribute::ReadNone) || if (Attr.hasAttribute(Attribute::ReadNone) ||
Attr.hasAttribute(Attribute::ReadOnly)) Attr.hasAttribute(Attribute::ReadOnly))
continue; continue;
// These attributes control the generation of the gc.statepoint call / // These attributes control the generation of the gc.statepoint call /
// invoke itself; and once the gc.statepoint is in place, they're of no // invoke itself; and once the gc.statepoint is in place, they're of no
// use. // use.
if (isStatepointDirectiveAttr(Attr)) if (isStatepointDirectiveAttr(Attr))
continue; continue;
Ret = Ret.addAttributes( Ret = Ret.addAttributes(
AS.getContext(), Index, AS.getContext(), Index,
AttributeSet::get(AS.getContext(), Index, AttrBuilder(Attr))); AttributeList::get(AS.getContext(), Index, AttrBuilder(Attr)));
} }
} }
// Just skip parameter attributes for now // Just skip parameter attributes for now
} }
return Ret; return Ret;
} }
▲ Show 20 Lines • Show All 134 Lines • ▼ Show 20 Lines#endif
} }
}; };
} }
static StringRef getDeoptLowering(CallSite CS) { static StringRef getDeoptLowering(CallSite CS) {
const char *DeoptLowering = "deopt-lowering"; const char *DeoptLowering = "deopt-lowering";
if (CS.hasFnAttr(DeoptLowering)) { if (CS.hasFnAttr(DeoptLowering)) {
// FIXME: CallSite has a *really* confusing interface around attributes // FIXME: CallSite has a *really* confusing interface around attributes
// with values. // with values.
const AttributeSet &CSAS = CS.getAttributes(); const AttributeList &CSAS = CS.getAttributes();
if (CSAS.hasAttribute(AttributeSet::FunctionIndex, if (CSAS.hasAttribute(AttributeList::FunctionIndex, DeoptLowering))
DeoptLowering)) return CSAS.getAttribute(AttributeList::FunctionIndex, DeoptLowering)
return CSAS.getAttribute(AttributeSet::FunctionIndex, .getValueAsString();
DeoptLowering).getValueAsString();
Function *F = CS.getCalledFunction(); Function *F = CS.getCalledFunction();
assert(F && F->hasFnAttribute(DeoptLowering)); assert(F && F->hasFnAttribute(DeoptLowering));
return F->getFnAttribute(DeoptLowering).getValueAsString(); return F->getFnAttribute(DeoptLowering).getValueAsString();
} }
return "live-through"; return "live-through";
} }
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines if (F->getIntrinsicID() == Intrinsic::experimental_deoptimize) {
F->getParent()->getOrInsertFunction("__llvm_deoptimize", FTy); F->getParent()->getOrInsertFunction("__llvm_deoptimize", FTy);
IsDeoptimize = true; IsDeoptimize = true;
} }
} }
// Create the statepoint given all the arguments // Create the statepoint given all the arguments
Instruction *Token = nullptr; Instruction *Token = nullptr;
AttributeSet ReturnAttrs; AttributeList ReturnAttrs;
if (CS.isCall()) { if (CS.isCall()) {
CallInst *ToReplace = cast<CallInst>(CS.getInstruction()); CallInst *ToReplace = cast<CallInst>(CS.getInstruction());
CallInst *Call = Builder.CreateGCStatepointCall( CallInst *Call = Builder.CreateGCStatepointCall(
StatepointID, NumPatchBytes, CallTarget, Flags, CallArgs, StatepointID, NumPatchBytes, CallTarget, Flags, CallArgs,
TransitionArgs, DeoptArgs, GCArgs, "safepoint_token"); TransitionArgs, DeoptArgs, GCArgs, "safepoint_token");
Call->setTailCallKind(ToReplace->getTailCallKind()); Call->setTailCallKind(ToReplace->getTailCallKind());
Call->setCallingConv(ToReplace->getCallingConv()); Call->setCallingConv(ToReplace->getCallingConv());
// Currently we will fail on parameter attributes and on certain // Currently we will fail on parameter attributes and on certain
// function attributes. // function attributes.
AttributeSet NewAttrs = legalizeCallAttributes(ToReplace->getAttributes()); AttributeList NewAttrs = legalizeCallAttributes(ToReplace->getAttributes());
// In case if we can handle this set of attributes - set up function attrs // In case if we can handle this set of attributes - set up function attrs
// directly on statepoint and return attrs later for gc_result intrinsic. // directly on statepoint and return attrs later for gc_result intrinsic.
Call->setAttributes(NewAttrs.getFnAttributes()); Call->setAttributes(NewAttrs.getFnAttributes());
ReturnAttrs = NewAttrs.getRetAttributes(); ReturnAttrs = NewAttrs.getRetAttributes();
Token = Call; Token = Call;
// Put the following gc_result and gc_relocate calls immediately after the // Put the following gc_result and gc_relocate calls immediately after the
Show All 11 Lines InvokeInst *Invoke = Builder.CreateGCStatepointInvoke(
StatepointID, NumPatchBytes, CallTarget, ToReplace->getNormalDest(), StatepointID, NumPatchBytes, CallTarget, ToReplace->getNormalDest(),
ToReplace->getUnwindDest(), Flags, CallArgs, TransitionArgs, DeoptArgs, ToReplace->getUnwindDest(), Flags, CallArgs, TransitionArgs, DeoptArgs,
GCArgs, "statepoint_token"); GCArgs, "statepoint_token");
Invoke->setCallingConv(ToReplace->getCallingConv()); Invoke->setCallingConv(ToReplace->getCallingConv());
// Currently we will fail on parameter attributes and on certain // Currently we will fail on parameter attributes and on certain
// function attributes. // function attributes.
AttributeSet NewAttrs = legalizeCallAttributes(ToReplace->getAttributes()); AttributeList NewAttrs = legalizeCallAttributes(ToReplace->getAttributes());
// In case if we can handle this set of attributes - set up function attrs // In case if we can handle this set of attributes - set up function attrs
// directly on statepoint and return attrs later for gc_result intrinsic. // directly on statepoint and return attrs later for gc_result intrinsic.
Invoke->setAttributes(NewAttrs.getFnAttributes()); Invoke->setAttributes(NewAttrs.getFnAttributes());
ReturnAttrs = NewAttrs.getRetAttributes(); ReturnAttrs = NewAttrs.getRetAttributes();
Token = Invoke; Token = Invoke;
// Generate gc relocates in exceptional path // Generate gc relocates in exceptional path
▲ Show 20 Lines • Show All 859 Lines • ▼ Show 20 Linesstatic void RemoveNonValidAttrAtIndex(LLVMContext &Ctx, AttrHolder &AH,
if (AH.getDereferenceableOrNullBytes(Index)) if (AH.getDereferenceableOrNullBytes(Index))
R.addAttribute(Attribute::get(Ctx, Attribute::DereferenceableOrNull, R.addAttribute(Attribute::get(Ctx, Attribute::DereferenceableOrNull,
AH.getDereferenceableOrNullBytes(Index))); AH.getDereferenceableOrNullBytes(Index)));
if (AH.doesNotAlias(Index)) if (AH.doesNotAlias(Index))
R.addAttribute(Attribute::NoAlias); R.addAttribute(Attribute::NoAlias);
if (!R.empty()) if (!R.empty())
AH.setAttributes(AH.getAttributes().removeAttributes( AH.setAttributes(AH.getAttributes().removeAttributes(
Ctx, Index, AttributeSet::get(Ctx, Index, R))); Ctx, Index, AttributeList::get(Ctx, Index, R)));
} }
void void
RewriteStatepointsForGC::stripNonValidAttributesFromPrototype(Function &F) { RewriteStatepointsForGC::stripNonValidAttributesFromPrototype(Function &F) {
LLVMContext &Ctx = F.getContext(); LLVMContext &Ctx = F.getContext();
for (Argument &A : F.args()) for (Argument &A : F.args())
if (isa<PointerType>(A.getType())) if (isa<PointerType>(A.getType()))
RemoveNonValidAttrAtIndex(Ctx, F, A.getArgNo() + 1); RemoveNonValidAttrAtIndex(Ctx, F, A.getArgNo() + 1);
if (isa<PointerType>(F.getReturnType())) if (isa<PointerType>(F.getReturnType()))
RemoveNonValidAttrAtIndex(Ctx, F, AttributeSet::ReturnIndex); RemoveNonValidAttrAtIndex(Ctx, F, AttributeList::ReturnIndex);
} }
void RewriteStatepointsForGC::stripNonValidAttributesFromBody(Function &F) { void RewriteStatepointsForGC::stripNonValidAttributesFromBody(Function &F) {
if (F.empty()) if (F.empty())
return; return;
LLVMContext &Ctx = F.getContext(); LLVMContext &Ctx = F.getContext();
MDBuilder Builder(Ctx); MDBuilder Builder(Ctx);
Show All 18 Lines if (const MDNode *MD = I.getMetadata(LLVMContext::MD_tbaa)) {
I.setMetadata(LLVMContext::MD_tbaa, MutableTBAA); I.setMetadata(LLVMContext::MD_tbaa, MutableTBAA);
} }
if (CallSite CS = CallSite(&I)) { if (CallSite CS = CallSite(&I)) {
for (int i = 0, e = CS.arg_size(); i != e; i++) for (int i = 0, e = CS.arg_size(); i != e; i++)
if (isa<PointerType>(CS.getArgument(i)->getType())) if (isa<PointerType>(CS.getArgument(i)->getType()))
RemoveNonValidAttrAtIndex(Ctx, CS, i + 1); RemoveNonValidAttrAtIndex(Ctx, CS, i + 1);
if (isa<PointerType>(CS.getType())) if (isa<PointerType>(CS.getType()))
RemoveNonValidAttrAtIndex(Ctx, CS, AttributeSet::ReturnIndex); RemoveNonValidAttrAtIndex(Ctx, CS, AttributeList::ReturnIndex);
} }
} }
} }
/// Returns true if this function should be rewritten by this pass. The main /// Returns true if this function should be rewritten by this pass. The main
/// point of this function is as an extension point for custom logic. /// point of this function is as an extension point for custom logic.
static bool shouldRewriteStatepointsIn(Function &F) { static bool shouldRewriteStatepointsIn(Function &F) {
// TODO: This should check the GCStrategy // TODO: This should check the GCStrategy
▲ Show 20 Lines • Show All 339 Lines • Show Last 20 Lines

llvm/trunk/lib/Transforms/Utils/BuildLibCalls.cpp

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Linesstatic bool setDoesNotAlias(Function &F, unsigned n) {
if (F.doesNotAlias(n)) if (F.doesNotAlias(n))
return false; return false;
F.setDoesNotAlias(n); F.setDoesNotAlias(n);
++NumNoAlias; ++NumNoAlias;
return true; return true;
} }
static bool setNonNull(Function &F, unsigned n) { static bool setNonNull(Function &F, unsigned n) {
assert((n != AttributeSet::ReturnIndex || assert(
F.getReturnType()->isPointerTy()) && (n != AttributeList::ReturnIndex || F.getReturnType()->isPointerTy()) &&
"nonnull applies only to pointers"); "nonnull applies only to pointers");
if (F.getAttributes().hasAttribute(n, Attribute::NonNull)) if (F.getAttributes().hasAttribute(n, Attribute::NonNull))
return false; return false;
F.addAttribute(n, Attribute::NonNull); F.addAttribute(n, Attribute::NonNull);
++NumNonNull; ++NumNonNull;
return true; return true;
} }
bool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) { bool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) {
▲ Show 20 Lines • Show All 568 Lines • ▼ Show 20 Linesbool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) {
case LibFunc_Znwm: // new(unsigned long) case LibFunc_Znwm: // new(unsigned long)
case LibFunc_Znaj: // new[](unsigned int) case LibFunc_Znaj: // new[](unsigned int)
case LibFunc_Znam: // new[](unsigned long) case LibFunc_Znam: // new[](unsigned long)
case LibFunc_msvc_new_int: // new(unsigned int) case LibFunc_msvc_new_int: // new(unsigned int)
case LibFunc_msvc_new_longlong: // new(unsigned long long) case LibFunc_msvc_new_longlong: // new(unsigned long long)
case LibFunc_msvc_new_array_int: // new[](unsigned int) case LibFunc_msvc_new_array_int: // new[](unsigned int)
case LibFunc_msvc_new_array_longlong: // new[](unsigned long long) case LibFunc_msvc_new_array_longlong: // new[](unsigned long long)
// Operator new always returns a nonnull noalias pointer // Operator new always returns a nonnull noalias pointer
Changed |= setNonNull(F, AttributeSet::ReturnIndex); Changed |= setNonNull(F, AttributeList::ReturnIndex);
Changed |= setDoesNotAlias(F, AttributeSet::ReturnIndex); Changed |= setDoesNotAlias(F, AttributeList::ReturnIndex);
return Changed; return Changed;
//TODO: add LibFunc entries for: //TODO: add LibFunc entries for:
//case LibFunc_memset_pattern4: //case LibFunc_memset_pattern4:
//case LibFunc_memset_pattern8: //case LibFunc_memset_pattern8:
case LibFunc_memset_pattern16: case LibFunc_memset_pattern16:
Changed |= setOnlyAccessesArgMemory(F); Changed |= setOnlyAccessesArgMemory(F);
Changed |= setDoesNotCapture(F, 1); Changed |= setDoesNotCapture(F, 1);
Changed |= setDoesNotCapture(F, 2); Changed |= setDoesNotCapture(F, 2);
▲ Show 20 Lines • Show All 109 Lines • ▼ Show 20 Lines
Value *llvm::emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize, Value *llvm::emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize,
IRBuilder<> &B, const DataLayout &DL, IRBuilder<> &B, const DataLayout &DL,
const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
if (!TLI->has(LibFunc_memcpy_chk)) if (!TLI->has(LibFunc_memcpy_chk))
return nullptr; return nullptr;
Module *M = B.GetInsertBlock()->getModule(); Module *M = B.GetInsertBlock()->getModule();
AttributeSet AS; AttributeList AS;
AS = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex, AS = AttributeList::get(M->getContext(), AttributeList::FunctionIndex,
Attribute::NoUnwind); Attribute::NoUnwind);
LLVMContext &Context = B.GetInsertBlock()->getContext(); LLVMContext &Context = B.GetInsertBlock()->getContext();
Value *MemCpy = M->getOrInsertFunction( Value *MemCpy = M->getOrInsertFunction(
"__memcpy_chk", AttributeSet::get(M->getContext(), AS), B.getInt8PtrTy(), "__memcpy_chk", AttributeList::get(M->getContext(), AS), B.getInt8PtrTy(),
B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context), B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context),
DL.getIntPtrType(Context), nullptr); DL.getIntPtrType(Context), nullptr);
Dst = castToCStr(Dst, B); Dst = castToCStr(Dst, B);
Src = castToCStr(Src, B); Src = castToCStr(Src, B);
CallInst *CI = B.CreateCall(MemCpy, {Dst, Src, Len, ObjSize}); CallInst *CI = B.CreateCall(MemCpy, {Dst, Src, Len, ObjSize});
if (const Function *F = dyn_cast<Function>(MemCpy->stripPointerCasts())) if (const Function *F = dyn_cast<Function>(MemCpy->stripPointerCasts()))
CI->setCallingConv(F->getCallingConv()); CI->setCallingConv(F->getCallingConv());
return CI; return CI;
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines if (!Op->getType()->isDoubleTy()) {
else else
NameBuffer += 'l'; NameBuffer += 'l';
Name = NameBuffer; Name = NameBuffer;
} }
} }
Value *llvm::emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilder<> &B, Value *llvm::emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilder<> &B,
const AttributeSet &Attrs) { const AttributeList &Attrs) {
SmallString<20> NameBuffer; SmallString<20> NameBuffer;
appendTypeSuffix(Op, Name, NameBuffer); appendTypeSuffix(Op, Name, NameBuffer);
Module *M = B.GetInsertBlock()->getModule(); Module *M = B.GetInsertBlock()->getModule();
Value *Callee = M->getOrInsertFunction(Name, Op->getType(), Value *Callee = M->getOrInsertFunction(Name, Op->getType(),
Op->getType(), nullptr); Op->getType(), nullptr);
CallInst *CI = B.CreateCall(Callee, Op, Name); CallInst *CI = B.CreateCall(Callee, Op, Name);
CI->setAttributes(Attrs); CI->setAttributes(Attrs);
if (const Function *F = dyn_cast<Function>(Callee->stripPointerCasts())) if (const Function *F = dyn_cast<Function>(Callee->stripPointerCasts()))
CI->setCallingConv(F->getCallingConv()); CI->setCallingConv(F->getCallingConv());
return CI; return CI;
} }
Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name, Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name,
IRBuilder<> &B, const AttributeSet &Attrs) { IRBuilder<> &B, const AttributeList &Attrs) {
SmallString<20> NameBuffer; SmallString<20> NameBuffer;
appendTypeSuffix(Op1, Name, NameBuffer); appendTypeSuffix(Op1, Name, NameBuffer);
Module *M = B.GetInsertBlock()->getModule(); Module *M = B.GetInsertBlock()->getModule();
Value *Callee = M->getOrInsertFunction(Name, Op1->getType(), Op1->getType(), Value *Callee = M->getOrInsertFunction(Name, Op1->getType(), Op1->getType(),
Op2->getType(), nullptr); Op2->getType(), nullptr);
CallInst *CI = B.CreateCall(Callee, {Op1, Op2}, Name); CallInst *CI = B.CreateCall(Callee, {Op1, Op2}, Name);
CI->setAttributes(Attrs); CI->setAttributes(Attrs);
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

llvm/trunk/lib/Transforms/Utils/CloneFunction.cpp

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 Linesvoid llvm::CloneFunctionInto(Function *NewFunc, const Function *OldFunc,
ValueMaterializer *Materializer) { ValueMaterializer *Materializer) {
assert(NameSuffix && "NameSuffix cannot be null!"); assert(NameSuffix && "NameSuffix cannot be null!");
#ifndef NDEBUG #ifndef NDEBUG
for (const Argument &I : OldFunc->args()) for (const Argument &I : OldFunc->args())
assert(VMap.count(&I) && "No mapping from source argument specified!"); assert(VMap.count(&I) && "No mapping from source argument specified!");
#endif #endif
// Copy all attributes other than those stored in the AttributeSet. We need // Copy all attributes other than those stored in the AttributeList. We need
// to remap the parameter indices of the AttributeSet. // to remap the parameter indices of the AttributeList.
AttributeSet NewAttrs = NewFunc->getAttributes(); AttributeList NewAttrs = NewFunc->getAttributes();
NewFunc->copyAttributesFrom(OldFunc); NewFunc->copyAttributesFrom(OldFunc);
NewFunc->setAttributes(NewAttrs); NewFunc->setAttributes(NewAttrs);
// Fix up the personality function that got copied over. // Fix up the personality function that got copied over.
if (OldFunc->hasPersonalityFn()) if (OldFunc->hasPersonalityFn())
NewFunc->setPersonalityFn( NewFunc->setPersonalityFn(
MapValue(OldFunc->getPersonalityFn(), VMap, MapValue(OldFunc->getPersonalityFn(), VMap,
ModuleLevelChanges ? RF_None : RF_NoModuleLevelChanges, ModuleLevelChanges ? RF_None : RF_NoModuleLevelChanges,
TypeMapper, Materializer)); TypeMapper, Materializer));
AttributeSet OldAttrs = OldFunc->getAttributes(); AttributeList OldAttrs = OldFunc->getAttributes();
// Clone any argument attributes that are present in the VMap. // Clone any argument attributes that are present in the VMap.
for (const Argument &OldArg : OldFunc->args()) for (const Argument &OldArg : OldFunc->args())
if (Argument *NewArg = dyn_cast<Argument>(VMap[&OldArg])) { if (Argument *NewArg = dyn_cast<Argument>(VMap[&OldArg])) {
AttributeSet attrs = AttributeList attrs = OldAttrs.getParamAttributes(OldArg.getArgNo() + 1);
OldAttrs.getParamAttributes(OldArg.getArgNo() + 1);
if (attrs.getNumSlots() > 0) if (attrs.getNumSlots() > 0)
NewArg->addAttr(attrs); NewArg->addAttr(attrs);
} }
NewFunc->setAttributes( NewFunc->setAttributes(
NewFunc->getAttributes() NewFunc->getAttributes()
.addAttributes(NewFunc->getContext(), AttributeSet::ReturnIndex, .addAttributes(NewFunc->getContext(), AttributeList::ReturnIndex,
OldAttrs.getRetAttributes()) OldAttrs.getRetAttributes())
.addAttributes(NewFunc->getContext(), AttributeSet::FunctionIndex, .addAttributes(NewFunc->getContext(), AttributeList::FunctionIndex,
OldAttrs.getFnAttributes())); OldAttrs.getFnAttributes()));
SmallVector<std::pair<unsigned, MDNode *>, 1> MDs; SmallVector<std::pair<unsigned, MDNode *>, 1> MDs;
OldFunc->getAllMetadata(MDs); OldFunc->getAllMetadata(MDs);
for (auto MD : MDs) for (auto MD : MDs)
NewFunc->addMetadata( NewFunc->addMetadata(
MD.first, MD.first,
*MapMetadata(MD.second, VMap, *MapMetadata(MD.second, VMap,
▲ Show 20 Lines • Show All 658 Lines • Show Last 20 Lines

llvm/trunk/lib/Transforms/Utils/CodeExtractor.cpp

Show First 20 Lines • Show All 356 Lines • ▼ Show 20 Lines if (oldFunction->hasUWTable())
newFunction->setHasUWTable(); newFunction->setHasUWTable();
// Inherit all of the target dependent attributes. // Inherit all of the target dependent attributes.
// (e.g. If the extracted region contains a call to an x86.sse // (e.g. If the extracted region contains a call to an x86.sse
// instruction we need to make sure that the extracted region has the // instruction we need to make sure that the extracted region has the
// "target-features" attribute allowing it to be lowered. // "target-features" attribute allowing it to be lowered.
// FIXME: This should be changed to check to see if a specific // FIXME: This should be changed to check to see if a specific
// attribute can not be inherited. // attribute can not be inherited.
AttributeSet OldFnAttrs = oldFunction->getAttributes().getFnAttributes(); AttributeList OldFnAttrs = oldFunction->getAttributes().getFnAttributes();
AttrBuilder AB(OldFnAttrs, AttributeSet::FunctionIndex); AttrBuilder AB(OldFnAttrs, AttributeList::FunctionIndex);
for (const auto &Attr : AB.td_attrs()) for (const auto &Attr : AB.td_attrs())
newFunction->addFnAttr(Attr.first, Attr.second); newFunction->addFnAttr(Attr.first, Attr.second);
newFunction->getBasicBlockList().push_back(newRootNode); newFunction->getBasicBlockList().push_back(newRootNode);
// Create an iterator to name all of the arguments we inserted. // Create an iterator to name all of the arguments we inserted.
Function::arg_iterator AI = newFunction->arg_begin(); Function::arg_iterator AI = newFunction->arg_begin();
▲ Show 20 Lines • Show All 501 Lines • Show Last 20 Lines

llvm/trunk/lib/Transforms/Utils/FunctionComparator.cpp

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Linesint FunctionComparator::cmpMem(StringRef L, StringRef R) const {
if (int Res = cmpNumbers(L.size(), R.size())) if (int Res = cmpNumbers(L.size(), R.size()))
return Res; return Res;
// Compare strings lexicographically only when it is necessary: only when // Compare strings lexicographically only when it is necessary: only when
// strings are equal in size. // strings are equal in size.
return L.compare(R); return L.compare(R);
} }
int FunctionComparator::cmpAttrs(const AttributeSet L, int FunctionComparator::cmpAttrs(const AttributeList L,
const AttributeSet R) const { const AttributeList R) const {
if (int Res = cmpNumbers(L.getNumSlots(), R.getNumSlots())) if (int Res = cmpNumbers(L.getNumSlots(), R.getNumSlots()))
return Res; return Res;
for (unsigned i = 0, e = L.getNumSlots(); i != e; ++i) { for (unsigned i = 0, e = L.getNumSlots(); i != e; ++i) {
AttributeSet::iterator LI = L.begin(i), LE = L.end(i), RI = R.begin(i), AttributeList::iterator LI = L.begin(i), LE = L.end(i), RI = R.begin(i),
RE = R.end(i); RE = R.end(i);
for (; LI != LE && RI != RE; ++LI, ++RI) { for (; LI != LE && RI != RE; ++LI, ++RI) {
Attribute LA = *LI; Attribute LA = *LI;
Attribute RA = *RI; Attribute RA = *RI;
if (LA < RA) if (LA < RA)
return -1; return -1;
if (RA < LA) if (RA < LA)
return 1; return 1;
} }
▲ Show 20 Lines • Show All 827 Lines • Show Last 20 Lines

llvm/trunk/lib/Transforms/Utils/Local.cpp

Show First 20 Lines • Show All 2,117 Lines • ▼ Show 20 Lines
// in CodeGen. // in CodeGen.
void llvm::maybeMarkSanitizerLibraryCallNoBuiltin( void llvm::maybeMarkSanitizerLibraryCallNoBuiltin(
CallInst *CI, const TargetLibraryInfo *TLI) { CallInst *CI, const TargetLibraryInfo *TLI) {
Function *F = CI->getCalledFunction(); Function *F = CI->getCalledFunction();
LibFunc Func; LibFunc Func;
if (F && !F->hasLocalLinkage() && F->hasName() && if (F && !F->hasLocalLinkage() && F->hasName() &&
TLI->getLibFunc(F->getName(), Func) && TLI->hasOptimizedCodeGen(Func) && TLI->getLibFunc(F->getName(), Func) && TLI->hasOptimizedCodeGen(Func) &&
!F->doesNotAccessMemory()) !F->doesNotAccessMemory())
CI->addAttribute(AttributeSet::FunctionIndex, Attribute::NoBuiltin); CI->addAttribute(AttributeList::FunctionIndex, Attribute::NoBuiltin);
} }

llvm/trunk/lib/Transforms/Utils/ModuleUtils.cpp

Show First 20 Lines • Show All 147 Lines • ▼ Show 20 Linesstd::pair<Function *, Function *> llvm::createSanitizerCtorAndInitFunctions(
Function *Ctor = Function::Create( Function *Ctor = Function::Create(
FunctionType::get(Type::getVoidTy(M.getContext()), false), FunctionType::get(Type::getVoidTy(M.getContext()), false),
GlobalValue::InternalLinkage, CtorName, &M); GlobalValue::InternalLinkage, CtorName, &M);
BasicBlock *CtorBB = BasicBlock::Create(M.getContext(), "", Ctor); BasicBlock *CtorBB = BasicBlock::Create(M.getContext(), "", Ctor);
IRBuilder<> IRB(ReturnInst::Create(M.getContext(), CtorBB)); IRBuilder<> IRB(ReturnInst::Create(M.getContext(), CtorBB));
Function *InitFunction = Function *InitFunction =
checkSanitizerInterfaceFunction(M.getOrInsertFunction( checkSanitizerInterfaceFunction(M.getOrInsertFunction(
InitName, FunctionType::get(IRB.getVoidTy(), InitArgTypes, false), InitName, FunctionType::get(IRB.getVoidTy(), InitArgTypes, false),
AttributeSet())); AttributeList()));
InitFunction->setLinkage(Function::ExternalLinkage); InitFunction->setLinkage(Function::ExternalLinkage);
IRB.CreateCall(InitFunction, InitArgs); IRB.CreateCall(InitFunction, InitArgs);
if (!VersionCheckName.empty()) { if (!VersionCheckName.empty()) {
Function *VersionCheckFunction = Function *VersionCheckFunction =
checkSanitizerInterfaceFunction(M.getOrInsertFunction( checkSanitizerInterfaceFunction(M.getOrInsertFunction(
VersionCheckName, FunctionType::get(IRB.getVoidTy(), {}, false), VersionCheckName, FunctionType::get(IRB.getVoidTy(), {}, false),
AttributeSet())); AttributeList()));
IRB.CreateCall(VersionCheckFunction, {}); IRB.CreateCall(VersionCheckFunction, {});
} }
return std::make_pair(Ctor, InitFunction); return std::make_pair(Ctor, InitFunction);
} }
void llvm::filterDeadComdatFunctions( void llvm::filterDeadComdatFunctions(
Module &M, SmallVectorImpl<Function *> &DeadComdatFunctions) { Module &M, SmallVectorImpl<Function *> &DeadComdatFunctions) {
// Build a map from the comdat to the number of entries in that comdat we // Build a map from the comdat to the number of entries in that comdat we
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

llvm/trunk/lib/Transforms/Utils/SimplifyLibCalls.cpp

Show First 20 Lines • Show All 803 Lines • ▼ Show 20 LinesValue *LibCallSimplifier::optimizeMemMove(CallInst *CI, IRBuilder<> &B) {
// memmove(x, y, n) -> llvm.memmove(x, y, n, 1) // memmove(x, y, n) -> llvm.memmove(x, y, n, 1)
B.CreateMemMove(CI->getArgOperand(0), CI->getArgOperand(1), B.CreateMemMove(CI->getArgOperand(0), CI->getArgOperand(1),
CI->getArgOperand(2), 1); CI->getArgOperand(2), 1);
return CI->getArgOperand(0); return CI->getArgOperand(0);
} }
// TODO: Does this belong in BuildLibCalls or should all of those similar // TODO: Does this belong in BuildLibCalls or should all of those similar
// functions be moved here? // functions be moved here?
static Value *emitCalloc(Value *Num, Value *Size, const AttributeSet &Attrs, static Value *emitCalloc(Value *Num, Value *Size, const AttributeList &Attrs,
IRBuilder<> &B, const TargetLibraryInfo &TLI) { IRBuilder<> &B, const TargetLibraryInfo &TLI) {
LibFunc Func; LibFunc Func;
if (!TLI.getLibFunc("calloc", Func) || !TLI.has(Func)) if (!TLI.getLibFunc("calloc", Func) || !TLI.has(Func))
return nullptr; return nullptr;
Module *M = B.GetInsertBlock()->getModule(); Module *M = B.GetInsertBlock()->getModule();
const DataLayout &DL = M->getDataLayout(); const DataLayout &DL = M->getDataLayout();
IntegerType *PtrType = DL.getIntPtrType((B.GetInsertBlock()->getContext())); IntegerType *PtrType = DL.getIntPtrType((B.GetInsertBlock()->getContext()));
▲ Show 20 Lines • Show All 799 Lines • ▼ Show 20 LinesValue *LibCallSimplifier::optimizeErrorReporting(CallInst *CI, IRBuilder<> &B,
// functions that the frontend might not understand as builtins. // functions that the frontend might not understand as builtins.
// This heuristic was suggested in: // This heuristic was suggested in:
// Improving Static Branch Prediction in a Compiler // Improving Static Branch Prediction in a Compiler
// Brian L. Deitrich, Ben-Chung Cheng, Wen-mei W. Hwu // Brian L. Deitrich, Ben-Chung Cheng, Wen-mei W. Hwu
// Proceedings of PACT'98, Oct. 1998, IEEE // Proceedings of PACT'98, Oct. 1998, IEEE
if (!CI->hasFnAttr(Attribute::Cold) && if (!CI->hasFnAttr(Attribute::Cold) &&
isReportingError(Callee, CI, StreamArg)) { isReportingError(Callee, CI, StreamArg)) {
CI->addAttribute(AttributeSet::FunctionIndex, Attribute::Cold); CI->addAttribute(AttributeList::FunctionIndex, Attribute::Cold);
} }
return nullptr; return nullptr;
} }
static bool isReportingError(Function *Callee, CallInst *CI, int StreamArg) { static bool isReportingError(Function *Callee, CallInst *CI, int StreamArg) {
if (!ColdErrorCalls || !Callee || !Callee->isDeclaration()) if (!ColdErrorCalls || !Callee || !Callee->isDeclaration())
return false; return false;
▲ Show 20 Lines • Show All 777 Lines • Show Last 20 Lines

llvm/trunk/unittests/ExecutionEngine/Orc/IndirectionUtilsTest.cpp

Show All 14 Lines
using namespace llvm; using namespace llvm;
namespace { namespace {
TEST(IndirectionUtilsTest, MakeStub) { TEST(IndirectionUtilsTest, MakeStub) {
LLVMContext Context; LLVMContext Context;
ModuleBuilder MB(Context, "x86_64-apple-macosx10.10", ""); ModuleBuilder MB(Context, "x86_64-apple-macosx10.10", "");
Function *F = MB.createFunctionDecl<void(DummyStruct, DummyStruct)>(""); Function *F = MB.createFunctionDecl<void(DummyStruct, DummyStruct)>("");
SmallVector<AttributeSet, 4> Attrs; SmallVector<AttributeList, 4> Attrs;
Attrs.push_back( Attrs.push_back(
AttributeSet::get(MB.getModule()->getContext(), 1U, AttributeList::get(MB.getModule()->getContext(), 1U,
AttrBuilder().addAttribute(Attribute::StructRet))); AttrBuilder().addAttribute(Attribute::StructRet)));
Attrs.push_back( Attrs.push_back(
AttributeSet::get(MB.getModule()->getContext(), 2U, AttributeList::get(MB.getModule()->getContext(), 2U,
AttrBuilder().addAttribute(Attribute::ByVal))); AttrBuilder().addAttribute(Attribute::ByVal)));
Attrs.push_back( Attrs.push_back(
AttributeSet::get(MB.getModule()->getContext(), ~0U, AttributeList::get(MB.getModule()->getContext(), ~0U,
AttrBuilder().addAttribute(Attribute::NoUnwind))); AttrBuilder().addAttribute(Attribute::NoUnwind)));
F->setAttributes(AttributeSet::get(MB.getModule()->getContext(), Attrs)); F->setAttributes(AttributeList::get(MB.getModule()->getContext(), Attrs));
auto ImplPtr = orc::createImplPointer(*F->getType(), *MB.getModule(), "", nullptr); auto ImplPtr = orc::createImplPointer(*F->getType(), *MB.getModule(), "", nullptr);
orc::makeStub(*F, *ImplPtr); orc::makeStub(*F, *ImplPtr);
auto II = F->getEntryBlock().begin(); auto II = F->getEntryBlock().begin();
EXPECT_TRUE(isa<LoadInst>(*II)) << "First instruction of stub should be a load."; EXPECT_TRUE(isa<LoadInst>(*II)) << "First instruction of stub should be a load.";
auto *Call = dyn_cast<CallInst>(std::next(II)); auto *Call = dyn_cast<CallInst>(std::next(II));
EXPECT_TRUE(Call != nullptr) << "Second instruction of stub should be a call."; EXPECT_TRUE(Call != nullptr) << "Second instruction of stub should be a call.";
EXPECT_TRUE(Call->isTailCall()) << "Indirect call from stub should be tail call."; EXPECT_TRUE(Call->isTailCall()) << "Indirect call from stub should be tail call.";
EXPECT_TRUE(Call->hasStructRetAttr()) EXPECT_TRUE(Call->hasStructRetAttr())
<< "makeStub should propagate sret attr on 1st argument."; << "makeStub should propagate sret attr on 1st argument.";
EXPECT_TRUE(Call->paramHasAttr(2U, Attribute::ByVal)) EXPECT_TRUE(Call->paramHasAttr(2U, Attribute::ByVal))
<< "makeStub should propagate byval attr on 2nd argument."; << "makeStub should propagate byval attr on 2nd argument.";
} }
} }

llvm/trunk/unittests/IR/AttributesTest.cpp

Show All 15 Lines
TEST(Attributes, Uniquing) { TEST(Attributes, Uniquing) {
LLVMContext C; LLVMContext C;
Attribute AttrA = Attribute::get(C, Attribute::AlwaysInline); Attribute AttrA = Attribute::get(C, Attribute::AlwaysInline);
Attribute AttrB = Attribute::get(C, Attribute::AlwaysInline); Attribute AttrB = Attribute::get(C, Attribute::AlwaysInline);
EXPECT_EQ(AttrA, AttrB); EXPECT_EQ(AttrA, AttrB);
AttributeSet ASs[] = { AttributeList ASs[] = {AttributeList::get(C, 1, Attribute::ZExt),
AttributeSet::get(C, 1, Attribute::ZExt), AttributeList::get(C, 2, Attribute::SExt)};
AttributeSet::get(C, 2, Attribute::SExt)
};
AttributeSet SetA = AttributeSet::get(C, ASs); AttributeList SetA = AttributeList::get(C, ASs);
AttributeSet SetB = AttributeSet::get(C, ASs); AttributeList SetB = AttributeList::get(C, ASs);
EXPECT_EQ(SetA, SetB); EXPECT_EQ(SetA, SetB);
} }
TEST(Attributes, Ordering) { TEST(Attributes, Ordering) {
LLVMContext C; LLVMContext C;
Attribute Align4 = Attribute::get(C, Attribute::Alignment, 4); Attribute Align4 = Attribute::get(C, Attribute::Alignment, 4);
Attribute Align5 = Attribute::get(C, Attribute::Alignment, 5); Attribute Align5 = Attribute::get(C, Attribute::Alignment, 5);
Attribute Deref4 = Attribute::get(C, Attribute::Dereferenceable, 4); Attribute Deref4 = Attribute::get(C, Attribute::Dereferenceable, 4);
Attribute Deref5 = Attribute::get(C, Attribute::Dereferenceable, 5); Attribute Deref5 = Attribute::get(C, Attribute::Dereferenceable, 5);
EXPECT_TRUE(Align4 < Align5); EXPECT_TRUE(Align4 < Align5);
EXPECT_TRUE(Align4 < Deref4); EXPECT_TRUE(Align4 < Deref4);
EXPECT_TRUE(Align4 < Deref5); EXPECT_TRUE(Align4 < Deref5);
EXPECT_TRUE(Align5 < Deref4); EXPECT_TRUE(Align5 < Deref4);
AttributeSet ASs[] = { AttributeList ASs[] = {AttributeList::get(C, 2, Attribute::ZExt),
AttributeSet::get(C, 2, Attribute::ZExt), AttributeList::get(C, 1, Attribute::SExt)};
AttributeSet::get(C, 1, Attribute::SExt)
};
AttributeSet SetA = AttributeSet::get(C, ASs); AttributeList SetA = AttributeList::get(C, ASs);
AttributeSet SetB = SetA.removeAttributes(C, 1, ASs[1]); AttributeList SetB = SetA.removeAttributes(C, 1, ASs[1]);
EXPECT_NE(SetA, SetB); EXPECT_NE(SetA, SetB);
} }
} // end anonymous namespace } // end anonymous namespace

llvm/trunk/unittests/IR/InstructionsTest.cpp

Show First 20 Lines • Show All 511 Lines • ▼ Show 20 Lines for (CallInst::TailCallKind TCK : Kinds) {
EXPECT_EQ(Call->getTailCallKind(), Clone->getTailCallKind()); EXPECT_EQ(Call->getTailCallKind(), Clone->getTailCallKind());
} }
Call->setTailCallKind(CallInst::TCK_None); Call->setTailCallKind(CallInst::TCK_None);
// Test cloning an attribute. // Test cloning an attribute.
{ {
AttrBuilder AB; AttrBuilder AB;
AB.addAttribute(Attribute::ReadOnly); AB.addAttribute(Attribute::ReadOnly);
Call->setAttributes(AttributeSet::get(C, AttributeSet::FunctionIndex, AB)); Call->setAttributes(
AttributeList::get(C, AttributeList::FunctionIndex, AB));
std::unique_ptr<CallInst> Clone(cast<CallInst>(Call->clone())); std::unique_ptr<CallInst> Clone(cast<CallInst>(Call->clone()));
EXPECT_TRUE(Clone->onlyReadsMemory()); EXPECT_TRUE(Clone->onlyReadsMemory());
} }
} }
TEST(InstructionsTest, AlterCallBundles) { TEST(InstructionsTest, AlterCallBundles) {
LLVMContext C; LLVMContext C;
Type *Int32Ty = Type::getInt32Ty(C); Type *Int32Ty = Type::getInt32Ty(C);
Type *FnTy = FunctionType::get(Int32Ty, Int32Ty, /*isVarArg=*/false); Type *FnTy = FunctionType::get(Int32Ty, Int32Ty, /*isVarArg=*/false);
Value *Callee = Constant::getNullValue(FnTy->getPointerTo()); Value *Callee = Constant::getNullValue(FnTy->getPointerTo());
Value *Args[] = {ConstantInt::get(Int32Ty, 42)}; Value *Args[] = {ConstantInt::get(Int32Ty, 42)};
OperandBundleDef OldBundle("before", UndefValue::get(Int32Ty)); OperandBundleDef OldBundle("before", UndefValue::get(Int32Ty));
std::unique_ptr<CallInst> Call( std::unique_ptr<CallInst> Call(
CallInst::Create(Callee, Args, OldBundle, "result")); CallInst::Create(Callee, Args, OldBundle, "result"));
Call->setTailCallKind(CallInst::TailCallKind::TCK_NoTail); Call->setTailCallKind(CallInst::TailCallKind::TCK_NoTail);
AttrBuilder AB; AttrBuilder AB;
AB.addAttribute(Attribute::Cold); AB.addAttribute(Attribute::Cold);
Call->setAttributes(AttributeSet::get(C, AttributeSet::FunctionIndex, AB)); Call->setAttributes(AttributeList::get(C, AttributeList::FunctionIndex, AB));
Call->setDebugLoc(DebugLoc(MDNode::get(C, None))); Call->setDebugLoc(DebugLoc(MDNode::get(C, None)));
OperandBundleDef NewBundle("after", ConstantInt::get(Int32Ty, 7)); OperandBundleDef NewBundle("after", ConstantInt::get(Int32Ty, 7));
std::unique_ptr<CallInst> Clone(CallInst::Create(Call.get(), NewBundle)); std::unique_ptr<CallInst> Clone(CallInst::Create(Call.get(), NewBundle));
EXPECT_EQ(Call->getNumArgOperands(), Clone->getNumArgOperands()); EXPECT_EQ(Call->getNumArgOperands(), Clone->getNumArgOperands());
EXPECT_EQ(Call->getArgOperand(0), Clone->getArgOperand(0)); EXPECT_EQ(Call->getArgOperand(0), Clone->getArgOperand(0));
EXPECT_EQ(Call->getCallingConv(), Clone->getCallingConv()); EXPECT_EQ(Call->getCallingConv(), Clone->getCallingConv());
EXPECT_EQ(Call->getTailCallKind(), Clone->getTailCallKind()); EXPECT_EQ(Call->getTailCallKind(), Clone->getTailCallKind());
Show All 11 LinesTEST(InstructionsTest, AlterInvokeBundles) {
Value *Args[] = {ConstantInt::get(Int32Ty, 42)}; Value *Args[] = {ConstantInt::get(Int32Ty, 42)};
std::unique_ptr<BasicBlock> NormalDest(BasicBlock::Create(C)); std::unique_ptr<BasicBlock> NormalDest(BasicBlock::Create(C));
std::unique_ptr<BasicBlock> UnwindDest(BasicBlock::Create(C)); std::unique_ptr<BasicBlock> UnwindDest(BasicBlock::Create(C));
OperandBundleDef OldBundle("before", UndefValue::get(Int32Ty)); OperandBundleDef OldBundle("before", UndefValue::get(Int32Ty));
std::unique_ptr<InvokeInst> Invoke(InvokeInst::Create( std::unique_ptr<InvokeInst> Invoke(InvokeInst::Create(
Callee, NormalDest.get(), UnwindDest.get(), Args, OldBundle, "result")); Callee, NormalDest.get(), UnwindDest.get(), Args, OldBundle, "result"));
AttrBuilder AB; AttrBuilder AB;
AB.addAttribute(Attribute::Cold); AB.addAttribute(Attribute::Cold);
Invoke->setAttributes(AttributeSet::get(C, AttributeSet::FunctionIndex, AB)); Invoke->setAttributes(
AttributeList::get(C, AttributeList::FunctionIndex, AB));
Invoke->setDebugLoc(DebugLoc(MDNode::get(C, None))); Invoke->setDebugLoc(DebugLoc(MDNode::get(C, None)));
OperandBundleDef NewBundle("after", ConstantInt::get(Int32Ty, 7)); OperandBundleDef NewBundle("after", ConstantInt::get(Int32Ty, 7));
std::unique_ptr<InvokeInst> Clone( std::unique_ptr<InvokeInst> Clone(
InvokeInst::Create(Invoke.get(), NewBundle)); InvokeInst::Create(Invoke.get(), NewBundle));
EXPECT_EQ(Invoke->getNormalDest(), Clone->getNormalDest()); EXPECT_EQ(Invoke->getNormalDest(), Clone->getNormalDest());
EXPECT_EQ(Invoke->getUnwindDest(), Clone->getUnwindDest()); EXPECT_EQ(Invoke->getUnwindDest(), Clone->getUnwindDest());
EXPECT_EQ(Invoke->getNumArgOperands(), Clone->getNumArgOperands()); EXPECT_EQ(Invoke->getNumArgOperands(), Clone->getNumArgOperands());
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

llvm/trunk/unittests/IR/LegacyPassManagerTest.cpp

Show First 20 Lines • Show All 423 Lines • ▼ Show 20 Lines Module *makeLLVMModule(LLVMContext &Context) {
// Function Declarations // Function Declarations
Function* func_test1 = Function::Create( Function* func_test1 = Function::Create(
/*Type=*/FuncTy_0, /*Type=*/FuncTy_0,
/*Linkage=*/GlobalValue::ExternalLinkage, /*Linkage=*/GlobalValue::ExternalLinkage,
/*Name=*/"test1", mod); /*Name=*/"test1", mod);
func_test1->setCallingConv(CallingConv::C); func_test1->setCallingConv(CallingConv::C);
AttributeSet func_test1_PAL; AttributeList func_test1_PAL;
func_test1->setAttributes(func_test1_PAL); func_test1->setAttributes(func_test1_PAL);
Function* func_test2 = Function::Create( Function* func_test2 = Function::Create(
/*Type=*/FuncTy_0, /*Type=*/FuncTy_0,
/*Linkage=*/GlobalValue::ExternalLinkage, /*Linkage=*/GlobalValue::ExternalLinkage,
/*Name=*/"test2", mod); /*Name=*/"test2", mod);
func_test2->setCallingConv(CallingConv::C); func_test2->setCallingConv(CallingConv::C);
AttributeSet func_test2_PAL; AttributeList func_test2_PAL;
func_test2->setAttributes(func_test2_PAL); func_test2->setAttributes(func_test2_PAL);
Function* func_test3 = Function::Create( Function* func_test3 = Function::Create(
/*Type=*/FuncTy_0, /*Type=*/FuncTy_0,
/*Linkage=*/GlobalValue::ExternalLinkage, /*Linkage=*/GlobalValue::ExternalLinkage,
/*Name=*/"test3", mod); /*Name=*/"test3", mod);
func_test3->setCallingConv(CallingConv::C); func_test3->setCallingConv(CallingConv::C);
AttributeSet func_test3_PAL; AttributeList func_test3_PAL;
func_test3->setAttributes(func_test3_PAL); func_test3->setAttributes(func_test3_PAL);
Function* func_test4 = Function::Create( Function* func_test4 = Function::Create(
/*Type=*/FuncTy_2, /*Type=*/FuncTy_2,
/*Linkage=*/GlobalValue::ExternalLinkage, /*Linkage=*/GlobalValue::ExternalLinkage,
/*Name=*/"test4", mod); /*Name=*/"test4", mod);
func_test4->setCallingConv(CallingConv::C); func_test4->setCallingConv(CallingConv::C);
AttributeSet func_test4_PAL; AttributeList func_test4_PAL;
func_test4->setAttributes(func_test4_PAL); func_test4->setAttributes(func_test4_PAL);
// Global Variable Declarations // Global Variable Declarations
// Constant Definitions // Constant Definitions
// Global Variable Definitions // Global Variable Definitions
// Function Definitions // Function Definitions
// Function: test1 (func_test1) // Function: test1 (func_test1)
{ {
BasicBlock *label_entry = BasicBlock *label_entry =
BasicBlock::Create(Context, "entry", func_test1, nullptr); BasicBlock::Create(Context, "entry", func_test1, nullptr);
// Block entry (label_entry) // Block entry (label_entry)
CallInst* int32_3 = CallInst::Create(func_test2, "", label_entry); CallInst* int32_3 = CallInst::Create(func_test2, "", label_entry);
int32_3->setCallingConv(CallingConv::C); int32_3->setCallingConv(CallingConv::C);
int32_3->setTailCall(false);AttributeSet int32_3_PAL; int32_3->setTailCall(false);
AttributeList int32_3_PAL;
int32_3->setAttributes(int32_3_PAL); int32_3->setAttributes(int32_3_PAL);
ReturnInst::Create(Context, int32_3, label_entry); ReturnInst::Create(Context, int32_3, label_entry);
} }
// Function: test2 (func_test2) // Function: test2 (func_test2)
{ {
BasicBlock *label_entry_5 = BasicBlock *label_entry_5 =
BasicBlock::Create(Context, "entry", func_test2, nullptr); BasicBlock::Create(Context, "entry", func_test2, nullptr);
// Block entry (label_entry_5) // Block entry (label_entry_5)
CallInst* int32_6 = CallInst::Create(func_test3, "", label_entry_5); CallInst* int32_6 = CallInst::Create(func_test3, "", label_entry_5);
int32_6->setCallingConv(CallingConv::C); int32_6->setCallingConv(CallingConv::C);
int32_6->setTailCall(false);AttributeSet int32_6_PAL; int32_6->setTailCall(false);
AttributeList int32_6_PAL;
int32_6->setAttributes(int32_6_PAL); int32_6->setAttributes(int32_6_PAL);
ReturnInst::Create(Context, int32_6, label_entry_5); ReturnInst::Create(Context, int32_6, label_entry_5);
} }
// Function: test3 (func_test3) // Function: test3 (func_test3)
{ {
BasicBlock *label_entry_8 = BasicBlock *label_entry_8 =
BasicBlock::Create(Context, "entry", func_test3, nullptr); BasicBlock::Create(Context, "entry", func_test3, nullptr);
// Block entry (label_entry_8) // Block entry (label_entry_8)
CallInst* int32_9 = CallInst::Create(func_test1, "", label_entry_8); CallInst* int32_9 = CallInst::Create(func_test1, "", label_entry_8);
int32_9->setCallingConv(CallingConv::C); int32_9->setCallingConv(CallingConv::C);
int32_9->setTailCall(false);AttributeSet int32_9_PAL; int32_9->setTailCall(false);
AttributeList int32_9_PAL;
int32_9->setAttributes(int32_9_PAL); int32_9->setAttributes(int32_9_PAL);
ReturnInst::Create(Context, int32_9, label_entry_8); ReturnInst::Create(Context, int32_9, label_entry_8);
} }
// Function: test4 (func_test4) // Function: test4 (func_test4)
{ {
Function::arg_iterator args = func_test4->arg_begin(); Function::arg_iterator args = func_test4->arg_begin();
Show All 39 Lines

llvm/trunk/unittests/IR/VerifierTest.cpp

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 LinesTEST(VerifierTest, Branch_i1) {
EXPECT_TRUE(verifyFunction(*F)); EXPECT_TRUE(verifyFunction(*F));
} }
TEST(VerifierTest, InvalidRetAttribute) { TEST(VerifierTest, InvalidRetAttribute) {
LLVMContext C; LLVMContext C;
Module M("M", C); Module M("M", C);
FunctionType *FTy = FunctionType::get(Type::getInt32Ty(C), /*isVarArg=*/false); FunctionType *FTy = FunctionType::get(Type::getInt32Ty(C), /*isVarArg=*/false);
Function *F = cast<Function>(M.getOrInsertFunction("foo", FTy)); Function *F = cast<Function>(M.getOrInsertFunction("foo", FTy));
AttributeSet AS = F->getAttributes(); AttributeList AS = F->getAttributes();
F->setAttributes(AS.addAttribute(C, AttributeSet::ReturnIndex, F->setAttributes(
Attribute::UWTable)); AS.addAttribute(C, AttributeList::ReturnIndex, Attribute::UWTable));
std::string Error; std::string Error;
raw_string_ostream ErrorOS(Error); raw_string_ostream ErrorOS(Error);
EXPECT_TRUE(verifyModule(M, &ErrorOS)); EXPECT_TRUE(verifyModule(M, &ErrorOS));
EXPECT_TRUE(StringRef(ErrorOS.str()).startswith( EXPECT_TRUE(StringRef(ErrorOS.str()).startswith(
"Attribute 'uwtable' only applies to functions!")); "Attribute 'uwtable' only applies to functions!"));
} }
▲ Show 20 Lines • Show All 165 Lines • Show Last 20 Lines

llvm/trunk/unittests/Transforms/Utils/Cloning.cpp

Show First 20 Lines • Show All 157 Lines • ▼ Show 20 LinesTEST_F(CloneInstruction, Attributes) {
Function *F1 = Function::Create(FT1, Function::ExternalLinkage); Function *F1 = Function::Create(FT1, Function::ExternalLinkage);
BasicBlock *BB = BasicBlock::Create(context, "", F1); BasicBlock *BB = BasicBlock::Create(context, "", F1);
IRBuilder<> Builder(BB); IRBuilder<> Builder(BB);
Builder.CreateRetVoid(); Builder.CreateRetVoid();
Function *F2 = Function::Create(FT1, Function::ExternalLinkage); Function *F2 = Function::Create(FT1, Function::ExternalLinkage);
Attribute::AttrKind AK[] = { Attribute::NoCapture }; Attribute::AttrKind AK[] = { Attribute::NoCapture };
AttributeSet AS = AttributeSet::get(context, 0, AK); AttributeList AS = AttributeList::get(context, 0, AK);
Argument *A = &*F1->arg_begin(); Argument *A = &*F1->arg_begin();
A->addAttr(AS); A->addAttr(AS);
SmallVector<ReturnInst*, 4> Returns; SmallVector<ReturnInst*, 4> Returns;
ValueToValueMapTy VMap; ValueToValueMapTy VMap;
VMap[A] = UndefValue::get(A->getType()); VMap[A] = UndefValue::get(A->getType());
CloneFunctionInto(F2, F1, VMap, false, Returns); CloneFunctionInto(F2, F1, VMap, false, Returns);
▲ Show 20 Lines • Show All 364 Lines • Show Last 20 Lines

llvm/trunk/utils/TableGen/IntrinsicEmitter.cpp

Show First 20 Lines • Show All 491 Lines • ▼ Show 20 Lines
} // End anonymous namespace } // End anonymous namespace
/// EmitAttributes - This emits the Intrinsic::getAttributes method. /// EmitAttributes - This emits the Intrinsic::getAttributes method.
void IntrinsicEmitter::EmitAttributes(const CodeGenIntrinsicTable &Ints, void IntrinsicEmitter::EmitAttributes(const CodeGenIntrinsicTable &Ints,
raw_ostream &OS) { raw_ostream &OS) {
OS << "// Add parameter attributes that are not common to all intrinsics.\n"; OS << "// Add parameter attributes that are not common to all intrinsics.\n";
OS << "#ifdef GET_INTRINSIC_ATTRIBUTES\n"; OS << "#ifdef GET_INTRINSIC_ATTRIBUTES\n";
if (TargetOnly) if (TargetOnly)
OS << "static AttributeSet getAttributes(LLVMContext &C, " << TargetPrefix OS << "static AttributeList getAttributes(LLVMContext &C, " << TargetPrefix
<< "Intrinsic::ID id) {\n"; << "Intrinsic::ID id) {\n";
else else
OS << "AttributeSet Intrinsic::getAttributes(LLVMContext &C, ID id) {\n"; OS << "AttributeList Intrinsic::getAttributes(LLVMContext &C, ID id) {\n";
// Compute the maximum number of attribute arguments and the map // Compute the maximum number of attribute arguments and the map
typedef std::map<const CodeGenIntrinsic*, unsigned, typedef std::map<const CodeGenIntrinsic*, unsigned,
AttributeComparator> UniqAttrMapTy; AttributeComparator> UniqAttrMapTy;
UniqAttrMapTy UniqAttributes; UniqAttrMapTy UniqAttributes;
unsigned maxArgAttrs = 0; unsigned maxArgAttrs = 0;
unsigned AttrNum = 0; unsigned AttrNum = 0;
for (unsigned i = 0, e = Ints.size(); i != e; ++i) { for (unsigned i = 0, e = Ints.size(); i != e; ++i) {
const CodeGenIntrinsic &intrinsic = Ints[i]; const CodeGenIntrinsic &intrinsic = Ints[i];
maxArgAttrs = maxArgAttrs =
std::max(maxArgAttrs, unsigned(intrinsic.ArgumentAttributes.size())); std::max(maxArgAttrs, unsigned(intrinsic.ArgumentAttributes.size()));
unsigned &N = UniqAttributes[&intrinsic]; unsigned &N = UniqAttributes[&intrinsic];
if (N) continue; if (N) continue;
assert(AttrNum < 256 && "Too many unique attributes for table!"); assert(AttrNum < 256 && "Too many unique attributes for table!");
N = ++AttrNum; N = ++AttrNum;
} }
// Emit an array of AttributeSet. Most intrinsics will have at least one // Emit an array of AttributeList. Most intrinsics will have at least one
// entry, for the function itself (index ~1), which is usually nounwind. // entry, for the function itself (index ~1), which is usually nounwind.
OS << " static const uint8_t IntrinsicsToAttributesMap[] = {\n"; OS << " static const uint8_t IntrinsicsToAttributesMap[] = {\n";
for (unsigned i = 0, e = Ints.size(); i != e; ++i) { for (unsigned i = 0, e = Ints.size(); i != e; ++i) {
const CodeGenIntrinsic &intrinsic = Ints[i]; const CodeGenIntrinsic &intrinsic = Ints[i];
OS << " " << UniqAttributes[&intrinsic] << ", // " OS << " " << UniqAttributes[&intrinsic] << ", // "
<< intrinsic.Name << "\n"; << intrinsic.Name << "\n";
} }
OS << " };\n\n"; OS << " };\n\n";
OS << " AttributeSet AS[" << maxArgAttrs+1 << "];\n"; OS << " AttributeList AS[" << maxArgAttrs + 1 << "];\n";
OS << " unsigned NumAttrs = 0;\n"; OS << " unsigned NumAttrs = 0;\n";
OS << " if (id != 0) {\n"; OS << " if (id != 0) {\n";
OS << " switch(IntrinsicsToAttributesMap[id - "; OS << " switch(IntrinsicsToAttributesMap[id - ";
if (TargetOnly) if (TargetOnly)
OS << "Intrinsic::num_intrinsics"; OS << "Intrinsic::num_intrinsics";
else else
OS << "1"; OS << "1";
OS << "]) {\n"; OS << "]) {\n";
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines if (ae) {
OS << "Attribute::ReadNone"; OS << "Attribute::ReadNone";
addComma = true; addComma = true;
break; break;
} }
++ai; ++ai;
} while (ai != ae && intrinsic.ArgumentAttributes[ai].first == argNo); } while (ai != ae && intrinsic.ArgumentAttributes[ai].first == argNo);
OS << "};\n"; OS << "};\n";
OS << " AS[" << numAttrs++ << "] = AttributeSet::get(C, " OS << " AS[" << numAttrs++ << "] = AttributeList::get(C, "
<< argNo+1 << ", AttrParam" << argNo +1 << ");\n"; << argNo + 1 << ", AttrParam" << argNo + 1 << ");\n";
} }
} }
if (!intrinsic.canThrow || if (!intrinsic.canThrow ||
intrinsic.ModRef != CodeGenIntrinsic::ReadWriteMem || intrinsic.ModRef != CodeGenIntrinsic::ReadWriteMem ||
intrinsic.isNoReturn || intrinsic.isNoDuplicate || intrinsic.isNoReturn || intrinsic.isNoDuplicate ||
intrinsic.isConvergent) { intrinsic.isConvergent) {
OS << " const Attribute::AttrKind Atts[] = {"; OS << " const Attribute::AttrKind Atts[] = {";
▲ Show 20 Lines • Show All 86 Lines • ▼ Show 20 Lines if (!intrinsic.canThrow ||
case CodeGenIntrinsic::ReadWriteInaccessibleMemOrArgMem: case CodeGenIntrinsic::ReadWriteInaccessibleMemOrArgMem:
if (addComma) if (addComma)
OS << ","; OS << ",";
OS << "Attribute::InaccessibleMemOrArgMemOnly"; OS << "Attribute::InaccessibleMemOrArgMemOnly";
case CodeGenIntrinsic::ReadWriteMem: case CodeGenIntrinsic::ReadWriteMem:
break; break;
} }
OS << "};\n"; OS << "};\n";
OS << " AS[" << numAttrs++ << "] = AttributeSet::get(C, " OS << " AS[" << numAttrs++ << "] = AttributeList::get(C, "
<< "AttributeSet::FunctionIndex, Atts);\n"; << "AttributeList::FunctionIndex, Atts);\n";
} }
if (numAttrs) { if (numAttrs) {
OS << " NumAttrs = " << numAttrs << ";\n"; OS << " NumAttrs = " << numAttrs << ";\n";
OS << " break;\n"; OS << " break;\n";
OS << " }\n"; OS << " }\n";
} else { } else {
OS << " return AttributeSet();\n"; OS << " return AttributeList();\n";
OS << " }\n"; OS << " }\n";
} }
} }
OS << " }\n"; OS << " }\n";
OS << " }\n"; OS << " }\n";
OS << " return AttributeSet::get(C, makeArrayRef(AS, NumAttrs));\n"; OS << " return AttributeList::get(C, makeArrayRef(AS, NumAttrs));\n";
OS << "}\n"; OS << "}\n";
OS << "#endif // GET_INTRINSIC_ATTRIBUTES\n\n"; OS << "#endif // GET_INTRINSIC_ATTRIBUTES\n\n";
} }
void IntrinsicEmitter::EmitIntrinsicToBuiltinMap( void IntrinsicEmitter::EmitIntrinsicToBuiltinMap(
const CodeGenIntrinsicTable &Ints, bool IsGCC, raw_ostream &OS) { const CodeGenIntrinsicTable &Ints, bool IsGCC, raw_ostream &OS) {
StringRef CompilerName = (IsGCC ? "GCC" : "MS"); StringRef CompilerName = (IsGCC ? "GCC" : "MS");
typedef std::map<std::string, std::map<std::string, std::string>> BIMTy; typedef std::map<std::string, std::map<std::string, std::string>> BIMTy;
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines