Thanks for the report. This is unfortunate. I guess we could restore the eqtype function on AIX.

Is there some linker magic to make it merge the symbols?

I agree that forcing -lgo doesn't seem nice. In theory there could be Go shared objects other than libgo itself, so forcing -lgo isn't a complete solution.

Not that I'm aware of...
By the way, is there any other kind of symbols which can be common between object files and shared objects and which should be merged ? I'm only aware of type descriptors for now.

There are some symbols that are nice to be merged, like compiler-generated wrapper functions, but the merging is not required for correctness, as we don't compare addresses of them. Type descriptors are probably the only one.

Change https://golang.org/cl/235697 mentions this issue: runtime: revert eqtype for AIX

I've discovered that there is another place where runtime.eqtype needs to be called. This happens when a type switch is checking for a "basic" types like string or int. Once again, for AIX even for "basic" types the type pointer is different. The statement to change is at https://github.com/golang/gofrontend/blob/master/go/statements.cc#L4669. But as there is no Gogo, I don't know how to check for Gogo->need_eqtype()

It can be reproduced with

package main

func do(i interface{}) bool {
	switch i.(type) {
	case string:
		return true
	case int:
		return true
	}
	return false
}

func main() {
	src := []byte("ab")
	do(src)

}

The current gimple representation for case string: is

        GOTMP.0 = i;
        GOTMP.1 = GOTMP.0.__type_descriptor;
        if (GOTMP.1 != &string..d) goto <D.1902>; else goto <D.1903>;
        <D.1902>:
        {
          goto <D.1619>;
        }
        <D.1903>:
        {
          {
            $ret0 = 1;
            D.1904 = $ret0;
            return D.1904;
          }
        }
        goto <D.1620>;
        <D.1619>:

It should be something like

        GOTMP.0 = i;
        GOTMP.1 = runtime.eqtype (&string..d, GOTMP.0.__type_descriptor);
        if (GOTMP.1 != &string..d) goto <D.1902>; else goto <D.1903>;
        <D.1902>:
        {
          goto <D.1619>;
        }
        <D.1903>:
        {
          {
            $ret0 = 1;
            D.1904 = $ret0;
            return D.1904;
          }
        }
        goto <D.1620>;
        <D.1619>:

Ps: The issue is already closed but that the exact same bug, thus I comment there. Tell me if I need to open another issue.

You can pass in the Gogo* from the only caller in Type_switch_statement::do_lower. You'll have to pass it through Type_case_clauses::lower.

Change https://golang.org/cl/255202 mentions this issue: compiler: call runtime.eqtype for non-interface type switch on aix

I've checked quickly, but it doesn't seem to have anywhere else in the compiler that need to call runtime.eqtype.

However, reflect and internal/reflectlite also have the same problem. In implements, the methods' type are checked (https://github.com/golang/gofrontend/blob/master/libgo/go/internal/reflectlite/type.go#L542 and https://github.com/golang/gofrontend/blob/master/libgo/go/internal/reflectlite/type.go#L559) and the last assertion toType(vm.mtyp).common() == toType(tm.typ).common() will also fail depending on where the type pointers are taken from.

As a workaround, I've changed this assertion to use the hash parameter toType(vm.mtyp).common().hash == toType(tm.typ).common().hash, it's not 100% accurate but I guess it works in almost all cases. Still, that's a workaround any idea if it could be fixed easily ?

You should be able to compare toType(vm.mtyp).String() == toType(tm.typ).String(), as runtime.eqtype does. But we should have an AIX and a non-AIX version.

Using String() seems to work. However, I still have some issues with it.

First, how the equality operation is made between strings ? Because if I remember correctly, some constant strings can be associated to a Read-Only symbol (or at least an address in RO sections). Thus, checking that two pointers are equal would be faster that checking if the whole strings are equal. If it's indeed how it's performed, we would have the same problem than with types, these symbols won't be merged.

Moreover, I was able to fix type equalities in reflect and reflectlite. But what about stuff like https://github.com/golang/gofrontend/blob/master/libgo/go/internal/unsafeheader/unsafeheader_test.go#L61 ? Equality checks made on reflect.Type will fail, if it's targeting a type from the libgo and a type from somewhere else. I don't know if such things happens a lot in practice outside libgo tests. Adding a special case in the compiler for equality operations between reflect.Type for AIX might be a solution but I don't if it's possible or even the right thing to do.

Edit: Actually, the previous example is failing because the two iface are also two different pointers. Thus, https://github.com/golang/gofrontend/blob/master/libgo/go/runtime/alg.go#L315 will be false. Maybe the problem is similar with iface/eface/etc...

I don't think there is a problem with strings. For strings we never assume that if the pointers are not equal that the strings are not equal. The library assumes that types are canonicalized (there is only instance of a given type) but that is not true for strings (there can be multiple instances of a particular string).

In the reflect package, we used to have a canonicalization map that ensured that when the program sees a reflect.Type, it always sees a canonical version. That ensures that program comparisons of reflect.Type values do the right thing. That canonicalization map was removed in https://golang.org/cl/179598. Perhaps we need to bring it back for AIX.

(This of course assumes that there is only a single version of the canonicalization map in the program, which for AIX may mean that there is only a single version of the reflect package in the program. I don't know how AIX handles that kind of thing when shared libraries are involved.)

No, it won't happen. Only the reflect tests might be a bit problematic as gotests is duplicating it. I'll check that anywya.

Change https://golang.org/cl/260158 mentions this issue: reflect: ensure uniqueness of type descriptors on AIX.