add signal stubs in runtime

Signed-off-by: leongross <[email protected]>

Author: leongross

GNUmakefile

@@ -335,6 +335,7 @@ TEST_PACKAGES_FAST = \
 	net/http/internal/ascii \
 	net/mail \
 	os \
+	os/signal \
 	path \
 	reflect \
 	sync \

src/os/exec.go

@@ -47,6 +47,10 @@ func (p *ProcessState) Sys() interface{} {
 	return nil // TODO
 }
 
+func (p *ProcessState) Exited() bool {
+	return false // TODO
+}
+
 // ExitCode returns the exit code of the exited process, or -1
 // if the process hasn't exited or was terminated by a signal.
 func (p *ProcessState) ExitCode() int {

src/os/signal/signal_linux.go

@@ -0,0 +1,54 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build !plan9 && !windows && !js && !wasm && !wasip1 && !wasip2
+// +build !plan9,!windows,!js,!wasm,!wasip1,!wasip2
+
+package signal
+
+import (
+	"os"
+	"syscall"
+)
+
+const (
+	numSig = 65 // max across all systems
+)
+
+type Signal interface {
+	String() string
+	Signal() // to distinguish from other Stringers
+}
+
+// Defined by the runtime package and used by syscall/sigqueue.go.
+func signal_disable(uint32)
+func signal_enable(uint32)
+func signal_ignore(uint32)
+func signal_ignored(uint32) bool
+func signal_recv() uint32
+
+func signum(sig os.Signal) int {
+	switch sig := sig.(type) {
+	case syscall.Signal:
+		i := int(sig)
+		if i < 0 || i >= numSig {
+			return -1
+		}
+		return i
+	default:
+		return -1
+	}
+}
+
+func enableSignal(sig int) {
+	signal_enable(uint32(sig))
+}
+
+func disableSignal(sig int) {
+	signal_disable(uint32(sig))
+}
+
+func ignoreSignal(sig int) {
+	signal_ignore(uint32(sig))
+}

src/os/signal/signal_linux_test.go

@@ -0,0 +1,30 @@
+//go:build !plan9 && !windows && !js && !wasm && !wasip1 && !wasip2
+// +build !plan9,!windows,!js,!wasm,!wasip1,!wasip2
+
+package signal
+
+import (
+	"runtime"
+	"testing"
+)
+
+// The file sigqueue.go contains preliminary stubs for signal handling.
+// Since tinygo ultimately lacks support for signals, these stubs are
+// placeholders for future work.
+// There might be userland applications that rely on these functions
+// from the upstream go package os/signal that we want to enable
+// building and linking.
+
+func TestSignalHandling(t *testing.T) {
+	if runtime.GOOS == "wasip1" || runtime.GOOS == "wasip2" {
+		t.Skip()
+	}
+
+	// This test is a placeholder for future work.
+	// It is here to ensure that the stubs in sigqueue.go
+	// are correctly linked and can be called from userland
+	// applications.
+	enableSignal(0)
+	disableSignal(0)
+	ignoreSignal(0)
+}

src/runtime/sigqueue.go

@@ -0,0 +1,26 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build !plan9
+// +build !plan9
+
+package runtime
+
+// Stub definitions copied from upstream golang
+// TODO: implement a minimal functional version of these functions
+
+// go: linkname os/signal.signal_disable signal_disable
+func signal_disable(_ uint32) {}
+
+// go: linkname os/signal.signal_enable signal_enable
+func signal_enable(_ uint32) {}
+
+// go: linkname os/signal.signal_ignore signal_ignore
+func signal_ignore(_ uint32) {}
+
+// go: linkname os/signal.signal_ignored signal_ignored
+func signal_ignored(_ uint32) bool { return true }
+
+// go: linkname os/signal.signal_recv signal_recv
+func signal_recv() uint32 { return 0 }

src/syscall/syscall_unix.go

@@ -1,5 +1,7 @@
 package syscall
 
+import "errors"
+
 func Exec(argv0 string, argv []string, envv []string) (err error)
 
 // The two SockaddrInet* structs have been copied from the Go source tree.
@@ -16,3 +18,54 @@ type SockaddrInet6 struct {
 	Addr   [16]byte
 	raw    RawSockaddrInet6
 }
+
+func Fork() (err error) {
+	fail := int(libc_fork())
+	if fail < 0 {
+		// TODO: parse the syscall return codes
+		return errors.New("fork failed")
+	}
+	return
+}
+
+// the golang standard library does not expose interfaces for execve and fork, so we define them here the same way via the libc wrapper
+func Execve(pathname string, argv []string, envv []string) (err error) {
+	argv0 := cstring(pathname)
+
+	// transform argv and envv into the format expected by execve
+	argv1 := make([]*byte, len(argv)+1)
+	for i, arg := range argv {
+		argv1[i] = &cstring(arg)[0]
+	}
+	argv1[len(argv)] = nil
+
+	env1 := make([]*byte, len(envv)+1)
+	for i, env := range envv {
+		env1[i] = &cstring(env)[0]
+	}
+	env1[len(envv)] = nil
+
+	fail := int(libc_execve(&argv0[0], &argv1[0], &env1[0]))
+	if fail < 0 {
+		// TODO: parse the syscall return codes
+		return errors.New("fork failed")
+	}
+	return
+}
+
+func cstring(s string) []byte {
+	data := make([]byte, len(s)+1)
+	copy(data, s)
+	// final byte should be zero from the initial allocation
+	return data
+}
+
+// pid_t fork(void);
+//
+//export fork
+func libc_fork() int32
+
+// int execve(const char *filename, char *const argv[], char *const envp[]);
+//
+//export execve
+func libc_execve(filename *byte, argv **byte, envp **byte) int