Adding extra files for testing multiline, globbing, etc.

.circleci/config.yml

@@ -17,15 +17,18 @@ commands:
             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 --no-install-recommends \
+            sudo apt-get install \
                 llvm-<<parameters.llvm>>-dev \
                 clang-<<parameters.llvm>> \
                 libclang-<<parameters.llvm>>-dev \
                 lld-<<parameters.llvm>> \
+                gcc-arm-linux-gnueabihf \
+                gcc-aarch64-linux-gnu \
                 qemu-system-arm \
                 qemu-user \
                 gcc-avr \
                 avr-libc
+            sudo apt-get install --no-install-recommends libc6-dev-i386 lib32gcc-8-dev
   install-node:
     steps:
       - run:
@@ -114,10 +117,7 @@ commands:
           key: wasi-libc-sysroot-systemclang-v3
           paths:
             - lib/wasi-libc/sysroot
-      - run:
-          name: "Test TinyGo"
-          command: go test -v -timeout=20m -tags=llvm<<parameters.llvm>> ./builder ./cgo ./compileopts ./compiler ./interp ./transform .
-          no_output_timeout: 20m
+      - run: go test -v -tags=llvm<<parameters.llvm>> ./cgo ./compileopts ./compiler ./interp ./transform .
       - run: make gen-device -j4
       - run: make smoketest XTENSA=0
       - run: make tinygo-test
@@ -136,12 +136,16 @@ commands:
           name: "Install apt dependencies"
           command: |
             sudo apt-get update
-            sudo apt-get install --no-install-recommends \
-                libgnutls30 libssl1.0.2 \
+            sudo apt-get install \
+                gcc-arm-linux-gnueabihf \
+                libc6-dev-armel-cross \
+                gcc-aarch64-linux-gnu \
+                libc6-dev-arm64-cross \
                 qemu-system-arm \
                 qemu-user \
                 gcc-avr \
                 avr-libc
+            sudo apt-get install --no-install-recommends libc6-dev-i386 lib32gcc-6-dev
       - install-node
       - install-wasmtime
       - install-xtensa-toolchain:
@@ -180,7 +184,6 @@ commands:
       - run:
           name: "Test TinyGo"
           command: make ASSERT=1 test
-          no_output_timeout: 20m
           environment:
             # Note: -p=2 limits parallelism to two jobs at a time, which is
             # necessary to keep memory consumption down and avoid OOM (for a
@@ -201,12 +204,16 @@ commands:
           name: "Install apt dependencies"
           command: |
             sudo apt-get update
-            sudo apt-get install --no-install-recommends \
-                libgnutls30 libssl1.0.2 \
+            sudo apt-get install \
+                gcc-arm-linux-gnueabihf \
+                libc6-dev-armel-cross \
+                gcc-aarch64-linux-gnu \
+                libc6-dev-arm64-cross \
                 qemu-system-arm \
                 qemu-user \
                 gcc-avr \
                 avr-libc
+            sudo apt-get install --no-install-recommends libc6-dev-i386 lib32gcc-6-dev
       - install-node
       - install-wasmtime
       - install-xtensa-toolchain:
@@ -244,7 +251,6 @@ commands:
       - run:
           name: "Test TinyGo"
           command: make test
-          no_output_timeout: 20m
       - run:
           name: "Install fpm"
           command: |
@@ -280,8 +286,8 @@ commands:
       - run:
           name: "Install dependencies"
           command: |
-            curl https://dl.google.com/go/go1.17.darwin-amd64.tar.gz -o go1.17.darwin-amd64.tar.gz
-            sudo tar -C /usr/local -xzf go1.17.darwin-amd64.tar.gz
+            curl https://dl.google.com/go/go1.16.darwin-amd64.tar.gz -o go1.16.darwin-amd64.tar.gz
+            sudo tar -C /usr/local -xzf go1.16.darwin-amd64.tar.gz
             ln -s /usr/local/go/bin/go /usr/local/bin/go
             HOMEBREW_NO_AUTO_UPDATE=1 brew install qemu
       - install-xtensa-toolchain:
@@ -337,7 +343,6 @@ commands:
       - run:
           name: "Test TinyGo"
           command: make test
-          no_output_timeout: 20m
       - run:
           name: "Build TinyGo release"
           command: |
@@ -360,6 +365,18 @@ commands:
             - /go/pkg/mod
 
 jobs:
+  test-llvm10-go113:
+    docker:
+      - image: circleci/golang:1.13-buster
+    steps:
+      - test-linux:
+          llvm: "10"
+  test-llvm10-go114:
+    docker:
+      - image: circleci/golang:1.14-buster
+    steps:
+      - test-linux:
+          llvm: "10"
   test-llvm11-go115:
     docker:
       - image: circleci/golang:1.15-buster
@@ -374,12 +391,12 @@ jobs:
           llvm: "11"
   assert-test-linux:
     docker:
-      - image: circleci/golang:1.17-stretch
+      - image: circleci/golang:1.14-stretch
     steps:
       - assert-test-linux
   build-linux:
     docker:
-      - image: circleci/golang:1.17-stretch
+      - image: circleci/golang:1.14-stretch
     steps:
       - build-linux
   build-macos:
@@ -393,6 +410,8 @@ jobs:
 workflows:
   test-all:
     jobs:
+      - test-llvm10-go113
+      - test-llvm10-go114
       - test-llvm11-go115
       - test-llvm11-go116
       - build-linux

.dockerignore

@@ -1,3 +0,0 @@
-build/
-llvm-*/
-

.github/workflows/build-tinygo-dev-docker.yml

@@ -1,7 +1,7 @@
 name: CI for tinygo-dev docker container
 on:
   push:
-    branches: [ dev, fix-docker-llvm-build ]
+    branches: [ dev ]
 
 jobs:
   push_to_registry:

.github/workflows/windows.yml

@@ -1,85 +0,0 @@
-name: Windows
-
-on: push
-
-jobs:
-  build-windows:
-    runs-on: windows-2016
-    steps:
-      - name: Install Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: '1.17'
-      - name: Install QEMU
-        shell: bash
-        run: |
-          choco install qemu --version=2020.06.12
-          echo "C:\Program Files\QEMU" >> $GITHUB_PATH
-      - name: Checkout
-        uses: actions/checkout@v2
-        with:
-          submodules: true
-      - name: Cache LLVM source
-        uses: actions/cache@v2
-        id: cache-llvm-source
-        with:
-          key: llvm-source-11-windows-v1
-          path: |
-            llvm-project/clang/lib/Headers
-            llvm-project/clang/include
-            llvm-project/lld/include
-            llvm-project/llvm/include
-      - name: Download LLVM source
-        if: steps.cache-llvm-source.outputs.cache-hit != 'true'
-        run: make llvm-source
-      - name: Cache LLVM build
-        uses: actions/cache@v2
-        id: cache-llvm-build
-        with:
-          key: llvm-build-11-windows-v2
-          path: llvm-build
-      - name: Build LLVM
-        if: steps.cache-llvm-build.outputs.cache-hit != 'true'
-        shell: bash
-        run: |
-          # fetch LLVM source
-          rm -rf llvm-project
-          make llvm-source
-          # install dependencies
-          choco install ninja
-          # build!
-          make llvm-build
-          # Remove unnecessary object files (to reduce cache size).
-          find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
-      - name: Cache wasi-libc sysroot
-        uses: actions/cache@v2
-        id: cache-wasi-libc
-        with:
-          key: wasi-libc-sysroot-v1
-          path: lib/wasi-libc/sysroot
-      - name: Build wasi-libc
-        if: steps.cache-wasi-libc.outputs.cache-hit != 'true'
-        run: make wasi-libc
-      - name: Test TinyGo
-        shell: bash
-        run: make test
-      - name: Build TinyGo release tarball
-        run: make build/release -j4
-      - name: Make release artifact
-        shell: bash
-        working-directory: build/release
-        run: 7z -tzip a release.zip tinygo
-      - name: Publish release artifact
-        # Note: this release artifact is double-zipped, see:
-        # https://github.com/actions/upload-artifact/issues/39
-        # We can essentially pick one of these:
-        # - have a dobule-zipped artifact when downloaded from the UI
-        # - have a very slow artifact upload
-        # We're doing the former here, to keep artifact uploads fast.
-        uses: actions/upload-artifact@v2
-        with:
-          name: release-double-zipped
-          path: build/release/release.zip
-      - name: Smoke tests
-        shell: bash
-        run: make smoketest TINYGO=build/tinygo AVR=0 XTENSA=0

.gitmodules

@@ -23,6 +23,3 @@
 [submodule "lib/stm32-svd"]
 	path = lib/stm32-svd
 	url = https://github.com/tinygo-org/stm32-svd
-[submodule "lib/musl"]
-	path = lib/musl
-	url = git://git.musl-libc.org/musl

BUILDING.md

@@ -23,7 +23,7 @@ different guide:
 LLVM, Clang and LLD are quite light on dependencies, requiring only standard
 build tools to be built. Go is of course necessary to build TinyGo itself.
 
-  * Go (1.15+)
+  * Go (1.13+)
   * Standard build tools (gcc/clang)
   * git
   * CMake

CHANGELOG.md

@@ -1,73 +1,3 @@
-0.20.0
----
-
-* **command line**
-  - add support for Go 1.17
-  - improve Go version detection
-  - add support for the Black Magic Probe (BMP)
-  - add a flag for creating cpu profiles
-* **compiler**
-  - `builder:` list libraries at the end of the linker command
-  - `builder:` strip debug information at link time instead of at compile time
-  - `builder:` add missing error check for `ioutil.TempFile()`
-  - `builder:` simplify running of jobs
-  - `compiler:` move LLVM math builtin support into the compiler
-  - `compiler:` move math aliases from the runtime to the compiler
-  - `compiler:` add aliases for many hashing packages
-  - `compiler:` add `*ssa.MakeSlice` bounds tests
-  - `compiler:` fix max possible slice
-  - `compiler:` add support for new language features of Go 1.17
-  - `compiler:` fix equally named structs in different scopes
-  - `compiler:` avoid zero-sized alloca in channel operations
-  - `interp:` don't ignore array indices for untyped objects
-  - `interp:` keep reverted package initializers in order
-  - `interp:` fix bug in compiler-time/run-time package initializers
-  - `loader:` fix panic in CGo files with syntax errors
-  - `transform:` improve GC stack slot pass to work around a bug
-* **standard library**
-  - `crypto/rand`: switch to `arc4random_buf`
-  - `math:` fix `math.Max` and `math.Min`
-  - `math/big`: fix undefined symbols error
-  - `net:` add MAC address implementation
-  - `os:` implement `os.Executable`
-  - `os:` add `SEEK_SET`, `SEEK_CUR`, and `SEEK_END`
-  - `reflect:` add StructField.IsExported method
-  - `runtime:` reset heapptr to heapStart after preinit()
-  - `runtime:` add `subsections_via_symbols` to assembly files on darwin
-  - `testing:` add subset implementation of Benchmark
-  - `testing:` test testing package using `tinygo test`
-  - `testing:` add support for the `-test.v` flag
-* **targets**
-  - `386:` bump minimum requirement to the Pentium 4
-  - `arm:` switch to Thumb instruction set on ARM
-  - `atsamd:` fix copy-paste error for atsamd21/51 calibTrim block
-  - `baremetal`,`wasm`: support command line params and environment variables
-  - `cortexm:` fix stack overflow because of unaligned stacks
-  - `esp32c3:` add support for the ESP32-C3 from Espressif
-  - `nrf52840:` fix ram size
-  - `nxpmk66f18:` fix a suspicious bitwise operation
-  - `rp2040:` add SPI support
-  - `rp2040:` add I2C support
-  - `rp2040:` add PWM implementation
-  - `rp2040:` add openocd configuration
-  - `stm32:` add support for PortMask* functions for WS2812 support
-  - `unix:` fix time base for time.Now()
-  - `unix:` check for mmap error and act accordingly
-  - `wasm:` override dlmalloc heap implementation from wasi-libc
-  - `wasm:` align heap to 16 bytes
-  - `wasm:` add support for the crypto/rand package
-* **boards**
-  - add `DefaultUART` to adafruit boards
-  - `arduino-mkrwifi1010:` add board definition for Arduino MKR WiFi 1010
-  - `arduino-mkrwifi1010:` fix pin definition of `NINA_RESETN`
-  - `feather-nrf52:` fix pin definition of uart
-  - `feather-rp2040:` add pin name definition
-  - `gameboy-advance:` fix ROM header
-  - `mdbt50qrx-uf2:` add Raytac MDBT50Q-RX Dongle with TinyUF2
-  - `nano-rp2040:` define `NINA_SPI` and fix wifinina pins
-  - `teensy40:` enable hardware UART reconfiguration, fix receive watermark interrupt
-
-
 0.19.0
 ---
 

Dockerfile

@@ -1,8 +1,8 @@
-# TinyGo base stage installs the most recent Go 1.17.x, LLVM 11 and the TinyGo compiler itself.
-FROM golang:1.17 AS tinygo-base
+# TinyGo base stage installs the most recent Go 1.16.x, LLVM 11 and the TinyGo compiler itself.
+FROM golang:1.16 AS tinygo-base
 
 RUN wget -O- https://apt.llvm.org/llvm-snapshot.gpg.key| apt-key add - && \
-    echo "deb http://apt.llvm.org/bullseye/ llvm-toolchain-bullseye-11 main" >> /etc/apt/sources.list && \
+    echo "deb http://apt.llvm.org/buster/ llvm-toolchain-buster-11 main" >> /etc/apt/sources.list && \
     apt-get update && \
     apt-get install -y llvm-11-dev libclang-11-dev lld-11 git
 
@@ -15,7 +15,7 @@ RUN cd /tinygo/ && \
     git submodule sync && \
     git submodule update --init --recursive --force
 
-COPY ./lib/picolibc-stdio.c /tinygo/lib/picolibc-stdio.c
+COPY ./lib/picolibc-include/* /tinygo/lib/picolibc-include/
 
 RUN cd /tinygo/ && \
     go install /tinygo/

Makefile

@@ -10,9 +10,9 @@ LLD_SRC ?= $(LLVM_PROJECTDIR)/lld
 
 # Try to autodetect LLVM build tools.
 detect = $(shell command -v $(1) 2> /dev/null && echo $(1))
-CLANG ?= $(word 1,$(abspath $(call detect,llvm-build/bin/clang))$(call detect,clang-11)$(call detect,clang))
-LLVM_AR ?= $(word 1,$(abspath $(call detect,llvm-build/bin/llvm-ar))$(call detect,llvm-ar-11)$(call detect,llvm-ar))
-LLVM_NM ?= $(word 1,$(abspath $(call detect,llvm-build/bin/llvm-nm))$(call detect,llvm-nm-11)$(call detect,llvm-nm))
+CLANG ?= $(word 1,$(abspath $(call detect,llvm-build/bin/clang))$(call detect,clang-11)$(call detect,clang-10)$(call detect,clang))
+LLVM_AR ?= $(word 1,$(abspath $(call detect,llvm-build/bin/llvm-ar))$(call detect,llvm-ar-11)$(call detect,llvm-ar-10)$(call detect,llvm-ar))
+LLVM_NM ?= $(word 1,$(abspath $(call detect,llvm-build/bin/llvm-nm))$(call detect,llvm-nm-11)$(call detect,llvm-nm-10)$(call detect,llvm-nm))
 
 # Go binary and GOROOT to select
 GO ?= go
@@ -100,7 +100,7 @@ endif
 clean:
 	@rm -rf build
 
-FMT_PATHS = ./*.go builder cgo compiler interp loader src/device/arm src/examples src/machine src/os src/reflect src/runtime src/sync src/syscall src/testing src/internal/reflectlite transform
+FMT_PATHS = ./*.go builder cgo compiler interp loader src/device/arm src/examples src/machine src/os src/reflect src/runtime src/sync src/syscall src/internal/reflectlite transform
 fmt:
 	@gofmt -l -w $(FMT_PATHS)
 fmt-check:
@@ -124,7 +124,6 @@ build/gen-device-svd: ./tools/gen-device-svd/*.go
 
 gen-device-esp: build/gen-device-svd
 	./build/gen-device-svd -source=https://github.com/posborne/cmsis-svd/tree/master/data/Espressif-Community -interrupts=software lib/cmsis-svd/data/Espressif-Community/ src/device/esp/
-	./build/gen-device-svd -source=https://github.com/posborne/cmsis-svd/tree/master/data/Espressif -interrupts=software lib/cmsis-svd/data/Espressif/ src/device/esp/
 	GO111MODULE=off $(GO) fmt ./src/device/esp
 
 gen-device-nrf: build/gen-device-svd
@@ -175,7 +174,7 @@ $(LLVM_BUILDDIR): $(LLVM_BUILDDIR)/build.ninja
 wasi-libc: lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a
 lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a:
 	@if [ ! -e lib/wasi-libc/Makefile ]; then echo "Submodules have not been downloaded. Please download them using:\n  git submodule update --init"; exit 1; fi
-	cd lib/wasi-libc && make -j4 WASM_CFLAGS="-O2 -g -DNDEBUG" WASM_CC=$(CLANG) WASM_AR=$(LLVM_AR) WASM_NM=$(LLVM_NM)
+	cd lib/wasi-libc && make -j4 WASM_CC=$(CLANG) WASM_AR=$(LLVM_AR) WASM_NM=$(LLVM_NM)
 
 
 # Build the Go compiler.
@@ -184,37 +183,23 @@ tinygo:
 	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) build -buildmode exe -o build/tinygo$(EXE) -tags byollvm -ldflags="-X main.gitSha1=`git rev-parse --short HEAD`" .
 
 test: wasi-libc
-	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test -v -timeout=20m -buildmode exe -tags byollvm ./builder ./cgo ./compileopts ./compiler ./interp ./transform .
+	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test -v -buildmode exe -tags byollvm ./builder ./cgo ./compileopts ./compiler ./interp ./transform .
 
 TEST_PACKAGES = \
-	compress/bzip2 \
 	container/heap \
 	container/list \
 	container/ring \
 	crypto/des \
-	crypto/dsa \
-	crypto/md5 \
-	crypto/rc4 \
-	crypto/sha1 \
-	crypto/sha256 \
-	crypto/sha512 \
 	encoding \
 	encoding/ascii85 \
 	encoding/base32 \
 	encoding/hex \
-	hash \
 	hash/adler32 \
 	hash/fnv \
 	hash/crc64 \
-	html \
-	index/suffixarray \
 	math \
 	math/cmplx \
-	testing \
-	testing/iotest \
 	text/scanner \
-	text/scanner \
-	unicode \
 	unicode/utf8 \
 
 # Test known-working standard library packages.
@@ -258,17 +243,17 @@ smoketest:
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/test
 	@$(MD5SUM) test.hex
 	# test simulated boards on play.tinygo.org
-	$(TINYGO) build -size short -o test.wasm -tags=arduino              examples/blinky1
+	$(TINYGO) build             -o test.wasm -tags=arduino              examples/blinky1
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build -size short -o test.wasm -tags=hifive1b             examples/blinky1
+	$(TINYGO) build             -o test.wasm -tags=hifive1b             examples/blinky1
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build -size short -o test.wasm -tags=reelboard            examples/blinky1
+	$(TINYGO) build             -o test.wasm -tags=reelboard            examples/blinky1
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build -size short -o test.wasm -tags=pca10040             examples/blinky2
+	$(TINYGO) build             -o test.wasm -tags=pca10040             examples/blinky2
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build -size short -o test.wasm -tags=pca10056             examples/blinky2
+	$(TINYGO) build             -o test.wasm -tags=pca10056             examples/blinky2
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build -size short -o test.wasm -tags=circuitplay_express  examples/blinky1
+	$(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
@@ -373,8 +358,6 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=arduino-nano33      examples/blinky1
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=arduino-mkrwifi1010 examples/blinky1
-	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pico                examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=nano-33-ble         examples/blinky1
@@ -441,19 +424,15 @@ ifneq ($(XTENSA), 0)
 	@$(MD5SUM) test.bin
 	$(TINYGO) build -size short -o test.bin -target=nodemcu             examples/blinky1
 	@$(MD5SUM) test.bin
-	$(TINYGO) build -size short -o test.bin -target m5stack-core2       examples/serial
-	@$(MD5SUM) test.bin
 endif
-	$(TINYGO) build -size short -o test.bin -target=esp32c3           	examples/serial
-	@$(MD5SUM) test.bin
 	$(TINYGO) build -size short -o test.hex -target=hifive1b            examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=hifive1-qemu        examples/serial
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=maixbit             examples/blinky1
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o wasm.wasm -target=wasm               examples/wasm/export
-	$(TINYGO) build -size short -o wasm.wasm -target=wasm               examples/wasm/main
+	$(TINYGO) build             -o wasm.wasm -target=wasm               examples/wasm/export
+	$(TINYGO) build             -o wasm.wasm -target=wasm               examples/wasm/main
 	# test various compiler flags
 	$(TINYGO) build -size short -o test.hex -target=pca10040 -gc=none -scheduler=none examples/blinky1
 	@$(MD5SUM) test.hex
@@ -465,10 +444,6 @@ endif
 	@$(MD5SUM) test.nro
 	$(TINYGO) build -size short -o test.hex -target=pca10040 -opt=0     ./testdata/stdlib.go
 	@$(MD5SUM) test.hex
-	GOOS=linux GOARCH=arm $(TINYGO) build -size short -o test.elf       ./testdata/cgo
-ifneq ($(OS),Windows_NT)
-	$(TINYGO) build -o test.elf -gc=leaking -scheduler=none examples/serial
-endif
 
 
 wasmtest:
@@ -479,16 +454,12 @@ build/release: tinygo gen-device wasi-libc
 	@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/musl/arch
-	@mkdir -p build/release/tinygo/lib/musl/crt
-	@mkdir -p build/release/tinygo/lib/musl/src
 	@mkdir -p build/release/tinygo/lib/nrfx
 	@mkdir -p build/release/tinygo/lib/picolibc/newlib/libc
-	@mkdir -p build/release/tinygo/lib/picolibc/newlib/libm
 	@mkdir -p build/release/tinygo/lib/wasi-libc
-	@mkdir -p build/release/tinygo/pkg/armv6m-unknown-unknown-eabi
-	@mkdir -p build/release/tinygo/pkg/armv7m-unknown-unknown-eabi
-	@mkdir -p build/release/tinygo/pkg/armv7em-unknown-unknown-eabi
+	@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
 	@echo copying source files
 	@cp -p  build/tinygo$(EXE)           build/release/tinygo/bin
 	@cp -p $(abspath $(CLANG_SRC))/lib/Headers/*.h build/release/tinygo/lib/clang/include
@@ -497,44 +468,22 @@ build/release: tinygo gen-device wasi-libc
 	@cp -rp lib/compiler-rt/lib/builtins build/release/tinygo/lib/compiler-rt/lib
 	@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/musl/arch/aarch64        build/release/tinygo/lib/musl/arch
-	@cp -rp lib/musl/arch/arm            build/release/tinygo/lib/musl/arch
-	@cp -rp lib/musl/arch/generic        build/release/tinygo/lib/musl/arch
-	@cp -rp lib/musl/arch/i386           build/release/tinygo/lib/musl/arch
-	@cp -rp lib/musl/arch/x86_64         build/release/tinygo/lib/musl/arch
-	@cp -rp lib/musl/crt/crt1.c          build/release/tinygo/lib/musl/crt
-	@cp -rp lib/musl/COPYRIGHT           build/release/tinygo/lib/musl
-	@cp -rp lib/musl/include             build/release/tinygo/lib/musl
-	@cp -rp lib/musl/src/env             build/release/tinygo/lib/musl/src
-	@cp -rp lib/musl/src/errno           build/release/tinygo/lib/musl/src
-	@cp -rp lib/musl/src/exit            build/release/tinygo/lib/musl/src
-	@cp -rp lib/musl/src/include         build/release/tinygo/lib/musl/src
-	@cp -rp lib/musl/src/internal        build/release/tinygo/lib/musl/src
-	@cp -rp lib/musl/src/malloc          build/release/tinygo/lib/musl/src
-	@cp -rp lib/musl/src/mman            build/release/tinygo/lib/musl/src
-	@cp -rp lib/musl/src/signal          build/release/tinygo/lib/musl/src
-	@cp -rp lib/musl/src/stdio           build/release/tinygo/lib/musl/src
-	@cp -rp lib/musl/src/string          build/release/tinygo/lib/musl/src
-	@cp -rp lib/musl/src/thread          build/release/tinygo/lib/musl/src
-	@cp -rp lib/musl/src/time            build/release/tinygo/lib/musl/src
-	@cp -rp lib/musl/src/unistd          build/release/tinygo/lib/musl/src
 	@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/newlib/libm/common      build/release/tinygo/lib/picolibc/newlib/libm
-	@cp -rp lib/picolibc-stdio.c         build/release/tinygo/lib
+	@cp -rp lib/picolibc-include         build/release/tinygo/lib
 	@cp -rp lib/wasi-libc/sysroot        build/release/tinygo/lib/wasi-libc/sysroot
 	@cp -rp src                          build/release/tinygo/src
 	@cp -rp targets                      build/release/tinygo/targets
-	./build/tinygo build-library -target=armv6m-unknown-unknown-eabi  -o build/release/tinygo/pkg/armv6m-unknown-unknown-eabi/compiler-rt compiler-rt
-	./build/tinygo build-library -target=armv7m-unknown-unknown-eabi  -o build/release/tinygo/pkg/armv7m-unknown-unknown-eabi/compiler-rt compiler-rt
-	./build/tinygo build-library -target=armv7em-unknown-unknown-eabi -o build/release/tinygo/pkg/armv7em-unknown-unknown-eabi/compiler-rt compiler-rt
-	./build/tinygo build-library -target=armv6m-unknown-unknown-eabi  -o build/release/tinygo/pkg/armv6m-unknown-unknown-eabi/picolibc picolibc
-	./build/tinygo build-library -target=armv7m-unknown-unknown-eabi  -o build/release/tinygo/pkg/armv7m-unknown-unknown-eabi/picolibc picolibc
-	./build/tinygo build-library -target=armv7em-unknown-unknown-eabi -o build/release/tinygo/pkg/armv7em-unknown-unknown-eabi/picolibc picolibc
+	./build/tinygo build-library -target=armv6m-none-eabi  -o build/release/tinygo/pkg/armv6m-none-eabi/compiler-rt.a compiler-rt
+	./build/tinygo build-library -target=armv7m-none-eabi  -o build/release/tinygo/pkg/armv7m-none-eabi/compiler-rt.a compiler-rt
+	./build/tinygo build-library -target=armv7em-none-eabi -o build/release/tinygo/pkg/armv7em-none-eabi/compiler-rt.a compiler-rt
+	./build/tinygo build-library -target=armv6m-none-eabi  -o build/release/tinygo/pkg/armv6m-none-eabi/picolibc.a picolibc
+	./build/tinygo build-library -target=armv7m-none-eabi  -o build/release/tinygo/pkg/armv7m-none-eabi/picolibc.a picolibc
+	./build/tinygo build-library -target=armv7em-none-eabi -o build/release/tinygo/pkg/armv7em-none-eabi/picolibc.a picolibc
 
 release: build/release
 	tar -czf build/release.tar.gz -C build/release tinygo

README.md

@@ -43,7 +43,7 @@ See the [getting started instructions](https://tinygo.org/getting-started/) for
 
 You can compile TinyGo programs for microcontrollers, WebAssembly and Linux.
 
-The following 71 microcontroller boards are currently supported:
+The following 68 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)
@@ -69,7 +69,6 @@ The following 71 microcontroller boards are currently supported:
 * [Arduino Mega 1280](https://www.arduino.cc/en/Main/arduinoBoardMega/)
 * [Arduino Mega 2560](https://store.arduino.cc/arduino-mega-2560-rev3)
 * [Arduino MKR1000](https://store.arduino.cc/arduino-mkr1000-wifi)
-* [Arduino MKR WiFi 1010](https://store.arduino.cc/usa/mkr-wifi-1010)
 * [Arduino Nano](https://store.arduino.cc/arduino-nano)
 * [Arduino Nano 33 BLE](https://store.arduino.cc/nano-33-ble)
 * [Arduino Nano 33 BLE Sense](https://store.arduino.cc/nano-33-ble-sense)
@@ -84,7 +83,6 @@ The following 71 microcontroller boards are currently supported:
 * [ESP32](https://www.espressif.com/en/products/socs/esp32)
 * [ESP8266](https://www.espressif.com/en/products/socs/esp8266)
 * [Game Boy Advance](https://en.wikipedia.org/wiki/Game_Boy_Advance)
-* [M5Stack Core2](https://shop.m5stack.com/products/m5stack-core2-esp32-iot-development-kit)
 * [Makerdiary nRF52840-MDK](https://wiki.makerdiary.com/nrf52840-mdk/)
 * [Makerdiary nRF52840-MDK USB Dongle](https://wiki.makerdiary.com/nrf52840-mdk-usb-dongle/)
 * [Microchip SAM E54 Xplained Pro](https://www.microchip.com/developmenttools/productdetails/atsame54-xpro)
@@ -103,7 +101,6 @@ The following 71 microcontroller boards are currently supported:
 * [PJRC Teensy 4.0](https://www.pjrc.com/store/teensy40.html)
 * [ProductivityOpen P1AM-100](https://facts-engineering.github.io/modules/P1AM-100/P1AM-100.html)
 * [Raspberry Pi Pico](https://www.raspberrypi.org/products/raspberry-pi-pico/)
-* [Raytac MDBT50Q-RX Dongle (with TinyUF2 bootloader)](https://www.adafruit.com/product/5199)
 * [Seeed Wio Terminal](https://www.seeedstudio.com/Wio-Terminal-p-4509.html)
 * [Seeed Seeeduino XIAO](https://www.seeedstudio.com/Seeeduino-XIAO-Arduino-Microcontroller-SAMD21-Cortex-M0+-p-4426.html)
 * [Seeed Sipeed MAix BiT](https://www.seeedstudio.com/Sipeed-MAix-BiT-for-RISC-V-AI-IoT-p-2872.html)

azure-pipelines.yml

@@ -0,0 +1,88 @@
+# Avoid lengthy LLVM rebuilds on each newly pushed branch. Pull requests will
+# be built anyway.
+trigger:
+- release
+- dev
+
+jobs:
+- job: Build
+  timeoutInMinutes: 240 # 4h
+  pool:
+    vmImage: 'VS2017-Win2016'
+  steps:
+    - task: GoTool@0
+      inputs:
+        version: '1.16'
+    - checkout: self
+      fetchDepth: 1
+    - task: Cache@2
+      displayName: Cache LLVM source
+      inputs:
+        key: llvm-source-11-windows-v1
+        path: llvm-project
+    - task: Bash@3
+      displayName: Download LLVM source
+      inputs:
+        targetType: inline
+        script: make llvm-source
+    - task: CacheBeta@0
+      displayName: Cache LLVM build
+      inputs:
+        key: llvm-build-11-windows-v5
+        path: llvm-build
+    - task: Bash@3
+      displayName: Build LLVM
+      inputs:
+        targetType: inline
+        script: |
+          if [ ! -f llvm-build/lib/liblldELF.a ]
+          then
+            # install dependencies
+            choco install ninja
+            # hack ninja to use fewer jobs
+            echo -e 'C:\\ProgramData\\Chocolatey\\bin\\ninja -j4 %*' > /usr/bin/ninja.bat
+            # build!
+            make llvm-build
+          fi
+    - task: Bash@3
+      displayName: Install QEMU
+      inputs:
+        targetType: inline
+        script: choco install qemu --version=2020.06.12
+    - task: CacheBeta@0
+      displayName: Cache wasi-libc sysroot
+      inputs:
+        key: wasi-libc-sysroot-v4
+        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="$PATH:./llvm-build/bin:/c/Program Files/qemu"
+          unset GOROOT
+          make test
+    - task: Bash@3
+      displayName: Build TinyGo release tarball
+      inputs:
+        targetType: inline
+        script: |
+          export PATH="$PATH:./llvm-build/bin:/c/Program Files/qemu"
+          unset GOROOT
+          make build/release -j4
+    - publish: $(System.DefaultWorkingDirectory)/build/release/tinygo
+      displayName: Publish zip as artifact
+      artifact: tinygo
+    - task: Bash@3
+      displayName: Smoke tests
+      inputs:
+        targetType: inline
+        script: |
+          export PATH="$PATH:./llvm-build/bin:/c/Program Files/qemu"
+          unset GOROOT
+          make smoketest TINYGO=build/tinygo AVR=0 XTENSA=0

builder/ar.go

@@ -5,7 +5,6 @@ import (
 	"debug/elf"
 	"encoding/binary"
 	"errors"
-	"fmt"
 	"io"
 	"os"
 	"path/filepath"
@@ -18,12 +17,17 @@ import (
 // given as a parameter. It is equivalent to the following command:
 //
 //     ar -rcs <archivePath> <objs...>
-func makeArchive(arfile *os.File, objs []string) error {
+func makeArchive(archivePath string, objs []string) error {
 	// Open the archive file.
-	arwriter := ar.NewWriter(arfile)
-	err := arwriter.WriteGlobalHeader()
+	arfile, err := os.Create(archivePath)
 	if err != nil {
-		return &os.PathError{Op: "write ar header", Path: arfile.Name(), Err: err}
+		return err
+	}
+	defer arfile.Close()
+	arwriter := ar.NewWriter(arfile)
+	err = arwriter.WriteGlobalHeader()
+	if err != nil {
+		return &os.PathError{"write ar header", archivePath, err}
 	}
 
 	// Open all object files and read the symbols for the symbol table.
@@ -31,17 +35,21 @@ func makeArchive(arfile *os.File, objs []string) error {
 		name      string // symbol name
 		fileIndex int    // index into objfiles
 	}{}
-	archiveOffsets := make([]int32, len(objs))
+	objfiles := make([]struct {
+		file          *os.File
+		archiveOffset int32
+	}, len(objs))
 	for i, objpath := range objs {
 		objfile, err := os.Open(objpath)
 		if err != nil {
 			return err
 		}
+		objfiles[i].file = objfile
 
 		// Read the symbols and add them to the symbol table.
 		dbg, err := elf.NewFile(objfile)
 		if err != nil {
-			return fmt.Errorf("failed to open file %s: %w", objpath, err)
+			return err
 		}
 		symbols, err := dbg.Symbols()
 		if err != nil {
@@ -53,8 +61,9 @@ func makeArchive(arfile *os.File, objs []string) error {
 				// Don't include local symbols (STB_LOCAL).
 				continue
 			}
-			if elf.ST_TYPE(symbol.Info) != elf.STT_FUNC && elf.ST_TYPE(symbol.Info) != elf.STT_OBJECT {
+			if elf.ST_TYPE(symbol.Info) != elf.STT_FUNC {
 				// Not a function.
+				// TODO: perhaps globals variables should also be included?
 				continue
 			}
 			// Include in archive.
@@ -63,10 +72,6 @@ func makeArchive(arfile *os.File, objs []string) error {
 				fileIndex int
 			}{symbol.Name, i})
 		}
-
-		// Close file, to avoid issues with too many open files (especially on
-		// MacOS X).
-		objfile.Close()
 	}
 
 	// Create the symbol table buffer.
@@ -120,12 +125,7 @@ func makeArchive(arfile *os.File, objs []string) error {
 	}
 
 	// Add all object files to the archive.
-	for i, objpath := range objs {
-		objfile, err := os.Open(objpath)
-		if err != nil {
-			return err
-		}
-
+	for i, objfile := range objfiles {
 		// Store the start index, for when we'll update the symbol table with
 		// the correct file start indices.
 		offset, err := arfile.Seek(0, os.SEEK_CUR)
@@ -133,17 +133,17 @@ func makeArchive(arfile *os.File, objs []string) error {
 			return err
 		}
 		if int64(int32(offset)) != offset {
-			return errors.New("large archives (4GB+) not supported: " + arfile.Name())
+			return errors.New("large archives (4GB+) not supported: " + archivePath)
 		}
-		archiveOffsets[i] = int32(offset)
+		objfiles[i].archiveOffset = int32(offset)
 
 		// Write the file header.
-		st, err := objfile.Stat()
+		st, err := objfile.file.Stat()
 		if err != nil {
 			return err
 		}
 		err = arwriter.WriteHeader(&ar.Header{
-			Name:    filepath.Base(objfile.Name()),
+			Name:    filepath.Base(objfile.file.Name()),
 			ModTime: time.Unix(0, 0),
 			Uid:     0,
 			Gid:     0,
@@ -155,22 +155,22 @@ func makeArchive(arfile *os.File, objs []string) error {
 		}
 
 		// Copy the file contents into the archive.
-		n, err := io.Copy(arwriter, objfile)
+		n, err := io.Copy(arwriter, objfile.file)
 		if err != nil {
 			return err
 		}
 		if n != st.Size() {
-			return errors.New("file modified during ar creation: " + arfile.Name())
+			return errors.New("file modified during ar creation: " + archivePath)
 		}
 
 		// File is not needed anymore.
-		objfile.Close()
+		objfile.file.Close()
 	}
 
 	// Create symbol indices.
 	indicesBuf := &bytes.Buffer{}
 	for _, sym := range symbolTable {
-		err = binary.Write(indicesBuf, binary.BigEndian, archiveOffsets[sym.fileIndex])
+		err = binary.Write(indicesBuf, binary.BigEndian, objfiles[sym.fileIndex].archiveOffset)
 		if err != nil {
 			return err
 		}

builder/build.go

@@ -21,7 +21,6 @@ import (
 	"sort"
 	"strings"
 
-	"github.com/tinygo-org/tinygo/cgo"
 	"github.com/tinygo-org/tinygo/compileopts"
 	"github.com/tinygo-org/tinygo/compiler"
 	"github.com/tinygo-org/tinygo/goenv"
@@ -61,7 +60,6 @@ type BuildResult struct {
 // implementation of an imported package changes.
 type packageAction struct {
 	ImportPath       string
-	CGoVersion       int // cgo.Version
 	CompilerVersion  int // compiler.Version
 	InterpVersion    int // interp.Version
 	LLVMVersion      string
@@ -88,38 +86,6 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	}
 	defer os.RemoveAll(dir)
 
-	// Check for a libc dependency.
-	// As a side effect, this also creates the headers for the given libc, if
-	// the libc needs them.
-	root := goenv.Get("TINYGOROOT")
-	var libcDependencies []*compileJob
-	switch config.Target.Libc {
-	case "musl":
-		job, err := Musl.load(config, dir)
-		if err != nil {
-			return err
-		}
-		libcDependencies = append(libcDependencies, dummyCompileJob(filepath.Join(filepath.Dir(job.result), "crt1.o")))
-		libcDependencies = append(libcDependencies, job)
-	case "picolibc":
-		libcJob, err := Picolibc.load(config, dir)
-		if err != nil {
-			return err
-		}
-		libcDependencies = append(libcDependencies, libcJob)
-	case "wasi-libc":
-		path := filepath.Join(root, "lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a")
-		if _, err := os.Stat(path); os.IsNotExist(err) {
-			return errors.New("could not find wasi-libc, perhaps you need to run `make wasi-libc`?")
-		}
-		libcDependencies = append(libcDependencies, dummyCompileJob(path))
-	case "":
-		// no library specified, so nothing to do
-	default:
-		return fmt.Errorf("unknown libc: %s", config.Target.Libc)
-	}
-
-	optLevel, sizeLevel, _ := config.OptLevels()
 	compilerConfig := &compiler.Config{
 		Triple:          config.Triple(),
 		CPU:             config.CPU(),
@@ -128,14 +94,13 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		GOARCH:          config.GOARCH(),
 		CodeModel:       config.CodeModel(),
 		RelocationModel: config.RelocationModel(),
-		SizeLevel:       sizeLevel,
 
 		Scheduler:          config.Scheduler(),
 		FuncImplementation: config.FuncImplementation(),
 		AutomaticStackSize: config.AutomaticStackSize(),
 		DefaultStackSize:   config.Target.DefaultStackSize,
 		NeedsStackObjects:  config.NeedsStackObjects(),
-		Debug:              true,
+		Debug:              config.Debug(),
 		LLVMFeatures:       config.LLVMFeatures(),
 	}
 
@@ -159,6 +124,11 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		return err
 	}
 
+	// The slice of jobs that orchestrates most of the build.
+	// This is somewhat like an in-memory Makefile with each job being a
+	// Makefile target.
+	var jobs []*compileJob
+
 	// Create the *ssa.Program. This does not yet build the entire SSA of the
 	// program so it's pretty fast and doesn't need to be parallelized.
 	program := lprogram.LoadSSA()
@@ -168,6 +138,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	var packageJobs []*compileJob
 	packageBitcodePaths := make(map[string]string)
 	packageActionIDs := make(map[string]string)
+	optLevel, sizeLevel, _ := config.OptLevels()
 	for _, pkg := range lprogram.Sorted() {
 		pkg := pkg // necessary to avoid a race condition
 
@@ -181,7 +152,6 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		// the parameters for the build.
 		actionID := packageAction{
 			ImportPath:       pkg.ImportPath,
-			CGoVersion:       cgo.Version,
 			CompilerVersion:  compiler.Version,
 			InterpVersion:    interp.Version,
 			LLVMVersion:      llvm.Version,
@@ -242,50 +212,6 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 					return errors.New("verification error after compiling package " + pkg.ImportPath)
 				}
 
-				// Load bitcode of CGo headers and join the modules together.
-				// This may seem vulnerable to cache problems, but this is not
-				// the case: the Go code that was just compiled already tracks
-				// all C files that are read and hashes them.
-				// These headers could be compiled in parallel but the benefit
-				// is so small that it's probably not worth parallelizing.
-				// Packages are compiled independently anyway.
-				for _, cgoHeader := range pkg.CGoHeaders {
-					// Store the header text in a temporary file.
-					f, err := ioutil.TempFile(dir, "cgosnippet-*.c")
-					if err != nil {
-						return err
-					}
-					_, err = f.Write([]byte(cgoHeader))
-					if err != nil {
-						return err
-					}
-					f.Close()
-
-					// Compile the code (if there is any) to bitcode.
-					flags := append([]string{"-c", "-emit-llvm", "-o", f.Name() + ".bc", f.Name()}, pkg.CFlags...)
-					if config.Options.PrintCommands != nil {
-						config.Options.PrintCommands("clang", flags...)
-					}
-					err = runCCompiler(flags...)
-					if err != nil {
-						return &commandError{"failed to build CGo header", "", err}
-					}
-
-					// Load and link the bitcode.
-					// This makes it possible to optimize the functions defined
-					// in the header together with the Go code. In particular,
-					// this allows inlining. It also ensures there is only one
-					// file per package to cache.
-					headerMod, err := mod.Context().ParseBitcodeFile(f.Name() + ".bc")
-					if err != nil {
-						return fmt.Errorf("failed to load bitcode file: %w", err)
-					}
-					err = llvm.LinkModules(mod, headerMod)
-					if err != nil {
-						return fmt.Errorf("failed to link module: %w", err)
-					}
-				}
-
 				// Erase all globals that are part of the undefinedGlobals list.
 				// This list comes from the -ldflags="-X pkg.foo=val" option.
 				// Instead of setting the value directly in the AST (which would
@@ -320,6 +246,16 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 					return errors.New("verification error after interpreting " + pkgInit.Name())
 				}
 
+				if sizeLevel >= 2 {
+					// Set the "optsize" attribute to make slightly smaller
+					// binaries at the cost of some performance.
+					kind := llvm.AttributeKindID("optsize")
+					attr := mod.Context().CreateEnumAttribute(kind, 0)
+					for fn := mod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
+						fn.AddFunctionAttr(attr)
+					}
+				}
+
 				// Run function passes for each function in the module.
 				// These passes are intended to be run on each function right
 				// after they're created to reduce IR size (and maybe also for
@@ -375,6 +311,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 				return os.Rename(f.Name(), bitcodePath)
 			},
 		}
+		jobs = append(jobs, job)
 		packageJobs = append(packageJobs, job)
 	}
 
@@ -405,7 +342,6 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 			llvmInitFn := mod.NamedFunction("runtime.initAll")
 			llvmInitFn.SetLinkage(llvm.InternalLinkage)
 			llvmInitFn.SetUnnamedAddr(true)
-			transform.AddStandardAttributes(llvmInitFn, config)
 			llvmInitFn.Param(0).SetName("context")
 			llvmInitFn.Param(1).SetName("parentHandle")
 			block := mod.Context().AddBasicBlock(llvmInitFn, "entry")
@@ -466,13 +402,14 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 			return nil
 		},
 	}
+	jobs = append(jobs, programJob)
 
 	// Check whether we only need to create an object file.
 	// If so, we don't need to link anything and will be finished quickly.
 	outext := filepath.Ext(outpath)
 	if outext == ".o" || outext == ".bc" || outext == ".ll" {
 		// Run jobs to produce the LLVM module.
-		err := runJobs(programJob, config.Options.Parallelism)
+		err := runJobs(jobs)
 		if err != nil {
 			return err
 		}
@@ -513,6 +450,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 			return ioutil.WriteFile(objfile, llvmBuf.Bytes(), 0666)
 		},
 	}
+	jobs = append(jobs, outputObjectFileJob)
 
 	// Prepare link command.
 	linkerDependencies := []*compileJob{outputObjectFileJob}
@@ -523,16 +461,19 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	// Add compiler-rt dependency if needed. Usually this is a simple load from
 	// a cache.
 	if config.Target.RTLib == "compiler-rt" {
-		job, err := CompilerRT.load(config, dir)
+		job, err := CompilerRT.load(config.Triple(), config.CPU(), dir)
 		if err != nil {
 			return err
 		}
+		jobs = append(jobs, job.dependencies...)
+		jobs = append(jobs, job)
 		linkerDependencies = append(linkerDependencies, job)
 	}
 
 	// Add jobs to compile extra files. These files are in C or assembly and
 	// contain things like the interrupt vector table and low level operations
 	// such as stack switching.
+	root := goenv.Get("TINYGOROOT")
 	for _, path := range config.ExtraFiles() {
 		abspath := filepath.Join(root, path)
 		job := &compileJob{
@@ -543,6 +484,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 				return err
 			},
 		}
+		jobs = append(jobs, job)
 		linkerDependencies = append(linkerDependencies, job)
 	}
 
@@ -561,6 +503,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 					return err
 				},
 			}
+			jobs = append(jobs, job)
 			linkerDependencies = append(linkerDependencies, job)
 		}
 	}
@@ -571,48 +514,34 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		ldflags = append(ldflags, lprogram.LDFlags...)
 	}
 
-	// Add libc dependencies, if they exist.
-	linkerDependencies = append(linkerDependencies, libcDependencies...)
-
-	// Strip debug information with -no-debug.
-	if !config.Debug() {
-		for _, tag := range config.BuildTags() {
-			if tag == "baremetal" {
-				// Don't use -no-debug on baremetal targets. It makes no sense:
-				// the debug information isn't flashed to the device anyway.
-				return fmt.Errorf("stripping debug information is unnecessary for baremetal targets")
-			}
+	// Add libc dependency if needed.
+	switch config.Target.Libc {
+	case "picolibc":
+		job, err := Picolibc.load(config.Triple(), config.CPU(), dir)
+		if err != nil {
+			return err
 		}
-		if config.Target.Linker == "wasm-ld" {
-			// Don't just strip debug information, also compress relocations
-			// while we're at it. Relocations can only be compressed when debug
-			// information is stripped.
-			ldflags = append(ldflags, "--strip-debug", "--compress-relocations")
-		} else if config.Target.Linker == "ld.lld" {
-			// ld.lld is also used on Linux.
-			ldflags = append(ldflags, "--strip-debug")
-		} else {
-			switch config.GOOS() {
-			case "linux":
-				// Either real linux or an embedded system (like AVR) that
-				// pretends to be Linux. It's a ELF linker wrapped by GCC in any
-				// case (not ld.lld - that case is handled above).
-				ldflags = append(ldflags, "-Wl,--strip-debug")
-			case "darwin":
-				// MacOS (darwin) doesn't have a linker flag to strip debug
-				// information. Apple expects you to use the strip command
-				// instead.
-				return errors.New("cannot remove debug information: MacOS doesn't suppor this linker flag")
-			default:
-				// Other OSes may have different flags.
-				return errors.New("cannot remove debug information: unknown OS: " + config.GOOS())
-			}
+		// The library needs to be compiled (cache miss).
+		jobs = append(jobs, job.dependencies...)
+		jobs = append(jobs, job)
+		linkerDependencies = append(linkerDependencies, job)
+	case "wasi-libc":
+		path := filepath.Join(root, "lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a")
+		if _, err := os.Stat(path); os.IsNotExist(err) {
+			return errors.New("could not find wasi-libc, perhaps you need to run `make wasi-libc`?")
 		}
+		job := dummyCompileJob(path)
+		jobs = append(jobs, job)
+		linkerDependencies = append(linkerDependencies, job)
+	case "":
+		// no library specified, so nothing to do
+	default:
+		return fmt.Errorf("unknown libc: %s", config.Target.Libc)
 	}
 
 	// Create a linker job, which links all object files together and does some
 	// extra stuff that can only be done after linking.
-	linkJob := &compileJob{
+	jobs = append(jobs, &compileJob{
 		description:  "link",
 		dependencies: linkerDependencies,
 		run: func(job *compileJob) error {
@@ -659,31 +588,22 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 				}
 			}
 
-			// Print code size if requested.
 			if config.Options.PrintSizes == "short" || config.Options.PrintSizes == "full" {
-				packagePathMap := make(map[string]string, len(lprogram.Packages))
-				for _, pkg := range lprogram.Sorted() {
-					packagePathMap[pkg.OriginalDir()] = pkg.Pkg.Path()
-				}
-				sizes, err := loadProgramSize(executable, packagePathMap)
+				sizes, err := loadProgramSize(executable)
 				if err != nil {
 					return err
 				}
 				if config.Options.PrintSizes == "short" {
 					fmt.Printf("   code    data     bss |   flash     ram\n")
-					fmt.Printf("%7d %7d %7d | %7d %7d\n", sizes.Code+sizes.ROData, sizes.Data, sizes.BSS, sizes.Flash(), sizes.RAM())
+					fmt.Printf("%7d %7d %7d | %7d %7d\n", sizes.Code, sizes.Data, sizes.BSS, sizes.Code+sizes.Data, sizes.Data+sizes.BSS)
 				} else {
-					if !config.Debug() {
-						fmt.Println("warning: data incomplete, remove the -no-debug flag for more detail")
-					}
 					fmt.Printf("   code  rodata    data     bss |   flash     ram | package\n")
-					fmt.Printf("------------------------------- | --------------- | -------\n")
 					for _, name := range sizes.sortedPackageNames() {
 						pkgSize := sizes.Packages[name]
 						fmt.Printf("%7d %7d %7d %7d | %7d %7d | %s\n", pkgSize.Code, pkgSize.ROData, pkgSize.Data, pkgSize.BSS, pkgSize.Flash(), pkgSize.RAM(), name)
 					}
-					fmt.Printf("------------------------------- | --------------- | -------\n")
-					fmt.Printf("%7d %7d %7d %7d | %7d %7d | total\n", sizes.Code, sizes.ROData, sizes.Data, sizes.BSS, sizes.Code+sizes.ROData+sizes.Data, sizes.Data+sizes.BSS)
+					fmt.Printf("%7d %7d %7d %7d | %7d %7d | (sum)\n", sizes.Sum.Code, sizes.Sum.ROData, sizes.Sum.Data, sizes.Sum.BSS, sizes.Sum.Flash(), sizes.Sum.RAM())
+					fmt.Printf("%7d       - %7d %7d | %7d %7d | (all)\n", sizes.Code, sizes.Data, sizes.BSS, sizes.Code+sizes.Data, sizes.Data+sizes.BSS)
 				}
 			}
 
@@ -694,12 +614,12 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 
 			return nil
 		},
-	}
+	})
 
 	// Run all jobs to compile and link the program.
 	// Do this now (instead of after elf-to-hex and similar conversions) as it
 	// is simpler and cannot be parallelized.
-	err = runJobs(linkJob, config.Options.Parallelism)
+	err = runJobs(jobs)
 	if err != nil {
 		return err
 	}
@@ -724,7 +644,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		if err != nil {
 			return err
 		}
-	case "esp32", "esp32c3", "esp8266":
+	case "esp32", "esp8266":
 		// Special format for the ESP family of chips (parsed by the ROM
 		// bootloader).
 		tmppath = filepath.Join(dir, "main"+outext)
@@ -791,7 +711,7 @@ func optimizeProgram(mod llvm.Module, config *compileopts.Config) error {
 	// stack-allocated values.
 	// Use -wasm-abi=generic to disable this behaviour.
 	if config.WasmAbi() == "js" {
-		err := transform.ExternalInt64AsPtr(mod, config)
+		err := transform.ExternalInt64AsPtr(mod)
 		if err != nil {
 			return err
 		}

builder/buildcache.go

@@ -0,0 +1,105 @@
+package builder
+
+import (
+	"io"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/tinygo-org/tinygo/goenv"
+)
+
+// Return the newest timestamp of all the file paths passed in. Used to check
+// for stale caches.
+func cacheTimestamp(paths []string) (time.Time, error) {
+	var timestamp time.Time
+	for _, path := range paths {
+		st, err := os.Stat(path)
+		if err != nil {
+			return time.Time{}, err
+		}
+		if timestamp.IsZero() {
+			timestamp = st.ModTime()
+		} else if timestamp.Before(st.ModTime()) {
+			timestamp = st.ModTime()
+		}
+	}
+	return timestamp, nil
+}
+
+// Try to load a given file from the cache. Return "", nil if no cached file can
+// be found (or the file is stale), return the absolute path if there is a cache
+// and return an error on I/O errors.
+func cacheLoad(name string, sourceFiles []string) (string, error) {
+	cachepath := filepath.Join(goenv.Get("GOCACHE"), name)
+	cacheStat, err := os.Stat(cachepath)
+	if os.IsNotExist(err) {
+		return "", nil // does not exist
+	} else if err != nil {
+		return "", err // cannot stat cache file
+	}
+
+	sourceTimestamp, err := cacheTimestamp(sourceFiles)
+	if err != nil {
+		return "", err // cannot stat source files
+	}
+
+	if cacheStat.ModTime().After(sourceTimestamp) {
+		return cachepath, nil
+	} else {
+		os.Remove(cachepath)
+		// stale cache
+		return "", nil
+	}
+}
+
+// Store the file located at tmppath in the cache with the given name. The
+// tmppath may or may not be gone afterwards.
+func cacheStore(tmppath, name string, sourceFiles []string) (string, error) {
+	// get the last modified time
+	if len(sourceFiles) == 0 {
+		panic("cache: no source files")
+	}
+
+	// TODO: check the config key
+
+	dir := goenv.Get("GOCACHE")
+	err := os.MkdirAll(dir, 0777)
+	if err != nil {
+		return "", err
+	}
+	cachepath := filepath.Join(dir, name)
+	err = copyFile(tmppath, cachepath)
+	if err != nil {
+		return "", err
+	}
+	return cachepath, nil
+}
+
+// copyFile copies the given file from src to dst. It can copy over
+// a possibly already existing file at the destination.
+func copyFile(src, dst string) error {
+	inf, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+	defer inf.Close()
+	outpath := dst + ".tmp"
+	outf, err := os.Create(outpath)
+	if err != nil {
+		return err
+	}
+
+	_, err = io.Copy(outf, inf)
+	if err != nil {
+		os.Remove(outpath)
+		return err
+	}
+
+	err = outf.Close()
+	if err != nil {
+		return err
+	}
+
+	return os.Rename(dst+".tmp", dst)
+}

builder/builder_test.go

@@ -1,146 +0,0 @@
-package builder
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/tinygo-org/tinygo/compileopts"
-	"github.com/tinygo-org/tinygo/goenv"
-	"tinygo.org/x/go-llvm"
-)
-
-// Test whether the Clang generated "target-cpu" attribute matches the CPU
-// property in TinyGo target files.
-func TestClangAttributes(t *testing.T) {
-	var targetNames = []string{
-		// Please keep this list sorted!
-		"atmega328p",
-		"atmega1280",
-		"atmega1284p",
-		"atmega2560",
-		"attiny85",
-		"cortex-m0",
-		"cortex-m0plus",
-		"cortex-m3",
-		//"cortex-m33", // TODO: broken in LLVM 11, fixed in https://reviews.llvm.org/D90305
-		"cortex-m4",
-		"cortex-m7",
-		"esp32c3",
-		"fe310",
-		"gameboy-advance",
-		"k210",
-		"nintendoswitch",
-		"riscv-qemu",
-		"wasi",
-		"wasm",
-	}
-	if hasBuiltinTools {
-		// hasBuiltinTools is set when TinyGo is statically linked with LLVM,
-		// which also implies it was built with Xtensa support.
-		targetNames = append(targetNames, "esp32", "esp8266")
-	}
-	for _, targetName := range targetNames {
-		targetName := targetName
-		t.Run(targetName, func(t *testing.T) {
-			testClangAttributes(t, &compileopts.Options{Target: targetName})
-		})
-	}
-
-	for _, options := range []*compileopts.Options{
-		{GOOS: "linux", GOARCH: "386"},
-		{GOOS: "linux", GOARCH: "amd64"},
-		{GOOS: "linux", GOARCH: "arm"},
-		{GOOS: "linux", GOARCH: "arm64"},
-		{GOOS: "darwin", GOARCH: "amd64"},
-		{GOOS: "darwin", GOARCH: "arm64"},
-	} {
-		t.Run("GOOS="+options.GOOS+",GOARCH="+options.GOARCH, func(t *testing.T) {
-			testClangAttributes(t, options)
-		})
-	}
-}
-
-func testClangAttributes(t *testing.T, options *compileopts.Options) {
-	testDir := t.TempDir()
-	clangHeaderPath := getClangHeaderPath(goenv.Get("TINYGOROOT"))
-
-	ctx := llvm.NewContext()
-	defer ctx.Dispose()
-
-	target, err := compileopts.LoadTarget(options)
-	if err != nil {
-		t.Fatalf("could not load target: %s", err)
-	}
-	config := compileopts.Config{
-		Options:      options,
-		Target:       target,
-		ClangHeaders: clangHeaderPath,
-	}
-
-	// Create a very simple C input file.
-	srcpath := filepath.Join(testDir, "test.c")
-	err = ioutil.WriteFile(srcpath, []byte("int add(int a, int b) { return a + b; }"), 0o666)
-	if err != nil {
-		t.Fatalf("could not write target file %s: %s", srcpath, err)
-	}
-
-	// Compile this file using Clang.
-	outpath := filepath.Join(testDir, "test.bc")
-	flags := append([]string{"-c", "-emit-llvm", "-o", outpath, srcpath}, config.CFlags()...)
-	if config.GOOS() == "darwin" {
-		// Silence some warnings that happen when testing GOOS=darwin on
-		// something other than MacOS.
-		flags = append(flags, "-Wno-missing-sysroot", "-Wno-incompatible-sysroot")
-	}
-	err = runCCompiler(flags...)
-	if err != nil {
-		t.Fatalf("failed to compile %s: %s", srcpath, err)
-	}
-
-	// Read the resulting LLVM bitcode.
-	mod, err := ctx.ParseBitcodeFile(outpath)
-	if err != nil {
-		t.Fatalf("could not parse bitcode file %s: %s", outpath, err)
-	}
-	defer mod.Dispose()
-
-	// Check whether the LLVM target matches.
-	if mod.Target() != config.Triple() {
-		t.Errorf("target has LLVM triple %#v but Clang makes it LLVM triple %#v", config.Triple(), mod.Target())
-	}
-
-	// Check the "target-cpu"  string attribute of the add function.
-	add := mod.NamedFunction("add")
-	var cpu string
-	cpuAttr := add.GetStringAttributeAtIndex(-1, "target-cpu")
-	if !cpuAttr.IsNil() {
-		cpu = cpuAttr.GetStringValue()
-	}
-	if cpu != config.CPU() {
-		t.Errorf("target has CPU %#v but Clang makes it CPU %#v", config.CPU(), cpu)
-	}
-}
-
-// 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 := 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())
-}

builder/builtins.go

@@ -157,12 +157,10 @@ var aeabiBuiltins = []string{
 //
 // For more information, see: https://compiler-rt.llvm.org/
 var CompilerRT = Library{
-	name: "compiler-rt",
-	cflags: func(target, headerPath string) []string {
-		return []string{"-Werror", "-Wall", "-std=c11", "-nostdlibinc"}
-	},
+	name:      "compiler-rt",
+	cflags:    func() []string { return []string{"-Werror", "-Wall", "-std=c11", "-nostdlibinc"} },
 	sourceDir: "lib/compiler-rt/lib/builtins",
-	librarySources: func(target string) []string {
+	sources: func(target string) []string {
 		builtins := append([]string{}, genericBuiltins...) // copy genericBuiltins
 		if strings.HasPrefix(target, "arm") || strings.HasPrefix(target, "thumb") {
 			builtins = append(builtins, aeabiBuiltins...)

builder/cc.go

@@ -155,10 +155,6 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands
 
 	// Write dependencies file.
 	f, err := ioutil.TempFile(filepath.Dir(depfileCachePath), depfileName)
-	if err != nil {
-		return "", err
-	}
-
 	buf, err = json.MarshalIndent(dependencySlice, "", "\t")
 	if err != nil {
 		panic(err) // shouldn't happen

builder/commands.go

@@ -21,7 +21,6 @@ func init() {
 	commands["clang"] = []string{"clang-" + llvmMajor}
 	commands["ld.lld"] = []string{"ld.lld-" + llvmMajor, "ld.lld"}
 	commands["wasm-ld"] = []string{"wasm-ld-" + llvmMajor, "wasm-ld"}
-	commands["lldb"] = []string{"lldb-" + llvmMajor, "lldb"}
 	// Add the path to a Homebrew-installed LLVM for ease of use (no need to
 	// manually set $PATH).
 	if runtime.GOOS == "darwin" {
@@ -29,7 +28,6 @@ func init() {
 		commands["clang"] = append(commands["clang"], prefix+"clang-"+llvmMajor)
 		commands["ld.lld"] = append(commands["ld.lld"], prefix+"ld.lld")
 		commands["wasm-ld"] = append(commands["wasm-ld"], prefix+"wasm-ld")
-		commands["lldb"] = append(commands["lldb"], prefix+"lldb")
 	}
 	// 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
@@ -38,7 +36,6 @@ func init() {
 		commands["clang"] = append(commands["clang"], "clang", "C:\\Program Files\\LLVM\\bin\\clang.exe")
 		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")
-		commands["lldb"] = append(commands["lldb"], "C:\\Program Files\\LLVM\\bin\\lldb.exe")
 	}
 	// Add the path to LLVM installed from ports.
 	if runtime.GOOS == "freebsd" {
@@ -46,34 +43,23 @@ func init() {
 		commands["clang"] = append(commands["clang"], prefix+"clang-"+llvmMajor)
 		commands["ld.lld"] = append(commands["ld.lld"], prefix+"ld.lld")
 		commands["wasm-ld"] = append(commands["wasm-ld"], prefix+"wasm-ld")
-		commands["lldb"] = append(commands["lldb"], prefix+"lldb")
 	}
 }
 
-// LookupCommand looks up the executable name for a given LLVM tool such as
-// clang or wasm-ld. It returns the (relative) command that can be used to
-// invoke the tool or an error if it could not be found.
-func LookupCommand(name string) (string, error) {
-	for _, cmdName := range commands[name] {
-		_, err := exec.LookPath(cmdName)
+func execCommand(cmdNames []string, args ...string) error {
+	for _, cmdName := range cmdNames {
+		cmd := exec.Command(cmdName, args...)
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		err := cmd.Run()
 		if err != nil {
-			if errors.Unwrap(err) == exec.ErrNotFound {
+			if err, ok := err.(*exec.Error); ok && (err.Err == exec.ErrNotFound || err.Err.Error() == "file does not exist") {
+				// this command was not found, try the next
 				continue
 			}
-			return cmdName, err
+			return err
 		}
-		return cmdName, nil
+		return nil
 	}
-	return "", errors.New("%#v: none of these commands were found in your $PATH: " + strings.Join(commands[name], " "))
-}
-
-func execCommand(name string, args ...string) error {
-	name, err := LookupCommand(name)
-	if err != nil {
-		return err
-	}
-	cmd := exec.Command(name, args...)
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	return cmd.Run()
+	return errors.New("none of these commands were found in your $PATH: " + strings.Join(cmdNames, " "))
 }

builder/config.go

@@ -13,7 +13,7 @@ import (
 // uses the currently active GOPATH (from the goenv package) to determine the Go
 // version to use.
 func NewConfig(options *compileopts.Options) (*compileopts.Config, error) {
-	spec, err := compileopts.LoadTarget(options)
+	spec, err := compileopts.LoadTarget(options.Target)
 	if err != nil {
 		return nil, err
 	}
@@ -33,8 +33,8 @@ func NewConfig(options *compileopts.Options) (*compileopts.Config, error) {
 	if err != nil {
 		return nil, fmt.Errorf("could not read version from GOROOT (%v): %v", goroot, err)
 	}
-	if major != 1 || minor < 15 || minor > 17 {
-		return nil, fmt.Errorf("requires go version 1.15 through 1.17, got go%d.%d", major, minor)
+	if major != 1 || minor < 13 || minor > 16 {
+		return nil, fmt.Errorf("requires go version 1.13 through 1.16, got go%d.%d", major, minor)
 	}
 
 	clangHeaderPath := getClangHeaderPath(goenv.Get("TINYGOROOT"))

builder/esp.go

@@ -78,21 +78,11 @@ func makeESPFirmareImage(infile, outfile, format string) error {
 	// An added benefit is that we don't need to check for errors all the time.
 	outf := &bytes.Buffer{}
 
-	// Chip IDs. Source:
-	// https://github.com/espressif/esp-idf/blob/v4.3/components/bootloader_support/include/esp_app_format.h#L22
-	chip_id := map[string]uint16{
-		"esp32":   0x0000,
-		"esp32c3": 0x0005,
-	}[format]
-
 	// Image header.
 	switch format {
-	case "esp32", "esp32c3":
+	case "esp32":
 		// Header format:
-		// https://github.com/espressif/esp-idf/blob/v4.3/components/bootloader_support/include/esp_app_format.h#L71
-		// Note: not adding a SHA256 hash as the binary is modified by
-		// esptool.py while flashing and therefore the hash won't be valid
-		// anymore.
+		// https://github.com/espressif/esp-idf/blob/8fbb63c2/components/bootloader_support/include/esp_image_format.h#L58
 		binary.Write(outf, binary.LittleEndian, struct {
 			magic          uint8
 			segment_count  uint8
@@ -101,18 +91,15 @@ func makeESPFirmareImage(infile, outfile, format string) error {
 			entry_addr     uint32
 			wp_pin         uint8
 			spi_pin_drv    [3]uint8
-			chip_id        uint16
-			min_chip_rev   uint8
-			reserved       [8]uint8
+			reserved       [11]uint8
 			hash_appended  bool
 		}{
 			magic:          0xE9,
 			segment_count:  byte(len(segments)),
-			spi_mode:       2,    // ESP_IMAGE_SPI_MODE_DIO
-			spi_speed_size: 0x1f, // ESP_IMAGE_SPI_SPEED_80M, ESP_IMAGE_FLASH_SIZE_2MB
+			spi_mode:       0, // irrelevant, replaced by esptool when flashing
+			spi_speed_size: 0, // spi_speed, spi_size: replaced by esptool when flashing
 			entry_addr:     uint32(inf.Entry),
 			wp_pin:         0xEE, // disable WP pin
-			chip_id:        chip_id,
 			hash_appended:  true, // add a SHA256 hash
 		})
 	case "esp8266":
@@ -155,7 +142,7 @@ func makeESPFirmareImage(infile, outfile, format string) error {
 	outf.Write(make([]byte, 15-outf.Len()%16))
 	outf.WriteByte(checksum)
 
-	if format != "esp8266" {
+	if format == "esp32" {
 		// SHA256 hash (to protect against image corruption, not for security).
 		hash := sha256.Sum256(outf.Bytes())
 		outf.Write(hash[:])

builder/jobs.go

@@ -65,45 +65,19 @@ func (job *compileJob) readyToRun() bool {
 	return true
 }
 
-// runJobs runs the indicated job and all its dependencies. For every job, all
-// the dependencies are run first. It returns the error of the first job that
-// fails.
-// It runs all jobs in the order of the dependencies slice, depth-first.
-// Therefore, if some jobs are preferred to run before others, they should be
-// ordered as such in the job dependencies.
-func runJobs(job *compileJob, parallelism int) error {
-	if parallelism == 0 {
-		// Have a default, if the parallelism isn't set. This is useful for
-		// tests.
-		parallelism = runtime.NumCPU()
-	}
-	if parallelism < 1 {
-		return fmt.Errorf("-p flag must be at least 1, provided -p=%d", parallelism)
-	}
-
-	// Create a slice of jobs to run, where all dependencies are run in order.
-	jobs := []*compileJob{}
-	addedJobs := map[*compileJob]struct{}{}
-	var addJobs func(*compileJob)
-	addJobs = func(job *compileJob) {
-		if _, ok := addedJobs[job]; ok {
-			return
-		}
-		for _, dep := range job.dependencies {
-			addJobs(dep)
-		}
-		jobs = append(jobs, job)
-		addedJobs[job] = struct{}{}
-	}
-	addJobs(job)
-
+// runJobs runs all the jobs indicated in the jobs slice and returns the error
+// of the first job that fails to run.
+// It runs all jobs in the order of the slice, as long as all dependencies have
+// already run. Therefore, if some jobs are preferred to run before others, they
+// should be ordered as such in this slice.
+func runJobs(jobs []*compileJob) error {
 	// Create channels to communicate with the workers.
 	doneChan := make(chan *compileJob)
 	workerChan := make(chan *compileJob)
 	defer close(workerChan)
 
 	// Start a number of workers.
-	for i := 0; i < parallelism; i++ {
+	for i := 0; i < runtime.NumCPU(); i++ {
 		if jobRunnerDebug {
 			fmt.Println("## starting worker", i)
 		}
@@ -118,7 +92,7 @@ func runJobs(job *compileJob, parallelism int) error {
 	for {
 		// If there are free workers, try starting a new job (if one is
 		// available). If it succeeds, try again to fill the entire worker pool.
-		if numRunningJobs < parallelism {
+		if numRunningJobs < runtime.NumCPU() {
 			jobToRun := nextJob(jobs)
 			if jobToRun != nil {
 				// Start job.

builder/library.go

@@ -1,12 +1,10 @@
 package builder
 
 import (
-	"io/ioutil"
 	"os"
 	"path/filepath"
 	"strings"
 
-	"github.com/tinygo-org/tinygo/compileopts"
 	"github.com/tinygo-org/tinygo/goenv"
 )
 
@@ -16,87 +14,72 @@ type Library struct {
 	// The library name, such as compiler-rt or picolibc.
 	name string
 
-	// makeHeaders creates a header include dir for the library
-	makeHeaders func(target, includeDir string) error
-
-	// cflags returns the C flags specific to this library
-	cflags func(target, headerPath string) []string
+	cflags func() []string
 
 	// The source directory, relative to TINYGOROOT.
 	sourceDir string
 
 	// The source files, relative to sourceDir.
-	librarySources func(target string) []string
+	sources func(target string) []string
+}
 
-	// The source code for the crt1.o file, relative to sourceDir.
-	crt1Source 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.
-// The resulting directory may be stored in the provided tmpdir, which is
-// expected to be removed after the Load call.
-func (l *Library) Load(config *compileopts.Config, tmpdir string) (dir string, err error) {
-	job, err := l.load(config, tmpdir)
+// The resulting file is stored in the provided tmpdir, which is expected to be
+// removed after the Load call.
+func (l *Library) Load(target, tmpdir string) (path string, err error) {
+	job, err := l.load(target, "", tmpdir)
 	if err != nil {
 		return "", err
 	}
-	err = runJobs(job, config.Options.Parallelism)
-	return filepath.Dir(job.result), err
+	jobs := append([]*compileJob{job}, job.dependencies...)
+	err = runJobs(jobs)
+	return job.result, err
 }
 
 // load returns a compile job to build this library file for the given target
 // and CPU. It may return a dummy compileJob if the library build is already
-// cached. The path is stored as job.result but is only valid after the job has
-// been run.
+// cached. The path is stored as job.result but is only valid if the job and
+// job.dependencies have been run.
 // The provided tmpdir will be used to store intermediary files and possibly the
 // output archive file, it is expected to be removed after use.
-// As a side effect, this call creates the library header files if they didn't
-// exist yet.
-func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJob, err error) {
-	outdir, precompiled := config.LibcPath(l.name)
-	archiveFilePath := filepath.Join(outdir, "lib.a")
-	if precompiled {
+func (l *Library) load(target, cpu, tmpdir string) (job *compileJob, err error) {
+	// Try to load a precompiled library.
+	precompiledPath := filepath.Join(goenv.Get("TINYGOROOT"), "pkg", target, l.name+".a")
+	if _, err := os.Stat(precompiledPath); err == nil {
 		// Found a precompiled library for this OS/architecture. Return the path
 		// directly.
-		return dummyCompileJob(archiveFilePath), nil
+		return dummyCompileJob(precompiledPath), nil
+	}
+
+	var outfile string
+	if cpu != "" {
+		outfile = l.name + "-" + target + "-" + cpu + ".a"
+	} else {
+		outfile = l.name + "-" + target + ".a"
 	}
 
 	// Try to fetch this library from the cache.
-	if _, err := os.Stat(archiveFilePath); err == nil {
-		return dummyCompileJob(archiveFilePath), nil
+	if path, err := cacheLoad(outfile, l.sourcePaths(target)); path != "" || err != nil {
+		// Cache hit.
+		return dummyCompileJob(path), nil
 	}
 	// Cache miss, build it now.
 
-	// Create the destination directory where the components of this library
-	// (lib.a file, include directory) are placed.
-	outname := filepath.Base(outdir)
-	err = os.MkdirAll(filepath.Join(goenv.Get("GOCACHE"), outname), 0o777)
-	if err != nil {
-		// Could not create directory (and not because it already exists).
-		return nil, err
-	}
-
-	// Make headers if needed.
-	headerPath := filepath.Join(outdir, "include")
-	target := config.Triple()
-	if l.makeHeaders != nil {
-		if _, err = os.Stat(headerPath); err != nil {
-			temporaryHeaderPath, err := ioutil.TempDir(outdir, "include.tmp*")
-			if err != nil {
-				return nil, err
-			}
-			defer os.RemoveAll(temporaryHeaderPath)
-			err = l.makeHeaders(target, temporaryHeaderPath)
-			if err != nil {
-				return nil, err
-			}
-			err = os.Rename(temporaryHeaderPath, headerPath)
-			if err != nil {
-				return nil, err
-			}
-		}
-	}
-
 	remapDir := filepath.Join(os.TempDir(), "tinygo-"+l.name)
 	dir := filepath.Join(tmpdir, "build-lib-"+l.name)
 	err = os.Mkdir(dir, 0777)
@@ -108,16 +91,9 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 	// Note: -fdebug-prefix-map is necessary to make the output archive
 	// reproducible. Otherwise the temporary directory is stored in the archive
 	// itself, which varies each run.
-	args := append(l.cflags(target, headerPath), "-c", "-Oz", "-g", "-ffunction-sections", "-fdata-sections", "-Wno-macro-redefined", "--target="+target, "-fdebug-prefix-map="+dir+"="+remapDir)
-	cpu := config.CPU()
+	args := append(l.cflags(), "-c", "-Oz", "-g", "-ffunction-sections", "-fdata-sections", "-Wno-macro-redefined", "--target="+target, "-fdebug-prefix-map="+dir+"="+remapDir)
 	if cpu != "" {
-		// X86 has deprecated the -mcpu flag, so we need to use -march instead.
-		// However, ARM has not done this.
-		if strings.HasPrefix(target, "i386") || strings.HasPrefix(target, "x86_64") {
-			args = append(args, "-march="+cpu)
-		} else {
-			args = append(args, "-mcpu="+cpu)
-		}
+		args = append(args, "-mcpu="+cpu)
 	}
 	if strings.HasPrefix(target, "arm") || strings.HasPrefix(target, "thumb") {
 		args = append(args, "-fshort-enums", "-fomit-frame-pointer", "-mfloat-abi=soft")
@@ -132,39 +108,27 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 	// Create job to put all the object files in a single archive. This archive
 	// file is the (static) library file.
 	var objs []string
+	arpath := filepath.Join(dir, l.name+".a")
 	job = &compileJob{
-		description: "ar " + l.name + "/lib.a",
-		result:      filepath.Join(goenv.Get("GOCACHE"), outname, "lib.a"),
+		description: "ar " + l.name + ".a",
+		result:      arpath,
 		run: func(*compileJob) error {
 			// Create an archive of all object files.
-			f, err := ioutil.TempFile(outdir, "libc.a.tmp*")
-			if err != nil {
-				return err
-			}
-			err = makeArchive(f, objs)
-			if err != nil {
-				return err
-			}
-			err = f.Close()
+			err := makeArchive(arpath, objs)
 			if err != nil {
 				return err
 			}
 			// Store this archive in the cache.
-			return os.Rename(f.Name(), archiveFilePath)
+			_, err = cacheStore(arpath, outfile, l.sourcePaths(target))
+			return err
 		},
 	}
 
 	// Create jobs to compile all sources. These jobs are depended upon by the
 	// archive job above, so must be run first.
-	for _, path := range l.librarySources(target) {
-		// Strip leading "../" parts off the path.
-		cleanpath := path
-		for strings.HasPrefix(cleanpath, "../") {
-			cleanpath = cleanpath[3:]
-		}
-		srcpath := filepath.Join(goenv.Get("TINYGOROOT"), l.sourceDir, path)
-		objpath := filepath.Join(dir, cleanpath+".o")
-		os.MkdirAll(filepath.Dir(objpath), 0o777)
+	for _, srcpath := range l.sourcePaths(target) {
+		srcpath := srcpath // avoid concurrency issues by redefining inside the loop
+		objpath := filepath.Join(dir, filepath.Base(srcpath)+".o")
 		objs = append(objs, objpath)
 		job.dependencies = append(job.dependencies, &compileJob{
 			description: "compile " + srcpath,
@@ -181,31 +145,5 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 		})
 	}
 
-	// Create crt1.o job, if needed.
-	// Add this as a (fake) dependency to the ar file so it gets compiled.
-	// (It could be done in parallel with creating the ar file, but it probably
-	// won't make much of a difference in speed).
-	if l.crt1Source != "" {
-		srcpath := filepath.Join(goenv.Get("TINYGOROOT"), l.sourceDir, l.crt1Source)
-		job.dependencies = append(job.dependencies, &compileJob{
-			description: "compile " + srcpath,
-			run: func(*compileJob) error {
-				var compileArgs []string
-				compileArgs = append(compileArgs, args...)
-				tmpfile, err := ioutil.TempFile(outdir, "crt1.o.tmp*")
-				if err != nil {
-					return err
-				}
-				tmpfile.Close()
-				compileArgs = append(compileArgs, "-o", tmpfile.Name(), srcpath)
-				err = runCCompiler(compileArgs...)
-				if err != nil {
-					return &commandError{"failed to build", srcpath, err}
-				}
-				return os.Rename(tmpfile.Name(), filepath.Join(outdir, "crt1.o"))
-			},
-		})
-	}
-
 	return job, nil
 }

builder/musl.go

@@ -1,162 +0,0 @@
-package builder
-
-import (
-	"bytes"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-
-	"github.com/tinygo-org/tinygo/compileopts"
-	"github.com/tinygo-org/tinygo/goenv"
-)
-
-var Musl = Library{
-	name: "musl",
-	makeHeaders: func(target, includeDir string) error {
-		bits := filepath.Join(includeDir, "bits")
-		err := os.Mkdir(bits, 0777)
-		if err != nil {
-			return err
-		}
-
-		arch := compileopts.MuslArchitecture(target)
-		muslDir := filepath.Join(goenv.Get("TINYGOROOT"), "lib", "musl")
-
-		// Create the file alltypes.h.
-		f, err := os.Create(filepath.Join(bits, "alltypes.h"))
-		if err != nil {
-			return err
-		}
-		infiles := []string{
-			filepath.Join(muslDir, "arch", arch, "bits", "alltypes.h.in"),
-			filepath.Join(muslDir, "include", "alltypes.h.in"),
-		}
-		for _, infile := range infiles {
-			data, err := ioutil.ReadFile(infile)
-			if err != nil {
-				return err
-			}
-			lines := strings.Split(string(data), "\n")
-			for _, line := range lines {
-				if strings.HasPrefix(line, "TYPEDEF ") {
-					matches := regexp.MustCompile(`TYPEDEF (.*) ([^ ]*);`).FindStringSubmatch(line)
-					value := matches[1]
-					name := matches[2]
-					line = fmt.Sprintf("#if defined(__NEED_%s) && !defined(__DEFINED_%s)\ntypedef %s %s;\n#define __DEFINED_%s\n#endif\n", name, name, value, name, name)
-				}
-				if strings.HasPrefix(line, "STRUCT ") {
-					matches := regexp.MustCompile(`STRUCT * ([^ ]*) (.*);`).FindStringSubmatch(line)
-					name := matches[1]
-					value := matches[2]
-					line = fmt.Sprintf("#if defined(__NEED_struct_%s) && !defined(__DEFINED_struct_%s)\nstruct %s %s;\n#define __DEFINED_struct_%s\n#endif\n", name, name, name, value, name)
-				}
-				f.WriteString(line + "\n")
-			}
-		}
-		f.Close()
-
-		// Create the file syscall.h.
-		f, err = os.Create(filepath.Join(bits, "syscall.h"))
-		if err != nil {
-			return err
-		}
-		data, err := ioutil.ReadFile(filepath.Join(muslDir, "arch", arch, "bits", "syscall.h.in"))
-		if err != nil {
-			return err
-		}
-		_, err = f.Write(bytes.ReplaceAll(data, []byte("__NR_"), []byte("SYS_")))
-		if err != nil {
-			return err
-		}
-		f.Close()
-
-		return nil
-	},
-	cflags: func(target, headerPath string) []string {
-		arch := compileopts.MuslArchitecture(target)
-		muslDir := filepath.Join(goenv.Get("TINYGOROOT"), "lib/musl")
-		return []string{
-			"-std=c99",            // same as in musl
-			"-D_XOPEN_SOURCE=700", // same as in musl
-			// Musl triggers some warnings and we don't want to show any
-			// warnings while compiling (only errors or silence), so disable
-			// specific warnings that are triggered in musl.
-			"-Werror",
-			"-Wno-logical-op-parentheses",
-			"-Wno-bitwise-op-parentheses",
-			"-Wno-shift-op-parentheses",
-			"-Wno-ignored-attributes",
-			"-Wno-string-plus-int",
-			"-Qunused-arguments",
-			// Select include dirs. Don't include standard library includes
-			// (that would introduce host dependencies and other complications),
-			// but do include all the include directories expected by musl.
-			"-nostdlibinc",
-			"-I" + muslDir + "/arch/" + arch,
-			"-I" + muslDir + "/arch/generic",
-			"-I" + muslDir + "/src/include",
-			"-I" + muslDir + "/src/internal",
-			"-I" + headerPath,
-			"-I" + muslDir + "/include",
-		}
-	},
-	sourceDir: "lib/musl/src",
-	librarySources: func(target string) []string {
-		arch := compileopts.MuslArchitecture(target)
-		globs := []string{
-			"env/*.c",
-			"errno/*.c",
-			"exit/*.c",
-			"internal/defsysinfo.c",
-			"internal/libc.c",
-			"internal/syscall_ret.c",
-			"internal/vdso.c",
-			"malloc/*.c",
-			"mman/*.c",
-			"signal/*.c",
-			"stdio/*.c",
-			"string/*.c",
-			"thread/" + arch + "/*.s",
-			"thread/" + arch + "/*.c",
-			"thread/*.c",
-			"time/*.c",
-			"unistd/*.c",
-		}
-
-		var sources []string
-		seenSources := map[string]struct{}{}
-		basepath := goenv.Get("TINYGOROOT") + "/lib/musl/src/"
-		for _, pattern := range globs {
-			matches, err := filepath.Glob(basepath + pattern)
-			if err != nil {
-				// From the documentation:
-				// > Glob ignores file system errors such as I/O errors reading
-				// > directories. The only possible returned error is
-				// > ErrBadPattern, when pattern is malformed.
-				// So the only possible error is when the (statically defined)
-				// pattern is wrong. In other words, a programming bug.
-				panic("could not glob source dirs: " + err.Error())
-			}
-			for _, match := range matches {
-				relpath, err := filepath.Rel(basepath, match)
-				if err != nil {
-					// Not sure if this is even possible.
-					panic(err)
-				}
-				// Make sure architecture specific files override generic files.
-				id := strings.ReplaceAll(relpath, "/"+arch+"/", "/")
-				if _, ok := seenSources[id]; ok {
-					// Already seen this file, skipping this (generic) file.
-					continue
-				}
-				seenSources[id] = struct{}{}
-				sources = append(sources, relpath)
-			}
-		}
-		return sources
-	},
-	crt1Source: "../crt/crt1.c", // lib/musl/crt/crt1.c
-}

builder/picolibc.go

@@ -1,7 +1,6 @@
 package builder
 
 import (
-	"os"
 	"path/filepath"
 
 	"github.com/tinygo-org/tinygo/goenv"
@@ -11,134 +10,17 @@ import (
 // based on newlib.
 var Picolibc = Library{
 	name: "picolibc",
-	makeHeaders: func(target, includeDir string) error {
-		f, err := os.Create(filepath.Join(includeDir, "picolibc.h"))
-		if err != nil {
-			return err
-		}
-		return f.Close()
-	},
-	cflags: func(target, headerPath string) []string {
+	cflags: func() []string {
 		picolibcDir := filepath.Join(goenv.Get("TINYGOROOT"), "lib/picolibc/newlib/libc")
-		return []string{
-			"-Werror",
-			"-Wall",
-			"-std=gnu11",
-			"-D_COMPILING_NEWLIB",
-			"-DHAVE_ALIAS_ATTRIBUTE",
-			"-DTINY_STDIO",
-			"-nostdlibinc",
-			"-Xclang", "-internal-isystem", "-Xclang", picolibcDir + "/include",
-			"-I" + picolibcDir + "/tinystdio",
-			"-I" + headerPath,
-		}
+		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",
-	librarySources: func(target string) []string {
+	sources: func(target string) []string {
 		return picolibcSources
 	},
 }
 
 var picolibcSources = []string{
-	"../../../picolibc-stdio.c",
-
-	"tinystdio/asprintf.c",
-	"tinystdio/atod_engine.c",
-	"tinystdio/atod_ryu.c",
-	"tinystdio/atof_engine.c",
-	"tinystdio/atof_ryu.c",
-	//"tinystdio/atold_engine.c", // have_long_double and not long_double_equals_double
-	"tinystdio/clearerr.c",
-	"tinystdio/compare_exchange.c",
-	"tinystdio/dtoa_data.c",
-	"tinystdio/dtoa_engine.c",
-	"tinystdio/dtoa_ryu.c",
-	"tinystdio/ecvtbuf.c",
-	"tinystdio/ecvt.c",
-	"tinystdio/ecvt_data.c",
-	"tinystdio/ecvtfbuf.c",
-	"tinystdio/ecvtf.c",
-	"tinystdio/ecvtf_data.c",
-	"tinystdio/exchange.c",
-	//"tinystdio/fclose.c", // posix-io
-	"tinystdio/fcvtbuf.c",
-	"tinystdio/fcvt.c",
-	"tinystdio/fcvtfbuf.c",
-	"tinystdio/fcvtf.c",
-	"tinystdio/fdevopen.c",
-	//"tinystdio/fdopen.c", // posix-io
-	"tinystdio/feof.c",
-	"tinystdio/ferror.c",
-	"tinystdio/fflush.c",
-	"tinystdio/fgetc.c",
-	"tinystdio/fgets.c",
-	"tinystdio/fileno.c",
-	"tinystdio/filestrget.c",
-	"tinystdio/filestrputalloc.c",
-	"tinystdio/filestrput.c",
-	//"tinystdio/fopen.c", // posix-io
-	"tinystdio/fprintf.c",
-	"tinystdio/fputc.c",
-	"tinystdio/fputs.c",
-	"tinystdio/fread.c",
-	"tinystdio/fscanf.c",
-	"tinystdio/fseek.c",
-	"tinystdio/ftell.c",
-	"tinystdio/ftoa_data.c",
-	"tinystdio/ftoa_engine.c",
-	"tinystdio/ftoa_ryu.c",
-	"tinystdio/fwrite.c",
-	"tinystdio/gcvtbuf.c",
-	"tinystdio/gcvt.c",
-	"tinystdio/gcvtfbuf.c",
-	"tinystdio/gcvtf.c",
-	"tinystdio/getchar.c",
-	"tinystdio/gets.c",
-	"tinystdio/matchcaseprefix.c",
-	"tinystdio/perror.c",
-	//"tinystdio/posixiob.c", // posix-io
-	//"tinystdio/posixio.c", // posix-io
-	"tinystdio/printf.c",
-	"tinystdio/putchar.c",
-	"tinystdio/puts.c",
-	"tinystdio/ryu_divpow2.c",
-	"tinystdio/ryu_log10.c",
-	"tinystdio/ryu_log2pow5.c",
-	"tinystdio/ryu_pow5bits.c",
-	"tinystdio/ryu_table.c",
-	"tinystdio/ryu_umul128.c",
-	"tinystdio/scanf.c",
-	"tinystdio/setbuf.c",
-	"tinystdio/setvbuf.c",
-	//"tinystdio/sflags.c", // posix-io
-	"tinystdio/snprintf.c",
-	"tinystdio/snprintfd.c",
-	"tinystdio/snprintff.c",
-	"tinystdio/sprintf.c",
-	"tinystdio/sprintfd.c",
-	"tinystdio/sprintff.c",
-	"tinystdio/sscanf.c",
-	"tinystdio/strfromd.c",
-	"tinystdio/strfromf.c",
-	"tinystdio/strtod.c",
-	"tinystdio/strtod_l.c",
-	"tinystdio/strtof.c",
-	//"tinystdio/strtold.c",   // have_long_double and not long_double_equals_double
-	//"tinystdio/strtold_l.c", // have_long_double and not long_double_equals_double
-	"tinystdio/ungetc.c",
-	"tinystdio/vasprintf.c",
-	"tinystdio/vfiprintf.c",
-	"tinystdio/vfiscanf.c",
-	"tinystdio/vfprintf.c",
-	"tinystdio/vfprintff.c",
-	"tinystdio/vfscanf.c",
-	"tinystdio/vfscanff.c",
-	"tinystdio/vprintf.c",
-	"tinystdio/vscanf.c",
-	"tinystdio/vsnprintf.c",
-	"tinystdio/vsprintf.c",
-	"tinystdio/vsscanf.c",
-
 	"string/bcmp.c",
 	"string/bcopy.c",
 	"string/bzero.c",

builder/sizes.go

@@ -1,30 +1,16 @@
 package builder
 
 import (
-	"bytes"
-	"debug/dwarf"
 	"debug/elf"
-	"encoding/binary"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"regexp"
 	"sort"
 	"strings"
-
-	"github.com/aykevl/go-wasm"
-	"github.com/tinygo-org/tinygo/goenv"
 )
 
-// Set to true to print extra debug logs.
-const sizesDebug = false
-
 // programSize contains size statistics per package of a compiled program.
 type programSize struct {
-	Packages map[string]packageSize
+	Packages map[string]*packageSize
+	Sum      *packageSize
 	Code     uint64
-	ROData   uint64
 	Data     uint64
 	BSS      uint64
 }
@@ -40,16 +26,6 @@ func (ps *programSize) sortedPackageNames() []string {
 	return names
 }
 
-// Flash usage in regular microcontrollers.
-func (ps *programSize) Flash() uint64 {
-	return ps.Code + ps.ROData + ps.Data
-}
-
-// Static RAM usage in regular microcontrollers.
-func (ps *programSize) RAM() uint64 {
-	return ps.Data + ps.BSS
-}
-
 // packageSize contains the size of a package, calculated from the linked object
 // file.
 type packageSize struct {
@@ -69,520 +45,129 @@ func (ps *packageSize) RAM() uint64 {
 	return ps.Data + ps.BSS
 }
 
-// A mapping of a single chunk of code or data to a file path.
-type addressLine struct {
-	Address    uint64
-	Length     uint64 // length of this chunk
-	File       string // file path as stored in DWARF
-	IsVariable bool   // true if this is a variable (or constant), false if it is code
+type symbolList []elf.Symbol
+
+func (l symbolList) Len() int {
+	return len(l)
 }
 
-// Sections defined in the input file. This struct defines them in a
-// filetype-agnostic way but roughly follow the ELF types (.text, .data, .bss,
-// etc).
-type memorySection struct {
-	Type    memoryType
-	Address uint64
-	Size    uint64
-}
-
-type memoryType int
-
-const (
-	memoryCode memoryType = iota + 1
-	memoryData
-	memoryROData
-	memoryBSS
-	memoryStack
-)
-
-// Regular expressions to match particular symbol names. These are not stored as
-// DWARF variables because they have no mapping to source code global variables.
-var (
-	// Various globals that aren't a variable but nonetheless need to be stored
-	// somewhere:
-	//   alloc:  heap allocations during init interpretation
-	//   pack:   data created when storing a constant in an interface for example
-	//   string: buffer behind strings
-	packageSymbolRegexp = regexp.MustCompile(`\$(alloc|pack|string)(\.[0-9]+)?$`)
-
-	// Reflect sidetables. Created by the reflect lowering pass.
-	// See src/reflect/sidetables.go.
-	reflectDataRegexp = regexp.MustCompile(`^reflect\.[a-zA-Z]+Sidetable$`)
-)
-
-// readProgramSizeFromDWARF reads the source location for each line of code and
-// each variable in the program, as far as this is stored in the DWARF debug
-// information.
-func readProgramSizeFromDWARF(data *dwarf.Data, codeOffset uint64) ([]addressLine, error) {
-	r := data.Reader()
-	var lines []*dwarf.LineFile
-	var addresses []addressLine
-	for {
-		e, err := r.Next()
-		if err != nil {
-			return nil, err
-		}
-		if e == nil {
-			break
-		}
-		switch e.Tag {
-		case dwarf.TagCompileUnit:
-			// Found a compile unit.
-			// We can read the .debug_line section using it, which contains a
-			// mapping for most instructions to their file/line/column - even
-			// for inlined functions!
-			lr, err := data.LineReader(e)
-			if err != nil {
-				return nil, err
-			}
-			lines = lr.Files()
-			var lineEntry = dwarf.LineEntry{
-				EndSequence: true,
-			}
-
-			// Line tables are organized as sequences of line entries until an
-			// end sequence. A single line table can contain multiple such
-			// sequences. The last line entry is an EndSequence to indicate the
-			// end.
-			for {
-				// Read the next .debug_line entry.
-				prevLineEntry := lineEntry
-				err := lr.Next(&lineEntry)
-				if err != nil {
-					if err == io.EOF {
-						break
-					}
-					return nil, err
-				}
-
-				if prevLineEntry.EndSequence && lineEntry.Address == 0 {
-					// Tombstone value. This symbol has been removed, for
-					// example by the --gc-sections linker flag. It is still
-					// here in the debug information because the linker can't
-					// just remove this reference.
-					// Read until the next EndSequence so that this sequence is
-					// skipped.
-					// For more details, see (among others):
-					// https://reviews.llvm.org/D84825
-					for {
-						err := lr.Next(&lineEntry)
-						if err != nil {
-							return nil, err
-						}
-						if lineEntry.EndSequence {
-							break
-						}
-					}
-				}
-
-				if !prevLineEntry.EndSequence {
-					// The chunk describes the code from prevLineEntry to
-					// lineEntry.
-					line := addressLine{
-						Address: prevLineEntry.Address + codeOffset,
-						Length:  lineEntry.Address - prevLineEntry.Address,
-						File:    prevLineEntry.File.Name,
-					}
-					if line.Length != 0 {
-						addresses = append(addresses, line)
-					}
-				}
-			}
-		case dwarf.TagVariable:
-			// Global variable (or constant). Most of these are not actually
-			// stored in the binary, because they have been optimized out. Only
-			// the ones with a location are still present.
-			r.SkipChildren()
-
-			file := e.AttrField(dwarf.AttrDeclFile)
-			location := e.AttrField(dwarf.AttrLocation)
-			globalType := e.AttrField(dwarf.AttrType)
-			if file == nil || location == nil || globalType == nil {
-				// Doesn't contain the requested information.
-				continue
-			}
-
-			// Try to parse the location. While this could in theory be a very
-			// complex expression, usually it's just a DW_OP_addr opcode
-			// followed by an address.
-			locationCode := location.Val.([]uint8)
-			if locationCode[0] != 3 { // DW_OP_addr
-				continue
-			}
-			var addr uint64
-			switch len(locationCode) {
-			case 1 + 2:
-				addr = uint64(binary.LittleEndian.Uint16(locationCode[1:]))
-			case 1 + 4:
-				addr = uint64(binary.LittleEndian.Uint32(locationCode[1:]))
-			case 1 + 8:
-				addr = binary.LittleEndian.Uint64(locationCode[1:])
-			default:
-				continue // unknown address
-			}
-
-			// Parse the type of the global variable, which (importantly)
-			// contains the variable size. We're not interested in the type,
-			// only in the size.
-			typ, err := data.Type(globalType.Val.(dwarf.Offset))
-			if err != nil {
-				return nil, err
-			}
-
-			addresses = append(addresses, addressLine{
-				Address:    addr,
-				Length:     uint64(typ.Size()),
-				File:       lines[file.Val.(int64)].Name,
-				IsVariable: true,
-			})
-		default:
-			r.SkipChildren()
-		}
+func (l symbolList) Less(i, j int) bool {
+	bind_i := elf.ST_BIND(l[i].Info)
+	bind_j := elf.ST_BIND(l[j].Info)
+	if l[i].Value == l[j].Value && bind_i != elf.STB_WEAK && bind_j == elf.STB_WEAK {
+		// sort weak symbols after non-weak symbols
+		return true
 	}
-	return addresses, nil
+	return l[i].Value < l[j].Value
+}
+
+func (l symbolList) Swap(i, j int) {
+	l[i], l[j] = l[j], l[i]
 }
 
 // loadProgramSize calculate a program/data size breakdown of each package for a
 // given ELF file.
-// If the file doesn't contain DWARF debug information, the returned program
-// size will still have valid summaries but won't have complete size information
-// per package.
-func loadProgramSize(path string, packagePathMap map[string]string) (*programSize, error) {
-	// Open the binary file.
-	f, err := os.Open(path)
+func loadProgramSize(path string) (*programSize, error) {
+	file, err := elf.Open(path)
 	if err != nil {
 		return nil, err
 	}
-	defer f.Close()
+	defer file.Close()
 
-	// This stores all chunks of addresses found in the binary.
-	var addresses []addressLine
-
-	// Load the binary file, which could be in a number of file formats.
-	var sections []memorySection
-	if file, err := elf.NewFile(f); err == nil {
-		// Read DWARF information. The error is intentionally ignored.
-		data, _ := file.DWARF()
-		if data != nil {
-			addresses, err = readProgramSizeFromDWARF(data, 0)
-			if err != nil {
-				// However, _do_ report an error here. Something must have gone
-				// wrong while trying to parse DWARF data.
-				return nil, err
-			}
+	var sumCode uint64
+	var sumData uint64
+	var sumBSS uint64
+	for _, section := range file.Sections {
+		if section.Flags&elf.SHF_ALLOC == 0 {
+			continue
 		}
-
-		// Read the ELF symbols for some more chunks of location information.
-		// Some globals (such as strings) aren't stored in the DWARF debug
-		// information and therefore need to be obtained in a different way.
-		allSymbols, err := file.Symbols()
-		if err != nil {
-			return nil, err
+		if section.Type != elf.SHT_PROGBITS && section.Type != elf.SHT_NOBITS {
+			continue
 		}
-		for _, symbol := range allSymbols {
-			symType := elf.ST_TYPE(symbol.Info)
-			if symbol.Size == 0 {
-				continue
-			}
-			if symType != elf.STT_FUNC && symType != elf.STT_OBJECT && symType != elf.STT_NOTYPE {
-				continue
-			}
-			section := file.Sections[symbol.Section]
-			if section.Flags&elf.SHF_ALLOC == 0 {
-				continue
-			}
-			if packageSymbolRegexp.MatchString(symbol.Name) || reflectDataRegexp.MatchString(symbol.Name) {
-				addresses = append(addresses, addressLine{
-					Address:    symbol.Value,
-					Length:     symbol.Size,
-					File:       symbol.Name,
-					IsVariable: true,
-				})
-			}
+		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
+		} else if section.Flags&elf.SHF_WRITE != 0 {
+			sumData += section.Size
 		}
+	}
 
-		// Load allocated sections.
-		for _, section := range file.Sections {
-			if section.Flags&elf.SHF_ALLOC == 0 {
-				continue
-			}
-			if section.Type == elf.SHT_NOBITS {
-				if section.Name == ".stack" {
-					// TinyGo emits stack sections on microcontroller using the
-					// ".stack" name.
-					// This is a bit ugly, but I don't think there is a way to
-					// mark the stack section in a linker script.
-					sections = append(sections, memorySection{
-						Address: section.Addr,
-						Size:    section.Size,
-						Type:    memoryStack,
-					})
+	allSymbols, err := file.Symbols()
+	if err != nil {
+		return nil, err
+	}
+	symbols := make([]elf.Symbol, 0, len(allSymbols))
+	for _, symbol := range allSymbols {
+		symType := elf.ST_TYPE(symbol.Info)
+		if symbol.Size == 0 {
+			continue
+		}
+		if symType != elf.STT_FUNC && symType != elf.STT_OBJECT && symType != elf.STT_NOTYPE {
+			continue
+		}
+		if symbol.Section >= elf.SectionIndex(len(file.Sections)) {
+			continue
+		}
+		section := file.Sections[symbol.Section]
+		if section.Flags&elf.SHF_ALLOC == 0 {
+			continue
+		}
+		symbols = append(symbols, symbol)
+	}
+	sort.Sort(symbolList(symbols))
+
+	sizes := map[string]*packageSize{}
+	var lastSymbolValue uint64
+	for _, symbol := range symbols {
+		symType := elf.ST_TYPE(symbol.Info)
+		//bind := elf.ST_BIND(symbol.Info)
+		section := file.Sections[symbol.Section]
+		pkgName := "(bootstrap)"
+		symName := strings.TrimLeft(symbol.Name, "(*")
+		dot := strings.IndexByte(symName, '.')
+		if dot > 0 {
+			pkgName = symName[:dot]
+		}
+		pkgSize := sizes[pkgName]
+		if pkgSize == nil {
+			pkgSize = &packageSize{}
+			sizes[pkgName] = pkgSize
+		}
+		if lastSymbolValue != symbol.Value || lastSymbolValue == 0 {
+			if symType == elf.STT_FUNC {
+				pkgSize.Code += symbol.Size
+			} else if section.Flags&elf.SHF_WRITE != 0 {
+				if section.Type == elf.SHT_NOBITS {
+					pkgSize.BSS += symbol.Size
 				} else {
-					// Regular .bss section.
-					sections = append(sections, memorySection{
-						Address: section.Addr,
-						Size:    section.Size,
-						Type:    memoryBSS,
-					})
+					pkgSize.Data += symbol.Size
 				}
-			} else if section.Type == elf.SHT_PROGBITS && section.Flags&elf.SHF_EXECINSTR != 0 {
-				// .text
-				sections = append(sections, memorySection{
-					Address: section.Addr,
-					Size:    section.Size,
-					Type:    memoryCode,
-				})
-			} else if section.Type == elf.SHT_PROGBITS && section.Flags&elf.SHF_WRITE != 0 {
-				// .data
-				sections = append(sections, memorySection{
-					Address: section.Addr,
-					Size:    section.Size,
-					Type:    memoryData,
-				})
-			} else if section.Type == elf.SHT_PROGBITS {
-				// .rodata
-				sections = append(sections, memorySection{
-					Address: section.Addr,
-					Size:    section.Size,
-					Type:    memoryROData,
-				})
+			} else {
+				pkgSize.ROData += symbol.Size
 			}
 		}
-	} else if file, err := wasm.Parse(f); err == nil {
-		// File is in WebAssembly format.
-
-		// Put code at a very high address, so that it won't conflict with the
-		// data in the memory section.
-		const codeOffset = 0x8000_0000_0000_0000
-
-		// Read DWARF information. The error is intentionally ignored.
-		data, err := file.DWARF()
-		if data != nil {
-			addresses, err = readProgramSizeFromDWARF(data, codeOffset)
-			if err != nil {
-				// However, _do_ report an error here. Something must have gone
-				// wrong while trying to parse DWARF data.
-				return nil, err
-			}
-		}
-
-		var linearMemorySize uint64
-		for _, section := range file.Sections {
-			switch section := section.(type) {
-			case *wasm.SectionCode:
-				sections = append(sections, memorySection{
-					Address: codeOffset,
-					Size:    uint64(section.Size()),
-					Type:    memoryCode,
-				})
-			case *wasm.SectionMemory:
-				// This value is used when processing *wasm.SectionData (which
-				// always comes after *wasm.SectionMemory).
-				linearMemorySize = uint64(section.Entries[0].Limits.Initial) * 64 * 1024
-			case *wasm.SectionData:
-				// Data sections contain initial values for linear memory.
-				// First load the list of data sections, and sort them by
-				// address for easier processing.
-				var dataSections []memorySection
-				for _, entry := range section.Entries {
-					address, err := wasm.Eval(bytes.NewBuffer(entry.Offset))
-					if err != nil {
-						return nil, fmt.Errorf("could not parse data section address: %w", err)
-					}
-					dataSections = append(dataSections, memorySection{
-						Address: uint64(address[0].(int32)),
-						Size:    uint64(len(entry.Data)),
-						Type:    memoryData,
-					})
-				}
-				sort.Slice(dataSections, func(i, j int) bool {
-					return dataSections[i].Address < dataSections[j].Address
-				})
-
-				// And now add all data sections for linear memory.
-				// Parts that are in the slice of data sections are added as
-				// memoryData, and parts that are not are added as memoryBSS.
-				addr := uint64(0)
-				for _, section := range dataSections {
-					if addr < section.Address {
-						sections = append(sections, memorySection{
-							Address: addr,
-							Size:    section.Address - addr,
-							Type:    memoryBSS,
-						})
-					}
-					if addr > section.Address {
-						// This might be allowed, I'm not sure.
-						// It certainly doesn't make a lot of sense.
-						return nil, fmt.Errorf("overlapping data section")
-					}
-					// addr == section.Address
-					sections = append(sections, section)
-					addr = section.Address + section.Size
-				}
-				if addr < linearMemorySize {
-					sections = append(sections, memorySection{
-						Address: addr,
-						Size:    linearMemorySize - addr,
-						Type:    memoryBSS,
-					})
-				}
-			}
-		}
-	} else {
-		return nil, fmt.Errorf("could not parse file: %w", err)
+		lastSymbolValue = symbol.Value
 	}
 
-	// Sort the slice of address chunks by address, so that we can iterate
-	// through it to calculate section sizes.
-	sort.Slice(addresses, func(i, j int) bool {
-		if addresses[i].Address == addresses[j].Address {
-			// Very rarely, there might be duplicate addresses.
-			// If that happens, sort the largest chunks first.
-			return addresses[i].Length > addresses[j].Length
-		}
-		return addresses[i].Address < addresses[j].Address
-	})
-
-	// Now finally determine the binary/RAM size usage per package by going
-	// through each allocated section.
-	sizes := make(map[string]packageSize)
-	for _, section := range sections {
-		switch section.Type {
-		case memoryCode:
-			readSection(section, addresses, func(path string, size uint64, isVariable bool) {
-				field := sizes[path]
-				if isVariable {
-					field.ROData += size
-				} else {
-					field.Code += size
-				}
-				sizes[path] = field
-			}, packagePathMap)
-		case memoryROData:
-			readSection(section, addresses, func(path string, size uint64, isVariable bool) {
-				field := sizes[path]
-				field.ROData += size
-				sizes[path] = field
-			}, packagePathMap)
-		case memoryData:
-			readSection(section, addresses, func(path string, size uint64, isVariable bool) {
-				field := sizes[path]
-				field.Data += size
-				sizes[path] = field
-			}, packagePathMap)
-		case memoryBSS:
-			readSection(section, addresses, func(path string, size uint64, isVariable bool) {
-				field := sizes[path]
-				field.BSS += size
-				sizes[path] = field
-			}, packagePathMap)
-		case memoryStack:
-			// We store the C stack as a pseudo-package.
-			sizes["C stack"] = packageSize{
-				BSS: section.Size,
-			}
-		}
-	}
-
-	// ...and summarize the results.
-	program := &programSize{
-		Packages: sizes,
-	}
+	sum := &packageSize{}
 	for _, pkg := range sizes {
-		program.Code += pkg.Code
-		program.ROData += pkg.ROData
-		program.Data += pkg.Data
-		program.BSS += pkg.BSS
+		sum.Code += pkg.Code
+		sum.ROData += pkg.ROData
+		sum.Data += pkg.Data
+		sum.BSS += pkg.BSS
 	}
-	return program, nil
-}
 
-// readSection determines for each byte in this section to which package it
-// belongs. It reports this usage through the addSize callback.
-func readSection(section memorySection, addresses []addressLine, addSize func(string, uint64, bool), packagePathMap map[string]string) {
-	// The addr variable tracks at which address we are while going through this
-	// section. We start at the beginning.
-	addr := section.Address
-	sectionEnd := section.Address + section.Size
-	for _, line := range addresses {
-		if line.Address < section.Address || line.Address+line.Length >= sectionEnd {
-			// Check that this line is entirely within the section.
-			// Don't bother dealing with line entries that cross sections (that
-			// seems rather unlikely anyway).
-			continue
-		}
-		if addr < line.Address {
-			// There is a gap: there is a space between the current and the
-			// previous line entry.
-			addSize("(unknown)", line.Address-addr, false)
-			if sizesDebug {
-				fmt.Printf("%08x..%08x %4d: unknown (gap)\n", addr, line.Address, line.Address-addr)
-			}
-		}
-		if addr > line.Address+line.Length {
-			// The current line is already covered by a previous line entry.
-			// Simply skip it.
-			continue
-		}
-		// At this point, addr falls within the current line (probably at the
-		// start).
-		length := line.Length
-		if addr > line.Address {
-			// There is some overlap: the previous line entry already covered
-			// part of this line entry. So reduce the length to add to the
-			// remaining bit of the line entry.
-			length = line.Length - (addr - line.Address)
-		}
-		// Finally, mark this chunk of memory as used by the given package.
-		addSize(findPackagePath(line.File, packagePathMap), length, line.IsVariable)
-		addr = line.Address + line.Length
-	}
-	if addr < sectionEnd {
-		// There is a gap at the end of the section.
-		addSize("(unknown)", sectionEnd-addr, false)
-		if sizesDebug {
-			fmt.Printf("%08x..%08x %4d: unknown (end)\n", addr, sectionEnd, sectionEnd-addr)
-		}
-	}
-}
-
-// findPackagePath returns the Go package (or a pseudo package) for the given
-// path. It uses some heuristics, for example for some C libraries.
-func findPackagePath(path string, packagePathMap map[string]string) string {
-	// Check whether this path is part of one of the compiled packages.
-	packagePath, ok := packagePathMap[filepath.Dir(path)]
-	if !ok {
-		if strings.HasPrefix(path, filepath.Join(goenv.Get("TINYGOROOT"), "lib")) {
-			// Emit C libraries (in the lib subdirectory of TinyGo) as a single
-			// package, with a "C" prefix. For example: "C compiler-rt" for the
-			// compiler runtime library from LLVM.
-			packagePath = "C " + strings.Split(strings.TrimPrefix(path, filepath.Join(goenv.Get("TINYGOROOT"), "lib")), string(os.PathSeparator))[1]
-		} else if packageSymbolRegexp.MatchString(path) {
-			// Parse symbol names like main$alloc or runtime$string.
-			packagePath = path[:strings.LastIndex(path, "$")]
-		} else if reflectDataRegexp.MatchString(path) {
-			// Parse symbol names like reflect.structTypesSidetable.
-			packagePath = "Go reflect data"
-		} else if path == "<Go interface assert>" {
-			// Interface type assert, generated by the interface lowering pass.
-			packagePath = "Go interface assert"
-		} else if path == "<Go interface method>" {
-			// Interface method wrapper (switch over all concrete types),
-			// generated by the interface lowering pass.
-			packagePath = "Go interface method"
-		} else if path == "<stdin>" {
-			// This can happen when the source code (in Go) doesn't have a
-			// source file and uses "-" as the location. Somewhere this is
-			// converted to "<stdin>".
-			// Convert this back to the "-" string. Eventually, this should be
-			// fixed in the compiler.
-			packagePath = "-"
-		} else {
-			// This is some other path. Not sure what it is, so just emit its directory.
-			packagePath = filepath.Dir(path) // fallback
-		}
-	}
-	return packagePath
+	return &programSize{Packages: sizes, Code: sumCode, Data: sumData, BSS: sumBSS, Sum: sum}, nil
 }

builder/tools.go

@@ -24,7 +24,7 @@ func runCCompiler(flags ...string) error {
 	}
 
 	// Compile this with an external invocation of the Clang compiler.
-	return execCommand("clang", flags...)
+	return execCommand(commands["clang"], flags...)
 }
 
 // link invokes a linker with the given name and flags.
@@ -38,8 +38,8 @@ func link(linker string, flags ...string) error {
 	}
 
 	// Fall back to external command.
-	if _, ok := commands[linker]; ok {
-		return execCommand(linker, flags...)
+	if cmdNames, ok := commands[linker]; ok {
+		return execCommand(cmdNames, flags...)
 	}
 
 	cmd := exec.Command(linker, flags...)

builder/uf2.go

@@ -141,13 +141,11 @@ func split(input []byte, limit int) [][]byte {
 	var block []byte
 	output := make([][]byte, 0, len(input)/limit+1)
 	for len(input) >= limit {
-		// add all blocks
 		block, input = input[:limit], input[limit:]
 		output = append(output, block)
 	}
 	if len(input) > 0 {
-		// add remaining block (that isn't full sized)
-		output = append(output, input)
+		output = append(output, input[:len(input)])
 	}
 	return output
 }

cgo/cgo.go

@@ -25,19 +25,12 @@ import (
 	"golang.org/x/tools/go/ast/astutil"
 )
 
-// Version of the cgo package. It must be incremented whenever the cgo package
-// is changed in a way that affects the output so that cached package builds
-// will be invalidated.
-// This version is independent of the TinyGo version number.
-const Version = 1 // last change: run libclang once per Go file
-
 // cgoPackage holds all CGo-related information of a package.
 type cgoPackage struct {
 	generated       *ast.File
 	generatedPos    token.Pos
 	errors          []error
-	currentDir      string // current working directory
-	packageDir      string // full path to the package to process
+	dir             string
 	fset            *token.FileSet
 	tokenFiles      map[string]*token.File
 	missingSymbols  map[string]struct{}
@@ -131,17 +124,17 @@ var cgoAliases = map[string]string{
 // builtinAliases are handled specially because they only exist on the Go side
 // of CGo, not on the CGo side (they're prefixed with "_Cgo_" there).
 var builtinAliases = map[string]struct{}{
-	"char":      {},
-	"schar":     {},
-	"uchar":     {},
-	"short":     {},
-	"ushort":    {},
-	"int":       {},
-	"uint":      {},
-	"long":      {},
-	"ulong":     {},
-	"longlong":  {},
-	"ulonglong": {},
+	"char":      struct{}{},
+	"schar":     struct{}{},
+	"uchar":     struct{}{},
+	"short":     struct{}{},
+	"ushort":    struct{}{},
+	"int":       struct{}{},
+	"uint":      struct{}{},
+	"long":      struct{}{},
+	"ulong":     struct{}{},
+	"longlong":  struct{}{},
+	"ulonglong": struct{}{},
 }
 
 // cgoTypes lists some C types with ambiguous sizes that must be retrieved
@@ -165,13 +158,12 @@ typedef unsigned long long  _Cgo_ulonglong;
 // Process extracts `import "C"` statements from the AST, parses the comment
 // with libclang, and modifies the AST to use this information. It returns a
 // newly created *ast.File that should be added to the list of to-be-parsed
-// files, the CGo header snippets that should be compiled (for inline
-// functions), the CFLAGS and LDFLAGS found in #cgo lines, and a map of file
-// hashes of the accessed C header files. If there is one or more error, it
-// returns these in the []error slice but still modifies the AST.
-func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string) (*ast.File, []string, []string, []string, map[string][]byte, []error) {
+// files, the CFLAGS and LDFLAGS found in #cgo lines, and a map of file hashes
+// of the accessed C header files. If there is one or more error, it returns
+// these in the []error slice but still modifies the AST.
+func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string) (*ast.File, []string, []string, map[string][]byte, []error) {
 	p := &cgoPackage{
-		currentDir:      dir,
+		dir:             dir,
 		fset:            fset,
 		tokenFiles:      map[string]*token.File{},
 		missingSymbols:  map[string]struct{}{},
@@ -192,14 +184,14 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 	// Find the absolute path for this package.
 	packagePath, err := filepath.Abs(fset.File(files[0].Pos()).Name())
 	if err != nil {
-		return nil, nil, nil, nil, nil, []error{
+		return nil, nil, nil, nil, []error{
 			scanner.Error{
 				Pos: fset.Position(files[0].Pos()),
 				Msg: "cgo: cannot find absolute path: " + err.Error(), // TODO: wrap this error
 			},
 		}
 	}
-	p.packageDir = filepath.Dir(packagePath)
+	packagePath = filepath.Dir(packagePath)
 
 	// Construct a new in-memory AST for CGo declarations of this package.
 	unsafeImport := &ast.ImportSpec{
@@ -232,7 +224,7 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 				Specs: []ast.Spec{
 					&ast.ValueSpec{
 						Names: []*ast.Ident{
-							{
+							&ast.Ident{
 								Name: "_",
 								Obj: &ast.Object{
 									Kind: ast.Var,
@@ -263,10 +255,9 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 		p.missingSymbols["_Cgo_"+name] = struct{}{}
 	}
 
-	// Find `import "C"` C fragments in the file.
-	cgoHeaders := make([]string, len(files)) // combined CGo header fragment for each file
-	for i, f := range files {
-		var cgoHeader string
+	// Find `import "C"` statements in the file.
+	var statements []*ast.GenDecl
+	for _, f := range files {
 		for i := 0; i < len(f.Decls); i++ {
 			decl := f.Decls[i]
 			genDecl, ok := decl.(*ast.GenDecl)
@@ -290,40 +281,105 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 				continue
 			}
 
+			// Found a CGo statement.
+			statements = append(statements, genDecl)
+
 			// Remove this import declaration.
 			f.Decls = append(f.Decls[:i], f.Decls[i+1:]...)
 			i--
-
-			if genDecl.Doc == nil {
-				continue
-			}
-
-			// Iterate through all parts of the CGo header. Note that every //
-			// line is a new comment.
-			position := fset.Position(genDecl.Doc.Pos())
-			fragment := fmt.Sprintf("# %d %#v\n", position.Line, position.Filename)
-			for _, comment := range genDecl.Doc.List {
-				// Find all #cgo lines, extract and use their contents, and
-				// replace the lines with spaces (to preserve locations).
-				c := p.parseCGoPreprocessorLines(comment.Text, comment.Slash)
-
-				// Change the comment (which is still in Go syntax, with // and
-				// /* */ ) to a regular string by replacing the start/end
-				// markers of comments with spaces.
-				// It is similar to the Text() method but differs in that it
-				// doesn't strip anything and tries to keep all offsets correct
-				// by adding spaces and newlines where necessary.
-				if c[1] == '/' { /* comment */
-					c = "  " + c[2:]
-				} else { // comment
-					c = "  " + c[2:len(c)-2]
-				}
-				fragment += c + "\n"
-			}
-			cgoHeader += fragment
 		}
 
-		cgoHeaders[i] = cgoHeader
+		// Print the AST, for debugging.
+		//ast.Print(fset, f)
+	}
+
+	// Find all #cgo lines.
+	for _, genDecl := range statements {
+		if genDecl.Doc == nil {
+			continue
+		}
+		for _, comment := range genDecl.Doc.List {
+			for {
+				// Extract the #cgo line, and replace it with spaces.
+				// Replacing with spaces makes sure that error locations are
+				// still correct, while not interfering with parsing in any way.
+				lineStart := strings.Index(comment.Text, "#cgo ")
+				if lineStart < 0 {
+					break
+				}
+				lineLen := strings.IndexByte(comment.Text[lineStart:], '\n')
+				if lineLen < 0 {
+					lineLen = len(comment.Text) - lineStart
+				}
+				lineEnd := lineStart + lineLen
+				line := comment.Text[lineStart:lineEnd]
+				spaces := make([]byte, len(line))
+				for i := range spaces {
+					spaces[i] = ' '
+				}
+				lenBefore := len(comment.Text)
+				comment.Text = comment.Text[:lineStart] + string(spaces) + comment.Text[lineEnd:]
+				if len(comment.Text) != lenBefore {
+					println(lenBefore, len(comment.Text))
+					panic("length of preamble changed!")
+				}
+
+				// Get the text before the colon in the #cgo directive.
+				colon := strings.IndexByte(line, ':')
+				if colon < 0 {
+					p.addErrorAfter(comment.Slash, comment.Text[:lineStart], "missing colon in #cgo line")
+					continue
+				}
+
+				// Extract the fields before the colon. These fields are a list
+				// of build tags and the C environment variable.
+				fields := strings.Fields(line[4:colon])
+				if len(fields) == 0 {
+					p.addErrorAfter(comment.Slash, comment.Text[:lineStart+colon-1], "invalid #cgo line")
+					continue
+				}
+
+				if len(fields) > 1 {
+					p.addErrorAfter(comment.Slash, comment.Text[:lineStart+5], "not implemented: build constraints in #cgo line")
+					continue
+				}
+
+				name := fields[len(fields)-1]
+				value := line[colon+1:]
+				switch name {
+				case "CFLAGS":
+					flags, err := shlex.Split(value)
+					if err != nil {
+						// TODO: find the exact location where the error happened.
+						p.addErrorAfter(comment.Slash, comment.Text[:lineStart+colon+1], "failed to parse flags in #cgo line: "+err.Error())
+						continue
+					}
+					if err := checkCompilerFlags(name, flags); err != nil {
+						p.addErrorAfter(comment.Slash, comment.Text[:lineStart+colon+1], err.Error())
+						continue
+					}
+					makePathsAbsolute(flags, packagePath)
+					p.cflags = append(p.cflags, flags...)
+				case "LDFLAGS":
+					flags, err := shlex.Split(value)
+					if err != nil {
+						// TODO: find the exact location where the error happened.
+						p.addErrorAfter(comment.Slash, comment.Text[:lineStart+colon+1], "failed to parse flags in #cgo line: "+err.Error())
+						continue
+					}
+					if err := checkLinkerFlags(name, flags); err != nil {
+						p.addErrorAfter(comment.Slash, comment.Text[:lineStart+colon+1], err.Error())
+						continue
+					}
+					makePathsAbsolute(flags, packagePath)
+					p.ldflags = append(p.ldflags, flags...)
+				default:
+					startPos := strings.LastIndex(line[4:colon], name) + 4
+					p.addErrorAfter(comment.Slash, comment.Text[:lineStart+startPos], "invalid #cgo line: "+name)
+					continue
+				}
+			}
+		}
 	}
 
 	// Define CFlags that will be used while parsing the package.
@@ -333,9 +389,16 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 	cflagsForCGo := append([]string{"-D_FORTIFY_SOURCE=0"}, cflags...)
 	cflagsForCGo = append(cflagsForCGo, p.cflags...)
 
-	// Process CGo imports for each file.
-	for i, f := range files {
-		p.parseFragment(cgoHeaders[i]+cgoTypes, cflagsForCGo, filepath.Base(fset.File(f.Pos()).Name()))
+	// Process all CGo imports.
+	for _, genDecl := range statements {
+		cgoComment := genDecl.Doc.Text()
+
+		pos := genDecl.Pos()
+		if genDecl.Doc != nil {
+			pos = genDecl.Doc.Pos()
+		}
+		position := fset.PositionFor(pos, true)
+		p.parseFragment(cgoComment+cgoTypes, cflagsForCGo, position.Filename, position.Line)
 	}
 
 	// Declare functions found by libclang.
@@ -370,18 +433,18 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 	// Print the newly generated in-memory AST, for debugging.
 	//ast.Print(fset, p.generated)
 
-	return p.generated, cgoHeaders, p.cflags, p.ldflags, p.visitedFiles, p.errors
+	return p.generated, p.cflags, p.ldflags, p.visitedFiles, 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 (p *cgoPackage) makePathsAbsolute(args []string) {
+func makePathsAbsolute(args []string, packagePath string) {
 	nextIsPath := false
 	for i, arg := range args {
 		if nextIsPath {
 			if !filepath.IsAbs(arg) {
-				args[i] = filepath.Join(p.packageDir, arg)
+				args[i] = filepath.Join(packagePath, arg)
 			}
 		}
 		if arg == "-I" || arg == "-L" {
@@ -391,95 +454,12 @@ func (p *cgoPackage) makePathsAbsolute(args []string) {
 		if strings.HasPrefix(arg, "-I") || strings.HasPrefix(arg, "-L") {
 			path := arg[2:]
 			if !filepath.IsAbs(path) {
-				args[i] = arg[:2] + filepath.Join(p.packageDir, path)
+				args[i] = arg[:2] + filepath.Join(packagePath, path)
 			}
 		}
 	}
 }
 
-// parseCGoPreprocessorLines reads #cgo pseudo-preprocessor lines in the source
-// text (import "C" fragment), stores their information such as CFLAGS, and
-// returns the same text but with those #cgo lines replaced by spaces (to keep
-// position offsets the same).
-func (p *cgoPackage) parseCGoPreprocessorLines(text string, pos token.Pos) string {
-	for {
-		// Extract the #cgo line, and replace it with spaces.
-		// Replacing with spaces makes sure that error locations are
-		// still correct, while not interfering with parsing in any way.
-		lineStart := strings.Index(text, "#cgo ")
-		if lineStart < 0 {
-			break
-		}
-		lineLen := strings.IndexByte(text[lineStart:], '\n')
-		if lineLen < 0 {
-			lineLen = len(text) - lineStart
-		}
-		lineEnd := lineStart + lineLen
-		line := text[lineStart:lineEnd]
-		spaces := make([]byte, len(line))
-		for i := range spaces {
-			spaces[i] = ' '
-		}
-		text = text[:lineStart] + string(spaces) + text[lineEnd:]
-
-		// Get the text before the colon in the #cgo directive.
-		colon := strings.IndexByte(line, ':')
-		if colon < 0 {
-			p.addErrorAfter(pos, text[:lineStart], "missing colon in #cgo line")
-			continue
-		}
-
-		// Extract the fields before the colon. These fields are a list
-		// of build tags and the C environment variable.
-		fields := strings.Fields(line[4:colon])
-		if len(fields) == 0 {
-			p.addErrorAfter(pos, text[:lineStart+colon-1], "invalid #cgo line")
-			continue
-		}
-
-		if len(fields) > 1 {
-			p.addErrorAfter(pos, text[:lineStart+5], "not implemented: build constraints in #cgo line")
-			continue
-		}
-
-		name := fields[len(fields)-1]
-		value := line[colon+1:]
-		switch name {
-		case "CFLAGS":
-			flags, err := shlex.Split(value)
-			if err != nil {
-				// TODO: find the exact location where the error happened.
-				p.addErrorAfter(pos, text[:lineStart+colon+1], "failed to parse flags in #cgo line: "+err.Error())
-				continue
-			}
-			if err := checkCompilerFlags(name, flags); err != nil {
-				p.addErrorAfter(pos, text[:lineStart+colon+1], err.Error())
-				continue
-			}
-			p.makePathsAbsolute(flags)
-			p.cflags = append(p.cflags, flags...)
-		case "LDFLAGS":
-			flags, err := shlex.Split(value)
-			if err != nil {
-				// TODO: find the exact location where the error happened.
-				p.addErrorAfter(pos, text[:lineStart+colon+1], "failed to parse flags in #cgo line: "+err.Error())
-				continue
-			}
-			if err := checkLinkerFlags(name, flags); err != nil {
-				p.addErrorAfter(pos, text[:lineStart+colon+1], err.Error())
-				continue
-			}
-			p.makePathsAbsolute(flags)
-			p.ldflags = append(p.ldflags, flags...)
-		default:
-			startPos := strings.LastIndex(line[4:colon], name) + 4
-			p.addErrorAfter(pos, text[:lineStart+startPos], "invalid #cgo line: "+name)
-			continue
-		}
-	}
-	return text
-}
-
 // addFuncDecls adds the C function declarations found by libclang in the
 // comment above the `import "C"` statement.
 func (p *cgoPackage) addFuncDecls() {
@@ -514,7 +494,7 @@ func (p *cgoPackage) addFuncDecls() {
 		if fn.variadic {
 			decl.Doc = &ast.CommentGroup{
 				List: []*ast.Comment{
-					{
+					&ast.Comment{
 						Slash: fn.pos,
 						Text:  "//go:variadic",
 					},
@@ -525,7 +505,7 @@ func (p *cgoPackage) addFuncDecls() {
 		for i, arg := range fn.args {
 			args[i] = &ast.Field{
 				Names: []*ast.Ident{
-					{
+					&ast.Ident{
 						NamePos: fn.pos,
 						Name:    arg.name,
 						Obj: &ast.Object{
@@ -573,7 +553,7 @@ func (p *cgoPackage) addFuncPtrDecls() {
 			Name: "C." + name + "$funcaddr",
 		}
 		valueSpec := &ast.ValueSpec{
-			Names: []*ast.Ident{{
+			Names: []*ast.Ident{&ast.Ident{
 				NamePos: fn.pos,
 				Name:    "C." + name + "$funcaddr",
 				Obj:     obj,
@@ -623,7 +603,7 @@ func (p *cgoPackage) addConstDecls() {
 			Name: "C." + name,
 		}
 		valueSpec := &ast.ValueSpec{
-			Names: []*ast.Ident{{
+			Names: []*ast.Ident{&ast.Ident{
 				NamePos: constVal.pos,
 				Name:    "C." + name,
 				Obj:     obj,
@@ -664,7 +644,7 @@ func (p *cgoPackage) addVarDecls() {
 			Name: "C." + name,
 		}
 		valueSpec := &ast.ValueSpec{
-			Names: []*ast.Ident{{
+			Names: []*ast.Ident{&ast.Ident{
 				NamePos: global.pos,
 				Name:    "C." + name,
 				Obj:     obj,
@@ -865,9 +845,9 @@ func (p *cgoPackage) makeUnionField(typ *elaboratedTypeInfo) *ast.StructType {
 		Struct: typ.typeExpr.Struct,
 		Fields: &ast.FieldList{
 			Opening: typ.typeExpr.Fields.Opening,
-			List: []*ast.Field{{
+			List: []*ast.Field{&ast.Field{
 				Names: []*ast.Ident{
-					{
+					&ast.Ident{
 						NamePos: typ.typeExpr.Fields.Opening,
 						Name:    "$union",
 					},
@@ -948,9 +928,9 @@ func (p *cgoPackage) createUnionAccessor(field *ast.Field, typeName string) {
 		Recv: &ast.FieldList{
 			Opening: pos,
 			List: []*ast.Field{
-				{
+				&ast.Field{
 					Names: []*ast.Ident{
-						{
+						&ast.Ident{
 							NamePos: pos,
 							Name:    "union",
 						},
@@ -979,7 +959,7 @@ func (p *cgoPackage) createUnionAccessor(field *ast.Field, typeName string) {
 			},
 			Results: &ast.FieldList{
 				List: []*ast.Field{
-					{
+					&ast.Field{
 						Type: &ast.StarExpr{
 							Star: pos,
 							X:    field.Type,
@@ -1058,9 +1038,9 @@ func (p *cgoPackage) createBitfieldGetter(bitfield bitfieldInfo, typeName string
 		Recv: &ast.FieldList{
 			Opening: bitfield.pos,
 			List: []*ast.Field{
-				{
+				&ast.Field{
 					Names: []*ast.Ident{
-						{
+						&ast.Ident{
 							NamePos: bitfield.pos,
 							Name:    "s",
 							Obj: &ast.Object{
@@ -1094,7 +1074,7 @@ func (p *cgoPackage) createBitfieldGetter(bitfield bitfieldInfo, typeName string
 			},
 			Results: &ast.FieldList{
 				List: []*ast.Field{
-					{
+					&ast.Field{
 						Type: bitfield.field.Type,
 					},
 				},
@@ -1211,9 +1191,9 @@ func (p *cgoPackage) createBitfieldSetter(bitfield bitfieldInfo, typeName string
 		Recv: &ast.FieldList{
 			Opening: bitfield.pos,
 			List: []*ast.Field{
-				{
+				&ast.Field{
 					Names: []*ast.Ident{
-						{
+						&ast.Ident{
 							NamePos: bitfield.pos,
 							Name:    "s",
 							Obj: &ast.Object{
@@ -1244,9 +1224,9 @@ func (p *cgoPackage) createBitfieldSetter(bitfield bitfieldInfo, typeName string
 			Params: &ast.FieldList{
 				Opening: bitfield.pos,
 				List: []*ast.Field{
-					{
+					&ast.Field{
 						Names: []*ast.Ident{
-							{
+							&ast.Ident{
 								NamePos: bitfield.pos,
 								Name:    "value",
 								Obj:     nil,

cgo/cgo_test.go

@@ -12,6 +12,7 @@ import (
 	"go/types"
 	"io/ioutil"
 	"path/filepath"
+	"regexp"
 	"runtime"
 	"strings"
 	"testing"
@@ -24,11 +25,19 @@ var flagUpdate = flag.Bool("update", false, "Update images based on test output.
 // platforms and Go versions.
 func normalizeResult(result string) string {
 	actual := strings.ReplaceAll(result, "\r\n", "\n")
+
+	// Make sure all functions are wrapped, even those that would otherwise be
+	// single-line functions. This is necessary because Go 1.14 changed the way
+	// such functions are wrapped and it's important to have consistent test
+	// results.
+	re := regexp.MustCompile(`func \((.+)\)( .*?) +{ (.+) }`)
+	actual = re.ReplaceAllString(actual, "func ($1)$2 {\n\t$3\n}")
+
 	return actual
 }
 
 func TestCGo(t *testing.T) {
-	var cflags = []string{"--target=armv6m-unknown-unknown-eabi"}
+	var cflags = []string{"--target=armv6m-none-eabi"}
 
 	for _, name := range []string{"basic", "errors", "types", "flags", "const"} {
 		name := name // avoid a race condition
@@ -56,7 +65,7 @@ func TestCGo(t *testing.T) {
 			}
 
 			// Process the AST with CGo.
-			cgoAST, _, _, _, _, cgoErrors := Process([]*ast.File{f}, "testdata", fset, cflags)
+			cgoAST, _, _, _, cgoErrors := Process([]*ast.File{f}, "testdata", fset, cflags)
 
 			// Check the AST for type errors.
 			var typecheckErrors []error
@@ -96,7 +105,7 @@ func TestCGo(t *testing.T) {
 			if err != nil {
 				t.Errorf("could not write out CGo AST: %v", err)
 			}
-			actual := normalizeResult(buf.String())
+			actual := normalizeResult(string(buf.Bytes()))
 
 			// Read the file with the expected output, to compare against.
 			outfile := filepath.Join("testdata", name+".out.go")

cgo/libclang.go

@@ -16,7 +16,7 @@ import (
 )
 
 /*
-#include <clang-c/Index.h> // if this fails, install libclang-11-dev
+#include <clang-c/Index.h> // if this fails, install libclang-10-dev
 #include <stdlib.h>
 #include <stdint.h>
 
@@ -72,14 +72,17 @@ var diagnosticSeverity = [...]string{
 	C.CXDiagnostic_Fatal:   "fatal",
 }
 
-func (p *cgoPackage) parseFragment(fragment string, cflags []string, filename string) {
+func (p *cgoPackage) parseFragment(fragment string, cflags []string, posFilename string, posLine int) {
 	index := C.clang_createIndex(0, 0)
 	defer C.clang_disposeIndex(index)
 
 	// pretend to be a .c file
-	filenameC := C.CString(filename + "!cgo.c")
+	filenameC := C.CString(posFilename + "!cgo.c")
 	defer C.free(unsafe.Pointer(filenameC))
 
+	// fix up error locations
+	fragment = fmt.Sprintf("# %d %#v\n", posLine+1, posFilename) + fragment
+
 	fragmentC := C.CString(fragment)
 	defer C.free(unsafe.Pointer(fragmentC))
 
@@ -193,14 +196,14 @@ func tinygo_clang_globals_visitor(c, parent C.GoCXCursor, client_data C.CXClient
 			}
 			fn.args = append(fn.args, paramInfo{
 				name:     argName,
-				typeExpr: p.makeDecayingASTType(argType, pos),
+				typeExpr: p.makeASTType(argType, pos),
 			})
 		}
 		resultType := C.tinygo_clang_getCursorResultType(c)
 		if resultType.kind != C.CXType_Void {
 			fn.results = &ast.FieldList{
 				List: []*ast.Field{
-					{
+					&ast.Field{
 						Type: p.makeASTType(resultType, pos),
 					},
 				},
@@ -377,7 +380,7 @@ func (p *cgoPackage) addErrorAfter(pos token.Pos, after, msg string) {
 func (p *cgoPackage) addErrorAt(position token.Position, msg string) {
 	if filepath.IsAbs(position.Filename) {
 		// Relative paths for readability, like other Go parser errors.
-		relpath, err := filepath.Rel(p.currentDir, position.Filename)
+		relpath, err := filepath.Rel(p.dir, position.Filename)
 		if err == nil {
 			position.Filename = relpath
 		}
@@ -388,41 +391,6 @@ func (p *cgoPackage) addErrorAt(position token.Position, msg string) {
 	})
 }
 
-// makeDecayingASTType does the same as makeASTType but takes care of decaying
-// types (arrays in function parameters, etc). It is otherwise identical to
-// makeASTType.
-func (p *cgoPackage) makeDecayingASTType(typ C.CXType, pos token.Pos) ast.Expr {
-	// Strip typedefs, if any.
-	underlyingType := typ
-	if underlyingType.kind == C.CXType_Typedef {
-		c := C.tinygo_clang_getTypeDeclaration(typ)
-		underlyingType = C.tinygo_clang_getTypedefDeclUnderlyingType(c)
-		// TODO: support a chain of typedefs. At the moment, it seems to get
-		// stuck in an endless loop when trying to get to the most underlying
-		// type.
-	}
-	// Check for decaying type. An example would be an array type in a
-	// parameter. This declaration:
-	//   void foo(char buf[6]);
-	// is the same as this one:
-	//   void foo(char *buf);
-	// But this one:
-	//   void bar(char buf[6][4]);
-	// equals this:
-	//   void bar(char *buf[4]);
-	// so not all array dimensions should be stripped, just the first one.
-	// TODO: there are more kinds of decaying types.
-	if underlyingType.kind == C.CXType_ConstantArray {
-		// Apply type decaying.
-		pointeeType := C.clang_getElementType(underlyingType)
-		return &ast.StarExpr{
-			Star: pos,
-			X:    p.makeASTType(pointeeType, pos),
-		}
-	}
-	return p.makeASTType(typ, pos)
-}
-
 // makeASTType return the ast.Expr for the given libclang type. In other words,
 // it converts a libclang type to a type in the Go AST.
 func (p *cgoPackage) makeASTType(typ C.CXType, pos token.Pos) ast.Expr {
@@ -807,7 +775,7 @@ func tinygo_clang_struct_visitor(c, parent C.GoCXCursor, client_data C.CXClientD
 	}
 	*inBitfield = false
 	field.Names = []*ast.Ident{
-		{
+		&ast.Ident{
 			NamePos: pos,
 			Name:    name,
 			Obj: &ast.Object{
@@ -828,12 +796,8 @@ func tinygo_clang_enum_visitor(c, parent C.GoCXCursor, client_data C.CXClientDat
 	pos := p.getCursorPosition(c)
 	value := C.tinygo_clang_getEnumConstantDeclValue(c)
 	p.constants[name] = constantInfo{
-		expr: &ast.BasicLit{
-			ValuePos: pos,
-			Kind:     token.INT,
-			Value:    strconv.FormatInt(int64(value), 10),
-		},
-		pos: pos,
+		expr: &ast.BasicLit{pos, token.INT, strconv.FormatInt(int64(value), 10)},
+		pos:  pos,
 	}
 	return C.CXChildVisit_Continue
 }

cgo/libclang_config.go

@@ -1,4 +1,5 @@
 // +build !byollvm
+// +build !llvm10
 
 package cgo
 

cgo/libclang_config_llvm10.go

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

cgo/libclang_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-11-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/errors.go

@@ -14,12 +14,6 @@ typedef someType noType; // undefined type
 #define SOME_CONST_2 6) // const not used (so no error)
 #define SOME_CONST_3 1234 // const too large for byte
 */
-//
-//
-// #define SOME_CONST_4 8) // after some empty lines
-import "C"
-
-// #warning another warning
 import "C"
 
 // Make sure that errors for the following lines won't change with future
@@ -36,6 +30,4 @@ var (
 	_ = C.SOME_CONST_1
 
 	_ byte = C.SOME_CONST_3
-
-	_ = C.SOME_CONST_4
 )

cgo/testdata/errors.out.go

@@ -1,16 +1,13 @@
 // CGo errors:
 //     testdata/errors.go:4:2: warning: some warning
 //     testdata/errors.go:11:9: error: unknown type name 'someType'
-//     testdata/errors.go:22:5: warning: another warning
 //     testdata/errors.go:13:23: unexpected token ), expected end of expression
-//     testdata/errors.go:19:26: unexpected token ), expected end of expression
 
 // Type checking errors after CGo processing:
 //     testdata/errors.go:102: cannot use 2 << 10 (untyped int constant 2048) as uint8 value in variable declaration (overflows)
 //     testdata/errors.go:105: unknown field z in struct literal
 //     testdata/errors.go:108: undeclared name: C.SOME_CONST_1
 //     testdata/errors.go:110: cannot use C.SOME_CONST_3 (untyped int constant 1234) as byte value in variable declaration (overflows)
-//     testdata/errors.go:112: undeclared name: C.SOME_CONST_4
 
 package main
 

cgo/testdata/types.go

@@ -111,10 +111,6 @@ void variadic2(int x, int y, ...);
 */
 import "C"
 
-// // Test that we can refer from this CGo fragment to the fragment above.
-// typedef myint myint2;
-import "C"
-
 var (
 	// Simple typedefs.
 	_ C.myint

cgo/testdata/types.out.go

@@ -67,7 +67,9 @@ type C.union3_t = C.union_1
 type C.union_nested_t = C.union_3
 type C.unionarray_t = struct{ arr [10]C.uchar }
 
-func (s *C.struct_4) bitfield_a() C.uchar { return s.__bitfield_1 & 0x1f }
+func (s *C.struct_4) bitfield_a() C.uchar {
+	return s.__bitfield_1 & 0x1f
+}
 func (s *C.struct_4) set_bitfield_a(value C.uchar) {
 	s.__bitfield_1 = s.__bitfield_1&^0x1f | value&0x1f<<0
 }
@@ -103,9 +105,15 @@ type C.struct_type1 struct {
 }
 type C.struct_type2 struct{ _type C.int }
 
-func (union *C.union_1) unionfield_i() *C.int   { return (*C.int)(unsafe.Pointer(&union.$union)) }
-func (union *C.union_1) unionfield_d() *float64 { return (*float64)(unsafe.Pointer(&union.$union)) }
-func (union *C.union_1) unionfield_s() *C.short { return (*C.short)(unsafe.Pointer(&union.$union)) }
+func (union *C.union_1) unionfield_i() *C.int {
+	return (*C.int)(unsafe.Pointer(&union.$union))
+}
+func (union *C.union_1) unionfield_d() *float64 {
+	return (*float64)(unsafe.Pointer(&union.$union))
+}
+func (union *C.union_1) unionfield_s() *C.short {
+	return (*C.short)(unsafe.Pointer(&union.$union))
+}
 
 type C.union_1 struct{ $union uint64 }
 
@@ -130,7 +138,9 @@ func (union *C.union_3) unionfield_thing() *C.union3_t {
 
 type C.union_3 struct{ $union [2]uint64 }
 
-func (union *C.union_union2d) unionfield_i() *C.int { return (*C.int)(unsafe.Pointer(&union.$union)) }
+func (union *C.union_union2d) unionfield_i() *C.int {
+	return (*C.int)(unsafe.Pointer(&union.$union))
+}
 func (union *C.union_union2d) unionfield_d() *[2]float64 {
 	return (*[2]float64)(unsafe.Pointer(&union.$union))
 }

compileopts/config.go

@@ -5,7 +5,6 @@ package compileopts
 import (
 	"errors"
 	"fmt"
-	"os"
 	"path/filepath"
 	"regexp"
 	"strings"
@@ -22,7 +21,7 @@ type Config struct {
 	TestConfig     TestConfig
 }
 
-// Triple returns the LLVM target triple, like armv6m-unknown-unknown-eabi.
+// Triple returns the LLVM target triple, like armv6m-none-eabi.
 func (c *Config) Triple() string {
 	return c.Target.Triple
 }
@@ -56,7 +55,7 @@ func (c *Config) GOARCH() string {
 
 // BuildTags returns the complete list of build tags used during this build.
 func (c *Config) BuildTags() []string {
-	tags := append(c.Target.BuildTags, []string{"tinygo", "math_big_pure_go", "gc." + c.GC(), "scheduler." + c.Scheduler(), "serial." + c.Serial()}...)
+	tags := append(c.Target.BuildTags, []string{"tinygo", "gc." + c.GC(), "scheduler." + c.Scheduler(), "serial." + c.Serial()}...)
 	for i := 1; i <= c.GoMinorVersion; i++ {
 		tags = append(tags, fmt.Sprintf("go1.%d", i))
 	}
@@ -198,39 +197,6 @@ func (c *Config) RP2040BootPatch() bool {
 	return false
 }
 
-// MuslArchitecture returns the architecture name as used in musl libc. It is
-// usually the same as the first part of the LLVM triple, but not always.
-func MuslArchitecture(triple string) string {
-	arch := strings.Split(triple, "-")[0]
-	if strings.HasPrefix(arch, "arm") || strings.HasPrefix(arch, "thumb") {
-		arch = "arm"
-	}
-	return arch
-}
-
-// LibcPath returns the path to the libc directory. The libc path will be either
-// a precompiled libc shipped with a TinyGo build, or a libc path in the cache
-// directory (which might not yet be built).
-func (c *Config) LibcPath(name string) (path string, precompiled bool) {
-	// Try to load a precompiled library.
-	precompiledDir := filepath.Join(goenv.Get("TINYGOROOT"), "pkg", c.Triple(), name)
-	if _, err := os.Stat(precompiledDir); err == nil {
-		// Found a precompiled library for this OS/architecture. Return the path
-		// directly.
-		return precompiledDir, true
-	}
-
-	// No precompiled library found. Determine the path name that will be used
-	// in the build cache.
-	var outname string
-	if c.CPU() != "" {
-		outname = name + "-" + c.Triple() + "-" + c.CPU()
-	} else {
-		outname = name + "-" + c.Triple()
-	}
-	return filepath.Join(goenv.Get("GOCACHE"), outname), false
-}
-
 // CFlags returns the flags to pass to the C compiler. This is necessary for CGo
 // preprocessing.
 func (c *Config) CFlags() []string {
@@ -238,53 +204,13 @@ func (c *Config) CFlags() []string {
 	for _, flag := range c.Target.CFlags {
 		cflags = append(cflags, strings.ReplaceAll(flag, "{root}", goenv.Get("TINYGOROOT")))
 	}
-	switch c.Target.Libc {
-	case "picolibc":
+	if c.Target.Libc == "picolibc" {
 		root := goenv.Get("TINYGOROOT")
-		picolibcDir := filepath.Join(root, "lib", "picolibc", "newlib", "libc")
-		path, _ := c.LibcPath("picolibc")
-		cflags = append(cflags,
-			"--sysroot="+path,
-			"-Xclang", "-internal-isystem", "-Xclang", filepath.Join(picolibcDir, "include"),
-			"-Xclang", "-internal-isystem", "-Xclang", filepath.Join(picolibcDir, "tinystdio"),
-		)
-	case "musl":
-		root := goenv.Get("TINYGOROOT")
-		path, _ := c.LibcPath("musl")
-		arch := MuslArchitecture(c.Triple())
-		cflags = append(cflags,
-			"--sysroot="+path,
-			"-Xclang", "-internal-isystem", "-Xclang", filepath.Join(root, "lib", "musl", "arch", arch),
-			"-Xclang", "-internal-isystem", "-Xclang", filepath.Join(root, "lib", "musl", "include"),
-		)
-	case "wasi-libc":
-		root := goenv.Get("TINYGOROOT")
-		cflags = append(cflags, "--sysroot="+root+"/lib/wasi-libc/sysroot")
-	case "":
-		// No libc specified, nothing to add.
-	default:
-		// Incorrect configuration. This could be handled in a better way, but
-		// usually this will be found by developers (not by TinyGo users).
-		panic("unknown libc: " + c.Target.Libc)
+		cflags = append(cflags, "-nostdlibinc", "-Xclang", "-internal-isystem", "-Xclang", filepath.Join(root, "lib", "picolibc", "newlib", "libc", "include"))
+		cflags = append(cflags, "-I"+filepath.Join(root, "lib/picolibc-include"))
 	}
-	// Always emit debug information. It is optionally stripped at link time.
-	cflags = append(cflags, "-g")
-	// Use the same optimization level as TinyGo.
-	cflags = append(cflags, "-O"+c.Options.Opt)
-	// Set the LLVM target triple.
-	cflags = append(cflags, "--target="+c.Triple())
-	// Set the -mcpu (or similar) flag.
-	if c.Target.CPU != "" {
-		if c.GOARCH() == "amd64" || c.GOARCH() == "386" {
-			// x86 prefers the -march flag (-mcpu is deprecated there).
-			cflags = append(cflags, "-march="+c.Target.CPU)
-		} else if strings.HasPrefix(c.Triple(), "avr") {
-			// AVR MCUs use -mmcu instead of -mcpu.
-			cflags = append(cflags, "-mmcu="+c.Target.CPU)
-		} else {
-			// The rest just uses -mcpu.
-			cflags = append(cflags, "-mcpu="+c.Target.CPU)
-		}
+	if c.Debug() {
+		cflags = append(cflags, "-g")
 	}
 	return cflags
 }
@@ -324,9 +250,8 @@ func (c *Config) VerifyIR() bool {
 	return c.Options.VerifyIR
 }
 
-// Debug returns whether debug (DWARF) information should be retained by the
-// linker. By default, debug information is retained but it can be removed with
-// the -no-debug flag.
+// Debug returns whether to add debug symbols to the IR, for debugging with GDB
+// and similar.
 func (c *Config) Debug() bool {
 	return c.Options.Debug
 }
@@ -372,9 +297,6 @@ func (c *Config) Programmer() (method, openocdInterface string) {
 	case "openocd", "msd", "command":
 		// The -programmer flag only specifies the flash method.
 		return c.Options.Programmer, c.Target.OpenOCDInterface
-	case "bmp":
-		// The -programmer flag only specifies the flash method.
-		return c.Options.Programmer, ""
 	default:
 		// The -programmer flag specifies something else, assume it specifies
 		// the OpenOCD interface name.

compileopts/options.go

@@ -16,11 +16,8 @@ var (
 )
 
 // Options contains extra options to give to the compiler. These options are
-// usually passed from the command line, but can also be passed in environment
-// variables for example.
+// usually passed from the command line.
 type Options struct {
-	GOOS            string // environment variable
-	GOARCH          string // environment variable
 	Target          string
 	Opt             string
 	GC              string
@@ -31,7 +28,6 @@ type Options struct {
 	DumpSSA         bool
 	VerifyIR        bool
 	PrintCommands   func(cmd string, args ...string)
-	Parallelism     int // -p flag
 	Debug           bool
 	PrintSizes      string
 	PrintAllocs     *regexp.Regexp // regexp string

compileopts/target.go

@@ -161,54 +161,75 @@ func (spec *TargetSpec) resolveInherits() error {
 }
 
 // Load a target specification.
-func LoadTarget(options *Options) (*TargetSpec, error) {
-	if options.Target == "" {
+func LoadTarget(target string) (*TargetSpec, error) {
+	if target == "" {
 		// Configure based on GOOS/GOARCH environment variables (falling back to
 		// runtime.GOOS/runtime.GOARCH), and generate a LLVM target based on it.
+		goos := goenv.Get("GOOS")
+		goarch := goenv.Get("GOARCH")
+		llvmos := goos
 		llvmarch := map[string]string{
 			"386":   "i386",
 			"amd64": "x86_64",
 			"arm64": "aarch64",
-			"arm":   "armv7",
-		}[options.GOARCH]
+		}[goarch]
 		if llvmarch == "" {
-			llvmarch = options.GOARCH
+			llvmarch = goarch
 		}
-		llvmos := options.GOOS
-		if llvmos == "darwin" {
-			// Use macosx* instead of darwin, otherwise darwin/arm64 will refer
-			// to iOS!
-			llvmos = "macosx10.12.0"
-			if llvmarch == "aarch64" {
-				// Looks like Apple prefers to call this architecture ARM64
-				// instead of AArch64.
-				llvmarch = "arm64"
-			}
-		}
-		// Target triples (which actually have four components, but are called
-		// triples for historical reasons) have the form:
-		//   arch-vendor-os-environment
-		target := llvmarch + "-unknown-" + llvmos
-		if options.GOARCH == "arm" {
+		target = llvmarch + "--" + llvmos
+		if goarch == "arm" {
 			target += "-gnueabihf"
 		}
-		return defaultTarget(options.GOOS, options.GOARCH, target)
+		return defaultTarget(goos, goarch, target)
 	}
 
 	// See whether there is a target specification for this target (e.g.
 	// Arduino).
 	spec := &TargetSpec{}
-	err := spec.loadFromGivenStr(options.Target)
-	if err != nil {
+	err := spec.loadFromGivenStr(target)
+	if err == nil {
+		// Successfully loaded this target from a built-in .json file. Make sure
+		// it includes all parents as specified in the "inherits" key.
+		err = spec.resolveInherits()
+		if err != nil {
+			return nil, err
+		}
+		return spec, nil
+	} else if !os.IsNotExist(err) {
+		// Expected a 'file not found' error, got something else. Report it as
+		// an error.
 		return nil, err
+	} else {
+		// Load target from given triple, ignore GOOS/GOARCH environment
+		// variables.
+		tripleSplit := strings.Split(target, "-")
+		if len(tripleSplit) < 3 {
+			return nil, errors.New("expected a full LLVM target or a custom target in -target flag")
+		}
+		if tripleSplit[0] == "arm" {
+			// LLVM and Clang have a different idea of what "arm" means, so
+			// upgrade to a slightly more modern ARM. In fact, when you pass
+			// --target=arm--linux-gnueabihf to Clang, it will convert that
+			// internally to armv7-unknown-linux-gnueabihf. Changing the
+			// architecture to armv7 will keep things consistent.
+			tripleSplit[0] = "armv7"
+		}
+		goos := tripleSplit[2]
+		if strings.HasPrefix(goos, "darwin") {
+			goos = "darwin"
+		}
+		goarch := map[string]string{ // map from LLVM arch to Go arch
+			"i386":    "386",
+			"i686":    "386",
+			"x86_64":  "amd64",
+			"aarch64": "arm64",
+			"armv7":   "arm",
+		}[tripleSplit[0]]
+		if goarch == "" {
+			goarch = tripleSplit[0]
+		}
+		return defaultTarget(goos, goarch, strings.Join(tripleSplit, "-"))
 	}
-	// Successfully loaded this target from a built-in .json file. Make sure
-	// it includes all parents as specified in the "inherits" key.
-	err = spec.resolveInherits()
-	if err != nil {
-		return nil, err
-	}
-	return spec, nil
 }
 
 // WindowsBuildNotSupportedErr is being thrown, when goos is windows and no target has been specified.
@@ -228,27 +249,13 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 		Scheduler:        "tasks",
 		Linker:           "cc",
 		DefaultStackSize: 1024 * 64, // 64kB
+		CFlags:           []string{"--target=" + triple},
 		GDB:              []string{"gdb"},
 		PortReset:        "false",
 	}
-	switch goarch {
-	case "386":
-		spec.CPU = "pentium4"
-	case "amd64":
-		spec.CPU = "x86-64"
-	case "arm":
-		spec.CPU = "generic"
-	case "arm64":
-		spec.CPU = "generic"
-	}
 	if goos == "darwin" {
 		spec.CFlags = append(spec.CFlags, "-isysroot", "/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk")
 		spec.LDFlags = append(spec.LDFlags, "-Wl,-dead_strip")
-	} else if goos == "linux" {
-		spec.Linker = "ld.lld"
-		spec.RTLib = "compiler-rt"
-		spec.Libc = "musl"
-		spec.LDFlags = append(spec.LDFlags, "--gc-sections")
 	} else {
 		spec.LDFlags = append(spec.LDFlags, "-no-pie", "-Wl,--gc-sections") // WARNING: clang < 5.0 requires -nopie
 	}
@@ -260,10 +267,18 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 		// Some educated guesses as to how to invoke helper programs.
 		spec.GDB = []string{"gdb-multiarch"}
 		if goarch == "arm" && goos == "linux" {
-			spec.Emulator = []string{"qemu-arm"}
+			spec.CFlags = append(spec.CFlags, "--sysroot=/usr/arm-linux-gnueabihf")
+			spec.Linker = "arm-linux-gnueabihf-gcc"
+			spec.Emulator = []string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"}
 		}
 		if goarch == "arm64" && goos == "linux" {
-			spec.Emulator = []string{"qemu-aarch64"}
+			spec.CFlags = append(spec.CFlags, "--sysroot=/usr/aarch64-linux-gnu")
+			spec.Linker = "aarch64-linux-gnu-gcc"
+			spec.Emulator = []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"}
+		}
+		if goarch == "386" && runtime.GOARCH == "amd64" {
+			spec.CFlags = append(spec.CFlags, "-m32")
+			spec.LDFlags = append(spec.LDFlags, "-m32")
 		}
 	}
 	return &spec, nil

compileopts/target_test.go

@@ -1,23 +1,22 @@
 package compileopts
 
 import (
-	"os"
 	"reflect"
 	"testing"
 )
 
 func TestLoadTarget(t *testing.T) {
-	_, err := LoadTarget(&Options{Target: "arduino"})
+	_, err := LoadTarget("arduino")
 	if err != nil {
 		t.Error("LoadTarget test failed:", err)
 	}
 
-	_, err = LoadTarget(&Options{Target: "notexist"})
+	_, err = LoadTarget("notexist")
 	if err == nil {
 		t.Error("LoadTarget should have failed with non existing target")
 	}
 
-	if !os.IsNotExist(err) {
+	if err.Error() != "expected a full LLVM target or a custom target in -target flag" {
 		t.Error("LoadTarget failed for wrong reason:", err)
 	}
 }

compiler/alias.go

@@ -1,102 +0,0 @@
-package compiler
-
-// This file defines alias functions for functions that are normally defined in
-// Go assembly.
-//
-// The Go toolchain defines many performance critical functions in assembly
-// instead of plain Go. This is a problem for TinyGo as it currently (as of
-// august 2021) is not able to compile these assembly files and even if it
-// could, it would not be able to make use of them for many targets that are
-// supported by TinyGo (baremetal RISC-V, AVR, etc). Therefore, many of these
-// functions are aliased to their generic Go implementation.
-// This results in slower than possible implementations, but at least they are
-// usable.
-
-import "tinygo.org/x/go-llvm"
-
-var stdlibAliases = map[string]string{
-	// crypto packages
-	"crypto/md5.block":         "crypto/md5.blockGeneric",
-	"crypto/sha1.block":        "crypto/sha1.blockGeneric",
-	"crypto/sha1.blockAMD64":   "crypto/sha1.blockGeneric",
-	"crypto/sha256.block":      "crypto/sha256.blockGeneric",
-	"crypto/sha512.blockAMD64": "crypto/sha512.blockGeneric",
-
-	// math package
-	"math.Asin":      "math.asin",
-	"math.Asinh":     "math.asinh",
-	"math.Acos":      "math.acos",
-	"math.Acosh":     "math.acosh",
-	"math.Atan":      "math.atan",
-	"math.Atanh":     "math.atanh",
-	"math.Atan2":     "math.atan2",
-	"math.Cbrt":      "math.cbrt",
-	"math.Ceil":      "math.ceil",
-	"math.archCeil":  "math.ceil",
-	"math.Cos":       "math.cos",
-	"math.Cosh":      "math.cosh",
-	"math.Erf":       "math.erf",
-	"math.Erfc":      "math.erfc",
-	"math.Exp":       "math.exp",
-	"math.archExp":   "math.exp",
-	"math.Expm1":     "math.expm1",
-	"math.Exp2":      "math.exp2",
-	"math.archExp2":  "math.exp2",
-	"math.Floor":     "math.floor",
-	"math.archFloor": "math.floor",
-	"math.Frexp":     "math.frexp",
-	"math.Hypot":     "math.hypot",
-	"math.archHypot": "math.hypot",
-	"math.Ldexp":     "math.ldexp",
-	"math.Log":       "math.log",
-	"math.archLog":   "math.log",
-	"math.Log1p":     "math.log1p",
-	"math.Log10":     "math.log10",
-	"math.Log2":      "math.log2",
-	"math.Max":       "math.max",
-	"math.archMax":   "math.max",
-	"math.Min":       "math.min",
-	"math.archMin":   "math.min",
-	"math.Mod":       "math.mod",
-	"math.Modf":      "math.modf",
-	"math.archModf":  "math.modf",
-	"math.Pow":       "math.pow",
-	"math.Remainder": "math.remainder",
-	"math.Sin":       "math.sin",
-	"math.Sinh":      "math.sinh",
-	"math.Sqrt":      "math.sqrt",
-	"math.archSqrt":  "math.sqrt",
-	"math.Tan":       "math.tan",
-	"math.Tanh":      "math.tanh",
-	"math.Trunc":     "math.trunc",
-	"math.archTrunc": "math.trunc",
-}
-
-// createAlias implements the function (in the builder) as a call to the alias
-// function.
-func (b *builder) createAlias(alias llvm.Value) {
-	b.llvmFn.SetVisibility(llvm.HiddenVisibility)
-	b.llvmFn.SetUnnamedAddr(true)
-
-	if b.Debug {
-		if b.fn.Syntax() != nil {
-			// Create debug info file if present.
-			b.difunc = b.attachDebugInfo(b.fn)
-		}
-		pos := b.program.Fset.Position(b.fn.Pos())
-		b.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), b.difunc, llvm.Metadata{})
-	}
-	entryBlock := llvm.AddBasicBlock(b.llvmFn, "entry")
-	b.SetInsertPointAtEnd(entryBlock)
-	if b.llvmFn.Type() != alias.Type() {
-		b.addError(b.fn.Pos(), "alias function should have the same type as aliasee "+alias.Name())
-		b.CreateUnreachable()
-		return
-	}
-	result := b.CreateCall(alias, b.llvmFn.Params(), "")
-	if result.Type().TypeKind() == llvm.VoidTypeKind {
-		b.CreateRetVoid()
-	} else {
-		b.CreateRet(result)
-	}
-}

compiler/asserts.go

@@ -101,55 +101,6 @@ func (b *builder) createSliceBoundsCheck(capacity, low, high, max llvm.Value, lo
 	b.createRuntimeAssert(outOfBounds, "slice", "slicePanic")
 }
 
-// createSliceToArrayPointerCheck adds a check for slice-to-array pointer
-// conversions. This conversion was added in Go 1.17. For details, see:
-// https://tip.golang.org/ref/spec#Conversions_from_slice_to_array_pointer
-func (b *builder) createSliceToArrayPointerCheck(sliceLen llvm.Value, arrayLen int64) {
-	// From the spec:
-	// > If the length of the slice is less than the length of the array, a
-	// > run-time panic occurs.
-	arrayLenValue := llvm.ConstInt(b.uintptrType, uint64(arrayLen), false)
-	isLess := b.CreateICmp(llvm.IntULT, sliceLen, arrayLenValue, "")
-	b.createRuntimeAssert(isLess, "slicetoarray", "sliceToArrayPointerPanic")
-}
-
-// createUnsafeSliceCheck inserts a runtime check used for unsafe.Slice. This
-// function must panic if the ptr/len parameters are invalid.
-func (b *builder) createUnsafeSliceCheck(ptr, len llvm.Value, lenType *types.Basic) {
-	// From the documentation of unsafe.Slice:
-	//   > At run time, if len is negative, or if ptr is nil and len is not
-	//   > zero, a run-time panic occurs.
-	// However, in practice, it is also necessary to check that the length is
-	// not too big that a GEP wouldn't be possible without wrapping the pointer.
-	// These two checks (non-negative and not too big) can be merged into one
-	// using an unsiged greater than.
-
-	// Make sure the len value is at least as big as a uintptr.
-	if len.Type().IntTypeWidth() < b.uintptrType.IntTypeWidth() {
-		if lenType.Info()&types.IsUnsigned != 0 {
-			len = b.CreateZExt(len, b.uintptrType, "")
-		} else {
-			len = b.CreateSExt(len, b.uintptrType, "")
-		}
-	}
-
-	// Determine the maximum slice size, and therefore the maximum value of the
-	// len parameter.
-	maxSize := b.maxSliceSize(ptr.Type().ElementType())
-	maxSizeValue := llvm.ConstInt(len.Type(), maxSize, false)
-
-	// Do the check. By using unsigned greater than for the length check, signed
-	// negative values are also checked (which are very large numbers when
-	// interpreted as signed values).
-	zero := llvm.ConstInt(len.Type(), 0, false)
-	lenOutOfBounds := b.CreateICmp(llvm.IntUGT, len, maxSizeValue, "")
-	ptrIsNil := b.CreateICmp(llvm.IntEQ, ptr, llvm.ConstNull(ptr.Type()), "")
-	lenIsNotZero := b.CreateICmp(llvm.IntNE, len, zero, "")
-	assert := b.CreateAnd(ptrIsNil, lenIsNotZero, "")
-	assert = b.CreateOr(assert, lenOutOfBounds, "")
-	b.createRuntimeAssert(assert, "unsafe.Slice", "unsafeSlicePanic")
-}
-
 // createChanBoundsCheck creates a bounds check before creating a new channel to
 // check that the value is not too big for runtime.chanMake.
 func (b *builder) createChanBoundsCheck(elementSize uint64, bufSize llvm.Value, bufSizeType *types.Basic, pos token.Pos) {
@@ -164,9 +115,11 @@ func (b *builder) createChanBoundsCheck(elementSize uint64, bufSize llvm.Value,
 	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, "")
 		}
 	}
@@ -253,19 +206,6 @@ func (b *builder) createNegativeShiftCheck(shift llvm.Value) {
 	b.createRuntimeAssert(isNegative, "shift", "negativeShiftPanic")
 }
 
-// createDivideByZeroCheck asserts that y is not zero. If it is, a runtime panic
-// will be emitted. This follows the Go specification which says that a divide
-// by zero must cause a run time panic.
-func (b *builder) createDivideByZeroCheck(y llvm.Value) {
-	if b.info.nobounds {
-		return
-	}
-
-	// isZero = y == 0
-	isZero := b.CreateICmp(llvm.IntEQ, y, llvm.ConstInt(y.Type(), 0, false), "")
-	b.createRuntimeAssert(isZero, "divbyzero", "divideByZeroPanic")
-}
-
 // 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) {

compiler/atomic.go

@@ -38,10 +38,11 @@ func (b *builder) createAtomicOp(call *ssa.CallCommon) (llvm.Value, bool) {
 		old := b.getValue(call.Args[1])
 		newVal := b.getValue(call.Args[2])
 		if strings.HasSuffix(name, "64") {
-			if strings.HasPrefix(b.Triple, "thumb") {
+			arch := strings.Split(b.Triple, "-")[0]
+			if strings.HasPrefix(arch, "arm") && strings.HasSuffix(arch, "m") {
 				// Work around a bug in LLVM, at least LLVM 11:
 				// https://reviews.llvm.org/D95891
-				// Check for thumbv6m, thumbv7, thumbv7em, and perhaps others.
+				// Check for armv6m, armv7, armv7em, and perhaps others.
 				// See also: https://gcc.gnu.org/onlinedocs/gcc/_005f_005fsync-Builtins.html
 				compareAndSwap := b.mod.NamedFunction("__sync_val_compare_and_swap_8")
 				if compareAndSwap.IsNil() {

compiler/calls.go

@@ -63,10 +63,10 @@ func (c *compilerContext) expandFormalParamType(t llvm.Type, name string, goType
 	case llvm.StructTypeKind:
 		fieldInfos := c.flattenAggregateType(t, name, goType)
 		if len(fieldInfos) <= maxFieldsPerParam {
-			// managed to expand this parameter
 			return fieldInfos
+		} else {
+			// failed to lower
 		}
-		// failed to expand this parameter: too many fields
 	}
 	// TODO: split small arrays
 	return []paramInfo{

compiler/channel.go

@@ -32,15 +32,8 @@ func (b *builder) createChanSend(instr *ssa.Send) {
 
 	// store value-to-send
 	valueType := b.getLLVMType(instr.X.Type())
-	isZeroSize := b.targetData.TypeAllocSize(valueType) == 0
-	var valueAlloca, valueAllocaCast, valueAllocaSize llvm.Value
-	if isZeroSize {
-		valueAlloca = llvm.ConstNull(llvm.PointerType(valueType, 0))
-		valueAllocaCast = llvm.ConstNull(b.i8ptrType)
-	} else {
-		valueAlloca, valueAllocaCast, valueAllocaSize = b.createTemporaryAlloca(valueType, "chan.value")
-		b.CreateStore(chanValue, valueAlloca)
-	}
+	valueAlloca, valueAllocaCast, valueAllocaSize := b.createTemporaryAlloca(valueType, "chan.value")
+	b.CreateStore(chanValue, valueAlloca)
 
 	// Allocate blockedlist buffer.
 	channelBlockedList := b.mod.GetTypeByName("runtime.channelBlockedList")
@@ -53,9 +46,7 @@ func (b *builder) createChanSend(instr *ssa.Send) {
 	// This also works around a bug in CoroSplit, at least in LLVM 8:
 	// https://bugs.llvm.org/show_bug.cgi?id=41742
 	b.emitLifetimeEnd(channelBlockedListAllocaCast, channelBlockedListAllocaSize)
-	if !isZeroSize {
-		b.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
-	}
+	b.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
 }
 
 // createChanRecv emits a pseudo chan receive operation. It is lowered to the
@@ -65,14 +56,7 @@ func (b *builder) createChanRecv(unop *ssa.UnOp) llvm.Value {
 	ch := b.getValue(unop.X)
 
 	// Allocate memory to receive into.
-	isZeroSize := b.targetData.TypeAllocSize(valueType) == 0
-	var valueAlloca, valueAllocaCast, valueAllocaSize llvm.Value
-	if isZeroSize {
-		valueAlloca = llvm.ConstNull(llvm.PointerType(valueType, 0))
-		valueAllocaCast = llvm.ConstNull(b.i8ptrType)
-	} else {
-		valueAlloca, valueAllocaCast, valueAllocaSize = b.createTemporaryAlloca(valueType, "chan.value")
-	}
+	valueAlloca, valueAllocaCast, valueAllocaSize := b.createTemporaryAlloca(valueType, "chan.value")
 
 	// Allocate blockedlist buffer.
 	channelBlockedList := b.mod.GetTypeByName("runtime.channelBlockedList")
@@ -80,14 +64,9 @@ func (b *builder) createChanRecv(unop *ssa.UnOp) llvm.Value {
 
 	// Do the receive.
 	commaOk := b.createRuntimeCall("chanRecv", []llvm.Value{ch, valueAllocaCast, channelBlockedListAlloca}, "")
-	var received llvm.Value
-	if isZeroSize {
-		received = llvm.ConstNull(valueType)
-	} else {
-		received = b.CreateLoad(valueAlloca, "chan.received")
-		b.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
-	}
+	received := b.CreateLoad(valueAlloca, "chan.received")
 	b.emitLifetimeEnd(channelBlockedListAllocaCast, channelBlockedListAllocaSize)
+	b.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
 
 	if unop.CommaOk {
 		tuple := llvm.Undef(b.ctx.StructType([]llvm.Type{valueType, b.ctx.Int1Type()}, false))
@@ -137,6 +116,7 @@ func (b *builder) createSelect(expr *ssa.Select) llvm.Value {
 	// determine the receive buffer size and alignment.
 	recvbufSize := uint64(0)
 	recvbufAlign := 0
+	hasReceives := false
 	var selectStates []llvm.Value
 	chanSelectStateType := b.getLLVMRuntimeType("chanSelectState")
 	for _, state := range expr.States {
@@ -153,6 +133,7 @@ func (b *builder) createSelect(expr *ssa.Select) llvm.Value {
 			if align := b.targetData.ABITypeAlignment(llvmType); align > recvbufAlign {
 				recvbufAlign = align
 			}
+			hasReceives = true
 		case types.SendOnly:
 			// Store this value in an alloca and put a pointer to this alloca
 			// in the send state.
@@ -169,7 +150,7 @@ func (b *builder) createSelect(expr *ssa.Select) llvm.Value {
 
 	// Create a receive buffer, where the received value will be stored.
 	recvbuf := llvm.Undef(b.i8ptrType)
-	if recvbufSize != 0 {
+	if hasReceives {
 		allocaType := llvm.ArrayType(b.ctx.Int8Type(), int(recvbufSize))
 		recvbufAlloca, _, _ := b.createTemporaryAlloca(allocaType, "select.recvbuf.alloca")
 		recvbufAlloca.SetAlignment(recvbufAlign)

compiler/compiler.go

@@ -23,7 +23,7 @@ import (
 // Version of the compiler pacakge. Must be incremented each time the compiler
 // package changes in a way that affects the generated LLVM module.
 // This version is independent of the TinyGo version number.
-const Version = 24 // last change: add layout param to runtime.alloc calls
+const Version = 12 // last change: implement syscall.rawSyscallNoError
 
 func init() {
 	llvm.InitializeAllTargets()
@@ -33,6 +33,9 @@ func init() {
 	llvm.InitializeAllAsmPrinters()
 }
 
+// The TinyGo import path.
+const tinygoPath = "github.com/tinygo-org/tinygo"
+
 // Config is the configuration for the compiler. Most settings should be copied
 // directly from compileopts.Config, it recreated here to decouple the compiler
 // package a bit and because it makes caching easier.
@@ -48,7 +51,6 @@ type Config struct {
 	GOARCH          string
 	CodeModel       string
 	RelocationModel string
-	SizeLevel       int
 
 	// Various compiler options that determine how code is generated.
 	Scheduler          string
@@ -72,18 +74,15 @@ type compilerContext struct {
 	cu               llvm.Metadata
 	difiles          map[string]llvm.Metadata
 	ditypes          map[types.Type]llvm.Metadata
-	llvmTypes        map[types.Type]llvm.Type
 	machine          llvm.TargetMachine
 	targetData       llvm.TargetData
 	intType          llvm.Type
 	i8ptrType        llvm.Type // for convenience
-	rawVoidFuncType  llvm.Type // for convenience
 	funcPtrAddrSpace int
 	uintptrType      llvm.Type
 	program          *ssa.Program
 	diagnostics      []error
 	astComments      map[string]*ast.CommentGroup
-	pkg              *types.Package
 	runtimePkg       *types.Package
 }
 
@@ -95,7 +94,6 @@ func newCompilerContext(moduleName string, machine llvm.TargetMachine, config *C
 		DumpSSA:     dumpSSA,
 		difiles:     make(map[string]llvm.Metadata),
 		ditypes:     make(map[types.Type]llvm.Metadata),
-		llvmTypes:   make(map[types.Type]llvm.Type),
 		machine:     machine,
 		targetData:  machine.CreateTargetData(),
 		astComments: map[string]*ast.CommentGroup{},
@@ -124,7 +122,6 @@ func newCompilerContext(moduleName string, machine llvm.TargetMachine, config *C
 	dummyFuncType := llvm.FunctionType(c.ctx.VoidType(), nil, false)
 	dummyFunc := llvm.AddFunction(c.mod, "tinygo.dummy", dummyFuncType)
 	c.funcPtrAddrSpace = dummyFunc.Type().PointerAddressSpace()
-	c.rawVoidFuncType = dummyFunc.Type()
 	dummyFunc.EraseFromParentAsFunction()
 
 	return c
@@ -142,6 +139,7 @@ type builder struct {
 	blockExits        map[*ssa.BasicBlock]llvm.BasicBlock // these are the exit blocks
 	currentBlock      *ssa.BasicBlock
 	phis              []phiNode
+	taskHandle        llvm.Value
 	deferPtr          llvm.Value
 	difunc            llvm.Metadata
 	dilocals          map[*types.Var]llvm.Metadata
@@ -233,6 +231,10 @@ func Sizes(machine llvm.TargetMachine) types.Sizes {
 	targetData := machine.CreateTargetData()
 	defer targetData.Dispose()
 
+	intPtrType := targetData.IntPtrType()
+	if intPtrType.IntTypeWidth()/8 <= 32 {
+	}
+
 	var intWidth int
 	if targetData.PointerSize() <= 4 {
 		// 8, 16, 32 bits targets
@@ -247,14 +249,13 @@ func Sizes(machine llvm.TargetMachine) types.Sizes {
 	return &stdSizes{
 		IntSize:  int64(intWidth / 8),
 		PtrSize:  int64(targetData.PointerSize()),
-		MaxAlign: int64(targetData.PrefTypeAlignment(targetData.IntPtrType())),
+		MaxAlign: int64(targetData.PrefTypeAlignment(intPtrType)),
 	}
 }
 
 // CompilePackage compiles a single package to a LLVM module.
 func CompilePackage(moduleName string, pkg *loader.Package, ssaPkg *ssa.Package, machine llvm.TargetMachine, config *Config, dumpSSA bool) (llvm.Module, []error) {
 	c := newCompilerContext(moduleName, machine, config, dumpSSA)
-	c.pkg = pkg.Pkg
 	c.runtimePkg = ssaPkg.Prog.ImportedPackage("runtime").Pkg
 	c.program = ssaPkg.Prog
 
@@ -288,14 +289,14 @@ func CompilePackage(moduleName string, pkg *loader.Package, ssaPkg *ssa.Package,
 	if c.Debug {
 		c.mod.AddNamedMetadataOperand("llvm.module.flags",
 			c.ctx.MDNode([]llvm.Metadata{
-				llvm.ConstInt(c.ctx.Int32Type(), 2, false).ConstantAsMetadata(), // Warning on mismatch
+				llvm.ConstInt(c.ctx.Int32Type(), 1, false).ConstantAsMetadata(), // Error on mismatch
 				c.ctx.MDString("Debug Info Version"),
 				llvm.ConstInt(c.ctx.Int32Type(), 3, false).ConstantAsMetadata(), // DWARF version
 			}),
 		)
 		c.mod.AddNamedMetadataOperand("llvm.module.flags",
 			c.ctx.MDNode([]llvm.Metadata{
-				llvm.ConstInt(c.ctx.Int32Type(), 7, false).ConstantAsMetadata(), // Max on mismatch
+				llvm.ConstInt(c.ctx.Int32Type(), 1, false).ConstantAsMetadata(),
 				c.ctx.MDString("Dwarf Version"),
 				llvm.ConstInt(c.ctx.Int32Type(), 4, false).ConstantAsMetadata(),
 			}),
@@ -314,23 +315,10 @@ func (c *compilerContext) getLLVMRuntimeType(name string) llvm.Type {
 	return c.getLLVMType(typ)
 }
 
-// getLLVMType returns a LLVM type for a Go type. It doesn't recreate already
-// created types. This is somewhat important for performance, but especially
-// important for named struct types (which should only be created once).
+// getLLVMType creates and returns a LLVM type for a Go type. In the case of
+// named struct types (or Go types implemented as named LLVM structs such as
+// strings) it also creates it first if necessary.
 func (c *compilerContext) getLLVMType(goType types.Type) llvm.Type {
-	// Try to load the LLVM type from the cache.
-	if t, ok := c.llvmTypes[goType]; ok {
-		return t
-	}
-	// Not already created, so adding this type to the cache.
-	llvmType := c.makeLLVMType(goType)
-	c.llvmTypes[goType] = llvmType
-	return llvmType
-}
-
-// makeLLVMType creates a LLVM type for a Go type. Don't call this, use
-// getLLVMType instead.
-func (c *compilerContext) makeLLVMType(goType types.Type) llvm.Type {
 	switch typ := goType.(type) {
 	case *types.Array:
 		elemType := c.getLLVMType(typ.Elem())
@@ -379,10 +367,12 @@ func (c *compilerContext) makeLLVMType(goType types.Type) llvm.Type {
 			// LLVM. This is because it is otherwise impossible to create
 			// self-referencing types such as linked lists.
 			llvmName := typ.Obj().Pkg().Path() + "." + typ.Obj().Name()
-			llvmType := c.ctx.StructCreateNamed(llvmName)
-			c.llvmTypes[goType] = llvmType // avoid infinite recursion
-			underlying := c.getLLVMType(st)
-			llvmType.StructSetBody(underlying.StructElementTypes(), false)
+			llvmType := c.mod.GetTypeByName(llvmName)
+			if llvmType.IsNil() {
+				llvmType = c.ctx.StructCreateNamed(llvmName)
+				underlying := c.getLLVMType(st)
+				llvmType.StructSetBody(underlying.StructElementTypes(), false)
+			}
 			return llvmType
 		}
 		return c.getLLVMType(typ.Underlying())
@@ -449,7 +439,7 @@ func (c *compilerContext) createDIType(typ types.Type) llvm.Metadata {
 			AlignInBits: uint32(c.targetData.ABITypeAlignment(llvmType)) * 8,
 			ElementType: c.getDIType(typ.Elem()),
 			Subscripts: []llvm.DISubrange{
-				{
+				llvm.DISubrange{
 					Lo:    0,
 					Count: typ.Len(),
 				},
@@ -703,6 +693,7 @@ func (c *compilerContext) getDIFile(filename string) llvm.Metadata {
 // createPackage builds the LLVM IR for all types, methods, and global variables
 // in the given package.
 func (c *compilerContext) createPackage(irbuilder llvm.Builder, pkg *ssa.Package) {
+	println("called create package:", pkg.Pkg.Name())
 	// Sort by position, so that the order of the functions in the IR matches
 	// the order of functions in the source file. This is useful for testing,
 	// for example.
@@ -768,6 +759,35 @@ func (c *compilerContext) createPackage(irbuilder llvm.Builder, pkg *ssa.Package
 		case *ssa.Global:
 			// Global variable.
 			info := c.getGlobalInfo(member)
+			// process go:embed pragmas
+			// TODO: skip this if not Go 1.16 or higher
+			if strings.TrimSpace(info.embeds) != "" {
+				embeds, err := parseGoEmbed(info.embeds)
+				if err != nil {
+					c.addError(member.Pos(), `invalid go:embed pragma: `+err.Error())
+					goto getGlobal
+				}
+				importsEmbedPkg := false
+				for _, imprt := range pkg.Pkg.Imports() {
+					if imprt.Name() == "embed" {
+						importsEmbedPkg = true
+						break
+					}
+				}
+				if !importsEmbedPkg {
+					// FIXME: technically the "embed" package needs to be imported in every
+					// *source file* that has a //go:embed pragma... that will always be the
+					// case when referencing embed.FS but not necessarily when a go:embed
+					// pragma is added to a string or []byte.  For now, as long as the embed
+					// package is imported in at least one source file, TinyGo will process
+					// any go:embed pragmas in the entire package.
+					c.addError(member.Pos(), `//go:embed only allowed in Go files that import "embed"`)
+					goto getGlobal
+				}
+				fmt.Printf("file embed found at %v (import: %v): %v\n", info.linkName, importsEmbedPkg, embeds)
+			}
+
+		getGlobal:
 			global := c.getGlobal(member)
 			if !info.extern {
 				global.SetInitializer(llvm.ConstNull(global.Type().ElementType()))
@@ -776,29 +796,7 @@ func (c *compilerContext) createPackage(irbuilder llvm.Builder, pkg *ssa.Package
 					global.SetSection(info.section)
 				}
 			}
-		}
-	}
 
-	// Add forwarding functions for functions that would otherwise be
-	// implemented in assembly.
-	for _, name := range members {
-		member := pkg.Members[name]
-		switch member := member.(type) {
-		case *ssa.Function:
-			if member.Blocks != nil {
-				continue // external function
-			}
-			info := c.getFunctionInfo(member)
-			if aliasName, ok := stdlibAliases[info.linkName]; ok {
-				alias := c.mod.NamedFunction(aliasName)
-				if alias.IsNil() {
-					// Shouldn't happen, but perhaps best to just ignore.
-					// The error will be a link error, if there is an error.
-					continue
-				}
-				b := newBuilder(c, irbuilder, member)
-				b.createAlias(alias)
-			}
 		}
 	}
 }
@@ -819,7 +817,6 @@ func (b *builder) createFunction() {
 		b.addError(b.fn.Pos(), errValue)
 		return
 	}
-	b.addStandardDefinedAttributes(b.llvmFn)
 	if !b.info.exported {
 		b.llvmFn.SetVisibility(llvm.HiddenVisibility)
 		b.llvmFn.SetUnnamedAddr(true)
@@ -846,17 +843,6 @@ func (b *builder) createFunction() {
 		b.llvmFn.AddFunctionAttr(noinline)
 	}
 
-	if b.info.interrupt {
-		// Mark this function as an interrupt.
-		// This is necessary on MCUs that don't push caller saved registers when
-		// entering an interrupt, such as on AVR.
-		if strings.HasPrefix(b.Triple, "avr") {
-			b.llvmFn.AddFunctionAttr(b.ctx.CreateStringAttribute("signal", ""))
-		} else {
-			b.addError(b.fn.Pos(), "//go:interrupt not supported on this architecture")
-		}
-	}
-
 	// Add debug info, if needed.
 	if b.Debug {
 		if b.fn.Synthetic == "package initializer" {
@@ -1315,38 +1301,6 @@ func (b *builder) createBuiltin(argTypes []types.Type, argValues []llvm.Value, c
 	case "ssa:wrapnilchk":
 		// TODO: do an actual nil check?
 		return argValues[0], nil
-
-	// Builtins from the unsafe package.
-	case "Add": // unsafe.Add
-		// This is basically just a GEP operation.
-		// Note: the pointer is always of type *i8.
-		ptr := argValues[0]
-		len := argValues[1]
-		return b.CreateGEP(ptr, []llvm.Value{len}, ""), nil
-	case "Slice": // unsafe.Slice
-		// This creates a slice from a pointer and a length.
-		// Note that the exception mentioned in the documentation (if the
-		// pointer and length are nil, the slice is also nil) is trivially
-		// already the case.
-		ptr := argValues[0]
-		len := argValues[1]
-		slice := llvm.Undef(b.ctx.StructType([]llvm.Type{
-			ptr.Type(),
-			b.uintptrType,
-			b.uintptrType,
-		}, false))
-		b.createUnsafeSliceCheck(ptr, len, argTypes[1].Underlying().(*types.Basic))
-		if len.Type().IntTypeWidth() < b.uintptrType.IntTypeWidth() {
-			// Too small, zero-extend len.
-			len = b.CreateZExt(len, b.uintptrType, "")
-		} else if len.Type().IntTypeWidth() > b.uintptrType.IntTypeWidth() {
-			// Too big, truncate len.
-			len = b.CreateTrunc(len, b.uintptrType, "")
-		}
-		slice = b.CreateInsertValue(slice, ptr, 0, "")
-		slice = b.CreateInsertValue(slice, len, 1, "")
-		slice = b.CreateInsertValue(slice, len, 2, "")
-		return slice, nil
 	default:
 		return llvm.Value{}, b.makeError(pos, "todo: builtin: "+callName)
 	}
@@ -1358,9 +1312,9 @@ func (b *builder) createBuiltin(argTypes []types.Type, argValues []llvm.Value, c
 //
 // This is also where compiler intrinsics are implemented.
 func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error) {
-	var params []llvm.Value
-	for _, param := range instr.Args {
-		params = append(params, b.getValue(param))
+	if instr.IsInvoke() {
+		fnCast, args := b.getInvokeCall(instr)
+		return b.createCall(fnCast, args, ""), nil
 	}
 
 	// Try to call the function directly for trivially static calls.
@@ -1375,11 +1329,6 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 			return b.createMemoryCopyCall(fn, instr.Args)
 		case name == "runtime.memzero":
 			return b.createMemoryZeroCall(instr.Args)
-		case name == "math.Ceil" || name == "math.Floor" || name == "math.Sqrt" || name == "math.Trunc":
-			result, ok := b.createMathOp(instr)
-			if ok {
-				return result, nil
-			}
 		case name == "device.Asm" || name == "device/arm.Asm" || name == "device/arm64.Asm" || name == "device/avr.Asm" || name == "device/riscv.Asm":
 			return b.createInlineAsm(instr.Args)
 		case name == "device.AsmFull" || name == "device/arm.AsmFull" || name == "device/arm64.AsmFull" || name == "device/avr.AsmFull" || name == "device/riscv.AsmFull":
@@ -1431,20 +1380,12 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 	} else if call, ok := instr.Value.(*ssa.Builtin); ok {
 		// Builtin function (append, close, delete, etc.).)
 		var argTypes []types.Type
+		var argValues []llvm.Value
 		for _, arg := range instr.Args {
 			argTypes = append(argTypes, arg.Type())
+			argValues = append(argValues, b.getValue(arg))
 		}
-		return b.createBuiltin(argTypes, params, call.Name(), instr.Pos())
-	} else if instr.IsInvoke() {
-		// Interface method call (aka invoke call).
-		itf := b.getValue(instr.Value) // interface value (runtime._interface)
-		typecode := b.CreateExtractValue(itf, 0, "invoke.func.typecode")
-		value := b.CreateExtractValue(itf, 1, "invoke.func.value") // receiver
-		// Prefix the params with receiver value and suffix with typecode.
-		params = append([]llvm.Value{value}, params...)
-		params = append(params, typecode)
-		callee = b.getInvokeFunction(instr)
-		context = llvm.Undef(b.i8ptrType)
+		return b.createBuiltin(argTypes, argValues, call.Name(), instr.Pos())
 	} else {
 		// Function pointer.
 		value := b.getValue(instr.Value)
@@ -1454,6 +1395,11 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 		b.createNilCheck(instr.Value, callee, "fpcall")
 	}
 
+	var params []llvm.Value
+	for _, param := range instr.Args {
+		params = append(params, b.getValue(param))
+	}
+
 	if !exported {
 		// This function takes a context parameter.
 		// Add it to the end of the parameter list.
@@ -1471,7 +1417,7 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 func (b *builder) getValue(expr ssa.Value) llvm.Value {
 	switch expr := expr.(type) {
 	case *ssa.Const:
-		return b.createConst(expr)
+		return b.createConst(b.info.linkName, expr)
 	case *ssa.Function:
 		if b.getFunctionInfo(expr).exported {
 			b.addError(expr.Pos(), "cannot use an exported function as value: "+expr.String())
@@ -1496,28 +1442,6 @@ func (b *builder) getValue(expr ssa.Value) llvm.Value {
 	}
 }
 
-// maxSliceSize determines the maximum size a slice of the given element type
-// can be.
-func (c *compilerContext) maxSliceSize(elementType llvm.Type) uint64 {
-	// Calculate ^uintptr(0), which is the max value that fits in uintptr.
-	maxPointerValue := llvm.ConstNot(llvm.ConstInt(c.uintptrType, 0, false)).ZExtValue()
-	// Calculate (^uint(0))/2, which is the max value that fits in an int.
-	maxIntegerValue := llvm.ConstNot(llvm.ConstInt(c.intType, 0, false)).ZExtValue() / 2
-
-	// Determine the maximum allowed size for a slice. The biggest possible
-	// pointer (starting from 0) would be maxPointerValue*sizeof(elementType) so
-	// divide by the element type to get the real maximum size.
-	maxSize := maxPointerValue / c.targetData.TypeAllocSize(elementType)
-
-	// len(slice) is an int. Make sure the length remains small enough to fit in
-	// an int.
-	if maxSize > maxIntegerValue {
-		maxSize = maxIntegerValue
-	}
-
-	return maxSize
-}
-
 // createExpr translates a Go SSA expression to LLVM IR. This can be zero, one,
 // or multiple LLVM IR instructions and/or runtime calls.
 func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
@@ -1538,8 +1462,7 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 				return llvm.Value{}, b.makeError(expr.Pos(), fmt.Sprintf("value is too big (%v bytes)", size))
 			}
 			sizeValue := llvm.ConstInt(b.uintptrType, size, false)
-			layoutValue := b.createObjectLayout(typ, expr.Pos())
-			buf := b.createRuntimeCall("alloc", []llvm.Value{sizeValue, layoutValue}, expr.Comment)
+			buf := b.createRuntimeCall("alloc", []llvm.Value{sizeValue}, expr.Comment)
 			buf = b.CreateBitCast(buf, llvm.PointerType(typ, 0), "")
 			return buf, nil
 		} else {
@@ -1732,8 +1655,10 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		elemSize := b.targetData.TypeAllocSize(llvmElemType)
 		elemSizeValue := llvm.ConstInt(b.uintptrType, elemSize, false)
 
-		maxSize := b.maxSliceSize(llvmElemType)
-		if elemSize > maxSize {
+		// Calculate (^uintptr(0)) >> 1, which is the max value that fits in
+		// uintptr if uintptr were signed.
+		maxSize := llvm.ConstLShr(llvm.ConstNot(llvm.ConstInt(b.uintptrType, 0, false)), llvm.ConstInt(b.uintptrType, 1, false))
+		if elemSize > maxSize.ZExtValue() {
 			// This seems to be checked by the typechecker already, but let's
 			// check it again just to be sure.
 			return llvm.Value{}, b.makeError(expr.Pos(), fmt.Sprintf("slice element type is too big (%v bytes)", elemSize))
@@ -1742,8 +1667,7 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		// Bounds checking.
 		lenType := expr.Len.Type().Underlying().(*types.Basic)
 		capType := expr.Cap.Type().Underlying().(*types.Basic)
-		maxSizeValue := llvm.ConstInt(b.uintptrType, maxSize, false)
-		b.createSliceBoundsCheck(maxSizeValue, sliceLen, sliceCap, sliceCap, lenType, capType, capType)
+		b.createSliceBoundsCheck(maxSize, sliceLen, sliceCap, sliceCap, lenType, capType, capType)
 
 		// Allocate the backing array.
 		sliceCapCast, err := b.createConvert(expr.Cap.Type(), types.Typ[types.Uintptr], sliceCap, expr.Pos())
@@ -1751,8 +1675,7 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 			return llvm.Value{}, err
 		}
 		sliceSize := b.CreateBinOp(llvm.Mul, elemSizeValue, sliceCapCast, "makeslice.cap")
-		layoutValue := b.createObjectLayout(llvmElemType, expr.Pos())
-		slicePtr := b.createRuntimeCall("alloc", []llvm.Value{sliceSize, layoutValue}, "makeslice.buf")
+		slicePtr := b.createRuntimeCall("alloc", []llvm.Value{sliceSize}, "makeslice.buf")
 		slicePtr = b.CreateBitCast(slicePtr, llvm.PointerType(llvmElemType, 0), "makeslice.array")
 
 		// Extend or truncate if necessary. This is safe as we've already done
@@ -1987,17 +1910,6 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		default:
 			return llvm.Value{}, b.makeError(expr.Pos(), "unknown slice type: "+typ.String())
 		}
-	case *ssa.SliceToArrayPointer:
-		// Conversion from a slice to an array pointer, as the name clearly
-		// says. This requires a runtime check to make sure the slice is at
-		// least as big as the array.
-		slice := b.getValue(expr.X)
-		sliceLen := b.CreateExtractValue(slice, 1, "")
-		arrayLen := expr.Type().Underlying().(*types.Pointer).Elem().Underlying().(*types.Array).Len()
-		b.createSliceToArrayPointerCheck(sliceLen, arrayLen)
-		ptr := b.CreateExtractValue(slice, 0, "")
-		ptr = b.CreateBitCast(ptr, b.getLLVMType(expr.Type()), "")
-		return ptr, nil
 	case *ssa.TypeAssert:
 		return b.createTypeAssert(expr), nil
 	case *ssa.UnOp:
@@ -2026,58 +1938,17 @@ func (b *builder) createBinOp(op token.Token, typ, ytyp types.Type, x, y llvm.Va
 				return b.CreateSub(x, y, ""), nil
 			case token.MUL: // *
 				return b.CreateMul(x, y, ""), nil
-			case token.QUO, token.REM: // /, %
-				// Check for a divide by zero. If y is zero, the Go
-				// specification says that a runtime error must be triggered.
-				b.createDivideByZeroCheck(y)
-
+			case token.QUO: // /
 				if signed {
-					// Deal with signed division overflow.
-					// The LLVM LangRef says:
-					//
-					//   Overflow also leads to undefined behavior; this is a
-					//   rare case, but can occur, for example, by doing a
-					//   32-bit division of -2147483648 by -1.
-					//
-					// The Go specification however says this about division:
-					//
-					//   The one exception to this rule is that if the dividend
-					//   x is the most negative value for the int type of x, the
-					//   quotient q = x / -1 is equal to x (and r = 0) due to
-					//   two's-complement integer overflow.
-					//
-					// In other words, in the special case that the lowest
-					// possible signed integer is divided by -1, the result of
-					// the division is the same as x (the dividend).
-					// This is implemented by checking for this condition and
-					// changing y to 1 if it occurs, for example for 32-bit
-					// ints:
-					//
-					//   if x == -2147483648 && y == -1 {
-					//       y = 1
-					//   }
-					//
-					// Dividing x by 1 obviously returns x, therefore satisfying
-					// the Go specification without a branch.
-					llvmType := x.Type()
-					minusOne := llvm.ConstSub(llvm.ConstInt(llvmType, 0, false), llvm.ConstInt(llvmType, 1, false))
-					lowestInteger := llvm.ConstInt(x.Type(), 1<<(llvmType.IntTypeWidth()-1), false)
-					yIsMinusOne := b.CreateICmp(llvm.IntEQ, y, minusOne, "")
-					xIsLowestInteger := b.CreateICmp(llvm.IntEQ, x, lowestInteger, "")
-					hasOverflow := b.CreateAnd(yIsMinusOne, xIsLowestInteger, "")
-					y = b.CreateSelect(hasOverflow, llvm.ConstInt(llvmType, 1, true), y, "")
-
-					if op == token.QUO {
-						return b.CreateSDiv(x, y, ""), nil
-					} else {
-						return b.CreateSRem(x, y, ""), nil
-					}
+					return b.CreateSDiv(x, y, ""), nil
 				} else {
-					if op == token.QUO {
-						return b.CreateUDiv(x, y, ""), nil
-					} else {
-						return b.CreateURem(x, y, ""), nil
-					}
+					return b.CreateUDiv(x, y, ""), nil
+				}
+			case token.REM: // %
+				if signed {
+					return b.CreateSRem(x, y, ""), nil
+				} else {
+					return b.CreateURem(x, y, ""), nil
 				}
 			case token.AND: // &
 				return b.CreateAnd(x, y, ""), nil
@@ -2424,7 +2295,7 @@ func (b *builder) createBinOp(op token.Token, typ, ytyp types.Type, x, y llvm.Va
 }
 
 // createConst creates a LLVM constant value from a Go constant.
-func (b *builder) createConst(expr *ssa.Const) llvm.Value {
+func (b *builder) createConst(prefix string, expr *ssa.Const) llvm.Value {
 	switch typ := expr.Type().Underlying().(type) {
 	case *types.Basic:
 		llvmType := b.getLLVMType(typ)
@@ -2440,7 +2311,7 @@ func (b *builder) createConst(expr *ssa.Const) llvm.Value {
 			strLen := llvm.ConstInt(b.uintptrType, uint64(len(str)), false)
 			var strPtr llvm.Value
 			if str != "" {
-				objname := b.pkg.Path() + "$string"
+				objname := prefix + "$string"
 				global := llvm.AddGlobal(b.mod, llvm.ArrayType(b.ctx.Int8Type(), len(str)), objname)
 				global.SetInitializer(b.ctx.ConstString(str, false))
 				global.SetLinkage(llvm.InternalLinkage)
@@ -2470,15 +2341,15 @@ func (b *builder) createConst(expr *ssa.Const) llvm.Value {
 			n, _ := constant.Float64Val(expr.Value)
 			return llvm.ConstFloat(llvmType, n)
 		} else if typ.Kind() == types.Complex64 {
-			r := b.createConst(ssa.NewConst(constant.Real(expr.Value), types.Typ[types.Float32]))
-			i := b.createConst(ssa.NewConst(constant.Imag(expr.Value), types.Typ[types.Float32]))
+			r := b.createConst(prefix, ssa.NewConst(constant.Real(expr.Value), types.Typ[types.Float32]))
+			i := b.createConst(prefix, ssa.NewConst(constant.Imag(expr.Value), types.Typ[types.Float32]))
 			cplx := llvm.Undef(b.ctx.StructType([]llvm.Type{b.ctx.FloatType(), b.ctx.FloatType()}, false))
 			cplx = b.CreateInsertValue(cplx, r, 0, "")
 			cplx = b.CreateInsertValue(cplx, i, 1, "")
 			return cplx
 		} else if typ.Kind() == types.Complex128 {
-			r := b.createConst(ssa.NewConst(constant.Real(expr.Value), types.Typ[types.Float64]))
-			i := b.createConst(ssa.NewConst(constant.Imag(expr.Value), types.Typ[types.Float64]))
+			r := b.createConst(prefix, ssa.NewConst(constant.Real(expr.Value), types.Typ[types.Float64]))
+			i := b.createConst(prefix, ssa.NewConst(constant.Imag(expr.Value), types.Typ[types.Float64]))
 			cplx := llvm.Undef(b.ctx.StructType([]llvm.Type{b.ctx.DoubleType(), b.ctx.DoubleType()}, false))
 			cplx = b.CreateInsertValue(cplx, r, 0, "")
 			cplx = b.CreateInsertValue(cplx, i, 1, "")

compiler/compiler_test.go

@@ -9,7 +9,6 @@ import (
 	"testing"
 
 	"github.com/tinygo-org/tinygo/compileopts"
-	"github.com/tinygo-org/tinygo/goenv"
 	"github.com/tinygo-org/tinygo/loader"
 	"tinygo.org/x/go-llvm"
 )
@@ -17,11 +16,6 @@ import (
 // Pass -update to go test to update the output of the test files.
 var flagUpdate = flag.Bool("update", false, "update tests based on test output")
 
-type testCase struct {
-	file   string
-	target string
-}
-
 // Basic tests for the compiler. Build some Go files and compare the output with
 // the expected LLVM IR for regression testing.
 func TestCompiler(t *testing.T) {
@@ -40,7 +34,10 @@ func TestCompiler(t *testing.T) {
 		t.Skip("compiler tests require LLVM 11 or above, got LLVM ", llvm.Version)
 	}
 
-	tests := []testCase{
+	tests := []struct {
+		file   string
+		target string
+	}{
 		{"basic.go", ""},
 		{"pointer.go", ""},
 		{"slice.go", ""},
@@ -51,18 +48,6 @@ func TestCompiler(t *testing.T) {
 		{"pragma.go", ""},
 		{"goroutine.go", "wasm"},
 		{"goroutine.go", "cortex-m-qemu"},
-		{"channel.go", ""},
-		{"intrinsics.go", "cortex-m-qemu"},
-		{"intrinsics.go", "wasm"},
-		{"gc.go", ""},
-	}
-
-	_, minor, err := goenv.GetGorootVersion(goenv.Get("GOROOT"))
-	if err != nil {
-		t.Fatal("could not read Go version:", err)
-	}
-	if minor >= 17 {
-		tests = append(tests, testCase{"go1.17.go", ""})
 	}
 
 	for _, tc := range tests {
@@ -74,15 +59,12 @@ func TestCompiler(t *testing.T) {
 		}
 
 		t.Run(name, func(t *testing.T) {
-			options := &compileopts.Options{
-				Target: targetString,
-			}
-			target, err := compileopts.LoadTarget(options)
+			target, err := compileopts.LoadTarget(targetString)
 			if err != nil {
 				t.Fatal("failed to load target:", err)
 			}
 			config := &compileopts.Config{
-				Options: options,
+				Options: &compileopts.Options{},
 				Target:  target,
 			}
 			compilerConfig := &Config{

compiler/defer.go

@@ -217,8 +217,7 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 		// 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)
-		nilPtr := llvm.ConstNull(b.i8ptrType)
-		allocCall := b.createRuntimeCall("alloc", []llvm.Value{sizeValue, nilPtr}, "defer.alloc.call")
+		allocCall := b.createRuntimeCall("alloc", []llvm.Value{sizeValue}, "defer.alloc.call")
 		alloca = b.CreateBitCast(allocCall, llvm.PointerType(deferFrameType, 0), "defer.alloc")
 	}
 	if b.NeedsStackObjects {
@@ -332,10 +331,10 @@ func (b *builder) createRunDefers() {
 				//Pass context
 				forwardParams = append(forwardParams, context)
 			} else {
-				// Move typecode from the start to the end of the list of
-				// parameters.
-				forwardParams = append(forwardParams[1:], forwardParams[0])
-				fnPtr = b.getInvokeFunction(callback)
+				// Isolate the typecode.
+				typecode := forwardParams[0]
+				forwardParams = forwardParams[1:]
+				fnPtr = b.getInvokePtr(callback, typecode)
 
 				// Add the context parameter. An interface call cannot also be a
 				// closure but we have to supply the parameter anyway for platforms

compiler/embed.go

@@ -0,0 +1,70 @@
+package compiler
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+)
+
+// parseGoEmbed parses the text following "//go:embed" to extract the glob patterns.
+// It accepts unquoted space-separated patterns as well as double-quoted and back-quoted Go strings.
+// Copied from https://github.com/golang/go/blob/219fe9d547d09d3de1b024c6c8b8314dd0bf12e4/src/cmd/compile/internal/noder/noder.go#L1717-L1776
+func parseGoEmbed(args string) ([]string, error) {
+	var list []string
+	for args = strings.TrimSpace(args); args != ""; args = strings.TrimSpace(args) {
+		var path string
+	Switch:
+		switch args[0] {
+		default:
+			i := len(args)
+			for j, c := range args {
+				if unicode.IsSpace(c) {
+					i = j
+					break
+				}
+			}
+			path = args[:i]
+			args = args[i:]
+
+		case '`':
+			i := strings.Index(args[1:], "`")
+			if i < 0 {
+				return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args)
+			}
+			path = args[1 : 1+i]
+			args = args[1+i+1:]
+
+		case '"':
+			i := 1
+			for ; i < len(args); i++ {
+				if args[i] == '\\' {
+					i++
+					continue
+				}
+				if args[i] == '"' {
+					q, err := strconv.Unquote(args[:i+1])
+					if err != nil {
+						return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args[:i+1])
+					}
+					path = q
+					args = args[i+1:]
+					break Switch
+				}
+			}
+			if i >= len(args) {
+				return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args)
+			}
+		}
+
+		if args != "" {
+			r, _ := utf8.DecodeRuneInString(args)
+			if !unicode.IsSpace(r) {
+				return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args)
+			}
+		}
+		list = append(list, path)
+	}
+	return list, nil
+}

compiler/errors.go

@@ -3,6 +3,7 @@ package compiler
 // This file contains some utility functions related to error handling.
 
 import (
+	"go/scanner"
 	"go/token"
 	"go/types"
 	"path/filepath"
@@ -19,11 +20,20 @@ func (c *compilerContext) makeError(pos token.Pos, msg string) types.Error {
 	}
 }
 
-// addError adds a new compiler diagnostic with the given location and message.
 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 {

compiler/func.go

@@ -23,7 +23,7 @@ func (c *compilerContext) createFuncValue(builder llvm.Builder, funcPtr, context
 	switch c.FuncImplementation {
 	case "doubleword":
 		// Closure is: {context, function pointer}
-		funcValueScalar = llvm.ConstBitCast(funcPtr, c.rawVoidFuncType)
+		funcValueScalar = funcPtr
 	case "switch":
 		funcValueWithSignatureGlobalName := funcPtr.Name() + "$withSignature"
 		funcValueWithSignatureGlobal := c.mod.NamedGlobal(funcValueWithSignatureGlobalName)
@@ -80,21 +80,8 @@ func (b *builder) decodeFuncValue(funcValue llvm.Value, sig *types.Signature) (f
 	context = b.CreateExtractValue(funcValue, 0, "")
 	switch b.FuncImplementation {
 	case "doubleword":
-		bitcast := b.CreateExtractValue(funcValue, 1, "")
-		if !bitcast.IsAConstantExpr().IsNil() && bitcast.Opcode() == llvm.BitCast {
-			funcPtr = bitcast.Operand(0)
-			return
-		}
-		llvmSig := b.getRawFuncType(sig)
-		funcPtr = b.CreateBitCast(bitcast, llvmSig, "")
+		funcPtr = b.CreateExtractValue(funcValue, 1, "")
 	case "switch":
-		if !funcValue.IsAConstant().IsNil() {
-			// If this is a constant func value, the underlying function is
-			// known and can be returned directly.
-			funcValueWithSignatureGlobal := llvm.ConstExtractValue(funcValue, []uint32{1}).Operand(0)
-			funcPtr = llvm.ConstExtractValue(funcValueWithSignatureGlobal.Initializer(), []uint32{0}).Operand(0)
-			return
-		}
 		llvmSig := b.getRawFuncType(sig)
 		sigGlobal := b.getFuncSignatureID(sig)
 		funcPtr = b.createRuntimeCall("getFuncPtr", []llvm.Value{funcValue, sigGlobal}, "")
@@ -109,7 +96,8 @@ func (b *builder) decodeFuncValue(funcValue llvm.Value, sig *types.Signature) (f
 func (c *compilerContext) getFuncType(typ *types.Signature) llvm.Type {
 	switch c.FuncImplementation {
 	case "doubleword":
-		return c.ctx.StructType([]llvm.Type{c.i8ptrType, c.rawVoidFuncType}, false)
+		rawPtr := c.getRawFuncType(typ)
+		return c.ctx.StructType([]llvm.Type{c.i8ptrType, rawPtr}, false)
 	case "switch":
 		return c.getLLVMRuntimeType("funcValue")
 	default:

compiler/goroutine.go

@@ -79,15 +79,7 @@ func (b *builder) createGo(instr *ssa.Go) {
 		}
 		b.createBuiltin(argTypes, argValues, builtin.Name(), instr.Pos())
 		return
-	} else if instr.Call.IsInvoke() {
-		// This is a method call on an interface value.
-		itf := b.getValue(instr.Call.Value)
-		itfTypeCode := b.CreateExtractValue(itf, 0, "")
-		itfValue := b.CreateExtractValue(itf, 1, "")
-		funcPtr = b.getInvokeFunction(&instr.Call)
-		params = append([]llvm.Value{itfValue}, params...) // start with receiver
-		params = append(params, itfTypeCode)               // end with typecode
-	} else {
+	} else if !instr.Call.IsInvoke() {
 		// This is a function pointer.
 		// At the moment, two extra params are passed to the newly started
 		// goroutine:
@@ -107,6 +99,9 @@ func (b *builder) createGo(instr *ssa.Go) {
 			panic("unknown scheduler type")
 		}
 		prefix = b.fn.RelString(nil)
+	} else {
+		b.addError(instr.Pos(), "todo: go on interface call")
+		return
 	}
 
 	paramBundle := b.emitPointerPack(params)
@@ -181,7 +176,6 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 		// Create the wrapper.
 		wrapperType := llvm.FunctionType(c.ctx.VoidType(), []llvm.Type{c.i8ptrType}, false)
 		wrapper = llvm.AddFunction(c.mod, name+"$gowrapper", wrapperType)
-		c.addStandardAttributes(wrapper)
 		wrapper.SetLinkage(llvm.LinkOnceODRLinkage)
 		wrapper.SetUnnamedAddr(true)
 		wrapper.AddAttributeAtIndex(-1, c.ctx.CreateStringAttribute("tinygo-gowrapper", name))
@@ -246,7 +240,6 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 		// Create the wrapper.
 		wrapperType := llvm.FunctionType(c.ctx.VoidType(), []llvm.Type{c.i8ptrType}, false)
 		wrapper = llvm.AddFunction(c.mod, prefix+".gowrapper", wrapperType)
-		c.addStandardAttributes(wrapper)
 		wrapper.SetLinkage(llvm.LinkOnceODRLinkage)
 		wrapper.SetUnnamedAddr(true)
 		wrapper.AddAttributeAtIndex(-1, c.ctx.CreateStringAttribute("tinygo-gowrapper", ""))

compiler/inlineasm.go

@@ -72,7 +72,7 @@ func (b *builder) createInlineAsmFull(instr *ssa.CallCommon) (llvm.Value, error)
 	args := []llvm.Value{}
 	constraints := []string{}
 	hasOutput := false
-	asmString = regexp.MustCompile(`\{\}`).ReplaceAllStringFunc(asmString, func(s string) string {
+	asmString = regexp.MustCompile("\\{\\}").ReplaceAllStringFunc(asmString, func(s string) string {
 		hasOutput = true
 		return "$0"
 	})
@@ -80,7 +80,7 @@ func (b *builder) createInlineAsmFull(instr *ssa.CallCommon) (llvm.Value, error)
 		constraints = append(constraints, "=&r")
 		registerNumbers[""] = 0
 	}
-	asmString = regexp.MustCompile(`\{[a-zA-Z]+\}`).ReplaceAllStringFunc(asmString, func(s string) string {
+	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]

compiler/interface.go

@@ -47,7 +47,6 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 		var length int64
 		var methodSet llvm.Value
 		var ptrTo llvm.Value
-		var typeAssert llvm.Value
 		switch typ := typ.(type) {
 		case *types.Named:
 			references = c.getTypeCode(typ.Underlying())
@@ -70,9 +69,6 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 		}
 		if _, ok := typ.Underlying().(*types.Interface); !ok {
 			methodSet = c.getTypeMethodSet(typ)
-		} else {
-			typeAssert = c.getInterfaceImplementsFunc(typ)
-			typeAssert = llvm.ConstPtrToInt(typeAssert, c.uintptrType)
 		}
 		if _, ok := typ.Underlying().(*types.Pointer); !ok {
 			ptrTo = c.getTypeCode(types.NewPointer(typ))
@@ -91,9 +87,6 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 		if !ptrTo.IsNil() {
 			globalValue = llvm.ConstInsertValue(globalValue, ptrTo, []uint32{3})
 		}
-		if !typeAssert.IsNil() {
-			globalValue = llvm.ConstInsertValue(globalValue, typeAssert, []uint32{4})
-		}
 		global.SetInitializer(globalValue)
 		global.SetLinkage(llvm.LinkOnceODRLinkage)
 		global.SetGlobalConstant(true)
@@ -200,11 +193,7 @@ func getTypeCodeName(t types.Type) string {
 	case *types.Interface:
 		methods := make([]string, t.NumMethods())
 		for i := 0; i < t.NumMethods(); i++ {
-			name := t.Method(i).Name()
-			if !token.IsExported(name) {
-				name = t.Method(i).Pkg().Path() + "." + name
-			}
-			methods[i] = name + ":" + getTypeCodeName(t.Method(i).Type())
+			methods[i] = t.Method(i).Name() + ":" + getTypeCodeName(t.Method(i).Type())
 		}
 		return "interface:" + "{" + strings.Join(methods, ",") + "}"
 	case *types.Map:
@@ -317,9 +306,10 @@ func (c *compilerContext) getInterfaceMethodSet(typ types.Type) llvm.Value {
 	return llvm.ConstGEP(global, []llvm.Value{zero, zero})
 }
 
-// getMethodSignatureName returns a unique name (that can be used as the name of
-// a global) for the given method.
-func (c *compilerContext) getMethodSignatureName(method *types.Func) string {
+// getMethodSignature returns a global variable which is a reference to an
+// external *i8 indicating the indicating the signature of this method. It is
+// used during the interface lowering pass.
+func (c *compilerContext) getMethodSignature(method *types.Func) llvm.Value {
 	signature := methodSignature(method)
 	var globalName string
 	if token.IsExported(method.Name()) {
@@ -327,14 +317,6 @@ func (c *compilerContext) getMethodSignatureName(method *types.Func) string {
 	} else {
 		globalName = method.Type().(*types.Signature).Recv().Pkg().Path() + ".$methods." + signature
 	}
-	return globalName
-}
-
-// getMethodSignature returns a global variable which is a reference to an
-// external *i8 indicating the indicating the signature of this method. It is
-// used during the interface lowering pass.
-func (c *compilerContext) getMethodSignature(method *types.Func) llvm.Value {
-	globalName := c.getMethodSignatureName(method)
 	signatureGlobal := c.mod.NamedGlobal(globalName)
 	if signatureGlobal.IsNil() {
 		// TODO: put something useful in these globals, such as the method
@@ -363,16 +345,15 @@ func (b *builder) createTypeAssert(expr *ssa.TypeAssert) llvm.Value {
 	commaOk := llvm.Value{}
 	if _, ok := expr.AssertedType.Underlying().(*types.Interface); ok {
 		// Type assert on interface type.
-		// This is a call to an interface type assert function.
-		// The interface lowering pass will define this function by filling it
-		// with a type switch over all concrete types that implement this
-		// interface, and returning whether it's one of the matched types.
+		// This pseudo call will be lowered in the interface lowering pass to a
+		// real call which checks whether the provided typecode is any of the
+		// concrete types that implements this interface.
 		// This is very different from how interface asserts are implemented in
 		// the main Go compiler, where the runtime checks whether the type
 		// implements each method of the interface. See:
 		// https://research.swtch.com/interfaces
-		fn := b.getInterfaceImplementsFunc(expr.AssertedType)
-		commaOk = b.CreateCall(fn, []llvm.Value{actualTypeNum}, "")
+		methodSet := b.getInterfaceMethodSet(expr.AssertedType)
+		commaOk = b.createRuntimeCall("interfaceImplements", []llvm.Value{actualTypeNum, methodSet}, "")
 
 	} else {
 		globalName := "reflect/types.typeid:" + getTypeCodeName(expr.AssertedType)
@@ -439,52 +420,39 @@ func (b *builder) createTypeAssert(expr *ssa.TypeAssert) llvm.Value {
 	}
 }
 
-// getMethodsString returns a string to be used in the "tinygo-methods" string
-// attribute for interface functions.
-func (c *compilerContext) getMethodsString(itf *types.Interface) string {
-	methods := make([]string, itf.NumMethods())
-	for i := range methods {
-		methods[i] = c.getMethodSignatureName(itf.Method(i))
+// 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,
+		b.getInterfaceMethodSet(instr.Value.Type()),
+		b.getMethodSignature(instr.Method),
 	}
-	return strings.Join(methods, "; ")
+	fn := b.createRuntimeCall("interfaceMethod", values, "invoke.func")
+	return b.CreateIntToPtr(fn, llvmFnType, "invoke.func.cast")
 }
 
-// getInterfaceImplementsfunc returns a declared function that works as a type
-// switch. The interface lowering pass will define this function.
-func (c *compilerContext) getInterfaceImplementsFunc(assertedType types.Type) llvm.Value {
-	fnName := getTypeCodeName(assertedType.Underlying()) + ".$typeassert"
-	llvmFn := c.mod.NamedFunction(fnName)
-	if llvmFn.IsNil() {
-		llvmFnType := llvm.FunctionType(c.ctx.Int1Type(), []llvm.Type{c.uintptrType}, false)
-		llvmFn = llvm.AddFunction(c.mod, fnName, llvmFnType)
-		c.addStandardDeclaredAttributes(llvmFn)
-		methods := c.getMethodsString(assertedType.Underlying().(*types.Interface))
-		llvmFn.AddFunctionAttr(c.ctx.CreateStringAttribute("tinygo-methods", methods))
-	}
-	return llvmFn
-}
+// 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
 
-// getInvokeFunction returns the thunk to call the given interface method. The
-// thunk is declared, not defined: it will be defined by the interface lowering
-// pass.
-func (c *compilerContext) getInvokeFunction(instr *ssa.CallCommon) llvm.Value {
-	fnName := getTypeCodeName(instr.Value.Type().Underlying()) + "." + instr.Method.Name() + "$invoke"
-	llvmFn := c.mod.NamedFunction(fnName)
-	if llvmFn.IsNil() {
-		sig := instr.Method.Type().(*types.Signature)
-		var paramTuple []*types.Var
-		for i := 0; i < sig.Params().Len(); i++ {
-			paramTuple = append(paramTuple, sig.Params().At(i))
-		}
-		paramTuple = append(paramTuple, types.NewVar(token.NoPos, nil, "$typecode", types.Typ[types.Uintptr]))
-		llvmFnType := c.getRawFuncType(types.NewSignature(sig.Recv(), types.NewTuple(paramTuple...), sig.Results(), false)).ElementType()
-		llvmFn = llvm.AddFunction(c.mod, fnName, llvmFnType)
-		c.addStandardDeclaredAttributes(llvmFn)
-		llvmFn.AddFunctionAttr(c.ctx.CreateStringAttribute("tinygo-invoke", c.getMethodSignatureName(instr.Method)))
-		methods := c.getMethodsString(instr.Value.Type().Underlying().(*types.Interface))
-		llvmFn.AddFunctionAttr(c.ctx.CreateStringAttribute("tinygo-methods", methods))
+	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, b.getValue(arg))
 	}
-	return llvmFn
+	// Add the context parameter. An interface call never takes a context but we
+	// have to supply the parameter anyway.
+	args = append(args, llvm.Undef(b.i8ptrType))
+	// Add the parent goroutine handle.
+	args = append(args, llvm.Undef(b.i8ptrType))
+
+	return fnCast, args
 }
 
 // getInterfaceInvokeWrapper returns a wrapper for the given method so it can be
@@ -521,7 +489,6 @@ func (c *compilerContext) getInterfaceInvokeWrapper(fn *ssa.Function, llvmFn llv
 	paramTypes := append([]llvm.Type{c.i8ptrType}, fnType.ParamTypes()[len(expandedReceiverType):]...)
 	wrapFnType := llvm.FunctionType(fnType.ReturnType(), paramTypes, false)
 	wrapper = llvm.AddFunction(c.mod, wrapperName, wrapFnType)
-	c.addStandardAttributes(wrapper)
 	wrapper.LastParam().SetName("parentHandle")
 
 	wrapper.SetLinkage(llvm.LinkOnceODRLinkage)

compiler/interrupt.go

@@ -36,8 +36,6 @@ func (b *builder) createInterruptGlobal(instr *ssa.CallCommon) (llvm.Value, erro
 		// Fall back to a generic error.
 		return llvm.Value{}, b.makeError(instr.Pos(), "interrupt function must be constant")
 	}
-	funcRawPtr, funcContext := b.decodeFuncValue(funcValue, nil)
-	funcPtr := llvm.ConstPtrToInt(funcRawPtr, b.uintptrType)
 
 	// Create a new global of type runtime/interrupt.handle. Globals of this
 	// type are lowered in the interrupt lowering pass.
@@ -49,9 +47,8 @@ func (b *builder) createInterruptGlobal(instr *ssa.CallCommon) (llvm.Value, erro
 	global.SetGlobalConstant(true)
 	global.SetUnnamedAddr(true)
 	initializer := llvm.ConstNull(globalLLVMType)
-	initializer = llvm.ConstInsertValue(initializer, funcContext, []uint32{0})
-	initializer = llvm.ConstInsertValue(initializer, funcPtr, []uint32{1})
-	initializer = llvm.ConstInsertValue(initializer, llvm.ConstInt(b.intType, uint64(id.Int64()), true), []uint32{2, 0})
+	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.

compiler/intrinsics.go

@@ -48,57 +48,3 @@ func (b *builder) createMemoryZeroCall(args []ssa.Value) (llvm.Value, error) {
 	b.CreateCall(llvmFn, params, "")
 	return llvm.Value{}, nil
 }
-
-var mathToLLVMMapping = map[string]string{
-	"math.Sqrt":  "llvm.sqrt.f64",
-	"math.Floor": "llvm.floor.f64",
-	"math.Ceil":  "llvm.ceil.f64",
-	"math.Trunc": "llvm.trunc.f64",
-}
-
-// createMathOp tries to lower the given call as a LLVM math intrinsic, if
-// possible. It returns the call result if possible, and a boolean whether it
-// succeeded. If it doesn't succeed, the architecture doesn't support the given
-// intrinsic.
-func (b *builder) createMathOp(call *ssa.CallCommon) (llvm.Value, bool) {
-	// Check whether this intrinsic is supported on the given GOARCH.
-	// If it is unsupported, this can have two reasons:
-	//
-	//  1. LLVM can expand the intrinsic inline (using float instructions), but
-	//     the result doesn't pass the tests of the math package.
-	//  2. LLVM cannot expand the intrinsic inline, will therefore lower it as a
-	//     libm function call, but the libm function call also fails the math
-	//     package tests.
-	//
-	// Whatever the implementation, it must pass the tests in the math package
-	// so unfortunately only the below intrinsic+architecture combinations are
-	// supported.
-	name := call.StaticCallee().RelString(nil)
-	switch name {
-	case "math.Ceil", "math.Floor", "math.Trunc":
-		if b.GOARCH != "wasm" && b.GOARCH != "arm64" {
-			return llvm.Value{}, false
-		}
-	case "math.Sqrt":
-		if b.GOARCH != "wasm" && b.GOARCH != "amd64" && b.GOARCH != "386" {
-			return llvm.Value{}, false
-		}
-	default:
-		return llvm.Value{}, false // only the above functions are supported.
-	}
-
-	llvmFn := b.mod.NamedFunction(mathToLLVMMapping[name])
-	if llvmFn.IsNil() {
-		// The intrinsic doesn't exist yet, so declare it.
-		// At the moment, all supported intrinsics have the form "double
-		// foo(double %x)" so we can hardcode the signature here.
-		llvmType := llvm.FunctionType(b.ctx.DoubleType(), []llvm.Type{b.ctx.DoubleType()}, false)
-		llvmFn = llvm.AddFunction(b.mod, mathToLLVMMapping[name], llvmType)
-	}
-	// Create a call to the intrinsic.
-	args := make([]llvm.Value, len(call.Args))
-	for i, arg := range call.Args {
-		args[i] = b.getValue(arg)
-	}
-	return b.CreateCall(llvmFn, args, ""), true
-}

compiler/llvm.go

@@ -1,11 +1,6 @@
 package compiler
 
 import (
-	"fmt"
-	"go/token"
-	"go/types"
-	"math/big"
-
 	"github.com/tinygo-org/tinygo/compiler/llvmutil"
 	"tinygo.org/x/go-llvm"
 )
@@ -13,6 +8,21 @@ import (
 // This file contains helper functions for LLVM that are not exposed in the Go
 // bindings.
 
+// Return a list of values (actually, instructions) where this value is used as
+// an operand.
+func getUses(value llvm.Value) []llvm.Value {
+	if value.IsNil() {
+		return nil
+	}
+	var uses []llvm.Value
+	use := value.FirstUse()
+	for !use.IsNil() {
+		uses = append(uses, use.User())
+		use = use.NextUse()
+	}
+	return uses
+}
+
 // createTemporaryAlloca creates a new alloca in the entry block and adds
 // lifetime start information in the IR signalling that the alloca won't be used
 // before this point.
@@ -34,7 +44,7 @@ func (b *builder) emitLifetimeEnd(ptr, size llvm.Value) {
 // bitcasts, or else allocates a value on the heap if it cannot be packed in the
 // pointer value directly. It returns the pointer with the packed data.
 func (b *builder) emitPointerPack(values []llvm.Value) llvm.Value {
-	return llvmutil.EmitPointerPack(b.Builder, b.mod, b.pkg.Path(), b.NeedsStackObjects, values)
+	return llvmutil.EmitPointerPack(b.Builder, b.mod, b.NeedsStackObjects, values)
 }
 
 // emitPointerUnpack extracts a list of values packed using emitPointerPack.
@@ -57,199 +67,3 @@ func (c *compilerContext) makeGlobalArray(buf []byte, name string, elementType l
 	global.SetInitializer(value)
 	return global
 }
-
-// createObjectLayout returns a LLVM value (of type i8*) that describes where
-// there are pointers in the type t. If all the data fits in a word, it is
-// returned as a word. Otherwise it will store the data in a global.
-//
-// The value contains two pieces of information: the length of the object and
-// which words contain a pointer (indicated by setting the given bit to 1). For
-// arrays, only the element is stored. This works because the GC knows the
-// object size and can therefore know how this value is repeated in the object.
-func (c *compilerContext) createObjectLayout(t llvm.Type, pos token.Pos) llvm.Value {
-	// Use the element type for arrays. This works even for nested arrays.
-	for {
-		kind := t.TypeKind()
-		if kind == llvm.ArrayTypeKind {
-			t = t.ElementType()
-			continue
-		}
-		if kind == llvm.StructTypeKind {
-			fields := t.StructElementTypes()
-			if len(fields) == 1 {
-				t = fields[0]
-				continue
-			}
-		}
-		break
-	}
-
-	// Do a few checks to see whether we need to generate any object layout
-	// information at all.
-	objectSizeBytes := c.targetData.TypeAllocSize(t)
-	pointerSize := c.targetData.TypeAllocSize(c.i8ptrType)
-	pointerAlignment := c.targetData.PrefTypeAlignment(c.i8ptrType)
-	if objectSizeBytes < pointerSize {
-		// Too small to contain a pointer.
-		layout := (uint64(1) << 1) | 1
-		return llvm.ConstIntToPtr(llvm.ConstInt(c.uintptrType, layout, false), c.i8ptrType)
-	}
-	bitmap := c.getPointerBitmap(t, pos)
-	if bitmap.BitLen() == 0 {
-		// There are no pointers in this type, so we can simplify the layout.
-		// TODO: this can be done in many other cases, e.g. when allocating an
-		// array (like [4][]byte, which repeats a slice 4 times).
-		layout := (uint64(1) << 1) | 1
-		return llvm.ConstIntToPtr(llvm.ConstInt(c.uintptrType, layout, false), c.i8ptrType)
-	}
-	if objectSizeBytes%uint64(pointerAlignment) != 0 {
-		// This shouldn't happen except for packed structs, which aren't
-		// currently used.
-		c.addError(pos, "internal error: unexpected object size for object with pointer field")
-		return llvm.ConstNull(c.i8ptrType)
-	}
-	objectSizeWords := objectSizeBytes / uint64(pointerAlignment)
-
-	pointerBits := pointerSize * 8
-	var sizeFieldBits uint64
-	switch pointerBits {
-	case 16:
-		sizeFieldBits = 4
-	case 32:
-		sizeFieldBits = 5
-	case 64:
-		sizeFieldBits = 6
-	default:
-		panic("unknown pointer size")
-	}
-	layoutFieldBits := pointerBits - 1 - sizeFieldBits
-
-	// Try to emit the value as an inline integer. This is possible in most
-	// cases.
-	if objectSizeWords < layoutFieldBits {
-		// If it can be stored directly in the pointer value, do so.
-		// The runtime knows that if the least significant bit of the pointer is
-		// set, the pointer contains the value itself.
-		layout := bitmap.Uint64()<<(sizeFieldBits+1) | (objectSizeWords << 1) | 1
-		return llvm.ConstIntToPtr(llvm.ConstInt(c.uintptrType, layout, false), c.i8ptrType)
-	}
-
-	// Unfortunately, the object layout is too big to fit in a pointer-sized
-	// integer. Store it in a global instead.
-
-	// Try first whether the global already exists. All objects with a
-	// particular name have the same type, so this is possible.
-	globalName := "runtime/gc.layout:" + fmt.Sprintf("%d-%0*x", objectSizeWords, (objectSizeWords+15)/16, bitmap)
-	global := c.mod.NamedGlobal(globalName)
-	if !global.IsNil() {
-		return llvm.ConstBitCast(global, c.i8ptrType)
-	}
-
-	// Create the global initializer.
-	bitmapBytes := make([]byte, int(objectSizeWords+7)/8)
-	copy(bitmapBytes, bitmap.Bytes())
-	var bitmapByteValues []llvm.Value
-	for _, b := range bitmapBytes {
-		bitmapByteValues = append(bitmapByteValues, llvm.ConstInt(c.ctx.Int8Type(), uint64(b), false))
-	}
-	initializer := c.ctx.ConstStruct([]llvm.Value{
-		llvm.ConstInt(c.uintptrType, objectSizeWords, false),
-		llvm.ConstArray(c.ctx.Int8Type(), bitmapByteValues),
-	}, false)
-
-	global = llvm.AddGlobal(c.mod, initializer.Type(), globalName)
-	global.SetInitializer(initializer)
-	global.SetUnnamedAddr(true)
-	global.SetGlobalConstant(true)
-	global.SetLinkage(llvm.LinkOnceODRLinkage)
-	if c.targetData.PrefTypeAlignment(c.uintptrType) < 2 {
-		// AVR doesn't have alignment by default.
-		global.SetAlignment(2)
-	}
-	if c.Debug && pos != token.NoPos {
-		// Creating a fake global so that the value can be inspected in GDB.
-		// For example, the layout for strings.stringFinder (as of Go version
-		// 1.15) has the following type according to GDB:
-		//   type = struct {
-		//       uintptr numBits;
-		//       uint8 data[33];
-		//   }
-		// ...that's sort of a mixed C/Go type, but it is readable. More
-		// importantly, these object layout globals can be read and printed by
-		// GDB which may be useful for debugging.
-		position := c.program.Fset.Position(pos)
-		diglobal := c.dibuilder.CreateGlobalVariableExpression(c.difiles[position.Filename], llvm.DIGlobalVariableExpression{
-			Name: globalName,
-			File: c.getDIFile(position.Filename),
-			Line: position.Line,
-			Type: c.getDIType(types.NewStruct([]*types.Var{
-				types.NewVar(pos, nil, "numBits", types.Typ[types.Uintptr]),
-				types.NewVar(pos, nil, "data", types.NewArray(types.Typ[types.Byte], int64(len(bitmapByteValues)))),
-			}, nil)),
-			LocalToUnit: false,
-			Expr:        c.dibuilder.CreateExpression(nil),
-		})
-		global.AddMetadata(0, diglobal)
-	}
-
-	return llvm.ConstBitCast(global, c.i8ptrType)
-}
-
-// getPointerBitmap scans the given LLVM type for pointers and sets bits in a
-// bigint at the word offset that contains a pointer. This scan is recursive.
-func (c *compilerContext) getPointerBitmap(typ llvm.Type, pos token.Pos) *big.Int {
-	alignment := c.targetData.PrefTypeAlignment(c.i8ptrType)
-	switch typ.TypeKind() {
-	case llvm.IntegerTypeKind, llvm.FloatTypeKind, llvm.DoubleTypeKind:
-		return big.NewInt(0)
-	case llvm.PointerTypeKind:
-		return big.NewInt(1)
-	case llvm.StructTypeKind:
-		ptrs := big.NewInt(0)
-		if typ.StructName() == "runtime.funcValue" {
-			// Hack: the type runtime.funcValue contains an 'id' field which is
-			// of type uintptr, but before the LowerFuncValues pass it actually
-			// contains a pointer (ptrtoint) to a global. This trips up the
-			// interp package. Therefore, make the id field a pointer for now.
-			typ = c.ctx.StructType([]llvm.Type{c.i8ptrType, c.i8ptrType}, false)
-		}
-		for i, subtyp := range typ.StructElementTypes() {
-			subptrs := c.getPointerBitmap(subtyp, pos)
-			if subptrs.BitLen() == 0 {
-				continue
-			}
-			offset := c.targetData.ElementOffset(typ, i)
-			if offset%uint64(alignment) != 0 {
-				// This error will let the compilation fail, but by continuing
-				// the error can still easily be shown.
-				c.addError(pos, "internal error: allocated struct contains unaligned pointer")
-				continue
-			}
-			subptrs.Lsh(subptrs, uint(offset)/uint(alignment))
-			ptrs.Or(ptrs, subptrs)
-		}
-		return ptrs
-	case llvm.ArrayTypeKind:
-		subtyp := typ.ElementType()
-		subptrs := c.getPointerBitmap(subtyp, pos)
-		ptrs := big.NewInt(0)
-		if subptrs.BitLen() == 0 {
-			return ptrs
-		}
-		elementSize := c.targetData.TypeAllocSize(subtyp)
-		if elementSize%uint64(alignment) != 0 {
-			// This error will let the compilation fail (but continues so that
-			// other errors can be shown).
-			c.addError(pos, "internal error: allocated array contains unaligned pointer")
-			return ptrs
-		}
-		for i := 0; i < typ.ArrayLength(); i++ {
-			ptrs.Lsh(ptrs, uint(elementSize)/uint(alignment))
-			ptrs.Or(ptrs, subptrs)
-		}
-		return ptrs
-	default:
-		// Should not happen.
-		panic("unknown LLVM type")
-	}
-}

compiler/llvmutil/wordpack.go

@@ -12,7 +12,7 @@ import (
 // bitcasts, or else allocates a value on the heap if it cannot be packed in the
 // pointer value directly. It returns the pointer with the packed data.
 // If the values are all constants, they are be stored in a constant global and deduplicated.
-func EmitPointerPack(builder llvm.Builder, mod llvm.Module, prefix string, needsStackObjects bool, values []llvm.Value) llvm.Value {
+func EmitPointerPack(builder llvm.Builder, mod llvm.Module, needsStackObjects bool, values []llvm.Value) llvm.Value {
 	ctx := mod.Context()
 	targetData := llvm.NewTargetData(mod.DataLayout())
 	i8ptrType := llvm.PointerType(mod.Context().Int8Type(), 0)
@@ -83,11 +83,12 @@ func EmitPointerPack(builder llvm.Builder, mod llvm.Module, prefix string, needs
 		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.
-			global := llvm.AddGlobal(mod, packedType, prefix+"$pack")
+			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.InternalLinkage)
+			global.SetLinkage(llvm.PrivateLinkage)
 			return llvm.ConstBitCast(global, i8ptrType)
 		}
 
@@ -96,7 +97,6 @@ func EmitPointerPack(builder llvm.Builder, mod llvm.Module, prefix string, needs
 		alloc := mod.NamedFunction("runtime.alloc")
 		packedHeapAlloc := builder.CreateCall(alloc, []llvm.Value{
 			sizeValue,
-			llvm.ConstNull(i8ptrType),
 			llvm.Undef(i8ptrType),            // unused context parameter
 			llvm.ConstPointerNull(i8ptrType), // coroutine handle
 		}, "")

compiler/symbol.go

@@ -26,7 +26,6 @@ type functionInfo struct {
 	linkName   string     // go:linkname, go:export - The name that we map for the particular module -> importName
 	section    string     // go:section - object file section name
 	exported   bool       // go:export, CGo
-	interrupt  bool       // go:interrupt
 	nobounds   bool       // go:nobounds
 	variadic   bool       // go:variadic (CGo only)
 	inline     inlineType // go:inline
@@ -109,7 +108,6 @@ func (c *compilerContext) getFunction(fn *ssa.Function) llvm.Value {
 			llvmFn.AddFunctionAttr(attr)
 		}
 	}
-	c.addStandardDeclaredAttributes(llvmFn)
 
 	dereferenceableOrNullKind := llvm.AttributeKindID("dereferenceable_or_null")
 	for i, info := range paramInfos {
@@ -252,10 +250,6 @@ func (info *functionInfo) parsePragmas(f *ssa.Function) {
 
 				importName = parts[1]
 				info.exported = true
-			case "//go:interrupt":
-				if hasUnsafeImport(f.Pkg.Pkg) {
-					info.interrupt = true
-				}
 			case "//go:wasm-module":
 				// Alternative comment for setting the import module.
 				if len(parts) != 2 {
@@ -329,47 +323,6 @@ func getParams(sig *types.Signature) []*types.Var {
 	return params
 }
 
-// addStandardDeclaredAttributes adds attributes that are set for any function,
-// whether declared or defined.
-func (c *compilerContext) addStandardDeclaredAttributes(llvmFn llvm.Value) {
-	if c.SizeLevel >= 1 {
-		// Set the "optsize" attribute to make slightly smaller binaries at the
-		// cost of minimal performance loss (-Os in Clang).
-		kind := llvm.AttributeKindID("optsize")
-		attr := c.ctx.CreateEnumAttribute(kind, 0)
-		llvmFn.AddFunctionAttr(attr)
-	}
-	if c.SizeLevel >= 2 {
-		// Set the "minsize" attribute to reduce code size even further,
-		// regardless of performance loss (-Oz in Clang).
-		kind := llvm.AttributeKindID("minsize")
-		attr := c.ctx.CreateEnumAttribute(kind, 0)
-		llvmFn.AddFunctionAttr(attr)
-	}
-}
-
-// addStandardDefinedAttributes adds the set of attributes that are added to
-// every function defined by TinyGo (even thunks/wrappers), possibly depending
-// on the architecture. It does not set attributes only set for declared
-// functions, use addStandardDeclaredAttributes for this.
-func (c *compilerContext) addStandardDefinedAttributes(llvmFn llvm.Value) {
-	// TinyGo does not currently raise exceptions, so set the 'nounwind' flag.
-	// This behavior matches Clang when compiling C source files.
-	// It reduces binary size on Linux a little bit on non-x86_64 targets by
-	// eliminating exception tables for these functions.
-	llvmFn.AddFunctionAttr(c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nounwind"), 0))
-	if strings.Split(c.Triple, "-")[0] == "x86_64" {
-		// Required by the ABI.
-		llvmFn.AddFunctionAttr(c.ctx.CreateEnumAttribute(llvm.AttributeKindID("uwtable"), 0))
-	}
-}
-
-// addStandardAttribute adds all attributes added to defined functions.
-func (c *compilerContext) addStandardAttributes(llvmFn llvm.Value) {
-	c.addStandardDeclaredAttributes(llvmFn)
-	c.addStandardDefinedAttributes(llvmFn)
-}
-
 // globalInfo contains some information about a specific global. By default,
 // linkName is equal to .RelString(nil) on a global and extern is false, but for
 // some symbols this is different (due to //go:extern for example).
@@ -378,6 +331,7 @@ type globalInfo struct {
 	extern   bool   // go:extern
 	align    int    // go:align
 	section  string // go:section
+	embeds   string // go:embed
 }
 
 // loadASTComments loads comments on globals from the AST, for use later in the
@@ -495,6 +449,9 @@ func (info *globalInfo) parsePragmas(doc *ast.CommentGroup) {
 			if len(parts) == 2 {
 				info.section = parts[1]
 			}
+		case "//go:embed":
+			raw := strings.TrimPrefix(comment.Text, "//go:embed")
+			info.embeds += " " + raw
 		}
 	}
 }

compiler/testdata/basic.go

@@ -10,22 +10,6 @@ func equalInt(x, y int) bool {
 	return x == y
 }
 
-func divInt(x, y int) int {
-	return x / y
-}
-
-func divUint(x, y uint) uint {
-	return x / y
-}
-
-func remInt(x, y int) int {
-	return x % y
-}
-
-func remUint(x, y uint) uint {
-	return x % y
-}
-
 func floatEQ(x, y float32) bool {
 	return x == y
 }
@@ -71,18 +55,3 @@ func complexMul(x, y complex64) complex64 {
 }
 
 // TODO: complexDiv (requires runtime call)
-
-// A type 'kv' also exists in function foo. Test that these two types don't
-// conflict with each other.
-type kv struct {
-	v float32
-}
-
-func foo(a *kv) {
-	// Define a new 'kv' type.
-	type kv struct {
-		v byte
-	}
-	// Use this type.
-	func(b *kv) {}(nil)
-}

compiler/testdata/basic.ll

@@ -1,159 +1,74 @@
 ; ModuleID = 'basic.go'
 source_filename = "basic.go"
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-wasi"
+target triple = "wasm32--wasi"
 
-%main.kv = type { float }
-%main.kv.0 = type { i8 }
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
 
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret void
 }
 
-; Function Attrs: nounwind
-define hidden i32 @main.addInt(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i32 @main.addInt(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %0 = add i32 %x, %y
   ret i32 %0
 }
 
-; Function Attrs: nounwind
-define hidden i1 @main.equalInt(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i1 @main.equalInt(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %0 = icmp eq i32 %x, %y
   ret i1 %0
 }
 
-; Function Attrs: nounwind
-define hidden i32 @main.divInt(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = icmp eq i32 %y, 0
-  br i1 %0, label %divbyzero.throw, label %divbyzero.next
-
-divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(i8* undef, i8* null) #0
-  unreachable
-
-divbyzero.next:                                   ; preds = %entry
-  %1 = icmp eq i32 %y, -1
-  %2 = icmp eq i32 %x, -2147483648
-  %3 = and i1 %1, %2
-  %4 = select i1 %3, i32 1, i32 %y
-  %5 = sdiv i32 %x, %4
-  ret i32 %5
-}
-
-declare void @runtime.divideByZeroPanic(i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden i32 @main.divUint(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = icmp eq i32 %y, 0
-  br i1 %0, label %divbyzero.throw, label %divbyzero.next
-
-divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(i8* undef, i8* null) #0
-  unreachable
-
-divbyzero.next:                                   ; preds = %entry
-  %1 = udiv i32 %x, %y
-  ret i32 %1
-}
-
-; Function Attrs: nounwind
-define hidden i32 @main.remInt(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = icmp eq i32 %y, 0
-  br i1 %0, label %divbyzero.throw, label %divbyzero.next
-
-divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(i8* undef, i8* null) #0
-  unreachable
-
-divbyzero.next:                                   ; preds = %entry
-  %1 = icmp eq i32 %y, -1
-  %2 = icmp eq i32 %x, -2147483648
-  %3 = and i1 %1, %2
-  %4 = select i1 %3, i32 1, i32 %y
-  %5 = srem i32 %x, %4
-  ret i32 %5
-}
-
-; Function Attrs: nounwind
-define hidden i32 @main.remUint(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = icmp eq i32 %y, 0
-  br i1 %0, label %divbyzero.throw, label %divbyzero.next
-
-divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(i8* undef, i8* null) #0
-  unreachable
-
-divbyzero.next:                                   ; preds = %entry
-  %1 = urem i32 %x, %y
-  ret i32 %1
-}
-
-; Function Attrs: nounwind
-define hidden i1 @main.floatEQ(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i1 @main.floatEQ(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %0 = fcmp oeq float %x, %y
   ret i1 %0
 }
 
-; Function Attrs: nounwind
-define hidden i1 @main.floatNE(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i1 @main.floatNE(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %0 = fcmp une float %x, %y
   ret i1 %0
 }
 
-; Function Attrs: nounwind
-define hidden i1 @main.floatLower(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i1 @main.floatLower(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %0 = fcmp olt float %x, %y
   ret i1 %0
 }
 
-; Function Attrs: nounwind
-define hidden i1 @main.floatLowerEqual(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i1 @main.floatLowerEqual(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %0 = fcmp ole float %x, %y
   ret i1 %0
 }
 
-; Function Attrs: nounwind
-define hidden i1 @main.floatGreater(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i1 @main.floatGreater(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %0 = fcmp ogt float %x, %y
   ret i1 %0
 }
 
-; Function Attrs: nounwind
-define hidden i1 @main.floatGreaterEqual(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i1 @main.floatGreaterEqual(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %0 = fcmp oge float %x, %y
   ret i1 %0
 }
 
-; Function Attrs: nounwind
-define hidden float @main.complexReal(float %x.r, float %x.i, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden float @main.complexReal(float %x.r, float %x.i, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret float %x.r
 }
 
-; Function Attrs: nounwind
-define hidden float @main.complexImag(float %x.r, float %x.i, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden float @main.complexImag(float %x.r, float %x.i, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret float %x.i
 }
 
-; Function Attrs: nounwind
-define hidden { float, float } @main.complexAdd(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden { float, float } @main.complexAdd(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %0 = fadd float %x.r, %y.r
   %1 = fadd float %x.i, %y.i
@@ -162,8 +77,7 @@ entry:
   ret { float, float } %3
 }
 
-; Function Attrs: nounwind
-define hidden { float, float } @main.complexSub(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden { float, float } @main.complexSub(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %0 = fsub float %x.r, %y.r
   %1 = fsub float %x.i, %y.i
@@ -172,8 +86,7 @@ entry:
   ret { float, float } %3
 }
 
-; Function Attrs: nounwind
-define hidden { float, float } @main.complexMul(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden { float, float } @main.complexMul(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %0 = fmul float %x.r, %y.r
   %1 = fmul float %x.i, %y.i
@@ -185,18 +98,3 @@ entry:
   %7 = insertvalue { float, float } %6, float %5, 1
   ret { float, float } %7
 }
-
-; Function Attrs: nounwind
-define hidden void @main.foo(%main.kv* dereferenceable_or_null(4) %a, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  call void @"main.foo$1"(%main.kv.0* null, i8* undef, i8* undef)
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden void @"main.foo$1"(%main.kv.0* dereferenceable_or_null(1) %b, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  ret void
-}
-
-attributes #0 = { nounwind }

compiler/testdata/channel.go

@@ -1,25 +0,0 @@
-package main
-
-func chanIntSend(ch chan int) {
-	ch <- 3
-}
-
-func chanIntRecv(ch chan int) {
-	<-ch
-}
-
-func chanZeroSend(ch chan struct{}) {
-	ch <- struct{}{}
-}
-
-func chanZeroRecv(ch chan struct{}) {
-	<-ch
-}
-
-func selectZeroRecv(ch1 chan int, ch2 chan struct{}) {
-	select {
-	case ch1 <- 1:
-	case <-ch2:
-	default:
-	}
-}

compiler/testdata/channel.ll

@@ -1,121 +0,0 @@
-; ModuleID = 'channel.go'
-source_filename = "channel.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-wasi"
-
-%runtime.channel = type { i32, i32, i8, %runtime.channelBlockedList*, i32, i32, i32, i8* }
-%runtime.channelBlockedList = type { %runtime.channelBlockedList*, %"internal/task.Task"*, %runtime.chanSelectState*, { %runtime.channelBlockedList*, i32, i32 } }
-%"internal/task.Task" = type { %"internal/task.Task"*, i8*, i64, %"internal/task.state" }
-%"internal/task.state" = type { i8* }
-%runtime.chanSelectState = type { %runtime.channel*, i8* }
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden void @main.chanIntSend(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %chan.blockedList = alloca %runtime.channelBlockedList, align 8
-  %chan.value = alloca i32, align 4
-  %chan.value.bitcast = bitcast i32* %chan.value to i8*
-  call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %chan.value.bitcast)
-  store i32 3, i32* %chan.value, align 4
-  %chan.blockedList.bitcast = bitcast %runtime.channelBlockedList* %chan.blockedList to i8*
-  call void @llvm.lifetime.start.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  call void @runtime.chanSend(%runtime.channel* %ch, i8* nonnull %chan.value.bitcast, %runtime.channelBlockedList* nonnull %chan.blockedList, i8* undef, i8* null) #0
-  call void @llvm.lifetime.end.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %chan.value.bitcast)
-  ret void
-}
-
-; Function Attrs: argmemonly nounwind willreturn
-declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) #1
-
-declare void @runtime.chanSend(%runtime.channel* dereferenceable_or_null(32), i8*, %runtime.channelBlockedList* dereferenceable_or_null(24), i8*, i8*)
-
-; Function Attrs: argmemonly nounwind willreturn
-declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture) #1
-
-; Function Attrs: nounwind
-define hidden void @main.chanIntRecv(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %chan.blockedList = alloca %runtime.channelBlockedList, align 8
-  %chan.value = alloca i32, align 4
-  %chan.value.bitcast = bitcast i32* %chan.value to i8*
-  call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %chan.value.bitcast)
-  %chan.blockedList.bitcast = bitcast %runtime.channelBlockedList* %chan.blockedList to i8*
-  call void @llvm.lifetime.start.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  %0 = call i1 @runtime.chanRecv(%runtime.channel* %ch, i8* nonnull %chan.value.bitcast, %runtime.channelBlockedList* nonnull %chan.blockedList, i8* undef, i8* null) #0
-  call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %chan.value.bitcast)
-  call void @llvm.lifetime.end.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  ret void
-}
-
-declare i1 @runtime.chanRecv(%runtime.channel* dereferenceable_or_null(32), i8*, %runtime.channelBlockedList* dereferenceable_or_null(24), i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden void @main.chanZeroSend(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %chan.blockedList = alloca %runtime.channelBlockedList, align 8
-  %chan.blockedList.bitcast = bitcast %runtime.channelBlockedList* %chan.blockedList to i8*
-  call void @llvm.lifetime.start.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  call void @runtime.chanSend(%runtime.channel* %ch, i8* null, %runtime.channelBlockedList* nonnull %chan.blockedList, i8* undef, i8* null) #0
-  call void @llvm.lifetime.end.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden void @main.chanZeroRecv(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %chan.blockedList = alloca %runtime.channelBlockedList, align 8
-  %chan.blockedList.bitcast = bitcast %runtime.channelBlockedList* %chan.blockedList to i8*
-  call void @llvm.lifetime.start.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  %0 = call i1 @runtime.chanRecv(%runtime.channel* %ch, i8* null, %runtime.channelBlockedList* nonnull %chan.blockedList, i8* undef, i8* null) #0
-  call void @llvm.lifetime.end.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden void @main.selectZeroRecv(%runtime.channel* dereferenceable_or_null(32) %ch1, %runtime.channel* dereferenceable_or_null(32) %ch2, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %select.states.alloca = alloca [2 x %runtime.chanSelectState], align 8
-  %select.send.value = alloca i32, align 4
-  store i32 1, i32* %select.send.value, align 4
-  %select.states.alloca.bitcast = bitcast [2 x %runtime.chanSelectState]* %select.states.alloca to i8*
-  call void @llvm.lifetime.start.p0i8(i64 16, i8* nonnull %select.states.alloca.bitcast)
-  %.repack = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 0, i32 0
-  store %runtime.channel* %ch1, %runtime.channel** %.repack, align 8
-  %.repack1 = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 0, i32 1
-  %0 = bitcast i8** %.repack1 to i32**
-  store i32* %select.send.value, i32** %0, align 4
-  %.repack3 = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 1, i32 0
-  store %runtime.channel* %ch2, %runtime.channel** %.repack3, align 8
-  %.repack4 = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 1, i32 1
-  store i8* null, i8** %.repack4, align 4
-  %select.states = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 0
-  %select.result = call { i32, i1 } @runtime.tryChanSelect(i8* undef, %runtime.chanSelectState* nonnull %select.states, i32 2, i32 2, i8* undef, i8* null) #0
-  call void @llvm.lifetime.end.p0i8(i64 16, i8* nonnull %select.states.alloca.bitcast)
-  %1 = extractvalue { i32, i1 } %select.result, 0
-  %2 = icmp eq i32 %1, 0
-  br i1 %2, label %select.done, label %select.next
-
-select.done:                                      ; preds = %select.body, %select.next, %entry
-  ret void
-
-select.next:                                      ; preds = %entry
-  %3 = icmp eq i32 %1, 1
-  br i1 %3, label %select.body, label %select.done
-
-select.body:                                      ; preds = %select.next
-  br label %select.done
-}
-
-declare { i32, i1 } @runtime.tryChanSelect(i8*, %runtime.chanSelectState*, i32, i32, i8*, i8*)
-
-attributes #0 = { nounwind }
-attributes #1 = { argmemonly nounwind willreturn }

compiler/testdata/float.ll

@@ -1,18 +1,16 @@
 ; ModuleID = 'float.go'
 source_filename = "float.go"
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-wasi"
+target triple = "wasm32--wasi"
 
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
 
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret void
 }
 
-; Function Attrs: nounwind
-define hidden i32 @main.f32tou32(float %v, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i32 @main.f32tou32(float %v, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %positive = fcmp oge float %v, 0.000000e+00
   %withinmax = fcmp ole float %v, 0x41EFFFFFC0000000
@@ -23,26 +21,22 @@ entry:
   ret i32 %0
 }
 
-; Function Attrs: nounwind
-define hidden float @main.maxu32f(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden float @main.maxu32f(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret float 0x41F0000000000000
 }
 
-; Function Attrs: nounwind
-define hidden i32 @main.maxu32tof32(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i32 @main.maxu32tof32(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret i32 -1
 }
 
-; Function Attrs: nounwind
-define hidden { i32, i32, i32, i32 } @main.inftoi32(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden { i32, i32, i32, i32 } @main.inftoi32(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret { i32, i32, i32, i32 } { i32 -1, i32 0, i32 2147483647, i32 -2147483648 }
 }
 
-; Function Attrs: nounwind
-define hidden i32 @main.u32tof32tou32(i32 %v, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i32 @main.u32tof32tou32(i32 %v, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %0 = uitofp i32 %v to float
   %withinmax = fcmp ole float %0, 0x41EFFFFFC0000000
@@ -51,8 +45,7 @@ entry:
   ret i32 %1
 }
 
-; Function Attrs: nounwind
-define hidden float @main.f32tou32tof32(float %v, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden float @main.f32tou32tof32(float %v, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %positive = fcmp oge float %v, 0.000000e+00
   %withinmax = fcmp ole float %v, 0x41EFFFFFC0000000
@@ -64,8 +57,7 @@ entry:
   ret float %1
 }
 
-; Function Attrs: nounwind
-define hidden i8 @main.f32tou8(float %v, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i8 @main.f32tou8(float %v, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %positive = fcmp oge float %v, 0.000000e+00
   %withinmax = fcmp ole float %v, 2.550000e+02
@@ -76,8 +68,7 @@ entry:
   ret i8 %0
 }
 
-; Function Attrs: nounwind
-define hidden i8 @main.f32toi8(float %v, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i8 @main.f32toi8(float %v, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %abovemin = fcmp oge float %v, -1.280000e+02
   %belowmax = fcmp ole float %v, 1.270000e+02
@@ -89,5 +80,3 @@ entry:
   %0 = select i1 %inbounds, i8 %normal, i8 %remapped
   ret i8 %0
 }
-
-attributes #0 = { nounwind }

compiler/testdata/func.ll

@@ -1,35 +1,33 @@
 ; ModuleID = 'func.go'
 source_filename = "func.go"
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-wasi"
+target triple = "wasm32--wasi"
 
 %runtime.funcValueWithSignature = type { i32, i8* }
 
 @"reflect/types.funcid:func:{basic:int}{}" = external constant i8
 @"main.someFunc$withSignature" = linkonce_odr constant %runtime.funcValueWithSignature { i32 ptrtoint (void (i32, i8*, i8*)* @main.someFunc to i32), i8* @"reflect/types.funcid:func:{basic:int}{}" }
 
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
 
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret void
 }
 
-; Function Attrs: nounwind
-define hidden void @main.foo(i8* %callback.context, i32 %callback.funcptr, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.foo(i8* %callback.context, i32 %callback.funcptr, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %0 = call i32 @runtime.getFuncPtr(i8* %callback.context, i32 %callback.funcptr, i8* nonnull @"reflect/types.funcid:func:{basic:int}{}", i8* undef, i8* null) #0
+  %0 = call i32 @runtime.getFuncPtr(i8* %callback.context, i32 %callback.funcptr, i8* nonnull @"reflect/types.funcid:func:{basic:int}{}", i8* undef, i8* null)
   %1 = icmp eq i32 %0, 0
   br i1 %1, label %fpcall.throw, label %fpcall.next
 
 fpcall.throw:                                     ; preds = %entry
-  call void @runtime.nilPanic(i8* undef, i8* null) #0
+  call void @runtime.nilPanic(i8* undef, i8* null)
   unreachable
 
 fpcall.next:                                      ; preds = %entry
   %2 = inttoptr i32 %0 to void (i32, i8*, i8*)*
-  call void %2(i32 3, i8* %callback.context, i8* undef) #0
+  call void %2(i32 3, i8* %callback.context, i8* undef)
   ret void
 }
 
@@ -37,17 +35,13 @@ declare i32 @runtime.getFuncPtr(i8*, i32, i8* dereferenceable_or_null(1), i8*, i
 
 declare void @runtime.nilPanic(i8*, i8*)
 
-; Function Attrs: nounwind
-define hidden void @main.bar(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.bar(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   call void @main.foo(i8* undef, i32 ptrtoint (%runtime.funcValueWithSignature* @"main.someFunc$withSignature" to i32), i8* undef, i8* undef)
   ret void
 }
 
-; Function Attrs: nounwind
-define hidden void @main.someFunc(i32 %arg0, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.someFunc(i32 %arg0, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret void
 }
-
-attributes #0 = { nounwind }

compiler/testdata/gc.go

@@ -1,72 +0,0 @@
-package main
-
-var (
-	scalar1 *byte
-	scalar2 *int32
-	scalar3 *int64
-	scalar4 *float32
-
-	array1 *[3]byte
-	array2 *[71]byte
-	array3 *[3]*byte
-
-	struct1 *struct{}
-	struct2 *struct {
-		x int
-		y int
-	}
-	struct3 *struct {
-		x *byte
-		y [60]uintptr
-		z *byte
-	}
-
-	slice1 []byte
-	slice2 []*int
-	slice3 [][]byte
-)
-
-func newScalar() {
-	scalar1 = new(byte)
-	scalar2 = new(int32)
-	scalar3 = new(int64)
-	scalar4 = new(float32)
-}
-
-func newArray() {
-	array1 = new([3]byte)
-	array2 = new([71]byte)
-	array3 = new([3]*byte)
-}
-
-func newStruct() {
-	struct1 = new(struct{})
-	struct2 = new(struct {
-		x int
-		y int
-	})
-	struct3 = new(struct {
-		x *byte
-		y [60]uintptr
-		z *byte
-	})
-}
-
-func newFuncValue() *func() {
-	// On some platforms that use runtime.funcValue ("switch" style) function
-	// values, a func value is allocated as having two pointer words while the
-	// struct looks like {unsafe.Pointer; uintptr}. This is so that the interp
-	// package won't get confused, see getPointerBitmap in compiler/llvm.go for
-	// details.
-	return new(func())
-}
-
-func makeSlice() {
-	slice1 = make([]byte, 5)
-	slice2 = make([]*int, 5)
-	slice3 = make([][]byte, 5)
-}
-
-func makeInterface(v complex128) interface{} {
-	return v // always stored in an allocation
-}

compiler/testdata/gc.ll

@@ -1,113 +0,0 @@
-; ModuleID = 'gc.go'
-source_filename = "gc.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-wasi"
-
-%runtime.typecodeID = type { %runtime.typecodeID*, i32, %runtime.interfaceMethodInfo*, %runtime.typecodeID*, i32 }
-%runtime.interfaceMethodInfo = type { i8*, i32 }
-%runtime.funcValue = type { i8*, i32 }
-%runtime._interface = type { i32, i8* }
-
-@main.scalar1 = hidden global i8* null, align 4
-@main.scalar2 = hidden global i32* null, align 4
-@main.scalar3 = hidden global i64* null, align 4
-@main.scalar4 = hidden global float* null, align 4
-@main.array1 = hidden global [3 x i8]* null, align 4
-@main.array2 = hidden global [71 x i8]* null, align 4
-@main.array3 = hidden global [3 x i8*]* null, align 4
-@main.struct1 = hidden global {}* null, align 4
-@main.struct2 = hidden global { i32, i32 }* null, align 4
-@main.struct3 = hidden global { i8*, [60 x i32], i8* }* null, align 4
-@main.slice1 = hidden global { i8*, i32, i32 } zeroinitializer, align 8
-@main.slice2 = hidden global { i32**, i32, i32 } zeroinitializer, align 8
-@main.slice3 = hidden global { { i8*, i32, i32 }*, i32, i32 } zeroinitializer, align 8
-@"runtime/gc.layout:62-2000000000000001" = linkonce_odr unnamed_addr constant { i32, [8 x i8] } { i32 62, [8 x i8] c" \00\00\00\00\00\00\01" }
-@"reflect/types.type:basic:complex128" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* null, i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:basic:complex128", i32 0 }
-@"reflect/types.type:pointer:basic:complex128" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:basic:complex128", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null, i32 0 }
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden void @main.newScalar(i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %new = call i8* @runtime.alloc(i32 1, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  store i8* %new, i8** @main.scalar1, align 4
-  %new1 = call i8* @runtime.alloc(i32 4, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  store i8* %new1, i8** bitcast (i32** @main.scalar2 to i8**), align 4
-  %new2 = call i8* @runtime.alloc(i32 8, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  store i8* %new2, i8** bitcast (i64** @main.scalar3 to i8**), align 4
-  %new3 = call i8* @runtime.alloc(i32 4, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  store i8* %new3, i8** bitcast (float** @main.scalar4 to i8**), align 4
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden void @main.newArray(i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %new = call i8* @runtime.alloc(i32 3, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  store i8* %new, i8** bitcast ([3 x i8]** @main.array1 to i8**), align 4
-  %new1 = call i8* @runtime.alloc(i32 71, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  store i8* %new1, i8** bitcast ([71 x i8]** @main.array2 to i8**), align 4
-  %new2 = call i8* @runtime.alloc(i32 12, i8* nonnull inttoptr (i32 67 to i8*), i8* undef, i8* null) #0
-  store i8* %new2, i8** bitcast ([3 x i8*]** @main.array3 to i8**), align 4
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden void @main.newStruct(i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %new = call i8* @runtime.alloc(i32 0, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  store i8* %new, i8** bitcast ({}** @main.struct1 to i8**), align 4
-  %new1 = call i8* @runtime.alloc(i32 8, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  store i8* %new1, i8** bitcast ({ i32, i32 }** @main.struct2 to i8**), align 4
-  %new2 = call i8* @runtime.alloc(i32 248, i8* bitcast ({ i32, [8 x i8] }* @"runtime/gc.layout:62-2000000000000001" to i8*), i8* undef, i8* null) #0
-  store i8* %new2, i8** bitcast ({ i8*, [60 x i32], i8* }** @main.struct3 to i8**), align 4
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden %runtime.funcValue* @main.newFuncValue(i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %new = call i8* @runtime.alloc(i32 8, i8* nonnull inttoptr (i32 197 to i8*), i8* undef, i8* null) #0
-  %0 = bitcast i8* %new to %runtime.funcValue*
-  ret %runtime.funcValue* %0
-}
-
-; Function Attrs: nounwind
-define hidden void @main.makeSlice(i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %makeslice = call i8* @runtime.alloc(i32 5, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  store i8* %makeslice, i8** getelementptr inbounds ({ i8*, i32, i32 }, { i8*, i32, i32 }* @main.slice1, i32 0, i32 0), align 8
-  store i32 5, i32* getelementptr inbounds ({ i8*, i32, i32 }, { i8*, i32, i32 }* @main.slice1, i32 0, i32 1), align 4
-  store i32 5, i32* getelementptr inbounds ({ i8*, i32, i32 }, { i8*, i32, i32 }* @main.slice1, i32 0, i32 2), align 8
-  %makeslice1 = call i8* @runtime.alloc(i32 20, i8* nonnull inttoptr (i32 67 to i8*), i8* undef, i8* null) #0
-  store i8* %makeslice1, i8** bitcast ({ i32**, i32, i32 }* @main.slice2 to i8**), align 8
-  store i32 5, i32* getelementptr inbounds ({ i32**, i32, i32 }, { i32**, i32, i32 }* @main.slice2, i32 0, i32 1), align 4
-  store i32 5, i32* getelementptr inbounds ({ i32**, i32, i32 }, { i32**, i32, i32 }* @main.slice2, i32 0, i32 2), align 8
-  %makeslice3 = call i8* @runtime.alloc(i32 60, i8* nonnull inttoptr (i32 71 to i8*), i8* undef, i8* null) #0
-  store i8* %makeslice3, i8** bitcast ({ { i8*, i32, i32 }*, i32, i32 }* @main.slice3 to i8**), align 8
-  store i32 5, i32* getelementptr inbounds ({ { i8*, i32, i32 }*, i32, i32 }, { { i8*, i32, i32 }*, i32, i32 }* @main.slice3, i32 0, i32 1), align 4
-  store i32 5, i32* getelementptr inbounds ({ { i8*, i32, i32 }*, i32, i32 }, { { i8*, i32, i32 }*, i32, i32 }* @main.slice3, i32 0, i32 2), align 8
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden %runtime._interface @main.makeInterface(double %v.r, double %v.i, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = call i8* @runtime.alloc(i32 16, i8* null, i8* undef, i8* null) #0
-  %.repack = bitcast i8* %0 to double*
-  store double %v.r, double* %.repack, align 8
-  %.repack1 = getelementptr inbounds i8, i8* %0, i32 8
-  %1 = bitcast i8* %.repack1 to double*
-  store double %v.i, double* %1, align 8
-  %2 = insertvalue %runtime._interface { i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:basic:complex128" to i32), i8* undef }, i8* %0, 1
-  ret %runtime._interface %2
-}
-
-attributes #0 = { nounwind }

compiler/testdata/go1.17.go

@@ -1,41 +0,0 @@
-package main
-
-// Test changes to the language introduced in Go 1.17.
-// For details, see: https://tip.golang.org/doc/go1.17#language
-// These tests should be merged into the regular slice tests once Go 1.17 is the
-// minimun Go version for TinyGo.
-
-import "unsafe"
-
-func Add32(p unsafe.Pointer, len int) unsafe.Pointer {
-	return unsafe.Add(p, len)
-}
-
-func Add64(p unsafe.Pointer, len int64) unsafe.Pointer {
-	return unsafe.Add(p, len)
-}
-
-func SliceToArray(s []int) *[4]int {
-	return (*[4]int)(s)
-}
-
-func SliceToArrayConst() *[4]int {
-	s := make([]int, 6)
-	return (*[4]int)(s)
-}
-
-func SliceInt(ptr *int, len int) []int {
-	return unsafe.Slice(ptr, len)
-}
-
-func SliceUint16(ptr *byte, len uint16) []byte {
-	return unsafe.Slice(ptr, len)
-}
-
-func SliceUint64(ptr *int, len uint64) []int {
-	return unsafe.Slice(ptr, len)
-}
-
-func SliceInt64(ptr *int, len int64) []int {
-	return unsafe.Slice(ptr, len)
-}

compiler/testdata/go1.17.ll

@@ -1,147 +0,0 @@
-; ModuleID = 'go1.17.go'
-source_filename = "go1.17.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-wasi"
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden i8* @main.Add32(i8* %p, i32 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = getelementptr i8, i8* %p, i32 %len
-  ret i8* %0
-}
-
-; Function Attrs: nounwind
-define hidden i8* @main.Add64(i8* %p, i64 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = trunc i64 %len to i32
-  %1 = getelementptr i8, i8* %p, i32 %0
-  ret i8* %1
-}
-
-; Function Attrs: nounwind
-define hidden [4 x i32]* @main.SliceToArray(i32* %s.data, i32 %s.len, i32 %s.cap, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = icmp ult i32 %s.len, 4
-  br i1 %0, label %slicetoarray.throw, label %slicetoarray.next
-
-slicetoarray.throw:                               ; preds = %entry
-  call void @runtime.sliceToArrayPointerPanic(i8* undef, i8* null) #0
-  unreachable
-
-slicetoarray.next:                                ; preds = %entry
-  %1 = bitcast i32* %s.data to [4 x i32]*
-  ret [4 x i32]* %1
-}
-
-declare void @runtime.sliceToArrayPointerPanic(i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden [4 x i32]* @main.SliceToArrayConst(i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %makeslice = call i8* @runtime.alloc(i32 24, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  br i1 false, label %slicetoarray.throw, label %slicetoarray.next
-
-slicetoarray.throw:                               ; preds = %entry
-  unreachable
-
-slicetoarray.next:                                ; preds = %entry
-  %0 = bitcast i8* %makeslice to [4 x i32]*
-  ret [4 x i32]* %0
-}
-
-; Function Attrs: nounwind
-define hidden { i32*, i32, i32 } @main.SliceInt(i32* dereferenceable_or_null(4) %ptr, i32 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = icmp ugt i32 %len, 1073741823
-  %1 = icmp eq i32* %ptr, null
-  %2 = icmp ne i32 %len, 0
-  %3 = and i1 %1, %2
-  %4 = or i1 %3, %0
-  br i1 %4, label %unsafe.Slice.throw, label %unsafe.Slice.next
-
-unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(i8* undef, i8* null) #0
-  unreachable
-
-unsafe.Slice.next:                                ; preds = %entry
-  %5 = insertvalue { i32*, i32, i32 } undef, i32* %ptr, 0
-  %6 = insertvalue { i32*, i32, i32 } %5, i32 %len, 1
-  %7 = insertvalue { i32*, i32, i32 } %6, i32 %len, 2
-  ret { i32*, i32, i32 } %7
-}
-
-declare void @runtime.unsafeSlicePanic(i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden { i8*, i32, i32 } @main.SliceUint16(i8* dereferenceable_or_null(1) %ptr, i16 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = icmp eq i8* %ptr, null
-  %1 = icmp ne i16 %len, 0
-  %2 = and i1 %0, %1
-  br i1 %2, label %unsafe.Slice.throw, label %unsafe.Slice.next
-
-unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(i8* undef, i8* null) #0
-  unreachable
-
-unsafe.Slice.next:                                ; preds = %entry
-  %3 = zext i16 %len to i32
-  %4 = insertvalue { i8*, i32, i32 } undef, i8* %ptr, 0
-  %5 = insertvalue { i8*, i32, i32 } %4, i32 %3, 1
-  %6 = insertvalue { i8*, i32, i32 } %5, i32 %3, 2
-  ret { i8*, i32, i32 } %6
-}
-
-; Function Attrs: nounwind
-define hidden { i32*, i32, i32 } @main.SliceUint64(i32* dereferenceable_or_null(4) %ptr, i64 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = icmp ugt i64 %len, 1073741823
-  %1 = icmp eq i32* %ptr, null
-  %2 = icmp ne i64 %len, 0
-  %3 = and i1 %1, %2
-  %4 = or i1 %3, %0
-  br i1 %4, label %unsafe.Slice.throw, label %unsafe.Slice.next
-
-unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(i8* undef, i8* null) #0
-  unreachable
-
-unsafe.Slice.next:                                ; preds = %entry
-  %5 = trunc i64 %len to i32
-  %6 = insertvalue { i32*, i32, i32 } undef, i32* %ptr, 0
-  %7 = insertvalue { i32*, i32, i32 } %6, i32 %5, 1
-  %8 = insertvalue { i32*, i32, i32 } %7, i32 %5, 2
-  ret { i32*, i32, i32 } %8
-}
-
-; Function Attrs: nounwind
-define hidden { i32*, i32, i32 } @main.SliceInt64(i32* dereferenceable_or_null(4) %ptr, i64 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = icmp ugt i64 %len, 1073741823
-  %1 = icmp eq i32* %ptr, null
-  %2 = icmp ne i64 %len, 0
-  %3 = and i1 %1, %2
-  %4 = or i1 %3, %0
-  br i1 %4, label %unsafe.Slice.throw, label %unsafe.Slice.next
-
-unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(i8* undef, i8* null) #0
-  unreachable
-
-unsafe.Slice.next:                                ; preds = %entry
-  %5 = trunc i64 %len to i32
-  %6 = insertvalue { i32*, i32, i32 } undef, i32* %ptr, 0
-  %7 = insertvalue { i32*, i32, i32 } %6, i32 %5, 1
-  %8 = insertvalue { i32*, i32, i32 } %7, i32 %5, 2
-  ret { i32*, i32, i32 } %8
-}
-
-attributes #0 = { nounwind }

compiler/testdata/goroutine-cortex-m-qemu.ll

@@ -1,7 +1,7 @@
 ; ModuleID = 'goroutine.go'
 source_filename = "goroutine.go"
 target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
-target triple = "thumbv7m-unknown-unknown-eabi"
+target triple = "armv7m-none-eabi"
 
 %runtime.channel = type { i32, i32, i8, %runtime.channelBlockedList*, i32, i32, i32, i8* }
 %runtime.channelBlockedList = type { %runtime.channelBlockedList*, %"internal/task.Task"*, %runtime.chanSelectState*, { %runtime.channelBlockedList*, i32, i32 } }
@@ -9,31 +9,26 @@ target triple = "thumbv7m-unknown-unknown-eabi"
 %"internal/task.state" = type { i32, i32* }
 %runtime.chanSelectState = type { %runtime.channel*, i8* }
 
-@"main$string" = internal unnamed_addr constant [4 x i8] c"test", align 1
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
 
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret void
 }
 
-; Function Attrs: nounwind
-define hidden void @main.regularFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.regularFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.regularFunction$gowrapper" to i32), i8* undef, i8* undef) #0
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.regularFunction$gowrapper" to i32), i8* nonnull inttoptr (i32 5 to i8*), i32 %stacksize, i8* undef, i8* null) #0
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.regularFunction$gowrapper" to i32), i8* undef, i8* undef)
+  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.regularFunction$gowrapper" to i32), i8* nonnull inttoptr (i32 5 to i8*), i32 %stacksize, i8* undef, i8* null)
   ret void
 }
 
 declare void @main.regularFunction(i32, i8*, i8*)
 
-; Function Attrs: nounwind
-define linkonce_odr void @"main.regularFunction$gowrapper"(i8* %0) unnamed_addr #1 {
+define linkonce_odr void @"main.regularFunction$gowrapper"(i8* %0) unnamed_addr #0 {
 entry:
   %unpack.int = ptrtoint i8* %0 to i32
-  call void @main.regularFunction(i32 %unpack.int, i8* undef, i8* undef) #0
+  call void @main.regularFunction(i32 %unpack.int, i8* undef, i8* undef)
   ret void
 }
 
@@ -41,57 +36,51 @@ declare i32 @"internal/task.getGoroutineStackSize"(i32, i8*, i8*)
 
 declare void @"internal/task.start"(i32, i8*, i32, i8*, i8*)
 
-; Function Attrs: nounwind
-define hidden void @main.inlineFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.inlineFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.inlineFunctionGoroutine$1$gowrapper" to i32), i8* undef, i8* undef) #0
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.inlineFunctionGoroutine$1$gowrapper" to i32), i8* nonnull inttoptr (i32 5 to i8*), i32 %stacksize, i8* undef, i8* null) #0
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.inlineFunctionGoroutine$1$gowrapper" to i32), i8* undef, i8* undef)
+  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.inlineFunctionGoroutine$1$gowrapper" to i32), i8* nonnull inttoptr (i32 5 to i8*), i32 %stacksize, i8* undef, i8* null)
   ret void
 }
 
-; Function Attrs: nounwind
-define hidden void @"main.inlineFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @"main.inlineFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret void
 }
 
-; Function Attrs: nounwind
-define linkonce_odr void @"main.inlineFunctionGoroutine$1$gowrapper"(i8* %0) unnamed_addr #2 {
+define linkonce_odr void @"main.inlineFunctionGoroutine$1$gowrapper"(i8* %0) unnamed_addr #1 {
 entry:
   %unpack.int = ptrtoint i8* %0 to i32
   call void @"main.inlineFunctionGoroutine$1"(i32 %unpack.int, i8* undef, i8* undef)
   ret void
 }
 
-; Function Attrs: nounwind
-define hidden void @main.closureFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.closureFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %n = call i8* @runtime.alloc(i32 4, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
+  %n = call i8* @runtime.alloc(i32 4, i8* undef, i8* null)
   %0 = bitcast i8* %n to i32*
   store i32 3, i32* %0, align 4
-  %1 = call i8* @runtime.alloc(i32 8, i8* null, i8* undef, i8* null) #0
+  %1 = call i8* @runtime.alloc(i32 8, i8* undef, i8* null)
   %2 = bitcast i8* %1 to i32*
   store i32 5, i32* %2, align 4
   %3 = getelementptr inbounds i8, i8* %1, i32 4
   %4 = bitcast i8* %3 to i8**
   store i8* %n, i8** %4, align 4
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.closureFunctionGoroutine$1$gowrapper" to i32), i8* undef, i8* undef) #0
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.closureFunctionGoroutine$1$gowrapper" to i32), i8* nonnull %1, i32 %stacksize, i8* undef, i8* null) #0
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.closureFunctionGoroutine$1$gowrapper" to i32), i8* undef, i8* undef)
+  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.closureFunctionGoroutine$1$gowrapper" to i32), i8* nonnull %1, i32 %stacksize, i8* undef, i8* null)
   %5 = load i32, i32* %0, align 4
-  call void @runtime.printint32(i32 %5, i8* undef, i8* null) #0
+  call void @runtime.printint32(i32 %5, i8* undef, i8* null)
   ret void
 }
 
-; Function Attrs: nounwind
-define hidden void @"main.closureFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @"main.closureFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %unpack.ptr = bitcast i8* %context to i32*
   store i32 7, i32* %unpack.ptr, align 4
   ret void
 }
 
-; Function Attrs: nounwind
-define linkonce_odr void @"main.closureFunctionGoroutine$1$gowrapper"(i8* %0) unnamed_addr #3 {
+define linkonce_odr void @"main.closureFunctionGoroutine$1$gowrapper"(i8* %0) unnamed_addr #2 {
 entry:
   %1 = bitcast i8* %0 to i32*
   %2 = load i32, i32* %1, align 4
@@ -104,25 +93,23 @@ entry:
 
 declare void @runtime.printint32(i32, i8*, i8*)
 
-; Function Attrs: nounwind
-define hidden void @main.funcGoroutine(i8* %fn.context, void ()* %fn.funcptr, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.funcGoroutine(i8* %fn.context, void (i32, i8*, i8*)* %fn.funcptr, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %0 = call i8* @runtime.alloc(i32 12, i8* null, i8* undef, i8* null) #0
+  %0 = call i8* @runtime.alloc(i32 12, i8* undef, i8* null)
   %1 = bitcast i8* %0 to i32*
   store i32 5, i32* %1, align 4
   %2 = getelementptr inbounds i8, i8* %0, i32 4
   %3 = bitcast i8* %2 to i8**
   store i8* %fn.context, i8** %3, align 4
   %4 = getelementptr inbounds i8, i8* %0, i32 8
-  %5 = bitcast i8* %4 to void ()**
-  store void ()* %fn.funcptr, void ()** %5, align 4
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @main.funcGoroutine.gowrapper to i32), i8* undef, i8* undef) #0
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @main.funcGoroutine.gowrapper to i32), i8* nonnull %0, i32 %stacksize, i8* undef, i8* null) #0
+  %5 = bitcast i8* %4 to void (i32, i8*, i8*)**
+  store void (i32, i8*, i8*)* %fn.funcptr, void (i32, i8*, i8*)** %5, align 4
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @main.funcGoroutine.gowrapper to i32), i8* undef, i8* undef)
+  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @main.funcGoroutine.gowrapper to i32), i8* nonnull %0, i32 %stacksize, i8* undef, i8* null)
   ret void
 }
 
-; Function Attrs: nounwind
-define linkonce_odr void @main.funcGoroutine.gowrapper(i8* %0) unnamed_addr #4 {
+define linkonce_odr void @main.funcGoroutine.gowrapper(i8* %0) unnamed_addr #3 {
 entry:
   %1 = bitcast i8* %0 to i32*
   %2 = load i32, i32* %1, align 4
@@ -132,78 +119,32 @@ entry:
   %6 = getelementptr inbounds i8, i8* %0, i32 8
   %7 = bitcast i8* %6 to void (i32, i8*, i8*)**
   %8 = load void (i32, i8*, i8*)*, void (i32, i8*, i8*)** %7, align 4
-  call void %8(i32 %2, i8* %5, i8* undef) #0
+  call void %8(i32 %2, i8* %5, i8* undef)
   ret void
 }
 
-; Function Attrs: nounwind
-define hidden void @main.recoverBuiltinGoroutine(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.recoverBuiltinGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret void
 }
 
-; Function Attrs: nounwind
-define hidden void @main.copyBuiltinGoroutine(i8* %dst.data, i32 %dst.len, i32 %dst.cap, i8* %src.data, i32 %src.len, i32 %src.cap, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.copyBuiltinGoroutine(i8* %dst.data, i32 %dst.len, i32 %dst.cap, i8* %src.data, i32 %src.len, i32 %src.cap, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %copy.n = call i32 @runtime.sliceCopy(i8* %dst.data, i8* %src.data, i32 %dst.len, i32 %src.len, i32 1, i8* undef, i8* null) #0
+  %copy.n = call i32 @runtime.sliceCopy(i8* %dst.data, i8* %src.data, i32 %dst.len, i32 %src.len, i32 1, i8* undef, i8* null)
   ret void
 }
 
 declare i32 @runtime.sliceCopy(i8* nocapture writeonly, i8* nocapture readonly, i32, i32, i32, i8*, i8*)
 
-; Function Attrs: nounwind
-define hidden void @main.closeBuiltinGoroutine(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.closeBuiltinGoroutine(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  call void @runtime.chanClose(%runtime.channel* %ch, i8* undef, i8* null) #0
+  call void @runtime.chanClose(%runtime.channel* %ch, i8* undef, i8* null)
   ret void
 }
 
 declare void @runtime.chanClose(%runtime.channel* dereferenceable_or_null(32), i8*, i8*)
 
-; Function Attrs: nounwind
-define hidden void @main.startInterfaceMethod(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = call i8* @runtime.alloc(i32 16, i8* null, i8* undef, i8* null) #0
-  %1 = bitcast i8* %0 to i8**
-  store i8* %itf.value, i8** %1, align 4
-  %2 = getelementptr inbounds i8, i8* %0, i32 4
-  %.repack = bitcast i8* %2 to i8**
-  store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @"main$string", i32 0, i32 0), i8** %.repack, align 4
-  %.repack1 = getelementptr inbounds i8, i8* %0, i32 8
-  %3 = bitcast i8* %.repack1 to i32*
-  store i32 4, i32* %3, align 4
-  %4 = getelementptr inbounds i8, i8* %0, i32 12
-  %5 = bitcast i8* %4 to i32*
-  store i32 %itf.typecode, i32* %5, align 4
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper" to i32), i8* undef, i8* undef) #0
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper" to i32), i8* nonnull %0, i32 %stacksize, i8* undef, i8* null) #0
-  ret void
-}
-
-declare void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(i8*, i8*, i32, i32, i8*, i8*) #5
-
-; Function Attrs: nounwind
-define linkonce_odr void @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper"(i8* %0) unnamed_addr #6 {
-entry:
-  %1 = bitcast i8* %0 to i8**
-  %2 = load i8*, i8** %1, align 4
-  %3 = getelementptr inbounds i8, i8* %0, i32 4
-  %4 = bitcast i8* %3 to i8**
-  %5 = load i8*, i8** %4, align 4
-  %6 = getelementptr inbounds i8, i8* %0, i32 8
-  %7 = bitcast i8* %6 to i32*
-  %8 = load i32, i32* %7, align 4
-  %9 = getelementptr inbounds i8, i8* %0, i32 12
-  %10 = bitcast i8* %9 to i32*
-  %11 = load i32, i32* %10, align 4
-  call void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(i8* %2, i8* %5, i32 %8, i32 %11, i8* undef, i8* undef) #0
-  ret void
-}
-
-attributes #0 = { nounwind }
-attributes #1 = { nounwind "tinygo-gowrapper"="main.regularFunction" }
-attributes #2 = { nounwind "tinygo-gowrapper"="main.inlineFunctionGoroutine$1" }
-attributes #3 = { nounwind "tinygo-gowrapper"="main.closureFunctionGoroutine$1" }
-attributes #4 = { nounwind "tinygo-gowrapper" }
-attributes #5 = { "tinygo-invoke"="reflect/methods.Print(string)" "tinygo-methods"="reflect/methods.Print(string)" }
-attributes #6 = { nounwind "tinygo-gowrapper"="interface:{Print:func:{basic:string}{}}.Print$invoke" }
+attributes #0 = { "tinygo-gowrapper"="main.regularFunction" }
+attributes #1 = { "tinygo-gowrapper"="main.inlineFunctionGoroutine$1" }
+attributes #2 = { "tinygo-gowrapper"="main.closureFunctionGoroutine$1" }
+attributes #3 = { "tinygo-gowrapper" }

compiler/testdata/goroutine-wasm.ll

@@ -1,7 +1,7 @@
 ; ModuleID = 'goroutine.go'
 source_filename = "goroutine.go"
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-wasi"
+target triple = "wasm32--wasi"
 
 %runtime.funcValueWithSignature = type { i32, i8* }
 %runtime.channel = type { i32, i32, i8, %runtime.channelBlockedList*, i32, i32, i32, i8* }
@@ -10,24 +10,21 @@ target triple = "wasm32-unknown-wasi"
 %"internal/task.state" = type { i8* }
 %runtime.chanSelectState = type { %runtime.channel*, i8* }
 
-@"main$pack" = internal unnamed_addr constant { i32, i8* } { i32 5, i8* undef }
-@"main$pack.1" = internal unnamed_addr constant { i32, i8* } { i32 5, i8* undef }
+@"main.regularFunctionGoroutine$pack" = private unnamed_addr constant { i32, i8* } { i32 5, i8* undef }
+@"main.inlineFunctionGoroutine$pack" = private unnamed_addr constant { i32, i8* } { i32 5, i8* undef }
 @"reflect/types.funcid:func:{basic:int}{}" = external constant i8
 @"main.closureFunctionGoroutine$1$withSignature" = linkonce_odr constant %runtime.funcValueWithSignature { i32 ptrtoint (void (i32, i8*, i8*)* @"main.closureFunctionGoroutine$1" to i32), i8* @"reflect/types.funcid:func:{basic:int}{}" }
-@"main$string" = internal unnamed_addr constant [4 x i8] c"test", align 1
 
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
 
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret void
 }
 
-; Function Attrs: nounwind
-define hidden void @main.regularFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.regularFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  call void @"internal/task.start"(i32 ptrtoint (void (i32, i8*, i8*)* @main.regularFunction to i32), i8* bitcast ({ i32, i8* }* @"main$pack" to i8*), i32 undef, i8* undef, i8* null) #0
+  call void @"internal/task.start"(i32 ptrtoint (void (i32, i8*, i8*)* @main.regularFunction to i32), i8* bitcast ({ i32, i8* }* @"main.regularFunctionGoroutine$pack" to i8*), i32 undef, i8* undef, i8* null)
   ret void
 }
 
@@ -35,39 +32,35 @@ declare void @main.regularFunction(i32, i8*, i8*)
 
 declare void @"internal/task.start"(i32, i8*, i32, i8*, i8*)
 
-; Function Attrs: nounwind
-define hidden void @main.inlineFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.inlineFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  call void @"internal/task.start"(i32 ptrtoint (void (i32, i8*, i8*)* @"main.inlineFunctionGoroutine$1" to i32), i8* bitcast ({ i32, i8* }* @"main$pack.1" to i8*), i32 undef, i8* undef, i8* null) #0
+  call void @"internal/task.start"(i32 ptrtoint (void (i32, i8*, i8*)* @"main.inlineFunctionGoroutine$1" to i32), i8* bitcast ({ i32, i8* }* @"main.inlineFunctionGoroutine$pack" to i8*), i32 undef, i8* undef, i8* null)
   ret void
 }
 
-; Function Attrs: nounwind
-define hidden void @"main.inlineFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @"main.inlineFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret void
 }
 
-; Function Attrs: nounwind
-define hidden void @main.closureFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.closureFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %n = call i8* @runtime.alloc(i32 4, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
+  %n = call i8* @runtime.alloc(i32 4, i8* undef, i8* null)
   %0 = bitcast i8* %n to i32*
   store i32 3, i32* %0, align 4
-  %1 = call i8* @runtime.alloc(i32 8, i8* null, i8* undef, i8* null) #0
+  %1 = call i8* @runtime.alloc(i32 8, i8* undef, i8* null)
   %2 = bitcast i8* %1 to i32*
   store i32 5, i32* %2, align 4
   %3 = getelementptr inbounds i8, i8* %1, i32 4
   %4 = bitcast i8* %3 to i8**
   store i8* %n, i8** %4, align 4
-  call void @"internal/task.start"(i32 ptrtoint (void (i32, i8*, i8*)* @"main.closureFunctionGoroutine$1" to i32), i8* nonnull %1, i32 undef, i8* undef, i8* null) #0
+  call void @"internal/task.start"(i32 ptrtoint (void (i32, i8*, i8*)* @"main.closureFunctionGoroutine$1" to i32), i8* nonnull %1, i32 undef, i8* undef, i8* null)
   %5 = load i32, i32* %0, align 4
-  call void @runtime.printint32(i32 %5, i8* undef, i8* null) #0
+  call void @runtime.printint32(i32 %5, i8* undef, i8* null)
   ret void
 }
 
-; Function Attrs: nounwind
-define hidden void @"main.closureFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @"main.closureFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %unpack.ptr = bitcast i8* %context to i32*
   store i32 7, i32* %unpack.ptr, align 4
@@ -76,66 +69,38 @@ entry:
 
 declare void @runtime.printint32(i32, i8*, i8*)
 
-; Function Attrs: nounwind
-define hidden void @main.funcGoroutine(i8* %fn.context, i32 %fn.funcptr, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.funcGoroutine(i8* %fn.context, i32 %fn.funcptr, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %0 = call i32 @runtime.getFuncPtr(i8* %fn.context, i32 %fn.funcptr, i8* nonnull @"reflect/types.funcid:func:{basic:int}{}", i8* undef, i8* null) #0
-  %1 = call i8* @runtime.alloc(i32 8, i8* null, i8* undef, i8* null) #0
+  %0 = call i32 @runtime.getFuncPtr(i8* %fn.context, i32 %fn.funcptr, i8* nonnull @"reflect/types.funcid:func:{basic:int}{}", i8* undef, i8* null)
+  %1 = call i8* @runtime.alloc(i32 8, i8* undef, i8* null)
   %2 = bitcast i8* %1 to i32*
   store i32 5, i32* %2, align 4
   %3 = getelementptr inbounds i8, i8* %1, i32 4
   %4 = bitcast i8* %3 to i8**
   store i8* %fn.context, i8** %4, align 4
-  call void @"internal/task.start"(i32 %0, i8* nonnull %1, i32 undef, i8* undef, i8* null) #0
+  call void @"internal/task.start"(i32 %0, i8* nonnull %1, i32 undef, i8* undef, i8* null)
   ret void
 }
 
 declare i32 @runtime.getFuncPtr(i8*, i32, i8* dereferenceable_or_null(1), i8*, i8*)
 
-; Function Attrs: nounwind
-define hidden void @main.recoverBuiltinGoroutine(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.recoverBuiltinGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret void
 }
 
-; Function Attrs: nounwind
-define hidden void @main.copyBuiltinGoroutine(i8* %dst.data, i32 %dst.len, i32 %dst.cap, i8* %src.data, i32 %src.len, i32 %src.cap, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.copyBuiltinGoroutine(i8* %dst.data, i32 %dst.len, i32 %dst.cap, i8* %src.data, i32 %src.len, i32 %src.cap, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %copy.n = call i32 @runtime.sliceCopy(i8* %dst.data, i8* %src.data, i32 %dst.len, i32 %src.len, i32 1, i8* undef, i8* null) #0
+  %copy.n = call i32 @runtime.sliceCopy(i8* %dst.data, i8* %src.data, i32 %dst.len, i32 %src.len, i32 1, i8* undef, i8* null)
   ret void
 }
 
 declare i32 @runtime.sliceCopy(i8* nocapture writeonly, i8* nocapture readonly, i32, i32, i32, i8*, i8*)
 
-; Function Attrs: nounwind
-define hidden void @main.closeBuiltinGoroutine(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.closeBuiltinGoroutine(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  call void @runtime.chanClose(%runtime.channel* %ch, i8* undef, i8* null) #0
+  call void @runtime.chanClose(%runtime.channel* %ch, i8* undef, i8* null)
   ret void
 }
 
 declare void @runtime.chanClose(%runtime.channel* dereferenceable_or_null(32), i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden void @main.startInterfaceMethod(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = call i8* @runtime.alloc(i32 16, i8* null, i8* undef, i8* null) #0
-  %1 = bitcast i8* %0 to i8**
-  store i8* %itf.value, i8** %1, align 4
-  %2 = getelementptr inbounds i8, i8* %0, i32 4
-  %.repack = bitcast i8* %2 to i8**
-  store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @"main$string", i32 0, i32 0), i8** %.repack, align 4
-  %.repack1 = getelementptr inbounds i8, i8* %0, i32 8
-  %3 = bitcast i8* %.repack1 to i32*
-  store i32 4, i32* %3, align 4
-  %4 = getelementptr inbounds i8, i8* %0, i32 12
-  %5 = bitcast i8* %4 to i32*
-  store i32 %itf.typecode, i32* %5, align 4
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*, i8*, i32, i32, i8*, i8*)* @"interface:{Print:func:{basic:string}{}}.Print$invoke" to i32), i8* nonnull %0, i32 undef, i8* undef, i8* null) #0
-  ret void
-}
-
-declare void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(i8*, i8*, i32, i32, i8*, i8*) #1
-
-attributes #0 = { nounwind }
-attributes #1 = { "tinygo-invoke"="reflect/methods.Print(string)" "tinygo-methods"="reflect/methods.Print(string)" }

compiler/testdata/goroutine.go

@@ -41,11 +41,3 @@ func closeBuiltinGoroutine(ch chan int) {
 }
 
 func regularFunction(x int)
-
-type simpleInterface interface {
-	Print(string)
-}
-
-func startInterfaceMethod(itf simpleInterface) {
-	go itf.Print("test")
-}

compiler/testdata/interface.go

@@ -49,15 +49,6 @@ func isStringer(itf interface{}) bool {
 	return ok
 }
 
-type fooInterface interface {
-	String() string
-	foo(int) byte
-}
-
-func callFooMethod(itf fooInterface) uint8 {
-	return itf.foo(3)
-}
-
 func callErrorMethod(itf error) string {
 	return itf.Error()
 }

compiler/testdata/interface.ll

@@ -1,67 +1,58 @@
 ; ModuleID = 'interface.go'
 source_filename = "interface.go"
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-wasi"
+target triple = "wasm32--wasi"
 
-%runtime.typecodeID = type { %runtime.typecodeID*, i32, %runtime.interfaceMethodInfo*, %runtime.typecodeID*, i32 }
+%runtime.typecodeID = type { %runtime.typecodeID*, i32, %runtime.interfaceMethodInfo*, %runtime.typecodeID* }
 %runtime.interfaceMethodInfo = type { i8*, i32 }
 %runtime._interface = type { i32, i8* }
 %runtime._string = type { i8*, i32 }
 
-@"reflect/types.type:basic:int" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* null, i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:basic:int", i32 0 }
-@"reflect/types.type:pointer:basic:int" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:basic:int", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null, i32 0 }
-@"reflect/types.type:pointer:named:error" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:named:error", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null, i32 0 }
-@"reflect/types.type:named:error" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:interface:{Error:func:{}{basic:string}}", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:named:error", i32 ptrtoint (i1 (i32)* @"interface:{Error:func:{}{basic:string}}.$typeassert" to i32) }
-@"reflect/types.type:interface:{Error:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* bitcast ([1 x i8*]* @"reflect/types.interface:interface{Error() string}$interface" to %runtime.typecodeID*), i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}", i32 ptrtoint (i1 (i32)* @"interface:{Error:func:{}{basic:string}}.$typeassert" to i32) }
+@"reflect/types.type:basic:int" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* null, i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:basic:int" }
+@"reflect/types.type:pointer:basic:int" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:basic:int", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null }
+@"reflect/types.type:pointer:named:error" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:named:error", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null }
+@"reflect/types.type:named:error" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:interface:{Error:func:{}{basic:string}}", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:named:error" }
+@"reflect/types.type:interface:{Error:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* bitcast ([1 x i8*]* @"reflect/types.interface:interface{Error() string}$interface" to %runtime.typecodeID*), i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}" }
 @"reflect/methods.Error() string" = linkonce_odr constant i8 0, align 1
 @"reflect/types.interface:interface{Error() string}$interface" = linkonce_odr constant [1 x i8*] [i8* @"reflect/methods.Error() string"]
-@"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:interface:{Error:func:{}{basic:string}}", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null, i32 0 }
-@"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:interface:{String:func:{}{basic:string}}", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null, i32 0 }
-@"reflect/types.type:interface:{String:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* bitcast ([1 x i8*]* @"reflect/types.interface:interface{String() string}$interface" to %runtime.typecodeID*), i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}", i32 ptrtoint (i1 (i32)* @"interface:{String:func:{}{basic:string}}.$typeassert" to i32) }
+@"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:interface:{Error:func:{}{basic:string}}", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null }
+@"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:interface:{String:func:{}{basic:string}}", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null }
+@"reflect/types.type:interface:{String:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* bitcast ([1 x i8*]* @"reflect/types.interface:interface{String() string}$interface" to %runtime.typecodeID*), i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}" }
 @"reflect/methods.String() string" = linkonce_odr constant i8 0, align 1
 @"reflect/types.interface:interface{String() string}$interface" = linkonce_odr constant [1 x i8*] [i8* @"reflect/methods.String() string"]
 @"reflect/types.typeid:basic:int" = external constant i8
+@"error$interface" = linkonce_odr constant [1 x i8*] [i8* @"reflect/methods.Error() string"]
 
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
 
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret void
 }
 
-; Function Attrs: nounwind
-define hidden %runtime._interface @main.simpleType(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden %runtime._interface @main.simpleType(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret %runtime._interface { i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:basic:int" to i32), i8* null }
 }
 
-; Function Attrs: nounwind
-define hidden %runtime._interface @main.pointerType(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden %runtime._interface @main.pointerType(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret %runtime._interface { i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:pointer:basic:int" to i32), i8* null }
 }
 
-; Function Attrs: nounwind
-define hidden %runtime._interface @main.interfaceType(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden %runtime._interface @main.interfaceType(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret %runtime._interface { i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:pointer:named:error" to i32), i8* null }
 }
 
-declare i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(i32) #1
-
-; Function Attrs: nounwind
-define hidden %runtime._interface @main.anonymousInterfaceType(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden %runtime._interface @main.anonymousInterfaceType(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret %runtime._interface { i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}" to i32), i8* null }
 }
 
-declare i1 @"interface:{String:func:{}{basic:string}}.$typeassert"(i32) #2
-
-; Function Attrs: nounwind
-define hidden i1 @main.isInt(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i1 @main.isInt(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %typecode = call i1 @runtime.typeAssert(i32 %itf.typecode, i8* nonnull @"reflect/types.typeid:basic:int", i8* undef, i8* null) #0
+  %typecode = call i1 @runtime.typeAssert(i32 %itf.typecode, i8* nonnull @"reflect/types.typeid:basic:int", i8* undef, i8* null)
   br i1 %typecode, label %typeassert.ok, label %typeassert.next
 
 typeassert.ok:                                    ; preds = %entry
@@ -73,10 +64,9 @@ typeassert.next:                                  ; preds = %typeassert.ok, %ent
 
 declare i1 @runtime.typeAssert(i32, i8* dereferenceable_or_null(1), i8*, i8*)
 
-; Function Attrs: nounwind
-define hidden i1 @main.isError(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i1 @main.isError(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %0 = call i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(i32 %itf.typecode) #0
+  %0 = call i1 @runtime.interfaceImplements(i32 %itf.typecode, i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @"error$interface", i32 0, i32 0), i8* undef, i8* null)
   br i1 %0, label %typeassert.ok, label %typeassert.next
 
 typeassert.ok:                                    ; preds = %entry
@@ -86,10 +76,11 @@ typeassert.next:                                  ; preds = %typeassert.ok, %ent
   ret i1 %0
 }
 
-; Function Attrs: nounwind
-define hidden i1 @main.isStringer(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+declare i1 @runtime.interfaceImplements(i32, i8** dereferenceable_or_null(4), i8*, i8*)
+
+define hidden i1 @main.isStringer(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %0 = call i1 @"interface:{String:func:{}{basic:string}}.$typeassert"(i32 %itf.typecode) #0
+  %0 = call i1 @runtime.interfaceImplements(i32 %itf.typecode, i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @"reflect/types.interface:interface{String() string}$interface", i32 0, i32 0), i8* undef, i8* null)
   br i1 %0, label %typeassert.ok, label %typeassert.next
 
 typeassert.ok:                                    ; preds = %entry
@@ -99,26 +90,12 @@ typeassert.next:                                  ; preds = %typeassert.ok, %ent
   ret i1 %0
 }
 
-; Function Attrs: nounwind
-define hidden i8 @main.callFooMethod(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden %runtime._string @main.callErrorMethod(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %0 = call i8 @"interface:{String:func:{}{basic:string},main.foo:func:{basic:int}{basic:uint8}}.foo$invoke"(i8* %itf.value, i32 3, i32 %itf.typecode, i8* undef, i8* undef) #0
-  ret i8 %0
-}
-
-declare i8 @"interface:{String:func:{}{basic:string},main.foo:func:{basic:int}{basic:uint8}}.foo$invoke"(i8*, i32, i32, i8*, i8*) #3
-
-; Function Attrs: nounwind
-define hidden %runtime._string @main.callErrorMethod(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = call %runtime._string @"interface:{Error:func:{}{basic:string}}.Error$invoke"(i8* %itf.value, i32 %itf.typecode, i8* undef, i8* undef) #0
+  %invoke.func = call i32 @runtime.interfaceMethod(i32 %itf.typecode, i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @"error$interface", i32 0, i32 0), i8* nonnull @"reflect/methods.Error() string", i8* undef, i8* null)
+  %invoke.func.cast = inttoptr i32 %invoke.func to %runtime._string (i8*, i8*, i8*)*
+  %0 = call %runtime._string %invoke.func.cast(i8* %itf.value, i8* undef, i8* undef)
   ret %runtime._string %0
 }
 
-declare %runtime._string @"interface:{Error:func:{}{basic:string}}.Error$invoke"(i8*, i32, i8*, i8*) #4
-
-attributes #0 = { nounwind }
-attributes #1 = { "tinygo-methods"="reflect/methods.Error() string" }
-attributes #2 = { "tinygo-methods"="reflect/methods.String() string" }
-attributes #3 = { "tinygo-invoke"="main.$methods.foo(int) byte" "tinygo-methods"="reflect/methods.String() string; main.$methods.foo(int) byte" }
-attributes #4 = { "tinygo-invoke"="reflect/methods.Error() string" "tinygo-methods"="reflect/methods.Error() string" }
+declare i32 @runtime.interfaceMethod(i32, i8** dereferenceable_or_null(4), i8* dereferenceable_or_null(1), i8*, i8*)

compiler/testdata/intrinsics-cortex-m-qemu.ll

@@ -1,32 +0,0 @@
-; ModuleID = 'intrinsics.go'
-source_filename = "intrinsics.go"
-target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
-target triple = "thumbv7m-unknown-unknown-eabi"
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden double @main.mySqrt(double %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = call double @math.Sqrt(double %x, i8* undef, i8* undef) #0
-  ret double %0
-}
-
-declare double @math.Sqrt(double, i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden double @main.myTrunc(double %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = call double @math.Trunc(double %x, i8* undef, i8* undef) #0
-  ret double %0
-}
-
-declare double @math.Trunc(double, i8*, i8*)
-
-attributes #0 = { nounwind }

compiler/testdata/intrinsics-wasm.ll

@@ -1,35 +0,0 @@
-; ModuleID = 'intrinsics.go'
-source_filename = "intrinsics.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-wasi"
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden double @main.mySqrt(double %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = call double @llvm.sqrt.f64(double %x)
-  ret double %0
-}
-
-; Function Attrs: nounwind readnone speculatable willreturn
-declare double @llvm.sqrt.f64(double) #1
-
-; Function Attrs: nounwind
-define hidden double @main.myTrunc(double %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = call double @llvm.trunc.f64(double %x)
-  ret double %0
-}
-
-; Function Attrs: nounwind readnone speculatable willreturn
-declare double @llvm.trunc.f64(double) #1
-
-attributes #0 = { nounwind }
-attributes #1 = { nounwind readnone speculatable willreturn }

compiler/testdata/intrinsics.go

@@ -1,14 +0,0 @@
-package main
-
-// Test how intrinsics are lowered: either as regular calls to the math
-// functions or as LLVM builtins (such as llvm.sqrt.f64).
-
-import "math"
-
-func mySqrt(x float64) float64 {
-	return math.Sqrt(x)
-}
-
-func myTrunc(x float64) float64 {
-	return math.Trunc(x)
-}

compiler/testdata/pointer.ll

@@ -1,61 +1,51 @@
 ; ModuleID = 'pointer.go'
 source_filename = "pointer.go"
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-wasi"
+target triple = "wasm32--wasi"
 
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
 
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret void
 }
 
-; Function Attrs: nounwind
-define hidden [0 x i32] @main.pointerDerefZero([0 x i32]* %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden [0 x i32] @main.pointerDerefZero([0 x i32]* %x, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret [0 x i32] zeroinitializer
 }
 
-; Function Attrs: nounwind
-define hidden i32* @main.pointerCastFromUnsafe(i8* %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i32* @main.pointerCastFromUnsafe(i8* %x, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %0 = bitcast i8* %x to i32*
   ret i32* %0
 }
 
-; Function Attrs: nounwind
-define hidden i8* @main.pointerCastToUnsafe(i32* dereferenceable_or_null(4) %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i8* @main.pointerCastToUnsafe(i32* dereferenceable_or_null(4) %x, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %0 = bitcast i32* %x to i8*
   ret i8* %0
 }
 
-; Function Attrs: nounwind
-define hidden i8* @main.pointerCastToUnsafeNoop(i8* dereferenceable_or_null(1) %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i8* @main.pointerCastToUnsafeNoop(i8* dereferenceable_or_null(1) %x, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret i8* %x
 }
 
-; Function Attrs: nounwind
-define hidden i8* @main.pointerUnsafeGEPFixedOffset(i8* dereferenceable_or_null(1) %ptr, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i8* @main.pointerUnsafeGEPFixedOffset(i8* dereferenceable_or_null(1) %ptr, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %0 = getelementptr inbounds i8, i8* %ptr, i32 10
   ret i8* %0
 }
 
-; Function Attrs: nounwind
-define hidden i8* @main.pointerUnsafeGEPByteOffset(i8* dereferenceable_or_null(1) %ptr, i32 %offset, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i8* @main.pointerUnsafeGEPByteOffset(i8* dereferenceable_or_null(1) %ptr, i32 %offset, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %0 = getelementptr inbounds i8, i8* %ptr, i32 %offset
   ret i8* %0
 }
 
-; Function Attrs: nounwind
-define hidden i32* @main.pointerUnsafeGEPIntOffset(i32* dereferenceable_or_null(4) %ptr, i32 %offset, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i32* @main.pointerUnsafeGEPIntOffset(i32* dereferenceable_or_null(4) %ptr, i32 %offset, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %0 = getelementptr i32, i32* %ptr, i32 %offset
   ret i32* %0
 }
-
-attributes #0 = { nounwind }

compiler/testdata/pragma.ll

@@ -1,7 +1,7 @@
 ; ModuleID = 'pragma.go'
 source_filename = "pragma.go"
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-wasi"
+target triple = "wasm32--wasi"
 
 @extern_global = external global [0 x i8], align 1
 @main.alignedGlobal = hidden global [4 x i32] zeroinitializer, align 32
@@ -10,56 +10,50 @@ target triple = "wasm32-unknown-wasi"
 @undefinedGlobalNotInSection = external global i32, align 4
 @main.multipleGlobalPragmas = hidden global i32 0, section ".global_section", align 1024
 
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
 
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret void
 }
 
-; Function Attrs: nounwind
-define void @extern_func() #1 {
+define void @extern_func() #0 {
 entry:
   ret void
 }
 
-; Function Attrs: nounwind
-define hidden void @somepkg.someFunction1(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @somepkg.someFunction1(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret void
 }
 
 declare void @somepkg.someFunction2(i8*, i8*)
 
-; Function Attrs: inlinehint nounwind
-define hidden void @main.inlineFunc(i8* %context, i8* %parentHandle) unnamed_addr #2 {
+; Function Attrs: inlinehint
+define hidden void @main.inlineFunc(i8* %context, i8* %parentHandle) unnamed_addr #1 {
 entry:
   ret void
 }
 
-; Function Attrs: noinline nounwind
-define hidden void @main.noinlineFunc(i8* %context, i8* %parentHandle) unnamed_addr #3 {
+; Function Attrs: noinline
+define hidden void @main.noinlineFunc(i8* %context, i8* %parentHandle) unnamed_addr #2 {
 entry:
   ret void
 }
 
-; Function Attrs: nounwind
-define hidden void @main.functionInSection(i8* %context, i8* %parentHandle) unnamed_addr #0 section ".special_function_section" {
+define hidden void @main.functionInSection(i8* %context, i8* %parentHandle) unnamed_addr section ".special_function_section" {
 entry:
   ret void
 }
 
-; Function Attrs: nounwind
-define void @exportedFunctionInSection() #4 section ".special_function_section" {
+define void @exportedFunctionInSection() #3 section ".special_function_section" {
 entry:
   ret void
 }
 
 declare void @main.undefinedFunctionNotInSection(i8*, i8*)
 
-attributes #0 = { nounwind }
-attributes #1 = { nounwind "wasm-export-name"="extern_func" }
-attributes #2 = { inlinehint nounwind }
-attributes #3 = { noinline nounwind }
-attributes #4 = { nounwind "wasm-export-name"="exportedFunctionInSection" }
+attributes #0 = { "wasm-export-name"="extern_func" }
+attributes #1 = { inlinehint }
+attributes #2 = { noinline }
+attributes #3 = { "wasm-export-name"="exportedFunctionInSection" }

compiler/testdata/slice.go

@@ -23,21 +23,3 @@ func sliceAppendSlice(ints, added []int) []int {
 func sliceCopy(dst, src []int) int {
 	return copy(dst, src)
 }
-
-// Test bounds checking in *ssa.MakeSlice instruction.
-
-func makeByteSlice(len int) []byte {
-	return make([]byte, len)
-}
-
-func makeInt16Slice(len int) []int16 {
-	return make([]int16, len)
-}
-
-func makeArraySlice(len int) [][3]byte {
-	return make([][3]byte, len) // slice with element size of 3
-}
-
-func makeInt32Slice(len int) []int32 {
-	return make([]int32, len)
-}

compiler/testdata/slice.ll

@@ -1,36 +1,32 @@
 ; ModuleID = 'slice.go'
 source_filename = "slice.go"
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-wasi"
+target triple = "wasm32--wasi"
 
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
 
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret void
 }
 
-; Function Attrs: nounwind
-define hidden i32 @main.sliceLen(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i32 @main.sliceLen(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret i32 %ints.len
 }
 
-; Function Attrs: nounwind
-define hidden i32 @main.sliceCap(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i32 @main.sliceCap(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret i32 %ints.cap
 }
 
-; Function Attrs: nounwind
-define hidden i32 @main.sliceElement(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i32 %index, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i32 @main.sliceElement(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i32 %index, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %.not = icmp ult i32 %index, %ints.len
   br i1 %.not, label %lookup.next, label %lookup.throw
 
 lookup.throw:                                     ; preds = %entry
-  call void @runtime.lookupPanic(i8* undef, i8* null) #0
+  call void @runtime.lookupPanic(i8* undef, i8* null)
   unreachable
 
 lookup.next:                                      ; preds = %entry
@@ -41,10 +37,9 @@ lookup.next:                                      ; preds = %entry
 
 declare void @runtime.lookupPanic(i8*, i8*)
 
-; Function Attrs: nounwind
-define hidden { i32*, i32, i32 } @main.sliceAppendValues(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden { i32*, i32, i32 } @main.sliceAppendValues(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %varargs = call i8* @runtime.alloc(i32 12, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
+  %varargs = call i8* @runtime.alloc(i32 12, i8* undef, i8* null)
   %0 = bitcast i8* %varargs to i32*
   store i32 1, i32* %0, align 4
   %1 = getelementptr inbounds i8, i8* %varargs, i32 4
@@ -54,7 +49,7 @@ entry:
   %4 = bitcast i8* %3 to i32*
   store i32 3, i32* %4, align 4
   %append.srcPtr = bitcast i32* %ints.data to i8*
-  %append.new = call { i8*, i32, i32 } @runtime.sliceAppend(i8* %append.srcPtr, i8* nonnull %varargs, i32 %ints.len, i32 %ints.cap, i32 3, i32 4, i8* undef, i8* null) #0
+  %append.new = call { i8*, i32, i32 } @runtime.sliceAppend(i8* %append.srcPtr, i8* nonnull %varargs, i32 %ints.len, i32 %ints.cap, i32 3, i32 4, i8* undef, i8* null)
   %append.newPtr = extractvalue { i8*, i32, i32 } %append.new, 0
   %append.newBuf = bitcast i8* %append.newPtr to i32*
   %append.newLen = extractvalue { i8*, i32, i32 } %append.new, 1
@@ -67,12 +62,11 @@ entry:
 
 declare { i8*, i32, i32 } @runtime.sliceAppend(i8*, i8* nocapture readonly, i32, i32, i32, i32, i8*, i8*)
 
-; Function Attrs: nounwind
-define hidden { i32*, i32, i32 } @main.sliceAppendSlice(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i32* %added.data, i32 %added.len, i32 %added.cap, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden { i32*, i32, i32 } @main.sliceAppendSlice(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i32* %added.data, i32 %added.len, i32 %added.cap, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %append.srcPtr = bitcast i32* %ints.data to i8*
   %append.srcPtr1 = bitcast i32* %added.data to i8*
-  %append.new = call { i8*, i32, i32 } @runtime.sliceAppend(i8* %append.srcPtr, i8* %append.srcPtr1, i32 %ints.len, i32 %ints.cap, i32 %added.len, i32 4, i8* undef, i8* null) #0
+  %append.new = call { i8*, i32, i32 } @runtime.sliceAppend(i8* %append.srcPtr, i8* %append.srcPtr1, i32 %ints.len, i32 %ints.cap, i32 %added.len, i32 4, i8* undef, i8* null)
   %append.newPtr = extractvalue { i8*, i32, i32 } %append.new, 0
   %append.newBuf = bitcast i8* %append.newPtr to i32*
   %append.newLen = extractvalue { i8*, i32, i32 } %append.new, 1
@@ -83,95 +77,12 @@ entry:
   ret { i32*, i32, i32 } %2
 }
 
-; Function Attrs: nounwind
-define hidden i32 @main.sliceCopy(i32* %dst.data, i32 %dst.len, i32 %dst.cap, i32* %src.data, i32 %src.len, i32 %src.cap, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i32 @main.sliceCopy(i32* %dst.data, i32 %dst.len, i32 %dst.cap, i32* %src.data, i32 %src.len, i32 %src.cap, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %copy.dstPtr = bitcast i32* %dst.data to i8*
   %copy.srcPtr = bitcast i32* %src.data to i8*
-  %copy.n = call i32 @runtime.sliceCopy(i8* %copy.dstPtr, i8* %copy.srcPtr, i32 %dst.len, i32 %src.len, i32 4, i8* undef, i8* null) #0
+  %copy.n = call i32 @runtime.sliceCopy(i8* %copy.dstPtr, i8* %copy.srcPtr, i32 %dst.len, i32 %src.len, i32 4, i8* undef, i8* null)
   ret i32 %copy.n
 }
 
 declare i32 @runtime.sliceCopy(i8* nocapture writeonly, i8* nocapture readonly, i32, i32, i32, i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden { i8*, i32, i32 } @main.makeByteSlice(i32 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %slice.maxcap = icmp slt i32 %len, 0
-  br i1 %slice.maxcap, label %slice.throw, label %slice.next
-
-slice.throw:                                      ; preds = %entry
-  call void @runtime.slicePanic(i8* undef, i8* null) #0
-  unreachable
-
-slice.next:                                       ; preds = %entry
-  %makeslice.buf = call i8* @runtime.alloc(i32 %len, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  %0 = insertvalue { i8*, i32, i32 } undef, i8* %makeslice.buf, 0
-  %1 = insertvalue { i8*, i32, i32 } %0, i32 %len, 1
-  %2 = insertvalue { i8*, i32, i32 } %1, i32 %len, 2
-  ret { i8*, i32, i32 } %2
-}
-
-declare void @runtime.slicePanic(i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden { i16*, i32, i32 } @main.makeInt16Slice(i32 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %slice.maxcap = icmp slt i32 %len, 0
-  br i1 %slice.maxcap, label %slice.throw, label %slice.next
-
-slice.throw:                                      ; preds = %entry
-  call void @runtime.slicePanic(i8* undef, i8* null) #0
-  unreachable
-
-slice.next:                                       ; preds = %entry
-  %makeslice.cap = shl i32 %len, 1
-  %makeslice.buf = call i8* @runtime.alloc(i32 %makeslice.cap, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  %makeslice.array = bitcast i8* %makeslice.buf to i16*
-  %0 = insertvalue { i16*, i32, i32 } undef, i16* %makeslice.array, 0
-  %1 = insertvalue { i16*, i32, i32 } %0, i32 %len, 1
-  %2 = insertvalue { i16*, i32, i32 } %1, i32 %len, 2
-  ret { i16*, i32, i32 } %2
-}
-
-; Function Attrs: nounwind
-define hidden { [3 x i8]*, i32, i32 } @main.makeArraySlice(i32 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %slice.maxcap = icmp ugt i32 %len, 1431655765
-  br i1 %slice.maxcap, label %slice.throw, label %slice.next
-
-slice.throw:                                      ; preds = %entry
-  call void @runtime.slicePanic(i8* undef, i8* null) #0
-  unreachable
-
-slice.next:                                       ; preds = %entry
-  %makeslice.cap = mul i32 %len, 3
-  %makeslice.buf = call i8* @runtime.alloc(i32 %makeslice.cap, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  %makeslice.array = bitcast i8* %makeslice.buf to [3 x i8]*
-  %0 = insertvalue { [3 x i8]*, i32, i32 } undef, [3 x i8]* %makeslice.array, 0
-  %1 = insertvalue { [3 x i8]*, i32, i32 } %0, i32 %len, 1
-  %2 = insertvalue { [3 x i8]*, i32, i32 } %1, i32 %len, 2
-  ret { [3 x i8]*, i32, i32 } %2
-}
-
-; Function Attrs: nounwind
-define hidden { i32*, i32, i32 } @main.makeInt32Slice(i32 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %slice.maxcap = icmp ugt i32 %len, 1073741823
-  br i1 %slice.maxcap, label %slice.throw, label %slice.next
-
-slice.throw:                                      ; preds = %entry
-  call void @runtime.slicePanic(i8* undef, i8* null) #0
-  unreachable
-
-slice.next:                                       ; preds = %entry
-  %makeslice.cap = shl i32 %len, 2
-  %makeslice.buf = call i8* @runtime.alloc(i32 %makeslice.cap, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  %makeslice.array = bitcast i8* %makeslice.buf to i32*
-  %0 = insertvalue { i32*, i32, i32 } undef, i32* %makeslice.array, 0
-  %1 = insertvalue { i32*, i32, i32 } %0, i32 %len, 1
-  %2 = insertvalue { i32*, i32, i32 } %1, i32 %len, 2
-  ret { i32*, i32, i32 } %2
-}
-
-attributes #0 = { nounwind }

compiler/testdata/string.ll

@@ -1,46 +1,41 @@
 ; ModuleID = 'string.go'
 source_filename = "string.go"
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-wasi"
+target triple = "wasm32--wasi"
 
 %runtime._string = type { i8*, i32 }
 
-@"main$string" = internal unnamed_addr constant [3 x i8] c"foo", align 1
+@"main.someString$string" = internal unnamed_addr constant [3 x i8] c"foo", align 1
 
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
 
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret void
 }
 
-; Function Attrs: nounwind
-define hidden %runtime._string @main.someString(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden %runtime._string @main.someString(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  ret %runtime._string { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @"main$string", i32 0, i32 0), i32 3 }
+  ret %runtime._string { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @"main.someString$string", i32 0, i32 0), i32 3 }
 }
 
-; Function Attrs: nounwind
-define hidden %runtime._string @main.zeroLengthString(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden %runtime._string @main.zeroLengthString(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret %runtime._string zeroinitializer
 }
 
-; Function Attrs: nounwind
-define hidden i32 @main.stringLen(i8* %s.data, i32 %s.len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i32 @main.stringLen(i8* %s.data, i32 %s.len, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   ret i32 %s.len
 }
 
-; Function Attrs: nounwind
-define hidden i8 @main.stringIndex(i8* %s.data, i32 %s.len, i32 %index, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i8 @main.stringIndex(i8* %s.data, i32 %s.len, i32 %index, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   %.not = icmp ult i32 %index, %s.len
   br i1 %.not, label %lookup.next, label %lookup.throw
 
 lookup.throw:                                     ; preds = %entry
-  call void @runtime.lookupPanic(i8* undef, i8* null) #0
+  call void @runtime.lookupPanic(i8* undef, i8* null)
   unreachable
 
 lookup.next:                                      ; preds = %entry
@@ -51,31 +46,26 @@ lookup.next:                                      ; preds = %entry
 
 declare void @runtime.lookupPanic(i8*, i8*)
 
-; Function Attrs: nounwind
-define hidden i1 @main.stringCompareEqual(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i1 @main.stringCompareEqual(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %0 = call i1 @runtime.stringEqual(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* undef, i8* null) #0
+  %0 = call i1 @runtime.stringEqual(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* undef, i8* null)
   ret i1 %0
 }
 
 declare i1 @runtime.stringEqual(i8*, i32, i8*, i32, i8*, i8*)
 
-; Function Attrs: nounwind
-define hidden i1 @main.stringCompareUnequal(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i1 @main.stringCompareUnequal(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %0 = call i1 @runtime.stringEqual(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* undef, i8* null) #0
+  %0 = call i1 @runtime.stringEqual(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* undef, i8* null)
   %1 = xor i1 %0, true
   ret i1 %1
 }
 
-; Function Attrs: nounwind
-define hidden i1 @main.stringCompareLarger(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i1 @main.stringCompareLarger(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %0 = call i1 @runtime.stringLess(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* undef, i8* null) #0
+  %0 = call i1 @runtime.stringLess(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* undef, i8* null)
   %1 = xor i1 %0, true
   ret i1 %1
 }
 
 declare i1 @runtime.stringLess(i8*, i32, i8*, i32, i8*, i8*)
-
-attributes #0 = { nounwind }

go.mod

@@ -1,17 +1,16 @@
 module github.com/tinygo-org/tinygo
 
-go 1.15
+go 1.16
 
 require (
-	github.com/aykevl/go-wasm v0.0.2-0.20211030161413-11881cb9032d // indirect
 	github.com/blakesmith/ar v0.0.0-20150311145944-8bd4349a67f2
 	github.com/chromedp/cdproto v0.0.0-20210113043257-dabd2f2e7693
 	github.com/chromedp/chromedp v0.6.4
 	github.com/google/shlex v0.0.0-20181106134648-c34317bd91bf
 	github.com/marcinbor85/gohex v0.0.0-20200531091804-343a4b548892
 	github.com/mattn/go-colorable v0.1.8
-	go.bug.st/serial v1.1.3
-	golang.org/x/sys v0.0.0-20210510120138-977fb7262007
-	golang.org/x/tools v0.1.6-0.20210813165731-45389f592fe9
+	go.bug.st/serial v1.1.2
+	golang.org/x/sys v0.0.0-20210113181707-4bcb84eeeb78
+	golang.org/x/tools v0.0.0-20200216192241-b320d3a0f5a2
 	tinygo.org/x/go-llvm v0.0.0-20210325115028-e7b85195e81c
 )

go.sum

@@ -1,5 +1,3 @@
-github.com/aykevl/go-wasm v0.0.2-0.20211030161413-11881cb9032d h1:JeuI5/546naK5hpOIX+Lq5xE8rvt7uwiTp6iL+pLQgk=
-github.com/aykevl/go-wasm v0.0.2-0.20211030161413-11881cb9032d/go.mod h1:7sXyiaA0WtSogCu67R2252fQpVmJMh9JWJ9ddtGkpWw=
 github.com/blakesmith/ar v0.0.0-20150311145944-8bd4349a67f2 h1:oMCHnXa6CCCafdPDbMh/lWRhRByN0VFLvv+g+ayx1SI=
 github.com/blakesmith/ar v0.0.0-20150311145944-8bd4349a67f2/go.mod h1:PkYb9DJNAwrSvRx5DYA+gUcOIgTGVMNkfSCbZM8cWpI=
 github.com/chromedp/cdproto v0.0.0-20210113043257-dabd2f2e7693 h1:11eq/RkpaotwdF6b1TRMcdgQUPNmyFEJOB7zLvh0O/Y=
@@ -8,8 +6,8 @@ github.com/chromedp/chromedp v0.6.4 h1:Gx7ZkRyrSVmbbDDja/ieNgNGJIvElroPOyeqYQGVD
 github.com/chromedp/chromedp v0.6.4/go.mod h1:vodUdJf5dF/b8n0UBJv6NeM/QK28RjP3j+eM7fq4+84=
 github.com/chromedp/sysutil v1.0.0 h1:+ZxhTpfpZlmchB58ih/LBHX52ky7w2VhQVKQMucy3Ic=
 github.com/chromedp/sysutil v1.0.0/go.mod h1:kgWmDdq8fTzXYcKIBqIYvRRTnYb9aNS9moAV0xufSww=
-github.com/creack/goselect v0.1.2 h1:2DNy14+JPjRBgPzAd1thbQp4BSIihxcBf0IXhQXDRa0=
-github.com/creack/goselect v0.1.2/go.mod h1:a/NhLweNvqIYMuxcMOuWY516Cimucms3DglDzQP3hKY=
+github.com/creack/goselect v0.1.1 h1:tiSSgKE1eJtxs1h/VgGQWuXUP0YS4CDIFMp6vaI1ls0=
+github.com/creack/goselect v0.1.1/go.mod h1:a/NhLweNvqIYMuxcMOuWY516Cimucms3DglDzQP3hKY=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/gobwas/httphead v0.1.0 h1:exrUm0f4YX0L7EBwZHuCF4GDp8aJfVeBrlLQrs6NqWU=
 github.com/gobwas/httphead v0.1.0/go.mod h1:O/RXo79gxV8G+RqlR/otEwx4Q36zl9rqC5u12GKvMCM=
@@ -32,40 +30,31 @@ github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Ky
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/yuin/goldmark v1.3.5 h1:dPmz1Snjq0kmkz159iL7S6WzdahUTHnHB5M56WFVifs=
-github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
-go.bug.st/serial v1.1.3 h1:YEBxJa9pKS9Wdg46B/jiaKbvvbUrjhZZZITfJHEJhaE=
-go.bug.st/serial v1.1.3/go.mod h1:8TT7u/SwwNIpJ8QaG4s+HTjFt9ReXs2cdOU7ZEk50Dk=
+go.bug.st/serial v1.0.0 h1:ogEPzrllCsnG00EqKRjeYvPRsO7NJW6DqykzkdD6E/k=
+go.bug.st/serial v1.0.0/go.mod h1:rpXPISGjuNjPTRTcMlxi9lN6LoIPxd1ixVjBd8aSk/Q=
+go.bug.st/serial v1.1.2 h1:6xDpbta8KJ+VLRTeM8ghhxXRMLE/Lr8h9iDKwydarAY=
+go.bug.st/serial v1.1.2/go.mod h1:VmYBeyJWp5BnJ0tw2NUJHZdJTGl2ecBGABHlzRK1knY=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee h1:WG0RUwxtNT4qqaXX3DPA8zHFNm/D9xaBpxzHt1WcA/E=
 golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
-golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191128015809-6d18c012aee9 h1:ZBzSG/7F4eNKz2L3GE9o300RX0Az1Bw5HF7PDraD+qU=
+golang.org/x/sys v0.0.0-20191128015809-6d18c012aee9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200909081042-eff7692f9009/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210113181707-4bcb84eeeb78 h1:nVuTkr9L6Bq62qpUqKo/RnZCFfzDBL0bYo6w9OJUqZY=
 golang.org/x/sys v0.0.0-20210113181707-4bcb84eeeb78/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210510120138-977fb7262007 h1:gG67DSER+11cZvqIMb8S8bt0vZtiN6xWYARwirrOSfE=
-golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.1.6-0.20210813165731-45389f592fe9 h1:nvvuMxmx1q0gfRki3T0hjG8EwAcVCs91oWAXvyt4zhI=
-golang.org/x/tools v0.1.6-0.20210813165731-45389f592fe9/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/tools v0.0.0-20200216192241-b320d3a0f5a2 h1:0sfSpGSa544Fwnbot3Oxq/U6SXqjty6Jy/3wRhVS7ig=
+golang.org/x/tools v0.0.0-20200216192241-b320d3a0f5a2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898 h1:/atklqdjdhuosWIl6AIbOeHJjicWYPqR9bpxqxYG2pA=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 tinygo.org/x/go-llvm v0.0.0-20210308112806-9ef958b6bed4 h1:CMUHxVTb+UuUePuMf8vkWjZ3gTp9BBK91KrgOCwoNHs=

goenv/version.go

@@ -12,7 +12,7 @@ import (
 
 // Version of TinyGo.
 // Update this value before release of new version of software.
-const Version = "0.21.0-dev"
+const Version = "0.20.0-dev"
 
 // GetGorootVersion returns the major and minor version for a given GOROOT path.
 // If the goroot cannot be determined, (0, 0) is returned.
@@ -48,10 +48,7 @@ func GetGorootVersion(goroot string) (major, minor int, err error) {
 // toolchain for the given GOROOT path. It is usually of the form `go1.x.y` but
 // can have some variations (for beta releases, for example).
 func GorootVersionString(goroot string) (string, error) {
-	if data, err := ioutil.ReadFile(filepath.Join(goroot, "VERSION")); err == nil {
-		return string(data), nil
-
-	} else if data, err := ioutil.ReadFile(filepath.Join(
+	if data, err := ioutil.ReadFile(filepath.Join(
 		goroot, "src", "runtime", "internal", "sys", "zversion.go")); err == nil {
 
 		r := regexp.MustCompile("const TheVersion = `(.*)`")
@@ -62,6 +59,9 @@ func GorootVersionString(goroot string) (string, error) {
 
 		return string(matches[1]), nil
 
+	} else if data, err := ioutil.ReadFile(filepath.Join(goroot, "VERSION")); err == nil {
+		return string(data), nil
+
 	} else {
 		return "", err
 	}

interp/interp_test.go

@@ -3,6 +3,7 @@ package interp
 import (
 	"io/ioutil"
 	"os"
+	"regexp"
 	"strings"
 	"testing"
 
@@ -17,7 +18,6 @@ func TestInterp(t *testing.T) {
 		"consteval",
 		"interface",
 		"revert",
-		"alloc",
 	} {
 		name := name // make tc local to this closure
 		t.Run(name, func(t *testing.T) {
@@ -88,6 +88,8 @@ func runTest(t *testing.T, pathPrefix string) {
 	}
 }
 
+var alignRegexp = regexp.MustCompile(", align [0-9]+$")
+
 // fuzzyEqualIR returns true if the two LLVM IR strings passed in are roughly
 // equal. That means, only relevant lines are compared (excluding comments
 // etc.).
@@ -99,6 +101,15 @@ func fuzzyEqualIR(s1, s2 string) bool {
 	}
 	for i, line1 := range lines1 {
 		line2 := lines2[i]
+		match1 := alignRegexp.MatchString(line1)
+		match2 := alignRegexp.MatchString(line2)
+		if match1 != match2 {
+			// Only one of the lines has the align keyword. Remove it.
+			// This is a change to make the test work in both LLVM 10 and LLVM
+			// 11 (LLVM 11 appears to automatically add alignment everywhere).
+			line1 = alignRegexp.ReplaceAllString(line1, "")
+			line2 = alignRegexp.ReplaceAllString(line2, "")
+		}
 		if line1 != line2 {
 			return false
 		}

interp/interpreter.go

@@ -234,15 +234,11 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				// Get the requested memory size to be allocated.
 				size := operands[1].Uint()
 
-				// Get the object layout, if it is available.
-				llvmLayoutType := r.getLLVMTypeFromLayout(operands[2])
-
 				// Create the object.
 				alloc := object{
-					globalName:     r.pkgName + "$alloc",
-					llvmLayoutType: llvmLayoutType,
-					buffer:         newRawValue(uint32(size)),
-					size:           uint32(size),
+					globalName: r.pkgName + "$alloc",
+					buffer:     newRawValue(uint32(size)),
+					size:       uint32(size),
 				}
 				index := len(r.objects)
 				r.objects = append(r.objects, alloc)
@@ -382,7 +378,7 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				} else {
 					locals[inst.localIndex] = literalValue{uint8(0)}
 				}
-			case strings.HasSuffix(callFn.name, ".$typeassert"):
+			case callFn.name == "runtime.interfaceImplements":
 				if r.debug {
 					fmt.Fprintln(os.Stderr, indent+"interface assert:", operands[1:])
 				}
@@ -397,9 +393,11 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 					return nil, mem, r.errorAt(inst, err)
 				}
 				methodSet := mem.get(methodSetPtr.index()).llvmGlobal.Initializer()
-				llvmFn := inst.llvmInst.CalledValue()
-				methodSetAttr := llvmFn.GetStringAttributeAtIndex(-1, "tinygo-methods")
-				methodSetString := methodSetAttr.GetStringValue()
+				interfaceMethodSetPtr, err := operands[2].asPointer(r)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
+				}
+				interfaceMethodSet := mem.get(interfaceMethodSetPtr.index()).llvmGlobal.Initializer()
 
 				// Make a set of all the methods on the concrete type, for
 				// easier checking in the next step.
@@ -414,7 +412,8 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				// of defined methods calculated above. This is the interface
 				// assert itself.
 				assertOk := uint8(1) // i1 true
-				for _, name := range strings.Split(methodSetString, "; ") {
+				for i := 0; i < interfaceMethodSet.Type().ArrayLength(); i++ {
+					name := llvm.ConstExtractValue(interfaceMethodSet, []uint32{uint32(i)}).Name()
 					if _, ok := concreteTypeMethods[name]; !ok {
 						// There is a method on the interface that is not
 						// implemented by the type. The assertion will fail.
@@ -424,20 +423,20 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				}
 				// If assertOk is still 1, the assertion succeeded.
 				locals[inst.localIndex] = literalValue{assertOk}
-			case strings.HasSuffix(callFn.name, "$invoke"):
-				// This thunk is the interface method dispatcher: it is called
-				// with all regular parameters and a type code. It will then
-				// call the concrete method for it.
+			case callFn.name == "runtime.interfaceMethod":
+				// This builtin returns the function (which may be a thunk) to
+				// invoke a method on an interface. It does not call the method.
 				if r.debug {
-					fmt.Fprintln(os.Stderr, indent+"invoke method:", operands[1:])
+					fmt.Fprintln(os.Stderr, indent+"interface method:", operands[1:])
 				}
 
-				// Load the type code of the interface value.
-				typecodeIDBitCast, err := operands[len(operands)-3].toLLVMValue(inst.llvmInst.Operand(len(operands)-4).Type(), &mem)
+				// Load the first param, which is the type code (ptrtoint of the
+				// type code global).
+				typecodeIDPtrToInt, err := operands[1].toLLVMValue(inst.llvmInst.Operand(0).Type(), &mem)
 				if err != nil {
 					return nil, mem, r.errorAt(inst, err)
 				}
-				typecodeID := typecodeIDBitCast.Operand(0).Initializer()
+				typecodeID := typecodeIDPtrToInt.Operand(0).Initializer()
 
 				// Load the method set, which is part of the typecodeID object.
 				methodSet := llvm.ConstExtractValue(typecodeID, []uint32{2}).Operand(0).Initializer()
@@ -445,10 +444,7 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				// We don't need to load the interface method set.
 
 				// Load the signature of the to-be-called function.
-				llvmFn := inst.llvmInst.CalledValue()
-				invokeAttr := llvmFn.GetStringAttributeAtIndex(-1, "tinygo-invoke")
-				invokeName := invokeAttr.GetStringValue()
-				signature := r.mod.NamedGlobal(invokeName)
+				signature := inst.llvmInst.Operand(2)
 
 				// Iterate through all methods, looking for the one method that
 				// should be returned.
@@ -461,13 +457,9 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 					}
 				}
 				if method.IsNil() {
-					return nil, mem, r.errorAt(inst, errors.New("could not find method: "+invokeName))
+					return nil, mem, r.errorAt(inst, errors.New("could not find method: "+signature.Name()))
 				}
-
-				// Change the to-be-called function to the underlying method to
-				// be called and fall through to the default case.
-				callFn = r.getFunction(method)
-				fallthrough
+				locals[inst.localIndex] = r.getValue(method)
 			default:
 				if len(callFn.blocks) == 0 {
 					// Call to a function declaration without a definition
@@ -598,14 +590,18 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 			// GetElementPtr does pointer arithmetic, changing the offset of the
 			// pointer into the underlying object.
 			var offset uint64
+			var gepOperands []uint64
 			for i := 2; i < len(operands); i += 2 {
 				index := operands[i].Uint()
 				elementSize := operands[i+1].Uint()
 				if int64(elementSize) < 0 {
 					// This is a struct field.
+					// The field number is encoded by flipping all the bits.
+					gepOperands = append(gepOperands, ^elementSize)
 					offset += index
 				} else {
 					// This is a normal GEP, probably an array index.
+					gepOperands = append(gepOperands, index)
 					offset += elementSize * index
 				}
 			}

interp/memory.go

@@ -18,7 +18,6 @@ import (
 	"encoding/binary"
 	"errors"
 	"math"
-	"math/big"
 	"strconv"
 	"strings"
 
@@ -28,20 +27,17 @@ import (
 // An object is a memory buffer that may be an already existing global or a
 // global created with runtime.alloc or the alloca instruction. If llvmGlobal is
 // set, that's the global for this object, otherwise it needs to be created (if
-// it is still reachable when the package initializer returns). The
-// llvmLayoutType is not necessarily a complete type: it may need to be
-// repeated (for example, for a slice value).
+// it is still reachable when the package initializer returns).
 //
 // Objects are copied in a memory view when they are stored to, to provide the
 // ability to roll back interpreting a function.
 type object struct {
-	llvmGlobal     llvm.Value
-	llvmType       llvm.Type // must match llvmGlobal.Type() if both are set, may be unset if llvmGlobal is set
-	llvmLayoutType llvm.Type // LLVM type based on runtime.alloc layout parameter, if available
-	globalName     string    // name, if not yet created (not guaranteed to be the final name)
-	buffer         value     // buffer with value as given by interp, nil if external
-	size           uint32    // must match buffer.len(), if available
-	marked         uint8     // 0 means unmarked, 1 means external read, 2 means external write
+	llvmGlobal llvm.Value
+	llvmType   llvm.Type // must match llvmGlobal.Type() if both are set, may be unset if llvmGlobal is set
+	globalName string    // name, if not yet created (not guaranteed to be the final name)
+	buffer     value     // buffer with value as given by interp, nil if external
+	size       uint32    // must match buffer.len(), if available
+	marked     uint8     // 0 means unmarked, 1 means external read, 2 means external write
 }
 
 // clone() returns a cloned version of this object, for when an object needs to
@@ -526,18 +522,6 @@ func (v pointerValue) llvmValue(mem *memoryView) llvm.Value {
 // bitcast. The llvm.Type parameter is optional, if omitted the pointer type may
 // be different than expected.
 func (v pointerValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Value, error) {
-	// If a particular LLVM type is requested, cast to it.
-	if !llvmType.IsNil() && llvmType.TypeKind() != llvm.PointerTypeKind {
-		// The LLVM value has (or should have) the same bytes once compiled, but
-		// does not have the right LLVM type. This can happen for example when
-		// storing to a struct with a single pointer field: this pointer may
-		// then become the value even though the pointer should be wrapped in a
-		// struct.
-		// This can be worked around by simply converting to a raw value,
-		// rawValue knows how to create such structs.
-		return v.asRawValue(mem.r).toLLVMValue(llvmType, mem)
-	}
-
 	// Obtain the llvmValue, creating it if it doesn't exist yet.
 	llvmValue := v.llvmValue(mem)
 	if llvmValue.IsNil() {
@@ -545,7 +529,7 @@ func (v pointerValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Val
 		// runtime.alloc.
 		// First allocate a new global for this object.
 		obj := mem.get(v.index())
-		if obj.llvmType.IsNil() && obj.llvmLayoutType.IsNil() {
+		if obj.llvmType.IsNil() {
 			// Create an initializer without knowing the global type.
 			// This is probably the result of a runtime.alloc call.
 			initializer, err := obj.buffer.asRawValue(mem.r).rawLLVMValue(mem)
@@ -559,23 +543,7 @@ func (v pointerValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Val
 			obj.llvmGlobal = llvmValue
 			mem.put(v.index(), obj)
 		} else {
-			// The global type is known, or at least its structure.
-			var globalType llvm.Type
-			if !obj.llvmType.IsNil() {
-				// The exact type is known.
-				globalType = obj.llvmType.ElementType()
-			} else { // !obj.llvmLayoutType.IsNil()
-				// The exact type isn't known, but the object layout is known.
-				globalType = obj.llvmLayoutType
-				// The layout may not span the full size of the global because
-				// of repetition. One example would be make([]string, 5) which
-				// would be 10 words in size but the layout would only be two
-				// words (for the string type).
-				typeSize := mem.r.targetData.TypeAllocSize(globalType)
-				if typeSize != uint64(obj.size) {
-					globalType = llvm.ArrayType(globalType, int(uint64(obj.size)/typeSize))
-				}
-			}
+			globalType := obj.llvmType.ElementType()
 			if checks && mem.r.targetData.TypeAllocSize(globalType) != uint64(obj.size) {
 				panic("size of the globalType isn't the same as the object size")
 			}
@@ -594,11 +562,6 @@ func (v pointerValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Val
 				return llvm.Value{}, errors.New("interp: allocated value does not match allocated type")
 			}
 			llvmValue.SetInitializer(initializer)
-			if obj.llvmType.IsNil() {
-				// The exact type isn't known (only the layout), so use the
-				// alignment that would normally be expected from runtime.alloc.
-				llvmValue.SetAlignment(mem.r.maxAlign)
-			}
 		}
 
 		// It should be included in r.globals because otherwise markExternal
@@ -608,24 +571,87 @@ func (v pointerValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Val
 		llvmValue.SetLinkage(llvm.InternalLinkage)
 	}
 
-	if v.offset() != 0 {
-		// If there is an offset, make sure to use a GEP to index into the
-		// pointer.
-		// Cast to an i8* first (if needed) for easy indexing.
-		if llvmValue.Type() != mem.r.i8ptrType {
-			llvmValue = llvm.ConstBitCast(llvmValue, mem.r.i8ptrType)
+	if llvmType.IsNil() {
+		if v.offset() != 0 {
+			// If there is an offset, make sure to use a GEP to index into the
+			// pointer. Because there is no expected type, we use whatever is
+			// most convenient: an *i8 type. It is trivial to index byte-wise.
+			if llvmValue.Type() != mem.r.i8ptrType {
+				llvmValue = llvm.ConstBitCast(llvmValue, mem.r.i8ptrType)
+			}
+			llvmValue = llvm.ConstInBoundsGEP(llvmValue, []llvm.Value{
+				llvm.ConstInt(llvmValue.Type().Context().Int32Type(), uint64(v.offset()), false),
+			})
 		}
-		llvmValue = llvm.ConstInBoundsGEP(llvmValue, []llvm.Value{
-			llvm.ConstInt(llvmValue.Type().Context().Int32Type(), uint64(v.offset()), false),
-		})
+		return llvmValue, nil
 	}
 
-	// If a particular LLVM pointer type is requested, cast to it.
-	if !llvmType.IsNil() && llvmType != llvmValue.Type() {
-		llvmValue = llvm.ConstBitCast(llvmValue, llvmType)
+	if llvmType.TypeKind() != llvm.PointerTypeKind {
+		// The LLVM value has (or should have) the same bytes once compiled, but
+		// does not have the right LLVM type. This can happen for example when
+		// storing to a struct with a single pointer field: this pointer may
+		// then become the value even though the pointer should be wrapped in a
+		// struct.
+		// This can be worked around by simply converting to a raw value,
+		// rawValue knows how to create such structs.
+		if v.offset() != 0 {
+			return llvm.Value{}, errors.New("interp: offset set without known pointer type")
+		}
+		return v.asRawValue(mem.r).toLLVMValue(llvmType, mem)
 	}
 
-	return llvmValue, nil
+	requestedType := llvmType
+	objectElementType := llvmValue.Type()
+	if requestedType == objectElementType {
+		if v.offset() != 0 {
+			// This should never happen, if offset is non-zero, the types
+			// shouldn't match.
+			return llvm.Value{}, errors.New("interp: offset set while there is no way to convert the type")
+		}
+		return llvmValue, nil
+	}
+
+	if v.offset() == 0 {
+		// Offset is zero, so we can just bitcast to get a correct pointer.
+		return llvm.ConstBitCast(llvmValue, llvmType), nil
+	}
+
+	// We need to make a constant GEP for pointer arithmetic.
+	int32Type := llvmType.Context().Int32Type()
+	indices := []llvm.Value{llvm.ConstInt(int32Type, 0, false)}
+	requestedType = requestedType.ElementType()
+	objectElementType = objectElementType.ElementType()
+	offset := int64(v.offset())
+	for offset > 0 {
+		switch objectElementType.TypeKind() {
+		case llvm.ArrayTypeKind:
+			elementType := objectElementType.ElementType()
+			elementSize := mem.r.targetData.TypeAllocSize(elementType)
+			elementIndex := uint64(offset) / elementSize
+			indices = append(indices, llvm.ConstInt(int32Type, elementIndex, false))
+			offset -= int64(elementIndex * elementSize)
+			objectElementType = elementType
+		case llvm.StructTypeKind:
+			element := mem.r.targetData.ElementContainingOffset(objectElementType, uint64(offset))
+			indices = append(indices, llvm.ConstInt(int32Type, uint64(element), false))
+			offset -= int64(mem.r.targetData.ElementOffset(objectElementType, element))
+			objectElementType = objectElementType.StructElementTypes()[element]
+		default:
+			return llvm.Value{}, errors.New("interp: pointer index with something other than a struct or array?")
+		}
+	}
+	if offset < 0 {
+		return llvm.Value{}, errors.New("interp: offset has somehow gone negative, this should be impossible")
+	}
+
+	// Finally do the gep, using the above computed indices.
+	// If it still doesn't match te requested type, it's possible to bitcast (as
+	// the bits of the pointer are now correct, just not the type).
+	gep := llvm.ConstInBoundsGEP(llvmValue, indices)
+	if gep.Type() != llvmType {
+		return llvm.ConstBitCast(gep, llvmType), nil
+	}
+	return gep, nil
 }
 
 // rawValue is a raw memory buffer that can store either pointers or regular
@@ -959,9 +985,12 @@ func (v *rawValue) set(llvmValue llvm.Value, r *runner) {
 		case llvm.GetElementPtr:
 			ptr := llvmValue.Operand(0)
 			index := llvmValue.Operand(1)
+			if checks && index.IsAConstantInt().IsNil() || index.ZExtValue() != 0 {
+				panic("expected first index of const gep to be i32 0")
+			}
 			numOperands := llvmValue.OperandsCount()
 			elementType := ptr.Type().ElementType()
-			totalOffset := r.targetData.TypeAllocSize(elementType) * index.ZExtValue()
+			totalOffset := uint64(0)
 			for i := 2; i < numOperands; i++ {
 				indexValue := llvmValue.Operand(i)
 				if checks && indexValue.IsAConstantInt().IsNil() {
@@ -1180,108 +1209,3 @@ func (r *runner) getValue(llvmValue llvm.Value) value {
 		panic("unknown value")
 	}
 }
-
-// readObjectLayout reads the object layout as it is stored by the compiler. It
-// returns the size in the number of words and the bitmap.
-func (r *runner) readObjectLayout(layoutValue value) (uint64, *big.Int) {
-	pointerSize := layoutValue.len(r)
-	if checks && uint64(pointerSize) != r.targetData.TypeAllocSize(r.i8ptrType) {
-		panic("inconsistent pointer size")
-	}
-
-	// The object layout can be stored in a global variable, directly as an
-	// integer value, or can be nil.
-	ptr, err := layoutValue.asPointer(r)
-	if err == errIntegerAsPointer {
-		// It's an integer, which means it's a small object or unknown.
-		layout := layoutValue.Uint()
-		if layout == 0 {
-			// Nil pointer, which means the layout is unknown.
-			return 0, nil
-		}
-		if layout%2 != 1 {
-			// Sanity check: the least significant bit must be set. This is how
-			// the runtime can separate pointers from integers.
-			panic("unexpected layout")
-		}
-
-		// Determine format of bitfields in the integer.
-		pointerBits := uint64(pointerSize * 8)
-		var sizeFieldBits uint64
-		switch pointerBits {
-		case 16:
-			sizeFieldBits = 4
-		case 32:
-			sizeFieldBits = 5
-		case 64:
-			sizeFieldBits = 6
-		default:
-			panic("unknown pointer size")
-		}
-
-		// Extract fields.
-		objectSizeWords := (layout >> 1) & (1<<sizeFieldBits - 1)
-		bitmap := new(big.Int).SetUint64(layout >> (1 + sizeFieldBits))
-		return objectSizeWords, bitmap
-	}
-
-	// Read the object size in words and the bitmap from the global.
-	buf := r.objects[ptr.index()].buffer.(rawValue)
-	objectSizeWords := rawValue{buf: buf.buf[:r.pointerSize]}.Uint()
-	rawByteValues := buf.buf[r.pointerSize:]
-	rawBytes := make([]byte, len(rawByteValues))
-	for i, v := range rawByteValues {
-		if uint64(byte(v)) != v {
-			panic("found pointer in data array?") // sanity check
-		}
-		rawBytes[i] = byte(v)
-	}
-	bitmap := new(big.Int).SetBytes(rawBytes)
-	return objectSizeWords, bitmap
-}
-
-// getLLVMTypeFromLayout returns the 'layout type', which is an approximation of
-// the real type. Pointers are in the correct location but the actual object may
-// have some additional repetition, for example in the buffer of a slice.
-func (r *runner) getLLVMTypeFromLayout(layoutValue value) llvm.Type {
-	objectSizeWords, bitmap := r.readObjectLayout(layoutValue)
-	if bitmap == nil {
-		// No information available.
-		return llvm.Type{}
-	}
-
-	if bitmap.BitLen() == 0 {
-		// There are no pointers in this object, so treat this as a raw byte
-		// buffer. This is important because objects without pointers may have
-		// lower alignment.
-		return r.mod.Context().Int8Type()
-	}
-
-	// Create the LLVM type.
-	pointerSize := layoutValue.len(r)
-	pointerAlignment := r.targetData.PrefTypeAlignment(r.i8ptrType)
-	var fields []llvm.Type
-	for i := 0; i < int(objectSizeWords); {
-		if bitmap.Bit(i) != 0 {
-			// Pointer field.
-			fields = append(fields, r.i8ptrType)
-			i += int(pointerSize / uint32(pointerAlignment))
-		} else {
-			// Byte/word field.
-			fields = append(fields, r.mod.Context().IntType(pointerAlignment*8))
-			i += 1
-		}
-	}
-	var llvmLayoutType llvm.Type
-	if len(fields) == 1 {
-		llvmLayoutType = fields[0]
-	} else {
-		llvmLayoutType = r.mod.Context().StructType(fields, false)
-	}
-
-	objectSizeBytes := objectSizeWords * uint64(pointerAlignment)
-	if checks && r.targetData.TypeAllocSize(llvmLayoutType) != objectSizeBytes {
-		panic("unexpected size") // sanity check
-	}
-	return llvmLayoutType
-}

interp/testdata/alloc.ll

@@ -1,53 +0,0 @@
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32--wasi"
-
-@"runtime/gc.layout:62-2000000000000001" = linkonce_odr unnamed_addr constant { i32, [8 x i8] } { i32 62, [8 x i8] c" \00\00\00\00\00\00\01" }
-@pointerFree12 = global i8* null
-@pointerFree7 = global i8* null
-@pointerFree3 = global i8* null
-@pointerFree0 = global i8* null
-@layout1 = global i8* null
-@layout2 = global i8* null
-@layout3 = global i8* null
-@layout4 = global i8* null
-@bigobj1 = global i8* null
-
-declare i8* @runtime.alloc(i32, i8*) unnamed_addr
-
-define void @runtime.initAll() unnamed_addr {
-  call void @main.init()
-  ret void
-}
-
-define internal void @main.init() unnamed_addr {
-  ; Object that's word-aligned.
-  %pointerFree12 = call i8* @runtime.alloc(i32 12, i8* inttoptr (i32 3 to i8*))
-  store i8* %pointerFree12, i8** @pointerFree12
-  ; Object larger than a word but not word-aligned.
-  %pointerFree7 = call i8* @runtime.alloc(i32 7, i8* inttoptr (i32 3 to i8*))
-  store i8* %pointerFree7, i8** @pointerFree7
-  ; Object smaller than a word (and of course not word-aligned).
-  %pointerFree3 = call i8* @runtime.alloc(i32 3, i8* inttoptr (i32 3 to i8*))
-  store i8* %pointerFree3, i8** @pointerFree3
-  ; Zero-sized object.
-  %pointerFree0 = call i8* @runtime.alloc(i32 0, i8* inttoptr (i32 3 to i8*))
-  store i8* %pointerFree0, i8** @pointerFree0
-
-  ; Object made out of 3 pointers.
-  %layout1 = call i8* @runtime.alloc(i32 12, i8* inttoptr (i32 67 to i8*))
-  store i8* %layout1, i8** @layout1
-  ; Array (or slice) of 5 slices.
-  %layout2 = call i8* @runtime.alloc(i32 60, i8* inttoptr (i32 71 to i8*))
-  store i8* %layout2, i8** @layout2
-  ; Oddly shaped object, using all bits in the layout integer.
-  %layout3 = call i8* @runtime.alloc(i32 104, i8* inttoptr (i32 2467830261 to i8*))
-  store i8* %layout3, i8** @layout3
-  ; ...repeated.
-  %layout4 = call i8* @runtime.alloc(i32 312, i8* inttoptr (i32 2467830261 to i8*))
-  store i8* %layout4, i8** @layout4
-
-  ; Large object that needs to be stored in a separate global.
-  %bigobj1 = call i8* @runtime.alloc(i32 248, i8* bitcast ({ i32, [8 x i8] }* @"runtime/gc.layout:62-2000000000000001" to i8*))
-  store i8* %bigobj1, i8** @bigobj1
-  ret void
-}

interp/testdata/alloc.out.ll

@@ -1,25 +0,0 @@
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32--wasi"
-
-@pointerFree12 = local_unnamed_addr global i8* getelementptr inbounds ([12 x i8], [12 x i8]* @"main$alloc", i32 0, i32 0)
-@pointerFree7 = local_unnamed_addr global i8* getelementptr inbounds ([7 x i8], [7 x i8]* @"main$alloc.1", i32 0, i32 0)
-@pointerFree3 = local_unnamed_addr global i8* getelementptr inbounds ([3 x i8], [3 x i8]* @"main$alloc.2", i32 0, i32 0)
-@pointerFree0 = local_unnamed_addr global i8* getelementptr inbounds ([0 x i8], [0 x i8]* @"main$alloc.3", i32 0, i32 0)
-@layout1 = local_unnamed_addr global i8* bitcast ([3 x i8*]* @"main$alloc.4" to i8*)
-@layout2 = local_unnamed_addr global i8* bitcast ([5 x { i8*, i32, i32 }]* @"main$alloc.5" to i8*)
-@layout3 = local_unnamed_addr global i8* bitcast ({ i8*, i8*, i8*, i32, i32, i8*, i8*, i32, i32, i32, i32, i32, i32, i8*, i8*, i32, i32, i32, i8*, i8*, i32, i32, i8*, i32, i32, i8* }* @"main$alloc.6" to i8*)
-@layout4 = local_unnamed_addr global i8* bitcast ([3 x { i8*, i8*, i8*, i32, i32, i8*, i8*, i32, i32, i32, i32, i32, i32, i8*, i8*, i32, i32, i32, i8*, i8*, i32, i32, i8*, i32, i32, i8* }]* @"main$alloc.7" to i8*)
-@bigobj1 = local_unnamed_addr global i8* bitcast ({ i8*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i8* }* @"main$alloc.8" to i8*)
-@"main$alloc" = internal global [12 x i8] zeroinitializer, align 4
-@"main$alloc.1" = internal global [7 x i8] zeroinitializer, align 4
-@"main$alloc.2" = internal global [3 x i8] zeroinitializer, align 4
-@"main$alloc.3" = internal global [0 x i8] zeroinitializer, align 4
-@"main$alloc.4" = internal global [3 x i8*] zeroinitializer, align 4
-@"main$alloc.5" = internal global [5 x { i8*, i32, i32 }] zeroinitializer, align 4
-@"main$alloc.6" = internal global { i8*, i8*, i8*, i32, i32, i8*, i8*, i32, i32, i32, i32, i32, i32, i8*, i8*, i32, i32, i32, i8*, i8*, i32, i32, i8*, i32, i32, i8* } zeroinitializer, align 4
-@"main$alloc.7" = internal global [3 x { i8*, i8*, i8*, i32, i32, i8*, i8*, i32, i32, i32, i32, i32, i32, i8*, i8*, i32, i32, i32, i8*, i8*, i32, i32, i8*, i32, i32, i8* }] zeroinitializer, align 4
-@"main$alloc.8" = internal global { i8*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i8* } zeroinitializer, align 4
-
-define void @runtime.initAll() unnamed_addr {
-  ret void
-}

interp/testdata/basic.out.ll

@@ -18,14 +18,14 @@ entry:
   call void @runtime.printint64(i64 5)
   call void @runtime.printnl()
   %value1 = call i64 @someValue()
-  store i64 %value1, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @main.nonConst1, i32 0, i32 0), align 8
-  %value2 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @main.nonConst1, i32 0, i32 0), align 8
-  store i64 %value2, i64* @main.nonConst2, align 8
-  call void @modifyExternal(i32* bitcast (i8* getelementptr inbounds (i8, i8* bitcast ([8 x { i16, i32 }]* @main.someArray to i8*), i32 28) to i32*))
+  store i64 %value1, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @main.nonConst1, i32 0, i32 0)
+  %value2 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @main.nonConst1, i32 0, i32 0)
+  store i64 %value2, i64* @main.nonConst2
+  call void @modifyExternal(i32* getelementptr inbounds ([8 x { i16, i32 }], [8 x { i16, i32 }]* @main.someArray, i32 0, i32 3, i32 1))
   call void @modifyExternal(i32* bitcast ([1 x i16*]* @main.exportedValue to i32*))
-  store i16 5, i16* @main.exposedValue1, align 2
+  store i16 5, i16* @main.exposedValue1
   call void @modifyExternal(i32* bitcast (void ()* @willModifyGlobal to i32*))
-  store i16 7, i16* @main.exposedValue2, align 2
+  store i16 7, i16* @main.exposedValue2
   call void @modifyExternal(i32* bitcast (void ()* @hasInlineAsm to i32*))
   call void @runtime.printint64(i64 6)
   call void @runtime.printint64(i64 -1)
@@ -39,7 +39,7 @@ entry:
   %agg2.insertvalue2 = insertvalue { i64, i16 } %agg2.agg1, i64 5, 0
   %agg2.insertvalue1 = insertvalue { float, { i64, i16 } } %agg2.agg0, { i64, i16 } %agg2.insertvalue2, 1
   %agg2.insertvalue0 = insertvalue { i8, i32, { float, { i64, i16 } } } %agg, { float, { i64, i16 } } %agg2.insertvalue1, 2
-  store { i8, i32, { float, { i64, i16 } } } %agg2.insertvalue0, { i8, i32, { float, { i64, i16 } } }* @main.insertedValue, align 8
+  store { i8, i32, { float, { i64, i16 } } } %agg2.insertvalue0, { i8, i32, { float, { i64, i16 } } }* @main.insertedValue
   ret void
 }
 
@@ -56,7 +56,7 @@ declare void @modifyExternal(i32*) local_unnamed_addr
 
 define void @willModifyGlobal() {
 entry:
-  store i16 8, i16* @main.exposedValue2, align 2
+  store i16 8, i16* @main.exposedValue2
   ret void
 }
 

interp/testdata/consteval.ll

@@ -3,8 +3,6 @@ target triple = "x86_64--linux"
 
 @intToPtrResult = global i8 0
 @ptrToIntResult = global i8 0
-@someArray = internal global {i16, i8, i8} zeroinitializer
-@someArrayPointer = global i8* zeroinitializer
 
 define void @runtime.initAll() {
   call void @main.init()
@@ -14,7 +12,6 @@ define void @runtime.initAll() {
 define internal void @main.init() {
   call void @testIntToPtr()
   call void @testPtrToInt()
-  call void @testConstGEP()
   ret void
 }
 
@@ -43,8 +40,3 @@ b:
   store i8 2, i8* @ptrToIntResult
   ret void
 }
-
-define internal void @testConstGEP() {
-  store i8* getelementptr inbounds (i8, i8* bitcast ({i16, i8, i8}* @someArray to i8*), i32 2), i8** @someArrayPointer
-  ret void
-}

interp/testdata/consteval.out.ll

@@ -3,8 +3,6 @@ target triple = "x86_64--linux"
 
 @intToPtrResult = local_unnamed_addr global i8 2
 @ptrToIntResult = local_unnamed_addr global i8 2
-@someArray = internal global { i16, i8, i8 } zeroinitializer
-@someArrayPointer = local_unnamed_addr global i8* getelementptr inbounds ({ i16, i8, i8 }, { i16, i8, i8 }* @someArray, i64 0, i32 1)
 
 define void @runtime.initAll() local_unnamed_addr {
   ret void

interp/testdata/slice-copy.ll

@@ -10,7 +10,7 @@ target triple = "x86_64--linux"
 
 declare i64 @runtime.sliceCopy(i8* %dst, i8* %src, i64 %dstLen, i64 %srcLen, i64 %elemSize) unnamed_addr
 
-declare i8* @runtime.alloc(i64, i8*) unnamed_addr
+declare i8* @runtime.alloc(i64) unnamed_addr
 
 declare void @runtime.printuint8(i8)
 
@@ -52,7 +52,7 @@ entry:
   ;     uint8SliceDst = make([]uint8, len(uint8SliceSrc))
   %uint8SliceSrc = load { i8*, i64, i64 }, { i8*, i64, i64 }* @main.uint8SliceSrc
   %uint8SliceSrc.len = extractvalue { i8*, i64, i64 } %uint8SliceSrc, 1
-  %uint8SliceDst.buf = call i8* @runtime.alloc(i64 %uint8SliceSrc.len, i8* null)
+  %uint8SliceDst.buf = call i8* @runtime.alloc(i64 %uint8SliceSrc.len)
   %0 = insertvalue { i8*, i64, i64 } undef, i8* %uint8SliceDst.buf, 0
   %1 = insertvalue { i8*, i64, i64 } %0, i64 %uint8SliceSrc.len, 1
   %2 = insertvalue { i8*, i64, i64 } %1, i64 %uint8SliceSrc.len, 2
@@ -68,7 +68,7 @@ entry:
   %int16SliceSrc = load { i16*, i64, i64 }, { i16*, i64, i64 }* @main.int16SliceSrc
   %int16SliceSrc.len = extractvalue { i16*, i64, i64 } %int16SliceSrc, 1
   %int16SliceSrc.len.bytes = mul i64 %int16SliceSrc.len, 2
-  %int16SliceDst.buf.raw = call i8* @runtime.alloc(i64 %int16SliceSrc.len.bytes, i8* null)
+  %int16SliceDst.buf.raw = call i8* @runtime.alloc(i64 %int16SliceSrc.len.bytes)
   %int16SliceDst.buf = bitcast i8* %int16SliceDst.buf.raw to i16*
   %3 = insertvalue { i16*, i64, i64 } undef, i16* %int16SliceDst.buf, 0
   %4 = insertvalue { i16*, i64, i64 } %3, i64 %int16SliceSrc.len, 1

interp/testdata/slice-copy.out.ll

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