targets/gba: implement interrupt handler

targets/gba: make linker script cleaner
Make it clearer where the stack is located.
2026-07-29 16:18:41 +00:00 · 2020-01-06 14:45:32 +01:00 · 2020-01-06 11:48:09 +01:00 · 2020-01-05 08:05:38 +01:00 · 2020-01-04 23:40:45 +01:00 · 2020-01-04 23:40:44 +01:00
522 changed files with 7909 additions and 28479 deletions
@@ -14,16 +14,18 @@ commands:
      - run:
          name: "Install apt dependencies"
          command: |
-            echo 'deb https://apt.llvm.org/buster/ llvm-toolchain-buster-<<parameters.llvm>> main' | sudo tee /etc/apt/sources.list.d/llvm.list
+            echo 'deb http://apt.llvm.org/stretch/ llvm-toolchain-stretch<<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 \
@@ -37,83 +39,39 @@ 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-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-10-v1
+            - llvm-source-9-v0
      - run:
          name: "Fetch LLVM source"
          command: make llvm-source
      - save_cache:
-          key: llvm-source-10-v1
+          key: llvm-source-9-v0
          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: "<<parameters.llvm>>"
+          llvm: "-9"
      - install-node
-      - install-chrome
      - 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 -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: go install .
+      - run: go test -v ./cgo ./compileopts ./interp ./transform .
      - run: make gen-device -j4
-      - run: make smoketest XTENSA=0
-      - run: make tinygo-test
-      - run: make wasmtest
+      - run: make smoketest
      - 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:
@@ -134,8 +92,6 @@ commands:
                gcc-avr \
                avr-libc
      - install-node
-      - install-xtensa-toolchain:
-          variant: "linux-amd64"
      - restore_cache:
          keys:
            - go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
@@ -143,7 +99,7 @@ commands:
      - llvm-source-linux
      - restore_cache:
          keys:
-            - llvm-build-10-linux-v1-assert
+            - llvm-build-9-linux-v0-assert
      - run:
          name: "Build LLVM"
          command: |
@@ -161,11 +117,10 @@ commands:
              make ASSERT=1 llvm-build
            fi
      - save_cache:
-          key: llvm-build-10-linux-v1-assert
+          key: llvm-build-9-linux-v0-assert
          paths:
            llvm-build
      - run: make ASSERT=1
-      - build-wasi-libc
      - run:
          name: "Test TinyGo"
          command: make ASSERT=1 test
@@ -173,6 +128,7 @@ 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
@@ -194,8 +150,6 @@ commands:
                gcc-avr \
                avr-libc
      - install-node
-      - install-xtensa-toolchain:
-          variant: "linux-amd64"
      - restore_cache:
          keys:
            - go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
@@ -203,7 +157,7 @@ commands:
      - llvm-source-linux
      - restore_cache:
          keys:
-            - llvm-build-10-linux-v1
+            - llvm-build-9-linux-v0
      - run:
          name: "Build LLVM"
          command: |
@@ -221,32 +175,24 @@ commands:
              make llvm-build
            fi
      - save_cache:
-          key: llvm-build-10-linux-v1
+          key: llvm-build-9-linux-v0
          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 deb -j3
+            make release -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"
@@ -263,29 +209,27 @@ commands:
      - run:
          name: "Install dependencies"
          command: |
-            curl https://dl.google.com/go/go1.14.darwin-amd64.tar.gz -o go1.14.darwin-amd64.tar.gz
-            sudo tar -C /usr/local -xzf go1.14.darwin-amd64.tar.gz
+            curl https://dl.google.com/go/go1.13.darwin-amd64.tar.gz -o go1.13.darwin-amd64.tar.gz
+            sudo tar -C /usr/local -xzf go1.13.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-10-macos-v1
+            - llvm-source-9-macos-v0
      - run:
          name: "Fetch LLVM source"
          command: make llvm-source
      - save_cache:
-          key: llvm-source-10-macos-v1
+          key: llvm-source-9-macos-v0
          paths:
            - llvm-project
      - restore_cache:
          keys:
-            - llvm-build-10-macos-v1
+            - llvm-build-9-macos-v0
      - run:
          name: "Build LLVM"
          command: |
@@ -297,19 +241,9 @@ commands:
              make llvm-build
            fi
      - save_cache:
-          key: llvm-build-10-macos-v1
+          key: llvm-build-9-macos-v0
          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
@@ -327,106 +261,44 @@ 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
-  arch-release:
-    steps:
-      - run:
-          name: Install dependencies
-          command: pacman -Sy --noconfirm openssh git pacman-contrib binutils
-      - run:
-          name: Create TinyGo user
-          command: useradd -m tinygo
-      - run:
-          name: Start SSH Agent
-          user: tinygo
-          command: eval $(ssh-agent -s)
-      - run:
-          name: Add ARCH_RELEASE_SSH_PRIVATE_KEY identity
-          user: tinygo
-          command: echo "${ARCH_RELEASE_SSH_PRIVATE_KEY}" | tr -d '\r' | ssh-add -
-      - run:
-          name: Create SSH directory
-          user: tinygo
-          command: mkdir -p ~/.ssh && chmod 700 ~/.ssh
-      - run:
-          name: Add aur.archlinux.org to known hosts
-          user: tinygo
-          command: ssh-keyscan aur.archlinux.org >> ~/.ssh/known_hosts
-      - run:
-          name: Clone tinygo-bin repo
-          user: tinygo
-          command: git clone ssh://aur@aur.archlinux.org/tinygo-bin.git ~/tinygo-bin
-      - run:
-          name: Update package version
-          user: tinygo
-          command: sed -i -E "s/(pkgver=)(.*)$/\1${CIRCLE_TAG}/" ~/tinygo-bin/PKGBUILD
-      - run:
-          name: Update file checksums
-          user: tinygo
-          command: cd ~/tinygo-bin && updpkgsums
-      - run:
-          name: Update .SRCINFO
-          user: tinygo
-          command: cd ~/tinygo-bin && makepkg --printsrcinfo > .SRCINFO
-      # Commit the update
-      - run:
-          name: Set git commit config
-          user: tinygo
-          command: |
-            git config --global user.email "tinygo-bot@tinygo.org" &&
-            git config --global user.name "TinyGo Release Bot"
-      - run:
-          name: Commit and push changes
-          user: tinygo
-          command: |
-            cd ~/tinygo-bin &&
-            git commit -a -m "Update tinygo-bin to v${CIRCLE_TAG}" &&
-            git push origin master
+

 jobs:
  test-llvm9-go111:
    docker:
-      - image: circleci/golang:1.11-buster
+      - image: circleci/golang:1.11-stretch
    steps:
-      - test-linux:
-          llvm: "9"
-  test-llvm10-go112:
+      - test-linux
+  test-llvm9-go112:
    docker:
-      - image: circleci/golang:1.12-buster
+      - image: circleci/golang:1.12-stretch
    steps:
-      - test-linux:
-          llvm: "10"
-  test-llvm10-go113:
+      - test-linux
+  test-llvm9-go113:
    docker:
-      - image: circleci/golang:1.13-buster
+      - image: circleci/golang:1.13-stretch
    steps:
-      - test-linux:
-          llvm: "10"
-  test-llvm10-go114:
-    docker:
-      - image: circleci/golang:1.14-buster
-    steps:
-      - test-linux:
-          llvm: "10"
-  test-llvm10-go115:
-    docker:
-      - image: circleci/golang:1.15-buster
-    steps:
-      - test-linux:
-          llvm: "10"        
+      - test-linux
  assert-test-linux:
    docker:
-      - image: circleci/golang:1.14-stretch
+      - image: circleci/golang:1.13-stretch
    steps:
      - assert-test-linux
  build-linux:
    docker:
-      - image: circleci/golang:1.14-stretch
+      - image: circleci/golang:1.13-stretch
    steps:
      - build-linux
  build-macos:
@@ -434,11 +306,6 @@ jobs:
      xcode: "10.1.0"
    steps:
      - build-macos
-  arch-release:
-    docker:
-      - image: archlinux:latest
-    steps:
-      - arch-release



@@ -447,19 +314,8 @@ workflows:
  test-all:
    jobs:
      - test-llvm9-go111
-      - test-llvm10-go112
-      - test-llvm10-go113
-      - test-llvm10-go114
-      - test-llvm10-go115
+      - test-llvm9-go112
+      - test-llvm9-go113
      - build-linux
      - build-macos
      - assert-test-linux
-  release:
-    jobs:
-      - arch-release:
-          filters:
-            branches:
-              ignore: /.*/
-            tags:
-              # Runs on every semver release
-              only: /v[0-9]+(\.[0-9]+)*(-.*)*/
@@ -3,19 +3,14 @@ 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,9 +14,3 @@
 	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,14 +10,6 @@ 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
@@ -92,10 +84,6 @@ 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,330 +1,3 @@
-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 `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.
+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.

 Here is how to contribute back some code or documentation:

@@ -15,4 +15,3 @@ 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.14, LLVM 10 and the TinyGo compiler itself.
-FROM golang:1.14 AS tinygo-base
+# TinyGo base stage installs Go 1.13, LLVM 9 and the TinyGo compiler itself.
+FROM golang:1.13 AS tinygo-base

 RUN wget -O- https://apt.llvm.org/llvm-snapshot.gpg.key| apt-key add - && \
-    echo "deb http://apt.llvm.org/buster/ llvm-toolchain-buster-10 main" >> /etc/apt/sources.list && \
+    echo "deb http://apt.llvm.org/buster/ llvm-toolchain-buster-9 main" >> /etc/apt/sources.list && \
    apt-get update && \
-    apt-get install -y llvm-10-dev libclang-10-dev lld-10 git
+    apt-get install -y llvm-9-dev libclang-9-dev git

 COPY . /tinygo

@@ -12,11 +12,8 @@ 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/

@@ -27,10 +24,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 cd /tinygo/ && \
+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 && \
    apt-get update && \
-    apt-get install -y make clang-10 libllvm10 lld-10 && \
-    make wasi-libc
+    apt-get install -y libllvm9 lld-9

 # tinygo-avr stage installs the needed dependencies to compile TinyGo programs for AVR microcontrollers.
 FROM tinygo-base AS tinygo-avr
@@ -61,7 +58,7 @@ COPY --from=tinygo-base /tinygo/lib /tinygo/lib

 RUN cd /tinygo/ && \
    apt-get update && \
-    apt-get install -y apt-utils make clang-10 && \
+    apt-get install -y apt-utils make clang-9 && \
    make gen-device-nrf && make gen-device-stm32

 # tinygo-all stage installs the needed dependencies to compile TinyGo programs for all platforms.
@@ -73,7 +70,7 @@ COPY --from=tinygo-base /tinygo/lib /tinygo/lib

 RUN cd /tinygo/ && \
    apt-get update && \
-    apt-get install -y apt-utils make clang-10 binutils-avr gcc-avr avr-libc && \
+    apt-get install -y apt-utils make clang-9 binutils-avr gcc-avr avr-libc && \
    make gen-device

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

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

 # Default build and source directories, as created by `make llvm-build`.
 LLVM_BUILDDIR ?= llvm-build
-LLVM_PROJECTDIR ?= llvm-project
-CLANG_SRC ?= $(LLVM_PROJECTDIR)/clang
-LLD_SRC ?= $(LLVM_PROJECTDIR)/lld
-
-# Try to autodetect LLVM build tools.
-ifneq (, $(shell command -v llvm-build/bin/clang 2> /dev/null))
-    CLANG ?= $(abspath llvm-build/bin/clang)
-else
-    CLANG ?= clang-10
-endif
-ifneq (, $(shell command -v llvm-build/bin/llvm-ar 2> /dev/null))
-    LLVM_AR ?= $(abspath llvm-build/bin/llvm-ar)
-else ifneq (, $(shell command -v llvm-ar-10 2> /dev/null))
-    LLVM_AR ?= llvm-ar-10
-else
-    LLVM_AR ?= llvm-ar
-endif
-ifneq (, $(shell command -v llvm-build/bin/llvm-nm 2> /dev/null))
-    LLVM_NM ?= $(abspath llvm-build/bin/llvm-nm)
-else ifneq (, $(shell command -v llvm-nm-10 2> /dev/null))
-    LLVM_NM ?= llvm-nm-10
-else
-    LLVM_NM ?= llvm-nm
-endif
+CLANG_SRC ?= llvm-project/clang
+LLD_SRC ?= llvm-project/lld

 # Go binary and GOROOT to select
 GO ?= go
@@ -40,7 +18,7 @@ MD5SUM = md5sum
 TINYGO ?= tinygo

 # Use CCACHE for LLVM if possible
-ifneq (, $(shell command -v ccache 2> /dev/null))
+ifneq (, $(shell which ccache))
    LLVM_OPTION += '-DLLVM_CCACHE_BUILD=ON'
 endif

@@ -51,9 +29,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-nxp gen-device-avr
+.PHONY: all tinygo test $(LLVM_BUILDDIR) llvm-source clean fmt gen-device gen-device-nrf gen-device-avr

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

 ifeq ($(OS),Windows_NT)
    EXE = .exe
@@ -103,8 +81,8 @@ 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++14
-    CGO_LDFLAGS+=$(LIBCLANG_PATH) -std=c++14 -L$(abspath $(LLVM_BUILDDIR)/lib) $(CLANG_LIBS) $(LLD_LIBS) $(shell $(LLVM_BUILDDIR)/bin/llvm-config --ldflags --libs --system-libs $(LLVM_COMPONENTS)) -lstdc++ $(CGO_LDFLAGS_EXTRA)
+    CGO_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)
 endif


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


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

 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/
@@ -130,79 +107,53 @@ 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 -interrupts=software 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 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_PROJECTDIR)/README.md:
-	git clone -b xtensa_release_10.0.1 --depth=1 https://github.com/tinygo-org/llvm-project $(LLVM_PROJECTDIR)
-llvm-source: $(LLVM_PROJECTDIR)/README.md
+llvm-project/README.md:
+	git clone -b release/9.x https://github.com/llvm/llvm-project
+llvm-source: llvm-project/README.md

 # Configure LLVM.
 TINYGO_SOURCE_DIR=$(shell pwd)
 $(LLVM_BUILDDIR)/build.ninja: llvm-source
-	mkdir -p $(LLVM_BUILDDIR); cd $(LLVM_BUILDDIR); cmake -G Ninja $(TINYGO_SOURCE_DIR)/$(LLVM_PROJECTDIR)/llvm "-DLLVM_TARGETS_TO_BUILD=X86;ARM;AArch64;RISCV;WebAssembly" "-DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=AVR;Xtensa" -DCMAKE_BUILD_TYPE=Release -DLIBCLANG_BUILD_STATIC=ON -DLLVM_ENABLE_TERMINFO=OFF -DLLVM_ENABLE_ZLIB=OFF -DLLVM_ENABLE_LIBEDIT=OFF -DLLVM_ENABLE_Z3_SOLVER=OFF -DLLVM_ENABLE_OCAMLDOC=OFF -DLLVM_ENABLE_PROJECTS="clang;lld" -DLLVM_TOOL_CLANG_TOOLS_EXTRA_BUILD=OFF $(LLVM_OPTION)
+	mkdir -p $(LLVM_BUILDDIR); cd $(LLVM_BUILDDIR); cmake -G Ninja $(TINYGO_SOURCE_DIR)/llvm-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)

 # 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 -buildmode exe -o build/tinygo$(EXE) -tags byollvm -ldflags="-X main.gitSha1=`git rev-parse --short HEAD`" .
+	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) build -o build/tinygo$(EXE) -tags byollvm .

-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:
+	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test -v -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:
-	$(TINYGO) test container/list
-	$(TINYGO) test container/ring
-	$(TINYGO) test text/scanner
+	cd tests/tinygotest && tinygo test

 .PHONY: smoketest
 smoketest:
 	$(TINYGO) version
-	# test all examples (except pwm)
+	# test all examples
 	$(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
@@ -223,7 +174,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/pininterrupt
+	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/pwm
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/serial
 	@$(MD5SUM) test.hex
@@ -234,8 +185,6 @@ smoketest:
 	# test simulated boards on play.tinygo.org
 	$(TINYGO) build             -o test.wasm -tags=arduino              examples/blinky1
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build             -o test.wasm -tags=hifive1-qemu         examples/serial
-	@$(MD5SUM) test.wasm
 	$(TINYGO) build             -o test.wasm -tags=hifive1b             examples/blinky1
 	@$(MD5SUM) test.wasm
 	$(TINYGO) build             -o test.wasm -tags=reelboard            examples/blinky1
@@ -251,8 +200,6 @@ 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
@@ -279,16 +226,8 @@ 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
@@ -299,14 +238,6 @@ 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
@@ -315,78 +246,23 @@ 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
-	# 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-wroom-32      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=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

-wasmtest:
-	$(GO) test ./tests/wasm
-
-build/release: tinygo gen-device wasi-libc
+release: tinygo gen-device
 	@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
@@ -399,28 +275,9 @@ build/release: tinygo gen-device wasi-libc
 	@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-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
+	./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
 	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,47 +43,27 @@ See the [getting started instructions](https://tinygo.org/getting-started/) for

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

-The following 44 microcontroller boards are currently supported:
+The following 22 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)
@@ -148,6 +128,4 @@ The original reasoning was: if [Python](https://micropython.org/) can run on mic

 This project is licensed under the BSD 3-clause license, just like the [Go project](https://golang.org/LICENSE) itself.

-Some code has been copied from the LLVM project and is therefore licensed under [a variant of the Apache 2.0 license](http://releases.llvm.org/10.0.0/LICENSE.TXT). This has been clearly indicated in the header of these files.
-
-Some code has been copied 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.
+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.
@@ -1,7 +1,7 @@
 # Avoid lengthy LLVM rebuilds on each newly pushed branch. Pull requests will
 # be built anyway.
 trigger:
- release
+- master
 - dev

 jobs:
@@ -10,29 +10,21 @@ jobs:
  pool:
    vmImage: 'VS2017-Win2016'
  steps:
-    - task: GoTool@0
-      inputs:
-        version: '1.15'
    - checkout: self
-      fetchDepth: 1
-    - task: Cache@2
+    - task: CacheBeta@0
      displayName: Cache LLVM source
      inputs:
-        key: llvm-source-10-windows-v1
+        key: llvm-source-9-windows-v0
        path: llvm-project
    - task: Bash@3
      displayName: Download LLVM source
      inputs:
        targetType: inline
-        script: |
-          make llvm-source
-          # Workaround for bad symlinks:
-          # https://github.com/microsoft/azure-pipelines-tasks/issues/13418
-          rm -f llvm-project/libcxx/test/std/input.output/filesystems/Inputs/static_test_env/bad_symlink
+        script: make llvm-source
    - task: CacheBeta@0
      displayName: Cache LLVM build
      inputs:
-        key: llvm-build-10-windows-v1
+        key: llvm-build-9-windows-v0
        path: llvm-build
    - task: Bash@3
      displayName: Build LLVM
@@ -42,29 +34,23 @@ jobs:
          if [ ! -f llvm-build/lib/liblldELF.a ]
          then
            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
            make llvm-build
          fi
    - task: Bash@3
      displayName: Install QEMU
      inputs:
        targetType: inline
-        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
+        script: choco install qemu
    - task: Bash@3
      displayName: Test TinyGo
      inputs:
        targetType: inline
        script: |
-          export PATH="$PATH:./llvm-build/bin:/c/Program Files/qemu"
+          export PATH="/c/Go1.13/bin:$PATH:./llvm-build/bin:/c/Program Files/qemu"
          unset GOROOT
          make test
    - task: Bash@3
@@ -72,17 +58,17 @@ jobs:
      inputs:
        targetType: inline
        script: |
-          export PATH="$PATH:./llvm-build/bin:/c/Program Files/qemu"
+          export PATH="/c/Go1.13/bin:$PATH:./llvm-build/bin:/c/Program Files/qemu"
          unset GOROOT
-          make build/release -j4
-    - publish: $(System.DefaultWorkingDirectory)/build/release/tinygo
-      displayName: Publish zip as artifact
-      artifact: tinygo
+          make release -j4
+    - publish: $(System.DefaultWorkingDirectory)/build/release.tar.gz
+      displayName: Publish tarball as artifact
+      artifact: tinygo.windows-amd64.tar.gz
    - task: Bash@3
      displayName: Smoke tests
      inputs:
        targetType: inline
        script: |
-          export PATH="$PATH:./llvm-build/bin:/c/Program Files/qemu"
+          export PATH="/c/Go1.13/bin:$PATH:./llvm-build/bin:/c/Program Files/qemu"
          unset GOROOT
-          make smoketest TINYGO=build/tinygo AVR=0 XTENSA=0
+          make smoketest TINYGO=build/tinygo AVR=0
@@ -4,14 +4,11 @@
 package builder

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

@@ -19,59 +16,43 @@ 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(BuildResult) error) error {
-	// Compile Go code to IR.
-	machine, err := compiler.NewTargetMachine(config)
+func Build(pkgName, outpath string, config *compileopts.Config, action func(string) error) error {
+	c, err := compiler.NewCompiler(pkgName, config)
 	if err != nil {
 		return err
 	}
-	buildOutput, errs := compiler.Compile(pkgName, machine, config)
-	if errs != nil {
+
+	// Compile Go code to IR.
+	errs := c.Compile(pkgName)
+	if len(errs) != 0 {
 		return newMultiError(errs)
 	}
-	mod := buildOutput.Mod
-
 	if config.Options.PrintIR {
 		fmt.Println("; Generated LLVM IR:")
-		fmt.Println(mod.String())
+		fmt.Println(c.IR())
 	}
-	if err := llvm.VerifyModule(mod, llvm.PrintMessageAction); err != nil {
+	if err := c.Verify(); err != nil {
 		return errors.New("verification error after IR construction")
 	}

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

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

 	// Browsers cannot handle external functions that have type i64 because it
@@ -80,7 +61,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	// stack-allocated values.
 	// Use -wasm-abi=generic to disable this behaviour.
 	if config.Options.WasmAbi == "js" && strings.HasPrefix(config.Triple(), "wasm") {
-		err := transform.ExternalInt64AsPtr(mod)
+		err := c.ExternalInt64AsPtr()
 		if err != nil {
 			return err
 		}
@@ -90,30 +71,23 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	// exactly.
 	errs = nil
 	switch config.Options.Opt {
-	/*
-		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 "none:", "0":
+		errs = c.Optimize(0, 0, 0) // -O0
 	case "1":
-		errs = transform.Optimize(mod, config, 1, 0, 0) // -O1
+		errs = c.Optimize(1, 0, 0) // -O1
 	case "2":
-		errs = transform.Optimize(mod, config, 2, 0, 225) // -O2
+		errs = c.Optimize(2, 0, 225) // -O2
 	case "s":
-		errs = transform.Optimize(mod, config, 2, 1, 225) // -Os
+		errs = c.Optimize(2, 1, 225) // -Os
 	case "z":
-		errs = transform.Optimize(mod, config, 2, 2, 5) // -Oz, default
+		errs = c.Optimize(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 := llvm.VerifyModule(mod, llvm.PrintMessageAction); err != nil {
+	if err := c.Verify(); err != nil {
 		return errors.New("verification failure after LLVM optimization passes")
 	}

@@ -123,34 +97,21 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	// pointers are flash and which are in RAM so that pointers can have a
 	// correct address space parameter (address space 1 is for flash).
 	if strings.HasPrefix(config.Triple(), "avr") {
-		transform.NonConstGlobals(mod)
-		if err := llvm.VerifyModule(mod, llvm.PrintMessageAction); err != nil {
+		c.NonConstGlobals()
+		if err := c.Verify(); err != nil {
 			return errors.New("verification error after making all globals non-constant on AVR")
 		}
 	}

-	// Make sure stack sizes are loaded from a separate section so they can be
-	// modified after linking.
-	var stackSizeLoads []string
-	if config.AutomaticStackSize() {
-		stackSizeLoads = transform.CreateStackSizeLoads(mod, config)
-	}
-
 	// Generate output.
 	outext := filepath.Ext(outpath)
 	switch outext {
 	case ".o":
-		llvmBuf, err := machine.EmitToMemoryBuffer(mod, llvm.ObjectFile)
-		if err != nil {
-			return err
-		}
-		return ioutil.WriteFile(outpath, llvmBuf.Bytes(), 0666)
+		return c.EmitObject(outpath)
 	case ".bc":
-		data := llvm.WriteBitcodeToMemoryBuffer(mod).Bytes()
-		return ioutil.WriteFile(outpath, data, 0666)
+		return c.EmitBitcode(outpath)
 	case ".ll":
-		data := []byte(mod.String())
-		return ioutil.WriteFile(outpath, data, 0666)
+		return c.EmitText(outpath)
 	default:
 		// Act as a compiler driver.

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

 		// Write the object file.
 		objfile := filepath.Join(dir, "main.o")
-		llvmBuf, err := machine.EmitToMemoryBuffer(mod, llvm.ObjectFile)
+		err = c.EmitObject(objfile)
 		if err != nil {
 			return err
 		}
-		err = ioutil.WriteFile(objfile, llvmBuf.Bytes(), 0666)
-		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
+			}
 		}

 		// 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() {
@@ -209,17 +160,16 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		}

 		// Compile C files in packages.
-		for i, file := range buildOutput.ExtraFiles {
-			outpath := filepath.Join(dir, "pkg"+strconv.Itoa(i)+"-"+filepath.Base(file)+".o")
-			err := runCCompiler(config.Target.Compiler, append(config.CFlags(), "-c", "-o", outpath, file)...)
-			if err != nil {
-				return &commandError{"failed to build", file, err}
+		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)
 			}
-			ldflags = append(ldflags, outpath)
-		}
-
-		if len(buildOutput.ExtraLDFlags) > 0 {
-			ldflags = append(ldflags, buildOutput.ExtraLDFlags...)
 		}

 		// Link the object files together.
@@ -228,26 +178,6 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 			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 {
@@ -267,278 +197,21 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 			}
 		}

-		// Print goroutine stack sizes, as far as possible.
-		if config.Options.PrintStacks {
-			printStacks(calculatedStacks, stackSizes)
-		}
-
 		// Get an Intel .hex file or .bin file from the .elf file.
-		outputBinaryFormat := config.BinaryFormat(outext)
-		switch outputBinaryFormat {
-		case "elf":
-			// do nothing, file is already in ELF format
-		case "hex", "bin":
-			// Extract raw binary, either encoding it as a hex file or as a raw
-			// firmware file.
+		if outext == ".hex" || outext == ".bin" || outext == ".gba" {
 			tmppath = filepath.Join(dir, "main"+outext)
-			err := objcopy(executable, tmppath, outputBinaryFormat)
+			err := objcopy(executable, tmppath)
 			if err != nil {
 				return err
 			}
-		case "uf2":
+		} else if outext == ".uf2" {
 			// Get UF2 from the .elf file.
 			tmppath = filepath.Join(dir, "main"+outext)
-			err := convertELFFileToUF2File(executable, tmppath, config.Target.UF2FamilyID)
+			err := convertELFFileToUF2File(executable, tmppath)
 			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,7 +1,12 @@
 package builder

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

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

-// 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...)
-		}
-		return builtins
-	},
+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, '/'):]
+		}
+		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)
 }
@@ -48,7 +48,6 @@
 #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"
@@ -71,12 +70,12 @@ bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
  bool Success = true;

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

  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) {
@@ -89,7 +88,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)
@@ -182,7 +181,6 @@ 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.NoWarn = Args.hasArg(OPT_massembler_no_warn);
  Opts.RelocationModel = Args.getLastArgValue(OPT_mrelocation_model, "pic");
  Opts.TargetABI = Args.getLastArgValue(OPT_target_abi);
  Opts.IncrementalLinkerCompatible =
@@ -210,8 +208,8 @@ getOutputStream(StringRef Path, DiagnosticsEngine &Diags, bool Binary) {
    sys::RemoveFileOnSignal(Path);

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

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

  // Ensure MCAsmInfo initialization occurs before any use, otherwise sections
@@ -273,7 +269,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, &MCOptions);
+  MCContext Ctx(MAI.get(), MRI.get(), MOFI.get(), &SrcMgr);

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

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

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

-    auto FOut = std::make_unique<formatted_raw_ostream>(*Out);
+    auto FOut = llvm::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),
@@ -356,7 +351,7 @@ bool ExecuteAssembler(AssemblerInvocation &Opts, DiagnosticsEngine &Diags) {
    assert(Opts.OutputType == AssemblerInvocation::FT_Obj &&
           "Invalid file type!");
    if (!FDOS->supportsSeeking()) {
-      BOS = std::make_unique<buffer_ostream>(*FDOS);
+      BOS = make_unique<buffer_ostream>(*FDOS);
      Out = BOS.get();
    }

@@ -441,7 +436,7 @@ static void LLVMErrorHandler(void *UserData, const std::string &Message,
  Diags.Report(diag::err_fe_error_backend) << Message;

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

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

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

@@ -490,7 +485,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 = std::make_unique<const char*[]>(NumArgs + 2);
+    auto Args = llvm::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();
@@ -504,7 +499,6 @@ 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,6 +11,8 @@
 //
 //===----------------------------------------------------------------------===//

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

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

 			// Execute the invocation, unless there were parsing errors.
@@ -6,28 +6,25 @@ 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{}
+var commands = map[string][]string{
+	"clang":   {"clang-9"},
+	"ld.lld":  {"ld.lld-9", "ld.lld"},
+	"wasm-ld": {"wasm-ld-9", "wasm-ld"},
+}

 func init() {
-	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
+	// Add the path to a Homebrew-installed LLVM 9 for ease of use (no need to
 	// manually set $PATH).
 	if runtime.GOOS == "darwin" {
-		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")
+		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")
 	}
 	// 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
@@ -37,12 +34,11 @@ 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 LLVM installed from ports.
+	// Add the path to the llvm90 installed from ports
 	if runtime.GOOS == "freebsd" {
-		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")
+		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")
 	}
 }

@@ -0,0 +1,60 @@
+// +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()
+	}
+}
@@ -0,0 +1,24 @@
+// +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 := goenv.GetGorootVersion(goroot)
+	major, minor, err := 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 > 15 {
-		return nil, fmt.Errorf("requires go version 1.11 through 1.15, got go%d.%d", major, minor)
+	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)
 	}
 	clangHeaderPath := getClangHeaderPath(goenv.Get("TINYGOROOT"))
 	return &compileopts.Config{
@@ -1,13 +1,71 @@
 package builder

 import (
+	"errors"
+	"fmt"
+	"io"
 	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
 	"sort"
+	"strings"
 )

+// 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.
@@ -1,153 +0,0 @@
-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)
-}
@@ -1,105 +0,0 @@
-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))
-}
@@ -0,0 +1,71 @@
+// +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()
+	}
+}
@@ -0,0 +1,27 @@
+// +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, llvm::outs(), llvm::errs());
+	return lld::elf::link(args, false);
 }

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

 } // external "C"
@@ -4,15 +4,12 @@ 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
@@ -74,12 +71,7 @@ func extractROM(path string) (uint64, []byte, error) {
 	var rom []byte
 	for _, prog := range progs {
 		if prog.Paddr != progs[0].Paddr+uint64(len(rom)) {
-			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)...)
+			return 0, nil, objcopyError{"ROM segments are non-contiguous: " + path, nil}
 		}
 		data, err := ioutil.ReadAll(prog.Open())
 		if err != nil {
@@ -101,7 +93,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, binaryFormat string) error {
+func objcopy(infile, outfile string) error {
 	f, err := os.OpenFile(outfile, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666)
 	if err != nil {
 		return err
@@ -115,20 +107,24 @@ func objcopy(infile, outfile, binaryFormat string) error {
 	}

 	// Write to the file, in the correct format.
-	switch binaryFormat {
-	case "hex":
-		// Intel hex file, includes the firmware start address.
+	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":
 		mem := gohex.NewMemory()
 		err := mem.AddBinary(uint32(addr), data)
 		if err != nil {
 			return objcopyError{"failed to create .hex file", err}
 		}
-		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
+		mem.DumpIntelHex(f, 16) // TODO: handle error
+		return nil
 	default:
 		panic("unreachable")
 	}
@@ -1,127 +0,0 @@
-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,18 +84,7 @@ func loadProgramSize(path string) (*programSize, error) {
 		if section.Type != elf.SHT_PROGBITS && section.Type != elf.SHT_NOBITS {
 			continue
 		}
-		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 {
+		if section.Type == elf.SHT_NOBITS {
 			sumBSS += section.Size
 		} else if section.Flags&elf.SHF_EXECINSTR != 0 {
 			sumCode += section.Size
@@ -1,54 +0,0 @@
-// +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
-}
@@ -1,15 +0,0 @@
-// +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)
-}
@@ -1,59 +0,0 @@
-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,33 +11,26 @@ import (
 	"bytes"
 	"encoding/binary"
 	"io/ioutil"
-	"strconv"
 )

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

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

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

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

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

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

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

 // newUF2Block returns a new uf2Block struct that has been correctly populated
-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)
-	}
+func newUF2Block(targetAddr uint32) *uf2Block {
 	return &uf2Block{magicStart0: uf2MagicStart0,
 		magicStart1: uf2MagicStart1,
 		magicEnd:    uf2MagicEnd,
 		targetAddr:  targetAddr,
-		flags:       flags,
-		familyID:    familyID,
+		flags:       0x0,
+		familyID:    0x0,
 		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,9 +14,7 @@ package cgo
 import (
 	"fmt"
 	"go/ast"
-	"go/scanner"
 	"go/token"
-	"path/filepath"
 	"sort"
 	"strconv"
 	"strings"
@@ -41,7 +39,6 @@ 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
@@ -157,7 +154,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, []string, []error) {
+func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string) (*ast.File, []error) {
 	p := &cgoPackage{
 		dir:             dir,
 		fset:            fset,
@@ -171,28 +168,11 @@ 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{
@@ -358,21 +338,7 @@ 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)
@@ -426,31 +392,7 @@ 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.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)
-			}
-		}
-	}
+	return p.generated, p.errors
 }

 // addFuncDecls adds the C function declarations found by libclang in the
@@ -11,7 +11,6 @@ import (
 	"go/types"
 	"io/ioutil"
 	"path/filepath"
-	"regexp"
 	"runtime"
 	"strings"
 	"testing"
@@ -20,21 +19,6 @@ 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"}

@@ -50,7 +34,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
@@ -90,7 +74,7 @@ func TestCGo(t *testing.T) {
 			if err != nil {
 				t.Errorf("could not write out CGo AST: %v", err)
 			}
-			actual := normalizeResult(string(buf.Bytes()))
+			actual := strings.Replace(string(buf.Bytes()), "\r\n", "\n", -1)

 			// 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-10-dev
+#include <clang-c/Index.h> // if this fails, install libclang-9-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, scannerError := parseConst(pos+token.Pos(len(name)), p.fset, value)
-		if scannerError != nil {
-			p.errors = append(p.errors, *scannerError)
+		expr, err := parseConst(pos+token.Pos(len(name)), p.fset, value)
+		if err != nil {
+			p.errors = append(p.errors, err)
 		}
 		if expr != nil {
 			// Parsing was successful.
@@ -1,14 +1,13 @@
 // +build !byollvm
-// +build !llvm9

 package cgo

 /*
-#cgo linux  CFLAGS: -I/usr/lib/llvm-10/include
-#cgo darwin CFLAGS: -I/usr/local/opt/llvm@10/include
-#cgo freebsd CFLAGS: -I/usr/local/llvm10/include
-#cgo linux  LDFLAGS: -L/usr/lib/llvm-10/lib -lclang
-#cgo darwin LDFLAGS: -L/usr/local/opt/llvm@10/lib -lclang -lffi
-#cgo freebsd LDFLAGS: -L/usr/local/llvm10/lib -lclang
+#cgo linux  CFLAGS: -I/usr/lib/llvm-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
 */
 import "C"
@@ -1,14 +0,0 @@
-// +build !byollvm
-// +build llvm9
-
-package cgo
-
-/*
-#cgo linux  CFLAGS: -I/usr/lib/llvm-9/include
-#cgo darwin CFLAGS: -I/usr/local/opt/llvm@9/include
-#cgo freebsd CFLAGS: -I/usr/local/llvm9/include
-#cgo linux  LDFLAGS: -L/usr/lib/llvm-9/lib -lclang
-#cgo darwin LDFLAGS: -L/usr/local/opt/llvm@9/lib -lclang -lffi
-#cgo freebsd LDFLAGS: -L/usr/local/llvm9/lib -lclang
-*/
-import "C"
@@ -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-10-dev
+#include <clang-c/Index.h> // if this fails, install libclang-9-dev

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

 #cgo CFLAGS: -DFOO

-#cgo CFLAGS: -Iinclude
-#include "foo.h"
-
 #if defined(FOO)
 #define BAR 3
 #else
@@ -21,17 +18,9 @@ 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,7 +1,6 @@
 // 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

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

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

 type C.int16_t = int16
 type C.int32_t = int32
@@ -1 +0,0 @@
-#define FOO_H 1
@@ -62,18 +62,12 @@ 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
 }
@@ -100,45 +94,25 @@ 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,7 +5,6 @@ package compileopts
 import (
 	"errors"
 	"fmt"
-	"path/filepath"
 	"regexp"
 	"strconv"
 	"strings"
@@ -22,29 +21,6 @@ type Config struct {
 	TestConfig     TestConfig
 }

-// FuncValueImplementation is an enum for the particular implementations of Go
-// func values.
-type FuncValueImplementation int
-
-// These constants describe the various possible implementations of Go func
-// values.
-const (
-	FuncValueNone FuncValueImplementation = iota
-
-	// A func value is implemented as a pair of pointers:
-	//     {context, function pointer}
-	// where the context may be a pointer to a heap-allocated struct containing
-	// the free variables, or it may be undef if the function being pointed to
-	// doesn't need a context. The function pointer is a regular function
-	// pointer.
-	FuncValueDoubleword
-
-	// As funcValueDoubleword, but with the function pointer replaced by a
-	// unique ID per function signature. Function values are called by using a
-	// switch statement and choosing which function to call.
-	FuncValueSwitch
-)
-
 // Triple returns the LLVM target triple, like armv6m-none-eabi.
 func (c *Config) Triple() string {
 	return c.Target.Triple
@@ -89,14 +65,8 @@ 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", "extalloc", and "conservative".
+// values are "none", "leaking", and "conservative".
 func (c *Config) GC() string {
 	if c.Options.GC != "" {
 		return c.Options.GC
@@ -104,33 +74,26 @@ func (c *Config) GC() string {
 	if c.Target.GC != "" {
 		return c.Target.GC
 	}
-	for _, tag := range c.Target.BuildTags {
-		if tag == "baremetal" || tag == "wasm" {
-			return "conservative"
-		}
-	}
-	return "extalloc"
+	return "conservative"
 }

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

-// Scheduler returns the scheduler implementation. Valid values are "none",
-//"coroutines" and "tasks".
+// Scheduler returns the scheduler implementation. Valid values are "coroutines"
+// and "tasks".
 func (c *Config) Scheduler() string {
 	if c.Options.Scheduler != "" {
 		return c.Options.Scheduler
@@ -142,21 +105,6 @@ 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).
@@ -164,16 +112,6 @@ 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 {
@@ -181,14 +119,6 @@ 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
 }

@@ -239,31 +169,6 @@ 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.
@@ -310,25 +215,6 @@ 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"
-}
-
 type TestConfig struct {
 	CompileTestBinary bool
 	// TODO: Filter the test functions to run, include verbose flag, etc
@@ -1,17 +1,5 @@
 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 {
@@ -25,7 +13,6 @@ type Options struct {
 	VerifyIR      bool
 	Debug         bool
 	PrintSizes    string
-	PrintStacks   bool
 	CFlags        []string
 	LDFlags       []string
 	Tags          string
@@ -34,53 +21,3 @@ 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
-}
@@ -1,138 +0,0 @@
-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)
-				}
-			}
-		})
-	}
-}
@@ -32,9 +32,6 @@ 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"`
@@ -46,14 +43,9 @@ type TargetSpec struct {
 	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"`
 }

 // copyProperties copies all properties that are set in spec2 into itself.
@@ -90,15 +82,6 @@ func (spec *TargetSpec) copyProperties(spec2 *TargetSpec) {
 	if spec2.RTLib != "" {
 		spec.RTLib = spec2.RTLib
 	}
-	if spec2.Libc != "" {
-		spec.Libc = spec2.Libc
-	}
-	if spec2.AutoStackSize != nil {
-		spec.AutoStackSize = spec2.AutoStackSize
-	}
-	if spec2.DefaultStackSize != 0 {
-		spec.DefaultStackSize = spec2.DefaultStackSize
-	}
 	spec.CFlags = append(spec.CFlags, spec2.CFlags...)
 	spec.LDFlags = append(spec.LDFlags, spec2.LDFlags...)
 	if spec2.LinkerScript != "" {
@@ -126,12 +109,6 @@ func (spec *TargetSpec) copyProperties(spec2 *TargetSpec) {
 	if spec2.FlashFilename != "" {
 		spec.FlashFilename = spec2.FlashFilename
 	}
-	if spec2.UF2FamilyID != "" {
-		spec.UF2FamilyID = spec2.UF2FamilyID
-	}
-	if spec2.BinaryFormat != "" {
-		spec.BinaryFormat = spec2.BinaryFormat
-	}
 	if spec2.OpenOCDInterface != "" {
 		spec.OpenOCDInterface = spec2.OpenOCDInterface
 	}
@@ -141,16 +118,6 @@ func (spec *TargetSpec) copyProperties(spec2 *TargetSpec) {
 	if spec2.OpenOCDTransport != "" {
 		spec.OpenOCDTransport = spec2.OpenOCDTransport
 	}
-	if spec2.JLinkDevice != "" {
-		spec.JLinkDevice = spec2.JLinkDevice
-	}
-	if spec2.CodeModel != "" {
-		spec.CodeModel = spec2.CodeModel
-	}
-
-	if spec2.RelocationModel != "" {
-		spec.RelocationModel = spec2.RelocationModel
-	}
 }

 // load reads a target specification from the JSON in the given io.Reader. It
@@ -254,14 +221,6 @@ 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"
@@ -270,12 +229,11 @@ func LoadTarget(target string) (*TargetSpec, error) {
 			"i386":    "386",
 			"x86_64":  "amd64",
 			"aarch64": "arm64",
-			"armv7":   "arm",
 		}[tripleSplit[0]]
 		if goarch == "" {
 			goarch = tripleSplit[0]
 		}
-		return defaultTarget(goos, goarch, strings.Join(tripleSplit, "-"))
+		return defaultTarget(goos, goarch, target)
 	}
 }

@@ -289,7 +247,6 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 		BuildTags:   []string{goos, goarch},
 		Compiler:    "clang",
 		Linker:      "cc",
-		CFlags:      []string{"--target=" + triple},
 		GDB:         "gdb",
 		PortReset:   "false",
 		FlashMethod: "native",
@@ -302,13 +259,11 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 	if goarch != runtime.GOARCH {
 		// Some educated guesses as to how to invoke helper programs.
 		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"}
@@ -4,19 +4,16 @@ 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"
 )

-// createLookupBoundsCheck emits a bounds check before doing a lookup into a
+// emitLookupBoundsCheck 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 (b *builder) createLookupBoundsCheck(arrayLen, index llvm.Value, indexType types.Type) {
-	if b.fn.IsNoBounds() {
+func (c *Compiler) emitLookupBoundsCheck(frame *Frame, arrayLen, index llvm.Value, indexType types.Type) {
+	if frame.fn.IsNoBounds() {
 		// The //go:nobounds pragma was added to the function to avoid bounds
 		// checking.
 		return
@@ -26,29 +23,41 @@ func (b *builder) createLookupBoundsCheck(arrayLen, index llvm.Value, indexType
 		// 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 = b.CreateZExt(index, arrayLen.Type(), "")
+			index = c.builder.CreateZExt(index, arrayLen.Type(), "")
 		} else {
-			index = b.CreateSExt(index, arrayLen.Type(), "")
+			index = c.builder.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 = b.CreateZExt(arrayLen, index.Type(), "")
+		arrayLen = c.builder.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 := b.CreateICmp(llvm.IntUGE, index, arrayLen, "")
-	b.createRuntimeAssert(outOfBounds, "lookup", "lookupPanic")
+	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)
 }

-// createSliceBoundsCheck emits a bounds check before a slicing operation to make
+// emitSliceBoundsCheck 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 (b *builder) createSliceBoundsCheck(capacity, low, high, max llvm.Value, lowType, highType, maxType *types.Basic) {
-	if b.fn.IsNoBounds() {
+func (c *Compiler) emitSliceBoundsCheck(frame *Frame, capacity, low, high, max llvm.Value, lowType, highType, maxType *types.Basic) {
+	if frame.fn.IsNoBounds() {
 		// The //go:nobounds pragma was added to the function to avoid bounds
 		// checking.
 		return
@@ -66,164 +75,92 @@ func (b *builder) createSliceBoundsCheck(capacity, low, high, max llvm.Value, lo
 		capacityType = max.Type()
 	}
 	if capacityType != capacity.Type() {
-		capacity = b.CreateZExt(capacity, capacityType, "")
+		capacity = c.builder.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 = b.CreateZExt(low, capacityType, "")
+			low = c.builder.CreateZExt(low, capacityType, "")
 		} else {
-			low = b.CreateSExt(low, capacityType, "")
+			low = c.builder.CreateSExt(low, capacityType, "")
 		}
 	}
 	if high.Type().IntTypeWidth() < capacityType.IntTypeWidth() {
 		if highType.Info()&types.IsUnsigned != 0 {
-			high = b.CreateZExt(high, capacityType, "")
+			high = c.builder.CreateZExt(high, capacityType, "")
 		} else {
-			high = b.CreateSExt(high, capacityType, "")
+			high = c.builder.CreateSExt(high, capacityType, "")
 		}
 	}
 	if max.Type().IntTypeWidth() < capacityType.IntTypeWidth() {
 		if maxType.Info()&types.IsUnsigned != 0 {
-			max = b.CreateZExt(max, capacityType, "")
+			max = c.builder.CreateZExt(max, capacityType, "")
 		} else {
-			max = b.CreateSExt(max, capacityType, "")
+			max = c.builder.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 := 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")
+	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)
 }

-// 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
+// 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
 // pointer dereferences exist in valid Go code.
-func (b *builder) createNilCheck(inst ssa.Value, ptr llvm.Value, blockPrefix string) {
+func (c *Compiler) emitNilCheck(frame *Frame, ptr llvm.Value, blockPrefix string) {
 	// Check whether we need to emit this check at all.
 	if !ptr.IsAGlobalValue().IsNil() {
 		return
 	}

-	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
-		}
-	}
+	// 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

 	// Compare against nil.
-	// 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, "")
-
-	// 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
+	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)

-	// 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)
+	// 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)
 }
@@ -1,57 +0,0 @@
-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,9 +1,8 @@
 package compiler

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

@@ -12,80 +11,62 @@ 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

-// 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
-}
-
-// 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)
+// 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)
 	}
-	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)
+	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)
 }

-// 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 {
+// 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 {
 	expanded := make([]llvm.Value, 0, len(args))
 	for _, arg := range args {
-		fragments := b.expandFormalParam(arg)
+		fragments := c.expandFormalParam(arg)
 		expanded = append(expanded, fragments...)
 	}
-	return b.CreateCall(fn, expanded, name)
+	return c.builder.CreateCall(fn, expanded, name)
 }

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

-// 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 {
+// 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 {
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
-		fields := b.flattenAggregateTypeOffsets(t)
-		if len(fields) <= maxFieldsPerParam {
+		fields := c.flattenAggregateTypeOffsets(t)
+		if len(fields) <= MaxFieldsPerParam {
 			return fields
 		} else {
 			// failed to lower
@@ -97,17 +78,14 @@ func (b *builder) expandFormalParamOffsets(t llvm.Type) []uint64 {
 	}
 }

-// 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 {
+// Equivalent of expandFormalParamType for parameter values.
+func (c *Compiler) expandFormalParam(v llvm.Value) []llvm.Value {
 	switch v.Type().TypeKind() {
 	case llvm.StructTypeKind:
-		fieldInfos := flattenAggregateType(v.Type(), "", nil)
-		if len(fieldInfos) <= maxFieldsPerParam {
-			fields := b.flattenAggregate(v)
-			if len(fields) != len(fieldInfos) {
+		fieldTypes := c.flattenAggregateType(v.Type())
+		if len(fieldTypes) <= MaxFieldsPerParam {
+			fields := c.flattenAggregate(v)
+			if len(fields) != len(fieldTypes) {
 				panic("type and value param lowering don't match")
 			}
 			return fields
@@ -123,98 +101,24 @@ func (b *builder) 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 flattenAggregateType(t llvm.Type, name string, goType types.Type) []paramInfo {
-	typeFlags := getTypeFlags(goType)
+func (c *Compiler) flattenAggregateType(t llvm.Type) []llvm.Type {
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
-		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...)
+		fields := make([]llvm.Type, 0, t.StructElementTypesCount())
+		for _, subfield := range t.StructElementTypes() {
+			subfields := c.flattenAggregateType(subfield)
+			fields = append(fields, subfields...)
 		}
-		return paramInfos
+		return fields
 	default:
-		return []paramInfo{
-			{
-				llvmType: t,
-				name:     name,
-				flags:    typeFlags,
-			},
-		}
+		return []llvm.Type{t}
 	}
 }

-// 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 {
+// 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 {
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
 		fields := make([]uint64, 0, t.StructElementTypesCount())
@@ -232,15 +136,15 @@ func (c *compilerContext) flattenAggregateTypeOffsets(t llvm.Type) []uint64 {
 	}
 }

-// 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 {
+// 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 {
 	switch v.Type().TypeKind() {
 	case llvm.StructTypeKind:
 		fields := make([]llvm.Value, 0, v.Type().StructElementTypesCount())
 		for i := range v.Type().StructElementTypes() {
-			subfield := b.CreateExtractValue(v, i, "")
-			subfields := b.flattenAggregate(subfield)
+			subfield := c.builder.CreateExtractValue(v, i, "")
+			subfields := c.flattenAggregate(subfield)
 			fields = append(fields, subfields...)
 		}
 		return fields
@@ -249,29 +153,25 @@ func (b *builder) flattenAggregate(v llvm.Value) []llvm.Value {
 	}
 }

-// 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)
+// 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)
 	if len(remaining) != 0 {
 		panic("failed to expand back all fields")
 	}
 	return param
 }

-// 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) {
+// Returns (value, remainingFields). Used by collapseFormalParam.
+func (c *Compiler) collapseFormalParamInternal(t llvm.Type, fields []llvm.Value) (llvm.Value, []llvm.Value) {
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
-		flattened := flattenAggregateType(t, "", nil)
-		if len(flattened) <= maxFieldsPerParam {
+		if len(c.flattenAggregateType(t)) <= MaxFieldsPerParam {
 			value := llvm.ConstNull(t)
 			for i, subtyp := range t.StructElementTypes() {
-				structField, remaining := b.collapseFormalParamInternal(subtyp, fields)
+				structField, remaining := c.collapseFormalParamInternal(subtyp, fields)
 				fields = remaining
-				value = b.CreateInsertValue(value, structField, i, "")
+				value = c.builder.CreateInsertValue(value, structField, i, "")
 			}
 			return value, fields
 		} else {
@@ -11,89 +11,73 @@ import (
 	"tinygo.org/x/go-llvm"
 )

-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}, "")
+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}, "")
 }

-// 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)
+// 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)

 	// store value-to-send
-	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")
+	valueType := c.getLLVMType(instr.X.Type())
+	valueAlloca, valueAllocaCast, valueAllocaSize := c.createTemporaryAlloca(valueType, "chan.value")
+	c.builder.CreateStore(chanValue, valueAlloca)

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

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

-// createChanRecv emits a pseudo chan receive operation. It is lowered to the
+// emitChanRecv emits a pseudo chan receive operation. It is lowered to the
 // actual channel receive operation during goroutine lowering.
-func (b *builder) createChanRecv(unop *ssa.UnOp) llvm.Value {
-	valueType := b.getLLVMType(unop.X.Type().Underlying().(*types.Chan).Elem())
-	ch := b.getValue(unop.X)
+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)

 	// Allocate memory to receive into.
-	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")
+	valueAlloca, valueAllocaCast, valueAllocaSize := c.createTemporaryAlloca(valueType, "chan.value")

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

 	if unop.CommaOk {
-		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, "")
+		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, "")
 		return tuple
 	} else {
 		return received
 	}
 }

-// createChanClose closes the given channel.
-func (b *builder) createChanClose(param ssa.Value) {
-	ch := b.getValue(param)
-	b.createRuntimeCall("chanClose", []llvm.Value{ch}, "")
+// 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}, "")
 }

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

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

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

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

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

 	// Terminate the lifetime of the states alloca.
-	b.emitLifetimeEnd(statesI8, statesSize)
+	c.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 b.selectRecvBuf == nil {
-		b.selectRecvBuf = make(map[*ssa.Select]llvm.Value)
+	if frame.selectRecvBuf == nil {
+		frame.selectRecvBuf = make(map[*ssa.Select]llvm.Value)
 	}
-	b.selectRecvBuf[expr] = recvbuf
+	frame.selectRecvBuf[expr] = recvbuf

 	return results
 }
@@ -226,28 +210,28 @@ func (b *builder) createSelect(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 (b *builder) getChanSelectResult(expr *ssa.Extract) llvm.Value {
+func (c *Compiler) getChanSelectResult(frame *Frame, expr *ssa.Extract) llvm.Value {
 	if expr.Index == 0 {
 		// index
-		value := b.getValue(expr.Tuple)
-		index := b.CreateExtractValue(value, expr.Index, "")
-		if index.Type().IntTypeWidth() < b.intType.IntTypeWidth() {
-			index = b.CreateSExt(index, b.intType, "")
+		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, "")
 		}
 		return index
 	} else if expr.Index == 1 {
 		// comma-ok
-		value := b.getValue(expr.Tuple)
-		return b.CreateExtractValue(value, expr.Index, "")
+		value := c.getValue(frame, expr.Tuple)
+		return c.builder.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 := b.selectRecvBuf[expr.Tuple.(*ssa.Select)]
-		typ := llvm.PointerType(b.getLLVMType(expr.Type()), 0)
-		ptr := b.CreateBitCast(recvbuf, typ, "")
-		return b.CreateLoad(ptr, "")
+		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, "")
 	}
 }
@@ -1,8 +1,7 @@
-// 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
+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.

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

-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 {
+func (c *Compiler) 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
@@ -86,7 +81,7 @@ func (c *checker) checkType(t llvm.Type, checked map[llvm.Type]struct{}, special
 	return nil
 }

-func (c *checker) checkValue(v llvm.Value, types map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) error {
+func (c *Compiler) 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())
@@ -100,30 +95,12 @@ func (c *checker) checkValue(v llvm.Value, types map[llvm.Type]struct{}, special
 	return nil
 }

-func (c *checker) checkInstruction(inst llvm.Value, types map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) error {
+func (c *Compiler) 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 {
@@ -134,7 +111,7 @@ func (c *checker) checkInstruction(inst llvm.Value, types map[llvm.Type]struct{}
 	return nil
 }

-func (c *checker) checkBasicBlock(bb llvm.BasicBlock, types map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) []error {
+func (c *Compiler) 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 {
@@ -151,7 +128,7 @@ func (c *checker) checkBasicBlock(bb llvm.BasicBlock, types map[llvm.Type]struct
 	return errs
 }

-func (c *checker) checkFunction(fn llvm.Value, types map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) []error {
+func (c *Compiler) 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 {
@@ -166,25 +143,26 @@ func (c *checker) checkFunction(fn llvm.Value, types map[llvm.Type]struct{}, spe
 	return errs
 }

-// Module checks the given module and returns a slice of error, if there are
-// any.
-func Module(mod llvm.Module) []error {
+func (c *Compiler) checkModule() []error {
 	// check for any context mismatches
 	var errs []error
-	c := checker{
-		ctx: mod.Context(),
-	}
-	if c.ctx == llvm.GlobalContext() {
+	switch {
+	case c.mod.Context() == c.ctx:
+		// this is correct
+	case c.mod.Context() == 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 := mod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
+	for fn := c.mod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
 		errs = append(errs, c.checkFunction(fn, types, specials)...)
 	}
-	for g := mod.FirstGlobal(); !g.IsNil(); g = llvm.NextGlobal(g) {
+	for g := c.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()))
 		}
@@ -16,7 +16,6 @@ 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"
 )
@@ -24,18 +23,16 @@ 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 (b *builder) deferInitFunc() {
+func (c *Compiler) deferInitFunc(frame *Frame) {
 	// Some setup.
-	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)
+	frame.deferFuncs = make(map[*ir.Function]int)
+	frame.deferInvokeFuncs = make(map[string]int)
+	frame.deferClosureFuncs = make(map[*ir.Function]int)

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

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

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

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

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

 		// Collect all values to be put in the struct (starting with
 		// runtime._defer fields, followed by the call parameters).
-		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)
+		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)
 		for _, arg := range instr.Call.Args {
-			val := b.getValue(arg)
+			val := c.getValue(frame, arg)
 			values = append(values, val)
 			valueTypes = append(valueTypes, val.Type())
 		}

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

-		if _, ok := b.deferFuncs[fn]; !ok {
-			b.deferFuncs[fn] = len(b.allDeferFuncs)
-			b.allDeferFuncs = append(b.allDeferFuncs, fn)
+		if _, ok := frame.deferFuncs[fn]; !ok {
+			frame.deferFuncs[fn] = len(frame.allDeferFuncs)
+			frame.allDeferFuncs = append(frame.allDeferFuncs, fn)
 		}
-		callback := llvm.ConstInt(b.uintptrType, uint64(b.deferFuncs[fn]), false)
+		callback := llvm.ConstInt(c.uintptrType, uint64(frame.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 := b.getValue(param)
+			llvmParam := c.getValue(frame, param)
 			values = append(values, llvmParam)
 			valueTypes = append(valueTypes, llvmParam.Type())
 		}
@@ -131,110 +127,65 @@ func (b *builder) createDefer(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 := b.getValue(instr.Call.Value)
-		context := b.CreateExtractValue(closure, 0, "")
+		closure := c.getValue(frame, instr.Call.Value)
+		context := c.builder.CreateExtractValue(closure, 0, "")

 		// Get the callback number.
-		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)
+		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)
 		}
-		callback := llvm.ConstInt(b.uintptrType, uint64(b.deferClosureFuncs[fn]), false)
+		callback := llvm.ConstInt(c.uintptrType, uint64(frame.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 := b.getValue(param)
+			llvmParam := c.getValue(frame, 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 {
-		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())
-		}
+		c.addError(instr.Pos(), "todo: defer on uncommon function call type")
+		return
 	}

 	// Make a struct out of the collected values to put in the defer frame.
-	deferFrameType := b.ctx.StructType(valueTypes, false)
+	deferFrameType := c.ctx.StructType(valueTypes, false)
 	deferFrame := llvm.ConstNull(deferFrameType)
 	for i, value := range values {
-		deferFrame = b.CreateInsertValue(deferFrame, value, i, "")
+		deferFrame = c.builder.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(b.Builder, deferFrameType, "defer.alloca")
+		alloca = llvmutil.CreateEntryBlockAlloca(c.builder, deferFrameType, "defer.alloca")
 	} else {
 		// This may be hit a variable number of times, so use a heap allocation.
-		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")
+		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")
 	}
-	if b.NeedsStackObjects() {
-		b.trackPointer(alloca)
+	if c.NeedsStackObjects() {
+		c.trackPointer(alloca)
 	}
-	b.CreateStore(deferFrame, alloca)
+	c.builder.CreateStore(deferFrame, alloca)

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

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

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

 	// Create loop head:
 	//     for stack != nil {
-	b.SetInsertPointAtEnd(loophead)
-	deferData := b.CreateLoad(b.deferPtr, "")
-	stackIsNil := b.CreateICmp(llvm.IntEQ, deferData, llvm.ConstPointerNull(deferData.Type()), "stackIsNil")
-	b.CreateCondBr(stackIsNil, end, loop)
+	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)

 	// Create loop body:
 	//     _stack := stack
 	//     stack = stack.next
 	//     switch stack.callback {
-	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
+	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
 	}, "stack.next.gep")
-	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
+	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
 	}, "callback.gep")
-	callback := b.CreateLoad(gep, "callback")
-	sw := b.CreateSwitch(callback, unreachable, len(b.allDeferFuncs))
+	callback := c.builder.CreateLoad(gep, "callback")
+	sw := c.builder.CreateSwitch(callback, unreachable, len(frame.allDeferFuncs))

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

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

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

-			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))
-			}
+			// 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))

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

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

 		case *ir.Function:
 			// Direct call.

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

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

-			// 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))
+			// 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))

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

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

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

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

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

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

-			//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.
-		b.CreateBr(loophead)
+		c.builder.CreateBr(loophead)
 	}

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

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

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

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

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

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

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

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

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

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

 // decodeFuncValue extracts the context and the function pointer from this func
 // value. This may be an expensive operation.
-func (b *builder) decodeFuncValue(funcValue llvm.Value, sig *types.Signature) (funcPtr, context llvm.Value) {
-	context = b.CreateExtractValue(funcValue, 0, "")
-	switch b.FuncImplementation() {
-	case compileopts.FuncValueDoubleword:
-		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, "")
+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, "")
 	default:
 		panic("unimplemented func value variant")
 	}
@@ -82,12 +109,12 @@ func (b *builder) decodeFuncValue(funcValue llvm.Value, sig *types.Signature) (f
 }

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

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

 // parseMakeClosure makes a function value (with context) from the given
 // closure expression.
-func (b *builder) parseMakeClosure(expr *ssa.MakeClosure) (llvm.Value, error) {
+func (c *Compiler) parseMakeClosure(frame *Frame, expr *ssa.MakeClosure) (llvm.Value, error) {
 	if len(expr.Bindings) == 0 {
 		panic("unexpected: MakeClosure without bound variables")
 	}
-	f := b.ir.GetFunction(expr.Fn.(*ssa.Function))
+	f := c.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 := b.getValue(binding)
+		llvmBoundVar := c.getValue(frame, binding)
 		boundVars[i] = llvmBoundVar
 	}

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

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

 // trackExpr inserts pointer tracking intrinsics for the GC if the expression is
 // one of the expressions that need this.
-func (b *builder) trackExpr(expr ssa.Value, value llvm.Value) {
+func (c *Compiler) trackExpr(frame *Frame, 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.
-		b.trackPointer(value)
+		c.trackPointer(value)
 	case *ssa.Call, *ssa.Convert, *ssa.MakeClosure, *ssa.MakeInterface, *ssa.MakeSlice, *ssa.Next:
 		if !value.IsNil() {
-			b.trackValue(value)
+			c.trackValue(value)
 		}
 	case *ssa.Select:
-		if alloca, ok := b.selectRecvBuf[expr]; ok {
+		if alloca, ok := frame.selectRecvBuf[expr]; ok {
 			if alloca.IsAUndefValue().IsNil() {
-				b.trackPointer(alloca)
+				c.trackPointer(alloca)
 			}
 		}
 	case *ssa.UnOp:
 		switch expr.Op {
 		case token.MUL:
 			// Pointer dereference.
-			b.trackValue(value)
+			c.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).
-			b.trackValue(value)
-		}
-	case *ssa.BinOp:
-		switch expr.Op {
-		case token.ADD:
-			// String concatenation.
-			b.trackValue(value)
+			c.trackValue(value)
 		}
 	}
 }

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

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

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

-	"github.com/tinygo-org/tinygo/compiler/llvmutil"
-	"tinygo.org/x/go-llvm"
-)
-
-// createGoInstruction starts a new goroutine with the provided function pointer
+// emitStartGoroutine starts a new goroutine with the provided function pointer
 // and parameters.
 // In general, you should pass all regular parameters plus the context parameter.
 // There is one exception: the task-based scheduler needs to have the function
 // pointer passed in as a parameter too in addition to the context.
 //
 // Because a go statement doesn't return anything, return undef.
-func (b *builder) createGoInstruction(funcPtr llvm.Value, params []llvm.Value, prefix string, pos token.Pos) llvm.Value {
-	paramBundle := b.emitPointerPack(params)
-	var callee, stackSize llvm.Value
-	switch b.Scheduler() {
-	case "none", "tasks":
-		callee = b.createGoroutineStartWrapper(funcPtr, prefix, 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)
-		}
+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}, "")
 	case "coroutines":
-		callee = b.CreatePtrToInt(funcPtr, b.uintptrType, "")
-		// There is no goroutine stack size: coroutines are used instead of
-		// stacks.
-		stackSize = llvm.Undef(b.uintptrType)
+		// 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)), "")
 	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())
 }

@@ -64,58 +52,36 @@ func (b *builder) createGoInstruction(funcPtr llvm.Value, params []llvm.Value, p
 // 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 *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix string, pos token.Pos) llvm.Value {
+func (c *Compiler) createGoroutineStartWrapper(fn llvm.Value) 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 llvm.ConstPtrToInt(wrapper, c.uintptrType)
+			return c.builder.CreatePtrToInt(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.InternalLinkage)
+		wrapper.SetLinkage(llvm.PrivateLinkage)
 		wrapper.SetUnnamedAddr(true)
-		wrapper.AddAttributeAtIndex(-1, c.ctx.CreateStringAttribute("tinygo-gowrapper", name))
 		entry := c.ctx.AddBasicBlock(wrapper, "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{})
-		}
+		c.builder.SetInsertPointAtEnd(entry)

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

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

 	} else {
 		// For a function pointer like this:
@@ -135,41 +101,22 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 		// 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, prefix+".gowrapper", wrapperType)
+		wrapper = llvm.AddFunction(c.mod, ".gowrapper", wrapperType)
 		wrapper.SetLinkage(llvm.InternalLinkage)
 		wrapper.SetUnnamedAddr(true)
-		wrapper.AddAttributeAtIndex(-1, c.ctx.CreateStringAttribute("tinygo-gowrapper", ""))
 		entry := c.ctx.AddBasicBlock(wrapper, "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{})
-		}
+		c.builder.SetInsertPointAtEnd(entry)

 		// 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 := llvmutil.EmitPointerUnpack(builder, c.mod, wrapper.Param(0), paramTypes)
+		params := c.emitPointerUnpack(wrapper.Param(0), paramTypes)

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

 		// Create the call.
-		builder.CreateCall(fnPtr, params, "")
+		c.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.
-	builder.CreateRetVoid()
+	c.builder.CreateRetVoid()

 	// Return a ptrtoint of the wrapper, not the function itself.
-	return builder.CreatePtrToInt(wrapper, c.uintptrType, "")
+	return c.builder.CreatePtrToInt(wrapper, c.uintptrType, "")
 }
@@ -13,6 +13,27 @@ 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.
@@ -20,18 +41,18 @@ import (
 //     func Asm(asm string)
 //
 // The provided assembly must be a constant.
-func (b *builder) createInlineAsm(args []ssa.Value) (llvm.Value, error) {
+func (c *Compiler) emitAsm(args []ssa.Value) (llvm.Value, error) {
 	// Magic function: insert inline assembly instead of calling it.
-	fnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{}, false)
+	fnType := llvm.FunctionType(c.ctx.VoidType(), []llvm.Type{}, false)
 	asm := constant.StringVal(args[0].(*ssa.Const).Value)
 	target := llvm.InlineAsm(fnType, asm, "", true, false, 0)
-	return b.CreateCall(target, nil, ""), nil
+	return c.builder.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{}) uintptr
+//     func AsmFull(asm string, regs map[string]interface{})
 //
 // The asm parameter must be a constant string. The regs parameter must be
 // provided immediately. For example:
@@ -42,27 +63,27 @@ func (b *builder) createInlineAsm(args []ssa.Value) (llvm.Value, error) {
 //             "value":  1
 //             "result": &dest,
 //         })
-func (b *builder) createInlineAsmFull(instr *ssa.CallCommon) (llvm.Value, error) {
+func (c *Compiler) emitAsmFull(frame *Frame, instr *ssa.CallCommon) (llvm.Value, error) {
 	asmString := constant.StringVal(instr.Args[0].(*ssa.Const).Value)
 	registers := map[string]llvm.Value{}
-	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())
+	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")
 			}
+			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
@@ -71,22 +92,13 @@ func (b *builder) createInlineAsmFull(instr *ssa.CallCommon) (llvm.Value, error)
 	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 = b.makeError(instr.Pos(), "unknown register name: "+name)
+				err = c.makeError(instr.Pos(), "unknown register name: "+name)
 			}
 			return s
 		}
@@ -100,7 +112,7 @@ func (b *builder) createInlineAsmFull(instr *ssa.CallCommon) (llvm.Value, error)
 			case llvm.PointerTypeKind:
 				constraints = append(constraints, "*m")
 			default:
-				err = b.makeError(instr.Pos(), "unknown type in inline assembly for value: "+name)
+				err = c.makeError(instr.Pos(), "unknown type in inline assembly for value: "+name)
 				return s
 			}
 		}
@@ -109,21 +121,9 @@ func (b *builder) createInlineAsmFull(instr *ssa.CallCommon) (llvm.Value, error)
 	if err != nil {
 		return llvm.Value{}, err
 	}
-	var outputType llvm.Type
-	if hasOutput {
-		outputType = b.uintptrType
-	} else {
-		outputType = b.ctx.VoidType()
-	}
-	fnType := llvm.FunctionType(outputType, argTypes, false)
+	fnType := llvm.FunctionType(c.ctx.VoidType(), argTypes, false)
 	target := llvm.InlineAsm(fnType, asmString, strings.Join(constraints, ","), true, false, 0)
-	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
-	}
+	return c.builder.CreateCall(target, args, ""), nil
 }

 // This is a compiler builtin which emits an inline SVCall instruction. It can
@@ -137,7 +137,7 @@ func (b *builder) createInlineAsmFull(instr *ssa.CallCommon) (llvm.Value, error)
 //
 // The num parameter must be a constant. All other parameters may be any scalar
 // value supported by LLVM inline assembly.
-func (b *builder) emitSVCall(args []ssa.Value) (llvm.Value, error) {
+func (c *Compiler) emitSVCall(frame *Frame, 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 (b *builder) emitSVCall(args []ssa.Value) (llvm.Value, error) {
 		} else {
 			constraints += ",{r" + strconv.Itoa(i) + "}"
 		}
-		llvmValue := b.getValue(arg)
+		llvmValue := c.getValue(frame, arg)
 		llvmArgs = append(llvmArgs, llvmValue)
 		argTypes = append(argTypes, llvmValue.Type())
 	}
@@ -158,52 +158,7 @@ func (b *builder) emitSVCall(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(b.uintptrType, argTypes, false)
+	fnType := llvm.FunctionType(c.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)
-	}
+	return c.builder.CreateCall(target, llvmArgs, ""), nil
 }
@@ -16,35 +16,35 @@ import (
 	"tinygo.org/x/go-llvm"
 )

-// createMakeInterface emits the LLVM IR for the *ssa.MakeInterface instruction.
+// parseMakeInterface 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 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())
+// 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())
 	if itfConcreteTypeGlobal.IsNil() {
-		typeInInterface := b.getLLVMRuntimeType("typeInInterface")
-		itfConcreteTypeGlobal = llvm.AddGlobal(b.mod, typeInInterface, "typeInInterface:"+itfTypeCodeGlobal.Name())
+		typeInInterface := c.getLLVMRuntimeType("typeInInterface")
+		itfConcreteTypeGlobal = llvm.AddGlobal(c.mod, typeInInterface, "typeInInterface:"+itfTypeCodeGlobal.Name())
 		itfConcreteTypeGlobal.SetInitializer(llvm.ConstNamedStruct(typeInInterface, []llvm.Value{itfTypeCodeGlobal, itfMethodSetGlobal}))
 		itfConcreteTypeGlobal.SetGlobalConstant(true)
 		itfConcreteTypeGlobal.SetLinkage(llvm.PrivateLinkage)
 	}
-	itfTypeCode := b.CreatePtrToInt(itfConcreteTypeGlobal, b.uintptrType, "")
-	itf := llvm.Undef(b.getLLVMRuntimeType("_interface"))
-	itf = b.CreateInsertValue(itf, itfTypeCode, 0, "")
-	itf = b.CreateInsertValue(itf, itfValue, 1, "")
+	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, "")
 	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 *compilerContext) getTypeCode(typ types.Type) llvm.Value {
+func (c *Compiler) 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 *compilerContext) 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 *compilerContext) makeStructTypeFields(typ *types.Struct) llvm.Value {
+func (c *Compiler) 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 *compilerContext) getTypeMethodSet(typ types.Type) llvm.Value {
+func (c *Compiler) 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,13 +271,8 @@ func (c *compilerContext) 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 *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")
+func (c *Compiler) getInterfaceMethodSet(typ *types.Named) llvm.Value {
+	global := c.mod.NamedGlobal(typ.String() + "$interface")
 	zero := llvm.ConstInt(c.ctx.Int32Type(), 0, false)
 	if !global.IsNil() {
 		// method set already exist, return it
@@ -292,7 +287,7 @@ func (c *compilerContext) getInterfaceMethodSet(typ types.Type) llvm.Value {
 	}

 	value := llvm.ConstArray(c.i8ptrType, methods)
-	global = llvm.AddGlobal(c.mod, value.Type(), name+"$interface")
+	global = llvm.AddGlobal(c.mod, value.Type(), typ.String()+"$interface")
 	global.SetInitializer(value)
 	global.SetGlobalConstant(true)
 	global.SetLinkage(llvm.PrivateLinkage)
@@ -302,7 +297,7 @@ func (c *compilerContext) getInterfaceMethodSet(typ types.Type) 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 *compilerContext) getMethodSignature(method *types.Func) llvm.Value {
+func (c *Compiler) getMethodSignature(method *types.Func) llvm.Value {
 	signature := ir.MethodSignature(method)
 	signatureGlobal := c.mod.NamedGlobal("func " + signature)
 	if signatureGlobal.IsNil() {
@@ -312,18 +307,18 @@ func (c *compilerContext) getMethodSignature(method *types.Func) llvm.Value {
 	return signatureGlobal
 }

-// createTypeAssert will emit the code for a typeassert, used in if statements
+// parseTypeAssert 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 (b *builder) createTypeAssert(expr *ssa.TypeAssert) llvm.Value {
-	itf := b.getValue(expr.X)
-	assertedType := b.getLLVMType(expr.AssertedType)
+func (c *Compiler) parseTypeAssert(frame *Frame, expr *ssa.TypeAssert) llvm.Value {
+	itf := c.getValue(frame, expr.X)
+	assertedType := c.getLLVMType(expr.AssertedType)

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

 	// Add 2 new basic blocks (that should get optimized away): one for the
@@ -356,15 +351,15 @@ func (b *builder) createTypeAssert(expr *ssa.TypeAssert) llvm.Value {
 	// typeassert should return a zero value, not an incorrectly casted
 	// value.

-	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)
+	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)

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

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

 	if expr.CommaOk {
-		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
+		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
 		return tuple
 	} else {
 		// This is kind of dirty as the branch above becomes mostly useless,
 		// but hopefully this gets optimized away.
-		b.createRuntimeCall("interfaceTypeAssert", []llvm.Value{commaOk}, "")
+		c.createRuntimeCall("interfaceTypeAssert", []llvm.Value{commaOk}, "")
 		return phi
 	}
 }

-// 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))
+// 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")
 	values := []llvm.Value{
 		typecode,
-		b.getInterfaceMethodSet(instr.Value.Type()),
-		b.getMethodSignature(instr.Method),
+		c.getInterfaceMethodSet(instr.Value.Type().(*types.Named)),
+		c.getMethodSignature(instr.Method),
 	}
-	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")
+	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")

 	args := []llvm.Value{receiverValue}
 	for _, arg := range instr.Args {
-		args = append(args, b.getValue(arg))
+		args = append(args, c.getValue(frame, 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(b.i8ptrType))
+	args = append(args, llvm.Undef(c.i8ptrType))
 	// Add the parent goroutine handle.
-	args = append(args, llvm.Undef(b.i8ptrType))
+	args = append(args, llvm.Undef(c.i8ptrType))

 	return fnCast, args
 }

-// 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 {
+// 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 {
 	wrapperName := f.LinkName() + "$invoke"
 	wrapper := c.mod.NamedFunction(wrapperName)
 	if !wrapper.IsNil() {
@@ -446,10 +445,7 @@ func (c *compilerContext) getInterfaceInvokeWrapper(f *ir.Function) llvm.Value {

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

 	// Does this method even need any wrapping?
 	if len(expandedReceiverType) == 1 && receiverType.TypeKind() == llvm.PointerTypeKind {
@@ -468,37 +464,41 @@ func (c *compilerContext) getInterfaceInvokeWrapper(f *ir.Function) llvm.Value {
 	if f.LLVMFn.LastParam().Name() == "parentHandle" {
 		wrapper.LastParam().SetName("parentHandle")
 	}
+	c.interfaceInvokeWrappers = append(c.interfaceInvokeWrappers, interfaceInvokeWrapper{
+		fn:           f,
+		wrapper:      wrapper,
+		receiverType: receiverType,
+	})
+	return wrapper
+}

+// 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(f.Pos())
-		difunc := c.attachDebugInfoRaw(f, wrapper, "$invoke", pos.Filename, pos.Line)
-		b.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), difunc, llvm.Metadata{})
+		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{})
 	}

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

-	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()
+	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()
 	} else {
-		ret := b.CreateCall(f.LLVMFn, params, "ret")
-		b.CreateRet(ret)
+		ret := c.builder.CreateCall(fn.LLVMFn, params, "ret")
+		c.builder.CreateRet(ret)
 	}
-
-	return wrapper
 }
@@ -8,62 +8,61 @@ import (
 	"tinygo.org/x/go-llvm"
 )

-// createInterruptGlobal creates a new runtime/interrupt.Interrupt struct that
+// emitInterruptGlobal 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 (b *builder) createInterruptGlobal(instr *ssa.CallCommon) (llvm.Value, error) {
+func (c *Compiler) emitInterruptGlobal(frame *Frame, 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{}, b.makeError(instr.Pos(), "interrupt ID is not a constant")
+		return llvm.Value{}, c.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 := b.getValue(instr.Args[1])
+	funcValue := c.getValue(frame, 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{}, b.makeError(instr.Pos(), "closures are not supported in interrupt.New")
+			return llvm.Value{}, c.makeError(instr.Pos(), "closures are not supported in interrupt.New")
 		}
 		// Fall back to a generic error.
-		return llvm.Value{}, b.makeError(instr.Pos(), "interrupt function must be constant")
+		return llvm.Value{}, c.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 := b.ir.Program.ImportedPackage("runtime/interrupt").Type("handle").Type()
-	globalLLVMType := b.getLLVMType(globalType)
+	globalType := c.ir.Program.ImportedPackage("runtime/interrupt").Type("handle").Type()
+	globalLLVMType := c.getLLVMType(globalType)
 	globalName := "runtime/interrupt.$interrupt" + strconv.FormatInt(id.Int64(), 10)
-	if global := b.mod.NamedGlobal(globalName); !global.IsNil() {
-		return llvm.Value{}, b.makeError(instr.Pos(), "interrupt redeclared in this program")
+	if global := c.mod.NamedGlobal(globalName); !global.IsNil() {
+		return llvm.Value{}, c.makeError(instr.Pos(), "interrupt redeclared in this program")
 	}
-	global := llvm.AddGlobal(b.mod, globalLLVMType, globalName)
+	global := llvm.AddGlobal(c.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(b.intType, uint64(id.Int64()), true), []uint32{1, 0})
+	initializer = llvm.ConstInsertValue(initializer, llvm.ConstInt(c.intType, uint64(id.Int64()), true), []uint32{1, 0})
 	global.SetInitializer(initializer)

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

 	// Create the runtime/interrupt.Interrupt type. It is a struct with a single
 	// member of type int.
-	num := llvm.ConstPtrToInt(global, b.intType)
-	interrupt := llvm.ConstNamedStruct(b.mod.GetTypeByName("runtime/interrupt.Interrupt"), []llvm.Value{num})
+	num := llvm.ConstPtrToInt(global, c.intType)
+	interrupt := llvm.ConstNamedStruct(c.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(b.Triple(), "avr") {
-		useFn := b.mod.NamedFunction("runtime/interrupt.use")
+	if strings.HasPrefix(c.Triple(), "avr") {
+		useFn := c.mod.NamedFunction("runtime/interrupt.use")
 		if useFn.IsNil() {
-			useFnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{interrupt.Type()}, false)
-			useFn = llvm.AddFunction(b.mod, "runtime/interrupt.use", useFnType)
+			useFnType := llvm.FunctionType(c.ctx.VoidType(), []llvm.Type{interrupt.Type()}, false)
+			useFn = llvm.AddFunction(c.mod, "runtime/interrupt.use", useFnType)
 		}
-		b.CreateCall(useFn, []llvm.Value{interrupt}, "")
+		c.builder.CreateCall(useFn, []llvm.Value{interrupt}, "")
 	}

 	return interrupt, nil
@@ -1,50 +0,0 @@
-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,48 +0,0 @@
-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 information in the IR signalling that the alloca won't be used
+// lifetime start infromation 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 (b *builder) createTemporaryAlloca(t llvm.Type, name string) (alloca, bitcast, size llvm.Value) {
-	return llvmutil.CreateTemporaryAlloca(b.Builder, b.mod, t, name)
+func (c *Compiler) createTemporaryAlloca(t llvm.Type, name string) (alloca, bitcast, size llvm.Value) {
+	return llvmutil.CreateTemporaryAlloca(c.builder, c.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 (b *builder) emitLifetimeEnd(ptr, size llvm.Value) {
-	llvmutil.EmitLifetimeEnd(b.Builder, b.mod, ptr, size)
+func (c *Compiler) emitLifetimeEnd(ptr, size llvm.Value) {
+	llvmutil.EmitLifetimeEnd(c.builder, c.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 (b *builder) emitPointerPack(values []llvm.Value) llvm.Value {
-	return llvmutil.EmitPointerPack(b.Builder, b.mod, b.Config, values)
+func (c *Compiler) emitPointerPack(values []llvm.Value) llvm.Value {
+	return llvmutil.EmitPointerPack(c.builder, c.mod, c.Config, values)
 }

 // emitPointerUnpack extracts a list of values packed using emitPointerPack.
-func (b *builder) emitPointerUnpack(ptr llvm.Value, valueTypes []llvm.Type) []llvm.Value {
-	return llvmutil.EmitPointerUnpack(b.Builder, b.mod, ptr, valueTypes)
+func (c *Compiler) emitPointerUnpack(ptr llvm.Value, valueTypes []llvm.Type) []llvm.Value {
+	return llvmutil.EmitPointerUnpack(c.builder, c.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 *compilerContext) makeGlobalArray(buf []byte, name string, elementType llvm.Type) llvm.Value {
+func (c *Compiler) 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,7 +12,6 @@ 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())
@@ -43,27 +42,6 @@ func EmitPointerPack(builder llvm.Builder, mod llvm.Module, config *compileopts.
 		// it in an alloca first for bitcasting (store+bitcast+load).
 		packedAlloc, _, _ = CreateTemporaryAlloca(builder, mod, packedType, "")
 	} 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")
@@ -6,167 +6,115 @@ import (
 	"go/token"
 	"go/types"

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

-// 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)
+func (c *Compiler) emitMapLookup(keyType, valueType types.Type, m, key llvm.Value, commaOk bool, pos token.Pos) (llvm.Value, error) {
+	llvmValueType := c.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, 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)
-	}
+	mapValueAlloca, mapValuePtr, mapValueSize := c.createTemporaryAlloca(llvmValueType, "hashmap.value")

 	// 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, mapValueSize}
-		commaOkValue = b.createRuntimeCall("hashmapStringGet", params, "")
+		params := []llvm.Value{m, key, mapValuePtr}
+		commaOkValue = c.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 := b.createTemporaryAlloca(key.Type(), "hashmap.key")
-		b.CreateStore(key, mapKeyAlloca)
+		mapKeyAlloca, mapKeyPtr, mapKeySize := c.createTemporaryAlloca(key.Type(), "hashmap.key")
+		c.builder.CreateStore(key, mapKeyAlloca)
 		// Fetch the value from the hashmap.
-		params := []llvm.Value{m, mapKeyPtr, mapValuePtr, mapValueSize}
-		commaOkValue = b.createRuntimeCall("hashmapBinaryGet", params, "")
-		b.emitLifetimeEnd(mapKeyPtr, mapKeySize)
+		params := []llvm.Value{m, mapKeyPtr, mapValuePtr}
+		commaOkValue = c.createRuntimeCall("hashmapBinaryGet", params, "")
+		c.emitLifetimeEnd(mapKeyPtr, mapKeySize)
 	} else {
-		// 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, "")
+		// 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())
 	}

 	// 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 := b.CreateLoad(mapValueAlloca, "")
-	b.emitLifetimeEnd(mapValuePtr, mapValueAllocaSize)
+	mapValue := c.builder.CreateLoad(mapValueAlloca, "")
+	c.emitLifetimeEnd(mapValuePtr, mapValueSize)

 	if commaOk {
-		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, "")
+		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, "")
 		return tuple, nil
 	} else {
 		return mapValue, nil
 	}
 }

-// 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)
+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)
 	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}
-		b.createRuntimeCall("hashmapStringSet", params, "")
+		c.createRuntimeCall("hashmapStringSet", params, "")
 	} else if hashmapIsBinaryKey(keyType) {
 		// key can be compared with runtime.memequal
-		keyAlloca, keyPtr, keySize := b.createTemporaryAlloca(key.Type(), "hashmap.key")
-		b.CreateStore(key, keyAlloca)
+		keyAlloca, keyPtr, keySize := c.createTemporaryAlloca(key.Type(), "hashmap.key")
+		c.builder.CreateStore(key, keyAlloca)
 		params := []llvm.Value{m, keyPtr, valuePtr}
-		b.createRuntimeCall("hashmapBinarySet", params, "")
-		b.emitLifetimeEnd(keyPtr, keySize)
+		c.createRuntimeCall("hashmapBinarySet", params, "")
+		c.emitLifetimeEnd(keyPtr, keySize)
 	} else {
-		// 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.addError(pos, "only strings, bools, ints, pointers or structs of bools/ints are supported as map keys, but got: "+keyType.String())
 	}
-	b.emitLifetimeEnd(valuePtr, valueSize)
+	c.emitLifetimeEnd(valuePtr, valueSize)
 }

-// 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 {
+func (c *Compiler) emitMapDelete(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}
-		b.createRuntimeCall("hashmapStringDelete", params, "")
+		c.createRuntimeCall("hashmapStringDelete", params, "")
 		return nil
 	} else if hashmapIsBinaryKey(keyType) {
-		keyAlloca, keyPtr, keySize := b.createTemporaryAlloca(key.Type(), "hashmap.key")
-		b.CreateStore(key, keyAlloca)
+		keyAlloca, keyPtr, keySize := c.createTemporaryAlloca(key.Type(), "hashmap.key")
+		c.builder.CreateStore(key, keyAlloca)
 		params := []llvm.Value{m, keyPtr}
-		b.createRuntimeCall("hashmapBinaryDelete", params, "")
-		b.emitLifetimeEnd(keyPtr, keySize)
+		c.createRuntimeCall("hashmapBinaryDelete", params, "")
+		c.emitLifetimeEnd(keyPtr, keySize)
 		return nil
 	} else {
-		// 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
+		return c.makeError(pos, "only strings, bools, ints, pointers or structs of bools/ints are supported as map keys, but got: "+keyType.String())
 	}
 }

+// 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 {
@@ -0,0 +1,164 @@
+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 *compilerContext) loadASTComments(lprogram *loader.Program) {
+func (c *Compiler) 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 *compilerContext) 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 *compilerContext) getGlobal(g *ssa.Global) llvm.Value {
+func (c *Compiler) 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 *compilerContext) getGlobal(g *ssa.Global) llvm.Value {
 			}
 		}

-		if c.Debug() && !info.extern {
+		if c.Debug() {
 			// 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 *compilerContext) getGlobal(g *ssa.Global) llvm.Value {
 }

 // getGlobalInfo returns some information about a specific global.
-func (c *compilerContext) getGlobalInfo(g *ssa.Global) globalInfo {
+func (c *Compiler) 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"
 )

-// 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])
+// 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])
 	var syscallResult llvm.Value
 	switch {
-	case b.GOARCH() == "amd64":
-		if b.GOOS() == "darwin" {
+	case c.GOARCH() == "amd64":
+		if c.GOOS() == "darwin" {
 			// Darwin adds this magic number to system call numbers:
 			//
 			// > Syscall classes for 64-bit system call entry.
@@ -28,13 +28,13 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 			// > 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 = b.CreateOr(num, llvm.ConstInt(b.uintptrType, 0x2000000, false), "")
+			num = c.builder.CreateOr(num, llvm.ConstInt(c.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{b.uintptrType}
+		argTypes := []llvm.Type{c.uintptrType}
 		// Constraints will look something like:
 		//   "={rax},0,{rdi},{rsi},{rdx},{r10},{r8},{r9},~{rcx},~{r11}"
 		constraints := "={rax},0"
@@ -50,21 +50,21 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 				"{r12}",
 				"{r13}",
 			}[i]
-			llvmValue := b.getValue(arg)
+			llvmValue := c.getValue(frame, arg)
 			args = append(args, llvmValue)
 			argTypes = append(argTypes, llvmValue.Type())
 		}
 		constraints += ",~{rcx},~{r11}"
-		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
+		fnType := llvm.FunctionType(c.uintptrType, argTypes, false)
 		target := llvm.InlineAsm(fnType, "syscall", constraints, true, false, llvm.InlineAsmDialectIntel)
-		syscallResult = b.CreateCall(target, args, "")
-	case b.GOARCH() == "386" && b.GOOS() == "linux":
+		syscallResult = c.builder.CreateCall(target, args, "")
+	case c.GOARCH() == "386" && c.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{b.uintptrType}
+		argTypes := []llvm.Type{c.uintptrType}
 		// Constraints will look something like:
 		//   "={eax},0,{ebx},{ecx},{edx},{esi},{edi},{ebp}"
 		constraints := "={eax},0"
@@ -77,14 +77,14 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 				"{edi}",
 				"{ebp}",
 			}[i]
-			llvmValue := b.getValue(arg)
+			llvmValue := c.getValue(frame, arg)
 			args = append(args, llvmValue)
 			argTypes = append(argTypes, llvmValue.Type())
 		}
-		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
+		fnType := llvm.FunctionType(c.uintptrType, argTypes, false)
 		target := llvm.InlineAsm(fnType, "int 0x80", constraints, true, false, llvm.InlineAsmDialectIntel)
-		syscallResult = b.CreateCall(target, args, "")
-	case b.GOARCH() == "arm" && b.GOOS() == "linux":
+		syscallResult = c.builder.CreateCall(target, args, "")
+	case c.GOARCH() == "arm" && c.GOOS() == "linux":
 		// Implement the EABI system call convention for Linux.
 		// Source: syscall(2) man page.
 		args := []llvm.Value{}
@@ -102,21 +102,21 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 				"{r5}",
 				"{r6}",
 			}[i]
-			llvmValue := b.getValue(arg)
+			llvmValue := c.getValue(frame, arg)
 			args = append(args, llvmValue)
 			argTypes = append(argTypes, llvmValue.Type())
 		}
 		args = append(args, num)
-		argTypes = append(argTypes, b.uintptrType)
+		argTypes = append(argTypes, c.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(b.uintptrType, argTypes, false)
+		fnType := llvm.FunctionType(c.uintptrType, argTypes, false)
 		target := llvm.InlineAsm(fnType, "svc #0", constraints, true, false, 0)
-		syscallResult = b.CreateCall(target, args, "")
-	case b.GOARCH() == "arm64" && b.GOOS() == "linux":
+		syscallResult = c.builder.CreateCall(target, args, "")
+	case c.GOARCH() == "arm64" && c.GOOS() == "linux":
 		// Source: syscall(2) man page.
 		args := []llvm.Value{}
 		argTypes := []llvm.Type{}
@@ -132,12 +132,12 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 				"{x4}",
 				"{x5}",
 			}[i]
-			llvmValue := b.getValue(arg)
+			llvmValue := c.getValue(frame, arg)
 			args = append(args, llvmValue)
 			argTypes = append(argTypes, llvmValue.Type())
 		}
 		args = append(args, num)
-		argTypes = append(argTypes, b.uintptrType)
+		argTypes = append(argTypes, c.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 (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 			constraints += ",~{x" + strconv.Itoa(i) + "}"
 		}
 		constraints += ",~{x16},~{x17}" // scratch registers
-		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
+		fnType := llvm.FunctionType(c.uintptrType, argTypes, false)
 		target := llvm.InlineAsm(fnType, "svc #0", constraints, true, false, 0)
-		syscallResult = b.CreateCall(target, args, "")
+		syscallResult = c.builder.CreateCall(target, args, "")
 	default:
-		return llvm.Value{}, b.makeError(call.Pos(), "unknown GOOS/GOARCH for syscall: "+b.GOOS()+"/"+b.GOARCH())
+		return llvm.Value{}, c.makeError(call.Pos(), "unknown GOOS/GOARCH for syscall: "+c.GOOS()+"/"+c.GOARCH())
 	}
-	switch b.GOOS() {
+	switch c.GOOS() {
 	case "linux", "freebsd":
 		// Return values: r0, r1 uintptr, err Errno
 		// Pseudocode:
@@ -160,15 +160,15 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		//         err = -syscallResult
 		//     }
 		//     return syscallResult, 0, err
-		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, "")
+		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, "")
 		return retval, nil
 	case "darwin":
 		// Return values: r0, r1 uintptr, err Errno
@@ -178,15 +178,15 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		//         err = syscallResult
 		//     }
 		//     return syscallResult, 0, err
-		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, "")
+		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, "")
 		return retval, nil
 	default:
-		return llvm.Value{}, b.makeError(call.Pos(), "unknown GOOS/GOARCH for syscall: "+b.GOOS()+"/"+b.GOARCH())
+		return llvm.Value{}, c.makeError(call.Pos(), "unknown GOOS/GOARCH for syscall: "+c.GOOS()+"/"+c.GOARCH())
 	}
 }
@@ -8,23 +8,19 @@ import (
 	"tinygo.org/x/go-llvm"
 )

-// 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, "")
+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, "")
 	val.SetVolatile(true)
 	return val, nil
 }

-// 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)
+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)
 	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/chromedp/cdproto v0.0.0-20200116234248-4da64dd111ac
-	github.com/chromedp/chromedp v0.5.3
+	github.com/creack/goselect v0.1.0 // indirect
 	github.com/google/shlex v0.0.0-20181106134648-c34317bd91bf
-	github.com/marcinbor85/gohex v0.0.0-20200531091804-343a4b548892
-	go.bug.st/serial v1.0.0
-	golang.org/x/tools v0.0.0-20200216192241-b320d3a0f5a2
-	tinygo.org/x/go-llvm v0.0.0-20200503225853-345b2947b59d
+	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
 )
@@ -1,50 +1,36 @@
 github.com/blakesmith/ar v0.0.0-20150311145944-8bd4349a67f2 h1:oMCHnXa6CCCafdPDbMh/lWRhRByN0VFLvv+g+ayx1SI=
 github.com/blakesmith/ar v0.0.0-20150311145944-8bd4349a67f2/go.mod h1:PkYb9DJNAwrSvRx5DYA+gUcOIgTGVMNkfSCbZM8cWpI=
-github.com/chromedp/cdproto v0.0.0-20200116234248-4da64dd111ac h1:T7V5BXqnYd55Hj/g5uhDYumg9Fp3rMTS6bykYtTIFX4=
-github.com/chromedp/cdproto v0.0.0-20200116234248-4da64dd111ac/go.mod h1:PfAWWKJqjlGFYJEidUM6aVIWPr0EpobeyVWEEmplX7g=
-github.com/chromedp/chromedp v0.5.3 h1:F9LafxmYpsQhWQBdCs+6Sret1zzeeFyHS5LkRF//Ffg=
-github.com/chromedp/chromedp v0.5.3/go.mod h1:YLdPtndaHQ4rCpSpBG+IPpy9JvX0VD+7aaLxYgYj28w=
-github.com/creack/goselect v0.1.1 h1:tiSSgKE1eJtxs1h/VgGQWuXUP0YS4CDIFMp6vaI1ls0=
-github.com/creack/goselect v0.1.1/go.mod h1:a/NhLweNvqIYMuxcMOuWY516Cimucms3DglDzQP3hKY=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee h1:s+21KNqlpePfkah2I+gwHF8xmJWRjooY+5248k6m4A0=
-github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo=
-github.com/gobwas/pool v0.2.0 h1:QEmUOlnSjWtnpRGHF3SauEiOsy82Cup83Vf2LcMlnc8=
-github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
-github.com/gobwas/ws v1.0.2 h1:CoAavW/wd/kulfZmSIBt6p24n4j7tHgNVCjsfHVNUbo=
-github.com/gobwas/ws v1.0.2/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM=
+github.com/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/google/shlex v0.0.0-20181106134648-c34317bd91bf h1:7+FW5aGwISbqUtkfmIpZJGRgNFg2ioYPvFaUxdqpDsg=
 github.com/google/shlex v0.0.0-20181106134648-c34317bd91bf/go.mod h1:RpwtwJQFrIEPstU94h88MWPXP2ektJZ8cZ0YntAmXiE=
-github.com/knq/sysutil v0.0.0-20191005231841-15668db23d08 h1:V0an7KRw92wmJysvFvtqtKMAPmvS5O0jtB0nYo6t+gs=
-github.com/knq/sysutil v0.0.0-20191005231841-15668db23d08/go.mod h1:dFWs1zEqDjFtnBXsd1vPOZaLsESovai349994nHx3e0=
-github.com/mailru/easyjson v0.7.0 h1:aizVhC/NAAcKWb+5QsU1iNOZb4Yws5UO2I+aIprQITM=
-github.com/mailru/easyjson v0.7.0/go.mod h1:KAzv3t3aY1NaHWoQz1+4F1ccyAH66Jk7yos7ldAVICs=
-github.com/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=
+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=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/tools v0.0.0-20200216192241-b320d3a0f5a2 h1:0sfSpGSa544Fwnbot3Oxq/U6SXqjty6Jy/3wRhVS7ig=
-golang.org/x/tools v0.0.0-20200216192241-b320d3a0f5a2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-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-20200503225853-345b2947b59d h1:hcX7vpB067GWM/EH4sGGOti0PMgIx+0bbZwUXctOIvE=
-tinygo.org/x/go-llvm v0.0.0-20200503225853-345b2947b59d/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
+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=
@@ -18,7 +18,6 @@ var Keys = []string{
 	"GOROOT",
 	"GOPATH",
 	"GOCACHE",
-	"CGO_ENABLED",
 	"TINYGOROOT",
 }

@@ -58,13 +57,6 @@ 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:
@@ -1,68 +0,0 @@
-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.15.0"
-
-// 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
-	}
-}
@@ -1,5 +0,0 @@
-# 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
@@ -1,4 +0,0 @@
-#!/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
@@ -13,46 +13,55 @@ import (

 // errUnreachable is returned when an unreachable instruction is executed. This
 // error should not be visible outside of the interp package.
-var errUnreachable = &Error{Err: errors.New("interp: unreachable executed")}
+var errUnreachable = errors.New("interp: unreachable executed")
+
+// 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 (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) *Error {
-	return e.errorAt(inst, errors.New("interp: unsupported instruction"))
-}
-
-// ErrorLine is one line in a traceback. The position may be missing.
-type ErrorLine struct {
-	Pos  token.Position
-	Inst llvm.Value
+func (e *evalPackage) unsupportedInstructionError(inst llvm.Value) *Unsupported {
+	return &Unsupported{
+		ImportPath: e.packagePath,
+		Inst:       inst,
+		Pos:        getPosition(inst),
+	}
 }

 // 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
-	Inst       llvm.Value
-	Pos        token.Position
-	Err        error
-	Traceback  []ErrorLine
+	Errs       []scanner.Error
 }

 // Error returns the string of the first error in the list of errors.
-func (e *Error) Error() string {
-	return e.Pos.String() + ": " + e.Err.Error()
+func (e Error) Error() string {
+	return e.Errs[0].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, err error) *Error {
-	pos := getPosition(inst)
-	return &Error{
+func (e *evalPackage) errorAt(inst llvm.Value, msg string) Error {
+	return Error{
 		ImportPath: e.packagePath,
-		Pos:        pos,
-		Err:        err,
-		Traceback:  []ErrorLine{{pos, inst}},
+		Errs:       []scanner.Error{errorAt(inst, msg)},
 	}
 }

@@ -4,7 +4,6 @@ package interp
 // functions.

 import (
-	"errors"
 	"strings"

 	"tinygo.org/x/go-llvm"
@@ -22,7 +21,7 @@ type frame struct {
 // 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) {
+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)
@@ -95,14 +94,10 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 			if !operand.IsConstant() || inst.IsVolatile() || (!operand.Underlying.IsAConstantExpr().IsNil() && operand.Underlying.Opcode() == llvm.BitCast) {
 				value = fr.builder.CreateLoad(operand.Value(), inst.Name())
 			} else {
-				var err error
-				value, err = operand.Load()
-				if err != nil {
-					return nil, nil, fr.errorAt(inst, err)
-				}
+				value = operand.Load()
 			}
 			if value.Type() != inst.Type() {
-				return nil, nil, fr.errorAt(inst, errors.New("interp: load: type does not match"))
+				return nil, nil, fr.errorAt(inst, "interp: load: type does not match")
 			}
 			fr.locals[inst] = fr.getValue(value)
 		case !inst.IsAStoreInst().IsNil():
@@ -111,10 +106,7 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 			if inst.IsVolatile() {
 				fr.builder.CreateStore(value.Value(), ptr.Value())
 			} else {
-				err := ptr.Store(value.Value())
-				if err != nil {
-					return nil, nil, fr.errorAt(inst, err)
-				}
+				ptr.Store(value.Value())
 			}
 		case !inst.IsAGetElementPtrInst().IsNil():
 			value := fr.getLocal(inst.Operand(0))
@@ -129,16 +121,13 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 					// Not a constant operation.
 					// This should be detected by the scanner, but isn't at the
 					// moment.
-					return nil, nil, fr.errorAt(inst, errors.New("todo: non-const gep"))
+					return nil, nil, fr.errorAt(inst, "todo: non-const gep")
 				}
 				indices[i] = uint32(operand.Value().ZExtValue())
 			}
-			result, err := value.GetElementPtr(indices)
-			if err != nil {
-				return nil, nil, fr.errorAt(inst, err)
-			}
+			result := value.GetElementPtr(indices)
 			if result.Type() != inst.Type() {
-				return nil, nil, fr.errorAt(inst, errors.New("interp: gep: type does not match"))
+				return nil, nil, fr.errorAt(inst, "interp: gep: type does not match")
 			}
 			fr.locals[inst] = result

@@ -193,7 +182,7 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 					}
 				}
 				// It is not possible in Go to bitcast a map value to a pointer.
-				return nil, nil, fr.errorAt(inst, errors.New("unimplemented: bitcast of map"))
+				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(), "")}
@@ -275,11 +264,7 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 				if elementCount == 1 {
 					fr.locals[resultInst] = result
 				} else {
-					result, err := result.GetElementPtr([]uint32{0, 0})
-					if err != nil {
-						return nil, nil, fr.errorAt(inst, err)
-					}
-					fr.locals[resultInst] = result
+					fr.locals[resultInst] = result.GetElementPtr([]uint32{0, 0})
 				}
 			case callee.Name() == "runtime.hashmapMake":
 				// create a map
@@ -315,10 +300,7 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 				}
 				// "key" is a Go string value, which in the TinyGo calling convention is split up
 				// into separate pointer and length parameters.
-				err := m.PutString(keyBuf, keyLen, valPtr)
-				if err != nil {
-					return nil, nil, fr.errorAt(inst, err)
-				}
+				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)
@@ -339,24 +321,15 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 					fr.builder.CreateCall(callee, llvmParams, "")
 					continue
 				}
-				err := m.PutBinary(keyBuf, valPtr)
-				if err != nil {
-					return nil, nil, fr.errorAt(inst, err)
-				}
+				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, err := getStringBytes(buf1Ptr, buf1Len.Value())
-				if err != nil {
-					return nil, nil, fr.errorAt(inst, err)
-				}
-				buf2, err := getStringBytes(buf2Ptr, buf2Len.Value())
-				if err != nil {
-					return nil, nil, fr.errorAt(inst, err)
-				}
+				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 {
@@ -392,64 +365,38 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 					// a bitcast of the original array instead of the GEP,
 					// which breaks our assumptions.
 					// Re-add this GEP, in the hope that it it is then of the correct type...
-					dstArrayValue, err := dstArray.GetElementPtr([]uint32{0, 0})
-					if err != nil {
-						return nil, nil, fr.errorAt(inst, err)
-					}
-					dstArray = dstArrayValue.(*LocalValue)
-					srcArrayValue, err := srcArray.GetElementPtr([]uint32{0, 0})
-					if err != nil {
-						return nil, nil, fr.errorAt(inst, err)
-					}
-					srcArray = srcArrayValue.(*LocalValue)
+					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, errors.New("interp: slice dst element size does not match pointer type"))
+					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, errors.New("interp: slice src element size does not match pointer type"))
+					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, errors.New("interp: slice element types don't match"))
+					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, errors.New("interp: trying to copy a slice with negative length?"))
+					return nil, nil, fr.errorAt(inst, "interp: trying to copy a slice with negative length?")
 				}
 				for i := int64(0); i < length; i++ {
 					// *dst = *src
-					val, err := srcArray.Load()
-					if err != nil {
-						return nil, nil, fr.errorAt(inst, err)
-					}
-					err = dstArray.Store(val)
-					if err != nil {
-						return nil, nil, fr.errorAt(inst, err)
-					}
+					dstArray.Store(srcArray.Load())
 					// dst++
-					dstArrayValue, err := dstArray.GetElementPtr([]uint32{1})
-					if err != nil {
-						return nil, nil, fr.errorAt(inst, err)
-					}
-					dstArray = dstArrayValue.(*LocalValue)
+					dstArray = dstArray.GetElementPtr([]uint32{1}).(*LocalValue)
 					// src++
-					srcArrayValue, err := srcArray.GetElementPtr([]uint32{1})
-					if err != nil {
-						return nil, nil, fr.errorAt(inst, err)
-					}
-					srcArray = srcArrayValue.(*LocalValue)
+					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, err := getStringBytes(bufPtr, bufLen.Value())
-				if err != nil {
-					return nil, nil, fr.errorAt(inst, err)
-				}
+				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)
@@ -469,35 +416,20 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 				ret = llvm.ConstInsertValue(ret, retLen, []uint32{1}) // len
 				ret = llvm.ConstInsertValue(ret, retLen, []uint32{2}) // cap
 				fr.locals[inst] = &LocalValue{fr.Eval, ret}
-			case callee.Name() == "runtime.typeAssert":
-				actualTypeInt := fr.getLocal(inst.Operand(0)).(*LocalValue).Underlying
-				assertedType := fr.getLocal(inst.Operand(1)).(*LocalValue).Underlying
-				if actualTypeInt.IsAConstantExpr().IsNil() || actualTypeInt.Opcode() != llvm.PtrToInt {
-					return nil, nil, fr.errorAt(inst, errors.New("interp: expected typecode in runtime.typeAssert to be a ptrtoint"))
-				}
-				actualType := actualTypeInt.Operand(0)
-				if actualType.IsAConstant().IsNil() || assertedType.IsAConstant().IsNil() {
-					return nil, nil, fr.errorAt(inst, errors.New("interp: unimplemented: type assert with non-constant interface value"))
-				}
-				assertOk := uint64(0)
-				if llvm.ConstExtractValue(actualType.Initializer(), []uint32{0}) == assertedType {
-					assertOk = 1
-				}
-				fr.locals[inst] = &LocalValue{fr.Eval, llvm.ConstInt(fr.Mod.Context().Int1Type(), assertOk, false)}
 			case callee.Name() == "runtime.interfaceImplements":
 				typecode := fr.getLocal(inst.Operand(0)).(*LocalValue).Underlying
 				interfaceMethodSet := fr.getLocal(inst.Operand(1)).(*LocalValue).Underlying
 				if typecode.IsAConstantExpr().IsNil() || typecode.Opcode() != llvm.PtrToInt {
-					return nil, nil, fr.errorAt(inst, errors.New("interp: expected typecode to be a ptrtoint"))
+					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, errors.New("interp: expected method set in runtime.interfaceImplements to be a constant gep"))
+					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, errors.New("interp: expected method set to be a constant gep"))
+					return nil, nil, fr.errorAt(inst, "interp: expected method set to be a constant gep")
 				}
 				methodSet = methodSet.Operand(0).Initializer()

@@ -597,11 +529,6 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 					//     interpret anyway and hope for the best.
 					ret, err = fr.function(callee, params, indent+"    ")
 					if err != nil {
-						// Record this function call in the backtrace.
-						err.Traceback = append(err.Traceback, ErrorLine{
-							Pos:  getPosition(inst),
-							Inst: inst,
-						})
 						return nil, nil, err
 					}
 				}
@@ -620,7 +547,7 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 				fr.locals[inst] = fr.getValue(newValue)
 			} else {
 				if len(indices) != 1 {
-					return nil, nil, fr.errorAt(inst, errors.New("interp: cannot handle extractvalue with not exactly 1 index"))
+					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())}
 			}
@@ -633,22 +560,10 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 				fr.locals[inst] = &LocalValue{fr.Eval, newValue}
 			} else {
 				if len(indices) != 1 {
-					return nil, nil, fr.errorAt(inst, errors.New("interp: cannot handle insertvalue with not exactly 1 index"))
+					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.IsASelectInst().IsNil():
-			// var result T
-			// if cond {
-			//   result = x
-			// } else {
-			//   result = y
-			// }
-			// return result
-			cond := fr.getLocal(inst.Operand(0)).(*LocalValue).Underlying
-			x := fr.getLocal(inst.Operand(1)).(*LocalValue).Underlying
-			y := fr.getLocal(inst.Operand(2)).(*LocalValue).Underlying
-			fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateSelect(cond, x, y, "")}

 		case !inst.IsAReturnInst().IsNil() && inst.OperandsCount() == 0:
 			return nil, nil, nil // ret void
@@ -658,17 +573,17 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 			// conditional branch (if/then/else)
 			cond := fr.getLocal(inst.Operand(0)).Value()
 			if cond.Type() != fr.Mod.Context().Int1Type() {
-				return nil, nil, fr.errorAt(inst, errors.New("expected an i1 in a branch instruction"))
+				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, errors.New("interp: branch on a non-constant"))
+				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, errors.New("interp: branch on a non-const-propagated constant expression"))
+				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
@@ -676,7 +591,7 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 			case llvm.ConstInt(fr.Mod.Context().Int1Type(), 1, false): // true
 				return nil, []llvm.Value{elseBB}, nil // else
 			default:
-				return nil, nil, fr.errorAt(inst, errors.New("branch was not true or false"))
+				return nil, nil, fr.errorAt(inst, "branch was not true or false")
 			}
 		case !inst.IsABranchInst().IsNil() && inst.OperandsCount() == 1:
 			// unconditional branch (goto)
@@ -97,7 +97,7 @@ func Run(mod llvm.Module, debug bool) error {
 // 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) {
+func (e *evalPackage) function(fn llvm.Value, params []Value, indent string) (Value, error) {
 	fr := frame{
 		evalPackage: e,
 		fn:          fn,
@@ -15,7 +15,6 @@ 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) {
@@ -1,7 +1,6 @@
 package interp

 import (
-	"errors"
 	"strings"

 	"tinygo.org/x/go-llvm"
@@ -41,7 +40,7 @@ type sideEffectResult 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) {
+func (e *evalPackage) hasSideEffects(fn llvm.Value) (*sideEffectResult, error) {
 	name := fn.Name()
 	switch {
 	case name == "runtime.alloc":
@@ -52,8 +51,6 @@ func (e *evalPackage) hasSideEffects(fn llvm.Value) (*sideEffectResult, *Error)
 		return &sideEffectResult{severity: sideEffectNone}, nil
 	case name == "runtime._panic":
 		return &sideEffectResult{severity: sideEffectLimited}, nil
-	case name == "runtime.typeAssert":
-		return &sideEffectResult{severity: sideEffectNone}, nil
 	case name == "runtime.interfaceImplements":
 		return &sideEffectResult{severity: sideEffectNone}, nil
 	case name == "runtime.sliceCopy":
@@ -62,10 +59,6 @@ func (e *evalPackage) hasSideEffects(fn llvm.Value) (*sideEffectResult, *Error)
 		return &sideEffectResult{severity: sideEffectNone}, nil
 	case name == "llvm.dbg.value":
 		return &sideEffectResult{severity: sideEffectNone}, nil
-	case name == "(*sync/atomic.Value).Load" || name == "(*sync/atomic.Value).Store":
-		// These functions do some unsafe pointer loading/storing but are
-		// otherwise safe.
-		return &sideEffectResult{severity: sideEffectLimited}, nil
 	case strings.HasPrefix(name, "llvm.lifetime."):
 		return &sideEffectResult{severity: sideEffectNone}, nil
 	}
@@ -104,7 +97,7 @@ func (e *evalPackage) hasSideEffects(fn llvm.Value) (*sideEffectResult, *Error)
 			switch inst.InstructionOpcode() {
 			case llvm.IndirectBr, llvm.Invoke:
 				// Not emitted by the compiler.
-				return nil, e.errorAt(inst, errors.New("unknown instructions"))
+				return nil, e.errorAt(inst, "unknown instructions")
 			case llvm.Call:
 				child := inst.CalledValue()
 				if !child.IsAInlineAsm().IsNil() {
@@ -125,14 +118,6 @@ func (e *evalPackage) hasSideEffects(fn llvm.Value) (*sideEffectResult, *Error)
 				if child.IsDeclaration() {
 					// External function call. Assume only limited side effects
 					// (no affected globals, etc.).
-					switch child.Name() {
-					case "runtime.alloc":
-						continue
-					case "runtime.typeAssert":
-						continue // implemented in interp
-					case "runtime.interfaceImplements":
-						continue // implemented in interp
-					}
 					if e.hasLocalSideEffects(dirtyLocals, inst) {
 						result.updateSeverity(sideEffectLimited)
 					}
@@ -23,8 +23,6 @@ var scanTestTable = []struct {
 	{"callFunctionPointer", sideEffectAll, []string{"functionPointer"}},
 	{"getDirtyPointer", sideEffectLimited, nil},
 	{"storeToPointer", sideEffectLimited, nil},
-	{"callTypeAssert", sideEffectNone, nil},
-	{"callInterfaceImplements", sideEffectNone, nil},
 }

 func TestScan(t *testing.T) {
@@ -1,28 +0,0 @@
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64--linux"
-
-%runtime.typecodeID = type { %runtime.typecodeID*, i64 }
-%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
-}
@@ -1,9 +0,0 @@
-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
-}
@@ -1,11 +1,6 @@
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64--linux"

-%runtime.typecodeID = type { %runtime.typecodeID*, i64 }
-
-declare i1 @runtime.typeAssert(i64, %runtime.typecodeID*, i8*, i8*)
-declare i1 @runtime.interfaceImplements(i64, i8**)
-
 define i64 @returnsConst() {
  ret i64 0
 }
@@ -64,15 +59,3 @@ define i64 @callFunctionPointer() {
  %result = call i64 %fp()
  ret i64 %result
 }
-
-define i1 @callTypeAssert() {
-  ; Note: parameters are not realistic.
-  %ok = call i1 @runtime.typeAssert(i64 0, %runtime.typecodeID* null, i8* undef, i8* null)
-  ret i1 %ok
-}
-
-define i1 @callInterfaceImplements() {
-  ; Note: parameters are not realistic.
-  %ok = call i1 @runtime.interfaceImplements(i64 0, i8** null)
-  ret i1 %ok
-}
@@ -1,8 +1,6 @@
 package interp

 import (
-	"errors"
-
 	"tinygo.org/x/go-llvm"
 )

@@ -20,23 +18,16 @@ func getUses(value llvm.Value) []llvm.Value {

 // getStringBytes loads the byte slice of a Go string represented as a
 // {ptr, len} pair.
-func getStringBytes(strPtr Value, strLen llvm.Value) ([]byte, error) {
+func getStringBytes(strPtr Value, strLen llvm.Value) []byte {
 	if !strLen.IsConstant() {
-		return nil, errors.New("getStringBytes with a non-constant length")
+		panic("getStringBytes with a non-constant length")
 	}
 	buf := make([]byte, strLen.ZExtValue())
 	for i := range buf {
-		gep, err := strPtr.GetElementPtr([]uint32{uint32(i)})
-		if err != nil {
-			return nil, err
-		}
-		c, err := gep.Load()
-		if err != nil {
-			return nil, err
-		}
+		c := strPtr.GetElementPtr([]uint32{uint32(i)}).Load()
 		buf[i] = byte(c.ZExtValue())
 	}
-	return buf, nil
+	return buf
 }

 // getLLVMIndices converts an []uint32 into an []llvm.Value, for use in
@@ -3,7 +3,6 @@ package interp
 // This file provides a litte bit of abstraction around LLVM values.

 import (
-	"errors"
 	"strconv"

 	"tinygo.org/x/go-llvm"
@@ -12,13 +11,13 @@ import (
 // A Value is a LLVM value with some extra methods attached for easier
 // interpretation.
 type Value interface {
-	Value() llvm.Value                     // returns a LLVM value
-	Type() llvm.Type                       // equal to Value().Type()
-	IsConstant() bool                      // returns true if this value is a constant value
-	Load() (llvm.Value, error)             // dereference a pointer
-	Store(llvm.Value) error                // store to a pointer
-	GetElementPtr([]uint32) (Value, error) // returns an interior pointer
-	String() string                        // string representation, for debugging
+	Value() llvm.Value            // returns a LLVM value
+	Type() llvm.Type              // equal to Value().Type()
+	IsConstant() bool             // returns true if this value is a constant value
+	Load() llvm.Value             // dereference a pointer
+	Store(llvm.Value)             // store to a pointer
+	GetElementPtr([]uint32) Value // returns an interior pointer
+	String() string               // string representation, for debugging
 }

 // A type that simply wraps a LLVM constant value.
@@ -44,32 +43,29 @@ func (v *LocalValue) IsConstant() bool {
 }

 // Load loads a constant value if this is a constant pointer.
-func (v *LocalValue) Load() (llvm.Value, error) {
+func (v *LocalValue) Load() llvm.Value {
 	if !v.Underlying.IsAGlobalVariable().IsNil() {
-		return v.Underlying.Initializer(), nil
+		return v.Underlying.Initializer()
 	}
 	switch v.Underlying.Opcode() {
 	case llvm.GetElementPtr:
 		indices := v.getConstGEPIndices()
 		if indices[0] != 0 {
-			return llvm.Value{}, errors.New("invalid GEP")
+			panic("invalid GEP")
 		}
 		global := v.Eval.getValue(v.Underlying.Operand(0))
-		agg, err := global.Load()
-		if err != nil {
-			return llvm.Value{}, err
-		}
-		return llvm.ConstExtractValue(agg, indices[1:]), nil
+		agg := global.Load()
+		return llvm.ConstExtractValue(agg, indices[1:])
 	case llvm.BitCast:
-		return llvm.Value{}, errors.New("interp: load from a bitcast")
+		panic("interp: load from a bitcast")
 	default:
-		return llvm.Value{}, errors.New("interp: load from a constant")
+		panic("interp: load from a constant")
 	}
 }

 // Store stores to the underlying value if the value type is a pointer type,
-// otherwise it returns an error.
-func (v *LocalValue) Store(value llvm.Value) error {
+// otherwise it panics.
+func (v *LocalValue) Store(value llvm.Value) {
 	if !v.Underlying.IsAGlobalVariable().IsNil() {
 		if !value.IsConstant() {
 			v.MarkDirty()
@@ -77,47 +73,45 @@ func (v *LocalValue) Store(value llvm.Value) error {
 		} else {
 			v.Underlying.SetInitializer(value)
 		}
-		return nil
+		return
 	}
 	if !value.IsConstant() {
 		v.MarkDirty()
 		v.Eval.builder.CreateStore(value, v.Underlying)
-		return nil
+		return
 	}
 	switch v.Underlying.Opcode() {
 	case llvm.GetElementPtr:
 		indices := v.getConstGEPIndices()
 		if indices[0] != 0 {
-			return errors.New("invalid GEP")
+			panic("invalid GEP")
 		}
 		global := &LocalValue{v.Eval, v.Underlying.Operand(0)}
-		agg, err := global.Load()
-		if err != nil {
-			return err
-		}
+		agg := global.Load()
 		agg = llvm.ConstInsertValue(agg, value, indices[1:])
-		return global.Store(agg)
+		global.Store(agg)
+		return
 	default:
-		return errors.New("interp: store on a constant")
+		panic("interp: store on a constant")
 	}
 }

 // GetElementPtr returns a GEP when the underlying value is of pointer type.
-func (v *LocalValue) GetElementPtr(indices []uint32) (Value, error) {
+func (v *LocalValue) GetElementPtr(indices []uint32) Value {
 	if !v.Underlying.IsAGlobalVariable().IsNil() {
 		int32Type := v.Underlying.Type().Context().Int32Type()
 		gep := llvm.ConstGEP(v.Underlying, getLLVMIndices(int32Type, indices))
-		return &LocalValue{v.Eval, gep}, nil
+		return &LocalValue{v.Eval, gep}
 	}
 	if !v.Underlying.IsAConstantExpr().IsNil() {
 		switch v.Underlying.Opcode() {
 		case llvm.GetElementPtr, llvm.IntToPtr, llvm.BitCast:
 			int32Type := v.Underlying.Type().Context().Int32Type()
 			llvmIndices := getLLVMIndices(int32Type, indices)
-			return &LocalValue{v.Eval, llvm.ConstGEP(v.Underlying, llvmIndices)}, nil
+			return &LocalValue{v.Eval, llvm.ConstGEP(v.Underlying, llvmIndices)}
 		}
 	}
-	return nil, errors.New("interp: unknown GEP")
+	panic("interp: unknown GEP")
 }

 // stripPointerCasts removes all const bitcasts from pointer values, if there
@@ -230,11 +224,7 @@ func (v *MapValue) Value() llvm.Value {
 			keyPtr := llvm.ConstExtractValue(llvmKey, []uint32{0})
 			keyLen := llvm.ConstExtractValue(llvmKey, []uint32{1})
 			keyPtrVal := v.Eval.getValue(keyPtr)
-			var err error
-			keyBuf, err = getStringBytes(keyPtrVal, keyLen)
-			if err != nil {
-				panic(err) // TODO
-			}
+			keyBuf = getStringBytes(keyPtrVal, keyLen)
 		} else if key.Type().TypeKind() == llvm.IntegerTypeKind {
 			keyBuf = make([]byte, v.Eval.TargetData.TypeAllocSize(key.Type()))
 			n := key.Value().ZExtValue()
@@ -308,45 +298,40 @@ func (v *MapValue) IsConstant() bool {
 }

 // Load panics: maps are of reference type so cannot be dereferenced.
-func (v *MapValue) Load() (llvm.Value, error) {
+func (v *MapValue) Load() llvm.Value {
 	panic("interp: load from a map")
 }

-// Store returns an error: maps are of reference type so cannot be stored to.
-func (v *MapValue) Store(value llvm.Value) error {
-	// This must be a bug, but it might be helpful to indicate the location
-	// anyway.
-	return errors.New("interp: store on a map")
+// Store panics: maps are of reference type so cannot be stored to.
+func (v *MapValue) Store(value llvm.Value) {
+	panic("interp: store on a map")
 }

 // GetElementPtr panics: maps are of reference type so their (interior)
 // addresses cannot be calculated.
-func (v *MapValue) GetElementPtr(indices []uint32) (Value, error) {
-	return nil, errors.New("interp: GEP on a map")
+func (v *MapValue) GetElementPtr(indices []uint32) Value {
+	panic("interp: GEP on a map")
 }

 // PutString does a map assign operation, assuming that the map is of type
 // map[string]T.
-func (v *MapValue) PutString(keyBuf, keyLen, valPtr *LocalValue) error {
+func (v *MapValue) PutString(keyBuf, keyLen, valPtr *LocalValue) {
 	if !v.Underlying.IsNil() {
-		return errors.New("map already created")
+		panic("map already created")
 	}

 	if valPtr.Underlying.Opcode() == llvm.BitCast {
 		valPtr = &LocalValue{v.Eval, valPtr.Underlying.Operand(0)}
 	}
-	value, err := valPtr.Load()
-	if err != nil {
-		return err
-	}
+	value := valPtr.Load()
 	if v.ValueType.IsNil() {
 		v.ValueType = value.Type()
 		if int(v.Eval.TargetData.TypeAllocSize(v.ValueType)) != v.ValueSize {
-			return errors.New("interp: map store value type has the wrong size")
+			panic("interp: map store value type has the wrong size")
 		}
 	} else {
 		if value.Type() != v.ValueType {
-			return errors.New("interp: map store value type is inconsistent")
+			panic("interp: map store value type is inconsistent")
 		}
 	}

@@ -359,31 +344,26 @@ func (v *MapValue) PutString(keyBuf, keyLen, valPtr *LocalValue) error {
 	// TODO: avoid duplicate keys
 	v.Keys = append(v.Keys, &LocalValue{v.Eval, key})
 	v.Values = append(v.Values, &LocalValue{v.Eval, value})
-
-	return nil
 }

 // PutBinary does a map assign operation.
-func (v *MapValue) PutBinary(keyPtr, valPtr *LocalValue) error {
+func (v *MapValue) PutBinary(keyPtr, valPtr *LocalValue) {
 	if !v.Underlying.IsNil() {
-		return errors.New("map already created")
+		panic("map already created")
 	}

 	if valPtr.Underlying.Opcode() == llvm.BitCast {
 		valPtr = &LocalValue{v.Eval, valPtr.Underlying.Operand(0)}
 	}
-	value, err := valPtr.Load()
-	if err != nil {
-		return err
-	}
+	value := valPtr.Load()
 	if v.ValueType.IsNil() {
 		v.ValueType = value.Type()
 		if int(v.Eval.TargetData.TypeAllocSize(v.ValueType)) != v.ValueSize {
-			return errors.New("interp: map store value type has the wrong size")
+			panic("interp: map store value type has the wrong size")
 		}
 	} else {
 		if value.Type() != v.ValueType {
-			return errors.New("interp: map store value type is inconsistent")
+			panic("interp: map store value type is inconsistent")
 		}
 	}

@@ -394,26 +374,21 @@ func (v *MapValue) PutBinary(keyPtr, valPtr *LocalValue) error {
 			keyPtr = &LocalValue{v.Eval, keyPtr.Underlying.Operand(0)}
 		}
 	}
-	key, err := keyPtr.Load()
-	if err != nil {
-		return err
-	}
+	key := keyPtr.Load()
 	if v.KeyType.IsNil() {
 		v.KeyType = key.Type()
 		if int(v.Eval.TargetData.TypeAllocSize(v.KeyType)) != v.KeySize {
-			return errors.New("interp: map store key type has the wrong size")
+			panic("interp: map store key type has the wrong size")
 		}
 	} else {
 		if key.Type() != v.KeyType {
-			return errors.New("interp: map store key type is inconsistent")
+			panic("interp: map store key type is inconsistent")
 		}
 	}

 	// TODO: avoid duplicate keys
 	v.Keys = append(v.Keys, &LocalValue{v.Eval, key})
 	v.Values = append(v.Values, &LocalValue{v.Eval, value})
-
-	return nil
 }

 // Get FNV-1a hash of this string.
@@ -63,14 +63,73 @@ const (
 )

 // Create and initialize a new *Program from a *ssa.Program.
-func NewProgram(lprogram *loader.Program) *Program {
+func NewProgram(lprogram *loader.Program, mainPath string) *Program {
 	program := lprogram.LoadSSA()
 	program.Build()

-	mainPkg := program.ImportedPackage(lprogram.MainPkg().ImportPath)
+	// Find the main package, which is a bit difficult when running a .go file
+	// directly.
+	mainPkg := program.ImportedPackage(mainPath)
+	if mainPkg == nil {
+		for _, pkgInfo := range program.AllPackages() {
+			if pkgInfo.Pkg.Name() == "main" {
+				if mainPkg != nil {
+					panic("more than one main package found")
+				}
+				mainPkg = pkgInfo
+			}
+		}
+	}
 	if mainPkg == nil {
 		panic("could not find main package")
 	}
+
+	// Make a list of packages in import order.
+	packageList := []*ssa.Package{}
+	packageSet := map[string]struct{}{}
+	worklist := []string{"runtime", mainPath}
+	for len(worklist) != 0 {
+		pkgPath := worklist[0]
+		var pkg *ssa.Package
+		if pkgPath == mainPath {
+			pkg = mainPkg // necessary for compiling individual .go files
+		} else {
+			pkg = program.ImportedPackage(pkgPath)
+		}
+		if pkg == nil {
+			// Non-SSA package (e.g. cgo).
+			packageSet[pkgPath] = struct{}{}
+			worklist = worklist[1:]
+			continue
+		}
+		if _, ok := packageSet[pkgPath]; ok {
+			// Package already in the final package list.
+			worklist = worklist[1:]
+			continue
+		}
+
+		unsatisfiedImports := make([]string, 0)
+		imports := pkg.Pkg.Imports()
+		for _, pkg := range imports {
+			if _, ok := packageSet[pkg.Path()]; ok {
+				continue
+			}
+			unsatisfiedImports = append(unsatisfiedImports, pkg.Path())
+		}
+		if len(unsatisfiedImports) == 0 {
+			// All dependencies of this package are satisfied, so add this
+			// package to the list.
+			packageList = append(packageList, pkg)
+			packageSet[pkgPath] = struct{}{}
+			worklist = worklist[1:]
+		} else {
+			// Prepend all dependencies to the worklist and reconsider this
+			// package (by not removing it from the worklist). At that point, it
+			// must be possible to add it to packageList.
+			worklist = append(unsatisfiedImports, worklist...)
+		}
+	}
+
 	p := &Program{
 		Program:       program,
 		LoaderProgram: lprogram,
@@ -78,8 +137,8 @@ func NewProgram(lprogram *loader.Program) *Program {
 		functionMap:   make(map[*ssa.Function]*Function),
 	}

-	for _, pkg := range lprogram.Sorted() {
-		p.AddPackage(program.ImportedPackage(pkg.ImportPath))
+	for _, pkg := range packageList {
+		p.AddPackage(pkg)
 	}

 	return p
@@ -1,7 +1,6 @@
 package ir

 import (
-	"errors"
 	"go/types"

 	"golang.org/x/tools/go/ssa"
@@ -59,7 +58,7 @@ func signature(sig *types.Signature) string {

 // Simple pass that removes dead code. This pass makes later analysis passes
 // more useful.
-func (p *Program) SimpleDCE() error {
+func (p *Program) SimpleDCE() {
 	// Unmark all functions.
 	for _, f := range p.Functions {
 		f.flag = false
@@ -67,21 +66,13 @@ func (p *Program) SimpleDCE() error {

 	// Initial set of live functions. Include main.main, *.init and runtime.*
 	// functions.
-	main, ok := p.mainPkg.Members["main"].(*ssa.Function)
-	if !ok {
-		if p.mainPkg.Members["main"] == nil {
-			return errors.New("function main is undeclared in the main package")
-		} else {
-			return errors.New("cannot declare main - must be func")
-		}
-	}
+	main := p.mainPkg.Members["main"].(*ssa.Function)
 	runtimePkg := p.Program.ImportedPackage("runtime")
 	mathPkg := p.Program.ImportedPackage("math")
-	taskPkg := p.Program.ImportedPackage("internal/task")
 	p.GetFunction(main).flag = true
 	worklist := []*ssa.Function{main}
 	for _, f := range p.Functions {
-		if f.exported || f.Synthetic == "package initializer" || f.Pkg == runtimePkg || f.Pkg == taskPkg || (f.Pkg == mathPkg && f.Pkg != nil) {
+		if f.exported || f.Synthetic == "package initializer" || f.Pkg == runtimePkg || (f.Pkg == mathPkg && f.Pkg != nil) {
 			if f.flag {
 				continue
 			}
@@ -144,6 +135,4 @@ func (p *Program) SimpleDCE() error {
 		}
 	}
 	p.Functions = livefunctions
-
-	return nil
 }
@@ -1,6 +1,9 @@
 package loader

-import "go/scanner"
+import (
+	"go/token"
+	"strings"
+)

 // Errors contains a list of parser errors or a list of typechecker errors for
 // the given package.
@@ -13,13 +16,24 @@ func (e Errors) Error() string {
 	return "could not compile: " + e.Errs[0].Error()
 }

-// Error is a regular error but with an added import stack. This is especially
-// useful for debugging import cycle errors.
-type Error struct {
-	ImportStack []string
-	Err         scanner.Error
+// ImportCycleErrors is returned when encountering an import cycle. The list of
+// packages is a list from the root package to the leaf package that imports one
+// of the packages in the list.
+type ImportCycleError struct {
+	Packages        []string
+	ImportPositions []token.Position
 }

-func (e Error) Error() string {
-	return e.Err.Error()
+func (e *ImportCycleError) Error() string {
+	var msg strings.Builder
+	msg.WriteString("import cycle:\n\t")
+	msg.WriteString(strings.Join(e.Packages, "\n\t"))
+	msg.WriteString("\n at ")
+	for i, pos := range e.ImportPositions {
+		if i > 0 {
+			msg.WriteString(", ")
+		}
+		msg.WriteString(pos.String())
+	}
+	return msg.String()
 }
@@ -1,281 +0,0 @@
-package loader
-
-// This file constructs a new temporary GOROOT directory by merging both the
-// standard Go GOROOT and the GOROOT from TinyGo using symlinks.
-
-import (
-	"crypto/sha512"
-	"encoding/hex"
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"os/exec"
-	"path"
-	"path/filepath"
-	"runtime"
-	"sync"
-
-	"github.com/tinygo-org/tinygo/compileopts"
-	"github.com/tinygo-org/tinygo/goenv"
-)
-
-var gorootCreateMutex sync.Mutex
-
-// GetCachedGoroot creates a new GOROOT by merging both the standard GOROOT and
-// the GOROOT from TinyGo using lots of symbolic links.
-func GetCachedGoroot(config *compileopts.Config) (string, error) {
-	goroot := goenv.Get("GOROOT")
-	if goroot == "" {
-		return "", errors.New("could not determine GOROOT")
-	}
-	tinygoroot := goenv.Get("TINYGOROOT")
-	if tinygoroot == "" {
-		return "", errors.New("could not determine TINYGOROOT")
-	}
-
-	// Determine the location of the cached GOROOT.
-	version, err := goenv.GorootVersionString(goroot)
-	if err != nil {
-		return "", err
-	}
-	// This hash is really a cache key, that contains (hopefully) enough
-	// information to make collisions unlikely during development.
-	// By including the Go version and TinyGo version, cache collisions should
-	// not happen outside of development.
-	hash := sha512.New512_256()
-	fmt.Fprintln(hash, goroot)
-	fmt.Fprintln(hash, version)
-	fmt.Fprintln(hash, goenv.Version)
-	fmt.Fprintln(hash, tinygoroot)
-	gorootsHash := hash.Sum(nil)
-	gorootsHashHex := hex.EncodeToString(gorootsHash[:])
-	cachedgorootName := "goroot-" + version + "-" + gorootsHashHex
-	cachedgoroot := filepath.Join(goenv.Get("GOCACHE"), cachedgorootName)
-	if needsSyscallPackage(config.BuildTags()) {
-		cachedgoroot += "-syscall"
-	}
-
-	// Do not try to create the cached GOROOT in parallel, that's only a waste
-	// of I/O bandwidth and thus speed. Instead, use a mutex to make sure only
-	// one goroutine does it at a time.
-	// This is not a way to ensure atomicity (a different TinyGo invocation
-	// could be creating the same directory), but instead a way to avoid
-	// creating it many times in parallel when running tests in parallel.
-	gorootCreateMutex.Lock()
-	defer gorootCreateMutex.Unlock()
-
-	if _, err := os.Stat(cachedgoroot); err == nil {
-		return cachedgoroot, nil
-	}
-	err = os.MkdirAll(goenv.Get("GOCACHE"), 0777)
-	if err != nil {
-		return "", err
-	}
-	tmpgoroot, err := ioutil.TempDir(goenv.Get("GOCACHE"), cachedgorootName+".tmp")
-	if err != nil {
-		return "", err
-	}
-
-	// Remove the temporary directory if it wasn't moved to the right place
-	// (for example, when there was an error).
-	defer os.RemoveAll(tmpgoroot)
-
-	for _, name := range []string{"bin", "lib", "pkg"} {
-		err = symlink(filepath.Join(goroot, name), filepath.Join(tmpgoroot, name))
-		if err != nil {
-			return "", err
-		}
-	}
-	err = mergeDirectory(goroot, tinygoroot, tmpgoroot, "", pathsToOverride(needsSyscallPackage(config.BuildTags())))
-	if err != nil {
-		return "", err
-	}
-	err = os.Rename(tmpgoroot, cachedgoroot)
-	if err != nil {
-		if os.IsExist(err) {
-			// Another invocation of TinyGo also seems to have created a GOROOT.
-			// Use that one instead. Our new GOROOT will be automatically
-			// deleted by the defer above.
-			return cachedgoroot, nil
-		}
-		if runtime.GOOS == "windows" && os.IsPermission(err) {
-			// On Windows, a rename with a destination directory that already
-			// exists does not result in an IsExist error, but rather in an
-			// access denied error. To be sure, check for this case by checking
-			// whether the target directory exists.
-			if _, err := os.Stat(cachedgoroot); err == nil {
-				return cachedgoroot, nil
-			}
-		}
-		return "", err
-	}
-	return cachedgoroot, nil
-}
-
-// mergeDirectory merges two roots recursively. The tmpgoroot is the directory
-// that will be created by this call by either symlinking the directory from
-// goroot or tinygoroot, or by creating the directory and merging the contents.
-func mergeDirectory(goroot, tinygoroot, tmpgoroot, importPath string, overrides map[string]bool) error {
-	if mergeSubdirs, ok := overrides[importPath+"/"]; ok {
-		if !mergeSubdirs {
-			// This directory and all subdirectories should come from the TinyGo
-			// root, so simply make a symlink.
-			newname := filepath.Join(tmpgoroot, "src", importPath)
-			oldname := filepath.Join(tinygoroot, "src", importPath)
-			return symlink(oldname, newname)
-		}
-
-		// Merge subdirectories. Start by making the directory to merge.
-		err := os.Mkdir(filepath.Join(tmpgoroot, "src", importPath), 0777)
-		if err != nil {
-			return err
-		}
-
-		// Symlink all files from TinyGo, and symlink directories from TinyGo
-		// that need to be overridden.
-		tinygoEntries, err := ioutil.ReadDir(filepath.Join(tinygoroot, "src", importPath))
-		if err != nil {
-			return err
-		}
-		for _, e := range tinygoEntries {
-			if e.IsDir() {
-				// A directory, so merge this thing.
-				err := mergeDirectory(goroot, tinygoroot, tmpgoroot, path.Join(importPath, e.Name()), overrides)
-				if err != nil {
-					return err
-				}
-			} else {
-				// A file, so symlink this.
-				newname := filepath.Join(tmpgoroot, "src", importPath, e.Name())
-				oldname := filepath.Join(tinygoroot, "src", importPath, e.Name())
-				err := symlink(oldname, newname)
-				if err != nil {
-					return err
-				}
-			}
-		}
-
-		// Symlink all directories from $GOROOT that are not part of the TinyGo
-		// overrides.
-		gorootEntries, err := ioutil.ReadDir(filepath.Join(goroot, "src", importPath))
-		if err != nil {
-			return err
-		}
-		for _, e := range gorootEntries {
-			if !e.IsDir() {
-				// Don't merge in files from Go. Otherwise we'd end up with a
-				// weird syscall package with files from both roots.
-				continue
-			}
-			if _, ok := overrides[path.Join(importPath, e.Name())+"/"]; ok {
-				// Already included above, so don't bother trying to create this
-				// symlink.
-				continue
-			}
-			newname := filepath.Join(tmpgoroot, "src", importPath, e.Name())
-			oldname := filepath.Join(goroot, "src", importPath, e.Name())
-			err := symlink(oldname, newname)
-			if err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-// needsSyscallPackage returns whether the syscall package should be overriden
-// with the TinyGo version. This is the case on some targets.
-func needsSyscallPackage(buildTags []string) bool {
-	for _, tag := range buildTags {
-		if tag == "baremetal" || tag == "darwin" || tag == "nintendoswitch" {
-			return true
-		}
-	}
-	return false
-}
-
-// The boolean indicates whether to merge the subdirs. True means merge, false
-// means use the TinyGo version.
-func pathsToOverride(needsSyscallPackage bool) map[string]bool {
-	paths := map[string]bool{
-		"/":                     true,
-		"device/":               false,
-		"examples/":             false,
-		"internal/":             true,
-		"internal/bytealg/":     false,
-		"internal/reflectlite/": false,
-		"internal/task/":        false,
-		"machine/":              false,
-		"os/":                   true,
-		"reflect/":              false,
-		"runtime/":              false,
-		"sync/":                 true,
-		"testing/":              true,
-	}
-	if needsSyscallPackage {
-		paths["syscall/"] = true // include syscall/js
-	}
-	return paths
-}
-
-// symlink creates a symlink or something similar. On Unix-like systems, it
-// always creates a symlink. On Windows, it tries to create a symlink and if
-// that fails, creates a hardlink or directory junction instead.
-//
-// Note that while Windows 10 does support symlinks and allows them to be
-// created using os.Symlink, it requires developer mode to be enabled.
-// Therefore provide a fallback for when symlinking is not possible.
-// Unfortunately this fallback only works when TinyGo is installed on the same
-// filesystem as the TinyGo cache and the Go installation (which is usually the
-// C drive).
-func symlink(oldname, newname string) error {
-	symlinkErr := os.Symlink(oldname, newname)
-	if runtime.GOOS == "windows" && symlinkErr != nil {
-		// Fallback for when developer mode is disabled.
-		// Note that we return the symlink error even if something else fails
-		// later on. This is because symlinks are the easiest to support
-		// (they're also used on Linux and MacOS) and enabling them is easy:
-		// just enable developer mode.
-		st, err := os.Stat(oldname)
-		if err != nil {
-			return symlinkErr
-		}
-		if st.IsDir() {
-			// Make a directory junction. There may be a way to do this
-			// programmatically, but it involves a lot of magic. Use the mklink
-			// command built into cmd instead (mklink is a builtin, not an
-			// external command).
-			err := exec.Command("cmd", "/k", "mklink", "/J", newname, oldname).Run()
-			if err != nil {
-				return symlinkErr
-			}
-		} else {
-			// Try making a hard link.
-			err := os.Link(oldname, newname)
-			if err != nil {
-				// Making a hardlink failed. Try copying the file as a last
-				// fallback.
-				inf, err := os.Open(oldname)
-				if err != nil {
-					return err
-				}
-				defer inf.Close()
-				outf, err := os.Create(newname)
-				if err != nil {
-					return err
-				}
-				defer outf.Close()
-				_, err = io.Copy(outf, inf)
-				if err != nil {
-					os.Remove(newname)
-					return err
-				}
-				// File was copied.
-			}
-		}
-		return nil // success
-	}
-	return symlinkErr
-}
@@ -1,30 +0,0 @@
-package loader
-
-import (
-	"os"
-	"os/exec"
-	"strings"
-
-	"github.com/tinygo-org/tinygo/compileopts"
-)
-
-// List returns a ready-to-run *exec.Cmd for running the `go list` command with
-// the configuration used for TinyGo.
-func List(config *compileopts.Config, extraArgs, pkgs []string) (*exec.Cmd, error) {
-	goroot, err := GetCachedGoroot(config)
-	if err != nil {
-		return nil, err
-	}
-	args := append([]string{"list"}, extraArgs...)
-	if len(config.BuildTags()) != 0 {
-		args = append(args, "-tags", strings.Join(config.BuildTags(), " "))
-	}
-	args = append(args, pkgs...)
-	cgoEnabled := "0"
-	if config.CgoEnabled() {
-		cgoEnabled = "1"
-	}
-	cmd := exec.Command("go", args...)
-	cmd.Env = append(os.Environ(), "GOROOT="+goroot, "GOOS="+config.GOOS(), "GOARCH="+config.GOARCH(), "CGO_ENABLED="+cgoEnabled)
-	return cmd, nil
-}
@@ -2,239 +2,226 @@ package loader

 import (
 	"bytes"
-	"encoding/json"
 	"errors"
-	"fmt"
 	"go/ast"
+	"go/build"
 	"go/parser"
 	"go/scanner"
 	"go/token"
 	"go/types"
-	"io"
 	"os"
-	"os/exec"
 	"path/filepath"
-	"strconv"
+	"sort"
 	"strings"
-	"syscall"
+	"text/template"

 	"github.com/tinygo-org/tinygo/cgo"
-	"github.com/tinygo-org/tinygo/compileopts"
-	"github.com/tinygo-org/tinygo/goenv"
 )

 // Program holds all packages and some metadata about the program as a whole.
 type Program struct {
-	config       *compileopts.Config
-	clangHeaders string
-	typeChecker  types.Config
-	goroot       string // synthetic GOROOT
-	workingDir   string
-
-	Packages map[string]*Package
-	sorted   []*Package
-	fset     *token.FileSet
-
-	// Information obtained during parsing.
-	LDFlags []string
-}
-
-// PackageJSON is a subset of the JSON struct returned from `go list`.
-type PackageJSON struct {
-	Dir        string
-	ImportPath string
-	ForTest    string
-
-	// Source files
-	GoFiles  []string
-	CgoFiles []string
-	CFiles   []string
-
-	// Dependency information
-	Imports   []string
-	ImportMap map[string]string
-
-	// Error information
-	Error *struct {
-		ImportStack []string
-		Pos         string
-		Err         string
-	}
+	mainPkg      string
+	Build        *build.Context
+	OverlayBuild *build.Context
+	OverlayPath  func(path string) string
+	Packages     map[string]*Package
+	sorted       []*Package
+	fset         *token.FileSet
+	TypeChecker  types.Config
+	Dir          string // current working directory (for error reporting)
+	TINYGOROOT   string // root of the TinyGo installation or root of the source code
+	CFlags       []string
+	ClangHeaders string
 }

 // Package holds a loaded package, its imports, and its parsed files.
 type Package struct {
-	PackageJSON
-
-	program *Program
-	Files   []*ast.File
-	Pkg     *types.Package
-	info    types.Info
+	*Program
+	*build.Package
+	Imports   map[string]*Package
+	Importing bool
+	Files     []*ast.File
+	Pkg       *types.Package
+	types.Info
 }

-// Load loads the given package with all dependencies (including the runtime
-// package). Call .Parse() afterwards to parse all Go files (including CGo
-// processing, if necessary).
-func Load(config *compileopts.Config, inputPkgs []string, clangHeaders string, typeChecker types.Config) (*Program, error) {
-	goroot, err := GetCachedGoroot(config)
-	if err != nil {
-		return nil, err
-	}
-	wd, err := os.Getwd()
-	if err != nil {
-		return nil, err
-	}
-	p := &Program{
-		config:       config,
-		clangHeaders: clangHeaders,
-		typeChecker:  typeChecker,
-		goroot:       goroot,
-		workingDir:   wd,
-		Packages:     make(map[string]*Package),
-		fset:         token.NewFileSet(),
+// Import loads the given package relative to srcDir (for the vendor directory).
+// It only loads the current package without recursion.
+func (p *Program) Import(path, srcDir string, pos token.Position) (*Package, error) {
+	if p.Packages == nil {
+		p.Packages = make(map[string]*Package)
 	}

-	// List the dependencies of this package, in raw JSON format.
-	extraArgs := []string{"-json", "-deps"}
-	if config.TestConfig.CompileTestBinary {
-		extraArgs = append(extraArgs, "-test")
+	// Load this package.
+	ctx := p.Build
+	if newPath := p.OverlayPath(path); newPath != "" {
+		ctx = p.OverlayBuild
+		path = newPath
 	}
-	cmd, err := List(config, extraArgs, inputPkgs)
+	buildPkg, err := ctx.Import(path, srcDir, build.ImportComment)
 	if err != nil {
-		return nil, err
-	}
-	buf := &bytes.Buffer{}
-	cmd.Stdout = buf
-	cmd.Stderr = os.Stderr
-	err = cmd.Run()
-	if err != nil {
-		if exitErr, ok := err.(*exec.ExitError); ok {
-			if status, ok := exitErr.Sys().(syscall.WaitStatus); ok {
-				os.Exit(status.ExitStatus())
-			}
-			os.Exit(1)
+		return nil, scanner.Error{
+			Pos: pos,
+			Msg: err.Error(), // TODO: define a new error type that will wrap the inner error
 		}
-		return nil, fmt.Errorf("failed to run `go list`: %s", err)
+	}
+	if existingPkg, ok := p.Packages[buildPkg.ImportPath]; ok {
+		// Already imported, or at least started the import.
+		return existingPkg, nil
+	}
+	p.sorted = nil // invalidate the sorted order of packages
+	pkg := p.newPackage(buildPkg)
+	p.Packages[buildPkg.ImportPath] = pkg
+
+	if p.mainPkg == "" {
+		p.mainPkg = buildPkg.ImportPath
 	}

-	// Parse the returned json from `go list`.
-	decoder := json.NewDecoder(buf)
-	for {
-		pkg := &Package{
-			program: p,
-			info: types.Info{
-				Types:      make(map[ast.Expr]types.TypeAndValue),
-				Defs:       make(map[*ast.Ident]types.Object),
-				Uses:       make(map[*ast.Ident]types.Object),
-				Implicits:  make(map[ast.Node]types.Object),
-				Scopes:     make(map[ast.Node]*types.Scope),
-				Selections: make(map[*ast.SelectorExpr]*types.Selection),
-			},
-		}
-		err := decoder.Decode(&pkg.PackageJSON)
-		if err != nil {
-			if err == io.EOF {
-				break
-			}
-			return nil, err
-		}
-		if pkg.Error != nil {
-			// There was an error while importing (for example, a circular
-			// dependency).
-			pos := token.Position{}
-			fields := strings.Split(pkg.Error.Pos, ":")
-			if len(fields) >= 2 {
-				// There is some file/line/column information.
-				if n, err := strconv.Atoi(fields[len(fields)-2]); err == nil {
-					// Format: filename.go:line:colum
-					pos.Filename = strings.Join(fields[:len(fields)-2], ":")
-					pos.Line = n
-					pos.Column, _ = strconv.Atoi(fields[len(fields)-1])
-				} else {
-					// Format: filename.go:line
-					pos.Filename = strings.Join(fields[:len(fields)-1], ":")
-					pos.Line, _ = strconv.Atoi(fields[len(fields)-1])
-				}
-				pos.Filename = p.getOriginalPath(pos.Filename)
-			}
-			err := scanner.Error{
-				Pos: pos,
-				Msg: pkg.Error.Err,
-			}
-			if len(pkg.Error.ImportStack) != 0 {
-				return nil, Error{
-					ImportStack: pkg.Error.ImportStack,
-					Err:         err,
-				}
-			}
-			return nil, err
-		}
-		p.sorted = append(p.sorted, pkg)
-		p.Packages[pkg.ImportPath] = pkg
-	}
-
-	return p, nil
+	return pkg, nil
 }

-// getOriginalPath looks whether this path is in the generated GOROOT and if so,
-// replaces the path with the original path (in GOROOT or TINYGOROOT). Otherwise
-// the input path is returned.
-func (p *Program) getOriginalPath(path string) string {
-	originalPath := path
-	if strings.HasPrefix(path, p.goroot+string(filepath.Separator)) {
-		// If this file is part of the synthetic GOROOT, try to infer the
-		// original path.
-		relpath := path[len(filepath.Join(p.goroot, "src"))+1:]
-		realgorootPath := filepath.Join(goenv.Get("GOROOT"), "src", relpath)
-		if _, err := os.Stat(realgorootPath); err == nil {
-			originalPath = realgorootPath
-		}
-		maybeInTinyGoRoot := false
-		for prefix := range pathsToOverride(needsSyscallPackage(p.config.BuildTags())) {
-			if !strings.HasPrefix(relpath, prefix) {
-				continue
-			}
-			maybeInTinyGoRoot = true
-		}
-		if maybeInTinyGoRoot {
-			tinygoPath := filepath.Join(goenv.Get("TINYGOROOT"), "src", relpath)
-			if _, err := os.Stat(tinygoPath); err == nil {
-				originalPath = tinygoPath
-			}
-		}
+// ImportFile loads and parses the import statements in the given path and
+// creates a pseudo-package out of it.
+func (p *Program) ImportFile(path string) (*Package, error) {
+	if p.Packages == nil {
+		p.Packages = make(map[string]*Package)
+	}
+	if _, ok := p.Packages[path]; ok {
+		// unlikely
+		return nil, errors.New("loader: cannot import file that is already imported as package: " + path)
+	}
+
+	file, err := p.parseFile(path, parser.ImportsOnly)
+	if err != nil {
+		return nil, err
+	}
+	buildPkg := &build.Package{
+		Dir:        filepath.Dir(path),
+		ImportPath: path,
+		GoFiles:    []string{filepath.Base(path)},
+	}
+	for _, importSpec := range file.Imports {
+		buildPkg.Imports = append(buildPkg.Imports, importSpec.Path.Value[1:len(importSpec.Path.Value)-1])
+	}
+	p.sorted = nil // invalidate the sorted order of packages
+	pkg := p.newPackage(buildPkg)
+	p.Packages[buildPkg.ImportPath] = pkg
+
+	if p.mainPkg == "" {
+		p.mainPkg = buildPkg.ImportPath
+	}
+
+	return pkg, nil
+}
+
+// newPackage instantiates a new *Package object with initialized members.
+func (p *Program) newPackage(pkg *build.Package) *Package {
+	return &Package{
+		Program: p,
+		Package: pkg,
+		Imports: make(map[string]*Package, len(pkg.Imports)),
+		Info: types.Info{
+			Types:      make(map[ast.Expr]types.TypeAndValue),
+			Defs:       make(map[*ast.Ident]types.Object),
+			Uses:       make(map[*ast.Ident]types.Object),
+			Implicits:  make(map[ast.Node]types.Object),
+			Scopes:     make(map[ast.Node]*types.Scope),
+			Selections: make(map[*ast.SelectorExpr]*types.Selection),
+		},
 	}
-	return originalPath
 }

 // Sorted returns a list of all packages, sorted in a way that no packages come
 // before the packages they depend upon.
 func (p *Program) Sorted() []*Package {
+	if p.sorted == nil {
+		p.sort()
+	}
 	return p.sorted
 }

-// MainPkg returns the last package in the Sorted() slice. This is the main
-// package of the program.
-func (p *Program) MainPkg() *Package {
-	return p.sorted[len(p.sorted)-1]
+func (p *Program) sort() {
+	p.sorted = nil
+	packageList := make([]*Package, 0, len(p.Packages))
+	packageSet := make(map[string]struct{}, len(p.Packages))
+	worklist := make([]string, 0, len(p.Packages))
+	for path := range p.Packages {
+		worklist = append(worklist, path)
+	}
+	sort.Strings(worklist)
+	for len(worklist) != 0 {
+		pkgPath := worklist[0]
+		pkg := p.Packages[pkgPath]
+
+		if _, ok := packageSet[pkgPath]; ok {
+			// Package already in the final package list.
+			worklist = worklist[1:]
+			continue
+		}
+
+		unsatisfiedImports := make([]string, 0)
+		for _, pkg := range pkg.Imports {
+			if _, ok := packageSet[pkg.ImportPath]; ok {
+				continue
+			}
+			unsatisfiedImports = append(unsatisfiedImports, pkg.ImportPath)
+		}
+		sort.Strings(unsatisfiedImports)
+		if len(unsatisfiedImports) == 0 {
+			// All dependencies of this package are satisfied, so add this
+			// package to the list.
+			packageList = append(packageList, pkg)
+			packageSet[pkgPath] = struct{}{}
+			worklist = worklist[1:]
+		} else {
+			// Prepend all dependencies to the worklist and reconsider this
+			// package (by not removing it from the worklist). At that point, it
+			// must be possible to add it to packageList.
+			worklist = append(unsatisfiedImports, worklist...)
+		}
+	}
+
+	p.sorted = packageList
 }

-// Parse parses all packages and typechecks them.
+// Parse recursively imports all packages, parses them, and typechecks them.
 //
 // The returned error may be an Errors error, which contains a list of errors.
 //
 // Idempotent.
-func (p *Program) Parse() error {
+func (p *Program) Parse(compileTestBinary bool) error {
+	includeTests := compileTestBinary
+
+	// Load all imports
+	for _, pkg := range p.Sorted() {
+		err := pkg.importRecursively(includeTests)
+		if err != nil {
+			if err, ok := err.(*ImportCycleError); ok {
+				if pkg.ImportPath != err.Packages[0] {
+					err.Packages = append([]string{pkg.ImportPath}, err.Packages...)
+				}
+			}
+			return err
+		}
+	}
+
 	// Parse all packages.
-	// TODO: do this in parallel.
-	for _, pkg := range p.sorted {
-		err := pkg.Parse()
+	for _, pkg := range p.Sorted() {
+		err := pkg.Parse(includeTests)
+		if err != nil {
+			return err
+		}
+	}
+
+	if compileTestBinary {
+		err := p.SwapTestMain()
 		if err != nil {
 			return err
 		}
 	}

 	// Typecheck all packages.
-	for _, pkg := range p.sorted {
+	for _, pkg := range p.Sorted() {
 		err := pkg.Check()
 		if err != nil {
 			return err
@@ -244,6 +231,83 @@ func (p *Program) Parse() error {
 	return nil
 }

+func (p *Program) SwapTestMain() error {
+	var tests []string
+
+	isTestFunc := func(f *ast.FuncDecl) bool {
+		// TODO: improve signature check
+		if strings.HasPrefix(f.Name.Name, "Test") && f.Name.Name != "TestMain" {
+			return true
+		}
+		return false
+	}
+	mainPkg := p.Packages[p.mainPkg]
+	for _, f := range mainPkg.Files {
+		for i, d := range f.Decls {
+			switch v := d.(type) {
+			case *ast.FuncDecl:
+				if isTestFunc(v) {
+					tests = append(tests, v.Name.Name)
+				}
+				if v.Name.Name == "main" {
+					// Remove main
+					if len(f.Decls) == 1 {
+						f.Decls = make([]ast.Decl, 0)
+					} else {
+						f.Decls[i] = f.Decls[len(f.Decls)-1]
+						f.Decls = f.Decls[:len(f.Decls)-1]
+					}
+				}
+			}
+		}
+	}
+
+	// TODO: Check if they defined a TestMain and call it instead of testing.TestMain
+	const mainBody = `package main
+
+import (
+	"testing"
+)
+
+func main () {
+	m := &testing.M{
+		Tests: []testing.TestToCall{
+{{range .TestFunctions}}
+			{Name: "{{.}}", Func: {{.}}},
+{{end}}
+		},
+	}
+
+	testing.TestMain(m)
+}
+`
+	tmpl := template.Must(template.New("testmain").Parse(mainBody))
+	b := bytes.Buffer{}
+	tmplData := struct {
+		TestFunctions []string
+	}{
+		TestFunctions: tests,
+	}
+
+	err := tmpl.Execute(&b, tmplData)
+	if err != nil {
+		return err
+	}
+	path := filepath.Join(p.mainPkg, "$testmain.go")
+
+	if p.fset == nil {
+		p.fset = token.NewFileSet()
+	}
+
+	newMain, err := parser.ParseFile(p.fset, path, b.Bytes(), parser.AllErrors)
+	if err != nil {
+		return err
+	}
+	mainPkg.Files = append(mainPkg.Files, newMain)
+
+	return nil
+}
+
 // parseFile is a wrapper around parser.ParseFile.
 func (p *Program) parseFile(path string, mode parser.Mode) (*ast.File, error) {
 	if p.fset == nil {
@@ -255,26 +319,34 @@ func (p *Program) parseFile(path string, mode parser.Mode) (*ast.File, error) {
 		return nil, err
 	}
 	defer rd.Close()
-	return parser.ParseFile(p.fset, p.getOriginalPath(path), rd, mode)
+	relpath := path
+	if filepath.IsAbs(path) {
+		rp, err := filepath.Rel(p.Dir, path)
+		if err == nil {
+			relpath = rp
+		}
+	}
+	return parser.ParseFile(p.fset, relpath, rd, mode)
 }

 // Parse parses and typechecks this package.
 //
 // Idempotent.
-func (p *Package) Parse() error {
+func (p *Package) Parse(includeTests bool) error {
 	if len(p.Files) != 0 {
-		return nil // nothing to do (?)
+		return nil
 	}

 	// Load the AST.
+	// TODO: do this in parallel.
 	if p.ImportPath == "unsafe" {
-		// Special case for the unsafe package, which is defined internally by
-		// the types package.
+		// Special case for the unsafe package. Don't even bother loading
+		// the files.
 		p.Pkg = types.Unsafe
 		return nil
 	}

-	files, err := p.parseFiles()
+	files, err := p.parseFiles(includeTests)
 	if err != nil {
 		return err
 	}
@@ -289,11 +361,11 @@ func (p *Package) Parse() error {
 // Idempotent.
 func (p *Package) Check() error {
 	if p.Pkg != nil {
-		return nil // already typechecked
+		return nil
 	}

 	var typeErrors []error
-	checker := p.program.typeChecker // make a copy, because it will be modified
+	checker := p.TypeChecker
 	checker.Error = func(err error) {
 		typeErrors = append(typeErrors, err)
 	}
@@ -301,7 +373,7 @@ func (p *Package) Check() error {
 	// Do typechecking of the package.
 	checker.Importer = p

-	typesPkg, err := checker.Check(p.ImportPath, p.program.fset, p.Files, &p.info)
+	typesPkg, err := checker.Check(p.ImportPath, p.fset, p.Files, &p.Info)
 	if err != nil {
 		if err, ok := err.(Errors); ok {
 			return err
@@ -313,47 +385,52 @@ func (p *Package) Check() error {
 }

 // parseFiles parses the loaded list of files and returns this list.
-func (p *Package) parseFiles() ([]*ast.File, error) {
+func (p *Package) parseFiles(includeTests bool) ([]*ast.File, error) {
+	// TODO: do this concurrently.
 	var files []*ast.File
 	var fileErrs []error

-	// Parse all files (incuding CgoFiles).
-	parseFile := func(file string) {
-		if !filepath.IsAbs(file) {
-			file = filepath.Join(p.Dir, file)
-		}
-		f, err := p.program.parseFile(file, parser.ParseComments)
+	var gofiles []string
+	if includeTests {
+		gofiles = make([]string, 0, len(p.GoFiles)+len(p.TestGoFiles))
+		gofiles = append(gofiles, p.GoFiles...)
+		gofiles = append(gofiles, p.TestGoFiles...)
+	} else {
+		gofiles = p.GoFiles
+	}
+
+	for _, file := range gofiles {
+		f, err := p.parseFile(filepath.Join(p.Package.Dir, file), parser.ParseComments)
 		if err != nil {
 			fileErrs = append(fileErrs, err)
-			return
+			continue
+		}
+		if err != nil {
+			fileErrs = append(fileErrs, err)
+			continue
 		}
 		files = append(files, f)
 	}
-	for _, file := range p.GoFiles {
-		parseFile(file)
-	}
 	for _, file := range p.CgoFiles {
-		parseFile(file)
-	}
-
-	// Do CGo processing.
-	if len(p.CgoFiles) != 0 {
-		var cflags []string
-		cflags = append(cflags, p.program.config.CFlags()...)
-		cflags = append(cflags, "-I"+p.Dir)
-		if p.program.clangHeaders != "" {
-			cflags = append(cflags, "-Xclang", "-internal-isystem", "-Xclang", p.program.clangHeaders)
+		path := filepath.Join(p.Package.Dir, file)
+		f, err := p.parseFile(path, parser.ParseComments)
+		if err != nil {
+			fileErrs = append(fileErrs, err)
+			continue
 		}
-		generated, ldflags, errs := cgo.Process(files, p.program.workingDir, p.program.fset, cflags)
+		files = append(files, f)
+	}
+	if len(p.CgoFiles) != 0 {
+		cflags := append(p.CFlags, "-I"+p.Package.Dir)
+		if p.ClangHeaders != "" {
+			cflags = append(cflags, "-I"+p.ClangHeaders)
+		}
+		generated, errs := cgo.Process(files, p.Program.Dir, p.fset, cflags)
 		if errs != nil {
 			fileErrs = append(fileErrs, errs...)
 		}
 		files = append(files, generated)
-		p.program.LDFlags = append(p.program.LDFlags, ldflags...)
 	}
-
-	// Only return an error after CGo processing, so that errors in parsing and
-	// CGo can be reported together.
 	if len(fileErrs) != 0 {
 		return nil, Errors{p, fileErrs}
 	}
@@ -367,14 +444,59 @@ func (p *Package) Import(to string) (*types.Package, error) {
 	if to == "unsafe" {
 		return types.Unsafe, nil
 	}
-	if replace, ok := p.ImportMap[to]; ok {
-		// This import path should be replaced by another import path, according
-		// to `go list`.
-		to = replace
-	}
-	if imported, ok := p.program.Packages[to]; ok {
-		return imported.Pkg, nil
+	if _, ok := p.Imports[to]; ok {
+		return p.Imports[to].Pkg, nil
 	} else {
 		return nil, errors.New("package not imported: " + to)
 	}
 }
+
+// importRecursively calls Program.Import() on all imported packages, and calls
+// importRecursively() on the imported packages as well.
+//
+// Idempotent.
+func (p *Package) importRecursively(includeTests bool) error {
+	p.Importing = true
+
+	imports := p.Package.Imports
+	if includeTests {
+		imports = append(imports, p.Package.TestImports...)
+	}
+
+	for _, to := range imports {
+		if to == "C" {
+			// Do CGo processing in a later stage.
+			continue
+		}
+		if _, ok := p.Imports[to]; ok {
+			continue
+		}
+		// Find error location.
+		var pos token.Position
+		if len(p.Package.ImportPos[to]) > 0 {
+			pos = p.Package.ImportPos[to][0]
+		} else {
+			pos = token.Position{Filename: p.Package.ImportPath}
+		}
+		importedPkg, err := p.Program.Import(to, p.Package.Dir, pos)
+		if err != nil {
+			if err, ok := err.(*ImportCycleError); ok {
+				err.Packages = append([]string{p.ImportPath}, err.Packages...)
+			}
+			return err
+		}
+		if importedPkg.Importing {
+			return &ImportCycleError{[]string{p.ImportPath, importedPkg.ImportPath}, p.ImportPos[to]}
+		}
+		err = importedPkg.importRecursively(false)
+		if err != nil {
+			if err, ok := err.(*ImportCycleError); ok {
+				err.Packages = append([]string{p.ImportPath}, err.Packages...)
+			}
+			return err
+		}
+		p.Imports[to] = importedPkg
+	}
+	p.Importing = false
+	return nil
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Ayke van Laethem	ebde8b5875	targets/gba: implement interrupt handler	2020-01-06 14:45:32 +01:00
Ayke van Laethem	9d50587d63	targets/gba: make linker script cleaner Make it clearer where the stack is located.	2020-01-06 11:48:09 +01:00
Ayke van Laethem	5e6f1725ac	WIP interrupts via ptrtoint handler	2020-01-05 08:05:38 +01:00
Ayke van Laethem	9cdc2fa768	WIP: interrupt API	2020-01-04 23:40:45 +01:00
Ayke van Laethem	084386262a	compiler: add support for debugging globals This makes most globals visible from GDB, using `info variables`.	2020-01-04 23:40:44 +01:00
Ayke van Laethem	674ddef219	compiler: add globaldce pass to start of optimization pipeline This reduces code size in a few cases when tested against the drivers smoketests (although there was one minor increase) without significantly increasing compile time. In fact, in my testing compile time appears to be going down a little bit (around 1%, within the noise).	2020-01-04 23:40:44 +01:00