aboutsummaryrefslogtreecommitdiffhomepage
path: root/interp
diff options
context:
space:
mode:
authorAyke van Laethem <[email protected]>2024-08-22 16:42:03 +0200
committerRon Evans <[email protected]>2024-09-05 10:06:30 +0200
commit73f519b589bf45d8b9a121063bd264357f632c06 (patch)
treea55d9e8f21b22867566e28b59bed3e31340a8308 /interp
parent25abfff63204f72140ab1b29120ab9b674d5cf41 (diff)
downloadtinygo-73f519b589bf45d8b9a121063bd264357f632c06.tar.gz
tinygo-73f519b589bf45d8b9a121063bd264357f632c06.zip
interp: support big-endian targets
The interp package was assuming that all targets were little-endian. But that's not true: we now have a big-endian target (GOARCH=mips). This fixes the interp package to use the appropriate byte order for a given target.
Diffstat (limited to 'interp')
-rw-r--r--interp/interp.go4
-rw-r--r--interp/interpreter.go98
-rw-r--r--interp/memory.go76
3 files changed, 94 insertions, 84 deletions
diff --git a/interp/interp.go b/interp/interp.go
index 80afc39c7..30b087248 100644
--- a/interp/interp.go
+++ b/interp/interp.go
@@ -3,11 +3,13 @@
package interp
import (
+ "encoding/binary"
"fmt"
"os"
"strings"
"time"
+ "github.com/tinygo-org/tinygo/compiler/llvmutil"
"tinygo.org/x/go-llvm"
)
@@ -24,6 +26,7 @@ type runner struct {
dataPtrType llvm.Type // often used type so created in advance
uintptrType llvm.Type // equivalent to uintptr in Go
maxAlign int // maximum alignment of an object, alignment of runtime.alloc() result
+ byteOrder binary.ByteOrder // big-endian or little-endian
debug bool // log debug messages
pkgName string // package name of the currently executing package
functionCache map[llvm.Value]*function // cache of compiled functions
@@ -38,6 +41,7 @@ func newRunner(mod llvm.Module, timeout time.Duration, debug bool) *runner {
r := runner{
mod: mod,
targetData: llvm.NewTargetData(mod.DataLayout()),
+ byteOrder: llvmutil.ByteOrder(mod.Target()),
debug: debug,
functionCache: make(map[llvm.Value]*function),
objects: []object{{}},
diff --git a/interp/interpreter.go b/interp/interpreter.go
index b35129b81..512d93eb7 100644
--- a/interp/interpreter.go
+++ b/interp/interpreter.go
@@ -173,7 +173,7 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
case 3:
// Conditional branch: [cond, thenBB, elseBB]
lastBB = currentBB
- switch operands[0].Uint() {
+ switch operands[0].Uint(r) {
case 1: // true -> thenBB
currentBB = int(operands[1].(literalValue).value.(uint32))
case 0: // false -> elseBB
@@ -191,12 +191,12 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
}
case llvm.Switch:
// Switch statement: [value, defaultLabel, case0, label0, case1, label1, ...]
- value := operands[0].Uint()
- targetLabel := operands[1].Uint() // default label
+ value := operands[0].Uint(r)
+ targetLabel := operands[1].Uint(r) // default label
// Do a lazy switch by iterating over all cases.
for i := 2; i < len(operands); i += 2 {
- if value == operands[i].Uint() {
- targetLabel = operands[i+1].Uint()
+ if value == operands[i].Uint(r) {
+ targetLabel = operands[i+1].Uint(r)
break
}
}
@@ -211,7 +211,7 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
// Select is much like a ternary operator: it picks a result from
// the second and third operand based on the boolean first operand.
var result value
- switch operands[0].Uint() {
+ switch operands[0].Uint(r) {
case 1:
result = operands[1]
case 0:
@@ -282,7 +282,7 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
// by creating a global variable.
// Get the requested memory size to be allocated.
- size := operands[1].Uint()
+ size := operands[1].Uint(r)
// Get the object layout, if it is available.
llvmLayoutType := r.getLLVMTypeFromLayout(operands[2])
@@ -318,9 +318,9 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
// memmove(dst, src, n*elemSize)
// return int(n)
// }
- dstLen := operands[3].Uint()
- srcLen := operands[4].Uint()
- elemSize := operands[5].Uint()
+ dstLen := operands[3].Uint(r)
+ srcLen := operands[4].Uint(r)
+ elemSize := operands[5].Uint(r)
n := srcLen
if n > dstLen {
n = dstLen
@@ -374,7 +374,7 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
if err != nil {
return nil, mem, r.errorAt(inst, err)
}
- nBytes := uint32(operands[3].Uint())
+ nBytes := uint32(operands[3].Uint(r))
dstObj := mem.getWritable(dst.index())
dstBuf := dstObj.buffer.asRawValue(r)
if mem.get(src.index()).buffer == nil {
@@ -661,8 +661,8 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
// pointer into the underlying object.
var offset int64
for i := 1; i < len(operands); i += 2 {
- index := operands[i].Int()
- elementSize := operands[i+1].Int()
+ index := operands[i].Int(r)
+ elementSize := operands[i+1].Int(r)
if elementSize < 0 {
// This is a struct field.
offset += index
@@ -677,7 +677,7 @@ 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() + uint64(offset)
+ ptrValue := operands[0].Uint(r) + uint64(offset)
locals[inst.localIndex] = makeLiteralInt(ptrValue, int(operands[0].len(r)*8))
continue
}
@@ -739,11 +739,11 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
var lhs, rhs float64
switch operands[0].len(r) {
case 8:
- lhs = math.Float64frombits(operands[0].Uint())
- rhs = math.Float64frombits(operands[1].Uint())
+ lhs = math.Float64frombits(operands[0].Uint(r))
+ rhs = math.Float64frombits(operands[1].Uint(r))
case 4:
- lhs = float64(math.Float32frombits(uint32(operands[0].Uint())))
- rhs = float64(math.Float32frombits(uint32(operands[1].Uint())))
+ lhs = float64(math.Float32frombits(uint32(operands[0].Uint(r))))
+ rhs = float64(math.Float32frombits(uint32(operands[1].Uint(r))))
default:
panic("unknown float type")
}
@@ -782,23 +782,23 @@ 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, err = lhsPtr.addOffset(int64(rhs.Uint()))
+ lhsPtr, err = lhsPtr.addOffset(int64(rhs.Uint(r)))
if err != nil {
return nil, mem, r.errorAt(inst, err)
}
locals[inst.localIndex] = lhsPtr
- } else if inst.opcode == llvm.Xor && rhs.Uint() == 0 {
+ } else if inst.opcode == llvm.Xor && rhs.Uint(r) == 0 {
// Special workaround for strings.noescape, see
// src/strings/builder.go in the Go source tree. This is
// the identity operator, so we can return the input.
locals[inst.localIndex] = lhs
- } else if inst.opcode == llvm.And && rhs.Uint() < 8 {
+ } else if inst.opcode == llvm.And && rhs.Uint(r) < 8 {
// This is probably part of a pattern to get the lower bits
// of a pointer for pointer tagging, like this:
// uintptr(unsafe.Pointer(t)) & 0b11
// We can actually support this easily by ANDing with the
// pointer offset.
- result := uint64(lhsPtr.offset()) & rhs.Uint()
+ result := uint64(lhsPtr.offset()) & rhs.Uint(r)
locals[inst.localIndex] = makeLiteralInt(result, int(lhs.len(r)*8))
} else {
// Catch-all for weird operations that should just be done
@@ -813,31 +813,31 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
var result uint64
switch inst.opcode {
case llvm.Add:
- result = lhs.Uint() + rhs.Uint()
+ result = lhs.Uint(r) + rhs.Uint(r)
case llvm.Sub:
- result = lhs.Uint() - rhs.Uint()
+ result = lhs.Uint(r) - rhs.Uint(r)
case llvm.Mul:
- result = lhs.Uint() * rhs.Uint()
+ result = lhs.Uint(r) * rhs.Uint(r)
case llvm.UDiv:
- result = lhs.Uint() / rhs.Uint()
+ result = lhs.Uint(r) / rhs.Uint(r)
case llvm.SDiv:
- result = uint64(lhs.Int() / rhs.Int())
+ result = uint64(lhs.Int(r) / rhs.Int(r))
case llvm.URem:
- result = lhs.Uint() % rhs.Uint()
+ result = lhs.Uint(r) % rhs.Uint(r)
case llvm.SRem:
- result = uint64(lhs.Int() % rhs.Int())
+ result = uint64(lhs.Int(r) % rhs.Int(r))
case llvm.Shl:
- result = lhs.Uint() << rhs.Uint()
+ result = lhs.Uint(r) << rhs.Uint(r)
case llvm.LShr:
- result = lhs.Uint() >> rhs.Uint()
+ result = lhs.Uint(r) >> rhs.Uint(r)
case llvm.AShr:
- result = uint64(lhs.Int() >> rhs.Uint())
+ result = uint64(lhs.Int(r) >> rhs.Uint(r))
case llvm.And:
- result = lhs.Uint() & rhs.Uint()
+ result = lhs.Uint(r) & rhs.Uint(r)
case llvm.Or:
- result = lhs.Uint() | rhs.Uint()
+ result = lhs.Uint(r) | rhs.Uint(r)
case llvm.Xor:
- result = lhs.Uint() ^ rhs.Uint()
+ result = lhs.Uint(r) ^ rhs.Uint(r)
default:
panic("unreachable")
}
@@ -855,11 +855,11 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
// and then truncating it as necessary.
var value uint64
if inst.opcode == llvm.SExt {
- value = uint64(operands[0].Int())
+ value = uint64(operands[0].Int(r))
} else {
- value = operands[0].Uint()
+ value = operands[0].Uint(r)
}
- bitwidth := operands[1].Uint()
+ bitwidth := operands[1].Uint(r)
if r.debug {
fmt.Fprintln(os.Stderr, indent+instructionNameMap[inst.opcode]+":", value, bitwidth)
}
@@ -868,11 +868,11 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
var value float64
switch inst.opcode {
case llvm.SIToFP:
- value = float64(operands[0].Int())
+ value = float64(operands[0].Int(r))
case llvm.UIToFP:
- value = float64(operands[0].Uint())
+ value = float64(operands[0].Uint(r))
}
- bitwidth := operands[1].Uint()
+ bitwidth := operands[1].Uint(r)
if r.debug {
fmt.Fprintln(os.Stderr, indent+instructionNameMap[inst.opcode]+":", value, bitwidth)
}
@@ -918,21 +918,21 @@ func (r *runner) interpretICmp(lhs, rhs value, predicate llvm.IntPredicate) bool
}
return result
case llvm.IntUGT:
- return lhs.Uint() > rhs.Uint()
+ return lhs.Uint(r) > rhs.Uint(r)
case llvm.IntUGE:
- return lhs.Uint() >= rhs.Uint()
+ return lhs.Uint(r) >= rhs.Uint(r)
case llvm.IntULT:
- return lhs.Uint() < rhs.Uint()
+ return lhs.Uint(r) < rhs.Uint(r)
case llvm.IntULE:
- return lhs.Uint() <= rhs.Uint()
+ return lhs.Uint(r) <= rhs.Uint(r)
case llvm.IntSGT:
- return lhs.Int() > rhs.Int()
+ return lhs.Int(r) > rhs.Int(r)
case llvm.IntSGE:
- return lhs.Int() >= rhs.Int()
+ return lhs.Int(r) >= rhs.Int(r)
case llvm.IntSLT:
- return lhs.Int() < rhs.Int()
+ return lhs.Int(r) < rhs.Int(r)
case llvm.IntSLE:
- return lhs.Int() <= rhs.Int()
+ return lhs.Int(r) <= rhs.Int(r)
default:
// _should_ be unreachable, until LLVM adds new icmp operands (unlikely)
panic("interp: unsupported icmp")
diff --git a/interp/memory.go b/interp/memory.go
index 759a1ffe4..176228fdc 100644
--- a/interp/memory.go
+++ b/interp/memory.go
@@ -361,8 +361,8 @@ type value interface {
clone() value
asPointer(*runner) (pointerValue, error)
asRawValue(*runner) rawValue
- Uint() uint64
- Int() int64
+ Uint(*runner) uint64
+ Int(*runner) int64
toLLVMValue(llvm.Type, *memoryView) (llvm.Value, error)
String() string
}
@@ -405,7 +405,8 @@ func (v literalValue) len(r *runner) uint32 {
}
func (v literalValue) String() string {
- return strconv.FormatInt(v.Int(), 10)
+ // Note: passing a nil *runner to v.Int because we know it won't use it.
+ return strconv.FormatInt(v.Int(nil), 10)
}
func (v literalValue) clone() value {
@@ -421,13 +422,13 @@ func (v literalValue) asRawValue(r *runner) rawValue {
switch value := v.value.(type) {
case uint64:
buf = make([]byte, 8)
- binary.LittleEndian.PutUint64(buf, value)
+ r.byteOrder.PutUint64(buf, value)
case uint32:
buf = make([]byte, 4)
- binary.LittleEndian.PutUint32(buf, uint32(value))
+ r.byteOrder.PutUint32(buf, uint32(value))
case uint16:
buf = make([]byte, 2)
- binary.LittleEndian.PutUint16(buf, uint16(value))
+ r.byteOrder.PutUint16(buf, uint16(value))
case uint8:
buf = []byte{uint8(value)}
default:
@@ -440,7 +441,7 @@ func (v literalValue) asRawValue(r *runner) rawValue {
return raw
}
-func (v literalValue) Uint() uint64 {
+func (v literalValue) Uint(r *runner) uint64 {
switch value := v.value.(type) {
case uint64:
return value
@@ -455,7 +456,7 @@ func (v literalValue) Uint() uint64 {
}
}
-func (v literalValue) Int() int64 {
+func (v literalValue) Int(r *runner) int64 {
switch value := v.value.(type) {
case uint64:
return int64(value)
@@ -553,11 +554,11 @@ func (v pointerValue) asRawValue(r *runner) rawValue {
return rv
}
-func (v pointerValue) Uint() uint64 {
+func (v pointerValue) Uint(r *runner) uint64 {
panic("cannot convert pointer to integer")
}
-func (v pointerValue) Int() int64 {
+func (v pointerValue) Int(r *runner) int64 {
panic("cannot convert pointer to integer")
}
@@ -702,7 +703,12 @@ func (v rawValue) String() string {
}
// Format as number if none of the buf is a pointer.
if !v.hasPointer() {
- return strconv.FormatInt(v.Int(), 10)
+ // Construct a fake runner, which is little endian.
+ // We only use String() for debugging, so this is is good enough
+ // (the printed value will just be slightly wrong when debugging the
+ // interp package with GOOS=mips for example).
+ r := &runner{byteOrder: binary.LittleEndian}
+ return strconv.FormatInt(v.Int(r), 10)
}
}
return "<[…" + strconv.Itoa(len(v.buf)) + "]>"
@@ -738,33 +744,33 @@ func (v rawValue) bytes() []byte {
return buf
}
-func (v rawValue) Uint() uint64 {
+func (v rawValue) Uint(r *runner) uint64 {
buf := v.bytes()
switch len(v.buf) {
case 1:
return uint64(buf[0])
case 2:
- return uint64(binary.LittleEndian.Uint16(buf))
+ return uint64(r.byteOrder.Uint16(buf))
case 4:
- return uint64(binary.LittleEndian.Uint32(buf))
+ return uint64(r.byteOrder.Uint32(buf))
case 8:
- return binary.LittleEndian.Uint64(buf)
+ return r.byteOrder.Uint64(buf)
default:
panic("unknown integer size")
}
}
-func (v rawValue) Int() int64 {
+func (v rawValue) Int(r *runner) int64 {
switch len(v.buf) {
case 1:
- return int64(int8(v.Uint()))
+ return int64(int8(v.Uint(r)))
case 2:
- return int64(int16(v.Uint()))
+ return int64(int16(v.Uint(r)))
case 4:
- return int64(int32(v.Uint()))
+ return int64(int32(v.Uint(r)))
case 8:
- return int64(int64(v.Uint()))
+ return int64(int64(v.Uint(r)))
default:
panic("unknown integer size")
}
@@ -878,11 +884,11 @@ func (v rawValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Value,
var n uint64
switch llvmType.IntTypeWidth() {
case 64:
- n = rawValue{v.buf[:8]}.Uint()
+ n = rawValue{v.buf[:8]}.Uint(mem.r)
case 32:
- n = rawValue{v.buf[:4]}.Uint()
+ n = rawValue{v.buf[:4]}.Uint(mem.r)
case 16:
- n = rawValue{v.buf[:2]}.Uint()
+ n = rawValue{v.buf[:2]}.Uint(mem.r)
case 8:
n = uint64(v.buf[0])
case 1:
@@ -951,7 +957,7 @@ func (v rawValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Value,
}
// This is either a null pointer or a raw pointer for memory-mapped I/O
// (such as 0xe000ed00).
- ptr := rawValue{v.buf[:mem.r.pointerSize]}.Uint()
+ ptr := rawValue{v.buf[:mem.r.pointerSize]}.Uint(mem.r)
if ptr == 0 {
// Null pointer.
return llvm.ConstNull(llvmType), nil
@@ -969,11 +975,11 @@ func (v rawValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Value,
}
return llvm.ConstIntToPtr(ptrValue, llvmType), nil
case llvm.DoubleTypeKind:
- b := rawValue{v.buf[:8]}.Uint()
+ b := rawValue{v.buf[:8]}.Uint(mem.r)
f := math.Float64frombits(b)
return llvm.ConstFloat(llvmType, f), nil
case llvm.FloatTypeKind:
- b := uint32(rawValue{v.buf[:4]}.Uint())
+ b := uint32(rawValue{v.buf[:4]}.Uint(mem.r))
f := math.Float32frombits(b)
return llvm.ConstFloat(llvmType, float64(f)), nil
default:
@@ -1065,19 +1071,19 @@ func (v *rawValue) set(llvmValue llvm.Value, r *runner) {
switch llvmValue.Type().IntTypeWidth() {
case 64:
var buf [8]byte
- binary.LittleEndian.PutUint64(buf[:], n)
+ r.byteOrder.PutUint64(buf[:], n)
for i, b := range buf {
v.buf[i] = uint64(b)
}
case 32:
var buf [4]byte
- binary.LittleEndian.PutUint32(buf[:], uint32(n))
+ r.byteOrder.PutUint32(buf[:], uint32(n))
for i, b := range buf {
v.buf[i] = uint64(b)
}
case 16:
var buf [2]byte
- binary.LittleEndian.PutUint16(buf[:], uint16(n))
+ r.byteOrder.PutUint16(buf[:], uint16(n))
for i, b := range buf {
v.buf[i] = uint64(b)
}
@@ -1109,14 +1115,14 @@ func (v *rawValue) set(llvmValue llvm.Value, r *runner) {
case llvm.DoubleTypeKind:
f, _ := llvmValue.DoubleValue()
var buf [8]byte
- binary.LittleEndian.PutUint64(buf[:], math.Float64bits(f))
+ r.byteOrder.PutUint64(buf[:], math.Float64bits(f))
for i, b := range buf {
v.buf[i] = uint64(b)
}
case llvm.FloatTypeKind:
f, _ := llvmValue.DoubleValue()
var buf [4]byte
- binary.LittleEndian.PutUint32(buf[:], math.Float32bits(float32(f)))
+ r.byteOrder.PutUint32(buf[:], math.Float32bits(float32(f)))
for i, b := range buf {
v.buf[i] = uint64(b)
}
@@ -1166,11 +1172,11 @@ func (v localValue) asRawValue(r *runner) rawValue {
panic("interp: localValue.asRawValue")
}
-func (v localValue) Uint() uint64 {
+func (v localValue) Uint(r *runner) uint64 {
panic("interp: localValue.Uint")
}
-func (v localValue) Int() int64 {
+func (v localValue) Int(r *runner) int64 {
panic("interp: localValue.Int")
}
@@ -1254,7 +1260,7 @@ func (r *runner) readObjectLayout(layoutValue value) (uint64, *big.Int) {
ptr, err := layoutValue.asPointer(r)
if err == errIntegerAsPointer {
// It's an integer, which means it's a small object or unknown.
- layout := layoutValue.Uint()
+ layout := layoutValue.Uint(r)
if layout == 0 {
// Nil pointer, which means the layout is unknown.
return 0, nil
@@ -1287,7 +1293,7 @@ func (r *runner) readObjectLayout(layoutValue value) (uint64, *big.Int) {
// 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()
+ objectSizeWords := rawValue{buf: buf.buf[:r.pointerSize]}.Uint(r)
rawByteValues := buf.buf[r.pointerSize:]
rawBytes := make([]byte, len(rawByteValues))
for i, v := range rawByteValues {