func (l langType) rtypeBuild(i int, sizes types.Sizes, t types.Type, name string) (string, reflect.Kind) { var kind reflect.Kind kind, name = getTypeInfo(t, name) sof := int64(4) aof := int64(4) if kind != reflect.Invalid { sof = sizes.Sizeof(t) aof = sizes.Alignof(t) } ret := "Go_haxegoruntime_newRRtype.callFromRT(0,\n" ret += fmt.Sprintf("\t/*size:*/ %d,\n", sof) ret += fmt.Sprintf("\t/*align:*/ %d,\n", aof) ret += fmt.Sprintf("\t/*fieldAlign:*/ %d,\n", aof) // TODO check correct for fieldAlign ret += fmt.Sprintf("\t/*kind:*/ %d, // %s\n", kind, (kind & ((1 << 5) - 1)).String()) alg := "false" if types.Comparable(t) { alg = "true" } ret += fmt.Sprintf("\t/*comprable:*/ %s,\n", alg) // TODO change this to be the actual function ret += fmt.Sprintf("\t/*string:*/ \"%s\", // %s\n", escapedTypeString(t.String()), t.String()) ret += fmt.Sprintf("\t/*uncommonType:*/ %s,\n", l.uncommonBuild(i, sizes, name, t)) ptt := "null" for pti, pt := range l.hc.typesByID { _, isPtr := pt.(*types.Pointer) if isPtr { ele := l.hc.pte.At(pt.(*types.Pointer).Elem()) if ele != nil { if i == ele.(int) { ptt = fmt.Sprintf("type%d()", pti) } } } } ret += fmt.Sprintf("\t/*ptrToThis:*/ %s", ptt) ret += ")" return ret, kind }
// Interpret interprets the Go program whose main package is mainpkg. // mode specifies various interpreter options. filename and args are // the initial values of os.Args for the target program. sizes is the // effective type-sizing function for this program. // // Interpret returns the exit code of the program: 2 for panic (like // gc does), or the argument to os.Exit for normal termination. // // The SSA program must include the "runtime" package. // func Interpret(mainpkg *ssa.Package, mode Mode, sizes types.Sizes, filename string, args []string) (exitCode int) { i := &interpreter{ prog: mainpkg.Prog, globals: make(map[ssa.Value]*value), mode: mode, sizes: sizes, } runtimePkg := i.prog.ImportedPackage("runtime") if runtimePkg == nil { panic("ssa.Program doesn't include runtime package") } i.runtimeErrorString = runtimePkg.Type("errorString").Object().Type() initReflect(i) i.osArgs = append(i.osArgs, filename) for _, arg := range args { i.osArgs = append(i.osArgs, arg) } for _, pkg := range i.prog.AllPackages() { // Initialize global storage. for _, m := range pkg.Members { switch v := m.(type) { case *ssa.Global: cell := zero(deref(v.Type())) i.globals[v] = &cell } } // Ad-hoc initialization for magic system variables. switch pkg.Object.Path() { case "syscall": setGlobal(i, pkg, "envs", environ) case "runtime": sz := sizes.Sizeof(pkg.Object.Scope().Lookup("MemStats").Type()) setGlobal(i, pkg, "sizeof_C_MStats", uintptr(sz)) // Delete the bodies of almost all "runtime" functions since they're magic. // A missing intrinsic leads to a very clear error. for _, mem := range pkg.Members { if fn, ok := mem.(*ssa.Function); ok { switch fn.Name() { case "GOROOT", "gogetenv": // keep default: fn.Blocks = nil } } } } } // Top-level error handler. exitCode = 2 defer func() { if exitCode != 2 || i.mode&DisableRecover != 0 { return } switch p := recover().(type) { case exitPanic: exitCode = int(p) return case targetPanic: fmt.Fprintln(os.Stderr, "panic:", toString(p.v)) case runtime.Error: fmt.Fprintln(os.Stderr, "panic:", p.Error()) case string: fmt.Fprintln(os.Stderr, "panic:", p) default: fmt.Fprintf(os.Stderr, "panic: unexpected type: %T\n", p) } // TODO(adonovan): dump panicking interpreter goroutine? // buf := make([]byte, 0x10000) // runtime.Stack(buf, false) // fmt.Fprintln(os.Stderr, string(buf)) // (Or dump panicking target goroutine?) }() // Run! call(i, nil, token.NoPos, mainpkg.Func("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 }