Don't use $ as suffix for symbol names in ThinLTOBitcodeWriter and other places

[hans]

Summary

Using $ breaks demangling of the symbols. For example,

$ c++filt _Z3foov\$123
_Z3foov$123

This causes problems for developers who would like to see nice stack traces etc. but also for automatic crash tracking systems which try to organize crashes based on the stack traces.

Instead, use the period as suffix separator, since Itanium demanglers normally ignore such suffixes:

$ c++filt _Z3foov.123
foo() [clone .123]

This is already done in some places; create a utility function to do it, and try to use that everywhere.

[lebedev.ri]

Why isn't the solution is to fix the uses to prevent variable substitution in them?
Because of course $1 is substituted with a value of variable 1 in shell, and elsewhere.

$ c++filt _Z3foov\$123
_Z3foov$123

[hans]

In D97484#2587991, @lebedev.ri wrote:

Why isn't the solution is to fix the uses to prevent variable substitution in them?
Because of course $1 is substituted with a value of variable 1 in shell, and elsewhere.

$ c++filt _Z3foov\$123
_Z3foov$123

Sorry, I should have used quotes. But your example shows that the name is still not getting demangled. Compare that with a period as separator:

$ c++filt _Z3foov.123
foo() [clone .123]

Now it demangles, and puts the suffix on the side.

[tejohnson]

Thanks for fixing this. Question below

llvm/lib/IR/Module.cpp

677 ↗

(On Diff #326420)

Should getUniqueModuleId be changed to not put in the "$"? Looking at the other use sites, it is used for renaming comdats and types - can/should these get the same treatment via this function (use .llvm.moduleId instead of $moduleId)?

[pcc]

llvm/lib/IR/Module.cpp

677 ↗

(On Diff #326420)

I agree, that function should be changed to use . instead of $.

[lebedev.ri]

In D97484#2588003, @hans wrote:

In D97484#2587991, @lebedev.ri wrote:

Why isn't the solution is to fix the uses to prevent variable substitution in them?
Because of course $1 is substituted with a value of variable 1 in shell, and elsewhere.

$ c++filt _Z3foov\$123
_Z3foov$123

Sorry, I should have used quotes. But your example shows that the name is still not getting demangled. Compare that with a period as separator:

$ c++filt _Z3foov.123
foo() [clone .123]

Now it demangles, and puts the suffix on the side.

Thank you, please make that more obvious in the patch's description :)

[hans]

Sorry for the delay, I got distracted by other fires.

I've updated the patch to just use a period as separator in getUniqueModuleId() and tweak any other place I found that used $ as separator on their own.

Please take another look.

[tejohnson]

lgtm, thanks!

llvm/lib/Transforms/IPO/WholeProgramDevirt.cpp

bool DevirtModule::trySingleImplDevirt(
   applySingleImplDevirt(SlotInfo, TheFn, IsExported);
   if (!IsExported)
     return false;
 
   // If the only implementation has local linkage, we must promote to external
   // to make it visible to thin LTO objects. We can only get here during the
   // ThinLTO export phase.
   if (TheFn->hasLocalLinkage()) {
-    std::string NewName = (TheFn->getName() + "$merged").str();
+    std::string NewName = (TheFn->getName() + ".llvm.merged").str();
 
     // Since we are renaming the function, any comdats with the same name must
     // also be renamed. This is required when targeting COFF, as the comdat name
     // must match one of the names of the symbols in the comdat.
     if (Comdat *C = TheFn->getComdat()) {
       if (C->getName() == TheFn->getName()) {
         Comdat *NewC = M.getOrInsertComdat(NewName);
         NewC->setSelectionKind(C->getSelectionKind());

llvm/lib/Transforms/Utils/ModuleUtils.cpp

std::string llvm::getUniqueModuleId(Module *M) {
   if (!ExportsSymbols)
     return "";
 
   MD5::MD5Result R;
   Md5.final(R);
 
   SmallString<32> Str;
   MD5::stringifyResult(R, Str);
-  return ("$" + Str).str();
+  return ("." + Str).str();
 }
 
 void VFABI::setVectorVariantNames(
     CallInst *CI, const SmallVector<std::string, 8> &VariantMappings) {
   if (VariantMappings.empty())
     return;
 
   SmallString<256> Buffer;

llvm/test/Instrumentation/AddressSanitizer/global_with_comdat.ll

 @_ZZ4funcvE10static_var = internal global i32 0, align 4
 @.str = private unnamed_addr constant [14 x i8] c"Hello, world!\00", align 1
 @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @_GLOBAL__sub_I_asan_globals.cpp, i8* null }]
 
 ; Check that globals were instrumented:
 
 ; COMDAT: $global = comdat any
 ; COMDAT: $dyn_init_global = comdat any
-; COMDAT: $"_ZZ4funcvE10static_var${{[01-9a-f]+}}" = comdat any
-; COMDAT: $".str${{[01-9a-f]+}}" = comdat any
+; COMDAT: $_ZZ4funcvE10static_var.{{[01-9a-f]+}} = comdat any
+; COMDAT: $.str.{{[01-9a-f]+}} = comdat any
 
 ; NOCOMDAT-NOT: $global = comdat any
 ; NOCOMDAT-NOT: $dyn_init_global = comdat any
-; NOCOMDAT-NOT: $"_ZZ4funcvE10static_var${{[01-9a-f]+}}" = comdat any
-; NOCOMDAT-NOT: $".str${{[01-9a-f]+}}" = comdat any
+; NOCOMDAT-NOT: $_ZZ4funcvE10static_var.{{[01-9a-f]+}} = comdat any
+; NOCOMDAT-NOT: $.str.{{[01-9a-f]+}} = comdat any
 
 ; COMDAT: @global = global { i32, [60 x i8] } zeroinitializer, comdat, align 32
 ; COMDAT: @dyn_init_global = global { i32, [60 x i8] } zeroinitializer, comdat, align 32
-; COMDAT: @_ZZ4funcvE10static_var = internal global { i32, [60 x i8] } zeroinitializer, comdat($"_ZZ4funcvE10static_var${{[01-9a-f]+}}"), align 32
-; COMDAT: @.str = internal constant { [14 x i8], [50 x i8] } { [14 x i8] c"Hello, world!\00", [50 x i8] zeroinitializer }, comdat($".str${{[01-9a-f]+}}"), align 32
+; COMDAT: @_ZZ4funcvE10static_var = internal global { i32, [60 x i8] } zeroinitializer, comdat($_ZZ4funcvE10static_var.{{[01-9a-f]+}}), align 32
+; COMDAT: @.str = internal constant { [14 x i8], [50 x i8] } { [14 x i8] c"Hello, world!\00", [50 x i8] zeroinitializer }, comdat($.str.{{[01-9a-f]+}}), align 32
 
 ; NOCOMDAT: @global = global { i32, [60 x i8] } zeroinitializer, align 32
 ; NOCOMDAT: @dyn_init_global = global { i32, [60 x i8] } zeroinitializer, align 32
 ; NOCOMDAT: @_ZZ4funcvE10static_var = internal global { i32, [60 x i8] } zeroinitializer, align 32
 ; NOCOMDAT: @.str = internal constant { [14 x i8], [50 x i8] } { [14 x i8] c"Hello, world!\00", [50 x i8] zeroinitializer }, align 32
 
 ; Check emitted location descriptions:
 ; CHECK: [[VARNAME:@___asan_gen_.[0-9]+]] = private unnamed_addr constant [7 x i8] c"global\00", align 1

llvm/test/ThinLTO/X86/devirt.ll

 ; NOENABLESPLITFLAG-DAG: [[Dm:\^[0-9]+]] = gv: (name: "_ZN1D1mEi"
 ; NOENABLESPLITFLAG-DAG: [[B:\^[0-9]+]] = gv: (name: "_ZTV1B", {{.*}} vTableFuncs: ((virtFunc: [[Bf]], offset: 16), (virtFunc: [[An]], offset: 24)), refs: ([[Bf]], [[An]])
 ; NOENABLESPLITFLAG-DAG: [[C:\^[0-9]+]] = gv: (name: "_ZTV1C", {{.*}} vTableFuncs: ((virtFunc: [[Cf]], offset: 16), (virtFunc: [[An]], offset: 24)), refs: ([[An]], [[Cf]])
 ; NOENABLESPLITFLAG-DAG: [[D:\^[0-9]+]] = gv: (name: "_ZTV1D", {{.*}} vTableFuncs: ((virtFunc: [[Dm]], offset: 16)), refs: ([[Dm]])
 ; NOENABLESPLITFLAG-DAG: typeidCompatibleVTable: (name: "_ZTS1A", summary: ((offset: 16, [[B]]), (offset: 16, [[C]])))
 ; NOENABLESPLITFLAG-DAG: typeidCompatibleVTable: (name: "_ZTS1B", summary: ((offset: 16, [[B]])))
 ; NOENABLESPLITFLAG-DAG: typeidCompatibleVTable: (name: "_ZTS1C", summary: ((offset: 16, [[C]])))
 ; Type Id on _ZTV1D should have been promoted
-; NOENABLESPLITFLAG-DAG: typeidCompatibleVTable: (name: "1${{.*}}", summary: ((offset: 16, [[D]])))
+; NOENABLESPLITFLAG-DAG: typeidCompatibleVTable: (name: "1.{{.*}}", summary: ((offset: 16, [[D]])))
 
 ; Legacy PM, Index based WPD
 ; RUN: llvm-lto2 run %t2.o -save-temps -pass-remarks=. \
 ; RUN:   -whole-program-visibility \
 ; RUN:   -o %t3 \
 ; RUN:   -r=%t2.o,test,px \
 ; RUN:   -r=%t2.o,_ZN1A1nEi,p \
 ; RUN:   -r=%t2.o,_ZN1B1fEi,p \

llvm/test/ThinLTO/X86/devirt2.ll

 ; RUN:   -r=%t2.o,_ZTV1C,px \
 ; RUN:   -r=%t2.o,_ZTV1D,px \
 ; RUN:   -r=%t2.o,_ZTV1E,px 2>&1 | FileCheck %s --check-prefix=REMARK
 ; RUN: llvm-dis %t5.1.4.opt.bc -o - | FileCheck %s --check-prefix=CHECK-IR1
 ; RUN: llvm-dis %t5.2.4.opt.bc -o - | FileCheck %s --check-prefix=CHECK-IR2
 ; RUN: llvm-nm %t5.1 | FileCheck %s --check-prefix=NM-HYBRID1
 ; RUN: llvm-nm %t5.2 | FileCheck %s --check-prefix=NM-HYBRID2
 
-; NM-HYBRID1-DAG: U _ZN1A1nEi$
-; NM-HYBRID1-DAG: U _ZN1E1mEi$
+; NM-HYBRID1-DAG: U _ZN1A1nEi.{{[0-9a-f]*}}
+; NM-HYBRID1-DAG: U _ZN1E1mEi.{{[0-9a-f]*}}
 ; NM-HYBRID1-DAG: U _ZN1D1mEi
 
-; NM-HYBRID2-DAG: T _ZN1A1nEi$
-; NM-HYBRID2-DAG: T _ZN1E1mEi$
+; NM-HYBRID2-DAG: T _ZN1A1nEi.{{[0-9a-f]*}}
+; NM-HYBRID2-DAG: T _ZN1E1mEi.{{[0-9a-f]*}}
 ; NM-HYBRID2-DAG: W _ZN1D1mEi
 ; NM-HYBRID2-DAG: T _ZN1B1fEi
 ; NM-HYBRID2-DAG: T _ZN1C1fEi
 
 ; REMARK-DAG: single-impl: devirtualized a call to _ZN1A1nEi
 ; REMARK-DAG: single-impl: devirtualized a call to _ZN1D1mEi
 ; We should devirt call to _ZN1E1mEi once in importing module and once
 ; in original (exporting) module.

llvm/test/Transforms/ThinLTOBitcodeWriter/split-internal-typeid.ll

 
 ; M0: @g = external global i8{{$}}
 ; M1: @g = global i8 42, !type !0, !type !1, !type !2
 @g = global i8 42, !type !1, !type !2, !type !4
 
 ; M0: define void @f()
 ; M1-NOT: @f()
 define void @f() {
-  ; M0: llvm.type.test{{.*}}metadata !"1$f50b51a12bb012bebbeff978335e34cf"
+  ; M0: llvm.type.test{{.*}}metadata !"1.f50b51a12bb012bebbeff978335e34cf"
   %p = call i1 @llvm.type.test(i8* null, metadata !0)
-  ; M0: llvm.type.checked.load{{.*}}metadata !"2$f50b51a12bb012bebbeff978335e34cf"
+  ; M0: llvm.type.checked.load{{.*}}metadata !"2.f50b51a12bb012bebbeff978335e34cf"
   %q = call {i8*, i1} @llvm.type.checked.load(i8* null, i32 0, metadata !3)
   ret void
 }
 
 declare i1 @llvm.type.test(i8*, metadata)
 declare {i8*, i1} @llvm.type.checked.load(i8*, i32, metadata)
 
 !0 = distinct !{}
-; M1: !0 = !{i32 0, !"1$f50b51a12bb012bebbeff978335e34cf"}
+; M1: !0 = !{i32 0, !"1.f50b51a12bb012bebbeff978335e34cf"}
 !1 = !{i32 0, !0}
-; M1: !1 = !{i32 1, !"1$f50b51a12bb012bebbeff978335e34cf"}
+; M1: !1 = !{i32 1, !"1.f50b51a12bb012bebbeff978335e34cf"}
 !2 = !{i32 1, !0}
 
 !3 = distinct !{}
-; M1: !2 = !{i32 0, !"2$f50b51a12bb012bebbeff978335e34cf"}
+; M1: !2 = !{i32 0, !"2.f50b51a12bb012bebbeff978335e34cf"}
 !4 = !{i32 0, !3}

llvm/test/Transforms/ThinLTOBitcodeWriter/split-internal1.ll

 ; RUN: opt -thinlto-bc -thinlto-split-lto-unit -o %t %s
 ; RUN: llvm-modextract -b -n 0 -o %t0 %t
 ; RUN: llvm-modextract -b -n 1 -o %t1 %t
 ; RUN: not llvm-modextract -b -n 2 -o - %t 2>&1 | FileCheck --check-prefix=ERROR %s
 ; RUN: llvm-dis -o - %t0 | FileCheck --check-prefix=M0 %s
 ; RUN: llvm-dis -o - %t1 | FileCheck --check-prefix=M1 %s
 ; RUN: llvm-bcanalyzer -dump %t0 | FileCheck --check-prefix=BCA0 %s
 ; RUN: llvm-bcanalyzer -dump %t1 | FileCheck --check-prefix=BCA1 %s
 
 ; ERROR: llvm-modextract: error: module index out of range; bitcode file contains 2 module(s)
 
 ; BCA0: <GLOBALVAL_SUMMARY_BLOCK
 ; BCA1-NOT: <GLOBALVAL_SUMMARY_BLOCK
 
-; M0: @"g$581d7631532fa146ba4061179da39272" = external hidden global i8{{$}}
-; M1: @"g$581d7631532fa146ba4061179da39272" = hidden global i8 42, !type !0
+; M0: @g.581d7631532fa146ba4061179da39272 = external hidden global i8{{$}}
+; M1: @g.581d7631532fa146ba4061179da39272 = hidden global i8 42, !type !0
 @g = internal global i8 42, !type !0
 
 ; M0: define i8* @f()
 ; M1-NOT: @f()
 define i8* @f() {
-  ; M0: ret i8* @"g$581d7631532fa146ba4061179da39272"
+  ; M0: ret i8* @g.581d7631532fa146ba4061179da39272
   ret i8* @g
 }
 
 ; M1: !0 = !{i32 0, !"typeid"}
 !0 = !{i32 0, !"typeid"}

llvm/test/Transforms/ThinLTOBitcodeWriter/split-internal2.ll

 ; RUN: opt -thinlto-bc -thinlto-split-lto-unit -o %t %s
 ; RUN: llvm-modextract -b -n 0 -o %t0 %t
 ; RUN: llvm-modextract -b -n 1 -o %t1 %t
 ; RUN: not llvm-modextract -b -n 2 -o - %t 2>&1 | FileCheck --check-prefix=ERROR %s
 ; RUN: llvm-dis -o - %t0 | FileCheck --check-prefix=M0 %s
 ; RUN: llvm-dis -o - %t1 | FileCheck --check-prefix=M1 %s
 ; RUN: llvm-bcanalyzer -dump %t0 | FileCheck --check-prefix=BCA0 %s
 ; RUN: llvm-bcanalyzer -dump %t1 | FileCheck --check-prefix=BCA1 %s
 
 ; ERROR: llvm-modextract: error: module index out of range; bitcode file contains 2 module(s)
 
 ; BCA0: <GLOBALVAL_SUMMARY_BLOCK
 ; BCA1-NOT: <GLOBALVAL_SUMMARY_BLOCK
 
 ; M0: @g = external global void ()*{{$}}
-; M1: @g = global void ()* @"f$13757e0fb71915e385efa4dc9d1e08fd", !type !0
+; M1: @g = global void ()* @f.13757e0fb71915e385efa4dc9d1e08fd, !type !0
 @g = global void ()* @f, !type !0
 
-; M0: define hidden void @"f$13757e0fb71915e385efa4dc9d1e08fd"()
-; M1: declare hidden void @"f$13757e0fb71915e385efa4dc9d1e08fd"()
+; M0: define hidden void @f.13757e0fb71915e385efa4dc9d1e08fd()
+; M1: declare hidden void @f.13757e0fb71915e385efa4dc9d1e08fd()
 define internal void @f() {
   call void @f2()
   ret void
 }
 
 ; M0: define internal void @f2()
 define internal void @f2() {
   ret void
 }
 
 ; M1: !0 = !{i32 0, !"typeid"}
 !0 = !{i32 0, !"typeid"}

llvm/test/Transforms/ThinLTOBitcodeWriter/split-vfunc-internal.ll

 ; RUN: opt -thinlto-bc -thinlto-split-lto-unit -o %t %s
 ; RUN: llvm-modextract -b -n 0 -o - %t | llvm-dis | FileCheck --check-prefix=M0 %s
 ; RUN: llvm-modextract -b -n 1 -o - %t | llvm-dis | FileCheck --check-prefix=M1 %s
 
 define [1 x i8*]* @source() {
   ret [1 x i8*]* @g
 }
 
-; M0: @"g$84f59439b469192440047efc8de357fb" = external hidden constant [1 x i8*]{{$}}
-; M1: @"g$84f59439b469192440047efc8de357fb" = hidden constant [1 x i8*] [i8* bitcast (i64 (i8*)* @"ok$84f59439b469192440047efc8de357fb" to i8*)]
+; M0: @g.84f59439b469192440047efc8de357fb = external hidden constant [1 x i8*]{{$}}
+; M1: @g.84f59439b469192440047efc8de357fb = hidden constant [1 x i8*] [i8* bitcast (i64 (i8*)* @ok.84f59439b469192440047efc8de357fb to i8*)]
 @g = internal constant [1 x i8*] [
   i8* bitcast (i64 (i8*)* @ok to i8*)
 ], !type !0
 
-; M0: define hidden i64 @"ok$84f59439b469192440047efc8de357fb"
-; M1: define available_externally hidden i64 @"ok$84f59439b469192440047efc8de357fb"
+; M0: define hidden i64 @ok.84f59439b469192440047efc8de357fb
+; M1: define available_externally hidden i64 @ok.84f59439b469192440047efc8de357fb
 define internal i64 @ok(i8* %this) {
   ret i64 42
 }
 
 !0 = !{i32 0, !"typeid"}

llvm/test/Transforms/WholeProgramDevirt/export-single-impl.ll

 ; RUN: opt -wholeprogramdevirt -whole-program-visibility -wholeprogramdevirt-summary-action=export -wholeprogramdevirt-read-summary=%S/Inputs/export.yaml -wholeprogramdevirt-write-summary=%t -S -o - %s | FileCheck %s
 ; RUN: FileCheck --check-prefix=SUMMARY %s < %t
 
 ; SUMMARY:      TypeIdMap:
 ; SUMMARY-NEXT:   typeid3:
 ; SUMMARY-NEXT:     TTRes:
 ; SUMMARY-NEXT:       Kind:            Unknown
 ; SUMMARY-NEXT:       SizeM1BitWidth:  0
 ; SUMMARY-NEXT:       AlignLog2:       0
 ; SUMMARY-NEXT:       SizeM1:          0
 ; SUMMARY-NEXT:       BitMask:         0
 ; SUMMARY-NEXT:       InlineBits:      0
 ; SUMMARY-NEXT:     WPDRes:
 ; SUMMARY-NEXT:       0:
 ; SUMMARY-NEXT:         Kind:            SingleImpl
-; SUMMARY-NEXT:         SingleImplName:  'vf3$merged'
+; SUMMARY-NEXT:         SingleImplName:  vf3.llvm.merged
 ; SUMMARY-NEXT:         ResByArg:
 ; SUMMARY-NEXT:   typeid1:
 ; SUMMARY-NEXT:     TTRes:
 ; SUMMARY-NEXT:       Kind:            Unknown
 ; SUMMARY-NEXT:       SizeM1BitWidth:  0
 ; SUMMARY-NEXT:       AlignLog2:       0
 ; SUMMARY-NEXT:       SizeM1:          0
 ; SUMMARY-NEXT:       BitMask:         0

 ; SUMMARY-NEXT:       SizeM1BitWidth:  0
 ; SUMMARY-NEXT:       AlignLog2:       0
 ; SUMMARY-NEXT:       SizeM1:          0
 ; SUMMARY-NEXT:       BitMask:         0
 ; SUMMARY-NEXT:       InlineBits:      0
 ; SUMMARY-NEXT:     WPDRes:
 ; SUMMARY-NEXT:       0:
 ; SUMMARY-NEXT:         Kind:            SingleImpl
-; SUMMARY-NEXT:         SingleImplName:  'vf4$merged'
+; SUMMARY-NEXT:         SingleImplName:  vf4.llvm.merged
 ; SUMMARY-NEXT:         ResByArg:
 ; SUMMARY-NEXT: WithGlobalValueDeadStripping: false
 ; SUMMARY-NEXT: ...
 
-; CHECK: $"vf4$merged" = comdat largest
+; CHECK: $vf4.llvm.merged = comdat largest
 $vf4 = comdat largest
 
 ; CHECK: @vt1 = constant void (i8*)* @vf1
 @vt1 = constant void (i8*)* @vf1, !type !0
 
 ; CHECK: @vt2 = constant void (i8*)* @vf2
 @vt2 = constant void (i8*)* @vf2, !type !1
 
 @vt3 = constant void (i8*)* @vf3, !type !2
 
-; CHECK: @vt4 = constant void (i8*)* @"vf4$merged", comdat($"vf4$merged")
+; CHECK: @vt4 = constant void (i8*)* @vf4.llvm.merged, comdat($vf4.llvm.merged)
 @vt4 = constant void (i8*)* @vf4, comdat($vf4), !type !3
 
 @vt5 = constant void (i8*)* @vf5, !type !4
 
 ; CHECK: declare void @vf1(i8*)
 declare void @vf1(i8*)
 
 ; CHECK: define void @vf2(i8* %0)
 define void @vf2(i8*) {
   ret void
 }
 
-; CHECK: define hidden void @"vf3$merged"(i8* %0) {
+; CHECK: define hidden void @vf3.llvm.merged(i8* %0) {
 define internal void @vf3(i8*) {
   ret void
 }
 
-; CHECK: define hidden void @"vf4$merged"(i8* %0) comdat {
+; CHECK: define hidden void @vf4.llvm.merged(i8* %0) comdat {
 define internal void @vf4(i8*) comdat {
   ret void
 }
 
 declare void @vf5(i8*)
 
 !0 = !{i32 0, !"typeid1"}
 !1 = !{i32 0, !"typeid2"}
 !2 = !{i32 0, !"typeid3"}
 !3 = !{i32 0, !"typeid4"}
 !4 = !{i32 0, !5}
 !5 = distinct !{}

llvm/tools/llvm-lto2/llvm-lto2.cpp

static int run(int argc, char **argv) {
   for (std::string F : InputFilenames) {
     std::unique_ptr<MemoryBuffer> MB = check(MemoryBuffer::getFile(F), F);
     std::unique_ptr<InputFile> Input =
         check(InputFile::create(MB->getMemBufferRef()), F);
 
     std::vector<SymbolResolution> Res;
     for (const InputFile::Symbol &Sym : Input->symbols()) {
       auto I = CommandLineResolutions.find({F, std::string(Sym.getName())});
-      // If it isn't found, look for "$", which would have been added
+      // If it isn't found, look for ".", which would have been added
       // (followed by a hash) when the symbol was promoted during module
       // splitting if it was defined in one part and used in the other.
-      // Try looking up the symbol name before the "$".
+      // Try looking up the symbol name before the suffix.
       if (I == CommandLineResolutions.end()) {
-        auto SplitName = Sym.getName().rsplit("$");
+        auto SplitName = Sym.getName().rsplit(".");
         I = CommandLineResolutions.find({F, std::string(SplitName.first)});
       }
       if (I == CommandLineResolutions.end()) {
         llvm::errs() << argv[0] << ": missing symbol resolution for " << F
                      << ',' << Sym.getName() << '\n';
         HasErrors = true;
       } else {
         Res.push_back(I->second.front());