compiler: lower interfaces in a separate pass

This commit changes many things:

  * Most interface-related operations are moved into an optimization
    pass for more modularity. IR construction creates pseudo-calls which
    are lowered in this pass.
  * Type codes are assigned in this interface lowering pass, after DCE.
  * Type codes are sorted by usage: types more often used in type
    asserts are assigned lower numbers to ease jump table construction
    during machine code generation.
  * Interface assertions are optimized: they are replaced by constant
    false, comparison against a constant, or a typeswitch with only
    concrete types in the general case.
  * Interface calls are replaced with unreachable, direct calls, or a
    concrete type switch with direct calls depending on the number of
    implementing types. This hopefully makes some interface patterns
    zero-cost.

These changes lead to a ~0.5K reduction in code size on Cortex-M for
testdata/interface.go. It appears that a major cause for this is the
replacement of function pointers with direct calls, which are far more
susceptible to optimization. Also, not having a fixed global array of
function pointers greatly helps dead code elimination.

This change also makes future optimizations easier, like optimizations
on interface value comparisons.

compiler/optimizer.go

@@ -1,12 +1,14 @@
 package compiler
 
 import (
+	"errors"
+
 	"github.com/aykevl/go-llvm"
 )
 
 // Run the LLVM optimizer over the module.
 // The inliner can be disabled (if necessary) by passing 0 to the inlinerThreshold.
-func (c *Compiler) Optimize(optLevel, sizeLevel int, inlinerThreshold uint) {
+func (c *Compiler) Optimize(optLevel, sizeLevel int, inlinerThreshold uint) error {
 	builder := llvm.NewPassManagerBuilder()
 	defer builder.Dispose()
 	builder.SetOptLevel(optLevel)
@@ -40,7 +42,13 @@ func (c *Compiler) Optimize(optLevel, sizeLevel int, inlinerThreshold uint) {
 		c.OptimizeMaps()
 		c.OptimizeStringToBytes()
 		c.OptimizeAllocs()
-		c.Verify()
+		c.LowerInterfaces()
+	} else {
+		// Must be run at any optimization level.
+		c.LowerInterfaces()
+	}
+	if err := c.Verify(); err != nil {
+		return errors.New("optimizations caused a verification failure")
 	}
 
 	// Run module passes.
@@ -48,6 +56,8 @@ func (c *Compiler) Optimize(optLevel, sizeLevel int, inlinerThreshold uint) {
 	defer modPasses.Dispose()
 	builder.Populate(modPasses)
 	modPasses.Run(c.mod)
+
+	return nil
 }
 
 // Eliminate created but not used maps.
@@ -299,6 +309,9 @@ func (c *Compiler) hasFlag(call, param llvm.Value, kind string) bool {
 // Return a list of values (actually, instructions) where this value is used as
 // an operand.
 func getUses(value llvm.Value) []llvm.Value {
+	if value.IsNil() {
+		return nil
+	}
 	var uses []llvm.Value
 	use := value.FirstUse()
 	for !use.IsNil() {