Generalize DWARF tests that expect DW_FORM_strp

[Jake-Egan]

Summary

The modified tests were failing on AIX because DWARF on AIX uses inline strings by default, but the tests check for DW_FORM_strp.

This patch removes DW_FORM_strp so both forms will pass the check.

[shchenz]

Maybe we could split this patch into two:
1: for the space and tab
2: for -dwarf-inlined-strings=Disable

The second one looks reasonable to me.
But for the first one, do we know why on AIX it generates a tab instead of space? Is it caused by llvm-dwarfdump on AIX? If so, maybe we need to change llvm-dwarfdump to make it generate space also on AIX?

[dblaikie]

In D112286#3079832, @shchenz wrote:

Maybe we could split this patch into two:
1: for the space and tab
2: for -dwarf-inlined-strings=Disable

The second one looks reasonable to me.
But for the first one, do we know why on AIX it generates a tab instead of space? Is it caused by llvm-dwarfdump on AIX? If so, maybe we need to change llvm-dwarfdump to make it generate space also on AIX?

^ agreed. Would be good to understand why llvm-dwarfdump is doing anything different in terms of whitespace on AIX... I can't think of any reason that should be the case.

[Jake-Egan]

Here is an example for the differing output with file llvm/test/DebugInfo/Generic/varargs.ll

On Linux:

DW_AT_name [DW_FORM_strp]^I( .debug_str[0x00000065] = "a")$

On AIX:

DW_AT_name [DW_FORM_string]^I("a")$

I will create a new patch for the white space issue and convert this patch to add the -dwarf-inlined-strings=Disable option.

[Jake-Egan]

Update patch for -dwarf-inlined-strings=Disable option.

[shchenz]

LGTM. Thanks

[dblaikie]

I think probably generalizing the tests to not care about the string encodings is probably the right thing, rather than forcing indirect strings?

I think these tests are overly specific - they don't look like they should care about the string encoding (& Probably an artifact of older techniques in writing these debug info tests - improvements to the dumper to print strings inline, skip forms, etc)

[dblaikie]

In D112286#3082790, @Jake-Egan wrote:

Here is an example for the differing output with file llvm/test/DebugInfo/Generic/varargs.ll

On Linux:

DW_AT_name [DW_FORM_strp]^I( .debug_str[0x00000065] = "a")$

On AIX:

DW_AT_name [DW_FORM_string]^I("a")$

I will create a new patch for the white space issue and convert this patch to add the -dwarf-inlined-strings=Disable option.

Thanks for showing the difference - I think these can probably most often be tested with CHECK: DW_AT_name {{.*}}"a" is probably fine - or if the tests don't need -v output (doesn't dump forms, etc), it'll probably be simpler, may even be exactly the same output between strp and str encodings.

[Jake-Egan]

In D112286#3085048, @dblaikie wrote:

I think probably generalizing the tests to not care about the string encodings is probably the right thing, rather than forcing indirect strings?

I think these tests are overly specific - they don't look like they should care about the string encoding (& Probably an artifact of older techniques in writing these debug info tests - improvements to the dumper to print strings inline, skip forms, etc)

I agree generalizing the test is probably the better option if DW_FORM_strp isn't necessary for the purpose of the test.

@shchenz I will update the patch if you have no objection.

[shchenz]

In D112286#3086128, @Jake-Egan wrote:

In D112286#3085048, @dblaikie wrote:

I think probably generalizing the tests to not care about the string encodings is probably the right thing, rather than forcing indirect strings?

I think these tests are overly specific - they don't look like they should care about the string encoding (& Probably an artifact of older techniques in writing these debug info tests - improvements to the dumper to print strings inline, skip forms, etc)

I agree generalizing the test is probably the better option if DW_FORM_strp isn't necessary for the purpose of the test.

@shchenz I will update the patch if you have no objection.

Sounds good to me

[Jake-Egan]

Update patch to generalize the tests instead.

[dblaikie]

llvm/test/DebugInfo/Generic/containing-type-extension.ll

8

I'd drop the "= " here (& elsewhere in the patch), like it's done elsewhere

[Jake-Egan]

llvm/test/DebugInfo/Generic/containing-type-extension.ll

8

I was going to do that in a separate patch for the whitespace. I think it's more related to the whitespace issue do you think? The patch would remove both = and spaces.

[dblaikie]

llvm/test/DebugInfo/Generic/containing-type-extension.ll

8

Oh, sure, either way

llvm/test/DebugInfo/Generic/2010-04-06-NestedFnDbgInfo.ll

 ; RUN: %llc_dwarf -O0 -filetype=obj -o - < %s | llvm-dwarfdump -v -debug-info - | FileCheck %s
 ; Radar 7833483
 ; Do not emit a separate out-of-line definition DIE for the function-local 'foo'
 ; function (member of the function local 'A' type)
 ; CHECK: DW_TAG_class_type
 ; CHECK: DW_TAG_class_type
-; CHECK-NEXT: DW_AT_name {{.*}} "A"
+; CHECK-NEXT: DW_AT_name {{.*}}"A"
 ; Check that the subprogram inside the class definition has low_pc, only
 ; attached to the definition.
 ; CHECK: [[FOO_INL:0x........]]: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_low_pc
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_name {{.*}} "foo"
+; CHECK: DW_AT_name {{.*}}"foo"
 ; And just double check that there's no out of line definition that references
 ; this subprogram.
 ; CHECK-NOT: DW_AT_specification {{.*}} {[[FOO_INL]]}
 
 %class.A = type { i8 }
 %class.B = type { i8 }
 
 define i32 @main() ssp !dbg !2 {

llvm/test/DebugInfo/Generic/PR20038.ll

 ; For some reason, the output when targetting sparc is not quite as expected.
 ; XFAIL: sparc
 
 ; RUN: %llc_dwarf -O0 -filetype=obj -dwarf-linkage-names=All < %s | llvm-dwarfdump -v -debug-info - | FileCheck %s
 
 ; IR generated from clang -O0 with:
 ; struct C {
 ;   ~C();
 ; };
 ; extern bool b;
 ; void fun4() { b && (C(), 1); }
 ; __attribute__((always_inline)) C::~C() { }
 
 ; CHECK: DW_TAG_structure_type
 ; CHECK-NOT: DW_TAG
-; CHECK:   DW_AT_name {{.*}} "C"
+; CHECK:   DW_AT_name {{.*}}"C"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:   DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
-; CHECK:     DW_AT_name {{.*}} "~C"
+; CHECK:     DW_AT_name {{.*}}"~C"
 
 ; CHECK:  DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
-; CHECK:   DW_AT_linkage_name {{.*}} "_ZN1CD1Ev"
+; CHECK:   DW_AT_linkage_name {{.*}}"_ZN1CD1Ev"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:  DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
-; CHECK:     DW_AT_name {{.*}} "this"
+; CHECK:     DW_AT_name {{.*}}"this"
 
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
-; CHECK:   DW_AT_name {{.*}} "fun4"
+; CHECK:   DW_AT_name {{.*}}"fun4"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:   DW_TAG_inlined_subroutine
 ; CHECK-NOT: DW_TAG
-; CHECK:     DW_AT_abstract_origin {{.*}} "_ZN1CD1Ev"
+; CHECK:     DW_AT_abstract_origin {{.*}}"_ZN1CD1Ev"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:     DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
-; CHECK:       DW_AT_abstract_origin {{.*}} "this"
+; CHECK:       DW_AT_abstract_origin {{.*}}"this"
 
 ; FIXME: D2 is actually inlined into D1 but doesn't show up here, possibly due
 ; to there being no work in D2 (calling another member function from the dtor
 ; causes D2 to show up, calling a free function doesn't).
 
 ; CHECK-NOT: DW_TAG
 ; CHECK:     NULL
 ; CHECK-NOT: DW_TAG

llvm/test/DebugInfo/Generic/constant-pointers.ll

 ; RUN: %llc_dwarf -O0 -filetype=obj %s -o - | llvm-dwarfdump -v -debug-info - | FileCheck %s
 
 ; Ensure that pointer constants are emitted as unsigned data. Alternatively,
 ; these could be signless data (dataN).
 
 ; Built with Clang from:
 ; template <void *V, void (*F)(), int i>
 ; void func() {}
 ; template void func<nullptr, nullptr, 42>();
 
 ; CHECK: DW_TAG_subprogram
 ; CHECK:   DW_TAG_template_value_parameter
-; CHECK:     DW_AT_name {{.*}} "V"
+; CHECK:     DW_AT_name {{.*}}"V"
 ; CHECK:     DW_AT_const_value [DW_FORM_udata] (0)
 ; CHECK:   DW_TAG_template_value_parameter
-; CHECK:     DW_AT_name {{.*}} "F"
+; CHECK:     DW_AT_name {{.*}}"F"
 ; CHECK:     DW_AT_const_value [DW_FORM_udata] (0)
 
 ; Function Attrs: nounwind uwtable
 define weak_odr void @_Z4funcILPv0ELPFvvE0ELi42EEvv() #0 !dbg !4 {
 entry:
   ret void, !dbg !18
 }
 

llvm/test/DebugInfo/Generic/containing-type-extension.ll

-; RUN: %llc_dwarf -O0 -filetype=obj < %s > %t
+; RUN: %llc_dwarf -O0 -filetype=obj -dwarf-inlined-strings=Disable < %s > %t
 ; RUN: llvm-dwarfdump -v -debug-info %t | FileCheck %s
 
 ; Check that any type can have a vtable holder.
 ; CHECK: [[SP:.*]]: DW_TAG_structure_type
 ; CHECK-NOT: TAG
 ; CHECK: DW_AT_containing_type [DW_FORM_ref4]
-; CHECK: DW_AT_name [DW_FORM_strp] {{.*}}= "vtable")
+; CHECK: DW_AT_name [DW_FORM_strp] {{.*}}"vtable")
 
 ; The code doesn't actually matter.
 define i32 @main() #0 !dbg !4 {
 entry:
   %retval = alloca i32, align 4
   store i32 0, i32* %retval
   ret i32 0, !dbg !10
 }

llvm/test/DebugInfo/Generic/cross-cu-inlining.ll

 ; int __attribute__((always_inline)) func(int x) {
 ;   return x * 2;
 ; }
 
 ; Ensure that func inlined into main is described and references the abstract
 ; definition in b.cpp's CU.
 
 ; CHECK: DW_TAG_compile_unit
-; CHECK:   DW_AT_name {{.*}} "a.cpp"
+; CHECK:   DW_AT_name {{.*}}"a.cpp"
 ; CHECK:   DW_TAG_subprogram
 ; CHECK:     DW_AT_type [DW_FORM_ref_addr] (0x00000000[[INT:[a-f0-9]+]]
 ; CHECK:     0x[[INLINED:[0-9a-f]*]]:{{.*}}DW_TAG_inlined_subroutine
 ; CHECK:       DW_AT_abstract_origin {{.*}}[[ABS_FUNC:........]] "_Z4funci"
 ; CHECK:       DW_TAG_formal_parameter
 ; CHECK:         DW_AT_abstract_origin {{.*}}[[ABS_VAR:........]] "x"
 
 ; Check the abstract definition is in the 'b.cpp' CU and doesn't contain any
 ; concrete information (address range or variable location)
 ; CHECK: DW_TAG_compile_unit
-; CHECK:   DW_AT_name {{.*}} "b.cpp"
+; CHECK:   DW_AT_name {{.*}}"b.cpp"
 ; CHECK: 0x[[ABS_FUNC]]: DW_TAG_subprogram
 ; CHECK-NOT: DW_AT_low_pc
 ; CHECK: 0x[[ABS_VAR]]: DW_TAG_formal_parameter
 ; CHECK-NOT: DW_AT_location
 ; CHECK: DW_AT_type [DW_FORM_ref4] {{.*}} {0x[[INT]]}
 ; CHECK-NOT: DW_AT_location
 
 ; CHECK: 0x[[INT]]: DW_TAG_base_type
-; CHECK:   DW_AT_name {{.*}} "int"
+; CHECK:   DW_AT_name {{.*}}"int"
 
 ; Check the concrete out of line definition references the abstract and
 ; provides the address range and variable location
 ; CHECK: 0x[[FUNC:[0-9a-f]*]]{{.*}}DW_TAG_subprogram
 ; CHECK:   DW_AT_low_pc
 ; CHECK:   DW_AT_abstract_origin {{.*}} {0x[[ABS_FUNC]]} "_Z4funci"
 ; CHECK:   DW_TAG_formal_parameter
 ; CHECK:     DW_AT_location

llvm/test/DebugInfo/Generic/cross-cu-linkonce-distinct.ll

 ; CHECK: DW_TAG_compile_unit
 ; CHECK-NOT: DW_TAG
 ; CHECK:    DW_AT_name {{.*}}"b.cpp"
 ; CHECK-NOT: DW_TAG_subprogram
 
 ; CHECK: DW_TAG_compile_unit
 ; CHECK-NOT: DW_TAG
 ; CHECK:     DW_AT_name {{.*}}"a.cpp"
-; CHECK:     DW_AT_name {{.*}} "func"
+; CHECK:     DW_AT_name {{.*}}"func"
 
 source_filename = "test/DebugInfo/Generic/cross-cu-linkonce-distinct.ll"
 
 @x = global i32 (i32)* @_Z4funci, align 8, !dbg !0
 @y = global i32 (i32)* @_Z4funci, align 8, !dbg !7
 
 ; Function Attrs: inlinehint nounwind uwtable
 define linkonce_odr i32 @_Z4funci(i32 %i) #0 !dbg !18 {

llvm/test/DebugInfo/Generic/cross-cu-linkonce.ll

 ; inline int func(int i) {
 ;   return i * 2;
 ; }
 ; int (*y)(int) = &func;
 
 ; CHECK: DW_TAG_compile_unit
 ; CHECK:   DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
-; CHECK:     DW_AT_name {{.*}} "func"
+; CHECK:     DW_AT_name {{.*}}"func"
 ; CHECK: DW_TAG_compile_unit
 ; CHECK-NOT: DW_TAG_subprogram
 
 source_filename = "test/DebugInfo/Generic/cross-cu-linkonce.ll"
 
 @x = global i32 (i32)* @_Z4funci, align 8, !dbg !0
 @y = global i32 (i32)* @_Z4funci, align 8, !dbg !7
 

llvm/test/DebugInfo/Generic/dead-argument-order.ll

 ; RUN: %llc_dwarf -O0 -filetype=obj < %s | llvm-dwarfdump -v -debug-info - | FileCheck %s
 
 ; Built from the following source with clang -O1
 ; struct S { int i; };
 ; int function(struct S s, int i) { return s.i + i; }
 
 ; Due to the X86_64 ABI, 's' is passed in registers and once optimized, the
 ; entirety of 's' is never reconstituted, since only the int is required, and
 ; thus the variable's location is unknown/dead to debug info.
 
 ; Future/current work should enable us to describe partial variables, which, in
 ; this case, happens to be the entire variable.
 
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
-; CHECK:   DW_AT_name {{.*}} "function"
+; CHECK:   DW_AT_name {{.*}}"function"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:   DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
-; CHECK:     DW_AT_name {{.*}} "s"
+; CHECK:     DW_AT_name {{.*}}"s"
 ; CHECK-NOT: DW_TAG
 ; FIXME: Even though 's' is never reconstituted into a struct, the one member
 ; variable is still live and used, and so we should be able to describe 's's
 ; location as the location of that int.
 ; CHECK-NOT: DW_AT_location
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:   DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
 ; CHECK:     DW_AT_location
 ; CHECK-NOT: DW_TAG
-; CHECK:     DW_AT_name {{.*}} "i"
+; CHECK:     DW_AT_name {{.*}}"i"
 
 
 %struct.S = type { i32 }
 
 ; Function Attrs: nounwind readnone uwtable
 define i32 @_Z8function1Si(i32 %s.coerce, i32 %i) #0 !dbg !9 {
 entry:
   tail call void @llvm.dbg.declare(metadata %struct.S* undef, metadata !14, metadata !DIExpression()), !dbg !20

llvm/test/DebugInfo/Generic/debug-label-inline.ll

-; RUN: llc -O0 -filetype=obj -o - %s | llvm-dwarfdump -v - | FileCheck %s
+; RUN: llc -O0 -filetype=obj -o - %s -dwarf-inlined-strings=Disable | llvm-dwarfdump -v - | FileCheck %s
 ;
 ; Bug 47129
 ; XFAIL: sparc
 ;
 ; CHECK: .debug_info contents:
 ; CHECK: [[LABEL_ORIGIN:0x[0-9a-zA-Z]+]]:{{ *}}DW_TAG_label
 ; CHECK-NEXT: DW_AT_name [DW_FORM_strp] {{.*}}"top"
 ; CHECK-NEXT: DW_AT_decl_file [DW_FORM_data1] {{.*}}debug-label-inline.c

llvm/test/DebugInfo/Generic/debug-label.ll

-; RUN: llc -O0 -filetype=obj -o - %s | llvm-dwarfdump -v - | FileCheck %s
+; RUN: llc -O0 -filetype=obj -o - %s -dwarf-inlined-strings=Disable | llvm-dwarfdump -v - | FileCheck %s
 ;
 ; CHECK: .debug_info contents:
 ; CHECK: DW_TAG_label
 ; CHECK-NEXT: DW_AT_name [DW_FORM_strp] {{.*}}"top"
 ; CHECK-NEXT: DW_AT_decl_file [DW_FORM_data1] {{.*}}debug-label.c
 ; CHECK-NEXT: DW_AT_decl_line [DW_FORM_data1] {{.*}}4
 ; CHECK-NEXT: DW_AT_low_pc [DW_FORM_addr] {{.*}}{{0x[0-9a-f]+}}
 ; CHECK: DW_TAG_label

llvm/test/DebugInfo/Generic/disubrange_vla.ll

 ; RUN: rm -rf %t %t2
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s > %t
 ; RUN: llvm-dwarfdump -name=vla_expr %t > %t2
 ; RUN: llvm-dwarfdump -verbose %t >> %t2
 ; RUN: cat %t2 | FileCheck %s
 
 ; This test runs llvm-dwarfdump twice:
 ; - First to get the debug entry for 'vla_expr'.
 ; - Second to check that this is the entry referenced in DW_AT_count.
 ; This way the test does not depend on the order in which DW_TAG_variables
 ; are emitted.
 
 ; CHECK:       [[NODE:[0-9a-zA-Zx]+]]: DW_TAG_variable [4]
-; CHECK-NEXT:  DW_AT_name {{.*}} "vla_expr"
+; CHECK-NEXT:  DW_AT_name {{.*}}"vla_expr"
 ; CHECK:       DW_AT_count [DW_FORM_ref4]  (cu + {{.*}} => {[[NODE]]})
 
 define void @foo(i32 %n) !dbg !7 {
 entry:
   call void @llvm.dbg.value(metadata i32 %n, i64 0, metadata !12, metadata !19), !dbg !20
   ret void, !dbg !21
 }
 

llvm/test/DebugInfo/Generic/enum-types.ll

 ;
 ; RUN: %llc_dwarf -filetype=obj -O0 -dwarf-linkage-names=All < %s | llvm-dwarfdump -v -debug-info - | FileCheck %s
 
 ; Make sure we can handle enums with the same identifier but in enum types of
 ; different compile units.
 ; rdar://17628609
 
 ; CHECK: DW_TAG_compile_unit
 ; CHECK: 0x[[ENUM:.*]]: DW_TAG_enumeration_type
-; CHECK-NEXT:   DW_AT_name {{.*}} "EA"
+; CHECK-NEXT:   DW_AT_name {{.*}}"EA"
 ; CHECK: DW_TAG_subprogram
-; CHECK: DW_AT_MIPS_linkage_name {{.*}} "_Z4topA2EA"
+; CHECK: DW_AT_MIPS_linkage_name {{.*}}"_Z4topA2EA"
 ; CHECK: DW_TAG_formal_parameter
 ; CHECK: DW_AT_type [DW_FORM_ref4] (cu + 0x{{.*}} => {0x[[ENUM]]}
 
 ; CHECK: DW_TAG_compile_unit
 ; CHECK: DW_TAG_subprogram
-; CHECK:   DW_AT_MIPS_linkage_name {{.*}} "_Z4topB2EA"
+; CHECK:   DW_AT_MIPS_linkage_name {{.*}}"_Z4topB2EA"
 ; CHECK: DW_TAG_formal_parameter
 ; CHECK: DW_AT_type [DW_FORM_ref_addr] {{.*}}[[ENUM]]
 
 ; Function Attrs: nounwind ssp uwtable
 define void @_Z4topA2EA(i32 %sa) #0 !dbg !7 {
 entry:
   %sa.addr = alloca i32, align 4
   store i32 %sa, i32* %sa.addr, align 4

llvm/test/DebugInfo/Generic/enum.ll

 ; RUN: %llc_dwarf -O0 -filetype=obj < %s > %t
 ; RUN: llvm-dwarfdump -v %t | FileCheck %s
 
 ; IR generated from the following code compiled with clang -g:
 ; enum e1 { I, J = 0xffffffffU, K = 0xf000000000000000ULL } a;
 ; enum e2 { X };
 ; void func() {
 ;   int b = X;
 ; }
 
 ; These values were previously being truncated to -1 and 0 respectively.
 
 ; CHECK: debug_info contents
 ; CHECK: DW_TAG_enumeration_type
-; CHECK-NEXT: DW_AT_name{{.*}} = "e1"
+; CHECK-NEXT: DW_AT_name{{.*}}"e1"
 ; CHECK-NOT: NULL
 ; CHECK: DW_TAG_enumerator
 ; CHECK-NOT: NULL
 ; CHECK: DW_TAG_enumerator
-; CHECK-NEXT: DW_AT_name{{.*}} = "J"
+; CHECK-NEXT: DW_AT_name{{.*}}"J"
 ; CHECK-NEXT: DW_AT_const_value [DW_FORM_sdata]     (4294967295)
 ; CHECK-NOT: NULL
 ; CHECK: DW_TAG_enumerator
-; CHECK-NEXT: DW_AT_name{{.*}} = "K"
+; CHECK-NEXT: DW_AT_name{{.*}}"K"
 ; CHECK-NEXT: DW_AT_const_value [DW_FORM_sdata]     (-1152921504606846976)
 
 ; Check that we retain enums that aren't referenced by any variables, etc
 ; CHECK: DW_TAG_enumeration_type
-; CHECK-NEXT: DW_AT_name{{.*}} = "e2"
+; CHECK-NEXT: DW_AT_name{{.*}}"e2"
 ; CHECK-NOT: NULL
 ; CHECK: DW_TAG_enumerator
-; CHECK-NEXT: DW_AT_name{{.*}} = "X"
+; CHECK-NEXT: DW_AT_name{{.*}}"X"
 
 source_filename = "test/DebugInfo/Generic/enum.ll"
 
 @a = global i64 0, align 8, !dbg !0
 
 ; Function Attrs: nounwind uwtable
 define void @_Z4funcv() #0 !dbg !17 {
 entry:

llvm/test/DebugInfo/Generic/fortran-subprogram-attr.ll

 ; Test for DISPFlagPure, DISPFlagElement and DISPFlagRecursive.  These
 ; three DISPFlags are used to attach DW_AT_pure, DW_AT_element, and
 ; DW_AT_recursive attributes to DW_TAG_subprogram DIEs.
 
 ; -- test the resulting DWARF to make sure we're emitting
 ; DW_AT_{pure,elemental,recursive}.
 
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s > %t.o
 ; RUN: llvm-dwarfdump -v -debug-info %t.o | FileCheck %s
 
 ; CHECK: DW_TAG_subprogram
-; CHECK-DAG: DW_AT_name {{.*}} "subroutine1"
+; CHECK-DAG: DW_AT_name {{.*}}"subroutine1"
 ; CHECK-DAG: DW_AT_pure [DW_FORM_flag_present] (true)
 ; CHECK: DW_TAG_subprogram
-; CHECK-DAG: DW_AT_name {{.*}} "subroutine2"
+; CHECK-DAG: DW_AT_name {{.*}}"subroutine2"
 ; CHECK-DAG: DW_AT_elemental [DW_FORM_flag_present] (true)
 ; CHECK: DW_TAG_subprogram
-; CHECK-DAG: DW_AT_name {{.*}} "subroutine3"
+; CHECK-DAG: DW_AT_name {{.*}}"subroutine3"
 ; CHECK-DAG: DW_AT_recursive [DW_FORM_flag_present] (true)
 ; CHECK: DW_TAG_subprogram
-; CHECK-DAG: DW_AT_name {{.*}} "subroutine4"
+; CHECK-DAG: DW_AT_name {{.*}}"subroutine4"
 ; CHECK-DAG: DW_AT_pure [DW_FORM_flag_present] (true)
 ; CHECK-DAG: DW_AT_elemental [DW_FORM_flag_present] (true)
 ; CHECK-DAG: DW_AT_recursive [DW_FORM_flag_present] (true)
 ; CHECK: {{DW_TAG|NULL}}
 
 
 ; Function Attrs: noinline nounwind optnone uwtable
 define dso_local void @subroutine1() !dbg !7 {

llvm/test/DebugInfo/Generic/gmlt_profiling.ll

 ; RUN: %llc_dwarf -O0 -filetype=obj < %S/gmlt_profiling.ll | llvm-dwarfdump -v - | FileCheck %S/gmlt_profiling.ll
 
 ; CHECK: .debug_info
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_name {{.*}} "f1"
+; CHECK: DW_AT_name {{.*}}"f1"
 ; With debug-info-for-profiling attribute, we need to emit decl_file and
 ; decl_line of the subprogram.
 ; CHECK-NEXT: DW_AT_decl_file
 ; CHECK-NEXT: DW_AT_decl_line
 
 ; Function Attrs: nounwind uwtable
 define void @_Z2f1v() !dbg !4 {
 entry:

llvm/test/DebugInfo/Generic/imported-name-inlined.ll

 
 ; Ensure that top level imported declarations don't produce an extra degenerate
 ; concrete subprogram definition.
 
 ; FIXME: imported entities should only be emitted to the abstract origin if one is present
 
 ; CHECK: DW_TAG_compile_unit
 ; CHECK:   DW_TAG_subprogram
-; CHECK:     DW_AT_name {{.*}} "f1"
+; CHECK:     DW_AT_name {{.*}}"f1"
 ; CHECK:     DW_TAG_imported_declaration
 ; CHECK:     NULL
 ; CHECK:   DW_TAG_namespace
 ; CHECK:     DW_TAG_subprogram
 ; CHECK:     NULL
 ; CHECK:   DW_TAG_subprogram
-; CHECK:     DW_AT_name {{.*}} "f2"
+; CHECK:     DW_AT_name {{.*}}"f2"
 ; CHECK:     DW_TAG_inlined_subroutine
 ; CHECK:       DW_TAG_imported_declaration
 ; CHECK:       NULL
 ; CHECK:     NULL
 ; CHECK:   NULL
 
 ; Function Attrs: noinline
 define void @_Z2f2v() noinline !dbg !14 {

llvm/test/DebugInfo/Generic/incorrect-variable-debugloc.ll

 ;   A.m_fn3();
 ; }
 ; void C::m_fn3() {
 ;   A().m_fn1();
 ;   b.m_fn2();
 ; }
 
 ; CHECK: DW_TAG_structure_type
-; CHECK-NEXT: DW_AT_name {{.*}} "C"
+; CHECK-NEXT: DW_AT_name {{.*}}"C"
 ; CHECK: [[M_FN3_DECL:.*]]:  DW_TAG_subprogram
 ; CHECK-NOT: {{DW_TAG|NULL}}
-; CHECK: DW_AT_name {{.*}} "m_fn3"
+; CHECK: DW_AT_name {{.*}}"m_fn3"
 
 ; CHECK: DW_AT_specification {{.*}} {[[M_FN3_DECL]]}
 ; CHECK-NOT: DW_TAG
 ; CHECK:   DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
-; CHECK:     DW_AT_name {{.*}} "this"
+; CHECK:     DW_AT_name {{.*}}"this"
 
 %struct.C = type { i32, %struct.B }
 %struct.B = type { i32 }
 %struct.A = type { i8 }
 
 @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 1, void ()* @asan.module_ctor, i8* null }]
 @__asan_option_detect_stack_use_after_return = external global i32
 @___asan_gen_ = private unnamed_addr constant [11 x i8] c"1 32 8 1 A\00", align 1

llvm/test/DebugInfo/Generic/linkage-name-abstract.ll

 ; }
 ; void f6() {
 ;   F4::f5();
 ; }
 
 ; Show that the only linkage names are for the inlined functions,
 ; because those are the ones with an abstract origin.
 ; ONENAME-NOT: {{DW_AT(_MIPS)?_linkage_name}}
-; ONENAME:     {{DW_AT(_MIPS)?_linkage_name}} {{.*}} "_Z2f2v"
+; ONENAME:     {{DW_AT(_MIPS)?_linkage_name}} {{.*}}"_Z2f2v"
 ; ONENAME-NOT: {{DW_AT(_MIPS)?_linkage_name}}
-; ONENAME:     {{DW_AT(_MIPS)?_linkage_name}} {{.*}} "_ZN2F42f5Ev"
+; ONENAME:     {{DW_AT(_MIPS)?_linkage_name}} {{.*}}"_ZN2F42f5Ev"
 ; ONENAME-NOT: {{DW_AT(_MIPS)?_linkage_name}}
 
 ; For f2() we see the definition pointing to an abstract origin DIE,
 ; which in turn is where the linkage_name is; and then there's
 ; an inlined_subroutine pointing back to the abstract origin.
 ; The order of these DIEs is not important of course, just the links.
 ; REF:      DW_TAG_subprogram
 ; REF-NOT:  {{DW_TAG|NULL}}
 ; REF:      DW_AT_abstract_origin {{.*}} {[[F2:0x.*]]} "_Z2f2v"
 ; REF:      [[F2]]: DW_TAG_subprogram
-; REF-NEXT: linkage_name {{.*}} "_Z2f2v"
+; REF-NEXT: linkage_name {{.*}}"_Z2f2v"
 ; REF:      DW_TAG_inlined_subroutine
 ; REF-NOT:  {{DW_TAG|NULL}}
 ; REF:      DW_AT_abstract_origin {{.*}} {[[F2]]}
 
 ; For F4::f5(), first we see the in-class declaration,
 ; then the definition, abstract origin, and the inlined_subroutine.
 ; REF:      DW_TAG_structure_type
-; REF-NEXT: DW_AT_name {{.*}} "F4"
+; REF-NEXT: DW_AT_name {{.*}}"F4"
 ; REF-NOT:  {{DW_TAG|NULL}}
 ; REF:      [[F5_DECL:0x.*]]: DW_TAG_subprogram
-; REF-NEXT: DW_AT_name {{.*}} "f5"
+; REF-NEXT: DW_AT_name {{.*}}"f5"
 ; REF:      DW_TAG_subprogram
 ; REF-NOT:  {{DW_TAG|NULL}}
 ; REF:      DW_AT_abstract_origin {{.*}} {[[F5_ABS:0x.*]]} "_ZN2F42f5Ev"
 ; REF:      [[F5_ABS]]: DW_TAG_subprogram
 ; REF-NOT:  {{DW_TAG|NULL}}
-; REF:      linkage_name {{.*}} "_ZN2F42f5Ev"
+; REF:      linkage_name {{.*}}"_ZN2F42f5Ev"
 ; REF-NEXT: DW_AT_specification {{.*}} {[[F5_DECL]]}
 ; REF:      DW_TAG_inlined_subroutine
 ; REF-NOT:  {{DW_TAG|NULL}}
 ; REF:      DW_AT_abstract_origin {{.*}} {[[F5_ABS]]}
 
 
 ; Function Attrs: alwaysinline uwtable
 define void @_Z2f2v() #0 !dbg !6 {

llvm/test/DebugInfo/Generic/mainsubprogram.ll

 ; RUN: %llc_dwarf -O0 -filetype=obj < %s > %t
 ; RUN: llvm-dwarfdump -v -debug-info %t | FileCheck %s
 
 ; Make sure we're emitting DW_AT_main_subprogram.
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: {{DW_TAG|NULL}}
-; CHECK:   DW_AT_name {{.*}} "main"
+; CHECK:   DW_AT_name {{.*}}"main"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:   DW_AT_main_subprogram [DW_FORM_flag_present] (true)
 
 define i32 @main() #0 !dbg !4 {
 entry:
   %retval = alloca i32, align 4
   store i32 0, i32* %retval
   ret i32 0, !dbg !10

llvm/test/DebugInfo/Generic/member-order.ll

 ; RUN: %llc_dwarf -filetype=obj -O0 < %s | llvm-dwarfdump -v -debug-info - | FileCheck %s
 
 ; generated by clang from:
 ; struct foo {
 ;   void f1();
 ;   void f2();
 ; };
 ;
 ; void foo::f1() {
 ; }
 
 ; CHECK: DW_TAG_structure_type
-; CHECK-NEXT: DW_AT_name {{.*}} "foo"
+; CHECK-NEXT: DW_AT_name {{.*}}"foo"
 ; CHECK-NOT: NULL
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: NULL
-; CHECK: DW_AT_name {{.*}} "f1"
+; CHECK: DW_AT_name {{.*}}"f1"
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: NULL
-; CHECK: DW_AT_name {{.*}} "f2"
+; CHECK: DW_AT_name {{.*}}"f2"
 
 
 %struct.foo = type { i8 }
 
 ; Function Attrs: nounwind uwtable
 define void @_ZN3foo2f1Ev(%struct.foo* %this) #0 align 2 !dbg !14 {
 entry:
   %this.addr = alloca %struct.foo*, align 8

llvm/test/DebugInfo/Generic/missing-abstract-variable.ll

 ; }
 ;
 ; void a(bool u) {
 ;   x(u);
 ; }
 
 ; CHECK: [[X_DECL:.*]]: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
-; CHECK:   DW_AT_name {{.*}} "x"
+; CHECK:   DW_AT_name {{.*}}"x"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:   DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
-; CHECK:     DW_AT_name {{.*}} "b"
+; CHECK:     DW_AT_name {{.*}}"b"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:       DW_TAG_lexical_block
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:   DW_TAG_variable
 ; CHECK-NOT: DW_TAG
-; CHECK:         DW_AT_name {{.*}} "s"
+; CHECK:         DW_AT_name {{.*}}"s"
 
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
-; CHECK:   DW_AT_name {{.*}} "b"
+; CHECK:   DW_AT_name {{.*}}"b"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:   DW_TAG_inlined_subroutine
 ; CHECK-NOT: DW_TAG
 ; CHECK:     DW_AT_abstract_origin {{.*}} {[[X_DECL]]}
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:     DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
-; CHECK:       DW_AT_abstract_origin {{.*}} "b"
+; CHECK:       DW_AT_abstract_origin {{.*}}"b"
 ; Notice 'x's local variable 's' is missing. Not necessarily a bug here,
 ; since it's been optimized entirely away and it should be described in
 ; abstract subprogram.
 ; CHECK-NOT: DW_TAG
 ; CHECK: NULL
 ; CHECK-NOT: DW_TAG
 ; CHECK: NULL
 
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
-; CHECK:   DW_AT_name {{.*}} "a"
+; CHECK:   DW_AT_name {{.*}}"a"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:   DW_TAG_formal_parameter
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:   DW_TAG_inlined_subroutine
 ; CHECK-NOT: DW_TAG
 ; CHECK:     DW_AT_abstract_origin {{.*}} {[[X_DECL]]}
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; FIXME: This formal parameter goes missing at least at -O2 (& on
 ; mips/powerpc), maybe before that. Perhaps SelectionDAG is to blame (and
 ; fastisel succeeds).
 ; CHECK:     DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
 ; CHECK:       DW_AT_location
-; CHECK:       DW_AT_abstract_origin {{.*}} "b"
+; CHECK:       DW_AT_abstract_origin {{.*}}"b"
 
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:     DW_TAG_lexical_block
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:       DW_TAG_variable
 ; CHECK-NOT: DW_TAG
-; CHECK:         DW_AT_abstract_origin {{.*}} "s"
+; CHECK:         DW_AT_abstract_origin {{.*}}"s"
 
 @t = external global i32
 
 ; Function Attrs: uwtable
 define void @_Z1bv() #0 !dbg !4 {
 entry:
   tail call void @llvm.dbg.value(metadata i1 false, metadata !25, metadata !DIExpression()), !dbg !27
   tail call void @_Z1fi(i32 0), !dbg !28

llvm/test/DebugInfo/Generic/namespace.ll

 ; RUN: %llc_dwarf -O0 -filetype=obj -dwarf-linkage-names=All < %s | llvm-dwarfdump -v - | FileCheck %s
 ; CHECK: debug_info contents
-; CHECK: DW_AT_name{{.*}}= [[F1:.*]])
+; CHECK: DW_AT_name{{.*}}[[F1:.*]])
 ; CHECK: [[NS1:0x[0-9a-f]*]]:{{ *}}DW_TAG_namespace
 ; CHECK-NOT: DW_AT_decl_file
 ; CHECK-NOT: DW_AT_decl_line
 ; CHECK-NOT: NULL
 ; CHECK: [[NS2:0x[0-9a-f]*]]:{{ *}}DW_TAG_namespace
-; CHECK-NEXT: DW_AT_name{{.*}} = "B"
+; CHECK-NEXT: DW_AT_name{{.*}}"B"
 ; CHECK-NOT: DW_AT_decl_file
 ; CHECK-NOT: DW_AT_decl_line
 ; CHECK-NOT: NULL
 ; CHECK: [[I:0x[0-9a-f]*]]:{{ *}}DW_TAG_variable
-; CHECK-NEXT: DW_AT_name{{.*}}= "i"
+; CHECK-NEXT: DW_AT_name{{.*}}"i"
 ; CHECK: [[VAR_FWD:0x[0-9a-f]*]]:{{ *}}DW_TAG_variable
-; CHECK-NEXT: DW_AT_name{{.*}}= "var_fwd"
+; CHECK-NEXT: DW_AT_name{{.*}}"var_fwd"
 ; CHECK-NOT: NULL
 ; CHECK: [[FOO:0x[0-9a-f]*]]:{{ *}}DW_TAG_structure_type
-; CHECK-NEXT: DW_AT_name{{.*}}= "foo"
+; CHECK-NEXT: DW_AT_name{{.*}}"foo"
 ; CHECK-NEXT: DW_AT_declaration
 ; CHECK-NOT: NULL
 ; CHECK: [[BAR:0x[0-9a-f]*]]:{{ *}}DW_TAG_structure_type
-; CHECK-NEXT: DW_AT_name{{.*}}= "bar"
+; CHECK-NEXT: DW_AT_name{{.*}}"bar"
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_MIPS_linkage_name
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_name{{.*}}= "f1"
+; CHECK: DW_AT_name{{.*}}"f1"
 ; CHECK: [[FUNC1:.*]]: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_MIPS_linkage_name
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_name{{.*}}= "f1"
+; CHECK: DW_AT_name{{.*}}"f1"
 ; CHECK: [[BAZ:0x[0-9a-f]*]]:{{.*}}DW_TAG_typedef
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_name{{.*}}= "baz"
+; CHECK: DW_AT_name{{.*}}"baz"
 ; CHECK: [[VAR_DECL:0x[0-9a-f]*]]:{{.*}}DW_TAG_variable
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_name{{.*}}= "var_decl"
+; CHECK: DW_AT_name{{.*}}"var_decl"
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_declaration
 ; CHECK: [[FUNC_DECL:0x[0-9a-f]*]]:{{.*}}DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_name{{.*}}= "func_decl"
+; CHECK: DW_AT_name{{.*}}"func_decl"
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_declaration
 ; CHECK: [[FUNC_FWD:0x[0-9a-f]*]]:{{.*}}DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_name{{.*}}= "func_fwd"
+; CHECK: DW_AT_name{{.*}}"func_fwd"
 ; CHECK-NOT: DW_AT_declaration
 ; CHECK: NULL
 
 ; CHECK-NOT: NULL
 ; CHECK: DW_TAG_imported_module
 ; CHECK-NEXT: DW_AT_decl_file{{.*}}([[F2:.*]])
 ; CHECK-NEXT: DW_AT_decl_line{{.*}}(15)
 ; CHECK-NEXT: DW_AT_import{{.*}}=> {[[NS2]]})
 ; CHECK: NULL
 ; CHECK-NOT: NULL
 
 ; CHECK: DW_TAG_imported_module
 ; CHECK-NEXT: DW_AT_decl_file{{.*}}([[F2:.*]])
 ; CHECK-NEXT: DW_AT_decl_line{{.*}}(18)
 ; CHECK-NEXT: DW_AT_import{{.*}}=> {[[NS1]]})
 ; CHECK-NOT: NULL
 
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_MIPS_linkage_name
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_name{{.*}}= "func"
+; CHECK: DW_AT_name{{.*}}"func"
 ; CHECK-NOT: NULL
 ; CHECK: DW_TAG_imported_module
 ; CHECK-NEXT: DW_AT_decl_file{{.*}}([[F2:.*]])
 ; CHECK-NEXT: DW_AT_decl_line{{.*}}(26)
 ; CHECK-NEXT: DW_AT_import{{.*}}=> {[[NS1]]})
 ; CHECK-NOT: NULL
 ; CHECK: DW_TAG_imported_declaration
 ; CHECK-NEXT: DW_AT_decl_file{{.*}}([[F2]])

llvm/test/DebugInfo/Generic/namespace_function_definition.ll

 ; RUN: %llc_dwarf -O0 -filetype=obj -dwarf-linkage-names=All < %s | llvm-dwarfdump -v -debug-info - | FileCheck %s
 
 ; Generated from clang with the following source:
 ; namespace ns {
 ; void func() {
 ; }
 ; }
 
 ; CHECK: DW_TAG_namespace
-; CHECK-NEXT: DW_AT_name {{.*}} "ns"
+; CHECK-NEXT: DW_AT_name {{.*}}"ns"
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK:   DW_AT_low_pc
 ; CHECK-NOT: DW_TAG
-; CHECK:   DW_AT_linkage_name {{.*}} "_ZN2ns4funcEv"
+; CHECK:   DW_AT_linkage_name {{.*}}"_ZN2ns4funcEv"
 ; CHECK: NULL
 ; CHECK: NULL
 
 ; Function Attrs: nounwind uwtable
 define void @_ZN2ns4funcEv() #0 !dbg !4 {
 entry:
   ret void, !dbg !11
 }

llvm/test/DebugInfo/Generic/namespace_inline_function_definition.ll

 ; RUN: %llc_dwarf -O0 -filetype=obj -dwarf-linkage-names=All < %s | llvm-dwarfdump -v -debug-info - | FileCheck %s
 
 ; Generate from clang with the following source. Note that the definition of
 ; the inline function follows its use to workaround another bug that should be
 ; fixed soon.
 ; namespace ns {
 ; int func(int i);
 ; }
 ; extern int x;
 ; int main() { return ns::func(x); }
 ; int __attribute__((always_inline)) ns::func(int i) { return i * 2; }
 
 ; CHECK: DW_TAG_namespace
-; CHECK-NEXT: DW_AT_name {{.*}} "ns"
+; CHECK-NEXT: DW_AT_name {{.*}}"ns"
 ; CHECK-NOT: DW_TAG
 ; CHECK:   DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
-; CHECK:   DW_AT_linkage_name {{.*}} "_ZN2ns4funcEi"
+; CHECK:   DW_AT_linkage_name {{.*}}"_ZN2ns4funcEi"
 ; CHECK-NOT: DW_TAG
 ; CHECK:   DW_TAG_formal_parameter
 ; CHECK:   NULL
 ; CHECK-NOT: NULL
 ; CHECK:   DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
-; CHECK:     DW_AT_abstract_origin {{.*}} "_ZN2ns4funcEi"
+; CHECK:     DW_AT_abstract_origin {{.*}}"_ZN2ns4funcEi"
 ; CHECK-NOT: DW_TAG
 ; CHECK:     DW_TAG_formal_parameter
-; CHECK:       DW_AT_abstract_origin {{.*}} "i"
+; CHECK:       DW_AT_abstract_origin {{.*}}"i"
 ; CHECK:     NULL
 ; CHECK:   NULL
 ; CHECK: NULL
 
 @x = external global i32
 
 ; Function Attrs: uwtable
 define i32 @main() #0 !dbg !4 {

llvm/test/DebugInfo/Generic/recursive_inlining.ll

 
 ; The definition of C and declaration of C::m_fn2
 ; CHECK: DW_TAG_structure_type
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK: DW_TAG_member
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK: [[M_FN2_DECL:.*]]: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
-; CHECK:     DW_AT_name {{.*}} "m_fn2"
+; CHECK:     DW_AT_name {{.*}}"m_fn2"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:     DW_TAG_formal_parameter
 
 ; The abstract definition of C::m_fn2
 ; CHECK: [[M_FN2_ABS_DEF:.*]]: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK:   DW_AT_specification {{.*}} {[[M_FN2_DECL]]}
 ; CHECK-NOT: DW_TAG
 ; CHECK:   DW_AT_inline
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK: [[M_FN2_THIS_ABS_DEF:.*]]:   DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
-; CHECK:     DW_AT_name {{.*}} "this"
+; CHECK:     DW_AT_name {{.*}}"this"
 
 ; Skip some other functions
 ; CHECK: DW_TAG_subprogram
 ; CHECK: DW_TAG_subprogram
 ; CHECK: DW_TAG_subprogram
 
 ; The concrete definition of C::m_fn2
 ; CHECK: DW_TAG_subprogram

llvm/test/DebugInfo/Generic/restrict.ll

 ; RUN: %llc_dwarf -dwarf-version=2 -O0 -filetype=obj < %s | llvm-dwarfdump -v -debug-info - | FileCheck --check-prefix=CHECK --check-prefix=V2 %s
 ; RUN: %llc_dwarf -dwarf-version=3 -O0 -filetype=obj < %s | llvm-dwarfdump -v -debug-info - | FileCheck --check-prefix=CHECK --check-prefix=V3 %s
 
-; CHECK: DW_AT_name {{.*}} "dst"
+; CHECK: DW_AT_name {{.*}}"dst"
 ; V2: DW_AT_type {{.*}} {[[PTR:0x.*]]}
 ; V3: DW_AT_type {{.*}} {[[RESTRICT:0x.*]]}
 ; V3: [[RESTRICT]]: {{.*}}DW_TAG_restrict_type
 ; V3-NEXT: DW_AT_type {{.*}} {[[PTR:0x.*]]}
 ; CHECK: [[PTR]]: {{.*}}DW_TAG_pointer_type
 ; CHECK-NOT: DW_AT_type
 
 ; Generated with clang from:

llvm/test/DebugInfo/Generic/thrownTypes.ll

 ; RUN: %llc_dwarf -O0 -filetype=obj < %s | llvm-dwarfdump -v -debug-info - | FileCheck %s
 
 ; CHECK: DW_TAG_subprogram
-; CHECK:   DW_AT_name {{.*}} "f"
+; CHECK:   DW_AT_name {{.*}}"f"
 ; CHECK-NOT: DW_TAG
 ; CHECK:   DW_TAG_thrown_type
 ; CHECK-NEXT:   DW_AT_type {{.*}} {[[ERROR:.*]]}
 ; CHECK-NOT: DW_TAG
 ; CHECK:   DW_TAG_thrown_type
 ; CHECK-NEXT:   DW_AT_type {{.*}} {[[ERROR2:.*]]}
 ; CHECK: [[ERROR]]: DW_TAG_structure_type
-; CHECK-NEXT:   DW_AT_name {{.*}} "Error"
+; CHECK-NEXT:   DW_AT_name {{.*}}"Error"
 ; CHECK: [[ERROR2]]: DW_TAG_structure_type
-; CHECK-NEXT:   DW_AT_name {{.*}} "DifferentError"
+; CHECK-NEXT:   DW_AT_name {{.*}}"DifferentError"
 
 ; Function Attrs: nounwind uwtable
 define void @f() #0 !dbg !5 {
 entry:
   ret void, !dbg !11
 }
 
 attributes #0 = { nounwind uwtable }

llvm/test/DebugInfo/Generic/tu-composite.ll

-; RUN: %llc_dwarf -filetype=obj -O0 < %s > %t
+; RUN: %llc_dwarf -filetype=obj -O0 -dwarf-inlined-strings=Disable < %s > %t
 ; RUN: llvm-dwarfdump -v -debug-info %t | FileCheck %s
 ; CHECK: [[TYPE:.*]]: DW_TAG_structure_type
 ; Make sure we correctly handle containing type of a struct being a type identifier.
 ; CHECK-NEXT: DW_AT_containing_type [DW_FORM_ref4]       (cu + {{.*}} => {[[TYPE]]})
-; CHECK-NEXT: DW_AT_name [DW_FORM_strp] {{.*}}= "C")
+; CHECK-NEXT: DW_AT_name [DW_FORM_strp] {{.*}}"C")
 
 ; Make sure we correctly handle context of a subprogram being a type identifier.
 ; CHECK: [[SP:.*]]: DW_TAG_subprogram
-; CHECK: DW_AT_name [DW_FORM_strp] {{.*}}= "foo")
+; CHECK: DW_AT_name [DW_FORM_strp] {{.*}}"foo")
 ; Make sure we correctly handle containing type of a subprogram being a type identifier.
 ; CHECK: DW_AT_containing_type [DW_FORM_ref4]       (cu + {{.*}} => {[[TYPE]]})
 ; CHECK: DW_TAG_formal_parameter
 ; CHECK: NULL
 ; CHECK: NULL
 
 ; CHECK: [[TYPE2:.*]]: DW_TAG_structure_type
-; CHECK: DW_AT_name [DW_FORM_strp] {{.*}}= "bar")
+; CHECK: DW_AT_name [DW_FORM_strp] {{.*}}"bar")
 ; CHECK: DW_TAG_structure_type
-; CHECK: DW_AT_name [DW_FORM_strp] {{.*}}= "D")
+; CHECK: DW_AT_name [DW_FORM_strp] {{.*}}"D")
 ; CHECK: DW_TAG_member
-; CHECK: DW_AT_name [DW_FORM_strp] {{.*}}= "a") 
+; CHECK: DW_AT_name [DW_FORM_strp] {{.*}}"a") 
 ; Make sure we correctly handle context of a struct being a type identifier.
 ; CHECK: DW_TAG_structure_type
-; CHECK-NEXT: DW_AT_name [DW_FORM_strp] {{.*}}= "Nested")
+; CHECK-NEXT: DW_AT_name [DW_FORM_strp] {{.*}}"Nested")
 ; CHECK: DW_TAG_structure_type
-; CHECK-NEXT: DW_AT_name [DW_FORM_strp] {{.*}}= "Nested2")
+; CHECK-NEXT: DW_AT_name [DW_FORM_strp] {{.*}}"Nested2")
 ; CHECK-NEXT: DW_AT_declaration [DW_FORM_flag]      (0x01)
 ; CHECK: DW_TAG_structure_type
-; CHECK-NEXT: DW_AT_name [DW_FORM_strp] {{.*}}= "virt<bar>")
+; CHECK-NEXT: DW_AT_name [DW_FORM_strp] {{.*}}"virt<bar>")
 ; Make sure we correctly handle type of a template_type being a type identifier.
 ; CHECK: DW_TAG_template_type_parameter
 ; CHECK-NEXT: DW_AT_type [DW_FORM_ref4] (cu + {{.*}} => {[[TYPE2]]}
-; CHECK-NEXT: DW_AT_name [DW_FORM_strp] {{.*}}= "T")
+; CHECK-NEXT: DW_AT_name [DW_FORM_strp] {{.*}}"T")
 ; Make sure we correctly handle derived-from of a typedef being a type identifier.
 ; CHECK: DW_TAG_typedef
 ; CHECK-NEXT: DW_AT_type [DW_FORM_ref4] (cu + {{.*}} => {[[TYPE2]]}
-; CHECK: DW_AT_name [DW_FORM_strp] {{.*}}= "baz2")
+; CHECK: DW_AT_name [DW_FORM_strp] {{.*}}"baz2")
 ; Make sure we correctly handle derived-from of a pointer type being a type identifier.
 ; CHECK: DW_TAG_pointer_type
 ; CHECK: DW_AT_type [DW_FORM_ref4] (cu + {{.*}} => {[[TYPE]]}
 ; CHECK: DW_TAG_typedef
 ; CHECK-NEXT: DW_AT_type [DW_FORM_ref4] (cu + {{.*}} => {[[TYPE2]]}
-; CHECK: DW_AT_name [DW_FORM_strp] {{.*}}= "baz")
+; CHECK: DW_AT_name [DW_FORM_strp] {{.*}}"baz")
 ; Make sure we correctly handle derived-from of an array type being a type identifier.
 ; CHECK: DW_TAG_array_type
 ; CHECK-NEXT: DW_AT_type [DW_FORM_ref4] (cu + {{.*}} => {[[TYPE2]]}
 ; IR generated from clang -g with the following source:
 ; struct C {
 ;   virtual void foo();
 ; };
 ; void C::foo() {

llvm/test/DebugInfo/Generic/varargs.ll

 ; RUN: %llc_dwarf -O0 -filetype=obj -o %t.o %s
 ; RUN: llvm-dwarfdump -v -debug-info %t.o | FileCheck %s
 ;
 ; Test debug info for variadic function arguments.
 ; Created from tools/clang/tests/CodeGenCXX/debug-info-varargs.cpp
 ;
 ; The ... parameter of variadic should be emitted as
 ; DW_TAG_unspecified_parameters.
 ;
 ; Normal variadic function.
 ; void b(int c, ...);
 ;
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_name {{.*}} "a"
+; CHECK: DW_AT_name {{.*}}"a"
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_TAG_unspecified_parameters
 ;
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_name {{.*}} "b"
+; CHECK: DW_AT_name {{.*}}"b"
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_TAG_formal_parameter
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_TAG_variable
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_TAG_variable
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_TAG_unspecified_parameters

llvm/test/DebugInfo/Inputs/gmlt.ll

 
 ; FIXME: Emitting separate abstract definitions is inefficient when we could
 ; just attach the DW_AT_name to the inlined_subroutine directly. Except that
 ; would produce many string relocations. Implement string indexing in the
 ; skeleton CU to address the relocation problem, then remove abstract
 ; definitions from -gmlt here.
 
 ; CHECK: DW_TAG_subprogram
-; CHECK-NEXT:     DW_AT_name {{.*}} "f3"
+; CHECK-NEXT:     DW_AT_name {{.*}}"f3"
 ; CHECK-NEXT:     DW_AT_inline
 
 ; Check that we only provide the minimal attributes on a subprogram to save space.
 ; CHECK:   DW_TAG_subprogram
 ; CHECK-NEXT:     DW_AT_low_pc
 ; CHECK-NEXT:     DW_AT_high_pc
 ; CHECK-NEXT:     DW_AT_name
 ; CHECK-NOT: {{DW_TAG|DW_AT}}
 ; CHECK:     DW_TAG_inlined_subroutine
 
 ; As mentioned above - replace DW_AT_abstract_origin with DW_AT_name to save
 ; space once we have support for string indexing in non-dwo sections
 
-; CHECK-NEXT:       DW_AT_abstract_origin {{.*}} "f3"
+; CHECK-NEXT:       DW_AT_abstract_origin {{.*}}"f3"
 ; CHECK-NEXT:       DW_AT_low_pc
 ; CHECK-NEXT:       DW_AT_high_pc
 ; CHECK-NEXT:       DW_AT_call_file
 ; CHECK-NEXT:       DW_AT_call_line
 ; CHECK-NEXT:       DW_AT_call_column
 
 ; Make sure we don't have any other subprograms here (subprograms with no
 ; inlined subroutines are omitted by design to save space)

llvm/test/Linker/Inputs/type-unique-simple2-a.ll

 ; Make sure the backend generates a single DIE and uses ref_addr.
 ; CHECK: 0x[[BASE:.*]]: DW_TAG_structure_type
-; CHECK-NEXT: DW_AT_name {{.*}} = "Base"
+; CHECK-NEXT: DW_AT_name {{.*}}"Base"
 ; CHECK-NOT: DW_TAG_structure_type
 ; CHECK: 0x[[INT:.*]]: DW_TAG_base_type
-; CHECK-NEXT: DW_AT_name {{.*}} = "int"
+; CHECK-NEXT: DW_AT_name {{.*}}"int"
 ; CHECK-NOT: DW_TAG_base_type
 
 ; CHECK: DW_TAG_compile_unit
 ; CHECK: DW_TAG_formal_parameter
 ; CHECK: DW_AT_type [DW_FORM_ref_addr] {{.*}}[[INT]]
 ; CHECK: DW_TAG_variable
 ; CHECK: DW_AT_type [DW_FORM_ref_addr] {{.*}}[[BASE]]
 

llvm/test/Linker/type-unique-odr-a.ll

 ;    10
 ;    11 void baz() { bar(); }
 ;; #include "ab.h"
 ; foo_t bar() {
 ;     return A().getFoo();
 ; }
 ;
 ; CHECK:      DW_TAG_class_type
-; CHECK-NEXT:   DW_AT_name {{.*}} "A"
+; CHECK-NEXT:   DW_AT_name {{.*}}"A"
 ; CHECK-NOT:    DW_TAG
 ; CHECK:        DW_TAG_member
-; CHECK-NEXT:     DW_AT_name {{.*}} "data"
+; CHECK-NEXT:     DW_AT_name {{.*}}"data"
 ; CHECK-NOT:    DW_TAG
 ; CHECK:        DW_TAG_subprogram
 ; CHECK-NOT:    DW_TAG
-; CHECK:          DW_AT_linkage_name {{.*}} "_ZN1A6getFooEv"
+; CHECK:          DW_AT_linkage_name {{.*}}"_ZN1A6getFooEv"
 ; CHECK-NOT:    DW_TAG
-; CHECK:          DW_AT_name {{.*}} "getFoo"
+; CHECK:          DW_AT_name {{.*}}"getFoo"
 
 ; Ensure that there aren't any other subprograms in class A.
 ; CHECK-NOT:      DW_TAG
 ; CHECK:          DW_TAG_formal_parameter
 ; CHECK-NOT:      DW_TAG
 ; CHECK:          NULL
 ; CHECK-NOT:    DW_TAG
 ; CHECK:        NULL

llvm/test/Linker/type-unique-simple-a.ll

 ; REQUIRES: default_triple, object-emission
 
 ; RUN: llvm-link %s %p/type-unique-simple-b.ll -S -o %t
 ; RUN: cat %t | FileCheck %s -check-prefix=LINK
 ; RUN: %llc_dwarf -filetype=obj -O0 < %t > %t2
 ; RUN: llvm-dwarfdump -v -debug-info %t2 | FileCheck %s
 
 ; Make sure the backend generates a single DIE and uses ref_addr.
 ; CHECK: 0x[[BASE:.*]]: DW_TAG_structure_type
-; CHECK-NEXT: DW_AT_name {{.*}} = "Base"
+; CHECK-NEXT: DW_AT_name {{.*}}"Base"
 ; CHECK-NOT: DW_TAG_structure_type
 ; CHECK: 0x[[INT:.*]]: DW_TAG_base_type
-; CHECK-NEXT: DW_AT_name {{.*}} = "int"
+; CHECK-NEXT: DW_AT_name {{.*}}"int"
 ; CHECK-NOT: DW_TAG_base_type
 
 ; CHECK: DW_TAG_compile_unit
 ; CHECK: DW_TAG_formal_parameter
 ; CHECK: DW_AT_type [DW_FORM_ref_addr] {{.*}}[[INT]]
 ; CHECK: DW_TAG_variable
 ; CHECK: DW_AT_type [DW_FORM_ref_addr] {{.*}}[[BASE]]
 

llvm/test/Linker/type-unique-simple2-a.ll

 ; };
 ;
 ; $ cat a.cpp
 ; #include "ab.h"
 ; foo_t bar() {
 ;     return A().getFoo();
 ; }
 ;
-; CHECK: DW_AT_name {{.*}} "setFoo"
+; CHECK: DW_AT_name {{.*}}"setFoo"
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_accessibility [DW_FORM_data1]   (DW_ACCESS_public)
 ; CHECK-NOT: DW_AT_accessibility
 ; CHECK: DW_TAG
 
 ; ModuleID = 'a.cpp'
 
 %class.A = type { i32 (...)** }

llvm/test/Linker/type-unique-type-array-a.ll

 ;     9 };
 ;    10 
 ;    11 void topA(A *a, SA sa) {
 ;    12   a->testA(sa);
 ;    13 }
 ;
 ; CHECK: DW_TAG_compile_unit
 ; CHECK: DW_TAG_class_type
-; CHECK-NEXT:   DW_AT_name {{.*}} "A"
+; CHECK-NEXT:   DW_AT_name {{.*}}"A"
 ; CHECK: DW_TAG_subprogram
-; CHECK: DW_AT_name {{.*}} "testA"
+; CHECK: DW_AT_name {{.*}}"testA"
 ; CHECK: DW_TAG_formal_parameter
 ; CHECK: DW_TAG_formal_parameter
 ; CHECK-NEXT: DW_AT_type [DW_FORM_ref4] (cu + 0x{{.*}} => {0x[[STRUCT:.*]]}
 ; CHECK: 0x[[STRUCT]]: DW_TAG_structure_type
-; CHECK-NEXT:   DW_AT_name {{.*}} "SA"
+; CHECK-NEXT:   DW_AT_name {{.*}}"SA"
 
 ; CHECK: DW_TAG_compile_unit
 ; CHECK: DW_TAG_class_type
-; CHECK-NEXT:   DW_AT_name {{.*}} "B"
+; CHECK-NEXT:   DW_AT_name {{.*}}"B"
 ; CHECK: DW_TAG_subprogram
-; CHECK:   DW_AT_name {{.*}} "testB"
+; CHECK:   DW_AT_name {{.*}}"testB"
 ; CHECK: DW_TAG_formal_parameter
 ; CHECK: DW_TAG_formal_parameter
 ; CHECK-NEXT: DW_AT_type [DW_FORM_ref_addr] {{.*}}[[STRUCT]]
 
 %class.A = type { i8 }
 %struct.SA = type { i32 }
 
 ; Function Attrs: ssp uwtable