handlers

	// That means we have args in the usual places, and all is the same *save* that we will
	// implement a function, not shuffle data around.
	// We first need to see if it's a call that got us here.
	// So if the inst() fails, we'll need to look at (rsp) and get the inst from there.
	// For now, we're gonna hack it out. If the failing addr is in the range
	// of funcs we assume function call.
	/*	if addr >= StartFuncs && addr < EndFuncs {
			// Assume it's a call. We can switch on the addr. We're going to want to pop the
			// stack when done.
			op := addr & 0xffff
			log.Printf("functions: %v(%#x), arg type %T, args %v", table.RuntimeServicesNames[op], op, inst.Args, inst.Args)
			switch op {
			case table.STOutputString:
				args := args(p, &r, 6)
				log.Printf("StOutputString args %#x", args)
				r.Rax = EFI_SUCCESS
				if err := p.SetRegs(r); err != nil {
					return err
				}
				return nil
			default:
				log.Printf("conout op opcode %#x addr %v: unknonw opcode", op, addr)
				r.Rax = EFI_SUCCESS
				if err := p.SetRegs(r); err != nil {
					return err
				}
				return nil
			}
		}

		}*/

	log.Printf("Segv: addr %#x: %s", addr, showone("\t", r))
	if pc < 0x200000 {
		var err error
		// Just grab them all
		args := args(p, r, 6)
		l := fmt.Sprintf("%#x, %s[", addr, InfoString(i))
		for _, a := range inst.Args {
			l += fmt.Sprintf("%v,", a)
		}
		l += "]"
		op := addr & 0xfff
		// This is a mess: the eip is actually at the instruction
		// after the call. dammit. variable length instructions.
		// likely a 5 byte call but ... dammit.
		switch addr & ^uint64(0xffff) {
		case STOut:
			switch op {
			case table.STOutOutputString:
				log.Printf("StOutputString args %#x", args)
				ptr := args[1]
				// it's an f'ing struct. The first element is This. Skip it.
				str, err := p.ReadWord(uintptr(ptr + 8))
				if err != nil {
					return fmt.Errorf("STOutputString: Reading char * at %#x failed", ptr+8)
				}
				n, err := p.ReadStupidString(uintptr(str))
				if err != nil {
					err = fmt.Errorf("Can't read StupidString at #%x, err %v", str, err)
				}
				fmt.Printf("%s\n", n)
				r.Rax = EFI_SUCCESS
				if err := p.SetRegs(r); err != nil {
					return err
				}
			}
		default:
			err = fmt.Errorf("Can't handle dest %v", inst.Args[0])
		}
		// pop the stack, then set the EIP, then setregs.
		r.Rip, err = pop(p, r)
		if err != nil {
			return err
		}

		if err := p.SetRegs(r); err != nil {
			return err
		}
		return err
	}

	if (addr >= ImageHandle) && (addr <= ImageHandleEnd) {
		l := fmt.Sprintf("%#x, %s[", pc, InfoString(i))
		for _, a := range inst.Args {
			l += fmt.Sprintf("%s,", a.String())
		}
		l += "]"
		return fmt.Errorf("ImageHandle error, %v", l)
	}
	if (addr >= SystemTable) && (addr <= SystemTableEnd) {
		l := fmt.Sprintf("%#x, %s[", pc, InfoString(i))
		for _, a := range inst.Args {
			l += fmt.Sprintf("%v,", a)
		}
		l += "]"
		op := addr & 0xffff
		n, ok := table.SystemTableNames[op]
		if !ok {
			return fmt.Errorf("No system table entry for offset %#x: %s\n", op, l)
		}
		log.Printf("System table: %#x, %s", op, n.N)
		// code expects to return a value of a thing, or call that thing.
		// So consistent.
		switch inst.Args[0] {
		case x86asm.RCX:
			r.Rcx = n.Val
			r.Rip += uint64(inst.Len)
			if err := p.SetRegs(r); err != nil {
				return err
			}
			return nil
		case x86asm.RDX:
			r.Rdx = n.Val
			r.Rip += uint64(inst.Len)
			if err := p.SetRegs(r); err != nil {
				return err
			}
			return nil
		case x86asm.RAX:
			r.Rax = n.Val
			r.Rip += uint64(inst.Len)
			if err := p.SetRegs(r); err != nil {
				return err
			}
			return nil
		case x86asm.R8:
			r.R8 = n.Val
			r.Rip += uint64(inst.Len)
			if err := p.SetRegs(r); err != nil {
				return err
			}
			return nil
		default:
			return fmt.Errorf("Can't handle dest %v", inst.Args[0])
		}
	}
	if (addr >= LoadedImage) && (addr <= LoadedImage+0x10000) {
		l := fmt.Sprintf("%#x, %s[", pc, InfoString(i))
		for _, a := range inst.Args {
			l += fmt.Sprintf("%v,", a)
		}
		l += "]"
		op := addr & 0xffff
		n, ok := table.LoadedImageTableNames[op]
		if !ok {
			return fmt.Errorf("No loaded image entry for offset %#x: %s\n", op, l)
		}
		log.Printf("loaded image table: %#x, %s", op, n.N)
		switch inst.Args[0] {
		case x86asm.EDX:
			r.Rdx = n.Val
			r.Rip += uint64(inst.Len)
			if err := p.SetRegs(r); err != nil {
				return err
			}
			return nil
		case x86asm.RDX:
			r.Rdx = n.Val
			r.Rip += uint64(inst.Len)
			if err := p.SetRegs(r); err != nil {
				return err
			}
			return nil
		case x86asm.RCX:
			r.Rcx = n.Val
			r.Rip += uint64(inst.Len)
			if err := p.SetRegs(r); err != nil {
				return err
			}
			return nil
		case x86asm.RAX:
			r.Rax = n.Val
			r.Rip += uint64(inst.Len)
			if err := p.SetRegs(r); err != nil {
				return err
			}
			return nil
		default:
			return fmt.Errorf("Can't handle dest %v", inst.Args[0])
		}
	}
	if (addr >= Boot) && (addr <= Boot+0x10000) {
		// No matter what happpens, move to the next one.
		r.Rip += uint64(inst.Len)
		if err := p.SetRegs(r); err != nil {
			return err
		}
		op := addr & 0xffff
		log.Printf("Boot services: %s(%#x), arg type %T, args %v", bootServicesNames[int(op)], op, inst.Args, inst.Args)
		switch op {
		case AllocatePool:
			// Status = gBS->AllocatePool (EfiBootServicesData, sizeof (EXAMPLE_DEVICE), (VOID **)&Device);
			args := args(p, r, 3)
			// ignore arg 0 for now.
			log.Printf("AllocatePool: %d bytes", args[1])
			var bb [8]byte
			binary.LittleEndian.PutUint64(bb[:], uint64(dat))
			if err := p.Write(args[2], bb[:]); err != nil {
				return fmt.Errorf("Can't write %d bytes to %#x: %v", len(bb), dat, err)
			}
			dat += args[1]
			return nil
		case FreePool:
			// Status = gBS->FreePool (Device);
			args := args(p, r, 1)
			// Free? Forget it.
			log.Printf("FreePool: %#x", args[0])
			return nil
		case LocateHandle:
			// EFI_STATUS LocateHandle (IN EFI_LOCATE_SEARCH_TYPE SearchType, IN EFI_GUID *Protocol OPTIONAL, IN VOID *SearchKey OPTIONAL,IN OUT UINTN *NoHandles,  OUT EFI_HANDLE **Buffer);
			args := args(p, r, 5)
			no := args[3]
			var bb [8]byte
			// just fail.
			if err := p.Write(no, bb[:]); err != nil {
				return fmt.Errorf("Can't write %d bytes to %#x: %v", len(bb), dat, err)
			}
			return nil
		case HandleProtocol:
			// There. All on one line. Not 7. So, UEFI, did that really hurt so much?
			// typedef EFI_STATUS (EFIAPI *EFI_HANDLE_PROTOCOL) (IN EFI_HANDLE Handle, IN EFI_GUID *Protocol, OUT VOID **Interface);

			// The arguments are rcx, rdx, r9
			args := args(p, r, 3)
			var g guid.GUID
			if err := p.Read(args[1], g[:]); err != nil {
				return fmt.Errorf("Can't read guid at #%x, err %v", args[1], err)
			}
			log.Printf("HandleProtocol: GUID %s", g)
			if err := Srv(p, &g, args...); err != nil {
				return fmt.Errorf("Can't handle HandleProtocol: %s: %v", callinfo(i, inst, r), err)
			}
			return nil
		case PCHandleProtocol:
			// There. All on one line. Not 7. So, UEFI, did that really hurt so much?
			// typedef EFI_STATUS (EFIAPI *EFI_HANDLE_PROTOCOL) (IN EFI_HANDLE Handle, IN EFI_GUID *Protocol, OUT VOID **Interface);

			// The arguments are rcx, rdx, r9
			args := args(p, r, 3)
			var g guid.GUID
			if err := p.Read(args[1], g[:]); err != nil {
				return fmt.Errorf("Can't read guid at #%x, err %v", args[1], err)
			}
			log.Printf("PCHandleProtocol: GUID %s", g)
			if err := Srv(p, &g, args...); err != nil {
				return fmt.Errorf("Can't handle HandleProtocol: %s: %v", callinfo(i, inst, r), err)
			}
			return nil
		case ConnectController:
			// The arguments are rcx, rdx, r9, r8
			args := args(p, r, 4)
			log.Printf("ConnectController: %#x", args)
			// Just pretend it worked.
			return nil
		case WaitForEvent:
			args := args(p, r, 3)
			log.Printf("WaitForEvent: %#x", args)
			// Just pretend it worked.
			return nil
		case 0xfffe:
			arg0, err := GetReg(r, x86asm.RDX)
			if err != nil {
				return fmt.Errorf("Can't get RDX: %v", err)
			}
			any("go get it")
			// idiot UEFI and idiot wchar_t
			arg := uintptr(*arg0)
			for {
				var dat [2]byte
				if err := p.Read(arg, dat[:]); err != nil {
					return fmt.Errorf("Can't read data at #%x, err %v", addr, err)
				}
				if dat[0] == 0 && dat[1] == 0 {
					break
				}
				fmt.Printf("%#02x %c,", dat, dat[0])
				arg++
			}
			// This code is right for getting an arbitrary Mem out.
			// It's wrong for 0xf8, whoops. Leave it here
			// for reference.
		case 0xffff:
			m := inst.Args[0].(x86asm.Mem)
			// A Mem is a memory reference.
			// The general form is Segment:[Base+Scale*Index+Disp].
			/*
				type Mem struct {
					Segment Reg
					Base    Reg
					Scale   uint8
					Index   Reg
					Disp    int64
				}
			*/
			log.Printf("ARG[0] %q m is %#x", inst.Args[0], m)
			b, err := GetReg(r, m.Base)
			if err != nil {
				any("FUCKED BASE")
				return fmt.Errorf("Can't get Base reg %v in %v", m.Base, m)
			}
			addr := *b + uint64(m.Disp)
			x, err := GetReg(r, m.Index)
			if err == nil {
				addr += uint64(m.Scale) * (*x)
			}
			//if v, ok := inst.Args[0].(*x86asm.Mem); ok {
			log.Printf("computed addr is %#x", addr)
			any("go get it")
			var dat [16]byte
			if err := p.Read(uintptr(addr), dat[:]); err != nil {
				return fmt.Errorf("Can't read data at #%x, err %v", addr, err)
			}
			log.Printf("dat at %#x is %#x", addr, dat)

			//return nil
			//}
			//return fmt.Errorf("Wrong type of 0xf8? %T but should be %T", inst.Args[0], x86asm.Mem)
			return nil
		default:
			return fmt.Errorf("opcode %#x addr %v: unknonw opcode", op, addr)
		}
	}
	if (addr >= Runtime) && (addr <= Runtime+0x10000) {
		// No matter what happpens, move to the next one.
		r.Rip += uint64(inst.Len)
		if err := p.SetRegs(r); err != nil {
			return err
		}
		op := addr & 0xffff
		log.Printf("Runtime services: %v(%#x), arg type %T, args %v", table.RuntimeServicesNames[op], op, inst.Args, inst.Args)
		switch op {
		case table.RTGetVariable:
			args := args(p, r, 5)
			log.Printf("table.RTGetVariable args %#x", args)
			ptr := args[0]
			n, err := p.ReadStupidString(ptr)
			if err != nil {
				return fmt.Errorf("Can't read StupidString at #%x, err %v", ptr, err)
			}
			var g guid.GUID
			if err := p.Read(args[1], g[:]); err != nil {
				return fmt.Errorf("Can't read guid at #%x, err %v", args[1], err)
			}
			log.Printf("PCHandleProtocol: find %s %s", n, g)
			v, err := ReadVariable(n, g)
			if err != nil {
				r.Rax = EFI_NOT_FOUND
				if err := p.SetRegs(r); err != nil {
					return err
				}
			}
			log.Printf("%s:%s: v is %v", n, g, v)
			r.Rax = EFI_SUCCESS
			return nil
		default:
			return fmt.Errorf("opcode %#x addr %v: unknonw opcode", op, addr)
		}
	}
	// ConOut points to a simple text output interface. We got here from the
	// System Table.
	// We got here because         table.SystemTableNames[table.ConOut].Val = ConOut
	if (addr >= ConOut) && (addr <= ConOut+0x10000) {
		l := fmt.Sprintf("%#x, %s[", pc, InfoString(i))
		for _, a := range inst.Args {
			l += fmt.Sprintf("%v,", a)
		}
		l += "]"
		op := addr & 0xfff
		// pretend it's a deref
		var n uint64
		// This should then point to a function, which we will call.
		if op <= table.STOutMode {
			n = STOut + op
		}

		log.Printf("ConOut table: %#x, %#x", op, n)
		// code expects to return a value of a thing, or call that thing.
		// So consistent.
		switch inst.Args[0] {
		case x86asm.RCX:
			r.Rcx = n
			r.Rip += uint64(inst.Len)
			if err := p.SetRegs(r); err != nil {
				return err
			}
			return nil
		case x86asm.RAX:
			r.Rax = n
			r.Rip += uint64(inst.Len)
			if err := p.SetRegs(r); err != nil {
				return err
			}
			return nil
		case x86asm.R8:
			r.R8 = n
			r.Rip += uint64(inst.Len)
			if err := p.SetRegs(r); err != nil {
				return err
			}
			return nil
		default:
			return fmt.Errorf("ConOut Can't handle dest %v", inst.Args[0])
		}
	}
	if (addr >= ConIn) && (addr <= ConIn+0x10000) {
		l := fmt.Sprintf("%#x, %s[", pc, InfoString(i))
		for _, a := range inst.Args {
			l += fmt.Sprintf("%v,", a)
		}
		l += "]"
		op := addr & 0xfff
		// pretend it's a deref
		var n uint64
		log.Printf("ConIn table: %#x, %#x", op, n)
		n = STIn + op
		// code expects to return a value of a thing, or call that thing.
		// So consistent.
		switch inst.Args[0] {
		case x86asm.RCX:
			r.Rcx = n
			r.Rip += uint64(inst.Len)
			if err := p.SetRegs(r); err != nil {
				return err
			}
			return nil
		case x86asm.RAX:
			r.Rax = n
			r.Rip += uint64(inst.Len)
			if err := p.SetRegs(r); err != nil {
				return err
			}
			return nil
		case x86asm.R8:
			r.R8 = n
			r.Rip += uint64(inst.Len)
			if err := p.SetRegs(r); err != nil {
				return err
			}
			return nil
		default:
			return fmt.Errorf("ConOut Can't handle dest %v", inst.Args[0])
		}
	}
	// like i give a shit about their stupid console
	// This is setting variables 'n shit. Not functions.
	if (addr >= STOut+table.STOutMode) && (addr < STOut+table.STOutMode+0x1000) {
		l := fmt.Sprintf("%#x, %s[", pc, InfoString(i))
		for _, a := range inst.Args {
			l += fmt.Sprintf("%v,", a)
		}
		l += "]"
		// code expects to return a value of a thing, or call that thing.
		// So consistent.
		switch inst.Args[0] {
		case x86asm.RCX:
			r.Rcx = 0
			r.Rip += uint64(inst.Len)
			if err := p.SetRegs(r); err != nil {
				return err
			}
			return nil
		case x86asm.RDX:
			r.Rdx = 0
			r.Rip += uint64(inst.Len)
			if err := p.SetRegs(r); err != nil {
				return err
			}
			return nil
		case x86asm.RAX:
			r.Rax = 0
			r.Rip += uint64(inst.Len)
			if err := p.SetRegs(r); err != nil {
				return err
			}
			return nil
		case x86asm.R8:
			r.R8 = 0
			r.Rip += uint64(inst.Len)
			if err := p.SetRegs(r); err != nil {
				return err
			}
			return nil
		default:
			return fmt.Errorf("ConOut Can't handle dest %v", inst.Args[0])
		}
	}






	case protocol.LoadedImageProtocol:
		if len(args) < 3 {
			return fmt.Errorf("protocol.LoadedImageProtocol needs 3 args, got %d", len(args))
		}
		// For now, we're not putting this out there.
		// We will handle access via segv.
		odat := dat
		if false {
			i, err := protocol.NewLoadedImage()
			if err != nil {
				return err
			}

			b, err := i.Marshal()
			if err != nil {
				return fmt.Errorf("Can't serialize %T: %v", i, err)
			}
			if err := p.Write(dat, b); err != nil {
				return fmt.Errorf("Can't write %d bytes to %#x: %v", len(b), dat, err)
			}
			dat += uintptr(len(b))
			// Store the return pointer through arg3.
		}
		var bb [8]byte
		binary.LittleEndian.PutUint64(bb[:], uint64(LoadedImage))
		if err := p.Write(args[2], bb[:]); err != nil {
			return fmt.Errorf("Can't write %d bytes to %#x: %v", len(bb), odat, err)
		}
		return nil