tree 22af8b980714d46c9dec63788301729508daab68
parent 5dad908948f710852177feda3da356166ac24f25
author Cherry Zhang <cherryyz@google.com> 1542923569 -0500
committer Cherry Zhang <cherryyz@google.com> 1544212232 +0000

gollvm: use non-integral pointers for GC

When the GC support is enabled, the statepoint insertion pass
needs to analyze the function IR and finds all the live
pointers. It is important to preserve the pointerness in the
optimization passes.

LLVM provides a mechanism, non-integral pointers, which prevents
the optimizer to rewrite pointer operations to integer
operations. We make use of this in CL.

In LLVM, non-integral pointers are pointers in non-integral
address spaces. The default address space 0 cannot be non-
integral, so we use address space 1.

There are some trickiness around the address spaces in LLVM.
For example, although stacks (allocas) are technically allowed
to be in non-zero address space, things fall apart in various
places in the backend. Therefore, currently we use the following
design:

- All Go pointer types are in address space 1.
- Heap pointers are in address space 1.
- Global variables are in address space 1, so the addresses of
  globals are non-integral pointers and can be assigned to
  pointer variables.
- Stacks (allocas) are in address space 0. For each stack
  variable, we create an alloca in address space 0, immediately
  cast to address space 1, using this value as the variable's
  address. This way, we can assign a stack variable's address to
  pointer variables.
- Program text is also in address space 0. When we take the
  address of function code, we cast it to address space 1, so it
  is assignable to pointer variables. We don't need address space
  casts in direct calls.

In LLVM it is illegal to cast non-integral pointers to/from
integers. However, Go supports pointer<->integer casts. These
casts are handled with address space 0 as an intermediate, i.e.

addrspace(1) pointer <-> addrspace(0) pointer <-> integer

It seems that LLVM code generator does not handle addrspacecast
in static initializers. So we add a IR pass that runs after the
statepoint insertion pass, removes addrspacecast in static
initializers. At that point we don't need non-integral pointers
anymore, so we remove the non-integral constraint there, which
makes the code generator happy.

Change-Id: I26e0cff874e1dfdfbccd89fc7d3c7c190fbae057
Reviewed-on: https://go-review.googlesource.com/c/152001
Reviewed-by: Than McIntosh <thanm@google.com>