mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-25 04:02:41 +01:00
Revert "[DebugInfo] Enforce implicit constraints on distinct MDNodes"
This reverts commit 8cd35ad854ab4458fd509447359066ea3578b494. It breaks `TestMembersAndLocalsWithSameName.py` on GreenDragon and Mikael Holmén points out in D104827 that bitcode files created with the patch cannot be parsed with binaries built before it.
This commit is contained in:
Jonas Devlieghere
parent
322eb67111
commit
3020664b33
@ -5102,18 +5102,17 @@ metadata nodes are related to debug info.
|
||||
DICompileUnit
|
||||
"""""""""""""
|
||||
|
||||
``DICompileUnit`` nodes represent a compile unit. ``DICompileUnit`` nodes must
|
||||
be ``distinct``. The ``enums:``, ``retainedTypes:``, ``globals:``, ``imports:``
|
||||
and ``macros:`` fields are tuples containing the debug info to be emitted along
|
||||
with the compile unit, regardless of code optimizations (some nodes are only
|
||||
emitted if there are references to them from instructions). The
|
||||
``debugInfoForProfiling:`` field is a boolean indicating whether or not
|
||||
line-table discriminators are updated to provide more-accurate debug info for
|
||||
profiling results.
|
||||
``DICompileUnit`` nodes represent a compile unit. The ``enums:``,
|
||||
``retainedTypes:``, ``globals:``, ``imports:`` and ``macros:`` fields are tuples
|
||||
containing the debug info to be emitted along with the compile unit, regardless
|
||||
of code optimizations (some nodes are only emitted if there are references to
|
||||
them from instructions). The ``debugInfoForProfiling:`` field is a boolean
|
||||
indicating whether or not line-table discriminators are updated to provide
|
||||
more-accurate debug info for profiling results.
|
||||
|
||||
.. code-block:: text
|
||||
|
||||
!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang",
|
||||
!0 = !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang",
|
||||
isOptimized: true, flags: "-O2", runtimeVersion: 2,
|
||||
splitDebugFilename: "abc.debug", emissionKind: FullDebug,
|
||||
enums: !2, retainedTypes: !3, globals: !4, imports: !5,
|
||||
@ -5528,14 +5527,12 @@ DIExpression
|
||||
""""""""""""
|
||||
|
||||
``DIExpression`` nodes represent expressions that are inspired by the DWARF
|
||||
expression language. ``DIExpression`` nodes must not be ``distinct``, and are
|
||||
canonically printed inline at each use. They are used in :ref:`debug
|
||||
intrinsics<dbg_intrinsics>` (such as ``llvm.dbg.declare`` and
|
||||
``llvm.dbg.value``) to describe how the referenced LLVM variable relates to the
|
||||
source language variable. Debug intrinsics are interpreted left-to-right: start
|
||||
by pushing the value/address operand of the intrinsic onto a stack, then
|
||||
repeatedly push and evaluate opcodes from the DIExpression until the final
|
||||
variable description is produced.
|
||||
expression language. They are used in :ref:`debug intrinsics<dbg_intrinsics>`
|
||||
(such as ``llvm.dbg.declare`` and ``llvm.dbg.value``) to describe how the
|
||||
referenced LLVM variable relates to the source language variable. Debug
|
||||
intrinsics are interpreted left-to-right: start by pushing the value/address
|
||||
operand of the intrinsic onto a stack, then repeatedly push and evaluate
|
||||
opcodes from the DIExpression until the final variable description is produced.
|
||||
|
||||
The current supported opcode vocabulary is limited:
|
||||
|
||||
@ -5613,23 +5610,23 @@ The current supported opcode vocabulary is limited:
|
||||
|
||||
IR for "*ptr = 4;"
|
||||
--------------
|
||||
call void @llvm.dbg.value(metadata i32 4, metadata !17,
|
||||
metadata !DIExpression(DW_OP_LLVM_implicit_pointer)))
|
||||
call void @llvm.dbg.value(metadata i32 4, metadata !17, metadata !20)
|
||||
!17 = !DILocalVariable(name: "ptr1", scope: !12, file: !3, line: 5,
|
||||
type: !18)
|
||||
!18 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !19, size: 64)
|
||||
!19 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
|
||||
!20 = !DIExpression(DW_OP_LLVM_implicit_pointer))
|
||||
|
||||
IR for "**ptr = 4;"
|
||||
--------------
|
||||
call void @llvm.dbg.value(metadata i32 4, metadata !17,
|
||||
metadata !DIExpression(DW_OP_LLVM_implicit_pointer,
|
||||
DW_OP_LLVM_implicit_pointer)))
|
||||
call void @llvm.dbg.value(metadata i32 4, metadata !17, metadata !21)
|
||||
!17 = !DILocalVariable(name: "ptr1", scope: !12, file: !3, line: 5,
|
||||
type: !18)
|
||||
!18 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !19, size: 64)
|
||||
!19 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !20, size: 64)
|
||||
!20 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
|
||||
!21 = !DIExpression(DW_OP_LLVM_implicit_pointer,
|
||||
DW_OP_LLVM_implicit_pointer))
|
||||
|
||||
DWARF specifies three kinds of simple location descriptions: Register, memory,
|
||||
and implicit location descriptions. Note that a location description is
|
||||
@ -5670,13 +5667,12 @@ valid debug intrinsic.
|
||||
DIArgList
|
||||
""""""""""""
|
||||
|
||||
``DIArgList`` nodes hold a list of constant or SSA value references.
|
||||
``DIArgList`` must not be ``distinct``, must only be used as an argument to a
|
||||
function call, and must appear inline at each use. ``DIArgList`` may refer to
|
||||
function-local values of the containing function. ``DIArgList`` nodes are used
|
||||
in :ref:`debug intrinsics<dbg_intrinsics>` (currently only in
|
||||
``DIArgList`` nodes hold a list of constant or SSA value references. These are
|
||||
used in :ref:`debug intrinsics<dbg_intrinsics>` (currently only in
|
||||
``llvm.dbg.value``) in combination with a ``DIExpression`` that uses the
|
||||
``DW_OP_LLVM_arg`` operator.
|
||||
``DW_OP_LLVM_arg`` operator. Because a DIArgList may refer to local values
|
||||
within a function, it must only be used as a function argument, must always be
|
||||
inlined, and cannot appear in named metadata.
|
||||
|
||||
.. code-block:: text
|
||||
|
||||
|
||||
@ -291,17 +291,17 @@ Compiled to LLVM, this function would be represented like this:
|
||||
%X = alloca i32, align 4
|
||||
%Y = alloca i32, align 4
|
||||
%Z = alloca i32, align 4
|
||||
call void @llvm.dbg.declare(metadata i32* %X, metadata !11, metadata !DIExpression()), !dbg !13
|
||||
store i32 21, i32* %X, align 4, !dbg !13
|
||||
call void @llvm.dbg.declare(metadata i32* %Y, metadata !14, metadata !DIExpression()), !dbg !15
|
||||
store i32 22, i32* %Y, align 4, !dbg !15
|
||||
call void @llvm.dbg.declare(metadata i32* %Z, metadata !16, metadata !DIExpression()), !dbg !18
|
||||
store i32 23, i32* %Z, align 4, !dbg !18
|
||||
%0 = load i32, i32* %X, align 4, !dbg !19
|
||||
store i32 %0, i32* %Z, align 4, !dbg !20
|
||||
%1 = load i32, i32* %Y, align 4, !dbg !21
|
||||
store i32 %1, i32* %X, align 4, !dbg !22
|
||||
ret void, !dbg !23
|
||||
call void @llvm.dbg.declare(metadata i32* %X, metadata !11, metadata !13), !dbg !14
|
||||
store i32 21, i32* %X, align 4, !dbg !14
|
||||
call void @llvm.dbg.declare(metadata i32* %Y, metadata !15, metadata !13), !dbg !16
|
||||
store i32 22, i32* %Y, align 4, !dbg !16
|
||||
call void @llvm.dbg.declare(metadata i32* %Z, metadata !17, metadata !13), !dbg !19
|
||||
store i32 23, i32* %Z, align 4, !dbg !19
|
||||
%0 = load i32, i32* %X, align 4, !dbg !20
|
||||
store i32 %0, i32* %Z, align 4, !dbg !21
|
||||
%1 = load i32, i32* %Y, align 4, !dbg !22
|
||||
store i32 %1, i32* %X, align 4, !dbg !23
|
||||
ret void, !dbg !24
|
||||
}
|
||||
|
||||
; Function Attrs: nounwind readnone
|
||||
@ -327,17 +327,18 @@ Compiled to LLVM, this function would be represented like this:
|
||||
!10 = !{!"clang version 3.7.0 (trunk 231150) (llvm/trunk 231154)"}
|
||||
!11 = !DILocalVariable(name: "X", scope: !4, file: !1, line: 2, type: !12)
|
||||
!12 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
|
||||
!13 = !DILocation(line: 2, column: 9, scope: !4)
|
||||
!14 = !DILocalVariable(name: "Y", scope: !4, file: !1, line: 3, type: !12)
|
||||
!15 = !DILocation(line: 3, column: 9, scope: !4)
|
||||
!16 = !DILocalVariable(name: "Z", scope: !17, file: !1, line: 5, type: !12)
|
||||
!17 = distinct !DILexicalBlock(scope: !4, file: !1, line: 4, column: 5)
|
||||
!18 = !DILocation(line: 5, column: 11, scope: !17)
|
||||
!19 = !DILocation(line: 6, column: 11, scope: !17)
|
||||
!20 = !DILocation(line: 6, column: 9, scope: !17)
|
||||
!21 = !DILocation(line: 8, column: 9, scope: !4)
|
||||
!22 = !DILocation(line: 8, column: 7, scope: !4)
|
||||
!23 = !DILocation(line: 9, column: 3, scope: !4)
|
||||
!13 = !DIExpression()
|
||||
!14 = !DILocation(line: 2, column: 9, scope: !4)
|
||||
!15 = !DILocalVariable(name: "Y", scope: !4, file: !1, line: 3, type: !12)
|
||||
!16 = !DILocation(line: 3, column: 9, scope: !4)
|
||||
!17 = !DILocalVariable(name: "Z", scope: !18, file: !1, line: 5, type: !12)
|
||||
!18 = distinct !DILexicalBlock(scope: !4, file: !1, line: 4, column: 5)
|
||||
!19 = !DILocation(line: 5, column: 11, scope: !18)
|
||||
!20 = !DILocation(line: 6, column: 11, scope: !18)
|
||||
!21 = !DILocation(line: 6, column: 9, scope: !18)
|
||||
!22 = !DILocation(line: 8, column: 9, scope: !4)
|
||||
!23 = !DILocation(line: 8, column: 7, scope: !4)
|
||||
!24 = !DILocation(line: 9, column: 3, scope: !4)
|
||||
|
||||
|
||||
This example illustrates a few important details about LLVM debugging
|
||||
@ -348,21 +349,21 @@ variable definitions, and the code used to implement the function.
|
||||
|
||||
.. code-block:: llvm
|
||||
|
||||
call void @llvm.dbg.declare(metadata i32* %X, metadata !11, metadata !DIExpression()), !dbg !13
|
||||
call void @llvm.dbg.declare(metadata i32* %X, metadata !11, metadata !13), !dbg !14
|
||||
; [debug line = 2:7] [debug variable = X]
|
||||
|
||||
The first intrinsic ``%llvm.dbg.declare`` encodes debugging information for the
|
||||
variable ``X``. The metadata ``!dbg !13`` attached to the intrinsic provides
|
||||
variable ``X``. The metadata ``!dbg !14`` attached to the intrinsic provides
|
||||
scope information for the variable ``X``.
|
||||
|
||||
.. code-block:: text
|
||||
|
||||
!13 = !DILocation(line: 2, column: 9, scope: !4)
|
||||
!14 = !DILocation(line: 2, column: 9, scope: !4)
|
||||
!4 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !5,
|
||||
isLocal: false, isDefinition: true, scopeLine: 1,
|
||||
isOptimized: false, variables: !2)
|
||||
|
||||
Here ``!13`` is metadata providing `location information
|
||||
Here ``!14`` is metadata providing `location information
|
||||
<LangRef.html#dilocation>`_. In this example, scope is encoded by ``!4``, a
|
||||
`subprogram descriptor <LangRef.html#disubprogram>`_. This way the location
|
||||
information attached to the intrinsics indicates that the variable ``X`` is
|
||||
@ -372,20 +373,20 @@ Now lets take another example.
|
||||
|
||||
.. code-block:: llvm
|
||||
|
||||
call void @llvm.dbg.declare(metadata i32* %Z, metadata !16, metadata !DIExpression()), !dbg !18
|
||||
call void @llvm.dbg.declare(metadata i32* %Z, metadata !17, metadata !13), !dbg !19
|
||||
; [debug line = 5:9] [debug variable = Z]
|
||||
|
||||
The third intrinsic ``%llvm.dbg.declare`` encodes debugging information for
|
||||
variable ``Z``. The metadata ``!dbg !18`` attached to the intrinsic provides
|
||||
variable ``Z``. The metadata ``!dbg !19`` attached to the intrinsic provides
|
||||
scope information for the variable ``Z``.
|
||||
|
||||
.. code-block:: text
|
||||
|
||||
!17 = distinct !DILexicalBlock(scope: !4, file: !1, line: 4, column: 5)
|
||||
!18 = !DILocation(line: 5, column: 11, scope: !17)
|
||||
!18 = distinct !DILexicalBlock(scope: !4, file: !1, line: 4, column: 5)
|
||||
!19 = !DILocation(line: 5, column: 11, scope: !18)
|
||||
|
||||
Here ``!18`` indicates that ``Z`` is declared at line number 5 and column
|
||||
number 11 inside of lexical scope ``!17``. The lexical scope itself resides
|
||||
Here ``!19`` indicates that ``Z`` is declared at line number 5 and column
|
||||
number 11 inside of lexical scope ``!18``. The lexical scope itself resides
|
||||
inside of subprogram ``!4`` described above.
|
||||
|
||||
The scope information attached with each instruction provides a straightforward
|
||||
@ -799,14 +800,14 @@ presents several difficulties:
|
||||
br label %exit, !dbg !26
|
||||
|
||||
truebr:
|
||||
call void @llvm.dbg.value(metadata i32 %input, metadata !30, metadata !DIExpression()), !dbg !23
|
||||
call void @llvm.dbg.value(metadata i32 1, metadata !22, metadata !DIExpression()), !dbg !23
|
||||
call void @llvm.dbg.value(metadata i32 %input, metadata !30, metadata !DIExpression()), !dbg !24
|
||||
call void @llvm.dbg.value(metadata i32 1, metadata !23, metadata !DIExpression()), !dbg !24
|
||||
%value1 = add i32 %input, 1
|
||||
br label %bb1
|
||||
|
||||
falsebr:
|
||||
call void @llvm.dbg.value(metadata i32 %input, metadata !30, metadata !DIExpression()), !dbg !23
|
||||
call void @llvm.dbg.value(metadata i32 2, metadata !22, metadata !DIExpression()), !dbg !23
|
||||
call void @llvm.dbg.value(metadata i32 %input, metadata !30, metadata !DIExpression()), !dbg !24
|
||||
call void @llvm.dbg.value(metadata i32 2, metadata !23, metadata !DIExpression()), !dbg !24
|
||||
%value = add i32 %input, 2
|
||||
br label %bb1
|
||||
|
||||
@ -817,7 +818,7 @@ presents several difficulties:
|
||||
Here the difficulties are:
|
||||
|
||||
* The control flow is roughly the opposite of basic block order
|
||||
* The value of the ``!22`` variable merges into ``%bb1``, but there is no PHI
|
||||
* The value of the ``!23`` variable merges into ``%bb1``, but there is no PHI
|
||||
node
|
||||
|
||||
As mentioned above, the ``llvm.dbg.value`` intrinsics essentially form an
|
||||
@ -830,9 +831,9 @@ location, which would lead to a large number of debugging intrinsics being
|
||||
generated.
|
||||
|
||||
Examining the example above, variable ``!30`` is assigned ``%input`` on both
|
||||
conditional paths through the function, while ``!22`` is assigned differing
|
||||
conditional paths through the function, while ``!23`` is assigned differing
|
||||
constant values on either path. Where control flow merges in ``%bb1`` we would
|
||||
want ``!30`` to keep its location (``%input``), but ``!22`` to become undefined
|
||||
want ``!30`` to keep its location (``%input``), but ``!23`` to become undefined
|
||||
as we cannot determine at runtime what value it should have in %bb1 without
|
||||
inserting a PHI node. mem2reg does not insert the PHI node to avoid changing
|
||||
codegen when debugging is enabled, and does not insert the other dbg.values
|
||||
@ -851,7 +852,7 @@ DbgEntityHistoryCalculator) to build a map of each instruction to every
|
||||
valid variable location, without the need to consider control flow. From
|
||||
the example above, it is otherwise difficult to determine that the location
|
||||
of variable ``!30`` should flow "up" into block ``%bb1``, but that the location
|
||||
of variable ``!22`` should not flow "down" into the ``%exit`` block.
|
||||
of variable ``!23`` should not flow "down" into the ``%exit`` block.
|
||||
|
||||
.. _ccxx_frontend:
|
||||
|
||||
|
||||
@ -533,8 +533,7 @@ namespace llvm {
|
||||
template <class ParserTy> bool parseMDFieldsImplBody(ParserTy ParseField);
|
||||
template <class ParserTy>
|
||||
bool parseMDFieldsImpl(ParserTy ParseField, LocTy &ClosingLoc);
|
||||
bool parseSpecializedMDNode(MDNode *&N, bool IsDistinct = false,
|
||||
LocTy DistinctLoc = LocTy());
|
||||
bool parseSpecializedMDNode(MDNode *&N, bool IsDistinct = false);
|
||||
|
||||
#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \
|
||||
bool parse##CLASS(MDNode *&Result, bool IsDistinct);
|
||||
|
||||
@ -8,39 +8,12 @@
|
||||
//
|
||||
// Macros for running through all types of metadata.
|
||||
//
|
||||
// Definitions for terms used to describe metadata include:
|
||||
//
|
||||
// * BRANCH: refers to an "abstract" metadata kind, which exists only in the
|
||||
// C++ class hierarchy. These cannot appear directly in IR/bitcode.
|
||||
// * LEAF: refers to a "concrete" metadata kind. These can appear directly in
|
||||
// IR/bitcode.
|
||||
// * SPECIALIZED: refers to non-MDTuple MDNodes, i.e. those that use the
|
||||
// syntax "!CLASS(...)" in IR.
|
||||
// * UNIQUABLE: refers to nodes which can use uniqued, distinct, or temporary
|
||||
// storage without any restrictions.
|
||||
// * UNIQUED: refers to nodes which must use uniqued or temporary storage.
|
||||
// * DISTINCT: refers to nodes which must use distinct or temporary storage.
|
||||
//
|
||||
// In LLVM IR, UNIQUABLE and DISTINCT nodes must be referred to by MDNode ID,
|
||||
// as in `!0`, whereas UNIQUED nodes canonically appear inline at each use, as
|
||||
// in `DIExpression(...)`. This is because `distinct` nodes maintain their
|
||||
// identity irrespective of contents, making the inline syntax ambiguous in
|
||||
// some cases.
|
||||
//
|
||||
// Note: UNIQUABLE, UNIQUED, and DISTINCT are mutually exclusive. For example,
|
||||
// code which intends to consider all nodes which can use uniqued storage must
|
||||
// consider both UNIQUABLE and UNIQUED nodes.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#if !(defined HANDLE_METADATA || defined HANDLE_METADATA_LEAF || \
|
||||
defined HANDLE_METADATA_BRANCH || defined HANDLE_MDNODE_LEAF || \
|
||||
defined HANDLE_MDNODE_LEAF_UNIQUABLE || \
|
||||
defined HANDLE_MDNODE_LEAF_UNIQUED || \
|
||||
defined HANDLE_MDNODE_LEAF_DISTINCT || defined HANDLE_MDNODE_BRANCH || \
|
||||
defined HANDLE_MDNODE_LEAF_UNIQUABLE || defined HANDLE_MDNODE_BRANCH || \
|
||||
defined HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE || \
|
||||
defined HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUED || \
|
||||
defined HANDLE_SPECIALIZED_MDNODE_LEAF_DISTINCT || \
|
||||
defined HANDLE_SPECIALIZED_MDNODE_LEAF || \
|
||||
defined HANDLE_SPECIALIZED_MDNODE_BRANCH)
|
||||
#error "Missing macro definition of HANDLE_METADATA*"
|
||||
@ -74,47 +47,11 @@
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Handler for specialized and always-uniqued leaf nodes under MDNode. Defers to
|
||||
// HANDLE_MDNODE_LEAF_UNIQUED if it's defined, otherwise to
|
||||
// HANDLE_SPECIALIZED_MDNODE_LEAF.
|
||||
#ifndef HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUED
|
||||
#ifdef HANDLE_MDNODE_LEAF_UNIQUED
|
||||
#define HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUED(CLASS) \
|
||||
HANDLE_MDNODE_LEAF_UNIQUED(CLASS)
|
||||
#else
|
||||
#define HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUED(CLASS) \
|
||||
HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Handler for specialized and always-distinct leaf nodes under MDNode. Defers
|
||||
// to HANDLE_MDNODE_LEAF_DISTINCT if it's defined, otherwise to
|
||||
// HANDLE_SPECIALIZED_MDNODE_LEAF.
|
||||
#ifndef HANDLE_SPECIALIZED_MDNODE_LEAF_DISTINCT
|
||||
#ifdef HANDLE_MDNODE_LEAF_DISTINCT
|
||||
#define HANDLE_SPECIALIZED_MDNODE_LEAF_DISTINCT(CLASS) \
|
||||
HANDLE_MDNODE_LEAF_DISTINCT(CLASS)
|
||||
#else
|
||||
#define HANDLE_SPECIALIZED_MDNODE_LEAF_DISTINCT(CLASS) \
|
||||
HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Handler for uniquable leaf nodes under MDNode.
|
||||
// Handler for leaf nodes under MDNode.
|
||||
#ifndef HANDLE_MDNODE_LEAF_UNIQUABLE
|
||||
#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) HANDLE_MDNODE_LEAF(CLASS)
|
||||
#endif
|
||||
|
||||
// Handler for uniqued leaf nodes under MDNode.
|
||||
#ifndef HANDLE_MDNODE_LEAF_UNIQUED
|
||||
#define HANDLE_MDNODE_LEAF_UNIQUED(CLASS) HANDLE_MDNODE_LEAF(CLASS)
|
||||
#endif
|
||||
|
||||
// Handler for distinct leaf nodes under MDNode.
|
||||
#ifndef HANDLE_MDNODE_LEAF_DISTINCT
|
||||
#define HANDLE_MDNODE_LEAF_DISTINCT(CLASS) HANDLE_MDNODE_LEAF(CLASS)
|
||||
#endif
|
||||
|
||||
// Handler for leaf nodes under MDNode.
|
||||
#ifndef HANDLE_MDNODE_LEAF
|
||||
#define HANDLE_MDNODE_LEAF(CLASS) HANDLE_METADATA_LEAF(CLASS)
|
||||
@ -143,7 +80,7 @@ HANDLE_METADATA_LEAF(DistinctMDOperandPlaceholder)
|
||||
HANDLE_MDNODE_BRANCH(MDNode)
|
||||
HANDLE_MDNODE_LEAF_UNIQUABLE(MDTuple)
|
||||
HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DILocation)
|
||||
HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUED(DIExpression)
|
||||
HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIExpression)
|
||||
HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIGlobalVariableExpression)
|
||||
HANDLE_SPECIALIZED_MDNODE_BRANCH(DINode)
|
||||
HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(GenericDINode)
|
||||
@ -156,7 +93,7 @@ HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIDerivedType)
|
||||
HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DICompositeType)
|
||||
HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DISubroutineType)
|
||||
HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIFile)
|
||||
HANDLE_SPECIALIZED_MDNODE_LEAF_DISTINCT(DICompileUnit)
|
||||
HANDLE_SPECIALIZED_MDNODE_LEAF(DICompileUnit)
|
||||
HANDLE_SPECIALIZED_MDNODE_BRANCH(DILocalScope)
|
||||
HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DISubprogram)
|
||||
HANDLE_SPECIALIZED_MDNODE_BRANCH(DILexicalBlockBase)
|
||||
@ -177,7 +114,7 @@ HANDLE_SPECIALIZED_MDNODE_BRANCH(DIMacroNode)
|
||||
HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIMacro)
|
||||
HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIMacroFile)
|
||||
HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DICommonBlock)
|
||||
HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUED(DIArgList)
|
||||
HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIArgList)
|
||||
HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIStringType)
|
||||
HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIGenericSubrange)
|
||||
|
||||
@ -186,11 +123,7 @@ HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIGenericSubrange)
|
||||
#undef HANDLE_METADATA_BRANCH
|
||||
#undef HANDLE_MDNODE_LEAF
|
||||
#undef HANDLE_MDNODE_LEAF_UNIQUABLE
|
||||
#undef HANDLE_MDNODE_LEAF_UNIQUED
|
||||
#undef HANDLE_MDNODE_LEAF_DISTINCT
|
||||
#undef HANDLE_MDNODE_BRANCH
|
||||
#undef HANDLE_SPECIALIZED_MDNODE_LEAF
|
||||
#undef HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE
|
||||
#undef HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUED
|
||||
#undef HANDLE_SPECIALIZED_MDNODE_LEAF_DISTINCT
|
||||
#undef HANDLE_SPECIALIZED_MDNODE_BRANCH
|
||||
|
||||
@ -740,25 +740,23 @@ bool LLParser::parseNamedMetadata() {
|
||||
return true;
|
||||
|
||||
NamedMDNode *NMD = M->getOrInsertNamedMetadata(Name);
|
||||
|
||||
if (Lex.getKind() == lltok::rbrace) {
|
||||
Lex.Lex();
|
||||
return false;
|
||||
}
|
||||
|
||||
if (Lex.getKind() != lltok::rbrace)
|
||||
do {
|
||||
MDNode *N = nullptr;
|
||||
// Parse uniqued MDNodes inline as a special case.
|
||||
#define HANDLE_MDNODE_LEAF_UNIQUED(CLASS) \
|
||||
if (Lex.getKind() == lltok::MetadataVar && Lex.getStrVal() == #CLASS) { \
|
||||
if (parse##CLASS(N, /*IsDistinct=*/false)) \
|
||||
return true; \
|
||||
NMD->addOperand(N); \
|
||||
continue; \
|
||||
}
|
||||
#include "llvm/IR/Metadata.def"
|
||||
// Parse all other MDNodes as an MDNodeID.
|
||||
if (parseToken(lltok::exclaim, "Expected '!' here") || parseMDNodeID(N)) {
|
||||
// parse DIExpressions inline as a special case. They are still MDNodes,
|
||||
// so they can still appear in named metadata. Remove this logic if they
|
||||
// become plain Metadata.
|
||||
if (Lex.getKind() == lltok::MetadataVar &&
|
||||
Lex.getStrVal() == "DIExpression") {
|
||||
if (parseDIExpression(N, /*IsDistinct=*/false))
|
||||
return true;
|
||||
// DIArgLists should only appear inline in a function, as they may
|
||||
// contain LocalAsMetadata arguments which require a function context.
|
||||
} else if (Lex.getKind() == lltok::MetadataVar &&
|
||||
Lex.getStrVal() == "DIArgList") {
|
||||
return tokError("found DIArgList outside of function");
|
||||
} else if (parseToken(lltok::exclaim, "Expected '!' here") ||
|
||||
parseMDNodeID(N)) {
|
||||
return true;
|
||||
}
|
||||
NMD->addOperand(N);
|
||||
@ -782,10 +780,9 @@ bool LLParser::parseStandaloneMetadata() {
|
||||
if (Lex.getKind() == lltok::Type)
|
||||
return tokError("unexpected type in metadata definition");
|
||||
|
||||
auto DistinctLoc = Lex.getLoc();
|
||||
bool IsDistinct = EatIfPresent(lltok::kw_distinct);
|
||||
if (Lex.getKind() == lltok::MetadataVar) {
|
||||
if (parseSpecializedMDNode(Init, IsDistinct, DistinctLoc))
|
||||
if (parseSpecializedMDNode(Init, IsDistinct))
|
||||
return true;
|
||||
} else if (parseToken(lltok::exclaim, "Expected '!' here") ||
|
||||
parseMDTuple(Init, IsDistinct))
|
||||
@ -4681,25 +4678,12 @@ bool LLParser::parseMDField(StringRef Name, FieldTy &Result) {
|
||||
return parseMDField(Loc, Name, Result);
|
||||
}
|
||||
|
||||
bool LLParser::parseSpecializedMDNode(MDNode *&N, bool IsDistinct,
|
||||
LocTy DistinctLoc) {
|
||||
bool LLParser::parseSpecializedMDNode(MDNode *&N, bool IsDistinct) {
|
||||
assert(Lex.getKind() == lltok::MetadataVar && "Expected metadata type name");
|
||||
|
||||
#define HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(CLASS) \
|
||||
#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \
|
||||
if (Lex.getStrVal() == #CLASS) \
|
||||
return parse##CLASS(N, IsDistinct);
|
||||
#define HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUED(CLASS) \
|
||||
if (Lex.getStrVal() == #CLASS) { \
|
||||
if (IsDistinct) \
|
||||
return error(DistinctLoc, "'distinct' not allowed for !" #CLASS); \
|
||||
return parse##CLASS(N, IsDistinct); \
|
||||
}
|
||||
#define HANDLE_SPECIALIZED_MDNODE_LEAF_DISTINCT(CLASS) \
|
||||
if (Lex.getStrVal() == #CLASS) { \
|
||||
if (!IsDistinct) \
|
||||
return error(DistinctLoc, "missing 'distinct', required for !" #CLASS); \
|
||||
return parse##CLASS(N, IsDistinct); \
|
||||
}
|
||||
#include "llvm/IR/Metadata.def"
|
||||
|
||||
return tokError("expected metadata type");
|
||||
@ -5043,6 +5027,9 @@ bool LLParser::parseDIFile(MDNode *&Result, bool IsDistinct) {
|
||||
/// globals: !4, imports: !5, macros: !6, dwoId: 0x0abcd,
|
||||
/// sysroot: "/", sdk: "MacOSX.sdk")
|
||||
bool LLParser::parseDICompileUnit(MDNode *&Result, bool IsDistinct) {
|
||||
if (!IsDistinct)
|
||||
return Lex.Error("missing 'distinct', required for !DICompileUnit");
|
||||
|
||||
#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
|
||||
REQUIRED(language, DwarfLangField, ); \
|
||||
REQUIRED(file, MDField, (/* AllowNull */ false)); \
|
||||
@ -5406,7 +5393,7 @@ bool LLParser::parseDIExpression(MDNode *&Result, bool IsDistinct) {
|
||||
}
|
||||
|
||||
bool LLParser::parseDIArgList(MDNode *&Result, bool IsDistinct) {
|
||||
return tokError("!DIArgList cannot appear outside of a function");
|
||||
return parseDIArgList(Result, IsDistinct, nullptr);
|
||||
}
|
||||
/// ParseDIArgList:
|
||||
/// ::= !DIArgList(i32 7, i64 %0)
|
||||
|
||||
@ -555,7 +555,7 @@ class MetadataLoader::MetadataLoaderImpl {
|
||||
}
|
||||
|
||||
/// Upgrade the expression from previous versions.
|
||||
Error upgradeDIExpression(uint64_t FromVersion, bool &IsDistinct,
|
||||
Error upgradeDIExpression(uint64_t FromVersion,
|
||||
MutableArrayRef<uint64_t> &Expr,
|
||||
SmallVectorImpl<uint64_t> &Buffer) {
|
||||
auto N = Expr.size();
|
||||
@ -629,9 +629,6 @@ class MetadataLoader::MetadataLoaderImpl {
|
||||
LLVM_FALLTHROUGH;
|
||||
}
|
||||
case 3:
|
||||
IsDistinct = false;
|
||||
LLVM_FALLTHROUGH;
|
||||
case 4:
|
||||
// Up-to-date!
|
||||
break;
|
||||
}
|
||||
@ -1984,12 +1981,9 @@ Error MetadataLoader::MetadataLoaderImpl::parseOneMetadata(
|
||||
auto Elts = MutableArrayRef<uint64_t>(Record).slice(1);
|
||||
|
||||
SmallVector<uint64_t, 6> Buffer;
|
||||
if (Error Err = upgradeDIExpression(Version, IsDistinct, Elts, Buffer))
|
||||
if (Error Err = upgradeDIExpression(Version, Elts, Buffer))
|
||||
return Err;
|
||||
|
||||
if (IsDistinct)
|
||||
return error("Invalid record");
|
||||
|
||||
MetadataList.assignValue(
|
||||
GET_OR_DISTINCT(DIExpression, (Context, Elts)), NextMetadataNo);
|
||||
NextMetadataNo++;
|
||||
|
||||
@ -1758,6 +1758,7 @@ void ModuleBitcodeWriter::writeDIFile(const DIFile *N,
|
||||
void ModuleBitcodeWriter::writeDICompileUnit(const DICompileUnit *N,
|
||||
SmallVectorImpl<uint64_t> &Record,
|
||||
unsigned Abbrev) {
|
||||
assert(N->isDistinct() && "Expected distinct compile units");
|
||||
Record.push_back(/* IsDistinct */ true);
|
||||
Record.push_back(N->getSourceLanguage());
|
||||
Record.push_back(VE.getMetadataOrNullID(N->getFile()));
|
||||
@ -2008,7 +2009,7 @@ void ModuleBitcodeWriter::writeDIExpression(const DIExpression *N,
|
||||
SmallVectorImpl<uint64_t> &Record,
|
||||
unsigned Abbrev) {
|
||||
Record.reserve(N->getElements().size() + 1);
|
||||
const uint64_t Version = 4 << 1;
|
||||
const uint64_t Version = 3 << 1;
|
||||
Record.push_back((uint64_t)N->isDistinct() | Version);
|
||||
Record.append(N->elements_begin(), N->elements_end());
|
||||
|
||||
@ -2153,20 +2154,6 @@ void ModuleBitcodeWriter::writeMetadataRecords(
|
||||
if (const MDNode *N = dyn_cast<MDNode>(MD)) {
|
||||
assert(N->isResolved() && "Expected forward references to be resolved");
|
||||
|
||||
#ifndef NDEBUG
|
||||
switch (N->getMetadataID()) {
|
||||
#define HANDLE_MDNODE_LEAF_UNIQUED(CLASS) \
|
||||
case Metadata::CLASS##Kind: \
|
||||
assert(!N->isDistinct() && "Expected non-distinct " #CLASS); \
|
||||
break;
|
||||
#define HANDLE_MDNODE_LEAF_DISTINCT(CLASS) \
|
||||
case Metadata::CLASS##Kind: \
|
||||
assert(N->isDistinct() && "Expected distinct " #CLASS); \
|
||||
break;
|
||||
#include "llvm/IR/Metadata.def"
|
||||
}
|
||||
#endif
|
||||
|
||||
switch (N->getMetadataID()) {
|
||||
default:
|
||||
llvm_unreachable("Invalid MDNode subclass");
|
||||
|
||||
@ -1182,7 +1182,6 @@ bool MIParser::parseStandaloneMDNode(MDNode *&Node) {
|
||||
if (parseMDNode(Node))
|
||||
return true;
|
||||
} else if (Token.is(MIToken::md_diexpr)) {
|
||||
// FIXME: This should be driven off of the UNIQUED property in Metadata.def
|
||||
if (parseDIExpression(Node))
|
||||
return true;
|
||||
} else if (Token.is(MIToken::md_dilocation)) {
|
||||
@ -2326,7 +2325,6 @@ bool MIParser::parseMetadataOperand(MachineOperand &Dest) {
|
||||
if (parseMDNode(Node))
|
||||
return true;
|
||||
} else if (Token.is(MIToken::md_diexpr)) {
|
||||
// FIXME: This should be driven off of the UNIQUED property in Metadata.def
|
||||
if (parseDIExpression(Node))
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -1235,11 +1235,10 @@ void SlotTracker::CreateFunctionSlot(const Value *V) {
|
||||
void SlotTracker::CreateMetadataSlot(const MDNode *N) {
|
||||
assert(N && "Can't insert a null Value into SlotTracker!");
|
||||
|
||||
// Don't make slots for uniqued nodes. We just print them inline everywhere.
|
||||
#define HANDLE_MDNODE_LEAF_UNIQUED(CLASS) \
|
||||
if (isa<CLASS>(N)) \
|
||||
// Don't make slots for DIExpressions or DIArgLists. We just print them inline
|
||||
// everywhere.
|
||||
if (isa<DIExpression>(N) || isa<DIArgList>(N))
|
||||
return;
|
||||
#include "llvm/IR/Metadata.def"
|
||||
|
||||
unsigned DestSlot = mdnNext;
|
||||
if (!mdnMap.insert(std::make_pair(N, DestSlot)).second)
|
||||
@ -2357,7 +2356,9 @@ static void writeDIExpression(raw_ostream &Out, const DIExpression *N,
|
||||
|
||||
static void writeDIArgList(raw_ostream &Out, const DIArgList *N,
|
||||
TypePrinting *TypePrinter, SlotTracker *Machine,
|
||||
const Module *Context) {
|
||||
const Module *Context, bool FromValue = false) {
|
||||
assert(FromValue &&
|
||||
"Unexpected DIArgList metadata outside of value argument");
|
||||
Out << "!DIArgList(";
|
||||
FieldSeparator FS;
|
||||
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
|
||||
@ -2515,16 +2516,16 @@ static void WriteAsOperandInternal(raw_ostream &Out, const Metadata *MD,
|
||||
TypePrinting *TypePrinter,
|
||||
SlotTracker *Machine, const Module *Context,
|
||||
bool FromValue) {
|
||||
assert((FromValue || !(isa<LocalAsMetadata>(MD) || isa<DIArgList>(MD))) &&
|
||||
"Unexpected function-local metadata outside of value argument");
|
||||
|
||||
// Write uniqued MDNodes inline when used as a value.
|
||||
#define HANDLE_MDNODE_LEAF_UNIQUED(CLASS) \
|
||||
if (const CLASS *N = dyn_cast<CLASS>(MD)) { \
|
||||
write##CLASS(Out, N, TypePrinter, Machine, Context); \
|
||||
return; \
|
||||
// Write DIExpressions and DIArgLists inline when used as a value. Improves
|
||||
// readability of debug info intrinsics.
|
||||
if (const DIExpression *Expr = dyn_cast<DIExpression>(MD)) {
|
||||
writeDIExpression(Out, Expr, TypePrinter, Machine, Context);
|
||||
return;
|
||||
}
|
||||
if (const DIArgList *ArgList = dyn_cast<DIArgList>(MD)) {
|
||||
writeDIArgList(Out, ArgList, TypePrinter, Machine, Context, FromValue);
|
||||
return;
|
||||
}
|
||||
#include "llvm/IR/Metadata.def"
|
||||
|
||||
if (const MDNode *N = dyn_cast<MDNode>(MD)) {
|
||||
std::unique_ptr<SlotTracker> MachineStorage;
|
||||
@ -2555,6 +2556,9 @@ static void WriteAsOperandInternal(raw_ostream &Out, const Metadata *MD,
|
||||
|
||||
auto *V = cast<ValueAsMetadata>(MD);
|
||||
assert(TypePrinter && "TypePrinter required for metadata values");
|
||||
assert((FromValue || !isa<LocalAsMetadata>(V)) &&
|
||||
"Unexpected function-local metadata outside of value argument");
|
||||
|
||||
TypePrinter->print(V->getValue()->getType(), Out);
|
||||
Out << ' ';
|
||||
WriteAsOperandInternal(Out, V->getValue(), TypePrinter, Machine, Context);
|
||||
@ -3443,17 +3447,15 @@ void AssemblyWriter::printNamedMDNode(const NamedMDNode *NMD) {
|
||||
if (i)
|
||||
Out << ", ";
|
||||
|
||||
// Write UNIQUED nodes inline.
|
||||
// Write DIExpressions inline.
|
||||
// FIXME: Ban DIExpressions in NamedMDNodes, they will serve no purpose.
|
||||
MDNode *Op = NMD->getOperand(i);
|
||||
assert(!isa<DIArgList>(Op) &&
|
||||
"DIArgLists should not appear in NamedMDNodes");
|
||||
#define HANDLE_MDNODE_LEAF_UNIQUED(CLASS) \
|
||||
if (auto *N = dyn_cast<CLASS>(Op)) { \
|
||||
write##CLASS(Out, N, nullptr, nullptr, nullptr); \
|
||||
continue; \
|
||||
if (auto *Expr = dyn_cast<DIExpression>(Op)) {
|
||||
writeDIExpression(Out, Expr, nullptr, nullptr, nullptr);
|
||||
continue;
|
||||
}
|
||||
#include "llvm/IR/Metadata.def"
|
||||
|
||||
int Slot = Machine.getMetadataSlot(Op);
|
||||
if (Slot == -1)
|
||||
@ -4710,18 +4712,12 @@ static void printMetadataImpl(raw_ostream &ROS, const Metadata &MD,
|
||||
|
||||
TypePrinting TypePrinter(M);
|
||||
|
||||
WriteAsOperandInternal(OS, &MD, &TypePrinter, MST.getMachine(), M);
|
||||
WriteAsOperandInternal(OS, &MD, &TypePrinter, MST.getMachine(), M,
|
||||
/* FromValue */ true);
|
||||
|
||||
auto *N = dyn_cast<MDNode>(&MD);
|
||||
if (OnlyAsOperand || !N) {
|
||||
if (OnlyAsOperand || !N || isa<DIExpression>(MD) || isa<DIArgList>(MD))
|
||||
return;
|
||||
}
|
||||
// Uniqued MDNodes are always treated as if OnlyAsOperand, as they are
|
||||
// printed inline.
|
||||
#define HANDLE_MDNODE_LEAF_UNIQUED(CLASS) \
|
||||
if (isa<CLASS>(MD)) \
|
||||
return;
|
||||
#include "llvm/IR/Metadata.def"
|
||||
|
||||
OS << " = ";
|
||||
WriteMDNodeBodyInternal(OS, N, &TypePrinter, MST.getMachine(), M);
|
||||
|
||||
@ -1053,7 +1053,6 @@ DILabel *DILabel::getImpl(LLVMContext &Context, Metadata *Scope,
|
||||
DIExpression *DIExpression::getImpl(LLVMContext &Context,
|
||||
ArrayRef<uint64_t> Elements,
|
||||
StorageType Storage, bool ShouldCreate) {
|
||||
assert(Storage != Distinct && "DIExpression cannot be distinct");
|
||||
DEFINE_GETIMPL_LOOKUP(DIExpression, (Elements));
|
||||
DEFINE_GETIMPL_STORE_NO_OPS(DIExpression, (Elements));
|
||||
}
|
||||
@ -1584,7 +1583,6 @@ DIMacroFile *DIMacroFile::getImpl(LLVMContext &Context, unsigned MIType,
|
||||
DIArgList *DIArgList::getImpl(LLVMContext &Context,
|
||||
ArrayRef<ValueAsMetadata *> Args,
|
||||
StorageType Storage, bool ShouldCreate) {
|
||||
assert(Storage != Distinct && "DIArgList cannot be distinct");
|
||||
DEFINE_GETIMPL_LOOKUP(DIArgList, (Args));
|
||||
DEFINE_GETIMPL_STORE_NO_OPS(DIArgList, (Args));
|
||||
}
|
||||
|
||||
@ -60,7 +60,6 @@ LLVMContextImpl::~LLVMContextImpl() {
|
||||
#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \
|
||||
for (auto *I : CLASS##s) \
|
||||
I->dropAllReferences();
|
||||
#define HANDLE_MDNODE_LEAF_UNIQUED(CLASS) HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS)
|
||||
#include "llvm/IR/Metadata.def"
|
||||
|
||||
// Also drop references that come from the Value bridges.
|
||||
@ -75,7 +74,6 @@ LLVMContextImpl::~LLVMContextImpl() {
|
||||
#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \
|
||||
for (CLASS * I : CLASS##s) \
|
||||
delete I;
|
||||
#define HANDLE_MDNODE_LEAF_UNIQUED(CLASS) HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS)
|
||||
#include "llvm/IR/Metadata.def"
|
||||
|
||||
// Free the constants.
|
||||
|
||||
@ -1381,7 +1381,6 @@ public:
|
||||
|
||||
#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \
|
||||
DenseSet<CLASS *, CLASS##Info> CLASS##s;
|
||||
#define HANDLE_MDNODE_LEAF_UNIQUED(CLASS) HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS)
|
||||
#include "llvm/IR/Metadata.def"
|
||||
|
||||
// Optional map for looking up composite types by identifier.
|
||||
|
||||
@ -672,7 +672,6 @@ MDNode *MDNode::replaceWithPermanentImpl() {
|
||||
#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \
|
||||
case CLASS##Kind: \
|
||||
break;
|
||||
#define HANDLE_MDNODE_LEAF_UNIQUED(CLASS) HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS)
|
||||
#include "llvm/IR/Metadata.def"
|
||||
}
|
||||
|
||||
@ -813,7 +812,6 @@ MDNode *MDNode::uniquify() {
|
||||
dispatchRecalculateHash(SubclassThis, ShouldRecalculateHash); \
|
||||
return uniquifyImpl(SubclassThis, getContext().pImpl->CLASS##s); \
|
||||
}
|
||||
#define HANDLE_MDNODE_LEAF_UNIQUED(CLASS) HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS)
|
||||
#include "llvm/IR/Metadata.def"
|
||||
}
|
||||
}
|
||||
@ -826,7 +824,6 @@ void MDNode::eraseFromStore() {
|
||||
case CLASS##Kind: \
|
||||
getContext().pImpl->CLASS##s.erase(cast<CLASS>(this)); \
|
||||
break;
|
||||
#define HANDLE_MDNODE_LEAF_UNIQUED(CLASS) HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS)
|
||||
#include "llvm/IR/Metadata.def"
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,4 +0,0 @@
|
||||
; RUN: not llvm-as < %s -disable-output 2>&1 | FileCheck %s
|
||||
|
||||
; CHECK: <stdin>:[[@LINE+1]]:6: error: !DIArgList cannot appear outside of a function
|
||||
!0 = !DIArgList()
|
||||
@ -1,4 +0,0 @@
|
||||
; RUN: not llvm-as < %s -disable-output 2>&1 | FileCheck %s
|
||||
|
||||
; CHECK: <stdin>:[[@LINE+1]]:6: error: 'distinct' not allowed for !DIExpression
|
||||
!0 = distinct !DIExpression()
|
||||
@ -1,16 +0,0 @@
|
||||
; RUN: llvm-dis -o - %s.bc | FileCheck %s
|
||||
|
||||
!llvm.dbg.cu = !{!1}
|
||||
!llvm.module.flags = !{!8, !9}
|
||||
|
||||
!0 = distinct !DIGlobalVariable(name: "g", scope: !1, file: !2, line: 1, type: !5, isLocal: false, isDefinition: true)
|
||||
!1 = distinct !DICompileUnit(language: DW_LANG_C99, file: !2, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !3, globals: !4)
|
||||
!2 = !DIFile(filename: "a.c", directory: "/")
|
||||
!3 = !{}
|
||||
!4 = !{!7}
|
||||
!5 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
|
||||
; CHECK: expr: !DIExpression()
|
||||
!6 = distinct !DIExpression()
|
||||
!7 = !DIGlobalVariableExpression(var: !0, expr: !6)
|
||||
!8 = !{i32 2, !"Dwarf Version", i32 4}
|
||||
!9 = !{i32 2, !"Debug Info Version", i32 3}
|
||||
Binary file not shown.
Loading…
Reference in New Issue
Block a user