use super::capabilities::{CapabilitySet, CapabilityTarget};
use super::ids::{
AddressSpaceId, ArtifactId, BreakpointId, CaptureId, ContextId, OperationId, ProviderId,
SessionId,
};
use super::model::{
AddressSpaceDescriptor, ArtifactDescriptor, CaptureBoundaryKind, CaptureManifest,
ContextSelector, DebugAddress, DebugExecutionState, DecodedArtifact, DisassemblyLine,
ExecutionContextDescriptor, InspectionProviderDescriptor, MemoryReadResult, OperationStatus,
RegisterSnapshot, StackPreview,
};
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum BreakpointKind {
ProgramCounter,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub struct BreakpointSpec {
pub kind: BreakpointKind,
pub address: DebugAddress,
pub context: Option<ContextId>,
pub enabled: bool,
pub one_shot: bool,
}
impl BreakpointSpec {
pub fn program_counter(address: u64) -> Self {
Self {
kind: BreakpointKind::ProgramCounter,
address: DebugAddress::new(AddressSpaceId::UNSPECIFIED, address),
context: None,
enabled: true,
one_shot: false,
}
}
pub fn program_counter_at(address: DebugAddress) -> Self {
Self {
kind: BreakpointKind::ProgramCounter,
address,
context: None,
enabled: true,
one_shot: false,
}
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub struct BreakpointInfo {
pub id: BreakpointId,
pub spec: BreakpointSpec,
pub hit_count: u64,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum CaptureMode {
CurrentState,
NextBoundary,
PauseAtBoundary,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub struct CaptureRequest {
pub mode: CaptureMode,
pub boundary: Option<CaptureBoundaryKind>,
pub providers: Vec<ProviderId>,
pub include_artifacts: bool,
}
impl Default for CaptureRequest {
fn default() -> Self {
Self {
mode: CaptureMode::CurrentState,
boundary: None,
providers: Vec::new(),
include_artifacts: true,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(tag = "op", rename_all = "snake_case")]
pub enum DebugRequest {
SessionInfo,
InSession {
session: SessionId,
generation: u64,
request: Box<DebugRequest>,
},
ReadProvider {
id: ProviderId,
},
ReadCaptureProvider {
capture: CaptureId,
provider: ProviderId,
},
ListContexts,
ListAddressSpaces {
context: ContextSelector,
},
ListProviders,
GetCapabilities {
target: CapabilityTarget,
},
ExecutionStatus,
Notifications {
after: u64,
},
Pause,
Resume,
Step {
context: ContextSelector,
},
ReadRegisters {
context: ContextSelector,
registers: Option<Vec<u32>>,
},
ReadMemory {
space: AddressSpaceId,
address: u64,
length: u64,
},
Disassemble {
context: ContextSelector,
address: DebugAddress,
count: u32,
},
StackPreview {
context: ContextSelector,
words: u32,
},
ListBreakpoints,
SetBreakpoint {
spec: BreakpointSpec,
},
RemoveBreakpoint {
id: BreakpointId,
},
SetBreakpointEnabled {
id: BreakpointId,
enabled: bool,
},
ListCaptures,
RequestCapture {
request: CaptureRequest,
},
CancelCapture {
operation: OperationId,
},
GetCapture {
id: CaptureId,
},
ReleaseCapture {
id: CaptureId,
},
GetOperation {
id: OperationId,
},
GetArtifact {
id: ArtifactId,
},
DecodeArtifact {
id: ArtifactId,
},
ResolveSymbol {
context: ContextSelector,
address: DebugAddress,
window: Option<u64>,
},
LookupSymbol {
context: ContextSelector,
name: String,
},
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub struct SessionInfo {
pub session: SessionId,
pub generation: u64,
pub active_context: Option<ContextId>,
pub terminal: bool,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub struct ExecutionStatusReply {
pub state: DebugExecutionState,
pub terminal: bool,
pub active_context: Option<ContextId>,
pub guest_tick: Option<u32>,
pub execution_units: Option<u64>,
pub revision: u64,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(tag = "reply", content = "value", rename_all = "snake_case")]
pub enum DebugReply {
SessionInfo(SessionInfo),
Contexts(Vec<ExecutionContextDescriptor>),
AddressSpaces(Vec<AddressSpaceDescriptor>),
Providers(Vec<InspectionProviderDescriptor>),
ProviderSnapshot(super::provider::ProviderSnapshot),
Capabilities(CapabilitySet),
ExecutionStatus(ExecutionStatusReply),
Notifications(Vec<super::model::DebugNotification>),
Accepted {
state: DebugExecutionState,
operation_id: Option<OperationId>,
},
Registers {
context: ContextId,
registers: Vec<RegisterSnapshot>,
},
Memory(MemoryReadResult),
Disassembly {
context: ContextId,
lines: Vec<DisassemblyLine>,
},
Stack(StackPreview),
Breakpoints(Vec<BreakpointInfo>),
Breakpoint(BreakpointInfo),
BreakpointRemoved {
id: BreakpointId,
},
Captures(Vec<CaptureManifest>),
Capture(CaptureManifest),
CaptureReleased {
id: CaptureId,
},
ArtifactData {
descriptor: ArtifactDescriptor,
bytes: Vec<u8>,
},
Operation(OperationStatus),
Artifact(ArtifactDescriptor),
Decoded(DecodedArtifact),
Symbol(super::symbols::SymbolResolution),
Symbols(Vec<super::symbols::SymbolEntry>),
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn sequence_replies_serialize_through_transports() {
for (reply, tag) in [
(DebugReply::Contexts(Vec::new()), "contexts"),
(DebugReply::Providers(Vec::new()), "providers"),
(DebugReply::Captures(Vec::new()), "captures"),
(DebugReply::Breakpoints(Vec::new()), "breakpoints"),
] {
let json = serde_json::to_value(&reply).expect("sequence reply serializes");
assert_eq!(
json.get("reply").and_then(|value| value.as_str()),
Some(tag)
);
assert!(json.get("value").is_some_and(|value| value.is_array()));
}
}
}