add Registers::pc method

If #29 is ever resolved, a similar method could be added to `RegId`,
enabling more efficient `pc` queries. Note that the less efficient
approach would still need to be supported, as the ability to query
individual registers is not a required feature implemented by all
targets.

src/arch/arm/reg/arm_core.rs

@@ -18,6 +18,12 @@ pub struct ArmCoreRegs {
 }
 
 impl Registers for ArmCoreRegs {
+    type ProgramCounter = u32;
+
+    fn pc(&self) -> Self::ProgramCounter {
+        self.pc
+    }
+
     fn gdb_serialize(&self, mut write_byte: impl FnMut(Option<u8>)) {
         macro_rules! write_bytes {
             ($bytes:expr) => {

src/arch/mips/mod.rs

@@ -87,6 +87,7 @@ impl Arch for MipsWithDsp {
     type Usize = u32;
     type Registers = reg::MipsCoreRegsWithDsp<u32>;
     type RegId = reg::id::MipsRegId<u32>;
+    type BreakpointKind = MipsBreakpointKind;
 
     fn target_description_xml() -> Option<&'static str> {
         Some(
@@ -99,6 +100,7 @@ impl Arch for Mips64WithDsp {
     type Usize = u64;
     type Registers = reg::MipsCoreRegsWithDsp<u64>;
     type RegId = reg::id::MipsRegId<u64>;
+    type BreakpointKind = MipsBreakpointKind;
 
     fn target_description_xml() -> Option<&'static str> {
         Some(

src/arch/mips/reg/mips.rs

@@ -92,6 +92,12 @@ impl<U> Registers for MipsCoreRegs<U>
 where
     U: PrimInt + LeBytes + Default + core::fmt::Debug,
 {
+    type ProgramCounter = U;
+
+    fn pc(&self) -> Self::ProgramCounter {
+        self.pc
+    }
+
     fn gdb_serialize(&self, mut write_byte: impl FnMut(Option<u8>)) {
         macro_rules! write_le_bytes {
             ($value:expr) => {
@@ -183,6 +189,12 @@ impl<U> Registers for MipsCoreRegsWithDsp<U>
 where
     U: PrimInt + LeBytes + Default + core::fmt::Debug,
 {
+    type ProgramCounter = U;
+
+    fn pc(&self) -> Self::ProgramCounter {
+        self.core.pc
+    }
+
     fn gdb_serialize(&self, mut write_byte: impl FnMut(Option<u8>)) {
         macro_rules! write_le_bytes {
             ($value:expr) => {

src/arch/msp430/mod.rs

@@ -15,7 +15,7 @@ pub enum Msp430<RegIdImpl: RegId = reg::id::Msp430RegId> {
 }
 
 impl<RegIdImpl: RegId> Arch for Msp430<RegIdImpl> {
-    type Usize = u32;
+    type Usize = u16;
     type Registers = reg::Msp430Regs;
     type RegId = RegIdImpl;
     type BreakpointKind = usize;

src/arch/msp430/reg/msp430.rs

@@ -14,6 +14,12 @@ pub struct Msp430Regs {
 }
 
 impl Registers for Msp430Regs {
+    type ProgramCounter = u16;
+
+    fn pc(&self) -> Self::ProgramCounter {
+        self.pc
+    }
+
     fn gdb_serialize(&self, mut write_byte: impl FnMut(Option<u8>)) {
         macro_rules! write_bytes {
             ($bytes:expr) => {

src/arch/ppc/reg/common.rs

@@ -39,6 +39,12 @@ pub struct PowerPcCommonRegs {
 }
 
 impl Registers for PowerPcCommonRegs {
+    type ProgramCounter = u32;
+
+    fn pc(&self) -> Self::ProgramCounter {
+        self.pc
+    }
+
     fn gdb_serialize(&self, mut write_byte: impl FnMut(Option<u8>)) {
         macro_rules! write_bytes {
             ($bytes:expr) => {

src/arch/riscv/reg/riscv.rs

@@ -22,6 +22,12 @@ impl<U> Registers for RiscvCoreRegs<U>
 where
     U: PrimInt + LeBytes + Default + core::fmt::Debug,
 {
+    type ProgramCounter = U;
+
+    fn pc(&self) -> Self::ProgramCounter {
+        self.pc
+    }
+
     fn gdb_serialize(&self, mut write_byte: impl FnMut(Option<u8>)) {
         macro_rules! write_le_bytes {
             ($value:expr) => {

src/arch/traits.rs

@@ -30,6 +30,13 @@ impl RegId for () {
 /// github.com/bminor/binutils-gdb/blob/master/gdb/features/arm/arm-core.xml
 // TODO: add way to de/serialize arbitrary "missing"/"uncollected" registers.
 pub trait Registers: Default + Debug + Clone + PartialEq {
+    /// The type of the architecture's program counter / instruction pointer.
+    /// Must match with the corresponding `Arch::Usize`.
+    type ProgramCounter: Copy;
+
+    /// Return the value of the program counter / instruction pointer.
+    fn pc(&self) -> Self::ProgramCounter;
+
     /// Serialize `self` into a GDB register bytestream.
     ///
     /// Missing registers are serialized by passing `None` to write_byte.
@@ -88,7 +95,7 @@ pub trait Arch {
     type Usize: PrimInt + Unsigned + BeBytes + LeBytes;
 
     /// The architecture's register file.
-    type Registers: Registers;
+    type Registers: Registers<ProgramCounter = Self::Usize>;
 
     /// The architecture's breakpoint kind, used to determine the "size"
     /// of breakpoint to set. See [`BreakpointKind`] for more details.

src/arch/x86/reg/core32.rs

@@ -42,6 +42,12 @@ pub struct X86CoreRegs {
 }
 
 impl Registers for X86CoreRegs {
+    type ProgramCounter = u32;
+
+    fn pc(&self) -> Self::ProgramCounter {
+        self.eip
+    }
+
     fn gdb_serialize(&self, mut write_byte: impl FnMut(Option<u8>)) {
         macro_rules! write_bytes {
             ($bytes:expr) => {

src/arch/x86/reg/core64.rs

@@ -28,6 +28,12 @@ pub struct X86_64CoreRegs {
 }
 
 impl Registers for X86_64CoreRegs {
+    type ProgramCounter = u64;
+
+    fn pc(&self) -> Self::ProgramCounter {
+        self.rip
+    }
+
     fn gdb_serialize(&self, mut write_byte: impl FnMut(Option<u8>)) {
         macro_rules! write_bytes {
             ($bytes:expr) => {

src/arch/x86/reg/mod.rs

@@ -38,6 +38,14 @@ pub struct X87FpuInternalRegs {
 }
 
 impl Registers for X87FpuInternalRegs {
+    type ProgramCounter = u32;
+
+    // HACK: this struct is never used as an architecture's main register file, so
+    // using a dummy value here is fine.
+    fn pc(&self) -> Self::ProgramCounter {
+        0
+    }
+
     fn gdb_serialize(&self, mut write_byte: impl FnMut(Option<u8>)) {
         macro_rules! write_bytes {
             ($bytes:expr) => {