Chdir flag

.gitignore

@@ -20,6 +20,8 @@ src/device/stm32/*.go
 src/device/stm32/*.s
 src/device/kendryte/*.go
 src/device/kendryte/*.s
+src/device/renesas/*.go
+src/device/renesas/*.s
 src/device/rp/*.go
 src/device/rp/*.s
 ./vendor

.gitmodules

@@ -32,9 +32,6 @@
 [submodule "lib/macos-minimal-sdk"]
 	path = lib/macos-minimal-sdk
 	url = https://github.com/aykevl/macos-minimal-sdk.git
-[submodule "lib/renesas-svd"]
-	path = lib/renesas-svd
-	url = https://github.com/tinygo-org/renesas-svd.git
 [submodule "src/net"]
 	path = src/net
 	url = https://github.com/tinygo-org/net.git

GNUmakefile

@@ -185,7 +185,7 @@ fmt-check: ## Warn if any source needs reformatting
 	@unformatted=$$(gofmt -l $(FMT_PATHS)); [ -z "$$unformatted" ] && exit 0; echo "Unformatted:"; for fn in $$unformatted; do echo "  $$fn"; done; exit 1
 
 
-gen-device: gen-device-avr gen-device-esp gen-device-nrf gen-device-sam gen-device-sifive gen-device-kendryte gen-device-nxp gen-device-rp ## Generate microcontroller-specific sources
+gen-device: gen-device-avr gen-device-esp gen-device-nrf gen-device-sam gen-device-sifive gen-device-kendryte gen-device-nxp gen-device-rp gen-device-renesas ## Generate microcontroller-specific sources
 ifneq ($(STM32), 0)
 gen-device: gen-device-stm32
 endif
@@ -234,7 +234,7 @@ gen-device-rp: build/gen-device-svd
 	GO111MODULE=off $(GO) fmt ./src/device/rp
 
 gen-device-renesas: build/gen-device-svd
-	./build/gen-device-svd -source=https://github.com/tinygo-org/renesas-svd lib/renesas-svd/ src/device/renesas/
+	./build/gen-device-svd -source=https://github.com/cmsis-svd/cmsis-svd-data/tree/master/data/Renesas lib/cmsis-svd/data/Renesas/ src/device/renesas/
 	GO111MODULE=off $(GO) fmt ./src/device/renesas
 
 $(LLVM_PROJECTDIR)/llvm:
@@ -267,7 +267,7 @@ lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a:
 	cd lib/wasi-libc && $(MAKE) -j4 EXTRA_CFLAGS="-O2 -g -DNDEBUG -mnontrapping-fptoint -msign-ext" MALLOC_IMPL=none CC="$(CLANG)" AR=$(LLVM_AR) NM=$(LLVM_NM)
 
 # Generate WASI syscall bindings
-WASM_TOOLS_MODULE=github.com/ydnar/wasm-tools-go
+WASM_TOOLS_MODULE=github.com/bytecodealliance/wasm-tools-go
 .PHONY: wasi-syscall
 wasi-syscall: wasi-cm
 	go run -modfile ./internal/wasm-tools/go.mod $(WASM_TOOLS_MODULE)/cmd/wit-bindgen-go generate --versioned -o ./src/internal -p internal --cm internal/cm ./lib/wasi-cli/wit
@@ -483,8 +483,17 @@ tinygo-baremetal:
 	# regression test for #2666: e.g. encoding/hex must pass on baremetal
 	$(TINYGO) test -target cortex-m-qemu encoding/hex
 
+.PHONY: testchdir
+testchdir:
+	# test 'build' command with{,out} -C argument
+	$(TINYGO) build -C tests/testing/chdir chdir.go && rm tests/testing/chdir/chdir
+	$(TINYGO) build ./tests/testing/chdir/chdir.go && rm chdir
+	# test 'run' command with{,out} -C argument
+	EXPECT_DIR=$(PWD)/tests/testing/chdir $(TINYGO) run -C tests/testing/chdir chdir.go
+	EXPECT_DIR=$(PWD) $(TINYGO) run ./tests/testing/chdir/chdir.go
+
 .PHONY: smoketest
-smoketest:
+smoketest: testchdir
 	$(TINYGO) version
 	$(TINYGO) targets > /dev/null
 	# regression test for #2892
@@ -642,6 +651,8 @@ endif
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=xiao                examples/blinky1
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=rak4631             examples/blinky1
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=circuitplay-express examples/dac
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pyportal            examples/dac

compileopts/target.go

@@ -336,19 +336,19 @@ func defaultTarget(options *Options) (*TargetSpec, error) {
 			spec.Features = "+fp-armv8,+neon,-fmv,-outline-atomics"
 		}
 	case "mips", "mipsle":
-		spec.CPU = "mips32r2"
+		spec.CPU = "mips32"
 		spec.CFlags = append(spec.CFlags, "-fno-pic")
-		if options.GOOS == "mips" {
+		if options.GOARCH == "mips" {
 			llvmarch = "mips" // big endian
 		} else {
 			llvmarch = "mipsel" // little endian
 		}
 		switch options.GOMIPS {
 		case "hardfloat":
-			spec.Features = "+fpxx,+mips32r2,+nooddspreg,-noabicalls"
+			spec.Features = "+fpxx,+mips32,+nooddspreg,-noabicalls"
 		case "softfloat":
 			spec.SoftFloat = true
-			spec.Features = "+mips32r2,+soft-float,-noabicalls"
+			spec.Features = "+mips32,+soft-float,-noabicalls"
 			spec.CFlags = append(spec.CFlags, "-msoft-float")
 		default:
 			return nil, fmt.Errorf("invalid GOMIPS=%s: must be hardfloat or softfloat", options.GOMIPS)
@@ -389,6 +389,7 @@ func defaultTarget(options *Options) (*TargetSpec, error) {
 			"-platform_version", "macos", platformVersion, platformVersion,
 		)
 		spec.ExtraFiles = append(spec.ExtraFiles,
+			"src/runtime/os_darwin.c",
 			"src/runtime/runtime_unix.c")
 	case "linux":
 		spec.Linker = "ld.lld"

compiler/compiler.go

@@ -1847,7 +1847,9 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 		case strings.HasPrefix(name, "(device/riscv.CSR)."):
 			return b.emitCSROperation(instr)
 		case strings.HasPrefix(name, "syscall.Syscall") || strings.HasPrefix(name, "syscall.RawSyscall") || strings.HasPrefix(name, "golang.org/x/sys/unix.Syscall") || strings.HasPrefix(name, "golang.org/x/sys/unix.RawSyscall"):
-			return b.createSyscall(instr)
+			if b.GOOS != "darwin" {
+				return b.createSyscall(instr)
+			}
 		case strings.HasPrefix(name, "syscall.rawSyscallNoError") || strings.HasPrefix(name, "golang.org/x/sys/unix.RawSyscallNoError"):
 			return b.createRawSyscallNoError(instr)
 		case name == "runtime.supportsRecover":
@@ -1865,6 +1867,11 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 			return llvm.ConstInt(b.ctx.Int8Type(), panicStrategy, false), nil
 		case name == "runtime/interrupt.New":
 			return b.createInterruptGlobal(instr)
+		case name == "internal/abi.FuncPCABI0":
+			retval := b.createDarwinFuncPCABI0Call(instr)
+			if !retval.IsNil() {
+				return retval, nil
+			}
 		}
 
 		calleeType, callee = b.getFunction(fn)

compiler/defer.go

@@ -16,6 +16,7 @@ package compiler
 import (
 	"go/types"
 	"strconv"
+	"strings"
 
 	"github.com/tinygo-org/tinygo/compiler/llvmutil"
 	"golang.org/x/tools/go/ssa"
@@ -198,7 +199,13 @@ jal 1f
 addiu $$ra, 8
 sw $$ra, 4($$5)
 .set at`
-		constraints = "={$4},{$5},~{$1},~{$2},~{$3},~{$5},~{$6},~{$7},~{$8},~{$9},~{$10},~{$11},~{$12},~{$13},~{$14},~{$15},~{$16},~{$17},~{$18},~{$19},~{$20},~{$21},~{$22},~{$23},~{$24},~{$25},~{$26},~{$27},~{$28},~{$29},~{$30},~{$31},~{$f0},~{$f1},~{$f2},~{$f3},~{$f4},~{$f5},~{$f6},~{$f7},~{$f8},~{$f9},~{$f10},~{$f11},~{$f12},~{$f13},~{$f14},~{$f15},~{$f16},~{$f17},~{$f18},~{$f19},~{$f20},~{$f21},~{$f22},~{$f23},~{$f24},~{$f25},~{$f26},~{$f27},~{$f28},~{$f29},~{$f30},~{$f31},~{memory}"
+		constraints = "={$4},{$5},~{$1},~{$2},~{$3},~{$5},~{$6},~{$7},~{$8},~{$9},~{$10},~{$11},~{$12},~{$13},~{$14},~{$15},~{$16},~{$17},~{$18},~{$19},~{$20},~{$21},~{$22},~{$23},~{$24},~{$25},~{$26},~{$27},~{$28},~{$29},~{$30},~{$31},~{memory}"
+		if !strings.Contains(b.Features, "+soft-float") {
+			// Using floating point registers together with GOMIPS=softfloat
+			// results in a crash: "This value type is not natively supported!"
+			// So only add them when using hardfloat.
+			constraints += ",~{$f0},~{$f1},~{$f2},~{$f3},~{$f4},~{$f5},~{$f6},~{$f7},~{$f8},~{$f9},~{$f10},~{$f11},~{$f12},~{$f13},~{$f14},~{$f15},~{$f16},~{$f17},~{$f18},~{$f19},~{$f20},~{$f21},~{$f22},~{$f23},~{$f24},~{$f25},~{$f26},~{$f27},~{$f28},~{$f29},~{$f30},~{$f31}"
+		}
 	case "riscv32":
 		asmString = `
 la a2, 1f

compiler/goroutine.go

@@ -13,37 +13,7 @@ import (
 
 // createGo emits code to start a new goroutine.
 func (b *builder) createGo(instr *ssa.Go) {
-	// Get all function parameters to pass to the goroutine.
-	var params []llvm.Value
-	for _, param := range instr.Call.Args {
-		params = append(params, b.getValue(param, getPos(instr)))
-	}
-
-	var prefix string
-	var funcPtr llvm.Value
-	var funcType llvm.Type
-	hasContext := false
-	if callee := instr.Call.StaticCallee(); callee != nil {
-		// Static callee is known. This makes it easier to start a new
-		// goroutine.
-		var context llvm.Value
-		switch value := instr.Call.Value.(type) {
-		case *ssa.Function:
-			// Goroutine call is regular function call. No context is necessary.
-		case *ssa.MakeClosure:
-			// A goroutine call on a func value, but the callee is trivial to find. For
-			// example: immediately applied functions.
-			funcValue := b.getValue(value, getPos(instr))
-			context = b.extractFuncContext(funcValue)
-		default:
-			panic("StaticCallee returned an unexpected value")
-		}
-		if !context.IsNil() {
-			params = append(params, context) // context parameter
-			hasContext = true
-		}
-		funcType, funcPtr = b.getFunction(callee)
-	} else if builtin, ok := instr.Call.Value.(*ssa.Builtin); ok {
+	if builtin, ok := instr.Call.Value.(*ssa.Builtin); ok {
 		// We cheat. None of the builtins do any long or blocking operation, so
 		// we might as well run these builtins right away without the program
 		// noticing the difference.
@@ -74,6 +44,38 @@ func (b *builder) createGo(instr *ssa.Go) {
 		}
 		b.createBuiltin(argTypes, argValues, builtin.Name(), instr.Pos())
 		return
+	}
+
+	// Get all function parameters to pass to the goroutine.
+	var params []llvm.Value
+	for _, param := range instr.Call.Args {
+		params = append(params, b.expandFormalParam(b.getValue(param, getPos(instr)))...)
+	}
+
+	var prefix string
+	var funcPtr llvm.Value
+	var funcType llvm.Type
+	hasContext := false
+	if callee := instr.Call.StaticCallee(); callee != nil {
+		// Static callee is known. This makes it easier to start a new
+		// goroutine.
+		var context llvm.Value
+		switch value := instr.Call.Value.(type) {
+		case *ssa.Function:
+			// Goroutine call is regular function call. No context is necessary.
+		case *ssa.MakeClosure:
+			// A goroutine call on a func value, but the callee is trivial to find. For
+			// example: immediately applied functions.
+			funcValue := b.getValue(value, getPos(instr))
+			context = b.extractFuncContext(funcValue)
+		default:
+			panic("StaticCallee returned an unexpected value")
+		}
+		if !context.IsNil() {
+			params = append(params, context) // context parameter
+			hasContext = true
+		}
+		funcType, funcPtr = b.getFunction(callee)
 	} else if instr.Call.IsInvoke() {
 		// This is a method call on an interface value.
 		itf := b.getValue(instr.Call.Value, getPos(instr))

compiler/llvmutil/llvm.go

@@ -8,6 +8,7 @@
 package llvmutil
 
 import (
+	"encoding/binary"
 	"strconv"
 	"strings"
 
@@ -216,3 +217,13 @@ func Version() int {
 	}
 	return major
 }
+
+// Return the byte order for the given target triple. Most targets are little
+// endian, but for example MIPS can be big-endian.
+func ByteOrder(target string) binary.ByteOrder {
+	if strings.HasPrefix(target, "mips-") {
+		return binary.BigEndian
+	} else {
+		return binary.LittleEndian
+	}
+}

compiler/syscall.go

@@ -5,6 +5,7 @@ package compiler
 
 import (
 	"strconv"
+	"strings"
 
 	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
@@ -329,3 +330,64 @@ func (b *builder) createRawSyscallNoError(call *ssa.CallCommon) (llvm.Value, err
 	retval = b.CreateInsertValue(retval, llvm.ConstInt(b.uintptrType, 0, false), 1, "")
 	return retval, nil
 }
+
+// Lower a call to internal/abi.FuncPCABI0 on MacOS.
+// This function is called like this:
+//
+//	syscall(abi.FuncPCABI0(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+//
+// So we'll want to return a function pointer (as uintptr) that points to the
+// libc function. Specifically, we _don't_ want to point to the trampoline
+// function (which is implemented in Go assembly which we can't read), but
+// rather to the actually intended function. For this we're going to assume that
+// all the functions follow a specific pattern: libc_<functionname>_trampoline.
+//
+// The return value is the function pointer as an uintptr, or a nil value if
+// this isn't possible (and a regular call should be made as fallback).
+func (b *builder) createDarwinFuncPCABI0Call(instr *ssa.CallCommon) llvm.Value {
+	if b.GOOS != "darwin" {
+		// This has only been tested on MacOS (and only seems to be used there).
+		return llvm.Value{}
+	}
+
+	// Check that it uses a function call like syscall.libc_*_trampoline
+	itf := instr.Args[0].(*ssa.MakeInterface)
+	calledFn := itf.X.(*ssa.Function)
+	if pkgName := calledFn.Pkg.Pkg.Path(); pkgName != "syscall" && pkgName != "internal/syscall/unix" {
+		return llvm.Value{}
+	}
+	if !strings.HasPrefix(calledFn.Name(), "libc_") || !strings.HasSuffix(calledFn.Name(), "_trampoline") {
+
+		return llvm.Value{}
+	}
+
+	// Extract the libc function name.
+	name := strings.TrimPrefix(strings.TrimSuffix(calledFn.Name(), "_trampoline"), "libc_")
+	if name == "open" {
+		// Special case: open() is a variadic function and can't be called like
+		// a regular function. Therefore, we need to use a wrapper implemented
+		// in C.
+		name = "syscall_libc_open"
+	}
+	if b.GOARCH == "amd64" {
+		if name == "fdopendir" || name == "readdir_r" {
+			// Hack to support amd64, which needs the $INODE64 suffix.
+			// This is also done in upstream Go:
+			// https://github.com/golang/go/commit/096ab3c21b88ccc7d411379d09fe6274e3159467
+			name += "$INODE64"
+		}
+	}
+
+	// Obtain the C function.
+	// Use a simple function (no parameters or return value) because all we need
+	// is the address of the function.
+	llvmFn := b.mod.NamedFunction(name)
+	if llvmFn.IsNil() {
+		llvmFnType := llvm.FunctionType(b.ctx.VoidType(), nil, false)
+		llvmFn = llvm.AddFunction(b.mod, name, llvmFnType)
+	}
+
+	// Cast the function pointer to a uintptr (because that's what
+	// abi.FuncPCABI0 returns).
+	return b.CreatePtrToInt(llvmFn, b.uintptrType, "")
+}

compiler/testdata/goroutine-cortex-m-qemu-tasks.ll

@@ -3,8 +3,6 @@ source_filename = "goroutine.go"
 target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
 target triple = "thumbv7m-unknown-unknown-eabi"
 
-%runtime._string = type { ptr, i32 }
-
 @"main$string" = internal unnamed_addr constant [4 x i8] c"test", align 1
 
 ; Function Attrs: allockind("alloc,zeroed") allocsize(0)
@@ -150,12 +148,12 @@ define hidden void @main.startInterfaceMethod(ptr %itf.typecode, ptr %itf.value,
 entry:
   %0 = call align 4 dereferenceable(16) ptr @runtime.alloc(i32 16, ptr null, ptr undef) #9
   store ptr %itf.value, ptr %0, align 4
-  %1 = getelementptr inbounds { ptr, %runtime._string, ptr }, ptr %0, i32 0, i32 1
+  %1 = getelementptr inbounds { ptr, ptr, i32, ptr }, ptr %0, i32 0, i32 1
   store ptr @"main$string", ptr %1, align 4
-  %.repack1 = getelementptr inbounds { ptr, %runtime._string, ptr }, ptr %0, i32 0, i32 1, i32 1
-  store i32 4, ptr %.repack1, align 4
-  %2 = getelementptr inbounds { ptr, %runtime._string, ptr }, ptr %0, i32 0, i32 2
-  store ptr %itf.typecode, ptr %2, align 4
+  %2 = getelementptr inbounds { ptr, ptr, i32, ptr }, ptr %0, i32 0, i32 2
+  store i32 4, ptr %2, align 4
+  %3 = getelementptr inbounds { ptr, ptr, i32, ptr }, ptr %0, i32 0, i32 3
+  store ptr %itf.typecode, ptr %3, align 4
   %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (ptr @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper" to i32), ptr undef) #9
   call void @"internal/task.start"(i32 ptrtoint (ptr @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper" to i32), ptr nonnull %0, i32 %stacksize, ptr undef) #9
   ret void

compiler/testdata/goroutine-wasm-asyncify.ll

@@ -3,8 +3,6 @@ source_filename = "goroutine.go"
 target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"
 
-%runtime._string = type { ptr, i32 }
-
 @"main$string" = internal unnamed_addr constant [4 x i8] c"test", align 1
 
 ; Function Attrs: allockind("alloc,zeroed") allocsize(0)
@@ -161,12 +159,12 @@ entry:
   %0 = call align 4 dereferenceable(16) ptr @runtime.alloc(i32 16, ptr null, ptr undef) #9
   call void @runtime.trackPointer(ptr nonnull %0, ptr nonnull %stackalloc, ptr undef) #9
   store ptr %itf.value, ptr %0, align 4
-  %1 = getelementptr inbounds { ptr, %runtime._string, ptr }, ptr %0, i32 0, i32 1
+  %1 = getelementptr inbounds { ptr, ptr, i32, ptr }, ptr %0, i32 0, i32 1
   store ptr @"main$string", ptr %1, align 4
-  %.repack1 = getelementptr inbounds { ptr, %runtime._string, ptr }, ptr %0, i32 0, i32 1, i32 1
-  store i32 4, ptr %.repack1, align 4
-  %2 = getelementptr inbounds { ptr, %runtime._string, ptr }, ptr %0, i32 0, i32 2
-  store ptr %itf.typecode, ptr %2, align 4
+  %2 = getelementptr inbounds { ptr, ptr, i32, ptr }, ptr %0, i32 0, i32 2
+  store i32 4, ptr %2, align 4
+  %3 = getelementptr inbounds { ptr, ptr, i32, ptr }, ptr %0, i32 0, i32 3
+  store ptr %itf.typecode, ptr %3, align 4
   call void @"internal/task.start"(i32 ptrtoint (ptr @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper" to i32), ptr nonnull %0, i32 65536, ptr undef) #9
   ret void
 }

goenv/version.go

@@ -9,7 +9,7 @@ import (
 
 // Version of TinyGo.
 // Update this value before release of new version of software.
-const version = "0.33.0"
+const version = "0.34.0-dev"
 
 var (
 	// This variable is set at build time using -ldflags parameters.