StopInfoSP
StopInfoMachException::CreateStopReasonWithMachException
(
Thread &thread,
uint32_t exc_type,
uint32_t exc_data_count,
uint64_t exc_code,
uint64_t exc_sub_code,
uint64_t exc_sub_sub_code,
bool pc_already_adjusted,
bool adjust_pc_if_needed
)
{
if (exc_type != 0)
{
uint32_t pc_decrement = 0;
ExecutionContext exe_ctx (thread.shared_from_this());
Target *target = exe_ctx.GetTargetPtr();
const llvm::Triple::ArchType cpu = target ? target->GetArchitecture().GetMachine() : llvm::Triple::UnknownArch;
switch (exc_type)
{
case 1: // EXC_BAD_ACCESS
break;
case 2: // EXC_BAD_INSTRUCTION
switch (cpu)
{
case llvm::Triple::ppc:
case llvm::Triple::ppc64:
switch (exc_code)
{
case 1: // EXC_PPC_INVALID_SYSCALL
case 2: // EXC_PPC_UNIPL_INST
case 3: // EXC_PPC_PRIVINST
case 4: // EXC_PPC_PRIVREG
break;
case 5: // EXC_PPC_TRACE
return StopInfo::CreateStopReasonToTrace (thread);
case 6: // EXC_PPC_PERFMON
break;
}
break;
default:
break;
}
break;
case 3: // EXC_ARITHMETIC
case 4: // EXC_EMULATION
break;
case 5: // EXC_SOFTWARE
if (exc_code == 0x10003) // EXC_SOFT_SIGNAL
return StopInfo::CreateStopReasonWithSignal (thread, exc_sub_code);
break;
case 6: // EXC_BREAKPOINT
{
bool is_software_breakpoint = false;
bool is_trace_if_software_breakpoint_missing = false;
switch (cpu)
{
case llvm::Triple::x86:
case llvm::Triple::x86_64:
if (exc_code == 1) // EXC_I386_SGL
{
if (!exc_sub_code)
return StopInfo::CreateStopReasonToTrace(thread);
// It's a watchpoint, then.
// The exc_sub_code indicates the data break address.
lldb::WatchpointSP wp_sp;
if (target)
wp_sp = target->GetWatchpointList().FindByAddress((lldb::addr_t)exc_sub_code);
if (wp_sp && wp_sp->IsEnabled())
{
// Debugserver may piggyback the hardware index of the fired watchpoint in the exception data.
// Set the hardware index if that's the case.
if (exc_data_count >=3)
wp_sp->SetHardwareIndex((uint32_t)exc_sub_sub_code);
return StopInfo::CreateStopReasonWithWatchpointID(thread, wp_sp->GetID());
}
}
else if (exc_code == 2 || // EXC_I386_BPT
exc_code == 3) // EXC_I386_BPTFLT
{
// KDP returns EXC_I386_BPTFLT for trace breakpoints
if (exc_code == 3)
is_trace_if_software_breakpoint_missing = true;
is_software_breakpoint = true;
if (!pc_already_adjusted)
pc_decrement = 1;
}
break;
case llvm::Triple::ppc:
case llvm::Triple::ppc64:
is_software_breakpoint = exc_code == 1; // EXC_PPC_BREAKPOINT
break;
case llvm::Triple::arm:
if (exc_code == 0x102)
{
// It's a watchpoint, then, if the exc_sub_code indicates a known/enabled
// data break address from our watchpoint list.
lldb::WatchpointSP wp_sp;
if (target)
wp_sp = target->GetWatchpointList().FindByAddress((lldb::addr_t)exc_sub_code);
if (wp_sp && wp_sp->IsEnabled())
{
// Debugserver may piggyback the hardware index of the fired watchpoint in the exception data.
// Set the hardware index if that's the case.
if (exc_data_count >=3)
wp_sp->SetHardwareIndex((uint32_t)exc_sub_sub_code);
return StopInfo::CreateStopReasonWithWatchpointID(thread, wp_sp->GetID());
}
// EXC_ARM_DA_DEBUG seems to be reused for EXC_BREAKPOINT as well as EXC_BAD_ACCESS
if (thread.GetTemporaryResumeState() == eStateStepping)
return StopInfo::CreateStopReasonToTrace(thread);
}
else if (exc_code == 1)
{
is_software_breakpoint = true;
is_trace_if_software_breakpoint_missing = true;
}
break;
default:
break;
}
if (is_software_breakpoint)
{
RegisterContextSP reg_ctx_sp (thread.GetRegisterContext());
addr_t pc = reg_ctx_sp->GetPC() - pc_decrement;
ProcessSP process_sp (thread.CalculateProcess());
lldb::BreakpointSiteSP bp_site_sp;
if (process_sp)
bp_site_sp = process_sp->GetBreakpointSiteList().FindByAddress(pc);
if (bp_site_sp && bp_site_sp->IsEnabled())
{
// Update the PC if we were asked to do so, but only do
// so if we find a breakpoint that we know about cause
// this could be a trap instruction in the code
if (pc_decrement > 0 && adjust_pc_if_needed)
reg_ctx_sp->SetPC (pc);
// If the breakpoint is for this thread, then we'll report the hit, but if it is for another thread,
// we can just report no reason. We don't need to worry about stepping over the breakpoint here, that
// will be taken care of when the thread resumes and notices that there's a breakpoint under the pc.
if (bp_site_sp->ValidForThisThread (&thread))
return StopInfo::CreateStopReasonWithBreakpointSiteID (thread, bp_site_sp->GetID());
else
return StopInfoSP();
}
// Don't call this a trace if we weren't single stepping this thread.
if (is_trace_if_software_breakpoint_missing && thread.GetTemporaryResumeState() == eStateStepping)
{
return StopInfo::CreateStopReasonToTrace (thread);
}
}
}
break;
case 7: // EXC_SYSCALL
case 8: // EXC_MACH_SYSCALL
case 9: // EXC_RPC_ALERT
case 10: // EXC_CRASH
break;
}
return StopInfoSP(new StopInfoMachException (thread, exc_type, exc_data_count, exc_code, exc_sub_code));
}
return StopInfoSP();
}
StopInfoSP
StopInfoMachException::CreateStopReasonWithMachException
(
Thread &thread,
uint32_t exc_type,
uint32_t exc_data_count,
uint64_t exc_code,
uint64_t exc_sub_code,
uint64_t exc_sub_sub_code,
bool pc_already_adjusted,
bool adjust_pc_if_needed
)
{
if (exc_type != 0)
{
uint32_t pc_decrement = 0;
ExecutionContext exe_ctx (thread.shared_from_this());
Target *target = exe_ctx.GetTargetPtr();
const llvm::Triple::ArchType cpu = target ? target->GetArchitecture().GetMachine() : llvm::Triple::UnknownArch;
switch (exc_type)
{
case 1: // EXC_BAD_ACCESS
break;
case 2: // EXC_BAD_INSTRUCTION
switch (cpu)
{
case llvm::Triple::ppc:
case llvm::Triple::ppc64:
switch (exc_code)
{
case 1: // EXC_PPC_INVALID_SYSCALL
case 2: // EXC_PPC_UNIPL_INST
case 3: // EXC_PPC_PRIVINST
case 4: // EXC_PPC_PRIVREG
break;
case 5: // EXC_PPC_TRACE
return StopInfo::CreateStopReasonToTrace (thread);
case 6: // EXC_PPC_PERFMON
break;
}
break;
default:
break;
}
break;
case 3: // EXC_ARITHMETIC
case 4: // EXC_EMULATION
break;
case 5: // EXC_SOFTWARE
if (exc_code == 0x10003) // EXC_SOFT_SIGNAL
{
if (exc_sub_code == 5)
{
// On MacOSX, a SIGTRAP can signify that a process has called
// exec, so we should check with our dynamic loader to verify.
ProcessSP process_sp (thread.GetProcess());
if (process_sp)
{
DynamicLoader *dynamic_loader = process_sp->GetDynamicLoader();
if (dynamic_loader && dynamic_loader->ProcessDidExec())
{
// The program was re-exec'ed
return StopInfo::CreateStopReasonWithExec (thread);
}
// if (!process_did_exec)
// {
// // We have a SIGTRAP, make sure we didn't exec by checking
// // for the PC being at "_dyld_start"...
// lldb::StackFrameSP frame_sp (thread.GetStackFrameAtIndex(0));
// if (frame_sp)
// {
// const Symbol *symbol = frame_sp->GetSymbolContext(eSymbolContextSymbol).symbol;
// if (symbol)
// {
// if (symbol->GetName() == ConstString("_dyld_start"))
// process_did_exec = true;
// }
// }
// }
}
}
return StopInfo::CreateStopReasonWithSignal (thread, exc_sub_code);
}
break;
case 6: // EXC_BREAKPOINT
{
bool is_actual_breakpoint = false;
bool is_trace_if_actual_breakpoint_missing = false;
switch (cpu)
{
case llvm::Triple::x86:
case llvm::Triple::x86_64:
if (exc_code == 1) // EXC_I386_SGL
{
if (!exc_sub_code)
{
// This looks like a plain trap.
// Have to check if there is a breakpoint here as well. When you single-step onto a trap,
// the single step stops you not to trap. Since we also do that check below, let's just use
// that logic.
is_actual_breakpoint = true;
is_trace_if_actual_breakpoint_missing = true;
}
else
{
// It's a watchpoint, then.
// The exc_sub_code indicates the data break address.
lldb::WatchpointSP wp_sp;
if (target)
wp_sp = target->GetWatchpointList().FindByAddress((lldb::addr_t)exc_sub_code);
if (wp_sp && wp_sp->IsEnabled())
{
// Debugserver may piggyback the hardware index of the fired watchpoint in the exception data.
// Set the hardware index if that's the case.
if (exc_data_count >=3)
wp_sp->SetHardwareIndex((uint32_t)exc_sub_sub_code);
return StopInfo::CreateStopReasonWithWatchpointID(thread, wp_sp->GetID());
}
}
}
else if (exc_code == 2 || // EXC_I386_BPT
exc_code == 3) // EXC_I386_BPTFLT
{
// KDP returns EXC_I386_BPTFLT for trace breakpoints
if (exc_code == 3)
is_trace_if_actual_breakpoint_missing = true;
is_actual_breakpoint = true;
if (!pc_already_adjusted)
pc_decrement = 1;
}
break;
case llvm::Triple::ppc:
case llvm::Triple::ppc64:
is_actual_breakpoint = exc_code == 1; // EXC_PPC_BREAKPOINT
break;
case llvm::Triple::arm:
if (exc_code == 0x102) // EXC_ARM_DA_DEBUG
{
// It's a watchpoint, then, if the exc_sub_code indicates a known/enabled
// data break address from our watchpoint list.
lldb::WatchpointSP wp_sp;
if (target)
wp_sp = target->GetWatchpointList().FindByAddress((lldb::addr_t)exc_sub_code);
if (wp_sp && wp_sp->IsEnabled())
{
// Debugserver may piggyback the hardware index of the fired watchpoint in the exception data.
// Set the hardware index if that's the case.
if (exc_data_count >=3)
wp_sp->SetHardwareIndex((uint32_t)exc_sub_sub_code);
return StopInfo::CreateStopReasonWithWatchpointID(thread, wp_sp->GetID());
}
else
{
is_actual_breakpoint = true;
is_trace_if_actual_breakpoint_missing = true;
}
}
else if (exc_code == 1) // EXC_ARM_BREAKPOINT
{
is_actual_breakpoint = true;
is_trace_if_actual_breakpoint_missing = true;
}
else if (exc_code == 0) // FIXME not EXC_ARM_BREAKPOINT but a kernel is currently returning this so accept it as indicating a breakpoint until the kernel is fixed
{
is_actual_breakpoint = true;
is_trace_if_actual_breakpoint_missing = true;
}
break;
case llvm::Triple::aarch64:
{
if (exc_code == 1 && exc_sub_code == 0) // EXC_ARM_BREAKPOINT
{
// This is hit when we single instruction step aka MDSCR_EL1 SS bit 0 is set
return StopInfo::CreateStopReasonToTrace(thread);
}
if (exc_code == 0x102) // EXC_ARM_DA_DEBUG
{
// It's a watchpoint, then, if the exc_sub_code indicates a known/enabled
// data break address from our watchpoint list.
lldb::WatchpointSP wp_sp;
if (target)
wp_sp = target->GetWatchpointList().FindByAddress((lldb::addr_t)exc_sub_code);
if (wp_sp && wp_sp->IsEnabled())
{
// Debugserver may piggyback the hardware index of the fired watchpoint in the exception data.
// Set the hardware index if that's the case.
if (exc_data_count >= 3)
wp_sp->SetHardwareIndex((uint32_t)exc_sub_sub_code);
return StopInfo::CreateStopReasonWithWatchpointID(thread, wp_sp->GetID());
}
// EXC_ARM_DA_DEBUG seems to be reused for EXC_BREAKPOINT as well as EXC_BAD_ACCESS
if (thread.GetTemporaryResumeState() == eStateStepping)
return StopInfo::CreateStopReasonToTrace(thread);
}
// It looks like exc_sub_code has the 4 bytes of the instruction that triggered the
// exception, i.e. our breakpoint opcode
is_actual_breakpoint = exc_code == 1;
break;
}
default:
break;
}
if (is_actual_breakpoint)
{
RegisterContextSP reg_ctx_sp (thread.GetRegisterContext());
addr_t pc = reg_ctx_sp->GetPC() - pc_decrement;
ProcessSP process_sp (thread.CalculateProcess());
lldb::BreakpointSiteSP bp_site_sp;
if (process_sp)
bp_site_sp = process_sp->GetBreakpointSiteList().FindByAddress(pc);
if (bp_site_sp && bp_site_sp->IsEnabled())
{
// Update the PC if we were asked to do so, but only do
// so if we find a breakpoint that we know about cause
// this could be a trap instruction in the code
if (pc_decrement > 0 && adjust_pc_if_needed)
reg_ctx_sp->SetPC (pc);
// If the breakpoint is for this thread, then we'll report the hit, but if it is for another thread,
// we can just report no reason. We don't need to worry about stepping over the breakpoint here, that
// will be taken care of when the thread resumes and notices that there's a breakpoint under the pc.
// If we have an operating system plug-in, we might have set a thread specific breakpoint using the
// operating system thread ID, so we can't make any assumptions about the thread ID so we must always
// report the breakpoint regardless of the thread.
if (bp_site_sp->ValidForThisThread (&thread) || thread.GetProcess()->GetOperatingSystem () != NULL)
return StopInfo::CreateStopReasonWithBreakpointSiteID (thread, bp_site_sp->GetID());
else
return StopInfoSP();
}
// Don't call this a trace if we weren't single stepping this thread.
if (is_trace_if_actual_breakpoint_missing && thread.GetTemporaryResumeState() == eStateStepping)
{
return StopInfo::CreateStopReasonToTrace (thread);
}
}
}
break;
case 7: // EXC_SYSCALL
case 8: // EXC_MACH_SYSCALL
case 9: // EXC_RPC_ALERT
case 10: // EXC_CRASH
break;
}
return StopInfoSP(new StopInfoMachException (thread, exc_type, exc_data_count, exc_code, exc_sub_code));
}
return StopInfoSP();
}
