builder: try to determine stack size information at compile time

For now, this is just an extra flag that can be used to print stack
frame information, but this is intended to provide a way to determine
stack sizes for goroutines at compile time in many cases.

Stack sizes are often somewhere around 350 bytes so are in fact not all
that big usually. Once this can be determined at compile time in many
cases, it is possible to use this information when available and as a
result increase the fallback stack size if the size cannot be determined
at compile time. This should reduce stack overflows while at the same
time reducing RAM consumption in many cases.

Interesting output for testdata/channel.go:

    function                                 stack usage (in bytes)
    Reset_Handler                            332
    .Lcommand-line-arguments.fastreceiver    220
    .Lcommand-line-arguments.fastsender      192
    .Lcommand-line-arguments.iterator        192
    .Lcommand-line-arguments.main$1          184
    .Lcommand-line-arguments.main$2          200
    .Lcommand-line-arguments.main$3          200
    .Lcommand-line-arguments.main$4          328
    .Lcommand-line-arguments.receive         176
    .Lcommand-line-arguments.selectDeadlock  72
    .Lcommand-line-arguments.selectNoOp      72
    .Lcommand-line-arguments.send            184
    .Lcommand-line-arguments.sendComplex     192
    .Lcommand-line-arguments.sender          192
    .Lruntime.run$1                          548

This shows that the stack size (if these numbers are correct) can in
fact be determined automatically in many cases, especially for small
goroutines. One of the great things about Go is lightweight goroutines,
and reducing stack sizes is very important to make goroutines
lightweight on microcontrollers.

Author: aykevl

builder/build.go

@@ -4,18 +4,21 @@
 package builder
 
 import (
+	"debug/elf"
 	"errors"
 	"fmt"
 	"io/ioutil"
 	"os"
 	"path/filepath"
+	"sort"
 	"strconv"
 	"strings"
 
 	"github.com/tinygo-org/tinygo/compileopts"
 	"github.com/tinygo-org/tinygo/compiler"
 	"github.com/tinygo-org/tinygo/goenv"
 	"github.com/tinygo-org/tinygo/interp"
+	"github.com/tinygo-org/tinygo/stacksize"
 	"github.com/tinygo-org/tinygo/transform"
 	"tinygo.org/x/go-llvm"
 )
@@ -216,6 +219,11 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(stri
 			}
 		}
 
+		// Print goroutine stack sizes, as far as possible.
+		if config.Options.PrintStacks {
+			printStacks(mod, executable)
+		}
+
 		// Get an Intel .hex file or .bin file from the .elf file.
 		if outext == ".hex" || outext == ".bin" || outext == ".gba" {
 			tmppath = filepath.Join(dir, "main"+outext)
@@ -234,3 +242,89 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(stri
 		return action(tmppath)
 	}
 }
+
+// printStacks prints the maximum stack depth for functions that are started as
+// goroutines. Stack sizes cannot always be determined statically, in particular
+// recursive functions and functions that call interface methods or function
+// pointers may have an unknown stack depth (depending on what the optimizer
+// manages to optimize away).
+//
+// It might print something like the following:
+//
+//     function                         stack usage (in bytes)
+//     Reset_Handler                    316
+//     .Lexamples/blinky2.led1          92
+//     .Lruntime.run$1                  300
+func printStacks(mod llvm.Module, executable string) {
+	// Determine which functions call a function pointer.
+	var callsIndirectFunction []string
+	for fn := mod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
+		for bb := fn.FirstBasicBlock(); !bb.IsNil(); bb = llvm.NextBasicBlock(bb) {
+			for inst := bb.FirstInstruction(); !inst.IsNil(); inst = llvm.NextInstruction(inst) {
+				if inst.IsACallInst().IsNil() {
+					continue
+				}
+				if callee := inst.CalledValue(); callee.IsAFunction().IsNil() && callee.IsAInlineAsm().IsNil() {
+					callsIndirectFunction = append(callsIndirectFunction, fn.Name())
+				}
+			}
+		}
+	}
+
+	// Load the ELF binary.
+	f, err := elf.Open(executable)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "could not load executable for stack size analysis:", err)
+		return
+	}
+	defer f.Close()
+
+	// Determine the frame size of each function (if available) and the callgraph.
+	functions, err := stacksize.CallGraph(f, callsIndirectFunction)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "could not parse executable for stack size analysis:", err)
+		return
+	}
+
+	// Get a list of "go wrappers", small wrapper functions that decode
+	// parameters when starting a new goroutine.
+	var gowrappers []string
+	for name := range functions {
+		if strings.HasSuffix(name, "$gowrapper") {
+			gowrappers = append(gowrappers, name)
+		}
+	}
+	sort.Strings(gowrappers)
+
+	switch f.Machine {
+	case elf.EM_ARM:
+		// Add the reset handler, which runs startup code and is the
+		// interrupt/scheduler stack with -scheduler=tasks.
+		// Note that because interrupts happen on this stack, the stack needed
+		// by just the Reset_Handler is not enough. Stacks needed by interrupt
+		// handlers should also be taken into account.
+		gowrappers = append([]string{"Reset_Handler"}, gowrappers...)
+	}
+
+	// Print the sizes of all stacks.
+	fmt.Printf("%-32s %s\n", "function", "stack usage (in bytes)")
+	for _, name := range gowrappers {
+		for _, fn := range functions[name] {
+			stackSize, stackSizeType, missingStackSize := fn.StackSize()
+			strippedName := name
+			if strings.HasSuffix(name, "$gowrapper") {
+				strippedName = name[:len(name)-len("$gowrapper")]
+			}
+			switch stackSizeType {
+			case stacksize.Bounded:
+				fmt.Printf("%-32s %d\n", strippedName, stackSize)
+			case stacksize.Unknown:
+				fmt.Printf("%-32s unknown, %s does not have stack frame information\n", strippedName, missingStackSize)
+			case stacksize.Recursive:
+				fmt.Printf("%-32s recursive, %s may call itself\n", strippedName, missingStackSize)
+			case stacksize.IndirectCall:
+				fmt.Printf("%-32s unknown, %s calls a function pointer\n", strippedName, missingStackSize)
+			}
+		}
+	}
+}

compileopts/options.go

@@ -25,6 +25,7 @@ type Options struct {
 	VerifyIR      bool
 	Debug         bool
 	PrintSizes    string
+	PrintStacks   bool
 	CFlags        []string
 	LDFlags       []string
 	Tags          string

main.go

@@ -796,6 +796,7 @@ func main() {
 	tags := flag.String("tags", "", "a space-separated list of extra build tags")
 	target := flag.String("target", "", "LLVM target | .json file with TargetSpec")
 	printSize := flag.String("size", "", "print sizes (none, short, full)")
+	printStacks := flag.Bool("print-stacks", false, "print stack sizes of goroutines")
 	nodebug := flag.Bool("no-debug", false, "disable DWARF debug symbol generation")
 	ocdOutput := flag.Bool("ocd-output", false, "print OCD daemon output during debug")
 	port := flag.String("port", "", "flash port")
@@ -835,6 +836,7 @@ func main() {
 		VerifyIR:      *verifyIR,
 		Debug:         !*nodebug,
 		PrintSizes:    *printSize,
+		PrintStacks:   *printStacks,
 		Tags:          *tags,
 		WasmAbi:       *wasmAbi,
 		Programmer:    *programmer,

src/device/arm/cortexm.s

@@ -19,6 +19,7 @@ HardFault_Handler:
 
     // Continue handling this error in Go.
     bl handleHardFault
+.size HardFault_Handler, .-HardFault_Handler
 
 // This is a convenience function for semihosting support.
 // At some point, this should be replaced by inline assembly.

src/runtime/scheduler_cortexm.S

@@ -18,6 +18,7 @@ tinygo_startTask:
 
     // After return, exit this goroutine. This is a tail call.
     bl    	tinygo_pause
+.size tinygo_startTask, .-tinygo_startTask
 
 .section .text.tinygo_getSystemStackPointer
 .global  tinygo_getSystemStackPointer
@@ -44,6 +45,7 @@ tinygo_switchToScheduler:
     str r1, [r0]
 
     b tinygo_swapTask
+.size tinygo_switchToScheduler, .-tinygo_switchToScheduler
 
 .global  tinygo_switchToTask
 .type    tinygo_switchToTask, %function
@@ -56,6 +58,7 @@ tinygo_switchToTask:
 
     // Continue executing in the swapTask function, which swaps the stack
     // pointer.
+.size tinygo_switchToTask, .-tinygo_switchToTask
 
 .global  tinygo_swapTask
 .type    tinygo_swapTask, %function
@@ -111,6 +114,7 @@ tinygo_swapTask:
     mov r11, r3
     pop {pc}
     #endif
+.size tinygo_swapTask, .-tinygo_swapTask
 
 .section .text.tinygo_scanCurrentStack
 .global  tinygo_scanCurrentStack
@@ -135,3 +139,4 @@ tinygo_scanCurrentStack:
     // Restore stack state and return.
     add sp, #32
     pop {pc}
+.size tinygo_scanCurrentStack, .-tinygo_scanCurrentStack