[yaml2obj][obj2yaml] - Stop using square brackets for unique suffixes.

[grimar]

Summary

For describing section/symbol names we can use unique suffixes,
e.g:

- Name: '.foo [1]`
- Name: '.foo [2]`

It can be a problem (see https://reviews.llvm.org/D79984#inline-734829),
because [] are sometimes used to describe a macros:

- Name: "[[a0]]"

Seems the better approach is to use something else, like "()" or "<>".
This patch does it and refactors the code related.

[grimar]

I am going to change the new API to a better version.

[grimar]

• Refined new API.

[MaskRay]

LGTM.

[jhenderson]

Just a couple of small test suggestions for documentation purposes.

llvm/test/tools/yaml2obj/ELF/duplicate-section-names.yaml

35–36

If I understand it correctly, '.foo2 (asbdjasbdjasbd)' is also a valid unique suffix. Perhaps worth showing that arbitrary contents are allowed in there?

llvm/test/tools/yaml2obj/ELF/duplicate-symbol-names.yaml

18

Same comment as above. Perhaps worth showing that the contents of the '()' can be arbitrary.

[grimar]

llvm/test/tools/yaml2obj/ELF/duplicate-section-names.yaml

35–36

We have such tests. See duplicate-symbol-and-section-names.yaml above:

--- !ELF
FileHeader:
  Class:   ELFCLASS64
  Data:    ELFDATA2LSB
  Type:    ET_REL
  Machine: EM_X86_64
Sections:
  - Name: .foo
    Type: SHT_PROGBITS
  - Name: '.foo (555)'
    Type: SHT_PROGBITS
  - Name: '.foo (random_tag)'
    Type: SHT_PROGBITS
  - Name: .bar
    Type: SHT_PROGBITS
  - Name: '.bar (666)'
    Type: SHT_PROGBITS
  - Name: '.bar (random_tag)'
    Type: SHT_PROGBITS
Symbols:
  - Name: 'localfoo (111)'
  - Name: 'localfoo (222)'
  - Name: 'localfoo (random_tag)'
  - Name: 'localbar (333)'
  - Name: 'localbar (444)'
  - Name: 'localbar (random_tag)'

llvm/test/tools/yaml2obj/ELF/duplicate-symbol-names.yaml

18

The same.

[jhenderson]

LGTM, thanks.

llvm/include/llvm/ObjectYAML/ELFYAML.h

 #include <cstdint>
 #include <memory>
 #include <vector>
 
 namespace llvm {
 namespace ELFYAML {
 
 StringRef dropUniqueSuffix(StringRef S);
+StringRef getNameSuffixStart();
+char getNameSuffixEnd();
 
 // These types are invariant across 32/64-bit ELF, so for simplicity just
 // directly give them their exact sizes. We don't need to worry about
 // endianness because these are just the types in the YAMLIO structures,
 // and are appropriately converted to the necessary endianness when
 // reading/generating binary object files.
 // The naming of these types is intended to be ELF_PREFIX, where PREFIX is
 // the common prefix of the respective constants. E.g. ELF_EM corresponds

llvm/lib/ObjectYAML/ELFEmitter.cpp

bool ELFState<ELFT>::initImplicitHeader(ContiguousBlobAccumulator &CBA,
 
   LocationCounter += Header.sh_size;
 
   // Override section fields if requested.
   overrideFields<ELFT>(YAMLSec, Header);
   return true;
 }
 
+StringRef llvm::ELFYAML::getNameSuffixStart() { return " ("; }
+
+char llvm::ELFYAML::getNameSuffixEnd() { return ')'; }
+
 StringRef llvm::ELFYAML::dropUniqueSuffix(StringRef S) {
-  size_t SuffixPos = S.rfind(" [");
+  if (S.empty() || S.back() != ELFYAML::getNameSuffixEnd())
+    return S;
+
+  size_t SuffixPos = S.rfind(ELFYAML::getNameSuffixStart());
   if (SuffixPos == StringRef::npos)
     return S;
   return S.substr(0, SuffixPos);
 }
 
 template <class ELFT>
 void ELFState<ELFT>::initSectionHeaders(std::vector<Elf_Shdr> &SHeaders,
                                         ContiguousBlobAccumulator &CBA) {

llvm/test/Object/X86/obj2yaml-dup-section-name.s

 # RUN: llvm-mc %s -o %t.o -filetype=obj -triple=x86_64-pc-linux
 # RUN: obj2yaml %t.o | FileCheck %s
 
 # CHECK: Sections:
 # CHECK: - Name:            .group{{$}}
 # CHECK:   Members:
 # CHECK:     - SectionOrType:   .text.foo{{$}}
 # CHECK:     - SectionOrType:   .rela.text.foo{{$}}
 # CHECK: - Name:            .text.foo{{$}}
 # CHECK: - Name:            .rela.text.foo{{$}}
 # CHECK:   Info:            .text.foo{{$}}
-# CHECK: - Name:            '.group [1]'
+# CHECK: - Name:            '.group (1)'
 # CHECK:   Members:
-# CHECK:     - SectionOrType:   '.text.foo [1]'
-# CHECK:     - SectionOrType:   '.rela.text.foo [1]'
-# CHECK: - Name:            '.text.foo [1]'
-# CHECK: - Name:            '.rela.text.foo [1]'
-# CHECK:   Info:            '.text.foo [1]'
+# CHECK:     - SectionOrType:   '.text.foo (1)'
+# CHECK:     - SectionOrType:   '.rela.text.foo (1)'
+# CHECK: - Name:            '.text.foo (1)'
+# CHECK: - Name:            '.rela.text.foo (1)'
+# CHECK:   Info:            '.text.foo (1)'
 # CHECK: Symbols:
 # CHECK:   Section:         .group{{$}}
-# CHECK:   Section:         '.group [1]'
+# CHECK:   Section:         '.group (1)'
 
 
         .section        .text.foo,"axG",@progbits,sym1,comdat
         .quad undef
 
         .section        .text.foo,"axG",@progbits,sym2,comdat
         .quad undef

llvm/test/tools/llvm-dwarfdump/X86/section_sizes_elf.test

- Name: .debug_line
     Type: SHT_PROGBITS
     Size: 19
   - Name: .debug_loc
     Type: SHT_PROGBITS
     Size: 1
   - Name: .debug_type
     Type: SHT_PROGBITS
     Size: 13
-  - Name: .debug_type [1]
+  - Name: .debug_type (1)
     Type: SHT_PROGBITS
     Size: 13
   - Name: .debug_foo
     Type: SHT_PROGBITS
     Size: 100
   - Name: .debug_info.dwo
     Type: SHT_PROGBITS
     Size: 9
 ## This is a debug section following the Mach-O naming style, and is used
 ## to show that such sections are not included in the report.
   - Name: __debug_bar
     Type: SHT_PROGBITS
     Size: 1

llvm/test/tools/llvm-gsymutil/X86/elf-dwarf.yaml

- Name:            frame_dummy
     Value:           0x00000000004004A0
   - Name:            __frame_dummy_init_array_entry
     Type:            STT_OBJECT
     Section:         .init_array
     Value:           0x0000000000600E10
   - Name:            main.cpp
     Type:            STT_FILE
     Index:           SHN_ABS
-  - Name:            'crtstuff.c [1]'
+  - Name:            'crtstuff.c (1)'
     Type:            STT_FILE
     Index:           SHN_ABS
   - Name:            __FRAME_END__
     Type:            STT_OBJECT
     Section:         .eh_frame
     Value:           0x0000000000400698
   - Name:            __JCR_END__
     Type:            STT_OBJECT

llvm/test/tools/llvm-objcopy/ELF/strip-dwo-groups.test

- Name: .group
     Link: .symtab
     Info: group1
     Members:
       - SectionOrType: GRP_COMDAT
       - SectionOrType: .text.group1
   - Name:  .text.group1
     Type:  SHT_PROGBITS
     Flags: [ SHF_ALLOC, SHF_EXECINSTR, SHF_GROUP ]
-  - Name: '.group [1]'
+  - Name: '.group (1)'
     Type: SHT_GROUP
     Link: .symtab
     Info: group2
     Members:
       - SectionOrType: GRP_COMDAT
       - SectionOrType: .text.group2
       - SectionOrType: .rela.text.group2
   - Name:  .text.group2

llvm/test/tools/llvm-readobj/ELF/stack-sizes.test

- Name:    .text.baz
     Flags:   [SHF_ALLOC]
     Size:    16
   - Name:    .stack_sizes
     Type:    SHT_PROGBITS
     Entries:
       - Size: 0x10
       - Size: 0x20
     Link:    .text
-  - Name:    '.stack_sizes [1]'
+  - Name:    '.stack_sizes (1)'
     Type:    SHT_PROGBITS
     Entries:
       - Address: 0x20
         Size:    0x8
     Link:    .text.baz
   - Name:    .rela.stack_sizes
     Type:    SHT_RELA
     Info:    .stack_sizes
     Relocations:
 ## A symbol relative reference. 
       - Offset: 0
         Symbol: referenced_by_symbol_foo 
         Type:   R_X86_64_64
 ## A section relative reference. 
       - Offset: 9
         Addend: 16
         Symbol: .text
         Type:   R_X86_64_64
-  - Name:   '.rela.stack_sizes [1]'
+  - Name:   '.rela.stack_sizes (1)'
     Type:   SHT_RELA
-    Info:   '.stack_sizes [1]'
+    Info:   '.stack_sizes (1)'
     Relocations:
       - Offset: 0
         Symbol: separate_text_section_baz
         Type:   R_X86_64_64
 Symbols:
   - Name:    separate_text_section_baz
     Section: .text.baz
     Type:    STT_FUNC

llvm/test/tools/obj2yaml/ELF/duplicate-symbol-and-section-names.yaml

 # CASE1-NEXT: FileHeader:
 # CASE1-NEXT:   Class:   ELFCLASS64
 # CASE1-NEXT:   Data:    ELFDATA2LSB
 # CASE1-NEXT:   Type:    ET_REL
 # CASE1-NEXT:   Machine: EM_X86_64
 # CASE1-NEXT: Sections:
 # CASE1-NEXT:   - Name: .foo
 # CASE1-NEXT:     Type: SHT_PROGBITS
-# CASE1-NEXT:   - Name: '.foo [1]'
+# CASE1-NEXT:   - Name: '.foo (1)'
 # CASE1-NEXT:     Type: SHT_PROGBITS
-# CASE1-NEXT:   - Name: '.foo [2]'
+# CASE1-NEXT:   - Name: '.foo (2)'
 # CASE1-NEXT:     Type: SHT_PROGBITS
 # CASE1-NEXT:   - Name: .bar
 # CASE1-NEXT:     Type: SHT_PROGBITS
-# CASE1-NEXT:   - Name: '.bar [1]'
+# CASE1-NEXT:   - Name: '.bar (1)'
 # CASE1-NEXT:     Type: SHT_PROGBITS
-# CASE1-NEXT:   - Name: '.bar [2]'
+# CASE1-NEXT:   - Name: '.bar (2)'
 # CASE1-NEXT:     Type: SHT_PROGBITS
 # CASE1-NEXT: Symbols:
 # CASE1-NEXT:   - Name: localfoo
-# CASE1-NEXT:   - Name: 'localfoo [1]'
-# CASE1-NEXT:   - Name: 'localfoo [2]'
+# CASE1-NEXT:   - Name: 'localfoo (1)'
+# CASE1-NEXT:   - Name: 'localfoo (2)'
 # CASE1-NEXT:   - Name: localbar
-# CASE1-NEXT:   - Name: 'localbar [1]'
-# CASE1-NEXT:   - Name: 'localbar [2]'
+# CASE1-NEXT:   - Name: 'localbar (1)'
+# CASE1-NEXT:   - Name: 'localbar (2)'
 # CASE1-NEXT: ...
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .foo
     Type: SHT_PROGBITS
-  - Name: '.foo [555]'
+  - Name: '.foo (555)'
     Type: SHT_PROGBITS
-  - Name: '.foo [random_tag]'
+  - Name: '.foo (random_tag)'
     Type: SHT_PROGBITS
   - Name: .bar
     Type: SHT_PROGBITS
-  - Name: '.bar [666]'
+  - Name: '.bar (666)'
     Type: SHT_PROGBITS
-  - Name: '.bar [random_tag]'
+  - Name: '.bar (random_tag)'
     Type: SHT_PROGBITS
 Symbols:
-  - Name: 'localfoo [111]'
-  - Name: 'localfoo [222]'
-  - Name: 'localfoo [random_tag]' 
-  - Name: 'localbar [333]'
-  - Name: 'localbar [444]'
-  - Name: 'localbar [random_tag]' 
+  - Name: 'localfoo (111)'
+  - Name: 'localfoo (222)'
+  - Name: 'localfoo (random_tag)'
+  - Name: 'localbar (333)'
+  - Name: 'localbar (444)'
+  - Name: 'localbar (random_tag)'
 
 ## Check we can refer to symbols with the same
 ## name from relocations.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: obj2yaml %t2 | FileCheck %s --check-prefix=CASE2
 
 # CASE2:      Relocations:
-# CASE2-NEXT:  - Symbol: 'foo [1]'
+# CASE2-NEXT:  - Symbol: 'foo (1)'
 # CASE2-NEXT:    Type:   R_X86_64_PC32
 # CASE2-NEXT:  - Offset: 0x0000000000000004
 # CASE2-NEXT:    Symbol: foo
 # CASE2-NEXT:    Type:   R_X86_64_PC32
 # CASE2-NEXT: Symbols:
 # CASE2-NEXT:  - Name: foo
-# CASE2-NEXT:  - Name: 'foo [1]'
+# CASE2-NEXT:  - Name: 'foo (1)'
   
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .text
     Type: SHT_PROGBITS
     Size: 8
   - Name: .rela.text
     Type: SHT_RELA
     Info: .text
     Link: .symtab
     Relocations:
       - Type: R_X86_64_PC32
-        Symbol: 'foo [1]'
+        Symbol: 'foo (1)'
       - Type: R_X86_64_PC32
         Offset: 4
         Symbol: foo
 Symbols:
   - Name: foo
-  - Name: 'foo [1]'
+  - Name: 'foo (1)'
 
 ## Check obj2yaml does not add a suffix to a name if the
 ## symbol is in .symtab and .dynsym at the same time.
 
 # RUN: yaml2obj --docnum=3 %s -o %t3
 # RUN: obj2yaml %t3 | FileCheck %s --check-prefix=CASE3
 
 # CASE3:      Symbols:

llvm/test/tools/obj2yaml/ELF/program-headers.yaml

 # YAML-NEXT:    Sections:
 # YAML-NEXT:      - Section: .foo
 # YAML-NEXT:      - Section: .zed
 # YAML-NEXT:    VAddr: 0x0000000000001000
 # YAML-NEXT:    Align: 0x0000000000001000
 # YAML-NEXT:  - Type:  PT_LOAD
 # YAML-NEXT:    Flags: [ PF_R ]
 # YAML-NEXT:    Sections:
-# YAML-NEXT:      - Section: '.foo [1]'
+# YAML-NEXT:      - Section: '.foo (1)'
 # YAML-NEXT:      - Section: .baz
 # YAML-NEXT:    VAddr: 0x0000000000002000
 # YAML-NEXT:    Align: 0x0000000000001000
 # YAML-NEXT:  - Type:  PT_LOAD
 # YAML-NEXT:    Flags: [ PF_W, PF_R ]
 # YAML-NEXT:    Sections:
 # YAML-NEXT:      - Section: .dynamic
 # YAML-NEXT:      - Section: .dynamic.tail
Sections:
       - Section: .foo
       - Section: .zed
     VAddr: 0x1000
     Align: 0x1000
 ## Create a PT_LOAD to demonstate we are able to refer to output sections with the same name.
   - Type:  PT_LOAD
     Flags: [ PF_R ]
     Sections:
-      - Section: '.foo [1]'
+      - Section: '.foo (1)'
       - Section: .baz
     VAddr: 0x2000
     Align: 0x1000
 ## Show we can create a writeable PT_LOAD segment and put an arbitrary section into it.
 ## Here we test both regular (SHT_PROGBITS) and a special section (SHT_DYNAMIC).
   - Type:  PT_LOAD
     Flags: [ PF_W, PF_R ]
     Sections:
- Name:    .foo
     Flags:   [ SHF_ALLOC, SHF_EXECINSTR ]
     Address: 0x1000
     Size:    0x8
   - Name:    .zed
     Type:    SHT_PROGBITS
     Flags:   [ SHF_ALLOC, SHF_EXECINSTR ]
     Address: 0x1008
     Size:    0x8
-  - Name:    '.foo [1]'
+  - Name:    '.foo (1)'
     Type:    SHT_PROGBITS
     Flags:   [ SHF_ALLOC ]
     Address: 0x2000
     Size:    0x8
   - Name:    .baz
     Type:    SHT_PROGBITS
     Flags:   [ SHF_ALLOC ]
     Address: 0x2008

llvm/test/tools/yaml2obj/ELF/call-graph-profile-section.yaml

- Name: .llvm.call-graph-profile
     Type: SHT_LLVM_CALL_GRAPH_PROFILE
     Entries:
 ## Case 1: Test we can use symbol names to describe an entry.
       - From:   foo
         To:     bar
         Weight: 10
 ## Case 2: Test we can refer to symbols with suffixes.
       - From:   foo
-        To:     'foo [1]'
+        To:     'foo (1)'
         Weight: 30
 Symbols:
   - Name: foo
   - Name: bar
-  - Name: 'foo [1]'
+  - Name: 'foo (1)'
 
 ## Check we can describe SHT_LLVM_CALL_GRAPH_PROFILE sections using the "Content" tag.
 # RUN: yaml2obj --docnum=5 %s -o %t.content
 # RUN: llvm-readobj --sections --section-data %t.content | FileCheck %s --check-prefix=CONTENT
 
 # CONTENT:      Name: .llvm.call-graph-profile
 # CONTENT:      SectionData (
 # CONTENT-NEXT:   0000: 11223344 |

llvm/test/tools/yaml2obj/ELF/duplicate-section-names.yaml

 ## Check that yaml2obj is able to produce an object from YAML
 ## containing sections with duplicate names (but different name suffixes).
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
-# RUN: llvm-readobj -s %t1 | FileCheck %s --check-prefix=CASE1
+# RUN: llvm-readelf -sections %t1 | FileCheck %s --check-prefix=CASE1
 
-# CASE1: Name: .foo1 (
-# CASE1: Name: .foo (
-# CASE1: Name: .foo (
-# CASE1: Name: .foo2 (
+# CASE1:      [Nr] Name    Type
+# CASE1:      [ 1] .foo1   PROGBITS
+# CASE1-NEXT: [ 2] .foo    PROGBITS
+# CASE1-NEXT: [ 3] .foo    PROGBITS
+# CASE1-NEXT: [ 4] .foo2   PROGBITS
+# CASE1-NEXT: [ 5] .foo2 ( PROGBITS
+# CASE1-NEXT: [ 6] .foo2 ) PROGBITS
+# CASE1-NEXT: [ 7] .foo2   PROGBITS
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .foo1
     Type: SHT_PROGBITS
   - Name: .foo
     Type: SHT_PROGBITS
-  - Name: '.foo [1]'
+  - Name: '.foo (1)'
     Type: SHT_PROGBITS
   - Name: .foo2
     Type: SHT_PROGBITS
+  - Name: '.foo2 ('
+    Type: SHT_PROGBITS
+  - Name: '.foo2 )'
+    Type: SHT_PROGBITS
+  - Name: '.foo2 ()'
+    Type: SHT_PROGBITS
 
 ## Check that yaml2obj reports an error in case we have
 ## sections with equal names and suffixes.
 
 # RUN: not yaml2obj --docnum=2 %s 2>&1 | FileCheck %s --check-prefix=CASE2
-# CASE2: error: repeated section/fill name: '.foo [1]' at YAML section/fill number 2
-# CASE2: error: repeated section/fill name: '.foo [1]' at YAML section/fill number 3
+# CASE2: error: repeated section/fill name: '.foo (1)' at YAML section/fill number 2
+# CASE2: error: repeated section/fill name: '.foo (1)' at YAML section/fill number 3
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
-  - Name: '.foo [1]'
+  - Name: '.foo (1)'
     Type: SHT_PROGBITS
-  - Name: '.foo [1]'
+  - Name: '.foo (1)'
     Type: SHT_PROGBITS
-  - Name: '.foo [1]'
+  - Name: '.foo (1)'
     Type: SHT_PROGBITS
 
 ## Check that yaml2obj reports an error in case we have
 ## symbols without suffixes in the names and their
 ## names are equal.
 
 # RUN: not yaml2obj --docnum=3 %s 2>&1 | FileCheck %s --check-prefix=CASE3
 # CASE3: error: repeated section/fill name: '.foo' at YAML section/fill number 2

 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .foo
     Type: SHT_PROGBITS
-  - Name: '.foo [1]'
+  - Name: '.foo (1)'
     Type: SHT_PROGBITS
 Symbols:
   - Name:    foo
     Section: .foo
   - Name:    bar
-    Section: '.foo [1]'
+    Section: '.foo (1)'
 
 ## Check that yaml2obj can produce SHT_GROUP sections that
 ## reference sections and symbols with name suffixes.
 
 # RUN: yaml2obj --docnum=5 %s -o %t5
 # RUN: llvm-readobj --elf-section-groups %t5 | FileCheck %s --check-prefix=CASE5
 
 # CASE5:      Groups {
Sections:
   - Name: .group
     Type: SHT_GROUP
     Info: foo
     Members:
       - SectionOrType: GRP_COMDAT
       - SectionOrType: .text.foo
   - Name: .text.foo
     Type: SHT_PROGBITS
-  - Name: '.group [1]'
+  - Name: '.group (1)'
     Type: SHT_GROUP
-    Info: 'foo [1]'
+    Info: 'foo (1)'
     Members:
       - SectionOrType: GRP_COMDAT
-      - SectionOrType: '.text.foo [1]'
-  - Name: '.text.foo [1]'
+      - SectionOrType: '.text.foo (1)'
+  - Name: '.text.foo (1)'
     Type: SHT_PROGBITS
 Symbols:
   - Name:    foo
     Section: .text.foo
-  - Name:    'foo [1]'
-    Section: '.text.foo [1]'
+  - Name:    'foo (1)'
+    Section: '.text.foo (1)'

llvm/test/tools/yaml2obj/ELF/duplicate-symbol-names.yaml

 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Symbols:
   - Name: localfoo
-  - Name: 'localfoo [1]'
+  - Name: 'localfoo (1)'
 
 ## Check that yaml2obj reports an error when we have
 ## symbols with equal names and suffixes.
 
 # RUN: not yaml2obj --docnum=2 %s 2>&1| FileCheck %s --check-prefix=CASE2
-# CASE2-COUNT-2: error: repeated symbol name: 'localfoo [1]'
+# CASE2-COUNT-2: error: repeated symbol name: 'localfoo (1)'
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Symbols:
-  - Name: 'localfoo [1]'
-  - Name: 'localfoo [1]'
-  - Name: 'localfoo [1]'
+  - Name: 'localfoo (1)'
+  - Name: 'localfoo (1)'
+  - Name: 'localfoo (1)'
 
 ## Check that yaml2obj reports an error when we have
 ## symbols without suffixes in the names and their
 ## names are equal.
 
 # RUN: not yaml2obj --docnum=3 %s 2>&1| FileCheck %s --check-prefix=CASE3
 # CASE3: error: repeated symbol name: 'localfoo'
 # CASE3: error: repeated symbol name: 'localfoo'
- Name: .rela.text
     Type: SHT_RELA
     Info: .text
     Link: .symtab
     Relocations:
       - Type:   R_X86_64_NONE
         Symbol: foo
       - Offset: 0x1
         Type:   R_X86_64_NONE
-        Symbol: 'foo [1]'
+        Symbol: 'foo (1)'
 Symbols:
   - Name: foo
-  - Name: 'foo [1]'
+  - Name: 'foo (1)'

llvm/test/tools/yaml2obj/ELF/stack-sizes.yaml

 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
 ## Valid.
-  - Name:    '.stack_sizes [1]'
+  - Name:    '.stack_sizes (1)'
     Type:    SHT_PROGBITS
     Content: "100000000000000020"
 ## Truncated.
-  - Name:    '.stack_sizes [2]'
+  - Name:    '.stack_sizes (2)'
     Type:    SHT_PROGBITS
     Content: "1000000000000000"
 ## Empty.
-  - Name:    '.stack_sizes [3]'
+  - Name:    '.stack_sizes (3)'
     Type:    SHT_PROGBITS
     Content: ""
 
 ## Check we can describe .stack_sizes section using <address, size> pairs.
 
 # RUN: yaml2obj --docnum=2 -D BITS=64 -D ENCODE=LSB %s -o %t2.le64
 # RUN: llvm-readobj --sections --section-data %t2.le64 | FileCheck %s --check-prefix=ENTRIES-LE64-BOTH
 # RUN: yaml2obj --docnum=2 -D BITS=64 -D ENCODE=MSB %s -o %t2.be64

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
-  - Name:    '.stack_sizes [1]'
+  - Name:    '.stack_sizes (1)'
     Type:    SHT_PROGBITS
     Entries:
       - Address: 0x10
         Size:    0x20
-  - Name:    '.stack_sizes [2]'
+  - Name:    '.stack_sizes (2)'
     Type:    SHT_PROGBITS
     Entries:
       - Address: 0x30
         Size:    0x40

llvm/tools/obj2yaml/elf2yaml.cpp

ELFDumper<ELFT>::getUniquedSectionName(const Elf_Shdr *Sec) {
   // it doesn't make sense to uniquify their names and add noise to the output.
   if (Name.empty())
     return "";
 
   std::string &Ret = SectionNames[SecIndex];
 
   auto It = UsedSectionNames.insert({Name, 0});
   if (!It.second)
-    Ret = (Name + " [" + Twine(++It.first->second) + "]").str();
+    Ret = (Name + ELFYAML::getNameSuffixStart() + Twine(++It.first->second) +
+           Twine(ELFYAML::getNameSuffixEnd()))
+              .str();
   else
     Ret = std::string(Name);
   return Ret;
 }
 
 template <class ELFT>
 Expected<StringRef>
 ELFDumper<ELFT>::getUniquedSymbolName(const Elf_Sym *Sym, StringRef StrTable,
ELFDumper<ELFT>::getUniquedSymbolName(const Elf_Sym *Sym, StringRef StrTable,
   if (SymTab->sh_type == ELF::SHT_SYMTAB) {
     unsigned Index = Sym - SymTable.data();
     if (!SymbolNames[Index].empty())
       return SymbolNames[Index];
 
     auto It = UsedSymbolNames.insert({Name, 0});
     if (!It.second)
       SymbolNames[Index] =
-          (Name + " [" + Twine(++It.first->second) + "]").str();
+          (Name + ELFYAML::getNameSuffixStart() + Twine(++It.first->second) +
+           Twine(ELFYAML::getNameSuffixEnd()))
+              .str();
     else
       SymbolNames[Index] = std::string(Name);
     return SymbolNames[Index];
   }
 
   return Name;
 }