Keeping up with the Gophers

A brief history of gccgo, improvements, and the future

gccgo: "The Other Go Compiler"

• Written and maintained by Ian Lance Taylor (released November 2009)

2010-01-26  Ian Lance Taylor  <iant@google.com>

        * MAINTAINERS: Add myself as Go frontend maintainer.

• Compiler frontend for the Go language written in C++

gccgo: The Go Team didn't know

"Ian just showed up at our door with a fully working compiler" ~ probably Rob

Why write a Go compiler in C++?

rationale: architecture support

• cmd/gc (2009) targets 4 major architectures: i386, amd64, ARM, and IBM POWER
• gcc (4.3, 2009) targets 45 architectures officially, 28 unofficially
• leveraging gcc => minimal work to support Go on existing architectures

rationale: code generation

• gcc has ~30 years of work put into code analysis and optimization
• cmd/gc has only recently focused on code generation (khr's SSA work)
• leveraging gcc => minimal work to produce optimized binaries

rationale: technical honesty

• "Keeping each other honest"
• Distinct implementations => Inconsistencies in specification and implementations
• Users have options when an implementation lacks features
• Compilers seek feature parity => Compilers learn from each other
• Compilers generate better binaries => Virtuous cycle

gccgo improvements through a telescope

gofrontend: no dependency on gcc

• gcc implements gofrontend's backend interface

gofrontend (gcc/go/gofrontend/expressions.cc)

-  tree val_type_tree = type_to_tree(this->type()->get_backend(gogo));
-  go_assert(val_type_tree != error_mark_node);
-  return build_int_cstu(val_type_tree, val);
+  mpz_t cst;
+  mpz_init_set_ui(cst, val);
+  Btype* int_btype = this->type()->get_backend(gogo);
+  return gogo->backend()->integer_constant_expression(int_btype, cst);

backend (gcc/go/go-gcc.cc)

Bexpression*
Gcc_backend::integer_constant_expression(Btype* btype, mpz_t val)
{
  tree t = btype->get_tree();
  tree ret = double_int_to_tree(t, mpz_get_double_int(t, val, true));
  return this->make_expression(ret);
}

gccgo: builds the `go` tool

• One way to build code across multiple compilers

$ cat hello.go
package main

import "fmt"

func main() {
     fmt.Println("Hello World!")
}

$ go run -gccgoflags="-fgo-optimize-allocs" hello.go
Hello World!

$ go version
go version go1.4.2 gccgo (GCC) 6.0.0 20150714 (experimental) linux/amd64

gofrontend: basic escape analysis

• Implementation of Escape analysis for Java by JD Choi

escape.go

package main

var global *int

func f(i *int) { global = i }

func main() {
    a := new(int)
    f(a)
}

Connection Graph

Keeping up

gccgo: runtime and garbage collector parity

• gccgo runtime is a modified version of Go 1.3 runtime
• Go 1.4 runtime was rewritten in Go
• Go 1.4 changed GC type info

beyond gccgo: compiler stack maps

• Stack map records locations of live values at a certain address
• Allows Garbage Collector to be precise about types on stack
• Enables contiguous stacks to readjust copied pointers
• Little support in C compilers: gcc has no support, LLVM support is WIP

llvmgo: another "other Go compiler"

• gofrontend provides backend interface LLVM can implement
• LLVM byte code is trusted in secure environments such as PNaCl
• Run native Go in the web

OS support: OSX and Windows

• gccgo support on not unixes
• Expert needed

Thank you