interp: support GEP on fixed (MMIO) addresses

GetElementPtr would not work on values that weren't pointers. Because fixed addresses (often used in memory-mapped I/O) are integers rather than pointers in interp, it would return an error. This resulted in the teensy40 target not compiling correctly since the interp package rewrite. This commit should fix that.
interp: fix alignment of untyped globals
2026-07-26 14:48:40 +00:00 · 2021-03-05 21:24:28 +01:00 · 2020-12-27 11:21:35 +01:00 · 2020-12-22 15:54:23 +01:00 · 2020-12-22 15:54:23 +01:00 · 2020-12-22 15:54:23 +01:00
596 changed files with 39465 additions and 10358 deletions
@@ -14,22 +14,21 @@ commands:
      - run:
          name: "Install apt dependencies"
          command: |
-            echo 'deb http://apt.llvm.org/stretch/ llvm-toolchain-stretch<<parameters.llvm>> main' | sudo tee /etc/apt/sources.list.d/llvm.list
+            echo 'deb https://apt.llvm.org/buster/ llvm-toolchain-buster-<<parameters.llvm>> main' | sudo tee /etc/apt/sources.list.d/llvm.list
            wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key|sudo apt-key add -
            sudo apt-get update
            sudo apt-get install \
-                llvm<<parameters.llvm>>-dev \
-                clang<<parameters.llvm>> \
-                libclang<<parameters.llvm>>-dev \
-                lld<<parameters.llvm>> \
+                llvm-<<parameters.llvm>>-dev \
+                clang-<<parameters.llvm>> \
+                libclang-<<parameters.llvm>>-dev \
+                lld-<<parameters.llvm>> \
                gcc-arm-linux-gnueabihf \
-                libc6-dev-armel-cross \
                gcc-aarch64-linux-gnu \
-                libc6-dev-arm64-cross \
                qemu-system-arm \
                qemu-user \
                gcc-avr \
                avr-libc
+            sudo apt-get install --no-install-recommends libc6-dev-i386 lib32gcc-8-dev
  install-node:
    steps:
      - run:
@@ -39,39 +38,91 @@ commands:
            sudo tar -C /usr/local -xf node-v10.15.1-linux-x64.tar.xz
            sudo ln -s /usr/local/node-v10.15.1-linux-x64/bin/node /usr/bin/node
            rm node-v10.15.1-linux-x64.tar.xz
+  install-chrome:
+    steps:
+      - run:
+          name: "Install Chrome"
+          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:
+        type: string
+    steps:
+      - run:
+          name: "Install Xtensa toolchain"
+          command: |
+            curl -L https://github.com/espressif/crosstool-NG/releases/download/esp-2020r2/xtensa-esp32-elf-gcc8_2_0-esp-2020r2-<<parameters.variant>>.tar.gz -o xtensa-esp32-elf-gcc8_2_0-esp-2020r2-<<parameters.variant>>.tar.gz
+            sudo tar -C /usr/local -xf xtensa-esp32-elf-gcc8_2_0-esp-2020r2-<<parameters.variant>>.tar.gz
+            sudo ln -s /usr/local/xtensa-esp32-elf/bin/xtensa-esp32-elf-ld /usr/local/bin/xtensa-esp32-elf-ld
+            rm xtensa-esp32-elf-gcc8_2_0-esp-2020r2-<<parameters.variant>>.tar.gz
  llvm-source-linux:
    steps:
      - restore_cache:
          keys:
-            - llvm-source-9-v0
+            - llvm-source-11-v1
      - run:
          name: "Fetch LLVM source"
          command: make llvm-source
      - save_cache:
-          key: llvm-source-9-v0
+          key: llvm-source-11-v1
          paths:
            - llvm-project
+  build-wasi-libc:
+    steps:
+      - restore_cache:
+          keys:
+            - wasi-libc-sysroot-v3
+      - run:
+          name: "Build wasi-libc"
+          command: make wasi-libc
+      - save_cache:
+          key: wasi-libc-sysroot-v3
+          paths:
+            - lib/wasi-libc/sysroot
  test-linux:
+    parameters:
+      llvm:
+        type: string
    steps:
      - checkout
      - submodules
      - apt-dependencies:
-          llvm: "-9"
+          llvm: "<<parameters.llvm>>"
      - install-node
+      - install-chrome
+      - install-wasmtime
      - restore_cache:
          keys:
            - go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
            - go-cache-v2-{{ checksum "go.mod" }}
      - llvm-source-linux
-      - run: go install .
-      - run: go test -v ./cgo ./compileopts ./interp ./transform .
+      - run: go install -tags=llvm<<parameters.llvm>> .
+      - restore_cache:
+          keys:
+            - wasi-libc-sysroot-systemclang-v2
+      - run: make wasi-libc
+      - save_cache:
+          key: wasi-libc-sysroot-systemclang-v2
+          paths:
+            - lib/wasi-libc/sysroot
+      - run: go test -v -tags=llvm<<parameters.llvm>> ./cgo ./compileopts ./interp ./transform .
      - run: make gen-device -j4
-      - run: make smoketest
+      - run: make smoketest XTENSA=0
+      - run: make tinygo-test
+      - run: make wasmtest
      - save_cache:
          key: go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
          paths:
            - ~/.cache/go-build
-            - ~/.cache/tinygo
            - /go/pkg/mod
      - run: make fmt-check
  assert-test-linux:
@@ -83,7 +134,6 @@ commands:
          command: |
            sudo apt-get install \
                gcc-arm-linux-gnueabihf \
-                binutils-arm-none-eabi \
                libc6-dev-armel-cross \
                gcc-aarch64-linux-gnu \
                libc6-dev-arm64-cross \
@@ -91,7 +141,11 @@ 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:
          keys:
            - go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
@@ -99,17 +153,14 @@ commands:
      - llvm-source-linux
      - restore_cache:
          keys:
-            - llvm-build-9-linux-v0-assert
+            - llvm-build-11-linux-v1-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
@@ -117,10 +168,11 @@ commands:
              make ASSERT=1 llvm-build
            fi
      - save_cache:
-          key: llvm-build-9-linux-v0-assert
+          key: llvm-build-11-linux-v1-assert
          paths:
            llvm-build
      - run: make ASSERT=1
+      - build-wasi-libc
      - run:
          name: "Test TinyGo"
          command: make ASSERT=1 test
@@ -128,7 +180,6 @@ commands:
          key: go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
          paths:
            - ~/.cache/go-build
-            - ~/.cache/tinygo
            - /go/pkg/mod
      - run: make gen-device -j4
      - run: make smoketest TINYGO=build/tinygo
@@ -141,7 +192,6 @@ commands:
          command: |
            sudo apt-get install \
                gcc-arm-linux-gnueabihf \
-                binutils-arm-none-eabi \
                libc6-dev-armel-cross \
                gcc-aarch64-linux-gnu \
                libc6-dev-arm64-cross \
@@ -149,7 +199,11 @@ 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:
          keys:
            - go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
@@ -157,17 +211,14 @@ commands:
      - llvm-source-linux
      - restore_cache:
          keys:
-            - llvm-build-9-linux-v0
+            - llvm-build-11-linux-v1-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
@@ -175,24 +226,32 @@ commands:
              make llvm-build
            fi
      - save_cache:
-          key: llvm-build-9-linux-v0
+          key: llvm-build-11-linux-v1-noassert
          paths:
            llvm-build
+      - build-wasi-libc
      - run:
          name: "Test TinyGo"
          command: make test
+      - run:
+          name: "Install fpm"
+          command: |
+            sudo apt-get install ruby ruby-dev
+            sudo gem install --no-document fpm
      - run:
          name: "Build TinyGo release"
          command: |
-            make release -j3
+            make release deb -j3
            cp -p build/release.tar.gz /tmp/tinygo.linux-amd64.tar.gz
+            cp -p build/release.deb    /tmp/tinygo_amd64.deb
      - store_artifacts:
          path: /tmp/tinygo.linux-amd64.tar.gz
+      - store_artifacts:
+          path: /tmp/tinygo_amd64.deb
      - save_cache:
          key: go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
          paths:
            - ~/.cache/go-build
-            - ~/.cache/tinygo
            - /go/pkg/mod
      - run:
          name: "Extract release tarball"
@@ -209,27 +268,29 @@ commands:
      - run:
          name: "Install dependencies"
          command: |
-            curl https://dl.google.com/go/go1.13.darwin-amd64.tar.gz -o go1.13.darwin-amd64.tar.gz
-            sudo tar -C /usr/local -xzf go1.13.darwin-amd64.tar.gz
+            curl https://dl.google.com/go/go1.15.5.darwin-amd64.tar.gz -o go1.15.5.darwin-amd64.tar.gz
+            sudo tar -C /usr/local -xzf go1.15.5.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:
+          variant: "macos"
      - restore_cache:
          keys:
            - go-cache-macos-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
            - go-cache-macos-v2-{{ checksum "go.mod" }}
      - restore_cache:
          keys:
-            - llvm-source-9-macos-v0
+            - llvm-source-11-macos-v1
      - run:
          name: "Fetch LLVM source"
          command: make llvm-source
      - save_cache:
-          key: llvm-source-9-macos-v0
+          key: llvm-source-11-macos-v1
          paths:
            - llvm-project
      - restore_cache:
          keys:
-            - llvm-build-9-macos-v0
+            - llvm-build-11-macos-v1
      - run:
          name: "Build LLVM"
          command: |
@@ -241,9 +302,19 @@ commands:
              make llvm-build
            fi
      - save_cache:
-          key: llvm-build-9-macos-v0
+          key: llvm-build-11-macos-v1
          paths:
            llvm-build
+      - restore_cache:
+          keys:
+            - wasi-libc-sysroot-macos-v2
+      - run:
+          name: "Build wasi-libc"
+          command: make wasi-libc
+      - save_cache:
+          key: wasi-libc-sysroot-macos-v2
+          paths:
+            - lib/wasi-libc/sysroot
      - run:
          name: "Test TinyGo"
          command: make test
@@ -261,44 +332,52 @@ commands:
            tar -C /usr/local/opt -xf /tmp/tinygo.darwin-amd64.tar.gz
            ln -s /usr/local/opt/tinygo/bin/tinygo /usr/local/bin/tinygo
            tinygo version
-      - run:
-          name: "Download SiFive GNU toolchain"
-          command: |
-            curl -O https://static.dev.sifive.com/dev-tools/riscv64-unknown-elf-gcc-8.2.0-2019.05.3-x86_64-apple-darwin.tar.gz
-            sudo tar -C /usr/local --strip-components=1 -xf riscv64-unknown-elf-gcc-8.2.0-2019.05.3-x86_64-apple-darwin.tar.gz
      - run: make smoketest AVR=0
      - save_cache:
          key: go-cache-macos-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
          paths:
            - ~/.cache/go-build
-            - ~/.cache/tinygo
            - /go/pkg/mod

-
 jobs:
  test-llvm9-go111:
    docker:
-      - image: circleci/golang:1.11-stretch
+      - image: circleci/golang:1.11-buster
    steps:
-      - test-linux
-  test-llvm9-go112:
+      - test-linux:
+          llvm: "9"
+  test-llvm10-go112:
    docker:
-      - image: circleci/golang:1.12-stretch
+      - image: circleci/golang:1.12-buster
    steps:
-      - test-linux
-  test-llvm9-go113:
+      - test-linux:
+          llvm: "10"
+  test-llvm10-go113:
    docker:
-      - image: circleci/golang:1.13-stretch
+      - image: circleci/golang:1.13-buster
    steps:
-      - test-linux
+      - test-linux:
+          llvm: "10"
+  test-llvm10-go114:
+    docker:
+      - image: circleci/golang:1.14-buster
+    steps:
+      - test-linux:
+          llvm: "10"
+  test-llvm11-go115:
+    docker:
+      - image: circleci/golang:1.15-buster
+    steps:
+      - test-linux:
+          llvm: "11"
  assert-test-linux:
    docker:
-      - image: circleci/golang:1.13-stretch
+      - image: circleci/golang:1.14-stretch
    steps:
      - assert-test-linux
  build-linux:
    docker:
-      - image: circleci/golang:1.13-stretch
+      - image: circleci/golang:1.14-stretch
    steps:
      - build-linux
  build-macos:
@@ -309,13 +388,14 @@ jobs:



-
 workflows:
  test-all:
    jobs:
      - test-llvm9-go111
-      - test-llvm9-go112
-      - test-llvm9-go113
+      - test-llvm10-go112
+      - test-llvm10-go113
+      - test-llvm10-go114
+      - test-llvm11-go115
      - build-linux
      - build-macos
      - assert-test-linux
@@ -3,14 +3,19 @@ docs/_build
 src/device/avr/*.go
 src/device/avr/*.ld
 src/device/avr/*.s
+src/device/esp/*.go
 src/device/nrf/*.go
 src/device/nrf/*.s
+src/device/nxp/*.go
+src/device/nxp/*.s
 src/device/sam/*.go
 src/device/sam/*.s
 src/device/sifive/*.go
 src/device/sifive/*.s
 src/device/stm32/*.go
 src/device/stm32/*.s
+src/device/kendryte/*.go
+src/device/kendryte/*.s
 vendor
 llvm-build
 llvm-project
@@ -14,3 +14,9 @@
 	path = lib/compiler-rt
 	url = https://github.com/llvm-mirror/compiler-rt.git
 	branch = release_80
+[submodule "lib/wasi-libc"]
+	path = lib/wasi-libc
+	url = https://github.com/CraneStation/wasi-libc
+[submodule "lib/picolibc"]
+	path = lib/picolibc
+	url = https://github.com/keith-packard/picolibc.git
@@ -10,6 +10,14 @@ This guide describes how to statically link TinyGo against LLVM, libclang and
 lld so that the binary can be easily moved between systems. It also shows how to
 build a release tarball that includes this binary and all necessary extra files.

+**Note**: this documentation describes how to build a statically linked release
+tarball. If you want to develop TinyGo, you will probably want to follow a
+different guide:
+
+  * [Linux](https://tinygo.org/getting-started/linux/#source-install)
+  * [macOS](https://tinygo.org/getting-started/macos/#source-install)
+  * [Windows](https://tinygo.org/getting-started/windows/#source-install)
+
 ## Dependencies

 LLVM, Clang and LLD are quite light on dependencies, requiring only standard
@@ -84,6 +92,10 @@ Now that we have a working static build, it's time to make a release tarball:

    make release

+If you did not clone the repository with the `--recursive` option, you will get errors until you initialize the project submodules:
+
+    git submodule update --init
+
 The release tarball is stored in build/release.tar.gz, and can be extracted with
 the following command (for example in ~/lib):

@@ -1,3 +1,384 @@
+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
+---
+
+* **command-line**
+  - add cached GOROOT to info subcommand
+  - embed git-hash in tinygo-dev executable
+  - implement tinygo targets to list usable targets
+  - use simpler file copy instead of file renaming to avoid issues on nrf52840 UF2 bootloaders
+  - use ToSlash() to specify program path
+  - support flashing esp32/esp8266 directly from tinygo
+  - when flashing call PortReset only on other than openocd
+* **compiler**
+  - `compileopts`: add support for custom binary formats
+  - `compiler`: improve display of goroutine wrappers
+  - `interp`: don't panic in the Store method
+  - `interp`: replace some panics with error messages
+  - `interp`: show error line in first line of the traceback
+  - `loader`: be more robust when creating the cached GOROOT
+  - `loader`: rewrite/refactor much of the code to use go list directly
+  - `loader`: use ioutil.TempDir to create a temporary directory
+  - `stacksize`: deal with DW_CFA_advance_loc1
+* **standard library**
+  - `runtime`: use waitForEvents when appropriate
+* **wasm**
+  - `wasm`: Remove --no-threads from wasm-ld calls.
+  - `wasm`: update wasi-libc dependency
+* **targets**
+  - `arduino-mega2560`: fix flashing on Windows
+  - `arm`: automatically determine stack sizes
+  - `arm64`: make dynamic loader structs and constants private
+  - `avr`: configure emulator in board files
+  - `cortexm`: fix stack size calculation with interrupts
+  - `flash`: add openocd settings to atsamd21 / atsamd51
+  - `flash`: add openocd settings to nrf5
+  - `microbit`: reelboard: flash using OpenOCD when needed
+  - `nintendoswitch`: Add dynamic loader for runtime loading PIE sections
+  - `nintendoswitch`: fix import cycle on dynamic_arm64.go
+  - `nintendoswitch`: Fix invalid memory read / write in print calls
+  - `nintendoswitch`: simplified assembly code
+  - `nintendoswitch`: support outputting .nro files directly
+* **boards**
+  - `arduino-zero`: Adding support for the Arduino Zero (#1365)
+  - `atsamd2x`: fix BAUD value
+  - `atsamd5x`: fix BAUD value
+  - `bluepill`: Enable stm32's USART2 for the board and map it to UART1 tinygo's device
+  - `device/atsamd51x`: add all remaining bitfield values for PCHCTRLm Mapping
+  - `esp32`: add libgcc ROM functions to linker script
+  - `esp32`: add SPI support
+  - `esp32`: add support for basic GPIO
+  - `esp32`: add support for the Espressif ESP32 chip
+  - `esp32`: configure the I/O matrix for GPIO pins
+  - `esp32`: export machine.PortMask* for bitbanging implementations
+  - `esp8266`: add support for this chip
+  - `machine/atsamd51x,runtime/atsamd51x`: fixes needed for full support for all PWM pins. Also adds some useful constants to clarify peripheral clock usage
+  - `machine/itsybitsy-nrf52840`: add support for Adafruit Itsybitsy nrf52840 (#1243)
+  - `machine/stm32f4`: refactor common code and add new build tag stm32f4 (#1332)
+  - `nrf`: add SoftDevice support for the Circuit Playground Bluefruit
+  - `nrf`: call sd_app_evt_wait when the SoftDevice is enabled
+  - `nrf52840`: add build tags for SoftDevice support
+  - `nrf52840`: use higher priority for USB-CDC code
+  - `runtime/atsamd51x`: use PCHCTRL_GCLK_SERCOMX_SLOW for setting clocks on all SERCOM ports
+  - `stm32f405`: add basic UART handler
+  - `stm32f405`: add STM32F405 machine/runtime, and new board/target feather-stm32f405
+* **build**
+  - `all`: run test binaries in the correct directory
+  - `build`: Fix arch release job
+  - `ci`: run `tinygo test` for known-working packages
+  - `ci`: set git-fetch-depth to 1
+  - `docker`: fix the problem with the wasm build (#1357)
+  - `Makefile`: check whether submodules have been downloaded in some common cases
+* **docs**
+  - add ESP32, ESP8266, and Adafruit Feather STM32F405 to list of supported boards
+
+0.14.1
+---
+* **command-line**
+  - support for Go 1.15
+* **compiler**
+  - loader:  work around Windows symlink limitation
+
+0.14.0
+---
+* **command-line**
+  - fix `getDefaultPort()` on non-English Windows locales
+  - compileopts: improve error reporting of unsupported flags
+  - fix test subcommand
+  - use auto-retry to locate MSD for UF2 and HEX flashing
+  - fix touchSerialPortAt1200bps on Windows
+  - support package names with backslashes on Windows
+* **compiler**
+  - fix a few crashes due to named types
+  - add support for atomic operations
+  - move the channel blocked list onto the stack
+  - fix -gc=none
+  - fix named string to `[]byte` slice conversion
+  - implement func value and builtin defers
+  - add proper parameter names to runtime.initAll, to fix a panic
+  - builder: fix picolibc include path
+  - builder: use newer version of gohex
+  - builder: try to determine stack size information at compile time
+  - builder: remove -opt=0
+  - interp: fix sync/atomic.Value load/store methods
+  - loader: add Go module support
+  - transform: fix debug information in func lowering pass
+  - transform: do not special-case zero or one implementations of a method call
+  - transform: introduce check for method calls on nil interfaces
+  - transform: gc: track 0-index GEPs to fix miscompilation
+* **cgo**
+  - Add LDFlags support
+* **standard library**
+  - extend stdlib to allow import of more packages
+  - replace master/slave terminology with appropriate alternatives (MOSI->SDO
+    etc)
+  - `internal/bytealg`: reimplement bytealg in pure Go
+  - `internal/task`: fix nil panic in (*internal/task.Stack).Pop
+  - `os`: add Args and stub it with mock data
+  - `os`: implement virtual filesystem support
+  - `reflect`: add Cap and Len support for map and chan
+  - `runtime`: fix return address in scheduler on RISC-V
+  - `runtime`: avoid recursion in printuint64 function
+  - `runtime`: replace ReadRegister with AsmFull inline assembly
+  - `runtime`: fix compilation errors when using gc.extalloc
+  - `runtime`: add cap and len support for chans
+  - `runtime`: refactor time handling (improving accuracy)
+  - `runtime`: make channels work in interrupts
+  - `runtime/interrupt`: add cross-chip disable/restore interrupt support
+  - `sync`: implement `sync.Cond`
+  - `sync`: add WaitGroup
+* **targets**
+  - `arm`: allow nesting in DisableInterrupts and EnableInterrupts
+  - `arm`: make FPU configuraton consistent
+  - `arm`: do not mask fault handlers in critical sections
+  - `atmega2560`: fix pin mapping for pins D2, D5 and the L port
+  - `atsamd`: return an error when an incorrect PWM pin is used
+  - `atsamd`: add support for pin change interrupts
+  - `atsamd`: add DAC support
+  - `atsamd21`: add more ADC pins
+  - `atsamd51`: fix ROM / RAM size on atsamd51j20
+  - `atsamd51`: add more pins
+  - `atsamd51`: add more ADC pins
+  - `atsamd51`: add pin change interrupt settings
+  - `atsamd51`: extend pinPadMapping
+  - `arduino-nano33`: use (U)SB flag to ensure that device can be found when
+     not on default port
+  - `arduino-nano33`: remove (d)ebug flag to reduce console noise when flashing
+  - `avr`: use standard pin numbering
+  - `avr`: unify GPIO pin/port code
+  - `avr`: add support for PinInputPullup
+  - `avr`: work around codegen bug in LLVM 10
+  - `avr`: fix target triple
+  - `fe310`: remove extra println left in by mistake
+  - `feather-nrf52840`: add support for the Feather nRF52840
+  - `maixbit`: add board definition and dummy runtime
+  - `nintendoswitch`: Add experimental Nintendo Switch support without CRT
+  - `nrf`: expose the RAM base address
+  - `nrf`: add support for pin change interrupts
+  - `nrf`: add microbit-s110v8 target
+  - `nrf`: fix bug in SPI.Tx
+  - `nrf`: support debugging the PCA10056
+  - `pygamer`: add Adafruit PyGamer suport
+  - `riscv`: fix interrupt configuration bug
+  - `riscv`: disable linker relaxations during gp init
+  - `stm32f4disco`: add new target with ST-Link v2.1 debugger
+  - `teensy36`: add Teensy 3.6 support
+  - `wasm`: fix event handling
+  - `wasm`: add --no-demangle linker option
+  - `wioterminal`: add support for the Seeed Wio Terminal
+  - `xiao`: add support for the Seeed XIAO
+
+0.13.1
+---
+* **standard library**
+  - `runtime`: do not put scheduler and GC code in the same section
+  - `runtime`: copy stack scan assembly for GBA
+* **boards**
+  - `gameboy-advance`: always use ARM mode instead of Thumb mode
+
+
+0.13.0
+---
+* **command line**
+  - use `gdb-multiarch` for debugging Cortex-M chips
+  - support `tinygo run` with simavr
+  - support LLVM 10
+  - support Go 1.14
+  - retry 3 times when attempting to do a 1200-baud reset
+* **compiler**
+  - mark the `abort` function as noreturn
+  - fix deferred calls to exported functions
+  - add debug info for local variables
+  - check for channel size limit
+  - refactor coroutine lowering
+  - add `dereferenceable_or_null` attribute to pointer parameters
+  - do not perform nil checking when indexing slices and on `unsafe.Pointer`
+  - remove `runtime.isnil` hack
+  - use LLVM builtins for runtime `memcpy`/`memmove`/`memzero` functions
+  - implement spec-compliant shifts on negative/overflow
+  - support anonymous type asserts
+  - track pointer result of string concatenation for GC
+  - track PHI nodes for GC
+  - add debug info to goroutine start wrappers
+  - optimize comparing interface values against nil
+  - fix miscompilation when deferring an interface call
+  - builder: include picolibc for most baremetal targets
+  - builder: run tools (clang, lld) as separate processes
+  - builder: use `-fshort-enums` consistently
+  - interp: add support for constant type asserts
+  - interp: better support for interface operations
+  - interp: include backtrace with error
+  - transform: do not track const globals for GC
+  - transform: replace panics with source locations
+  - transform: fix error in interface lowering pass
+  - transform: make coroutine lowering deterministic
+  - transform: fix miscompilation in func lowering
+* **cgo**
+  - make `-I` and `-L` paths absolute
+* **standard library**
+  - `machine`: set the USB VID and PID to the manufacturer values
+  - `machine`: correct USB CDC composite descriptors
+  - `machine`: move `errors.New` calls to globals
+  - `runtime`: support operations on nil maps
+  - `runtime`: fix copy builtin return value on AVR
+  - `runtime`: refactor goroutines
+  - `runtime`: support `-scheduler=none` on most platforms
+  - `runtime`: run package initialization in the main goroutine
+  - `runtime`: export `malloc` / `free` for use from C
+  - `runtime`: add garbage collector that uses an external allocator
+  - `runtime`: scan callee-saved registers while marking the stack
+  - `runtime`: remove recursion from conservative GC
+  - `runtime`: fix blocking select on nil channel
+  - `runtime/volatile`: include `ReplaceBits` method
+  - `sync`: implement trivial `sync.Map`
+* **targets**
+  - `arm`: use `-fomit-frame-pointer`
+  - `atmega1284`: support this chip for testing purposes
+  - `atsamd51`: make QSPI available on all boards
+  - `atsamd51`: add support for ADC1
+  - `atsamd51`: use new interrupt registration in UART code
+  - `attiny`: clean up pin definitions
+  - `avr`: use the correct RAM start address
+  - `avr`: pass the correct `-mmcu` flag to the linker
+  - `avr`: add support for tasks scheduler (disabled by default)
+  - `avr`: fix linker problem with overlapping program/data areas
+  - `nrf`: fix typo in pin configuration options
+  - `nrf`: add lib/nrfx/mdk to include dirs
+  - `nrf52840`: implement USB-CDC
+  - `riscv`: implement VirtIO target and add RISC-V integration test
+  - `riscv`: add I2C support for the HiFive1 rev B board
+  - `stm32`: refactor GPIO pin handling
+  - `stm32`: refactor UART code
+  - `stm32f4`: add SPI
+  - `wasm`: support Go 1.14 (breaking previous versions)
+  - `wasm`: support `syscall/js.CopyBytesToJS`
+  - `wasm`: sync polyfills from Go 1.14.
+* **boards**
+  - `arduino-mega2560`: add the Arduino Mega 2560
+  - `clue-alpha`: add the Adafruit CLUE Alpha
+  - `gameboy-advance`: enable debugging with GDB
+  - `particle-argon`: add the Particle Argon board
+  - `particle-boron`: add the Particle Boron board
+  - `particle-xenon`: add the Particle Xenon board
+  - `reelboard`: add `reelboard-s140v7` SoftDevice target
+
+0.12.0
+---
+* **command line**
+  - add initial FreeBSD support
+  - remove getting a serial port in gdb subcommand
+  - add support for debugging through JLinkGDBServer
+  - fix CGo when cross compiling
+  - remove default port check for Digispark as micronucleus communicates directly using HID
+  - differentiate between various serial/USB error messages
+* **builder**
+  - improve detection of Clang headers
+* **compiler**
+  - fix assertion on empty interface
+  - don't crash when encountering `types.Invalid`
+  - revise defer to use heap allocations when running a variable number of times
+  - improve error messages for failed imports
+  - improve "function redeclared" error
+  - add globaldce pass to start of optimization pipeline
+  - add support for debugging globals
+  - implement RISC-V CSR operations as intrinsics
+  - add support for CGO_ENABLED environment variable
+  - do not emit debug info for extern globals (bugfix)
+  - add support for interrupts
+  - implement maps for arbitrary keys
+  - interp: error location for "unknown GEP" error
+  - wasm-abi: create temporary allocas in the entry block
+* **cgo**
+  - add support for symbols in `#define`
+  - fix a bug in number tokenization
+* **standard library**
+  - `machine`: avoid bytes package in USB logic
+  - `runtime`: fix external address declarations
+  - `runtime`: provide implementation for `internal/bytealg.IndexByte`
+* **targets**
+  - `atsamd51`: fix volatile usage
+  - `atsamd51`: fix ADC, updating to 12-bits precision
+  - `atsamd51`: refactor SPI pin configuration to only look at pin numbers
+  - `atsamd51`: switch UART to use new pin configuration
+  - `atsamd51`: fix obvious bug in I2C code
+  - `atsamd51`: use only the necessary UART interrupts
+  - `atsamd51`: refactor I2C pin handling to auto-detect pin mode
+  - `avr`: use a garbage collector
+  - `fe310`: use CLINT peripheral for timekeeping
+  - `fe310`: add support for PLIC interrupts
+  - `fe310`: implement UART receive interrupts
+  - `riscv`: support sleeping in QEMU
+  - `riscv`: add bare-bones interrupt support
+  - `riscv`: print exception PC and code
+  - `wasm`: implement memcpy and memset
+  - `wasm`: include wasi-libc
+  - `wasm`: use wasi ABI for basic startup/stdout
+* **boards**
+  - `arduino`: make avrdude command line compatible with Windows
+  - `arduino-nano`: add this board
+  - `arduino-nano33`: fix UART1 and UART2
+  - `circuitplay-bluefruit`: add this board
+  - `digispark`: add clock speed and pin mappings
+  - `gameboy-advance`: include compiler-rt in build
+  - `gameboy-advance`: implement interrupt handler
+  - `hifive1b`: add support for gdb subcommand
+  - `pyportal`: add this board
+  - `pyportal`: remove manual SPI pin mapping as now handled by default
+
+
 0.11.0
 ---
 * **command line**
@@ -32,7 +32,7 @@ Microcontrollers have lots of peripherals (I2C, SPI, ADC, etc.) and many don't h

 ## How to use our Github repository

-The `master` branch of this repo will always have the latest released version of TinyGo. All of the active development work for the next release will take place in the `dev` branch. TinyGo will use semantic versioning and will create a tag/release for each release.
+The `release` branch of this repo will always have the latest released version of TinyGo. All of the active development work for the next release will take place in the `dev` branch. TinyGo will use semantic versioning and will create a tag/release for each release.

 Here is how to contribute back some code or documentation:

@@ -15,3 +15,4 @@ Ayke van Laethem <aykevanlaethem@gmail.com>
 Daniel Esteban <conejo@conejo.me>
 Loon, LLC.
 Ron Evans <ron@hybridgroup.com>
+Nia Weiss <niaow1234@gmail.com>
@@ -1,10 +1,10 @@
-# TinyGo base stage installs Go 1.13, LLVM 9 and the TinyGo compiler itself.
-FROM golang:1.13 AS tinygo-base
+# TinyGo base stage installs the most recent Go 1.15.x, LLVM 10 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-9 main" >> /etc/apt/sources.list && \
+    echo "deb http://apt.llvm.org/buster/ llvm-toolchain-buster-10 main" >> /etc/apt/sources.list && \
    apt-get update && \
-    apt-get install -y llvm-9-dev libclang-9-dev git
+    apt-get install -y llvm-10-dev libclang-10-dev lld-10 git

 COPY . /tinygo

@@ -12,8 +12,11 @@ COPY . /tinygo
 # after copying the tinygo directory in the previous step.
 RUN cd /tinygo/ && \
    rm -rf ./lib/* && \
+    git submodule sync && \
    git submodule update --init --recursive --force

+COPY ./lib/picolibc-include/* /tinygo/lib/picolibc-include/
+
 RUN cd /tinygo/ && \
    go install /tinygo/

@@ -24,10 +27,10 @@ COPY --from=tinygo-base /go/bin/tinygo /go/bin/tinygo
 COPY --from=tinygo-base /tinygo/src /tinygo/src
 COPY --from=tinygo-base /tinygo/targets /tinygo/targets

-RUN wget -O- https://apt.llvm.org/llvm-snapshot.gpg.key| apt-key add - && \
-    echo "deb http://apt.llvm.org/buster/ llvm-toolchain-buster-9 main" >> /etc/apt/sources.list && \
+RUN cd /tinygo/ && \
    apt-get update && \
-    apt-get install -y libllvm9 lld-9
+    apt-get install -y make clang-10 libllvm10 lld-10 && \
+    make wasi-libc

 # tinygo-avr stage installs the needed dependencies to compile TinyGo programs for AVR microcontrollers.
 FROM tinygo-base AS tinygo-avr
@@ -58,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-9 && \
+    apt-get install -y apt-utils make clang-10 && \
    make gen-device-nrf && make gen-device-stm32

 # tinygo-all stage installs the needed dependencies to compile TinyGo programs for all platforms.
@@ -70,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-9 binutils-avr gcc-avr avr-libc && \
+    apt-get install -y apt-utils make clang-10 binutils-avr gcc-avr avr-libc && \
    make gen-device

 CMD ["tinygo"]
@@ -1,7 +1,7 @@
-Copyright (c) 2018-2019 TinyGo Authors. All rights reserved.
+Copyright (c) 2018-2020 TinyGo Authors. All rights reserved.

 TinyGo includes portions of the Go standard library.
-Copyright (c) 2009-2019 The Go Authors. All rights reserved.
+Copyright (c) 2009-2020 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.
@@ -4,8 +4,15 @@ all: tinygo

 # Default build and source directories, as created by `make llvm-build`.
 LLVM_BUILDDIR ?= llvm-build
-CLANG_SRC ?= llvm-project/clang
-LLD_SRC ?= llvm-project/lld
+LLVM_PROJECTDIR ?= llvm-project
+CLANG_SRC ?= $(LLVM_PROJECTDIR)/clang
+LLD_SRC ?= $(LLVM_PROJECTDIR)/lld
+
+# Try to autodetect LLVM build tools.
+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
@@ -15,10 +22,10 @@ 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 which ccache))
+ifneq (, $(shell command -v ccache 2> /dev/null))
    LLVM_OPTION += '-DLLVM_CCACHE_BUILD=ON'
 endif

@@ -29,9 +36,9 @@ else
    LLVM_OPTION += '-DLLVM_ENABLE_ASSERTIONS=OFF'
 endif

-.PHONY: all tinygo test $(LLVM_BUILDDIR) llvm-source clean fmt gen-device gen-device-nrf gen-device-avr
+.PHONY: all tinygo test $(LLVM_BUILDDIR) llvm-source clean fmt gen-device gen-device-nrf gen-device-nxp gen-device-avr

-LLVM_COMPONENTS = all-targets analysis asmparser asmprinter bitreader bitwriter codegen core coroutines coverage debuginfodwarf executionengine instrumentation interpreter ipo irreader linker lto mc mcjit objcarcopts option profiledata scalaropts support target
+LLVM_COMPONENTS = all-targets analysis asmparser asmprinter bitreader bitwriter codegen core coroutines coverage debuginfodwarf executionengine frontendopenmp instrumentation interpreter ipo irreader linker lto mc mcjit objcarcopts option profiledata scalaropts support target

 ifeq ($(OS),Windows_NT)
    EXE = .exe
@@ -41,23 +48,13 @@ 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_PATH = $(abspath $(LLVM_BUILDDIR))/lib/liblibclang.a

 else ifeq ($(shell uname -s),Darwin)
    MD5SUM = md5
@@ -80,9 +77,9 @@ LLD_LIBS = $(START_GROUP) -llldCOFF -llldCommon -llldCore -llldDriver -llldELF -

 # 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_CXXFLAGS=-std=c++11
-    CGO_LDFLAGS+=$(LIBCLANG_PATH) -std=c++11 -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_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) -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


@@ -96,9 +93,10 @@ fmt-check:
 	@unformatted=$$(gofmt -l $(FMT_PATHS)); [ -z "$$unformatted" ] && exit 0; echo "Unformatted:"; for fn in $$unformatted; do echo "  $$fn"; done; exit 1


-gen-device: gen-device-avr gen-device-nrf gen-device-sam gen-device-sifive gen-device-stm32
+gen-device: gen-device-avr gen-device-esp gen-device-nrf gen-device-sam gen-device-sifive gen-device-stm32 gen-device-kendryte gen-device-nxp

 gen-device-avr:
+	@if [ ! -e lib/avr/README.md ]; then echo "Submodules have not been downloaded. Please download them using:\n  git submodule update --init"; exit 1; fi
 	$(GO) build -o ./build/gen-device-avr ./tools/gen-device-avr/
 	./build/gen-device-avr lib/avr/packs/atmega src/device/avr/
 	./build/gen-device-avr lib/avr/packs/tiny src/device/avr/
@@ -107,53 +105,90 @@ gen-device-avr:
 build/gen-device-svd: ./tools/gen-device-svd/*.go
 	$(GO) build -o $@ ./tools/gen-device-svd/

+gen-device-esp: build/gen-device-svd
+	./build/gen-device-svd -source=https://github.com/posborne/cmsis-svd/tree/master/data/Espressif-Community -interrupts=software lib/cmsis-svd/data/Espressif-Community/ src/device/esp/
+	GO111MODULE=off $(GO) fmt ./src/device/esp
+
 gen-device-nrf: build/gen-device-svd
 	./build/gen-device-svd -source=https://github.com/NordicSemiconductor/nrfx/tree/master/mdk lib/nrfx/mdk/ src/device/nrf/
 	GO111MODULE=off $(GO) fmt ./src/device/nrf

+gen-device-nxp: build/gen-device-svd
+	./build/gen-device-svd -source=https://github.com/posborne/cmsis-svd/tree/master/data/NXP lib/cmsis-svd/data/NXP/ src/device/nxp/
+	GO111MODULE=off $(GO) fmt ./src/device/nxp
+
 gen-device-sam: build/gen-device-svd
 	./build/gen-device-svd -source=https://github.com/posborne/cmsis-svd/tree/master/data/Atmel lib/cmsis-svd/data/Atmel/ src/device/sam/
 	GO111MODULE=off $(GO) fmt ./src/device/sam

 gen-device-sifive: build/gen-device-svd
-	./build/gen-device-svd -source=https://github.com/posborne/cmsis-svd/tree/master/data/SiFive-Community lib/cmsis-svd/data/SiFive-Community/ src/device/sifive/
+	./build/gen-device-svd -source=https://github.com/posborne/cmsis-svd/tree/master/data/SiFive-Community -interrupts=software lib/cmsis-svd/data/SiFive-Community/ src/device/sifive/
 	GO111MODULE=off $(GO) fmt ./src/device/sifive

+gen-device-kendryte: build/gen-device-svd
+	./build/gen-device-svd -source=https://github.com/posborne/cmsis-svd/tree/master/data/Kendryte-Community -interrupts=software lib/cmsis-svd/data/Kendryte-Community/ src/device/kendryte/
+	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/
 	GO111MODULE=off $(GO) fmt ./src/device/stm32


 # Get LLVM sources.
-llvm-project/README.md:
-	git clone -b release/9.x https://github.com/llvm/llvm-project
-llvm-source: llvm-project/README.md
+$(LLVM_PROJECTDIR)/README.md:
+	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-project/llvm "-DLLVM_TARGETS_TO_BUILD=X86;ARM;AArch64;RISCV;WebAssembly" "-DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=AVR" -DCMAKE_BUILD_TYPE=Release -DLIBCLANG_BUILD_STATIC=ON -DLLVM_ENABLE_TERMINFO=OFF -DLLVM_ENABLE_ZLIB=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_PROJECTS="clang;lld" -DLLVM_TOOL_CLANG_TOOLS_EXTRA_BUILD=OFF $(LLVM_OPTION)

 # Build LLVM.
 $(LLVM_BUILDDIR): $(LLVM_BUILDDIR)/build.ninja
 	cd $(LLVM_BUILDDIR); ninja


+# Build wasi-libc sysroot
+.PHONY: wasi-libc
+wasi-libc: lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a
+lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a:
+	@if [ ! -e lib/wasi-libc/Makefile ]; then echo "Submodules have not been downloaded. Please download them using:\n  git submodule update --init"; exit 1; fi
+	cd lib/wasi-libc && make -j4 WASM_CC=$(CLANG) WASM_AR=$(LLVM_AR) WASM_NM=$(LLVM_NM)
+
+
 # Build the Go compiler.
 tinygo:
 	@if [ ! -f "$(LLVM_BUILDDIR)/bin/llvm-config" ]; then echo "Fetch and build LLVM first by running:"; echo "  make llvm-source"; echo "  make $(LLVM_BUILDDIR)"; exit 1; fi
-	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) build -o build/tinygo$(EXE) -tags byollvm .
+	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:
-	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test -v -tags byollvm ./cgo ./compileopts ./interp ./transform .
+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 .

+# 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:
-	cd tests/tinygotest && 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:
 	$(TINYGO) version
-	# test all examples
+	# test all examples (except pwm)
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/adc
@@ -174,7 +209,7 @@ 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=pca10040            examples/pwm
+	$(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
 	@$(MD5SUM) test.hex
@@ -200,6 +235,8 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=microbit            examples/echo
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=microbit-s110v8     examples/echo
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=nrf52840-mdk        examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10031            examples/blinky1
@@ -226,8 +263,16 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=stm32f4disco        examples/blinky2
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=stm32f4disco-1      examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=feather-stm32f405   examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=circuitplay-bluefruit examples/blinky1
+	@$(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
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.gba -target=gameboy-advance     examples/gba-display
 	@$(MD5SUM) test.gba
 	$(TINYGO) build -size short -o test.hex -target=itsybitsy-m4        examples/blinky1
@@ -238,6 +283,14 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=metro-m4-airlift    examples/blinky1
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=pyportal            examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=particle-argon      examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=particle-boron      examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=particle-xenon      examples/blinky1
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=nucleo-f103rb       examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pinetime-devkit0    examples/blinky1
@@ -246,23 +299,88 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10056-s140v7     examples/blinky1
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=reelboard-s140v7    examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=wioterminal         examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=pygamer             examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=xiao                examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=circuitplay-express examples/dac
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=pyportal            examples/dac
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=feather-nrf52840  	examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=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
+	# test pwm
+	$(TINYGO) build -size short -o test.hex -target=itsybitsy-m0        examples/pwm
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=itsybitsy-m4        examples/pwm
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=feather-m4          examples/pwm
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=pyportal            examples/pwm
+	@$(MD5SUM) test.hex
 ifneq ($(AVR), 0)
+	$(TINYGO) build -size short -o test.hex -target=atmega1284p         examples/serial
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=arduino             examples/blinky1
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=arduino             examples/pwm
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=arduino -scheduler=tasks  examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=arduino-nano        examples/blinky1
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=digispark           examples/blinky1
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=digispark -gc=leaking examples/blinky1
+	@$(MD5SUM) test.hex
+endif
+ifneq ($(XTENSA), 0)
+	$(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
 	$(TINYGO) build             -o wasm.wasm -target=wasm               examples/wasm/main
+	# test various compiler flags
+	$(TINYGO) build -size short -o test.hex -target=pca10040 -gc=none -scheduler=none examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=pca10040 -opt=1     examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build             -o test.nro -target=nintendoswitch      examples/serial
+	@$(MD5SUM) test.nro

-release: tinygo gen-device
+wasmtest:
+	$(GO) test ./tests/wasm
+
+build/release: tinygo gen-device wasi-libc
 	@mkdir -p build/release/tinygo/bin
 	@mkdir -p build/release/tinygo/lib/clang/include
 	@mkdir -p build/release/tinygo/lib/CMSIS/CMSIS
 	@mkdir -p build/release/tinygo/lib/compiler-rt/lib
 	@mkdir -p build/release/tinygo/lib/nrfx
+	@mkdir -p build/release/tinygo/lib/picolibc/newlib/libc
+	@mkdir -p build/release/tinygo/lib/wasi-libc
 	@mkdir -p build/release/tinygo/pkg/armv6m-none-eabi
 	@mkdir -p build/release/tinygo/pkg/armv7m-none-eabi
 	@mkdir -p build/release/tinygo/pkg/armv7em-none-eabi
@@ -275,9 +393,28 @@ release: tinygo gen-device
 	@cp -rp lib/compiler-rt/LICENSE.TXT  build/release/tinygo/lib/compiler-rt
 	@cp -rp lib/compiler-rt/README.txt   build/release/tinygo/lib/compiler-rt
 	@cp -rp lib/nrfx/*                   build/release/tinygo/lib/nrfx
+	@cp -rp lib/picolibc/newlib/libc/ctype       build/release/tinygo/lib/picolibc/newlib/libc
+	@cp -rp lib/picolibc/newlib/libc/include     build/release/tinygo/lib/picolibc/newlib/libc
+	@cp -rp lib/picolibc/newlib/libc/locale      build/release/tinygo/lib/picolibc/newlib/libc
+	@cp -rp lib/picolibc/newlib/libc/string      build/release/tinygo/lib/picolibc/newlib/libc
+	@cp -rp lib/picolibc/newlib/libc/tinystdio   build/release/tinygo/lib/picolibc/newlib/libc
+	@cp -rp lib/picolibc-include         build/release/tinygo/lib
+	@cp -rp lib/wasi-libc/sysroot        build/release/tinygo/lib/wasi-libc/sysroot
 	@cp -rp src                          build/release/tinygo/src
 	@cp -rp targets                      build/release/tinygo/targets
-	./build/tinygo build-builtins -target=armv6m-none-eabi  -o build/release/tinygo/pkg/armv6m-none-eabi/compiler-rt.a
-	./build/tinygo build-builtins -target=armv7m-none-eabi  -o build/release/tinygo/pkg/armv7m-none-eabi/compiler-rt.a
-	./build/tinygo build-builtins -target=armv7em-none-eabi -o build/release/tinygo/pkg/armv7em-none-eabi/compiler-rt.a
+	./build/tinygo build-library -target=armv6m-none-eabi  -o build/release/tinygo/pkg/armv6m-none-eabi/compiler-rt.a compiler-rt
+	./build/tinygo build-library -target=armv7m-none-eabi  -o build/release/tinygo/pkg/armv7m-none-eabi/compiler-rt.a compiler-rt
+	./build/tinygo build-library -target=armv7em-none-eabi -o build/release/tinygo/pkg/armv7em-none-eabi/compiler-rt.a compiler-rt
+	./build/tinygo build-library -target=armv6m-none-eabi  -o build/release/tinygo/pkg/armv6m-none-eabi/picolibc.a picolibc
+	./build/tinygo build-library -target=armv7m-none-eabi  -o build/release/tinygo/pkg/armv7m-none-eabi/picolibc.a picolibc
+	./build/tinygo build-library -target=armv7em-none-eabi -o build/release/tinygo/pkg/armv7em-none-eabi/picolibc.a picolibc
+
+release: build/release
 	tar -czf build/release.tar.gz -C build/release tinygo
+
+deb: build/release
+	@mkdir -p build/release-deb/usr/local/bin
+	@mkdir -p build/release-deb/usr/local/lib
+	cp -ar build/release/tinygo build/release-deb/usr/local/lib/tinygo
+	ln -sf ../lib/tinygo/bin/tinygo build/release-deb/usr/local/bin/tinygo
+	fpm -f -s dir -t deb -n tinygo -v $(shell grep "const Version = " goenv/version.go | awk '{print $$NF}') -m '@tinygo-org' --description='TinyGo is a Go compiler for small places.' --license='BSD 3-Clause' --url=https://tinygo.org/ --deb-changelog CHANGELOG.md -p build/release.deb -C ./build/release-deb
@@ -43,27 +43,47 @@ See the [getting started instructions](https://tinygo.org/getting-started/) for

 You can compile TinyGo programs for microcontrollers, WebAssembly and Linux.

-The following 22 microcontroller boards are currently supported:
+The following 44 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 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)
+* [Adafruit Feather STM32F405 Express](https://www.adafruit.com/product/4382)
 * [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 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 Trinket M0](https://www.adafruit.com/product/3500)
+* [Arduino Mega 2560](https://store.arduino.cc/arduino-mega-2560-rev3)
+* [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/)
 * [Digispark](http://digistump.com/products/1)
+* [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/)
+* [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)
 * [Nordic Semiconductor PCA10056](https://www.nordicsemi.com/Software-and-Tools/Development-Kits/nRF52840-DK)
+* [Particle Argon](https://docs.particle.io/datasheets/wi-fi/argon-datasheet/)
+* [Particle Boron](https://docs.particle.io/datasheets/cellular/boron-datasheet/)
+* [Particle Xenon](https://docs.particle.io/datasheets/discontinued/xenon-datasheet/)
 * [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)
+* [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)
@@ -128,4 +148,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/9.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.
@@ -1,7 +1,7 @@
 # Avoid lengthy LLVM rebuilds on each newly pushed branch. Pull requests will
 # be built anyway.
 trigger:
- master
+- release
 - dev

 jobs:
@@ -10,21 +10,29 @@ jobs:
  pool:
    vmImage: 'VS2017-Win2016'
  steps:
+    - task: GoTool@0
+      inputs:
+        version: '1.15'
    - checkout: self
-    - task: CacheBeta@0
+      fetchDepth: 1
+    - task: Cache@2
      displayName: Cache LLVM source
      inputs:
-        key: llvm-source-9-windows-v0
+        key: llvm-source-11-windows-v1
        path: llvm-project
    - task: Bash@3
      displayName: Download LLVM source
      inputs:
        targetType: inline
-        script: make llvm-source
+        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
    - task: CacheBeta@0
      displayName: Cache LLVM build
      inputs:
-        key: llvm-build-9-windows-v0
+        key: llvm-build-11-windows-v3
        path: llvm-build
    - task: Bash@3
      displayName: Build LLVM
@@ -33,24 +41,34 @@ jobs:
        script: |
          if [ ! -f llvm-build/lib/liblldELF.a ]
          then
+            # install dependencies
            choco install ninja
-            # LLVM 9 cannot be built with MinGW 8.
-            # For details: https://reviews.llvm.org/D70266
-            choco uninstall mingw
-            choco install mingw --version=7.3.0
+            # 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
      displayName: Install QEMU
      inputs:
        targetType: inline
-        script: choco install qemu
+        script: choco install qemu --version=2020.06.12
+    - task: CacheBeta@0
+      displayName: Cache wasi-libc sysroot
+      inputs:
+        key: wasi-libc-sysroot-v3
+        path: lib/wasi-libc/sysroot
+    - task: Bash@3
+      displayName: Build wasi-libc
+      inputs:
+        targetType: inline
+        script: PATH=/usr/bin:$PATH make wasi-libc
    - task: Bash@3
      displayName: Test TinyGo
      inputs:
        targetType: inline
        script: |
-          export PATH="/c/Go1.13/bin:$PATH:./llvm-build/bin:/c/Program Files/qemu"
+          export PATH="$PATH:./llvm-build/bin:/c/Program Files/qemu"
          unset GOROOT
          make test
    - task: Bash@3
@@ -58,17 +76,17 @@ jobs:
      inputs:
        targetType: inline
        script: |
-          export PATH="/c/Go1.13/bin:$PATH:./llvm-build/bin:/c/Program Files/qemu"
+          export PATH="$PATH:./llvm-build/bin:/c/Program Files/qemu"
          unset GOROOT
-          make release -j4
-    - publish: $(System.DefaultWorkingDirectory)/build/release.tar.gz
-      displayName: Publish tarball as artifact
-      artifact: tinygo.windows-amd64.tar.gz
+          make build/release -j4
+    - publish: $(System.DefaultWorkingDirectory)/build/release/tinygo
+      displayName: Publish zip as artifact
+      artifact: tinygo
    - task: Bash@3
      displayName: Smoke tests
      inputs:
        targetType: inline
        script: |
-          export PATH="/c/Go1.13/bin:$PATH:./llvm-build/bin:/c/Program Files/qemu"
+          export PATH="$PATH:./llvm-build/bin:/c/Program Files/qemu"
          unset GOROOT
-          make smoketest TINYGO=build/tinygo AVR=0
+          make smoketest TINYGO=build/tinygo AVR=0 XTENSA=0
@@ -4,11 +4,14 @@
 package builder

 import (
+	"debug/elf"
+	"encoding/binary"
 	"errors"
 	"fmt"
 	"io/ioutil"
 	"os"
 	"path/filepath"
+	"sort"
 	"strconv"
 	"strings"

@@ -16,43 +19,59 @@ import (
 	"github.com/tinygo-org/tinygo/compiler"
 	"github.com/tinygo-org/tinygo/goenv"
 	"github.com/tinygo-org/tinygo/interp"
+	"github.com/tinygo-org/tinygo/stacksize"
+	"github.com/tinygo-org/tinygo/transform"
+	"tinygo.org/x/go-llvm"
 )

+// BuildResult is the output of a build. This includes the binary itself and
+// some other metadata that is obtained while building the binary.
+type BuildResult struct {
+	// A path to the output binary. It will be removed after Build returns, so
+	// if it should be kept it must be copied or moved away.
+	Binary string
+
+	// The directory of the main package. This is useful for testing as the test
+	// binary must be run in the directory of the tested package.
+	MainDir string
+}
+
 // Build performs a single package to executable Go build. It takes in a package
 // name, an output path, and set of compile options and from that it manages the
 // whole compilation process.
 //
 // 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(string) error) error {
-	c, err := compiler.NewCompiler(pkgName, config)
+func Build(pkgName, outpath string, config *compileopts.Config, action func(BuildResult) error) error {
+	// Compile Go code to IR.
+	machine, err := compiler.NewTargetMachine(config)
 	if err != nil {
 		return err
 	}
-
-	// Compile Go code to IR.
-	errs := c.Compile(pkgName)
-	if len(errs) != 0 {
+	buildOutput, errs := compiler.Compile(pkgName, machine, config)
+	if errs != nil {
 		return newMultiError(errs)
 	}
+	mod := buildOutput.Mod
+
 	if config.Options.PrintIR {
 		fmt.Println("; Generated LLVM IR:")
-		fmt.Println(c.IR())
+		fmt.Println(mod.String())
 	}
-	if err := c.Verify(); err != nil {
+	if err := llvm.VerifyModule(mod, llvm.PrintMessageAction); err != nil {
 		return errors.New("verification error after IR construction")
 	}

-	err = interp.Run(c.Module(), config.DumpSSA())
+	err = interp.Run(mod, config.DumpSSA())
 	if err != nil {
 		return err
 	}
-	if err := c.Verify(); err != nil {
+	if err := llvm.VerifyModule(mod, llvm.PrintMessageAction); err != nil {
 		return errors.New("verification error after interpreting runtime.initAll")
 	}

 	if config.GOOS() != "darwin" {
-		c.ApplyFunctionSections() // -ffunction-sections
+		transform.ApplyFunctionSections(mod) // -ffunction-sections
 	}

 	// Browsers cannot handle external functions that have type i64 because it
@@ -60,8 +79,8 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(stri
 	// 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") {
-		err := c.ExternalInt64AsPtr()
+	if config.WasmAbi() == "js" {
+		err := transform.ExternalInt64AsPtr(mod)
 		if err != nil {
 			return err
 		}
@@ -71,47 +90,66 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(stri
 	// exactly.
 	errs = nil
 	switch config.Options.Opt {
-	case "none:", "0":
-		errs = c.Optimize(0, 0, 0) // -O0
+	/*
+		Currently, turning optimizations off causes compile failures.
+		We rely on the optimizer removing some dead symbols.
+		Avoid providing an option that does not work right now.
+		In the future once everything has been fixed we can re-enable this.
+
+		case "none", "0":
+			errs = transform.Optimize(mod, config, 0, 0, 0) // -O0
+	*/
 	case "1":
-		errs = c.Optimize(1, 0, 0) // -O1
+		errs = transform.Optimize(mod, config, 1, 0, 0) // -O1
 	case "2":
-		errs = c.Optimize(2, 0, 225) // -O2
+		errs = transform.Optimize(mod, config, 2, 0, 225) // -O2
 	case "s":
-		errs = c.Optimize(2, 1, 225) // -Os
+		errs = transform.Optimize(mod, config, 2, 1, 225) // -Os
 	case "z":
-		errs = c.Optimize(2, 2, 5) // -Oz, default
+		errs = transform.Optimize(mod, config, 2, 2, 5) // -Oz, default
 	default:
 		errs = []error{errors.New("unknown optimization level: -opt=" + config.Options.Opt)}
 	}
 	if len(errs) > 0 {
 		return newMultiError(errs)
 	}
-	if err := c.Verify(); err != nil {
+	if err := llvm.VerifyModule(mod, llvm.PrintMessageAction); err != nil {
 		return 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") {
-		c.NonConstGlobals()
-		if err := c.Verify(); 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":
-		return c.EmitObject(outpath)
+		llvmBuf, err := machine.EmitToMemoryBuffer(mod, llvm.ObjectFile)
+		if err != nil {
+			return err
+		}
+		return ioutil.WriteFile(outpath, llvmBuf.Bytes(), 0666)
 	case ".bc":
-		return c.EmitBitcode(outpath)
+		data := llvm.WriteBitcodeToMemoryBuffer(mod).Bytes()
+		return ioutil.WriteFile(outpath, data, 0666)
 	case ".ll":
-		return c.EmitText(outpath)
+		data := []byte(mod.String())
+		return ioutil.WriteFile(outpath, data, 0666)
 	default:
 		// Act as a compiler driver.

@@ -124,29 +162,39 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(stri

 		// Write the object file.
 		objfile := filepath.Join(dir, "main.o")
-		err = c.EmitObject(objfile)
+		llvmBuf, err := machine.EmitToMemoryBuffer(mod, llvm.ObjectFile)
 		if err != nil {
 			return err
 		}
-
-		// Load builtins library from the cache, possibly compiling it on the
-		// fly.
-		var librt string
-		if config.Target.RTLib == "compiler-rt" {
-			librt, err = loadBuiltins(config.Triple())
-			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() {
@@ -160,16 +208,17 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(stri
 		}

 		// Compile C files in packages.
-		for i, pkg := range c.Packages() {
-			for _, file := range pkg.CFiles {
-				path := filepath.Join(pkg.Package.Dir, file)
-				outpath := filepath.Join(dir, "pkg"+strconv.Itoa(i)+"-"+file+".o")
-				err := runCCompiler(config.Target.Compiler, append(config.CFlags(), "-c", "-o", outpath, path)...)
-				if err != nil {
-					return &commandError{"failed to build", path, err}
-				}
-				ldflags = append(ldflags, outpath)
+		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.
@@ -178,6 +227,26 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(stri
 			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 {
@@ -197,21 +266,278 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(stri
 			}
 		}

+		// 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.
-		if outext == ".hex" || outext == ".bin" || outext == ".gba" {
+		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)
+			err := objcopy(executable, tmppath, outputBinaryFormat)
 			if err != nil {
 				return err
 			}
-		} else if outext == ".uf2" {
+		case "uf2":
 			// Get UF2 from the .elf file.
 			tmppath = filepath.Join(dir, "main"+outext)
-			err := convertELFFileToUF2File(executable, tmppath)
+			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,
+		})
+	}
+}
+
+// functionStackSizes keeps stack size information about a single function
+// (usually a goroutine).
+type functionStackSize struct {
+	humanName        string
+	stackSize        uint64
+	stackSizeType    stacksize.SizeType
+	missingStackSize *stacksize.CallNode
+}
+
+// determineStackSizes tries to determine the stack sizes of all started
+// goroutines and of the reset vector. The LLVM module is necessary to find
+// functions that call a function pointer.
+func determineStackSizes(mod llvm.Module, executable string) ([]string, map[string]functionStackSize, error) {
+	var callsIndirectFunction []string
+	gowrappers := []string{}
+	gowrapperNames := make(map[string]string)
+	for fn := mod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
+		// Determine which functions call a function pointer.
+		for bb := fn.FirstBasicBlock(); !bb.IsNil(); bb = llvm.NextBasicBlock(bb) {
+			for inst := bb.FirstInstruction(); !inst.IsNil(); inst = llvm.NextInstruction(inst) {
+				if inst.IsACallInst().IsNil() {
+					continue
+				}
+				if callee := inst.CalledValue(); callee.IsAFunction().IsNil() && callee.IsAInlineAsm().IsNil() {
+					callsIndirectFunction = append(callsIndirectFunction, fn.Name())
+				}
+			}
+		}
+
+		// Get a list of "go wrappers", small wrapper functions that decode
+		// parameters when starting a new goroutine.
+		attr := fn.GetStringAttributeAtIndex(-1, "tinygo-gowrapper")
+		if !attr.IsNil() {
+			gowrappers = append(gowrappers, fn.Name())
+			gowrapperNames[fn.Name()] = attr.GetStringValue()
+		}
+	}
+	sort.Strings(gowrappers)
+
+	// Load the ELF binary.
+	f, err := elf.Open(executable)
+	if err != nil {
+		return nil, nil, fmt.Errorf("could not load executable for stack size analysis: %w", err)
+	}
+	defer f.Close()
+
+	// Determine the frame size of each function (if available) and the callgraph.
+	functions, err := stacksize.CallGraph(f, callsIndirectFunction)
+	if err != nil {
+		return nil, nil, fmt.Errorf("could not parse executable for stack size analysis: %w", err)
+	}
+
+	// Goroutines need to be started and finished and take up some stack space
+	// that way. This can be measured by measuing the stack size of
+	// tinygo_startTask.
+	if numFuncs := len(functions["tinygo_startTask"]); numFuncs != 1 {
+		return nil, nil, fmt.Errorf("expected exactly one definition of tinygo_startTask, got %d", numFuncs)
+	}
+	baseStackSize, baseStackSizeType, baseStackSizeFailedAt := functions["tinygo_startTask"][0].StackSize()
+
+	sizes := make(map[string]functionStackSize)
+
+	// Add the reset handler function, for convenience. The reset handler runs
+	// startup code and the scheduler. The listed stack size is not the full
+	// stack size: interrupts are not counted.
+	var resetFunction string
+	switch f.Machine {
+	case elf.EM_ARM:
+		// Note: all interrupts happen on this stack so the real size is bigger.
+		resetFunction = "Reset_Handler"
+	}
+	if resetFunction != "" {
+		funcs := functions[resetFunction]
+		if len(funcs) != 1 {
+			return nil, nil, fmt.Errorf("expected exactly one definition of %s in the callgraph, found %d", resetFunction, len(funcs))
+		}
+		stackSize, stackSizeType, missingStackSize := funcs[0].StackSize()
+		sizes[resetFunction] = functionStackSize{
+			stackSize:        stackSize,
+			stackSizeType:    stackSizeType,
+			missingStackSize: missingStackSize,
+			humanName:        resetFunction,
+		}
+	}
+
+	// Add all goroutine wrapper functions.
+	for _, name := range gowrappers {
+		funcs := functions[name]
+		if len(funcs) != 1 {
+			return nil, nil, fmt.Errorf("expected exactly one definition of %s in the callgraph, found %d", name, len(funcs))
+		}
+		humanName := gowrapperNames[name]
+		if humanName == "" {
+			humanName = name // fallback
+		}
+		stackSize, stackSizeType, missingStackSize := funcs[0].StackSize()
+		if baseStackSizeType != stacksize.Bounded {
+			// It was not possible to determine the stack size at compile time
+			// because tinygo_startTask does not have a fixed stack size. This
+			// can happen when using -opt=1.
+			stackSizeType = baseStackSizeType
+			missingStackSize = baseStackSizeFailedAt
+		} else if stackSize < baseStackSize {
+			// This goroutine has a very small stack, but still needs to fit all
+			// registers to start and suspend the goroutine. Otherwise a stack
+			// overflow will occur even before the goroutine is started.
+			stackSize = baseStackSize
+		}
+		sizes[name] = functionStackSize{
+			stackSize:        stackSize,
+			stackSizeType:    stackSizeType,
+			missingStackSize: missingStackSize,
+			humanName:        humanName,
+		}
+	}
+
+	if resetFunction != "" {
+		return append([]string{resetFunction}, gowrappers...), sizes, nil
+	}
+	return gowrappers, sizes, nil
+}
+
+// modifyStackSizes modifies the .tinygo_stacksizes section with the updated
+// stack size information. Before this modification, all stack sizes in the
+// section assume the default stack size (which is relatively big).
+func modifyStackSizes(executable string, stackSizeLoads []string, stackSizes map[string]functionStackSize) error {
+	fp, err := os.OpenFile(executable, os.O_RDWR, 0)
+	if err != nil {
+		return err
+	}
+	defer fp.Close()
+
+	elfFile, err := elf.NewFile(fp)
+	if err != nil {
+		return err
+	}
+
+	section := elfFile.Section(".tinygo_stacksizes")
+	if section == nil {
+		return errors.New("could not find .tinygo_stacksizes section")
+	}
+
+	if section.Size != section.FileSize {
+		// Sanity check.
+		return fmt.Errorf("expected .tinygo_stacksizes to have identical size and file size, got %d and %d", section.Size, section.FileSize)
+	}
+
+	// Read all goroutine stack sizes.
+	data := make([]byte, section.Size)
+	_, err = fp.ReadAt(data, int64(section.Offset))
+	if err != nil {
+		return err
+	}
+
+	if len(stackSizeLoads)*4 != len(data) {
+		// Note: while AVR should use 2 byte stack sizes, even 64-bit platforms
+		// should probably stick to 4 byte stack sizes as a larger than 4GB
+		// stack doesn't make much sense.
+		return errors.New("expected 4 byte stack sizes")
+	}
+
+	// Modify goroutine stack sizes with a compile-time known worst case stack
+	// size.
+	for i, name := range stackSizeLoads {
+		fn, ok := stackSizes[name]
+		if !ok {
+			return fmt.Errorf("could not find symbol %s in ELF file", name)
+		}
+		if fn.stackSizeType == stacksize.Bounded {
+			stackSize := uint32(fn.stackSize)
+
+			// Adding 4 for the stack canary. Even though the size may be
+			// automatically determined, stack overflow checking is still
+			// important as the stack size cannot be determined for all
+			// goroutines.
+			stackSize += 4
+
+			// Add stack size used by interrupts.
+			switch elfFile.Machine {
+			case elf.EM_ARM:
+				// On Cortex-M (assumed here), this stack size is 8 words or 32
+				// bytes. This is only to store the registers that the interrupt
+				// may modify, the interrupt will switch to the interrupt stack
+				// (MSP).
+				// Some background:
+				// https://interrupt.memfault.com/blog/cortex-m-rtos-context-switching
+				stackSize += 32
+			}
+
+			// Finally write the stack size to the binary.
+			binary.LittleEndian.PutUint32(data[i*4:], stackSize)
+		}
+	}
+
+	// Write back the modified stack sizes.
+	_, err = fp.WriteAt(data, int64(section.Offset))
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// printStacks prints the maximum stack depth for functions that are started as
+// goroutines. Stack sizes cannot always be determined statically, in particular
+// recursive functions and functions that call interface methods or function
+// pointers may have an unknown stack depth (depending on what the optimizer
+// manages to optimize away).
+//
+// It might print something like the following:
+//
+//     function                         stack usage (in bytes)
+//     Reset_Handler                    316
+//     examples/blinky2.led1            92
+//     runtime.run$1                    300
+func printStacks(calculatedStacks []string, stackSizes map[string]functionStackSize) {
+	// Print the sizes of all stacks.
+	fmt.Printf("%-32s %s\n", "function", "stack usage (in bytes)")
+	for _, name := range calculatedStacks {
+		fn := stackSizes[name]
+		switch fn.stackSizeType {
+		case stacksize.Bounded:
+			fmt.Printf("%-32s %d\n", fn.humanName, fn.stackSize)
+		case stacksize.Unknown:
+			fmt.Printf("%-32s unknown, %s does not have stack frame information\n", fn.humanName, fn.missingStackSize)
+		case stacksize.Recursive:
+			fmt.Printf("%-32s recursive, %s may call itself\n", fn.humanName, fn.missingStackSize)
+		case stacksize.IndirectCall:
+			fmt.Printf("%-32s unknown, %s calls a function pointer\n", fn.humanName, fn.missingStackSize)
 		}
-		return action(tmppath)
 	}
 }
@@ -1,12 +1,7 @@
 package builder

 import (
-	"io/ioutil"
-	"os"
-	"path/filepath"
 	"strings"
-
-	"github.com/tinygo-org/tinygo/goenv"
 )

 // These are the GENERIC_SOURCES according to CMakeList.txt.
@@ -156,105 +151,20 @@ var aeabiBuiltins = []string{
 	"arm/aeabi_uldivmod.S",
 }

-func builtinFiles(target string) []string {
-	builtins := append([]string{}, genericBuiltins...) // copy genericBuiltins
-	if strings.HasPrefix(target, "arm") {
-		builtins = append(builtins, aeabiBuiltins...)
-	}
-	return builtins
-}
-
-// builtinsDir returns the directory where the sources for compiler-rt are kept.
-func builtinsDir() string {
-	return filepath.Join(goenv.Get("TINYGOROOT"), "lib", "compiler-rt", "lib", "builtins")
-}
-
-// Get the builtins archive, possibly generating it as needed.
-func loadBuiltins(target string) (path string, err error) {
-	// Try to load a precompiled compiler-rt library.
-	precompiledPath := filepath.Join(goenv.Get("TINYGOROOT"), "pkg", target, "compiler-rt.a")
-	if _, err := os.Stat(precompiledPath); err == nil {
-		// Found a precompiled compiler-rt for this OS/architecture. Return the
-		// path directly.
-		return precompiledPath, nil
-	}
-
-	outfile := "librt-" + target + ".a"
-	builtinsDir := builtinsDir()
-
-	builtins := builtinFiles(target)
-	srcs := make([]string, len(builtins))
-	for i, name := range builtins {
-		srcs[i] = filepath.Join(builtinsDir, name)
-	}
-
-	if path, err := cacheLoad(outfile, commands["clang"][0], srcs); path != "" || err != nil {
-		return path, err
-	}
-
-	var cachepath string
-	err = CompileBuiltins(target, func(path string) error {
-		path, err := cacheStore(path, outfile, commands["clang"][0], srcs)
-		cachepath = path
-		return err
-	})
-	return cachepath, err
-}
-
-// CompileBuiltins compiles builtins from compiler-rt into a static library.
-// When it succeeds, it will call the callback with the resulting path. The path
-// will be removed after callback returns. If callback returns an error, this is
-// passed through to the return value of this function.
-func CompileBuiltins(target string, callback func(path string) error) error {
-	builtinsDir := builtinsDir()
-
-	builtins := builtinFiles(target)
-	srcs := make([]string, len(builtins))
-	for i, name := range builtins {
-		srcs[i] = filepath.Join(builtinsDir, name)
-	}
-
-	dirPrefix := "tinygo-builtins"
-	remapDir := filepath.Join(os.TempDir(), dirPrefix)
-	dir, err := ioutil.TempDir(os.TempDir(), dirPrefix)
-	if err != nil {
-		return err
-	}
-	defer os.RemoveAll(dir)
-
-	// Compile all builtins.
-	// TODO: use builtins optimized for a given target if available.
-	objs := make([]string, 0, len(builtins))
-	for _, name := range builtins {
-		objname := name
-		if strings.LastIndexByte(objname, '/') >= 0 {
-			objname = objname[strings.LastIndexByte(objname, '/'):]
+// CompilerRT is a library with symbols required by programs compiled with LLVM.
+// These symbols are for operations that cannot be emitted with a single
+// instruction or a short sequence of instructions for that target.
+//
+// For more information, see: https://compiler-rt.llvm.org/
+var CompilerRT = Library{
+	name:      "compiler-rt",
+	cflags:    func() []string { return []string{"-Werror", "-Wall", "-std=c11", "-nostdlibinc"} },
+	sourceDir: "lib/compiler-rt/lib/builtins",
+	sources: func(target string) []string {
+		builtins := append([]string{}, genericBuiltins...) // copy genericBuiltins
+		if strings.HasPrefix(target, "arm") || strings.HasPrefix(target, "thumb") {
+			builtins = append(builtins, aeabiBuiltins...)
 		}
-		objpath := filepath.Join(dir, objname+".o")
-		objs = append(objs, objpath)
-		srcpath := filepath.Join(builtinsDir, name)
-		// 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 := []string{"-c", "-Oz", "-g", "-Werror", "-Wall", "-std=c11", "-fshort-enums", "-nostdlibinc", "-ffunction-sections", "-fdata-sections", "-Wno-macro-redefined", "--target=" + target, "-fdebug-prefix-map=" + dir + "=" + remapDir}
-		if strings.HasPrefix(target, "riscv32-") {
-			args = append(args, "-march=rv32imac", "-mabi=ilp32", "-fforce-enable-int128")
-		}
-		err := runCCompiler("clang", append(args, "-o", objpath, srcpath)...)
-		if err != nil {
-			return &commandError{"failed to build", srcpath, err}
-		}
-	}
-
-	// Put all the object files in a single archive. This archive file will be
-	// used to statically link compiler-rt.
-	arpath := filepath.Join(dir, "librt.a")
-	err = makeArchive(arpath, objs)
-	if err != nil {
-		return err
-	}
-
-	// Give the caller the resulting file. The callback must copy the file,
-	// because after it returns the temporary directory will be removed.
-	return callback(arpath)
+		return builtins
+	},
 }
@@ -48,6 +48,7 @@
 #include "llvm/Support/Host.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetRegistry.h"
@@ -70,12 +71,12 @@ bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
  bool Success = true;

  // Parse the arguments.
-  std::unique_ptr<OptTable> OptTbl(createDriverOptTable());
+  const OptTable &OptTbl = getDriverOptTable();

  const unsigned IncludedFlagsBitmask = options::CC1AsOption;
  unsigned MissingArgIndex, MissingArgCount;
-  InputArgList Args = OptTbl->ParseArgs(Argv, MissingArgIndex, MissingArgCount,
-                                        IncludedFlagsBitmask);
+  InputArgList Args = OptTbl.ParseArgs(Argv, MissingArgIndex, MissingArgCount,
+                                       IncludedFlagsBitmask);

  // Check for missing argument error.
  if (MissingArgCount) {
@@ -88,7 +89,7 @@ bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
  for (const Arg *A : Args.filtered(OPT_UNKNOWN)) {
    auto ArgString = A->getAsString(Args);
    std::string Nearest;
-    if (OptTbl->findNearest(ArgString, Nearest, IncludedFlagsBitmask) > 1)
+    if (OptTbl.findNearest(ArgString, Nearest, IncludedFlagsBitmask) > 1)
      Diags.Report(diag::err_drv_unknown_argument) << ArgString;
    else
      Diags.Report(diag::err_drv_unknown_argument_with_suggestion)
@@ -100,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.
@@ -131,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)) {
@@ -153,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)
@@ -181,8 +189,10 @@ bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
  Opts.RelaxAll = Args.hasArg(OPT_mrelax_all);
  Opts.NoExecStack = Args.hasArg(OPT_mno_exec_stack);
  Opts.FatalWarnings = Args.hasArg(OPT_massembler_fatal_warnings);
-  Opts.RelocationModel = Args.getLastArgValue(OPT_mrelocation_model, "pic");
-  Opts.TargetABI = Args.getLastArgValue(OPT_target_abi);
+  Opts.NoWarn = Args.hasArg(OPT_massembler_no_warn);
+  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);
@@ -208,8 +218,8 @@ getOutputStream(StringRef Path, DiagnosticsEngine &Diags, bool Binary) {
    sys::RemoveFileOnSignal(Path);

  std::error_code EC;
-  auto Out = llvm::make_unique<raw_fd_ostream>(
-      Path, EC, (Binary ? sys::fs::F_None : sys::fs::F_Text));
+  auto Out = std::make_unique<raw_fd_ostream>(
+      Path, EC, (Binary ? sys::fs::OF_None : sys::fs::OF_Text));
  if (EC) {
    Diags.Report(diag::err_fe_unable_to_open_output) << Path << EC.message();
    return nullptr;
@@ -245,7 +255,9 @@ bool ExecuteAssembler(AssemblerInvocation &Opts, DiagnosticsEngine &Diags) {
  std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(Opts.Triple));
  assert(MRI && "Unable to create target register info!");

-  std::unique_ptr<MCAsmInfo> MAI(TheTarget->createMCAsmInfo(*MRI, Opts.Triple));
+  MCTargetOptions MCOptions;
+  std::unique_ptr<MCAsmInfo> MAI(
+      TheTarget->createMCAsmInfo(*MRI, Opts.Triple, MCOptions));
  assert(MAI && "Unable to create target asm info!");

  // Ensure MCAsmInfo initialization occurs before any use, otherwise sections
@@ -269,7 +281,7 @@ bool ExecuteAssembler(AssemblerInvocation &Opts, DiagnosticsEngine &Diags) {
  // MCObjectFileInfo needs a MCContext reference in order to initialize itself.
  std::unique_ptr<MCObjectFileInfo> MOFI(new MCObjectFileInfo());

-  MCContext Ctx(MAI.get(), MRI.get(), MOFI.get(), &SrcMgr);
+  MCContext Ctx(MAI.get(), MRI.get(), MOFI.get(), &SrcMgr, &MCOptions);

  bool PIC = false;
  if (Opts.RelocationModel == "static") {
@@ -310,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;

@@ -326,7 +333,8 @@ bool ExecuteAssembler(AssemblerInvocation &Opts, DiagnosticsEngine &Diags) {
  raw_pwrite_stream *Out = FDOS.get();
  std::unique_ptr<buffer_ostream> BOS;

-  MCTargetOptions MCOptions;
+  MCOptions.MCNoWarn = Opts.NoWarn;
+  MCOptions.MCFatalWarnings = Opts.FatalWarnings;
  MCOptions.ABIName = Opts.TargetABI;

  // FIXME: There is a bit of code duplication with addPassesToEmitFile.
@@ -340,7 +348,7 @@ bool ExecuteAssembler(AssemblerInvocation &Opts, DiagnosticsEngine &Diags) {
    std::unique_ptr<MCAsmBackend> MAB(
        TheTarget->createMCAsmBackend(*STI, *MRI, MCOptions));

-    auto FOut = llvm::make_unique<formatted_raw_ostream>(*Out);
+    auto FOut = std::make_unique<formatted_raw_ostream>(*Out);
    Str.reset(TheTarget->createAsmStreamer(
        Ctx, std::move(FOut), /*asmverbose*/ true,
        /*useDwarfDirectory*/ true, IP, std::move(CE), std::move(MAB),
@@ -351,7 +359,7 @@ bool ExecuteAssembler(AssemblerInvocation &Opts, DiagnosticsEngine &Diags) {
    assert(Opts.OutputType == AssemblerInvocation::FT_Obj &&
           "Invalid file type!");
    if (!FDOS->supportsSeeking()) {
-      BOS = make_unique<buffer_ostream>(*FDOS);
+      BOS = std::make_unique<buffer_ostream>(*FDOS);
      Out = BOS.get();
    }

@@ -378,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.
@@ -436,7 +444,7 @@ static void LLVMErrorHandler(void *UserData, const std::string &Message,
  Diags.Report(diag::err_fe_error_backend) << Message;

  // We cannot recover from llvm errors.
-  exit(1);
+  sys::Process::Exit(1);
 }

 int cc1as_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
@@ -464,11 +472,11 @@ int cc1as_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
    return 1;

  if (Asm.ShowHelp) {
-    std::unique_ptr<OptTable> Opts(driver::createDriverOptTable());
-    Opts->PrintHelp(llvm::outs(), "clang -cc1as [options] file...",
-                    "Clang Integrated Assembler",
-                    /*Include=*/driver::options::CC1AsOption, /*Exclude=*/0,
-                    /*ShowAllAliases=*/false);
+    getDriverOptTable().PrintHelp(
+        llvm::outs(), "clang -cc1as [options] file...",
+        "Clang Integrated Assembler",
+        /*Include=*/driver::options::CC1AsOption, /*Exclude=*/0,
+        /*ShowAllAliases=*/false);
    return 0;
  }

@@ -485,7 +493,7 @@ int cc1as_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
  // FIXME: Remove this, one day.
  if (!Asm.LLVMArgs.empty()) {
    unsigned NumArgs = Asm.LLVMArgs.size();
-    auto Args = llvm::make_unique<const char*[]>(NumArgs + 2);
+    auto Args = std::make_unique<const char*[]>(NumArgs + 2);
    Args[0] = "clang (LLVM option parsing)";
    for (unsigned i = 0; i != NumArgs; ++i)
      Args[i + 1] = Asm.LLVMArgs[i].c_str();
@@ -499,6 +507,7 @@ int cc1as_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
  // If any timers were active but haven't been destroyed yet, print their
  // results now.
  TimerGroup::printAll(errs());
+  TimerGroup::clearAll();

  return !!Failed;
 }
@@ -11,8 +11,6 @@
 //
 //===----------------------------------------------------------------------===//

-#include "llvm/ADT/ArrayRef.h"
-
 /// Helper class for representing a single invocation of the assembler.
 struct AssemblerInvocation {
  /// @name Target Options
@@ -82,6 +80,7 @@ struct AssemblerInvocation {
  unsigned RelaxAll : 1;
  unsigned NoExecStack : 1;
  unsigned FatalWarnings : 1;
+  unsigned NoWarn : 1;
  unsigned IncrementalLinkerCompatible : 1;
  unsigned EmbedBitcode : 1;

@@ -107,6 +106,7 @@ public:
    RelaxAll = 0;
    NoExecStack = 0;
    FatalWarnings = 0;
+    NoWarn = 0;
    IncrementalLinkerCompatible = 0;
    DwarfVersion = 0;
    EmbedBitcode = 0;
@@ -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;
@@ -52,8 +53,7 @@ bool tinygo_clang_driver(int argc, char **argv) {
 			std::unique_ptr<clang::CompilerInstance> Clang(new clang::CompilerInstance());
 			bool success = clang::CompilerInvocation::CreateFromArgs(
 					Clang->getInvocation(),
-					const_cast<const char **>(CCArgs.data()),
-					const_cast<const char **>(CCArgs.data()) + CCArgs.size(),
+					CCArgs,
 					Diags);
 			if (!success) {
 				return false;
@@ -74,7 +74,8 @@ bool tinygo_clang_driver(int argc, char **argv) {
 		} else if (strcmp(*CCArgs.data(), "-cc1as") == 0) {
 			// This is the assembler frontend. Parse the arguments.
 			AssemblerInvocation Asm;
-			if (!AssemblerInvocation::CreateFromArgs(Asm, llvm::ArrayRef<const char*>(CCArgs).slice(1), Diags))
+			ArrayRef<const char *> Argv = llvm::ArrayRef<const char*>(CCArgs);
+			if (!AssemblerInvocation::CreateFromArgs(Asm, Argv.slice(1), Diags))
 				return false;

 			// Execute the invocation, unless there were parsing errors.
@@ -6,25 +6,28 @@ import (
 	"os/exec"
 	"runtime"
 	"strings"
+
+	"tinygo.org/x/go-llvm"
 )

 // Commands lists command alternatives for various operating systems. These
 // commands may have a slightly different name across operating systems and
 // distributions or may not even exist in $PATH, in which case absolute paths
 // may be used.
-var commands = map[string][]string{
-	"clang":   {"clang-9"},
-	"ld.lld":  {"ld.lld-9", "ld.lld"},
-	"wasm-ld": {"wasm-ld-9", "wasm-ld"},
-}
+var commands = map[string][]string{}

 func init() {
-	// Add the path to a Homebrew-installed LLVM 9 for ease of use (no need to
+	llvmMajor := strings.Split(llvm.Version, ".")[0]
+	commands["clang"] = []string{"clang-" + llvmMajor}
+	commands["ld.lld"] = []string{"ld.lld-" + llvmMajor, "ld.lld"}
+	commands["wasm-ld"] = []string{"wasm-ld-" + llvmMajor, "wasm-ld"}
+	// Add the path to a Homebrew-installed LLVM for ease of use (no need to
 	// manually set $PATH).
 	if runtime.GOOS == "darwin" {
-		commands["clang"] = append(commands["clang"], "/usr/local/opt/llvm@9/bin/clang-9")
-		commands["ld.lld"] = append(commands["ld.lld"], "/usr/local/opt/llvm@9/bin/ld.lld")
-		commands["wasm-ld"] = append(commands["wasm-ld"], "/usr/local/opt/llvm@9/bin/wasm-ld")
+		prefix := "/usr/local/opt/llvm@" + llvmMajor + "/bin/"
+		commands["clang"] = append(commands["clang"], prefix+"clang-"+llvmMajor)
+		commands["ld.lld"] = append(commands["ld.lld"], prefix+"ld.lld")
+		commands["wasm-ld"] = append(commands["wasm-ld"], prefix+"wasm-ld")
 	}
 	// Add the path for when LLVM was installed with the installer from
 	// llvm.org, which by default doesn't add LLVM to the $PATH environment
@@ -34,11 +37,12 @@ func init() {
 		commands["ld.lld"] = append(commands["ld.lld"], "lld", "C:\\Program Files\\LLVM\\bin\\lld.exe")
 		commands["wasm-ld"] = append(commands["wasm-ld"], "C:\\Program Files\\LLVM\\bin\\wasm-ld.exe")
 	}
-	// Add the path to the llvm90 installed from ports
+	// Add the path to LLVM installed from ports.
 	if runtime.GOOS == "freebsd" {
-		commands["clang"] = append(commands["clang"], "/usr/local/llvm90/bin/clang-9")
-		commands["ld.lld"] = append(commands["ld.lld"], "/usr/local/llvm90/bin/ld.lld")
-		commands["wasm-ld"] = append(commands["wasm-ld"], "/usr/local/llvm90/bin/wasm-ld")
+		prefix := "/usr/local/llvm" + llvmMajor + "/bin/"
+		commands["clang"] = append(commands["clang"], prefix+"clang-"+llvmMajor)
+		commands["ld.lld"] = append(commands["ld.lld"], prefix+"ld.lld")
+		commands["wasm-ld"] = append(commands["wasm-ld"], prefix+"wasm-ld")
 	}
 }

@@ -1,60 +0,0 @@
-// +build byollvm
-
-package builder
-
-import (
-	"errors"
-	"os"
-	"os/exec"
-	"unsafe"
-
-	"github.com/tinygo-org/tinygo/goenv"
-)
-
-/*
-#cgo CXXFLAGS: -fno-rtti
-#include <stdbool.h>
-#include <stdlib.h>
-bool tinygo_clang_driver(int argc, char **argv);
-*/
-import "C"
-
-// runCCompiler invokes a C compiler with the given arguments.
-//
-// This version invokes the built-in Clang when trying to run the Clang compiler.
-func runCCompiler(command string, flags ...string) error {
-	switch command {
-	case "clang":
-		// Compile this with the internal Clang compiler.
-		headerPath := getClangHeaderPath(goenv.Get("TINYGOROOT"))
-		if headerPath == "" {
-			return errors.New("could not locate Clang headers")
-		}
-		flags = append(flags, "-I"+headerPath)
-		flags = append([]string{"tinygo:" + command}, flags...)
-		var cflag *C.char
-		buf := C.calloc(C.size_t(len(flags)), C.size_t(unsafe.Sizeof(cflag)))
-		cflags := (*[1 << 10]*C.char)(unsafe.Pointer(buf))[:len(flags):len(flags)]
-		for i, flag := range flags {
-			cflag := C.CString(flag)
-			cflags[i] = cflag
-			defer C.free(unsafe.Pointer(cflag))
-		}
-		ok := C.tinygo_clang_driver(C.int(len(flags)), (**C.char)(buf))
-		if !ok {
-			return errors.New("failed to compile using built-in clang")
-		}
-		return nil
-	default:
-		// Running some other compiler. Maybe it has been defined in the
-		// commands map (unlikely).
-		if cmdNames, ok := commands[command]; ok {
-			return execCommand(cmdNames, flags...)
-		}
-		// Alternatively, run the compiler directly.
-		cmd := exec.Command(command, flags...)
-		cmd.Stdout = os.Stdout
-		cmd.Stderr = os.Stderr
-		return cmd.Run()
-	}
-}
@@ -1,24 +0,0 @@
-// +build !byollvm
-
-package builder
-
-// This file provides a way to a C compiler as an external command. See also:
-// clang-external.go
-
-import (
-	"os"
-	"os/exec"
-)
-
-// runCCompiler invokes a C compiler with the given arguments.
-//
-// This version always runs the compiler as an external command.
-func runCCompiler(command string, flags ...string) error {
-	if cmdNames, ok := commands[command]; ok {
-		return execCommand(cmdNames, flags...)
-	}
-	cmd := exec.Command(command, flags...)
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	return cmd.Run()
-}
@@ -21,12 +21,12 @@ func NewConfig(options *compileopts.Options) (*compileopts.Config, error) {
 	if goroot == "" {
 		return nil, errors.New("cannot locate $GOROOT, please set it manually")
 	}
-	major, minor, err := getGorootVersion(goroot)
+	major, minor, err := goenv.GetGorootVersion(goroot)
 	if err != nil {
 		return nil, fmt.Errorf("could not read version from GOROOT (%v): %v", goroot, err)
 	}
-	if major != 1 || (minor != 11 && minor != 12 && minor != 13) {
-		return nil, fmt.Errorf("requires go version 1.11, 1.12, or 1.13, got go%d.%d", major, minor)
+	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)
 	}
 	clangHeaderPath := getClangHeaderPath(goenv.Get("TINYGOROOT"))
 	return &compileopts.Config{
@@ -1,71 +1,16 @@
 package builder

 import (
-	"errors"
-	"fmt"
-	"io"
 	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
-	"regexp"
 	"sort"
 	"strings"
+
+	"tinygo.org/x/go-llvm"
 )

-// getGorootVersion returns the major and minor version for a given GOROOT path.
-// If the goroot cannot be determined, (0, 0) is returned.
-func getGorootVersion(goroot string) (major, minor int, err error) {
-	s, err := GorootVersionString(goroot)
-	if err != nil {
-		return 0, 0, err
-	}
-
-	if s == "" || s[:2] != "go" {
-		return 0, 0, errors.New("could not parse Go version: version does not start with 'go' prefix")
-	}
-
-	parts := strings.Split(s[2:], ".")
-	if len(parts) < 2 {
-		return 0, 0, errors.New("could not parse Go version: version has less than two parts")
-	}
-
-	// Ignore the errors, we don't really handle errors here anyway.
-	var trailing string
-	n, err := fmt.Sscanf(s, "go%d.%d%s", &major, &minor, &trailing)
-	if n == 2 && err == io.EOF {
-		// Means there were no trailing characters (i.e., not an alpha/beta)
-		err = nil
-	}
-	if err != nil {
-		return 0, 0, fmt.Errorf("failed to parse version: %s", err)
-	}
-	return
-}
-
-// GorootVersionString returns the version string as reported by the Go
-// toolchain for the given GOROOT path. It is usually of the form `go1.x.y` but
-// can have some variations (for beta releases, for example).
-func GorootVersionString(goroot string) (string, error) {
-	if data, err := ioutil.ReadFile(filepath.Join(
-		goroot, "src", "runtime", "internal", "sys", "zversion.go")); err == nil {
-
-		r := regexp.MustCompile("const TheVersion = `(.*)`")
-		matches := r.FindSubmatch(data)
-		if len(matches) != 2 {
-			return "", errors.New("Invalid go version output:\n" + string(data))
-		}
-
-		return string(matches[1]), nil
-
-	} else if data, err := ioutil.ReadFile(filepath.Join(goroot, "VERSION")); err == nil {
-		return string(data), nil
-
-	} else {
-		return "", err
-	}
-}
-
 // getClangHeaderPath returns the path to the built-in Clang headers. It tries
 // multiple locations, which should make it find the directory when installed in
 // various ways.
@@ -84,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 {
@@ -98,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
@@ -0,0 +1,153 @@
+package builder
+
+// This file implements support for writing ESP image files. These image files
+// are read by the ROM bootloader so have to be in a particular format.
+//
+// In the future, it may be necessary to implement support for other image
+// formats, such as the ESP8266 image formats (again, used by the ROM bootloader
+// to load the firmware).
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"debug/elf"
+	"encoding/binary"
+	"fmt"
+	"io/ioutil"
+	"sort"
+)
+
+type espImageSegment struct {
+	addr uint32
+	data []byte
+}
+
+// makeESPFirmare converts an input ELF file to an image file for an ESP32 or
+// ESP8266 chip. This is a special purpose image format just for the ESP chip
+// family, and is parsed by the on-chip mask ROM bootloader.
+//
+// The following documentation has been used:
+// https://github.com/espressif/esptool/wiki/Firmware-Image-Format
+// https://github.com/espressif/esp-idf/blob/8fbb63c2a701c22ccf4ce249f43aded73e134a34/components/bootloader_support/include/esp_image_format.h#L58
+// https://github.com/espressif/esptool/blob/master/esptool.py
+func makeESPFirmareImage(infile, outfile, format string) error {
+	inf, err := elf.Open(infile)
+	if err != nil {
+		return err
+	}
+	defer inf.Close()
+
+	// Load all segments to be written to the image. These are actually ELF
+	// sections, not true ELF segments (similar to how esptool does it).
+	var segments []*espImageSegment
+	for _, section := range inf.Sections {
+		if section.Type != elf.SHT_PROGBITS || section.Size == 0 || section.Flags&elf.SHF_ALLOC == 0 {
+			continue
+		}
+		data, err := section.Data()
+		if err != nil {
+			return fmt.Errorf("failed to read section data: %w", err)
+		}
+		for len(data)%4 != 0 {
+			// Align segment to 4 bytes.
+			data = append(data, 0)
+		}
+		if uint64(uint32(section.Addr)) != section.Addr {
+			return fmt.Errorf("section address too big: 0x%x", section.Addr)
+		}
+		segments = append(segments, &espImageSegment{
+			addr: uint32(section.Addr),
+			data: data,
+		})
+	}
+
+	// Sort the segments by address. This is what esptool does too.
+	sort.SliceStable(segments, func(i, j int) bool { return segments[i].addr < segments[j].addr })
+
+	// Calculate checksum over the segment data. This is used in the image
+	// footer.
+	checksum := uint8(0xef)
+	for _, segment := range segments {
+		for _, b := range segment.data {
+			checksum ^= b
+		}
+	}
+
+	// Write first to an in-memory buffer, primarily so that we can easily
+	// calculate a hash over the entire image.
+	// An added benefit is that we don't need to check for errors all the time.
+	outf := &bytes.Buffer{}
+
+	// Image header.
+	switch format {
+	case "esp32":
+		// Header format:
+		// https://github.com/espressif/esp-idf/blob/8fbb63c2/components/bootloader_support/include/esp_image_format.h#L58
+		binary.Write(outf, binary.LittleEndian, struct {
+			magic          uint8
+			segment_count  uint8
+			spi_mode       uint8
+			spi_speed_size uint8
+			entry_addr     uint32
+			wp_pin         uint8
+			spi_pin_drv    [3]uint8
+			reserved       [11]uint8
+			hash_appended  bool
+		}{
+			magic:          0xE9,
+			segment_count:  byte(len(segments)),
+			spi_mode:       0, // irrelevant, replaced by esptool when flashing
+			spi_speed_size: 0, // spi_speed, spi_size: replaced by esptool when flashing
+			entry_addr:     uint32(inf.Entry),
+			wp_pin:         0xEE, // disable WP pin
+			hash_appended:  true, // add a SHA256 hash
+		})
+	case "esp8266":
+		// Header format:
+		// https://github.com/espressif/esptool/wiki/Firmware-Image-Format
+		// Basically a truncated version of the ESP32 header.
+		binary.Write(outf, binary.LittleEndian, struct {
+			magic          uint8
+			segment_count  uint8
+			spi_mode       uint8
+			spi_speed_size uint8
+			entry_addr     uint32
+		}{
+			magic:          0xE9,
+			segment_count:  byte(len(segments)),
+			spi_mode:       0,    // irrelevant, replaced by esptool when flashing
+			spi_speed_size: 0x20, // spi_speed, spi_size: replaced by esptool when flashing
+			entry_addr:     uint32(inf.Entry),
+		})
+	default:
+		return fmt.Errorf("builder: unknown binary format %#v, expected esp32 or esp8266", format)
+	}
+
+	// Write all segments to the image.
+	// https://github.com/espressif/esptool/wiki/Firmware-Image-Format#segment
+	for _, segment := range segments {
+		binary.Write(outf, binary.LittleEndian, struct {
+			addr   uint32
+			length uint32
+		}{
+			addr:   segment.addr,
+			length: uint32(len(segment.data)),
+		})
+		outf.Write(segment.data)
+	}
+
+	// Footer, including checksum.
+	// The entire image size must be a multiple of 16, so pad the image to one
+	// byte less than that before writing the checksum.
+	outf.Write(make([]byte, 15-outf.Len()%16))
+	outf.WriteByte(checksum)
+
+	if format == "esp32" {
+		// SHA256 hash (to protect against image corruption, not for security).
+		hash := sha256.Sum256(outf.Bytes())
+		outf.Write(hash[:])
+	}
+
+	// Write the image to the output file.
+	return ioutil.WriteFile(outfile, outf.Bytes(), 0666)
+}
@@ -0,0 +1,105 @@
+package builder
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/tinygo-org/tinygo/goenv"
+)
+
+// Library is a container for information about a single C library, such as a
+// compiler runtime or libc.
+type Library struct {
+	// The library name, such as compiler-rt or picolibc.
+	name string
+
+	cflags func() []string
+
+	// The source directory, relative to TINYGOROOT.
+	sourceDir string
+
+	// The source files, relative to sourceDir.
+	sources func(target string) []string
+}
+
+// fullPath returns the full path to the source directory.
+func (l *Library) fullPath() string {
+	return filepath.Join(goenv.Get("TINYGOROOT"), l.sourceDir)
+}
+
+// sourcePaths returns a slice with the full paths to the source files.
+func (l *Library) sourcePaths(target string) []string {
+	sources := l.sources(target)
+	paths := make([]string, len(sources))
+	for i, name := range sources {
+		paths[i] = filepath.Join(l.fullPath(), name)
+	}
+	return paths
+}
+
+// Load the library archive, possibly generating and caching it if needed.
+func (l *Library) Load(target string) (path string, 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
+	}
+
+	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 {
+		// Cache hit.
+		return path, err
+	}
+	// Cache miss, build it now.
+
+	dirPrefix := "tinygo-" + l.name
+	remapDir := filepath.Join(os.TempDir(), dirPrefix)
+	dir, err := ioutil.TempDir(os.TempDir(), dirPrefix)
+	if err != nil {
+		return "", err
+	}
+	defer os.RemoveAll(dir)
+
+	// Precalculate the flags to the compiler invocation.
+	args := append(l.cflags(), "-c", "-Oz", "-g", "-ffunction-sections", "-fdata-sections", "-Wno-macro-redefined", "--target="+target, "-fdebug-prefix-map="+dir+"="+remapDir)
+	if strings.HasPrefix(target, "arm") || strings.HasPrefix(target, "thumb") {
+		args = append(args, "-fshort-enums", "-fomit-frame-pointer", "-mfloat-abi=soft")
+	}
+	if strings.HasPrefix(target, "riscv32-") {
+		args = append(args, "-march=rv32imac", "-mabi=ilp32", "-fforce-enable-int128")
+	}
+	if strings.HasPrefix(target, "riscv64-") {
+		args = append(args, "-march=rv64gc", "-mabi=lp64")
+	}
+
+	// Compile all sources.
+	var objs []string
+	for _, srcpath := range l.sourcePaths(target) {
+		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}
+		}
+	}
+
+	// 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))
+}
@@ -1,71 +0,0 @@
-// +build byollvm
-
-package builder
-
-// This file provides a Link() function that uses the bundled lld if possible.
-
-import (
-	"errors"
-	"os"
-	"os/exec"
-	"unsafe"
-
-	"github.com/tinygo-org/tinygo/goenv"
-)
-
-/*
-#include <stdbool.h>
-#include <stdlib.h>
-bool tinygo_link_elf(int argc, char **argv);
-bool tinygo_link_wasm(int argc, char **argv);
-*/
-import "C"
-
-// link invokes a linker with the given name and flags.
-//
-// This version uses the built-in linker when trying to use lld.
-func link(linker string, flags ...string) error {
-	switch linker {
-	case "ld.lld":
-		flags = append([]string{"tinygo:" + linker}, flags...)
-		var cflag *C.char
-		buf := C.calloc(C.size_t(len(flags)), C.size_t(unsafe.Sizeof(cflag)))
-		cflags := (*[1 << 10]*C.char)(unsafe.Pointer(buf))[:len(flags):len(flags)]
-		for i, flag := range flags {
-			cflag := C.CString(flag)
-			cflags[i] = cflag
-			defer C.free(unsafe.Pointer(cflag))
-		}
-		ok := C.tinygo_link_elf(C.int(len(flags)), (**C.char)(buf))
-		if !ok {
-			return errors.New("failed to link using built-in ld.lld")
-		}
-		return nil
-	case "wasm-ld":
-		flags = append([]string{"tinygo:" + linker}, flags...)
-		var cflag *C.char
-		buf := C.calloc(C.size_t(len(flags)), C.size_t(unsafe.Sizeof(cflag)))
-		defer C.free(buf)
-		cflags := (*[1 << 10]*C.char)(unsafe.Pointer(buf))[:len(flags):len(flags)]
-		for i, flag := range flags {
-			cflag := C.CString(flag)
-			cflags[i] = cflag
-			defer C.free(unsafe.Pointer(cflag))
-		}
-		ok := C.tinygo_link_wasm(C.int(len(flags)), (**C.char)(buf))
-		if !ok {
-			return errors.New("failed to link using built-in wasm-ld")
-		}
-		return nil
-	default:
-		// Fall back to external command.
-		if cmdNames, ok := commands[linker]; ok {
-			return execCommand(cmdNames, flags...)
-		}
-		cmd := exec.Command(linker, flags...)
-		cmd.Stdout = os.Stdout
-		cmd.Stderr = os.Stderr
-		cmd.Dir = goenv.Get("TINYGOROOT")
-		return cmd.Run()
-	}
-}
@@ -1,27 +0,0 @@
-// +build !byollvm
-
-package builder
-
-// This file provides a Link() function that always runs an external command. It
-// is provided for when tinygo is built without linking to liblld.
-
-import (
-	"os"
-	"os/exec"
-
-	"github.com/tinygo-org/tinygo/goenv"
-)
-
-// link invokes a linker with the given name and arguments.
-//
-// This version always runs the linker as an external command.
-func link(linker string, flags ...string) error {
-	if cmdNames, ok := commands[linker]; ok {
-		return execCommand(cmdNames, flags...)
-	}
-	cmd := exec.Command(linker, flags...)
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	cmd.Dir = goenv.Get("TINYGOROOT")
-	return cmd.Run()
-}
@@ -8,12 +8,12 @@ extern "C" {

 bool tinygo_link_elf(int argc, char **argv) {
 	std::vector<const char*> args(argv, argv + argc);
-	return lld::elf::link(args, false);
+	return lld::elf::link(args, false, llvm::outs(), llvm::errs());
 }

 bool tinygo_link_wasm(int argc, char **argv) {
 	std::vector<const char*> args(argv, argv + argc);
-	return lld::wasm::link(args, false);
+	return lld::wasm::link(args, false, llvm::outs(), llvm::errs());
 }

 } // external "C"
@@ -4,12 +4,15 @@ import (
 	"debug/elf"
 	"io/ioutil"
 	"os"
-	"path/filepath"
 	"sort"

 	"github.com/marcinbor85/gohex"
 )

+// maxPadBytes is the maximum allowed bytes to be padded in a rom extraction
+// this value is currently defined by Nintendo Switch Page Alignment (4096 bytes)
+const maxPadBytes = 4095
+
 // objcopyError is an error returned by functions that act like objcopy.
 type objcopyError struct {
 	Op  string
@@ -58,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)
@@ -70,8 +73,19 @@ 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)) {
-			return 0, nil, objcopyError{"ROM segments are non-contiguous: " + path, nil}
+			diff := prog.Paddr - (progs[0].Paddr + uint64(len(rom)))
+			if diff > maxPadBytes {
+				return 0, nil, objcopyError{"ROM segments are non-contiguous: " + path, nil}
+			}
+			// Pad the difference
+			rom = append(rom, make([]byte, diff)...)
 		}
 		data, err := ioutil.ReadAll(prog.Open())
 		if err != nil {
@@ -93,7 +107,7 @@ func extractROM(path string) (uint64, []byte, error) {

 // objcopy converts an ELF file to a different (simpler) output file format:
 // .bin or .hex. It extracts only the .text section.
-func objcopy(infile, outfile string) error {
+func objcopy(infile, outfile, binaryFormat string) error {
 	f, err := os.OpenFile(outfile, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666)
 	if err != nil {
 		return err
@@ -107,24 +121,20 @@ func objcopy(infile, outfile string) error {
 	}

 	// Write to the file, in the correct format.
-	switch filepath.Ext(outfile) {
-	case ".gba":
-		// The address is not stored in a .gba file.
-		_, err := f.Write(data)
-		return err
-	case ".bin":
-		// The address is not stored in a .bin file (therefore you
-		// should use .hex files in most cases).
-		_, err := f.Write(data)
-		return err
-	case ".hex":
+	switch binaryFormat {
+	case "hex":
+		// Intel hex file, includes the firmware start address.
 		mem := gohex.NewMemory()
 		err := mem.AddBinary(uint32(addr), data)
 		if err != nil {
 			return objcopyError{"failed to create .hex file", err}
 		}
-		mem.DumpIntelHex(f, 16) // TODO: handle error
-		return nil
+		return mem.DumpIntelHex(f, 16)
+	case "bin":
+		// The start address is not stored in raw firmware files (therefore you
+		// should use .hex files in most cases).
+		_, err := f.Write(data)
+		return err
 	default:
 		panic("unreachable")
 	}
@@ -0,0 +1,127 @@
+package builder
+
+import (
+	"path/filepath"
+
+	"github.com/tinygo-org/tinygo/goenv"
+)
+
+// Picolibc is a C library for bare metal embedded devices. It was originally
+// based on newlib.
+var Picolibc = Library{
+	name: "picolibc",
+	cflags: func() []string {
+		picolibcDir := filepath.Join(goenv.Get("TINYGOROOT"), "lib/picolibc/newlib/libc")
+		return []string{"-Werror", "-Wall", "-std=gnu11", "-D_COMPILING_NEWLIB", "-nostdlibinc", "-Xclang", "-internal-isystem", "-Xclang", picolibcDir + "/include", "-I" + picolibcDir + "/tinystdio", "-I" + goenv.Get("TINYGOROOT") + "/lib/picolibc-include"}
+	},
+	sourceDir: "lib/picolibc/newlib/libc",
+	sources: func(target string) []string {
+		return picolibcSources
+	},
+}
+
+var picolibcSources = []string{
+	"string/bcmp.c",
+	"string/bcopy.c",
+	"string/bzero.c",
+	"string/explicit_bzero.c",
+	"string/ffsl.c",
+	"string/ffsll.c",
+	"string/fls.c",
+	"string/flsl.c",
+	"string/flsll.c",
+	"string/gnu_basename.c",
+	"string/index.c",
+	"string/memccpy.c",
+	"string/memchr.c",
+	"string/memcmp.c",
+	"string/memcpy.c",
+	"string/memmem.c",
+	"string/memmove.c",
+	"string/mempcpy.c",
+	"string/memrchr.c",
+	"string/memset.c",
+	"string/rawmemchr.c",
+	"string/rindex.c",
+	"string/stpcpy.c",
+	"string/stpncpy.c",
+	"string/strcasecmp.c",
+	"string/strcasecmp_l.c",
+	"string/strcasestr.c",
+	"string/strcat.c",
+	"string/strchr.c",
+	"string/strchrnul.c",
+	"string/strcmp.c",
+	"string/strcoll.c",
+	"string/strcoll_l.c",
+	"string/strcpy.c",
+	"string/strcspn.c",
+	"string/strdup.c",
+	"string/strerror.c",
+	"string/strerror_r.c",
+	"string/strlcat.c",
+	"string/strlcpy.c",
+	"string/strlen.c",
+	"string/strlwr.c",
+	"string/strncasecmp.c",
+	"string/strncasecmp_l.c",
+	"string/strncat.c",
+	"string/strncmp.c",
+	"string/strncpy.c",
+	"string/strndup.c",
+	"string/strnlen.c",
+	"string/strnstr.c",
+	"string/strpbrk.c",
+	"string/strrchr.c",
+	"string/strsep.c",
+	"string/strsignal.c",
+	"string/strspn.c",
+	"string/strstr.c",
+	"string/strtok.c",
+	"string/strtok_r.c",
+	"string/strupr.c",
+	"string/strverscmp.c",
+	"string/strxfrm.c",
+	"string/strxfrm_l.c",
+	"string/swab.c",
+	"string/timingsafe_bcmp.c",
+	"string/timingsafe_memcmp.c",
+	"string/u_strerr.c",
+	"string/wcpcpy.c",
+	"string/wcpncpy.c",
+	"string/wcscasecmp.c",
+	"string/wcscasecmp_l.c",
+	"string/wcscat.c",
+	"string/wcschr.c",
+	"string/wcscmp.c",
+	"string/wcscoll.c",
+	"string/wcscoll_l.c",
+	"string/wcscpy.c",
+	"string/wcscspn.c",
+	"string/wcsdup.c",
+	"string/wcslcat.c",
+	"string/wcslcpy.c",
+	"string/wcslen.c",
+	"string/wcsncasecmp.c",
+	"string/wcsncasecmp_l.c",
+	"string/wcsncat.c",
+	"string/wcsncmp.c",
+	"string/wcsncpy.c",
+	"string/wcsnlen.c",
+	"string/wcspbrk.c",
+	"string/wcsrchr.c",
+	"string/wcsspn.c",
+	"string/wcsstr.c",
+	"string/wcstok.c",
+	"string/wcswidth.c",
+	"string/wcsxfrm.c",
+	"string/wcsxfrm_l.c",
+	"string/wcwidth.c",
+	"string/wmemchr.c",
+	"string/wmemcmp.c",
+	"string/wmemcpy.c",
+	"string/wmemmove.c",
+	"string/wmempcpy.c",
+	"string/wmemset.c",
+	"string/xpg_strerror_r.c",
+}
@@ -84,7 +84,18 @@ func loadProgramSize(path string) (*programSize, error) {
 		if section.Type != elf.SHT_PROGBITS && section.Type != elf.SHT_NOBITS {
 			continue
 		}
-		if section.Type == elf.SHT_NOBITS {
+		if section.Name == ".stack" {
+			// HACK: this works around a bug in ld.lld from LLVM 10. The linker
+			// marks sections with no input symbols (such as is the case for the
+			// .stack section) as SHT_PROGBITS instead of SHT_NOBITS. While it
+			// doesn't affect the generated binaries (.hex and .bin), it does
+			// affect the reported size.
+			// https://bugs.llvm.org/show_bug.cgi?id=45336
+			// https://reviews.llvm.org/D76981
+			// It has been merged in master, but it has not (yet) been
+			// backported to the LLVM 10 release branch.
+			sumBSS += section.Size
+		} else if section.Type == elf.SHT_NOBITS {
 			sumBSS += section.Size
 		} else if section.Flags&elf.SHF_EXECINSTR != 0 {
 			sumCode += section.Size
@@ -0,0 +1,54 @@
+// +build byollvm
+
+package builder
+
+import (
+	"errors"
+	"unsafe"
+)
+
+/*
+#cgo CXXFLAGS: -fno-rtti
+#include <stdbool.h>
+#include <stdlib.h>
+bool tinygo_clang_driver(int argc, char **argv);
+bool tinygo_link_elf(int argc, char **argv);
+bool tinygo_link_wasm(int argc, char **argv);
+*/
+import "C"
+
+const hasBuiltinTools = true
+
+// RunTool runs the given tool (such as clang).
+//
+// This version actually runs the tools because TinyGo was compiled while
+// linking statically with LLVM (with the byollvm build tag).
+func RunTool(tool string, args ...string) error {
+	args = append([]string{"tinygo:" + tool}, args...)
+
+	var cflag *C.char
+	buf := C.calloc(C.size_t(len(args)), C.size_t(unsafe.Sizeof(cflag)))
+	defer C.free(buf)
+	cflags := (*[1 << 10]*C.char)(unsafe.Pointer(buf))[:len(args):len(args)]
+	for i, flag := range args {
+		cflag := C.CString(flag)
+		cflags[i] = cflag
+		defer C.free(unsafe.Pointer(cflag))
+	}
+
+	var ok C.bool
+	switch tool {
+	case "clang":
+		ok = C.tinygo_clang_driver(C.int(len(args)), (**C.char)(buf))
+	case "ld.lld":
+		ok = C.tinygo_link_elf(C.int(len(args)), (**C.char)(buf))
+	case "wasm-ld":
+		ok = C.tinygo_link_wasm(C.int(len(args)), (**C.char)(buf))
+	default:
+		return errors.New("unknown tool: " + tool)
+	}
+	if !ok {
+		return errors.New("failed to run tool: " + tool)
+	}
+	return nil
+}
@@ -0,0 +1,15 @@
+// +build !byollvm
+
+package builder
+
+import "errors"
+
+const hasBuiltinTools = false
+
+// RunTool runs the given tool (such as clang).
+//
+// This version doesn't actually run the tool: TinyGo has not been compiled by
+// statically linking to LLVM.
+func RunTool(tool string, args ...string) error {
+	return errors.New("cannot run tool: " + tool)
+}
@@ -0,0 +1,59 @@
+package builder
+
+import (
+	"errors"
+	"os"
+	"os/exec"
+
+	"github.com/tinygo-org/tinygo/goenv"
+)
+
+// runCCompiler invokes a C compiler with the given arguments.
+func runCCompiler(command string, flags ...string) error {
+	if hasBuiltinTools && command == "clang" {
+		// Compile this with the internal Clang compiler.
+		headerPath := getClangHeaderPath(goenv.Get("TINYGOROOT"))
+		if headerPath == "" {
+			return errors.New("could not locate Clang headers")
+		}
+		flags = append(flags, "-I"+headerPath)
+		cmd := exec.Command(os.Args[0], append([]string{"clang"}, flags...)...)
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		return cmd.Run()
+	}
+
+	// Running some other compiler. Maybe it has been defined in the
+	// commands map (unlikely).
+	if cmdNames, ok := commands[command]; ok {
+		return execCommand(cmdNames, flags...)
+	}
+
+	// Alternatively, run the compiler directly.
+	cmd := exec.Command(command, flags...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	return cmd.Run()
+}
+
+// link invokes a linker with the given name and flags.
+func link(linker string, flags ...string) error {
+	if hasBuiltinTools && (linker == "ld.lld" || linker == "wasm-ld") {
+		// Run command with internal linker.
+		cmd := exec.Command(os.Args[0], append([]string{linker}, flags...)...)
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		return cmd.Run()
+	}
+
+	// Fall back to external command.
+	if cmdNames, ok := commands[linker]; ok {
+		return execCommand(cmdNames, flags...)
+	}
+
+	cmd := exec.Command(linker, flags...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	cmd.Dir = goenv.Get("TINYGOROOT")
+	return cmd.Run()
+}
@@ -11,26 +11,33 @@ import (
 	"bytes"
 	"encoding/binary"
 	"io/ioutil"
+	"strconv"
 )

 // convertELFFileToUF2File converts an ELF file to a UF2 file.
-func convertELFFileToUF2File(infile, outfile string) error {
+func convertELFFileToUF2File(infile, outfile string, uf2FamilyID string) error {
 	// Read the .text segment.
 	targetAddress, data, err := extractROM(infile)
 	if err != nil {
 		return err
 	}

-	output, _ := convertBinToUF2(data, uint32(targetAddress))
+	output, _, err := convertBinToUF2(data, uint32(targetAddress), uf2FamilyID)
+	if err != nil {
+		return err
+	}
 	return ioutil.WriteFile(outfile, output, 0644)
 }

 // convertBinToUF2 converts the binary bytes in input to UF2 formatted data.
-func convertBinToUF2(input []byte, targetAddr uint32) ([]byte, int) {
+func convertBinToUF2(input []byte, targetAddr uint32, uf2FamilyID string) ([]byte, int, error) {
 	blocks := split(input, 256)
 	output := make([]byte, 0)

-	bl := newUF2Block(targetAddr)
+	bl, err := newUF2Block(targetAddr, uf2FamilyID)
+	if err != nil {
+		return nil, 0, err
+	}
 	bl.SetNumBlocks(len(blocks))

 	for i := 0; i < len(blocks); i++ {
@@ -41,7 +48,7 @@ func convertBinToUF2(input []byte, targetAddr uint32) ([]byte, int) {
 		bl.IncrementAddress(bl.payloadSize)
 	}

-	return output, len(blocks)
+	return output, len(blocks), nil
 }

 const (
@@ -65,18 +72,32 @@ type uf2Block struct {
 }

 // newUF2Block returns a new uf2Block struct that has been correctly populated
-func newUF2Block(targetAddr uint32) *uf2Block {
+func newUF2Block(targetAddr uint32, uf2FamilyID string) (*uf2Block, error) {
+	var flags uint32
+	var familyID uint32
+	if uf2FamilyID != "" {
+		flags |= flagFamilyIDPresent
+		v, err := strconv.ParseUint(uf2FamilyID, 0, 32)
+		if err != nil {
+			return nil, err
+		}
+		familyID = uint32(v)
+	}
 	return &uf2Block{magicStart0: uf2MagicStart0,
 		magicStart1: uf2MagicStart1,
 		magicEnd:    uf2MagicEnd,
 		targetAddr:  targetAddr,
-		flags:       0x0,
-		familyID:    0x0,
+		flags:       flags,
+		familyID:    familyID,
 		payloadSize: 256,
 		data:        make([]byte, 476),
-	}
+	}, nil
 }

+const (
+	flagFamilyIDPresent = 0x00002000
+)
+
 // Bytes converts the uf2Block to a slice of bytes that can be written to file.
 func (b *uf2Block) Bytes() []byte {
 	buf := bytes.NewBuffer(make([]byte, 0, 512))
@@ -14,7 +14,9 @@ package cgo
 import (
 	"fmt"
 	"go/ast"
+	"go/scanner"
 	"go/token"
+	"path/filepath"
 	"sort"
 	"strconv"
 	"strings"
@@ -39,6 +41,7 @@ type cgoPackage struct {
 	elaboratedTypes map[string]*elaboratedTypeInfo
 	enums           map[string]enumInfo
 	anonStructNum   int
+	ldflags         []string
 }

 // constantInfo stores some information about a CGo constant found by libclang
@@ -154,7 +157,7 @@ typedef unsigned long long  _Cgo_ulonglong;
 // newly created *ast.File that should be added to the list of to-be-parsed
 // files. If there is one or more error, it returns these in the []error slice
 // but still modifies the AST.
-func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string) (*ast.File, []error) {
+func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string) (*ast.File, []string, []error) {
 	p := &cgoPackage{
 		dir:             dir,
 		fset:            fset,
@@ -168,11 +171,28 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 		enums:           map[string]enumInfo{},
 	}

+	// Disable _FORTIFY_SOURCE as it causes problems on macOS.
+	// Note that it is only disabled for memcpy (etc) calls made from Go, which
+	// have better alternatives anyway.
+	cflags = append(cflags, "-D_FORTIFY_SOURCE=0")
+
 	// Add a new location for the following file.
 	generatedTokenPos := p.fset.AddFile(dir+"/!cgo.go", -1, 0)
 	generatedTokenPos.SetLines([]int{0})
 	p.generatedPos = generatedTokenPos.Pos(0)

+	// Find the absolute path for this package.
+	packagePath, err := filepath.Abs(fset.File(files[0].Pos()).Name())
+	if err != nil {
+		return nil, nil, []error{
+			scanner.Error{
+				Pos: fset.Position(files[0].Pos()),
+				Msg: "cgo: cannot find absolute path: " + err.Error(), // TODO: wrap this error
+			},
+		}
+	}
+	packagePath = filepath.Dir(packagePath)
+
 	// Construct a new in-memory AST for CGo declarations of this package.
 	unsafeImport := &ast.ImportSpec{
 		Path: &ast.BasicLit{
@@ -338,7 +358,21 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 						p.addErrorAfter(comment.Slash, comment.Text[:lineStart+colon+1], err.Error())
 						continue
 					}
+					makePathsAbsolute(flags, packagePath)
 					cflags = append(cflags, flags...)
+				case "LDFLAGS":
+					flags, err := shlex.Split(value)
+					if err != nil {
+						// TODO: find the exact location where the error happened.
+						p.addErrorAfter(comment.Slash, comment.Text[:lineStart+colon+1], "failed to parse flags in #cgo line: "+err.Error())
+						continue
+					}
+					if err := checkLinkerFlags(name, flags); err != nil {
+						p.addErrorAfter(comment.Slash, comment.Text[:lineStart+colon+1], err.Error())
+						continue
+					}
+					makePathsAbsolute(flags, packagePath)
+					p.ldflags = append(p.ldflags, flags...)
 				default:
 					startPos := strings.LastIndex(line[4:colon], name) + 4
 					p.addErrorAfter(comment.Slash, comment.Text[:lineStart+startPos], "invalid #cgo line: "+name)
@@ -392,7 +426,31 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 	// Print the newly generated in-memory AST, for debugging.
 	//ast.Print(fset, p.generated)

-	return p.generated, p.errors
+	return p.generated, p.ldflags, p.errors
+}
+
+// makePathsAbsolute converts some common path compiler flags (-I, -L) from
+// relative flags into absolute flags, if they are relative. This is necessary
+// because the C compiler is usually not invoked from the package path.
+func makePathsAbsolute(args []string, packagePath string) {
+	nextIsPath := false
+	for i, arg := range args {
+		if nextIsPath {
+			if !filepath.IsAbs(arg) {
+				args[i] = filepath.Join(packagePath, arg)
+			}
+		}
+		if arg == "-I" || arg == "-L" {
+			nextIsPath = true
+			continue
+		}
+		if strings.HasPrefix(arg, "-I") || strings.HasPrefix(arg, "-L") {
+			path := arg[2:]
+			if !filepath.IsAbs(path) {
+				args[i] = arg[:2] + filepath.Join(packagePath, path)
+			}
+		}
+	}
 }

 // addFuncDecls adds the C function declarations found by libclang in the
@@ -11,6 +11,7 @@ import (
 	"go/types"
 	"io/ioutil"
 	"path/filepath"
+	"regexp"
 	"runtime"
 	"strings"
 	"testing"
@@ -19,6 +20,21 @@ import (
 // Pass -update to go test to update the output of the test files.
 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)
+
+	// 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
+	// such functions are wrapped and it's important to have consistent test
+	// results.
+	re := regexp.MustCompile(`func \((.+)\)( .*?) +{ (.+) }`)
+	actual = re.ReplaceAllString(actual, "func ($1)$2 {\n\t$3\n}")
+
+	return actual
+}
+
 func TestCGo(t *testing.T) {
 	var cflags = []string{"--target=armv6m-none-eabi"}

@@ -34,7 +50,7 @@ func TestCGo(t *testing.T) {
 			}

 			// Process the AST with CGo.
-			cgoAST, cgoErrors := Process([]*ast.File{f}, "testdata", fset, cflags)
+			cgoAST, _, cgoErrors := Process([]*ast.File{f}, "testdata", fset, cflags)

 			// Check the AST for type errors.
 			var typecheckErrors []error
@@ -74,7 +90,7 @@ func TestCGo(t *testing.T) {
 			if err != nil {
 				t.Errorf("could not write out CGo AST: %v", err)
 			}
-			actual := strings.Replace(string(buf.Bytes()), "\r\n", "\n", -1)
+			actual := normalizeResult(string(buf.Bytes()))

 			// Read the file with the expected output, to compare against.
 			outfile := filepath.Join("testdata", name+".out.go")
@@ -15,7 +15,7 @@ import (
 )

 /*
-#include <clang-c/Index.h> // if this fails, install libclang-9-dev
+#include <clang-c/Index.h> // if this fails, install libclang-10-dev
 #include <stdlib.h>
 #include <stdint.h>

@@ -246,9 +246,9 @@ func tinygo_clang_globals_visitor(c, parent C.GoCXCursor, client_data C.CXClient
 		}
 		value := source[len(name):]
 		// Try to convert this #define into a Go constant expression.
-		expr, err := parseConst(pos+token.Pos(len(name)), p.fset, value)
-		if err != nil {
-			p.errors = append(p.errors, err)
+		expr, scannerError := parseConst(pos+token.Pos(len(name)), p.fset, value)
+		if scannerError != nil {
+			p.errors = append(p.errors, *scannerError)
 		}
 		if expr != nil {
 			// Parsing was successful.
@@ -1,13 +1,14 @@
 // +build !byollvm
+// +build !llvm9,!llvm11

 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/llvm90/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/llvm90/lib -lclang
+#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"
@@ -0,0 +1,14 @@
+// +build !byollvm
+// +build llvm11
+
+package cgo
+
+/*
+#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"
@@ -0,0 +1,14 @@
+// +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"
@@ -3,7 +3,7 @@
 // are slightly different from the ones defined in libclang.go, but they
 // should be ABI compatible.

-#include <clang-c/Index.h> // if this fails, install libclang-9-dev
+#include <clang-c/Index.h> // if this fails, install libclang-10-dev

 CXCursor tinygo_clang_getTranslationUnitCursor(CXTranslationUnit tu) {
 	return clang_getTranslationUnitCursor(tu);
@@ -9,6 +9,9 @@ package main

 #cgo CFLAGS: -DFOO

+#cgo CFLAGS: -Iinclude
+#include "foo.h"
+
 #if defined(FOO)
 #define BAR 3
 #else
@@ -18,9 +21,17 @@ package main
 #if defined(NOTDEFINED)
 #warning flag must not be defined
 #endif
+
+// Check Compiler flags
+#cgo LDFLAGS: -lc
+
+// This flag is not valid ldflags
+#cgo LDFLAGS: -does-not-exists
+
 */
 import "C"

 var (
 	_ = C.BAR
+	_ = C.FOO_H
 )
@@ -1,6 +1,7 @@
 // CGo errors:
 //     testdata/flags.go:5:7: invalid #cgo line: NOFLAGS
 //     testdata/flags.go:8:13: invalid flag: -fdoes-not-exist
+//     testdata/flags.go:29:14: invalid flag: -does-not-exists

 package main

@@ -9,6 +10,7 @@ import "unsafe"
 var _ unsafe.Pointer

 const C.BAR = 3
+const C.FOO_H = 1

 type C.int16_t = int16
 type C.int32_t = int32
@@ -0,0 +1 @@
+#define FOO_H 1
@@ -62,12 +62,18 @@ type C.union3_t = C.union_1
 type C.union_nested_t = C.union_3
 type C.unionarray_t = struct{ arr [10]C.uchar }

-func (s *C.struct_4) bitfield_a() C.uchar          { return s.__bitfield_1 & 0x1f }
-func (s *C.struct_4) set_bitfield_a(value C.uchar) { s.__bitfield_1 = s.__bitfield_1&^0x1f | value&0x1f<<0 }
+func (s *C.struct_4) bitfield_a() C.uchar {
+	return s.__bitfield_1 & 0x1f
+}
+func (s *C.struct_4) set_bitfield_a(value C.uchar) {
+	s.__bitfield_1 = s.__bitfield_1&^0x1f | value&0x1f<<0
+}
 func (s *C.struct_4) bitfield_b() C.uchar {
 	return s.__bitfield_1 >> 5 & 0x1
 }
-func (s *C.struct_4) set_bitfield_b(value C.uchar) { s.__bitfield_1 = s.__bitfield_1&^0x20 | value&0x1<<5 }
+func (s *C.struct_4) set_bitfield_b(value C.uchar) {
+	s.__bitfield_1 = s.__bitfield_1&^0x20 | value&0x1<<5
+}
 func (s *C.struct_4) bitfield_c() C.uchar {
 	return s.__bitfield_1 >> 6
 }
@@ -94,25 +100,45 @@ type C.struct_type1 struct {
 }
 type C.struct_type2 struct{ _type C.int }

-func (union *C.union_1) unionfield_i() *C.int   { return (*C.int)(unsafe.Pointer(&union.$union)) }
-func (union *C.union_1) unionfield_d() *float64 { return (*float64)(unsafe.Pointer(&union.$union)) }
-func (union *C.union_1) unionfield_s() *C.short { return (*C.short)(unsafe.Pointer(&union.$union)) }
+func (union *C.union_1) unionfield_i() *C.int {
+	return (*C.int)(unsafe.Pointer(&union.$union))
+}
+func (union *C.union_1) unionfield_d() *float64 {
+	return (*float64)(unsafe.Pointer(&union.$union))
+}
+func (union *C.union_1) unionfield_s() *C.short {
+	return (*C.short)(unsafe.Pointer(&union.$union))
+}

 type C.union_1 struct{ $union uint64 }

-func (union *C.union_2) unionfield_area() *C.point2d_t  { return (*C.point2d_t)(unsafe.Pointer(&union.$union)) }
-func (union *C.union_2) unionfield_solid() *C.point3d_t { return (*C.point3d_t)(unsafe.Pointer(&union.$union)) }
+func (union *C.union_2) unionfield_area() *C.point2d_t {
+	return (*C.point2d_t)(unsafe.Pointer(&union.$union))
+}
+func (union *C.union_2) unionfield_solid() *C.point3d_t {
+	return (*C.point3d_t)(unsafe.Pointer(&union.$union))
+}

 type C.union_2 struct{ $union [3]uint32 }

-func (union *C.union_3) unionfield_point() *C.point3d_t    { return (*C.point3d_t)(unsafe.Pointer(&union.$union)) }
-func (union *C.union_3) unionfield_array() *C.unionarray_t { return (*C.unionarray_t)(unsafe.Pointer(&union.$union)) }
-func (union *C.union_3) unionfield_thing() *C.union3_t     { return (*C.union3_t)(unsafe.Pointer(&union.$union)) }
+func (union *C.union_3) unionfield_point() *C.point3d_t {
+	return (*C.point3d_t)(unsafe.Pointer(&union.$union))
+}
+func (union *C.union_3) unionfield_array() *C.unionarray_t {
+	return (*C.unionarray_t)(unsafe.Pointer(&union.$union))
+}
+func (union *C.union_3) unionfield_thing() *C.union3_t {
+	return (*C.union3_t)(unsafe.Pointer(&union.$union))
+}

 type C.union_3 struct{ $union [2]uint64 }

-func (union *C.union_union2d) unionfield_i() *C.int      { return (*C.int)(unsafe.Pointer(&union.$union)) }
-func (union *C.union_union2d) unionfield_d() *[2]float64 { return (*[2]float64)(unsafe.Pointer(&union.$union)) }
+func (union *C.union_union2d) unionfield_i() *C.int {
+	return (*C.int)(unsafe.Pointer(&union.$union))
+}
+func (union *C.union_union2d) unionfield_d() *[2]float64 {
+	return (*[2]float64)(unsafe.Pointer(&union.$union))
+}

 type C.union_union2d struct{ $union [2]uint64 }
 type C.enum_option C.int
@@ -5,6 +5,7 @@ package compileopts
 import (
 	"errors"
 	"fmt"
+	"path/filepath"
 	"regexp"
 	"strconv"
 	"strings"
@@ -21,6 +22,29 @@ 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
@@ -65,8 +89,14 @@ func (c *Config) BuildTags() []string {
 	return tags
 }

+// CgoEnabled returns true if (and only if) CGo is enabled. It is true by
+// default and false if CGO_ENABLED is set to "0".
+func (c *Config) CgoEnabled() bool {
+	return goenv.Get("CGO_ENABLED") == "1"
+}
+
 // GC returns the garbage collection strategy in use on this platform. Valid
-// values are "none", "leaking", and "conservative".
+// values are "none", "leaking", "extalloc", and "conservative".
 func (c *Config) GC() string {
 	if c.Options.GC != "" {
 		return c.Options.GC
@@ -74,26 +104,33 @@ func (c *Config) GC() string {
 	if c.Target.GC != "" {
 		return c.Target.GC
 	}
-	return "conservative"
+	for _, tag := range c.Target.BuildTags {
+		if tag == "baremetal" || tag == "wasm" {
+			return "conservative"
+		}
+	}
+	return "extalloc"
 }

 // NeedsStackObjects returns true if the compiler should insert stack objects
 // that can be traced by the garbage collector.
 func (c *Config) NeedsStackObjects() bool {
-	if c.GC() != "conservative" {
+	switch c.GC() {
+	case "conservative", "extalloc":
+		for _, tag := range c.BuildTags() {
+			if tag == "wasm" {
+				return true
+			}
+		}
+
+		return false
+	default:
 		return false
 	}
-	for _, tag := range c.BuildTags() {
-		if tag == "baremetal" {
-			return false
-		}
-	}
-
-	return true
 }

-// Scheduler returns the scheduler implementation. Valid values are "coroutines"
-// and "tasks".
+// Scheduler returns the scheduler implementation. Valid values are "none",
+//"coroutines" and "tasks".
 func (c *Config) Scheduler() string {
 	if c.Options.Scheduler != "" {
 		return c.Options.Scheduler
@@ -105,6 +142,21 @@ func (c *Config) Scheduler() string {
 	return "coroutines"
 }

+// 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.
+	switch c.Scheduler() {
+	case "none", "coroutines":
+		return FuncValueSwitch
+	case "tasks":
+		return FuncValueDoubleword
+	default:
+		panic("unknown scheduler type")
+	}
+}
+
 // PanicStrategy returns the panic strategy selected for this target. Valid
 // values are "print" (print the panic value, then exit) or "trap" (issue a trap
 // instruction).
@@ -112,6 +164,16 @@ func (c *Config) PanicStrategy() string {
 	return c.Options.PanicStrategy
 }

+// AutomaticStackSize returns whether goroutine stack sizes should be determined
+// automatically at compile time, if possible. If it is false, no attempt is
+// made.
+func (c *Config) AutomaticStackSize() bool {
+	if c.Target.AutoStackSize != nil && c.Scheduler() == "tasks" {
+		return *c.Target.AutoStackSize
+	}
+	return false
+}
+
 // CFlags returns the flags to pass to the C compiler. This is necessary for CGo
 // preprocessing.
 func (c *Config) CFlags() []string {
@@ -119,6 +181,14 @@ func (c *Config) CFlags() []string {
 	for _, flag := range c.Target.CFlags {
 		cflags = append(cflags, strings.Replace(flag, "{root}", goenv.Get("TINYGOROOT"), -1))
 	}
+	if c.Target.Libc == "picolibc" {
+		root := goenv.Get("TINYGOROOT")
+		cflags = append(cflags, "-nostdlibinc", "-Xclang", "-internal-isystem", "-Xclang", filepath.Join(root, "lib", "picolibc", "newlib", "libc", "include"))
+		cflags = append(cflags, "-I"+filepath.Join(root, "lib/picolibc-include"))
+	}
+	if c.Debug() {
+		cflags = append(cflags, "-g")
+	}
 	return cflags
 }

@@ -169,6 +239,31 @@ func (c *Config) Debug() bool {
 	return c.Options.Debug
 }

+// BinaryFormat returns an appropriate binary format, based on the file
+// extension and the configured binary format in the target JSON file.
+func (c *Config) BinaryFormat(ext string) string {
+	switch ext {
+	case ".bin", ".gba", ".nro":
+		// The simplest format possible: dump everything in a raw binary file.
+		if c.Target.BinaryFormat != "" {
+			return c.Target.BinaryFormat
+		}
+		return "bin"
+	case ".hex":
+		// Similar to bin, but includes the start address and is thus usually a
+		// better format.
+		return "hex"
+	case ".uf2":
+		// Special purpose firmware format, mainly used on Adafruit boards.
+		// More information:
+		// https://github.com/Microsoft/uf2
+		return "uf2"
+	default:
+		// Use the ELF format for unrecognized file formats.
+		return "elf"
+	}
+}
+
 // Programmer returns the flash method and OpenOCD interface name given a
 // particular configuration. It may either be all configured in the target JSON
 // file or be modified using the -programmmer command-line option.
@@ -215,6 +310,34 @@ func (c *Config) OpenOCDConfiguration() (args []string, err error) {
 	return args, nil
 }

+// CodeModel returns the code model used on this platform.
+func (c *Config) CodeModel() string {
+	if c.Target.CodeModel != "" {
+		return c.Target.CodeModel
+	}
+
+	return "default"
+}
+
+// RelocationModel returns the relocation model in use on this platform. Valid
+// values are "static", "pic", "dynamicnopic".
+func (c *Config) RelocationModel() string {
+	if c.Target.RelocationModel != "" {
+		return c.Target.RelocationModel
+	}
+
+	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
@@ -1,5 +1,17 @@
 package compileopts

+import (
+	"fmt"
+	"strings"
+)
+
+var (
+	validGCOptions            = []string{"none", "leaking", "extalloc", "conservative"}
+	validSchedulerOptions     = []string{"none", "tasks", "coroutines"}
+	validPrintSizeOptions     = []string{"none", "short", "full"}
+	validPanicStrategyOptions = []string{"print", "trap"}
+)
+
 // Options contains extra options to give to the compiler. These options are
 // usually passed from the command line.
 type Options struct {
@@ -13,6 +25,7 @@ type Options struct {
 	VerifyIR      bool
 	Debug         bool
 	PrintSizes    string
+	PrintStacks   bool
 	CFlags        []string
 	LDFlags       []string
 	Tags          string
@@ -21,3 +34,53 @@ type Options struct {
 	TestConfig    TestConfig
 	Programmer    string
 }
+
+// Verify performs a validation on the given options, raising an error if options are not valid.
+func (o *Options) Verify() error {
+	if o.GC != "" {
+		valid := isInArray(validGCOptions, o.GC)
+		if !valid {
+			return fmt.Errorf(`invalid gc option '%s': valid values are %s`,
+				o.GC,
+				strings.Join(validGCOptions, ", "))
+		}
+	}
+
+	if o.Scheduler != "" {
+		valid := isInArray(validSchedulerOptions, o.Scheduler)
+		if !valid {
+			return fmt.Errorf(`invalid scheduler option '%s': valid values are %s`,
+				o.Scheduler,
+				strings.Join(validSchedulerOptions, ", "))
+		}
+	}
+
+	if o.PrintSizes != "" {
+		valid := isInArray(validPrintSizeOptions, o.PrintSizes)
+		if !valid {
+			return fmt.Errorf(`invalid size option '%s': valid values are %s`,
+				o.PrintSizes,
+				strings.Join(validPrintSizeOptions, ", "))
+		}
+	}
+
+	if o.PanicStrategy != "" {
+		valid := isInArray(validPanicStrategyOptions, o.PanicStrategy)
+		if !valid {
+			return fmt.Errorf(`invalid panic option '%s': valid values are %s`,
+				o.PanicStrategy,
+				strings.Join(validPanicStrategyOptions, ", "))
+		}
+	}
+
+	return nil
+}
+
+func isInArray(arr []string, item string) bool {
+	for _, i := range arr {
+		if i == item {
+			return true
+		}
+	}
+	return false
+}
@@ -0,0 +1,138 @@
+package compileopts_test
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/tinygo-org/tinygo/compileopts"
+)
+
+func TestVerifyOptions(t *testing.T) {
+
+	expectedGCError := errors.New(`invalid gc option 'incorrect': valid values are none, leaking, extalloc, conservative`)
+	expectedSchedulerError := errors.New(`invalid scheduler option 'incorrect': valid values are none, tasks, coroutines`)
+	expectedPrintSizeError := errors.New(`invalid size option 'incorrect': valid values are none, short, full`)
+	expectedPanicStrategyError := errors.New(`invalid panic option 'incorrect': valid values are print, trap`)
+
+	testCases := []struct {
+		name          string
+		opts          compileopts.Options
+		expectedError error
+	}{
+		{
+			name: "OptionsEmpty",
+			opts: compileopts.Options{},
+		},
+		{
+			name: "InvalidGCOption",
+			opts: compileopts.Options{
+				GC: "incorrect",
+			},
+			expectedError: expectedGCError,
+		},
+		{
+			name: "GCOptionNone",
+			opts: compileopts.Options{
+				GC: "none",
+			},
+		},
+		{
+			name: "GCOptionLeaking",
+			opts: compileopts.Options{
+				GC: "leaking",
+			},
+		},
+		{
+			name: "GCOptionExtalloc",
+			opts: compileopts.Options{
+				GC: "extalloc",
+			},
+		},
+		{
+			name: "GCOptionConservative",
+			opts: compileopts.Options{
+				GC: "conservative",
+			},
+		},
+		{
+			name: "InvalidSchedulerOption",
+			opts: compileopts.Options{
+				Scheduler: "incorrect",
+			},
+			expectedError: expectedSchedulerError,
+		},
+		{
+			name: "SchedulerOptionNone",
+			opts: compileopts.Options{
+				Scheduler: "none",
+			},
+		},
+		{
+			name: "SchedulerOptionTasks",
+			opts: compileopts.Options{
+				Scheduler: "tasks",
+			},
+		},
+		{
+			name: "SchedulerOptionCoroutines",
+			opts: compileopts.Options{
+				Scheduler: "coroutines",
+			},
+		},
+		{
+			name: "InvalidPrintSizeOption",
+			opts: compileopts.Options{
+				PrintSizes: "incorrect",
+			},
+			expectedError: expectedPrintSizeError,
+		},
+		{
+			name: "PrintSizeOptionNone",
+			opts: compileopts.Options{
+				PrintSizes: "none",
+			},
+		},
+		{
+			name: "PrintSizeOptionShort",
+			opts: compileopts.Options{
+				PrintSizes: "short",
+			},
+		},
+		{
+			name: "PrintSizeOptionFull",
+			opts: compileopts.Options{
+				PrintSizes: "full",
+			},
+		},
+		{
+			name: "InvalidPanicOption",
+			opts: compileopts.Options{
+				PanicStrategy: "incorrect",
+			},
+			expectedError: expectedPanicStrategyError,
+		},
+		{
+			name: "PanicOptionPrint",
+			opts: compileopts.Options{
+				PanicStrategy: "print",
+			},
+		},
+		{
+			name: "PanicOptionTrap",
+			opts: compileopts.Options{
+				PanicStrategy: "trap",
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			err := tc.opts.Verify()
+			if tc.expectedError != err {
+				if tc.expectedError.Error() != err.Error() {
+					t.Errorf("expected %v, got %v", tc.expectedError, err)
+				}
+			}
+		})
+	}
+}
@@ -8,6 +8,7 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"reflect"
 	"runtime"
 	"strings"

@@ -32,91 +33,71 @@ type TargetSpec struct {
 	Compiler         string   `json:"compiler"`
 	Linker           string   `json:"linker"`
 	RTLib            string   `json:"rtlib"` // compiler runtime library (libgcc, compiler-rt)
+	Libc             string   `json:"libc"`
+	AutoStackSize    *bool    `json:"automatic-stack-size"` // Determine stack size automatically at compile time.
+	DefaultStackSize uint64   `json:"default-stack-size"`   // Default stack size if the size couldn't be determined at compile time.
 	CFlags           []string `json:"cflags"`
 	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"`
 	FlashMethod      string   `json:"flash-method"`
 	FlashVolume      string   `json:"msd-volume-name"`
 	FlashFilename    string   `json:"msd-firmware-name"`
+	UF2FamilyID      string   `json:"uf2-family-id"`
+	BinaryFormat     string   `json:"binary-format"`
 	OpenOCDInterface string   `json:"openocd-interface"`
 	OpenOCDTarget    string   `json:"openocd-target"`
 	OpenOCDTransport string   `json:"openocd-transport"`
+	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
-	}
-	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.OpenOCDInterface != "" {
-		spec.OpenOCDInterface = spec2.OpenOCDInterface
-	}
-	if spec2.OpenOCDTarget != "" {
-		spec.OpenOCDTarget = spec2.OpenOCDTarget
-	}
-	if spec2.OpenOCDTransport != "" {
-		spec.OpenOCDTransport = spec2.OpenOCDTransport
+// 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()
+
+	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())
+		}
 	}
 }

@@ -165,11 +146,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
@@ -221,19 +202,29 @@ func LoadTarget(target string) (*TargetSpec, error) {
 		if len(tripleSplit) < 3 {
 			return nil, errors.New("expected a full LLVM target or a custom target in -target flag")
 		}
+		if tripleSplit[0] == "arm" {
+			// LLVM and Clang have a different idea of what "arm" means, so
+			// upgrade to a slightly more modern ARM. In fact, when you pass
+			// --target=arm--linux-gnueabihf to Clang, it will convert that
+			// internally to armv7-unknown-linux-gnueabihf. Changing the
+			// architecture to armv7 will keep things consistent.
+			tripleSplit[0] = "armv7"
+		}
 		goos := tripleSplit[2]
 		if strings.HasPrefix(goos, "darwin") {
 			goos = "darwin"
 		}
 		goarch := map[string]string{ // map from LLVM arch to Go arch
 			"i386":    "386",
+			"i686":    "386",
 			"x86_64":  "amd64",
 			"aarch64": "arm64",
+			"armv7":   "arm",
 		}[tripleSplit[0]]
 		if goarch == "" {
 			goarch = tripleSplit[0]
 		}
-		return defaultTarget(goos, goarch, target)
+		return defaultTarget(goos, goarch, strings.Join(tripleSplit, "-"))
 	}
 }

@@ -241,36 +232,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",
-		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
@@ -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)
+	}
+
+}
@@ -4,16 +4,19 @@ package compiler
 // required by the Go programming language.

 import (
+	"fmt"
+	"go/token"
 	"go/types"

+	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )

-// emitLookupBoundsCheck emits a bounds check before doing a lookup into a
+// createLookupBoundsCheck emits a bounds check before doing a lookup into a
 // slice. This is required by the Go language spec: an index out of bounds must
 // cause a panic.
-func (c *Compiler) emitLookupBoundsCheck(frame *Frame, arrayLen, index llvm.Value, indexType types.Type) {
-	if frame.fn.IsNoBounds() {
+func (b *builder) createLookupBoundsCheck(arrayLen, index llvm.Value, indexType types.Type) {
+	if b.fn.IsNoBounds() {
 		// The //go:nobounds pragma was added to the function to avoid bounds
 		// checking.
 		return
@@ -23,41 +26,29 @@ func (c *Compiler) emitLookupBoundsCheck(frame *Frame, arrayLen, index llvm.Valu
 		// Sometimes, the index can be e.g. an uint8 or int8, and we have to
 		// correctly extend that type.
 		if indexType.Underlying().(*types.Basic).Info()&types.IsUnsigned == 0 {
-			index = c.builder.CreateZExt(index, arrayLen.Type(), "")
+			index = b.CreateZExt(index, arrayLen.Type(), "")
 		} else {
-			index = c.builder.CreateSExt(index, arrayLen.Type(), "")
+			index = b.CreateSExt(index, arrayLen.Type(), "")
 		}
 	} else if index.Type().IntTypeWidth() > arrayLen.Type().IntTypeWidth() {
 		// The index is bigger than the array length type, so extend it.
-		arrayLen = c.builder.CreateZExt(arrayLen, index.Type(), "")
+		arrayLen = b.CreateZExt(arrayLen, index.Type(), "")
 	}

-	faultBlock := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "lookup.outofbounds")
-	nextBlock := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "lookup.next")
-	frame.blockExits[frame.currentBlock] = nextBlock // adjust outgoing block for phi nodes
-
 	// Now do the bounds check: index >= arrayLen
-	outOfBounds := c.builder.CreateICmp(llvm.IntUGE, index, arrayLen, "")
-	c.builder.CreateCondBr(outOfBounds, faultBlock, nextBlock)
-
-	// Fail: this is a nil pointer, exit with a panic.
-	c.builder.SetInsertPointAtEnd(faultBlock)
-	c.createRuntimeCall("lookupPanic", nil, "")
-	c.builder.CreateUnreachable()
-
-	// Ok: this is a valid pointer.
-	c.builder.SetInsertPointAtEnd(nextBlock)
+	outOfBounds := b.CreateICmp(llvm.IntUGE, index, arrayLen, "")
+	b.createRuntimeAssert(outOfBounds, "lookup", "lookupPanic")
 }

-// emitSliceBoundsCheck emits a bounds check before a slicing operation to make
+// createSliceBoundsCheck emits a bounds check before a slicing operation to make
 // sure it is within bounds.
 //
 // This function is both used for slicing a slice (low and high have their
 // normal meaning) and for creating a new slice, where 'capacity' means the
 // biggest possible slice capacity, 'low' means len and 'high' means cap. The
 // logic is the same in both cases.
-func (c *Compiler) emitSliceBoundsCheck(frame *Frame, capacity, low, high, max llvm.Value, lowType, highType, maxType *types.Basic) {
-	if frame.fn.IsNoBounds() {
+func (b *builder) createSliceBoundsCheck(capacity, low, high, max llvm.Value, lowType, highType, maxType *types.Basic) {
+	if b.fn.IsNoBounds() {
 		// The //go:nobounds pragma was added to the function to avoid bounds
 		// checking.
 		return
@@ -75,92 +66,164 @@ func (c *Compiler) emitSliceBoundsCheck(frame *Frame, capacity, low, high, max l
 		capacityType = max.Type()
 	}
 	if capacityType != capacity.Type() {
-		capacity = c.builder.CreateZExt(capacity, capacityType, "")
+		capacity = b.CreateZExt(capacity, capacityType, "")
 	}

 	// Extend low and high to be the same size as capacity.
 	if low.Type().IntTypeWidth() < capacityType.IntTypeWidth() {
 		if lowType.Info()&types.IsUnsigned != 0 {
-			low = c.builder.CreateZExt(low, capacityType, "")
+			low = b.CreateZExt(low, capacityType, "")
 		} else {
-			low = c.builder.CreateSExt(low, capacityType, "")
+			low = b.CreateSExt(low, capacityType, "")
 		}
 	}
 	if high.Type().IntTypeWidth() < capacityType.IntTypeWidth() {
 		if highType.Info()&types.IsUnsigned != 0 {
-			high = c.builder.CreateZExt(high, capacityType, "")
+			high = b.CreateZExt(high, capacityType, "")
 		} else {
-			high = c.builder.CreateSExt(high, capacityType, "")
+			high = b.CreateSExt(high, capacityType, "")
 		}
 	}
 	if max.Type().IntTypeWidth() < capacityType.IntTypeWidth() {
 		if maxType.Info()&types.IsUnsigned != 0 {
-			max = c.builder.CreateZExt(max, capacityType, "")
+			max = b.CreateZExt(max, capacityType, "")
 		} else {
-			max = c.builder.CreateSExt(max, capacityType, "")
+			max = b.CreateSExt(max, capacityType, "")
 		}
 	}

-	faultBlock := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "slice.outofbounds")
-	nextBlock := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "slice.next")
-	frame.blockExits[frame.currentBlock] = nextBlock // adjust outgoing block for phi nodes
-
 	// Now do the bounds check: low > high || high > capacity
-	outOfBounds1 := c.builder.CreateICmp(llvm.IntUGT, low, high, "slice.lowhigh")
-	outOfBounds2 := c.builder.CreateICmp(llvm.IntUGT, high, max, "slice.highmax")
-	outOfBounds3 := c.builder.CreateICmp(llvm.IntUGT, max, capacity, "slice.maxcap")
-	outOfBounds := c.builder.CreateOr(outOfBounds1, outOfBounds2, "slice.lowmax")
-	outOfBounds = c.builder.CreateOr(outOfBounds, outOfBounds3, "slice.lowcap")
-	c.builder.CreateCondBr(outOfBounds, faultBlock, nextBlock)
-
-	// Fail: this is a nil pointer, exit with a panic.
-	c.builder.SetInsertPointAtEnd(faultBlock)
-	c.createRuntimeCall("slicePanic", nil, "")
-	c.builder.CreateUnreachable()
-
-	// Ok: this is a valid pointer.
-	c.builder.SetInsertPointAtEnd(nextBlock)
+	outOfBounds1 := b.CreateICmp(llvm.IntUGT, low, high, "slice.lowhigh")
+	outOfBounds2 := b.CreateICmp(llvm.IntUGT, high, max, "slice.highmax")
+	outOfBounds3 := b.CreateICmp(llvm.IntUGT, max, capacity, "slice.maxcap")
+	outOfBounds := b.CreateOr(outOfBounds1, outOfBounds2, "slice.lowmax")
+	outOfBounds = b.CreateOr(outOfBounds, outOfBounds3, "slice.lowcap")
+	b.createRuntimeAssert(outOfBounds, "slice", "slicePanic")
 }

-// emitNilCheck checks whether the given pointer is nil, and panics if it is. It
-// has no effect in well-behaved programs, but makes sure no uncaught nil
+// 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() {
+		// The //go:nobounds pragma was added to the function to avoid bounds
+		// checking.
+		return
+	}
+
+	// Check whether the bufSize parameter must be cast to a wider integer for
+	// comparison.
+	if bufSize.Type().IntTypeWidth() < b.uintptrType.IntTypeWidth() {
+		if bufSizeType.Info()&types.IsUnsigned != 0 {
+			// Unsigned, so zero-extend to uint type.
+			bufSizeType = types.Typ[types.Uint]
+			bufSize = b.CreateZExt(bufSize, b.intType, "")
+		} else {
+			// Signed, so sign-extend to int type.
+			bufSizeType = types.Typ[types.Int]
+			bufSize = b.CreateSExt(bufSize, b.intType, "")
+		}
+	}
+
+	// Calculate (^uintptr(0)) >> 1, which is the max value that fits in an
+	// uintptr if uintptrs were signed.
+	maxBufSize := llvm.ConstLShr(llvm.ConstNot(llvm.ConstInt(b.uintptrType, 0, false)), llvm.ConstInt(b.uintptrType, 1, false))
+	if elementSize > maxBufSize.ZExtValue() {
+		b.addError(pos, fmt.Sprintf("channel element type is too big (%v bytes)", elementSize))
+		return
+	}
+	// Avoid divide-by-zero.
+	if elementSize == 0 {
+		elementSize = 1
+	}
+	// Make the maxBufSize actually the maximum allowed value (in number of
+	// elements in the channel buffer).
+	maxBufSize = llvm.ConstUDiv(maxBufSize, llvm.ConstInt(b.uintptrType, elementSize, false))
+
+	// Make sure maxBufSize has the same type as bufSize.
+	if maxBufSize.Type() != bufSize.Type() {
+		maxBufSize = llvm.ConstZExt(maxBufSize, bufSize.Type())
+	}
+
+	// Do the check for a too large (or negative) buffer size.
+	bufSizeTooBig := b.CreateICmp(llvm.IntUGE, bufSize, maxBufSize, "")
+	b.createRuntimeAssert(bufSizeTooBig, "chan", "chanMakePanic")
+}
+
+// createNilCheck checks whether the given pointer is nil, and panics if it is.
+// It has no effect in well-behaved programs, but makes sure no uncaught nil
 // pointer dereferences exist in valid Go code.
-func (c *Compiler) emitNilCheck(frame *Frame, ptr llvm.Value, blockPrefix string) {
+func (b *builder) createNilCheck(inst ssa.Value, ptr llvm.Value, blockPrefix string) {
 	// Check whether we need to emit this check at all.
 	if !ptr.IsAGlobalValue().IsNil() {
 		return
 	}

-	// Check whether this is a nil pointer.
-	faultBlock := c.ctx.AddBasicBlock(frame.fn.LLVMFn, blockPrefix+".nil")
-	nextBlock := c.ctx.AddBasicBlock(frame.fn.LLVMFn, blockPrefix+".next")
-	frame.blockExits[frame.currentBlock] = nextBlock // adjust outgoing block for phi nodes
+	switch inst := inst.(type) {
+	case *ssa.IndexAddr:
+		// This pointer is the result of an index operation into a slice or
+		// array. Such slices/arrays are already bounds checked so the pointer
+		// must be a valid (non-nil) pointer. No nil checking is necessary.
+		return
+	case *ssa.Convert:
+		// This is a pointer that comes from a conversion from unsafe.Pointer.
+		// Don't do nil checking because this is unsafe code and the code should
+		// know what it is doing.
+		// Note: all *ssa.Convert instructions that result in a pointer must
+		// come from unsafe.Pointer. Testing here for unsafe.Pointer to be sure.
+		if inst.X.Type() == types.Typ[types.UnsafePointer] {
+			return
+		}
+	}

 	// Compare against nil.
-	var isnil llvm.Value
-	if ptr.Type().PointerAddressSpace() == 0 {
-		// Do the nil check using the isnil builtin, which marks the parameter
-		// as nocapture.
-		// The reason it has to go through a builtin, is that a regular icmp
-		// instruction may capture the pointer in LLVM semantics, see
-		// https://reviews.llvm.org/D60047 for details. Pointer capturing
-		// unfortunately breaks escape analysis, so we use this trick to let the
-		// functionattr pass know that this pointer doesn't really escape.
-		ptr = c.builder.CreateBitCast(ptr, c.i8ptrType, "")
-		isnil = c.createRuntimeCall("isnil", []llvm.Value{ptr}, "")
-	} else {
-		// Do the nil check using a regular icmp. This can happen with function
-		// pointers on AVR, which don't benefit from escape analysis anyway.
-		nilptr := llvm.ConstPointerNull(ptr.Type())
-		isnil = c.builder.CreateICmp(llvm.IntEQ, ptr, nilptr, "")
-	}
-	c.builder.CreateCondBr(isnil, faultBlock, nextBlock)
+	// We previously used a hack to make sure this wouldn't break escape
+	// analysis, but this is not necessary anymore since
+	// https://reviews.llvm.org/D60047 has been merged.
+	nilptr := llvm.ConstPointerNull(ptr.Type())
+	isnil := b.CreateICmp(llvm.IntEQ, ptr, nilptr, "")

-	// Fail: this is a nil pointer, exit with a panic.
-	c.builder.SetInsertPointAtEnd(faultBlock)
-	c.createRuntimeCall("nilPanic", nil, "")
-	c.builder.CreateUnreachable()
-
-	// Ok: this is a valid pointer.
-	c.builder.SetInsertPointAtEnd(nextBlock)
+	// Emit the nil check in IR.
+	b.createRuntimeAssert(isnil, blockPrefix, "nilPanic")
+}
+
+// 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() {
+		// Function disabled bounds checking - skip shift check.
+		return
+	}
+
+	// isNegative = shift < 0
+	isNegative := b.CreateICmp(llvm.IntSLT, shift, llvm.ConstInt(shift.Type(), 0, false), "")
+	b.createRuntimeAssert(isNegative, "shift", "negativeShiftPanic")
+}
+
+// createRuntimeAssert is a common function to create a new branch on an assert
+// bool, calling an assert func if the assert value is true (1).
+func (b *builder) createRuntimeAssert(assert llvm.Value, blockPrefix, assertFunc string) {
+	// Check whether we can resolve this check at compile time.
+	if !assert.IsAConstantInt().IsNil() {
+		val := assert.ZExtValue()
+		if val == 0 {
+			// Everything is constant so the check does not have to be emitted
+			// in IR. This avoids emitting some redundant IR.
+			return
+		}
+	}
+
+	faultBlock := b.ctx.AddBasicBlock(b.fn.LLVMFn, blockPrefix+".throw")
+	nextBlock := b.ctx.AddBasicBlock(b.fn.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.
+	b.CreateCondBr(assert, faultBlock, nextBlock)
+
+	// Fail: the assert triggered so panic.
+	b.SetInsertPointAtEnd(faultBlock)
+	b.createRuntimeCall(assertFunc, nil, "")
+	b.CreateUnreachable()
+
+	// Ok: assert didn't trigger so continue normally.
+	b.SetInsertPointAtEnd(nextBlock)
 }
@@ -0,0 +1,57 @@
+package compiler
+
+import (
+	"golang.org/x/tools/go/ssa"
+	"tinygo.org/x/go-llvm"
+)
+
+// createAtomicOp lowers an atomic library call by lowering it as an LLVM atomic
+// operation. It returns the result of the operation and true if the call could
+// be lowered inline, and false otherwise.
+func (b *builder) createAtomicOp(call *ssa.CallCommon) (llvm.Value, bool) {
+	name := call.Value.(*ssa.Function).Name()
+	switch name {
+	case "AddInt32", "AddInt64", "AddUint32", "AddUint64", "AddUintptr":
+		ptr := b.getValue(call.Args[0])
+		val := b.getValue(call.Args[1])
+		oldVal := b.CreateAtomicRMW(llvm.AtomicRMWBinOpAdd, ptr, val, llvm.AtomicOrderingSequentiallyConsistent, true)
+		// Return the new value, not the original value returned by atomicrmw.
+		return b.CreateAdd(oldVal, val, ""), true
+	case "SwapInt32", "SwapInt64", "SwapUint32", "SwapUint64", "SwapUintptr", "SwapPointer":
+		ptr := b.getValue(call.Args[0])
+		val := b.getValue(call.Args[1])
+		isPointer := val.Type().TypeKind() == llvm.PointerTypeKind
+		if isPointer {
+			// atomicrmw only supports integers, so cast to an integer.
+			val = b.CreatePtrToInt(val, b.uintptrType, "")
+			ptr = b.CreateBitCast(ptr, llvm.PointerType(val.Type(), 0), "")
+		}
+		oldVal := b.CreateAtomicRMW(llvm.AtomicRMWBinOpXchg, ptr, val, llvm.AtomicOrderingSequentiallyConsistent, true)
+		if isPointer {
+			oldVal = b.CreateIntToPtr(oldVal, b.i8ptrType, "")
+		}
+		return oldVal, true
+	case "CompareAndSwapInt32", "CompareAndSwapInt64", "CompareAndSwapUint32", "CompareAndSwapUint64", "CompareAndSwapUintptr", "CompareAndSwapPointer":
+		ptr := b.getValue(call.Args[0])
+		old := b.getValue(call.Args[1])
+		newVal := b.getValue(call.Args[2])
+		tuple := b.CreateAtomicCmpXchg(ptr, old, newVal, llvm.AtomicOrderingSequentiallyConsistent, llvm.AtomicOrderingSequentiallyConsistent, true)
+		swapped := b.CreateExtractValue(tuple, 1, "")
+		return swapped, true
+	case "LoadInt32", "LoadInt64", "LoadUint32", "LoadUint64", "LoadUintptr", "LoadPointer":
+		ptr := b.getValue(call.Args[0])
+		val := b.CreateLoad(ptr, "")
+		val.SetOrdering(llvm.AtomicOrderingSequentiallyConsistent)
+		val.SetAlignment(b.targetData.PrefTypeAlignment(val.Type())) // required
+		return val, true
+	case "StoreInt32", "StoreInt64", "StoreUint32", "StoreUint64", "StoreUintptr", "StorePointer":
+		ptr := b.getValue(call.Args[0])
+		val := b.getValue(call.Args[1])
+		store := b.CreateStore(val, ptr)
+		store.SetOrdering(llvm.AtomicOrderingSequentiallyConsistent)
+		store.SetAlignment(b.targetData.PrefTypeAlignment(val.Type())) // required
+		return store, true
+	default:
+		return llvm.Value{}, false
+	}
+}
@@ -1,8 +1,9 @@
 package compiler

 import (
-	"fmt"
-	"golang.org/x/tools/go/ssa"
+	"go/types"
+	"strconv"
+
 	"tinygo.org/x/go-llvm"
 )

@@ -11,62 +12,80 @@ import (

 // The maximum number of arguments that can be expanded from a single struct. If
 // a struct contains more fields, it is passed as a struct without expanding.
-const MaxFieldsPerParam = 3
+const maxFieldsPerParam = 3

-// Shortcut: create a call to runtime.<fnName> with the given arguments.
-func (c *Compiler) createRuntimeCall(fnName string, args []llvm.Value, name string) llvm.Value {
-	runtimePkg := c.ir.Program.ImportedPackage("runtime")
-	member := runtimePkg.Members[fnName]
-	if member == nil {
-		panic("trying to call runtime." + fnName)
-	}
-	fn := c.ir.GetFunction(member.(*ssa.Function))
-	if fn.LLVMFn.IsNil() {
-		panic(fmt.Errorf("function %s does not appear in LLVM IR", fnName))
-	}
-	if !fn.IsExported() {
-		args = append(args, llvm.Undef(c.i8ptrType))            // unused context parameter
-		args = append(args, llvm.ConstPointerNull(c.i8ptrType)) // coroutine handle
-	}
-	return c.createCall(fn.LLVMFn, args, name)
+// paramInfo contains some information collected about a function parameter,
+// useful while declaring or defining a function.
+type paramInfo struct {
+	llvmType llvm.Type
+	name     string // name, possibly with suffixes for e.g. struct fields
+	flags    paramFlags
 }

-// Create a call to the given function with the arguments possibly expanded.
-func (c *Compiler) createCall(fn llvm.Value, args []llvm.Value, name string) llvm.Value {
+// paramFlags identifies parameter attributes for flags. Most importantly, it
+// determines which parameters are dereferenceable_or_null and which aren't.
+type paramFlags uint8
+
+const (
+	// Parameter may have the deferenceable_or_null attribute. This attribute
+	// cannot be applied to unsafe.Pointer and to the data pointer of slices.
+	paramIsDeferenceableOrNull = 1 << iota
+)
+
+// 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)
+	}
+	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)
+}
+
+// createCall creates a call to the given function with the arguments possibly
+// expanded.
+func (b *builder) createCall(fn llvm.Value, args []llvm.Value, name string) llvm.Value {
 	expanded := make([]llvm.Value, 0, len(args))
 	for _, arg := range args {
-		fragments := c.expandFormalParam(arg)
+		fragments := b.expandFormalParam(arg)
 		expanded = append(expanded, fragments...)
 	}
-	return c.builder.CreateCall(fn, expanded, name)
+	return b.CreateCall(fn, expanded, name)
 }

 // Expand an argument type to a list that can be used in a function call
 // parameter list.
-func (c *Compiler) expandFormalParamType(t llvm.Type) []llvm.Type {
+func expandFormalParamType(t llvm.Type, name string, goType types.Type) []paramInfo {
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
-		fields := c.flattenAggregateType(t)
-		if len(fields) <= MaxFieldsPerParam {
-			return fields
+		fieldInfos := flattenAggregateType(t, name, goType)
+		if len(fieldInfos) <= maxFieldsPerParam {
+			return fieldInfos
 		} else {
 			// failed to lower
-			return []llvm.Type{t}
 		}
-	default:
-		// TODO: split small arrays
-		return []llvm.Type{t}
+	}
+	// TODO: split small arrays
+	return []paramInfo{
+		{
+			llvmType: t,
+			name:     name,
+			flags:    getTypeFlags(goType),
+		},
 	}
 }

-// Expand an argument type to a list of offsets from the start of the object.
-// Used together with expandFormalParam to get the offset of each value from the
-// start of the non-expanded value.
-func (c *Compiler) expandFormalParamOffsets(t llvm.Type) []uint64 {
+// expandFormalParamOffsets returns a list of offsets from the start of an
+// object of type t after it would have been split up by expandFormalParam. This
+// is useful for debug information, where it is necessary to know the offset
+// from the start of the combined object.
+func (b *builder) expandFormalParamOffsets(t llvm.Type) []uint64 {
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
-		fields := c.flattenAggregateTypeOffsets(t)
-		if len(fields) <= MaxFieldsPerParam {
+		fields := b.flattenAggregateTypeOffsets(t)
+		if len(fields) <= maxFieldsPerParam {
 			return fields
 		} else {
 			// failed to lower
@@ -78,14 +97,17 @@ func (c *Compiler) expandFormalParamOffsets(t llvm.Type) []uint64 {
 	}
 }

-// Equivalent of expandFormalParamType for parameter values.
-func (c *Compiler) expandFormalParam(v llvm.Value) []llvm.Value {
+// expandFormalParam splits a formal param value into pieces, so it can be
+// passed directly as part of a function call. For example, it splits up small
+// structs into individual fields. It is the equivalent of expandFormalParamType
+// for parameter values.
+func (b *builder) expandFormalParam(v llvm.Value) []llvm.Value {
 	switch v.Type().TypeKind() {
 	case llvm.StructTypeKind:
-		fieldTypes := c.flattenAggregateType(v.Type())
-		if len(fieldTypes) <= MaxFieldsPerParam {
-			fields := c.flattenAggregate(v)
-			if len(fields) != len(fieldTypes) {
+		fieldInfos := flattenAggregateType(v.Type(), "", nil)
+		if len(fieldInfos) <= maxFieldsPerParam {
+			fields := b.flattenAggregate(v)
+			if len(fields) != len(fieldInfos) {
 				panic("type and value param lowering don't match")
 			}
 			return fields
@@ -101,24 +123,98 @@ func (c *Compiler) expandFormalParam(v llvm.Value) []llvm.Value {

 // Try to flatten a struct type to a list of types. Returns a 1-element slice
 // with the passed in type if this is not possible.
-func (c *Compiler) flattenAggregateType(t llvm.Type) []llvm.Type {
+func flattenAggregateType(t llvm.Type, name string, goType types.Type) []paramInfo {
+	typeFlags := getTypeFlags(goType)
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
-		fields := make([]llvm.Type, 0, t.StructElementTypesCount())
-		for _, subfield := range t.StructElementTypes() {
-			subfields := c.flattenAggregateType(subfield)
-			fields = append(fields, subfields...)
+		paramInfos := make([]paramInfo, 0, t.StructElementTypesCount())
+		for i, subfield := range t.StructElementTypes() {
+			suffix := strconv.Itoa(i)
+			if goType != nil {
+				// Try to come up with a good suffix for this struct field,
+				// depending on which Go type it's based on.
+				switch goType := goType.Underlying().(type) {
+				case *types.Interface:
+					suffix = []string{"typecode", "value"}[i]
+				case *types.Slice:
+					suffix = []string{"data", "len", "cap"}[i]
+				case *types.Struct:
+					suffix = goType.Field(i).Name()
+				case *types.Basic:
+					switch goType.Kind() {
+					case types.Complex64, types.Complex128:
+						suffix = []string{"r", "i"}[i]
+					case types.String:
+						suffix = []string{"data", "len"}[i]
+					}
+				case *types.Signature:
+					suffix = []string{"context", "funcptr"}[i]
+				}
+			}
+			subInfos := flattenAggregateType(subfield, name+"."+suffix, extractSubfield(goType, i))
+			for i := range subInfos {
+				subInfos[i].flags |= typeFlags
+			}
+			paramInfos = append(paramInfos, subInfos...)
 		}
-		return fields
+		return paramInfos
 	default:
-		return []llvm.Type{t}
+		return []paramInfo{
+			{
+				llvmType: t,
+				name:     name,
+				flags:    typeFlags,
+			},
+		}
 	}
 }

-// Return the offsets from the start of the object if this object type were
-// flattened like in flattenAggregate. Used together with flattenAggregate to
-// know the start indices of each value in the non-flattened object.
-func (c *Compiler) flattenAggregateTypeOffsets(t llvm.Type) []uint64 {
+// getTypeFlags returns the type flags for a given type. It will not recurse
+// into sub-types (such as in structs).
+func getTypeFlags(t types.Type) paramFlags {
+	if t == nil {
+		return 0
+	}
+	switch t.Underlying().(type) {
+	case *types.Pointer:
+		// Pointers in Go must either point to an object or be nil.
+		return paramIsDeferenceableOrNull
+	case *types.Chan, *types.Map:
+		// Channels and maps are implemented as pointers pointing to some
+		// object, and follow the same rules as *types.Pointer.
+		return paramIsDeferenceableOrNull
+	default:
+		return 0
+	}
+}
+
+// extractSubfield extracts a field from a struct, or returns null if this is
+// not a struct and thus no subfield can be obtained.
+func extractSubfield(t types.Type, field int) types.Type {
+	if t == nil {
+		return nil
+	}
+	switch t := t.Underlying().(type) {
+	case *types.Struct:
+		return t.Field(field).Type()
+	case *types.Interface, *types.Slice, *types.Basic, *types.Signature:
+		// These Go types are (sometimes) implemented as LLVM structs but can't
+		// really be split further up in Go (with the possible exception of
+		// complex numbers).
+		return nil
+	default:
+		// This should be unreachable.
+		panic("cannot split subfield: " + t.String())
+	}
+}
+
+// flattenAggregateTypeOffset returns the offsets from the start of an object of
+// type t if this object were flattened like in flattenAggregate. Used together
+// with flattenAggregate to know the start indices of each value in the
+// non-flattened object.
+//
+// Note: this is an implementation detail, use expandFormalParamOffsets instead.
+func (c *compilerContext) flattenAggregateTypeOffsets(t llvm.Type) []uint64 {
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
 		fields := make([]uint64, 0, t.StructElementTypesCount())
@@ -136,15 +232,15 @@ func (c *Compiler) flattenAggregateTypeOffsets(t llvm.Type) []uint64 {
 	}
 }

-// Break down a struct into its elementary types for argument passing. The value
-// equivalent of flattenAggregateType
-func (c *Compiler) flattenAggregate(v llvm.Value) []llvm.Value {
+// flattenAggregate breaks down a struct into its elementary values for argument
+// passing. It is the value equivalent of flattenAggregateType
+func (b *builder) flattenAggregate(v llvm.Value) []llvm.Value {
 	switch v.Type().TypeKind() {
 	case llvm.StructTypeKind:
 		fields := make([]llvm.Value, 0, v.Type().StructElementTypesCount())
 		for i := range v.Type().StructElementTypes() {
-			subfield := c.builder.CreateExtractValue(v, i, "")
-			subfields := c.flattenAggregate(subfield)
+			subfield := b.CreateExtractValue(v, i, "")
+			subfields := b.flattenAggregate(subfield)
 			fields = append(fields, subfields...)
 		}
 		return fields
@@ -153,25 +249,29 @@ func (c *Compiler) flattenAggregate(v llvm.Value) []llvm.Value {
 	}
 }

-// Collapse a list of fields into its original value.
-func (c *Compiler) collapseFormalParam(t llvm.Type, fields []llvm.Value) llvm.Value {
-	param, remaining := c.collapseFormalParamInternal(t, fields)
+// collapseFormalParam combines an aggregate object back into the original
+// value. This is used to join multiple LLVM parameters into a single Go value
+// in the function entry block.
+func (b *builder) collapseFormalParam(t llvm.Type, fields []llvm.Value) llvm.Value {
+	param, remaining := b.collapseFormalParamInternal(t, fields)
 	if len(remaining) != 0 {
 		panic("failed to expand back all fields")
 	}
 	return param
 }

-// Returns (value, remainingFields). Used by collapseFormalParam.
-func (c *Compiler) collapseFormalParamInternal(t llvm.Type, fields []llvm.Value) (llvm.Value, []llvm.Value) {
+// collapseFormalParamInternal is an implementation detail of
+// collapseFormalParam: it works by recursing until there are no fields left.
+func (b *builder) collapseFormalParamInternal(t llvm.Type, fields []llvm.Value) (llvm.Value, []llvm.Value) {
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
-		if len(c.flattenAggregateType(t)) <= MaxFieldsPerParam {
+		flattened := flattenAggregateType(t, "", nil)
+		if len(flattened) <= maxFieldsPerParam {
 			value := llvm.ConstNull(t)
 			for i, subtyp := range t.StructElementTypes() {
-				structField, remaining := c.collapseFormalParamInternal(subtyp, fields)
+				structField, remaining := b.collapseFormalParamInternal(subtyp, fields)
 				fields = remaining
-				value = c.builder.CreateInsertValue(value, structField, i, "")
+				value = b.CreateInsertValue(value, structField, i, "")
 			}
 			return value, fields
 		} else {
@@ -11,73 +11,89 @@ import (
 	"tinygo.org/x/go-llvm"
 )

-func (c *Compiler) emitMakeChan(frame *Frame, expr *ssa.MakeChan) llvm.Value {
-	elementSize := c.targetData.TypeAllocSize(c.getLLVMType(expr.Type().(*types.Chan).Elem()))
-	elementSizeValue := llvm.ConstInt(c.uintptrType, elementSize, false)
-	bufSize := c.getValue(frame, expr.Size)
-	return c.createRuntimeCall("chanMake", []llvm.Value{elementSizeValue, bufSize}, "")
+func (b *builder) createMakeChan(expr *ssa.MakeChan) llvm.Value {
+	elementSize := b.targetData.TypeAllocSize(b.getLLVMType(expr.Type().Underlying().(*types.Chan).Elem()))
+	elementSizeValue := llvm.ConstInt(b.uintptrType, elementSize, false)
+	bufSize := b.getValue(expr.Size)
+	b.createChanBoundsCheck(elementSize, bufSize, expr.Size.Type().Underlying().(*types.Basic), expr.Pos())
+	if bufSize.Type().IntTypeWidth() < b.uintptrType.IntTypeWidth() {
+		bufSize = b.CreateZExt(bufSize, b.uintptrType, "")
+	} else if bufSize.Type().IntTypeWidth() > b.uintptrType.IntTypeWidth() {
+		bufSize = b.CreateTrunc(bufSize, b.uintptrType, "")
+	}
+	return b.createRuntimeCall("chanMake", []llvm.Value{elementSizeValue, bufSize}, "")
 }

-// emitChanSend emits a pseudo chan send operation. It is lowered to the actual
-// channel send operation during goroutine lowering.
-func (c *Compiler) emitChanSend(frame *Frame, instr *ssa.Send) {
-	ch := c.getValue(frame, instr.Chan)
-	chanValue := c.getValue(frame, instr.X)
+// createChanSend emits a pseudo chan send operation. It is lowered to the
+// actual channel send operation during goroutine lowering.
+func (b *builder) createChanSend(instr *ssa.Send) {
+	ch := b.getValue(instr.Chan)
+	chanValue := b.getValue(instr.X)

 	// store value-to-send
-	valueType := c.getLLVMType(instr.X.Type())
-	valueAlloca, valueAllocaCast, valueAllocaSize := c.createTemporaryAlloca(valueType, "chan.value")
-	c.builder.CreateStore(chanValue, valueAlloca)
+	valueType := b.getLLVMType(instr.X.Type())
+	valueAlloca, valueAllocaCast, valueAllocaSize := b.createTemporaryAlloca(valueType, "chan.value")
+	b.CreateStore(chanValue, valueAlloca)
+
+	// Allocate blockedlist buffer.
+	channelBlockedList := b.mod.GetTypeByName("runtime.channelBlockedList")
+	channelBlockedListAlloca, channelBlockedListAllocaCast, channelBlockedListAllocaSize := b.createTemporaryAlloca(channelBlockedList, "chan.blockedList")

 	// Do the send.
-	c.createRuntimeCall("chanSend", []llvm.Value{ch, valueAllocaCast}, "")
+	b.createRuntimeCall("chanSend", []llvm.Value{ch, valueAllocaCast, channelBlockedListAlloca}, "")

-	// End the lifetime of the alloca.
+	// End the lifetime of the allocas.
 	// This also works around a bug in CoroSplit, at least in LLVM 8:
 	// https://bugs.llvm.org/show_bug.cgi?id=41742
-	c.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
+	b.emitLifetimeEnd(channelBlockedListAllocaCast, channelBlockedListAllocaSize)
+	b.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
 }

-// emitChanRecv emits a pseudo chan receive operation. It is lowered to the
+// createChanRecv emits a pseudo chan receive operation. It is lowered to the
 // actual channel receive operation during goroutine lowering.
-func (c *Compiler) emitChanRecv(frame *Frame, unop *ssa.UnOp) llvm.Value {
-	valueType := c.getLLVMType(unop.X.Type().(*types.Chan).Elem())
-	ch := c.getValue(frame, unop.X)
+func (b *builder) createChanRecv(unop *ssa.UnOp) llvm.Value {
+	valueType := b.getLLVMType(unop.X.Type().Underlying().(*types.Chan).Elem())
+	ch := b.getValue(unop.X)

 	// Allocate memory to receive into.
-	valueAlloca, valueAllocaCast, valueAllocaSize := c.createTemporaryAlloca(valueType, "chan.value")
+	valueAlloca, valueAllocaCast, valueAllocaSize := b.createTemporaryAlloca(valueType, "chan.value")
+
+	// Allocate blockedlist buffer.
+	channelBlockedList := b.mod.GetTypeByName("runtime.channelBlockedList")
+	channelBlockedListAlloca, channelBlockedListAllocaCast, channelBlockedListAllocaSize := b.createTemporaryAlloca(channelBlockedList, "chan.blockedList")

 	// Do the receive.
-	commaOk := c.createRuntimeCall("chanRecv", []llvm.Value{ch, valueAllocaCast}, "")
-	received := c.builder.CreateLoad(valueAlloca, "chan.received")
-	c.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
+	commaOk := b.createRuntimeCall("chanRecv", []llvm.Value{ch, valueAllocaCast, channelBlockedListAlloca}, "")
+	received := b.CreateLoad(valueAlloca, "chan.received")
+	b.emitLifetimeEnd(channelBlockedListAllocaCast, channelBlockedListAllocaSize)
+	b.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)

 	if unop.CommaOk {
-		tuple := llvm.Undef(c.ctx.StructType([]llvm.Type{valueType, c.ctx.Int1Type()}, false))
-		tuple = c.builder.CreateInsertValue(tuple, received, 0, "")
-		tuple = c.builder.CreateInsertValue(tuple, commaOk, 1, "")
+		tuple := llvm.Undef(b.ctx.StructType([]llvm.Type{valueType, b.ctx.Int1Type()}, false))
+		tuple = b.CreateInsertValue(tuple, received, 0, "")
+		tuple = b.CreateInsertValue(tuple, commaOk, 1, "")
 		return tuple
 	} else {
 		return received
 	}
 }

-// emitChanClose closes the given channel.
-func (c *Compiler) emitChanClose(frame *Frame, param ssa.Value) {
-	ch := c.getValue(frame, param)
-	c.createRuntimeCall("chanClose", []llvm.Value{ch}, "")
+// createChanClose closes the given channel.
+func (b *builder) createChanClose(param ssa.Value) {
+	ch := b.getValue(param)
+	b.createRuntimeCall("chanClose", []llvm.Value{ch}, "")
 }

-// emitSelect emits all IR necessary for a select statements. That's a
+// createSelect emits all IR necessary for a select statements. That's a
 // non-trivial amount of code because select is very complex to implement.
-func (c *Compiler) emitSelect(frame *Frame, expr *ssa.Select) llvm.Value {
+func (b *builder) createSelect(expr *ssa.Select) llvm.Value {
 	if len(expr.States) == 0 {
 		// Shortcuts for some simple selects.
-		llvmType := c.getLLVMType(expr.Type())
+		llvmType := b.getLLVMType(expr.Type())
 		if expr.Blocking {
 			// Blocks forever:
 			//     select {}
-			c.createRuntimeCall("deadlock", nil, "")
+			b.createRuntimeCall("deadlock", nil, "")
 			return llvm.Undef(llvmType)
 		} else {
 			// No-op:
@@ -85,7 +101,7 @@ func (c *Compiler) emitSelect(frame *Frame, expr *ssa.Select) llvm.Value {
 			//     default:
 			//     }
 			retval := llvm.Undef(llvmType)
-			retval = c.builder.CreateInsertValue(retval, llvm.ConstInt(c.intType, 0xffffffffffffffff, true), 0, "")
+			retval = b.CreateInsertValue(retval, llvm.ConstInt(b.intType, 0xffffffffffffffff, true), 0, "")
 			return retval // {-1, false}
 		}
 	}
@@ -103,30 +119,30 @@ func (c *Compiler) emitSelect(frame *Frame, expr *ssa.Select) llvm.Value {
 	recvbufAlign := 0
 	hasReceives := false
 	var selectStates []llvm.Value
-	chanSelectStateType := c.getLLVMRuntimeType("chanSelectState")
+	chanSelectStateType := b.getLLVMRuntimeType("chanSelectState")
 	for _, state := range expr.States {
-		ch := c.getValue(frame, state.Chan)
+		ch := b.getValue(state.Chan)
 		selectState := llvm.ConstNull(chanSelectStateType)
-		selectState = c.builder.CreateInsertValue(selectState, ch, 0, "")
+		selectState = b.CreateInsertValue(selectState, ch, 0, "")
 		switch state.Dir {
 		case types.RecvOnly:
 			// Make sure the receive buffer is big enough and has the correct alignment.
-			llvmType := c.getLLVMType(state.Chan.Type().(*types.Chan).Elem())
-			if size := c.targetData.TypeAllocSize(llvmType); size > recvbufSize {
+			llvmType := b.getLLVMType(state.Chan.Type().Underlying().(*types.Chan).Elem())
+			if size := b.targetData.TypeAllocSize(llvmType); size > recvbufSize {
 				recvbufSize = size
 			}
-			if align := c.targetData.ABITypeAlignment(llvmType); align > recvbufAlign {
+			if align := b.targetData.ABITypeAlignment(llvmType); align > recvbufAlign {
 				recvbufAlign = align
 			}
 			hasReceives = true
 		case types.SendOnly:
 			// Store this value in an alloca and put a pointer to this alloca
 			// in the send state.
-			sendValue := c.getValue(frame, state.Send)
-			alloca := llvmutil.CreateEntryBlockAlloca(c.builder, sendValue.Type(), "select.send.value")
-			c.builder.CreateStore(sendValue, alloca)
-			ptr := c.builder.CreateBitCast(alloca, c.i8ptrType, "")
-			selectState = c.builder.CreateInsertValue(selectState, ptr, 1, "")
+			sendValue := b.getValue(state.Send)
+			alloca := llvmutil.CreateEntryBlockAlloca(b.Builder, sendValue.Type(), "select.send.value")
+			b.CreateStore(sendValue, alloca)
+			ptr := b.CreateBitCast(alloca, b.i8ptrType, "")
+			selectState = b.CreateInsertValue(selectState, ptr, 1, "")
 		default:
 			panic("unreachable")
 		}
@@ -134,74 +150,74 @@ func (c *Compiler) emitSelect(frame *Frame, expr *ssa.Select) llvm.Value {
 	}

 	// Create a receive buffer, where the received value will be stored.
-	recvbuf := llvm.Undef(c.i8ptrType)
+	recvbuf := llvm.Undef(b.i8ptrType)
 	if hasReceives {
-		allocaType := llvm.ArrayType(c.ctx.Int8Type(), int(recvbufSize))
-		recvbufAlloca, _, _ := c.createTemporaryAlloca(allocaType, "select.recvbuf.alloca")
+		allocaType := llvm.ArrayType(b.ctx.Int8Type(), int(recvbufSize))
+		recvbufAlloca, _, _ := b.createTemporaryAlloca(allocaType, "select.recvbuf.alloca")
 		recvbufAlloca.SetAlignment(recvbufAlign)
-		recvbuf = c.builder.CreateGEP(recvbufAlloca, []llvm.Value{
-			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
-			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
+		recvbuf = b.CreateGEP(recvbufAlloca, []llvm.Value{
+			llvm.ConstInt(b.ctx.Int32Type(), 0, false),
+			llvm.ConstInt(b.ctx.Int32Type(), 0, false),
 		}, "select.recvbuf")
 	}

 	// Create the states slice (allocated on the stack).
 	statesAllocaType := llvm.ArrayType(chanSelectStateType, len(selectStates))
-	statesAlloca, statesI8, statesSize := c.createTemporaryAlloca(statesAllocaType, "select.states.alloca")
+	statesAlloca, statesI8, statesSize := b.createTemporaryAlloca(statesAllocaType, "select.states.alloca")
 	for i, state := range selectStates {
 		// Set each slice element to the appropriate channel.
-		gep := c.builder.CreateGEP(statesAlloca, []llvm.Value{
-			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
-			llvm.ConstInt(c.ctx.Int32Type(), uint64(i), false),
+		gep := b.CreateGEP(statesAlloca, []llvm.Value{
+			llvm.ConstInt(b.ctx.Int32Type(), 0, false),
+			llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false),
 		}, "")
-		c.builder.CreateStore(state, gep)
+		b.CreateStore(state, gep)
 	}
-	statesPtr := c.builder.CreateGEP(statesAlloca, []llvm.Value{
-		llvm.ConstInt(c.ctx.Int32Type(), 0, false),
-		llvm.ConstInt(c.ctx.Int32Type(), 0, false),
+	statesPtr := b.CreateGEP(statesAlloca, []llvm.Value{
+		llvm.ConstInt(b.ctx.Int32Type(), 0, false),
+		llvm.ConstInt(b.ctx.Int32Type(), 0, false),
 	}, "select.states")
-	statesLen := llvm.ConstInt(c.uintptrType, uint64(len(selectStates)), false)
+	statesLen := llvm.ConstInt(b.uintptrType, uint64(len(selectStates)), false)

 	// Do the select in the runtime.
 	var results llvm.Value
 	if expr.Blocking {
 		// Stack-allocate operation structures.
 		// If these were simply created as a slice, they would heap-allocate.
-		chBlockAllocaType := llvm.ArrayType(c.getLLVMRuntimeType("channelBlockedList"), len(selectStates))
-		chBlockAlloca, chBlockAllocaPtr, chBlockSize := c.createTemporaryAlloca(chBlockAllocaType, "select.block.alloca")
-		chBlockLen := llvm.ConstInt(c.uintptrType, uint64(len(selectStates)), false)
-		chBlockPtr := c.builder.CreateGEP(chBlockAlloca, []llvm.Value{
-			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
-			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
+		chBlockAllocaType := llvm.ArrayType(b.getLLVMRuntimeType("channelBlockedList"), len(selectStates))
+		chBlockAlloca, chBlockAllocaPtr, chBlockSize := b.createTemporaryAlloca(chBlockAllocaType, "select.block.alloca")
+		chBlockLen := llvm.ConstInt(b.uintptrType, uint64(len(selectStates)), false)
+		chBlockPtr := b.CreateGEP(chBlockAlloca, []llvm.Value{
+			llvm.ConstInt(b.ctx.Int32Type(), 0, false),
+			llvm.ConstInt(b.ctx.Int32Type(), 0, false),
 		}, "select.block")

-		results = c.createRuntimeCall("chanSelect", []llvm.Value{
+		results = b.createRuntimeCall("chanSelect", []llvm.Value{
 			recvbuf,
 			statesPtr, statesLen, statesLen, // []chanSelectState
 			chBlockPtr, chBlockLen, chBlockLen, // []channelBlockList
 		}, "select.result")

 		// Terminate the lifetime of the operation structures.
-		c.emitLifetimeEnd(chBlockAllocaPtr, chBlockSize)
+		b.emitLifetimeEnd(chBlockAllocaPtr, chBlockSize)
 	} else {
-		results = c.createRuntimeCall("tryChanSelect", []llvm.Value{
+		results = b.createRuntimeCall("tryChanSelect", []llvm.Value{
 			recvbuf,
 			statesPtr, statesLen, statesLen, // []chanSelectState
 		}, "select.result")
 	}

 	// Terminate the lifetime of the states alloca.
-	c.emitLifetimeEnd(statesI8, statesSize)
+	b.emitLifetimeEnd(statesI8, statesSize)

 	// The result value does not include all the possible received values,
 	// because we can't load them in advance. Instead, the *ssa.Extract
 	// instruction will treat a *ssa.Select specially and load it there inline.
 	// Store the receive alloca in a sidetable until we hit this extract
 	// instruction.
-	if frame.selectRecvBuf == nil {
-		frame.selectRecvBuf = make(map[*ssa.Select]llvm.Value)
+	if b.selectRecvBuf == nil {
+		b.selectRecvBuf = make(map[*ssa.Select]llvm.Value)
 	}
-	frame.selectRecvBuf[expr] = recvbuf
+	b.selectRecvBuf[expr] = recvbuf

 	return results
 }
@@ -210,28 +226,28 @@ func (c *Compiler) emitSelect(frame *Frame, expr *ssa.Select) llvm.Value {
 // when extracting a value from a select statement (*ssa.Select). Because
 // *ssa.Select cannot load all values in advance, it does this later in the
 // *ssa.Extract expression.
-func (c *Compiler) getChanSelectResult(frame *Frame, expr *ssa.Extract) llvm.Value {
+func (b *builder) getChanSelectResult(expr *ssa.Extract) llvm.Value {
 	if expr.Index == 0 {
 		// index
-		value := c.getValue(frame, expr.Tuple)
-		index := c.builder.CreateExtractValue(value, expr.Index, "")
-		if index.Type().IntTypeWidth() < c.intType.IntTypeWidth() {
-			index = c.builder.CreateSExt(index, c.intType, "")
+		value := b.getValue(expr.Tuple)
+		index := b.CreateExtractValue(value, expr.Index, "")
+		if index.Type().IntTypeWidth() < b.intType.IntTypeWidth() {
+			index = b.CreateSExt(index, b.intType, "")
 		}
 		return index
 	} else if expr.Index == 1 {
 		// comma-ok
-		value := c.getValue(frame, expr.Tuple)
-		return c.builder.CreateExtractValue(value, expr.Index, "")
+		value := b.getValue(expr.Tuple)
+		return b.CreateExtractValue(value, expr.Index, "")
 	} else {
 		// Select statements are (index, ok, ...) where ... is a number of
 		// received values, depending on how many receive statements there
 		// are. They are all combined into one alloca (because only one
 		// receive can proceed at a time) so we'll get that alloca, bitcast
 		// it to the correct type, and dereference it.
-		recvbuf := frame.selectRecvBuf[expr.Tuple.(*ssa.Select)]
-		typ := llvm.PointerType(c.getLLVMType(expr.Type()), 0)
-		ptr := c.builder.CreateBitCast(recvbuf, typ, "")
-		return c.builder.CreateLoad(ptr, "")
+		recvbuf := b.selectRecvBuf[expr.Tuple.(*ssa.Select)]
+		typ := llvm.PointerType(b.getLLVMType(expr.Type()), 0)
+		ptr := b.CreateBitCast(recvbuf, typ, "")
+		return b.CreateLoad(ptr, "")
 	}
 }
@@ -16,6 +16,7 @@ package compiler
 import (
 	"github.com/tinygo-org/tinygo/compiler/llvmutil"
 	"github.com/tinygo-org/tinygo/ir"
+	"go/types"
 	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )
@@ -23,16 +24,18 @@ import (
 // deferInitFunc sets up this function for future deferred calls. It must be
 // called from within the entry block when this function contains deferred
 // calls.
-func (c *Compiler) deferInitFunc(frame *Frame) {
+func (b *builder) deferInitFunc() {
 	// Some setup.
-	frame.deferFuncs = make(map[*ir.Function]int)
-	frame.deferInvokeFuncs = make(map[string]int)
-	frame.deferClosureFuncs = make(map[*ir.Function]int)
+	b.deferFuncs = make(map[*ir.Function]int)
+	b.deferInvokeFuncs = make(map[string]int)
+	b.deferClosureFuncs = make(map[*ir.Function]int)
+	b.deferExprFuncs = make(map[ssa.Value]int)
+	b.deferBuiltinFuncs = make(map[ssa.Value]deferBuiltin)

 	// Create defer list pointer.
-	deferType := llvm.PointerType(c.getLLVMRuntimeType("_defer"), 0)
-	frame.deferPtr = c.builder.CreateAlloca(deferType, "deferPtr")
-	c.builder.CreateStore(llvm.ConstPointerNull(deferType), frame.deferPtr)
+	deferType := llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0)
+	b.deferPtr = b.CreateAlloca(deferType, "deferPtr")
+	b.CreateStore(llvm.ConstPointerNull(deferType), b.deferPtr)
 }

 // isInLoop checks if there is a path from a basic block to itself.
@@ -69,53 +72,54 @@ func isInLoop(start *ssa.BasicBlock) bool {
 	return false
 }

-// emitDefer emits a single defer instruction, to be run when this function
+// createDefer emits a single defer instruction, to be run when this function
 // returns.
-func (c *Compiler) emitDefer(frame *Frame, instr *ssa.Defer) {
+func (b *builder) createDefer(instr *ssa.Defer) {
 	// The pointer to the previous defer struct, which we will replace to
 	// make a linked list.
-	next := c.builder.CreateLoad(frame.deferPtr, "defer.next")
+	next := b.CreateLoad(b.deferPtr, "defer.next")

 	var values []llvm.Value
-	valueTypes := []llvm.Type{c.uintptrType, next.Type()}
+	valueTypes := []llvm.Type{b.uintptrType, next.Type()}
 	if instr.Call.IsInvoke() {
 		// Method call on an interface.

 		// Get callback type number.
 		methodName := instr.Call.Method.FullName()
-		if _, ok := frame.deferInvokeFuncs[methodName]; !ok {
-			frame.deferInvokeFuncs[methodName] = len(frame.allDeferFuncs)
-			frame.allDeferFuncs = append(frame.allDeferFuncs, &instr.Call)
+		if _, ok := b.deferInvokeFuncs[methodName]; !ok {
+			b.deferInvokeFuncs[methodName] = len(b.allDeferFuncs)
+			b.allDeferFuncs = append(b.allDeferFuncs, &instr.Call)
 		}
-		callback := llvm.ConstInt(c.uintptrType, uint64(frame.deferInvokeFuncs[methodName]), false)
+		callback := llvm.ConstInt(b.uintptrType, uint64(b.deferInvokeFuncs[methodName]), false)

 		// Collect all values to be put in the struct (starting with
 		// runtime._defer fields, followed by the call parameters).
-		itf := c.getValue(frame, instr.Call.Value) // interface
-		receiverValue := c.builder.CreateExtractValue(itf, 1, "invoke.func.receiver")
-		values = []llvm.Value{callback, next, receiverValue}
-		valueTypes = append(valueTypes, c.i8ptrType)
+		itf := b.getValue(instr.Call.Value) // interface
+		typecode := b.CreateExtractValue(itf, 0, "invoke.func.typecode")
+		receiverValue := b.CreateExtractValue(itf, 1, "invoke.func.receiver")
+		values = []llvm.Value{callback, next, typecode, receiverValue}
+		valueTypes = append(valueTypes, b.uintptrType, b.i8ptrType)
 		for _, arg := range instr.Call.Args {
-			val := c.getValue(frame, arg)
+			val := b.getValue(arg)
 			values = append(values, val)
 			valueTypes = append(valueTypes, val.Type())
 		}

 	} else if callee, ok := instr.Call.Value.(*ssa.Function); ok {
 		// Regular function call.
-		fn := c.ir.GetFunction(callee)
+		fn := b.ir.GetFunction(callee)

-		if _, ok := frame.deferFuncs[fn]; !ok {
-			frame.deferFuncs[fn] = len(frame.allDeferFuncs)
-			frame.allDeferFuncs = append(frame.allDeferFuncs, fn)
+		if _, ok := b.deferFuncs[fn]; !ok {
+			b.deferFuncs[fn] = len(b.allDeferFuncs)
+			b.allDeferFuncs = append(b.allDeferFuncs, fn)
 		}
-		callback := llvm.ConstInt(c.uintptrType, uint64(frame.deferFuncs[fn]), false)
+		callback := llvm.ConstInt(b.uintptrType, uint64(b.deferFuncs[fn]), false)

 		// 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 := c.getValue(frame, param)
+			llvmParam := b.getValue(param)
 			values = append(values, llvmParam)
 			valueTypes = append(valueTypes, llvmParam.Type())
 		}
@@ -127,65 +131,110 @@ func (c *Compiler) emitDefer(frame *Frame, instr *ssa.Defer) {
 		// pointer.
 		// TODO: ignore this closure entirely and put pointers to the free
 		// variables directly in the defer struct, avoiding a memory allocation.
-		closure := c.getValue(frame, instr.Call.Value)
-		context := c.builder.CreateExtractValue(closure, 0, "")
+		closure := b.getValue(instr.Call.Value)
+		context := b.CreateExtractValue(closure, 0, "")

 		// Get the callback number.
-		fn := c.ir.GetFunction(makeClosure.Fn.(*ssa.Function))
-		if _, ok := frame.deferClosureFuncs[fn]; !ok {
-			frame.deferClosureFuncs[fn] = len(frame.allDeferFuncs)
-			frame.allDeferFuncs = append(frame.allDeferFuncs, makeClosure)
+		fn := b.ir.GetFunction(makeClosure.Fn.(*ssa.Function))
+		if _, ok := b.deferClosureFuncs[fn]; !ok {
+			b.deferClosureFuncs[fn] = len(b.allDeferFuncs)
+			b.allDeferFuncs = append(b.allDeferFuncs, makeClosure)
 		}
-		callback := llvm.ConstInt(c.uintptrType, uint64(frame.deferClosureFuncs[fn]), false)
+		callback := llvm.ConstInt(b.uintptrType, uint64(b.deferClosureFuncs[fn]), false)

 		// Collect all values to be put in the struct (starting with
 		// runtime._defer fields, followed by all parameters including the
 		// context pointer).
 		values = []llvm.Value{callback, next}
 		for _, param := range instr.Call.Args {
-			llvmParam := c.getValue(frame, param)
+			llvmParam := b.getValue(param)
 			values = append(values, llvmParam)
 			valueTypes = append(valueTypes, llvmParam.Type())
 		}
 		values = append(values, context)
 		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
+		}
+
+		if _, ok := b.deferBuiltinFuncs[instr.Call.Value]; !ok {
+			b.deferBuiltinFuncs[instr.Call.Value] = deferBuiltin{
+				funcName,
+				len(b.allDeferFuncs),
+			}
+			b.allDeferFuncs = append(b.allDeferFuncs, instr.Call.Value)
+		}
+		callback := llvm.ConstInt(b.uintptrType, uint64(b.deferBuiltinFuncs[instr.Call.Value].callback), false)
+
+		// 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())
+		}
+
 	} else {
-		c.addError(instr.Pos(), "todo: defer on uncommon function call type")
-		return
+		funcValue := b.getValue(instr.Call.Value)
+
+		if _, ok := b.deferExprFuncs[instr.Call.Value]; !ok {
+			b.deferExprFuncs[instr.Call.Value] = len(b.allDeferFuncs)
+			b.allDeferFuncs = append(b.allDeferFuncs, &instr.Call)
+		}
+
+		callback := llvm.ConstInt(b.uintptrType, uint64(b.deferExprFuncs[instr.Call.Value]), false)
+
+		// Collect all values to be put in the struct (starting with
+		// runtime._defer fields, followed by all parameters including the
+		// context pointer).
+		values = []llvm.Value{callback, next, funcValue}
+		valueTypes = append(valueTypes, funcValue.Type())
+		for _, param := range instr.Call.Args {
+			llvmParam := b.getValue(param)
+			values = append(values, llvmParam)
+			valueTypes = append(valueTypes, llvmParam.Type())
+		}
 	}

 	// Make a struct out of the collected values to put in the defer frame.
-	deferFrameType := c.ctx.StructType(valueTypes, false)
+	deferFrameType := b.ctx.StructType(valueTypes, false)
 	deferFrame := llvm.ConstNull(deferFrameType)
 	for i, value := range values {
-		deferFrame = c.builder.CreateInsertValue(deferFrame, value, i, "")
+		deferFrame = b.CreateInsertValue(deferFrame, value, i, "")
 	}

 	// Put this struct in an allocation.
 	var alloca llvm.Value
 	if !isInLoop(instr.Block()) {
 		// This can safely use a stack allocation.
-		alloca = llvmutil.CreateEntryBlockAlloca(c.builder, deferFrameType, "defer.alloca")
+		alloca = llvmutil.CreateEntryBlockAlloca(b.Builder, deferFrameType, "defer.alloca")
 	} else {
 		// This may be hit a variable number of times, so use a heap allocation.
-		size := c.targetData.TypeAllocSize(deferFrameType)
-		sizeValue := llvm.ConstInt(c.uintptrType, size, false)
-		allocCall := c.createRuntimeCall("alloc", []llvm.Value{sizeValue}, "defer.alloc.call")
-		alloca = c.builder.CreateBitCast(allocCall, llvm.PointerType(deferFrameType, 0), "defer.alloc")
+		size := b.targetData.TypeAllocSize(deferFrameType)
+		sizeValue := llvm.ConstInt(b.uintptrType, size, false)
+		allocCall := b.createRuntimeCall("alloc", []llvm.Value{sizeValue}, "defer.alloc.call")
+		alloca = b.CreateBitCast(allocCall, llvm.PointerType(deferFrameType, 0), "defer.alloc")
 	}
-	if c.NeedsStackObjects() {
-		c.trackPointer(alloca)
+	if b.NeedsStackObjects() {
+		b.trackPointer(alloca)
 	}
-	c.builder.CreateStore(deferFrame, alloca)
+	b.CreateStore(deferFrame, alloca)

 	// Push it on top of the linked list by replacing deferPtr.
-	allocaCast := c.builder.CreateBitCast(alloca, next.Type(), "defer.alloca.cast")
-	c.builder.CreateStore(allocaCast, frame.deferPtr)
+	allocaCast := b.CreateBitCast(alloca, next.Type(), "defer.alloca.cast")
+	b.CreateStore(allocaCast, b.deferPtr)
 }

-// emitRunDefers emits code to run all deferred functions.
-func (c *Compiler) emitRunDefers(frame *Frame) {
+// createRunDefers emits code to run all deferred functions.
+func (b *builder) createRunDefers() {
 	// Add a loop like the following:
 	//     for stack != nil {
 	//         _stack := stack
@@ -202,151 +251,205 @@ func (c *Compiler) emitRunDefers(frame *Frame) {
 	//     }

 	// Create loop.
-	loophead := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "rundefers.loophead")
-	loop := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "rundefers.loop")
-	unreachable := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "rundefers.default")
-	end := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "rundefers.end")
-	c.builder.CreateBr(loophead)
+	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")
+	b.CreateBr(loophead)

 	// Create loop head:
 	//     for stack != nil {
-	c.builder.SetInsertPointAtEnd(loophead)
-	deferData := c.builder.CreateLoad(frame.deferPtr, "")
-	stackIsNil := c.builder.CreateICmp(llvm.IntEQ, deferData, llvm.ConstPointerNull(deferData.Type()), "stackIsNil")
-	c.builder.CreateCondBr(stackIsNil, end, loop)
+	b.SetInsertPointAtEnd(loophead)
+	deferData := b.CreateLoad(b.deferPtr, "")
+	stackIsNil := b.CreateICmp(llvm.IntEQ, deferData, llvm.ConstPointerNull(deferData.Type()), "stackIsNil")
+	b.CreateCondBr(stackIsNil, end, loop)

 	// Create loop body:
 	//     _stack := stack
 	//     stack = stack.next
 	//     switch stack.callback {
-	c.builder.SetInsertPointAtEnd(loop)
-	nextStackGEP := c.builder.CreateInBoundsGEP(deferData, []llvm.Value{
-		llvm.ConstInt(c.ctx.Int32Type(), 0, false),
-		llvm.ConstInt(c.ctx.Int32Type(), 1, false), // .next field
+	b.SetInsertPointAtEnd(loop)
+	nextStackGEP := b.CreateInBoundsGEP(deferData, []llvm.Value{
+		llvm.ConstInt(b.ctx.Int32Type(), 0, false),
+		llvm.ConstInt(b.ctx.Int32Type(), 1, false), // .next field
 	}, "stack.next.gep")
-	nextStack := c.builder.CreateLoad(nextStackGEP, "stack.next")
-	c.builder.CreateStore(nextStack, frame.deferPtr)
-	gep := c.builder.CreateInBoundsGEP(deferData, []llvm.Value{
-		llvm.ConstInt(c.ctx.Int32Type(), 0, false),
-		llvm.ConstInt(c.ctx.Int32Type(), 0, false), // .callback field
+	nextStack := b.CreateLoad(nextStackGEP, "stack.next")
+	b.CreateStore(nextStack, b.deferPtr)
+	gep := b.CreateInBoundsGEP(deferData, []llvm.Value{
+		llvm.ConstInt(b.ctx.Int32Type(), 0, false),
+		llvm.ConstInt(b.ctx.Int32Type(), 0, false), // .callback field
 	}, "callback.gep")
-	callback := c.builder.CreateLoad(gep, "callback")
-	sw := c.builder.CreateSwitch(callback, unreachable, len(frame.allDeferFuncs))
+	callback := b.CreateLoad(gep, "callback")
+	sw := b.CreateSwitch(callback, unreachable, len(b.allDeferFuncs))

-	for i, callback := range frame.allDeferFuncs {
+	for i, callback := range b.allDeferFuncs {
 		// Create switch case, for example:
 		//     case 0:
 		//         // run first deferred call
-		block := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "rundefers.callback")
-		sw.AddCase(llvm.ConstInt(c.uintptrType, uint64(i), false), block)
-		c.builder.SetInsertPointAtEnd(block)
+		block := b.ctx.AddBasicBlock(b.fn.LLVMFn, "rundefers.callback")
+		sw.AddCase(llvm.ConstInt(b.uintptrType, uint64(i), false), block)
+		b.SetInsertPointAtEnd(block)
 		switch callback := callback.(type) {
 		case *ssa.CallCommon:
-			// Call on an interface value.
-			if !callback.IsInvoke() {
-				panic("expected an invoke call, not a direct call")
-			}
+			// Call on an value or interface value.

 			// Get the real defer struct type and cast to it.
-			valueTypes := []llvm.Type{c.uintptrType, llvm.PointerType(c.getLLVMRuntimeType("_defer"), 0), c.i8ptrType}
-			for _, arg := range callback.Args {
-				valueTypes = append(valueTypes, c.getLLVMType(arg.Type()))
+			valueTypes := []llvm.Type{b.uintptrType, llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0)}
+
+			if !callback.IsInvoke() {
+				//Expect funcValue to be passed through the defer frame.
+				valueTypes = append(valueTypes, b.getFuncType(callback.Signature()))
+			} else {
+				//Expect typecode
+				valueTypes = append(valueTypes, b.uintptrType, b.i8ptrType)
 			}
-			deferFrameType := c.ctx.StructType(valueTypes, false)
-			deferFramePtr := c.builder.CreateBitCast(deferData, llvm.PointerType(deferFrameType, 0), "deferFrame")
+
+			for _, arg := range callback.Args {
+				valueTypes = append(valueTypes, b.getLLVMType(arg.Type()))
+			}
+
+			deferFrameType := b.ctx.StructType(valueTypes, false)
+			deferFramePtr := b.CreateBitCast(deferData, llvm.PointerType(deferFrameType, 0), "deferFrame")

 			// Extract the params from the struct (including receiver).
 			forwardParams := []llvm.Value{}
-			zero := llvm.ConstInt(c.ctx.Int32Type(), 0, false)
+			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
 			for i := 2; i < len(valueTypes); i++ {
-				gep := c.builder.CreateInBoundsGEP(deferFramePtr, []llvm.Value{zero, llvm.ConstInt(c.ctx.Int32Type(), uint64(i), false)}, "gep")
-				forwardParam := c.builder.CreateLoad(gep, "param")
+				gep := b.CreateInBoundsGEP(deferFramePtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false)}, "gep")
+				forwardParam := b.CreateLoad(gep, "param")
 				forwardParams = append(forwardParams, forwardParam)
 			}

-			// Add the context parameter. An interface call cannot also be a
-			// closure but we have to supply the parameter anyway for platforms
-			// with a strict calling convention.
-			forwardParams = append(forwardParams, llvm.Undef(c.i8ptrType))
+			var fnPtr llvm.Value
+
+			if !callback.IsInvoke() {
+				// Isolate the func value.
+				funcValue := forwardParams[0]
+				forwardParams = forwardParams[1:]
+
+				//Get function pointer and context
+				fp, context := b.decodeFuncValue(funcValue, callback.Signature())
+				fnPtr = fp
+
+				//Pass context
+				forwardParams = append(forwardParams, context)
+			} else {
+				// Isolate the typecode.
+				typecode := forwardParams[0]
+				forwardParams = forwardParams[1:]
+				fnPtr = b.getInvokePtr(callback, typecode)
+
+				// Add the context parameter. An interface call cannot also be a
+				// closure but we have to supply the parameter anyway for platforms
+				// with a strict calling convention.
+				forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))
+			}

 			// Parent coroutine handle.
-			forwardParams = append(forwardParams, llvm.Undef(c.i8ptrType))
+			forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))

-			fnPtr, _ := c.getInvokeCall(frame, callback)
-			c.createCall(fnPtr, forwardParams, "")
+			b.createCall(fnPtr, forwardParams, "")

 		case *ir.Function:
 			// Direct call.

 			// Get the real defer struct type and cast to it.
-			valueTypes := []llvm.Type{c.uintptrType, llvm.PointerType(c.getLLVMRuntimeType("_defer"), 0)}
+			valueTypes := []llvm.Type{b.uintptrType, llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0)}
 			for _, param := range callback.Params {
-				valueTypes = append(valueTypes, c.getLLVMType(param.Type()))
+				valueTypes = append(valueTypes, b.getLLVMType(param.Type()))
 			}
-			deferFrameType := c.ctx.StructType(valueTypes, false)
-			deferFramePtr := c.builder.CreateBitCast(deferData, llvm.PointerType(deferFrameType, 0), "deferFrame")
+			deferFrameType := b.ctx.StructType(valueTypes, false)
+			deferFramePtr := b.CreateBitCast(deferData, llvm.PointerType(deferFrameType, 0), "deferFrame")

 			// Extract the params from the struct.
 			forwardParams := []llvm.Value{}
-			zero := llvm.ConstInt(c.ctx.Int32Type(), 0, false)
+			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
 			for i := range callback.Params {
-				gep := c.builder.CreateInBoundsGEP(deferFramePtr, []llvm.Value{zero, llvm.ConstInt(c.ctx.Int32Type(), uint64(i+2), false)}, "gep")
-				forwardParam := c.builder.CreateLoad(gep, "param")
+				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)
 			}

-			// 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(c.i8ptrType))
+			// 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() {
+				// 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))

-			// Parent coroutine handle.
-			forwardParams = append(forwardParams, llvm.Undef(c.i8ptrType))
+				// Parent coroutine handle.
+				forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))
+			}

 			// Call real function.
-			c.createCall(callback.LLVMFn, forwardParams, "")
+			b.createCall(callback.LLVMFn, forwardParams, "")

 		case *ssa.MakeClosure:
 			// Get the real defer struct type and cast to it.
-			fn := c.ir.GetFunction(callback.Fn.(*ssa.Function))
-			valueTypes := []llvm.Type{c.uintptrType, llvm.PointerType(c.getLLVMRuntimeType("_defer"), 0)}
+			fn := b.ir.GetFunction(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++ {
-				valueTypes = append(valueTypes, c.getLLVMType(params.At(i).Type()))
+				valueTypes = append(valueTypes, b.getLLVMType(params.At(i).Type()))
 			}
-			valueTypes = append(valueTypes, c.i8ptrType) // closure
-			deferFrameType := c.ctx.StructType(valueTypes, false)
-			deferFramePtr := c.builder.CreateBitCast(deferData, llvm.PointerType(deferFrameType, 0), "deferFrame")
+			valueTypes = append(valueTypes, b.i8ptrType) // closure
+			deferFrameType := b.ctx.StructType(valueTypes, false)
+			deferFramePtr := b.CreateBitCast(deferData, llvm.PointerType(deferFrameType, 0), "deferFrame")

 			// Extract the params from the struct.
 			forwardParams := []llvm.Value{}
-			zero := llvm.ConstInt(c.ctx.Int32Type(), 0, false)
+			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
 			for i := 2; i < len(valueTypes); i++ {
-				gep := c.builder.CreateInBoundsGEP(deferFramePtr, []llvm.Value{zero, llvm.ConstInt(c.ctx.Int32Type(), uint64(i), false)}, "")
-				forwardParam := c.builder.CreateLoad(gep, "param")
+				gep := b.CreateInBoundsGEP(deferFramePtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false)}, "")
+				forwardParam := b.CreateLoad(gep, "param")
 				forwardParams = append(forwardParams, forwardParam)
 			}

 			// Parent coroutine handle.
-			forwardParams = append(forwardParams, llvm.Undef(c.i8ptrType))
+			forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))

 			// Call deferred function.
-			c.createCall(fn.LLVMFn, forwardParams, "")
+			b.createCall(fn.LLVMFn, forwardParams, "")
+		case *ssa.Builtin:
+			db := b.deferBuiltinFuncs[callback]

+			//Get parameter types
+			valueTypes := []llvm.Type{b.uintptrType, llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0)}
+
+			//Get signature from call results
+			params := callback.Type().Underlying().(*types.Signature).Params()
+			for i := 0; i < params.Len(); i++ {
+				valueTypes = append(valueTypes, b.getLLVMType(params.At(i).Type()))
+			}
+
+			deferFrameType := b.ctx.StructType(valueTypes, false)
+			deferFramePtr := b.CreateBitCast(deferData, llvm.PointerType(deferFrameType, 0), "deferFrame")
+
+			// Extract the params from the struct.
+			var forwardParams []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)
+			}
+
+			b.createRuntimeCall(db.funcName, forwardParams, "")
 		default:
 			panic("unknown deferred function type")
 		}

 		// Branch back to the start of the loop.
-		c.builder.CreateBr(loophead)
+		b.CreateBr(loophead)
 	}

 	// Create default unreachable block:
 	//     default:
 	//         unreachable
 	//     }
-	c.builder.SetInsertPointAtEnd(unreachable)
-	c.builder.CreateUnreachable()
+	b.SetInsertPointAtEnd(unreachable)
+	b.CreateUnreachable()

 	// End of loop.
-	c.builder.SetInsertPointAtEnd(end)
+	b.SetInsertPointAtEnd(end)
 }
@@ -1,5 +1,7 @@
 package compiler

+// This file contains some utility functions related to error handling.
+
 import (
 	"go/scanner"
 	"go/token"
@@ -9,7 +11,8 @@ import (
 	"tinygo.org/x/go-llvm"
 )

-func (c *Compiler) makeError(pos token.Pos, msg string) types.Error {
+// 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,
 		Pos:  pos,
@@ -17,7 +20,7 @@ func (c *Compiler) makeError(pos token.Pos, msg string) types.Error {
 	}
 }

-func (c *Compiler) addError(pos token.Pos, msg string) {
+func (c *compilerContext) addError(pos token.Pos, msg string) {
 	c.diagnostics = append(c.diagnostics, c.makeError(pos, msg))
 }

@@ -6,53 +6,26 @@ package compiler
 import (
 	"go/types"

+	"github.com/tinygo-org/tinygo/compileopts"
 	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )

-type funcValueImplementation int
-
-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
-)
-
-// funcImplementation picks an appropriate func value implementation for the
-// target.
-func (c *Compiler) funcImplementation() funcValueImplementation {
-	// Always pick the switch implementation, as it allows the use of blocking
-	// inside a function that is used as a func value.
-	switch c.Scheduler() {
-	case "coroutines":
-		return funcValueSwitch
-	case "tasks":
-		return funcValueDoubleword
-	default:
-		panic("unknown scheduler type")
-	}
+// createFuncValue creates a function value from a raw function pointer with no
+// context.
+func (b *builder) createFuncValue(funcPtr, context llvm.Value, sig *types.Signature) llvm.Value {
+	return b.compilerContext.createFuncValue(b.Builder, funcPtr, context, sig)
 }

 // createFuncValue creates a function value from a raw function pointer with no
 // context.
-func (c *Compiler) createFuncValue(funcPtr, context llvm.Value, sig *types.Signature) llvm.Value {
+func (c *compilerContext) createFuncValue(builder llvm.Builder, funcPtr, context llvm.Value, sig *types.Signature) llvm.Value {
 	var funcValueScalar llvm.Value
-	switch c.funcImplementation() {
-	case funcValueDoubleword:
+	switch c.FuncImplementation() {
+	case compileopts.FuncValueDoubleword:
 		// Closure is: {context, function pointer}
 		funcValueScalar = funcPtr
-	case funcValueSwitch:
+	case compileopts.FuncValueSwitch:
 		sigGlobal := c.getTypeCode(sig)
 		funcValueWithSignatureGlobalName := funcPtr.Name() + "$withSignature"
 		funcValueWithSignatureGlobal := c.mod.NamedGlobal(funcValueWithSignatureGlobalName)
@@ -73,35 +46,35 @@ func (c *Compiler) createFuncValue(funcPtr, context llvm.Value, sig *types.Signa
 	}
 	funcValueType := c.getFuncType(sig)
 	funcValue := llvm.Undef(funcValueType)
-	funcValue = c.builder.CreateInsertValue(funcValue, context, 0, "")
-	funcValue = c.builder.CreateInsertValue(funcValue, funcValueScalar, 1, "")
+	funcValue = builder.CreateInsertValue(funcValue, context, 0, "")
+	funcValue = builder.CreateInsertValue(funcValue, funcValueScalar, 1, "")
 	return funcValue
 }

 // extractFuncScalar returns some scalar that can be used in comparisons. It is
 // a cheap operation.
-func (c *Compiler) extractFuncScalar(funcValue llvm.Value) llvm.Value {
-	return c.builder.CreateExtractValue(funcValue, 1, "")
+func (b *builder) extractFuncScalar(funcValue llvm.Value) llvm.Value {
+	return b.CreateExtractValue(funcValue, 1, "")
 }

 // extractFuncContext extracts the context pointer from this function value. It
 // is a cheap operation.
-func (c *Compiler) extractFuncContext(funcValue llvm.Value) llvm.Value {
-	return c.builder.CreateExtractValue(funcValue, 0, "")
+func (b *builder) extractFuncContext(funcValue llvm.Value) llvm.Value {
+	return b.CreateExtractValue(funcValue, 0, "")
 }

 // decodeFuncValue extracts the context and the function pointer from this func
 // value. This may be an expensive operation.
-func (c *Compiler) decodeFuncValue(funcValue llvm.Value, sig *types.Signature) (funcPtr, context llvm.Value) {
-	context = c.builder.CreateExtractValue(funcValue, 0, "")
-	switch c.funcImplementation() {
-	case funcValueDoubleword:
-		funcPtr = c.builder.CreateExtractValue(funcValue, 1, "")
-	case funcValueSwitch:
-		llvmSig := c.getRawFuncType(sig)
-		sigGlobal := c.getTypeCode(sig)
-		funcPtr = c.createRuntimeCall("getFuncPtr", []llvm.Value{funcValue, sigGlobal}, "")
-		funcPtr = c.builder.CreateIntToPtr(funcPtr, llvmSig, "")
+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:
+		funcPtr = b.CreateExtractValue(funcValue, 1, "")
+	case compileopts.FuncValueSwitch:
+		llvmSig := b.getRawFuncType(sig)
+		sigGlobal := b.getTypeCode(sig)
+		funcPtr = b.createRuntimeCall("getFuncPtr", []llvm.Value{funcValue, sigGlobal}, "")
+		funcPtr = b.CreateIntToPtr(funcPtr, llvmSig, "")
 	default:
 		panic("unimplemented func value variant")
 	}
@@ -109,12 +82,12 @@ func (c *Compiler) decodeFuncValue(funcValue llvm.Value, sig *types.Signature) (
 }

 // getFuncType returns the type of a func value given a signature.
-func (c *Compiler) getFuncType(typ *types.Signature) llvm.Type {
-	switch c.funcImplementation() {
-	case funcValueDoubleword:
+func (c *compilerContext) getFuncType(typ *types.Signature) llvm.Type {
+	switch c.FuncImplementation() {
+	case compileopts.FuncValueDoubleword:
 		rawPtr := c.getRawFuncType(typ)
 		return c.ctx.StructType([]llvm.Type{c.i8ptrType, rawPtr}, false)
-	case funcValueSwitch:
+	case compileopts.FuncValueSwitch:
 		return c.getLLVMRuntimeType("funcValue")
 	default:
 		panic("unimplemented func value variant")
@@ -122,7 +95,7 @@ func (c *Compiler) getFuncType(typ *types.Signature) llvm.Type {
 }

 // getRawFuncType returns a LLVM function pointer type for a given signature.
-func (c *Compiler) getRawFuncType(typ *types.Signature) llvm.Type {
+func (c *compilerContext) getRawFuncType(typ *types.Signature) llvm.Type {
 	// Get the return type.
 	var returnType llvm.Type
 	switch typ.Results().Len() {
@@ -152,11 +125,15 @@ func (c *Compiler) getRawFuncType(typ *types.Signature) llvm.Type {
 			// The receiver is not an interface, but a i8* type.
 			recv = c.i8ptrType
 		}
-		paramTypes = append(paramTypes, c.expandFormalParamType(recv)...)
+		for _, info := range expandFormalParamType(recv, "", nil) {
+			paramTypes = append(paramTypes, info.llvmType)
+		}
 	}
 	for i := 0; i < typ.Params().Len(); i++ {
 		subType := c.getLLVMType(typ.Params().At(i).Type())
-		paramTypes = append(paramTypes, c.expandFormalParamType(subType)...)
+		for _, info := range expandFormalParamType(subType, "", nil) {
+			paramTypes = append(paramTypes, info.llvmType)
+		}
 	}
 	// All functions take these parameters at the end.
 	paramTypes = append(paramTypes, c.i8ptrType) // context
@@ -168,24 +145,24 @@ func (c *Compiler) getRawFuncType(typ *types.Signature) llvm.Type {

 // parseMakeClosure makes a function value (with context) from the given
 // closure expression.
-func (c *Compiler) parseMakeClosure(frame *Frame, expr *ssa.MakeClosure) (llvm.Value, error) {
+func (b *builder) parseMakeClosure(expr *ssa.MakeClosure) (llvm.Value, error) {
 	if len(expr.Bindings) == 0 {
 		panic("unexpected: MakeClosure without bound variables")
 	}
-	f := c.ir.GetFunction(expr.Fn.(*ssa.Function))
+	f := b.ir.GetFunction(expr.Fn.(*ssa.Function))

 	// Collect all bound variables.
 	boundVars := make([]llvm.Value, len(expr.Bindings))
 	for i, binding := range expr.Bindings {
 		// The context stores the bound variables.
-		llvmBoundVar := c.getValue(frame, binding)
+		llvmBoundVar := b.getValue(binding)
 		boundVars[i] = llvmBoundVar
 	}

 	// Store the bound variables in a single object, allocating it on the heap
 	// if necessary.
-	context := c.emitPointerPack(boundVars)
+	context := b.emitPointerPack(boundVars)

 	// Create the closure.
-	return c.createFuncValue(f.LLVMFn, context, f.Signature), nil
+	return b.createFuncValue(f.LLVMFn, context, f.Signature), nil
 }
@@ -12,53 +12,59 @@ import (

 // trackExpr inserts pointer tracking intrinsics for the GC if the expression is
 // one of the expressions that need this.
-func (c *Compiler) trackExpr(frame *Frame, expr ssa.Value, value llvm.Value) {
+func (b *builder) trackExpr(expr ssa.Value, value llvm.Value) {
 	// There are uses of this expression, Make sure the pointers
 	// are tracked during GC.
 	switch expr := expr.(type) {
 	case *ssa.Alloc, *ssa.MakeChan, *ssa.MakeMap:
 		// These values are always of pointer type in IR.
-		c.trackPointer(value)
+		b.trackPointer(value)
 	case *ssa.Call, *ssa.Convert, *ssa.MakeClosure, *ssa.MakeInterface, *ssa.MakeSlice, *ssa.Next:
 		if !value.IsNil() {
-			c.trackValue(value)
+			b.trackValue(value)
 		}
 	case *ssa.Select:
-		if alloca, ok := frame.selectRecvBuf[expr]; ok {
+		if alloca, ok := b.selectRecvBuf[expr]; ok {
 			if alloca.IsAUndefValue().IsNil() {
-				c.trackPointer(alloca)
+				b.trackPointer(alloca)
 			}
 		}
 	case *ssa.UnOp:
 		switch expr.Op {
 		case token.MUL:
 			// Pointer dereference.
-			c.trackValue(value)
+			b.trackValue(value)
 		case token.ARROW:
 			// Channel receive operator.
 			// It's not necessary to look at commaOk here, because in that
 			// case it's just an aggregate and trackValue will extract the
 			// pointer in there (if there is one).
-			c.trackValue(value)
+			b.trackValue(value)
+		}
+	case *ssa.BinOp:
+		switch expr.Op {
+		case token.ADD:
+			// String concatenation.
+			b.trackValue(value)
 		}
 	}
 }

 // trackValue locates pointers in a value (possibly an aggregate) and tracks the
 // individual pointers
-func (c *Compiler) trackValue(value llvm.Value) {
+func (b *builder) trackValue(value llvm.Value) {
 	typ := value.Type()
 	switch typ.TypeKind() {
 	case llvm.PointerTypeKind:
-		c.trackPointer(value)
+		b.trackPointer(value)
 	case llvm.StructTypeKind:
 		if !typeHasPointers(typ) {
 			return
 		}
 		numElements := typ.StructElementTypesCount()
 		for i := 0; i < numElements; i++ {
-			subValue := c.builder.CreateExtractValue(value, i, "")
-			c.trackValue(subValue)
+			subValue := b.CreateExtractValue(value, i, "")
+			b.trackValue(subValue)
 		}
 	case llvm.ArrayTypeKind:
 		if !typeHasPointers(typ) {
@@ -66,19 +72,19 @@ func (c *Compiler) trackValue(value llvm.Value) {
 		}
 		numElements := typ.ArrayLength()
 		for i := 0; i < numElements; i++ {
-			subValue := c.builder.CreateExtractValue(value, i, "")
-			c.trackValue(subValue)
+			subValue := b.CreateExtractValue(value, i, "")
+			b.trackValue(subValue)
 		}
 	}
 }

 // trackPointer creates a call to runtime.trackPointer, bitcasting the poitner
 // first if needed. The input value must be of LLVM pointer type.
-func (c *Compiler) trackPointer(value llvm.Value) {
-	if value.Type() != c.i8ptrType {
-		value = c.builder.CreateBitCast(value, c.i8ptrType, "")
+func (b *builder) trackPointer(value llvm.Value) {
+	if value.Type() != b.i8ptrType {
+		value = b.CreateBitCast(value, b.i8ptrType, "")
 	}
-	c.createRuntimeCall("trackPointer", []llvm.Value{value}, "")
+	b.createRuntimeCall("trackPointer", []llvm.Value{value}, "")
 }

 // typeHasPointers returns whether this type is a pointer or contains pointers.
@@ -3,34 +3,46 @@ package compiler
 // This file implements the 'go' keyword to start a new goroutine. See
 // goroutine-lowering.go for more details.

-import "tinygo.org/x/go-llvm"
+import (
+	"go/token"

-// emitStartGoroutine starts a new goroutine with the provided function pointer
+	"github.com/tinygo-org/tinygo/compiler/llvmutil"
+	"tinygo.org/x/go-llvm"
+)
+
+// createGoInstruction starts a new goroutine with the provided function pointer
 // and parameters.
 // In general, you should pass all regular parameters plus the context parameter.
 // There is one exception: the task-based scheduler needs to have the function
 // pointer passed in as a parameter too in addition to the context.
 //
 // Because a go statement doesn't return anything, return undef.
-func (c *Compiler) emitStartGoroutine(funcPtr llvm.Value, params []llvm.Value) llvm.Value {
-	switch c.Scheduler() {
-	case "tasks":
-		paramBundle := c.emitPointerPack(params)
-		paramBundle = c.builder.CreatePtrToInt(paramBundle, c.uintptrType, "")
-
-		calleeValue := c.createGoroutineStartWrapper(funcPtr)
-		c.createRuntimeCall("startGoroutine", []llvm.Value{calleeValue, paramBundle}, "")
+func (b *builder) createGoInstruction(funcPtr llvm.Value, params []llvm.Value, prefix string, pos token.Pos) llvm.Value {
+	paramBundle := b.emitPointerPack(params)
+	var callee, stackSize llvm.Value
+	switch b.Scheduler() {
+	case "none", "tasks":
+		callee = b.createGoroutineStartWrapper(funcPtr, prefix, pos)
+		if b.AutomaticStackSize() {
+			// The stack size is not known until after linking. Call a dummy
+			// function that will be replaced with a load from a special ELF
+			// 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")
+		} 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)
+		}
 	case "coroutines":
-		// We roundtrip through runtime.makeGoroutine as a signal (to find these
-		// calls) and to break any optimizations LLVM will try to do: they are
-		// invalid if we called this as a regular function to be updated later.
-		calleeValue := c.builder.CreatePtrToInt(funcPtr, c.uintptrType, "")
-		calleeValue = c.createRuntimeCall("makeGoroutine", []llvm.Value{calleeValue}, "")
-		calleeValue = c.builder.CreateIntToPtr(calleeValue, funcPtr.Type(), "")
-		c.createCall(calleeValue, append(params, llvm.ConstPointerNull(c.i8ptrType)), "")
+		callee = b.CreatePtrToInt(funcPtr, b.uintptrType, "")
+		// There is no goroutine stack size: coroutines are used instead of
+		// stacks.
+		stackSize = llvm.Undef(b.uintptrType)
 	default:
 		panic("unreachable")
 	}
+	b.createCall(b.mod.NamedFunction("internal/task.start"), []llvm.Value{callee, paramBundle, stackSize, llvm.Undef(b.i8ptrType), llvm.ConstPointerNull(b.i8ptrType)}, "")
 	return llvm.Undef(funcPtr.Type().ElementType().ReturnType())
 }

@@ -52,36 +64,58 @@ func (c *Compiler) emitStartGoroutine(funcPtr llvm.Value, params []llvm.Value) l
 // allows a single (pointer) argument to the newly started goroutine. Also, it
 // ignores the return value because newly started goroutines do not have a
 // return value.
-func (c *Compiler) createGoroutineStartWrapper(fn llvm.Value) llvm.Value {
+func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix string, pos token.Pos) llvm.Value {
 	var wrapper llvm.Value

+	builder := c.ctx.NewBuilder()
+	defer builder.Dispose()
+
 	if !fn.IsAFunction().IsNil() {
 		// See whether this wrapper has already been created. If so, return it.
 		name := fn.Name()
 		wrapper = c.mod.NamedFunction(name + "$gowrapper")
 		if !wrapper.IsNil() {
-			return c.builder.CreatePtrToInt(wrapper, c.uintptrType, "")
+			return llvm.ConstPtrToInt(wrapper, c.uintptrType)
 		}

-		// Save the current position in the IR builder.
-		currentBlock := c.builder.GetInsertBlock()
-		defer c.builder.SetInsertPointAtEnd(currentBlock)
-
 		// Create the wrapper.
 		wrapperType := llvm.FunctionType(c.ctx.VoidType(), []llvm.Type{c.i8ptrType}, false)
 		wrapper = llvm.AddFunction(c.mod, name+"$gowrapper", wrapperType)
-		wrapper.SetLinkage(llvm.PrivateLinkage)
+		wrapper.SetLinkage(llvm.InternalLinkage)
 		wrapper.SetUnnamedAddr(true)
+		wrapper.AddAttributeAtIndex(-1, c.ctx.CreateStringAttribute("tinygo-gowrapper", name))
 		entry := c.ctx.AddBasicBlock(wrapper, "entry")
-		c.builder.SetInsertPointAtEnd(entry)
+		builder.SetInsertPointAtEnd(entry)
+
+		if c.Debug() {
+			pos := c.ir.Program.Fset.Position(pos)
+			diFuncType := c.dibuilder.CreateSubroutineType(llvm.DISubroutineType{
+				File:       c.getDIFile(pos.Filename),
+				Parameters: nil, // do not show parameters in debugger
+				Flags:      0,   // ?
+			})
+			difunc := c.dibuilder.CreateFunction(c.getDIFile(pos.Filename), llvm.DIFunction{
+				Name:         "<goroutine wrapper>",
+				File:         c.getDIFile(pos.Filename),
+				Line:         pos.Line,
+				Type:         diFuncType,
+				LocalToUnit:  true,
+				IsDefinition: true,
+				ScopeLine:    0,
+				Flags:        llvm.FlagPrototyped,
+				Optimized:    true,
+			})
+			wrapper.SetSubprogram(difunc)
+			builder.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), difunc, llvm.Metadata{})
+		}

 		// Create the list of params for the call.
 		paramTypes := fn.Type().ElementType().ParamTypes()
-		params := c.emitPointerUnpack(wrapper.Param(0), paramTypes[:len(paramTypes)-1])
+		params := llvmutil.EmitPointerUnpack(builder, c.mod, wrapper.Param(0), paramTypes[:len(paramTypes)-1])
 		params = append(params, llvm.Undef(c.i8ptrType))

 		// Create the call.
-		c.builder.CreateCall(fn, params, "")
+		builder.CreateCall(fn, params, "")

 	} else {
 		// For a function pointer like this:
@@ -101,22 +135,41 @@ func (c *Compiler) createGoroutineStartWrapper(fn llvm.Value) llvm.Value {
 		// With a bit of luck, identical wrapper functions like these can be
 		// merged into one.

-		// Save the current position in the IR builder.
-		currentBlock := c.builder.GetInsertBlock()
-		defer c.builder.SetInsertPointAtEnd(currentBlock)
-
 		// Create the wrapper.
 		wrapperType := llvm.FunctionType(c.ctx.VoidType(), []llvm.Type{c.i8ptrType}, false)
-		wrapper = llvm.AddFunction(c.mod, ".gowrapper", wrapperType)
+		wrapper = llvm.AddFunction(c.mod, prefix+".gowrapper", wrapperType)
 		wrapper.SetLinkage(llvm.InternalLinkage)
 		wrapper.SetUnnamedAddr(true)
+		wrapper.AddAttributeAtIndex(-1, c.ctx.CreateStringAttribute("tinygo-gowrapper", ""))
 		entry := c.ctx.AddBasicBlock(wrapper, "entry")
-		c.builder.SetInsertPointAtEnd(entry)
+		builder.SetInsertPointAtEnd(entry)
+
+		if c.Debug() {
+			pos := c.ir.Program.Fset.Position(pos)
+			diFuncType := c.dibuilder.CreateSubroutineType(llvm.DISubroutineType{
+				File:       c.getDIFile(pos.Filename),
+				Parameters: nil, // do not show parameters in debugger
+				Flags:      0,   // ?
+			})
+			difunc := c.dibuilder.CreateFunction(c.getDIFile(pos.Filename), llvm.DIFunction{
+				Name:         "<goroutine wrapper>",
+				File:         c.getDIFile(pos.Filename),
+				Line:         pos.Line,
+				Type:         diFuncType,
+				LocalToUnit:  true,
+				IsDefinition: true,
+				ScopeLine:    0,
+				Flags:        llvm.FlagPrototyped,
+				Optimized:    true,
+			})
+			wrapper.SetSubprogram(difunc)
+			builder.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), difunc, llvm.Metadata{})
+		}

 		// Get the list of parameters, with the extra parameters at the end.
 		paramTypes := fn.Type().ElementType().ParamTypes()
 		paramTypes[len(paramTypes)-1] = fn.Type() // the last element is the function pointer
-		params := c.emitPointerUnpack(wrapper.Param(0), paramTypes)
+		params := llvmutil.EmitPointerUnpack(builder, c.mod, wrapper.Param(0), paramTypes)

 		// Get the function pointer.
 		fnPtr := params[len(params)-1]
@@ -126,13 +179,13 @@ func (c *Compiler) createGoroutineStartWrapper(fn llvm.Value) llvm.Value {
 		params[len(params)-1] = llvm.Undef(c.i8ptrType)

 		// Create the call.
-		c.builder.CreateCall(fnPtr, params, "")
+		builder.CreateCall(fnPtr, params, "")
 	}

 	// Finish the function. Every basic block must end in a terminator, and
 	// because goroutines never return a value we can simply return void.
-	c.builder.CreateRetVoid()
+	builder.CreateRetVoid()

 	// Return a ptrtoint of the wrapper, not the function itself.
-	return c.builder.CreatePtrToInt(wrapper, c.uintptrType, "")
+	return builder.CreatePtrToInt(wrapper, c.uintptrType, "")
 }
@@ -13,27 +13,6 @@ import (
 	"tinygo.org/x/go-llvm"
 )

-// This is a compiler builtin, which reads the given register by name:
-//
-//     func ReadRegister(name string) uintptr
-//
-// The register name must be a constant, for example "sp".
-func (c *Compiler) emitReadRegister(name string, args []ssa.Value) (llvm.Value, error) {
-	fnType := llvm.FunctionType(c.uintptrType, []llvm.Type{}, false)
-	regname := constant.StringVal(args[0].(*ssa.Const).Value)
-	var asm string
-	switch name {
-	case "device/arm.ReadRegister":
-		asm = "mov $0, " + regname
-	case "device/riscv.ReadRegister":
-		asm = "mv $0, " + regname
-	default:
-		panic("unknown architecture")
-	}
-	target := llvm.InlineAsm(fnType, asm, "=r", false, false, 0)
-	return c.builder.CreateCall(target, nil, ""), nil
-}
-
 // This is a compiler builtin, which emits a piece of inline assembly with no
 // operands or return values. It is useful for trivial instructions, like wfi in
 // ARM or sleep in AVR.
@@ -41,18 +20,18 @@ func (c *Compiler) emitReadRegister(name string, args []ssa.Value) (llvm.Value,
 //     func Asm(asm string)
 //
 // The provided assembly must be a constant.
-func (c *Compiler) emitAsm(args []ssa.Value) (llvm.Value, error) {
+func (b *builder) createInlineAsm(args []ssa.Value) (llvm.Value, error) {
 	// Magic function: insert inline assembly instead of calling it.
-	fnType := llvm.FunctionType(c.ctx.VoidType(), []llvm.Type{}, false)
+	fnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{}, false)
 	asm := constant.StringVal(args[0].(*ssa.Const).Value)
 	target := llvm.InlineAsm(fnType, asm, "", true, false, 0)
-	return c.builder.CreateCall(target, nil, ""), nil
+	return b.CreateCall(target, nil, ""), nil
 }

 // This is a compiler builtin, which allows assembly to be called in a flexible
 // way.
 //
-//     func AsmFull(asm string, regs map[string]interface{})
+//     func AsmFull(asm string, regs map[string]interface{}) uintptr
 //
 // The asm parameter must be a constant string. The regs parameter must be
 // provided immediately. For example:
@@ -63,27 +42,27 @@ func (c *Compiler) emitAsm(args []ssa.Value) (llvm.Value, error) {
 //             "value":  1
 //             "result": &dest,
 //         })
-func (c *Compiler) emitAsmFull(frame *Frame, instr *ssa.CallCommon) (llvm.Value, error) {
+func (b *builder) createInlineAsmFull(instr *ssa.CallCommon) (llvm.Value, error) {
 	asmString := constant.StringVal(instr.Args[0].(*ssa.Const).Value)
 	registers := map[string]llvm.Value{}
-	registerMap := instr.Args[1].(*ssa.MakeMap)
-	for _, r := range *registerMap.Referrers() {
-		switch r := r.(type) {
-		case *ssa.DebugRef:
-			// ignore
-		case *ssa.MapUpdate:
-			if r.Block() != registerMap.Block() {
-				return llvm.Value{}, c.makeError(instr.Pos(), "register value map must be created in the same basic block")
+	if registerMap, ok := instr.Args[1].(*ssa.MakeMap); ok {
+		for _, r := range *registerMap.Referrers() {
+			switch r := r.(type) {
+			case *ssa.DebugRef:
+				// ignore
+			case *ssa.MapUpdate:
+				if r.Block() != registerMap.Block() {
+					return llvm.Value{}, b.makeError(instr.Pos(), "register value map must be created in the same basic block")
+				}
+				key := constant.StringVal(r.Key.(*ssa.Const).Value)
+				registers[key] = b.getValue(r.Value.(*ssa.MakeInterface).X)
+			case *ssa.Call:
+				if r.Common() == instr {
+					break
+				}
+			default:
+				return llvm.Value{}, b.makeError(instr.Pos(), "don't know how to handle argument to inline assembly: "+r.String())
 			}
-			key := constant.StringVal(r.Key.(*ssa.Const).Value)
-			//println("value:", r.Value.(*ssa.MakeInterface).X.String())
-			registers[key] = c.getValue(frame, r.Value.(*ssa.MakeInterface).X)
-		case *ssa.Call:
-			if r.Common() == instr {
-				break
-			}
-		default:
-			return llvm.Value{}, c.makeError(instr.Pos(), "don't know how to handle argument to inline assembly: "+r.String())
 		}
 	}
 	// TODO: handle dollar signs in asm string
@@ -92,13 +71,22 @@ func (c *Compiler) emitAsmFull(frame *Frame, instr *ssa.CallCommon) (llvm.Value,
 	argTypes := []llvm.Type{}
 	args := []llvm.Value{}
 	constraints := []string{}
+	hasOutput := false
+	asmString = regexp.MustCompile("\\{\\}").ReplaceAllStringFunc(asmString, func(s string) string {
+		hasOutput = true
+		return "$0"
+	})
+	if hasOutput {
+		constraints = append(constraints, "=&r")
+		registerNumbers[""] = 0
+	}
 	asmString = regexp.MustCompile("\\{[a-zA-Z]+\\}").ReplaceAllStringFunc(asmString, func(s string) string {
 		// TODO: skip strings like {r4} etc. that look like ARM push/pop
 		// instructions.
 		name := s[1 : len(s)-1]
 		if _, ok := registers[name]; !ok {
 			if err == nil {
-				err = c.makeError(instr.Pos(), "unknown register name: "+name)
+				err = b.makeError(instr.Pos(), "unknown register name: "+name)
 			}
 			return s
 		}
@@ -112,7 +100,7 @@ func (c *Compiler) emitAsmFull(frame *Frame, instr *ssa.CallCommon) (llvm.Value,
 			case llvm.PointerTypeKind:
 				constraints = append(constraints, "*m")
 			default:
-				err = c.makeError(instr.Pos(), "unknown type in inline assembly for value: "+name)
+				err = b.makeError(instr.Pos(), "unknown type in inline assembly for value: "+name)
 				return s
 			}
 		}
@@ -121,9 +109,21 @@ func (c *Compiler) emitAsmFull(frame *Frame, instr *ssa.CallCommon) (llvm.Value,
 	if err != nil {
 		return llvm.Value{}, err
 	}
-	fnType := llvm.FunctionType(c.ctx.VoidType(), argTypes, false)
+	var outputType llvm.Type
+	if hasOutput {
+		outputType = b.uintptrType
+	} else {
+		outputType = b.ctx.VoidType()
+	}
+	fnType := llvm.FunctionType(outputType, argTypes, false)
 	target := llvm.InlineAsm(fnType, asmString, strings.Join(constraints, ","), true, false, 0)
-	return c.builder.CreateCall(target, args, ""), nil
+	result := b.CreateCall(target, args, "")
+	if hasOutput {
+		return result, nil
+	} else {
+		// Make sure we return something valid.
+		return llvm.ConstInt(b.uintptrType, 0, false), nil
+	}
 }

 // This is a compiler builtin which emits an inline SVCall instruction. It can
@@ -137,7 +137,7 @@ func (c *Compiler) emitAsmFull(frame *Frame, instr *ssa.CallCommon) (llvm.Value,
 //
 // The num parameter must be a constant. All other parameters may be any scalar
 // value supported by LLVM inline assembly.
-func (c *Compiler) emitSVCall(frame *Frame, args []ssa.Value) (llvm.Value, error) {
+func (b *builder) emitSVCall(args []ssa.Value) (llvm.Value, error) {
 	num, _ := constant.Uint64Val(args[0].(*ssa.Const).Value)
 	llvmArgs := []llvm.Value{}
 	argTypes := []llvm.Type{}
@@ -150,7 +150,7 @@ func (c *Compiler) emitSVCall(frame *Frame, args []ssa.Value) (llvm.Value, error
 		} else {
 			constraints += ",{r" + strconv.Itoa(i) + "}"
 		}
-		llvmValue := c.getValue(frame, arg)
+		llvmValue := b.getValue(arg)
 		llvmArgs = append(llvmArgs, llvmValue)
 		argTypes = append(argTypes, llvmValue.Type())
 	}
@@ -158,7 +158,90 @@ func (c *Compiler) emitSVCall(frame *Frame, args []ssa.Value) (llvm.Value, error
 	// clobbered. r0 is used as an output register so doesn't have to be
 	// marked as clobbered.
 	constraints += ",~{r1},~{r2},~{r3}"
-	fnType := llvm.FunctionType(c.uintptrType, argTypes, false)
+	fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
 	target := llvm.InlineAsm(fnType, asm, constraints, true, false, 0)
-	return c.builder.CreateCall(target, llvmArgs, ""), nil
+	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
+//     func (csr CSR) Set(uintptr)
+//     func (csr CSR) SetBits(uintptr) uintptr
+//     func (csr CSR) ClearBits(uintptr) uintptr
+//
+// The csr parameter (method receiver) must be a constant. Other parameter can
+// be any value.
+func (b *builder) emitCSROperation(call *ssa.CallCommon) (llvm.Value, error) {
+	csrConst, ok := call.Args[0].(*ssa.Const)
+	if !ok {
+		return llvm.Value{}, b.makeError(call.Pos(), "CSR must be constant")
+	}
+	csr := csrConst.Uint64()
+	switch name := call.StaticCallee().Name(); name {
+	case "Get":
+		// Note that this instruction may have side effects, and thus must be
+		// marked as such.
+		fnType := llvm.FunctionType(b.uintptrType, nil, false)
+		asm := fmt.Sprintf("csrr $0, %d", csr)
+		target := llvm.InlineAsm(fnType, asm, "=r", true, false, 0)
+		return b.CreateCall(target, nil, ""), nil
+	case "Set":
+		fnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{b.uintptrType}, false)
+		asm := fmt.Sprintf("csrw %d, $0", csr)
+		target := llvm.InlineAsm(fnType, asm, "r", true, false, 0)
+		return b.CreateCall(target, []llvm.Value{b.getValue(call.Args[1])}, ""), nil
+	case "SetBits":
+		// Note: it may be possible to optimize this to csrrsi in many cases.
+		fnType := llvm.FunctionType(b.uintptrType, []llvm.Type{b.uintptrType}, false)
+		asm := fmt.Sprintf("csrrs $0, %d, $1", csr)
+		target := llvm.InlineAsm(fnType, asm, "=r,r", true, false, 0)
+		return b.CreateCall(target, []llvm.Value{b.getValue(call.Args[1])}, ""), nil
+	case "ClearBits":
+		// Note: it may be possible to optimize this to csrrci in many cases.
+		fnType := llvm.FunctionType(b.uintptrType, []llvm.Type{b.uintptrType}, false)
+		asm := fmt.Sprintf("csrrc $0, %d, $1", csr)
+		target := llvm.InlineAsm(fnType, asm, "=r,r", true, false, 0)
+		return b.CreateCall(target, []llvm.Value{b.getValue(call.Args[1])}, ""), nil
+	default:
+		return llvm.Value{}, b.makeError(call.Pos(), "unknown CSR operation: "+name)
+	}
 }
@@ -16,35 +16,35 @@ import (
 	"tinygo.org/x/go-llvm"
 )

-// parseMakeInterface emits the LLVM IR for the *ssa.MakeInterface instruction.
+// createMakeInterface emits the LLVM IR for the *ssa.MakeInterface instruction.
 // It tries to put the type in the interface value, but if that's not possible,
 // it will do an allocation of the right size and put that in the interface
 // value field.
 //
-// An interface value is a {typecode, value} tuple, or {i16, i8*} to be exact.
-func (c *Compiler) parseMakeInterface(val llvm.Value, typ types.Type, pos token.Pos) llvm.Value {
-	itfValue := c.emitPointerPack([]llvm.Value{val})
-	itfTypeCodeGlobal := c.getTypeCode(typ)
-	itfMethodSetGlobal := c.getTypeMethodSet(typ)
-	itfConcreteTypeGlobal := c.mod.NamedGlobal("typeInInterface:" + itfTypeCodeGlobal.Name())
+// An interface value is a {typecode, value} tuple named runtime._interface.
+func (b *builder) createMakeInterface(val llvm.Value, typ types.Type, pos token.Pos) llvm.Value {
+	itfValue := b.emitPointerPack([]llvm.Value{val})
+	itfTypeCodeGlobal := b.getTypeCode(typ)
+	itfMethodSetGlobal := b.getTypeMethodSet(typ)
+	itfConcreteTypeGlobal := b.mod.NamedGlobal("typeInInterface:" + itfTypeCodeGlobal.Name())
 	if itfConcreteTypeGlobal.IsNil() {
-		typeInInterface := c.getLLVMRuntimeType("typeInInterface")
-		itfConcreteTypeGlobal = llvm.AddGlobal(c.mod, typeInInterface, "typeInInterface:"+itfTypeCodeGlobal.Name())
+		typeInInterface := b.getLLVMRuntimeType("typeInInterface")
+		itfConcreteTypeGlobal = llvm.AddGlobal(b.mod, typeInInterface, "typeInInterface:"+itfTypeCodeGlobal.Name())
 		itfConcreteTypeGlobal.SetInitializer(llvm.ConstNamedStruct(typeInInterface, []llvm.Value{itfTypeCodeGlobal, itfMethodSetGlobal}))
 		itfConcreteTypeGlobal.SetGlobalConstant(true)
 		itfConcreteTypeGlobal.SetLinkage(llvm.PrivateLinkage)
 	}
-	itfTypeCode := c.builder.CreatePtrToInt(itfConcreteTypeGlobal, c.uintptrType, "")
-	itf := llvm.Undef(c.getLLVMRuntimeType("_interface"))
-	itf = c.builder.CreateInsertValue(itf, itfTypeCode, 0, "")
-	itf = c.builder.CreateInsertValue(itf, itfValue, 1, "")
+	itfTypeCode := b.CreatePtrToInt(itfConcreteTypeGlobal, b.uintptrType, "")
+	itf := llvm.Undef(b.getLLVMRuntimeType("_interface"))
+	itf = b.CreateInsertValue(itf, itfTypeCode, 0, "")
+	itf = b.CreateInsertValue(itf, itfValue, 1, "")
 	return itf
 }

 // getTypeCode returns a reference to a type code.
 // It returns a pointer to an external global which should be replaced with the
 // real type in the interface lowering pass.
-func (c *Compiler) getTypeCode(typ types.Type) llvm.Value {
+func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 	globalName := "reflect/types.type:" + getTypeCodeName(typ)
 	global := c.mod.NamedGlobal(globalName)
 	if global.IsNil() {
@@ -91,7 +91,7 @@ func (c *Compiler) getTypeCode(typ types.Type) llvm.Value {
 // makeStructTypeFields creates a new global that stores all type information
 // related to this struct type, and returns the resulting global. This global is
 // actually an array of all the fields in the structs.
-func (c *Compiler) makeStructTypeFields(typ *types.Struct) llvm.Value {
+func (c *compilerContext) makeStructTypeFields(typ *types.Struct) llvm.Value {
 	// The global is an array of runtime.structField structs.
 	runtimeStructField := c.getLLVMRuntimeType("structField")
 	structGlobalType := llvm.ArrayType(runtimeStructField, typ.NumFields())
@@ -228,7 +228,7 @@ func getTypeCodeName(t types.Type) string {

 // getTypeMethodSet returns a reference (GEP) to a global method set. This
 // method set should be unreferenced after the interface lowering pass.
-func (c *Compiler) getTypeMethodSet(typ types.Type) llvm.Value {
+func (c *compilerContext) getTypeMethodSet(typ types.Type) llvm.Value {
 	global := c.mod.NamedGlobal(typ.String() + "$methodset")
 	zero := llvm.ConstInt(c.ctx.Int32Type(), 0, false)
 	if !global.IsNil() {
@@ -271,8 +271,13 @@ func (c *Compiler) getTypeMethodSet(typ types.Type) llvm.Value {
 // getInterfaceMethodSet returns a global variable with the method set of the
 // given named interface type. This method set is used by the interface lowering
 // pass.
-func (c *Compiler) getInterfaceMethodSet(typ *types.Named) llvm.Value {
-	global := c.mod.NamedGlobal(typ.String() + "$interface")
+func (c *compilerContext) getInterfaceMethodSet(typ types.Type) llvm.Value {
+	name := typ.String()
+	if _, ok := typ.(*types.Named); !ok {
+		// Anonymous interface.
+		name = "reflect/types.interface:" + name
+	}
+	global := c.mod.NamedGlobal(name + "$interface")
 	zero := llvm.ConstInt(c.ctx.Int32Type(), 0, false)
 	if !global.IsNil() {
 		// method set already exist, return it
@@ -287,7 +292,7 @@ func (c *Compiler) getInterfaceMethodSet(typ *types.Named) llvm.Value {
 	}

 	value := llvm.ConstArray(c.i8ptrType, methods)
-	global = llvm.AddGlobal(c.mod, value.Type(), typ.String()+"$interface")
+	global = llvm.AddGlobal(c.mod, value.Type(), name+"$interface")
 	global.SetInitializer(value)
 	global.SetGlobalConstant(true)
 	global.SetLinkage(llvm.PrivateLinkage)
@@ -297,7 +302,7 @@ func (c *Compiler) getInterfaceMethodSet(typ *types.Named) llvm.Value {
 // getMethodSignature returns a global variable which is a reference to an
 // external *i8 indicating the indicating the signature of this method. It is
 // used during the interface lowering pass.
-func (c *Compiler) getMethodSignature(method *types.Func) llvm.Value {
+func (c *compilerContext) getMethodSignature(method *types.Func) llvm.Value {
 	signature := ir.MethodSignature(method)
 	signatureGlobal := c.mod.NamedGlobal("func " + signature)
 	if signatureGlobal.IsNil() {
@@ -307,18 +312,18 @@ func (c *Compiler) getMethodSignature(method *types.Func) llvm.Value {
 	return signatureGlobal
 }

-// parseTypeAssert will emit the code for a typeassert, used in if statements
+// createTypeAssert will emit the code for a typeassert, used in if statements
 // and in type switches (Go SSA does not have type switches, only if/else
 // chains). Note that even though the Go SSA does not contain type switches,
 // LLVM will recognize the pattern and make it a real switch in many cases.
 //
 // Type asserts on concrete types are trivial: just compare type numbers. Type
 // asserts on interfaces are more difficult, see the comments in the function.
-func (c *Compiler) parseTypeAssert(frame *Frame, expr *ssa.TypeAssert) llvm.Value {
-	itf := c.getValue(frame, expr.X)
-	assertedType := c.getLLVMType(expr.AssertedType)
+func (b *builder) createTypeAssert(expr *ssa.TypeAssert) llvm.Value {
+	itf := b.getValue(expr.X)
+	assertedType := b.getLLVMType(expr.AssertedType)

-	actualTypeNum := c.builder.CreateExtractValue(itf, 0, "interface.type")
+	actualTypeNum := b.CreateExtractValue(itf, 0, "interface.type")
 	commaOk := llvm.Value{}
 	if _, ok := expr.AssertedType.Underlying().(*types.Interface); ok {
 		// Type assert on interface type.
@@ -329,15 +334,15 @@ func (c *Compiler) parseTypeAssert(frame *Frame, expr *ssa.TypeAssert) llvm.Valu
 		// the main Go compiler, where the runtime checks whether the type
 		// implements each method of the interface. See:
 		// https://research.swtch.com/interfaces
-		methodSet := c.getInterfaceMethodSet(expr.AssertedType.(*types.Named))
-		commaOk = c.createRuntimeCall("interfaceImplements", []llvm.Value{actualTypeNum, methodSet}, "")
+		methodSet := b.getInterfaceMethodSet(expr.AssertedType)
+		commaOk = b.createRuntimeCall("interfaceImplements", []llvm.Value{actualTypeNum, methodSet}, "")

 	} else {
 		// Type assert on concrete type.
 		// Call runtime.typeAssert, which will be lowered to a simple icmp or
 		// const false in the interface lowering pass.
-		assertedTypeCodeGlobal := c.getTypeCode(expr.AssertedType)
-		commaOk = c.createRuntimeCall("typeAssert", []llvm.Value{actualTypeNum, assertedTypeCodeGlobal}, "typecode")
+		assertedTypeCodeGlobal := b.getTypeCode(expr.AssertedType)
+		commaOk = b.createRuntimeCall("typeAssert", []llvm.Value{actualTypeNum, assertedTypeCodeGlobal}, "typecode")
 	}

 	// Add 2 new basic blocks (that should get optimized away): one for the
@@ -351,15 +356,15 @@ func (c *Compiler) parseTypeAssert(frame *Frame, expr *ssa.TypeAssert) llvm.Valu
 	// typeassert should return a zero value, not an incorrectly casted
 	// value.

-	prevBlock := c.builder.GetInsertBlock()
-	okBlock := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "typeassert.ok")
-	nextBlock := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "typeassert.next")
-	frame.blockExits[frame.currentBlock] = nextBlock // adjust outgoing block for phi nodes
-	c.builder.CreateCondBr(commaOk, okBlock, nextBlock)
+	prevBlock := b.GetInsertBlock()
+	okBlock := b.ctx.AddBasicBlock(b.fn.LLVMFn, "typeassert.ok")
+	nextBlock := b.ctx.AddBasicBlock(b.fn.LLVMFn, "typeassert.next")
+	b.blockExits[b.currentBlock] = nextBlock // adjust outgoing block for phi nodes
+	b.CreateCondBr(commaOk, okBlock, nextBlock)

 	// Retrieve the value from the interface if the type assert was
 	// successful.
-	c.builder.SetInsertPointAtEnd(okBlock)
+	b.SetInsertPointAtEnd(okBlock)
 	var valueOk llvm.Value
 	if _, ok := expr.AssertedType.Underlying().(*types.Interface); ok {
 		// Type assert on interface type. Easy: just return the same
@@ -368,74 +373,70 @@ func (c *Compiler) parseTypeAssert(frame *Frame, expr *ssa.TypeAssert) llvm.Valu
 	} else {
 		// Type assert on concrete type. Extract the underlying type from
 		// the interface (but only after checking it matches).
-		valuePtr := c.builder.CreateExtractValue(itf, 1, "typeassert.value.ptr")
-		valueOk = c.emitPointerUnpack(valuePtr, []llvm.Type{assertedType})[0]
+		valuePtr := b.CreateExtractValue(itf, 1, "typeassert.value.ptr")
+		valueOk = b.emitPointerUnpack(valuePtr, []llvm.Type{assertedType})[0]
 	}
-	c.builder.CreateBr(nextBlock)
+	b.CreateBr(nextBlock)

 	// Continue after the if statement.
-	c.builder.SetInsertPointAtEnd(nextBlock)
-	phi := c.builder.CreatePHI(assertedType, "typeassert.value")
+	b.SetInsertPointAtEnd(nextBlock)
+	phi := b.CreatePHI(assertedType, "typeassert.value")
 	phi.AddIncoming([]llvm.Value{llvm.ConstNull(assertedType), valueOk}, []llvm.BasicBlock{prevBlock, okBlock})

 	if expr.CommaOk {
-		tuple := c.ctx.ConstStruct([]llvm.Value{llvm.Undef(assertedType), llvm.Undef(c.ctx.Int1Type())}, false) // create empty tuple
-		tuple = c.builder.CreateInsertValue(tuple, phi, 0, "")                                                  // insert value
-		tuple = c.builder.CreateInsertValue(tuple, commaOk, 1, "")                                              // insert 'comma ok' boolean
+		tuple := b.ctx.ConstStruct([]llvm.Value{llvm.Undef(assertedType), llvm.Undef(b.ctx.Int1Type())}, false) // create empty tuple
+		tuple = b.CreateInsertValue(tuple, phi, 0, "")                                                          // insert value
+		tuple = b.CreateInsertValue(tuple, commaOk, 1, "")                                                      // insert 'comma ok' boolean
 		return tuple
 	} else {
 		// This is kind of dirty as the branch above becomes mostly useless,
 		// but hopefully this gets optimized away.
-		c.createRuntimeCall("interfaceTypeAssert", []llvm.Value{commaOk}, "")
+		b.createRuntimeCall("interfaceTypeAssert", []llvm.Value{commaOk}, "")
 		return phi
 	}
 }

-// getInvokeCall creates and returns the function pointer and parameters of an
-// interface call. It can be used in a call or defer instruction.
-func (c *Compiler) getInvokeCall(frame *Frame, instr *ssa.CallCommon) (llvm.Value, []llvm.Value) {
-	// Call an interface method with dynamic dispatch.
-	itf := c.getValue(frame, instr.Value) // interface
-
-	llvmFnType := c.getRawFuncType(instr.Method.Type().(*types.Signature))
-
-	typecode := c.builder.CreateExtractValue(itf, 0, "invoke.typecode")
+// getInvokePtr creates an interface function pointer lookup for the specified invoke instruction, using a specified typecode.
+func (b *builder) getInvokePtr(instr *ssa.CallCommon, typecode llvm.Value) llvm.Value {
+	llvmFnType := b.getRawFuncType(instr.Method.Type().(*types.Signature))
 	values := []llvm.Value{
 		typecode,
-		c.getInterfaceMethodSet(instr.Value.Type().(*types.Named)),
-		c.getMethodSignature(instr.Method),
+		b.getInterfaceMethodSet(instr.Value.Type()),
+		b.getMethodSignature(instr.Method),
 	}
-	fn := c.createRuntimeCall("interfaceMethod", values, "invoke.func")
-	fnCast := c.builder.CreateIntToPtr(fn, llvmFnType, "invoke.func.cast")
-	receiverValue := c.builder.CreateExtractValue(itf, 1, "invoke.func.receiver")
+	fn := b.createRuntimeCall("interfaceMethod", values, "invoke.func")
+	return b.CreateIntToPtr(fn, llvmFnType, "invoke.func.cast")
+}
+
+// getInvokeCall creates and returns the function pointer and parameters of an
+// interface call.
+func (b *builder) getInvokeCall(instr *ssa.CallCommon) (llvm.Value, []llvm.Value) {
+	// Call an interface method with dynamic dispatch.
+	itf := b.getValue(instr.Value) // interface
+
+	typecode := b.CreateExtractValue(itf, 0, "invoke.typecode")
+	fnCast := b.getInvokePtr(instr, typecode)
+	receiverValue := b.CreateExtractValue(itf, 1, "invoke.func.receiver")

 	args := []llvm.Value{receiverValue}
 	for _, arg := range instr.Args {
-		args = append(args, c.getValue(frame, arg))
+		args = append(args, b.getValue(arg))
 	}
 	// Add the context parameter. An interface call never takes a context but we
 	// have to supply the parameter anyway.
-	args = append(args, llvm.Undef(c.i8ptrType))
+	args = append(args, llvm.Undef(b.i8ptrType))
 	// Add the parent goroutine handle.
-	args = append(args, llvm.Undef(c.i8ptrType))
+	args = append(args, llvm.Undef(b.i8ptrType))

 	return fnCast, args
 }

-// interfaceInvokeWrapper keeps some state between getInterfaceInvokeWrapper and
-// createInterfaceInvokeWrapper. The former is called during IR construction
-// itself and the latter is called when finishing up the IR.
-type interfaceInvokeWrapper struct {
-	fn           *ir.Function
-	wrapper      llvm.Value
-	receiverType llvm.Type
-}
-
-// Wrap an interface method function pointer. The wrapper takes in a pointer to
-// the underlying value, dereferences it, and calls the real method. This
-// wrapper is only needed when the interface value actually doesn't fit in a
-// pointer and a pointer to the value must be created.
-func (c *Compiler) getInterfaceInvokeWrapper(f *ir.Function) llvm.Value {
+// getInterfaceInvokeWrapper returns a wrapper for the given method so it can be
+// invoked from an interface. The wrapper takes in a pointer to the underlying
+// 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"
 	wrapper := c.mod.NamedFunction(wrapperName)
 	if !wrapper.IsNil() {
@@ -445,7 +446,10 @@ func (c *Compiler) getInterfaceInvokeWrapper(f *ir.Function) llvm.Value {

 	// Get the expanded receiver type.
 	receiverType := c.getLLVMType(f.Params[0].Type())
-	expandedReceiverType := c.expandFormalParamType(receiverType)
+	var expandedReceiverType []llvm.Type
+	for _, info := range expandFormalParamType(receiverType, "", nil) {
+		expandedReceiverType = append(expandedReceiverType, info.llvmType)
+	}

 	// Does this method even need any wrapping?
 	if len(expandedReceiverType) == 1 && receiverType.TypeKind() == llvm.PointerTypeKind {
@@ -461,44 +465,38 @@ func (c *Compiler) getInterfaceInvokeWrapper(f *ir.Function) llvm.Value {
 	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")
-	}
-	c.interfaceInvokeWrappers = append(c.interfaceInvokeWrappers, interfaceInvokeWrapper{
-		fn:           f,
-		wrapper:      wrapper,
-		receiverType: receiverType,
-	})
-	return wrapper
-}
+	wrapper.LastParam().SetName("parentHandle")

-// createInterfaceInvokeWrapper finishes the work of getInterfaceInvokeWrapper,
-// see that function for details.
-func (c *Compiler) createInterfaceInvokeWrapper(state interfaceInvokeWrapper) {
-	wrapper := state.wrapper
-	fn := state.fn
-	receiverType := state.receiverType
 	wrapper.SetLinkage(llvm.InternalLinkage)
 	wrapper.SetUnnamedAddr(true)

+	// Create a new builder just to create this wrapper.
+	b := builder{
+		compilerContext: c,
+		Builder:         c.ctx.NewBuilder(),
+	}
+	defer b.Builder.Dispose()
+
 	// add debug info if needed
 	if c.Debug() {
-		pos := c.ir.Program.Fset.Position(fn.Pos())
-		difunc := c.attachDebugInfoRaw(fn, wrapper, "$invoke", pos.Filename, pos.Line)
-		c.builder.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), difunc, llvm.Metadata{})
+		pos := c.ir.Program.Fset.Position(f.Pos())
+		difunc := c.attachDebugInfoRaw(f, wrapper, "$invoke", pos.Filename, pos.Line)
+		b.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), difunc, llvm.Metadata{})
 	}

 	// set up IR builder
-	block := c.ctx.AddBasicBlock(wrapper, "entry")
-	c.builder.SetInsertPointAtEnd(block)
+	block := b.ctx.AddBasicBlock(wrapper, "entry")
+	b.SetInsertPointAtEnd(block)

-	receiverValue := c.emitPointerUnpack(wrapper.Param(0), []llvm.Type{receiverType})[0]
-	params := append(c.expandFormalParam(receiverValue), wrapper.Params()[1:]...)
-	if fn.LLVMFn.Type().ElementType().ReturnType().TypeKind() == llvm.VoidTypeKind {
-		c.builder.CreateCall(fn.LLVMFn, params, "")
-		c.builder.CreateRetVoid()
+	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, "")
+		b.CreateRetVoid()
 	} else {
-		ret := c.builder.CreateCall(fn.LLVMFn, params, "ret")
-		c.builder.CreateRet(ret)
+		ret := b.CreateCall(f.LLVMFn, params, "ret")
+		b.CreateRet(ret)
 	}
+
+	return wrapper
 }
@@ -8,61 +8,62 @@ import (
 	"tinygo.org/x/go-llvm"
 )

-// emitInterruptGlobal creates a new runtime/interrupt.Interrupt struct that
+// createInterruptGlobal creates a new runtime/interrupt.Interrupt struct that
 // will be lowered to a real interrupt during interrupt lowering.
 //
 // This two-stage approach allows unused interrupts to be optimized away if
 // necessary.
-func (c *Compiler) emitInterruptGlobal(frame *Frame, instr *ssa.CallCommon) (llvm.Value, error) {
+func (b *builder) createInterruptGlobal(instr *ssa.CallCommon) (llvm.Value, error) {
 	// Get the interrupt number, which must be a compile-time constant.
 	id, ok := instr.Args[0].(*ssa.Const)
 	if !ok {
-		return llvm.Value{}, c.makeError(instr.Pos(), "interrupt ID is not a constant")
+		return llvm.Value{}, b.makeError(instr.Pos(), "interrupt ID is not a constant")
 	}

 	// Get the func value, which also must be a compile time constant.
 	// Note that bound functions are allowed if the function has a pointer
 	// receiver and is a global. This is rather strict but still allows for
 	// idiomatic Go code.
-	funcValue := c.getValue(frame, instr.Args[1])
+	funcValue := b.getValue(instr.Args[1])
 	if funcValue.IsAConstant().IsNil() {
 		// Try to determine the cause of the non-constantness for a nice error
 		// message.
 		switch instr.Args[1].(type) {
 		case *ssa.MakeClosure:
 			// This may also be a bound method.
-			return llvm.Value{}, c.makeError(instr.Pos(), "closures are not supported in interrupt.New")
+			return llvm.Value{}, b.makeError(instr.Pos(), "closures are not supported in interrupt.New")
 		}
 		// Fall back to a generic error.
-		return llvm.Value{}, c.makeError(instr.Pos(), "interrupt function must be constant")
+		return llvm.Value{}, b.makeError(instr.Pos(), "interrupt function must be constant")
 	}

 	// Create a new global of type runtime/interrupt.handle. Globals of this
 	// type are lowered in the interrupt lowering pass.
-	globalType := c.ir.Program.ImportedPackage("runtime/interrupt").Type("handle").Type()
-	globalLLVMType := c.getLLVMType(globalType)
+	globalType := b.ir.Program.ImportedPackage("runtime/interrupt").Type("handle").Type()
+	globalLLVMType := b.getLLVMType(globalType)
 	globalName := "runtime/interrupt.$interrupt" + strconv.FormatInt(id.Int64(), 10)
-	if global := c.mod.NamedGlobal(globalName); !global.IsNil() {
-		return llvm.Value{}, c.makeError(instr.Pos(), "interrupt redeclared in this program")
+	if global := b.mod.NamedGlobal(globalName); !global.IsNil() {
+		return llvm.Value{}, b.makeError(instr.Pos(), "interrupt redeclared in this program")
 	}
-	global := llvm.AddGlobal(c.mod, globalLLVMType, globalName)
+	global := llvm.AddGlobal(b.mod, globalLLVMType, globalName)
 	global.SetLinkage(llvm.PrivateLinkage)
 	global.SetGlobalConstant(true)
+	global.SetUnnamedAddr(true)
 	initializer := llvm.ConstNull(globalLLVMType)
 	initializer = llvm.ConstInsertValue(initializer, funcValue, []uint32{0})
-	initializer = llvm.ConstInsertValue(initializer, llvm.ConstInt(c.intType, uint64(id.Int64()), true), []uint32{1, 0})
+	initializer = llvm.ConstInsertValue(initializer, llvm.ConstInt(b.intType, uint64(id.Int64()), true), []uint32{1, 0})
 	global.SetInitializer(initializer)

 	// Add debug info to the interrupt global.
-	if c.Debug() {
-		pos := c.ir.Program.Fset.Position(instr.Pos())
-		diglobal := c.dibuilder.CreateGlobalVariableExpression(c.difiles[pos.Filename], llvm.DIGlobalVariableExpression{
+	if b.Debug() {
+		pos := b.ir.Program.Fset.Position(instr.Pos())
+		diglobal := b.dibuilder.CreateGlobalVariableExpression(b.getDIFile(pos.Filename), llvm.DIGlobalVariableExpression{
 			Name:        "interrupt" + strconv.FormatInt(id.Int64(), 10),
 			LinkageName: globalName,
-			File:        c.getDIFile(pos.Filename),
+			File:        b.getDIFile(pos.Filename),
 			Line:        pos.Line,
-			Type:        c.getDIType(globalType),
-			Expr:        c.dibuilder.CreateExpression(nil),
+			Type:        b.getDIType(globalType),
+			Expr:        b.dibuilder.CreateExpression(nil),
 			LocalToUnit: false,
 		})
 		global.AddMetadata(0, diglobal)
@@ -70,21 +71,21 @@ func (c *Compiler) emitInterruptGlobal(frame *Frame, instr *ssa.CallCommon) (llv

 	// Create the runtime/interrupt.Interrupt type. It is a struct with a single
 	// member of type int.
-	num := llvm.ConstPtrToInt(global, c.intType)
-	interrupt := llvm.ConstNamedStruct(c.mod.GetTypeByName("runtime/interrupt.Interrupt"), []llvm.Value{num})
+	num := llvm.ConstPtrToInt(global, b.intType)
+	interrupt := llvm.ConstNamedStruct(b.mod.GetTypeByName("runtime/interrupt.Interrupt"), []llvm.Value{num})

 	// Add dummy "use" call for AVR, because interrupts may be used even though
 	// they are never referenced again. This is unlike Cortex-M or the RISC-V
 	// 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(c.Triple(), "avr") {
-		useFn := c.mod.NamedFunction("runtime/interrupt.use")
+	if strings.HasPrefix(b.Triple(), "avr") {
+		useFn := b.mod.NamedFunction("runtime/interrupt.use")
 		if useFn.IsNil() {
-			useFnType := llvm.FunctionType(c.ctx.VoidType(), []llvm.Type{interrupt.Type()}, false)
-			useFn = llvm.AddFunction(c.mod, "runtime/interrupt.use", useFnType)
+			useFnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{interrupt.Type()}, false)
+			useFn = llvm.AddFunction(b.mod, "runtime/interrupt.use", useFnType)
 		}
-		c.builder.CreateCall(useFn, []llvm.Value{interrupt}, "")
+		b.CreateCall(useFn, []llvm.Value{interrupt}, "")
 	}

 	return interrupt, nil
@@ -0,0 +1,50 @@
+package compiler
+
+// This file contains helper functions to create calls to LLVM intrinsics.
+
+import (
+	"strconv"
+
+	"golang.org/x/tools/go/ssa"
+	"tinygo.org/x/go-llvm"
+)
+
+// createMemoryCopyCall creates a call to a builtin LLVM memcpy or memmove
+// function, declaring this function if needed. These calls are treated
+// specially by optimization passes possibly resulting in better generated code,
+// and will otherwise be lowered to regular libc memcpy/memmove calls.
+func (b *builder) createMemoryCopyCall(fn *ssa.Function, args []ssa.Value) (llvm.Value, error) {
+	fnName := "llvm." + fn.Name() + ".p0i8.p0i8.i" + strconv.Itoa(b.uintptrType.IntTypeWidth())
+	llvmFn := b.mod.NamedFunction(fnName)
+	if llvmFn.IsNil() {
+		fnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{b.i8ptrType, b.i8ptrType, b.uintptrType, b.ctx.Int1Type()}, false)
+		llvmFn = llvm.AddFunction(b.mod, fnName, fnType)
+	}
+	var params []llvm.Value
+	for _, param := range args {
+		params = append(params, b.getValue(param))
+	}
+	params = append(params, llvm.ConstInt(b.ctx.Int1Type(), 0, false))
+	b.CreateCall(llvmFn, params, "")
+	return llvm.Value{}, nil
+}
+
+// createMemoryZeroCall creates calls to llvm.memset.* to zero a block of
+// memory, declaring the function if needed. These calls will be lowered to
+// regular libc memset calls if they aren't optimized out in a different way.
+func (b *builder) createMemoryZeroCall(args []ssa.Value) (llvm.Value, error) {
+	fnName := "llvm.memset.p0i8.i" + strconv.Itoa(b.uintptrType.IntTypeWidth())
+	llvmFn := b.mod.NamedFunction(fnName)
+	if llvmFn.IsNil() {
+		fnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{b.i8ptrType, b.ctx.Int8Type(), b.uintptrType, b.ctx.Int1Type()}, false)
+		llvmFn = llvm.AddFunction(b.mod, fnName, fnType)
+	}
+	params := []llvm.Value{
+		b.getValue(args[0]),
+		llvm.ConstInt(b.ctx.Int8Type(), 0, false),
+		b.getValue(args[1]),
+		llvm.ConstInt(b.ctx.Int1Type(), 0, false),
+	}
+	b.CreateCall(llvmFn, params, "")
+	return llvm.Value{}, nil
+}
@@ -1,7 +1,8 @@
-package compiler
-
-// This file implements a set of sanity checks for the IR that is generated.
-// It can catch some mistakes that LLVM's verifier cannot.
+// Package ircheck implements a checker for LLVM IR, that goes a bit further
+// than the regular LLVM IR verifier. Note that it checks different things, so
+// this is not a replacement for the LLVM verifier but does catch things that
+// the LLVM verifier doesn't catch.
+package ircheck

 import (
 	"errors"
@@ -10,7 +11,11 @@ import (
 	"tinygo.org/x/go-llvm"
 )

-func (c *Compiler) checkType(t llvm.Type, checked map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) error {
+type checker struct {
+	ctx llvm.Context
+}
+
+func (c *checker) checkType(t llvm.Type, checked map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) error {
 	// prevent infinite recursion for self-referential types
 	if _, ok := checked[t]; ok {
 		return nil
@@ -81,7 +86,7 @@ func (c *Compiler) checkType(t llvm.Type, checked map[llvm.Type]struct{}, specia
 	return nil
 }

-func (c *Compiler) checkValue(v llvm.Value, types map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) error {
+func (c *checker) checkValue(v llvm.Value, types map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) error {
 	// check type
 	if err := c.checkType(v.Type(), types, specials); err != nil {
 		return fmt.Errorf("failed to verify type of value: %s", err.Error())
@@ -95,12 +100,30 @@ func (c *Compiler) checkValue(v llvm.Value, types map[llvm.Type]struct{}, specia
 	return nil
 }

-func (c *Compiler) checkInstruction(inst llvm.Value, types map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) error {
+func (c *checker) checkInstruction(inst llvm.Value, types map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) error {
 	// check value properties
 	if err := c.checkValue(inst, types, specials); err != nil {
 		return errorAt(inst, err.Error())
 	}

+	// The alloca instruction can be present in every basic block. However,
+	// allocas in basic blocks other than the entry basic block have a number of
+	// problems:
+	//   * They are hard to optimize, leading to potential missed optimizations.
+	//   * They may cause stack overflows in loops that would otherwise be
+	//     innocent.
+	//   * They cause extra code to be generated, because it requires the use of
+	//     a frame pointer.
+	//   * Perhaps most importantly, the coroutine lowering pass of LLVM (as of
+	//     LLVM 9) cannot deal with these allocas:
+	//     https://llvm.org/docs/Coroutines.html
+	// Therefore, alloca instructions should be limited to the entry block.
+	if !inst.IsAAllocaInst().IsNil() {
+		if inst.InstructionParent() != inst.InstructionParent().Parent().EntryBasicBlock() {
+			return errorAt(inst, "internal error: non-static alloca")
+		}
+	}
+
 	// check operands
 	for i := 0; i < inst.OperandsCount(); i++ {
 		if err := c.checkValue(inst.Operand(i), types, specials); err != nil {
@@ -111,7 +134,7 @@ func (c *Compiler) checkInstruction(inst llvm.Value, types map[llvm.Type]struct{
 	return nil
 }

-func (c *Compiler) checkBasicBlock(bb llvm.BasicBlock, types map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) []error {
+func (c *checker) checkBasicBlock(bb llvm.BasicBlock, types map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) []error {
 	// check basic block value and type
 	var errs []error
 	if err := c.checkValue(bb.AsValue(), types, specials); err != nil {
@@ -128,7 +151,7 @@ func (c *Compiler) checkBasicBlock(bb llvm.BasicBlock, types map[llvm.Type]struc
 	return errs
 }

-func (c *Compiler) checkFunction(fn llvm.Value, types map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) []error {
+func (c *checker) checkFunction(fn llvm.Value, types map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) []error {
 	// check function value and type
 	var errs []error
 	if err := c.checkValue(fn, types, specials); err != nil {
@@ -143,26 +166,25 @@ func (c *Compiler) checkFunction(fn llvm.Value, types map[llvm.Type]struct{}, sp
 	return errs
 }

-func (c *Compiler) checkModule() []error {
+// Module checks the given module and returns a slice of error, if there are
+// any.
+func Module(mod llvm.Module) []error {
 	// check for any context mismatches
 	var errs []error
-	switch {
-	case c.mod.Context() == c.ctx:
-		// this is correct
-	case c.mod.Context() == llvm.GlobalContext():
+	c := checker{
+		ctx: mod.Context(),
+	}
+	if c.ctx == llvm.GlobalContext() {
 		// somewhere we accidentally used the global context instead of a real context
 		errs = append(errs, errors.New("module uses global context"))
-	default:
-		// we used some other context by accident
-		errs = append(errs, fmt.Errorf("module uses context %v instead of the main context %v", c.mod.Context(), c.ctx))
 	}

 	types := map[llvm.Type]struct{}{}
 	specials := map[llvm.TypeKind]llvm.Type{}
-	for fn := c.mod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
+	for fn := mod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
 		errs = append(errs, c.checkFunction(fn, types, specials)...)
 	}
-	for g := c.mod.FirstGlobal(); !g.IsNil(); g = llvm.NextGlobal(g) {
+	for g := mod.FirstGlobal(); !g.IsNil(); g = llvm.NextGlobal(g) {
 		if err := c.checkValue(g, types, specials); err != nil {
 			errs = append(errs, fmt.Errorf("failed to verify global %s of module: %s", g.Name(), err.Error()))
 		}
@@ -0,0 +1,48 @@
+package ircheck
+
+import (
+	"go/scanner"
+	"go/token"
+	"path/filepath"
+
+	"tinygo.org/x/go-llvm"
+)
+
+// errorAt returns an error value at the location of the instruction.
+// The location information may not be complete as it depends on debug
+// information in the IR.
+func errorAt(inst llvm.Value, msg string) scanner.Error {
+	return scanner.Error{
+		Pos: getPosition(inst),
+		Msg: msg,
+	}
+}
+
+// getPosition returns the position information for the given value, as far as
+// it is available.
+func getPosition(val llvm.Value) token.Position {
+	if !val.IsAInstruction().IsNil() {
+		loc := val.InstructionDebugLoc()
+		if loc.IsNil() {
+			return token.Position{}
+		}
+		file := loc.LocationScope().ScopeFile()
+		return token.Position{
+			Filename: filepath.Join(file.FileDirectory(), file.FileFilename()),
+			Line:     int(loc.LocationLine()),
+			Column:   int(loc.LocationColumn()),
+		}
+	} else if !val.IsAFunction().IsNil() {
+		loc := val.Subprogram()
+		if loc.IsNil() {
+			return token.Position{}
+		}
+		file := loc.ScopeFile()
+		return token.Position{
+			Filename: filepath.Join(file.FileDirectory(), file.FileFilename()),
+			Line:     int(loc.SubprogramLine()),
+		}
+	} else {
+		return token.Position{}
+	}
+}
@@ -24,39 +24,39 @@ func getUses(value llvm.Value) []llvm.Value {
 }

 // createTemporaryAlloca creates a new alloca in the entry block and adds
-// lifetime start infromation in the IR signalling that the alloca won't be used
+// lifetime start information in the IR signalling that the alloca won't be used
 // before this point.
 //
 // This is useful for creating temporary allocas for intrinsics. Don't forget to
 // end the lifetime using emitLifetimeEnd after you're done with it.
-func (c *Compiler) createTemporaryAlloca(t llvm.Type, name string) (alloca, bitcast, size llvm.Value) {
-	return llvmutil.CreateTemporaryAlloca(c.builder, c.mod, t, name)
+func (b *builder) createTemporaryAlloca(t llvm.Type, name string) (alloca, bitcast, size llvm.Value) {
+	return llvmutil.CreateTemporaryAlloca(b.Builder, b.mod, t, name)
 }

 // emitLifetimeEnd signals the end of an (alloca) lifetime by calling the
 // llvm.lifetime.end intrinsic. It is commonly used together with
 // createTemporaryAlloca.
-func (c *Compiler) emitLifetimeEnd(ptr, size llvm.Value) {
-	llvmutil.EmitLifetimeEnd(c.builder, c.mod, ptr, size)
+func (b *builder) emitLifetimeEnd(ptr, size llvm.Value) {
+	llvmutil.EmitLifetimeEnd(b.Builder, b.mod, ptr, size)
 }

 // emitPointerPack packs the list of values into a single pointer value using
 // 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 (c *Compiler) emitPointerPack(values []llvm.Value) llvm.Value {
-	return llvmutil.EmitPointerPack(c.builder, c.mod, c.Config, values)
+func (b *builder) emitPointerPack(values []llvm.Value) llvm.Value {
+	return llvmutil.EmitPointerPack(b.Builder, b.mod, b.Config, values)
 }

 // emitPointerUnpack extracts a list of values packed using emitPointerPack.
-func (c *Compiler) emitPointerUnpack(ptr llvm.Value, valueTypes []llvm.Type) []llvm.Value {
-	return llvmutil.EmitPointerUnpack(c.builder, c.mod, ptr, valueTypes)
+func (b *builder) emitPointerUnpack(ptr llvm.Value, valueTypes []llvm.Type) []llvm.Value {
+	return llvmutil.EmitPointerUnpack(b.Builder, b.mod, ptr, valueTypes)
 }

 // makeGlobalArray creates a new LLVM global with the given name and integers as
 // contents, and returns the global.
 // Note that it is left with the default linkage etc., you should set
 // linkage/constant/etc properties yourself.
-func (c *Compiler) makeGlobalArray(buf []byte, name string, elementType llvm.Type) llvm.Value {
+func (c *compilerContext) makeGlobalArray(buf []byte, name string, elementType llvm.Type) llvm.Value {
 	globalType := llvm.ArrayType(elementType, len(buf))
 	global := llvm.AddGlobal(c.mod, globalType, name)
 	value := llvm.Undef(globalType)
@@ -12,6 +12,7 @@ import (
 // EmitPointerPack packs the list of values into a single pointer value using
 // 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 {
 	ctx := mod.Context()
 	targetData := llvm.NewTargetData(mod.DataLayout())
@@ -25,7 +26,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)
@@ -38,14 +38,65 @@ 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
+		for _, v := range values {
+			if !v.IsConstant() {
+				constant = false
+				break
+			}
+		}
+
+		if constant {
+			// The data is known at compile time, so store it in a constant global.
+			// The global address is marked as unnamed, which allows LLVM to merge duplicates.
+			funcName := builder.GetInsertBlock().Parent().Name()
+			global := llvm.AddGlobal(mod, packedType, funcName+"$pack")
+			global.SetInitializer(ctx.ConstStruct(values, false))
+			global.SetGlobalConstant(true)
+			global.SetUnnamedAddr(true)
+			global.SetLinkage(llvm.PrivateLinkage)
+			return llvm.ConstBitCast(global, i8ptrType)
+		}
+
 		// 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
@@ -58,28 +109,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
 	}
 }
@@ -6,115 +6,167 @@ import (
 	"go/token"
 	"go/types"

+	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )

-func (c *Compiler) emitMapLookup(keyType, valueType types.Type, m, key llvm.Value, commaOk bool, pos token.Pos) (llvm.Value, error) {
-	llvmValueType := c.getLLVMType(valueType)
+// createMakeMap creates a new map object (runtime.hashmap) by allocating and
+// initializing an appropriately sized object.
+func (b *builder) createMakeMap(expr *ssa.MakeMap) (llvm.Value, error) {
+	mapType := expr.Type().Underlying().(*types.Map)
+	keyType := mapType.Key().Underlying()
+	llvmValueType := b.getLLVMType(mapType.Elem().Underlying())
+	var llvmKeyType llvm.Type
+	if t, ok := keyType.(*types.Basic); ok && t.Info()&types.IsString != 0 {
+		// String keys.
+		llvmKeyType = b.getLLVMType(keyType)
+	} else if hashmapIsBinaryKey(keyType) {
+		// Trivially comparable keys.
+		llvmKeyType = b.getLLVMType(keyType)
+	} else {
+		// All other keys. Implemented as map[interface{}]valueType for ease of
+		// implementation.
+		llvmKeyType = b.getLLVMRuntimeType("_interface")
+	}
+	keySize := b.targetData.TypeAllocSize(llvmKeyType)
+	valueSize := b.targetData.TypeAllocSize(llvmValueType)
+	llvmKeySize := llvm.ConstInt(b.ctx.Int8Type(), keySize, false)
+	llvmValueSize := llvm.ConstInt(b.ctx.Int8Type(), valueSize, false)
+	sizeHint := llvm.ConstInt(b.uintptrType, 8, false)
+	if expr.Reserve != nil {
+		sizeHint = b.getValue(expr.Reserve)
+		var err error
+		sizeHint, err = b.createConvert(expr.Reserve.Type(), types.Typ[types.Uintptr], sizeHint, expr.Pos())
+		if err != nil {
+			return llvm.Value{}, err
+		}
+	}
+	hashmap := b.createRuntimeCall("hashmapMake", []llvm.Value{llvmKeySize, llvmValueSize, sizeHint}, "")
+	return hashmap, nil
+}
+
+// createMapLookup returns the value in a map. It calls a runtime function
+// depending on the map key type to load the map value and its comma-ok value.
+func (b *builder) createMapLookup(keyType, valueType types.Type, m, key llvm.Value, commaOk bool, pos token.Pos) (llvm.Value, error) {
+	llvmValueType := b.getLLVMType(valueType)

 	// Allocate the memory for the resulting type. Do not zero this memory: it
 	// will be zeroed by the hashmap get implementation if the key is not
 	// present in the map.
-	mapValueAlloca, mapValuePtr, mapValueSize := c.createTemporaryAlloca(llvmValueType, "hashmap.value")
+	mapValueAlloca, mapValuePtr, mapValueAllocaSize := b.createTemporaryAlloca(llvmValueType, "hashmap.value")
+
+	// We need the map size (with type uintptr) to pass to the hashmap*Get
+	// functions. This is necessary because those *Get functions are valid on
+	// nil maps, and they'll need to zero the value pointer by that number of
+	// bytes.
+	mapValueSize := mapValueAllocaSize
+	if mapValueSize.Type().IntTypeWidth() > b.uintptrType.IntTypeWidth() {
+		mapValueSize = llvm.ConstTrunc(mapValueSize, b.uintptrType)
+	}

 	// Do the lookup. How it is done depends on the key type.
 	var commaOkValue llvm.Value
+	keyType = keyType.Underlying()
 	if t, ok := keyType.(*types.Basic); ok && t.Info()&types.IsString != 0 {
 		// key is a string
-		params := []llvm.Value{m, key, mapValuePtr}
-		commaOkValue = c.createRuntimeCall("hashmapStringGet", params, "")
+		params := []llvm.Value{m, key, mapValuePtr, mapValueSize}
+		commaOkValue = b.createRuntimeCall("hashmapStringGet", params, "")
 	} else if hashmapIsBinaryKey(keyType) {
 		// key can be compared with runtime.memequal
 		// Store the key in an alloca, in the entry block to avoid dynamic stack
 		// growth.
-		mapKeyAlloca, mapKeyPtr, mapKeySize := c.createTemporaryAlloca(key.Type(), "hashmap.key")
-		c.builder.CreateStore(key, mapKeyAlloca)
+		mapKeyAlloca, mapKeyPtr, mapKeySize := b.createTemporaryAlloca(key.Type(), "hashmap.key")
+		b.CreateStore(key, mapKeyAlloca)
 		// Fetch the value from the hashmap.
-		params := []llvm.Value{m, mapKeyPtr, mapValuePtr}
-		commaOkValue = c.createRuntimeCall("hashmapBinaryGet", params, "")
-		c.emitLifetimeEnd(mapKeyPtr, mapKeySize)
+		params := []llvm.Value{m, mapKeyPtr, mapValuePtr, mapValueSize}
+		commaOkValue = b.createRuntimeCall("hashmapBinaryGet", params, "")
+		b.emitLifetimeEnd(mapKeyPtr, mapKeySize)
 	} else {
-		// Not trivially comparable using memcmp.
-		return llvm.Value{}, c.makeError(pos, "only strings, bools, ints, pointers or structs of bools/ints are supported as map keys, but got: "+keyType.String())
+		// Not trivially comparable using memcmp. Make it an interface instead.
+		itfKey := key
+		if _, ok := keyType.(*types.Interface); !ok {
+			// Not already an interface, so convert it to an interface now.
+			itfKey = b.createMakeInterface(key, keyType, pos)
+		}
+		params := []llvm.Value{m, itfKey, mapValuePtr, mapValueSize}
+		commaOkValue = b.createRuntimeCall("hashmapInterfaceGet", params, "")
 	}

 	// Load the resulting value from the hashmap. The value is set to the zero
 	// value if the key doesn't exist in the hashmap.
-	mapValue := c.builder.CreateLoad(mapValueAlloca, "")
-	c.emitLifetimeEnd(mapValuePtr, mapValueSize)
+	mapValue := b.CreateLoad(mapValueAlloca, "")
+	b.emitLifetimeEnd(mapValuePtr, mapValueAllocaSize)

 	if commaOk {
-		tuple := llvm.Undef(c.ctx.StructType([]llvm.Type{llvmValueType, c.ctx.Int1Type()}, false))
-		tuple = c.builder.CreateInsertValue(tuple, mapValue, 0, "")
-		tuple = c.builder.CreateInsertValue(tuple, commaOkValue, 1, "")
+		tuple := llvm.Undef(b.ctx.StructType([]llvm.Type{llvmValueType, b.ctx.Int1Type()}, false))
+		tuple = b.CreateInsertValue(tuple, mapValue, 0, "")
+		tuple = b.CreateInsertValue(tuple, commaOkValue, 1, "")
 		return tuple, nil
 	} else {
 		return mapValue, nil
 	}
 }

-func (c *Compiler) emitMapUpdate(keyType types.Type, m, key, value llvm.Value, pos token.Pos) {
-	valueAlloca, valuePtr, valueSize := c.createTemporaryAlloca(value.Type(), "hashmap.value")
-	c.builder.CreateStore(value, valueAlloca)
+// createMapUpdate updates a map key to a given value, by creating an
+// appropriate runtime call.
+func (b *builder) createMapUpdate(keyType types.Type, m, key, value llvm.Value, pos token.Pos) {
+	valueAlloca, valuePtr, valueSize := b.createTemporaryAlloca(value.Type(), "hashmap.value")
+	b.CreateStore(value, valueAlloca)
 	keyType = keyType.Underlying()
 	if t, ok := keyType.(*types.Basic); ok && t.Info()&types.IsString != 0 {
 		// key is a string
 		params := []llvm.Value{m, key, valuePtr}
-		c.createRuntimeCall("hashmapStringSet", params, "")
+		b.createRuntimeCall("hashmapStringSet", params, "")
 	} else if hashmapIsBinaryKey(keyType) {
 		// key can be compared with runtime.memequal
-		keyAlloca, keyPtr, keySize := c.createTemporaryAlloca(key.Type(), "hashmap.key")
-		c.builder.CreateStore(key, keyAlloca)
+		keyAlloca, keyPtr, keySize := b.createTemporaryAlloca(key.Type(), "hashmap.key")
+		b.CreateStore(key, keyAlloca)
 		params := []llvm.Value{m, keyPtr, valuePtr}
-		c.createRuntimeCall("hashmapBinarySet", params, "")
-		c.emitLifetimeEnd(keyPtr, keySize)
+		b.createRuntimeCall("hashmapBinarySet", params, "")
+		b.emitLifetimeEnd(keyPtr, keySize)
 	} else {
-		c.addError(pos, "only strings, bools, ints, pointers or structs of bools/ints are supported as map keys, but got: "+keyType.String())
+		// Key is not trivially comparable, so compare it as an interface instead.
+		itfKey := key
+		if _, ok := keyType.(*types.Interface); !ok {
+			// Not already an interface, so convert it to an interface first.
+			itfKey = b.createMakeInterface(key, keyType, pos)
+		}
+		params := []llvm.Value{m, itfKey, valuePtr}
+		b.createRuntimeCall("hashmapInterfaceSet", params, "")
 	}
-	c.emitLifetimeEnd(valuePtr, valueSize)
+	b.emitLifetimeEnd(valuePtr, valueSize)
 }

-func (c *Compiler) emitMapDelete(keyType types.Type, m, key llvm.Value, pos token.Pos) error {
+// createMapDelete deletes a key from a map by calling the appropriate runtime
+// function. It is the implementation of the Go delete() builtin.
+func (b *builder) createMapDelete(keyType types.Type, m, key llvm.Value, pos token.Pos) error {
 	keyType = keyType.Underlying()
 	if t, ok := keyType.(*types.Basic); ok && t.Info()&types.IsString != 0 {
 		// key is a string
 		params := []llvm.Value{m, key}
-		c.createRuntimeCall("hashmapStringDelete", params, "")
+		b.createRuntimeCall("hashmapStringDelete", params, "")
 		return nil
 	} else if hashmapIsBinaryKey(keyType) {
-		keyAlloca, keyPtr, keySize := c.createTemporaryAlloca(key.Type(), "hashmap.key")
-		c.builder.CreateStore(key, keyAlloca)
+		keyAlloca, keyPtr, keySize := b.createTemporaryAlloca(key.Type(), "hashmap.key")
+		b.CreateStore(key, keyAlloca)
 		params := []llvm.Value{m, keyPtr}
-		c.createRuntimeCall("hashmapBinaryDelete", params, "")
-		c.emitLifetimeEnd(keyPtr, keySize)
+		b.createRuntimeCall("hashmapBinaryDelete", params, "")
+		b.emitLifetimeEnd(keyPtr, keySize)
 		return nil
 	} else {
-		return c.makeError(pos, "only strings, bools, ints, pointers or structs of bools/ints are supported as map keys, but got: "+keyType.String())
+		// Key is not trivially comparable, so compare it as an interface
+		// instead.
+		itfKey := key
+		if _, ok := keyType.(*types.Interface); !ok {
+			// Not already an interface, so convert it to an interface first.
+			itfKey = b.createMakeInterface(key, keyType, pos)
+		}
+		params := []llvm.Value{m, itfKey}
+		b.createRuntimeCall("hashmapInterfaceDelete", params, "")
+		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 hashmapHash(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 hashmapTopHash(hash uint32) uint8 {
-	tophash := uint8(hash >> 24)
-	if tophash < 1 {
-		// 0 means empty slot, so make it bigger.
-		tophash += 1
-	}
-	return tophash
-}
-
 // Returns true if this key type does not contain strings, interfaces etc., so
 // can be compared with runtime.memequal.
 func hashmapIsBinaryKey(keyType types.Type) bool {
@@ -1,164 +0,0 @@
-package compiler
-
-import (
-	"errors"
-
-	"github.com/tinygo-org/tinygo/transform"
-	"tinygo.org/x/go-llvm"
-)
-
-// Run the LLVM optimizer over the module.
-// The inliner can be disabled (if necessary) by passing 0 to the inlinerThreshold.
-func (c *Compiler) Optimize(optLevel, sizeLevel int, inlinerThreshold uint) []error {
-	builder := llvm.NewPassManagerBuilder()
-	defer builder.Dispose()
-	builder.SetOptLevel(optLevel)
-	builder.SetSizeLevel(sizeLevel)
-	if inlinerThreshold != 0 {
-		builder.UseInlinerWithThreshold(inlinerThreshold)
-	}
-	builder.AddCoroutinePassesToExtensionPoints()
-
-	if c.PanicStrategy() == "trap" {
-		transform.ReplacePanicsWithTrap(c.mod) // -panic=trap
-	}
-
-	// run a check of all of our code
-	if c.VerifyIR() {
-		errs := c.checkModule()
-		if errs != nil {
-			return errs
-		}
-	}
-
-	// Run function passes for each function.
-	funcPasses := llvm.NewFunctionPassManagerForModule(c.mod)
-	defer funcPasses.Dispose()
-	builder.PopulateFunc(funcPasses)
-	funcPasses.InitializeFunc()
-	for fn := c.mod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
-		funcPasses.RunFunc(fn)
-	}
-	funcPasses.FinalizeFunc()
-
-	if optLevel > 0 {
-		// Run some preparatory passes for the Go optimizer.
-		goPasses := llvm.NewPassManager()
-		defer goPasses.Dispose()
-		goPasses.AddGlobalDCEPass()
-		goPasses.AddGlobalOptimizerPass()
-		goPasses.AddConstantPropagationPass()
-		goPasses.AddAggressiveDCEPass()
-		goPasses.AddFunctionAttrsPass()
-		goPasses.Run(c.mod)
-
-		// Run Go-specific optimization passes.
-		transform.OptimizeMaps(c.mod)
-		transform.OptimizeStringToBytes(c.mod)
-		transform.OptimizeAllocs(c.mod)
-		transform.LowerInterfaces(c.mod)
-
-		errs := transform.LowerInterruptRegistrations(c.mod)
-		if len(errs) > 0 {
-			return errs
-		}
-
-		if c.funcImplementation() == funcValueSwitch {
-			transform.LowerFuncValues(c.mod)
-		}
-
-		// After interfaces are lowered, there are many more opportunities for
-		// interprocedural optimizations. To get them to work, function
-		// attributes have to be updated first.
-		goPasses.Run(c.mod)
-
-		// Run TinyGo-specific interprocedural optimizations.
-		transform.OptimizeAllocs(c.mod)
-		transform.OptimizeStringToBytes(c.mod)
-
-		// Lower runtime.isnil calls to regular nil comparisons.
-		isnil := c.mod.NamedFunction("runtime.isnil")
-		if !isnil.IsNil() {
-			for _, use := range getUses(isnil) {
-				c.builder.SetInsertPointBefore(use)
-				ptr := use.Operand(0)
-				if !ptr.IsABitCastInst().IsNil() {
-					ptr = ptr.Operand(0)
-				}
-				nilptr := llvm.ConstPointerNull(ptr.Type())
-				icmp := c.builder.CreateICmp(llvm.IntEQ, ptr, nilptr, "")
-				use.ReplaceAllUsesWith(icmp)
-				use.EraseFromParentAsInstruction()
-			}
-		}
-
-		err := c.LowerGoroutines()
-		if err != nil {
-			return []error{err}
-		}
-	} else {
-		// Must be run at any optimization level.
-		transform.LowerInterfaces(c.mod)
-		if c.funcImplementation() == funcValueSwitch {
-			transform.LowerFuncValues(c.mod)
-		}
-		err := c.LowerGoroutines()
-		if err != nil {
-			return []error{err}
-		}
-		errs := transform.LowerInterruptRegistrations(c.mod)
-		if len(errs) > 0 {
-			return errs
-		}
-	}
-	if c.VerifyIR() {
-		if errs := c.checkModule(); errs != nil {
-			return errs
-		}
-	}
-	if err := c.Verify(); err != nil {
-		return []error{errors.New("optimizations caused a verification failure")}
-	}
-
-	if sizeLevel >= 2 {
-		// Set the "optsize" attribute to make slightly smaller binaries at the
-		// cost of some performance.
-		kind := llvm.AttributeKindID("optsize")
-		attr := c.ctx.CreateEnumAttribute(kind, 0)
-		for fn := c.mod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
-			fn.AddFunctionAttr(attr)
-		}
-	}
-
-	// After TinyGo-specific transforms have finished, undo exporting these functions.
-	for _, name := range c.getFunctionsUsedInTransforms() {
-		fn := c.mod.NamedFunction(name)
-		if fn.IsNil() {
-			continue
-		}
-		fn.SetLinkage(llvm.InternalLinkage)
-	}
-
-	// Run function passes again, because without it, llvm.coro.size.i32()
-	// doesn't get lowered.
-	for fn := c.mod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
-		funcPasses.RunFunc(fn)
-	}
-	funcPasses.FinalizeFunc()
-
-	// Run module passes.
-	modPasses := llvm.NewPassManager()
-	defer modPasses.Dispose()
-	builder.Populate(modPasses)
-	modPasses.Run(c.mod)
-
-	hasGCPass := transform.AddGlobalsBitmap(c.mod)
-	hasGCPass = transform.MakeGCStackSlots(c.mod) || hasGCPass
-	if hasGCPass {
-		if err := c.Verify(); err != nil {
-			return []error{errors.New("GC pass caused a verification failure")}
-		}
-	}
-
-	return nil
-}
@@ -10,13 +10,13 @@ import (
 // The original license can be found here:
 //     https://golang.org/LICENSE

-type StdSizes struct {
+type stdSizes struct {
 	IntSize  int64
 	PtrSize  int64
 	MaxAlign int64
 }

-func (s *StdSizes) Alignof(T types.Type) int64 {
+func (s *stdSizes) Alignof(T types.Type) int64 {
 	// For arrays and structs, alignment is defined in terms
 	// of alignment of the elements and fields, respectively.
 	switch t := T.Underlying().(type) {
@@ -61,7 +61,7 @@ func (s *StdSizes) Alignof(T types.Type) int64 {
 	return a
 }

-func (s *StdSizes) Offsetsof(fields []*types.Var) []int64 {
+func (s *stdSizes) Offsetsof(fields []*types.Var) []int64 {
 	offsets := make([]int64, len(fields))
 	var o int64
 	for i, f := range fields {
@@ -89,7 +89,7 @@ var basicSizes = [...]byte{
 	types.Complex128: 16,
 }

-func (s *StdSizes) Sizeof(T types.Type) int64 {
+func (s *stdSizes) Sizeof(T types.Type) int64 {
 	switch t := T.Underlying().(type) {
 	case *types.Basic:
 		k := t.Kind()
@@ -26,7 +26,7 @@ type globalInfo struct {

 // loadASTComments loads comments on globals from the AST, for use later in the
 // program. In particular, they are required for //go:extern pragmas on globals.
-func (c *Compiler) loadASTComments(lprogram *loader.Program) {
+func (c *compilerContext) loadASTComments(lprogram *loader.Program) {
 	c.astComments = map[string]*ast.CommentGroup{}
 	for _, pkgInfo := range lprogram.Sorted() {
 		for _, file := range pkgInfo.Files {
@@ -56,7 +56,7 @@ func (c *Compiler) loadASTComments(lprogram *loader.Program) {

 // getGlobal returns a LLVM IR global value for a Go SSA global. It is added to
 // the LLVM IR if it has not been added already.
-func (c *Compiler) getGlobal(g *ssa.Global) llvm.Value {
+func (c *compilerContext) getGlobal(g *ssa.Global) llvm.Value {
 	info := c.getGlobalInfo(g)
 	llvmGlobal := c.mod.NamedGlobal(info.linkName)
 	if llvmGlobal.IsNil() {
@@ -82,7 +82,7 @@ func (c *Compiler) getGlobal(g *ssa.Global) llvm.Value {
 			}
 		}

-		if c.Debug() {
+		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.
@@ -104,7 +104,7 @@ func (c *Compiler) getGlobal(g *ssa.Global) llvm.Value {
 }

 // getGlobalInfo returns some information about a specific global.
-func (c *Compiler) getGlobalInfo(g *ssa.Global) globalInfo {
+func (c *compilerContext) getGlobalInfo(g *ssa.Global) globalInfo {
 	info := globalInfo{}
 	if strings.HasPrefix(g.Name(), "C.") {
 		// Created by CGo: such a name cannot be created by regular C code.
@@ -10,14 +10,14 @@ import (
 	"tinygo.org/x/go-llvm"
 )

-// emitSyscall emits an inline system call instruction, depending on the target
-// OS/arch.
-func (c *Compiler) emitSyscall(frame *Frame, call *ssa.CallCommon) (llvm.Value, error) {
-	num := c.getValue(frame, call.Args[0])
+// createSyscall emits an inline system call instruction, depending on the
+// target OS/arch.
+func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
+	num := b.getValue(call.Args[0])
 	var syscallResult llvm.Value
 	switch {
-	case c.GOARCH() == "amd64":
-		if c.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.
@@ -28,13 +28,13 @@ func (c *Compiler) emitSyscall(frame *Frame, call *ssa.CallCommon) (llvm.Value,
 			// > All system classes enter the kernel via the syscall instruction.
 			//
 			// Source: https://opensource.apple.com/source/xnu/xnu-792.13.8/osfmk/mach/i386/syscall_sw.h
-			num = c.builder.CreateOr(num, llvm.ConstInt(c.uintptrType, 0x2000000, false), "")
+			num = b.CreateOr(num, llvm.ConstInt(b.uintptrType, 0x2000000, false), "")
 		}
 		// Sources:
 		//   https://stackoverflow.com/a/2538212
 		//   https://en.wikibooks.org/wiki/X86_Assembly/Interfacing_with_Linux#syscall
 		args := []llvm.Value{num}
-		argTypes := []llvm.Type{c.uintptrType}
+		argTypes := []llvm.Type{b.uintptrType}
 		// Constraints will look something like:
 		//   "={rax},0,{rdi},{rsi},{rdx},{r10},{r8},{r9},~{rcx},~{r11}"
 		constraints := "={rax},0"
@@ -50,21 +50,21 @@ func (c *Compiler) emitSyscall(frame *Frame, call *ssa.CallCommon) (llvm.Value,
 				"{r12}",
 				"{r13}",
 			}[i]
-			llvmValue := c.getValue(frame, arg)
+			llvmValue := b.getValue(arg)
 			args = append(args, llvmValue)
 			argTypes = append(argTypes, llvmValue.Type())
 		}
 		constraints += ",~{rcx},~{r11}"
-		fnType := llvm.FunctionType(c.uintptrType, argTypes, false)
+		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
 		target := llvm.InlineAsm(fnType, "syscall", constraints, true, false, llvm.InlineAsmDialectIntel)
-		syscallResult = c.builder.CreateCall(target, args, "")
-	case c.GOARCH() == "386" && c.GOOS() == "linux":
+		syscallResult = b.CreateCall(target, args, "")
+	case b.GOARCH() == "386" && b.GOOS() == "linux":
 		// Sources:
 		//   syscall(2) man page
 		//   https://stackoverflow.com/a/2538212
 		//   https://en.wikibooks.org/wiki/X86_Assembly/Interfacing_with_Linux#int_0x80
 		args := []llvm.Value{num}
-		argTypes := []llvm.Type{c.uintptrType}
+		argTypes := []llvm.Type{b.uintptrType}
 		// Constraints will look something like:
 		//   "={eax},0,{ebx},{ecx},{edx},{esi},{edi},{ebp}"
 		constraints := "={eax},0"
@@ -77,14 +77,14 @@ func (c *Compiler) emitSyscall(frame *Frame, call *ssa.CallCommon) (llvm.Value,
 				"{edi}",
 				"{ebp}",
 			}[i]
-			llvmValue := c.getValue(frame, arg)
+			llvmValue := b.getValue(arg)
 			args = append(args, llvmValue)
 			argTypes = append(argTypes, llvmValue.Type())
 		}
-		fnType := llvm.FunctionType(c.uintptrType, argTypes, false)
+		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
 		target := llvm.InlineAsm(fnType, "int 0x80", constraints, true, false, llvm.InlineAsmDialectIntel)
-		syscallResult = c.builder.CreateCall(target, args, "")
-	case c.GOARCH() == "arm" && c.GOOS() == "linux":
+		syscallResult = b.CreateCall(target, args, "")
+	case b.GOARCH() == "arm" && b.GOOS() == "linux":
 		// Implement the EABI system call convention for Linux.
 		// Source: syscall(2) man page.
 		args := []llvm.Value{}
@@ -102,21 +102,21 @@ func (c *Compiler) emitSyscall(frame *Frame, call *ssa.CallCommon) (llvm.Value,
 				"{r5}",
 				"{r6}",
 			}[i]
-			llvmValue := c.getValue(frame, arg)
+			llvmValue := b.getValue(arg)
 			args = append(args, llvmValue)
 			argTypes = append(argTypes, llvmValue.Type())
 		}
 		args = append(args, num)
-		argTypes = append(argTypes, c.uintptrType)
+		argTypes = append(argTypes, b.uintptrType)
 		constraints += ",{r7}" // syscall number
 		for i := len(call.Args) - 1; i < 4; i++ {
 			// r0-r3 get clobbered after the syscall returns
 			constraints += ",~{r" + strconv.Itoa(i) + "}"
 		}
-		fnType := llvm.FunctionType(c.uintptrType, argTypes, false)
+		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
 		target := llvm.InlineAsm(fnType, "svc #0", constraints, true, false, 0)
-		syscallResult = c.builder.CreateCall(target, args, "")
-	case c.GOARCH() == "arm64" && c.GOOS() == "linux":
+		syscallResult = b.CreateCall(target, args, "")
+	case b.GOARCH() == "arm64" && b.GOOS() == "linux":
 		// Source: syscall(2) man page.
 		args := []llvm.Value{}
 		argTypes := []llvm.Type{}
@@ -132,12 +132,12 @@ func (c *Compiler) emitSyscall(frame *Frame, call *ssa.CallCommon) (llvm.Value,
 				"{x4}",
 				"{x5}",
 			}[i]
-			llvmValue := c.getValue(frame, arg)
+			llvmValue := b.getValue(arg)
 			args = append(args, llvmValue)
 			argTypes = append(argTypes, llvmValue.Type())
 		}
 		args = append(args, num)
-		argTypes = append(argTypes, c.uintptrType)
+		argTypes = append(argTypes, b.uintptrType)
 		constraints += ",{x8}" // syscall number
 		for i := len(call.Args) - 1; i < 8; i++ {
 			// x0-x7 may get clobbered during the syscall following the aarch64
@@ -145,13 +145,13 @@ func (c *Compiler) emitSyscall(frame *Frame, call *ssa.CallCommon) (llvm.Value,
 			constraints += ",~{x" + strconv.Itoa(i) + "}"
 		}
 		constraints += ",~{x16},~{x17}" // scratch registers
-		fnType := llvm.FunctionType(c.uintptrType, argTypes, false)
+		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
 		target := llvm.InlineAsm(fnType, "svc #0", constraints, true, false, 0)
-		syscallResult = c.builder.CreateCall(target, args, "")
+		syscallResult = b.CreateCall(target, args, "")
 	default:
-		return llvm.Value{}, c.makeError(call.Pos(), "unknown GOOS/GOARCH for syscall: "+c.GOOS()+"/"+c.GOARCH())
+		return llvm.Value{}, b.makeError(call.Pos(), "unknown GOOS/GOARCH for syscall: "+b.GOOS()+"/"+b.GOARCH())
 	}
-	switch c.GOOS() {
+	switch b.GOOS() {
 	case "linux", "freebsd":
 		// Return values: r0, r1 uintptr, err Errno
 		// Pseudocode:
@@ -160,15 +160,15 @@ func (c *Compiler) emitSyscall(frame *Frame, call *ssa.CallCommon) (llvm.Value,
 		//         err = -syscallResult
 		//     }
 		//     return syscallResult, 0, err
-		zero := llvm.ConstInt(c.uintptrType, 0, false)
-		inrange1 := c.builder.CreateICmp(llvm.IntSLT, syscallResult, llvm.ConstInt(c.uintptrType, 0, false), "")
-		inrange2 := c.builder.CreateICmp(llvm.IntSGT, syscallResult, llvm.ConstInt(c.uintptrType, 0xfffffffffffff000, true), "") // -4096
-		hasError := c.builder.CreateAnd(inrange1, inrange2, "")
-		errResult := c.builder.CreateSelect(hasError, c.builder.CreateSub(zero, syscallResult, ""), zero, "syscallError")
-		retval := llvm.Undef(c.ctx.StructType([]llvm.Type{c.uintptrType, c.uintptrType, c.uintptrType}, false))
-		retval = c.builder.CreateInsertValue(retval, syscallResult, 0, "")
-		retval = c.builder.CreateInsertValue(retval, zero, 1, "")
-		retval = c.builder.CreateInsertValue(retval, errResult, 2, "")
+		zero := llvm.ConstInt(b.uintptrType, 0, false)
+		inrange1 := b.CreateICmp(llvm.IntSLT, syscallResult, llvm.ConstInt(b.uintptrType, 0, false), "")
+		inrange2 := b.CreateICmp(llvm.IntSGT, syscallResult, llvm.ConstInt(b.uintptrType, 0xfffffffffffff000, true), "") // -4096
+		hasError := b.CreateAnd(inrange1, inrange2, "")
+		errResult := b.CreateSelect(hasError, b.CreateSub(zero, syscallResult, ""), zero, "syscallError")
+		retval := llvm.Undef(b.ctx.StructType([]llvm.Type{b.uintptrType, b.uintptrType, b.uintptrType}, false))
+		retval = b.CreateInsertValue(retval, syscallResult, 0, "")
+		retval = b.CreateInsertValue(retval, zero, 1, "")
+		retval = b.CreateInsertValue(retval, errResult, 2, "")
 		return retval, nil
 	case "darwin":
 		// Return values: r0, r1 uintptr, err Errno
@@ -178,15 +178,15 @@ func (c *Compiler) emitSyscall(frame *Frame, call *ssa.CallCommon) (llvm.Value,
 		//         err = syscallResult
 		//     }
 		//     return syscallResult, 0, err
-		zero := llvm.ConstInt(c.uintptrType, 0, false)
-		hasError := c.builder.CreateICmp(llvm.IntNE, syscallResult, llvm.ConstInt(c.uintptrType, 0, false), "")
-		errResult := c.builder.CreateSelect(hasError, syscallResult, zero, "syscallError")
-		retval := llvm.Undef(c.ctx.StructType([]llvm.Type{c.uintptrType, c.uintptrType, c.uintptrType}, false))
-		retval = c.builder.CreateInsertValue(retval, syscallResult, 0, "")
-		retval = c.builder.CreateInsertValue(retval, zero, 1, "")
-		retval = c.builder.CreateInsertValue(retval, errResult, 2, "")
+		zero := llvm.ConstInt(b.uintptrType, 0, false)
+		hasError := b.CreateICmp(llvm.IntNE, syscallResult, llvm.ConstInt(b.uintptrType, 0, false), "")
+		errResult := b.CreateSelect(hasError, syscallResult, zero, "syscallError")
+		retval := llvm.Undef(b.ctx.StructType([]llvm.Type{b.uintptrType, b.uintptrType, b.uintptrType}, false))
+		retval = b.CreateInsertValue(retval, syscallResult, 0, "")
+		retval = b.CreateInsertValue(retval, zero, 1, "")
+		retval = b.CreateInsertValue(retval, errResult, 2, "")
 		return retval, nil
 	default:
-		return llvm.Value{}, c.makeError(call.Pos(), "unknown GOOS/GOARCH for syscall: "+c.GOOS()+"/"+c.GOARCH())
+		return llvm.Value{}, b.makeError(call.Pos(), "unknown GOOS/GOARCH for syscall: "+b.GOOS()+"/"+b.GOARCH())
 	}
 }
@@ -8,19 +8,23 @@ import (
 	"tinygo.org/x/go-llvm"
 )

-func (c *Compiler) emitVolatileLoad(frame *Frame, instr *ssa.CallCommon) (llvm.Value, error) {
-	addr := c.getValue(frame, instr.Args[0])
-	c.emitNilCheck(frame, addr, "deref")
-	val := c.builder.CreateLoad(addr, "")
+// createVolatileLoad is the implementation of the intrinsic function
+// runtime/volatile.LoadT().
+func (b *builder) createVolatileLoad(instr *ssa.CallCommon) (llvm.Value, error) {
+	addr := b.getValue(instr.Args[0])
+	b.createNilCheck(instr.Args[0], addr, "deref")
+	val := b.CreateLoad(addr, "")
 	val.SetVolatile(true)
 	return val, nil
 }

-func (c *Compiler) emitVolatileStore(frame *Frame, instr *ssa.CallCommon) (llvm.Value, error) {
-	addr := c.getValue(frame, instr.Args[0])
-	val := c.getValue(frame, instr.Args[1])
-	c.emitNilCheck(frame, addr, "deref")
-	store := c.builder.CreateStore(val, addr)
+// createVolatileStore is the implementation of the intrinsic function
+// runtime/volatile.StoreT().
+func (b *builder) createVolatileStore(instr *ssa.CallCommon) (llvm.Value, error) {
+	addr := b.getValue(instr.Args[0])
+	val := b.getValue(instr.Args[1])
+	b.createNilCheck(instr.Args[0], addr, "deref")
+	store := b.CreateStore(val, addr)
 	store.SetVolatile(true)
 	return llvm.Value{}, nil
 }
@@ -4,11 +4,11 @@ go 1.11

 require (
 	github.com/blakesmith/ar v0.0.0-20150311145944-8bd4349a67f2
-	github.com/creack/goselect v0.1.0 // indirect
+	github.com/chromedp/cdproto v0.0.0-20200709115526-d1f6fc58448b
+	github.com/chromedp/chromedp v0.5.4-0.20200303084119-2bb39134ab9e
 	github.com/google/shlex v0.0.0-20181106134648-c34317bd91bf
-	github.com/marcinbor85/gohex v0.0.0-20180128172054-7a43cd876e46
-	go.bug.st/serial.v1 v0.0.0-20180827123349-5f7892a7bb45
-	golang.org/x/sys v0.0.0-20191010194322-b09406accb47 // indirect
-	golang.org/x/tools v0.0.0-20190227180812-8dcc6e70cdef
-	tinygo.org/x/go-llvm v0.0.0-20200104190746-1ff21df33566
+	github.com/marcinbor85/gohex v0.0.0-20200531091804-343a4b548892
+	go.bug.st/serial v1.0.0
+	golang.org/x/tools v0.0.0-20200216192241-b320d3a0f5a2
+	tinygo.org/x/go-llvm v0.0.0-20201104183921-570e7a6841d9
 )
@@ -1,36 +1,52 @@
 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/creack/goselect v0.1.0 h1:4QiXIhcpSQF50XGaBsFzesjwX/1qOY5bOveQPmN9CXY=
-github.com/creack/goselect v0.1.0/go.mod h1:gHrIcH/9UZDn2qgeTUeW5K9eZsVYCH6/60J/FHysWyE=
-github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/chromedp/cdproto v0.0.0-20200116234248-4da64dd111ac/go.mod h1:PfAWWKJqjlGFYJEidUM6aVIWPr0EpobeyVWEEmplX7g=
+github.com/chromedp/cdproto v0.0.0-20200709115526-d1f6fc58448b h1:LF+GRwyzxrO3MUzPvejv+yBup0lNG+/QdIRrkxOPseA=
+github.com/chromedp/cdproto v0.0.0-20200709115526-d1f6fc58448b/go.mod h1:E6LPWRdIJc11h/di5p0rwvRmUYbhGpBEH7ZbPfzDIOE=
+github.com/chromedp/chromedp v0.5.4-0.20200303084119-2bb39134ab9e h1:Hv0JVyHhbIXb9NiYQe4NsrfgrSofAp0q2FnhhJOXgi8=
+github.com/chromedp/chromedp v0.5.4-0.20200303084119-2bb39134ab9e/go.mod h1:vmQMRHFZrY3T+Jv51T0n87OK/i6bK+5P9a+Fg5jPwgQ=
+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.3 h1:ZOigqf7iBxkA4jdQ3am7ATzdlOFp9YzA6NmuvEEZc9g=
+github.com/gobwas/ws v1.0.3/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/marcinbor85/gohex v0.0.0-20180128172054-7a43cd876e46 h1:wXG2bA8fO7Vv7lLk2PihFMTqmbT173Tje39oKzQ50Mo=
-github.com/marcinbor85/gohex v0.0.0-20180128172054-7a43cd876e46/go.mod h1:Pb6XcsXyropB9LNHhnqaknG/vEwYztLkQzVCHv8sQ3M=
-go.bug.st/serial.v1 v0.0.0-20180827123349-5f7892a7bb45 h1:mACY1anK6HNCZtm/DK2Rf2ZPHggVqeB0+7rY9Gl6wyI=
-go.bug.st/serial.v1 v0.0.0-20180827123349-5f7892a7bb45/go.mod h1:dRSl/CVCTf56CkXgJMDOdSwNfo2g1orOGE/gBGdvjZw=
-golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20191010194322-b09406accb47 h1:/XfQ9z7ib8eEJX2hdgFTZJ/ntt0swNk5oYBziWeTCvY=
-golang.org/x/sys v0.0.0-20191010194322-b09406accb47/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+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/go.mod h1:KAzv3t3aY1NaHWoQz1+4F1ccyAH66Jk7yos7ldAVICs=
+github.com/mailru/easyjson v0.7.1 h1:mdxE1MF9o53iCb2Ghj1VfWvh7ZOwHpnVG/xwXrV90U8=
+github.com/mailru/easyjson v0.7.1/go.mod h1:KAzv3t3aY1NaHWoQz1+4F1ccyAH66Jk7yos7ldAVICs=
+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/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=
+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=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191128015809-6d18c012aee9 h1:ZBzSG/7F4eNKz2L3GE9o300RX0Az1Bw5HF7PDraD+qU=
+golang.org/x/sys v0.0.0-20191128015809-6d18c012aee9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42 h1:vEOn+mP2zCOVzKckCZy6YsCtDblrpj/w7B9nxGNELpg=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/tools v0.0.0-20190227180812-8dcc6e70cdef h1:ymc9FeDom3RIEA3coKokSllBB1hRcMT0tZ1W3Jf9Ids=
-golang.org/x/tools v0.0.0-20190227180812-8dcc6e70cdef/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
-google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
-tinygo.org/x/go-llvm v0.0.0-20190224120431-7707ae5d1261 h1:rJS2Hga39YAnm7DE4qrPm6Dr/67EOojL0XPzvbEeBiw=
-tinygo.org/x/go-llvm v0.0.0-20190224120431-7707ae5d1261/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
-tinygo.org/x/go-llvm v0.0.0-20190818154551-95bc4ffe1add h1:dFjMH1sLhYADg8UQm7DB56B7e+TfvAmWmEZLhyv3r/w=
-tinygo.org/x/go-llvm v0.0.0-20190818154551-95bc4ffe1add/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
-tinygo.org/x/go-llvm v0.0.0-20191103182207-90b6e4bdc0b9 h1:d6rAX39a3C0pKrY5HcojEGyN8w9ocU0v7X28lC/TRKU=
-tinygo.org/x/go-llvm v0.0.0-20191103182207-90b6e4bdc0b9/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
-tinygo.org/x/go-llvm v0.0.0-20191103200204-37e93e3f04e2 h1:Q5Hv3e5cLMGkiYwYgZL1Zrv6nb/EY+DJpRWrdO6ws6o=
-tinygo.org/x/go-llvm v0.0.0-20191103200204-37e93e3f04e2/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
-tinygo.org/x/go-llvm v0.0.0-20191113125529-bad6d01809e8 h1:9Bfvso+tTVQg16UzOA614NaYA4x8vsRBNtd3eBrXwp0=
-tinygo.org/x/go-llvm v0.0.0-20191113125529-bad6d01809e8/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
-tinygo.org/x/go-llvm v0.0.0-20191124211856-b2db3df3f257 h1:o8VDylrMN7gWemBMu8rEyuogKPhcLTdx5KrUAp9macc=
-tinygo.org/x/go-llvm v0.0.0-20191124211856-b2db3df3f257/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
-tinygo.org/x/go-llvm v0.0.0-20191215173731-ad71f3d24aae h1:s8J5EyxCkHxXB08UI3gk9W9IS/ekizRvSX+PfZxnAB0=
-tinygo.org/x/go-llvm v0.0.0-20191215173731-ad71f3d24aae/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
-tinygo.org/x/go-llvm v0.0.0-20200104190746-1ff21df33566 h1:a4y30bTf7U0zDA75v2PTL+XQ2OzJetj19gK8XwQpUNY=
-tinygo.org/x/go-llvm v0.0.0-20200104190746-1ff21df33566/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
+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=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898 h1:/atklqdjdhuosWIl6AIbOeHJjicWYPqR9bpxqxYG2pA=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/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-20201104183921-570e7a6841d9 h1:l2kTQOhqEoeDTK3ckUnwReOQwMPUmURMIdjJbeAuDT4=
+tinygo.org/x/go-llvm v0.0.0-20201104183921-570e7a6841d9/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
@@ -18,6 +18,7 @@ var Keys = []string{
 	"GOROOT",
 	"GOPATH",
 	"GOCACHE",
+	"CGO_ENABLED",
 	"TINYGOROOT",
 }

@@ -57,6 +58,13 @@ func Get(name string) string {
 			panic("could not find cache dir: " + err.Error())
 		}
 		return filepath.Join(dir, "tinygo")
+	case "CGO_ENABLED":
+		val := os.Getenv("CGO_ENABLED")
+		if val == "1" || val == "0" {
+			return val
+		}
+		// Default to enabling CGo.
+		return "1"
 	case "TINYGOROOT":
 		return sourceDir()
 	default:
@@ -0,0 +1,68 @@
+package goenv
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+// Version of TinyGo.
+// Update this value before release of new version of software.
+const Version = "0.17.0-dev"
+
+// GetGorootVersion returns the major and minor version for a given GOROOT path.
+// If the goroot cannot be determined, (0, 0) is returned.
+func GetGorootVersion(goroot string) (major, minor int, err error) {
+	s, err := GorootVersionString(goroot)
+	if err != nil {
+		return 0, 0, err
+	}
+
+	if s == "" || s[:2] != "go" {
+		return 0, 0, errors.New("could not parse Go version: version does not start with 'go' prefix")
+	}
+
+	parts := strings.Split(s[2:], ".")
+	if len(parts) < 2 {
+		return 0, 0, errors.New("could not parse Go version: version has less than two parts")
+	}
+
+	// Ignore the errors, we don't really handle errors here anyway.
+	var trailing string
+	n, err := fmt.Sscanf(s, "go%d.%d%s", &major, &minor, &trailing)
+	if n == 2 && err == io.EOF {
+		// Means there were no trailing characters (i.e., not an alpha/beta)
+		err = nil
+	}
+	if err != nil {
+		return 0, 0, fmt.Errorf("failed to parse version: %s", err)
+	}
+	return
+}
+
+// GorootVersionString returns the version string as reported by the Go
+// toolchain for the given GOROOT path. It is usually of the form `go1.x.y` but
+// can have some variations (for beta releases, for example).
+func GorootVersionString(goroot string) (string, error) {
+	if data, err := ioutil.ReadFile(filepath.Join(
+		goroot, "src", "runtime", "internal", "sys", "zversion.go")); err == nil {
+
+		r := regexp.MustCompile("const TheVersion = `(.*)`")
+		matches := r.FindSubmatch(data)
+		if len(matches) != 2 {
+			return "", errors.New("Invalid go version output:\n" + string(data))
+		}
+
+		return string(matches[1]), nil
+
+	} else if data, err := ioutil.ReadFile(filepath.Join(goroot, "VERSION")); err == nil {
+		return string(data), nil
+
+	} else {
+		return "", err
+	}
+}
@@ -0,0 +1,5 @@
+# Hooks for Docker Hub
+
+Files in this directory are custom commands to be run during the different Docker Hub build phases.
+
+See https://docs.docker.com/docker-hub/builds/advanced/#custom-build-phase-hooks
@@ -0,0 +1,4 @@
+#!/bin/bash
+# Docker hub does a recursive clone, then checks the branch out,
+# so when a PR adds a submodule (or updates it), it fails.
+git submodule update --init
@@ -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/).
@@ -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",
+}
@@ -11,57 +11,50 @@ 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 = 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")
+)

-// Unsupported is the specific error that is returned when an unsupported
-// instruction is hit while trying to interpret all initializers.
-type Unsupported struct {
-	ImportPath string
-	Inst       llvm.Value
-	Pos        token.Position
+func isRecoverableError(err error) bool {
+	return err == errIntegerAsPointer || err == errUnsupportedInst || err == errUnsupportedRuntimeInst || err == errMapAlreadyCreated
 }

-func (e Unsupported) Error() string {
-	// TODO: how to return the actual instruction string?
-	// It looks like LLVM provides no function for that...
-	return scanner.Error{
-		Pos: e.Pos,
-		Msg: "interp: unsupported instruction",
-	}.Error()
-}
-
-// 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) *Unsupported {
-	return &Unsupported{
-		ImportPath: e.packagePath,
-		Inst:       inst,
-		Pos:        getPosition(inst),
-	}
+// ErrorLine is one line in a traceback. The position may be missing.
+type ErrorLine struct {
+	Pos  token.Position
+	Inst llvm.Value
 }

 // Error encapsulates compile-time interpretation errors with an associated
 // import path. The errors may not have a precise location attached.
 type Error struct {
 	ImportPath string
-	Errs       []scanner.Error
+	Inst       llvm.Value
+	Pos        token.Position
+	Err        error
+	Traceback  []ErrorLine
 }

 // Error returns the string of the first error in the list of errors.
-func (e Error) Error() string {
-	return e.Errs[0].Error()
+func (e *Error) Error() string {
+	return e.Pos.String() + ": " + e.Err.Error()
 }

 // 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, msg string) Error {
-	return Error{
-		ImportPath: e.packagePath,
-		Errs:       []scanner.Error{errorAt(inst, msg)},
+func (r *runner) errorAt(inst instruction, err error) *Error {
+	pos := getPosition(inst.llvmInst)
+	return &Error{
+		ImportPath: r.pkgName,
+		Pos:        pos,
+		Err:        err,
+		Traceback:  []ErrorLine{{pos, inst.llvmInst}},
 	}
 }

@@ -1,623 +0,0 @@
-package interp
-
-// This file implements the core interpretation routines, interpreting single
-// functions.
-
-import (
-	"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 {
-				value = operand.Load()
-			}
-			if value.Type() != inst.Type() {
-				return nil, nil, fr.errorAt(inst, "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 {
-				ptr.Store(value.Value())
-			}
-		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, "todo: non-const gep")
-				}
-				indices[i] = uint32(operand.Value().ZExtValue())
-			}
-			result := value.GetElementPtr(indices)
-			if result.Type() != inst.Type() {
-				return nil, nil, fr.errorAt(inst, "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, "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 {
-					fr.locals[resultInst] = result.GetElementPtr([]uint32{0, 0})
-				}
-			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.
-				m.PutString(keyBuf, keyLen, valPtr)
-			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
-				}
-				m.PutBinary(keyBuf, valPtr)
-			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 := getStringBytes(buf1Ptr, buf1Len.Value())
-				buf2 := getStringBytes(buf2Ptr, buf2Len.Value())
-				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...
-					dstArray = dstArray.GetElementPtr([]uint32{0, 0}).(*LocalValue)
-					srcArray = srcArray.GetElementPtr([]uint32{0, 0}).(*LocalValue)
-				}
-				if fr.Eval.TargetData.TypeAllocSize(dstArray.Type().ElementType()) != elementSize {
-					return nil, nil, fr.errorAt(inst, "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, "interp: slice src element size does not match pointer type")
-				}
-				if dstArray.Type() != srcArray.Type() {
-					return nil, nil, fr.errorAt(inst, "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, "interp: trying to copy a slice with negative length?")
-				}
-				for i := int64(0); i < length; i++ {
-					// *dst = *src
-					dstArray.Store(srcArray.Load())
-					// dst++
-					dstArray = dstArray.GetElementPtr([]uint32{1}).(*LocalValue)
-					// src++
-					srcArray = srcArray.GetElementPtr([]uint32{1}).(*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 := getStringBytes(bufPtr, bufLen.Value())
-				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.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, "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, "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, "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 {
-						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, "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, "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.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, "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, "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, "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, "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")
-	}
-}
@@ -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
 }
@@ -3,6 +3,7 @@ package interp
 import (
 	"io/ioutil"
 	"os"
+	"regexp"
 	"strings"
 	"testing"

@@ -15,6 +16,7 @@ func TestInterp(t *testing.T) {
 		"slice-copy",
 		"consteval",
 		"map",
+		"interface",
 	} {
 		name := name // make tc local to this closure
 		t.Run(name, func(t *testing.T) {
@@ -40,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()
@@ -65,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.).
@@ -74,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
 		}
 	}
@@ -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?"
+	}
+}
@@ -1,244 +0,0 @@
-package interp
-
-import (
-	"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.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 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, "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.).
-					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{}{}
-	}
-}
@@ -1,93 +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},
-}
-
-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)
-		}
-	}
-}
@@ -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
+}
@@ -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
+}
@@ -0,0 +1,28 @@
+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 }
+%runtime.interfaceMethodInfo = type { i8*, i64 }
+%runtime.typeInInterface = type { %runtime.typecodeID*, %runtime.interfaceMethodInfo* }
+
+@main.v1 = global i1 0
+@"reflect/types.type:named:main.foo" = private constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:basic:int", i64 0 }
+@"reflect/types.type:basic:int" = external constant %runtime.typecodeID
+@"typeInInterface:reflect/types.type:named:main.foo" = private constant %runtime.typeInInterface { %runtime.typecodeID* @"reflect/types.type:named:main.foo", %runtime.interfaceMethodInfo* null }
+
+
+declare i1 @runtime.typeAssert(i64, %runtime.typecodeID*, i8*, i8*)
+
+define void @runtime.initAll() unnamed_addr {
+entry:
+  call void @main.init()
+  ret void
+}
+
+define internal void @main.init() unnamed_addr {
+entry:
+  ; Test type asserts.
+  %typecode = call i1 @runtime.typeAssert(i64 ptrtoint (%runtime.typeInInterface* @"typeInInterface:reflect/types.type:named:main.foo" to i64), %runtime.typecodeID* @"reflect/types.type:named:main.foo", i8* undef, i8* null)
+  store i1 %typecode, i1* @main.v1
+  ret void
+}
@@ -0,0 +1,9 @@
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64--linux"
+
+@main.v1 = local_unnamed_addr global i1 true
+
+define void @runtime.initAll() unnamed_addr {
+entry:
+  ret void
+}
@@ -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
@@ -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
 }
@@ -1,61 +0,0 @@
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64--linux"
-
-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
-}
@@ -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
 }
@@ -1,117 +0,0 @@
-package interp
-
-import (
-	"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 {
-	if !strLen.IsConstant() {
-		panic("getStringBytes with a non-constant length")
-	}
-	buf := make([]byte, strLen.ZExtValue())
-	for i := range buf {
-		c := strPtr.GetElementPtr([]uint32{uint32(i)}).Load()
-		buf[i] = byte(c.ZExtValue())
-	}
-	return buf
-}
-
-// 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
-}
--- a/Show More
+++ b/Show More