build: make msd flash faster

2026-07-28 07:38:41 +00:00 · 2021-03-15 23:07:27 +09:00
597 changed files with 6475 additions and 26313 deletions
@@ -68,17 +68,14 @@ commands:
    steps:
      - restore_cache:
          keys:
-            - llvm-source-11-v2
+            - llvm-source-11-v1
      - run:
          name: "Fetch LLVM source"
          command: make llvm-source
      - save_cache:
-          key: llvm-source-11-v2
+          key: llvm-source-11-v1
          paths:
-            - llvm-project/clang/lib/Headers
-            - llvm-project/clang/include
-            - llvm-project/lld/include
-            - llvm-project/llvm/include
+            - llvm-project
  build-wasi-libc:
    steps:
      - restore_cache:
@@ -157,15 +154,12 @@ commands:
      - llvm-source-linux
      - restore_cache:
          keys:
-            - llvm-build-11-linux-v4-assert
+            - llvm-build-11-linux-v2-assert
      - run:
          name: "Build LLVM"
          command: |
            if [ ! -f llvm-build/lib/liblldELF.a ]
            then
-              # fetch LLVM source
-              rm -rf llvm-project
-              make llvm-source
              # install dependencies
              sudo apt-get install cmake ninja-build
              # hack ninja to use less jobs
@@ -173,10 +167,9 @@ commands:
              chmod +x /go/bin/ninja
              # build!
              make ASSERT=1 llvm-build
-              find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
            fi
      - save_cache:
-          key: llvm-build-11-linux-v4-assert
+          key: llvm-build-11-linux-v2-assert
          paths:
            llvm-build
      - run: make ASSERT=1
@@ -184,11 +177,6 @@ commands:
      - run:
          name: "Test TinyGo"
          command: make ASSERT=1 test
-          environment:
-            # Note: -p=2 limits parallelism to two jobs at a time, which is
-            # necessary to keep memory consumption down and avoid OOM (for a
-            # 2CPU/4GB executor).
-            GOFLAGS: -p=2
      - save_cache:
          key: go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
          paths:
@@ -225,15 +213,12 @@ commands:
      - llvm-source-linux
      - restore_cache:
          keys:
-            - llvm-build-11-linux-v4-noassert
+            - llvm-build-11-linux-v2-noassert
      - run:
          name: "Build LLVM"
          command: |
            if [ ! -f llvm-build/lib/liblldELF.a ]
            then
-              # fetch LLVM source
-              rm -rf llvm-project
-              make llvm-source
              # install dependencies
              sudo apt-get install cmake ninja-build
              # hack ninja to use less jobs
@@ -241,10 +226,9 @@ commands:
              chmod +x /go/bin/ninja
              # build!
              make llvm-build
-              find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
            fi
      - save_cache:
-          key: llvm-build-11-linux-v4-noassert
+          key: llvm-build-11-linux-v2-noassert
          paths:
            llvm-build
      - build-wasi-libc
@@ -286,58 +270,51 @@ commands:
      - run:
          name: "Install dependencies"
          command: |
-            curl https://dl.google.com/go/go1.17.darwin-amd64.tar.gz -o go1.17.darwin-amd64.tar.gz
-            sudo tar -C /usr/local -xzf go1.17.darwin-amd64.tar.gz
+            curl https://dl.google.com/go/go1.16.darwin-amd64.tar.gz -o go1.16.darwin-amd64.tar.gz
+            sudo tar -C /usr/local -xzf go1.16.darwin-amd64.tar.gz
            ln -s /usr/local/go/bin/go /usr/local/bin/go
            HOMEBREW_NO_AUTO_UPDATE=1 brew install qemu
      - install-xtensa-toolchain:
          variant: "macos"
      - restore_cache:
          keys:
-            - go-cache-macos-v3-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
-            - go-cache-macos-v3-{{ checksum "go.mod" }}
+            - go-cache-macos-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
+            - go-cache-macos-v2-{{ checksum "go.mod" }}
      - restore_cache:
          keys:
-            - llvm-source-11-macos-v3
+            - llvm-source-11-macos-v1
      - run:
          name: "Fetch LLVM source"
          command: make llvm-source
      - save_cache:
-          key: llvm-source-11-macos-v3
+          key: llvm-source-11-macos-v1
          paths:
-            - llvm-project/clang/lib/Headers
-            - llvm-project/clang/include
-            - llvm-project/lld/include
-            - llvm-project/llvm/include
+            - llvm-project
      - restore_cache:
          keys:
-            - llvm-build-11-macos-v5
+            - llvm-build-11-macos-v2
      - run:
          name: "Build LLVM"
          command: |
            if [ ! -f llvm-build/lib/liblldELF.a ]
            then
-              # fetch LLVM source
-              rm -rf llvm-project
-              make llvm-source
              # install dependencies
              HOMEBREW_NO_AUTO_UPDATE=1 brew install cmake ninja
              # build!
              make llvm-build
-              find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
            fi
      - save_cache:
-          key: llvm-build-11-macos-v5
+          key: llvm-build-11-macos-v2
          paths:
            llvm-build
      - restore_cache:
          keys:
-            - wasi-libc-sysroot-macos-v4
+            - wasi-libc-sysroot-macos-v3
      - run:
          name: "Build wasi-libc"
          command: make wasi-libc
      - save_cache:
-          key: wasi-libc-sysroot-macos-v4
+          key: wasi-libc-sysroot-macos-v3
          paths:
            - lib/wasi-libc/sysroot
      - run:
@@ -359,18 +336,30 @@ commands:
            tinygo version
      - run: make smoketest AVR=0
      - save_cache:
-          key: go-cache-macos-v3-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
+          key: go-cache-macos-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
          paths:
            - ~/.cache/go-build
            - /go/pkg/mod

 jobs:
-  test-llvm10-go115:
+  test-llvm10-go113:
+    docker:
+      - image: circleci/golang:1.13-buster
+    steps:
+      - test-linux:
+          llvm: "10"
+  test-llvm10-go114:
+    docker:
+      - image: circleci/golang:1.14-buster
+    steps:
+      - test-linux:
+          llvm: "10"
+  test-llvm11-go115:
    docker:
      - image: circleci/golang:1.15-buster
    steps:
      - test-linux:
-          llvm: "10"
+          llvm: "11"
  test-llvm11-go116:
    docker:
      - image: circleci/golang:1.16-buster
@@ -379,17 +368,17 @@ jobs:
          llvm: "11"
  assert-test-linux:
    docker:
-      - image: circleci/golang:1.17-stretch
+      - image: circleci/golang:1.14-stretch
    steps:
      - assert-test-linux
  build-linux:
    docker:
-      - image: circleci/golang:1.17-stretch
+      - image: circleci/golang:1.14-stretch
    steps:
      - build-linux
  build-macos:
    macos:
-      xcode: "11.1.0" # macOS 10.14
+      xcode: "10.1.0"
    steps:
      - build-macos

@@ -398,7 +387,9 @@ jobs:
 workflows:
  test-all:
    jobs:
-      - test-llvm10-go115
+      - test-llvm10-go113
+      - test-llvm10-go114
+      - test-llvm11-go115
      - test-llvm11-go116
      - build-linux
      - build-macos
@@ -1,3 +0,0 @@
-build/
-llvm-*/
-
@@ -1,45 +0,0 @@
-name: CI for tinygo-dev docker container
-on:
-  push:
-    branches: [ dev, fix-docker-llvm-build ]
-
-jobs:
-  push_to_registry:
-    name: Push Docker image to GHCR/Docker Hub
-    runs-on: ubuntu-latest
-    permissions:
-      packages: write
-      contents: read
-    steps:
-      - name: Check out the repo
-        uses: actions/checkout@v2
-        with:
-          submodules: recursive
-      - name: Docker meta
-        id: meta
-        uses: docker/metadata-action@v3
-        with:
-          images: |
-            tinygo/tinygo-dev
-            ghcr.io/${{ github.repository }}/tinygo-dev
-          tags: |
-            type=sha,format=long
-            type=raw,value=latest
-      - name: Log in to Docker Hub
-        uses: docker/login-action@v1
-        with:
-          username: ${{ secrets.DOCKER_HUB_USERNAME }}
-          password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
-      - name: Log in to Github Container Registry
-        uses: docker/login-action@v1
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-      - name: Build and push
-        uses: docker/build-push-action@v2
-        with:
-          context: .
-          push: true
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
@@ -16,15 +16,6 @@ src/device/stm32/*.go
 src/device/stm32/*.s
 src/device/kendryte/*.go
 src/device/kendryte/*.s
-src/device/rp/*.go
-src/device/rp/*.s
 vendor
 llvm-build
 llvm-project
-
-# Ignore files generated by smoketest
-test.gba
-test.hex
-test.nro
-test.wasm
-wasm.wasm
@@ -23,7 +23,7 @@ different guide:
 LLVM, Clang and LLD are quite light on dependencies, requiring only standard
 build tools to be built. Go is of course necessary to build TinyGo itself.

-  * Go (1.15+)
+  * Go (1.13+)
  * Standard build tools (gcc/clang)
  * git
  * CMake
@@ -1,261 +1,3 @@
-0.20.0
---
-
-* **command line**
-  - add support for Go 1.17
-  - improve Go version detection
-  - add support for the Black Magic Probe (BMP)
-  - add a flag for creating cpu profiles
-* **compiler**
-  - `builder:` list libraries at the end of the linker command
-  - `builder:` strip debug information at link time instead of at compile time
-  - `builder:` add missing error check for `ioutil.TempFile()`
-  - `builder:` simplify running of jobs
-  - `compiler:` move LLVM math builtin support into the compiler
-  - `compiler:` move math aliases from the runtime to the compiler
-  - `compiler:` add aliases for many hashing packages
-  - `compiler:` add `*ssa.MakeSlice` bounds tests
-  - `compiler:` fix max possible slice
-  - `compiler:` add support for new language features of Go 1.17
-  - `compiler:` fix equally named structs in different scopes
-  - `compiler:` avoid zero-sized alloca in channel operations
-  - `interp:` don't ignore array indices for untyped objects
-  - `interp:` keep reverted package initializers in order
-  - `interp:` fix bug in compiler-time/run-time package initializers
-  - `loader:` fix panic in CGo files with syntax errors
-  - `transform:` improve GC stack slot pass to work around a bug
-* **standard library**
-  - `crypto/rand`: switch to `arc4random_buf`
-  - `math:` fix `math.Max` and `math.Min`
-  - `math/big`: fix undefined symbols error
-  - `net:` add MAC address implementation
-  - `os:` implement `os.Executable`
-  - `os:` add `SEEK_SET`, `SEEK_CUR`, and `SEEK_END`
-  - `reflect:` add StructField.IsExported method
-  - `runtime:` reset heapptr to heapStart after preinit()
-  - `runtime:` add `subsections_via_symbols` to assembly files on darwin
-  - `testing:` add subset implementation of Benchmark
-  - `testing:` test testing package using `tinygo test`
-  - `testing:` add support for the `-test.v` flag
-* **targets**
-  - `386:` bump minimum requirement to the Pentium 4
-  - `arm:` switch to Thumb instruction set on ARM
-  - `atsamd:` fix copy-paste error for atsamd21/51 calibTrim block
-  - `baremetal`,`wasm`: support command line params and environment variables
-  - `cortexm:` fix stack overflow because of unaligned stacks
-  - `esp32c3:` add support for the ESP32-C3 from Espressif
-  - `nrf52840:` fix ram size
-  - `nxpmk66f18:` fix a suspicious bitwise operation
-  - `rp2040:` add SPI support
-  - `rp2040:` add I2C support
-  - `rp2040:` add PWM implementation
-  - `rp2040:` add openocd configuration
-  - `stm32:` add support for PortMask* functions for WS2812 support
-  - `unix:` fix time base for time.Now()
-  - `unix:` check for mmap error and act accordingly
-  - `wasm:` override dlmalloc heap implementation from wasi-libc
-  - `wasm:` align heap to 16 bytes
-  - `wasm:` add support for the crypto/rand package
-* **boards**
-  - add `DefaultUART` to adafruit boards
-  - `arduino-mkrwifi1010:` add board definition for Arduino MKR WiFi 1010
-  - `arduino-mkrwifi1010:` fix pin definition of `NINA_RESETN`
-  - `feather-nrf52:` fix pin definition of uart
-  - `feather-rp2040:` add pin name definition
-  - `gameboy-advance:` fix ROM header
-  - `mdbt50qrx-uf2:` add Raytac MDBT50Q-RX Dongle with TinyUF2
-  - `nano-rp2040:` define `NINA_SPI` and fix wifinina pins
-  - `teensy40:` enable hardware UART reconfiguration, fix receive watermark interrupt
-
-
-0.19.0
---
-
-* **command line**
-  - don't consider compile-only tests as failing
-  - add -test flag for `tinygo list`
-  - escape commands while printing them with the -x flag
-  - make flash-command portable and safer to use
-  - use `extended-remote` instead of `remote` in GDB
-  - detect specific serial port IDs based on USB vid/pid
-  - add a flag to the command line to select the serial implementation
-* **compiler**
-  - `cgo`: improve constant parser
-  - `compiler`: support chained interrupt handlers
-  - `compiler`: add support for running a builtin in a goroutine
-  - `compiler`: do not emit nil checks for loading closure variables
-  - `compiler`: skip context parameter when starting regular goroutine
-  - `compiler`: refactor method names
-  - `compiler`: add function and global section pragmas
-  - `compiler`: implement `syscall.rawSyscallNoError` in inline assembly
-  - `interp`: ignore inline assembly in markExternal
-  - `interp`: fix a bug in pointer cast workaround
-  - `loader`: fix testing a main package
-* **standard library**
-  - `crypto/rand`: replace this package with a TinyGo version
-  - `machine`: make USBCDC global a pointer
-  - `machine`: make UART objects pointer receivers
-  - `machine`: define Serial as the default output
-  - `net`: add initial support for net.IP
-  - `net`: add more net compatibility
-  - `os`: add stub for os.ReadDir
-  - `os`: add FileMode constants from Go 1.16
-  - `os`: add stubs required for net/http
-  - `os`: implement process related functions
-  - `reflect`: implement AppendSlice
-  - `reflect`: add stubs required for net/http
-  - `runtime`: make task.Data a 64-bit integer to avoid overflow
-  - `runtime`: expose memory stats
-  - `sync`: implement NewCond
-  - `syscall`: fix int type in libc version
-* **targets**
-  - `cortexm`: do not disable interrupts on abort
-  - `cortexm`: bump default stack size to 2048 bytes
-  - `nrf`: avoid heap allocation in waitForEvent
-  - `nrf`: don't trigger a heap allocation in SPI.Transfer
-  - `nrf52840`: add support for flashing with the BOSSA tool
-  - `rp2040`: add support for GPIO input
-  - `rp2040`: add basic support for ADC
-  - `rp2040`: gpio and adc pin definitions
-  - `rp2040`: implement UART
-  - `rp2040`: patch elf to checksum 2nd stage boot
-  - `stm32`: add PWM for most chips
-  - `stm32`: add support for pin interrupts
-  - `stm32f103`: add support for PinInputPullup / PinInputPulldown
-  - `wasi`: remove wasm build tag
-* **boards**
-  - `feather-rp2040`: add support for this board
-  - `feather-nrf52840-sense`: add board definition for this board
-  - `pca10059`: support flashing from Windows
-  - `nano-rp2040`: add this board
-  - `nano-33-ble`: add support for this board
-  - `pico`: add the Raspberry Pi Pico board with the new RP2040 chip
-  - `qtpy`: add pin for neopixels
-  - all: add definition for ws2812 for supported boards
-
-
-0.18.0
---
-
-* **command line**
-  - drop support for Go 1.11 and 1.12
-  - throw an error when no target is specified on Windows
-  - improve error messages in `getDefaultPort()`, support for multiple ports
-  - remove `-cflags` and `-ldflags` flags
-  - implement `-ldflags="-X ..."`
-  - add `-print-allocs` flag that lets you print all heap allocations
-  - openocd commands in tinygo command line
-  - add `-llvm-features` parameter
-  - match `go test` output
-  - discover USB ports only, this will ignore f.ex. bluetooth
-  - use physicmal path instead of cached GOROOT in function getGoroot
-  - add goroot for snap installs
-* **compiler**
-  - `builder`: add support for `-opt=0`
-  - `builder`, `compiler`: compile and cache packages in parallel
-  - `builder`: run interp per package
-  - `builder`: cache C and assembly file outputs
-  - `builder`: add support for `-x` flag to print commands
-  - `builder`: add optsize attribute while building the package
-  - `builder`: run function passes per package
-  - `builder`: hard code Clang compiler
-  - `compiler`: do not use `llvm.GlobalContext()`
-  - `compiler`: remove SimpleDCE pass
-  - `compiler`: do not emit nil checks for `*ssa.Alloc` instructions
-  - `compiler`: merge `runtime.typecodeID` and runtime.typeInInterface
-  - `compiler`: do not check for impossible type asserts
-  - `compiler`: fix use of global context: `llvm.Int32Type()`
-  - `compiler`: add interface IR test
-  - `compiler`: fix lack of method name in interface matching
-  - `compiler`: fix "fragment covers entire variable" bug
-  - `compiler`: optimize string literals and globals
-  - `compiler`: decouple func lowering from interface type codes
-  - `compiler`: add function attributes to some runtime calls
-  - `compiler`: improve position information in error messages
-  - `cgo`: add support for CFLAGS in .c files
-  - `interp`: support GEP on fixed (MMIO) addresses
-  - `interp`: handle `(reflect.Type).Elem()`
-  - `interp`: add support for runtime.interfaceMethod
-  - `interp`: make toLLVMValue return an error instead of panicking
-  - `interp`: add support for switch statement
-  - `interp`: fix phi instruction
-  - `interp`: remove map support
-  - `interp`: support extractvalue/insertvalue with multiple operands
-  - `transform`: optimize string comparisons against ""
-  - `transform`: optimize `reflect.Type` `Implements()` method
-  - `transform`: fix bug in interface lowering when signatures are renamed
-  - `transform`: don't rely on struct name of `runtime.typecodeID`
-  - `transform`: use IPSCCP pass instead of the constant propagation pass
-  - `transform`: fix func lowering assertion failure
-  - `transform`: do not lower zero-sized alloc to alloca
-  - `transform`: split interface and reflect lowering
-* **standard library**
-  - `runtime`: add dummy debug package
-  - `machine`: fix data shift/mask in newUSBSetup
-  - `machine`: make `machine.I2C0` and similar objects pointers
-  - `machine`: unify usbcdc code
-  - `machine`: refactor PWM support
-  - `machine`: avoid heap allocations in USB code
-  - `reflect`: let `reflect.Type` be of interface type
-  - `reflect`: implement a number of stub functions
-  - `reflect`: check for access in the `Interface` method call
-  - `reflect`: fix `AssignableTo` and `Implements` methods
-  - `reflect`: implement `Value.CanAddr`
-  - `reflect`: implement `Sizeof` and `Alignof` for func values
-  - `reflect`: implement `New` function
-  - `runtime`: implement command line arguments in hosted environments
-  - `runtime`: implement environment variables for Linux
-  - `runtime`: improve timers on nrf, and samd chips
-* **targets**
-  - all: use -Qunused-arguments only for assembly files
-  - `atmega1280`: add PWM support
-  - `attiny`: remove dummy UART
-  - `atsamd21`: improve SPI
-  - `atsamd51`: fix PWM support in atsamd51p20
-  - `atsamd5x`: improve SPI
-  - `atsamd51`, `atsame5x`: unify samd51 and same5x
-  - `atsamd51`, `atsamd21`: fix `ADC.Get()` value at 8bit and 10bit
-  - `atsame5x`: add support for CAN
-  - `avr`: remove I2C stubs from attiny support
-  - `cortexm`: check for `arm-none-eabi-gdb` and `gdb-multiarch` commands
-  - `cortexm`: add `__isr_vector` symbol
-  - `cortexm`: disable FPU on Cortex-M4
-  - `cortexm`: clean up Cortex-M target files
-  - `fe310`: fix SPI read
-  - `gameboy-advance`: Fix RGBA color interpretation
-  - `nrf52833`: add PWM support
-  - `stm32l0`: use unified UART logic
-  - `stm32`: move f103 (bluepill) to common i2c code
-  - `stm32`: separate altfunc selection for UART Tx/Rx
-  - `stm32`: i2c implementation for F7, L5 and L4 MCUs
-  - `stm32`: make SPI CLK fast to fix data issue
-  - `stm32`: support SPI on L4 series
-  - `unix`: avoid possible heap allocation with `-opt=0`
-  - `unix`: use conservative GC by default
-  - `unix`: use the tasks scheduler instead of coroutines
-  - `wasi`: upgrade WASI version to wasi_snapshot_preview1
-  - `wasi`: darwin: support basic file io based on libc
-  - `wasm`: only export explicitly exported functions
-  - `wasm`: use WASI ABI for exit function
-  - `wasm`: scan globals conservatively
-* **boards**
-  - `arduino-mega1280`: add support for the Arduino Mega 1280
-  - `arduino-nano-new`: Add Arduino Nano w/ New Bootloader target
-  - `atsame54-xpro`: add initial support this board
-  - `feather-m4-can`: add initial support for this board
-  - `grandcentral-m4`: add board support for Adafruit Grand Central M4 (SAMD51)
-  - `lgt92`: update to new UART structure
-  - `microbit`: remove LED constant
-  - `microbit-v2`: add support for S113 SoftDevice
-  - `nucleol432`: add support for this board
-  - `nucleo-l031k6`: add this board
-  - `pca10059`: initial support for this board
-  - `qtpy`: fix msd-volume-name
-  - `qtpy`: fix i2c setting
-  - `teensy40`: move txBuffer allocation to UART declaration
-  - `teensy40`: add UART0 as alias for UART1
-
-
 0.17.0

 ---
@@ -1,8 +1,8 @@
-# TinyGo base stage installs the most recent Go 1.17.x, LLVM 11 and the TinyGo compiler itself.
-FROM golang:1.17 AS tinygo-base
+# TinyGo base stage installs the most recent Go 1.15.x, LLVM 11 and the TinyGo compiler itself.
+FROM golang:1.15 AS tinygo-base

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

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

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

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

@@ -71,7 +71,7 @@ else
 endif

 # Libraries that should be linked in for the statically linked Clang.
-CLANG_LIB_NAMES = clangAnalysis clangAST clangASTMatchers clangBasic clangCodeGen clangCrossTU clangDriver clangDynamicASTMatchers clangEdit clangFormat clangFrontend clangFrontendTool clangHandleCXX clangHandleLLVM clangIndex clangLex clangParse clangRewrite clangRewriteFrontend clangSema clangSerialization clangTooling clangToolingASTDiff clangToolingCore clangToolingInclusions
+CLANG_LIB_NAMES = clangAnalysis clangARCMigrate clangAST clangASTMatchers clangBasic clangCodeGen clangCrossTU clangDriver clangDynamicASTMatchers clangEdit clangFormat clangFrontend clangFrontendTool clangHandleCXX clangHandleLLVM clangIndex clangLex clangParse clangRewrite clangRewriteFrontend clangSema clangSerialization clangStaticAnalyzerCheckers clangStaticAnalyzerCore clangStaticAnalyzerFrontend clangTooling clangToolingASTDiff clangToolingCore clangToolingInclusions
 CLANG_LIBS = $(START_GROUP) $(addprefix -l,$(CLANG_LIB_NAMES)) $(END_GROUP) -lstdc++

 # Libraries that should be linked in for the statically linked LLD.
@@ -100,17 +100,14 @@ endif
 clean:
 	@rm -rf build

-FMT_PATHS = ./*.go builder cgo compiler interp loader src/device/arm src/examples src/machine src/os src/reflect src/runtime src/sync src/syscall src/testing src/internal/reflectlite transform
+FMT_PATHS = ./*.go builder cgo compiler interp loader src/device/arm src/examples src/machine src/os src/reflect src/runtime src/sync src/syscall src/internal/reflectlite transform
 fmt:
 	@gofmt -l -w $(FMT_PATHS)
 fmt-check:
 	@unformatted=$$(gofmt -l $(FMT_PATHS)); [ -z "$$unformatted" ] && exit 0; echo "Unformatted:"; for fn in $$unformatted; do echo "  $$fn"; done; exit 1


-gen-device: gen-device-avr gen-device-esp gen-device-nrf gen-device-sam gen-device-sifive gen-device-kendryte gen-device-nxp gen-device-rp
-ifneq ($(STM32), 0)
-gen-device: gen-device-stm32
-endif
+gen-device: gen-device-avr gen-device-esp gen-device-nrf gen-device-sam gen-device-sifive gen-device-stm32 gen-device-kendryte gen-device-nxp

 gen-device-avr:
 	@if [ ! -e lib/avr/README.md ]; then echo "Submodules have not been downloaded. Please download them using:\n  git submodule update --init"; exit 1; fi
@@ -124,7 +121,6 @@ build/gen-device-svd: ./tools/gen-device-svd/*.go

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

 gen-device-nrf: build/gen-device-svd
@@ -151,19 +147,16 @@ gen-device-stm32: build/gen-device-svd
 	./build/gen-device-svd -source=https://github.com/tinygo-org/stm32-svd lib/stm32-svd/svd src/device/stm32/
 	GO111MODULE=off $(GO) fmt ./src/device/stm32

-gen-device-rp: build/gen-device-svd
-	./build/gen-device-svd -source=https://github.com/posborne/cmsis-svd/tree/master/data/RaspberryPi lib/cmsis-svd/data/RaspberryPi/ src/device/rp/
-	GO111MODULE=off $(GO) fmt ./src/device/rp

 # Get LLVM sources.
-$(LLVM_PROJECTDIR)/llvm:
+$(LLVM_PROJECTDIR)/README.md:
 	git clone -b xtensa_release_11.0.0 --depth=1 https://github.com/tinygo-org/llvm-project $(LLVM_PROJECTDIR)
-llvm-source: $(LLVM_PROJECTDIR)/llvm
+llvm-source: $(LLVM_PROJECTDIR)/README.md

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

 # Build LLVM.
 $(LLVM_BUILDDIR): $(LLVM_BUILDDIR)/build.ninja
@@ -184,35 +177,27 @@ tinygo:
 	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) build -buildmode exe -o build/tinygo$(EXE) -tags byollvm -ldflags="-X main.gitSha1=`git rev-parse --short HEAD`" .

 test: wasi-libc
-	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test -v -buildmode exe -tags byollvm ./builder ./cgo ./compileopts ./compiler ./interp ./transform .
-
-TEST_PACKAGES = \
-	container/heap \
-	container/list \
-	container/ring \
-	crypto/des \
-	crypto/md5 \
-	crypto/sha1 \
-	crypto/sha256 \
-	crypto/sha512 \
-	encoding \
-	encoding/ascii85 \
-	encoding/base32 \
-	encoding/hex \
-	hash/adler32 \
-	hash/fnv \
-	hash/crc64 \
-	math \
-	math/cmplx \
-	testing \
-	text/scanner \
-	unicode/utf8 \
+	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test -v -buildmode exe -tags byollvm ./cgo ./compileopts ./compiler ./interp ./transform .

 # Test known-working standard library packages.
-# TODO: parallelize, and only show failing tests (no implied -v flag).
+# TODO: do this in one command, parallelize, and only show failing tests (no
+# implied -v flag).
 .PHONY: tinygo-test
 tinygo-test:
-	$(TINYGO) test $(TEST_PACKAGES)
+	$(TINYGO) test container/heap
+	$(TINYGO) test container/list
+	$(TINYGO) test container/ring
+	$(TINYGO) test crypto/des
+	$(TINYGO) test encoding/ascii85
+	$(TINYGO) test encoding/base32
+	$(TINYGO) test encoding/hex
+	$(TINYGO) test hash/adler32
+	$(TINYGO) test hash/fnv
+	$(TINYGO) test hash/crc64
+	$(TINYGO) test math
+	$(TINYGO) test math/cmplx
+	$(TINYGO) test text/scanner
+	$(TINYGO) test unicode/utf8

 .PHONY: smoketest
 smoketest:
@@ -236,10 +221,10 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/mcp3008
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/memstats
-	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=microbit            examples/microbit-blink
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=microbit-v2         examples/microbit-blink
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/pininterrupt
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/serial
@@ -268,14 +253,12 @@ smoketest:
 	@$(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=microbit-v2         examples/microbit-blink
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=microbit-v2-s113v7  examples/microbit-blink
-	@$(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
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=bluepill            examples/blinky1
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=reelboard           examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=reelboard           examples/blinky2
@@ -284,10 +267,6 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10056            examples/blinky2
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=pca10059            examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=pca10059            examples/blinky2
-	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=itsybitsy-m0        examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=feather-m0          examples/blinky1
@@ -296,6 +275,14 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=circuitplay-express examples/blinky1
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=stm32f4disco        examples/blinky1
+	@$(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
@@ -304,8 +291,6 @@ smoketest:
 	@$(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=grandcentral-m4     examples/blinky1
-	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=itsybitsy-m4        examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=feather-m4          examples/blinky1
@@ -322,8 +307,12 @@ smoketest:
 	@$(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
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=lgt92    examples/blinky1
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=x9pro               examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10056-s140v7     examples/blinky1
@@ -342,38 +331,20 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=feather-nrf52840  	examples/blinky1
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=feather-nrf52840-sense examples/blinky1
-	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=itsybitsy-nrf52840  examples/blinky1
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=qtpy                examples/serial
+	$(TINYGO) build -size short -o test.hex -target=qtpy  				examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=teensy40            examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=teensy36            examples/blinky1
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=nucleo-f722ze       examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=nucleo-l552ze       examples/blinky1
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=p1am-100            examples/blinky1
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=atsame54-xpro       examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=atsame54-xpro       examples/can
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=feather-m4-can      examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=feather-m4-can      examples/caninterrupt
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=arduino-nano33      examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=arduino-mkrwifi1010 examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=pico                examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=nano-33-ble         examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=nano-rp2040         examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=feather-rp2040 		examples/blinky1
-	@$(MD5SUM) test.hex
 	# test pwm
 	$(TINYGO) build -size short -o test.hex -target=itsybitsy-m0        examples/pwm
 	@$(MD5SUM) test.hex
@@ -381,32 +352,8 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=feather-m4          examples/pwm
 	@$(MD5SUM) test.hex
-ifneq ($(STM32), 0)
-	$(TINYGO) build -size short -o test.hex -target=bluepill            examples/blinky1
+	$(TINYGO) build -size short -o test.hex -target=pyportal            examples/pwm
 	@$(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=lgt92               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=nucleo-f722ze       examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=nucleo-l031k6       examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=nucleo-l432kc       examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=nucleo-l552ze       examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=stm32f4disco        examples/blinky1
-	@$(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=stm32f4disco-1      examples/pwm
-	@$(MD5SUM) test.hex
-endif
 ifneq ($(AVR), 0)
 	$(TINYGO) build -size short -o test.hex -target=atmega1284p         examples/serial
 	@$(MD5SUM) test.hex
@@ -416,10 +363,6 @@ ifneq ($(AVR), 0)
 	@$(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-mega1280    examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=arduino-mega1280    examples/pwm
-	@$(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
@@ -433,8 +376,6 @@ ifneq ($(XTENSA), 0)
 	$(TINYGO) build -size short -o test.bin -target=nodemcu             examples/blinky1
 	@$(MD5SUM) test.bin
 endif
-	$(TINYGO) build -size short -o test.bin -target=esp32c3           	examples/serial
-	@$(MD5SUM) test.bin
 	$(TINYGO) build -size short -o test.hex -target=hifive1b            examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=hifive1-qemu        examples/serial
@@ -448,16 +389,8 @@ endif
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10040 -opt=1     examples/blinky1
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=pca10040 -serial=none examples/echo
-	@$(MD5SUM) test.hex
 	$(TINYGO) build             -o test.nro -target=nintendoswitch      examples/serial
 	@$(MD5SUM) test.nro
-	$(TINYGO) build -size short -o test.hex -target=pca10040 -opt=0     ./testdata/stdlib.go
-	@$(MD5SUM) test.hex
-ifneq ($(OS),Windows_NT)
-	$(TINYGO) build -o test.elf -gc=leaking -scheduler=none examples/serial
-endif
-

 wasmtest:
 	$(GO) test ./tests/wasm
@@ -43,19 +43,15 @@ See the [getting started instructions](https://tinygo.org/getting-started/) for

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

-The following 70 microcontroller boards are currently supported:
+The following 55 microcontroller boards are currently supported:

 * [Adafruit Circuit Playground Bluefruit](https://www.adafruit.com/product/4333)
 * [Adafruit Circuit Playground Express](https://www.adafruit.com/product/3333)
 * [Adafruit CLUE](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 M4 CAN](https://www.adafruit.com/product/4759)
 * [Adafruit Feather nRF52840 Express](https://www.adafruit.com/product/4062)
-* [Adafruit Feather nRF52840 Sense](https://www.adafruit.com/product/4516)
-* [Adafruit Feather RP2040](https://www.adafruit.com/product/4884)
 * [Adafruit Feather STM32F405 Express](https://www.adafruit.com/product/4382)
-* [Adafruit Grand Central M4](https://www.adafruit.com/product/4064)
 * [Adafruit ItsyBitsy M0](https://www.adafruit.com/product/3727)
 * [Adafruit ItsyBitsy M4](https://www.adafruit.com/product/3800)
 * [Adafruit ItsyBitsy nRF52840](https://www.adafruit.com/product/4481)
@@ -66,15 +62,10 @@ The following 70 microcontroller boards are currently supported:
 * [Adafruit PyPortal](https://www.adafruit.com/product/4116)
 * [Adafruit QT Py](https://www.adafruit.com/product/4600)
 * [Adafruit Trinket M0](https://www.adafruit.com/product/3500)
-* [Arduino Mega 1280](https://www.arduino.cc/en/Main/arduinoBoardMega/)
 * [Arduino Mega 2560](https://store.arduino.cc/arduino-mega-2560-rev3)
 * [Arduino MKR1000](https://store.arduino.cc/arduino-mkr1000-wifi)
-* [Arduino MKR WiFi 1010](https://store.arduino.cc/usa/mkr-wifi-1010)
 * [Arduino Nano](https://store.arduino.cc/arduino-nano)
-* [Arduino Nano 33 BLE](https://store.arduino.cc/nano-33-ble)
-* [Arduino Nano 33 BLE Sense](https://store.arduino.cc/nano-33-ble-sense)
-* [Arduino Nano 33 IoT](https://store.arduino.cc/nano-33-iot)
-* [Arduino Nano RP2040 Connect](https://store.arduino.cc/nano-rp2040-connect)
+* [Arduino Nano33 IoT](https://store.arduino.cc/nano-33-iot)
 * [Arduino Uno](https://store.arduino.cc/arduino-uno-rev3)
 * [Arduino Zero](https://store.arduino.cc/usa/arduino-zero)
 * [BBC micro:bit](https://microbit.org/)
@@ -86,13 +77,11 @@ The following 70 microcontroller boards are currently supported:
 * [Game Boy Advance](https://en.wikipedia.org/wiki/Game_Boy_Advance)
 * [Makerdiary nRF52840-MDK](https://wiki.makerdiary.com/nrf52840-mdk/)
 * [Makerdiary nRF52840-MDK USB Dongle](https://wiki.makerdiary.com/nrf52840-mdk-usb-dongle/)
-* [Microchip SAM E54 Xplained Pro](https://www.microchip.com/developmenttools/productdetails/atsame54-xpro)
 * [nice!nano](https://docs.nicekeyboards.com/#/nice!nano/)
 * [Nintendo Switch](https://www.nintendo.com/switch/)
 * [Nordic Semiconductor PCA10031](https://www.nordicsemi.com/eng/Products/nRF51-Dongle)
 * [Nordic Semiconductor PCA10040](https://www.nordicsemi.com/eng/Products/Bluetooth-low-energy/nRF52-DK)
 * [Nordic Semiconductor PCA10056](https://www.nordicsemi.com/Software-and-Tools/Development-Kits/nRF52840-DK)
-* [Nordic Semiconductor pca10059](https://www.nordicsemi.com/Software-and-tools/Development-Kits/nRF52840-Dongle)
 * [Particle Argon](https://docs.particle.io/datasheets/wi-fi/argon-datasheet/)
 * [Particle Boron](https://docs.particle.io/datasheets/cellular/boron-datasheet/)
 * [Particle Xenon](https://docs.particle.io/datasheets/discontinued/xenon-datasheet/)
@@ -101,16 +90,12 @@ The following 70 microcontroller boards are currently supported:
 * [PJRC Teensy 3.6](https://www.pjrc.com/store/teensy36.html)
 * [PJRC Teensy 4.0](https://www.pjrc.com/store/teensy40.html)
 * [ProductivityOpen P1AM-100](https://facts-engineering.github.io/modules/P1AM-100/P1AM-100.html)
-* [Raspberry Pi Pico](https://www.raspberrypi.org/products/raspberry-pi-pico/)
-* [Raytac MDBT50Q-RX Dongle (with TinyUF2 bootloader)](https://www.adafruit.com/product/5199)
 * [Seeed Wio Terminal](https://www.seeedstudio.com/Wio-Terminal-p-4509.html)
 * [Seeed Seeeduino XIAO](https://www.seeedstudio.com/Seeeduino-XIAO-Arduino-Microcontroller-SAMD21-Cortex-M0+-p-4426.html)
 * [Seeed Sipeed MAix BiT](https://www.seeedstudio.com/Sipeed-MAix-BiT-for-RISC-V-AI-IoT-p-2872.html)
 * [SiFIve HiFive1](https://www.sifive.com/boards/hifive1)
 * [ST Micro "Nucleo" F103RB](https://www.st.com/en/evaluation-tools/nucleo-f103rb.html)
 * [ST Micro "Nucleo" F722ZE](https://www.st.com/en/evaluation-tools/nucleo-f722ze.html)
-* [ST Micro "Nucleo" L031K6](https://www.st.com/ja/evaluation-tools/nucleo-l031k6.html)
-* [ST Micro "Nucleo" L432KC](https://www.st.com/ja/evaluation-tools/nucleo-l432kc.html)
 * [ST Micro "Nucleo" L552ZE](https://www.st.com/en/evaluation-tools/nucleo-l552ze-q.html)
 * [ST Micro STM32F103XX "Bluepill"](https://stm32-base.org/boards/STM32F103C8T6-Blue-Pill)
 * [ST Micro STM32F407 "Discovery"](https://www.st.com/en/evaluation-tools/stm32f4discovery.html)
@@ -12,7 +12,7 @@ jobs:
  steps:
    - task: GoTool@0
      inputs:
-        version: '1.17'
+        version: '1.16'
    - checkout: self
      fetchDepth: 1
    - task: Cache@2
@@ -28,7 +28,7 @@ jobs:
    - task: CacheBeta@0
      displayName: Cache LLVM build
      inputs:
-        key: llvm-build-11-windows-v5
+        key: llvm-build-11-windows-v4
        path: llvm-build
    - task: Bash@3
      displayName: Build LLVM
@@ -4,21 +4,16 @@
 package builder

 import (
-	"crypto/sha512"
 	"debug/elf"
 	"encoding/binary"
-	"encoding/hex"
-	"encoding/json"
 	"errors"
 	"fmt"
 	"go/types"
-	"hash/crc32"
 	"io/ioutil"
-	"math/bits"
 	"os"
 	"path/filepath"
-	"runtime"
 	"sort"
+	"strconv"
 	"strings"

 	"github.com/tinygo-org/tinygo/compileopts"
@@ -41,35 +36,6 @@ type BuildResult struct {
 	// 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
-
-	// ImportPath is the import path of the main package. This is useful for
-	// correctly printing test results: the import path isn't always the same as
-	// the path listed on the command line.
-	ImportPath string
-}
-
-// packageAction is the struct that is serialized to JSON and hashed, to work as
-// a cache key of compiled packages. It should contain all the information that
-// goes into a compiled package to avoid using stale data.
-//
-// Right now it's still important to include a hash of every import, because a
-// dependency might have a public constant that this package uses and thus this
-// package will need to be recompiled if that constant changes. In the future,
-// the type data should be serialized to disk which can then be used as cache
-// key, avoiding the need for recompiling all dependencies when only the
-// implementation of an imported package changes.
-type packageAction struct {
-	ImportPath       string
-	CompilerVersion  int // compiler.Version
-	InterpVersion    int // interp.Version
-	LLVMVersion      string
-	Config           *compiler.Config
-	CFlags           []string
-	FileHashes       map[string]string // hash of every file that's part of the package
-	Imports          map[string]string // map from imported package to action ID hash
-	OptLevel         int               // LLVM optimization level (0-3)
-	SizeLevel        int               // LLVM optimization for size level (0-2)
-	UndefinedGlobals []string          // globals that are left as external globals (no initializer)
 }

 // Build performs a single package to executable Go build. It takes in a package
@@ -78,14 +44,7 @@ type packageAction struct {
 //
 // The error value may be of type *MultiError. Callers will likely want to check
 // for this case and print such errors individually.
-func Build(pkgName, outpath string, config *compileopts.Config, action func(BuildResult) error) error {
-	// Create a temporary directory for intermediary files.
-	dir, err := ioutil.TempDir("", "tinygo")
-	if err != nil {
-		return err
-	}
-	defer os.RemoveAll(dir)
-
+func Build(pkgName, outpath string, config *compileopts.Config, preAction func() error, action func(BuildResult) error) error {
 	compilerConfig := &compiler.Config{
 		Triple:          config.Triple(),
 		CPU:             config.CPU(),
@@ -100,8 +59,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		AutomaticStackSize: config.AutomaticStackSize(),
 		DefaultStackSize:   config.Target.DefaultStackSize,
 		NeedsStackObjects:  config.NeedsStackObjects(),
-		Debug:              true,
-		LLVMFeatures:       config.LLVMFeatures(),
+		Debug:              config.Debug(),
 	}

 	// Load the target machine, which is the LLVM object that contains all
@@ -124,285 +82,46 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		return err
 	}

-	// Create the *ssa.Program. This does not yet build the entire SSA of the
-	// program so it's pretty fast and doesn't need to be parallelized.
-	program := lprogram.LoadSSA()
+	// The slice of jobs that orchestrates most of the build.
+	// This is somewhat like an in-memory Makefile with each job being a
+	// Makefile target.
+	var jobs []*compileJob

-	// Add jobs to compile each package.
-	// Packages that have a cache hit will not be compiled again.
-	var packageJobs []*compileJob
-	packageBitcodePaths := make(map[string]string)
-	packageActionIDs := make(map[string]string)
-	optLevel, sizeLevel, _ := config.OptLevels()
-	for _, pkg := range lprogram.Sorted() {
-		pkg := pkg // necessary to avoid a race condition
-
-		var undefinedGlobals []string
-		for name := range config.Options.GlobalValues[pkg.Pkg.Path()] {
-			undefinedGlobals = append(undefinedGlobals, name)
-		}
-		sort.Strings(undefinedGlobals)
-
-		// Create a cache key: a hash from the action ID below that contains all
-		// the parameters for the build.
-		actionID := packageAction{
-			ImportPath:       pkg.ImportPath,
-			CompilerVersion:  compiler.Version,
-			InterpVersion:    interp.Version,
-			LLVMVersion:      llvm.Version,
-			Config:           compilerConfig,
-			CFlags:           pkg.CFlags,
-			FileHashes:       make(map[string]string, len(pkg.FileHashes)),
-			Imports:          make(map[string]string, len(pkg.Pkg.Imports())),
-			OptLevel:         optLevel,
-			SizeLevel:        sizeLevel,
-			UndefinedGlobals: undefinedGlobals,
-		}
-		for filePath, hash := range pkg.FileHashes {
-			actionID.FileHashes[filePath] = hex.EncodeToString(hash)
-		}
-		for _, imported := range pkg.Pkg.Imports() {
-			hash, ok := packageActionIDs[imported.Path()]
-			if !ok {
-				return fmt.Errorf("package %s imports %s but couldn't find dependency", pkg.ImportPath, imported.Path())
-			}
-			actionID.Imports[imported.Path()] = hash
-		}
-		buf, err := json.Marshal(actionID)
-		if err != nil {
-			panic(err) // shouldn't happen
-		}
-		hash := sha512.Sum512_224(buf)
-		packageActionIDs[pkg.ImportPath] = hex.EncodeToString(hash[:])
-
-		// Determine the path of the bitcode file (which is a serialized version
-		// of a LLVM module).
-		cacheDir := goenv.Get("GOCACHE")
-		if cacheDir == "off" {
-			// Use temporary build directory instead, effectively disabling the
-			// build cache.
-			cacheDir = dir
-		}
-		bitcodePath := filepath.Join(cacheDir, "pkg-"+hex.EncodeToString(hash[:])+".bc")
-		packageBitcodePaths[pkg.ImportPath] = bitcodePath
-
-		// Check whether this package has been compiled before, and if so don't
-		// compile it again.
-		if _, err := os.Stat(bitcodePath); err == nil {
-			// Already cached, don't recreate this package.
-			continue
-		}
-
-		// The package has not yet been compiled, so create a job to do so.
-		job := &compileJob{
-			description: "compile package " + pkg.ImportPath,
-			run: func(*compileJob) error {
-				// Compile AST to IR. The compiler.CompilePackage function will
-				// build the SSA as needed.
-				mod, errs := compiler.CompilePackage(pkg.ImportPath, pkg, program.Package(pkg.Pkg), machine, compilerConfig, config.DumpSSA())
-				if errs != nil {
-					return newMultiError(errs)
-				}
-				if err := llvm.VerifyModule(mod, llvm.PrintMessageAction); err != nil {
-					return errors.New("verification error after compiling package " + pkg.ImportPath)
-				}
-
-				// Erase all globals that are part of the undefinedGlobals list.
-				// This list comes from the -ldflags="-X pkg.foo=val" option.
-				// Instead of setting the value directly in the AST (which would
-				// mean the value, which may be a secret, is stored in the build
-				// cache), the global itself is left external (undefined) and is
-				// only set at the end of the compilation.
-				for _, name := range undefinedGlobals {
-					globalName := pkg.Pkg.Path() + "." + name
-					global := mod.NamedGlobal(globalName)
-					if global.IsNil() {
-						return errors.New("global not found: " + globalName)
-					}
-					name := global.Name()
-					newGlobal := llvm.AddGlobal(mod, global.Type().ElementType(), name+".tmp")
-					global.ReplaceAllUsesWith(newGlobal)
-					global.EraseFromParentAsGlobal()
-					newGlobal.SetName(name)
-				}
-
-				// Try to interpret package initializers at compile time.
-				// It may only be possible to do this partially, in which case
-				// it is completed after all IR files are linked.
-				pkgInit := mod.NamedFunction(pkg.Pkg.Path() + ".init")
-				if pkgInit.IsNil() {
-					panic("init not found for " + pkg.Pkg.Path())
-				}
-				err := interp.RunFunc(pkgInit, config.DumpSSA())
-				if err != nil {
-					return err
-				}
-				if err := llvm.VerifyModule(mod, llvm.PrintMessageAction); err != nil {
-					return errors.New("verification error after interpreting " + pkgInit.Name())
-				}
-
-				if sizeLevel >= 2 {
-					// Set the "optsize" attribute to make slightly smaller
-					// binaries at the cost of some performance.
-					kind := llvm.AttributeKindID("optsize")
-					attr := mod.Context().CreateEnumAttribute(kind, 0)
-					for fn := mod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
-						fn.AddFunctionAttr(attr)
-					}
-				}
-
-				// Run function passes for each function in the module.
-				// These passes are intended to be run on each function right
-				// after they're created to reduce IR size (and maybe also for
-				// cache locality to improve performance), but for now they're
-				// run here for each function in turn. Maybe this can be
-				// improved in the future.
-				builder := llvm.NewPassManagerBuilder()
-				defer builder.Dispose()
-				builder.SetOptLevel(optLevel)
-				builder.SetSizeLevel(sizeLevel)
-				funcPasses := llvm.NewFunctionPassManagerForModule(mod)
-				defer funcPasses.Dispose()
-				builder.PopulateFunc(funcPasses)
-				funcPasses.InitializeFunc()
-				for fn := mod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
-					if fn.IsDeclaration() {
-						continue
-					}
-					funcPasses.RunFunc(fn)
-				}
-				funcPasses.FinalizeFunc()
-
-				// Serialize the LLVM module as a bitcode file.
-				// Write to a temporary path that is renamed to the destination
-				// file to avoid race conditions with other TinyGo invocatiosn
-				// that might also be compiling this package at the same time.
-				f, err := ioutil.TempFile(filepath.Dir(bitcodePath), filepath.Base(bitcodePath))
-				if err != nil {
-					return err
-				}
-				if runtime.GOOS == "windows" {
-					// Work around a problem on Windows.
-					// For some reason, WriteBitcodeToFile causes TinyGo to
-					// exit with the following message:
-					//   LLVM ERROR: IO failure on output stream: Bad file descriptor
-					buf := llvm.WriteBitcodeToMemoryBuffer(mod)
-					defer buf.Dispose()
-					_, err = f.Write(buf.Bytes())
-				} else {
-					// Otherwise, write bitcode directly to the file (probably
-					// faster).
-					err = llvm.WriteBitcodeToFile(mod, f)
-				}
-				if err != nil {
-					// WriteBitcodeToFile doesn't produce a useful error on its
-					// own, so create a somewhat useful error message here.
-					return fmt.Errorf("failed to write bitcode for package %s to file %s", pkg.ImportPath, bitcodePath)
-				}
-				err = f.Close()
-				if err != nil {
-					return err
-				}
-				return os.Rename(f.Name(), bitcodePath)
-			},
-		}
-		packageJobs = append(packageJobs, job)
+	if preAction != nil {
+		// Add job to preAction.
+		jobs = append(jobs, &compileJob{
+			description: "preAction",
+			run:         preAction,
+		})
 	}

-	// Add job that links and optimizes all packages together.
+	// Add job to compile and optimize all Go files at once.
+	// TODO: parallelize this.
 	var mod llvm.Module
 	var stackSizeLoads []string
 	programJob := &compileJob{
-		description:  "link+optimize packages (LTO)",
-		dependencies: packageJobs,
-		run: func(*compileJob) error {
-			// Load and link all the bitcode files. This does not yet optimize
-			// anything, it only links the bitcode files together.
-			ctx := llvm.NewContext()
-			mod = ctx.NewModule("")
-			for _, pkg := range lprogram.Sorted() {
-				pkgMod, err := ctx.ParseBitcodeFile(packageBitcodePaths[pkg.ImportPath])
-				if err != nil {
-					return fmt.Errorf("failed to load bitcode file: %w", err)
-				}
-				err = llvm.LinkModules(mod, pkgMod)
-				if err != nil {
-					return fmt.Errorf("failed to link module: %w", err)
-				}
-			}
-
-			// Create runtime.initAll function that calls the runtime
-			// initializer of each package.
-			llvmInitFn := mod.NamedFunction("runtime.initAll")
-			llvmInitFn.SetLinkage(llvm.InternalLinkage)
-			llvmInitFn.SetUnnamedAddr(true)
-			llvmInitFn.Param(0).SetName("context")
-			llvmInitFn.Param(1).SetName("parentHandle")
-			block := mod.Context().AddBasicBlock(llvmInitFn, "entry")
-			irbuilder := mod.Context().NewBuilder()
-			defer irbuilder.Dispose()
-			irbuilder.SetInsertPointAtEnd(block)
-			i8ptrType := llvm.PointerType(mod.Context().Int8Type(), 0)
-			for _, pkg := range lprogram.Sorted() {
-				pkgInit := mod.NamedFunction(pkg.Pkg.Path() + ".init")
-				if pkgInit.IsNil() {
-					panic("init not found for " + pkg.Pkg.Path())
-				}
-				irbuilder.CreateCall(pkgInit, []llvm.Value{llvm.Undef(i8ptrType), llvm.Undef(i8ptrType)}, "")
-			}
-			irbuilder.CreateRetVoid()
-
-			// After linking, functions should (as far as possible) be set to
-			// private linkage or internal linkage. The compiler package marks
-			// non-exported functions by setting the visibility to hidden or
-			// (for thunks) to linkonce_odr linkage. Change the linkage here to
-			// internal to benefit much more from interprocedural optimizations.
-			for fn := mod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
-				if fn.Visibility() == llvm.HiddenVisibility {
-					fn.SetVisibility(llvm.DefaultVisibility)
-					fn.SetLinkage(llvm.InternalLinkage)
-				} else if fn.Linkage() == llvm.LinkOnceODRLinkage {
-					fn.SetLinkage(llvm.InternalLinkage)
-				}
-			}
-
-			// Do the same for globals.
-			for global := mod.FirstGlobal(); !global.IsNil(); global = llvm.NextGlobal(global) {
-				if global.Visibility() == llvm.HiddenVisibility {
-					global.SetVisibility(llvm.DefaultVisibility)
-					global.SetLinkage(llvm.InternalLinkage)
-				} else if global.Linkage() == llvm.LinkOnceODRLinkage {
-					global.SetLinkage(llvm.InternalLinkage)
-				}
-			}
-
-			if config.Options.PrintIR {
-				fmt.Println("; Generated LLVM IR:")
-				fmt.Println(mod.String())
-			}
-
-			// Run all optimization passes, which are much more effective now
-			// that the optimizer can see the whole program at once.
-			err := optimizeProgram(mod, config)
+		description: "compile Go files",
+		run: func() (err error) {
+			mod, err = compileWholeProgram(pkgName, config, compilerConfig, lprogram, machine)
 			if err != nil {
-				return err
+				return
 			}
-
 			// Make sure stack sizes are loaded from a separate section so they can be
 			// modified after linking.
 			if config.AutomaticStackSize() {
 				stackSizeLoads = transform.CreateStackSizeLoads(mod, config)
 			}
-			return nil
+			return
 		},
 	}
+	jobs = append(jobs, programJob)

 	// Check whether we only need to create an object file.
 	// If so, we don't need to link anything and will be finished quickly.
 	outext := filepath.Ext(outpath)
 	if outext == ".o" || outext == ".bc" || outext == ".ll" {
 		// Run jobs to produce the LLVM module.
-		err := runJobs(programJob)
+		err := runJobs(jobs)
 		if err != nil {
 			return err
 		}
@@ -429,13 +148,19 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	// First add all jobs necessary to build this object file, then afterwards
 	// run all jobs in parallel as far as possible.

+	// Create a temporary directory for intermediary files.
+	dir, err := ioutil.TempDir("", "tinygo")
+	if err != nil {
+		return err
+	}
+	defer os.RemoveAll(dir)
+
 	// Add job to write the output object file.
 	objfile := filepath.Join(dir, "main.o")
 	outputObjectFileJob := &compileJob{
 		description:  "generate output file",
 		dependencies: []*compileJob{programJob},
-		result:       objfile,
-		run: func(*compileJob) error {
+		run: func() error {
 			llvmBuf, err := machine.EmitToMemoryBuffer(mod, llvm.ObjectFile)
 			if err != nil {
 				return err
@@ -443,56 +168,99 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 			return ioutil.WriteFile(objfile, llvmBuf.Bytes(), 0666)
 		},
 	}
+	jobs = append(jobs, outputObjectFileJob)

 	// Prepare link command.
 	linkerDependencies := []*compileJob{outputObjectFileJob}
 	executable := filepath.Join(dir, "main")
 	tmppath := executable // final file
-	ldflags := append(config.LDFlags(), "-o", executable)
+	ldflags := append(config.LDFlags(), "-o", executable, objfile)

 	// Add compiler-rt dependency if needed. Usually this is a simple load from
 	// a cache.
 	if config.Target.RTLib == "compiler-rt" {
-		job, err := CompilerRT.load(config.Triple(), config.CPU(), dir)
+		path, job, err := CompilerRT.load(config.Triple(), config.CPU(), dir)
 		if err != nil {
 			return err
 		}
-		linkerDependencies = append(linkerDependencies, job)
+		if job != nil {
+			// The library was not loaded from cache so needs to be compiled
+			// (and then stored in the cache).
+			jobs = append(jobs, job.dependencies...)
+			jobs = append(jobs, job)
+			linkerDependencies = append(linkerDependencies, job)
+		}
+		ldflags = append(ldflags, path)
+	}
+
+	// Add libc dependency if needed.
+	root := goenv.Get("TINYGOROOT")
+	switch config.Target.Libc {
+	case "picolibc":
+		path, job, err := Picolibc.load(config.Triple(), config.CPU(), dir)
+		if err != nil {
+			return err
+		}
+		if job != nil {
+			// The library needs to be compiled (cache miss).
+			jobs = append(jobs, job.dependencies...)
+			jobs = append(jobs, job)
+			linkerDependencies = append(linkerDependencies, job)
+		}
+		ldflags = append(ldflags, path)
+	case "wasi-libc":
+		path := filepath.Join(root, "lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a")
+		if _, err := os.Stat(path); os.IsNotExist(err) {
+			return errors.New("could not find wasi-libc, perhaps you need to run `make wasi-libc`?")
+		}
+		ldflags = append(ldflags, path)
+	case "":
+		// no library specified, so nothing to do
+	default:
+		return fmt.Errorf("unknown libc: %s", config.Target.Libc)
 	}

 	// Add jobs to compile extra files. These files are in C or assembly and
 	// contain things like the interrupt vector table and low level operations
 	// such as stack switching.
-	root := goenv.Get("TINYGOROOT")
-	for _, path := range config.ExtraFiles() {
+	for i, path := range config.ExtraFiles() {
 		abspath := filepath.Join(root, path)
+		outpath := filepath.Join(dir, "extra-"+strconv.Itoa(i)+"-"+filepath.Base(path)+".o")
 		job := &compileJob{
 			description: "compile extra file " + path,
-			run: func(job *compileJob) error {
-				result, err := compileAndCacheCFile(abspath, dir, config.CFlags(), config.Options.PrintCommands)
-				job.result = result
-				return err
+			run: func() error {
+				err := runCCompiler(config.Target.Compiler, append(config.CFlags(), "-c", "-o", outpath, abspath)...)
+				if err != nil {
+					return &commandError{"failed to build", path, err}
+				}
+				return nil
 			},
 		}
+		jobs = append(jobs, job)
 		linkerDependencies = append(linkerDependencies, job)
+		ldflags = append(ldflags, outpath)
 	}

 	// Add jobs to compile C files in all packages. This is part of CGo.
 	// TODO: do this as part of building the package to be able to link the
 	// bitcode files together.
-	for _, pkg := range lprogram.Sorted() {
-		pkg := pkg
-		for _, filename := range pkg.CFiles {
-			abspath := filepath.Join(pkg.Dir, filename)
+	for i, pkg := range lprogram.Sorted() {
+		for j, filename := range pkg.CFiles {
+			file := filepath.Join(pkg.Dir, filename)
+			outpath := filepath.Join(dir, "pkg"+strconv.Itoa(i)+"."+strconv.Itoa(j)+"-"+filepath.Base(file)+".o")
 			job := &compileJob{
-				description: "compile CGo file " + abspath,
-				run: func(job *compileJob) error {
-					result, err := compileAndCacheCFile(abspath, dir, pkg.CFlags, config.Options.PrintCommands)
-					job.result = result
-					return err
+				description: "compile CGo file " + file,
+				run: func() error {
+					err := runCCompiler(config.Target.Compiler, append(config.CFlags(), "-c", "-o", outpath, file)...)
+					if err != nil {
+						return &commandError{"failed to build", file, err}
+					}
+					return nil
 				},
 			}
+			jobs = append(jobs, job)
 			linkerDependencies = append(linkerDependencies, job)
+			ldflags = append(ldflags, outpath)
 		}
 	}

@@ -502,75 +270,12 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		ldflags = append(ldflags, lprogram.LDFlags...)
 	}

-	// Add libc dependency if needed.
-	switch config.Target.Libc {
-	case "picolibc":
-		job, err := Picolibc.load(config.Triple(), config.CPU(), dir)
-		if err != nil {
-			return err
-		}
-		linkerDependencies = append(linkerDependencies, job)
-	case "wasi-libc":
-		path := filepath.Join(root, "lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a")
-		if _, err := os.Stat(path); os.IsNotExist(err) {
-			return errors.New("could not find wasi-libc, perhaps you need to run `make wasi-libc`?")
-		}
-		job := dummyCompileJob(path)
-		linkerDependencies = append(linkerDependencies, job)
-	case "":
-		// no library specified, so nothing to do
-	default:
-		return fmt.Errorf("unknown libc: %s", config.Target.Libc)
-	}
-
-	// Strip debug information with -no-debug.
-	if !config.Debug() {
-		for _, tag := range config.BuildTags() {
-			if tag == "baremetal" {
-				// Don't use -no-debug on baremetal targets. It makes no sense:
-				// the debug information isn't flashed to the device anyway.
-				return fmt.Errorf("stripping debug information is unnecessary for baremetal targets")
-			}
-		}
-		if config.Target.Linker == "wasm-ld" {
-			// Don't just strip debug information, also compress relocations
-			// while we're at it. Relocations can only be compressed when debug
-			// information is stripped.
-			ldflags = append(ldflags, "--strip-debug", "--compress-relocations")
-		} else {
-			switch config.GOOS() {
-			case "linux":
-				// Either real linux or an embedded system (like AVR) that
-				// pretends to be Linux. It's a ELF linker wrapped by GCC in any
-				// case.
-				ldflags = append(ldflags, "-Wl,--strip-debug")
-			case "darwin":
-				// MacOS (darwin) doesn't have a linker flag to strip debug
-				// information. Apple expects you to use the strip command
-				// instead.
-				return errors.New("cannot remove debug information: MacOS doesn't suppor this linker flag")
-			default:
-				// Other OSes may have different flags.
-				return errors.New("cannot remove debug information: unknown OS: " + config.GOOS())
-			}
-		}
-	}
-
 	// Create a linker job, which links all object files together and does some
 	// extra stuff that can only be done after linking.
-	linkJob := &compileJob{
+	jobs = append(jobs, &compileJob{
 		description:  "link",
 		dependencies: linkerDependencies,
-		run: func(job *compileJob) error {
-			for _, dependency := range job.dependencies {
-				if dependency.result == "" {
-					return errors.New("dependency without result: " + dependency.description)
-				}
-				ldflags = append(ldflags, dependency.result)
-			}
-			if config.Options.PrintCommands != nil {
-				config.Options.PrintCommands(config.Target.Linker, ldflags...)
-			}
+		run: func() error {
 			err = link(config.Target.Linker, ldflags...)
 			if err != nil {
 				return &commandError{"failed to link", executable, err}
@@ -587,8 +292,6 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 					return err
 				}
 			}
-
-			// Apply ELF patches
 			if config.AutomaticStackSize() {
 				// Modify the .tinygo_stacksizes section that contains a stack size
 				// for each goroutine.
@@ -597,13 +300,6 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 					return fmt.Errorf("could not modify stack sizes: %w", err)
 				}
 			}
-			if config.RP2040BootPatch() {
-				// Patch the second stage bootloader CRC into the .boot2 section
-				err = patchRP2040BootCRC(executable)
-				if err != nil {
-					return fmt.Errorf("could not patch RP2040 second stage boot loader: %w", err)
-				}
-			}

 			if config.Options.PrintSizes == "short" || config.Options.PrintSizes == "full" {
 				sizes, err := loadProgramSize(executable)
@@ -631,12 +327,12 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil

 			return nil
 		},
-	}
+	})

 	// Run all jobs to compile and link the program.
 	// Do this now (instead of after elf-to-hex and similar conversions) as it
 	// is simpler and cannot be parallelized.
-	err = runJobs(linkJob)
+	err = runJobs(jobs)
 	if err != nil {
 		return err
 	}
@@ -661,7 +357,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		if err != nil {
 			return err
 		}
-	case "esp32", "esp32c3", "esp8266":
+	case "esp32", "esp8266":
 		// Special format for the ESP family of chips (parsed by the ROM
 		// bootloader).
 		tmppath = filepath.Join(dir, "main"+outext)
@@ -669,59 +365,44 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		if err != nil {
 			return err
 		}
-	case "nrf-dfu":
-		// special format for nrfutil for Nordic chips
-		tmphexpath := filepath.Join(dir, "main.hex")
-		err := objcopy(executable, tmphexpath, "hex")
-		if err != nil {
-			return err
-		}
-		tmppath = filepath.Join(dir, "main"+outext)
-		err = makeDFUFirmwareImage(config.Options, tmphexpath, tmppath)
-		if err != nil {
-			return err
-		}
 	default:
 		return fmt.Errorf("unknown output binary format: %s", outputBinaryFormat)
 	}
 	return action(BuildResult{
-		Binary:     tmppath,
-		MainDir:    lprogram.MainPkg().Dir,
-		ImportPath: lprogram.MainPkg().ImportPath,
+		Binary:  tmppath,
+		MainDir: lprogram.MainPkg().Dir,
 	})
 }

-// optimizeProgram runs a series of optimizations and transformations that are
-// needed to convert a program to its final form. Some transformations are not
-// optional and must be run as the compiler expects them to run.
-func optimizeProgram(mod llvm.Module, config *compileopts.Config) error {
+// compileWholeProgram compiles the entire *loader.Program to a LLVM module and
+// applies most necessary optimizations and transformations.
+func compileWholeProgram(pkgName string, config *compileopts.Config, compilerConfig *compiler.Config, lprogram *loader.Program, machine llvm.TargetMachine) (llvm.Module, error) {
+	// Compile AST to IR.
+	mod, errs := compiler.CompileProgram(lprogram, machine, compilerConfig, config.DumpSSA())
+	if errs != nil {
+		return mod, newMultiError(errs)
+	}
+
+	if config.Options.PrintIR {
+		fmt.Println("; Generated LLVM IR:")
+		fmt.Println(mod.String())
+	}
+	if err := llvm.VerifyModule(mod, llvm.PrintMessageAction); err != nil {
+		return mod, errors.New("verification error after IR construction")
+	}
+
 	err := interp.Run(mod, config.DumpSSA())
 	if err != nil {
-		return err
+		return mod, err
 	}
-	if config.VerifyIR() {
-		// Only verify if we really need it.
-		// The IR has already been verified before writing the bitcode to disk
-		// and the interp function above doesn't need to do a lot as most of the
-		// package initializers have already run. Additionally, verifying this
-		// linked IR is _expensive_ because dead code hasn't been removed yet,
-		// easily costing a few hundred milliseconds. Therefore, only do it when
-		// specifically requested.
-		if err := llvm.VerifyModule(mod, llvm.PrintMessageAction); err != nil {
-			return errors.New("verification error after interpreting runtime.initAll")
-		}
+	if err := llvm.VerifyModule(mod, llvm.PrintMessageAction); err != nil {
+		return mod, errors.New("verification error after interpreting runtime.initAll")
 	}

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

-	// Insert values from -ldflags="-X ..." into the IR.
-	err = setGlobalValues(mod, config.Options.GlobalValues)
-	if err != nil {
-		return err
-	}
-
 	// Browsers cannot handle external functions that have type i64 because it
 	// cannot be represented exactly in JavaScript (JS only has doubles). To
 	// keep functions interoperable, pass int64 types as pointers to
@@ -730,19 +411,39 @@ func optimizeProgram(mod llvm.Module, config *compileopts.Config) error {
 	if config.WasmAbi() == "js" {
 		err := transform.ExternalInt64AsPtr(mod)
 		if err != nil {
-			return err
+			return mod, err
 		}
 	}

 	// Optimization levels here are roughly the same as Clang, but probably not
 	// exactly.
-	optLevel, sizeLevel, inlinerThreshold := config.OptLevels()
-	errs := transform.Optimize(mod, config, optLevel, sizeLevel, inlinerThreshold)
+	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 "1":
+		errs = transform.Optimize(mod, config, 1, 0, 0) // -O1
+	case "2":
+		errs = transform.Optimize(mod, config, 2, 0, 225) // -O2
+	case "s":
+		errs = transform.Optimize(mod, config, 2, 1, 225) // -Os
+	case "z":
+		errs = transform.Optimize(mod, config, 2, 2, 5) // -Oz, default
+	default:
+		errs = []error{errors.New("unknown optimization level: -opt=" + config.Options.Opt)}
+	}
 	if len(errs) > 0 {
-		return newMultiError(errs)
+		return mod, newMultiError(errs)
 	}
 	if err := llvm.VerifyModule(mod, llvm.PrintMessageAction); err != nil {
-		return errors.New("verification failure after LLVM optimization passes")
+		return mod, errors.New("verification failure after LLVM optimization passes")
 	}

 	// LLVM 11 by default tries to emit tail calls (even with the target feature
@@ -756,72 +457,7 @@ func optimizeProgram(mod llvm.Module, config *compileopts.Config) error {
 		transform.DisableTailCalls(mod)
 	}

-	return nil
-}
-
-// setGlobalValues sets the global values from the -ldflags="-X ..." compiler
-// option in the given module. An error may be returned if the global is not of
-// the expected type.
-func setGlobalValues(mod llvm.Module, globals map[string]map[string]string) error {
-	var pkgPaths []string
-	for pkgPath := range globals {
-		pkgPaths = append(pkgPaths, pkgPath)
-	}
-	sort.Strings(pkgPaths)
-	for _, pkgPath := range pkgPaths {
-		pkg := globals[pkgPath]
-		var names []string
-		for name := range pkg {
-			names = append(names, name)
-		}
-		sort.Strings(names)
-		for _, name := range names {
-			value := pkg[name]
-			globalName := pkgPath + "." + name
-			global := mod.NamedGlobal(globalName)
-			if global.IsNil() || !global.Initializer().IsNil() {
-				// The global either does not exist (optimized away?) or has
-				// some value, in which case it has already been initialized at
-				// package init time.
-				continue
-			}
-
-			// A strin is a {ptr, len} pair. We need these types to build the
-			// initializer.
-			initializerType := global.Type().ElementType()
-			if initializerType.TypeKind() != llvm.StructTypeKind || initializerType.StructName() == "" {
-				return fmt.Errorf("%s: not a string", globalName)
-			}
-			elementTypes := initializerType.StructElementTypes()
-			if len(elementTypes) != 2 {
-				return fmt.Errorf("%s: not a string", globalName)
-			}
-
-			// Create a buffer for the string contents.
-			bufInitializer := mod.Context().ConstString(value, false)
-			buf := llvm.AddGlobal(mod, bufInitializer.Type(), ".string")
-			buf.SetInitializer(bufInitializer)
-			buf.SetAlignment(1)
-			buf.SetUnnamedAddr(true)
-			buf.SetLinkage(llvm.PrivateLinkage)
-
-			// Create the string value, which is a {ptr, len} pair.
-			zero := llvm.ConstInt(mod.Context().Int32Type(), 0, false)
-			ptr := llvm.ConstGEP(buf, []llvm.Value{zero, zero})
-			if ptr.Type() != elementTypes[0] {
-				return fmt.Errorf("%s: not a string", globalName)
-			}
-			length := llvm.ConstInt(elementTypes[1], uint64(len(value)), false)
-			initializer := llvm.ConstNamedStruct(initializerType, []llvm.Value{
-				ptr,
-				length,
-			})
-
-			// Set the initializer. No initializer should be set at this point.
-			global.SetInitializer(initializer)
-		}
-	}
-	return nil
+	return mod, nil
 }

 // functionStackSizes keeps stack size information about a single function
@@ -950,7 +586,30 @@ func determineStackSizes(mod llvm.Module, executable string) ([]string, map[stri
 // stack size information. Before this modification, all stack sizes in the
 // section assume the default stack size (which is relatively big).
 func modifyStackSizes(executable string, stackSizeLoads []string, stackSizes map[string]functionStackSize) error {
-	data, fileHeader, err := getElfSectionData(executable, ".tinygo_stacksizes")
+	fp, err := os.OpenFile(executable, os.O_RDWR, 0)
+	if err != nil {
+		return err
+	}
+	defer fp.Close()
+
+	elfFile, err := elf.NewFile(fp)
+	if err != nil {
+		return err
+	}
+
+	section := elfFile.Section(".tinygo_stacksizes")
+	if section == nil {
+		return errors.New("could not find .tinygo_stacksizes section")
+	}
+
+	if section.Size != section.FileSize {
+		// Sanity check.
+		return fmt.Errorf("expected .tinygo_stacksizes to have identical size and file size, got %d and %d", section.Size, section.FileSize)
+	}
+
+	// Read all goroutine stack sizes.
+	data := make([]byte, section.Size)
+	_, err = fp.ReadAt(data, int64(section.Offset))
 	if err != nil {
 		return err
 	}
@@ -972,19 +631,15 @@ func modifyStackSizes(executable string, stackSizeLoads []string, stackSizes map
 		if fn.stackSizeType == stacksize.Bounded {
 			stackSize := uint32(fn.stackSize)

-			// Add stack size used by interrupts.
-			switch fileHeader.Machine {
-			case elf.EM_ARM:
-				if stackSize%8 != 0 {
-					// If the stack isn't a multiple of 8, it means the leaf
-					// function with the biggest stack depth doesn't have an aligned
-					// stack. If the STKALIGN flag is set (which it is by default)
-					// the interrupt controller will forcibly align the stack before
-					// storing in-use registers. This will thus overwrite one word
-					// past the end of the stack (off-by-one).
-					stackSize += 4
-				}
+			// Adding 4 for the stack canary. Even though the size may be
+			// automatically determined, stack overflow checking is still
+			// important as the stack size cannot be determined for all
+			// goroutines.
+			stackSize += 4

+			// Add stack size used by interrupts.
+			switch elfFile.Machine {
+			case elf.EM_ARM:
 				// On Cortex-M (assumed here), this stack size is 8 words or 32
 				// bytes. This is only to store the registers that the interrupt
 				// may modify, the interrupt will switch to the interrupt stack
@@ -992,14 +647,6 @@ func modifyStackSizes(executable string, stackSizeLoads []string, stackSizes map
 				// Some background:
 				// https://interrupt.memfault.com/blog/cortex-m-rtos-context-switching
 				stackSize += 32
-
-				// Adding 4 for the stack canary, and another 4 to keep the
-				// stack aligned. Even though the size may be automatically
-				// determined, stack overflow checking is still important as the
-				// stack size cannot be determined for all goroutines.
-				stackSize += 8
-			default:
-				return fmt.Errorf("unknown architecture: %s", fileHeader.Machine.String())
 			}

 			// Finally write the stack size to the binary.
@@ -1007,7 +654,13 @@ func modifyStackSizes(executable string, stackSizeLoads []string, stackSizes map
 		}
 	}

-	return replaceElfSection(executable, ".tinygo_stacksizes", data)
+	// Write back the modified stack sizes.
+	_, err = fp.WriteAt(data, int64(section.Offset))
+	if err != nil {
+		return err
+	}
+
+	return nil
 }

 // printStacks prints the maximum stack depth for functions that are started as
@@ -1039,41 +692,3 @@ func printStacks(calculatedStacks []string, stackSizes map[string]functionStackS
 		}
 	}
 }
-
-// RP2040 second stage bootloader CRC32 calculation
-//
-// Spec: https://datasheets.raspberrypi.org/rp2040/rp2040-datasheet.pdf
-// Section: 2.8.1.3.1. Checksum
-func patchRP2040BootCRC(executable string) error {
-	bytes, _, err := getElfSectionData(executable, ".boot2")
-	if err != nil {
-		return err
-	}
-
-	if len(bytes) != 256 {
-		return fmt.Errorf("rp2040 .boot2 section must be exactly 256 bytes")
-	}
-
-	// From the 'official' RP2040 checksum script:
-	//
-	//  Our bootrom CRC32 is slightly bass-ackward but it's
-	//  best to work around for now (FIXME)
-	//  100% worth it to save two Thumb instructions
-	revBytes := make([]byte, len(bytes))
-	for i := range bytes {
-		revBytes[i] = bits.Reverse8(bytes[i])
-	}
-
-	// crc32.Update does an initial negate and negates the
-	// result, so to meet RP2040 spec, pass 0x0 as initial
-	// hash and negate returned value.
-	//
-	// Note: checksum is over 252 bytes (256 - 4)
-	hash := bits.Reverse32(crc32.Update(0x0, crc32.IEEETable, revBytes[:252]) ^ 0xFFFFFFFF)
-
-	// Write the CRC to the end of the bootloader.
-	binary.LittleEndian.PutUint32(bytes[252:], hash)
-
-	// Update the .boot2 section to included the CRC
-	return replaceElfSection(executable, ".boot2", bytes)
-}
@@ -1,313 +0,0 @@
-package builder
-
-// This file implements a wrapper around the C compiler (Clang) which uses a
-// build cache.
-
-import (
-	"crypto/sha512"
-	"encoding/hex"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"sort"
-	"strings"
-	"unicode"
-
-	"github.com/tinygo-org/tinygo/goenv"
-	"tinygo.org/x/go-llvm"
-)
-
-// compileAndCacheCFile compiles a C or assembly file using a build cache.
-// Compiling the same file again (if nothing changed, including included header
-// files) the output is loaded from the build cache instead.
-//
-// Its operation is a bit complex (more complex than Go package build caching)
-// because the list of file dependencies is only known after the file is
-// compiled. However, luckily compilers have a flag to write a list of file
-// dependencies in Makefile syntax which can be used for caching.
-//
-// Because of this complexity, every file has in fact two cached build outputs:
-// the file itself, and the list of dependencies. Its operation is as follows:
-//
-//   depfile = hash(path, compiler, cflags, ...)
-//   if depfile exists:
-//     outfile = hash of all files and depfile name
-//     if outfile exists:
-//       # cache hit
-//       return outfile
-//   # cache miss
-//   tmpfile = compile file
-//   read dependencies (side effect of compile)
-//   write depfile
-//   outfile = hash of all files and depfile name
-//   rename tmpfile to outfile
-//
-// There are a few edge cases that are not handled:
-// - If a file is added to an include path, that file may be included instead of
-//   some other file. This would be fixed by also including lookup failures in the
-//   dependencies file, but I'm not aware of a compiler which does that.
-// - The Makefile syntax that compilers output has issues, see readDepFile for
-//   details.
-// - A header file may be changed to add/remove an include. This invalidates the
-//   depfile but without invalidating its name. For this reason, the depfile is
-//   written on each new compilation (even when it seems unnecessary). However, it
-//   could in rare cases lead to a stale file fetched from the cache.
-func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands func(string, ...string)) (string, error) {
-	// Hash input file.
-	fileHash, err := hashFile(abspath)
-	if err != nil {
-		return "", err
-	}
-
-	// Create cache key for the dependencies file.
-	buf, err := json.Marshal(struct {
-		Path        string
-		Hash        string
-		Flags       []string
-		LLVMVersion string
-	}{
-		Path:        abspath,
-		Hash:        fileHash,
-		Flags:       cflags,
-		LLVMVersion: llvm.Version,
-	})
-	if err != nil {
-		panic(err) // shouldn't happen
-	}
-	depfileNameHashBuf := sha512.Sum512_224(buf)
-	depfileNameHash := hex.EncodeToString(depfileNameHashBuf[:])
-
-	// Load dependencies file, if possible.
-	depfileName := "dep-" + depfileNameHash + ".json"
-	depfileCachePath := filepath.Join(goenv.Get("GOCACHE"), depfileName)
-	depfileBuf, err := ioutil.ReadFile(depfileCachePath)
-	var dependencies []string // sorted list of dependency paths
-	if err == nil {
-		// There is a dependency file, that's great!
-		// Parse it first.
-		err := json.Unmarshal(depfileBuf, &dependencies)
-		if err != nil {
-			return "", fmt.Errorf("could not parse dependencies JSON: %w", err)
-		}
-
-		// Obtain hashes of all the files listed as a dependency.
-		outpath, err := makeCFileCachePath(dependencies, depfileNameHash)
-		if err == nil {
-			if _, err := os.Stat(outpath); err == nil {
-				return outpath, nil
-			} else if !os.IsNotExist(err) {
-				return "", err
-			}
-		}
-	} else if !os.IsNotExist(err) {
-		// expected either nil or IsNotExist
-		return "", err
-	}
-
-	objTmpFile, err := ioutil.TempFile(goenv.Get("GOCACHE"), "tmp-*.o")
-	if err != nil {
-		return "", err
-	}
-	objTmpFile.Close()
-	depTmpFile, err := ioutil.TempFile(tmpdir, "dep-*.d")
-	if err != nil {
-		return "", err
-	}
-	depTmpFile.Close()
-	flags := append([]string{}, cflags...)                                   // copy cflags
-	flags = append(flags, "-MD", "-MV", "-MTdeps", "-MF", depTmpFile.Name()) // autogenerate dependencies
-	flags = append(flags, "-c", "-o", objTmpFile.Name(), abspath)
-	if strings.ToLower(filepath.Ext(abspath)) == ".s" {
-		// If this is an assembly file (.s or .S, lowercase or uppercase), then
-		// we'll need to add -Qunused-arguments because many parameters are
-		// relevant to C, not assembly. And with -Werror, having meaningless
-		// flags (for the assembler) is a compiler error.
-		flags = append(flags, "-Qunused-arguments")
-	}
-	if printCommands != nil {
-		printCommands("clang", flags...)
-	}
-	err = runCCompiler(flags...)
-	if err != nil {
-		return "", &commandError{"failed to build", abspath, err}
-	}
-
-	// Create sorted and uniqued slice of dependencies.
-	dependencyPaths, err := readDepFile(depTmpFile.Name())
-	if err != nil {
-		return "", err
-	}
-	dependencyPaths = append(dependencyPaths, abspath) // necessary for .s files
-	dependencySet := make(map[string]struct{}, len(dependencyPaths))
-	var dependencySlice []string
-	for _, path := range dependencyPaths {
-		if _, ok := dependencySet[path]; ok {
-			continue
-		}
-		dependencySet[path] = struct{}{}
-		dependencySlice = append(dependencySlice, path)
-	}
-	sort.Strings(dependencySlice)
-
-	// Write dependencies file.
-	f, err := ioutil.TempFile(filepath.Dir(depfileCachePath), depfileName)
-	if err != nil {
-		return "", err
-	}
-
-	buf, err = json.MarshalIndent(dependencySlice, "", "\t")
-	if err != nil {
-		panic(err) // shouldn't happen
-	}
-	_, err = f.Write(buf)
-	if err != nil {
-		return "", err
-	}
-	err = f.Close()
-	if err != nil {
-		return "", err
-	}
-	err = os.Rename(f.Name(), depfileCachePath)
-	if err != nil {
-		return "", err
-	}
-
-	// Move temporary object file to final location.
-	outpath, err := makeCFileCachePath(dependencySlice, depfileNameHash)
-	if err != nil {
-		return "", err
-	}
-	err = os.Rename(objTmpFile.Name(), outpath)
-	if err != nil {
-		return "", err
-	}
-
-	return outpath, nil
-}
-
-// Create a cache path (a path in GOCACHE) to store the output of a compiler
-// job. This path is based on the dep file name (which is a hash of metadata
-// including compiler flags) and the hash of all input files in the paths slice.
-func makeCFileCachePath(paths []string, depfileNameHash string) (string, error) {
-	// Hash all input files.
-	fileHashes := make(map[string]string, len(paths))
-	for _, path := range paths {
-		hash, err := hashFile(path)
-		if err != nil {
-			return "", err
-		}
-		fileHashes[path] = hash
-	}
-
-	// Calculate a cache key based on the above hashes.
-	buf, err := json.Marshal(struct {
-		DepfileHash string
-		FileHashes  map[string]string
-	}{
-		DepfileHash: depfileNameHash,
-		FileHashes:  fileHashes,
-	})
-	if err != nil {
-		panic(err) // shouldn't happen
-	}
-	outFileNameBuf := sha512.Sum512_224(buf)
-	cacheKey := hex.EncodeToString(outFileNameBuf[:])
-
-	outpath := filepath.Join(goenv.Get("GOCACHE"), "obj-"+cacheKey+".o")
-	return outpath, nil
-}
-
-// hashFile hashes the given file path and returns the hash as a hex string.
-func hashFile(path string) (string, error) {
-	f, err := os.Open(path)
-	if err != nil {
-		return "", fmt.Errorf("failed to hash file: %w", err)
-	}
-	defer f.Close()
-	fileHasher := sha512.New512_224()
-	_, err = io.Copy(fileHasher, f)
-	if err != nil {
-		return "", fmt.Errorf("failed to hash file: %w", err)
-	}
-	return hex.EncodeToString(fileHasher.Sum(nil)), nil
-}
-
-// readDepFile reads a dependency file in NMake (Visual Studio make) format. The
-// file is assumed to have a single target named deps.
-//
-// There are roughly three make syntax variants:
-// - BSD make, which doesn't support any escaping. This means that many special
-//   characters are not supported in file names.
-// - GNU make, which supports escaping using a backslash but when it fails to
-//   find a file it tries to fall back with the literal path name (to match BSD
-//   make).
-// - NMake (Visual Studio) and Jom, which simply quote the string if there are
-//   any weird characters.
-// Clang supports two variants: a format that's a compromise between BSD and GNU
-// make (and is buggy to match GCC which is equally buggy), and NMake/Jom, which
-// is at least somewhat sane. This last format isn't perfect either: it does not
-// correctly handle filenames with quote marks in them. Those are generally not
-// allowed on Windows, but of course can be used on POSIX like systems. Still,
-// it's the most sane of any of the formats so readDepFile will use that format.
-func readDepFile(filename string) ([]string, error) {
-	buf, err := ioutil.ReadFile(filename)
-	if err != nil {
-		return nil, err
-	}
-	if len(buf) == 0 {
-		return nil, nil
-	}
-	return parseDepFile(string(buf))
-}
-
-func parseDepFile(s string) ([]string, error) {
-	// This function makes no attempt at parsing anything other than Clang -MD
-	// -MV output.
-
-	// For Windows: replace CRLF with LF to make the logic below simpler.
-	s = strings.ReplaceAll(s, "\r\n", "\n")
-
-	// Collapse all lines ending in a backslash. These backslashes are really
-	// just a way to continue a line without making very long lines.
-	s = strings.ReplaceAll(s, "\\\n", " ")
-
-	// Only use the first line, which is expected to begin with "deps:".
-	line := strings.SplitN(s, "\n", 2)[0]
-	if !strings.HasPrefix(line, "deps:") {
-		return nil, errors.New("readDepFile: expected 'deps:' prefix")
-	}
-	line = strings.TrimSpace(line[len("deps:"):])
-
-	var deps []string
-	for line != "" {
-		if line[0] == '"' {
-			// File path is quoted. Path ends with double quote.
-			// This does not handle double quotes in path names, which is a
-			// problem on non-Windows systems.
-			line = line[1:]
-			end := strings.IndexByte(line, '"')
-			if end < 0 {
-				return nil, errors.New("readDepFile: path is incorrectly quoted")
-			}
-			dep := line[:end]
-			line = strings.TrimSpace(line[end+1:])
-			deps = append(deps, dep)
-		} else {
-			// File path is not quoted. Path ends in space or EOL.
-			end := strings.IndexFunc(line, unicode.IsSpace)
-			if end < 0 {
-				// last dependency
-				deps = append(deps, line)
-				break
-			}
-			dep := line[:end]
-			line = strings.TrimSpace(line[end:])
-			deps = append(deps, dep)
-		}
-	}
-	return deps, nil
-}
@@ -1,33 +0,0 @@
-package builder
-
-import (
-	"reflect"
-	"testing"
-)
-
-func TestSplitDepFile(t *testing.T) {
-	for i, tc := range []struct {
-		in  string
-		out []string
-	}{
-		{`deps: foo bar`, []string{"foo", "bar"}},
-		{`deps: foo "bar"`, []string{"foo", "bar"}},
-		{`deps: "foo" bar`, []string{"foo", "bar"}},
-		{`deps: "foo bar"`, []string{"foo bar"}},
-		{`deps: "foo bar" `, []string{"foo bar"}},
-		{"deps: foo\nbar", []string{"foo"}},
-		{"deps: foo \\\nbar", []string{"foo", "bar"}},
-		{"deps: foo\\bar \\\nbaz", []string{"foo\\bar", "baz"}},
-		{"deps: foo\\bar \\\r\n baz", []string{"foo\\bar", "baz"}}, // Windows uses CRLF line endings
-	} {
-		out, err := parseDepFile(tc.in)
-		if err != nil {
-			t.Errorf("test #%d failed: %v", i, err)
-			continue
-		}
-		if !reflect.DeepEqual(out, tc.out) {
-			t.Errorf("test #%d failed: expected %#v but got %#v", i, tc.out, out)
-			continue
-		}
-	}
-}
@@ -17,28 +17,18 @@ func NewConfig(options *compileopts.Options) (*compileopts.Config, error) {
 	if err != nil {
 		return nil, err
 	}
-
-	if options.OpenOCDCommands != nil {
-		// Override the OpenOCDCommands from the target spec if specified on
-		// the command-line
-		spec.OpenOCDCommands = options.OpenOCDCommands
-	}
-
 	goroot := goenv.Get("GOROOT")
 	if goroot == "" {
 		return nil, errors.New("cannot locate $GOROOT, please set it manually")
 	}
-
 	major, minor, err := goenv.GetGorootVersion(goroot)
 	if err != nil {
 		return nil, fmt.Errorf("could not read version from GOROOT (%v): %v", goroot, err)
 	}
-	if major != 1 || minor < 15 || minor > 17 {
-		return nil, fmt.Errorf("requires go version 1.15 through 1.17, got go%d.%d", major, minor)
+	if major != 1 || minor < 13 || minor > 16 {
+		return nil, fmt.Errorf("requires go version 1.13 through 1.16, got go%d.%d", major, minor)
 	}
-
 	clangHeaderPath := getClangHeaderPath(goenv.Get("TINYGOROOT"))
-
 	return &compileopts.Config{
 		Options:        options,
 		Target:         spec,
@@ -1,57 +0,0 @@
-package builder
-
-import (
-	"debug/elf"
-	"fmt"
-	"os"
-)
-
-func getElfSectionData(executable string, sectionName string) ([]byte, elf.FileHeader, error) {
-	elfFile, err := elf.Open(executable)
-	if err != nil {
-		return nil, elf.FileHeader{}, err
-	}
-	defer elfFile.Close()
-
-	section := elfFile.Section(sectionName)
-	if section == nil {
-		return nil, elf.FileHeader{}, fmt.Errorf("could not find %s section", sectionName)
-	}
-
-	data, err := section.Data()
-
-	return data, elfFile.FileHeader, err
-}
-
-func replaceElfSection(executable string, sectionName string, data []byte) error {
-	fp, err := os.OpenFile(executable, os.O_RDWR, 0)
-	if err != nil {
-		return err
-	}
-	defer fp.Close()
-
-	elfFile, err := elf.Open(executable)
-	if err != nil {
-		return err
-	}
-	defer elfFile.Close()
-
-	section := elfFile.Section(sectionName)
-	if section == nil {
-		return fmt.Errorf("could not find %s section", sectionName)
-	}
-
-	// Implicitly check for compressed sections
-	if section.Size != section.FileSize {
-		return fmt.Errorf("expected section %s to have identical size and file size, got %d and %d", sectionName, section.Size, section.FileSize)
-	}
-
-	// Only permit complete replacement of section
-	if section.Size != uint64(len(data)) {
-		return fmt.Errorf("expected section %s to have size %d, was actually %d", sectionName, len(data), section.Size)
-	}
-
-	// Write the replacement section data
-	_, err = fp.WriteAt(data, int64(section.Offset))
-	return err
-}
@@ -78,21 +78,11 @@ func makeESPFirmareImage(infile, outfile, format string) error {
 	// An added benefit is that we don't need to check for errors all the time.
 	outf := &bytes.Buffer{}

-	// Chip IDs. Source:
-	// https://github.com/espressif/esp-idf/blob/v4.3/components/bootloader_support/include/esp_app_format.h#L22
-	chip_id := map[string]uint16{
-		"esp32":   0x0000,
-		"esp32c3": 0x0005,
-	}[format]
-
 	// Image header.
 	switch format {
-	case "esp32", "esp32c3":
+	case "esp32":
 		// Header format:
-		// https://github.com/espressif/esp-idf/blob/v4.3/components/bootloader_support/include/esp_app_format.h#L71
-		// Note: not adding a SHA256 hash as the binary is modified by
-		// esptool.py while flashing and therefore the hash won't be valid
-		// anymore.
+		// 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
@@ -101,18 +91,15 @@ func makeESPFirmareImage(infile, outfile, format string) error {
 			entry_addr     uint32
 			wp_pin         uint8
 			spi_pin_drv    [3]uint8
-			chip_id        uint16
-			min_chip_rev   uint8
-			reserved       [8]uint8
+			reserved       [11]uint8
 			hash_appended  bool
 		}{
 			magic:          0xE9,
 			segment_count:  byte(len(segments)),
-			spi_mode:       2,    // ESP_IMAGE_SPI_MODE_DIO
-			spi_speed_size: 0x1f, // ESP_IMAGE_SPI_SPEED_80M, ESP_IMAGE_FLASH_SIZE_2MB
+			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
-			chip_id:        chip_id,
 			hash_appended:  true, // add a SHA256 hash
 		})
 	case "esp8266":
@@ -155,7 +142,7 @@ func makeESPFirmareImage(infile, outfile, format string) error {
 	outf.Write(make([]byte, 15-outf.Len()%16))
 	outf.WriteByte(checksum)

-	if format != "esp8266" {
+	if format == "esp32" {
 		// SHA256 hash (to protect against image corruption, not for security).
 		hash := sha256.Sum256(outf.Bytes())
 		outf.Write(hash[:])
@@ -27,23 +27,12 @@ const (
 type compileJob struct {
 	description  string // description, only used for logging
 	dependencies []*compileJob
-	result       string // result (path)
-	run          func(*compileJob) (err error)
+	run          func() error
 	state        jobState
 	err          error         // error if finished
 	duration     time.Duration // how long it took to run this job (only set after finishing)
 }

-// dummyCompileJob returns a new *compileJob that produces an output without
-// doing anything. This can be useful where a *compileJob producing an output is
-// expected but nothing needs to be done, for example for a load from a cache.
-func dummyCompileJob(result string) *compileJob {
-	return &compileJob{
-		description: "<dummy>",
-		result:      result,
-	}
-}
-
 // readyToRun returns whether this job is ready to run: it is itself not yet
 // started and all dependencies are finished.
 func (job *compileJob) readyToRun() bool {
@@ -65,29 +54,12 @@ func (job *compileJob) readyToRun() bool {
 	return true
 }

-// runJobs runs the indicated job and all its dependencies. For every job, all
-// the dependencies are run first. It returns the error of the first job that
-// fails.
-// It runs all jobs in the order of the dependencies slice, depth-first.
-// Therefore, if some jobs are preferred to run before others, they should be
-// ordered as such in the job dependencies.
-func runJobs(job *compileJob) error {
-	// Create a slice of jobs to run, where all dependencies are run in order.
-	jobs := []*compileJob{}
-	addedJobs := map[*compileJob]struct{}{}
-	var addJobs func(*compileJob)
-	addJobs = func(job *compileJob) {
-		if _, ok := addedJobs[job]; ok {
-			return
-		}
-		for _, dep := range job.dependencies {
-			addJobs(dep)
-		}
-		jobs = append(jobs, job)
-		addedJobs[job] = struct{}{}
-	}
-	addJobs(job)
-
+// runJobs runs all the jobs indicated in the jobs slice and returns the error
+// of the first job that fails to run.
+// It runs all jobs in the order of the slice, as long as all dependencies have
+// already run. Therefore, if some jobs are preferred to run before others, they
+// should be ordered as such in this slice.
+func runJobs(jobs []*compileJob) error {
 	// Create channels to communicate with the workers.
 	doneChan := make(chan *compileJob)
 	workerChan := make(chan *compileJob)
@@ -178,11 +150,9 @@ func nextJob(jobs []*compileJob) *compileJob {
 func jobWorker(workerChan, doneChan chan *compileJob) {
 	for job := range workerChan {
 		start := time.Now()
-		if job.run != nil {
-			err := job.run(job)
-			if err != nil {
-				job.err = err
-			}
+		err := job.run()
+		if err != nil {
+			job.err = err
 		}
 		job.duration = time.Since(start)
 		doneChan <- job
@@ -42,27 +42,30 @@ func (l *Library) sourcePaths(target string) []string {
 // The resulting file is stored in the provided tmpdir, which is expected to be
 // removed after the Load call.
 func (l *Library) Load(target, tmpdir string) (path string, err error) {
-	job, err := l.load(target, "", tmpdir)
+	path, job, err := l.load(target, "", tmpdir)
 	if err != nil {
 		return "", err
 	}
-	err = runJobs(job)
-	return job.result, err
+	if job != nil {
+		jobs := append([]*compileJob{job}, job.dependencies...)
+		err = runJobs(jobs)
+	}
+	return path, err
 }

-// load returns a compile job to build this library file for the given target
-// and CPU. It may return a dummy compileJob if the library build is already
-// cached. The path is stored as job.result but is only valid after the job has
-// been run.
+// load returns a path to the library file for the given target, loading it from
+// cache if possible. It will return a non-zero compiler job if the library
+// wasn't cached, this job (and its dependencies) must be run before the library
+// path is valid.
 // The provided tmpdir will be used to store intermediary files and possibly the
 // output archive file, it is expected to be removed after use.
-func (l *Library) load(target, cpu, tmpdir string) (job *compileJob, err error) {
+func (l *Library) load(target, cpu, tmpdir string) (path string, job *compileJob, err error) {
 	// Try to load a precompiled library.
 	precompiledPath := filepath.Join(goenv.Get("TINYGOROOT"), "pkg", target, l.name+".a")
 	if _, err := os.Stat(precompiledPath); err == nil {
 		// Found a precompiled library for this OS/architecture. Return the path
 		// directly.
-		return dummyCompileJob(precompiledPath), nil
+		return precompiledPath, nil, nil
 	}

 	var outfile string
@@ -75,7 +78,7 @@ func (l *Library) load(target, cpu, tmpdir string) (job *compileJob, err error)
 	// Try to fetch this library from the cache.
 	if path, err := cacheLoad(outfile, l.sourcePaths(target)); path != "" || err != nil {
 		// Cache hit.
-		return dummyCompileJob(path), nil
+		return path, nil, err
 	}
 	// Cache miss, build it now.

@@ -83,7 +86,7 @@ func (l *Library) load(target, cpu, tmpdir string) (job *compileJob, err error)
 	dir := filepath.Join(tmpdir, "build-lib-"+l.name)
 	err = os.Mkdir(dir, 0777)
 	if err != nil {
-		return nil, err
+		return "", nil, err
 	}

 	// Precalculate the flags to the compiler invocation.
@@ -110,8 +113,7 @@ func (l *Library) load(target, cpu, tmpdir string) (job *compileJob, err error)
 	arpath := filepath.Join(dir, l.name+".a")
 	job = &compileJob{
 		description: "ar " + l.name + ".a",
-		result:      arpath,
-		run: func(*compileJob) error {
+		run: func() error {
 			// Create an archive of all object files.
 			err := makeArchive(arpath, objs)
 			if err != nil {
@@ -131,11 +133,11 @@ func (l *Library) load(target, cpu, tmpdir string) (job *compileJob, err error)
 		objs = append(objs, objpath)
 		job.dependencies = append(job.dependencies, &compileJob{
 			description: "compile " + srcpath,
-			run: func(*compileJob) error {
+			run: func() error {
 				var compileArgs []string
 				compileArgs = append(compileArgs, args...)
 				compileArgs = append(compileArgs, "-o", objpath, srcpath)
-				err := runCCompiler(compileArgs...)
+				err := runCCompiler("clang", compileArgs...)
 				if err != nil {
 					return &commandError{"failed to build", srcpath, err}
 				}
@@ -144,5 +146,5 @@ func (l *Library) load(target, cpu, tmpdir string) (job *compileJob, err error)
 		})
 	}

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

 // runCCompiler invokes a C compiler with the given arguments.
-func runCCompiler(flags ...string) error {
-	if hasBuiltinTools {
+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 == "" {
@@ -23,8 +23,17 @@ func runCCompiler(flags ...string) error {
 		return cmd.Run()
 	}

-	// Compile this with an external invocation of the Clang compiler.
-	return execCommand(commands["clang"], flags...)
+	// 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.
@@ -41,9 +41,7 @@ type cgoPackage struct {
 	elaboratedTypes map[string]*elaboratedTypeInfo
 	enums           map[string]enumInfo
 	anonStructNum   int
-	cflags          []string // CFlags from #cgo lines
-	ldflags         []string // LDFlags from #cgo lines
-	visitedFiles    map[string][]byte
+	ldflags         []string
 }

 // constantInfo stores some information about a CGo constant found by libclang
@@ -158,10 +156,9 @@ typedef unsigned long long  _Cgo_ulonglong;
 // Process extracts `import "C"` statements from the AST, parses the comment
 // with libclang, and modifies the AST to use this information. It returns a
 // newly created *ast.File that should be added to the list of to-be-parsed
-// files, the CFLAGS and LDFLAGS found in #cgo lines, and a map of file hashes
-// of the accessed C header 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, []string, map[string][]byte, []error) {
+// 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) {
 	p := &cgoPackage{
 		dir:             dir,
 		fset:            fset,
@@ -173,9 +170,13 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 		typedefs:        map[string]*typedefInfo{},
 		elaboratedTypes: map[string]*elaboratedTypeInfo{},
 		enums:           map[string]enumInfo{},
-		visitedFiles:    map[string][]byte{},
 	}

+	// 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})
@@ -184,7 +185,7 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 	// Find the absolute path for this package.
 	packagePath, err := filepath.Abs(fset.File(files[0].Pos()).Name())
 	if err != nil {
-		return nil, nil, nil, nil, []error{
+		return nil, nil, []error{
 			scanner.Error{
 				Pos: fset.Position(files[0].Pos()),
 				Msg: "cgo: cannot find absolute path: " + err.Error(), // TODO: wrap this error
@@ -359,7 +360,7 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 						continue
 					}
 					makePathsAbsolute(flags, packagePath)
-					p.cflags = append(p.cflags, flags...)
+					cflags = append(cflags, flags...)
 				case "LDFLAGS":
 					flags, err := shlex.Split(value)
 					if err != nil {
@@ -382,13 +383,6 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 		}
 	}

-	// Define CFlags that will be used while parsing the package.
-	// 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.
-	cflagsForCGo := append([]string{"-D_FORTIFY_SOURCE=0"}, cflags...)
-	cflagsForCGo = append(cflagsForCGo, p.cflags...)
-
 	// Process all CGo imports.
 	for _, genDecl := range statements {
 		cgoComment := genDecl.Doc.Text()
@@ -398,7 +392,7 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 			pos = genDecl.Doc.Pos()
 		}
 		position := fset.PositionFor(pos, true)
-		p.parseFragment(cgoComment+cgoTypes, cflagsForCGo, position.Filename, position.Line)
+		p.parseFragment(cgoComment+cgoTypes, cflags, position.Filename, position.Line)
 	}

 	// Declare functions found by libclang.
@@ -433,7 +427,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.cflags, p.ldflags, p.visitedFiles, p.errors
+	return p.generated, p.ldflags, p.errors
 }

 // makePathsAbsolute converts some common path compiler flags (-I, -L) from
@@ -12,6 +12,7 @@ import (
 	"go/types"
 	"io/ioutil"
 	"path/filepath"
+	"regexp"
 	"runtime"
 	"strings"
 	"testing"
@@ -24,6 +25,14 @@ var flagUpdate = flag.Bool("update", false, "Update images based on test output.
 // platforms and Go versions.
 func normalizeResult(result string) string {
 	actual := strings.ReplaceAll(result, "\r\n", "\n")
+
+	// Make sure all functions are wrapped, even those that would otherwise be
+	// single-line functions. This is necessary because Go 1.14 changed the way
+	// 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
 }

@@ -56,7 +65,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
@@ -11,184 +11,105 @@ import (
 	"strings"
 )

-var (
-	prefixParseFns map[token.Token]func(*tokenizer) (ast.Expr, *scanner.Error)
-	precedences    = map[token.Token]int{
-		token.ADD: precedenceAdd,
-		token.SUB: precedenceAdd,
-		token.MUL: precedenceMul,
-		token.QUO: precedenceMul,
-		token.REM: precedenceMul,
-	}
-)
-
-const (
-	precedenceLowest = iota + 1
-	precedenceAdd
-	precedenceMul
-	precedencePrefix
-)
-
-func init() {
-	// This must be done in an init function to avoid an initialization order
-	// failure.
-	prefixParseFns = map[token.Token]func(*tokenizer) (ast.Expr, *scanner.Error){
-		token.IDENT:  parseIdent,
-		token.INT:    parseBasicLit,
-		token.FLOAT:  parseBasicLit,
-		token.STRING: parseBasicLit,
-		token.CHAR:   parseBasicLit,
-		token.LPAREN: parseParenExpr,
-		token.SUB:    parseUnaryExpr,
-	}
-}
-
 // parseConst parses the given string as a C constant.
 func parseConst(pos token.Pos, fset *token.FileSet, value string) (ast.Expr, *scanner.Error) {
 	t := newTokenizer(pos, fset, value)
-	expr, err := parseConstExpr(t, precedenceLowest)
-	t.Next()
-	if t.curToken != token.EOF {
+	expr, err := parseConstExpr(t)
+	if t.token != token.EOF {
 		return nil, &scanner.Error{
-			Pos: t.fset.Position(t.curPos),
-			Msg: "unexpected token " + t.curToken.String() + ", expected end of expression",
+			Pos: t.fset.Position(t.pos),
+			Msg: "unexpected token " + t.token.String(),
 		}
 	}
 	return expr, err
 }

 // parseConstExpr parses a stream of C tokens to a Go expression.
-func parseConstExpr(t *tokenizer, precedence int) (ast.Expr, *scanner.Error) {
-	if t.curToken == token.EOF {
+func parseConstExpr(t *tokenizer) (ast.Expr, *scanner.Error) {
+	switch t.token {
+	case token.LPAREN:
+		lparen := t.pos
+		t.Next()
+		x, err := parseConstExpr(t)
+		if err != nil {
+			return nil, err
+		}
+		if t.token != token.RPAREN {
+			return nil, unexpectedToken(t, token.RPAREN)
+		}
+		expr := &ast.ParenExpr{
+			Lparen: lparen,
+			X:      x,
+			Rparen: t.pos,
+		}
+		t.Next()
+		return expr, nil
+	case token.INT, token.FLOAT, token.STRING, token.CHAR:
+		expr := &ast.BasicLit{
+			ValuePos: t.pos,
+			Kind:     t.token,
+			Value:    t.value,
+		}
+		t.Next()
+		return expr, nil
+	case token.IDENT:
+		expr := &ast.Ident{
+			NamePos: t.pos,
+			Name:    "C." + t.value,
+		}
+		t.Next()
+		return expr, nil
+	case token.EOF:
 		return nil, &scanner.Error{
-			Pos: t.fset.Position(t.curPos),
+			Pos: t.fset.Position(t.pos),
 			Msg: "empty constant",
 		}
-	}
-	prefix := prefixParseFns[t.curToken]
-	if prefix == nil {
+	default:
 		return nil, &scanner.Error{
-			Pos: t.fset.Position(t.curPos),
-			Msg: fmt.Sprintf("unexpected token %s", t.curToken),
+			Pos: t.fset.Position(t.pos),
+			Msg: fmt.Sprintf("unexpected token %s", t.token),
 		}
 	}
-	leftExpr, err := prefix(t)
-
-	for t.peekToken != token.EOF && precedence < precedences[t.peekToken] {
-		switch t.peekToken {
-		case token.ADD, token.SUB, token.MUL, token.QUO, token.REM:
-			t.Next()
-			leftExpr, err = parseBinaryExpr(t, leftExpr)
-		}
-	}
-
-	return leftExpr, err
-}
-
-func parseIdent(t *tokenizer) (ast.Expr, *scanner.Error) {
-	return &ast.Ident{
-		NamePos: t.curPos,
-		Name:    "C." + t.curValue,
-	}, nil
-}
-
-func parseBasicLit(t *tokenizer) (ast.Expr, *scanner.Error) {
-	return &ast.BasicLit{
-		ValuePos: t.curPos,
-		Kind:     t.curToken,
-		Value:    t.curValue,
-	}, nil
-}
-
-func parseParenExpr(t *tokenizer) (ast.Expr, *scanner.Error) {
-	lparen := t.curPos
-	t.Next()
-	x, err := parseConstExpr(t, precedenceLowest)
-	if err != nil {
-		return nil, err
-	}
-	t.Next()
-	if t.curToken != token.RPAREN {
-		return nil, unexpectedToken(t, token.RPAREN)
-	}
-	expr := &ast.ParenExpr{
-		Lparen: lparen,
-		X:      x,
-		Rparen: t.curPos,
-	}
-	return expr, nil
-}
-
-func parseBinaryExpr(t *tokenizer, left ast.Expr) (ast.Expr, *scanner.Error) {
-	expression := &ast.BinaryExpr{
-		X:     left,
-		Op:    t.curToken,
-		OpPos: t.curPos,
-	}
-	precedence := precedences[t.curToken]
-	t.Next()
-	right, err := parseConstExpr(t, precedence)
-	expression.Y = right
-	return expression, err
-}
-
-func parseUnaryExpr(t *tokenizer) (ast.Expr, *scanner.Error) {
-	expression := &ast.UnaryExpr{
-		OpPos: t.curPos,
-		Op:    t.curToken,
-	}
-	t.Next()
-	x, err := parseConstExpr(t, precedencePrefix)
-	expression.X = x
-	return expression, err
 }

 // unexpectedToken returns an error of the form "unexpected token FOO, expected
 // BAR".
 func unexpectedToken(t *tokenizer, expected token.Token) *scanner.Error {
 	return &scanner.Error{
-		Pos: t.fset.Position(t.curPos),
-		Msg: fmt.Sprintf("unexpected token %s, expected %s", t.curToken, expected),
+		Pos: t.fset.Position(t.pos),
+		Msg: fmt.Sprintf("unexpected token %s, expected %s", t.token, expected),
 	}
 }

 // tokenizer reads C source code and converts it to Go tokens.
 type tokenizer struct {
-	curPos, peekPos     token.Pos
-	fset                *token.FileSet
-	curToken, peekToken token.Token
-	curValue, peekValue string
-	buf                 string
+	pos   token.Pos
+	fset  *token.FileSet
+	token token.Token
+	value string
+	buf   string
 }

 // newTokenizer initializes a new tokenizer, positioned at the first token in
 // the string.
 func newTokenizer(start token.Pos, fset *token.FileSet, buf string) *tokenizer {
 	t := &tokenizer{
-		peekPos:   start,
-		fset:      fset,
-		buf:       buf,
-		peekToken: token.ILLEGAL,
+		pos:   start,
+		fset:  fset,
+		buf:   buf,
+		token: token.ILLEGAL,
 	}
-	// Parse the first two tokens (cur and peek).
-	t.Next()
-	t.Next()
+	t.Next() // Parse the first token.
 	return t
 }

 // Next consumes the next token in the stream. There is no return value, read
 // the next token from the pos, token and value properties.
 func (t *tokenizer) Next() {
-	// The previous peek is now the current token.
-	t.curPos = t.peekPos
-	t.curToken = t.peekToken
-	t.curValue = t.peekValue
-
-	// Parse the next peek token.
-	t.peekPos += token.Pos(len(t.curValue))
+	t.pos += token.Pos(len(t.value))
 	for {
 		if len(t.buf) == 0 {
-			t.peekToken = token.EOF
+			t.token = token.EOF
 			return
 		}
 		c := t.buf[0]
@@ -197,28 +118,17 @@ func (t *tokenizer) Next() {
 			// Skip whitespace.
 			// Based on this source, not sure whether it represents C whitespace:
 			// https://en.cppreference.com/w/cpp/string/byte/isspace
-			t.peekPos++
+			t.pos++
 			t.buf = t.buf[1:]
-		case c == '(' || c == ')' || c == '+' || c == '-' || c == '*' || c == '/' || c == '%':
+		case c == '(' || c == ')':
 			// Single-character tokens.
-			// TODO: ++ (increment) and -- (decrement) operators.
 			switch c {
 			case '(':
-				t.peekToken = token.LPAREN
+				t.token = token.LPAREN
 			case ')':
-				t.peekToken = token.RPAREN
-			case '+':
-				t.peekToken = token.ADD
-			case '-':
-				t.peekToken = token.SUB
-			case '*':
-				t.peekToken = token.MUL
-			case '/':
-				t.peekToken = token.QUO
-			case '%':
-				t.peekToken = token.REM
+				t.token = token.RPAREN
 			}
-			t.peekValue = t.buf[:1]
+			t.value = t.buf[:1]
 			t.buf = t.buf[1:]
 			return
 		case c >= '0' && c <= '9':
@@ -236,17 +146,17 @@ func (t *tokenizer) Next() {
 					break
 				}
 			}
-			t.peekValue = t.buf[:tokenLen]
+			t.value = t.buf[:tokenLen]
 			t.buf = t.buf[tokenLen:]
 			if hasDot {
 				// Integer constants are more complicated than this but this is
 				// a close approximation.
 				// https://en.cppreference.com/w/cpp/language/integer_literal
-				t.peekToken = token.FLOAT
-				t.peekValue = strings.TrimRight(t.peekValue, "f")
+				t.token = token.FLOAT
+				t.value = strings.TrimRight(t.value, "f")
 			} else {
-				t.peekToken = token.INT
-				t.peekValue = strings.TrimRight(t.peekValue, "uUlL")
+				t.token = token.INT
+				t.value = strings.TrimRight(t.value, "uUlL")
 			}
 			return
 		case c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z' || c == '_':
@@ -260,9 +170,9 @@ func (t *tokenizer) Next() {
 					break
 				}
 			}
-			t.peekValue = t.buf[:tokenLen]
+			t.value = t.buf[:tokenLen]
 			t.buf = t.buf[tokenLen:]
-			t.peekToken = token.IDENT
+			t.token = token.IDENT
 			return
 		case c == '"':
 			// String constant. Find the first '"' character that is not
@@ -278,8 +188,8 @@ func (t *tokenizer) Next() {
 					escape = c == '\\'
 				}
 			}
-			t.peekToken = token.STRING
-			t.peekValue = t.buf[:tokenLen]
+			t.token = token.STRING
+			t.value = t.buf[:tokenLen]
 			t.buf = t.buf[tokenLen:]
 			return
 		case c == '\'':
@@ -296,12 +206,12 @@ func (t *tokenizer) Next() {
 					escape = c == '\\'
 				}
 			}
-			t.peekToken = token.CHAR
-			t.peekValue = t.buf[:tokenLen]
+			t.token = token.CHAR
+			t.value = t.buf[:tokenLen]
 			t.buf = t.buf[tokenLen:]
 			return
 		default:
-			t.peekToken = token.ILLEGAL
+			t.token = token.ILLEGAL
 			return
 		}
 	}
@@ -18,7 +18,7 @@ func TestParseConst(t *testing.T) {
 		{`(5)`, `(5)`},
 		{`(((5)))`, `(5)`},
 		{`)`, `error: 1:1: unexpected token )`},
-		{`5)`, `error: 1:2: unexpected token ), expected end of expression`},
+		{`5)`, `error: 1:2: unexpected token )`},
 		{"  \t)", `error: 1:4: unexpected token )`},
 		{`5.8f`, `5.8`},
 		{`foo`, `C.foo`},
@@ -30,24 +30,7 @@ func TestParseConst(t *testing.T) {
 		{`'a'`, `'a'`},
 		{`0b10`, `0b10`},
 		{`0x1234_5678`, `0x1234_5678`},
-		{`5 5`, `error: 1:3: unexpected token INT, expected end of expression`}, // test for a bugfix
-		// Binary operators.
-		{`5+5`, `5 + 5`},
-		{`5-5`, `5 - 5`},
-		{`5*5`, `5 * 5`},
-		{`5/5`, `5 / 5`},
-		{`5%5`, `5 % 5`},
-		{`(5/5)`, `(5 / 5)`},
-		{`1 - 2`, `1 - 2`},
-		{`1 - 2 + 3`, `1 - 2 + 3`},
-		{`1 - 2 * 3`, `1 - 2*3`},
-		{`(1 - 2) * 3`, `(1 - 2) * 3`},
-		{`1 * 2 - 3`, `1*2 - 3`},
-		{`1 * (2 - 3)`, `1 * (2 - 3)`},
-		// Unary operators.
-		{`-5`, `-5`},
-		{`-5-2`, `-5 - 2`},
-		{`5 - - 2`, `5 - -2`},
+		{`5 5`, `error: 1:3: unexpected token INT`}, // test for a bugfix
 	} {
 		fset := token.NewFileSet()
 		startPos := fset.AddFile("", -1, 1000).Pos(0)
@@ -4,7 +4,6 @@ package cgo
 // modification. It does not touch the AST itself.

 import (
-	"crypto/sha512"
 	"fmt"
 	"go/ast"
 	"go/scanner"
@@ -57,7 +56,6 @@ unsigned tinygo_clang_Cursor_isBitField(GoCXCursor c);
 int tinygo_clang_globals_visitor(GoCXCursor c, GoCXCursor parent, CXClientData client_data);
 int tinygo_clang_struct_visitor(GoCXCursor c, GoCXCursor parent, CXClientData client_data);
 int tinygo_clang_enum_visitor(GoCXCursor c, GoCXCursor parent, CXClientData client_data);
-void tinygo_clang_inclusion_visitor(CXFile included_file, CXSourceLocation *inclusion_stack, unsigned include_len, CXClientData client_data);
 */
 import "C"

@@ -116,7 +114,6 @@ func (p *cgoPackage) parseFragment(fragment string, cflags []string, posFilename
 	}
 	defer C.clang_disposeTranslationUnit(unit)

-	// Report parser and type errors.
 	if numDiagnostics := int(C.clang_getNumDiagnostics(unit)); numDiagnostics != 0 {
 		addDiagnostic := func(diagnostic C.CXDiagnostic) {
 			spelling := getString(C.clang_getDiagnosticSpelling(diagnostic))
@@ -137,36 +134,10 @@ func (p *cgoPackage) parseFragment(fragment string, cflags []string, posFilename
 		}
 	}

-	// Extract information required by CGo.
 	ref := storedRefs.Put(p)
 	defer storedRefs.Remove(ref)
 	cursor := C.tinygo_clang_getTranslationUnitCursor(unit)
 	C.tinygo_clang_visitChildren(cursor, C.CXCursorVisitor(C.tinygo_clang_globals_visitor), C.CXClientData(ref))
-
-	// Determine files read during CGo processing, for caching.
-	inclusionCallback := func(includedFile C.CXFile) {
-		// Get full file path.
-		path := getString(C.clang_getFileName(includedFile))
-
-		// Get contents of file (that should be in-memory).
-		size := C.size_t(0)
-		rawData := C.clang_getFileContents(unit, includedFile, &size)
-		if rawData == nil {
-			// Sanity check. This should (hopefully) never trigger.
-			panic("libclang: file contents was not loaded")
-		}
-		data := (*[1 << 24]byte)(unsafe.Pointer(rawData))[:size]
-
-		// Hash the contents if it isn't hashed yet.
-		if _, ok := p.visitedFiles[path]; !ok {
-			// already stored
-			sum := sha512.Sum512_224(data)
-			p.visitedFiles[path] = sum[:]
-		}
-	}
-	inclusionCallbackRef := storedRefs.Put(inclusionCallback)
-	defer storedRefs.Remove(inclusionCallbackRef)
-	C.clang_getInclusions(unit, C.CXInclusionVisitor(C.tinygo_clang_inclusion_visitor), C.CXClientData(inclusionCallbackRef))
 }

 //export tinygo_clang_globals_visitor
@@ -801,9 +772,3 @@ func tinygo_clang_enum_visitor(c, parent C.GoCXCursor, client_data C.CXClientDat
 	}
 	return C.CXChildVisit_Continue
 }
-
-//export tinygo_clang_inclusion_visitor
-func tinygo_clang_inclusion_visitor(includedFile C.CXFile, inclusionStack *C.CXSourceLocation, includeLen C.unsigned, clientData C.CXClientData) {
-	callback := storedRefs.Get(unsafe.Pointer(clientData)).(func(C.CXFile))
-	callback(includedFile)
-}
@@ -1,7 +1,7 @@
 // CGo errors:
 //     testdata/errors.go:4:2: warning: some warning
 //     testdata/errors.go:11:9: error: unknown type name 'someType'
-//     testdata/errors.go:13:23: unexpected token ), expected end of expression
+//     testdata/errors.go:13:23: unexpected token )

 // Type checking errors after CGo processing:
 //     testdata/errors.go:102: cannot use 2 << 10 (untyped int constant 2048) as uint8 value in variable declaration (overflows)
@@ -67,7 +67,9 @@ 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) 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
 }
@@ -103,9 +105,15 @@ 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 }

@@ -130,7 +138,9 @@ func (union *C.union_3) unionfield_thing() *C.union3_t {

 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_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))
 }
@@ -55,7 +55,7 @@ func (c *Config) GOARCH() string {

 // BuildTags returns the complete list of build tags used during this build.
 func (c *Config) BuildTags() []string {
-	tags := append(c.Target.BuildTags, []string{"tinygo", "math_big_pure_go", "gc." + c.GC(), "scheduler." + c.Scheduler(), "serial." + c.Serial()}...)
+	tags := append(c.Target.BuildTags, []string{"tinygo", "gc." + c.GC(), "scheduler." + c.Scheduler()}...)
 	for i := 1; i <= c.GoMinorVersion; i++ {
 		tags = append(tags, fmt.Sprintf("go1.%d", i))
 	}
@@ -80,7 +80,12 @@ func (c *Config) GC() string {
 	if c.Target.GC != "" {
 		return c.Target.GC
 	}
-	return "conservative"
+	for _, tag := range c.Target.BuildTags {
+		if tag == "baremetal" || tag == "wasm" {
+			return "conservative"
+		}
+	}
+	return "extalloc"
 }

 // NeedsStackObjects returns true if the compiler should insert stack objects
@@ -89,7 +94,7 @@ func (c *Config) NeedsStackObjects() bool {
 	switch c.GC() {
 	case "conservative", "extalloc":
 		for _, tag := range c.BuildTags() {
-			if tag == "tinygo.wasm" {
+			if tag == "wasm" {
 				return true
 			}
 		}
@@ -113,39 +118,6 @@ func (c *Config) Scheduler() string {
 	return "coroutines"
 }

-// Serial returns the serial implementation for this build configuration: uart,
-// usb (meaning USB-CDC), or none.
-func (c *Config) Serial() string {
-	if c.Options.Serial != "" {
-		return c.Options.Serial
-	}
-	if c.Target.Serial != "" {
-		return c.Target.Serial
-	}
-	return "none"
-}
-
-// OptLevels returns the optimization level (0-2), size level (0-2), and inliner
-// threshold as used in the LLVM optimization pipeline.
-func (c *Config) OptLevels() (optLevel, sizeLevel int, inlinerThreshold uint) {
-	switch c.Options.Opt {
-	case "none", "0":
-		return 0, 0, 0 // -O0
-	case "1":
-		return 1, 0, 0 // -O1
-	case "2":
-		return 2, 0, 225 // -O2
-	case "s":
-		return 2, 1, 225 // -Os
-	case "z":
-		return 2, 2, 5 // -Oz, default
-	default:
-		// This is not shown to the user: valid choices are already checked as
-		// part of Options.Verify(). It is here as a sanity check.
-		panic("unknown optimization level: -opt=" + c.Options.Opt)
-	}
-}
-
 // FuncImplementation picks an appropriate func value implementation for the
 // target.
 func (c *Config) FuncImplementation() string {
@@ -188,19 +160,10 @@ func (c *Config) AutomaticStackSize() bool {
 	return false
 }

-// RP2040BootPatch returns whether the RP2040 boot patch should be applied that
-// calculates and patches in the checksum for the 2nd stage bootloader.
-func (c *Config) RP2040BootPatch() bool {
-	if c.Target.RP2040BootPatch != nil {
-		return *c.Target.RP2040BootPatch
-	}
-	return false
-}
-
 // CFlags returns the flags to pass to the C compiler. This is necessary for CGo
 // preprocessing.
 func (c *Config) CFlags() []string {
-	var cflags []string
+	cflags := append([]string{}, c.Options.CFlags...)
 	for _, flag := range c.Target.CFlags {
 		cflags = append(cflags, strings.ReplaceAll(flag, "{root}", goenv.Get("TINYGOROOT")))
 	}
@@ -209,8 +172,9 @@ func (c *Config) CFlags() []string {
 		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"))
 	}
-	// Always emit debug information. It is optionally stripped at link time.
-	cflags = append(cflags, "-g")
+	if c.Debug() {
+		cflags = append(cflags, "-g")
+	}
 	return cflags
 }

@@ -220,7 +184,7 @@ func (c *Config) CFlags() []string {
 func (c *Config) LDFlags() []string {
 	root := goenv.Get("TINYGOROOT")
 	// Merge and adjust LDFlags.
-	var ldflags []string
+	ldflags := append([]string{}, c.Options.LDFlags...)
 	for _, flag := range c.Target.LDFlags {
 		ldflags = append(ldflags, strings.ReplaceAll(flag, "{root}", root))
 	}
@@ -249,9 +213,8 @@ func (c *Config) VerifyIR() bool {
 	return c.Options.VerifyIR
 }

-// Debug returns whether debug (DWARF) information should be retained by the
-// linker. By default, debug information is retained but it can be removed with
-// the -no-debug flag.
+// Debug returns whether to add debug symbols to the IR, for debugging with GDB
+// and similar.
 func (c *Config) Debug() bool {
 	return c.Options.Debug
 }
@@ -275,11 +238,6 @@ func (c *Config) BinaryFormat(ext string) string {
 		// More information:
 		// https://github.com/Microsoft/uf2
 		return "uf2"
-	case ".zip":
-		if c.Target.BinaryFormat != "" {
-			return c.Target.BinaryFormat
-		}
-		return "zip"
 	default:
 		// Use the ELF format for unrecognized file formats.
 		return "elf"
@@ -297,9 +255,6 @@ func (c *Config) Programmer() (method, openocdInterface string) {
 	case "openocd", "msd", "command":
 		// The -programmer flag only specifies the flash method.
 		return c.Options.Programmer, c.Target.OpenOCDInterface
-	case "bmp":
-		// The -programmer flag only specifies the flash method.
-		return c.Options.Programmer, ""
 	default:
 		// The -programmer flag specifies something else, assume it specifies
 		// the OpenOCD interface name.
@@ -366,10 +321,6 @@ func (c *Config) WasmAbi() string {
 	return c.Target.WasmAbi
 }

-func (c *Config) LLVMFeatures() string {
-	return c.Options.LLVMFeatures
-}
-
 type TestConfig struct {
 	CompileTestBinary bool
 	// TODO: Filter the test functions to run, include verbose flag, etc
@@ -2,43 +2,37 @@ package compileopts

 import (
 	"fmt"
-	"regexp"
 	"strings"
 )

 var (
 	validGCOptions            = []string{"none", "leaking", "extalloc", "conservative"}
 	validSchedulerOptions     = []string{"none", "tasks", "coroutines"}
-	validSerialOptions        = []string{"none", "uart", "usb"}
 	validPrintSizeOptions     = []string{"none", "short", "full"}
 	validPanicStrategyOptions = []string{"print", "trap"}
-	validOptOptions           = []string{"none", "0", "1", "2", "s", "z"}
 )

 // Options contains extra options to give to the compiler. These options are
 // usually passed from the command line.
 type Options struct {
-	Target          string
-	Opt             string
-	GC              string
-	PanicStrategy   string
-	Scheduler       string
-	Serial          string
-	PrintIR         bool
-	DumpSSA         bool
-	VerifyIR        bool
-	PrintCommands   func(cmd string, args ...string)
-	Debug           bool
-	PrintSizes      string
-	PrintAllocs     *regexp.Regexp // regexp string
-	PrintStacks     bool
-	Tags            string
-	WasmAbi         string
-	GlobalValues    map[string]map[string]string // map[pkgpath]map[varname]value
-	TestConfig      TestConfig
-	Programmer      string
-	OpenOCDCommands []string
-	LLVMFeatures    string
+	Target        string
+	Opt           string
+	GC            string
+	PanicStrategy string
+	Scheduler     string
+	PrintIR       bool
+	DumpSSA       bool
+	VerifyIR      bool
+	PrintCommands bool
+	Debug         bool
+	PrintSizes    string
+	PrintStacks   bool
+	CFlags        []string
+	LDFlags       []string
+	Tags          string
+	WasmAbi       string
+	TestConfig    TestConfig
+	Programmer    string
 }

 // Verify performs a validation on the given options, raising an error if options are not valid.
@@ -61,15 +55,6 @@ func (o *Options) Verify() error {
 		}
 	}

-	if o.Serial != "" {
-		valid := isInArray(validSerialOptions, o.Serial)
-		if !valid {
-			return fmt.Errorf(`invalid serial option '%s': valid values are %s`,
-				o.Serial,
-				strings.Join(validSerialOptions, ", "))
-		}
-	}
-
 	if o.PrintSizes != "" {
 		valid := isInArray(validPrintSizeOptions, o.PrintSizes)
 		if !valid {
@@ -88,12 +73,6 @@ func (o *Options) Verify() error {
 		}
 	}

-	if o.Opt != "" {
-		if !isInArray(validOptOptions, o.Opt) {
-			return fmt.Errorf("invalid -opt=%s: valid values are %s", o.Opt, strings.Join(validOptOptions, ", "))
-		}
-	}
-
 	return nil
 }

@@ -7,7 +7,6 @@ import (
 	"errors"
 	"io"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"reflect"
 	"runtime"
@@ -31,7 +30,7 @@ type TargetSpec struct {
 	BuildTags        []string `json:"build-tags"`
 	GC               string   `json:"gc"`
 	Scheduler        string   `json:"scheduler"`
-	Serial           string   `json:"serial"` // which serial output to use (uart, usb, none)
+	Compiler         string   `json:"compiler"`
 	Linker           string   `json:"linker"`
 	RTLib            string   `json:"rtlib"` // compiler runtime library (libgcc, compiler-rt)
 	Libc             string   `json:"libc"`
@@ -41,12 +40,10 @@ type TargetSpec struct {
 	LDFlags          []string `json:"ldflags"`
 	LinkerScript     string   `json:"linkerscript"`
 	ExtraFiles       []string `json:"extra-files"`
-	RP2040BootPatch  *bool    `json:"rp2040-boot-patch"`        // Patch RP2040 2nd stage bootloader checksum
 	Emulator         []string `json:"emulator" override:"copy"` // inherited Emulator must not be append
 	FlashCommand     string   `json:"flash-command"`
-	GDB              []string `json:"gdb"`
+	GDB              string   `json:"gdb"`
 	PortReset        string   `json:"flash-1200-bps-reset"`
-	SerialPort       []string `json:"serial-port"` // serial port IDs in the form "acm:vid:pid" or "usb:vid:pid"
 	FlashMethod      string   `json:"flash-method"`
 	FlashVolume      string   `json:"msd-volume-name"`
 	FlashFilename    string   `json:"msd-firmware-name"`
@@ -172,7 +169,6 @@ func LoadTarget(target string) (*TargetSpec, error) {
 			"386":   "i386",
 			"amd64": "x86_64",
 			"arm64": "aarch64",
-			"arm":   "thumbv7",
 		}[goarch]
 		if llvmarch == "" {
 			llvmarch = goarch
@@ -233,43 +229,31 @@ func LoadTarget(target string) (*TargetSpec, error) {
 	}
 }

-// WindowsBuildNotSupportedErr is being thrown, when goos is windows and no target has been specified.
-var WindowsBuildNotSupportedErr = errors.New("Building Windows binaries is currently not supported. Try specifying a different target")
-
 func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
-	if goos == "windows" {
-		return nil, WindowsBuildNotSupportedErr
-	}
 	// No target spec available. Use the default one, useful on most systems
 	// with a regular OS.
 	spec := TargetSpec{
-		Triple:           triple,
-		GOOS:             goos,
-		GOARCH:           goarch,
-		BuildTags:        []string{goos, goarch},
-		Scheduler:        "tasks",
-		Linker:           "cc",
-		DefaultStackSize: 1024 * 64, // 64kB
-		CFlags:           []string{"--target=" + triple},
-		GDB:              []string{"gdb"},
-		PortReset:        "false",
-	}
-	if goarch == "386" {
-		spec.CPU = "pentium4"
+		Triple:    triple,
+		GOOS:      goos,
+		GOARCH:    goarch,
+		BuildTags: []string{goos, goarch},
+		Compiler:  "clang",
+		Linker:    "cc",
+		CFlags:    []string{"--target=" + triple},
+		GDB:       "gdb",
+		PortReset: "false",
 	}
 	if goos == "darwin" {
-		spec.CFlags = append(spec.CFlags, "-isysroot", "/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk")
 		spec.LDFlags = append(spec.LDFlags, "-Wl,-dead_strip")
 	} else {
 		spec.LDFlags = append(spec.LDFlags, "-no-pie", "-Wl,--gc-sections") // WARNING: clang < 5.0 requires -nopie
 	}
 	if goarch != "wasm" {
 		spec.ExtraFiles = append(spec.ExtraFiles, "src/runtime/gc_"+goarch+".S")
-		spec.ExtraFiles = append(spec.ExtraFiles, "src/internal/task/task_stack_"+goarch+".S")
 	}
 	if goarch != runtime.GOARCH {
 		// Some educated guesses as to how to invoke helper programs.
-		spec.GDB = []string{"gdb-multiarch"}
+		spec.GDB = "gdb-multiarch"
 		if goarch == "arm" && goos == "linux" {
 			spec.CFlags = append(spec.CFlags, "--sysroot=/usr/arm-linux-gnueabihf")
 			spec.Linker = "arm-linux-gnueabihf-gcc"
@@ -287,17 +271,3 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 	}
 	return &spec, nil
 }
-
-// LookupGDB looks up a gdb executable.
-func (spec *TargetSpec) LookupGDB() (string, error) {
-	if len(spec.GDB) == 0 {
-		return "", errors.New("gdb not configured in the target specification")
-	}
-	for _, d := range spec.GDB {
-		_, err := exec.LookPath(d)
-		if err == nil {
-			return d, nil
-		}
-	}
-	return "", errors.New("no gdb found configured in the target specification (" + strings.Join(spec.GDB, ", ") + ")")
-}
@@ -1,99 +0,0 @@
-package compiler
-
-// This file defines alias functions for functions that are normally defined in
-// Go assembly.
-//
-// The Go toolchain defines many performance critical functions in assembly
-// instead of plain Go. This is a problem for TinyGo as it currently (as of
-// august 2021) is not able to compile these assembly files and even if it
-// could, it would not be able to make use of them for many targets that are
-// supported by TinyGo (baremetal RISC-V, AVR, etc). Therefore, many of these
-// functions are aliased to their generic Go implementation.
-// This results in slower than possible implementations, but at least they are
-// usable.
-
-import "tinygo.org/x/go-llvm"
-
-var stdlibAliases = map[string]string{
-	// crypto packages
-	"crypto/md5.block":         "crypto/md5.blockGeneric",
-	"crypto/sha1.block":        "crypto/sha1.blockGeneric",
-	"crypto/sha1.blockAMD64":   "crypto/sha1.blockGeneric",
-	"crypto/sha256.block":      "crypto/sha256.blockGeneric",
-	"crypto/sha512.blockAMD64": "crypto/sha512.blockGeneric",
-
-	// math package
-	"math.Asin":      "math.asin",
-	"math.Asinh":     "math.asinh",
-	"math.Acos":      "math.acos",
-	"math.Acosh":     "math.acosh",
-	"math.Atan":      "math.atan",
-	"math.Atanh":     "math.atanh",
-	"math.Atan2":     "math.atan2",
-	"math.Cbrt":      "math.cbrt",
-	"math.Ceil":      "math.ceil",
-	"math.archCeil":  "math.ceil",
-	"math.Cos":       "math.cos",
-	"math.Cosh":      "math.cosh",
-	"math.Erf":       "math.erf",
-	"math.Erfc":      "math.erfc",
-	"math.Exp":       "math.exp",
-	"math.archExp":   "math.exp",
-	"math.Expm1":     "math.expm1",
-	"math.Exp2":      "math.exp2",
-	"math.archExp2":  "math.exp2",
-	"math.Floor":     "math.floor",
-	"math.archFloor": "math.floor",
-	"math.Frexp":     "math.frexp",
-	"math.Hypot":     "math.hypot",
-	"math.archHypot": "math.hypot",
-	"math.Ldexp":     "math.ldexp",
-	"math.Log":       "math.log",
-	"math.archLog":   "math.log",
-	"math.Log1p":     "math.log1p",
-	"math.Log10":     "math.log10",
-	"math.Log2":      "math.log2",
-	"math.Max":       "math.max",
-	"math.archMax":   "math.max",
-	"math.Min":       "math.min",
-	"math.archMin":   "math.min",
-	"math.Mod":       "math.mod",
-	"math.Modf":      "math.modf",
-	"math.archModf":  "math.modf",
-	"math.Pow":       "math.pow",
-	"math.Remainder": "math.remainder",
-	"math.Sin":       "math.sin",
-	"math.Sinh":      "math.sinh",
-	"math.Sqrt":      "math.sqrt",
-	"math.archSqrt":  "math.sqrt",
-	"math.Tan":       "math.tan",
-	"math.Tanh":      "math.tanh",
-	"math.Trunc":     "math.trunc",
-	"math.archTrunc": "math.trunc",
-}
-
-// createAlias implements the function (in the builder) as a call to the alias
-// function.
-func (b *builder) createAlias(alias llvm.Value) {
-	if b.Debug {
-		if b.fn.Syntax() != nil {
-			// Create debug info file if present.
-			b.difunc = b.attachDebugInfo(b.fn)
-		}
-		pos := b.program.Fset.Position(b.fn.Pos())
-		b.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), b.difunc, llvm.Metadata{})
-	}
-	entryBlock := llvm.AddBasicBlock(b.llvmFn, "entry")
-	b.SetInsertPointAtEnd(entryBlock)
-	if b.llvmFn.Type() != alias.Type() {
-		b.addError(b.fn.Pos(), "alias function should have the same type as aliasee "+alias.Name())
-		b.CreateUnreachable()
-		return
-	}
-	result := b.CreateCall(alias, b.llvmFn.Params(), "")
-	if result.Type().TypeKind() == llvm.VoidTypeKind {
-		b.CreateRetVoid()
-	} else {
-		b.CreateRet(result)
-	}
-}
@@ -101,55 +101,6 @@ func (b *builder) createSliceBoundsCheck(capacity, low, high, max llvm.Value, lo
 	b.createRuntimeAssert(outOfBounds, "slice", "slicePanic")
 }

-// createSliceToArrayPointerCheck adds a check for slice-to-array pointer
-// conversions. This conversion was added in Go 1.17. For details, see:
-// https://tip.golang.org/ref/spec#Conversions_from_slice_to_array_pointer
-func (b *builder) createSliceToArrayPointerCheck(sliceLen llvm.Value, arrayLen int64) {
-	// From the spec:
-	// > If the length of the slice is less than the length of the array, a
-	// > run-time panic occurs.
-	arrayLenValue := llvm.ConstInt(b.uintptrType, uint64(arrayLen), false)
-	isLess := b.CreateICmp(llvm.IntULT, sliceLen, arrayLenValue, "")
-	b.createRuntimeAssert(isLess, "slicetoarray", "sliceToArrayPointerPanic")
-}
-
-// createUnsafeSliceCheck inserts a runtime check used for unsafe.Slice. This
-// function must panic if the ptr/len parameters are invalid.
-func (b *builder) createUnsafeSliceCheck(ptr, len llvm.Value, lenType *types.Basic) {
-	// From the documentation of unsafe.Slice:
-	//   > At run time, if len is negative, or if ptr is nil and len is not
-	//   > zero, a run-time panic occurs.
-	// However, in practice, it is also necessary to check that the length is
-	// not too big that a GEP wouldn't be possible without wrapping the pointer.
-	// These two checks (non-negative and not too big) can be merged into one
-	// using an unsiged greater than.
-
-	// Make sure the len value is at least as big as a uintptr.
-	if len.Type().IntTypeWidth() < b.uintptrType.IntTypeWidth() {
-		if lenType.Info()&types.IsUnsigned != 0 {
-			len = b.CreateZExt(len, b.uintptrType, "")
-		} else {
-			len = b.CreateSExt(len, b.uintptrType, "")
-		}
-	}
-
-	// Determine the maximum slice size, and therefore the maximum value of the
-	// len parameter.
-	maxSize := b.maxSliceSize(ptr.Type().ElementType())
-	maxSizeValue := llvm.ConstInt(len.Type(), maxSize, false)
-
-	// Do the check. By using unsigned greater than for the length check, signed
-	// negative values are also checked (which are very large numbers when
-	// interpreted as signed values).
-	zero := llvm.ConstInt(len.Type(), 0, false)
-	lenOutOfBounds := b.CreateICmp(llvm.IntUGT, len, maxSizeValue, "")
-	ptrIsNil := b.CreateICmp(llvm.IntEQ, ptr, llvm.ConstNull(ptr.Type()), "")
-	lenIsNotZero := b.CreateICmp(llvm.IntNE, len, zero, "")
-	assert := b.CreateAnd(ptrIsNil, lenIsNotZero, "")
-	assert = b.CreateOr(assert, lenOutOfBounds, "")
-	b.createRuntimeAssert(assert, "unsafe.Slice", "unsafeSlicePanic")
-}
-
 // 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) {
@@ -208,13 +159,6 @@ func (b *builder) createNilCheck(inst ssa.Value, ptr llvm.Value, blockPrefix str
 	}

 	switch inst := inst.(type) {
-	case *ssa.Alloc:
-		// An alloc is never nil.
-		return
-	case *ssa.FreeVar:
-		// A free variable is allocated in a parent function and is thus never
-		// nil.
-		return
 	case *ssa.IndexAddr:
 		// This pointer is the result of an index operation into a slice or
 		// array. Such slices/arrays are already bounds checked so the pointer
@@ -58,10 +58,10 @@ func (b *builder) createCall(fn llvm.Value, args []llvm.Value, name string) llvm

 // Expand an argument type to a list that can be used in a function call
 // parameter list.
-func (c *compilerContext) expandFormalParamType(t llvm.Type, name string, goType types.Type) []paramInfo {
+func expandFormalParamType(t llvm.Type, name string, goType types.Type) []paramInfo {
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
-		fieldInfos := c.flattenAggregateType(t, name, goType)
+		fieldInfos := flattenAggregateType(t, name, goType)
 		if len(fieldInfos) <= maxFieldsPerParam {
 			return fieldInfos
 		} else {
@@ -105,7 +105,7 @@ func (b *builder) expandFormalParamOffsets(t llvm.Type) []uint64 {
 func (b *builder) expandFormalParam(v llvm.Value) []llvm.Value {
 	switch v.Type().TypeKind() {
 	case llvm.StructTypeKind:
-		fieldInfos := b.flattenAggregateType(v.Type(), "", nil)
+		fieldInfos := flattenAggregateType(v.Type(), "", nil)
 		if len(fieldInfos) <= maxFieldsPerParam {
 			fields := b.flattenAggregate(v)
 			if len(fields) != len(fieldInfos) {
@@ -124,15 +124,12 @@ 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 (c *compilerContext) flattenAggregateType(t llvm.Type, name string, goType types.Type) []paramInfo {
+func flattenAggregateType(t llvm.Type, name string, goType types.Type) []paramInfo {
 	typeFlags := getTypeFlags(goType)
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
-		var paramInfos []paramInfo
+		paramInfos := make([]paramInfo, 0, t.StructElementTypesCount())
 		for i, subfield := range t.StructElementTypes() {
-			if c.targetData.TypeAllocSize(subfield) == 0 {
-				continue
-			}
 			suffix := strconv.Itoa(i)
 			if goType != nil {
 				// Try to come up with a good suffix for this struct field,
@@ -155,7 +152,7 @@ func (c *compilerContext) flattenAggregateType(t llvm.Type, name string, goType
 					suffix = []string{"context", "funcptr"}[i]
 				}
 			}
-			subInfos := c.flattenAggregateType(subfield, name+"."+suffix, extractSubfield(goType, i))
+			subInfos := flattenAggregateType(subfield, name+"."+suffix, extractSubfield(goType, i))
 			for i := range subInfos {
 				subInfos[i].flags |= typeFlags
 			}
@@ -221,11 +218,8 @@ func extractSubfield(t types.Type, field int) types.Type {
 func (c *compilerContext) flattenAggregateTypeOffsets(t llvm.Type) []uint64 {
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
-		var fields []uint64
+		fields := make([]uint64, 0, t.StructElementTypesCount())
 		for fieldIndex, field := range t.StructElementTypes() {
-			if c.targetData.TypeAllocSize(field) == 0 {
-				continue
-			}
 			suboffsets := c.flattenAggregateTypeOffsets(field)
 			offset := c.targetData.ElementOffset(t, fieldIndex)
 			for i := range suboffsets {
@@ -244,11 +238,8 @@ func (c *compilerContext) flattenAggregateTypeOffsets(t llvm.Type) []uint64 {
 func (b *builder) flattenAggregate(v llvm.Value) []llvm.Value {
 	switch v.Type().TypeKind() {
 	case llvm.StructTypeKind:
-		var fields []llvm.Value
-		for i, field := range v.Type().StructElementTypes() {
-			if b.targetData.TypeAllocSize(field) == 0 {
-				continue
-			}
+		fields := make([]llvm.Value, 0, v.Type().StructElementTypesCount())
+		for i := range v.Type().StructElementTypes() {
 			subfield := b.CreateExtractValue(v, i, "")
 			subfields := b.flattenAggregate(subfield)
 			fields = append(fields, subfields...)
@@ -275,13 +266,10 @@ func (b *builder) collapseFormalParam(t llvm.Type, fields []llvm.Value) llvm.Val
 func (b *builder) collapseFormalParamInternal(t llvm.Type, fields []llvm.Value) (llvm.Value, []llvm.Value) {
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
-		flattened := b.flattenAggregateType(t, "", nil)
+		flattened := flattenAggregateType(t, "", nil)
 		if len(flattened) <= maxFieldsPerParam {
 			value := llvm.ConstNull(t)
 			for i, subtyp := range t.StructElementTypes() {
-				if b.targetData.TypeAllocSize(subtyp) == 0 {
-					continue
-				}
 				structField, remaining := b.collapseFormalParamInternal(subtyp, fields)
 				fields = remaining
 				value = b.CreateInsertValue(value, structField, i, "")
@@ -32,15 +32,8 @@ func (b *builder) createChanSend(instr *ssa.Send) {

 	// store value-to-send
 	valueType := b.getLLVMType(instr.X.Type())
-	isZeroSize := b.targetData.TypeAllocSize(valueType) == 0
-	var valueAlloca, valueAllocaCast, valueAllocaSize llvm.Value
-	if isZeroSize {
-		valueAlloca = llvm.ConstNull(llvm.PointerType(valueType, 0))
-		valueAllocaCast = llvm.ConstNull(b.i8ptrType)
-	} else {
-		valueAlloca, valueAllocaCast, valueAllocaSize = b.createTemporaryAlloca(valueType, "chan.value")
-		b.CreateStore(chanValue, valueAlloca)
-	}
+	valueAlloca, valueAllocaCast, valueAllocaSize := b.createTemporaryAlloca(valueType, "chan.value")
+	b.CreateStore(chanValue, valueAlloca)

 	// Allocate blockedlist buffer.
 	channelBlockedList := b.mod.GetTypeByName("runtime.channelBlockedList")
@@ -53,9 +46,7 @@ func (b *builder) createChanSend(instr *ssa.Send) {
 	// 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)
-	if !isZeroSize {
-		b.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
-	}
+	b.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
 }

 // createChanRecv emits a pseudo chan receive operation. It is lowered to the
@@ -65,14 +56,7 @@ func (b *builder) createChanRecv(unop *ssa.UnOp) llvm.Value {
 	ch := b.getValue(unop.X)

 	// Allocate memory to receive into.
-	isZeroSize := b.targetData.TypeAllocSize(valueType) == 0
-	var valueAlloca, valueAllocaCast, valueAllocaSize llvm.Value
-	if isZeroSize {
-		valueAlloca = llvm.ConstNull(llvm.PointerType(valueType, 0))
-		valueAllocaCast = llvm.ConstNull(b.i8ptrType)
-	} else {
-		valueAlloca, valueAllocaCast, valueAllocaSize = b.createTemporaryAlloca(valueType, "chan.value")
-	}
+	valueAlloca, valueAllocaCast, valueAllocaSize := b.createTemporaryAlloca(valueType, "chan.value")

 	// Allocate blockedlist buffer.
 	channelBlockedList := b.mod.GetTypeByName("runtime.channelBlockedList")
@@ -80,14 +64,9 @@ func (b *builder) createChanRecv(unop *ssa.UnOp) llvm.Value {

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

 	if unop.CommaOk {
 		tuple := llvm.Undef(b.ctx.StructType([]llvm.Type{valueType, b.ctx.Int1Type()}, false))
@@ -137,6 +116,7 @@ func (b *builder) createSelect(expr *ssa.Select) llvm.Value {
 	// determine the receive buffer size and alignment.
 	recvbufSize := uint64(0)
 	recvbufAlign := 0
+	hasReceives := false
 	var selectStates []llvm.Value
 	chanSelectStateType := b.getLLVMRuntimeType("chanSelectState")
 	for _, state := range expr.States {
@@ -153,6 +133,7 @@ func (b *builder) createSelect(expr *ssa.Select) llvm.Value {
 			if align := b.targetData.ABITypeAlignment(llvmType); align > recvbufAlign {
 				recvbufAlign = align
 			}
+			hasReceives = true
 		case types.SendOnly:
 			// Store this value in an alloca and put a pointer to this alloca
 			// in the send state.
@@ -169,7 +150,7 @@ 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)
-	if recvbufSize != 0 {
+	if hasReceives {
 		allocaType := llvm.ArrayType(b.ctx.Int8Type(), int(recvbufSize))
 		recvbufAlloca, _, _ := b.createTemporaryAlloca(allocaType, "select.recvbuf.alloca")
 		recvbufAlloca.SetAlignment(recvbufAlign)
@@ -20,11 +20,6 @@ import (
 	"tinygo.org/x/go-llvm"
 )

-// Version of the compiler pacakge. Must be incremented each time the compiler
-// package changes in a way that affects the generated LLVM module.
-// This version is independent of the TinyGo version number.
-const Version = 19 // last change: fix channel ops with zero values
-
 func init() {
 	llvm.InitializeAllTargets()
 	llvm.InitializeAllTargetMCs()
@@ -59,7 +54,6 @@ type Config struct {
 	DefaultStackSize   uint64
 	NeedsStackObjects  bool
 	Debug              bool // Whether to emit debug information in the LLVM module.
-	LLVMFeatures       string
 }

 // compilerContext contains function-independent data that should still be
@@ -74,7 +68,6 @@ type compilerContext struct {
 	cu               llvm.Metadata
 	difiles          map[string]llvm.Metadata
 	ditypes          map[types.Type]llvm.Metadata
-	llvmTypes        map[types.Type]llvm.Type
 	machine          llvm.TargetMachine
 	targetData       llvm.TargetData
 	intType          llvm.Type
@@ -91,14 +84,12 @@ type compilerContext struct {
 // importantly with a newly created LLVM context and module.
 func newCompilerContext(moduleName string, machine llvm.TargetMachine, config *Config, dumpSSA bool) *compilerContext {
 	c := &compilerContext{
-		Config:      config,
-		DumpSSA:     dumpSSA,
-		difiles:     make(map[string]llvm.Metadata),
-		ditypes:     make(map[types.Type]llvm.Metadata),
-		llvmTypes:   make(map[types.Type]llvm.Type),
-		machine:     machine,
-		targetData:  machine.CreateTargetData(),
-		astComments: map[string]*ast.CommentGroup{},
+		Config:     config,
+		DumpSSA:    dumpSSA,
+		difiles:    make(map[string]llvm.Metadata),
+		ditypes:    make(map[types.Type]llvm.Metadata),
+		machine:    machine,
+		targetData: machine.CreateTargetData(),
 	}

 	c.ctx = llvm.NewContext()
@@ -188,12 +179,7 @@ func NewTargetMachine(config *Config) (llvm.TargetMachine, error) {
 	if err != nil {
 		return llvm.TargetMachine{}, err
 	}
-
-	feat := config.Features
-	if len(config.LLVMFeatures) > 0 {
-		feat = append(feat, config.LLVMFeatures)
-	}
-	features := strings.Join(feat, ",")
+	features := strings.Join(config.Features, ",")

 	var codeModel llvm.CodeModel
 	var relocationModel llvm.RelocMode
@@ -255,14 +241,21 @@ func Sizes(machine llvm.TargetMachine) types.Sizes {
 	}
 }

-// CompilePackage compiles a single package to a LLVM module.
-func CompilePackage(moduleName string, pkg *loader.Package, ssaPkg *ssa.Package, machine llvm.TargetMachine, config *Config, dumpSSA bool) (llvm.Module, []error) {
-	c := newCompilerContext(moduleName, machine, config, dumpSSA)
-	c.runtimePkg = ssaPkg.Prog.ImportedPackage("runtime").Pkg
-	c.program = ssaPkg.Prog
+// CompileProgram compiles the given package path or .go file path. Return an
+// error when this fails (in any stage). If successful it returns the LLVM
+// module. If not, one or more errors will be returned.
+func CompileProgram(lprogram *loader.Program, machine llvm.TargetMachine, config *Config, dumpSSA bool) (llvm.Module, []error) {
+	c := newCompilerContext("", machine, config, dumpSSA)

-	// Convert AST to SSA.
-	ssaPkg.Build()
+	c.program = lprogram.LoadSSA()
+	c.program.Build()
+	c.runtimePkg = c.program.ImportedPackage("runtime").Pkg
+
+	// Run a simple dead code elimination pass.
+	functions, err := c.simpleDCE(lprogram)
+	if err != nil {
+		return llvm.Module{}, []error{err}
+	}

 	// Initialize debug information.
 	if c.Debug {
@@ -275,31 +268,62 @@ func CompilePackage(moduleName string, pkg *loader.Package, ssaPkg *ssa.Package,
 		})
 	}

-	// Load comments such as //go:extern on globals.
-	c.loadASTComments(pkg)
+	c.loadASTComments(lprogram)

 	// Predeclare the runtime.alloc function, which is used by the wordpack
 	// functionality.
 	c.getFunction(c.program.ImportedPackage("runtime").Members["alloc"].(*ssa.Function))

-	// Compile all functions, methods, and global variables in this package.
+	// Add definitions to declarations.
+	var initFuncs []llvm.Value
 	irbuilder := c.ctx.NewBuilder()
 	defer irbuilder.Dispose()
-	c.createPackage(irbuilder, ssaPkg)
+	for _, f := range functions {
+		if f.Synthetic == "package initializer" {
+			initFuncs = append(initFuncs, c.getFunction(f))
+		}
+		if f.Blocks == nil {
+			continue // external function
+		}
+
+		// Create the function definition.
+		b := newBuilder(c, irbuilder, f)
+		b.createFunction()
+	}
+
+	// After all packages are imported, add a synthetic initializer function
+	// that calls the initializer of each package.
+	initFn := c.program.ImportedPackage("runtime").Members["initAll"].(*ssa.Function)
+	llvmInitFn := c.getFunction(initFn)
+	llvmInitFn.SetLinkage(llvm.InternalLinkage)
+	llvmInitFn.SetUnnamedAddr(true)
+	if c.Debug {
+		difunc := c.attachDebugInfo(initFn)
+		pos := c.program.Fset.Position(initFn.Pos())
+		irbuilder.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), difunc, llvm.Metadata{})
+	}
+	llvmInitFn.Param(0).SetName("context")
+	llvmInitFn.Param(1).SetName("parentHandle")
+	block := c.ctx.AddBasicBlock(llvmInitFn, "entry")
+	irbuilder.SetInsertPointAtEnd(block)
+	for _, fn := range initFuncs {
+		irbuilder.CreateCall(fn, []llvm.Value{llvm.Undef(c.i8ptrType), llvm.Undef(c.i8ptrType)}, "")
+	}
+	irbuilder.CreateRetVoid()

 	// see: https://reviews.llvm.org/D18355
 	if c.Debug {
 		c.mod.AddNamedMetadataOperand("llvm.module.flags",
 			c.ctx.MDNode([]llvm.Metadata{
 				llvm.ConstInt(c.ctx.Int32Type(), 1, false).ConstantAsMetadata(), // Error on mismatch
-				c.ctx.MDString("Debug Info Version"),
+				llvm.GlobalContext().MDString("Debug Info Version"),
 				llvm.ConstInt(c.ctx.Int32Type(), 3, false).ConstantAsMetadata(), // DWARF version
 			}),
 		)
 		c.mod.AddNamedMetadataOperand("llvm.module.flags",
 			c.ctx.MDNode([]llvm.Metadata{
 				llvm.ConstInt(c.ctx.Int32Type(), 1, false).ConstantAsMetadata(),
-				c.ctx.MDString("Dwarf Version"),
+				llvm.GlobalContext().MDString("Dwarf Version"),
 				llvm.ConstInt(c.ctx.Int32Type(), 4, false).ConstantAsMetadata(),
 			}),
 		)
@@ -309,6 +333,50 @@ func CompilePackage(moduleName string, pkg *loader.Package, ssaPkg *ssa.Package,
 	return c.mod, c.diagnostics
 }

+// CompilePackage compiles a single package to a LLVM module.
+func CompilePackage(moduleName string, pkg *loader.Package, machine llvm.TargetMachine, config *Config, dumpSSA bool) (llvm.Module, []error) {
+	c := newCompilerContext(moduleName, machine, config, dumpSSA)
+
+	// Build SSA from AST.
+	ssaPkg := pkg.LoadSSA()
+	ssaPkg.Build()
+
+	// Sort by position, so that the order of the functions in the IR matches
+	// the order of functions in the source file. This is useful for testing,
+	// for example.
+	var members []string
+	for name := range ssaPkg.Members {
+		members = append(members, name)
+	}
+	sort.Slice(members, func(i, j int) bool {
+		iPos := ssaPkg.Members[members[i]].Pos()
+		jPos := ssaPkg.Members[members[j]].Pos()
+		if i == j {
+			// Cannot sort by pos, so do it by name.
+			return members[i] < members[j]
+		}
+		return iPos < jPos
+	})
+
+	// Define all functions.
+	irbuilder := c.ctx.NewBuilder()
+	defer irbuilder.Dispose()
+	for _, name := range members {
+		member := ssaPkg.Members[name]
+		switch member := member.(type) {
+		case *ssa.Function:
+			if member.Blocks == nil {
+				continue // external function
+			}
+			// Create the function definition.
+			b := newBuilder(c, irbuilder, member)
+			b.createFunction()
+		}
+	}
+
+	return c.mod, nil
+}
+
 // getLLVMRuntimeType obtains a named type from the runtime package and returns
 // it as a LLVM type, creating it if necessary. It is a shorthand for
 // getLLVMType(getRuntimeType(name)).
@@ -317,23 +385,10 @@ func (c *compilerContext) getLLVMRuntimeType(name string) llvm.Type {
 	return c.getLLVMType(typ)
 }

-// getLLVMType returns a LLVM type for a Go type. It doesn't recreate already
-// created types. This is somewhat important for performance, but especially
-// important for named struct types (which should only be created once).
+// getLLVMType creates and returns a LLVM type for a Go type. In the case of
+// named struct types (or Go types implemented as named LLVM structs such as
+// strings) it also creates it first if necessary.
 func (c *compilerContext) getLLVMType(goType types.Type) llvm.Type {
-	// Try to load the LLVM type from the cache.
-	if t, ok := c.llvmTypes[goType]; ok {
-		return t
-	}
-	// Not already created, so adding this type to the cache.
-	llvmType := c.makeLLVMType(goType)
-	c.llvmTypes[goType] = llvmType
-	return llvmType
-}
-
-// makeLLVMType creates a LLVM type for a Go type. Don't call this, use
-// getLLVMType instead.
-func (c *compilerContext) makeLLVMType(goType types.Type) llvm.Type {
 	switch typ := goType.(type) {
 	case *types.Array:
 		elemType := c.getLLVMType(typ.Elem())
@@ -382,10 +437,12 @@ func (c *compilerContext) makeLLVMType(goType types.Type) llvm.Type {
 			// LLVM. This is because it is otherwise impossible to create
 			// self-referencing types such as linked lists.
 			llvmName := typ.Obj().Pkg().Path() + "." + typ.Obj().Name()
-			llvmType := c.ctx.StructCreateNamed(llvmName)
-			c.llvmTypes[goType] = llvmType // avoid infinite recursion
-			underlying := c.getLLVMType(st)
-			llvmType.StructSetBody(underlying.StructElementTypes(), false)
+			llvmType := c.mod.GetTypeByName(llvmName)
+			if llvmType.IsNil() {
+				llvmType = c.ctx.StructCreateNamed(llvmName)
+				underlying := c.getLLVMType(st)
+				llvmType.StructSetBody(underlying.StructElementTypes(), false)
+			}
 			return llvmType
 		}
 		return c.getLLVMType(typ.Underlying())
@@ -663,9 +720,8 @@ func (c *compilerContext) attachDebugInfo(f *ssa.Function) llvm.Metadata {
 // debug info is added to the function.
 func (c *compilerContext) attachDebugInfoRaw(f *ssa.Function, llvmFn llvm.Value, suffix, filename string, line int) llvm.Metadata {
 	// Debug info for this function.
-	params := getParams(f.Signature)
-	diparams := make([]llvm.Metadata, 0, len(params))
-	for _, param := range params {
+	diparams := make([]llvm.Metadata, 0, len(f.Params))
+	for _, param := range f.Params {
 		diparams = append(diparams, c.getDIType(param.Type()))
 	}
 	diFuncType := c.dibuilder.CreateSubroutineType(llvm.DISubroutineType{
@@ -703,109 +759,6 @@ func (c *compilerContext) getDIFile(filename string) llvm.Metadata {
 	return c.difiles[filename]
 }

-// createPackage builds the LLVM IR for all types, methods, and global variables
-// in the given package.
-func (c *compilerContext) createPackage(irbuilder llvm.Builder, pkg *ssa.Package) {
-	// Sort by position, so that the order of the functions in the IR matches
-	// the order of functions in the source file. This is useful for testing,
-	// for example.
-	var members []string
-	for name := range pkg.Members {
-		members = append(members, name)
-	}
-	sort.Slice(members, func(i, j int) bool {
-		iPos := pkg.Members[members[i]].Pos()
-		jPos := pkg.Members[members[j]].Pos()
-		if i == j {
-			// Cannot sort by pos, so do it by name.
-			return members[i] < members[j]
-		}
-		return iPos < jPos
-	})
-
-	// Define all functions.
-	for _, name := range members {
-		member := pkg.Members[name]
-		switch member := member.(type) {
-		case *ssa.Function:
-			// Create the function definition.
-			b := newBuilder(c, irbuilder, member)
-			if member.Blocks == nil {
-				continue // external function
-			}
-			b.createFunction()
-		case *ssa.Type:
-			if types.IsInterface(member.Type()) {
-				// Interfaces don't have concrete methods.
-				continue
-			}
-
-			// Named type. We should make sure all methods are created.
-			// This includes both functions with pointer receivers and those
-			// without.
-			methods := getAllMethods(pkg.Prog, member.Type())
-			methods = append(methods, getAllMethods(pkg.Prog, types.NewPointer(member.Type()))...)
-			for _, method := range methods {
-				// Parse this method.
-				fn := pkg.Prog.MethodValue(method)
-				if fn.Blocks == nil {
-					continue // external function
-				}
-				if member.Type().String() != member.String() {
-					// This is a member on a type alias. Do not build such a
-					// function.
-					continue
-				}
-				if fn.Synthetic != "" && fn.Synthetic != "package initializer" {
-					// This function is a kind of wrapper function (created by
-					// the ssa package, not appearing in the source code) that
-					// is created by the getFunction method as needed.
-					// Therefore, don't build it here to avoid "function
-					// redeclared" errors.
-					continue
-				}
-				// Create the function definition.
-				b := newBuilder(c, irbuilder, fn)
-				b.createFunction()
-			}
-		case *ssa.Global:
-			// Global variable.
-			info := c.getGlobalInfo(member)
-			global := c.getGlobal(member)
-			if !info.extern {
-				global.SetInitializer(llvm.ConstNull(global.Type().ElementType()))
-				global.SetVisibility(llvm.HiddenVisibility)
-				if info.section != "" {
-					global.SetSection(info.section)
-				}
-			}
-		}
-	}
-
-	// Add forwarding functions for functions that would otherwise be
-	// implemented in assembly.
-	for _, name := range members {
-		member := pkg.Members[name]
-		switch member := member.(type) {
-		case *ssa.Function:
-			if member.Blocks != nil {
-				continue // external function
-			}
-			info := c.getFunctionInfo(member)
-			if aliasName, ok := stdlibAliases[info.linkName]; ok {
-				alias := c.mod.NamedFunction(aliasName)
-				if alias.IsNil() {
-					// Shouldn't happen, but perhaps best to just ignore.
-					// The error will be a link error, if there is an error.
-					continue
-				}
-				b := newBuilder(c, irbuilder, member)
-				b.createAlias(alias)
-			}
-		}
-	}
-}
-
 // createFunction builds the LLVM IR implementation for this function. The
 // function must not yet be defined, otherwise this function will create a
 // diagnostic.
@@ -814,7 +767,7 @@ func (b *builder) createFunction() {
 		fmt.Printf("\nfunc %s:\n", b.fn)
 	}
 	if !b.llvmFn.IsDeclaration() {
-		errValue := b.llvmFn.Name() + " redeclared in this program"
+		errValue := b.fn.Name() + " redeclared in this program"
 		fnPos := getPosition(b.llvmFn)
 		if fnPos.IsValid() {
 			errValue += "\n\tprevious declaration at " + fnPos.String()
@@ -823,18 +776,9 @@ func (b *builder) createFunction() {
 		return
 	}
 	if !b.info.exported {
-		b.llvmFn.SetVisibility(llvm.HiddenVisibility)
+		b.llvmFn.SetLinkage(llvm.InternalLinkage)
 		b.llvmFn.SetUnnamedAddr(true)
 	}
-	if b.info.section != "" {
-		b.llvmFn.SetSection(b.info.section)
-	}
-	if b.info.exported && strings.HasPrefix(b.Triple, "wasm") {
-		// Set the exported name. This is necessary for WebAssembly because
-		// otherwise the function is not exported.
-		functionAttr := b.ctx.CreateStringAttribute("wasm-export-name", b.info.linkName)
-		b.llvmFn.AddFunctionAttr(functionAttr)
-	}

 	// Some functions have a pragma controlling the inlining level.
 	switch b.info.inline {
@@ -877,7 +821,7 @@ func (b *builder) createFunction() {
 	for _, param := range b.fn.Params {
 		llvmType := b.getLLVMType(param.Type())
 		fields := make([]llvm.Value, 0, 1)
-		for _, info := range b.expandFormalParamType(llvmType, param.Name(), param.Type()) {
+		for _, info := range expandFormalParamType(llvmType, param.Name(), param.Type()) {
 			param := b.llvmFn.Param(llvmParamIndex)
 			param.SetName(info.name)
 			fields = append(fields, param)
@@ -1004,69 +948,13 @@ func (b *builder) createFunction() {
 			b.trackValue(phi.llvm)
 		}
 	}
-
-	// Create anonymous functions (closures etc.).
-	for _, sub := range b.fn.AnonFuncs {
-		b := newBuilder(b.compilerContext, b.Builder, sub)
-		b.createFunction()
-	}
-}
-
-// posser is an interface that's implemented by both ssa.Value and
-// ssa.Instruction. It is implemented by everything that has a Pos() method,
-// which is all that getPos() needs.
-type posser interface {
-	Pos() token.Pos
-}
-
-// getPos returns position information for a ssa.Value or ssa.Instruction.
-//
-// Not all instructions have position information, especially when they're
-// implicit (such as implicit casts or implicit returns at the end of a
-// function). In these cases, it makes sense to try a bit harder to guess what
-// the position really should be.
-func getPos(val posser) token.Pos {
-	pos := val.Pos()
-	if pos != token.NoPos {
-		// Easy: position is known.
-		return pos
-	}
-
-	// No position information is known.
-	switch val := val.(type) {
-	case *ssa.MakeInterface:
-		return getPos(val.X)
-	case *ssa.MakeClosure:
-		return val.Fn.(*ssa.Function).Pos()
-	case *ssa.Return:
-		syntax := val.Parent().Syntax()
-		if syntax != nil {
-			// non-synthetic
-			return syntax.End()
-		}
-		return token.NoPos
-	case *ssa.FieldAddr:
-		return getPos(val.X)
-	case *ssa.IndexAddr:
-		return getPos(val.X)
-	case *ssa.Slice:
-		return getPos(val.X)
-	case *ssa.Store:
-		return getPos(val.Addr)
-	case *ssa.Extract:
-		return getPos(val.Tuple)
-	default:
-		// This is reachable, for example with *ssa.Const, *ssa.If, and
-		// *ssa.Jump. They might be implemented in some way in the future.
-		return token.NoPos
-	}
 }

 // createInstruction builds the LLVM IR equivalent instructions for the
 // particular Go SSA instruction.
 func (b *builder) createInstruction(instr ssa.Instruction) {
 	if b.Debug {
-		pos := b.program.Fset.Position(getPos(instr))
+		pos := b.program.Fset.Position(instr.Pos())
 		b.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), b.difunc, llvm.Metadata{})
 	}

@@ -1092,8 +980,52 @@ func (b *builder) createInstruction(instr ssa.Instruction) {
 	case *ssa.Defer:
 		b.createDefer(instr)
 	case *ssa.Go:
+		// Get all function parameters to pass to the goroutine.
+		var params []llvm.Value
+		for _, param := range instr.Call.Args {
+			params = append(params, b.getValue(param))
+		}
+
 		// Start a new goroutine.
-		b.createGo(instr)
+		if callee := instr.Call.StaticCallee(); callee != nil {
+			// Static callee is known. This makes it easier to start a new
+			// goroutine.
+			var context llvm.Value
+			switch value := instr.Call.Value.(type) {
+			case *ssa.Function:
+				// Goroutine call is regular function call. No context is necessary.
+				context = llvm.Undef(b.i8ptrType)
+			case *ssa.MakeClosure:
+				// A goroutine call on a func value, but the callee is trivial to find. For
+				// example: immediately applied functions.
+				funcValue := b.getValue(value)
+				context = b.extractFuncContext(funcValue)
+			default:
+				panic("StaticCallee returned an unexpected value")
+			}
+			params = append(params, context) // context parameter
+			b.createGoInstruction(b.getFunction(callee), params, "", callee.Pos())
+		} else if !instr.Call.IsInvoke() {
+			// This is a function pointer.
+			// At the moment, two extra params are passed to the newly started
+			// goroutine:
+			//   * The function context, for closures.
+			//   * The function pointer (for tasks).
+			funcPtr, context := b.decodeFuncValue(b.getValue(instr.Call.Value), instr.Call.Value.Type().Underlying().(*types.Signature))
+			params = append(params, context) // context parameter
+			switch b.Scheduler {
+			case "none", "coroutines":
+				// There are no additional parameters needed for the goroutine start operation.
+			case "tasks":
+				// Add the function pointer as a parameter to start the goroutine.
+				params = append(params, funcPtr)
+			default:
+				panic("unknown scheduler type")
+			}
+			b.createGoInstruction(funcPtr, params, b.fn.RelString(nil), instr.Pos())
+		} else {
+			b.addError(instr.Pos(), "todo: go on interface call")
+		}
 	case *ssa.If:
 		cond := b.getValue(instr.Cond)
 		block := instr.Block()
@@ -1306,38 +1238,6 @@ func (b *builder) createBuiltin(argTypes []types.Type, argValues []llvm.Value, c
 	case "ssa:wrapnilchk":
 		// TODO: do an actual nil check?
 		return argValues[0], nil
-
-	// Builtins from the unsafe package.
-	case "Add": // unsafe.Add
-		// This is basically just a GEP operation.
-		// Note: the pointer is always of type *i8.
-		ptr := argValues[0]
-		len := argValues[1]
-		return b.CreateGEP(ptr, []llvm.Value{len}, ""), nil
-	case "Slice": // unsafe.Slice
-		// This creates a slice from a pointer and a length.
-		// Note that the exception mentioned in the documentation (if the
-		// pointer and length are nil, the slice is also nil) is trivially
-		// already the case.
-		ptr := argValues[0]
-		len := argValues[1]
-		slice := llvm.Undef(b.ctx.StructType([]llvm.Type{
-			ptr.Type(),
-			b.uintptrType,
-			b.uintptrType,
-		}, false))
-		b.createUnsafeSliceCheck(ptr, len, argTypes[1].Underlying().(*types.Basic))
-		if len.Type().IntTypeWidth() < b.uintptrType.IntTypeWidth() {
-			// Too small, zero-extend len.
-			len = b.CreateZExt(len, b.uintptrType, "")
-		} else if len.Type().IntTypeWidth() > b.uintptrType.IntTypeWidth() {
-			// Too big, truncate len.
-			len = b.CreateTrunc(len, b.uintptrType, "")
-		}
-		slice = b.CreateInsertValue(slice, ptr, 0, "")
-		slice = b.CreateInsertValue(slice, len, 1, "")
-		slice = b.CreateInsertValue(slice, len, 2, "")
-		return slice, nil
 	default:
 		return llvm.Value{}, b.makeError(pos, "todo: builtin: "+callName)
 	}
@@ -1366,11 +1266,6 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 			return b.createMemoryCopyCall(fn, instr.Args)
 		case name == "runtime.memzero":
 			return b.createMemoryZeroCall(instr.Args)
-		case name == "math.Ceil" || name == "math.Floor" || name == "math.Sqrt" || name == "math.Trunc":
-			result, ok := b.createMathOp(instr)
-			if ok {
-				return result, nil
-			}
 		case name == "device.Asm" || name == "device/arm.Asm" || name == "device/arm64.Asm" || name == "device/avr.Asm" || name == "device/riscv.Asm":
 			return b.createInlineAsm(instr.Args)
 		case name == "device.AsmFull" || name == "device/arm.AsmFull" || name == "device/arm64.AsmFull" || name == "device/avr.AsmFull" || name == "device/riscv.AsmFull":
@@ -1383,8 +1278,6 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 			return b.emitCSROperation(instr)
 		case strings.HasPrefix(name, "syscall.Syscall"):
 			return b.createSyscall(instr)
-		case strings.HasPrefix(name, "syscall.rawSyscallNoError"):
-			return b.createRawSyscallNoError(instr)
 		case strings.HasPrefix(name, "runtime/volatile.Load"):
 			return b.createVolatileLoad(instr)
 		case strings.HasPrefix(name, "runtime/volatile.Store"):
@@ -1484,28 +1377,6 @@ func (b *builder) getValue(expr ssa.Value) llvm.Value {
 	}
 }

-// maxSliceSize determines the maximum size a slice of the given element type
-// can be.
-func (c *compilerContext) maxSliceSize(elementType llvm.Type) uint64 {
-	// Calculate ^uintptr(0), which is the max value that fits in uintptr.
-	maxPointerValue := llvm.ConstNot(llvm.ConstInt(c.uintptrType, 0, false)).ZExtValue()
-	// Calculate (^uint(0))/2, which is the max value that fits in an int.
-	maxIntegerValue := llvm.ConstNot(llvm.ConstInt(c.intType, 0, false)).ZExtValue() / 2
-
-	// Determine the maximum allowed size for a slice. The biggest possible
-	// pointer (starting from 0) would be maxPointerValue*sizeof(elementType) so
-	// divide by the element type to get the real maximum size.
-	maxSize := maxPointerValue / c.targetData.TypeAllocSize(elementType)
-
-	// len(slice) is an int. Make sure the length remains small enough to fit in
-	// an int.
-	if maxSize > maxIntegerValue {
-		maxSize = maxIntegerValue
-	}
-
-	return maxSize
-}
-
 // createExpr translates a Go SSA expression to LLVM IR. This can be zero, one,
 // or multiple LLVM IR instructions and/or runtime calls.
 func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
@@ -1719,8 +1590,10 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		elemSize := b.targetData.TypeAllocSize(llvmElemType)
 		elemSizeValue := llvm.ConstInt(b.uintptrType, elemSize, false)

-		maxSize := b.maxSliceSize(llvmElemType)
-		if elemSize > maxSize {
+		// Calculate (^uintptr(0)) >> 1, which is the max value that fits in
+		// uintptr if uintptr were signed.
+		maxSize := llvm.ConstLShr(llvm.ConstNot(llvm.ConstInt(b.uintptrType, 0, false)), llvm.ConstInt(b.uintptrType, 1, false))
+		if elemSize > maxSize.ZExtValue() {
 			// This seems to be checked by the typechecker already, but let's
 			// check it again just to be sure.
 			return llvm.Value{}, b.makeError(expr.Pos(), fmt.Sprintf("slice element type is too big (%v bytes)", elemSize))
@@ -1729,8 +1602,7 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		// Bounds checking.
 		lenType := expr.Len.Type().Underlying().(*types.Basic)
 		capType := expr.Cap.Type().Underlying().(*types.Basic)
-		maxSizeValue := llvm.ConstInt(b.uintptrType, maxSize, false)
-		b.createSliceBoundsCheck(maxSizeValue, sliceLen, sliceCap, sliceCap, lenType, capType, capType)
+		b.createSliceBoundsCheck(maxSize, sliceLen, sliceCap, sliceCap, lenType, capType, capType)

 		// Allocate the backing array.
 		sliceCapCast, err := b.createConvert(expr.Cap.Type(), types.Typ[types.Uintptr], sliceCap, expr.Pos())
@@ -1973,17 +1845,6 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		default:
 			return llvm.Value{}, b.makeError(expr.Pos(), "unknown slice type: "+typ.String())
 		}
-	case *ssa.SliceToArrayPointer:
-		// Conversion from a slice to an array pointer, as the name clearly
-		// says. This requires a runtime check to make sure the slice is at
-		// least as big as the array.
-		slice := b.getValue(expr.X)
-		sliceLen := b.CreateExtractValue(slice, 1, "")
-		arrayLen := expr.Type().Underlying().(*types.Pointer).Elem().Underlying().(*types.Array).Len()
-		b.createSliceToArrayPointerCheck(sliceLen, arrayLen)
-		ptr := b.CreateExtractValue(slice, 0, "")
-		ptr = b.CreateBitCast(ptr, b.getLLVMType(expr.Type()), "")
-		return ptr, nil
 	case *ssa.TypeAssert:
 		return b.createTypeAssert(expr), nil
 	case *ssa.UnOp:
@@ -2383,20 +2244,14 @@ func (b *builder) createConst(prefix string, expr *ssa.Const) llvm.Value {
 		} else if typ.Info()&types.IsString != 0 {
 			str := constant.StringVal(expr.Value)
 			strLen := llvm.ConstInt(b.uintptrType, uint64(len(str)), false)
-			var strPtr llvm.Value
-			if str != "" {
-				objname := prefix + "$string"
-				global := llvm.AddGlobal(b.mod, llvm.ArrayType(b.ctx.Int8Type(), len(str)), objname)
-				global.SetInitializer(b.ctx.ConstString(str, false))
-				global.SetLinkage(llvm.InternalLinkage)
-				global.SetGlobalConstant(true)
-				global.SetUnnamedAddr(true)
-				global.SetAlignment(1)
-				zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
-				strPtr = b.CreateInBoundsGEP(global, []llvm.Value{zero, zero}, "")
-			} else {
-				strPtr = llvm.ConstNull(b.i8ptrType)
-			}
+			objname := prefix + "$string"
+			global := llvm.AddGlobal(b.mod, llvm.ArrayType(b.ctx.Int8Type(), len(str)), objname)
+			global.SetInitializer(b.ctx.ConstString(str, false))
+			global.SetLinkage(llvm.InternalLinkage)
+			global.SetGlobalConstant(true)
+			global.SetUnnamedAddr(true)
+			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
+			strPtr := b.CreateInBoundsGEP(global, []llvm.Value{zero, zero}, "")
 			strObj := llvm.ConstNamedStruct(b.getLLVMRuntimeType("_string"), []llvm.Value{strPtr, strLen})
 			return strObj
 		} else if typ.Kind() == types.UnsafePointer {
@@ -4,12 +4,12 @@ import (
 	"flag"
 	"go/types"
 	"io/ioutil"
+	"regexp"
 	"strconv"
 	"strings"
 	"testing"

 	"github.com/tinygo-org/tinygo/compileopts"
-	"github.com/tinygo-org/tinygo/goenv"
 	"github.com/tinygo-org/tinygo/loader"
 	"tinygo.org/x/go-llvm"
 )
@@ -17,87 +17,43 @@ import (
 // Pass -update to go test to update the output of the test files.
 var flagUpdate = flag.Bool("update", false, "update tests based on test output")

-type testCase struct {
-	file   string
-	target string
-}
-
 // Basic tests for the compiler. Build some Go files and compare the output with
 // the expected LLVM IR for regression testing.
 func TestCompiler(t *testing.T) {
-	t.Parallel()
-
-	// Check LLVM version.
-	llvmMajor, err := strconv.Atoi(strings.SplitN(llvm.Version, ".", 2)[0])
+	target, err := compileopts.LoadTarget("i686--linux")
 	if err != nil {
-		t.Fatal("could not parse LLVM version:", llvm.Version)
+		t.Fatal("failed to load target:", err)
 	}
-	if llvmMajor < 11 {
-		// It is likely this version needs to be bumped in the future.
-		// The goal is to at least test the LLVM version that's used by default
-		// in TinyGo and (if possible without too many workarounds) also some
-		// previous versions.
-		t.Skip("compiler tests require LLVM 11 or above, got LLVM ", llvm.Version)
+	config := &compileopts.Config{
+		Options: &compileopts.Options{},
+		Target:  target,
 	}
-
-	tests := []testCase{
-		{"basic.go", ""},
-		{"pointer.go", ""},
-		{"slice.go", ""},
-		{"string.go", ""},
-		{"float.go", ""},
-		{"interface.go", ""},
-		{"func.go", ""},
-		{"pragma.go", ""},
-		{"goroutine.go", "wasm"},
-		{"goroutine.go", "cortex-m-qemu"},
-		{"channel.go", ""},
-		{"intrinsics.go", "cortex-m-qemu"},
-		{"intrinsics.go", "wasm"},
+	compilerConfig := &Config{
+		Triple:             config.Triple(),
+		GOOS:               config.GOOS(),
+		GOARCH:             config.GOARCH(),
+		CodeModel:          config.CodeModel(),
+		RelocationModel:    config.RelocationModel(),
+		Scheduler:          config.Scheduler(),
+		FuncImplementation: config.FuncImplementation(),
+		AutomaticStackSize: config.AutomaticStackSize(),
 	}
-
-	_, minor, err := goenv.GetGorootVersion(goenv.Get("GOROOT"))
+	machine, err := NewTargetMachine(compilerConfig)
 	if err != nil {
-		t.Fatal("could not read Go version:", err)
-	}
-	if minor >= 17 {
-		tests = append(tests, testCase{"go1.17.go", ""})
+		t.Fatal("failed to create target machine:", err)
 	}

-	for _, tc := range tests {
-		name := tc.file
-		targetString := "wasm"
-		if tc.target != "" {
-			targetString = tc.target
-			name = tc.file + "-" + tc.target
-		}
-
-		t.Run(name, func(t *testing.T) {
-			target, err := compileopts.LoadTarget(targetString)
-			if err != nil {
-				t.Fatal("failed to load target:", err)
-			}
-			config := &compileopts.Config{
-				Options: &compileopts.Options{},
-				Target:  target,
-			}
-			compilerConfig := &Config{
-				Triple:             config.Triple(),
-				GOOS:               config.GOOS(),
-				GOARCH:             config.GOARCH(),
-				CodeModel:          config.CodeModel(),
-				RelocationModel:    config.RelocationModel(),
-				Scheduler:          config.Scheduler(),
-				FuncImplementation: config.FuncImplementation(),
-				AutomaticStackSize: config.AutomaticStackSize(),
-			}
-			machine, err := NewTargetMachine(compilerConfig)
-			if err != nil {
-				t.Fatal("failed to create target machine:", err)
-			}
+	tests := []string{
+		"basic.go",
+		"pointer.go",
+		"slice.go",
+		"float.go",
+	}

+	for _, testCase := range tests {
+		t.Run(testCase, func(t *testing.T) {
 			// Load entire program AST into memory.
-			lprogram, err := loader.Load(config, []string{"./testdata/" + tc.file}, config.ClangHeaders, types.Config{
+			lprogram, err := loader.Load(config, []string{"./testdata/" + testCase}, config.ClangHeaders, types.Config{
 				Sizes: Sizes(machine),
 			})
 			if err != nil {
@@ -105,25 +61,19 @@ func TestCompiler(t *testing.T) {
 			}
 			err = lprogram.Parse()
 			if err != nil {
-				t.Fatalf("could not parse test case %s: %s", tc.file, err)
+				t.Fatalf("could not parse test case %s: %s", testCase, err)
 			}

 			// Compile AST to IR.
-			program := lprogram.LoadSSA()
 			pkg := lprogram.MainPkg()
-			mod, errs := CompilePackage(tc.file, pkg, program.Package(pkg.Pkg), machine, compilerConfig, false)
+			mod, errs := CompilePackage(testCase, pkg, machine, compilerConfig, false)
 			if errs != nil {
 				for _, err := range errs {
-					t.Error(err)
+					t.Log("error:", err)
 				}
 				return
 			}

-			err = llvm.VerifyModule(mod, llvm.PrintMessageAction)
-			if err != nil {
-				t.Error(err)
-			}
-
 			// Optimize IR a little.
 			funcPasses := llvm.NewFunctionPassManagerForModule(mod)
 			defer funcPasses.Dispose()
@@ -134,22 +84,18 @@ func TestCompiler(t *testing.T) {
 			}
 			funcPasses.FinalizeFunc()

-			outFilePrefix := tc.file[:len(tc.file)-3]
-			if tc.target != "" {
-				outFilePrefix += "-" + tc.target
-			}
-			outPath := "./testdata/" + outFilePrefix + ".ll"
+			outfile := "./testdata/" + testCase[:len(testCase)-3] + ".ll"

 			// Update test if needed. Do not check the result.
 			if *flagUpdate {
-				err := ioutil.WriteFile(outPath, []byte(mod.String()), 0666)
+				err := ioutil.WriteFile(outfile, []byte(mod.String()), 0666)
 				if err != nil {
 					t.Error("failed to write updated output file:", err)
 				}
 				return
 			}

-			expected, err := ioutil.ReadFile(outPath)
+			expected, err := ioutil.ReadFile(outfile)
 			if err != nil {
 				t.Fatal("failed to read golden file:", err)
 			}
@@ -161,6 +107,8 @@ func TestCompiler(t *testing.T) {
 	}
 }

+var alignRegexp = regexp.MustCompile(", align [0-9]+$")
+
 // fuzzyEqualIR returns true if the two LLVM IR strings passed in are roughly
 // equal. That means, only relevant lines are compared (excluding comments
 // etc.).
@@ -172,6 +120,15 @@ func fuzzyEqualIR(s1, s2 string) bool {
 	}
 	for i, line1 := range lines1 {
 		line2 := lines2[i]
+		match1 := alignRegexp.MatchString(line1)
+		match2 := alignRegexp.MatchString(line2)
+		if match1 != match2 {
+			// Only one of the lines has the align keyword. Remove it.
+			// This is a change to make the test work in both LLVM 10 and LLVM
+			// 11 (LLVM 11 appears to automatically add alignment everywhere).
+			line1 = alignRegexp.ReplaceAllString(line1, "")
+			line2 = alignRegexp.ReplaceAllString(line2, "")
+		}
 		if line1 != line2 {
 			return false
 		}
@@ -185,6 +142,12 @@ func fuzzyEqualIR(s1, s2 string) bool {
 // stripped out.
 func filterIrrelevantIRLines(lines []string) []string {
 	var out []string
+	llvmVersion, err := strconv.Atoi(strings.Split(llvm.Version, ".")[0])
+	if err != nil {
+		// Note: this should never happen and if it does, it will always happen
+		// for a particular build because llvm.Version is a constant.
+		panic(err)
+	}
 	for _, line := range lines {
 		line = strings.Split(line, ";")[0]    // strip out comments/info
 		line = strings.TrimRight(line, "\r ") // drop '\r' on Windows and remove trailing spaces from comments
@@ -194,6 +157,15 @@ func filterIrrelevantIRLines(lines []string) []string {
 		if strings.HasPrefix(line, "source_filename = ") {
 			continue
 		}
+		if llvmVersion < 10 && strings.HasPrefix(line, "attributes ") {
+			// Ignore attribute groups. These may change between LLVM versions.
+			// Right now test outputs are for LLVM 10.
+			continue
+		}
+		if llvmVersion < 10 && strings.HasPrefix(line, "target datalayout ") {
+			// Ignore the target layout. This may change between LLVM versions.
+			continue
+		}
 		out = append(out, line)
 	}
 	return out
@@ -352,7 +352,7 @@ func (b *builder) createRunDefers() {

 			// Get the real defer struct type and cast to it.
 			valueTypes := []llvm.Type{b.uintptrType, llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0)}
-			for _, param := range getParams(callback.Signature) {
+			for _, param := range callback.Params {
 				valueTypes = append(valueTypes, b.getLLVMType(param.Type()))
 			}
 			deferFrameType := b.ctx.StructType(valueTypes, false)
@@ -361,7 +361,7 @@ func (b *builder) createRunDefers() {
 			// Extract the params from the struct.
 			forwardParams := []llvm.Value{}
 			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
-			for i := range getParams(callback.Signature) {
+			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")
 				forwardParams = append(forwardParams, forwardParam)
@@ -25,18 +25,19 @@ func (c *compilerContext) createFuncValue(builder llvm.Builder, funcPtr, context
 		// Closure is: {context, function pointer}
 		funcValueScalar = funcPtr
 	case "switch":
+		sigGlobal := c.getTypeCode(sig)
 		funcValueWithSignatureGlobalName := funcPtr.Name() + "$withSignature"
 		funcValueWithSignatureGlobal := c.mod.NamedGlobal(funcValueWithSignatureGlobalName)
 		if funcValueWithSignatureGlobal.IsNil() {
 			funcValueWithSignatureType := c.getLLVMRuntimeType("funcValueWithSignature")
 			funcValueWithSignature := llvm.ConstNamedStruct(funcValueWithSignatureType, []llvm.Value{
 				llvm.ConstPtrToInt(funcPtr, c.uintptrType),
-				c.getFuncSignatureID(sig),
+				sigGlobal,
 			})
 			funcValueWithSignatureGlobal = llvm.AddGlobal(c.mod, funcValueWithSignatureType, funcValueWithSignatureGlobalName)
 			funcValueWithSignatureGlobal.SetInitializer(funcValueWithSignature)
 			funcValueWithSignatureGlobal.SetGlobalConstant(true)
-			funcValueWithSignatureGlobal.SetLinkage(llvm.LinkOnceODRLinkage)
+			funcValueWithSignatureGlobal.SetLinkage(llvm.InternalLinkage)
 		}
 		funcValueScalar = llvm.ConstPtrToInt(funcValueWithSignatureGlobal, c.uintptrType)
 	default:
@@ -49,19 +50,6 @@ func (c *compilerContext) createFuncValue(builder llvm.Builder, funcPtr, context
 	return funcValue
 }

-// getFuncSignatureID returns a new external global for a given signature. This
-// global reference is not real, it is only used during func lowering to assign
-// signature types to functions and will then be removed.
-func (c *compilerContext) getFuncSignatureID(sig *types.Signature) llvm.Value {
-	sigGlobalName := "reflect/types.funcid:" + getTypeCodeName(sig)
-	sigGlobal := c.mod.NamedGlobal(sigGlobalName)
-	if sigGlobal.IsNil() {
-		sigGlobal = llvm.AddGlobal(c.mod, c.ctx.Int8Type(), sigGlobalName)
-		sigGlobal.SetGlobalConstant(true)
-	}
-	return sigGlobal
-}
-
 // extractFuncScalar returns some scalar that can be used in comparisons. It is
 // a cheap operation.
 func (b *builder) extractFuncScalar(funcValue llvm.Value) llvm.Value {
@@ -83,7 +71,7 @@ func (b *builder) decodeFuncValue(funcValue llvm.Value, sig *types.Signature) (f
 		funcPtr = b.CreateExtractValue(funcValue, 1, "")
 	case "switch":
 		llvmSig := b.getRawFuncType(sig)
-		sigGlobal := b.getFuncSignatureID(sig)
+		sigGlobal := b.getTypeCode(sig)
 		funcPtr = b.createRuntimeCall("getFuncPtr", []llvm.Value{funcValue, sigGlobal}, "")
 		funcPtr = b.CreateIntToPtr(funcPtr, llvmSig, "")
 	default:
@@ -136,13 +124,13 @@ 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 c.expandFormalParamType(recv, "", nil) {
+		for _, info := range expandFormalParamType(recv, "", nil) {
 			paramTypes = append(paramTypes, info.llvmType)
 		}
 	}
 	for i := 0; i < typ.Params().Len(); i++ {
 		subType := c.getLLVMType(typ.Params().At(i).Type())
-		for _, info := range c.expandFormalParamType(subType, "", nil) {
+		for _, info := range expandFormalParamType(subType, "", nil) {
 			paramTypes = append(paramTypes, info.llvmType)
 		}
 	}
@@ -5,110 +5,25 @@ package compiler

 import (
 	"go/token"
-	"go/types"

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

-// createGo emits code to start a new goroutine.
-func (b *builder) createGo(instr *ssa.Go) {
-	// Get all function parameters to pass to the goroutine.
-	var params []llvm.Value
-	for _, param := range instr.Call.Args {
-		params = append(params, b.getValue(param))
-	}
-
-	var prefix string
-	var funcPtr llvm.Value
-	hasContext := false
-	if callee := instr.Call.StaticCallee(); callee != nil {
-		// Static callee is known. This makes it easier to start a new
-		// goroutine.
-		var context llvm.Value
-		switch value := instr.Call.Value.(type) {
-		case *ssa.Function:
-			// Goroutine call is regular function call. No context is necessary.
-			if b.Scheduler == "coroutines" {
-				// The context parameter is assumed to be always present in the
-				// coroutines scheduler.
-				context = llvm.Undef(b.i8ptrType)
-			}
-		case *ssa.MakeClosure:
-			// A goroutine call on a func value, but the callee is trivial to find. For
-			// example: immediately applied functions.
-			funcValue := b.getValue(value)
-			context = b.extractFuncContext(funcValue)
-		default:
-			panic("StaticCallee returned an unexpected value")
-		}
-		if !context.IsNil() {
-			params = append(params, context) // context parameter
-			hasContext = true
-		}
-		funcPtr = b.getFunction(callee)
-	} else if builtin, ok := instr.Call.Value.(*ssa.Builtin); ok {
-		// We cheat. None of the builtins do any long or blocking operation, so
-		// we might as well run these builtins right away without the program
-		// noticing the difference.
-		// Possible exceptions:
-		//   - copy: this is a possibly long operation, but not a blocking
-		//     operation. Semantically it makes no difference to run it right
-		//     away (not in a goroutine). However, in practice it makes no sense
-		//     to run copy in a goroutine as there is no way to (safely) know
-		//     when it is finished.
-		//   - panic: the error message would appear in the parent goroutine.
-		//     But because `go panic("err")` would halt the program anyway
-		//     (there is no recover), panicking right away would give the same
-		//     behavior as creating a goroutine, switching the scheduler to that
-		//     goroutine, and panicking there. So this optimization seems
-		//     correct.
-		//   - recover: because it runs in a new goroutine, it is never a
-		//     deferred function. Thus this is a no-op.
-		if builtin.Name() == "recover" {
-			// This is a no-op, even in a deferred function:
-			//   go recover()
-			return
-		}
-		var argTypes []types.Type
-		var argValues []llvm.Value
-		for _, arg := range instr.Call.Args {
-			argTypes = append(argTypes, arg.Type())
-			argValues = append(argValues, b.getValue(arg))
-		}
-		b.createBuiltin(argTypes, argValues, builtin.Name(), instr.Pos())
-		return
-	} else if !instr.Call.IsInvoke() {
-		// This is a function pointer.
-		// At the moment, two extra params are passed to the newly started
-		// goroutine:
-		//   * The function context, for closures.
-		//   * The function pointer (for tasks).
-		var context llvm.Value
-		funcPtr, context = b.decodeFuncValue(b.getValue(instr.Call.Value), instr.Call.Value.Type().Underlying().(*types.Signature))
-		params = append(params, context) // context parameter
-		hasContext = true
-		switch b.Scheduler {
-		case "none", "coroutines":
-			// There are no additional parameters needed for the goroutine start operation.
-		case "tasks":
-			// Add the function pointer as a parameter to start the goroutine.
-			params = append(params, funcPtr)
-		default:
-			panic("unknown scheduler type")
-		}
-		prefix = b.fn.RelString(nil)
-	} else {
-		b.addError(instr.Pos(), "todo: go on interface call")
-		return
-	}
-
+// createGoInstruction starts a new goroutine with the provided function pointer
+// and parameters.
+// In general, you should pass all regular parameters plus the context parameter.
+// There is one exception: the task-based scheduler needs to have the function
+// pointer passed in as a parameter too in addition to the context.
+//
+// Because a go statement doesn't return anything, return undef.
+func (b *builder) createGoInstruction(funcPtr llvm.Value, params []llvm.Value, prefix string, pos token.Pos) llvm.Value {
 	paramBundle := b.emitPointerPack(params)
 	var callee, stackSize llvm.Value
 	switch b.Scheduler {
 	case "none", "tasks":
-		callee = b.createGoroutineStartWrapper(funcPtr, prefix, hasContext, instr.Pos())
+		callee = b.createGoroutineStartWrapper(funcPtr, prefix, pos)
 		if b.AutomaticStackSize {
 			// The stack size is not known until after linking. Call a dummy
 			// function that will be replaced with a load from a special ELF
@@ -119,9 +34,6 @@ func (b *builder) createGo(instr *ssa.Go) {
 		} else {
 			// The stack size is fixed at compile time. By emitting it here as a
 			// constant, it can be optimized.
-			if b.Scheduler == "tasks" && b.DefaultStackSize == 0 {
-				b.addError(instr.Pos(), "default stack size for goroutines is not set")
-			}
 			stackSize = llvm.ConstInt(b.uintptrType, b.DefaultStackSize, false)
 		}
 	case "coroutines":
@@ -134,6 +46,7 @@ func (b *builder) createGo(instr *ssa.Go) {
 	}
 	start := b.getFunction(b.program.ImportedPackage("internal/task").Members["start"].(*ssa.Function))
 	b.createCall(start, []llvm.Value{callee, paramBundle, stackSize, llvm.Undef(b.i8ptrType), llvm.ConstPointerNull(b.i8ptrType)}, "")
+	return llvm.Undef(funcPtr.Type().ElementType().ReturnType())
 }

 // createGoroutineStartWrapper creates a wrapper for the task-based
@@ -154,12 +67,7 @@ func (b *builder) createGo(instr *ssa.Go) {
 // allows a single (pointer) argument to the newly started goroutine. Also, it
 // ignores the return value because newly started goroutines do not have a
 // return value.
-//
-// The hasContext parameter indicates whether the context parameter (the second
-// to last parameter of the function) is used for this wrapper. If hasContext is
-// false, the parameter bundle is assumed to have no context parameter and undef
-// is passed instead.
-func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix string, hasContext bool, pos token.Pos) llvm.Value {
+func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix string, pos token.Pos) llvm.Value {
 	var wrapper llvm.Value

 	builder := c.ctx.NewBuilder()
@@ -176,7 +84,7 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 		// 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.LinkOnceODRLinkage)
+		wrapper.SetLinkage(llvm.InternalLinkage)
 		wrapper.SetUnnamedAddr(true)
 		wrapper.AddAttributeAtIndex(-1, c.ctx.CreateStringAttribute("tinygo-gowrapper", name))
 		entry := c.ctx.AddBasicBlock(wrapper, "entry")
@@ -206,15 +114,8 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri

 		// Create the list of params for the call.
 		paramTypes := fn.Type().ElementType().ParamTypes()
-		paramTypes = paramTypes[:len(paramTypes)-1] // strip parentHandle parameter
-		if !hasContext {
-			paramTypes = paramTypes[:len(paramTypes)-1] // strip context parameter
-		}
-		params := llvmutil.EmitPointerUnpack(builder, c.mod, wrapper.Param(0), paramTypes)
-		if !hasContext {
-			params = append(params, llvm.Undef(c.i8ptrType)) // add dummy context parameter
-		}
-		params = append(params, llvm.Undef(c.i8ptrType)) // add dummy parentHandle parameter
+		params := llvmutil.EmitPointerUnpack(builder, c.mod, wrapper.Param(0), paramTypes[:len(paramTypes)-1])
+		params = append(params, llvm.Undef(c.i8ptrType))

 		// Create the call.
 		builder.CreateCall(fn, params, "")
@@ -240,7 +141,7 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 		// Create the wrapper.
 		wrapperType := llvm.FunctionType(c.ctx.VoidType(), []llvm.Type{c.i8ptrType}, false)
 		wrapper = llvm.AddFunction(c.mod, prefix+".gowrapper", wrapperType)
-		wrapper.SetLinkage(llvm.LinkOnceODRLinkage)
+		wrapper.SetLinkage(llvm.InternalLinkage)
 		wrapper.SetUnnamedAddr(true)
 		wrapper.AddAttributeAtIndex(-1, c.ctx.CreateStringAttribute("tinygo-gowrapper", ""))
 		entry := c.ctx.AddBasicBlock(wrapper, "entry")
@@ -276,11 +177,8 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 		// Get the function pointer.
 		fnPtr := params[len(params)-1]

-		// The last parameter in the packed object has somewhat of a dual role.
-		// Inside the parameter bundle it's the function pointer, stored right
-		// after the context pointer. But in the IR call instruction, it's the
-		// parentHandle function that's always undef outside of the coroutines
-		// scheduler. Thus, make the parameter undef here.
+		// Ignore the last param, which isn't used anymore.
+		// TODO: avoid this extra "parent handle" parameter in most functions.
 		params[len(params)-1] = llvm.Undef(c.i8ptrType)

 		// Create the call.
@@ -24,7 +24,16 @@ import (
 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)
-	itfTypeCode := b.CreatePtrToInt(itfTypeCodeGlobal, b.uintptrType, "")
+	itfMethodSetGlobal := b.getTypeMethodSet(typ)
+	itfConcreteTypeGlobal := b.mod.NamedGlobal("typeInInterface:" + itfTypeCodeGlobal.Name())
+	if itfConcreteTypeGlobal.IsNil() {
+		typeInInterface := b.getLLVMRuntimeType("typeInInterface")
+		itfConcreteTypeGlobal = llvm.AddGlobal(b.mod, typeInInterface, "typeInInterface:"+itfTypeCodeGlobal.Name())
+		itfConcreteTypeGlobal.SetInitializer(llvm.ConstNamedStruct(typeInInterface, []llvm.Value{itfTypeCodeGlobal, itfMethodSetGlobal}))
+		itfConcreteTypeGlobal.SetGlobalConstant(true)
+		itfConcreteTypeGlobal.SetLinkage(llvm.PrivateLinkage)
+	}
+	itfTypeCode := b.CreatePtrToInt(itfConcreteTypeGlobal, b.uintptrType, "")
 	itf := llvm.Undef(b.getLLVMRuntimeType("_interface"))
 	itf = b.CreateInsertValue(itf, itfTypeCode, 0, "")
 	itf = b.CreateInsertValue(itf, itfValue, 1, "")
@@ -45,8 +54,6 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 		// reflect lowering simpler.
 		var references llvm.Value
 		var length int64
-		var methodSet llvm.Value
-		var ptrTo llvm.Value
 		switch typ := typ.(type) {
 		case *types.Named:
 			references = c.getTypeCode(typ.Underlying())
@@ -63,32 +70,18 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 			// Take a pointer to the typecodeID of the first field (if it exists).
 			structGlobal := c.makeStructTypeFields(typ)
 			references = llvm.ConstBitCast(structGlobal, global.Type())
-		case *types.Interface:
-			methodSetGlobal := c.getInterfaceMethodSet(typ)
-			references = llvm.ConstBitCast(methodSetGlobal, global.Type())
 		}
-		if _, ok := typ.Underlying().(*types.Interface); !ok {
-			methodSet = c.getTypeMethodSet(typ)
-		}
-		if _, ok := typ.Underlying().(*types.Pointer); !ok {
-			ptrTo = c.getTypeCode(types.NewPointer(typ))
-		}
-		globalValue := llvm.ConstNull(global.Type().ElementType())
 		if !references.IsNil() {
+			// Set the 'references' field of the runtime.typecodeID struct.
+			globalValue := llvm.ConstNull(global.Type().ElementType())
 			globalValue = llvm.ConstInsertValue(globalValue, references, []uint32{0})
+			if length != 0 {
+				lengthValue := llvm.ConstInt(c.uintptrType, uint64(length), false)
+				globalValue = llvm.ConstInsertValue(globalValue, lengthValue, []uint32{1})
+			}
+			global.SetInitializer(globalValue)
+			global.SetLinkage(llvm.PrivateLinkage)
 		}
-		if length != 0 {
-			lengthValue := llvm.ConstInt(c.uintptrType, uint64(length), false)
-			globalValue = llvm.ConstInsertValue(globalValue, lengthValue, []uint32{1})
-		}
-		if !methodSet.IsNil() {
-			globalValue = llvm.ConstInsertValue(globalValue, methodSet, []uint32{2})
-		}
-		if !ptrTo.IsNil() {
-			globalValue = llvm.ConstInsertValue(globalValue, ptrTo, []uint32{3})
-		}
-		global.SetInitializer(globalValue)
-		global.SetLinkage(llvm.LinkOnceODRLinkage)
 		global.SetGlobalConstant(true)
 	}
 	return global
@@ -110,8 +103,8 @@ func (c *compilerContext) makeStructTypeFields(typ *types.Struct) llvm.Value {
 		fieldName.SetLinkage(llvm.PrivateLinkage)
 		fieldName.SetUnnamedAddr(true)
 		fieldName = llvm.ConstGEP(fieldName, []llvm.Value{
-			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
-			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
+			llvm.ConstInt(llvm.Int32Type(), 0, false),
+			llvm.ConstInt(llvm.Int32Type(), 0, false),
 		})
 		fieldGlobalValue = llvm.ConstInsertValue(fieldGlobalValue, fieldName, []uint32{1})
 		if typ.Tag(i) != "" {
@@ -119,8 +112,8 @@ func (c *compilerContext) makeStructTypeFields(typ *types.Struct) llvm.Value {
 			fieldTag.SetLinkage(llvm.PrivateLinkage)
 			fieldTag.SetUnnamedAddr(true)
 			fieldTag = llvm.ConstGEP(fieldTag, []llvm.Value{
-				llvm.ConstInt(c.ctx.Int32Type(), 0, false),
-				llvm.ConstInt(c.ctx.Int32Type(), 0, false),
+				llvm.ConstInt(llvm.Int32Type(), 0, false),
+				llvm.ConstInt(llvm.Int32Type(), 0, false),
 			})
 			fieldGlobalValue = llvm.ConstInsertValue(fieldGlobalValue, fieldTag, []uint32{2})
 		}
@@ -193,7 +186,7 @@ func getTypeCodeName(t types.Type) string {
 	case *types.Interface:
 		methods := make([]string, t.NumMethods())
 		for i := 0; i < t.NumMethods(); i++ {
-			methods[i] = t.Method(i).Name() + ":" + getTypeCodeName(t.Method(i).Type())
+			methods[i] = getTypeCodeName(t.Method(i).Type())
 		}
 		return "interface:" + "{" + strings.Join(methods, ",") + "}"
 	case *types.Map:
@@ -271,7 +264,7 @@ func (c *compilerContext) getTypeMethodSet(typ types.Type) llvm.Value {
 	global = llvm.AddGlobal(c.mod, arrayType, typ.String()+"$methodset")
 	global.SetInitializer(value)
 	global.SetGlobalConstant(true)
-	global.SetLinkage(llvm.LinkOnceODRLinkage)
+	global.SetLinkage(llvm.PrivateLinkage)
 	return llvm.ConstGEP(global, []llvm.Value{zero, zero})
 }

@@ -302,7 +295,7 @@ func (c *compilerContext) getInterfaceMethodSet(typ types.Type) llvm.Value {
 	global = llvm.AddGlobal(c.mod, value.Type(), name+"$interface")
 	global.SetInitializer(value)
 	global.SetGlobalConstant(true)
-	global.SetLinkage(llvm.LinkOnceODRLinkage)
+	global.SetLinkage(llvm.PrivateLinkage)
 	return llvm.ConstGEP(global, []llvm.Value{zero, zero})
 }

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

 	} else {
-		globalName := "reflect/types.typeid:" + getTypeCodeName(expr.AssertedType)
-		assertedTypeCodeGlobal := b.mod.NamedGlobal(globalName)
-		if assertedTypeCodeGlobal.IsNil() {
-			// Create a new typecode global.
-			assertedTypeCodeGlobal = llvm.AddGlobal(b.mod, b.ctx.Int8Type(), globalName)
-			assertedTypeCodeGlobal.SetGlobalConstant(true)
-		}
 		// 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")
 	}

@@ -469,9 +445,9 @@ func (c *compilerContext) getInterfaceInvokeWrapper(fn *ssa.Function, llvmFn llv
 	}

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

@@ -491,7 +467,7 @@ func (c *compilerContext) getInterfaceInvokeWrapper(fn *ssa.Function, llvmFn llv
 	wrapper = llvm.AddFunction(c.mod, wrapperName, wrapFnType)
 	wrapper.LastParam().SetName("parentHandle")

-	wrapper.SetLinkage(llvm.LinkOnceODRLinkage)
+	wrapper.SetLinkage(llvm.InternalLinkage)
 	wrapper.SetUnnamedAddr(true)

 	// Create a new builder just to create this wrapper.
@@ -41,9 +41,12 @@ func (b *builder) createInterruptGlobal(instr *ssa.CallCommon) (llvm.Value, erro
 	// type are lowered in the interrupt lowering pass.
 	globalType := b.program.ImportedPackage("runtime/interrupt").Type("handle").Type()
 	globalLLVMType := b.getLLVMType(globalType)
-	globalName := b.fn.Package().Pkg.Path() + "$interrupt" + strconv.FormatInt(id.Int64(), 10)
+	globalName := "runtime/interrupt.$interrupt" + strconv.FormatInt(id.Int64(), 10)
+	if global := b.mod.NamedGlobal(globalName); !global.IsNil() {
+		return llvm.Value{}, b.makeError(instr.Pos(), "interrupt redeclared in this program")
+	}
 	global := llvm.AddGlobal(b.mod, globalLLVMType, globalName)
-	global.SetVisibility(llvm.HiddenVisibility)
+	global.SetLinkage(llvm.PrivateLinkage)
 	global.SetGlobalConstant(true)
 	global.SetUnnamedAddr(true)
 	initializer := llvm.ConstNull(globalLLVMType)
@@ -48,57 +48,3 @@ func (b *builder) createMemoryZeroCall(args []ssa.Value) (llvm.Value, error) {
 	b.CreateCall(llvmFn, params, "")
 	return llvm.Value{}, nil
 }
-
-var mathToLLVMMapping = map[string]string{
-	"math.Sqrt":  "llvm.sqrt.f64",
-	"math.Floor": "llvm.floor.f64",
-	"math.Ceil":  "llvm.ceil.f64",
-	"math.Trunc": "llvm.trunc.f64",
-}
-
-// createMathOp tries to lower the given call as a LLVM math intrinsic, if
-// possible. It returns the call result if possible, and a boolean whether it
-// succeeded. If it doesn't succeed, the architecture doesn't support the given
-// intrinsic.
-func (b *builder) createMathOp(call *ssa.CallCommon) (llvm.Value, bool) {
-	// Check whether this intrinsic is supported on the given GOARCH.
-	// If it is unsupported, this can have two reasons:
-	//
-	//  1. LLVM can expand the intrinsic inline (using float instructions), but
-	//     the result doesn't pass the tests of the math package.
-	//  2. LLVM cannot expand the intrinsic inline, will therefore lower it as a
-	//     libm function call, but the libm function call also fails the math
-	//     package tests.
-	//
-	// Whatever the implementation, it must pass the tests in the math package
-	// so unfortunately only the below intrinsic+architecture combinations are
-	// supported.
-	name := call.StaticCallee().RelString(nil)
-	switch name {
-	case "math.Ceil", "math.Floor", "math.Trunc":
-		if b.GOARCH != "wasm" && b.GOARCH != "arm64" {
-			return llvm.Value{}, false
-		}
-	case "math.Sqrt":
-		if b.GOARCH != "wasm" && b.GOARCH != "amd64" && b.GOARCH != "386" {
-			return llvm.Value{}, false
-		}
-	default:
-		return llvm.Value{}, false // only the above functions are supported.
-	}
-
-	llvmFn := b.mod.NamedFunction(mathToLLVMMapping[name])
-	if llvmFn.IsNil() {
-		// The intrinsic doesn't exist yet, so declare it.
-		// At the moment, all supported intrinsics have the form "double
-		// foo(double %x)" so we can hardcode the signature here.
-		llvmType := llvm.FunctionType(b.ctx.DoubleType(), []llvm.Type{b.ctx.DoubleType()}, false)
-		llvmFn = llvm.AddFunction(b.mod, mathToLLVMMapping[name], llvmType)
-	}
-	// Create a call to the intrinsic.
-	args := make([]llvm.Value, len(call.Args))
-	for i, arg := range call.Args {
-		args[i] = b.getValue(arg)
-	}
-	return b.CreateCall(llvmFn, args, ""), true
-}
@@ -0,0 +1,164 @@
+package compiler
+
+// This file implements a simple reachability analysis, to reduce compile time.
+// This DCE pass used to be necessary for improving other passes but now it
+// isn't necessary anymore.
+
+import (
+	"errors"
+	"go/types"
+	"sort"
+
+	"github.com/tinygo-org/tinygo/loader"
+	"golang.org/x/tools/go/ssa"
+)
+
+type dceState struct {
+	*compilerContext
+	functions   []*dceFunction
+	functionMap map[*ssa.Function]*dceFunction
+}
+
+type dceFunction struct {
+	*ssa.Function
+	functionInfo
+	flag bool // used by dead code elimination
+}
+
+func (p *dceState) addFunction(ssaFn *ssa.Function) {
+	if _, ok := p.functionMap[ssaFn]; ok {
+		return
+	}
+	f := &dceFunction{Function: ssaFn}
+	f.functionInfo = p.getFunctionInfo(ssaFn)
+	p.functions = append(p.functions, f)
+	p.functionMap[ssaFn] = f
+
+	for _, anon := range ssaFn.AnonFuncs {
+		p.addFunction(anon)
+	}
+}
+
+// simpleDCE returns a list of alive functions in the program. Compiling only
+// these functions makes the compiler faster.
+//
+// This functionality will likely be replaced in the future with build caching.
+func (c *compilerContext) simpleDCE(lprogram *loader.Program) ([]*ssa.Function, error) {
+	mainPkg := c.program.Package(lprogram.MainPkg().Pkg)
+	if mainPkg == nil {
+		panic("could not find main package")
+	}
+	p := &dceState{
+		compilerContext: c,
+		functionMap:     make(map[*ssa.Function]*dceFunction),
+	}
+
+	for _, pkg := range lprogram.Sorted() {
+		pkg := c.program.Package(pkg.Pkg)
+		memberNames := make([]string, 0)
+		for name := range pkg.Members {
+			memberNames = append(memberNames, name)
+		}
+		sort.Strings(memberNames)
+
+		for _, name := range memberNames {
+			member := pkg.Members[name]
+			switch member := member.(type) {
+			case *ssa.Function:
+				p.addFunction(member)
+			case *ssa.Type:
+				methods := getAllMethods(pkg.Prog, member.Type())
+				if !types.IsInterface(member.Type()) {
+					// named type
+					for _, method := range methods {
+						p.addFunction(pkg.Prog.MethodValue(method))
+					}
+				}
+			case *ssa.Global:
+				// Ignore. Globals are not handled here.
+			case *ssa.NamedConst:
+				// Ignore: these are already resolved.
+			default:
+				panic("unknown member type: " + member.String())
+			}
+		}
+	}
+
+	// Initial set of live functions. Include main.main, *.init and runtime.*
+	// functions.
+	main, ok := mainPkg.Members["main"].(*ssa.Function)
+	if !ok {
+		if mainPkg.Members["main"] == nil {
+			return nil, errors.New("function main is undeclared in the main package")
+		} else {
+			return nil, errors.New("cannot declare main - must be func")
+		}
+	}
+	runtimePkg := c.program.ImportedPackage("runtime")
+	mathPkg := c.program.ImportedPackage("math")
+	taskPkg := c.program.ImportedPackage("internal/task")
+	p.functionMap[main].flag = true
+	worklist := []*ssa.Function{main}
+	for _, f := range p.functions {
+		if f.exported || f.Synthetic == "package initializer" || f.Pkg == runtimePkg || f.Pkg == taskPkg || (f.Pkg == mathPkg && f.Pkg != nil) {
+			if f.flag {
+				continue
+			}
+			f.flag = true
+			worklist = append(worklist, f.Function)
+		}
+	}
+
+	// Mark all called functions recursively.
+	for len(worklist) != 0 {
+		f := worklist[len(worklist)-1]
+		worklist = worklist[:len(worklist)-1]
+		for _, block := range f.Blocks {
+			for _, instr := range block.Instrs {
+				if instr, ok := instr.(*ssa.MakeInterface); ok {
+					for _, sel := range getAllMethods(c.program, instr.X.Type()) {
+						fn := c.program.MethodValue(sel)
+						callee := p.functionMap[fn]
+						if callee == nil {
+							// TODO: why is this necessary?
+							p.addFunction(fn)
+							callee = p.functionMap[fn]
+						}
+						if !callee.flag {
+							callee.flag = true
+							worklist = append(worklist, callee.Function)
+						}
+					}
+				}
+				for _, operand := range instr.Operands(nil) {
+					if operand == nil || *operand == nil {
+						continue
+					}
+					switch operand := (*operand).(type) {
+					case *ssa.Function:
+						f := p.functionMap[operand]
+						if f == nil {
+							// FIXME HACK: this function should have been
+							// discovered already. It is not for bound methods.
+							p.addFunction(operand)
+							f = p.functionMap[operand]
+						}
+						if !f.flag {
+							f.flag = true
+							worklist = append(worklist, operand)
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// Return all live functions.
+	liveFunctions := []*ssa.Function{}
+	for _, f := range p.functions {
+		if f.flag {
+			liveFunctions = append(liveFunctions, f.Function)
+		}
+	}
+	return liveFunctions, nil
+}
@@ -150,9 +150,6 @@ func (s *stdSizes) Sizeof(T types.Type) int64 {
 		return s.PtrSize * 2
 	case *types.Pointer:
 		return s.PtrSize
-	case *types.Signature:
-		// Func values in TinyGo are two words in size.
-		return s.PtrSize * 2
 	default:
 		panic("unknown type: " + t.String())
 	}
@@ -24,7 +24,6 @@ type functionInfo struct {
 	module     string     // go:wasm-module
 	importName string     // go:linkname, go:export - The name the developer assigns
 	linkName   string     // go:linkname, go:export - The name that we map for the particular module -> importName
-	section    string     // go:section - object file section name
 	exported   bool       // go:export, CGo
 	nobounds   bool       // go:nobounds
 	variadic   bool       // go:variadic (CGo only)
@@ -73,9 +72,9 @@ func (c *compilerContext) getFunction(fn *ssa.Function) llvm.Value {
 	}

 	var paramInfos []paramInfo
-	for _, param := range getParams(fn.Signature) {
+	for _, param := range fn.Params {
 		paramType := c.getLLVMType(param.Type())
-		paramFragmentInfos := c.expandFormalParamType(paramType, param.Name(), param.Type())
+		paramFragmentInfos := expandFormalParamType(paramType, param.Name(), param.Type())
 		paramInfos = append(paramInfos, paramFragmentInfos...)
 	}

@@ -140,17 +139,6 @@ func (c *compilerContext) getFunction(fn *ssa.Function) llvm.Value {
 		for _, attrName := range []string{"noalias", "nonnull"} {
 			llvmFn.AddAttributeAtIndex(0, c.ctx.CreateEnumAttribute(llvm.AttributeKindID(attrName), 0))
 		}
-	case "runtime.sliceAppend":
-		// Appending a slice will only read the to-be-appended slice, it won't
-		// be modified.
-		llvmFn.AddAttributeAtIndex(2, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
-		llvmFn.AddAttributeAtIndex(2, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("readonly"), 0))
-	case "runtime.sliceCopy":
-		// Copying a slice won't capture any of the parameters.
-		llvmFn.AddAttributeAtIndex(1, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("writeonly"), 0))
-		llvmFn.AddAttributeAtIndex(1, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
-		llvmFn.AddAttributeAtIndex(2, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("readonly"), 0))
-		llvmFn.AddAttributeAtIndex(2, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
 	case "runtime.trackPointer":
 		// This function is necessary for tracking pointers on the stack in a
 		// portable way (see gc_stack_portable.go). Indicate to the optimizer
@@ -184,21 +172,6 @@ func (c *compilerContext) getFunction(fn *ssa.Function) llvm.Value {
 		}
 	}

-	// Synthetic functions are functions that do not appear in the source code,
-	// they are artificially constructed. Usually they are wrapper functions
-	// that are not referenced anywhere except in a SSA call instruction so
-	// should be created right away.
-	// The exception is the package initializer, which does appear in the
-	// *ssa.Package members and so shouldn't be created here.
-	if fn.Synthetic != "" && fn.Synthetic != "package initializer" {
-		irbuilder := c.ctx.NewBuilder()
-		b := newBuilder(c, irbuilder, fn)
-		b.createFunction()
-		irbuilder.Dispose()
-		llvmFn.SetLinkage(llvm.LinkOnceODRLinkage)
-		llvmFn.SetUnnamedAddr(true)
-	}
-
 	return llvmFn
 }

@@ -271,10 +244,6 @@ func (info *functionInfo) parsePragmas(f *ssa.Function) {
 				if hasUnsafeImport(f.Pkg.Pkg) {
 					info.linkName = parts[2]
 				}
-			case "//go:section":
-				if len(parts) == 2 && hasUnsafeImport(f.Pkg.Pkg) {
-					info.section = parts[1]
-				}
 			case "//go:nobounds":
 				// Skip bounds checking in this function. Useful for some
 				// runtime functions.
@@ -309,20 +278,6 @@ func (info *functionInfo) parsePragmas(f *ssa.Function) {
 	}
 }

-// getParams returns the function parameters, including the receiver at the
-// start. This is an alternative to the Params member of *ssa.Function, which is
-// not yet populated when the package has not yet been built.
-func getParams(sig *types.Signature) []*types.Var {
-	params := []*types.Var{}
-	if sig.Recv() != nil {
-		params = append(params, sig.Recv())
-	}
-	for i := 0; i < sig.Params().Len(); i++ {
-		params = append(params, sig.Params().At(i))
-	}
-	return params
-}
-
 // globalInfo contains some information about a specific global. By default,
 // linkName is equal to .RelString(nil) on a global and extern is false, but for
 // some symbols this is different (due to //go:extern for example).
@@ -330,27 +285,29 @@ type globalInfo struct {
 	linkName string // go:extern
 	extern   bool   // go:extern
 	align    int    // go:align
-	section  string // go:section
 }

 // loadASTComments loads comments on globals from the AST, for use later in the
 // program. In particular, they are required for //go:extern pragmas on globals.
-func (c *compilerContext) loadASTComments(pkg *loader.Package) {
-	for _, file := range pkg.Files {
-		for _, decl := range file.Decls {
-			switch decl := decl.(type) {
-			case *ast.GenDecl:
-				switch decl.Tok {
-				case token.VAR:
-					if len(decl.Specs) != 1 {
-						continue
-					}
-					for _, spec := range decl.Specs {
-						switch spec := spec.(type) {
-						case *ast.ValueSpec: // decl.Tok == token.VAR
-							for _, name := range spec.Names {
-								id := pkg.Pkg.Path() + "." + name.Name
-								c.astComments[id] = decl.Doc
+func (c *compilerContext) loadASTComments(lprogram *loader.Program) {
+	c.astComments = map[string]*ast.CommentGroup{}
+	for _, pkgInfo := range lprogram.Sorted() {
+		for _, file := range pkgInfo.Files {
+			for _, decl := range file.Decls {
+				switch decl := decl.(type) {
+				case *ast.GenDecl:
+					switch decl.Tok {
+					case token.VAR:
+						if len(decl.Specs) != 1 {
+							continue
+						}
+						for _, spec := range decl.Specs {
+							switch spec := spec.(type) {
+							case *ast.ValueSpec: // decl.Tok == token.VAR
+								for _, name := range spec.Names {
+									id := pkgInfo.Pkg.Path() + "." + name.Name
+									c.astComments[id] = decl.Doc
+								}
 							}
 						}
 					}
@@ -369,25 +326,29 @@ func (c *compilerContext) getGlobal(g *ssa.Global) llvm.Value {
 		typ := g.Type().(*types.Pointer).Elem()
 		llvmType := c.getLLVMType(typ)
 		llvmGlobal = llvm.AddGlobal(c.mod, llvmType, info.linkName)
+		if !info.extern {
+			llvmGlobal.SetInitializer(llvm.ConstNull(llvmType))
+			llvmGlobal.SetLinkage(llvm.InternalLinkage)
+		}

 		// Set alignment from the //go:align comment.
 		var alignInBits uint32
-		alignment := c.targetData.ABITypeAlignment(llvmType)
-		if info.align > alignment {
-			alignment = info.align
-		}
-		if alignment <= 0 || alignment&(alignment-1) != 0 {
+		if info.align < 0 || info.align&(info.align-1) != 0 {
 			// Check for power-of-two (or 0).
 			// See: https://stackoverflow.com/a/108360
 			c.addError(g.Pos(), "global variable alignment must be a positive power of two")
 		} else {
 			// Set the alignment only when it is a power of two.
-			alignInBits = uint32(alignment) ^ uint32(alignment-1)
-			llvmGlobal.SetAlignment(alignment)
+			alignInBits = uint32(info.align) ^ uint32(info.align-1)
+			if info.align > c.targetData.ABITypeAlignment(llvmType) {
+				llvmGlobal.SetAlignment(info.align)
+			}
 		}

 		if c.Debug && !info.extern {
 			// Add debug info.
+			// TODO: this should be done for every global in the program, not just
+			// the ones that are referenced from some code.
 			pos := c.program.Fset.Position(g.Pos())
 			diglobal := c.dibuilder.CreateGlobalVariableExpression(c.difiles[pos.Filename], llvm.DIGlobalVariableExpression{
 				Name:        g.RelString(nil),
@@ -444,10 +405,6 @@ func (info *globalInfo) parsePragmas(doc *ast.CommentGroup) {
 			if err == nil {
 				info.align = align
 			}
-		case "//go:section":
-			if len(parts) == 2 {
-				info.section = parts[1]
-			}
 		}
 	}
 }
@@ -10,11 +10,11 @@ import (
 	"tinygo.org/x/go-llvm"
 )

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

 // TODO: complexDiv (requires runtime call)
-
-// A type 'kv' also exists in function foo. Test that these two types don't
-// conflict with each other.
-type kv struct {
-	v float32
-}
-
-func foo(a *kv) {
-	// Define a new 'kv' type.
-	type kv struct {
-		v byte
-	}
-	// Use this type.
-	func(b *kv) {}(nil)
-}
@@ -1,77 +1,72 @@
 ; ModuleID = 'basic.go'
 source_filename = "basic.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32--wasi"
+target datalayout = "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-f80:32-n8:16:32-S128"
+target triple = "i686--linux"

-%main.kv = type { float }
-%main.kv.0 = type { i8 }
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
-
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
+define internal void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret void
 }

-define hidden i32 @main.addInt(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal i32 @main.addInt(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = add i32 %x, %y
  ret i32 %0
 }

-define hidden i1 @main.equalInt(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal i1 @main.equalInt(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = icmp eq i32 %x, %y
  ret i1 %0
 }

-define hidden i1 @main.floatEQ(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal i1 @main.floatEQ(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = fcmp oeq float %x, %y
  ret i1 %0
 }

-define hidden i1 @main.floatNE(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal i1 @main.floatNE(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = fcmp une float %x, %y
  ret i1 %0
 }

-define hidden i1 @main.floatLower(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal i1 @main.floatLower(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = fcmp olt float %x, %y
  ret i1 %0
 }

-define hidden i1 @main.floatLowerEqual(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal i1 @main.floatLowerEqual(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = fcmp ole float %x, %y
  ret i1 %0
 }

-define hidden i1 @main.floatGreater(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal i1 @main.floatGreater(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = fcmp ogt float %x, %y
  ret i1 %0
 }

-define hidden i1 @main.floatGreaterEqual(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal i1 @main.floatGreaterEqual(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = fcmp oge float %x, %y
  ret i1 %0
 }

-define hidden float @main.complexReal(float %x.r, float %x.i, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal float @main.complexReal(float %x.r, float %x.i, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret float %x.r
 }

-define hidden float @main.complexImag(float %x.r, float %x.i, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal float @main.complexImag(float %x.r, float %x.i, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret float %x.i
 }

-define hidden { float, float } @main.complexAdd(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal { float, float } @main.complexAdd(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = fadd float %x.r, %y.r
  %1 = fadd float %x.i, %y.i
@@ -80,7 +75,7 @@ entry:
  ret { float, float } %3
 }

-define hidden { float, float } @main.complexSub(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal { float, float } @main.complexSub(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = fsub float %x.r, %y.r
  %1 = fsub float %x.i, %y.i
@@ -89,7 +84,7 @@ entry:
  ret { float, float } %3
 }

-define hidden { float, float } @main.complexMul(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal { float, float } @main.complexMul(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = fmul float %x.r, %y.r
  %1 = fmul float %x.i, %y.i
@@ -101,14 +96,3 @@ entry:
  %7 = insertvalue { float, float } %6, float %5, 1
  ret { float, float } %7
 }
-
-define hidden void @main.foo(%main.kv* dereferenceable_or_null(4) %a, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  call void @"main.foo$1"(%main.kv.0* null, i8* undef, i8* undef)
-  ret void
-}
-
-define hidden void @"main.foo$1"(%main.kv.0* dereferenceable_or_null(1) %b, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret void
-}
@@ -1,25 +0,0 @@
-package main
-
-func chanIntSend(ch chan int) {
-	ch <- 3
-}
-
-func chanIntRecv(ch chan int) {
-	<-ch
-}
-
-func chanZeroSend(ch chan struct{}) {
-	ch <- struct{}{}
-}
-
-func chanZeroRecv(ch chan struct{}) {
-	<-ch
-}
-
-func selectZeroRecv(ch1 chan int, ch2 chan struct{}) {
-	select {
-	case ch1 <- 1:
-	case <-ch2:
-	default:
-	}
-}
@@ -1,114 +0,0 @@
-; ModuleID = 'channel.go'
-source_filename = "channel.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32--wasi"
-
-%runtime.channel = type { i32, i32, i8, %runtime.channelBlockedList*, i32, i32, i32, i8* }
-%runtime.channelBlockedList = type { %runtime.channelBlockedList*, %"internal/task.Task"*, %runtime.chanSelectState*, { %runtime.channelBlockedList*, i32, i32 } }
-%"internal/task.Task" = type { %"internal/task.Task"*, i8*, i64, %"internal/task.state" }
-%"internal/task.state" = type { i8* }
-%runtime.chanSelectState = type { %runtime.channel*, i8* }
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
-
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret void
-}
-
-define hidden void @main.chanIntSend(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %chan.blockedList = alloca %runtime.channelBlockedList, align 8
-  %chan.value = alloca i32, align 4
-  %chan.value.bitcast = bitcast i32* %chan.value to i8*
-  call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %chan.value.bitcast)
-  store i32 3, i32* %chan.value, align 4
-  %chan.blockedList.bitcast = bitcast %runtime.channelBlockedList* %chan.blockedList to i8*
-  call void @llvm.lifetime.start.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  call void @runtime.chanSend(%runtime.channel* %ch, i8* nonnull %chan.value.bitcast, %runtime.channelBlockedList* nonnull %chan.blockedList, i8* undef, i8* null)
-  call void @llvm.lifetime.end.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %chan.value.bitcast)
-  ret void
-}
-
-; Function Attrs: argmemonly nounwind willreturn
-declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) #0
-
-declare void @runtime.chanSend(%runtime.channel* dereferenceable_or_null(32), i8*, %runtime.channelBlockedList* dereferenceable_or_null(24), i8*, i8*)
-
-; Function Attrs: argmemonly nounwind willreturn
-declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture) #0
-
-define hidden void @main.chanIntRecv(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %chan.blockedList = alloca %runtime.channelBlockedList, align 8
-  %chan.value = alloca i32, align 4
-  %chan.value.bitcast = bitcast i32* %chan.value to i8*
-  call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %chan.value.bitcast)
-  %chan.blockedList.bitcast = bitcast %runtime.channelBlockedList* %chan.blockedList to i8*
-  call void @llvm.lifetime.start.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  %0 = call i1 @runtime.chanRecv(%runtime.channel* %ch, i8* nonnull %chan.value.bitcast, %runtime.channelBlockedList* nonnull %chan.blockedList, i8* undef, i8* null)
-  call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %chan.value.bitcast)
-  call void @llvm.lifetime.end.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  ret void
-}
-
-declare i1 @runtime.chanRecv(%runtime.channel* dereferenceable_or_null(32), i8*, %runtime.channelBlockedList* dereferenceable_or_null(24), i8*, i8*)
-
-define hidden void @main.chanZeroSend(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %chan.blockedList = alloca %runtime.channelBlockedList, align 8
-  %chan.blockedList.bitcast = bitcast %runtime.channelBlockedList* %chan.blockedList to i8*
-  call void @llvm.lifetime.start.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  call void @runtime.chanSend(%runtime.channel* %ch, i8* null, %runtime.channelBlockedList* nonnull %chan.blockedList, i8* undef, i8* null)
-  call void @llvm.lifetime.end.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  ret void
-}
-
-define hidden void @main.chanZeroRecv(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %chan.blockedList = alloca %runtime.channelBlockedList, align 8
-  %chan.blockedList.bitcast = bitcast %runtime.channelBlockedList* %chan.blockedList to i8*
-  call void @llvm.lifetime.start.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  %0 = call i1 @runtime.chanRecv(%runtime.channel* %ch, i8* null, %runtime.channelBlockedList* nonnull %chan.blockedList, i8* undef, i8* null)
-  call void @llvm.lifetime.end.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  ret void
-}
-
-define hidden void @main.selectZeroRecv(%runtime.channel* dereferenceable_or_null(32) %ch1, %runtime.channel* dereferenceable_or_null(32) %ch2, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %select.states.alloca = alloca [2 x %runtime.chanSelectState], align 8
-  %select.send.value = alloca i32, align 4
-  store i32 1, i32* %select.send.value, align 4
-  %select.states.alloca.bitcast = bitcast [2 x %runtime.chanSelectState]* %select.states.alloca to i8*
-  call void @llvm.lifetime.start.p0i8(i64 16, i8* nonnull %select.states.alloca.bitcast)
-  %.repack = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 0, i32 0
-  store %runtime.channel* %ch1, %runtime.channel** %.repack, align 8
-  %.repack1 = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 0, i32 1
-  %0 = bitcast i8** %.repack1 to i32**
-  store i32* %select.send.value, i32** %0, align 4
-  %.repack3 = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 1, i32 0
-  store %runtime.channel* %ch2, %runtime.channel** %.repack3, align 8
-  %.repack4 = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 1, i32 1
-  store i8* null, i8** %.repack4, align 4
-  %select.states = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 0
-  %select.result = call { i32, i1 } @runtime.tryChanSelect(i8* undef, %runtime.chanSelectState* nonnull %select.states, i32 2, i32 2, i8* undef, i8* null)
-  call void @llvm.lifetime.end.p0i8(i64 16, i8* nonnull %select.states.alloca.bitcast)
-  %1 = extractvalue { i32, i1 } %select.result, 0
-  %2 = icmp eq i32 %1, 0
-  br i1 %2, label %select.done, label %select.next
-
-select.done:                                      ; preds = %select.body, %select.next, %entry
-  ret void
-
-select.next:                                      ; preds = %entry
-  %3 = icmp eq i32 %1, 1
-  br i1 %3, label %select.body, label %select.done
-
-select.body:                                      ; preds = %select.next
-  br label %select.done
-}
-
-declare { i32, i1 } @runtime.tryChanSelect(i8*, %runtime.chanSelectState*, i32, i32, i8*, i8*)
-
-attributes #0 = { argmemonly nounwind willreturn }
@@ -1,16 +1,14 @@
 ; ModuleID = 'float.go'
 source_filename = "float.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32--wasi"
+target datalayout = "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-f80:32-n8:16:32-S128"
+target triple = "i686--linux"

-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
-
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
+define internal void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret void
 }

-define hidden i32 @main.f32tou32(float %v, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal i32 @main.f32tou32(float %v, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %positive = fcmp oge float %v, 0.000000e+00
  %withinmax = fcmp ole float %v, 0x41EFFFFFC0000000
@@ -21,22 +19,22 @@ entry:
  ret i32 %0
 }

-define hidden float @main.maxu32f(i8* %context, i8* %parentHandle) unnamed_addr {
+define internal float @main.maxu32f(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret float 0x41F0000000000000
 }

-define hidden i32 @main.maxu32tof32(i8* %context, i8* %parentHandle) unnamed_addr {
+define internal i32 @main.maxu32tof32(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret i32 -1
 }

-define hidden { i32, i32, i32, i32 } @main.inftoi32(i8* %context, i8* %parentHandle) unnamed_addr {
+define internal { i32, i32, i32, i32 } @main.inftoi32(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret { i32, i32, i32, i32 } { i32 -1, i32 0, i32 2147483647, i32 -2147483648 }
 }

-define hidden i32 @main.u32tof32tou32(i32 %v, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal i32 @main.u32tof32tou32(i32 %v, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = uitofp i32 %v to float
  %withinmax = fcmp ole float %0, 0x41EFFFFFC0000000
@@ -45,7 +43,7 @@ entry:
  ret i32 %1
 }

-define hidden float @main.f32tou32tof32(float %v, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal float @main.f32tou32tof32(float %v, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %positive = fcmp oge float %v, 0.000000e+00
  %withinmax = fcmp ole float %v, 0x41EFFFFFC0000000
@@ -57,7 +55,7 @@ entry:
  ret float %1
 }

-define hidden i8 @main.f32tou8(float %v, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal i8 @main.f32tou8(float %v, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %positive = fcmp oge float %v, 0.000000e+00
  %withinmax = fcmp ole float %v, 2.550000e+02
@@ -68,7 +66,7 @@ entry:
  ret i8 %0
 }

-define hidden i8 @main.f32toi8(float %v, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal i8 @main.f32toi8(float %v, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %abovemin = fcmp oge float %v, -1.280000e+02
  %belowmax = fcmp ole float %v, 1.270000e+02
@@ -1,12 +0,0 @@
-package main
-
-func foo(callback func(int)) {
-	callback(3)
-}
-
-func bar() {
-	foo(someFunc)
-}
-
-func someFunc(int) {
-}
@@ -1,47 +0,0 @@
-; ModuleID = 'func.go'
-source_filename = "func.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32--wasi"
-
-%runtime.funcValueWithSignature = type { i32, i8* }
-
-@"reflect/types.funcid:func:{basic:int}{}" = external constant i8
-@"main.someFunc$withSignature" = linkonce_odr constant %runtime.funcValueWithSignature { i32 ptrtoint (void (i32, i8*, i8*)* @main.someFunc to i32), i8* @"reflect/types.funcid:func:{basic:int}{}" }
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
-
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret void
-}
-
-define hidden void @main.foo(i8* %callback.context, i32 %callback.funcptr, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %0 = call i32 @runtime.getFuncPtr(i8* %callback.context, i32 %callback.funcptr, i8* nonnull @"reflect/types.funcid:func:{basic:int}{}", i8* undef, i8* null)
-  %1 = icmp eq i32 %0, 0
-  br i1 %1, label %fpcall.throw, label %fpcall.next
-
-fpcall.throw:                                     ; preds = %entry
-  call void @runtime.nilPanic(i8* undef, i8* null)
-  unreachable
-
-fpcall.next:                                      ; preds = %entry
-  %2 = inttoptr i32 %0 to void (i32, i8*, i8*)*
-  call void %2(i32 3, i8* %callback.context, i8* undef)
-  ret void
-}
-
-declare i32 @runtime.getFuncPtr(i8*, i32, i8* dereferenceable_or_null(1), i8*, i8*)
-
-declare void @runtime.nilPanic(i8*, i8*)
-
-define hidden void @main.bar(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  call void @main.foo(i8* undef, i32 ptrtoint (%runtime.funcValueWithSignature* @"main.someFunc$withSignature" to i32), i8* undef, i8* undef)
-  ret void
-}
-
-define hidden void @main.someFunc(i32 %arg0, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret void
-}
@@ -1,41 +0,0 @@
-package main
-
-// Test changes to the language introduced in Go 1.17.
-// For details, see: https://tip.golang.org/doc/go1.17#language
-// These tests should be merged into the regular slice tests once Go 1.17 is the
-// minimun Go version for TinyGo.
-
-import "unsafe"
-
-func Add32(p unsafe.Pointer, len int) unsafe.Pointer {
-	return unsafe.Add(p, len)
-}
-
-func Add64(p unsafe.Pointer, len int64) unsafe.Pointer {
-	return unsafe.Add(p, len)
-}
-
-func SliceToArray(s []int) *[4]int {
-	return (*[4]int)(s)
-}
-
-func SliceToArrayConst() *[4]int {
-	s := make([]int, 6)
-	return (*[4]int)(s)
-}
-
-func SliceInt(ptr *int, len int) []int {
-	return unsafe.Slice(ptr, len)
-}
-
-func SliceUint16(ptr *byte, len uint16) []byte {
-	return unsafe.Slice(ptr, len)
-}
-
-func SliceUint64(ptr *int, len uint64) []int {
-	return unsafe.Slice(ptr, len)
-}
-
-func SliceInt64(ptr *int, len int64) []int {
-	return unsafe.Slice(ptr, len)
-}
@@ -1,136 +0,0 @@
-; ModuleID = 'go1.17.go'
-source_filename = "go1.17.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32--wasi"
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
-
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret void
-}
-
-define hidden i8* @main.Add32(i8* %p, i32 %len, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %0 = getelementptr i8, i8* %p, i32 %len
-  ret i8* %0
-}
-
-define hidden i8* @main.Add64(i8* %p, i64 %len, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %0 = trunc i64 %len to i32
-  %1 = getelementptr i8, i8* %p, i32 %0
-  ret i8* %1
-}
-
-define hidden [4 x i32]* @main.SliceToArray(i32* %s.data, i32 %s.len, i32 %s.cap, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %0 = icmp ult i32 %s.len, 4
-  br i1 %0, label %slicetoarray.throw, label %slicetoarray.next
-
-slicetoarray.throw:                               ; preds = %entry
-  call void @runtime.sliceToArrayPointerPanic(i8* undef, i8* null)
-  unreachable
-
-slicetoarray.next:                                ; preds = %entry
-  %1 = bitcast i32* %s.data to [4 x i32]*
-  ret [4 x i32]* %1
-}
-
-declare void @runtime.sliceToArrayPointerPanic(i8*, i8*)
-
-define hidden [4 x i32]* @main.SliceToArrayConst(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %makeslice = call i8* @runtime.alloc(i32 24, i8* undef, i8* null)
-  br i1 false, label %slicetoarray.throw, label %slicetoarray.next
-
-slicetoarray.throw:                               ; preds = %entry
-  unreachable
-
-slicetoarray.next:                                ; preds = %entry
-  %0 = bitcast i8* %makeslice to [4 x i32]*
-  ret [4 x i32]* %0
-}
-
-define hidden { i32*, i32, i32 } @main.SliceInt(i32* dereferenceable_or_null(4) %ptr, i32 %len, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %0 = icmp ugt i32 %len, 1073741823
-  %1 = icmp eq i32* %ptr, null
-  %2 = icmp ne i32 %len, 0
-  %3 = and i1 %1, %2
-  %4 = or i1 %3, %0
-  br i1 %4, label %unsafe.Slice.throw, label %unsafe.Slice.next
-
-unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(i8* undef, i8* null)
-  unreachable
-
-unsafe.Slice.next:                                ; preds = %entry
-  %5 = insertvalue { i32*, i32, i32 } undef, i32* %ptr, 0
-  %6 = insertvalue { i32*, i32, i32 } %5, i32 %len, 1
-  %7 = insertvalue { i32*, i32, i32 } %6, i32 %len, 2
-  ret { i32*, i32, i32 } %7
-}
-
-declare void @runtime.unsafeSlicePanic(i8*, i8*)
-
-define hidden { i8*, i32, i32 } @main.SliceUint16(i8* dereferenceable_or_null(1) %ptr, i16 %len, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %0 = icmp eq i8* %ptr, null
-  %1 = icmp ne i16 %len, 0
-  %2 = and i1 %0, %1
-  br i1 %2, label %unsafe.Slice.throw, label %unsafe.Slice.next
-
-unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(i8* undef, i8* null)
-  unreachable
-
-unsafe.Slice.next:                                ; preds = %entry
-  %3 = zext i16 %len to i32
-  %4 = insertvalue { i8*, i32, i32 } undef, i8* %ptr, 0
-  %5 = insertvalue { i8*, i32, i32 } %4, i32 %3, 1
-  %6 = insertvalue { i8*, i32, i32 } %5, i32 %3, 2
-  ret { i8*, i32, i32 } %6
-}
-
-define hidden { i32*, i32, i32 } @main.SliceUint64(i32* dereferenceable_or_null(4) %ptr, i64 %len, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %0 = icmp ugt i64 %len, 1073741823
-  %1 = icmp eq i32* %ptr, null
-  %2 = icmp ne i64 %len, 0
-  %3 = and i1 %1, %2
-  %4 = or i1 %3, %0
-  br i1 %4, label %unsafe.Slice.throw, label %unsafe.Slice.next
-
-unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(i8* undef, i8* null)
-  unreachable
-
-unsafe.Slice.next:                                ; preds = %entry
-  %5 = trunc i64 %len to i32
-  %6 = insertvalue { i32*, i32, i32 } undef, i32* %ptr, 0
-  %7 = insertvalue { i32*, i32, i32 } %6, i32 %5, 1
-  %8 = insertvalue { i32*, i32, i32 } %7, i32 %5, 2
-  ret { i32*, i32, i32 } %8
-}
-
-define hidden { i32*, i32, i32 } @main.SliceInt64(i32* dereferenceable_or_null(4) %ptr, i64 %len, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %0 = icmp ugt i64 %len, 1073741823
-  %1 = icmp eq i32* %ptr, null
-  %2 = icmp ne i64 %len, 0
-  %3 = and i1 %1, %2
-  %4 = or i1 %3, %0
-  br i1 %4, label %unsafe.Slice.throw, label %unsafe.Slice.next
-
-unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(i8* undef, i8* null)
-  unreachable
-
-unsafe.Slice.next:                                ; preds = %entry
-  %5 = trunc i64 %len to i32
-  %6 = insertvalue { i32*, i32, i32 } undef, i32* %ptr, 0
-  %7 = insertvalue { i32*, i32, i32 } %6, i32 %5, 1
-  %8 = insertvalue { i32*, i32, i32 } %7, i32 %5, 2
-  ret { i32*, i32, i32 } %8
-}
@@ -1,150 +0,0 @@
-; ModuleID = 'goroutine.go'
-source_filename = "goroutine.go"
-target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
-target triple = "armv7m-none-eabi"
-
-%runtime.channel = type { i32, i32, i8, %runtime.channelBlockedList*, i32, i32, i32, i8* }
-%runtime.channelBlockedList = type { %runtime.channelBlockedList*, %"internal/task.Task"*, %runtime.chanSelectState*, { %runtime.channelBlockedList*, i32, i32 } }
-%"internal/task.Task" = type { %"internal/task.Task"*, i8*, i64, %"internal/task.state" }
-%"internal/task.state" = type { i32, i32* }
-%runtime.chanSelectState = type { %runtime.channel*, i8* }
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
-
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret void
-}
-
-define hidden void @main.regularFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.regularFunction$gowrapper" to i32), i8* undef, i8* undef)
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.regularFunction$gowrapper" to i32), i8* nonnull inttoptr (i32 5 to i8*), i32 %stacksize, i8* undef, i8* null)
-  ret void
-}
-
-declare void @main.regularFunction(i32, i8*, i8*)
-
-define linkonce_odr void @"main.regularFunction$gowrapper"(i8* %0) unnamed_addr #0 {
-entry:
-  %unpack.int = ptrtoint i8* %0 to i32
-  call void @main.regularFunction(i32 %unpack.int, i8* undef, i8* undef)
-  ret void
-}
-
-declare i32 @"internal/task.getGoroutineStackSize"(i32, i8*, i8*)
-
-declare void @"internal/task.start"(i32, i8*, i32, i8*, i8*)
-
-define hidden void @main.inlineFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.inlineFunctionGoroutine$1$gowrapper" to i32), i8* undef, i8* undef)
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.inlineFunctionGoroutine$1$gowrapper" to i32), i8* nonnull inttoptr (i32 5 to i8*), i32 %stacksize, i8* undef, i8* null)
-  ret void
-}
-
-define hidden void @"main.inlineFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret void
-}
-
-define linkonce_odr void @"main.inlineFunctionGoroutine$1$gowrapper"(i8* %0) unnamed_addr #1 {
-entry:
-  %unpack.int = ptrtoint i8* %0 to i32
-  call void @"main.inlineFunctionGoroutine$1"(i32 %unpack.int, i8* undef, i8* undef)
-  ret void
-}
-
-define hidden void @main.closureFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %n = call i8* @runtime.alloc(i32 4, i8* undef, i8* null)
-  %0 = bitcast i8* %n to i32*
-  store i32 3, i32* %0, align 4
-  %1 = call i8* @runtime.alloc(i32 8, i8* undef, i8* null)
-  %2 = bitcast i8* %1 to i32*
-  store i32 5, i32* %2, align 4
-  %3 = getelementptr inbounds i8, i8* %1, i32 4
-  %4 = bitcast i8* %3 to i8**
-  store i8* %n, i8** %4, align 4
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.closureFunctionGoroutine$1$gowrapper" to i32), i8* undef, i8* undef)
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.closureFunctionGoroutine$1$gowrapper" to i32), i8* nonnull %1, i32 %stacksize, i8* undef, i8* null)
-  %5 = load i32, i32* %0, align 4
-  call void @runtime.printint32(i32 %5, i8* undef, i8* null)
-  ret void
-}
-
-define hidden void @"main.closureFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %unpack.ptr = bitcast i8* %context to i32*
-  store i32 7, i32* %unpack.ptr, align 4
-  ret void
-}
-
-define linkonce_odr void @"main.closureFunctionGoroutine$1$gowrapper"(i8* %0) unnamed_addr #2 {
-entry:
-  %1 = bitcast i8* %0 to i32*
-  %2 = load i32, i32* %1, align 4
-  %3 = getelementptr inbounds i8, i8* %0, i32 4
-  %4 = bitcast i8* %3 to i8**
-  %5 = load i8*, i8** %4, align 4
-  call void @"main.closureFunctionGoroutine$1"(i32 %2, i8* %5, i8* undef)
-  ret void
-}
-
-declare void @runtime.printint32(i32, i8*, i8*)
-
-define hidden void @main.funcGoroutine(i8* %fn.context, void (i32, i8*, i8*)* %fn.funcptr, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %0 = call i8* @runtime.alloc(i32 12, i8* undef, i8* null)
-  %1 = bitcast i8* %0 to i32*
-  store i32 5, i32* %1, align 4
-  %2 = getelementptr inbounds i8, i8* %0, i32 4
-  %3 = bitcast i8* %2 to i8**
-  store i8* %fn.context, i8** %3, align 4
-  %4 = getelementptr inbounds i8, i8* %0, i32 8
-  %5 = bitcast i8* %4 to void (i32, i8*, i8*)**
-  store void (i32, i8*, i8*)* %fn.funcptr, void (i32, i8*, i8*)** %5, align 4
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @main.funcGoroutine.gowrapper to i32), i8* undef, i8* undef)
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @main.funcGoroutine.gowrapper to i32), i8* nonnull %0, i32 %stacksize, i8* undef, i8* null)
-  ret void
-}
-
-define linkonce_odr void @main.funcGoroutine.gowrapper(i8* %0) unnamed_addr #3 {
-entry:
-  %1 = bitcast i8* %0 to i32*
-  %2 = load i32, i32* %1, align 4
-  %3 = getelementptr inbounds i8, i8* %0, i32 4
-  %4 = bitcast i8* %3 to i8**
-  %5 = load i8*, i8** %4, align 4
-  %6 = getelementptr inbounds i8, i8* %0, i32 8
-  %7 = bitcast i8* %6 to void (i32, i8*, i8*)**
-  %8 = load void (i32, i8*, i8*)*, void (i32, i8*, i8*)** %7, align 4
-  call void %8(i32 %2, i8* %5, i8* undef)
-  ret void
-}
-
-define hidden void @main.recoverBuiltinGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret void
-}
-
-define hidden void @main.copyBuiltinGoroutine(i8* %dst.data, i32 %dst.len, i32 %dst.cap, i8* %src.data, i32 %src.len, i32 %src.cap, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %copy.n = call i32 @runtime.sliceCopy(i8* %dst.data, i8* %src.data, i32 %dst.len, i32 %src.len, i32 1, i8* undef, i8* null)
-  ret void
-}
-
-declare i32 @runtime.sliceCopy(i8* nocapture writeonly, i8* nocapture readonly, i32, i32, i32, i8*, i8*)
-
-define hidden void @main.closeBuiltinGoroutine(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  call void @runtime.chanClose(%runtime.channel* %ch, i8* undef, i8* null)
-  ret void
-}
-
-declare void @runtime.chanClose(%runtime.channel* dereferenceable_or_null(32), i8*, i8*)
-
-attributes #0 = { "tinygo-gowrapper"="main.regularFunction" }
-attributes #1 = { "tinygo-gowrapper"="main.inlineFunctionGoroutine$1" }
-attributes #2 = { "tinygo-gowrapper"="main.closureFunctionGoroutine$1" }
-attributes #3 = { "tinygo-gowrapper" }
@@ -1,106 +0,0 @@
-; ModuleID = 'goroutine.go'
-source_filename = "goroutine.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32--wasi"
-
-%runtime.funcValueWithSignature = type { i32, i8* }
-%runtime.channel = type { i32, i32, i8, %runtime.channelBlockedList*, i32, i32, i32, i8* }
-%runtime.channelBlockedList = type { %runtime.channelBlockedList*, %"internal/task.Task"*, %runtime.chanSelectState*, { %runtime.channelBlockedList*, i32, i32 } }
-%"internal/task.Task" = type { %"internal/task.Task"*, i8*, i64, %"internal/task.state" }
-%"internal/task.state" = type { i8* }
-%runtime.chanSelectState = type { %runtime.channel*, i8* }
-
-@"main.regularFunctionGoroutine$pack" = private unnamed_addr constant { i32, i8* } { i32 5, i8* undef }
-@"main.inlineFunctionGoroutine$pack" = private unnamed_addr constant { i32, i8* } { i32 5, i8* undef }
-@"reflect/types.funcid:func:{basic:int}{}" = external constant i8
-@"main.closureFunctionGoroutine$1$withSignature" = linkonce_odr constant %runtime.funcValueWithSignature { i32 ptrtoint (void (i32, i8*, i8*)* @"main.closureFunctionGoroutine$1" to i32), i8* @"reflect/types.funcid:func:{basic:int}{}" }
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
-
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret void
-}
-
-define hidden void @main.regularFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  call void @"internal/task.start"(i32 ptrtoint (void (i32, i8*, i8*)* @main.regularFunction to i32), i8* bitcast ({ i32, i8* }* @"main.regularFunctionGoroutine$pack" to i8*), i32 undef, i8* undef, i8* null)
-  ret void
-}
-
-declare void @main.regularFunction(i32, i8*, i8*)
-
-declare void @"internal/task.start"(i32, i8*, i32, i8*, i8*)
-
-define hidden void @main.inlineFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  call void @"internal/task.start"(i32 ptrtoint (void (i32, i8*, i8*)* @"main.inlineFunctionGoroutine$1" to i32), i8* bitcast ({ i32, i8* }* @"main.inlineFunctionGoroutine$pack" to i8*), i32 undef, i8* undef, i8* null)
-  ret void
-}
-
-define hidden void @"main.inlineFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret void
-}
-
-define hidden void @main.closureFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %n = call i8* @runtime.alloc(i32 4, i8* undef, i8* null)
-  %0 = bitcast i8* %n to i32*
-  store i32 3, i32* %0, align 4
-  %1 = call i8* @runtime.alloc(i32 8, i8* undef, i8* null)
-  %2 = bitcast i8* %1 to i32*
-  store i32 5, i32* %2, align 4
-  %3 = getelementptr inbounds i8, i8* %1, i32 4
-  %4 = bitcast i8* %3 to i8**
-  store i8* %n, i8** %4, align 4
-  call void @"internal/task.start"(i32 ptrtoint (void (i32, i8*, i8*)* @"main.closureFunctionGoroutine$1" to i32), i8* nonnull %1, i32 undef, i8* undef, i8* null)
-  %5 = load i32, i32* %0, align 4
-  call void @runtime.printint32(i32 %5, i8* undef, i8* null)
-  ret void
-}
-
-define hidden void @"main.closureFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %unpack.ptr = bitcast i8* %context to i32*
-  store i32 7, i32* %unpack.ptr, align 4
-  ret void
-}
-
-declare void @runtime.printint32(i32, i8*, i8*)
-
-define hidden void @main.funcGoroutine(i8* %fn.context, i32 %fn.funcptr, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %0 = call i32 @runtime.getFuncPtr(i8* %fn.context, i32 %fn.funcptr, i8* nonnull @"reflect/types.funcid:func:{basic:int}{}", i8* undef, i8* null)
-  %1 = call i8* @runtime.alloc(i32 8, i8* undef, i8* null)
-  %2 = bitcast i8* %1 to i32*
-  store i32 5, i32* %2, align 4
-  %3 = getelementptr inbounds i8, i8* %1, i32 4
-  %4 = bitcast i8* %3 to i8**
-  store i8* %fn.context, i8** %4, align 4
-  call void @"internal/task.start"(i32 %0, i8* nonnull %1, i32 undef, i8* undef, i8* null)
-  ret void
-}
-
-declare i32 @runtime.getFuncPtr(i8*, i32, i8* dereferenceable_or_null(1), i8*, i8*)
-
-define hidden void @main.recoverBuiltinGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret void
-}
-
-define hidden void @main.copyBuiltinGoroutine(i8* %dst.data, i32 %dst.len, i32 %dst.cap, i8* %src.data, i32 %src.len, i32 %src.cap, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %copy.n = call i32 @runtime.sliceCopy(i8* %dst.data, i8* %src.data, i32 %dst.len, i32 %src.len, i32 1, i8* undef, i8* null)
-  ret void
-}
-
-declare i32 @runtime.sliceCopy(i8* nocapture writeonly, i8* nocapture readonly, i32, i32, i32, i8*, i8*)
-
-define hidden void @main.closeBuiltinGoroutine(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  call void @runtime.chanClose(%runtime.channel* %ch, i8* undef, i8* null)
-  ret void
-}
-
-declare void @runtime.chanClose(%runtime.channel* dereferenceable_or_null(32), i8*, i8*)
@@ -1,43 +0,0 @@
-package main
-
-func regularFunctionGoroutine() {
-	go regularFunction(5)
-}
-
-func inlineFunctionGoroutine() {
-	go func(x int) {
-	}(5)
-}
-
-func closureFunctionGoroutine() {
-	n := 3
-	go func(x int) {
-		n = 7
-	}(5)
-	print(n) // note: this is racy (but good enough for this test)
-}
-
-func funcGoroutine(fn func(x int)) {
-	go fn(5)
-}
-
-func recoverBuiltinGoroutine() {
-	// This is a no-op.
-	go recover()
-}
-
-func copyBuiltinGoroutine(dst, src []byte) {
-	// This is not run in a goroutine. While this copy operation can indeed take
-	// some time (if there is a lot of data to copy), there is no race-free way
-	// to make use of the result so it's unlikely applications will make use of
-	// it. And doing it this way should be just within the Go specification.
-	go copy(dst, src)
-}
-
-func closeBuiltinGoroutine(ch chan int) {
-	// This builtin is executed directly, not in a goroutine.
-	// The observed behavior is the same.
-	go close(ch)
-}
-
-func regularFunction(x int)
@@ -1,54 +0,0 @@
-// This file tests interface types and interface builtins.
-
-package main
-
-// Test interface construction.
-
-func simpleType() interface{} {
-	return 0
-}
-
-func pointerType() interface{} {
-	// Pointers have an element type, in this case int.
-	var v *int
-	return v
-}
-
-func interfaceType() interface{} {
-	// Interfaces can exist in interfaces, but only indirectly (through
-	// pointers).
-	var v *error
-	return v
-}
-
-func anonymousInterfaceType() interface{} {
-	var v *interface {
-		String() string
-	}
-	return v
-}
-
-// Test interface builtins.
-
-func isInt(itf interface{}) bool {
-	_, ok := itf.(int)
-	return ok
-}
-
-func isError(itf interface{}) bool {
-	// Interface assert on (builtin) named interface type.
-	_, ok := itf.(error)
-	return ok
-}
-
-func isStringer(itf interface{}) bool {
-	// Interface assert on anonymous interface type.
-	_, ok := itf.(interface {
-		String() string
-	})
-	return ok
-}
-
-func callErrorMethod(itf error) string {
-	return itf.Error()
-}
@@ -1,101 +0,0 @@
-; ModuleID = 'interface.go'
-source_filename = "interface.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32--wasi"
-
-%runtime.typecodeID = type { %runtime.typecodeID*, i32, %runtime.interfaceMethodInfo*, %runtime.typecodeID* }
-%runtime.interfaceMethodInfo = type { i8*, i32 }
-%runtime._interface = type { i32, i8* }
-%runtime._string = type { i8*, i32 }
-
-@"reflect/types.type:basic:int" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* null, i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:basic:int" }
-@"reflect/types.type:pointer:basic:int" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:basic:int", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null }
-@"reflect/types.type:pointer:named:error" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:named:error", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null }
-@"reflect/types.type:named:error" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:interface:{Error:func:{}{basic:string}}", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:named:error" }
-@"reflect/types.type:interface:{Error:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* bitcast ([1 x i8*]* @"reflect/types.interface:interface{Error() string}$interface" to %runtime.typecodeID*), i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}" }
-@"reflect/methods.Error() string" = linkonce_odr constant i8 0, align 1
-@"reflect/types.interface:interface{Error() string}$interface" = linkonce_odr constant [1 x i8*] [i8* @"reflect/methods.Error() string"]
-@"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:interface:{Error:func:{}{basic:string}}", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null }
-@"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:interface:{String:func:{}{basic:string}}", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null }
-@"reflect/types.type:interface:{String:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* bitcast ([1 x i8*]* @"reflect/types.interface:interface{String() string}$interface" to %runtime.typecodeID*), i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}" }
-@"reflect/methods.String() string" = linkonce_odr constant i8 0, align 1
-@"reflect/types.interface:interface{String() string}$interface" = linkonce_odr constant [1 x i8*] [i8* @"reflect/methods.String() string"]
-@"reflect/types.typeid:basic:int" = external constant i8
-@"error$interface" = linkonce_odr constant [1 x i8*] [i8* @"reflect/methods.Error() string"]
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
-
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret void
-}
-
-define hidden %runtime._interface @main.simpleType(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret %runtime._interface { i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:basic:int" to i32), i8* null }
-}
-
-define hidden %runtime._interface @main.pointerType(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret %runtime._interface { i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:pointer:basic:int" to i32), i8* null }
-}
-
-define hidden %runtime._interface @main.interfaceType(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret %runtime._interface { i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:pointer:named:error" to i32), i8* null }
-}
-
-define hidden %runtime._interface @main.anonymousInterfaceType(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret %runtime._interface { i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}" to i32), i8* null }
-}
-
-define hidden i1 @main.isInt(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %typecode = call i1 @runtime.typeAssert(i32 %itf.typecode, i8* nonnull @"reflect/types.typeid:basic:int", i8* undef, i8* null)
-  br i1 %typecode, label %typeassert.ok, label %typeassert.next
-
-typeassert.ok:                                    ; preds = %entry
-  br label %typeassert.next
-
-typeassert.next:                                  ; preds = %typeassert.ok, %entry
-  ret i1 %typecode
-}
-
-declare i1 @runtime.typeAssert(i32, i8* dereferenceable_or_null(1), i8*, i8*)
-
-define hidden i1 @main.isError(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %0 = call i1 @runtime.interfaceImplements(i32 %itf.typecode, i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @"error$interface", i32 0, i32 0), i8* undef, i8* null)
-  br i1 %0, label %typeassert.ok, label %typeassert.next
-
-typeassert.ok:                                    ; preds = %entry
-  br label %typeassert.next
-
-typeassert.next:                                  ; preds = %typeassert.ok, %entry
-  ret i1 %0
-}
-
-declare i1 @runtime.interfaceImplements(i32, i8** dereferenceable_or_null(4), i8*, i8*)
-
-define hidden i1 @main.isStringer(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %0 = call i1 @runtime.interfaceImplements(i32 %itf.typecode, i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @"reflect/types.interface:interface{String() string}$interface", i32 0, i32 0), i8* undef, i8* null)
-  br i1 %0, label %typeassert.ok, label %typeassert.next
-
-typeassert.ok:                                    ; preds = %entry
-  br label %typeassert.next
-
-typeassert.next:                                  ; preds = %typeassert.ok, %entry
-  ret i1 %0
-}
-
-define hidden %runtime._string @main.callErrorMethod(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %invoke.func = call i32 @runtime.interfaceMethod(i32 %itf.typecode, i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @"error$interface", i32 0, i32 0), i8* nonnull @"reflect/methods.Error() string", i8* undef, i8* null)
-  %invoke.func.cast = inttoptr i32 %invoke.func to %runtime._string (i8*, i8*, i8*)*
-  %0 = call %runtime._string %invoke.func.cast(i8* %itf.value, i8* undef, i8* undef)
-  ret %runtime._string %0
-}
-
-declare i32 @runtime.interfaceMethod(i32, i8** dereferenceable_or_null(4), i8* dereferenceable_or_null(1), i8*, i8*)
@@ -1,27 +0,0 @@
-; ModuleID = 'intrinsics.go'
-source_filename = "intrinsics.go"
-target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
-target triple = "armv7m-none-eabi"
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
-
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret void
-}
-
-define hidden double @main.mySqrt(double %x, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %0 = call double @math.Sqrt(double %x, i8* undef, i8* undef)
-  ret double %0
-}
-
-declare double @math.Sqrt(double, i8*, i8*)
-
-define hidden double @main.myTrunc(double %x, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %0 = call double @math.Trunc(double %x, i8* undef, i8* undef)
-  ret double %0
-}
-
-declare double @math.Trunc(double, i8*, i8*)
@@ -1,31 +0,0 @@
-; ModuleID = 'intrinsics.go'
-source_filename = "intrinsics.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32--wasi"
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
-
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret void
-}
-
-define hidden double @main.mySqrt(double %x, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %0 = call double @llvm.sqrt.f64(double %x)
-  ret double %0
-}
-
-; Function Attrs: nounwind readnone speculatable willreturn
-declare double @llvm.sqrt.f64(double) #0
-
-define hidden double @main.myTrunc(double %x, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %0 = call double @llvm.trunc.f64(double %x)
-  ret double %0
-}
-
-; Function Attrs: nounwind readnone speculatable willreturn
-declare double @llvm.trunc.f64(double) #0
-
-attributes #0 = { nounwind readnone speculatable willreturn }
@@ -1,14 +0,0 @@
-package main
-
-// Test how intrinsics are lowered: either as regular calls to the math
-// functions or as LLVM builtins (such as llvm.sqrt.f64).
-
-import "math"
-
-func mySqrt(x float64) float64 {
-	return math.Sqrt(x)
-}
-
-func myTrunc(x float64) float64 {
-	return math.Trunc(x)
-}
@@ -1,50 +1,48 @@
 ; ModuleID = 'pointer.go'
 source_filename = "pointer.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32--wasi"
+target datalayout = "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-f80:32-n8:16:32-S128"
+target triple = "i686--linux"

-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
-
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
+define internal void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret void
 }

-define hidden [0 x i32] @main.pointerDerefZero([0 x i32]* %x, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal [0 x i32] @main.pointerDerefZero([0 x i32]* %x, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret [0 x i32] zeroinitializer
 }

-define hidden i32* @main.pointerCastFromUnsafe(i8* %x, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal i32* @main.pointerCastFromUnsafe(i8* %x, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = bitcast i8* %x to i32*
  ret i32* %0
 }

-define hidden i8* @main.pointerCastToUnsafe(i32* dereferenceable_or_null(4) %x, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal i8* @main.pointerCastToUnsafe(i32* dereferenceable_or_null(4) %x, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = bitcast i32* %x to i8*
  ret i8* %0
 }

-define hidden i8* @main.pointerCastToUnsafeNoop(i8* dereferenceable_or_null(1) %x, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal i8* @main.pointerCastToUnsafeNoop(i8* dereferenceable_or_null(1) %x, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret i8* %x
 }

-define hidden i8* @main.pointerUnsafeGEPFixedOffset(i8* dereferenceable_or_null(1) %ptr, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal i8* @main.pointerUnsafeGEPFixedOffset(i8* dereferenceable_or_null(1) %ptr, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = getelementptr inbounds i8, i8* %ptr, i32 10
  ret i8* %0
 }

-define hidden i8* @main.pointerUnsafeGEPByteOffset(i8* dereferenceable_or_null(1) %ptr, i32 %offset, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal i8* @main.pointerUnsafeGEPByteOffset(i8* dereferenceable_or_null(1) %ptr, i32 %offset, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = getelementptr inbounds i8, i8* %ptr, i32 %offset
  ret i8* %0
 }

-define hidden i32* @main.pointerUnsafeGEPIntOffset(i32* dereferenceable_or_null(4) %ptr, i32 %offset, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal i32* @main.pointerUnsafeGEPIntOffset(i32* dereferenceable_or_null(4) %ptr, i32 %offset, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = getelementptr i32, i32* %ptr, i32 %offset
  ret i32* %0
@@ -1,66 +0,0 @@
-package main
-
-import _ "unsafe"
-
-// Creates an external global with name extern_global.
-//go:extern extern_global
-var externGlobal [0]byte
-
-// Creates a
-//go:align 32
-var alignedGlobal [4]uint32
-
-// Test conflicting pragmas (the last one counts).
-//go:align 64
-//go:align 16
-var alignedGlobal16 [4]uint32
-
-// Test exported functions.
-//export extern_func
-func externFunc() {
-}
-
-// Define a function in a different package using go:linkname.
-//go:linkname withLinkageName1 somepkg.someFunction1
-func withLinkageName1() {
-}
-
-// Import a function from a different package using go:linkname.
-//go:linkname withLinkageName2 somepkg.someFunction2
-func withLinkageName2()
-
-// Function has an 'inline hint', similar to the inline keyword in C.
-//go:inline
-func inlineFunc() {
-}
-
-// Function should never be inlined, equivalent to GCC
-// __attribute__((noinline)).
-//go:noinline
-func noinlineFunc() {
-}
-
-// This function should have the specified section.
-//go:section .special_function_section
-func functionInSection() {
-}
-
-//export exportedFunctionInSection
-//go:section .special_function_section
-func exportedFunctionInSection() {
-}
-
-// This function should not: it's only a declaration and not a definition.
-//go:section .special_function_section
-func undefinedFunctionNotInSection()
-
-//go:section .special_global_section
-var globalInSection uint32
-
-//go:section .special_global_section
-//go:extern undefinedGlobalNotInSection
-var undefinedGlobalNotInSection uint32
-
-//go:align 1024
-//go:section .global_section
-var multipleGlobalPragmas uint32
@@ -1,59 +0,0 @@
-; ModuleID = 'pragma.go'
-source_filename = "pragma.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32--wasi"
-
-@extern_global = external global [0 x i8], align 1
-@main.alignedGlobal = hidden global [4 x i32] zeroinitializer, align 32
-@main.alignedGlobal16 = hidden global [4 x i32] zeroinitializer, align 16
-@main.globalInSection = hidden global i32 0, section ".special_global_section", align 4
-@undefinedGlobalNotInSection = external global i32, align 4
-@main.multipleGlobalPragmas = hidden global i32 0, section ".global_section", align 1024
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
-
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret void
-}
-
-define void @extern_func() #0 {
-entry:
-  ret void
-}
-
-define hidden void @somepkg.someFunction1(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret void
-}
-
-declare void @somepkg.someFunction2(i8*, i8*)
-
-; Function Attrs: inlinehint
-define hidden void @main.inlineFunc(i8* %context, i8* %parentHandle) unnamed_addr #1 {
-entry:
-  ret void
-}
-
-; Function Attrs: noinline
-define hidden void @main.noinlineFunc(i8* %context, i8* %parentHandle) unnamed_addr #2 {
-entry:
-  ret void
-}
-
-define hidden void @main.functionInSection(i8* %context, i8* %parentHandle) unnamed_addr section ".special_function_section" {
-entry:
-  ret void
-}
-
-define void @exportedFunctionInSection() #3 section ".special_function_section" {
-entry:
-  ret void
-}
-
-declare void @main.undefinedFunctionNotInSection(i8*, i8*)
-
-attributes #0 = { "wasm-export-name"="extern_func" }
-attributes #1 = { inlinehint }
-attributes #2 = { noinline }
-attributes #3 = { "wasm-export-name"="exportedFunctionInSection" }
@@ -7,37 +7,3 @@ func sliceLen(ints []int) int {
 func sliceCap(ints []int) int {
 	return cap(ints)
 }
-
-func sliceElement(ints []int, index int) int {
-	return ints[index]
-}
-
-func sliceAppendValues(ints []int) []int {
-	return append(ints, 1, 2, 3)
-}
-
-func sliceAppendSlice(ints, added []int) []int {
-	return append(ints, added...)
-}
-
-func sliceCopy(dst, src []int) int {
-	return copy(dst, src)
-}
-
-// Test bounds checking in *ssa.MakeSlice instruction.
-
-func makeByteSlice(len int) []byte {
-	return make([]byte, len)
-}
-
-func makeInt16Slice(len int) []int16 {
-	return make([]int16, len)
-}
-
-func makeArraySlice(len int) [][3]byte {
-	return make([][3]byte, len) // slice with element size of 3
-}
-
-func makeInt32Slice(len int) []int32 {
-	return make([]int32, len)
-}
@@ -1,164 +1,19 @@
 ; ModuleID = 'slice.go'
 source_filename = "slice.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32--wasi"
+target datalayout = "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-f80:32-n8:16:32-S128"
+target triple = "i686--linux"

-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
-
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
+define internal void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret void
 }

-define hidden i32 @main.sliceLen(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal i32 @main.sliceLen(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret i32 %ints.len
 }

-define hidden i32 @main.sliceCap(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context, i8* %parentHandle) unnamed_addr {
+define internal i32 @main.sliceCap(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret i32 %ints.cap
 }
-
-define hidden i32 @main.sliceElement(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i32 %index, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %.not = icmp ult i32 %index, %ints.len
-  br i1 %.not, label %lookup.next, label %lookup.throw
-
-lookup.throw:                                     ; preds = %entry
-  call void @runtime.lookupPanic(i8* undef, i8* null)
-  unreachable
-
-lookup.next:                                      ; preds = %entry
-  %0 = getelementptr inbounds i32, i32* %ints.data, i32 %index
-  %1 = load i32, i32* %0, align 4
-  ret i32 %1
-}
-
-declare void @runtime.lookupPanic(i8*, i8*)
-
-define hidden { i32*, i32, i32 } @main.sliceAppendValues(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %varargs = call i8* @runtime.alloc(i32 12, i8* undef, i8* null)
-  %0 = bitcast i8* %varargs to i32*
-  store i32 1, i32* %0, align 4
-  %1 = getelementptr inbounds i8, i8* %varargs, i32 4
-  %2 = bitcast i8* %1 to i32*
-  store i32 2, i32* %2, align 4
-  %3 = getelementptr inbounds i8, i8* %varargs, i32 8
-  %4 = bitcast i8* %3 to i32*
-  store i32 3, i32* %4, align 4
-  %append.srcPtr = bitcast i32* %ints.data to i8*
-  %append.new = call { i8*, i32, i32 } @runtime.sliceAppend(i8* %append.srcPtr, i8* nonnull %varargs, i32 %ints.len, i32 %ints.cap, i32 3, i32 4, i8* undef, i8* null)
-  %append.newPtr = extractvalue { i8*, i32, i32 } %append.new, 0
-  %append.newBuf = bitcast i8* %append.newPtr to i32*
-  %append.newLen = extractvalue { i8*, i32, i32 } %append.new, 1
-  %append.newCap = extractvalue { i8*, i32, i32 } %append.new, 2
-  %5 = insertvalue { i32*, i32, i32 } undef, i32* %append.newBuf, 0
-  %6 = insertvalue { i32*, i32, i32 } %5, i32 %append.newLen, 1
-  %7 = insertvalue { i32*, i32, i32 } %6, i32 %append.newCap, 2
-  ret { i32*, i32, i32 } %7
-}
-
-declare { i8*, i32, i32 } @runtime.sliceAppend(i8*, i8* nocapture readonly, i32, i32, i32, i32, i8*, i8*)
-
-define hidden { i32*, i32, i32 } @main.sliceAppendSlice(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i32* %added.data, i32 %added.len, i32 %added.cap, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %append.srcPtr = bitcast i32* %ints.data to i8*
-  %append.srcPtr1 = bitcast i32* %added.data to i8*
-  %append.new = call { i8*, i32, i32 } @runtime.sliceAppend(i8* %append.srcPtr, i8* %append.srcPtr1, i32 %ints.len, i32 %ints.cap, i32 %added.len, i32 4, i8* undef, i8* null)
-  %append.newPtr = extractvalue { i8*, i32, i32 } %append.new, 0
-  %append.newBuf = bitcast i8* %append.newPtr to i32*
-  %append.newLen = extractvalue { i8*, i32, i32 } %append.new, 1
-  %append.newCap = extractvalue { i8*, i32, i32 } %append.new, 2
-  %0 = insertvalue { i32*, i32, i32 } undef, i32* %append.newBuf, 0
-  %1 = insertvalue { i32*, i32, i32 } %0, i32 %append.newLen, 1
-  %2 = insertvalue { i32*, i32, i32 } %1, i32 %append.newCap, 2
-  ret { i32*, i32, i32 } %2
-}
-
-define hidden i32 @main.sliceCopy(i32* %dst.data, i32 %dst.len, i32 %dst.cap, i32* %src.data, i32 %src.len, i32 %src.cap, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %copy.dstPtr = bitcast i32* %dst.data to i8*
-  %copy.srcPtr = bitcast i32* %src.data to i8*
-  %copy.n = call i32 @runtime.sliceCopy(i8* %copy.dstPtr, i8* %copy.srcPtr, i32 %dst.len, i32 %src.len, i32 4, i8* undef, i8* null)
-  ret i32 %copy.n
-}
-
-declare i32 @runtime.sliceCopy(i8* nocapture writeonly, i8* nocapture readonly, i32, i32, i32, i8*, i8*)
-
-define hidden { i8*, i32, i32 } @main.makeByteSlice(i32 %len, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %slice.maxcap = icmp slt i32 %len, 0
-  br i1 %slice.maxcap, label %slice.throw, label %slice.next
-
-slice.throw:                                      ; preds = %entry
-  call void @runtime.slicePanic(i8* undef, i8* null)
-  unreachable
-
-slice.next:                                       ; preds = %entry
-  %makeslice.buf = call i8* @runtime.alloc(i32 %len, i8* undef, i8* null)
-  %0 = insertvalue { i8*, i32, i32 } undef, i8* %makeslice.buf, 0
-  %1 = insertvalue { i8*, i32, i32 } %0, i32 %len, 1
-  %2 = insertvalue { i8*, i32, i32 } %1, i32 %len, 2
-  ret { i8*, i32, i32 } %2
-}
-
-declare void @runtime.slicePanic(i8*, i8*)
-
-define hidden { i16*, i32, i32 } @main.makeInt16Slice(i32 %len, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %slice.maxcap = icmp slt i32 %len, 0
-  br i1 %slice.maxcap, label %slice.throw, label %slice.next
-
-slice.throw:                                      ; preds = %entry
-  call void @runtime.slicePanic(i8* undef, i8* null)
-  unreachable
-
-slice.next:                                       ; preds = %entry
-  %makeslice.cap = shl i32 %len, 1
-  %makeslice.buf = call i8* @runtime.alloc(i32 %makeslice.cap, i8* undef, i8* null)
-  %makeslice.array = bitcast i8* %makeslice.buf to i16*
-  %0 = insertvalue { i16*, i32, i32 } undef, i16* %makeslice.array, 0
-  %1 = insertvalue { i16*, i32, i32 } %0, i32 %len, 1
-  %2 = insertvalue { i16*, i32, i32 } %1, i32 %len, 2
-  ret { i16*, i32, i32 } %2
-}
-
-define hidden { [3 x i8]*, i32, i32 } @main.makeArraySlice(i32 %len, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %slice.maxcap = icmp ugt i32 %len, 1431655765
-  br i1 %slice.maxcap, label %slice.throw, label %slice.next
-
-slice.throw:                                      ; preds = %entry
-  call void @runtime.slicePanic(i8* undef, i8* null)
-  unreachable
-
-slice.next:                                       ; preds = %entry
-  %makeslice.cap = mul i32 %len, 3
-  %makeslice.buf = call i8* @runtime.alloc(i32 %makeslice.cap, i8* undef, i8* null)
-  %makeslice.array = bitcast i8* %makeslice.buf to [3 x i8]*
-  %0 = insertvalue { [3 x i8]*, i32, i32 } undef, [3 x i8]* %makeslice.array, 0
-  %1 = insertvalue { [3 x i8]*, i32, i32 } %0, i32 %len, 1
-  %2 = insertvalue { [3 x i8]*, i32, i32 } %1, i32 %len, 2
-  ret { [3 x i8]*, i32, i32 } %2
-}
-
-define hidden { i32*, i32, i32 } @main.makeInt32Slice(i32 %len, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %slice.maxcap = icmp ugt i32 %len, 1073741823
-  br i1 %slice.maxcap, label %slice.throw, label %slice.next
-
-slice.throw:                                      ; preds = %entry
-  call void @runtime.slicePanic(i8* undef, i8* null)
-  unreachable
-
-slice.next:                                       ; preds = %entry
-  %makeslice.cap = shl i32 %len, 2
-  %makeslice.buf = call i8* @runtime.alloc(i32 %makeslice.cap, i8* undef, i8* null)
-  %makeslice.array = bitcast i8* %makeslice.buf to i32*
-  %0 = insertvalue { i32*, i32, i32 } undef, i32* %makeslice.array, 0
-  %1 = insertvalue { i32*, i32, i32 } %0, i32 %len, 1
-  %2 = insertvalue { i32*, i32, i32 } %1, i32 %len, 2
-  ret { i32*, i32, i32 } %2
-}
@@ -1,29 +0,0 @@
-package main
-
-func someString() string {
-	return "foo"
-}
-
-func zeroLengthString() string {
-	return ""
-}
-
-func stringLen(s string) int {
-	return len(s)
-}
-
-func stringIndex(s string, index int) byte {
-	return s[index]
-}
-
-func stringCompareEqual(s1, s2 string) bool {
-	return s1 == s2
-}
-
-func stringCompareUnequal(s1, s2 string) bool {
-	return s1 != s2
-}
-
-func stringCompareLarger(s1, s2 string) bool {
-	return s1 > s2
-}
@@ -1,71 +0,0 @@
-; ModuleID = 'string.go'
-source_filename = "string.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32--wasi"
-
-%runtime._string = type { i8*, i32 }
-
-@"main.someString$string" = internal unnamed_addr constant [3 x i8] c"foo", align 1
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
-
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret void
-}
-
-define hidden %runtime._string @main.someString(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret %runtime._string { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @"main.someString$string", i32 0, i32 0), i32 3 }
-}
-
-define hidden %runtime._string @main.zeroLengthString(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret %runtime._string zeroinitializer
-}
-
-define hidden i32 @main.stringLen(i8* %s.data, i32 %s.len, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  ret i32 %s.len
-}
-
-define hidden i8 @main.stringIndex(i8* %s.data, i32 %s.len, i32 %index, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %.not = icmp ult i32 %index, %s.len
-  br i1 %.not, label %lookup.next, label %lookup.throw
-
-lookup.throw:                                     ; preds = %entry
-  call void @runtime.lookupPanic(i8* undef, i8* null)
-  unreachable
-
-lookup.next:                                      ; preds = %entry
-  %0 = getelementptr inbounds i8, i8* %s.data, i32 %index
-  %1 = load i8, i8* %0, align 1
-  ret i8 %1
-}
-
-declare void @runtime.lookupPanic(i8*, i8*)
-
-define hidden i1 @main.stringCompareEqual(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %0 = call i1 @runtime.stringEqual(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* undef, i8* null)
-  ret i1 %0
-}
-
-declare i1 @runtime.stringEqual(i8*, i32, i8*, i32, i8*, i8*)
-
-define hidden i1 @main.stringCompareUnequal(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %0 = call i1 @runtime.stringEqual(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* undef, i8* null)
-  %1 = xor i1 %0, true
-  ret i1 %1
-}
-
-define hidden i1 @main.stringCompareLarger(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  %0 = call i1 @runtime.stringLess(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* undef, i8* null)
-  %1 = xor i1 %0, true
-  ret i1 %1
-}
-
-declare i1 @runtime.stringLess(i8*, i32, i8*, i32, i8*, i8*)
@@ -1,6 +1,6 @@
 module github.com/tinygo-org/tinygo

-go 1.15
+go 1.13

 require (
 	github.com/blakesmith/ar v0.0.0-20150311145944-8bd4349a67f2
@@ -10,7 +10,7 @@ require (
 	github.com/marcinbor85/gohex v0.0.0-20200531091804-343a4b548892
 	github.com/mattn/go-colorable v0.1.8
 	go.bug.st/serial v1.1.2
-	golang.org/x/sys v0.0.0-20210510120138-977fb7262007
-	golang.org/x/tools v0.1.6-0.20210813165731-45389f592fe9
-	tinygo.org/x/go-llvm v0.0.0-20210325115028-e7b85195e81c
+	golang.org/x/sys v0.0.0-20210113181707-4bcb84eeeb78
+	golang.org/x/tools v0.0.0-20200216192241-b320d3a0f5a2
+	tinygo.org/x/go-llvm v0.0.0-20210206225315-7fe719483a0f
 )
@@ -30,8 +30,6 @@ github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Ky
 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=
-github.com/yuin/goldmark v1.3.5 h1:dPmz1Snjq0kmkz159iL7S6WzdahUTHnHB5M56WFVifs=
-github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
 go.bug.st/serial v1.0.0 h1:ogEPzrllCsnG00EqKRjeYvPRsO7NJW6DqykzkdD6E/k=
 go.bug.st/serial v1.0.0/go.mod h1:rpXPISGjuNjPTRTcMlxi9lN6LoIPxd1ixVjBd8aSk/Q=
 go.bug.st/serial v1.1.2 h1:6xDpbta8KJ+VLRTeM8ghhxXRMLE/Lr8h9iDKwydarAY=
@@ -40,35 +38,24 @@ golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACk
 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/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 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/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191128015809-6d18c012aee9 h1:ZBzSG/7F4eNKz2L3GE9o300RX0Az1Bw5HF7PDraD+qU=
+golang.org/x/sys v0.0.0-20191128015809-6d18c012aee9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200909081042-eff7692f9009/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210113181707-4bcb84eeeb78 h1:nVuTkr9L6Bq62qpUqKo/RnZCFfzDBL0bYo6w9OJUqZY=
 golang.org/x/sys v0.0.0-20210113181707-4bcb84eeeb78/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210510120138-977fb7262007 h1:gG67DSER+11cZvqIMb8S8bt0vZtiN6xWYARwirrOSfE=
-golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.1.6-0.20210813165731-45389f592fe9 h1:nvvuMxmx1q0gfRki3T0hjG8EwAcVCs91oWAXvyt4zhI=
-golang.org/x/tools v0.1.6-0.20210813165731-45389f592fe9/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+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=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/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-20210308112806-9ef958b6bed4 h1:CMUHxVTb+UuUePuMf8vkWjZ3gTp9BBK91KrgOCwoNHs=
-tinygo.org/x/go-llvm v0.0.0-20210308112806-9ef958b6bed4/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
-tinygo.org/x/go-llvm v0.0.0-20210325115028-e7b85195e81c h1:vn9IPshzYmzZis10UEVrsIBRv9FpykADw6M3/tHHROg=
-tinygo.org/x/go-llvm v0.0.0-20210325115028-e7b85195e81c/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
+tinygo.org/x/go-llvm v0.0.0-20210206225315-7fe719483a0f h1:FP5Do5omlQ/dLQ3Hfy7oyJo69VS5Hn46rZw004r0lGU=
+tinygo.org/x/go-llvm v0.0.0-20210206225315-7fe719483a0f/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
@@ -171,9 +171,8 @@ func getGoroot() string {
 	switch runtime.GOOS {
 	case "linux":
 		candidates = []string{
-			"/usr/local/go",     // manually installed
-			"/usr/lib/go",       // from the distribution
-			"/snap/go/current/", // installed using snap
+			"/usr/local/go", // manually installed
+			"/usr/lib/go",   // from the distribution
 		}
 	case "darwin":
 		candidates = []string{
@@ -12,7 +12,7 @@ import (

 // Version of TinyGo.
 // Update this value before release of new version of software.
-const Version = "0.20.0"
+const Version = "0.18.0-dev"

 // GetGorootVersion returns the major and minor version for a given GOROOT path.
 // If the goroot cannot be determined, (0, 0) is returned.
@@ -48,10 +48,7 @@ func GetGorootVersion(goroot string) (major, minor int, err error) {
 // 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, "VERSION")); err == nil {
-		return string(data), nil
-
-	} else if data, err := ioutil.ReadFile(filepath.Join(
+	if data, err := ioutil.ReadFile(filepath.Join(
 		goroot, "src", "runtime", "internal", "sys", "zversion.go")); err == nil {

 		r := regexp.MustCompile("const TheVersion = `(.*)`")
@@ -62,6 +59,9 @@ func GorootVersionString(goroot string) (string, error) {

 		return string(matches[1]), nil

+	} else if data, err := ioutil.ReadFile(filepath.Join(goroot, "VERSION")); err == nil {
+		return string(data), nil
+
 	} else {
 		return "", err
 	}
@@ -25,7 +25,6 @@ type function struct {
 // basicBlock represents a LLVM basic block and contains a slice of
 // instructions. The last instruction must be a terminator instruction.
 type basicBlock struct {
-	phiNodes     []instruction
 	instructions []instruction
 }

@@ -136,15 +135,6 @@ func (r *runner) compileFunction(llvmFn llvm.Value) *function {
 				default:
 					panic("unknown number of operands")
 				}
-			case llvm.Switch:
-				// A switch is an array of (value, label) pairs, of which the
-				// first one indicates the to-switch value and the default
-				// label.
-				numOperands := llvmInst.OperandsCount()
-				for i := 0; i < numOperands; i += 2 {
-					inst.operands = append(inst.operands, r.getValue(llvmInst.Operand(i)))
-					inst.operands = append(inst.operands, literalValue{uint32(blockIndices[llvmInst.Operand(i+1)])})
-				}
 			case llvm.PHI:
 				inst.name = llvmInst.Name()
 				incomingCount := inst.llvmInst.IncomingCount()
@@ -347,13 +337,7 @@ func (r *runner) compileFunction(llvmFn llvm.Value) *function {
 				// This error is handled when actually trying to interpret this
 				// instruction (to not trigger on code that won't be executed).
 			}
-			if inst.opcode == llvm.PHI {
-				// PHI nodes need to be treated specially, see the comment in
-				// interpreter.go for an explanation.
-				bb.phiNodes = append(bb.phiNodes, inst)
-			} else {
-				bb.instructions = append(bb.instructions, inst)
-			}
+			bb.instructions = append(bb.instructions, inst)
 		}
 	}
 	return fn
@@ -20,11 +20,6 @@ var (
 	errMapAlreadyCreated      = errors.New("interp: map already created")
 )

-// This is one of the errors that can be returned from toLLVMValue when the
-// passed type does not fit the data to serialize. It is recoverable by
-// serializing without a type (using rawValue.rawLLVMValue).
-var errInvalidPtrToIntSize = errors.New("interp: ptrtoint integer size does not equal pointer size")
-
 func isRecoverableError(err error) bool {
 	return err == errIntegerAsPointer || err == errUnsupportedInst || err == errUnsupportedRuntimeInst || err == errMapAlreadyCreated
 }
@@ -57,7 +52,6 @@ func (r *runner) errorAt(inst instruction, err error) *Error {
 	pos := getPosition(inst.llvmInst)
 	return &Error{
 		ImportPath: r.pkgName,
-		Inst:       inst.llvmInst,
 		Pos:        pos,
 		Err:        err,
 		Traceback:  []ErrorLine{{pos, inst.llvmInst}},
@@ -11,12 +11,6 @@ import (
 	"tinygo.org/x/go-llvm"
 )

-// Version of the interp package. It must be incremented whenever the interp
-// package is changed in a way that affects the output so that cached package
-// builds will be invalidated.
-// This version is independent of the TinyGo version number.
-const Version = 2 // last change: fix GEP on untyped pointers
-
 // Enable extra checks, which should be disabled by default.
 // This may help track down bugs by adding a few more sanity checks.
 const checks = true
@@ -38,7 +32,9 @@ type runner struct {
 	callsExecuted uint64
 }

-func newRunner(mod llvm.Module, debug bool) *runner {
+// Run evaluates runtime.initAll function as much as possible at compile time.
+// Set debug to true if it should print output while running.
+func Run(mod llvm.Module, debug bool) error {
 	r := runner{
 		mod:           mod,
 		targetData:    llvm.NewTargetData(mod.DataLayout()),
@@ -51,13 +47,6 @@ func newRunner(mod llvm.Module, debug bool) *runner {
 	r.pointerSize = uint32(r.targetData.PointerSize())
 	r.i8ptrType = llvm.PointerType(mod.Context().Int8Type(), 0)
 	r.maxAlign = r.targetData.PrefTypeAlignment(r.i8ptrType) // assume pointers are maximally aligned (this is not always the case)
-	return &r
-}
-
-// Run evaluates runtime.initAll function as much as possible at compile time.
-// Set debug to true if it should print output while running.
-func Run(mod llvm.Module, debug bool) error {
-	r := newRunner(mod, debug)

 	initAll := mod.NamedFunction("runtime.initAll")
 	bb := initAll.EntryBasicBlock()
@@ -110,26 +99,17 @@ func Run(mod llvm.Module, debug bool) error {
 			fmt.Fprintln(os.Stderr, "call:", fn.Name())
 		}
 		_, mem, callErr := r.run(r.getFunction(fn), nil, nil, "    ")
-		call.EraseFromParentAsInstruction()
 		if callErr != nil {
 			if isRecoverableError(callErr.Err) {
 				if r.debug {
 					fmt.Fprintln(os.Stderr, "not interpreting", r.pkgName, "because of error:", callErr.Error())
 				}
-				// Remove instructions that were created as part of interpreting
-				// the package.
 				mem.revert()
-				// Create a call to the package initializer (which was
-				// previously deleted).
-				i8undef := llvm.Undef(r.i8ptrType)
-				r.builder.CreateCall(fn, []llvm.Value{i8undef, i8undef}, "")
-				// Make sure that any globals touched by the package
-				// initializer, won't be accessed by later package initializers.
-				r.markExternalLoad(fn)
 				continue
 			}
 			return callErr
 		}
+		call.EraseFromParentAsInstruction()
 		for index, obj := range mem.objects {
 			r.objects[index] = obj
 		}
@@ -137,110 +117,7 @@ func Run(mod llvm.Module, debug bool) error {
 	r.pkgName = ""

 	// Update all global variables in the LLVM module.
-	mem := memoryView{r: r}
-	for i, obj := range r.objects {
-		if obj.llvmGlobal.IsNil() {
-			continue
-		}
-		if obj.buffer == nil {
-			continue
-		}
-		initializer, err := obj.buffer.toLLVMValue(obj.llvmGlobal.Type().ElementType(), &mem)
-		if err == errInvalidPtrToIntSize {
-			// This can happen when a previous interp run did not have the
-			// correct LLVM type for a global and made something up. In that
-			// case, some fields could be written out as a series of (null)
-			// bytes even though they actually contain a pointer value.
-			// As a fallback, use asRawValue to get something of the correct
-			// memory layout.
-			initializer, err := obj.buffer.asRawValue(r).rawLLVMValue(&mem)
-			if err != nil {
-				return err
-			}
-			initializerType := initializer.Type()
-			newGlobal := llvm.AddGlobal(mod, initializerType, obj.llvmGlobal.Name()+".tmp")
-			newGlobal.SetInitializer(initializer)
-			newGlobal.SetLinkage(obj.llvmGlobal.Linkage())
-			newGlobal.SetAlignment(obj.llvmGlobal.Alignment())
-			// TODO: copy debug info, unnamed_addr, ...
-			bitcast := llvm.ConstBitCast(newGlobal, obj.llvmGlobal.Type())
-			obj.llvmGlobal.ReplaceAllUsesWith(bitcast)
-			name := obj.llvmGlobal.Name()
-			obj.llvmGlobal.EraseFromParentAsGlobal()
-			newGlobal.SetName(name)
-
-			// Update interp-internal references.
-			delete(r.globals, obj.llvmGlobal)
-			obj.llvmGlobal = newGlobal
-			r.globals[newGlobal] = i
-			r.objects[i] = obj
-			continue
-		}
-		if err != nil {
-			return err
-		}
-		if checks && initializer.Type() != obj.llvmGlobal.Type().ElementType() {
-			panic("initializer type mismatch")
-		}
-		obj.llvmGlobal.SetInitializer(initializer)
-	}
-
-	return nil
-}
-
-// RunFunc evaluates a single package initializer at compile time.
-// Set debug to true if it should print output while running.
-func RunFunc(fn llvm.Value, debug bool) error {
-	// Create and initialize *runner object.
-	mod := fn.GlobalParent()
-	r := newRunner(mod, debug)
-	initName := fn.Name()
-	if !strings.HasSuffix(initName, ".init") {
-		return errorAt(fn, "interp: unexpected function name (expected *.init)")
-	}
-	r.pkgName = initName[:len(initName)-len(".init")]
-
-	// Create new function with the interp result.
-	newFn := llvm.AddFunction(mod, fn.Name()+".tmp", fn.Type().ElementType())
-	newFn.SetLinkage(fn.Linkage())
-	newFn.SetVisibility(fn.Visibility())
-	entry := mod.Context().AddBasicBlock(newFn, "entry")
-
-	// Create a builder, to insert instructions that could not be evaluated at
-	// compile time.
-	r.builder = mod.Context().NewBuilder()
-	defer r.builder.Dispose()
-	r.builder.SetInsertPointAtEnd(entry)
-
-	// Copy debug information.
-	subprogram := fn.Subprogram()
-	if !subprogram.IsNil() {
-		newFn.SetSubprogram(subprogram)
-		r.builder.SetCurrentDebugLocation(subprogram.SubprogramLine(), 0, subprogram, llvm.Metadata{})
-	}
-
-	// Run the initializer, filling the .init.tmp function.
-	if r.debug {
-		fmt.Fprintln(os.Stderr, "interp:", fn.Name())
-	}
-	_, pkgMem, callErr := r.run(r.getFunction(fn), nil, nil, "    ")
-	if callErr != nil {
-		if isRecoverableError(callErr.Err) {
-			// Could not finish, but could recover from it.
-			if r.debug {
-				fmt.Fprintln(os.Stderr, "not interpreting", r.pkgName, "because of error:", callErr.Error())
-			}
-			newFn.EraseFromParentAsFunction()
-			return nil
-		}
-		return callErr
-	}
-	for index, obj := range pkgMem.objects {
-		r.objects[index] = obj
-	}
-
-	// Update globals with values determined while running the initializer above.
-	mem := memoryView{r: r}
+	mem := memoryView{r: &r}
 	for _, obj := range r.objects {
 		if obj.llvmGlobal.IsNil() {
 			continue
@@ -248,24 +125,13 @@ func RunFunc(fn llvm.Value, debug bool) error {
 		if obj.buffer == nil {
 			continue
 		}
-		initializer, err := obj.buffer.toLLVMValue(obj.llvmGlobal.Type().ElementType(), &mem)
-		if err != nil {
-			return err
-		}
+		initializer := obj.buffer.toLLVMValue(obj.llvmGlobal.Type().ElementType(), &mem)
 		if checks && initializer.Type() != obj.llvmGlobal.Type().ElementType() {
 			panic("initializer type mismatch")
 		}
 		obj.llvmGlobal.SetInitializer(initializer)
 	}

-	// Finalize: remove the old init function and replace it with the new
-	// (.init.tmp) function.
-	r.builder.CreateRetVoid()
-	fnName := fn.Name()
-	fn.ReplaceAllUsesWith(newFn)
-	fn.EraseFromParentAsFunction()
-	newFn.SetName(fnName)
-
 	return nil
 }

@@ -279,19 +145,3 @@ func (r *runner) getFunction(llvmFn llvm.Value) *function {
 	r.functionCache[llvmFn] = fn
 	return fn
 }
-
-// markExternalLoad marks the given llvmValue as being loaded externally. This
-// is primarily used to mark package initializers that could not be run at
-// compile time. As an example, a package initialize might store to a global
-// variable. Another package initializer might read from the same global
-// variable. By marking this function as being run at runtime, that load
-// instruction will need to be run at runtime instead of at compile time.
-func (r *runner) markExternalLoad(llvmValue llvm.Value) {
-	mem := memoryView{r: r}
-	mem.markExternalLoad(llvmValue)
-	for index, obj := range mem.objects {
-		if obj.marked > r.objects[index].marked {
-			r.objects[index].marked = obj.marked
-		}
-	}
-}
@@ -13,11 +13,10 @@ import (
 func TestInterp(t *testing.T) {
 	for _, name := range []string{
 		"basic",
-		"phi",
 		"slice-copy",
 		"consteval",
+		"map",
 		"interface",
-		"revert",
 	} {
 		name := name // make tc local to this closure
 		t.Run(name, func(t *testing.T) {
@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"math"
 	"os"
-	"strconv"
 	"strings"
 	"time"

@@ -34,50 +33,6 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 	lastBB := -1 // last basic block is undefined, only defined after a branch
 	var operands []value
 	for instIndex := 0; instIndex < len(bb.instructions); instIndex++ {
-		if instIndex == 0 {
-			// This is the start of a new basic block.
-			// There may be PHI nodes that need to be resolved. Resolve all PHI
-			// nodes before continuing with regular instructions.
-			// PHI nodes need to be treated specially because they can have a
-			// mutual dependency:
-			//   for.loop:
-			//     %a = phi i8 [ 1, %entry ], [ %b, %for.loop ]
-			//     %b = phi i8 [ 3, %entry ], [ %a, %for.loop ]
-			// If these PHI nodes are processed like a regular instruction, %a
-			// and %b are both 3 on the second iteration of the loop because %b
-			// loads the value of %a from the second iteration, while it should
-			// load the value from the previous iteration. The correct behavior
-			// is that these two values swap each others place on each
-			// iteration.
-			var phiValues []value
-			var phiIndices []int
-			for _, inst := range bb.phiNodes {
-				var result value
-				for i := 0; i < len(inst.operands); i += 2 {
-					if int(inst.operands[i].(literalValue).value.(uint32)) == lastBB {
-						incoming := inst.operands[i+1]
-						if local, ok := incoming.(localValue); ok {
-							result = locals[fn.locals[local.value]]
-						} else {
-							result = incoming
-						}
-						break
-					}
-				}
-				if r.debug {
-					fmt.Fprintln(os.Stderr, indent+"phi", inst.operands, "->", result)
-				}
-				if result == nil {
-					panic("could not find PHI input")
-				}
-				phiValues = append(phiValues, result)
-				phiIndices = append(phiIndices, inst.localIndex)
-			}
-			for i, value := range phiValues {
-				locals[phiIndices[i]] = value
-			}
-		}
-
 		inst := bb.instructions[instIndex]
 		operands = operands[:0]
 		isRuntimeInst := false
@@ -148,24 +103,27 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 			default:
 				panic("unknown operands length")
 			}
-		case llvm.Switch:
-			// Switch statement: [value, defaultLabel, case0, label0, case1, label1, ...]
-			value := operands[0].Uint()
-			targetLabel := operands[1].Uint() // default label
-			// Do a lazy switch by iterating over all cases.
-			for i := 2; i < len(operands); i += 2 {
-				if value == operands[i].Uint() {
-					targetLabel = operands[i+1].Uint()
+			break // continue with next block
+		case llvm.PHI:
+			var result value
+			for i := 0; i < len(inst.operands); i += 2 {
+				if int(inst.operands[i].(literalValue).value.(uint32)) == lastBB {
+					incoming := inst.operands[i+1]
+					if local, ok := incoming.(localValue); ok {
+						result = locals[fn.locals[local.value]]
+					} else {
+						result = incoming
+					}
 					break
 				}
 			}
-			lastBB = currentBB
-			currentBB = int(targetLabel)
-			bb = fn.blocks[currentBB]
-			instIndex = -1 // start at 0 the next cycle
 			if r.debug {
-				fmt.Fprintln(os.Stderr, indent+"switch", operands, "->", currentBB)
+				fmt.Fprintln(os.Stderr, indent+"phi", inst.operands, "->", result)
 			}
+			if result == nil {
+				panic("could not find PHI input")
+			}
+			locals[inst.localIndex] = result
 		case llvm.Select:
 			// Select is much like a ternary operator: it picks a result from
 			// the second and third operand based on the boolean first operand.
@@ -197,17 +155,17 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				// which case this call won't even get to this point but will
 				// already be emitted in initAll.
 				continue
-			case strings.HasPrefix(callFn.name, "runtime.print") || callFn.name == "runtime._panic" || callFn.name == "runtime.hashmapGet" || callFn.name == "os.runtime_args":
+			case callFn.name == "(reflect.Type).Elem" || strings.HasPrefix(callFn.name, "runtime.print") || callFn.name == "runtime._panic" || callFn.name == "runtime.hashmapGet":
 				// These functions should be run at runtime. Specifically:
+				//   * (reflect.Type).Elem is a special function. It should
+				//     eventually be interpreted, but fall back to a runtime call
+				//     for now.
 				//   * Print and panic functions are best emitted directly without
 				//     interpreting them, otherwise we get a ton of putchar (etc.)
 				//     calls.
 				//   * runtime.hashmapGet tries to access the map value directly.
 				//     This is not possible as the map value is treated as a special
 				//     kind of object in this package.
-				//   * os.runtime_args reads globals that are initialized outside
-				//     the view of the interp package so it always needs to be run
-				//     at runtime.
 				err := r.runAtRuntime(fn, inst, locals, &mem, indent)
 				if err != nil {
 					return nil, mem, err
@@ -322,58 +280,26 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				copy(dstBuf.buf[dst.offset():dst.offset()+nBytes], srcBuf.buf[src.offset():])
 				dstObj.buffer = dstBuf
 				mem.put(dst.index(), dstObj)
-			case callFn.name == "(reflect.rawType).elem":
-				if r.debug {
-					fmt.Fprintln(os.Stderr, indent+"call (reflect.rawType).elem:", operands[1:])
-				}
-				// Extract the type code global from the first parameter.
-				typecodeIDPtrToInt, err := operands[1].toLLVMValue(inst.llvmInst.Operand(0).Type(), &mem)
-				if err != nil {
-					return nil, mem, r.errorAt(inst, err)
-				}
-				typecodeID := typecodeIDPtrToInt.Operand(0)
-
-				// Get the type class.
-				// See also: getClassAndValueFromTypeCode in transform/reflect.go.
-				typecodeName := typecodeID.Name()
-				const prefix = "reflect/types.type:"
-				if !strings.HasPrefix(typecodeName, prefix) {
-					panic("unexpected typecode name: " + typecodeName)
-				}
-				id := typecodeName[len(prefix):]
-				class := id[:strings.IndexByte(id, ':')]
-				value := id[len(class)+1:]
-				if class == "named" {
-					// Get the underlying type.
-					class = value[:strings.IndexByte(value, ':')]
-					value = value[len(class)+1:]
-				}
-
-				// Elem() is only valid for certain type classes.
-				switch class {
-				case "chan", "pointer", "slice", "array":
-					elementType := llvm.ConstExtractValue(typecodeID.Initializer(), []uint32{0})
-					uintptrType := r.mod.Context().IntType(int(mem.r.pointerSize) * 8)
-					locals[inst.localIndex] = r.getValue(llvm.ConstPtrToInt(elementType, uintptrType))
-				default:
-					return nil, mem, r.errorAt(inst, fmt.Errorf("(reflect.Type).Elem() called on %s type", class))
-				}
 			case callFn.name == "runtime.typeAssert":
 				// This function must be implemented manually as it is normally
 				// implemented by the interface lowering pass.
 				if r.debug {
 					fmt.Fprintln(os.Stderr, indent+"typeassert:", operands[1:])
 				}
-				assertedType, err := operands[2].toLLVMValue(inst.llvmInst.Operand(1).Type(), &mem)
+				typeInInterfacePtr, err := operands[1].asPointer(r)
 				if err != nil {
 					return nil, mem, r.errorAt(inst, err)
 				}
-				actualTypePtrToInt, err := operands[1].toLLVMValue(inst.llvmInst.Operand(0).Type(), &mem)
+				actualType, err := mem.load(typeInInterfacePtr, r.pointerSize).asPointer(r)
 				if err != nil {
 					return nil, mem, r.errorAt(inst, err)
 				}
-				actualType := actualTypePtrToInt.Operand(0)
-				if strings.TrimPrefix(actualType.Name(), "reflect/types.type:") == strings.TrimPrefix(assertedType.Name(), "reflect/types.typeid:") {
+				assertedType, err := operands[2].asPointer(r)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
+				}
+				result := assertedType.asRawValue(r).equal(actualType.asRawValue(r))
+				if result {
 					locals[inst.localIndex] = literalValue{uint8(1)}
 				} else {
 					locals[inst.localIndex] = literalValue{uint8(0)}
@@ -384,11 +310,11 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				}

 				// Load various values for the interface implements check below.
-				typecodePtr, err := operands[1].asPointer(r)
+				typeInInterfacePtr, err := operands[1].asPointer(r)
 				if err != nil {
 					return nil, mem, r.errorAt(inst, err)
 				}
-				methodSetPtr, err := mem.load(typecodePtr.addOffset(r.pointerSize*2), r.pointerSize).asPointer(r)
+				methodSetPtr, err := mem.load(typeInInterfacePtr.addOffset(r.pointerSize), r.pointerSize).asPointer(r)
 				if err != nil {
 					return nil, mem, r.errorAt(inst, err)
 				}
@@ -423,43 +349,74 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				}
 				// If assertOk is still 1, the assertion succeeded.
 				locals[inst.localIndex] = literalValue{assertOk}
-			case callFn.name == "runtime.interfaceMethod":
-				// This builtin returns the function (which may be a thunk) to
-				// invoke a method on an interface. It does not call the method.
-				if r.debug {
-					fmt.Fprintln(os.Stderr, indent+"interface method:", operands[1:])
+			case callFn.name == "runtime.hashmapMake":
+				// Create a new map.
+				hashmapPointerType := inst.llvmInst.Type()
+				keySize := uint32(operands[1].Uint())
+				valueSize := uint32(operands[2].Uint())
+				m := newMapValue(r, hashmapPointerType, keySize, valueSize)
+				alloc := object{
+					llvmType:   hashmapPointerType,
+					globalName: r.pkgName + "$map",
+					buffer:     m,
+					size:       m.len(r),
 				}
+				index := len(r.objects)
+				r.objects = append(r.objects, alloc)

-				// Load the first param, which is the type code (ptrtoint of the
-				// type code global).
-				typecodeIDPtrToInt, err := operands[1].toLLVMValue(inst.llvmInst.Operand(0).Type(), &mem)
+				// Create a pointer to this map. Maps are reference types, so
+				// are implemented as pointers.
+				ptr := newPointerValue(r, index, 0)
+				if r.debug {
+					fmt.Fprintln(os.Stderr, indent+"runtime.hashmapMake:", keySize, valueSize, "->", ptr)
+				}
+				locals[inst.localIndex] = ptr
+			case callFn.name == "runtime.hashmapBinarySet":
+				// Do a mapassign operation with a binary key (that is, without
+				// a string key).
+				if r.debug {
+					fmt.Fprintln(os.Stderr, indent+"runtime.hashmapBinarySet:", operands[1:])
+				}
+				mapPtr, err := operands[1].asPointer(r)
 				if err != nil {
 					return nil, mem, r.errorAt(inst, err)
 				}
-				typecodeID := typecodeIDPtrToInt.Operand(0).Initializer()
-
-				// Load the method set, which is part of the typecodeID object.
-				methodSet := llvm.ConstExtractValue(typecodeID, []uint32{2}).Operand(0).Initializer()
-
-				// We don't need to load the interface method set.
-
-				// Load the signature of the to-be-called function.
-				signature := inst.llvmInst.Operand(2)
-
-				// Iterate through all methods, looking for the one method that
-				// should be returned.
-				numMethods := methodSet.Type().ArrayLength()
-				var method llvm.Value
-				for i := 0; i < numMethods; i++ {
-					methodSignature := llvm.ConstExtractValue(methodSet, []uint32{uint32(i), 0})
-					if methodSignature == signature {
-						method = llvm.ConstExtractValue(methodSet, []uint32{uint32(i), 1}).Operand(0)
-					}
+				m := mem.getWritable(mapPtr.index()).buffer.(*mapValue)
+				keyPtr, err := operands[2].asPointer(r)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
 				}
-				if method.IsNil() {
-					return nil, mem, r.errorAt(inst, errors.New("could not find method: "+signature.Name()))
+				valuePtr, err := operands[3].asPointer(r)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
+				}
+				err = m.putBinary(&mem, keyPtr, valuePtr)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
+				}
+			case callFn.name == "runtime.hashmapStringSet":
+				// Do a mapassign operation with a string key.
+				if r.debug {
+					fmt.Fprintln(os.Stderr, indent+"runtime.hashmapBinarySet:", operands[1:])
+				}
+				mapPtr, err := operands[1].asPointer(r)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
+				}
+				m := mem.getWritable(mapPtr.index()).buffer.(*mapValue)
+				stringPtr, err := operands[2].asPointer(r)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
+				}
+				stringLen := operands[3].Uint()
+				valuePtr, err := operands[4].asPointer(r)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
+				}
+				err = m.putString(&mem, stringPtr, stringLen, valuePtr)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
 				}
-				locals[inst.localIndex] = r.getValue(method)
 			default:
 				if len(callFn.blocks) == 0 {
 					// Call to a function declaration without a definition
@@ -525,13 +482,6 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				continue
 			}
 			result := mem.load(ptr, uint32(size))
-			if result == nil {
-				err := r.runAtRuntime(fn, inst, locals, &mem, indent)
-				if err != nil {
-					return nil, mem, err
-				}
-				continue
-			}
 			if r.debug {
 				fmt.Fprintln(os.Stderr, indent+"load:", ptr, "->", result)
 			}
@@ -554,14 +504,7 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 			if r.debug {
 				fmt.Fprintln(os.Stderr, indent+"store:", val, ptr)
 			}
-			ok := mem.store(val, ptr)
-			if !ok {
-				// Could not store the value, do it at runtime.
-				err := r.runAtRuntime(fn, inst, locals, &mem, indent)
-				if err != nil {
-					return nil, mem, err
-				}
-			}
+			mem.store(val, ptr)
 		case llvm.Alloca:
 			// Alloca normally allocates some stack memory. In the interpreter,
 			// it allocates a global instead.
@@ -590,14 +533,18 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 			// GetElementPtr does pointer arithmetic, changing the offset of the
 			// pointer into the underlying object.
 			var offset uint64
+			var gepOperands []uint64
 			for i := 2; i < len(operands); i += 2 {
 				index := operands[i].Uint()
 				elementSize := operands[i+1].Uint()
 				if int64(elementSize) < 0 {
 					// This is a struct field.
+					// The field number is encoded by flipping all the bits.
+					gepOperands = append(gepOperands, ^elementSize)
 					offset += index
 				} else {
 					// This is a normal GEP, probably an array index.
+					gepOperands = append(gepOperands, index)
 					offset += elementSize * index
 				}
 			}
@@ -889,11 +836,7 @@ func (r *runner) runAtRuntime(fn *function, inst instruction, locals []value, me
 	for i := 0; i < numOperands; i++ {
 		operand := inst.llvmInst.Operand(i)
 		if !operand.IsAInstruction().IsNil() || !operand.IsAArgument().IsNil() {
-			var err error
-			operand, err = locals[fn.locals[operand]].toLLVMValue(operand.Type(), mem)
-			if err != nil {
-				return r.errorAt(inst, err)
-			}
+			operand = locals[fn.locals[operand]].toLLVMValue(operand.Type(), mem)
 		}
 		operands[i] = operand
 	}
@@ -927,31 +870,16 @@ func (r *runner) runAtRuntime(fn *function, inst instruction, locals []value, me
 		result = r.builder.CreateBitCast(operands[0], inst.llvmInst.Type(), inst.name)
 	case llvm.ExtractValue:
 		indices := inst.llvmInst.Indices()
-		// Note: the Go LLVM API doesn't support multiple indices, so simulate
-		// this operation with some extra extractvalue instructions. Hopefully
-		// this is optimized to a single instruction.
-		agg := operands[0]
-		for i := 0; i < len(indices)-1; i++ {
-			agg = r.builder.CreateExtractValue(agg, int(indices[i]), inst.name+".agg")
+		if len(indices) != 1 {
+			panic("expected exactly one index")
 		}
-		result = r.builder.CreateExtractValue(agg, int(indices[len(indices)-1]), inst.name)
+		result = r.builder.CreateExtractValue(operands[0], int(indices[0]), inst.name)
 	case llvm.InsertValue:
 		indices := inst.llvmInst.Indices()
-		// Similar to extractvalue, we're working around a limitation in the Go
-		// LLVM API here by splitting the insertvalue into multiple instructions
-		// if there is more than one operand.
-		agg := operands[0]
-		aggregates := []llvm.Value{agg}
-		for i := 0; i < len(indices)-1; i++ {
-			agg = r.builder.CreateExtractValue(agg, int(indices[i]), inst.name+".agg"+strconv.Itoa(i))
-			aggregates = append(aggregates, agg)
+		if len(indices) != 1 {
+			panic("expected exactly one index")
 		}
-		result = operands[1]
-		for i := len(indices) - 1; i >= 0; i-- {
-			agg := aggregates[i]
-			result = r.builder.CreateInsertValue(agg, result, int(indices[i]), inst.name+".insertvalue"+strconv.Itoa(i))
-		}
-
+		result = r.builder.CreateInsertValue(operands[0], operands[1], int(indices[0]), inst.name)
 	case llvm.Add:
 		result = r.builder.CreateAdd(operands[0], operands[1], inst.name)
 	case llvm.Sub:
@@ -178,9 +178,6 @@ func (mv *memoryView) markExternal(llvmValue llvm.Value, mark uint8) {
 		default:
 			panic("interp: unknown constant expression")
 		}
-	} else if !llvmValue.IsAInlineAsm().IsNil() {
-		// Inline assembly can modify globals but only exported globals. Let's
-		// hope the author knows what they're doing.
 	} else {
 		llvmType := llvmValue.Type()
 		switch llvmType.TypeKind() {
@@ -262,17 +259,12 @@ func (mv *memoryView) put(index uint32, obj object) {
 	mv.objects[index] = obj
 }

-// Load the value behind the given pointer. Returns nil if the pointer points to
-// an external global.
+// Load the value behind the given pointer.
 func (mv *memoryView) load(p pointerValue, size uint32) value {
 	if checks && mv.hasExternalStore(p) {
 		panic("interp: load from object with external store")
 	}
 	obj := mv.get(p.index())
-	if obj.buffer == nil {
-		// External global, return nil.
-		return nil
-	}
 	if p.offset() == 0 && size == obj.size {
 		return obj.buffer.clone()
 	}
@@ -288,17 +280,12 @@ func (mv *memoryView) load(p pointerValue, size uint32) value {

 // Store to the value behind the given pointer. This overwrites the value in the
 // memory view, so that the changed value is discarded when the memory view is
-// reverted. Returns true on success, false if the object to store to is
-// external.
-func (mv *memoryView) store(v value, p pointerValue) bool {
+// reverted.
+func (mv *memoryView) store(v value, p pointerValue) {
 	if checks && mv.hasExternalLoadOrStore(p) {
 		panic("interp: store to object with external load/store")
 	}
 	obj := mv.get(p.index())
-	if obj.buffer == nil {
-		// External global, return false (for a failure).
-		return false
-	}
 	if checks && p.offset()+v.len(mv.r) > obj.size {
 		panic("interp: store out of bounds")
 	}
@@ -314,7 +301,6 @@ func (mv *memoryView) store(v value, p pointerValue) bool {
 		}
 	}
 	mv.put(p.index(), obj)
-	return true // success
 }

 // value is some sort of value, comparable to a LLVM constant. It can be
@@ -328,7 +314,7 @@ type value interface {
 	asRawValue(*runner) rawValue
 	Uint() uint64
 	Int() int64
-	toLLVMValue(llvm.Type, *memoryView) (llvm.Value, error)
+	toLLVMValue(llvm.Type, *memoryView) llvm.Value
 	String() string
 }

@@ -419,25 +405,25 @@ func (v literalValue) Int() int64 {
 	}
 }

-func (v literalValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Value, error) {
+func (v literalValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) llvm.Value {
 	switch llvmType.TypeKind() {
 	case llvm.IntegerTypeKind:
 		switch value := v.value.(type) {
 		case uint64:
-			return llvm.ConstInt(llvmType, value, false), nil
+			return llvm.ConstInt(llvmType, value, false)
 		case uint32:
-			return llvm.ConstInt(llvmType, uint64(value), false), nil
+			return llvm.ConstInt(llvmType, uint64(value), false)
 		case uint16:
-			return llvm.ConstInt(llvmType, uint64(value), false), nil
+			return llvm.ConstInt(llvmType, uint64(value), false)
 		case uint8:
-			return llvm.ConstInt(llvmType, uint64(value), false), nil
+			return llvm.ConstInt(llvmType, uint64(value), false)
 		default:
-			return llvm.Value{}, errors.New("interp: unknown literal type")
+			panic("inpterp: unknown literal type")
 		}
 	case llvm.DoubleTypeKind:
-		return llvm.ConstFloat(llvmType, math.Float64frombits(v.value.(uint64))), nil
+		return llvm.ConstFloat(llvmType, math.Float64frombits(v.value.(uint64)))
 	case llvm.FloatTypeKind:
-		return llvm.ConstFloat(llvmType, float64(math.Float32frombits(v.value.(uint32)))), nil
+		return llvm.ConstFloat(llvmType, float64(math.Float32frombits(v.value.(uint32))))
 	default:
 		return v.asRawValue(mem.r).toLLVMValue(llvmType, mem)
 	}
@@ -521,7 +507,7 @@ func (v pointerValue) llvmValue(mem *memoryView) llvm.Value {
 // toLLVMValue returns the LLVM value for this pointer, which may be a GEP or
 // bitcast. The llvm.Type parameter is optional, if omitted the pointer type may
 // be different than expected.
-func (v pointerValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Value, error) {
+func (v pointerValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) llvm.Value {
 	// Obtain the llvmValue, creating it if it doesn't exist yet.
 	llvmValue := v.llvmValue(mem)
 	if llvmValue.IsNil() {
@@ -532,10 +518,7 @@ func (v pointerValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Val
 		if obj.llvmType.IsNil() {
 			// Create an initializer without knowing the global type.
 			// This is probably the result of a runtime.alloc call.
-			initializer, err := obj.buffer.asRawValue(mem.r).rawLLVMValue(mem)
-			if err != nil {
-				return llvm.Value{}, err
-			}
+			initializer := obj.buffer.asRawValue(mem.r).rawLLVMValue(mem)
 			globalType := initializer.Type()
 			llvmValue = llvm.AddGlobal(mem.r.mod, globalType, obj.globalName)
 			llvmValue.SetInitializer(initializer)
@@ -554,12 +537,9 @@ func (v pointerValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Val
 			// Set the initializer for the global. Do this after creation to avoid
 			// infinite recursion between creating the global and creating the
 			// contents of the global (if the global contains itself).
-			initializer, err := obj.buffer.toLLVMValue(globalType, mem)
-			if err != nil {
-				return llvm.Value{}, err
-			}
+			initializer := obj.buffer.toLLVMValue(globalType, mem)
 			if checks && initializer.Type() != globalType {
-				return llvm.Value{}, errors.New("interp: allocated value does not match allocated type")
+				panic("allocated value does not match allocated type")
 			}
 			llvmValue.SetInitializer(initializer)
 		}
@@ -572,18 +552,7 @@ func (v pointerValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Val
 	}

 	if llvmType.IsNil() {
-		if v.offset() != 0 {
-			// If there is an offset, make sure to use a GEP to index into the
-			// pointer. Because there is no expected type, we use whatever is
-			// most convenient: an *i8 type. It is trivial to index byte-wise.
-			if llvmValue.Type() != mem.r.i8ptrType {
-				llvmValue = llvm.ConstBitCast(llvmValue, mem.r.i8ptrType)
-			}
-			llvmValue = llvm.ConstInBoundsGEP(llvmValue, []llvm.Value{
-				llvm.ConstInt(llvmValue.Type().Context().Int32Type(), uint64(v.offset()), false),
-			})
-		}
-		return llvmValue, nil
+		return llvmValue
 	}

 	if llvmType.TypeKind() != llvm.PointerTypeKind {
@@ -595,7 +564,7 @@ func (v pointerValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Val
 		// This can be worked around by simply converting to a raw value,
 		// rawValue knows how to create such structs.
 		if v.offset() != 0 {
-			return llvm.Value{}, errors.New("interp: offset set without known pointer type")
+			panic("offset set without known pointer type")
 		}
 		return v.asRawValue(mem.r).toLLVMValue(llvmType, mem)
 	}
@@ -606,14 +575,14 @@ func (v pointerValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Val
 		if v.offset() != 0 {
 			// This should never happen, if offset is non-zero, the types
 			// shouldn't match.
-			return llvm.Value{}, errors.New("interp: offset set while there is no way to convert the type")
+			panic("offset set while there is no way to convert the type")
 		}
-		return llvmValue, nil
+		return llvmValue
 	}

 	if v.offset() == 0 {
 		// Offset is zero, so we can just bitcast to get a correct pointer.
-		return llvm.ConstBitCast(llvmValue, llvmType), nil
+		return llvm.ConstBitCast(llvmValue, llvmType)
 	}

 	// We need to make a constant GEP for pointer arithmetic.
@@ -637,11 +606,11 @@ func (v pointerValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Val
 			offset -= int64(mem.r.targetData.ElementOffset(objectElementType, element))
 			objectElementType = objectElementType.StructElementTypes()[element]
 		default:
-			return llvm.Value{}, errors.New("interp: pointer index with something other than a struct or array?")
+			panic("pointer index with something other than a struct or array?")
 		}
 	}
 	if offset < 0 {
-		return llvm.Value{}, errors.New("interp: offset has somehow gone negative, this should be impossible")
+		panic("offset has somehow gone negative, this should be impossible")
 	}

 	// Finally do the gep, using the above computed indices.
@@ -649,9 +618,283 @@ func (v pointerValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Val
 	// the bits of the pointer are now correct, just not the type).
 	gep := llvm.ConstInBoundsGEP(llvmValue, indices)
 	if gep.Type() != llvmType {
-		return llvm.ConstBitCast(gep, llvmType), nil
+		return llvm.ConstBitCast(gep, llvmType)
 	}
-	return gep, nil
+	return gep
+}
+
+// mapValue implements a Go map which is created at compile time and stored as a
+// global variable.
+// The value itself is only used as part of an object (object.buffer). Maps are
+// reference types aka pointers, so it can only be used as a pointerValue, not
+// directly.
+type mapValue struct {
+	r           *runner
+	pkgName     string
+	size        uint32 // byte size of runtime.hashmap
+	hashmap     llvm.Value
+	keyIsString bool
+	keys        []interface{} // either rawValue (for binary key) or mapStringKey (for string key)
+	values      []rawValue
+	keySize     uint32
+	valueSize   uint32
+}
+
+type mapStringKey struct {
+	buf  pointerValue
+	size uint64
+	data []uint64
+}
+
+func newMapValue(r *runner, hashmapPointerType llvm.Type, keySize, valueSize uint32) *mapValue {
+	size := uint32(r.targetData.TypeAllocSize(hashmapPointerType.ElementType()))
+	return &mapValue{
+		r:         r,
+		pkgName:   r.pkgName,
+		size:      size,
+		keySize:   keySize,
+		valueSize: valueSize,
+	}
+}
+
+func (v *mapValue) len(r *runner) uint32 {
+	return v.size
+}
+
+func (v *mapValue) clone() value {
+	// Return a copy of mapValue.
+	clone := *v
+	clone.keys = append([]interface{}{}, clone.keys...)
+	clone.values = append([]rawValue{}, clone.values...)
+	return &clone
+}
+
+func (v *mapValue) asPointer(r *runner) (pointerValue, error) {
+	panic("interp: mapValue.asPointer")
+}
+
+func (v *mapValue) asRawValue(r *runner) rawValue {
+	panic("interp: mapValue.asRawValue")
+}
+
+func (v *mapValue) Uint() uint64 {
+	panic("interp: mapValue.Uint")
+}
+
+func (v *mapValue) Int() int64 {
+	panic("interp: mapValue.Int")
+}
+
+// Temporary struct to collect data before turning this into a hashmap bucket
+// LLVM value.
+type mapBucket struct {
+	m       *mapValue
+	tophash [8]uint8
+	keys    []rawValue // can have up to 8 keys
+	values  []rawValue // can have up to 8 values, len(keys) == len(values)
+}
+
+// create returns a (pointer to a) buffer structurally equivalent to
+// runtime.hashmapBucket.
+func (b *mapBucket) create(ctx llvm.Context, nextBucket llvm.Value, mem *memoryView) llvm.Value {
+	// Create tophash array.
+	int8Type := ctx.Int8Type()
+	tophashValues := make([]llvm.Value, 8)
+	for i := range tophashValues {
+		tophashValues[i] = llvm.ConstInt(int8Type, uint64(b.tophash[i]), false)
+	}
+	tophash := llvm.ConstArray(int8Type, tophashValues)
+
+	// Create next pointer (if not set).
+	if nextBucket.IsNil() {
+		nextBucket = llvm.ConstNull(llvm.PointerType(int8Type, 0))
+	}
+
+	// Create data for keys.
+	var keyValues []llvm.Value
+	for _, key := range b.keys {
+		keyValues = append(keyValues, key.rawLLVMValue(mem))
+	}
+	if len(b.keys) < 8 {
+		keyValues = append(keyValues, llvm.ConstNull(llvm.ArrayType(int8Type, int(b.m.keySize)*(8-len(b.keys)))))
+	}
+	keyValue := ctx.ConstStruct(keyValues, false)
+	if checks && uint32(b.m.r.targetData.TypeAllocSize(keyValue.Type())) != b.m.keySize*8 {
+		panic("key size invalid")
+	}
+
+	// Create data for values.
+	var valueValues []llvm.Value
+	for _, value := range b.values {
+		valueValues = append(valueValues, value.rawLLVMValue(mem))
+	}
+	if len(b.values) < 8 {
+		valueValues = append(valueValues, llvm.ConstNull(llvm.ArrayType(int8Type, int(b.m.valueSize)*(8-len(b.values)))))
+	}
+	valueValue := ctx.ConstStruct(valueValues, false)
+	if checks && uint32(b.m.r.targetData.TypeAllocSize(valueValue.Type())) != b.m.valueSize*8 {
+		panic("value size invalid")
+	}
+
+	// Create the bucket.
+	bucketInitializer := ctx.ConstStruct([]llvm.Value{
+		tophash,
+		nextBucket,
+		keyValue,
+		valueValue,
+	}, false)
+	bucket := llvm.AddGlobal(b.m.r.mod, bucketInitializer.Type(), b.m.pkgName+"$mapbucket")
+	bucket.SetInitializer(bucketInitializer)
+	bucket.SetLinkage(llvm.InternalLinkage)
+	bucket.SetUnnamedAddr(true)
+	return bucket
+}
+
+func (v *mapValue) toLLVMValue(hashmapType llvm.Type, mem *memoryView) llvm.Value {
+	if !v.hashmap.IsNil() {
+		return v.hashmap
+	}
+
+	// Create a slice of buckets with all the keys and values in the hashmap.
+	var buckets []*mapBucket
+	var bucket *mapBucket
+	for i, key := range v.keys {
+		var data []uint64
+		var keyValue rawValue
+		switch key := key.(type) {
+		case mapStringKey:
+			data = key.data
+			keyValue = newRawValue(v.keySize)
+			// runtime._string is {ptr, length}
+			for i := uint32(0); i < v.keySize/2; i++ {
+				keyValue.buf[i] = key.buf.pointer
+			}
+			copy(keyValue.buf[v.keySize/2:], literalValue{key.size}.asRawValue(v.r).buf)
+		case rawValue:
+			if key.hasPointer() {
+				panic("todo: map key with pointer")
+			}
+			data = key.buf
+			keyValue = key
+		default:
+			panic("unknown map key type")
+		}
+		buf := make([]byte, len(data))
+		for i, p := range data {
+			buf[i] = byte(p)
+		}
+		hash := v.hash(buf)
+
+		if i%8 == 0 {
+			bucket = &mapBucket{m: v}
+			buckets = append(buckets, bucket)
+		}
+		bucket.tophash[i%8] = v.topHash(hash)
+		bucket.keys = append(bucket.keys, keyValue)
+		bucket.values = append(bucket.values, v.values[i])
+	}
+
+	// Convert these buckets into LLVM global variables.
+	ctx := v.r.mod.Context()
+	var nextBucket llvm.Value
+	for i := len(buckets) - 1; i >= 0; i-- {
+		bucket = buckets[i]
+		bucketValue := bucket.create(ctx, nextBucket, mem)
+		nextBucket = bucketValue
+	}
+	firstBucket := nextBucket
+	if firstBucket.IsNil() {
+		firstBucket = llvm.ConstNull(mem.r.i8ptrType)
+	} else {
+		firstBucket = llvm.ConstBitCast(firstBucket, mem.r.i8ptrType)
+	}
+
+	// Create the hashmap itself, pointing to these buckets.
+	hashmapPointerType := llvm.PointerType(hashmapType, 0)
+	hashmap := llvm.ConstNamedStruct(hashmapType, []llvm.Value{
+		llvm.ConstPointerNull(hashmapPointerType), // next
+		firstBucket, // buckets
+		llvm.ConstInt(hashmapType.StructElementTypes()[2], uint64(len(v.keys)), false), // count
+		llvm.ConstInt(ctx.Int8Type(), uint64(v.keySize), false),                        // keySize
+		llvm.ConstInt(ctx.Int8Type(), uint64(v.valueSize), false),                      // valueSize
+		llvm.ConstInt(ctx.Int8Type(), 0, false),                                        // bucketBits
+	})
+
+	v.hashmap = hashmap
+	return v.hashmap
+}
+
+// putString does a map assign operation, assuming that the map is of type
+// map[string]T.
+func (v *mapValue) putString(mem *memoryView, stringBuf pointerValue, stringLen uint64, valuePtr pointerValue) error {
+	if !v.hashmap.IsNil() {
+		return errMapAlreadyCreated
+	}
+
+	value := mem.load(valuePtr, v.valueSize)
+	stringValue := mem.load(stringBuf, uint32(stringLen)).asRawValue(v.r)
+	if stringValue.hasPointer() {
+		panic("interp: string contains pointer")
+	}
+
+	// TODO: avoid duplicate keys
+	v.keys = append(v.keys, mapStringKey{stringBuf, stringLen, stringValue.buf})
+	v.values = append(v.values, value.asRawValue(v.r))
+	v.keyIsString = true
+
+	return nil
+}
+
+// putBinary does a map assign operation for binary data (e.g. [3]int etc). The
+// key must not contain pointer values.
+func (v *mapValue) putBinary(mem *memoryView, keyPtr, valuePtr pointerValue) error {
+	if !v.hashmap.IsNil() {
+		return errMapAlreadyCreated
+	}
+
+	key := mem.load(keyPtr, v.keySize)
+	value := mem.load(valuePtr, v.valueSize)
+
+	// Sanity checks.
+	if v.keySize != key.len(mem.r) || v.valueSize != value.len(mem.r) {
+		// This is a bug (not unhandled input), so panic.
+		panic("interp: key or value size mismatch")
+	}
+	if v.keyIsString {
+		panic("cannot put binary keys in string map")
+	}
+
+	// TODO: avoid duplicate keys
+	v.keys = append(v.keys, key.asRawValue(v.r))
+	v.values = append(v.values, value.asRawValue(v.r))
+
+	return nil
+}
+
+// Get FNV-1a hash of this string.
+//
+// https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function#FNV-1a_hash
+func (v *mapValue) hash(data []byte) uint32 {
+	var result uint32 = 2166136261 // FNV offset basis
+	for _, c := range data {
+		result ^= uint32(c)
+		result *= 16777619 // FNV prime
+	}
+	return result
+}
+
+// Get the topmost 8 bits of the hash, without using a special value (like 0).
+func (v *mapValue) topHash(hash uint32) uint8 {
+	tophash := uint8(hash >> 24)
+	if tophash < 1 {
+		// 0 means empty slot, so make it bigger.
+		tophash++
+	}
+	return tophash
+}
+
+func (v *mapValue) String() string {
+	return "<map keySize=" + strconv.Itoa(int(v.keySize)) + " valueSize=" + strconv.Itoa(int(v.valueSize)) + ">"
 }

 // rawValue is a raw memory buffer that can store either pointers or regular
@@ -775,7 +1018,7 @@ func (v rawValue) equal(rhs rawValue) bool {
 // goes. The resulting value does not have a specified type, but it will be the
 // same size and have the same bytes if it was created with a provided LLVM type
 // (through toLLVMValue).
-func (v rawValue) rawLLVMValue(mem *memoryView) (llvm.Value, error) {
+func (v rawValue) rawLLVMValue(mem *memoryView) llvm.Value {
 	var structFields []llvm.Value
 	ctx := mem.r.mod.Context()
 	int8Type := ctx.Int8Type()
@@ -799,16 +1042,13 @@ func (v rawValue) rawLLVMValue(mem *memoryView) (llvm.Value, error) {
 	for i := uint32(0); i < uint32(len(v.buf)); {
 		if v.buf[i] > 255 {
 			addBytes()
-			field, err := pointerValue{v.buf[i]}.toLLVMValue(llvm.Type{}, mem)
-			if err != nil {
-				return llvm.Value{}, err
-			}
+			field := pointerValue{v.buf[i]}.toLLVMValue(llvm.Type{}, mem)
 			elementType := field.Type().ElementType()
 			if elementType.TypeKind() == llvm.StructTypeKind {
 				// There are some special pointer types that should be used as a
 				// ptrtoint, so that they can be used in certain optimizations.
 				name := elementType.StructName()
-				if name == "runtime.typecodeID" || name == "runtime.funcValueWithSignature" {
+				if name == "runtime.typeInInterface" || name == "runtime.funcValueWithSignature" {
 					uintptrType := ctx.IntType(int(mem.r.pointerSize) * 8)
 					field = llvm.ConstPtrToInt(field, uintptrType)
 				}
@@ -825,12 +1065,12 @@ func (v rawValue) rawLLVMValue(mem *memoryView) (llvm.Value, error) {

 	// Return the created data.
 	if len(structFields) == 1 {
-		return structFields[0], nil
+		return structFields[0]
 	}
-	return ctx.ConstStruct(structFields, false), nil
+	return ctx.ConstStruct(structFields, false)
 }

-func (v rawValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Value, error) {
+func (v rawValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) llvm.Value {
 	isZero := true
 	for _, p := range v.buf {
 		if p != 0 {
@@ -839,7 +1079,7 @@ func (v rawValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Value,
 		}
 	}
 	if isZero {
-		return llvm.ConstNull(llvmType), nil
+		return llvm.ConstNull(llvmType)
 	}
 	switch llvmType.TypeKind() {
 	case llvm.IntegerTypeKind:
@@ -848,17 +1088,7 @@ func (v rawValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Value,
 			if err != nil {
 				panic(err)
 			}
-			if checks && mem.r.targetData.TypeAllocSize(llvmType) != mem.r.targetData.TypeAllocSize(mem.r.i8ptrType) {
-				// Probably trying to serialize a pointer to a byte array,
-				// perhaps as a result of rawLLVMValue() in a previous interp
-				// run.
-				return llvm.Value{}, errInvalidPtrToIntSize
-			}
-			v, err := ptr.toLLVMValue(llvm.Type{}, mem)
-			if err != nil {
-				return llvm.Value{}, err
-			}
-			return llvm.ConstPtrToInt(v, llvmType), nil
+			return llvm.ConstPtrToInt(ptr.toLLVMValue(llvm.Type{}, mem), llvmType)
 		}
 		var n uint64
 		switch llvmType.IntTypeWidth() {
@@ -878,7 +1108,7 @@ func (v rawValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Value,
 		default:
 			panic("unknown integer size")
 		}
-		return llvm.ConstInt(llvmType, n, false), nil
+		return llvm.ConstInt(llvmType, n, false)
 	case llvm.StructTypeKind:
 		fieldTypes := llvmType.StructElementTypes()
 		fields := make([]llvm.Value, len(fieldTypes))
@@ -887,16 +1117,12 @@ func (v rawValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Value,
 			field := rawValue{
 				buf: v.buf[offset:],
 			}
-			var err error
-			fields[i], err = field.toLLVMValue(fieldType, mem)
-			if err != nil {
-				return llvm.Value{}, err
-			}
+			fields[i] = field.toLLVMValue(fieldType, mem)
 		}
 		if llvmType.StructName() != "" {
-			return llvm.ConstNamedStruct(llvmType, fields), nil
+			return llvm.ConstNamedStruct(llvmType, fields)
 		}
-		return llvmType.Context().ConstStruct(fields, false), nil
+		return llvmType.Context().ConstStruct(fields, false)
 	case llvm.ArrayTypeKind:
 		numElements := llvmType.ArrayLength()
 		childType := llvmType.ElementType()
@@ -907,34 +1133,27 @@ func (v rawValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Value,
 			field := rawValue{
 				buf: v.buf[offset:],
 			}
-			var err error
-			fields[i], err = field.toLLVMValue(childType, mem)
-			if err != nil {
-				return llvm.Value{}, err
-			}
+			fields[i] = field.toLLVMValue(childType, mem)
 			if checks && fields[i].Type() != childType {
 				panic("child type doesn't match")
 			}
 		}
-		return llvm.ConstArray(childType, fields), nil
+		return llvm.ConstArray(childType, fields)
 	case llvm.PointerTypeKind:
 		if v.buf[0] > 255 {
 			// This is a regular pointer.
-			llvmValue, err := pointerValue{v.buf[0]}.toLLVMValue(llvm.Type{}, mem)
-			if err != nil {
-				return llvm.Value{}, err
-			}
+			llvmValue := pointerValue{v.buf[0]}.toLLVMValue(llvm.Type{}, mem)
 			if llvmValue.Type() != llvmType {
 				llvmValue = llvm.ConstBitCast(llvmValue, llvmType)
 			}
-			return llvmValue, nil
+			return llvmValue
 		}
 		// This is either a null pointer or a raw pointer for memory-mapped I/O
 		// (such as 0xe000ed00).
 		ptr := rawValue{v.buf[:mem.r.pointerSize]}.Uint()
 		if ptr == 0 {
 			// Null pointer.
-			return llvm.ConstNull(llvmType), nil
+			return llvm.ConstNull(llvmType)
 		}
 		var ptrValue llvm.Value // the underlying int
 		switch mem.r.pointerSize {
@@ -945,19 +1164,19 @@ func (v rawValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Value,
 		case 2:
 			ptrValue = llvm.ConstInt(llvmType.Context().Int16Type(), ptr, false)
 		default:
-			return llvm.Value{}, errors.New("interp: unknown pointer size")
+			panic("unknown pointer size")
 		}
-		return llvm.ConstIntToPtr(ptrValue, llvmType), nil
+		return llvm.ConstIntToPtr(ptrValue, llvmType)
 	case llvm.DoubleTypeKind:
 		b := rawValue{v.buf[:8]}.Uint()
 		f := math.Float64frombits(b)
-		return llvm.ConstFloat(llvmType, f), nil
+		return llvm.ConstFloat(llvmType, f)
 	case llvm.FloatTypeKind:
 		b := uint32(rawValue{v.buf[:4]}.Uint())
 		f := math.Float32frombits(b)
-		return llvm.ConstFloat(llvmType, float64(f)), nil
+		return llvm.ConstFloat(llvmType, float64(f))
 	default:
-		return llvm.Value{}, errors.New("interp: todo: raw value to LLVM value: " + llvmType.String())
+		panic("todo: raw value to LLVM value: " + llvmType.String())
 	}
 }

@@ -1146,8 +1365,8 @@ func (v localValue) Int() int64 {
 	panic("interp: localValue.Int")
 }

-func (v localValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Value, error) {
-	return v.value, nil
+func (v localValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) llvm.Value {
+	return v.value
 }

 func (r *runner) getValue(llvmValue llvm.Value) value {
@@ -8,7 +8,6 @@ target triple = "x86_64--linux"
@main.exportedValue = global [1 x i16*] [i16* @main.exposedValue1]
@main.exposedValue1 = global i16 0
@main.exposedValue2 = global i16 0
-@main.insertedValue = global {i8, i32, {float, {i64, i16}}} zeroinitializer

 declare void @runtime.printint64(i64) unnamed_addr

@@ -66,22 +65,6 @@ entry:
  call void @modifyExternal(i32* bitcast (void ()* @willModifyGlobal to i32*))
  store i16 7, i16* @main.exposedValue2

-  ; Test that inline assembly is ignored.
-  call void @modifyExternal(i32* bitcast (void ()* @hasInlineAsm to i32*))
-
-  ; Test switch statement.
-  %switch1 = call i64 @testSwitch(i64 1) ; 1 returns 6
-  %switch2 = call i64 @testSwitch(i64 9) ; 9 returns the default value -1
-  call void @runtime.printint64(i64 %switch1)
-  call void @runtime.printint64(i64 %switch2)
-
-  ; Test extractvalue/insertvalue with multiple operands.
-  %agg = call {i8, i32, {float, {i64, i16}}} @nestedStruct()
-  %elt = extractvalue {i8, i32, {float, {i64, i16}}} %agg, 2, 1, 0
-  call void @runtime.printint64(i64 %elt)
-  %agg2 = insertvalue {i8, i32, {float, {i64, i16}}} %agg, i64 5, 2, 1, 0
-  store {i8, i32, {float, {i64, i16}}} %agg2, {i8, i32, {float, {i64, i16}}}* @main.insertedValue
-
  ret void
 }

@@ -104,33 +87,3 @@ entry:
  store i16 8, i16* @main.exposedValue2
  ret void
 }
-
-; Inline assembly should be ignored in the interp package. While it is possible
-; to modify other globals that way, usually that's not the case and there is no
-; real way to check.
-define void @hasInlineAsm() {
-entry:
-  call void asm sideeffect "", ""()
-  ret void
-}
-
-define i64 @testSwitch(i64 %val) {
-entry:
-  ; Test switch statement.
-  switch i64 %val, label %otherwise [ i64 0, label %zero
-                                      i64 1, label %one
-                                      i64 2, label %two ]
-zero:
-  ret i64 5
-
-one:
-  ret i64 6
-
-two:
-  ret i64 7
-
-otherwise:
-  ret i64 -1
-}
-
-declare {i8, i32, {float, {i64, i16}}} @nestedStruct()
@@ -7,7 +7,6 @@ target triple = "x86_64--linux"
@main.exportedValue = global [1 x i16*] [i16* @main.exposedValue1]
@main.exposedValue1 = global i16 0
@main.exposedValue2 = local_unnamed_addr global i16 0
-@main.insertedValue = local_unnamed_addr global { i8, i32, { float, { i64, i16 } } } zeroinitializer

 declare void @runtime.printint64(i64) unnamed_addr

@@ -26,20 +25,6 @@ entry:
  store i16 5, i16* @main.exposedValue1
  call void @modifyExternal(i32* bitcast (void ()* @willModifyGlobal to i32*))
  store i16 7, i16* @main.exposedValue2
-  call void @modifyExternal(i32* bitcast (void ()* @hasInlineAsm to i32*))
-  call void @runtime.printint64(i64 6)
-  call void @runtime.printint64(i64 -1)
-  %agg = call { i8, i32, { float, { i64, i16 } } } @nestedStruct()
-  %elt.agg = extractvalue { i8, i32, { float, { i64, i16 } } } %agg, 2
-  %elt.agg1 = extractvalue { float, { i64, i16 } } %elt.agg, 1
-  %elt = extractvalue { i64, i16 } %elt.agg1, 0
-  call void @runtime.printint64(i64 %elt)
-  %agg2.agg0 = extractvalue { i8, i32, { float, { i64, i16 } } } %agg, 2
-  %agg2.agg1 = extractvalue { float, { i64, i16 } } %agg2.agg0, 1
-  %agg2.insertvalue2 = insertvalue { i64, i16 } %agg2.agg1, i64 5, 0
-  %agg2.insertvalue1 = insertvalue { float, { i64, i16 } } %agg2.agg0, { i64, i16 } %agg2.insertvalue2, 1
-  %agg2.insertvalue0 = insertvalue { i8, i32, { float, { i64, i16 } } } %agg, { float, { i64, i16 } } %agg2.insertvalue1, 2
-  store { i8, i32, { float, { i64, i16 } } } %agg2.insertvalue0, { i8, i32, { float, { i64, i16 } } }* @main.insertedValue
  ret void
 }

@@ -59,32 +44,3 @@ entry:
  store i16 8, i16* @main.exposedValue2
  ret void
 }
-
-define void @hasInlineAsm() {
-entry:
-  call void asm sideeffect "", ""()
-  ret void
-}
-
-define i64 @testSwitch(i64 %val) local_unnamed_addr {
-entry:
-  switch i64 %val, label %otherwise [
-    i64 0, label %zero
-    i64 1, label %one
-    i64 2, label %two
-  ]
-
-zero:                                             ; preds = %entry
-  ret i64 5
-
-one:                                              ; preds = %entry
-  ret i64 6
-
-two:                                              ; preds = %entry
-  ret i64 7
-
-otherwise:                                        ; preds = %entry
-  ret i64 -1
-}
-
-declare { i8, i32, { float, { i64, i16 } } } @nestedStruct() local_unnamed_addr
@@ -1,16 +1,17 @@
 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* }
+%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, %runtime.interfaceMethodInfo* null }
-@"reflect/types.typeid:named:main.foo" = external constant i8
+@"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, i8*, i8*, i8*)
+declare i1 @runtime.typeAssert(i64, %runtime.typecodeID*, i8*, i8*)

 define void @runtime.initAll() unnamed_addr {
 entry:
@@ -21,7 +22,7 @@ entry:
 define internal void @main.init() unnamed_addr {
 entry:
  ; Test type asserts.
-  %typecode = call i1 @runtime.typeAssert(i64 ptrtoint (%runtime.typecodeID* @"reflect/types.type:named:main.foo" to i64), i8* @"reflect/types.typeid:named:main.foo", i8* undef, i8* null)
+  %typecode = call i1 @runtime.typeAssert(i64 ptrtoint (%runtime.typeInInterface* @"typeInInterface:reflect/types.type:named:main.foo" to i64), %runtime.typecodeID* @"reflect/types.type:named:main.foo", i8* undef, i8* null)
  store i1 %typecode, i1* @main.v1
  ret void
 }
@@ -0,0 +1,74 @@
+target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
+target triple = "armv6m-none-eabi"
+
+%runtime._string = type { i8*, i32 }
+%runtime.hashmap = type { %runtime.hashmap*, i8*, i32, i8, i8, i8 }
+
+@main.m = global %runtime.hashmap* null
+@main.binaryMap = global %runtime.hashmap* null
+@main.stringMap = global %runtime.hashmap* null
+@main.init.string = internal unnamed_addr constant [7 x i8] c"CONNECT"
+
+declare %runtime.hashmap* @runtime.hashmapMake(i8, i8, i32, i8* %context, i8* %parentHandle)
+declare void @runtime.hashmapBinarySet(%runtime.hashmap*, i8*, i8*, i8* %context, i8* %parentHandle)
+declare void @runtime.hashmapStringSet(%runtime.hashmap*, i8*, i32, i8*, i8* %context, i8* %parentHandle)
+declare void @llvm.lifetime.end.p0i8(i64, i8*)
+declare void @llvm.lifetime.start.p0i8(i64, i8*)
+
+define void @runtime.initAll() unnamed_addr {
+entry:
+  call void @main.init(i8* undef, i8* null)
+  ret void
+}
+
+define internal void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+; Test that hashmap optimizations generally work (even with lifetimes).
+  %hashmap.key = alloca i8
+  %hashmap.value = alloca %runtime._string
+  %0 = call %runtime.hashmap* @runtime.hashmapMake(i8 1, i8 8, i32 1, i8* undef, i8* null)
+  %hashmap.value.bitcast = bitcast %runtime._string* %hashmap.value to i8*
+  call void @llvm.lifetime.start.p0i8(i64 8, i8* %hashmap.value.bitcast)
+  store %runtime._string { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @main.init.string, i32 0, i32 0), i32 7 }, %runtime._string* %hashmap.value
+  call void @llvm.lifetime.start.p0i8(i64 1, i8* %hashmap.key)
+  store i8 1, i8* %hashmap.key
+  call void @runtime.hashmapBinarySet(%runtime.hashmap* %0, i8* %hashmap.key, i8* %hashmap.value.bitcast, i8* undef, i8* null)
+  call void @llvm.lifetime.end.p0i8(i64 1, i8* %hashmap.key)
+  call void @llvm.lifetime.end.p0i8(i64 8, i8* %hashmap.value.bitcast)
+  store %runtime.hashmap* %0, %runtime.hashmap** @main.m
+
+  ; Other tests, that can be done in a separate function.
+  call void @main.testNonConstantBinarySet()
+  call void @main.testNonConstantStringSet()
+  ret void
+}
+
+; Test that a map loaded from a global can still be used for mapassign
+; operations (with binary keys).
+define internal void @main.testNonConstantBinarySet() {
+  %hashmap.key = alloca i8
+  %hashmap.value = alloca i8
+  ; Create hashmap from global.
+  %map.new = call %runtime.hashmap* @runtime.hashmapMake(i8 1, i8 1, i32 1, i8* undef, i8* null)
+  store %runtime.hashmap* %map.new, %runtime.hashmap** @main.binaryMap
+  %map = load %runtime.hashmap*, %runtime.hashmap** @main.binaryMap
+  ; Do the binary set to the newly loaded map.
+  store i8 1, i8* %hashmap.key
+  store i8 2, i8* %hashmap.value
+  call void @runtime.hashmapBinarySet(%runtime.hashmap* %map, i8* %hashmap.key, i8* %hashmap.value, i8* undef, i8* null)
+  ret void
+}
+
+; Test that a map loaded from a global can still be used for mapassign
+; operations (with string keys).
+define internal void @main.testNonConstantStringSet() {
+  %hashmap.value = alloca i8
+  ; Create hashmap from global.
+  %map.new = call %runtime.hashmap* @runtime.hashmapMake(i8 8, i8 1, i32 1, i8* undef, i8* null)
+  store %runtime.hashmap* %map.new, %runtime.hashmap** @main.stringMap
+  %map = load %runtime.hashmap*, %runtime.hashmap** @main.stringMap
+  ; Do the string set to the newly loaded map.
+  store i8 2, i8* %hashmap.value
+  call void @runtime.hashmapStringSet(%runtime.hashmap* %map, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @main.init.string, i32 0, i32 0), i32 7, i8* %hashmap.value, i8* undef, i8* null)
+  ret void
+}
@@ -0,0 +1,20 @@
+target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
+target triple = "armv6m-none-eabi"
+
+%runtime.hashmap = type { %runtime.hashmap*, i8*, i32, i8, i8, i8 }
+
+@main.m = local_unnamed_addr global %runtime.hashmap* @"main$map"
+@main.binaryMap = local_unnamed_addr global %runtime.hashmap* @"main$map.1"
+@main.stringMap = local_unnamed_addr global %runtime.hashmap* @"main$map.3"
+@main.init.string = internal unnamed_addr constant [7 x i8] c"CONNECT"
+@"main$map" = internal global %runtime.hashmap { %runtime.hashmap* null, i8* getelementptr inbounds ({ [8 x i8], i8*, { i8, [7 x i8] }, { { [7 x i8]*, [4 x i8] }, [56 x i8] } }, { [8 x i8], i8*, { i8, [7 x i8] }, { { [7 x i8]*, [4 x i8] }, [56 x i8] } }* @"main$mapbucket", i32 0, i32 0, i32 0), i32 1, i8 1, i8 8, i8 0 }
+@"main$mapbucket" = internal unnamed_addr global { [8 x i8], i8*, { i8, [7 x i8] }, { { [7 x i8]*, [4 x i8] }, [56 x i8] } } { [8 x i8] c"\04\00\00\00\00\00\00\00", i8* null, { i8, [7 x i8] } { i8 1, [7 x i8] zeroinitializer }, { { [7 x i8]*, [4 x i8] }, [56 x i8] } { { [7 x i8]*, [4 x i8] } { [7 x i8]* @main.init.string, [4 x i8] c"\07\00\00\00" }, [56 x i8] zeroinitializer } }
+@"main$map.1" = internal global %runtime.hashmap { %runtime.hashmap* null, i8* getelementptr inbounds ({ [8 x i8], i8*, { i8, [7 x i8] }, { i8, [7 x i8] } }, { [8 x i8], i8*, { i8, [7 x i8] }, { i8, [7 x i8] } }* @"main$mapbucket.2", i32 0, i32 0, i32 0), i32 1, i8 1, i8 1, i8 0 }
+@"main$mapbucket.2" = internal unnamed_addr global { [8 x i8], i8*, { i8, [7 x i8] }, { i8, [7 x i8] } } { [8 x i8] c"\04\00\00\00\00\00\00\00", i8* null, { i8, [7 x i8] } { i8 1, [7 x i8] zeroinitializer }, { i8, [7 x i8] } { i8 2, [7 x i8] zeroinitializer } }
+@"main$map.3" = internal global %runtime.hashmap { %runtime.hashmap* null, i8* getelementptr inbounds ({ [8 x i8], i8*, { { [7 x i8]*, [4 x i8] }, [56 x i8] }, { i8, [7 x i8] } }, { [8 x i8], i8*, { { [7 x i8]*, [4 x i8] }, [56 x i8] }, { i8, [7 x i8] } }* @"main$mapbucket.4", i32 0, i32 0, i32 0), i32 1, i8 8, i8 1, i8 0 }
+@"main$mapbucket.4" = internal unnamed_addr global { [8 x i8], i8*, { { [7 x i8]*, [4 x i8] }, [56 x i8] }, { i8, [7 x i8] } } { [8 x i8] c"x\00\00\00\00\00\00\00", i8* null, { { [7 x i8]*, [4 x i8] }, [56 x i8] } { { [7 x i8]*, [4 x i8] } { [7 x i8]* @main.init.string, [4 x i8] c"\07\00\00\00" }, [56 x i8] zeroinitializer }, { i8, [7 x i8] } { i8 2, [7 x i8] zeroinitializer } }
+
+define void @runtime.initAll() unnamed_addr {
+entry:
+  ret void
+}
@@ -1,31 +0,0 @@
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64--linux"
-
-@main.phiNodesResultA = global i8 0
-@main.phiNodesResultB = global i8 0
-
-define void @runtime.initAll() {
-  call void @main.init()
-  ret void
-}
-
-; PHI nodes always use the value from the previous block, even in a loop. This
-; means that the loop below should swap the values %a and %b on each iteration.
-; Previously there was a bug which resulted in %b getting the value 3 on the
-; second iteration while it should have gotten 1 (from the first iteration of
-; %for.loop).
-define internal void @main.init() {
-entry:
-  br label %for.loop
-
-for.loop:
-  %a = phi i8 [ 1, %entry ], [ %b, %for.loop ]
-  %b = phi i8 [ 3, %entry ], [ %a, %for.loop ]
-  %icmp = icmp eq i8 %a, 3
-  br i1 %icmp, label %for.done, label %for.loop
-
-for.done:
-  store i8 %a, i8* @main.phiNodesResultA
-  store i8 %b, i8* @main.phiNodesResultB
-  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.phiNodesResultA = local_unnamed_addr global i8 3
-@main.phiNodesResultB = local_unnamed_addr global i8 1
-
-define void @runtime.initAll() local_unnamed_addr {
-  ret void
-}
@@ -1,32 +0,0 @@
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64--linux"
-
-declare void @externalCall(i64)
-
-@foo.knownAtRuntime = global i64 0
-@bar.knownAtRuntime = global i64 0
-
-define void @runtime.initAll() unnamed_addr {
-entry:
-  call void @foo.init(i8* undef, i8* undef)
-  call void @bar.init(i8* undef, i8* undef)
-  call void @main.init(i8* undef, i8* undef)
-  ret void
-}
-
-define internal void @foo.init(i8* %context, i8* %parentHandle) unnamed_addr {
-  store i64 5, i64* @foo.knownAtRuntime
-  unreachable ; this triggers a revert of @foo.init.
-}
-
-define internal void @bar.init(i8* %context, i8* %parentHandle) unnamed_addr {
-  %val = load i64, i64* @foo.knownAtRuntime
-  store i64 %val, i64* @bar.knownAtRuntime
-  ret void
-}
-
-define internal void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
-entry:
-  call void @externalCall(i64 3)
-  ret void
-}
@@ -1,21 +0,0 @@
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64--linux"
-
-@foo.knownAtRuntime = local_unnamed_addr global i64 0
-@bar.knownAtRuntime = local_unnamed_addr global i64 0
-
-declare void @externalCall(i64) local_unnamed_addr
-
-define void @runtime.initAll() unnamed_addr {
-entry:
-  call fastcc void @foo.init(i8* undef, i8* undef)
-  %val = load i64, i64* @foo.knownAtRuntime, align 8
-  store i64 %val, i64* @bar.knownAtRuntime, align 8
-  call void @externalCall(i64 3)
-  ret void
-}
-
-define internal fastcc void @foo.init(i8* %context, i8* %parentHandle) unnamed_addr {
-  store i64 5, i64* @foo.knownAtRuntime, align 8
-  unreachable
-}
@@ -23,13 +23,3 @@ type Error struct {
 func (e Error) Error() string {
 	return e.Err.Error()
 }
-
-// Error returned when loading a *Program for a test binary but no test files
-// are present.
-type NoTestFilesError struct {
-	ImportPath string
-}
-
-func (e NoTestFilesError) Error() string {
-	return "no test files"
-}
@@ -2,14 +2,6 @@ package loader

 // This file constructs a new temporary GOROOT directory by merging both the
 // standard Go GOROOT and the GOROOT from TinyGo using symlinks.
-//
-// The goal is to replace specific packages from Go with a TinyGo version. It's
-// never a partial replacement, either a package is fully replaced or it is not.
-// This is important because if we did allow to merge packages (e.g. by adding
-// files to a package), it would lead to a dependency on implementation details
-// with all the maintenance burden that results in. Only allowing to replace
-// packages as a whole avoids this as packages are already designed to have a
-// public (backwards-compatible) API.

 import (
 	"crypto/sha512"
@@ -147,7 +139,6 @@ func mergeDirectory(goroot, tinygoroot, tmpgoroot, importPath string, overrides
 		if err != nil {
 			return err
 		}
-		hasTinyGoFiles := false
 		for _, e := range tinygoEntries {
 			if e.IsDir() {
 				// A directory, so merge this thing.
@@ -163,7 +154,6 @@ func mergeDirectory(goroot, tinygoroot, tmpgoroot, importPath string, overrides
 				if err != nil {
 					return err
 				}
-				hasTinyGoFiles = true
 			}
 		}

@@ -174,30 +164,21 @@ func mergeDirectory(goroot, tinygoroot, tmpgoroot, importPath string, overrides
 			return err
 		}
 		for _, e := range gorootEntries {
-			if e.IsDir() {
-				if _, ok := overrides[path.Join(importPath, e.Name())+"/"]; ok {
-					// Already included above, so don't bother trying to create this
-					// symlink.
-					continue
-				}
-				newname := filepath.Join(tmpgoroot, "src", importPath, e.Name())
-				oldname := filepath.Join(goroot, "src", importPath, e.Name())
-				err := symlink(oldname, newname)
-				if err != nil {
-					return err
-				}
-			} else {
-				// Only merge files from Go if TinyGo does not have any files.
-				// Otherwise we'd end up with a weird mix from both Go
-				// implementations.
-				if !hasTinyGoFiles {
-					newname := filepath.Join(tmpgoroot, "src", importPath, e.Name())
-					oldname := filepath.Join(goroot, "src", importPath, e.Name())
-					err := symlink(oldname, newname)
-					if err != nil {
-						return err
-					}
-				}
+			if !e.IsDir() {
+				// Don't merge in files from Go. Otherwise we'd end up with a
+				// weird syscall package with files from both roots.
+				continue
+			}
+			if _, ok := overrides[path.Join(importPath, e.Name())+"/"]; ok {
+				// Already included above, so don't bother trying to create this
+				// symlink.
+				continue
+			}
+			newname := filepath.Join(tmpgoroot, "src", importPath, e.Name())
+			oldname := filepath.Join(goroot, "src", importPath, e.Name())
+			err := symlink(oldname, newname)
+			if err != nil {
+				return err
 			}
 		}
 	}
@@ -208,7 +189,7 @@ func mergeDirectory(goroot, tinygoroot, tmpgoroot, importPath string, overrides
 // with the TinyGo version. This is the case on some targets.
 func needsSyscallPackage(buildTags []string) bool {
 	for _, tag := range buildTags {
-		if tag == "baremetal" || tag == "darwin" || tag == "nintendoswitch" || tag == "tinygo.wasm" {
+		if tag == "baremetal" || tag == "darwin" || tag == "nintendoswitch" || tag == "wasi" {
 			return true
 		}
 	}
@@ -220,8 +201,6 @@ func needsSyscallPackage(buildTags []string) bool {
 func pathsToOverride(needsSyscallPackage bool) map[string]bool {
 	paths := map[string]bool{
 		"/":                     true,
-		"crypto/":               true,
-		"crypto/rand/":          false,
 		"device/":               false,
 		"examples/":             false,
 		"internal/":             true,
@@ -229,7 +208,6 @@ func pathsToOverride(needsSyscallPackage bool) map[string]bool {
 		"internal/reflectlite/": false,
 		"internal/task/":        false,
 		"machine/":              false,
-		"net/":                  true,
 		"os/":                   true,
 		"reflect/":              false,
 		"runtime/":              false,
@@ -2,7 +2,6 @@ package loader

 import (
 	"bytes"
-	"crypto/sha512"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -12,7 +11,6 @@ import (
 	"go/token"
 	"go/types"
 	"io"
-	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -68,12 +66,10 @@ type PackageJSON struct {
 type Package struct {
 	PackageJSON

-	program    *Program
-	Files      []*ast.File
-	FileHashes map[string][]byte
-	CFlags     []string // CFlags used during CGo preprocessing (only set if CGo is used)
-	Pkg        *types.Package
-	info       types.Info
+	program *Program
+	Files   []*ast.File
+	Pkg     *types.Package
+	info    types.Info
 }

 // Load loads the given package with all dependencies (including the runtime
@@ -122,8 +118,7 @@ func Load(config *compileopts.Config, inputPkgs []string, clangHeaders string, t
 	decoder := json.NewDecoder(buf)
 	for {
 		pkg := &Package{
-			program:    p,
-			FileHashes: make(map[string][]byte),
+			program: p,
 			info: types.Info{
 				Types:      make(map[ast.Expr]types.TypeAndValue),
 				Defs:       make(map[*ast.Ident]types.Object),
@@ -210,12 +205,6 @@ func Load(config *compileopts.Config, inputPkgs []string, clangHeaders string, t
 		p.Packages[pkg.ImportPath] = pkg
 	}

-	if config.TestConfig.CompileTestBinary && !strings.HasSuffix(p.sorted[len(p.sorted)-1].ImportPath, ".test") {
-		// Trying to compile a test binary but there are no test files in this
-		// package.
-		return p, NoTestFilesError{p.sorted[len(p.sorted)-1].ImportPath}
-	}
-
 	return p, nil
 }

@@ -288,15 +277,17 @@ func (p *Program) Parse() error {
 }

 // parseFile is a wrapper around parser.ParseFile.
-func (p *Package) parseFile(path string, mode parser.Mode) (*ast.File, error) {
-	originalPath := p.program.getOriginalPath(path)
-	data, err := ioutil.ReadFile(path)
+func (p *Program) parseFile(path string, mode parser.Mode) (*ast.File, error) {
+	if p.fset == nil {
+		p.fset = token.NewFileSet()
+	}
+
+	rd, err := os.Open(path)
 	if err != nil {
 		return nil, err
 	}
-	sum := sha512.Sum512_224(data)
-	p.FileHashes[originalPath] = sum[:]
-	return parser.ParseFile(p.program.fset, originalPath, data, mode)
+	defer rd.Close()
+	return parser.ParseFile(p.fset, p.getOriginalPath(path), rd, mode)
 }

 // Parse parses and typechecks this package.
@@ -343,11 +334,12 @@ func (p *Package) Check() error {
 	checker.Importer = p

 	packageName := p.ImportPath
-	if p == p.program.MainPkg() {
-		if p.Name != "main" {
-			// Sanity check. Should not ever trigger.
-			panic("expected main package to have name 'main'")
-		}
+	if p.Name == "main" {
+		// The main package normally has a different import path, such as
+		// "command-line-arguments" or "./testdata/cgo". Therefore, use the name
+		// "main" in such a case: this package isn't imported from anywhere.
+		// This is safe as it isn't possible to import a package with the name
+		// "main".
 		packageName = "main"
 	}
 	typesPkg, err := checker.Check(packageName, p.program.fset, p.Files, &p.info)
@@ -371,7 +363,7 @@ func (p *Package) parseFiles() ([]*ast.File, error) {
 		if !filepath.IsAbs(file) {
 			file = filepath.Join(p.Dir, file)
 		}
-		f, err := p.parseFile(file, parser.ParseComments)
+		f, err := p.program.parseFile(file, parser.ParseComments)
 		if err != nil {
 			fileErrs = append(fileErrs, err)
 			return
@@ -386,22 +378,14 @@ func (p *Package) parseFiles() ([]*ast.File, error) {
 	}

 	// Do CGo processing.
-	// This is done when there are any CgoFiles at all. In that case, len(files)
-	// should be non-zero. However, if len(GoFiles) == 0 and len(CgoFiles) == 1
-	// and there is a syntax error in a CGo file, len(files) may be 0. Don't try
-	// to call cgo.Process in that case as it will only cause issues.
-	if len(p.CgoFiles) != 0 && len(files) != 0 {
-		var initialCFlags []string
-		initialCFlags = append(initialCFlags, p.program.config.CFlags()...)
-		initialCFlags = append(initialCFlags, "-I"+p.Dir)
+	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 != "" {
-			initialCFlags = append(initialCFlags, "-Xclang", "-internal-isystem", "-Xclang", p.program.clangHeaders)
-		}
-		generated, cflags, ldflags, accessedFiles, errs := cgo.Process(files, p.program.workingDir, p.program.fset, initialCFlags)
-		p.CFlags = append(initialCFlags, cflags...)
-		for path, hash := range accessedFiles {
-			p.FileHashes[path] = hash
+			cflags = append(cflags, "-Xclang", "-internal-isystem", "-Xclang", p.program.clangHeaders)
 		}
+		generated, ldflags, errs := cgo.Process(files, p.program.workingDir, p.program.fset, cflags)
 		if errs != nil {
 			fileErrs = append(fileErrs, errs...)
 		}
@@ -13,15 +13,11 @@ import (
 	"os/exec"
 	"os/signal"
 	"path/filepath"
-	"regexp"
 	"runtime"
-	"runtime/pprof"
-	"strconv"
 	"strings"
 	"sync/atomic"
 	"time"

-	"github.com/google/shlex"
 	"github.com/mattn/go-colorable"
 	"github.com/tinygo-org/tinygo/builder"
 	"github.com/tinygo-org/tinygo/compileopts"
@@ -32,7 +28,6 @@ import (
 	"tinygo.org/x/go-llvm"

 	"go.bug.st/serial"
-	"go.bug.st/serial/enumerator"
 )

 var (
@@ -97,31 +92,12 @@ func copyFile(src, dst string) error {

 // executeCommand is a simple wrapper to exec.Cmd
 func executeCommand(options *compileopts.Options, name string, arg ...string) *exec.Cmd {
-	if options.PrintCommands != nil {
-		options.PrintCommands(name, arg...)
+	if options.PrintCommands {
+		fmt.Printf("%s %s\n ", name, strings.Join(arg, " "))
 	}
 	return exec.Command(name, arg...)
 }

-// printCommand prints a command to stdout while formatting it like a real
-// command (escaping characters etc). The resulting command should be easy to
-// run directly in a shell, although it is not guaranteed to be a safe shell
-// escape. That's not a problem as the primary use case is printing the command,
-// not running it.
-func printCommand(cmd string, args ...string) {
-	command := append([]string{cmd}, args...)
-	for i, arg := range command {
-		// Source: https://www.oreilly.com/library/view/learning-the-bash/1565923472/ch01s09.html
-		const specialChars = "~`#$&*()\\|[]{};'\"<>?! "
-		if strings.ContainsAny(arg, specialChars) {
-			// See: https://stackoverflow.com/questions/15783701/which-characters-need-to-be-escaped-when-using-bash
-			arg = "'" + strings.ReplaceAll(arg, `'`, `'\''`) + "'"
-			command[i] = arg
-		}
-	}
-	fmt.Fprintln(os.Stderr, strings.Join(command, " "))
-}
-
 // Build compiles and links the given package and writes it to outpath.
 func Build(pkgName, outpath string, options *compileopts.Options) error {
 	config, err := builder.NewConfig(options)
@@ -129,7 +105,7 @@ func Build(pkgName, outpath string, options *compileopts.Options) error {
 		return err
 	}

-	return builder.Build(pkgName, outpath, config, func(result builder.BuildResult) error {
+	return builder.Build(pkgName, outpath, config, nil, func(result builder.BuildResult) error {
 		if err := os.Rename(result.Binary, outpath); err != nil {
 			// Moving failed. Do a file copy.
 			inf, err := os.Open(result.Binary)
@@ -157,17 +133,15 @@ func Build(pkgName, outpath string, options *compileopts.Options) error {
 	})
 }

-// Test runs the tests in the given package. Returns whether the test passed and
-// possibly an error if the test failed to run.
-func Test(pkgName string, options *compileopts.Options, testCompileOnly, testVerbose bool, outpath string) (bool, error) {
+// Test runs the tests in the given package.
+func Test(pkgName string, options *compileopts.Options, testCompileOnly bool, outpath string) error {
 	options.TestConfig.CompileTestBinary = true
 	config, err := builder.NewConfig(options)
 	if err != nil {
-		return false, err
+		return err
 	}

-	passed := true
-	err = builder.Build(pkgName, outpath, config, func(result builder.BuildResult) error {
+	return builder.Build(pkgName, outpath, config, nil, func(result builder.BuildResult) error {
 		if testCompileOnly || outpath != "" {
 			// Write test binary to the specified file name.
 			if outpath == "" {
@@ -181,83 +155,48 @@ func Test(pkgName string, options *compileopts.Options, testCompileOnly, testVer
 			// Do not run the test.
 			return nil
 		}
-
-		// Run the test.
-		start := time.Now()
-		var err error
-		passed, err = runPackageTest(config, result, testVerbose)
-		if err != nil {
-			return err
-		}
-		duration := time.Since(start)
-
-		// Print the result.
-		importPath := strings.TrimSuffix(result.ImportPath, ".test")
-		if passed {
-			fmt.Printf("ok  \t%s\t%.3fs\n", importPath, duration.Seconds())
+		if len(config.Target.Emulator) == 0 {
+			// Run directly.
+			cmd := executeCommand(config.Options, result.Binary)
+			cmd.Stdout = os.Stdout
+			cmd.Stderr = os.Stderr
+			cmd.Dir = result.MainDir
+			err := cmd.Run()
+			if err != nil {
+				// Propagate the exit code
+				if err, ok := err.(*exec.ExitError); ok {
+					os.Exit(err.ExitCode())
+				}
+				return &commandError{"failed to run compiled binary", result.Binary, err}
+			}
+			return nil
 		} else {
-			fmt.Printf("FAIL\t%s\t%.3fs\n", importPath, duration.Seconds())
+			// Run in an emulator.
+			args := append(config.Target.Emulator[1:], result.Binary)
+			cmd := executeCommand(config.Options, config.Target.Emulator[0], args...)
+			buf := &bytes.Buffer{}
+			w := io.MultiWriter(os.Stdout, buf)
+			cmd.Stdout = w
+			cmd.Stderr = os.Stderr
+			err := cmd.Run()
+			if err != nil {
+				if err, ok := err.(*exec.ExitError); !ok || !err.Exited() {
+					// Workaround for QEMU which always exits with an error.
+					return &commandError{"failed to run emulator with", result.Binary, err}
+				}
+			}
+			testOutput := string(buf.Bytes())
+			if testOutput == "PASS\n" || strings.HasSuffix(testOutput, "\nPASS\n") {
+				// Test passed.
+				return nil
+			} else {
+				// Test failed, either by ending with the word "FAIL" or with a
+				// panic of some sort.
+				os.Exit(1)
+				return nil // unreachable
+			}
 		}
-		return nil
 	})
-	if err, ok := err.(loader.NoTestFilesError); ok {
-		fmt.Printf("?   \t%s\t[no test files]\n", err.ImportPath)
-		// Pretend the test passed - it at least didn't fail.
-		return true, nil
-	}
-	return passed, err
-}
-
-// runPackageTest runs a test binary that was previously built. The return
-// values are whether the test passed and any errors encountered while trying to
-// run the binary.
-func runPackageTest(config *compileopts.Config, result builder.BuildResult, testVerbose bool) (bool, error) {
-	if len(config.Target.Emulator) == 0 {
-		// Run directly.
-		var flags []string
-		if testVerbose {
-			flags = append(flags, "-test.v")
-		}
-		cmd := executeCommand(config.Options, result.Binary, flags...)
-		cmd.Stdout = os.Stdout
-		cmd.Stderr = os.Stderr
-		cmd.Dir = result.MainDir
-		err := cmd.Run()
-		if err != nil {
-			if _, ok := err.(*exec.ExitError); ok {
-				// Binary exited with a non-zero exit code, which means the test
-				// failed.
-				return false, nil
-			}
-			return false, &commandError{"failed to run compiled binary", result.Binary, err}
-		}
-		return true, nil
-	} else {
-		// Run in an emulator.
-		// TODO: pass the -test.v flag if needed.
-		args := append(config.Target.Emulator[1:], result.Binary)
-		cmd := executeCommand(config.Options, config.Target.Emulator[0], args...)
-		buf := &bytes.Buffer{}
-		w := io.MultiWriter(os.Stdout, buf)
-		cmd.Stdout = w
-		cmd.Stderr = os.Stderr
-		err := cmd.Run()
-		if err != nil {
-			if err, ok := err.(*exec.ExitError); !ok || !err.Exited() {
-				// Workaround for QEMU which always exits with an error.
-				return false, &commandError{"failed to run emulator with", result.Binary, err}
-			}
-		}
-		testOutput := string(buf.Bytes())
-		if testOutput == "PASS\n" || strings.HasSuffix(testOutput, "\nPASS\n") {
-			// Test passed.
-			return true, nil
-		} else {
-			// Test failed, either by ending with the word "FAIL" or with a
-			// panic of some sort.
-			return false, nil
-		}
-	}
 }

 // Flash builds and flashes the built binary to the given serial port.
@@ -282,8 +221,6 @@ func Flash(pkgName, port string, options *compileopts.Options) error {
 			fileExt = ".bin"
 		case strings.Contains(config.Target.FlashCommand, "{uf2}"):
 			fileExt = ".uf2"
-		case strings.Contains(config.Target.FlashCommand, "{zip}"):
-			fileExt = ".zip"
 		default:
 			return errors.New("invalid target file - did you forget the {hex} token in the 'flash-command' section?")
 		}
@@ -294,65 +231,68 @@ func Flash(pkgName, port string, options *compileopts.Options) error {
 		fileExt = filepath.Ext(config.Target.FlashFilename)
 	case "openocd":
 		fileExt = ".hex"
-	case "bmp":
-		fileExt = ".elf"
 	case "native":
 		return errors.New("unknown flash method \"native\" - did you miss a -target flag?")
 	default:
 		return errors.New("unknown flash method: " + flashMethod)
 	}

-	return builder.Build(pkgName, fileExt, config, func(result builder.BuildResult) error {
+	return builder.Build(pkgName, fileExt, config, func() error {
 		// do we need port reset to put MCU into bootloader mode?
 		if config.Target.PortReset == "true" && flashMethod != "openocd" {
-			port, err := getDefaultPort(port, config.Target.SerialPort)
-			if err != nil {
-				return err
-			}
-
-			err = touchSerialPortAt1200bps(port)
-			if err != nil {
-				return &commandError{"failed to reset port", result.Binary, err}
-			}
-			// give the target MCU a chance to restart into bootloader
-			time.Sleep(3 * time.Second)
-		}
-
-		// this flashing method copies the binary data to a Mass Storage Device (msd)
-		switch flashMethod {
-		case "", "command":
-			// Create the command.
-			flashCmd := config.Target.FlashCommand
-			flashCmdList, err := shlex.Split(flashCmd)
-			if err != nil {
-				return fmt.Errorf("could not parse flash command %#v: %w", flashCmd, err)
-			}
-
-			if strings.Contains(flashCmd, "{port}") {
+			if port == "" {
 				var err error
-				port, err = getDefaultPort(port, config.Target.SerialPort)
+				port, err = getDefaultPort()
 				if err != nil {
 					return err
 				}
 			}

-			// Fill in fields in the command template.
+			err := touchSerialPortAt1200bps(port)
+			if err != nil {
+				return &commandError{"failed to reset port", "", err}
+			}
+			// give the target MCU a chance to restart into bootloader
+			time.Sleep(3 * time.Second)
+		}
+		return nil
+
+	}, func(result builder.BuildResult) error {
+		// this flashing method copies the binary data to a Mass Storage Device (msd)
+		switch flashMethod {
+		case "", "command":
+			// Create the command.
+			flashCmd := config.Target.FlashCommand
 			fileToken := "{" + fileExt[1:] + "}"
-			for i, arg := range flashCmdList {
-				arg = strings.ReplaceAll(arg, fileToken, result.Binary)
-				arg = strings.ReplaceAll(arg, "{port}", port)
-				flashCmdList[i] = arg
+			flashCmd = strings.ReplaceAll(flashCmd, fileToken, result.Binary)
+
+			if port == "" && strings.Contains(flashCmd, "{port}") {
+				var err error
+				port, err = getDefaultPort()
+				if err != nil {
+					return err
+				}
 			}

+			flashCmd = strings.ReplaceAll(flashCmd, "{port}", port)
+
 			// Execute the command.
-			if len(flashCmdList) < 2 {
-				return fmt.Errorf("invalid flash command: %#v", flashCmd)
+			var cmd *exec.Cmd
+			switch runtime.GOOS {
+			case "windows":
+				command := strings.Split(flashCmd, " ")
+				if len(command) < 2 {
+					return errors.New("invalid flash command")
+				}
+				cmd = executeCommand(config.Options, command[0], command[1:]...)
+			default:
+				cmd = executeCommand(config.Options, "/bin/sh", "-c", flashCmd)
 			}
-			cmd := executeCommand(config.Options, flashCmdList[0], flashCmdList[1:]...)
+
 			cmd.Stdout = os.Stdout
 			cmd.Stderr = os.Stderr
 			cmd.Dir = goenv.Get("TINYGOROOT")
-			err = cmd.Run()
+			err := cmd.Run()
 			if err != nil {
 				return &commandError{"failed to flash", result.Binary, err}
 			}
@@ -388,25 +328,6 @@ func Flash(pkgName, port string, options *compileopts.Options) error {
 				return &commandError{"failed to flash", result.Binary, err}
 			}
 			return nil
-		case "bmp":
-			gdb, err := config.Target.LookupGDB()
-			if err != nil {
-				return err
-			}
-			var bmpGDBPort string
-			bmpGDBPort, _, err = getBMPPorts()
-			if err != nil {
-				return err
-			}
-			args := []string{"-ex", "target extended-remote " + bmpGDBPort, "-ex", "monitor swdp_scan", "-ex", "attach 1", "-ex", "load", filepath.ToSlash(result.Binary)}
-			cmd := executeCommand(config.Options, gdb, args...)
-			cmd.Stdout = os.Stdout
-			cmd.Stderr = os.Stderr
-			err = cmd.Run()
-			if err != nil {
-				return &commandError{"failed to flash", result.Binary, err}
-			}
-			return nil
 		default:
 			return fmt.Errorf("unknown flash method: %s", flashMethod)
 		}
@@ -425,12 +346,11 @@ func FlashGDB(pkgName string, ocdOutput bool, options *compileopts.Options) erro
 	if err != nil {
 		return err
 	}
-	gdb, err := config.Target.LookupGDB()
-	if err != nil {
-		return err
+	if config.Target.GDB == "" {
+		return errors.New("gdb not configured in the target specification")
 	}

-	return builder.Build(pkgName, "", config, func(result builder.BuildResult) error {
+	return builder.Build(pkgName, "", config, nil, func(result builder.BuildResult) error {
 		// Find a good way to run GDB.
 		gdbInterface, openocdInterface := config.Programmer()
 		switch gdbInterface {
@@ -461,15 +381,8 @@ func FlashGDB(pkgName string, ocdOutput bool, options *compileopts.Options) erro
 		switch gdbInterface {
 		case "native":
 			// Run GDB directly.
-		case "bmp":
-			var bmpGDBPort string
-			bmpGDBPort, _, err = getBMPPorts()
-			if err != nil {
-				return err
-			}
-			gdbCommands = append(gdbCommands, "target extended-remote "+bmpGDBPort, "monitor swdp_scan", "compare-sections", "attach 1", "load")
 		case "openocd":
-			gdbCommands = append(gdbCommands, "target extended-remote :3333", "monitor halt", "load", "monitor reset halt")
+			gdbCommands = append(gdbCommands, "target remote :3333", "monitor halt", "load", "monitor reset halt")

 			// We need a separate debugging daemon for on-chip debugging.
 			args, err := config.OpenOCDConfiguration()
@@ -488,7 +401,7 @@ func FlashGDB(pkgName string, ocdOutput bool, options *compileopts.Options) erro
 				daemon.Stderr = w
 			}
 		case "jlink":
-			gdbCommands = append(gdbCommands, "target extended-remote :2331", "load", "monitor reset halt")
+			gdbCommands = append(gdbCommands, "target remote :2331", "load", "monitor reset halt")

 			// We need a separate debugging daemon for on-chip debugging.
 			daemon = executeCommand(config.Options, "JLinkGDBServer", "-device", config.Target.JLinkDevice)
@@ -503,7 +416,7 @@ func FlashGDB(pkgName string, ocdOutput bool, options *compileopts.Options) erro
 				daemon.Stderr = w
 			}
 		case "qemu":
-			gdbCommands = append(gdbCommands, "target extended-remote :1234")
+			gdbCommands = append(gdbCommands, "target remote :1234")

 			// Run in an emulator.
 			args := append(config.Target.Emulator[1:], result.Binary, "-s", "-S")
@@ -511,7 +424,7 @@ func FlashGDB(pkgName string, ocdOutput bool, options *compileopts.Options) erro
 			daemon.Stdout = os.Stdout
 			daemon.Stderr = os.Stderr
 		case "qemu-user":
-			gdbCommands = append(gdbCommands, "target extended-remote :1234")
+			gdbCommands = append(gdbCommands, "target remote :1234")

 			// Run in an emulator.
 			args := append(config.Target.Emulator[1:], "-g", "1234", result.Binary)
@@ -519,7 +432,7 @@ func FlashGDB(pkgName string, ocdOutput bool, options *compileopts.Options) erro
 			daemon.Stdout = os.Stdout
 			daemon.Stderr = os.Stderr
 		case "mgba":
-			gdbCommands = append(gdbCommands, "target extended-remote :2345")
+			gdbCommands = append(gdbCommands, "target remote :2345")

 			// Run in an emulator.
 			args := append(config.Target.Emulator[1:], result.Binary, "-g")
@@ -527,7 +440,7 @@ func FlashGDB(pkgName string, ocdOutput bool, options *compileopts.Options) erro
 			daemon.Stdout = os.Stdout
 			daemon.Stderr = os.Stderr
 		case "simavr":
-			gdbCommands = append(gdbCommands, "target extended-remote :1234")
+			gdbCommands = append(gdbCommands, "target remote :1234")

 			// Run in an emulator.
 			args := append(config.Target.Emulator[1:], "-g", result.Binary)
@@ -579,7 +492,7 @@ func FlashGDB(pkgName string, ocdOutput bool, options *compileopts.Options) erro
 		for _, cmd := range gdbCommands {
 			params = append(params, "-ex", cmd)
 		}
-		cmd := executeCommand(config.Options, gdb, params...)
+		cmd := executeCommand(config.Options, config.Target.GDB, params...)
 		cmd.Stdin = os.Stdin
 		cmd.Stdout = os.Stdout
 		cmd.Stderr = os.Stderr
@@ -601,7 +514,7 @@ func Run(pkgName string, options *compileopts.Options) error {
 		return err
 	}

-	return builder.Build(pkgName, ".elf", config, func(result builder.BuildResult) error {
+	return builder.Build(pkgName, ".elf", config, nil, func(result builder.BuildResult) error {
 		if len(config.Target.Emulator) == 0 {
 			// Run directly.
 			cmd := executeCommand(config.Options, result.Binary)
@@ -753,155 +666,41 @@ func windowsFindUSBDrive(volume string, options *compileopts.Options) (string, e
 }

 // getDefaultPort returns the default serial port depending on the operating system.
-func getDefaultPort(portFlag string, usbInterfaces []string) (port string, err error) {
-	portCandidates := strings.FieldsFunc(portFlag, func(c rune) bool { return c == ',' })
-	if len(portCandidates) == 1 {
-		return portCandidates[0], nil
-	}
-
-	var ports []string
+func getDefaultPort() (port string, err error) {
+	var portPath string
 	switch runtime.GOOS {
+	case "darwin":
+		portPath = "/dev/cu.usb*"
+	case "linux":
+		portPath = "/dev/ttyACM*"
 	case "freebsd":
-		ports, err = filepath.Glob("/dev/cuaU*")
-	case "darwin", "linux", "windows":
-		var portsList []*enumerator.PortDetails
-		portsList, err = enumerator.GetDetailedPortsList()
+		portPath = "/dev/cuaU*"
+	case "windows":
+		ports, err := serial.GetPortsList()
 		if err != nil {
 			return "", err
 		}

-		var preferredPortIDs [][2]uint16
-		for _, s := range usbInterfaces {
-			parts := strings.Split(s, ":")
-			if len(parts) != 3 || (parts[0] != "acm" && parts[0] == "usb") {
-				// acm and usb are the two types of serial ports recognized
-				// under Linux (ttyACM*, ttyUSB*). Other operating systems don't
-				// generally make this distinction. If this is not one of the
-				// given USB devices, don't try to parse the USB IDs.
-				continue
-			}
-			vid, err := strconv.ParseUint(parts[1], 16, 16)
-			if err != nil {
-				return "", fmt.Errorf("could not parse USB vendor ID %q: %w", parts[1], err)
-			}
-			pid, err := strconv.ParseUint(parts[2], 16, 16)
-			if err != nil {
-				return "", fmt.Errorf("could not parse USB product ID %q: %w", parts[1], err)
-			}
-			preferredPortIDs = append(preferredPortIDs, [2]uint16{uint16(vid), uint16(pid)})
-		}
-
-		var primaryPorts []string   // ports picked from preferred USB VID/PID
-		var secondaryPorts []string // other ports (as a fallback)
-		for _, p := range portsList {
-			if !p.IsUSB {
-				continue
-			}
-			if p.VID != "" && p.PID != "" {
-				foundPort := false
-				vid, vidErr := strconv.ParseUint(p.VID, 16, 16)
-				pid, pidErr := strconv.ParseUint(p.PID, 16, 16)
-				if vidErr == nil && pidErr == nil {
-					for _, id := range preferredPortIDs {
-						if uint16(vid) == id[0] && uint16(pid) == id[1] {
-							primaryPorts = append(primaryPorts, p.Name)
-							foundPort = true
-							continue
-						}
-					}
-				}
-				if foundPort {
-					continue
-				}
-			}
-
-			secondaryPorts = append(secondaryPorts, p.Name)
-		}
-		if len(primaryPorts) == 1 {
-			// There is exactly one match in the set of preferred ports. Use
-			// this port, even if there may be others available. This allows
-			// flashing a specific board even if there are multiple available.
-			return primaryPorts[0], nil
-		} else if len(primaryPorts) > 1 {
-			// There are multiple preferred ports, probably because more than
-			// one device of the same type are connected (e.g. two Arduino
-			// Unos).
-			ports = primaryPorts
-		} else {
-			// No preferred ports found. Fall back to other serial ports
-			// available in the system.
-			ports = secondaryPorts
-		}
-
 		if len(ports) == 0 {
-			// fallback
-			switch runtime.GOOS {
-			case "darwin":
-				ports, err = filepath.Glob("/dev/cu.usb*")
-			case "linux":
-				ports, err = filepath.Glob("/dev/ttyACM*")
-			case "windows":
-				ports, err = serial.GetPortsList()
-			}
+			return "", errors.New("no serial ports available")
+		} else if len(ports) > 1 {
+			return "", errors.New("multiple serial ports available - use -port flag")
 		}
+
+		return ports[0], nil
 	default:
 		return "", errors.New("unable to search for a default USB device to be flashed on this OS")
 	}

+	d, err := filepath.Glob(portPath)
 	if err != nil {
 		return "", err
-	} else if ports == nil {
+	}
+	if d == nil {
 		return "", errors.New("unable to locate a serial port")
-	} else if len(ports) == 0 {
-		return "", errors.New("no serial ports available")
 	}

-	if len(portCandidates) == 0 {
-		if len(ports) == 1 {
-			return ports[0], nil
-		} else {
-			return "", errors.New("multiple serial ports available - use -port flag, available ports are " + strings.Join(ports, ", "))
-		}
-	}
-
-	for _, ps := range portCandidates {
-		for _, p := range ports {
-			if p == ps {
-				return p, nil
-			}
-		}
-	}
-
-	return "", errors.New("port you specified '" + strings.Join(portCandidates, ",") + "' does not exist, available ports are " + strings.Join(ports, ", "))
-}
-
-// getBMPPorts returns BlackMagicProbe's serial ports if any
-func getBMPPorts() (gdbPort, uartPort string, err error) {
-	var portsList []*enumerator.PortDetails
-	portsList, err = enumerator.GetDetailedPortsList()
-	if err != nil {
-		return "", "", err
-	}
-	var ports []string
-	for _, p := range portsList {
-		if !p.IsUSB {
-			continue
-		}
-		if p.VID != "" && p.PID != "" {
-			vid, vidErr := strconv.ParseUint(p.VID, 16, 16)
-			pid, pidErr := strconv.ParseUint(p.PID, 16, 16)
-			if vidErr == nil && pidErr == nil && vid == 0x1d50 && pid == 0x6018 {
-				ports = append(ports, p.Name)
-			}
-		}
-	}
-	if len(ports) == 2 {
-		return ports[0], ports[1], nil
-	} else if len(ports) == 0 {
-		return "", "", errors.New("no BMP detected")
-	} else {
-		return "", "", fmt.Errorf("expected 2 BMP serial ports, found %d - did you perhaps connect more than one BMP?", len(ports))
-	}
+	return d[0], nil
 }

 func usage() {
@@ -1014,52 +813,6 @@ func handleCompilerError(err error) {
 	}
 }

-// This is a special type for the -X flag to parse the pkgpath.Var=stringVal
-// format. It has to be a special type to allow multiple variables to be defined
-// this way.
-type globalValuesFlag map[string]map[string]string
-
-func (m globalValuesFlag) String() string {
-	return "pkgpath.Var=value"
-}
-
-func (m globalValuesFlag) Set(value string) error {
-	equalsIndex := strings.IndexByte(value, '=')
-	if equalsIndex < 0 {
-		return errors.New("expected format pkgpath.Var=value")
-	}
-	pathAndName := value[:equalsIndex]
-	pointIndex := strings.LastIndexByte(pathAndName, '.')
-	if pointIndex < 0 {
-		return errors.New("expected format pkgpath.Var=value")
-	}
-	path := pathAndName[:pointIndex]
-	name := pathAndName[pointIndex+1:]
-	stringValue := value[equalsIndex+1:]
-	if m[path] == nil {
-		m[path] = make(map[string]string)
-	}
-	m[path][name] = stringValue
-	return nil
-}
-
-// parseGoLinkFlag parses the -ldflags parameter. Its primary purpose right now
-// is the -X flag, for setting the value of global string variables.
-func parseGoLinkFlag(flagsString string) (map[string]map[string]string, error) {
-	set := flag.NewFlagSet("link", flag.ExitOnError)
-	globalVarValues := make(globalValuesFlag)
-	set.Var(globalVarValues, "X", "Set the value of the string variable to the given value.")
-	flags, err := shlex.Split(flagsString)
-	if err != nil {
-		return nil, err
-	}
-	err = set.Parse(flags)
-	if err != nil {
-		return nil, err
-	}
-	return map[string]map[string]string(globalVarValues), nil
-}
-
 func main() {
 	if len(os.Args) < 2 {
 		fmt.Fprintln(os.Stderr, "No command-line arguments supplied.")
@@ -1072,7 +825,6 @@ func main() {
 	gc := flag.String("gc", "", "garbage collector to use (none, leaking, extalloc, conservative)")
 	panicStrategy := flag.String("panic", "print", "panic strategy (print, trap)")
 	scheduler := flag.String("scheduler", "", "which scheduler to use (none, coroutines, tasks)")
-	serial := flag.String("serial", "", "which serial output to use (none, uart, usb)")
 	printIR := flag.Bool("printir", false, "print LLVM IR")
 	dumpSSA := flag.Bool("dumpssa", false, "dump internal Go SSA")
 	verifyIR := flag.Bool("verifyir", false, "run extra verification steps on LLVM IR")
@@ -1080,32 +832,27 @@ func main() {
 	target := flag.String("target", "", "LLVM target | .json file with TargetSpec")
 	printSize := flag.String("size", "", "print sizes (none, short, full)")
 	printStacks := flag.Bool("print-stacks", false, "print stack sizes of goroutines")
-	printAllocsString := flag.String("print-allocs", "", "regular expression of functions for which heap allocations should be printed")
 	printCommands := flag.Bool("x", false, "Print commands")
-	nodebug := flag.Bool("no-debug", false, "strip debug information")
-	ocdCommandsString := flag.String("ocd-commands", "", "OpenOCD commands, overriding target spec (can specify multiple separated by commas)")
+	nodebug := flag.Bool("no-debug", false, "disable DWARF debug symbol generation")
 	ocdOutput := flag.Bool("ocd-output", false, "print OCD daemon output during debug")
-	port := flag.String("port", "", "flash port (can specify multiple candidates separated by commas)")
+	port := flag.String("port", "", "flash port")
 	programmer := flag.String("programmer", "", "which hardware programmer to use")
-	ldflags := flag.String("ldflags", "", "Go link tool compatible ldflags")
+	cFlags := flag.String("cflags", "", "additional cflags for compiler")
+	ldFlags := flag.String("ldflags", "", "additional ldflags for linker")
 	wasmAbi := flag.String("wasm-abi", "", "WebAssembly ABI conventions: js (no i64 params) or generic")
-	llvmFeatures := flag.String("llvm-features", "", "comma separated LLVM features to enable")
-	cpuprofile := flag.String("cpuprofile", "", "cpuprofile output")

-	var flagJSON, flagDeps, flagTest *bool
+	var flagJSON, flagDeps *bool
 	if command == "help" || command == "list" {
 		flagJSON = flag.Bool("json", false, "print data in JSON format")
-		flagDeps = flag.Bool("deps", false, "supply -deps flag to go list")
-		flagTest = flag.Bool("test", false, "supply -test flag to go list")
+		flagDeps = flag.Bool("deps", false, "")
 	}
 	var outpath string
 	if command == "help" || command == "build" || command == "build-library" || command == "test" {
 		flag.StringVar(&outpath, "o", "", "output filename")
 	}
-	var testCompileOnlyFlag, testVerboseFlag *bool
+	var testCompileOnlyFlag *bool
 	if command == "help" || command == "test" {
 		testCompileOnlyFlag = flag.Bool("c", false, "compile the test binary but do not run it")
-		testVerboseFlag = flag.Bool("v", false, "verbose: print additional output")
 	}

 	// Early command processing, before commands are interpreted by the Go flag
@@ -1121,74 +868,41 @@ func main() {
 	}

 	flag.CommandLine.Parse(os.Args[2:])
-	globalVarValues, err := parseGoLinkFlag(*ldflags)
-	if err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
-
-	var printAllocs *regexp.Regexp
-	if *printAllocsString != "" {
-		printAllocs, err = regexp.Compile(*printAllocsString)
-		if err != nil {
-			fmt.Fprintln(os.Stderr, err)
-			os.Exit(1)
-		}
-	}
-
-	var ocdCommands []string
-	if *ocdCommandsString != "" {
-		ocdCommands = strings.Split(*ocdCommandsString, ",")
-	}
-
 	options := &compileopts.Options{
-		Target:          *target,
-		Opt:             *opt,
-		GC:              *gc,
-		PanicStrategy:   *panicStrategy,
-		Scheduler:       *scheduler,
-		Serial:          *serial,
-		PrintIR:         *printIR,
-		DumpSSA:         *dumpSSA,
-		VerifyIR:        *verifyIR,
-		Debug:           !*nodebug,
-		PrintSizes:      *printSize,
-		PrintStacks:     *printStacks,
-		PrintAllocs:     printAllocs,
-		Tags:            *tags,
-		GlobalValues:    globalVarValues,
-		WasmAbi:         *wasmAbi,
-		Programmer:      *programmer,
-		OpenOCDCommands: ocdCommands,
-		LLVMFeatures:    *llvmFeatures,
+		Target:        *target,
+		Opt:           *opt,
+		GC:            *gc,
+		PanicStrategy: *panicStrategy,
+		Scheduler:     *scheduler,
+		PrintIR:       *printIR,
+		DumpSSA:       *dumpSSA,
+		VerifyIR:      *verifyIR,
+		Debug:         !*nodebug,
+		PrintSizes:    *printSize,
+		PrintStacks:   *printStacks,
+		PrintCommands: *printCommands,
+		Tags:          *tags,
+		WasmAbi:       *wasmAbi,
+		Programmer:    *programmer,
 	}
-	if *printCommands {
-		options.PrintCommands = printCommand
+
+	if *cFlags != "" {
+		options.CFlags = strings.Split(*cFlags, " ")
+	}
+
+	if *ldFlags != "" {
+		options.LDFlags = strings.Split(*ldFlags, " ")
 	}

 	os.Setenv("CC", "clang -target="+*target)

-	err = options.Verify()
+	err := options.Verify()
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err.Error())
 		usage()
 		os.Exit(1)
 	}

-	if *cpuprofile != "" {
-		f, err := os.Create(*cpuprofile)
-		if err != nil {
-			fmt.Fprintln(os.Stderr, "could not create CPU profile: ", err)
-			os.Exit(1)
-		}
-		defer f.Close()
-		if err := pprof.StartCPUProfile(f); err != nil {
-			fmt.Fprintln(os.Stderr, "could not start CPU profile: ", err)
-			os.Exit(1)
-		}
-		defer pprof.StopCPUProfile()
-	}
-
 	switch command {
 	case "build":
 		if outpath == "" {
@@ -1270,26 +984,16 @@ func main() {
 		err := Run(pkgName, options)
 		handleCompilerError(err)
 	case "test":
-		var pkgNames []string
-		for i := 0; i < flag.NArg(); i++ {
-			pkgNames = append(pkgNames, filepath.ToSlash(flag.Arg(i)))
-		}
-		if len(pkgNames) == 0 {
-			pkgNames = []string{"."}
-		}
-		allTestsPassed := true
-		for _, pkgName := range pkgNames {
-			// TODO: parallelize building the test binaries
-			passed, err := Test(pkgName, options, *testCompileOnlyFlag, *testVerboseFlag, outpath)
-			handleCompilerError(err)
-			if !passed {
-				allTestsPassed = false
-			}
-		}
-		if !allTestsPassed {
-			fmt.Println("FAIL")
+		pkgName := "."
+		if flag.NArg() == 1 {
+			pkgName = filepath.ToSlash(flag.Arg(0))
+		} else if flag.NArg() > 1 {
+			fmt.Fprintln(os.Stderr, "test only accepts a single positional argument: package name, but multiple were specified")
+			usage()
 			os.Exit(1)
 		}
+		err := Test(pkgName, options, *testCompileOnlyFlag, outpath)
+		handleCompilerError(err)
 	case "targets":
 		dir := filepath.Join(goenv.Get("TINYGOROOT"), "targets")
 		entries, err := ioutil.ReadDir(dir)
@@ -1364,9 +1068,6 @@ func main() {
 		if *flagDeps {
 			extraArgs = append(extraArgs, "-deps")
 		}
-		if *flagTest {
-			extraArgs = append(extraArgs, "-test")
-		}
 		cmd, err := loader.List(config, extraArgs, flag.Args())
 		if err != nil {
 			fmt.Fprintln(os.Stderr, "failed to run `go list`:", err)
@@ -13,6 +13,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"runtime"
+	"sort"
 	"strings"
 	"sync"
 	"testing"
@@ -28,52 +29,38 @@ const TESTDATA = "testdata"
 var testTarget = flag.String("target", "", "override test target")

 func TestCompiler(t *testing.T) {
-	tests := []string{
-		"alias.go",
-		"atomic.go",
-		"binop.go",
-		"calls.go",
-		"cgo/",
-		"channel.go",
-		"float.go",
-		"gc.go",
-		"goroutines.go",
-		"init.go",
-		"init_multi.go",
-		"interface.go",
-		"json.go",
-		"map.go",
-		"math.go",
-		"print.go",
-		"reflect.go",
-		"slice.go",
-		"sort.go",
-		"stdlib.go",
-		"string.go",
-		"structs.go",
-		"testing.go",
-		"zeroalloc.go",
+	matches, err := filepath.Glob(filepath.Join(TESTDATA, "*.go"))
+	if err != nil {
+		t.Fatal("could not read test files:", err)
 	}

-	_, minor, err := goenv.GetGorootVersion(goenv.Get("GOROOT"))
+	dirMatches, err := filepath.Glob(filepath.Join(TESTDATA, "*", "main.go"))
 	if err != nil {
-		t.Fatal("could not read version from GOROOT:", err)
+		t.Fatal("could not read test packages:", err)
 	}
-	if minor >= 17 {
-		tests = append(tests, "go1.17.go")
+	if len(matches) == 0 || len(dirMatches) == 0 {
+		t.Fatal("no test files found")
 	}
+	for _, m := range dirMatches {
+		matches = append(matches, filepath.Dir(m)+string(filepath.Separator))
+	}
+
+	sort.Strings(matches)

 	if *testTarget != "" {
 		// This makes it possible to run one specific test (instead of all),
 		// which is especially useful to quickly check whether some changes
 		// affect a particular target architecture.
-		runPlatTests(*testTarget, tests, t)
+		runPlatTests(*testTarget, matches, t)
 		return
 	}

 	if runtime.GOOS != "windows" {
 		t.Run("Host", func(t *testing.T) {
-			runPlatTests("", tests, t)
+			runPlatTests("", matches, t)
+			if runtime.GOOS == "darwin" {
+				runTest("testdata/libc/env.go", "", t, []string{"ENV1=VALUE1", "ENV2=VALUE2"}...)
+			}
 		})
 	}

@@ -82,97 +69,57 @@ func TestCompiler(t *testing.T) {
 	}

 	t.Run("EmulatedCortexM3", func(t *testing.T) {
-		runPlatTests("cortex-m-qemu", tests, t)
+		runPlatTests("cortex-m-qemu", matches, t)
 	})

 	if runtime.GOOS == "windows" || runtime.GOOS == "darwin" {
 		// Note: running only on Windows and macOS because Linux (as of 2020)
 		// usually has an outdated QEMU version that doesn't support RISC-V yet.
 		t.Run("EmulatedRISCV", func(t *testing.T) {
-			runPlatTests("riscv-qemu", tests, t)
+			runPlatTests("riscv-qemu", matches, t)
 		})
 	}

 	if runtime.GOOS == "linux" {
 		t.Run("X86Linux", func(t *testing.T) {
-			runPlatTests("i386--linux-gnu", tests, t)
+			runPlatTests("i386--linux-gnu", matches, t)
 		})
 		t.Run("ARMLinux", func(t *testing.T) {
-			runPlatTests("arm--linux-gnueabihf", tests, t)
+			runPlatTests("arm--linux-gnueabihf", matches, t)
 		})
 		t.Run("ARM64Linux", func(t *testing.T) {
-			runPlatTests("aarch64--linux-gnu", tests, t)
-		})
-		t.Run("WebAssembly", func(t *testing.T) {
-			runPlatTests("wasm", tests, t)
+			runPlatTests("aarch64--linux-gnu", matches, t)
 		})
+		goVersion, err := goenv.GorootVersionString(goenv.Get("GOROOT"))
+		if err != nil {
+			t.Error("could not get Go version:", err)
+			return
+		}
+		minorVersion := strings.Split(goVersion, ".")[1]
+		if minorVersion != "13" {
+			// WebAssembly tests fail on Go 1.13, so skip them there. Versions
+			// below that are also not supported but still seem to pass, so
+			// include them in the tests for now.
+			t.Run("WebAssembly", func(t *testing.T) {
+				runPlatTests("wasm", matches, t)
+			})
+		}
+
 		t.Run("WASI", func(t *testing.T) {
-			runPlatTests("wasi", tests, t)
+			runPlatTests("wasi", matches, t)
+			runTest("testdata/libc/env.go", "wasi", t, []string{"ENV1=VALUE1", "ENV2=VALUE2"}...)
 		})
 	}
-
-	// Test a few build options.
-	t.Run("build-options", func(t *testing.T) {
-		if runtime.GOOS == "windows" {
-			// These tests assume a host that is supported by TinyGo.
-			t.Skip("can't test build options on Windows")
-		}
-		t.Parallel()
-
-		// Test with few optimizations enabled (no inlining, etc).
-		t.Run("opt=1", func(t *testing.T) {
-			t.Parallel()
-			runTestWithConfig("stdlib.go", "", t, compileopts.Options{
-				Opt: "1",
-			}, nil, nil)
-		})
-
-		// Test with only the bare minimum of optimizations enabled.
-		// TODO: fix this for stdlib.go, which currently fails.
-		t.Run("opt=0", func(t *testing.T) {
-			t.Parallel()
-			runTestWithConfig("print.go", "", t, compileopts.Options{
-				Opt: "0",
-			}, nil, nil)
-		})
-
-		t.Run("ldflags", func(t *testing.T) {
-			t.Parallel()
-			runTestWithConfig("ldflags.go", "", t, compileopts.Options{
-				GlobalValues: map[string]map[string]string{
-					"main": {
-						"someGlobal": "foobar",
-					},
-				},
-			}, nil, nil)
-		})
-	})
 }

-func runPlatTests(target string, tests []string, t *testing.T) {
+func runPlatTests(target string, matches []string, t *testing.T) {
 	t.Parallel()

-	for _, name := range tests {
-		name := name // redefine to avoid race condition
-		t.Run(name, func(t *testing.T) {
+	for _, path := range matches {
+		path := path // redefine to avoid race condition
+		t.Run(filepath.Base(path), func(t *testing.T) {
 			t.Parallel()
-			runTest(name, target, t, nil, nil)
-		})
-	}
-	t.Run("env.go", func(t *testing.T) {
-		t.Parallel()
-		runTest("env.go", target, t, []string{"first", "second"}, []string{"ENV1=VALUE1", "ENV2=VALUE2"})
-	})
-	if target == "" || target == "wasi" {
-		t.Run("filesystem.go", func(t *testing.T) {
-			t.Parallel()
-			runTest("filesystem.go", target, t, nil, nil)
-		})
-	}
-	if target == "" || target == "wasi" || target == "wasm" {
-		t.Run("rand.go", func(t *testing.T) {
-			t.Parallel()
-			runTest("rand.go", target, t, nil, nil)
+			runTest(path, target, t)
 		})
 	}
 }
@@ -189,28 +136,10 @@ func runBuild(src, out string, opts *compileopts.Options) error {
 	return Build(src, out, opts)
 }

-func runTest(name, target string, t *testing.T, cmdArgs, environmentVars []string) {
-	options := compileopts.Options{
-		Target: target,
-	}
-	runTestWithConfig(name, target, t, options, cmdArgs, environmentVars)
-}
-
-func runTestWithConfig(name, target string, t *testing.T, options compileopts.Options, cmdArgs, environmentVars []string) {
-	// Set default config.
-	options.Debug = true
-	options.VerifyIR = true
-	if options.Opt == "" {
-		options.Opt = "z"
-	}
-
-	// Get the expected output for this test.
-	// Note: not using filepath.Join as it strips the path separator at the end
-	// of the path.
-	path := TESTDATA + "/" + name
+func runTest(path, target string, t *testing.T, environmentVars ...string) {
 	// Get the expected output for this test.
 	txtpath := path[:len(path)-3] + ".txt"
-	if path[len(path)-1] == '/' {
+	if path[len(path)-1] == os.PathSeparator {
 		txtpath = path + "out.txt"
 	}
 	expected, err := ioutil.ReadFile(txtpath)
@@ -219,78 +148,64 @@ func runTestWithConfig(name, target string, t *testing.T, options compileopts.Op
 	}

 	// Create a temporary directory for test output files.
-	tmpdir := t.TempDir()
-
-	// Determine whether we're on a system that supports environment variables
-	// and command line parameters (operating systems, WASI) or not (baremetal,
-	// WebAssembly in the browser). If we're on a system without an environment,
-	// we need to pass command line arguments and environment variables through
-	// global variables (built into the binary directly) instead of the
-	// conventional way.
-	spec, err := compileopts.LoadTarget(target)
+	tmpdir, err := ioutil.TempDir("", "tinygo-test")
 	if err != nil {
-		t.Fatal("failed to load target spec:", err)
+		t.Fatal("could not create temporary directory:", err)
 	}
-	needsEnvInVars := spec.GOOS == "js"
-	for _, tag := range spec.BuildTags {
-		if tag == "baremetal" {
-			needsEnvInVars = true
+	defer func() {
+		rerr := os.RemoveAll(tmpdir)
+		if rerr != nil {
+			t.Errorf("failed to remove temporary directory %q: %s", tmpdir, rerr.Error())
 		}
-	}
-	if needsEnvInVars {
-		runtimeGlobals := make(map[string]string)
-		if len(cmdArgs) != 0 {
-			runtimeGlobals["osArgs"] = strings.Join(cmdArgs, "\x00")
-		}
-		if len(environmentVars) != 0 {
-			runtimeGlobals["osEnv"] = strings.Join(environmentVars, "\x00")
-		}
-		if len(runtimeGlobals) != 0 {
-			// This sets the global variables like they would be set with
-			// `-ldflags="-X=runtime.osArgs=first\x00second`.
-			// The runtime package has two variables (osArgs and osEnv) that are
-			// both strings, from which the parameters and environment variables
-			// are read.
-			options.GlobalValues = map[string]map[string]string{
-				"runtime": runtimeGlobals,
-			}
-		}
-	}
+	}()

 	// Build the test binary.
+	config := &compileopts.Options{
+		Target:     target,
+		Opt:        "z",
+		PrintIR:    false,
+		DumpSSA:    false,
+		VerifyIR:   true,
+		Debug:      true,
+		PrintSizes: "",
+		WasmAbi:    "",
+	}
+
 	binary := filepath.Join(tmpdir, "test")
-	err = runBuild("./"+path, binary, &options)
+	err = runBuild("./"+path, binary, config)
 	if err != nil {
 		printCompilerError(t.Log, err)
 		t.Fail()
 		return
 	}

-	// Create the test command, taking care of emulators etc.
+	// Run the test.
+	runComplete := make(chan struct{})
 	var cmd *exec.Cmd
-	if len(spec.Emulator) == 0 {
+	ranTooLong := false
+	if target == "" {
 		cmd = exec.Command(binary)
+		cmd.Env = append(cmd.Env, environmentVars...)
 	} else {
-		args := append(spec.Emulator[1:], binary)
-		cmd = exec.Command(spec.Emulator[0], args...)
-	}
-	if len(spec.Emulator) != 0 && spec.Emulator[0] == "wasmtime" {
-		// Allow reading from the current directory.
-		cmd.Args = append(cmd.Args, "--dir=.")
-		for _, v := range environmentVars {
-			cmd.Args = append(cmd.Args, "--env", v)
+		spec, err := compileopts.LoadTarget(target)
+		if err != nil {
+			t.Fatal("failed to load target spec:", err)
 		}
-		cmd.Args = append(cmd.Args, cmdArgs...)
-	} else {
-		if !needsEnvInVars {
-			cmd.Args = append(cmd.Args, cmdArgs...) // works on qemu-aarch64 etc
+		if len(spec.Emulator) == 0 {
+			cmd = exec.Command(binary)
+		} else {
+			args := append(spec.Emulator[1:], binary)
+			cmd = exec.Command(spec.Emulator[0], args...)
+		}
+
+		if len(spec.Emulator) != 0 && spec.Emulator[0] == "wasmtime" {
+			for _, v := range environmentVars {
+				cmd.Args = append(cmd.Args, "--env", v)
+			}
+		} else {
 			cmd.Env = append(cmd.Env, environmentVars...)
 		}
 	}
-
-	// Run the test.
-	runComplete := make(chan struct{})
-	ranTooLong := false
 	stdout := &bytes.Buffer{}
 	cmd.Stdout = stdout
 	cmd.Stderr = os.Stderr
@@ -1,19 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package rand implements a cryptographically secure
-// random number generator.
-package rand
-
-import "io"
-
-// Reader is a global, shared instance of a cryptographically
-// secure random number generator.
-var Reader io.Reader
-
-// Read is a helper function that calls Reader.Read using io.ReadFull.
-// On return, n == len(b) if and only if err == nil.
-func Read(b []byte) (n int, err error) {
-	return io.ReadFull(Reader, b)
-}
@@ -1,30 +0,0 @@
-// +build darwin freebsd tinygo.wasm
-
-// This implementation of crypto/rand uses the arc4random_buf function
-// (available on both MacOS and WASI) to generate random numbers.
-//
-// Note: arc4random_buf (unlike what the name suggets) does not use the insecure
-// RC4 cipher. Instead, it uses a high-quality cipher, varying by the libc
-// implementation.
-
-package rand
-
-import "unsafe"
-
-func init() {
-	Reader = &reader{}
-}
-
-type reader struct {
-}
-
-func (r *reader) Read(b []byte) (n int, err error) {
-	if len(b) != 0 {
-		libc_arc4random_buf(unsafe.Pointer(&b[0]), uint(len(b)))
-	}
-	return len(b), nil
-}
-
-// void arc4random_buf(void *buf, size_t buflen);
-//export arc4random_buf
-func libc_arc4random_buf(buf unsafe.Pointer, buflen uint)
@@ -1,38 +0,0 @@
-// +build linux,!baremetal,!wasi
-
-// This implementation of crypto/rand uses the /dev/urandom pseudo-file to
-// generate random numbers.
-// TODO: convert to the getentropy or getrandom libc function on Linux once it
-// is more widely supported.
-
-package rand
-
-import (
-	"syscall"
-)
-
-func init() {
-	Reader = &reader{}
-}
-
-type reader struct {
-	fd int
-}
-
-func (r *reader) Read(b []byte) (n int, err error) {
-	if len(b) == 0 {
-		return
-	}
-
-	// Open /dev/urandom first if needed.
-	if r.fd == 0 {
-		fd, err := syscall.Open("/dev/urandom", syscall.O_RDONLY, 0)
-		if err != nil {
-			return 0, err
-		}
-		r.fd = fd
-	}
-
-	// Read from the file.
-	return syscall.Read(r.fd, b)
-}
@@ -1,143 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package rand
-
-import (
-	"errors"
-	"io"
-	"math/big"
-)
-
-// smallPrimes is a list of small, prime numbers that allows us to rapidly
-// exclude some fraction of composite candidates when searching for a random
-// prime. This list is truncated at the point where smallPrimesProduct exceeds
-// a uint64. It does not include two because we ensure that the candidates are
-// odd by construction.
-var smallPrimes = []uint8{
-	3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53,
-}
-
-// smallPrimesProduct is the product of the values in smallPrimes and allows us
-// to reduce a candidate prime by this number and then determine whether it's
-// coprime to all the elements of smallPrimes without further big.Int
-// operations.
-var smallPrimesProduct = new(big.Int).SetUint64(16294579238595022365)
-
-// Prime returns a number, p, of the given size, such that p is prime
-// with high probability.
-// Prime will return error for any error returned by rand.Read or if bits < 2.
-func Prime(rand io.Reader, bits int) (p *big.Int, err error) {
-	if bits < 2 {
-		err = errors.New("crypto/rand: prime size must be at least 2-bit")
-		return
-	}
-
-	b := uint(bits % 8)
-	if b == 0 {
-		b = 8
-	}
-
-	bytes := make([]byte, (bits+7)/8)
-	p = new(big.Int)
-
-	bigMod := new(big.Int)
-
-	for {
-		_, err = io.ReadFull(rand, bytes)
-		if err != nil {
-			return nil, err
-		}
-
-		// Clear bits in the first byte to make sure the candidate has a size <= bits.
-		bytes[0] &= uint8(int(1<<b) - 1)
-		// Don't let the value be too small, i.e, set the most significant two bits.
-		// Setting the top two bits, rather than just the top bit,
-		// means that when two of these values are multiplied together,
-		// the result isn't ever one bit short.
-		if b >= 2 {
-			bytes[0] |= 3 << (b - 2)
-		} else {
-			// Here b==1, because b cannot be zero.
-			bytes[0] |= 1
-			if len(bytes) > 1 {
-				bytes[1] |= 0x80
-			}
-		}
-		// Make the value odd since an even number this large certainly isn't prime.
-		bytes[len(bytes)-1] |= 1
-
-		p.SetBytes(bytes)
-
-		// Calculate the value mod the product of smallPrimes. If it's
-		// a multiple of any of these primes we add two until it isn't.
-		// The probability of overflowing is minimal and can be ignored
-		// because we still perform Miller-Rabin tests on the result.
-		bigMod.Mod(p, smallPrimesProduct)
-		mod := bigMod.Uint64()
-
-	NextDelta:
-		for delta := uint64(0); delta < 1<<20; delta += 2 {
-			m := mod + delta
-			for _, prime := range smallPrimes {
-				if m%uint64(prime) == 0 && (bits > 6 || m != uint64(prime)) {
-					continue NextDelta
-				}
-			}
-
-			if delta > 0 {
-				bigMod.SetUint64(delta)
-				p.Add(p, bigMod)
-			}
-			break
-		}
-
-		// There is a tiny possibility that, by adding delta, we caused
-		// the number to be one bit too long. Thus we check BitLen
-		// here.
-		if p.ProbablyPrime(20) && p.BitLen() == bits {
-			return
-		}
-	}
-}
-
-// Int returns a uniform random value in [0, max). It panics if max <= 0.
-func Int(rand io.Reader, max *big.Int) (n *big.Int, err error) {
-	if max.Sign() <= 0 {
-		panic("crypto/rand: argument to Int is <= 0")
-	}
-	n = new(big.Int)
-	n.Sub(max, n.SetUint64(1))
-	// bitLen is the maximum bit length needed to encode a value < max.
-	bitLen := n.BitLen()
-	if bitLen == 0 {
-		// the only valid result is 0
-		return
-	}
-	// k is the maximum byte length needed to encode a value < max.
-	k := (bitLen + 7) / 8
-	// b is the number of bits in the most significant byte of max-1.
-	b := uint(bitLen % 8)
-	if b == 0 {
-		b = 8
-	}
-
-	bytes := make([]byte, k)
-
-	for {
-		_, err = io.ReadFull(rand, bytes)
-		if err != nil {
-			return nil, err
-		}
-
-		// Clear bits in the first byte to increase the probability
-		// that the candidate is < max.
-		bytes[0] &= uint8(int(1<<b) - 1)
-
-		n.SetBytes(bytes)
-		if n.Cmp(max) < 0 {
-			return
-		}
-	}
-}
--- a/Show More
+++ b/Show More