5 // Allocates memory (allot)
6 callstack* factor_vm::allot_callstack(cell size) {
7 callstack* stack = allot<callstack>(callstack_object_size(size));
8 stack->length = tag_fixnum(size);
12 // We ignore the two topmost frames, the 'callstack' primitive
13 // frame itself, and the frame calling the 'callstack' primitive,
14 // so that set-callstack doesn't get stuck in an infinite loop.
16 // This means that if 'callstack' is called in tail position, we
17 // will have popped a necessary frame... however this word is only
18 // called by continuation implementation, and user code shouldn't
19 // be calling it at all, so we leave it as it is for now.
20 cell factor_vm::second_from_top_stack_frame(context* ctx) {
21 cell frame_top = ctx->callstack_top;
22 for (cell i = 0; i < 2; ++i) {
23 cell pred = code->frame_predecessor(frame_top);
24 if (pred >= ctx->callstack_bottom)
31 // Allocates memory (allot_callstack)
32 cell factor_vm::capture_callstack(context* ctx) {
33 cell top = second_from_top_stack_frame(ctx);
34 cell bottom = ctx->callstack_bottom;
36 fixnum size = std::max((cell)0, bottom - top);
38 callstack* stack = allot_callstack(size);
39 memcpy(stack->top(), (void *)top, size);
40 return tag<callstack>(stack);
43 // Allocates memory (capture_callstack)
44 void factor_vm::primitive_callstack_for() {
45 context* other_ctx = (context*)pinned_alien_offset(ctx->peek());
46 ctx->replace(capture_callstack(other_ctx));
49 struct stack_frame_in_array {
53 // Allocates memory (frames.trim()), iterate_callstack_object()
54 void factor_vm::primitive_callstack_to_array() {
55 data_root<callstack> callstack(ctx->peek(), this);
56 // Allocates memory here.
57 growable_array frames(this);
59 auto stack_frame_accumulator = [&](cell frame_top,
63 data_root<object> executing_quot(owner->owner_quot(), this);
64 data_root<object> executing(owner->owner, this);
65 data_root<object> scan(owner->scan(this, addr), this);
67 frames.add(executing.value());
68 frames.add(executing_quot.value());
69 frames.add(scan.value());
71 iterate_callstack_object(callstack.untagged(), stack_frame_accumulator);
75 ctx->replace(frames.elements.value());
78 // Some primitives implementing a limited form of callstack mutation.
79 // Used by the single stepper.
80 void factor_vm::primitive_innermost_stack_frame_executing() {
81 callstack* stack = untag_check<callstack>(ctx->peek());
82 void* frame = stack->top();
83 cell addr = *(cell*)frame;
84 ctx->replace(code->code_block_for_address(addr)->owner_quot());
87 void factor_vm::primitive_innermost_stack_frame_scan() {
88 callstack* stack = untag_check<callstack>(ctx->peek());
89 void* frame = stack->top();
90 cell addr = *(cell*)frame;
91 ctx->replace(code->code_block_for_address(addr)->scan(this, addr));
94 // Allocates memory (jit_compile_quotation)
95 void factor_vm::primitive_set_innermost_stack_frame_quotation() {
96 data_root<callstack> stack(ctx->pop(), this);
97 data_root<quotation> quot(ctx->pop(), this);
102 jit_compile_quotation(quot.value(), true);
104 void* inner = stack->top();
105 cell addr = *(cell*)inner;
106 code_block* block = code->code_block_for_address(addr);
107 cell offset = block->offset(addr);
108 *(cell*)inner = quot->entry_point + offset;
111 // Allocates memory (allot_alien)
112 void factor_vm::primitive_callstack_bounds() {
113 ctx->push(allot_alien(ctx->callstack_seg->start));
114 ctx->push(allot_alien(ctx->callstack_seg->end));