vm/errors.cpp

   1 #include "master.hpp"
   2
   3 namespace factor
   4 {
   5
   6 bool factor_vm::fatal_erroring_p;
   7
   8 static inline void fa_diddly_atal_error()
   9 {
  10         printf("fatal_error in fatal_error!\n");
  11         breakpoint();
  12         ::_exit(86);
  13 }
  14
  15 void fatal_error(const char *msg, cell tagged)
  16 {
  17         if (factor_vm::fatal_erroring_p)
  18                 fa_diddly_atal_error();
  19
  20         factor_vm::fatal_erroring_p = true;
  21
  22         std::cout << "fatal_error: " << msg;
  23         std::cout << ": " << (void*)tagged;
  24         std::cout << std::endl;
  25         abort();
  26 }
  27
  28 void critical_error(const char *msg, cell tagged)
  29 {
  30         std::cout << "You have triggered a bug in Factor. Please report.\n";
  31         std::cout << "critical_error: " << msg;
  32         std::cout << ": " << std::hex << tagged << std::dec;
  33         std::cout << std::endl;
  34         current_vm()->factorbug();
  35 }
  36
  37 void out_of_memory()
  38 {
  39         std::cout << "Out of memory\n\n";
  40         current_vm()->dump_generations();
  41         abort();
  42 }
  43
  44 void factor_vm::general_error(vm_error_type error, cell arg1_, cell arg2_)
  45 {
  46         data_root<object> arg1(arg1_,this);
  47         data_root<object> arg2(arg2_,this);
  48
  49         faulting_p = true;
  50
  51         /* If we had an underflow or overflow, data or retain stack
  52         pointers might be out of bounds, so fix them before allocating
  53         anything */
  54         ctx->fix_stacks();
  55
  56         /* If error was thrown during heap scan, we re-enable the GC */
  57         gc_off = false;
  58
  59         /* If the error handler is set, we rewind any C stack frames and
  60         pass the error to user-space. */
  61         if(!current_gc && to_boolean(special_objects[ERROR_HANDLER_QUOT]))
  62         {
  63 #ifdef FACTOR_DEBUG
  64                 /* Doing a GC here triggers all kinds of funny errors */
  65                 primitive_compact_gc();
  66 #endif
  67
  68                 /* Now its safe to allocate and GC */
  69                 cell error_object = allot_array_4(special_objects[OBJ_ERROR],
  70                         tag_fixnum(error),arg1.value(),arg2.value());
  71
  72                 ctx->push(error_object);
  73
  74                 /* Reset local roots */
  75                 data_roots.clear();
  76                 bignum_roots.clear();
  77                 code_roots.clear();
  78
  79                 /* The unwind-native-frames subprimitive will clear faulting_p
  80                 if it was successfully reached. */
  81                 unwind_native_frames(special_objects[ERROR_HANDLER_QUOT],
  82                         ctx->callstack_top);
  83         }
  84         /* Error was thrown in early startup before error handler is set, so just
  85         crash. */
  86         else
  87         {
  88                 std::cout << "You have triggered a bug in Factor. Please report.\n";
  89                 std::cout << "error: " << error << std::endl;
  90                 std::cout << "arg 1: "; print_obj(arg1.value()); std::cout << std::endl;
  91                 std::cout << "arg 2: "; print_obj(arg2.value()); std::cout << std::endl;
  92                 factorbug();
  93                 abort();
  94         }
  95 }
  96
  97 void factor_vm::type_error(cell type, cell tagged)
  98 {
  99         general_error(ERROR_TYPE,tag_fixnum(type),tagged);
 100 }
 101
 102 void factor_vm::not_implemented_error()
 103 {
 104         general_error(ERROR_NOT_IMPLEMENTED,false_object,false_object);
 105 }
 106
 107 void factor_vm::verify_memory_protection_error(cell addr)
 108 {
 109         /* Called from the OS-specific top halves of the signal handlers to
 110         make sure it's safe to dispatch to memory_protection_error */
 111         if(fatal_erroring_p)
 112                 fa_diddly_atal_error();
 113         if(faulting_p && !code->safepoint_p(addr))
 114                 fatal_error("Double fault", addr);
 115         else if(fep_p)
 116                 fatal_error("Memory protection fault during low-level debugger", addr);
 117         else if(atomic::load(&current_gc_p))
 118                 fatal_error("Memory protection fault during gc", addr);
 119 }
 120
 121 void factor_vm::memory_protection_error(cell pc, cell addr)
 122 {
 123         if(code->safepoint_p(addr))
 124                 safepoint.handle_safepoint(this, pc);
 125         else if(ctx->datastack_seg->underflow_p(addr))
 126                 general_error(ERROR_DATASTACK_UNDERFLOW,false_object,false_object);
 127         else if(ctx->datastack_seg->overflow_p(addr))
 128                 general_error(ERROR_DATASTACK_OVERFLOW,false_object,false_object);
 129         else if(ctx->retainstack_seg->underflow_p(addr))
 130                 general_error(ERROR_RETAINSTACK_UNDERFLOW,false_object,false_object);
 131         else if(ctx->retainstack_seg->overflow_p(addr))
 132                 general_error(ERROR_RETAINSTACK_OVERFLOW,false_object,false_object);
 133         else if(ctx->callstack_seg->underflow_p(addr))
 134                 general_error(ERROR_CALLSTACK_OVERFLOW,false_object,false_object);
 135         else if(ctx->callstack_seg->overflow_p(addr))
 136                 general_error(ERROR_CALLSTACK_UNDERFLOW,false_object,false_object);
 137         else
 138                 general_error(ERROR_MEMORY,from_unsigned_cell(addr),false_object);
 139 }
 140
 141 void factor_vm::signal_error(cell signal)
 142 {
 143         general_error(ERROR_SIGNAL,from_unsigned_cell(signal),false_object);
 144 }
 145
 146 void factor_vm::divide_by_zero_error()
 147 {
 148         general_error(ERROR_DIVIDE_BY_ZERO,false_object,false_object);
 149 }
 150
 151 void factor_vm::fp_trap_error(unsigned int fpu_status)
 152 {
 153         general_error(ERROR_FP_TRAP,tag_fixnum(fpu_status),false_object);
 154 }
 155
 156 /* For testing purposes */
 157 void factor_vm::primitive_unimplemented()
 158 {
 159         not_implemented_error();
 160 }
 161
 162 void factor_vm::memory_signal_handler_impl()
 163 {
 164         memory_protection_error(signal_fault_pc, signal_fault_addr);
 165         if (!signal_resumable)
 166         {
 167                 /* In theory we should only get here if the callstack overflowed during a
 168                 safepoint */
 169                 general_error(ERROR_CALLSTACK_OVERFLOW,false_object,false_object);
 170         }
 171 }
 172
 173 void memory_signal_handler_impl()
 174 {
 175         current_vm()->memory_signal_handler_impl();
 176 }
 177
 178 void factor_vm::synchronous_signal_handler_impl()
 179 {
 180         signal_error(signal_number);
 181 }
 182
 183 void synchronous_signal_handler_impl()
 184 {
 185         current_vm()->synchronous_signal_handler_impl();
 186 }
 187
 188 void factor_vm::fp_signal_handler_impl()
 189 {
 190         /* Clear pending exceptions to avoid getting stuck in a loop */
 191         set_fpu_state(get_fpu_state());
 192
 193         fp_trap_error(signal_fpu_status);
 194 }
 195
 196 void fp_signal_handler_impl()
 197 {
 198         current_vm()->fp_signal_handler_impl();
 199 }
 200 }