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

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

 // Package exp/ssa/interp defines an interpreter for the SSA
 // representation of Go programs.
 //
 // This interpreter is provided as an adjunct for testing the SSA
 // construction algorithm.  Its purpose is to provide a minimal
 // metacircular implementation of the dynamic semantics of each SSA
 // instruction.  It is not, and will never be, a production-quality Go
 // interpreter.
 //
 // The following is a partial list of Go features that are currently
@@ skipping 90 matching lines @@
         case nil:
                 return nil
         case *ssa.Function, *ssa.Builtin:
                 return key
         case *ssa.Literal:
                 return literalValue(key)
         case *ssa.Global:
                 if r, ok := fr.i.globals[key]; ok {
                         return r
                 }
-        default:
-                if r, ok := fr.env[key]; ok {
-                        return r
-                }
-        }
-        panic(fmt.Sprintf("get: unexpected type %T", key))
+        }
+        if r, ok := fr.env[key]; ok {
+                return r
+        }
+        panic(fmt.Sprintf("get: no value for %T: %v", key, key.Name()))
 }
 
 // findMethodSet returns the method set for type typ, which may be one
 // of the interpreter's fake types.
 func findMethodSet(i *interpreter, typ types.Type) ssa.MethodSet {
         if typ == rtypeType {
                 return i.rtypeMethods
         }
         return i.prog.MethodSet(typ)
 }
@@ skipping 38 matching lines @@
                 case 1:
                         fr.result = fr.get(instr.Results[0])
                 default:
                         var res []value
                         for _, r := range instr.Results {
                                 res = append(res, copyVal(fr.get(r)))
                         }
                         fr.result = tuple(res)
                 }
                 return kReturn
+
+        case *ssa.Panic:
+                panic(targetPanic{fr.get(instr.X)})
 
         case *ssa.Send:
                 fr.get(instr.Chan).(chan value) <- copyVal(fr.get(instr.X))
 
         case *ssa.Store:
                 *fr.get(instr.Addr).(*value) = copyVal(fr.get(instr.Val))
 
         case *ssa.If:
                 succ := 1
                 if fr.get(instr.Cond).(bool) {
@@ skipping 285 matching lines @@
                 for i := range fn.Locals {
                         fr.locals[i] = bad{}
                 }
                 if fr.status == stPanic {
                         panic(fr.panic) // panic stack is not entirely clean
                 }
         }()
 
         for {
                 if i.mode&EnableTracing != 0 {
-                        fmt.Fprintf(os.Stderr, ".%s:\n", fr.block.Name)
+                        fmt.Fprintf(os.Stderr, ".%s:\n", fr.block)
                 }
         block:
                 for _, instr = range fr.block.Instrs {
                         if i.mode&EnableTracing != 0 {
                                 if v, ok := instr.(ssa.Value); ok {
                                         fmt.Fprintln(os.Stderr, "\t", v.Name(), "=", instr)
                                 } else {
                                         fmt.Fprintln(os.Stderr, "\t", instr)
                                 }
                         }
@@ skipping 54 matching lines @@
                         }
                         envs = append(envs, "GOSSAINTERP=1")
                         setGlobal(i, pkg, "envs", envs)
 
                 case "runtime":
                         // TODO(gri): expose go/types.sizeof so we can
                         // avoid this fragile magic number;
                         // unsafe.Sizeof(memStats) won't work since gc
                         // and go/types have different sizeof
                         // functions.
-                        setGlobal(i, pkg, "sizeof_C_MStats", uintptr(3450))
+                        setGlobal(i, pkg, "sizeof_C_MStats", uintptr(3696))
 
                 case "os":
                         Args := []value{filename}
                         for _, s := range args {
                                 Args = append(Args, s)
                         }
                         setGlobal(i, pkg, "Args", Args)
                 }
         }
 
@@ skipping 28 matching lines @@
         call(i, nil, token.NoPos, mainpkg.Init, nil)
         if mainFn := mainpkg.Func("main"); mainFn != nil {
                 call(i, nil, token.NoPos, mainFn, nil)
                 exitCode = 0
         } else {
                 fmt.Fprintln(os.Stderr, "No main function.")
                 exitCode = 1
         }
         return
 }