src/pkg/debug/proc/regs_linux_amd64.go

// Copyright 2009 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 proc

import (
	"os"
	"strconv"
	"syscall"
)

type amd64Regs struct {
	syscall.PtraceRegs
	setter func(*syscall.PtraceRegs) os.Error
}

var names = [...]string{
	"rax",
	"rbx",
	"rcx",
	"rdx",
	"rsi",
	"rdi",
	"rbp",
	"rsp",
	"r8",
	"r9",
	"r10",
	"r11",
	"r12",
	"r13",
	"r14",
	"r15",
	"rip",
	"eflags",
	"cs",
	"ss",
	"ds",
	"es",
	"fs",
	"gs",

	// PtraceRegs contains these registers, but I don't think
	// they're actually meaningful.
	//"orig_rax",
	//"fs_base",
	//"gs_base",
}

func (r *amd64Regs) PC() Word { return Word(r.Rip) }

func (r *amd64Regs) SetPC(val Word) os.Error {
	r.Rip = uint64(val)
	return r.setter(&r.PtraceRegs)
}

func (r *amd64Regs) Link() Word {
	// TODO(austin)
	panic("No link register")
}

func (r *amd64Regs) SetLink(val Word) os.Error {
	panic("No link register")
}

func (r *amd64Regs) SP() Word { return Word(r.Rsp) }

func (r *amd64Regs) SetSP(val Word) os.Error {
	r.Rsp = uint64(val)
	return r.setter(&r.PtraceRegs)
}

func (r *amd64Regs) Names() []string { return &names }

func (r *amd64Regs) Get(i int) Word {
	switch i {
	case 0:
		return Word(r.Rax)
	case 1:
		return Word(r.Rbx)
	case 2:
		return Word(r.Rcx)
	case 3:
		return Word(r.Rdx)
	case 4:
		return Word(r.Rsi)
	case 5:
		return Word(r.Rdi)
	case 6:
		return Word(r.Rbp)
	case 7:
		return Word(r.Rsp)
	case 8:
		return Word(r.R8)
	case 9:
		return Word(r.R9)
	case 10:
		return Word(r.R10)
	case 11:
		return Word(r.R11)
	case 12:
		return Word(r.R12)
	case 13:
		return Word(r.R13)
	case 14:
		return Word(r.R14)
	case 15:
		return Word(r.R15)
	case 16:
		return Word(r.Rip)
	case 17:
		return Word(r.Eflags)
	case 18:
		return Word(r.Cs)
	case 19:
		return Word(r.Ss)
	case 20:
		return Word(r.Ds)
	case 21:
		return Word(r.Es)
	case 22:
		return Word(r.Fs)
	case 23:
		return Word(r.Gs)
	}
	panic("invalid register index " + strconv.Itoa(i))
}

func (r *amd64Regs) Set(i int, val Word) os.Error {
	switch i {
	case 0:
		r.Rax = uint64(val)
	case 1:
		r.Rbx = uint64(val)
	case 2:
		r.Rcx = uint64(val)
	case 3:
		r.Rdx = uint64(val)
	case 4:
		r.Rsi = uint64(val)
	case 5:
		r.Rdi = uint64(val)
	case 6:
		r.Rbp = uint64(val)
	case 7:
		r.Rsp = uint64(val)
	case 8:
		r.R8 = uint64(val)
	case 9:
		r.R9 = uint64(val)
	case 10:
		r.R10 = uint64(val)
	case 11:
		r.R11 = uint64(val)
	case 12:
		r.R12 = uint64(val)
	case 13:
		r.R13 = uint64(val)
	case 14:
		r.R14 = uint64(val)
	case 15:
		r.R15 = uint64(val)
	case 16:
		r.Rip = uint64(val)
	case 17:
		r.Eflags = uint64(val)
	case 18:
		r.Cs = uint64(val)
	case 19:
		r.Ss = uint64(val)
	case 20:
		r.Ds = uint64(val)
	case 21:
		r.Es = uint64(val)
	case 22:
		r.Fs = uint64(val)
	case 23:
		r.Gs = uint64(val)
	default:
		panic("invalid register index " + strconv.Itoa(i))
	}
	return r.setter(&r.PtraceRegs)
}

func newRegs(regs *syscall.PtraceRegs, setter func(*syscall.PtraceRegs) os.Error) Regs {
	res := amd64Regs{}
	res.PtraceRegs = *regs
	res.setter = setter
	return &res
}