optimize check function

compiler/check.go

@@ -0,0 +1,121 @@
+package compiler
+
+import (
+	"errors"
+	"fmt"
+
+	"tinygo.org/x/go-llvm"
+)
+
+func (c *Compiler) checkType(t llvm.Type, checked map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) {
+	if t.IsNil() {
+		panic(t)
+	}
+
+	// prevent infinite recursion for self-referential types
+	if _, ok := checked[t]; ok {
+		return
+	}
+	checked[t] = struct{}{}
+
+	// check for any context mismatches
+	switch {
+	case t.Context() == c.ctx:
+		// this is correct
+	case t.Context() == llvm.GlobalContext():
+		// somewhere we accidentally used the global context instead of a real context
+		panic(fmt.Errorf("type %q uses global context", t.String()))
+	default:
+		// we used some other context by accident
+		panic(fmt.Errorf("type %q uses context %v instead of the main context %v", t.Context(), c.ctx))
+	}
+
+	// if this is a composite type, check the components of the type
+	switch t.TypeKind() {
+	case llvm.VoidTypeKind, llvm.LabelTypeKind, llvm.TokenTypeKind, llvm.MetadataTypeKind:
+		// there should only be one of any of these
+		if s, ok := specials[t.TypeKind()]; !ok {
+			specials[t.TypeKind()] = t
+		} else if s != t {
+			panic(fmt.Errorf("duplicate special type %q: %v and %v", t.TypeKind().String(), t, s))
+		}
+	case llvm.FloatTypeKind, llvm.DoubleTypeKind, llvm.X86_FP80TypeKind, llvm.FP128TypeKind, llvm.PPC_FP128TypeKind:
+		// floating point numbers are primitives - nothing to recurse
+	case llvm.IntegerTypeKind:
+		// integers are primitives - nothing to recurse
+	case llvm.FunctionTypeKind:
+		// check arguments and return(s)
+		for _, v := range t.ParamTypes() {
+			c.checkType(v, checked, specials)
+		}
+		c.checkType(t.ReturnType(), checked, specials)
+	case llvm.StructTypeKind:
+		// check all elements
+		for _, v := range t.StructElementTypes() {
+			c.checkType(v, checked, specials)
+		}
+	case llvm.ArrayTypeKind:
+		// check element type
+		c.checkType(t.ElementType(), checked, specials)
+	case llvm.PointerTypeKind:
+		// check underlying type
+		c.checkType(t.ElementType(), checked, specials)
+	case llvm.VectorTypeKind:
+		// check element type
+		c.checkType(t.ElementType(), checked, specials)
+	}
+}
+
+func (c *Compiler) checkValue(v llvm.Value, checked map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) {
+	// check type
+	c.checkType(v.Type(), checked, specials)
+}
+
+func (c *Compiler) checkInstruction(inst llvm.Value, checked map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) {
+	// check value properties
+	c.checkValue(inst, checked, specials)
+}
+
+func (c *Compiler) checkBasicBlock(bb llvm.BasicBlock, checked map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) {
+	// check basic block value and type
+	c.checkValue(bb.AsValue(), checked, specials)
+
+	// check instructions
+	for inst := bb.FirstInstruction(); !inst.IsNil(); inst = llvm.NextInstruction(inst) {
+		c.checkInstruction(inst, checked, specials)
+	}
+}
+
+func (c *Compiler) checkFunction(fn llvm.Value, checked map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) {
+	// check function value and type
+	c.checkValue(fn, checked, specials)
+
+	// check basic blocks
+	for bb := fn.FirstBasicBlock(); !bb.IsNil(); bb = llvm.NextBasicBlock(bb) {
+		c.checkBasicBlock(bb, checked, specials)
+	}
+}
+
+func (c *Compiler) check() {
+	// check for any context mismatches
+	switch {
+	case c.mod.Context() == c.ctx:
+		// this is correct
+	case c.mod.Context() == llvm.GlobalContext():
+		// somewhere we accidentally used the global context instead of a real context
+		panic(errors.New("module uses global context"))
+	default:
+		// we used some other context by accident
+		panic(fmt.Errorf("module uses context %v instead of the main context %v", c.mod.Context(), c.ctx))
+	}
+
+	// base of type-check stack
+	checked := map[llvm.Type]struct{}{}
+	specials := map[llvm.TypeKind]llvm.Type{}
+	for fn := c.mod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
+		c.checkFunction(fn, checked, specials)
+	}
+	for g := c.mod.FirstGlobal(); !g.IsNil(); g = llvm.NextGlobal(g) {
+		c.checkValue(g, checked, specials)
+	}
+}

compiler/compiler.go

@@ -2743,7 +2743,7 @@ func (c *Compiler) ExternalInt64AsPtr() error {
 			// correct calling convention.
 			fn.SetLinkage(llvm.InternalLinkage)
 			fn.SetUnnamedAddr(true)
-			entryBlock := llvm.AddBasicBlock(externalFn, "entry")
+			entryBlock := c.ctx.AddBasicBlock(externalFn, "entry")
 			c.builder.SetInsertPointAtEnd(entryBlock)
 			var callParams []llvm.Value
 			if fnType.ReturnType() == int64Type {

compiler/defer.go

@@ -157,10 +157,10 @@ func (c *Compiler) emitRunDefers(frame *Frame) {
 	//     }
 
 	// Create loop.
-	loophead := llvm.AddBasicBlock(frame.fn.LLVMFn, "rundefers.loophead")
-	loop := llvm.AddBasicBlock(frame.fn.LLVMFn, "rundefers.loop")
-	unreachable := llvm.AddBasicBlock(frame.fn.LLVMFn, "rundefers.default")
-	end := llvm.AddBasicBlock(frame.fn.LLVMFn, "rundefers.end")
+	loophead := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "rundefers.loophead")
+	loop := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "rundefers.loop")
+	unreachable := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "rundefers.default")
+	end := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "rundefers.end")
 	c.builder.CreateBr(loophead)
 
 	// Create loop head:
@@ -192,7 +192,7 @@ func (c *Compiler) emitRunDefers(frame *Frame) {
 		// Create switch case, for example:
 		//     case 0:
 		//         // run first deferred call
-		block := llvm.AddBasicBlock(frame.fn.LLVMFn, "rundefers.callback")
+		block := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "rundefers.callback")
 		sw.AddCase(llvm.ConstInt(c.uintptrType, uint64(i), false), block)
 		c.builder.SetInsertPointAtEnd(block)
 		switch callback := callback.(type) {

compiler/func-lowering.go

@@ -234,7 +234,7 @@ func (c *Compiler) addFuncLoweringSwitch(funcID, call llvm.Value, createCall fun
 	// The block that cannot be reached with correct funcValues (to help the
 	// optimizer).
 	c.builder.SetInsertPointBefore(call)
-	defaultBlock := llvm.AddBasicBlock(call.InstructionParent().Parent(), "func.default")
+	defaultBlock := c.ctx.AddBasicBlock(call.InstructionParent().Parent(), "func.default")
 	c.builder.SetInsertPointAtEnd(defaultBlock)
 	c.builder.CreateUnreachable()
 
@@ -247,7 +247,7 @@ func (c *Compiler) addFuncLoweringSwitch(funcID, call llvm.Value, createCall fun
 	nextBlock := c.splitBasicBlock(sw, llvm.NextBasicBlock(sw.InstructionParent()), "func.next")
 
 	// The 0 case, which is actually a nil check.
-	nilBlock := llvm.InsertBasicBlock(nextBlock, "func.nil")
+	nilBlock := c.ctx.InsertBasicBlock(nextBlock, "func.nil")
 	c.builder.SetInsertPointAtEnd(nilBlock)
 	c.createRuntimeCall("nilPanic", nil, "")
 	c.builder.CreateUnreachable()
@@ -265,7 +265,7 @@ func (c *Compiler) addFuncLoweringSwitch(funcID, call llvm.Value, createCall fun
 	phiValues := make([]llvm.Value, len(functions))
 	for i, fn := range functions {
 		// Insert a switch case.
-		bb := llvm.InsertBasicBlock(nextBlock, "func.call"+strconv.Itoa(fn.id))
+		bb := c.ctx.InsertBasicBlock(nextBlock, "func.call"+strconv.Itoa(fn.id))
 		c.builder.SetInsertPointAtEnd(bb)
 		result := createCall(fn.funcPtr, callParams)
 		c.builder.CreateBr(nextBlock)

compiler/gc.go

@@ -398,10 +398,21 @@ func (c *Compiler) addGlobalsBitmap() bool {
 	for i, b := range bitmapBytes {
 		bitmapValues[len(bitmapBytes)-i-1] = llvm.ConstInt(c.ctx.Int8Type(), uint64(b), false)
 	}
-	bitmapArray := llvm.ConstArray(llvm.ArrayType(c.ctx.Int8Type(), len(bitmapBytes)), bitmapValues)
+	bitmapArray := llvm.ConstArray(c.ctx.Int8Type(), bitmapValues)
 	bitmapNew := llvm.AddGlobal(c.mod, bitmapArray.Type(), "runtime.trackedGlobalsBitmap.tmp")
 	bitmapOld := c.mod.NamedGlobal("runtime.trackedGlobalsBitmap")
-	bitmapOld.ReplaceAllUsesWith(bitmapNew)
+	for _, inst := range getUses(bitmapOld) {
+		c.builder.SetInsertPointBefore(inst)
+		bc := c.builder.CreateBitCast(bitmapNew, bitmapOld.Type(), "runtime.trackedGlobalsBitmap.cast")
+		for i := 0; i < inst.OperandsCount(); i++ {
+			if inst.Operand(i) == bitmapOld {
+				inst.SetOperand(i, bc)
+			}
+		}
+	}
+	if len(getUses(bitmapOld)) > 0 {
+		panic("failed to eliminate tracked globals bitmap representation")
+	}
 	bitmapNew.SetInitializer(bitmapArray)
 	bitmapNew.SetName("runtime.trackedGlobalsBitmap")
 

compiler/goroutine.go

@@ -57,7 +57,7 @@ func (c *Compiler) createGoroutineStartWrapper(fn llvm.Value) llvm.Value {
 		name := fn.Name()
 		wrapper = c.mod.NamedFunction(name + "$gowrapper")
 		if !wrapper.IsNil() {
-			return c.builder.CreateIntToPtr(wrapper, c.uintptrType, "")
+			return c.builder.CreatePtrToInt(wrapper, c.uintptrType, "")
 		}
 
 		// Save the current position in the IR builder.
@@ -69,7 +69,7 @@ func (c *Compiler) createGoroutineStartWrapper(fn llvm.Value) llvm.Value {
 		wrapper = llvm.AddFunction(c.mod, name+"$gowrapper", wrapperType)
 		wrapper.SetLinkage(llvm.PrivateLinkage)
 		wrapper.SetUnnamedAddr(true)
-		entry := llvm.AddBasicBlock(wrapper, "entry")
+		entry := c.ctx.AddBasicBlock(wrapper, "entry")
 		c.builder.SetInsertPointAtEnd(entry)
 
 		// Create the list of params for the call.
@@ -107,7 +107,7 @@ func (c *Compiler) createGoroutineStartWrapper(fn llvm.Value) llvm.Value {
 		wrapper = llvm.AddFunction(c.mod, ".gowrapper", wrapperType)
 		wrapper.SetLinkage(llvm.InternalLinkage)
 		wrapper.SetUnnamedAddr(true)
-		entry := llvm.AddBasicBlock(wrapper, "entry")
+		entry := c.ctx.AddBasicBlock(wrapper, "entry")
 		c.builder.SetInsertPointAtEnd(entry)
 
 		// Get the list of parameters, with the extra parameters at the end.

compiler/interface-lowering.go

@@ -603,9 +603,9 @@ func (p *lowerInterfacesPass) createInterfaceImplementsFunc(itf *interfaceInfo)
 	// TODO: debug info
 
 	// Create all used basic blocks.
-	entry := llvm.AddBasicBlock(fn, "entry")
-	thenBlock := llvm.AddBasicBlock(fn, "then")
-	elseBlock := llvm.AddBasicBlock(fn, "else")
+	entry := p.ctx.AddBasicBlock(fn, "entry")
+	thenBlock := p.ctx.AddBasicBlock(fn, "then")
+	elseBlock := p.ctx.AddBasicBlock(fn, "else")
 
 	// Add all possible types as cases.
 	p.builder.SetInsertPointAtEnd(entry)
@@ -661,11 +661,11 @@ func (p *lowerInterfacesPass) createInterfaceMethodFunc(itf *interfaceInfo, sign
 	// TODO: debug info
 
 	// Create entry block.
-	entry := llvm.AddBasicBlock(fn, "entry")
+	entry := p.ctx.AddBasicBlock(fn, "entry")
 
 	// Create default block and make it unreachable (which it is, because all
 	// possible types are checked).
-	defaultBlock := llvm.AddBasicBlock(fn, "default")
+	defaultBlock := p.ctx.AddBasicBlock(fn, "default")
 	p.builder.SetInsertPointAtEnd(defaultBlock)
 	p.builder.CreateUnreachable()
 
@@ -684,7 +684,7 @@ func (p *lowerInterfacesPass) createInterfaceMethodFunc(itf *interfaceInfo, sign
 
 	// Define all possible functions that can be called.
 	for _, typ := range itf.types {
-		bb := llvm.AddBasicBlock(fn, typ.name)
+		bb := p.ctx.AddBasicBlock(fn, typ.name)
 		sw.AddCase(llvm.ConstInt(p.uintptrType, typ.num, false), bb)
 
 		// The function we will redirect to when the interface has this type.

compiler/interface.go

@@ -110,12 +110,12 @@ func (c *Compiler) makeStructTypeFields(typ *types.Struct) llvm.Value {
 		fieldGlobalValue = llvm.ConstInsertValue(fieldGlobalValue, fieldName, []uint32{1})
 		if typ.Tag(i) != "" {
 			fieldTag := c.makeGlobalArray([]byte(typ.Tag(i)), "reflect/types.structFieldTag", c.ctx.Int8Type())
+			fieldTag.SetLinkage(llvm.PrivateLinkage)
+			fieldTag.SetUnnamedAddr(true)
 			fieldTag = llvm.ConstGEP(fieldTag, []llvm.Value{
 				llvm.ConstInt(llvm.Int32Type(), 0, false),
 				llvm.ConstInt(llvm.Int32Type(), 0, false),
 			})
-			fieldTag.SetLinkage(llvm.PrivateLinkage)
-			fieldTag.SetUnnamedAddr(true)
 			fieldGlobalValue = llvm.ConstInsertValue(fieldGlobalValue, fieldTag, []uint32{2})
 		}
 		if typ.Field(i).Embedded() {

compiler/optimizer.go

@@ -22,6 +22,12 @@ func (c *Compiler) Optimize(optLevel, sizeLevel int, inlinerThreshold uint) erro
 		c.replacePanicsWithTrap() // -panic=trap
 	}
 
+	// run a check of all of our code
+	c.check()
+	if err := c.Verify(); err != nil {
+		return errors.New("verification failure before optimizations")
+	}
+
 	// Run function passes for each function.
 	funcPasses := llvm.NewFunctionPassManagerForModule(c.mod)
 	defer funcPasses.Dispose()

compiler/syscall.go

@@ -165,7 +165,7 @@ func (c *Compiler) emitSyscall(frame *Frame, call *ssa.CallCommon) (llvm.Value,
 		inrange2 := c.builder.CreateICmp(llvm.IntSGT, syscallResult, llvm.ConstInt(c.uintptrType, 0xfffffffffffff000, true), "") // -4096
 		hasError := c.builder.CreateAnd(inrange1, inrange2, "")
 		errResult := c.builder.CreateSelect(hasError, c.builder.CreateSub(zero, syscallResult, ""), zero, "syscallError")
-		retval := llvm.Undef(llvm.StructType([]llvm.Type{c.uintptrType, c.uintptrType, c.uintptrType}, false))
+		retval := llvm.Undef(c.ctx.StructType([]llvm.Type{c.uintptrType, c.uintptrType, c.uintptrType}, false))
 		retval = c.builder.CreateInsertValue(retval, syscallResult, 0, "")
 		retval = c.builder.CreateInsertValue(retval, zero, 1, "")
 		retval = c.builder.CreateInsertValue(retval, errResult, 2, "")
@@ -181,7 +181,7 @@ func (c *Compiler) emitSyscall(frame *Frame, call *ssa.CallCommon) (llvm.Value,
 		zero := llvm.ConstInt(c.uintptrType, 0, false)
 		hasError := c.builder.CreateICmp(llvm.IntNE, syscallResult, llvm.ConstInt(c.uintptrType, 0, false), "")
 		errResult := c.builder.CreateSelect(hasError, syscallResult, zero, "syscallError")
-		retval := llvm.Undef(llvm.StructType([]llvm.Type{c.uintptrType, c.uintptrType, c.uintptrType}, false))
+		retval := llvm.Undef(c.ctx.StructType([]llvm.Type{c.uintptrType, c.uintptrType, c.uintptrType}, false))
 		retval = c.builder.CreateInsertValue(retval, syscallResult, 0, "")
 		retval = c.builder.CreateInsertValue(retval, zero, 1, "")
 		retval = c.builder.CreateInsertValue(retval, errResult, 2, "")