build: make msd flash faster

machine/grandcentral-m4: implementation for Adafruit Grand Central M4 board.

.circleci/config.yml

@@ -28,6 +28,7 @@ commands:
                 qemu-user \
                 gcc-avr \
                 avr-libc
+            sudo apt-get install --no-install-recommends libc6-dev-i386 lib32gcc-8-dev
   install-node:
     steps:
       - run:
@@ -44,6 +45,13 @@ commands:
           command: |
             wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
             sudo apt install ./google-chrome-stable_current_amd64.deb
+  install-wasmtime:
+    steps:
+      - run:
+          name: "Install wasmtime"
+          command: |
+            curl https://wasmtime.dev/install.sh -sSf | bash
+            sudo ln -s ~/.wasmtime/bin/wasmtime /usr/local/bin/wasmtime
   install-xtensa-toolchain:
     parameters:
       variant:
@@ -60,24 +68,24 @@ commands:
     steps:
       - restore_cache:
           keys:
-            - llvm-source-10-v1
+            - llvm-source-11-v1
       - run:
           name: "Fetch LLVM source"
           command: make llvm-source
       - save_cache:
-          key: llvm-source-10-v1
+          key: llvm-source-11-v1
           paths:
             - llvm-project
   build-wasi-libc:
     steps:
       - restore_cache:
           keys:
-            - wasi-libc-sysroot-v3
+            - wasi-libc-sysroot-v4
       - run:
           name: "Build wasi-libc"
           command: make wasi-libc
       - save_cache:
-          key: wasi-libc-sysroot-v3
+          key: wasi-libc-sysroot-v4
           paths:
             - lib/wasi-libc/sysroot
   test-linux:
@@ -91,6 +99,7 @@ commands:
           llvm: "<<parameters.llvm>>"
       - install-node
       - install-chrome
+      - install-wasmtime
       - restore_cache:
           keys:
             - go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
@@ -99,13 +108,13 @@ commands:
       - run: go install -tags=llvm<<parameters.llvm>> .
       - restore_cache:
           keys:
-            - wasi-libc-sysroot-systemclang-v2
+            - wasi-libc-sysroot-systemclang-v3
       - run: make wasi-libc
       - save_cache:
-          key: wasi-libc-sysroot-systemclang-v2
+          key: wasi-libc-sysroot-systemclang-v3
           paths:
             - lib/wasi-libc/sysroot
-      - run: go test -v -tags=llvm<<parameters.llvm>> ./cgo ./compileopts ./interp ./transform .
+      - run: go test -v -tags=llvm<<parameters.llvm>> ./cgo ./compileopts ./compiler ./interp ./transform .
       - run: make gen-device -j4
       - run: make smoketest XTENSA=0
       - run: make tinygo-test
@@ -123,9 +132,9 @@ commands:
       - run:
           name: "Install apt dependencies"
           command: |
+            sudo apt-get update
             sudo apt-get install \
                 gcc-arm-linux-gnueabihf \
-                binutils-arm-none-eabi \
                 libc6-dev-armel-cross \
                 gcc-aarch64-linux-gnu \
                 libc6-dev-arm64-cross \
@@ -133,7 +142,9 @@ commands:
                 qemu-user \
                 gcc-avr \
                 avr-libc
+            sudo apt-get install --no-install-recommends libc6-dev-i386 lib32gcc-6-dev
       - install-node
+      - install-wasmtime
       - install-xtensa-toolchain:
           variant: "linux-amd64"
       - restore_cache:
@@ -143,17 +154,14 @@ commands:
       - llvm-source-linux
       - restore_cache:
           keys:
-            - llvm-build-10-linux-v1-assert
+            - llvm-build-11-linux-v2-assert
       - run:
           name: "Build LLVM"
           command: |
             if [ ! -f llvm-build/lib/liblldELF.a ]
             then
               # install dependencies
-              sudo apt-get install cmake clang ninja-build
-              # make build faster
-              export CC=clang
-              export CXX=clang++
+              sudo apt-get install cmake ninja-build
               # hack ninja to use less jobs
               echo -e '#!/bin/sh\n/usr/bin/ninja -j3 "$@"' > /go/bin/ninja
               chmod +x /go/bin/ninja
@@ -161,7 +169,7 @@ commands:
               make ASSERT=1 llvm-build
             fi
       - save_cache:
-          key: llvm-build-10-linux-v1-assert
+          key: llvm-build-11-linux-v2-assert
           paths:
             llvm-build
       - run: make ASSERT=1
@@ -183,9 +191,9 @@ commands:
       - run:
           name: "Install apt dependencies"
           command: |
+            sudo apt-get update
             sudo apt-get install \
                 gcc-arm-linux-gnueabihf \
-                binutils-arm-none-eabi \
                 libc6-dev-armel-cross \
                 gcc-aarch64-linux-gnu \
                 libc6-dev-arm64-cross \
@@ -193,7 +201,9 @@ commands:
                 qemu-user \
                 gcc-avr \
                 avr-libc
+            sudo apt-get install --no-install-recommends libc6-dev-i386 lib32gcc-6-dev
       - install-node
+      - install-wasmtime
       - install-xtensa-toolchain:
           variant: "linux-amd64"
       - restore_cache:
@@ -203,17 +213,14 @@ commands:
       - llvm-source-linux
       - restore_cache:
           keys:
-            - llvm-build-10-linux-v1
+            - llvm-build-11-linux-v2-noassert
       - run:
           name: "Build LLVM"
           command: |
             if [ ! -f llvm-build/lib/liblldELF.a ]
             then
               # install dependencies
-              sudo apt-get install cmake clang ninja-build
-              # make build faster
-              export CC=clang
-              export CXX=clang++
+              sudo apt-get install cmake ninja-build
               # hack ninja to use less jobs
               echo -e '#!/bin/sh\n/usr/bin/ninja -j3 "$@"' > /go/bin/ninja
               chmod +x /go/bin/ninja
@@ -221,7 +228,7 @@ commands:
               make llvm-build
             fi
       - save_cache:
-          key: llvm-build-10-linux-v1
+          key: llvm-build-11-linux-v2-noassert
           paths:
             llvm-build
       - build-wasi-libc
@@ -263,8 +270,8 @@ commands:
       - run:
           name: "Install dependencies"
           command: |
-            curl https://dl.google.com/go/go1.14.darwin-amd64.tar.gz -o go1.14.darwin-amd64.tar.gz
-            sudo tar -C /usr/local -xzf go1.14.darwin-amd64.tar.gz
+            curl https://dl.google.com/go/go1.16.darwin-amd64.tar.gz -o go1.16.darwin-amd64.tar.gz
+            sudo tar -C /usr/local -xzf go1.16.darwin-amd64.tar.gz
             ln -s /usr/local/go/bin/go /usr/local/bin/go
             HOMEBREW_NO_AUTO_UPDATE=1 brew install qemu
       - install-xtensa-toolchain:
@@ -275,17 +282,17 @@ commands:
             - go-cache-macos-v2-{{ checksum "go.mod" }}
       - restore_cache:
           keys:
-            - llvm-source-10-macos-v1
+            - llvm-source-11-macos-v1
       - run:
           name: "Fetch LLVM source"
           command: make llvm-source
       - save_cache:
-          key: llvm-source-10-macos-v1
+          key: llvm-source-11-macos-v1
           paths:
             - llvm-project
       - restore_cache:
           keys:
-            - llvm-build-10-macos-v1
+            - llvm-build-11-macos-v2
       - run:
           name: "Build LLVM"
           command: |
@@ -297,17 +304,17 @@ commands:
               make llvm-build
             fi
       - save_cache:
-          key: llvm-build-10-macos-v1
+          key: llvm-build-11-macos-v2
           paths:
             llvm-build
       - restore_cache:
           keys:
-            - wasi-libc-sysroot-macos-v2
+            - wasi-libc-sysroot-macos-v3
       - run:
           name: "Build wasi-libc"
           command: make wasi-libc
       - save_cache:
-          key: wasi-libc-sysroot-macos-v2
+          key: wasi-libc-sysroot-macos-v3
           paths:
             - lib/wasi-libc/sysroot
       - run:
@@ -333,74 +340,8 @@ commands:
           paths:
             - ~/.cache/go-build
             - /go/pkg/mod
-  arch-release:
-    steps:
-      - run:
-          name: Install dependencies
-          command: pacman -Sy --noconfirm openssh git pacman-contrib binutils
-      - run:
-          name: Create TinyGo user
-          command: useradd -m tinygo
-      - run:
-          name: Start SSH Agent
-          user: tinygo
-          command: eval $(ssh-agent -s)
-      - run:
-          name: Add ARCH_RELEASE_SSH_PRIVATE_KEY identity
-          user: tinygo
-          command: echo "${ARCH_RELEASE_SSH_PRIVATE_KEY}" | tr -d '\r' | ssh-add -
-      - run:
-          name: Create SSH directory
-          user: tinygo
-          command: mkdir -p ~/.ssh && chmod 700 ~/.ssh
-      - run:
-          name: Add aur.archlinux.org to known hosts
-          user: tinygo
-          command: ssh-keyscan aur.archlinux.org >> ~/.ssh/known_hosts
-      - run:
-          name: Clone tinygo-bin repo
-          user: tinygo
-          command: git clone ssh://aur@aur.archlinux.org/tinygo-bin.git ~/tinygo-bin
-      - run:
-          name: Update package version
-          user: tinygo
-          command: sed -i -E "s/(pkgver=)(.*)$/\1${CIRCLE_TAG}/" ~/tinygo-bin/PKGBUILD
-      - run:
-          name: Update file checksums
-          user: tinygo
-          command: cd ~/tinygo-bin && updpkgsums
-      - run:
-          name: Update .SRCINFO
-          user: tinygo
-          command: cd ~/tinygo-bin && makepkg --printsrcinfo > .SRCINFO
-      # Commit the update
-      - run:
-          name: Set git commit config
-          user: tinygo
-          command: |
-            git config --global user.email "tinygo-bot@tinygo.org" &&
-            git config --global user.name "TinyGo Release Bot"
-      - run:
-          name: Commit and push changes
-          user: tinygo
-          command: |
-            cd ~/tinygo-bin &&
-            git commit -a -m "Update tinygo-bin to v${CIRCLE_TAG}" &&
-            git push origin master
 
 jobs:
-  test-llvm9-go111:
-    docker:
-      - image: circleci/golang:1.11-buster
-    steps:
-      - test-linux:
-          llvm: "9"
-  test-llvm10-go112:
-    docker:
-      - image: circleci/golang:1.12-buster
-    steps:
-      - test-linux:
-          llvm: "10"
   test-llvm10-go113:
     docker:
       - image: circleci/golang:1.13-buster
@@ -413,12 +354,18 @@ jobs:
     steps:
       - test-linux:
           llvm: "10"
-  test-llvm10-go115:
+  test-llvm11-go115:
     docker:
       - image: circleci/golang:1.15-buster
     steps:
       - test-linux:
-          llvm: "10"        
+          llvm: "11"
+  test-llvm11-go116:
+    docker:
+      - image: circleci/golang:1.16-buster
+    steps:
+      - test-linux:
+          llvm: "11"
   assert-test-linux:
     docker:
       - image: circleci/golang:1.14-stretch
@@ -434,32 +381,16 @@ jobs:
       xcode: "10.1.0"
     steps:
       - build-macos
-  arch-release:
-    docker:
-      - image: archlinux:latest
-    steps:
-      - arch-release
-
 
 
 
 workflows:
   test-all:
     jobs:
-      - test-llvm9-go111
-      - test-llvm10-go112
       - test-llvm10-go113
       - test-llvm10-go114
-      - test-llvm10-go115
+      - test-llvm11-go115
+      - test-llvm11-go116
       - build-linux
       - build-macos
       - assert-test-linux
-  release:
-    jobs:
-      - arch-release:
-          filters:
-            branches:
-              ignore: /.*/
-            tags:
-              # Runs on every semver release
-              only: /v[0-9]+(\.[0-9]+)*(-.*)*/

.gitmodules

@@ -20,3 +20,6 @@
 [submodule "lib/picolibc"]
 	path = lib/picolibc
 	url = https://github.com/keith-packard/picolibc.git
+[submodule "lib/stm32-svd"]
+	path = lib/stm32-svd
+	url = https://github.com/tinygo-org/stm32-svd

BUILDING.md

@@ -23,7 +23,7 @@ different guide:
 LLVM, Clang and LLD are quite light on dependencies, requiring only standard
 build tools to be built. Go is of course necessary to build TinyGo itself.
 
-  * Go (1.11+)
+  * Go (1.13+)
   * Standard build tools (gcc/clang)
   * git
   * CMake
@@ -43,11 +43,6 @@ You can also store LLVM outside of the TinyGo root directory by setting the
 `LLVM_BUILDDIR`, `CLANG_SRC` and `LLD_SRC` make variables, but that is not
 covered by this guide.
 
-TinyGo uses Go modules, so if you clone TinyGo inside your GOPATH (and are using
-Go below 1.13), make sure that Go modules are enabled:
-
-    export GO111MODULE=on
-
 ## Build LLVM, Clang, LLD
 
 Before starting the build, you may want to set the following environment

CHANGELOG.md

@@ -1,3 +1,147 @@
+0.17.0
+
+---
+* **command line**
+  - switch to LLVM 11 for static builds
+  - support gdb debugging with AVR
+  - add support for additional openocd commands
+  - add `-x` flag to print commands
+  - use LLVM 11 by default when linking LLVM dynamically
+  - update go-llvm to use LLVM 11 on macOS
+  - bump go.bug.st/serial to version 1.1.2
+  - do not build LLVM with libxml to work around a bugo on macOS
+  - add support for Go 1.16
+  - support gdb daemonization on Windows
+  - remove support for LLVM 9, to fix CI
+  - kill OpenOCD if it does not exit with a regular quit signal
+  - support `-ocd-output` on Windows
+* **compiler**
+  - `builder`: parallelize most of the build
+  - `builder`: remove unused cacheKey parameter
+  - `builder`: add -mcpu flag while building libraries
+  - `builder`: wait for running jobs to finish
+  - `cgo`: add support for variadic functions
+  - `compiler`: fix undefined behavior in wordpack
+  - `compiler`: fix incorrect "exported function" panic
+  - `compiler`: fix non-int integer constants (fixing a crash)
+  - `compiler`: refactor and add tests
+  - `compiler`: emit a nil check when slicing an array pointer
+  - `compiler`: saturate float-to-int conversions
+  - `compiler`: test float to int conversions and fix upper-bound calculation
+  - `compiler`: support all kinds of deferred builtins
+  - `compiler`: remove ir package
+  - `compiler`: remove unnecessary main.main call workaround
+  - `compiler`: move the setting of attributes to getFunction
+  - `compiler`: create runtime types lazily when needed
+  - `compiler`: move settings to a separate Config struct
+  - `compiler`: work around an ARM backend bug in LLVM
+  - `interp`: rewrite entire package
+  - `interp`: fix alignment of untyped globals
+  - `loader`: use name "main" for the main package
+  - `loader`: support imports from vendor directories
+  - `stacksize`: add support for DW_CFA_offset_extended
+  - `transform`: show better error message in coroutines lowering
+* **standard library**
+  - `machine`: accept configuration struct for ADC parameters
+  - `machine`: make I2C.Configure signature consistent
+  - `reflect`: implement PtrTo
+  - `runtime`: refactor to simplify stack switching
+  - `runtime`: put metadata at the top end of the heap
+* **targets**
+  - `atsam`: add a length check to findPinPadMapping
+  - `atsam`: improve USBCDC
+  - `atsam`: avoid infinite loop when USBCDC is disconnected
+  - `avr`: add SPI support for Atmega based chips
+  - `avr`: use Clang for compiling C and assembly files
+  - `esp32`: implement task based scheduler
+  - `esp32`: enable the FPU
+  - `esp8266`: implement task based scheduler
+  - `esp`: add compiler-rt library
+  - `esp`: add picolibc
+  - `nrf`: refactor code a bit to reduce duplication
+  - `nrf`: use SPIM peripheral instead of the legacy SPI peripheral
+  - `nrf`: update nrfx submodule to latest commit
+  - `nrf52840`: ensure that USB CDC interface is only initialized once
+  - `nrf52840`: improve USBCDC
+  - `stm32`: use stm32-rs SVDs which are of much higher quality
+  - `stm32`: harmonization of UART logic
+  - `stm32`: replace I2C addressable interface with simpler type
+  - `stm32`: fix i2c and add stm32f407 i2c
+  - `stm32`: revert change that adds support for channels in interrupts
+  - `wasm`: implement a growable heap
+  - `wasm`: fix typo in wasm_exec.js, syscall/js.valueLoadString()
+  - `wasm`: Namespaced Wasm Imports so they don't conflict across modules, or reserved LLVM IR
+  - `wasi`: support env variables based on libc
+  - `wasi`: specify wasi-libc in a different way, to improve error message
+* **boards**
+  - `matrixportal-m4`: add support for board Adafruit Matrix Portal M4
+  - `mkr1000`: add this board
+  - `nucleo-f722ze`: add this board
+  - `clue`: correct volume name and add alias for release version of Adafruit Clue board
+  - `p1am-100`: add support for the P1AM-100 (similar to Arduino MKR)
+  - `microbit-v2`: add initial support based on work done by @alankrantas thank you!
+  - `lgt92`: support for STM32L0 MCUs and Dragino LGT92 device
+  - `nicenano`: nice!nano board support
+  - `circuitplay-bluefruit`: correct internal I2C pin mapping
+  - `clue`: correct for lack of low frequency crystal
+  - `digispark`: split off attiny85 target
+  - `nucleo-l552ze`: implementation with CLOCK, LED, and UART
+  - `nrf52840-mdk-usb-dongle`: add this board
+
+0.16.0
+---
+
+* **command-line**
+  - add initial support for LLVM 11
+  - make lib64 clang include path check more robust
+  - `build`: improve support for GOARCH=386 and add tests
+  - `gdb`: add support for qemu-user targets
+  - `test`: support non-host tests
+  - `test`: add support for -c and -o flags
+  - `test`: implement some benchmark stubs
+* **compiler**
+  - `builder`: improve detection of clang on Fedora
+  - `compiler`: fix floating point comparison bugs
+  - `compiler`: implement negate for complex numbers
+  - `loader`: fix linkname in test binaries
+  - `transform`: add missing return pointer restore for regular coroutine tail
+    calls
+* **standard library**
+  - `machine`: switch default frequency to 4MHz
+  - `machine`: clarify caller's responsibility in `SetInterrupt`
+  - `os`: add `LookupEnv()` stub
+  - `reflect`: implement `Swapper`
+  - `runtime`: fix UTF-8 decoding
+  - `runtime`: gc: use raw stack access whenever possible
+  - `runtime`: use dedicated printfloat32
+  - `runtime`: allow ranging over a nil map
+  - `runtime`: avoid device/nxp dependency in HardFault handler
+  - `testing`: implement dummy Helper method
+  - `testing`: add Run method
+* **targets**
+  - `arm64`: add support for SVCall intrinsic
+  - `atsamd51`: avoid panic when configuring SPI with SDI=NoPin
+  - `avr`: properly support the `.rodata` section
+  - `esp8266`: implement `Pin.Get` function
+  - `nintendoswitch`: fix crash when printing long lines (> 120)
+  - `nintendoswitch`: add env parser and removed unused stuff
+  - `nrf`: add I2C error checking
+  - `nrf`: give more flexibility in picking SPI speeds
+  - `nrf`: fix nrf52832 flash size
+  - `stm32f103`: support wakeups from interrupts
+  - `stm32f405`: add SPI support
+  - `stm32f405`: add I2C support
+  - `wasi`: add support for this target
+  - `wasi`: use 'generic' ABI by default
+  - `wasi`: remove --no-threads flag from wasm-ld
+  - `wasm`: add instanceof support for WebAssembly
+  - `wasm`: use fixed length buffer for putchar
+* **boards**
+  - `d1mini`: add this ESP8266 based board
+  - `esp32`: use board definitions instead of chip names
+  - `qtpy`: add board definition for Adafruit QTPy
+  - `teensy40`: add this board
+
 0.15.0
 ---
 

Dockerfile

@@ -1,10 +1,10 @@
-# TinyGo base stage installs Go 1.14, LLVM 10 and the TinyGo compiler itself.
-FROM golang:1.14 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-10 main" >> /etc/apt/sources.list && \
+    echo "deb http://apt.llvm.org/buster/ llvm-toolchain-buster-11 main" >> /etc/apt/sources.list && \
     apt-get update && \
-    apt-get install -y llvm-10-dev libclang-10-dev lld-10 git
+    apt-get install -y llvm-11-dev libclang-11-dev lld-11 git
 
 COPY . /tinygo
 
@@ -29,7 +29,7 @@ COPY --from=tinygo-base /tinygo/targets /tinygo/targets
 
 RUN cd /tinygo/ && \
     apt-get update && \
-    apt-get install -y make clang-10 libllvm10 lld-10 && \
+    apt-get install -y make clang-11 libllvm11 lld-11 && \
     make wasi-libc
 
 # tinygo-avr stage installs the needed dependencies to compile TinyGo programs for AVR microcontrollers.
@@ -61,7 +61,7 @@ COPY --from=tinygo-base /tinygo/lib /tinygo/lib
 
 RUN cd /tinygo/ && \
     apt-get update && \
-    apt-get install -y apt-utils make clang-10 && \
+    apt-get install -y apt-utils make clang-11 && \
     make gen-device-nrf && make gen-device-stm32
 
 # tinygo-all stage installs the needed dependencies to compile TinyGo programs for all platforms.
@@ -73,7 +73,7 @@ COPY --from=tinygo-base /tinygo/lib /tinygo/lib
 
 RUN cd /tinygo/ && \
     apt-get update && \
-    apt-get install -y apt-utils make clang-10 binutils-avr gcc-avr avr-libc && \
+    apt-get install -y apt-utils make clang-11 binutils-avr gcc-avr avr-libc && \
     make gen-device
 
 CMD ["tinygo"]

LICENSE

@@ -1,7 +1,7 @@
-Copyright (c) 2018-2020 TinyGo Authors. All rights reserved.
+Copyright (c) 2018-2021 TinyGo Authors. All rights reserved.
 
 TinyGo includes portions of the Go standard library.
-Copyright (c) 2009-2020 The Go Authors. All rights reserved.
+Copyright (c) 2009-2021 The Go Authors. All rights reserved.
 
 TinyGo includes portions of LLVM, which is under the Apache License v2.0 with
 LLVM Exceptions. See https://llvm.org/LICENSE.txt for license information.

Makefile

@@ -9,25 +9,10 @@ CLANG_SRC ?= $(LLVM_PROJECTDIR)/clang
 LLD_SRC ?= $(LLVM_PROJECTDIR)/lld
 
 # Try to autodetect LLVM build tools.
-ifneq (, $(shell command -v llvm-build/bin/clang 2> /dev/null))
-    CLANG ?= $(abspath llvm-build/bin/clang)
-else
-    CLANG ?= clang-10
-endif
-ifneq (, $(shell command -v llvm-build/bin/llvm-ar 2> /dev/null))
-    LLVM_AR ?= $(abspath llvm-build/bin/llvm-ar)
-else ifneq (, $(shell command -v llvm-ar-10 2> /dev/null))
-    LLVM_AR ?= llvm-ar-10
-else
-    LLVM_AR ?= llvm-ar
-endif
-ifneq (, $(shell command -v llvm-build/bin/llvm-nm 2> /dev/null))
-    LLVM_NM ?= $(abspath llvm-build/bin/llvm-nm)
-else ifneq (, $(shell command -v llvm-nm-10 2> /dev/null))
-    LLVM_NM ?= llvm-nm-10
-else
-    LLVM_NM ?= llvm-nm
-endif
+detect = $(shell command -v $(1) 2> /dev/null && echo $(1))
+CLANG ?= $(word 1,$(abspath $(call detect,llvm-build/bin/clang))$(call detect,clang-11)$(call detect,clang-10)$(call detect,clang))
+LLVM_AR ?= $(word 1,$(abspath $(call detect,llvm-build/bin/llvm-ar))$(call detect,llvm-ar-11)$(call detect,llvm-ar-10)$(call detect,llvm-ar))
+LLVM_NM ?= $(word 1,$(abspath $(call detect,llvm-build/bin/llvm-nm))$(call detect,llvm-nm-11)$(call detect,llvm-nm-10)$(call detect,llvm-nm))
 
 # Go binary and GOROOT to select
 GO ?= go
@@ -37,7 +22,7 @@ export GOROOT = $(shell $(GO) env GOROOT)
 MD5SUM = md5sum
 
 # tinygo binary for tests
-TINYGO ?= tinygo
+TINYGO ?= $(word 1,$(call detect,tinygo)$(call detect,build/tinygo))
 
 # Use CCACHE for LLVM if possible
 ifneq (, $(shell command -v ccache 2> /dev/null))
@@ -63,55 +48,59 @@ ifeq ($(OS),Windows_NT)
     # LLVM compiled using MinGW on Windows appears to have problems with threads.
     # Without this flag, linking results in errors like these:
     #     libLLVMSupport.a(Threading.cpp.obj):Threading.cpp:(.text+0x55): undefined reference to `std::thread::hardware_concurrency()'
-    LLVM_OPTION += -DLLVM_ENABLE_THREADS=OFF
+    LLVM_OPTION += -DLLVM_ENABLE_THREADS=OFF -DLLVM_ENABLE_PIC=OFF
 
+    CGO_CPPFLAGS += -DCINDEX_NO_EXPORTS
     CGO_LDFLAGS += -static -static-libgcc -static-libstdc++
     CGO_LDFLAGS_EXTRA += -lversion
 
-    # Build libclang manually because the CMake-based build system on Windows
-    # doesn't allow building libclang as a static library.
-    LIBCLANG_PATH = $(abspath build/libclang-custom.a)
-    LIBCLANG_FILES = $(abspath $(wildcard $(LLVM_BUILDDIR)/tools/clang/tools/libclang/CMakeFiles/libclang.dir/*.cpp.obj))
-
-    # Add the libclang dependency to the tinygo binary target.
-tinygo: $(LIBCLANG_PATH)
-test: $(LIBCLANG_PATH)
-    # Build libclang.
-$(LIBCLANG_PATH): $(LIBCLANG_FILES)
-	@mkdir -p build
-	ar rcs $(LIBCLANG_PATH) $^
+    LIBCLANG_NAME = libclang
 
 else ifeq ($(shell uname -s),Darwin)
     MD5SUM = md5
-    LIBCLANG_PATH = $(abspath $(LLVM_BUILDDIR))/lib/libclang.a
+    LIBCLANG_NAME = clang
 else ifeq ($(shell uname -s),FreeBSD)
     MD5SUM = md5
-    LIBCLANG_PATH = $(abspath $(LLVM_BUILDDIR))/lib/libclang.a
+    LIBCLANG_NAME = clang
     START_GROUP = -Wl,--start-group
     END_GROUP = -Wl,--end-group
 else
-    LIBCLANG_PATH = $(abspath $(LLVM_BUILDDIR))/lib/libclang.a
+    LIBCLANG_NAME = clang
     START_GROUP = -Wl,--start-group
     END_GROUP = -Wl,--end-group
 endif
 
-CLANG_LIBS = $(START_GROUP) -lclangAnalysis -lclangARCMigrate -lclangAST -lclangASTMatchers -lclangBasic -lclangCodeGen -lclangCrossTU -lclangDriver -lclangDynamicASTMatchers -lclangEdit -lclangFormat -lclangFrontend -lclangFrontendTool -lclangHandleCXX -lclangHandleLLVM -lclangIndex -lclangLex -lclangParse -lclangRewrite -lclangRewriteFrontend -lclangSema -lclangSerialization -lclangStaticAnalyzerCheckers -lclangStaticAnalyzerCore -lclangStaticAnalyzerFrontend -lclangTooling -lclangToolingASTDiff -lclangToolingCore -lclangToolingInclusions $(END_GROUP) -lstdc++
+# Libraries that should be linked in for the statically linked Clang.
+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++
 
-LLD_LIBS = $(START_GROUP) -llldCOFF -llldCommon -llldCore -llldDriver -llldELF -llldMachO -llldMinGW -llldReaderWriter -llldWasm -llldYAML $(END_GROUP)
+# Libraries that should be linked in for the statically linked LLD.
+LLD_LIB_NAMES = lldCOFF lldCommon lldCore lldDriver lldELF lldMachO lldMinGW lldReaderWriter lldWasm lldYAML
+LLD_LIBS = $(START_GROUP) $(addprefix -l,$(LLD_LIB_NAMES)) $(END_GROUP)
 
+# Other libraries that are needed to link TinyGo.
+EXTRA_LIB_NAMES = LLVMInterpreter
+
+# These build targets appear to be the only ones necessary to build all TinyGo
+# dependencies. Only building a subset significantly speeds up rebuilding LLVM.
+# The Makefile rules convert a name like lldELF to lib/liblldELF.a to match the
+# library path (for ninja).
+# This list also includes a few tools that are necessary as part of the full
+# TinyGo build.
+NINJA_BUILD_TARGETS = clang llvm-config llvm-ar llvm-nm $(addprefix lib/lib,$(addsuffix .a,$(LIBCLANG_NAME) $(CLANG_LIB_NAMES) $(LLD_LIB_NAMES) $(EXTRA_LIB_NAMES)))
 
 # For static linking.
 ifneq ("$(wildcard $(LLVM_BUILDDIR)/bin/llvm-config*)","")
-    CGO_CPPFLAGS=$(shell $(LLVM_BUILDDIR)/bin/llvm-config --cppflags) -I$(abspath $(LLVM_BUILDDIR))/tools/clang/include -I$(abspath $(CLANG_SRC))/include -I$(abspath $(LLD_SRC))/include
+    CGO_CPPFLAGS+=$(shell $(LLVM_BUILDDIR)/bin/llvm-config --cppflags) -I$(abspath $(LLVM_BUILDDIR))/tools/clang/include -I$(abspath $(CLANG_SRC))/include -I$(abspath $(LLD_SRC))/include
     CGO_CXXFLAGS=-std=c++14
-    CGO_LDFLAGS+=$(LIBCLANG_PATH) -std=c++14 -L$(abspath $(LLVM_BUILDDIR)/lib) $(CLANG_LIBS) $(LLD_LIBS) $(shell $(LLVM_BUILDDIR)/bin/llvm-config --ldflags --libs --system-libs $(LLVM_COMPONENTS)) -lstdc++ $(CGO_LDFLAGS_EXTRA)
+    CGO_LDFLAGS+=$(abspath $(LLVM_BUILDDIR))/lib/lib$(LIBCLANG_NAME).a -L$(abspath $(LLVM_BUILDDIR)/lib) $(CLANG_LIBS) $(LLD_LIBS) $(shell $(LLVM_BUILDDIR)/bin/llvm-config --ldflags --libs --system-libs $(LLVM_COMPONENTS)) -lstdc++ $(CGO_LDFLAGS_EXTRA)
 endif
 
 
 clean:
 	@rm -rf build
 
-FMT_PATHS = ./*.go builder cgo compiler interp ir loader src/device/arm src/examples src/machine src/os src/reflect src/runtime src/sync src/syscall src/internal/reflectlite transform
+FMT_PATHS = ./*.go builder cgo compiler interp loader src/device/arm src/examples src/machine src/os src/reflect src/runtime src/sync src/syscall src/internal/reflectlite transform
 fmt:
 	@gofmt -l -w $(FMT_PATHS)
 fmt-check:
@@ -155,23 +144,23 @@ gen-device-kendryte: build/gen-device-svd
 	GO111MODULE=off $(GO) fmt ./src/device/kendryte
 
 gen-device-stm32: build/gen-device-svd
-	./build/gen-device-svd -source=https://github.com/posborne/cmsis-svd/tree/master/data/STMicro lib/cmsis-svd/data/STMicro/ src/device/stm32/
+	./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
 
 
 # Get LLVM sources.
 $(LLVM_PROJECTDIR)/README.md:
-	git clone -b xtensa_release_10.0.1 --depth=1 https://github.com/tinygo-org/llvm-project $(LLVM_PROJECTDIR)
+	git clone -b xtensa_release_11.0.0 --depth=1 https://github.com/tinygo-org/llvm-project $(LLVM_PROJECTDIR)
 llvm-source: $(LLVM_PROJECTDIR)/README.md
 
 # 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_PROJECTS="clang;lld" -DLLVM_TOOL_CLANG_TOOLS_EXTRA_BUILD=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
-	cd $(LLVM_BUILDDIR); ninja
+	cd $(LLVM_BUILDDIR); ninja $(NINJA_BUILD_TARGETS)
 
 
 # Build wasi-libc sysroot
@@ -188,16 +177,27 @@ tinygo:
 	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) build -buildmode exe -o build/tinygo$(EXE) -tags byollvm -ldflags="-X main.gitSha1=`git rev-parse --short HEAD`" .
 
 test: wasi-libc
-	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test -v -buildmode exe -tags byollvm ./cgo ./compileopts ./interp ./transform .
+	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test -v -buildmode exe -tags byollvm ./cgo ./compileopts ./compiler ./interp ./transform .
 
 # Test known-working standard library packages.
 # TODO: do this in one command, parallelize, and only show failing tests (no
 # implied -v flag).
 .PHONY: tinygo-test
 tinygo-test:
+	$(TINYGO) test container/heap
 	$(TINYGO) test container/list
 	$(TINYGO) test container/ring
+	$(TINYGO) test crypto/des
+	$(TINYGO) test encoding/ascii85
+	$(TINYGO) test encoding/base32
+	$(TINYGO) test encoding/hex
+	$(TINYGO) test hash/adler32
+	$(TINYGO) test hash/fnv
+	$(TINYGO) test hash/crc64
+	$(TINYGO) test math
+	$(TINYGO) test math/cmplx
 	$(TINYGO) test text/scanner
+	$(TINYGO) test unicode/utf8
 
 .PHONY: smoketest
 smoketest:
@@ -223,6 +223,8 @@ smoketest:
 	@$(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=microbit-v2         examples/microbit-blink
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/pininterrupt
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/serial
@@ -234,8 +236,6 @@ smoketest:
 	# test simulated boards on play.tinygo.org
 	$(TINYGO) build             -o test.wasm -tags=arduino              examples/blinky1
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build             -o test.wasm -tags=hifive1-qemu         examples/serial
-	@$(MD5SUM) test.wasm
 	$(TINYGO) build             -o test.wasm -tags=hifive1b             examples/blinky1
 	@$(MD5SUM) test.wasm
 	$(TINYGO) build             -o test.wasm -tags=reelboard            examples/blinky1
@@ -287,7 +287,7 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=circuitplay-express examples/i2s
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=clue_alpha          examples/blinky1
+	$(TINYGO) build -size short -o test.hex -target=clue-alpha          examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.gba -target=gameboy-advance     examples/gba-display
 	@$(MD5SUM) test.gba
@@ -311,6 +311,8 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pinetime-devkit0    examples/blinky1
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=lgt92    examples/blinky1
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=x9pro               examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10056-s140v7     examples/blinky1
@@ -331,6 +333,18 @@ smoketest:
 	@$(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/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=teensy40            examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=teensy36            examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=nucleo-f722ze       examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=nucleo-l552ze       examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=p1am-100            examples/blinky1
+	@$(MD5SUM) test.hex
 	# test pwm
 	$(TINYGO) build -size short -o test.hex -target=itsybitsy-m0        examples/pwm
 	@$(MD5SUM) test.hex
@@ -357,13 +371,15 @@ ifneq ($(AVR), 0)
 	@$(MD5SUM) test.hex
 endif
 ifneq ($(XTENSA), 0)
-	$(TINYGO) build -size short -o test.bin -target=esp32-wroom-32      examples/blinky1
+	$(TINYGO) build -size short -o test.bin -target=esp32-mini32      	examples/blinky1
 	@$(MD5SUM) test.bin
 	$(TINYGO) build -size short -o test.bin -target=nodemcu             examples/blinky1
 	@$(MD5SUM) test.bin
 endif
 	$(TINYGO) build -size short -o test.hex -target=hifive1b            examples/blinky1
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=hifive1-qemu        examples/serial
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=maixbit             examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build             -o wasm.wasm -target=wasm               examples/wasm/export

README.md

@@ -43,11 +43,11 @@ See the [getting started instructions](https://tinygo.org/getting-started/) for
 
 You can compile TinyGo programs for microcontrollers, WebAssembly and Linux.
 
-The following 44 microcontroller boards are currently supported:
+The following 55 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)
-* [Adafruit CLUE Alpha](https://www.adafruit.com/product/4500)
+* [Adafruit CLUE](https://www.adafruit.com/product/4500)
 * [Adafruit Feather M0](https://www.adafruit.com/product/2772)
 * [Adafruit Feather M4](https://www.adafruit.com/product/3857)
 * [Adafruit Feather nRF52840 Express](https://www.adafruit.com/product/4062)
@@ -55,22 +55,29 @@ The following 44 microcontroller boards are currently supported:
 * [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)
+* [Adafruit Matrix Portal M4](https://www.adafruit.com/product/4745)
 * [Adafruit Metro M4 Express Airlift](https://www.adafruit.com/product/4000)
 * [Adafruit PyBadge](https://www.adafruit.com/product/4200)
 * [Adafruit PyGamer](https://www.adafruit.com/product/4242)
 * [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 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 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/)
+* [BBC micro:bit v2](https://microbit.org/new-microbit/)
 * [Digispark](http://digistump.com/products/1)
+* [Dragino LoRaWAN GPS Tracker LGT-92](http://www.dragino.com/products/lora-lorawan-end-node/item/142-lgt-92.html)
 * [ESP32](https://www.espressif.com/en/products/socs/esp32)
 * [ESP8266](https://www.espressif.com/en/products/socs/esp8266)
 * [Game Boy Advance](https://en.wikipedia.org/wiki/Game_Boy_Advance)
 * [Makerdiary nRF52840-MDK](https://wiki.makerdiary.com/nrf52840-mdk/)
+* [Makerdiary nRF52840-MDK USB Dongle](https://wiki.makerdiary.com/nrf52840-mdk-usb-dongle/)
+* [nice!nano](https://docs.nicekeyboards.com/#/nice!nano/)
 * [Nintendo Switch](https://www.nintendo.com/switch/)
 * [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)
@@ -81,12 +88,16 @@ The following 44 microcontroller boards are currently supported:
 * [Phytec reel board](https://www.phytec.eu/product-eu/internet-of-things/reelboard/)
 * [PineTime DevKit](https://www.pine64.org/pinetime/)
 * [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)
 * [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 STM32F103XX "Bluepill"](http://wiki.stm32duino.com/index.php?title=Blue_Pill)
+* [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" 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)
 * [X9 Pro smartwatch](https://github.com/curtpw/nRF5x-device-reverse-engineering/tree/master/X9-nrf52832-activity-tracker/)
 
@@ -148,6 +159,6 @@ The original reasoning was: if [Python](https://micropython.org/) can run on mic
 
 This project is licensed under the BSD 3-clause license, just like the [Go project](https://golang.org/LICENSE) itself.
 
-Some code has been copied from the LLVM project and is therefore licensed under [a variant of the Apache 2.0 license](http://releases.llvm.org/10.0.0/LICENSE.TXT). This has been clearly indicated in the header of these files.
+Some code has been copied from the LLVM project and is therefore licensed under [a variant of the Apache 2.0 license](http://releases.llvm.org/11.0.0/LICENSE.TXT). This has been clearly indicated in the header of these files.
 
 Some code has been copied and/or ported from Paul Stoffregen's Teensy libraries and is therefore licensed under PJRC's license. This has been clearly indicated in the header of these files.

azure-pipelines.yml

@@ -12,27 +12,23 @@ jobs:
   steps:
     - task: GoTool@0
       inputs:
-        version: '1.15'
+        version: '1.16'
     - checkout: self
       fetchDepth: 1
     - task: Cache@2
       displayName: Cache LLVM source
       inputs:
-        key: llvm-source-10-windows-v1
+        key: llvm-source-11-windows-v1
         path: llvm-project
     - task: Bash@3
       displayName: Download LLVM source
       inputs:
         targetType: inline
-        script: |
-          make llvm-source
-          # Workaround for bad symlinks:
-          # https://github.com/microsoft/azure-pipelines-tasks/issues/13418
-          rm -f llvm-project/libcxx/test/std/input.output/filesystems/Inputs/static_test_env/bad_symlink
+        script: make llvm-source
     - task: CacheBeta@0
       displayName: Cache LLVM build
       inputs:
-        key: llvm-build-10-windows-v1
+        key: llvm-build-11-windows-v4
         path: llvm-build
     - task: Bash@3
       displayName: Build LLVM
@@ -41,7 +37,11 @@ jobs:
         script: |
           if [ ! -f llvm-build/lib/liblldELF.a ]
           then
+            # install dependencies
             choco install ninja
+            # hack ninja to use fewer jobs
+            echo -e 'C:\\ProgramData\\Chocolatey\\bin\\ninja -j4 %*' > /usr/bin/ninja.bat
+            # build!
             make llvm-build
           fi
     - task: Bash@3
@@ -52,7 +52,7 @@ jobs:
     - task: CacheBeta@0
       displayName: Cache wasi-libc sysroot
       inputs:
-        key: wasi-libc-sysroot-v3
+        key: wasi-libc-sysroot-v4
         path: lib/wasi-libc/sysroot
     - task: Bash@3
       displayName: Build wasi-libc

builder/build.go

@@ -8,6 +8,7 @@ import (
 	"encoding/binary"
 	"errors"
 	"fmt"
+	"go/types"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -19,6 +20,7 @@ import (
 	"github.com/tinygo-org/tinygo/compiler"
 	"github.com/tinygo-org/tinygo/goenv"
 	"github.com/tinygo-org/tinygo/interp"
+	"github.com/tinygo-org/tinygo/loader"
 	"github.com/tinygo-org/tinygo/stacksize"
 	"github.com/tinygo-org/tinygo/transform"
 	"tinygo.org/x/go-llvm"
@@ -42,32 +44,359 @@ type BuildResult struct {
 //
 // The error value may be of type *MultiError. Callers will likely want to check
 // for this case and print such errors individually.
-func Build(pkgName, outpath string, config *compileopts.Config, action func(BuildResult) error) error {
-	// Compile Go code to IR.
-	machine, err := compiler.NewTargetMachine(config)
+func Build(pkgName, outpath string, config *compileopts.Config, preAction func() error, action func(BuildResult) error) error {
+	compilerConfig := &compiler.Config{
+		Triple:          config.Triple(),
+		CPU:             config.CPU(),
+		Features:        config.Features(),
+		GOOS:            config.GOOS(),
+		GOARCH:          config.GOARCH(),
+		CodeModel:       config.CodeModel(),
+		RelocationModel: config.RelocationModel(),
+
+		Scheduler:          config.Scheduler(),
+		FuncImplementation: config.FuncImplementation(),
+		AutomaticStackSize: config.AutomaticStackSize(),
+		DefaultStackSize:   config.Target.DefaultStackSize,
+		NeedsStackObjects:  config.NeedsStackObjects(),
+		Debug:              config.Debug(),
+	}
+
+	// Load the target machine, which is the LLVM object that contains all
+	// details of a target (alignment restrictions, pointer size, default
+	// address spaces, etc).
+	machine, err := compiler.NewTargetMachine(compilerConfig)
 	if err != nil {
 		return err
 	}
-	buildOutput, errs := compiler.Compile(pkgName, machine, config)
-	if errs != nil {
-		return newMultiError(errs)
+
+	// Load entire program AST into memory.
+	lprogram, err := loader.Load(config, []string{pkgName}, config.ClangHeaders, types.Config{
+		Sizes: compiler.Sizes(machine),
+	})
+	if err != nil {
+		return err
+	}
+	err = lprogram.Parse()
+	if err != nil {
+		return err
+	}
+
+	// The slice of jobs that orchestrates most of the build.
+	// This is somewhat like an in-memory Makefile with each job being a
+	// Makefile target.
+	var jobs []*compileJob
+
+	if preAction != nil {
+		// Add job to preAction.
+		jobs = append(jobs, &compileJob{
+			description: "preAction",
+			run:         preAction,
+		})
+	}
+
+	// Add job to compile and optimize all Go files at once.
+	// TODO: parallelize this.
+	var mod llvm.Module
+	var stackSizeLoads []string
+	programJob := &compileJob{
+		description: "compile Go files",
+		run: func() (err error) {
+			mod, err = compileWholeProgram(pkgName, config, compilerConfig, lprogram, machine)
+			if err != nil {
+				return
+			}
+			// Make sure stack sizes are loaded from a separate section so they can be
+			// modified after linking.
+			if config.AutomaticStackSize() {
+				stackSizeLoads = transform.CreateStackSizeLoads(mod, config)
+			}
+			return
+		},
+	}
+	jobs = append(jobs, programJob)
+
+	// Check whether we only need to create an object file.
+	// If so, we don't need to link anything and will be finished quickly.
+	outext := filepath.Ext(outpath)
+	if outext == ".o" || outext == ".bc" || outext == ".ll" {
+		// Run jobs to produce the LLVM module.
+		err := runJobs(jobs)
+		if err != nil {
+			return err
+		}
+		// Generate output.
+		switch outext {
+		case ".o":
+			llvmBuf, err := machine.EmitToMemoryBuffer(mod, llvm.ObjectFile)
+			if err != nil {
+				return err
+			}
+			return ioutil.WriteFile(outpath, llvmBuf.Bytes(), 0666)
+		case ".bc":
+			data := llvm.WriteBitcodeToMemoryBuffer(mod).Bytes()
+			return ioutil.WriteFile(outpath, data, 0666)
+		case ".ll":
+			data := []byte(mod.String())
+			return ioutil.WriteFile(outpath, data, 0666)
+		default:
+			panic("unreachable")
+		}
+	}
+
+	// Act as a compiler driver, as we need to produce a complete executable.
+	// First add all jobs necessary to build this object file, then afterwards
+	// run all jobs in parallel as far as possible.
+
+	// Create a temporary directory for intermediary files.
+	dir, err := ioutil.TempDir("", "tinygo")
+	if err != nil {
+		return err
+	}
+	defer os.RemoveAll(dir)
+
+	// Add job to write the output object file.
+	objfile := filepath.Join(dir, "main.o")
+	outputObjectFileJob := &compileJob{
+		description:  "generate output file",
+		dependencies: []*compileJob{programJob},
+		run: func() error {
+			llvmBuf, err := machine.EmitToMemoryBuffer(mod, llvm.ObjectFile)
+			if err != nil {
+				return err
+			}
+			return ioutil.WriteFile(objfile, llvmBuf.Bytes(), 0666)
+		},
+	}
+	jobs = append(jobs, outputObjectFileJob)
+
+	// Prepare link command.
+	linkerDependencies := []*compileJob{outputObjectFileJob}
+	executable := filepath.Join(dir, "main")
+	tmppath := executable // final file
+	ldflags := append(config.LDFlags(), "-o", executable, objfile)
+
+	// Add compiler-rt dependency if needed. Usually this is a simple load from
+	// a cache.
+	if config.Target.RTLib == "compiler-rt" {
+		path, job, err := CompilerRT.load(config.Triple(), config.CPU(), dir)
+		if err != nil {
+			return err
+		}
+		if job != nil {
+			// The library was not loaded from cache so needs to be compiled
+			// (and then stored in the cache).
+			jobs = append(jobs, job.dependencies...)
+			jobs = append(jobs, job)
+			linkerDependencies = append(linkerDependencies, job)
+		}
+		ldflags = append(ldflags, path)
+	}
+
+	// Add libc dependency if needed.
+	root := goenv.Get("TINYGOROOT")
+	switch config.Target.Libc {
+	case "picolibc":
+		path, job, err := Picolibc.load(config.Triple(), config.CPU(), dir)
+		if err != nil {
+			return err
+		}
+		if job != nil {
+			// The library needs to be compiled (cache miss).
+			jobs = append(jobs, job.dependencies...)
+			jobs = append(jobs, job)
+			linkerDependencies = append(linkerDependencies, job)
+		}
+		ldflags = append(ldflags, path)
+	case "wasi-libc":
+		path := filepath.Join(root, "lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a")
+		if _, err := os.Stat(path); os.IsNotExist(err) {
+			return errors.New("could not find wasi-libc, perhaps you need to run `make wasi-libc`?")
+		}
+		ldflags = append(ldflags, path)
+	case "":
+		// no library specified, so nothing to do
+	default:
+		return fmt.Errorf("unknown libc: %s", config.Target.Libc)
+	}
+
+	// Add jobs to compile extra files. These files are in C or assembly and
+	// contain things like the interrupt vector table and low level operations
+	// such as stack switching.
+	for i, path := range config.ExtraFiles() {
+		abspath := filepath.Join(root, path)
+		outpath := filepath.Join(dir, "extra-"+strconv.Itoa(i)+"-"+filepath.Base(path)+".o")
+		job := &compileJob{
+			description: "compile extra file " + path,
+			run: func() error {
+				err := runCCompiler(config.Target.Compiler, append(config.CFlags(), "-c", "-o", outpath, abspath)...)
+				if err != nil {
+					return &commandError{"failed to build", path, err}
+				}
+				return nil
+			},
+		}
+		jobs = append(jobs, job)
+		linkerDependencies = append(linkerDependencies, job)
+		ldflags = append(ldflags, outpath)
+	}
+
+	// Add jobs to compile C files in all packages. This is part of CGo.
+	// TODO: do this as part of building the package to be able to link the
+	// bitcode files together.
+	for i, pkg := range lprogram.Sorted() {
+		for j, filename := range pkg.CFiles {
+			file := filepath.Join(pkg.Dir, filename)
+			outpath := filepath.Join(dir, "pkg"+strconv.Itoa(i)+"."+strconv.Itoa(j)+"-"+filepath.Base(file)+".o")
+			job := &compileJob{
+				description: "compile CGo file " + file,
+				run: func() error {
+					err := runCCompiler(config.Target.Compiler, append(config.CFlags(), "-c", "-o", outpath, file)...)
+					if err != nil {
+						return &commandError{"failed to build", file, err}
+					}
+					return nil
+				},
+			}
+			jobs = append(jobs, job)
+			linkerDependencies = append(linkerDependencies, job)
+			ldflags = append(ldflags, outpath)
+		}
+	}
+
+	// Linker flags from CGo lines:
+	//     #cgo LDFLAGS: foo
+	if len(lprogram.LDFlags) > 0 {
+		ldflags = append(ldflags, lprogram.LDFlags...)
+	}
+
+	// Create a linker job, which links all object files together and does some
+	// extra stuff that can only be done after linking.
+	jobs = append(jobs, &compileJob{
+		description:  "link",
+		dependencies: linkerDependencies,
+		run: func() error {
+			err = link(config.Target.Linker, ldflags...)
+			if err != nil {
+				return &commandError{"failed to link", executable, err}
+			}
+
+			var calculatedStacks []string
+			var stackSizes map[string]functionStackSize
+			if config.Options.PrintStacks || config.AutomaticStackSize() {
+				// Try to determine stack sizes at compile time.
+				// Don't do this by default as it usually doesn't work on
+				// unsupported architectures.
+				calculatedStacks, stackSizes, err = determineStackSizes(mod, executable)
+				if err != nil {
+					return err
+				}
+			}
+			if config.AutomaticStackSize() {
+				// Modify the .tinygo_stacksizes section that contains a stack size
+				// for each goroutine.
+				err = modifyStackSizes(executable, stackSizeLoads, stackSizes)
+				if err != nil {
+					return fmt.Errorf("could not modify stack sizes: %w", err)
+				}
+			}
+
+			if config.Options.PrintSizes == "short" || config.Options.PrintSizes == "full" {
+				sizes, err := loadProgramSize(executable)
+				if err != nil {
+					return err
+				}
+				if config.Options.PrintSizes == "short" {
+					fmt.Printf("   code    data     bss |   flash     ram\n")
+					fmt.Printf("%7d %7d %7d | %7d %7d\n", sizes.Code, sizes.Data, sizes.BSS, sizes.Code+sizes.Data, sizes.Data+sizes.BSS)
+				} else {
+					fmt.Printf("   code  rodata    data     bss |   flash     ram | package\n")
+					for _, name := range sizes.sortedPackageNames() {
+						pkgSize := sizes.Packages[name]
+						fmt.Printf("%7d %7d %7d %7d | %7d %7d | %s\n", pkgSize.Code, pkgSize.ROData, pkgSize.Data, pkgSize.BSS, pkgSize.Flash(), pkgSize.RAM(), name)
+					}
+					fmt.Printf("%7d %7d %7d %7d | %7d %7d | (sum)\n", sizes.Sum.Code, sizes.Sum.ROData, sizes.Sum.Data, sizes.Sum.BSS, sizes.Sum.Flash(), sizes.Sum.RAM())
+					fmt.Printf("%7d       - %7d %7d | %7d %7d | (all)\n", sizes.Code, sizes.Data, sizes.BSS, sizes.Code+sizes.Data, sizes.Data+sizes.BSS)
+				}
+			}
+
+			// Print goroutine stack sizes, as far as possible.
+			if config.Options.PrintStacks {
+				printStacks(calculatedStacks, stackSizes)
+			}
+
+			return nil
+		},
+	})
+
+	// Run all jobs to compile and link the program.
+	// Do this now (instead of after elf-to-hex and similar conversions) as it
+	// is simpler and cannot be parallelized.
+	err = runJobs(jobs)
+	if err != nil {
+		return err
+	}
+
+	// Get an Intel .hex file or .bin file from the .elf file.
+	outputBinaryFormat := config.BinaryFormat(outext)
+	switch outputBinaryFormat {
+	case "elf":
+		// do nothing, file is already in ELF format
+	case "hex", "bin":
+		// Extract raw binary, either encoding it as a hex file or as a raw
+		// firmware file.
+		tmppath = filepath.Join(dir, "main"+outext)
+		err := objcopy(executable, tmppath, outputBinaryFormat)
+		if err != nil {
+			return err
+		}
+	case "uf2":
+		// Get UF2 from the .elf file.
+		tmppath = filepath.Join(dir, "main"+outext)
+		err := convertELFFileToUF2File(executable, tmppath, config.Target.UF2FamilyID)
+		if err != nil {
+			return err
+		}
+	case "esp32", "esp8266":
+		// Special format for the ESP family of chips (parsed by the ROM
+		// bootloader).
+		tmppath = filepath.Join(dir, "main"+outext)
+		err := makeESPFirmareImage(executable, tmppath, outputBinaryFormat)
+		if err != nil {
+			return err
+		}
+	default:
+		return fmt.Errorf("unknown output binary format: %s", outputBinaryFormat)
+	}
+	return action(BuildResult{
+		Binary:  tmppath,
+		MainDir: lprogram.MainPkg().Dir,
+	})
+}
+
+// compileWholeProgram compiles the entire *loader.Program to a LLVM module and
+// applies most necessary optimizations and transformations.
+func compileWholeProgram(pkgName string, config *compileopts.Config, compilerConfig *compiler.Config, lprogram *loader.Program, machine llvm.TargetMachine) (llvm.Module, error) {
+	// Compile AST to IR.
+	mod, errs := compiler.CompileProgram(lprogram, machine, compilerConfig, config.DumpSSA())
+	if errs != nil {
+		return mod, newMultiError(errs)
 	}
-	mod := buildOutput.Mod
 
 	if config.Options.PrintIR {
 		fmt.Println("; Generated LLVM IR:")
 		fmt.Println(mod.String())
 	}
 	if err := llvm.VerifyModule(mod, llvm.PrintMessageAction); err != nil {
-		return errors.New("verification error after IR construction")
+		return mod, errors.New("verification error after IR construction")
 	}
 
-	err = interp.Run(mod, config.DumpSSA())
+	err := interp.Run(mod, config.DumpSSA())
 	if err != nil {
-		return err
+		return mod, err
 	}
 	if err := llvm.VerifyModule(mod, llvm.PrintMessageAction); err != nil {
-		return errors.New("verification error after interpreting runtime.initAll")
+		return mod, errors.New("verification error after interpreting runtime.initAll")
 	}
 
 	if config.GOOS() != "darwin" {
@@ -79,10 +408,10 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	// keep functions interoperable, pass int64 types as pointers to
 	// stack-allocated values.
 	// Use -wasm-abi=generic to disable this behaviour.
-	if config.Options.WasmAbi == "js" && strings.HasPrefix(config.Triple(), "wasm") {
+	if config.WasmAbi() == "js" {
 		err := transform.ExternalInt64AsPtr(mod)
 		if err != nil {
-			return err
+			return mod, err
 		}
 	}
 
@@ -111,203 +440,24 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		errs = []error{errors.New("unknown optimization level: -opt=" + config.Options.Opt)}
 	}
 	if len(errs) > 0 {
-		return newMultiError(errs)
+		return mod, newMultiError(errs)
 	}
 	if err := llvm.VerifyModule(mod, llvm.PrintMessageAction); err != nil {
-		return errors.New("verification failure after LLVM optimization passes")
+		return mod, errors.New("verification failure after LLVM optimization passes")
 	}
 
-	// On the AVR, pointers can point either to flash or to RAM, but we don't
-	// know. As a temporary fix, load all global variables in RAM.
-	// In the future, there should be a compiler pass that determines which
-	// pointers are flash and which are in RAM so that pointers can have a
-	// correct address space parameter (address space 1 is for flash).
-	if strings.HasPrefix(config.Triple(), "avr") {
-		transform.NonConstGlobals(mod)
-		if err := llvm.VerifyModule(mod, llvm.PrintMessageAction); err != nil {
-			return errors.New("verification error after making all globals non-constant on AVR")
-		}
+	// LLVM 11 by default tries to emit tail calls (even with the target feature
+	// disabled) unless it is explicitly disabled with a function attribute.
+	// This is a problem, as it tries to emit them and prints an error when it
+	// can't with this feature disabled.
+	// Because as of september 2020 tail calls are not yet widely supported,
+	// they need to be disabled until they are widely supported (at which point
+	// the +tail-call target feautre can be set).
+	if strings.HasPrefix(config.Triple(), "wasm") {
+		transform.DisableTailCalls(mod)
 	}
 
-	// Make sure stack sizes are loaded from a separate section so they can be
-	// modified after linking.
-	var stackSizeLoads []string
-	if config.AutomaticStackSize() {
-		stackSizeLoads = transform.CreateStackSizeLoads(mod, config)
-	}
-
-	// Generate output.
-	outext := filepath.Ext(outpath)
-	switch outext {
-	case ".o":
-		llvmBuf, err := machine.EmitToMemoryBuffer(mod, llvm.ObjectFile)
-		if err != nil {
-			return err
-		}
-		return ioutil.WriteFile(outpath, llvmBuf.Bytes(), 0666)
-	case ".bc":
-		data := llvm.WriteBitcodeToMemoryBuffer(mod).Bytes()
-		return ioutil.WriteFile(outpath, data, 0666)
-	case ".ll":
-		data := []byte(mod.String())
-		return ioutil.WriteFile(outpath, data, 0666)
-	default:
-		// Act as a compiler driver.
-
-		// Create a temporary directory for intermediary files.
-		dir, err := ioutil.TempDir("", "tinygo")
-		if err != nil {
-			return err
-		}
-		defer os.RemoveAll(dir)
-
-		// Write the object file.
-		objfile := filepath.Join(dir, "main.o")
-		llvmBuf, err := machine.EmitToMemoryBuffer(mod, llvm.ObjectFile)
-		if err != nil {
-			return err
-		}
-		err = ioutil.WriteFile(objfile, llvmBuf.Bytes(), 0666)
-		if err != nil {
-			return err
-		}
-
-		// Prepare link command.
-		executable := filepath.Join(dir, "main")
-		tmppath := executable // final file
-		ldflags := append(config.LDFlags(), "-o", executable, objfile)
-
-		// Load builtins library from the cache, possibly compiling it on the
-		// fly.
-		if config.Target.RTLib == "compiler-rt" {
-			librt, err := CompilerRT.Load(config.Triple())
-			if err != nil {
-				return err
-			}
-			ldflags = append(ldflags, librt)
-		}
-
-		// Add libc.
-		if config.Target.Libc == "picolibc" {
-			libc, err := Picolibc.Load(config.Triple())
-			if err != nil {
-				return err
-			}
-			ldflags = append(ldflags, libc)
-		}
-
-		// Compile extra files.
-		root := goenv.Get("TINYGOROOT")
-		for i, path := range config.ExtraFiles() {
-			abspath := filepath.Join(root, path)
-			outpath := filepath.Join(dir, "extra-"+strconv.Itoa(i)+"-"+filepath.Base(path)+".o")
-			err := runCCompiler(config.Target.Compiler, append(config.CFlags(), "-c", "-o", outpath, abspath)...)
-			if err != nil {
-				return &commandError{"failed to build", path, err}
-			}
-			ldflags = append(ldflags, outpath)
-		}
-
-		// Compile C files in packages.
-		for i, file := range buildOutput.ExtraFiles {
-			outpath := filepath.Join(dir, "pkg"+strconv.Itoa(i)+"-"+filepath.Base(file)+".o")
-			err := runCCompiler(config.Target.Compiler, append(config.CFlags(), "-c", "-o", outpath, file)...)
-			if err != nil {
-				return &commandError{"failed to build", file, err}
-			}
-			ldflags = append(ldflags, outpath)
-		}
-
-		if len(buildOutput.ExtraLDFlags) > 0 {
-			ldflags = append(ldflags, buildOutput.ExtraLDFlags...)
-		}
-
-		// Link the object files together.
-		err = link(config.Target.Linker, ldflags...)
-		if err != nil {
-			return &commandError{"failed to link", executable, err}
-		}
-
-		var calculatedStacks []string
-		var stackSizes map[string]functionStackSize
-		if config.Options.PrintStacks || config.AutomaticStackSize() {
-			// Try to determine stack sizes at compile time.
-			// Don't do this by default as it usually doesn't work on
-			// unsupported architectures.
-			calculatedStacks, stackSizes, err = determineStackSizes(mod, executable)
-			if err != nil {
-				return err
-			}
-		}
-		if config.AutomaticStackSize() {
-			// Modify the .tinygo_stacksizes section that contains a stack size
-			// for each goroutine.
-			err = modifyStackSizes(executable, stackSizeLoads, stackSizes)
-			if err != nil {
-				return fmt.Errorf("could not modify stack sizes: %w", err)
-			}
-		}
-
-		if config.Options.PrintSizes == "short" || config.Options.PrintSizes == "full" {
-			sizes, err := loadProgramSize(executable)
-			if err != nil {
-				return err
-			}
-			if config.Options.PrintSizes == "short" {
-				fmt.Printf("   code    data     bss |   flash     ram\n")
-				fmt.Printf("%7d %7d %7d | %7d %7d\n", sizes.Code, sizes.Data, sizes.BSS, sizes.Code+sizes.Data, sizes.Data+sizes.BSS)
-			} else {
-				fmt.Printf("   code  rodata    data     bss |   flash     ram | package\n")
-				for _, name := range sizes.sortedPackageNames() {
-					pkgSize := sizes.Packages[name]
-					fmt.Printf("%7d %7d %7d %7d | %7d %7d | %s\n", pkgSize.Code, pkgSize.ROData, pkgSize.Data, pkgSize.BSS, pkgSize.Flash(), pkgSize.RAM(), name)
-				}
-				fmt.Printf("%7d %7d %7d %7d | %7d %7d | (sum)\n", sizes.Sum.Code, sizes.Sum.ROData, sizes.Sum.Data, sizes.Sum.BSS, sizes.Sum.Flash(), sizes.Sum.RAM())
-				fmt.Printf("%7d       - %7d %7d | %7d %7d | (all)\n", sizes.Code, sizes.Data, sizes.BSS, sizes.Code+sizes.Data, sizes.Data+sizes.BSS)
-			}
-		}
-
-		// Print goroutine stack sizes, as far as possible.
-		if config.Options.PrintStacks {
-			printStacks(calculatedStacks, stackSizes)
-		}
-
-		// Get an Intel .hex file or .bin file from the .elf file.
-		outputBinaryFormat := config.BinaryFormat(outext)
-		switch outputBinaryFormat {
-		case "elf":
-			// do nothing, file is already in ELF format
-		case "hex", "bin":
-			// Extract raw binary, either encoding it as a hex file or as a raw
-			// firmware file.
-			tmppath = filepath.Join(dir, "main"+outext)
-			err := objcopy(executable, tmppath, outputBinaryFormat)
-			if err != nil {
-				return err
-			}
-		case "uf2":
-			// Get UF2 from the .elf file.
-			tmppath = filepath.Join(dir, "main"+outext)
-			err := convertELFFileToUF2File(executable, tmppath, config.Target.UF2FamilyID)
-			if err != nil {
-				return err
-			}
-		case "esp32", "esp8266":
-			// Special format for the ESP family of chips (parsed by the ROM
-			// bootloader).
-			tmppath = filepath.Join(dir, "main"+outext)
-			err := makeESPFirmareImage(executable, tmppath, outputBinaryFormat)
-			if err != nil {
-				return err
-			}
-		default:
-			return fmt.Errorf("unknown output binary format: %s", outputBinaryFormat)
-		}
-		return action(BuildResult{
-			Binary:  tmppath,
-			MainDir: buildOutput.MainDir,
-		})
-	}
+	return mod, nil
 }
 
 // functionStackSizes keeps stack size information about a single function

builder/buildcache.go

@@ -30,10 +30,7 @@ func cacheTimestamp(paths []string) (time.Time, error) {
 // Try to load a given file from the cache. Return "", nil if no cached file can
 // be found (or the file is stale), return the absolute path if there is a cache
 // and return an error on I/O errors.
-//
-// TODO: the configKey is currently ignored. It is supposed to be used as extra
-// data for the cache key, like the compiler version and arguments.
-func cacheLoad(name, configKey string, sourceFiles []string) (string, error) {
+func cacheLoad(name string, sourceFiles []string) (string, error) {
 	cachepath := filepath.Join(goenv.Get("GOCACHE"), name)
 	cacheStat, err := os.Stat(cachepath)
 	if os.IsNotExist(err) {
@@ -58,9 +55,7 @@ func cacheLoad(name, configKey string, sourceFiles []string) (string, error) {
 
 // Store the file located at tmppath in the cache with the given name. The
 // tmppath may or may not be gone afterwards.
-//
-// Note: the configKey is ignored, see cacheLoad.
-func cacheStore(tmppath, name, configKey string, sourceFiles []string) (string, error) {
+func cacheStore(tmppath, name string, sourceFiles []string) (string, error) {
 	// get the last modified time
 	if len(sourceFiles) == 0 {
 		panic("cache: no source files")
@@ -74,24 +69,16 @@ func cacheStore(tmppath, name, configKey string, sourceFiles []string) (string,
 		return "", err
 	}
 	cachepath := filepath.Join(dir, name)
-	err = moveFile(tmppath, cachepath)
+	err = copyFile(tmppath, cachepath)
 	if err != nil {
 		return "", err
 	}
 	return cachepath, nil
 }
 
-// moveFile renames the file from src to dst. If renaming doesn't work (for
-// example, the rename crosses a filesystem boundary), the file is copied and
-// the old file is removed.
-func moveFile(src, dst string) error {
-	err := os.Rename(src, dst)
-	if err == nil {
-		// Success!
-		return nil
-	}
-	// Failed to move, probably a different filesystem.
-	// Do a copy + remove.
+// copyFile copies the given file from src to dst. It can copy over
+// a possibly already existing file at the destination.
+func copyFile(src, dst string) error {
 	inf, err := os.Open(src)
 	if err != nil {
 		return err

builder/cc1as.cpp

@@ -101,7 +101,7 @@ bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
 
   // Target Options
   Opts.Triple = llvm::Triple::normalize(Args.getLastArgValue(OPT_triple));
-  Opts.CPU = Args.getLastArgValue(OPT_target_cpu);
+  Opts.CPU = std::string(Args.getLastArgValue(OPT_target_cpu));
   Opts.Features = Args.getAllArgValues(OPT_target_feature);
 
   // Use the default target triple if unspecified.
@@ -132,13 +132,19 @@ bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
 
   Opts.RelaxELFRelocations = Args.hasArg(OPT_mrelax_relocations);
   Opts.DwarfVersion = getLastArgIntValue(Args, OPT_dwarf_version_EQ, 2, Diags);
-  Opts.DwarfDebugFlags = Args.getLastArgValue(OPT_dwarf_debug_flags);
-  Opts.DwarfDebugProducer = Args.getLastArgValue(OPT_dwarf_debug_producer);
-  Opts.DebugCompilationDir = Args.getLastArgValue(OPT_fdebug_compilation_dir);
-  Opts.MainFileName = Args.getLastArgValue(OPT_main_file_name);
+  Opts.DwarfDebugFlags =
+      std::string(Args.getLastArgValue(OPT_dwarf_debug_flags));
+  Opts.DwarfDebugProducer =
+      std::string(Args.getLastArgValue(OPT_dwarf_debug_producer));
+  Opts.DebugCompilationDir =
+      std::string(Args.getLastArgValue(OPT_fdebug_compilation_dir));
+  Opts.MainFileName = std::string(Args.getLastArgValue(OPT_main_file_name));
 
-  for (const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ))
-    Opts.DebugPrefixMap.insert(StringRef(Arg).split('='));
+  for (const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ)) {
+    auto Split = StringRef(Arg).split('=');
+    Opts.DebugPrefixMap.insert(
+        {std::string(Split.first), std::string(Split.second)});
+  }
 
   // Frontend Options
   if (Args.hasArg(OPT_INPUT)) {
@@ -154,8 +160,9 @@ bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
     }
   }
   Opts.LLVMArgs = Args.getAllArgValues(OPT_mllvm);
-  Opts.OutputPath = Args.getLastArgValue(OPT_o);
-  Opts.SplitDwarfOutput = Args.getLastArgValue(OPT_split_dwarf_output);
+  Opts.OutputPath = std::string(Args.getLastArgValue(OPT_o));
+  Opts.SplitDwarfOutput =
+      std::string(Args.getLastArgValue(OPT_split_dwarf_output));
   if (Arg *A = Args.getLastArg(OPT_filetype)) {
     StringRef Name = A->getValue();
     unsigned OutputType = StringSwitch<unsigned>(Name)
@@ -183,8 +190,9 @@ bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
   Opts.NoExecStack = Args.hasArg(OPT_mno_exec_stack);
   Opts.FatalWarnings = Args.hasArg(OPT_massembler_fatal_warnings);
   Opts.NoWarn = Args.hasArg(OPT_massembler_no_warn);
-  Opts.RelocationModel = Args.getLastArgValue(OPT_mrelocation_model, "pic");
-  Opts.TargetABI = Args.getLastArgValue(OPT_target_abi);
+  Opts.RelocationModel =
+      std::string(Args.getLastArgValue(OPT_mrelocation_model, "pic"));
+  Opts.TargetABI = std::string(Args.getLastArgValue(OPT_target_abi));
   Opts.IncrementalLinkerCompatible =
       Args.hasArg(OPT_mincremental_linker_compatible);
   Opts.SymbolDefs = Args.getAllArgValues(OPT_defsym);
@@ -314,12 +322,7 @@ bool ExecuteAssembler(AssemblerInvocation &Opts, DiagnosticsEngine &Diags) {
                             SrcMgr.getMemoryBuffer(BufferIndex)->getBuffer());
 
   // Build up the feature string from the target feature list.
-  std::string FS;
-  if (!Opts.Features.empty()) {
-    FS = Opts.Features[0];
-    for (unsigned i = 1, e = Opts.Features.size(); i != e; ++i)
-      FS += "," + Opts.Features[i];
-  }
+  std::string FS = llvm::join(Opts.Features, ",");
 
   std::unique_ptr<MCStreamer> Str;
 
@@ -383,7 +386,7 @@ bool ExecuteAssembler(AssemblerInvocation &Opts, DiagnosticsEngine &Diags) {
     MCSection *AsmLabel = Ctx.getMachOSection(
         "__LLVM", "__asm", MachO::S_REGULAR, 4, SectionKind::getReadOnly());
     Str.get()->SwitchSection(AsmLabel);
-    Str.get()->EmitZeros(1);
+    Str.get()->emitZeros(1);
   }
 
   // Assembly to object compilation should leverage assembly info.

builder/clang.cpp

@@ -11,6 +11,7 @@
 #include <clang/FrontendTool/Utils.h>
 #include <llvm/ADT/IntrusiveRefCntPtr.h>
 #include <llvm/Option/Option.h>
+#include <llvm/Support/Host.h>
 
 using namespace llvm;
 using namespace clang;

builder/config.go

@@ -25,8 +25,8 @@ func NewConfig(options *compileopts.Options) (*compileopts.Config, error) {
 	if err != nil {
 		return nil, fmt.Errorf("could not read version from GOROOT (%v): %v", goroot, err)
 	}
-	if major != 1 || minor < 11 || minor > 15 {
-		return nil, fmt.Errorf("requires go version 1.11 through 1.15, got go%d.%d", major, minor)
+	if major != 1 || minor < 13 || minor > 16 {
+		return nil, fmt.Errorf("requires go version 1.13 through 1.16, got go%d.%d", major, minor)
 	}
 	clangHeaderPath := getClangHeaderPath(goenv.Get("TINYGOROOT"))
 	return &compileopts.Config{

builder/env.go

@@ -6,6 +6,9 @@ import (
 	"os/exec"
 	"path/filepath"
 	"sort"
+	"strings"
+
+	"tinygo.org/x/go-llvm"
 )
 
 // getClangHeaderPath returns the path to the built-in Clang headers. It tries
@@ -26,6 +29,7 @@ func getClangHeaderPath(TINYGOROOT string) string {
 
 	// It looks like we are built with a system-installed LLVM. Do a last
 	// attempt: try to use Clang headers relative to the clang binary.
+	llvmMajor := strings.Split(llvm.Version, ".")[0]
 	for _, cmdName := range commands["clang"] {
 		binpath, err := exec.LookPath(cmdName)
 		if err == nil {
@@ -40,22 +44,38 @@ func getClangHeaderPath(TINYGOROOT string) string {
 			// Example executable:
 			//     /usr/lib/llvm-9/bin/clang
 			// Example include path:
-			//     /usr/lib/llvm-9/lib/clang/9.0.1/include/
+			//     /usr/lib/llvm-9/lib64/clang/9.0.1/include/
 			llvmRoot := filepath.Dir(filepath.Dir(binpath))
-			clangVersionRoot := filepath.Join(llvmRoot, "lib", "clang")
-			dirs, err := ioutil.ReadDir(clangVersionRoot)
-			if err != nil {
+			clangVersionRoot := filepath.Join(llvmRoot, "lib64", "clang")
+			dirs64, err64 := ioutil.ReadDir(clangVersionRoot)
+			// Example include path:
+			//     /usr/lib/llvm-9/lib/clang/9.0.1/include/
+			clangVersionRoot = filepath.Join(llvmRoot, "lib", "clang")
+			dirs32, err32 := ioutil.ReadDir(clangVersionRoot)
+			if err64 != nil && err32 != nil {
 				// Unexpected.
 				continue
 			}
-			dirnames := make([]string, len(dirs))
-			for i, d := range dirs {
-				dirnames[i] = d.Name()
+			dirnames := make([]string, len(dirs64)+len(dirs32))
+			dirCount := 0
+			for _, d := range dirs32 {
+				name := d.Name()
+				if name == llvmMajor || strings.HasPrefix(name, llvmMajor+".") {
+					dirnames[dirCount] = filepath.Join(llvmRoot, "lib", "clang", name)
+					dirCount++
+				}
+			}
+			for _, d := range dirs64 {
+				name := d.Name()
+				if name == llvmMajor || strings.HasPrefix(name, llvmMajor+".") {
+					dirnames[dirCount] = filepath.Join(llvmRoot, "lib64", "clang", name)
+					dirCount++
+				}
 			}
 			sort.Strings(dirnames)
 			// Check for the highest version first.
-			for i := len(dirnames) - 1; i >= 0; i-- {
-				path := filepath.Join(clangVersionRoot, dirnames[i], "include")
+			for i := dirCount - 1; i >= 0; i-- {
+				path := filepath.Join(dirnames[i], "include")
 				_, err := os.Stat(filepath.Join(path, "stdint.h"))
 				if err == nil {
 					return path

builder/jobs.go

@@ -0,0 +1,160 @@
+package builder
+
+// This file implements a job runner for the compiler, which runs jobs in
+// parallel while taking care of dependencies.
+
+import (
+	"fmt"
+	"runtime"
+	"time"
+)
+
+// Set to true to enable logging in the job runner. This may help to debug
+// concurrency or performance issues.
+const jobRunnerDebug = false
+
+type jobState uint8
+
+const (
+	jobStateQueued   jobState = iota // not yet running
+	jobStateRunning                  // running
+	jobStateFinished                 // finished running
+)
+
+// compileJob is a single compiler job, comparable to a single Makefile target.
+// It is used to orchestrate various compiler tasks that can be run in parallel
+// but that have dependencies and thus have limitations in how they can be run.
+type compileJob struct {
+	description  string // description, only used for logging
+	dependencies []*compileJob
+	run          func() error
+	state        jobState
+	err          error         // error if finished
+	duration     time.Duration // how long it took to run this job (only set after finishing)
+}
+
+// readyToRun returns whether this job is ready to run: it is itself not yet
+// started and all dependencies are finished.
+func (job *compileJob) readyToRun() bool {
+	if job.state != jobStateQueued {
+		// Already running or finished, so shouldn't be run again.
+		return false
+	}
+
+	// Check dependencies.
+	for _, dep := range job.dependencies {
+		if dep.state != jobStateFinished {
+			// A dependency is not finished, so this job has to wait until it
+			// is.
+			return false
+		}
+	}
+
+	// All conditions are satisfied.
+	return true
+}
+
+// runJobs runs all the jobs indicated in the jobs slice and returns the error
+// of the first job that fails to run.
+// It runs all jobs in the order of the slice, as long as all dependencies have
+// already run. Therefore, if some jobs are preferred to run before others, they
+// should be ordered as such in this slice.
+func runJobs(jobs []*compileJob) error {
+	// Create channels to communicate with the workers.
+	doneChan := make(chan *compileJob)
+	workerChan := make(chan *compileJob)
+	defer close(workerChan)
+
+	// Start a number of workers.
+	for i := 0; i < runtime.NumCPU(); i++ {
+		if jobRunnerDebug {
+			fmt.Println("## starting worker", i)
+		}
+		go jobWorker(workerChan, doneChan)
+	}
+
+	// Send each job in the jobs slice to a worker, taking care of job
+	// dependencies.
+	numRunningJobs := 0
+	var totalTime time.Duration
+	start := time.Now()
+	for {
+		// If there are free workers, try starting a new job (if one is
+		// available). If it succeeds, try again to fill the entire worker pool.
+		if numRunningJobs < runtime.NumCPU() {
+			jobToRun := nextJob(jobs)
+			if jobToRun != nil {
+				// Start job.
+				if jobRunnerDebug {
+					fmt.Println("## start:   ", jobToRun.description)
+				}
+				jobToRun.state = jobStateRunning
+				workerChan <- jobToRun
+				numRunningJobs++
+				continue
+			}
+		}
+
+		// When there are no jobs running, all jobs in the jobs slice must have
+		// been finished. Therefore, the work is done.
+		if numRunningJobs == 0 {
+			break
+		}
+
+		// Wait until a job is finished.
+		job := <-doneChan
+		job.state = jobStateFinished
+		numRunningJobs--
+		totalTime += job.duration
+		if jobRunnerDebug {
+			fmt.Println("## finished:", job.description, "(time "+job.duration.String()+")")
+		}
+		if job.err != nil {
+			// Wait for running jobs to finish.
+			for numRunningJobs != 0 {
+				<-doneChan
+				numRunningJobs--
+			}
+			// Return error of first failing job.
+			return job.err
+		}
+	}
+
+	// Some statistics, if debugging.
+	if jobRunnerDebug {
+		// Total duration of running all jobs.
+		duration := time.Since(start)
+		fmt.Println("## total:   ", duration)
+
+		// The individual time of each job combined. On a multicore system, this
+		// should be lower than the total above.
+		fmt.Println("## job sum: ", totalTime)
+	}
+
+	return nil
+}
+
+// nextJob returns the first ready-to-run job.
+// This is an implementation detail of runJobs.
+func nextJob(jobs []*compileJob) *compileJob {
+	for _, job := range jobs {
+		if job.readyToRun() {
+			return job
+		}
+	}
+	return nil
+}
+
+// jobWorker is the goroutine that runs received jobs.
+// This is an implementation detail of runJobs.
+func jobWorker(workerChan, doneChan chan *compileJob) {
+	for job := range workerChan {
+		start := time.Now()
+		err := job.run()
+		if err != nil {
+			job.err = err
+		}
+		job.duration = time.Since(start)
+		doneChan <- job
+	}
+}

builder/library.go

@@ -1,7 +1,6 @@
 package builder
 
 import (
-	"io/ioutil"
 	"os"
 	"path/filepath"
 	"strings"
@@ -40,34 +39,64 @@ func (l *Library) sourcePaths(target string) []string {
 }
 
 // Load the library archive, possibly generating and caching it if needed.
-func (l *Library) Load(target string) (path string, err error) {
+// The resulting file is stored in the provided tmpdir, which is expected to be
+// removed after the Load call.
+func (l *Library) Load(target, tmpdir string) (path string, err error) {
+	path, job, err := l.load(target, "", tmpdir)
+	if err != nil {
+		return "", err
+	}
+	if job != nil {
+		jobs := append([]*compileJob{job}, job.dependencies...)
+		err = runJobs(jobs)
+	}
+	return path, err
+}
+
+// load returns a path to the library file for the given target, loading it from
+// cache if possible. It will return a non-zero compiler job if the library
+// wasn't cached, this job (and its dependencies) must be run before the library
+// path is valid.
+// The provided tmpdir will be used to store intermediary files and possibly the
+// output archive file, it is expected to be removed after use.
+func (l *Library) load(target, cpu, tmpdir string) (path string, job *compileJob, err error) {
 	// Try to load a precompiled library.
 	precompiledPath := filepath.Join(goenv.Get("TINYGOROOT"), "pkg", target, l.name+".a")
 	if _, err := os.Stat(precompiledPath); err == nil {
 		// Found a precompiled library for this OS/architecture. Return the path
 		// directly.
-		return precompiledPath, nil
+		return precompiledPath, nil, nil
 	}
 
-	outfile := l.name + "-" + target + ".a"
+	var outfile string
+	if cpu != "" {
+		outfile = l.name + "-" + target + "-" + cpu + ".a"
+	} else {
+		outfile = l.name + "-" + target + ".a"
+	}
 
 	// Try to fetch this library from the cache.
-	if path, err := cacheLoad(outfile, commands["clang"][0], l.sourcePaths(target)); path != "" || err != nil {
+	if path, err := cacheLoad(outfile, l.sourcePaths(target)); path != "" || err != nil {
 		// Cache hit.
-		return path, err
+		return path, nil, err
 	}
 	// Cache miss, build it now.
 
-	dirPrefix := "tinygo-" + l.name
-	remapDir := filepath.Join(os.TempDir(), dirPrefix)
-	dir, err := ioutil.TempDir(os.TempDir(), dirPrefix)
+	remapDir := filepath.Join(os.TempDir(), "tinygo-"+l.name)
+	dir := filepath.Join(tmpdir, "build-lib-"+l.name)
+	err = os.Mkdir(dir, 0777)
 	if err != nil {
-		return "", err
+		return "", nil, err
 	}
-	defer os.RemoveAll(dir)
 
 	// Precalculate the flags to the compiler invocation.
+	// Note: -fdebug-prefix-map is necessary to make the output archive
+	// reproducible. Otherwise the temporary directory is stored in the archive
+	// itself, which varies each run.
 	args := append(l.cflags(), "-c", "-Oz", "-g", "-ffunction-sections", "-fdata-sections", "-Wno-macro-redefined", "--target="+target, "-fdebug-prefix-map="+dir+"="+remapDir)
+	if cpu != "" {
+		args = append(args, "-mcpu="+cpu)
+	}
 	if strings.HasPrefix(target, "arm") || strings.HasPrefix(target, "thumb") {
 		args = append(args, "-fshort-enums", "-fomit-frame-pointer", "-mfloat-abi=soft")
 	}
@@ -78,28 +107,44 @@ func (l *Library) Load(target string) (path string, err error) {
 		args = append(args, "-march=rv64gc", "-mabi=lp64")
 	}
 
-	// Compile all sources.
+	// Create job to put all the object files in a single archive. This archive
+	// file is the (static) library file.
 	var objs []string
+	arpath := filepath.Join(dir, l.name+".a")
+	job = &compileJob{
+		description: "ar " + l.name + ".a",
+		run: func() error {
+			// Create an archive of all object files.
+			err := makeArchive(arpath, objs)
+			if err != nil {
+				return err
+			}
+			// Store this archive in the cache.
+			_, err = cacheStore(arpath, outfile, l.sourcePaths(target))
+			return err
+		},
+	}
+
+	// Create jobs to compile all sources. These jobs are depended upon by the
+	// archive job above, so must be run first.
 	for _, srcpath := range l.sourcePaths(target) {
+		srcpath := srcpath // avoid concurrency issues by redefining inside the loop
 		objpath := filepath.Join(dir, filepath.Base(srcpath)+".o")
 		objs = append(objs, objpath)
-		// Note: -fdebug-prefix-map is necessary to make the output archive
-		// reproducible. Otherwise the temporary directory is stored in the
-		// archive itself, which varies each run.
-		err := runCCompiler("clang", append(args, "-o", objpath, srcpath)...)
-		if err != nil {
-			return "", &commandError{"failed to build", srcpath, err}
-		}
+		job.dependencies = append(job.dependencies, &compileJob{
+			description: "compile " + srcpath,
+			run: func() error {
+				var compileArgs []string
+				compileArgs = append(compileArgs, args...)
+				compileArgs = append(compileArgs, "-o", objpath, srcpath)
+				err := runCCompiler("clang", compileArgs...)
+				if err != nil {
+					return &commandError{"failed to build", srcpath, err}
+				}
+				return nil
+			},
+		})
 	}
 
-	// Put all the object files in a single archive. This archive file will be
-	// used to statically link this library.
-	arpath := filepath.Join(dir, l.name+".a")
-	err = makeArchive(arpath, objs)
-	if err != nil {
-		return "", err
-	}
-
-	// Store this archive in the cache.
-	return cacheStore(arpath, outfile, commands["clang"][0], l.sourcePaths(target))
+	return arpath, job, nil
 }

builder/objcopy.go

@@ -61,7 +61,7 @@ func extractROM(path string) (uint64, []byte, error) {
 
 	progs := make(progSlice, 0, 2)
 	for _, prog := range f.Progs {
-		if prog.Type != elf.PT_LOAD || prog.Filesz == 0 {
+		if prog.Type != elf.PT_LOAD || prog.Filesz == 0 || prog.Off == 0 {
 			continue
 		}
 		progs = append(progs, prog)
@@ -73,6 +73,12 @@ func extractROM(path string) (uint64, []byte, error) {
 
 	var rom []byte
 	for _, prog := range progs {
+		romEnd := progs[0].Paddr + uint64(len(rom))
+		if prog.Paddr > romEnd && prog.Paddr < romEnd+16 {
+			// Sometimes, the linker seems to insert a bit of padding between
+			// segments. Simply zero-fill these parts.
+			rom = append(rom, make([]byte, prog.Paddr-romEnd)...)
+		}
 		if prog.Paddr != progs[0].Paddr+uint64(len(rom)) {
 			diff := prog.Paddr - (progs[0].Paddr + uint64(len(rom)))
 			if diff > maxPadBytes {

cgo/cgo.go

@@ -54,9 +54,10 @@ type constantInfo struct {
 // functionInfo stores some information about a CGo function found by libclang
 // and declared in the AST.
 type functionInfo struct {
-	args    []paramInfo
-	results *ast.FieldList
-	pos     token.Pos
+	args     []paramInfo
+	results  *ast.FieldList
+	pos      token.Pos
+	variadic bool
 }
 
 // paramInfo is a parameter of a CGo function (see functionInfo).
@@ -484,6 +485,16 @@ func (p *cgoPackage) addFuncDecls() {
 				Results: fn.results,
 			},
 		}
+		if fn.variadic {
+			decl.Doc = &ast.CommentGroup{
+				List: []*ast.Comment{
+					&ast.Comment{
+						Slash: fn.pos,
+						Text:  "//go:variadic",
+					},
+				},
+			}
+		}
 		obj.Decl = decl
 		for i, arg := range fn.args {
 			args[i] = &ast.Field{

cgo/cgo_test.go

@@ -5,6 +5,7 @@ import (
 	"flag"
 	"fmt"
 	"go/ast"
+	"go/build"
 	"go/format"
 	"go/parser"
 	"go/token"
@@ -23,7 +24,7 @@ var flagUpdate = flag.Bool("update", false, "Update images based on test output.
 // normalizeResult normalizes Go source code that comes out of tests across
 // platforms and Go versions.
 func normalizeResult(result string) string {
-	actual := strings.Replace(result, "\r\n", "\n", -1)
+	actual := strings.ReplaceAll(result, "\r\n", "\n")
 
 	// Make sure all functions are wrapped, even those that would otherwise be
 	// single-line functions. This is necessary because Go 1.14 changed the way
@@ -41,6 +42,20 @@ func TestCGo(t *testing.T) {
 	for _, name := range []string{"basic", "errors", "types", "flags", "const"} {
 		name := name // avoid a race condition
 		t.Run(name, func(t *testing.T) {
+			// Skip tests that require specific Go version.
+			if name == "errors" {
+				ok := false
+				for _, version := range build.Default.ReleaseTags {
+					if version == "go1.16" {
+						ok = true
+						break
+					}
+				}
+				if !ok {
+					t.Skip("Results for errors test are only valid for Go 1.16+")
+				}
+			}
+
 			// Read the AST in memory.
 			path := filepath.Join("testdata", name+".go")
 			fset := token.NewFileSet()
@@ -98,7 +113,7 @@ func TestCGo(t *testing.T) {
 			if err != nil {
 				t.Fatalf("could not read expected output: %v", err)
 			}
-			expected := strings.Replace(string(expectedBytes), "\r\n", "\n", -1)
+			expected := strings.ReplaceAll(string(expectedBytes), "\r\n", "\n")
 
 			// Check whether the output is as expected.
 			if expected != actual {
@@ -139,7 +154,7 @@ func formatDiagnostic(err error) string {
 	msg := err.Error()
 	if runtime.GOOS == "windows" {
 		// Fix Windows path slashes.
-		msg = strings.Replace(msg, "testdata\\", "testdata/", -1)
+		msg = strings.ReplaceAll(msg, "testdata\\", "testdata/")
 	}
 	return "//     " + msg + "\n"
 }

cgo/libclang.go

@@ -152,12 +152,10 @@ func tinygo_clang_globals_visitor(c, parent C.GoCXCursor, client_data C.CXClient
 			return C.CXChildVisit_Continue
 		}
 		cursorType := C.tinygo_clang_getCursorType(c)
-		if C.clang_isFunctionTypeVariadic(cursorType) != 0 {
-			return C.CXChildVisit_Continue // not supported
-		}
 		numArgs := int(C.tinygo_clang_Cursor_getNumArguments(c))
 		fn := &functionInfo{
-			pos: pos,
+			pos:      pos,
+			variadic: C.clang_isFunctionTypeVariadic(cursorType) != 0,
 		}
 		p.functions[name] = fn
 		for i := 0; i < numArgs; i++ {

cgo/libclang_config.go

@@ -1,14 +1,14 @@
 // +build !byollvm
-// +build !llvm9
+// +build !llvm10
 
 package cgo
 
 /*
-#cgo linux  CFLAGS: -I/usr/lib/llvm-10/include
-#cgo darwin CFLAGS: -I/usr/local/opt/llvm@10/include
-#cgo freebsd CFLAGS: -I/usr/local/llvm10/include
-#cgo linux  LDFLAGS: -L/usr/lib/llvm-10/lib -lclang
-#cgo darwin LDFLAGS: -L/usr/local/opt/llvm@10/lib -lclang -lffi
-#cgo freebsd LDFLAGS: -L/usr/local/llvm10/lib -lclang
+#cgo linux   CFLAGS:  -I/usr/lib/llvm-11/include
+#cgo darwin  CFLAGS:  -I/usr/local/opt/llvm@11/include
+#cgo freebsd CFLAGS:  -I/usr/local/llvm11/include
+#cgo linux   LDFLAGS: -L/usr/lib/llvm-11/lib -lclang
+#cgo darwin  LDFLAGS: -L/usr/local/opt/llvm@11/lib -lclang -lffi
+#cgo freebsd LDFLAGS: -L/usr/local/llvm11/lib -lclang
 */
 import "C"

cgo/libclang_config_llvm10.go

@@ -0,0 +1,14 @@
+// +build !byollvm
+// +build llvm10
+
+package cgo
+
+/*
+#cgo linux  CFLAGS: -I/usr/lib/llvm-10/include
+#cgo darwin CFLAGS: -I/usr/local/opt/llvm@10/include
+#cgo freebsd CFLAGS: -I/usr/local/llvm10/include
+#cgo linux  LDFLAGS: -L/usr/lib/llvm-10/lib -lclang
+#cgo darwin LDFLAGS: -L/usr/local/opt/llvm@10/lib -lclang -lffi
+#cgo freebsd LDFLAGS: -L/usr/local/llvm10/lib -lclang
+*/
+import "C"

cgo/libclang_config_llvm9.go

@@ -1,14 +0,0 @@
-// +build !byollvm
-// +build llvm9
-
-package cgo
-
-/*
-#cgo linux  CFLAGS: -I/usr/lib/llvm-9/include
-#cgo darwin CFLAGS: -I/usr/local/opt/llvm@9/include
-#cgo freebsd CFLAGS: -I/usr/local/llvm9/include
-#cgo linux  LDFLAGS: -L/usr/lib/llvm-9/lib -lclang
-#cgo darwin LDFLAGS: -L/usr/local/opt/llvm@9/lib -lclang -lffi
-#cgo freebsd LDFLAGS: -L/usr/local/llvm9/lib -lclang
-*/
-import "C"

cgo/testdata/errors.out.go

@@ -4,10 +4,10 @@
 //     testdata/errors.go:13:23: unexpected token )
 
 // Type checking errors after CGo processing:
-//     testdata/errors.go:102: 2 << 10 (untyped int constant 2048) overflows uint8
+//     testdata/errors.go:102: cannot use 2 << 10 (untyped int constant 2048) as uint8 value in variable declaration (overflows)
 //     testdata/errors.go:105: unknown field z in struct literal
 //     testdata/errors.go:108: undeclared name: C.SOME_CONST_1
-//     testdata/errors.go:110: C.SOME_CONST_3 (untyped int constant 1234) overflows byte
+//     testdata/errors.go:110: cannot use C.SOME_CONST_3 (untyped int constant 1234) as byte value in variable declaration (overflows)
 
 package main
 

cgo/testdata/types.go

@@ -104,6 +104,10 @@ typedef struct {
 	unsigned char e : 3;
 	// Note that C++ allows bitfields bigger than the underlying type.
 } bitfield_t;
+
+// Function signatures.
+void variadic0();
+void variadic2(int x, int y, ...);
 */
 import "C"
 
@@ -163,3 +167,9 @@ func accessUnion() {
 	var _ *C.int = union2d.unionfield_i()
 	var _ *[2]float64 = union2d.unionfield_d()
 }
+
+// Test function signatures.
+func accessFunctions() {
+	C.variadic0()
+	C.variadic2(3, 5)
+}

cgo/testdata/types.out.go

@@ -4,6 +4,11 @@ import "unsafe"
 
 var _ unsafe.Pointer
 
+func C.variadic0() //go:variadic
+func C.variadic2(x C.int, y C.int) //go:variadic
+var C.variadic0$funcaddr unsafe.Pointer
+var C.variadic2$funcaddr unsafe.Pointer
+
 const C.option2A = 20
 const C.optionA = 0
 const C.optionB = 1

compileopts/config.go

@@ -7,7 +7,6 @@ import (
 	"fmt"
 	"path/filepath"
 	"regexp"
-	"strconv"
 	"strings"
 
 	"github.com/tinygo-org/tinygo/goenv"
@@ -22,29 +21,6 @@ type Config struct {
 	TestConfig     TestConfig
 }
 
-// FuncValueImplementation is an enum for the particular implementations of Go
-// func values.
-type FuncValueImplementation int
-
-// These constants describe the various possible implementations of Go func
-// values.
-const (
-	FuncValueNone FuncValueImplementation = iota
-
-	// A func value is implemented as a pair of pointers:
-	//     {context, function pointer}
-	// where the context may be a pointer to a heap-allocated struct containing
-	// the free variables, or it may be undef if the function being pointed to
-	// doesn't need a context. The function pointer is a regular function
-	// pointer.
-	FuncValueDoubleword
-
-	// As funcValueDoubleword, but with the function pointer replaced by a
-	// unique ID per function signature. Function values are called by using a
-	// switch statement and choosing which function to call.
-	FuncValueSwitch
-)
-
 // Triple returns the LLVM target triple, like armv6m-none-eabi.
 func (c *Config) Triple() string {
 	return c.Target.Triple
@@ -118,12 +94,12 @@ func (c *Config) NeedsStackObjects() bool {
 	switch c.GC() {
 	case "conservative", "extalloc":
 		for _, tag := range c.BuildTags() {
-			if tag == "baremetal" {
-				return false
+			if tag == "wasm" {
+				return true
 			}
 		}
 
-		return true
+		return false
 	default:
 		return false
 	}
@@ -144,14 +120,24 @@ func (c *Config) Scheduler() string {
 
 // FuncImplementation picks an appropriate func value implementation for the
 // target.
-func (c *Config) FuncImplementation() FuncValueImplementation {
-	// Always pick the switch implementation, as it allows the use of blocking
-	// inside a function that is used as a func value.
+func (c *Config) FuncImplementation() string {
 	switch c.Scheduler() {
-	case "none", "coroutines":
-		return FuncValueSwitch
 	case "tasks":
-		return FuncValueDoubleword
+		// A func value is implemented as a pair of pointers:
+		//     {context, function pointer}
+		// where the context may be a pointer to a heap-allocated struct
+		// containing the free variables, or it may be undef if the function
+		// being pointed to doesn't need a context. The function pointer is a
+		// regular function pointer.
+		return "doubleword"
+	case "none", "coroutines":
+		// As "doubleword", but with the function pointer replaced by a unique
+		// ID per function signature. Function values are called by using a
+		// switch statement and choosing which function to call.
+		// Pick the switch implementation with the coroutines scheduler, as it
+		// allows the use of blocking inside a function that is used as a func
+		// value.
+		return "switch"
 	default:
 		panic("unknown scheduler type")
 	}
@@ -179,7 +165,7 @@ func (c *Config) AutomaticStackSize() bool {
 func (c *Config) CFlags() []string {
 	cflags := append([]string{}, c.Options.CFlags...)
 	for _, flag := range c.Target.CFlags {
-		cflags = append(cflags, strings.Replace(flag, "{root}", goenv.Get("TINYGOROOT"), -1))
+		cflags = append(cflags, strings.ReplaceAll(flag, "{root}", goenv.Get("TINYGOROOT")))
 	}
 	if c.Target.Libc == "picolibc" {
 		root := goenv.Get("TINYGOROOT")
@@ -200,15 +186,9 @@ func (c *Config) LDFlags() []string {
 	// Merge and adjust LDFlags.
 	ldflags := append([]string{}, c.Options.LDFlags...)
 	for _, flag := range c.Target.LDFlags {
-		ldflags = append(ldflags, strings.Replace(flag, "{root}", root, -1))
+		ldflags = append(ldflags, strings.ReplaceAll(flag, "{root}", root))
 	}
 	ldflags = append(ldflags, "-L", root)
-	if c.Target.GOARCH == "wasm" {
-		// Round heap size to next multiple of 65536 (the WebAssembly page
-		// size).
-		heapSize := (c.Options.HeapSize + (65536 - 1)) &^ (65536 - 1)
-		ldflags = append(ldflags, "--initial-memory="+strconv.FormatInt(heapSize, 10))
-	}
 	if c.Target.LinkerScript != "" {
 		ldflags = append(ldflags, "-T", c.Target.LinkerScript)
 	}
@@ -303,6 +283,9 @@ func (c *Config) OpenOCDConfiguration() (args []string, err error) {
 		return nil, fmt.Errorf("unknown OpenOCD transport: %#v", c.Target.OpenOCDTransport)
 	}
 	args = []string{"-f", "interface/" + openocdInterface + ".cfg"}
+	for _, cmd := range c.Target.OpenOCDCommands {
+		args = append(args, "-c", cmd)
+	}
 	if c.Target.OpenOCDTransport != "" {
 		args = append(args, "-c", "transport select "+c.Target.OpenOCDTransport)
 	}
@@ -329,6 +312,15 @@ func (c *Config) RelocationModel() string {
 	return "static"
 }
 
+// WasmAbi returns the WASM ABI which is specified in the target JSON file, and
+// the value is overridden by `-wasm-abi` flag if it is provided
+func (c *Config) WasmAbi() string {
+	if c.Options.WasmAbi != "" {
+		return c.Options.WasmAbi
+	}
+	return c.Target.WasmAbi
+}
+
 type TestConfig struct {
 	CompileTestBinary bool
 	// TODO: Filter the test functions to run, include verbose flag, etc

compileopts/options.go

@@ -23,6 +23,7 @@ type Options struct {
 	PrintIR       bool
 	DumpSSA       bool
 	VerifyIR      bool
+	PrintCommands bool
 	Debug         bool
 	PrintSizes    string
 	PrintStacks   bool
@@ -30,7 +31,6 @@ type Options struct {
 	LDFlags       []string
 	Tags          string
 	WasmAbi       string
-	HeapSize      int64
 	TestConfig    TestConfig
 	Programmer    string
 }

compileopts/target.go

@@ -8,6 +8,7 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"reflect"
 	"runtime"
 	"strings"
 
@@ -39,7 +40,7 @@ type TargetSpec struct {
 	LDFlags          []string `json:"ldflags"`
 	LinkerScript     string   `json:"linkerscript"`
 	ExtraFiles       []string `json:"extra-files"`
-	Emulator         []string `json:"emulator"`
+	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"`
@@ -51,105 +52,53 @@ type TargetSpec struct {
 	OpenOCDInterface string   `json:"openocd-interface"`
 	OpenOCDTarget    string   `json:"openocd-target"`
 	OpenOCDTransport string   `json:"openocd-transport"`
+	OpenOCDCommands  []string `json:"openocd-commands"`
 	JLinkDevice      string   `json:"jlink-device"`
 	CodeModel        string   `json:"code-model"`
 	RelocationModel  string   `json:"relocation-model"`
+	WasmAbi          string   `json:"wasm-abi"`
 }
 
-// copyProperties copies all properties that are set in spec2 into itself.
-func (spec *TargetSpec) copyProperties(spec2 *TargetSpec) {
-	// TODO: simplify this using reflection? Inherits and BuildTags are special
-	// cases, but the rest can simply be copied if set.
-	spec.Inherits = append(spec.Inherits, spec2.Inherits...)
-	if spec2.Triple != "" {
-		spec.Triple = spec2.Triple
-	}
-	if spec2.CPU != "" {
-		spec.CPU = spec2.CPU
-	}
-	spec.Features = append(spec.Features, spec2.Features...)
-	if spec2.GOOS != "" {
-		spec.GOOS = spec2.GOOS
-	}
-	if spec2.GOARCH != "" {
-		spec.GOARCH = spec2.GOARCH
-	}
-	spec.BuildTags = append(spec.BuildTags, spec2.BuildTags...)
-	if spec2.GC != "" {
-		spec.GC = spec2.GC
-	}
-	if spec2.Scheduler != "" {
-		spec.Scheduler = spec2.Scheduler
-	}
-	if spec2.Compiler != "" {
-		spec.Compiler = spec2.Compiler
-	}
-	if spec2.Linker != "" {
-		spec.Linker = spec2.Linker
-	}
-	if spec2.RTLib != "" {
-		spec.RTLib = spec2.RTLib
-	}
-	if spec2.Libc != "" {
-		spec.Libc = spec2.Libc
-	}
-	if spec2.AutoStackSize != nil {
-		spec.AutoStackSize = spec2.AutoStackSize
-	}
-	if spec2.DefaultStackSize != 0 {
-		spec.DefaultStackSize = spec2.DefaultStackSize
-	}
-	spec.CFlags = append(spec.CFlags, spec2.CFlags...)
-	spec.LDFlags = append(spec.LDFlags, spec2.LDFlags...)
-	if spec2.LinkerScript != "" {
-		spec.LinkerScript = spec2.LinkerScript
-	}
-	spec.ExtraFiles = append(spec.ExtraFiles, spec2.ExtraFiles...)
-	if len(spec2.Emulator) != 0 {
-		spec.Emulator = spec2.Emulator
-	}
-	if spec2.FlashCommand != "" {
-		spec.FlashCommand = spec2.FlashCommand
-	}
-	if spec2.GDB != "" {
-		spec.GDB = spec2.GDB
-	}
-	if spec2.PortReset != "" {
-		spec.PortReset = spec2.PortReset
-	}
-	if spec2.FlashMethod != "" {
-		spec.FlashMethod = spec2.FlashMethod
-	}
-	if spec2.FlashVolume != "" {
-		spec.FlashVolume = spec2.FlashVolume
-	}
-	if spec2.FlashFilename != "" {
-		spec.FlashFilename = spec2.FlashFilename
-	}
-	if spec2.UF2FamilyID != "" {
-		spec.UF2FamilyID = spec2.UF2FamilyID
-	}
-	if spec2.BinaryFormat != "" {
-		spec.BinaryFormat = spec2.BinaryFormat
-	}
-	if spec2.OpenOCDInterface != "" {
-		spec.OpenOCDInterface = spec2.OpenOCDInterface
-	}
-	if spec2.OpenOCDTarget != "" {
-		spec.OpenOCDTarget = spec2.OpenOCDTarget
-	}
-	if spec2.OpenOCDTransport != "" {
-		spec.OpenOCDTransport = spec2.OpenOCDTransport
-	}
-	if spec2.JLinkDevice != "" {
-		spec.JLinkDevice = spec2.JLinkDevice
-	}
-	if spec2.CodeModel != "" {
-		spec.CodeModel = spec2.CodeModel
-	}
+// overrideProperties overrides all properties that are set in child into itself using reflection.
+func (spec *TargetSpec) overrideProperties(child *TargetSpec) {
+	specType := reflect.TypeOf(spec).Elem()
+	specValue := reflect.ValueOf(spec).Elem()
+	childValue := reflect.ValueOf(child).Elem()
 
-	if spec2.RelocationModel != "" {
-		spec.RelocationModel = spec2.RelocationModel
+	for i := 0; i < specType.NumField(); i++ {
+		field := specType.Field(i)
+		src := childValue.Field(i)
+		dst := specValue.Field(i)
+
+		switch kind := field.Type.Kind(); kind {
+		case reflect.String: // for strings, just copy the field of child to spec if not empty
+			if src.Len() > 0 {
+				dst.Set(src)
+			}
+		case reflect.Uint, reflect.Uint32, reflect.Uint64: // for Uint, copy if not zero
+			if src.Uint() != 0 {
+				dst.Set(src)
+			}
+		case reflect.Ptr: // for pointers, copy if not nil
+			if !src.IsNil() {
+				dst.Set(src)
+			}
+		case reflect.Slice: // for slices...
+			if src.Len() > 0 { // ... if not empty ...
+				switch tag := field.Tag.Get("override"); tag {
+				case "copy":
+					// copy the field of child to spec
+					dst.Set(src)
+				case "append", "":
+					// or append the field of child to spec
+					dst.Set(reflect.AppendSlice(src, dst))
+				default:
+					panic("override mode must be 'copy' or 'append' (default). I don't know how to '" + tag + "'.")
+				}
+			}
+		default:
+			panic("unknown field type : " + kind.String())
+		}
 	}
 }
 
@@ -198,11 +147,11 @@ func (spec *TargetSpec) resolveInherits() error {
 		if err != nil {
 			return err
 		}
-		newSpec.copyProperties(subtarget)
+		newSpec.overrideProperties(subtarget)
 	}
 
 	// When all properties are loaded, make sure they are properly inherited.
-	newSpec.copyProperties(spec)
+	newSpec.overrideProperties(spec)
 	*spec = *newSpec
 
 	return nil
@@ -268,6 +217,7 @@ func LoadTarget(target string) (*TargetSpec, error) {
 		}
 		goarch := map[string]string{ // map from LLVM arch to Go arch
 			"i386":    "386",
+			"i686":    "386",
 			"x86_64":  "amd64",
 			"aarch64": "arm64",
 			"armv7":   "arm",
@@ -283,39 +233,40 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 	// No target spec available. Use the default one, useful on most systems
 	// with a regular OS.
 	spec := TargetSpec{
-		Triple:      triple,
-		GOOS:        goos,
-		GOARCH:      goarch,
-		BuildTags:   []string{goos, goarch},
-		Compiler:    "clang",
-		Linker:      "cc",
-		CFlags:      []string{"--target=" + triple},
-		GDB:         "gdb",
-		PortReset:   "false",
-		FlashMethod: "native",
+		Triple:    triple,
+		GOOS:      goos,
+		GOARCH:    goarch,
+		BuildTags: []string{goos, goarch},
+		Compiler:  "clang",
+		Linker:    "cc",
+		CFlags:    []string{"--target=" + triple},
+		GDB:       "gdb",
+		PortReset: "false",
 	}
 	if goos == "darwin" {
 		spec.LDFlags = append(spec.LDFlags, "-Wl,-dead_strip")
 	} else {
 		spec.LDFlags = append(spec.LDFlags, "-no-pie", "-Wl,--gc-sections") // WARNING: clang < 5.0 requires -nopie
 	}
+	if goarch != "wasm" {
+		spec.ExtraFiles = append(spec.ExtraFiles, "src/runtime/gc_"+goarch+".S")
+	}
 	if goarch != runtime.GOARCH {
 		// Some educated guesses as to how to invoke helper programs.
+		spec.GDB = "gdb-multiarch"
 		if goarch == "arm" && goos == "linux" {
 			spec.CFlags = append(spec.CFlags, "--sysroot=/usr/arm-linux-gnueabihf")
 			spec.Linker = "arm-linux-gnueabihf-gcc"
-			spec.GDB = "arm-linux-gnueabihf-gdb"
 			spec.Emulator = []string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"}
 		}
 		if goarch == "arm64" && goos == "linux" {
 			spec.CFlags = append(spec.CFlags, "--sysroot=/usr/aarch64-linux-gnu")
 			spec.Linker = "aarch64-linux-gnu-gcc"
-			spec.GDB = "aarch64-linux-gnu-gdb"
 			spec.Emulator = []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"}
 		}
-		if goarch == "386" {
-			spec.CFlags = []string{"-m32"}
-			spec.LDFlags = []string{"-m32"}
+		if goarch == "386" && runtime.GOARCH == "amd64" {
+			spec.CFlags = append(spec.CFlags, "-m32")
+			spec.LDFlags = append(spec.LDFlags, "-m32")
 		}
 	}
 	return &spec, nil

compileopts/target_test.go

@@ -1,6 +1,9 @@
 package compileopts
 
-import "testing"
+import (
+	"reflect"
+	"testing"
+)
 
 func TestLoadTarget(t *testing.T) {
 	_, err := LoadTarget("arduino")
@@ -17,3 +20,67 @@ func TestLoadTarget(t *testing.T) {
 		t.Error("LoadTarget failed for wrong reason:", err)
 	}
 }
+
+func TestOverrideProperties(t *testing.T) {
+	baseAutoStackSize := true
+	base := &TargetSpec{
+		GOOS:             "baseGoos",
+		CPU:              "baseCpu",
+		Features:         []string{"bf1", "bf2"},
+		BuildTags:        []string{"bt1", "bt2"},
+		Emulator:         []string{"be1", "be2"},
+		DefaultStackSize: 42,
+		AutoStackSize:    &baseAutoStackSize,
+	}
+	childAutoStackSize := false
+	child := &TargetSpec{
+		GOOS:             "",
+		CPU:              "chlidCpu",
+		Features:         []string{"cf1", "cf2"},
+		Emulator:         []string{"ce1", "ce2"},
+		AutoStackSize:    &childAutoStackSize,
+		DefaultStackSize: 64,
+	}
+
+	base.overrideProperties(child)
+
+	if base.GOOS != "baseGoos" {
+		t.Errorf("Overriding failed : got %v", base.GOOS)
+	}
+	if base.CPU != "chlidCpu" {
+		t.Errorf("Overriding failed : got %v", base.CPU)
+	}
+	if !reflect.DeepEqual(base.Features, []string{"cf1", "cf2", "bf1", "bf2"}) {
+		t.Errorf("Overriding failed : got %v", base.Features)
+	}
+	if !reflect.DeepEqual(base.BuildTags, []string{"bt1", "bt2"}) {
+		t.Errorf("Overriding failed : got %v", base.BuildTags)
+	}
+	if !reflect.DeepEqual(base.Emulator, []string{"ce1", "ce2"}) {
+		t.Errorf("Overriding failed : got %v", base.Emulator)
+	}
+	if *base.AutoStackSize != false {
+		t.Errorf("Overriding failed : got %v", base.AutoStackSize)
+	}
+	if base.DefaultStackSize != 64 {
+		t.Errorf("Overriding failed : got %v", base.DefaultStackSize)
+	}
+
+	baseAutoStackSize = true
+	base = &TargetSpec{
+		AutoStackSize:    &baseAutoStackSize,
+		DefaultStackSize: 42,
+	}
+	child = &TargetSpec{
+		AutoStackSize:    nil,
+		DefaultStackSize: 0,
+	}
+	base.overrideProperties(child)
+	if *base.AutoStackSize != true {
+		t.Errorf("Overriding failed : got %v", base.AutoStackSize)
+	}
+	if base.DefaultStackSize != 42 {
+		t.Errorf("Overriding failed : got %v", base.DefaultStackSize)
+	}
+
+}

compiler/asserts.go

@@ -16,7 +16,7 @@ import (
 // slice. This is required by the Go language spec: an index out of bounds must
 // cause a panic.
 func (b *builder) createLookupBoundsCheck(arrayLen, index llvm.Value, indexType types.Type) {
-	if b.fn.IsNoBounds() {
+	if b.info.nobounds {
 		// The //go:nobounds pragma was added to the function to avoid bounds
 		// checking.
 		return
@@ -48,7 +48,7 @@ func (b *builder) createLookupBoundsCheck(arrayLen, index llvm.Value, indexType
 // biggest possible slice capacity, 'low' means len and 'high' means cap. The
 // logic is the same in both cases.
 func (b *builder) createSliceBoundsCheck(capacity, low, high, max llvm.Value, lowType, highType, maxType *types.Basic) {
-	if b.fn.IsNoBounds() {
+	if b.info.nobounds {
 		// The //go:nobounds pragma was added to the function to avoid bounds
 		// checking.
 		return
@@ -104,7 +104,7 @@ func (b *builder) createSliceBoundsCheck(capacity, low, high, max llvm.Value, lo
 // createChanBoundsCheck creates a bounds check before creating a new channel to
 // check that the value is not too big for runtime.chanMake.
 func (b *builder) createChanBoundsCheck(elementSize uint64, bufSize llvm.Value, bufSizeType *types.Basic, pos token.Pos) {
-	if b.fn.IsNoBounds() {
+	if b.info.nobounds {
 		// The //go:nobounds pragma was added to the function to avoid bounds
 		// checking.
 		return
@@ -189,7 +189,7 @@ func (b *builder) createNilCheck(inst ssa.Value, ptr llvm.Value, blockPrefix str
 // createNegativeShiftCheck creates an assertion that panics if the given shift value is negative.
 // This function assumes that the shift value is signed.
 func (b *builder) createNegativeShiftCheck(shift llvm.Value) {
-	if b.fn.IsNoBounds() {
+	if b.info.nobounds {
 		// Function disabled bounds checking - skip shift check.
 		return
 	}
@@ -212,8 +212,8 @@ func (b *builder) createRuntimeAssert(assert llvm.Value, blockPrefix, assertFunc
 		}
 	}
 
-	faultBlock := b.ctx.AddBasicBlock(b.fn.LLVMFn, blockPrefix+".throw")
-	nextBlock := b.ctx.AddBasicBlock(b.fn.LLVMFn, blockPrefix+".next")
+	faultBlock := b.ctx.AddBasicBlock(b.llvmFn, blockPrefix+".throw")
+	nextBlock := b.ctx.AddBasicBlock(b.llvmFn, blockPrefix+".next")
 	b.blockExits[b.currentBlock] = nextBlock // adjust outgoing block for phi nodes
 
 	// Now branch to the out-of-bounds or the regular block.

compiler/atomic.go

@@ -1,6 +1,8 @@
 package compiler
 
 import (
+	"strings"
+
 	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )
@@ -35,6 +37,31 @@ func (b *builder) createAtomicOp(call *ssa.CallCommon) (llvm.Value, bool) {
 		ptr := b.getValue(call.Args[0])
 		old := b.getValue(call.Args[1])
 		newVal := b.getValue(call.Args[2])
+		if strings.HasSuffix(name, "64") {
+			arch := strings.Split(b.Triple, "-")[0]
+			if strings.HasPrefix(arch, "arm") && strings.HasSuffix(arch, "m") {
+				// Work around a bug in LLVM, at least LLVM 11:
+				// https://reviews.llvm.org/D95891
+				// Check for armv6m, armv7, armv7em, and perhaps others.
+				// See also: https://gcc.gnu.org/onlinedocs/gcc/_005f_005fsync-Builtins.html
+				compareAndSwap := b.mod.NamedFunction("__sync_val_compare_and_swap_8")
+				if compareAndSwap.IsNil() {
+					// Declare the function if it isn't already declared.
+					i64Type := b.ctx.Int64Type()
+					fnType := llvm.FunctionType(i64Type, []llvm.Type{llvm.PointerType(i64Type, 0), i64Type, i64Type}, false)
+					compareAndSwap = llvm.AddFunction(b.mod, "__sync_val_compare_and_swap_8", fnType)
+				}
+				actualOldValue := b.CreateCall(compareAndSwap, []llvm.Value{ptr, old, newVal}, "")
+				// The __sync_val_compare_and_swap_8 function returns the old
+				// value. However, we shouldn't return the old value, we should
+				// return whether the compare/exchange was successful. This is
+				// easily done by comparing the returned (actual) old value with
+				// the expected old value passed to
+				// __sync_val_compare_and_swap_8.
+				swapped := b.CreateICmp(llvm.IntEQ, old, actualOldValue, "")
+				return swapped, true
+			}
+		}
 		tuple := b.CreateAtomicCmpXchg(ptr, old, newVal, llvm.AtomicOrderingSequentiallyConsistent, llvm.AtomicOrderingSequentiallyConsistent, true)
 		swapped := b.CreateExtractValue(tuple, 1, "")
 		return swapped, true

compiler/calls.go

@@ -4,6 +4,7 @@ import (
 	"go/types"
 	"strconv"
 
+	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )
 
@@ -34,14 +35,14 @@ const (
 
 // createCall creates a new call to runtime.<fnName> with the given arguments.
 func (b *builder) createRuntimeCall(fnName string, args []llvm.Value, name string) llvm.Value {
-	fullName := "runtime." + fnName
-	fn := b.mod.NamedFunction(fullName)
-	if fn.IsNil() {
-		panic("trying to call non-existent function: " + fullName)
+	fn := b.program.ImportedPackage("runtime").Members[fnName].(*ssa.Function)
+	llvmFn := b.getFunction(fn)
+	if llvmFn.IsNil() {
+		panic("trying to call non-existent function: " + fn.RelString(nil))
 	}
 	args = append(args, llvm.Undef(b.i8ptrType))            // unused context parameter
 	args = append(args, llvm.ConstPointerNull(b.i8ptrType)) // coroutine handle
-	return b.createCall(fn, args, name)
+	return b.createCall(llvmFn, args, name)
 }
 
 // createCall creates a call to the given function with the arguments possibly

compiler/channel.go

@@ -79,8 +79,7 @@ func (b *builder) createChanRecv(unop *ssa.UnOp) llvm.Value {
 }
 
 // createChanClose closes the given channel.
-func (b *builder) createChanClose(param ssa.Value) {
-	ch := b.getValue(param)
+func (b *builder) createChanClose(ch llvm.Value) {
 	b.createRuntimeCall("chanClose", []llvm.Value{ch}, "")
 }
 

compiler/compiler_test.go

@@ -0,0 +1,172 @@
+package compiler
+
+import (
+	"flag"
+	"go/types"
+	"io/ioutil"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/tinygo-org/tinygo/compileopts"
+	"github.com/tinygo-org/tinygo/loader"
+	"tinygo.org/x/go-llvm"
+)
+
+// Pass -update to go test to update the output of the test files.
+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) {
+	target, err := compileopts.LoadTarget("i686--linux")
+	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",
+		"float.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/" + testCase}, config.ClangHeaders, types.Config{
+				Sizes: Sizes(machine),
+			})
+			if err != nil {
+				t.Fatal("failed to create target machine:", err)
+			}
+			err = lprogram.Parse()
+			if err != nil {
+				t.Fatalf("could not parse test case %s: %s", testCase, err)
+			}
+
+			// Compile AST to IR.
+			pkg := lprogram.MainPkg()
+			mod, errs := CompilePackage(testCase, pkg, machine, compilerConfig, false)
+			if errs != nil {
+				for _, err := range errs {
+					t.Log("error:", err)
+				}
+				return
+			}
+
+			// Optimize IR a little.
+			funcPasses := llvm.NewFunctionPassManagerForModule(mod)
+			defer funcPasses.Dispose()
+			funcPasses.AddInstructionCombiningPass()
+			funcPasses.InitializeFunc()
+			for fn := mod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
+				funcPasses.RunFunc(fn)
+			}
+			funcPasses.FinalizeFunc()
+
+			outfile := "./testdata/" + testCase[:len(testCase)-3] + ".ll"
+
+			// Update test if needed. Do not check the result.
+			if *flagUpdate {
+				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(outfile)
+			if err != nil {
+				t.Fatal("failed to read golden file:", err)
+			}
+
+			if !fuzzyEqualIR(mod.String(), string(expected)) {
+				t.Errorf("output does not match expected output:\n%s", mod.String())
+			}
+		})
+	}
+}
+
+var alignRegexp = regexp.MustCompile(", align [0-9]+$")
+
+// fuzzyEqualIR returns true if the two LLVM IR strings passed in are roughly
+// equal. That means, only relevant lines are compared (excluding comments
+// etc.).
+func fuzzyEqualIR(s1, s2 string) bool {
+	lines1 := filterIrrelevantIRLines(strings.Split(s1, "\n"))
+	lines2 := filterIrrelevantIRLines(strings.Split(s2, "\n"))
+	if len(lines1) != len(lines2) {
+		return false
+	}
+	for i, line1 := range lines1 {
+		line2 := lines2[i]
+		match1 := alignRegexp.MatchString(line1)
+		match2 := alignRegexp.MatchString(line2)
+		if match1 != match2 {
+			// Only one of the lines has the align keyword. Remove it.
+			// This is a change to make the test work in both LLVM 10 and LLVM
+			// 11 (LLVM 11 appears to automatically add alignment everywhere).
+			line1 = alignRegexp.ReplaceAllString(line1, "")
+			line2 = alignRegexp.ReplaceAllString(line2, "")
+		}
+		if line1 != line2 {
+			return false
+		}
+	}
+
+	return true
+}
+
+// filterIrrelevantIRLines removes lines from the input slice of strings that
+// are not relevant in comparing IR. For example, empty lines and comments are
+// stripped out.
+func filterIrrelevantIRLines(lines []string) []string {
+	var out []string
+	llvmVersion, err := strconv.Atoi(strings.Split(llvm.Version, ".")[0])
+	if err != nil {
+		// Note: this should never happen and if it does, it will always happen
+		// for a particular build because llvm.Version is a constant.
+		panic(err)
+	}
+	for _, line := range lines {
+		line = strings.Split(line, ";")[0]    // strip out comments/info
+		line = strings.TrimRight(line, "\r ") // drop '\r' on Windows and remove trailing spaces from comments
+		if line == "" {
+			continue
+		}
+		if strings.HasPrefix(line, "source_filename = ") {
+			continue
+		}
+		if llvmVersion < 10 && strings.HasPrefix(line, "attributes ") {
+			// Ignore attribute groups. These may change between LLVM versions.
+			// Right now test outputs are for LLVM 10.
+			continue
+		}
+		if llvmVersion < 10 && strings.HasPrefix(line, "target datalayout ") {
+			// Ignore the target layout. This may change between LLVM versions.
+			continue
+		}
+		out = append(out, line)
+	}
+	return out
+}

compiler/defer.go

@@ -14,9 +14,9 @@ package compiler
 //     frames.
 
 import (
-	"github.com/tinygo-org/tinygo/compiler/llvmutil"
-	"github.com/tinygo-org/tinygo/ir"
 	"go/types"
+
+	"github.com/tinygo-org/tinygo/compiler/llvmutil"
 	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )
@@ -26,9 +26,9 @@ import (
 // calls.
 func (b *builder) deferInitFunc() {
 	// Some setup.
-	b.deferFuncs = make(map[*ir.Function]int)
+	b.deferFuncs = make(map[*ssa.Function]int)
 	b.deferInvokeFuncs = make(map[string]int)
-	b.deferClosureFuncs = make(map[*ir.Function]int)
+	b.deferClosureFuncs = make(map[*ssa.Function]int)
 	b.deferExprFuncs = make(map[ssa.Value]int)
 	b.deferBuiltinFuncs = make(map[ssa.Value]deferBuiltin)
 
@@ -107,13 +107,11 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 
 	} else if callee, ok := instr.Call.Value.(*ssa.Function); ok {
 		// Regular function call.
-		fn := b.ir.GetFunction(callee)
-
-		if _, ok := b.deferFuncs[fn]; !ok {
-			b.deferFuncs[fn] = len(b.allDeferFuncs)
-			b.allDeferFuncs = append(b.allDeferFuncs, fn)
+		if _, ok := b.deferFuncs[callee]; !ok {
+			b.deferFuncs[callee] = len(b.allDeferFuncs)
+			b.allDeferFuncs = append(b.allDeferFuncs, callee)
 		}
-		callback := llvm.ConstInt(b.uintptrType, uint64(b.deferFuncs[fn]), false)
+		callback := llvm.ConstInt(b.uintptrType, uint64(b.deferFuncs[callee]), false)
 
 		// Collect all values to be put in the struct (starting with
 		// runtime._defer fields).
@@ -135,7 +133,7 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 		context := b.CreateExtractValue(closure, 0, "")
 
 		// Get the callback number.
-		fn := b.ir.GetFunction(makeClosure.Fn.(*ssa.Function))
+		fn := makeClosure.Fn.(*ssa.Function)
 		if _, ok := b.deferClosureFuncs[fn]; !ok {
 			b.deferClosureFuncs[fn] = len(b.allDeferFuncs)
 			b.allDeferFuncs = append(b.allDeferFuncs, makeClosure)
@@ -155,19 +153,19 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 		valueTypes = append(valueTypes, context.Type())
 
 	} else if builtin, ok := instr.Call.Value.(*ssa.Builtin); ok {
-		var funcName string
-		switch builtin.Name() {
-		case "close":
-			funcName = "chanClose"
-		default:
-			b.addError(instr.Pos(), "todo: Implement defer for "+builtin.Name())
-			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))
 		}
 
 		if _, ok := b.deferBuiltinFuncs[instr.Call.Value]; !ok {
 			b.deferBuiltinFuncs[instr.Call.Value] = deferBuiltin{
-				funcName,
-				len(b.allDeferFuncs),
+				callName: builtin.Name(),
+				pos:      builtin.Pos(),
+				argTypes: argTypes,
+				callback: len(b.allDeferFuncs),
 			}
 			b.allDeferFuncs = append(b.allDeferFuncs, instr.Call.Value)
 		}
@@ -176,10 +174,9 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 		// Collect all values to be put in the struct (starting with
 		// runtime._defer fields).
 		values = []llvm.Value{callback, next}
-		for _, param := range instr.Call.Args {
-			llvmParam := b.getValue(param)
-			values = append(values, llvmParam)
-			valueTypes = append(valueTypes, llvmParam.Type())
+		for _, param := range argValues {
+			values = append(values, param)
+			valueTypes = append(valueTypes, param.Type())
 		}
 
 	} else {
@@ -223,7 +220,7 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 		allocCall := b.createRuntimeCall("alloc", []llvm.Value{sizeValue}, "defer.alloc.call")
 		alloca = b.CreateBitCast(allocCall, llvm.PointerType(deferFrameType, 0), "defer.alloc")
 	}
-	if b.NeedsStackObjects() {
+	if b.NeedsStackObjects {
 		b.trackPointer(alloca)
 	}
 	b.CreateStore(deferFrame, alloca)
@@ -251,10 +248,10 @@ func (b *builder) createRunDefers() {
 	//     }
 
 	// Create loop.
-	loophead := b.ctx.AddBasicBlock(b.fn.LLVMFn, "rundefers.loophead")
-	loop := b.ctx.AddBasicBlock(b.fn.LLVMFn, "rundefers.loop")
-	unreachable := b.ctx.AddBasicBlock(b.fn.LLVMFn, "rundefers.default")
-	end := b.ctx.AddBasicBlock(b.fn.LLVMFn, "rundefers.end")
+	loophead := b.ctx.AddBasicBlock(b.llvmFn, "rundefers.loophead")
+	loop := b.ctx.AddBasicBlock(b.llvmFn, "rundefers.loop")
+	unreachable := b.ctx.AddBasicBlock(b.llvmFn, "rundefers.default")
+	end := b.ctx.AddBasicBlock(b.llvmFn, "rundefers.end")
 	b.CreateBr(loophead)
 
 	// Create loop head:
@@ -286,7 +283,7 @@ func (b *builder) createRunDefers() {
 		// Create switch case, for example:
 		//     case 0:
 		//         // run first deferred call
-		block := b.ctx.AddBasicBlock(b.fn.LLVMFn, "rundefers.callback")
+		block := b.ctx.AddBasicBlock(b.llvmFn, "rundefers.callback")
 		sw.AddCase(llvm.ConstInt(b.uintptrType, uint64(i), false), block)
 		b.SetInsertPointAtEnd(block)
 		switch callback := callback.(type) {
@@ -350,7 +347,7 @@ func (b *builder) createRunDefers() {
 
 			b.createCall(fnPtr, forwardParams, "")
 
-		case *ir.Function:
+		case *ssa.Function:
 			// Direct call.
 
 			// Get the real defer struct type and cast to it.
@@ -372,7 +369,7 @@ func (b *builder) createRunDefers() {
 
 			// Plain TinyGo functions add some extra parameters to implement async functionality and function recievers.
 			// These parameters should not be supplied when calling into an external C/ASM function.
-			if !callback.IsExported() {
+			if !b.getFunctionInfo(callback).exported {
 				// Add the context parameter. We know it is ignored by the receiving
 				// function, but we have to pass one anyway.
 				forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))
@@ -382,11 +379,11 @@ func (b *builder) createRunDefers() {
 			}
 
 			// Call real function.
-			b.createCall(callback.LLVMFn, forwardParams, "")
+			b.createCall(b.getFunction(callback), forwardParams, "")
 
 		case *ssa.MakeClosure:
 			// Get the real defer struct type and cast to it.
-			fn := b.ir.GetFunction(callback.Fn.(*ssa.Function))
+			fn := callback.Fn.(*ssa.Function)
 			valueTypes := []llvm.Type{b.uintptrType, llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0)}
 			params := fn.Signature.Params()
 			for i := 0; i < params.Len(); i++ {
@@ -409,7 +406,7 @@ func (b *builder) createRunDefers() {
 			forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))
 
 			// Call deferred function.
-			b.createCall(fn.LLVMFn, forwardParams, "")
+			b.createCall(b.getFunction(fn), forwardParams, "")
 		case *ssa.Builtin:
 			db := b.deferBuiltinFuncs[callback]
 
@@ -426,15 +423,18 @@ func (b *builder) createRunDefers() {
 			deferFramePtr := b.CreateBitCast(deferData, llvm.PointerType(deferFrameType, 0), "deferFrame")
 
 			// Extract the params from the struct.
-			var forwardParams []llvm.Value
+			var argValues []llvm.Value
 			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
 			for i := 0; i < params.Len(); i++ {
 				gep := b.CreateInBoundsGEP(deferFramePtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i+2), false)}, "gep")
 				forwardParam := b.CreateLoad(gep, "param")
-				forwardParams = append(forwardParams, forwardParam)
+				argValues = append(argValues, forwardParam)
 			}
 
-			b.createRuntimeCall(db.funcName, forwardParams, "")
+			_, err := b.createBuiltin(db.argTypes, argValues, db.callName, db.pos)
+			if err != nil {
+				b.diagnostics = append(b.diagnostics, err)
+			}
 		default:
 			panic("unknown deferred function type")
 		}

compiler/errors.go

@@ -14,7 +14,7 @@ import (
 // makeError makes it easy to create an error from a token.Pos with a message.
 func (c *compilerContext) makeError(pos token.Pos, msg string) types.Error {
 	return types.Error{
-		Fset: c.ir.Program.Fset,
+		Fset: c.program.Fset,
 		Pos:  pos,
 		Msg:  msg,
 	}

compiler/func.go

@@ -6,7 +6,6 @@ package compiler
 import (
 	"go/types"
 
-	"github.com/tinygo-org/tinygo/compileopts"
 	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )
@@ -21,11 +20,11 @@ func (b *builder) createFuncValue(funcPtr, context llvm.Value, sig *types.Signat
 // context.
 func (c *compilerContext) createFuncValue(builder llvm.Builder, funcPtr, context llvm.Value, sig *types.Signature) llvm.Value {
 	var funcValueScalar llvm.Value
-	switch c.FuncImplementation() {
-	case compileopts.FuncValueDoubleword:
+	switch c.FuncImplementation {
+	case "doubleword":
 		// Closure is: {context, function pointer}
 		funcValueScalar = funcPtr
-	case compileopts.FuncValueSwitch:
+	case "switch":
 		sigGlobal := c.getTypeCode(sig)
 		funcValueWithSignatureGlobalName := funcPtr.Name() + "$withSignature"
 		funcValueWithSignatureGlobal := c.mod.NamedGlobal(funcValueWithSignatureGlobalName)
@@ -67,10 +66,10 @@ func (b *builder) extractFuncContext(funcValue llvm.Value) llvm.Value {
 // value. This may be an expensive operation.
 func (b *builder) decodeFuncValue(funcValue llvm.Value, sig *types.Signature) (funcPtr, context llvm.Value) {
 	context = b.CreateExtractValue(funcValue, 0, "")
-	switch b.FuncImplementation() {
-	case compileopts.FuncValueDoubleword:
+	switch b.FuncImplementation {
+	case "doubleword":
 		funcPtr = b.CreateExtractValue(funcValue, 1, "")
-	case compileopts.FuncValueSwitch:
+	case "switch":
 		llvmSig := b.getRawFuncType(sig)
 		sigGlobal := b.getTypeCode(sig)
 		funcPtr = b.createRuntimeCall("getFuncPtr", []llvm.Value{funcValue, sigGlobal}, "")
@@ -83,11 +82,11 @@ func (b *builder) decodeFuncValue(funcValue llvm.Value, sig *types.Signature) (f
 
 // getFuncType returns the type of a func value given a signature.
 func (c *compilerContext) getFuncType(typ *types.Signature) llvm.Type {
-	switch c.FuncImplementation() {
-	case compileopts.FuncValueDoubleword:
+	switch c.FuncImplementation {
+	case "doubleword":
 		rawPtr := c.getRawFuncType(typ)
 		return c.ctx.StructType([]llvm.Type{c.i8ptrType, rawPtr}, false)
-	case compileopts.FuncValueSwitch:
+	case "switch":
 		return c.getLLVMRuntimeType("funcValue")
 	default:
 		panic("unimplemented func value variant")
@@ -149,7 +148,7 @@ func (b *builder) parseMakeClosure(expr *ssa.MakeClosure) (llvm.Value, error) {
 	if len(expr.Bindings) == 0 {
 		panic("unexpected: MakeClosure without bound variables")
 	}
-	f := b.ir.GetFunction(expr.Fn.(*ssa.Function))
+	f := expr.Fn.(*ssa.Function)
 
 	// Collect all bound variables.
 	boundVars := make([]llvm.Value, len(expr.Bindings))
@@ -164,5 +163,5 @@ func (b *builder) parseMakeClosure(expr *ssa.MakeClosure) (llvm.Value, error) {
 	context := b.emitPointerPack(boundVars)
 
 	// Create the closure.
-	return b.createFuncValue(f.LLVMFn, context, f.Signature), nil
+	return b.createFuncValue(b.getFunction(f), context, f.Signature), nil
 }

compiler/goroutine.go

@@ -7,6 +7,7 @@ import (
 	"go/token"
 
 	"github.com/tinygo-org/tinygo/compiler/llvmutil"
+	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )
 
@@ -20,19 +21,20 @@ import (
 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() {
+	switch b.Scheduler {
 	case "none", "tasks":
 		callee = b.createGoroutineStartWrapper(funcPtr, prefix, pos)
-		if b.AutomaticStackSize() {
+		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
 			// section that contains the stack size (and is modified after
 			// linking).
-			stackSize = b.createCall(b.mod.NamedFunction("internal/task.getGoroutineStackSize"), []llvm.Value{callee, llvm.Undef(b.i8ptrType), llvm.Undef(b.i8ptrType)}, "stacksize")
+			stackSizeFn := b.getFunction(b.program.ImportedPackage("internal/task").Members["getGoroutineStackSize"].(*ssa.Function))
+			stackSize = b.createCall(stackSizeFn, []llvm.Value{callee, llvm.Undef(b.i8ptrType), llvm.Undef(b.i8ptrType)}, "stacksize")
 		} else {
 			// The stack size is fixed at compile time. By emitting it here as a
 			// constant, it can be optimized.
-			stackSize = llvm.ConstInt(b.uintptrType, b.Target.DefaultStackSize, false)
+			stackSize = llvm.ConstInt(b.uintptrType, b.DefaultStackSize, false)
 		}
 	case "coroutines":
 		callee = b.CreatePtrToInt(funcPtr, b.uintptrType, "")
@@ -42,7 +44,8 @@ func (b *builder) createGoInstruction(funcPtr llvm.Value, params []llvm.Value, p
 	default:
 		panic("unreachable")
 	}
-	b.createCall(b.mod.NamedFunction("internal/task.start"), []llvm.Value{callee, paramBundle, stackSize, llvm.Undef(b.i8ptrType), llvm.ConstPointerNull(b.i8ptrType)}, "")
+	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())
 }
 
@@ -87,8 +90,8 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 		entry := c.ctx.AddBasicBlock(wrapper, "entry")
 		builder.SetInsertPointAtEnd(entry)
 
-		if c.Debug() {
-			pos := c.ir.Program.Fset.Position(pos)
+		if c.Debug {
+			pos := c.program.Fset.Position(pos)
 			diFuncType := c.dibuilder.CreateSubroutineType(llvm.DISubroutineType{
 				File:       c.getDIFile(pos.Filename),
 				Parameters: nil, // do not show parameters in debugger
@@ -144,8 +147,8 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 		entry := c.ctx.AddBasicBlock(wrapper, "entry")
 		builder.SetInsertPointAtEnd(entry)
 
-		if c.Debug() {
-			pos := c.ir.Program.Fset.Position(pos)
+		if c.Debug {
+			pos := c.program.Fset.Position(pos)
 			diFuncType := c.dibuilder.CreateSubroutineType(llvm.DISubroutineType{
 				File:       c.getDIFile(pos.Filename),
 				Parameters: nil, // do not show parameters in debugger

compiler/inlineasm.go

@@ -163,6 +163,44 @@ func (b *builder) emitSVCall(args []ssa.Value) (llvm.Value, error) {
 	return b.CreateCall(target, llvmArgs, ""), nil
 }
 
+// This is a compiler builtin which emits an inline SVCall instruction. It can
+// be one of:
+//
+//     func SVCall0(num uintptr) uintptr
+//     func SVCall1(num uintptr, a1 interface{}) uintptr
+//     func SVCall2(num uintptr, a1, a2 interface{}) uintptr
+//     func SVCall3(num uintptr, a1, a2, a3 interface{}) uintptr
+//     func SVCall4(num uintptr, a1, a2, a3, a4 interface{}) uintptr
+//
+// The num parameter must be a constant. All other parameters may be any scalar
+// value supported by LLVM inline assembly.
+// Same as emitSVCall but for AArch64
+func (b *builder) emitSV64Call(args []ssa.Value) (llvm.Value, error) {
+	num, _ := constant.Uint64Val(args[0].(*ssa.Const).Value)
+	llvmArgs := []llvm.Value{}
+	argTypes := []llvm.Type{}
+	asm := "svc #" + strconv.FormatUint(num, 10)
+	constraints := "={x0}"
+	for i, arg := range args[1:] {
+		arg = arg.(*ssa.MakeInterface).X
+		if i == 0 {
+			constraints += ",0"
+		} else {
+			constraints += ",{x" + strconv.Itoa(i) + "}"
+		}
+		llvmValue := b.getValue(arg)
+		llvmArgs = append(llvmArgs, llvmValue)
+		argTypes = append(argTypes, llvmValue.Type())
+	}
+	// Implement the ARM64 calling convention by marking x1-x7 as
+	// clobbered. x0 is used as an output register so doesn't have to be
+	// marked as clobbered.
+	constraints += ",~{x1},~{x2},~{x3},~{x4},~{x5},~{x6},~{x7}"
+	fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
+	target := llvm.InlineAsm(fnType, asm, constraints, true, false, 0)
+	return b.CreateCall(target, llvmArgs, ""), nil
+}
+
 // This is a compiler builtin which emits CSR instructions. It can be one of:
 //
 //     func (csr CSR) Get() uintptr

compiler/interface.go

@@ -11,7 +11,6 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/tinygo-org/tinygo/ir"
 	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )
@@ -236,7 +235,7 @@ func (c *compilerContext) getTypeMethodSet(typ types.Type) llvm.Value {
 		return llvm.ConstGEP(global, []llvm.Value{zero, zero})
 	}
 
-	ms := c.ir.Program.MethodSets.MethodSet(typ)
+	ms := c.program.MethodSets.MethodSet(typ)
 	if ms.Len() == 0 {
 		// no methods, so can leave that one out
 		return llvm.ConstPointerNull(llvm.PointerType(c.getLLVMRuntimeType("interfaceMethodInfo"), 0))
@@ -247,15 +246,16 @@ func (c *compilerContext) getTypeMethodSet(typ types.Type) llvm.Value {
 	for i := 0; i < ms.Len(); i++ {
 		method := ms.At(i)
 		signatureGlobal := c.getMethodSignature(method.Obj().(*types.Func))
-		f := c.ir.GetFunction(c.ir.Program.MethodValue(method))
-		if f.LLVMFn.IsNil() {
+		fn := c.program.MethodValue(method)
+		llvmFn := c.getFunction(fn)
+		if llvmFn.IsNil() {
 			// compiler error, so panic
-			panic("cannot find function: " + f.LinkName())
+			panic("cannot find function: " + c.getFunctionInfo(fn).linkName)
 		}
-		fn := c.getInterfaceInvokeWrapper(f)
+		wrapper := c.getInterfaceInvokeWrapper(fn, llvmFn)
 		methodInfo := llvm.ConstNamedStruct(interfaceMethodInfoType, []llvm.Value{
 			signatureGlobal,
-			llvm.ConstPtrToInt(fn, c.uintptrType),
+			llvm.ConstPtrToInt(wrapper, c.uintptrType),
 		})
 		methods[i] = methodInfo
 	}
@@ -303,7 +303,7 @@ func (c *compilerContext) getInterfaceMethodSet(typ types.Type) llvm.Value {
 // external *i8 indicating the indicating the signature of this method. It is
 // used during the interface lowering pass.
 func (c *compilerContext) getMethodSignature(method *types.Func) llvm.Value {
-	signature := ir.MethodSignature(method)
+	signature := methodSignature(method)
 	signatureGlobal := c.mod.NamedGlobal("func " + signature)
 	if signatureGlobal.IsNil() {
 		signatureGlobal = llvm.AddGlobal(c.mod, c.ctx.Int8Type(), "func "+signature)
@@ -357,8 +357,8 @@ func (b *builder) createTypeAssert(expr *ssa.TypeAssert) llvm.Value {
 	// value.
 
 	prevBlock := b.GetInsertBlock()
-	okBlock := b.ctx.AddBasicBlock(b.fn.LLVMFn, "typeassert.ok")
-	nextBlock := b.ctx.AddBasicBlock(b.fn.LLVMFn, "typeassert.next")
+	okBlock := b.ctx.AddBasicBlock(b.llvmFn, "typeassert.ok")
+	nextBlock := b.ctx.AddBasicBlock(b.llvmFn, "typeassert.next")
 	b.blockExits[b.currentBlock] = nextBlock // adjust outgoing block for phi nodes
 	b.CreateCondBr(commaOk, okBlock, nextBlock)
 
@@ -436,8 +436,8 @@ func (b *builder) getInvokeCall(instr *ssa.CallCommon) (llvm.Value, []llvm.Value
 // value, dereferences or unpacks it if necessary, and calls the real method.
 // If the method to wrap has a pointer receiver, no wrapping is necessary and
 // the function is returned directly.
-func (c *compilerContext) getInterfaceInvokeWrapper(f *ir.Function) llvm.Value {
-	wrapperName := f.LinkName() + "$invoke"
+func (c *compilerContext) getInterfaceInvokeWrapper(fn *ssa.Function, llvmFn llvm.Value) llvm.Value {
+	wrapperName := llvmFn.Name() + "$invoke"
 	wrapper := c.mod.NamedFunction(wrapperName)
 	if !wrapper.IsNil() {
 		// Wrapper already created. Return it directly.
@@ -445,7 +445,7 @@ func (c *compilerContext) getInterfaceInvokeWrapper(f *ir.Function) llvm.Value {
 	}
 
 	// Get the expanded receiver type.
-	receiverType := c.getLLVMType(f.Params[0].Type())
+	receiverType := c.getLLVMType(fn.Params[0].Type())
 	var expandedReceiverType []llvm.Type
 	for _, info := range expandFormalParamType(receiverType, "", nil) {
 		expandedReceiverType = append(expandedReceiverType, info.llvmType)
@@ -457,17 +457,15 @@ func (c *compilerContext) getInterfaceInvokeWrapper(f *ir.Function) llvm.Value {
 		// Casting a function signature to a different signature and calling it
 		// with a receiver pointer bitcasted to *i8 (as done in calls on an
 		// interface) is hopefully a safe (defined) operation.
-		return f.LLVMFn
+		return llvmFn
 	}
 
 	// create wrapper function
-	fnType := f.LLVMFn.Type().ElementType()
+	fnType := llvmFn.Type().ElementType()
 	paramTypes := append([]llvm.Type{c.i8ptrType}, fnType.ParamTypes()[len(expandedReceiverType):]...)
 	wrapFnType := llvm.FunctionType(fnType.ReturnType(), paramTypes, false)
 	wrapper = llvm.AddFunction(c.mod, wrapperName, wrapFnType)
-	if f.LLVMFn.LastParam().Name() == "parentHandle" {
-		wrapper.LastParam().SetName("parentHandle")
-	}
+	wrapper.LastParam().SetName("parentHandle")
 
 	wrapper.SetLinkage(llvm.InternalLinkage)
 	wrapper.SetUnnamedAddr(true)
@@ -480,9 +478,9 @@ func (c *compilerContext) getInterfaceInvokeWrapper(f *ir.Function) llvm.Value {
 	defer b.Builder.Dispose()
 
 	// add debug info if needed
-	if c.Debug() {
-		pos := c.ir.Program.Fset.Position(f.Pos())
-		difunc := c.attachDebugInfoRaw(f, wrapper, "$invoke", pos.Filename, pos.Line)
+	if c.Debug {
+		pos := c.program.Fset.Position(fn.Pos())
+		difunc := c.attachDebugInfoRaw(fn, wrapper, "$invoke", pos.Filename, pos.Line)
 		b.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), difunc, llvm.Metadata{})
 	}
 
@@ -492,13 +490,60 @@ func (c *compilerContext) getInterfaceInvokeWrapper(f *ir.Function) llvm.Value {
 
 	receiverValue := b.emitPointerUnpack(wrapper.Param(0), []llvm.Type{receiverType})[0]
 	params := append(b.expandFormalParam(receiverValue), wrapper.Params()[1:]...)
-	if f.LLVMFn.Type().ElementType().ReturnType().TypeKind() == llvm.VoidTypeKind {
-		b.CreateCall(f.LLVMFn, params, "")
+	if llvmFn.Type().ElementType().ReturnType().TypeKind() == llvm.VoidTypeKind {
+		b.CreateCall(llvmFn, params, "")
 		b.CreateRetVoid()
 	} else {
-		ret := b.CreateCall(f.LLVMFn, params, "ret")
+		ret := b.CreateCall(llvmFn, params, "ret")
 		b.CreateRet(ret)
 	}
 
 	return wrapper
 }
+
+// methodSignature creates a readable version of a method signature (including
+// the function name, excluding the receiver name). This string is used
+// internally to match interfaces and to call the correct method on an
+// interface. Examples:
+//
+//     String() string
+//     Read([]byte) (int, error)
+func methodSignature(method *types.Func) string {
+	return method.Name() + signature(method.Type().(*types.Signature))
+}
+
+// Make a readable version of a function (pointer) signature.
+// Examples:
+//
+//     () string
+//     (string, int) (int, error)
+func signature(sig *types.Signature) string {
+	s := ""
+	if sig.Params().Len() == 0 {
+		s += "()"
+	} else {
+		s += "("
+		for i := 0; i < sig.Params().Len(); i++ {
+			if i > 0 {
+				s += ", "
+			}
+			s += sig.Params().At(i).Type().String()
+		}
+		s += ")"
+	}
+	if sig.Results().Len() == 0 {
+		// keep as-is
+	} else if sig.Results().Len() == 1 {
+		s += " " + sig.Results().At(0).Type().String()
+	} else {
+		s += " ("
+		for i := 0; i < sig.Results().Len(); i++ {
+			if i > 0 {
+				s += ", "
+			}
+			s += sig.Results().At(i).Type().String()
+		}
+		s += ")"
+	}
+	return s
+}

compiler/interrupt.go

@@ -39,7 +39,7 @@ func (b *builder) createInterruptGlobal(instr *ssa.CallCommon) (llvm.Value, erro
 
 	// Create a new global of type runtime/interrupt.handle. Globals of this
 	// type are lowered in the interrupt lowering pass.
-	globalType := b.ir.Program.ImportedPackage("runtime/interrupt").Type("handle").Type()
+	globalType := b.program.ImportedPackage("runtime/interrupt").Type("handle").Type()
 	globalLLVMType := b.getLLVMType(globalType)
 	globalName := "runtime/interrupt.$interrupt" + strconv.FormatInt(id.Int64(), 10)
 	if global := b.mod.NamedGlobal(globalName); !global.IsNil() {
@@ -55,8 +55,8 @@ func (b *builder) createInterruptGlobal(instr *ssa.CallCommon) (llvm.Value, erro
 	global.SetInitializer(initializer)
 
 	// Add debug info to the interrupt global.
-	if b.Debug() {
-		pos := b.ir.Program.Fset.Position(instr.Pos())
+	if b.Debug {
+		pos := b.program.Fset.Position(instr.Pos())
 		diglobal := b.dibuilder.CreateGlobalVariableExpression(b.getDIFile(pos.Filename), llvm.DIGlobalVariableExpression{
 			Name:        "interrupt" + strconv.FormatInt(id.Int64(), 10),
 			LinkageName: globalName,
@@ -79,7 +79,7 @@ func (b *builder) createInterruptGlobal(instr *ssa.CallCommon) (llvm.Value, erro
 	// PLIC where each interrupt must be enabled using the interrupt number, and
 	// thus keeps the Interrupt object alive.
 	// This call is removed during interrupt lowering.
-	if strings.HasPrefix(b.Triple(), "avr") {
+	if strings.HasPrefix(b.Triple, "avr") {
 		useFn := b.mod.NamedFunction("runtime/interrupt.use")
 		if useFn.IsNil() {
 			useFnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{interrupt.Type()}, false)

compiler/llvm.go

@@ -44,7 +44,7 @@ func (b *builder) emitLifetimeEnd(ptr, size llvm.Value) {
 // bitcasts, or else allocates a value on the heap if it cannot be packed in the
 // pointer value directly. It returns the pointer with the packed data.
 func (b *builder) emitPointerPack(values []llvm.Value) llvm.Value {
-	return llvmutil.EmitPointerPack(b.Builder, b.mod, b.Config, values)
+	return llvmutil.EmitPointerPack(b.Builder, b.mod, b.NeedsStackObjects, values)
 }
 
 // emitPointerUnpack extracts a list of values packed using emitPointerPack.

compiler/llvmutil/wordpack.go

@@ -5,7 +5,6 @@ package llvmutil
 // itself if possible and legal.
 
 import (
-	"github.com/tinygo-org/tinygo/compileopts"
 	"tinygo.org/x/go-llvm"
 )
 
@@ -13,7 +12,7 @@ import (
 // bitcasts, or else allocates a value on the heap if it cannot be packed in the
 // pointer value directly. It returns the pointer with the packed data.
 // If the values are all constants, they are be stored in a constant global and deduplicated.
-func EmitPointerPack(builder llvm.Builder, mod llvm.Module, config *compileopts.Config, values []llvm.Value) llvm.Value {
+func EmitPointerPack(builder llvm.Builder, mod llvm.Module, needsStackObjects bool, values []llvm.Value) llvm.Value {
 	ctx := mod.Context()
 	targetData := llvm.NewTargetData(mod.DataLayout())
 	i8ptrType := llvm.PointerType(mod.Context().Int8Type(), 0)
@@ -26,7 +25,6 @@ func EmitPointerPack(builder llvm.Builder, mod llvm.Module, config *compileopts.
 	packedType := ctx.StructType(valueTypes, false)
 
 	// Allocate memory for the packed data.
-	var packedAlloc, packedHeapAlloc llvm.Value
 	size := targetData.TypeAllocSize(packedType)
 	if size == 0 {
 		return llvm.ConstPointerNull(i8ptrType)
@@ -39,9 +37,39 @@ func EmitPointerPack(builder llvm.Builder, mod llvm.Module, config *compileopts.
 			// Try to keep this cast in SSA form.
 			return builder.CreateIntToPtr(values[0], i8ptrType, "pack.int")
 		}
+
 		// Because packedType is a struct and we have to cast it to a *i8, store
-		// it in an alloca first for bitcasting (store+bitcast+load).
-		packedAlloc, _, _ = CreateTemporaryAlloca(builder, mod, packedType, "")
+		// it in a *i8 alloca first and load the *i8 value from there. This is
+		// effectively a bitcast.
+		packedAlloc, _, _ := CreateTemporaryAlloca(builder, mod, i8ptrType, "")
+
+		if size < targetData.TypeAllocSize(i8ptrType) {
+			// The alloca is bigger than the value that will be stored in it.
+			// To avoid having some bits undefined, zero the alloca first.
+			// Hopefully this will get optimized away.
+			builder.CreateStore(llvm.ConstNull(i8ptrType), packedAlloc)
+		}
+
+		// Store all values in the alloca.
+		packedAllocCast := builder.CreateBitCast(packedAlloc, llvm.PointerType(packedType, 0), "")
+		for i, value := range values {
+			indices := []llvm.Value{
+				llvm.ConstInt(ctx.Int32Type(), 0, false),
+				llvm.ConstInt(ctx.Int32Type(), uint64(i), false),
+			}
+			gep := builder.CreateInBoundsGEP(packedAllocCast, indices, "")
+			builder.CreateStore(value, gep)
+		}
+
+		// Load value (the *i8) from the alloca.
+		result := builder.CreateLoad(packedAlloc, "")
+
+		// End the lifetime of the alloca, to help the optimizer.
+		packedPtr := builder.CreateBitCast(packedAlloc, i8ptrType, "")
+		packedSize := llvm.ConstInt(ctx.Int64Type(), targetData.TypeAllocSize(packedAlloc.Type()), false)
+		EmitLifetimeEnd(builder, mod, packedPtr, packedSize)
+
+		return result
 	} else {
 		// Check if the values are all constants.
 		constant := true
@@ -67,12 +95,12 @@ func EmitPointerPack(builder llvm.Builder, mod llvm.Module, config *compileopts.
 		// Packed data is bigger than a pointer, so allocate it on the heap.
 		sizeValue := llvm.ConstInt(uintptrType, size, false)
 		alloc := mod.NamedFunction("runtime.alloc")
-		packedHeapAlloc = builder.CreateCall(alloc, []llvm.Value{
+		packedHeapAlloc := builder.CreateCall(alloc, []llvm.Value{
 			sizeValue,
 			llvm.Undef(i8ptrType),            // unused context parameter
 			llvm.ConstPointerNull(i8ptrType), // coroutine handle
 		}, "")
-		if config.NeedsStackObjects() {
+		if needsStackObjects {
 			trackPointer := mod.NamedFunction("runtime.trackPointer")
 			builder.CreateCall(trackPointer, []llvm.Value{
 				packedHeapAlloc,
@@ -80,28 +108,19 @@ func EmitPointerPack(builder llvm.Builder, mod llvm.Module, config *compileopts.
 				llvm.ConstPointerNull(i8ptrType), // coroutine handle
 			}, "")
 		}
-		packedAlloc = builder.CreateBitCast(packedHeapAlloc, llvm.PointerType(packedType, 0), "")
-	}
-	// Store all values in the alloca or heap pointer.
-	for i, value := range values {
-		indices := []llvm.Value{
-			llvm.ConstInt(ctx.Int32Type(), 0, false),
-			llvm.ConstInt(ctx.Int32Type(), uint64(i), false),
-		}
-		gep := builder.CreateInBoundsGEP(packedAlloc, indices, "")
-		builder.CreateStore(value, gep)
-	}
+		packedAlloc := builder.CreateBitCast(packedHeapAlloc, llvm.PointerType(packedType, 0), "")
 
-	if packedHeapAlloc.IsNil() {
-		// Load value (as *i8) from the alloca.
-		packedAlloc = builder.CreateBitCast(packedAlloc, llvm.PointerType(i8ptrType, 0), "")
-		result := builder.CreateLoad(packedAlloc, "")
-		packedPtr := builder.CreateBitCast(packedAlloc, i8ptrType, "")
-		packedSize := llvm.ConstInt(ctx.Int64Type(), targetData.TypeAllocSize(packedAlloc.Type()), false)
-		EmitLifetimeEnd(builder, mod, packedPtr, packedSize)
-		return result
-	} else {
-		// Get the original heap allocation pointer, which already is an *i8.
+		// Store all values in the heap pointer.
+		for i, value := range values {
+			indices := []llvm.Value{
+				llvm.ConstInt(ctx.Int32Type(), 0, false),
+				llvm.ConstInt(ctx.Int32Type(), uint64(i), false),
+			}
+			gep := builder.CreateInBoundsGEP(packedAlloc, indices, "")
+			builder.CreateStore(value, gep)
+		}
+
+		// Return the original heap allocation pointer, which already is an *i8.
 		return packedHeapAlloc
 	}
 }

compiler/passes.go

@@ -0,0 +1,164 @@
+package compiler
+
+// This file implements a simple reachability analysis, to reduce compile time.
+// This DCE pass used to be necessary for improving other passes but now it
+// isn't necessary anymore.
+
+import (
+	"errors"
+	"go/types"
+	"sort"
+
+	"github.com/tinygo-org/tinygo/loader"
+	"golang.org/x/tools/go/ssa"
+)
+
+type dceState struct {
+	*compilerContext
+	functions   []*dceFunction
+	functionMap map[*ssa.Function]*dceFunction
+}
+
+type dceFunction struct {
+	*ssa.Function
+	functionInfo
+	flag bool // used by dead code elimination
+}
+
+func (p *dceState) addFunction(ssaFn *ssa.Function) {
+	if _, ok := p.functionMap[ssaFn]; ok {
+		return
+	}
+	f := &dceFunction{Function: ssaFn}
+	f.functionInfo = p.getFunctionInfo(ssaFn)
+	p.functions = append(p.functions, f)
+	p.functionMap[ssaFn] = f
+
+	for _, anon := range ssaFn.AnonFuncs {
+		p.addFunction(anon)
+	}
+}
+
+// simpleDCE returns a list of alive functions in the program. Compiling only
+// these functions makes the compiler faster.
+//
+// This functionality will likely be replaced in the future with build caching.
+func (c *compilerContext) simpleDCE(lprogram *loader.Program) ([]*ssa.Function, error) {
+	mainPkg := c.program.Package(lprogram.MainPkg().Pkg)
+	if mainPkg == nil {
+		panic("could not find main package")
+	}
+	p := &dceState{
+		compilerContext: c,
+		functionMap:     make(map[*ssa.Function]*dceFunction),
+	}
+
+	for _, pkg := range lprogram.Sorted() {
+		pkg := c.program.Package(pkg.Pkg)
+		memberNames := make([]string, 0)
+		for name := range pkg.Members {
+			memberNames = append(memberNames, name)
+		}
+		sort.Strings(memberNames)
+
+		for _, name := range memberNames {
+			member := pkg.Members[name]
+			switch member := member.(type) {
+			case *ssa.Function:
+				p.addFunction(member)
+			case *ssa.Type:
+				methods := getAllMethods(pkg.Prog, member.Type())
+				if !types.IsInterface(member.Type()) {
+					// named type
+					for _, method := range methods {
+						p.addFunction(pkg.Prog.MethodValue(method))
+					}
+				}
+			case *ssa.Global:
+				// Ignore. Globals are not handled here.
+			case *ssa.NamedConst:
+				// Ignore: these are already resolved.
+			default:
+				panic("unknown member type: " + member.String())
+			}
+		}
+	}
+
+	// Initial set of live functions. Include main.main, *.init and runtime.*
+	// functions.
+	main, ok := mainPkg.Members["main"].(*ssa.Function)
+	if !ok {
+		if mainPkg.Members["main"] == nil {
+			return nil, errors.New("function main is undeclared in the main package")
+		} else {
+			return nil, errors.New("cannot declare main - must be func")
+		}
+	}
+	runtimePkg := c.program.ImportedPackage("runtime")
+	mathPkg := c.program.ImportedPackage("math")
+	taskPkg := c.program.ImportedPackage("internal/task")
+	p.functionMap[main].flag = true
+	worklist := []*ssa.Function{main}
+	for _, f := range p.functions {
+		if f.exported || f.Synthetic == "package initializer" || f.Pkg == runtimePkg || f.Pkg == taskPkg || (f.Pkg == mathPkg && f.Pkg != nil) {
+			if f.flag {
+				continue
+			}
+			f.flag = true
+			worklist = append(worklist, f.Function)
+		}
+	}
+
+	// Mark all called functions recursively.
+	for len(worklist) != 0 {
+		f := worklist[len(worklist)-1]
+		worklist = worklist[:len(worklist)-1]
+		for _, block := range f.Blocks {
+			for _, instr := range block.Instrs {
+				if instr, ok := instr.(*ssa.MakeInterface); ok {
+					for _, sel := range getAllMethods(c.program, instr.X.Type()) {
+						fn := c.program.MethodValue(sel)
+						callee := p.functionMap[fn]
+						if callee == nil {
+							// TODO: why is this necessary?
+							p.addFunction(fn)
+							callee = p.functionMap[fn]
+						}
+						if !callee.flag {
+							callee.flag = true
+							worklist = append(worklist, callee.Function)
+						}
+					}
+				}
+				for _, operand := range instr.Operands(nil) {
+					if operand == nil || *operand == nil {
+						continue
+					}
+					switch operand := (*operand).(type) {
+					case *ssa.Function:
+						f := p.functionMap[operand]
+						if f == nil {
+							// FIXME HACK: this function should have been
+							// discovered already. It is not for bound methods.
+							p.addFunction(operand)
+							f = p.functionMap[operand]
+						}
+						if !f.flag {
+							f.flag = true
+							worklist = append(worklist, operand)
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// Return all live functions.
+	liveFunctions := []*ssa.Function{}
+	for _, f := range p.functions {
+		if f.flag {
+			liveFunctions = append(liveFunctions, f.Function)
+		}
+	}
+	return liveFunctions, nil
+}

compiler/symbol.go

@@ -15,6 +15,269 @@ import (
 	"tinygo.org/x/go-llvm"
 )
 
+// functionInfo contains some information about a function or method. In
+// particular, it contains information obtained from pragmas.
+//
+// The linkName value contains a valid link name, even if //go:linkname is not
+// present.
+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
+	exported   bool       // go:export, CGo
+	nobounds   bool       // go:nobounds
+	variadic   bool       // go:variadic (CGo only)
+	inline     inlineType // go:inline
+}
+
+type inlineType int
+
+// How much to inline.
+const (
+	// Default behavior. The compiler decides for itself whether any given
+	// function will be inlined. Whether any function is inlined depends on the
+	// optimization level.
+	inlineDefault inlineType = iota
+
+	// Inline hint, just like the C inline keyword (signalled using
+	// //go:inline). The compiler will be more likely to inline this function,
+	// but it is not a guarantee.
+	inlineHint
+
+	// Don't inline, just like the GCC noinline attribute. Signalled using
+	// //go:noinline.
+	inlineNone
+)
+
+// getFunction returns the LLVM function for the given *ssa.Function, creating
+// it if needed. It can later be filled with compilerContext.createFunction().
+func (c *compilerContext) getFunction(fn *ssa.Function) llvm.Value {
+	info := c.getFunctionInfo(fn)
+	llvmFn := c.mod.NamedFunction(info.linkName)
+	if !llvmFn.IsNil() {
+		return llvmFn
+	}
+
+	var retType llvm.Type
+	if fn.Signature.Results() == nil {
+		retType = c.ctx.VoidType()
+	} else if fn.Signature.Results().Len() == 1 {
+		retType = c.getLLVMType(fn.Signature.Results().At(0).Type())
+	} else {
+		results := make([]llvm.Type, 0, fn.Signature.Results().Len())
+		for i := 0; i < fn.Signature.Results().Len(); i++ {
+			results = append(results, c.getLLVMType(fn.Signature.Results().At(i).Type()))
+		}
+		retType = c.ctx.StructType(results, false)
+	}
+
+	var paramInfos []paramInfo
+	for _, param := range fn.Params {
+		paramType := c.getLLVMType(param.Type())
+		paramFragmentInfos := expandFormalParamType(paramType, param.Name(), param.Type())
+		paramInfos = append(paramInfos, paramFragmentInfos...)
+	}
+
+	// Add an extra parameter as the function context. This context is used in
+	// closures and bound methods, but should be optimized away when not used.
+	if !info.exported {
+		paramInfos = append(paramInfos, paramInfo{llvmType: c.i8ptrType, name: "context", flags: 0})
+		paramInfos = append(paramInfos, paramInfo{llvmType: c.i8ptrType, name: "parentHandle", flags: 0})
+	}
+
+	var paramTypes []llvm.Type
+	for _, info := range paramInfos {
+		paramTypes = append(paramTypes, info.llvmType)
+	}
+
+	fnType := llvm.FunctionType(retType, paramTypes, info.variadic)
+	llvmFn = llvm.AddFunction(c.mod, info.linkName, fnType)
+	if strings.HasPrefix(c.Triple, "wasm") {
+		// C functions without prototypes like this:
+		//   void foo();
+		// are actually variadic functions. However, it appears that it has been
+		// decided in WebAssembly that such prototype-less functions are not
+		// allowed in WebAssembly.
+		// In C, this can only happen when there are zero parameters, hence this
+		// check here. For more information:
+		// https://reviews.llvm.org/D48443
+		// https://github.com/WebAssembly/tool-conventions/issues/16
+		if info.variadic && len(fn.Params) == 0 {
+			attr := c.ctx.CreateStringAttribute("no-prototype", "")
+			llvmFn.AddFunctionAttr(attr)
+		}
+	}
+
+	dereferenceableOrNullKind := llvm.AttributeKindID("dereferenceable_or_null")
+	for i, info := range paramInfos {
+		if info.flags&paramIsDeferenceableOrNull == 0 {
+			continue
+		}
+		if info.llvmType.TypeKind() == llvm.PointerTypeKind {
+			el := info.llvmType.ElementType()
+			size := c.targetData.TypeAllocSize(el)
+			if size == 0 {
+				// dereferenceable_or_null(0) appears to be illegal in LLVM.
+				continue
+			}
+			dereferenceableOrNull := c.ctx.CreateEnumAttribute(dereferenceableOrNullKind, size)
+			llvmFn.AddAttributeAtIndex(i+1, dereferenceableOrNull)
+		}
+	}
+
+	// Set a number of function or parameter attributes, depending on the
+	// function. These functions are runtime functions that are known to have
+	// certain attributes that might not be inferred by the compiler.
+	switch info.linkName {
+	case "abort":
+		// On *nix systems, the "abort" functuion in libc is used to handle fatal panics.
+		// Mark it as noreturn so LLVM can optimize away code.
+		llvmFn.AddFunctionAttr(c.ctx.CreateEnumAttribute(llvm.AttributeKindID("noreturn"), 0))
+	case "runtime.alloc":
+		// Tell the optimizer that runtime.alloc is an allocator, meaning that it
+		// returns values that are never null and never alias to an existing value.
+		for _, attrName := range []string{"noalias", "nonnull"} {
+			llvmFn.AddAttributeAtIndex(0, c.ctx.CreateEnumAttribute(llvm.AttributeKindID(attrName), 0))
+		}
+	case "runtime.trackPointer":
+		// This function is necessary for tracking pointers on the stack in a
+		// portable way (see gc_stack_portable.go). Indicate to the optimizer
+		// that the only thing we'll do is read the pointer.
+		llvmFn.AddAttributeAtIndex(1, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
+		llvmFn.AddAttributeAtIndex(1, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("readonly"), 0))
+	}
+
+	// External/exported functions may not retain pointer values.
+	// https://golang.org/cmd/cgo/#hdr-Passing_pointers
+	if info.exported {
+		// Set the wasm-import-module attribute if the function's module is set.
+		if info.module != "" {
+
+			// We need to add the wasm-import-module and the wasm-import-name
+			wasmImportModuleAttr := c.ctx.CreateStringAttribute("wasm-import-module", info.module)
+			llvmFn.AddFunctionAttr(wasmImportModuleAttr)
+
+			// Add the Wasm Import Name, if we are a named wasm import
+			if info.importName != "" {
+				wasmImportNameAttr := c.ctx.CreateStringAttribute("wasm-import-name", info.importName)
+				llvmFn.AddFunctionAttr(wasmImportNameAttr)
+			}
+		}
+		nocaptureKind := llvm.AttributeKindID("nocapture")
+		nocapture := c.ctx.CreateEnumAttribute(nocaptureKind, 0)
+		for i, typ := range paramTypes {
+			if typ.TypeKind() == llvm.PointerTypeKind {
+				llvmFn.AddAttributeAtIndex(i+1, nocapture)
+			}
+		}
+	}
+
+	return llvmFn
+}
+
+// getFunctionInfo returns information about a function that is not directly
+// present in *ssa.Function, such as the link name and whether it should be
+// exported.
+func (c *compilerContext) getFunctionInfo(f *ssa.Function) functionInfo {
+	info := functionInfo{}
+	if strings.HasPrefix(f.Name(), "C.") {
+		// Created by CGo: such a name cannot be created by regular C code.
+		info.linkName = f.Name()[2:]
+		info.exported = true
+	} else {
+		// Pick the default linkName.
+		info.linkName = f.RelString(nil)
+	}
+	// Check for //go: pragmas, which may change the link name (among others).
+	info.parsePragmas(f)
+	return info
+}
+
+// parsePragmas is used by getFunctionInfo to parse function pragmas such as
+// //export or //go:noinline.
+func (info *functionInfo) parsePragmas(f *ssa.Function) {
+	if f.Syntax() == nil {
+		return
+	}
+	if decl, ok := f.Syntax().(*ast.FuncDecl); ok && decl.Doc != nil {
+
+		// Our importName for a wasm module (if we are compiling to wasm), or llvm link name
+		var importName string
+
+		for _, comment := range decl.Doc.List {
+			text := comment.Text
+			if strings.HasPrefix(text, "//export ") {
+				// Rewrite '//export' to '//go:export' for compatibility with
+				// gc.
+				text = "//go:" + text[2:]
+			}
+			if !strings.HasPrefix(text, "//go:") {
+				continue
+			}
+			parts := strings.Fields(text)
+			switch parts[0] {
+			case "//go:export":
+				if len(parts) != 2 {
+					continue
+				}
+
+				importName = parts[1]
+				info.exported = true
+			case "//go:wasm-module":
+				// Alternative comment for setting the import module.
+				if len(parts) != 2 {
+					continue
+				}
+				info.module = parts[1]
+			case "//go:inline":
+				info.inline = inlineHint
+			case "//go:noinline":
+				info.inline = inlineNone
+			case "//go:linkname":
+				if len(parts) != 3 || parts[1] != f.Name() {
+					continue
+				}
+				// Only enable go:linkname when the package imports "unsafe".
+				// This is a slightly looser requirement than what gc uses: gc
+				// requires the file to import "unsafe", not the package as a
+				// whole.
+				if hasUnsafeImport(f.Pkg.Pkg) {
+					info.linkName = parts[2]
+				}
+			case "//go:nobounds":
+				// Skip bounds checking in this function. Useful for some
+				// runtime functions.
+				// This is somewhat dangerous and thus only imported in packages
+				// that import unsafe.
+				if hasUnsafeImport(f.Pkg.Pkg) {
+					info.nobounds = true
+				}
+			case "//go:variadic":
+				// The //go:variadic pragma is emitted by the CGo preprocessing
+				// pass for C variadic functions. This includes both explicit
+				// (with ...) and implicit (no parameters in signature)
+				// functions.
+				if strings.HasPrefix(f.Name(), "C.") {
+					// This prefix cannot naturally be created, it must have
+					// been created as a result of CGo preprocessing.
+					info.variadic = true
+				}
+			}
+		}
+
+		// Set the importName for our exported function if we have one
+		if importName != "" {
+			if info.module == "" {
+				info.linkName = importName
+			} else {
+				// WebAssembly import
+				info.importName = importName
+			}
+		}
+
+	}
+}
+
 // globalInfo contains some information about a specific global. By default,
 // linkName is equal to .RelString(nil) on a global and extern is false, but for
 // some symbols this is different (due to //go:extern for example).
@@ -82,11 +345,11 @@ func (c *compilerContext) getGlobal(g *ssa.Global) llvm.Value {
 			}
 		}
 
-		if c.Debug() && !info.extern {
+		if c.Debug && !info.extern {
 			// Add debug info.
 			// TODO: this should be done for every global in the program, not just
 			// the ones that are referenced from some code.
-			pos := c.ir.Program.Fset.Position(g.Pos())
+			pos := c.program.Fset.Position(g.Pos())
 			diglobal := c.dibuilder.CreateGlobalVariableExpression(c.difiles[pos.Filename], llvm.DIGlobalVariableExpression{
 				Name:        g.RelString(nil),
 				LinkageName: info.linkName,
@@ -145,3 +408,23 @@ func (info *globalInfo) parsePragmas(doc *ast.CommentGroup) {
 		}
 	}
 }
+
+// Get all methods of a type.
+func getAllMethods(prog *ssa.Program, typ types.Type) []*types.Selection {
+	ms := prog.MethodSets.MethodSet(typ)
+	methods := make([]*types.Selection, ms.Len())
+	for i := 0; i < ms.Len(); i++ {
+		methods[i] = ms.At(i)
+	}
+	return methods
+}
+
+// Return true if this package imports "unsafe", false otherwise.
+func hasUnsafeImport(pkg *types.Package) bool {
+	for _, imp := range pkg.Imports() {
+		if imp == types.Unsafe {
+			return true
+		}
+	}
+	return false
+}

compiler/syscall.go

@@ -16,8 +16,8 @@ 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" {
+	case b.GOARCH == "amd64":
+		if b.GOOS == "darwin" {
 			// Darwin adds this magic number to system call numbers:
 			//
 			// > Syscall classes for 64-bit system call entry.
@@ -58,7 +58,7 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
 		target := llvm.InlineAsm(fnType, "syscall", constraints, true, false, llvm.InlineAsmDialectIntel)
 		syscallResult = b.CreateCall(target, args, "")
-	case b.GOARCH() == "386" && b.GOOS() == "linux":
+	case b.GOARCH == "386" && b.GOOS == "linux":
 		// Sources:
 		//   syscall(2) man page
 		//   https://stackoverflow.com/a/2538212
@@ -84,7 +84,7 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
 		target := llvm.InlineAsm(fnType, "int 0x80", constraints, true, false, llvm.InlineAsmDialectIntel)
 		syscallResult = b.CreateCall(target, args, "")
-	case b.GOARCH() == "arm" && b.GOOS() == "linux":
+	case b.GOARCH == "arm" && b.GOOS == "linux":
 		// Implement the EABI system call convention for Linux.
 		// Source: syscall(2) man page.
 		args := []llvm.Value{}
@@ -116,7 +116,7 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
 		target := llvm.InlineAsm(fnType, "svc #0", constraints, true, false, 0)
 		syscallResult = b.CreateCall(target, args, "")
-	case b.GOARCH() == "arm64" && b.GOOS() == "linux":
+	case b.GOARCH == "arm64" && b.GOOS == "linux":
 		// Source: syscall(2) man page.
 		args := []llvm.Value{}
 		argTypes := []llvm.Type{}
@@ -149,9 +149,9 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		target := llvm.InlineAsm(fnType, "svc #0", constraints, true, false, 0)
 		syscallResult = b.CreateCall(target, args, "")
 	default:
-		return llvm.Value{}, b.makeError(call.Pos(), "unknown GOOS/GOARCH for syscall: "+b.GOOS()+"/"+b.GOARCH())
+		return llvm.Value{}, b.makeError(call.Pos(), "unknown GOOS/GOARCH for syscall: "+b.GOOS+"/"+b.GOARCH)
 	}
-	switch b.GOOS() {
+	switch b.GOOS {
 	case "linux", "freebsd":
 		// Return values: r0, r1 uintptr, err Errno
 		// Pseudocode:
@@ -187,6 +187,6 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		retval = b.CreateInsertValue(retval, errResult, 2, "")
 		return retval, nil
 	default:
-		return llvm.Value{}, b.makeError(call.Pos(), "unknown GOOS/GOARCH for syscall: "+b.GOOS()+"/"+b.GOARCH())
+		return llvm.Value{}, b.makeError(call.Pos(), "unknown GOOS/GOARCH for syscall: "+b.GOOS+"/"+b.GOARCH)
 	}
 }

compiler/testdata/basic.go

@@ -0,0 +1,57 @@
+package main
+
+// Basic tests that don't need to be split into a separate file.
+
+func addInt(x, y int) int {
+	return x + y
+}
+
+func equalInt(x, y int) bool {
+	return x == y
+}
+
+func floatEQ(x, y float32) bool {
+	return x == y
+}
+
+func floatNE(x, y float32) bool {
+	return x != y
+}
+
+func floatLower(x, y float32) bool {
+	return x < y
+}
+
+func floatLowerEqual(x, y float32) bool {
+	return x <= y
+}
+
+func floatGreater(x, y float32) bool {
+	return x > y
+}
+
+func floatGreaterEqual(x, y float32) bool {
+	return x >= y
+}
+
+func complexReal(x complex64) float32 {
+	return real(x)
+}
+
+func complexImag(x complex64) float32 {
+	return imag(x)
+}
+
+func complexAdd(x, y complex64) complex64 {
+	return x + y
+}
+
+func complexSub(x, y complex64) complex64 {
+	return x - y
+}
+
+func complexMul(x, y complex64) complex64 {
+	return x * y
+}
+
+// TODO: complexDiv (requires runtime call)

compiler/testdata/basic.ll

@@ -0,0 +1,98 @@
+; ModuleID = 'basic.go'
+source_filename = "basic.go"
+target datalayout = "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-f80:32-n8:16:32-S128"
+target triple = "i686--linux"
+
+define internal void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  ret void
+}
+
+define internal i32 @main.addInt(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  %0 = add i32 %x, %y
+  ret i32 %0
+}
+
+define internal i1 @main.equalInt(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  %0 = icmp eq i32 %x, %y
+  ret i1 %0
+}
+
+define internal i1 @main.floatEQ(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  %0 = fcmp oeq float %x, %y
+  ret i1 %0
+}
+
+define internal i1 @main.floatNE(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  %0 = fcmp une float %x, %y
+  ret i1 %0
+}
+
+define internal i1 @main.floatLower(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  %0 = fcmp olt float %x, %y
+  ret i1 %0
+}
+
+define internal i1 @main.floatLowerEqual(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  %0 = fcmp ole float %x, %y
+  ret i1 %0
+}
+
+define internal i1 @main.floatGreater(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  %0 = fcmp ogt float %x, %y
+  ret i1 %0
+}
+
+define internal i1 @main.floatGreaterEqual(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  %0 = fcmp oge float %x, %y
+  ret i1 %0
+}
+
+define internal float @main.complexReal(float %x.r, float %x.i, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  ret float %x.r
+}
+
+define internal float @main.complexImag(float %x.r, float %x.i, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  ret float %x.i
+}
+
+define internal { float, float } @main.complexAdd(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  %0 = fadd float %x.r, %y.r
+  %1 = fadd float %x.i, %y.i
+  %2 = insertvalue { float, float } undef, float %0, 0
+  %3 = insertvalue { float, float } %2, float %1, 1
+  ret { float, float } %3
+}
+
+define internal { float, float } @main.complexSub(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  %0 = fsub float %x.r, %y.r
+  %1 = fsub float %x.i, %y.i
+  %2 = insertvalue { float, float } undef, float %0, 0
+  %3 = insertvalue { float, float } %2, float %1, 1
+  ret { float, float } %3
+}
+
+define internal { float, float } @main.complexMul(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  %0 = fmul float %x.r, %y.r
+  %1 = fmul float %x.i, %y.i
+  %2 = fsub float %0, %1
+  %3 = fmul float %x.r, %y.i
+  %4 = fmul float %x.i, %y.r
+  %5 = fadd float %3, %4
+  %6 = insertvalue { float, float } undef, float %2, 0
+  %7 = insertvalue { float, float } %6, float %5, 1
+  ret { float, float } %7
+}

compiler/testdata/float.go

@@ -0,0 +1,39 @@
+package main
+
+// Test converting floats to ints.
+
+func f32tou32(v float32) uint32 {
+	return uint32(v)
+}
+
+func maxu32f() float32 {
+	return float32(^uint32(0))
+}
+
+func maxu32tof32() uint32 {
+	f := float32(^uint32(0))
+	return uint32(f)
+}
+
+func inftoi32() (uint32, uint32, int32, int32) {
+	inf := 1.0
+	inf /= 0.0
+
+	return uint32(inf), uint32(-inf), int32(inf), int32(-inf)
+}
+
+func u32tof32tou32(v uint32) uint32 {
+	return uint32(float32(v))
+}
+
+func f32tou32tof32(v float32) float32 {
+	return float32(uint32(v))
+}
+
+func f32tou8(v float32) uint8 {
+	return uint8(v)
+}
+
+func f32toi8(v float32) int8 {
+	return int8(v)
+}

compiler/testdata/float.ll

@@ -0,0 +1,80 @@
+; ModuleID = 'float.go'
+source_filename = "float.go"
+target datalayout = "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-f80:32-n8:16:32-S128"
+target triple = "i686--linux"
+
+define internal void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  ret void
+}
+
+define internal i32 @main.f32tou32(float %v, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  %positive = fcmp oge float %v, 0.000000e+00
+  %withinmax = fcmp ole float %v, 0x41EFFFFFC0000000
+  %inbounds = and i1 %positive, %withinmax
+  %saturated = sext i1 %positive to i32
+  %normal = fptoui float %v to i32
+  %0 = select i1 %inbounds, i32 %normal, i32 %saturated
+  ret i32 %0
+}
+
+define internal float @main.maxu32f(i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  ret float 0x41F0000000000000
+}
+
+define internal i32 @main.maxu32tof32(i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  ret i32 -1
+}
+
+define internal { i32, i32, i32, i32 } @main.inftoi32(i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  ret { i32, i32, i32, i32 } { i32 -1, i32 0, i32 2147483647, i32 -2147483648 }
+}
+
+define internal i32 @main.u32tof32tou32(i32 %v, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  %0 = uitofp i32 %v to float
+  %withinmax = fcmp ole float %0, 0x41EFFFFFC0000000
+  %normal = fptoui float %0 to i32
+  %1 = select i1 %withinmax, i32 %normal, i32 -1
+  ret i32 %1
+}
+
+define internal float @main.f32tou32tof32(float %v, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  %positive = fcmp oge float %v, 0.000000e+00
+  %withinmax = fcmp ole float %v, 0x41EFFFFFC0000000
+  %inbounds = and i1 %positive, %withinmax
+  %saturated = sext i1 %positive to i32
+  %normal = fptoui float %v to i32
+  %0 = select i1 %inbounds, i32 %normal, i32 %saturated
+  %1 = uitofp i32 %0 to float
+  ret float %1
+}
+
+define internal i8 @main.f32tou8(float %v, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  %positive = fcmp oge float %v, 0.000000e+00
+  %withinmax = fcmp ole float %v, 2.550000e+02
+  %inbounds = and i1 %positive, %withinmax
+  %saturated = sext i1 %positive to i8
+  %normal = fptoui float %v to i8
+  %0 = select i1 %inbounds, i8 %normal, i8 %saturated
+  ret i8 %0
+}
+
+define internal i8 @main.f32toi8(float %v, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  %abovemin = fcmp oge float %v, -1.280000e+02
+  %belowmax = fcmp ole float %v, 1.270000e+02
+  %inbounds = and i1 %abovemin, %belowmax
+  %saturated = select i1 %abovemin, i8 127, i8 -128
+  %isnan = fcmp uno float %v, 0.000000e+00
+  %remapped = select i1 %isnan, i8 0, i8 %saturated
+  %normal = fptosi float %v to i8
+  %0 = select i1 %inbounds, i8 %normal, i8 %remapped
+  ret i8 %0
+}

compiler/testdata/pointer.go

@@ -0,0 +1,41 @@
+package main
+
+// This file tests various operations on pointers, such as pointer arithmetic
+// and dereferencing pointers.
+
+import "unsafe"
+
+// Dereference pointers.
+
+func pointerDerefZero(x *[0]int) [0]int {
+	return *x // This is a no-op, there is nothing to load.
+}
+
+// Unsafe pointer casts, they are sometimes a no-op.
+
+func pointerCastFromUnsafe(x unsafe.Pointer) *int {
+	return (*int)(x)
+}
+
+func pointerCastToUnsafe(x *int) unsafe.Pointer {
+	return unsafe.Pointer(x)
+}
+
+func pointerCastToUnsafeNoop(x *byte) unsafe.Pointer {
+	return unsafe.Pointer(x)
+}
+
+// The compiler has support for a few special cast+add patterns that are
+// transformed into a single GEP.
+
+func pointerUnsafeGEPFixedOffset(ptr *byte) *byte {
+	return (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ptr)) + 10))
+}
+
+func pointerUnsafeGEPByteOffset(ptr *byte, offset uintptr) *byte {
+	return (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ptr)) + offset))
+}
+
+func pointerUnsafeGEPIntOffset(ptr *int32, offset uintptr) *int32 {
+	return (*int32)(unsafe.Pointer(uintptr(unsafe.Pointer(ptr)) + offset*4))
+}

compiler/testdata/pointer.ll

@@ -0,0 +1,49 @@
+; ModuleID = 'pointer.go'
+source_filename = "pointer.go"
+target datalayout = "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-f80:32-n8:16:32-S128"
+target triple = "i686--linux"
+
+define internal void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  ret void
+}
+
+define internal [0 x i32] @main.pointerDerefZero([0 x i32]* %x, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  ret [0 x i32] zeroinitializer
+}
+
+define internal i32* @main.pointerCastFromUnsafe(i8* %x, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  %0 = bitcast i8* %x to i32*
+  ret i32* %0
+}
+
+define internal i8* @main.pointerCastToUnsafe(i32* dereferenceable_or_null(4) %x, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  %0 = bitcast i32* %x to i8*
+  ret i8* %0
+}
+
+define internal i8* @main.pointerCastToUnsafeNoop(i8* dereferenceable_or_null(1) %x, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  ret i8* %x
+}
+
+define internal i8* @main.pointerUnsafeGEPFixedOffset(i8* dereferenceable_or_null(1) %ptr, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  %0 = getelementptr inbounds i8, i8* %ptr, i32 10
+  ret i8* %0
+}
+
+define internal i8* @main.pointerUnsafeGEPByteOffset(i8* dereferenceable_or_null(1) %ptr, i32 %offset, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  %0 = getelementptr inbounds i8, i8* %ptr, i32 %offset
+  ret i8* %0
+}
+
+define internal i32* @main.pointerUnsafeGEPIntOffset(i32* dereferenceable_or_null(4) %ptr, i32 %offset, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  %0 = getelementptr i32, i32* %ptr, i32 %offset
+  ret i32* %0
+}

compiler/testdata/slice.go

@@ -0,0 +1,9 @@
+package main
+
+func sliceLen(ints []int) int {
+	return len(ints)
+}
+
+func sliceCap(ints []int) int {
+	return cap(ints)
+}

compiler/testdata/slice.ll

@@ -0,0 +1,19 @@
+; ModuleID = 'slice.go'
+source_filename = "slice.go"
+target datalayout = "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-f80:32-n8:16:32-S128"
+target triple = "i686--linux"
+
+define internal void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  ret void
+}
+
+define internal i32 @main.sliceLen(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  ret i32 %ints.len
+}
+
+define internal i32 @main.sliceCap(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  ret i32 %ints.cap
+}

go.mod

@@ -1,14 +1,16 @@
 module github.com/tinygo-org/tinygo
 
-go 1.11
+go 1.13
 
 require (
 	github.com/blakesmith/ar v0.0.0-20150311145944-8bd4349a67f2
-	github.com/chromedp/cdproto v0.0.0-20200116234248-4da64dd111ac
-	github.com/chromedp/chromedp v0.5.3
+	github.com/chromedp/cdproto v0.0.0-20210113043257-dabd2f2e7693
+	github.com/chromedp/chromedp v0.6.4
 	github.com/google/shlex v0.0.0-20181106134648-c34317bd91bf
 	github.com/marcinbor85/gohex v0.0.0-20200531091804-343a4b548892
-	go.bug.st/serial v1.0.0
+	github.com/mattn/go-colorable v0.1.8
+	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
-	tinygo.org/x/go-llvm v0.0.0-20200503225853-345b2947b59d
+	tinygo.org/x/go-llvm v0.0.0-20210206225315-7fe719483a0f
 )

go.sum

@@ -1,31 +1,39 @@
 github.com/blakesmith/ar v0.0.0-20150311145944-8bd4349a67f2 h1:oMCHnXa6CCCafdPDbMh/lWRhRByN0VFLvv+g+ayx1SI=
 github.com/blakesmith/ar v0.0.0-20150311145944-8bd4349a67f2/go.mod h1:PkYb9DJNAwrSvRx5DYA+gUcOIgTGVMNkfSCbZM8cWpI=
-github.com/chromedp/cdproto v0.0.0-20200116234248-4da64dd111ac h1:T7V5BXqnYd55Hj/g5uhDYumg9Fp3rMTS6bykYtTIFX4=
-github.com/chromedp/cdproto v0.0.0-20200116234248-4da64dd111ac/go.mod h1:PfAWWKJqjlGFYJEidUM6aVIWPr0EpobeyVWEEmplX7g=
-github.com/chromedp/chromedp v0.5.3 h1:F9LafxmYpsQhWQBdCs+6Sret1zzeeFyHS5LkRF//Ffg=
-github.com/chromedp/chromedp v0.5.3/go.mod h1:YLdPtndaHQ4rCpSpBG+IPpy9JvX0VD+7aaLxYgYj28w=
+github.com/chromedp/cdproto v0.0.0-20210113043257-dabd2f2e7693 h1:11eq/RkpaotwdF6b1TRMcdgQUPNmyFEJOB7zLvh0O/Y=
+github.com/chromedp/cdproto v0.0.0-20210113043257-dabd2f2e7693/go.mod h1:55pim6Ht4LJKdVLlyFJV/g++HsEA1hQxPbB5JyNdZC0=
+github.com/chromedp/chromedp v0.6.4 h1:Gx7ZkRyrSVmbbDDja/ieNgNGJIvElroPOyeqYQGVDSY=
+github.com/chromedp/chromedp v0.6.4/go.mod h1:vodUdJf5dF/b8n0UBJv6NeM/QK28RjP3j+eM7fq4+84=
+github.com/chromedp/sysutil v1.0.0 h1:+ZxhTpfpZlmchB58ih/LBHX52ky7w2VhQVKQMucy3Ic=
+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/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee h1:s+21KNqlpePfkah2I+gwHF8xmJWRjooY+5248k6m4A0=
-github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo=
-github.com/gobwas/pool v0.2.0 h1:QEmUOlnSjWtnpRGHF3SauEiOsy82Cup83Vf2LcMlnc8=
-github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
-github.com/gobwas/ws v1.0.2 h1:CoAavW/wd/kulfZmSIBt6p24n4j7tHgNVCjsfHVNUbo=
-github.com/gobwas/ws v1.0.2/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM=
+github.com/gobwas/httphead v0.1.0 h1:exrUm0f4YX0L7EBwZHuCF4GDp8aJfVeBrlLQrs6NqWU=
+github.com/gobwas/httphead v0.1.0/go.mod h1:O/RXo79gxV8G+RqlR/otEwx4Q36zl9rqC5u12GKvMCM=
+github.com/gobwas/pool v0.2.1 h1:xfeeEhW7pwmX8nuLVlqbzVc7udMDrwetjEv+TZIz1og=
+github.com/gobwas/pool v0.2.1/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
+github.com/gobwas/ws v1.0.4 h1:5eXU1CZhpQdq5kXbKb+sECH5Ia5KiO6CYzIzdlVx6Bs=
+github.com/gobwas/ws v1.0.4/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM=
 github.com/google/shlex v0.0.0-20181106134648-c34317bd91bf h1:7+FW5aGwISbqUtkfmIpZJGRgNFg2ioYPvFaUxdqpDsg=
 github.com/google/shlex v0.0.0-20181106134648-c34317bd91bf/go.mod h1:RpwtwJQFrIEPstU94h88MWPXP2ektJZ8cZ0YntAmXiE=
-github.com/knq/sysutil v0.0.0-20191005231841-15668db23d08 h1:V0an7KRw92wmJysvFvtqtKMAPmvS5O0jtB0nYo6t+gs=
-github.com/knq/sysutil v0.0.0-20191005231841-15668db23d08/go.mod h1:dFWs1zEqDjFtnBXsd1vPOZaLsESovai349994nHx3e0=
-github.com/mailru/easyjson v0.7.0 h1:aizVhC/NAAcKWb+5QsU1iNOZb4Yws5UO2I+aIprQITM=
-github.com/mailru/easyjson v0.7.0/go.mod h1:KAzv3t3aY1NaHWoQz1+4F1ccyAH66Jk7yos7ldAVICs=
+github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
+github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
+github.com/mailru/easyjson v0.7.6 h1:8yTIVnZgCoiM1TgqoeTl+LfU5Jg6/xL3QhGQnimLYnA=
+github.com/mailru/easyjson v0.7.6/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
 github.com/marcinbor85/gohex v0.0.0-20200531091804-343a4b548892 h1:6J+qramlHVLmiBOgRiBOnQkno8uprqG6YFFQTt6uYIw=
 github.com/marcinbor85/gohex v0.0.0-20200531091804-343a4b548892/go.mod h1:Pb6XcsXyropB9LNHhnqaknG/vEwYztLkQzVCHv8sQ3M=
+github.com/mattn/go-colorable v0.1.8 h1:c1ghPdyEDarC70ftn0y+A/Ee++9zz8ljHG1b13eJ0s8=
+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/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 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=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee h1:WG0RUwxtNT4qqaXX3DPA8zHFNm/D9xaBpxzHt1WcA/E=
@@ -37,8 +45,11 @@ golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5h
 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 h1:vEOn+mP2zCOVzKckCZy6YsCtDblrpj/w7B9nxGNELpg=
 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=
+golang.org/x/sys v0.0.0-20210113181707-4bcb84eeeb78 h1:nVuTkr9L6Bq62qpUqKo/RnZCFfzDBL0bYo6w9OJUqZY=
+golang.org/x/sys v0.0.0-20210113181707-4bcb84eeeb78/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/tools v0.0.0-20200216192241-b320d3a0f5a2 h1:0sfSpGSa544Fwnbot3Oxq/U6SXqjty6Jy/3wRhVS7ig=
 golang.org/x/tools v0.0.0-20200216192241-b320d3a0f5a2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
@@ -46,5 +57,5 @@ golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898 h1:/atklqdjdhuosWIl6AIbO
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-tinygo.org/x/go-llvm v0.0.0-20200503225853-345b2947b59d h1:hcX7vpB067GWM/EH4sGGOti0PMgIx+0bbZwUXctOIvE=
-tinygo.org/x/go-llvm v0.0.0-20200503225853-345b2947b59d/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
+tinygo.org/x/go-llvm v0.0.0-20210206225315-7fe719483a0f h1:FP5Do5omlQ/dLQ3Hfy7oyJo69VS5Hn46rZw004r0lGU=
+tinygo.org/x/go-llvm v0.0.0-20210206225315-7fe719483a0f/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=

goenv/goenv.go

@@ -142,10 +142,11 @@ func getHomeDir() string {
 // getGoroot returns an appropriate GOROOT from various sources. If it can't be
 // found, it returns an empty string.
 func getGoroot() string {
+	// An explicitly set GOROOT always has preference.
 	goroot := os.Getenv("GOROOT")
 	if goroot != "" {
-		// An explicitly set GOROOT always has preference.
-		return goroot
+		// Convert to the standard GOROOT being referenced, if it's a TinyGo cache.
+		return getStandardGoroot(goroot)
 	}
 
 	// Check for the location of the 'go' binary and base GOROOT on that.
@@ -195,3 +196,21 @@ func isGoroot(goroot string) bool {
 	_, err := os.Stat(filepath.Join(goroot, "src", "runtime", "internal", "sys", "zversion.go"))
 	return err == nil
 }
+
+// getStandardGoroot returns the physical path to a real, standard Go GOROOT
+// implied by the given path.
+// If the given path appears to be a TinyGo cached GOROOT, it returns the path
+// referenced by symlinks contained in the cache. Otherwise, it returns the
+// given path as-is.
+func getStandardGoroot(path string) string {
+	// Check if the "bin" subdirectory of our given GOROOT is a symlink, and then
+	// return the _parent_ directory of its destination.
+	if dest, err := os.Readlink(filepath.Join(path, "bin")); nil == err {
+		// Clean the destination to remove any trailing slashes, so that
+		// filepath.Dir will always return the parent.
+		//   (because both "/foo" and "/foo/" are valid symlink destinations,
+		//   but filepath.Dir would return "/" and "/foo", respectively)
+		return filepath.Dir(filepath.Clean(dest))
+	}
+	return path
+}

goenv/version.go

@@ -12,7 +12,7 @@ import (
 
 // Version of TinyGo.
 // Update this value before release of new version of software.
-const Version = "0.15.0"
+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/README.md

@@ -6,50 +6,81 @@ possible and only run unknown expressions (e.g. external calls) at runtime. This
 is in practice a partial evaluator of the `runtime.initAll` function, which
 calls each package initializer.
 
-It works by directly interpreting LLVM IR:
+This package is a rewrite of a previous partial evaluator that worked
+directly on LLVM IR and used the module and LLVM constants as intermediate
+values. This newer version instead uses a mostly Go intermediate form. It
+compiles functions and extracts relevant data first (compiler.go), then
+executes those functions (interpreter.go) in a memory space that can be
+rolled back per function (memory.go). This means that it is not necessary to
+scan functions to see whether they can be run at compile time, which was very
+error prone. Instead it just tries to execute everything and if it hits
+something it cannot interpret (such as a store to memory-mapped I/O) it rolls
+back the execution of that function and runs the function at runtime instead.
+All in all, this design provides several benefits:
 
-  * Almost all operations work directly on constants, and are implemented using
-    the llvm.Const* set of functions that are evaluated directly.
-  * External function calls and some other operations (inline assembly, volatile
-    load, volatile store) are seen as having limited side effects. Limited in
-    the sense that it is known at compile time which globals it affects, which
-    then are marked 'dirty' (meaning, further operations on it must be done at
-    runtime). These operations are emitted directly in the `runtime.initAll`
-    function. Return values are also considered 'dirty'.
-  * Such 'dirty' objects and local values must be executed at runtime instead of
-    at compile time. This dirtyness propagates further through the IR, for
-    example storing a dirty local value to a global also makes the global dirty,
-    meaning that the global may not be read or written at compile time as it's
-    contents at that point during interpretation is unknown.
-  * There are some heuristics in place to avoid doing too much with dirty
-    values. For example, a branch based on a dirty local marks the whole
-    function itself as having side effect (as if it is an external function).
-    However, all globals it touches are still taken into account and when a call
-    is inserted in `runtime.initAll`, all globals it references are also marked
-    dirty.
-  * Heap allocation (`runtime.alloc`) is emulated by creating new objects. The
-    value in the allocation is the initializer of the global, the zero value is
-    the zero initializer.
-  * Stack allocation (`alloca`) is often emulated using a fake alloca object,
-    until the address of the alloca is taken in which case it is also created as
-    a real `alloca` in `runtime.initAll` and marked dirty. This may be necessary
-    when calling an external function with the given alloca as paramter.
+  * Much better error handling. By being able to revert to runtime execution
+    without the need for scanning functions, this version is able to
+    automatically work around many bugs in the previous implementation.
+  * More correct memory model. This is not inherent to the new design, but the
+    new design also made the memory model easier to reason about.
+  * Faster execution of initialization code. While it is not much faster for
+    normal interpretation (maybe 25% or so) due to the compilation overhead,
+    it should be a whole lot faster for loops as it doesn't have to call into
+    LLVM (via CGo) for every operation.
+
+As mentioned, this partial evaulator comes in three parts: a compiler, an
+interpreter, and a memory manager.
+
+## Compiler
+
+The main task of the compiler is that it extracts all necessary data from
+every instruction in a function so that when this instruction is interpreted,
+no additional CGo calls are necessary. This is not currently done for all
+instructions (`runtime.alloc` is a notable exception), but at least it does
+so for the vast majority of instructions.
+
+## Interpreter
+
+The interpreter runs an instruction just like it would if it were executed
+'for real'. The vast majority of instructions can be executed at compile
+time. As indicated above, some instructions need to be executed at runtime
+instead.
+
+## Memory
+
+Memory is represented as objects (the `object` type) that contains data that
+will eventually be stored in a global and values (the `value` interface) that
+can be worked with while running the interpreter. Values therefore are only
+used locally and are always passed by value (just like most LLVM constants)
+while objects represent the backing storage (like LLVM globals). Some values
+are pointer values, and point to an object.
+
+Importantly, this partial evaluator can roll back the execution of a
+function. This is implemented by creating a new memory view per function
+activation, which makes sure that any change to a global (such as a store
+instruction) is stored in the memory view. It creates a copy of the object
+and stores that in the memory view to be modified. Once the function has
+executed successfully, all these modified objects are then copied into the
+parent function, up to the root function invocation which (on successful
+execution) writes the values back into the LLVM module. This way, function
+invocations can be rolled back without leaving a trace.
+
+Pointer values point to memory objects, but not to a particular memory
+object. Every memory object is given an index, and pointers use that index to
+look up the current active object for the pointer to load from or to copy
+when storing to it.
+
+Rolling back a function should roll back everyting, including the few
+instructions emitted at runtime. This is done by treating instructions much
+like memory objects and removing the created instructions when necessary.
 
 ## Why is this necessary?
 
 A partial evaluator is hard to get right, so why go through all the trouble of
 writing one?
 
-The main reason is that the previous attempt wasn't complete and wasn't sound.
-It simply tried to evaluate Go SSA directly, which was good but more difficult
-than necessary. An IR based interpreter needs to understand fewer instructions
-as the LLVM IR simply has less (complex) instructions than Go SSA. Also, LLVM
-provides some useful tools like easily getting all uses of a function or global,
-which Go SSA does not provide.
-
-But why is it necessary at all? The answer is that globals with initializers are
-much easier to optimize by LLVM than initialization code. Also, there are a few
-other benefits:
+The answer is that globals with initializers are much easier to optimize by
+LLVM than initialization code. Also, there are a few other benefits:
 
   * Dead globals are trivial to optimize away.
   * Constant globals are easier to detect. Remember that Go does not have global
@@ -60,5 +91,29 @@ other benefits:
   * Constants are much more efficent on microcontrollers, as they can be
     allocated in flash instead of RAM.
 
+The Go SSA package does not create constant initializers for globals.
+Instead, it emits initialization functions, so if you write the following:
+
+```go
+var foo = []byte{1, 2, 3, 4}
+```
+
+It would generate something like this:
+
+```go
+var foo []byte
+
+func init() {
+    foo = make([]byte, 4)
+    foo[0] = 1
+    foo[1] = 2
+    foo[2] = 3
+    foo[3] = 4
+}
+```
+
+This is of course hugely wasteful, it's much better to create `foo` as a
+global array instead of initializing it at runtime.
+
 For more details, see [this section of the
 documentation](https://tinygo.org/compiler-internals/differences-from-go/).

interp/compiler.go

@@ -0,0 +1,410 @@
+package interp
+
+// This file compiles the LLVM IR to a form that's easy to efficiently
+// interpret.
+
+import (
+	"strings"
+
+	"tinygo.org/x/go-llvm"
+)
+
+// A function is a compiled LLVM function, which means that interpreting it
+// avoids most CGo calls necessary. This is done in a separate step so the
+// result can be cached.
+// Functions are in SSA form, just like the LLVM version if it. The first block
+// (blocks[0]) is the entry block.
+type function struct {
+	llvmFn llvm.Value
+	name   string       // precalculated llvmFn.Name()
+	params []llvm.Value // precalculated llvmFn.Params()
+	blocks []*basicBlock
+	locals map[llvm.Value]int
+}
+
+// basicBlock represents a LLVM basic block and contains a slice of
+// instructions. The last instruction must be a terminator instruction.
+type basicBlock struct {
+	instructions []instruction
+}
+
+// instruction is a precompiled LLVM IR instruction. The operands can be either
+// an already known value (such as literalValue or pointerValue) but can also be
+// the special localValue, which means that the value is a function parameter or
+// is produced by another instruction in the function. In that case, the
+// interpreter will replace the operand with that local value.
+type instruction struct {
+	opcode     llvm.Opcode
+	localIndex int
+	operands   []value
+	llvmInst   llvm.Value
+	name       string
+}
+
+// String returns a nice human-readable version of this instruction.
+func (inst *instruction) String() string {
+	operands := make([]string, len(inst.operands))
+	for i, op := range inst.operands {
+		operands[i] = op.String()
+	}
+
+	name := instructionNameMap[inst.opcode]
+	if name == "" {
+		name = "<unknown op>"
+	}
+	return name + " " + strings.Join(operands, " ")
+}
+
+// compileFunction compiles a given LLVM function to an easier to interpret
+// version of the function. As far as possible, all operands are preprocessed so
+// that the interpreter doesn't have to call into LLVM.
+func (r *runner) compileFunction(llvmFn llvm.Value) *function {
+	fn := &function{
+		llvmFn: llvmFn,
+		name:   llvmFn.Name(),
+		params: llvmFn.Params(),
+		locals: make(map[llvm.Value]int),
+	}
+	if llvmFn.IsDeclaration() {
+		// Nothing to do.
+		return fn
+	}
+
+	for i, param := range fn.params {
+		fn.locals[param] = i
+	}
+
+	// Make a map of all the blocks, to quickly find the block number for a
+	// given branch instruction.
+	blockIndices := make(map[llvm.Value]int)
+	for llvmBB := llvmFn.FirstBasicBlock(); !llvmBB.IsNil(); llvmBB = llvm.NextBasicBlock(llvmBB) {
+		index := len(blockIndices)
+		blockIndices[llvmBB.AsValue()] = index
+	}
+
+	// Compile every block.
+	for llvmBB := llvmFn.FirstBasicBlock(); !llvmBB.IsNil(); llvmBB = llvm.NextBasicBlock(llvmBB) {
+		bb := &basicBlock{}
+		fn.blocks = append(fn.blocks, bb)
+
+		// Compile every instruction in the block.
+		for llvmInst := llvmBB.FirstInstruction(); !llvmInst.IsNil(); llvmInst = llvm.NextInstruction(llvmInst) {
+			// Create instruction skeleton.
+			opcode := llvmInst.InstructionOpcode()
+			inst := instruction{
+				opcode:     opcode,
+				localIndex: len(fn.locals),
+				llvmInst:   llvmInst,
+			}
+			fn.locals[llvmInst] = len(fn.locals)
+
+			// Add operands specific for this instruction.
+			switch opcode {
+			case llvm.Ret:
+				// Return instruction, which can either be a `ret void` (no
+				// return value) or return a value.
+				numOperands := llvmInst.OperandsCount()
+				if numOperands != 0 {
+					inst.operands = []value{
+						r.getValue(llvmInst.Operand(0)),
+					}
+				}
+			case llvm.Br:
+				// Branch instruction. Can be either a conditional branch (with
+				// 3 operands) or unconditional branch (with just one basic
+				// block operand).
+				numOperands := llvmInst.OperandsCount()
+				switch numOperands {
+				case 3:
+					// Conditional jump to one of two blocks. Comparable to an
+					// if/else in procedural languages.
+					thenBB := llvmInst.Operand(2)
+					elseBB := llvmInst.Operand(1)
+					inst.operands = []value{
+						r.getValue(llvmInst.Operand(0)),
+						literalValue{uint32(blockIndices[thenBB])},
+						literalValue{uint32(blockIndices[elseBB])},
+					}
+				case 1:
+					// Unconditional jump to a target basic block. Comparable to
+					// a jump in C and Go.
+					jumpBB := llvmInst.Operand(0)
+					inst.operands = []value{
+						literalValue{uint32(blockIndices[jumpBB])},
+					}
+				default:
+					panic("unknown number of operands")
+				}
+			case llvm.PHI:
+				inst.name = llvmInst.Name()
+				incomingCount := inst.llvmInst.IncomingCount()
+				for i := 0; i < incomingCount; i++ {
+					incomingBB := inst.llvmInst.IncomingBlock(i)
+					incomingValue := inst.llvmInst.IncomingValue(i)
+					inst.operands = append(inst.operands,
+						literalValue{uint32(blockIndices[incomingBB.AsValue()])},
+						r.getValue(incomingValue),
+					)
+				}
+			case llvm.Select:
+				// Select is a special instruction that is much like a ternary
+				// operator. It produces operand 1 or 2 based on the boolean
+				// that is operand 0.
+				inst.name = llvmInst.Name()
+				inst.operands = []value{
+					r.getValue(llvmInst.Operand(0)),
+					r.getValue(llvmInst.Operand(1)),
+					r.getValue(llvmInst.Operand(2)),
+				}
+			case llvm.Call:
+				// Call is a regular function call but could also be a runtime
+				// intrinsic. Some runtime intrinsics are treated specially by
+				// the interpreter, such as runtime.alloc. We don't
+				// differentiate between them here because these calls may also
+				// need to be run at runtime, in which case they should all be
+				// created in the same way.
+				llvmCalledValue := llvmInst.CalledValue()
+				if !llvmCalledValue.IsAFunction().IsNil() {
+					name := llvmCalledValue.Name()
+					if name == "llvm.dbg.value" || strings.HasPrefix(name, "llvm.lifetime.") {
+						// These intrinsics should not be interpreted, they are not
+						// relevant to the execution of this function.
+						continue
+					}
+				}
+				inst.name = llvmInst.Name()
+				numOperands := llvmInst.OperandsCount()
+				inst.operands = append(inst.operands, r.getValue(llvmCalledValue))
+				for i := 0; i < numOperands-1; i++ {
+					inst.operands = append(inst.operands, r.getValue(llvmInst.Operand(i)))
+				}
+			case llvm.Load:
+				// Load instruction. The interpreter will load from the
+				// appropriate memory view.
+				// Also provide the memory size to be loaded, which is necessary
+				// with a lack of type information.
+				inst.name = llvmInst.Name()
+				inst.operands = []value{
+					r.getValue(llvmInst.Operand(0)),
+					literalValue{r.targetData.TypeAllocSize(llvmInst.Type())},
+				}
+			case llvm.Store:
+				// Store instruction. The interpreter will create a new object
+				// in the memory view of the function invocation and store to
+				// that, to make it possible to roll back this store.
+				inst.operands = []value{
+					r.getValue(llvmInst.Operand(0)),
+					r.getValue(llvmInst.Operand(1)),
+				}
+			case llvm.Alloca:
+				// Alloca allocates stack space for local variables.
+				numElements := r.getValue(inst.llvmInst.Operand(0)).(literalValue).value.(uint32)
+				elementSize := r.targetData.TypeAllocSize(inst.llvmInst.Type().ElementType())
+				inst.operands = []value{
+					literalValue{elementSize * uint64(numElements)},
+				}
+			case llvm.GetElementPtr:
+				// GetElementPtr does pointer arithmetic.
+				inst.name = llvmInst.Name()
+				ptr := llvmInst.Operand(0)
+				n := llvmInst.OperandsCount()
+				elementType := ptr.Type().ElementType()
+				// gep: [source ptr, dest value size, pairs of indices...]
+				inst.operands = []value{
+					r.getValue(ptr),
+					literalValue{r.targetData.TypeAllocSize(llvmInst.Type().ElementType())},
+					r.getValue(llvmInst.Operand(1)),
+					literalValue{r.targetData.TypeAllocSize(elementType)},
+				}
+				for i := 2; i < n; i++ {
+					operand := r.getValue(llvmInst.Operand(i))
+					if elementType.TypeKind() == llvm.StructTypeKind {
+						index := operand.(literalValue).value.(uint32)
+						elementOffset := r.targetData.ElementOffset(elementType, int(index))
+						// Encode operands in a special way. The elementOffset
+						// is just the offset in bytes. The elementSize is a
+						// negative number (when cast to a int64) by flipping
+						// all the bits. This allows the interpreter to detect
+						// this is a struct field and that it should not
+						// multiply it with the elementOffset to get the offset.
+						// It is important for the interpreter to know the
+						// struct field index for when the GEP must be done at
+						// runtime.
+						inst.operands = append(inst.operands, literalValue{elementOffset}, literalValue{^uint64(index)})
+						elementType = elementType.StructElementTypes()[index]
+					} else {
+						elementType = elementType.ElementType()
+						elementSize := r.targetData.TypeAllocSize(elementType)
+						elementSizeOperand := literalValue{elementSize}
+						// Add operand * elementSizeOperand bytes to the pointer.
+						inst.operands = append(inst.operands, operand, elementSizeOperand)
+					}
+				}
+			case llvm.BitCast, llvm.IntToPtr, llvm.PtrToInt:
+				// Bitcasts are ususally used to cast a pointer from one type to
+				// another leaving the pointer itself intact.
+				inst.name = llvmInst.Name()
+				inst.operands = []value{
+					r.getValue(llvmInst.Operand(0)),
+				}
+			case llvm.ExtractValue:
+				inst.name = llvmInst.Name()
+				agg := llvmInst.Operand(0)
+				var offset uint64
+				indexingType := agg.Type()
+				for _, index := range inst.llvmInst.Indices() {
+					switch indexingType.TypeKind() {
+					case llvm.StructTypeKind:
+						offset += r.targetData.ElementOffset(indexingType, int(index))
+						indexingType = indexingType.StructElementTypes()[index]
+					default: // ArrayTypeKind
+						indexingType = indexingType.ElementType()
+						elementSize := r.targetData.TypeAllocSize(indexingType)
+						offset += elementSize * uint64(index)
+					}
+				}
+				size := r.targetData.TypeAllocSize(inst.llvmInst.Type())
+				// extractvalue [agg, byteOffset, byteSize]
+				inst.operands = []value{
+					r.getValue(agg),
+					literalValue{offset},
+					literalValue{size},
+				}
+			case llvm.InsertValue:
+				inst.name = llvmInst.Name()
+				agg := llvmInst.Operand(0)
+				var offset uint64
+				indexingType := agg.Type()
+				for _, index := range inst.llvmInst.Indices() {
+					switch indexingType.TypeKind() {
+					case llvm.StructTypeKind:
+						offset += r.targetData.ElementOffset(indexingType, int(index))
+						indexingType = indexingType.StructElementTypes()[index]
+					default: // ArrayTypeKind
+						indexingType = indexingType.ElementType()
+						elementSize := r.targetData.TypeAllocSize(indexingType)
+						offset += elementSize * uint64(index)
+					}
+				}
+				// insertvalue [agg, elt, byteOffset]
+				inst.operands = []value{
+					r.getValue(agg),
+					r.getValue(llvmInst.Operand(1)),
+					literalValue{offset},
+				}
+			case llvm.ICmp:
+				inst.name = llvmInst.Name()
+				inst.operands = []value{
+					r.getValue(llvmInst.Operand(0)),
+					r.getValue(llvmInst.Operand(1)),
+					literalValue{uint8(llvmInst.IntPredicate())},
+				}
+			case llvm.FCmp:
+				inst.name = llvmInst.Name()
+				inst.operands = []value{
+					r.getValue(llvmInst.Operand(0)),
+					r.getValue(llvmInst.Operand(1)),
+					literalValue{uint8(llvmInst.FloatPredicate())},
+				}
+			case llvm.Add, llvm.Sub, llvm.Mul, llvm.UDiv, llvm.SDiv, llvm.URem, llvm.SRem, llvm.Shl, llvm.LShr, llvm.AShr, llvm.And, llvm.Or, llvm.Xor:
+				// Integer binary operations.
+				inst.name = llvmInst.Name()
+				inst.operands = []value{
+					r.getValue(llvmInst.Operand(0)),
+					r.getValue(llvmInst.Operand(1)),
+				}
+			case llvm.SExt, llvm.ZExt, llvm.Trunc:
+				// Extend or shrink an integer size.
+				// No sign extension going on so easy to do.
+				// zext: [value, bitwidth]
+				// trunc: [value, bitwidth]
+				inst.name = llvmInst.Name()
+				inst.operands = []value{
+					r.getValue(llvmInst.Operand(0)),
+					literalValue{uint64(llvmInst.Type().IntTypeWidth())},
+				}
+			case llvm.SIToFP, llvm.UIToFP:
+				// Convert an integer to a floating point instruction.
+				// opcode: [value, bitwidth]
+				inst.name = llvmInst.Name()
+				inst.operands = []value{
+					r.getValue(llvmInst.Operand(0)),
+					literalValue{uint64(r.targetData.TypeAllocSize(llvmInst.Type()) * 8)},
+				}
+			default:
+				// Unknown instruction, which is already set in inst.opcode so
+				// is detectable.
+				// This error is handled when actually trying to interpret this
+				// instruction (to not trigger on code that won't be executed).
+			}
+			bb.instructions = append(bb.instructions, inst)
+		}
+	}
+	return fn
+}
+
+// instructionNameMap maps from instruction opcodes to instruction names. This
+// can be useful for debug logging.
+var instructionNameMap = [...]string{
+	llvm.Ret:         "ret",
+	llvm.Br:          "br",
+	llvm.Switch:      "switch",
+	llvm.IndirectBr:  "indirectbr",
+	llvm.Invoke:      "invoke",
+	llvm.Unreachable: "unreachable",
+
+	// Standard Binary Operators
+	llvm.Add:  "add",
+	llvm.FAdd: "fadd",
+	llvm.Sub:  "sub",
+	llvm.FSub: "fsub",
+	llvm.Mul:  "mul",
+	llvm.FMul: "fmul",
+	llvm.UDiv: "udiv",
+	llvm.SDiv: "sdiv",
+	llvm.FDiv: "fdiv",
+	llvm.URem: "urem",
+	llvm.SRem: "srem",
+	llvm.FRem: "frem",
+
+	// Logical Operators
+	llvm.Shl:  "shl",
+	llvm.LShr: "lshr",
+	llvm.AShr: "ashr",
+	llvm.And:  "and",
+	llvm.Or:   "or",
+	llvm.Xor:  "xor",
+
+	// Memory Operators
+	llvm.Alloca:        "alloca",
+	llvm.Load:          "load",
+	llvm.Store:         "store",
+	llvm.GetElementPtr: "getelementptr",
+
+	// Cast Operators
+	llvm.Trunc:    "trunc",
+	llvm.ZExt:     "zext",
+	llvm.SExt:     "sext",
+	llvm.FPToUI:   "fptoui",
+	llvm.FPToSI:   "fptosi",
+	llvm.UIToFP:   "uitofp",
+	llvm.SIToFP:   "sitofp",
+	llvm.FPTrunc:  "fptrunc",
+	llvm.FPExt:    "fpext",
+	llvm.PtrToInt: "ptrtoint",
+	llvm.IntToPtr: "inttoptr",
+	llvm.BitCast:  "bitcast",
+
+	// Other Operators
+	llvm.ICmp:           "icmp",
+	llvm.FCmp:           "fcmp",
+	llvm.PHI:            "phi",
+	llvm.Call:           "call",
+	llvm.Select:         "select",
+	llvm.VAArg:          "vaarg",
+	llvm.ExtractElement: "extractelement",
+	llvm.InsertElement:  "insertelement",
+	llvm.ShuffleVector:  "shufflevector",
+	llvm.ExtractValue:   "extractvalue",
+	llvm.InsertValue:    "insertvalue",
+}

interp/errors.go

@@ -11,15 +11,17 @@ import (
 	"tinygo.org/x/go-llvm"
 )
 
-// errUnreachable is returned when an unreachable instruction is executed. This
-// error should not be visible outside of the interp package.
-var errUnreachable = &Error{Err: errors.New("interp: unreachable executed")}
+// These errors are expected during normal execution and can be recovered from
+// by running the affected function at runtime instead of compile time.
+var (
+	errIntegerAsPointer       = errors.New("interp: trying to use an integer as a pointer (memory-mapped I/O?)")
+	errUnsupportedInst        = errors.New("interp: unsupported instruction")
+	errUnsupportedRuntimeInst = errors.New("interp: unsupported instruction (to be emitted at runtime)")
+	errMapAlreadyCreated      = errors.New("interp: map already created")
+)
 
-// unsupportedInstructionError returns a new "unsupported instruction" error for
-// the given instruction. It includes source location information, when
-// available.
-func (e *evalPackage) unsupportedInstructionError(inst llvm.Value) *Error {
-	return e.errorAt(inst, errors.New("interp: unsupported instruction"))
+func isRecoverableError(err error) bool {
+	return err == errIntegerAsPointer || err == errUnsupportedInst || err == errUnsupportedRuntimeInst || err == errMapAlreadyCreated
 }
 
 // ErrorLine is one line in a traceback. The position may be missing.
@@ -46,13 +48,13 @@ func (e *Error) Error() string {
 // errorAt returns an error value for the currently interpreted package at the
 // location of the instruction. The location information may not be complete as
 // it depends on debug information in the IR.
-func (e *evalPackage) errorAt(inst llvm.Value, err error) *Error {
-	pos := getPosition(inst)
+func (r *runner) errorAt(inst instruction, err error) *Error {
+	pos := getPosition(inst.llvmInst)
 	return &Error{
-		ImportPath: e.packagePath,
+		ImportPath: r.pkgName,
 		Pos:        pos,
 		Err:        err,
-		Traceback:  []ErrorLine{{pos, inst}},
+		Traceback:  []ErrorLine{{pos, inst.llvmInst}},
 	}
 }
 

interp/frame.go

@@ -1,708 +0,0 @@
-package interp
-
-// This file implements the core interpretation routines, interpreting single
-// functions.
-
-import (
-	"errors"
-	"strings"
-
-	"tinygo.org/x/go-llvm"
-)
-
-type frame struct {
-	*evalPackage
-	fn     llvm.Value
-	locals map[llvm.Value]Value
-}
-
-// evalBasicBlock evaluates a single basic block, returning the return value (if
-// ending with a ret instruction), a list of outgoing basic blocks (if not
-// ending with a ret instruction), or an error on failure.
-// Most of it works at compile time. Some calls get translated into calls to be
-// executed at runtime: calls to functions with side effects, external calls,
-// and operations on the result of such instructions.
-func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (retval Value, outgoing []llvm.Value, err *Error) {
-	for inst := bb.FirstInstruction(); !inst.IsNil(); inst = llvm.NextInstruction(inst) {
-		if fr.Debug {
-			print(indent)
-			inst.Dump()
-			println()
-		}
-		switch {
-		case !inst.IsABinaryOperator().IsNil():
-			lhs := fr.getLocal(inst.Operand(0)).(*LocalValue).Underlying
-			rhs := fr.getLocal(inst.Operand(1)).(*LocalValue).Underlying
-
-			switch inst.InstructionOpcode() {
-			// Standard binary operators
-			case llvm.Add:
-				fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateAdd(lhs, rhs, "")}
-			case llvm.FAdd:
-				fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateFAdd(lhs, rhs, "")}
-			case llvm.Sub:
-				fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateSub(lhs, rhs, "")}
-			case llvm.FSub:
-				fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateFSub(lhs, rhs, "")}
-			case llvm.Mul:
-				fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateMul(lhs, rhs, "")}
-			case llvm.FMul:
-				fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateFMul(lhs, rhs, "")}
-			case llvm.UDiv:
-				fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateUDiv(lhs, rhs, "")}
-			case llvm.SDiv:
-				fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateSDiv(lhs, rhs, "")}
-			case llvm.FDiv:
-				fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateFDiv(lhs, rhs, "")}
-			case llvm.URem:
-				fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateURem(lhs, rhs, "")}
-			case llvm.SRem:
-				fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateSRem(lhs, rhs, "")}
-			case llvm.FRem:
-				fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateFRem(lhs, rhs, "")}
-
-			// Logical operators
-			case llvm.Shl:
-				fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateShl(lhs, rhs, "")}
-			case llvm.LShr:
-				fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateLShr(lhs, rhs, "")}
-			case llvm.AShr:
-				fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateAShr(lhs, rhs, "")}
-			case llvm.And:
-				fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateAnd(lhs, rhs, "")}
-			case llvm.Or:
-				fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateOr(lhs, rhs, "")}
-			case llvm.Xor:
-				fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateXor(lhs, rhs, "")}
-
-			default:
-				return nil, nil, fr.unsupportedInstructionError(inst)
-			}
-
-		// Memory operators
-		case !inst.IsAAllocaInst().IsNil():
-			allocType := inst.Type().ElementType()
-			alloca := llvm.AddGlobal(fr.Mod, allocType, fr.packagePath+"$alloca")
-			alloca.SetInitializer(llvm.ConstNull(allocType))
-			alloca.SetLinkage(llvm.InternalLinkage)
-			fr.locals[inst] = &LocalValue{
-				Underlying: alloca,
-				Eval:       fr.Eval,
-			}
-		case !inst.IsALoadInst().IsNil():
-			operand := fr.getLocal(inst.Operand(0)).(*LocalValue)
-			var value llvm.Value
-			if !operand.IsConstant() || inst.IsVolatile() || (!operand.Underlying.IsAConstantExpr().IsNil() && operand.Underlying.Opcode() == llvm.BitCast) {
-				value = fr.builder.CreateLoad(operand.Value(), inst.Name())
-			} else {
-				var err error
-				value, err = operand.Load()
-				if err != nil {
-					return nil, nil, fr.errorAt(inst, err)
-				}
-			}
-			if value.Type() != inst.Type() {
-				return nil, nil, fr.errorAt(inst, errors.New("interp: load: type does not match"))
-			}
-			fr.locals[inst] = fr.getValue(value)
-		case !inst.IsAStoreInst().IsNil():
-			value := fr.getLocal(inst.Operand(0))
-			ptr := fr.getLocal(inst.Operand(1))
-			if inst.IsVolatile() {
-				fr.builder.CreateStore(value.Value(), ptr.Value())
-			} else {
-				err := ptr.Store(value.Value())
-				if err != nil {
-					return nil, nil, fr.errorAt(inst, err)
-				}
-			}
-		case !inst.IsAGetElementPtrInst().IsNil():
-			value := fr.getLocal(inst.Operand(0))
-			llvmIndices := make([]llvm.Value, inst.OperandsCount()-1)
-			for i := range llvmIndices {
-				llvmIndices[i] = inst.Operand(i + 1)
-			}
-			indices := make([]uint32, len(llvmIndices))
-			for i, llvmIndex := range llvmIndices {
-				operand := fr.getLocal(llvmIndex)
-				if !operand.IsConstant() {
-					// Not a constant operation.
-					// This should be detected by the scanner, but isn't at the
-					// moment.
-					return nil, nil, fr.errorAt(inst, errors.New("todo: non-const gep"))
-				}
-				indices[i] = uint32(operand.Value().ZExtValue())
-			}
-			result, err := value.GetElementPtr(indices)
-			if err != nil {
-				return nil, nil, fr.errorAt(inst, err)
-			}
-			if result.Type() != inst.Type() {
-				return nil, nil, fr.errorAt(inst, errors.New("interp: gep: type does not match"))
-			}
-			fr.locals[inst] = result
-
-		// Cast operators
-		case !inst.IsATruncInst().IsNil():
-			value := fr.getLocal(inst.Operand(0))
-			fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateTrunc(value.(*LocalValue).Value(), inst.Type(), "")}
-		case !inst.IsAZExtInst().IsNil():
-			value := fr.getLocal(inst.Operand(0))
-			fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateZExt(value.(*LocalValue).Value(), inst.Type(), "")}
-		case !inst.IsASExtInst().IsNil():
-			value := fr.getLocal(inst.Operand(0))
-			fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateSExt(value.(*LocalValue).Value(), inst.Type(), "")}
-		case !inst.IsAFPToUIInst().IsNil():
-			value := fr.getLocal(inst.Operand(0))
-			fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateFPToUI(value.(*LocalValue).Value(), inst.Type(), "")}
-		case !inst.IsAFPToSIInst().IsNil():
-			value := fr.getLocal(inst.Operand(0))
-			fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateFPToSI(value.(*LocalValue).Value(), inst.Type(), "")}
-		case !inst.IsAUIToFPInst().IsNil():
-			value := fr.getLocal(inst.Operand(0))
-			fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateUIToFP(value.(*LocalValue).Value(), inst.Type(), "")}
-		case !inst.IsASIToFPInst().IsNil():
-			value := fr.getLocal(inst.Operand(0))
-			fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateSIToFP(value.(*LocalValue).Value(), inst.Type(), "")}
-		case !inst.IsAFPTruncInst().IsNil():
-			value := fr.getLocal(inst.Operand(0))
-			fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateFPTrunc(value.(*LocalValue).Value(), inst.Type(), "")}
-		case !inst.IsAFPExtInst().IsNil():
-			value := fr.getLocal(inst.Operand(0))
-			fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateFPExt(value.(*LocalValue).Value(), inst.Type(), "")}
-		case !inst.IsAPtrToIntInst().IsNil():
-			value := fr.getLocal(inst.Operand(0))
-			fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreatePtrToInt(value.Value(), inst.Type(), "")}
-		case !inst.IsABitCastInst().IsNil() && inst.Type().TypeKind() == llvm.PointerTypeKind:
-			operand := inst.Operand(0)
-			if !operand.IsACallInst().IsNil() {
-				fn := operand.CalledValue()
-				if !fn.IsAFunction().IsNil() && fn.Name() == "runtime.alloc" {
-					continue // special case: bitcast of alloc
-				}
-			}
-			if _, ok := fr.getLocal(operand).(*MapValue); ok {
-				// Special case for runtime.trackPointer calls.
-				// Note: this might not be entirely sound in some rare cases
-				// where the map is stored in a dirty global.
-				uses := getUses(inst)
-				if len(uses) == 1 {
-					use := uses[0]
-					if !use.IsACallInst().IsNil() && !use.CalledValue().IsAFunction().IsNil() && use.CalledValue().Name() == "runtime.trackPointer" {
-						continue
-					}
-				}
-				// It is not possible in Go to bitcast a map value to a pointer.
-				return nil, nil, fr.errorAt(inst, errors.New("unimplemented: bitcast of map"))
-			}
-			value := fr.getLocal(operand).(*LocalValue)
-			fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateBitCast(value.Value(), inst.Type(), "")}
-
-		// Other operators
-		case !inst.IsAICmpInst().IsNil():
-			lhs := fr.getLocal(inst.Operand(0)).(*LocalValue).Underlying
-			rhs := fr.getLocal(inst.Operand(1)).(*LocalValue).Underlying
-			predicate := inst.IntPredicate()
-			if predicate == llvm.IntEQ {
-				var lhsZero, rhsZero bool
-				var ok1, ok2 bool
-				if lhs.Type().TypeKind() == llvm.PointerTypeKind {
-					// Unfortunately, the const propagation in the IR builder
-					// doesn't handle pointer compares of inttoptr values. So we
-					// implement it manually here.
-					lhsZero, ok1 = isPointerNil(lhs)
-					rhsZero, ok2 = isPointerNil(rhs)
-				}
-				if lhs.Type().TypeKind() == llvm.IntegerTypeKind {
-					lhsZero, ok1 = isZero(lhs)
-					rhsZero, ok2 = isZero(rhs)
-				}
-				if ok1 && ok2 {
-					if lhsZero && rhsZero {
-						// Both are zero, so this icmp is always evaluated to true.
-						fr.locals[inst] = &LocalValue{fr.Eval, llvm.ConstInt(fr.Mod.Context().Int1Type(), 1, false)}
-						continue
-					}
-					if lhsZero != rhsZero {
-						// Only one of them is zero, so this comparison must return false.
-						fr.locals[inst] = &LocalValue{fr.Eval, llvm.ConstInt(fr.Mod.Context().Int1Type(), 0, false)}
-						continue
-					}
-				}
-			}
-			fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateICmp(predicate, lhs, rhs, "")}
-		case !inst.IsAFCmpInst().IsNil():
-			lhs := fr.getLocal(inst.Operand(0)).(*LocalValue).Underlying
-			rhs := fr.getLocal(inst.Operand(1)).(*LocalValue).Underlying
-			predicate := inst.FloatPredicate()
-			fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateFCmp(predicate, lhs, rhs, "")}
-		case !inst.IsAPHINode().IsNil():
-			for i := 0; i < inst.IncomingCount(); i++ {
-				if inst.IncomingBlock(i) == incoming {
-					fr.locals[inst] = fr.getLocal(inst.IncomingValue(i))
-				}
-			}
-		case !inst.IsACallInst().IsNil():
-			callee := inst.CalledValue()
-			switch {
-			case callee.Name() == "runtime.alloc":
-				// heap allocation
-				users := getUses(inst)
-				var resultInst = inst
-				if len(users) == 1 && !users[0].IsABitCastInst().IsNil() {
-					// happens when allocating something other than i8*
-					resultInst = users[0]
-				}
-				size := fr.getLocal(inst.Operand(0)).(*LocalValue).Underlying.ZExtValue()
-				allocType := resultInst.Type().ElementType()
-				typeSize := fr.TargetData.TypeAllocSize(allocType)
-				elementCount := 1
-				if size != typeSize {
-					// allocate an array
-					if size%typeSize != 0 {
-						return nil, nil, fr.unsupportedInstructionError(inst)
-					}
-					elementCount = int(size / typeSize)
-					allocType = llvm.ArrayType(allocType, elementCount)
-				}
-				alloc := llvm.AddGlobal(fr.Mod, allocType, fr.packagePath+"$alloc")
-				alloc.SetInitializer(llvm.ConstNull(allocType))
-				alloc.SetLinkage(llvm.InternalLinkage)
-				result := &LocalValue{
-					Underlying: alloc,
-					Eval:       fr.Eval,
-				}
-				if elementCount == 1 {
-					fr.locals[resultInst] = result
-				} else {
-					result, err := result.GetElementPtr([]uint32{0, 0})
-					if err != nil {
-						return nil, nil, fr.errorAt(inst, err)
-					}
-					fr.locals[resultInst] = result
-				}
-			case callee.Name() == "runtime.hashmapMake":
-				// create a map
-				keySize := inst.Operand(0).ZExtValue()
-				valueSize := inst.Operand(1).ZExtValue()
-				fr.locals[inst] = &MapValue{
-					Eval:      fr.Eval,
-					PkgName:   fr.packagePath,
-					KeySize:   int(keySize),
-					ValueSize: int(valueSize),
-				}
-			case callee.Name() == "runtime.hashmapStringSet":
-				// set a string key in the map
-				keyBuf := fr.getLocal(inst.Operand(1)).(*LocalValue)
-				keyLen := fr.getLocal(inst.Operand(2)).(*LocalValue)
-				valPtr := fr.getLocal(inst.Operand(3)).(*LocalValue)
-				m, ok := fr.getLocal(inst.Operand(0)).(*MapValue)
-				if !ok || !keyBuf.IsConstant() || !keyLen.IsConstant() || !valPtr.IsConstant() {
-					// The mapassign operation could not be done at compile
-					// time. Do it at runtime instead.
-					m := fr.getLocal(inst.Operand(0)).Value()
-					fr.markDirty(m)
-					llvmParams := []llvm.Value{
-						m,                                    // *runtime.hashmap
-						fr.getLocal(inst.Operand(1)).Value(), // key.ptr
-						fr.getLocal(inst.Operand(2)).Value(), // key.len
-						fr.getLocal(inst.Operand(3)).Value(), // value (unsafe.Pointer)
-						fr.getLocal(inst.Operand(4)).Value(), // context
-						fr.getLocal(inst.Operand(5)).Value(), // parentHandle
-					}
-					fr.builder.CreateCall(callee, llvmParams, "")
-					continue
-				}
-				// "key" is a Go string value, which in the TinyGo calling convention is split up
-				// into separate pointer and length parameters.
-				err := m.PutString(keyBuf, keyLen, valPtr)
-				if err != nil {
-					return nil, nil, fr.errorAt(inst, err)
-				}
-			case callee.Name() == "runtime.hashmapBinarySet":
-				// set a binary (int etc.) key in the map
-				keyBuf := fr.getLocal(inst.Operand(1)).(*LocalValue)
-				valPtr := fr.getLocal(inst.Operand(2)).(*LocalValue)
-				m, ok := fr.getLocal(inst.Operand(0)).(*MapValue)
-				if !ok || !keyBuf.IsConstant() || !valPtr.IsConstant() {
-					// The mapassign operation could not be done at compile
-					// time. Do it at runtime instead.
-					m := fr.getLocal(inst.Operand(0)).Value()
-					fr.markDirty(m)
-					llvmParams := []llvm.Value{
-						m,                                    // *runtime.hashmap
-						fr.getLocal(inst.Operand(1)).Value(), // key
-						fr.getLocal(inst.Operand(2)).Value(), // value
-						fr.getLocal(inst.Operand(3)).Value(), // context
-						fr.getLocal(inst.Operand(4)).Value(), // parentHandle
-					}
-					fr.builder.CreateCall(callee, llvmParams, "")
-					continue
-				}
-				err := m.PutBinary(keyBuf, valPtr)
-				if err != nil {
-					return nil, nil, fr.errorAt(inst, err)
-				}
-			case callee.Name() == "runtime.stringConcat":
-				// adding two strings together
-				buf1Ptr := fr.getLocal(inst.Operand(0))
-				buf1Len := fr.getLocal(inst.Operand(1))
-				buf2Ptr := fr.getLocal(inst.Operand(2))
-				buf2Len := fr.getLocal(inst.Operand(3))
-				buf1, err := getStringBytes(buf1Ptr, buf1Len.Value())
-				if err != nil {
-					return nil, nil, fr.errorAt(inst, err)
-				}
-				buf2, err := getStringBytes(buf2Ptr, buf2Len.Value())
-				if err != nil {
-					return nil, nil, fr.errorAt(inst, err)
-				}
-				result := []byte(string(buf1) + string(buf2))
-				vals := make([]llvm.Value, len(result))
-				for i := range vals {
-					vals[i] = llvm.ConstInt(fr.Mod.Context().Int8Type(), uint64(result[i]), false)
-				}
-				globalType := llvm.ArrayType(fr.Mod.Context().Int8Type(), len(result))
-				globalValue := llvm.ConstArray(fr.Mod.Context().Int8Type(), vals)
-				global := llvm.AddGlobal(fr.Mod, globalType, fr.packagePath+"$stringconcat")
-				global.SetInitializer(globalValue)
-				global.SetLinkage(llvm.InternalLinkage)
-				global.SetGlobalConstant(true)
-				global.SetUnnamedAddr(true)
-				stringType := fr.Mod.GetTypeByName("runtime._string")
-				retPtr := llvm.ConstGEP(global, getLLVMIndices(fr.Mod.Context().Int32Type(), []uint32{0, 0}))
-				retLen := llvm.ConstInt(stringType.StructElementTypes()[1], uint64(len(result)), false)
-				ret := llvm.ConstNull(stringType)
-				ret = llvm.ConstInsertValue(ret, retPtr, []uint32{0})
-				ret = llvm.ConstInsertValue(ret, retLen, []uint32{1})
-				fr.locals[inst] = &LocalValue{fr.Eval, ret}
-			case callee.Name() == "runtime.sliceCopy":
-				elementSize := fr.getLocal(inst.Operand(4)).(*LocalValue).Value().ZExtValue()
-				dstArray := fr.getLocal(inst.Operand(0)).(*LocalValue).stripPointerCasts()
-				srcArray := fr.getLocal(inst.Operand(1)).(*LocalValue).stripPointerCasts()
-				dstLen := fr.getLocal(inst.Operand(2)).(*LocalValue)
-				srcLen := fr.getLocal(inst.Operand(3)).(*LocalValue)
-				if elementSize != 1 && dstArray.Type().ElementType().TypeKind() == llvm.ArrayTypeKind && srcArray.Type().ElementType().TypeKind() == llvm.ArrayTypeKind {
-					// Slice data pointers are created by adding a global array
-					// and getting the address of the first element using a GEP.
-					// However, before the compiler can pass it to
-					// runtime.sliceCopy, it has to perform a bitcast to a *i8,
-					// to make it a unsafe.Pointer. Now, when the IR builder
-					// sees a bitcast of a GEP with zero indices, it will make
-					// a bitcast of the original array instead of the GEP,
-					// which breaks our assumptions.
-					// Re-add this GEP, in the hope that it it is then of the correct type...
-					dstArrayValue, err := dstArray.GetElementPtr([]uint32{0, 0})
-					if err != nil {
-						return nil, nil, fr.errorAt(inst, err)
-					}
-					dstArray = dstArrayValue.(*LocalValue)
-					srcArrayValue, err := srcArray.GetElementPtr([]uint32{0, 0})
-					if err != nil {
-						return nil, nil, fr.errorAt(inst, err)
-					}
-					srcArray = srcArrayValue.(*LocalValue)
-				}
-				if fr.Eval.TargetData.TypeAllocSize(dstArray.Type().ElementType()) != elementSize {
-					return nil, nil, fr.errorAt(inst, errors.New("interp: slice dst element size does not match pointer type"))
-				}
-				if fr.Eval.TargetData.TypeAllocSize(srcArray.Type().ElementType()) != elementSize {
-					return nil, nil, fr.errorAt(inst, errors.New("interp: slice src element size does not match pointer type"))
-				}
-				if dstArray.Type() != srcArray.Type() {
-					return nil, nil, fr.errorAt(inst, errors.New("interp: slice element types don't match"))
-				}
-				length := dstLen.Value().SExtValue()
-				if srcLength := srcLen.Value().SExtValue(); srcLength < length {
-					length = srcLength
-				}
-				if length < 0 {
-					return nil, nil, fr.errorAt(inst, errors.New("interp: trying to copy a slice with negative length?"))
-				}
-				for i := int64(0); i < length; i++ {
-					// *dst = *src
-					val, err := srcArray.Load()
-					if err != nil {
-						return nil, nil, fr.errorAt(inst, err)
-					}
-					err = dstArray.Store(val)
-					if err != nil {
-						return nil, nil, fr.errorAt(inst, err)
-					}
-					// dst++
-					dstArrayValue, err := dstArray.GetElementPtr([]uint32{1})
-					if err != nil {
-						return nil, nil, fr.errorAt(inst, err)
-					}
-					dstArray = dstArrayValue.(*LocalValue)
-					// src++
-					srcArrayValue, err := srcArray.GetElementPtr([]uint32{1})
-					if err != nil {
-						return nil, nil, fr.errorAt(inst, err)
-					}
-					srcArray = srcArrayValue.(*LocalValue)
-				}
-			case callee.Name() == "runtime.stringToBytes":
-				// convert a string to a []byte
-				bufPtr := fr.getLocal(inst.Operand(0))
-				bufLen := fr.getLocal(inst.Operand(1))
-				result, err := getStringBytes(bufPtr, bufLen.Value())
-				if err != nil {
-					return nil, nil, fr.errorAt(inst, err)
-				}
-				vals := make([]llvm.Value, len(result))
-				for i := range vals {
-					vals[i] = llvm.ConstInt(fr.Mod.Context().Int8Type(), uint64(result[i]), false)
-				}
-				globalType := llvm.ArrayType(fr.Mod.Context().Int8Type(), len(result))
-				globalValue := llvm.ConstArray(fr.Mod.Context().Int8Type(), vals)
-				global := llvm.AddGlobal(fr.Mod, globalType, fr.packagePath+"$bytes")
-				global.SetInitializer(globalValue)
-				global.SetLinkage(llvm.InternalLinkage)
-				global.SetGlobalConstant(true)
-				global.SetUnnamedAddr(true)
-				sliceType := inst.Type()
-				retPtr := llvm.ConstGEP(global, getLLVMIndices(fr.Mod.Context().Int32Type(), []uint32{0, 0}))
-				retLen := llvm.ConstInt(sliceType.StructElementTypes()[1], uint64(len(result)), false)
-				ret := llvm.ConstNull(sliceType)
-				ret = llvm.ConstInsertValue(ret, retPtr, []uint32{0}) // ptr
-				ret = llvm.ConstInsertValue(ret, retLen, []uint32{1}) // len
-				ret = llvm.ConstInsertValue(ret, retLen, []uint32{2}) // cap
-				fr.locals[inst] = &LocalValue{fr.Eval, ret}
-			case callee.Name() == "runtime.typeAssert":
-				actualTypeInt := fr.getLocal(inst.Operand(0)).(*LocalValue).Underlying
-				assertedType := fr.getLocal(inst.Operand(1)).(*LocalValue).Underlying
-				if actualTypeInt.IsAConstantExpr().IsNil() || actualTypeInt.Opcode() != llvm.PtrToInt {
-					return nil, nil, fr.errorAt(inst, errors.New("interp: expected typecode in runtime.typeAssert to be a ptrtoint"))
-				}
-				actualType := actualTypeInt.Operand(0)
-				if actualType.IsAConstant().IsNil() || assertedType.IsAConstant().IsNil() {
-					return nil, nil, fr.errorAt(inst, errors.New("interp: unimplemented: type assert with non-constant interface value"))
-				}
-				assertOk := uint64(0)
-				if llvm.ConstExtractValue(actualType.Initializer(), []uint32{0}) == assertedType {
-					assertOk = 1
-				}
-				fr.locals[inst] = &LocalValue{fr.Eval, llvm.ConstInt(fr.Mod.Context().Int1Type(), assertOk, false)}
-			case callee.Name() == "runtime.interfaceImplements":
-				typecode := fr.getLocal(inst.Operand(0)).(*LocalValue).Underlying
-				interfaceMethodSet := fr.getLocal(inst.Operand(1)).(*LocalValue).Underlying
-				if typecode.IsAConstantExpr().IsNil() || typecode.Opcode() != llvm.PtrToInt {
-					return nil, nil, fr.errorAt(inst, errors.New("interp: expected typecode to be a ptrtoint"))
-				}
-				typecode = typecode.Operand(0)
-				if interfaceMethodSet.IsAConstantExpr().IsNil() || interfaceMethodSet.Opcode() != llvm.GetElementPtr {
-					return nil, nil, fr.errorAt(inst, errors.New("interp: expected method set in runtime.interfaceImplements to be a constant gep"))
-				}
-				interfaceMethodSet = interfaceMethodSet.Operand(0).Initializer()
-				methodSet := llvm.ConstExtractValue(typecode.Initializer(), []uint32{1})
-				if methodSet.IsAConstantExpr().IsNil() || methodSet.Opcode() != llvm.GetElementPtr {
-					return nil, nil, fr.errorAt(inst, errors.New("interp: expected method set to be a constant gep"))
-				}
-				methodSet = methodSet.Operand(0).Initializer()
-
-				// Make a set of all the methods on the concrete type, for
-				// easier checking in the next step.
-				definedMethods := map[string]struct{}{}
-				for i := 0; i < methodSet.Type().ArrayLength(); i++ {
-					methodInfo := llvm.ConstExtractValue(methodSet, []uint32{uint32(i)})
-					name := llvm.ConstExtractValue(methodInfo, []uint32{0}).Name()
-					definedMethods[name] = struct{}{}
-				}
-				// Check whether all interface methods are also in the list
-				// of defined methods calculated above.
-				implements := uint64(1) // i1 true
-				for i := 0; i < interfaceMethodSet.Type().ArrayLength(); i++ {
-					name := llvm.ConstExtractValue(interfaceMethodSet, []uint32{uint32(i)}).Name()
-					if _, ok := definedMethods[name]; !ok {
-						// There is a method on the interface that is not
-						// implemented by the type.
-						implements = 0 // i1 false
-						break
-					}
-				}
-				fr.locals[inst] = &LocalValue{fr.Eval, llvm.ConstInt(fr.Mod.Context().Int1Type(), implements, false)}
-			case callee.Name() == "runtime.nanotime":
-				fr.locals[inst] = &LocalValue{fr.Eval, llvm.ConstInt(fr.Mod.Context().Int64Type(), 0, false)}
-			case callee.Name() == "llvm.dbg.value":
-				// do nothing
-			case strings.HasPrefix(callee.Name(), "llvm.lifetime."):
-				// do nothing
-			case callee.Name() == "runtime.trackPointer":
-				// do nothing
-			case strings.HasPrefix(callee.Name(), "runtime.print") || callee.Name() == "runtime._panic":
-				// This are all print instructions, which necessarily have side
-				// effects but no results.
-				// TODO: print an error when executing runtime._panic (with the
-				// exact error message it would print at runtime).
-				var params []llvm.Value
-				for i := 0; i < inst.OperandsCount()-1; i++ {
-					operand := fr.getLocal(inst.Operand(i)).Value()
-					fr.markDirty(operand)
-					params = append(params, operand)
-				}
-				// TODO: accurate debug info, including call chain
-				fr.builder.CreateCall(callee, params, inst.Name())
-			case !callee.IsAFunction().IsNil() && callee.IsDeclaration():
-				// external functions
-				var params []llvm.Value
-				for i := 0; i < inst.OperandsCount()-1; i++ {
-					operand := fr.getLocal(inst.Operand(i)).Value()
-					fr.markDirty(operand)
-					params = append(params, operand)
-				}
-				// TODO: accurate debug info, including call chain
-				result := fr.builder.CreateCall(callee, params, inst.Name())
-				if inst.Type().TypeKind() != llvm.VoidTypeKind {
-					fr.markDirty(result)
-					fr.locals[inst] = &LocalValue{fr.Eval, result}
-				}
-			case !callee.IsAFunction().IsNil():
-				// regular function
-				var params []Value
-				dirtyParams := false
-				for i := 0; i < inst.OperandsCount()-1; i++ {
-					local := fr.getLocal(inst.Operand(i))
-					if !local.IsConstant() {
-						dirtyParams = true
-					}
-					params = append(params, local)
-				}
-				var ret Value
-				scanResult, err := fr.hasSideEffects(callee)
-				if err != nil {
-					return nil, nil, err
-				}
-				if scanResult.severity == sideEffectLimited || dirtyParams && scanResult.severity != sideEffectAll {
-					// Side effect is bounded. This means the operation invokes
-					// side effects (like calling an external function) but it
-					// is known at compile time which side effects it invokes.
-					// This means the function can be called at runtime and the
-					// affected globals can be marked dirty at compile time.
-					llvmParams := make([]llvm.Value, len(params))
-					for i, param := range params {
-						llvmParams[i] = param.Value()
-					}
-					result := fr.builder.CreateCall(callee, llvmParams, inst.Name())
-					ret = &LocalValue{fr.Eval, result}
-					// mark all mentioned globals as dirty
-					for global := range scanResult.mentionsGlobals {
-						fr.markDirty(global)
-					}
-				} else {
-					// Side effect is one of:
-					//   * None: no side effects, can be fully interpreted at
-					//     compile time.
-					//   * Unbounded: cannot call at runtime so we'll try to
-					//     interpret anyway and hope for the best.
-					ret, err = fr.function(callee, params, indent+"    ")
-					if err != nil {
-						// Record this function call in the backtrace.
-						err.Traceback = append(err.Traceback, ErrorLine{
-							Pos:  getPosition(inst),
-							Inst: inst,
-						})
-						return nil, nil, err
-					}
-				}
-				if inst.Type().TypeKind() != llvm.VoidTypeKind {
-					fr.locals[inst] = ret
-				}
-			default:
-				// function pointers, etc.
-				return nil, nil, fr.unsupportedInstructionError(inst)
-			}
-		case !inst.IsAExtractValueInst().IsNil():
-			agg := fr.getLocal(inst.Operand(0)).(*LocalValue) // must be constant
-			indices := inst.Indices()
-			if agg.Underlying.IsConstant() {
-				newValue := llvm.ConstExtractValue(agg.Underlying, indices)
-				fr.locals[inst] = fr.getValue(newValue)
-			} else {
-				if len(indices) != 1 {
-					return nil, nil, fr.errorAt(inst, errors.New("interp: cannot handle extractvalue with not exactly 1 index"))
-				}
-				fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateExtractValue(agg.Underlying, int(indices[0]), inst.Name())}
-			}
-		case !inst.IsAInsertValueInst().IsNil():
-			agg := fr.getLocal(inst.Operand(0)).(*LocalValue) // must be constant
-			val := fr.getLocal(inst.Operand(1))
-			indices := inst.Indices()
-			if agg.IsConstant() && val.IsConstant() {
-				newValue := llvm.ConstInsertValue(agg.Underlying, val.Value(), indices)
-				fr.locals[inst] = &LocalValue{fr.Eval, newValue}
-			} else {
-				if len(indices) != 1 {
-					return nil, nil, fr.errorAt(inst, errors.New("interp: cannot handle insertvalue with not exactly 1 index"))
-				}
-				fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateInsertValue(agg.Underlying, val.Value(), int(indices[0]), inst.Name())}
-			}
-		case !inst.IsASelectInst().IsNil():
-			// var result T
-			// if cond {
-			//   result = x
-			// } else {
-			//   result = y
-			// }
-			// return result
-			cond := fr.getLocal(inst.Operand(0)).(*LocalValue).Underlying
-			x := fr.getLocal(inst.Operand(1)).(*LocalValue).Underlying
-			y := fr.getLocal(inst.Operand(2)).(*LocalValue).Underlying
-			fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateSelect(cond, x, y, "")}
-
-		case !inst.IsAReturnInst().IsNil() && inst.OperandsCount() == 0:
-			return nil, nil, nil // ret void
-		case !inst.IsAReturnInst().IsNil() && inst.OperandsCount() == 1:
-			return fr.getLocal(inst.Operand(0)), nil, nil
-		case !inst.IsABranchInst().IsNil() && inst.OperandsCount() == 3:
-			// conditional branch (if/then/else)
-			cond := fr.getLocal(inst.Operand(0)).Value()
-			if cond.Type() != fr.Mod.Context().Int1Type() {
-				return nil, nil, fr.errorAt(inst, errors.New("expected an i1 in a branch instruction"))
-			}
-			thenBB := inst.Operand(1)
-			elseBB := inst.Operand(2)
-			if !cond.IsAInstruction().IsNil() {
-				return nil, nil, fr.errorAt(inst, errors.New("interp: branch on a non-constant"))
-			}
-			if !cond.IsAConstantExpr().IsNil() {
-				// This may happen when the instruction builder could not
-				// const-fold some instructions.
-				return nil, nil, fr.errorAt(inst, errors.New("interp: branch on a non-const-propagated constant expression"))
-			}
-			switch cond {
-			case llvm.ConstInt(fr.Mod.Context().Int1Type(), 0, false): // false
-				return nil, []llvm.Value{thenBB}, nil // then
-			case llvm.ConstInt(fr.Mod.Context().Int1Type(), 1, false): // true
-				return nil, []llvm.Value{elseBB}, nil // else
-			default:
-				return nil, nil, fr.errorAt(inst, errors.New("branch was not true or false"))
-			}
-		case !inst.IsABranchInst().IsNil() && inst.OperandsCount() == 1:
-			// unconditional branch (goto)
-			return nil, []llvm.Value{inst.Operand(0)}, nil
-		case !inst.IsAUnreachableInst().IsNil():
-			// Unreachable was reached (e.g. after a call to panic()).
-			// Report this as an error, as it is not supposed to happen.
-			// This is a sentinel error value.
-			return nil, nil, errUnreachable
-
-		default:
-			return nil, nil, fr.unsupportedInstructionError(inst)
-		}
-	}
-
-	panic("interp: reached end of basic block without terminator")
-}
-
-// Get the Value for an operand, which is a constant value of some sort.
-func (fr *frame) getLocal(v llvm.Value) Value {
-	if ret, ok := fr.locals[v]; ok {
-		return ret
-	} else if value := fr.getValue(v); value != nil {
-		return value
-	} else {
-		// This should not happen under normal circumstances.
-		panic("cannot find value")
-	}
-}

interp/interp.go

@@ -1,59 +1,77 @@
-// Package interp interprets Go package initializers as much as possible. This
-// avoid running them at runtime, improving code size and making other
-// optimizations possible.
+// Package interp is a partial evaluator of code run at package init time. See
+// the README in this package for details.
 package interp
 
-// This file provides the overarching Eval object with associated (utility)
-// methods.
-
 import (
+	"fmt"
+	"os"
 	"strings"
+	"time"
 
 	"tinygo.org/x/go-llvm"
 )
 
-type Eval struct {
-	Mod             llvm.Module
-	TargetData      llvm.TargetData
-	Debug           bool
-	builder         llvm.Builder
-	dirtyGlobals    map[llvm.Value]struct{}
-	sideEffectFuncs map[llvm.Value]*sideEffectResult // cache of side effect scan results
+// Enable extra checks, which should be disabled by default.
+// This may help track down bugs by adding a few more sanity checks.
+const checks = true
+
+// runner contains all state related to one interp run.
+type runner struct {
+	mod           llvm.Module
+	targetData    llvm.TargetData
+	builder       llvm.Builder
+	pointerSize   uint32                   // cached pointer size from the TargetData
+	i8ptrType     llvm.Type                // often used type so created in advance
+	maxAlign      int                      // maximum alignment of an object, alignment of runtime.alloc() result
+	debug         bool                     // log debug messages
+	pkgName       string                   // package name of the currently executing package
+	functionCache map[llvm.Value]*function // cache of compiled functions
+	objects       []object                 // slice of objects in memory
+	globals       map[llvm.Value]int       // map from global to index in objects slice
+	start         time.Time
+	callsExecuted uint64
 }
 
-// evalPackage encapsulates the Eval type for just a single package. The Eval
-// type keeps state across the whole program, the evalPackage type keeps extra
-// state for the currently interpreted package.
-type evalPackage struct {
-	*Eval
-	packagePath string
-}
-
-// Run evaluates the function with the given name and then eliminates all
-// callers.
+// Run evaluates runtime.initAll function as much as possible at compile time.
+// Set debug to true if it should print output while running.
 func Run(mod llvm.Module, debug bool) error {
-	if debug {
-		println("\ncompile-time evaluation:")
+	r := runner{
+		mod:           mod,
+		targetData:    llvm.NewTargetData(mod.DataLayout()),
+		debug:         debug,
+		functionCache: make(map[llvm.Value]*function),
+		objects:       []object{{}},
+		globals:       make(map[llvm.Value]int),
+		start:         time.Now(),
 	}
+	r.pointerSize = uint32(r.targetData.PointerSize())
+	r.i8ptrType = llvm.PointerType(mod.Context().Int8Type(), 0)
+	r.maxAlign = r.targetData.PrefTypeAlignment(r.i8ptrType) // assume pointers are maximally aligned (this is not always the case)
 
-	name := "runtime.initAll"
-	e := &Eval{
-		Mod:          mod,
-		TargetData:   llvm.NewTargetData(mod.DataLayout()),
-		Debug:        debug,
-		dirtyGlobals: map[llvm.Value]struct{}{},
-	}
-	e.builder = mod.Context().NewBuilder()
-
-	initAll := mod.NamedFunction(name)
+	initAll := mod.NamedFunction("runtime.initAll")
 	bb := initAll.EntryBasicBlock()
+
+	// Create a builder, to insert instructions that could not be evaluated at
+	// compile time.
+	r.builder = mod.Context().NewBuilder()
+	defer r.builder.Dispose()
+
 	// Create a dummy alloca in the entry block that we can set the insert point
 	// to. This is necessary because otherwise we might be removing the
 	// instruction (init call) that we are removing after successful
 	// interpretation.
-	e.builder.SetInsertPointBefore(bb.FirstInstruction())
-	dummy := e.builder.CreateAlloca(e.Mod.Context().Int8Type(), "dummy")
-	e.builder.SetInsertPointBefore(dummy)
+	r.builder.SetInsertPointBefore(bb.FirstInstruction())
+	dummy := r.builder.CreateAlloca(r.mod.Context().Int8Type(), "dummy")
+	r.builder.SetInsertPointBefore(dummy)
+	defer dummy.EraseFromParentAsInstruction()
+
+	// Get a list if init calls. A runtime.initAll might look something like this:
+	// func initAll() {
+	//     unsafe.init()
+	//     machine.init()
+	//     runtime.init()
+	// }
+	// This function gets a list of these call instructions.
 	var initCalls []llvm.Value
 	for inst := bb.FirstInstruction(); !inst.IsNil(); inst = llvm.NextInstruction(inst) {
 		if inst == dummy {
@@ -63,99 +81,67 @@ func Run(mod llvm.Module, debug bool) error {
 			break // ret void
 		}
 		if inst.IsACallInst().IsNil() || inst.CalledValue().IsAFunction().IsNil() {
-			return errorAt(inst, "interp: expected all instructions in "+name+" to be direct calls")
+			return errorAt(inst, "interp: expected all instructions in "+initAll.Name()+" to be direct calls")
 		}
 		initCalls = append(initCalls, inst)
 	}
 
-	// Do this in a separate step to avoid corrupting the iterator above.
-	undefPtr := llvm.Undef(llvm.PointerType(mod.Context().Int8Type(), 0))
+	// Run initializers for each package. Once the package initializer is
+	// finished, the call to the package initializer can be removed.
 	for _, call := range initCalls {
 		initName := call.CalledValue().Name()
 		if !strings.HasSuffix(initName, ".init") {
-			return errorAt(call, "interp: expected all instructions in "+name+" to be *.init() calls")
+			return errorAt(call, "interp: expected all instructions in "+initAll.Name()+" to be *.init() calls")
 		}
-		pkgName := initName[:len(initName)-5]
+		r.pkgName = initName[:len(initName)-len(".init")]
 		fn := call.CalledValue()
+		if r.debug {
+			fmt.Fprintln(os.Stderr, "call:", fn.Name())
+		}
+		_, mem, callErr := r.run(r.getFunction(fn), nil, nil, "    ")
+		if callErr != nil {
+			if isRecoverableError(callErr.Err) {
+				if r.debug {
+					fmt.Fprintln(os.Stderr, "not interpreting", r.pkgName, "because of error:", callErr.Error())
+				}
+				mem.revert()
+				continue
+			}
+			return callErr
+		}
 		call.EraseFromParentAsInstruction()
-		evalPkg := evalPackage{
-			Eval:        e,
-			packagePath: pkgName,
+		for index, obj := range mem.objects {
+			r.objects[index] = obj
 		}
-		_, err := evalPkg.function(fn, []Value{&LocalValue{e, undefPtr}, &LocalValue{e, undefPtr}}, "")
-		if err == errUnreachable {
-			break
+	}
+	r.pkgName = ""
+
+	// Update all global variables in the LLVM module.
+	mem := memoryView{r: &r}
+	for _, obj := range r.objects {
+		if obj.llvmGlobal.IsNil() {
+			continue
 		}
-		if err != nil {
-			return err
+		if obj.buffer == nil {
+			continue
 		}
+		initializer := obj.buffer.toLLVMValue(obj.llvmGlobal.Type().ElementType(), &mem)
+		if checks && initializer.Type() != obj.llvmGlobal.Type().ElementType() {
+			panic("initializer type mismatch")
+		}
+		obj.llvmGlobal.SetInitializer(initializer)
 	}
 
 	return nil
 }
 
-// function interprets the given function. The params are the function params
-// and the indent is the string indentation to use when dumping all interpreted
-// instructions.
-func (e *evalPackage) function(fn llvm.Value, params []Value, indent string) (Value, *Error) {
-	fr := frame{
-		evalPackage: e,
-		fn:          fn,
-		locals:      make(map[llvm.Value]Value),
-	}
-	for i, param := range fn.Params() {
-		fr.locals[param] = params[i]
-	}
-
-	bb := fn.EntryBasicBlock()
-	var lastBB llvm.BasicBlock
-	for {
-		retval, outgoing, err := fr.evalBasicBlock(bb, lastBB, indent)
-		if outgoing == nil {
-			// returned something (a value or void, or an error)
-			return retval, err
-		}
-		if len(outgoing) > 1 {
-			panic("unimplemented: multiple outgoing blocks")
-		}
-		next := outgoing[0]
-		if next.IsABasicBlock().IsNil() {
-			panic("did not switch to a basic block")
-		}
-		lastBB = bb
-		bb = next.AsBasicBlock()
-	}
-}
-
-// getValue determines what kind of LLVM value it gets and returns the
-// appropriate Value type.
-func (e *Eval) getValue(v llvm.Value) Value {
-	return &LocalValue{e, v}
-}
-
-// markDirty marks the passed-in LLVM value dirty, recursively. For example,
-// when it encounters a constant GEP on a global, it marks the global dirty.
-func (e *Eval) markDirty(v llvm.Value) {
-	if !v.IsAGlobalVariable().IsNil() {
-		if v.IsGlobalConstant() {
-			return
-		}
-		if _, ok := e.dirtyGlobals[v]; !ok {
-			e.dirtyGlobals[v] = struct{}{}
-			e.sideEffectFuncs = nil // re-calculate all side effects
-		}
-	} else if v.IsConstant() {
-		if v.OperandsCount() >= 2 && !v.Operand(0).IsAGlobalVariable().IsNil() {
-			// looks like a constant getelementptr of a global.
-			// TODO: find a way to make sure it really is: v.Opcode() returns 0.
-			e.markDirty(v.Operand(0))
-			return
-		}
-		return // nothing to mark
-	} else if !v.IsAGetElementPtrInst().IsNil() {
-		panic("interp: todo: GEP")
-	} else {
-		// Not constant and not a global or GEP so doesn't have to be marked
-		// non-constant.
+// getFunction returns the compiled version of the given LLVM function. It
+// compiles the function if necessary and caches the result.
+func (r *runner) getFunction(llvmFn llvm.Value) *function {
+	if fn, ok := r.functionCache[llvmFn]; ok {
+		return fn
 	}
+	fn := r.compileFunction(llvmFn)
+	r.functionCache[llvmFn] = fn
+	return fn
 }

interp/interp_test.go

@@ -3,6 +3,7 @@ package interp
 import (
 	"io/ioutil"
 	"os"
+	"regexp"
 	"strings"
 	"testing"
 
@@ -41,9 +42,29 @@ func runTest(t *testing.T, pathPrefix string) {
 	// Perform the transform.
 	err = Run(mod, false)
 	if err != nil {
+		if err, match := err.(*Error); match {
+			println(err.Error())
+			if !err.Inst.IsNil() {
+				err.Inst.Dump()
+				println()
+			}
+			if len(err.Traceback) > 0 {
+				println("\ntraceback:")
+				for _, line := range err.Traceback {
+					println(line.Pos.String() + ":")
+					line.Inst.Dump()
+					println()
+				}
+			}
+		}
 		t.Fatal(err)
 	}
 
+	// To be sure, verify that the module is still valid.
+	if llvm.VerifyModule(mod, llvm.PrintMessageAction) != nil {
+		t.FailNow()
+	}
+
 	// Run some cleanup passes to get easy-to-read outputs.
 	pm := llvm.NewPassManager()
 	defer pm.Dispose()
@@ -66,6 +87,8 @@ func runTest(t *testing.T, pathPrefix string) {
 	}
 }
 
+var alignRegexp = regexp.MustCompile(", align [0-9]+$")
+
 // fuzzyEqualIR returns true if the two LLVM IR strings passed in are roughly
 // equal. That means, only relevant lines are compared (excluding comments
 // etc.).
@@ -75,8 +98,18 @@ func fuzzyEqualIR(s1, s2 string) bool {
 	if len(lines1) != len(lines2) {
 		return false
 	}
-	for i, line := range lines1 {
-		if line != lines2[i] {
+	for i, line1 := range lines1 {
+		line2 := lines2[i]
+		match1 := alignRegexp.MatchString(line1)
+		match2 := alignRegexp.MatchString(line2)
+		if match1 != match2 {
+			// Only one of the lines has the align keyword. Remove it.
+			// This is a change to make the test work in both LLVM 10 and LLVM
+			// 11 (LLVM 11 appears to automatically add alignment everywhere).
+			line1 = alignRegexp.ReplaceAllString(line1, "")
+			line2 = alignRegexp.ReplaceAllString(line2, "")
+		}
+		if line1 != line2 {
 			return false
 		}
 	}

interp/interpreter.go

@@ -0,0 +1,932 @@
+package interp
+
+import (
+	"errors"
+	"fmt"
+	"math"
+	"os"
+	"strings"
+	"time"
+
+	"tinygo.org/x/go-llvm"
+)
+
+func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent string) (value, memoryView, *Error) {
+	mem := memoryView{r: r, parent: parentMem}
+	locals := make([]value, len(fn.locals))
+	r.callsExecuted++
+
+	if time.Since(r.start) > time.Minute {
+		// Running for more than a minute. This should never happen.
+		return nil, mem, r.errorAt(fn.blocks[0].instructions[0], fmt.Errorf("interp: running for more than a minute, timing out (executed calls: %d)", r.callsExecuted))
+	}
+
+	// Parameters are considered a kind of local values.
+	for i, param := range params {
+		locals[i] = param
+	}
+
+	// Start with the first basic block and the first instruction.
+	// Branch instructions may modify both bb and instIndex when branching.
+	bb := fn.blocks[0]
+	currentBB := 0
+	lastBB := -1 // last basic block is undefined, only defined after a branch
+	var operands []value
+	for instIndex := 0; instIndex < len(bb.instructions); instIndex++ {
+		inst := bb.instructions[instIndex]
+		operands = operands[:0]
+		isRuntimeInst := false
+		if inst.opcode != llvm.PHI {
+			for _, v := range inst.operands {
+				if v, ok := v.(localValue); ok {
+					if localVal := locals[fn.locals[v.value]]; localVal == nil {
+						return nil, mem, r.errorAt(inst, errors.New("interp: local not defined"))
+					} else {
+						operands = append(operands, localVal)
+						if _, ok := localVal.(localValue); ok {
+							isRuntimeInst = true
+						}
+						continue
+					}
+				}
+				operands = append(operands, v)
+			}
+		}
+		if isRuntimeInst {
+			err := r.runAtRuntime(fn, inst, locals, &mem, indent)
+			if err != nil {
+				return nil, mem, err
+			}
+			continue
+		}
+		switch inst.opcode {
+		case llvm.Ret:
+			if len(operands) != 0 {
+				if r.debug {
+					fmt.Fprintln(os.Stderr, indent+"ret", operands[0])
+				}
+				// Return instruction has a value to return.
+				return operands[0], mem, nil
+			}
+			if r.debug {
+				fmt.Fprintln(os.Stderr, indent+"ret")
+			}
+			// Return instruction doesn't return anything, it's just 'ret void'.
+			return nil, mem, nil
+		case llvm.Br:
+			switch len(operands) {
+			case 1:
+				// Unconditional branch: [nextBB]
+				lastBB = currentBB
+				currentBB = int(operands[0].(literalValue).value.(uint32))
+				bb = fn.blocks[currentBB]
+				instIndex = -1 // start at 0 the next cycle
+				if r.debug {
+					fmt.Fprintln(os.Stderr, indent+"br", operands, "->", currentBB)
+				}
+			case 3:
+				// Conditional branch: [cond, thenBB, elseBB]
+				lastBB = currentBB
+				switch operands[0].Uint() {
+				case 1: // true -> thenBB
+					currentBB = int(operands[1].(literalValue).value.(uint32))
+				case 0: // false -> elseBB
+					currentBB = int(operands[2].(literalValue).value.(uint32))
+				default:
+					panic("bool should be 0 or 1")
+				}
+				if r.debug {
+					fmt.Fprintln(os.Stderr, indent+"br", operands, "->", currentBB)
+				}
+				bb = fn.blocks[currentBB]
+				instIndex = -1 // start at 0 the next cycle
+			default:
+				panic("unknown operands length")
+			}
+			break // continue with next block
+		case llvm.PHI:
+			var result value
+			for i := 0; i < len(inst.operands); i += 2 {
+				if int(inst.operands[i].(literalValue).value.(uint32)) == lastBB {
+					incoming := inst.operands[i+1]
+					if local, ok := incoming.(localValue); ok {
+						result = locals[fn.locals[local.value]]
+					} else {
+						result = incoming
+					}
+					break
+				}
+			}
+			if r.debug {
+				fmt.Fprintln(os.Stderr, indent+"phi", inst.operands, "->", result)
+			}
+			if result == nil {
+				panic("could not find PHI input")
+			}
+			locals[inst.localIndex] = result
+		case llvm.Select:
+			// Select is much like a ternary operator: it picks a result from
+			// the second and third operand based on the boolean first operand.
+			var result value
+			switch operands[0].Uint() {
+			case 1:
+				result = operands[1]
+			case 0:
+				result = operands[2]
+			default:
+				panic("boolean must be 0 or 1")
+			}
+			locals[inst.localIndex] = result
+			if r.debug {
+				fmt.Fprintln(os.Stderr, indent+"select", operands, "->", result)
+			}
+		case llvm.Call:
+			// A call instruction can either be a regular call or a runtime intrinsic.
+			fnPtr, err := operands[0].asPointer(r)
+			if err != nil {
+				return nil, mem, r.errorAt(inst, err)
+			}
+			callFn := r.getFunction(fnPtr.llvmValue(&mem))
+			switch {
+			case callFn.name == "runtime.trackPointer":
+				// Allocas and such are created as globals, so don't need a
+				// runtime.trackPointer.
+				// Unless the object is allocated at runtime for example, in
+				// which case this call won't even get to this point but will
+				// already be emitted in initAll.
+				continue
+			case callFn.name == "(reflect.Type).Elem" || strings.HasPrefix(callFn.name, "runtime.print") || callFn.name == "runtime._panic" || callFn.name == "runtime.hashmapGet":
+				// These functions should be run at runtime. Specifically:
+				//   * (reflect.Type).Elem is a special function. It should
+				//     eventually be interpreted, but fall back to a runtime call
+				//     for now.
+				//   * Print and panic functions are best emitted directly without
+				//     interpreting them, otherwise we get a ton of putchar (etc.)
+				//     calls.
+				//   * runtime.hashmapGet tries to access the map value directly.
+				//     This is not possible as the map value is treated as a special
+				//     kind of object in this package.
+				err := r.runAtRuntime(fn, inst, locals, &mem, indent)
+				if err != nil {
+					return nil, mem, err
+				}
+			case callFn.name == "runtime.nanotime" && r.pkgName == "time":
+				// The time package contains a call to runtime.nanotime.
+				// This appears to be to work around a limitation in Windows
+				// Server 2008:
+				//   > Monotonic times are reported as offsets from startNano.
+				//   > We initialize startNano to runtimeNano() - 1 so that on systems where
+				//   > monotonic time resolution is fairly low (e.g. Windows 2008
+				//   > which appears to have a default resolution of 15ms),
+				//   > we avoid ever reporting a monotonic time of 0.
+				//   > (Callers may want to use 0 as "time not set".)
+				// Simply let runtime.nanotime return 0 in this case, which
+				// should be fine and avoids a call to runtime.nanotime. It
+				// means that monotonic time in the time package is counted from
+				// time.Time{}.Sub(1), which should be fine.
+				locals[inst.localIndex] = literalValue{uint64(0)}
+			case callFn.name == "runtime.alloc":
+				// Allocate heap memory. At compile time, this is instead done
+				// by creating a global variable.
+
+				// Get the requested memory size to be allocated.
+				size := operands[1].Uint()
+
+				// Create the object.
+				alloc := object{
+					globalName: r.pkgName + "$alloc",
+					buffer:     newRawValue(uint32(size)),
+					size:       uint32(size),
+				}
+				index := len(r.objects)
+				r.objects = append(r.objects, alloc)
+
+				// And create a pointer to this object, for working with it (so
+				// that stores to it copy it, etc).
+				ptr := newPointerValue(r, index, 0)
+				if r.debug {
+					fmt.Fprintln(os.Stderr, indent+"runtime.alloc:", size, "->", ptr)
+				}
+				locals[inst.localIndex] = ptr
+			case callFn.name == "runtime.sliceCopy":
+				// sliceCopy implements the built-in copy function for slices.
+				// It is implemented here so that it can be used even if the
+				// runtime implementation is not available. Doing it this way
+				// may also be faster.
+				// Code:
+				// func sliceCopy(dst, src unsafe.Pointer, dstLen, srcLen uintptr, elemSize uintptr) int {
+				//     n := srcLen
+				//     if n > dstLen {
+				//         n = dstLen
+				//     }
+				//     memmove(dst, src, n*elemSize)
+				//     return int(n)
+				// }
+				dstLen := operands[3].Uint()
+				srcLen := operands[4].Uint()
+				elemSize := operands[5].Uint()
+				n := srcLen
+				if n > dstLen {
+					n = dstLen
+				}
+				if r.debug {
+					fmt.Fprintln(os.Stderr, indent+"copy:", operands[1], operands[2], n)
+				}
+				if n != 0 {
+					// Only try to copy bytes when there are any bytes to copy.
+					// This is not just an optimization. If one of the slices
+					// (or both) are nil, the asPointer method call will fail
+					// even though copying a nil slice is allowed.
+					dst, err := operands[1].asPointer(r)
+					if err != nil {
+						return nil, mem, r.errorAt(inst, err)
+					}
+					src, err := operands[2].asPointer(r)
+					if err != nil {
+						return nil, mem, r.errorAt(inst, err)
+					}
+					nBytes := uint32(n * elemSize)
+					dstObj := mem.getWritable(dst.index())
+					dstBuf := dstObj.buffer.asRawValue(r)
+					srcBuf := mem.get(src.index()).buffer.asRawValue(r)
+					copy(dstBuf.buf[dst.offset():dst.offset()+nBytes], srcBuf.buf[src.offset():])
+					dstObj.buffer = dstBuf
+					mem.put(dst.index(), dstObj)
+				}
+				switch inst.llvmInst.Type().IntTypeWidth() {
+				case 16:
+					locals[inst.localIndex] = literalValue{uint16(n)}
+				case 32:
+					locals[inst.localIndex] = literalValue{uint32(n)}
+				case 64:
+					locals[inst.localIndex] = literalValue{uint64(n)}
+				default:
+					panic("unknown integer type width")
+				}
+			case strings.HasPrefix(callFn.name, "llvm.memcpy.p0i8.p0i8.") || strings.HasPrefix(callFn.name, "llvm.memmove.p0i8.p0i8."):
+				// Copy a block of memory from one pointer to another.
+				dst, err := operands[1].asPointer(r)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
+				}
+				src, err := operands[2].asPointer(r)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
+				}
+				nBytes := uint32(operands[3].Uint())
+				dstObj := mem.getWritable(dst.index())
+				dstBuf := dstObj.buffer.asRawValue(r)
+				srcBuf := mem.get(src.index()).buffer.asRawValue(r)
+				copy(dstBuf.buf[dst.offset():dst.offset()+nBytes], srcBuf.buf[src.offset():])
+				dstObj.buffer = dstBuf
+				mem.put(dst.index(), dstObj)
+			case callFn.name == "runtime.typeAssert":
+				// This function must be implemented manually as it is normally
+				// implemented by the interface lowering pass.
+				if r.debug {
+					fmt.Fprintln(os.Stderr, indent+"typeassert:", operands[1:])
+				}
+				typeInInterfacePtr, err := operands[1].asPointer(r)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
+				}
+				actualType, err := mem.load(typeInInterfacePtr, r.pointerSize).asPointer(r)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
+				}
+				assertedType, err := operands[2].asPointer(r)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
+				}
+				result := assertedType.asRawValue(r).equal(actualType.asRawValue(r))
+				if result {
+					locals[inst.localIndex] = literalValue{uint8(1)}
+				} else {
+					locals[inst.localIndex] = literalValue{uint8(0)}
+				}
+			case callFn.name == "runtime.interfaceImplements":
+				if r.debug {
+					fmt.Fprintln(os.Stderr, indent+"interface assert:", operands[1:])
+				}
+
+				// Load various values for the interface implements check below.
+				typeInInterfacePtr, err := operands[1].asPointer(r)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
+				}
+				methodSetPtr, err := mem.load(typeInInterfacePtr.addOffset(r.pointerSize), r.pointerSize).asPointer(r)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
+				}
+				methodSet := mem.get(methodSetPtr.index()).llvmGlobal.Initializer()
+				interfaceMethodSetPtr, err := operands[2].asPointer(r)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
+				}
+				interfaceMethodSet := mem.get(interfaceMethodSetPtr.index()).llvmGlobal.Initializer()
+
+				// Make a set of all the methods on the concrete type, for
+				// easier checking in the next step.
+				concreteTypeMethods := map[string]struct{}{}
+				for i := 0; i < methodSet.Type().ArrayLength(); i++ {
+					methodInfo := llvm.ConstExtractValue(methodSet, []uint32{uint32(i)})
+					name := llvm.ConstExtractValue(methodInfo, []uint32{0}).Name()
+					concreteTypeMethods[name] = struct{}{}
+				}
+
+				// Check whether all interface methods are also in the list
+				// of defined methods calculated above. This is the interface
+				// assert itself.
+				assertOk := uint8(1) // i1 true
+				for i := 0; i < interfaceMethodSet.Type().ArrayLength(); i++ {
+					name := llvm.ConstExtractValue(interfaceMethodSet, []uint32{uint32(i)}).Name()
+					if _, ok := concreteTypeMethods[name]; !ok {
+						// There is a method on the interface that is not
+						// implemented by the type. The assertion will fail.
+						assertOk = 0 // i1 false
+						break
+					}
+				}
+				// If assertOk is still 1, the assertion succeeded.
+				locals[inst.localIndex] = literalValue{assertOk}
+			case callFn.name == "runtime.hashmapMake":
+				// Create a new map.
+				hashmapPointerType := inst.llvmInst.Type()
+				keySize := uint32(operands[1].Uint())
+				valueSize := uint32(operands[2].Uint())
+				m := newMapValue(r, hashmapPointerType, keySize, valueSize)
+				alloc := object{
+					llvmType:   hashmapPointerType,
+					globalName: r.pkgName + "$map",
+					buffer:     m,
+					size:       m.len(r),
+				}
+				index := len(r.objects)
+				r.objects = append(r.objects, alloc)
+
+				// Create a pointer to this map. Maps are reference types, so
+				// are implemented as pointers.
+				ptr := newPointerValue(r, index, 0)
+				if r.debug {
+					fmt.Fprintln(os.Stderr, indent+"runtime.hashmapMake:", keySize, valueSize, "->", ptr)
+				}
+				locals[inst.localIndex] = ptr
+			case callFn.name == "runtime.hashmapBinarySet":
+				// Do a mapassign operation with a binary key (that is, without
+				// a string key).
+				if r.debug {
+					fmt.Fprintln(os.Stderr, indent+"runtime.hashmapBinarySet:", operands[1:])
+				}
+				mapPtr, err := operands[1].asPointer(r)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
+				}
+				m := mem.getWritable(mapPtr.index()).buffer.(*mapValue)
+				keyPtr, err := operands[2].asPointer(r)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
+				}
+				valuePtr, err := operands[3].asPointer(r)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
+				}
+				err = m.putBinary(&mem, keyPtr, valuePtr)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
+				}
+			case callFn.name == "runtime.hashmapStringSet":
+				// Do a mapassign operation with a string key.
+				if r.debug {
+					fmt.Fprintln(os.Stderr, indent+"runtime.hashmapBinarySet:", operands[1:])
+				}
+				mapPtr, err := operands[1].asPointer(r)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
+				}
+				m := mem.getWritable(mapPtr.index()).buffer.(*mapValue)
+				stringPtr, err := operands[2].asPointer(r)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
+				}
+				stringLen := operands[3].Uint()
+				valuePtr, err := operands[4].asPointer(r)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
+				}
+				err = m.putString(&mem, stringPtr, stringLen, valuePtr)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
+				}
+			default:
+				if len(callFn.blocks) == 0 {
+					// Call to a function declaration without a definition
+					// available.
+					err := r.runAtRuntime(fn, inst, locals, &mem, indent)
+					if err != nil {
+						return nil, mem, err
+					}
+					continue
+				}
+				// Call a function with a definition available. Run it as usual,
+				// possibly trying to recover from it if it failed to execute.
+				if r.debug {
+					argStrings := make([]string, len(operands)-1)
+					for i := range argStrings {
+						argStrings[i] = operands[i+1].String()
+					}
+					fmt.Fprintln(os.Stderr, indent+"call:", callFn.name+"("+strings.Join(argStrings, ", ")+")")
+				}
+				retval, callMem, callErr := r.run(callFn, operands[1:], &mem, indent+"    ")
+				if callErr != nil {
+					if isRecoverableError(callErr.Err) {
+						// This error can be recovered by doing the call at
+						// runtime instead of at compile time. But we need to
+						// revert any changes made by the call first.
+						if r.debug {
+							fmt.Fprintln(os.Stderr, indent+"!! revert because of error:", callErr.Err)
+						}
+						callMem.revert()
+						err := r.runAtRuntime(fn, inst, locals, &mem, indent)
+						if err != nil {
+							return nil, mem, err
+						}
+						continue
+					}
+					// Add to the traceback, so that error handling code can see
+					// how this function got called.
+					callErr.Traceback = append(callErr.Traceback, ErrorLine{
+						Pos:  getPosition(inst.llvmInst),
+						Inst: inst.llvmInst,
+					})
+					return nil, mem, callErr
+				}
+				locals[inst.localIndex] = retval
+				mem.extend(callMem)
+			}
+		case llvm.Load:
+			// Load instruction, loading some data from the topmost memory view.
+			ptr, err := operands[0].asPointer(r)
+			if err != nil {
+				return nil, mem, r.errorAt(inst, err)
+			}
+			size := operands[1].(literalValue).value.(uint64)
+			if mem.hasExternalStore(ptr) {
+				// If there could be an external store (for example, because a
+				// pointer to the object was passed to a function that could not
+				// be interpreted at compile time) then the load must be done at
+				// runtime.
+				err := r.runAtRuntime(fn, inst, locals, &mem, indent)
+				if err != nil {
+					return nil, mem, err
+				}
+				continue
+			}
+			result := mem.load(ptr, uint32(size))
+			if r.debug {
+				fmt.Fprintln(os.Stderr, indent+"load:", ptr, "->", result)
+			}
+			locals[inst.localIndex] = result
+		case llvm.Store:
+			// Store instruction. Create a new object in the memory view and
+			// store to that, to make it possible to roll back this store.
+			ptr, err := operands[1].asPointer(r)
+			if err != nil {
+				return nil, mem, r.errorAt(inst, err)
+			}
+			if mem.hasExternalLoadOrStore(ptr) {
+				err := r.runAtRuntime(fn, inst, locals, &mem, indent)
+				if err != nil {
+					return nil, mem, err
+				}
+				continue
+			}
+			val := operands[0]
+			if r.debug {
+				fmt.Fprintln(os.Stderr, indent+"store:", val, ptr)
+			}
+			mem.store(val, ptr)
+		case llvm.Alloca:
+			// Alloca normally allocates some stack memory. In the interpreter,
+			// it allocates a global instead.
+			// This can likely be optimized, as all it really needs is an alloca
+			// in the initAll function and creating a global is wasteful for
+			// this purpose.
+
+			// Create the new object.
+			size := operands[0].(literalValue).value.(uint64)
+			alloca := object{
+				llvmType:   inst.llvmInst.Type(),
+				globalName: r.pkgName + "$alloca",
+				buffer:     newRawValue(uint32(size)),
+				size:       uint32(size),
+			}
+			index := len(r.objects)
+			r.objects = append(r.objects, alloca)
+
+			// Create a pointer to this object (an alloca produces a pointer).
+			ptr := newPointerValue(r, index, 0)
+			if r.debug {
+				fmt.Fprintln(os.Stderr, indent+"alloca:", operands, "->", ptr)
+			}
+			locals[inst.localIndex] = ptr
+		case llvm.GetElementPtr:
+			// GetElementPtr does pointer arithmetic, changing the offset of the
+			// pointer into the underlying object.
+			var offset uint64
+			var gepOperands []uint64
+			for i := 2; i < len(operands); i += 2 {
+				index := operands[i].Uint()
+				elementSize := operands[i+1].Uint()
+				if int64(elementSize) < 0 {
+					// This is a struct field.
+					// The field number is encoded by flipping all the bits.
+					gepOperands = append(gepOperands, ^elementSize)
+					offset += index
+				} else {
+					// This is a normal GEP, probably an array index.
+					gepOperands = append(gepOperands, index)
+					offset += elementSize * index
+				}
+			}
+			ptr, err := operands[0].asPointer(r)
+			if err != nil {
+				if err != errIntegerAsPointer {
+					return nil, mem, r.errorAt(inst, err)
+				}
+				// GEP on fixed pointer value (for example, memory-mapped I/O).
+				ptrValue := operands[0].Uint() + offset
+				switch operands[0].len(r) {
+				case 8:
+					locals[inst.localIndex] = literalValue{uint64(ptrValue)}
+				case 4:
+					locals[inst.localIndex] = literalValue{uint32(ptrValue)}
+				case 2:
+					locals[inst.localIndex] = literalValue{uint16(ptrValue)}
+				default:
+					panic("pointer operand is not of a known pointer size")
+				}
+				continue
+			}
+			ptr = ptr.addOffset(uint32(offset))
+			locals[inst.localIndex] = ptr
+			if r.debug {
+				fmt.Fprintln(os.Stderr, indent+"gep:", operands, "->", ptr)
+			}
+		case llvm.BitCast, llvm.IntToPtr, llvm.PtrToInt:
+			// Various bitcast-like instructions that all keep the same bits
+			// while changing the LLVM type.
+			// Because interp doesn't preserve the type, these operations are
+			// identity operations.
+			if r.debug {
+				fmt.Fprintln(os.Stderr, indent+instructionNameMap[inst.opcode]+":", operands[0])
+			}
+			locals[inst.localIndex] = operands[0]
+		case llvm.ExtractValue:
+			agg := operands[0].asRawValue(r)
+			offset := operands[1].(literalValue).value.(uint64)
+			size := operands[2].(literalValue).value.(uint64)
+			elt := rawValue{
+				buf: agg.buf[offset : offset+size],
+			}
+			if r.debug {
+				fmt.Fprintln(os.Stderr, indent+"extractvalue:", operands, "->", elt)
+			}
+			locals[inst.localIndex] = elt
+		case llvm.InsertValue:
+			agg := operands[0].asRawValue(r)
+			elt := operands[1].asRawValue(r)
+			offset := int(operands[2].(literalValue).value.(uint64))
+			newagg := newRawValue(uint32(len(agg.buf)))
+			copy(newagg.buf, agg.buf)
+			copy(newagg.buf[offset:], elt.buf)
+			if r.debug {
+				fmt.Fprintln(os.Stderr, indent+"insertvalue:", operands, "->", newagg)
+			}
+			locals[inst.localIndex] = newagg
+		case llvm.ICmp:
+			predicate := llvm.IntPredicate(operands[2].(literalValue).value.(uint8))
+			var result bool
+			lhs := operands[0]
+			rhs := operands[1]
+			switch predicate {
+			case llvm.IntEQ, llvm.IntNE:
+				lhsPointer, lhsErr := lhs.asPointer(r)
+				rhsPointer, rhsErr := rhs.asPointer(r)
+				if (lhsErr == nil) != (rhsErr == nil) {
+					// Fast path: only one is a pointer, so they can't be equal.
+					result = false
+				} else if lhsErr == nil {
+					// Both must be nil, so both are pointers.
+					// Compare them directly.
+					result = lhsPointer.equal(rhsPointer)
+				} else {
+					// Fall back to generic comparison.
+					result = lhs.asRawValue(r).equal(rhs.asRawValue(r))
+				}
+				if predicate == llvm.IntNE {
+					result = !result
+				}
+			case llvm.IntUGT:
+				result = lhs.Uint() > rhs.Uint()
+			case llvm.IntUGE:
+				result = lhs.Uint() >= rhs.Uint()
+			case llvm.IntULT:
+				result = lhs.Uint() < rhs.Uint()
+			case llvm.IntULE:
+				result = lhs.Uint() <= rhs.Uint()
+			case llvm.IntSGT:
+				result = lhs.Int() > rhs.Int()
+			case llvm.IntSGE:
+				result = lhs.Int() >= rhs.Int()
+			case llvm.IntSLT:
+				result = lhs.Int() < rhs.Int()
+			case llvm.IntSLE:
+				result = lhs.Int() <= rhs.Int()
+			default:
+				return nil, mem, r.errorAt(inst, errors.New("interp: unsupported icmp"))
+			}
+			if result {
+				locals[inst.localIndex] = literalValue{uint8(1)}
+			} else {
+				locals[inst.localIndex] = literalValue{uint8(0)}
+			}
+			if r.debug {
+				fmt.Fprintln(os.Stderr, indent+"icmp:", operands[0], intPredicateString(predicate), operands[1], "->", result)
+			}
+		case llvm.FCmp:
+			predicate := llvm.FloatPredicate(operands[2].(literalValue).value.(uint8))
+			var result bool
+			var lhs, rhs float64
+			switch operands[0].len(r) {
+			case 8:
+				lhs = math.Float64frombits(operands[0].Uint())
+				rhs = math.Float64frombits(operands[1].Uint())
+			case 4:
+				lhs = float64(math.Float32frombits(uint32(operands[0].Uint())))
+				rhs = float64(math.Float32frombits(uint32(operands[1].Uint())))
+			default:
+				panic("unknown float type")
+			}
+			switch predicate {
+			case llvm.FloatOEQ:
+				result = lhs == rhs
+			case llvm.FloatUNE:
+				result = lhs != rhs
+			case llvm.FloatOGT:
+				result = lhs > rhs
+			case llvm.FloatOGE:
+				result = lhs >= rhs
+			case llvm.FloatOLT:
+				result = lhs < rhs
+			case llvm.FloatOLE:
+				result = lhs <= rhs
+			default:
+				return nil, mem, r.errorAt(inst, errors.New("interp: unsupported fcmp"))
+			}
+			if result {
+				locals[inst.localIndex] = literalValue{uint8(1)}
+			} else {
+				locals[inst.localIndex] = literalValue{uint8(0)}
+			}
+			if r.debug {
+				fmt.Fprintln(os.Stderr, indent+"fcmp:", operands[0], predicate, operands[1], "->", result)
+			}
+		case llvm.Add, llvm.Sub, llvm.Mul, llvm.UDiv, llvm.SDiv, llvm.URem, llvm.SRem, llvm.Shl, llvm.LShr, llvm.AShr, llvm.And, llvm.Or, llvm.Xor:
+			// Integer binary operations.
+			lhs := operands[0]
+			rhs := operands[1]
+			lhsPtr, err := lhs.asPointer(r)
+			if err == nil {
+				// The lhs is a pointer. This sometimes happens for particular
+				// pointer tricks.
+				switch inst.opcode {
+				case llvm.Add:
+					// This likely means this is part of a
+					// unsafe.Pointer(uintptr(ptr) + offset) pattern.
+					lhsPtr = lhsPtr.addOffset(uint32(rhs.Uint()))
+					locals[inst.localIndex] = lhsPtr
+					continue
+				case llvm.Xor:
+					if rhs.Uint() == 0 {
+						// Special workaround for strings.noescape, see
+						// src/strings/builder.go in the Go source tree. This is
+						// the identity operator, so we can return the input.
+						locals[inst.localIndex] = lhs
+						continue
+					}
+				default:
+					// Catch-all for weird operations that should just be done
+					// at runtime.
+					err := r.runAtRuntime(fn, inst, locals, &mem, indent)
+					if err != nil {
+						return nil, mem, err
+					}
+					continue
+				}
+			}
+			var result uint64
+			switch inst.opcode {
+			case llvm.Add:
+				result = lhs.Uint() + rhs.Uint()
+			case llvm.Sub:
+				result = lhs.Uint() - rhs.Uint()
+			case llvm.Mul:
+				result = lhs.Uint() * rhs.Uint()
+			case llvm.UDiv:
+				result = lhs.Uint() / rhs.Uint()
+			case llvm.SDiv:
+				result = uint64(lhs.Int() / rhs.Int())
+			case llvm.URem:
+				result = lhs.Uint() % rhs.Uint()
+			case llvm.SRem:
+				result = uint64(lhs.Int() % rhs.Int())
+			case llvm.Shl:
+				result = lhs.Uint() << rhs.Uint()
+			case llvm.LShr:
+				result = lhs.Uint() >> rhs.Uint()
+			case llvm.AShr:
+				result = uint64(lhs.Int() >> rhs.Uint())
+			case llvm.And:
+				result = lhs.Uint() & rhs.Uint()
+			case llvm.Or:
+				result = lhs.Uint() | rhs.Uint()
+			case llvm.Xor:
+				result = lhs.Uint() ^ rhs.Uint()
+			default:
+				panic("unreachable")
+			}
+			switch lhs.len(r) {
+			case 8:
+				locals[inst.localIndex] = literalValue{result}
+			case 4:
+				locals[inst.localIndex] = literalValue{uint32(result)}
+			case 2:
+				locals[inst.localIndex] = literalValue{uint16(result)}
+			case 1:
+				locals[inst.localIndex] = literalValue{uint8(result)}
+			default:
+				panic("unknown integer size")
+			}
+			if r.debug {
+				fmt.Fprintln(os.Stderr, indent+instructionNameMap[inst.opcode]+":", lhs, rhs, "->", result)
+			}
+		case llvm.SExt, llvm.ZExt, llvm.Trunc:
+			// Change the size of an integer to a larger or smaller bit width.
+			// We make use of the fact that the Uint() function already
+			// zero-extends the value and that Int() already sign-extends the
+			// value, so we only need to truncate it to the appropriate bit
+			// width. This means we can implement sext, zext and trunc in the
+			// same way, by first {zero,sign}extending all the way up to uint64
+			// and then truncating it as necessary.
+			var value uint64
+			if inst.opcode == llvm.SExt {
+				value = uint64(operands[0].Int())
+			} else {
+				value = operands[0].Uint()
+			}
+			bitwidth := operands[1].Uint()
+			if r.debug {
+				fmt.Fprintln(os.Stderr, indent+instructionNameMap[inst.opcode]+":", value, bitwidth)
+			}
+			switch bitwidth {
+			case 64:
+				locals[inst.localIndex] = literalValue{value}
+			case 32:
+				locals[inst.localIndex] = literalValue{uint32(value)}
+			case 16:
+				locals[inst.localIndex] = literalValue{uint16(value)}
+			case 8:
+				locals[inst.localIndex] = literalValue{uint8(value)}
+			default:
+				panic("unknown integer size in sext/zext/trunc")
+			}
+		case llvm.SIToFP, llvm.UIToFP:
+			var value float64
+			switch inst.opcode {
+			case llvm.SIToFP:
+				value = float64(operands[0].Int())
+			case llvm.UIToFP:
+				value = float64(operands[0].Uint())
+			}
+			bitwidth := operands[1].Uint()
+			if r.debug {
+				fmt.Fprintln(os.Stderr, indent+instructionNameMap[inst.opcode]+":", value, bitwidth)
+			}
+			switch bitwidth {
+			case 64:
+				locals[inst.localIndex] = literalValue{math.Float64bits(value)}
+			case 32:
+				locals[inst.localIndex] = literalValue{math.Float32bits(float32(value))}
+			default:
+				panic("unknown integer size in sitofp/uitofp")
+			}
+		default:
+			if r.debug {
+				fmt.Fprintln(os.Stderr, indent+inst.String())
+			}
+			return nil, mem, r.errorAt(inst, errUnsupportedInst)
+		}
+	}
+	return nil, mem, r.errorAt(bb.instructions[len(bb.instructions)-1], errors.New("interp: reached end of basic block without terminator"))
+}
+
+func (r *runner) runAtRuntime(fn *function, inst instruction, locals []value, mem *memoryView, indent string) *Error {
+	numOperands := inst.llvmInst.OperandsCount()
+	operands := make([]llvm.Value, numOperands)
+	for i := 0; i < numOperands; i++ {
+		operand := inst.llvmInst.Operand(i)
+		if !operand.IsAInstruction().IsNil() || !operand.IsAArgument().IsNil() {
+			operand = locals[fn.locals[operand]].toLLVMValue(operand.Type(), mem)
+		}
+		operands[i] = operand
+	}
+	if r.debug {
+		fmt.Fprintln(os.Stderr, indent+inst.String())
+	}
+	var result llvm.Value
+	switch inst.opcode {
+	case llvm.Call:
+		llvmFn := operands[len(operands)-1]
+		args := operands[:len(operands)-1]
+		for _, arg := range args {
+			if arg.Type().TypeKind() == llvm.PointerTypeKind {
+				mem.markExternalStore(arg)
+			}
+		}
+		result = r.builder.CreateCall(llvmFn, args, inst.name)
+	case llvm.Load:
+		mem.markExternalLoad(operands[0])
+		result = r.builder.CreateLoad(operands[0], inst.name)
+		if inst.llvmInst.IsVolatile() {
+			result.SetVolatile(true)
+		}
+	case llvm.Store:
+		mem.markExternalStore(operands[1])
+		result = r.builder.CreateStore(operands[0], operands[1])
+		if inst.llvmInst.IsVolatile() {
+			result.SetVolatile(true)
+		}
+	case llvm.BitCast:
+		result = r.builder.CreateBitCast(operands[0], inst.llvmInst.Type(), inst.name)
+	case llvm.ExtractValue:
+		indices := inst.llvmInst.Indices()
+		if len(indices) != 1 {
+			panic("expected exactly one index")
+		}
+		result = r.builder.CreateExtractValue(operands[0], int(indices[0]), inst.name)
+	case llvm.InsertValue:
+		indices := inst.llvmInst.Indices()
+		if len(indices) != 1 {
+			panic("expected exactly one index")
+		}
+		result = r.builder.CreateInsertValue(operands[0], operands[1], int(indices[0]), inst.name)
+	case llvm.Add:
+		result = r.builder.CreateAdd(operands[0], operands[1], inst.name)
+	case llvm.Sub:
+		result = r.builder.CreateSub(operands[0], operands[1], inst.name)
+	case llvm.Mul:
+		result = r.builder.CreateMul(operands[0], operands[1], inst.name)
+	case llvm.UDiv:
+		result = r.builder.CreateUDiv(operands[0], operands[1], inst.name)
+	case llvm.SDiv:
+		result = r.builder.CreateSDiv(operands[0], operands[1], inst.name)
+	case llvm.URem:
+		result = r.builder.CreateURem(operands[0], operands[1], inst.name)
+	case llvm.SRem:
+		result = r.builder.CreateSRem(operands[0], operands[1], inst.name)
+	case llvm.ZExt:
+		result = r.builder.CreateZExt(operands[0], inst.llvmInst.Type(), inst.name)
+	default:
+		return r.errorAt(inst, errUnsupportedRuntimeInst)
+	}
+	locals[inst.localIndex] = localValue{result}
+	mem.instructions = append(mem.instructions, result)
+	return nil
+}
+
+func intPredicateString(predicate llvm.IntPredicate) string {
+	switch predicate {
+	case llvm.IntEQ:
+		return "eq"
+	case llvm.IntNE:
+		return "ne"
+	case llvm.IntUGT:
+		return "ugt"
+	case llvm.IntUGE:
+		return "uge"
+	case llvm.IntULT:
+		return "ult"
+	case llvm.IntULE:
+		return "ule"
+	case llvm.IntSGT:
+		return "sgt"
+	case llvm.IntSGE:
+		return "sge"
+	case llvm.IntSLT:
+		return "slt"
+	case llvm.IntSLE:
+		return "sle"
+	default:
+		return "cmp?"
+	}
+}

interp/scan.go

@@ -1,259 +0,0 @@
-package interp
-
-import (
-	"errors"
-	"strings"
-
-	"tinygo.org/x/go-llvm"
-)
-
-type sideEffectSeverity int
-
-func (severity sideEffectSeverity) String() string {
-	switch severity {
-	case sideEffectInProgress:
-		return "in progress"
-	case sideEffectNone:
-		return "none"
-	case sideEffectLimited:
-		return "limited"
-	case sideEffectAll:
-		return "all"
-	default:
-		return "unknown"
-	}
-}
-
-const (
-	sideEffectInProgress sideEffectSeverity = iota // computing side effects is in progress (for recursive functions)
-	sideEffectNone                                 // no side effects at all (pure)
-	sideEffectLimited                              // has side effects, but the effects are known
-	sideEffectAll                                  // has unknown side effects
-)
-
-// sideEffectResult contains the scan results after scanning a function for side
-// effects (recursively).
-type sideEffectResult struct {
-	severity        sideEffectSeverity
-	mentionsGlobals map[llvm.Value]struct{}
-}
-
-// hasSideEffects scans this function and all descendants, recursively. It
-// returns whether this function has side effects and if it does, which globals
-// it mentions anywhere in this function or any called functions.
-func (e *evalPackage) hasSideEffects(fn llvm.Value) (*sideEffectResult, *Error) {
-	name := fn.Name()
-	switch {
-	case name == "runtime.alloc":
-		// Cannot be scanned but can be interpreted.
-		return &sideEffectResult{severity: sideEffectNone}, nil
-	case name == "runtime.nanotime":
-		// Fixed value at compile time.
-		return &sideEffectResult{severity: sideEffectNone}, nil
-	case name == "runtime._panic":
-		return &sideEffectResult{severity: sideEffectLimited}, nil
-	case name == "runtime.typeAssert":
-		return &sideEffectResult{severity: sideEffectNone}, nil
-	case name == "runtime.interfaceImplements":
-		return &sideEffectResult{severity: sideEffectNone}, nil
-	case name == "runtime.sliceCopy":
-		return &sideEffectResult{severity: sideEffectNone}, nil
-	case name == "runtime.trackPointer":
-		return &sideEffectResult{severity: sideEffectNone}, nil
-	case name == "llvm.dbg.value":
-		return &sideEffectResult{severity: sideEffectNone}, nil
-	case name == "(*sync/atomic.Value).Load" || name == "(*sync/atomic.Value).Store":
-		// These functions do some unsafe pointer loading/storing but are
-		// otherwise safe.
-		return &sideEffectResult{severity: sideEffectLimited}, nil
-	case strings.HasPrefix(name, "llvm.lifetime."):
-		return &sideEffectResult{severity: sideEffectNone}, nil
-	}
-	if fn.IsDeclaration() {
-		return &sideEffectResult{severity: sideEffectLimited}, nil
-	}
-	if e.sideEffectFuncs == nil {
-		e.sideEffectFuncs = make(map[llvm.Value]*sideEffectResult)
-	}
-	if se, ok := e.sideEffectFuncs[fn]; ok {
-		return se, nil
-	}
-	result := &sideEffectResult{
-		severity:        sideEffectInProgress,
-		mentionsGlobals: map[llvm.Value]struct{}{},
-	}
-	e.sideEffectFuncs[fn] = result
-	dirtyLocals := map[llvm.Value]struct{}{}
-	for bb := fn.EntryBasicBlock(); !bb.IsNil(); bb = llvm.NextBasicBlock(bb) {
-		for inst := bb.FirstInstruction(); !inst.IsNil(); inst = llvm.NextInstruction(inst) {
-			if inst.IsAInstruction().IsNil() {
-				// Should not happen in valid IR.
-				panic("not an instruction")
-			}
-
-			// Check for any globals mentioned anywhere in the function. Assume
-			// any mentioned globals may be read from or written to when
-			// executed, thus must be marked dirty with a call.
-			for i := 0; i < inst.OperandsCount(); i++ {
-				operand := inst.Operand(i)
-				if !operand.IsAGlobalVariable().IsNil() {
-					result.mentionsGlobals[operand] = struct{}{}
-				}
-			}
-
-			switch inst.InstructionOpcode() {
-			case llvm.IndirectBr, llvm.Invoke:
-				// Not emitted by the compiler.
-				return nil, e.errorAt(inst, errors.New("unknown instructions"))
-			case llvm.Call:
-				child := inst.CalledValue()
-				if !child.IsAInlineAsm().IsNil() {
-					// Inline assembly. This most likely has side effects.
-					// Assume they're only limited side effects, similar to
-					// external function calls.
-					result.updateSeverity(sideEffectLimited)
-					continue
-				}
-				if child.IsAFunction().IsNil() {
-					// Indirect call?
-					// In any case, we can't know anything here about what it
-					// affects exactly so mark this function as invoking all
-					// possible side effects.
-					result.updateSeverity(sideEffectAll)
-					continue
-				}
-				if child.IsDeclaration() {
-					// External function call. Assume only limited side effects
-					// (no affected globals, etc.).
-					switch child.Name() {
-					case "runtime.alloc":
-						continue
-					case "runtime.typeAssert":
-						continue // implemented in interp
-					case "runtime.interfaceImplements":
-						continue // implemented in interp
-					}
-					if e.hasLocalSideEffects(dirtyLocals, inst) {
-						result.updateSeverity(sideEffectLimited)
-					}
-					continue
-				}
-				childSideEffects, err := e.hasSideEffects(child)
-				if err != nil {
-					return nil, err
-				}
-				switch childSideEffects.severity {
-				case sideEffectInProgress, sideEffectNone:
-					// no side effects or recursive function - continue scanning
-				case sideEffectLimited:
-					// The return value may be problematic.
-					if e.hasLocalSideEffects(dirtyLocals, inst) {
-						result.updateSeverity(sideEffectLimited)
-					}
-				case sideEffectAll:
-					result.updateSeverity(sideEffectAll)
-				default:
-					panic("unreachable")
-				}
-			case llvm.Load:
-				if inst.IsVolatile() {
-					result.updateSeverity(sideEffectLimited)
-				}
-				if _, ok := e.dirtyGlobals[inst.Operand(0)]; ok {
-					if e.hasLocalSideEffects(dirtyLocals, inst) {
-						result.updateSeverity(sideEffectLimited)
-					}
-				}
-			case llvm.Store:
-				if inst.IsVolatile() {
-					result.updateSeverity(sideEffectLimited)
-				}
-			case llvm.IntToPtr:
-				// Pointer casts are not yet supported.
-				result.updateSeverity(sideEffectLimited)
-			default:
-				// Ignore most instructions.
-				// Check this list for completeness:
-				// https://godoc.org/github.com/llvm-mirror/llvm/bindings/go/llvm#Opcode
-			}
-		}
-	}
-
-	if result.severity == sideEffectInProgress {
-		// No side effect was reported for this function.
-		result.severity = sideEffectNone
-	}
-	return result, nil
-}
-
-// hasLocalSideEffects checks whether the given instruction flows into a branch
-// or return instruction, in which case the whole function must be marked as
-// having side effects and be called at runtime.
-func (e *Eval) hasLocalSideEffects(dirtyLocals map[llvm.Value]struct{}, inst llvm.Value) bool {
-	if _, ok := dirtyLocals[inst]; ok {
-		// It is already known that this local is dirty.
-		return true
-	}
-
-	for use := inst.FirstUse(); !use.IsNil(); use = use.NextUse() {
-		user := use.User()
-		if user.IsAInstruction().IsNil() {
-			// Should not happen in valid IR.
-			panic("user not an instruction")
-		}
-		switch user.InstructionOpcode() {
-		case llvm.Br, llvm.Switch:
-			// A branch on a dirty value makes this function dirty: it cannot be
-			// interpreted at compile time so has to be run at runtime. It is
-			// marked as having side effects for this reason.
-			return true
-		case llvm.Ret:
-			// This function returns a dirty value so it is itself marked as
-			// dirty to make sure it is called at runtime.
-			return true
-		case llvm.Store:
-			ptr := user.Operand(1)
-			if !ptr.IsAGlobalVariable().IsNil() {
-				// Store to a global variable.
-				// Already handled in (*Eval).hasSideEffects.
-				continue
-			}
-			// This store might affect all kinds of values. While it is
-			// certainly possible to traverse through all of them, the easiest
-			// option right now is to just assume the worst and say that this
-			// function has side effects.
-			// TODO: traverse through all stores and mark all relevant allocas /
-			// globals dirty.
-			return true
-		default:
-			// All instructions that take 0 or more operands (1 or more if it
-			// was a use) and produce a result.
-			// For a list:
-			// https://godoc.org/github.com/llvm-mirror/llvm/bindings/go/llvm#Opcode
-			dirtyLocals[user] = struct{}{}
-			if e.hasLocalSideEffects(dirtyLocals, user) {
-				return true
-			}
-		}
-	}
-
-	// No side effects found.
-	return false
-}
-
-// updateSeverity sets r.severity to the max of r.severity and severity,
-// conservatively assuming the worst severity.
-func (r *sideEffectResult) updateSeverity(severity sideEffectSeverity) {
-	if severity > r.severity {
-		r.severity = severity
-	}
-}
-
-// updateSeverity updates the severity with the severity of the child severity,
-// like in a function call. This means it also copies the mentioned globals.
-func (r *sideEffectResult) update(child *sideEffectResult) {
-	r.updateSeverity(child.severity)
-	for global := range child.mentionsGlobals {
-		r.mentionsGlobals[global] = struct{}{}
-	}
-}

interp/scan_test.go

@@ -1,95 +0,0 @@
-package interp
-
-import (
-	"os"
-	"sort"
-	"testing"
-
-	"tinygo.org/x/go-llvm"
-)
-
-var scanTestTable = []struct {
-	name            string
-	severity        sideEffectSeverity
-	mentionsGlobals []string
-}{
-	{"returnsConst", sideEffectNone, nil},
-	{"returnsArg", sideEffectNone, nil},
-	{"externalCallOnly", sideEffectNone, nil},
-	{"externalCallAndReturn", sideEffectLimited, nil},
-	{"externalCallBranch", sideEffectLimited, nil},
-	{"readCleanGlobal", sideEffectNone, []string{"cleanGlobalInt"}},
-	{"readDirtyGlobal", sideEffectLimited, []string{"dirtyGlobalInt"}},
-	{"callFunctionPointer", sideEffectAll, []string{"functionPointer"}},
-	{"getDirtyPointer", sideEffectLimited, nil},
-	{"storeToPointer", sideEffectLimited, nil},
-	{"callTypeAssert", sideEffectNone, nil},
-	{"callInterfaceImplements", sideEffectNone, nil},
-}
-
-func TestScan(t *testing.T) {
-	t.Parallel()
-
-	// Read the input IR.
-	path := "testdata/scan.ll"
-	ctx := llvm.NewContext()
-	buf, err := llvm.NewMemoryBufferFromFile(path)
-	os.Stat(path) // make sure this file is tracked by `go test` caching
-	if err != nil {
-		t.Fatalf("could not read file %s: %v", path, err)
-	}
-	mod, err := ctx.ParseIR(buf)
-	if err != nil {
-		t.Fatalf("could not load module:\n%v", err)
-	}
-
-	// Check all to-be-tested functions.
-	for _, tc := range scanTestTable {
-		// Create an eval object, for testing.
-		e := &Eval{
-			Mod:          mod,
-			TargetData:   llvm.NewTargetData(mod.DataLayout()),
-			dirtyGlobals: map[llvm.Value]struct{}{},
-		}
-
-		// Mark some globals dirty, for testing.
-		e.markDirty(mod.NamedGlobal("dirtyGlobalInt"))
-
-		// Scan for side effects.
-		fn := mod.NamedFunction(tc.name)
-		if fn.IsNil() {
-			t.Errorf("scan test: could not find tested function %s in the IR", tc.name)
-			continue
-		}
-		evalPkg := &evalPackage{e, "testdata"}
-		result, err := evalPkg.hasSideEffects(fn)
-		if err != nil {
-			t.Errorf("scan test: failed to scan %s for side effects: %v", fn.Name(), err)
-		}
-
-		// Check whether the result is what we expect.
-		if result.severity != tc.severity {
-			t.Errorf("scan test: function %s should have severity %s but it has %s", tc.name, tc.severity, result.severity)
-		}
-
-		// Check whether the mentioned globals match with what we'd expect.
-		mentionsGlobalNames := make([]string, 0, len(result.mentionsGlobals))
-		for global := range result.mentionsGlobals {
-			mentionsGlobalNames = append(mentionsGlobalNames, global.Name())
-		}
-		sort.Strings(mentionsGlobalNames)
-		globalsMismatch := false
-		if len(result.mentionsGlobals) != len(tc.mentionsGlobals) {
-			globalsMismatch = true
-		} else {
-			for i, globalName := range mentionsGlobalNames {
-				if tc.mentionsGlobals[i] != globalName {
-					globalsMismatch = true
-				}
-			}
-		}
-		if globalsMismatch {
-			t.Errorf("scan test: expected %s to mention globals %v, but it mentions globals %v", tc.name, tc.mentionsGlobals, mentionsGlobalNames)
-		}
-	}
-}

interp/testdata/basic.ll

@@ -4,6 +4,10 @@ target triple = "x86_64--linux"
 @main.v1 = internal global i64 0
 @main.nonConst1 = global [4 x i64] zeroinitializer
 @main.nonConst2 = global i64 0
+@main.someArray = global [8 x {i16, i32}] zeroinitializer
+@main.exportedValue = global [1 x i16*] [i16* @main.exposedValue1]
+@main.exposedValue1 = global i16 0
+@main.exposedValue2 = global i16 0
 
 declare void @runtime.printint64(i64) unnamed_addr
 
@@ -47,6 +51,20 @@ entry:
   %value2 = load i64, i64* %gep2
   store i64 %value2, i64* @main.nonConst2
 
+  ; Test that the following GEP works:
+  ;     var someArray
+  ;     modifyExternal(&someArray[3].field1)
+  %gep3 = getelementptr [8 x {i16, i32}], [8 x {i16, i32}]* @main.someArray, i32 0, i32 3, i32 1
+  call void @modifyExternal(i32* %gep3)
+
+  ; Test that marking a value as external also marks all referenced values.
+  call void @modifyExternal(i32* bitcast ([1 x i16*]* @main.exportedValue to i32*))
+  store i16 5, i16* @main.exposedValue1
+
+  ; Test that this even propagates through functions.
+  call void @modifyExternal(i32* bitcast (void ()* @willModifyGlobal to i32*))
+  store i16 7, i16* @main.exposedValue2
+
   ret void
 }
 
@@ -58,3 +76,14 @@ entry:
 }
 
 declare i64 @someValue()
+
+declare void @modifyExternal(i32*)
+
+; This function will modify an external value. By passing this function as a
+; function pointer to an external function, @main.exposedValue2 should be
+; marked as external.
+define void @willModifyGlobal() {
+entry:
+  store i16 8, i16* @main.exposedValue2
+  ret void
+}

interp/testdata/basic.out.ll

@@ -3,6 +3,10 @@ target triple = "x86_64--linux"
 
 @main.nonConst1 = local_unnamed_addr global [4 x i64] zeroinitializer
 @main.nonConst2 = local_unnamed_addr global i64 0
+@main.someArray = global [8 x { i16, i32 }] zeroinitializer
+@main.exportedValue = global [1 x i16*] [i16* @main.exposedValue1]
+@main.exposedValue1 = global i16 0
+@main.exposedValue2 = local_unnamed_addr global i16 0
 
 declare void @runtime.printint64(i64) unnamed_addr
 
@@ -16,6 +20,11 @@ entry:
   store i64 %value1, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @main.nonConst1, i32 0, i32 0)
   %value2 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @main.nonConst1, i32 0, i32 0)
   store i64 %value2, i64* @main.nonConst2
+  call void @modifyExternal(i32* getelementptr inbounds ([8 x { i16, i32 }], [8 x { i16, i32 }]* @main.someArray, i32 0, i32 3, i32 1))
+  call void @modifyExternal(i32* bitcast ([1 x i16*]* @main.exportedValue to i32*))
+  store i16 5, i16* @main.exposedValue1
+  call void @modifyExternal(i32* bitcast (void ()* @willModifyGlobal to i32*))
+  store i16 7, i16* @main.exposedValue2
   ret void
 }
 
@@ -27,3 +36,11 @@ entry:
 }
 
 declare i64 @someValue() local_unnamed_addr
+
+declare void @modifyExternal(i32*) local_unnamed_addr
+
+define void @willModifyGlobal() {
+entry:
+  store i16 8, i16* @main.exposedValue2
+  ret void
+}

interp/testdata/map.ll

@@ -48,8 +48,7 @@ entry:
 define internal void @main.testNonConstantBinarySet() {
   %hashmap.key = alloca i8
   %hashmap.value = alloca i8
-  ; Create hashmap from global. This breaks the normal hashmapBinarySet
-  ; optimization, to test the fallback.
+  ; Create hashmap from global.
   %map.new = call %runtime.hashmap* @runtime.hashmapMake(i8 1, i8 1, i32 1, i8* undef, i8* null)
   store %runtime.hashmap* %map.new, %runtime.hashmap** @main.binaryMap
   %map = load %runtime.hashmap*, %runtime.hashmap** @main.binaryMap
@@ -64,8 +63,7 @@ define internal void @main.testNonConstantBinarySet() {
 ; operations (with string keys).
 define internal void @main.testNonConstantStringSet() {
   %hashmap.value = alloca i8
-  ; Create hashmap from global. This breaks the normal hashmapStringSet
-  ; optimization, to test the fallback.
+  ; Create hashmap from global.
   %map.new = call %runtime.hashmap* @runtime.hashmapMake(i8 8, i8 1, i32 1, i8* undef, i8* null)
   store %runtime.hashmap* %map.new, %runtime.hashmap** @main.stringMap
   %map = load %runtime.hashmap*, %runtime.hashmap** @main.stringMap

interp/testdata/map.out.ll

@@ -2,27 +2,19 @@ target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
 target triple = "armv6m-none-eabi"
 
 %runtime.hashmap = type { %runtime.hashmap*, i8*, i32, i8, i8, i8 }
-%runtime._string = type { i8*, i32 }
 
 @main.m = local_unnamed_addr global %runtime.hashmap* @"main$map"
-@main.binaryMap = local_unnamed_addr global %runtime.hashmap* @"main$map.4"
-@main.stringMap = local_unnamed_addr global %runtime.hashmap* @"main$map.6"
+@main.binaryMap = local_unnamed_addr global %runtime.hashmap* @"main$map.1"
+@main.stringMap = local_unnamed_addr global %runtime.hashmap* @"main$map.3"
 @main.init.string = internal unnamed_addr constant [7 x i8] c"CONNECT"
-@"main$mapbucket" = internal unnamed_addr global { [8 x i8], i8*, [8 x i8], [8 x %runtime._string] } { [8 x i8] c"\04\00\00\00\00\00\00\00", i8* null, [8 x i8] c"\01\00\00\00\00\00\00\00", [8 x %runtime._string] [%runtime._string { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @main.init.string, i32 0, i32 0), i32 7 }, %runtime._string zeroinitializer, %runtime._string zeroinitializer, %runtime._string zeroinitializer, %runtime._string zeroinitializer, %runtime._string zeroinitializer, %runtime._string zeroinitializer, %runtime._string zeroinitializer] }
-@"main$map" = internal unnamed_addr global %runtime.hashmap { %runtime.hashmap* null, i8* getelementptr inbounds ({ [8 x i8], i8*, [8 x i8], [8 x %runtime._string] }, { [8 x i8], i8*, [8 x i8], [8 x %runtime._string] }* @"main$mapbucket", i32 0, i32 0, i32 0), i32 1, i8 1, i8 8, i8 0 }
-@"main$alloca.2" = internal global i8 1
-@"main$alloca.3" = internal global i8 2
-@"main$map.4" = internal unnamed_addr global %runtime.hashmap { %runtime.hashmap* null, i8* null, i32 0, i8 1, i8 1, i8 0 }
-@"main$alloca.5" = internal global i8 2
-@"main$map.6" = internal unnamed_addr global %runtime.hashmap { %runtime.hashmap* null, i8* null, i32 0, i8 8, i8 1, i8 0 }
-
-declare void @runtime.hashmapBinarySet(%runtime.hashmap*, i8*, i8*, i8*, i8*) local_unnamed_addr
-
-declare void @runtime.hashmapStringSet(%runtime.hashmap*, i8*, i32, i8*, i8*, i8*) local_unnamed_addr
+@"main$map" = internal global %runtime.hashmap { %runtime.hashmap* null, i8* getelementptr inbounds ({ [8 x i8], i8*, { i8, [7 x i8] }, { { [7 x i8]*, [4 x i8] }, [56 x i8] } }, { [8 x i8], i8*, { i8, [7 x i8] }, { { [7 x i8]*, [4 x i8] }, [56 x i8] } }* @"main$mapbucket", i32 0, i32 0, i32 0), i32 1, i8 1, i8 8, i8 0 }
+@"main$mapbucket" = internal unnamed_addr global { [8 x i8], i8*, { i8, [7 x i8] }, { { [7 x i8]*, [4 x i8] }, [56 x i8] } } { [8 x i8] c"\04\00\00\00\00\00\00\00", i8* null, { i8, [7 x i8] } { i8 1, [7 x i8] zeroinitializer }, { { [7 x i8]*, [4 x i8] }, [56 x i8] } { { [7 x i8]*, [4 x i8] } { [7 x i8]* @main.init.string, [4 x i8] c"\07\00\00\00" }, [56 x i8] zeroinitializer } }
+@"main$map.1" = internal global %runtime.hashmap { %runtime.hashmap* null, i8* getelementptr inbounds ({ [8 x i8], i8*, { i8, [7 x i8] }, { i8, [7 x i8] } }, { [8 x i8], i8*, { i8, [7 x i8] }, { i8, [7 x i8] } }* @"main$mapbucket.2", i32 0, i32 0, i32 0), i32 1, i8 1, i8 1, i8 0 }
+@"main$mapbucket.2" = internal unnamed_addr global { [8 x i8], i8*, { i8, [7 x i8] }, { i8, [7 x i8] } } { [8 x i8] c"\04\00\00\00\00\00\00\00", i8* null, { i8, [7 x i8] } { i8 1, [7 x i8] zeroinitializer }, { i8, [7 x i8] } { i8 2, [7 x i8] zeroinitializer } }
+@"main$map.3" = internal global %runtime.hashmap { %runtime.hashmap* null, i8* getelementptr inbounds ({ [8 x i8], i8*, { { [7 x i8]*, [4 x i8] }, [56 x i8] }, { i8, [7 x i8] } }, { [8 x i8], i8*, { { [7 x i8]*, [4 x i8] }, [56 x i8] }, { i8, [7 x i8] } }* @"main$mapbucket.4", i32 0, i32 0, i32 0), i32 1, i8 8, i8 1, i8 0 }
+@"main$mapbucket.4" = internal unnamed_addr global { [8 x i8], i8*, { { [7 x i8]*, [4 x i8] }, [56 x i8] }, { i8, [7 x i8] } } { [8 x i8] c"x\00\00\00\00\00\00\00", i8* null, { { [7 x i8]*, [4 x i8] }, [56 x i8] } { { [7 x i8]*, [4 x i8] } { [7 x i8]* @main.init.string, [4 x i8] c"\07\00\00\00" }, [56 x i8] zeroinitializer }, { i8, [7 x i8] } { i8 2, [7 x i8] zeroinitializer } }
 
 define void @runtime.initAll() unnamed_addr {
 entry:
-  call void @runtime.hashmapBinarySet(%runtime.hashmap* @"main$map.4", i8* @"main$alloca.2", i8* @"main$alloca.3", i8* undef, i8* null)
-  call void @runtime.hashmapStringSet(%runtime.hashmap* @"main$map.6", i8* getelementptr inbounds ([7 x i8], [7 x i8]* @main.init.string, i32 0, i32 0), i32 7, i8* @"main$alloca.5", i8* undef, i8* null)
   ret void
 }

interp/testdata/scan.ll

@@ -1,78 +0,0 @@
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64--linux"
-
-%runtime.typecodeID = type { %runtime.typecodeID*, i64 }
-
-declare i1 @runtime.typeAssert(i64, %runtime.typecodeID*, i8*, i8*)
-declare i1 @runtime.interfaceImplements(i64, i8**)
-
-define i64 @returnsConst() {
-  ret i64 0
-}
-
-define i64 @returnsArg(i64 %arg) {
-  ret i64 %arg
-}
-
-declare i64 @externalCall()
-
-define i64 @externalCallOnly() {
-  %result = call i64 @externalCall()
-  ret i64 0
-}
-
-define i64 @externalCallAndReturn() {
-  %result = call i64 @externalCall()
-  ret i64 %result
-}
-
-define i64 @externalCallBranch() {
-  %result = call i64 @externalCall()
-  %zero = icmp eq i64 %result, 0
-  br i1 %zero, label %if.then, label %if.done
-
-if.then:
-  ret i64 2
-
-if.done:
-  ret i64 4
-}
-
-@cleanGlobalInt = global i64 5
-define i64 @readCleanGlobal() {
-  %global = load i64, i64* @cleanGlobalInt
-  ret i64 %global
-}
-
-@dirtyGlobalInt = global i64 5
-define i64 @readDirtyGlobal() {
-  %global = load i64, i64* @dirtyGlobalInt
-  ret i64 %global
-}
-
-declare i64* @getDirtyPointer()
-
-define void @storeToPointer() {
-  %ptr = call i64* @getDirtyPointer()
-  store i64 3, i64* %ptr
-  ret void
-}
-
-@functionPointer = global i64()* null
-define i64 @callFunctionPointer() {
-  %fp = load i64()*, i64()** @functionPointer
-  %result = call i64 %fp()
-  ret i64 %result
-}
-
-define i1 @callTypeAssert() {
-  ; Note: parameters are not realistic.
-  %ok = call i1 @runtime.typeAssert(i64 0, %runtime.typecodeID* null, i8* undef, i8* null)
-  ret i1 %ok
-}
-
-define i1 @callInterfaceImplements() {
-  ; Note: parameters are not realistic.
-  %ok = call i1 @runtime.interfaceImplements(i64 0, i8** null)
-  ret i1 %ok
-}

interp/testdata/slice-copy.out.ll

@@ -1,6 +1,8 @@
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64--linux"
 
+@"main$alloc.1" = internal unnamed_addr constant [6 x i8] c"\05\00{\00\00\04"
+
 declare void @runtime.printuint8(i8) local_unnamed_addr
 
 declare void @runtime.printint16(i16) local_unnamed_addr
@@ -15,6 +17,7 @@ entry:
   call void @runtime.printuint8(i8 3)
   call void @runtime.printuint8(i8 3)
   call void @runtime.printint16(i16 5)
-  call void @runtime.printint16(i16 5)
+  %int16SliceDst.val = load i16, i16* bitcast ([6 x i8]* @"main$alloc.1" to i16*)
+  call void @runtime.printint16(i16 %int16SliceDst.val)
   ret void
 }

interp/utils.go

@@ -1,126 +0,0 @@
-package interp
-
-import (
-	"errors"
-
-	"tinygo.org/x/go-llvm"
-)
-
-// Return a list of values (actually, instructions) where this value is used as
-// an operand.
-func getUses(value llvm.Value) []llvm.Value {
-	var uses []llvm.Value
-	use := value.FirstUse()
-	for !use.IsNil() {
-		uses = append(uses, use.User())
-		use = use.NextUse()
-	}
-	return uses
-}
-
-// getStringBytes loads the byte slice of a Go string represented as a
-// {ptr, len} pair.
-func getStringBytes(strPtr Value, strLen llvm.Value) ([]byte, error) {
-	if !strLen.IsConstant() {
-		return nil, errors.New("getStringBytes with a non-constant length")
-	}
-	buf := make([]byte, strLen.ZExtValue())
-	for i := range buf {
-		gep, err := strPtr.GetElementPtr([]uint32{uint32(i)})
-		if err != nil {
-			return nil, err
-		}
-		c, err := gep.Load()
-		if err != nil {
-			return nil, err
-		}
-		buf[i] = byte(c.ZExtValue())
-	}
-	return buf, nil
-}
-
-// getLLVMIndices converts an []uint32 into an []llvm.Value, for use in
-// llvm.ConstGEP.
-func getLLVMIndices(int32Type llvm.Type, indices []uint32) []llvm.Value {
-	llvmIndices := make([]llvm.Value, len(indices))
-	for i, index := range indices {
-		llvmIndices[i] = llvm.ConstInt(int32Type, uint64(index), false)
-	}
-	return llvmIndices
-}
-
-// Return true if this type is a scalar value (integer or floating point), false
-// otherwise.
-func isScalar(t llvm.Type) bool {
-	switch t.TypeKind() {
-	case llvm.IntegerTypeKind, llvm.FloatTypeKind, llvm.DoubleTypeKind:
-		return true
-	default:
-		return false
-	}
-}
-
-// isPointerNil returns whether this is a nil pointer or not. The ok value
-// indicates whether the result is certain: if it is false the result boolean is
-// not valid.
-func isPointerNil(v llvm.Value) (result bool, ok bool) {
-	if !v.IsAConstantExpr().IsNil() {
-		switch v.Opcode() {
-		case llvm.IntToPtr:
-			// Whether a constant inttoptr is nil is easy to
-			// determine.
-			result, ok = isZero(v.Operand(0))
-			if ok {
-				return
-			}
-		case llvm.BitCast, llvm.GetElementPtr:
-			// These const instructions are just a kind of wrappers for the
-			// underlying pointer.
-			return isPointerNil(v.Operand(0))
-		}
-	}
-	if !v.IsAConstantPointerNull().IsNil() {
-		// A constant pointer null is always null, of course.
-		return true, true
-	}
-	if !v.IsAGlobalValue().IsNil() {
-		// A global value is never null.
-		return false, true
-	}
-	return false, false // not valid
-}
-
-// isZero returns whether the value in v is the integer zero, and whether that
-// can be known right now.
-func isZero(v llvm.Value) (result bool, ok bool) {
-	if !v.IsAConstantExpr().IsNil() {
-		switch v.Opcode() {
-		case llvm.PtrToInt:
-			return isPointerNil(v.Operand(0))
-		}
-	}
-	if !v.IsAConstantInt().IsNil() {
-		val := v.ZExtValue()
-		return val == 0, true
-	}
-	return false, false // not valid
-}
-
-// unwrap returns the underlying value, with GEPs removed. This can be useful to
-// get the underlying global of a GEP pointer.
-func unwrap(value llvm.Value) llvm.Value {
-	for {
-		if !value.IsAConstantExpr().IsNil() {
-			switch value.Opcode() {
-			case llvm.GetElementPtr:
-				value = value.Operand(0)
-				continue
-			}
-		} else if !value.IsAGetElementPtrInst().IsNil() {
-			value = value.Operand(0)
-			continue
-		}
-		break
-	}
-	return value
-}

interp/values.go

@@ -1,443 +0,0 @@
-package interp
-
-// This file provides a litte bit of abstraction around LLVM values.
-
-import (
-	"errors"
-	"strconv"
-
-	"tinygo.org/x/go-llvm"
-)
-
-// A Value is a LLVM value with some extra methods attached for easier
-// interpretation.
-type Value interface {
-	Value() llvm.Value                     // returns a LLVM value
-	Type() llvm.Type                       // equal to Value().Type()
-	IsConstant() bool                      // returns true if this value is a constant value
-	Load() (llvm.Value, error)             // dereference a pointer
-	Store(llvm.Value) error                // store to a pointer
-	GetElementPtr([]uint32) (Value, error) // returns an interior pointer
-	String() string                        // string representation, for debugging
-}
-
-// A type that simply wraps a LLVM constant value.
-type LocalValue struct {
-	Eval       *Eval
-	Underlying llvm.Value
-}
-
-// Value implements Value by returning the constant value itself.
-func (v *LocalValue) Value() llvm.Value {
-	return v.Underlying
-}
-
-func (v *LocalValue) Type() llvm.Type {
-	return v.Underlying.Type()
-}
-
-func (v *LocalValue) IsConstant() bool {
-	if _, ok := v.Eval.dirtyGlobals[unwrap(v.Underlying)]; ok {
-		return false
-	}
-	return v.Underlying.IsConstant()
-}
-
-// Load loads a constant value if this is a constant pointer.
-func (v *LocalValue) Load() (llvm.Value, error) {
-	if !v.Underlying.IsAGlobalVariable().IsNil() {
-		return v.Underlying.Initializer(), nil
-	}
-	switch v.Underlying.Opcode() {
-	case llvm.GetElementPtr:
-		indices := v.getConstGEPIndices()
-		if indices[0] != 0 {
-			return llvm.Value{}, errors.New("invalid GEP")
-		}
-		global := v.Eval.getValue(v.Underlying.Operand(0))
-		agg, err := global.Load()
-		if err != nil {
-			return llvm.Value{}, err
-		}
-		return llvm.ConstExtractValue(agg, indices[1:]), nil
-	case llvm.BitCast:
-		return llvm.Value{}, errors.New("interp: load from a bitcast")
-	default:
-		return llvm.Value{}, errors.New("interp: load from a constant")
-	}
-}
-
-// Store stores to the underlying value if the value type is a pointer type,
-// otherwise it returns an error.
-func (v *LocalValue) Store(value llvm.Value) error {
-	if !v.Underlying.IsAGlobalVariable().IsNil() {
-		if !value.IsConstant() {
-			v.MarkDirty()
-			v.Eval.builder.CreateStore(value, v.Underlying)
-		} else {
-			v.Underlying.SetInitializer(value)
-		}
-		return nil
-	}
-	if !value.IsConstant() {
-		v.MarkDirty()
-		v.Eval.builder.CreateStore(value, v.Underlying)
-		return nil
-	}
-	switch v.Underlying.Opcode() {
-	case llvm.GetElementPtr:
-		indices := v.getConstGEPIndices()
-		if indices[0] != 0 {
-			return errors.New("invalid GEP")
-		}
-		global := &LocalValue{v.Eval, v.Underlying.Operand(0)}
-		agg, err := global.Load()
-		if err != nil {
-			return err
-		}
-		agg = llvm.ConstInsertValue(agg, value, indices[1:])
-		return global.Store(agg)
-	default:
-		return errors.New("interp: store on a constant")
-	}
-}
-
-// GetElementPtr returns a GEP when the underlying value is of pointer type.
-func (v *LocalValue) GetElementPtr(indices []uint32) (Value, error) {
-	if !v.Underlying.IsAGlobalVariable().IsNil() {
-		int32Type := v.Underlying.Type().Context().Int32Type()
-		gep := llvm.ConstGEP(v.Underlying, getLLVMIndices(int32Type, indices))
-		return &LocalValue{v.Eval, gep}, nil
-	}
-	if !v.Underlying.IsAConstantExpr().IsNil() {
-		switch v.Underlying.Opcode() {
-		case llvm.GetElementPtr, llvm.IntToPtr, llvm.BitCast:
-			int32Type := v.Underlying.Type().Context().Int32Type()
-			llvmIndices := getLLVMIndices(int32Type, indices)
-			return &LocalValue{v.Eval, llvm.ConstGEP(v.Underlying, llvmIndices)}, nil
-		}
-	}
-	return nil, errors.New("interp: unknown GEP")
-}
-
-// stripPointerCasts removes all const bitcasts from pointer values, if there
-// are any.
-func (v *LocalValue) stripPointerCasts() *LocalValue {
-	value := v.Underlying
-	for {
-		if !value.IsAConstantExpr().IsNil() {
-			switch value.Opcode() {
-			case llvm.BitCast:
-				value = value.Operand(0)
-				continue
-			}
-		}
-		return &LocalValue{
-			Eval:       v.Eval,
-			Underlying: value,
-		}
-	}
-}
-
-func (v *LocalValue) String() string {
-	isConstant := "false"
-	if v.IsConstant() {
-		isConstant = "true"
-	}
-	return "&LocalValue{Type: " + v.Type().String() + ", IsConstant: " + isConstant + "}"
-}
-
-// getConstGEPIndices returns indices of this constant GEP, if this is a GEP
-// instruction. If it is not, the behavior is undefined.
-func (v *LocalValue) getConstGEPIndices() []uint32 {
-	indices := make([]uint32, v.Underlying.OperandsCount()-1)
-	for i := range indices {
-		operand := v.Underlying.Operand(i + 1)
-		indices[i] = uint32(operand.ZExtValue())
-	}
-	return indices
-}
-
-// MarkDirty marks this global as dirty, meaning that every load from and store
-// to this global (from now on) must be performed at runtime.
-func (v *LocalValue) MarkDirty() {
-	underlying := unwrap(v.Underlying)
-	if underlying.IsAGlobalVariable().IsNil() {
-		panic("trying to mark a non-global as dirty")
-	}
-	if !v.IsConstant() {
-		return // already dirty
-	}
-	v.Eval.dirtyGlobals[underlying] = struct{}{}
-}
-
-// MapValue implements a Go map which is created at compile time and stored as a
-// global variable.
-type MapValue struct {
-	Eval       *Eval
-	PkgName    string
-	Underlying llvm.Value
-	Keys       []Value
-	Values     []Value
-	KeySize    int
-	ValueSize  int
-	KeyType    llvm.Type
-	ValueType  llvm.Type
-}
-
-func (v *MapValue) newBucket() llvm.Value {
-	ctx := v.Eval.Mod.Context()
-	i8ptrType := llvm.PointerType(ctx.Int8Type(), 0)
-	bucketType := ctx.StructType([]llvm.Type{
-		llvm.ArrayType(ctx.Int8Type(), 8), // tophash
-		i8ptrType,                         // next bucket
-		llvm.ArrayType(v.KeyType, 8),      // key type
-		llvm.ArrayType(v.ValueType, 8),    // value type
-	}, false)
-	bucketValue := llvm.ConstNull(bucketType)
-	bucket := llvm.AddGlobal(v.Eval.Mod, bucketType, v.PkgName+"$mapbucket")
-	bucket.SetInitializer(bucketValue)
-	bucket.SetLinkage(llvm.InternalLinkage)
-	bucket.SetUnnamedAddr(true)
-	return bucket
-}
-
-// Value returns a global variable which is a pointer to the actual hashmap.
-func (v *MapValue) Value() llvm.Value {
-	if !v.Underlying.IsNil() {
-		return v.Underlying
-	}
-
-	ctx := v.Eval.Mod.Context()
-	i8ptrType := llvm.PointerType(ctx.Int8Type(), 0)
-
-	var firstBucketGlobal llvm.Value
-	if len(v.Keys) == 0 {
-		// there are no buckets
-		firstBucketGlobal = llvm.ConstPointerNull(i8ptrType)
-	} else {
-		// create initial bucket
-		firstBucketGlobal = v.newBucket()
-	}
-
-	// Insert each key/value pair in the hashmap.
-	bucketGlobal := firstBucketGlobal
-	for i, key := range v.Keys {
-		var keyBuf []byte
-		llvmKey := key.Value()
-		llvmValue := v.Values[i].Value()
-		if key.Type().TypeKind() == llvm.StructTypeKind && key.Type().StructName() == "runtime._string" {
-			keyPtr := llvm.ConstExtractValue(llvmKey, []uint32{0})
-			keyLen := llvm.ConstExtractValue(llvmKey, []uint32{1})
-			keyPtrVal := v.Eval.getValue(keyPtr)
-			var err error
-			keyBuf, err = getStringBytes(keyPtrVal, keyLen)
-			if err != nil {
-				panic(err) // TODO
-			}
-		} else if key.Type().TypeKind() == llvm.IntegerTypeKind {
-			keyBuf = make([]byte, v.Eval.TargetData.TypeAllocSize(key.Type()))
-			n := key.Value().ZExtValue()
-			for i := range keyBuf {
-				keyBuf[i] = byte(n)
-				n >>= 8
-			}
-		} else if key.Type().TypeKind() == llvm.ArrayTypeKind &&
-			key.Type().ElementType().TypeKind() == llvm.IntegerTypeKind &&
-			key.Type().ElementType().IntTypeWidth() == 8 {
-			keyBuf = make([]byte, v.Eval.TargetData.TypeAllocSize(key.Type()))
-			for i := range keyBuf {
-				keyBuf[i] = byte(llvm.ConstExtractValue(llvmKey, []uint32{uint32(i)}).ZExtValue())
-			}
-		} else {
-			panic("interp: map key type not implemented: " + key.Type().String())
-		}
-		hash := v.hash(keyBuf)
-
-		if i%8 == 0 && i != 0 {
-			// Bucket is full, create a new one.
-			newBucketGlobal := v.newBucket()
-			zero := llvm.ConstInt(ctx.Int32Type(), 0, false)
-			newBucketPtr := llvm.ConstInBoundsGEP(newBucketGlobal, []llvm.Value{zero})
-			newBucketPtrCast := llvm.ConstBitCast(newBucketPtr, i8ptrType)
-			// insert pointer into old bucket
-			bucket := bucketGlobal.Initializer()
-			bucket = llvm.ConstInsertValue(bucket, newBucketPtrCast, []uint32{1})
-			bucketGlobal.SetInitializer(bucket)
-			// switch to next bucket
-			bucketGlobal = newBucketGlobal
-		}
-
-		tophashValue := llvm.ConstInt(ctx.Int8Type(), uint64(v.topHash(hash)), false)
-		bucket := bucketGlobal.Initializer()
-		bucket = llvm.ConstInsertValue(bucket, tophashValue, []uint32{0, uint32(i % 8)})
-		bucket = llvm.ConstInsertValue(bucket, llvmKey, []uint32{2, uint32(i % 8)})
-		bucket = llvm.ConstInsertValue(bucket, llvmValue, []uint32{3, uint32(i % 8)})
-		bucketGlobal.SetInitializer(bucket)
-	}
-
-	// Create the hashmap itself.
-	zero := llvm.ConstInt(ctx.Int32Type(), 0, false)
-	bucketPtr := llvm.ConstInBoundsGEP(firstBucketGlobal, []llvm.Value{zero})
-	hashmapType := v.Type()
-	hashmap := llvm.ConstNamedStruct(hashmapType, []llvm.Value{
-		llvm.ConstPointerNull(llvm.PointerType(hashmapType, 0)),                        // next
-		llvm.ConstBitCast(bucketPtr, i8ptrType),                                        // buckets
-		llvm.ConstInt(hashmapType.StructElementTypes()[2], uint64(len(v.Keys)), false), // count
-		llvm.ConstInt(ctx.Int8Type(), uint64(v.KeySize), false),                        // keySize
-		llvm.ConstInt(ctx.Int8Type(), uint64(v.ValueSize), false),                      // valueSize
-		llvm.ConstInt(ctx.Int8Type(), 0, false),                                        // bucketBits
-	})
-
-	// Create a pointer to this hashmap.
-	hashmapPtr := llvm.AddGlobal(v.Eval.Mod, hashmap.Type(), v.PkgName+"$map")
-	hashmapPtr.SetInitializer(hashmap)
-	hashmapPtr.SetLinkage(llvm.InternalLinkage)
-	hashmapPtr.SetUnnamedAddr(true)
-	v.Underlying = llvm.ConstInBoundsGEP(hashmapPtr, []llvm.Value{zero})
-	return v.Underlying
-}
-
-// Type returns type runtime.hashmap, which is the actual hashmap type.
-func (v *MapValue) Type() llvm.Type {
-	return v.Eval.Mod.GetTypeByName("runtime.hashmap")
-}
-
-func (v *MapValue) IsConstant() bool {
-	return true // TODO: dirty maps
-}
-
-// Load panics: maps are of reference type so cannot be dereferenced.
-func (v *MapValue) Load() (llvm.Value, error) {
-	panic("interp: load from a map")
-}
-
-// Store returns an error: maps are of reference type so cannot be stored to.
-func (v *MapValue) Store(value llvm.Value) error {
-	// This must be a bug, but it might be helpful to indicate the location
-	// anyway.
-	return errors.New("interp: store on a map")
-}
-
-// GetElementPtr panics: maps are of reference type so their (interior)
-// addresses cannot be calculated.
-func (v *MapValue) GetElementPtr(indices []uint32) (Value, error) {
-	return nil, errors.New("interp: GEP on a map")
-}
-
-// PutString does a map assign operation, assuming that the map is of type
-// map[string]T.
-func (v *MapValue) PutString(keyBuf, keyLen, valPtr *LocalValue) error {
-	if !v.Underlying.IsNil() {
-		return errors.New("map already created")
-	}
-
-	if valPtr.Underlying.Opcode() == llvm.BitCast {
-		valPtr = &LocalValue{v.Eval, valPtr.Underlying.Operand(0)}
-	}
-	value, err := valPtr.Load()
-	if err != nil {
-		return err
-	}
-	if v.ValueType.IsNil() {
-		v.ValueType = value.Type()
-		if int(v.Eval.TargetData.TypeAllocSize(v.ValueType)) != v.ValueSize {
-			return errors.New("interp: map store value type has the wrong size")
-		}
-	} else {
-		if value.Type() != v.ValueType {
-			return errors.New("interp: map store value type is inconsistent")
-		}
-	}
-
-	keyType := v.Eval.Mod.GetTypeByName("runtime._string")
-	v.KeyType = keyType
-	key := llvm.ConstNull(keyType)
-	key = llvm.ConstInsertValue(key, keyBuf.Value(), []uint32{0})
-	key = llvm.ConstInsertValue(key, keyLen.Value(), []uint32{1})
-
-	// TODO: avoid duplicate keys
-	v.Keys = append(v.Keys, &LocalValue{v.Eval, key})
-	v.Values = append(v.Values, &LocalValue{v.Eval, value})
-
-	return nil
-}
-
-// PutBinary does a map assign operation.
-func (v *MapValue) PutBinary(keyPtr, valPtr *LocalValue) error {
-	if !v.Underlying.IsNil() {
-		return errors.New("map already created")
-	}
-
-	if valPtr.Underlying.Opcode() == llvm.BitCast {
-		valPtr = &LocalValue{v.Eval, valPtr.Underlying.Operand(0)}
-	}
-	value, err := valPtr.Load()
-	if err != nil {
-		return err
-	}
-	if v.ValueType.IsNil() {
-		v.ValueType = value.Type()
-		if int(v.Eval.TargetData.TypeAllocSize(v.ValueType)) != v.ValueSize {
-			return errors.New("interp: map store value type has the wrong size")
-		}
-	} else {
-		if value.Type() != v.ValueType {
-			return errors.New("interp: map store value type is inconsistent")
-		}
-	}
-
-	if !keyPtr.Underlying.IsAConstantExpr().IsNil() {
-		if keyPtr.Underlying.Opcode() == llvm.BitCast {
-			keyPtr = &LocalValue{v.Eval, keyPtr.Underlying.Operand(0)}
-		} else if keyPtr.Underlying.Opcode() == llvm.GetElementPtr {
-			keyPtr = &LocalValue{v.Eval, keyPtr.Underlying.Operand(0)}
-		}
-	}
-	key, err := keyPtr.Load()
-	if err != nil {
-		return err
-	}
-	if v.KeyType.IsNil() {
-		v.KeyType = key.Type()
-		if int(v.Eval.TargetData.TypeAllocSize(v.KeyType)) != v.KeySize {
-			return errors.New("interp: map store key type has the wrong size")
-		}
-	} else {
-		if key.Type() != v.KeyType {
-			return errors.New("interp: map store key type is inconsistent")
-		}
-	}
-
-	// TODO: avoid duplicate keys
-	v.Keys = append(v.Keys, &LocalValue{v.Eval, key})
-	v.Values = append(v.Values, &LocalValue{v.Eval, value})
-
-	return nil
-}
-
-// Get FNV-1a hash of this string.
-//
-// https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function#FNV-1a_hash
-func (v *MapValue) hash(data []byte) uint32 {
-	var result uint32 = 2166136261 // FNV offset basis
-	for _, c := range data {
-		result ^= uint32(c)
-		result *= 16777619 // FNV prime
-	}
-	return result
-}
-
-// Get the topmost 8 bits of the hash, without using a special value (like 0).
-func (v *MapValue) topHash(hash uint32) uint8 {
-	tophash := uint8(hash >> 24)
-	if tophash < 1 {
-		// 0 means empty slot, so make it bigger.
-		tophash += 1
-	}
-	return tophash
-}
-
-func (v *MapValue) String() string {
-	return "&MapValue{KeySize: " + strconv.Itoa(v.KeySize) + ", ValueSize: " + strconv.Itoa(v.ValueSize) + "}"
-}

ir/ir.go

@@ -1,271 +0,0 @@
-package ir
-
-import (
-	"go/ast"
-	"go/types"
-	"sort"
-	"strings"
-
-	"github.com/tinygo-org/tinygo/loader"
-	"golang.org/x/tools/go/ssa"
-	"tinygo.org/x/go-llvm"
-)
-
-// This file provides a wrapper around go/ssa values and adds extra
-// functionality to them.
-
-// View on all functions, types, and globals in a program, with analysis
-// results.
-type Program struct {
-	Program       *ssa.Program
-	LoaderProgram *loader.Program
-	mainPkg       *ssa.Package
-	Functions     []*Function
-	functionMap   map[*ssa.Function]*Function
-}
-
-// Function or method.
-type Function struct {
-	*ssa.Function
-	LLVMFn   llvm.Value
-	module   string     // go:wasm-module
-	linkName string     // go:linkname, go:export
-	exported bool       // go:export
-	nobounds bool       // go:nobounds
-	flag     bool       // used by dead code elimination
-	inline   InlineType // go:inline
-}
-
-// Interface type that is at some point used in a type assert (to check whether
-// it implements another interface).
-type Interface struct {
-	Num  int
-	Type *types.Interface
-}
-
-type InlineType int
-
-// How much to inline.
-const (
-	// Default behavior. The compiler decides for itself whether any given
-	// function will be inlined. Whether any function is inlined depends on the
-	// optimization level.
-	InlineDefault InlineType = iota
-
-	// Inline hint, just like the C inline keyword (signalled using
-	// //go:inline). The compiler will be more likely to inline this function,
-	// but it is not a guarantee.
-	InlineHint
-
-	// Don't inline, just like the GCC noinline attribute. Signalled using
-	// //go:noinline.
-	InlineNone
-)
-
-// Create and initialize a new *Program from a *ssa.Program.
-func NewProgram(lprogram *loader.Program) *Program {
-	program := lprogram.LoadSSA()
-	program.Build()
-
-	mainPkg := program.ImportedPackage(lprogram.MainPkg().ImportPath)
-	if mainPkg == nil {
-		panic("could not find main package")
-	}
-	p := &Program{
-		Program:       program,
-		LoaderProgram: lprogram,
-		mainPkg:       mainPkg,
-		functionMap:   make(map[*ssa.Function]*Function),
-	}
-
-	for _, pkg := range lprogram.Sorted() {
-		p.AddPackage(program.ImportedPackage(pkg.ImportPath))
-	}
-
-	return p
-}
-
-// Add a package to this Program. All packages need to be added first before any
-// analysis is done for correct results.
-func (p *Program) AddPackage(pkg *ssa.Package) {
-	memberNames := make([]string, 0)
-	for name := range pkg.Members {
-		memberNames = append(memberNames, name)
-	}
-	sort.Strings(memberNames)
-
-	for _, name := range memberNames {
-		member := pkg.Members[name]
-		switch member := member.(type) {
-		case *ssa.Function:
-			p.addFunction(member)
-		case *ssa.Type:
-			methods := getAllMethods(pkg.Prog, member.Type())
-			if !types.IsInterface(member.Type()) {
-				// named type
-				for _, method := range methods {
-					p.addFunction(pkg.Prog.MethodValue(method))
-				}
-			}
-		case *ssa.Global:
-			// Ignore. Globals are not handled here.
-		case *ssa.NamedConst:
-			// Ignore: these are already resolved.
-		default:
-			panic("unknown member type: " + member.String())
-		}
-	}
-}
-
-func (p *Program) addFunction(ssaFn *ssa.Function) {
-	if _, ok := p.functionMap[ssaFn]; ok {
-		return
-	}
-	f := &Function{Function: ssaFn}
-	f.parsePragmas()
-	p.Functions = append(p.Functions, f)
-	p.functionMap[ssaFn] = f
-
-	for _, anon := range ssaFn.AnonFuncs {
-		p.addFunction(anon)
-	}
-}
-
-// Return true if this package imports "unsafe", false otherwise.
-func hasUnsafeImport(pkg *types.Package) bool {
-	for _, imp := range pkg.Imports() {
-		if imp == types.Unsafe {
-			return true
-		}
-	}
-	return false
-}
-
-func (p *Program) GetFunction(ssaFn *ssa.Function) *Function {
-	return p.functionMap[ssaFn]
-}
-
-func (p *Program) MainPkg() *ssa.Package {
-	return p.mainPkg
-}
-
-// Parse compiler directives in the preceding comments.
-func (f *Function) parsePragmas() {
-	if f.Syntax() == nil {
-		return
-	}
-	if decl, ok := f.Syntax().(*ast.FuncDecl); ok && decl.Doc != nil {
-		for _, comment := range decl.Doc.List {
-			text := comment.Text
-			if strings.HasPrefix(text, "//export ") {
-				// Rewrite '//export' to '//go:export' for compatibility with
-				// gc.
-				text = "//go:" + text[2:]
-			}
-			if !strings.HasPrefix(text, "//go:") {
-				continue
-			}
-			parts := strings.Fields(text)
-			switch parts[0] {
-			case "//go:export":
-				if len(parts) != 2 {
-					continue
-				}
-				f.linkName = parts[1]
-				f.exported = true
-			case "//go:wasm-module":
-				// Alternative comment for setting the import module.
-				if len(parts) != 2 {
-					continue
-				}
-				f.module = parts[1]
-			case "//go:inline":
-				f.inline = InlineHint
-			case "//go:noinline":
-				f.inline = InlineNone
-			case "//go:linkname":
-				if len(parts) != 3 || parts[1] != f.Name() {
-					continue
-				}
-				// Only enable go:linkname when the package imports "unsafe".
-				// This is a slightly looser requirement than what gc uses: gc
-				// requires the file to import "unsafe", not the package as a
-				// whole.
-				if hasUnsafeImport(f.Pkg.Pkg) {
-					f.linkName = parts[2]
-				}
-			case "//go:nobounds":
-				// Skip bounds checking in this function. Useful for some
-				// runtime functions.
-				// This is somewhat dangerous and thus only imported in packages
-				// that import unsafe.
-				if hasUnsafeImport(f.Pkg.Pkg) {
-					f.nobounds = true
-				}
-			}
-		}
-	}
-}
-
-func (f *Function) IsNoBounds() bool {
-	return f.nobounds
-}
-
-// Return true iff this function is externally visible.
-func (f *Function) IsExported() bool {
-	return f.exported || f.CName() != ""
-}
-
-// Return the inline directive of this function.
-func (f *Function) Inline() InlineType {
-	return f.inline
-}
-
-// Return the module name if not the default.
-func (f *Function) Module() string {
-	return f.module
-}
-
-// Return the link name for this function.
-func (f *Function) LinkName() string {
-	if f.linkName != "" {
-		return f.linkName
-	}
-	if f.Signature.Recv() != nil {
-		// Method on a defined type (which may be a pointer).
-		return f.RelString(nil)
-	} else {
-		// Bare function.
-		if name := f.CName(); name != "" {
-			// Name CGo functions directly.
-			return name
-		} else {
-			return f.RelString(nil)
-		}
-	}
-}
-
-// Return the name of the C function if this is a CGo wrapper. Otherwise, return
-// a zero-length string.
-func (f *Function) CName() string {
-	name := f.Name()
-	if strings.HasPrefix(name, "_Cfunc_") {
-		// emitted by `go tool cgo`
-		return name[len("_Cfunc_"):]
-	}
-	if strings.HasPrefix(name, "C.") {
-		// created by ../loader/cgo.go
-		return name[2:]
-	}
-	return ""
-}
-
-// Get all methods of a type.
-func getAllMethods(prog *ssa.Program, typ types.Type) []*types.Selection {
-	ms := prog.MethodSets.MethodSet(typ)
-	methods := make([]*types.Selection, ms.Len())
-	for i := 0; i < ms.Len(); i++ {
-		methods[i] = ms.At(i)
-	}
-	return methods
-}

ir/passes.go

@@ -1,149 +0,0 @@
-package ir
-
-import (
-	"errors"
-	"go/types"
-
-	"golang.org/x/tools/go/ssa"
-)
-
-// This file implements several optimization passes (analysis + transform) to
-// optimize code in SSA form before it is compiled to LLVM IR. It is based on
-// the IR defined in ir.go.
-
-// Make a readable version of a method signature (including the function name,
-// excluding the receiver name). This string is used internally to match
-// interfaces and to call the correct method on an interface. Examples:
-//
-//     String() string
-//     Read([]byte) (int, error)
-func MethodSignature(method *types.Func) string {
-	return method.Name() + signature(method.Type().(*types.Signature))
-}
-
-// Make a readable version of a function (pointer) signature.
-// Examples:
-//
-//     () string
-//     (string, int) (int, error)
-func signature(sig *types.Signature) string {
-	s := ""
-	if sig.Params().Len() == 0 {
-		s += "()"
-	} else {
-		s += "("
-		for i := 0; i < sig.Params().Len(); i++ {
-			if i > 0 {
-				s += ", "
-			}
-			s += sig.Params().At(i).Type().String()
-		}
-		s += ")"
-	}
-	if sig.Results().Len() == 0 {
-		// keep as-is
-	} else if sig.Results().Len() == 1 {
-		s += " " + sig.Results().At(0).Type().String()
-	} else {
-		s += " ("
-		for i := 0; i < sig.Results().Len(); i++ {
-			if i > 0 {
-				s += ", "
-			}
-			s += sig.Results().At(i).Type().String()
-		}
-		s += ")"
-	}
-	return s
-}
-
-// Simple pass that removes dead code. This pass makes later analysis passes
-// more useful.
-func (p *Program) SimpleDCE() error {
-	// Unmark all functions.
-	for _, f := range p.Functions {
-		f.flag = false
-	}
-
-	// Initial set of live functions. Include main.main, *.init and runtime.*
-	// functions.
-	main, ok := p.mainPkg.Members["main"].(*ssa.Function)
-	if !ok {
-		if p.mainPkg.Members["main"] == nil {
-			return errors.New("function main is undeclared in the main package")
-		} else {
-			return errors.New("cannot declare main - must be func")
-		}
-	}
-	runtimePkg := p.Program.ImportedPackage("runtime")
-	mathPkg := p.Program.ImportedPackage("math")
-	taskPkg := p.Program.ImportedPackage("internal/task")
-	p.GetFunction(main).flag = true
-	worklist := []*ssa.Function{main}
-	for _, f := range p.Functions {
-		if f.exported || f.Synthetic == "package initializer" || f.Pkg == runtimePkg || f.Pkg == taskPkg || (f.Pkg == mathPkg && f.Pkg != nil) {
-			if f.flag {
-				continue
-			}
-			f.flag = true
-			worklist = append(worklist, f.Function)
-		}
-	}
-
-	// Mark all called functions recursively.
-	for len(worklist) != 0 {
-		f := worklist[len(worklist)-1]
-		worklist = worklist[:len(worklist)-1]
-		for _, block := range f.Blocks {
-			for _, instr := range block.Instrs {
-				if instr, ok := instr.(*ssa.MakeInterface); ok {
-					for _, sel := range getAllMethods(p.Program, instr.X.Type()) {
-						fn := p.Program.MethodValue(sel)
-						callee := p.GetFunction(fn)
-						if callee == nil {
-							// TODO: why is this necessary?
-							p.addFunction(fn)
-							callee = p.GetFunction(fn)
-						}
-						if !callee.flag {
-							callee.flag = true
-							worklist = append(worklist, callee.Function)
-						}
-					}
-				}
-				for _, operand := range instr.Operands(nil) {
-					if operand == nil || *operand == nil {
-						continue
-					}
-					switch operand := (*operand).(type) {
-					case *ssa.Function:
-						f := p.GetFunction(operand)
-						if f == nil {
-							// FIXME HACK: this function should have been
-							// discovered already. It is not for bound methods.
-							p.addFunction(operand)
-							f = p.GetFunction(operand)
-						}
-						if !f.flag {
-							f.flag = true
-							worklist = append(worklist, operand)
-						}
-					}
-				}
-			}
-		}
-	}
-
-	// Remove unmarked functions.
-	livefunctions := []*Function{}
-	for _, f := range p.Functions {
-		if f.flag {
-			livefunctions = append(livefunctions, f)
-		} else {
-			delete(p.functionMap, f.Function)
-		}
-	}
-	p.Functions = livefunctions
-
-	return nil
-}

loader/goroot.go

@@ -189,7 +189,7 @@ func mergeDirectory(goroot, tinygoroot, tmpgoroot, importPath string, overrides
 // with the TinyGo version. This is the case on some targets.
 func needsSyscallPackage(buildTags []string) bool {
 	for _, tag := range buildTags {
-		if tag == "baremetal" || tag == "darwin" || tag == "nintendoswitch" {
+		if tag == "baremetal" || tag == "darwin" || tag == "nintendoswitch" || tag == "wasi" {
 			return true
 		}
 	}

loader/loader.go

@@ -16,7 +16,6 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
-	"syscall"
 
 	"github.com/tinygo-org/tinygo/cgo"
 	"github.com/tinygo-org/tinygo/compileopts"
@@ -43,6 +42,7 @@ type Program struct {
 type PackageJSON struct {
 	Dir        string
 	ImportPath string
+	Name       string
 	ForTest    string
 
 	// Source files
@@ -109,10 +109,7 @@ func Load(config *compileopts.Config, inputPkgs []string, clangHeaders string, t
 	err = cmd.Run()
 	if err != nil {
 		if exitErr, ok := err.(*exec.ExitError); ok {
-			if status, ok := exitErr.Sys().(syscall.WaitStatus); ok {
-				os.Exit(status.ExitStatus())
-			}
-			os.Exit(1)
+			os.Exit(exitErr.ExitCode())
 		}
 		return nil, fmt.Errorf("failed to run `go list`: %s", err)
 	}
@@ -169,6 +166,41 @@ func Load(config *compileopts.Config, inputPkgs []string, clangHeaders string, t
 			}
 			return nil, err
 		}
+		if config.TestConfig.CompileTestBinary {
+			// When creating a test binary, `go list` will list two or three
+			// packages used for testing the package. The first is the original
+			// package as if it were built normally, the second is the same
+			// package but with the *_test.go files included. A possible third
+			// may be included for _test packages (such as math_test), used to
+			// test the external API with no access to internal functions.
+			// All packages that are necessary for testing (including the to be
+			// tested package with *_test.go files, but excluding the original
+			// unmodified package) have a suffix added to the import path, for
+			// example the math package has import path "math [math.test]" and
+			// test dependencies such as fmt will have an import path of the
+			// form "fmt [math.test]".
+			// The code below removes this suffix, and if this results in a
+			// duplicate (which happens with the to-be-tested package without
+			// *.test.go files) the previous package is removed from the list of
+			// packages included in this build.
+			// This is necessary because the change in import paths results in
+			// breakage to //go:linkname. Additionally, the duplicated package
+			// slows down the build and so is best removed.
+			if pkg.ForTest != "" && strings.HasSuffix(pkg.ImportPath, " ["+pkg.ForTest+".test]") {
+				newImportPath := pkg.ImportPath[:len(pkg.ImportPath)-len(" ["+pkg.ForTest+".test]")]
+				if _, ok := p.Packages[newImportPath]; ok {
+					// Delete the previous package (that this package overrides).
+					delete(p.Packages, newImportPath)
+					for i, pkg := range p.sorted {
+						if pkg.ImportPath == newImportPath {
+							p.sorted = append(p.sorted[:i], p.sorted[i+1:]...) // remove element from slice
+							break
+						}
+					}
+				}
+				pkg.ImportPath = newImportPath
+			}
+		}
 		p.sorted = append(p.sorted, pkg)
 		p.Packages[pkg.ImportPath] = pkg
 	}
@@ -301,7 +333,16 @@ func (p *Package) Check() error {
 	// Do typechecking of the package.
 	checker.Importer = p
 
-	typesPkg, err := checker.Check(p.ImportPath, p.program.fset, p.Files, &p.info)
+	packageName := p.ImportPath
+	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)
 	if err != nil {
 		if err, ok := err.(Errors); ok {
 			return err
@@ -367,10 +408,8 @@ func (p *Package) Import(to string) (*types.Package, error) {
 	if to == "unsafe" {
 		return types.Unsafe, nil
 	}
-	if replace, ok := p.ImportMap[to]; ok {
-		// This import path should be replaced by another import path, according
-		// to `go list`.
-		to = replace
+	if newTo, ok := p.ImportMap[to]; ok && !strings.HasSuffix(newTo, ".test]") {
+		to = newTo
 	}
 	if imported, ok := p.program.Packages[to]; ok {
 		return imported.Pkg, nil

loader/ssa.go

@@ -16,3 +16,11 @@ func (p *Program) LoadSSA() *ssa.Program {
 
 	return prog
 }
+
+// LoadSSA constructs the SSA form of this package.
+//
+// The program must already be parsed and type-checked with the .Parse() method.
+func (p *Package) LoadSSA() *ssa.Package {
+	prog := ssa.NewProgram(p.program.fset, ssa.SanityCheckFunctions|ssa.BareInits|ssa.GlobalDebug)
+	return prog.CreatePackage(p.Pkg, p.Files, &p.info, true)
+}

main.go

@@ -14,16 +14,17 @@ import (
 	"os/signal"
 	"path/filepath"
 	"runtime"
-	"strconv"
 	"strings"
-	"syscall"
+	"sync/atomic"
 	"time"
 
+	"github.com/mattn/go-colorable"
 	"github.com/tinygo-org/tinygo/builder"
 	"github.com/tinygo-org/tinygo/compileopts"
 	"github.com/tinygo-org/tinygo/goenv"
 	"github.com/tinygo-org/tinygo/interp"
 	"github.com/tinygo-org/tinygo/loader"
+	"github.com/tinygo-org/tinygo/transform"
 	"tinygo.org/x/go-llvm"
 
 	"go.bug.st/serial"
@@ -74,7 +75,12 @@ func copyFile(src, dst string) error {
 	}
 	defer source.Close()
 
-	destination, err := os.Create(dst)
+	st, err := source.Stat()
+	if err != nil {
+		return err
+	}
+
+	destination, err := os.OpenFile(dst, os.O_RDWR|os.O_CREATE|os.O_TRUNC, st.Mode())
 	if err != nil {
 		return err
 	}
@@ -84,6 +90,14 @@ func copyFile(src, dst string) error {
 	return err
 }
 
+// executeCommand is a simple wrapper to exec.Cmd
+func executeCommand(options *compileopts.Options, name string, arg ...string) *exec.Cmd {
+	if options.PrintCommands {
+		fmt.Printf("%s %s\n ", name, strings.Join(arg, " "))
+	}
+	return exec.Command(name, arg...)
+}
+
 // 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)
@@ -91,7 +105,7 @@ func Build(pkgName, outpath string, options *compileopts.Options) error {
 		return err
 	}
 
-	return builder.Build(pkgName, outpath, config, func(result builder.BuildResult) error {
+	return builder.Build(pkgName, outpath, config, nil, func(result builder.BuildResult) error {
 		if err := os.Rename(result.Binary, outpath); err != nil {
 			// Moving failed. Do a file copy.
 			inf, err := os.Open(result.Binary)
@@ -120,30 +134,68 @@ func Build(pkgName, outpath string, options *compileopts.Options) error {
 }
 
 // Test runs the tests in the given package.
-func Test(pkgName string, options *compileopts.Options) error {
+func Test(pkgName string, options *compileopts.Options, testCompileOnly bool, outpath string) error {
 	options.TestConfig.CompileTestBinary = true
 	config, err := builder.NewConfig(options)
 	if err != nil {
 		return err
 	}
 
-	return builder.Build(pkgName, ".elf", config, func(result builder.BuildResult) error {
-		cmd := exec.Command(result.Binary)
-		cmd.Stdout = os.Stdout
-		cmd.Stderr = os.Stderr
-		cmd.Dir = result.MainDir
-		err := cmd.Run()
-		if err != nil {
-			// Propagate the exit code
-			if err, ok := err.(*exec.ExitError); ok {
-				if status, ok := err.Sys().(syscall.WaitStatus); ok {
-					os.Exit(status.ExitStatus())
-				}
-				os.Exit(1)
+	return builder.Build(pkgName, outpath, config, nil, func(result builder.BuildResult) error {
+		if testCompileOnly || outpath != "" {
+			// Write test binary to the specified file name.
+			if outpath == "" {
+				// No -o path was given, so create one now.
+				// This matches the behavior of go test.
+				outpath = filepath.Base(result.MainDir) + ".test"
+			}
+			copyFile(result.Binary, outpath)
+		}
+		if testCompileOnly {
+			// Do not run the test.
+			return nil
+		}
+		if len(config.Target.Emulator) == 0 {
+			// Run directly.
+			cmd := executeCommand(config.Options, result.Binary)
+			cmd.Stdout = os.Stdout
+			cmd.Stderr = os.Stderr
+			cmd.Dir = result.MainDir
+			err := cmd.Run()
+			if err != nil {
+				// Propagate the exit code
+				if err, ok := err.(*exec.ExitError); ok {
+					os.Exit(err.ExitCode())
+				}
+				return &commandError{"failed to run compiled binary", result.Binary, err}
+			}
+			return nil
+		} else {
+			// Run in an emulator.
+			args := append(config.Target.Emulator[1:], result.Binary)
+			cmd := executeCommand(config.Options, config.Target.Emulator[0], args...)
+			buf := &bytes.Buffer{}
+			w := io.MultiWriter(os.Stdout, buf)
+			cmd.Stdout = w
+			cmd.Stderr = os.Stderr
+			err := cmd.Run()
+			if err != nil {
+				if err, ok := err.(*exec.ExitError); !ok || !err.Exited() {
+					// Workaround for QEMU which always exits with an error.
+					return &commandError{"failed to run emulator with", result.Binary, err}
+				}
+			}
+			testOutput := string(buf.Bytes())
+			if testOutput == "PASS\n" || strings.HasSuffix(testOutput, "\nPASS\n") {
+				// Test passed.
+				return nil
+			} else {
+				// Test failed, either by ending with the word "FAIL" or with a
+				// panic of some sort.
+				os.Exit(1)
+				return nil // unreachable
 			}
-			return &commandError{"failed to run compiled binary", result.Binary, err}
 		}
-		return nil
 	})
 }
 
@@ -185,7 +237,7 @@ func Flash(pkgName, port string, options *compileopts.Options) error {
 		return errors.New("unknown flash method: " + flashMethod)
 	}
 
-	return builder.Build(pkgName, fileExt, config, func(result builder.BuildResult) error {
+	return builder.Build(pkgName, fileExt, config, func() error {
 		// do we need port reset to put MCU into bootloader mode?
 		if config.Target.PortReset == "true" && flashMethod != "openocd" {
 			if port == "" {
@@ -198,19 +250,21 @@ func Flash(pkgName, port string, options *compileopts.Options) error {
 
 			err := touchSerialPortAt1200bps(port)
 			if err != nil {
-				return &commandError{"failed to reset port", result.Binary, err}
+				return &commandError{"failed to reset port", "", err}
 			}
 			// give the target MCU a chance to restart into bootloader
 			time.Sleep(3 * time.Second)
 		}
+		return nil
 
+	}, func(result builder.BuildResult) error {
 		// this flashing method copies the binary data to a Mass Storage Device (msd)
 		switch flashMethod {
 		case "", "command":
 			// Create the command.
 			flashCmd := config.Target.FlashCommand
 			fileToken := "{" + fileExt[1:] + "}"
-			flashCmd = strings.Replace(flashCmd, fileToken, result.Binary, -1)
+			flashCmd = strings.ReplaceAll(flashCmd, fileToken, result.Binary)
 
 			if port == "" && strings.Contains(flashCmd, "{port}") {
 				var err error
@@ -220,7 +274,7 @@ func Flash(pkgName, port string, options *compileopts.Options) error {
 				}
 			}
 
-			flashCmd = strings.Replace(flashCmd, "{port}", port, -1)
+			flashCmd = strings.ReplaceAll(flashCmd, "{port}", port)
 
 			// Execute the command.
 			var cmd *exec.Cmd
@@ -230,9 +284,9 @@ func Flash(pkgName, port string, options *compileopts.Options) error {
 				if len(command) < 2 {
 					return errors.New("invalid flash command")
 				}
-				cmd = exec.Command(command[0], command[1:]...)
+				cmd = executeCommand(config.Options, command[0], command[1:]...)
 			default:
-				cmd = exec.Command("/bin/sh", "-c", flashCmd)
+				cmd = executeCommand(config.Options, "/bin/sh", "-c", flashCmd)
 			}
 
 			cmd.Stdout = os.Stdout
@@ -246,13 +300,13 @@ func Flash(pkgName, port string, options *compileopts.Options) error {
 		case "msd":
 			switch fileExt {
 			case ".uf2":
-				err := flashUF2UsingMSD(config.Target.FlashVolume, result.Binary)
+				err := flashUF2UsingMSD(config.Target.FlashVolume, result.Binary, config.Options)
 				if err != nil {
 					return &commandError{"failed to flash", result.Binary, err}
 				}
 				return nil
 			case ".hex":
-				err := flashHexUsingMSD(config.Target.FlashVolume, result.Binary)
+				err := flashHexUsingMSD(config.Target.FlashVolume, result.Binary, config.Options)
 				if err != nil {
 					return &commandError{"failed to flash", result.Binary, err}
 				}
@@ -266,7 +320,7 @@ func Flash(pkgName, port string, options *compileopts.Options) error {
 				return err
 			}
 			args = append(args, "-c", "program "+filepath.ToSlash(result.Binary)+" reset exit")
-			cmd := exec.Command("openocd", args...)
+			cmd := executeCommand(config.Options, "openocd", args...)
 			cmd.Stdout = os.Stdout
 			cmd.Stderr = os.Stderr
 			err = cmd.Run()
@@ -296,22 +350,28 @@ func FlashGDB(pkgName string, ocdOutput bool, options *compileopts.Options) erro
 		return errors.New("gdb not configured in the target specification")
 	}
 
-	return builder.Build(pkgName, "", config, func(result builder.BuildResult) error {
+	return builder.Build(pkgName, "", config, nil, func(result builder.BuildResult) error {
 		// Find a good way to run GDB.
 		gdbInterface, openocdInterface := config.Programmer()
 		switch gdbInterface {
 		case "msd", "command", "":
 			if len(config.Target.Emulator) != 0 {
-				// Assume QEMU as an emulator.
 				if config.Target.Emulator[0] == "mgba" {
 					gdbInterface = "mgba"
-				} else {
+				} else if config.Target.Emulator[0] == "simavr" {
+					gdbInterface = "simavr"
+				} else if strings.HasPrefix(config.Target.Emulator[0], "qemu-system-") {
 					gdbInterface = "qemu"
+				} else {
+					// Assume QEMU as an emulator.
+					gdbInterface = "qemu-user"
 				}
 			} else if openocdInterface != "" && config.Target.OpenOCDTarget != "" {
 				gdbInterface = "openocd"
 			} else if config.Target.JLinkDevice != "" {
 				gdbInterface = "jlink"
+			} else {
+				gdbInterface = "native"
 			}
 		}
 
@@ -329,11 +389,11 @@ func FlashGDB(pkgName string, ocdOutput bool, options *compileopts.Options) erro
 			if err != nil {
 				return err
 			}
-			daemon = exec.Command("openocd", args...)
+			daemon = executeCommand(config.Options, "openocd", args...)
 			if ocdOutput {
 				// Make it clear which output is from the daemon.
 				w := &ColorWriter{
-					Out:    os.Stderr,
+					Out:    colorable.NewColorableStderr(),
 					Prefix: "openocd: ",
 					Color:  TermColorYellow,
 				}
@@ -344,11 +404,11 @@ func FlashGDB(pkgName string, ocdOutput bool, options *compileopts.Options) erro
 			gdbCommands = append(gdbCommands, "target remote :2331", "load", "monitor reset halt")
 
 			// We need a separate debugging daemon for on-chip debugging.
-			daemon = exec.Command("JLinkGDBServer", "-device", config.Target.JLinkDevice)
+			daemon = executeCommand(config.Options, "JLinkGDBServer", "-device", config.Target.JLinkDevice)
 			if ocdOutput {
 				// Make it clear which output is from the daemon.
 				w := &ColorWriter{
-					Out:    os.Stderr,
+					Out:    colorable.NewColorableStderr(),
 					Prefix: "jlink: ",
 					Color:  TermColorYellow,
 				}
@@ -360,7 +420,15 @@ func FlashGDB(pkgName string, ocdOutput bool, options *compileopts.Options) erro
 
 			// Run in an emulator.
 			args := append(config.Target.Emulator[1:], result.Binary, "-s", "-S")
-			daemon = exec.Command(config.Target.Emulator[0], args...)
+			daemon = executeCommand(config.Options, config.Target.Emulator[0], args...)
+			daemon.Stdout = os.Stdout
+			daemon.Stderr = os.Stderr
+		case "qemu-user":
+			gdbCommands = append(gdbCommands, "target remote :1234")
+
+			// Run in an emulator.
+			args := append(config.Target.Emulator[1:], "-g", "1234", result.Binary)
+			daemon = executeCommand(config.Options, config.Target.Emulator[0], args...)
 			daemon.Stdout = os.Stdout
 			daemon.Stderr = os.Stderr
 		case "mgba":
@@ -368,7 +436,15 @@ func FlashGDB(pkgName string, ocdOutput bool, options *compileopts.Options) erro
 
 			// Run in an emulator.
 			args := append(config.Target.Emulator[1:], result.Binary, "-g")
-			daemon = exec.Command(config.Target.Emulator[0], args...)
+			daemon = executeCommand(config.Options, config.Target.Emulator[0], args...)
+			daemon.Stdout = os.Stdout
+			daemon.Stderr = os.Stderr
+		case "simavr":
+			gdbCommands = append(gdbCommands, "target remote :1234")
+
+			// Run in an emulator.
+			args := append(config.Target.Emulator[1:], "-g", result.Binary)
+			daemon = executeCommand(config.Options, config.Target.Emulator[0], args...)
 			daemon.Stdout = os.Stdout
 			daemon.Stderr = os.Stderr
 		case "msd":
@@ -389,8 +465,15 @@ func FlashGDB(pkgName string, ocdOutput bool, options *compileopts.Options) erro
 			}
 			defer func() {
 				daemon.Process.Signal(os.Interrupt)
-				// Maybe we should send a .Kill() after x seconds?
+				var stopped uint32
+				go func() {
+					time.Sleep(time.Millisecond * 100)
+					if atomic.LoadUint32(&stopped) == 0 {
+						daemon.Process.Kill()
+					}
+				}()
 				daemon.Wait()
+				atomic.StoreUint32(&stopped, 1)
 			}()
 		}
 
@@ -409,7 +492,7 @@ func FlashGDB(pkgName string, ocdOutput bool, options *compileopts.Options) erro
 		for _, cmd := range gdbCommands {
 			params = append(params, "-ex", cmd)
 		}
-		cmd := exec.Command(config.Target.GDB, params...)
+		cmd := executeCommand(config.Options, config.Target.GDB, params...)
 		cmd.Stdin = os.Stdin
 		cmd.Stdout = os.Stdout
 		cmd.Stderr = os.Stderr
@@ -431,10 +514,10 @@ func Run(pkgName string, options *compileopts.Options) error {
 		return err
 	}
 
-	return builder.Build(pkgName, ".elf", config, func(result builder.BuildResult) error {
+	return builder.Build(pkgName, ".elf", config, nil, func(result builder.BuildResult) error {
 		if len(config.Target.Emulator) == 0 {
 			// Run directly.
-			cmd := exec.Command(result.Binary)
+			cmd := executeCommand(config.Options, result.Binary)
 			cmd.Stdout = os.Stdout
 			cmd.Stderr = os.Stderr
 			err := cmd.Run()
@@ -449,7 +532,7 @@ func Run(pkgName string, options *compileopts.Options) error {
 		} else {
 			// Run in an emulator.
 			args := append(config.Target.Emulator[1:], result.Binary)
-			cmd := exec.Command(config.Target.Emulator[0], args...)
+			cmd := executeCommand(config.Options, config.Target.Emulator[0], args...)
 			cmd.Stdout = os.Stdout
 			cmd.Stderr = os.Stderr
 			err := cmd.Run()
@@ -492,7 +575,7 @@ func touchSerialPortAt1200bps(port string) (err error) {
 
 const maxMSDRetries = 10
 
-func flashUF2UsingMSD(volume, tmppath string) error {
+func flashUF2UsingMSD(volume, tmppath string, options *compileopts.Options) error {
 	// find standard UF2 info path
 	var infoPath string
 	switch runtime.GOOS {
@@ -501,7 +584,7 @@ func flashUF2UsingMSD(volume, tmppath string) error {
 	case "darwin":
 		infoPath = "/Volumes/" + volume + "/INFO_UF2.TXT"
 	case "windows":
-		path, err := windowsFindUSBDrive(volume)
+		path, err := windowsFindUSBDrive(volume, options)
 		if err != nil {
 			return err
 		}
@@ -516,7 +599,7 @@ func flashUF2UsingMSD(volume, tmppath string) error {
 	return moveFile(tmppath, filepath.Dir(d)+"/flash.uf2")
 }
 
-func flashHexUsingMSD(volume, tmppath string) error {
+func flashHexUsingMSD(volume, tmppath string, options *compileopts.Options) error {
 	// find expected volume path
 	var destPath string
 	switch runtime.GOOS {
@@ -525,7 +608,7 @@ func flashHexUsingMSD(volume, tmppath string) error {
 	case "darwin":
 		destPath = "/Volumes/" + volume
 	case "windows":
-		path, err := windowsFindUSBDrive(volume)
+		path, err := windowsFindUSBDrive(volume, options)
 		if err != nil {
 			return err
 		}
@@ -559,8 +642,8 @@ func locateDevice(volume, path string) (string, error) {
 	return d[0], nil
 }
 
-func windowsFindUSBDrive(volume string) (string, error) {
-	cmd := exec.Command("wmic",
+func windowsFindUSBDrive(volume string, options *compileopts.Options) (string, error) {
+	cmd := executeCommand(options, "wmic",
 		"PATH", "Win32_LogicalDisk", "WHERE", "VolumeName = '"+volume+"'",
 		"get", "DeviceID,VolumeName,FileSystem,DriveType")
 
@@ -582,30 +665,6 @@ func windowsFindUSBDrive(volume string) (string, error) {
 	return "", errors.New("unable to locate a USB device to be flashed")
 }
 
-// parseSize converts a human-readable size (with k/m/g suffix) into a plain
-// number.
-func parseSize(s string) (int64, error) {
-	s = strings.ToLower(strings.TrimSpace(s))
-	if len(s) == 0 {
-		return 0, errors.New("no size provided")
-	}
-	multiply := int64(1)
-	switch s[len(s)-1] {
-	case 'k':
-		multiply = 1 << 10
-	case 'm':
-		multiply = 1 << 20
-	case 'g':
-		multiply = 1 << 30
-	}
-	if multiply != 1 {
-		s = s[:len(s)-1]
-	}
-	n, err := strconv.ParseInt(s, 0, 64)
-	n *= multiply
-	return n, err
-}
-
 // getDefaultPort returns the default serial port depending on the operating system.
 func getDefaultPort() (port string, err error) {
 	var portPath string
@@ -716,6 +775,15 @@ func printCompilerError(logln func(...interface{}), err error) {
 				logln()
 			}
 		}
+	case transform.CoroutinesError:
+		logln(err.Pos.String() + ": " + err.Msg)
+		logln("\ntraceback:")
+		for _, line := range err.Traceback {
+			logln(line.Name)
+			if line.Position.IsValid() {
+				logln("\t" + line.Position.String())
+			}
+		}
 	case loader.Errors:
 		logln("#", err.Pkg.ImportPath)
 		for _, err := range err.Errs {
@@ -753,7 +821,6 @@ func main() {
 	}
 	command := os.Args[1]
 
-	outpath := flag.String("o", "", "output filename")
 	opt := flag.String("opt", "z", "optimization level: 0, 1, 2, s, z")
 	gc := flag.String("gc", "", "garbage collector to use (none, leaking, extalloc, conservative)")
 	panicStrategy := flag.String("panic", "print", "panic strategy (print, trap)")
@@ -765,20 +832,28 @@ func main() {
 	target := flag.String("target", "", "LLVM target | .json file with TargetSpec")
 	printSize := flag.String("size", "", "print sizes (none, short, full)")
 	printStacks := flag.Bool("print-stacks", false, "print stack sizes of goroutines")
+	printCommands := flag.Bool("x", false, "Print commands")
 	nodebug := flag.Bool("no-debug", false, "disable DWARF debug symbol generation")
 	ocdOutput := flag.Bool("ocd-output", false, "print OCD daemon output during debug")
 	port := flag.String("port", "", "flash port")
 	programmer := flag.String("programmer", "", "which hardware programmer to use")
 	cFlags := flag.String("cflags", "", "additional cflags for compiler")
 	ldFlags := flag.String("ldflags", "", "additional ldflags for linker")
-	wasmAbi := flag.String("wasm-abi", "js", "WebAssembly ABI conventions: js (no i64 params) or generic")
-	heapSize := flag.String("heap-size", "1M", "default heap size in bytes (only supported by WebAssembly)")
+	wasmAbi := flag.String("wasm-abi", "", "WebAssembly ABI conventions: js (no i64 params) or generic")
 
 	var flagJSON, flagDeps *bool
-	if command == "list" {
+	if command == "help" || command == "list" {
 		flagJSON = flag.Bool("json", false, "print data in JSON format")
 		flagDeps = flag.Bool("deps", false, "")
 	}
+	var outpath string
+	if command == "help" || command == "build" || command == "build-library" || command == "test" {
+		flag.StringVar(&outpath, "o", "", "output filename")
+	}
+	var testCompileOnlyFlag *bool
+	if command == "help" || command == "test" {
+		testCompileOnlyFlag = flag.Bool("c", false, "compile the test binary but do not run it")
+	}
 
 	// Early command processing, before commands are interpreted by the Go flag
 	// library.
@@ -805,6 +880,7 @@ func main() {
 		Debug:         !*nodebug,
 		PrintSizes:    *printSize,
 		PrintStacks:   *printStacks,
+		PrintCommands: *printCommands,
 		Tags:          *tags,
 		WasmAbi:       *wasmAbi,
 		Programmer:    *programmer,
@@ -818,16 +894,9 @@ func main() {
 		options.LDFlags = strings.Split(*ldFlags, " ")
 	}
 
-	var err error
-	if options.HeapSize, err = parseSize(*heapSize); err != nil {
-		fmt.Fprintln(os.Stderr, "Could not read heap size:", *heapSize)
-		usage()
-		os.Exit(1)
-	}
-
 	os.Setenv("CC", "clang -target="+*target)
 
-	err = options.Verify()
+	err := options.Verify()
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err.Error())
 		usage()
@@ -836,7 +905,7 @@ func main() {
 
 	switch command {
 	case "build":
-		if *outpath == "" {
+		if outpath == "" {
 			fmt.Fprintln(os.Stderr, "No output filename supplied (-o).")
 			usage()
 			os.Exit(1)
@@ -849,15 +918,15 @@ func main() {
 			usage()
 			os.Exit(1)
 		}
-		if options.Target == "" && filepath.Ext(*outpath) == ".wasm" {
+		if options.Target == "" && filepath.Ext(outpath) == ".wasm" {
 			options.Target = "wasm"
 		}
 
-		err := Build(pkgName, *outpath, options)
+		err := Build(pkgName, outpath, options)
 		handleCompilerError(err)
 	case "build-library":
 		// Note: this command is only meant to be used while making a release!
-		if *outpath == "" {
+		if outpath == "" {
 			fmt.Fprintln(os.Stderr, "No output filename supplied (-o).")
 			usage()
 			os.Exit(1)
@@ -880,15 +949,18 @@ func main() {
 			fmt.Fprintf(os.Stderr, "Unknown library: %s\n", name)
 			os.Exit(1)
 		}
-		path, err := lib.Load(*target)
-		handleCompilerError(err)
-		copyFile(path, *outpath)
-	case "flash", "gdb":
-		if *outpath != "" {
-			fmt.Fprintln(os.Stderr, "Output cannot be specified with the flash command.")
-			usage()
-			os.Exit(1)
+		tmpdir, err := ioutil.TempDir("", "tinygo*")
+		if err != nil {
+			handleCompilerError(err)
 		}
+		defer os.RemoveAll(tmpdir)
+		path, err := lib.Load(*target, tmpdir)
+		handleCompilerError(err)
+		err = copyFile(path, outpath)
+		if err != nil {
+			handleCompilerError(err)
+		}
+	case "flash", "gdb":
 		pkgName := filepath.ToSlash(flag.Arg(0))
 		if command == "flash" {
 			err := Flash(pkgName, *port, options)
@@ -920,7 +992,7 @@ func main() {
 			usage()
 			os.Exit(1)
 		}
-		err := Test(pkgName, options)
+		err := Test(pkgName, options, *testCompileOnlyFlag, outpath)
 		handleCompilerError(err)
 	case "targets":
 		dir := filepath.Join(goenv.Get("TINYGOROOT"), "targets")
@@ -1006,10 +1078,7 @@ func main() {
 		err = cmd.Run()
 		if err != nil {
 			if exitErr, ok := err.(*exec.ExitError); ok {
-				if status, ok := exitErr.Sys().(syscall.WaitStatus); ok {
-					os.Exit(status.ExitStatus())
-				}
-				os.Exit(1)
+				os.Exit(exitErr.ExitCode())
 			}
 			fmt.Fprintln(os.Stderr, "failed to run `go list`:", err)
 			os.Exit(1)

main_test.go

@@ -58,6 +58,9 @@ func TestCompiler(t *testing.T) {
 	if runtime.GOOS != "windows" {
 		t.Run("Host", func(t *testing.T) {
 			runPlatTests("", matches, t)
+			if runtime.GOOS == "darwin" {
+				runTest("testdata/libc/env.go", "", t, []string{"ENV1=VALUE1", "ENV2=VALUE2"}...)
+			}
 		})
 	}
 
@@ -78,6 +81,9 @@ func TestCompiler(t *testing.T) {
 	}
 
 	if runtime.GOOS == "linux" {
+		t.Run("X86Linux", func(t *testing.T) {
+			runPlatTests("i386--linux-gnu", matches, t)
+		})
 		t.Run("ARMLinux", func(t *testing.T) {
 			runPlatTests("arm--linux-gnueabihf", matches, t)
 		})
@@ -98,6 +104,11 @@ func TestCompiler(t *testing.T) {
 				runPlatTests("wasm", matches, t)
 			})
 		}
+
+		t.Run("WASI", func(t *testing.T) {
+			runPlatTests("wasi", matches, t)
+			runTest("testdata/libc/env.go", "wasi", t, []string{"ENV1=VALUE1", "ENV2=VALUE2"}...)
+		})
 	}
 }
 
@@ -106,10 +117,8 @@ func runPlatTests(target string, matches []string, t *testing.T) {
 
 	for _, path := range matches {
 		path := path // redefine to avoid race condition
-
 		t.Run(filepath.Base(path), func(t *testing.T) {
 			t.Parallel()
-
 			runTest(path, target, t)
 		})
 	}
@@ -127,7 +136,7 @@ func runBuild(src, out string, opts *compileopts.Options) error {
 	return Build(src, out, opts)
 }
 
-func runTest(path, target string, t *testing.T) {
+func runTest(path, target string, t *testing.T, environmentVars ...string) {
 	// Get the expected output for this test.
 	txtpath := path[:len(path)-3] + ".txt"
 	if path[len(path)-1] == os.PathSeparator {
@@ -159,8 +168,9 @@ func runTest(path, target string, t *testing.T) {
 		VerifyIR:   true,
 		Debug:      true,
 		PrintSizes: "",
-		WasmAbi:    "js",
+		WasmAbi:    "",
 	}
+
 	binary := filepath.Join(tmpdir, "test")
 	err = runBuild("./"+path, binary, config)
 	if err != nil {
@@ -175,16 +185,26 @@ func runTest(path, target string, t *testing.T) {
 	ranTooLong := false
 	if target == "" {
 		cmd = exec.Command(binary)
+		cmd.Env = append(cmd.Env, environmentVars...)
 	} else {
 		spec, err := compileopts.LoadTarget(target)
 		if err != nil {
 			t.Fatal("failed to load target spec:", err)
 		}
 		if len(spec.Emulator) == 0 {
-			t.Fatal("no emulator available for target:", target)
+			cmd = exec.Command(binary)
+		} else {
+			args := append(spec.Emulator[1:], binary)
+			cmd = exec.Command(spec.Emulator[0], args...)
+		}
+
+		if len(spec.Emulator) != 0 && spec.Emulator[0] == "wasmtime" {
+			for _, v := range environmentVars {
+				cmd.Args = append(cmd.Args, "--env", v)
+			}
+		} else {
+			cmd.Env = append(cmd.Env, environmentVars...)
 		}
-		args := append(spec.Emulator[1:], binary)
-		cmd = exec.Command(spec.Emulator[0], args...)
 	}
 	stdout := &bytes.Buffer{}
 	cmd.Stdout = stdout

src/device/arm/arm.go

@@ -76,32 +76,8 @@ const (
 	SCS_BASE  = 0xE000E000
 	SYST_BASE = SCS_BASE + 0x0010
 	NVIC_BASE = SCS_BASE + 0x0100
-	SCB_BASE  = SCS_BASE + 0x0D00
 )
 
-const (
-	SCB_AIRCR_VECTKEY_Pos     = 16
-	SCB_AIRCR_SYSRESETREQ_Pos = 2
-	SCB_AIRCR_SYSRESETREQ_Msk = 1 << SCB_AIRCR_SYSRESETREQ_Pos
-)
-
-// System Control Block (SCB)
-//
-// SCB_Type provides the definitions for the System Control Block Registers.
-type SCB_Type struct {
-	CPUID volatile.Register32    // CPUID Base Register
-	ICSR  volatile.Register32    // Interrupt Control and State Register
-	VTOR  volatile.Register32    // Vector Table Offset Register
-	AIRCR volatile.Register32    // Application Interrupt and Reset Control Register
-	SCR   volatile.Register32    // System Control Register
-	CCR   volatile.Register32    // Configuration Control Register
-	_     volatile.Register32    // RESERVED1;
-	SHP   [2]volatile.Register32 // System Handlers Priority Registers. [0] is RESERVED
-	SHCSR volatile.Register32    // System Handler Control and State Register
-}
-
-var SCB = (*SCB_Type)(unsafe.Pointer(uintptr(SCB_BASE)))
-
 // Nested Vectored Interrupt Controller (NVIC).
 //
 // Source:
@@ -213,17 +189,6 @@ func EnableInterrupts(mask uintptr) {
 	})
 }
 
-// SystemReset performs a hard system reset.
-func SystemReset() {
-	// SCB->AIRCR  = ((0x5FA << SCB_AIRCR_VECTKEY_Pos)      |
-	//              SCB_AIRCR_SYSRESETREQ_Msk);
-	SCB.AIRCR.Set((0x5FA << SCB_AIRCR_VECTKEY_Pos) | SCB_AIRCR_SYSRESETREQ_Msk)
-
-	for {
-		Asm("wfi")
-	}
-}
-
 // Set up the system timer to generate periodic tick events.
 // This will cause SysTick_Handler to fire once per tick.
 // The cyclecount parameter is a counter value which can range from 0 to

src/device/arm/scb.go

@@ -0,0 +1,431 @@
+// Hand created file. DO NOT DELETE.
+// Cortex-M System Control Block-related definitions.
+
+// +build cortexm
+
+package arm
+
+import (
+	"runtime/volatile"
+	"unsafe"
+)
+
+const SCB_BASE = SCS_BASE + 0x0D00
+
+// System Control Block (SCB)
+//
+// SCB_Type provides the definitions for the System Control Block Registers.
+type SCB_Type struct {
+	CPUID volatile.Register32 // 0xD00: CPUID Base Register
+	ICSR  volatile.Register32 // 0xD04: Interrupt Control and State Register
+	VTOR  volatile.Register32 // 0xD08: Vector Table Offset Register
+	AIRCR volatile.Register32 // 0xD0C: Application Interrupt and Reset Control Register
+	SCR   volatile.Register32 // 0xD10: System Control Register
+	CCR   volatile.Register32 // 0xD14: Configuration and Control Register
+	SHPR1 volatile.Register32 // 0xD18: System Handler Priority Register 1 (Cortex-M3/M33/M4/M7 only)
+	SHPR2 volatile.Register32 // 0xD1C: System Handler Priority Register 2
+	SHPR3 volatile.Register32 // 0xD20: System Handler Priority Register 3
+	// the following are only applicable for Cortex-M3/M33/M4/M7
+	SHCSR volatile.Register32 // 0xD24: System Handler Control and State Register
+	CFSR  volatile.Register32 // 0xD28: Configurable Fault Status Register
+	HFSR  volatile.Register32 // 0xD2C: HardFault Status Register
+	DFSR  volatile.Register32 // 0xD30: Debug Fault Status Register
+	MMFAR volatile.Register32 // 0xD34: MemManage Fault Address Register
+	BFAR  volatile.Register32 // 0xD38: BusFault Address Register
+}
+
+var SCB = (*SCB_Type)(unsafe.Pointer(uintptr(SCB_BASE)))
+
+// SystemReset performs a hard system reset.
+func SystemReset() {
+	SCB.AIRCR.Set((0x5FA << SCB_AIRCR_VECTKEY_Pos) | SCB_AIRCR_SYSRESETREQ_Msk)
+	for {
+		Asm("wfi")
+	}
+}
+
+const (
+	// CPUID: CPUID Base Register
+	SCB_CPUID_REVISION_Pos     = 0x0        // Position of REVISION field.
+	SCB_CPUID_REVISION_Msk     = 0xf        // Bit mask of REVISION field.
+	SCB_CPUID_PARTNO_Pos       = 0x4        // Position of PARTNO field.
+	SCB_CPUID_PARTNO_Msk       = 0xfff0     // Bit mask of PARTNO field.
+	SCB_CPUID_ARCHITECTURE_Pos = 0x10       // Position of ARCHITECTURE field.
+	SCB_CPUID_ARCHITECTURE_Msk = 0xf0000    // Bit mask of ARCHITECTURE field.
+	SCB_CPUID_VARIANT_Pos      = 0x14       // Position of VARIANT field.
+	SCB_CPUID_VARIANT_Msk      = 0xf00000   // Bit mask of VARIANT field.
+	SCB_CPUID_IMPLEMENTER_Pos  = 0x18       // Position of IMPLEMENTER field.
+	SCB_CPUID_IMPLEMENTER_Msk  = 0xff000000 // Bit mask of IMPLEMENTER field.
+
+	// ICSR: Interrupt Control and State Register
+	SCB_ICSR_VECTACTIVE_Pos          = 0x0        // Position of VECTACTIVE field.
+	SCB_ICSR_VECTACTIVE_Msk          = 0x1ff      // Bit mask of VECTACTIVE field.
+	SCB_ICSR_RETTOBASE_Pos           = 0xb        // Position of RETTOBASE field.
+	SCB_ICSR_RETTOBASE_Msk           = 0x800      // Bit mask of RETTOBASE field.
+	SCB_ICSR_RETTOBASE               = 0x800      // Bit RETTOBASE.
+	SCB_ICSR_RETTOBASE_RETTOBASE_0   = 0x0        // there are preempted active exceptions to execute
+	SCB_ICSR_RETTOBASE_RETTOBASE_1   = 0x1        // there are no active exceptions, or the currently-executing exception is the only active exception
+	SCB_ICSR_VECTPENDING_Pos         = 0xc        // Position of VECTPENDING field.
+	SCB_ICSR_VECTPENDING_Msk         = 0x1ff000   // Bit mask of VECTPENDING field.
+	SCB_ICSR_ISRPENDING_Pos          = 0x16       // Position of ISRPENDING field.
+	SCB_ICSR_ISRPENDING_Msk          = 0x400000   // Bit mask of ISRPENDING field.
+	SCB_ICSR_ISRPENDING              = 0x400000   // Bit ISRPENDING.
+	SCB_ICSR_ISRPENDING_ISRPENDING_0 = 0x0        // No external interrupt pending.
+	SCB_ICSR_ISRPENDING_ISRPENDING_1 = 0x1        // External interrupt pending.
+	SCB_ICSR_PENDSTCLR_Pos           = 0x19       // Position of PENDSTCLR field.
+	SCB_ICSR_PENDSTCLR_Msk           = 0x2000000  // Bit mask of PENDSTCLR field.
+	SCB_ICSR_PENDSTCLR               = 0x2000000  // Bit PENDSTCLR.
+	SCB_ICSR_PENDSTCLR_PENDSTCLR_0   = 0x0        // no effect
+	SCB_ICSR_PENDSTCLR_PENDSTCLR_1   = 0x1        // removes the pending state from the SysTick exception
+	SCB_ICSR_PENDSTSET_Pos           = 0x1a       // Position of PENDSTSET field.
+	SCB_ICSR_PENDSTSET_Msk           = 0x4000000  // Bit mask of PENDSTSET field.
+	SCB_ICSR_PENDSTSET               = 0x4000000  // Bit PENDSTSET.
+	SCB_ICSR_PENDSTSET_PENDSTSET_0   = 0x0        // write: no effect; read: SysTick exception is not pending
+	SCB_ICSR_PENDSTSET_PENDSTSET_1   = 0x1        // write: changes SysTick exception state to pending; read: SysTick exception is pending
+	SCB_ICSR_PENDSVCLR_Pos           = 0x1b       // Position of PENDSVCLR field.
+	SCB_ICSR_PENDSVCLR_Msk           = 0x8000000  // Bit mask of PENDSVCLR field.
+	SCB_ICSR_PENDSVCLR               = 0x8000000  // Bit PENDSVCLR.
+	SCB_ICSR_PENDSVCLR_PENDSVCLR_0   = 0x0        // no effect
+	SCB_ICSR_PENDSVCLR_PENDSVCLR_1   = 0x1        // removes the pending state from the PendSV exception
+	SCB_ICSR_PENDSVSET_Pos           = 0x1c       // Position of PENDSVSET field.
+	SCB_ICSR_PENDSVSET_Msk           = 0x10000000 // Bit mask of PENDSVSET field.
+	SCB_ICSR_PENDSVSET               = 0x10000000 // Bit PENDSVSET.
+	SCB_ICSR_PENDSVSET_PENDSVSET_0   = 0x0        // write: no effect; read: PendSV exception is not pending
+	SCB_ICSR_PENDSVSET_PENDSVSET_1   = 0x1        // write: changes PendSV exception state to pending; read: PendSV exception is pending
+	SCB_ICSR_NMIPENDSET_Pos          = 0x1f       // Position of NMIPENDSET field.
+	SCB_ICSR_NMIPENDSET_Msk          = 0x80000000 // Bit mask of NMIPENDSET field.
+	SCB_ICSR_NMIPENDSET              = 0x80000000 // Bit NMIPENDSET.
+	SCB_ICSR_NMIPENDSET_NMIPENDSET_0 = 0x0        // write: no effect; read: NMI exception is not pending
+	SCB_ICSR_NMIPENDSET_NMIPENDSET_1 = 0x1        // write: changes NMI exception state to pending; read: NMI exception is pending
+
+	// VTOR: Vector Table Offset Register
+	SCB_VTOR_TBLOFF_Pos = 0x7        // Position of TBLOFF field.
+	SCB_VTOR_TBLOFF_Msk = 0xffffff80 // Bit mask of TBLOFF field.
+
+	// AIRCR: Application Interrupt and Reset Control Register
+	SCB_AIRCR_VECTRESET_Pos                 = 0x0        // Position of VECTRESET field.
+	SCB_AIRCR_VECTRESET_Msk                 = 0x1        // Bit mask of VECTRESET field.
+	SCB_AIRCR_VECTRESET                     = 0x1        // Bit VECTRESET.
+	SCB_AIRCR_VECTRESET_VECTRESET_0         = 0x0        // No change
+	SCB_AIRCR_VECTRESET_VECTRESET_1         = 0x1        // Causes a local system reset
+	SCB_AIRCR_VECTCLRACTIVE_Pos             = 0x1        // Position of VECTCLRACTIVE field.
+	SCB_AIRCR_VECTCLRACTIVE_Msk             = 0x2        // Bit mask of VECTCLRACTIVE field.
+	SCB_AIRCR_VECTCLRACTIVE                 = 0x2        // Bit VECTCLRACTIVE.
+	SCB_AIRCR_VECTCLRACTIVE_VECTCLRACTIVE_0 = 0x0        // No change
+	SCB_AIRCR_VECTCLRACTIVE_VECTCLRACTIVE_1 = 0x1        // Clears all active state information for fixed and configurable exceptions
+	SCB_AIRCR_SYSRESETREQ_Pos               = 0x2        // Position of SYSRESETREQ field.
+	SCB_AIRCR_SYSRESETREQ_Msk               = 0x4        // Bit mask of SYSRESETREQ field.
+	SCB_AIRCR_SYSRESETREQ                   = 0x4        // Bit SYSRESETREQ.
+	SCB_AIRCR_SYSRESETREQ_SYSRESETREQ_0     = 0x0        // no system reset request
+	SCB_AIRCR_SYSRESETREQ_SYSRESETREQ_1     = 0x1        // asserts a signal to the outer system that requests a reset
+	SCB_AIRCR_PRIGROUP_Pos                  = 0x8        // Position of PRIGROUP field.
+	SCB_AIRCR_PRIGROUP_Msk                  = 0x700      // Bit mask of PRIGROUP field.
+	SCB_AIRCR_ENDIANNESS_Pos                = 0xf        // Position of ENDIANNESS field.
+	SCB_AIRCR_ENDIANNESS_Msk                = 0x8000     // Bit mask of ENDIANNESS field.
+	SCB_AIRCR_ENDIANNESS                    = 0x8000     // Bit ENDIANNESS.
+	SCB_AIRCR_ENDIANNESS_ENDIANNESS_0       = 0x0        // Little-endian
+	SCB_AIRCR_ENDIANNESS_ENDIANNESS_1       = 0x1        // Big-endian
+	SCB_AIRCR_VECTKEY_Pos                   = 0x10       // Position of VECTKEY field.
+	SCB_AIRCR_VECTKEY_Msk                   = 0xffff0000 // Bit mask of VECTKEY field.
+
+	// SCR: System Control Register
+	SCB_SCR_SLEEPONEXIT_Pos           = 0x1  // Position of SLEEPONEXIT field.
+	SCB_SCR_SLEEPONEXIT_Msk           = 0x2  // Bit mask of SLEEPONEXIT field.
+	SCB_SCR_SLEEPONEXIT               = 0x2  // Bit SLEEPONEXIT.
+	SCB_SCR_SLEEPONEXIT_SLEEPONEXIT_0 = 0x0  // o not sleep when returning to Thread mode
+	SCB_SCR_SLEEPONEXIT_SLEEPONEXIT_1 = 0x1  // enter sleep, or deep sleep, on return from an ISR
+	SCB_SCR_SLEEPDEEP_Pos             = 0x2  // Position of SLEEPDEEP field.
+	SCB_SCR_SLEEPDEEP_Msk             = 0x4  // Bit mask of SLEEPDEEP field.
+	SCB_SCR_SLEEPDEEP                 = 0x4  // Bit SLEEPDEEP.
+	SCB_SCR_SLEEPDEEP_SLEEPDEEP_0     = 0x0  // sleep
+	SCB_SCR_SLEEPDEEP_SLEEPDEEP_1     = 0x1  // deep sleep
+	SCB_SCR_SEVONPEND_Pos             = 0x4  // Position of SEVONPEND field.
+	SCB_SCR_SEVONPEND_Msk             = 0x10 // Bit mask of SEVONPEND field.
+	SCB_SCR_SEVONPEND                 = 0x10 // Bit SEVONPEND.
+	SCB_SCR_SEVONPEND_SEVONPEND_0     = 0x0  // only enabled interrupts or events can wakeup the processor, disabled interrupts are excluded
+	SCB_SCR_SEVONPEND_SEVONPEND_1     = 0x1  // enabled events and all interrupts, including disabled interrupts, can wakeup the processor
+
+	// CCR: Configuration and Control Register
+	SCB_CCR_NONBASETHRDENA_Pos              = 0x0     // Position of NONBASETHRDENA field.
+	SCB_CCR_NONBASETHRDENA_Msk              = 0x1     // Bit mask of NONBASETHRDENA field.
+	SCB_CCR_NONBASETHRDENA                  = 0x1     // Bit NONBASETHRDENA.
+	SCB_CCR_NONBASETHRDENA_NONBASETHRDENA_0 = 0x0     // processor can enter Thread mode only when no exception is active
+	SCB_CCR_NONBASETHRDENA_NONBASETHRDENA_1 = 0x1     // processor can enter Thread mode from any level under the control of an EXC_RETURN value
+	SCB_CCR_USERSETMPEND_Pos                = 0x1     // Position of USERSETMPEND field.
+	SCB_CCR_USERSETMPEND_Msk                = 0x2     // Bit mask of USERSETMPEND field.
+	SCB_CCR_USERSETMPEND                    = 0x2     // Bit USERSETMPEND.
+	SCB_CCR_USERSETMPEND_USERSETMPEND_0     = 0x0     // disable
+	SCB_CCR_USERSETMPEND_USERSETMPEND_1     = 0x1     // enable
+	SCB_CCR_UNALIGN_TRP_Pos                 = 0x3     // Position of UNALIGN_TRP field.
+	SCB_CCR_UNALIGN_TRP_Msk                 = 0x8     // Bit mask of UNALIGN_TRP field.
+	SCB_CCR_UNALIGN_TRP                     = 0x8     // Bit UNALIGN_TRP.
+	SCB_CCR_UNALIGN_TRP_UNALIGN_TRP_0       = 0x0     // do not trap unaligned halfword and word accesses
+	SCB_CCR_UNALIGN_TRP_UNALIGN_TRP_1       = 0x1     // trap unaligned halfword and word accesses
+	SCB_CCR_DIV_0_TRP_Pos                   = 0x4     // Position of DIV_0_TRP field.
+	SCB_CCR_DIV_0_TRP_Msk                   = 0x10    // Bit mask of DIV_0_TRP field.
+	SCB_CCR_DIV_0_TRP                       = 0x10    // Bit DIV_0_TRP.
+	SCB_CCR_DIV_0_TRP_DIV_0_TRP_0           = 0x0     // do not trap divide by 0
+	SCB_CCR_DIV_0_TRP_DIV_0_TRP_1           = 0x1     // trap divide by 0
+	SCB_CCR_BFHFNMIGN_Pos                   = 0x8     // Position of BFHFNMIGN field.
+	SCB_CCR_BFHFNMIGN_Msk                   = 0x100   // Bit mask of BFHFNMIGN field.
+	SCB_CCR_BFHFNMIGN                       = 0x100   // Bit BFHFNMIGN.
+	SCB_CCR_BFHFNMIGN_BFHFNMIGN_0           = 0x0     // data bus faults caused by load and store instructions cause a lock-up
+	SCB_CCR_BFHFNMIGN_BFHFNMIGN_1           = 0x1     // handlers running at priority -1 and -2 ignore data bus faults caused by load and store instructions
+	SCB_CCR_STKALIGN_Pos                    = 0x9     // Position of STKALIGN field.
+	SCB_CCR_STKALIGN_Msk                    = 0x200   // Bit mask of STKALIGN field.
+	SCB_CCR_STKALIGN                        = 0x200   // Bit STKALIGN.
+	SCB_CCR_STKALIGN_STKALIGN_0             = 0x0     // 4-byte aligned
+	SCB_CCR_STKALIGN_STKALIGN_1             = 0x1     // 8-byte aligned
+	SCB_CCR_DC_Pos                          = 0x10    // Position of DC field.
+	SCB_CCR_DC_Msk                          = 0x10000 // Bit mask of DC field.
+	SCB_CCR_DC                              = 0x10000 // Bit DC.
+	SCB_CCR_DC_DC_0                         = 0x0     // L1 data cache disabled
+	SCB_CCR_DC_DC_1                         = 0x1     // L1 data cache enabled
+	SCB_CCR_IC_Pos                          = 0x11    // Position of IC field.
+	SCB_CCR_IC_Msk                          = 0x20000 // Bit mask of IC field.
+	SCB_CCR_IC                              = 0x20000 // Bit IC.
+	SCB_CCR_IC_IC_0                         = 0x0     // L1 instruction cache disabled
+	SCB_CCR_IC_IC_1                         = 0x1     // L1 instruction cache enabled
+	SCB_CCR_BP_Pos                          = 0x12    // Position of BP field.
+	SCB_CCR_BP_Msk                          = 0x40000 // Bit mask of BP field.
+	SCB_CCR_BP                              = 0x40000 // Bit BP.
+
+	// SHPR1: System Handler Priority Register 1
+	SCB_SHPR1_PRI_4_Pos = 0x0      // Position of PRI_4 field.
+	SCB_SHPR1_PRI_4_Msk = 0xff     // Bit mask of PRI_4 field.
+	SCB_SHPR1_PRI_5_Pos = 0x8      // Position of PRI_5 field.
+	SCB_SHPR1_PRI_5_Msk = 0xff00   // Bit mask of PRI_5 field.
+	SCB_SHPR1_PRI_6_Pos = 0x10     // Position of PRI_6 field.
+	SCB_SHPR1_PRI_6_Msk = 0xff0000 // Bit mask of PRI_6 field.
+
+	// SHPR2: System Handler Priority Register 2
+	SCB_SHPR2_PRI_11_Pos = 0x18       // Position of PRI_11 field.
+	SCB_SHPR2_PRI_11_Msk = 0xff000000 // Bit mask of PRI_11 field.
+
+	// SHPR3: System Handler Priority Register 3
+	SCB_SHPR3_PRI_14_Pos = 0x10       // Position of PRI_14 field.
+	SCB_SHPR3_PRI_14_Msk = 0xff0000   // Bit mask of PRI_14 field.
+	SCB_SHPR3_PRI_15_Pos = 0x18       // Position of PRI_15 field.
+	SCB_SHPR3_PRI_15_Msk = 0xff000000 // Bit mask of PRI_15 field.
+
+	// SHCSR: System Handler Control and State Register
+	SCB_SHCSR_MEMFAULTACT_Pos                 = 0x0     // Position of MEMFAULTACT field.
+	SCB_SHCSR_MEMFAULTACT_Msk                 = 0x1     // Bit mask of MEMFAULTACT field.
+	SCB_SHCSR_MEMFAULTACT                     = 0x1     // Bit MEMFAULTACT.
+	SCB_SHCSR_MEMFAULTACT_MEMFAULTACT_0       = 0x0     // exception is not active
+	SCB_SHCSR_MEMFAULTACT_MEMFAULTACT_1       = 0x1     // exception is active
+	SCB_SHCSR_BUSFAULTACT_Pos                 = 0x1     // Position of BUSFAULTACT field.
+	SCB_SHCSR_BUSFAULTACT_Msk                 = 0x2     // Bit mask of BUSFAULTACT field.
+	SCB_SHCSR_BUSFAULTACT                     = 0x2     // Bit BUSFAULTACT.
+	SCB_SHCSR_BUSFAULTACT_BUSFAULTACT_0       = 0x0     // exception is not active
+	SCB_SHCSR_BUSFAULTACT_BUSFAULTACT_1       = 0x1     // exception is active
+	SCB_SHCSR_USGFAULTACT_Pos                 = 0x3     // Position of USGFAULTACT field.
+	SCB_SHCSR_USGFAULTACT_Msk                 = 0x8     // Bit mask of USGFAULTACT field.
+	SCB_SHCSR_USGFAULTACT                     = 0x8     // Bit USGFAULTACT.
+	SCB_SHCSR_USGFAULTACT_USGFAULTACT_0       = 0x0     // exception is not active
+	SCB_SHCSR_USGFAULTACT_USGFAULTACT_1       = 0x1     // exception is active
+	SCB_SHCSR_SVCALLACT_Pos                   = 0x7     // Position of SVCALLACT field.
+	SCB_SHCSR_SVCALLACT_Msk                   = 0x80    // Bit mask of SVCALLACT field.
+	SCB_SHCSR_SVCALLACT                       = 0x80    // Bit SVCALLACT.
+	SCB_SHCSR_SVCALLACT_SVCALLACT_0           = 0x0     // exception is not active
+	SCB_SHCSR_SVCALLACT_SVCALLACT_1           = 0x1     // exception is active
+	SCB_SHCSR_MONITORACT_Pos                  = 0x8     // Position of MONITORACT field.
+	SCB_SHCSR_MONITORACT_Msk                  = 0x100   // Bit mask of MONITORACT field.
+	SCB_SHCSR_MONITORACT                      = 0x100   // Bit MONITORACT.
+	SCB_SHCSR_MONITORACT_MONITORACT_0         = 0x0     // exception is not active
+	SCB_SHCSR_MONITORACT_MONITORACT_1         = 0x1     // exception is active
+	SCB_SHCSR_PENDSVACT_Pos                   = 0xa     // Position of PENDSVACT field.
+	SCB_SHCSR_PENDSVACT_Msk                   = 0x400   // Bit mask of PENDSVACT field.
+	SCB_SHCSR_PENDSVACT                       = 0x400   // Bit PENDSVACT.
+	SCB_SHCSR_PENDSVACT_PENDSVACT_0           = 0x0     // exception is not active
+	SCB_SHCSR_PENDSVACT_PENDSVACT_1           = 0x1     // exception is active
+	SCB_SHCSR_SYSTICKACT_Pos                  = 0xb     // Position of SYSTICKACT field.
+	SCB_SHCSR_SYSTICKACT_Msk                  = 0x800   // Bit mask of SYSTICKACT field.
+	SCB_SHCSR_SYSTICKACT                      = 0x800   // Bit SYSTICKACT.
+	SCB_SHCSR_SYSTICKACT_SYSTICKACT_0         = 0x0     // exception is not active
+	SCB_SHCSR_SYSTICKACT_SYSTICKACT_1         = 0x1     // exception is active
+	SCB_SHCSR_USGFAULTPENDED_Pos              = 0xc     // Position of USGFAULTPENDED field.
+	SCB_SHCSR_USGFAULTPENDED_Msk              = 0x1000  // Bit mask of USGFAULTPENDED field.
+	SCB_SHCSR_USGFAULTPENDED                  = 0x1000  // Bit USGFAULTPENDED.
+	SCB_SHCSR_USGFAULTPENDED_USGFAULTPENDED_0 = 0x0     // exception is not pending
+	SCB_SHCSR_USGFAULTPENDED_USGFAULTPENDED_1 = 0x1     // exception is pending
+	SCB_SHCSR_MEMFAULTPENDED_Pos              = 0xd     // Position of MEMFAULTPENDED field.
+	SCB_SHCSR_MEMFAULTPENDED_Msk              = 0x2000  // Bit mask of MEMFAULTPENDED field.
+	SCB_SHCSR_MEMFAULTPENDED                  = 0x2000  // Bit MEMFAULTPENDED.
+	SCB_SHCSR_MEMFAULTPENDED_MEMFAULTPENDED_0 = 0x0     // exception is not pending
+	SCB_SHCSR_MEMFAULTPENDED_MEMFAULTPENDED_1 = 0x1     // exception is pending
+	SCB_SHCSR_BUSFAULTPENDED_Pos              = 0xe     // Position of BUSFAULTPENDED field.
+	SCB_SHCSR_BUSFAULTPENDED_Msk              = 0x4000  // Bit mask of BUSFAULTPENDED field.
+	SCB_SHCSR_BUSFAULTPENDED                  = 0x4000  // Bit BUSFAULTPENDED.
+	SCB_SHCSR_BUSFAULTPENDED_BUSFAULTPENDED_0 = 0x0     // exception is not pending
+	SCB_SHCSR_BUSFAULTPENDED_BUSFAULTPENDED_1 = 0x1     // exception is pending
+	SCB_SHCSR_SVCALLPENDED_Pos                = 0xf     // Position of SVCALLPENDED field.
+	SCB_SHCSR_SVCALLPENDED_Msk                = 0x8000  // Bit mask of SVCALLPENDED field.
+	SCB_SHCSR_SVCALLPENDED                    = 0x8000  // Bit SVCALLPENDED.
+	SCB_SHCSR_SVCALLPENDED_SVCALLPENDED_0     = 0x0     // exception is not pending
+	SCB_SHCSR_SVCALLPENDED_SVCALLPENDED_1     = 0x1     // exception is pending
+	SCB_SHCSR_MEMFAULTENA_Pos                 = 0x10    // Position of MEMFAULTENA field.
+	SCB_SHCSR_MEMFAULTENA_Msk                 = 0x10000 // Bit mask of MEMFAULTENA field.
+	SCB_SHCSR_MEMFAULTENA                     = 0x10000 // Bit MEMFAULTENA.
+	SCB_SHCSR_MEMFAULTENA_MEMFAULTENA_0       = 0x0     // disable the exception
+	SCB_SHCSR_MEMFAULTENA_MEMFAULTENA_1       = 0x1     // enable the exception
+	SCB_SHCSR_BUSFAULTENA_Pos                 = 0x11    // Position of BUSFAULTENA field.
+	SCB_SHCSR_BUSFAULTENA_Msk                 = 0x20000 // Bit mask of BUSFAULTENA field.
+	SCB_SHCSR_BUSFAULTENA                     = 0x20000 // Bit BUSFAULTENA.
+	SCB_SHCSR_BUSFAULTENA_BUSFAULTENA_0       = 0x0     // disable the exception
+	SCB_SHCSR_BUSFAULTENA_BUSFAULTENA_1       = 0x1     // enable the exception
+	SCB_SHCSR_USGFAULTENA_Pos                 = 0x12    // Position of USGFAULTENA field.
+	SCB_SHCSR_USGFAULTENA_Msk                 = 0x40000 // Bit mask of USGFAULTENA field.
+	SCB_SHCSR_USGFAULTENA                     = 0x40000 // Bit USGFAULTENA.
+	SCB_SHCSR_USGFAULTENA_USGFAULTENA_0       = 0x0     // disable the exception
+	SCB_SHCSR_USGFAULTENA_USGFAULTENA_1       = 0x1     // enable the exception
+
+	// CFSR: Configurable Fault Status Register
+	SCB_CFSR_IACCVIOL_Pos              = 0x0       // Position of IACCVIOL field.
+	SCB_CFSR_IACCVIOL_Msk              = 0x1       // Bit mask of IACCVIOL field.
+	SCB_CFSR_IACCVIOL                  = 0x1       // Bit IACCVIOL.
+	SCB_CFSR_IACCVIOL_IACCVIOL_0       = 0x0       // no instruction access violation fault
+	SCB_CFSR_IACCVIOL_IACCVIOL_1       = 0x1       // the processor attempted an instruction fetch from a location that does not permit execution
+	SCB_CFSR_DACCVIOL_Pos              = 0x1       // Position of DACCVIOL field.
+	SCB_CFSR_DACCVIOL_Msk              = 0x2       // Bit mask of DACCVIOL field.
+	SCB_CFSR_DACCVIOL                  = 0x2       // Bit DACCVIOL.
+	SCB_CFSR_DACCVIOL_DACCVIOL_0       = 0x0       // no data access violation fault
+	SCB_CFSR_DACCVIOL_DACCVIOL_1       = 0x1       // the processor attempted a load or store at a location that does not permit the operation
+	SCB_CFSR_MUNSTKERR_Pos             = 0x3       // Position of MUNSTKERR field.
+	SCB_CFSR_MUNSTKERR_Msk             = 0x8       // Bit mask of MUNSTKERR field.
+	SCB_CFSR_MUNSTKERR                 = 0x8       // Bit MUNSTKERR.
+	SCB_CFSR_MUNSTKERR_MUNSTKERR_0     = 0x0       // no unstacking fault
+	SCB_CFSR_MUNSTKERR_MUNSTKERR_1     = 0x1       // unstack for an exception return has caused one or more access violations
+	SCB_CFSR_MSTKERR_Pos               = 0x4       // Position of MSTKERR field.
+	SCB_CFSR_MSTKERR_Msk               = 0x10      // Bit mask of MSTKERR field.
+	SCB_CFSR_MSTKERR                   = 0x10      // Bit MSTKERR.
+	SCB_CFSR_MSTKERR_MSTKERR_0         = 0x0       // no stacking fault
+	SCB_CFSR_MSTKERR_MSTKERR_1         = 0x1       // stacking for an exception entry has caused one or more access violations
+	SCB_CFSR_MLSPERR_Pos               = 0x5       // Position of MLSPERR field.
+	SCB_CFSR_MLSPERR_Msk               = 0x20      // Bit mask of MLSPERR field.
+	SCB_CFSR_MLSPERR                   = 0x20      // Bit MLSPERR.
+	SCB_CFSR_MLSPERR_MLSPERR_0         = 0x0       // No MemManage fault occurred during floating-point lazy state preservation
+	SCB_CFSR_MLSPERR_MLSPERR_1         = 0x1       // A MemManage fault occurred during floating-point lazy state preservation
+	SCB_CFSR_MMARVALID_Pos             = 0x7       // Position of MMARVALID field.
+	SCB_CFSR_MMARVALID_Msk             = 0x80      // Bit mask of MMARVALID field.
+	SCB_CFSR_MMARVALID                 = 0x80      // Bit MMARVALID.
+	SCB_CFSR_MMARVALID_MMARVALID_0     = 0x0       // value in MMAR is not a valid fault address
+	SCB_CFSR_MMARVALID_MMARVALID_1     = 0x1       // MMAR holds a valid fault address
+	SCB_CFSR_IBUSERR_Pos               = 0x8       // Position of IBUSERR field.
+	SCB_CFSR_IBUSERR_Msk               = 0x100     // Bit mask of IBUSERR field.
+	SCB_CFSR_IBUSERR                   = 0x100     // Bit IBUSERR.
+	SCB_CFSR_IBUSERR_IBUSERR_0         = 0x0       // no instruction bus error
+	SCB_CFSR_IBUSERR_IBUSERR_1         = 0x1       // instruction bus error
+	SCB_CFSR_PRECISERR_Pos             = 0x9       // Position of PRECISERR field.
+	SCB_CFSR_PRECISERR_Msk             = 0x200     // Bit mask of PRECISERR field.
+	SCB_CFSR_PRECISERR                 = 0x200     // Bit PRECISERR.
+	SCB_CFSR_PRECISERR_PRECISERR_0     = 0x0       // no precise data bus error
+	SCB_CFSR_PRECISERR_PRECISERR_1     = 0x1       // a data bus error has occurred, and the PC value stacked for the exception return points to the instruction that caused the fault
+	SCB_CFSR_IMPRECISERR_Pos           = 0xa       // Position of IMPRECISERR field.
+	SCB_CFSR_IMPRECISERR_Msk           = 0x400     // Bit mask of IMPRECISERR field.
+	SCB_CFSR_IMPRECISERR               = 0x400     // Bit IMPRECISERR.
+	SCB_CFSR_IMPRECISERR_IMPRECISERR_0 = 0x0       // no imprecise data bus error
+	SCB_CFSR_IMPRECISERR_IMPRECISERR_1 = 0x1       // a data bus error has occurred, but the return address in the stack frame is not related to the instruction that caused the error
+	SCB_CFSR_UNSTKERR_Pos              = 0xb       // Position of UNSTKERR field.
+	SCB_CFSR_UNSTKERR_Msk              = 0x800     // Bit mask of UNSTKERR field.
+	SCB_CFSR_UNSTKERR                  = 0x800     // Bit UNSTKERR.
+	SCB_CFSR_UNSTKERR_UNSTKERR_0       = 0x0       // no unstacking fault
+	SCB_CFSR_UNSTKERR_UNSTKERR_1       = 0x1       // unstack for an exception return has caused one or more BusFaults
+	SCB_CFSR_STKERR_Pos                = 0xc       // Position of STKERR field.
+	SCB_CFSR_STKERR_Msk                = 0x1000    // Bit mask of STKERR field.
+	SCB_CFSR_STKERR                    = 0x1000    // Bit STKERR.
+	SCB_CFSR_STKERR_STKERR_0           = 0x0       // no stacking fault
+	SCB_CFSR_STKERR_STKERR_1           = 0x1       // stacking for an exception entry has caused one or more BusFaults
+	SCB_CFSR_LSPERR_Pos                = 0xd       // Position of LSPERR field.
+	SCB_CFSR_LSPERR_Msk                = 0x2000    // Bit mask of LSPERR field.
+	SCB_CFSR_LSPERR                    = 0x2000    // Bit LSPERR.
+	SCB_CFSR_LSPERR_LSPERR_0           = 0x0       // No bus fault occurred during floating-point lazy state preservation
+	SCB_CFSR_LSPERR_LSPERR_1           = 0x1       // A bus fault occurred during floating-point lazy state preservation
+	SCB_CFSR_BFARVALID_Pos             = 0xf       // Position of BFARVALID field.
+	SCB_CFSR_BFARVALID_Msk             = 0x8000    // Bit mask of BFARVALID field.
+	SCB_CFSR_BFARVALID                 = 0x8000    // Bit BFARVALID.
+	SCB_CFSR_BFARVALID_BFARVALID_0     = 0x0       // value in BFAR is not a valid fault address
+	SCB_CFSR_BFARVALID_BFARVALID_1     = 0x1       // BFAR holds a valid fault address
+	SCB_CFSR_UNDEFINSTR_Pos            = 0x10      // Position of UNDEFINSTR field.
+	SCB_CFSR_UNDEFINSTR_Msk            = 0x10000   // Bit mask of UNDEFINSTR field.
+	SCB_CFSR_UNDEFINSTR                = 0x10000   // Bit UNDEFINSTR.
+	SCB_CFSR_UNDEFINSTR_UNDEFINSTR_0   = 0x0       // no undefined instruction UsageFault
+	SCB_CFSR_UNDEFINSTR_UNDEFINSTR_1   = 0x1       // the processor has attempted to execute an undefined instruction
+	SCB_CFSR_INVSTATE_Pos              = 0x11      // Position of INVSTATE field.
+	SCB_CFSR_INVSTATE_Msk              = 0x20000   // Bit mask of INVSTATE field.
+	SCB_CFSR_INVSTATE                  = 0x20000   // Bit INVSTATE.
+	SCB_CFSR_INVSTATE_INVSTATE_0       = 0x0       // no invalid state UsageFault
+	SCB_CFSR_INVSTATE_INVSTATE_1       = 0x1       // the processor has attempted to execute an instruction that makes illegal use of the EPSR
+	SCB_CFSR_INVPC_Pos                 = 0x12      // Position of INVPC field.
+	SCB_CFSR_INVPC_Msk                 = 0x40000   // Bit mask of INVPC field.
+	SCB_CFSR_INVPC                     = 0x40000   // Bit INVPC.
+	SCB_CFSR_INVPC_INVPC_0             = 0x0       // no invalid PC load UsageFault
+	SCB_CFSR_INVPC_INVPC_1             = 0x1       // the processor has attempted an illegal load of EXC_RETURN to the PC
+	SCB_CFSR_NOCP_Pos                  = 0x13      // Position of NOCP field.
+	SCB_CFSR_NOCP_Msk                  = 0x80000   // Bit mask of NOCP field.
+	SCB_CFSR_NOCP                      = 0x80000   // Bit NOCP.
+	SCB_CFSR_NOCP_NOCP_0               = 0x0       // no UsageFault caused by attempting to access a coprocessor
+	SCB_CFSR_NOCP_NOCP_1               = 0x1       // the processor has attempted to access a coprocessor
+	SCB_CFSR_UNALIGNED_Pos             = 0x18      // Position of UNALIGNED field.
+	SCB_CFSR_UNALIGNED_Msk             = 0x1000000 // Bit mask of UNALIGNED field.
+	SCB_CFSR_UNALIGNED                 = 0x1000000 // Bit UNALIGNED.
+	SCB_CFSR_UNALIGNED_UNALIGNED_0     = 0x0       // no unaligned access fault, or unaligned access trapping not enabled
+	SCB_CFSR_UNALIGNED_UNALIGNED_1     = 0x1       // the processor has made an unaligned memory access
+	SCB_CFSR_DIVBYZERO_Pos             = 0x19      // Position of DIVBYZERO field.
+	SCB_CFSR_DIVBYZERO_Msk             = 0x2000000 // Bit mask of DIVBYZERO field.
+	SCB_CFSR_DIVBYZERO                 = 0x2000000 // Bit DIVBYZERO.
+	SCB_CFSR_DIVBYZERO_DIVBYZERO_0     = 0x0       // no divide by zero fault, or divide by zero trapping not enabled
+	SCB_CFSR_DIVBYZERO_DIVBYZERO_1     = 0x1       // the processor has executed an SDIV or UDIV instruction with a divisor of 0
+
+	// HFSR: HardFault Status register
+	SCB_HFSR_VECTTBL_Pos         = 0x1        // Position of VECTTBL field.
+	SCB_HFSR_VECTTBL_Msk         = 0x2        // Bit mask of VECTTBL field.
+	SCB_HFSR_VECTTBL             = 0x2        // Bit VECTTBL.
+	SCB_HFSR_VECTTBL_VECTTBL_0   = 0x0        // no BusFault on vector table read
+	SCB_HFSR_VECTTBL_VECTTBL_1   = 0x1        // BusFault on vector table read
+	SCB_HFSR_FORCED_Pos          = 0x1e       // Position of FORCED field.
+	SCB_HFSR_FORCED_Msk          = 0x40000000 // Bit mask of FORCED field.
+	SCB_HFSR_FORCED              = 0x40000000 // Bit FORCED.
+	SCB_HFSR_FORCED_FORCED_0     = 0x0        // no forced HardFault
+	SCB_HFSR_FORCED_FORCED_1     = 0x1        // forced HardFault
+	SCB_HFSR_DEBUGEVT_Pos        = 0x1f       // Position of DEBUGEVT field.
+	SCB_HFSR_DEBUGEVT_Msk        = 0x80000000 // Bit mask of DEBUGEVT field.
+	SCB_HFSR_DEBUGEVT            = 0x80000000 // Bit DEBUGEVT.
+	SCB_HFSR_DEBUGEVT_DEBUGEVT_0 = 0x0        // No Debug event has occurred.
+	SCB_HFSR_DEBUGEVT_DEBUGEVT_1 = 0x1        // Debug event has occurred. The Debug Fault Status Register has been updated.
+
+	// DFSR: Debug Fault Status Register
+	SCB_DFSR_HALTED_Pos          = 0x0  // Position of HALTED field.
+	SCB_DFSR_HALTED_Msk          = 0x1  // Bit mask of HALTED field.
+	SCB_DFSR_HALTED              = 0x1  // Bit HALTED.
+	SCB_DFSR_HALTED_HALTED_0     = 0x0  // No active halt request debug event
+	SCB_DFSR_HALTED_HALTED_1     = 0x1  // Halt request debug event active
+	SCB_DFSR_BKPT_Pos            = 0x1  // Position of BKPT field.
+	SCB_DFSR_BKPT_Msk            = 0x2  // Bit mask of BKPT field.
+	SCB_DFSR_BKPT                = 0x2  // Bit BKPT.
+	SCB_DFSR_BKPT_BKPT_0         = 0x0  // No current breakpoint debug event
+	SCB_DFSR_BKPT_BKPT_1         = 0x1  // At least one current breakpoint debug event
+	SCB_DFSR_DWTTRAP_Pos         = 0x2  // Position of DWTTRAP field.
+	SCB_DFSR_DWTTRAP_Msk         = 0x4  // Bit mask of DWTTRAP field.
+	SCB_DFSR_DWTTRAP             = 0x4  // Bit DWTTRAP.
+	SCB_DFSR_DWTTRAP_DWTTRAP_0   = 0x0  // No current debug events generated by the DWT
+	SCB_DFSR_DWTTRAP_DWTTRAP_1   = 0x1  // At least one current debug event generated by the DWT
+	SCB_DFSR_VCATCH_Pos          = 0x3  // Position of VCATCH field.
+	SCB_DFSR_VCATCH_Msk          = 0x8  // Bit mask of VCATCH field.
+	SCB_DFSR_VCATCH              = 0x8  // Bit VCATCH.
+	SCB_DFSR_VCATCH_VCATCH_0     = 0x0  // No Vector catch triggered
+	SCB_DFSR_VCATCH_VCATCH_1     = 0x1  // Vector catch triggered
+	SCB_DFSR_EXTERNAL_Pos        = 0x4  // Position of EXTERNAL field.
+	SCB_DFSR_EXTERNAL_Msk        = 0x10 // Bit mask of EXTERNAL field.
+	SCB_DFSR_EXTERNAL            = 0x10 // Bit EXTERNAL.
+	SCB_DFSR_EXTERNAL_EXTERNAL_0 = 0x0  // No external debug request debug event
+	SCB_DFSR_EXTERNAL_EXTERNAL_1 = 0x1  // External debug request debug event
+
+	// MMFAR: MemManage Fault Address Register
+	SCB_MMFAR_ADDRESS_Pos = 0x0        // Position of ADDRESS field.
+	SCB_MMFAR_ADDRESS_Msk = 0xffffffff // Bit mask of ADDRESS field.
+
+	// BFAR: BusFault Address Register
+	SCB_BFAR_ADDRESS_Pos = 0x0        // Position of ADDRESS field.
+	SCB_BFAR_ADDRESS_Msk = 0xffffffff // Bit mask of ADDRESS field.
+)

src/device/arm64/arm64.go

@@ -0,0 +1,36 @@
+package arm64
+
+// Run the given assembly code. The code will be marked as having side effects,
+// as it doesn't produce output and thus would normally be eliminated by the
+// optimizer.
+func Asm(asm string)
+
+// Run the given inline assembly. The code will be marked as having side
+// effects, as it would otherwise be optimized away. The inline assembly string
+// recognizes template values in the form {name}, like so:
+//
+//     arm.AsmFull(
+//         "str {value}, {result}",
+//         map[string]interface{}{
+//             "value":  1
+//             "result": &dest,
+//         })
+//
+// You can use {} in the asm string (which expands to a register) to set the
+// return value.
+func AsmFull(asm string, regs map[string]interface{}) uintptr
+
+// Run the following system call (SVCall) with 0 arguments.
+func SVCall0(num uintptr) uintptr
+
+// Run the following system call (SVCall) with 1 argument.
+func SVCall1(num uintptr, a1 interface{}) uintptr
+
+// Run the following system call (SVCall) with 2 arguments.
+func SVCall2(num uintptr, a1, a2 interface{}) uintptr
+
+// Run the following system call (SVCall) with 3 arguments.
+func SVCall3(num uintptr, a1, a2, a3 interface{}) uintptr
+
+// Run the following system call (SVCall) with 4 arguments.
+func SVCall4(num uintptr, a1, a2, a3, a4 interface{}) uintptr

src/device/esp/esp32.S

@@ -24,7 +24,7 @@ call_start_cpu0:
     wsr.ps a2
     rsync
 
-    // Set WINDOWBASE to 1 << WINDOWSTART.
+    // Set WINDOWSTART to 1 << WINDOWBASE.
     rsr.windowbase  a2
     ssl  a2
     movi a2, 1
@@ -42,8 +42,13 @@ call_start_cpu0:
     wsr.ps a2
     rsync
 
+    // Enable the FPU (coprocessor 0 so the lowest bit).
+    movi a2, 1
+    wsr.cpenable a2
+    rsync
+
     // Jump to the runtime start function written in Go.
-    j main
+    call4 main
 
 .section .text.tinygo_scanCurrentStack
 .global tinygo_scanCurrentStack

src/device/nxp/hardfault.go

@@ -0,0 +1,29 @@
+// Hand created file. DO NOT DELETE.
+// Hardfault aliases for definitions that have inconsistent naming (which are
+// auto-generated by gen-device-svd.go) among devices in package nxp.
+
+// +build nxp,!mimxrt1062
+
+package nxp
+
+const (
+	HardFault_CFSR_IACCVIOL    = SystemControl_CFSR_IACCVIOL
+	HardFault_CFSR_DACCVIOL    = SystemControl_CFSR_DACCVIOL
+	HardFault_CFSR_MUNSTKERR   = SystemControl_CFSR_MUNSTKERR
+	HardFault_CFSR_MSTKERR     = SystemControl_CFSR_MSTKERR
+	HardFault_CFSR_MLSPERR     = SystemControl_CFSR_MLSPERR
+	HardFault_CFSR_IBUSERR     = SystemControl_CFSR_IBUSERR
+	HardFault_CFSR_PRECISERR   = SystemControl_CFSR_PRECISERR
+	HardFault_CFSR_IMPRECISERR = SystemControl_CFSR_IMPRECISERR
+	HardFault_CFSR_UNSTKERR    = SystemControl_CFSR_UNSTKERR
+	HardFault_CFSR_STKERR      = SystemControl_CFSR_STKERR
+	HardFault_CFSR_LSPERR      = SystemControl_CFSR_LSPERR
+	HardFault_CFSR_UNDEFINSTR  = SystemControl_CFSR_UNDEFINSTR
+	HardFault_CFSR_INVSTATE    = SystemControl_CFSR_INVSTATE
+	HardFault_CFSR_INVPC       = SystemControl_CFSR_INVPC
+	HardFault_CFSR_NOCP        = SystemControl_CFSR_NOCP
+	HardFault_CFSR_UNALIGNED   = SystemControl_CFSR_UNALIGNED
+	HardFault_CFSR_DIVBYZERO   = SystemControl_CFSR_DIVBYZERO
+	HardFault_CFSR_MMARVALID   = SystemControl_CFSR_MMARVALID
+	HardFault_CFSR_BFARVALID   = SystemControl_CFSR_BFARVALID
+)

src/device/nxp/mimxrt1062_clock.go

@@ -0,0 +1,529 @@
+// Hand created file. DO NOT DELETE.
+// Type definitions, fields, and constants associated with various clocks and
+// peripherals of the NXP MIMXRT1062.
+
+// +build nxp,mimxrt1062
+
+package nxp
+
+import (
+	"runtime/volatile"
+	"unsafe"
+)
+
+// Clock represents an individual peripheral clock that may be enabled/disabled
+// at runtime. Clocks also have a method `Mux` for selecting the clock source
+// and a method `Div` for selecting the hardware divisor. Note that many
+// peripherals have an independent prescalar configuration applied to the output
+// of this divisor.
+type (
+	Clock     uint32
+	ClockMode uint8
+)
+
+// Enable activates or deactivates the clock gate of receiver Clock c.
+func (c Clock) Enable(enable bool) {
+	if enable {
+		c.setGate(clockNeededRunWait)
+	} else {
+		c.setGate(clockNotNeeded)
+	}
+}
+
+// Mux selects a clock source for the mux of the receiver Clock c.
+func (c Clock) Mux(mux uint32) { c.setCcm(mux) }
+
+// Div configures the prescalar divisor of the receiver Clock c.
+func (c Clock) Div(div uint32) { c.setCcm(div) }
+
+const (
+	ClockModeRun  ClockMode = 0 // Remain in run mode
+	ClockModeWait ClockMode = 1 // Transfer to wait mode
+	ClockModeStop ClockMode = 2 // Transfer to stop mode
+)
+
+// Set configures the run mode of the MCU.
+func (m ClockMode) Set() {
+	CCM.CLPCR.Set((CCM.CLPCR.Get() & ^uint32(CCM_CLPCR_LPM_Msk)) |
+		((uint32(m) << CCM_CLPCR_LPM_Pos) & CCM_CLPCR_LPM_Msk))
+}
+
+// Named oscillators
+const (
+	ClockCpu         Clock = 0x0  // CPU clock
+	ClockAhb         Clock = 0x1  // AHB clock
+	ClockSemc        Clock = 0x2  // SEMC clock
+	ClockIpg         Clock = 0x3  // IPG clock
+	ClockPer         Clock = 0x4  // PER clock
+	ClockOsc         Clock = 0x5  // OSC clock selected by PMU_LOWPWR_CTRL[OSC_SEL]
+	ClockRtc         Clock = 0x6  // RTC clock (RTCCLK)
+	ClockArmPll      Clock = 0x7  // ARMPLLCLK
+	ClockUsb1Pll     Clock = 0x8  // USB1PLLCLK
+	ClockUsb1PllPfd0 Clock = 0x9  // USB1PLLPDF0CLK
+	ClockUsb1PllPfd1 Clock = 0xA  // USB1PLLPFD1CLK
+	ClockUsb1PllPfd2 Clock = 0xB  // USB1PLLPFD2CLK
+	ClockUsb1PllPfd3 Clock = 0xC  // USB1PLLPFD3CLK
+	ClockUsb2Pll     Clock = 0xD  // USB2PLLCLK
+	ClockSysPll      Clock = 0xE  // SYSPLLCLK
+	ClockSysPllPfd0  Clock = 0xF  // SYSPLLPDF0CLK
+	ClockSysPllPfd1  Clock = 0x10 // SYSPLLPFD1CLK
+	ClockSysPllPfd2  Clock = 0x11 // SYSPLLPFD2CLK
+	ClockSysPllPfd3  Clock = 0x12 // SYSPLLPFD3CLK
+	ClockEnetPll0    Clock = 0x13 // Enet PLLCLK ref_enetpll0
+	ClockEnetPll1    Clock = 0x14 // Enet PLLCLK ref_enetpll1
+	ClockEnetPll2    Clock = 0x15 // Enet PLLCLK ref_enetpll2
+	ClockAudioPll    Clock = 0x16 // Audio PLLCLK
+	ClockVideoPll    Clock = 0x17 // Video PLLCLK
+)
+
+// Named clocks of integrated peripherals
+const (
+	ClockIpAipsTz1     Clock = (0 << 8) | CCM_CCGR0_CG0_Pos  // CCGR0, CG0
+	ClockIpAipsTz2     Clock = (0 << 8) | CCM_CCGR0_CG1_Pos  // CCGR0, CG1
+	ClockIpMqs         Clock = (0 << 8) | CCM_CCGR0_CG2_Pos  // CCGR0, CG2
+	ClockIpFlexSpiExsc Clock = (0 << 8) | CCM_CCGR0_CG3_Pos  // CCGR0, CG3
+	ClockIpSimMMain    Clock = (0 << 8) | CCM_CCGR0_CG4_Pos  // CCGR0, CG4
+	ClockIpDcp         Clock = (0 << 8) | CCM_CCGR0_CG5_Pos  // CCGR0, CG5
+	ClockIpLpuart3     Clock = (0 << 8) | CCM_CCGR0_CG6_Pos  // CCGR0, CG6
+	ClockIpCan1        Clock = (0 << 8) | CCM_CCGR0_CG7_Pos  // CCGR0, CG7
+	ClockIpCan1S       Clock = (0 << 8) | CCM_CCGR0_CG8_Pos  // CCGR0, CG8
+	ClockIpCan2        Clock = (0 << 8) | CCM_CCGR0_CG9_Pos  // CCGR0, CG9
+	ClockIpCan2S       Clock = (0 << 8) | CCM_CCGR0_CG10_Pos // CCGR0, CG10
+	ClockIpTrace       Clock = (0 << 8) | CCM_CCGR0_CG11_Pos // CCGR0, CG11
+	ClockIpGpt2        Clock = (0 << 8) | CCM_CCGR0_CG12_Pos // CCGR0, CG12
+	ClockIpGpt2S       Clock = (0 << 8) | CCM_CCGR0_CG13_Pos // CCGR0, CG13
+	ClockIpLpuart2     Clock = (0 << 8) | CCM_CCGR0_CG14_Pos // CCGR0, CG14
+	ClockIpGpio2       Clock = (0 << 8) | CCM_CCGR0_CG15_Pos // CCGR0, CG15
+
+	ClockIpLpspi1   Clock = (1 << 8) | CCM_CCGR1_CG0_Pos  // CCGR1, CG0
+	ClockIpLpspi2   Clock = (1 << 8) | CCM_CCGR1_CG1_Pos  // CCGR1, CG1
+	ClockIpLpspi3   Clock = (1 << 8) | CCM_CCGR1_CG2_Pos  // CCGR1, CG2
+	ClockIpLpspi4   Clock = (1 << 8) | CCM_CCGR1_CG3_Pos  // CCGR1, CG3
+	ClockIpAdc2     Clock = (1 << 8) | CCM_CCGR1_CG4_Pos  // CCGR1, CG4
+	ClockIpEnet     Clock = (1 << 8) | CCM_CCGR1_CG5_Pos  // CCGR1, CG5
+	ClockIpPit      Clock = (1 << 8) | CCM_CCGR1_CG6_Pos  // CCGR1, CG6
+	ClockIpAoi2     Clock = (1 << 8) | CCM_CCGR1_CG7_Pos  // CCGR1, CG7
+	ClockIpAdc1     Clock = (1 << 8) | CCM_CCGR1_CG8_Pos  // CCGR1, CG8
+	ClockIpSemcExsc Clock = (1 << 8) | CCM_CCGR1_CG9_Pos  // CCGR1, CG9
+	ClockIpGpt1     Clock = (1 << 8) | CCM_CCGR1_CG10_Pos // CCGR1, CG10
+	ClockIpGpt1S    Clock = (1 << 8) | CCM_CCGR1_CG11_Pos // CCGR1, CG11
+	ClockIpLpuart4  Clock = (1 << 8) | CCM_CCGR1_CG12_Pos // CCGR1, CG12
+	ClockIpGpio1    Clock = (1 << 8) | CCM_CCGR1_CG13_Pos // CCGR1, CG13
+	ClockIpCsu      Clock = (1 << 8) | CCM_CCGR1_CG14_Pos // CCGR1, CG14
+	ClockIpGpio5    Clock = (1 << 8) | CCM_CCGR1_CG15_Pos // CCGR1, CG15
+
+	ClockIpOcramExsc  Clock = (2 << 8) | CCM_CCGR2_CG0_Pos  // CCGR2, CG0
+	ClockIpCsi        Clock = (2 << 8) | CCM_CCGR2_CG1_Pos  // CCGR2, CG1
+	ClockIpIomuxcSnvs Clock = (2 << 8) | CCM_CCGR2_CG2_Pos  // CCGR2, CG2
+	ClockIpLpi2c1     Clock = (2 << 8) | CCM_CCGR2_CG3_Pos  // CCGR2, CG3
+	ClockIpLpi2c2     Clock = (2 << 8) | CCM_CCGR2_CG4_Pos  // CCGR2, CG4
+	ClockIpLpi2c3     Clock = (2 << 8) | CCM_CCGR2_CG5_Pos  // CCGR2, CG5
+	ClockIpOcotp      Clock = (2 << 8) | CCM_CCGR2_CG6_Pos  // CCGR2, CG6
+	ClockIpXbar3      Clock = (2 << 8) | CCM_CCGR2_CG7_Pos  // CCGR2, CG7
+	ClockIpIpmux1     Clock = (2 << 8) | CCM_CCGR2_CG8_Pos  // CCGR2, CG8
+	ClockIpIpmux2     Clock = (2 << 8) | CCM_CCGR2_CG9_Pos  // CCGR2, CG9
+	ClockIpIpmux3     Clock = (2 << 8) | CCM_CCGR2_CG10_Pos // CCGR2, CG10
+	ClockIpXbar1      Clock = (2 << 8) | CCM_CCGR2_CG11_Pos // CCGR2, CG11
+	ClockIpXbar2      Clock = (2 << 8) | CCM_CCGR2_CG12_Pos // CCGR2, CG12
+	ClockIpGpio3      Clock = (2 << 8) | CCM_CCGR2_CG13_Pos // CCGR2, CG13
+	ClockIpLcd        Clock = (2 << 8) | CCM_CCGR2_CG14_Pos // CCGR2, CG14
+	ClockIpPxp        Clock = (2 << 8) | CCM_CCGR2_CG15_Pos // CCGR2, CG15
+
+	ClockIpFlexio2       Clock = (3 << 8) | CCM_CCGR3_CG0_Pos  // CCGR3, CG0
+	ClockIpLpuart5       Clock = (3 << 8) | CCM_CCGR3_CG1_Pos  // CCGR3, CG1
+	ClockIpSemc          Clock = (3 << 8) | CCM_CCGR3_CG2_Pos  // CCGR3, CG2
+	ClockIpLpuart6       Clock = (3 << 8) | CCM_CCGR3_CG3_Pos  // CCGR3, CG3
+	ClockIpAoi1          Clock = (3 << 8) | CCM_CCGR3_CG4_Pos  // CCGR3, CG4
+	ClockIpLcdPixel      Clock = (3 << 8) | CCM_CCGR3_CG5_Pos  // CCGR3, CG5
+	ClockIpGpio4         Clock = (3 << 8) | CCM_CCGR3_CG6_Pos  // CCGR3, CG6
+	ClockIpEwm0          Clock = (3 << 8) | CCM_CCGR3_CG7_Pos  // CCGR3, CG7
+	ClockIpWdog1         Clock = (3 << 8) | CCM_CCGR3_CG8_Pos  // CCGR3, CG8
+	ClockIpFlexRam       Clock = (3 << 8) | CCM_CCGR3_CG9_Pos  // CCGR3, CG9
+	ClockIpAcmp1         Clock = (3 << 8) | CCM_CCGR3_CG10_Pos // CCGR3, CG10
+	ClockIpAcmp2         Clock = (3 << 8) | CCM_CCGR3_CG11_Pos // CCGR3, CG11
+	ClockIpAcmp3         Clock = (3 << 8) | CCM_CCGR3_CG12_Pos // CCGR3, CG12
+	ClockIpAcmp4         Clock = (3 << 8) | CCM_CCGR3_CG13_Pos // CCGR3, CG13
+	ClockIpOcram         Clock = (3 << 8) | CCM_CCGR3_CG14_Pos // CCGR3, CG14
+	ClockIpIomuxcSnvsGpr Clock = (3 << 8) | CCM_CCGR3_CG15_Pos // CCGR3, CG15
+
+	ClockIpIomuxc    Clock = (4 << 8) | CCM_CCGR4_CG1_Pos  // CCGR4, CG1
+	ClockIpIomuxcGpr Clock = (4 << 8) | CCM_CCGR4_CG2_Pos  // CCGR4, CG2
+	ClockIpBee       Clock = (4 << 8) | CCM_CCGR4_CG3_Pos  // CCGR4, CG3
+	ClockIpSimM7     Clock = (4 << 8) | CCM_CCGR4_CG4_Pos  // CCGR4, CG4
+	ClockIpTsc       Clock = (4 << 8) | CCM_CCGR4_CG5_Pos  // CCGR4, CG5
+	ClockIpSimM      Clock = (4 << 8) | CCM_CCGR4_CG6_Pos  // CCGR4, CG6
+	ClockIpSimEms    Clock = (4 << 8) | CCM_CCGR4_CG7_Pos  // CCGR4, CG7
+	ClockIpPwm1      Clock = (4 << 8) | CCM_CCGR4_CG8_Pos  // CCGR4, CG8
+	ClockIpPwm2      Clock = (4 << 8) | CCM_CCGR4_CG9_Pos  // CCGR4, CG9
+	ClockIpPwm3      Clock = (4 << 8) | CCM_CCGR4_CG10_Pos // CCGR4, CG10
+	ClockIpPwm4      Clock = (4 << 8) | CCM_CCGR4_CG11_Pos // CCGR4, CG11
+	ClockIpEnc1      Clock = (4 << 8) | CCM_CCGR4_CG12_Pos // CCGR4, CG12
+	ClockIpEnc2      Clock = (4 << 8) | CCM_CCGR4_CG13_Pos // CCGR4, CG13
+	ClockIpEnc3      Clock = (4 << 8) | CCM_CCGR4_CG14_Pos // CCGR4, CG14
+	ClockIpEnc4      Clock = (4 << 8) | CCM_CCGR4_CG15_Pos // CCGR4, CG15
+
+	ClockIpRom     Clock = (5 << 8) | CCM_CCGR5_CG0_Pos  // CCGR5, CG0
+	ClockIpFlexio1 Clock = (5 << 8) | CCM_CCGR5_CG1_Pos  // CCGR5, CG1
+	ClockIpWdog3   Clock = (5 << 8) | CCM_CCGR5_CG2_Pos  // CCGR5, CG2
+	ClockIpDma     Clock = (5 << 8) | CCM_CCGR5_CG3_Pos  // CCGR5, CG3
+	ClockIpKpp     Clock = (5 << 8) | CCM_CCGR5_CG4_Pos  // CCGR5, CG4
+	ClockIpWdog2   Clock = (5 << 8) | CCM_CCGR5_CG5_Pos  // CCGR5, CG5
+	ClockIpAipsTz4 Clock = (5 << 8) | CCM_CCGR5_CG6_Pos  // CCGR5, CG6
+	ClockIpSpdif   Clock = (5 << 8) | CCM_CCGR5_CG7_Pos  // CCGR5, CG7
+	ClockIpSimMain Clock = (5 << 8) | CCM_CCGR5_CG8_Pos  // CCGR5, CG8
+	ClockIpSai1    Clock = (5 << 8) | CCM_CCGR5_CG9_Pos  // CCGR5, CG9
+	ClockIpSai2    Clock = (5 << 8) | CCM_CCGR5_CG10_Pos // CCGR5, CG10
+	ClockIpSai3    Clock = (5 << 8) | CCM_CCGR5_CG11_Pos // CCGR5, CG11
+	ClockIpLpuart1 Clock = (5 << 8) | CCM_CCGR5_CG12_Pos // CCGR5, CG12
+	ClockIpLpuart7 Clock = (5 << 8) | CCM_CCGR5_CG13_Pos // CCGR5, CG13
+	ClockIpSnvsHp  Clock = (5 << 8) | CCM_CCGR5_CG14_Pos // CCGR5, CG14
+	ClockIpSnvsLp  Clock = (5 << 8) | CCM_CCGR5_CG15_Pos // CCGR5, CG15
+
+	ClockIpUsbOh3  Clock = (6 << 8) | CCM_CCGR6_CG0_Pos  // CCGR6, CG0
+	ClockIpUsdhc1  Clock = (6 << 8) | CCM_CCGR6_CG1_Pos  // CCGR6, CG1
+	ClockIpUsdhc2  Clock = (6 << 8) | CCM_CCGR6_CG2_Pos  // CCGR6, CG2
+	ClockIpDcdc    Clock = (6 << 8) | CCM_CCGR6_CG3_Pos  // CCGR6, CG3
+	ClockIpIpmux4  Clock = (6 << 8) | CCM_CCGR6_CG4_Pos  // CCGR6, CG4
+	ClockIpFlexSpi Clock = (6 << 8) | CCM_CCGR6_CG5_Pos  // CCGR6, CG5
+	ClockIpTrng    Clock = (6 << 8) | CCM_CCGR6_CG6_Pos  // CCGR6, CG6
+	ClockIpLpuart8 Clock = (6 << 8) | CCM_CCGR6_CG7_Pos  // CCGR6, CG7
+	ClockIpTimer4  Clock = (6 << 8) | CCM_CCGR6_CG8_Pos  // CCGR6, CG8
+	ClockIpAipsTz3 Clock = (6 << 8) | CCM_CCGR6_CG9_Pos  // CCGR6, CG9
+	ClockIpSimPer  Clock = (6 << 8) | CCM_CCGR6_CG10_Pos // CCGR6, CG10
+	ClockIpAnadig  Clock = (6 << 8) | CCM_CCGR6_CG11_Pos // CCGR6, CG11
+	ClockIpLpi2c4  Clock = (6 << 8) | CCM_CCGR6_CG12_Pos // CCGR6, CG12
+	ClockIpTimer1  Clock = (6 << 8) | CCM_CCGR6_CG13_Pos // CCGR6, CG13
+	ClockIpTimer2  Clock = (6 << 8) | CCM_CCGR6_CG14_Pos // CCGR6, CG14
+	ClockIpTimer3  Clock = (6 << 8) | CCM_CCGR6_CG15_Pos // CCGR6, CG15
+
+	ClockIpEnet2    Clock = (7 << 8) | CCM_CCGR7_CG0_Pos // CCGR7, CG0
+	ClockIpFlexSpi2 Clock = (7 << 8) | CCM_CCGR7_CG1_Pos // CCGR7, CG1
+	ClockIpAxbsL    Clock = (7 << 8) | CCM_CCGR7_CG2_Pos // CCGR7, CG2
+	ClockIpCan3     Clock = (7 << 8) | CCM_CCGR7_CG3_Pos // CCGR7, CG3
+	ClockIpCan3S    Clock = (7 << 8) | CCM_CCGR7_CG4_Pos // CCGR7, CG4
+	ClockIpAipsLite Clock = (7 << 8) | CCM_CCGR7_CG5_Pos // CCGR7, CG5
+	ClockIpFlexio3  Clock = (7 << 8) | CCM_CCGR7_CG6_Pos // CCGR7, CG6
+)
+
+// PLL name
+const (
+	ClockPllArm     Clock = ((offPllArm & 0xFFF) << 16) | CCM_ANALOG_PLL_ARM_ENABLE_Pos            // PLL ARM
+	ClockPllSys     Clock = ((offPllSys & 0xFFF) << 16) | CCM_ANALOG_PLL_SYS_ENABLE_Pos            // PLL SYS
+	ClockPllUsb1    Clock = ((offPllUsb1 & 0xFFF) << 16) | CCM_ANALOG_PLL_USB1_ENABLE_Pos          // PLL USB1
+	ClockPllAudio   Clock = ((offPllAudio & 0xFFF) << 16) | CCM_ANALOG_PLL_AUDIO_ENABLE_Pos        // PLL Audio
+	ClockPllVideo   Clock = ((offPllVideo & 0xFFF) << 16) | CCM_ANALOG_PLL_VIDEO_ENABLE_Pos        // PLL Video
+	ClockPllEnet    Clock = ((offPllEnet & 0xFFF) << 16) | CCM_ANALOG_PLL_ENET_ENABLE_Pos          // PLL Enet0
+	ClockPllEnet2   Clock = ((offPllEnet & 0xFFF) << 16) | CCM_ANALOG_PLL_ENET_ENET2_REF_EN_Pos    // PLL Enet1
+	ClockPllEnet25M Clock = ((offPllEnet & 0xFFF) << 16) | CCM_ANALOG_PLL_ENET_ENET_25M_REF_EN_Pos // PLL Enet2
+	ClockPllUsb2    Clock = ((offPllUsb2 & 0xFFF) << 16) | CCM_ANALOG_PLL_USB2_ENABLE_Pos          // PLL USB2
+)
+
+// PLL PFD name
+const (
+	ClockPfd0 Clock = 0 // PLL PFD0
+	ClockPfd1 Clock = 1 // PLL PFD1
+	ClockPfd2 Clock = 2 // PLL PFD2
+	ClockPfd3 Clock = 3 // PLL PFD3
+)
+
+// Named clock muxes of integrated peripherals
+const (
+	MuxIpPll3Sw     Clock = (offCCSR & 0xFF) | (CCM_CCSR_PLL3_SW_CLK_SEL_Pos << 8) | (((CCM_CCSR_PLL3_SW_CLK_SEL_Msk >> CCM_CCSR_PLL3_SW_CLK_SEL_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                          // pll3_sw_clk mux name
+	MuxIpPeriph     Clock = (offCBCDR & 0xFF) | (CCM_CBCDR_PERIPH_CLK_SEL_Pos << 8) | (((CCM_CBCDR_PERIPH_CLK_SEL_Msk >> CCM_CBCDR_PERIPH_CLK_SEL_Pos) & 0x1FFF) << 13) | (CCM_CDHIPR_PERIPH_CLK_SEL_BUSY_Pos << 26) // periph mux name
+	MuxIpSemcAlt    Clock = (offCBCDR & 0xFF) | (CCM_CBCDR_SEMC_ALT_CLK_SEL_Pos << 8) | (((CCM_CBCDR_SEMC_ALT_CLK_SEL_Msk >> CCM_CBCDR_SEMC_ALT_CLK_SEL_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                   // semc mux name
+	MuxIpSemc       Clock = (offCBCDR & 0xFF) | (CCM_CBCDR_SEMC_CLK_SEL_Pos << 8) | (((CCM_CBCDR_SEMC_CLK_SEL_Msk >> CCM_CBCDR_SEMC_CLK_SEL_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                               // semc mux name
+	MuxIpPrePeriph  Clock = (offCBCMR & 0xFF) | (CCM_CBCMR_PRE_PERIPH_CLK_SEL_Pos << 8) | (((CCM_CBCMR_PRE_PERIPH_CLK_SEL_Msk >> CCM_CBCMR_PRE_PERIPH_CLK_SEL_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)             // pre-periph mux name
+	MuxIpTrace      Clock = (offCBCMR & 0xFF) | (CCM_CBCMR_TRACE_CLK_SEL_Pos << 8) | (((CCM_CBCMR_TRACE_CLK_SEL_Msk >> CCM_CBCMR_TRACE_CLK_SEL_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                            // trace mux name
+	MuxIpPeriphClk2 Clock = (offCBCMR & 0xFF) | (CCM_CBCMR_PERIPH_CLK2_SEL_Pos << 8) | (((CCM_CBCMR_PERIPH_CLK2_SEL_Msk >> CCM_CBCMR_PERIPH_CLK2_SEL_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                      // periph clock2 mux name
+	MuxIpFlexSpi2   Clock = (offCBCMR & 0xFF) | (CCM_CBCMR_FLEXSPI2_CLK_SEL_Pos << 8) | (((CCM_CBCMR_FLEXSPI2_CLK_SEL_Msk >> CCM_CBCMR_FLEXSPI2_CLK_SEL_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                   // flexspi2 mux name
+	MuxIpLpspi      Clock = (offCBCMR & 0xFF) | (CCM_CBCMR_LPSPI_CLK_SEL_Pos << 8) | (((CCM_CBCMR_LPSPI_CLK_SEL_Msk >> CCM_CBCMR_LPSPI_CLK_SEL_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                            // lpspi mux name
+	MuxIpFlexSpi    Clock = (offCSCMR1 & 0xFF) | (CCM_CSCMR1_FLEXSPI_CLK_SEL_Pos << 8) | (((CCM_CSCMR1_FLEXSPI_CLK_SEL_Msk >> CCM_CSCMR1_FLEXSPI_CLK_SEL_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                  // flexspi mux name
+	MuxIpUsdhc2     Clock = (offCSCMR1 & 0xFF) | (CCM_CSCMR1_USDHC2_CLK_SEL_Pos << 8) | (((CCM_CSCMR1_USDHC2_CLK_SEL_Msk >> CCM_CSCMR1_USDHC2_CLK_SEL_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                     // usdhc2 mux name
+	MuxIpUsdhc1     Clock = (offCSCMR1 & 0xFF) | (CCM_CSCMR1_USDHC1_CLK_SEL_Pos << 8) | (((CCM_CSCMR1_USDHC1_CLK_SEL_Msk >> CCM_CSCMR1_USDHC1_CLK_SEL_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                     // usdhc1 mux name
+	MuxIpSai3       Clock = (offCSCMR1 & 0xFF) | (CCM_CSCMR1_SAI3_CLK_SEL_Pos << 8) | (((CCM_CSCMR1_SAI3_CLK_SEL_Msk >> CCM_CSCMR1_SAI3_CLK_SEL_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                           // sai3 mux name
+	MuxIpSai2       Clock = (offCSCMR1 & 0xFF) | (CCM_CSCMR1_SAI2_CLK_SEL_Pos << 8) | (((CCM_CSCMR1_SAI2_CLK_SEL_Msk >> CCM_CSCMR1_SAI2_CLK_SEL_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                           // sai2 mux name
+	MuxIpSai1       Clock = (offCSCMR1 & 0xFF) | (CCM_CSCMR1_SAI1_CLK_SEL_Pos << 8) | (((CCM_CSCMR1_SAI1_CLK_SEL_Msk >> CCM_CSCMR1_SAI1_CLK_SEL_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                           // sai1 mux name
+	MuxIpPerclk     Clock = (offCSCMR1 & 0xFF) | (CCM_CSCMR1_PERCLK_CLK_SEL_Pos << 8) | (((CCM_CSCMR1_PERCLK_CLK_SEL_Msk >> CCM_CSCMR1_PERCLK_CLK_SEL_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                     // perclk mux name
+	MuxIpFlexio2    Clock = (offCSCMR2 & 0xFF) | (CCM_CSCMR2_FLEXIO2_CLK_SEL_Pos << 8) | (((CCM_CSCMR2_FLEXIO2_CLK_SEL_Msk >> CCM_CSCMR2_FLEXIO2_CLK_SEL_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                  // flexio2 mux name
+	MuxIpCan        Clock = (offCSCMR2 & 0xFF) | (CCM_CSCMR2_CAN_CLK_SEL_Pos << 8) | (((CCM_CSCMR2_CAN_CLK_SEL_Msk >> CCM_CSCMR2_CAN_CLK_SEL_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                              // can mux name
+	MuxIpUart       Clock = (offCSCDR1 & 0xFF) | (CCM_CSCDR1_UART_CLK_SEL_Pos << 8) | (((CCM_CSCDR1_UART_CLK_SEL_Msk >> CCM_CSCDR1_UART_CLK_SEL_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                           // uart mux name
+	MuxIpSpdif      Clock = (offCDCDR & 0xFF) | (CCM_CDCDR_SPDIF0_CLK_SEL_Pos << 8) | (((CCM_CDCDR_SPDIF0_CLK_SEL_Msk >> CCM_CDCDR_SPDIF0_CLK_SEL_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                         // spdif mux name
+	MuxIpFlexio1    Clock = (offCDCDR & 0xFF) | (CCM_CDCDR_FLEXIO1_CLK_SEL_Pos << 8) | (((CCM_CDCDR_FLEXIO1_CLK_SEL_Msk >> CCM_CDCDR_FLEXIO1_CLK_SEL_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                      // flexio1 mux name
+	MuxIpLpi2c      Clock = (offCSCDR2 & 0xFF) | (CCM_CSCDR2_LPI2C_CLK_SEL_Pos << 8) | (((CCM_CSCDR2_LPI2C_CLK_SEL_Msk >> CCM_CSCDR2_LPI2C_CLK_SEL_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                        // lpi2c mux name
+	MuxIpLcdifPre   Clock = (offCSCDR2 & 0xFF) | (CCM_CSCDR2_LCDIF_PRE_CLK_SEL_Pos << 8) | (((CCM_CSCDR2_LCDIF_PRE_CLK_SEL_Msk >> CCM_CSCDR2_LCDIF_PRE_CLK_SEL_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)            // lcdif pre mux name
+	MuxIpCsi        Clock = (offCSCDR3 & 0xFF) | (CCM_CSCDR3_CSI_CLK_SEL_Pos << 8) | (((CCM_CSCDR3_CSI_CLK_SEL_Msk >> CCM_CSCDR3_CSI_CLK_SEL_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                              // csi mux name
+)
+
+// Named hardware clock divisors of integrated peripherals
+const (
+	DivIpArm        Clock = (offCACRR & 0xFF) | (CCM_CACRR_ARM_PODF_Pos << 8) | (((CCM_CACRR_ARM_PODF_Msk >> CCM_CACRR_ARM_PODF_Pos) & 0x1FFF) << 13) | (CCM_CDHIPR_ARM_PODF_BUSY_Pos << 26)           // core div name
+	DivIpPeriphClk2 Clock = (offCBCDR & 0xFF) | (CCM_CBCDR_PERIPH_CLK2_PODF_Pos << 8) | (((CCM_CBCDR_PERIPH_CLK2_PODF_Msk >> CCM_CBCDR_PERIPH_CLK2_PODF_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)     // periph clock2 div name
+	DivIpSemc       Clock = (offCBCDR & 0xFF) | (CCM_CBCDR_SEMC_PODF_Pos << 8) | (((CCM_CBCDR_SEMC_PODF_Msk >> CCM_CBCDR_SEMC_PODF_Pos) & 0x1FFF) << 13) | (CCM_CDHIPR_SEMC_PODF_BUSY_Pos << 26)       // semc div name
+	DivIpAhb        Clock = (offCBCDR & 0xFF) | (CCM_CBCDR_AHB_PODF_Pos << 8) | (((CCM_CBCDR_AHB_PODF_Msk >> CCM_CBCDR_AHB_PODF_Pos) & 0x1FFF) << 13) | (CCM_CDHIPR_AHB_PODF_BUSY_Pos << 26)           // ahb div name
+	DivIpIpg        Clock = (offCBCDR & 0xFF) | (CCM_CBCDR_IPG_PODF_Pos << 8) | (((CCM_CBCDR_IPG_PODF_Msk >> CCM_CBCDR_IPG_PODF_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                             // ipg div name
+	DivIpFlexSpi2   Clock = (offCBCMR & 0xFF) | (CCM_CBCMR_FLEXSPI2_PODF_Pos << 8) | (((CCM_CBCMR_FLEXSPI2_PODF_Msk >> CCM_CBCMR_FLEXSPI2_PODF_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)              // flexspi2 div name
+	DivIpLpspi      Clock = (offCBCMR & 0xFF) | (CCM_CBCMR_LPSPI_PODF_Pos << 8) | (((CCM_CBCMR_LPSPI_PODF_Msk >> CCM_CBCMR_LPSPI_PODF_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                       // lpspi div name
+	DivIpLcdif      Clock = (offCBCMR & 0xFF) | (CCM_CBCMR_LCDIF_PODF_Pos << 8) | (((CCM_CBCMR_LCDIF_PODF_Msk >> CCM_CBCMR_LCDIF_PODF_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                       // lcdif div name
+	DivIpFlexSpi    Clock = (offCSCMR1 & 0xFF) | (CCM_CSCMR1_FLEXSPI_PODF_Pos << 8) | (((CCM_CSCMR1_FLEXSPI_PODF_Msk >> CCM_CSCMR1_FLEXSPI_PODF_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)             // flexspi div name
+	DivIpPerclk     Clock = (offCSCMR1 & 0xFF) | (CCM_CSCMR1_PERCLK_PODF_Pos << 8) | (((CCM_CSCMR1_PERCLK_PODF_Msk >> CCM_CSCMR1_PERCLK_PODF_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                // perclk div name
+	DivIpCan        Clock = (offCSCMR2 & 0xFF) | (CCM_CSCMR2_CAN_CLK_PODF_Pos << 8) | (((CCM_CSCMR2_CAN_CLK_PODF_Msk >> CCM_CSCMR2_CAN_CLK_PODF_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)             // can div name
+	DivIpTrace      Clock = (offCSCDR1 & 0xFF) | (CCM_CSCDR1_TRACE_PODF_Pos << 8) | (((CCM_CSCDR1_TRACE_PODF_Msk >> CCM_CSCDR1_TRACE_PODF_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                   // trace div name
+	DivIpUsdhc2     Clock = (offCSCDR1 & 0xFF) | (CCM_CSCDR1_USDHC2_PODF_Pos << 8) | (((CCM_CSCDR1_USDHC2_PODF_Msk >> CCM_CSCDR1_USDHC2_PODF_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                // usdhc2 div name
+	DivIpUsdhc1     Clock = (offCSCDR1 & 0xFF) | (CCM_CSCDR1_USDHC1_PODF_Pos << 8) | (((CCM_CSCDR1_USDHC1_PODF_Msk >> CCM_CSCDR1_USDHC1_PODF_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                // usdhc1 div name
+	DivIpUart       Clock = (offCSCDR1 & 0xFF) | (CCM_CSCDR1_UART_CLK_PODF_Pos << 8) | (((CCM_CSCDR1_UART_CLK_PODF_Msk >> CCM_CSCDR1_UART_CLK_PODF_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)          // uart div name
+	DivIpFlexio2    Clock = (offCS1CDR & 0xFF) | (CCM_CS1CDR_FLEXIO2_CLK_PODF_Pos << 8) | (((CCM_CS1CDR_FLEXIO2_CLK_PODF_Msk >> CCM_CS1CDR_FLEXIO2_CLK_PODF_Pos) & 0x1FFF) << 13) | (noBusyWait << 26) // flexio2 pre div name
+	DivIpSai3Pre    Clock = (offCS1CDR & 0xFF) | (CCM_CS1CDR_SAI3_CLK_PRED_Pos << 8) | (((CCM_CS1CDR_SAI3_CLK_PRED_Msk >> CCM_CS1CDR_SAI3_CLK_PRED_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)          // sai3 pre div name
+	DivIpSai3       Clock = (offCS1CDR & 0xFF) | (CCM_CS1CDR_SAI3_CLK_PODF_Pos << 8) | (((CCM_CS1CDR_SAI3_CLK_PODF_Msk >> CCM_CS1CDR_SAI3_CLK_PODF_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)          // sai3 div name
+	DivIpFlexio2Pre Clock = (offCS1CDR & 0xFF) | (CCM_CS1CDR_FLEXIO2_CLK_PRED_Pos << 8) | (((CCM_CS1CDR_FLEXIO2_CLK_PRED_Msk >> CCM_CS1CDR_FLEXIO2_CLK_PRED_Pos) & 0x1FFF) << 13) | (noBusyWait << 26) // sai3 pre div name
+	DivIpSai1Pre    Clock = (offCS1CDR & 0xFF) | (CCM_CS1CDR_SAI1_CLK_PRED_Pos << 8) | (((CCM_CS1CDR_SAI1_CLK_PRED_Msk >> CCM_CS1CDR_SAI1_CLK_PRED_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)          // sai1 pre div name
+	DivIpSai1       Clock = (offCS1CDR & 0xFF) | (CCM_CS1CDR_SAI1_CLK_PODF_Pos << 8) | (((CCM_CS1CDR_SAI1_CLK_PODF_Msk >> CCM_CS1CDR_SAI1_CLK_PODF_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)          // sai1 div name
+	DivIpSai2Pre    Clock = (offCS2CDR & 0xFF) | (CCM_CS2CDR_SAI2_CLK_PRED_Pos << 8) | (((CCM_CS2CDR_SAI2_CLK_PRED_Msk >> CCM_CS2CDR_SAI2_CLK_PRED_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)          // sai2 pre div name
+	DivIpSai2       Clock = (offCS2CDR & 0xFF) | (CCM_CS2CDR_SAI2_CLK_PODF_Pos << 8) | (((CCM_CS2CDR_SAI2_CLK_PODF_Msk >> CCM_CS2CDR_SAI2_CLK_PODF_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)          // sai2 div name
+	DivIpSpdif0Pre  Clock = (offCDCDR & 0xFF) | (CCM_CDCDR_SPDIF0_CLK_PRED_Pos << 8) | (((CCM_CDCDR_SPDIF0_CLK_PRED_Msk >> CCM_CDCDR_SPDIF0_CLK_PRED_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)        // spdif pre div name
+	DivIpSpdif0     Clock = (offCDCDR & 0xFF) | (CCM_CDCDR_SPDIF0_CLK_PODF_Pos << 8) | (((CCM_CDCDR_SPDIF0_CLK_PODF_Msk >> CCM_CDCDR_SPDIF0_CLK_PODF_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)        // spdif div name
+	DivIpFlexio1Pre Clock = (offCDCDR & 0xFF) | (CCM_CDCDR_FLEXIO1_CLK_PRED_Pos << 8) | (((CCM_CDCDR_FLEXIO1_CLK_PRED_Msk >> CCM_CDCDR_FLEXIO1_CLK_PRED_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)     // flexio1 pre div name
+	DivIpFlexio1    Clock = (offCDCDR & 0xFF) | (CCM_CDCDR_FLEXIO1_CLK_PODF_Pos << 8) | (((CCM_CDCDR_FLEXIO1_CLK_PODF_Msk >> CCM_CDCDR_FLEXIO1_CLK_PODF_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)     // flexio1 div name
+	DivIpLpi2c      Clock = (offCSCDR2 & 0xFF) | (CCM_CSCDR2_LPI2C_CLK_PODF_Pos << 8) | (((CCM_CSCDR2_LPI2C_CLK_PODF_Msk >> CCM_CSCDR2_LPI2C_CLK_PODF_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)       // lpi2c div name
+	DivIpLcdifPre   Clock = (offCSCDR2 & 0xFF) | (CCM_CSCDR2_LCDIF_PRED_Pos << 8) | (((CCM_CSCDR2_LCDIF_PRED_Msk >> CCM_CSCDR2_LCDIF_PRED_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                   // lcdif pre div name
+	DivIpCsi        Clock = (offCSCDR3 & 0xFF) | (CCM_CSCDR3_CSI_PODF_Pos << 8) | (((CCM_CSCDR3_CSI_PODF_Msk >> CCM_CSCDR3_CSI_PODF_Pos) & 0x1FFF) << 13) | (noBusyWait << 26)                         // csi div name
+)
+
+// Selected clock offsets
+const (
+	offCCSR   = 0x0C
+	offCBCDR  = 0x14
+	offCBCMR  = 0x18
+	offCSCMR1 = 0x1C
+	offCSCMR2 = 0x20
+	offCSCDR1 = 0x24
+	offCDCDR  = 0x30
+	offCSCDR2 = 0x38
+	offCSCDR3 = 0x3C
+	offCACRR  = 0x10
+	offCS1CDR = 0x28
+	offCS2CDR = 0x2C
+
+	offPllArm   = 0x00
+	offPllSys   = 0x30
+	offPllUsb1  = 0x10
+	offPllAudio = 0x70
+	offPllVideo = 0xA0
+	offPllEnet  = 0xE0
+	offPllUsb2  = 0x20
+
+	noBusyWait = 0x20
+)
+
+// analog PLL definition
+const (
+	pllBypassPos       = 16
+	pllBypassClkSrcMsk = 0xC000
+	pllBypassClkSrcPos = 14
+)
+
+// PLL clock source, bypass cloco source also
+const (
+	pllSrc24M   = 0 // Pll clock source 24M
+	pllSrcClkPN = 1 // Pll clock source CLK1_P and CLK1_N
+)
+
+const (
+	clockNotNeeded     uint32 = 0 // Clock is off during all modes
+	clockNeededRun     uint32 = 1 // Clock is on in run mode, but off in WAIT and STOP modes
+	clockNeededRunWait uint32 = 3 // Clock is on during all modes, except STOP mode
+)
+
+// getGate returns the CCM clock gating register for the receiver clk.
+func (clk Clock) getGate() *volatile.Register32 {
+	switch clk >> 8 {
+	case 0:
+		return &CCM.CCGR0
+	case 1:
+		return &CCM.CCGR1
+	case 2:
+		return &CCM.CCGR2
+	case 3:
+		return &CCM.CCGR3
+	case 4:
+		return &CCM.CCGR4
+	case 5:
+		return &CCM.CCGR5
+	case 6:
+		return &CCM.CCGR6
+	case 7:
+		return &CCM.CCGR7
+	default:
+		panic("nxp: invalid clock")
+	}
+}
+
+// setGate enables or disables the receiver clk using its gating register.
+func (clk Clock) setGate(value uint32) {
+	reg := clk.getGate()
+	shift := clk & 0x1F
+	reg.Set((reg.Get() & ^(3 << shift)) | (value << shift))
+}
+
+func (clk Clock) setCcm(value uint32) {
+	const ccmBase = 0x400fc000
+	reg := (*volatile.Register32)(unsafe.Pointer(uintptr(ccmBase + (uint32(clk) & 0xFF))))
+	msk := ((uint32(clk) >> 13) & 0x1FFF) << ((uint32(clk) >> 8) & 0x1F)
+	pos := (uint32(clk) >> 8) & 0x1F
+	bsy := (uint32(clk) >> 26) & 0x3F
+	reg.Set((reg.Get() & ^uint32(msk)) | ((value << pos) & msk))
+	if bsy < noBusyWait {
+		for CCM.CDHIPR.HasBits(1 << bsy) {
+		}
+	}
+}
+
+func setSysPfd(value ...uint32) {
+	for i, val := range value {
+		pfd528 := CCM_ANALOG.PFD_528.Get() &
+			^((CCM_ANALOG_PFD_528_PFD0_CLKGATE_Msk | CCM_ANALOG_PFD_528_PFD0_FRAC_Msk) << (8 * uint32(i)))
+		frac := (val << CCM_ANALOG_PFD_528_PFD0_FRAC_Pos) & CCM_ANALOG_PFD_528_PFD0_FRAC_Msk
+		// disable the clock output first
+		CCM_ANALOG.PFD_528.Set(pfd528 | (CCM_ANALOG_PFD_528_PFD0_CLKGATE_Msk << (8 * uint32(i))))
+		// set the new value and enable output
+		CCM_ANALOG.PFD_528.Set(pfd528 | (frac << (8 * uint32(i))))
+	}
+}
+
+func setUsb1Pfd(value ...uint32) {
+	for i, val := range value {
+		pfd480 := CCM_ANALOG.PFD_480.Get() &
+			^((CCM_ANALOG_PFD_480_PFD0_CLKGATE_Msk | CCM_ANALOG_PFD_480_PFD0_FRAC_Msk) << (8 * uint32(i)))
+		frac := (val << CCM_ANALOG_PFD_480_PFD0_FRAC_Pos) & CCM_ANALOG_PFD_480_PFD0_FRAC_Msk
+		// disable the clock output first
+		CCM_ANALOG.PFD_480.Set(pfd480 | (CCM_ANALOG_PFD_480_PFD0_CLKGATE_Msk << (8 * uint32(i))))
+		// set the new value and enable output
+		CCM_ANALOG.PFD_480.Set(pfd480 | (frac << (8 * uint32(i))))
+	}
+}
+
+// PLL configuration for ARM
+type ClockConfigArmPll struct {
+	LoopDivider uint32 // PLL loop divider. Valid range for divider value: 54-108. Fout=Fin*LoopDivider/2.
+	Src         uint8  // Pll clock source, reference _clock_pll_clk_src
+}
+
+func (cfg ClockConfigArmPll) Configure() {
+
+	// bypass PLL first
+	src := (uint32(cfg.Src) << CCM_ANALOG_PLL_ARM_BYPASS_CLK_SRC_Pos) & CCM_ANALOG_PLL_ARM_BYPASS_CLK_SRC_Msk
+	CCM_ANALOG.PLL_ARM.Set(
+		(CCM_ANALOG.PLL_ARM.Get() & ^uint32(CCM_ANALOG_PLL_ARM_BYPASS_CLK_SRC_Msk)) |
+			CCM_ANALOG_PLL_ARM_BYPASS_Msk | src)
+
+	sel := (cfg.LoopDivider << CCM_ANALOG_PLL_ARM_DIV_SELECT_Pos) & CCM_ANALOG_PLL_ARM_DIV_SELECT_Msk
+	CCM_ANALOG.PLL_ARM.Set(
+		(CCM_ANALOG.PLL_ARM.Get() & ^uint32(CCM_ANALOG_PLL_ARM_DIV_SELECT_Msk|CCM_ANALOG_PLL_ARM_POWERDOWN_Msk)) |
+			CCM_ANALOG_PLL_ARM_ENABLE_Msk | sel)
+
+	for !CCM_ANALOG.PLL_ARM.HasBits(CCM_ANALOG_PLL_ARM_LOCK_Msk) {
+	}
+
+	// disable bypass
+	CCM_ANALOG.PLL_ARM.ClearBits(CCM_ANALOG_PLL_ARM_BYPASS_Msk)
+}
+
+// PLL configuration for System
+type ClockConfigSysPll struct {
+	LoopDivider uint8  // PLL loop divider. Intended to be 1 (528M): 0 - Fout=Fref*20, 1 - Fout=Fref*22
+	Numerator   uint32 // 30 bit Numerator of fractional loop divider.
+	Denominator uint32 // 30 bit Denominator of fractional loop divider
+	Src         uint8  // Pll clock source, reference _clock_pll_clk_src
+	SsStop      uint16 // Stop value to get frequency change.
+	SsEnable    uint8  // Enable spread spectrum modulation
+	SsStep      uint16 // Step value to get frequency change step.
+}
+
+func (cfg ClockConfigSysPll) Configure(pfd ...uint32) {
+
+	// bypass PLL first
+	src := (uint32(cfg.Src) << CCM_ANALOG_PLL_SYS_BYPASS_CLK_SRC_Pos) & CCM_ANALOG_PLL_SYS_BYPASS_CLK_SRC_Msk
+	CCM_ANALOG.PLL_SYS.Set(
+		(CCM_ANALOG.PLL_SYS.Get() & ^uint32(CCM_ANALOG_PLL_SYS_BYPASS_CLK_SRC_Msk)) |
+			CCM_ANALOG_PLL_SYS_BYPASS_Msk | src)
+
+	sel := (uint32(cfg.LoopDivider) << CCM_ANALOG_PLL_SYS_DIV_SELECT_Pos) & CCM_ANALOG_PLL_SYS_DIV_SELECT_Msk
+	CCM_ANALOG.PLL_SYS.Set(
+		(CCM_ANALOG.PLL_SYS.Get() & ^uint32(CCM_ANALOG_PLL_SYS_DIV_SELECT_Msk|CCM_ANALOG_PLL_SYS_POWERDOWN_Msk)) |
+			CCM_ANALOG_PLL_SYS_ENABLE_Msk | sel)
+
+	// initialize the fractional mode
+	CCM_ANALOG.PLL_SYS_NUM.Set((cfg.Numerator << CCM_ANALOG_PLL_SYS_NUM_A_Pos) & CCM_ANALOG_PLL_SYS_NUM_A_Msk)
+	CCM_ANALOG.PLL_SYS_DENOM.Set((cfg.Denominator << CCM_ANALOG_PLL_SYS_DENOM_B_Pos) & CCM_ANALOG_PLL_SYS_DENOM_B_Msk)
+
+	// initialize the spread spectrum mode
+	inc := (uint32(cfg.SsStep) << CCM_ANALOG_PLL_SYS_SS_STEP_Pos) & CCM_ANALOG_PLL_SYS_SS_STEP_Msk
+	enb := (uint32(cfg.SsEnable) << CCM_ANALOG_PLL_SYS_SS_ENABLE_Pos) & CCM_ANALOG_PLL_SYS_SS_ENABLE_Msk
+	stp := (uint32(cfg.SsStop) << CCM_ANALOG_PLL_SYS_SS_STOP_Pos) & CCM_ANALOG_PLL_SYS_SS_STOP_Msk
+	CCM_ANALOG.PLL_SYS_SS.Set(inc | enb | stp)
+
+	for !CCM_ANALOG.PLL_SYS.HasBits(CCM_ANALOG_PLL_SYS_LOCK_Msk) {
+	}
+
+	// disable bypass
+	CCM_ANALOG.PLL_SYS.ClearBits(CCM_ANALOG_PLL_SYS_BYPASS_Msk)
+
+	// update PFDs after update
+	setSysPfd(pfd...)
+}
+
+// PLL configuration for USB
+type ClockConfigUsbPll struct {
+	Instance    uint8 // USB PLL number (1 or 2)
+	LoopDivider uint8 // PLL loop divider: 0 - Fout=Fref*20, 1 - Fout=Fref*22
+	Src         uint8 // Pll clock source, reference _clock_pll_clk_src
+}
+
+func (cfg ClockConfigUsbPll) Configure(pfd ...uint32) {
+
+	switch cfg.Instance {
+	case 1:
+
+		// bypass PLL first
+		src := (uint32(cfg.Src) << CCM_ANALOG_PLL_USB1_BYPASS_CLK_SRC_Pos) & CCM_ANALOG_PLL_USB1_BYPASS_CLK_SRC_Msk
+		CCM_ANALOG.PLL_USB1.Set(
+			(CCM_ANALOG.PLL_USB1.Get() & ^uint32(CCM_ANALOG_PLL_USB1_BYPASS_CLK_SRC_Msk)) |
+				CCM_ANALOG_PLL_USB1_BYPASS_Msk | src)
+
+		sel := uint32((cfg.LoopDivider << CCM_ANALOG_PLL_USB1_DIV_SELECT_Pos) & CCM_ANALOG_PLL_USB1_DIV_SELECT_Msk)
+		CCM_ANALOG.PLL_USB1_SET.Set(
+			(CCM_ANALOG.PLL_USB1.Get() & ^uint32(CCM_ANALOG_PLL_USB1_DIV_SELECT_Msk)) |
+				CCM_ANALOG_PLL_USB1_ENABLE_Msk | CCM_ANALOG_PLL_USB1_POWER_Msk |
+				CCM_ANALOG_PLL_USB1_EN_USB_CLKS_Msk | sel)
+
+		for !CCM_ANALOG.PLL_USB1.HasBits(CCM_ANALOG_PLL_USB1_LOCK_Msk) {
+		}
+
+		// disable bypass
+		CCM_ANALOG.PLL_USB1_CLR.Set(CCM_ANALOG_PLL_USB1_BYPASS_Msk)
+
+		// update PFDs after update
+		setUsb1Pfd(pfd...)
+
+	case 2:
+		// bypass PLL first
+		src := (uint32(cfg.Src) << CCM_ANALOG_PLL_USB2_BYPASS_CLK_SRC_Pos) & CCM_ANALOG_PLL_USB2_BYPASS_CLK_SRC_Msk
+		CCM_ANALOG.PLL_USB2.Set(
+			(CCM_ANALOG.PLL_USB2.Get() & ^uint32(CCM_ANALOG_PLL_USB2_BYPASS_CLK_SRC_Msk)) |
+				CCM_ANALOG_PLL_USB2_BYPASS_Msk | src)
+
+		sel := uint32((cfg.LoopDivider << CCM_ANALOG_PLL_USB2_DIV_SELECT_Pos) & CCM_ANALOG_PLL_USB2_DIV_SELECT_Msk)
+		CCM_ANALOG.PLL_USB2.Set(
+			(CCM_ANALOG.PLL_USB2.Get() & ^uint32(CCM_ANALOG_PLL_USB2_DIV_SELECT_Msk)) |
+				CCM_ANALOG_PLL_USB2_ENABLE_Msk | CCM_ANALOG_PLL_USB2_POWER_Msk |
+				CCM_ANALOG_PLL_USB2_EN_USB_CLKS_Msk | sel)
+
+		for !CCM_ANALOG.PLL_USB2.HasBits(CCM_ANALOG_PLL_USB2_LOCK_Msk) {
+		}
+
+		// disable bypass
+		CCM_ANALOG.PLL_USB2.ClearBits(CCM_ANALOG_PLL_USB2_BYPASS_Msk)
+
+	default:
+		panic("nxp: invalid USB PLL")
+	}
+}

src/device/nxp/mimxrt1062_hardfault.go

@@ -0,0 +1,29 @@
+// Hand created file. DO NOT DELETE.
+// Hardfault aliases for definitions that have inconsistent naming (which are
+// auto-generated by gen-device-svd.go) among devices in package nxp.
+
+// +build nxp,mimxrt1062
+
+package nxp
+
+const (
+	HardFault_CFSR_IACCVIOL    = SCB_CFSR_IACCVIOL
+	HardFault_CFSR_DACCVIOL    = SCB_CFSR_DACCVIOL
+	HardFault_CFSR_MUNSTKERR   = SCB_CFSR_MUNSTKERR
+	HardFault_CFSR_MSTKERR     = SCB_CFSR_MSTKERR
+	HardFault_CFSR_MLSPERR     = SCB_CFSR_MLSPERR
+	HardFault_CFSR_IBUSERR     = SCB_CFSR_IBUSERR
+	HardFault_CFSR_PRECISERR   = SCB_CFSR_PRECISERR
+	HardFault_CFSR_IMPRECISERR = SCB_CFSR_IMPRECISERR
+	HardFault_CFSR_UNSTKERR    = SCB_CFSR_UNSTKERR
+	HardFault_CFSR_STKERR      = SCB_CFSR_STKERR
+	HardFault_CFSR_LSPERR      = SCB_CFSR_LSPERR
+	HardFault_CFSR_UNDEFINSTR  = SCB_CFSR_UNDEFINSTR
+	HardFault_CFSR_INVSTATE    = SCB_CFSR_INVSTATE
+	HardFault_CFSR_INVPC       = SCB_CFSR_INVPC
+	HardFault_CFSR_NOCP        = SCB_CFSR_NOCP
+	HardFault_CFSR_UNALIGNED   = SCB_CFSR_UNALIGNED
+	HardFault_CFSR_DIVBYZERO   = SCB_CFSR_DIVBYZERO
+	HardFault_CFSR_MMARVALID   = SCB_CFSR_MMARVALID
+	HardFault_CFSR_BFARVALID   = SCB_CFSR_BFARVALID
+)

src/device/nxp/mimxrt1062_mpu.go

@@ -0,0 +1,278 @@
+// Hand created file. DO NOT DELETE.
+// Type definitions, fields, and constants associated with the MPU peripheral
+// of the NXP MIMXRT1062.
+
+// +build nxp,mimxrt1062
+
+package nxp
+
+import (
+	"device/arm"
+	"runtime/volatile"
+	"unsafe"
+)
+
+type MPU_Type struct {
+	TYPE    volatile.Register32 // 0x000 (R/ ) - MPU Type Register
+	CTRL    volatile.Register32 // 0x004 (R/W) - MPU Control Register
+	RNR     volatile.Register32 // 0x008 (R/W) - MPU Region RNRber Register
+	RBAR    volatile.Register32 // 0x00C (R/W) - MPU Region Base Address Register
+	RASR    volatile.Register32 // 0x010 (R/W) - MPU Region Attribute and Size Register
+	RBAR_A1 volatile.Register32 // 0x014 (R/W) - MPU Alias 1 Region Base Address Register
+	RASR_A1 volatile.Register32 // 0x018 (R/W) - MPU Alias 1 Region Attribute and Size Register
+	RBAR_A2 volatile.Register32 // 0x01C (R/W) - MPU Alias 2 Region Base Address Register
+	RASR_A2 volatile.Register32 // 0x020 (R/W) - MPU Alias 2 Region Attribute and Size Register
+	RBAR_A3 volatile.Register32 // 0x024 (R/W) - MPU Alias 3 Region Base Address Register
+	RASR_A3 volatile.Register32 // 0x028 (R/W) - MPU Alias 3 Region Attribute and Size Register
+}
+
+var MPU = (*MPU_Type)(unsafe.Pointer(uintptr(0xe000ed90)))
+
+type (
+	RegionSize  uint32
+	AccessPerms uint32
+	Extension   uint32
+)
+
+// MPU Control Register Definitions
+const (
+	MPU_CTRL_PRIVDEFENA_Pos = 2                            // MPU CTRL: PRIVDEFENA Position
+	MPU_CTRL_PRIVDEFENA_Msk = 1 << MPU_CTRL_PRIVDEFENA_Pos // MPU CTRL: PRIVDEFENA Mask
+	MPU_CTRL_HFNMIENA_Pos   = 1                            // MPU CTRL: HFNMIENA Position
+	MPU_CTRL_HFNMIENA_Msk   = 1 << MPU_CTRL_HFNMIENA_Pos   // MPU CTRL: HFNMIENA Mask
+	MPU_CTRL_ENABLE_Pos     = 0                            // MPU CTRL: ENABLE Position
+	MPU_CTRL_ENABLE_Msk     = 1                            // MPU CTRL: ENABLE Mask
+)
+
+// MPU Region Base Address Register Definitions
+const (
+	MPU_RBAR_ADDR_Pos   = 5                              // MPU RBAR: ADDR Position
+	MPU_RBAR_ADDR_Msk   = 0x7FFFFFF << MPU_RBAR_ADDR_Pos // MPU RBAR: ADDR Mask
+	MPU_RBAR_VALID_Pos  = 4                              // MPU RBAR: VALID Position
+	MPU_RBAR_VALID_Msk  = 1 << MPU_RBAR_VALID_Pos        // MPU RBAR: VALID Mask
+	MPU_RBAR_REGION_Pos = 0                              // MPU RBAR: REGION Position
+	MPU_RBAR_REGION_Msk = 0xF                            // MPU RBAR: REGION Mask
+)
+
+// MPU Region Attribute and Size Register Definitions
+const (
+	MPU_RASR_ATTRS_Pos  = 16                           // MPU RASR: MPU Region Attribute field Position
+	MPU_RASR_ATTRS_Msk  = 0xFFFF << MPU_RASR_ATTRS_Pos // MPU RASR: MPU Region Attribute field Mask
+	MPU_RASR_XN_Pos     = 28                           // MPU RASR: ATTRS.XN Position
+	MPU_RASR_XN_Msk     = 1 << MPU_RASR_XN_Pos         // MPU RASR: ATTRS.XN Mask
+	MPU_RASR_AP_Pos     = 24                           // MPU RASR: ATTRS.AP Position
+	MPU_RASR_AP_Msk     = 0x7 << MPU_RASR_AP_Pos       // MPU RASR: ATTRS.AP Mask
+	MPU_RASR_TEX_Pos    = 19                           // MPU RASR: ATTRS.TEX Position
+	MPU_RASR_TEX_Msk    = 0x7 << MPU_RASR_TEX_Pos      // MPU RASR: ATTRS.TEX Mask
+	MPU_RASR_S_Pos      = 18                           // MPU RASR: ATTRS.S Position
+	MPU_RASR_S_Msk      = 1 << MPU_RASR_S_Pos          // MPU RASR: ATTRS.S Mask
+	MPU_RASR_C_Pos      = 17                           // MPU RASR: ATTRS.C Position
+	MPU_RASR_C_Msk      = 1 << MPU_RASR_C_Pos          // MPU RASR: ATTRS.C Mask
+	MPU_RASR_B_Pos      = 16                           // MPU RASR: ATTRS.B Position
+	MPU_RASR_B_Msk      = 1 << MPU_RASR_B_Pos          // MPU RASR: ATTRS.B Mask
+	MPU_RASR_SRD_Pos    = 8                            // MPU RASR: Sub-Region Disable Position
+	MPU_RASR_SRD_Msk    = 0xFF << MPU_RASR_SRD_Pos     // MPU RASR: Sub-Region Disable Mask
+	MPU_RASR_SIZE_Pos   = 1                            // MPU RASR: Region Size Field Position
+	MPU_RASR_SIZE_Msk   = 0x1F << MPU_RASR_SIZE_Pos    // MPU RASR: Region Size Field Mask
+	MPU_RASR_ENABLE_Pos = 0                            // MPU RASR: Region enable bit Position
+	MPU_RASR_ENABLE_Msk = 1                            // MPU RASR: Region enable bit Disable Mask
+)
+
+const (
+	SCB_DCISW_WAY_Pos = 30                         // SCB DCISW: Way Position
+	SCB_DCISW_WAY_Msk = 3 << SCB_DCISW_WAY_Pos     // SCB DCISW: Way Mask
+	SCB_DCISW_SET_Pos = 5                          // SCB DCISW: Set Position
+	SCB_DCISW_SET_Msk = 0x1FF << SCB_DCISW_SET_Pos // SCB DCISW: Set Mask
+)
+
+const (
+	SCB_DCCISW_WAY_Pos = 30                          // SCB DCCISW: Way Position
+	SCB_DCCISW_WAY_Msk = 3 << SCB_DCCISW_WAY_Pos     // SCB DCCISW: Way Mask
+	SCB_DCCISW_SET_Pos = 5                           // SCB DCCISW: Set Position
+	SCB_DCCISW_SET_Msk = 0x1FF << SCB_DCCISW_SET_Pos // SCB DCCISW: Set Mask
+)
+
+const (
+	RGNSZ_32B   RegionSize = 0x04 // MPU Region Size 32 Bytes
+	RGNSZ_64B   RegionSize = 0x05 // MPU Region Size 64 Bytes
+	RGNSZ_128B  RegionSize = 0x06 // MPU Region Size 128 Bytes
+	RGNSZ_256B  RegionSize = 0x07 // MPU Region Size 256 Bytes
+	RGNSZ_512B  RegionSize = 0x08 // MPU Region Size 512 Bytes
+	RGNSZ_1KB   RegionSize = 0x09 // MPU Region Size 1 KByte
+	RGNSZ_2KB   RegionSize = 0x0A // MPU Region Size 2 KBytes
+	RGNSZ_4KB   RegionSize = 0x0B // MPU Region Size 4 KBytes
+	RGNSZ_8KB   RegionSize = 0x0C // MPU Region Size 8 KBytes
+	RGNSZ_16KB  RegionSize = 0x0D // MPU Region Size 16 KBytes
+	RGNSZ_32KB  RegionSize = 0x0E // MPU Region Size 32 KBytes
+	RGNSZ_64KB  RegionSize = 0x0F // MPU Region Size 64 KBytes
+	RGNSZ_128KB RegionSize = 0x10 // MPU Region Size 128 KBytes
+	RGNSZ_256KB RegionSize = 0x11 // MPU Region Size 256 KBytes
+	RGNSZ_512KB RegionSize = 0x12 // MPU Region Size 512 KBytes
+	RGNSZ_1MB   RegionSize = 0x13 // MPU Region Size 1 MByte
+	RGNSZ_2MB   RegionSize = 0x14 // MPU Region Size 2 MBytes
+	RGNSZ_4MB   RegionSize = 0x15 // MPU Region Size 4 MBytes
+	RGNSZ_8MB   RegionSize = 0x16 // MPU Region Size 8 MBytes
+	RGNSZ_16MB  RegionSize = 0x17 // MPU Region Size 16 MBytes
+	RGNSZ_32MB  RegionSize = 0x18 // MPU Region Size 32 MBytes
+	RGNSZ_64MB  RegionSize = 0x19 // MPU Region Size 64 MBytes
+	RGNSZ_128MB RegionSize = 0x1A // MPU Region Size 128 MBytes
+	RGNSZ_256MB RegionSize = 0x1B // MPU Region Size 256 MBytes
+	RGNSZ_512MB RegionSize = 0x1C // MPU Region Size 512 MBytes
+	RGNSZ_1GB   RegionSize = 0x1D // MPU Region Size 1 GByte
+	RGNSZ_2GB   RegionSize = 0x1E // MPU Region Size 2 GBytes
+	RGNSZ_4GB   RegionSize = 0x1F // MPU Region Size 4 GBytes
+)
+
+const (
+	PERM_NONE AccessPerms = 0 // MPU Access Permission no access
+	PERM_PRIV AccessPerms = 1 // MPU Access Permission privileged access only
+	PERM_URO  AccessPerms = 2 // MPU Access Permission unprivileged access read-only
+	PERM_FULL AccessPerms = 3 // MPU Access Permission full access
+	PERM_PRO  AccessPerms = 5 // MPU Access Permission privileged access read-only
+	PERM_RO   AccessPerms = 6 // MPU Access Permission read-only access
+)
+
+const (
+	EXTN_NORMAL Extension = 0
+	EXTN_DEVICE Extension = 2
+)
+
+func (mpu *MPU_Type) Enable(enable bool) {
+	if enable {
+		mpu.CTRL.Set(MPU_CTRL_PRIVDEFENA_Msk | MPU_CTRL_ENABLE_Msk)
+		SystemControl.SHCSR.SetBits(SCB_SHCSR_MEMFAULTENA_Msk)
+		arm.AsmFull(`
+      dsb 0xF
+      isb 0xF
+    `, nil)
+		enableDcache(true)
+		enableIcache(true)
+	} else {
+		enableIcache(false)
+		enableDcache(false)
+		arm.AsmFull(`
+      dmb 0xF
+    `, nil)
+		SystemControl.SHCSR.ClearBits(SCB_SHCSR_MEMFAULTENA_Msk)
+		mpu.CTRL.ClearBits(MPU_CTRL_ENABLE_Msk)
+	}
+}
+
+// MPU Region Base Address Register value
+func (mpu *MPU_Type) SetRBAR(region uint32, baseAddress uint32) {
+	mpu.RBAR.Set((baseAddress & MPU_RBAR_ADDR_Msk) |
+		(region & MPU_RBAR_REGION_Msk) | MPU_RBAR_VALID_Msk)
+}
+
+// MPU Region Attribute and Size Register value
+func (mpu *MPU_Type) SetRASR(size RegionSize, access AccessPerms, ext Extension, exec, share, cache, buffer, disable bool) {
+	boolBit := func(b bool) uint32 {
+		if b {
+			return 1
+		}
+		return 0
+	}
+	attr := ((uint32(ext) << MPU_RASR_TEX_Pos) & MPU_RASR_TEX_Msk) |
+		((boolBit(share) << MPU_RASR_S_Pos) & MPU_RASR_S_Msk) |
+		((boolBit(cache) << MPU_RASR_C_Pos) & MPU_RASR_C_Msk) |
+		((boolBit(buffer) << MPU_RASR_B_Pos) & MPU_RASR_B_Msk)
+	mpu.RASR.Set(((boolBit(!exec) << MPU_RASR_XN_Pos) & MPU_RASR_XN_Msk) |
+		((uint32(access) << MPU_RASR_AP_Pos) & MPU_RASR_AP_Msk) |
+		(attr & (MPU_RASR_TEX_Msk | MPU_RASR_S_Msk | MPU_RASR_C_Msk | MPU_RASR_B_Msk)) |
+		((boolBit(disable) << MPU_RASR_SRD_Pos) & MPU_RASR_SRD_Msk) |
+		((uint32(size) << MPU_RASR_SIZE_Pos) & MPU_RASR_SIZE_Msk) |
+		MPU_RASR_ENABLE_Msk)
+}
+
+func enableIcache(enable bool) {
+	if enable != SystemControl.CCR.HasBits(SCB_CCR_IC_Msk) {
+		if enable {
+			arm.AsmFull(`
+        dsb 0xF
+        isb 0xF
+      `, nil)
+			SystemControl.ICIALLU.Set(0)
+			arm.AsmFull(`
+        dsb 0xF
+        isb 0xF
+      `, nil)
+			SystemControl.CCR.SetBits(SCB_CCR_IC_Msk)
+			arm.AsmFull(`
+        dsb 0xF
+        isb 0xF
+      `, nil)
+		} else {
+			arm.AsmFull(`
+        dsb 0xF
+        isb 0xF
+      `, nil)
+			SystemControl.CCR.ClearBits(SCB_CCR_IC_Msk)
+			SystemControl.ICIALLU.Set(0)
+			arm.AsmFull(`
+        dsb 0xF
+        isb 0xF
+      `, nil)
+		}
+	}
+}
+
+func enableDcache(enable bool) {
+	if enable != SystemControl.CCR.HasBits(SCB_CCR_DC_Msk) {
+		if enable {
+			SystemControl.CSSELR.Set(0)
+			arm.AsmFull(`
+        dsb 0xF
+      `, nil)
+			ccsidr := SystemControl.CCSIDR.Get()
+			sets := (ccsidr & SCB_CCSIDR_NUMSETS_Msk) >> SCB_CCSIDR_NUMSETS_Pos
+			for sets != 0 {
+				ways := (ccsidr & SCB_CCSIDR_ASSOCIATIVITY_Msk) >> SCB_CCSIDR_ASSOCIATIVITY_Pos
+				for ways != 0 {
+					SystemControl.DCISW.Set(
+						((sets << SCB_DCISW_SET_Pos) & SCB_DCISW_SET_Msk) |
+							((ways << SCB_DCISW_WAY_Pos) & SCB_DCISW_WAY_Msk))
+					ways--
+				}
+				sets--
+			}
+			arm.AsmFull(`
+        dsb 0xF
+      `, nil)
+			SystemControl.CCR.SetBits(SCB_CCR_DC_Msk)
+			arm.AsmFull(`
+        dsb 0xF
+        isb 0xF
+      `, nil)
+		} else {
+			var (
+				ccsidr volatile.Register32
+				sets   volatile.Register32
+				ways   volatile.Register32
+			)
+			SystemControl.CSSELR.Set(0)
+			arm.AsmFull(`
+        dsb 0xF
+      `, nil)
+			SystemControl.CCR.ClearBits(SCB_CCR_DC_Msk)
+			arm.AsmFull(`
+        dsb 0xF
+      `, nil)
+			ccsidr.Set(SystemControl.CCSIDR.Get())
+			sets.Set((ccsidr.Get() & SCB_CCSIDR_NUMSETS_Msk) >> SCB_CCSIDR_NUMSETS_Pos)
+			for sets.Get() != 0 {
+				ways.Set((ccsidr.Get() & SCB_CCSIDR_ASSOCIATIVITY_Msk) >> SCB_CCSIDR_ASSOCIATIVITY_Pos)
+				for ways.Get() != 0 {
+					SystemControl.DCCISW.Set(
+						((sets.Get() << SCB_DCCISW_SET_Pos) & SCB_DCCISW_SET_Msk) |
+							((ways.Get() << SCB_DCCISW_WAY_Pos) & SCB_DCCISW_WAY_Msk))
+					ways.Set(ways.Get() - 1)
+				}
+				sets.Set(sets.Get() - 1)
+			}
+			arm.AsmFull(`
+        dsb 0xF
+        isb 0xF
+      `, nil)
+		}
+	}
+}

src/device/stm32/stm32-moder-bitfields.go

@@ -1,57 +0,0 @@
-// Hand created file. DO NOT DELETE.
-// STM32FXXX (except stm32f1xx) bitfield definitions that are not
-//  auto-generated by gen-device-svd.go
-
-// These apply to the stm32 families that use the MODER, OTYPE amd PUPDR
-//  registers for managing GPIO functionality.
-
-// Add in other families that use the same settings, e.g. stm32f0xx, etc
-
-// +build stm32,!stm32f103xx
-
-package stm32
-
-// AltFunc represents the alternate function peripherals that can be mapped to
-// the GPIO ports. Since these differ by what is supported on the stm32 family
-// they are defined in the more specific files
-type AltFunc uint8
-
-// Family-wide common post-reset AltFunc. This represents
-//  normal GPIO operation of the pins
-const AF0_SYSTEM AltFunc = 0
-
-const (
-	// Register values for the chip
-	// GPIOx_MODER
-	GPIOModeInput         = 0
-	GPIOModeOutputGeneral = 1
-	GPIOModeOutputAltFunc = 2
-	GPIOModeAnalog        = 3
-
-	// GPIOx_OTYPER
-	GPIOOutputTypePushPull  = 0
-	GPIOOutputTypeOpenDrain = 1
-
-	// GPIOx_OSPEEDR
-	GPIOSpeedLow      = 0
-	GPIOSpeedMid      = 1
-	GPIOSpeedHigh     = 2 // Note: this is also low speed on stm32f0, see RM0091
-	GPIOSpeedVeryHigh = 3
-
-	// GPIOx_PUPDR
-	GPIOPUPDRFloating = 0
-	GPIOPUPDRPullUp   = 1
-	GPIOPUPDRPullDown = 2
-)
-
-// SPI prescaler values fPCLK / X
-const (
-	SPI_PCLK_2   = 0
-	SPI_PCLK_4   = 1
-	SPI_PCLK_8   = 2
-	SPI_PCLK_16  = 3
-	SPI_PCLK_32  = 4
-	SPI_PCLK_64  = 5
-	SPI_PCLK_128 = 6
-	SPI_PCLK_256 = 7
-)

src/device/stm32/stm32f103xx-bitfields.go

@@ -1,88 +0,0 @@
-// Hand created file. DO NOT DELETE.
-// STM32F103XX bitfield definitions that are not auto-generated by gen-device-svd.go
-
-// +build stm32,stm32f103xx
-
-package stm32
-
-const (
-	// Flash Access Control Register flag values.
-	FLASH_ACR_LATENCY_0 = 0x00000001
-	FLASH_ACR_LATENCY_1 = 0x00000002
-	FLASH_ACR_LATENCY_2 = 0x00000004
-
-	// Reset and Clock Control Control Register flag values.
-
-	// System Clock source
-	RCC_CFGR_SW_HSI = 0
-	RCC_CFGR_SW_HSE = 1
-	RCC_CFGR_SW_PLL = 2
-
-	// Flags for when System Clock source is set.
-	RCC_CFGR_SWS_HSI = 0x00000000
-	RCC_CFGR_SWS_HSE = 0x00000004
-	RCC_CFGR_SWS_PLL = 0x00000008
-
-	// Sets PCLK1
-	RCC_CFGR_PPRE1_DIV_NONE = 0x00000000
-	RCC_CFGR_PPRE1_DIV_2    = 0x00000400
-	RCC_CFGR_PPRE1_DIV_4    = 0x00000500
-	RCC_CFGR_PPRE1_DIV_8    = 0x00000600
-	RCC_CFGR_PPRE1_DIV_16   = 0x00000700
-
-	// Sets PCLK2
-	RCC_CFGR_PPRE2_DIV_NONE = 0x00000000
-	RCC_CFGR_PPRE2_DIV_2    = 0x00002000
-	RCC_CFGR_PPRE2_DIV_4    = 0x00002800
-	RCC_CFGR_PPRE2_DIV_8    = 0x00003000
-	RCC_CFGR_PPRE2_DIV_16   = 0x00003800
-
-	// Sets PLL multiplier
-	RCC_CFGR_PLLMUL_2  = 0x00000000
-	RCC_CFGR_PLLMUL_3  = 0x00040000
-	RCC_CFGR_PLLMUL_4  = 0x00080000
-	RCC_CFGR_PLLMUL_5  = 0x000C0000
-	RCC_CFGR_PLLMUL_6  = 0x00100000
-	RCC_CFGR_PLLMUL_7  = 0x00140000
-	RCC_CFGR_PLLMUL_8  = 0x00180000
-	RCC_CFGR_PLLMUL_9  = 0x001C0000
-	RCC_CFGR_PLLMUL_10 = 0x00200000
-	RCC_CFGR_PLLMUL_11 = 0x00240000
-	RCC_CFGR_PLLMUL_12 = 0x00280000
-	RCC_CFGR_PLLMUL_13 = 0x002C0000
-	RCC_CFGR_PLLMUL_14 = 0x00300000
-	RCC_CFGR_PLLMUL_15 = 0x00340000
-	RCC_CFGR_PLLMUL_16 = 0x00380000
-
-	// RTC clock source
-	RCC_RTCCLKSource_LSE        = 0x00000100
-	RCC_RTCCLKSource_LSI        = 0x00000200
-	RCC_RTCCLKSource_HSE_Div128 = 0x00000300
-
-	// SPI settings
-	SPI_FirstBit_MSB = 0x0000
-	SPI_FirstBit_LSB = 0x0080
-
-	SPI_BaudRatePrescaler_2   = 0x0000
-	SPI_BaudRatePrescaler_4   = 0x0008
-	SPI_BaudRatePrescaler_8   = 0x0010
-	SPI_BaudRatePrescaler_16  = 0x0018
-	SPI_BaudRatePrescaler_32  = 0x0020
-	SPI_BaudRatePrescaler_64  = 0x0028
-	SPI_BaudRatePrescaler_128 = 0x0030
-	SPI_BaudRatePrescaler_256 = 0x0038
-
-	SPI_Direction_2Lines_FullDuplex = 0x0000
-	SPI_Direction_2Lines_RxOnly     = 0x0400
-	SPI_Direction_1Line_Rx          = 0x8000
-	SPI_Direction_1Line_Tx          = 0xC000
-
-	SPI_Mode_Master = 0x0104
-	SPI_Mode_Slave  = 0x0000
-
-	SPI_NSS_Soft = 0x0200
-	SPI_NSS_Hard = 0x0000
-
-	SPI_NSSInternalSoft_Set   = 0x0100
-	SPI_NSSInternalSoft_Reset = 0xFEFF
-)

src/device/stm32/stm32f4-altfunc-bitfields.go

@@ -1,28 +0,0 @@
-// Hand created file. DO NOT DELETE.
-// STM32FXXX (except stm32f1xx) bitfield definitions that are not
-//  auto-generated by gen-device-svd.go
-// +build stm32f4
-
-// Alternate function settings on the stm32f4 series
-
-package stm32
-
-const (
-	// Alternative peripheral pin functions
-	// AF0_SYSTEM is defined im the common bitfields package
-	AF1_TIM1_2                AltFunc = 1
-	AF2_TIM3_4_5                      = 2
-	AF3_TIM8_9_10_11                  = 3
-	AF4_I2C1_2_3                      = 4
-	AF5_SPI1_SPI2                     = 5
-	AF6_SPI3                          = 6
-	AF7_USART1_2_3                    = 7
-	AF8_USART4_5_6                    = 8
-	AF9_CAN1_CAN2_TIM12_13_14         = 9
-	AF10_OTG_FS_OTG_HS                = 10
-	AF11_ETH                          = 11
-	AF12_FSMC_SDIO_OTG_HS_1           = 12
-	AF13_DCMI                         = 13
-	AF14                              = 14
-	AF15_EVENTOUT                     = 15
-)

src/examples/adc/adc.go

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