7 bool factor_print_p = true;
9 ostream& operator<<(ostream& out, const string* str) {
10 for (cell i = 0; i < string_capacity(str); i++)
11 out << (char)str->data()[i];
15 void factor_vm::print_word(ostream& out, word* word, cell nesting) {
16 if (TAG(word->vocabulary) == STRING_TYPE)
17 out << untag<string>(word->vocabulary) << ":";
19 if (TAG(word->name) == STRING_TYPE)
20 out << untag<string>(word->name);
22 out << "#<not a string: ";
23 print_nested_obj(out, word->name, nesting);
28 void factor_vm::print_factor_string(ostream& out, string* str) {
29 out << '"' << str << '"';
32 void factor_vm::print_array(ostream& out, array* array, cell nesting) {
33 cell length = array_capacity(array);
37 if (length > 10 && !full_output) {
43 for (i = 0; i < length; i++) {
45 print_nested_obj(out, array_nth(array, i), nesting);
52 void factor_vm::print_alien(ostream& out, alien* alien, cell nesting) {
53 if (to_boolean(alien->expired))
54 out << "#<expired alien>";
55 else if (to_boolean(alien->base)) {
56 out << "#<displaced alien " << alien->displacement << "+";
57 print_nested_obj(out, alien->base, nesting);
60 out << "#<alien " << (void*)alien->address << ">";
64 void factor_vm::print_byte_array(ostream& out, byte_array* array, cell nesting) {
66 cell length = array->capacity;
69 unsigned char* data = array->data<unsigned char>();
71 if (length > 16 && !full_output) {
77 for (i = 0; i < length; i++) {
78 out << " " << (unsigned) data[i];
85 void factor_vm::print_tuple(ostream& out, tuple* tuple, cell nesting) {
86 tuple_layout* layout = untag<tuple_layout>(tuple->layout);
87 cell length = to_cell(layout->size);
90 print_nested_obj(out, layout->klass, nesting);
93 if (length > 10 && !full_output) {
99 for (cell i = 0; i < length; i++) {
101 print_nested_obj(out, tuple->data()[i], nesting);
108 void factor_vm::print_nested_obj(ostream& out, cell obj, fixnum nesting) {
109 if (nesting <= 0 && !full_output) {
118 out << untag_fixnum(obj);
121 out << untag_float(obj);
124 print_word(out, untag<word>(obj), nesting - 1);
127 print_factor_string(out, untag<string>(obj));
134 print_tuple(out, untag<tuple>(obj), nesting - 1);
139 print_nested_obj(out, untag<wrapper>(obj)->object, nesting - 1);
142 case BYTE_ARRAY_TYPE:
144 print_byte_array(out, untag<byte_array>(obj), nesting - 1);
149 print_array(out, untag<array>(obj), nesting - 1);
154 quot = untag<quotation>(obj);
155 print_array(out, untag<array>(quot->array), nesting - 1);
159 print_alien(out, untag<alien>(obj), nesting - 1);
162 out << "#<" << type_name(TAG(obj)) << " @ ";
163 out << (void*)obj << ">";
169 void factor_vm::print_obj(ostream& out, cell obj) {
170 print_nested_obj(out, obj, 10);
173 void factor_vm::print_objects(ostream& out, cell* start, cell* end) {
174 for (; start <= end; start++) {
175 print_obj(out, *start);
180 void factor_vm::print_datastack(ostream& out) {
181 out << "==== DATA STACK:" << endl;
184 (cell*)ctx->datastack_seg->start,
185 (cell*)ctx->datastack);
187 out << "*** Context not initialized" << endl;
190 void factor_vm::print_retainstack(ostream& out) {
191 out << "==== RETAIN STACK:" << endl;
194 (cell*)ctx->retainstack_seg->start,
195 (cell*)ctx->retainstack);
197 out << "*** Context not initialized" << endl;
200 struct stack_frame_printer {
204 explicit stack_frame_printer(factor_vm* parent, ostream& out)
205 : parent(parent), out(out) {}
206 void operator()(cell frame_top, cell size, code_block* owner, cell addr) {
208 out << "frame: " << (void*)frame_top << " size " << size << endl;
209 out << "executing: ";
210 parent->print_obj(out, owner->owner);
213 parent->print_obj(out, owner->scan(parent, addr));
215 out << "word/quot addr: ";
216 out << hex << owner->owner << dec;
218 out << "word/quot xt: ";
219 out << hex << owner->entry_point() << dec;
221 out << "return address: ";
222 out << hex << addr << dec;
227 void factor_vm::print_callstack(ostream& out) {
228 out << "==== CALL STACK:" << endl;
230 stack_frame_printer printer(this, out);
231 iterate_callstack(ctx, printer);
233 out << "*** Context not initialized" << endl;
236 void factor_vm::print_callstack_object(ostream& out, callstack* obj) {
237 stack_frame_printer printer(this, out);
238 iterate_callstack_object(obj, printer);
241 struct padded_address {
244 explicit padded_address(cell value) : value(value) {}
247 ostream& operator<<(ostream& out, const padded_address& value) {
248 char prev = out.fill('0');
249 out.width(sizeof(cell) * 2);
250 out << hex << value.value << dec;
255 void factor_vm::dump_cell(ostream& out, cell x) {
256 out << padded_address(x) << ": ";
258 out << padded_address(x) << " tag " << TAG(x) << endl;
261 void factor_vm::dump_memory(ostream& out, cell from, cell to) {
264 for (; from <= to; from += sizeof(cell))
265 dump_cell(out, from);
268 void dump_memory_range(ostream& out, const char* name, cell name_w,
269 cell start, cell end) {
270 out << setw(name_w) << left << name << ": ";
272 out << "[" << (void*)start << " -> " << (void*)end << "] ";
273 out << setw(10) << right << (end - start) << " bytes" << endl;
276 template <typename Generation>
277 void dump_generation(ostream& out, const char* name, Generation* gen) {
278 dump_memory_range(out, name, 10, gen->start, gen->end);
281 void factor_vm::dump_memory_layout(ostream& out) {
282 dump_generation(out, "Nursery", data->nursery);
283 dump_generation(out, "Aging", data->aging);
284 dump_generation(out, "Tenured", data->tenured);
285 dump_memory_range(out, "Cards", 10, (cell)data->cards, (cell)data->cards_end);
287 out << endl << "Contexts:" << endl << endl;
288 FACTOR_FOR_EACH(active_contexts) {
289 context* the_ctx = *iter;
290 segment* ds = the_ctx->datastack_seg;
291 segment* rs = the_ctx->retainstack_seg;
292 segment* cs = the_ctx->callstack_seg;
293 if (the_ctx == ctx) {
294 out << " Active:" << endl;
296 dump_memory_range(out, " Datastack", 14, ds->start, ds->end);
297 dump_memory_range(out, " Retainstack", 14, rs->start, rs->end);
298 dump_memory_range(out, " Callstack", 14, cs->start, cs->end);
303 void factor_vm::dump_objects(ostream& out, cell type) {
305 auto object_dumper = [&](object* obj) {
306 if (type == TYPE_COUNT || obj->type() == type) {
307 out << padded_address((cell)obj) << " ";
308 print_nested_obj(out, tag_dynamic(obj), 2);
312 each_object(object_dumper);
315 void factor_vm::find_data_references(ostream& out, cell look_for) {
317 auto find_data_ref_func = [&](object* obj, cell* slot) {
318 if (look_for == *slot) {
319 out << padded_address((cell)obj) << " ";
320 print_nested_obj(out, tag_dynamic(obj), 2);
324 each_object_each_slot(find_data_ref_func);
327 void factor_vm::dump_edges(ostream& out) {
329 auto dump_edges_func = [&](object* obj, cell* scan) {
330 if (TAG(*scan) > F_TYPE) {
331 out << (void*)tag_dynamic(obj);
333 out << (void*)*scan << endl;
336 each_object_each_slot(dump_edges_func);
339 struct code_block_printer {
342 cell reloc_size, parameter_size;
344 explicit code_block_printer(factor_vm* parent, ostream& out)
345 : parent(parent), out(out), reloc_size(0), parameter_size(0) {}
347 void operator()(code_block* scan, cell size) {
352 reloc_size += object_size(scan->relocation);
353 parameter_size += object_size(scan->parameters);
355 if (parent->code->allocator->state.marked_p((cell)scan))
358 status = "allocated";
360 out << hex << (cell)scan << dec << " ";
361 out << hex << size << dec << " ";
362 out << status << " ";
363 out << "stack frame " << scan->stack_frame_size();
369 // Dump all code blocks for debugging
370 void factor_vm::dump_code_heap(ostream& out) {
371 code_block_printer printer(this, out);
372 code->allocator->iterate(printer, no_fixup());
373 out << printer.reloc_size << " bytes used by relocation tables" << endl;
374 out << printer.parameter_size << " bytes used by parameter tables" << endl;
377 void factor_vm::factorbug_usage(bool advanced_p) {
378 cout << "Basic commands:" << endl;
380 cout << " q ^Z -- quit Factor" << endl;
382 cout << " q ^D -- quit Factor" << endl;
384 cout << " c -- continue executing Factor - NOT SAFE"
386 cout << " t -- throw exception in Factor - NOT SAFE"
388 cout << " .s .r .c -- print data, retain, call stacks"
391 cout << " help -- reprint this message" << endl;
392 cout << "Advanced commands:" << endl;
393 cout << " e -- dump environment" << endl;
394 cout << " d <addr> <count> -- dump memory" << endl;
395 cout << " u <addr> -- dump object at tagged <addr>"
397 cout << " . <addr> -- print object at tagged <addr>"
399 cout << " g -- dump memory layout" << endl;
400 cout << " ds dr -- dump data, retain stacks" << endl;
401 cout << " trim -- toggle output trimming" << endl;
402 cout << " data -- data heap dump" << endl;
403 cout << " words -- words dump" << endl;
404 cout << " tuples -- tuples dump" << endl;
405 cout << " edges -- print all object-to-object references"
407 cout << " refs <addr> -- find data heap references to object"
409 cout << " push <addr> -- push object on data stack - NOT SAFE"
411 cout << " gc -- trigger full GC - NOT SAFE"
413 cout << " compact-gc -- trigger compacting GC - NOT SAFE"
415 cout << " code -- code heap dump" << endl;
416 cout << " abort -- call abort()" << endl;
417 cout << " breakpoint -- trigger system breakpoint" << endl;
419 cout << " help -- full help, including advanced commands"
425 static void exit_fep(factor_vm* vm) {
431 void factor_vm::factorbug() {
433 cout << "Low level debugger disabled" << endl;
437 if (sampling_profiler_p)
438 end_sampling_profiler();
442 cout << "Starting low level debugger..." << endl;
444 // Even though we've stopped the VM, the stdin_loop thread (see os-*.cpp)
445 // that pumps the console is still running concurrently. We lock a mutex so
446 // the thread will take a break and give us exclusive access to stdin.
450 if (!fep_help_was_shown) {
451 factorbug_usage(false);
452 fep_help_was_shown = true;
454 bool seen_command = false;
459 cout << "> " << flush;
461 cin >> setw(1024) >> cmd >> setw(0);
464 // If we exit with an EOF immediately, then
465 // dump stacks. This is useful for builder and
466 // other cases where Factor is run with stdin
467 // redirected to /dev/null
470 print_datastack(cout);
471 print_retainstack(cout);
472 print_callstack(cout);
483 cell addr = read_cell_hex();
484 if (cin.peek() == ' ')
489 cell count = read_cell_hex();
490 dump_memory(cout, addr, addr + count);
491 } else if (cmd == "u") {
492 cell addr = read_cell_hex();
493 cell count = object_size(addr);
494 dump_memory(cout, addr, addr + count);
495 } else if (cmd == ".") {
496 cell addr = read_cell_hex();
497 print_obj(cout, addr);
499 } else if (cmd == "trim")
500 full_output = !full_output;
501 else if (cmd == "ds")
502 dump_memory(cout, ctx->datastack_seg->start, ctx->datastack);
503 else if (cmd == "dr")
504 dump_memory(cout, ctx->retainstack_seg->start, ctx->retainstack);
505 else if (cmd == ".s")
506 print_datastack(cout);
507 else if (cmd == ".r")
508 print_retainstack(cout);
509 else if (cmd == ".c")
510 print_callstack(cout);
511 else if (cmd == "e") {
512 for (cell i = 0; i < special_object_count; i++)
513 dump_cell(cout, (cell)&special_objects[i]);
514 } else if (cmd == "g")
515 dump_memory_layout(cout);
516 else if (cmd == "c") {
519 } else if (cmd == "t") {
521 general_error(ERROR_INTERRUPT, false_object, false_object);
522 FACTOR_ASSERT(false);
523 } else if (cmd == "data")
524 dump_objects(cout, TYPE_COUNT);
525 else if (cmd == "edges")
527 else if (cmd == "refs") {
528 cell addr = read_cell_hex();
529 cout << "Data heap references:" << endl;
530 find_data_references(cout, addr);
532 } else if (cmd == "words")
533 dump_objects(cout, WORD_TYPE);
534 else if (cmd == "tuples")
535 dump_objects(cout, TUPLE_TYPE);
536 else if (cmd == "push") {
537 cell addr = read_cell_hex();
539 } else if (cmd == "code")
540 dump_code_heap(cout);
541 else if (cmd == "gc")
543 else if (cmd == "compact-gc")
544 primitive_compact_gc();
545 else if (cmd == "help")
546 factorbug_usage(true);
547 else if (cmd == "abort")
549 else if (cmd == "breakpoint")
552 cout << "unknown command" << endl;
556 void factor_vm::primitive_die() {
557 critical_error("The die word was called by the library.", 0);