5 bool factor_vm::fatal_erroring_p;
7 static inline void fa_diddly_atal_error() {
8 printf("fatal_error in fatal_error!\n");
13 void fatal_error(const char* msg, cell tagged) {
14 if (factor_vm::fatal_erroring_p)
15 fa_diddly_atal_error();
17 factor_vm::fatal_erroring_p = true;
19 std::cout << "fatal_error: " << msg;
20 std::cout << ": " << (void*)tagged;
21 std::cout << std::endl << std::endl;
22 current_vm()->dump_memory_layout(std::cout);
26 void critical_error(const char* msg, cell tagged) {
27 std::cout << "You have triggered a bug in Factor. Please report.\n";
28 std::cout << "critical_error: " << msg;
29 std::cout << ": " << std::hex << tagged << std::dec;
30 std::cout << std::endl;
31 current_vm()->factorbug();
34 /* Allocates memory */
35 void factor_vm::general_error(vm_error_type error, cell arg1_, cell arg2_) {
37 data_root<object> arg1(arg1_, this);
38 data_root<object> arg2(arg2_, this);
42 /* If we had an underflow or overflow, data or retain stack
43 pointers might be out of bounds, so fix them before allocating
47 /* If error was thrown during heap scan, we re-enable the GC */
50 /* If the error handler is set, we rewind any C stack frames and
51 pass the error to user-space. */
52 if (!current_gc && to_boolean(special_objects[ERROR_HANDLER_QUOT])) {
54 /* Doing a GC here triggers all kinds of funny errors */
55 primitive_compact_gc();
58 /* Now its safe to allocate and GC */
60 allot_array_4(special_objects[OBJ_ERROR], tag_fixnum(error),
61 arg1.value(), arg2.value());
62 ctx->push(error_object);
64 /* Clear the data roots since arg1 and arg2's destructors won't be
68 /* The unwind-native-frames subprimitive will clear faulting_p
69 if it was successfully reached. */
70 unwind_native_frames(special_objects[ERROR_HANDLER_QUOT],
72 } /* Error was thrown in early startup before error handler is set, so just
75 std::cout << "You have triggered a bug in Factor. Please report.\n";
76 std::cout << "error: " << error << std::endl;
77 std::cout << "arg 1: ";
78 print_obj(std::cout, arg1.value());
79 std::cout << std::endl;
80 std::cout << "arg 2: ";
81 print_obj(std::cout, arg2.value());
82 std::cout << std::endl;
88 /* Allocates memory */
89 void factor_vm::type_error(cell type, cell tagged) {
90 general_error(ERROR_TYPE, tag_fixnum(type), tagged);
93 /* Allocates memory */
94 void factor_vm::not_implemented_error() {
95 general_error(ERROR_NOT_IMPLEMENTED, false_object, false_object);
98 void factor_vm::verify_memory_protection_error(cell addr) {
99 /* Called from the OS-specific top halves of the signal handlers to
100 make sure it's safe to dispatch to memory_signal_handler_impl. */
101 if (fatal_erroring_p)
102 fa_diddly_atal_error();
103 if (faulting_p && !code->safepoint_p(addr))
104 fatal_error("Double fault", addr);
106 fatal_error("Memory protection fault during low-level debugger", addr);
107 else if (atomic::load(¤t_gc_p))
108 fatal_error("Memory protection fault during gc", addr);
111 /* Allocates memory */
112 void factor_vm::divide_by_zero_error() {
113 general_error(ERROR_DIVIDE_BY_ZERO, false_object, false_object);
116 /* For testing purposes */
117 /* Allocates memory */
118 void factor_vm::primitive_unimplemented() { not_implemented_error(); }
120 /* Allocates memory */
121 void factor_vm::memory_signal_handler_impl() {
122 if (code->safepoint_p(signal_fault_addr)) {
123 safepoint.handle_safepoint(this, signal_fault_pc);
126 vm_error_type type = ctx->address_to_error(signal_fault_addr);
127 cell number = from_unsigned_cell(signal_fault_addr);
128 general_error(type, number, false_object);
130 if (!signal_resumable) {
131 /* In theory we should only get here if the callstack overflowed during a
133 general_error(ERROR_CALLSTACK_OVERFLOW, false_object, false_object);
137 /* Allocates memory */
138 void memory_signal_handler_impl() {
139 current_vm()->memory_signal_handler_impl();
142 /* Allocates memory */
143 void factor_vm::synchronous_signal_handler_impl() {
144 general_error(ERROR_SIGNAL, from_unsigned_cell(signal_number), false_object);
147 /* Allocates memory */
148 void synchronous_signal_handler_impl() {
149 current_vm()->synchronous_signal_handler_impl();
152 /* Allocates memory (fp_trap_error())*/
153 void factor_vm::fp_signal_handler_impl() {
154 /* Clear pending exceptions to avoid getting stuck in a loop */
155 set_fpu_state(get_fpu_state());
157 general_error(ERROR_FP_TRAP, tag_fixnum(signal_fpu_status), false_object);
160 /* Allocates memory */
161 void fp_signal_handler_impl() { current_vm()->fp_signal_handler_impl(); }