vm/debug.cpp

   1 #include "master.hpp"
   2
   3 using namespace std;
   4
   5 namespace factor {
   6
   7 bool factor_print_p = true;
   8
   9 ostream& operator<<(ostream& out, const string* str) {
  10   for (cell i = 0; i < string_capacity(str); i++)
  11     out << (char)str->data()[i];
  12   return out;
  13 }
  14
  15 void factor_vm::print_word(ostream& out, word* word, cell nesting) {
  16   if (tagged<object>(word->vocabulary).type_p(STRING_TYPE))
  17     out << untag<string>(word->vocabulary) << ":";
  18
  19   if (tagged<object>(word->name).type_p(STRING_TYPE))
  20     out << untag<string>(word->name);
  21   else {
  22     out << "#<not a string: ";
  23     print_nested_obj(out, word->name, nesting);
  24     out << ">";
  25   }
  26 }
  27
  28 void factor_vm::print_factor_string(ostream& out, string* str) {
  29   out << '"' << str << '"';
  30 }
  31
  32 void factor_vm::print_array(ostream& out, array* array, cell nesting) {
  33   cell length = array_capacity(array);
  34   cell i;
  35   bool trimmed;
  36
  37   if (length > 10 && !full_output) {
  38     trimmed = true;
  39     length = 10;
  40   } else
  41     trimmed = false;
  42
  43   for (i = 0; i < length; i++) {
  44     out << " ";
  45     print_nested_obj(out, array_nth(array, i), nesting);
  46   }
  47
  48   if (trimmed)
  49     out << "...";
  50 }
  51
  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);
  58     out << ">";
  59   } else {
  60     out << "#<alien " << (void*)alien->address << ">";
  61   }
  62 }
  63
  64 void factor_vm::print_byte_array(ostream& out, byte_array* array, cell nesting) {
  65   cell length = array->capacity;
  66   cell i;
  67   bool trimmed;
  68   unsigned char* data = array->data<unsigned char>();
  69
  70   if (length > 16 && !full_output) {
  71     trimmed = true;
  72     length = 16;
  73   } else
  74     trimmed = false;
  75
  76   for (i = 0; i < length; i++) {
  77     out << " " << (unsigned) data[i];
  78   }
  79
  80   if (trimmed)
  81     out << "...";
  82 }
  83
  84 void factor_vm::print_tuple(ostream& out, tuple* tuple, cell nesting) {
  85   tuple_layout* layout = untag<tuple_layout>(tuple->layout);
  86   cell length = to_cell(layout->size);
  87
  88   out << " ";
  89   print_nested_obj(out, layout->klass, nesting);
  90
  91   bool trimmed;
  92   if (length > 10 && !full_output) {
  93     trimmed = true;
  94     length = 10;
  95   } else
  96     trimmed = false;
  97
  98   for (cell i = 0; i < length; i++) {
  99     out << " ";
 100     print_nested_obj(out, tuple->data()[i], nesting);
 101   }
 102
 103   if (trimmed)
 104     out << "...";
 105 }
 106
 107 void factor_vm::print_nested_obj(ostream& out, cell obj, fixnum nesting) {
 108   if (nesting <= 0 && !full_output) {
 109     out << " ... ";
 110     return;
 111   }
 112
 113   quotation* quot;
 114
 115   switch (tagged<object>(obj).type()) {
 116     case FIXNUM_TYPE:
 117       out << untag_fixnum(obj);
 118       break;
 119     case FLOAT_TYPE:
 120       out << untag_float(obj);
 121       break;
 122     case WORD_TYPE:
 123       print_word(out, untag<word>(obj), nesting - 1);
 124       break;
 125     case STRING_TYPE:
 126       print_factor_string(out, untag<string>(obj));
 127       break;
 128     case F_TYPE:
 129       out << "f";
 130       break;
 131     case TUPLE_TYPE:
 132       out << "T{";
 133       print_tuple(out, untag<tuple>(obj), nesting - 1);
 134       out << " }";
 135       break;
 136     case WRAPPER_TYPE:
 137       out << "W{ ";
 138       print_nested_obj(out, untag<wrapper>(obj)->object, nesting - 1);
 139       out << " }";
 140       break;
 141     case BYTE_ARRAY_TYPE:
 142       out << "B{";
 143       print_byte_array(out, untag<byte_array>(obj), nesting - 1);
 144       out << " }";
 145       break;
 146     case ARRAY_TYPE:
 147       out << "{";
 148       print_array(out, untag<array>(obj), nesting - 1);
 149       out << " }";
 150       break;
 151     case QUOTATION_TYPE:
 152       out << "[";
 153       quot = untag<quotation>(obj);
 154       print_array(out, untag<array>(quot->array), nesting - 1);
 155       out << " ]";
 156       break;
 157     case ALIEN_TYPE:
 158       print_alien(out, untag<alien>(obj), nesting - 1);
 159       break;
 160     default:
 161       out << "#<" << type_name(tagged<object>(obj).type()) << " @ ";
 162       out << (void*)obj << ">";
 163       break;
 164   }
 165   out << flush;
 166 }
 167
 168 void factor_vm::print_obj(ostream& out, cell obj) {
 169   print_nested_obj(out, obj, 10);
 170 }
 171
 172 void factor_vm::print_objects(ostream& out, cell* start, cell* end) {
 173   for (; start <= end; start++) {
 174     print_obj(out, *start);
 175     cout << endl;
 176   }
 177 }
 178
 179 void factor_vm::print_datastack(ostream& out) {
 180   out << "==== DATA STACK:" << endl;
 181   if (ctx)
 182     print_objects(out,
 183                   (cell*)ctx->datastack_seg->start,
 184                   (cell*)ctx->datastack);
 185   else
 186     out << "*** Context not initialized" << endl;
 187 }
 188
 189 void factor_vm::print_retainstack(ostream& out) {
 190   out << "==== RETAIN STACK:" << endl;
 191   if (ctx)
 192     print_objects(out,
 193                   (cell*)ctx->retainstack_seg->start,
 194                   (cell*)ctx->retainstack);
 195   else
 196     out << "*** Context not initialized" << endl;
 197 }
 198
 199 struct stack_frame_printer {
 200   factor_vm* parent;
 201   ostream& out;
 202
 203   explicit stack_frame_printer(factor_vm* parent, ostream& out)
 204       : parent(parent), out(out) {}
 205   void operator()(cell frame_top, cell size, code_block* owner, cell addr) {
 206     out << endl;
 207     out << "frame: " << (void*)frame_top << " size " << size << endl;
 208     out << "executing: ";
 209     parent->print_obj(out, owner->owner);
 210     out << endl;
 211     out << "scan: ";
 212     parent->print_obj(out, owner->scan(parent, addr));
 213     out << endl;
 214     out << "word/quot addr: ";
 215     out << hex << owner->owner << dec;
 216     out << endl;
 217     out << "word/quot xt: ";
 218     out << hex << owner->entry_point() << dec;
 219     out << endl;
 220     out << "return address: ";
 221     out << hex << addr << dec;
 222     out << endl;
 223   }
 224 };
 225
 226 void factor_vm::print_callstack(ostream& out) {
 227   out << "==== CALL STACK:" << endl;
 228   if (ctx) {
 229     stack_frame_printer printer(this, out);
 230     iterate_callstack(ctx, printer);
 231   } else
 232     out << "*** Context not initialized" << endl;
 233 }
 234
 235 void factor_vm::print_callstack_object(ostream& out, callstack* obj) {
 236   stack_frame_printer printer(this, out);
 237   iterate_callstack_object(obj, printer);
 238 }
 239
 240 struct padded_address {
 241   cell value;
 242
 243   explicit padded_address(cell value) : value(value) {}
 244 };
 245
 246 ostream& operator<<(ostream& out, const padded_address& value) {
 247   char prev = out.fill('0');
 248   out.width(sizeof(cell) * 2);
 249   out << hex << value.value << dec;
 250   out.fill(prev);
 251   return out;
 252 }
 253
 254 void factor_vm::dump_cell(ostream& out, cell x) {
 255   out << padded_address(x) << ": ";
 256   x = *(cell*)x;
 257   out << padded_address(x) << " tag " << TAG(x) << endl;
 258 }
 259
 260 void factor_vm::dump_memory(ostream& out, cell from, cell to) {
 261   from = UNTAG(from);
 262
 263   for (; from <= to; from += sizeof(cell))
 264     dump_cell(out, from);
 265 }
 266
 267 template <typename Generation>
 268 void factor_vm::dump_generation(ostream& out, const char* name, Generation* gen) {
 269   out << name << ": ";
 270   out << "Start=" << gen->start;
 271   out << ", size=" << gen->size;
 272   out << ", end=" << gen->end;
 273   out << endl;
 274 }
 275
 276 void factor_vm::dump_generations(ostream& out) {
 277   out << hex;
 278
 279   dump_generation(out, "Nursery", &nursery);
 280   dump_generation(out, "Aging", data->aging);
 281   dump_generation(out, "Tenured", data->tenured);
 282
 283   out << "Cards:";
 284   out << "base=" << (cell)data->cards << ", ";
 285   out << "size=" << (cell)(data->cards_end - data->cards) << endl;
 286   out << dec;
 287 }
 288
 289 struct object_dumper {
 290   factor_vm* parent;
 291   cell type;
 292   ostream& out;
 293
 294   object_dumper(factor_vm* parent, cell type, ostream& out)
 295       : parent(parent), type(type), out(out) {}
 296
 297   void operator()(object* obj) {
 298     if (type == TYPE_COUNT || obj->type() == type) {
 299       out << padded_address((cell)obj) << " ";
 300       parent->print_nested_obj(out, tag_dynamic(obj), 2);
 301       out << endl;
 302     }
 303   }
 304 };
 305
 306 void factor_vm::dump_objects(ostream& out, cell type) {
 307   primitive_full_gc();
 308   object_dumper dumper(this, type, out);
 309   each_object(dumper);
 310 }
 311
 312 struct find_data_reference_slot_visitor {
 313   cell look_for;
 314   object* obj;
 315   factor_vm* parent;
 316   ostream& out;
 317
 318   find_data_reference_slot_visitor(cell look_for,
 319                                    object* obj,
 320                                    factor_vm* parent,
 321                                    ostream& out)
 322     : look_for(look_for), obj(obj), parent(parent), out(out) {}
 323
 324   void operator()(cell* scan) {
 325     if (look_for == *scan) {
 326       out << padded_address((cell)obj) << " ";
 327       parent->print_nested_obj(out, tag_dynamic(obj), 2);
 328       out << endl;
 329     }
 330   }
 331 };
 332
 333 struct dump_edges_slot_visitor {
 334   object* obj;
 335   factor_vm* parent;
 336   ostream& out;
 337
 338   dump_edges_slot_visitor(cell, object* obj, factor_vm* parent, ostream& out)
 339       : obj(obj), parent(parent), out(out) {}
 340
 341   void operator()(cell* scan) {
 342     if (TAG(*scan) > F_TYPE)
 343       out << (void*)tag_dynamic(obj) << " ==> " << (void*)*scan << endl;
 344   }
 345 };
 346
 347 template <typename SlotVisitor> struct data_reference_object_visitor {
 348   cell look_for;
 349   factor_vm* parent;
 350   ostream& out;
 351
 352   data_reference_object_visitor(cell look_for, factor_vm* parent, ostream& out)
 353       : look_for(look_for), parent(parent), out(out) {}
 354
 355   void operator()(object* obj) {
 356     SlotVisitor visitor(look_for, obj, parent, out);
 357     obj->each_slot(visitor);
 358   }
 359 };
 360
 361 void factor_vm::find_data_references(ostream& out, cell look_for) {
 362   data_reference_object_visitor<find_data_reference_slot_visitor>
 363       visitor(look_for, this, out);
 364   each_object(visitor);
 365 }
 366
 367 void factor_vm::dump_edges(ostream& out) {
 368   data_reference_object_visitor<dump_edges_slot_visitor> visitor(0, this, out);
 369   each_object(visitor);
 370 }
 371
 372 struct code_block_printer {
 373   factor_vm* parent;
 374   ostream& out;
 375   cell reloc_size, parameter_size;
 376
 377   explicit code_block_printer(factor_vm* parent, ostream& out)
 378       : parent(parent), out(out), reloc_size(0), parameter_size(0) {}
 379
 380   void operator()(code_block* scan, cell size) {
 381     const char* status;
 382     if (scan->free_p())
 383       status = "free";
 384     else {
 385       reloc_size += parent->object_size(scan->relocation);
 386       parameter_size += parent->object_size(scan->parameters);
 387
 388       if (parent->code->allocator->state.marked_p((cell)scan))
 389         status = "marked";
 390       else
 391         status = "allocated";
 392
 393       out << hex << (cell)scan << dec << " ";
 394       out << hex << size << dec << " ";
 395       out << status << " ";
 396       out << "stack frame " << scan->stack_frame_size();
 397       out << endl;
 398     }
 399   }
 400 };
 401
 402 /* Dump all code blocks for debugging */
 403 void factor_vm::dump_code_heap(ostream& out) {
 404   code_block_printer printer(this, out);
 405   code->allocator->iterate(printer);
 406   out << printer.reloc_size << " bytes used by relocation tables" << endl;
 407   out << printer.parameter_size << " bytes used by parameter tables" << endl;
 408 }
 409
 410 void factor_vm::factorbug_usage(bool advanced_p) {
 411   cout << "Basic commands:" << endl;
 412 #ifdef WINDOWS
 413   cout << "  q ^Z             -- quit Factor" << endl;
 414 #else
 415   cout << "  q ^D             -- quit Factor" << endl;
 416 #endif
 417   cout << "  c                -- continue executing Factor - NOT SAFE"
 418        << endl;
 419   cout << "  t                -- throw exception in Factor - NOT SAFE"
 420        << endl;
 421   cout << "  .s .r .c         -- print data, retain, call stacks"
 422        << endl;
 423   if (advanced_p) {
 424     cout << "  help             -- reprint this message" << endl;
 425     cout << "Advanced commands:" << endl;
 426     cout << "  e                -- dump environment" << endl;
 427     cout << "  d <addr> <count> -- dump memory" << endl;
 428     cout << "  u <addr>         -- dump object at tagged <addr>"
 429          << endl;
 430     cout << "  . <addr>         -- print object at tagged <addr>"
 431          << endl;
 432     cout << "  g                -- dump generations" << endl;
 433     cout << "  ds dr            -- dump data, retain stacks" << endl;
 434     cout << "  trim             -- toggle output trimming" << endl;
 435     cout << "  data             -- data heap dump" << endl;
 436     cout << "  words            -- words dump" << endl;
 437     cout << "  tuples           -- tuples dump" << endl;
 438     cout << "  edges            -- print all object-to-object references"
 439          << endl;
 440     cout << "  refs <addr>      -- find data heap references to object"
 441          << endl;
 442     cout << "  push <addr>      -- push object on data stack - NOT SAFE"
 443          << endl;
 444     cout << "  gc               -- trigger full GC - NOT SAFE"
 445          << endl;
 446     cout << "  compact-gc       -- trigger compacting GC - NOT SAFE"
 447          << endl;
 448     cout << "  code             -- code heap dump" << endl;
 449     cout << "  abort            -- call abort()" << endl;
 450     cout << "  breakpoint       -- trigger system breakpoint" << endl;
 451   } else {
 452     cout << "  help             -- full help, including advanced commands"
 453          << endl;
 454   }
 455   cout << endl;
 456 }
 457
 458 static void exit_fep(factor_vm* vm) {
 459   vm->unlock_console();
 460   vm->handle_ctrl_c();
 461   vm->fep_p = false;
 462 }
 463
 464 void factor_vm::factorbug() {
 465   if (fep_disabled) {
 466     cout << "Low level debugger disabled" << endl;
 467     exit(1);
 468   }
 469
 470   if (sampling_profiler_p)
 471     end_sampling_profiler();
 472
 473   fep_p = true;
 474
 475   cout << "Starting low level debugger..." << endl;
 476
 477   // Even though we've stopped the VM, the stdin_loop thread (see os-*.cpp)
 478   // that pumps the console is still running concurrently. We lock a mutex so
 479   // the thread will take a break and give us exclusive access to stdin.
 480   lock_console();
 481   ignore_ctrl_c();
 482
 483   if (!fep_help_was_shown) {
 484     factorbug_usage(false);
 485     fep_help_was_shown = true;
 486   }
 487   bool seen_command = false;
 488
 489   for (;;) {
 490     std::string cmd;
 491
 492     cout << "> " << flush;
 493
 494     cin >> setw(1024) >> cmd >> setw(0);
 495     if (!cin.good()) {
 496       if (!seen_command) {
 497         /* If we exit with an EOF immediately, then
 498            dump stacks. This is useful for builder and
 499            other cases where Factor is run with stdin
 500            redirected to /dev/null */
 501         fep_disabled = true;
 502
 503         print_datastack(cout);
 504         print_retainstack(cout);
 505         print_callstack(cout);
 506       }
 507
 508       exit(1);
 509     }
 510
 511     seen_command = true;
 512
 513     if (cmd == "q")
 514       exit(1);
 515     if (cmd == "d") {
 516       cell addr = read_cell_hex();
 517       if (cin.peek() == ' ')
 518         cin.ignore();
 519
 520       if (!cin.good())
 521         break;
 522       cell count = read_cell_hex();
 523       dump_memory(cout, addr, addr + count);
 524     } else if (cmd == "u") {
 525       cell addr = read_cell_hex();
 526       cell count = object_size(addr);
 527       dump_memory(cout, addr, addr + count);
 528     } else if (cmd == ".") {
 529       cell addr = read_cell_hex();
 530       print_obj(cout, addr);
 531       cout << endl;
 532     } else if (cmd == "trim")
 533       full_output = !full_output;
 534     else if (cmd == "ds")
 535       dump_memory(cout, ctx->datastack_seg->start, ctx->datastack);
 536     else if (cmd == "dr")
 537       dump_memory(cout, ctx->retainstack_seg->start, ctx->retainstack);
 538     else if (cmd == ".s")
 539       print_datastack(cout);
 540     else if (cmd == ".r")
 541       print_retainstack(cout);
 542     else if (cmd == ".c")
 543       print_callstack(cout);
 544     else if (cmd == "e") {
 545       for (cell i = 0; i < special_object_count; i++)
 546         dump_cell(cout, (cell)&special_objects[i]);
 547     } else if (cmd == "g")
 548       dump_generations(cout);
 549     else if (cmd == "c") {
 550       exit_fep(this);
 551       return;
 552     } else if (cmd == "t") {
 553       exit_fep(this);
 554       general_error(ERROR_INTERRUPT, false_object, false_object);
 555       FACTOR_ASSERT(false);
 556     } else if (cmd == "data")
 557       dump_objects(cout, TYPE_COUNT);
 558     else if (cmd == "edges")
 559       dump_edges(cout);
 560     else if (cmd == "refs") {
 561       cell addr = read_cell_hex();
 562       cout << "Data heap references:" << endl;
 563       find_data_references(cout, addr);
 564       cout << endl;
 565     } else if (cmd == "words")
 566       dump_objects(cout, WORD_TYPE);
 567     else if (cmd == "tuples")
 568       dump_objects(cout, TUPLE_TYPE);
 569     else if (cmd == "push") {
 570       cell addr = read_cell_hex();
 571       ctx->push(addr);
 572     } else if (cmd == "code")
 573       dump_code_heap(cout);
 574     else if (cmd == "compact-gc")
 575       primitive_compact_gc();
 576     else if (cmd == "gc")
 577       primitive_full_gc();
 578     else if (cmd == "compact-gc")
 579       primitive_compact_gc();
 580     else if (cmd == "help")
 581       factorbug_usage(true);
 582     else if (cmd == "abort")
 583       abort();
 584     else if (cmd == "breakpoint")
 585       breakpoint();
 586     else
 587       cout << "unknown command" << endl;
 588   }
 589 }
 590
 591 void factor_vm::primitive_die() {
 592   cout << "The die word was called by the library. Unless you called it "
 593       "yourself," << endl;
 594   cout << "you have triggered a bug in Factor. Please report."
 595        << endl;
 596   factorbug();
 597 }
 598
 599 }