vm/errors.cpp

   1 #include "master.hpp"
   2
   3 namespace factor
   4 {
   5
   6 void fatal_error(const char *msg, cell tagged)
   7 {
   8         std::cout << "fatal_error: " << msg;
   9         std::cout << ": " << std::hex << tagged << std::dec;
  10         std::cout << std::endl;
  11         exit(1);
  12 }
  13
  14 void critical_error(const char *msg, cell tagged)
  15 {
  16         std::cout << "You have triggered a bug in Factor. Please report.\n";
  17         std::cout << "critical_error: " << msg;
  18         std::cout << ": " << std::hex << tagged << std::dec;
  19         std::cout << std::endl;
  20         current_vm()->factorbug();
  21 }
  22
  23 void out_of_memory()
  24 {
  25         std::cout << "Out of memory\n\n";
  26         current_vm()->dump_generations();
  27         exit(1);
  28 }
  29
  30 void factor_vm::throw_error(cell error, stack_frame *stack)
  31 {
  32         assert(stack);
  33
  34         /* If the error handler is set, we rewind any C stack frames and
  35         pass the error to user-space. */
  36         if(!current_gc && to_boolean(special_objects[ERROR_HANDLER_QUOT]))
  37         {
  38                 /* If error was thrown during heap scan, we re-enable the GC */
  39                 gc_off = false;
  40
  41                 /* Reset local roots */
  42                 data_roots.clear();
  43                 bignum_roots.clear();
  44                 code_roots.clear();
  45
  46                 /* If we had an underflow or overflow, data or retain stack
  47                 pointers might be out of bounds */
  48                 ctx->fix_stacks();
  49
  50                 ctx->push(error);
  51
  52                 unwind_native_frames(special_objects[ERROR_HANDLER_QUOT],stack);
  53         }
  54         /* Error was thrown in early startup before error handler is set, just
  55         crash. */
  56         else
  57         {
  58                 std::cout << "You have triggered a bug in Factor. Please report.\n";
  59                 std::cout << "early_error: ";
  60                 print_obj(error);
  61                 std::cout << std::endl;
  62                 factorbug();
  63         }
  64 }
  65
  66 void factor_vm::general_error(vm_error_type error, cell arg1, cell arg2, stack_frame *stack)
  67 {
  68         throw_error(allot_array_4(special_objects[OBJ_ERROR],
  69                 tag_fixnum(error),arg1,arg2),stack);
  70 }
  71
  72 void factor_vm::general_error(vm_error_type error, cell arg1, cell arg2)
  73 {
  74         throw_error(allot_array_4(special_objects[OBJ_ERROR],
  75                 tag_fixnum(error),arg1,arg2),ctx->callstack_top);
  76 }
  77
  78 void factor_vm::type_error(cell type, cell tagged)
  79 {
  80         general_error(ERROR_TYPE,tag_fixnum(type),tagged);
  81 }
  82
  83 void factor_vm::not_implemented_error()
  84 {
  85         general_error(ERROR_NOT_IMPLEMENTED,false_object,false_object);
  86 }
  87
  88 void factor_vm::memory_protection_error(cell addr, stack_frame *stack)
  89 {
  90         if(ctx->datastack_seg->underflow_p(addr))
  91                 general_error(ERROR_DATASTACK_UNDERFLOW,false_object,false_object,stack);
  92         else if(ctx->datastack_seg->overflow_p(addr))
  93                 general_error(ERROR_DATASTACK_OVERFLOW,false_object,false_object,stack);
  94         else if(ctx->retainstack_seg->underflow_p(addr))
  95                 general_error(ERROR_RETAINSTACK_UNDERFLOW,false_object,false_object,stack);
  96         else if(ctx->retainstack_seg->overflow_p(addr))
  97                 general_error(ERROR_RETAINSTACK_OVERFLOW,false_object,false_object,stack);
  98         else
  99                 general_error(ERROR_MEMORY,allot_cell(addr),false_object,stack);
 100 }
 101
 102 void factor_vm::signal_error(cell signal, stack_frame *stack)
 103 {
 104         general_error(ERROR_SIGNAL,allot_cell(signal),false_object,stack);
 105 }
 106
 107 void factor_vm::divide_by_zero_error()
 108 {
 109         general_error(ERROR_DIVIDE_BY_ZERO,false_object,false_object);
 110 }
 111
 112 void factor_vm::fp_trap_error(unsigned int fpu_status, stack_frame *stack)
 113 {
 114         general_error(ERROR_FP_TRAP,tag_fixnum(fpu_status),false_object,stack);
 115 }
 116
 117 void factor_vm::primitive_call_clear()
 118 {
 119         unwind_native_frames(ctx->pop(),ctx->callstack_bottom);
 120 }
 121
 122 /* For testing purposes */
 123 void factor_vm::primitive_unimplemented()
 124 {
 125         not_implemented_error();
 126 }
 127
 128 void factor_vm::memory_signal_handler_impl()
 129 {
 130         memory_protection_error(signal_fault_addr,signal_callstack_top);
 131 }
 132
 133 void memory_signal_handler_impl()
 134 {
 135         current_vm()->memory_signal_handler_impl();
 136 }
 137
 138 void factor_vm::misc_signal_handler_impl()
 139 {
 140         signal_error(signal_number,signal_callstack_top);
 141 }
 142
 143 void misc_signal_handler_impl()
 144 {
 145         current_vm()->misc_signal_handler_impl();
 146 }
 147
 148 void factor_vm::fp_signal_handler_impl()
 149 {
 150         fp_trap_error(signal_fpu_status,signal_callstack_top);
 151 }
 152
 153 void fp_signal_handler_impl()
 154 {
 155         current_vm()->fp_signal_handler_impl();
 156 }
 157
 158 }