code review 7313062: exp/ssa/interp: (#6 of 5): test interpretation of SSA f...

src/pkg/exp/ssa/interp/external.go

 // Copyright 2013 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package interp
 
 // Emulated functions that we cannot interpret because they are
 // external or because they use "unsafe" or "reflect" operations.
 
 import (
         "exp/ssa"
         "math"
         "os"
         "runtime"
         "syscall"
         "time"
 )
 
-type externalFn func(fn *ssa.Function, args []value, slots []value) value
+type externalFn func(fn *ssa.Function, args []value) value
 
 // Key strings are from Function.FullName().
 // That little dot ۰ is an Arabic zero numeral (U+06F0), categories [Nd].
 var externals = map[string]externalFn{
         "(reflect.Value).CanAddr":         ext۰reflect۰Value۰CanAddr,
         "(reflect.Value).CanInterface":    ext۰reflect۰Value۰CanInterface,
         "(reflect.Value).Elem":            ext۰reflect۰Value۰Elem,
         "(reflect.Value).Field":           ext۰reflect۰Value۰Field,
         "(reflect.Value).Index":           ext۰reflect۰Value۰Index,
         "(reflect.Value).Int":             ext۰reflect۰Value۰Int,
         "(reflect.Value).Interface":       ext۰reflect۰Value۰Interface,
         "(reflect.Value).IsNil":           ext۰reflect۰Value۰IsNil,
         "(reflect.Value).IsValid":         ext۰reflect۰Value۰IsValid,
         "(reflect.Value).Kind":            ext۰reflect۰Value۰Kind,
         "(reflect.Value).Len":             ext۰reflect۰Value۰Len,
         "(reflect.Value).NumField":        ext۰reflect۰Value۰NumField,
         "(reflect.Value).Pointer":         ext۰reflect۰Value۰Pointer,
+        "(reflect.Value).String":          ext۰reflect۰Value۰String,
         "(reflect.Value).Type":            ext۰reflect۰Value۰Type,
         "(reflect.rtype).Bits":            ext۰reflect۰rtype۰Bits,
         "(reflect.rtype).Elem":            ext۰reflect۰rtype۰Elem,
         "(reflect.rtype).Kind":            ext۰reflect۰rtype۰Kind,
         "(reflect.rtype).String":          ext۰reflect۰rtype۰String,
         "math.Float32bits":                ext۰math۰Float32bits,
         "math.Float32frombits":            ext۰math۰Float32frombits,
         "math.Float64bits":                ext۰math۰Float64bits,
         "math.Float64frombits":            ext۰math۰Float64frombits,
         "reflect.TypeOf":                  ext۰reflect۰TypeOf,
@@ skipping 14 matching lines @@
         "sync/atomic.StoreInt32":          ext۰atomic۰StoreInt32,
         "sync/atomic.StoreUint32":         ext۰atomic۰StoreUint32,
         "syscall.Exit":                    ext۰syscall۰Exit,
         "syscall.Getpid":                  ext۰syscall۰Getpid,
         "syscall.Kill":                    ext۰syscall۰Kill,
         "syscall.Write":                   ext۰syscall۰Write,
         "time.Sleep":                      ext۰time۰Sleep,
         "time.now":                        ext۰time۰now,
 }
 
-func ext۰math۰Float64frombits(fn *ssa.Function, args []value, slots []value) value {
+func ext۰math۰Float64frombits(fn *ssa.Function, args []value) value {
         return math.Float64frombits(args[0].(uint64))
 }
 
-func ext۰math۰Float64bits(fn *ssa.Function, args []value, slots []value) value {
+func ext۰math۰Float64bits(fn *ssa.Function, args []value) value {
         return math.Float64bits(args[0].(float64))
 }
 
-func ext۰math۰Float32frombits(fn *ssa.Function, args []value, slots []value) value {
+func ext۰math۰Float32frombits(fn *ssa.Function, args []value) value {
         return math.Float32frombits(args[0].(uint32))
 }
 
-func ext۰math۰Float32bits(fn *ssa.Function, args []value, slots []value) value {
+func ext۰math۰Float32bits(fn *ssa.Function, args []value) value {
         return math.Float32bits(args[0].(float32))
 }
 
-func ext۰runtime۰Breakpoint(fn *ssa.Function, args []value, slots []value) value {
+func ext۰runtime۰Breakpoint(fn *ssa.Function, args []value) value {
         runtime.Breakpoint()
         return nil
 }
 
-func ext۰runtime۰getgoroot(fn *ssa.Function, args []value, slots []value) value {
+func ext۰runtime۰getgoroot(fn *ssa.Function, args []value) value {
         return os.Getenv("GOROOT")
 }
 
-func ext۰runtime۰GOMAXPROCS(fn *ssa.Function, args []value, slots []value) value {
+func ext۰runtime۰GOMAXPROCS(fn *ssa.Function, args []value) value {
         return runtime.GOMAXPROCS(args[0].(int))
 }
 
-func ext۰runtime۰GC(fn *ssa.Function, args []value, slots []value) value {
+func ext۰runtime۰GC(fn *ssa.Function, args []value) value {
         runtime.GC()
         return nil
 }
 
-func ext۰runtime۰Gosched(fn *ssa.Function, args []value, slots []value) value {
+func ext۰runtime۰Gosched(fn *ssa.Function, args []value) value {
         runtime.Gosched()
         return nil
 }
 
-func ext۰runtime۰ReadMemStats(fn *ssa.Function, args []value, slots []value) value {
+func ext۰runtime۰ReadMemStats(fn *ssa.Function, args []value) value {
         // TODO(adonovan): populate args[0].(Struct)
         return nil
 }
 
-func ext۰atomic۰LoadUint32(fn *ssa.Function, args []value, slots []value) value {
+func ext۰atomic۰LoadUint32(fn *ssa.Function, args []value) value {
         // TODO(adonovan): fix: not atomic!
         return (*args[0].(*value)).(uint32)
 }
 
-func ext۰atomic۰StoreUint32(fn *ssa.Function, args []value, slots []value) value {
+func ext۰atomic۰StoreUint32(fn *ssa.Function, args []value) value {
         // TODO(adonovan): fix: not atomic!
         *args[0].(*value) = args[1].(uint32)
         return nil
 }
 
-func ext۰atomic۰LoadInt32(fn *ssa.Function, args []value, slots []value) value {
+func ext۰atomic۰LoadInt32(fn *ssa.Function, args []value) value {
         // TODO(adonovan): fix: not atomic!
         return (*args[0].(*value)).(int32)
 }
 
-func ext۰atomic۰StoreInt32(fn *ssa.Function, args []value, slots []value) value {
+func ext۰atomic۰StoreInt32(fn *ssa.Function, args []value) value {
         // TODO(adonovan): fix: not atomic!
         *args[0].(*value) = args[1].(int32)
         return nil
 }
 
-func ext۰atomic۰CompareAndSwapInt32(fn *ssa.Function, args []value, slots []value) value {
+func ext۰atomic۰CompareAndSwapInt32(fn *ssa.Function, args []value) value {
         // TODO(adonovan): fix: not atomic!
         p := args[0].(*value)
         if (*p).(int32) == args[1].(int32) {
                 *p = args[2].(int32)
                 return true
         }
         return false
 }
 
-func ext۰atomic۰AddInt32(fn *ssa.Function, args []value, slots []value) value {
+func ext۰atomic۰AddInt32(fn *ssa.Function, args []value) value {
         // TODO(adonovan): fix: not atomic!
         p := args[0].(*value)
         newv := (*p).(int32) + args[1].(int32)
         *p = newv
         return newv
 }
 
-func ext۰runtime۰SetFinalizer(fn *ssa.Function, args []value, slots []value) value {
+func ext۰runtime۰SetFinalizer(fn *ssa.Function, args []value) value {
         return nil // ignore
 }
 
-func ext۰time۰now(fn *ssa.Function, args []value, slots []value) value {
+func ext۰time۰now(fn *ssa.Function, args []value) value {
         nano := time.Now().UnixNano()
         return tuple{int64(nano / 1e9), int32(nano % 1e9)}
 }
 
-func ext۰time۰Sleep(fn *ssa.Function, args []value, slots []value) value {
+func ext۰time۰Sleep(fn *ssa.Function, args []value) value {
         time.Sleep(time.Duration(args[0].(int64)))
         return nil
 }
 
-func ext۰syscall۰Exit(fn *ssa.Function, args []value, slots []value) value {
-        // We could emulate syscall.Syscall but it's more effort.
-        syscall.Exit(args[0].(int))
-        return nil
+func ext۰syscall۰Exit(fn *ssa.Function, args []value) value {
+        panic(exitPanic(args[0].(int)))
 }
 
-func ext۰syscall۰Getpid(fn *ssa.Function, args []value, slots []value) value {
+func ext۰syscall۰Getpid(fn *ssa.Function, args []value) value {
         // We could emulate syscall.Syscall but it's more effort.
         return syscall.Getpid()
 }
 
 // The set of remaining native functions we need to implement (as needed):
 
 // bytes/bytes.go:42:func Equal(a, b []byte) bool
 // bytes/bytes_decl.go:8:func IndexByte(s []byte, c byte) int // asm_$GOARCH.s
 // crypto/aes/cipher_asm.go:10:func hasAsm() bool
 // crypto/aes/cipher_asm.go:11:func encryptBlockAsm(nr int, xk *uint32, dst, src *byte)
@@ skipping 101 matching lines @@
 // syscall/syscall_unix.go:23:func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
 // syscall/syscall_unix.go:24:func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
 // syscall/syscall_unix.go:25:func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
 // syscall/syscall_unix.go:26:func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
 // time/sleep.go:25:func startTimer(*runtimeTimer)
 // time/sleep.go:26:func stopTimer(*runtimeTimer) bool
 // time/time.go:758:func now() (sec int64, nsec int32)
 // unsafe/unsafe.go:27:func Sizeof(v ArbitraryType) uintptr
 // unsafe/unsafe.go:32:func Offsetof(v ArbitraryType) uintptr
 // unsafe/unsafe.go:37:func Alignof(v ArbitraryType) uintptr