#include "master.hpp"
-namespace factor
-{
-
-void factor_vm::dispatch_signal_handler(cell *sp, cell *pc, cell handler)
-{
- if (!code->seg->in_segment_p(*pc) || *sp < ctx->callstack_seg->start + stack_reserved)
- {
- /* Fault came from foreign code or a callstack overflow, or we don't
- have enough callstack room to try the resumable handler. Cut the
- callstack down to the shallowest Factor stack frame that leaves room for
- the signal handler to do its thing, and launch the handler without going
- through the resumable subprimitive. */
- signal_resumable = false;
- void *frame_top = (void*)ctx->callstack_top;
-
- while(frame_top < ctx->callstack_bottom
- && (cell)frame_top < ctx->callstack_seg->start + stack_reserved)
- {
- frame_top = frame_predecessor(frame_top);
- }
-
- *sp = (cell)frame_top;
- ctx->callstack_top = frame_top;
- *pc = handler;
- } else {
- signal_resumable = true;
- // Fault came from Factor, and we've got a good callstack. Route the signal
- // handler through the resumable signal handler subprimitive.
- cell offset = *sp % 16;
-
- signal_handler_addr = handler;
- tagged<word> handler_word = tagged<word>(special_objects[SIGNAL_HANDLER_WORD]);
-
- /* True stack frames are always 16-byte aligned. Leaf procedures
- that don't create a stack frame will be out of alignment by sizeof(cell)
- bytes. */
- /* On architectures with a link register we would have to check for leafness
- by matching the PC to a word. We should also use FRAME_RETURN_ADDRESS instead
- of assuming the stack pointer is the right place to put the resume address. */
- if (offset == 0)
- {
- cell newsp = *sp - sizeof(cell);
- *sp = newsp;
- *(cell*)newsp = *pc;
- }
- else if (offset == 16 - sizeof(cell))
- {
- // Make a fake frame for the leaf procedure
- code_block *leaf_block = code->code_block_for_address(*pc);
- FACTOR_ASSERT(leaf_block != NULL);
-
- cell newsp = *sp - LEAF_FRAME_SIZE;
- *(cell*)(newsp + 3*sizeof(cell)) = 4*sizeof(cell);
- *(cell*)(newsp + 2*sizeof(cell)) = (cell)leaf_block->entry_point();
- *(cell*) newsp = *pc;
- *sp = newsp;
- handler_word = tagged<word>(special_objects[LEAF_SIGNAL_HANDLER_WORD]);
- }
- else
- FACTOR_ASSERT(false);
-
- *pc = (cell)handler_word->entry_point;
- }
+namespace factor {
+
+void factor_vm::dispatch_non_resumable_signal(cell* sp, cell* pc,
+ cell handler,
+ cell limit) {
+
+ // Fault came from the VM or foreign code. We don't try to fix the
+ // call stack from *sp and instead use the last saved "good value"
+ // which we get from ctx->callstack_top. Then launch the handler
+ // without going through the resumable subprimitive.
+ cell frame_top = ctx->callstack_top;
+ cell seg_start = ctx->callstack_seg->start;
+
+ if (frame_top < seg_start) {
+ // The saved callstack pointer is outside the callstack
+ // segment. That means that we need to carefully cut off one frame
+ // first which hopefully should put the pointer within the
+ // callstack's bounds.
+ code_block *block = code->code_block_for_address(*pc);
+ cell frame_size = block->stack_frame_size_for_address(*pc);
+ frame_top += frame_size;
+ }
+
+ // Cut the callstack down to the shallowest Factor stack
+ // frame that leaves room for the signal handler to do its thing,
+ // and launch the handler without going through the resumable
+ // subprimitive.
+ FACTOR_ASSERT(seg_start <= frame_top);
+ while (frame_top < ctx->callstack_bottom && frame_top < limit) {
+ frame_top = code->frame_predecessor(frame_top);
+ }
+ ctx->callstack_top = frame_top;
+ *sp = frame_top;
+ *pc = handler;
+}
+
+void factor_vm::dispatch_resumable_signal(cell* sp, cell* pc, cell handler) {
+
+ // Fault came from Factor, and we've got a good callstack. Route the
+ // signal handler through the resumable signal handler
+ // subprimitive.
+
+ cell offset = *sp % 16;
+
+ signal_handler_addr = handler;
+
+ // True stack frames are always 16-byte aligned. Leaf procedures
+ // that don't create a stack frame will be out of alignment by
+ // sizeof(cell) bytes.
+ // On architectures with a link register we would have to check for
+ // leafness by matching the PC to a word. We should also use
+ // FRAME_RETURN_ADDRESS instead of assuming the stack pointer is the
+ // right place to put the resume address.
+ cell index = 0;
+ cell delta = 0;
+ if (offset == 0) {
+ delta = sizeof(cell);
+ index = SIGNAL_HANDLER_WORD;
+ } else if (offset == 16 - sizeof(cell)) {
+ // Make a fake frame for the leaf procedure
+ FACTOR_ASSERT(code->code_block_for_address(*pc) != NULL);
+ delta = LEAF_FRAME_SIZE;
+ index = LEAF_SIGNAL_HANDLER_WORD;
+ } else {
+ FACTOR_ASSERT(false);
+ }
+ cell new_sp = *sp - delta;
+ *sp = new_sp;
+ *(cell*)new_sp = *pc;
+
+ *pc = untag<word>(special_objects[index])->entry_point;
+}
+
+void factor_vm::dispatch_signal_handler(cell* sp, cell* pc, cell handler) {
+
+ bool in_code_seg = code->seg->in_segment_p(*pc);
+ cell cs_limit = ctx->callstack_seg->start + stack_reserved;
+ signal_resumable = in_code_seg && *sp >= cs_limit;
+
+ if (signal_resumable) {
+ dispatch_resumable_signal(sp, pc, handler);
+ } else {
+ dispatch_non_resumable_signal(sp, pc, handler, cs_limit);
+ }
+
+ // Poking with the stack pointer, which the above code does, means
+ // that pointers to stack-allocated objects will become
+ // corrupted. Therefore the root vectors needs to be cleared because
+ // their pointers to stack variables are now garbage.
+ data_roots.clear();
+ code_roots.clear();
}
}