main: add -json flag support to go env

This is needed for VS Code support.

.circleci/config.yml

@@ -14,19 +14,16 @@ commands:
       - run:
           name: "Install apt dependencies"
           command: |
-            echo 'deb http://apt.llvm.org/stretch/ llvm-toolchain-stretch<<parameters.llvm>> main' | sudo tee /etc/apt/sources.list.d/llvm.list
+            echo 'deb https://apt.llvm.org/buster/ llvm-toolchain-buster-<<parameters.llvm>> main' | sudo tee /etc/apt/sources.list.d/llvm.list
             wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key|sudo apt-key add -
             sudo apt-get update
             sudo apt-get install \
-                python3 \
-                llvm<<parameters.llvm>>-dev \
-                clang<<parameters.llvm>> \
-                libclang<<parameters.llvm>>-dev \
-                lld<<parameters.llvm>> \
+                llvm-<<parameters.llvm>>-dev \
+                clang-<<parameters.llvm>> \
+                libclang-<<parameters.llvm>>-dev \
+                lld-<<parameters.llvm>> \
                 gcc-arm-linux-gnueabihf \
-                libc6-dev-armel-cross \
                 gcc-aarch64-linux-gnu \
-                libc6-dev-arm64-cross \
                 qemu-system-arm \
                 qemu-user \
                 gcc-avr \
@@ -44,30 +41,53 @@ commands:
     steps:
       - restore_cache:
           keys:
-            - llvm-source-9-v0
+            - llvm-source-10-v0
       - run:
           name: "Fetch LLVM source"
           command: make llvm-source
       - save_cache:
-          key: llvm-source-9-v0
+          key: llvm-source-10-v0
           paths:
             - llvm-project
+  build-wasi-libc:
+    steps:
+      - restore_cache:
+          keys:
+            - wasi-libc-sysroot-v2
+      - run:
+          name: "Build wasi-libc"
+          command: make wasi-libc
+      - save_cache:
+          key: wasi-libc-sysroot-v2
+          paths:
+            - lib/wasi-libc/sysroot
   test-linux:
+    parameters:
+      llvm:
+        type: string
     steps:
       - checkout
       - submodules
       - apt-dependencies:
-          llvm: "-9"
+          llvm: "<<parameters.llvm>>"
       - install-node
       - restore_cache:
           keys:
             - go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
             - go-cache-v2-{{ checksum "go.mod" }}
       - llvm-source-linux
-      - run: go install .
-      - run: go test -v ./cgo ./compileopts ./interp ./transform .
+      - run: go install -tags=llvm<<parameters.llvm>> .
+      - restore_cache:
+          keys:
+            - wasi-libc-sysroot-systemclang-v1
+      - run: make wasi-libc
+      - save_cache:
+          key: wasi-libc-sysroot-systemclang-v1
+          paths:
+            - lib/wasi-libc/sysroot
+      - run: go test -v -tags=llvm<<parameters.llvm>> ./cgo ./compileopts ./interp ./transform .
       - run: make gen-device -j4
-      - run: make smoketest RISCV=0
+      - run: make smoketest
       - save_cache:
           key: go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
           paths:
@@ -83,7 +103,6 @@ commands:
           name: "Install apt dependencies"
           command: |
             sudo apt-get install \
-                python3 \
                 gcc-arm-linux-gnueabihf \
                 binutils-arm-none-eabi \
                 libc6-dev-armel-cross \
@@ -101,7 +120,7 @@ commands:
       - llvm-source-linux
       - restore_cache:
           keys:
-            - llvm-build-9-linux-v0-assert
+            - llvm-build-10-linux-v0-assert
       - run:
           name: "Build LLVM"
           command: |
@@ -119,16 +138,11 @@ commands:
               make ASSERT=1 llvm-build
             fi
       - save_cache:
-          key: llvm-build-9-linux-v0-assert
+          key: llvm-build-10-linux-v0-assert
           paths:
             llvm-build
-      - run:
-          name: "Create LLVM symlinks"
-          command: |
-            ln -s $PWD/llvm-build/bin/clang-9 /go/bin/clang-9
-            ln -s $PWD/llvm-build/bin/ld.lld  /go/bin/ld.lld-9
-            ln -s $PWD/llvm-build/bin/wasm-ld /go/bin/wasm-ld-9
       - run: make ASSERT=1
+      - build-wasi-libc
       - run:
           name: "Test TinyGo"
           command: make ASSERT=1 test
@@ -139,7 +153,7 @@ commands:
             - ~/.cache/tinygo
             - /go/pkg/mod
       - run: make gen-device -j4
-      - run: make smoketest TINYGO=build/tinygo RISCV=0
+      - run: make smoketest TINYGO=build/tinygo
   build-linux:
     steps:
       - checkout
@@ -148,7 +162,6 @@ commands:
           name: "Install apt dependencies"
           command: |
             sudo apt-get install \
-                python3 \
                 gcc-arm-linux-gnueabihf \
                 binutils-arm-none-eabi \
                 libc6-dev-armel-cross \
@@ -166,7 +179,7 @@ commands:
       - llvm-source-linux
       - restore_cache:
           keys:
-            - llvm-build-9-linux-v0
+            - llvm-build-10-linux-v0
       - run:
           name: "Build LLVM"
           command: |
@@ -184,15 +197,10 @@ commands:
               make llvm-build
             fi
       - save_cache:
-          key: llvm-build-9-linux-v0
+          key: llvm-build-10-linux-v0
           paths:
             llvm-build
-      - run:
-          name: "Create LLVM symlinks"
-          command: |
-            ln -s $PWD/llvm-build/bin/clang-9 /go/bin/clang-9
-            ln -s $PWD/llvm-build/bin/ld.lld  /go/bin/ld.lld-9
-            ln -s $PWD/llvm-build/bin/wasm-ld /go/bin/wasm-ld-9
+      - build-wasi-libc
       - run:
           name: "Test TinyGo"
           command: make test
@@ -216,11 +224,6 @@ commands:
             tar -C ~/lib -xf /tmp/tinygo.linux-amd64.tar.gz
             ln -s ~/lib/tinygo/bin/tinygo /go/bin/tinygo
             tinygo version
-      - run:
-          name: "Download SiFive GNU toolchain"
-          command: |
-            curl -O https://static.dev.sifive.com/dev-tools/riscv64-unknown-elf-gcc-8.2.0-2019.05.3-x86_64-linux-ubuntu14.tar.gz
-            sudo tar -C /usr/local --strip-components=1 -xf riscv64-unknown-elf-gcc-8.2.0-2019.05.3-x86_64-linux-ubuntu14.tar.gz
       - run: make smoketest
   build-macos:
     steps:
@@ -229,8 +232,8 @@ commands:
       - run:
           name: "Install dependencies"
           command: |
-            curl https://dl.google.com/go/go1.13.darwin-amd64.tar.gz -o go1.13.darwin-amd64.tar.gz
-            sudo tar -C /usr/local -xzf go1.13.darwin-amd64.tar.gz
+            curl https://dl.google.com/go/go1.14.darwin-amd64.tar.gz -o go1.14.darwin-amd64.tar.gz
+            sudo tar -C /usr/local -xzf go1.14.darwin-amd64.tar.gz
             ln -s /usr/local/go/bin/go /usr/local/bin/go
             HOMEBREW_NO_AUTO_UPDATE=1 brew install qemu
       - restore_cache:
@@ -239,17 +242,17 @@ commands:
             - go-cache-macos-v2-{{ checksum "go.mod" }}
       - restore_cache:
           keys:
-            - llvm-source-9-macos-v0
+            - llvm-source-10-macos-v0
       - run:
           name: "Fetch LLVM source"
           command: make llvm-source
       - save_cache:
-          key: llvm-source-9-macos-v0
+          key: llvm-source-10-macos-v0
           paths:
             - llvm-project
       - restore_cache:
           keys:
-            - llvm-build-9-macos-v0
+            - llvm-build-10-macos-v0
       - run:
           name: "Build LLVM"
           command: |
@@ -261,13 +264,19 @@ commands:
               make llvm-build
             fi
       - save_cache:
-          key: llvm-build-9-macos-v0
+          key: llvm-build-10-macos-v0
           paths:
             llvm-build
+      - restore_cache:
+          keys:
+            - wasi-libc-sysroot-macos-v1
       - run:
-          name: "Create LLVM symlinks"
-          command: |
-            ln -s $PWD/llvm-build/bin/clang-9 /usr/local/bin/clang-9
+          name: "Build wasi-libc"
+          command: make wasi-libc
+      - save_cache:
+          key: wasi-libc-sysroot-macos-v1
+          paths:
+            - lib/wasi-libc/sysroot
       - run:
           name: "Test TinyGo"
           command: make test
@@ -302,27 +311,36 @@ commands:
 jobs:
   test-llvm9-go111:
     docker:
-      - image: circleci/golang:1.11-stretch
+      - image: circleci/golang:1.11-buster
     steps:
-      - test-linux
-  test-llvm9-go112:
+      - test-linux:
+          llvm: "9"
+  test-llvm10-go112:
     docker:
-      - image: circleci/golang:1.12-stretch
+      - image: circleci/golang:1.12-buster
     steps:
-      - test-linux
-  test-llvm9-go113:
+      - test-linux:
+          llvm: "10"
+  test-llvm10-go113:
     docker:
-      - image: circleci/golang:1.13-stretch
+      - image: circleci/golang:1.13-buster
     steps:
-      - test-linux
+      - test-linux:
+          llvm: "10"
+  test-llvm10-go114:
+    docker:
+      - image: circleci/golang:1.14-buster
+    steps:
+      - test-linux:
+          llvm: "10"
   assert-test-linux:
     docker:
-      - image: circleci/golang:1.13-stretch
+      - image: circleci/golang:1.14-stretch
     steps:
       - assert-test-linux
   build-linux:
     docker:
-      - image: circleci/golang:1.13-stretch
+      - image: circleci/golang:1.14-stretch
     steps:
       - build-linux
   build-macos:
@@ -338,8 +356,9 @@ workflows:
   test-all:
     jobs:
       - test-llvm9-go111
-      - test-llvm9-go112
-      - test-llvm9-go113
+      - test-llvm10-go112
+      - test-llvm10-go113
+      - test-llvm10-go114
       - build-linux
       - build-macos
       - assert-test-linux

.gitmodules

@@ -9,8 +9,14 @@
 	url = https://github.com/avr-rust/avr-mcu.git
 [submodule "lib/cmsis-svd"]
 	path = lib/cmsis-svd
-	url = https://github.com/tinygo-org/cmsis-svd
+	url = https://github.com/posborne/cmsis-svd
 [submodule "lib/compiler-rt"]
 	path = lib/compiler-rt
 	url = https://github.com/llvm-mirror/compiler-rt.git
 	branch = release_80
+[submodule "lib/wasi-libc"]
+	path = lib/wasi-libc
+	url = https://github.com/CraneStation/wasi-libc
+[submodule "lib/picolibc"]
+	path = lib/picolibc
+	url = https://github.com/keith-packard/picolibc.git

CHANGELOG.md

@@ -1,3 +1,187 @@
+0.13.1
+---
+* **standard library**
+  - `runtime`: do not put scheduler and GC code in the same section
+  - `runtime`: copy stack scan assembly for GBA
+* **boards**
+  - `gameboy-advance`: always use ARM mode instead of Thumb mode
+
+
+0.13.0
+---
+* **command line**
+  - use `gdb-multiarch` for debugging Cortex-M chips
+  - support `tinygo run` with simavr
+  - support LLVM 10
+  - support Go 1.14
+  - retry 3 times when attempting to do a 1200-baud reset
+* **compiler**
+  - mark the `abort` function as noreturn
+  - fix deferred calls to exported functions
+  - add debug info for local variables
+  - check for channel size limit
+  - refactor coroutine lowering
+  - add `dereferenceable_or_null` attribute to pointer parameters
+  - do not perform nil checking when indexing slices and on `unsafe.Pointer`
+  - remove `runtime.isnil` hack
+  - use LLVM builtins for runtime `memcpy`/`memmove`/`memzero` functions
+  - implement spec-compliant shifts on negative/overflow
+  - support anonymous type asserts
+  - track pointer result of string concatenation for GC
+  - track PHI nodes for GC
+  - add debug info to goroutine start wrappers
+  - optimize comparing interface values against nil
+  - fix miscompilation when deferring an interface call
+  - builder: include picolibc for most baremetal targets
+  - builder: run tools (clang, lld) as separate processes
+  - builder: use `-fshort-enums` consistently
+  - interp: add support for constant type asserts
+  - interp: better support for interface operations
+  - interp: include backtrace with error
+  - transform: do not track const globals for GC
+  - transform: replace panics with source locations
+  - transform: fix error in interface lowering pass
+  - transform: make coroutine lowering deterministic
+  - transform: fix miscompilation in func lowering
+* **cgo**
+  - make `-I` and `-L` paths absolute
+* **standard library**
+  - `machine`: set the USB VID and PID to the manufacturer values
+  - `machine`: correct USB CDC composite descriptors
+  - `machine`: move `errors.New` calls to globals
+  - `runtime`: support operations on nil maps
+  - `runtime`: fix copy builtin return value on AVR
+  - `runtime`: refactor goroutines
+  - `runtime`: support `-scheduler=none` on most platforms
+  - `runtime`: run package initialization in the main goroutine
+  - `runtime`: export `malloc` / `free` for use from C
+  - `runtime`: add garbage collector that uses an external allocator
+  - `runtime`: scan callee-saved registers while marking the stack
+  - `runtime`: remove recursion from conservative GC
+  - `runtime`: fix blocking select on nil channel
+  - `runtime/volatile`: include `ReplaceBits` method
+  - `sync`: implement trivial `sync.Map`
+* **targets**
+  - `arm`: use `-fomit-frame-pointer`
+  - `atmega1284`: support this chip for testing purposes
+  - `atsamd51`: make QSPI available on all boards
+  - `atsamd51`: add support for ADC1
+  - `atsamd51`: use new interrupt registration in UART code
+  - `attiny`: clean up pin definitions
+  - `avr`: use the correct RAM start address
+  - `avr`: pass the correct `-mmcu` flag to the linker
+  - `avr`: add support for tasks scheduler (disabled by default)
+  - `avr`: fix linker problem with overlapping program/data areas
+  - `nrf`: fix typo in pin configuration options
+  - `nrf`: add lib/nrfx/mdk to include dirs
+  - `nrf52840`: implement USB-CDC
+  - `riscv`: implement VirtIO target and add RISC-V integration test
+  - `riscv`: add I2C support for the HiFive1 rev B board
+  - `stm32`: refactor GPIO pin handling
+  - `stm32`: refactor UART code
+  - `stm32f4`: add SPI
+  - `wasm`: support Go 1.14 (breaking previous versions)
+  - `wasm`: support `syscall/js.CopyBytesToJS`
+  - `wasm`: sync polyfills from Go 1.14.
+* **boards**
+  - `arduino-mega2560`: add the Arduino Mega 2560
+  - `clue-alpha`: add the Adafruit CLUE Alpha
+  - `gameboy-advance`: enable debugging with GDB
+  - `particle-argon`: add the Particle Argon board
+  - `particle-boron`: add the Particle Boron board
+  - `particle-xenon`: add the Particle Xenon board
+  - `reelboard`: add `reelboard-s140v7` SoftDevice target
+
+0.12.0
+---
+* **command line**
+  - add initial FreeBSD support
+  - remove getting a serial port in gdb subcommand
+  - add support for debugging through JLinkGDBServer
+  - fix CGo when cross compiling
+  - remove default port check for Digispark as micronucleus communicates directly using HID
+  - differentiate between various serial/USB error messages
+* **builder**
+  - improve detection of Clang headers
+* **compiler**
+  - fix assertion on empty interface
+  - don't crash when encountering `types.Invalid`
+  - revise defer to use heap allocations when running a variable number of times
+  - improve error messages for failed imports
+  - improve "function redeclared" error
+  - add globaldce pass to start of optimization pipeline
+  - add support for debugging globals
+  - implement RISC-V CSR operations as intrinsics
+  - add support for CGO_ENABLED environment variable
+  - do not emit debug info for extern globals (bugfix)
+  - add support for interrupts
+  - implement maps for arbitrary keys
+  - interp: error location for "unknown GEP" error
+  - wasm-abi: create temporary allocas in the entry block
+* **cgo**
+  - add support for symbols in `#define`
+  - fix a bug in number tokenization
+* **standard library**
+  - `machine`: avoid bytes package in USB logic
+  - `runtime`: fix external address declarations
+  - `runtime`: provide implementation for `internal/bytealg.IndexByte`
+* **targets**
+  - `atsamd51`: fix volatile usage
+  - `atsamd51`: fix ADC, updating to 12-bits precision
+  - `atsamd51`: refactor SPI pin configuration to only look at pin numbers
+  - `atsamd51`: switch UART to use new pin configuration
+  - `atsamd51`: fix obvious bug in I2C code
+  - `atsamd51`: use only the necessary UART interrupts
+  - `atsamd51`: refactor I2C pin handling to auto-detect pin mode
+  - `avr`: use a garbage collector
+  - `fe310`: use CLINT peripheral for timekeeping
+  - `fe310`: add support for PLIC interrupts
+  - `fe310`: implement UART receive interrupts
+  - `riscv`: support sleeping in QEMU
+  - `riscv`: add bare-bones interrupt support
+  - `riscv`: print exception PC and code
+  - `wasm`: implement memcpy and memset
+  - `wasm`: include wasi-libc
+  - `wasm`: use wasi ABI for basic startup/stdout
+* **boards**
+  - `arduino`: make avrdude command line compatible with Windows
+  - `arduino-nano`: add this board
+  - `arduino-nano33`: fix UART1 and UART2
+  - `circuitplay-bluefruit`: add this board
+  - `digispark`: add clock speed and pin mappings
+  - `gameboy-advance`: include compiler-rt in build
+  - `gameboy-advance`: implement interrupt handler
+  - `hifive1b`: add support for gdb subcommand
+  - `pyportal`: add this board
+  - `pyportal`: remove manual SPI pin mapping as now handled by default
+
+
+0.11.0
+---
+* **command line**
+  - add support for QEMU in `gdb` subcommand
+  - use builtin Clang when building statically, dropping the clang-9 dependency
+  - search for default serial port on both macOS and Linux
+  - windows: support `tinygo flash` directly by using win32 wmi
+* **compiler**
+  - add location information to the IR checker
+  - make reflection sidetables constant globals
+  - improve error locations in goroutine lowering
+  - interp: improve support for maps with string keys
+  - interp: add runtime fallback for mapassign operations
+* **standard library**
+  - `machine`: add support for `SPI.Tx()` on play.tinygo.org
+  - `machine`: rename `CPU_FREQUENCY` to `CPUFrequency()`
+* **targets**
+  - `adafruit-pybadge`: add Adafruit Pybadge
+  - `arduino-nano33`: allow simulation on play.tinygo.org
+  - `arduino-nano33`: fix default SPI pin numbers to be D13/D11/D12
+  - `circuitplay-express`: allow simulation on play.tinygo.org
+  - `hifive1-qemu`: add target for testing RISC-V bare metal in QEMU
+  - `riscv`: fix heap corruption due to changes in LLVM 9
+  - `riscv`: add support for compiler-rt
+  - `qemu`: rename to `cortex-m-qemu`
+
 0.10.0
 ---
 * **command line**

CODE-OF-CONDUCT.md

@@ -0,0 +1,76 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to make participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+  advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies within all project spaces, and it also applies when
+an individual is representing the project or its community in public spaces.
+Examples of representing a project or community include using an official
+project e-mail address, posting via an official social media account, or acting
+as an appointed representative at an online or offline event. Representation of
+a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at [conduct@tinygo.org](mailto:conduct@tinygo.org). All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq

CONTRIBUTORS

@@ -15,3 +15,4 @@ Ayke van Laethem <aykevanlaethem@gmail.com>
 Daniel Esteban <conejo@conejo.me>
 Loon, LLC.
 Ron Evans <ron@hybridgroup.com>
+Jaden Weiss <jaden@jadendw.dev>

Dockerfile

@@ -1,10 +1,10 @@
-# TinyGo base stage installs Go 1.13, LLVM 9 and the TinyGo compiler itself.
-FROM golang:1.13 AS tinygo-base
+# TinyGo base stage installs Go 1.14, LLVM 10 and the TinyGo compiler itself.
+FROM golang:1.14 AS tinygo-base
 
 RUN wget -O- https://apt.llvm.org/llvm-snapshot.gpg.key| apt-key add - && \
-    echo "deb http://apt.llvm.org/buster/ llvm-toolchain-buster-9 main" >> /etc/apt/sources.list && \
+    echo "deb http://apt.llvm.org/buster/ llvm-toolchain-buster-10 main" >> /etc/apt/sources.list && \
     apt-get update && \
-    apt-get install -y llvm-9-dev libclang-9-dev git
+    apt-get install -y llvm-10-dev libclang-10-dev git
 
 COPY . /tinygo
 
@@ -12,8 +12,11 @@ COPY . /tinygo
 # after copying the tinygo directory in the previous step.
 RUN cd /tinygo/ && \
     rm -rf ./lib/* && \
+    git submodule sync && \
     git submodule update --init --recursive --force
 
+COPY ./lib/picolibc-include/* /tinygo/lib/picolibc-include/
+
 RUN cd /tinygo/ && \
     go install /tinygo/
 
@@ -25,9 +28,9 @@ COPY --from=tinygo-base /tinygo/src /tinygo/src
 COPY --from=tinygo-base /tinygo/targets /tinygo/targets
 
 RUN wget -O- https://apt.llvm.org/llvm-snapshot.gpg.key| apt-key add - && \
-    echo "deb http://apt.llvm.org/buster/ llvm-toolchain-buster-9 main" >> /etc/apt/sources.list && \
+    echo "deb http://apt.llvm.org/buster/ llvm-toolchain-buster-10 main" >> /etc/apt/sources.list && \
     apt-get update && \
-    apt-get install -y libllvm9 lld-9
+    apt-get install -y libllvm10 lld-10
 
 # tinygo-avr stage installs the needed dependencies to compile TinyGo programs for AVR microcontrollers.
 FROM tinygo-base AS tinygo-avr
@@ -41,9 +44,8 @@ COPY --from=tinygo-base /tinygo/lib /tinygo/lib
 
 RUN cd /tinygo/ && \
     apt-get update && \
-    apt-get install -y apt-utils python3 make binutils-avr gcc-avr avr-libc && \
+    apt-get install -y apt-utils make binutils-avr gcc-avr avr-libc && \
     make gen-device-avr && \
-    apt-get remove -y python3 && \
     apt-get autoremove -y && \
     apt-get clean
 
@@ -59,11 +61,8 @@ COPY --from=tinygo-base /tinygo/lib /tinygo/lib
 
 RUN cd /tinygo/ && \
     apt-get update && \
-    apt-get install -y apt-utils python3 make clang-9 && \
-    make gen-device-nrf && make gen-device-stm32 && \
-    apt-get remove -y python3 && \
-    apt-get autoremove -y && \
-    apt-get clean
+    apt-get install -y apt-utils make clang-10 && \
+    make gen-device-nrf && make gen-device-stm32
 
 # tinygo-all stage installs the needed dependencies to compile TinyGo programs for all platforms.
 FROM tinygo-wasm AS tinygo-all
@@ -74,10 +73,7 @@ COPY --from=tinygo-base /tinygo/lib /tinygo/lib
 
 RUN cd /tinygo/ && \
     apt-get update && \
-    apt-get install -y apt-utils python3 make clang-9 binutils-avr gcc-avr avr-libc && \
-    make gen-device && \
-    apt-get remove -y python3 && \
-    apt-get autoremove -y && \
-    apt-get clean
+    apt-get install -y apt-utils make clang-10 binutils-avr gcc-avr avr-libc && \
+    make gen-device
 
 CMD ["tinygo"]

LICENSE

@@ -1,7 +1,10 @@
-Copyright (c) 2018-2019 TinyGo Authors. All rights reserved.
+Copyright (c) 2018-2020 TinyGo Authors. All rights reserved.
 
 TinyGo includes portions of the Go standard library.
-Copyright (c) 2009-2019 The Go Authors. All rights reserved.
+Copyright (c) 2009-2020 The Go Authors. All rights reserved.
+
+TinyGo includes portions of LLVM, which is under the Apache License v2.0 with
+LLVM Exceptions. See https://llvm.org/LICENSE.txt for license information.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are

Makefile

@@ -4,8 +4,30 @@ all: tinygo
 
 # Default build and source directories, as created by `make llvm-build`.
 LLVM_BUILDDIR ?= llvm-build
-CLANG_SRC ?= llvm-project/clang
-LLD_SRC ?= llvm-project/lld
+LLVM_PROJECTDIR ?= llvm-project
+CLANG_SRC ?= $(LLVM_PROJECTDIR)/clang
+LLD_SRC ?= $(LLVM_PROJECTDIR)/lld
+
+# Try to autodetect LLVM build tools.
+ifneq (, $(shell command -v llvm-build/bin/clang 2> /dev/null))
+    CLANG ?= $(abspath llvm-build/bin/clang)
+else
+    CLANG ?= clang-10
+endif
+ifneq (, $(shell command -v llvm-build/bin/llvm-ar 2> /dev/null))
+    LLVM_AR ?= $(abspath llvm-build/bin/llvm-ar)
+else ifneq (, $(shell command -v llvm-ar-10 2> /dev/null))
+    LLVM_AR ?= llvm-ar-10
+else
+    LLVM_AR ?= llvm-ar
+endif
+ifneq (, $(shell command -v llvm-build/bin/llvm-nm 2> /dev/null))
+    LLVM_NM ?= $(abspath llvm-build/bin/llvm-nm)
+else ifneq (, $(shell command -v llvm-nm-10 2> /dev/null))
+    LLVM_NM ?= llvm-nm-10
+else
+    LLVM_NM ?= llvm-nm
+endif
 
 # Go binary and GOROOT to select
 GO ?= go
@@ -14,14 +36,11 @@ export GOROOT = $(shell $(GO) env GOROOT)
 # md5sum binary
 MD5SUM = md5sum
 
-# Python binary
-PYTHON ?= python
-
 # tinygo binary for tests
 TINYGO ?= tinygo
 
 # Use CCACHE for LLVM if possible
-ifneq (, $(shell which ccache))
+ifneq (, $(shell command -v ccache 2> /dev/null))
     LLVM_OPTION += '-DLLVM_CCACHE_BUILD=ON'
 endif
 
@@ -34,7 +53,7 @@ endif
 
 .PHONY: all tinygo test $(LLVM_BUILDDIR) llvm-source clean fmt gen-device gen-device-nrf gen-device-avr
 
-LLVM_COMPONENTS = all-targets analysis asmparser asmprinter bitreader bitwriter codegen core coroutines debuginfodwarf executionengine instrumentation interpreter ipo irreader linker lto mc mcjit objcarcopts option profiledata scalaropts support target
+LLVM_COMPONENTS = all-targets analysis asmparser asmprinter bitreader bitwriter codegen core coroutines coverage debuginfodwarf executionengine frontendopenmp instrumentation interpreter ipo irreader linker lto mc mcjit objcarcopts option profiledata scalaropts support target
 
 ifeq ($(OS),Windows_NT)
     EXE = .exe
@@ -65,6 +84,11 @@ $(LIBCLANG_PATH): $(LIBCLANG_FILES)
 else ifeq ($(shell uname -s),Darwin)
     MD5SUM = md5
     LIBCLANG_PATH = $(abspath $(LLVM_BUILDDIR))/lib/libclang.a
+else ifeq ($(shell uname -s),FreeBSD)
+    MD5SUM = md5
+    LIBCLANG_PATH = $(abspath $(LLVM_BUILDDIR))/lib/libclang.a
+    START_GROUP = -Wl,--start-group
+    END_GROUP = -Wl,--end-group
 else
     LIBCLANG_PATH = $(abspath $(LLVM_BUILDDIR))/lib/libclang.a
     START_GROUP = -Wl,--start-group
@@ -78,9 +102,9 @@ LLD_LIBS = $(START_GROUP) -llldCOFF -llldCommon -llldCore -llldDriver -llldELF -
 
 # For static linking.
 ifneq ("$(wildcard $(LLVM_BUILDDIR)/bin/llvm-config*)","")
-    CGO_CPPFLAGS=$(shell $(LLVM_BUILDDIR)/bin/llvm-config --cppflags) -I$(abspath $(CLANG_SRC))/include -I$(abspath $(LLD_SRC))/include
-    CGO_CXXFLAGS=-std=c++11
-    CGO_LDFLAGS+=$(LIBCLANG_PATH) -std=c++11 -L$(abspath $(LLVM_BUILDDIR)/lib) $(CLANG_LIBS) $(LLD_LIBS) $(shell $(LLVM_BUILDDIR)/bin/llvm-config --ldflags --libs --system-libs $(LLVM_COMPONENTS)) -lstdc++ $(CGO_LDFLAGS_EXTRA)
+    CGO_CPPFLAGS=$(shell $(LLVM_BUILDDIR)/bin/llvm-config --cppflags) -I$(abspath $(LLVM_BUILDDIR))/tools/clang/include -I$(abspath $(CLANG_SRC))/include -I$(abspath $(LLD_SRC))/include
+    CGO_CXXFLAGS=-std=c++14
+    CGO_LDFLAGS+=$(LIBCLANG_PATH) -std=c++14 -L$(abspath $(LLVM_BUILDDIR)/lib) $(CLANG_LIBS) $(LLD_LIBS) $(shell $(LLVM_BUILDDIR)/bin/llvm-config --ldflags --libs --system-libs $(LLVM_COMPONENTS)) -lstdc++ $(CGO_LDFLAGS_EXTRA)
 endif
 
 
@@ -97,48 +121,59 @@ fmt-check:
 gen-device: gen-device-avr gen-device-nrf gen-device-sam gen-device-sifive gen-device-stm32
 
 gen-device-avr:
-	$(PYTHON) ./tools/gen-device-avr.py lib/avr/packs/atmega src/device/avr/
-	$(PYTHON) ./tools/gen-device-avr.py lib/avr/packs/tiny src/device/avr/
-	GO111MODULE=off $(GO) fmt ./src/device/avr
+	$(GO) build -o ./build/gen-device-avr ./tools/gen-device-avr/
+	./build/gen-device-avr lib/avr/packs/atmega src/device/avr/
+	./build/gen-device-avr lib/avr/packs/tiny src/device/avr/
+	@GO111MODULE=off $(GO) fmt ./src/device/avr
 
-gen-device-nrf:
-	$(PYTHON) ./tools/gen-device-svd.py lib/nrfx/mdk/ src/device/nrf/ --source=https://github.com/NordicSemiconductor/nrfx/tree/master/mdk
+build/gen-device-svd: ./tools/gen-device-svd/*.go
+	$(GO) build -o $@ ./tools/gen-device-svd/
+
+gen-device-nrf: build/gen-device-svd
+	./build/gen-device-svd -source=https://github.com/NordicSemiconductor/nrfx/tree/master/mdk lib/nrfx/mdk/ src/device/nrf/
 	GO111MODULE=off $(GO) fmt ./src/device/nrf
 
-gen-device-sam:
-	$(PYTHON) ./tools/gen-device-svd.py lib/cmsis-svd/data/Atmel/ src/device/sam/ --source=https://github.com/posborne/cmsis-svd/tree/master/data/Atmel
+gen-device-sam: build/gen-device-svd
+	./build/gen-device-svd -source=https://github.com/posborne/cmsis-svd/tree/master/data/Atmel lib/cmsis-svd/data/Atmel/ src/device/sam/
 	GO111MODULE=off $(GO) fmt ./src/device/sam
 
-gen-device-sifive:
-	$(PYTHON) ./tools/gen-device-svd.py lib/cmsis-svd/data/SiFive-Community/ src/device/sifive/ --source=https://github.com/posborne/cmsis-svd/tree/master/data/SiFive-Community
+gen-device-sifive: build/gen-device-svd
+	./build/gen-device-svd -source=https://github.com/posborne/cmsis-svd/tree/master/data/SiFive-Community -interrupts=software lib/cmsis-svd/data/SiFive-Community/ src/device/sifive/
 	GO111MODULE=off $(GO) fmt ./src/device/sifive
 
-gen-device-stm32:
-	$(PYTHON) ./tools/gen-device-svd.py lib/cmsis-svd/data/STMicro/ src/device/stm32/ --source=https://github.com/posborne/cmsis-svd/tree/master/data/STMicro
+gen-device-stm32: build/gen-device-svd
+	./build/gen-device-svd -source=https://github.com/posborne/cmsis-svd/tree/master/data/STMicro lib/cmsis-svd/data/STMicro/ src/device/stm32/
 	GO111MODULE=off $(GO) fmt ./src/device/stm32
 
 
 # Get LLVM sources.
-llvm-project/README.md:
-	git clone -b release/9.x https://github.com/llvm/llvm-project
-llvm-source: llvm-project/README.md
+$(LLVM_PROJECTDIR)/README.md:
+	git clone -b release/10.x https://github.com/llvm/llvm-project $(LLVM_PROJECTDIR)
+llvm-source: $(LLVM_PROJECTDIR)/README.md
 
 # Configure LLVM.
 TINYGO_SOURCE_DIR=$(shell pwd)
 $(LLVM_BUILDDIR)/build.ninja: llvm-source
-	mkdir -p $(LLVM_BUILDDIR); cd $(LLVM_BUILDDIR); cmake -G Ninja $(TINYGO_SOURCE_DIR)/llvm-project/llvm "-DLLVM_TARGETS_TO_BUILD=X86;ARM;AArch64;RISCV;WebAssembly" "-DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=AVR" -DCMAKE_BUILD_TYPE=Release -DLIBCLANG_BUILD_STATIC=ON -DLLVM_ENABLE_TERMINFO=OFF -DLLVM_ENABLE_ZLIB=OFF -DLLVM_ENABLE_PROJECTS="clang;lld" -DLLVM_TOOL_CLANG_TOOLS_EXTRA_BUILD=OFF $(LLVM_OPTION)
+	mkdir -p $(LLVM_BUILDDIR); cd $(LLVM_BUILDDIR); cmake -G Ninja $(TINYGO_SOURCE_DIR)/$(LLVM_PROJECTDIR)/llvm "-DLLVM_TARGETS_TO_BUILD=X86;ARM;AArch64;RISCV;WebAssembly" "-DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=AVR" -DCMAKE_BUILD_TYPE=Release -DLIBCLANG_BUILD_STATIC=ON -DLLVM_ENABLE_TERMINFO=OFF -DLLVM_ENABLE_ZLIB=OFF -DLLVM_ENABLE_PROJECTS="clang;lld" -DLLVM_TOOL_CLANG_TOOLS_EXTRA_BUILD=OFF $(LLVM_OPTION)
 
 # Build LLVM.
 $(LLVM_BUILDDIR): $(LLVM_BUILDDIR)/build.ninja
 	cd $(LLVM_BUILDDIR); ninja
 
 
+# Build wasi-libc sysroot
+.PHONY: wasi-libc
+wasi-libc: lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a
+lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a:
+	cd lib/wasi-libc && make -j4 WASM_CC=$(CLANG) WASM_AR=$(LLVM_AR) WASM_NM=$(LLVM_NM)
+
+
 # Build the Go compiler.
 tinygo:
 	@if [ ! -f "$(LLVM_BUILDDIR)/bin/llvm-config" ]; then echo "Fetch and build LLVM first by running:"; echo "  make llvm-source"; echo "  make $(LLVM_BUILDDIR)"; exit 1; fi
 	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) build -o build/tinygo$(EXE) -tags byollvm .
 
-test:
+test: wasi-libc
 	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test -v -tags byollvm ./cgo ./compileopts ./interp ./transform .
 
 tinygo-test:
@@ -179,6 +214,8 @@ smoketest:
 	# test simulated boards on play.tinygo.org
 	$(TINYGO) build             -o test.wasm -tags=arduino              examples/blinky1
 	@$(MD5SUM) test.wasm
+	$(TINYGO) build             -o test.wasm -tags=hifive1-qemu         examples/serial
+	@$(MD5SUM) test.wasm
 	$(TINYGO) build             -o test.wasm -tags=hifive1b             examples/blinky1
 	@$(MD5SUM) test.wasm
 	$(TINYGO) build             -o test.wasm -tags=reelboard            examples/blinky1
@@ -187,6 +224,8 @@ smoketest:
 	@$(MD5SUM) test.wasm
 	$(TINYGO) build             -o test.wasm -tags=pca10056             examples/blinky2
 	@$(MD5SUM) test.wasm
+	$(TINYGO) build             -o test.wasm -tags=circuitplay_express  examples/blinky1
+	@$(MD5SUM) test.wasm
 	# test all targets/boards
 	$(TINYGO) build -size short -o test.hex -target=pca10040-s132v6     examples/blinky1
 	@$(MD5SUM) test.hex
@@ -218,16 +257,30 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=stm32f4disco        examples/blinky2
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=circuitplay-bluefruit examples/blinky1
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=circuitplay-express examples/i2s
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=clue_alpha          examples/blinky1
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.gba -target=gameboy-advance     examples/gba-display
 	@$(MD5SUM) test.gba
 	$(TINYGO) build -size short -o test.hex -target=itsybitsy-m4        examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=feather-m4          examples/blinky1
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=pybadge             examples/blinky1
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=metro-m4-airlift    examples/blinky1
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=pyportal            examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=particle-argon      examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=particle-boron      examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=particle-xenon      examples/blinky1
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=nucleo-f103rb       examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pinetime-devkit0    examples/blinky1
@@ -236,25 +289,35 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10056-s140v7     examples/blinky1
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=reelboard-s140v7    examples/blinky1
+	@$(MD5SUM) test.hex
 ifneq ($(AVR), 0)
+	$(TINYGO) build -size short -o test.hex -target=atmega1284p         examples/serial
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=arduino             examples/blinky1
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=arduino -scheduler=tasks  examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=arduino-nano        examples/blinky1
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=digispark           examples/blinky1
 	@$(MD5SUM) test.hex
-endif
-ifneq ($(RISCV), 0)
-	$(TINYGO) build -size short -o test.hex -target=hifive1b            examples/blinky1
+	$(TINYGO) build -size short -o test.hex -target=digispark -gc=leaking examples/blinky1
 	@$(MD5SUM) test.hex
 endif
+	$(TINYGO) build -size short -o test.hex -target=hifive1b            examples/blinky1
+	@$(MD5SUM) test.hex
 	$(TINYGO) build             -o wasm.wasm -target=wasm               examples/wasm/export
 	$(TINYGO) build             -o wasm.wasm -target=wasm               examples/wasm/main
 
-release: tinygo gen-device
+release: tinygo gen-device wasi-libc
 	@mkdir -p build/release/tinygo/bin
 	@mkdir -p build/release/tinygo/lib/clang/include
 	@mkdir -p build/release/tinygo/lib/CMSIS/CMSIS
 	@mkdir -p build/release/tinygo/lib/compiler-rt/lib
 	@mkdir -p build/release/tinygo/lib/nrfx
+	@mkdir -p build/release/tinygo/lib/picolibc/newlib/libc
+	@mkdir -p build/release/tinygo/lib/wasi-libc
 	@mkdir -p build/release/tinygo/pkg/armv6m-none-eabi
 	@mkdir -p build/release/tinygo/pkg/armv7m-none-eabi
 	@mkdir -p build/release/tinygo/pkg/armv7em-none-eabi
@@ -267,9 +330,19 @@ release: tinygo gen-device
 	@cp -rp lib/compiler-rt/LICENSE.TXT  build/release/tinygo/lib/compiler-rt
 	@cp -rp lib/compiler-rt/README.txt   build/release/tinygo/lib/compiler-rt
 	@cp -rp lib/nrfx/*                   build/release/tinygo/lib/nrfx
+	@cp -rp lib/picolibc/newlib/libc/ctype       build/release/tinygo/lib/picolibc/newlib/libc
+	@cp -rp lib/picolibc/newlib/libc/include     build/release/tinygo/lib/picolibc/newlib/libc
+	@cp -rp lib/picolibc/newlib/libc/locale      build/release/tinygo/lib/picolibc/newlib/libc
+	@cp -rp lib/picolibc/newlib/libc/string      build/release/tinygo/lib/picolibc/newlib/libc
+	@cp -rp lib/picolibc/newlib/libc/tinystdio   build/release/tinygo/lib/picolibc/newlib/libc
+	@cp -rp lib/picolibc-include         build/release/tinygo/lib
+	@cp -rp lib/wasi-libc/sysroot        build/release/tinygo/lib/wasi-libc/sysroot
 	@cp -rp src                          build/release/tinygo/src
 	@cp -rp targets                      build/release/tinygo/targets
-	./build/tinygo build-builtins -target=armv6m-none-eabi  -o build/release/tinygo/pkg/armv6m-none-eabi/compiler-rt.a
-	./build/tinygo build-builtins -target=armv7m-none-eabi  -o build/release/tinygo/pkg/armv7m-none-eabi/compiler-rt.a
-	./build/tinygo build-builtins -target=armv7em-none-eabi -o build/release/tinygo/pkg/armv7em-none-eabi/compiler-rt.a
+	./build/tinygo build-library -target=armv6m-none-eabi  -o build/release/tinygo/pkg/armv6m-none-eabi/compiler-rt.a compiler-rt
+	./build/tinygo build-library -target=armv7m-none-eabi  -o build/release/tinygo/pkg/armv7m-none-eabi/compiler-rt.a compiler-rt
+	./build/tinygo build-library -target=armv7em-none-eabi -o build/release/tinygo/pkg/armv7em-none-eabi/compiler-rt.a compiler-rt
+	./build/tinygo build-library -target=armv6m-none-eabi  -o build/release/tinygo/pkg/armv6m-none-eabi/picolibc.a picolibc
+	./build/tinygo build-library -target=armv7m-none-eabi  -o build/release/tinygo/pkg/armv7m-none-eabi/picolibc.a picolibc
+	./build/tinygo build-library -target=armv7em-none-eabi -o build/release/tinygo/pkg/armv7em-none-eabi/picolibc.a picolibc
 	tar -czf build/release.tar.gz -C build/release tinygo

README.md

@@ -43,15 +43,21 @@ See the [getting started instructions](https://tinygo.org/getting-started/) for
 
 You can compile TinyGo programs for microcontrollers, WebAssembly and Linux.
 
-The following 22 microcontroller boards are currently supported:
+The following 32 microcontroller boards are currently supported:
 
+* [Adafruit Circuit Playground Bluefruit](https://www.adafruit.com/product/4333)
 * [Adafruit Circuit Playground Express](https://www.adafruit.com/product/3333)
+* [Adafruit CLUE Alpha](https://www.adafruit.com/product/4500)
 * [Adafruit Feather M0](https://www.adafruit.com/product/2772)
 * [Adafruit Feather M4](https://www.adafruit.com/product/3857)
 * [Adafruit ItsyBitsy M0](https://www.adafruit.com/product/3727)
 * [Adafruit ItsyBitsy M4](https://www.adafruit.com/product/3800)
 * [Adafruit Metro M4 Express Airlift](https://www.adafruit.com/product/4000)
+* [Adafruit PyBadge](https://www.adafruit.com/product/4200)
+* [Adafruit PyPortal](https://www.adafruit.com/product/4116)
 * [Adafruit Trinket M0](https://www.adafruit.com/product/3500)
+* [Arduino Mega 2560](https://store.arduino.cc/arduino-mega-2560-rev3)
+* [Arduino Nano](https://store.arduino.cc/arduino-nano)
 * [Arduino Nano33 IoT](https://store.arduino.cc/nano-33-iot)
 * [Arduino Uno](https://store.arduino.cc/arduino-uno-rev3)
 * [BBC micro:bit](https://microbit.org/)
@@ -61,7 +67,11 @@ The following 22 microcontroller boards are currently supported:
 * [Nordic Semiconductor PCA10031](https://www.nordicsemi.com/eng/Products/nRF51-Dongle)
 * [Nordic Semiconductor PCA10040](https://www.nordicsemi.com/eng/Products/Bluetooth-low-energy/nRF52-DK)
 * [Nordic Semiconductor PCA10056](https://www.nordicsemi.com/Software-and-Tools/Development-Kits/nRF52840-DK)
+* [Particle Argon](https://docs.particle.io/datasheets/wi-fi/argon-datasheet/)
+* [Particle Boron](https://docs.particle.io/datasheets/cellular/boron-datasheet/)
+* [Particle Xenon](https://docs.particle.io/datasheets/discontinued/xenon-datasheet/)
 * [Phytec reel board](https://www.phytec.eu/product-eu/internet-of-things/reelboard/)
+* [PineTime DevKit](https://www.pine64.org/pinetime/)
 * [SiFIve HiFive1](https://www.sifive.com/boards/hifive1)
 * [ST Micro "Nucleo F103RB"](https://www.st.com/en/evaluation-tools/nucleo-f103rb.html)
 * [ST Micro STM32F103XX "Bluepill"](http://wiki.stm32duino.com/index.php?title=Blue_Pill)
@@ -125,3 +135,5 @@ The original reasoning was: if [Python](https://micropython.org/) can run on mic
 ## License
 
 This project is licensed under the BSD 3-clause license, just like the [Go project](https://golang.org/LICENSE) itself.
+
+Some code has been copied from the LLVM project and is therefore licensed under [a variant of the Apache 2.0 license](http://releases.llvm.org/10.0.0/LICENSE.TXT). This has been clearly indicated in the header of these files.

azure-pipelines.yml

@@ -6,15 +6,18 @@ trigger:
 
 jobs:
 - job: Build
-  timeoutInMinutes: 180
+  timeoutInMinutes: 240 # 4h
   pool:
     vmImage: 'VS2017-Win2016'
   steps:
+    - task: GoTool@0
+      inputs:
+        version: '1.14.1'
     - checkout: self
     - task: CacheBeta@0
       displayName: Cache LLVM source
       inputs:
-        key: llvm-source-9-windows-v0
+        key: llvm-source-10-windows-v0
         path: llvm-project
     - task: Bash@3
       displayName: Download LLVM source
@@ -24,7 +27,7 @@ jobs:
     - task: CacheBeta@0
       displayName: Cache LLVM build
       inputs:
-        key: llvm-build-9-windows-v0
+        key: llvm-build-10-windows-v0
         path: llvm-build
     - task: Bash@3
       displayName: Build LLVM
@@ -34,10 +37,6 @@ jobs:
           if [ ! -f llvm-build/lib/liblldELF.a ]
           then
             choco install ninja
-            # LLVM 9 cannot be built with MinGW 8.
-            # For details: https://reviews.llvm.org/D70266
-            choco uninstall mingw
-            choco install mingw --version=7.3.0
             make llvm-build
           fi
     - task: Bash@3
@@ -45,12 +44,22 @@ jobs:
       inputs:
         targetType: inline
         script: choco install qemu
+    - task: CacheBeta@0
+      displayName: Cache wasi-libc sysroot
+      inputs:
+        key: wasi-libc-sysroot-v2
+        path: lib/wasi-libc/sysroot
+    - task: Bash@3
+      displayName: Build wasi-libc
+      inputs:
+        targetType: inline
+        script: PATH=/usr/bin:$PATH make wasi-libc
     - task: Bash@3
       displayName: Test TinyGo
       inputs:
         targetType: inline
         script: |
-          export PATH="/c/Go1.13/bin:$PATH:./llvm-build/bin:/c/Program Files/qemu"
+          export PATH="$PATH:./llvm-build/bin:/c/Program Files/qemu"
           unset GOROOT
           make test
     - task: Bash@3
@@ -58,17 +67,17 @@ jobs:
       inputs:
         targetType: inline
         script: |
-          export PATH="/c/Go1.13/bin:$PATH:./llvm-build/bin:/c/Program Files/qemu"
+          export PATH="$PATH:./llvm-build/bin:/c/Program Files/qemu"
           unset GOROOT
           make release -j4
-    - publish: $(System.DefaultWorkingDirectory)/build/release.tar.gz
-      displayName: Publish tarball as artifact
-      artifact: tinygo.windows-amd64.tar.gz
+    - publish: $(System.DefaultWorkingDirectory)/build/release/tinygo
+      displayName: Publish zip as artifact
+      artifact: tinygo
     - task: Bash@3
       displayName: Smoke tests
       inputs:
         targetType: inline
         script: |
-          export PATH="/c/Go1.13/bin:$PATH:./llvm-build/bin:/c/Program Files/qemu"
+          export PATH="$PATH:./llvm-build/bin:/c/Program Files/qemu"
           unset GOROOT
-          make smoketest TINYGO=build/tinygo AVR=0 RISCV=0
+          make smoketest TINYGO=build/tinygo AVR=0

builder/build.go

@@ -16,6 +16,8 @@ import (
 	"github.com/tinygo-org/tinygo/compiler"
 	"github.com/tinygo-org/tinygo/goenv"
 	"github.com/tinygo-org/tinygo/interp"
+	"github.com/tinygo-org/tinygo/transform"
+	"tinygo.org/x/go-llvm"
 )
 
 // Build performs a single package to executable Go build. It takes in a package
@@ -25,37 +27,34 @@ import (
 // The error value may be of type *MultiError. Callers will likely want to check
 // for this case and print such errors individually.
 func Build(pkgName, outpath string, config *compileopts.Config, action func(string) error) error {
-	c, err := compiler.NewCompiler(pkgName, config)
+	// Compile Go code to IR.
+	machine, err := compiler.NewTargetMachine(config)
 	if err != nil {
 		return err
 	}
-
-	// Compile Go code to IR.
-	errs := c.Compile(pkgName)
-	if len(errs) != 0 {
-		if len(errs) == 1 {
-			return errs[0]
-		}
-		return &MultiError{errs}
+	mod, extraFiles, errs := compiler.Compile(pkgName, machine, config)
+	if errs != nil {
+		return newMultiError(errs)
 	}
+
 	if config.Options.PrintIR {
 		fmt.Println("; Generated LLVM IR:")
-		fmt.Println(c.IR())
+		fmt.Println(mod.String())
 	}
-	if err := c.Verify(); err != nil {
+	if err := llvm.VerifyModule(mod, llvm.PrintMessageAction); err != nil {
 		return errors.New("verification error after IR construction")
 	}
 
-	err = interp.Run(c.Module(), config.DumpSSA())
+	err = interp.Run(mod, config.DumpSSA())
 	if err != nil {
 		return err
 	}
-	if err := c.Verify(); err != nil {
+	if err := llvm.VerifyModule(mod, llvm.PrintMessageAction); err != nil {
 		return errors.New("verification error after interpreting runtime.initAll")
 	}
 
 	if config.GOOS() != "darwin" {
-		c.ApplyFunctionSections() // -ffunction-sections
+		transform.ApplyFunctionSections(mod) // -ffunction-sections
 	}
 
 	// Browsers cannot handle external functions that have type i64 because it
@@ -64,7 +63,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(stri
 	// stack-allocated values.
 	// Use -wasm-abi=generic to disable this behaviour.
 	if config.Options.WasmAbi == "js" && strings.HasPrefix(config.Triple(), "wasm") {
-		err := c.ExternalInt64AsPtr()
+		err := transform.ExternalInt64AsPtr(mod)
 		if err != nil {
 			return err
 		}
@@ -72,24 +71,25 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(stri
 
 	// Optimization levels here are roughly the same as Clang, but probably not
 	// exactly.
+	errs = nil
 	switch config.Options.Opt {
-	case "none:", "0":
-		err = c.Optimize(0, 0, 0) // -O0
+	case "none", "0":
+		errs = transform.Optimize(mod, config, 0, 0, 0) // -O0
 	case "1":
-		err = c.Optimize(1, 0, 0) // -O1
+		errs = transform.Optimize(mod, config, 1, 0, 0) // -O1
 	case "2":
-		err = c.Optimize(2, 0, 225) // -O2
+		errs = transform.Optimize(mod, config, 2, 0, 225) // -O2
 	case "s":
-		err = c.Optimize(2, 1, 225) // -Os
+		errs = transform.Optimize(mod, config, 2, 1, 225) // -Os
 	case "z":
-		err = c.Optimize(2, 2, 5) // -Oz, default
+		errs = transform.Optimize(mod, config, 2, 2, 5) // -Oz, default
 	default:
-		err = errors.New("unknown optimization level: -opt=" + config.Options.Opt)
+		errs = []error{errors.New("unknown optimization level: -opt=" + config.Options.Opt)}
 	}
-	if err != nil {
-		return err
+	if len(errs) > 0 {
+		return newMultiError(errs)
 	}
-	if err := c.Verify(); err != nil {
+	if err := llvm.VerifyModule(mod, llvm.PrintMessageAction); err != nil {
 		return errors.New("verification failure after LLVM optimization passes")
 	}
 
@@ -99,8 +99,8 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(stri
 	// pointers are flash and which are in RAM so that pointers can have a
 	// correct address space parameter (address space 1 is for flash).
 	if strings.HasPrefix(config.Triple(), "avr") {
-		c.NonConstGlobals()
-		if err := c.Verify(); err != nil {
+		transform.NonConstGlobals(mod)
+		if err := llvm.VerifyModule(mod, llvm.PrintMessageAction); err != nil {
 			return errors.New("verification error after making all globals non-constant on AVR")
 		}
 	}
@@ -109,11 +109,17 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(stri
 	outext := filepath.Ext(outpath)
 	switch outext {
 	case ".o":
-		return c.EmitObject(outpath)
+		llvmBuf, err := machine.EmitToMemoryBuffer(mod, llvm.ObjectFile)
+		if err != nil {
+			return err
+		}
+		return ioutil.WriteFile(outpath, llvmBuf.Bytes(), 0666)
 	case ".bc":
-		return c.EmitBitcode(outpath)
+		data := llvm.WriteBitcodeToMemoryBuffer(mod).Bytes()
+		return ioutil.WriteFile(outpath, data, 0666)
 	case ".ll":
-		return c.EmitText(outpath)
+		data := []byte(mod.String())
+		return ioutil.WriteFile(outpath, data, 0666)
 	default:
 		// Act as a compiler driver.
 
@@ -126,39 +132,45 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(stri
 
 		// Write the object file.
 		objfile := filepath.Join(dir, "main.o")
-		err = c.EmitObject(objfile)
+		llvmBuf, err := machine.EmitToMemoryBuffer(mod, llvm.ObjectFile)
 		if err != nil {
 			return err
 		}
-
-		// Load builtins library from the cache, possibly compiling it on the
-		// fly.
-		var librt string
-		if config.Target.RTLib == "compiler-rt" {
-			librt, err = loadBuiltins(config.Triple())
-			if err != nil {
-				return err
-			}
+		err = ioutil.WriteFile(objfile, llvmBuf.Bytes(), 0666)
+		if err != nil {
+			return err
 		}
 
 		// Prepare link command.
 		executable := filepath.Join(dir, "main")
 		tmppath := executable // final file
 		ldflags := append(config.LDFlags(), "-o", executable, objfile)
+
+		// Load builtins library from the cache, possibly compiling it on the
+		// fly.
 		if config.Target.RTLib == "compiler-rt" {
+			librt, err := CompilerRT.Load(config.Triple())
+			if err != nil {
+				return err
+			}
 			ldflags = append(ldflags, librt)
 		}
 
+		// Add libc.
+		if config.Target.Libc == "picolibc" {
+			libc, err := Picolibc.Load(config.Triple())
+			if err != nil {
+				return err
+			}
+			ldflags = append(ldflags, libc)
+		}
+
 		// Compile extra files.
 		root := goenv.Get("TINYGOROOT")
 		for i, path := range config.ExtraFiles() {
 			abspath := filepath.Join(root, path)
 			outpath := filepath.Join(dir, "extra-"+strconv.Itoa(i)+"-"+filepath.Base(path)+".o")
-			cmdNames := []string{config.Target.Compiler}
-			if names, ok := commands[config.Target.Compiler]; ok {
-				cmdNames = names
-			}
-			err := execCommand(cmdNames, append(config.CFlags(), "-c", "-o", outpath, abspath)...)
+			err := runCCompiler(config.Target.Compiler, append(config.CFlags(), "-c", "-o", outpath, abspath)...)
 			if err != nil {
 				return &commandError{"failed to build", path, err}
 			}
@@ -166,20 +178,13 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(stri
 		}
 
 		// Compile C files in packages.
-		for i, pkg := range c.Packages() {
-			for _, file := range pkg.CFiles {
-				path := filepath.Join(pkg.Package.Dir, file)
-				outpath := filepath.Join(dir, "pkg"+strconv.Itoa(i)+"-"+file+".o")
-				cmdNames := []string{config.Target.Compiler}
-				if names, ok := commands[config.Target.Compiler]; ok {
-					cmdNames = names
-				}
-				err := execCommand(cmdNames, append(config.CFlags(), "-c", "-o", outpath, path)...)
-				if err != nil {
-					return &commandError{"failed to build", path, err}
-				}
-				ldflags = append(ldflags, outpath)
+		for i, file := range extraFiles {
+			outpath := filepath.Join(dir, "pkg"+strconv.Itoa(i)+"-"+filepath.Base(file)+".o")
+			err := runCCompiler(config.Target.Compiler, append(config.CFlags(), "-c", "-o", outpath, file)...)
+			if err != nil {
+				return &commandError{"failed to build", file, err}
 			}
+			ldflags = append(ldflags, outpath)
 		}
 
 		// Link the object files together.
@@ -217,7 +222,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(stri
 		} else if outext == ".uf2" {
 			// Get UF2 from the .elf file.
 			tmppath = filepath.Join(dir, "main"+outext)
-			err := convertELFFileToUF2File(executable, tmppath)
+			err := convertELFFileToUF2File(executable, tmppath, config.Target.UF2FamilyID)
 			if err != nil {
 				return err
 			}

builder/builtins.go

@@ -1,12 +1,7 @@
 package builder
 
 import (
-	"io/ioutil"
-	"os"
-	"path/filepath"
 	"strings"
-
-	"github.com/tinygo-org/tinygo/goenv"
 )
 
 // These are the GENERIC_SOURCES according to CMakeList.txt.
@@ -156,101 +151,20 @@ var aeabiBuiltins = []string{
 	"arm/aeabi_uldivmod.S",
 }
 
-func builtinFiles(target string) []string {
-	builtins := append([]string{}, genericBuiltins...) // copy genericBuiltins
-	if strings.HasPrefix(target, "arm") {
-		builtins = append(builtins, aeabiBuiltins...)
-	}
-	return builtins
-}
-
-// builtinsDir returns the directory where the sources for compiler-rt are kept.
-func builtinsDir() string {
-	return filepath.Join(goenv.Get("TINYGOROOT"), "lib", "compiler-rt", "lib", "builtins")
-}
-
-// Get the builtins archive, possibly generating it as needed.
-func loadBuiltins(target string) (path string, err error) {
-	// Try to load a precompiled compiler-rt library.
-	precompiledPath := filepath.Join(goenv.Get("TINYGOROOT"), "pkg", target, "compiler-rt.a")
-	if _, err := os.Stat(precompiledPath); err == nil {
-		// Found a precompiled compiler-rt for this OS/architecture. Return the
-		// path directly.
-		return precompiledPath, nil
-	}
-
-	outfile := "librt-" + target + ".a"
-	builtinsDir := builtinsDir()
-
-	builtins := builtinFiles(target)
-	srcs := make([]string, len(builtins))
-	for i, name := range builtins {
-		srcs[i] = filepath.Join(builtinsDir, name)
-	}
-
-	if path, err := cacheLoad(outfile, commands["clang"][0], srcs); path != "" || err != nil {
-		return path, err
-	}
-
-	var cachepath string
-	err = CompileBuiltins(target, func(path string) error {
-		path, err := cacheStore(path, outfile, commands["clang"][0], srcs)
-		cachepath = path
-		return err
-	})
-	return cachepath, err
-}
-
-// CompileBuiltins compiles builtins from compiler-rt into a static library.
-// When it succeeds, it will call the callback with the resulting path. The path
-// will be removed after callback returns. If callback returns an error, this is
-// passed through to the return value of this function.
-func CompileBuiltins(target string, callback func(path string) error) error {
-	builtinsDir := builtinsDir()
-
-	builtins := builtinFiles(target)
-	srcs := make([]string, len(builtins))
-	for i, name := range builtins {
-		srcs[i] = filepath.Join(builtinsDir, name)
-	}
-
-	dirPrefix := "tinygo-builtins"
-	remapDir := filepath.Join(os.TempDir(), dirPrefix)
-	dir, err := ioutil.TempDir(os.TempDir(), dirPrefix)
-	if err != nil {
-		return err
-	}
-	defer os.RemoveAll(dir)
-
-	// Compile all builtins.
-	// TODO: use builtins optimized for a given target if available.
-	objs := make([]string, 0, len(builtins))
-	for _, name := range builtins {
-		objname := name
-		if strings.LastIndexByte(objname, '/') >= 0 {
-			objname = objname[strings.LastIndexByte(objname, '/'):]
+// CompilerRT is a library with symbols required by programs compiled with LLVM.
+// These symbols are for operations that cannot be emitted with a single
+// instruction or a short sequence of instructions for that target.
+//
+// For more information, see: https://compiler-rt.llvm.org/
+var CompilerRT = Library{
+	name:      "compiler-rt",
+	cflags:    func() []string { return []string{"-Werror", "-Wall", "-std=c11", "-nostdlibinc"} },
+	sourceDir: "lib/compiler-rt/lib/builtins",
+	sources: func(target string) []string {
+		builtins := append([]string{}, genericBuiltins...) // copy genericBuiltins
+		if strings.HasPrefix(target, "arm") || strings.HasPrefix(target, "thumb") {
+			builtins = append(builtins, aeabiBuiltins...)
 		}
-		objpath := filepath.Join(dir, objname+".o")
-		objs = append(objs, objpath)
-		srcpath := filepath.Join(builtinsDir, name)
-		// Note: -fdebug-prefix-map is necessary to make the output archive
-		// reproducible. Otherwise the temporary directory is stored in the
-		// archive itself, which varies each run.
-		err := execCommand(commands["clang"], "-c", "-Oz", "-g", "-Werror", "-Wall", "-std=c11", "-fshort-enums", "-nostdlibinc", "-ffunction-sections", "-fdata-sections", "--target="+target, "-fdebug-prefix-map="+dir+"="+remapDir, "-o", objpath, srcpath)
-		if err != nil {
-			return &commandError{"failed to build", srcpath, err}
-		}
-	}
-
-	// Put all the object files in a single archive. This archive file will be
-	// used to statically link compiler-rt.
-	arpath := filepath.Join(dir, "librt.a")
-	err = makeArchive(arpath, objs)
-	if err != nil {
-		return err
-	}
-
-	// Give the caller the resulting file. The callback must copy the file,
-	// because after it returns the temporary directory will be removed.
-	return callback(arpath)
+		return builtins
+	},
 }

builder/cc1as.cpp

@@ -0,0 +1,510 @@
+// +build byollvm
+
+//===-- cc1as.cpp - Clang Assembler  --------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This is the entry point to the clang -cc1as functionality, which implements
+// the direct interface to the LLVM MC based assembler.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/DiagnosticOptions.h"
+#include "clang/Driver/DriverDiagnostic.h"
+#include "clang/Driver/Options.h"
+#include "clang/Frontend/FrontendDiagnostic.h"
+#include "clang/Frontend/TextDiagnosticPrinter.h"
+#include "clang/Frontend/Utils.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringSwitch.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/IR/DataLayout.h"
+#include "llvm/MC/MCAsmBackend.h"
+#include "llvm/MC/MCAsmInfo.h"
+#include "llvm/MC/MCCodeEmitter.h"
+#include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCInstrInfo.h"
+#include "llvm/MC/MCObjectFileInfo.h"
+#include "llvm/MC/MCObjectWriter.h"
+#include "llvm/MC/MCParser/MCAsmParser.h"
+#include "llvm/MC/MCParser/MCTargetAsmParser.h"
+#include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/MC/MCSectionMachO.h"
+#include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/MC/MCTargetOptions.h"
+#include "llvm/Option/Arg.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Option/OptTable.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/FormattedStream.h"
+#include "llvm/Support/Host.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/Process.h"
+#include "llvm/Support/Signals.h"
+#include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/TargetRegistry.h"
+#include "llvm/Support/TargetSelect.h"
+#include "llvm/Support/Timer.h"
+#include "llvm/Support/raw_ostream.h"
+#include <memory>
+#include <system_error>
+using namespace clang;
+using namespace clang::driver;
+using namespace clang::driver::options;
+using namespace llvm;
+using namespace llvm::opt;
+
+#include "cc1as.h"
+
+bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
+                                         ArrayRef<const char *> Argv,
+                                         DiagnosticsEngine &Diags) {
+  bool Success = true;
+
+  // Parse the arguments.
+  const OptTable &OptTbl = getDriverOptTable();
+
+  const unsigned IncludedFlagsBitmask = options::CC1AsOption;
+  unsigned MissingArgIndex, MissingArgCount;
+  InputArgList Args = OptTbl.ParseArgs(Argv, MissingArgIndex, MissingArgCount,
+                                       IncludedFlagsBitmask);
+
+  // Check for missing argument error.
+  if (MissingArgCount) {
+    Diags.Report(diag::err_drv_missing_argument)
+        << Args.getArgString(MissingArgIndex) << MissingArgCount;
+    Success = false;
+  }
+
+  // Issue errors on unknown arguments.
+  for (const Arg *A : Args.filtered(OPT_UNKNOWN)) {
+    auto ArgString = A->getAsString(Args);
+    std::string Nearest;
+    if (OptTbl.findNearest(ArgString, Nearest, IncludedFlagsBitmask) > 1)
+      Diags.Report(diag::err_drv_unknown_argument) << ArgString;
+    else
+      Diags.Report(diag::err_drv_unknown_argument_with_suggestion)
+          << ArgString << Nearest;
+    Success = false;
+  }
+
+  // Construct the invocation.
+
+  // Target Options
+  Opts.Triple = llvm::Triple::normalize(Args.getLastArgValue(OPT_triple));
+  Opts.CPU = Args.getLastArgValue(OPT_target_cpu);
+  Opts.Features = Args.getAllArgValues(OPT_target_feature);
+
+  // Use the default target triple if unspecified.
+  if (Opts.Triple.empty())
+    Opts.Triple = llvm::sys::getDefaultTargetTriple();
+
+  // Language Options
+  Opts.IncludePaths = Args.getAllArgValues(OPT_I);
+  Opts.NoInitialTextSection = Args.hasArg(OPT_n);
+  Opts.SaveTemporaryLabels = Args.hasArg(OPT_msave_temp_labels);
+  // Any DebugInfoKind implies GenDwarfForAssembly.
+  Opts.GenDwarfForAssembly = Args.hasArg(OPT_debug_info_kind_EQ);
+
+  if (const Arg *A = Args.getLastArg(OPT_compress_debug_sections,
+                                     OPT_compress_debug_sections_EQ)) {
+    if (A->getOption().getID() == OPT_compress_debug_sections) {
+      // TODO: be more clever about the compression type auto-detection
+      Opts.CompressDebugSections = llvm::DebugCompressionType::GNU;
+    } else {
+      Opts.CompressDebugSections =
+          llvm::StringSwitch<llvm::DebugCompressionType>(A->getValue())
+              .Case("none", llvm::DebugCompressionType::None)
+              .Case("zlib", llvm::DebugCompressionType::Z)
+              .Case("zlib-gnu", llvm::DebugCompressionType::GNU)
+              .Default(llvm::DebugCompressionType::None);
+    }
+  }
+
+  Opts.RelaxELFRelocations = Args.hasArg(OPT_mrelax_relocations);
+  Opts.DwarfVersion = getLastArgIntValue(Args, OPT_dwarf_version_EQ, 2, Diags);
+  Opts.DwarfDebugFlags = Args.getLastArgValue(OPT_dwarf_debug_flags);
+  Opts.DwarfDebugProducer = Args.getLastArgValue(OPT_dwarf_debug_producer);
+  Opts.DebugCompilationDir = Args.getLastArgValue(OPT_fdebug_compilation_dir);
+  Opts.MainFileName = Args.getLastArgValue(OPT_main_file_name);
+
+  for (const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ))
+    Opts.DebugPrefixMap.insert(StringRef(Arg).split('='));
+
+  // Frontend Options
+  if (Args.hasArg(OPT_INPUT)) {
+    bool First = true;
+    for (const Arg *A : Args.filtered(OPT_INPUT)) {
+      if (First) {
+        Opts.InputFile = A->getValue();
+        First = false;
+      } else {
+        Diags.Report(diag::err_drv_unknown_argument) << A->getAsString(Args);
+        Success = false;
+      }
+    }
+  }
+  Opts.LLVMArgs = Args.getAllArgValues(OPT_mllvm);
+  Opts.OutputPath = Args.getLastArgValue(OPT_o);
+  Opts.SplitDwarfOutput = Args.getLastArgValue(OPT_split_dwarf_output);
+  if (Arg *A = Args.getLastArg(OPT_filetype)) {
+    StringRef Name = A->getValue();
+    unsigned OutputType = StringSwitch<unsigned>(Name)
+      .Case("asm", FT_Asm)
+      .Case("null", FT_Null)
+      .Case("obj", FT_Obj)
+      .Default(~0U);
+    if (OutputType == ~0U) {
+      Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
+      Success = false;
+    } else
+      Opts.OutputType = FileType(OutputType);
+  }
+  Opts.ShowHelp = Args.hasArg(OPT_help);
+  Opts.ShowVersion = Args.hasArg(OPT_version);
+
+  // Transliterate Options
+  Opts.OutputAsmVariant =
+      getLastArgIntValue(Args, OPT_output_asm_variant, 0, Diags);
+  Opts.ShowEncoding = Args.hasArg(OPT_show_encoding);
+  Opts.ShowInst = Args.hasArg(OPT_show_inst);
+
+  // Assemble Options
+  Opts.RelaxAll = Args.hasArg(OPT_mrelax_all);
+  Opts.NoExecStack = Args.hasArg(OPT_mno_exec_stack);
+  Opts.FatalWarnings = Args.hasArg(OPT_massembler_fatal_warnings);
+  Opts.NoWarn = Args.hasArg(OPT_massembler_no_warn);
+  Opts.RelocationModel = Args.getLastArgValue(OPT_mrelocation_model, "pic");
+  Opts.TargetABI = Args.getLastArgValue(OPT_target_abi);
+  Opts.IncrementalLinkerCompatible =
+      Args.hasArg(OPT_mincremental_linker_compatible);
+  Opts.SymbolDefs = Args.getAllArgValues(OPT_defsym);
+
+  // EmbedBitcode Option. If -fembed-bitcode is enabled, set the flag.
+  // EmbedBitcode behaves the same for all embed options for assembly files.
+  if (auto *A = Args.getLastArg(OPT_fembed_bitcode_EQ)) {
+    Opts.EmbedBitcode = llvm::StringSwitch<unsigned>(A->getValue())
+                            .Case("all", 1)
+                            .Case("bitcode", 1)
+                            .Case("marker", 1)
+                            .Default(0);
+  }
+
+  return Success;
+}
+
+static std::unique_ptr<raw_fd_ostream>
+getOutputStream(StringRef Path, DiagnosticsEngine &Diags, bool Binary) {
+  // Make sure that the Out file gets unlinked from the disk if we get a
+  // SIGINT.
+  if (Path != "-")
+    sys::RemoveFileOnSignal(Path);
+
+  std::error_code EC;
+  auto Out = std::make_unique<raw_fd_ostream>(
+      Path, EC, (Binary ? sys::fs::OF_None : sys::fs::OF_Text));
+  if (EC) {
+    Diags.Report(diag::err_fe_unable_to_open_output) << Path << EC.message();
+    return nullptr;
+  }
+
+  return Out;
+}
+
+bool ExecuteAssembler(AssemblerInvocation &Opts, DiagnosticsEngine &Diags) {
+  // Get the target specific parser.
+  std::string Error;
+  const Target *TheTarget = TargetRegistry::lookupTarget(Opts.Triple, Error);
+  if (!TheTarget)
+    return Diags.Report(diag::err_target_unknown_triple) << Opts.Triple;
+
+  ErrorOr<std::unique_ptr<MemoryBuffer>> Buffer =
+      MemoryBuffer::getFileOrSTDIN(Opts.InputFile);
+
+  if (std::error_code EC = Buffer.getError()) {
+    Error = EC.message();
+    return Diags.Report(diag::err_fe_error_reading) << Opts.InputFile;
+  }
+
+  SourceMgr SrcMgr;
+
+  // Tell SrcMgr about this buffer, which is what the parser will pick up.
+  unsigned BufferIndex = SrcMgr.AddNewSourceBuffer(std::move(*Buffer), SMLoc());
+
+  // Record the location of the include directories so that the lexer can find
+  // it later.
+  SrcMgr.setIncludeDirs(Opts.IncludePaths);
+
+  std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(Opts.Triple));
+  assert(MRI && "Unable to create target register info!");
+
+  MCTargetOptions MCOptions;
+  std::unique_ptr<MCAsmInfo> MAI(
+      TheTarget->createMCAsmInfo(*MRI, Opts.Triple, MCOptions));
+  assert(MAI && "Unable to create target asm info!");
+
+  // Ensure MCAsmInfo initialization occurs before any use, otherwise sections
+  // may be created with a combination of default and explicit settings.
+  MAI->setCompressDebugSections(Opts.CompressDebugSections);
+
+  MAI->setRelaxELFRelocations(Opts.RelaxELFRelocations);
+
+  bool IsBinary = Opts.OutputType == AssemblerInvocation::FT_Obj;
+  if (Opts.OutputPath.empty())
+    Opts.OutputPath = "-";
+  std::unique_ptr<raw_fd_ostream> FDOS =
+      getOutputStream(Opts.OutputPath, Diags, IsBinary);
+  if (!FDOS)
+    return true;
+  std::unique_ptr<raw_fd_ostream> DwoOS;
+  if (!Opts.SplitDwarfOutput.empty())
+    DwoOS = getOutputStream(Opts.SplitDwarfOutput, Diags, IsBinary);
+
+  // FIXME: This is not pretty. MCContext has a ptr to MCObjectFileInfo and
+  // MCObjectFileInfo needs a MCContext reference in order to initialize itself.
+  std::unique_ptr<MCObjectFileInfo> MOFI(new MCObjectFileInfo());
+
+  MCContext Ctx(MAI.get(), MRI.get(), MOFI.get(), &SrcMgr, &MCOptions);
+
+  bool PIC = false;
+  if (Opts.RelocationModel == "static") {
+    PIC = false;
+  } else if (Opts.RelocationModel == "pic") {
+    PIC = true;
+  } else {
+    assert(Opts.RelocationModel == "dynamic-no-pic" &&
+           "Invalid PIC model!");
+    PIC = false;
+  }
+
+  MOFI->InitMCObjectFileInfo(Triple(Opts.Triple), PIC, Ctx);
+  if (Opts.SaveTemporaryLabels)
+    Ctx.setAllowTemporaryLabels(false);
+  if (Opts.GenDwarfForAssembly)
+    Ctx.setGenDwarfForAssembly(true);
+  if (!Opts.DwarfDebugFlags.empty())
+    Ctx.setDwarfDebugFlags(StringRef(Opts.DwarfDebugFlags));
+  if (!Opts.DwarfDebugProducer.empty())
+    Ctx.setDwarfDebugProducer(StringRef(Opts.DwarfDebugProducer));
+  if (!Opts.DebugCompilationDir.empty())
+    Ctx.setCompilationDir(Opts.DebugCompilationDir);
+  else {
+    // If no compilation dir is set, try to use the current directory.
+    SmallString<128> CWD;
+    if (!sys::fs::current_path(CWD))
+      Ctx.setCompilationDir(CWD);
+  }
+  if (!Opts.DebugPrefixMap.empty())
+    for (const auto &KV : Opts.DebugPrefixMap)
+      Ctx.addDebugPrefixMapEntry(KV.first, KV.second);
+  if (!Opts.MainFileName.empty())
+    Ctx.setMainFileName(StringRef(Opts.MainFileName));
+  Ctx.setDwarfVersion(Opts.DwarfVersion);
+  if (Opts.GenDwarfForAssembly)
+    Ctx.setGenDwarfRootFile(Opts.InputFile,
+                            SrcMgr.getMemoryBuffer(BufferIndex)->getBuffer());
+
+  // Build up the feature string from the target feature list.
+  std::string FS;
+  if (!Opts.Features.empty()) {
+    FS = Opts.Features[0];
+    for (unsigned i = 1, e = Opts.Features.size(); i != e; ++i)
+      FS += "," + Opts.Features[i];
+  }
+
+  std::unique_ptr<MCStreamer> Str;
+
+  std::unique_ptr<MCInstrInfo> MCII(TheTarget->createMCInstrInfo());
+  std::unique_ptr<MCSubtargetInfo> STI(
+      TheTarget->createMCSubtargetInfo(Opts.Triple, Opts.CPU, FS));
+
+  raw_pwrite_stream *Out = FDOS.get();
+  std::unique_ptr<buffer_ostream> BOS;
+
+  MCOptions.MCNoWarn = Opts.NoWarn;
+  MCOptions.MCFatalWarnings = Opts.FatalWarnings;
+  MCOptions.ABIName = Opts.TargetABI;
+
+  // FIXME: There is a bit of code duplication with addPassesToEmitFile.
+  if (Opts.OutputType == AssemblerInvocation::FT_Asm) {
+    MCInstPrinter *IP = TheTarget->createMCInstPrinter(
+        llvm::Triple(Opts.Triple), Opts.OutputAsmVariant, *MAI, *MCII, *MRI);
+
+    std::unique_ptr<MCCodeEmitter> CE;
+    if (Opts.ShowEncoding)
+      CE.reset(TheTarget->createMCCodeEmitter(*MCII, *MRI, Ctx));
+    std::unique_ptr<MCAsmBackend> MAB(
+        TheTarget->createMCAsmBackend(*STI, *MRI, MCOptions));
+
+    auto FOut = std::make_unique<formatted_raw_ostream>(*Out);
+    Str.reset(TheTarget->createAsmStreamer(
+        Ctx, std::move(FOut), /*asmverbose*/ true,
+        /*useDwarfDirectory*/ true, IP, std::move(CE), std::move(MAB),
+        Opts.ShowInst));
+  } else if (Opts.OutputType == AssemblerInvocation::FT_Null) {
+    Str.reset(createNullStreamer(Ctx));
+  } else {
+    assert(Opts.OutputType == AssemblerInvocation::FT_Obj &&
+           "Invalid file type!");
+    if (!FDOS->supportsSeeking()) {
+      BOS = std::make_unique<buffer_ostream>(*FDOS);
+      Out = BOS.get();
+    }
+
+    std::unique_ptr<MCCodeEmitter> CE(
+        TheTarget->createMCCodeEmitter(*MCII, *MRI, Ctx));
+    std::unique_ptr<MCAsmBackend> MAB(
+        TheTarget->createMCAsmBackend(*STI, *MRI, MCOptions));
+    std::unique_ptr<MCObjectWriter> OW =
+        DwoOS ? MAB->createDwoObjectWriter(*Out, *DwoOS)
+              : MAB->createObjectWriter(*Out);
+
+    Triple T(Opts.Triple);
+    Str.reset(TheTarget->createMCObjectStreamer(
+        T, Ctx, std::move(MAB), std::move(OW), std::move(CE), *STI,
+        Opts.RelaxAll, Opts.IncrementalLinkerCompatible,
+        /*DWARFMustBeAtTheEnd*/ true));
+    Str.get()->InitSections(Opts.NoExecStack);
+  }
+
+  // When -fembed-bitcode is passed to clang_as, a 1-byte marker
+  // is emitted in __LLVM,__asm section if the object file is MachO format.
+  if (Opts.EmbedBitcode && Ctx.getObjectFileInfo()->getObjectFileType() ==
+                               MCObjectFileInfo::IsMachO) {
+    MCSection *AsmLabel = Ctx.getMachOSection(
+        "__LLVM", "__asm", MachO::S_REGULAR, 4, SectionKind::getReadOnly());
+    Str.get()->SwitchSection(AsmLabel);
+    Str.get()->EmitZeros(1);
+  }
+
+  // Assembly to object compilation should leverage assembly info.
+  Str->setUseAssemblerInfoForParsing(true);
+
+  bool Failed = false;
+
+  std::unique_ptr<MCAsmParser> Parser(
+      createMCAsmParser(SrcMgr, Ctx, *Str.get(), *MAI));
+
+  // FIXME: init MCTargetOptions from sanitizer flags here.
+  std::unique_ptr<MCTargetAsmParser> TAP(
+      TheTarget->createMCAsmParser(*STI, *Parser, *MCII, MCOptions));
+  if (!TAP)
+    Failed = Diags.Report(diag::err_target_unknown_triple) << Opts.Triple;
+
+  // Set values for symbols, if any.
+  for (auto &S : Opts.SymbolDefs) {
+    auto Pair = StringRef(S).split('=');
+    auto Sym = Pair.first;
+    auto Val = Pair.second;
+    int64_t Value;
+    // We have already error checked this in the driver.
+    Val.getAsInteger(0, Value);
+    Ctx.setSymbolValue(Parser->getStreamer(), Sym, Value);
+  }
+
+  if (!Failed) {
+    Parser->setTargetParser(*TAP.get());
+    Failed = Parser->Run(Opts.NoInitialTextSection);
+  }
+
+  // Close Streamer first.
+  // It might have a reference to the output stream.
+  Str.reset();
+  // Close the output stream early.
+  BOS.reset();
+  FDOS.reset();
+
+  // Delete output file if there were errors.
+  if (Failed) {
+    if (Opts.OutputPath != "-")
+      sys::fs::remove(Opts.OutputPath);
+    if (!Opts.SplitDwarfOutput.empty() && Opts.SplitDwarfOutput != "-")
+      sys::fs::remove(Opts.SplitDwarfOutput);
+  }
+
+  return Failed;
+}
+
+static void LLVMErrorHandler(void *UserData, const std::string &Message,
+                             bool GenCrashDiag) {
+  DiagnosticsEngine &Diags = *static_cast<DiagnosticsEngine*>(UserData);
+
+  Diags.Report(diag::err_fe_error_backend) << Message;
+
+  // We cannot recover from llvm errors.
+  sys::Process::Exit(1);
+}
+
+int cc1as_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
+  // Initialize targets and assembly printers/parsers.
+  InitializeAllTargetInfos();
+  InitializeAllTargetMCs();
+  InitializeAllAsmParsers();
+
+  // Construct our diagnostic client.
+  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
+  TextDiagnosticPrinter *DiagClient
+    = new TextDiagnosticPrinter(errs(), &*DiagOpts);
+  DiagClient->setPrefix("clang -cc1as");
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
+  DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagClient);
+
+  // Set an error handler, so that any LLVM backend diagnostics go through our
+  // error handler.
+  ScopedFatalErrorHandler FatalErrorHandler
+    (LLVMErrorHandler, static_cast<void*>(&Diags));
+
+  // Parse the arguments.
+  AssemblerInvocation Asm;
+  if (!AssemblerInvocation::CreateFromArgs(Asm, Argv, Diags))
+    return 1;
+
+  if (Asm.ShowHelp) {
+    getDriverOptTable().PrintHelp(
+        llvm::outs(), "clang -cc1as [options] file...",
+        "Clang Integrated Assembler",
+        /*Include=*/driver::options::CC1AsOption, /*Exclude=*/0,
+        /*ShowAllAliases=*/false);
+    return 0;
+  }
+
+  // Honor -version.
+  //
+  // FIXME: Use a better -version message?
+  if (Asm.ShowVersion) {
+    llvm::cl::PrintVersionMessage();
+    return 0;
+  }
+
+  // Honor -mllvm.
+  //
+  // FIXME: Remove this, one day.
+  if (!Asm.LLVMArgs.empty()) {
+    unsigned NumArgs = Asm.LLVMArgs.size();
+    auto Args = std::make_unique<const char*[]>(NumArgs + 2);
+    Args[0] = "clang (LLVM option parsing)";
+    for (unsigned i = 0; i != NumArgs; ++i)
+      Args[i + 1] = Asm.LLVMArgs[i].c_str();
+    Args[NumArgs + 1] = nullptr;
+    llvm::cl::ParseCommandLineOptions(NumArgs + 1, Args.get());
+  }
+
+  // Execute the invocation, unless there were parsing errors.
+  bool Failed = Diags.hasErrorOccurred() || ExecuteAssembler(Asm, Diags);
+
+  // If any timers were active but haven't been destroyed yet, print their
+  // results now.
+  TimerGroup::printAll(errs());
+  TimerGroup::clearAll();
+
+  return !!Failed;
+}

builder/cc1as.h

@@ -0,0 +1,120 @@
+//===-- cc1as.h - Clang Assembler  ----------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This is the entry point to the clang -cc1as functionality, which implements
+// the direct interface to the LLVM MC based assembler.
+//
+//===----------------------------------------------------------------------===//
+
+/// Helper class for representing a single invocation of the assembler.
+struct AssemblerInvocation {
+  /// @name Target Options
+  /// @{
+
+  /// The name of the target triple to assemble for.
+  std::string Triple;
+
+  /// If given, the name of the target CPU to determine which instructions
+  /// are legal.
+  std::string CPU;
+
+  /// The list of target specific features to enable or disable -- this should
+  /// be a list of strings starting with '+' or '-'.
+  std::vector<std::string> Features;
+
+  /// The list of symbol definitions.
+  std::vector<std::string> SymbolDefs;
+
+  /// @}
+  /// @name Language Options
+  /// @{
+
+  std::vector<std::string> IncludePaths;
+  unsigned NoInitialTextSection : 1;
+  unsigned SaveTemporaryLabels : 1;
+  unsigned GenDwarfForAssembly : 1;
+  unsigned RelaxELFRelocations : 1;
+  unsigned DwarfVersion;
+  std::string DwarfDebugFlags;
+  std::string DwarfDebugProducer;
+  std::string DebugCompilationDir;
+  std::map<const std::string, const std::string> DebugPrefixMap;
+  llvm::DebugCompressionType CompressDebugSections =
+      llvm::DebugCompressionType::None;
+  std::string MainFileName;
+  std::string SplitDwarfOutput;
+
+  /// @}
+  /// @name Frontend Options
+  /// @{
+
+  std::string InputFile;
+  std::vector<std::string> LLVMArgs;
+  std::string OutputPath;
+  enum FileType {
+    FT_Asm,  ///< Assembly (.s) output, transliterate mode.
+    FT_Null, ///< No output, for timing purposes.
+    FT_Obj   ///< Object file output.
+  };
+  FileType OutputType;
+  unsigned ShowHelp : 1;
+  unsigned ShowVersion : 1;
+
+  /// @}
+  /// @name Transliterate Options
+  /// @{
+
+  unsigned OutputAsmVariant;
+  unsigned ShowEncoding : 1;
+  unsigned ShowInst : 1;
+
+  /// @}
+  /// @name Assembler Options
+  /// @{
+
+  unsigned RelaxAll : 1;
+  unsigned NoExecStack : 1;
+  unsigned FatalWarnings : 1;
+  unsigned NoWarn : 1;
+  unsigned IncrementalLinkerCompatible : 1;
+  unsigned EmbedBitcode : 1;
+
+  /// The name of the relocation model to use.
+  std::string RelocationModel;
+
+  /// The ABI targeted by the backend. Specified using -target-abi. Empty
+  /// otherwise.
+  std::string TargetABI;
+
+  /// @}
+
+public:
+  AssemblerInvocation() {
+    Triple = "";
+    NoInitialTextSection = 0;
+    InputFile = "-";
+    OutputPath = "-";
+    OutputType = FT_Asm;
+    OutputAsmVariant = 0;
+    ShowInst = 0;
+    ShowEncoding = 0;
+    RelaxAll = 0;
+    NoExecStack = 0;
+    FatalWarnings = 0;
+    NoWarn = 0;
+    IncrementalLinkerCompatible = 0;
+    DwarfVersion = 0;
+    EmbedBitcode = 0;
+  }
+
+  static bool CreateFromArgs(AssemblerInvocation &Res,
+                             ArrayRef<const char *> Argv,
+                             DiagnosticsEngine &Diags);
+};
+
+bool ExecuteAssembler(AssemblerInvocation &Opts, DiagnosticsEngine &Diags);

builder/clang.cpp

@@ -0,0 +1,97 @@
+// +build byollvm
+
+#include <clang/Basic/DiagnosticOptions.h>
+#include <clang/CodeGen/CodeGenAction.h>
+#include <clang/Driver/Compilation.h>
+#include <clang/Driver/Driver.h>
+#include <clang/Frontend/CompilerInstance.h>
+#include <clang/Frontend/CompilerInvocation.h>
+#include <clang/Frontend/FrontendDiagnostic.h>
+#include <clang/Frontend/TextDiagnosticPrinter.h>
+#include <clang/FrontendTool/Utils.h>
+#include <llvm/ADT/IntrusiveRefCntPtr.h>
+#include <llvm/Option/Option.h>
+
+using namespace llvm;
+using namespace clang;
+
+#include "cc1as.h"
+
+// This file provides C wrappers for the builtin tools cc1 and cc1as
+// provided by Clang, and calls them as the driver would call them.
+
+extern "C" {
+
+bool tinygo_clang_driver(int argc, char **argv) {
+	std::vector<const char*> args(argv, argv + argc);
+
+	// The compiler invocation needs a DiagnosticsEngine so it can report problems
+	llvm::IntrusiveRefCntPtr<clang::DiagnosticOptions> DiagOpts = new clang::DiagnosticOptions();
+	clang::TextDiagnosticPrinter DiagnosticPrinter(llvm::errs(), &*DiagOpts);
+	clang::DiagnosticsEngine Diags(llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs>(new clang::DiagnosticIDs()), &*DiagOpts, &DiagnosticPrinter, false);
+
+	// Create the clang driver
+	clang::driver::Driver TheDriver(args[0], llvm::sys::getDefaultTargetTriple(), Diags);
+
+	// Create the set of actions to perform
+	std::unique_ptr<clang::driver::Compilation> C(TheDriver.BuildCompilation(args));
+	if (!C) {
+		return false;
+	}
+	const clang::driver::JobList &Jobs = C->getJobs();
+
+	// There may be more than one job, for example for .S files
+	// (preprocessor + assembler).
+	for (auto Cmd : Jobs) {
+		// Select the tool: cc1 or cc1as.
+		const llvm::opt::ArgStringList &CCArgs = Cmd.getArguments();
+
+		if (strcmp(*CCArgs.data(), "-cc1") == 0) {
+			// This is the C frontend.
+			// Initialize a compiler invocation object from the clang (-cc1) arguments.
+			std::unique_ptr<clang::CompilerInstance> Clang(new clang::CompilerInstance());
+			bool success = clang::CompilerInvocation::CreateFromArgs(
+					Clang->getInvocation(),
+					CCArgs,
+					Diags);
+			if (!success) {
+				return false;
+			}
+
+			// Create the actual diagnostics engine.
+			Clang->createDiagnostics();
+			if (!Clang->hasDiagnostics()) {
+				return false;
+			}
+
+			// Execute the frontend actions.
+			success = ExecuteCompilerInvocation(Clang.get());
+			if (!success) {
+				return false;
+			}
+
+		} else if (strcmp(*CCArgs.data(), "-cc1as") == 0) {
+			// This is the assembler frontend. Parse the arguments.
+			AssemblerInvocation Asm;
+			ArrayRef<const char *> Argv = llvm::ArrayRef<const char*>(CCArgs);
+			if (!AssemblerInvocation::CreateFromArgs(Asm, Argv.slice(1), Diags))
+				return false;
+
+			// Execute the invocation, unless there were parsing errors.
+			bool failed = Diags.hasErrorOccurred() || ExecuteAssembler(Asm, Diags);
+			if (failed) {
+				return false;
+			}
+
+		} else {
+			// Unknown tool, print the tool and exit.
+			fprintf(stderr, "unknown tool: %s\n", *CCArgs.data());
+			return false;
+		}
+	}
+
+	// Commands executed successfully.
+	return true;
+}
+
+} // extern "C"

builder/commands.go

@@ -6,25 +6,28 @@ import (
 	"os/exec"
 	"runtime"
 	"strings"
+
+	"tinygo.org/x/go-llvm"
 )
 
 // Commands lists command alternatives for various operating systems. These
 // commands may have a slightly different name across operating systems and
 // distributions or may not even exist in $PATH, in which case absolute paths
 // may be used.
-var commands = map[string][]string{
-	"clang":   {"clang-9"},
-	"ld.lld":  {"ld.lld-9", "ld.lld"},
-	"wasm-ld": {"wasm-ld-9", "wasm-ld"},
-}
+var commands = map[string][]string{}
 
 func init() {
-	// Add the path to a Homebrew-installed LLVM 9 for ease of use (no need to
+	llvmMajor := strings.Split(llvm.Version, ".")[0]
+	commands["clang"] = []string{"clang-" + llvmMajor}
+	commands["ld.lld"] = []string{"ld.lld-" + llvmMajor, "ld.lld"}
+	commands["wasm-ld"] = []string{"wasm-ld-" + llvmMajor, "wasm-ld"}
+	// Add the path to a Homebrew-installed LLVM for ease of use (no need to
 	// manually set $PATH).
 	if runtime.GOOS == "darwin" {
-		commands["clang"] = append(commands["clang"], "/usr/local/opt/llvm@9/bin/clang-9")
-		commands["ld.lld"] = append(commands["ld.lld"], "/usr/local/opt/llvm@9/bin/ld.lld")
-		commands["wasm-ld"] = append(commands["wasm-ld"], "/usr/local/opt/llvm@9/bin/wasm-ld")
+		prefix := "/usr/local/opt/llvm@" + llvmMajor + "/bin/"
+		commands["clang"] = append(commands["clang"], prefix+"clang-"+llvmMajor)
+		commands["ld.lld"] = append(commands["ld.lld"], prefix+"ld.lld")
+		commands["wasm-ld"] = append(commands["wasm-ld"], prefix+"wasm-ld")
 	}
 	// Add the path for when LLVM was installed with the installer from
 	// llvm.org, which by default doesn't add LLVM to the $PATH environment
@@ -34,6 +37,13 @@ func init() {
 		commands["ld.lld"] = append(commands["ld.lld"], "lld", "C:\\Program Files\\LLVM\\bin\\lld.exe")
 		commands["wasm-ld"] = append(commands["wasm-ld"], "C:\\Program Files\\LLVM\\bin\\wasm-ld.exe")
 	}
+	// Add the path to LLVM installed from ports.
+	if runtime.GOOS == "freebsd" {
+		prefix := "/usr/local/llvm" + llvmMajor + "/bin/"
+		commands["clang"] = append(commands["clang"], prefix+"clang-"+llvmMajor)
+		commands["ld.lld"] = append(commands["ld.lld"], prefix+"ld.lld")
+		commands["wasm-ld"] = append(commands["wasm-ld"], prefix+"wasm-ld")
+	}
 }
 
 func execCommand(cmdNames []string, args ...string) error {

builder/config.go

@@ -21,12 +21,12 @@ func NewConfig(options *compileopts.Options) (*compileopts.Config, error) {
 	if goroot == "" {
 		return nil, errors.New("cannot locate $GOROOT, please set it manually")
 	}
-	major, minor, err := getGorootVersion(goroot)
+	major, minor, err := goenv.GetGorootVersion(goroot)
 	if err != nil {
 		return nil, fmt.Errorf("could not read version from GOROOT (%v): %v", goroot, err)
 	}
-	if major != 1 || (minor != 11 && minor != 12 && minor != 13) {
-		return nil, fmt.Errorf("requires go version 1.11, 1.12, or 1.13, got go%d.%d", major, minor)
+	if major != 1 || minor < 11 || minor > 14 {
+		return nil, fmt.Errorf("requires go version 1.11, 1.12, 1.13, or 1.14, got go%d.%d", major, minor)
 	}
 	clangHeaderPath := getClangHeaderPath(goenv.Get("TINYGOROOT"))
 	return &compileopts.Config{

builder/env.go

@@ -1,77 +1,19 @@
 package builder
 
 import (
-	"errors"
-	"fmt"
-	"io"
 	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
-	"regexp"
 	"sort"
-	"strings"
 )
 
-// getGorootVersion returns the major and minor version for a given GOROOT path.
-// If the goroot cannot be determined, (0, 0) is returned.
-func getGorootVersion(goroot string) (major, minor int, err error) {
-	s, err := GorootVersionString(goroot)
-	if err != nil {
-		return 0, 0, err
-	}
-
-	if s == "" || s[:2] != "go" {
-		return 0, 0, errors.New("could not parse Go version: version does not start with 'go' prefix")
-	}
-
-	parts := strings.Split(s[2:], ".")
-	if len(parts) < 2 {
-		return 0, 0, errors.New("could not parse Go version: version has less than two parts")
-	}
-
-	// Ignore the errors, we don't really handle errors here anyway.
-	var trailing string
-	n, err := fmt.Sscanf(s, "go%d.%d%s", &major, &minor, &trailing)
-	if n == 2 && err == io.EOF {
-		// Means there were no trailing characters (i.e., not an alpha/beta)
-		err = nil
-	}
-	if err != nil {
-		return 0, 0, fmt.Errorf("failed to parse version: %s", err)
-	}
-	return
-}
-
-// GorootVersionString returns the version string as reported by the Go
-// toolchain for the given GOROOT path. It is usually of the form `go1.x.y` but
-// can have some variations (for beta releases, for example).
-func GorootVersionString(goroot string) (string, error) {
-	if data, err := ioutil.ReadFile(filepath.Join(
-		goroot, "src", "runtime", "internal", "sys", "zversion.go")); err == nil {
-
-		r := regexp.MustCompile("const TheVersion = `(.*)`")
-		matches := r.FindSubmatch(data)
-		if len(matches) != 2 {
-			return "", errors.New("Invalid go version output:\n" + string(data))
-		}
-
-		return string(matches[1]), nil
-
-	} else if data, err := ioutil.ReadFile(filepath.Join(goroot, "VERSION")); err == nil {
-		return string(data), nil
-
-	} else {
-		return "", err
-	}
-}
-
 // getClangHeaderPath returns the path to the built-in Clang headers. It tries
 // multiple locations, which should make it find the directory when installed in
 // various ways.
 func getClangHeaderPath(TINYGOROOT string) string {
 	// Check whether we're running from the source directory.
-	path := filepath.Join(TINYGOROOT, "llvm", "tools", "clang", "lib", "Headers")
+	path := filepath.Join(TINYGOROOT, "llvm-project", "clang", "lib", "Headers")
 	if _, err := os.Stat(path); !os.IsNotExist(err) {
 		return path
 	}

builder/error.go

@@ -12,6 +12,20 @@ func (e *MultiError) Error() string {
 	return e.Errs[0].Error()
 }
 
+// newMultiError returns a *MultiError if there is more than one error, or
+// returns that error directly when there is only one. Passing an empty slice
+// will lead to a panic.
+func newMultiError(errs []error) error {
+	switch len(errs) {
+	case 0:
+		panic("attempted to create empty MultiError")
+	case 1:
+		return errs[0]
+	default:
+		return &MultiError{errs}
+	}
+}
+
 // commandError is an error type to wrap os/exec.Command errors. This provides
 // some more information regarding what went wrong while running a command.
 type commandError struct {

builder/library.go

@@ -0,0 +1,102 @@
+package builder
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/tinygo-org/tinygo/goenv"
+)
+
+// Library is a container for information about a single C library, such as a
+// compiler runtime or libc.
+type Library struct {
+	// The library name, such as compiler-rt or picolibc.
+	name string
+
+	cflags func() []string
+
+	// The source directory, relative to TINYGOROOT.
+	sourceDir string
+
+	// The source files, relative to sourceDir.
+	sources func(target string) []string
+}
+
+// fullPath returns the full path to the source directory.
+func (l *Library) fullPath() string {
+	return filepath.Join(goenv.Get("TINYGOROOT"), l.sourceDir)
+}
+
+// sourcePaths returns a slice with the full paths to the source files.
+func (l *Library) sourcePaths(target string) []string {
+	sources := l.sources(target)
+	paths := make([]string, len(sources))
+	for i, name := range sources {
+		paths[i] = filepath.Join(l.fullPath(), name)
+	}
+	return paths
+}
+
+// Load the library archive, possibly generating and caching it if needed.
+func (l *Library) Load(target string) (path string, err error) {
+	// Try to load a precompiled library.
+	precompiledPath := filepath.Join(goenv.Get("TINYGOROOT"), "pkg", target, l.name+".a")
+	if _, err := os.Stat(precompiledPath); err == nil {
+		// Found a precompiled library for this OS/architecture. Return the path
+		// directly.
+		return precompiledPath, nil
+	}
+
+	outfile := l.name + "-" + target + ".a"
+
+	// Try to fetch this library from the cache.
+	if path, err := cacheLoad(outfile, commands["clang"][0], l.sourcePaths(target)); path != "" || err != nil {
+		// Cache hit.
+		return path, err
+	}
+	// Cache miss, build it now.
+
+	dirPrefix := "tinygo-" + l.name
+	remapDir := filepath.Join(os.TempDir(), dirPrefix)
+	dir, err := ioutil.TempDir(os.TempDir(), dirPrefix)
+	if err != nil {
+		return "", err
+	}
+	defer os.RemoveAll(dir)
+
+	// Precalculate the flags to the compiler invocation.
+	args := append(l.cflags(), "-c", "-Oz", "-g", "-ffunction-sections", "-fdata-sections", "-Wno-macro-redefined", "--target="+target, "-fdebug-prefix-map="+dir+"="+remapDir)
+	if strings.HasPrefix(target, "arm") || strings.HasPrefix(target, "thumb") {
+		args = append(args, "-fshort-enums", "-fomit-frame-pointer")
+	}
+	if strings.HasPrefix(target, "riscv32-") {
+		args = append(args, "-march=rv32imac", "-mabi=ilp32", "-fforce-enable-int128")
+	}
+
+	// Compile all sources.
+	var objs []string
+	for _, srcpath := range l.sourcePaths(target) {
+		objpath := filepath.Join(dir, filepath.Base(srcpath)+".o")
+		objs = append(objs, objpath)
+		// Note: -fdebug-prefix-map is necessary to make the output archive
+		// reproducible. Otherwise the temporary directory is stored in the
+		// archive itself, which varies each run.
+		err := runCCompiler("clang", append(args, "-o", objpath, srcpath)...)
+		if err != nil {
+			return "", &commandError{"failed to build", srcpath, err}
+		}
+	}
+
+	// Put all the object files in a single archive. This archive file will be
+	// used to statically link this library.
+	arpath := filepath.Join(dir, l.name+".a")
+	err = makeArchive(arpath, objs)
+	if err != nil {
+		return "", err
+	}
+
+	// Store this archive in the cache.
+	return cacheStore(arpath, outfile, commands["clang"][0], l.sourcePaths(target))
+}

builder/linker-builtin.go

@@ -1,71 +0,0 @@
-// +build byollvm
-
-package builder
-
-// This file provides a Link() function that uses the bundled lld if possible.
-
-import (
-	"errors"
-	"os"
-	"os/exec"
-	"unsafe"
-
-	"github.com/tinygo-org/tinygo/goenv"
-)
-
-/*
-#include <stdbool.h>
-#include <stdlib.h>
-bool tinygo_link_elf(int argc, char **argv);
-bool tinygo_link_wasm(int argc, char **argv);
-*/
-import "C"
-
-// link invokes a linker with the given name and flags.
-//
-// This version uses the built-in linker when trying to use lld.
-func link(linker string, flags ...string) error {
-	switch linker {
-	case "ld.lld":
-		flags = append([]string{"tinygo:" + linker}, flags...)
-		var cflag *C.char
-		buf := C.calloc(C.size_t(len(flags)), C.size_t(unsafe.Sizeof(cflag)))
-		cflags := (*[1 << 10]*C.char)(unsafe.Pointer(buf))[:len(flags):len(flags)]
-		for i, flag := range flags {
-			cflag := C.CString(flag)
-			cflags[i] = cflag
-			defer C.free(unsafe.Pointer(cflag))
-		}
-		ok := C.tinygo_link_elf(C.int(len(flags)), (**C.char)(buf))
-		if !ok {
-			return errors.New("failed to link using built-in ld.lld")
-		}
-		return nil
-	case "wasm-ld":
-		flags = append([]string{"tinygo:" + linker}, flags...)
-		var cflag *C.char
-		buf := C.calloc(C.size_t(len(flags)), C.size_t(unsafe.Sizeof(cflag)))
-		defer C.free(buf)
-		cflags := (*[1 << 10]*C.char)(unsafe.Pointer(buf))[:len(flags):len(flags)]
-		for i, flag := range flags {
-			cflag := C.CString(flag)
-			cflags[i] = cflag
-			defer C.free(unsafe.Pointer(cflag))
-		}
-		ok := C.tinygo_link_wasm(C.int(len(flags)), (**C.char)(buf))
-		if !ok {
-			return errors.New("failed to link using built-in wasm-ld")
-		}
-		return nil
-	default:
-		// Fall back to external command.
-		if cmdNames, ok := commands[linker]; ok {
-			return execCommand(cmdNames, flags...)
-		}
-		cmd := exec.Command(linker, flags...)
-		cmd.Stdout = os.Stdout
-		cmd.Stderr = os.Stderr
-		cmd.Dir = goenv.Get("TINYGOROOT")
-		return cmd.Run()
-	}
-}

builder/linker-external.go

@@ -1,27 +0,0 @@
-// +build !byollvm
-
-package builder
-
-// This file provides a Link() function that always runs an external command. It
-// is provided for when tinygo is built without linking to liblld.
-
-import (
-	"os"
-	"os/exec"
-
-	"github.com/tinygo-org/tinygo/goenv"
-)
-
-// link invokes a linker with the given name and arguments.
-//
-// This version always runs the linker as an external command.
-func link(linker string, flags ...string) error {
-	if cmdNames, ok := commands[linker]; ok {
-		return execCommand(cmdNames, flags...)
-	}
-	cmd := exec.Command(linker, flags...)
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	cmd.Dir = goenv.Get("TINYGOROOT")
-	return cmd.Run()
-}

builder/lld.cpp

@@ -8,12 +8,12 @@ extern "C" {
 
 bool tinygo_link_elf(int argc, char **argv) {
 	std::vector<const char*> args(argv, argv + argc);
-	return lld::elf::link(args, false);
+	return lld::elf::link(args, false, llvm::outs(), llvm::errs());
 }
 
 bool tinygo_link_wasm(int argc, char **argv) {
 	std::vector<const char*> args(argv, argv + argc);
-	return lld::wasm::link(args, false);
+	return lld::wasm::link(args, false, llvm::outs(), llvm::errs());
 }
 
 } // external "C"

builder/picolibc.go

@@ -0,0 +1,127 @@
+package builder
+
+import (
+	"path/filepath"
+
+	"github.com/tinygo-org/tinygo/goenv"
+)
+
+// Picolibc is a C library for bare metal embedded devices. It was originally
+// based on newlib.
+var Picolibc = Library{
+	name: "picolibc",
+	cflags: func() []string {
+		picolibcDir := filepath.Join(goenv.Get("TINYGOROOT"), "lib/picolibc/newlib/libc")
+		return []string{"-Werror", "-Wall", "-std=gnu11", "-D_COMPILING_NEWLIB", "-nostdlibinc", "-Xclang", "-internal-isystem", "-Xclang", picolibcDir + "/include", "-I" + picolibcDir + "/tinystdio", "-I" + goenv.Get("TINYGOROOT") + "/lib/picolibc-include"}
+	},
+	sourceDir: "lib/picolibc/newlib/libc",
+	sources: func(target string) []string {
+		return picolibcSources
+	},
+}
+
+var picolibcSources = []string{
+	"string/bcmp.c",
+	"string/bcopy.c",
+	"string/bzero.c",
+	"string/explicit_bzero.c",
+	"string/ffsl.c",
+	"string/ffsll.c",
+	"string/fls.c",
+	"string/flsl.c",
+	"string/flsll.c",
+	"string/gnu_basename.c",
+	"string/index.c",
+	"string/memccpy.c",
+	"string/memchr.c",
+	"string/memcmp.c",
+	"string/memcpy.c",
+	"string/memmem.c",
+	"string/memmove.c",
+	"string/mempcpy.c",
+	"string/memrchr.c",
+	"string/memset.c",
+	"string/rawmemchr.c",
+	"string/rindex.c",
+	"string/stpcpy.c",
+	"string/stpncpy.c",
+	"string/strcasecmp.c",
+	"string/strcasecmp_l.c",
+	"string/strcasestr.c",
+	"string/strcat.c",
+	"string/strchr.c",
+	"string/strchrnul.c",
+	"string/strcmp.c",
+	"string/strcoll.c",
+	"string/strcoll_l.c",
+	"string/strcpy.c",
+	"string/strcspn.c",
+	"string/strdup.c",
+	"string/strerror.c",
+	"string/strerror_r.c",
+	"string/strlcat.c",
+	"string/strlcpy.c",
+	"string/strlen.c",
+	"string/strlwr.c",
+	"string/strncasecmp.c",
+	"string/strncasecmp_l.c",
+	"string/strncat.c",
+	"string/strncmp.c",
+	"string/strncpy.c",
+	"string/strndup.c",
+	"string/strnlen.c",
+	"string/strnstr.c",
+	"string/strpbrk.c",
+	"string/strrchr.c",
+	"string/strsep.c",
+	"string/strsignal.c",
+	"string/strspn.c",
+	"string/strstr.c",
+	"string/strtok.c",
+	"string/strtok_r.c",
+	"string/strupr.c",
+	"string/strverscmp.c",
+	"string/strxfrm.c",
+	"string/strxfrm_l.c",
+	"string/swab.c",
+	"string/timingsafe_bcmp.c",
+	"string/timingsafe_memcmp.c",
+	"string/u_strerr.c",
+	"string/wcpcpy.c",
+	"string/wcpncpy.c",
+	"string/wcscasecmp.c",
+	"string/wcscasecmp_l.c",
+	"string/wcscat.c",
+	"string/wcschr.c",
+	"string/wcscmp.c",
+	"string/wcscoll.c",
+	"string/wcscoll_l.c",
+	"string/wcscpy.c",
+	"string/wcscspn.c",
+	"string/wcsdup.c",
+	"string/wcslcat.c",
+	"string/wcslcpy.c",
+	"string/wcslen.c",
+	"string/wcsncasecmp.c",
+	"string/wcsncasecmp_l.c",
+	"string/wcsncat.c",
+	"string/wcsncmp.c",
+	"string/wcsncpy.c",
+	"string/wcsnlen.c",
+	"string/wcspbrk.c",
+	"string/wcsrchr.c",
+	"string/wcsspn.c",
+	"string/wcsstr.c",
+	"string/wcstok.c",
+	"string/wcswidth.c",
+	"string/wcsxfrm.c",
+	"string/wcsxfrm_l.c",
+	"string/wcwidth.c",
+	"string/wmemchr.c",
+	"string/wmemcmp.c",
+	"string/wmemcpy.c",
+	"string/wmemmove.c",
+	"string/wmempcpy.c",
+	"string/wmemset.c",
+	"string/xpg_strerror_r.c",
+}

builder/sizes.go

@@ -84,7 +84,18 @@ func loadProgramSize(path string) (*programSize, error) {
 		if section.Type != elf.SHT_PROGBITS && section.Type != elf.SHT_NOBITS {
 			continue
 		}
-		if section.Type == elf.SHT_NOBITS {
+		if section.Name == ".stack" {
+			// HACK: this works around a bug in ld.lld from LLVM 10. The linker
+			// marks sections with no input symbols (such as is the case for the
+			// .stack section) as SHT_PROGBITS instead of SHT_NOBITS. While it
+			// doesn't affect the generated binaries (.hex and .bin), it does
+			// affect the reported size.
+			// https://bugs.llvm.org/show_bug.cgi?id=45336
+			// https://reviews.llvm.org/D76981
+			// It has been merged in master, but it has not (yet) been
+			// backported to the LLVM 10 release branch.
+			sumBSS += section.Size
+		} else if section.Type == elf.SHT_NOBITS {
 			sumBSS += section.Size
 		} else if section.Flags&elf.SHF_EXECINSTR != 0 {
 			sumCode += section.Size

builder/tools-builtin.go

@@ -0,0 +1,54 @@
+// +build byollvm
+
+package builder
+
+import (
+	"errors"
+	"unsafe"
+)
+
+/*
+#cgo CXXFLAGS: -fno-rtti
+#include <stdbool.h>
+#include <stdlib.h>
+bool tinygo_clang_driver(int argc, char **argv);
+bool tinygo_link_elf(int argc, char **argv);
+bool tinygo_link_wasm(int argc, char **argv);
+*/
+import "C"
+
+const hasBuiltinTools = true
+
+// RunTool runs the given tool (such as clang).
+//
+// This version actually runs the tools because TinyGo was compiled while
+// linking statically with LLVM (with the byollvm build tag).
+func RunTool(tool string, args ...string) error {
+	args = append([]string{"tinygo:" + tool}, args...)
+
+	var cflag *C.char
+	buf := C.calloc(C.size_t(len(args)), C.size_t(unsafe.Sizeof(cflag)))
+	defer C.free(buf)
+	cflags := (*[1 << 10]*C.char)(unsafe.Pointer(buf))[:len(args):len(args)]
+	for i, flag := range args {
+		cflag := C.CString(flag)
+		cflags[i] = cflag
+		defer C.free(unsafe.Pointer(cflag))
+	}
+
+	var ok C.bool
+	switch tool {
+	case "clang":
+		ok = C.tinygo_clang_driver(C.int(len(args)), (**C.char)(buf))
+	case "ld.lld":
+		ok = C.tinygo_link_elf(C.int(len(args)), (**C.char)(buf))
+	case "wasm-ld":
+		ok = C.tinygo_link_wasm(C.int(len(args)), (**C.char)(buf))
+	default:
+		return errors.New("unknown tool: " + tool)
+	}
+	if !ok {
+		return errors.New("failed to run tool: " + tool)
+	}
+	return nil
+}

builder/tools-external.go

@@ -0,0 +1,15 @@
+// +build !byollvm
+
+package builder
+
+import "errors"
+
+const hasBuiltinTools = false
+
+// RunTool runs the given tool (such as clang).
+//
+// This version doesn't actually run the tool: TinyGo has not been compiled by
+// statically linking to LLVM.
+func RunTool(tool string, args ...string) error {
+	return errors.New("cannot run tool: " + tool)
+}

builder/tools.go

@@ -0,0 +1,59 @@
+package builder
+
+import (
+	"errors"
+	"os"
+	"os/exec"
+
+	"github.com/tinygo-org/tinygo/goenv"
+)
+
+// runCCompiler invokes a C compiler with the given arguments.
+func runCCompiler(command string, flags ...string) error {
+	if hasBuiltinTools && command == "clang" {
+		// Compile this with the internal Clang compiler.
+		headerPath := getClangHeaderPath(goenv.Get("TINYGOROOT"))
+		if headerPath == "" {
+			return errors.New("could not locate Clang headers")
+		}
+		flags = append(flags, "-I"+headerPath)
+		cmd := exec.Command(os.Args[0], append([]string{"clang"}, flags...)...)
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		return cmd.Run()
+	}
+
+	// Running some other compiler. Maybe it has been defined in the
+	// commands map (unlikely).
+	if cmdNames, ok := commands[command]; ok {
+		return execCommand(cmdNames, flags...)
+	}
+
+	// Alternatively, run the compiler directly.
+	cmd := exec.Command(command, flags...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	return cmd.Run()
+}
+
+// link invokes a linker with the given name and flags.
+func link(linker string, flags ...string) error {
+	if hasBuiltinTools && (linker == "ld.lld" || linker == "wasm-ld") {
+		// Run command with internal linker.
+		cmd := exec.Command(os.Args[0], append([]string{linker}, flags...)...)
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		return cmd.Run()
+	}
+
+	// Fall back to external command.
+	if cmdNames, ok := commands[linker]; ok {
+		return execCommand(cmdNames, flags...)
+	}
+
+	cmd := exec.Command(linker, flags...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	cmd.Dir = goenv.Get("TINYGOROOT")
+	return cmd.Run()
+}

builder/uf2.go

@@ -11,26 +11,33 @@ import (
 	"bytes"
 	"encoding/binary"
 	"io/ioutil"
+	"strconv"
 )
 
 // convertELFFileToUF2File converts an ELF file to a UF2 file.
-func convertELFFileToUF2File(infile, outfile string) error {
+func convertELFFileToUF2File(infile, outfile string, uf2FamilyID string) error {
 	// Read the .text segment.
 	targetAddress, data, err := extractROM(infile)
 	if err != nil {
 		return err
 	}
 
-	output, _ := convertBinToUF2(data, uint32(targetAddress))
+	output, _, err := convertBinToUF2(data, uint32(targetAddress), uf2FamilyID)
+	if err != nil {
+		return err
+	}
 	return ioutil.WriteFile(outfile, output, 0644)
 }
 
 // convertBinToUF2 converts the binary bytes in input to UF2 formatted data.
-func convertBinToUF2(input []byte, targetAddr uint32) ([]byte, int) {
+func convertBinToUF2(input []byte, targetAddr uint32, uf2FamilyID string) ([]byte, int, error) {
 	blocks := split(input, 256)
 	output := make([]byte, 0)
 
-	bl := newUF2Block(targetAddr)
+	bl, err := newUF2Block(targetAddr, uf2FamilyID)
+	if err != nil {
+		return nil, 0, err
+	}
 	bl.SetNumBlocks(len(blocks))
 
 	for i := 0; i < len(blocks); i++ {
@@ -41,7 +48,7 @@ func convertBinToUF2(input []byte, targetAddr uint32) ([]byte, int) {
 		bl.IncrementAddress(bl.payloadSize)
 	}
 
-	return output, len(blocks)
+	return output, len(blocks), nil
 }
 
 const (
@@ -65,18 +72,32 @@ type uf2Block struct {
 }
 
 // newUF2Block returns a new uf2Block struct that has been correctly populated
-func newUF2Block(targetAddr uint32) *uf2Block {
+func newUF2Block(targetAddr uint32, uf2FamilyID string) (*uf2Block, error) {
+	var flags uint32
+	var familyID uint32
+	if uf2FamilyID != "" {
+		flags |= flagFamilyIDPresent
+		v, err := strconv.ParseUint(uf2FamilyID, 0, 32)
+		if err != nil {
+			return nil, err
+		}
+		familyID = uint32(v)
+	}
 	return &uf2Block{magicStart0: uf2MagicStart0,
 		magicStart1: uf2MagicStart1,
 		magicEnd:    uf2MagicEnd,
 		targetAddr:  targetAddr,
-		flags:       0x0,
-		familyID:    0x0,
+		flags:       flags,
+		familyID:    familyID,
 		payloadSize: 256,
 		data:        make([]byte, 476),
-	}
+	}, nil
 }
 
+const (
+	flagFamilyIDPresent = 0x00002000
+)
+
 // Bytes converts the uf2Block to a slice of bytes that can be written to file.
 func (b *uf2Block) Bytes() []byte {
 	buf := bytes.NewBuffer(make([]byte, 0, 512))

cgo/cgo.go

@@ -14,7 +14,9 @@ package cgo
 import (
 	"fmt"
 	"go/ast"
+	"go/scanner"
 	"go/token"
+	"path/filepath"
 	"sort"
 	"strconv"
 	"strings"
@@ -168,11 +170,28 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 		enums:           map[string]enumInfo{},
 	}
 
+	// Disable _FORTIFY_SOURCE as it causes problems on macOS.
+	// Note that it is only disabled for memcpy (etc) calls made from Go, which
+	// have better alternatives anyway.
+	cflags = append(cflags, "-D_FORTIFY_SOURCE=0")
+
 	// Add a new location for the following file.
 	generatedTokenPos := p.fset.AddFile(dir+"/!cgo.go", -1, 0)
 	generatedTokenPos.SetLines([]int{0})
 	p.generatedPos = generatedTokenPos.Pos(0)
 
+	// Find the absolute path for this package.
+	packagePath, err := filepath.Abs(fset.File(files[0].Pos()).Name())
+	if err != nil {
+		return nil, []error{
+			scanner.Error{
+				Pos: fset.Position(files[0].Pos()),
+				Msg: "cgo: cannot find absolute path: " + err.Error(), // TODO: wrap this error
+			},
+		}
+	}
+	packagePath = filepath.Dir(packagePath)
+
 	// Construct a new in-memory AST for CGo declarations of this package.
 	unsafeImport := &ast.ImportSpec{
 		Path: &ast.BasicLit{
@@ -338,6 +357,7 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 						p.addErrorAfter(comment.Slash, comment.Text[:lineStart+colon+1], err.Error())
 						continue
 					}
+					makePathsAbsolute(flags, packagePath)
 					cflags = append(cflags, flags...)
 				default:
 					startPos := strings.LastIndex(line[4:colon], name) + 4
@@ -395,6 +415,30 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 	return p.generated, p.errors
 }
 
+// makePathsAbsolute converts some common path compiler flags (-I, -L) from
+// relative flags into absolute flags, if they are relative. This is necessary
+// because the C compiler is usually not invoked from the package path.
+func makePathsAbsolute(args []string, packagePath string) {
+	nextIsPath := false
+	for i, arg := range args {
+		if nextIsPath {
+			if !filepath.IsAbs(arg) {
+				args[i] = filepath.Join(packagePath, arg)
+			}
+		}
+		if arg == "-I" || arg == "-L" {
+			nextIsPath = true
+			continue
+		}
+		if strings.HasPrefix(arg, "-I") || strings.HasPrefix(arg, "-L") {
+			path := arg[2:]
+			if !filepath.IsAbs(path) {
+				args[i] = arg[:2] + filepath.Join(packagePath, path)
+			}
+		}
+	}
+}
+
 // addFuncDecls adds the C function declarations found by libclang in the
 // comment above the `import "C"` statement.
 func (p *cgoPackage) addFuncDecls() {

cgo/cgo_test.go

@@ -11,6 +11,7 @@ import (
 	"go/types"
 	"io/ioutil"
 	"path/filepath"
+	"regexp"
 	"runtime"
 	"strings"
 	"testing"
@@ -19,14 +20,27 @@ import (
 // Pass -update to go test to update the output of the test files.
 var flagUpdate = flag.Bool("update", false, "Update images based on test output.")
 
+// normalizeResult normalizes Go source code that comes out of tests across
+// platforms and Go versions.
+func normalizeResult(result string) string {
+	actual := strings.Replace(result, "\r\n", "\n", -1)
+
+	// Make sure all functions are wrapped, even those that would otherwise be
+	// single-line functions. This is necessary because Go 1.14 changed the way
+	// such functions are wrapped and it's important to have consistent test
+	// results.
+	re := regexp.MustCompile(`func \((.+)\)( .*?) +{ (.+) }`)
+	actual = re.ReplaceAllString(actual, "func ($1)$2 {\n\t$3\n}")
+
+	return actual
+}
+
 func TestCGo(t *testing.T) {
 	var cflags = []string{"--target=armv6m-none-eabi"}
 
-	for _, name := range []string{"basic", "errors", "types", "flags"} {
+	for _, name := range []string{"basic", "errors", "types", "flags", "const"} {
 		name := name // avoid a race condition
 		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
 			// Read the AST in memory.
 			path := filepath.Join("testdata", name+".go")
 			fset := token.NewFileSet()
@@ -76,7 +90,7 @@ func TestCGo(t *testing.T) {
 			if err != nil {
 				t.Errorf("could not write out CGo AST: %v", err)
 			}
-			actual := strings.Replace(string(buf.Bytes()), "\r\n", "\n", -1)
+			actual := normalizeResult(string(buf.Bytes()))
 
 			// Read the file with the expected output, to compare against.
 			outfile := filepath.Join("testdata", name+".out.go")

cgo/const.go

@@ -52,6 +52,13 @@ func parseConstExpr(t *tokenizer) (ast.Expr, *scanner.Error) {
 		}
 		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.pos),
@@ -133,8 +140,10 @@ func (t *tokenizer) Next() {
 				if c == '.' {
 					hasDot = true
 				}
-				if (c >= '0' && c <= '9') || c == '.' || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') {
+				if c >= '0' && c <= '9' || c == '.' || c == '_' || c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' {
 					tokenLen = i + 1
+				} else {
+					break
 				}
 			}
 			t.value = t.buf[:tokenLen]
@@ -150,6 +159,21 @@ func (t *tokenizer) Next() {
 				t.value = strings.TrimRight(t.value, "uUlL")
 			}
 			return
+		case c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z' || c == '_':
+			// Identifier. Find all remaining tokens that are part of this
+			// identifier.
+			tokenLen := len(t.buf)
+			for i, c := range t.buf {
+				if c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z' || c == '_' {
+					tokenLen = i + 1
+				} else {
+					break
+				}
+			}
+			t.value = t.buf[:tokenLen]
+			t.buf = t.buf[tokenLen:]
+			t.token = token.IDENT
+			return
 		case c == '"':
 			// String constant. Find the first '"' character that is not
 			// preceded by a backslash.

cgo/const_test.go

@@ -21,8 +21,8 @@ func TestParseConst(t *testing.T) {
 		{`5)`, `error: 1:2: unexpected token )`},
 		{"  \t)", `error: 1:4: unexpected token )`},
 		{`5.8f`, `5.8`},
-		{`foo`, `error: 1:1: unexpected token ILLEGAL`}, // identifiers unimplemented
-		{``, `error: 1:1: empty constant`},              // empty constants not allowed in Go
+		{`foo`, `C.foo`},
+		{``, `error: 1:1: empty constant`}, // empty constants not allowed in Go
 		{`"foo"`, `"foo"`},
 		{`"a\\n"`, `"a\\n"`},
 		{`"a\n"`, `"a\n"`},
@@ -30,6 +30,7 @@ func TestParseConst(t *testing.T) {
 		{`'a'`, `'a'`},
 		{`0b10`, `0b10`},
 		{`0x1234_5678`, `0x1234_5678`},
+		{`5 5`, `error: 1:3: unexpected token INT`}, // test for a bugfix
 	} {
 		fset := token.NewFileSet()
 		startPos := fset.AddFile("", -1, 1000).Pos(0)

cgo/libclang.go

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

cgo/libclang_config.go

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

cgo/libclang_config_llvm9.go

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

cgo/libclang_stubs.c

@@ -3,7 +3,7 @@
 // are slightly different from the ones defined in libclang.go, but they
 // should be ABI compatible.
 
-#include <clang-c/Index.h> // if this fails, install libclang-9-dev
+#include <clang-c/Index.h> // if this fails, install libclang-10-dev
 
 CXCursor tinygo_clang_getTranslationUnitCursor(CXTranslationUnit tu) {
 	return clang_getTranslationUnitCursor(tu);

cgo/testdata/const.go

@@ -0,0 +1,12 @@
+package main
+
+/*
+#define foo 3
+#define bar foo
+*/
+import "C"
+
+const (
+	Foo = C.foo
+	Bar = C.bar
+)

cgo/testdata/const.out.go

@@ -0,0 +1,29 @@
+package main
+
+import "unsafe"
+
+var _ unsafe.Pointer
+
+const C.bar = C.foo
+const C.foo = 3
+
+type C.int16_t = int16
+type C.int32_t = int32
+type C.int64_t = int64
+type C.int8_t = int8
+type C.uint16_t = uint16
+type C.uint32_t = uint32
+type C.uint64_t = uint64
+type C.uint8_t = uint8
+type C.uintptr_t = uintptr
+type C.char uint8
+type C.int int32
+type C.long int32
+type C.longlong int64
+type C.schar int8
+type C.short int16
+type C.uchar uint8
+type C.uint uint32
+type C.ulong uint32
+type C.ulonglong uint64
+type C.ushort uint16

cgo/testdata/flags.go

@@ -9,6 +9,9 @@ package main
 
 #cgo CFLAGS: -DFOO
 
+#cgo CFLAGS: -Iinclude
+#include "foo.h"
+
 #if defined(FOO)
 #define BAR 3
 #else
@@ -23,4 +26,5 @@ import "C"
 
 var (
 	_ = C.BAR
+	_ = C.FOO_H
 )

cgo/testdata/flags.out.go

@@ -9,6 +9,7 @@ import "unsafe"
 var _ unsafe.Pointer
 
 const C.BAR = 3
+const C.FOO_H = 1
 
 type C.int16_t = int16
 type C.int32_t = int32

cgo/testdata/include/foo.h

@@ -0,0 +1 @@
+#define FOO_H 1

cgo/testdata/types.out.go

@@ -62,12 +62,18 @@ type C.union3_t = C.union_1
 type C.union_nested_t = C.union_3
 type C.unionarray_t = struct{ arr [10]C.uchar }
 
-func (s *C.struct_4) bitfield_a() C.uchar          { return s.__bitfield_1 & 0x1f }
-func (s *C.struct_4) set_bitfield_a(value C.uchar) { s.__bitfield_1 = s.__bitfield_1&^0x1f | value&0x1f<<0 }
+func (s *C.struct_4) bitfield_a() C.uchar {
+	return s.__bitfield_1 & 0x1f
+}
+func (s *C.struct_4) set_bitfield_a(value C.uchar) {
+	s.__bitfield_1 = s.__bitfield_1&^0x1f | value&0x1f<<0
+}
 func (s *C.struct_4) bitfield_b() C.uchar {
 	return s.__bitfield_1 >> 5 & 0x1
 }
-func (s *C.struct_4) set_bitfield_b(value C.uchar) { s.__bitfield_1 = s.__bitfield_1&^0x20 | value&0x1<<5 }
+func (s *C.struct_4) set_bitfield_b(value C.uchar) {
+	s.__bitfield_1 = s.__bitfield_1&^0x20 | value&0x1<<5
+}
 func (s *C.struct_4) bitfield_c() C.uchar {
 	return s.__bitfield_1 >> 6
 }
@@ -94,25 +100,45 @@ type C.struct_type1 struct {
 }
 type C.struct_type2 struct{ _type C.int }
 
-func (union *C.union_1) unionfield_i() *C.int   { return (*C.int)(unsafe.Pointer(&union.$union)) }
-func (union *C.union_1) unionfield_d() *float64 { return (*float64)(unsafe.Pointer(&union.$union)) }
-func (union *C.union_1) unionfield_s() *C.short { return (*C.short)(unsafe.Pointer(&union.$union)) }
+func (union *C.union_1) unionfield_i() *C.int {
+	return (*C.int)(unsafe.Pointer(&union.$union))
+}
+func (union *C.union_1) unionfield_d() *float64 {
+	return (*float64)(unsafe.Pointer(&union.$union))
+}
+func (union *C.union_1) unionfield_s() *C.short {
+	return (*C.short)(unsafe.Pointer(&union.$union))
+}
 
 type C.union_1 struct{ $union uint64 }
 
-func (union *C.union_2) unionfield_area() *C.point2d_t  { return (*C.point2d_t)(unsafe.Pointer(&union.$union)) }
-func (union *C.union_2) unionfield_solid() *C.point3d_t { return (*C.point3d_t)(unsafe.Pointer(&union.$union)) }
+func (union *C.union_2) unionfield_area() *C.point2d_t {
+	return (*C.point2d_t)(unsafe.Pointer(&union.$union))
+}
+func (union *C.union_2) unionfield_solid() *C.point3d_t {
+	return (*C.point3d_t)(unsafe.Pointer(&union.$union))
+}
 
 type C.union_2 struct{ $union [3]uint32 }
 
-func (union *C.union_3) unionfield_point() *C.point3d_t    { return (*C.point3d_t)(unsafe.Pointer(&union.$union)) }
-func (union *C.union_3) unionfield_array() *C.unionarray_t { return (*C.unionarray_t)(unsafe.Pointer(&union.$union)) }
-func (union *C.union_3) unionfield_thing() *C.union3_t     { return (*C.union3_t)(unsafe.Pointer(&union.$union)) }
+func (union *C.union_3) unionfield_point() *C.point3d_t {
+	return (*C.point3d_t)(unsafe.Pointer(&union.$union))
+}
+func (union *C.union_3) unionfield_array() *C.unionarray_t {
+	return (*C.unionarray_t)(unsafe.Pointer(&union.$union))
+}
+func (union *C.union_3) unionfield_thing() *C.union3_t {
+	return (*C.union3_t)(unsafe.Pointer(&union.$union))
+}
 
 type C.union_3 struct{ $union [2]uint64 }
 
-func (union *C.union_union2d) unionfield_i() *C.int      { return (*C.int)(unsafe.Pointer(&union.$union)) }
-func (union *C.union_union2d) unionfield_d() *[2]float64 { return (*[2]float64)(unsafe.Pointer(&union.$union)) }
+func (union *C.union_union2d) unionfield_i() *C.int {
+	return (*C.int)(unsafe.Pointer(&union.$union))
+}
+func (union *C.union_union2d) unionfield_d() *[2]float64 {
+	return (*[2]float64)(unsafe.Pointer(&union.$union))
+}
 
 type C.union_union2d struct{ $union [2]uint64 }
 type C.enum_option C.int

compileopts/config.go

@@ -5,6 +5,7 @@ package compileopts
 import (
 	"errors"
 	"fmt"
+	"path/filepath"
 	"regexp"
 	"strconv"
 	"strings"
@@ -21,6 +22,29 @@ type Config struct {
 	TestConfig     TestConfig
 }
 
+// FuncValueImplementation is an enum for the particular implementations of Go
+// func values.
+type FuncValueImplementation int
+
+// These constants describe the various possible implementations of Go func
+// values.
+const (
+	FuncValueNone FuncValueImplementation = iota
+
+	// A func value is implemented as a pair of pointers:
+	//     {context, function pointer}
+	// where the context may be a pointer to a heap-allocated struct containing
+	// the free variables, or it may be undef if the function being pointed to
+	// doesn't need a context. The function pointer is a regular function
+	// pointer.
+	FuncValueDoubleword
+
+	// As funcValueDoubleword, but with the function pointer replaced by a
+	// unique ID per function signature. Function values are called by using a
+	// switch statement and choosing which function to call.
+	FuncValueSwitch
+)
+
 // Triple returns the LLVM target triple, like armv6m-none-eabi.
 func (c *Config) Triple() string {
 	return c.Target.Triple
@@ -65,8 +89,14 @@ func (c *Config) BuildTags() []string {
 	return tags
 }
 
+// CgoEnabled returns true if (and only if) CGo is enabled. It is true by
+// default and false if CGO_ENABLED is set to "0".
+func (c *Config) CgoEnabled() bool {
+	return goenv.Get("CGO_ENABLED") == "1"
+}
+
 // GC returns the garbage collection strategy in use on this platform. Valid
-// values are "none", "leaking", and "conservative".
+// values are "none", "leaking", "extalloc", and "conservative".
 func (c *Config) GC() string {
 	if c.Options.GC != "" {
 		return c.Options.GC
@@ -74,22 +104,29 @@ func (c *Config) GC() string {
 	if c.Target.GC != "" {
 		return c.Target.GC
 	}
-	return "conservative"
+	for _, tag := range c.Target.BuildTags {
+		if tag == "baremetal" || tag == "wasm" {
+			return "conservative"
+		}
+	}
+	return "extalloc"
 }
 
 // NeedsStackObjects returns true if the compiler should insert stack objects
 // that can be traced by the garbage collector.
 func (c *Config) NeedsStackObjects() bool {
-	if c.GC() != "conservative" {
+	switch c.GC() {
+	case "conservative", "extalloc":
+		for _, tag := range c.BuildTags() {
+			if tag == "baremetal" {
+				return false
+			}
+		}
+
+		return true
+	default:
 		return false
 	}
-	for _, tag := range c.BuildTags() {
-		if tag == "baremetal" {
-			return false
-		}
-	}
-
-	return true
 }
 
 // Scheduler returns the scheduler implementation. Valid values are "coroutines"
@@ -105,6 +142,21 @@ func (c *Config) Scheduler() string {
 	return "coroutines"
 }
 
+// FuncImplementation picks an appropriate func value implementation for the
+// target.
+func (c *Config) FuncImplementation() FuncValueImplementation {
+	// Always pick the switch implementation, as it allows the use of blocking
+	// inside a function that is used as a func value.
+	switch c.Scheduler() {
+	case "none", "coroutines":
+		return FuncValueSwitch
+	case "tasks":
+		return FuncValueDoubleword
+	default:
+		panic("unknown scheduler type")
+	}
+}
+
 // PanicStrategy returns the panic strategy selected for this target. Valid
 // values are "print" (print the panic value, then exit) or "trap" (issue a trap
 // instruction).
@@ -119,6 +171,11 @@ func (c *Config) CFlags() []string {
 	for _, flag := range c.Target.CFlags {
 		cflags = append(cflags, strings.Replace(flag, "{root}", goenv.Get("TINYGOROOT"), -1))
 	}
+	if c.Target.Libc == "picolibc" {
+		root := goenv.Get("TINYGOROOT")
+		cflags = append(cflags, "-nostdlibinc", "-Xclang", "-internal-isystem", "-Xclang", filepath.Join(root, "lib", "picolibc", "newlib", "libc", "include"))
+		cflags = append(cflags, "-I"+filepath.Join(root, "lib/picolibc-include"))
+	}
 	return cflags
 }
 

compileopts/target.go

@@ -32,6 +32,7 @@ type TargetSpec struct {
 	Compiler         string   `json:"compiler"`
 	Linker           string   `json:"linker"`
 	RTLib            string   `json:"rtlib"` // compiler runtime library (libgcc, compiler-rt)
+	Libc             string   `json:"libc"`
 	CFlags           []string `json:"cflags"`
 	LDFlags          []string `json:"ldflags"`
 	LinkerScript     string   `json:"linkerscript"`
@@ -43,9 +44,11 @@ type TargetSpec struct {
 	FlashMethod      string   `json:"flash-method"`
 	FlashVolume      string   `json:"msd-volume-name"`
 	FlashFilename    string   `json:"msd-firmware-name"`
+	UF2FamilyID      string   `json:"uf2-family-id"`
 	OpenOCDInterface string   `json:"openocd-interface"`
 	OpenOCDTarget    string   `json:"openocd-target"`
 	OpenOCDTransport string   `json:"openocd-transport"`
+	JLinkDevice      string   `json:"jlink-device"`
 }
 
 // copyProperties copies all properties that are set in spec2 into itself.
@@ -82,6 +85,9 @@ func (spec *TargetSpec) copyProperties(spec2 *TargetSpec) {
 	if spec2.RTLib != "" {
 		spec.RTLib = spec2.RTLib
 	}
+	if spec2.Libc != "" {
+		spec.Libc = spec2.Libc
+	}
 	spec.CFlags = append(spec.CFlags, spec2.CFlags...)
 	spec.LDFlags = append(spec.LDFlags, spec2.LDFlags...)
 	if spec2.LinkerScript != "" {
@@ -109,6 +115,9 @@ func (spec *TargetSpec) copyProperties(spec2 *TargetSpec) {
 	if spec2.FlashFilename != "" {
 		spec.FlashFilename = spec2.FlashFilename
 	}
+	if spec2.UF2FamilyID != "" {
+		spec.UF2FamilyID = spec2.UF2FamilyID
+	}
 	if spec2.OpenOCDInterface != "" {
 		spec.OpenOCDInterface = spec2.OpenOCDInterface
 	}
@@ -118,6 +127,9 @@ func (spec *TargetSpec) copyProperties(spec2 *TargetSpec) {
 	if spec2.OpenOCDTransport != "" {
 		spec.OpenOCDTransport = spec2.OpenOCDTransport
 	}
+	if spec2.JLinkDevice != "" {
+		spec.JLinkDevice = spec2.JLinkDevice
+	}
 }
 
 // load reads a target specification from the JSON in the given io.Reader. It
@@ -221,6 +233,14 @@ func LoadTarget(target string) (*TargetSpec, error) {
 		if len(tripleSplit) < 3 {
 			return nil, errors.New("expected a full LLVM target or a custom target in -target flag")
 		}
+		if tripleSplit[0] == "arm" {
+			// LLVM and Clang have a different idea of what "arm" means, so
+			// upgrade to a slightly more modern ARM. In fact, when you pass
+			// --target=arm--linux-gnueabihf to Clang, it will convert that
+			// internally to armv7-unknown-linux-gnueabihf. Changing the
+			// architecture to armv7 will keep things consistent.
+			tripleSplit[0] = "armv7"
+		}
 		goos := tripleSplit[2]
 		if strings.HasPrefix(goos, "darwin") {
 			goos = "darwin"
@@ -229,11 +249,12 @@ func LoadTarget(target string) (*TargetSpec, error) {
 			"i386":    "386",
 			"x86_64":  "amd64",
 			"aarch64": "arm64",
+			"armv7":   "arm",
 		}[tripleSplit[0]]
 		if goarch == "" {
 			goarch = tripleSplit[0]
 		}
-		return defaultTarget(goos, goarch, target)
+		return defaultTarget(goos, goarch, strings.Join(tripleSplit, "-"))
 	}
 }
 
@@ -247,6 +268,7 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 		BuildTags:   []string{goos, goarch},
 		Compiler:    "clang",
 		Linker:      "cc",
+		CFlags:      []string{"--target=" + triple},
 		GDB:         "gdb",
 		PortReset:   "false",
 		FlashMethod: "native",
@@ -259,11 +281,13 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 	if goarch != runtime.GOARCH {
 		// Some educated guesses as to how to invoke helper programs.
 		if goarch == "arm" && goos == "linux" {
+			spec.CFlags = append(spec.CFlags, "--sysroot=/usr/arm-linux-gnueabihf")
 			spec.Linker = "arm-linux-gnueabihf-gcc"
 			spec.GDB = "arm-linux-gnueabihf-gdb"
 			spec.Emulator = []string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"}
 		}
 		if goarch == "arm64" && goos == "linux" {
+			spec.CFlags = append(spec.CFlags, "--sysroot=/usr/aarch64-linux-gnu")
 			spec.Linker = "aarch64-linux-gnu-gcc"
 			spec.GDB = "aarch64-linux-gnu-gdb"
 			spec.Emulator = []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"}

compiler/asserts.go

@@ -4,16 +4,19 @@ package compiler
 // required by the Go programming language.
 
 import (
+	"fmt"
+	"go/token"
 	"go/types"
 
+	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )
 
-// emitLookupBoundsCheck emits a bounds check before doing a lookup into a
+// createLookupBoundsCheck emits a bounds check before doing a lookup into a
 // slice. This is required by the Go language spec: an index out of bounds must
 // cause a panic.
-func (c *Compiler) emitLookupBoundsCheck(frame *Frame, arrayLen, index llvm.Value, indexType types.Type) {
-	if frame.fn.IsNoBounds() {
+func (b *builder) createLookupBoundsCheck(arrayLen, index llvm.Value, indexType types.Type) {
+	if b.fn.IsNoBounds() {
 		// The //go:nobounds pragma was added to the function to avoid bounds
 		// checking.
 		return
@@ -23,41 +26,29 @@ func (c *Compiler) emitLookupBoundsCheck(frame *Frame, arrayLen, index llvm.Valu
 		// Sometimes, the index can be e.g. an uint8 or int8, and we have to
 		// correctly extend that type.
 		if indexType.Underlying().(*types.Basic).Info()&types.IsUnsigned == 0 {
-			index = c.builder.CreateZExt(index, arrayLen.Type(), "")
+			index = b.CreateZExt(index, arrayLen.Type(), "")
 		} else {
-			index = c.builder.CreateSExt(index, arrayLen.Type(), "")
+			index = b.CreateSExt(index, arrayLen.Type(), "")
 		}
 	} else if index.Type().IntTypeWidth() > arrayLen.Type().IntTypeWidth() {
 		// The index is bigger than the array length type, so extend it.
-		arrayLen = c.builder.CreateZExt(arrayLen, index.Type(), "")
+		arrayLen = b.CreateZExt(arrayLen, index.Type(), "")
 	}
 
-	faultBlock := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "lookup.outofbounds")
-	nextBlock := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "lookup.next")
-	frame.blockExits[frame.currentBlock] = nextBlock // adjust outgoing block for phi nodes
-
 	// Now do the bounds check: index >= arrayLen
-	outOfBounds := c.builder.CreateICmp(llvm.IntUGE, index, arrayLen, "")
-	c.builder.CreateCondBr(outOfBounds, faultBlock, nextBlock)
-
-	// Fail: this is a nil pointer, exit with a panic.
-	c.builder.SetInsertPointAtEnd(faultBlock)
-	c.createRuntimeCall("lookupPanic", nil, "")
-	c.builder.CreateUnreachable()
-
-	// Ok: this is a valid pointer.
-	c.builder.SetInsertPointAtEnd(nextBlock)
+	outOfBounds := b.CreateICmp(llvm.IntUGE, index, arrayLen, "")
+	b.createRuntimeAssert(outOfBounds, "lookup", "lookupPanic")
 }
 
-// emitSliceBoundsCheck emits a bounds check before a slicing operation to make
+// createSliceBoundsCheck emits a bounds check before a slicing operation to make
 // sure it is within bounds.
 //
 // This function is both used for slicing a slice (low and high have their
 // normal meaning) and for creating a new slice, where 'capacity' means the
 // biggest possible slice capacity, 'low' means len and 'high' means cap. The
 // logic is the same in both cases.
-func (c *Compiler) emitSliceBoundsCheck(frame *Frame, capacity, low, high, max llvm.Value, lowType, highType, maxType *types.Basic) {
-	if frame.fn.IsNoBounds() {
+func (b *builder) createSliceBoundsCheck(capacity, low, high, max llvm.Value, lowType, highType, maxType *types.Basic) {
+	if b.fn.IsNoBounds() {
 		// The //go:nobounds pragma was added to the function to avoid bounds
 		// checking.
 		return
@@ -75,92 +66,164 @@ func (c *Compiler) emitSliceBoundsCheck(frame *Frame, capacity, low, high, max l
 		capacityType = max.Type()
 	}
 	if capacityType != capacity.Type() {
-		capacity = c.builder.CreateZExt(capacity, capacityType, "")
+		capacity = b.CreateZExt(capacity, capacityType, "")
 	}
 
 	// Extend low and high to be the same size as capacity.
 	if low.Type().IntTypeWidth() < capacityType.IntTypeWidth() {
 		if lowType.Info()&types.IsUnsigned != 0 {
-			low = c.builder.CreateZExt(low, capacityType, "")
+			low = b.CreateZExt(low, capacityType, "")
 		} else {
-			low = c.builder.CreateSExt(low, capacityType, "")
+			low = b.CreateSExt(low, capacityType, "")
 		}
 	}
 	if high.Type().IntTypeWidth() < capacityType.IntTypeWidth() {
 		if highType.Info()&types.IsUnsigned != 0 {
-			high = c.builder.CreateZExt(high, capacityType, "")
+			high = b.CreateZExt(high, capacityType, "")
 		} else {
-			high = c.builder.CreateSExt(high, capacityType, "")
+			high = b.CreateSExt(high, capacityType, "")
 		}
 	}
 	if max.Type().IntTypeWidth() < capacityType.IntTypeWidth() {
 		if maxType.Info()&types.IsUnsigned != 0 {
-			max = c.builder.CreateZExt(max, capacityType, "")
+			max = b.CreateZExt(max, capacityType, "")
 		} else {
-			max = c.builder.CreateSExt(max, capacityType, "")
+			max = b.CreateSExt(max, capacityType, "")
 		}
 	}
 
-	faultBlock := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "slice.outofbounds")
-	nextBlock := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "slice.next")
-	frame.blockExits[frame.currentBlock] = nextBlock // adjust outgoing block for phi nodes
-
 	// Now do the bounds check: low > high || high > capacity
-	outOfBounds1 := c.builder.CreateICmp(llvm.IntUGT, low, high, "slice.lowhigh")
-	outOfBounds2 := c.builder.CreateICmp(llvm.IntUGT, high, max, "slice.highmax")
-	outOfBounds3 := c.builder.CreateICmp(llvm.IntUGT, max, capacity, "slice.maxcap")
-	outOfBounds := c.builder.CreateOr(outOfBounds1, outOfBounds2, "slice.lowmax")
-	outOfBounds = c.builder.CreateOr(outOfBounds, outOfBounds3, "slice.lowcap")
-	c.builder.CreateCondBr(outOfBounds, faultBlock, nextBlock)
-
-	// Fail: this is a nil pointer, exit with a panic.
-	c.builder.SetInsertPointAtEnd(faultBlock)
-	c.createRuntimeCall("slicePanic", nil, "")
-	c.builder.CreateUnreachable()
-
-	// Ok: this is a valid pointer.
-	c.builder.SetInsertPointAtEnd(nextBlock)
+	outOfBounds1 := b.CreateICmp(llvm.IntUGT, low, high, "slice.lowhigh")
+	outOfBounds2 := b.CreateICmp(llvm.IntUGT, high, max, "slice.highmax")
+	outOfBounds3 := b.CreateICmp(llvm.IntUGT, max, capacity, "slice.maxcap")
+	outOfBounds := b.CreateOr(outOfBounds1, outOfBounds2, "slice.lowmax")
+	outOfBounds = b.CreateOr(outOfBounds, outOfBounds3, "slice.lowcap")
+	b.createRuntimeAssert(outOfBounds, "slice", "slicePanic")
 }
 
-// emitNilCheck checks whether the given pointer is nil, and panics if it is. It
-// has no effect in well-behaved programs, but makes sure no uncaught nil
+// createChanBoundsCheck creates a bounds check before creating a new channel to
+// check that the value is not too big for runtime.chanMake.
+func (b *builder) createChanBoundsCheck(elementSize uint64, bufSize llvm.Value, bufSizeType *types.Basic, pos token.Pos) {
+	if b.fn.IsNoBounds() {
+		// The //go:nobounds pragma was added to the function to avoid bounds
+		// checking.
+		return
+	}
+
+	// Check whether the bufSize parameter must be cast to a wider integer for
+	// comparison.
+	if bufSize.Type().IntTypeWidth() < b.uintptrType.IntTypeWidth() {
+		if bufSizeType.Info()&types.IsUnsigned != 0 {
+			// Unsigned, so zero-extend to uint type.
+			bufSizeType = types.Typ[types.Uint]
+			bufSize = b.CreateZExt(bufSize, b.intType, "")
+		} else {
+			// Signed, so sign-extend to int type.
+			bufSizeType = types.Typ[types.Int]
+			bufSize = b.CreateSExt(bufSize, b.intType, "")
+		}
+	}
+
+	// Calculate (^uintptr(0)) >> 1, which is the max value that fits in an
+	// uintptr if uintptrs were signed.
+	maxBufSize := llvm.ConstLShr(llvm.ConstNot(llvm.ConstInt(b.uintptrType, 0, false)), llvm.ConstInt(b.uintptrType, 1, false))
+	if elementSize > maxBufSize.ZExtValue() {
+		b.addError(pos, fmt.Sprintf("channel element type is too big (%v bytes)", elementSize))
+		return
+	}
+	// Avoid divide-by-zero.
+	if elementSize == 0 {
+		elementSize = 1
+	}
+	// Make the maxBufSize actually the maximum allowed value (in number of
+	// elements in the channel buffer).
+	maxBufSize = llvm.ConstUDiv(maxBufSize, llvm.ConstInt(b.uintptrType, elementSize, false))
+
+	// Make sure maxBufSize has the same type as bufSize.
+	if maxBufSize.Type() != bufSize.Type() {
+		maxBufSize = llvm.ConstZExt(maxBufSize, bufSize.Type())
+	}
+
+	// Do the check for a too large (or negative) buffer size.
+	bufSizeTooBig := b.CreateICmp(llvm.IntUGE, bufSize, maxBufSize, "")
+	b.createRuntimeAssert(bufSizeTooBig, "chan", "chanMakePanic")
+}
+
+// createNilCheck checks whether the given pointer is nil, and panics if it is.
+// It has no effect in well-behaved programs, but makes sure no uncaught nil
 // pointer dereferences exist in valid Go code.
-func (c *Compiler) emitNilCheck(frame *Frame, ptr llvm.Value, blockPrefix string) {
+func (b *builder) createNilCheck(inst ssa.Value, ptr llvm.Value, blockPrefix string) {
 	// Check whether we need to emit this check at all.
 	if !ptr.IsAGlobalValue().IsNil() {
 		return
 	}
 
-	// Check whether this is a nil pointer.
-	faultBlock := c.ctx.AddBasicBlock(frame.fn.LLVMFn, blockPrefix+".nil")
-	nextBlock := c.ctx.AddBasicBlock(frame.fn.LLVMFn, blockPrefix+".next")
-	frame.blockExits[frame.currentBlock] = nextBlock // adjust outgoing block for phi nodes
+	switch inst := inst.(type) {
+	case *ssa.IndexAddr:
+		// This pointer is the result of an index operation into a slice or
+		// array. Such slices/arrays are already bounds checked so the pointer
+		// must be a valid (non-nil) pointer. No nil checking is necessary.
+		return
+	case *ssa.Convert:
+		// This is a pointer that comes from a conversion from unsafe.Pointer.
+		// Don't do nil checking because this is unsafe code and the code should
+		// know what it is doing.
+		// Note: all *ssa.Convert instructions that result in a pointer must
+		// come from unsafe.Pointer. Testing here for unsafe.Pointer to be sure.
+		if inst.X.Type() == types.Typ[types.UnsafePointer] {
+			return
+		}
+	}
 
 	// Compare against nil.
-	var isnil llvm.Value
-	if ptr.Type().PointerAddressSpace() == 0 {
-		// Do the nil check using the isnil builtin, which marks the parameter
-		// as nocapture.
-		// The reason it has to go through a builtin, is that a regular icmp
-		// instruction may capture the pointer in LLVM semantics, see
-		// https://reviews.llvm.org/D60047 for details. Pointer capturing
-		// unfortunately breaks escape analysis, so we use this trick to let the
-		// functionattr pass know that this pointer doesn't really escape.
-		ptr = c.builder.CreateBitCast(ptr, c.i8ptrType, "")
-		isnil = c.createRuntimeCall("isnil", []llvm.Value{ptr}, "")
-	} else {
-		// Do the nil check using a regular icmp. This can happen with function
-		// pointers on AVR, which don't benefit from escape analysis anyway.
-		nilptr := llvm.ConstPointerNull(ptr.Type())
-		isnil = c.builder.CreateICmp(llvm.IntEQ, ptr, nilptr, "")
-	}
-	c.builder.CreateCondBr(isnil, faultBlock, nextBlock)
+	// We previously used a hack to make sure this wouldn't break escape
+	// analysis, but this is not necessary anymore since
+	// https://reviews.llvm.org/D60047 has been merged.
+	nilptr := llvm.ConstPointerNull(ptr.Type())
+	isnil := b.CreateICmp(llvm.IntEQ, ptr, nilptr, "")
 
-	// Fail: this is a nil pointer, exit with a panic.
-	c.builder.SetInsertPointAtEnd(faultBlock)
-	c.createRuntimeCall("nilPanic", nil, "")
-	c.builder.CreateUnreachable()
-
-	// Ok: this is a valid pointer.
-	c.builder.SetInsertPointAtEnd(nextBlock)
+	// Emit the nil check in IR.
+	b.createRuntimeAssert(isnil, blockPrefix, "nilPanic")
+}
+
+// createNegativeShiftCheck creates an assertion that panics if the given shift value is negative.
+// This function assumes that the shift value is signed.
+func (b *builder) createNegativeShiftCheck(shift llvm.Value) {
+	if b.fn.IsNoBounds() {
+		// Function disabled bounds checking - skip shift check.
+		return
+	}
+
+	// isNegative = shift < 0
+	isNegative := b.CreateICmp(llvm.IntSLT, shift, llvm.ConstInt(shift.Type(), 0, false), "")
+	b.createRuntimeAssert(isNegative, "shift", "negativeShiftPanic")
+}
+
+// createRuntimeAssert is a common function to create a new branch on an assert
+// bool, calling an assert func if the assert value is true (1).
+func (b *builder) createRuntimeAssert(assert llvm.Value, blockPrefix, assertFunc string) {
+	// Check whether we can resolve this check at compile time.
+	if !assert.IsAConstantInt().IsNil() {
+		val := assert.ZExtValue()
+		if val == 0 {
+			// Everything is constant so the check does not have to be emitted
+			// in IR. This avoids emitting some redundant IR.
+			return
+		}
+	}
+
+	faultBlock := b.ctx.AddBasicBlock(b.fn.LLVMFn, blockPrefix+".throw")
+	nextBlock := b.ctx.AddBasicBlock(b.fn.LLVMFn, blockPrefix+".next")
+	b.blockExits[b.currentBlock] = nextBlock // adjust outgoing block for phi nodes
+
+	// Now branch to the out-of-bounds or the regular block.
+	b.CreateCondBr(assert, faultBlock, nextBlock)
+
+	// Fail: the assert triggered so panic.
+	b.SetInsertPointAtEnd(faultBlock)
+	b.createRuntimeCall(assertFunc, nil, "")
+	b.CreateUnreachable()
+
+	// Ok: assert didn't trigger so continue normally.
+	b.SetInsertPointAtEnd(nextBlock)
 }

compiler/calls.go

@@ -1,8 +1,9 @@
 package compiler
 
 import (
-	"fmt"
-	"golang.org/x/tools/go/ssa"
+	"go/types"
+	"strconv"
+
 	"tinygo.org/x/go-llvm"
 )
 
@@ -11,62 +12,80 @@ import (
 
 // The maximum number of arguments that can be expanded from a single struct. If
 // a struct contains more fields, it is passed as a struct without expanding.
-const MaxFieldsPerParam = 3
+const maxFieldsPerParam = 3
 
-// Shortcut: create a call to runtime.<fnName> with the given arguments.
-func (c *Compiler) createRuntimeCall(fnName string, args []llvm.Value, name string) llvm.Value {
-	runtimePkg := c.ir.Program.ImportedPackage("runtime")
-	member := runtimePkg.Members[fnName]
-	if member == nil {
-		panic("trying to call runtime." + fnName)
-	}
-	fn := c.ir.GetFunction(member.(*ssa.Function))
-	if fn.LLVMFn.IsNil() {
-		panic(fmt.Errorf("function %s does not appear in LLVM IR", fnName))
-	}
-	if !fn.IsExported() {
-		args = append(args, llvm.Undef(c.i8ptrType))            // unused context parameter
-		args = append(args, llvm.ConstPointerNull(c.i8ptrType)) // coroutine handle
-	}
-	return c.createCall(fn.LLVMFn, args, name)
+// paramInfo contains some information collected about a function parameter,
+// useful while declaring or defining a function.
+type paramInfo struct {
+	llvmType llvm.Type
+	name     string // name, possibly with suffixes for e.g. struct fields
+	flags    paramFlags
 }
 
-// Create a call to the given function with the arguments possibly expanded.
-func (c *Compiler) createCall(fn llvm.Value, args []llvm.Value, name string) llvm.Value {
+// paramFlags identifies parameter attributes for flags. Most importantly, it
+// determines which parameters are dereferenceable_or_null and which aren't.
+type paramFlags uint8
+
+const (
+	// Parameter may have the deferenceable_or_null attribute. This attribute
+	// cannot be applied to unsafe.Pointer and to the data pointer of slices.
+	paramIsDeferenceableOrNull = 1 << iota
+)
+
+// createCall creates a new call to runtime.<fnName> with the given arguments.
+func (b *builder) createRuntimeCall(fnName string, args []llvm.Value, name string) llvm.Value {
+	fullName := "runtime." + fnName
+	fn := b.mod.NamedFunction(fullName)
+	if fn.IsNil() {
+		panic("trying to call non-existent function: " + fullName)
+	}
+	args = append(args, llvm.Undef(b.i8ptrType))            // unused context parameter
+	args = append(args, llvm.ConstPointerNull(b.i8ptrType)) // coroutine handle
+	return b.createCall(fn, args, name)
+}
+
+// createCall creates a call to the given function with the arguments possibly
+// expanded.
+func (b *builder) createCall(fn llvm.Value, args []llvm.Value, name string) llvm.Value {
 	expanded := make([]llvm.Value, 0, len(args))
 	for _, arg := range args {
-		fragments := c.expandFormalParam(arg)
+		fragments := b.expandFormalParam(arg)
 		expanded = append(expanded, fragments...)
 	}
-	return c.builder.CreateCall(fn, expanded, name)
+	return b.CreateCall(fn, expanded, name)
 }
 
 // Expand an argument type to a list that can be used in a function call
 // parameter list.
-func (c *Compiler) expandFormalParamType(t llvm.Type) []llvm.Type {
+func expandFormalParamType(t llvm.Type, name string, goType types.Type) []paramInfo {
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
-		fields := c.flattenAggregateType(t)
-		if len(fields) <= MaxFieldsPerParam {
-			return fields
+		fieldInfos := flattenAggregateType(t, name, goType)
+		if len(fieldInfos) <= maxFieldsPerParam {
+			return fieldInfos
 		} else {
 			// failed to lower
-			return []llvm.Type{t}
 		}
-	default:
-		// TODO: split small arrays
-		return []llvm.Type{t}
+	}
+	// TODO: split small arrays
+	return []paramInfo{
+		{
+			llvmType: t,
+			name:     name,
+			flags:    getTypeFlags(goType),
+		},
 	}
 }
 
-// Expand an argument type to a list of offsets from the start of the object.
-// Used together with expandFormalParam to get the offset of each value from the
-// start of the non-expanded value.
-func (c *Compiler) expandFormalParamOffsets(t llvm.Type) []uint64 {
+// expandFormalParamOffsets returns a list of offsets from the start of an
+// object of type t after it would have been split up by expandFormalParam. This
+// is useful for debug information, where it is necessary to know the offset
+// from the start of the combined object.
+func (b *builder) expandFormalParamOffsets(t llvm.Type) []uint64 {
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
-		fields := c.flattenAggregateTypeOffsets(t)
-		if len(fields) <= MaxFieldsPerParam {
+		fields := b.flattenAggregateTypeOffsets(t)
+		if len(fields) <= maxFieldsPerParam {
 			return fields
 		} else {
 			// failed to lower
@@ -78,14 +97,17 @@ func (c *Compiler) expandFormalParamOffsets(t llvm.Type) []uint64 {
 	}
 }
 
-// Equivalent of expandFormalParamType for parameter values.
-func (c *Compiler) expandFormalParam(v llvm.Value) []llvm.Value {
+// expandFormalParam splits a formal param value into pieces, so it can be
+// passed directly as part of a function call. For example, it splits up small
+// structs into individual fields. It is the equivalent of expandFormalParamType
+// for parameter values.
+func (b *builder) expandFormalParam(v llvm.Value) []llvm.Value {
 	switch v.Type().TypeKind() {
 	case llvm.StructTypeKind:
-		fieldTypes := c.flattenAggregateType(v.Type())
-		if len(fieldTypes) <= MaxFieldsPerParam {
-			fields := c.flattenAggregate(v)
-			if len(fields) != len(fieldTypes) {
+		fieldInfos := flattenAggregateType(v.Type(), "", nil)
+		if len(fieldInfos) <= maxFieldsPerParam {
+			fields := b.flattenAggregate(v)
+			if len(fields) != len(fieldInfos) {
 				panic("type and value param lowering don't match")
 			}
 			return fields
@@ -101,24 +123,98 @@ func (c *Compiler) expandFormalParam(v llvm.Value) []llvm.Value {
 
 // Try to flatten a struct type to a list of types. Returns a 1-element slice
 // with the passed in type if this is not possible.
-func (c *Compiler) flattenAggregateType(t llvm.Type) []llvm.Type {
+func flattenAggregateType(t llvm.Type, name string, goType types.Type) []paramInfo {
+	typeFlags := getTypeFlags(goType)
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
-		fields := make([]llvm.Type, 0, t.StructElementTypesCount())
-		for _, subfield := range t.StructElementTypes() {
-			subfields := c.flattenAggregateType(subfield)
-			fields = append(fields, subfields...)
+		paramInfos := make([]paramInfo, 0, t.StructElementTypesCount())
+		for i, subfield := range t.StructElementTypes() {
+			suffix := strconv.Itoa(i)
+			if goType != nil {
+				// Try to come up with a good suffix for this struct field,
+				// depending on which Go type it's based on.
+				switch goType := goType.Underlying().(type) {
+				case *types.Interface:
+					suffix = []string{"typecode", "value"}[i]
+				case *types.Slice:
+					suffix = []string{"data", "len", "cap"}[i]
+				case *types.Struct:
+					suffix = goType.Field(i).Name()
+				case *types.Basic:
+					switch goType.Kind() {
+					case types.Complex64, types.Complex128:
+						suffix = []string{"r", "i"}[i]
+					case types.String:
+						suffix = []string{"data", "len"}[i]
+					}
+				case *types.Signature:
+					suffix = []string{"context", "funcptr"}[i]
+				}
+			}
+			subInfos := flattenAggregateType(subfield, name+"."+suffix, extractSubfield(goType, i))
+			for i := range subInfos {
+				subInfos[i].flags |= typeFlags
+			}
+			paramInfos = append(paramInfos, subInfos...)
 		}
-		return fields
+		return paramInfos
 	default:
-		return []llvm.Type{t}
+		return []paramInfo{
+			{
+				llvmType: t,
+				name:     name,
+				flags:    typeFlags,
+			},
+		}
 	}
 }
 
-// Return the offsets from the start of the object if this object type were
-// flattened like in flattenAggregate. Used together with flattenAggregate to
-// know the start indices of each value in the non-flattened object.
-func (c *Compiler) flattenAggregateTypeOffsets(t llvm.Type) []uint64 {
+// getTypeFlags returns the type flags for a given type. It will not recurse
+// into sub-types (such as in structs).
+func getTypeFlags(t types.Type) paramFlags {
+	if t == nil {
+		return 0
+	}
+	switch t.Underlying().(type) {
+	case *types.Pointer:
+		// Pointers in Go must either point to an object or be nil.
+		return paramIsDeferenceableOrNull
+	case *types.Chan, *types.Map:
+		// Channels and maps are implemented as pointers pointing to some
+		// object, and follow the same rules as *types.Pointer.
+		return paramIsDeferenceableOrNull
+	default:
+		return 0
+	}
+}
+
+// extractSubfield extracts a field from a struct, or returns null if this is
+// not a struct and thus no subfield can be obtained.
+func extractSubfield(t types.Type, field int) types.Type {
+	if t == nil {
+		return nil
+	}
+	switch t := t.Underlying().(type) {
+	case *types.Struct:
+		return t.Field(field).Type()
+	case *types.Interface, *types.Slice, *types.Basic, *types.Signature:
+		// These Go types are (sometimes) implemented as LLVM structs but can't
+		// really be split further up in Go (with the possible exception of
+		// complex numbers).
+		return nil
+	default:
+		// This should be unreachable.
+		panic("cannot split subfield: " + t.String())
+	}
+}
+
+// flattenAggregateTypeOffset returns the offsets from the start of an object of
+// type t if this object were flattened like in flattenAggregate. Used together
+// with flattenAggregate to know the start indices of each value in the
+// non-flattened object.
+//
+// Note: this is an implementation detail, use expandFormalParamOffsets instead.
+func (c *compilerContext) flattenAggregateTypeOffsets(t llvm.Type) []uint64 {
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
 		fields := make([]uint64, 0, t.StructElementTypesCount())
@@ -136,15 +232,15 @@ func (c *Compiler) flattenAggregateTypeOffsets(t llvm.Type) []uint64 {
 	}
 }
 
-// Break down a struct into its elementary types for argument passing. The value
-// equivalent of flattenAggregateType
-func (c *Compiler) flattenAggregate(v llvm.Value) []llvm.Value {
+// flattenAggregate breaks down a struct into its elementary values for argument
+// passing. It is the value equivalent of flattenAggregateType
+func (b *builder) flattenAggregate(v llvm.Value) []llvm.Value {
 	switch v.Type().TypeKind() {
 	case llvm.StructTypeKind:
 		fields := make([]llvm.Value, 0, v.Type().StructElementTypesCount())
 		for i := range v.Type().StructElementTypes() {
-			subfield := c.builder.CreateExtractValue(v, i, "")
-			subfields := c.flattenAggregate(subfield)
+			subfield := b.CreateExtractValue(v, i, "")
+			subfields := b.flattenAggregate(subfield)
 			fields = append(fields, subfields...)
 		}
 		return fields
@@ -153,25 +249,29 @@ func (c *Compiler) flattenAggregate(v llvm.Value) []llvm.Value {
 	}
 }
 
-// Collapse a list of fields into its original value.
-func (c *Compiler) collapseFormalParam(t llvm.Type, fields []llvm.Value) llvm.Value {
-	param, remaining := c.collapseFormalParamInternal(t, fields)
+// collapseFormalParam combines an aggregate object back into the original
+// value. This is used to join multiple LLVM parameters into a single Go value
+// in the function entry block.
+func (b *builder) collapseFormalParam(t llvm.Type, fields []llvm.Value) llvm.Value {
+	param, remaining := b.collapseFormalParamInternal(t, fields)
 	if len(remaining) != 0 {
 		panic("failed to expand back all fields")
 	}
 	return param
 }
 
-// Returns (value, remainingFields). Used by collapseFormalParam.
-func (c *Compiler) collapseFormalParamInternal(t llvm.Type, fields []llvm.Value) (llvm.Value, []llvm.Value) {
+// collapseFormalParamInternal is an implementation detail of
+// collapseFormalParam: it works by recursing until there are no fields left.
+func (b *builder) collapseFormalParamInternal(t llvm.Type, fields []llvm.Value) (llvm.Value, []llvm.Value) {
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
-		if len(c.flattenAggregateType(t)) <= MaxFieldsPerParam {
+		flattened := flattenAggregateType(t, "", nil)
+		if len(flattened) <= maxFieldsPerParam {
 			value := llvm.ConstNull(t)
 			for i, subtyp := range t.StructElementTypes() {
-				structField, remaining := c.collapseFormalParamInternal(subtyp, fields)
+				structField, remaining := b.collapseFormalParamInternal(subtyp, fields)
 				fields = remaining
-				value = c.builder.CreateInsertValue(value, structField, i, "")
+				value = b.CreateInsertValue(value, structField, i, "")
 			}
 			return value, fields
 		} else {

compiler/channel.go

@@ -11,73 +11,79 @@ import (
 	"tinygo.org/x/go-llvm"
 )
 
-func (c *Compiler) emitMakeChan(frame *Frame, expr *ssa.MakeChan) llvm.Value {
-	elementSize := c.targetData.TypeAllocSize(c.getLLVMType(expr.Type().(*types.Chan).Elem()))
-	elementSizeValue := llvm.ConstInt(c.uintptrType, elementSize, false)
-	bufSize := c.getValue(frame, expr.Size)
-	return c.createRuntimeCall("chanMake", []llvm.Value{elementSizeValue, bufSize}, "")
+func (b *builder) createMakeChan(expr *ssa.MakeChan) llvm.Value {
+	elementSize := b.targetData.TypeAllocSize(b.getLLVMType(expr.Type().(*types.Chan).Elem()))
+	elementSizeValue := llvm.ConstInt(b.uintptrType, elementSize, false)
+	bufSize := b.getValue(expr.Size)
+	b.createChanBoundsCheck(elementSize, bufSize, expr.Size.Type().Underlying().(*types.Basic), expr.Pos())
+	if bufSize.Type().IntTypeWidth() < b.uintptrType.IntTypeWidth() {
+		bufSize = b.CreateZExt(bufSize, b.uintptrType, "")
+	} else if bufSize.Type().IntTypeWidth() > b.uintptrType.IntTypeWidth() {
+		bufSize = b.CreateTrunc(bufSize, b.uintptrType, "")
+	}
+	return b.createRuntimeCall("chanMake", []llvm.Value{elementSizeValue, bufSize}, "")
 }
 
-// emitChanSend emits a pseudo chan send operation. It is lowered to the actual
-// channel send operation during goroutine lowering.
-func (c *Compiler) emitChanSend(frame *Frame, instr *ssa.Send) {
-	ch := c.getValue(frame, instr.Chan)
-	chanValue := c.getValue(frame, instr.X)
+// createChanSend emits a pseudo chan send operation. It is lowered to the
+// actual channel send operation during goroutine lowering.
+func (b *builder) createChanSend(instr *ssa.Send) {
+	ch := b.getValue(instr.Chan)
+	chanValue := b.getValue(instr.X)
 
 	// store value-to-send
-	valueType := c.getLLVMType(instr.X.Type())
-	valueAlloca, valueAllocaCast, valueAllocaSize := c.createTemporaryAlloca(valueType, "chan.value")
-	c.builder.CreateStore(chanValue, valueAlloca)
+	valueType := b.getLLVMType(instr.X.Type())
+	valueAlloca, valueAllocaCast, valueAllocaSize := b.createTemporaryAlloca(valueType, "chan.value")
+	b.CreateStore(chanValue, valueAlloca)
 
 	// Do the send.
-	c.createRuntimeCall("chanSend", []llvm.Value{ch, valueAllocaCast}, "")
+	b.createRuntimeCall("chanSend", []llvm.Value{ch, valueAllocaCast}, "")
 
 	// End the lifetime of the alloca.
 	// This also works around a bug in CoroSplit, at least in LLVM 8:
 	// https://bugs.llvm.org/show_bug.cgi?id=41742
-	c.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
+	b.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
 }
 
-// emitChanRecv emits a pseudo chan receive operation. It is lowered to the
+// createChanRecv emits a pseudo chan receive operation. It is lowered to the
 // actual channel receive operation during goroutine lowering.
-func (c *Compiler) emitChanRecv(frame *Frame, unop *ssa.UnOp) llvm.Value {
-	valueType := c.getLLVMType(unop.X.Type().(*types.Chan).Elem())
-	ch := c.getValue(frame, unop.X)
+func (b *builder) createChanRecv(unop *ssa.UnOp) llvm.Value {
+	valueType := b.getLLVMType(unop.X.Type().(*types.Chan).Elem())
+	ch := b.getValue(unop.X)
 
 	// Allocate memory to receive into.
-	valueAlloca, valueAllocaCast, valueAllocaSize := c.createTemporaryAlloca(valueType, "chan.value")
+	valueAlloca, valueAllocaCast, valueAllocaSize := b.createTemporaryAlloca(valueType, "chan.value")
 
 	// Do the receive.
-	commaOk := c.createRuntimeCall("chanRecv", []llvm.Value{ch, valueAllocaCast}, "")
-	received := c.builder.CreateLoad(valueAlloca, "chan.received")
-	c.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
+	commaOk := b.createRuntimeCall("chanRecv", []llvm.Value{ch, valueAllocaCast}, "")
+	received := b.CreateLoad(valueAlloca, "chan.received")
+	b.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
 
 	if unop.CommaOk {
-		tuple := llvm.Undef(c.ctx.StructType([]llvm.Type{valueType, c.ctx.Int1Type()}, false))
-		tuple = c.builder.CreateInsertValue(tuple, received, 0, "")
-		tuple = c.builder.CreateInsertValue(tuple, commaOk, 1, "")
+		tuple := llvm.Undef(b.ctx.StructType([]llvm.Type{valueType, b.ctx.Int1Type()}, false))
+		tuple = b.CreateInsertValue(tuple, received, 0, "")
+		tuple = b.CreateInsertValue(tuple, commaOk, 1, "")
 		return tuple
 	} else {
 		return received
 	}
 }
 
-// emitChanClose closes the given channel.
-func (c *Compiler) emitChanClose(frame *Frame, param ssa.Value) {
-	ch := c.getValue(frame, param)
-	c.createRuntimeCall("chanClose", []llvm.Value{ch}, "")
+// createChanClose closes the given channel.
+func (b *builder) createChanClose(param ssa.Value) {
+	ch := b.getValue(param)
+	b.createRuntimeCall("chanClose", []llvm.Value{ch}, "")
 }
 
-// emitSelect emits all IR necessary for a select statements. That's a
+// createSelect emits all IR necessary for a select statements. That's a
 // non-trivial amount of code because select is very complex to implement.
-func (c *Compiler) emitSelect(frame *Frame, expr *ssa.Select) llvm.Value {
+func (b *builder) createSelect(expr *ssa.Select) llvm.Value {
 	if len(expr.States) == 0 {
 		// Shortcuts for some simple selects.
-		llvmType := c.getLLVMType(expr.Type())
+		llvmType := b.getLLVMType(expr.Type())
 		if expr.Blocking {
 			// Blocks forever:
 			//     select {}
-			c.createRuntimeCall("deadlock", nil, "")
+			b.createRuntimeCall("deadlock", nil, "")
 			return llvm.Undef(llvmType)
 		} else {
 			// No-op:
@@ -85,7 +91,7 @@ func (c *Compiler) emitSelect(frame *Frame, expr *ssa.Select) llvm.Value {
 			//     default:
 			//     }
 			retval := llvm.Undef(llvmType)
-			retval = c.builder.CreateInsertValue(retval, llvm.ConstInt(c.intType, 0xffffffffffffffff, true), 0, "")
+			retval = b.CreateInsertValue(retval, llvm.ConstInt(b.intType, 0xffffffffffffffff, true), 0, "")
 			return retval // {-1, false}
 		}
 	}
@@ -103,30 +109,30 @@ func (c *Compiler) emitSelect(frame *Frame, expr *ssa.Select) llvm.Value {
 	recvbufAlign := 0
 	hasReceives := false
 	var selectStates []llvm.Value
-	chanSelectStateType := c.getLLVMRuntimeType("chanSelectState")
+	chanSelectStateType := b.getLLVMRuntimeType("chanSelectState")
 	for _, state := range expr.States {
-		ch := c.getValue(frame, state.Chan)
+		ch := b.getValue(state.Chan)
 		selectState := llvm.ConstNull(chanSelectStateType)
-		selectState = c.builder.CreateInsertValue(selectState, ch, 0, "")
+		selectState = b.CreateInsertValue(selectState, ch, 0, "")
 		switch state.Dir {
 		case types.RecvOnly:
 			// Make sure the receive buffer is big enough and has the correct alignment.
-			llvmType := c.getLLVMType(state.Chan.Type().(*types.Chan).Elem())
-			if size := c.targetData.TypeAllocSize(llvmType); size > recvbufSize {
+			llvmType := b.getLLVMType(state.Chan.Type().(*types.Chan).Elem())
+			if size := b.targetData.TypeAllocSize(llvmType); size > recvbufSize {
 				recvbufSize = size
 			}
-			if align := c.targetData.ABITypeAlignment(llvmType); align > recvbufAlign {
+			if align := b.targetData.ABITypeAlignment(llvmType); align > recvbufAlign {
 				recvbufAlign = align
 			}
 			hasReceives = true
 		case types.SendOnly:
 			// Store this value in an alloca and put a pointer to this alloca
 			// in the send state.
-			sendValue := c.getValue(frame, state.Send)
-			alloca := llvmutil.CreateEntryBlockAlloca(c.builder, sendValue.Type(), "select.send.value")
-			c.builder.CreateStore(sendValue, alloca)
-			ptr := c.builder.CreateBitCast(alloca, c.i8ptrType, "")
-			selectState = c.builder.CreateInsertValue(selectState, ptr, 1, "")
+			sendValue := b.getValue(state.Send)
+			alloca := llvmutil.CreateEntryBlockAlloca(b.Builder, sendValue.Type(), "select.send.value")
+			b.CreateStore(sendValue, alloca)
+			ptr := b.CreateBitCast(alloca, b.i8ptrType, "")
+			selectState = b.CreateInsertValue(selectState, ptr, 1, "")
 		default:
 			panic("unreachable")
 		}
@@ -134,74 +140,74 @@ func (c *Compiler) emitSelect(frame *Frame, expr *ssa.Select) llvm.Value {
 	}
 
 	// Create a receive buffer, where the received value will be stored.
-	recvbuf := llvm.Undef(c.i8ptrType)
+	recvbuf := llvm.Undef(b.i8ptrType)
 	if hasReceives {
-		allocaType := llvm.ArrayType(c.ctx.Int8Type(), int(recvbufSize))
-		recvbufAlloca, _, _ := c.createTemporaryAlloca(allocaType, "select.recvbuf.alloca")
+		allocaType := llvm.ArrayType(b.ctx.Int8Type(), int(recvbufSize))
+		recvbufAlloca, _, _ := b.createTemporaryAlloca(allocaType, "select.recvbuf.alloca")
 		recvbufAlloca.SetAlignment(recvbufAlign)
-		recvbuf = c.builder.CreateGEP(recvbufAlloca, []llvm.Value{
-			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
-			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
+		recvbuf = b.CreateGEP(recvbufAlloca, []llvm.Value{
+			llvm.ConstInt(b.ctx.Int32Type(), 0, false),
+			llvm.ConstInt(b.ctx.Int32Type(), 0, false),
 		}, "select.recvbuf")
 	}
 
 	// Create the states slice (allocated on the stack).
 	statesAllocaType := llvm.ArrayType(chanSelectStateType, len(selectStates))
-	statesAlloca, statesI8, statesSize := c.createTemporaryAlloca(statesAllocaType, "select.states.alloca")
+	statesAlloca, statesI8, statesSize := b.createTemporaryAlloca(statesAllocaType, "select.states.alloca")
 	for i, state := range selectStates {
 		// Set each slice element to the appropriate channel.
-		gep := c.builder.CreateGEP(statesAlloca, []llvm.Value{
-			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
-			llvm.ConstInt(c.ctx.Int32Type(), uint64(i), false),
+		gep := b.CreateGEP(statesAlloca, []llvm.Value{
+			llvm.ConstInt(b.ctx.Int32Type(), 0, false),
+			llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false),
 		}, "")
-		c.builder.CreateStore(state, gep)
+		b.CreateStore(state, gep)
 	}
-	statesPtr := c.builder.CreateGEP(statesAlloca, []llvm.Value{
-		llvm.ConstInt(c.ctx.Int32Type(), 0, false),
-		llvm.ConstInt(c.ctx.Int32Type(), 0, false),
+	statesPtr := b.CreateGEP(statesAlloca, []llvm.Value{
+		llvm.ConstInt(b.ctx.Int32Type(), 0, false),
+		llvm.ConstInt(b.ctx.Int32Type(), 0, false),
 	}, "select.states")
-	statesLen := llvm.ConstInt(c.uintptrType, uint64(len(selectStates)), false)
+	statesLen := llvm.ConstInt(b.uintptrType, uint64(len(selectStates)), false)
 
 	// Do the select in the runtime.
 	var results llvm.Value
 	if expr.Blocking {
 		// Stack-allocate operation structures.
 		// If these were simply created as a slice, they would heap-allocate.
-		chBlockAllocaType := llvm.ArrayType(c.getLLVMRuntimeType("channelBlockedList"), len(selectStates))
-		chBlockAlloca, chBlockAllocaPtr, chBlockSize := c.createTemporaryAlloca(chBlockAllocaType, "select.block.alloca")
-		chBlockLen := llvm.ConstInt(c.uintptrType, uint64(len(selectStates)), false)
-		chBlockPtr := c.builder.CreateGEP(chBlockAlloca, []llvm.Value{
-			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
-			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
+		chBlockAllocaType := llvm.ArrayType(b.getLLVMRuntimeType("channelBlockedList"), len(selectStates))
+		chBlockAlloca, chBlockAllocaPtr, chBlockSize := b.createTemporaryAlloca(chBlockAllocaType, "select.block.alloca")
+		chBlockLen := llvm.ConstInt(b.uintptrType, uint64(len(selectStates)), false)
+		chBlockPtr := b.CreateGEP(chBlockAlloca, []llvm.Value{
+			llvm.ConstInt(b.ctx.Int32Type(), 0, false),
+			llvm.ConstInt(b.ctx.Int32Type(), 0, false),
 		}, "select.block")
 
-		results = c.createRuntimeCall("chanSelect", []llvm.Value{
+		results = b.createRuntimeCall("chanSelect", []llvm.Value{
 			recvbuf,
 			statesPtr, statesLen, statesLen, // []chanSelectState
 			chBlockPtr, chBlockLen, chBlockLen, // []channelBlockList
 		}, "select.result")
 
 		// Terminate the lifetime of the operation structures.
-		c.emitLifetimeEnd(chBlockAllocaPtr, chBlockSize)
+		b.emitLifetimeEnd(chBlockAllocaPtr, chBlockSize)
 	} else {
-		results = c.createRuntimeCall("tryChanSelect", []llvm.Value{
+		results = b.createRuntimeCall("tryChanSelect", []llvm.Value{
 			recvbuf,
 			statesPtr, statesLen, statesLen, // []chanSelectState
 		}, "select.result")
 	}
 
 	// Terminate the lifetime of the states alloca.
-	c.emitLifetimeEnd(statesI8, statesSize)
+	b.emitLifetimeEnd(statesI8, statesSize)
 
 	// The result value does not include all the possible received values,
 	// because we can't load them in advance. Instead, the *ssa.Extract
 	// instruction will treat a *ssa.Select specially and load it there inline.
 	// Store the receive alloca in a sidetable until we hit this extract
 	// instruction.
-	if frame.selectRecvBuf == nil {
-		frame.selectRecvBuf = make(map[*ssa.Select]llvm.Value)
+	if b.selectRecvBuf == nil {
+		b.selectRecvBuf = make(map[*ssa.Select]llvm.Value)
 	}
-	frame.selectRecvBuf[expr] = recvbuf
+	b.selectRecvBuf[expr] = recvbuf
 
 	return results
 }
@@ -210,28 +216,28 @@ func (c *Compiler) emitSelect(frame *Frame, expr *ssa.Select) llvm.Value {
 // when extracting a value from a select statement (*ssa.Select). Because
 // *ssa.Select cannot load all values in advance, it does this later in the
 // *ssa.Extract expression.
-func (c *Compiler) getChanSelectResult(frame *Frame, expr *ssa.Extract) llvm.Value {
+func (b *builder) getChanSelectResult(expr *ssa.Extract) llvm.Value {
 	if expr.Index == 0 {
 		// index
-		value := c.getValue(frame, expr.Tuple)
-		index := c.builder.CreateExtractValue(value, expr.Index, "")
-		if index.Type().IntTypeWidth() < c.intType.IntTypeWidth() {
-			index = c.builder.CreateSExt(index, c.intType, "")
+		value := b.getValue(expr.Tuple)
+		index := b.CreateExtractValue(value, expr.Index, "")
+		if index.Type().IntTypeWidth() < b.intType.IntTypeWidth() {
+			index = b.CreateSExt(index, b.intType, "")
 		}
 		return index
 	} else if expr.Index == 1 {
 		// comma-ok
-		value := c.getValue(frame, expr.Tuple)
-		return c.builder.CreateExtractValue(value, expr.Index, "")
+		value := b.getValue(expr.Tuple)
+		return b.CreateExtractValue(value, expr.Index, "")
 	} else {
 		// Select statements are (index, ok, ...) where ... is a number of
 		// received values, depending on how many receive statements there
 		// are. They are all combined into one alloca (because only one
 		// receive can proceed at a time) so we'll get that alloca, bitcast
 		// it to the correct type, and dereference it.
-		recvbuf := frame.selectRecvBuf[expr.Tuple.(*ssa.Select)]
-		typ := llvm.PointerType(c.getLLVMType(expr.Type()), 0)
-		ptr := c.builder.CreateBitCast(recvbuf, typ, "")
-		return c.builder.CreateLoad(ptr, "")
+		recvbuf := b.selectRecvBuf[expr.Tuple.(*ssa.Select)]
+		typ := llvm.PointerType(b.getLLVMType(expr.Type()), 0)
+		ptr := b.CreateBitCast(recvbuf, typ, "")
+		return b.CreateLoad(ptr, "")
 	}
 }

compiler/defer.go

@@ -14,6 +14,7 @@ package compiler
 //     frames.
 
 import (
+	"github.com/tinygo-org/tinygo/compiler/llvmutil"
 	"github.com/tinygo-org/tinygo/ir"
 	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
@@ -22,65 +23,100 @@ import (
 // deferInitFunc sets up this function for future deferred calls. It must be
 // called from within the entry block when this function contains deferred
 // calls.
-func (c *Compiler) deferInitFunc(frame *Frame) {
+func (b *builder) deferInitFunc() {
 	// Some setup.
-	frame.deferFuncs = make(map[*ir.Function]int)
-	frame.deferInvokeFuncs = make(map[string]int)
-	frame.deferClosureFuncs = make(map[*ir.Function]int)
+	b.deferFuncs = make(map[*ir.Function]int)
+	b.deferInvokeFuncs = make(map[string]int)
+	b.deferClosureFuncs = make(map[*ir.Function]int)
 
 	// Create defer list pointer.
-	deferType := llvm.PointerType(c.getLLVMRuntimeType("_defer"), 0)
-	frame.deferPtr = c.builder.CreateAlloca(deferType, "deferPtr")
-	c.builder.CreateStore(llvm.ConstPointerNull(deferType), frame.deferPtr)
+	deferType := llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0)
+	b.deferPtr = b.CreateAlloca(deferType, "deferPtr")
+	b.CreateStore(llvm.ConstPointerNull(deferType), b.deferPtr)
 }
 
-// emitDefer emits a single defer instruction, to be run when this function
+// isInLoop checks if there is a path from a basic block to itself.
+func isInLoop(start *ssa.BasicBlock) bool {
+	// Use a breadth-first search to scan backwards through the block graph.
+	queue := []*ssa.BasicBlock{start}
+	checked := map[*ssa.BasicBlock]struct{}{}
+
+	for len(queue) > 0 {
+		// pop a block off of the queue
+		block := queue[len(queue)-1]
+		queue = queue[:len(queue)-1]
+
+		// Search through predecessors.
+		// Searching backwards means that this is pretty fast when the block is close to the start of the function.
+		// Defers are often placed near the start of the function.
+		for _, pred := range block.Preds {
+			if pred == start {
+				// cycle found
+				return true
+			}
+
+			if _, ok := checked[pred]; ok {
+				// block already checked
+				continue
+			}
+
+			// add to queue and checked map
+			queue = append(queue, pred)
+			checked[pred] = struct{}{}
+		}
+	}
+
+	return false
+}
+
+// createDefer emits a single defer instruction, to be run when this function
 // returns.
-func (c *Compiler) emitDefer(frame *Frame, instr *ssa.Defer) {
+func (b *builder) createDefer(instr *ssa.Defer) {
 	// The pointer to the previous defer struct, which we will replace to
 	// make a linked list.
-	next := c.builder.CreateLoad(frame.deferPtr, "defer.next")
+	next := b.CreateLoad(b.deferPtr, "defer.next")
 
 	var values []llvm.Value
-	valueTypes := []llvm.Type{c.uintptrType, next.Type()}
+	valueTypes := []llvm.Type{b.uintptrType, next.Type()}
 	if instr.Call.IsInvoke() {
 		// Method call on an interface.
 
 		// Get callback type number.
 		methodName := instr.Call.Method.FullName()
-		if _, ok := frame.deferInvokeFuncs[methodName]; !ok {
-			frame.deferInvokeFuncs[methodName] = len(frame.allDeferFuncs)
-			frame.allDeferFuncs = append(frame.allDeferFuncs, &instr.Call)
+		if _, ok := b.deferInvokeFuncs[methodName]; !ok {
+			b.deferInvokeFuncs[methodName] = len(b.allDeferFuncs)
+			b.allDeferFuncs = append(b.allDeferFuncs, &instr.Call)
 		}
-		callback := llvm.ConstInt(c.uintptrType, uint64(frame.deferInvokeFuncs[methodName]), false)
+		callback := llvm.ConstInt(b.uintptrType, uint64(b.deferInvokeFuncs[methodName]), false)
 
 		// Collect all values to be put in the struct (starting with
 		// runtime._defer fields, followed by the call parameters).
-		itf := c.getValue(frame, instr.Call.Value) // interface
-		receiverValue := c.builder.CreateExtractValue(itf, 1, "invoke.func.receiver")
-		values = []llvm.Value{callback, next, receiverValue}
-		valueTypes = append(valueTypes, c.i8ptrType)
+		itf := b.getValue(instr.Call.Value) // interface
+		typecode := b.CreateExtractValue(itf, 0, "invoke.func.typecode")
+		receiverValue := b.CreateExtractValue(itf, 1, "invoke.func.receiver")
+		values = []llvm.Value{callback, next, typecode, receiverValue}
+		valueTypes = append(valueTypes, b.uintptrType, b.i8ptrType)
 		for _, arg := range instr.Call.Args {
-			val := c.getValue(frame, arg)
+			val := b.getValue(arg)
 			values = append(values, val)
 			valueTypes = append(valueTypes, val.Type())
 		}
 
 	} else if callee, ok := instr.Call.Value.(*ssa.Function); ok {
 		// Regular function call.
-		fn := c.ir.GetFunction(callee)
+		fn := b.ir.GetFunction(callee)
 
-		if _, ok := frame.deferFuncs[fn]; !ok {
-			frame.deferFuncs[fn] = len(frame.allDeferFuncs)
-			frame.allDeferFuncs = append(frame.allDeferFuncs, fn)
+		if _, ok := b.deferFuncs[fn]; !ok {
+			b.deferFuncs[fn] = len(b.allDeferFuncs)
+			b.allDeferFuncs = append(b.allDeferFuncs, fn)
 		}
-		callback := llvm.ConstInt(c.uintptrType, uint64(frame.deferFuncs[fn]), false)
+		callback := llvm.ConstInt(b.uintptrType, uint64(b.deferFuncs[fn]), false)
 
 		// Collect all values to be put in the struct (starting with
 		// runtime._defer fields).
 		values = []llvm.Value{callback, next}
 		for _, param := range instr.Call.Args {
-			llvmParam := c.getValue(frame, param)
+			llvmParam := b.getValue(param)
 			values = append(values, llvmParam)
 			valueTypes = append(valueTypes, llvmParam.Type())
 		}
@@ -92,23 +128,23 @@ func (c *Compiler) emitDefer(frame *Frame, instr *ssa.Defer) {
 		// pointer.
 		// TODO: ignore this closure entirely and put pointers to the free
 		// variables directly in the defer struct, avoiding a memory allocation.
-		closure := c.getValue(frame, instr.Call.Value)
-		context := c.builder.CreateExtractValue(closure, 0, "")
+		closure := b.getValue(instr.Call.Value)
+		context := b.CreateExtractValue(closure, 0, "")
 
 		// Get the callback number.
-		fn := c.ir.GetFunction(makeClosure.Fn.(*ssa.Function))
-		if _, ok := frame.deferClosureFuncs[fn]; !ok {
-			frame.deferClosureFuncs[fn] = len(frame.allDeferFuncs)
-			frame.allDeferFuncs = append(frame.allDeferFuncs, makeClosure)
+		fn := b.ir.GetFunction(makeClosure.Fn.(*ssa.Function))
+		if _, ok := b.deferClosureFuncs[fn]; !ok {
+			b.deferClosureFuncs[fn] = len(b.allDeferFuncs)
+			b.allDeferFuncs = append(b.allDeferFuncs, makeClosure)
 		}
-		callback := llvm.ConstInt(c.uintptrType, uint64(frame.deferClosureFuncs[fn]), false)
+		callback := llvm.ConstInt(b.uintptrType, uint64(b.deferClosureFuncs[fn]), false)
 
 		// Collect all values to be put in the struct (starting with
 		// runtime._defer fields, followed by all parameters including the
 		// context pointer).
 		values = []llvm.Value{callback, next}
 		for _, param := range instr.Call.Args {
-			llvmParam := c.getValue(frame, param)
+			llvmParam := b.getValue(param)
 			values = append(values, llvmParam)
 			valueTypes = append(valueTypes, llvmParam.Type())
 		}
@@ -116,31 +152,41 @@ func (c *Compiler) emitDefer(frame *Frame, instr *ssa.Defer) {
 		valueTypes = append(valueTypes, context.Type())
 
 	} else {
-		c.addError(instr.Pos(), "todo: defer on uncommon function call type")
+		b.addError(instr.Pos(), "todo: defer on uncommon function call type")
 		return
 	}
 
 	// Make a struct out of the collected values to put in the defer frame.
-	deferFrameType := c.ctx.StructType(valueTypes, false)
+	deferFrameType := b.ctx.StructType(valueTypes, false)
 	deferFrame := llvm.ConstNull(deferFrameType)
 	for i, value := range values {
-		deferFrame = c.builder.CreateInsertValue(deferFrame, value, i, "")
+		deferFrame = b.CreateInsertValue(deferFrame, value, i, "")
 	}
 
-	// Put this struct in an alloca.
-	alloca := c.builder.CreateAlloca(deferFrameType, "defer.alloca")
-	c.builder.CreateStore(deferFrame, alloca)
-	if c.NeedsStackObjects() {
-		c.trackPointer(alloca)
+	// Put this struct in an allocation.
+	var alloca llvm.Value
+	if !isInLoop(instr.Block()) {
+		// This can safely use a stack allocation.
+		alloca = llvmutil.CreateEntryBlockAlloca(b.Builder, deferFrameType, "defer.alloca")
+	} else {
+		// This may be hit a variable number of times, so use a heap allocation.
+		size := b.targetData.TypeAllocSize(deferFrameType)
+		sizeValue := llvm.ConstInt(b.uintptrType, size, false)
+		allocCall := b.createRuntimeCall("alloc", []llvm.Value{sizeValue}, "defer.alloc.call")
+		alloca = b.CreateBitCast(allocCall, llvm.PointerType(deferFrameType, 0), "defer.alloc")
 	}
+	if b.NeedsStackObjects() {
+		b.trackPointer(alloca)
+	}
+	b.CreateStore(deferFrame, alloca)
 
 	// Push it on top of the linked list by replacing deferPtr.
-	allocaCast := c.builder.CreateBitCast(alloca, next.Type(), "defer.alloca.cast")
-	c.builder.CreateStore(allocaCast, frame.deferPtr)
+	allocaCast := b.CreateBitCast(alloca, next.Type(), "defer.alloca.cast")
+	b.CreateStore(allocaCast, b.deferPtr)
 }
 
-// emitRunDefers emits code to run all deferred functions.
-func (c *Compiler) emitRunDefers(frame *Frame) {
+// createRunDefers emits code to run all deferred functions.
+func (b *builder) createRunDefers() {
 	// Add a loop like the following:
 	//     for stack != nil {
 	//         _stack := stack
@@ -157,44 +203,44 @@ func (c *Compiler) emitRunDefers(frame *Frame) {
 	//     }
 
 	// Create loop.
-	loophead := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "rundefers.loophead")
-	loop := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "rundefers.loop")
-	unreachable := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "rundefers.default")
-	end := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "rundefers.end")
-	c.builder.CreateBr(loophead)
+	loophead := b.ctx.AddBasicBlock(b.fn.LLVMFn, "rundefers.loophead")
+	loop := b.ctx.AddBasicBlock(b.fn.LLVMFn, "rundefers.loop")
+	unreachable := b.ctx.AddBasicBlock(b.fn.LLVMFn, "rundefers.default")
+	end := b.ctx.AddBasicBlock(b.fn.LLVMFn, "rundefers.end")
+	b.CreateBr(loophead)
 
 	// Create loop head:
 	//     for stack != nil {
-	c.builder.SetInsertPointAtEnd(loophead)
-	deferData := c.builder.CreateLoad(frame.deferPtr, "")
-	stackIsNil := c.builder.CreateICmp(llvm.IntEQ, deferData, llvm.ConstPointerNull(deferData.Type()), "stackIsNil")
-	c.builder.CreateCondBr(stackIsNil, end, loop)
+	b.SetInsertPointAtEnd(loophead)
+	deferData := b.CreateLoad(b.deferPtr, "")
+	stackIsNil := b.CreateICmp(llvm.IntEQ, deferData, llvm.ConstPointerNull(deferData.Type()), "stackIsNil")
+	b.CreateCondBr(stackIsNil, end, loop)
 
 	// Create loop body:
 	//     _stack := stack
 	//     stack = stack.next
 	//     switch stack.callback {
-	c.builder.SetInsertPointAtEnd(loop)
-	nextStackGEP := c.builder.CreateInBoundsGEP(deferData, []llvm.Value{
-		llvm.ConstInt(c.ctx.Int32Type(), 0, false),
-		llvm.ConstInt(c.ctx.Int32Type(), 1, false), // .next field
+	b.SetInsertPointAtEnd(loop)
+	nextStackGEP := b.CreateInBoundsGEP(deferData, []llvm.Value{
+		llvm.ConstInt(b.ctx.Int32Type(), 0, false),
+		llvm.ConstInt(b.ctx.Int32Type(), 1, false), // .next field
 	}, "stack.next.gep")
-	nextStack := c.builder.CreateLoad(nextStackGEP, "stack.next")
-	c.builder.CreateStore(nextStack, frame.deferPtr)
-	gep := c.builder.CreateInBoundsGEP(deferData, []llvm.Value{
-		llvm.ConstInt(c.ctx.Int32Type(), 0, false),
-		llvm.ConstInt(c.ctx.Int32Type(), 0, false), // .callback field
+	nextStack := b.CreateLoad(nextStackGEP, "stack.next")
+	b.CreateStore(nextStack, b.deferPtr)
+	gep := b.CreateInBoundsGEP(deferData, []llvm.Value{
+		llvm.ConstInt(b.ctx.Int32Type(), 0, false),
+		llvm.ConstInt(b.ctx.Int32Type(), 0, false), // .callback field
 	}, "callback.gep")
-	callback := c.builder.CreateLoad(gep, "callback")
-	sw := c.builder.CreateSwitch(callback, unreachable, len(frame.allDeferFuncs))
+	callback := b.CreateLoad(gep, "callback")
+	sw := b.CreateSwitch(callback, unreachable, len(b.allDeferFuncs))
 
-	for i, callback := range frame.allDeferFuncs {
+	for i, callback := range b.allDeferFuncs {
 		// Create switch case, for example:
 		//     case 0:
 		//         // run first deferred call
-		block := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "rundefers.callback")
-		sw.AddCase(llvm.ConstInt(c.uintptrType, uint64(i), false), block)
-		c.builder.SetInsertPointAtEnd(block)
+		block := b.ctx.AddBasicBlock(b.fn.LLVMFn, "rundefers.callback")
+		sw.AddCase(llvm.ConstInt(b.uintptrType, uint64(i), false), block)
+		b.SetInsertPointAtEnd(block)
 		switch callback := callback.(type) {
 		case *ssa.CallCommon:
 			// Call on an interface value.
@@ -203,105 +249,112 @@ func (c *Compiler) emitRunDefers(frame *Frame) {
 			}
 
 			// Get the real defer struct type and cast to it.
-			valueTypes := []llvm.Type{c.uintptrType, llvm.PointerType(c.getLLVMRuntimeType("_defer"), 0), c.i8ptrType}
+			valueTypes := []llvm.Type{b.uintptrType, llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0), b.uintptrType, b.i8ptrType}
 			for _, arg := range callback.Args {
-				valueTypes = append(valueTypes, c.getLLVMType(arg.Type()))
+				valueTypes = append(valueTypes, b.getLLVMType(arg.Type()))
 			}
-			deferFrameType := c.ctx.StructType(valueTypes, false)
-			deferFramePtr := c.builder.CreateBitCast(deferData, llvm.PointerType(deferFrameType, 0), "deferFrame")
+			deferFrameType := b.ctx.StructType(valueTypes, false)
+			deferFramePtr := b.CreateBitCast(deferData, llvm.PointerType(deferFrameType, 0), "deferFrame")
 
 			// Extract the params from the struct (including receiver).
 			forwardParams := []llvm.Value{}
-			zero := llvm.ConstInt(c.ctx.Int32Type(), 0, false)
+			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
 			for i := 2; i < len(valueTypes); i++ {
-				gep := c.builder.CreateInBoundsGEP(deferFramePtr, []llvm.Value{zero, llvm.ConstInt(c.ctx.Int32Type(), uint64(i), false)}, "gep")
-				forwardParam := c.builder.CreateLoad(gep, "param")
+				gep := b.CreateInBoundsGEP(deferFramePtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false)}, "gep")
+				forwardParam := b.CreateLoad(gep, "param")
 				forwardParams = append(forwardParams, forwardParam)
 			}
 
+			// Isolate the typecode.
+			typecode, forwardParams := forwardParams[0], forwardParams[1:]
+
 			// Add the context parameter. An interface call cannot also be a
 			// closure but we have to supply the parameter anyway for platforms
 			// with a strict calling convention.
-			forwardParams = append(forwardParams, llvm.Undef(c.i8ptrType))
+			forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))
 
 			// Parent coroutine handle.
-			forwardParams = append(forwardParams, llvm.Undef(c.i8ptrType))
+			forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))
 
-			fnPtr, _ := c.getInvokeCall(frame, callback)
-			c.createCall(fnPtr, forwardParams, "")
+			fnPtr := b.getInvokePtr(callback, typecode)
+			b.createCall(fnPtr, forwardParams, "")
 
 		case *ir.Function:
 			// Direct call.
 
 			// Get the real defer struct type and cast to it.
-			valueTypes := []llvm.Type{c.uintptrType, llvm.PointerType(c.getLLVMRuntimeType("_defer"), 0)}
+			valueTypes := []llvm.Type{b.uintptrType, llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0)}
 			for _, param := range callback.Params {
-				valueTypes = append(valueTypes, c.getLLVMType(param.Type()))
+				valueTypes = append(valueTypes, b.getLLVMType(param.Type()))
 			}
-			deferFrameType := c.ctx.StructType(valueTypes, false)
-			deferFramePtr := c.builder.CreateBitCast(deferData, llvm.PointerType(deferFrameType, 0), "deferFrame")
+			deferFrameType := b.ctx.StructType(valueTypes, false)
+			deferFramePtr := b.CreateBitCast(deferData, llvm.PointerType(deferFrameType, 0), "deferFrame")
 
 			// Extract the params from the struct.
 			forwardParams := []llvm.Value{}
-			zero := llvm.ConstInt(c.ctx.Int32Type(), 0, false)
+			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
 			for i := range callback.Params {
-				gep := c.builder.CreateInBoundsGEP(deferFramePtr, []llvm.Value{zero, llvm.ConstInt(c.ctx.Int32Type(), uint64(i+2), false)}, "gep")
-				forwardParam := c.builder.CreateLoad(gep, "param")
+				gep := b.CreateInBoundsGEP(deferFramePtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i+2), false)}, "gep")
+				forwardParam := b.CreateLoad(gep, "param")
 				forwardParams = append(forwardParams, forwardParam)
 			}
 
-			// Add the context parameter. We know it is ignored by the receiving
-			// function, but we have to pass one anyway.
-			forwardParams = append(forwardParams, llvm.Undef(c.i8ptrType))
+			// Plain TinyGo functions add some extra parameters to implement async functionality and function recievers.
+			// These parameters should not be supplied when calling into an external C/ASM function.
+			if !callback.IsExported() {
+				// Add the context parameter. We know it is ignored by the receiving
+				// function, but we have to pass one anyway.
+				forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))
 
-			// Parent coroutine handle.
-			forwardParams = append(forwardParams, llvm.Undef(c.i8ptrType))
+				// Parent coroutine handle.
+				forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))
+			}
 
 			// Call real function.
-			c.createCall(callback.LLVMFn, forwardParams, "")
+			b.createCall(callback.LLVMFn, forwardParams, "")
 
 		case *ssa.MakeClosure:
 			// Get the real defer struct type and cast to it.
-			fn := c.ir.GetFunction(callback.Fn.(*ssa.Function))
-			valueTypes := []llvm.Type{c.uintptrType, llvm.PointerType(c.getLLVMRuntimeType("_defer"), 0)}
+			fn := b.ir.GetFunction(callback.Fn.(*ssa.Function))
+			valueTypes := []llvm.Type{b.uintptrType, llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0)}
 			params := fn.Signature.Params()
 			for i := 0; i < params.Len(); i++ {
-				valueTypes = append(valueTypes, c.getLLVMType(params.At(i).Type()))
+				valueTypes = append(valueTypes, b.getLLVMType(params.At(i).Type()))
 			}
-			valueTypes = append(valueTypes, c.i8ptrType) // closure
-			deferFrameType := c.ctx.StructType(valueTypes, false)
-			deferFramePtr := c.builder.CreateBitCast(deferData, llvm.PointerType(deferFrameType, 0), "deferFrame")
+			valueTypes = append(valueTypes, b.i8ptrType) // closure
+			deferFrameType := b.ctx.StructType(valueTypes, false)
+			deferFramePtr := b.CreateBitCast(deferData, llvm.PointerType(deferFrameType, 0), "deferFrame")
 
 			// Extract the params from the struct.
 			forwardParams := []llvm.Value{}
-			zero := llvm.ConstInt(c.ctx.Int32Type(), 0, false)
+			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
 			for i := 2; i < len(valueTypes); i++ {
-				gep := c.builder.CreateInBoundsGEP(deferFramePtr, []llvm.Value{zero, llvm.ConstInt(c.ctx.Int32Type(), uint64(i), false)}, "")
-				forwardParam := c.builder.CreateLoad(gep, "param")
+				gep := b.CreateInBoundsGEP(deferFramePtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false)}, "")
+				forwardParam := b.CreateLoad(gep, "param")
 				forwardParams = append(forwardParams, forwardParam)
 			}
 
 			// Parent coroutine handle.
-			forwardParams = append(forwardParams, llvm.Undef(c.i8ptrType))
+			forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))
 
 			// Call deferred function.
-			c.createCall(fn.LLVMFn, forwardParams, "")
+			b.createCall(fn.LLVMFn, forwardParams, "")
 
 		default:
 			panic("unknown deferred function type")
 		}
 
 		// Branch back to the start of the loop.
-		c.builder.CreateBr(loophead)
+		b.CreateBr(loophead)
 	}
 
 	// Create default unreachable block:
 	//     default:
 	//         unreachable
 	//     }
-	c.builder.SetInsertPointAtEnd(unreachable)
-	c.builder.CreateUnreachable()
+	b.SetInsertPointAtEnd(unreachable)
+	b.CreateUnreachable()
 
 	// End of loop.
-	c.builder.SetInsertPointAtEnd(end)
+	b.SetInsertPointAtEnd(end)
 }

compiler/errors.go

@@ -1,11 +1,18 @@
 package compiler
 
+// This file contains some utility functions related to error handling.
+
 import (
+	"go/scanner"
 	"go/token"
 	"go/types"
+	"path/filepath"
+
+	"tinygo.org/x/go-llvm"
 )
 
-func (c *Compiler) makeError(pos token.Pos, msg string) types.Error {
+// makeError makes it easy to create an error from a token.Pos with a message.
+func (c *compilerContext) makeError(pos token.Pos, msg string) types.Error {
 	return types.Error{
 		Fset: c.ir.Program.Fset,
 		Pos:  pos,
@@ -13,6 +20,45 @@ func (c *Compiler) makeError(pos token.Pos, msg string) types.Error {
 	}
 }
 
-func (c *Compiler) addError(pos token.Pos, msg string) {
+func (c *compilerContext) addError(pos token.Pos, msg string) {
 	c.diagnostics = append(c.diagnostics, c.makeError(pos, msg))
 }
+
+// errorAt returns an error value at the location of the instruction.
+// The location information may not be complete as it depends on debug
+// information in the IR.
+func errorAt(inst llvm.Value, msg string) scanner.Error {
+	return scanner.Error{
+		Pos: getPosition(inst),
+		Msg: msg,
+	}
+}
+
+// getPosition returns the position information for the given value, as far as
+// it is available.
+func getPosition(val llvm.Value) token.Position {
+	if !val.IsAInstruction().IsNil() {
+		loc := val.InstructionDebugLoc()
+		if loc.IsNil() {
+			return token.Position{}
+		}
+		file := loc.LocationScope().ScopeFile()
+		return token.Position{
+			Filename: filepath.Join(file.FileDirectory(), file.FileFilename()),
+			Line:     int(loc.LocationLine()),
+			Column:   int(loc.LocationColumn()),
+		}
+	} else if !val.IsAFunction().IsNil() {
+		loc := val.Subprogram()
+		if loc.IsNil() {
+			return token.Position{}
+		}
+		file := loc.ScopeFile()
+		return token.Position{
+			Filename: filepath.Join(file.FileDirectory(), file.FileFilename()),
+			Line:     int(loc.SubprogramLine()),
+		}
+	} else {
+		return token.Position{}
+	}
+}

compiler/func-lowering.go

@@ -1,293 +0,0 @@
-package compiler
-
-// This file lowers func values into their final form. This is necessary for
-// funcValueSwitch, which needs full program analysis.
-
-import (
-	"sort"
-	"strconv"
-
-	"tinygo.org/x/go-llvm"
-)
-
-// funcSignatureInfo keeps information about a single signature and its uses.
-type funcSignatureInfo struct {
-	sig                     llvm.Value   // *uint8 to identify the signature
-	funcValueWithSignatures []llvm.Value // slice of runtime.funcValueWithSignature
-}
-
-// funcWithUses keeps information about a single function used as func value and
-// the assigned function ID. More commonly used functions are assigned a lower
-// ID.
-type funcWithUses struct {
-	funcPtr  llvm.Value
-	useCount int // how often this function is used in a func value
-	id       int // assigned ID
-}
-
-// Slice to sort functions by their use counts, or else their name if they're
-// used equally often.
-type funcWithUsesList []*funcWithUses
-
-func (l funcWithUsesList) Len() int { return len(l) }
-func (l funcWithUsesList) Less(i, j int) bool {
-	if l[i].useCount != l[j].useCount {
-		// return the reverse: we want the highest use counts sorted first
-		return l[i].useCount > l[j].useCount
-	}
-	iName := l[i].funcPtr.Name()
-	jName := l[j].funcPtr.Name()
-	return iName < jName
-}
-func (l funcWithUsesList) Swap(i, j int) {
-	l[i], l[j] = l[j], l[i]
-}
-
-// LowerFuncValue lowers the runtime.funcValueWithSignature type and
-// runtime.getFuncPtr function to their final form.
-func (c *Compiler) LowerFuncValues() {
-	if c.funcImplementation() != funcValueSwitch {
-		return
-	}
-
-	// Find all func values used in the program with their signatures.
-	funcValueWithSignaturePtr := llvm.PointerType(c.getLLVMRuntimeType("funcValueWithSignature"), 0)
-	signatures := map[string]*funcSignatureInfo{}
-	for global := c.mod.FirstGlobal(); !global.IsNil(); global = llvm.NextGlobal(global) {
-		if global.Type() != funcValueWithSignaturePtr {
-			continue
-		}
-		sig := llvm.ConstExtractValue(global.Initializer(), []uint32{1})
-		name := sig.Name()
-		if info, ok := signatures[name]; ok {
-			info.funcValueWithSignatures = append(info.funcValueWithSignatures, global)
-		} else {
-			signatures[name] = &funcSignatureInfo{
-				sig:                     sig,
-				funcValueWithSignatures: []llvm.Value{global},
-			}
-		}
-	}
-
-	// Sort the signatures, for deterministic execution.
-	names := make([]string, 0, len(signatures))
-	for name := range signatures {
-		names = append(names, name)
-	}
-	sort.Strings(names)
-
-	for _, name := range names {
-		info := signatures[name]
-		functions := make(funcWithUsesList, len(info.funcValueWithSignatures))
-		for i, use := range info.funcValueWithSignatures {
-			var useCount int
-			for _, use2 := range getUses(use) {
-				useCount += len(getUses(use2))
-			}
-			functions[i] = &funcWithUses{
-				funcPtr:  llvm.ConstExtractValue(use.Initializer(), []uint32{0}).Operand(0),
-				useCount: useCount,
-			}
-		}
-		sort.Sort(functions)
-
-		for i, fn := range functions {
-			fn.id = i + 1
-			for _, ptrtoint := range getUses(fn.funcPtr) {
-				if ptrtoint.IsAConstantExpr().IsNil() || ptrtoint.Opcode() != llvm.PtrToInt {
-					continue
-				}
-				for _, funcValueWithSignatureConstant := range getUses(ptrtoint) {
-					if !funcValueWithSignatureConstant.IsACallInst().IsNil() && funcValueWithSignatureConstant.CalledValue().Name() == "runtime.makeGoroutine" {
-						// makeGoroutine calls are handled seperately
-						continue
-					}
-					for _, funcValueWithSignatureGlobal := range getUses(funcValueWithSignatureConstant) {
-						for _, use := range getUses(funcValueWithSignatureGlobal) {
-							if ptrtoint.IsAConstantExpr().IsNil() || ptrtoint.Opcode() != llvm.PtrToInt {
-								panic("expected const ptrtoint")
-							}
-							use.ReplaceAllUsesWith(llvm.ConstInt(c.uintptrType, uint64(fn.id), false))
-						}
-					}
-				}
-			}
-		}
-
-		for _, getFuncPtrCall := range getUses(info.sig) {
-			if getFuncPtrCall.IsACallInst().IsNil() {
-				continue
-			}
-			if getFuncPtrCall.CalledValue().Name() != "runtime.getFuncPtr" {
-				panic("expected all call uses to be runtime.getFuncPtr")
-			}
-			funcID := getFuncPtrCall.Operand(1)
-			switch len(functions) {
-			case 0:
-				// There are no functions used in a func value that implement
-				// this signature. The only possible value is a nil value.
-				for _, inttoptr := range getUses(getFuncPtrCall) {
-					if inttoptr.IsAIntToPtrInst().IsNil() {
-						panic("expected inttoptr")
-					}
-					nilptr := llvm.ConstPointerNull(inttoptr.Type())
-					inttoptr.ReplaceAllUsesWith(nilptr)
-					inttoptr.EraseFromParentAsInstruction()
-				}
-				getFuncPtrCall.EraseFromParentAsInstruction()
-			case 1:
-				// There is exactly one function with this signature that is
-				// used in a func value. The func value itself can be either nil
-				// or this one function.
-				c.builder.SetInsertPointBefore(getFuncPtrCall)
-				zero := llvm.ConstInt(c.uintptrType, 0, false)
-				isnil := c.builder.CreateICmp(llvm.IntEQ, funcID, zero, "")
-				funcPtrNil := llvm.ConstPointerNull(functions[0].funcPtr.Type())
-				funcPtr := c.builder.CreateSelect(isnil, funcPtrNil, functions[0].funcPtr, "")
-				for _, inttoptr := range getUses(getFuncPtrCall) {
-					if inttoptr.IsAIntToPtrInst().IsNil() {
-						panic("expected inttoptr")
-					}
-					inttoptr.ReplaceAllUsesWith(funcPtr)
-					inttoptr.EraseFromParentAsInstruction()
-				}
-				getFuncPtrCall.EraseFromParentAsInstruction()
-			default:
-				// There are multiple functions used in a func value that
-				// implement this signature.
-				// What we'll do is transform the following:
-				//     rawPtr := runtime.getFuncPtr(func.ptr)
-				//     if rawPtr == nil {
-				//         runtime.nilPanic()
-				//     }
-				//     result := rawPtr(...args, func.context)
-				// into this:
-				//     if false {
-				//         runtime.nilPanic()
-				//     }
-				//     var result // Phi
-				//     switch fn.id {
-				//     case 0:
-				//         runtime.nilPanic()
-				//     case 1:
-				//         result = call first implementation...
-				//     case 2:
-				//         result = call second implementation...
-				//     default:
-				//         unreachable
-				//     }
-
-				// Remove some casts, checks, and the old call which we're going
-				// to replace.
-				for _, callIntPtr := range getUses(getFuncPtrCall) {
-					if !callIntPtr.IsACallInst().IsNil() && callIntPtr.CalledValue().Name() == "runtime.makeGoroutine" {
-						for _, inttoptr := range getUses(callIntPtr) {
-							if inttoptr.IsAIntToPtrInst().IsNil() {
-								panic("expected a inttoptr")
-							}
-							for _, use := range getUses(inttoptr) {
-								c.addFuncLoweringSwitch(funcID, use, func(funcPtr llvm.Value, params []llvm.Value) llvm.Value {
-									// The function lowering switch code passes in a parent handle value.
-									// Strip the parent handle off here because it is irrelevant to goroutine starts.
-									return c.emitStartGoroutine(funcPtr, params[:len(params)-1])
-								}, functions)
-								use.EraseFromParentAsInstruction()
-							}
-							inttoptr.EraseFromParentAsInstruction()
-						}
-						callIntPtr.EraseFromParentAsInstruction()
-						continue
-					}
-					if callIntPtr.IsAIntToPtrInst().IsNil() {
-						panic("expected inttoptr")
-					}
-					for _, ptrUse := range getUses(callIntPtr) {
-						if !ptrUse.IsABitCastInst().IsNil() {
-							for _, bitcastUse := range getUses(ptrUse) {
-								if bitcastUse.IsACallInst().IsNil() || bitcastUse.CalledValue().IsAFunction().IsNil() {
-									panic("expected a call instruction")
-								}
-								switch bitcastUse.CalledValue().Name() {
-								case "runtime.isnil":
-									bitcastUse.ReplaceAllUsesWith(llvm.ConstInt(c.ctx.Int1Type(), 0, false))
-									bitcastUse.EraseFromParentAsInstruction()
-								default:
-									panic("expected a call to runtime.isnil")
-								}
-							}
-						} else if !ptrUse.IsACallInst().IsNil() && ptrUse.CalledValue() == callIntPtr {
-							c.addFuncLoweringSwitch(funcID, ptrUse, func(funcPtr llvm.Value, params []llvm.Value) llvm.Value {
-								return c.builder.CreateCall(funcPtr, params, "")
-							}, functions)
-						} else {
-							panic("unexpected getFuncPtrCall")
-						}
-						ptrUse.EraseFromParentAsInstruction()
-					}
-					callIntPtr.EraseFromParentAsInstruction()
-				}
-				getFuncPtrCall.EraseFromParentAsInstruction()
-			}
-		}
-	}
-}
-
-// addFuncLoweringSwitch creates a new switch on a function ID and inserts calls
-// to the newly created direct calls. The funcID is the number to switch on,
-// call is the call instruction to replace, and createCall is the callback that
-// actually creates the new call. By changing createCall to something other than
-// c.builder.CreateCall, instead of calling a function it can start a new
-// goroutine for example.
-func (c *Compiler) addFuncLoweringSwitch(funcID, call llvm.Value, createCall func(funcPtr llvm.Value, params []llvm.Value) llvm.Value, functions funcWithUsesList) {
-	// The block that cannot be reached with correct funcValues (to help the
-	// optimizer).
-	c.builder.SetInsertPointBefore(call)
-	defaultBlock := c.ctx.AddBasicBlock(call.InstructionParent().Parent(), "func.default")
-	c.builder.SetInsertPointAtEnd(defaultBlock)
-	c.builder.CreateUnreachable()
-
-	// Create the switch.
-	c.builder.SetInsertPointBefore(call)
-	sw := c.builder.CreateSwitch(funcID, defaultBlock, len(functions)+1)
-
-	// Split right after the switch. We will need to insert a few basic blocks
-	// in this gap.
-	nextBlock := c.splitBasicBlock(sw, llvm.NextBasicBlock(sw.InstructionParent()), "func.next")
-
-	// The 0 case, which is actually a nil check.
-	nilBlock := c.ctx.InsertBasicBlock(nextBlock, "func.nil")
-	c.builder.SetInsertPointAtEnd(nilBlock)
-	c.createRuntimeCall("nilPanic", nil, "")
-	c.builder.CreateUnreachable()
-	sw.AddCase(llvm.ConstInt(c.uintptrType, 0, false), nilBlock)
-
-	// Gather the list of parameters for every call we're going to make.
-	callParams := make([]llvm.Value, call.OperandsCount()-1)
-	for i := range callParams {
-		callParams[i] = call.Operand(i)
-	}
-
-	// If the call produces a value, we need to get it using a PHI
-	// node.
-	phiBlocks := make([]llvm.BasicBlock, len(functions))
-	phiValues := make([]llvm.Value, len(functions))
-	for i, fn := range functions {
-		// Insert a switch case.
-		bb := c.ctx.InsertBasicBlock(nextBlock, "func.call"+strconv.Itoa(fn.id))
-		c.builder.SetInsertPointAtEnd(bb)
-		result := createCall(fn.funcPtr, callParams)
-		c.builder.CreateBr(nextBlock)
-		sw.AddCase(llvm.ConstInt(c.uintptrType, uint64(fn.id), false), bb)
-		phiBlocks[i] = bb
-		phiValues[i] = result
-	}
-	// Create the PHI node so that the call result flows into the
-	// next block (after the split). This is only necessary when the
-	// call produced a value.
-	if call.Type().TypeKind() != llvm.VoidTypeKind {
-		c.builder.SetInsertPointBefore(nextBlock.FirstInstruction())
-		phi := c.builder.CreatePHI(call.Type(), "")
-		phi.AddIncoming(phiValues, phiBlocks)
-		call.ReplaceAllUsesWith(phi)
-	}
-}

compiler/func.go

@@ -6,53 +6,26 @@ package compiler
 import (
 	"go/types"
 
+	"github.com/tinygo-org/tinygo/compileopts"
 	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )
 
-type funcValueImplementation int
-
-const (
-	funcValueNone funcValueImplementation = iota
-
-	// A func value is implemented as a pair of pointers:
-	//     {context, function pointer}
-	// where the context may be a pointer to a heap-allocated struct containing
-	// the free variables, or it may be undef if the function being pointed to
-	// doesn't need a context. The function pointer is a regular function
-	// pointer.
-	funcValueDoubleword
-
-	// As funcValueDoubleword, but with the function pointer replaced by a
-	// unique ID per function signature. Function values are called by using a
-	// switch statement and choosing which function to call.
-	funcValueSwitch
-)
-
-// funcImplementation picks an appropriate func value implementation for the
-// target.
-func (c *Compiler) funcImplementation() funcValueImplementation {
-	// Always pick the switch implementation, as it allows the use of blocking
-	// inside a function that is used as a func value.
-	switch c.Scheduler() {
-	case "coroutines":
-		return funcValueSwitch
-	case "tasks":
-		return funcValueDoubleword
-	default:
-		panic("unknown scheduler type")
-	}
+// createFuncValue creates a function value from a raw function pointer with no
+// context.
+func (b *builder) createFuncValue(funcPtr, context llvm.Value, sig *types.Signature) llvm.Value {
+	return b.compilerContext.createFuncValue(b.Builder, funcPtr, context, sig)
 }
 
 // createFuncValue creates a function value from a raw function pointer with no
 // context.
-func (c *Compiler) createFuncValue(funcPtr, context llvm.Value, sig *types.Signature) llvm.Value {
+func (c *compilerContext) createFuncValue(builder llvm.Builder, funcPtr, context llvm.Value, sig *types.Signature) llvm.Value {
 	var funcValueScalar llvm.Value
-	switch c.funcImplementation() {
-	case funcValueDoubleword:
+	switch c.FuncImplementation() {
+	case compileopts.FuncValueDoubleword:
 		// Closure is: {context, function pointer}
 		funcValueScalar = funcPtr
-	case funcValueSwitch:
+	case compileopts.FuncValueSwitch:
 		sigGlobal := c.getTypeCode(sig)
 		funcValueWithSignatureGlobalName := funcPtr.Name() + "$withSignature"
 		funcValueWithSignatureGlobal := c.mod.NamedGlobal(funcValueWithSignatureGlobalName)
@@ -73,35 +46,35 @@ func (c *Compiler) createFuncValue(funcPtr, context llvm.Value, sig *types.Signa
 	}
 	funcValueType := c.getFuncType(sig)
 	funcValue := llvm.Undef(funcValueType)
-	funcValue = c.builder.CreateInsertValue(funcValue, context, 0, "")
-	funcValue = c.builder.CreateInsertValue(funcValue, funcValueScalar, 1, "")
+	funcValue = builder.CreateInsertValue(funcValue, context, 0, "")
+	funcValue = builder.CreateInsertValue(funcValue, funcValueScalar, 1, "")
 	return funcValue
 }
 
 // extractFuncScalar returns some scalar that can be used in comparisons. It is
 // a cheap operation.
-func (c *Compiler) extractFuncScalar(funcValue llvm.Value) llvm.Value {
-	return c.builder.CreateExtractValue(funcValue, 1, "")
+func (b *builder) extractFuncScalar(funcValue llvm.Value) llvm.Value {
+	return b.CreateExtractValue(funcValue, 1, "")
 }
 
 // extractFuncContext extracts the context pointer from this function value. It
 // is a cheap operation.
-func (c *Compiler) extractFuncContext(funcValue llvm.Value) llvm.Value {
-	return c.builder.CreateExtractValue(funcValue, 0, "")
+func (b *builder) extractFuncContext(funcValue llvm.Value) llvm.Value {
+	return b.CreateExtractValue(funcValue, 0, "")
 }
 
 // decodeFuncValue extracts the context and the function pointer from this func
 // value. This may be an expensive operation.
-func (c *Compiler) decodeFuncValue(funcValue llvm.Value, sig *types.Signature) (funcPtr, context llvm.Value) {
-	context = c.builder.CreateExtractValue(funcValue, 0, "")
-	switch c.funcImplementation() {
-	case funcValueDoubleword:
-		funcPtr = c.builder.CreateExtractValue(funcValue, 1, "")
-	case funcValueSwitch:
-		llvmSig := c.getRawFuncType(sig)
-		sigGlobal := c.getTypeCode(sig)
-		funcPtr = c.createRuntimeCall("getFuncPtr", []llvm.Value{funcValue, sigGlobal}, "")
-		funcPtr = c.builder.CreateIntToPtr(funcPtr, llvmSig, "")
+func (b *builder) decodeFuncValue(funcValue llvm.Value, sig *types.Signature) (funcPtr, context llvm.Value) {
+	context = b.CreateExtractValue(funcValue, 0, "")
+	switch b.FuncImplementation() {
+	case compileopts.FuncValueDoubleword:
+		funcPtr = b.CreateExtractValue(funcValue, 1, "")
+	case compileopts.FuncValueSwitch:
+		llvmSig := b.getRawFuncType(sig)
+		sigGlobal := b.getTypeCode(sig)
+		funcPtr = b.createRuntimeCall("getFuncPtr", []llvm.Value{funcValue, sigGlobal}, "")
+		funcPtr = b.CreateIntToPtr(funcPtr, llvmSig, "")
 	default:
 		panic("unimplemented func value variant")
 	}
@@ -109,12 +82,12 @@ func (c *Compiler) decodeFuncValue(funcValue llvm.Value, sig *types.Signature) (
 }
 
 // getFuncType returns the type of a func value given a signature.
-func (c *Compiler) getFuncType(typ *types.Signature) llvm.Type {
-	switch c.funcImplementation() {
-	case funcValueDoubleword:
+func (c *compilerContext) getFuncType(typ *types.Signature) llvm.Type {
+	switch c.FuncImplementation() {
+	case compileopts.FuncValueDoubleword:
 		rawPtr := c.getRawFuncType(typ)
 		return c.ctx.StructType([]llvm.Type{c.i8ptrType, rawPtr}, false)
-	case funcValueSwitch:
+	case compileopts.FuncValueSwitch:
 		return c.getLLVMRuntimeType("funcValue")
 	default:
 		panic("unimplemented func value variant")
@@ -122,7 +95,7 @@ func (c *Compiler) getFuncType(typ *types.Signature) llvm.Type {
 }
 
 // getRawFuncType returns a LLVM function pointer type for a given signature.
-func (c *Compiler) getRawFuncType(typ *types.Signature) llvm.Type {
+func (c *compilerContext) getRawFuncType(typ *types.Signature) llvm.Type {
 	// Get the return type.
 	var returnType llvm.Type
 	switch typ.Results().Len() {
@@ -152,11 +125,15 @@ func (c *Compiler) getRawFuncType(typ *types.Signature) llvm.Type {
 			// The receiver is not an interface, but a i8* type.
 			recv = c.i8ptrType
 		}
-		paramTypes = append(paramTypes, c.expandFormalParamType(recv)...)
+		for _, info := range expandFormalParamType(recv, "", nil) {
+			paramTypes = append(paramTypes, info.llvmType)
+		}
 	}
 	for i := 0; i < typ.Params().Len(); i++ {
 		subType := c.getLLVMType(typ.Params().At(i).Type())
-		paramTypes = append(paramTypes, c.expandFormalParamType(subType)...)
+		for _, info := range expandFormalParamType(subType, "", nil) {
+			paramTypes = append(paramTypes, info.llvmType)
+		}
 	}
 	// All functions take these parameters at the end.
 	paramTypes = append(paramTypes, c.i8ptrType) // context
@@ -168,24 +145,24 @@ func (c *Compiler) getRawFuncType(typ *types.Signature) llvm.Type {
 
 // parseMakeClosure makes a function value (with context) from the given
 // closure expression.
-func (c *Compiler) parseMakeClosure(frame *Frame, expr *ssa.MakeClosure) (llvm.Value, error) {
+func (b *builder) parseMakeClosure(expr *ssa.MakeClosure) (llvm.Value, error) {
 	if len(expr.Bindings) == 0 {
 		panic("unexpected: MakeClosure without bound variables")
 	}
-	f := c.ir.GetFunction(expr.Fn.(*ssa.Function))
+	f := b.ir.GetFunction(expr.Fn.(*ssa.Function))
 
 	// Collect all bound variables.
 	boundVars := make([]llvm.Value, len(expr.Bindings))
 	for i, binding := range expr.Bindings {
 		// The context stores the bound variables.
-		llvmBoundVar := c.getValue(frame, binding)
+		llvmBoundVar := b.getValue(binding)
 		boundVars[i] = llvmBoundVar
 	}
 
 	// Store the bound variables in a single object, allocating it on the heap
 	// if necessary.
-	context := c.emitPointerPack(boundVars)
+	context := b.emitPointerPack(boundVars)
 
 	// Create the closure.
-	return c.createFuncValue(f.LLVMFn, context, f.Signature), nil
+	return b.createFuncValue(f.LLVMFn, context, f.Signature), nil
 }

compiler/gc.go

@@ -12,53 +12,59 @@ import (
 
 // trackExpr inserts pointer tracking intrinsics for the GC if the expression is
 // one of the expressions that need this.
-func (c *Compiler) trackExpr(frame *Frame, expr ssa.Value, value llvm.Value) {
+func (b *builder) trackExpr(expr ssa.Value, value llvm.Value) {
 	// There are uses of this expression, Make sure the pointers
 	// are tracked during GC.
 	switch expr := expr.(type) {
 	case *ssa.Alloc, *ssa.MakeChan, *ssa.MakeMap:
 		// These values are always of pointer type in IR.
-		c.trackPointer(value)
+		b.trackPointer(value)
 	case *ssa.Call, *ssa.Convert, *ssa.MakeClosure, *ssa.MakeInterface, *ssa.MakeSlice, *ssa.Next:
 		if !value.IsNil() {
-			c.trackValue(value)
+			b.trackValue(value)
 		}
 	case *ssa.Select:
-		if alloca, ok := frame.selectRecvBuf[expr]; ok {
+		if alloca, ok := b.selectRecvBuf[expr]; ok {
 			if alloca.IsAUndefValue().IsNil() {
-				c.trackPointer(alloca)
+				b.trackPointer(alloca)
 			}
 		}
 	case *ssa.UnOp:
 		switch expr.Op {
 		case token.MUL:
 			// Pointer dereference.
-			c.trackValue(value)
+			b.trackValue(value)
 		case token.ARROW:
 			// Channel receive operator.
 			// It's not necessary to look at commaOk here, because in that
 			// case it's just an aggregate and trackValue will extract the
 			// pointer in there (if there is one).
-			c.trackValue(value)
+			b.trackValue(value)
+		}
+	case *ssa.BinOp:
+		switch expr.Op {
+		case token.ADD:
+			// String concatenation.
+			b.trackValue(value)
 		}
 	}
 }
 
 // trackValue locates pointers in a value (possibly an aggregate) and tracks the
 // individual pointers
-func (c *Compiler) trackValue(value llvm.Value) {
+func (b *builder) trackValue(value llvm.Value) {
 	typ := value.Type()
 	switch typ.TypeKind() {
 	case llvm.PointerTypeKind:
-		c.trackPointer(value)
+		b.trackPointer(value)
 	case llvm.StructTypeKind:
 		if !typeHasPointers(typ) {
 			return
 		}
 		numElements := typ.StructElementTypesCount()
 		for i := 0; i < numElements; i++ {
-			subValue := c.builder.CreateExtractValue(value, i, "")
-			c.trackValue(subValue)
+			subValue := b.CreateExtractValue(value, i, "")
+			b.trackValue(subValue)
 		}
 	case llvm.ArrayTypeKind:
 		if !typeHasPointers(typ) {
@@ -66,19 +72,19 @@ func (c *Compiler) trackValue(value llvm.Value) {
 		}
 		numElements := typ.ArrayLength()
 		for i := 0; i < numElements; i++ {
-			subValue := c.builder.CreateExtractValue(value, i, "")
-			c.trackValue(subValue)
+			subValue := b.CreateExtractValue(value, i, "")
+			b.trackValue(subValue)
 		}
 	}
 }
 
 // trackPointer creates a call to runtime.trackPointer, bitcasting the poitner
 // first if needed. The input value must be of LLVM pointer type.
-func (c *Compiler) trackPointer(value llvm.Value) {
-	if value.Type() != c.i8ptrType {
-		value = c.builder.CreateBitCast(value, c.i8ptrType, "")
+func (b *builder) trackPointer(value llvm.Value) {
+	if value.Type() != b.i8ptrType {
+		value = b.CreateBitCast(value, b.i8ptrType, "")
 	}
-	c.createRuntimeCall("trackPointer", []llvm.Value{value}, "")
+	b.createRuntimeCall("trackPointer", []llvm.Value{value}, "")
 }
 
 // typeHasPointers returns whether this type is a pointer or contains pointers.

compiler/goroutine.go

@@ -3,34 +3,32 @@ package compiler
 // This file implements the 'go' keyword to start a new goroutine. See
 // goroutine-lowering.go for more details.
 
-import "tinygo.org/x/go-llvm"
+import (
+	"go/token"
 
-// emitStartGoroutine starts a new goroutine with the provided function pointer
+	"github.com/tinygo-org/tinygo/compiler/llvmutil"
+	"tinygo.org/x/go-llvm"
+)
+
+// createGoInstruction starts a new goroutine with the provided function pointer
 // and parameters.
 // In general, you should pass all regular parameters plus the context parameter.
 // There is one exception: the task-based scheduler needs to have the function
 // pointer passed in as a parameter too in addition to the context.
 //
 // Because a go statement doesn't return anything, return undef.
-func (c *Compiler) emitStartGoroutine(funcPtr llvm.Value, params []llvm.Value) llvm.Value {
-	switch c.Scheduler() {
-	case "tasks":
-		paramBundle := c.emitPointerPack(params)
-		paramBundle = c.builder.CreatePtrToInt(paramBundle, c.uintptrType, "")
-
-		calleeValue := c.createGoroutineStartWrapper(funcPtr)
-		c.createRuntimeCall("startGoroutine", []llvm.Value{calleeValue, paramBundle}, "")
+func (b *builder) createGoInstruction(funcPtr llvm.Value, params []llvm.Value, prefix string, pos token.Pos) llvm.Value {
+	paramBundle := b.emitPointerPack(params)
+	var callee llvm.Value
+	switch b.Scheduler() {
+	case "none", "tasks":
+		callee = b.createGoroutineStartWrapper(funcPtr, prefix, pos)
 	case "coroutines":
-		// We roundtrip through runtime.makeGoroutine as a signal (to find these
-		// calls) and to break any optimizations LLVM will try to do: they are
-		// invalid if we called this as a regular function to be updated later.
-		calleeValue := c.builder.CreatePtrToInt(funcPtr, c.uintptrType, "")
-		calleeValue = c.createRuntimeCall("makeGoroutine", []llvm.Value{calleeValue}, "")
-		calleeValue = c.builder.CreateIntToPtr(calleeValue, funcPtr.Type(), "")
-		c.createCall(calleeValue, append(params, llvm.ConstPointerNull(c.i8ptrType)), "")
+		callee = b.CreatePtrToInt(funcPtr, b.uintptrType, "")
 	default:
 		panic("unreachable")
 	}
+	b.createCall(b.mod.NamedFunction("internal/task.start"), []llvm.Value{callee, paramBundle, llvm.Undef(b.i8ptrType), llvm.ConstPointerNull(b.i8ptrType)}, "")
 	return llvm.Undef(funcPtr.Type().ElementType().ReturnType())
 }
 
@@ -52,36 +50,57 @@ func (c *Compiler) emitStartGoroutine(funcPtr llvm.Value, params []llvm.Value) l
 // allows a single (pointer) argument to the newly started goroutine. Also, it
 // ignores the return value because newly started goroutines do not have a
 // return value.
-func (c *Compiler) createGoroutineStartWrapper(fn llvm.Value) llvm.Value {
+func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix string, pos token.Pos) llvm.Value {
 	var wrapper llvm.Value
 
+	builder := c.ctx.NewBuilder()
+	defer builder.Dispose()
+
 	if !fn.IsAFunction().IsNil() {
 		// See whether this wrapper has already been created. If so, return it.
 		name := fn.Name()
 		wrapper = c.mod.NamedFunction(name + "$gowrapper")
 		if !wrapper.IsNil() {
-			return c.builder.CreatePtrToInt(wrapper, c.uintptrType, "")
+			return llvm.ConstPtrToInt(wrapper, c.uintptrType)
 		}
 
-		// Save the current position in the IR builder.
-		currentBlock := c.builder.GetInsertBlock()
-		defer c.builder.SetInsertPointAtEnd(currentBlock)
-
 		// Create the wrapper.
 		wrapperType := llvm.FunctionType(c.ctx.VoidType(), []llvm.Type{c.i8ptrType}, false)
 		wrapper = llvm.AddFunction(c.mod, name+"$gowrapper", wrapperType)
 		wrapper.SetLinkage(llvm.PrivateLinkage)
 		wrapper.SetUnnamedAddr(true)
 		entry := c.ctx.AddBasicBlock(wrapper, "entry")
-		c.builder.SetInsertPointAtEnd(entry)
+		builder.SetInsertPointAtEnd(entry)
+
+		if c.Debug() {
+			pos := c.ir.Program.Fset.Position(pos)
+			diFuncType := c.dibuilder.CreateSubroutineType(llvm.DISubroutineType{
+				File:       c.getDIFile(pos.Filename),
+				Parameters: nil, // do not show parameters in debugger
+				Flags:      0,   // ?
+			})
+			difunc := c.dibuilder.CreateFunction(c.getDIFile(pos.Filename), llvm.DIFunction{
+				Name:         "<goroutine wrapper>",
+				File:         c.getDIFile(pos.Filename),
+				Line:         pos.Line,
+				Type:         diFuncType,
+				LocalToUnit:  true,
+				IsDefinition: true,
+				ScopeLine:    0,
+				Flags:        llvm.FlagPrototyped,
+				Optimized:    true,
+			})
+			wrapper.SetSubprogram(difunc)
+			builder.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), difunc, llvm.Metadata{})
+		}
 
 		// Create the list of params for the call.
 		paramTypes := fn.Type().ElementType().ParamTypes()
-		params := c.emitPointerUnpack(wrapper.Param(0), paramTypes[:len(paramTypes)-1])
+		params := llvmutil.EmitPointerUnpack(builder, c.mod, wrapper.Param(0), paramTypes[:len(paramTypes)-1])
 		params = append(params, llvm.Undef(c.i8ptrType))
 
 		// Create the call.
-		c.builder.CreateCall(fn, params, "")
+		builder.CreateCall(fn, params, "")
 
 	} else {
 		// For a function pointer like this:
@@ -101,22 +120,40 @@ func (c *Compiler) createGoroutineStartWrapper(fn llvm.Value) llvm.Value {
 		// With a bit of luck, identical wrapper functions like these can be
 		// merged into one.
 
-		// Save the current position in the IR builder.
-		currentBlock := c.builder.GetInsertBlock()
-		defer c.builder.SetInsertPointAtEnd(currentBlock)
-
 		// Create the wrapper.
 		wrapperType := llvm.FunctionType(c.ctx.VoidType(), []llvm.Type{c.i8ptrType}, false)
-		wrapper = llvm.AddFunction(c.mod, ".gowrapper", wrapperType)
+		wrapper = llvm.AddFunction(c.mod, prefix+".gowrapper", wrapperType)
 		wrapper.SetLinkage(llvm.InternalLinkage)
 		wrapper.SetUnnamedAddr(true)
 		entry := c.ctx.AddBasicBlock(wrapper, "entry")
-		c.builder.SetInsertPointAtEnd(entry)
+		builder.SetInsertPointAtEnd(entry)
+
+		if c.Debug() {
+			pos := c.ir.Program.Fset.Position(pos)
+			diFuncType := c.dibuilder.CreateSubroutineType(llvm.DISubroutineType{
+				File:       c.getDIFile(pos.Filename),
+				Parameters: nil, // do not show parameters in debugger
+				Flags:      0,   // ?
+			})
+			difunc := c.dibuilder.CreateFunction(c.getDIFile(pos.Filename), llvm.DIFunction{
+				Name:         "<goroutine wrapper>",
+				File:         c.getDIFile(pos.Filename),
+				Line:         pos.Line,
+				Type:         diFuncType,
+				LocalToUnit:  true,
+				IsDefinition: true,
+				ScopeLine:    0,
+				Flags:        llvm.FlagPrototyped,
+				Optimized:    true,
+			})
+			wrapper.SetSubprogram(difunc)
+			builder.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), difunc, llvm.Metadata{})
+		}
 
 		// Get the list of parameters, with the extra parameters at the end.
 		paramTypes := fn.Type().ElementType().ParamTypes()
 		paramTypes[len(paramTypes)-1] = fn.Type() // the last element is the function pointer
-		params := c.emitPointerUnpack(wrapper.Param(0), paramTypes)
+		params := llvmutil.EmitPointerUnpack(builder, c.mod, wrapper.Param(0), paramTypes)
 
 		// Get the function pointer.
 		fnPtr := params[len(params)-1]
@@ -126,13 +163,13 @@ func (c *Compiler) createGoroutineStartWrapper(fn llvm.Value) llvm.Value {
 		params[len(params)-1] = llvm.Undef(c.i8ptrType)
 
 		// Create the call.
-		c.builder.CreateCall(fnPtr, params, "")
+		builder.CreateCall(fnPtr, params, "")
 	}
 
 	// Finish the function. Every basic block must end in a terminator, and
 	// because goroutines never return a value we can simply return void.
-	c.builder.CreateRetVoid()
+	builder.CreateRetVoid()
 
 	// Return a ptrtoint of the wrapper, not the function itself.
-	return c.builder.CreatePtrToInt(wrapper, c.uintptrType, "")
+	return builder.CreatePtrToInt(wrapper, c.uintptrType, "")
 }

compiler/inlineasm.go

@@ -13,27 +13,6 @@ import (
 	"tinygo.org/x/go-llvm"
 )
 
-// This is a compiler builtin, which reads the given register by name:
-//
-//     func ReadRegister(name string) uintptr
-//
-// The register name must be a constant, for example "sp".
-func (c *Compiler) emitReadRegister(name string, args []ssa.Value) (llvm.Value, error) {
-	fnType := llvm.FunctionType(c.uintptrType, []llvm.Type{}, false)
-	regname := constant.StringVal(args[0].(*ssa.Const).Value)
-	var asm string
-	switch name {
-	case "device/arm.ReadRegister":
-		asm = "mov $0, " + regname
-	case "device/riscv.ReadRegister":
-		asm = "mv $0, " + regname
-	default:
-		panic("unknown architecture")
-	}
-	target := llvm.InlineAsm(fnType, asm, "=r", false, false, 0)
-	return c.builder.CreateCall(target, nil, ""), nil
-}
-
 // This is a compiler builtin, which emits a piece of inline assembly with no
 // operands or return values. It is useful for trivial instructions, like wfi in
 // ARM or sleep in AVR.
@@ -41,18 +20,18 @@ func (c *Compiler) emitReadRegister(name string, args []ssa.Value) (llvm.Value,
 //     func Asm(asm string)
 //
 // The provided assembly must be a constant.
-func (c *Compiler) emitAsm(args []ssa.Value) (llvm.Value, error) {
+func (b *builder) createInlineAsm(args []ssa.Value) (llvm.Value, error) {
 	// Magic function: insert inline assembly instead of calling it.
-	fnType := llvm.FunctionType(c.ctx.VoidType(), []llvm.Type{}, false)
+	fnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{}, false)
 	asm := constant.StringVal(args[0].(*ssa.Const).Value)
 	target := llvm.InlineAsm(fnType, asm, "", true, false, 0)
-	return c.builder.CreateCall(target, nil, ""), nil
+	return b.CreateCall(target, nil, ""), nil
 }
 
 // This is a compiler builtin, which allows assembly to be called in a flexible
 // way.
 //
-//     func AsmFull(asm string, regs map[string]interface{})
+//     func AsmFull(asm string, regs map[string]interface{}) uintptr
 //
 // The asm parameter must be a constant string. The regs parameter must be
 // provided immediately. For example:
@@ -63,27 +42,27 @@ func (c *Compiler) emitAsm(args []ssa.Value) (llvm.Value, error) {
 //             "value":  1
 //             "result": &dest,
 //         })
-func (c *Compiler) emitAsmFull(frame *Frame, instr *ssa.CallCommon) (llvm.Value, error) {
+func (b *builder) createInlineAsmFull(instr *ssa.CallCommon) (llvm.Value, error) {
 	asmString := constant.StringVal(instr.Args[0].(*ssa.Const).Value)
 	registers := map[string]llvm.Value{}
-	registerMap := instr.Args[1].(*ssa.MakeMap)
-	for _, r := range *registerMap.Referrers() {
-		switch r := r.(type) {
-		case *ssa.DebugRef:
-			// ignore
-		case *ssa.MapUpdate:
-			if r.Block() != registerMap.Block() {
-				return llvm.Value{}, c.makeError(instr.Pos(), "register value map must be created in the same basic block")
+	if registerMap, ok := instr.Args[1].(*ssa.MakeMap); ok {
+		for _, r := range *registerMap.Referrers() {
+			switch r := r.(type) {
+			case *ssa.DebugRef:
+				// ignore
+			case *ssa.MapUpdate:
+				if r.Block() != registerMap.Block() {
+					return llvm.Value{}, b.makeError(instr.Pos(), "register value map must be created in the same basic block")
+				}
+				key := constant.StringVal(r.Key.(*ssa.Const).Value)
+				registers[key] = b.getValue(r.Value.(*ssa.MakeInterface).X)
+			case *ssa.Call:
+				if r.Common() == instr {
+					break
+				}
+			default:
+				return llvm.Value{}, b.makeError(instr.Pos(), "don't know how to handle argument to inline assembly: "+r.String())
 			}
-			key := constant.StringVal(r.Key.(*ssa.Const).Value)
-			//println("value:", r.Value.(*ssa.MakeInterface).X.String())
-			registers[key] = c.getValue(frame, r.Value.(*ssa.MakeInterface).X)
-		case *ssa.Call:
-			if r.Common() == instr {
-				break
-			}
-		default:
-			return llvm.Value{}, c.makeError(instr.Pos(), "don't know how to handle argument to inline assembly: "+r.String())
 		}
 	}
 	// TODO: handle dollar signs in asm string
@@ -92,13 +71,22 @@ func (c *Compiler) emitAsmFull(frame *Frame, instr *ssa.CallCommon) (llvm.Value,
 	argTypes := []llvm.Type{}
 	args := []llvm.Value{}
 	constraints := []string{}
+	hasOutput := false
+	asmString = regexp.MustCompile("\\{\\}").ReplaceAllStringFunc(asmString, func(s string) string {
+		hasOutput = true
+		return "$0"
+	})
+	if hasOutput {
+		constraints = append(constraints, "=&r")
+		registerNumbers[""] = 0
+	}
 	asmString = regexp.MustCompile("\\{[a-zA-Z]+\\}").ReplaceAllStringFunc(asmString, func(s string) string {
 		// TODO: skip strings like {r4} etc. that look like ARM push/pop
 		// instructions.
 		name := s[1 : len(s)-1]
 		if _, ok := registers[name]; !ok {
 			if err == nil {
-				err = c.makeError(instr.Pos(), "unknown register name: "+name)
+				err = b.makeError(instr.Pos(), "unknown register name: "+name)
 			}
 			return s
 		}
@@ -112,7 +100,7 @@ func (c *Compiler) emitAsmFull(frame *Frame, instr *ssa.CallCommon) (llvm.Value,
 			case llvm.PointerTypeKind:
 				constraints = append(constraints, "*m")
 			default:
-				err = c.makeError(instr.Pos(), "unknown type in inline assembly for value: "+name)
+				err = b.makeError(instr.Pos(), "unknown type in inline assembly for value: "+name)
 				return s
 			}
 		}
@@ -121,9 +109,21 @@ func (c *Compiler) emitAsmFull(frame *Frame, instr *ssa.CallCommon) (llvm.Value,
 	if err != nil {
 		return llvm.Value{}, err
 	}
-	fnType := llvm.FunctionType(c.ctx.VoidType(), argTypes, false)
+	var outputType llvm.Type
+	if hasOutput {
+		outputType = b.uintptrType
+	} else {
+		outputType = b.ctx.VoidType()
+	}
+	fnType := llvm.FunctionType(outputType, argTypes, false)
 	target := llvm.InlineAsm(fnType, asmString, strings.Join(constraints, ","), true, false, 0)
-	return c.builder.CreateCall(target, args, ""), nil
+	result := b.CreateCall(target, args, "")
+	if hasOutput {
+		return result, nil
+	} else {
+		// Make sure we return something valid.
+		return llvm.ConstInt(b.uintptrType, 0, false), nil
+	}
 }
 
 // This is a compiler builtin which emits an inline SVCall instruction. It can
@@ -137,7 +137,7 @@ func (c *Compiler) emitAsmFull(frame *Frame, instr *ssa.CallCommon) (llvm.Value,
 //
 // The num parameter must be a constant. All other parameters may be any scalar
 // value supported by LLVM inline assembly.
-func (c *Compiler) emitSVCall(frame *Frame, args []ssa.Value) (llvm.Value, error) {
+func (b *builder) emitSVCall(args []ssa.Value) (llvm.Value, error) {
 	num, _ := constant.Uint64Val(args[0].(*ssa.Const).Value)
 	llvmArgs := []llvm.Value{}
 	argTypes := []llvm.Type{}
@@ -150,7 +150,7 @@ func (c *Compiler) emitSVCall(frame *Frame, args []ssa.Value) (llvm.Value, error
 		} else {
 			constraints += ",{r" + strconv.Itoa(i) + "}"
 		}
-		llvmValue := c.getValue(frame, arg)
+		llvmValue := b.getValue(arg)
 		llvmArgs = append(llvmArgs, llvmValue)
 		argTypes = append(argTypes, llvmValue.Type())
 	}
@@ -158,7 +158,52 @@ func (c *Compiler) emitSVCall(frame *Frame, args []ssa.Value) (llvm.Value, error
 	// clobbered. r0 is used as an output register so doesn't have to be
 	// marked as clobbered.
 	constraints += ",~{r1},~{r2},~{r3}"
-	fnType := llvm.FunctionType(c.uintptrType, argTypes, false)
+	fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
 	target := llvm.InlineAsm(fnType, asm, constraints, true, false, 0)
-	return c.builder.CreateCall(target, llvmArgs, ""), nil
+	return b.CreateCall(target, llvmArgs, ""), nil
+}
+
+// This is a compiler builtin which emits CSR instructions. It can be one of:
+//
+//     func (csr CSR) Get() uintptr
+//     func (csr CSR) Set(uintptr)
+//     func (csr CSR) SetBits(uintptr) uintptr
+//     func (csr CSR) ClearBits(uintptr) uintptr
+//
+// The csr parameter (method receiver) must be a constant. Other parameter can
+// be any value.
+func (b *builder) emitCSROperation(call *ssa.CallCommon) (llvm.Value, error) {
+	csrConst, ok := call.Args[0].(*ssa.Const)
+	if !ok {
+		return llvm.Value{}, b.makeError(call.Pos(), "CSR must be constant")
+	}
+	csr := csrConst.Uint64()
+	switch name := call.StaticCallee().Name(); name {
+	case "Get":
+		// Note that this instruction may have side effects, and thus must be
+		// marked as such.
+		fnType := llvm.FunctionType(b.uintptrType, nil, false)
+		asm := fmt.Sprintf("csrr $0, %d", csr)
+		target := llvm.InlineAsm(fnType, asm, "=r", true, false, 0)
+		return b.CreateCall(target, nil, ""), nil
+	case "Set":
+		fnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{b.uintptrType}, false)
+		asm := fmt.Sprintf("csrw %d, $0", csr)
+		target := llvm.InlineAsm(fnType, asm, "r", true, false, 0)
+		return b.CreateCall(target, []llvm.Value{b.getValue(call.Args[1])}, ""), nil
+	case "SetBits":
+		// Note: it may be possible to optimize this to csrrsi in many cases.
+		fnType := llvm.FunctionType(b.uintptrType, []llvm.Type{b.uintptrType}, false)
+		asm := fmt.Sprintf("csrrs $0, %d, $1", csr)
+		target := llvm.InlineAsm(fnType, asm, "=r,r", true, false, 0)
+		return b.CreateCall(target, []llvm.Value{b.getValue(call.Args[1])}, ""), nil
+	case "ClearBits":
+		// Note: it may be possible to optimize this to csrrci in many cases.
+		fnType := llvm.FunctionType(b.uintptrType, []llvm.Type{b.uintptrType}, false)
+		asm := fmt.Sprintf("csrrc $0, %d, $1", csr)
+		target := llvm.InlineAsm(fnType, asm, "=r,r", true, false, 0)
+		return b.CreateCall(target, []llvm.Value{b.getValue(call.Args[1])}, ""), nil
+	default:
+		return llvm.Value{}, b.makeError(call.Pos(), "unknown CSR operation: "+name)
+	}
 }

compiler/interface.go

@@ -16,35 +16,35 @@ import (
 	"tinygo.org/x/go-llvm"
 )
 
-// parseMakeInterface emits the LLVM IR for the *ssa.MakeInterface instruction.
+// createMakeInterface emits the LLVM IR for the *ssa.MakeInterface instruction.
 // It tries to put the type in the interface value, but if that's not possible,
 // it will do an allocation of the right size and put that in the interface
 // value field.
 //
-// An interface value is a {typecode, value} tuple, or {i16, i8*} to be exact.
-func (c *Compiler) parseMakeInterface(val llvm.Value, typ types.Type, pos token.Pos) llvm.Value {
-	itfValue := c.emitPointerPack([]llvm.Value{val})
-	itfTypeCodeGlobal := c.getTypeCode(typ)
-	itfMethodSetGlobal := c.getTypeMethodSet(typ)
-	itfConcreteTypeGlobal := c.mod.NamedGlobal("typeInInterface:" + itfTypeCodeGlobal.Name())
+// An interface value is a {typecode, value} tuple named runtime._interface.
+func (b *builder) createMakeInterface(val llvm.Value, typ types.Type, pos token.Pos) llvm.Value {
+	itfValue := b.emitPointerPack([]llvm.Value{val})
+	itfTypeCodeGlobal := b.getTypeCode(typ)
+	itfMethodSetGlobal := b.getTypeMethodSet(typ)
+	itfConcreteTypeGlobal := b.mod.NamedGlobal("typeInInterface:" + itfTypeCodeGlobal.Name())
 	if itfConcreteTypeGlobal.IsNil() {
-		typeInInterface := c.getLLVMRuntimeType("typeInInterface")
-		itfConcreteTypeGlobal = llvm.AddGlobal(c.mod, typeInInterface, "typeInInterface:"+itfTypeCodeGlobal.Name())
+		typeInInterface := b.getLLVMRuntimeType("typeInInterface")
+		itfConcreteTypeGlobal = llvm.AddGlobal(b.mod, typeInInterface, "typeInInterface:"+itfTypeCodeGlobal.Name())
 		itfConcreteTypeGlobal.SetInitializer(llvm.ConstNamedStruct(typeInInterface, []llvm.Value{itfTypeCodeGlobal, itfMethodSetGlobal}))
 		itfConcreteTypeGlobal.SetGlobalConstant(true)
 		itfConcreteTypeGlobal.SetLinkage(llvm.PrivateLinkage)
 	}
-	itfTypeCode := c.builder.CreatePtrToInt(itfConcreteTypeGlobal, c.uintptrType, "")
-	itf := llvm.Undef(c.getLLVMRuntimeType("_interface"))
-	itf = c.builder.CreateInsertValue(itf, itfTypeCode, 0, "")
-	itf = c.builder.CreateInsertValue(itf, itfValue, 1, "")
+	itfTypeCode := b.CreatePtrToInt(itfConcreteTypeGlobal, b.uintptrType, "")
+	itf := llvm.Undef(b.getLLVMRuntimeType("_interface"))
+	itf = b.CreateInsertValue(itf, itfTypeCode, 0, "")
+	itf = b.CreateInsertValue(itf, itfValue, 1, "")
 	return itf
 }
 
 // getTypeCode returns a reference to a type code.
 // It returns a pointer to an external global which should be replaced with the
 // real type in the interface lowering pass.
-func (c *Compiler) getTypeCode(typ types.Type) llvm.Value {
+func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 	globalName := "reflect/types.type:" + getTypeCodeName(typ)
 	global := c.mod.NamedGlobal(globalName)
 	if global.IsNil() {
@@ -91,7 +91,7 @@ func (c *Compiler) getTypeCode(typ types.Type) llvm.Value {
 // makeStructTypeFields creates a new global that stores all type information
 // related to this struct type, and returns the resulting global. This global is
 // actually an array of all the fields in the structs.
-func (c *Compiler) makeStructTypeFields(typ *types.Struct) llvm.Value {
+func (c *compilerContext) makeStructTypeFields(typ *types.Struct) llvm.Value {
 	// The global is an array of runtime.structField structs.
 	runtimeStructField := c.getLLVMRuntimeType("structField")
 	structGlobalType := llvm.ArrayType(runtimeStructField, typ.NumFields())
@@ -228,7 +228,7 @@ func getTypeCodeName(t types.Type) string {
 
 // getTypeMethodSet returns a reference (GEP) to a global method set. This
 // method set should be unreferenced after the interface lowering pass.
-func (c *Compiler) getTypeMethodSet(typ types.Type) llvm.Value {
+func (c *compilerContext) getTypeMethodSet(typ types.Type) llvm.Value {
 	global := c.mod.NamedGlobal(typ.String() + "$methodset")
 	zero := llvm.ConstInt(c.ctx.Int32Type(), 0, false)
 	if !global.IsNil() {
@@ -271,23 +271,28 @@ func (c *Compiler) getTypeMethodSet(typ types.Type) llvm.Value {
 // getInterfaceMethodSet returns a global variable with the method set of the
 // given named interface type. This method set is used by the interface lowering
 // pass.
-func (c *Compiler) getInterfaceMethodSet(typ *types.Named) llvm.Value {
-	global := c.mod.NamedGlobal(typ.String() + "$interface")
+func (c *compilerContext) getInterfaceMethodSet(typ types.Type) llvm.Value {
+	name := typ.String()
+	if _, ok := typ.(*types.Named); !ok {
+		// Anonymous interface.
+		name = "reflect/types.interface:" + name
+	}
+	global := c.mod.NamedGlobal(name + "$interface")
 	zero := llvm.ConstInt(c.ctx.Int32Type(), 0, false)
 	if !global.IsNil() {
 		// method set already exist, return it
 		return llvm.ConstGEP(global, []llvm.Value{zero, zero})
 	}
 
-	// Every method is a *i16 reference indicating the signature of this method.
+	// Every method is a *i8 reference indicating the signature of this method.
 	methods := make([]llvm.Value, typ.Underlying().(*types.Interface).NumMethods())
 	for i := range methods {
 		method := typ.Underlying().(*types.Interface).Method(i)
 		methods[i] = c.getMethodSignature(method)
 	}
 
-	value := llvm.ConstArray(methods[0].Type(), methods)
-	global = llvm.AddGlobal(c.mod, value.Type(), typ.String()+"$interface")
+	value := llvm.ConstArray(c.i8ptrType, methods)
+	global = llvm.AddGlobal(c.mod, value.Type(), name+"$interface")
 	global.SetInitializer(value)
 	global.SetGlobalConstant(true)
 	global.SetLinkage(llvm.PrivateLinkage)
@@ -295,9 +300,9 @@ func (c *Compiler) getInterfaceMethodSet(typ *types.Named) llvm.Value {
 }
 
 // getMethodSignature returns a global variable which is a reference to an
-// external *i16 indicating the indicating the signature of this method. It is
+// external *i8 indicating the indicating the signature of this method. It is
 // used during the interface lowering pass.
-func (c *Compiler) getMethodSignature(method *types.Func) llvm.Value {
+func (c *compilerContext) getMethodSignature(method *types.Func) llvm.Value {
 	signature := ir.MethodSignature(method)
 	signatureGlobal := c.mod.NamedGlobal("func " + signature)
 	if signatureGlobal.IsNil() {
@@ -307,18 +312,18 @@ func (c *Compiler) getMethodSignature(method *types.Func) llvm.Value {
 	return signatureGlobal
 }
 
-// parseTypeAssert will emit the code for a typeassert, used in if statements
+// createTypeAssert will emit the code for a typeassert, used in if statements
 // and in type switches (Go SSA does not have type switches, only if/else
 // chains). Note that even though the Go SSA does not contain type switches,
 // LLVM will recognize the pattern and make it a real switch in many cases.
 //
 // Type asserts on concrete types are trivial: just compare type numbers. Type
 // asserts on interfaces are more difficult, see the comments in the function.
-func (c *Compiler) parseTypeAssert(frame *Frame, expr *ssa.TypeAssert) llvm.Value {
-	itf := c.getValue(frame, expr.X)
-	assertedType := c.getLLVMType(expr.AssertedType)
+func (b *builder) createTypeAssert(expr *ssa.TypeAssert) llvm.Value {
+	itf := b.getValue(expr.X)
+	assertedType := b.getLLVMType(expr.AssertedType)
 
-	actualTypeNum := c.builder.CreateExtractValue(itf, 0, "interface.type")
+	actualTypeNum := b.CreateExtractValue(itf, 0, "interface.type")
 	commaOk := llvm.Value{}
 	if _, ok := expr.AssertedType.Underlying().(*types.Interface); ok {
 		// Type assert on interface type.
@@ -329,15 +334,15 @@ func (c *Compiler) parseTypeAssert(frame *Frame, expr *ssa.TypeAssert) llvm.Valu
 		// the main Go compiler, where the runtime checks whether the type
 		// implements each method of the interface. See:
 		// https://research.swtch.com/interfaces
-		methodSet := c.getInterfaceMethodSet(expr.AssertedType.(*types.Named))
-		commaOk = c.createRuntimeCall("interfaceImplements", []llvm.Value{actualTypeNum, methodSet}, "")
+		methodSet := b.getInterfaceMethodSet(expr.AssertedType)
+		commaOk = b.createRuntimeCall("interfaceImplements", []llvm.Value{actualTypeNum, methodSet}, "")
 
 	} else {
 		// Type assert on concrete type.
 		// Call runtime.typeAssert, which will be lowered to a simple icmp or
 		// const false in the interface lowering pass.
-		assertedTypeCodeGlobal := c.getTypeCode(expr.AssertedType)
-		commaOk = c.createRuntimeCall("typeAssert", []llvm.Value{actualTypeNum, assertedTypeCodeGlobal}, "typecode")
+		assertedTypeCodeGlobal := b.getTypeCode(expr.AssertedType)
+		commaOk = b.createRuntimeCall("typeAssert", []llvm.Value{actualTypeNum, assertedTypeCodeGlobal}, "typecode")
 	}
 
 	// Add 2 new basic blocks (that should get optimized away): one for the
@@ -351,15 +356,15 @@ func (c *Compiler) parseTypeAssert(frame *Frame, expr *ssa.TypeAssert) llvm.Valu
 	// typeassert should return a zero value, not an incorrectly casted
 	// value.
 
-	prevBlock := c.builder.GetInsertBlock()
-	okBlock := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "typeassert.ok")
-	nextBlock := c.ctx.AddBasicBlock(frame.fn.LLVMFn, "typeassert.next")
-	frame.blockExits[frame.currentBlock] = nextBlock // adjust outgoing block for phi nodes
-	c.builder.CreateCondBr(commaOk, okBlock, nextBlock)
+	prevBlock := b.GetInsertBlock()
+	okBlock := b.ctx.AddBasicBlock(b.fn.LLVMFn, "typeassert.ok")
+	nextBlock := b.ctx.AddBasicBlock(b.fn.LLVMFn, "typeassert.next")
+	b.blockExits[b.currentBlock] = nextBlock // adjust outgoing block for phi nodes
+	b.CreateCondBr(commaOk, okBlock, nextBlock)
 
 	// Retrieve the value from the interface if the type assert was
 	// successful.
-	c.builder.SetInsertPointAtEnd(okBlock)
+	b.SetInsertPointAtEnd(okBlock)
 	var valueOk llvm.Value
 	if _, ok := expr.AssertedType.Underlying().(*types.Interface); ok {
 		// Type assert on interface type. Easy: just return the same
@@ -368,74 +373,70 @@ func (c *Compiler) parseTypeAssert(frame *Frame, expr *ssa.TypeAssert) llvm.Valu
 	} else {
 		// Type assert on concrete type. Extract the underlying type from
 		// the interface (but only after checking it matches).
-		valuePtr := c.builder.CreateExtractValue(itf, 1, "typeassert.value.ptr")
-		valueOk = c.emitPointerUnpack(valuePtr, []llvm.Type{assertedType})[0]
+		valuePtr := b.CreateExtractValue(itf, 1, "typeassert.value.ptr")
+		valueOk = b.emitPointerUnpack(valuePtr, []llvm.Type{assertedType})[0]
 	}
-	c.builder.CreateBr(nextBlock)
+	b.CreateBr(nextBlock)
 
 	// Continue after the if statement.
-	c.builder.SetInsertPointAtEnd(nextBlock)
-	phi := c.builder.CreatePHI(assertedType, "typeassert.value")
+	b.SetInsertPointAtEnd(nextBlock)
+	phi := b.CreatePHI(assertedType, "typeassert.value")
 	phi.AddIncoming([]llvm.Value{llvm.ConstNull(assertedType), valueOk}, []llvm.BasicBlock{prevBlock, okBlock})
 
 	if expr.CommaOk {
-		tuple := c.ctx.ConstStruct([]llvm.Value{llvm.Undef(assertedType), llvm.Undef(c.ctx.Int1Type())}, false) // create empty tuple
-		tuple = c.builder.CreateInsertValue(tuple, phi, 0, "")                                                  // insert value
-		tuple = c.builder.CreateInsertValue(tuple, commaOk, 1, "")                                              // insert 'comma ok' boolean
+		tuple := b.ctx.ConstStruct([]llvm.Value{llvm.Undef(assertedType), llvm.Undef(b.ctx.Int1Type())}, false) // create empty tuple
+		tuple = b.CreateInsertValue(tuple, phi, 0, "")                                                          // insert value
+		tuple = b.CreateInsertValue(tuple, commaOk, 1, "")                                                      // insert 'comma ok' boolean
 		return tuple
 	} else {
 		// This is kind of dirty as the branch above becomes mostly useless,
 		// but hopefully this gets optimized away.
-		c.createRuntimeCall("interfaceTypeAssert", []llvm.Value{commaOk}, "")
+		b.createRuntimeCall("interfaceTypeAssert", []llvm.Value{commaOk}, "")
 		return phi
 	}
 }
 
-// getInvokeCall creates and returns the function pointer and parameters of an
-// interface call. It can be used in a call or defer instruction.
-func (c *Compiler) getInvokeCall(frame *Frame, instr *ssa.CallCommon) (llvm.Value, []llvm.Value) {
-	// Call an interface method with dynamic dispatch.
-	itf := c.getValue(frame, instr.Value) // interface
-
-	llvmFnType := c.getRawFuncType(instr.Method.Type().(*types.Signature))
-
-	typecode := c.builder.CreateExtractValue(itf, 0, "invoke.typecode")
+// getInvokePtr creates an interface function pointer lookup for the specified invoke instruction, using a specified typecode.
+func (b *builder) getInvokePtr(instr *ssa.CallCommon, typecode llvm.Value) llvm.Value {
+	llvmFnType := b.getRawFuncType(instr.Method.Type().(*types.Signature))
 	values := []llvm.Value{
 		typecode,
-		c.getInterfaceMethodSet(instr.Value.Type().(*types.Named)),
-		c.getMethodSignature(instr.Method),
+		b.getInterfaceMethodSet(instr.Value.Type()),
+		b.getMethodSignature(instr.Method),
 	}
-	fn := c.createRuntimeCall("interfaceMethod", values, "invoke.func")
-	fnCast := c.builder.CreateIntToPtr(fn, llvmFnType, "invoke.func.cast")
-	receiverValue := c.builder.CreateExtractValue(itf, 1, "invoke.func.receiver")
+	fn := b.createRuntimeCall("interfaceMethod", values, "invoke.func")
+	return b.CreateIntToPtr(fn, llvmFnType, "invoke.func.cast")
+}
+
+// getInvokeCall creates and returns the function pointer and parameters of an
+// interface call.
+func (b *builder) getInvokeCall(instr *ssa.CallCommon) (llvm.Value, []llvm.Value) {
+	// Call an interface method with dynamic dispatch.
+	itf := b.getValue(instr.Value) // interface
+
+	typecode := b.CreateExtractValue(itf, 0, "invoke.typecode")
+	fnCast := b.getInvokePtr(instr, typecode)
+	receiverValue := b.CreateExtractValue(itf, 1, "invoke.func.receiver")
 
 	args := []llvm.Value{receiverValue}
 	for _, arg := range instr.Args {
-		args = append(args, c.getValue(frame, arg))
+		args = append(args, b.getValue(arg))
 	}
 	// Add the context parameter. An interface call never takes a context but we
 	// have to supply the parameter anyway.
-	args = append(args, llvm.Undef(c.i8ptrType))
+	args = append(args, llvm.Undef(b.i8ptrType))
 	// Add the parent goroutine handle.
-	args = append(args, llvm.Undef(c.i8ptrType))
+	args = append(args, llvm.Undef(b.i8ptrType))
 
 	return fnCast, args
 }
 
-// interfaceInvokeWrapper keeps some state between getInterfaceInvokeWrapper and
-// createInterfaceInvokeWrapper. The former is called during IR construction
-// itself and the latter is called when finishing up the IR.
-type interfaceInvokeWrapper struct {
-	fn           *ir.Function
-	wrapper      llvm.Value
-	receiverType llvm.Type
-}
-
-// Wrap an interface method function pointer. The wrapper takes in a pointer to
-// the underlying value, dereferences it, and calls the real method. This
-// wrapper is only needed when the interface value actually doesn't fit in a
-// pointer and a pointer to the value must be created.
-func (c *Compiler) getInterfaceInvokeWrapper(f *ir.Function) llvm.Value {
+// getInterfaceInvokeWrapper returns a wrapper for the given method so it can be
+// invoked from an interface. The wrapper takes in a pointer to the underlying
+// value, dereferences or unpacks it if necessary, and calls the real method.
+// If the method to wrap has a pointer receiver, no wrapping is necessary and
+// the function is returned directly.
+func (c *compilerContext) getInterfaceInvokeWrapper(f *ir.Function) llvm.Value {
 	wrapperName := f.LinkName() + "$invoke"
 	wrapper := c.mod.NamedFunction(wrapperName)
 	if !wrapper.IsNil() {
@@ -445,7 +446,10 @@ func (c *Compiler) getInterfaceInvokeWrapper(f *ir.Function) llvm.Value {
 
 	// Get the expanded receiver type.
 	receiverType := c.getLLVMType(f.Params[0].Type())
-	expandedReceiverType := c.expandFormalParamType(receiverType)
+	var expandedReceiverType []llvm.Type
+	for _, info := range expandFormalParamType(receiverType, "", nil) {
+		expandedReceiverType = append(expandedReceiverType, info.llvmType)
+	}
 
 	// Does this method even need any wrapping?
 	if len(expandedReceiverType) == 1 && receiverType.TypeKind() == llvm.PointerTypeKind {
@@ -464,41 +468,37 @@ func (c *Compiler) getInterfaceInvokeWrapper(f *ir.Function) llvm.Value {
 	if f.LLVMFn.LastParam().Name() == "parentHandle" {
 		wrapper.LastParam().SetName("parentHandle")
 	}
-	c.interfaceInvokeWrappers = append(c.interfaceInvokeWrappers, interfaceInvokeWrapper{
-		fn:           f,
-		wrapper:      wrapper,
-		receiverType: receiverType,
-	})
-	return wrapper
-}
 
-// createInterfaceInvokeWrapper finishes the work of getInterfaceInvokeWrapper,
-// see that function for details.
-func (c *Compiler) createInterfaceInvokeWrapper(state interfaceInvokeWrapper) {
-	wrapper := state.wrapper
-	fn := state.fn
-	receiverType := state.receiverType
 	wrapper.SetLinkage(llvm.InternalLinkage)
 	wrapper.SetUnnamedAddr(true)
 
+	// Create a new builder just to create this wrapper.
+	b := builder{
+		compilerContext: c,
+		Builder:         c.ctx.NewBuilder(),
+	}
+	defer b.Builder.Dispose()
+
 	// add debug info if needed
 	if c.Debug() {
-		pos := c.ir.Program.Fset.Position(fn.Pos())
-		difunc := c.attachDebugInfoRaw(fn, wrapper, "$invoke", pos.Filename, pos.Line)
-		c.builder.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), difunc, llvm.Metadata{})
+		pos := c.ir.Program.Fset.Position(f.Pos())
+		difunc := c.attachDebugInfoRaw(f, wrapper, "$invoke", pos.Filename, pos.Line)
+		b.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), difunc, llvm.Metadata{})
 	}
 
 	// set up IR builder
-	block := c.ctx.AddBasicBlock(wrapper, "entry")
-	c.builder.SetInsertPointAtEnd(block)
+	block := b.ctx.AddBasicBlock(wrapper, "entry")
+	b.SetInsertPointAtEnd(block)
 
-	receiverValue := c.emitPointerUnpack(wrapper.Param(0), []llvm.Type{receiverType})[0]
-	params := append(c.expandFormalParam(receiverValue), wrapper.Params()[1:]...)
-	if fn.LLVMFn.Type().ElementType().ReturnType().TypeKind() == llvm.VoidTypeKind {
-		c.builder.CreateCall(fn.LLVMFn, params, "")
-		c.builder.CreateRetVoid()
+	receiverValue := b.emitPointerUnpack(wrapper.Param(0), []llvm.Type{receiverType})[0]
+	params := append(b.expandFormalParam(receiverValue), wrapper.Params()[1:]...)
+	if f.LLVMFn.Type().ElementType().ReturnType().TypeKind() == llvm.VoidTypeKind {
+		b.CreateCall(f.LLVMFn, params, "")
+		b.CreateRetVoid()
 	} else {
-		ret := c.builder.CreateCall(fn.LLVMFn, params, "ret")
-		c.builder.CreateRet(ret)
+		ret := b.CreateCall(f.LLVMFn, params, "ret")
+		b.CreateRet(ret)
 	}
+
+	return wrapper
 }

compiler/interrupt.go

@@ -0,0 +1,92 @@
+package compiler
+
+import (
+	"strconv"
+	"strings"
+
+	"golang.org/x/tools/go/ssa"
+	"tinygo.org/x/go-llvm"
+)
+
+// createInterruptGlobal creates a new runtime/interrupt.Interrupt struct that
+// will be lowered to a real interrupt during interrupt lowering.
+//
+// This two-stage approach allows unused interrupts to be optimized away if
+// necessary.
+func (b *builder) createInterruptGlobal(instr *ssa.CallCommon) (llvm.Value, error) {
+	// Get the interrupt number, which must be a compile-time constant.
+	id, ok := instr.Args[0].(*ssa.Const)
+	if !ok {
+		return llvm.Value{}, b.makeError(instr.Pos(), "interrupt ID is not a constant")
+	}
+
+	// Get the func value, which also must be a compile time constant.
+	// Note that bound functions are allowed if the function has a pointer
+	// receiver and is a global. This is rather strict but still allows for
+	// idiomatic Go code.
+	funcValue := b.getValue(instr.Args[1])
+	if funcValue.IsAConstant().IsNil() {
+		// Try to determine the cause of the non-constantness for a nice error
+		// message.
+		switch instr.Args[1].(type) {
+		case *ssa.MakeClosure:
+			// This may also be a bound method.
+			return llvm.Value{}, b.makeError(instr.Pos(), "closures are not supported in interrupt.New")
+		}
+		// Fall back to a generic error.
+		return llvm.Value{}, b.makeError(instr.Pos(), "interrupt function must be constant")
+	}
+
+	// Create a new global of type runtime/interrupt.handle. Globals of this
+	// type are lowered in the interrupt lowering pass.
+	globalType := b.ir.Program.ImportedPackage("runtime/interrupt").Type("handle").Type()
+	globalLLVMType := b.getLLVMType(globalType)
+	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.SetLinkage(llvm.PrivateLinkage)
+	global.SetGlobalConstant(true)
+	global.SetUnnamedAddr(true)
+	initializer := llvm.ConstNull(globalLLVMType)
+	initializer = llvm.ConstInsertValue(initializer, funcValue, []uint32{0})
+	initializer = llvm.ConstInsertValue(initializer, llvm.ConstInt(b.intType, uint64(id.Int64()), true), []uint32{1, 0})
+	global.SetInitializer(initializer)
+
+	// Add debug info to the interrupt global.
+	if b.Debug() {
+		pos := b.ir.Program.Fset.Position(instr.Pos())
+		diglobal := b.dibuilder.CreateGlobalVariableExpression(b.getDIFile(pos.Filename), llvm.DIGlobalVariableExpression{
+			Name:        "interrupt" + strconv.FormatInt(id.Int64(), 10),
+			LinkageName: globalName,
+			File:        b.getDIFile(pos.Filename),
+			Line:        pos.Line,
+			Type:        b.getDIType(globalType),
+			Expr:        b.dibuilder.CreateExpression(nil),
+			LocalToUnit: false,
+		})
+		global.AddMetadata(0, diglobal)
+	}
+
+	// Create the runtime/interrupt.Interrupt type. It is a struct with a single
+	// member of type int.
+	num := llvm.ConstPtrToInt(global, b.intType)
+	interrupt := llvm.ConstNamedStruct(b.mod.GetTypeByName("runtime/interrupt.Interrupt"), []llvm.Value{num})
+
+	// Add dummy "use" call for AVR, because interrupts may be used even though
+	// they are never referenced again. This is unlike Cortex-M or the RISC-V
+	// PLIC where each interrupt must be enabled using the interrupt number, and
+	// thus keeps the Interrupt object alive.
+	// This call is removed during interrupt lowering.
+	if strings.HasPrefix(b.Triple(), "avr") {
+		useFn := b.mod.NamedFunction("runtime/interrupt.use")
+		if useFn.IsNil() {
+			useFnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{interrupt.Type()}, false)
+			useFn = llvm.AddFunction(b.mod, "runtime/interrupt.use", useFnType)
+		}
+		b.CreateCall(useFn, []llvm.Value{interrupt}, "")
+	}
+
+	return interrupt, nil
+}

compiler/intrinsics.go

@@ -0,0 +1,50 @@
+package compiler
+
+// This file contains helper functions to create calls to LLVM intrinsics.
+
+import (
+	"strconv"
+
+	"golang.org/x/tools/go/ssa"
+	"tinygo.org/x/go-llvm"
+)
+
+// createMemoryCopyCall creates a call to a builtin LLVM memcpy or memmove
+// function, declaring this function if needed. These calls are treated
+// specially by optimization passes possibly resulting in better generated code,
+// and will otherwise be lowered to regular libc memcpy/memmove calls.
+func (b *builder) createMemoryCopyCall(fn *ssa.Function, args []ssa.Value) (llvm.Value, error) {
+	fnName := "llvm." + fn.Name() + ".p0i8.p0i8.i" + strconv.Itoa(b.uintptrType.IntTypeWidth())
+	llvmFn := b.mod.NamedFunction(fnName)
+	if llvmFn.IsNil() {
+		fnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{b.i8ptrType, b.i8ptrType, b.uintptrType, b.ctx.Int1Type()}, false)
+		llvmFn = llvm.AddFunction(b.mod, fnName, fnType)
+	}
+	var params []llvm.Value
+	for _, param := range args {
+		params = append(params, b.getValue(param))
+	}
+	params = append(params, llvm.ConstInt(b.ctx.Int1Type(), 0, false))
+	b.CreateCall(llvmFn, params, "")
+	return llvm.Value{}, nil
+}
+
+// createMemoryZeroCall creates calls to llvm.memset.* to zero a block of
+// memory, declaring the function if needed. These calls will be lowered to
+// regular libc memset calls if they aren't optimized out in a different way.
+func (b *builder) createMemoryZeroCall(args []ssa.Value) (llvm.Value, error) {
+	fnName := "llvm.memset.p0i8.i" + strconv.Itoa(b.uintptrType.IntTypeWidth())
+	llvmFn := b.mod.NamedFunction(fnName)
+	if llvmFn.IsNil() {
+		fnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{b.i8ptrType, b.ctx.Int8Type(), b.uintptrType, b.ctx.Int1Type()}, false)
+		llvmFn = llvm.AddFunction(b.mod, fnName, fnType)
+	}
+	params := []llvm.Value{
+		b.getValue(args[0]),
+		llvm.ConstInt(b.ctx.Int8Type(), 0, false),
+		b.getValue(args[1]),
+		llvm.ConstInt(b.ctx.Int1Type(), 0, false),
+	}
+	b.CreateCall(llvmFn, params, "")
+	return llvm.Value{}, nil
+}

compiler/ircheck/check.go

@@ -1,7 +1,8 @@
-package compiler
-
-// This file implements a set of sanity checks for the IR that is generated.
-// It can catch some mistakes that LLVM's verifier cannot.
+// Package ircheck implements a checker for LLVM IR, that goes a bit further
+// than the regular LLVM IR verifier. Note that it checks different things, so
+// this is not a replacement for the LLVM verifier but does catch things that
+// the LLVM verifier doesn't catch.
+package ircheck
 
 import (
 	"errors"
@@ -10,7 +11,11 @@ import (
 	"tinygo.org/x/go-llvm"
 )
 
-func (c *Compiler) checkType(t llvm.Type, checked map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) error {
+type checker struct {
+	ctx llvm.Context
+}
+
+func (c *checker) checkType(t llvm.Type, checked map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) error {
 	// prevent infinite recursion for self-referential types
 	if _, ok := checked[t]; ok {
 		return nil
@@ -81,7 +86,7 @@ func (c *Compiler) checkType(t llvm.Type, checked map[llvm.Type]struct{}, specia
 	return nil
 }
 
-func (c *Compiler) checkValue(v llvm.Value, types map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) error {
+func (c *checker) checkValue(v llvm.Value, types map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) error {
 	// check type
 	if err := c.checkType(v.Type(), types, specials); err != nil {
 		return fmt.Errorf("failed to verify type of value: %s", err.Error())
@@ -95,79 +100,95 @@ func (c *Compiler) checkValue(v llvm.Value, types map[llvm.Type]struct{}, specia
 	return nil
 }
 
-func (c *Compiler) checkInstruction(inst llvm.Value, types map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) error {
+func (c *checker) checkInstruction(inst llvm.Value, types map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) error {
 	// check value properties
 	if err := c.checkValue(inst, types, specials); err != nil {
-		return fmt.Errorf("failed to validate value of instruction %q: %s", inst.Name(), err.Error())
+		return errorAt(inst, err.Error())
+	}
+
+	// The alloca instruction can be present in every basic block. However,
+	// allocas in basic blocks other than the entry basic block have a number of
+	// problems:
+	//   * They are hard to optimize, leading to potential missed optimizations.
+	//   * They may cause stack overflows in loops that would otherwise be
+	//     innocent.
+	//   * They cause extra code to be generated, because it requires the use of
+	//     a frame pointer.
+	//   * Perhaps most importantly, the coroutine lowering pass of LLVM (as of
+	//     LLVM 9) cannot deal with these allocas:
+	//     https://llvm.org/docs/Coroutines.html
+	// Therefore, alloca instructions should be limited to the entry block.
+	if !inst.IsAAllocaInst().IsNil() {
+		if inst.InstructionParent() != inst.InstructionParent().Parent().EntryBasicBlock() {
+			return errorAt(inst, "internal error: non-static alloca")
+		}
 	}
 
 	// check operands
 	for i := 0; i < inst.OperandsCount(); i++ {
 		if err := c.checkValue(inst.Operand(i), types, specials); err != nil {
-			return fmt.Errorf("failed to validate argument %d of instruction %q: %s", i, inst.Name(), err.Error())
+			return errorAt(inst, fmt.Sprintf("failed to validate operand %d of instruction %q: %s", i, inst.Name(), err.Error()))
 		}
 	}
 
 	return nil
 }
 
-func (c *Compiler) checkBasicBlock(bb llvm.BasicBlock, types map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) error {
+func (c *checker) checkBasicBlock(bb llvm.BasicBlock, types map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) []error {
 	// check basic block value and type
+	var errs []error
 	if err := c.checkValue(bb.AsValue(), types, specials); err != nil {
-		return fmt.Errorf("failed to validate value of basic block %s: %s", bb.AsValue().Name(), err.Error())
+		errs = append(errs, errorAt(bb.Parent(), fmt.Sprintf("failed to validate value of basic block %s: %v", bb.AsValue().Name(), err)))
 	}
 
 	// check instructions
 	for inst := bb.FirstInstruction(); !inst.IsNil(); inst = llvm.NextInstruction(inst) {
 		if err := c.checkInstruction(inst, types, specials); err != nil {
-			return fmt.Errorf("failed to validate basic block %q: %s", bb.AsValue().Name(), err.Error())
+			errs = append(errs, err)
 		}
 	}
 
-	return nil
+	return errs
 }
 
-func (c *Compiler) checkFunction(fn llvm.Value, types map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) error {
+func (c *checker) checkFunction(fn llvm.Value, types map[llvm.Type]struct{}, specials map[llvm.TypeKind]llvm.Type) []error {
 	// check function value and type
+	var errs []error
 	if err := c.checkValue(fn, types, specials); err != nil {
-		return fmt.Errorf("failed to validate value of function %s: %s", fn.Name(), err.Error())
+		errs = append(errs, fmt.Errorf("failed to validate value of function %s: %s", fn.Name(), err.Error()))
 	}
 
 	// check basic blocks
 	for bb := fn.FirstBasicBlock(); !bb.IsNil(); bb = llvm.NextBasicBlock(bb) {
-		if err := c.checkBasicBlock(bb, types, specials); err != nil {
-			return fmt.Errorf("failed to validate basic block of function %s: %s", fn.Name(), err.Error())
-		}
+		errs = append(errs, c.checkBasicBlock(bb, types, specials)...)
 	}
 
-	return nil
+	return errs
 }
 
-func (c *Compiler) checkModule() error {
+// Module checks the given module and returns a slice of error, if there are
+// any.
+func Module(mod llvm.Module) []error {
 	// check for any context mismatches
-	switch {
-	case c.mod.Context() == c.ctx:
-		// this is correct
-	case c.mod.Context() == llvm.GlobalContext():
+	var errs []error
+	c := checker{
+		ctx: mod.Context(),
+	}
+	if c.ctx == llvm.GlobalContext() {
 		// somewhere we accidentally used the global context instead of a real context
-		return errors.New("module uses global context")
-	default:
-		// we used some other context by accident
-		return fmt.Errorf("module uses context %v instead of the main context %v", c.mod.Context(), c.ctx)
+		errs = append(errs, errors.New("module uses global context"))
 	}
 
 	types := map[llvm.Type]struct{}{}
 	specials := map[llvm.TypeKind]llvm.Type{}
-	for fn := c.mod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
-		if err := c.checkFunction(fn, types, specials); err != nil {
-			return err
-		}
+	for fn := mod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
+		errs = append(errs, c.checkFunction(fn, types, specials)...)
 	}
-	for g := c.mod.FirstGlobal(); !g.IsNil(); g = llvm.NextGlobal(g) {
+	for g := mod.FirstGlobal(); !g.IsNil(); g = llvm.NextGlobal(g) {
 		if err := c.checkValue(g, types, specials); err != nil {
-			return fmt.Errorf("failed to verify global %s of module: %s", g.Name(), err.Error())
+			errs = append(errs, fmt.Errorf("failed to verify global %s of module: %s", g.Name(), err.Error()))
 		}
 	}
 
-	return nil
+	return errs
 }

compiler/ircheck/errors.go

@@ -0,0 +1,48 @@
+package ircheck
+
+import (
+	"go/scanner"
+	"go/token"
+	"path/filepath"
+
+	"tinygo.org/x/go-llvm"
+)
+
+// errorAt returns an error value at the location of the instruction.
+// The location information may not be complete as it depends on debug
+// information in the IR.
+func errorAt(inst llvm.Value, msg string) scanner.Error {
+	return scanner.Error{
+		Pos: getPosition(inst),
+		Msg: msg,
+	}
+}
+
+// getPosition returns the position information for the given value, as far as
+// it is available.
+func getPosition(val llvm.Value) token.Position {
+	if !val.IsAInstruction().IsNil() {
+		loc := val.InstructionDebugLoc()
+		if loc.IsNil() {
+			return token.Position{}
+		}
+		file := loc.LocationScope().ScopeFile()
+		return token.Position{
+			Filename: filepath.Join(file.FileDirectory(), file.FileFilename()),
+			Line:     int(loc.LocationLine()),
+			Column:   int(loc.LocationColumn()),
+		}
+	} else if !val.IsAFunction().IsNil() {
+		loc := val.Subprogram()
+		if loc.IsNil() {
+			return token.Position{}
+		}
+		file := loc.ScopeFile()
+		return token.Position{
+			Filename: filepath.Join(file.FileDirectory(), file.FileFilename()),
+			Line:     int(loc.SubprogramLine()),
+		}
+	} else {
+		return token.Position{}
+	}
+}

compiler/llvm.go

@@ -24,111 +24,39 @@ func getUses(value llvm.Value) []llvm.Value {
 }
 
 // createTemporaryAlloca creates a new alloca in the entry block and adds
-// lifetime start infromation in the IR signalling that the alloca won't be used
+// lifetime start information in the IR signalling that the alloca won't be used
 // before this point.
 //
 // This is useful for creating temporary allocas for intrinsics. Don't forget to
 // end the lifetime using emitLifetimeEnd after you're done with it.
-func (c *Compiler) createTemporaryAlloca(t llvm.Type, name string) (alloca, bitcast, size llvm.Value) {
-	return llvmutil.CreateTemporaryAlloca(c.builder, c.mod, t, name)
+func (b *builder) createTemporaryAlloca(t llvm.Type, name string) (alloca, bitcast, size llvm.Value) {
+	return llvmutil.CreateTemporaryAlloca(b.Builder, b.mod, t, name)
 }
 
 // emitLifetimeEnd signals the end of an (alloca) lifetime by calling the
 // llvm.lifetime.end intrinsic. It is commonly used together with
 // createTemporaryAlloca.
-func (c *Compiler) emitLifetimeEnd(ptr, size llvm.Value) {
-	llvmutil.EmitLifetimeEnd(c.builder, c.mod, ptr, size)
+func (b *builder) emitLifetimeEnd(ptr, size llvm.Value) {
+	llvmutil.EmitLifetimeEnd(b.Builder, b.mod, ptr, size)
 }
 
 // emitPointerPack packs the list of values into a single pointer value using
 // bitcasts, or else allocates a value on the heap if it cannot be packed in the
 // pointer value directly. It returns the pointer with the packed data.
-func (c *Compiler) emitPointerPack(values []llvm.Value) llvm.Value {
-	return llvmutil.EmitPointerPack(c.builder, c.mod, c.Config, values)
+func (b *builder) emitPointerPack(values []llvm.Value) llvm.Value {
+	return llvmutil.EmitPointerPack(b.Builder, b.mod, b.Config, values)
 }
 
 // emitPointerUnpack extracts a list of values packed using emitPointerPack.
-func (c *Compiler) emitPointerUnpack(ptr llvm.Value, valueTypes []llvm.Type) []llvm.Value {
-	return llvmutil.EmitPointerUnpack(c.builder, c.mod, ptr, valueTypes)
-}
-
-// splitBasicBlock splits a LLVM basic block into two parts. All instructions
-// after afterInst are moved into a new basic block (created right after the
-// current one) with the given name.
-func (c *Compiler) splitBasicBlock(afterInst llvm.Value, insertAfter llvm.BasicBlock, name string) llvm.BasicBlock {
-	oldBlock := afterInst.InstructionParent()
-	newBlock := c.ctx.InsertBasicBlock(insertAfter, name)
-	var nextInstructions []llvm.Value // values to move
-
-	// Collect to-be-moved instructions.
-	inst := afterInst
-	for {
-		inst = llvm.NextInstruction(inst)
-		if inst.IsNil() {
-			break
-		}
-		nextInstructions = append(nextInstructions, inst)
-	}
-
-	// Move instructions.
-	c.builder.SetInsertPointAtEnd(newBlock)
-	for _, inst := range nextInstructions {
-		inst.RemoveFromParentAsInstruction()
-		c.builder.Insert(inst)
-	}
-
-	// Find PHI nodes to update.
-	var phiNodes []llvm.Value // PHI nodes to update
-	for bb := insertAfter.Parent().FirstBasicBlock(); !bb.IsNil(); bb = llvm.NextBasicBlock(bb) {
-		for inst := bb.FirstInstruction(); !inst.IsNil(); inst = llvm.NextInstruction(inst) {
-			if inst.IsAPHINode().IsNil() {
-				continue
-			}
-			needsUpdate := false
-			incomingCount := inst.IncomingCount()
-			for i := 0; i < incomingCount; i++ {
-				if inst.IncomingBlock(i) == oldBlock {
-					needsUpdate = true
-					break
-				}
-			}
-			if !needsUpdate {
-				// PHI node has no incoming edge from the old block.
-				continue
-			}
-			phiNodes = append(phiNodes, inst)
-		}
-	}
-
-	// Update PHI nodes.
-	for _, phi := range phiNodes {
-		c.builder.SetInsertPointBefore(phi)
-		newPhi := c.builder.CreatePHI(phi.Type(), "")
-		incomingCount := phi.IncomingCount()
-		incomingVals := make([]llvm.Value, incomingCount)
-		incomingBlocks := make([]llvm.BasicBlock, incomingCount)
-		for i := 0; i < incomingCount; i++ {
-			value := phi.IncomingValue(i)
-			block := phi.IncomingBlock(i)
-			if block == oldBlock {
-				block = newBlock
-			}
-			incomingVals[i] = value
-			incomingBlocks[i] = block
-		}
-		newPhi.AddIncoming(incomingVals, incomingBlocks)
-		phi.ReplaceAllUsesWith(newPhi)
-		phi.EraseFromParentAsInstruction()
-	}
-
-	return newBlock
+func (b *builder) emitPointerUnpack(ptr llvm.Value, valueTypes []llvm.Type) []llvm.Value {
+	return llvmutil.EmitPointerUnpack(b.Builder, b.mod, ptr, valueTypes)
 }
 
 // makeGlobalArray creates a new LLVM global with the given name and integers as
 // contents, and returns the global.
 // Note that it is left with the default linkage etc., you should set
 // linkage/constant/etc properties yourself.
-func (c *Compiler) makeGlobalArray(buf []byte, name string, elementType llvm.Type) llvm.Value {
+func (c *compilerContext) makeGlobalArray(buf []byte, name string, elementType llvm.Type) llvm.Value {
 	globalType := llvm.ArrayType(elementType, len(buf))
 	global := llvm.AddGlobal(c.mod, globalType, name)
 	value := llvm.Undef(globalType)

compiler/llvmutil/llvm.go

@@ -94,3 +94,75 @@ func getLifetimeEndFunc(mod llvm.Module) llvm.Value {
 	}
 	return fn
 }
+
+// SplitBasicBlock splits a LLVM basic block into two parts. All instructions
+// after afterInst are moved into a new basic block (created right after the
+// current one) with the given name.
+func SplitBasicBlock(builder llvm.Builder, afterInst llvm.Value, insertAfter llvm.BasicBlock, name string) llvm.BasicBlock {
+	oldBlock := afterInst.InstructionParent()
+	newBlock := afterInst.Type().Context().InsertBasicBlock(insertAfter, name)
+	var nextInstructions []llvm.Value // values to move
+
+	// Collect to-be-moved instructions.
+	inst := afterInst
+	for {
+		inst = llvm.NextInstruction(inst)
+		if inst.IsNil() {
+			break
+		}
+		nextInstructions = append(nextInstructions, inst)
+	}
+
+	// Move instructions.
+	builder.SetInsertPointAtEnd(newBlock)
+	for _, inst := range nextInstructions {
+		inst.RemoveFromParentAsInstruction()
+		builder.Insert(inst)
+	}
+
+	// Find PHI nodes to update.
+	var phiNodes []llvm.Value // PHI nodes to update
+	for bb := insertAfter.Parent().FirstBasicBlock(); !bb.IsNil(); bb = llvm.NextBasicBlock(bb) {
+		for inst := bb.FirstInstruction(); !inst.IsNil(); inst = llvm.NextInstruction(inst) {
+			if inst.IsAPHINode().IsNil() {
+				continue
+			}
+			needsUpdate := false
+			incomingCount := inst.IncomingCount()
+			for i := 0; i < incomingCount; i++ {
+				if inst.IncomingBlock(i) == oldBlock {
+					needsUpdate = true
+					break
+				}
+			}
+			if !needsUpdate {
+				// PHI node has no incoming edge from the old block.
+				continue
+			}
+			phiNodes = append(phiNodes, inst)
+		}
+	}
+
+	// Update PHI nodes.
+	for _, phi := range phiNodes {
+		builder.SetInsertPointBefore(phi)
+		newPhi := builder.CreatePHI(phi.Type(), "")
+		incomingCount := phi.IncomingCount()
+		incomingVals := make([]llvm.Value, incomingCount)
+		incomingBlocks := make([]llvm.BasicBlock, incomingCount)
+		for i := 0; i < incomingCount; i++ {
+			value := phi.IncomingValue(i)
+			block := phi.IncomingBlock(i)
+			if block == oldBlock {
+				block = newBlock
+			}
+			incomingVals[i] = value
+			incomingBlocks[i] = block
+		}
+		newPhi.AddIncoming(incomingVals, incomingBlocks)
+		phi.ReplaceAllUsesWith(newPhi)
+		phi.EraseFromParentAsInstruction()
+	}
+
+	return newBlock
+}

compiler/llvmutil/wordpack.go

@@ -12,6 +12,7 @@ import (
 // EmitPointerPack packs the list of values into a single pointer value using
 // bitcasts, or else allocates a value on the heap if it cannot be packed in the
 // pointer value directly. It returns the pointer with the packed data.
+// If the values are all constants, they are be stored in a constant global and deduplicated.
 func EmitPointerPack(builder llvm.Builder, mod llvm.Module, config *compileopts.Config, values []llvm.Value) llvm.Value {
 	ctx := mod.Context()
 	targetData := llvm.NewTargetData(mod.DataLayout())
@@ -42,6 +43,27 @@ func EmitPointerPack(builder llvm.Builder, mod llvm.Module, config *compileopts.
 		// it in an alloca first for bitcasting (store+bitcast+load).
 		packedAlloc, _, _ = CreateTemporaryAlloca(builder, mod, packedType, "")
 	} else {
+		// Check if the values are all constants.
+		constant := true
+		for _, v := range values {
+			if !v.IsConstant() {
+				constant = false
+				break
+			}
+		}
+
+		if constant {
+			// The data is known at compile time, so store it in a constant global.
+			// The global address is marked as unnamed, which allows LLVM to merge duplicates.
+			funcName := builder.GetInsertBlock().Parent().Name()
+			global := llvm.AddGlobal(mod, packedType, funcName+"$pack")
+			global.SetInitializer(ctx.ConstStruct(values, false))
+			global.SetGlobalConstant(true)
+			global.SetUnnamedAddr(true)
+			global.SetLinkage(llvm.PrivateLinkage)
+			return llvm.ConstBitCast(global, i8ptrType)
+		}
+
 		// Packed data is bigger than a pointer, so allocate it on the heap.
 		sizeValue := llvm.ConstInt(uintptrType, size, false)
 		alloc := mod.NamedFunction("runtime.alloc")

compiler/map.go

@@ -6,115 +6,167 @@ import (
 	"go/token"
 	"go/types"
 
+	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )
 
-func (c *Compiler) emitMapLookup(keyType, valueType types.Type, m, key llvm.Value, commaOk bool, pos token.Pos) (llvm.Value, error) {
-	llvmValueType := c.getLLVMType(valueType)
+// createMakeMap creates a new map object (runtime.hashmap) by allocating and
+// initializing an appropriately sized object.
+func (b *builder) createMakeMap(expr *ssa.MakeMap) (llvm.Value, error) {
+	mapType := expr.Type().Underlying().(*types.Map)
+	keyType := mapType.Key().Underlying()
+	llvmValueType := b.getLLVMType(mapType.Elem().Underlying())
+	var llvmKeyType llvm.Type
+	if t, ok := keyType.(*types.Basic); ok && t.Info()&types.IsString != 0 {
+		// String keys.
+		llvmKeyType = b.getLLVMType(keyType)
+	} else if hashmapIsBinaryKey(keyType) {
+		// Trivially comparable keys.
+		llvmKeyType = b.getLLVMType(keyType)
+	} else {
+		// All other keys. Implemented as map[interface{}]valueType for ease of
+		// implementation.
+		llvmKeyType = b.getLLVMRuntimeType("_interface")
+	}
+	keySize := b.targetData.TypeAllocSize(llvmKeyType)
+	valueSize := b.targetData.TypeAllocSize(llvmValueType)
+	llvmKeySize := llvm.ConstInt(b.ctx.Int8Type(), keySize, false)
+	llvmValueSize := llvm.ConstInt(b.ctx.Int8Type(), valueSize, false)
+	sizeHint := llvm.ConstInt(b.uintptrType, 8, false)
+	if expr.Reserve != nil {
+		sizeHint = b.getValue(expr.Reserve)
+		var err error
+		sizeHint, err = b.createConvert(expr.Reserve.Type(), types.Typ[types.Uintptr], sizeHint, expr.Pos())
+		if err != nil {
+			return llvm.Value{}, err
+		}
+	}
+	hashmap := b.createRuntimeCall("hashmapMake", []llvm.Value{llvmKeySize, llvmValueSize, sizeHint}, "")
+	return hashmap, nil
+}
+
+// createMapLookup returns the value in a map. It calls a runtime function
+// depending on the map key type to load the map value and its comma-ok value.
+func (b *builder) createMapLookup(keyType, valueType types.Type, m, key llvm.Value, commaOk bool, pos token.Pos) (llvm.Value, error) {
+	llvmValueType := b.getLLVMType(valueType)
 
 	// Allocate the memory for the resulting type. Do not zero this memory: it
 	// will be zeroed by the hashmap get implementation if the key is not
 	// present in the map.
-	mapValueAlloca, mapValuePtr, mapValueSize := c.createTemporaryAlloca(llvmValueType, "hashmap.value")
+	mapValueAlloca, mapValuePtr, mapValueAllocaSize := b.createTemporaryAlloca(llvmValueType, "hashmap.value")
+
+	// We need the map size (with type uintptr) to pass to the hashmap*Get
+	// functions. This is necessary because those *Get functions are valid on
+	// nil maps, and they'll need to zero the value pointer by that number of
+	// bytes.
+	mapValueSize := mapValueAllocaSize
+	if mapValueSize.Type().IntTypeWidth() > b.uintptrType.IntTypeWidth() {
+		mapValueSize = llvm.ConstTrunc(mapValueSize, b.uintptrType)
+	}
 
 	// Do the lookup. How it is done depends on the key type.
 	var commaOkValue llvm.Value
+	keyType = keyType.Underlying()
 	if t, ok := keyType.(*types.Basic); ok && t.Info()&types.IsString != 0 {
 		// key is a string
-		params := []llvm.Value{m, key, mapValuePtr}
-		commaOkValue = c.createRuntimeCall("hashmapStringGet", params, "")
+		params := []llvm.Value{m, key, mapValuePtr, mapValueSize}
+		commaOkValue = b.createRuntimeCall("hashmapStringGet", params, "")
 	} else if hashmapIsBinaryKey(keyType) {
 		// key can be compared with runtime.memequal
 		// Store the key in an alloca, in the entry block to avoid dynamic stack
 		// growth.
-		mapKeyAlloca, mapKeyPtr, mapKeySize := c.createTemporaryAlloca(key.Type(), "hashmap.key")
-		c.builder.CreateStore(key, mapKeyAlloca)
+		mapKeyAlloca, mapKeyPtr, mapKeySize := b.createTemporaryAlloca(key.Type(), "hashmap.key")
+		b.CreateStore(key, mapKeyAlloca)
 		// Fetch the value from the hashmap.
-		params := []llvm.Value{m, mapKeyPtr, mapValuePtr}
-		commaOkValue = c.createRuntimeCall("hashmapBinaryGet", params, "")
-		c.emitLifetimeEnd(mapKeyPtr, mapKeySize)
+		params := []llvm.Value{m, mapKeyPtr, mapValuePtr, mapValueSize}
+		commaOkValue = b.createRuntimeCall("hashmapBinaryGet", params, "")
+		b.emitLifetimeEnd(mapKeyPtr, mapKeySize)
 	} else {
-		// Not trivially comparable using memcmp.
-		return llvm.Value{}, c.makeError(pos, "only strings, bools, ints, pointers or structs of bools/ints are supported as map keys, but got: "+keyType.String())
+		// Not trivially comparable using memcmp. Make it an interface instead.
+		itfKey := key
+		if _, ok := keyType.(*types.Interface); !ok {
+			// Not already an interface, so convert it to an interface now.
+			itfKey = b.createMakeInterface(key, keyType, pos)
+		}
+		params := []llvm.Value{m, itfKey, mapValuePtr, mapValueSize}
+		commaOkValue = b.createRuntimeCall("hashmapInterfaceGet", params, "")
 	}
 
 	// Load the resulting value from the hashmap. The value is set to the zero
 	// value if the key doesn't exist in the hashmap.
-	mapValue := c.builder.CreateLoad(mapValueAlloca, "")
-	c.emitLifetimeEnd(mapValuePtr, mapValueSize)
+	mapValue := b.CreateLoad(mapValueAlloca, "")
+	b.emitLifetimeEnd(mapValuePtr, mapValueAllocaSize)
 
 	if commaOk {
-		tuple := llvm.Undef(c.ctx.StructType([]llvm.Type{llvmValueType, c.ctx.Int1Type()}, false))
-		tuple = c.builder.CreateInsertValue(tuple, mapValue, 0, "")
-		tuple = c.builder.CreateInsertValue(tuple, commaOkValue, 1, "")
+		tuple := llvm.Undef(b.ctx.StructType([]llvm.Type{llvmValueType, b.ctx.Int1Type()}, false))
+		tuple = b.CreateInsertValue(tuple, mapValue, 0, "")
+		tuple = b.CreateInsertValue(tuple, commaOkValue, 1, "")
 		return tuple, nil
 	} else {
 		return mapValue, nil
 	}
 }
 
-func (c *Compiler) emitMapUpdate(keyType types.Type, m, key, value llvm.Value, pos token.Pos) {
-	valueAlloca, valuePtr, valueSize := c.createTemporaryAlloca(value.Type(), "hashmap.value")
-	c.builder.CreateStore(value, valueAlloca)
+// createMapUpdate updates a map key to a given value, by creating an
+// appropriate runtime call.
+func (b *builder) createMapUpdate(keyType types.Type, m, key, value llvm.Value, pos token.Pos) {
+	valueAlloca, valuePtr, valueSize := b.createTemporaryAlloca(value.Type(), "hashmap.value")
+	b.CreateStore(value, valueAlloca)
 	keyType = keyType.Underlying()
 	if t, ok := keyType.(*types.Basic); ok && t.Info()&types.IsString != 0 {
 		// key is a string
 		params := []llvm.Value{m, key, valuePtr}
-		c.createRuntimeCall("hashmapStringSet", params, "")
+		b.createRuntimeCall("hashmapStringSet", params, "")
 	} else if hashmapIsBinaryKey(keyType) {
 		// key can be compared with runtime.memequal
-		keyAlloca, keyPtr, keySize := c.createTemporaryAlloca(key.Type(), "hashmap.key")
-		c.builder.CreateStore(key, keyAlloca)
+		keyAlloca, keyPtr, keySize := b.createTemporaryAlloca(key.Type(), "hashmap.key")
+		b.CreateStore(key, keyAlloca)
 		params := []llvm.Value{m, keyPtr, valuePtr}
-		c.createRuntimeCall("hashmapBinarySet", params, "")
-		c.emitLifetimeEnd(keyPtr, keySize)
+		b.createRuntimeCall("hashmapBinarySet", params, "")
+		b.emitLifetimeEnd(keyPtr, keySize)
 	} else {
-		c.addError(pos, "only strings, bools, ints, pointers or structs of bools/ints are supported as map keys, but got: "+keyType.String())
+		// Key is not trivially comparable, so compare it as an interface instead.
+		itfKey := key
+		if _, ok := keyType.(*types.Interface); !ok {
+			// Not already an interface, so convert it to an interface first.
+			itfKey = b.createMakeInterface(key, keyType, pos)
+		}
+		params := []llvm.Value{m, itfKey, valuePtr}
+		b.createRuntimeCall("hashmapInterfaceSet", params, "")
 	}
-	c.emitLifetimeEnd(valuePtr, valueSize)
+	b.emitLifetimeEnd(valuePtr, valueSize)
 }
 
-func (c *Compiler) emitMapDelete(keyType types.Type, m, key llvm.Value, pos token.Pos) error {
+// createMapDelete deletes a key from a map by calling the appropriate runtime
+// function. It is the implementation of the Go delete() builtin.
+func (b *builder) createMapDelete(keyType types.Type, m, key llvm.Value, pos token.Pos) error {
 	keyType = keyType.Underlying()
 	if t, ok := keyType.(*types.Basic); ok && t.Info()&types.IsString != 0 {
 		// key is a string
 		params := []llvm.Value{m, key}
-		c.createRuntimeCall("hashmapStringDelete", params, "")
+		b.createRuntimeCall("hashmapStringDelete", params, "")
 		return nil
 	} else if hashmapIsBinaryKey(keyType) {
-		keyAlloca, keyPtr, keySize := c.createTemporaryAlloca(key.Type(), "hashmap.key")
-		c.builder.CreateStore(key, keyAlloca)
+		keyAlloca, keyPtr, keySize := b.createTemporaryAlloca(key.Type(), "hashmap.key")
+		b.CreateStore(key, keyAlloca)
 		params := []llvm.Value{m, keyPtr}
-		c.createRuntimeCall("hashmapBinaryDelete", params, "")
-		c.emitLifetimeEnd(keyPtr, keySize)
+		b.createRuntimeCall("hashmapBinaryDelete", params, "")
+		b.emitLifetimeEnd(keyPtr, keySize)
 		return nil
 	} else {
-		return c.makeError(pos, "only strings, bools, ints, pointers or structs of bools/ints are supported as map keys, but got: "+keyType.String())
+		// Key is not trivially comparable, so compare it as an interface
+		// instead.
+		itfKey := key
+		if _, ok := keyType.(*types.Interface); !ok {
+			// Not already an interface, so convert it to an interface first.
+			itfKey = b.createMakeInterface(key, keyType, pos)
+		}
+		params := []llvm.Value{m, itfKey}
+		b.createRuntimeCall("hashmapInterfaceDelete", params, "")
+		return nil
 	}
 }
 
-// Get FNV-1a hash of this string.
-//
-// https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function#FNV-1a_hash
-func hashmapHash(data []byte) uint32 {
-	var result uint32 = 2166136261 // FNV offset basis
-	for _, c := range data {
-		result ^= uint32(c)
-		result *= 16777619 // FNV prime
-	}
-	return result
-}
-
-// Get the topmost 8 bits of the hash, without using a special value (like 0).
-func hashmapTopHash(hash uint32) uint8 {
-	tophash := uint8(hash >> 24)
-	if tophash < 1 {
-		// 0 means empty slot, so make it bigger.
-		tophash += 1
-	}
-	return tophash
-}
-
 // Returns true if this key type does not contain strings, interfaces etc., so
 // can be compared with runtime.memequal.
 func hashmapIsBinaryKey(keyType types.Type) bool {

compiler/optimizer.go

@@ -1,149 +0,0 @@
-package compiler
-
-import (
-	"errors"
-
-	"github.com/tinygo-org/tinygo/transform"
-	"tinygo.org/x/go-llvm"
-)
-
-// Run the LLVM optimizer over the module.
-// The inliner can be disabled (if necessary) by passing 0 to the inlinerThreshold.
-func (c *Compiler) Optimize(optLevel, sizeLevel int, inlinerThreshold uint) error {
-	builder := llvm.NewPassManagerBuilder()
-	defer builder.Dispose()
-	builder.SetOptLevel(optLevel)
-	builder.SetSizeLevel(sizeLevel)
-	if inlinerThreshold != 0 {
-		builder.UseInlinerWithThreshold(inlinerThreshold)
-	}
-	builder.AddCoroutinePassesToExtensionPoints()
-
-	if c.PanicStrategy() == "trap" {
-		transform.ReplacePanicsWithTrap(c.mod) // -panic=trap
-	}
-
-	// run a check of all of our code
-	if c.VerifyIR() {
-		err := c.checkModule()
-		if err != nil {
-			return err
-		}
-	}
-
-	// Run function passes for each function.
-	funcPasses := llvm.NewFunctionPassManagerForModule(c.mod)
-	defer funcPasses.Dispose()
-	builder.PopulateFunc(funcPasses)
-	funcPasses.InitializeFunc()
-	for fn := c.mod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
-		funcPasses.RunFunc(fn)
-	}
-	funcPasses.FinalizeFunc()
-
-	if optLevel > 0 {
-		// Run some preparatory passes for the Go optimizer.
-		goPasses := llvm.NewPassManager()
-		defer goPasses.Dispose()
-		goPasses.AddGlobalOptimizerPass()
-		goPasses.AddConstantPropagationPass()
-		goPasses.AddAggressiveDCEPass()
-		goPasses.AddFunctionAttrsPass()
-		goPasses.Run(c.mod)
-
-		// Run Go-specific optimization passes.
-		transform.OptimizeMaps(c.mod)
-		transform.OptimizeStringToBytes(c.mod)
-		transform.OptimizeAllocs(c.mod)
-		transform.LowerInterfaces(c.mod)
-		c.LowerFuncValues()
-
-		// After interfaces are lowered, there are many more opportunities for
-		// interprocedural optimizations. To get them to work, function
-		// attributes have to be updated first.
-		goPasses.Run(c.mod)
-
-		// Run TinyGo-specific interprocedural optimizations.
-		transform.OptimizeAllocs(c.mod)
-		transform.OptimizeStringToBytes(c.mod)
-
-		// Lower runtime.isnil calls to regular nil comparisons.
-		isnil := c.mod.NamedFunction("runtime.isnil")
-		if !isnil.IsNil() {
-			for _, use := range getUses(isnil) {
-				c.builder.SetInsertPointBefore(use)
-				ptr := use.Operand(0)
-				if !ptr.IsABitCastInst().IsNil() {
-					ptr = ptr.Operand(0)
-				}
-				nilptr := llvm.ConstPointerNull(ptr.Type())
-				icmp := c.builder.CreateICmp(llvm.IntEQ, ptr, nilptr, "")
-				use.ReplaceAllUsesWith(icmp)
-				use.EraseFromParentAsInstruction()
-			}
-		}
-
-		err := c.LowerGoroutines()
-		if err != nil {
-			return err
-		}
-	} else {
-		// Must be run at any optimization level.
-		transform.LowerInterfaces(c.mod)
-		c.LowerFuncValues()
-		err := c.LowerGoroutines()
-		if err != nil {
-			return err
-		}
-	}
-	if c.VerifyIR() {
-		if err := c.checkModule(); err != nil {
-			return err
-		}
-	}
-	if err := c.Verify(); err != nil {
-		return errors.New("optimizations caused a verification failure")
-	}
-
-	if sizeLevel >= 2 {
-		// Set the "optsize" attribute to make slightly smaller binaries at the
-		// cost of some performance.
-		kind := llvm.AttributeKindID("optsize")
-		attr := c.ctx.CreateEnumAttribute(kind, 0)
-		for fn := c.mod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
-			fn.AddFunctionAttr(attr)
-		}
-	}
-
-	// After TinyGo-specific transforms have finished, undo exporting these functions.
-	for _, name := range c.getFunctionsUsedInTransforms() {
-		fn := c.mod.NamedFunction(name)
-		if fn.IsNil() {
-			continue
-		}
-		fn.SetLinkage(llvm.InternalLinkage)
-	}
-
-	// Run function passes again, because without it, llvm.coro.size.i32()
-	// doesn't get lowered.
-	for fn := c.mod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
-		funcPasses.RunFunc(fn)
-	}
-	funcPasses.FinalizeFunc()
-
-	// Run module passes.
-	modPasses := llvm.NewPassManager()
-	defer modPasses.Dispose()
-	builder.Populate(modPasses)
-	modPasses.Run(c.mod)
-
-	hasGCPass := transform.AddGlobalsBitmap(c.mod)
-	hasGCPass = transform.MakeGCStackSlots(c.mod) || hasGCPass
-	if hasGCPass {
-		if err := c.Verify(); err != nil {
-			return errors.New("GC pass caused a verification failure")
-		}
-	}
-
-	return nil
-}

compiler/sizes.go

@@ -10,13 +10,13 @@ import (
 // The original license can be found here:
 //     https://golang.org/LICENSE
 
-type StdSizes struct {
+type stdSizes struct {
 	IntSize  int64
 	PtrSize  int64
 	MaxAlign int64
 }
 
-func (s *StdSizes) Alignof(T types.Type) int64 {
+func (s *stdSizes) Alignof(T types.Type) int64 {
 	// For arrays and structs, alignment is defined in terms
 	// of alignment of the elements and fields, respectively.
 	switch t := T.Underlying().(type) {
@@ -61,7 +61,7 @@ func (s *StdSizes) Alignof(T types.Type) int64 {
 	return a
 }
 
-func (s *StdSizes) Offsetsof(fields []*types.Var) []int64 {
+func (s *stdSizes) Offsetsof(fields []*types.Var) []int64 {
 	offsets := make([]int64, len(fields))
 	var o int64
 	for i, f := range fields {
@@ -89,7 +89,7 @@ var basicSizes = [...]byte{
 	types.Complex128: 16,
 }
 
-func (s *StdSizes) Sizeof(T types.Type) int64 {
+func (s *stdSizes) Sizeof(T types.Type) int64 {
 	switch t := T.Underlying().(type) {
 	case *types.Basic:
 		k := t.Kind()
@@ -110,6 +110,9 @@ func (s *StdSizes) Sizeof(T types.Type) int64 {
 		if k == types.UnsafePointer {
 			return s.PtrSize
 		}
+		if k == types.Invalid {
+			return 0 // only relevant when there is a type error somewhere
+		}
 		panic("unknown basic type: " + t.String())
 	case *types.Array:
 		n := t.Len()

compiler/symbol.go

@@ -26,7 +26,7 @@ type globalInfo struct {
 
 // loadASTComments loads comments on globals from the AST, for use later in the
 // program. In particular, they are required for //go:extern pragmas on globals.
-func (c *Compiler) loadASTComments(lprogram *loader.Program) {
+func (c *compilerContext) loadASTComments(lprogram *loader.Program) {
 	c.astComments = map[string]*ast.CommentGroup{}
 	for _, pkgInfo := range lprogram.Sorted() {
 		for _, file := range pkgInfo.Files {
@@ -56,25 +56,55 @@ func (c *Compiler) loadASTComments(lprogram *loader.Program) {
 
 // getGlobal returns a LLVM IR global value for a Go SSA global. It is added to
 // the LLVM IR if it has not been added already.
-func (c *Compiler) getGlobal(g *ssa.Global) llvm.Value {
+func (c *compilerContext) getGlobal(g *ssa.Global) llvm.Value {
 	info := c.getGlobalInfo(g)
 	llvmGlobal := c.mod.NamedGlobal(info.linkName)
 	if llvmGlobal.IsNil() {
-		llvmType := c.getLLVMType(g.Type().(*types.Pointer).Elem())
+		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)
 		}
-		if info.align > c.targetData.ABITypeAlignment(llvmType) {
-			llvmGlobal.SetAlignment(info.align)
+
+		// Set alignment from the //go:align comment.
+		var alignInBits uint32
+		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(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.ir.Program.Fset.Position(g.Pos())
+			diglobal := c.dibuilder.CreateGlobalVariableExpression(c.difiles[pos.Filename], llvm.DIGlobalVariableExpression{
+				Name:        g.RelString(nil),
+				LinkageName: info.linkName,
+				File:        c.getDIFile(pos.Filename),
+				Line:        pos.Line,
+				Type:        c.getDIType(typ),
+				LocalToUnit: false,
+				Expr:        c.dibuilder.CreateExpression(nil),
+				AlignInBits: alignInBits,
+			})
+			llvmGlobal.AddMetadata(0, diglobal)
 		}
 	}
 	return llvmGlobal
 }
 
 // getGlobalInfo returns some information about a specific global.
-func (c *Compiler) getGlobalInfo(g *ssa.Global) globalInfo {
+func (c *compilerContext) getGlobalInfo(g *ssa.Global) globalInfo {
 	info := globalInfo{}
 	if strings.HasPrefix(g.Name(), "C.") {
 		// Created by CGo: such a name cannot be created by regular C code.

compiler/syscall.go

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

compiler/volatile.go

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

go.mod

@@ -4,11 +4,10 @@ go 1.11
 
 require (
 	github.com/blakesmith/ar v0.0.0-20150311145944-8bd4349a67f2
-	github.com/creack/goselect v0.1.0 // indirect
 	github.com/google/shlex v0.0.0-20181106134648-c34317bd91bf
 	github.com/marcinbor85/gohex v0.0.0-20180128172054-7a43cd876e46
-	go.bug.st/serial.v1 v0.0.0-20180827123349-5f7892a7bb45
-	golang.org/x/sys v0.0.0-20191010194322-b09406accb47 // indirect
-	golang.org/x/tools v0.0.0-20190227180812-8dcc6e70cdef
-	tinygo.org/x/go-llvm v0.0.0-20191124211856-b2db3df3f257
+	go.bug.st/serial v1.0.0
+	golang.org/x/tools v0.0.0-20200216192241-b320d3a0f5a2
+	google.golang.org/appengine v1.4.0 // indirect
+	tinygo.org/x/go-llvm v0.0.0-20200401165421-8d120882fc7a
 )

go.sum

@@ -1,23 +1,42 @@
 github.com/blakesmith/ar v0.0.0-20150311145944-8bd4349a67f2 h1:oMCHnXa6CCCafdPDbMh/lWRhRByN0VFLvv+g+ayx1SI=
 github.com/blakesmith/ar v0.0.0-20150311145944-8bd4349a67f2/go.mod h1:PkYb9DJNAwrSvRx5DYA+gUcOIgTGVMNkfSCbZM8cWpI=
-github.com/creack/goselect v0.1.0 h1:4QiXIhcpSQF50XGaBsFzesjwX/1qOY5bOveQPmN9CXY=
-github.com/creack/goselect v0.1.0/go.mod h1:gHrIcH/9UZDn2qgeTUeW5K9eZsVYCH6/60J/FHysWyE=
+github.com/creack/goselect v0.1.1 h1:tiSSgKE1eJtxs1h/VgGQWuXUP0YS4CDIFMp6vaI1ls0=
+github.com/creack/goselect v0.1.1/go.mod h1:a/NhLweNvqIYMuxcMOuWY516Cimucms3DglDzQP3hKY=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/google/shlex v0.0.0-20181106134648-c34317bd91bf h1:7+FW5aGwISbqUtkfmIpZJGRgNFg2ioYPvFaUxdqpDsg=
 github.com/google/shlex v0.0.0-20181106134648-c34317bd91bf/go.mod h1:RpwtwJQFrIEPstU94h88MWPXP2ektJZ8cZ0YntAmXiE=
 github.com/marcinbor85/gohex v0.0.0-20180128172054-7a43cd876e46 h1:wXG2bA8fO7Vv7lLk2PihFMTqmbT173Tje39oKzQ50Mo=
 github.com/marcinbor85/gohex v0.0.0-20180128172054-7a43cd876e46/go.mod h1:Pb6XcsXyropB9LNHhnqaknG/vEwYztLkQzVCHv8sQ3M=
-go.bug.st/serial.v1 v0.0.0-20180827123349-5f7892a7bb45 h1:mACY1anK6HNCZtm/DK2Rf2ZPHggVqeB0+7rY9Gl6wyI=
-go.bug.st/serial.v1 v0.0.0-20180827123349-5f7892a7bb45/go.mod h1:dRSl/CVCTf56CkXgJMDOdSwNfo2g1orOGE/gBGdvjZw=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+go.bug.st/serial v1.0.0 h1:ogEPzrllCsnG00EqKRjeYvPRsO7NJW6DqykzkdD6E/k=
+go.bug.st/serial v1.0.0/go.mod h1:rpXPISGjuNjPTRTcMlxi9lN6LoIPxd1ixVjBd8aSk/Q=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee h1:WG0RUwxtNT4qqaXX3DPA8zHFNm/D9xaBpxzHt1WcA/E=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20191010194322-b09406accb47 h1:/XfQ9z7ib8eEJX2hdgFTZJ/ntt0swNk5oYBziWeTCvY=
-golang.org/x/sys v0.0.0-20191010194322-b09406accb47/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191128015809-6d18c012aee9 h1:ZBzSG/7F4eNKz2L3GE9o300RX0Az1Bw5HF7PDraD+qU=
+golang.org/x/sys v0.0.0-20191128015809-6d18c012aee9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/tools v0.0.0-20190227180812-8dcc6e70cdef h1:ymc9FeDom3RIEA3coKokSllBB1hRcMT0tZ1W3Jf9Ids=
 golang.org/x/tools v0.0.0-20190227180812-8dcc6e70cdef/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
+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=
 google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+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-20190224120431-7707ae5d1261 h1:rJS2Hga39YAnm7DE4qrPm6Dr/67EOojL0XPzvbEeBiw=
 tinygo.org/x/go-llvm v0.0.0-20190224120431-7707ae5d1261/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
 tinygo.org/x/go-llvm v0.0.0-20190818154551-95bc4ffe1add h1:dFjMH1sLhYADg8UQm7DB56B7e+TfvAmWmEZLhyv3r/w=
@@ -30,3 +49,11 @@ tinygo.org/x/go-llvm v0.0.0-20191113125529-bad6d01809e8 h1:9Bfvso+tTVQg16UzOA614
 tinygo.org/x/go-llvm v0.0.0-20191113125529-bad6d01809e8/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
 tinygo.org/x/go-llvm v0.0.0-20191124211856-b2db3df3f257 h1:o8VDylrMN7gWemBMu8rEyuogKPhcLTdx5KrUAp9macc=
 tinygo.org/x/go-llvm v0.0.0-20191124211856-b2db3df3f257/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
+tinygo.org/x/go-llvm v0.0.0-20191215173731-ad71f3d24aae h1:s8J5EyxCkHxXB08UI3gk9W9IS/ekizRvSX+PfZxnAB0=
+tinygo.org/x/go-llvm v0.0.0-20191215173731-ad71f3d24aae/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
+tinygo.org/x/go-llvm v0.0.0-20200104190746-1ff21df33566 h1:a4y30bTf7U0zDA75v2PTL+XQ2OzJetj19gK8XwQpUNY=
+tinygo.org/x/go-llvm v0.0.0-20200104190746-1ff21df33566/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
+tinygo.org/x/go-llvm v0.0.0-20200226165415-53522ab6713d h1:mtgZh/e8a3wxneQFuLXoQYO//1mvlki02yZ1JCwMKp4=
+tinygo.org/x/go-llvm v0.0.0-20200226165415-53522ab6713d/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
+tinygo.org/x/go-llvm v0.0.0-20200401165421-8d120882fc7a h1:Ugje2Lxuv8CFncHzs5W+hWfJvPsM+W4K0zRvzFbLvoE=
+tinygo.org/x/go-llvm v0.0.0-20200401165421-8d120882fc7a/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=

goenv/goenv.go

@@ -18,6 +18,7 @@ var Keys = []string{
 	"GOROOT",
 	"GOPATH",
 	"GOCACHE",
+	"CGO_ENABLED",
 	"TINYGOROOT",
 }
 
@@ -57,6 +58,13 @@ func Get(name string) string {
 			panic("could not find cache dir: " + err.Error())
 		}
 		return filepath.Join(dir, "tinygo")
+	case "CGO_ENABLED":
+		val := os.Getenv("CGO_ENABLED")
+		if val == "1" || val == "0" {
+			return val
+		}
+		// Default to enabling CGo.
+		return "1"
 	case "TINYGOROOT":
 		return sourceDir()
 	default:

goenv/version.go

@@ -0,0 +1,64 @@
+package goenv
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+// GetGorootVersion returns the major and minor version for a given GOROOT path.
+// If the goroot cannot be determined, (0, 0) is returned.
+func GetGorootVersion(goroot string) (major, minor int, err error) {
+	s, err := GorootVersionString(goroot)
+	if err != nil {
+		return 0, 0, err
+	}
+
+	if s == "" || s[:2] != "go" {
+		return 0, 0, errors.New("could not parse Go version: version does not start with 'go' prefix")
+	}
+
+	parts := strings.Split(s[2:], ".")
+	if len(parts) < 2 {
+		return 0, 0, errors.New("could not parse Go version: version has less than two parts")
+	}
+
+	// Ignore the errors, we don't really handle errors here anyway.
+	var trailing string
+	n, err := fmt.Sscanf(s, "go%d.%d%s", &major, &minor, &trailing)
+	if n == 2 && err == io.EOF {
+		// Means there were no trailing characters (i.e., not an alpha/beta)
+		err = nil
+	}
+	if err != nil {
+		return 0, 0, fmt.Errorf("failed to parse version: %s", err)
+	}
+	return
+}
+
+// GorootVersionString returns the version string as reported by the Go
+// toolchain for the given GOROOT path. It is usually of the form `go1.x.y` but
+// can have some variations (for beta releases, for example).
+func GorootVersionString(goroot string) (string, error) {
+	if data, err := ioutil.ReadFile(filepath.Join(
+		goroot, "src", "runtime", "internal", "sys", "zversion.go")); err == nil {
+
+		r := regexp.MustCompile("const TheVersion = `(.*)`")
+		matches := r.FindSubmatch(data)
+		if len(matches) != 2 {
+			return "", errors.New("Invalid go version output:\n" + string(data))
+		}
+
+		return string(matches[1]), nil
+
+	} else if data, err := ioutil.ReadFile(filepath.Join(goroot, "VERSION")); err == nil {
+		return string(data), nil
+
+	} else {
+		return "", err
+	}
+}

interp/errors.go

@@ -13,55 +13,44 @@ import (
 
 // errUnreachable is returned when an unreachable instruction is executed. This
 // error should not be visible outside of the interp package.
-var errUnreachable = errors.New("interp: unreachable executed")
-
-// Unsupported is the specific error that is returned when an unsupported
-// instruction is hit while trying to interpret all initializers.
-type Unsupported struct {
-	ImportPath string
-	Inst       llvm.Value
-	Pos        token.Position
-}
-
-func (e Unsupported) Error() string {
-	// TODO: how to return the actual instruction string?
-	// It looks like LLVM provides no function for that...
-	return scanner.Error{
-		Pos: e.Pos,
-		Msg: "interp: unsupported instruction",
-	}.Error()
-}
+var errUnreachable = &Error{Err: errors.New("interp: unreachable executed")}
 
 // unsupportedInstructionError returns a new "unsupported instruction" error for
 // the given instruction. It includes source location information, when
 // available.
-func (e *evalPackage) unsupportedInstructionError(inst llvm.Value) *Unsupported {
-	return &Unsupported{
-		ImportPath: e.packagePath,
-		Inst:       inst,
-		Pos:        getPosition(inst),
-	}
+func (e *evalPackage) unsupportedInstructionError(inst llvm.Value) *Error {
+	return e.errorAt(inst, errors.New("interp: unsupported instruction"))
+}
+
+// ErrorLine is one line in a traceback. The position may be missing.
+type ErrorLine struct {
+	Pos  token.Position
+	Inst llvm.Value
 }
 
 // Error encapsulates compile-time interpretation errors with an associated
 // import path. The errors may not have a precise location attached.
 type Error struct {
 	ImportPath string
-	Errs       []scanner.Error
+	Inst       llvm.Value
+	Pos        token.Position
+	Err        error
+	Traceback  []ErrorLine
 }
 
 // Error returns the string of the first error in the list of errors.
-func (e Error) Error() string {
-	return e.Errs[0].Error()
+func (e *Error) Error() string {
+	return e.Pos.String() + ": " + e.Err.Error()
 }
 
 // errorAt returns an error value for the currently interpreted package at the
 // location of the instruction. The location information may not be complete as
 // it depends on debug information in the IR.
-func (e *evalPackage) errorAt(inst llvm.Value, msg string) Error {
-	return Error{
+func (e *evalPackage) errorAt(inst llvm.Value, err error) *Error {
+	return &Error{
 		ImportPath: e.packagePath,
-		Errs:       []scanner.Error{errorAt(inst, msg)},
+		Pos:        getPosition(inst),
+		Err:        err,
 	}
 }
 

interp/frame.go

@@ -4,6 +4,7 @@ package interp
 // functions.
 
 import (
+	"errors"
 	"strings"
 
 	"tinygo.org/x/go-llvm"
@@ -21,7 +22,7 @@ type frame struct {
 // Most of it works at compile time. Some calls get translated into calls to be
 // executed at runtime: calls to functions with side effects, external calls,
 // and operations on the result of such instructions.
-func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (retval Value, outgoing []llvm.Value, err error) {
+func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (retval Value, outgoing []llvm.Value, err *Error) {
 	for inst := bb.FirstInstruction(); !inst.IsNil(); inst = llvm.NextInstruction(inst) {
 		if fr.Debug {
 			print(indent)
@@ -97,7 +98,7 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 				value = operand.Load()
 			}
 			if value.Type() != inst.Type() {
-				return nil, nil, fr.errorAt(inst, "interp: load: type does not match")
+				return nil, nil, fr.errorAt(inst, errors.New("interp: load: type does not match"))
 			}
 			fr.locals[inst] = fr.getValue(value)
 		case !inst.IsAStoreInst().IsNil():
@@ -121,13 +122,16 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 					// Not a constant operation.
 					// This should be detected by the scanner, but isn't at the
 					// moment.
-					return nil, nil, fr.errorAt(inst, "todo: non-const gep")
+					return nil, nil, fr.errorAt(inst, errors.New("todo: non-const gep"))
 				}
 				indices[i] = uint32(operand.Value().ZExtValue())
 			}
-			result := value.GetElementPtr(indices)
+			result, err := value.GetElementPtr(indices)
+			if err != nil {
+				return nil, nil, fr.errorAt(inst, err)
+			}
 			if result.Type() != inst.Type() {
-				return nil, nil, fr.errorAt(inst, "interp: gep: type does not match")
+				return nil, nil, fr.errorAt(inst, errors.New("interp: gep: type does not match"))
 			}
 			fr.locals[inst] = result
 
@@ -182,7 +186,7 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 					}
 				}
 				// It is not possible in Go to bitcast a map value to a pointer.
-				return nil, nil, fr.errorAt(inst, "unimplemented: bitcast of map")
+				return nil, nil, fr.errorAt(inst, errors.New("unimplemented: bitcast of map"))
 			}
 			value := fr.getLocal(operand).(*LocalValue)
 			fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateBitCast(value.Value(), inst.Type(), "")}
@@ -264,7 +268,11 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 				if elementCount == 1 {
 					fr.locals[resultInst] = result
 				} else {
-					fr.locals[resultInst] = result.GetElementPtr([]uint32{0, 0})
+					result, err := result.GetElementPtr([]uint32{0, 0})
+					if err != nil {
+						return nil, nil, fr.errorAt(inst, err)
+					}
+					fr.locals[resultInst] = result
 				}
 			case callee.Name() == "runtime.hashmapMake":
 				// create a map
@@ -278,24 +286,49 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 				}
 			case callee.Name() == "runtime.hashmapStringSet":
 				// set a string key in the map
-				m, ok := fr.getLocal(inst.Operand(0)).(*MapValue)
-				if !ok {
-					return nil, nil, fr.errorAt(inst, "could not update map with string key")
-				}
-				// "key" is a Go string value, which in the TinyGo calling convention is split up
-				// into separate pointer and length parameters.
 				keyBuf := fr.getLocal(inst.Operand(1)).(*LocalValue)
 				keyLen := fr.getLocal(inst.Operand(2)).(*LocalValue)
 				valPtr := fr.getLocal(inst.Operand(3)).(*LocalValue)
+				m, ok := fr.getLocal(inst.Operand(0)).(*MapValue)
+				if !ok || !keyBuf.IsConstant() || !keyLen.IsConstant() || !valPtr.IsConstant() {
+					// The mapassign operation could not be done at compile
+					// time. Do it at runtime instead.
+					m := fr.getLocal(inst.Operand(0)).Value()
+					fr.markDirty(m)
+					llvmParams := []llvm.Value{
+						m,                                    // *runtime.hashmap
+						fr.getLocal(inst.Operand(1)).Value(), // key.ptr
+						fr.getLocal(inst.Operand(2)).Value(), // key.len
+						fr.getLocal(inst.Operand(3)).Value(), // value (unsafe.Pointer)
+						fr.getLocal(inst.Operand(4)).Value(), // context
+						fr.getLocal(inst.Operand(5)).Value(), // parentHandle
+					}
+					fr.builder.CreateCall(callee, llvmParams, "")
+					continue
+				}
+				// "key" is a Go string value, which in the TinyGo calling convention is split up
+				// into separate pointer and length parameters.
 				m.PutString(keyBuf, keyLen, valPtr)
 			case callee.Name() == "runtime.hashmapBinarySet":
 				// set a binary (int etc.) key in the map
-				m, ok := fr.getLocal(inst.Operand(0)).(*MapValue)
-				if !ok {
-					return nil, nil, fr.errorAt(inst, "could not update map")
-				}
 				keyBuf := fr.getLocal(inst.Operand(1)).(*LocalValue)
 				valPtr := fr.getLocal(inst.Operand(2)).(*LocalValue)
+				m, ok := fr.getLocal(inst.Operand(0)).(*MapValue)
+				if !ok || !keyBuf.IsConstant() || !valPtr.IsConstant() {
+					// The mapassign operation could not be done at compile
+					// time. Do it at runtime instead.
+					m := fr.getLocal(inst.Operand(0)).Value()
+					fr.markDirty(m)
+					llvmParams := []llvm.Value{
+						m,                                    // *runtime.hashmap
+						fr.getLocal(inst.Operand(1)).Value(), // key
+						fr.getLocal(inst.Operand(2)).Value(), // value
+						fr.getLocal(inst.Operand(3)).Value(), // context
+						fr.getLocal(inst.Operand(4)).Value(), // parentHandle
+					}
+					fr.builder.CreateCall(callee, llvmParams, "")
+					continue
+				}
 				m.PutBinary(keyBuf, valPtr)
 			case callee.Name() == "runtime.stringConcat":
 				// adding two strings together
@@ -340,32 +373,49 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 					// a bitcast of the original array instead of the GEP,
 					// which breaks our assumptions.
 					// Re-add this GEP, in the hope that it it is then of the correct type...
-					dstArray = dstArray.GetElementPtr([]uint32{0, 0}).(*LocalValue)
-					srcArray = srcArray.GetElementPtr([]uint32{0, 0}).(*LocalValue)
+					dstArrayValue, err := dstArray.GetElementPtr([]uint32{0, 0})
+					if err != nil {
+						return nil, nil, fr.errorAt(inst, err)
+					}
+					dstArray = dstArrayValue.(*LocalValue)
+					srcArrayValue, err := srcArray.GetElementPtr([]uint32{0, 0})
+					if err != nil {
+						return nil, nil, fr.errorAt(inst, err)
+					}
+					srcArray = srcArrayValue.(*LocalValue)
 				}
 				if fr.Eval.TargetData.TypeAllocSize(dstArray.Type().ElementType()) != elementSize {
-					return nil, nil, fr.errorAt(inst, "interp: slice dst element size does not match pointer type")
+					return nil, nil, fr.errorAt(inst, errors.New("interp: slice dst element size does not match pointer type"))
 				}
 				if fr.Eval.TargetData.TypeAllocSize(srcArray.Type().ElementType()) != elementSize {
-					return nil, nil, fr.errorAt(inst, "interp: slice src element size does not match pointer type")
+					return nil, nil, fr.errorAt(inst, errors.New("interp: slice src element size does not match pointer type"))
 				}
 				if dstArray.Type() != srcArray.Type() {
-					return nil, nil, fr.errorAt(inst, "interp: slice element types don't match")
+					return nil, nil, fr.errorAt(inst, errors.New("interp: slice element types don't match"))
 				}
 				length := dstLen.Value().SExtValue()
 				if srcLength := srcLen.Value().SExtValue(); srcLength < length {
 					length = srcLength
 				}
 				if length < 0 {
-					return nil, nil, fr.errorAt(inst, "interp: trying to copy a slice with negative length?")
+					return nil, nil, fr.errorAt(inst, errors.New("interp: trying to copy a slice with negative length?"))
 				}
 				for i := int64(0); i < length; i++ {
+					var err error
 					// *dst = *src
 					dstArray.Store(srcArray.Load())
 					// dst++
-					dstArray = dstArray.GetElementPtr([]uint32{1}).(*LocalValue)
+					dstArrayValue, err := dstArray.GetElementPtr([]uint32{1})
+					if err != nil {
+						return nil, nil, fr.errorAt(inst, err)
+					}
+					dstArray = dstArrayValue.(*LocalValue)
 					// src++
-					srcArray = srcArray.GetElementPtr([]uint32{1}).(*LocalValue)
+					srcArrayValue, err := srcArray.GetElementPtr([]uint32{1})
+					if err != nil {
+						return nil, nil, fr.errorAt(inst, err)
+					}
+					srcArray = srcArrayValue.(*LocalValue)
 				}
 			case callee.Name() == "runtime.stringToBytes":
 				// convert a string to a []byte
@@ -391,20 +441,35 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 				ret = llvm.ConstInsertValue(ret, retLen, []uint32{1}) // len
 				ret = llvm.ConstInsertValue(ret, retLen, []uint32{2}) // cap
 				fr.locals[inst] = &LocalValue{fr.Eval, ret}
+			case callee.Name() == "runtime.typeAssert":
+				actualTypeInt := fr.getLocal(inst.Operand(0)).(*LocalValue).Underlying
+				assertedType := fr.getLocal(inst.Operand(1)).(*LocalValue).Underlying
+				if actualTypeInt.IsAConstantExpr().IsNil() || actualTypeInt.Opcode() != llvm.PtrToInt {
+					return nil, nil, fr.errorAt(inst, errors.New("interp: expected typecode in runtime.typeAssert to be a ptrtoint"))
+				}
+				actualType := actualTypeInt.Operand(0)
+				if actualType.IsAConstant().IsNil() || assertedType.IsAConstant().IsNil() {
+					return nil, nil, fr.errorAt(inst, errors.New("interp: unimplemented: type assert with non-constant interface value"))
+				}
+				assertOk := uint64(0)
+				if llvm.ConstExtractValue(actualType.Initializer(), []uint32{0}) == assertedType {
+					assertOk = 1
+				}
+				fr.locals[inst] = &LocalValue{fr.Eval, llvm.ConstInt(fr.Mod.Context().Int1Type(), assertOk, false)}
 			case callee.Name() == "runtime.interfaceImplements":
 				typecode := fr.getLocal(inst.Operand(0)).(*LocalValue).Underlying
 				interfaceMethodSet := fr.getLocal(inst.Operand(1)).(*LocalValue).Underlying
 				if typecode.IsAConstantExpr().IsNil() || typecode.Opcode() != llvm.PtrToInt {
-					return nil, nil, fr.errorAt(inst, "interp: expected typecode to be a ptrtoint")
+					return nil, nil, fr.errorAt(inst, errors.New("interp: expected typecode to be a ptrtoint"))
 				}
 				typecode = typecode.Operand(0)
 				if interfaceMethodSet.IsAConstantExpr().IsNil() || interfaceMethodSet.Opcode() != llvm.GetElementPtr {
-					return nil, nil, fr.errorAt(inst, "interp: expected method set in runtime.interfaceImplements to be a constant gep")
+					return nil, nil, fr.errorAt(inst, errors.New("interp: expected method set in runtime.interfaceImplements to be a constant gep"))
 				}
 				interfaceMethodSet = interfaceMethodSet.Operand(0).Initializer()
 				methodSet := llvm.ConstExtractValue(typecode.Initializer(), []uint32{1})
 				if methodSet.IsAConstantExpr().IsNil() || methodSet.Opcode() != llvm.GetElementPtr {
-					return nil, nil, fr.errorAt(inst, "interp: expected method set to be a constant gep")
+					return nil, nil, fr.errorAt(inst, errors.New("interp: expected method set to be a constant gep"))
 				}
 				methodSet = methodSet.Operand(0).Initializer()
 
@@ -433,6 +498,8 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 				fr.locals[inst] = &LocalValue{fr.Eval, llvm.ConstInt(fr.Mod.Context().Int64Type(), 0, false)}
 			case callee.Name() == "llvm.dbg.value":
 				// do nothing
+			case strings.HasPrefix(callee.Name(), "llvm.lifetime."):
+				// do nothing
 			case callee.Name() == "runtime.trackPointer":
 				// do nothing
 			case strings.HasPrefix(callee.Name(), "runtime.print") || callee.Name() == "runtime._panic":
@@ -502,6 +569,11 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 					//     interpret anyway and hope for the best.
 					ret, err = fr.function(callee, params, indent+"    ")
 					if err != nil {
+						// Record this function call in the backtrace.
+						err.Traceback = append(err.Traceback, ErrorLine{
+							Pos:  getPosition(inst),
+							Inst: inst,
+						})
 						return nil, nil, err
 					}
 				}
@@ -520,7 +592,7 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 				fr.locals[inst] = fr.getValue(newValue)
 			} else {
 				if len(indices) != 1 {
-					return nil, nil, fr.errorAt(inst, "interp: cannot handle extractvalue with not exactly 1 index")
+					return nil, nil, fr.errorAt(inst, errors.New("interp: cannot handle extractvalue with not exactly 1 index"))
 				}
 				fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateExtractValue(agg.Underlying, int(indices[0]), inst.Name())}
 			}
@@ -533,10 +605,22 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 				fr.locals[inst] = &LocalValue{fr.Eval, newValue}
 			} else {
 				if len(indices) != 1 {
-					return nil, nil, fr.errorAt(inst, "interp: cannot handle insertvalue with not exactly 1 index")
+					return nil, nil, fr.errorAt(inst, errors.New("interp: cannot handle insertvalue with not exactly 1 index"))
 				}
 				fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateInsertValue(agg.Underlying, val.Value(), int(indices[0]), inst.Name())}
 			}
+		case !inst.IsASelectInst().IsNil():
+			// var result T
+			// if cond {
+			//   result = x
+			// } else {
+			//   result = y
+			// }
+			// return result
+			cond := fr.getLocal(inst.Operand(0)).(*LocalValue).Underlying
+			x := fr.getLocal(inst.Operand(1)).(*LocalValue).Underlying
+			y := fr.getLocal(inst.Operand(2)).(*LocalValue).Underlying
+			fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateSelect(cond, x, y, "")}
 
 		case !inst.IsAReturnInst().IsNil() && inst.OperandsCount() == 0:
 			return nil, nil, nil // ret void
@@ -546,17 +630,17 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 			// conditional branch (if/then/else)
 			cond := fr.getLocal(inst.Operand(0)).Value()
 			if cond.Type() != fr.Mod.Context().Int1Type() {
-				return nil, nil, fr.errorAt(inst, "expected an i1 in a branch instruction")
+				return nil, nil, fr.errorAt(inst, errors.New("expected an i1 in a branch instruction"))
 			}
 			thenBB := inst.Operand(1)
 			elseBB := inst.Operand(2)
 			if !cond.IsAInstruction().IsNil() {
-				return nil, nil, fr.errorAt(inst, "interp: branch on a non-constant")
+				return nil, nil, fr.errorAt(inst, errors.New("interp: branch on a non-constant"))
 			}
 			if !cond.IsAConstantExpr().IsNil() {
 				// This may happen when the instruction builder could not
 				// const-fold some instructions.
-				return nil, nil, fr.errorAt(inst, "interp: branch on a non-const-propagated constant expression")
+				return nil, nil, fr.errorAt(inst, errors.New("interp: branch on a non-const-propagated constant expression"))
 			}
 			switch cond {
 			case llvm.ConstInt(fr.Mod.Context().Int1Type(), 0, false): // false
@@ -564,7 +648,7 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 			case llvm.ConstInt(fr.Mod.Context().Int1Type(), 1, false): // true
 				return nil, []llvm.Value{elseBB}, nil // else
 			default:
-				return nil, nil, fr.errorAt(inst, "branch was not true or false")
+				return nil, nil, fr.errorAt(inst, errors.New("branch was not true or false"))
 			}
 		case !inst.IsABranchInst().IsNil() && inst.OperandsCount() == 1:
 			// unconditional branch (goto)

interp/interp.go

@@ -97,7 +97,7 @@ func Run(mod llvm.Module, debug bool) error {
 // function interprets the given function. The params are the function params
 // and the indent is the string indentation to use when dumping all interpreted
 // instructions.
-func (e *evalPackage) function(fn llvm.Value, params []Value, indent string) (Value, error) {
+func (e *evalPackage) function(fn llvm.Value, params []Value, indent string) (Value, *Error) {
 	fr := frame{
 		evalPackage: e,
 		fn:          fn,

interp/interp_test.go

@@ -14,6 +14,8 @@ func TestInterp(t *testing.T) {
 		"basic",
 		"slice-copy",
 		"consteval",
+		"map",
+		"interface",
 	} {
 		name := name // make tc local to this closure
 		t.Run(name, func(t *testing.T) {

interp/scan.go

@@ -1,6 +1,9 @@
 package interp
 
 import (
+	"errors"
+	"strings"
+
 	"tinygo.org/x/go-llvm"
 )
 
@@ -38,23 +41,28 @@ type sideEffectResult struct {
 // hasSideEffects scans this function and all descendants, recursively. It
 // returns whether this function has side effects and if it does, which globals
 // it mentions anywhere in this function or any called functions.
-func (e *evalPackage) hasSideEffects(fn llvm.Value) (*sideEffectResult, error) {
-	switch fn.Name() {
-	case "runtime.alloc":
+func (e *evalPackage) hasSideEffects(fn llvm.Value) (*sideEffectResult, *Error) {
+	name := fn.Name()
+	switch {
+	case name == "runtime.alloc":
 		// Cannot be scanned but can be interpreted.
 		return &sideEffectResult{severity: sideEffectNone}, nil
-	case "runtime.nanotime":
+	case name == "runtime.nanotime":
 		// Fixed value at compile time.
 		return &sideEffectResult{severity: sideEffectNone}, nil
-	case "runtime._panic":
+	case name == "runtime._panic":
 		return &sideEffectResult{severity: sideEffectLimited}, nil
-	case "runtime.interfaceImplements":
+	case name == "runtime.typeAssert":
 		return &sideEffectResult{severity: sideEffectNone}, nil
-	case "runtime.sliceCopy":
+	case name == "runtime.interfaceImplements":
 		return &sideEffectResult{severity: sideEffectNone}, nil
-	case "runtime.trackPointer":
+	case name == "runtime.sliceCopy":
 		return &sideEffectResult{severity: sideEffectNone}, nil
-	case "llvm.dbg.value":
+	case name == "runtime.trackPointer":
+		return &sideEffectResult{severity: sideEffectNone}, nil
+	case name == "llvm.dbg.value":
+		return &sideEffectResult{severity: sideEffectNone}, nil
+	case strings.HasPrefix(name, "llvm.lifetime."):
 		return &sideEffectResult{severity: sideEffectNone}, nil
 	}
 	if fn.IsDeclaration() {
@@ -92,7 +100,7 @@ func (e *evalPackage) hasSideEffects(fn llvm.Value) (*sideEffectResult, error) {
 			switch inst.InstructionOpcode() {
 			case llvm.IndirectBr, llvm.Invoke:
 				// Not emitted by the compiler.
-				return nil, e.errorAt(inst, "unknown instructions")
+				return nil, e.errorAt(inst, errors.New("unknown instructions"))
 			case llvm.Call:
 				child := inst.CalledValue()
 				if !child.IsAInlineAsm().IsNil() {
@@ -113,6 +121,12 @@ func (e *evalPackage) hasSideEffects(fn llvm.Value) (*sideEffectResult, error) {
 				if child.IsDeclaration() {
 					// External function call. Assume only limited side effects
 					// (no affected globals, etc.).
+					switch child.Name() {
+					case "runtime.typeAssert":
+						continue // implemented in interp
+					case "runtime.interfaceImplements":
+						continue // implemented in interp
+					}
 					if e.hasLocalSideEffects(dirtyLocals, inst) {
 						result.updateSeverity(sideEffectLimited)
 					}

interp/scan_test.go

@@ -23,6 +23,8 @@ var scanTestTable = []struct {
 	{"callFunctionPointer", sideEffectAll, []string{"functionPointer"}},
 	{"getDirtyPointer", sideEffectLimited, nil},
 	{"storeToPointer", sideEffectLimited, nil},
+	{"callTypeAssert", sideEffectNone, nil},
+	{"callInterfaceImplements", sideEffectNone, nil},
 }
 
 func TestScan(t *testing.T) {

interp/testdata/interface.ll

@@ -0,0 +1,28 @@
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64--linux"
+
+%runtime.typecodeID = type { %runtime.typecodeID*, i64 }
+%runtime.interfaceMethodInfo = type { i8*, i64 }
+%runtime.typeInInterface = type { %runtime.typecodeID*, %runtime.interfaceMethodInfo* }
+
+@main.v1 = global i1 0
+@"reflect/types.type:named:main.foo" = private constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:basic:int", i64 0 }
+@"reflect/types.type:basic:int" = external constant %runtime.typecodeID
+@"typeInInterface:reflect/types.type:named:main.foo" = private constant %runtime.typeInInterface { %runtime.typecodeID* @"reflect/types.type:named:main.foo", %runtime.interfaceMethodInfo* null }
+
+
+declare i1 @runtime.typeAssert(i64, %runtime.typecodeID*, i8*, i8*)
+
+define void @runtime.initAll() unnamed_addr {
+entry:
+  call void @main.init()
+  ret void
+}
+
+define internal void @main.init() unnamed_addr {
+entry:
+  ; Test type asserts.
+  %typecode = call i1 @runtime.typeAssert(i64 ptrtoint (%runtime.typeInInterface* @"typeInInterface:reflect/types.type:named:main.foo" to i64), %runtime.typecodeID* @"reflect/types.type:named:main.foo", i8* undef, i8* null)
+  store i1 %typecode, i1* @main.v1
+  ret void
+}

interp/testdata/interface.out.ll

@@ -0,0 +1,9 @@
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64--linux"
+
+@main.v1 = local_unnamed_addr global i1 true
+
+define void @runtime.initAll() unnamed_addr {
+entry:
+  ret void
+}

interp/testdata/map.ll

@@ -0,0 +1,76 @@
+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. This breaks the normal hashmapBinarySet
+  ; optimization, to test the fallback.
+  %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. This breaks the normal hashmapStringSet
+  ; optimization, to test the fallback.
+  %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
+}

interp/testdata/map.out.ll

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

interp/testdata/scan.ll

@@ -1,6 +1,11 @@
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64--linux"
 
+%runtime.typecodeID = type { %runtime.typecodeID*, i64 }
+
+declare i1 @runtime.typeAssert(i64, %runtime.typecodeID*, i8*, i8*)
+declare i1 @runtime.interfaceImplements(i64, i8**)
+
 define i64 @returnsConst() {
   ret i64 0
 }
@@ -59,3 +64,15 @@ define i64 @callFunctionPointer() {
   %result = call i64 %fp()
   ret i64 %result
 }
+
+define i1 @callTypeAssert() {
+  ; Note: parameters are not realistic.
+  %ok = call i1 @runtime.typeAssert(i64 0, %runtime.typecodeID* null, i8* undef, i8* null)
+  ret i1 %ok
+}
+
+define i1 @callInterfaceImplements() {
+  ; Note: parameters are not realistic.
+  %ok = call i1 @runtime.interfaceImplements(i64 0, i8** null)
+  ret i1 %ok
+}

interp/utils.go

@@ -24,7 +24,11 @@ func getStringBytes(strPtr Value, strLen llvm.Value) []byte {
 	}
 	buf := make([]byte, strLen.ZExtValue())
 	for i := range buf {
-		c := strPtr.GetElementPtr([]uint32{uint32(i)}).Load()
+		gep, err := strPtr.GetElementPtr([]uint32{uint32(i)})
+		if err != nil {
+			panic(err) // TODO
+		}
+		c := gep.Load()
 		buf[i] = byte(c.ZExtValue())
 	}
 	return buf

interp/values.go

@@ -3,6 +3,7 @@ package interp
 // This file provides a litte bit of abstraction around LLVM values.
 
 import (
+	"errors"
 	"strconv"
 
 	"tinygo.org/x/go-llvm"
@@ -11,13 +12,13 @@ import (
 // A Value is a LLVM value with some extra methods attached for easier
 // interpretation.
 type Value interface {
-	Value() llvm.Value            // returns a LLVM value
-	Type() llvm.Type              // equal to Value().Type()
-	IsConstant() bool             // returns true if this value is a constant value
-	Load() llvm.Value             // dereference a pointer
-	Store(llvm.Value)             // store to a pointer
-	GetElementPtr([]uint32) Value // returns an interior pointer
-	String() string               // string representation, for debugging
+	Value() llvm.Value                     // returns a LLVM value
+	Type() llvm.Type                       // equal to Value().Type()
+	IsConstant() bool                      // returns true if this value is a constant value
+	Load() llvm.Value                      // dereference a pointer
+	Store(llvm.Value)                      // store to a pointer
+	GetElementPtr([]uint32) (Value, error) // returns an interior pointer
+	String() string                        // string representation, for debugging
 }
 
 // A type that simply wraps a LLVM constant value.
@@ -97,21 +98,21 @@ func (v *LocalValue) Store(value llvm.Value) {
 }
 
 // GetElementPtr returns a GEP when the underlying value is of pointer type.
-func (v *LocalValue) GetElementPtr(indices []uint32) Value {
+func (v *LocalValue) GetElementPtr(indices []uint32) (Value, error) {
 	if !v.Underlying.IsAGlobalVariable().IsNil() {
 		int32Type := v.Underlying.Type().Context().Int32Type()
 		gep := llvm.ConstGEP(v.Underlying, getLLVMIndices(int32Type, indices))
-		return &LocalValue{v.Eval, gep}
+		return &LocalValue{v.Eval, gep}, nil
 	}
 	if !v.Underlying.IsAConstantExpr().IsNil() {
 		switch v.Underlying.Opcode() {
 		case llvm.GetElementPtr, llvm.IntToPtr, llvm.BitCast:
 			int32Type := v.Underlying.Type().Context().Int32Type()
 			llvmIndices := getLLVMIndices(int32Type, indices)
-			return &LocalValue{v.Eval, llvm.ConstGEP(v.Underlying, llvmIndices)}
+			return &LocalValue{v.Eval, llvm.ConstGEP(v.Underlying, llvmIndices)}, nil
 		}
 	}
-	panic("interp: unknown GEP")
+	return nil, errors.New("interp: unknown GEP")
 }
 
 // stripPointerCasts removes all const bitcasts from pointer values, if there
@@ -309,8 +310,8 @@ func (v *MapValue) Store(value llvm.Value) {
 
 // GetElementPtr panics: maps are of reference type so their (interior)
 // addresses cannot be calculated.
-func (v *MapValue) GetElementPtr(indices []uint32) Value {
-	panic("interp: GEP on a map")
+func (v *MapValue) GetElementPtr(indices []uint32) (Value, error) {
+	return nil, errors.New("interp: GEP on a map")
 }
 
 // PutString does a map assign operation, assuming that the map is of type
@@ -367,10 +368,12 @@ func (v *MapValue) PutBinary(keyPtr, valPtr *LocalValue) {
 		}
 	}
 
-	if keyPtr.Underlying.Opcode() == llvm.BitCast {
-		keyPtr = &LocalValue{v.Eval, keyPtr.Underlying.Operand(0)}
-	} else if keyPtr.Underlying.Opcode() == llvm.GetElementPtr {
-		keyPtr = &LocalValue{v.Eval, keyPtr.Underlying.Operand(0)}
+	if !keyPtr.Underlying.IsAConstantExpr().IsNil() {
+		if keyPtr.Underlying.Opcode() == llvm.BitCast {
+			keyPtr = &LocalValue{v.Eval, keyPtr.Underlying.Operand(0)}
+		} else if keyPtr.Underlying.Opcode() == llvm.GetElementPtr {
+			keyPtr = &LocalValue{v.Eval, keyPtr.Underlying.Operand(0)}
+		}
 	}
 	key := keyPtr.Load()
 	if v.KeyType.IsNil() {

ir/ir.go

@@ -27,14 +27,13 @@ type Program struct {
 // Function or method.
 type Function struct {
 	*ssa.Function
-	LLVMFn    llvm.Value
-	module    string     // go:wasm-module
-	linkName  string     // go:linkname, go:export, go:interrupt
-	exported  bool       // go:export
-	nobounds  bool       // go:nobounds
-	flag      bool       // used by dead code elimination
-	interrupt bool       // go:interrupt
-	inline    InlineType // go:inline
+	LLVMFn   llvm.Value
+	module   string     // go:wasm-module
+	linkName string     // go:linkname, go:export
+	exported bool       // go:export
+	nobounds bool       // go:nobounds
+	flag     bool       // used by dead code elimination
+	inline   InlineType // go:inline
 }
 
 // Interface type that is at some point used in a type assert (to check whether
@@ -64,23 +63,13 @@ const (
 )
 
 // Create and initialize a new *Program from a *ssa.Program.
-func NewProgram(lprogram *loader.Program, mainPath string) *Program {
+func NewProgram(lprogram *loader.Program) *Program {
 	program := lprogram.LoadSSA()
 	program.Build()
 
 	// Find the main package, which is a bit difficult when running a .go file
 	// directly.
-	mainPkg := program.ImportedPackage(mainPath)
-	if mainPkg == nil {
-		for _, pkgInfo := range program.AllPackages() {
-			if pkgInfo.Pkg.Name() == "main" {
-				if mainPkg != nil {
-					panic("more than one main package found")
-				}
-				mainPkg = pkgInfo
-			}
-		}
-	}
+	mainPkg := program.ImportedPackage(lprogram.MainPkg.PkgPath)
 	if mainPkg == nil {
 		panic("could not find main package")
 	}
@@ -88,21 +77,10 @@ func NewProgram(lprogram *loader.Program, mainPath string) *Program {
 	// Make a list of packages in import order.
 	packageList := []*ssa.Package{}
 	packageSet := map[string]struct{}{}
-	worklist := []string{"runtime", mainPath}
+	worklist := []string{"runtime", lprogram.MainPkg.PkgPath}
 	for len(worklist) != 0 {
 		pkgPath := worklist[0]
-		var pkg *ssa.Package
-		if pkgPath == mainPath {
-			pkg = mainPkg // necessary for compiling individual .go files
-		} else {
-			pkg = program.ImportedPackage(pkgPath)
-		}
-		if pkg == nil {
-			// Non-SSA package (e.g. cgo).
-			packageSet[pkgPath] = struct{}{}
-			worklist = worklist[1:]
-			continue
-		}
+		pkg := program.ImportedPackage(pkgPath)
 		if _, ok := packageSet[pkgPath]; ok {
 			// Package already in the final package list.
 			worklist = worklist[1:]
@@ -243,18 +221,6 @@ func (f *Function) parsePragmas() {
 				f.inline = InlineHint
 			case "//go:noinline":
 				f.inline = InlineNone
-			case "//go:interrupt":
-				if len(parts) != 2 {
-					continue
-				}
-				name := parts[1]
-				if strings.HasSuffix(name, "_vect") {
-					// AVR vector naming
-					name = "__vector_" + name[:len(name)-5]
-				}
-				f.linkName = name
-				f.exported = true
-				f.interrupt = true
 			case "//go:linkname":
 				if len(parts) != 3 || parts[1] != f.Name() {
 					continue
@@ -288,14 +254,6 @@ func (f *Function) IsExported() bool {
 	return f.exported || f.CName() != ""
 }
 
-// Return true for functions annotated with //go:interrupt. The function name is
-// already customized in LinkName() to hook up in the interrupt vector.
-//
-// On some platforms (like AVR), interrupts need a special compiler flag.
-func (f *Function) IsInterrupt() bool {
-	return f.interrupt
-}
-
 // Return the inline directive of this function.
 func (f *Function) Inline() InlineType {
 	return f.inline

ir/passes.go

@@ -1,6 +1,7 @@
 package ir
 
 import (
+	"errors"
 	"go/types"
 
 	"golang.org/x/tools/go/ssa"
@@ -58,7 +59,7 @@ func signature(sig *types.Signature) string {
 
 // Simple pass that removes dead code. This pass makes later analysis passes
 // more useful.
-func (p *Program) SimpleDCE() {
+func (p *Program) SimpleDCE() error {
 	// Unmark all functions.
 	for _, f := range p.Functions {
 		f.flag = false
@@ -66,13 +67,21 @@ func (p *Program) SimpleDCE() {
 
 	// Initial set of live functions. Include main.main, *.init and runtime.*
 	// functions.
-	main := p.mainPkg.Members["main"].(*ssa.Function)
+	main, ok := p.mainPkg.Members["main"].(*ssa.Function)
+	if !ok {
+		if p.mainPkg.Members["main"] == nil {
+			return errors.New("function main is undeclared in the main package")
+		} else {
+			return errors.New("cannot declare main - must be func")
+		}
+	}
 	runtimePkg := p.Program.ImportedPackage("runtime")
 	mathPkg := p.Program.ImportedPackage("math")
+	taskPkg := p.Program.ImportedPackage("internal/task")
 	p.GetFunction(main).flag = true
 	worklist := []*ssa.Function{main}
 	for _, f := range p.Functions {
-		if f.exported || f.Synthetic == "package initializer" || f.Pkg == runtimePkg || (f.Pkg == mathPkg && f.Pkg != nil) {
+		if f.exported || f.Synthetic == "package initializer" || f.Pkg == runtimePkg || f.Pkg == taskPkg || (f.Pkg == mathPkg && f.Pkg != nil) {
 			if f.flag {
 				continue
 			}
@@ -135,4 +144,6 @@ func (p *Program) SimpleDCE() {
 		}
 	}
 	p.Functions = livefunctions
+
+	return nil
 }

loader/errors.go

@@ -1,10 +1,5 @@
 package loader
 
-import (
-	"go/token"
-	"strings"
-)
-
 // Errors contains a list of parser errors or a list of typechecker errors for
 // the given package.
 type Errors struct {
@@ -15,25 +10,3 @@ type Errors struct {
 func (e Errors) Error() string {
 	return "could not compile: " + e.Errs[0].Error()
 }
-
-// ImportCycleErrors is returned when encountering an import cycle. The list of
-// packages is a list from the root package to the leaf package that imports one
-// of the packages in the list.
-type ImportCycleError struct {
-	Packages        []string
-	ImportPositions []token.Position
-}
-
-func (e *ImportCycleError) Error() string {
-	var msg strings.Builder
-	msg.WriteString("import cycle:\n\t")
-	msg.WriteString(strings.Join(e.Packages, "\n\t"))
-	msg.WriteString("\n at ")
-	for i, pos := range e.ImportPositions {
-		if i > 0 {
-			msg.WriteString(", ")
-		}
-		msg.WriteString(pos.String())
-	}
-	return msg.String()
-}

loader/goroot.go

@@ -0,0 +1,225 @@
+package loader
+
+// This file constructs a new temporary GOROOT directory by merging both the
+// standard Go GOROOT and the GOROOT from TinyGo using symlinks.
+
+import (
+	"crypto/sha512"
+	"encoding/hex"
+	"errors"
+	"io/ioutil"
+	"math/rand"
+	"os"
+	"os/exec"
+	"path"
+	"path/filepath"
+	"runtime"
+	"strconv"
+
+	"github.com/tinygo-org/tinygo/compileopts"
+	"github.com/tinygo-org/tinygo/goenv"
+)
+
+// GetCachedGoroot creates a new GOROOT by merging both the standard GOROOT and
+// the GOROOT from TinyGo using lots of symbolic links.
+func GetCachedGoroot(config *compileopts.Config) (string, error) {
+	goroot := goenv.Get("GOROOT")
+	if goroot == "" {
+		return "", errors.New("could not determine GOROOT")
+	}
+	tinygoroot := goenv.Get("TINYGOROOT")
+	if tinygoroot == "" {
+		return "", errors.New("could not determine TINYGOROOT")
+	}
+
+	needsSyscallPackage := false
+	for _, tag := range config.BuildTags() {
+		if tag == "baremetal" || tag == "darwin" {
+			needsSyscallPackage = true
+		}
+	}
+
+	// Determine the location of the cached GOROOT.
+	version, err := goenv.GorootVersionString(goroot)
+	if err != nil {
+		return "", err
+	}
+	gorootsHash := sha512.Sum512_256([]byte(goroot + "\x00" + tinygoroot))
+	gorootsHashHex := hex.EncodeToString(gorootsHash[:])
+	cachedgoroot := filepath.Join(goenv.Get("GOCACHE"), "goroot-"+version+"-"+gorootsHashHex)
+	if needsSyscallPackage {
+		cachedgoroot += "-syscall"
+	}
+
+	if _, err := os.Stat(cachedgoroot); err == nil {
+		return cachedgoroot, nil
+	}
+	tmpgoroot := cachedgoroot + ".tmp" + strconv.Itoa(rand.Int())
+	err = os.MkdirAll(tmpgoroot, 0777)
+	if err != nil {
+		return "", err
+	}
+
+	// Remove the temporary directory if it wasn't moved to the right place
+	// (for example, when there was an error).
+	defer os.RemoveAll(tmpgoroot)
+
+	for _, name := range []string{"bin", "lib", "pkg"} {
+		err = symlink(filepath.Join(goroot, name), filepath.Join(tmpgoroot, name))
+		if err != nil {
+			return "", err
+		}
+	}
+	err = mergeDirectory(goroot, tinygoroot, tmpgoroot, "", pathsToOverride(needsSyscallPackage))
+	if err != nil {
+		return "", err
+	}
+	err = os.Rename(tmpgoroot, cachedgoroot)
+	if err != nil {
+		if os.IsExist(err) {
+			// Another invocation of TinyGo also seems to have created a GOROOT.
+			// Use that one instead. Our new GOROOT will be automatically
+			// deleted by the defer above.
+			return cachedgoroot, nil
+		}
+		return "", err
+	}
+	return cachedgoroot, nil
+}
+
+// mergeDirectory merges two roots recursively. The tmpgoroot is the directory
+// that will be created by this call by either symlinking the directory from
+// goroot or tinygoroot, or by creating the directory and merging the contents.
+func mergeDirectory(goroot, tinygoroot, tmpgoroot, importPath string, overrides map[string]bool) error {
+	if mergeSubdirs, ok := overrides[importPath+"/"]; ok {
+		if !mergeSubdirs {
+			// This directory and all subdirectories should come from the TinyGo
+			// root, so simply make a symlink.
+			newname := filepath.Join(tmpgoroot, "src", importPath)
+			oldname := filepath.Join(tinygoroot, "src", importPath)
+			return symlink(oldname, newname)
+		}
+
+		// Merge subdirectories. Start by making the directory to merge.
+		err := os.Mkdir(filepath.Join(tmpgoroot, "src", importPath), 0777)
+		if err != nil {
+			return err
+		}
+
+		// Symlink all files from TinyGo, and symlink directories from TinyGo
+		// that need to be overridden.
+		tinygoEntries, err := ioutil.ReadDir(filepath.Join(tinygoroot, "src", importPath))
+		if err != nil {
+			return err
+		}
+		for _, e := range tinygoEntries {
+			if e.IsDir() {
+				// A directory, so merge this thing.
+				err := mergeDirectory(goroot, tinygoroot, tmpgoroot, path.Join(importPath, e.Name()), overrides)
+				if err != nil {
+					return err
+				}
+			} else {
+				// A file, so symlink this.
+				newname := filepath.Join(tmpgoroot, "src", importPath, e.Name())
+				oldname := filepath.Join(tinygoroot, "src", importPath, e.Name())
+				err := symlink(oldname, newname)
+				if err != nil {
+					return err
+				}
+			}
+		}
+
+		// Symlink all directories from $GOROOT that are not part of the TinyGo
+		// overrides.
+		gorootEntries, err := ioutil.ReadDir(filepath.Join(goroot, "src", importPath))
+		if err != nil {
+			return err
+		}
+		for _, e := range gorootEntries {
+			if !e.IsDir() {
+				// Don't merge in files from Go. Otherwise we'd end up with a
+				// weird syscall package with files from both roots.
+				continue
+			}
+			if _, ok := overrides[path.Join(importPath, e.Name())+"/"]; ok {
+				// Already included above, so don't bother trying to create this
+				// symlink.
+				continue
+			}
+			newname := filepath.Join(tmpgoroot, "src", importPath, e.Name())
+			oldname := filepath.Join(goroot, "src", importPath, e.Name())
+			err := symlink(oldname, newname)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// The boolean indicates whether to merge the subdirs. True means merge, false
+// means use the TinyGo version.
+func pathsToOverride(needsSyscallPackage bool) map[string]bool {
+	paths := map[string]bool{
+		"/":                     true,
+		"device/":               false,
+		"examples/":             false,
+		"internal/":             true,
+		"internal/reflectlite/": false,
+		"internal/task/":        false,
+		"machine/":              false,
+		"os/":                   true,
+		"reflect/":              false,
+		"runtime/":              false,
+		"sync/":                 true,
+		"testing/":              false,
+	}
+	if needsSyscallPackage {
+		paths["syscall/"] = true // include syscall/js
+	}
+	return paths
+}
+
+// symlink creates a symlink or something similar. On Unix-like systems, it
+// always creates a symlink. On Windows, it tries to create a symlink and if
+// that fails, creates a hardlink or directory junction instead.
+//
+// Note that while Windows 10 does support symlinks and allows them to be
+// created using os.Symlink, it requires developer mode to be enabled.
+// Therefore provide a fallback for when symlinking is not possible.
+// Unfortunately this fallback only works when TinyGo is installed on the same
+// filesystem as the TinyGo cache and the Go installation (which is usually the
+// C drive).
+func symlink(oldname, newname string) error {
+	symlinkErr := os.Symlink(oldname, newname)
+	if runtime.GOOS == "windows" && symlinkErr != nil {
+		// Fallback for when developer mode is disabled.
+		// Note that we return the symlink error even if something else fails
+		// later on. This is because symlinks are the easiest to support
+		// (they're also used on Linux and MacOS) and enabling them is easy:
+		// just enable developer mode.
+		st, err := os.Stat(oldname)
+		if err != nil {
+			return symlinkErr
+		}
+		if st.IsDir() {
+			// Make a directory junction. There may be a way to do this
+			// programmatically, but it involves a lot of magic. Use the mklink
+			// command built into cmd instead (mklink is a builtin, not an
+			// external command).
+			err := exec.Command("cmd", "/k", "mklink", "/J", newname, oldname).Run()
+			if err != nil {
+				return symlinkErr
+			}
+		} else {
+			// Make a hard link.
+			err := os.Link(oldname, newname)
+			if err != nil {
+				return symlinkErr
+			}
+		}
+		return nil // success
+	}
+	return symlinkErr
+}

loader/loader.go

@@ -3,6 +3,7 @@ package loader
 import (
 	"bytes"
 	"errors"
+	"fmt"
 	"go/ast"
 	"go/build"
 	"go/parser"
@@ -15,15 +16,16 @@ import (
 	"text/template"
 
 	"github.com/tinygo-org/tinygo/cgo"
+	"github.com/tinygo-org/tinygo/goenv"
+	"golang.org/x/tools/go/packages"
 )
 
 // Program holds all packages and some metadata about the program as a whole.
 type Program struct {
-	mainPkg      string
 	Build        *build.Context
-	OverlayBuild *build.Context
-	OverlayPath  func(path string) string
+	Tests        bool
 	Packages     map[string]*Package
+	MainPkg      *Package
 	sorted       []*Package
 	fset         *token.FileSet
 	TypeChecker  types.Config
@@ -36,86 +38,114 @@ type Program struct {
 // Package holds a loaded package, its imports, and its parsed files.
 type Package struct {
 	*Program
-	*build.Package
-	Imports   map[string]*Package
-	Importing bool
-	Files     []*ast.File
-	Pkg       *types.Package
+	*packages.Package
+	Files []*ast.File
+	Pkg   *types.Package
 	types.Info
 }
 
-// Import loads the given package relative to srcDir (for the vendor directory).
-// It only loads the current package without recursion.
-func (p *Program) Import(path, srcDir string) (*Package, error) {
+// Load loads the given package with all dependencies (including the runtime
+// package). Call .Parse() afterwards to parse all Go files (including CGo
+// processing, if necessary).
+func (p *Program) Load(importPath string) error {
 	if p.Packages == nil {
 		p.Packages = make(map[string]*Package)
 	}
 
-	// Load this package.
-	ctx := p.Build
-	if newPath := p.OverlayPath(path); newPath != "" {
-		ctx = p.OverlayBuild
-		path = newPath
-	}
-	buildPkg, err := ctx.Import(path, srcDir, build.ImportComment)
+	err := p.loadPackage(importPath)
 	if err != nil {
-		return nil, err
+		return err
 	}
-	if existingPkg, ok := p.Packages[buildPkg.ImportPath]; ok {
-		// Already imported, or at least started the import.
-		return existingPkg, nil
+	p.MainPkg = p.sorted[len(p.sorted)-1]
+	if _, ok := p.Packages["runtime"]; !ok {
+		// The runtime package wasn't loaded. Although `go list -deps` seems to
+		// return the full dependency list, there is no way to get those
+		// packages from the go/packages package. Therefore load the runtime
+		// manually and add it to the list of to-be-compiled packages
+		// (duplicates are already filtered).
+		return p.loadPackage("runtime")
 	}
-	p.sorted = nil // invalidate the sorted order of packages
-	pkg := p.newPackage(buildPkg)
-	p.Packages[buildPkg.ImportPath] = pkg
-
-	if p.mainPkg == "" {
-		p.mainPkg = buildPkg.ImportPath
-	}
-
-	return pkg, nil
+	return nil
 }
 
-// ImportFile loads and parses the import statements in the given path and
-// creates a pseudo-package out of it.
-func (p *Program) ImportFile(path string) (*Package, error) {
-	if p.Packages == nil {
-		p.Packages = make(map[string]*Package)
+func (p *Program) loadPackage(importPath string) error {
+	cgoEnabled := "0"
+	if p.Build.CgoEnabled {
+		cgoEnabled = "1"
 	}
-	if _, ok := p.Packages[path]; ok {
-		// unlikely
-		return nil, errors.New("loader: cannot import file that is already imported as package: " + path)
-	}
-
-	file, err := p.parseFile(path, parser.ImportsOnly)
+	pkgs, err := packages.Load(&packages.Config{
+		Mode:       packages.NeedName | packages.NeedFiles | packages.NeedImports | packages.NeedDeps,
+		Env:        append(os.Environ(), "GOROOT="+p.Build.GOROOT, "GOOS="+p.Build.GOOS, "GOARCH="+p.Build.GOARCH, "CGO_ENABLED="+cgoEnabled),
+		BuildFlags: []string{"-tags", strings.Join(p.Build.BuildTags, " ")},
+		Tests:      p.Tests,
+	}, importPath)
 	if err != nil {
-		return nil, err
+		return err
 	}
-	buildPkg := &build.Package{
-		Dir:        filepath.Dir(path),
-		ImportPath: path,
-		GoFiles:    []string{filepath.Base(path)},
+	var pkg *packages.Package
+	if p.Tests {
+		// We need the second package. Quoting from the docs:
+		// > For example, when using the go command, loading "fmt" with Tests=true
+		// > returns four packages, with IDs "fmt" (the standard package),
+		// > "fmt [fmt.test]" (the package as compiled for the test),
+		// > "fmt_test" (the test functions from source files in package fmt_test),
+		// > and "fmt.test" (the test binary).
+		pkg = pkgs[1]
+	} else {
+		if len(pkgs) != 1 {
+			return fmt.Errorf("expected exactly one package while importing %s, got %d", importPath, len(pkgs))
+		}
+		pkg = pkgs[0]
 	}
-	for _, importSpec := range file.Imports {
-		buildPkg.Imports = append(buildPkg.Imports, importSpec.Path.Value[1:len(importSpec.Path.Value)-1])
-	}
-	p.sorted = nil // invalidate the sorted order of packages
-	pkg := p.newPackage(buildPkg)
-	p.Packages[buildPkg.ImportPath] = pkg
+	var importError *Errors
+	var addPackages func(pkg *packages.Package)
+	addPackages = func(pkg *packages.Package) {
+		if _, ok := p.Packages[pkg.PkgPath]; ok {
+			return
+		}
+		pkg2 := p.newPackage(pkg)
+		p.Packages[pkg.PkgPath] = pkg2
+		if len(pkg.Errors) != 0 {
+			if importError != nil {
+				// There was another error reported already. Do not report
+				// errors from multiple packages at once.
+				return
+			}
+			importError = &Errors{
+				Pkg: pkg2,
+			}
+			for _, err := range pkg.Errors {
+				importError.Errs = append(importError.Errs, err)
+			}
+			return
+		}
 
-	if p.mainPkg == "" {
-		p.mainPkg = buildPkg.ImportPath
-	}
+		// Get the list of imports (sorted alphabetically).
+		names := make([]string, 0, len(pkg.Imports))
+		for name := range pkg.Imports {
+			names = append(names, name)
+		}
+		sort.Strings(names)
 
-	return pkg, nil
+		// Add all the imports.
+		for _, name := range names {
+			addPackages(pkg.Imports[name])
+		}
+
+		p.sorted = append(p.sorted, pkg2)
+	}
+	addPackages(pkg)
+	if importError != nil {
+		return importError
+	}
+	return nil
 }
 
 // newPackage instantiates a new *Package object with initialized members.
-func (p *Program) newPackage(pkg *build.Package) *Package {
+func (p *Program) newPackage(pkg *packages.Package) *Package {
 	return &Package{
 		Program: p,
 		Package: pkg,
-		Imports: make(map[string]*Package, len(pkg.Imports)),
 		Info: types.Info{
 			Types:      make(map[ast.Expr]types.TypeAndValue),
 			Defs:       make(map[*ast.Ident]types.Object),
@@ -130,87 +160,25 @@ func (p *Program) newPackage(pkg *build.Package) *Package {
 // Sorted returns a list of all packages, sorted in a way that no packages come
 // before the packages they depend upon.
 func (p *Program) Sorted() []*Package {
-	if p.sorted == nil {
-		p.sort()
-	}
 	return p.sorted
 }
 
-func (p *Program) sort() {
-	p.sorted = nil
-	packageList := make([]*Package, 0, len(p.Packages))
-	packageSet := make(map[string]struct{}, len(p.Packages))
-	worklist := make([]string, 0, len(p.Packages))
-	for path := range p.Packages {
-		worklist = append(worklist, path)
-	}
-	sort.Strings(worklist)
-	for len(worklist) != 0 {
-		pkgPath := worklist[0]
-		pkg := p.Packages[pkgPath]
-
-		if _, ok := packageSet[pkgPath]; ok {
-			// Package already in the final package list.
-			worklist = worklist[1:]
-			continue
-		}
-
-		unsatisfiedImports := make([]string, 0)
-		for _, pkg := range pkg.Imports {
-			if _, ok := packageSet[pkg.ImportPath]; ok {
-				continue
-			}
-			unsatisfiedImports = append(unsatisfiedImports, pkg.ImportPath)
-		}
-		sort.Strings(unsatisfiedImports)
-		if len(unsatisfiedImports) == 0 {
-			// All dependencies of this package are satisfied, so add this
-			// package to the list.
-			packageList = append(packageList, pkg)
-			packageSet[pkgPath] = struct{}{}
-			worklist = worklist[1:]
-		} else {
-			// Prepend all dependencies to the worklist and reconsider this
-			// package (by not removing it from the worklist). At that point, it
-			// must be possible to add it to packageList.
-			worklist = append(unsatisfiedImports, worklist...)
-		}
-	}
-
-	p.sorted = packageList
-}
-
-// Parse recursively imports all packages, parses them, and typechecks them.
+// Parse parses all packages and typechecks them.
 //
 // The returned error may be an Errors error, which contains a list of errors.
 //
 // Idempotent.
-func (p *Program) Parse(compileTestBinary bool) error {
-	includeTests := compileTestBinary
-
-	// Load all imports
-	for _, pkg := range p.Sorted() {
-		err := pkg.importRecursively(includeTests)
-		if err != nil {
-			if err, ok := err.(*ImportCycleError); ok {
-				if pkg.ImportPath != err.Packages[0] {
-					err.Packages = append([]string{pkg.ImportPath}, err.Packages...)
-				}
-			}
-			return err
-		}
-	}
-
+func (p *Program) Parse() error {
 	// Parse all packages.
 	for _, pkg := range p.Sorted() {
-		err := pkg.Parse(includeTests)
+		err := pkg.Parse()
 		if err != nil {
 			return err
 		}
 	}
 
-	if compileTestBinary {
-		err := p.SwapTestMain()
+	if p.Tests {
+		err := p.swapTestMain()
 		if err != nil {
 			return err
 		}
@@ -227,7 +195,7 @@ func (p *Program) Parse(compileTestBinary bool) error {
 	return nil
 }
 
-func (p *Program) SwapTestMain() error {
+func (p *Program) swapTestMain() error {
 	var tests []string
 
 	isTestFunc := func(f *ast.FuncDecl) bool {
@@ -237,8 +205,7 @@ func (p *Program) SwapTestMain() error {
 		}
 		return false
 	}
-	mainPkg := p.Packages[p.mainPkg]
-	for _, f := range mainPkg.Files {
+	for _, f := range p.MainPkg.Files {
 		for i, d := range f.Decls {
 			switch v := d.(type) {
 			case *ast.FuncDecl:
@@ -289,7 +256,7 @@ func main () {
 	if err != nil {
 		return err
 	}
-	path := filepath.Join(p.mainPkg, "$testmain.go")
+	path := filepath.Join(p.MainPkg.Dir, "$testmain.go")
 
 	if p.fset == nil {
 		p.fset = token.NewFileSet()
@@ -299,7 +266,7 @@ func main () {
 	if err != nil {
 		return err
 	}
-	mainPkg.Files = append(mainPkg.Files, newMain)
+	p.MainPkg.Files = append(p.MainPkg.Files, newMain)
 
 	return nil
 }
@@ -315,34 +282,41 @@ func (p *Program) parseFile(path string, mode parser.Mode) (*ast.File, error) {
 		return nil, err
 	}
 	defer rd.Close()
-	relpath := path
-	if filepath.IsAbs(path) {
-		rp, err := filepath.Rel(p.Dir, path)
-		if err == nil {
-			relpath = rp
+	diagnosticPath := path
+	if strings.HasPrefix(path, p.Build.GOROOT+string(filepath.Separator)) {
+		// If this file is part of the synthetic GOROOT, try to infer the
+		// original path.
+		relpath := path[len(p.Build.GOROOT)+1:]
+		tinygoPath := filepath.Join(p.TINYGOROOT, relpath)
+		if _, err := os.Stat(tinygoPath); err == nil {
+			diagnosticPath = tinygoPath
+		}
+		realgorootPath := filepath.Join(goenv.Get("GOROOT"), relpath)
+		if _, err := os.Stat(realgorootPath); err == nil {
+			diagnosticPath = realgorootPath
 		}
 	}
-	return parser.ParseFile(p.fset, relpath, rd, mode)
+	return parser.ParseFile(p.fset, diagnosticPath, rd, mode)
 }
 
 // Parse parses and typechecks this package.
 //
 // Idempotent.
-func (p *Package) Parse(includeTests bool) error {
+func (p *Package) Parse() error {
 	if len(p.Files) != 0 {
 		return nil
 	}
 
 	// Load the AST.
 	// TODO: do this in parallel.
-	if p.ImportPath == "unsafe" {
+	if p.PkgPath == "unsafe" {
 		// Special case for the unsafe package. Don't even bother loading
 		// the files.
 		p.Pkg = types.Unsafe
 		return nil
 	}
 
-	files, err := p.parseFiles(includeTests)
+	files, err := p.parseFiles()
 	if err != nil {
 		return err
 	}
@@ -369,7 +343,7 @@ func (p *Package) Check() error {
 	// Do typechecking of the package.
 	checker.Importer = p
 
-	typesPkg, err := checker.Check(p.ImportPath, p.fset, p.Files, &p.Info)
+	typesPkg, err := checker.Check(p.PkgPath, p.fset, p.Files, &p.Info)
 	if err != nil {
 		if err, ok := err.(Errors); ok {
 			return err
@@ -381,22 +355,14 @@ func (p *Package) Check() error {
 }
 
 // parseFiles parses the loaded list of files and returns this list.
-func (p *Package) parseFiles(includeTests bool) ([]*ast.File, error) {
+func (p *Package) parseFiles() ([]*ast.File, error) {
 	// TODO: do this concurrently.
 	var files []*ast.File
 	var fileErrs []error
 
-	var gofiles []string
-	if includeTests {
-		gofiles = make([]string, 0, len(p.GoFiles)+len(p.TestGoFiles))
-		gofiles = append(gofiles, p.GoFiles...)
-		gofiles = append(gofiles, p.TestGoFiles...)
-	} else {
-		gofiles = p.GoFiles
-	}
-
-	for _, file := range gofiles {
-		f, err := p.parseFile(filepath.Join(p.Package.Dir, file), parser.ParseComments)
+	var cgoFiles []*ast.File
+	for _, file := range p.GoFiles {
+		f, err := p.parseFile(file, parser.ParseComments)
 		if err != nil {
 			fileErrs = append(fileErrs, err)
 			continue
@@ -405,21 +371,17 @@ func (p *Package) parseFiles(includeTests bool) ([]*ast.File, error) {
 			fileErrs = append(fileErrs, err)
 			continue
 		}
+		for _, importSpec := range f.Imports {
+			if importSpec.Path.Value == `"C"` {
+				cgoFiles = append(cgoFiles, f)
+			}
+		}
 		files = append(files, f)
 	}
-	for _, file := range p.CgoFiles {
-		path := filepath.Join(p.Package.Dir, file)
-		f, err := p.parseFile(path, parser.ParseComments)
-		if err != nil {
-			fileErrs = append(fileErrs, err)
-			continue
-		}
-		files = append(files, f)
-	}
-	if len(p.CgoFiles) != 0 {
-		cflags := append(p.CFlags, "-I"+p.Package.Dir)
+	if len(cgoFiles) != 0 {
+		cflags := append(p.CFlags, "-I"+filepath.Dir(p.GoFiles[0]))
 		if p.ClangHeaders != "" {
-			cflags = append(cflags, "-I"+p.ClangHeaders)
+			cflags = append(cflags, "-Xclang", "-internal-isystem", "-Xclang", p.ClangHeaders)
 		}
 		generated, errs := cgo.Process(files, p.Program.Dir, p.fset, cflags)
 		if errs != nil {
@@ -441,51 +403,8 @@ func (p *Package) Import(to string) (*types.Package, error) {
 		return types.Unsafe, nil
 	}
 	if _, ok := p.Imports[to]; ok {
-		return p.Imports[to].Pkg, nil
+		return p.Packages[p.Imports[to].PkgPath].Pkg, nil
 	} else {
 		return nil, errors.New("package not imported: " + to)
 	}
 }
-
-// importRecursively calls Program.Import() on all imported packages, and calls
-// importRecursively() on the imported packages as well.
-//
-// Idempotent.
-func (p *Package) importRecursively(includeTests bool) error {
-	p.Importing = true
-
-	imports := p.Package.Imports
-	if includeTests {
-		imports = append(imports, p.Package.TestImports...)
-	}
-
-	for _, to := range imports {
-		if to == "C" {
-			// Do CGo processing in a later stage.
-			continue
-		}
-		if _, ok := p.Imports[to]; ok {
-			continue
-		}
-		importedPkg, err := p.Program.Import(to, p.Package.Dir)
-		if err != nil {
-			if err, ok := err.(*ImportCycleError); ok {
-				err.Packages = append([]string{p.ImportPath}, err.Packages...)
-			}
-			return err
-		}
-		if importedPkg.Importing {
-			return &ImportCycleError{[]string{p.ImportPath, importedPkg.ImportPath}, p.ImportPos[to]}
-		}
-		err = importedPkg.importRecursively(false)
-		if err != nil {
-			if err, ok := err.(*ImportCycleError); ok {
-				err.Packages = append([]string{p.ImportPath}, err.Packages...)
-			}
-			return err
-		}
-		p.Imports[to] = importedPkg
-	}
-	p.Importing = false
-	return nil
-}

main.go

@@ -1,6 +1,8 @@
 package main
 
 import (
+	"bytes"
+	"encoding/json"
 	"errors"
 	"flag"
 	"fmt"
@@ -22,8 +24,9 @@ import (
 	"github.com/tinygo-org/tinygo/goenv"
 	"github.com/tinygo-org/tinygo/interp"
 	"github.com/tinygo-org/tinygo/loader"
+	"tinygo.org/x/go-llvm"
 
-	serial "go.bug.st/serial.v1"
+	"go.bug.st/serial"
 )
 
 // commandError is an error type to wrap os/exec.Command errors. This provides
@@ -49,6 +52,17 @@ func moveFile(src, dst string) error {
 	}
 	// Failed to move, probably a different filesystem.
 	// Do a copy + remove.
+	err = copyFile(src, dst)
+	if err != nil {
+		return err
+	}
+	return os.Remove(src)
+}
+
+// copyFile copies the given file from src to dst. It copies first to a .tmp
+// file which is then moved over a possibly already existing file at the
+// destination.
+func copyFile(src, dst string) error {
 	inf, err := os.Open(src)
 	if err != nil {
 		return err
@@ -111,6 +125,7 @@ func Build(pkgName, outpath string, options *compileopts.Options) error {
 
 // Test runs the tests in the given package.
 func Test(pkgName string, options *compileopts.Options) error {
+	options.TestConfig.CompileTestBinary = true
 	config, err := builder.NewConfig(options)
 	if err != nil {
 		return err
@@ -122,7 +137,6 @@ func Test(pkgName string, options *compileopts.Options) error {
 	// For details: https://github.com/golang/go/issues/21360
 	config.Target.BuildTags = append(config.Target.BuildTags, "test")
 
-	options.TestConfig.CompileTestBinary = true
 	return builder.Build(pkgName, ".elf", config, func(tmppath string) error {
 		cmd := exec.Command(tmppath)
 		cmd.Stdout = os.Stdout
@@ -183,6 +197,14 @@ func Flash(pkgName, port string, options *compileopts.Options) error {
 	return builder.Build(pkgName, fileExt, config, func(tmppath string) error {
 		// do we need port reset to put MCU into bootloader mode?
 		if config.Target.PortReset == "true" {
+			if port == "" {
+				var err error
+				port, err = getDefaultPort()
+				if err != nil {
+					return err
+				}
+			}
+
 			err := touchSerialPortAt1200bps(port)
 			if err != nil {
 				return &commandError{"failed to reset port", tmppath, err}
@@ -198,10 +220,30 @@ func Flash(pkgName, port string, options *compileopts.Options) error {
 			flashCmd := config.Target.FlashCommand
 			fileToken := "{" + fileExt[1:] + "}"
 			flashCmd = strings.Replace(flashCmd, fileToken, tmppath, -1)
+
+			if port == "" && strings.Contains(flashCmd, "{port}") {
+				var err error
+				port, err = getDefaultPort()
+				if err != nil {
+					return err
+				}
+			}
+
 			flashCmd = strings.Replace(flashCmd, "{port}", port, -1)
 
 			// Execute the command.
-			cmd := exec.Command("/bin/sh", "-c", 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 = exec.Command(command[0], command[1:]...)
+			default:
+				cmd = exec.Command("/bin/sh", "-c", flashCmd)
+			}
+
 			cmd.Stdout = os.Stdout
 			cmd.Stderr = os.Stderr
 			cmd.Dir = goenv.Get("TINYGOROOT")
@@ -254,7 +296,7 @@ func Flash(pkgName, port string, options *compileopts.Options) error {
 //
 // Note: this command is expected to execute just before exiting, as it
 // modifies global state.
-func FlashGDB(pkgName, port string, ocdOutput bool, options *compileopts.Options) error {
+func FlashGDB(pkgName string, ocdOutput bool, options *compileopts.Options) error {
 	config, err := builder.NewConfig(options)
 	if err != nil {
 		return err
@@ -268,16 +310,23 @@ func FlashGDB(pkgName, port string, ocdOutput bool, options *compileopts.Options
 		gdbInterface, openocdInterface := config.Programmer()
 		switch gdbInterface {
 		case "msd", "command", "":
-			if gdbInterface == "" {
-				gdbInterface = "command"
-			}
-			if openocdInterface != "" && config.Target.OpenOCDTarget != "" {
+			if len(config.Target.Emulator) != 0 {
+				// Assume QEMU as an emulator.
+				if config.Target.Emulator[0] == "mgba" {
+					gdbInterface = "mgba"
+				} else {
+					gdbInterface = "qemu"
+				}
+			} else if openocdInterface != "" && config.Target.OpenOCDTarget != "" {
 				gdbInterface = "openocd"
+			} else if config.Target.JLinkDevice != "" {
+				gdbInterface = "jlink"
 			}
 		}
 
 		// Run the GDB server, if necessary.
 		var gdbCommands []string
+		var daemon *exec.Cmd
 		switch gdbInterface {
 		case "native":
 			// Run GDB directly.
@@ -289,7 +338,7 @@ func FlashGDB(pkgName, port string, ocdOutput bool, options *compileopts.Options
 			if err != nil {
 				return err
 			}
-			daemon := exec.Command("openocd", args...)
+			daemon = exec.Command("openocd", args...)
 			if ocdOutput {
 				// Make it clear which output is from the daemon.
 				w := &ColorWriter{
@@ -300,20 +349,58 @@ func FlashGDB(pkgName, port string, ocdOutput bool, options *compileopts.Options
 				daemon.Stdout = w
 				daemon.Stderr = w
 			}
+		case "jlink":
+			gdbCommands = append(gdbCommands, "target remote :2331", "load", "monitor reset halt")
+
+			// We need a separate debugging daemon for on-chip debugging.
+			daemon = exec.Command("JLinkGDBServer", "-device", config.Target.JLinkDevice)
+			if ocdOutput {
+				// Make it clear which output is from the daemon.
+				w := &ColorWriter{
+					Out:    os.Stderr,
+					Prefix: "jlink: ",
+					Color:  TermColorYellow,
+				}
+				daemon.Stdout = w
+				daemon.Stderr = w
+			}
+		case "qemu":
+			gdbCommands = append(gdbCommands, "target remote :1234")
+
+			// Run in an emulator.
+			args := append(config.Target.Emulator[1:], tmppath, "-s", "-S")
+			daemon = exec.Command(config.Target.Emulator[0], args...)
+			daemon.Stdout = os.Stdout
+			daemon.Stderr = os.Stderr
+		case "mgba":
+			gdbCommands = append(gdbCommands, "target remote :2345")
+
+			// Run in an emulator.
+			args := append(config.Target.Emulator[1:], tmppath, "-g")
+			daemon = exec.Command(config.Target.Emulator[0], args...)
+			daemon.Stdout = os.Stdout
+			daemon.Stderr = os.Stderr
+		case "msd":
+			return errors.New("gdb is not supported for drag-and-drop programmable devices")
+		default:
+			return fmt.Errorf("gdb is not supported with interface %#v", gdbInterface)
+		}
+
+		if daemon != nil {
 			// Make sure the daemon doesn't receive Ctrl-C that is intended for
 			// GDB (to break the currently executing program).
 			setCommandAsDaemon(daemon)
+
 			// Start now, and kill it on exit.
-			daemon.Start()
+			err = daemon.Start()
+			if err != nil {
+				return &commandError{"failed to run", daemon.Path, err}
+			}
 			defer func() {
 				daemon.Process.Signal(os.Interrupt)
 				// Maybe we should send a .Kill() after x seconds?
 				daemon.Wait()
 			}()
-		case "msd":
-			return errors.New("gdb is not supported for drag-and-drop programmable devices")
-		default:
-			return fmt.Errorf("gdb is not supported with interface %#v", gdbInterface)
 		}
 
 		// Ignore Ctrl-C, it must be passed on to GDB.
@@ -387,23 +474,38 @@ func Run(pkgName string, options *compileopts.Options) error {
 	})
 }
 
-func touchSerialPortAt1200bps(port string) error {
-	// Open port
-	p, err := serial.Open(port, &serial.Mode{BaudRate: 1200})
-	if err != nil {
-		return fmt.Errorf("opening port: %s", err)
-	}
-	defer p.Close()
+func touchSerialPortAt1200bps(port string) (err error) {
+	retryCount := 3
+	for i := 0; i < retryCount; i++ {
+		// Open port
+		p, e := serial.Open(port, &serial.Mode{BaudRate: 1200})
+		if e != nil {
+			time.Sleep(1 * time.Second)
+			err = e
+			continue
+		}
+		defer p.Close()
 
-	p.SetDTR(false)
-	return nil
+		p.SetDTR(false)
+		return nil
+	}
+	return fmt.Errorf("opening port: %s", err)
 }
 
 func flashUF2UsingMSD(volume, tmppath string) error {
 	// find standard UF2 info path
-	infoPath := "/media/*/" + volume + "/INFO_UF2.TXT"
-	if runtime.GOOS == "darwin" {
+	var infoPath string
+	switch runtime.GOOS {
+	case "linux", "freebsd":
+		infoPath = "/media/*/" + volume + "/INFO_UF2.TXT"
+	case "darwin":
 		infoPath = "/Volumes/" + volume + "/INFO_UF2.TXT"
+	case "windows":
+		path, err := windowsFindUSBDrive(volume)
+		if err != nil {
+			return err
+		}
+		infoPath = path + "/INFO_UF2.TXT"
 	}
 
 	d, err := filepath.Glob(infoPath)
@@ -419,9 +521,18 @@ func flashUF2UsingMSD(volume, tmppath string) error {
 
 func flashHexUsingMSD(volume, tmppath string) error {
 	// find expected volume path
-	destPath := "/media/*/" + volume
-	if runtime.GOOS == "darwin" {
+	var destPath string
+	switch runtime.GOOS {
+	case "linux", "freebsd":
+		destPath = "/media/*/" + volume
+	case "darwin":
 		destPath = "/Volumes/" + volume
+	case "windows":
+		path, err := windowsFindUSBDrive(volume)
+		if err != nil {
+			return err
+		}
+		destPath = path + "/"
 	}
 
 	d, err := filepath.Glob(destPath)
@@ -435,6 +546,29 @@ func flashHexUsingMSD(volume, tmppath string) error {
 	return moveFile(tmppath, d[0]+"/flash.hex")
 }
 
+func windowsFindUSBDrive(volume string) (string, error) {
+	cmd := exec.Command("wmic",
+		"PATH", "Win32_LogicalDisk", "WHERE", "VolumeName = '"+volume+"'",
+		"get", "DeviceID,VolumeName,FileSystem,DriveType")
+
+	var out bytes.Buffer
+	cmd.Stdout = &out
+	err := cmd.Run()
+	if err != nil {
+		return "", err
+	}
+
+	for _, line := range strings.Split(out.String(), "\n") {
+		words := strings.Fields(line)
+		if len(words) >= 3 {
+			if words[1] == "2" && words[2] == "FAT" {
+				return words[0], nil
+			}
+		}
+	}
+	return "", errors.New("unable to locate a USB device to be flashed")
+}
+
 // parseSize converts a human-readable size (with k/m/g suffix) into a plain
 // number.
 func parseSize(s string) (int64, error) {
@@ -459,6 +593,85 @@ func parseSize(s string) (int64, error) {
 	return n, err
 }
 
+// getDefaultPort returns the default serial port depending on the operating system.
+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":
+		portPath = "/dev/cuaU*"
+	case "windows":
+		cmd := exec.Command("wmic",
+			"PATH", "Win32_SerialPort", "WHERE", "Caption LIKE 'USB Serial%'", "GET", "DeviceID")
+
+		var out bytes.Buffer
+		cmd.Stdout = &out
+		err := cmd.Run()
+		if err != nil {
+			return "", err
+		}
+
+		if out.String() == "No Instance(s) Available." {
+			return "", errors.New("no serial ports available")
+		}
+
+		for _, line := range strings.Split(out.String(), "\n") {
+			words := strings.Fields(line)
+			if len(words) == 1 {
+				if strings.Contains(words[0], "COM") {
+					return words[0], nil
+				}
+			}
+		}
+		return "", errors.New("unable to locate a serial port")
+	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
+	}
+	if d == nil {
+		return "", errors.New("unable to locate a serial port")
+	}
+
+	return d[0], nil
+}
+
+// runGoList runs the `go list` command but using the configuration used for
+// TinyGo.
+func runGoList(config *compileopts.Config, flagJSON, flagDeps bool, pkgs []string) error {
+	goroot, err := loader.GetCachedGoroot(config)
+	if err != nil {
+		return err
+	}
+	args := []string{"list"}
+	if flagJSON {
+		args = append(args, "-json")
+	}
+	if flagDeps {
+		args = append(args, "-deps")
+	}
+	if len(config.BuildTags()) != 0 {
+		args = append(args, "-tags", strings.Join(config.BuildTags(), " "))
+	}
+	args = append(args, pkgs...)
+	cgoEnabled := "0"
+	if config.CgoEnabled() {
+		cgoEnabled = "1"
+	}
+	cmd := exec.Command("go", args...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	cmd.Env = append(os.Environ(), "GOROOT="+goroot, "GOOS="+config.GOOS(), "GOARCH="+config.GOARCH(), "CGO_ENABLED="+cgoEnabled)
+	cmd.Run()
+	return nil
+}
+
 func usage() {
 	fmt.Fprintln(os.Stderr, "TinyGo is a Go compiler for small places.")
 	fmt.Fprintln(os.Stderr, "version:", version)
@@ -470,52 +683,71 @@ func usage() {
 	fmt.Fprintln(os.Stderr, "  flash: compile and flash to the device")
 	fmt.Fprintln(os.Stderr, "  gdb:   run/flash and immediately enter GDB")
 	fmt.Fprintln(os.Stderr, "  env:   list environment variables used during build")
+	fmt.Fprintln(os.Stderr, "  list:  run go list using the TinyGo root")
 	fmt.Fprintln(os.Stderr, "  clean: empty cache directory ("+goenv.Get("GOCACHE")+")")
 	fmt.Fprintln(os.Stderr, "  help:  print this help text")
 	fmt.Fprintln(os.Stderr, "\nflags:")
 	flag.PrintDefaults()
 }
 
+// printCompilerError prints compiler errors using the provided logger function
+// (similar to fmt.Println).
+//
+// There is one exception: interp errors may print to stderr unconditionally due
+// to limitations in the LLVM bindings.
+func printCompilerError(logln func(...interface{}), err error) {
+	switch err := err.(type) {
+	case types.Error, scanner.Error:
+		logln(err)
+	case *interp.Error:
+		logln("#", err.ImportPath)
+		logln(err.Error())
+		if !err.Inst.IsNil() {
+			err.Inst.Dump()
+			logln()
+		}
+		if len(err.Traceback) > 0 {
+			logln("\ntraceback:")
+			for _, line := range err.Traceback {
+				logln(line.Pos.String() + ":")
+				line.Inst.Dump()
+				logln()
+			}
+		}
+	case loader.Errors:
+		logln("#", err.Pkg.PkgPath)
+		for _, err := range err.Errs {
+			logln(err)
+		}
+	case *builder.MultiError:
+		for _, err := range err.Errs {
+			logln(err)
+		}
+	default:
+		logln("error:", err)
+	}
+}
+
 func handleCompilerError(err error) {
 	if err != nil {
-		switch err := err.(type) {
-		case *interp.Unsupported:
-			// hit an unknown/unsupported instruction
-			fmt.Fprintln(os.Stderr, "#", err.ImportPath)
-			msg := "unsupported instruction during init evaluation:"
-			if err.Pos.String() != "" {
-				msg = err.Pos.String() + " " + msg
-			}
-			fmt.Fprintln(os.Stderr, msg)
-			err.Inst.Dump()
-			fmt.Fprintln(os.Stderr)
-		case types.Error, scanner.Error:
-			fmt.Fprintln(os.Stderr, err)
-		case interp.Error:
-			fmt.Fprintln(os.Stderr, "#", err.ImportPath)
-			for _, err := range err.Errs {
-				fmt.Fprintln(os.Stderr, err)
-			}
-		case loader.Errors:
-			fmt.Fprintln(os.Stderr, "#", err.Pkg.ImportPath)
-			for _, err := range err.Errs {
-				fmt.Fprintln(os.Stderr, err)
-			}
-		case *builder.MultiError:
-			for _, err := range err.Errs {
-				fmt.Fprintln(os.Stderr, err)
-			}
-		default:
-			fmt.Fprintln(os.Stderr, "error:", err)
-		}
+		printCompilerError(func(args ...interface{}) {
+			fmt.Fprintln(os.Stderr, args...)
+		}, err)
 		os.Exit(1)
 	}
 }
 
 func main() {
+	if len(os.Args) < 2 {
+		fmt.Fprintln(os.Stderr, "No command-line arguments supplied.")
+		usage()
+		os.Exit(1)
+	}
+	command := os.Args[1]
+
 	outpath := flag.String("o", "", "output filename")
 	opt := flag.String("opt", "z", "optimization level: 0, 1, 2, s, z")
-	gc := flag.String("gc", "", "garbage collector to use (none, leaking, conservative)")
+	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 (coroutines, tasks)")
 	printIR := flag.Bool("printir", false, "print LLVM IR")
@@ -526,19 +758,32 @@ func main() {
 	printSize := flag.String("size", "", "print sizes (none, short, full)")
 	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", "/dev/ttyACM0", "flash port")
+	port := flag.String("port", "", "flash port")
 	programmer := flag.String("programmer", "", "which hardware programmer to use")
 	cFlags := flag.String("cflags", "", "additional cflags for compiler")
 	ldFlags := flag.String("ldflags", "", "additional ldflags for linker")
 	wasmAbi := flag.String("wasm-abi", "js", "WebAssembly ABI conventions: js (no i64 params) or generic")
 	heapSize := flag.String("heap-size", "1M", "default heap size in bytes (only supported by WebAssembly)")
 
-	if len(os.Args) < 2 {
-		fmt.Fprintln(os.Stderr, "No command-line arguments supplied.")
-		usage()
-		os.Exit(1)
+	var flagJSON, flagDeps *bool
+	if command == "list" || command == "env" {
+		flagJSON = flag.Bool("json", false, "print data in JSON format")
+	}
+	if command == "list" {
+		flagDeps = flag.Bool("deps", false, "")
+	}
+
+	// Early command processing, before commands are interpreted by the Go flag
+	// library.
+	switch command {
+	case "clang", "ld.lld", "wasm-ld":
+		err := builder.RunTool(command, os.Args[2:]...)
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(1)
+		}
+		os.Exit(0)
 	}
-	command := os.Args[1]
 
 	flag.CommandLine.Parse(os.Args[2:])
 	options := &compileopts.Options{
@@ -600,7 +845,7 @@ func main() {
 		}
 		err := Build(pkgName, *outpath, options)
 		handleCompilerError(err)
-	case "build-builtins":
+	case "build-library":
 		// Note: this command is only meant to be used while making a release!
 		if *outpath == "" {
 			fmt.Fprintln(os.Stderr, "No output filename supplied (-o).")
@@ -610,10 +855,24 @@ func main() {
 		if *target == "" {
 			fmt.Fprintln(os.Stderr, "No target (-target).")
 		}
-		err := builder.CompileBuiltins(*target, func(path string) error {
-			return moveFile(path, *outpath)
-		})
+		if flag.NArg() != 1 {
+			fmt.Fprintf(os.Stderr, "Build-library only accepts exactly one library name as argument, %d given\n", flag.NArg())
+			usage()
+			os.Exit(1)
+		}
+		var lib *builder.Library
+		switch name := flag.Arg(0); name {
+		case "compiler-rt":
+			lib = &builder.CompilerRT
+		case "picolibc":
+			lib = &builder.Picolibc
+		default:
+			fmt.Fprintf(os.Stderr, "Unknown library: %s\n", name)
+			os.Exit(1)
+		}
+		path, err := lib.Load(*target)
 		handleCompilerError(err)
+		copyFile(path, *outpath)
 	case "flash", "gdb":
 		if *outpath != "" {
 			fmt.Fprintln(os.Stderr, "Output cannot be specified with the flash command.")
@@ -629,7 +888,7 @@ func main() {
 				usage()
 				os.Exit(1)
 			}
-			err := FlashGDB(flag.Arg(0), *port, *ocdOutput, options)
+			err := FlashGDB(flag.Arg(0), *ocdOutput, options)
 			handleCompilerError(err)
 		}
 	case "run":
@@ -676,6 +935,18 @@ func main() {
 		fmt.Printf("build tags:        %s\n", strings.Join(config.BuildTags(), " "))
 		fmt.Printf("garbage collector: %s\n", config.GC())
 		fmt.Printf("scheduler:         %s\n", config.Scheduler())
+	case "list":
+		config, err := builder.NewConfig(options)
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			usage()
+			os.Exit(1)
+		}
+		err = runGoList(config, *flagJSON, *flagDeps, flag.Args())
+		if err != nil {
+			fmt.Fprintln(os.Stderr, "failed to run `go list`:", err)
+			os.Exit(1)
+		}
 	case "clean":
 		// remove cache directory
 		err := os.RemoveAll(goenv.Get("GOCACHE"))
@@ -687,20 +958,36 @@ func main() {
 		usage()
 	case "version":
 		goversion := "<unknown>"
-		if s, err := builder.GorootVersionString(goenv.Get("GOROOT")); err == nil {
+		if s, err := goenv.GorootVersionString(goenv.Get("GOROOT")); err == nil {
 			goversion = s
 		}
-		fmt.Printf("tinygo version %s %s/%s (using go version %s)\n", version, runtime.GOOS, runtime.GOARCH, goversion)
+		fmt.Printf("tinygo version %s %s/%s (using go version %s and LLVM version %s)\n", version, runtime.GOOS, runtime.GOARCH, goversion, llvm.Version)
 	case "env":
-		if flag.NArg() == 0 {
-			// Show all environment variables.
-			for _, key := range goenv.Keys {
-				fmt.Printf("%s=%#v\n", key, goenv.Get(key))
+		if *flagJSON {
+			keys := goenv.Keys
+			if flag.NArg() != 0 {
+				// Show only one (or a few) environment variables.
+				keys = flag.Args()
 			}
+			// Show environment variables in JSON format.
+			env := make(map[string]string)
+			for _, key := range keys {
+				env[key] = goenv.Get(key)
+			}
+			encoder := json.NewEncoder(os.Stdout)
+			encoder.SetIndent("", "\t")
+			encoder.Encode(env)
 		} else {
-			// Show only one (or a few) environment variables.
-			for i := 0; i < flag.NArg(); i++ {
-				fmt.Println(goenv.Get(flag.Arg(i)))
+			if flag.NArg() == 0 {
+				// Show all environment variables.
+				for _, key := range goenv.Keys {
+					fmt.Printf("%s=%#v\n", key, goenv.Get(key))
+				}
+			} else {
+				// Show only one (or a few) environment variables.
+				for i := 0; i < flag.NArg(); i++ {
+					fmt.Println(goenv.Get(flag.Arg(i)))
+				}
 			}
 		}
 	default:

main_test.go

@@ -6,16 +6,21 @@ package main
 import (
 	"bufio"
 	"bytes"
+	"fmt"
 	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"runtime"
 	"sort"
+	"strings"
+	"sync"
 	"testing"
+	"time"
 
+	"github.com/tinygo-org/tinygo/builder"
 	"github.com/tinygo-org/tinygo/compileopts"
-	"github.com/tinygo-org/tinygo/loader"
+	"github.com/tinygo-org/tinygo/goenv"
 )
 
 const TESTDATA = "testdata"
@@ -50,9 +55,17 @@ func TestCompiler(t *testing.T) {
 	}
 
 	t.Run("EmulatedCortexM3", func(t *testing.T) {
-		runPlatTests("qemu", matches, 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", matches, t)
+		})
+	}
+
 	if runtime.GOOS == "linux" {
 		t.Run("ARMLinux", func(t *testing.T) {
 			runPlatTests("arm--linux-gnueabihf", matches, t)
@@ -60,48 +73,56 @@ func TestCompiler(t *testing.T) {
 		t.Run("ARM64Linux", func(t *testing.T) {
 			runPlatTests("aarch64--linux-gnu", matches, t)
 		})
-		t.Run("WebAssembly", func(t *testing.T) {
-			runPlatTests("wasm", 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)
+			})
+		}
 	}
 }
 
 func runPlatTests(target string, matches []string, t *testing.T) {
+	t.Parallel()
+
 	for _, path := range matches {
-		switch {
-		case target == "wasm":
-			// testdata/gc.go is known not to work on WebAssembly
-			if path == filepath.Join("testdata", "gc.go") {
-				continue
-			}
-		case target == "":
-			// run all tests on host
-		case target == "qemu":
-			// all tests are supported
-		default:
-			// cross-compilation of cgo is not yet supported
-			if path == filepath.Join("testdata", "cgo")+string(filepath.Separator) {
-				continue
-			}
-		}
+		path := path // redefine to avoid race condition
 
 		t.Run(filepath.Base(path), func(t *testing.T) {
+			t.Parallel()
+
 			runTest(path, target, t)
 		})
 	}
 }
 
+// Due to some problems with LLD, we cannot run links in parallel, or in parallel with compiles.
+// Therefore, we put a lock around builds and run everything else in parallel.
+var buildLock sync.Mutex
+
+// runBuild is a thread-safe wrapper around Build.
+func runBuild(src, out string, opts *compileopts.Options) error {
+	buildLock.Lock()
+	defer buildLock.Unlock()
+
+	return Build(src, out, opts)
+}
+
 func runTest(path, target string, t *testing.T) {
 	// Get the expected output for this test.
 	txtpath := path[:len(path)-3] + ".txt"
 	if path[len(path)-1] == os.PathSeparator {
 		txtpath = path + "out.txt"
 	}
-	f, err := os.Open(txtpath)
-	if err != nil {
-		t.Fatal("could not open expected output file:", err)
-	}
-	expected, err := ioutil.ReadAll(f)
+	expected, err := ioutil.ReadFile(txtpath)
 	if err != nil {
 		t.Fatal("could not read expected output file:", err)
 	}
@@ -130,21 +151,17 @@ func runTest(path, target string, t *testing.T) {
 		WasmAbi:    "js",
 	}
 	binary := filepath.Join(tmpdir, "test")
-	err = Build("./"+path, binary, config)
+	err = runBuild("./"+path, binary, config)
 	if err != nil {
-		if errLoader, ok := err.(loader.Errors); ok {
-			for _, err := range errLoader.Errs {
-				t.Log("failed to build:", err)
-			}
-		} else {
-			t.Log("failed to build:", err)
-		}
+		printCompilerError(t.Log, err)
 		t.Fail()
 		return
 	}
 
 	// Run the test.
+	runComplete := make(chan struct{})
 	var cmd *exec.Cmd
+	ranTooLong := false
 	if target == "" {
 		cmd = exec.Command(binary)
 	} else {
@@ -160,13 +177,35 @@ func runTest(path, target string, t *testing.T) {
 	}
 	stdout := &bytes.Buffer{}
 	cmd.Stdout = stdout
-	if target != "" {
-		cmd.Stderr = os.Stderr
+	cmd.Stderr = os.Stderr
+	err = cmd.Start()
+	if err != nil {
+		t.Fatal("failed to start:", err)
 	}
-	err = cmd.Run()
+	go func() {
+		// Terminate the process if it runs too long.
+		timer := time.NewTimer(10 * time.Second)
+		select {
+		case <-runComplete:
+			timer.Stop()
+		case <-timer.C:
+			ranTooLong = true
+			if runtime.GOOS == "windows" {
+				cmd.Process.Signal(os.Kill) // Windows doesn't support SIGINT.
+			} else {
+				cmd.Process.Signal(os.Interrupt)
+			}
+		}
+	}()
+	err = cmd.Wait()
 	if _, ok := err.(*exec.ExitError); ok && target != "" {
 		err = nil // workaround for QEMU
 	}
+	close(runComplete)
+
+	if ranTooLong {
+		stdout.WriteString("--- test ran too long, terminating...\n")
+	}
 
 	// putchar() prints CRLF, convert it to LF.
 	actual := bytes.Replace(stdout.Bytes(), []byte{'\r', '\n'}, []byte{'\n'}, -1)
@@ -194,3 +233,24 @@ func runTest(path, target string, t *testing.T) {
 		t.Fail()
 	}
 }
+
+// This TestMain is necessary because TinyGo may also be invoked to run certain
+// LLVM tools in a separate process. Not capturing these invocations would lead
+// to recursive tests.
+func TestMain(m *testing.M) {
+	if len(os.Args) >= 2 {
+		switch os.Args[1] {
+		case "clang", "ld.lld", "wasm-ld":
+			// Invoke a specific tool.
+			err := builder.RunTool(os.Args[1], os.Args[2:]...)
+			if err != nil {
+				fmt.Fprintln(os.Stderr, err)
+				os.Exit(1)
+			}
+			os.Exit(0)
+		}
+	}
+
+	// Run normal tests.
+	os.Exit(m.Run())
+}

src/device/arm/arm.go

@@ -35,6 +35,8 @@ import (
 	"unsafe"
 )
 
+var errCycleCountTooLarge = errors.New("requested cycle count is too large, overflows 24 bit counter")
+
 // Run the given assembly code. The code will be marked as having side effects,
 // as it doesn't produce output and thus would normally be eliminated by the
 // optimizer.
@@ -50,11 +52,10 @@ func Asm(asm string)
 //             "value":  1
 //             "result": &dest,
 //         })
-func AsmFull(asm string, regs map[string]interface{})
-
-// ReadRegister returns the contents of the specified register. The register
-// must be a processor register, reachable with the "mov" instruction.
-func ReadRegister(name string) uintptr
+//
+// You can use {} in the asm string (which expands to a register) to set the
+// return value.
+func AsmFull(asm string, regs map[string]interface{}) uintptr
 
 // Run the following system call (SVCall) with 0 arguments.
 func SVCall0(num uintptr) uintptr
@@ -190,22 +191,21 @@ func SetPriority(irq uint32, priority uint32) {
 	NVIC.IPR[regnum].Set((uint32(NVIC.IPR[regnum].Get()) &^ mask) | priority)
 }
 
-// DisableInterrupts disables all interrupts, and returns the old state.
-//
-// TODO: it doesn't actually return the old state, meaning that it cannot be
-// nested.
+// DisableInterrupts disables all interrupts, and returns the old interrupt
+// state.
 func DisableInterrupts() uintptr {
-	Asm("cpsid if")
-	return 0
+	return AsmFull(`
+		mrs {}, PRIMASK
+		cpsid if
+	`, nil)
 }
 
 // EnableInterrupts enables all interrupts again. The value passed in must be
 // the mask returned by DisableInterrupts.
-//
-// TODO: it doesn't actually use the old state, meaning that it cannot be
-// nested.
 func EnableInterrupts(mask uintptr) {
-	Asm("cpsie if")
+	AsmFull("msr PRIMASK, {mask}", map[string]interface{}{
+		"mask": mask,
+	})
 }
 
 // SystemReset performs a hard system reset.
@@ -232,7 +232,7 @@ func SetupSystemTimer(cyclecount uint32) error {
 	}
 	if cyclecount&SYST_RVR_RELOAD_Msk != cyclecount {
 		// The cycle refresh register is only 24 bits wide.  The user-specified value will overflow.
-		return errors.New("requested cycle count is too large, overflows 24 bit counter")
+		return errCycleCountTooLarge
 	}
 
 	// set refresh count