[llgo] Use the object's package to mangle method names, rather than the receiver's package

[pcc]

Summary

If we use the receiver's package, we can end up with identical manglings
for different functions. Consider:

package p
type U struct{}
func (U) f()

package q
import "p"
type T struct { p.U }
func (T) f()

The method set of *T has two synthetic methods named (*T).f(); one forwards to
(T).f(), and the other to (U).f(). Previously, we were distinguishing them
by the receiver's package, and in this case because both methods have the
same receiver, they received the same name.

The methods are correctly distinguished by the package owning the identifier
"f", which is available via f.Object().Pkg().

[axw]

LGTM.

irgen/typemap.go

if f.Parent() != nil {
     // Anonymous functions are not guaranteed to
     // have unique identifiers at the global scope.
     b.WriteString(ctx.mangleFunctionName(f.Parent()))
     b.WriteRune(':')
     b.WriteString(f.String())
     return b.String()
   }
 
-  pkg := f.Pkg
-  var pkgobj *types.Package
-  if pkg != nil {
-    pkgobj = pkg.Object
-  } else if f.Signature.Recv() != nil {
-    pkgobj = f.Signature.Recv().Pkg()
-  } else {
+  // Synthetic bound and thunk functions are special cases; they can only be
+  // distinguished using private data that is only exposed via String().
+  if strings.HasSuffix(f.Name(), "$bound") || strings.HasSuffix(f.Name(), "$thunk") {
     b.WriteString(f.String())
     return b.String()
   }
 
+  var pkg *types.Package
+  if f.Pkg != nil {
+    pkg = f.Pkg.Object
+  } else if !f.Object().Exported() {
+    pkg = f.Object().Pkg()
+  }
+
   if pkg != nil {
-    ctx.manglePackagePath(pkgobj.Path(), &b)
+    ctx.manglePackagePath(pkg.Path(), &b)
     b.WriteRune('.')
   }
+
   if f.Signature.Recv() == nil && f.Name() == "init" {
     b.WriteString(".import")
   } else {
     b.WriteString(f.Name())
   }
   if f.Signature.Recv() != nil {
     b.WriteRune('.')
     ctx.mangleType(f.Signature.Recv().Type(), &b)

test/irgen/Inputs/mangling-synthetic-p.go

+package p
+
+type U struct{}
+func (U) f()

test/irgen/mangling-dot.go

 // RUN: llgo -fgo-pkgpath=llvm.org/llvm -S -emit-llvm -o - %s | FileCheck %s
 
 package llvm
 
 // CHECK: @llvm_org_llvm.F
 func F() {
 }

test/irgen/mangling-synthetic.go

+// RUN: llgo -fgo-pkgpath=p -c -o %T/p.o %S/Inputs/mangling-synthetic-p.go
+// RUN: llgo -fgo-pkgpath=q -I %T -S -emit-llvm -o - %s | FileCheck %s
+
+package q
+
+import "p"
+
+// CHECK-DAG: define linkonce_odr void @p.f.N3_q.T(i8*)
+// CHECK-DAG: define linkonce_odr void @p.f.pN3_q.T(i8*)
+type T struct { p.U }
+
+// CHECK-DAG: declare void @q.f.N3_q.T(i8*)
+// CHECK-DAG: define linkonce_odr void @q.f.pN3_q.T(i8*)
+func (T) f()