LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) {
int code = exceptionInfo->ExceptionRecord->ExceptionCode;
if (code == EXCEPTION_BREAKPOINT) {
// This exception is called when an assertion fails (__asm { int 3} is executed).
// It is therefore imperative we continue the search hereby enabling
// spawning of a Just-in-time debugger.
return EXCEPTION_CONTINUE_SEARCH;
}
lprintf("Exception caught \"%s\".\n", exception_name(code));
if (code == EXCEPTION_STACK_OVERFLOW) {
lprintf(" Oops, we encounted a stack overflow.\n");
lprintf(" You should check your program for infinite recursion!\n");
suspend_process_at_stack_overflow(
(int*) exceptionInfo->ContextRecord->Esp,
(int*) exceptionInfo->ContextRecord->Ebp,
(char*) exceptionInfo->ContextRecord->Eip);
lprintf(" Coutinue execution ??????????????\n");
} else {
// Do not report vm state when getting stack overflow
report_vm_state();
}
if (os::message_box("Exception caught", "Do you want a stack trace?")) {
trace_stack_at_exception((int*) exceptionInfo->ContextRecord->Esp,
(int*) exceptionInfo->ContextRecord->Ebp,
(char*) exceptionInfo->ContextRecord->Eip);
}
return EXCEPTION_CONTINUE_SEARCH;
}
void
x86_fatal_exception(iframe* frame)
{
char name[32];
panic("Fatal exception \"%s\" occurred! Error code: 0x%lx\n",
exception_name(frame->vector, name, sizeof(name)), frame->error_code);
}
void
x86_invalid_exception(iframe* frame)
{
Thread* thread = thread_get_current_thread();
char name[32];
panic("unhandled trap 0x%lx (%s) at ip 0x%lx, thread %" B_PRId32 "!\n",
frame->vector, exception_name(frame->vector, name, sizeof(name)),
frame->ip, thread ? thread->id : -1);
}
static void
add_exceptiondesc (Exception e, struct buffer_s *data, /* OUT */ list referenced)
{
printmToBuffer (data, "(exception %s %s \"\"",
interface_name(exception_interface(e)), exception_name(e));
if ((e->type != NULL) && (type_ur_kind(e->type) != void_Type)) {
print0ToBuffer (data, " ");
add_typeref (e->type, data, referenced);
} else {
print0ToBuffer (data, " void");
}
print0ToBuffer (data, ")");
}
static void add_exnref (Exception exn, struct buffer_s *data, list referenced)
{
print0ToBuffer (data, "(exn ");
if (exn->corba_rep_id != NULL) {
print0ToBuffer(data, "(id ");
add_quoted_string(exn->corba_rep_id, data);
print0ToBuffer(data, ")");
} else {
printmToBuffer (data, "(ref %s %s)", interface_name(exception_interface(exn)), exception_name(exn));
add_entity (ExceptionE, exn, referenced);
}
printmToBuffer (data, ")");
}
void sleh_fatal(vc4_saved_state_t* pcb, uint32_t n) {
printf("Fatal VPU Exception: %s\n", exception_name(n));
printf("VPU registers:\n");
printf(
REGISTER_FORMAT_STRING(" "),
pcb->r0,
pcb->r1,
pcb->r2,
pcb->r3,
pcb->r4,
pcb->r5,
pcb->r6,
pcb->r7,
pcb->r8,
pcb->r9,
pcb->r10,
pcb->r11,
pcb->r12,
pcb->r13,
pcb->r14,
pcb->r15,
pcb->pc,
pcb->lr,
pcb->sr
);
printf("Exception info:\n");
printf(
" src0: 0x%08x src1: 0x%08x vaddr: 0x%08x\n"
" C: 0x%08x S: 0x%08x\n",
IC0_SRC0,
IC0_SRC1,
IC0_VADDR,
IC0_C,
IC0_S
);
printf("We are hanging here ...\n");
hang_cpu();
}
void
x86_unexpected_exception(iframe* frame)
{
debug_exception_type type;
uint32 signalNumber;
int32 signalCode;
addr_t signalAddress = 0;
int32 signalError = B_ERROR;
switch (frame->vector) {
case 0: // Divide Error Exception (#DE)
type = B_DIVIDE_ERROR;
signalNumber = SIGFPE;
signalCode = FPE_INTDIV;
signalAddress = frame->ip;
break;
case 4: // Overflow Exception (#OF)
type = B_OVERFLOW_EXCEPTION;
signalNumber = SIGFPE;
signalCode = FPE_INTOVF;
signalAddress = frame->ip;
break;
case 5: // BOUND Range Exceeded Exception (#BR)
type = B_BOUNDS_CHECK_EXCEPTION;
signalNumber = SIGTRAP;
signalCode = SI_USER;
break;
case 6: // Invalid Opcode Exception (#UD)
type = B_INVALID_OPCODE_EXCEPTION;
signalNumber = SIGILL;
signalCode = ILL_ILLOPC;
signalAddress = frame->ip;
break;
case 13: // General Protection Exception (#GP)
type = B_GENERAL_PROTECTION_FAULT;
signalNumber = SIGILL;
signalCode = ILL_PRVOPC; // or ILL_PRVREG
signalAddress = frame->ip;
break;
case 16: // x87 FPU Floating-Point Error (#MF)
type = B_FLOATING_POINT_EXCEPTION;
signalNumber = SIGFPE;
signalCode = FPE_FLTDIV;
// TODO: Determine the correct cause via the FPU status
// register!
signalAddress = frame->ip;
break;
case 17: // Alignment Check Exception (#AC)
type = B_ALIGNMENT_EXCEPTION;
signalNumber = SIGBUS;
signalCode = BUS_ADRALN;
// TODO: Also get the address (from where?). Since we don't enable
// alignment checking this exception should never happen, though.
signalError = EFAULT;
break;
case 19: // SIMD Floating-Point Exception (#XF)
type = B_FLOATING_POINT_EXCEPTION;
signalNumber = SIGFPE;
signalCode = FPE_FLTDIV;
// TODO: Determine the correct cause via the MXCSR register!
signalAddress = frame->ip;
break;
default:
x86_invalid_exception(frame);
return;
}
if (IFRAME_IS_USER(frame)) {
struct sigaction action;
Thread* thread = thread_get_current_thread();
enable_interrupts();
// If the thread has a signal handler for the signal, we simply send it
// the signal. Otherwise we notify the user debugger first.
if ((sigaction(signalNumber, NULL, &action) == 0
&& action.sa_handler != SIG_DFL
&& action.sa_handler != SIG_IGN)
|| user_debug_exception_occurred(type, signalNumber)) {
Signal signal(signalNumber, signalCode, signalError,
thread->team->id);
signal.SetAddress((void*)signalAddress);
send_signal_to_thread(thread, signal, 0);
}
} else {
char name[32];
panic("Unexpected exception \"%s\" occurred in kernel mode! "
"Error code: 0x%lx\n",
exception_name(frame->vector, name, sizeof(name)),
frame->error_code);
}
}
