Update clang to r339409.
Change-Id: I800772d2d838223be1f6b40d490c4591b937fca2
diff --git a/linux-x64/clang/include/llvm/IR/IntrinsicInst.h b/linux-x64/clang/include/llvm/IR/IntrinsicInst.h
index 80d428c..32a62a4 100644
--- a/linux-x64/clang/include/llvm/IR/IntrinsicInst.h
+++ b/linux-x64/clang/include/llvm/IR/IntrinsicInst.h
@@ -66,6 +66,27 @@
/// This is the common base class for debug info intrinsics.
class DbgInfoIntrinsic : public IntrinsicInst {
public:
+ /// \name Casting methods
+ /// @{
+ static bool classof(const IntrinsicInst *I) {
+ switch (I->getIntrinsicID()) {
+ case Intrinsic::dbg_declare:
+ case Intrinsic::dbg_value:
+ case Intrinsic::dbg_addr:
+ case Intrinsic::dbg_label:
+ return true;
+ default: return false;
+ }
+ }
+ static bool classof(const Value *V) {
+ return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+ }
+ /// @}
+ };
+
+ /// This is the common base class for debug info intrinsics for variables.
+ class DbgVariableIntrinsic : public DbgInfoIntrinsic {
+ public:
/// Get the location corresponding to the variable referenced by the debug
/// info intrinsic. Depending on the intrinsic, this could be the
/// variable's value or its address.
@@ -93,6 +114,10 @@
return cast<MetadataAsValue>(getArgOperand(2))->getMetadata();
}
+ /// Get the size (in bits) of the variable, or fragment of the variable that
+ /// is described.
+ Optional<uint64_t> getFragmentSizeInBits() const;
+
/// \name Casting methods
/// @{
static bool classof(const IntrinsicInst *I) {
@@ -111,7 +136,7 @@
};
/// This represents the llvm.dbg.declare instruction.
- class DbgDeclareInst : public DbgInfoIntrinsic {
+ class DbgDeclareInst : public DbgVariableIntrinsic {
public:
Value *getAddress() const { return getVariableLocation(); }
@@ -127,7 +152,7 @@
};
/// This represents the llvm.dbg.addr instruction.
- class DbgAddrIntrinsic : public DbgInfoIntrinsic {
+ class DbgAddrIntrinsic : public DbgVariableIntrinsic {
public:
Value *getAddress() const { return getVariableLocation(); }
@@ -142,7 +167,7 @@
};
/// This represents the llvm.dbg.value instruction.
- class DbgValueInst : public DbgInfoIntrinsic {
+ class DbgValueInst : public DbgVariableIntrinsic {
public:
Value *getValue() const {
return getVariableLocation(/* AllowNullOp = */ false);
@@ -159,6 +184,28 @@
/// @}
};
+ /// This represents the llvm.dbg.label instruction.
+ class DbgLabelInst : public DbgInfoIntrinsic {
+ public:
+ DILabel *getLabel() const {
+ return cast<DILabel>(getRawLabel());
+ }
+
+ Metadata *getRawLabel() const {
+ return cast<MetadataAsValue>(getArgOperand(0))->getMetadata();
+ }
+
+ /// Methods for support type inquiry through isa, cast, and dyn_cast:
+ /// @{
+ static bool classof(const IntrinsicInst *I) {
+ return I->getIntrinsicID() == Intrinsic::dbg_label;
+ }
+ static bool classof(const Value *V) {
+ return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+ }
+ /// @}
+ };
+
/// This is the common base class for constrained floating point intrinsics.
class ConstrainedFPIntrinsic : public IntrinsicInst {
public:
@@ -266,6 +313,71 @@
}
};
+ /// Common base class for all memory transfer intrinsics. Simply provides
+ /// common methods.
+ template <class BaseCL> class MemTransferBase : public BaseCL {
+ private:
+ enum { ARG_SOURCE = 1 };
+
+ public:
+ /// Return the arguments to the instruction.
+ Value *getRawSource() const {
+ return const_cast<Value *>(BaseCL::getArgOperand(ARG_SOURCE));
+ }
+ const Use &getRawSourceUse() const {
+ return BaseCL::getArgOperandUse(ARG_SOURCE);
+ }
+ Use &getRawSourceUse() { return BaseCL::getArgOperandUse(ARG_SOURCE); }
+
+ /// This is just like getRawSource, but it strips off any cast
+ /// instructions that feed it, giving the original input. The returned
+ /// value is guaranteed to be a pointer.
+ Value *getSource() const { return getRawSource()->stripPointerCasts(); }
+
+ unsigned getSourceAddressSpace() const {
+ return cast<PointerType>(getRawSource()->getType())->getAddressSpace();
+ }
+
+ unsigned getSourceAlignment() const {
+ return BaseCL::getParamAlignment(ARG_SOURCE);
+ }
+
+ void setSource(Value *Ptr) {
+ assert(getRawSource()->getType() == Ptr->getType() &&
+ "setSource called with pointer of wrong type!");
+ BaseCL::setArgOperand(ARG_SOURCE, Ptr);
+ }
+
+ void setSourceAlignment(unsigned Align) {
+ BaseCL::removeParamAttr(ARG_SOURCE, Attribute::Alignment);
+ if (Align > 0)
+ BaseCL::addParamAttr(ARG_SOURCE, Attribute::getWithAlignment(
+ BaseCL::getContext(), Align));
+ }
+ };
+
+ /// Common base class for all memset intrinsics. Simply provides
+ /// common methods.
+ template <class BaseCL> class MemSetBase : public BaseCL {
+ private:
+ enum { ARG_VALUE = 1 };
+
+ public:
+ Value *getValue() const {
+ return const_cast<Value *>(BaseCL::getArgOperand(ARG_VALUE));
+ }
+ const Use &getValueUse() const {
+ return BaseCL::getArgOperandUse(ARG_VALUE);
+ }
+ Use &getValueUse() { return BaseCL::getArgOperandUse(ARG_VALUE); }
+
+ void setValue(Value *Val) {
+ assert(getValue()->getType() == Val->getType() &&
+ "setValue called with value of wrong type!");
+ BaseCL::setArgOperand(ARG_VALUE, Val);
+ }
+ };
+
// The common base class for the atomic memset/memmove/memcpy intrinsics
// i.e. llvm.element.unordered.atomic.memset/memcpy/memmove
class AtomicMemIntrinsic : public MemIntrinsicBase<AtomicMemIntrinsic> {
@@ -308,23 +420,8 @@
/// This class represents atomic memset intrinsic
// i.e. llvm.element.unordered.atomic.memset
- class AtomicMemSetInst : public AtomicMemIntrinsic {
- private:
- enum { ARG_VALUE = 1 };
-
+ class AtomicMemSetInst : public MemSetBase<AtomicMemIntrinsic> {
public:
- Value *getValue() const {
- return const_cast<Value *>(getArgOperand(ARG_VALUE));
- }
- const Use &getValueUse() const { return getArgOperandUse(ARG_VALUE); }
- Use &getValueUse() { return getArgOperandUse(ARG_VALUE); }
-
- void setValue(Value *Val) {
- assert(getValue()->getType() == Val->getType() &&
- "setValue called with value of wrong type!");
- setArgOperand(ARG_VALUE, Val);
- }
-
static bool classof(const IntrinsicInst *I) {
return I->getIntrinsicID() == Intrinsic::memset_element_unordered_atomic;
}
@@ -335,44 +432,8 @@
// This class wraps the atomic memcpy/memmove intrinsics
// i.e. llvm.element.unordered.atomic.memcpy/memmove
- class AtomicMemTransferInst : public AtomicMemIntrinsic {
- private:
- enum { ARG_SOURCE = 1 };
-
+ class AtomicMemTransferInst : public MemTransferBase<AtomicMemIntrinsic> {
public:
- /// Return the arguments to the instruction.
- Value *getRawSource() const {
- return const_cast<Value *>(getArgOperand(ARG_SOURCE));
- }
- const Use &getRawSourceUse() const { return getArgOperandUse(ARG_SOURCE); }
- Use &getRawSourceUse() { return getArgOperandUse(ARG_SOURCE); }
-
- /// This is just like getRawSource, but it strips off any cast
- /// instructions that feed it, giving the original input. The returned
- /// value is guaranteed to be a pointer.
- Value *getSource() const { return getRawSource()->stripPointerCasts(); }
-
- unsigned getSourceAddressSpace() const {
- return cast<PointerType>(getRawSource()->getType())->getAddressSpace();
- }
-
- unsigned getSourceAlignment() const {
- return getParamAlignment(ARG_SOURCE);
- }
-
- void setSource(Value *Ptr) {
- assert(getRawSource()->getType() == Ptr->getType() &&
- "setSource called with pointer of wrong type!");
- setArgOperand(ARG_SOURCE, Ptr);
- }
-
- void setSourceAlignment(unsigned Align) {
- removeParamAttr(ARG_SOURCE, Attribute::Alignment);
- if (Align > 0)
- addParamAttr(ARG_SOURCE,
- Attribute::getWithAlignment(getContext(), Align));
- }
-
static bool classof(const IntrinsicInst *I) {
switch (I->getIntrinsicID()) {
case Intrinsic::memcpy_element_unordered_atomic:
@@ -444,19 +505,8 @@
};
/// This class wraps the llvm.memset intrinsic.
- class MemSetInst : public MemIntrinsic {
+ class MemSetInst : public MemSetBase<MemIntrinsic> {
public:
- /// Return the arguments to the instruction.
- Value *getValue() const { return const_cast<Value*>(getArgOperand(1)); }
- const Use &getValueUse() const { return getArgOperandUse(1); }
- Use &getValueUse() { return getArgOperandUse(1); }
-
- void setValue(Value *Val) {
- assert(getValue()->getType() == Val->getType() &&
- "setValue called with value of wrong type!");
- setArgOperand(1, Val);
- }
-
// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const IntrinsicInst *I) {
return I->getIntrinsicID() == Intrinsic::memset;
@@ -467,42 +517,8 @@
};
/// This class wraps the llvm.memcpy/memmove intrinsics.
- class MemTransferInst : public MemIntrinsic {
- private:
- enum { ARG_SOURCE = 1 };
-
+ class MemTransferInst : public MemTransferBase<MemIntrinsic> {
public:
- /// Return the arguments to the instruction.
- Value *getRawSource() const { return const_cast<Value*>(getArgOperand(ARG_SOURCE)); }
- const Use &getRawSourceUse() const { return getArgOperandUse(ARG_SOURCE); }
- Use &getRawSourceUse() { return getArgOperandUse(ARG_SOURCE); }
-
- /// This is just like getRawSource, but it strips off any cast
- /// instructions that feed it, giving the original input. The returned
- /// value is guaranteed to be a pointer.
- Value *getSource() const { return getRawSource()->stripPointerCasts(); }
-
- unsigned getSourceAddressSpace() const {
- return cast<PointerType>(getRawSource()->getType())->getAddressSpace();
- }
-
- unsigned getSourceAlignment() const {
- return getParamAlignment(ARG_SOURCE);
- }
-
- void setSource(Value *Ptr) {
- assert(getRawSource()->getType() == Ptr->getType() &&
- "setSource called with pointer of wrong type!");
- setArgOperand(ARG_SOURCE, Ptr);
- }
-
- void setSourceAlignment(unsigned Align) {
- removeParamAttr(ARG_SOURCE, Attribute::Alignment);
- if (Align > 0)
- addParamAttr(ARG_SOURCE,
- Attribute::getWithAlignment(getContext(), Align));
- }
-
// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const IntrinsicInst *I) {
return I->getIntrinsicID() == Intrinsic::memcpy ||
@@ -571,23 +587,8 @@
/// This class represents any memset intrinsic
// i.e. llvm.element.unordered.atomic.memset
// and llvm.memset
- class AnyMemSetInst : public AnyMemIntrinsic {
- private:
- enum { ARG_VALUE = 1 };
-
+ class AnyMemSetInst : public MemSetBase<AnyMemIntrinsic> {
public:
- Value *getValue() const {
- return const_cast<Value *>(getArgOperand(ARG_VALUE));
- }
- const Use &getValueUse() const { return getArgOperandUse(ARG_VALUE); }
- Use &getValueUse() { return getArgOperandUse(ARG_VALUE); }
-
- void setValue(Value *Val) {
- assert(getValue()->getType() == Val->getType() &&
- "setValue called with value of wrong type!");
- setArgOperand(ARG_VALUE, Val);
- }
-
static bool classof(const IntrinsicInst *I) {
switch (I->getIntrinsicID()) {
case Intrinsic::memset:
@@ -605,44 +606,8 @@
// This class wraps any memcpy/memmove intrinsics
// i.e. llvm.element.unordered.atomic.memcpy/memmove
// and llvm.memcpy/memmove
- class AnyMemTransferInst : public AnyMemIntrinsic {
- private:
- enum { ARG_SOURCE = 1 };
-
+ class AnyMemTransferInst : public MemTransferBase<AnyMemIntrinsic> {
public:
- /// Return the arguments to the instruction.
- Value *getRawSource() const {
- return const_cast<Value *>(getArgOperand(ARG_SOURCE));
- }
- const Use &getRawSourceUse() const { return getArgOperandUse(ARG_SOURCE); }
- Use &getRawSourceUse() { return getArgOperandUse(ARG_SOURCE); }
-
- /// This is just like getRawSource, but it strips off any cast
- /// instructions that feed it, giving the original input. The returned
- /// value is guaranteed to be a pointer.
- Value *getSource() const { return getRawSource()->stripPointerCasts(); }
-
- unsigned getSourceAddressSpace() const {
- return cast<PointerType>(getRawSource()->getType())->getAddressSpace();
- }
-
- unsigned getSourceAlignment() const {
- return getParamAlignment(ARG_SOURCE);
- }
-
- void setSource(Value *Ptr) {
- assert(getRawSource()->getType() == Ptr->getType() &&
- "setSource called with pointer of wrong type!");
- setArgOperand(ARG_SOURCE, Ptr);
- }
-
- void setSourceAlignment(unsigned Align) {
- removeParamAttr(ARG_SOURCE, Attribute::Alignment);
- if (Align > 0)
- addParamAttr(ARG_SOURCE,
- Attribute::getWithAlignment(getContext(), Align));
- }
-
static bool classof(const IntrinsicInst *I) {
switch (I->getIntrinsicID()) {
case Intrinsic::memcpy: