main: remove -no-debug flag

The -no-debug flag controls whether to emit DWARF debug information.
However, instead of limiting debug information altogether, I think it's
better to strip it off at the end if it isn't needed. For several
reasons:

  * Some parts of the compiler now rely on the presence of debug
    information for proper diagnostics.
  * It works better with the cache: there is no distinction between
    debug and no-debug builds.
  * It makes it easier (or possible at all) to enable debug information
    in the wasi-libc library without big downsides.

I'm doing this in a separate commit so this can be reverted if needed.

builder/build.go

@@ -100,7 +100,6 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		AutomaticStackSize: config.AutomaticStackSize(),
 		DefaultStackSize:   config.Target.DefaultStackSize,
 		NeedsStackObjects:  config.NeedsStackObjects(),
-		Debug:              config.Debug(),
 		LLVMFeatures:       config.LLVMFeatures(),
 	}
 
@@ -470,10 +469,33 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		linkerDependencies = append(linkerDependencies, job)
 	}
 
+	// Add libc dependency if needed.
+	root := goenv.Get("TINYGOROOT")
+	switch config.Target.Libc {
+	case "picolibc":
+		job, err := Picolibc.load(config.Triple(), config.CPU(), dir)
+		if err != nil {
+			return err
+		}
+		// The library needs to be compiled (cache miss).
+		jobs = append(jobs, job.dependencies...)
+		jobs = append(jobs, job)
+		linkerDependencies = append(linkerDependencies, job)
+	case "wasi-libc":
+		path := filepath.Join(root, "lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a")
+		if _, err := os.Stat(path); os.IsNotExist(err) {
+			return errors.New("could not find wasi-libc, perhaps you need to run `make wasi-libc`?")
+		}
+		ldflags = append(ldflags, path)
+	case "":
+		// no library specified, so nothing to do
+	default:
+		return fmt.Errorf("unknown libc: %s", config.Target.Libc)
+	}
+
 	// Add jobs to compile extra files. These files are in C or assembly and
 	// contain things like the interrupt vector table and low level operations
 	// such as stack switching.
-	root := goenv.Get("TINYGOROOT")
 	for _, path := range config.ExtraFiles() {
 		abspath := filepath.Join(root, path)
 		job := &compileJob{
@@ -514,29 +536,39 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		ldflags = append(ldflags, lprogram.LDFlags...)
 	}
 
-	// Add libc dependency if needed.
-	switch config.Target.Libc {
-	case "picolibc":
-		job, err := Picolibc.load(config.Triple(), config.CPU(), dir)
-		if err != nil {
-			return err
+	// Strip debug information if -debug is true. This is sometimes the default,
+	// such as with WebAssembly targets.
+	if !config.Debug() {
+		for _, tag := range config.BuildTags() {
+			if tag == "baremetal" {
+				// Don't use -debug=false on baremetal targets. It makes no
+				// sense: the debug information isn't flashed to the device
+				// anyway.
+				return fmt.Errorf("stripping debug information is unnecessary for baremetal targets")
+			}
 		}
-		// The library needs to be compiled (cache miss).
-		jobs = append(jobs, job.dependencies...)
-		jobs = append(jobs, job)
-		linkerDependencies = append(linkerDependencies, job)
-	case "wasi-libc":
-		path := filepath.Join(root, "lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a")
-		if _, err := os.Stat(path); os.IsNotExist(err) {
-			return errors.New("could not find wasi-libc, perhaps you need to run `make wasi-libc`?")
+		if config.Target.Linker == "wasm-ld" {
+			// Don't just strip debug information, also compress relocations
+			// while we're at it. Relocations can only be compressed when debug
+			// information is stripped.
+			ldflags = append(ldflags, "--strip-debug", "--compress-relocations")
+		} else {
+			switch config.GOOS() {
+			case "linux":
+				// Either real linux or an embedded system (like AVR) that
+				// pretends to be Linux. It's a ELF linker wrapped by GCC in any
+				// case.
+				ldflags = append(ldflags, "-Wl,--strip-debug")
+			case "darwin":
+				// MacOS (darwin) doesn't have a linker flag to strip debug
+				// information. Apple expects you to use the strip command
+				// instead.
+				return errors.New("cannot remove debug information: MacOS doesn't suppor this linker flag")
+			default:
+				// Other OSes may have different flags.
+				return errors.New("cannot remove debug information: unknown OS: " + config.GOOS())
+			}
 		}
-		job := dummyCompileJob(path)
-		jobs = append(jobs, job)
-		linkerDependencies = append(linkerDependencies, job)
-	case "":
-		// no library specified, so nothing to do
-	default:
-		return fmt.Errorf("unknown libc: %s", config.Target.Libc)
 	}
 
 	// Create a linker job, which links all object files together and does some

compileopts/config.go

@@ -209,9 +209,8 @@ func (c *Config) CFlags() []string {
 		cflags = append(cflags, "-nostdlibinc", "-Xclang", "-internal-isystem", "-Xclang", filepath.Join(root, "lib", "picolibc", "newlib", "libc", "include"))
 		cflags = append(cflags, "-I"+filepath.Join(root, "lib/picolibc-include"))
 	}
-	if c.Debug() {
-		cflags = append(cflags, "-g")
-	}
+	// Always emit debug information. It is optionally stripped at link time.
+	cflags = append(cflags, "-g")
 	return cflags
 }
 
@@ -250,10 +249,27 @@ func (c *Config) VerifyIR() bool {
 	return c.Options.VerifyIR
 }
 
-// Debug returns whether to add debug symbols to the IR, for debugging with GDB
-// and similar.
+// Debug returns whether debug (DWARF) information should be retained by the
+// linker. The default varies by target but can be controlled with the -debug
+// command line flag.
 func (c *Config) Debug() bool {
-	return c.Options.Debug
+	switch c.Options.Debug {
+	case "true":
+		return true
+	case "false":
+		return false
+	case "auto":
+		// Emit debug information everywhere by default except on WebAssembly.
+		for _, tag := range c.BuildTags() {
+			if tag == "tinygo.wasm" {
+				return false
+			}
+		}
+		return true
+	default:
+		// This is already checked so shouldn't happen.
+		panic("unknown -debug flag")
+	}
 }
 
 // BinaryFormat returns an appropriate binary format, based on the file

compileopts/options.go

@@ -9,6 +9,7 @@ import (
 var (
 	validGCOptions            = []string{"none", "leaking", "extalloc", "conservative"}
 	validSchedulerOptions     = []string{"none", "tasks", "coroutines"}
+	validDebugOptions         = []string{"auto", "true", "false"}
 	validSerialOptions        = []string{"none", "uart", "usb"}
 	validPrintSizeOptions     = []string{"none", "short", "full"}
 	validPanicStrategyOptions = []string{"print", "trap"}
@@ -28,7 +29,7 @@ type Options struct {
 	DumpSSA         bool
 	VerifyIR        bool
 	PrintCommands   func(cmd string, args ...string)
-	Debug           bool
+	Debug           string
 	PrintSizes      string
 	PrintAllocs     *regexp.Regexp // regexp string
 	PrintStacks     bool
@@ -70,6 +71,12 @@ func (o *Options) Verify() error {
 		}
 	}
 
+	if !isInArray(validDebugOptions, o.Debug) {
+		return fmt.Errorf(`invalid debug option '%s': valid values are %s`,
+			o.Debug,
+			strings.Join(validDebugOptions, ", "))
+	}
+
 	if o.PrintSizes != "" {
 		valid := isInArray(validPrintSizeOptions, o.PrintSizes)
 		if !valid {

compiler/compiler.go

@@ -58,7 +58,6 @@ type Config struct {
 	AutomaticStackSize bool
 	DefaultStackSize   uint64
 	NeedsStackObjects  bool
-	Debug              bool // Whether to emit debug information in the LLVM module.
 	LLVMFeatures       string
 }
 
@@ -103,9 +102,7 @@ func newCompilerContext(moduleName string, machine llvm.TargetMachine, config *C
 	c.mod = c.ctx.NewModule(moduleName)
 	c.mod.SetTarget(config.Triple)
 	c.mod.SetDataLayout(c.targetData.String())
-	if c.Debug {
-		c.dibuilder = llvm.NewDIBuilder(c.mod)
-	}
+	c.dibuilder = llvm.NewDIBuilder(c.mod)
 
 	c.uintptrType = c.ctx.IntType(c.targetData.PointerSize() * 8)
 	if c.targetData.PointerSize() <= 4 {
@@ -263,15 +260,13 @@ func CompilePackage(moduleName string, pkg *loader.Package, ssaPkg *ssa.Package,
 	ssaPkg.Build()
 
 	// Initialize debug information.
-	if c.Debug {
-		c.cu = c.dibuilder.CreateCompileUnit(llvm.DICompileUnit{
-			Language:  0xb, // DW_LANG_C99 (0xc, off-by-one?)
-			File:      "<unknown>",
-			Dir:       "",
-			Producer:  "TinyGo",
-			Optimized: true,
-		})
-	}
+	c.cu = c.dibuilder.CreateCompileUnit(llvm.DICompileUnit{
+		Language:  0xb, // DW_LANG_C99 (0xc, off-by-one?)
+		File:      "<unknown>",
+		Dir:       "",
+		Producer:  "TinyGo",
+		Optimized: true,
+	})
 
 	// Load comments such as //go:extern on globals.
 	c.loadASTComments(pkg)
@@ -286,23 +281,21 @@ func CompilePackage(moduleName string, pkg *loader.Package, ssaPkg *ssa.Package,
 	c.createPackage(irbuilder, ssaPkg)
 
 	// see: https://reviews.llvm.org/D18355
-	if c.Debug {
-		c.mod.AddNamedMetadataOperand("llvm.module.flags",
-			c.ctx.MDNode([]llvm.Metadata{
-				llvm.ConstInt(c.ctx.Int32Type(), 1, false).ConstantAsMetadata(), // Error on mismatch
-				c.ctx.MDString("Debug Info Version"),
-				llvm.ConstInt(c.ctx.Int32Type(), 3, false).ConstantAsMetadata(), // DWARF version
-			}),
-		)
-		c.mod.AddNamedMetadataOperand("llvm.module.flags",
-			c.ctx.MDNode([]llvm.Metadata{
-				llvm.ConstInt(c.ctx.Int32Type(), 1, false).ConstantAsMetadata(),
-				c.ctx.MDString("Dwarf Version"),
-				llvm.ConstInt(c.ctx.Int32Type(), 4, false).ConstantAsMetadata(),
-			}),
-		)
-		c.dibuilder.Finalize()
-	}
+	c.mod.AddNamedMetadataOperand("llvm.module.flags",
+		c.ctx.MDNode([]llvm.Metadata{
+			llvm.ConstInt(c.ctx.Int32Type(), 1, false).ConstantAsMetadata(), // Error on mismatch
+			c.ctx.MDString("Debug Info Version"),
+			llvm.ConstInt(c.ctx.Int32Type(), 3, false).ConstantAsMetadata(), // DWARF version
+		}),
+	)
+	c.mod.AddNamedMetadataOperand("llvm.module.flags",
+		c.ctx.MDNode([]llvm.Metadata{
+			llvm.ConstInt(c.ctx.Int32Type(), 1, false).ConstantAsMetadata(),
+			c.ctx.MDString("Dwarf Version"),
+			llvm.ConstInt(c.ctx.Int32Type(), 4, false).ConstantAsMetadata(),
+		}),
+	)
+	c.dibuilder.Finalize()
 
 	return c.mod, c.diagnostics
 }
@@ -693,7 +686,6 @@ func (c *compilerContext) getDIFile(filename string) llvm.Metadata {
 // createPackage builds the LLVM IR for all types, methods, and global variables
 // in the given package.
 func (c *compilerContext) createPackage(irbuilder llvm.Builder, pkg *ssa.Package) {
-	println("called create package:", pkg.Pkg.Name())
 	// Sort by position, so that the order of the functions in the IR matches
 	// the order of functions in the source file. This is useful for testing,
 	// for example.
@@ -759,35 +751,6 @@ func (c *compilerContext) createPackage(irbuilder llvm.Builder, pkg *ssa.Package
 		case *ssa.Global:
 			// Global variable.
 			info := c.getGlobalInfo(member)
-			// process go:embed pragmas
-			// TODO: skip this if not Go 1.16 or higher
-			if strings.TrimSpace(info.embeds) != "" {
-				embeds, err := parseGoEmbed(info.embeds)
-				if err != nil {
-					c.addError(member.Pos(), `invalid go:embed pragma: `+err.Error())
-					goto getGlobal
-				}
-				importsEmbedPkg := false
-				for _, imprt := range pkg.Pkg.Imports() {
-					if imprt.Name() == "embed" {
-						importsEmbedPkg = true
-						break
-					}
-				}
-				if !importsEmbedPkg {
-					// FIXME: technically the "embed" package needs to be imported in every
-					// *source file* that has a //go:embed pragma... that will always be the
-					// case when referencing embed.FS but not necessarily when a go:embed
-					// pragma is added to a string or []byte.  For now, as long as the embed
-					// package is imported in at least one source file, TinyGo will process
-					// any go:embed pragmas in the entire package.
-					c.addError(member.Pos(), `//go:embed only allowed in Go files that import "embed"`)
-					goto getGlobal
-				}
-				fmt.Printf("file embed found at %v (import: %v): %v\n", info.linkName, importsEmbedPkg, embeds)
-			}
-
-		getGlobal:
 			global := c.getGlobal(member)
 			if !info.extern {
 				global.SetInitializer(llvm.ConstNull(global.Type().ElementType()))
@@ -796,7 +759,6 @@ func (c *compilerContext) createPackage(irbuilder llvm.Builder, pkg *ssa.Package
 					global.SetSection(info.section)
 				}
 			}
-
 		}
 	}
 }
@@ -843,20 +805,18 @@ func (b *builder) createFunction() {
 		b.llvmFn.AddFunctionAttr(noinline)
 	}
 
-	// Add debug info, if needed.
-	if b.Debug {
-		if b.fn.Synthetic == "package initializer" {
-			// Package initializers have no debug info. Create some fake debug
-			// info to at least have *something*.
-			filename := b.fn.Package().Pkg.Path() + "/<init>"
-			b.difunc = b.attachDebugInfoRaw(b.fn, b.llvmFn, "", filename, 0)
-		} else if b.fn.Syntax() != nil {
-			// Create debug info file if needed.
-			b.difunc = b.attachDebugInfo(b.fn)
-		}
-		pos := b.program.Fset.Position(b.fn.Pos())
-		b.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), b.difunc, llvm.Metadata{})
+	// Add debug info.
+	if b.fn.Synthetic == "package initializer" {
+		// Package initializers have no debug info. Create some fake debug
+		// info to at least have *something*.
+		filename := b.fn.Package().Pkg.Path() + "/<init>"
+		b.difunc = b.attachDebugInfoRaw(b.fn, b.llvmFn, "", filename, 0)
+	} else if b.fn.Syntax() != nil {
+		// Create debug info file if needed.
+		b.difunc = b.attachDebugInfo(b.fn)
 	}
+	pos := b.program.Fset.Position(b.fn.Pos())
+	b.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), b.difunc, llvm.Metadata{})
 
 	// Pre-create all basic blocks in the function.
 	for _, block := range b.fn.DomPreorder() {
@@ -881,7 +841,7 @@ func (b *builder) createFunction() {
 		b.locals[param] = b.collapseFormalParam(llvmType, fields)
 
 		// Add debug information to this parameter (if available)
-		if b.Debug && b.fn.Syntax() != nil {
+		if b.fn.Syntax() != nil {
 			dbgParam := b.getLocalVariable(param.Object().(*types.Var))
 			loc := b.GetCurrentDebugLocation()
 			if len(fields) == 1 {
@@ -941,9 +901,6 @@ func (b *builder) createFunction() {
 		b.currentBlock = block
 		for _, instr := range block.Instrs {
 			if instr, ok := instr.(*ssa.DebugRef); ok {
-				if !b.Debug {
-					continue
-				}
 				object := instr.Object()
 				variable, ok := object.(*types.Var)
 				if !ok {
@@ -1060,10 +1017,8 @@ func getPos(val posser) token.Pos {
 // createInstruction builds the LLVM IR equivalent instructions for the
 // particular Go SSA instruction.
 func (b *builder) createInstruction(instr ssa.Instruction) {
-	if b.Debug {
-		pos := b.program.Fset.Position(getPos(instr))
-		b.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), b.difunc, llvm.Metadata{})
-	}
+	pos := b.program.Fset.Position(getPos(instr))
+	b.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), b.difunc, llvm.Metadata{})
 
 	switch instr := instr.(type) {
 	case ssa.Value:

compiler/embed.go

@@ -1,70 +0,0 @@
-package compiler
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-	"unicode"
-	"unicode/utf8"
-)
-
-// parseGoEmbed parses the text following "//go:embed" to extract the glob patterns.
-// It accepts unquoted space-separated patterns as well as double-quoted and back-quoted Go strings.
-// Copied from https://github.com/golang/go/blob/219fe9d547d09d3de1b024c6c8b8314dd0bf12e4/src/cmd/compile/internal/noder/noder.go#L1717-L1776
-func parseGoEmbed(args string) ([]string, error) {
-	var list []string
-	for args = strings.TrimSpace(args); args != ""; args = strings.TrimSpace(args) {
-		var path string
-	Switch:
-		switch args[0] {
-		default:
-			i := len(args)
-			for j, c := range args {
-				if unicode.IsSpace(c) {
-					i = j
-					break
-				}
-			}
-			path = args[:i]
-			args = args[i:]
-
-		case '`':
-			i := strings.Index(args[1:], "`")
-			if i < 0 {
-				return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args)
-			}
-			path = args[1 : 1+i]
-			args = args[1+i+1:]
-
-		case '"':
-			i := 1
-			for ; i < len(args); i++ {
-				if args[i] == '\\' {
-					i++
-					continue
-				}
-				if args[i] == '"' {
-					q, err := strconv.Unquote(args[:i+1])
-					if err != nil {
-						return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args[:i+1])
-					}
-					path = q
-					args = args[i+1:]
-					break Switch
-				}
-			}
-			if i >= len(args) {
-				return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args)
-			}
-		}
-
-		if args != "" {
-			r, _ := utf8.DecodeRuneInString(args)
-			if !unicode.IsSpace(r) {
-				return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args)
-			}
-		}
-		list = append(list, path)
-	}
-	return list, nil
-}

compiler/goroutine.go

@@ -182,27 +182,26 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 		entry := c.ctx.AddBasicBlock(wrapper, "entry")
 		builder.SetInsertPointAtEnd(entry)
 
-		if c.Debug {
-			pos := c.program.Fset.Position(pos)
-			diFuncType := c.dibuilder.CreateSubroutineType(llvm.DISubroutineType{
-				File:       c.getDIFile(pos.Filename),
-				Parameters: nil, // do not show parameters in debugger
-				Flags:      0,   // ?
-			})
-			difunc := c.dibuilder.CreateFunction(c.getDIFile(pos.Filename), llvm.DIFunction{
-				Name:         "<goroutine wrapper>",
-				File:         c.getDIFile(pos.Filename),
-				Line:         pos.Line,
-				Type:         diFuncType,
-				LocalToUnit:  true,
-				IsDefinition: true,
-				ScopeLine:    0,
-				Flags:        llvm.FlagPrototyped,
-				Optimized:    true,
-			})
-			wrapper.SetSubprogram(difunc)
-			builder.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), difunc, llvm.Metadata{})
-		}
+		// Add debug information.
+		pos := c.program.Fset.Position(pos)
+		diFuncType := c.dibuilder.CreateSubroutineType(llvm.DISubroutineType{
+			File:       c.getDIFile(pos.Filename),
+			Parameters: nil, // do not show parameters in debugger
+			Flags:      0,   // ?
+		})
+		difunc := c.dibuilder.CreateFunction(c.getDIFile(pos.Filename), llvm.DIFunction{
+			Name:         "<goroutine wrapper>",
+			File:         c.getDIFile(pos.Filename),
+			Line:         pos.Line,
+			Type:         diFuncType,
+			LocalToUnit:  true,
+			IsDefinition: true,
+			ScopeLine:    0,
+			Flags:        llvm.FlagPrototyped,
+			Optimized:    true,
+		})
+		wrapper.SetSubprogram(difunc)
+		builder.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), difunc, llvm.Metadata{})
 
 		// Create the list of params for the call.
 		paramTypes := fn.Type().ElementType().ParamTypes()
@@ -246,27 +245,26 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 		entry := c.ctx.AddBasicBlock(wrapper, "entry")
 		builder.SetInsertPointAtEnd(entry)
 
-		if c.Debug {
-			pos := c.program.Fset.Position(pos)
-			diFuncType := c.dibuilder.CreateSubroutineType(llvm.DISubroutineType{
-				File:       c.getDIFile(pos.Filename),
-				Parameters: nil, // do not show parameters in debugger
-				Flags:      0,   // ?
-			})
-			difunc := c.dibuilder.CreateFunction(c.getDIFile(pos.Filename), llvm.DIFunction{
-				Name:         "<goroutine wrapper>",
-				File:         c.getDIFile(pos.Filename),
-				Line:         pos.Line,
-				Type:         diFuncType,
-				LocalToUnit:  true,
-				IsDefinition: true,
-				ScopeLine:    0,
-				Flags:        llvm.FlagPrototyped,
-				Optimized:    true,
-			})
-			wrapper.SetSubprogram(difunc)
-			builder.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), difunc, llvm.Metadata{})
-		}
+		// Add debug information.
+		pos := c.program.Fset.Position(pos)
+		diFuncType := c.dibuilder.CreateSubroutineType(llvm.DISubroutineType{
+			File:       c.getDIFile(pos.Filename),
+			Parameters: nil, // do not show parameters in debugger
+			Flags:      0,   // ?
+		})
+		difunc := c.dibuilder.CreateFunction(c.getDIFile(pos.Filename), llvm.DIFunction{
+			Name:         "<goroutine wrapper>",
+			File:         c.getDIFile(pos.Filename),
+			Line:         pos.Line,
+			Type:         diFuncType,
+			LocalToUnit:  true,
+			IsDefinition: true,
+			ScopeLine:    0,
+			Flags:        llvm.FlagPrototyped,
+			Optimized:    true,
+		})
+		wrapper.SetSubprogram(difunc)
+		builder.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), difunc, llvm.Metadata{})
 
 		// Get the list of parameters, with the extra parameters at the end.
 		paramTypes := fn.Type().ElementType().ParamTypes()

compiler/interface.go

@@ -501,12 +501,10 @@ func (c *compilerContext) getInterfaceInvokeWrapper(fn *ssa.Function, llvmFn llv
 	}
 	defer b.Builder.Dispose()
 
-	// add debug info if needed
-	if c.Debug {
-		pos := c.program.Fset.Position(fn.Pos())
-		difunc := c.attachDebugInfoRaw(fn, wrapper, "$invoke", pos.Filename, pos.Line)
-		b.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), difunc, llvm.Metadata{})
-	}
+	// add debug info
+	pos := c.program.Fset.Position(fn.Pos())
+	difunc := c.attachDebugInfoRaw(fn, wrapper, "$invoke", pos.Filename, pos.Line)
+	b.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), difunc, llvm.Metadata{})
 
 	// set up IR builder
 	block := b.ctx.AddBasicBlock(wrapper, "entry")

compiler/interrupt.go

@@ -52,19 +52,17 @@ func (b *builder) createInterruptGlobal(instr *ssa.CallCommon) (llvm.Value, erro
 	global.SetInitializer(initializer)
 
 	// Add debug info to the interrupt global.
-	if b.Debug {
-		pos := b.program.Fset.Position(instr.Pos())
-		diglobal := b.dibuilder.CreateGlobalVariableExpression(b.getDIFile(pos.Filename), llvm.DIGlobalVariableExpression{
-			Name:        "interrupt" + strconv.FormatInt(id.Int64(), 10),
-			LinkageName: globalName,
-			File:        b.getDIFile(pos.Filename),
-			Line:        pos.Line,
-			Type:        b.getDIType(globalType),
-			Expr:        b.dibuilder.CreateExpression(nil),
-			LocalToUnit: false,
-		})
-		global.AddMetadata(0, diglobal)
-	}
+	pos := b.program.Fset.Position(instr.Pos())
+	diglobal := b.dibuilder.CreateGlobalVariableExpression(b.getDIFile(pos.Filename), llvm.DIGlobalVariableExpression{
+		Name:        "interrupt" + strconv.FormatInt(id.Int64(), 10),
+		LinkageName: globalName,
+		File:        b.getDIFile(pos.Filename),
+		Line:        pos.Line,
+		Type:        b.getDIType(globalType),
+		Expr:        b.dibuilder.CreateExpression(nil),
+		LocalToUnit: false,
+	})
+	global.AddMetadata(0, diglobal)
 
 	// Create the runtime/interrupt.Interrupt type. It is a struct with a single
 	// member of type int.

compiler/symbol.go

@@ -331,7 +331,6 @@ type globalInfo struct {
 	extern   bool   // go:extern
 	align    int    // go:align
 	section  string // go:section
-	embeds   string // go:embed
 }
 
 // loadASTComments loads comments on globals from the AST, for use later in the
@@ -387,7 +386,7 @@ func (c *compilerContext) getGlobal(g *ssa.Global) llvm.Value {
 			llvmGlobal.SetAlignment(alignment)
 		}
 
-		if c.Debug && !info.extern {
+		if !info.extern {
 			// Add debug info.
 			pos := c.program.Fset.Position(g.Pos())
 			diglobal := c.dibuilder.CreateGlobalVariableExpression(c.difiles[pos.Filename], llvm.DIGlobalVariableExpression{
@@ -449,9 +448,6 @@ func (info *globalInfo) parsePragmas(doc *ast.CommentGroup) {
 			if len(parts) == 2 {
 				info.section = parts[1]
 			}
-		case "//go:embed":
-			raw := strings.TrimPrefix(comment.Text, "//go:embed")
-			info.embeds += " " + raw
 		}
 	}
 }

go.mod

@@ -1,6 +1,6 @@
 module github.com/tinygo-org/tinygo
 
-go 1.16
+go 1.13
 
 require (
 	github.com/blakesmith/ar v0.0.0-20150311145944-8bd4349a67f2

interp/errors.go

@@ -57,7 +57,6 @@ func (r *runner) errorAt(inst instruction, err error) *Error {
 	pos := getPosition(inst.llvmInst)
 	return &Error{
 		ImportPath: r.pkgName,
-		Inst:       inst.llvmInst,
 		Pos:        pos,
 		Err:        err,
 		Traceback:  []ErrorLine{{pos, inst.llvmInst}},

interp/interp.go

@@ -15,7 +15,7 @@ import (
 // package is changed in a way that affects the output so that cached package
 // builds will be invalidated.
 // This version is independent of the TinyGo version number.
-const Version = 2 // last change: fix GEP on untyped pointers
+const Version = 1
 
 // Enable extra checks, which should be disabled by default.
 // This may help track down bugs by adding a few more sanity checks.
@@ -110,26 +110,17 @@ func Run(mod llvm.Module, debug bool) error {
 			fmt.Fprintln(os.Stderr, "call:", fn.Name())
 		}
 		_, mem, callErr := r.run(r.getFunction(fn), nil, nil, "    ")
-		call.EraseFromParentAsInstruction()
 		if callErr != nil {
 			if isRecoverableError(callErr.Err) {
 				if r.debug {
 					fmt.Fprintln(os.Stderr, "not interpreting", r.pkgName, "because of error:", callErr.Error())
 				}
-				// Remove instructions that were created as part of interpreting
-				// the package.
 				mem.revert()
-				// Create a call to the package initializer (which was
-				// previously deleted).
-				i8undef := llvm.Undef(r.i8ptrType)
-				r.builder.CreateCall(fn, []llvm.Value{i8undef, i8undef}, "")
-				// Make sure that any globals touched by the package
-				// initializer, won't be accessed by later package initializers.
-				r.markExternalLoad(fn)
 				continue
 			}
 			return callErr
 		}
+		call.EraseFromParentAsInstruction()
 		for index, obj := range mem.objects {
 			r.objects[index] = obj
 		}
@@ -279,19 +270,3 @@ func (r *runner) getFunction(llvmFn llvm.Value) *function {
 	r.functionCache[llvmFn] = fn
 	return fn
 }
-
-// markExternalLoad marks the given llvmValue as being loaded externally. This
-// is primarily used to mark package initializers that could not be run at
-// compile time. As an example, a package initialize might store to a global
-// variable. Another package initializer might read from the same global
-// variable. By marking this function as being run at runtime, that load
-// instruction will need to be run at runtime instead of at compile time.
-func (r *runner) markExternalLoad(llvmValue llvm.Value) {
-	mem := memoryView{r: r}
-	mem.markExternalLoad(llvmValue)
-	for index, obj := range mem.objects {
-		if obj.marked > r.objects[index].marked {
-			r.objects[index].marked = obj.marked
-		}
-	}
-}

interp/interp_test.go

@@ -17,7 +17,6 @@ func TestInterp(t *testing.T) {
 		"slice-copy",
 		"consteval",
 		"interface",
-		"revert",
 	} {
 		name := name // make tc local to this closure
 		t.Run(name, func(t *testing.T) {

interp/memory.go

@@ -572,17 +572,6 @@ func (v pointerValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Val
 	}
 
 	if llvmType.IsNil() {
-		if v.offset() != 0 {
-			// If there is an offset, make sure to use a GEP to index into the
-			// pointer. Because there is no expected type, we use whatever is
-			// most convenient: an *i8 type. It is trivial to index byte-wise.
-			if llvmValue.Type() != mem.r.i8ptrType {
-				llvmValue = llvm.ConstBitCast(llvmValue, mem.r.i8ptrType)
-			}
-			llvmValue = llvm.ConstInBoundsGEP(llvmValue, []llvm.Value{
-				llvm.ConstInt(llvmValue.Type().Context().Int32Type(), uint64(v.offset()), false),
-			})
-		}
 		return llvmValue, nil
 	}
 

interp/testdata/revert.ll

@@ -1,32 +0,0 @@
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64--linux"
-
-declare void @externalCall(i64)
-
-@foo.knownAtRuntime = global i64 0
-@bar.knownAtRuntime = global i64 0
-
-define void @runtime.initAll() unnamed_addr {
-entry:
-  call void @foo.init(i8* undef, i8* undef)
-  call void @bar.init(i8* undef, i8* undef)
-  call void @main.init(i8* undef, i8* undef)
-  ret void
-}
-
-define internal void @foo.init(i8* %context, i8* %parentHandle) unnamed_addr {
-  store i64 5, i64* @foo.knownAtRuntime
-  unreachable ; this triggers a revert of @foo.init.
-}
-
-define internal void @bar.init(i8* %context, i8* %parentHandle) unnamed_addr {
-  %val = load i64, i64* @foo.knownAtRuntime
-  store i64 %val, i64* @bar.knownAtRuntime
-  ret void
-}
-
-define internal void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  call void @externalCall(i64 3)
-  ret void
-}

interp/testdata/revert.out.ll

@@ -1,21 +0,0 @@
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64--linux"
-
-@foo.knownAtRuntime = local_unnamed_addr global i64 0
-@bar.knownAtRuntime = local_unnamed_addr global i64 0
-
-declare void @externalCall(i64) local_unnamed_addr
-
-define void @runtime.initAll() unnamed_addr {
-entry:
-  call fastcc void @foo.init(i8* undef, i8* undef)
-  %val = load i64, i64* @foo.knownAtRuntime, align 8
-  store i64 %val, i64* @bar.knownAtRuntime, align 8
-  call void @externalCall(i64 3)
-  ret void
-}
-
-define internal fastcc void @foo.init(i8* %context, i8* %parentHandle) unnamed_addr {
-  store i64 5, i64* @foo.knownAtRuntime, align 8
-  unreachable
-}

main.go

@@ -1019,7 +1019,7 @@ func main() {
 	printStacks := flag.Bool("print-stacks", false, "print stack sizes of goroutines")
 	printAllocsString := flag.String("print-allocs", "", "regular expression of functions for which heap allocations should be printed")
 	printCommands := flag.Bool("x", false, "Print commands")
-	nodebug := flag.Bool("no-debug", false, "disable DWARF debug symbol generation")
+	debug := flag.String("debug", "auto", "remove debug information (auto, true, false)")
 	ocdCommandsString := flag.String("ocd-commands", "", "OpenOCD commands, overriding target spec (can specify multiple separated by commas)")
 	ocdOutput := flag.Bool("ocd-output", false, "print OCD daemon output during debug")
 	port := flag.String("port", "", "flash port (can specify multiple candidates separated by commas)")
@@ -1086,7 +1086,7 @@ func main() {
 		PrintIR:         *printIR,
 		DumpSSA:         *dumpSSA,
 		VerifyIR:        *verifyIR,
-		Debug:           !*nodebug,
+		Debug:           *debug,
 		PrintSizes:      *printSize,
 		PrintStacks:     *printStacks,
 		PrintAllocs:     printAllocs,
@@ -1173,11 +1173,6 @@ func main() {
 			err := Flash(pkgName, *port, options)
 			handleCompilerError(err)
 		} else {
-			if !options.Debug {
-				fmt.Fprintln(os.Stderr, "Debug disabled while running gdb?")
-				usage()
-				os.Exit(1)
-			}
 			err := FlashGDB(pkgName, *ocdOutput, options)
 			handleCompilerError(err)
 		}

main_test.go

@@ -125,7 +125,7 @@ func TestCompiler(t *testing.T) {
 		// Test with few optimizations enabled (no inlining, etc).
 		t.Run("opt=1", func(t *testing.T) {
 			t.Parallel()
-			runTestWithConfig("stdlib.go", "", t, compileopts.Options{
+			runTestWithConfig("stdlib.go", "", t, &compileopts.Options{
 				Opt: "1",
 			}, nil, nil)
 		})
@@ -134,14 +134,15 @@ func TestCompiler(t *testing.T) {
 		// TODO: fix this for stdlib.go, which currently fails.
 		t.Run("opt=0", func(t *testing.T) {
 			t.Parallel()
-			runTestWithConfig("print.go", "", t, compileopts.Options{
+			runTestWithConfig("print.go", "", t, &compileopts.Options{
 				Opt: "0",
 			}, nil, nil)
 		})
 
 		t.Run("ldflags", func(t *testing.T) {
 			t.Parallel()
-			runTestWithConfig("ldflags.go", "", t, compileopts.Options{
+			runTestWithConfig("ldflags.go", "", t, &compileopts.Options{
+				Opt: "z",
 				GlobalValues: map[string]map[string]string{
 					"main": {
 						"someGlobal": "foobar",
@@ -187,20 +188,20 @@ func runBuild(src, out string, opts *compileopts.Options) error {
 }
 
 func runTest(name, target string, t *testing.T, cmdArgs, environmentVars []string) {
-	options := compileopts.Options{
-		Target: target,
+	options := &compileopts.Options{
+		Target:     target,
+		Opt:        "z",
+		PrintIR:    false,
+		DumpSSA:    false,
+		VerifyIR:   true,
+		EmitDWARF:  true,
+		PrintSizes: "",
+		WasmAbi:    "",
 	}
 	runTestWithConfig(name, target, t, options, cmdArgs, environmentVars)
 }
 
-func runTestWithConfig(name, target string, t *testing.T, options compileopts.Options, cmdArgs, environmentVars []string) {
-	// Set default config.
-	options.Debug = true
-	options.VerifyIR = true
-	if options.Opt == "" {
-		options.Opt = "z"
-	}
-
+func runTestWithConfig(name, target string, t *testing.T, options *compileopts.Options, cmdArgs, environmentVars []string) {
 	// Get the expected output for this test.
 	// Note: not using filepath.Join as it strips the path separator at the end
 	// of the path.
@@ -229,7 +230,7 @@ func runTestWithConfig(name, target string, t *testing.T, options compileopts.Op
 
 	// Build the test binary.
 	binary := filepath.Join(tmpdir, "test")
-	err = runBuild("./"+path, binary, &options)
+	err = runBuild("./"+path, binary, options)
 	if err != nil {
 		printCompilerError(t.Log, err)
 		t.Fail()

src/examples/embed/embed.go

@@ -1,22 +0,0 @@
-package main
-
-import (
-	"embed"
-	"log"
-)
-
-//go:embed file*.txt
-//go:embed index.html styles.css
-var files embed.FS
-
-func main() {
-	println(".....")
-	println(msg)
-	contents, err := files.ReadDir(".")
-	if err != nil {
-		log.Fatal(err)
-	}
-	for _, c := range contents {
-		println("file:", c.Name())
-	}
-}

src/examples/embed/file1.txt

@@ -1 +0,0 @@
-file 1

src/examples/embed/file2.txt

@@ -1 +0,0 @@
-file 2

src/examples/embed/file3.txt

@@ -1 +0,0 @@
-file 3

src/examples/embed/message.txt

@@ -1 +0,0 @@
-hello world!

src/examples/embed/test.go

@@ -1,6 +0,0 @@
-package main
-
-import _ "embed"
-
-//go:embed message.txt
-var msg string

src/runtime/arch_tinygowasm.go

@@ -55,51 +55,3 @@ func growHeap() bool {
 	// Heap has grown successfully.
 	return true
 }
-
-// The below functions override the default allocator of wasi-libc.
-// Most functions are defined but unimplemented to make sure that if there is
-// any code using them, they will get an error instead of (incorrectly) using
-// the wasi-libc dlmalloc heap implementation instead. If they are needed by any
-// program, they can certainly be implemented.
-
-//export malloc
-func libc_malloc(size uintptr) unsafe.Pointer {
-	return alloc(size)
-}
-
-//export free
-func libc_free(ptr unsafe.Pointer) {
-	free(ptr)
-}
-
-//export calloc
-func libc_calloc(nmemb, size uintptr) unsafe.Pointer {
-	// Note: we could be even more correct here and check that nmemb * size
-	// doesn't overflow. However the current implementation should normally work
-	// fine.
-	return alloc(nmemb * size)
-}
-
-//export realloc
-func libc_realloc(ptr unsafe.Pointer, size uintptr) unsafe.Pointer {
-	runtimePanic("unimplemented: realloc")
-	return nil
-}
-
-//export posix_memalign
-func libc_posix_memalign(memptr *unsafe.Pointer, alignment, size uintptr) int {
-	runtimePanic("unimplemented: posix_memalign")
-	return 0
-}
-
-//export aligned_alloc
-func libc_aligned_alloc(alignment, bytes uintptr) unsafe.Pointer {
-	runtimePanic("unimplemented: aligned_alloc")
-	return nil
-}
-
-//export malloc_usable_size
-func libc_malloc_usable_size(ptr unsafe.Pointer) uintptr {
-	runtimePanic("unimplemented: malloc_usable_size")
-	return 0
-}

testdata/init.go

@@ -13,8 +13,6 @@ func main() {
 	println("v5:", len(v5), v5 == nil)
 	println("v6:", v6)
 	println("v7:", cap(v7), string(v7))
-	println("v8:", v8)
-	println("v9:", len(v9), v9[0], v9[1], v9[2])
 
 	println(uint8SliceSrc[0])
 	println(uint8SliceDst[0])
@@ -37,8 +35,6 @@ var (
 	v5 = map[string]int{}
 	v6 = float64(v1) < 2.6
 	v7 = []byte("foo")
-	v8 string
-	v9 []int
 
 	uint8SliceSrc = []uint8{3, 100}
 	uint8SliceDst []uint8
@@ -52,15 +48,4 @@ func init() {
 
 	intSliceDst = make([]int16, len(intSliceSrc))
 	copy(intSliceDst, intSliceSrc)
-
-	v8 = sliceString("foobarbaz", 3, 8)
-	v9 = sliceSlice([]int{0, 1, 2, 3, 4, 5}, 2, 5)
-}
-
-func sliceString(s string, start, end int) string {
-	return s[start:end]
-}
-
-func sliceSlice(s []int, start, end int) []int {
-	return s[start:end]
 }

testdata/init.txt

@@ -7,8 +7,6 @@ v4: 0 true
 v5: 0 false
 v6: false
 v7: 3 foo
-v8: barba
-v9: 3 2 3 4
 3
 3
 5