atsamd51 atsame5x: change to allow specifying the ADC Bus number

.circleci/config.yml

@@ -157,7 +157,7 @@ commands:
       - llvm-source-linux
       - restore_cache:
           keys:
-            - llvm-build-11-linux-v4-assert
+            - llvm-build-11-linux-v3-assert
       - run:
           name: "Build LLVM"
           command: |
@@ -176,7 +176,7 @@ commands:
               find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
             fi
       - save_cache:
-          key: llvm-build-11-linux-v4-assert
+          key: llvm-build-11-linux-v3-assert
           paths:
             llvm-build
       - run: make ASSERT=1
@@ -225,7 +225,7 @@ commands:
       - llvm-source-linux
       - restore_cache:
           keys:
-            - llvm-build-11-linux-v4-noassert
+            - llvm-build-11-linux-v3-noassert
       - run:
           name: "Build LLVM"
           command: |
@@ -244,7 +244,7 @@ commands:
               find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
             fi
       - save_cache:
-          key: llvm-build-11-linux-v4-noassert
+          key: llvm-build-11-linux-v3-noassert
           paths:
             llvm-build
       - build-wasi-libc
@@ -311,7 +311,7 @@ commands:
             - llvm-project/llvm/include
       - restore_cache:
           keys:
-            - llvm-build-11-macos-v5
+            - llvm-build-11-macos-v4
       - run:
           name: "Build LLVM"
           command: |
@@ -327,7 +327,7 @@ commands:
               find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
             fi
       - save_cache:
-          key: llvm-build-11-macos-v5
+          key: llvm-build-11-macos-v4
           paths:
             llvm-build
       - restore_cache:

.github/workflows/build-tinygo-dev-docker.yml

@@ -1,45 +0,0 @@
-name: CI for tinygo-dev docker container
-on:
-  push:
-    branches: [ dev ]
-
-jobs:
-  push_to_registry:
-    name: Push Docker image to GHCR/Docker Hub
-    runs-on: ubuntu-latest
-    permissions:
-      packages: write
-      contents: read
-    steps:
-      - name: Check out the repo
-        uses: actions/checkout@v2
-        with:
-          submodules: recursive
-      - name: Docker meta
-        id: meta
-        uses: docker/metadata-action@v3
-        with:
-          images: |
-            tinygo/tinygo-dev
-            ghcr.io/${{ github.repository }}/tinygo-dev
-          tags: |
-            type=sha,format=long
-            type=raw,value=latest
-      - name: Log in to Docker Hub
-        uses: docker/login-action@v1
-        with:
-          username: ${{ secrets.DOCKER_HUB_USERNAME }}
-          password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
-      - name: Log in to Github Container Registry
-        uses: docker/login-action@v1
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-      - name: Build and push
-        uses: docker/build-push-action@v2
-        with:
-          context: .
-          push: true
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}

.gitignore

@@ -16,8 +16,6 @@ src/device/stm32/*.go
 src/device/stm32/*.s
 src/device/kendryte/*.go
 src/device/kendryte/*.s
-src/device/rp/*.go
-src/device/rp/*.s
 vendor
 llvm-build
 llvm-project

CHANGELOG.md

@@ -1,191 +1,3 @@
-0.19.0
----
-
-* **command line**
-  - don't consider compile-only tests as failing
-  - add -test flag for `tinygo list`
-  - escape commands while printing them with the -x flag
-  - make flash-command portable and safer to use
-  - use `extended-remote` instead of `remote` in GDB
-  - detect specific serial port IDs based on USB vid/pid
-  - add a flag to the command line to select the serial implementation
-* **compiler**
-  - `cgo`: improve constant parser
-  - `compiler`: support chained interrupt handlers
-  - `compiler`: add support for running a builtin in a goroutine
-  - `compiler`: do not emit nil checks for loading closure variables
-  - `compiler`: skip context parameter when starting regular goroutine
-  - `compiler`: refactor method names
-  - `compiler`: add function and global section pragmas
-  - `compiler`: implement `syscall.rawSyscallNoError` in inline assembly
-  - `interp`: ignore inline assembly in markExternal
-  - `interp`: fix a bug in pointer cast workaround
-  - `loader`: fix testing a main package
-* **standard library**
-  - `crypto/rand`: replace this package with a TinyGo version
-  - `machine`: make USBCDC global a pointer
-  - `machine`: make UART objects pointer receivers
-  - `machine`: define Serial as the default output
-  - `net`: add initial support for net.IP
-  - `net`: add more net compatibility
-  - `os`: add stub for os.ReadDir
-  - `os`: add FileMode constants from Go 1.16
-  - `os`: add stubs required for net/http
-  - `os`: implement process related functions
-  - `reflect`: implement AppendSlice
-  - `reflect`: add stubs required for net/http
-  - `runtime`: make task.Data a 64-bit integer to avoid overflow
-  - `runtime`: expose memory stats
-  - `sync`: implement NewCond
-  - `syscall`: fix int type in libc version
-* **targets**
-  - `cortexm`: do not disable interrupts on abort
-  - `cortexm`: bump default stack size to 2048 bytes
-  - `nrf`: avoid heap allocation in waitForEvent
-  - `nrf`: don't trigger a heap allocation in SPI.Transfer
-  - `nrf52840`: add support for flashing with the BOSSA tool
-  - `rp2040`: add support for GPIO input
-  - `rp2040`: add basic support for ADC
-  - `rp2040`: gpio and adc pin definitions
-  - `rp2040`: implement UART
-  - `rp2040`: patch elf to checksum 2nd stage boot
-  - `stm32`: add PWM for most chips
-  - `stm32`: add support for pin interrupts
-  - `stm32f103`: add support for PinInputPullup / PinInputPulldown
-  - `wasi`: remove wasm build tag
-* **boards**
-  - `feather-rp2040`: add support for this board
-  - `feather-nrf52840-sense`: add board definition for this board
-  - `pca10059`: support flashing from Windows
-  - `nano-rp2040`: add this board
-  - `nano-33-ble`: add support for this board
-  - `pico`: add the Raspberry Pi Pico board with the new RP2040 chip
-  - `qtpy`: add pin for neopixels
-  - all: add definition for ws2812 for supported boards
-
-
-0.18.0
----
-
-* **command line**
-  - drop support for Go 1.11 and 1.12
-  - throw an error when no target is specified on Windows
-  - improve error messages in `getDefaultPort()`, support for multiple ports
-  - remove `-cflags` and `-ldflags` flags
-  - implement `-ldflags="-X ..."`
-  - add `-print-allocs` flag that lets you print all heap allocations
-  - openocd commands in tinygo command line
-  - add `-llvm-features` parameter
-  - match `go test` output
-  - discover USB ports only, this will ignore f.ex. bluetooth
-  - use physicmal path instead of cached GOROOT in function getGoroot
-  - add goroot for snap installs
-* **compiler**
-  - `builder`: add support for `-opt=0`
-  - `builder`, `compiler`: compile and cache packages in parallel
-  - `builder`: run interp per package
-  - `builder`: cache C and assembly file outputs
-  - `builder`: add support for `-x` flag to print commands
-  - `builder`: add optsize attribute while building the package
-  - `builder`: run function passes per package
-  - `builder`: hard code Clang compiler
-  - `compiler`: do not use `llvm.GlobalContext()`
-  - `compiler`: remove SimpleDCE pass
-  - `compiler`: do not emit nil checks for `*ssa.Alloc` instructions
-  - `compiler`: merge `runtime.typecodeID` and runtime.typeInInterface
-  - `compiler`: do not check for impossible type asserts
-  - `compiler`: fix use of global context: `llvm.Int32Type()`
-  - `compiler`: add interface IR test
-  - `compiler`: fix lack of method name in interface matching
-  - `compiler`: fix "fragment covers entire variable" bug
-  - `compiler`: optimize string literals and globals
-  - `compiler`: decouple func lowering from interface type codes
-  - `compiler`: add function attributes to some runtime calls
-  - `compiler`: improve position information in error messages
-  - `cgo`: add support for CFLAGS in .c files
-  - `interp`: support GEP on fixed (MMIO) addresses
-  - `interp`: handle `(reflect.Type).Elem()`
-  - `interp`: add support for runtime.interfaceMethod
-  - `interp`: make toLLVMValue return an error instead of panicking
-  - `interp`: add support for switch statement
-  - `interp`: fix phi instruction
-  - `interp`: remove map support
-  - `interp`: support extractvalue/insertvalue with multiple operands
-  - `transform`: optimize string comparisons against ""
-  - `transform`: optimize `reflect.Type` `Implements()` method
-  - `transform`: fix bug in interface lowering when signatures are renamed
-  - `transform`: don't rely on struct name of `runtime.typecodeID`
-  - `transform`: use IPSCCP pass instead of the constant propagation pass
-  - `transform`: fix func lowering assertion failure
-  - `transform`: do not lower zero-sized alloc to alloca
-  - `transform`: split interface and reflect lowering
-* **standard library**
-  - `runtime`: add dummy debug package
-  - `machine`: fix data shift/mask in newUSBSetup
-  - `machine`: make `machine.I2C0` and similar objects pointers
-  - `machine`: unify usbcdc code
-  - `machine`: refactor PWM support
-  - `machine`: avoid heap allocations in USB code
-  - `reflect`: let `reflect.Type` be of interface type
-  - `reflect`: implement a number of stub functions
-  - `reflect`: check for access in the `Interface` method call
-  - `reflect`: fix `AssignableTo` and `Implements` methods
-  - `reflect`: implement `Value.CanAddr`
-  - `reflect`: implement `Sizeof` and `Alignof` for func values
-  - `reflect`: implement `New` function
-  - `runtime`: implement command line arguments in hosted environments
-  - `runtime`: implement environment variables for Linux
-  - `runtime`: improve timers on nrf, and samd chips
-* **targets**
-  - all: use -Qunused-arguments only for assembly files
-  - `atmega1280`: add PWM support
-  - `attiny`: remove dummy UART
-  - `atsamd21`: improve SPI
-  - `atsamd51`: fix PWM support in atsamd51p20
-  - `atsamd5x`: improve SPI
-  - `atsamd51`, `atsame5x`: unify samd51 and same5x
-  - `atsamd51`, `atsamd21`: fix `ADC.Get()` value at 8bit and 10bit
-  - `atsame5x`: add support for CAN
-  - `avr`: remove I2C stubs from attiny support
-  - `cortexm`: check for `arm-none-eabi-gdb` and `gdb-multiarch` commands
-  - `cortexm`: add `__isr_vector` symbol
-  - `cortexm`: disable FPU on Cortex-M4
-  - `cortexm`: clean up Cortex-M target files
-  - `fe310`: fix SPI read
-  - `gameboy-advance`: Fix RGBA color interpretation
-  - `nrf52833`: add PWM support
-  - `stm32l0`: use unified UART logic
-  - `stm32`: move f103 (bluepill) to common i2c code
-  - `stm32`: separate altfunc selection for UART Tx/Rx
-  - `stm32`: i2c implementation for F7, L5 and L4 MCUs
-  - `stm32`: make SPI CLK fast to fix data issue
-  - `stm32`: support SPI on L4 series
-  - `unix`: avoid possible heap allocation with `-opt=0`
-  - `unix`: use conservative GC by default
-  - `unix`: use the tasks scheduler instead of coroutines
-  - `wasi`: upgrade WASI version to wasi_snapshot_preview1
-  - `wasi`: darwin: support basic file io based on libc
-  - `wasm`: only export explicitly exported functions
-  - `wasm`: use WASI ABI for exit function
-  - `wasm`: scan globals conservatively
-* **boards**
-  - `arduino-mega1280`: add support for the Arduino Mega 1280
-  - `arduino-nano-new`: Add Arduino Nano w/ New Bootloader target
-  - `atsame54-xpro`: add initial support this board
-  - `feather-m4-can`: add initial support for this board
-  - `grandcentral-m4`: add board support for Adafruit Grand Central M4 (SAMD51)
-  - `lgt92`: update to new UART structure
-  - `microbit`: remove LED constant
-  - `microbit-v2`: add support for S113 SoftDevice
-  - `nucleol432`: add support for this board
-  - `nucleo-l031k6`: add this board
-  - `pca10059`: initial support for this board
-  - `qtpy`: fix msd-volume-name
-  - `qtpy`: fix i2c setting
-  - `teensy40`: move txBuffer allocation to UART declaration
-  - `teensy40`: add UART0 as alias for UART1
-
-
 0.17.0
 
 ---

Dockerfile

@@ -1,5 +1,5 @@
-# TinyGo base stage installs the most recent Go 1.16.x, LLVM 11 and the TinyGo compiler itself.
-FROM golang:1.16 AS tinygo-base
+# TinyGo base stage installs the most recent Go 1.15.x, LLVM 11 and the TinyGo compiler itself.
+FROM golang:1.15 AS tinygo-base
 
 RUN wget -O- https://apt.llvm.org/llvm-snapshot.gpg.key| apt-key add - && \
     echo "deb http://apt.llvm.org/buster/ llvm-toolchain-buster-11 main" >> /etc/apt/sources.list && \

Makefile

@@ -36,7 +36,7 @@ else
     LLVM_OPTION += '-DLLVM_ENABLE_ASSERTIONS=OFF'
 endif
 
-.PHONY: all tinygo test $(LLVM_BUILDDIR) llvm-source clean fmt gen-device gen-device-nrf gen-device-nxp gen-device-avr gen-device-rp
+.PHONY: all tinygo test $(LLVM_BUILDDIR) llvm-source clean fmt gen-device gen-device-nrf gen-device-nxp gen-device-avr
 
 LLVM_COMPONENTS = all-targets analysis asmparser asmprinter bitreader bitwriter codegen core coroutines coverage debuginfodwarf executionengine frontendopenmp instrumentation interpreter ipo irreader linker lto mc mcjit objcarcopts option profiledata scalaropts support target
 
@@ -71,7 +71,7 @@ else
 endif
 
 # Libraries that should be linked in for the statically linked Clang.
-CLANG_LIB_NAMES = clangAnalysis clangAST clangASTMatchers clangBasic clangCodeGen clangCrossTU clangDriver clangDynamicASTMatchers clangEdit clangFormat clangFrontend clangFrontendTool clangHandleCXX clangHandleLLVM clangIndex clangLex clangParse clangRewrite clangRewriteFrontend clangSema clangSerialization clangTooling clangToolingASTDiff clangToolingCore clangToolingInclusions
+CLANG_LIB_NAMES = clangAnalysis clangARCMigrate clangAST clangASTMatchers clangBasic clangCodeGen clangCrossTU clangDriver clangDynamicASTMatchers clangEdit clangFormat clangFrontend clangFrontendTool clangHandleCXX clangHandleLLVM clangIndex clangLex clangParse clangRewrite clangRewriteFrontend clangSema clangSerialization clangStaticAnalyzerCheckers clangStaticAnalyzerCore clangStaticAnalyzerFrontend clangTooling clangToolingASTDiff clangToolingCore clangToolingInclusions
 CLANG_LIBS = $(START_GROUP) $(addprefix -l,$(CLANG_LIB_NAMES)) $(END_GROUP) -lstdc++
 
 # Libraries that should be linked in for the statically linked LLD.
@@ -107,7 +107,7 @@ fmt-check:
 	@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
+gen-device: gen-device-avr gen-device-esp gen-device-nrf gen-device-sam gen-device-sifive gen-device-kendryte gen-device-nxp
 ifneq ($(STM32), 0)
 gen-device: gen-device-stm32
 endif
@@ -150,9 +150,6 @@ gen-device-stm32: build/gen-device-svd
 	./build/gen-device-svd -source=https://github.com/tinygo-org/stm32-svd lib/stm32-svd/svd src/device/stm32/
 	GO111MODULE=off $(GO) fmt ./src/device/stm32
 
-gen-device-rp: build/gen-device-svd
-	./build/gen-device-svd -source=https://github.com/posborne/cmsis-svd/tree/master/data/RaspberryPi lib/cmsis-svd/data/RaspberryPi/ src/device/rp/
-	GO111MODULE=off $(GO) fmt ./src/device/rp
 
 # Get LLVM sources.
 $(LLVM_PROJECTDIR)/llvm:
@@ -162,7 +159,7 @@ llvm-source: $(LLVM_PROJECTDIR)/llvm
 # Configure LLVM.
 TINYGO_SOURCE_DIR=$(shell pwd)
 $(LLVM_BUILDDIR)/build.ninja: llvm-source
-	mkdir -p $(LLVM_BUILDDIR); cd $(LLVM_BUILDDIR); cmake -G Ninja $(TINYGO_SOURCE_DIR)/$(LLVM_PROJECTDIR)/llvm "-DLLVM_TARGETS_TO_BUILD=X86;ARM;AArch64;RISCV;WebAssembly" "-DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=AVR;Xtensa" -DCMAKE_BUILD_TYPE=Release -DLIBCLANG_BUILD_STATIC=ON -DLLVM_ENABLE_TERMINFO=OFF -DLLVM_ENABLE_ZLIB=OFF -DLLVM_ENABLE_LIBEDIT=OFF -DLLVM_ENABLE_Z3_SOLVER=OFF -DLLVM_ENABLE_OCAMLDOC=OFF -DLLVM_ENABLE_LIBXML2=OFF -DLLVM_ENABLE_PROJECTS="clang;lld" -DLLVM_TOOL_CLANG_TOOLS_EXTRA_BUILD=OFF -DCLANG_ENABLE_STATIC_ANALYZER=OFF -DCLANG_ENABLE_ARCMT=OFF $(LLVM_OPTION)
+	mkdir -p $(LLVM_BUILDDIR); cd $(LLVM_BUILDDIR); cmake -G Ninja $(TINYGO_SOURCE_DIR)/$(LLVM_PROJECTDIR)/llvm "-DLLVM_TARGETS_TO_BUILD=X86;ARM;AArch64;RISCV;WebAssembly" "-DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=AVR;Xtensa" -DCMAKE_BUILD_TYPE=Release -DLIBCLANG_BUILD_STATIC=ON -DLLVM_ENABLE_TERMINFO=OFF -DLLVM_ENABLE_ZLIB=OFF -DLLVM_ENABLE_LIBEDIT=OFF -DLLVM_ENABLE_Z3_SOLVER=OFF -DLLVM_ENABLE_OCAMLDOC=OFF -DLLVM_ENABLE_LIBXML2=OFF -DLLVM_ENABLE_PROJECTS="clang;lld" -DLLVM_TOOL_CLANG_TOOLS_EXTRA_BUILD=OFF $(LLVM_OPTION)
 
 # Build LLVM.
 $(LLVM_BUILDDIR): $(LLVM_BUILDDIR)/build.ninja
@@ -230,8 +227,6 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/mcp3008
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/memstats
-	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=microbit            examples/microbit-blink
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/pininterrupt
@@ -336,11 +331,9 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=feather-nrf52840  	examples/blinky1
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=feather-nrf52840-sense examples/blinky1
-	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=itsybitsy-nrf52840  examples/blinky1
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=qtpy                examples/serial
+	$(TINYGO) build -size short -o test.hex -target=qtpy  				examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=teensy40            examples/blinky1
 	@$(MD5SUM) test.hex
@@ -350,22 +343,8 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=atsame54-xpro       examples/blinky1
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=atsame54-xpro       examples/can
-	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=feather-m4-can      examples/blinky1
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=feather-m4-can      examples/caninterrupt
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=arduino-nano33      examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=pico                examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=nano-33-ble         examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=nano-rp2040         examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=feather-rp2040 		examples/blinky1
-	@$(MD5SUM) test.hex
 	# test pwm
 	$(TINYGO) build -size short -o test.hex -target=itsybitsy-m0        examples/pwm
 	@$(MD5SUM) test.hex
@@ -396,8 +375,6 @@ ifneq ($(STM32), 0)
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=stm32f4disco-1      examples/blinky1
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=stm32f4disco-1      examples/pwm
-	@$(MD5SUM) test.hex
 endif
 ifneq ($(AVR), 0)
 	$(TINYGO) build -size short -o test.hex -target=atmega1284p         examples/serial
@@ -438,8 +415,6 @@ endif
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10040 -opt=1     examples/blinky1
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=pca10040 -serial=none examples/echo
-	@$(MD5SUM) test.hex
 	$(TINYGO) build             -o test.nro -target=nintendoswitch      examples/serial
 	@$(MD5SUM) test.nro
 	$(TINYGO) build -size short -o test.hex -target=pca10040 -opt=0     ./testdata/stdlib.go

README.md

@@ -43,7 +43,7 @@ See the [getting started instructions](https://tinygo.org/getting-started/) for
 
 You can compile TinyGo programs for microcontrollers, WebAssembly and Linux.
 
-The following 68 microcontroller boards are currently supported:
+The following 57 microcontroller boards are currently supported:
 
 * [Adafruit Circuit Playground Bluefruit](https://www.adafruit.com/product/4333)
 * [Adafruit Circuit Playground Express](https://www.adafruit.com/product/3333)
@@ -52,10 +52,7 @@ The following 68 microcontroller boards are currently supported:
 * [Adafruit Feather M4](https://www.adafruit.com/product/3857)
 * [Adafruit Feather M4 CAN](https://www.adafruit.com/product/4759)
 * [Adafruit Feather nRF52840 Express](https://www.adafruit.com/product/4062)
-* [Adafruit Feather nRF52840 Sense](https://www.adafruit.com/product/4516)
-* [Adafruit Feather RP2040](https://www.adafruit.com/product/4884)
 * [Adafruit Feather STM32F405 Express](https://www.adafruit.com/product/4382)
-* [Adafruit Grand Central M4](https://www.adafruit.com/product/4064)
 * [Adafruit ItsyBitsy M0](https://www.adafruit.com/product/3727)
 * [Adafruit ItsyBitsy M4](https://www.adafruit.com/product/3800)
 * [Adafruit ItsyBitsy nRF52840](https://www.adafruit.com/product/4481)
@@ -66,14 +63,10 @@ The following 68 microcontroller boards are currently supported:
 * [Adafruit PyPortal](https://www.adafruit.com/product/4116)
 * [Adafruit QT Py](https://www.adafruit.com/product/4600)
 * [Adafruit Trinket M0](https://www.adafruit.com/product/3500)
-* [Arduino Mega 1280](https://www.arduino.cc/en/Main/arduinoBoardMega/)
 * [Arduino Mega 2560](https://store.arduino.cc/arduino-mega-2560-rev3)
 * [Arduino MKR1000](https://store.arduino.cc/arduino-mkr1000-wifi)
 * [Arduino Nano](https://store.arduino.cc/arduino-nano)
-* [Arduino Nano 33 BLE](https://store.arduino.cc/nano-33-ble)
-* [Arduino Nano 33 BLE Sense](https://store.arduino.cc/nano-33-ble-sense)
-* [Arduino Nano 33 IoT](https://store.arduino.cc/nano-33-iot)
-* [Arduino Nano RP2040 Connect](https://store.arduino.cc/nano-rp2040-connect)
+* [Arduino Nano33 IoT](https://store.arduino.cc/nano-33-iot)
 * [Arduino Uno](https://store.arduino.cc/arduino-uno-rev3)
 * [Arduino Zero](https://store.arduino.cc/usa/arduino-zero)
 * [BBC micro:bit](https://microbit.org/)
@@ -91,7 +84,6 @@ The following 68 microcontroller boards are currently supported:
 * [Nordic Semiconductor PCA10031](https://www.nordicsemi.com/eng/Products/nRF51-Dongle)
 * [Nordic Semiconductor PCA10040](https://www.nordicsemi.com/eng/Products/Bluetooth-low-energy/nRF52-DK)
 * [Nordic Semiconductor PCA10056](https://www.nordicsemi.com/Software-and-Tools/Development-Kits/nRF52840-DK)
-* [Nordic Semiconductor pca10059](https://www.nordicsemi.com/Software-and-tools/Development-Kits/nRF52840-Dongle)
 * [Particle Argon](https://docs.particle.io/datasheets/wi-fi/argon-datasheet/)
 * [Particle Boron](https://docs.particle.io/datasheets/cellular/boron-datasheet/)
 * [Particle Xenon](https://docs.particle.io/datasheets/discontinued/xenon-datasheet/)
@@ -100,15 +92,12 @@ The following 68 microcontroller boards are currently supported:
 * [PJRC Teensy 3.6](https://www.pjrc.com/store/teensy36.html)
 * [PJRC Teensy 4.0](https://www.pjrc.com/store/teensy40.html)
 * [ProductivityOpen P1AM-100](https://facts-engineering.github.io/modules/P1AM-100/P1AM-100.html)
-* [Raspberry Pi Pico](https://www.raspberrypi.org/products/raspberry-pi-pico/)
 * [Seeed Wio Terminal](https://www.seeedstudio.com/Wio-Terminal-p-4509.html)
 * [Seeed Seeeduino XIAO](https://www.seeedstudio.com/Seeeduino-XIAO-Arduino-Microcontroller-SAMD21-Cortex-M0+-p-4426.html)
 * [Seeed Sipeed MAix BiT](https://www.seeedstudio.com/Sipeed-MAix-BiT-for-RISC-V-AI-IoT-p-2872.html)
 * [SiFIve HiFive1](https://www.sifive.com/boards/hifive1)
 * [ST Micro "Nucleo" F103RB](https://www.st.com/en/evaluation-tools/nucleo-f103rb.html)
 * [ST Micro "Nucleo" F722ZE](https://www.st.com/en/evaluation-tools/nucleo-f722ze.html)
-* [ST Micro "Nucleo" L031K6](https://www.st.com/ja/evaluation-tools/nucleo-l031k6.html)
-* [ST Micro "Nucleo" L432KC](https://www.st.com/ja/evaluation-tools/nucleo-l432kc.html)
 * [ST Micro "Nucleo" L552ZE](https://www.st.com/en/evaluation-tools/nucleo-l552ze-q.html)
 * [ST Micro STM32F103XX "Bluepill"](https://stm32-base.org/boards/STM32F103C8T6-Blue-Pill)
 * [ST Micro STM32F407 "Discovery"](https://www.st.com/en/evaluation-tools/stm32f4discovery.html)

azure-pipelines.yml

@@ -28,7 +28,7 @@ jobs:
     - task: CacheBeta@0
       displayName: Cache LLVM build
       inputs:
-        key: llvm-build-11-windows-v5
+        key: llvm-build-11-windows-v4
         path: llvm-build
     - task: Bash@3
       displayName: Build LLVM

builder/build.go

@@ -12,9 +12,7 @@ import (
 	"errors"
 	"fmt"
 	"go/types"
-	"hash/crc32"
 	"io/ioutil"
-	"math/bits"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -549,8 +547,8 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 				}
 				ldflags = append(ldflags, dependency.result)
 			}
-			if config.Options.PrintCommands != nil {
-				config.Options.PrintCommands(config.Target.Linker, ldflags...)
+			if config.Options.PrintCommands {
+				fmt.Printf("%s %s\n", config.Target.Linker, strings.Join(ldflags, " "))
 			}
 			err = link(config.Target.Linker, ldflags...)
 			if err != nil {
@@ -568,8 +566,6 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 					return err
 				}
 			}
-
-			// Apply ELF patches
 			if config.AutomaticStackSize() {
 				// Modify the .tinygo_stacksizes section that contains a stack size
 				// for each goroutine.
@@ -578,13 +574,6 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 					return fmt.Errorf("could not modify stack sizes: %w", err)
 				}
 			}
-			if config.RP2040BootPatch() {
-				// Patch the second stage bootloader CRC into the .boot2 section
-				err = patchRP2040BootCRC(executable)
-				if err != nil {
-					return fmt.Errorf("could not patch RP2040 second stage boot loader: %w", err)
-				}
-			}
 
 			if config.Options.PrintSizes == "short" || config.Options.PrintSizes == "full" {
 				sizes, err := loadProgramSize(executable)
@@ -650,18 +639,6 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		if err != nil {
 			return err
 		}
-	case "nrf-dfu":
-		// special format for nrfutil for Nordic chips
-		tmphexpath := filepath.Join(dir, "main.hex")
-		err := objcopy(executable, tmphexpath, "hex")
-		if err != nil {
-			return err
-		}
-		tmppath = filepath.Join(dir, "main"+outext)
-		err = makeDFUFirmwareImage(config.Options, tmphexpath, tmppath)
-		if err != nil {
-			return err
-		}
 	default:
 		return fmt.Errorf("unknown output binary format: %s", outputBinaryFormat)
 	}
@@ -931,7 +908,30 @@ func determineStackSizes(mod llvm.Module, executable string) ([]string, map[stri
 // stack size information. Before this modification, all stack sizes in the
 // section assume the default stack size (which is relatively big).
 func modifyStackSizes(executable string, stackSizeLoads []string, stackSizes map[string]functionStackSize) error {
-	data, fileHeader, err := getElfSectionData(executable, ".tinygo_stacksizes")
+	fp, err := os.OpenFile(executable, os.O_RDWR, 0)
+	if err != nil {
+		return err
+	}
+	defer fp.Close()
+
+	elfFile, err := elf.NewFile(fp)
+	if err != nil {
+		return err
+	}
+
+	section := elfFile.Section(".tinygo_stacksizes")
+	if section == nil {
+		return errors.New("could not find .tinygo_stacksizes section")
+	}
+
+	if section.Size != section.FileSize {
+		// Sanity check.
+		return fmt.Errorf("expected .tinygo_stacksizes to have identical size and file size, got %d and %d", section.Size, section.FileSize)
+	}
+
+	// Read all goroutine stack sizes.
+	data := make([]byte, section.Size)
+	_, err = fp.ReadAt(data, int64(section.Offset))
 	if err != nil {
 		return err
 	}
@@ -953,19 +953,15 @@ func modifyStackSizes(executable string, stackSizeLoads []string, stackSizes map
 		if fn.stackSizeType == stacksize.Bounded {
 			stackSize := uint32(fn.stackSize)
 
-			// Add stack size used by interrupts.
-			switch fileHeader.Machine {
-			case elf.EM_ARM:
-				if stackSize%8 != 0 {
-					// If the stack isn't a multiple of 8, it means the leaf
-					// function with the biggest stack depth doesn't have an aligned
-					// stack. If the STKALIGN flag is set (which it is by default)
-					// the interrupt controller will forcibly align the stack before
-					// storing in-use registers. This will thus overwrite one word
-					// past the end of the stack (off-by-one).
-					stackSize += 4
-				}
+			// Adding 4 for the stack canary. Even though the size may be
+			// automatically determined, stack overflow checking is still
+			// important as the stack size cannot be determined for all
+			// goroutines.
+			stackSize += 4
 
+			// Add stack size used by interrupts.
+			switch elfFile.Machine {
+			case elf.EM_ARM:
 				// On Cortex-M (assumed here), this stack size is 8 words or 32
 				// bytes. This is only to store the registers that the interrupt
 				// may modify, the interrupt will switch to the interrupt stack
@@ -973,14 +969,6 @@ func modifyStackSizes(executable string, stackSizeLoads []string, stackSizes map
 				// Some background:
 				// https://interrupt.memfault.com/blog/cortex-m-rtos-context-switching
 				stackSize += 32
-
-				// Adding 4 for the stack canary, and another 4 to keep the
-				// stack aligned. Even though the size may be automatically
-				// determined, stack overflow checking is still important as the
-				// stack size cannot be determined for all goroutines.
-				stackSize += 8
-			default:
-				return fmt.Errorf("unknown architecture: %s", fileHeader.Machine.String())
 			}
 
 			// Finally write the stack size to the binary.
@@ -988,7 +976,13 @@ func modifyStackSizes(executable string, stackSizeLoads []string, stackSizes map
 		}
 	}
 
-	return replaceElfSection(executable, ".tinygo_stacksizes", data)
+	// Write back the modified stack sizes.
+	_, err = fp.WriteAt(data, int64(section.Offset))
+	if err != nil {
+		return err
+	}
+
+	return nil
 }
 
 // printStacks prints the maximum stack depth for functions that are started as
@@ -1020,41 +1014,3 @@ func printStacks(calculatedStacks []string, stackSizes map[string]functionStackS
 		}
 	}
 }
-
-// RP2040 second stage bootloader CRC32 calculation
-//
-// Spec: https://datasheets.raspberrypi.org/rp2040/rp2040-datasheet.pdf
-// Section: 2.8.1.3.1. Checksum
-func patchRP2040BootCRC(executable string) error {
-	bytes, _, err := getElfSectionData(executable, ".boot2")
-	if err != nil {
-		return err
-	}
-
-	if len(bytes) != 256 {
-		return fmt.Errorf("rp2040 .boot2 section must be exactly 256 bytes")
-	}
-
-	// From the 'official' RP2040 checksum script:
-	//
-	//  Our bootrom CRC32 is slightly bass-ackward but it's
-	//  best to work around for now (FIXME)
-	//  100% worth it to save two Thumb instructions
-	revBytes := make([]byte, len(bytes))
-	for i := range bytes {
-		revBytes[i] = bits.Reverse8(bytes[i])
-	}
-
-	// crc32.Update does an initial negate and negates the
-	// result, so to meet RP2040 spec, pass 0x0 as initial
-	// hash and negate returned value.
-	//
-	// Note: checksum is over 252 bytes (256 - 4)
-	hash := bits.Reverse32(crc32.Update(0x0, crc32.IEEETable, revBytes[:252]) ^ 0xFFFFFFFF)
-
-	// Write the CRC to the end of the bootloader.
-	binary.LittleEndian.PutUint32(bytes[252:], hash)
-
-	// Update the .boot2 section to included the CRC
-	return replaceElfSection(executable, ".boot2", bytes)
-}

builder/cc.go

@@ -56,7 +56,7 @@ import (
 //   depfile but without invalidating its name. For this reason, the depfile is
 //   written on each new compilation (even when it seems unnecessary). However, it
 //   could in rare cases lead to a stale file fetched from the cache.
-func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands func(string, ...string)) (string, error) {
+func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands bool) (string, error) {
 	// Hash input file.
 	fileHash, err := hashFile(abspath)
 	if err != nil {
@@ -128,8 +128,8 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands
 		// flags (for the assembler) is a compiler error.
 		flags = append(flags, "-Qunused-arguments")
 	}
-	if printCommands != nil {
-		printCommands("clang", flags...)
+	if printCommands {
+		fmt.Printf("clang %s\n", strings.Join(flags, " "))
 	}
 	err = runCCompiler(flags...)
 	if err != nil {

builder/elfpatch.go

@@ -1,57 +0,0 @@
-package builder
-
-import (
-	"debug/elf"
-	"fmt"
-	"os"
-)
-
-func getElfSectionData(executable string, sectionName string) ([]byte, elf.FileHeader, error) {
-	elfFile, err := elf.Open(executable)
-	if err != nil {
-		return nil, elf.FileHeader{}, err
-	}
-	defer elfFile.Close()
-
-	section := elfFile.Section(sectionName)
-	if section == nil {
-		return nil, elf.FileHeader{}, fmt.Errorf("could not find %s section", sectionName)
-	}
-
-	data, err := section.Data()
-
-	return data, elfFile.FileHeader, err
-}
-
-func replaceElfSection(executable string, sectionName string, data []byte) error {
-	fp, err := os.OpenFile(executable, os.O_RDWR, 0)
-	if err != nil {
-		return err
-	}
-	defer fp.Close()
-
-	elfFile, err := elf.Open(executable)
-	if err != nil {
-		return err
-	}
-	defer elfFile.Close()
-
-	section := elfFile.Section(sectionName)
-	if section == nil {
-		return fmt.Errorf("could not find %s section", sectionName)
-	}
-
-	// Implicitly check for compressed sections
-	if section.Size != section.FileSize {
-		return fmt.Errorf("expected section %s to have identical size and file size, got %d and %d", sectionName, section.Size, section.FileSize)
-	}
-
-	// Only permit complete replacement of section
-	if section.Size != uint64(len(data)) {
-		return fmt.Errorf("expected section %s to have size %d, was actually %d", sectionName, len(data), section.Size)
-	}
-
-	// Write the replacement section data
-	_, err = fp.WriteAt(data, int64(section.Offset))
-	return err
-}

builder/nrfutil.go

@@ -1,27 +0,0 @@
-package builder
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os/exec"
-
-	"github.com/tinygo-org/tinygo/compileopts"
-)
-
-// https://infocenter.nordicsemi.com/index.jsp?topic=%2Fug_nrfutil%2FUG%2Fnrfutil%2Fnrfutil_intro.html
-
-func makeDFUFirmwareImage(options *compileopts.Options, infile, outfile string) error {
-	cmdLine := []string{"nrfutil", "pkg", "generate", "--hw-version", "52", "--sd-req", "0x0", "--debug-mode", "--application", infile, outfile}
-
-	if options.PrintCommands != nil {
-		options.PrintCommands(cmdLine[0], cmdLine[1:]...)
-	}
-
-	cmd := exec.Command(cmdLine[0], cmdLine[1:]...)
-	cmd.Stdout = ioutil.Discard
-	err := cmd.Run()
-	if err != nil {
-		return fmt.Errorf("could not run nrfutil pkg generate: %w", err)
-	}
-	return nil
-}

cgo/const.go

@@ -11,184 +11,105 @@ import (
 	"strings"
 )
 
-var (
-	prefixParseFns map[token.Token]func(*tokenizer) (ast.Expr, *scanner.Error)
-	precedences    = map[token.Token]int{
-		token.ADD: precedenceAdd,
-		token.SUB: precedenceAdd,
-		token.MUL: precedenceMul,
-		token.QUO: precedenceMul,
-		token.REM: precedenceMul,
-	}
-)
-
-const (
-	precedenceLowest = iota + 1
-	precedenceAdd
-	precedenceMul
-	precedencePrefix
-)
-
-func init() {
-	// This must be done in an init function to avoid an initialization order
-	// failure.
-	prefixParseFns = map[token.Token]func(*tokenizer) (ast.Expr, *scanner.Error){
-		token.IDENT:  parseIdent,
-		token.INT:    parseBasicLit,
-		token.FLOAT:  parseBasicLit,
-		token.STRING: parseBasicLit,
-		token.CHAR:   parseBasicLit,
-		token.LPAREN: parseParenExpr,
-		token.SUB:    parseUnaryExpr,
-	}
-}
-
 // parseConst parses the given string as a C constant.
 func parseConst(pos token.Pos, fset *token.FileSet, value string) (ast.Expr, *scanner.Error) {
 	t := newTokenizer(pos, fset, value)
-	expr, err := parseConstExpr(t, precedenceLowest)
-	t.Next()
-	if t.curToken != token.EOF {
+	expr, err := parseConstExpr(t)
+	if t.token != token.EOF {
 		return nil, &scanner.Error{
-			Pos: t.fset.Position(t.curPos),
-			Msg: "unexpected token " + t.curToken.String() + ", expected end of expression",
+			Pos: t.fset.Position(t.pos),
+			Msg: "unexpected token " + t.token.String(),
 		}
 	}
 	return expr, err
 }
 
 // parseConstExpr parses a stream of C tokens to a Go expression.
-func parseConstExpr(t *tokenizer, precedence int) (ast.Expr, *scanner.Error) {
-	if t.curToken == token.EOF {
+func parseConstExpr(t *tokenizer) (ast.Expr, *scanner.Error) {
+	switch t.token {
+	case token.LPAREN:
+		lparen := t.pos
+		t.Next()
+		x, err := parseConstExpr(t)
+		if err != nil {
+			return nil, err
+		}
+		if t.token != token.RPAREN {
+			return nil, unexpectedToken(t, token.RPAREN)
+		}
+		expr := &ast.ParenExpr{
+			Lparen: lparen,
+			X:      x,
+			Rparen: t.pos,
+		}
+		t.Next()
+		return expr, nil
+	case token.INT, token.FLOAT, token.STRING, token.CHAR:
+		expr := &ast.BasicLit{
+			ValuePos: t.pos,
+			Kind:     t.token,
+			Value:    t.value,
+		}
+		t.Next()
+		return expr, nil
+	case token.IDENT:
+		expr := &ast.Ident{
+			NamePos: t.pos,
+			Name:    "C." + t.value,
+		}
+		t.Next()
+		return expr, nil
+	case token.EOF:
 		return nil, &scanner.Error{
-			Pos: t.fset.Position(t.curPos),
+			Pos: t.fset.Position(t.pos),
 			Msg: "empty constant",
 		}
-	}
-	prefix := prefixParseFns[t.curToken]
-	if prefix == nil {
+	default:
 		return nil, &scanner.Error{
-			Pos: t.fset.Position(t.curPos),
-			Msg: fmt.Sprintf("unexpected token %s", t.curToken),
+			Pos: t.fset.Position(t.pos),
+			Msg: fmt.Sprintf("unexpected token %s", t.token),
 		}
 	}
-	leftExpr, err := prefix(t)
-
-	for t.peekToken != token.EOF && precedence < precedences[t.peekToken] {
-		switch t.peekToken {
-		case token.ADD, token.SUB, token.MUL, token.QUO, token.REM:
-			t.Next()
-			leftExpr, err = parseBinaryExpr(t, leftExpr)
-		}
-	}
-
-	return leftExpr, err
-}
-
-func parseIdent(t *tokenizer) (ast.Expr, *scanner.Error) {
-	return &ast.Ident{
-		NamePos: t.curPos,
-		Name:    "C." + t.curValue,
-	}, nil
-}
-
-func parseBasicLit(t *tokenizer) (ast.Expr, *scanner.Error) {
-	return &ast.BasicLit{
-		ValuePos: t.curPos,
-		Kind:     t.curToken,
-		Value:    t.curValue,
-	}, nil
-}
-
-func parseParenExpr(t *tokenizer) (ast.Expr, *scanner.Error) {
-	lparen := t.curPos
-	t.Next()
-	x, err := parseConstExpr(t, precedenceLowest)
-	if err != nil {
-		return nil, err
-	}
-	t.Next()
-	if t.curToken != token.RPAREN {
-		return nil, unexpectedToken(t, token.RPAREN)
-	}
-	expr := &ast.ParenExpr{
-		Lparen: lparen,
-		X:      x,
-		Rparen: t.curPos,
-	}
-	return expr, nil
-}
-
-func parseBinaryExpr(t *tokenizer, left ast.Expr) (ast.Expr, *scanner.Error) {
-	expression := &ast.BinaryExpr{
-		X:     left,
-		Op:    t.curToken,
-		OpPos: t.curPos,
-	}
-	precedence := precedences[t.curToken]
-	t.Next()
-	right, err := parseConstExpr(t, precedence)
-	expression.Y = right
-	return expression, err
-}
-
-func parseUnaryExpr(t *tokenizer) (ast.Expr, *scanner.Error) {
-	expression := &ast.UnaryExpr{
-		OpPos: t.curPos,
-		Op:    t.curToken,
-	}
-	t.Next()
-	x, err := parseConstExpr(t, precedencePrefix)
-	expression.X = x
-	return expression, err
 }
 
 // unexpectedToken returns an error of the form "unexpected token FOO, expected
 // BAR".
 func unexpectedToken(t *tokenizer, expected token.Token) *scanner.Error {
 	return &scanner.Error{
-		Pos: t.fset.Position(t.curPos),
-		Msg: fmt.Sprintf("unexpected token %s, expected %s", t.curToken, expected),
+		Pos: t.fset.Position(t.pos),
+		Msg: fmt.Sprintf("unexpected token %s, expected %s", t.token, expected),
 	}
 }
 
 // tokenizer reads C source code and converts it to Go tokens.
 type tokenizer struct {
-	curPos, peekPos     token.Pos
-	fset                *token.FileSet
-	curToken, peekToken token.Token
-	curValue, peekValue string
-	buf                 string
+	pos   token.Pos
+	fset  *token.FileSet
+	token token.Token
+	value string
+	buf   string
 }
 
 // newTokenizer initializes a new tokenizer, positioned at the first token in
 // the string.
 func newTokenizer(start token.Pos, fset *token.FileSet, buf string) *tokenizer {
 	t := &tokenizer{
-		peekPos:   start,
-		fset:      fset,
-		buf:       buf,
-		peekToken: token.ILLEGAL,
+		pos:   start,
+		fset:  fset,
+		buf:   buf,
+		token: token.ILLEGAL,
 	}
-	// Parse the first two tokens (cur and peek).
-	t.Next()
-	t.Next()
+	t.Next() // Parse the first token.
 	return t
 }
 
 // Next consumes the next token in the stream. There is no return value, read
 // the next token from the pos, token and value properties.
 func (t *tokenizer) Next() {
-	// The previous peek is now the current token.
-	t.curPos = t.peekPos
-	t.curToken = t.peekToken
-	t.curValue = t.peekValue
-
-	// Parse the next peek token.
-	t.peekPos += token.Pos(len(t.curValue))
+	t.pos += token.Pos(len(t.value))
 	for {
 		if len(t.buf) == 0 {
-			t.peekToken = token.EOF
+			t.token = token.EOF
 			return
 		}
 		c := t.buf[0]
@@ -197,28 +118,17 @@ func (t *tokenizer) Next() {
 			// Skip whitespace.
 			// Based on this source, not sure whether it represents C whitespace:
 			// https://en.cppreference.com/w/cpp/string/byte/isspace
-			t.peekPos++
+			t.pos++
 			t.buf = t.buf[1:]
-		case c == '(' || c == ')' || c == '+' || c == '-' || c == '*' || c == '/' || c == '%':
+		case c == '(' || c == ')':
 			// Single-character tokens.
-			// TODO: ++ (increment) and -- (decrement) operators.
 			switch c {
 			case '(':
-				t.peekToken = token.LPAREN
+				t.token = token.LPAREN
 			case ')':
-				t.peekToken = token.RPAREN
-			case '+':
-				t.peekToken = token.ADD
-			case '-':
-				t.peekToken = token.SUB
-			case '*':
-				t.peekToken = token.MUL
-			case '/':
-				t.peekToken = token.QUO
-			case '%':
-				t.peekToken = token.REM
+				t.token = token.RPAREN
 			}
-			t.peekValue = t.buf[:1]
+			t.value = t.buf[:1]
 			t.buf = t.buf[1:]
 			return
 		case c >= '0' && c <= '9':
@@ -236,17 +146,17 @@ func (t *tokenizer) Next() {
 					break
 				}
 			}
-			t.peekValue = t.buf[:tokenLen]
+			t.value = t.buf[:tokenLen]
 			t.buf = t.buf[tokenLen:]
 			if hasDot {
 				// Integer constants are more complicated than this but this is
 				// a close approximation.
 				// https://en.cppreference.com/w/cpp/language/integer_literal
-				t.peekToken = token.FLOAT
-				t.peekValue = strings.TrimRight(t.peekValue, "f")
+				t.token = token.FLOAT
+				t.value = strings.TrimRight(t.value, "f")
 			} else {
-				t.peekToken = token.INT
-				t.peekValue = strings.TrimRight(t.peekValue, "uUlL")
+				t.token = token.INT
+				t.value = strings.TrimRight(t.value, "uUlL")
 			}
 			return
 		case c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z' || c == '_':
@@ -260,9 +170,9 @@ func (t *tokenizer) Next() {
 					break
 				}
 			}
-			t.peekValue = t.buf[:tokenLen]
+			t.value = t.buf[:tokenLen]
 			t.buf = t.buf[tokenLen:]
-			t.peekToken = token.IDENT
+			t.token = token.IDENT
 			return
 		case c == '"':
 			// String constant. Find the first '"' character that is not
@@ -278,8 +188,8 @@ func (t *tokenizer) Next() {
 					escape = c == '\\'
 				}
 			}
-			t.peekToken = token.STRING
-			t.peekValue = t.buf[:tokenLen]
+			t.token = token.STRING
+			t.value = t.buf[:tokenLen]
 			t.buf = t.buf[tokenLen:]
 			return
 		case c == '\'':
@@ -296,12 +206,12 @@ func (t *tokenizer) Next() {
 					escape = c == '\\'
 				}
 			}
-			t.peekToken = token.CHAR
-			t.peekValue = t.buf[:tokenLen]
+			t.token = token.CHAR
+			t.value = t.buf[:tokenLen]
 			t.buf = t.buf[tokenLen:]
 			return
 		default:
-			t.peekToken = token.ILLEGAL
+			t.token = token.ILLEGAL
 			return
 		}
 	}

cgo/const_test.go

@@ -18,7 +18,7 @@ func TestParseConst(t *testing.T) {
 		{`(5)`, `(5)`},
 		{`(((5)))`, `(5)`},
 		{`)`, `error: 1:1: unexpected token )`},
-		{`5)`, `error: 1:2: unexpected token ), expected end of expression`},
+		{`5)`, `error: 1:2: unexpected token )`},
 		{"  \t)", `error: 1:4: unexpected token )`},
 		{`5.8f`, `5.8`},
 		{`foo`, `C.foo`},
@@ -30,24 +30,7 @@ func TestParseConst(t *testing.T) {
 		{`'a'`, `'a'`},
 		{`0b10`, `0b10`},
 		{`0x1234_5678`, `0x1234_5678`},
-		{`5 5`, `error: 1:3: unexpected token INT, expected end of expression`}, // test for a bugfix
-		// Binary operators.
-		{`5+5`, `5 + 5`},
-		{`5-5`, `5 - 5`},
-		{`5*5`, `5 * 5`},
-		{`5/5`, `5 / 5`},
-		{`5%5`, `5 % 5`},
-		{`(5/5)`, `(5 / 5)`},
-		{`1 - 2`, `1 - 2`},
-		{`1 - 2 + 3`, `1 - 2 + 3`},
-		{`1 - 2 * 3`, `1 - 2*3`},
-		{`(1 - 2) * 3`, `(1 - 2) * 3`},
-		{`1 * 2 - 3`, `1*2 - 3`},
-		{`1 * (2 - 3)`, `1 * (2 - 3)`},
-		// Unary operators.
-		{`-5`, `-5`},
-		{`-5-2`, `-5 - 2`},
-		{`5 - - 2`, `5 - -2`},
+		{`5 5`, `error: 1:3: unexpected token INT`}, // test for a bugfix
 	} {
 		fset := token.NewFileSet()
 		startPos := fset.AddFile("", -1, 1000).Pos(0)

cgo/testdata/errors.out.go

@@ -1,7 +1,7 @@
 // CGo errors:
 //     testdata/errors.go:4:2: warning: some warning
 //     testdata/errors.go:11:9: error: unknown type name 'someType'
-//     testdata/errors.go:13:23: unexpected token ), expected end of expression
+//     testdata/errors.go:13:23: unexpected token )
 
 // Type checking errors after CGo processing:
 //     testdata/errors.go:102: cannot use 2 << 10 (untyped int constant 2048) as uint8 value in variable declaration (overflows)

compileopts/config.go

@@ -55,7 +55,7 @@ func (c *Config) GOARCH() string {
 
 // BuildTags returns the complete list of build tags used during this build.
 func (c *Config) BuildTags() []string {
-	tags := append(c.Target.BuildTags, []string{"tinygo", "gc." + c.GC(), "scheduler." + c.Scheduler(), "serial." + c.Serial()}...)
+	tags := append(c.Target.BuildTags, []string{"tinygo", "gc." + c.GC(), "scheduler." + c.Scheduler()}...)
 	for i := 1; i <= c.GoMinorVersion; i++ {
 		tags = append(tags, fmt.Sprintf("go1.%d", i))
 	}
@@ -89,7 +89,7 @@ func (c *Config) NeedsStackObjects() bool {
 	switch c.GC() {
 	case "conservative", "extalloc":
 		for _, tag := range c.BuildTags() {
-			if tag == "tinygo.wasm" {
+			if tag == "wasm" {
 				return true
 			}
 		}
@@ -113,18 +113,6 @@ func (c *Config) Scheduler() string {
 	return "coroutines"
 }
 
-// Serial returns the serial implementation for this build configuration: uart,
-// usb (meaning USB-CDC), or none.
-func (c *Config) Serial() string {
-	if c.Options.Serial != "" {
-		return c.Options.Serial
-	}
-	if c.Target.Serial != "" {
-		return c.Target.Serial
-	}
-	return "none"
-}
-
 // OptLevels returns the optimization level (0-2), size level (0-2), and inliner
 // threshold as used in the LLVM optimization pipeline.
 func (c *Config) OptLevels() (optLevel, sizeLevel int, inlinerThreshold uint) {
@@ -188,15 +176,6 @@ func (c *Config) AutomaticStackSize() bool {
 	return false
 }
 
-// RP2040BootPatch returns whether the RP2040 boot patch should be applied that
-// calculates and patches in the checksum for the 2nd stage bootloader.
-func (c *Config) RP2040BootPatch() bool {
-	if c.Target.RP2040BootPatch != nil {
-		return *c.Target.RP2040BootPatch
-	}
-	return false
-}
-
 // CFlags returns the flags to pass to the C compiler. This is necessary for CGo
 // preprocessing.
 func (c *Config) CFlags() []string {
@@ -275,11 +254,6 @@ func (c *Config) BinaryFormat(ext string) string {
 		// More information:
 		// https://github.com/Microsoft/uf2
 		return "uf2"
-	case ".zip":
-		if c.Target.BinaryFormat != "" {
-			return c.Target.BinaryFormat
-		}
-		return "zip"
 	default:
 		// Use the ELF format for unrecognized file formats.
 		return "elf"

compileopts/options.go

@@ -9,7 +9,6 @@ import (
 var (
 	validGCOptions            = []string{"none", "leaking", "extalloc", "conservative"}
 	validSchedulerOptions     = []string{"none", "tasks", "coroutines"}
-	validSerialOptions        = []string{"none", "uart", "usb"}
 	validPrintSizeOptions     = []string{"none", "short", "full"}
 	validPanicStrategyOptions = []string{"print", "trap"}
 	validOptOptions           = []string{"none", "0", "1", "2", "s", "z"}
@@ -23,11 +22,10 @@ type Options struct {
 	GC              string
 	PanicStrategy   string
 	Scheduler       string
-	Serial          string
 	PrintIR         bool
 	DumpSSA         bool
 	VerifyIR        bool
-	PrintCommands   func(cmd string, args ...string)
+	PrintCommands   bool
 	Debug           bool
 	PrintSizes      string
 	PrintAllocs     *regexp.Regexp // regexp string
@@ -61,15 +59,6 @@ func (o *Options) Verify() error {
 		}
 	}
 
-	if o.Serial != "" {
-		valid := isInArray(validSerialOptions, o.Serial)
-		if !valid {
-			return fmt.Errorf(`invalid serial option '%s': valid values are %s`,
-				o.Serial,
-				strings.Join(validSerialOptions, ", "))
-		}
-	}
-
 	if o.PrintSizes != "" {
 		valid := isInArray(validPrintSizeOptions, o.PrintSizes)
 		if !valid {

compileopts/target.go

@@ -31,7 +31,6 @@ type TargetSpec struct {
 	BuildTags        []string `json:"build-tags"`
 	GC               string   `json:"gc"`
 	Scheduler        string   `json:"scheduler"`
-	Serial           string   `json:"serial"` // which serial output to use (uart, usb, none)
 	Linker           string   `json:"linker"`
 	RTLib            string   `json:"rtlib"` // compiler runtime library (libgcc, compiler-rt)
 	Libc             string   `json:"libc"`
@@ -41,12 +40,10 @@ type TargetSpec struct {
 	LDFlags          []string `json:"ldflags"`
 	LinkerScript     string   `json:"linkerscript"`
 	ExtraFiles       []string `json:"extra-files"`
-	RP2040BootPatch  *bool    `json:"rp2040-boot-patch"`        // Patch RP2040 2nd stage bootloader checksum
 	Emulator         []string `json:"emulator" override:"copy"` // inherited Emulator must not be append
 	FlashCommand     string   `json:"flash-command"`
 	GDB              []string `json:"gdb"`
 	PortReset        string   `json:"flash-1200-bps-reset"`
-	SerialPort       []string `json:"serial-port"` // serial port IDs in the form "acm:vid:pid" or "usb:vid:pid"
 	FlashMethod      string   `json:"flash-method"`
 	FlashVolume      string   `json:"msd-volume-name"`
 	FlashFilename    string   `json:"msd-firmware-name"`

compiler/asserts.go

@@ -162,10 +162,6 @@ func (b *builder) createNilCheck(inst ssa.Value, ptr llvm.Value, blockPrefix str
 	case *ssa.Alloc:
 		// An alloc is never nil.
 		return
-	case *ssa.FreeVar:
-		// A free variable is allocated in a parent function and is thus never
-		// nil.
-		return
 	case *ssa.IndexAddr:
 		// This pointer is the result of an index operation into a slice or
 		// array. Such slices/arrays are already bounds checked so the pointer

compiler/compiler.go

@@ -23,7 +23,7 @@ import (
 // Version of the compiler pacakge. Must be incremented each time the compiler
 // package changes in a way that affects the generated LLVM module.
 // This version is independent of the TinyGo version number.
-const Version = 12 // last change: implement syscall.rawSyscallNoError
+const Version = 9 // last change: implement reflect.New()
 
 func init() {
 	llvm.InitializeAllTargets()
@@ -715,11 +715,11 @@ func (c *compilerContext) createPackage(irbuilder llvm.Builder, pkg *ssa.Package
 		member := pkg.Members[name]
 		switch member := member.(type) {
 		case *ssa.Function:
-			// Create the function definition.
-			b := newBuilder(c, irbuilder, member)
 			if member.Blocks == nil {
 				continue // external function
 			}
+			// Create the function definition.
+			b := newBuilder(c, irbuilder, member)
 			b.createFunction()
 		case *ssa.Type:
 			if types.IsInterface(member.Type()) {
@@ -758,13 +758,10 @@ func (c *compilerContext) createPackage(irbuilder llvm.Builder, pkg *ssa.Package
 		case *ssa.Global:
 			// Global variable.
 			info := c.getGlobalInfo(member)
-			global := c.getGlobal(member)
 			if !info.extern {
+				global := c.getGlobal(member)
 				global.SetInitializer(llvm.ConstNull(global.Type().ElementType()))
 				global.SetVisibility(llvm.HiddenVisibility)
-				if info.section != "" {
-					global.SetSection(info.section)
-				}
 			}
 		}
 	}
@@ -790,9 +787,6 @@ func (b *builder) createFunction() {
 		b.llvmFn.SetVisibility(llvm.HiddenVisibility)
 		b.llvmFn.SetUnnamedAddr(true)
 	}
-	if b.info.section != "" {
-		b.llvmFn.SetSection(b.info.section)
-	}
 	if b.info.exported && strings.HasPrefix(b.Triple, "wasm") {
 		// Set the exported name. This is necessary for WebAssembly because
 		// otherwise the function is not exported.
@@ -1000,8 +994,6 @@ func getPos(val posser) token.Pos {
 	switch val := val.(type) {
 	case *ssa.MakeInterface:
 		return getPos(val.X)
-	case *ssa.MakeClosure:
-		return val.Fn.(*ssa.Function).Pos()
 	case *ssa.Return:
 		syntax := val.Parent().Syntax()
 		if syntax != nil {
@@ -1056,8 +1048,52 @@ func (b *builder) createInstruction(instr ssa.Instruction) {
 	case *ssa.Defer:
 		b.createDefer(instr)
 	case *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))
+		}
+
 		// Start a new goroutine.
-		b.createGo(instr)
+		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.
+				context = llvm.Undef(b.i8ptrType)
+			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)
+				context = b.extractFuncContext(funcValue)
+			default:
+				panic("StaticCallee returned an unexpected value")
+			}
+			params = append(params, context) // context parameter
+			b.createGoInstruction(b.getFunction(callee), params, "", callee.Pos())
+		} else if !instr.Call.IsInvoke() {
+			// This is a function pointer.
+			// At the moment, two extra params are passed to the newly started
+			// goroutine:
+			//   * The function context, for closures.
+			//   * The function pointer (for tasks).
+			funcPtr, context := b.decodeFuncValue(b.getValue(instr.Call.Value), instr.Call.Value.Type().Underlying().(*types.Signature))
+			params = append(params, context) // context parameter
+			switch b.Scheduler {
+			case "none", "coroutines":
+				// There are no additional parameters needed for the goroutine start operation.
+			case "tasks":
+				// Add the function pointer as a parameter to start the goroutine.
+				params = append(params, funcPtr)
+			default:
+				panic("unknown scheduler type")
+			}
+			b.createGoInstruction(funcPtr, params, b.fn.RelString(nil), instr.Pos())
+		} else {
+			b.addError(instr.Pos(), "todo: go on interface call")
+		}
 	case *ssa.If:
 		cond := b.getValue(instr.Cond)
 		block := instr.Block()
@@ -1298,20 +1334,18 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 			return b.createMemoryCopyCall(fn, instr.Args)
 		case name == "runtime.memzero":
 			return b.createMemoryZeroCall(instr.Args)
-		case name == "github.com/sago35/device.Asm" || name == "github.com/sago35/device/arm.Asm" || name == "github.com/sago35/device/arm64.Asm" || name == "github.com/sago35/device/avr.Asm" || name == "github.com/sago35/device/riscv.Asm":
+		case name == "device.Asm" || name == "device/arm.Asm" || name == "device/arm64.Asm" || name == "device/avr.Asm" || name == "device/riscv.Asm":
 			return b.createInlineAsm(instr.Args)
-		case name == "github.com/sago35/device.AsmFull" || name == "github.com/sago35/device/arm.AsmFull" || name == "github.com/sago35/device/arm64.AsmFull" || name == "github.com/sago35/device/avr.AsmFull" || name == "github.com/sago35/device/riscv.AsmFull":
+		case name == "device.AsmFull" || name == "device/arm.AsmFull" || name == "device/arm64.AsmFull" || name == "device/avr.AsmFull" || name == "device/riscv.AsmFull":
 			return b.createInlineAsmFull(instr)
-		case strings.HasPrefix(name, "github.com/sago35/device/arm.SVCall"):
+		case strings.HasPrefix(name, "device/arm.SVCall"):
 			return b.emitSVCall(instr.Args)
-		case strings.HasPrefix(name, "github.com/sago35/device/arm64.SVCall"):
+		case strings.HasPrefix(name, "device/arm64.SVCall"):
 			return b.emitSV64Call(instr.Args)
-		case strings.HasPrefix(name, "(github.com/sago35/device/riscv.CSR)."):
+		case strings.HasPrefix(name, "(device/riscv.CSR)."):
 			return b.emitCSROperation(instr)
 		case strings.HasPrefix(name, "syscall.Syscall"):
 			return b.createSyscall(instr)
-		case strings.HasPrefix(name, "syscall.rawSyscallNoError"):
-			return b.createRawSyscallNoError(instr)
 		case strings.HasPrefix(name, "runtime/volatile.Load"):
 			return b.createVolatileLoad(instr)
 		case strings.HasPrefix(name, "runtime/volatile.Store"):

compiler/compiler_test.go

@@ -19,8 +19,6 @@ var flagUpdate = flag.Bool("update", false, "update tests based on test output")
 // Basic tests for the compiler. Build some Go files and compare the output with
 // the expected LLVM IR for regression testing.
 func TestCompiler(t *testing.T) {
-	t.Parallel()
-
 	// Check LLVM version.
 	llvmMajor, err := strconv.Atoi(strings.SplitN(llvm.Version, ".", 2)[0])
 	if err != nil {
@@ -34,56 +32,43 @@ func TestCompiler(t *testing.T) {
 		t.Skip("compiler tests require LLVM 11 or above, got LLVM ", llvm.Version)
 	}
 
-	tests := []struct {
-		file   string
-		target string
-	}{
-		{"basic.go", ""},
-		{"pointer.go", ""},
-		{"slice.go", ""},
-		{"string.go", ""},
-		{"float.go", ""},
-		{"interface.go", ""},
-		{"func.go", ""},
-		{"pragma.go", ""},
-		{"goroutine.go", "wasm"},
-		{"goroutine.go", "cortex-m-qemu"},
+	target, err := compileopts.LoadTarget("wasm")
+	if err != nil {
+		t.Fatal("failed to load target:", err)
+	}
+	config := &compileopts.Config{
+		Options: &compileopts.Options{},
+		Target:  target,
+	}
+	compilerConfig := &Config{
+		Triple:             config.Triple(),
+		GOOS:               config.GOOS(),
+		GOARCH:             config.GOARCH(),
+		CodeModel:          config.CodeModel(),
+		RelocationModel:    config.RelocationModel(),
+		Scheduler:          config.Scheduler(),
+		FuncImplementation: config.FuncImplementation(),
+		AutomaticStackSize: config.AutomaticStackSize(),
+	}
+	machine, err := NewTargetMachine(compilerConfig)
+	if err != nil {
+		t.Fatal("failed to create target machine:", err)
 	}
 
-	for _, tc := range tests {
-		name := tc.file
-		targetString := "wasm"
-		if tc.target != "" {
-			targetString = tc.target
-			name = tc.file + "-" + tc.target
-		}
-
-		t.Run(name, func(t *testing.T) {
-			target, err := compileopts.LoadTarget(targetString)
-			if err != nil {
-				t.Fatal("failed to load target:", err)
-			}
-			config := &compileopts.Config{
-				Options: &compileopts.Options{},
-				Target:  target,
-			}
-			compilerConfig := &Config{
-				Triple:             config.Triple(),
-				GOOS:               config.GOOS(),
-				GOARCH:             config.GOARCH(),
-				CodeModel:          config.CodeModel(),
-				RelocationModel:    config.RelocationModel(),
-				Scheduler:          config.Scheduler(),
-				FuncImplementation: config.FuncImplementation(),
-				AutomaticStackSize: config.AutomaticStackSize(),
-			}
-			machine, err := NewTargetMachine(compilerConfig)
-			if err != nil {
-				t.Fatal("failed to create target machine:", err)
-			}
+	tests := []string{
+		"basic.go",
+		"pointer.go",
+		"slice.go",
+		"string.go",
+		"float.go",
+		"interface.go",
+		"func.go",
+	}
 
+	for _, testCase := range tests {
+		t.Run(testCase, func(t *testing.T) {
 			// Load entire program AST into memory.
-			lprogram, err := loader.Load(config, []string{"./testdata/" + tc.file}, config.ClangHeaders, types.Config{
+			lprogram, err := loader.Load(config, []string{"./testdata/" + testCase}, config.ClangHeaders, types.Config{
 				Sizes: Sizes(machine),
 			})
 			if err != nil {
@@ -91,13 +76,13 @@ func TestCompiler(t *testing.T) {
 			}
 			err = lprogram.Parse()
 			if err != nil {
-				t.Fatalf("could not parse test case %s: %s", tc.file, err)
+				t.Fatalf("could not parse test case %s: %s", testCase, err)
 			}
 
 			// Compile AST to IR.
 			program := lprogram.LoadSSA()
 			pkg := lprogram.MainPkg()
-			mod, errs := CompilePackage(tc.file, pkg, program.Package(pkg.Pkg), machine, compilerConfig, false)
+			mod, errs := CompilePackage(testCase, pkg, program.Package(pkg.Pkg), machine, compilerConfig, false)
 			if errs != nil {
 				for _, err := range errs {
 					t.Error(err)
@@ -120,22 +105,18 @@ func TestCompiler(t *testing.T) {
 			}
 			funcPasses.FinalizeFunc()
 
-			outFilePrefix := tc.file[:len(tc.file)-3]
-			if tc.target != "" {
-				outFilePrefix += "-" + tc.target
-			}
-			outPath := "./testdata/" + outFilePrefix + ".ll"
+			outfile := "./testdata/" + testCase[:len(testCase)-3] + ".ll"
 
 			// Update test if needed. Do not check the result.
 			if *flagUpdate {
-				err := ioutil.WriteFile(outPath, []byte(mod.String()), 0666)
+				err := ioutil.WriteFile(outfile, []byte(mod.String()), 0666)
 				if err != nil {
 					t.Error("failed to write updated output file:", err)
 				}
 				return
 			}
 
-			expected, err := ioutil.ReadFile(outPath)
+			expected, err := ioutil.ReadFile(outfile)
 			if err != nil {
 				t.Fatal("failed to read golden file:", err)
 			}

compiler/goroutine.go

@@ -5,110 +5,25 @@ package compiler
 
 import (
 	"go/token"
-	"go/types"
 
 	"github.com/tinygo-org/tinygo/compiler/llvmutil"
 	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )
 
-// 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))
-	}
-
-	var prefix string
-	var funcPtr llvm.Value
-	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.
-			if b.Scheduler == "coroutines" {
-				// The context parameter is assumed to be always present in the
-				// coroutines scheduler.
-				context = llvm.Undef(b.i8ptrType)
-			}
-		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)
-			context = b.extractFuncContext(funcValue)
-		default:
-			panic("StaticCallee returned an unexpected value")
-		}
-		if !context.IsNil() {
-			params = append(params, context) // context parameter
-			hasContext = true
-		}
-		funcPtr = b.getFunction(callee)
-	} else 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.
-		// Possible exceptions:
-		//   - copy: this is a possibly long operation, but not a blocking
-		//     operation. Semantically it makes no difference to run it right
-		//     away (not in a goroutine). However, in practice it makes no sense
-		//     to run copy in a goroutine as there is no way to (safely) know
-		//     when it is finished.
-		//   - panic: the error message would appear in the parent goroutine.
-		//     But because `go panic("err")` would halt the program anyway
-		//     (there is no recover), panicking right away would give the same
-		//     behavior as creating a goroutine, switching the scheduler to that
-		//     goroutine, and panicking there. So this optimization seems
-		//     correct.
-		//   - recover: because it runs in a new goroutine, it is never a
-		//     deferred function. Thus this is a no-op.
-		if builtin.Name() == "recover" {
-			// This is a no-op, even in a deferred function:
-			//   go recover()
-			return
-		}
-		var argTypes []types.Type
-		var argValues []llvm.Value
-		for _, arg := range instr.Call.Args {
-			argTypes = append(argTypes, arg.Type())
-			argValues = append(argValues, b.getValue(arg))
-		}
-		b.createBuiltin(argTypes, argValues, builtin.Name(), instr.Pos())
-		return
-	} else if !instr.Call.IsInvoke() {
-		// This is a function pointer.
-		// At the moment, two extra params are passed to the newly started
-		// goroutine:
-		//   * The function context, for closures.
-		//   * The function pointer (for tasks).
-		var context llvm.Value
-		funcPtr, context = b.decodeFuncValue(b.getValue(instr.Call.Value), instr.Call.Value.Type().Underlying().(*types.Signature))
-		params = append(params, context) // context parameter
-		hasContext = true
-		switch b.Scheduler {
-		case "none", "coroutines":
-			// There are no additional parameters needed for the goroutine start operation.
-		case "tasks":
-			// Add the function pointer as a parameter to start the goroutine.
-			params = append(params, funcPtr)
-		default:
-			panic("unknown scheduler type")
-		}
-		prefix = b.fn.RelString(nil)
-	} else {
-		b.addError(instr.Pos(), "todo: go on interface call")
-		return
-	}
-
+// createGoInstruction starts a new goroutine with the provided function pointer
+// and parameters.
+// In general, you should pass all regular parameters plus the context parameter.
+// There is one exception: the task-based scheduler needs to have the function
+// pointer passed in as a parameter too in addition to the context.
+//
+// Because a go statement doesn't return anything, return undef.
+func (b *builder) createGoInstruction(funcPtr llvm.Value, params []llvm.Value, prefix string, pos token.Pos) llvm.Value {
 	paramBundle := b.emitPointerPack(params)
 	var callee, stackSize llvm.Value
 	switch b.Scheduler {
 	case "none", "tasks":
-		callee = b.createGoroutineStartWrapper(funcPtr, prefix, hasContext, instr.Pos())
+		callee = b.createGoroutineStartWrapper(funcPtr, prefix, pos)
 		if b.AutomaticStackSize {
 			// The stack size is not known until after linking. Call a dummy
 			// function that will be replaced with a load from a special ELF
@@ -119,8 +34,8 @@ func (b *builder) createGo(instr *ssa.Go) {
 		} else {
 			// The stack size is fixed at compile time. By emitting it here as a
 			// constant, it can be optimized.
-			if b.Scheduler == "tasks" && b.DefaultStackSize == 0 {
-				b.addError(instr.Pos(), "default stack size for goroutines is not set")
+			if b.DefaultStackSize == 0 {
+				b.addError(pos, "default stack size for goroutines is not set")
 			}
 			stackSize = llvm.ConstInt(b.uintptrType, b.DefaultStackSize, false)
 		}
@@ -134,6 +49,7 @@ func (b *builder) createGo(instr *ssa.Go) {
 	}
 	start := b.getFunction(b.program.ImportedPackage("internal/task").Members["start"].(*ssa.Function))
 	b.createCall(start, []llvm.Value{callee, paramBundle, stackSize, llvm.Undef(b.i8ptrType), llvm.ConstPointerNull(b.i8ptrType)}, "")
+	return llvm.Undef(funcPtr.Type().ElementType().ReturnType())
 }
 
 // createGoroutineStartWrapper creates a wrapper for the task-based
@@ -154,12 +70,7 @@ func (b *builder) createGo(instr *ssa.Go) {
 // allows a single (pointer) argument to the newly started goroutine. Also, it
 // ignores the return value because newly started goroutines do not have a
 // return value.
-//
-// The hasContext parameter indicates whether the context parameter (the second
-// to last parameter of the function) is used for this wrapper. If hasContext is
-// false, the parameter bundle is assumed to have no context parameter and undef
-// is passed instead.
-func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix string, hasContext bool, pos token.Pos) llvm.Value {
+func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix string, pos token.Pos) llvm.Value {
 	var wrapper llvm.Value
 
 	builder := c.ctx.NewBuilder()
@@ -206,15 +117,8 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 
 		// Create the list of params for the call.
 		paramTypes := fn.Type().ElementType().ParamTypes()
-		paramTypes = paramTypes[:len(paramTypes)-1] // strip parentHandle parameter
-		if !hasContext {
-			paramTypes = paramTypes[:len(paramTypes)-1] // strip context parameter
-		}
-		params := llvmutil.EmitPointerUnpack(builder, c.mod, wrapper.Param(0), paramTypes)
-		if !hasContext {
-			params = append(params, llvm.Undef(c.i8ptrType)) // add dummy context parameter
-		}
-		params = append(params, llvm.Undef(c.i8ptrType)) // add dummy parentHandle parameter
+		params := llvmutil.EmitPointerUnpack(builder, c.mod, wrapper.Param(0), paramTypes[:len(paramTypes)-1])
+		params = append(params, llvm.Undef(c.i8ptrType))
 
 		// Create the call.
 		builder.CreateCall(fn, params, "")
@@ -276,11 +180,8 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 		// Get the function pointer.
 		fnPtr := params[len(params)-1]
 
-		// The last parameter in the packed object has somewhat of a dual role.
-		// Inside the parameter bundle it's the function pointer, stored right
-		// after the context pointer. But in the IR call instruction, it's the
-		// parentHandle function that's always undef outside of the coroutines
-		// scheduler. Thus, make the parameter undef here.
+		// Ignore the last param, which isn't used anymore.
+		// TODO: avoid this extra "parent handle" parameter in most functions.
 		params[len(params)-1] = llvm.Undef(c.i8ptrType)
 
 		// Create the call.

compiler/interface.go

@@ -311,21 +311,10 @@ func (c *compilerContext) getInterfaceMethodSet(typ types.Type) llvm.Value {
 // used during the interface lowering pass.
 func (c *compilerContext) getMethodSignature(method *types.Func) llvm.Value {
 	signature := methodSignature(method)
-	var globalName string
-	if token.IsExported(method.Name()) {
-		globalName = "reflect/methods." + signature
-	} else {
-		globalName = method.Type().(*types.Signature).Recv().Pkg().Path() + ".$methods." + signature
-	}
-	signatureGlobal := c.mod.NamedGlobal(globalName)
+	signatureGlobal := c.mod.NamedGlobal("func " + signature)
 	if signatureGlobal.IsNil() {
-		// TODO: put something useful in these globals, such as the method
-		// signature. Useful to one day implement reflect.Value.Method(n).
-		signatureGlobal = llvm.AddGlobal(c.mod, c.ctx.Int8Type(), globalName)
-		signatureGlobal.SetInitializer(llvm.ConstInt(c.ctx.Int8Type(), 0, false))
-		signatureGlobal.SetLinkage(llvm.LinkOnceODRLinkage)
+		signatureGlobal = llvm.AddGlobal(c.mod, c.ctx.Int8Type(), "func "+signature)
 		signatureGlobal.SetGlobalConstant(true)
-		signatureGlobal.SetAlignment(1)
 	}
 	return signatureGlobal
 }

compiler/interrupt.go

@@ -41,7 +41,10 @@ func (b *builder) createInterruptGlobal(instr *ssa.CallCommon) (llvm.Value, erro
 	// type are lowered in the interrupt lowering pass.
 	globalType := b.program.ImportedPackage("runtime/interrupt").Type("handle").Type()
 	globalLLVMType := b.getLLVMType(globalType)
-	globalName := b.fn.Package().Pkg.Path() + "$interrupt" + strconv.FormatInt(id.Int64(), 10)
+	globalName := "runtime/interrupt.$interrupt" + strconv.FormatInt(id.Int64(), 10)
+	if global := b.mod.NamedGlobal(globalName); !global.IsNil() {
+		return llvm.Value{}, b.makeError(instr.Pos(), "interrupt redeclared in this program")
+	}
 	global := llvm.AddGlobal(b.mod, globalLLVMType, globalName)
 	global.SetVisibility(llvm.HiddenVisibility)
 	global.SetGlobalConstant(true)

compiler/symbol.go

@@ -24,7 +24,6 @@ type functionInfo struct {
 	module     string     // go:wasm-module
 	importName string     // go:linkname, go:export - The name the developer assigns
 	linkName   string     // go:linkname, go:export - The name that we map for the particular module -> importName
-	section    string     // go:section - object file section name
 	exported   bool       // go:export, CGo
 	nobounds   bool       // go:nobounds
 	variadic   bool       // go:variadic (CGo only)
@@ -271,10 +270,6 @@ func (info *functionInfo) parsePragmas(f *ssa.Function) {
 				if hasUnsafeImport(f.Pkg.Pkg) {
 					info.linkName = parts[2]
 				}
-			case "//go:section":
-				if len(parts) == 2 && hasUnsafeImport(f.Pkg.Pkg) {
-					info.section = parts[1]
-				}
 			case "//go:nobounds":
 				// Skip bounds checking in this function. Useful for some
 				// runtime functions.
@@ -330,7 +325,6 @@ type globalInfo struct {
 	linkName string // go:extern
 	extern   bool   // go:extern
 	align    int    // go:align
-	section  string // go:section
 }
 
 // loadASTComments loads comments on globals from the AST, for use later in the
@@ -444,10 +438,6 @@ func (info *globalInfo) parsePragmas(doc *ast.CommentGroup) {
 			if err == nil {
 				info.align = align
 			}
-		case "//go:section":
-			if len(parts) == 2 {
-				info.section = parts[1]
-			}
 		}
 	}
 }

compiler/syscall.go

@@ -10,11 +10,11 @@ import (
 	"tinygo.org/x/go-llvm"
 )
 
-// createRawSyscall creates a system call with the provided system call number
-// and returns the result as a single integer (the system call result). The
-// result is not further interpreted.
-func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
+// createSyscall emits an inline system call instruction, depending on the
+// target OS/arch.
+func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 	num := b.getValue(call.Args[0])
+	var syscallResult llvm.Value
 	switch {
 	case b.GOARCH == "amd64":
 		if b.GOOS == "darwin" {
@@ -57,7 +57,7 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		constraints += ",~{rcx},~{r11}"
 		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
 		target := llvm.InlineAsm(fnType, "syscall", constraints, true, false, llvm.InlineAsmDialectIntel)
-		return b.CreateCall(target, args, ""), nil
+		syscallResult = b.CreateCall(target, args, "")
 	case b.GOARCH == "386" && b.GOOS == "linux":
 		// Sources:
 		//   syscall(2) man page
@@ -83,7 +83,7 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		}
 		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
 		target := llvm.InlineAsm(fnType, "int 0x80", constraints, true, false, llvm.InlineAsmDialectIntel)
-		return b.CreateCall(target, args, ""), nil
+		syscallResult = b.CreateCall(target, args, "")
 	case b.GOARCH == "arm" && b.GOOS == "linux":
 		// Implement the EABI system call convention for Linux.
 		// Source: syscall(2) man page.
@@ -115,7 +115,7 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		}
 		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
 		target := llvm.InlineAsm(fnType, "svc #0", constraints, true, false, 0)
-		return b.CreateCall(target, args, ""), nil
+		syscallResult = b.CreateCall(target, args, "")
 	case b.GOARCH == "arm64" && b.GOOS == "linux":
 		// Source: syscall(2) man page.
 		args := []llvm.Value{}
@@ -147,19 +147,10 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		constraints += ",~{x16},~{x17}" // scratch registers
 		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
 		target := llvm.InlineAsm(fnType, "svc #0", constraints, true, false, 0)
-		return b.CreateCall(target, args, ""), nil
+		syscallResult = b.CreateCall(target, args, "")
 	default:
 		return llvm.Value{}, b.makeError(call.Pos(), "unknown GOOS/GOARCH for syscall: "+b.GOOS+"/"+b.GOARCH)
 	}
-}
-
-// createSyscall emits instructions for the syscall.Syscall* family of
-// functions, depending on the target OS/arch.
-func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
-	syscallResult, err := b.createRawSyscall(call)
-	if err != nil {
-		return syscallResult, err
-	}
 	switch b.GOOS {
 	case "linux", "freebsd":
 		// Return values: r0, r1 uintptr, err Errno
@@ -199,16 +190,3 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		return llvm.Value{}, b.makeError(call.Pos(), "unknown GOOS/GOARCH for syscall: "+b.GOOS+"/"+b.GOARCH)
 	}
 }
-
-// createRawSyscallNoError emits instructions for the Linux-specific
-// syscall.rawSyscallNoError function.
-func (b *builder) createRawSyscallNoError(call *ssa.CallCommon) (llvm.Value, error) {
-	syscallResult, err := b.createRawSyscall(call)
-	if err != nil {
-		return syscallResult, err
-	}
-	retval := llvm.ConstNull(b.ctx.StructType([]llvm.Type{b.uintptrType, b.uintptrType}, false))
-	retval = b.CreateInsertValue(retval, syscallResult, 0, "")
-	retval = b.CreateInsertValue(retval, llvm.ConstInt(b.uintptrType, 0, false), 1, "")
-	return retval, nil
-}

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

@@ -1,150 +0,0 @@
-; ModuleID = 'goroutine.go'
-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 = "armv7m-none-eabi"
-
-%runtime.channel = type { i32, i32, i8, %runtime.channelBlockedList*, i32, i32, i32, i8* }
-%runtime.channelBlockedList = type { %runtime.channelBlockedList*, %"internal/task.Task"*, %runtime.chanSelectState*, { %runtime.channelBlockedList*, i32, i32 } }
-%"internal/task.Task" = type { %"internal/task.Task"*, i8*, i64, %"internal/task.state" }
-%"internal/task.state" = type { i32, i32* }
-%runtime.chanSelectState = type { %runtime.channel*, i8* }
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
-
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret void
-}
-
-define hidden void @main.regularFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.regularFunction$gowrapper" to i32), i8* undef, i8* undef)
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.regularFunction$gowrapper" to i32), i8* nonnull inttoptr (i32 5 to i8*), i32 %stacksize, i8* undef, i8* null)
-  ret void
-}
-
-declare void @main.regularFunction(i32, i8*, i8*)
-
-define linkonce_odr void @"main.regularFunction$gowrapper"(i8* %0) unnamed_addr #0 {
-entry:
-  %unpack.int = ptrtoint i8* %0 to i32
-  call void @main.regularFunction(i32 %unpack.int, i8* undef, i8* undef)
-  ret void
-}
-
-declare i32 @"internal/task.getGoroutineStackSize"(i32, i8*, i8*)
-
-declare void @"internal/task.start"(i32, i8*, i32, i8*, i8*)
-
-define hidden void @main.inlineFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.inlineFunctionGoroutine$1$gowrapper" to i32), i8* undef, i8* undef)
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.inlineFunctionGoroutine$1$gowrapper" to i32), i8* nonnull inttoptr (i32 5 to i8*), i32 %stacksize, i8* undef, i8* null)
-  ret void
-}
-
-define hidden void @"main.inlineFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret void
-}
-
-define linkonce_odr void @"main.inlineFunctionGoroutine$1$gowrapper"(i8* %0) unnamed_addr #1 {
-entry:
-  %unpack.int = ptrtoint i8* %0 to i32
-  call void @"main.inlineFunctionGoroutine$1"(i32 %unpack.int, i8* undef, i8* undef)
-  ret void
-}
-
-define hidden void @main.closureFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %n = call i8* @runtime.alloc(i32 4, i8* undef, i8* null)
-  %0 = bitcast i8* %n to i32*
-  store i32 3, i32* %0, align 4
-  %1 = call i8* @runtime.alloc(i32 8, i8* undef, i8* null)
-  %2 = bitcast i8* %1 to i32*
-  store i32 5, i32* %2, align 4
-  %3 = getelementptr inbounds i8, i8* %1, i32 4
-  %4 = bitcast i8* %3 to i8**
-  store i8* %n, i8** %4, align 4
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.closureFunctionGoroutine$1$gowrapper" to i32), i8* undef, i8* undef)
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.closureFunctionGoroutine$1$gowrapper" to i32), i8* nonnull %1, i32 %stacksize, i8* undef, i8* null)
-  %5 = load i32, i32* %0, align 4
-  call void @runtime.printint32(i32 %5, i8* undef, i8* null)
-  ret void
-}
-
-define hidden void @"main.closureFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %unpack.ptr = bitcast i8* %context to i32*
-  store i32 7, i32* %unpack.ptr, align 4
-  ret void
-}
-
-define linkonce_odr void @"main.closureFunctionGoroutine$1$gowrapper"(i8* %0) unnamed_addr #2 {
-entry:
-  %1 = bitcast i8* %0 to i32*
-  %2 = load i32, i32* %1, align 4
-  %3 = getelementptr inbounds i8, i8* %0, i32 4
-  %4 = bitcast i8* %3 to i8**
-  %5 = load i8*, i8** %4, align 4
-  call void @"main.closureFunctionGoroutine$1"(i32 %2, i8* %5, i8* undef)
-  ret void
-}
-
-declare void @runtime.printint32(i32, i8*, i8*)
-
-define hidden void @main.funcGoroutine(i8* %fn.context, void (i32, i8*, i8*)* %fn.funcptr, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %0 = call i8* @runtime.alloc(i32 12, i8* undef, i8* null)
-  %1 = bitcast i8* %0 to i32*
-  store i32 5, i32* %1, align 4
-  %2 = getelementptr inbounds i8, i8* %0, i32 4
-  %3 = bitcast i8* %2 to i8**
-  store i8* %fn.context, i8** %3, align 4
-  %4 = getelementptr inbounds i8, i8* %0, i32 8
-  %5 = bitcast i8* %4 to void (i32, i8*, i8*)**
-  store void (i32, i8*, i8*)* %fn.funcptr, void (i32, i8*, i8*)** %5, align 4
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @main.funcGoroutine.gowrapper to i32), i8* undef, i8* undef)
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @main.funcGoroutine.gowrapper to i32), i8* nonnull %0, i32 %stacksize, i8* undef, i8* null)
-  ret void
-}
-
-define linkonce_odr void @main.funcGoroutine.gowrapper(i8* %0) unnamed_addr #3 {
-entry:
-  %1 = bitcast i8* %0 to i32*
-  %2 = load i32, i32* %1, align 4
-  %3 = getelementptr inbounds i8, i8* %0, i32 4
-  %4 = bitcast i8* %3 to i8**
-  %5 = load i8*, i8** %4, align 4
-  %6 = getelementptr inbounds i8, i8* %0, i32 8
-  %7 = bitcast i8* %6 to void (i32, i8*, i8*)**
-  %8 = load void (i32, i8*, i8*)*, void (i32, i8*, i8*)** %7, align 4
-  call void %8(i32 %2, i8* %5, i8* undef)
-  ret void
-}
-
-define hidden void @main.recoverBuiltinGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret void
-}
-
-define hidden void @main.copyBuiltinGoroutine(i8* %dst.data, i32 %dst.len, i32 %dst.cap, i8* %src.data, i32 %src.len, i32 %src.cap, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %copy.n = call i32 @runtime.sliceCopy(i8* %dst.data, i8* %src.data, i32 %dst.len, i32 %src.len, i32 1, i8* undef, i8* null)
-  ret void
-}
-
-declare i32 @runtime.sliceCopy(i8* nocapture writeonly, i8* nocapture readonly, i32, i32, i32, i8*, i8*)
-
-define hidden void @main.closeBuiltinGoroutine(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  call void @runtime.chanClose(%runtime.channel* %ch, i8* undef, i8* null)
-  ret void
-}
-
-declare void @runtime.chanClose(%runtime.channel* dereferenceable_or_null(32), i8*, i8*)
-
-attributes #0 = { "tinygo-gowrapper"="main.regularFunction" }
-attributes #1 = { "tinygo-gowrapper"="main.inlineFunctionGoroutine$1" }
-attributes #2 = { "tinygo-gowrapper"="main.closureFunctionGoroutine$1" }
-attributes #3 = { "tinygo-gowrapper" }

compiler/testdata/goroutine-wasm.ll

@@ -1,106 +0,0 @@
-; ModuleID = 'goroutine.go'
-source_filename = "goroutine.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32--wasi"
-
-%runtime.funcValueWithSignature = type { i32, i8* }
-%runtime.channel = type { i32, i32, i8, %runtime.channelBlockedList*, i32, i32, i32, i8* }
-%runtime.channelBlockedList = type { %runtime.channelBlockedList*, %"internal/task.Task"*, %runtime.chanSelectState*, { %runtime.channelBlockedList*, i32, i32 } }
-%"internal/task.Task" = type { %"internal/task.Task"*, i8*, i64, %"internal/task.state" }
-%"internal/task.state" = type { i8* }
-%runtime.chanSelectState = type { %runtime.channel*, i8* }
-
-@"main.regularFunctionGoroutine$pack" = private unnamed_addr constant { i32, i8* } { i32 5, i8* undef }
-@"main.inlineFunctionGoroutine$pack" = private unnamed_addr constant { i32, i8* } { i32 5, i8* undef }
-@"reflect/types.funcid:func:{basic:int}{}" = external constant i8
-@"main.closureFunctionGoroutine$1$withSignature" = linkonce_odr constant %runtime.funcValueWithSignature { i32 ptrtoint (void (i32, i8*, i8*)* @"main.closureFunctionGoroutine$1" to i32), i8* @"reflect/types.funcid:func:{basic:int}{}" }
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
-
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret void
-}
-
-define hidden void @main.regularFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  call void @"internal/task.start"(i32 ptrtoint (void (i32, i8*, i8*)* @main.regularFunction to i32), i8* bitcast ({ i32, i8* }* @"main.regularFunctionGoroutine$pack" to i8*), i32 undef, i8* undef, i8* null)
-  ret void
-}
-
-declare void @main.regularFunction(i32, i8*, i8*)
-
-declare void @"internal/task.start"(i32, i8*, i32, i8*, i8*)
-
-define hidden void @main.inlineFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  call void @"internal/task.start"(i32 ptrtoint (void (i32, i8*, i8*)* @"main.inlineFunctionGoroutine$1" to i32), i8* bitcast ({ i32, i8* }* @"main.inlineFunctionGoroutine$pack" to i8*), i32 undef, i8* undef, i8* null)
-  ret void
-}
-
-define hidden void @"main.inlineFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret void
-}
-
-define hidden void @main.closureFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %n = call i8* @runtime.alloc(i32 4, i8* undef, i8* null)
-  %0 = bitcast i8* %n to i32*
-  store i32 3, i32* %0, align 4
-  %1 = call i8* @runtime.alloc(i32 8, i8* undef, i8* null)
-  %2 = bitcast i8* %1 to i32*
-  store i32 5, i32* %2, align 4
-  %3 = getelementptr inbounds i8, i8* %1, i32 4
-  %4 = bitcast i8* %3 to i8**
-  store i8* %n, i8** %4, align 4
-  call void @"internal/task.start"(i32 ptrtoint (void (i32, i8*, i8*)* @"main.closureFunctionGoroutine$1" to i32), i8* nonnull %1, i32 undef, i8* undef, i8* null)
-  %5 = load i32, i32* %0, align 4
-  call void @runtime.printint32(i32 %5, i8* undef, i8* null)
-  ret void
-}
-
-define hidden void @"main.closureFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %unpack.ptr = bitcast i8* %context to i32*
-  store i32 7, i32* %unpack.ptr, align 4
-  ret void
-}
-
-declare void @runtime.printint32(i32, i8*, i8*)
-
-define hidden void @main.funcGoroutine(i8* %fn.context, i32 %fn.funcptr, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %0 = call i32 @runtime.getFuncPtr(i8* %fn.context, i32 %fn.funcptr, i8* nonnull @"reflect/types.funcid:func:{basic:int}{}", i8* undef, i8* null)
-  %1 = call i8* @runtime.alloc(i32 8, i8* undef, i8* null)
-  %2 = bitcast i8* %1 to i32*
-  store i32 5, i32* %2, align 4
-  %3 = getelementptr inbounds i8, i8* %1, i32 4
-  %4 = bitcast i8* %3 to i8**
-  store i8* %fn.context, i8** %4, align 4
-  call void @"internal/task.start"(i32 %0, i8* nonnull %1, i32 undef, i8* undef, i8* null)
-  ret void
-}
-
-declare i32 @runtime.getFuncPtr(i8*, i32, i8* dereferenceable_or_null(1), i8*, i8*)
-
-define hidden void @main.recoverBuiltinGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret void
-}
-
-define hidden void @main.copyBuiltinGoroutine(i8* %dst.data, i32 %dst.len, i32 %dst.cap, i8* %src.data, i32 %src.len, i32 %src.cap, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %copy.n = call i32 @runtime.sliceCopy(i8* %dst.data, i8* %src.data, i32 %dst.len, i32 %src.len, i32 1, i8* undef, i8* null)
-  ret void
-}
-
-declare i32 @runtime.sliceCopy(i8* nocapture writeonly, i8* nocapture readonly, i32, i32, i32, i8*, i8*)
-
-define hidden void @main.closeBuiltinGoroutine(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  call void @runtime.chanClose(%runtime.channel* %ch, i8* undef, i8* null)
-  ret void
-}
-
-declare void @runtime.chanClose(%runtime.channel* dereferenceable_or_null(32), i8*, i8*)

compiler/testdata/goroutine.go

@@ -1,43 +0,0 @@
-package main
-
-func regularFunctionGoroutine() {
-	go regularFunction(5)
-}
-
-func inlineFunctionGoroutine() {
-	go func(x int) {
-	}(5)
-}
-
-func closureFunctionGoroutine() {
-	n := 3
-	go func(x int) {
-		n = 7
-	}(5)
-	print(n) // note: this is racy (but good enough for this test)
-}
-
-func funcGoroutine(fn func(x int)) {
-	go fn(5)
-}
-
-func recoverBuiltinGoroutine() {
-	// This is a no-op.
-	go recover()
-}
-
-func copyBuiltinGoroutine(dst, src []byte) {
-	// This is not run in a goroutine. While this copy operation can indeed take
-	// some time (if there is a lot of data to copy), there is no race-free way
-	// to make use of the result so it's unlikely applications will make use of
-	// it. And doing it this way should be just within the Go specification.
-	go copy(dst, src)
-}
-
-func closeBuiltinGoroutine(ch chan int) {
-	// This builtin is executed directly, not in a goroutine.
-	// The observed behavior is the same.
-	go close(ch)
-}
-
-func regularFunction(x int)

compiler/testdata/interface.ll

@@ -13,15 +13,15 @@ target triple = "wasm32--wasi"
 @"reflect/types.type:pointer:named:error" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:named:error", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null }
 @"reflect/types.type:named:error" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:interface:{Error:func:{}{basic:string}}", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:named:error" }
 @"reflect/types.type:interface:{Error:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* bitcast ([1 x i8*]* @"reflect/types.interface:interface{Error() string}$interface" to %runtime.typecodeID*), i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}" }
-@"reflect/methods.Error() string" = linkonce_odr constant i8 0, align 1
-@"reflect/types.interface:interface{Error() string}$interface" = linkonce_odr constant [1 x i8*] [i8* @"reflect/methods.Error() string"]
+@"func Error() string" = external constant i8
+@"reflect/types.interface:interface{Error() string}$interface" = linkonce_odr constant [1 x i8*] [i8* @"func Error() string"]
 @"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:interface:{Error:func:{}{basic:string}}", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null }
 @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:interface:{String:func:{}{basic:string}}", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null }
 @"reflect/types.type:interface:{String:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* bitcast ([1 x i8*]* @"reflect/types.interface:interface{String() string}$interface" to %runtime.typecodeID*), i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}" }
-@"reflect/methods.String() string" = linkonce_odr constant i8 0, align 1
-@"reflect/types.interface:interface{String() string}$interface" = linkonce_odr constant [1 x i8*] [i8* @"reflect/methods.String() string"]
+@"func String() string" = external constant i8
+@"reflect/types.interface:interface{String() string}$interface" = linkonce_odr constant [1 x i8*] [i8* @"func String() string"]
 @"reflect/types.typeid:basic:int" = external constant i8
-@"error$interface" = linkonce_odr constant [1 x i8*] [i8* @"reflect/methods.Error() string"]
+@"error$interface" = linkonce_odr constant [1 x i8*] [i8* @"func Error() string"]
 
 declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
 
@@ -92,7 +92,7 @@ typeassert.next:                                  ; preds = %typeassert.ok, %ent
 
 define hidden %runtime._string @main.callErrorMethod(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %invoke.func = call i32 @runtime.interfaceMethod(i32 %itf.typecode, i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @"error$interface", i32 0, i32 0), i8* nonnull @"reflect/methods.Error() string", i8* undef, i8* null)
+  %invoke.func = call i32 @runtime.interfaceMethod(i32 %itf.typecode, i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @"error$interface", i32 0, i32 0), i8* nonnull @"func Error() string", i8* undef, i8* null)
   %invoke.func.cast = inttoptr i32 %invoke.func to %runtime._string (i8*, i8*, i8*)*
   %0 = call %runtime._string %invoke.func.cast(i8* %itf.value, i8* undef, i8* undef)
   ret %runtime._string %0

compiler/testdata/pragma.go

@@ -1,66 +0,0 @@
-package main
-
-import _ "unsafe"
-
-// Creates an external global with name extern_global.
-//go:extern extern_global
-var externGlobal [0]byte
-
-// Creates a
-//go:align 32
-var alignedGlobal [4]uint32
-
-// Test conflicting pragmas (the last one counts).
-//go:align 64
-//go:align 16
-var alignedGlobal16 [4]uint32
-
-// Test exported functions.
-//export extern_func
-func externFunc() {
-}
-
-// Define a function in a different package using go:linkname.
-//go:linkname withLinkageName1 somepkg.someFunction1
-func withLinkageName1() {
-}
-
-// Import a function from a different package using go:linkname.
-//go:linkname withLinkageName2 somepkg.someFunction2
-func withLinkageName2()
-
-// Function has an 'inline hint', similar to the inline keyword in C.
-//go:inline
-func inlineFunc() {
-}
-
-// Function should never be inlined, equivalent to GCC
-// __attribute__((noinline)).
-//go:noinline
-func noinlineFunc() {
-}
-
-// This function should have the specified section.
-//go:section .special_function_section
-func functionInSection() {
-}
-
-//export exportedFunctionInSection
-//go:section .special_function_section
-func exportedFunctionInSection() {
-}
-
-// This function should not: it's only a declaration and not a definition.
-//go:section .special_function_section
-func undefinedFunctionNotInSection()
-
-//go:section .special_global_section
-var globalInSection uint32
-
-//go:section .special_global_section
-//go:extern undefinedGlobalNotInSection
-var undefinedGlobalNotInSection uint32
-
-//go:align 1024
-//go:section .global_section
-var multipleGlobalPragmas uint32

compiler/testdata/pragma.ll

@@ -1,59 +0,0 @@
-; ModuleID = 'pragma.go'
-source_filename = "pragma.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32--wasi"
-
-@extern_global = external global [0 x i8], align 1
-@main.alignedGlobal = hidden global [4 x i32] zeroinitializer, align 32
-@main.alignedGlobal16 = hidden global [4 x i32] zeroinitializer, align 16
-@main.globalInSection = hidden global i32 0, section ".special_global_section", align 4
-@undefinedGlobalNotInSection = external global i32, align 4
-@main.multipleGlobalPragmas = hidden global i32 0, section ".global_section", align 1024
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
-
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret void
-}
-
-define void @extern_func() #0 {
-entry:
-  ret void
-}
-
-define hidden void @somepkg.someFunction1(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret void
-}
-
-declare void @somepkg.someFunction2(i8*, i8*)
-
-; Function Attrs: inlinehint
-define hidden void @main.inlineFunc(i8* %context, i8* %parentHandle) unnamed_addr #1 {
-entry:
-  ret void
-}
-
-; Function Attrs: noinline
-define hidden void @main.noinlineFunc(i8* %context, i8* %parentHandle) unnamed_addr #2 {
-entry:
-  ret void
-}
-
-define hidden void @main.functionInSection(i8* %context, i8* %parentHandle) unnamed_addr section ".special_function_section" {
-entry:
-  ret void
-}
-
-define void @exportedFunctionInSection() #3 section ".special_function_section" {
-entry:
-  ret void
-}
-
-declare void @main.undefinedFunctionNotInSection(i8*, i8*)
-
-attributes #0 = { "wasm-export-name"="extern_func" }
-attributes #1 = { inlinehint }
-attributes #2 = { noinline }
-attributes #3 = { "wasm-export-name"="exportedFunctionInSection" }

go.mod

@@ -9,7 +9,6 @@ require (
 	github.com/google/shlex v0.0.0-20181106134648-c34317bd91bf
 	github.com/marcinbor85/gohex v0.0.0-20200531091804-343a4b548892
 	github.com/mattn/go-colorable v0.1.8
-	github.com/sago35/device v0.0.0-20210708114705-5c2c56419249
 	go.bug.st/serial v1.1.2
 	golang.org/x/sys v0.0.0-20210113181707-4bcb84eeeb78
 	golang.org/x/tools v0.0.0-20200216192241-b320d3a0f5a2

go.sum

@@ -8,7 +8,6 @@ github.com/chromedp/sysutil v1.0.0 h1:+ZxhTpfpZlmchB58ih/LBHX52ky7w2VhQVKQMucy3I
 github.com/chromedp/sysutil v1.0.0/go.mod h1:kgWmDdq8fTzXYcKIBqIYvRRTnYb9aNS9moAV0xufSww=
 github.com/creack/goselect v0.1.1 h1:tiSSgKE1eJtxs1h/VgGQWuXUP0YS4CDIFMp6vaI1ls0=
 github.com/creack/goselect v0.1.1/go.mod h1:a/NhLweNvqIYMuxcMOuWY516Cimucms3DglDzQP3hKY=
-github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/gobwas/httphead v0.1.0 h1:exrUm0f4YX0L7EBwZHuCF4GDp8aJfVeBrlLQrs6NqWU=
 github.com/gobwas/httphead v0.1.0/go.mod h1:O/RXo79gxV8G+RqlR/otEwx4Q36zl9rqC5u12GKvMCM=
@@ -28,13 +27,11 @@ github.com/mattn/go-colorable v0.1.8 h1:c1ghPdyEDarC70ftn0y+A/Ee++9zz8ljHG1b13eJ
 github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
 github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
 github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/sago35/device v0.0.0-20210708114705-5c2c56419249 h1:GU6dEpii0PsE4TF8RuOcEWzbbCZQPtcqdVdZsQXy/Uw=
-github.com/sago35/device v0.0.0-20210708114705-5c2c56419249/go.mod h1:N8KfLtl2y31BvW1T9LmO7P+QkfoJk7SurI+0N0lCuOo=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+go.bug.st/serial v1.0.0 h1:ogEPzrllCsnG00EqKRjeYvPRsO7NJW6DqykzkdD6E/k=
+go.bug.st/serial v1.0.0/go.mod h1:rpXPISGjuNjPTRTcMlxi9lN6LoIPxd1ixVjBd8aSk/Q=
 go.bug.st/serial v1.1.2 h1:6xDpbta8KJ+VLRTeM8ghhxXRMLE/Lr8h9iDKwydarAY=
 go.bug.st/serial v1.1.2/go.mod h1:VmYBeyJWp5BnJ0tw2NUJHZdJTGl2ecBGABHlzRK1knY=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
@@ -46,6 +43,8 @@ golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLL
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191128015809-6d18c012aee9 h1:ZBzSG/7F4eNKz2L3GE9o300RX0Az1Bw5HF7PDraD+qU=
+golang.org/x/sys v0.0.0-20191128015809-6d18c012aee9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200909081042-eff7692f9009/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -56,9 +55,9 @@ golang.org/x/tools v0.0.0-20200216192241-b320d3a0f5a2 h1:0sfSpGSa544Fwnbot3Oxq/U
 golang.org/x/tools v0.0.0-20200216192241-b320d3a0f5a2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898 h1:/atklqdjdhuosWIl6AIbOeHJjicWYPqR9bpxqxYG2pA=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+tinygo.org/x/go-llvm v0.0.0-20210308112806-9ef958b6bed4 h1:CMUHxVTb+UuUePuMf8vkWjZ3gTp9BBK91KrgOCwoNHs=
+tinygo.org/x/go-llvm v0.0.0-20210308112806-9ef958b6bed4/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
 tinygo.org/x/go-llvm v0.0.0-20210325115028-e7b85195e81c h1:vn9IPshzYmzZis10UEVrsIBRv9FpykADw6M3/tHHROg=
 tinygo.org/x/go-llvm v0.0.0-20210325115028-e7b85195e81c/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=

goenv/version.go

@@ -12,7 +12,7 @@ import (
 
 // Version of TinyGo.
 // Update this value before release of new version of software.
-const Version = "0.20.0-dev"
+const Version = "0.18.0-dev"
 
 // GetGorootVersion returns the major and minor version for a given GOROOT path.
 // If the goroot cannot be determined, (0, 0) is returned.

interp/interp.go

@@ -129,7 +129,7 @@ func Run(mod llvm.Module, debug bool) error {
 
 	// Update all global variables in the LLVM module.
 	mem := memoryView{r: r}
-	for i, obj := range r.objects {
+	for _, obj := range r.objects {
 		if obj.llvmGlobal.IsNil() {
 			continue
 		}
@@ -159,12 +159,6 @@ func Run(mod llvm.Module, debug bool) error {
 			name := obj.llvmGlobal.Name()
 			obj.llvmGlobal.EraseFromParentAsGlobal()
 			newGlobal.SetName(name)
-
-			// Update interp-internal references.
-			delete(r.globals, obj.llvmGlobal)
-			obj.llvmGlobal = newGlobal
-			r.globals[newGlobal] = i
-			r.objects[i] = obj
 			continue
 		}
 		if err != nil {

interp/memory.go

@@ -178,9 +178,6 @@ func (mv *memoryView) markExternal(llvmValue llvm.Value, mark uint8) {
 		default:
 			panic("interp: unknown constant expression")
 		}
-	} else if !llvmValue.IsAInlineAsm().IsNil() {
-		// Inline assembly can modify globals but only exported globals. Let's
-		// hope the author knows what they're doing.
 	} else {
 		llvmType := llvmValue.Type()
 		switch llvmType.TypeKind() {

interp/testdata/basic.ll

@@ -66,9 +66,6 @@ entry:
   call void @modifyExternal(i32* bitcast (void ()* @willModifyGlobal to i32*))
   store i16 7, i16* @main.exposedValue2
 
-  ; Test that inline assembly is ignored.
-  call void @modifyExternal(i32* bitcast (void ()* @hasInlineAsm to i32*))
-
   ; Test switch statement.
   %switch1 = call i64 @testSwitch(i64 1) ; 1 returns 6
   %switch2 = call i64 @testSwitch(i64 9) ; 9 returns the default value -1
@@ -105,15 +102,6 @@ entry:
   ret void
 }
 
-; Inline assembly should be ignored in the interp package. While it is possible
-; to modify other globals that way, usually that's not the case and there is no
-; real way to check.
-define void @hasInlineAsm() {
-entry:
-  call void asm sideeffect "", ""()
-  ret void
-}
-
 define i64 @testSwitch(i64 %val) {
 entry:
   ; Test switch statement.

interp/testdata/basic.out.ll

@@ -26,7 +26,6 @@ entry:
   store i16 5, i16* @main.exposedValue1
   call void @modifyExternal(i32* bitcast (void ()* @willModifyGlobal to i32*))
   store i16 7, i16* @main.exposedValue2
-  call void @modifyExternal(i32* bitcast (void ()* @hasInlineAsm to i32*))
   call void @runtime.printint64(i64 6)
   call void @runtime.printint64(i64 -1)
   %agg = call { i8, i32, { float, { i64, i16 } } } @nestedStruct()
@@ -60,12 +59,6 @@ entry:
   ret void
 }
 
-define void @hasInlineAsm() {
-entry:
-  call void asm sideeffect "", ""()
-  ret void
-}
-
 define i64 @testSwitch(i64 %val) local_unnamed_addr {
 entry:
   switch i64 %val, label %otherwise [

loader/goroot.go

@@ -2,14 +2,6 @@ package loader
 
 // This file constructs a new temporary GOROOT directory by merging both the
 // standard Go GOROOT and the GOROOT from TinyGo using symlinks.
-//
-// The goal is to replace specific packages from Go with a TinyGo version. It's
-// never a partial replacement, either a package is fully replaced or it is not.
-// This is important because if we did allow to merge packages (e.g. by adding
-// files to a package), it would lead to a dependency on implementation details
-// with all the maintenance burden that results in. Only allowing to replace
-// packages as a whole avoids this as packages are already designed to have a
-// public (backwards-compatible) API.
 
 import (
 	"crypto/sha512"
@@ -147,7 +139,6 @@ func mergeDirectory(goroot, tinygoroot, tmpgoroot, importPath string, overrides
 		if err != nil {
 			return err
 		}
-		hasTinyGoFiles := false
 		for _, e := range tinygoEntries {
 			if e.IsDir() {
 				// A directory, so merge this thing.
@@ -163,7 +154,6 @@ func mergeDirectory(goroot, tinygoroot, tmpgoroot, importPath string, overrides
 				if err != nil {
 					return err
 				}
-				hasTinyGoFiles = true
 			}
 		}
 
@@ -174,30 +164,21 @@ func mergeDirectory(goroot, tinygoroot, tmpgoroot, importPath string, overrides
 			return err
 		}
 		for _, e := range gorootEntries {
-			if e.IsDir() {
-				if _, ok := overrides[path.Join(importPath, e.Name())+"/"]; ok {
-					// Already included above, so don't bother trying to create this
-					// symlink.
-					continue
-				}
-				newname := filepath.Join(tmpgoroot, "src", importPath, e.Name())
-				oldname := filepath.Join(goroot, "src", importPath, e.Name())
-				err := symlink(oldname, newname)
-				if err != nil {
-					return err
-				}
-			} else {
-				// Only merge files from Go if TinyGo does not have any files.
-				// Otherwise we'd end up with a weird mix from both Go
-				// implementations.
-				if !hasTinyGoFiles {
-					newname := filepath.Join(tmpgoroot, "src", importPath, e.Name())
-					oldname := filepath.Join(goroot, "src", importPath, e.Name())
-					err := symlink(oldname, newname)
-					if err != nil {
-						return err
-					}
-				}
+			if !e.IsDir() {
+				// Don't merge in files from Go. Otherwise we'd end up with a
+				// weird syscall package with files from both roots.
+				continue
+			}
+			if _, ok := overrides[path.Join(importPath, e.Name())+"/"]; ok {
+				// Already included above, so don't bother trying to create this
+				// symlink.
+				continue
+			}
+			newname := filepath.Join(tmpgoroot, "src", importPath, e.Name())
+			oldname := filepath.Join(goroot, "src", importPath, e.Name())
+			err := symlink(oldname, newname)
+			if err != nil {
+				return err
 			}
 		}
 	}
@@ -220,8 +201,6 @@ func needsSyscallPackage(buildTags []string) bool {
 func pathsToOverride(needsSyscallPackage bool) map[string]bool {
 	paths := map[string]bool{
 		"/":                     true,
-		"crypto/":               true,
-		"crypto/rand/":          false,
 		"device/":               false,
 		"examples/":             false,
 		"internal/":             true,
@@ -229,7 +208,6 @@ func pathsToOverride(needsSyscallPackage bool) map[string]bool {
 		"internal/reflectlite/": false,
 		"internal/task/":        false,
 		"machine/":              false,
-		"net/":                  true,
 		"os/":                   true,
 		"reflect/":              false,
 		"runtime/":              false,

loader/loader.go

@@ -343,11 +343,12 @@ func (p *Package) Check() error {
 	checker.Importer = p
 
 	packageName := p.ImportPath
-	if p == p.program.MainPkg() {
-		if p.Name != "main" {
-			// Sanity check. Should not ever trigger.
-			panic("expected main package to have name 'main'")
-		}
+	if p.Name == "main" {
+		// The main package normally has a different import path, such as
+		// "command-line-arguments" or "./testdata/cgo". Therefore, use the name
+		// "main" in such a case: this package isn't imported from anywhere.
+		// This is safe as it isn't possible to import a package with the name
+		// "main".
 		packageName = "main"
 	}
 	typesPkg, err := checker.Check(packageName, p.program.fset, p.Files, &p.info)

main.go

@@ -15,7 +15,6 @@ import (
 	"path/filepath"
 	"regexp"
 	"runtime"
-	"strconv"
 	"strings"
 	"sync/atomic"
 	"time"
@@ -96,31 +95,12 @@ func copyFile(src, dst string) error {
 
 // executeCommand is a simple wrapper to exec.Cmd
 func executeCommand(options *compileopts.Options, name string, arg ...string) *exec.Cmd {
-	if options.PrintCommands != nil {
-		options.PrintCommands(name, arg...)
+	if options.PrintCommands {
+		fmt.Printf("%s %s\n", name, strings.Join(arg, " "))
 	}
 	return exec.Command(name, arg...)
 }
 
-// printCommand prints a command to stdout while formatting it like a real
-// command (escaping characters etc). The resulting command should be easy to
-// run directly in a shell, although it is not guaranteed to be a safe shell
-// escape. That's not a problem as the primary use case is printing the command,
-// not running it.
-func printCommand(cmd string, args ...string) {
-	command := append([]string{cmd}, args...)
-	for i, arg := range command {
-		// Source: https://www.oreilly.com/library/view/learning-the-bash/1565923472/ch01s09.html
-		const specialChars = "~`#$&*()\\|[]{};'\"<>?! "
-		if strings.ContainsAny(arg, specialChars) {
-			// See: https://stackoverflow.com/questions/15783701/which-characters-need-to-be-escaped-when-using-bash
-			arg = "'" + strings.ReplaceAll(arg, `'`, `'\''`) + "'"
-			command[i] = arg
-		}
-	}
-	fmt.Fprintln(os.Stderr, strings.Join(command, " "))
-}
-
 // Build compiles and links the given package and writes it to outpath.
 func Build(pkgName, outpath string, options *compileopts.Options) error {
 	config, err := builder.NewConfig(options)
@@ -165,7 +145,7 @@ func Test(pkgName string, options *compileopts.Options, testCompileOnly bool, ou
 		return false, err
 	}
 
-	passed := true
+	var passed bool
 	err = builder.Build(pkgName, outpath, config, func(result builder.BuildResult) error {
 		if testCompileOnly || outpath != "" {
 			// Write test binary to the specified file name.
@@ -276,8 +256,6 @@ func Flash(pkgName, port string, options *compileopts.Options) error {
 			fileExt = ".bin"
 		case strings.Contains(config.Target.FlashCommand, "{uf2}"):
 			fileExt = ".uf2"
-		case strings.Contains(config.Target.FlashCommand, "{zip}"):
-			fileExt = ".zip"
 		default:
 			return errors.New("invalid target file - did you forget the {hex} token in the 'flash-command' section?")
 		}
@@ -297,7 +275,7 @@ func Flash(pkgName, port string, options *compileopts.Options) error {
 	return builder.Build(pkgName, fileExt, config, func(result builder.BuildResult) error {
 		// do we need port reset to put MCU into bootloader mode?
 		if config.Target.PortReset == "true" && flashMethod != "openocd" {
-			port, err := getDefaultPort(port, config.Target.SerialPort)
+			port, err := getDefaultPort(strings.FieldsFunc(port, func(c rune) bool { return c == ',' }))
 			if err != nil {
 				return err
 			}
@@ -315,36 +293,36 @@ func Flash(pkgName, port string, options *compileopts.Options) error {
 		case "", "command":
 			// Create the command.
 			flashCmd := config.Target.FlashCommand
-			flashCmdList, err := shlex.Split(flashCmd)
-			if err != nil {
-				return fmt.Errorf("could not parse flash command %#v: %w", flashCmd, err)
-			}
+			fileToken := "{" + fileExt[1:] + "}"
+			flashCmd = strings.ReplaceAll(flashCmd, fileToken, result.Binary)
 
 			if strings.Contains(flashCmd, "{port}") {
 				var err error
-				port, err = getDefaultPort(port, config.Target.SerialPort)
+				port, err = getDefaultPort(strings.FieldsFunc(port, func(c rune) bool { return c == ',' }))
 				if err != nil {
 					return err
 				}
 			}
 
-			// Fill in fields in the command template.
-			fileToken := "{" + fileExt[1:] + "}"
-			for i, arg := range flashCmdList {
-				arg = strings.ReplaceAll(arg, fileToken, result.Binary)
-				arg = strings.ReplaceAll(arg, "{port}", port)
-				flashCmdList[i] = arg
-			}
+			flashCmd = strings.ReplaceAll(flashCmd, "{port}", port)
 
 			// Execute the command.
-			if len(flashCmdList) < 2 {
-				return fmt.Errorf("invalid flash command: %#v", flashCmd)
+			var cmd *exec.Cmd
+			switch runtime.GOOS {
+			case "windows":
+				command := strings.Split(flashCmd, " ")
+				if len(command) < 2 {
+					return errors.New("invalid flash command")
+				}
+				cmd = executeCommand(config.Options, command[0], command[1:]...)
+			default:
+				cmd = executeCommand(config.Options, "/bin/sh", "-c", flashCmd)
 			}
-			cmd := executeCommand(config.Options, flashCmdList[0], flashCmdList[1:]...)
+
 			cmd.Stdout = os.Stdout
 			cmd.Stderr = os.Stderr
 			cmd.Dir = goenv.Get("TINYGOROOT")
-			err = cmd.Run()
+			err := cmd.Run()
 			if err != nil {
 				return &commandError{"failed to flash", result.Binary, err}
 			}
@@ -435,7 +413,7 @@ func FlashGDB(pkgName string, ocdOutput bool, options *compileopts.Options) erro
 		case "native":
 			// Run GDB directly.
 		case "openocd":
-			gdbCommands = append(gdbCommands, "target extended-remote :3333", "monitor halt", "load", "monitor reset halt")
+			gdbCommands = append(gdbCommands, "target remote :3333", "monitor halt", "load", "monitor reset halt")
 
 			// We need a separate debugging daemon for on-chip debugging.
 			args, err := config.OpenOCDConfiguration()
@@ -454,7 +432,7 @@ func FlashGDB(pkgName string, ocdOutput bool, options *compileopts.Options) erro
 				daemon.Stderr = w
 			}
 		case "jlink":
-			gdbCommands = append(gdbCommands, "target extended-remote :2331", "load", "monitor reset halt")
+			gdbCommands = append(gdbCommands, "target remote :2331", "load", "monitor reset halt")
 
 			// We need a separate debugging daemon for on-chip debugging.
 			daemon = executeCommand(config.Options, "JLinkGDBServer", "-device", config.Target.JLinkDevice)
@@ -469,7 +447,7 @@ func FlashGDB(pkgName string, ocdOutput bool, options *compileopts.Options) erro
 				daemon.Stderr = w
 			}
 		case "qemu":
-			gdbCommands = append(gdbCommands, "target extended-remote :1234")
+			gdbCommands = append(gdbCommands, "target remote :1234")
 
 			// Run in an emulator.
 			args := append(config.Target.Emulator[1:], result.Binary, "-s", "-S")
@@ -477,7 +455,7 @@ func FlashGDB(pkgName string, ocdOutput bool, options *compileopts.Options) erro
 			daemon.Stdout = os.Stdout
 			daemon.Stderr = os.Stderr
 		case "qemu-user":
-			gdbCommands = append(gdbCommands, "target extended-remote :1234")
+			gdbCommands = append(gdbCommands, "target remote :1234")
 
 			// Run in an emulator.
 			args := append(config.Target.Emulator[1:], "-g", "1234", result.Binary)
@@ -485,7 +463,7 @@ func FlashGDB(pkgName string, ocdOutput bool, options *compileopts.Options) erro
 			daemon.Stdout = os.Stdout
 			daemon.Stderr = os.Stderr
 		case "mgba":
-			gdbCommands = append(gdbCommands, "target extended-remote :2345")
+			gdbCommands = append(gdbCommands, "target remote :2345")
 
 			// Run in an emulator.
 			args := append(config.Target.Emulator[1:], result.Binary, "-g")
@@ -493,7 +471,7 @@ func FlashGDB(pkgName string, ocdOutput bool, options *compileopts.Options) erro
 			daemon.Stdout = os.Stdout
 			daemon.Stderr = os.Stderr
 		case "simavr":
-			gdbCommands = append(gdbCommands, "target extended-remote :1234")
+			gdbCommands = append(gdbCommands, "target remote :1234")
 
 			// Run in an emulator.
 			args := append(config.Target.Emulator[1:], "-g", result.Binary)
@@ -719,8 +697,7 @@ func windowsFindUSBDrive(volume string, options *compileopts.Options) (string, e
 }
 
 // getDefaultPort returns the default serial port depending on the operating system.
-func getDefaultPort(portFlag string, usbInterfaces []string) (port string, err error) {
-	portCandidates := strings.FieldsFunc(portFlag, func(c rune) bool { return c == ',' })
+func getDefaultPort(portCandidates []string) (port string, err error) {
 	if len(portCandidates) == 1 {
 		return portCandidates[0], nil
 	}
@@ -736,70 +713,11 @@ func getDefaultPort(portFlag string, usbInterfaces []string) (port string, err e
 			return "", err
 		}
 
-		var preferredPortIDs [][2]uint16
-		for _, s := range usbInterfaces {
-			parts := strings.Split(s, ":")
-			if len(parts) != 3 || (parts[0] != "acm" && parts[0] == "usb") {
-				// acm and usb are the two types of serial ports recognized
-				// under Linux (ttyACM*, ttyUSB*). Other operating systems don't
-				// generally make this distinction. If this is not one of the
-				// given USB devices, don't try to parse the USB IDs.
-				continue
-			}
-			vid, err := strconv.ParseUint(parts[1], 16, 16)
-			if err != nil {
-				return "", fmt.Errorf("could not parse USB vendor ID %q: %w", parts[1], err)
-			}
-			pid, err := strconv.ParseUint(parts[2], 16, 16)
-			if err != nil {
-				return "", fmt.Errorf("could not parse USB product ID %q: %w", parts[1], err)
-			}
-			preferredPortIDs = append(preferredPortIDs, [2]uint16{uint16(vid), uint16(pid)})
-		}
-
-		var primaryPorts []string   // ports picked from preferred USB VID/PID
-		var secondaryPorts []string // other ports (as a fallback)
 		for _, p := range portsList {
-			if !p.IsUSB {
-				continue
-			}
-			if p.VID != "" && p.PID != "" {
-				foundPort := false
-				vid, vidErr := strconv.ParseUint(p.VID, 16, 16)
-				pid, pidErr := strconv.ParseUint(p.PID, 16, 16)
-				if vidErr == nil && pidErr == nil {
-					for _, id := range preferredPortIDs {
-						if uint16(vid) == id[0] && uint16(pid) == id[1] {
-							primaryPorts = append(primaryPorts, p.Name)
-							foundPort = true
-							continue
-						}
-					}
-				}
-				if foundPort {
-					continue
-				}
-			}
-
-			secondaryPorts = append(secondaryPorts, p.Name)
-		}
-		if len(primaryPorts) == 1 {
-			// There is exactly one match in the set of preferred ports. Use
-			// this port, even if there may be others available. This allows
-			// flashing a specific board even if there are multiple available.
-			return primaryPorts[0], nil
-		} else if len(primaryPorts) > 1 {
-			// There are multiple preferred ports, probably because more than
-			// one device of the same type are connected (e.g. two Arduino
-			// Unos).
-			ports = primaryPorts
-		} else {
-			// No preferred ports found. Fall back to other serial ports
-			// available in the system.
-			ports = secondaryPorts
+			ports = append(ports, p.Name)
 		}
 
-		if len(ports) == 0 {
+		if ports == nil || len(ports) == 0 {
 			// fallback
 			switch runtime.GOOS {
 			case "darwin":
@@ -1009,7 +927,6 @@ func main() {
 	gc := flag.String("gc", "", "garbage collector to use (none, leaking, extalloc, conservative)")
 	panicStrategy := flag.String("panic", "print", "panic strategy (print, trap)")
 	scheduler := flag.String("scheduler", "", "which scheduler to use (none, coroutines, tasks)")
-	serial := flag.String("serial", "", "which serial output to use (none, uart, usb)")
 	printIR := flag.Bool("printir", false, "print LLVM IR")
 	dumpSSA := flag.Bool("dumpssa", false, "dump internal Go SSA")
 	verifyIR := flag.Bool("verifyir", false, "run extra verification steps on LLVM IR")
@@ -1028,11 +945,10 @@ func main() {
 	wasmAbi := flag.String("wasm-abi", "", "WebAssembly ABI conventions: js (no i64 params) or generic")
 	llvmFeatures := flag.String("llvm-features", "", "comma separated LLVM features to enable")
 
-	var flagJSON, flagDeps, flagTest *bool
+	var flagJSON, flagDeps *bool
 	if command == "help" || command == "list" {
 		flagJSON = flag.Bool("json", false, "print data in JSON format")
-		flagDeps = flag.Bool("deps", false, "supply -deps flag to go list")
-		flagTest = flag.Bool("test", false, "supply -test flag to go list")
+		flagDeps = flag.Bool("deps", false, "")
 	}
 	var outpath string
 	if command == "help" || command == "build" || command == "build-library" || command == "test" {
@@ -1082,7 +998,6 @@ func main() {
 		GC:              *gc,
 		PanicStrategy:   *panicStrategy,
 		Scheduler:       *scheduler,
-		Serial:          *serial,
 		PrintIR:         *printIR,
 		DumpSSA:         *dumpSSA,
 		VerifyIR:        *verifyIR,
@@ -1090,6 +1005,7 @@ func main() {
 		PrintSizes:      *printSize,
 		PrintStacks:     *printStacks,
 		PrintAllocs:     printAllocs,
+		PrintCommands:   *printCommands,
 		Tags:            *tags,
 		GlobalValues:    globalVarValues,
 		WasmAbi:         *wasmAbi,
@@ -1097,9 +1013,6 @@ func main() {
 		OpenOCDCommands: ocdCommands,
 		LLVMFeatures:    *llvmFeatures,
 	}
-	if *printCommands {
-		options.PrintCommands = printCommand
-	}
 
 	os.Setenv("CC", "clang -target="+*target)
 
@@ -1285,9 +1198,6 @@ func main() {
 		if *flagDeps {
 			extraArgs = append(extraArgs, "-deps")
 		}
-		if *flagTest {
-			extraArgs = append(extraArgs, "-test")
-		}
 		cmd, err := loader.List(config, extraArgs, flag.Args())
 		if err != nil {
 			fmt.Fprintln(os.Stderr, "failed to run `go list`:", err)

main_test.go

@@ -35,9 +35,9 @@ func TestCompiler(t *testing.T) {
 		"calls.go",
 		"cgo/",
 		"channel.go",
+		"coroutines.go",
 		"float.go",
 		"gc.go",
-		"goroutines.go",
 		"init.go",
 		"init_multi.go",
 		"interface.go",

src/crypto/rand/rand.go

@@ -1,19 +0,0 @@
-// Copyright 2010 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.
-
-// Package rand implements a cryptographically secure
-// random number generator.
-package rand
-
-import "io"
-
-// Reader is a global, shared instance of a cryptographically
-// secure random number generator.
-var Reader io.Reader
-
-// Read is a helper function that calls Reader.Read using io.ReadFull.
-// On return, n == len(b) if and only if err == nil.
-func Read(b []byte) (n int, err error) {
-	return io.ReadFull(Reader, b)
-}

src/crypto/rand/rand_getentropy.go

@@ -1,38 +0,0 @@
-// +build darwin freebsd wasi
-
-// This implementation of crypto/rand uses the getentropy system call (available
-// on both MacOS and WASI) to generate random numbers.
-
-package rand
-
-import (
-	"errors"
-	"unsafe"
-)
-
-var errReadFailed = errors.New("rand: could not read random bytes")
-
-func init() {
-	Reader = &reader{}
-}
-
-type reader struct {
-}
-
-func (r *reader) Read(b []byte) (n int, err error) {
-	if len(b) != 0 {
-		if len(b) > 256 {
-			b = b[:256]
-		}
-		result := libc_getentropy(unsafe.Pointer(&b[0]), len(b))
-		if result < 0 {
-			// Maybe we should return a syscall.Errno here?
-			return 0, errReadFailed
-		}
-	}
-	return len(b), nil
-}
-
-// int getentropy(void *buf, size_t buflen);
-//export getentropy
-func libc_getentropy(buf unsafe.Pointer, buflen int) int

src/crypto/rand/rand_urandom.go

@@ -1,38 +0,0 @@
-// +build linux,!baremetal,!wasi
-
-// This implementation of crypto/rand uses the /dev/urandom pseudo-file to
-// generate random numbers.
-// TODO: convert to the getentropy or getrandom libc function on Linux once it
-// is more widely supported.
-
-package rand
-
-import (
-	"syscall"
-)
-
-func init() {
-	Reader = &reader{}
-}
-
-type reader struct {
-	fd int
-}
-
-func (r *reader) Read(b []byte) (n int, err error) {
-	if len(b) == 0 {
-		return
-	}
-
-	// Open /dev/urandom first if needed.
-	if r.fd == 0 {
-		fd, err := syscall.Open("/dev/urandom", syscall.O_RDONLY, 0)
-		if err != nil {
-			return 0, err
-		}
-		r.fd = fd
-	}
-
-	// Read from the file.
-	return syscall.Read(r.fd, b)
-}

src/crypto/rand/util.go

@@ -1,143 +0,0 @@
-// Copyright 2011 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.
-
-package rand
-
-import (
-	"errors"
-	"io"
-	"math/big"
-)
-
-// smallPrimes is a list of small, prime numbers that allows us to rapidly
-// exclude some fraction of composite candidates when searching for a random
-// prime. This list is truncated at the point where smallPrimesProduct exceeds
-// a uint64. It does not include two because we ensure that the candidates are
-// odd by construction.
-var smallPrimes = []uint8{
-	3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53,
-}
-
-// smallPrimesProduct is the product of the values in smallPrimes and allows us
-// to reduce a candidate prime by this number and then determine whether it's
-// coprime to all the elements of smallPrimes without further big.Int
-// operations.
-var smallPrimesProduct = new(big.Int).SetUint64(16294579238595022365)
-
-// Prime returns a number, p, of the given size, such that p is prime
-// with high probability.
-// Prime will return error for any error returned by rand.Read or if bits < 2.
-func Prime(rand io.Reader, bits int) (p *big.Int, err error) {
-	if bits < 2 {
-		err = errors.New("crypto/rand: prime size must be at least 2-bit")
-		return
-	}
-
-	b := uint(bits % 8)
-	if b == 0 {
-		b = 8
-	}
-
-	bytes := make([]byte, (bits+7)/8)
-	p = new(big.Int)
-
-	bigMod := new(big.Int)
-
-	for {
-		_, err = io.ReadFull(rand, bytes)
-		if err != nil {
-			return nil, err
-		}
-
-		// Clear bits in the first byte to make sure the candidate has a size <= bits.
-		bytes[0] &= uint8(int(1<<b) - 1)
-		// Don't let the value be too small, i.e, set the most significant two bits.
-		// Setting the top two bits, rather than just the top bit,
-		// means that when two of these values are multiplied together,
-		// the result isn't ever one bit short.
-		if b >= 2 {
-			bytes[0] |= 3 << (b - 2)
-		} else {
-			// Here b==1, because b cannot be zero.
-			bytes[0] |= 1
-			if len(bytes) > 1 {
-				bytes[1] |= 0x80
-			}
-		}
-		// Make the value odd since an even number this large certainly isn't prime.
-		bytes[len(bytes)-1] |= 1
-
-		p.SetBytes(bytes)
-
-		// Calculate the value mod the product of smallPrimes. If it's
-		// a multiple of any of these primes we add two until it isn't.
-		// The probability of overflowing is minimal and can be ignored
-		// because we still perform Miller-Rabin tests on the result.
-		bigMod.Mod(p, smallPrimesProduct)
-		mod := bigMod.Uint64()
-
-	NextDelta:
-		for delta := uint64(0); delta < 1<<20; delta += 2 {
-			m := mod + delta
-			for _, prime := range smallPrimes {
-				if m%uint64(prime) == 0 && (bits > 6 || m != uint64(prime)) {
-					continue NextDelta
-				}
-			}
-
-			if delta > 0 {
-				bigMod.SetUint64(delta)
-				p.Add(p, bigMod)
-			}
-			break
-		}
-
-		// There is a tiny possibility that, by adding delta, we caused
-		// the number to be one bit too long. Thus we check BitLen
-		// here.
-		if p.ProbablyPrime(20) && p.BitLen() == bits {
-			return
-		}
-	}
-}
-
-// Int returns a uniform random value in [0, max). It panics if max <= 0.
-func Int(rand io.Reader, max *big.Int) (n *big.Int, err error) {
-	if max.Sign() <= 0 {
-		panic("crypto/rand: argument to Int is <= 0")
-	}
-	n = new(big.Int)
-	n.Sub(max, n.SetUint64(1))
-	// bitLen is the maximum bit length needed to encode a value < max.
-	bitLen := n.BitLen()
-	if bitLen == 0 {
-		// the only valid result is 0
-		return
-	}
-	// k is the maximum byte length needed to encode a value < max.
-	k := (bitLen + 7) / 8
-	// b is the number of bits in the most significant byte of max-1.
-	b := uint(bitLen % 8)
-	if b == 0 {
-		b = 8
-	}
-
-	bytes := make([]byte, k)
-
-	for {
-		_, err = io.ReadFull(rand, bytes)
-		if err != nil {
-			return nil, err
-		}
-
-		// Clear bits in the first byte to increase the probability
-		// that the candidate is < max.
-		bytes[0] &= uint8(int(1<<b) - 1)
-
-		n.SetBytes(bytes)
-		if n.Cmp(max) < 0 {
-			return
-		}
-	}
-}

src/device/nxp/mimxrt1062_mpu.go

@@ -7,7 +7,7 @@
 package nxp
 
 import (
-	"github.com/sago35/device/arm"
+	"device/arm"
 	"runtime/volatile"
 	"unsafe"
 )

src/examples/adc/adc.go

@@ -14,7 +14,7 @@ func main() {
 	led := machine.LED
 	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
 
-	sensor := machine.ADC{machine.ADC2}
+	sensor := machine.ADC{Pin: machine.ADC2}
 	sensor.Configure(machine.ADCConfig{})
 
 	for {

src/examples/can/feather-m4-can.go

@@ -1,15 +0,0 @@
-// +build feather_m4_can
-
-package main
-
-import (
-	"machine"
-)
-
-func init() {
-	// power on the CAN Transceiver
-	// https://learn.adafruit.com/adafruit-feather-m4-can-express/pinouts#can-bus-3078990-8
-	boost_en := machine.BOOST_EN
-	boost_en.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	boost_en.High()
-}

src/examples/can/main.go

@@ -1,53 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"machine"
-	"time"
-)
-
-func main() {
-	can1 := machine.CAN1
-	can1.Configure(machine.CANConfig{
-		TransferRate:   machine.CANTransferRate500kbps,
-		TransferRateFD: machine.CANTransferRate1000kbps,
-		Rx:             machine.CAN1_RX,
-		Tx:             machine.CAN1_TX,
-		Standby:        machine.CAN1_STANDBY,
-	})
-
-	can0 := machine.CAN0
-	can0.Configure(machine.CANConfig{
-		TransferRate:   machine.CANTransferRate500kbps,
-		TransferRateFD: machine.CANTransferRate1000kbps,
-		Rx:             machine.CAN0_RX,
-		Tx:             machine.CAN0_TX,
-		Standby:        machine.NoPin,
-	})
-
-	rxMsg := machine.CANRxBufferElement{}
-
-	for {
-		can1.Tx(0x123, []byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, false, false)
-		can1.Tx(0x789, []byte{0x02, 0x24, 0x46, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, true, false)
-		time.Sleep(time.Millisecond * 1000)
-
-		sz0 := can0.RxFifoSize()
-		if sz0 > 0 {
-			fmt.Printf("CAN0 %d\r\n", sz0)
-			for i := 0; i < sz0; i++ {
-				can0.RxRaw(&rxMsg)
-				fmt.Printf("-> %08X %X %#v\r\n", rxMsg.ID, rxMsg.DLC, rxMsg.Data())
-			}
-		}
-
-		sz1 := can1.RxFifoSize()
-		if sz1 > 0 {
-			fmt.Printf("CAN1 %d\r\n", sz1)
-			for i := 0; i < sz1; i++ {
-				can1.RxRaw(&rxMsg)
-				fmt.Printf("-> %08X %X %#v\r\n", rxMsg.ID, rxMsg.DLC, rxMsg.Data())
-			}
-		}
-	}
-}

src/examples/caninterrupt/feather-m4-can.go

@@ -1,15 +0,0 @@
-// +build feather_m4_can
-
-package main
-
-import (
-	"machine"
-)
-
-func init() {
-	// power on the CAN Transceiver
-	// https://learn.adafruit.com/adafruit-feather-m4-can-express/pinouts#can-bus-3078990-8
-	boost_en := machine.BOOST_EN
-	boost_en.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	boost_en.High()
-}

src/examples/caninterrupt/main.go

@@ -1,75 +0,0 @@
-package main
-
-import (
-	"github.com/sago35/device/sam"
-	"fmt"
-	"machine"
-	"time"
-)
-
-type canMsg struct {
-	ch   byte
-	id   uint32
-	dlc  byte
-	data []byte
-}
-
-func main() {
-	ch := make(chan canMsg, 10)
-	go func() {
-		for {
-			select {
-			case m := <-ch:
-				fmt.Printf("%d %03X %X ", m.ch, m.id, m.dlc)
-				for _, d := range m.data {
-					fmt.Printf("%02X ", d)
-				}
-				fmt.Printf("\r\n")
-			}
-
-		}
-	}()
-
-	can1 := machine.CAN1
-	can1.Configure(machine.CANConfig{
-		TransferRate:   machine.CANTransferRate500kbps,
-		TransferRateFD: machine.CANTransferRate1000kbps,
-		Rx:             machine.CAN1_RX,
-		Tx:             machine.CAN1_TX,
-		Standby:        machine.CAN1_STANDBY,
-	})
-	// RF0NE : Rx FIFO 0 New Message Interrupt Enable
-	can1.SetInterrupt(sam.CAN_IE_RF0NE, func(*machine.CAN) {
-		rxMsg := machine.CANRxBufferElement{}
-		can1.RxRaw(&rxMsg)
-		m := canMsg{ch: 1, id: rxMsg.ID, dlc: rxMsg.DLC, data: rxMsg.Data()}
-		select {
-		case ch <- m:
-		}
-	})
-
-	can0 := machine.CAN0
-	can0.Configure(machine.CANConfig{
-		TransferRate:   machine.CANTransferRate500kbps,
-		TransferRateFD: machine.CANTransferRate1000kbps,
-		Rx:             machine.CAN0_RX,
-		Tx:             machine.CAN0_TX,
-		Standby:        machine.NoPin,
-	})
-	// RF0NE : Rx FIFO 0 New Message Interrupt Enable
-	can0.SetInterrupt(sam.CAN_IE_RF0NE, func(*machine.CAN) {
-		rxMsg := machine.CANRxBufferElement{}
-		can0.RxRaw(&rxMsg)
-		m := canMsg{ch: 2, id: rxMsg.ID, dlc: rxMsg.DLC, data: rxMsg.Data()}
-		select {
-		case ch <- m:
-		}
-	})
-
-	for {
-		can0.Tx(0x123, []byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, false, false)
-		time.Sleep(time.Millisecond * 500)
-		can1.Tx(0x456, []byte{0xAA, 0xBB, 0xCC}, false, false)
-		time.Sleep(time.Millisecond * 1000)
-	}
-}

src/examples/echo/echo.go

@@ -9,7 +9,7 @@ import (
 
 // change these to test a different UART or pins if available
 var (
-	uart = machine.Serial
+	uart = machine.UART0
 	tx   = machine.UART_TX_PIN
 	rx   = machine.UART_RX_PIN
 )

src/examples/memstats/memstats.go

@@ -1,32 +0,0 @@
-package main
-
-import (
-	"math/rand"
-	"runtime"
-	"time"
-)
-
-func main() {
-
-	ms := runtime.MemStats{}
-
-	for {
-		escapesToHeap()
-		runtime.ReadMemStats(&ms)
-		println("Heap before GC. Used: ", ms.HeapInuse, " Free: ", ms.HeapIdle, " Meta: ", ms.GCSys)
-		runtime.GC()
-		runtime.ReadMemStats(&ms)
-		println("Heap after  GC. Used: ", ms.HeapInuse, " Free: ", ms.HeapIdle, " Meta: ", ms.GCSys)
-		time.Sleep(5 * time.Second)
-	}
-
-}
-
-func escapesToHeap() {
-	n := rand.Intn(100)
-	println("Doing ", n, " iterations")
-	for i := 0; i < n; i++ {
-		s := make([]byte, i)
-		_ = append(s, 42)
-	}
-}

src/examples/pininterrupt/stm32.go

@@ -1,10 +0,0 @@
-// +build stm32
-
-package main
-
-import "machine"
-
-const (
-	buttonMode      = machine.PinInputPulldown
-	buttonPinChange = machine.PinRising | machine.PinFalling
-)

src/examples/pwm/bluepill.go

@@ -1,11 +0,0 @@
-// +build bluepill
-
-package main
-
-import "machine"
-
-var (
-	pwm  = &machine.TIM2
-	pinA = machine.PA0
-	pinB = machine.PA1
-)

src/examples/pwm/nucleo-f722ze.go

@@ -1,11 +0,0 @@
-// +build stm32f7
-
-package main
-
-import "machine"
-
-var (
-	pwm  = &machine.TIM1
-	pinA = machine.PA8
-	pinB = machine.PA9
-)

src/examples/pwm/nucleo-l031k6.go

@@ -1,11 +0,0 @@
-// +build stm32l0
-
-package main
-
-import "machine"
-
-var (
-	pwm  = &machine.TIM2
-	pinA = machine.PA0
-	pinB = machine.PB3
-)

src/examples/pwm/nucleo-l432kc.go

@@ -1,11 +0,0 @@
-// +build stm32l4
-
-package main
-
-import "machine"
-
-var (
-	pwm  = &machine.TIM2
-	pinA = machine.PA0
-	pinB = machine.PB3
-)

src/examples/pwm/nucleo-l552ze.go

@@ -1,11 +0,0 @@
-// +build stm32l5
-
-package main
-
-import "machine"
-
-var (
-	pwm  = &machine.TIM1
-	pinA = machine.PA8
-	pinB = machine.PA9
-)

src/examples/pwm/stm32f4disco.go

@@ -1,13 +0,0 @@
-// +build stm32f4disco
-
-package main
-
-import "machine"
-
-var (
-	// These pins correspond to LEDs on the discovery
-	// board
-	pwm  = &machine.TIM4
-	pinA = machine.PD12
-	pinB = machine.PD13
-)

src/examples/systick/systick.go

@@ -1,7 +1,7 @@
 package main
 
 import (
-	"github.com/sago35/device/arm"
+	"device/arm"
 	"machine"
 )
 

src/internal/task/task.go

@@ -13,7 +13,7 @@ type Task struct {
 	Ptr unsafe.Pointer
 
 	// Data is a field which can be used for storing state information.
-	Data uint64
+	Data uint
 
 	// state is the underlying running state of the task.
 	state state

src/internal/task/task_stack_cortexm.go

@@ -9,7 +9,7 @@ package task
 // space for interrupts.
 
 import (
-	"github.com/sago35/device/arm"
+	"device/arm"
 	"unsafe"
 )
 

src/machine/adc.go

@@ -9,4 +9,11 @@ type ADCConfig struct {
 	Reference  uint32 // analog reference voltage (AREF) in millivolts
 	Resolution uint32 // number of bits for a single conversion (e.g., 8, 10, 12)
 	Samples    uint32 // number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	Bus        uint8  // bus Number of ADC
 }
+
+const (
+	AdcBusAuto = 0
+	AdcBus0    = 1
+	AdcBus1    = 2
+)

src/machine/board_arduino_mkr1000.go

@@ -47,7 +47,7 @@ const (
 	LED = D6
 )
 
-// USBCDC pins
+// UART0 aka USBCDC pins
 const (
 	USBCDC_DM_PIN Pin = PA24
 	USBCDC_DP_PIN Pin = PA25

src/machine/board_arduino_nano33.go

@@ -46,7 +46,7 @@ const (
 	LED = D13
 )
 
-// USBCDC pins
+// UART0 aka USBCDC pins
 const (
 	USBCDC_DM_PIN Pin = PA24
 	USBCDC_DP_PIN Pin = PA25

src/machine/board_arduino_nano33_baremetal.go

@@ -3,14 +3,13 @@
 package machine
 
 import (
-	"github.com/sago35/device/sam"
+	"device/sam"
 	"runtime/interrupt"
 )
 
 // UART1 on the Arduino Nano 33 connects to the onboard NINA-W102 WiFi chip.
 var (
-	UART1  = &_UART1
-	_UART1 = UART{
+	UART1 = UART{
 		Buffer: NewRingBuffer(),
 		Bus:    sam.SERCOM3_USART,
 		SERCOM: 3,
@@ -19,8 +18,7 @@ var (
 
 // UART2 on the Arduino Nano 33 connects to the normal TX/RX pins.
 var (
-	UART2  = &_UART2
-	_UART2 = UART{
+	UART2 = UART{
 		Buffer: NewRingBuffer(),
 		Bus:    sam.SERCOM5_USART,
 		SERCOM: 5,
@@ -28,8 +26,8 @@ var (
 )
 
 func init() {
-	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM3, _UART1.handleInterrupt)
-	UART2.Interrupt = interrupt.New(sam.IRQ_SERCOM5, _UART2.handleInterrupt)
+	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM3, UART1.handleInterrupt)
+	UART2.Interrupt = interrupt.New(sam.IRQ_SERCOM5, UART2.handleInterrupt)
 }
 
 // I2C on the Arduino Nano 33.

src/machine/board_atsame54-xpro.go

@@ -3,7 +3,7 @@
 package machine
 
 import (
-	"github.com/sago35/device/sam"
+	"device/sam"
 	"runtime/interrupt"
 )
 
@@ -152,7 +152,7 @@ const (
 	PIN_USB_ID      = PC19
 )
 
-// USBCDC pins
+// UART0 aka USBCDC pins
 const (
 	USBCDC_DM_PIN = PA24
 	USBCDC_DP_PIN = PA25
@@ -240,32 +240,28 @@ var (
 // UART on the SAM E54 Xplained Pro
 var (
 	// Extension Header EXT1
-	UART1  = &_UART1
-	_UART1 = UART{
+	UART1 = UART{
 		Buffer: NewRingBuffer(),
 		Bus:    sam.SERCOM0_USART_INT,
 		SERCOM: 0,
 	}
 
 	// Extension Header EXT2
-	UART2  = &_UART2
-	_UART2 = UART{
+	UART2 = UART{
 		Buffer: NewRingBuffer(),
 		Bus:    sam.SERCOM5_USART_INT,
 		SERCOM: 5,
 	}
 
 	// Extension Header EXT3
-	UART3  = &_UART3
-	_UART3 = UART{
+	UART3 = UART{
 		Buffer: NewRingBuffer(),
 		Bus:    sam.SERCOM1_USART_INT,
 		SERCOM: 1,
 	}
 
 	// EDBG Virtual COM Port
-	UART4  = &_UART4
-	_UART4 = UART{
+	UART4 = UART{
 		Buffer: NewRingBuffer(),
 		Bus:    sam.SERCOM2_USART_INT,
 		SERCOM: 2,
@@ -273,10 +269,10 @@ var (
 )
 
 func init() {
-	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, _UART1.handleInterrupt)
-	UART2.Interrupt = interrupt.New(sam.IRQ_SERCOM5_2, _UART2.handleInterrupt)
-	UART3.Interrupt = interrupt.New(sam.IRQ_SERCOM1_2, _UART3.handleInterrupt)
-	UART4.Interrupt = interrupt.New(sam.IRQ_SERCOM2_2, _UART4.handleInterrupt)
+	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, UART1.handleInterrupt)
+	UART2.Interrupt = interrupt.New(sam.IRQ_SERCOM5_2, UART2.handleInterrupt)
+	UART3.Interrupt = interrupt.New(sam.IRQ_SERCOM1_2, UART3.handleInterrupt)
+	UART4.Interrupt = interrupt.New(sam.IRQ_SERCOM2_2, UART4.handleInterrupt)
 }
 
 // I2C on the SAM E54 Xplained Pro
@@ -332,14 +328,3 @@ var (
 		SERCOM: 6,
 	}
 )
-
-// CAN on the SAM E54 Xplained Pro
-var (
-	CAN0 = CAN{
-		Bus: sam.CAN0,
-	}
-
-	CAN1 = CAN{
-		Bus: sam.CAN1,
-	}
-)

src/machine/board_bluepill.go

@@ -3,22 +3,53 @@
 package machine
 
 import (
-	"github.com/sago35/device/stm32"
+	"device/stm32"
 	"runtime/interrupt"
 )
 
+// https://wiki.stm32duino.com/index.php?title=File:Bluepillpinout.gif
+const (
+	PA0  = portA + 0
+	PA1  = portA + 1
+	PA2  = portA + 2
+	PA3  = portA + 3
+	PA4  = portA + 4
+	PA5  = portA + 5
+	PA6  = portA + 6
+	PA7  = portA + 7
+	PA8  = portA + 8
+	PA9  = portA + 9
+	PA10 = portA + 10
+	PA11 = portA + 11
+	PA12 = portA + 12
+	PA13 = portA + 13
+	PA14 = portA + 14
+	PA15 = portA + 15
+	PB0  = portB + 0
+	PB1  = portB + 1
+	PB2  = portB + 2
+	PB3  = portB + 3
+	PB4  = portB + 4
+	PB5  = portB + 5
+	PB6  = portB + 6
+	PB7  = portB + 7
+	PB8  = portB + 8
+	PB9  = portB + 9
+	PB10 = portB + 10
+	PB11 = portB + 11
+	PB12 = portB + 12
+	PB13 = portB + 13
+	PB14 = portB + 14
+	PB15 = portB + 15
+	PC13 = portC + 13
+	PC14 = portC + 14
+	PC15 = portC + 15
+)
+
 const (
 	LED = PC13
 )
 
-const (
-	// This board does not have a user button, so
-	// use first GPIO pin by default
-	BUTTON = PA0
-)
-
-var DefaultUART = UART1
-
 // UART pins
 const (
 	UART_TX_PIN     = PA9
@@ -29,21 +60,20 @@ const (
 
 var (
 	// USART1 is the first hardware serial port on the STM32.
-	UART1  = &_UART1
-	_UART1 = UART{
+	// Both UART0 and UART1 refer to USART1.
+	UART0 = UART{
 		Buffer: NewRingBuffer(),
 		Bus:    stm32.USART1,
 	}
-	UART2  = &_UART2
-	_UART2 = UART{
+	UART1 = UART{
 		Buffer: NewRingBuffer(),
 		Bus:    stm32.USART2,
 	}
 )
 
 func init() {
-	UART1.Interrupt = interrupt.New(stm32.IRQ_USART1, _UART1.handleInterrupt)
-	UART2.Interrupt = interrupt.New(stm32.IRQ_USART2, _UART2.handleInterrupt)
+	UART0.Interrupt = interrupt.New(stm32.IRQ_USART1, UART0.handleInterrupt)
+	UART1.Interrupt = interrupt.New(stm32.IRQ_USART2, UART1.handleInterrupt)
 }
 
 // SPI pins

src/machine/board_circuitplay_bluefruit.go

@@ -38,7 +38,6 @@ const (
 const (
 	LED       = D13
 	NEOPIXELS = D8
-	WS2812    = D8
 
 	BUTTONA = D4
 	BUTTONB = D5
@@ -57,6 +56,11 @@ const (
 	UART_RX_PIN = P0_30 // PORTB
 )
 
+// UART0 is the USB device
+var (
+	UART0 = &USB
+)
+
 // I2C pins
 const (
 	SDA_PIN = P0_05 // I2C0 external

src/machine/board_circuitplay_express.go

@@ -41,7 +41,6 @@ const (
 const (
 	LED       = D13
 	NEOPIXELS = D8
-	WS2812    = D8
 
 	BUTTONA = D4
 	BUTTONB = D5

src/machine/board_circuitplay_express_baremetal.go

@@ -3,14 +3,13 @@
 package machine
 
 import (
-	"github.com/sago35/device/sam"
+	"device/sam"
 	"runtime/interrupt"
 )
 
 // UART1 on the Circuit Playground Express.
 var (
-	UART1  = &_UART1
-	_UART1 = UART{
+	UART1 = UART{
 		Buffer: NewRingBuffer(),
 		Bus:    sam.SERCOM4_USART,
 		SERCOM: 4,
@@ -18,7 +17,7 @@ var (
 )
 
 func init() {
-	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM4, _UART1.handleInterrupt)
+	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM4, UART1.handleInterrupt)
 }
 
 // I2C on the Circuit Playground Express.

src/machine/board_clue_alpha.go

@@ -72,7 +72,6 @@ const (
 	LED1     = LED
 	LED2     = D43
 	NEOPIXEL = D18
-	WS2812   = D18
 
 	BUTTON_LEFT  = D5
 	BUTTON_RIGHT = D11
@@ -104,6 +103,11 @@ const (
 	UART_TX_PIN = D1
 )
 
+// UART0 is the USB device
+var (
+	UART0 = &USB
+)
+
 // I2C pins
 const (
 	SDA_PIN = D20 // I2C0 external

src/machine/board_feather-m0.go

@@ -3,7 +3,7 @@
 package machine
 
 import (
-	"github.com/sago35/device/sam"
+	"device/sam"
 	"runtime/interrupt"
 )
 
@@ -42,7 +42,7 @@ const (
 	LED = D13
 )
 
-// USBCDC pins
+// UART0 aka USBCDC pins
 const (
 	USBCDC_DM_PIN = PA24
 	USBCDC_DP_PIN = PA25
@@ -56,8 +56,7 @@ const (
 
 // UART1 on the Feather M0.
 var (
-	UART1  = &_UART1
-	_UART1 = UART{
+	UART1 = UART{
 		Buffer: NewRingBuffer(),
 		Bus:    sam.SERCOM1_USART,
 		SERCOM: 1,
@@ -65,7 +64,7 @@ var (
 )
 
 func init() {
-	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM1, _UART1.handleInterrupt)
+	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM1, UART1.handleInterrupt)
 }
 
 // I2C pins

src/machine/board_feather-m4-can.go

@@ -3,7 +3,7 @@
 package machine
 
 import (
-	"github.com/sago35/device/sam"
+	"device/sam"
 	"runtime/interrupt"
 )
 
@@ -44,10 +44,9 @@ const (
 const (
 	LED       = D13
 	NEOPIXELS = D8
-	WS2812    = D8
 )
 
-// USBCDC pins
+// UART0 aka USBCDC pins
 const (
 	USBCDC_DM_PIN = PA24
 	USBCDC_DP_PIN = PA25
@@ -104,15 +103,13 @@ var (
 )
 
 var (
-	UART1  = &_UART1
-	_UART1 = UART{
+	UART1 = UART{
 		Buffer: NewRingBuffer(),
 		Bus:    sam.SERCOM5_USART_INT,
 		SERCOM: 5,
 	}
 
-	UART2  = &_UART2
-	_UART2 = UART{
+	UART2 = UART{
 		Buffer: NewRingBuffer(),
 		Bus:    sam.SERCOM0_USART_INT,
 		SERCOM: 0,
@@ -120,15 +117,15 @@ var (
 )
 
 func init() {
-	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM5_2, _UART1.handleInterrupt)
-	UART2.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, _UART2.handleInterrupt)
+	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM5_2, UART1.handleInterrupt)
+	UART2.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, UART2.handleInterrupt)
 
 	// turn on neopixel
 	D7.Configure(PinConfig{Mode: PinOutput})
 	D7.High()
 }
 
-// I2C on the Feather M4 CAN.
+// I2C on the Feather M4.
 var (
 	I2C0 = &I2C{
 		Bus:    sam.SERCOM2_I2CM,
@@ -136,21 +133,10 @@ var (
 	}
 )
 
-// SPI on the Feather M4 CAN.
+// SPI on the Feather M4.
 var (
 	SPI0 = SPI{
 		Bus:    sam.SERCOM1_SPIM,
 		SERCOM: 1,
 	}
 )
-
-// CAN on the Feather M4 CAN.
-var (
-	CAN0 = CAN{
-		Bus: sam.CAN0,
-	}
-
-	CAN1 = CAN{
-		Bus: sam.CAN1,
-	}
-)

src/machine/board_feather-m4.go

@@ -36,11 +36,10 @@ const (
 )
 
 const (
-	LED    = D13
-	WS2812 = D8
+	LED = D13
 )
 
-// USBCDC pins
+// UART0 aka USBCDC pins
 const (
 	USBCDC_DM_PIN = PA24
 	USBCDC_DP_PIN = PA25

src/machine/board_feather-m4_baremetal.go

@@ -3,20 +3,18 @@
 package machine
 
 import (
-	"github.com/sago35/device/sam"
+	"device/sam"
 	"runtime/interrupt"
 )
 
 var (
-	UART1  = &_UART1
-	_UART1 = UART{
+	UART1 = UART{
 		Buffer: NewRingBuffer(),
 		Bus:    sam.SERCOM5_USART_INT,
 		SERCOM: 5,
 	}
 
-	UART2  = &_UART2
-	_UART2 = UART{
+	UART2 = UART{
 		Buffer: NewRingBuffer(),
 		Bus:    sam.SERCOM0_USART_INT,
 		SERCOM: 0,
@@ -24,8 +22,8 @@ var (
 )
 
 func init() {
-	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM5_2, _UART1.handleInterrupt)
-	UART2.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, _UART2.handleInterrupt)
+	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM5_2, UART1.handleInterrupt)
+	UART2.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, UART2.handleInterrupt)
 }
 
 // I2C on the Feather M4.

src/machine/board_feather-nrf52840-sense.go

@@ -1,101 +0,0 @@
-// +build feather_nrf52840_sense
-
-package machine
-
-const HasLowFrequencyCrystal = true
-
-// GPIO Pins
-const (
-	D0  = P0_25 // UART TX
-	D1  = P0_24 // UART RX
-	D2  = P0_10 // NFC2
-	D3  = P1_11
-	D4  = P1_10 // LED2
-	D5  = P1_08
-	D6  = P0_07
-	D7  = P1_02 // Button
-	D8  = P0_16 // NeoPixel
-	D9  = P0_26
-	D10 = P0_27
-	D11 = P0_06
-	D12 = P0_08
-	D13 = P1_09 // LED1
-	D14 = P0_04 // A0
-	D15 = P0_05 // A1
-	D16 = P0_30 // A2
-	D17 = P0_28 // A3
-	D18 = P0_02 // A4
-	D19 = P0_03 // A5
-	D20 = P0_29 // Battery
-	D21 = P0_31 // AREF
-	D22 = P0_12 // I2C SDA
-	D23 = P0_11 // I2C SCL
-	D24 = P0_15 // SPI MISO
-	D25 = P0_13 // SPI MOSI
-	D26 = P0_14 // SPI SCK
-	D27 = P0_19 // QSPI CLK
-	D28 = P0_20 // QSPI CS
-	D29 = P0_17 // QSPI Data 0
-	D30 = P0_22 // QSPI Data 1
-	D31 = P0_23 // QSPI Data 2
-	D32 = P0_21 // QSPI Data 3
-	D33 = P0_09 // NFC1 (test point on bottom of board)
-)
-
-// Analog Pins
-const (
-	A0 = D14
-	A1 = D15
-	A2 = D16
-	A3 = D17
-	A4 = D18
-	A5 = D19
-	A6 = D20 // Battery
-	A7 = D21 // ARef
-)
-
-const (
-	LED      = D13
-	LED1     = LED
-	LED2     = D4
-	NEOPIXEL = D8
-	WS2812   = D8
-	BUTTON   = D7
-
-	QSPI_SCK   = D27
-	QSPI_CS    = D28
-	QSPI_DATA0 = D29
-	QSPI_DATA1 = D30
-	QSPI_DATA2 = D31
-	QSPI_DATA3 = D32
-)
-
-// UART0 pins (logical UART1)
-const (
-	UART_RX_PIN = D0
-	UART_TX_PIN = D1
-)
-
-// I2C pins
-const (
-	SDA_PIN = D22 // I2C0 external
-	SCL_PIN = D23 // I2C0 external
-)
-
-// SPI pins
-const (
-	SPI0_SCK_PIN = D26 // SCK
-	SPI0_SDO_PIN = D25 // SDO
-	SPI0_SDI_PIN = D24 // SDI
-)
-
-// USB CDC identifiers
-const (
-	usb_STRING_PRODUCT      = "Feather nRF52840 Express"
-	usb_STRING_MANUFACTURER = "Adafruit Industries LLC"
-)
-
-var (
-	usb_VID uint16 = 0x239A
-	usb_PID uint16 = 0x8088
-)

src/machine/board_feather-nrf52840.go

@@ -59,7 +59,6 @@ const (
 	LED1     = LED
 	LED2     = D4
 	NEOPIXEL = D8
-	WS2812   = D8
 	BUTTON   = D7
 
 	QSPI_SCK   = D27
@@ -76,6 +75,11 @@ const (
 	UART_TX_PIN = D1
 )
 
+// UART0 is the USB device
+var (
+	UART0 = &USB
+)
+
 // I2C pins
 const (
 	SDA_PIN = D22 // I2C0 external

src/machine/board_feather-stm32f405.go

@@ -3,7 +3,7 @@
 package machine
 
 import (
-	"github.com/sago35/device/stm32"
+	"device/stm32"
 	"runtime/interrupt"
 )
 
@@ -84,7 +84,6 @@ const (
 	LED_NEOPIXEL = D8
 	LED_BUILTIN  = LED_RED
 	LED          = LED_BUILTIN
-	WS2812       = D8
 )
 
 func initLED() {}
@@ -120,34 +119,31 @@ const (
 )
 
 var (
-	UART1  = &_UART1
-	_UART1 = UART{
+	UART1 = UART{
 		Buffer:            NewRingBuffer(),
 		Bus:               stm32.USART3,
 		TxAltFuncSelector: AF7_USART1_2_3,
 		RxAltFuncSelector: AF7_USART1_2_3,
 	}
-	UART2  = &_UART2
-	_UART2 = UART{
+	UART2 = UART{
 		Buffer:            NewRingBuffer(),
 		Bus:               stm32.USART6,
 		TxAltFuncSelector: AF8_USART4_5_6,
 		RxAltFuncSelector: AF8_USART4_5_6,
 	}
-	UART3  = &_UART3
-	_UART3 = UART{
+	UART3 = UART{
 		Buffer:            NewRingBuffer(),
 		Bus:               stm32.USART1,
 		TxAltFuncSelector: AF7_USART1_2_3,
 		RxAltFuncSelector: AF7_USART1_2_3,
 	}
-	DefaultUART = UART1
+	UART0 = UART1
 )
 
 func initUART() {
-	UART1.Interrupt = interrupt.New(stm32.IRQ_USART3, _UART1.handleInterrupt)
-	UART2.Interrupt = interrupt.New(stm32.IRQ_USART6, _UART2.handleInterrupt)
-	UART3.Interrupt = interrupt.New(stm32.IRQ_USART1, _UART3.handleInterrupt)
+	UART1.Interrupt = interrupt.New(stm32.IRQ_USART3, UART1.handleInterrupt)
+	UART2.Interrupt = interrupt.New(stm32.IRQ_USART6, UART2.handleInterrupt)
+	UART3.Interrupt = interrupt.New(stm32.IRQ_USART1, UART3.handleInterrupt)
 }
 
 // -- SPI ----------------------------------------------------------------------

src/machine/board_feather_rp2040.go

@@ -1,10 +0,0 @@
-// +build feather_rp2040
-
-package machine
-
-const (
-	LED = GPIO13
-
-	// Onboard crystal oscillator frequency, in MHz.
-	xoscFreq = 12 // MHz
-)

src/machine/board_grandcentral-m4.go

@@ -139,7 +139,6 @@ const (
 	LED_RX   = UART_RX_LED_PIN
 	LED_TX   = UART_TX_LED_PIN
 	NEOPIXEL = NEOPIXEL_PIN
-	WS2812   = NEOPIXEL_PIN
 )
 
 // UART pins

src/machine/board_grandcentral-m4_baremetal.go

@@ -3,39 +3,35 @@
 package machine
 
 import (
-	"github.com/sago35/device/sam"
+	"device/sam"
 	"runtime/interrupt"
 )
 
 func init() {
-	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, _UART1.handleInterrupt)
-	UART2.Interrupt = interrupt.New(sam.IRQ_SERCOM4_2, _UART2.handleInterrupt)
-	UART3.Interrupt = interrupt.New(sam.IRQ_SERCOM1_2, _UART3.handleInterrupt)
-	UART4.Interrupt = interrupt.New(sam.IRQ_SERCOM5_2, _UART4.handleInterrupt)
+	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, UART1.handleInterrupt)
+	UART2.Interrupt = interrupt.New(sam.IRQ_SERCOM4_2, UART2.handleInterrupt)
+	UART3.Interrupt = interrupt.New(sam.IRQ_SERCOM1_2, UART3.handleInterrupt)
+	UART4.Interrupt = interrupt.New(sam.IRQ_SERCOM5_2, UART4.handleInterrupt)
 }
 
 // UART on the Grand Central M4
 var (
-	UART1  = &_UART1
-	_UART1 = UART{
+	UART1 = UART{
 		Buffer: NewRingBuffer(),
 		Bus:    sam.SERCOM0_USART_INT,
 		SERCOM: 0,
 	}
-	UART2  = &_UART2
-	_UART2 = UART{
+	UART2 = UART{
 		Buffer: NewRingBuffer(),
 		Bus:    sam.SERCOM4_USART_INT,
 		SERCOM: 4,
 	}
-	UART3  = &_UART3
-	_UART3 = UART{
+	UART3 = UART{
 		Buffer: NewRingBuffer(),
 		Bus:    sam.SERCOM1_USART_INT,
 		SERCOM: 1,
 	}
-	UART4  = &_UART4
-	_UART4 = UART{
+	UART4 = UART{
 		Buffer: NewRingBuffer(),
 		Bus:    sam.SERCOM5_USART_INT,
 		SERCOM: 5,

src/machine/board_hifive1b.go

@@ -35,8 +35,6 @@ const (
 	LED_BLUE  = P21
 )
 
-var DefaultUART = UART0
-
 const (
 	// TODO: figure out the pin numbers for these.
 	UART_TX_PIN = D1

src/machine/board_hifive1b_baremetal.go

@@ -2,7 +2,7 @@
 
 package machine
 
-import "github.com/sago35/device/sifive"
+import "device/sifive"
 
 // SPI on the HiFive1.
 var (

src/machine/board_itsybitsy-m0.go

@@ -3,7 +3,7 @@
 package machine
 
 import (
-	"github.com/sago35/device/sam"
+	"device/sam"
 	"runtime/interrupt"
 )
 
@@ -42,7 +42,7 @@ const (
 	LED = D13
 )
 
-// USBCDC pins
+// UART0 aka USBCDC pins
 const (
 	USBCDC_DM_PIN = PA24
 	USBCDC_DP_PIN = PA25
@@ -56,8 +56,7 @@ const (
 
 // UART1 on the ItsyBitsy M0.
 var (
-	UART1  = &_UART1
-	_UART1 = UART{
+	UART1 = UART{
 		Buffer: NewRingBuffer(),
 		Bus:    sam.SERCOM1_USART,
 		SERCOM: 1,
@@ -65,7 +64,7 @@ var (
 )
 
 func init() {
-	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM1, _UART1.handleInterrupt)
+	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM1, UART1.handleInterrupt)
 }
 
 // I2C pins

src/machine/board_itsybitsy-m4.go

@@ -37,7 +37,7 @@ const (
 	LED = D13
 )
 
-// USBCDC pins
+// UART0 aka USBCDC pins
 const (
 	USBCDC_DM_PIN = PA24
 	USBCDC_DP_PIN = PA25

src/machine/board_itsybitsy-m4_baremetal.go

@@ -3,20 +3,18 @@
 package machine
 
 import (
-	"github.com/sago35/device/sam"
+	"device/sam"
 	"runtime/interrupt"
 )
 
 var (
-	UART1  = &_UART1
-	_UART1 = UART{
+	UART1 = UART{
 		Buffer: NewRingBuffer(),
 		Bus:    sam.SERCOM3_USART_INT,
 		SERCOM: 3,
 	}
 
-	UART2  = &_UART2
-	_UART2 = UART{
+	UART2 = UART{
 		Buffer: NewRingBuffer(),
 		Bus:    sam.SERCOM0_USART_INT,
 		SERCOM: 0,
@@ -24,8 +22,8 @@ var (
 )
 
 func init() {
-	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM3_2, _UART1.handleInterrupt)
-	UART2.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, _UART2.handleInterrupt)
+	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM3_2, UART1.handleInterrupt)
+	UART2.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, UART2.handleInterrupt)
 }
 
 // I2C on the ItsyBitsy M4.

src/machine/board_itsybitsy-nrf52840.go

@@ -70,6 +70,11 @@ const (
 	UART_TX_PIN = D1
 )
 
+// UART0 is the USB device
+var (
+	UART0 = &USB
+)
+
 // I2C pins
 const (
 	SDA_PIN = D21 // I2C0 external

src/machine/board_lgt92.go

@@ -3,7 +3,7 @@
 package machine
 
 import (
-	"github.com/sago35/device/stm32"
+	"device/stm32"
 	"runtime/interrupt"
 )
 
@@ -54,13 +54,10 @@ const (
 	I2C0_SDA_PIN = PA10
 )
 
-var DefaultUART = UART0
-
 var (
 
 	// Console UART (LPUSART1)
-	UART0  = &_UART0
-	_UART0 = UART{
+	UART0 = UART{
 		Buffer:            NewRingBuffer(),
 		Bus:               stm32.LPUART1,
 		TxAltFuncSelector: 6,
@@ -68,8 +65,7 @@ var (
 	}
 
 	// Gps UART
-	UART1  = &_UART1
-	_UART1 = UART{
+	UART1 = UART{
 		Buffer:            NewRingBuffer(),
 		Bus:               stm32.USART1,
 		TxAltFuncSelector: 0,
@@ -92,6 +88,6 @@ var (
 
 func init() {
 	// Enable UARTs Interrupts
-	UART0.Interrupt = interrupt.New(stm32.IRQ_AES_RNG_LPUART1, _UART0.handleInterrupt)
-	UART1.Interrupt = interrupt.New(stm32.IRQ_USART1, _UART1.handleInterrupt)
+	UART0.Interrupt = interrupt.New(stm32.IRQ_AES_RNG_LPUART1, UART0.handleInterrupt)
+	UART1.Interrupt = interrupt.New(stm32.IRQ_USART1, UART1.handleInterrupt)
 }

src/machine/board_maixbit.go

@@ -52,8 +52,6 @@ const (
 	LED_BLUE  = D14
 )
 
-var DefaultUART = UART0
-
 // Default pins for UARTHS.
 const (
 	UART_TX_PIN = D5

src/machine/board_maixbit_baremetal.go

@@ -2,7 +2,7 @@
 
 package machine
 
-import "github.com/sago35/device/kendryte"
+import "device/kendryte"
 
 // SPI on the MAix Bit.
 var (

src/machine/board_matrixportal-m4.go

@@ -75,7 +75,6 @@ const (
 const (
 	LED      = D13
 	NEOPIXEL = D4
-	WS2812   = D4
 )
 
 // Button pins

src/machine/board_matrixportal-m4_baremetal.go

@@ -3,21 +3,19 @@
 package machine
 
 import (
-	"github.com/sago35/device/sam"
+	"device/sam"
 	"runtime/interrupt"
 )
 
 // UART on the MatrixPortal M4
 var (
-	UART1  = &_UART1
-	_UART1 = UART{
+	UART1 = UART{
 		Buffer: NewRingBuffer(),
 		Bus:    sam.SERCOM1_USART_INT,
 		SERCOM: 1,
 	}
 
-	UART2  = &_UART2
-	_UART2 = UART{
+	UART2 = UART{
 		Buffer: NewRingBuffer(),
 		Bus:    sam.SERCOM4_USART_INT,
 		SERCOM: 4,
@@ -25,8 +23,8 @@ var (
 )
 
 func init() {
-	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM1_1, _UART1.handleInterrupt)
-	UART2.Interrupt = interrupt.New(sam.IRQ_SERCOM4_1, _UART2.handleInterrupt)
+	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM1_1, UART1.handleInterrupt)
+	UART2.Interrupt = interrupt.New(sam.IRQ_SERCOM4_1, UART2.handleInterrupt)
 }
 
 // I2C on the MatrixPortal M4

src/machine/board_metro-m4-airlift.go

@@ -37,11 +37,10 @@ const (
 )
 
 const (
-	LED    = D13
-	WS2812 = D40
+	LED = D13
 )
 
-// USBCDC pins
+// UART0 aka USBCDC pins
 const (
 	USBCDC_DM_PIN = PA24
 	USBCDC_DP_PIN = PA25

src/machine/board_metro-m4-airlift_baremetal.go

@@ -3,20 +3,18 @@
 package machine
 
 import (
-	"github.com/sago35/device/sam"
+	"device/sam"
 	"runtime/interrupt"
 )
 
 var (
-	UART1  = &_UART1
-	_UART1 = UART{
+	UART1 = UART{
 		Buffer: NewRingBuffer(),
 		Bus:    sam.SERCOM3_USART_INT,
 		SERCOM: 3,
 	}
 
-	UART2  = &_UART2
-	_UART2 = UART{
+	UART2 = UART{
 		Buffer: NewRingBuffer(),
 		Bus:    sam.SERCOM0_USART_INT,
 		SERCOM: 0,
@@ -24,8 +22,8 @@ var (
 )
 
 func init() {
-	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM3_2, _UART1.handleInterrupt)
-	UART2.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, _UART2.handleInterrupt)
+	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM3_2, UART1.handleInterrupt)
+	UART2.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, UART2.handleInterrupt)
 }
 
 // I2C on the Metro M4.

src/machine/board_microbit-v2.go

@@ -12,8 +12,6 @@ const (
 	BUTTONB Pin = P11
 )
 
-var DefaultUART = UART0
-
 // UART pins
 const (
 	UART_TX_PIN Pin = P34