all: update for 0.31.1

Signed-off-by: deadprogram <ron@hybridgroup.com>

.github/workflows/docker.yml

@@ -64,7 +64,6 @@ jobs:
           push: true
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
-          build-contexts: tinygo-llvm-build=docker-image://tinygo/llvm-17
           cache-from: type=gha
           cache-to: type=gha,mode=max
       - name: Trigger Drivers repo build on Github Actions

CHANGELOG.md

@@ -1,3 +1,17 @@
+0.31.1
+---
+
+* **general**
+  * fix Binaryen build in make task
+  * update final build stage of Docker `dev` image to go1.22
+  * only use GHA cache for building Docker `dev` image
+  * update the `net` submodule to latest version
+
+* **compiler**
+  * `interp`: make getelementptr offsets signed
+  * `interp`: return a proper error message when indexing out of range
+
+
 0.31.0
 ---
 
@@ -64,7 +78,7 @@
   * `mksnanov3`: add support for the MKS Robin Nano V3.x
   * `nrf52840-generic`: add generic nrf52840 chip support
   * `thumby`: add support for Thumby
-  * `wasm`: add new `wasm-generic` target that doesn't depend on WASI or a browser
+  * `wasm`: add new `wasm-unknown` target that doesn't depend on WASI or a browser
 * **boards**
   * `arduino-mkrwifi1010`, `arduino-nano33`, `nano-rp2040`, `matrixportal-m4`, `metro-m4-airlift`, `pybadge`, `pyportal`: add `ninafw` build tag and some constants for BLE support
   * `gopher-badge`: fix typo in USB product name

Dockerfile

@@ -33,7 +33,7 @@ RUN cd /tinygo/ && \
 
 # tinygo-compiler copies the compiler build over to a base Go container (without
 # all the build tools etc).
-FROM golang:1.21 AS tinygo-compiler
+FROM golang:1.22 AS tinygo-compiler
 
 # Copy tinygo build.
 COPY --from=tinygo-compiler-build /tinygo/build/release/tinygo /tinygo

goenv/version.go

@@ -9,7 +9,7 @@ import (
 
 // Version of TinyGo.
 // Update this value before release of new version of software.
-const version = "0.31.0"
+const version = "0.31.1"
 
 var (
 	// This variable is set at build time using -ldflags parameters.

interp/interpreter.go

@@ -427,7 +427,11 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				if err != nil {
 					return nil, mem, r.errorAt(inst, err)
 				}
-				methodSetPtr, err := mem.load(typecodePtr.addOffset(-int64(r.pointerSize)), r.pointerSize).asPointer(r)
+				typecodePtrOffset, err := typecodePtr.addOffset(-int64(r.pointerSize))
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err) // unlikely
+				}
+				methodSetPtr, err := mem.load(typecodePtrOffset, r.pointerSize).asPointer(r)
 				if err != nil {
 					return nil, mem, r.errorAt(inst, err)
 				}
@@ -473,7 +477,11 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				if err != nil {
 					return nil, mem, r.errorAt(inst, err)
 				}
-				methodSetPtr, err := mem.load(typecodePtr.addOffset(-int64(r.pointerSize)), r.pointerSize).asPointer(r)
+				typecodePtrOffset, err := typecodePtr.addOffset(-int64(r.pointerSize))
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
+				}
+				methodSetPtr, err := mem.load(typecodePtrOffset, r.pointerSize).asPointer(r)
 				if err != nil {
 					return nil, mem, r.errorAt(inst, err)
 				}
@@ -636,11 +644,11 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 		case llvm.GetElementPtr:
 			// GetElementPtr does pointer arithmetic, changing the offset of the
 			// pointer into the underlying object.
-			var offset uint64
+			var offset int64
 			for i := 1; i < len(operands); i += 2 {
-				index := operands[i].Uint()
-				elementSize := operands[i+1].Uint()
-				if int64(elementSize) < 0 {
+				index := operands[i].Int()
+				elementSize := operands[i+1].Int()
+				if elementSize < 0 {
 					// This is a struct field.
 					offset += index
 				} else {
@@ -654,11 +662,14 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 					return nil, mem, r.errorAt(inst, err)
 				}
 				// GEP on fixed pointer value (for example, memory-mapped I/O).
-				ptrValue := operands[0].Uint() + offset
+				ptrValue := operands[0].Uint() + uint64(offset)
 				locals[inst.localIndex] = makeLiteralInt(ptrValue, int(operands[0].len(r)*8))
 				continue
 			}
-			ptr = ptr.addOffset(int64(offset))
+			ptr, err = ptr.addOffset(int64(offset))
+			if err != nil {
+				return nil, mem, r.errorAt(inst, err)
+			}
 			locals[inst.localIndex] = ptr
 			if r.debug {
 				fmt.Fprintln(os.Stderr, indent+"gep:", operands, "->", ptr)
@@ -756,7 +767,10 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				if inst.opcode == llvm.Add {
 					// This likely means this is part of a
 					// unsafe.Pointer(uintptr(ptr) + offset) pattern.
-					lhsPtr = lhsPtr.addOffset(int64(rhs.Uint()))
+					lhsPtr, err = lhsPtr.addOffset(int64(rhs.Uint()))
+					if err != nil {
+						return nil, mem, r.errorAt(inst, err)
+					}
 					locals[inst.localIndex] = lhsPtr
 				} else if inst.opcode == llvm.Xor && rhs.Uint() == 0 {
 					// Special workaround for strings.noescape, see

interp/memory.go

@@ -517,12 +517,12 @@ func (v pointerValue) offset() uint32 {
 // addOffset essentially does a GEP operation (pointer arithmetic): it adds the
 // offset to the pointer. It also checks that the offset doesn't overflow the
 // maximum offset size (which is 4GB).
-func (v pointerValue) addOffset(offset int64) pointerValue {
+func (v pointerValue) addOffset(offset int64) (pointerValue, error) {
 	result := pointerValue{v.pointer + uint64(offset)}
 	if checks && v.index() != result.index() {
-		panic("interp: offset out of range")
+		return result, fmt.Errorf("interp: offset %d out of range for object %v", offset, v)
 	}
-	return result
+	return result, nil
 }
 
 func (v pointerValue) len(r *runner) uint32 {

interp/testdata/basic.ll

@@ -10,6 +10,8 @@ target triple = "x86_64--linux"
 @main.exposedValue1 = global i16 0
 @main.exposedValue2 = global i16 0
 @main.insertedValue = global {i8, i32, {float, {i64, i16}}} zeroinitializer
+@main.gepArray = global [8 x i8] zeroinitializer
+@main.negativeGEP = global ptr null
 
 declare void @runtime.printint64(i64) unnamed_addr
 
@@ -88,6 +90,11 @@ entry:
   %agg2 = insertvalue {i8, i32, {float, {i64, i16}}} %agg, i64 5, 2, 1, 0
   store {i8, i32, {float, {i64, i16}}} %agg2, ptr @main.insertedValue
 
+  ; negative GEP instruction
+  %ngep1 = getelementptr [8 x i8], ptr @main.negativeGEP, i32 0, i32 5
+  %ngep2 = getelementptr [8 x i8], ptr %ngep1, i32 0, i32 -3
+  store ptr %ngep2, ptr @main.negativeGEP
+
   ret void
 }
 

interp/testdata/basic.out.ll

@@ -9,6 +9,8 @@ target triple = "x86_64--linux"
 @main.exposedValue1 = global i16 0
 @main.exposedValue2 = local_unnamed_addr global i16 0
 @main.insertedValue = local_unnamed_addr global { i8, i32, { float, { i64, i16 } } } zeroinitializer
+@main.gepArray = local_unnamed_addr global [8 x i8] zeroinitializer
+@main.negativeGEP = global ptr getelementptr inbounds (i8, ptr @main.negativeGEP, i64 2)
 
 declare void @runtime.printint64(i64) unnamed_addr