Example #1
0
File: main.go Project: Xslxy/e8vm
func runImage(bs []byte, dasm bool, n int) {
	if dasm {
		err := dasm8.DumpImage(bytes.NewReader(bs), os.Stdout)
		if err != nil {
			fmt.Println(err)
		}
	}
	if len(bs) == 0 {
		fmt.Println("(the image is empty)")
		return
	}

	m := arch8.NewMachine(new(arch8.Config))
	if err := m.LoadImageBytes(bs); err != nil {
		fmt.Println(err)
		return
	}

	ncycle, exp := m.Run(n)
	fmt.Printf("(%d cycles)\n", ncycle)
	if exp != nil {
		if !arch8.IsHalt(exp) {
			fmt.Println(exp)
			err := arch8.FprintStack(os.Stdout, m, exp)
			if err != nil {
				fmt.Println(err)
			}
		}
	} else {
		fmt.Println("(end of time)")
	}
}
Example #2
0
func run(bs []byte) (int, error) {
	// create a single core machine
	m := arch8.NewMachine(uint32(*memSize), 1)
	secs, err := e8.Read(bytes.NewReader(bs))
	if err != nil {
		return 0, err
	}

	if err := m.LoadSections(secs); err != nil {
		return 0, err
	}

	if *bootArg > math.MaxUint32 {
		log.Fatalf("boot arg(%d) is too large", *bootArg)
	}
	if err := m.WriteWord(arch8.AddrBootArg, uint32(*bootArg)); err != nil {
		return 0, err
	}

	if *romRoot != "" {
		m.MountROM(*romRoot)
	}
	if *randSeed != 0 {
		m.RandSeed(*randSeed)
	}

	ret, exp := m.Run(*ncycle)
	if *printStatus {
		m.PrintCoreStatus()
	}

	if !arch8.IsHalt(exp) {
		fmt.Println(exp)
		err := arch8.FprintStack(os.Stdout, m, exp)
		if err != nil {
			log.Fatal(err)
		}
	}

	if exp == nil {
		return ret, nil
	}
	return ret, exp
}
Example #3
0
File: main.go Project: Xslxy/e8vm
func run(bs []byte) (int, error) {
	// create a single core machine
	m := arch8.NewMachine(&arch8.Config{
		MemSize:  uint32(*memSize),
		RandSeed: *randSeed,
	})
	if err := m.LoadImageBytes(bs); err != nil {
		return 0, err
	}

	ret, exp := m.Run(*ncycle)
	if *printStatus {
		m.PrintCoreStatus()
	}

	if exp == nil {
		return ret, nil
	}
	return ret, exp
}
Example #4
0
File: main.go Project: Xslxy/e8vm
func run(bs []byte) (int, error) {
	if *bootArg > math.MaxUint32 {
		log.Fatalf("boot arg(%d) is too large", *bootArg)
	}

	// create a single core machine
	m := arch8.NewMachine(&arch8.Config{
		MemSize:  uint32(*memSize),
		ROM:      *romRoot,
		RandSeed: *randSeed,
		BootArg:  uint32(*bootArg),
	})

	secs, err := e8.Read(bytes.NewReader(bs))
	if err != nil {
		return 0, err
	}

	if err := m.LoadSections(secs); err != nil {
		return 0, err
	}

	ret, exp := m.Run(*ncycle)
	if *printStatus {
		m.PrintCoreStatus()
	}

	if !arch8.IsHalt(exp) {
		fmt.Println(exp)
		err := arch8.FprintStack(os.Stdout, m, exp)
		if err != nil {
			log.Fatal(err)
		}
	}

	if exp == nil {
		return ret, nil
	}
	return ret, exp
}
Example #5
0
File: tests.go Project: Xslxy/e8vm
func runTests(
	log lex8.Logger, tests map[string]uint32, img []byte, opt *Options,
) {
	logln := func(s string) {
		if opt.LogLine == nil {
			fmt.Println(s)
		} else {
			opt.LogLine(s)
		}
	}

	// TODO(h8liu): this reporting should go with JSON for better formatting.
	report := func(
		name string, ncycle int, pass bool,
		m *arch8.Machine, err error,
	) {
		if pass {
			if opt.Verbose {
				logln(fmt.Sprintf(
					"  - %s: passed (%s)", name, cycleStr(ncycle),
				))
			}
			return
		}

		if err == nil {
			err = errTimeOut
		}
		lex8.LogError(log, fmt.Errorf("%s failed: got %s", name, err))
		if opt.Verbose {
			logln(fmt.Sprintf(
				"  - %s: FAILED (%s, got %s)",
				name, cycleStr(ncycle), err,
			))
			// TODO(h8liu): this is too ugly here...
			excep, ok := err.(*arch8.CoreExcep)
			if !arch8.IsHalt(err) && ok {
				stackTrace := new(bytes.Buffer)
				arch8.FprintStack(stackTrace, m, excep)
				logln(stackTrace.String())
			}
		}
	}

	var testNames []string
	for name := range tests {
		testNames = append(testNames, name)
	}
	sort.Strings(testNames)

	for _, test := range testNames {
		arg := tests[test]
		m := arch8.NewMachine(&arch8.Config{
			BootArg: arg,
		})
		if err := m.LoadImageBytes(img); err != nil {
			report(test, 0, false, m, err)
			continue
		}

		var err error
		n, excep := m.Run(opt.TestCycles)
		if excep == nil {
			err = errTimeOut
		} else {
			err = excep
		}
		if strings.HasPrefix(test, "TestBad") {
			report(test, n, arch8.IsPanic(err), m, err)
		} else {
			report(test, n, arch8.IsHalt(err), m, err)
		}
	}
}