Update clang to r339409.
Change-Id: I800772d2d838223be1f6b40d490c4591b937fca2
diff --git a/linux-x64/clang/include/llvm/IR/DebugInfoMetadata.h b/linux-x64/clang/include/llvm/IR/DebugInfoMetadata.h
index e2210bb..905a7ca 100644
--- a/linux-x64/clang/include/llvm/IR/DebugInfoMetadata.h
+++ b/linux-x64/clang/include/llvm/IR/DebugInfoMetadata.h
@@ -232,6 +232,7 @@
case DITemplateValueParameterKind:
case DIGlobalVariableKind:
case DILocalVariableKind:
+ case DILabelKind:
case DIObjCPropertyKind:
case DIImportedEntityKind:
case DIModuleKind:
@@ -678,9 +679,11 @@
Metadata *getRawScope() const { return getOperand(1); }
MDString *getRawName() const { return getOperandAs<MDString>(2); }
- void setFlags(DIFlags NewFlags) {
- assert(!isUniqued() && "Cannot set flags on uniqued nodes");
- Flags = NewFlags;
+ /// Returns a new temporary DIType with updated Flags
+ TempDIType cloneWithFlags(DIFlags NewFlags) const {
+ auto NewTy = clone();
+ NewTy->Flags = NewFlags;
+ return NewTy;
}
bool isPrivate() const {
@@ -775,6 +778,12 @@
unsigned getEncoding() const { return Encoding; }
+ enum class Signedness { Signed, Unsigned };
+
+ /// Return the signedness of this type, or None if this type is neither
+ /// signed nor unsigned.
+ Optional<Signedness> getSignedness() const;
+
static bool classof(const Metadata *MD) {
return MD->getMetadataID() == DIBasicTypeKind;
}
@@ -790,7 +799,7 @@
friend class LLVMContextImpl;
friend class MDNode;
- /// \brief The DWARF address space of the memory pointed to or referenced by a
+ /// The DWARF address space of the memory pointed to or referenced by a
/// pointer or reference type respectively.
Optional<unsigned> DWARFAddressSpace;
@@ -865,7 +874,8 @@
/// Get extra data associated with this derived type.
///
/// Class type for pointer-to-members, objective-c property node for ivars,
- /// or global constant wrapper for static members.
+ /// global constant wrapper for static members, or virtual base pointer offset
+ /// for inheritance.
///
/// TODO: Separate out types that need this extra operand: pointer-to-member
/// types and member fields (static members and ivars).
@@ -883,6 +893,14 @@
return dyn_cast_or_null<DIObjCProperty>(getExtraData());
}
+ uint32_t getVBPtrOffset() const {
+ assert(getTag() == dwarf::DW_TAG_inheritance);
+ if (auto *CM = cast_or_null<ConstantAsMetadata>(getExtraData()))
+ if (auto *CI = dyn_cast_or_null<ConstantInt>(CM->getValue()))
+ return static_cast<uint32_t>(CI->getZExtValue());
+ return 0;
+ }
+
Constant *getStorageOffsetInBits() const {
assert(getTag() == dwarf::DW_TAG_member && isBitField());
if (auto *C = cast_or_null<ConstantAsMetadata>(getExtraData()))
@@ -1144,11 +1162,12 @@
NoDebug = 0,
FullDebug,
LineTablesOnly,
- LastEmissionKind = LineTablesOnly
+ DebugDirectivesOnly,
+ LastEmissionKind = DebugDirectivesOnly
};
static Optional<DebugEmissionKind> getEmissionKind(StringRef Str);
- static const char *EmissionKindString(DebugEmissionKind EK);
+ static const char *emissionKindString(DebugEmissionKind EK);
private:
unsigned SourceLanguage;
@@ -1250,6 +1269,9 @@
DebugEmissionKind getEmissionKind() const {
return (DebugEmissionKind)EmissionKind;
}
+ bool isDebugDirectivesOnly() const {
+ return EmissionKind == DebugDirectivesOnly;
+ }
bool getDebugInfoForProfiling() const { return DebugInfoForProfiling; }
bool getGnuPubnames() const { return GnuPubnames; }
StringRef getProducer() const { return getStringOperand(1); }
@@ -1497,26 +1519,25 @@
/// discriminator.
inline const DILocation *cloneWithDuplicationFactor(unsigned DF) const;
+ enum { NoGeneratedLocation = false, WithGeneratedLocation = true };
+
/// When two instructions are combined into a single instruction we also
/// need to combine the original locations into a single location.
///
/// When the locations are the same we can use either location. When they
- /// differ, we need a third location which is distinct from either. If
- /// they have the same file/line but have a different discriminator we
- /// could create a location with a new discriminator. If they are from
- /// different files/lines the location is ambiguous and can't be
- /// represented in a single line entry. In this case, no location
- /// should be set, unless the merged instruction is a call, which we will
- /// set the merged debug location as line 0 of the nearest common scope
- /// where 2 locations are inlined from. This only applies to Instruction;
- /// for MachineInstruction, as it is post-inline, we will treat the call
- /// instruction the same way as other instructions.
+ /// differ, we need a third location which is distinct from either. If they
+ /// have the same file/line but have a different discriminator we could
+ /// create a location with a new discriminator. If they are from different
+ /// files/lines the location is ambiguous and can't be represented in a line
+ /// entry. In this case, if \p GenerateLocation is true, we will set the
+ /// merged debug location as line 0 of the nearest common scope where the two
+ /// locations are inlined from.
///
- /// \p ForInst: The Instruction the merged DILocation is for. If the
- /// Instruction is unavailable or non-existent, use nullptr.
+ /// \p GenerateLocation: Whether the merged location can be generated when
+ /// \p LocA and \p LocB differ.
static const DILocation *
getMergedLocation(const DILocation *LocA, const DILocation *LocB,
- const Instruction *ForInst = nullptr);
+ bool GenerateLocation = NoGeneratedLocation);
/// Returns the base discriminator for a given encoded discriminator \p D.
static unsigned getBaseDiscriminatorFromDiscriminator(unsigned D) {
@@ -1610,13 +1631,13 @@
unsigned VirtualIndex, int ThisAdjustment, DIFlags Flags,
bool IsOptimized, DICompileUnit *Unit,
DITemplateParameterArray TemplateParams, DISubprogram *Declaration,
- DILocalVariableArray Variables, DITypeArray ThrownTypes,
+ DINodeArray RetainedNodes, DITypeArray ThrownTypes,
StorageType Storage, bool ShouldCreate = true) {
return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
getCanonicalMDString(Context, LinkageName), File, Line, Type,
IsLocalToUnit, IsDefinition, ScopeLine, ContainingType,
Virtuality, VirtualIndex, ThisAdjustment, Flags, IsOptimized,
- Unit, TemplateParams.get(), Declaration, Variables.get(),
+ Unit, TemplateParams.get(), Declaration, RetainedNodes.get(),
ThrownTypes.get(), Storage, ShouldCreate);
}
static DISubprogram *
@@ -1625,7 +1646,7 @@
bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
Metadata *ContainingType, unsigned Virtuality, unsigned VirtualIndex,
int ThisAdjustment, DIFlags Flags, bool IsOptimized, Metadata *Unit,
- Metadata *TemplateParams, Metadata *Declaration, Metadata *Variables,
+ Metadata *TemplateParams, Metadata *Declaration, Metadata *RetainedNodes,
Metadata *ThrownTypes, StorageType Storage, bool ShouldCreate = true);
TempDISubprogram cloneImpl() const {
@@ -1634,7 +1655,7 @@
isDefinition(), getScopeLine(), getContainingType(),
getVirtuality(), getVirtualIndex(), getThisAdjustment(),
getFlags(), isOptimized(), getUnit(),
- getTemplateParams(), getDeclaration(), getVariables(),
+ getTemplateParams(), getDeclaration(), getRetainedNodes(),
getThrownTypes());
}
@@ -1648,12 +1669,12 @@
bool IsOptimized, DICompileUnit *Unit,
DITemplateParameterArray TemplateParams = nullptr,
DISubprogram *Declaration = nullptr,
- DILocalVariableArray Variables = nullptr,
+ DINodeArray RetainedNodes = nullptr,
DITypeArray ThrownTypes = nullptr),
(Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
IsDefinition, ScopeLine, ContainingType, Virtuality,
VirtualIndex, ThisAdjustment, Flags, IsOptimized, Unit,
- TemplateParams, Declaration, Variables, ThrownTypes))
+ TemplateParams, Declaration, RetainedNodes, ThrownTypes))
DEFINE_MDNODE_GET(
DISubprogram,
(Metadata * Scope, MDString *Name, MDString *LinkageName, Metadata *File,
@@ -1661,15 +1682,22 @@
unsigned ScopeLine, Metadata *ContainingType, unsigned Virtuality,
unsigned VirtualIndex, int ThisAdjustment, DIFlags Flags,
bool IsOptimized, Metadata *Unit, Metadata *TemplateParams = nullptr,
- Metadata *Declaration = nullptr, Metadata *Variables = nullptr,
+ Metadata *Declaration = nullptr, Metadata *RetainedNodes = nullptr,
Metadata *ThrownTypes = nullptr),
(Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition,
ScopeLine, ContainingType, Virtuality, VirtualIndex, ThisAdjustment,
- Flags, IsOptimized, Unit, TemplateParams, Declaration, Variables,
+ Flags, IsOptimized, Unit, TemplateParams, Declaration, RetainedNodes,
ThrownTypes))
TempDISubprogram clone() const { return cloneImpl(); }
+ /// Returns a new temporary DISubprogram with updated Flags
+ TempDISubprogram cloneWithFlags(DIFlags NewFlags) const {
+ auto NewSP = clone();
+ NewSP->Flags = NewFlags;
+ return NewSP;
+ }
+
public:
unsigned getLine() const { return Line; }
unsigned getVirtuality() const { return Virtuality; }
@@ -1712,6 +1740,11 @@
/// Return true if this subprogram is C++11 noreturn or C11 _Noreturn
bool isNoReturn() const { return getFlags() & FlagNoReturn; }
+ // Check if this routine is a compiler-generated thunk.
+ //
+ // Returns true if this subprogram is a thunk generated by the compiler.
+ bool isThunk() const { return getFlags() & FlagThunk; }
+
DIScopeRef getScope() const { return DIScopeRef(getRawScope()); }
StringRef getName() const { return getStringOperand(2); }
@@ -1734,8 +1767,8 @@
DISubprogram *getDeclaration() const {
return cast_or_null<DISubprogram>(getRawDeclaration());
}
- DILocalVariableArray getVariables() const {
- return cast_or_null<MDTuple>(getRawVariables());
+ DINodeArray getRetainedNodes() const {
+ return cast_or_null<MDTuple>(getRawRetainedNodes());
}
DITypeArray getThrownTypes() const {
return cast_or_null<MDTuple>(getRawThrownTypes());
@@ -1747,7 +1780,7 @@
Metadata *getRawType() const { return getOperand(4); }
Metadata *getRawUnit() const { return getOperand(5); }
Metadata *getRawDeclaration() const { return getOperand(6); }
- Metadata *getRawVariables() const { return getOperand(7); }
+ Metadata *getRawRetainedNodes() const { return getOperand(7); }
Metadata *getRawContainingType() const {
return getNumOperands() > 8 ? getOperandAs<Metadata>(8) : nullptr;
}
@@ -2183,6 +2216,14 @@
/// Determines the size of the variable's type.
Optional<uint64_t> getSizeInBits() const;
+ /// Return the signedness of this variable's type, or None if this type is
+ /// neither signed nor unsigned.
+ Optional<DIBasicType::Signedness> getSignedness() const {
+ if (auto *BT = dyn_cast<DIBasicType>(getType().resolve()))
+ return BT->getSignedness();
+ return None;
+ }
+
StringRef getFilename() const {
if (auto *F = getFile())
return F->getFilename();
@@ -2289,6 +2330,11 @@
///
/// Return the number of elements in the operand (1 + args).
unsigned getSize() const;
+
+ /// Append the elements of this operand to \p V.
+ void appendToVector(SmallVectorImpl<uint64_t> &V) const {
+ V.append(get(), get() + getSize());
+ }
};
/// An iterator for expression operands.
@@ -2392,15 +2438,28 @@
/// Prepend \p DIExpr with a deref and offset operation and optionally turn it
/// into a stack value.
- static DIExpression *prepend(const DIExpression *DIExpr, bool DerefBefore,
+ static DIExpression *prepend(const DIExpression *Expr, bool DerefBefore,
int64_t Offset = 0, bool DerefAfter = false,
bool StackValue = false);
/// Prepend \p DIExpr with the given opcodes and optionally turn it into a
/// stack value.
- static DIExpression *doPrepend(const DIExpression *DIExpr,
- SmallVectorImpl<uint64_t> &Ops,
- bool StackValue = false);
+ static DIExpression *prependOpcodes(const DIExpression *Expr,
+ SmallVectorImpl<uint64_t> &Ops,
+ bool StackValue = false);
+
+ /// Append the opcodes \p Ops to \p DIExpr. Unlike \ref appendToStack, the
+ /// returned expression is a stack value only if \p DIExpr is a stack value.
+ /// If \p DIExpr describes a fragment, the returned expression will describe
+ /// the same fragment.
+ static DIExpression *append(const DIExpression *Expr, ArrayRef<uint64_t> Ops);
+
+ /// Convert \p DIExpr into a stack value if it isn't one already by appending
+ /// DW_OP_deref if needed, and appending \p Ops to the resulting expression.
+ /// If \p DIExpr describes a fragment, the returned expression will describe
+ /// the same fragment.
+ static DIExpression *appendToStack(const DIExpression *Expr,
+ ArrayRef<uint64_t> Ops);
/// Create a DIExpression to describe one part of an aggregate variable that
/// is fragmented across multiple Values. The DW_OP_LLVM_fragment operation
@@ -2603,6 +2662,76 @@
}
};
+/// Label.
+///
+class DILabel : public DINode {
+ friend class LLVMContextImpl;
+ friend class MDNode;
+
+ unsigned Line;
+
+ DILabel(LLVMContext &C, StorageType Storage, unsigned Line,
+ ArrayRef<Metadata *> Ops)
+ : DINode(C, DILabelKind, Storage, dwarf::DW_TAG_label, Ops), Line(Line) {}
+ ~DILabel() = default;
+
+ static DILabel *getImpl(LLVMContext &Context, DIScope *Scope,
+ StringRef Name, DIFile *File, unsigned Line,
+ StorageType Storage,
+ bool ShouldCreate = true) {
+ return getImpl(Context, Scope, getCanonicalMDString(Context, Name), File,
+ Line, Storage, ShouldCreate);
+ }
+ static DILabel *getImpl(LLVMContext &Context, Metadata *Scope,
+ MDString *Name, Metadata *File, unsigned Line,
+ StorageType Storage,
+ bool ShouldCreate = true);
+
+ TempDILabel cloneImpl() const {
+ return getTemporary(getContext(), getScope(), getName(), getFile(),
+ getLine());
+ }
+
+public:
+ DEFINE_MDNODE_GET(DILabel,
+ (DILocalScope * Scope, StringRef Name, DIFile *File,
+ unsigned Line),
+ (Scope, Name, File, Line))
+ DEFINE_MDNODE_GET(DILabel,
+ (Metadata * Scope, MDString *Name, Metadata *File,
+ unsigned Line),
+ (Scope, Name, File, Line))
+
+ TempDILabel clone() const { return cloneImpl(); }
+
+ /// Get the local scope for this label.
+ ///
+ /// Labels must be defined in a local scope.
+ DILocalScope *getScope() const {
+ return cast_or_null<DILocalScope>(getRawScope());
+ }
+ unsigned getLine() const { return Line; }
+ StringRef getName() const { return getStringOperand(1); }
+ DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
+
+ Metadata *getRawScope() const { return getOperand(0); }
+ MDString *getRawName() const { return getOperandAs<MDString>(1); }
+ Metadata *getRawFile() const { return getOperand(2); }
+
+ /// Check that a location is valid for this label.
+ ///
+ /// Check that \c DL exists, is in the same subprogram, and has the same
+ /// inlined-at location as \c this. (Otherwise, it's not a valid attachment
+ /// to a \a DbgInfoIntrinsic.)
+ bool isValidLocationForIntrinsic(const DILocation *DL) const {
+ return DL && getScope()->getSubprogram() == DL->getScope()->getSubprogram();
+ }
+
+ static bool classof(const Metadata *MD) {
+ return MD->getMetadataID() == DILabelKind;
+ }
+};
+
class DIObjCProperty : public DINode {
friend class LLVMContextImpl;
friend class MDNode;