vm/debug.cpp

   1 #include "master.hpp"
   2
   3 namespace factor
   4 {
   5
   6
   7 void factorvm::print_chars(string* str)
   8 {
   9         cell i;
  10         for(i = 0; i < string_capacity(str); i++)
  11                 putchar(string_nth(str,i));
  12 }
  13
  14
  15 void factorvm::print_word(word* word, cell nesting)
  16 {
  17         if(tagged<object>(word->vocabulary).type_p(STRING_TYPE))
  18         {
  19                 print_chars(untag<string>(word->vocabulary));
  20                 print_string(":");
  21         }
  22
  23         if(tagged<object>(word->name).type_p(STRING_TYPE))
  24                 print_chars(untag<string>(word->name));
  25         else
  26         {
  27                 print_string("#<not a string: ");
  28                 print_nested_obj(word->name,nesting);
  29                 print_string(">");
  30         }
  31 }
  32
  33
  34 void factorvm::print_factor_string(string* str)
  35 {
  36         putchar('"');
  37         print_chars(str);
  38         putchar('"');
  39 }
  40
  41
  42 void factorvm::print_array(array* array, cell nesting)
  43 {
  44         cell length = array_capacity(array);
  45         cell i;
  46         bool trimmed;
  47
  48         if(length > 10 && !full_output)
  49         {
  50                 trimmed = true;
  51                 length = 10;
  52         }
  53         else
  54                 trimmed = false;
  55
  56         for(i = 0; i < length; i++)
  57         {
  58                 print_string(" ");
  59                 print_nested_obj(array_nth(array,i),nesting);
  60         }
  61
  62         if(trimmed)
  63                 print_string("...");
  64 }
  65
  66
  67 void factorvm::print_tuple(tuple *tuple, cell nesting)
  68 {
  69         tuple_layout *layout = untag<tuple_layout>(tuple->layout);
  70         cell length = to_fixnum(layout->size);
  71
  72         print_string(" ");
  73         print_nested_obj(layout->klass,nesting);
  74
  75         cell i;
  76         bool trimmed;
  77
  78         if(length > 10 && !full_output)
  79         {
  80                 trimmed = true;
  81                 length = 10;
  82         }
  83         else
  84                 trimmed = false;
  85
  86         for(i = 0; i < length; i++)
  87         {
  88                 print_string(" ");
  89                 print_nested_obj(tuple->data()[i],nesting);
  90         }
  91
  92         if(trimmed)
  93                 print_string("...");
  94 }
  95
  96
  97 void factorvm::print_nested_obj(cell obj, fixnum nesting)
  98 {
  99         if(nesting <= 0 && !full_output)
 100         {
 101                 print_string(" ... ");
 102                 return;
 103         }
 104
 105         quotation *quot;
 106
 107         switch(tagged<object>(obj).type())
 108         {
 109         case FIXNUM_TYPE:
 110                 print_fixnum(untag_fixnum(obj));
 111                 break;
 112         case WORD_TYPE:
 113                 print_word(untag<word>(obj),nesting - 1);
 114                 break;
 115         case STRING_TYPE:
 116                 print_factor_string(untag<string>(obj));
 117                 break;
 118         case F_TYPE:
 119                 print_string("f");
 120                 break;
 121         case TUPLE_TYPE:
 122                 print_string("T{");
 123                 print_tuple(untag<tuple>(obj),nesting - 1);
 124                 print_string(" }");
 125                 break;
 126         case ARRAY_TYPE:
 127                 print_string("{");
 128                 print_array(untag<array>(obj),nesting - 1);
 129                 print_string(" }");
 130                 break;
 131         case QUOTATION_TYPE:
 132                 print_string("[");
 133                 quot = untag<quotation>(obj);
 134                 print_array(untag<array>(quot->array),nesting - 1);
 135                 print_string(" ]");
 136                 break;
 137         default:
 138                 print_string("#<type ");
 139                 print_cell(tagged<object>(obj).type());
 140                 print_string(" @ ");
 141                 print_cell_hex(obj);
 142                 print_string(">");
 143                 break;
 144         }
 145 }
 146
 147
 148 void factorvm::print_obj(cell obj)
 149 {
 150         print_nested_obj(obj,10);
 151 }
 152
 153
 154 void factorvm::print_objects(cell *start, cell *end)
 155 {
 156         for(; start <= end; start++)
 157         {
 158                 print_obj(*start);
 159                 nl();
 160         }
 161 }
 162
 163
 164 void factorvm::print_datastack()
 165 {
 166         print_string("==== DATA STACK:\n");
 167         print_objects((cell *)ds_bot,(cell *)ds);
 168 }
 169
 170
 171 void factorvm::print_retainstack()
 172 {
 173         print_string("==== RETAIN STACK:\n");
 174         print_objects((cell *)rs_bot,(cell *)rs);
 175 }
 176
 177
 178 void factorvm::print_stack_frame(stack_frame *frame)
 179 {
 180         print_obj(frame_executing(frame));
 181         print_string("\n");
 182         print_obj(frame_scan(frame));
 183         print_string("\n");
 184         print_string("word/quot addr: ");
 185         print_cell_hex((cell)frame_executing(frame));
 186         print_string("\n");
 187         print_string("word/quot xt: ");
 188         print_cell_hex((cell)frame->xt);
 189         print_string("\n");
 190         print_string("return address: ");
 191         print_cell_hex((cell)FRAME_RETURN_ADDRESS(frame));
 192         print_string("\n");
 193 }
 194
 195 void print_stack_frame(stack_frame *frame, factorvm *myvm)
 196 {
 197         return myvm->print_stack_frame(frame);
 198 }
 199
 200 void factorvm::print_callstack()
 201 {
 202         print_string("==== CALL STACK:\n");
 203         cell bottom = (cell)stack_chain->callstack_bottom;
 204         cell top = (cell)stack_chain->callstack_top;
 205         iterate_callstack(top,bottom,factor::print_stack_frame);
 206 }
 207
 208
 209 void factorvm::dump_cell(cell x)
 210 {
 211         print_cell_hex_pad(x); print_string(": ");
 212         x = *(cell *)x;
 213         print_cell_hex_pad(x); print_string(" tag "); print_cell(TAG(x));
 214         nl();
 215 }
 216
 217
 218 void factorvm::dump_memory(cell from, cell to)
 219 {
 220         from = UNTAG(from);
 221
 222         for(; from <= to; from += sizeof(cell))
 223                 dump_cell(from);
 224 }
 225
 226
 227 void factorvm::dump_zone(zone *z)
 228 {
 229         print_string("Start="); print_cell(z->start);
 230         print_string(", size="); print_cell(z->size);
 231         print_string(", here="); print_cell(z->here - z->start); nl();
 232 }
 233
 234
 235 void factorvm::dump_generations()
 236 {
 237         cell i;
 238
 239         print_string("Nursery: ");
 240         dump_zone(&nursery);
 241
 242         for(i = 1; i < data->gen_count; i++)
 243         {
 244                 print_string("Generation "); print_cell(i); print_string(": ");
 245                 dump_zone(&data->generations[i]);
 246         }
 247
 248         for(i = 0; i < data->gen_count; i++)
 249         {
 250                 print_string("Semispace "); print_cell(i); print_string(": ");
 251                 dump_zone(&data->semispaces[i]);
 252         }
 253
 254         print_string("Cards: base=");
 255         print_cell((cell)data->cards);
 256         print_string(", size=");
 257         print_cell((cell)(data->cards_end - data->cards));
 258         nl();
 259 }
 260
 261
 262 void factorvm::dump_objects(cell type)
 263 {
 264         gc();
 265         begin_scan();
 266
 267         cell obj;
 268         while((obj = next_object()) != F)
 269         {
 270                 if(type == TYPE_COUNT || tagged<object>(obj).type_p(type))
 271                 {
 272                         print_cell_hex_pad(obj);
 273                         print_string(" ");
 274                         print_nested_obj(obj,2);
 275                         nl();
 276                 }
 277         }
 278
 279         end_scan();
 280 }
 281
 282
 283
 284 void factorvm::find_data_references_step(cell *scan)
 285 {
 286         if(look_for == *scan)
 287         {
 288                 print_cell_hex_pad(obj);
 289                 print_string(" ");
 290                 print_nested_obj(obj,2);
 291                 nl();
 292         }
 293 }
 294
 295 void find_data_references_step(cell *scan,factorvm *myvm)
 296 {
 297         return myvm->find_data_references_step(scan);
 298 }
 299
 300 void factorvm::find_data_references(cell look_for_)
 301 {
 302         look_for = look_for_;
 303
 304         begin_scan();
 305
 306         while((obj = next_object()) != F)
 307                 do_slots(UNTAG(obj),factor::find_data_references_step);
 308
 309         end_scan();
 310 }
 311
 312
 313 /* Dump all code blocks for debugging */
 314 void factorvm::dump_code_heap()
 315 {
 316         cell reloc_size = 0, literal_size = 0;
 317
 318         heap_block *scan = first_block(&code);
 319
 320         while(scan)
 321         {
 322                 const char *status;
 323                 switch(scan->status)
 324                 {
 325                 case B_FREE:
 326                         status = "free";
 327                         break;
 328                 case B_ALLOCATED:
 329                         reloc_size += object_size(((code_block *)scan)->relocation);
 330                         literal_size += object_size(((code_block *)scan)->literals);
 331                         status = "allocated";
 332                         break;
 333                 case B_MARKED:
 334                         reloc_size += object_size(((code_block *)scan)->relocation);
 335                         literal_size += object_size(((code_block *)scan)->literals);
 336                         status = "marked";
 337                         break;
 338                 default:
 339                         status = "invalid";
 340                         break;
 341                 }
 342
 343                 print_cell_hex((cell)scan); print_string(" ");
 344                 print_cell_hex(scan->size); print_string(" ");
 345                 print_string(status); print_string("\n");
 346
 347                 scan = next_block(&code,scan);
 348         }
 349
 350         print_cell(reloc_size); print_string(" bytes of relocation data\n");
 351         print_cell(literal_size); print_string(" bytes of literal data\n");
 352 }
 353
 354
 355 void factorvm::factorbug()
 356 {
 357         if(fep_disabled)
 358         {
 359                 print_string("Low level debugger disabled\n");
 360                 exit(1);
 361         }
 362
 363         /* open_console(); */
 364
 365         print_string("Starting low level debugger...\n");
 366         print_string("  Basic commands:\n");
 367         print_string("q                -- continue executing Factor - NOT SAFE\n");
 368         print_string("im               -- save image to fep.image\n");
 369         print_string("x                -- exit Factor\n");
 370         print_string("  Advanced commands:\n");
 371         print_string("d <addr> <count> -- dump memory\n");
 372         print_string("u <addr>         -- dump object at tagged <addr>\n");
 373         print_string(". <addr>         -- print object at tagged <addr>\n");
 374         print_string("t                -- toggle output trimming\n");
 375         print_string("s r              -- dump data, retain stacks\n");
 376         print_string(".s .r .c         -- print data, retain, call stacks\n");
 377         print_string("e                -- dump environment\n");
 378         print_string("g                -- dump generations\n");
 379         print_string("card <addr>      -- print card containing address\n");
 380         print_string("addr <card>      -- print address containing card\n");
 381         print_string("data             -- data heap dump\n");
 382         print_string("words            -- words dump\n");
 383         print_string("tuples           -- tuples dump\n");
 384         print_string("refs <addr>      -- find data heap references to object\n");
 385         print_string("push <addr>      -- push object on data stack - NOT SAFE\n");
 386         print_string("code             -- code heap dump\n");
 387
 388         bool seen_command = false;
 389
 390         for(;;)
 391         {
 392                 char cmd[1024];
 393
 394                 print_string("READY\n");
 395                 fflush(stdout);
 396
 397                 if(scanf("%1000s",cmd) <= 0)
 398                 {
 399                         if(!seen_command)
 400                         {
 401                                 /* If we exit with an EOF immediately, then
 402                                 dump stacks. This is useful for builder and
 403                                 other cases where Factor is run with stdin
 404                                 redirected to /dev/null */
 405                                 fep_disabled = true;
 406
 407                                 print_datastack();
 408                                 print_retainstack();
 409                                 print_callstack();
 410                         }
 411
 412                         exit(1);
 413                 }
 414
 415                 seen_command = true;
 416
 417                 if(strcmp(cmd,"d") == 0)
 418                 {
 419                         cell addr = read_cell_hex();
 420                         if(scanf(" ") < 0) break;
 421                         cell count = read_cell_hex();
 422                         dump_memory(addr,addr+count);
 423                 }
 424                 else if(strcmp(cmd,"u") == 0)
 425                 {
 426                         cell addr = read_cell_hex();
 427                         cell count = object_size(addr);
 428                         dump_memory(addr,addr+count);
 429                 }
 430                 else if(strcmp(cmd,".") == 0)
 431                 {
 432                         cell addr = read_cell_hex();
 433                         print_obj(addr);
 434                         print_string("\n");
 435                 }
 436                 else if(strcmp(cmd,"t") == 0)
 437                         full_output = !full_output;
 438                 else if(strcmp(cmd,"s") == 0)
 439                         dump_memory(ds_bot,ds);
 440                 else if(strcmp(cmd,"r") == 0)
 441                         dump_memory(rs_bot,rs);
 442                 else if(strcmp(cmd,".s") == 0)
 443                         print_datastack();
 444                 else if(strcmp(cmd,".r") == 0)
 445                         print_retainstack();
 446                 else if(strcmp(cmd,".c") == 0)
 447                         print_callstack();
 448                 else if(strcmp(cmd,"e") == 0)
 449                 {
 450                         int i;
 451                         for(i = 0; i < USER_ENV; i++)
 452                                 dump_cell((cell)&userenv[i]);
 453                 }
 454                 else if(strcmp(cmd,"g") == 0)
 455                         dump_generations();
 456                 else if(strcmp(cmd,"card") == 0)
 457                 {
 458                         cell addr = read_cell_hex();
 459                         print_cell_hex((cell)addr_to_card(addr));
 460                         nl();
 461                 }
 462                 else if(strcmp(cmd,"addr") == 0)
 463                 {
 464                         card *ptr = (card *)read_cell_hex();
 465                         print_cell_hex(card_to_addr(ptr));
 466                         nl();
 467                 }
 468                 else if(strcmp(cmd,"q") == 0)
 469                         return;
 470                 else if(strcmp(cmd,"x") == 0)
 471                         exit(1);
 472                 else if(strcmp(cmd,"im") == 0)
 473                         save_image(STRING_LITERAL("fep.image"));
 474                 else if(strcmp(cmd,"data") == 0)
 475                         dump_objects(TYPE_COUNT);
 476                 else if(strcmp(cmd,"refs") == 0)
 477                 {
 478                         cell addr = read_cell_hex();
 479                         print_string("Data heap references:\n");
 480                         find_data_references(addr);
 481                         nl();
 482                 }
 483                 else if(strcmp(cmd,"words") == 0)
 484                         dump_objects(WORD_TYPE);
 485                 else if(strcmp(cmd,"tuples") == 0)
 486                         dump_objects(TUPLE_TYPE);
 487                 else if(strcmp(cmd,"push") == 0)
 488                 {
 489                         cell addr = read_cell_hex();
 490                         dpush(addr);
 491                 }
 492                 else if(strcmp(cmd,"code") == 0)
 493                         dump_code_heap();
 494                 else
 495                         print_string("unknown command\n");
 496         }
 497 }
 498
 499
 500 inline void factorvm::primitive_die()
 501 {
 502         print_string("The die word was called by the library. Unless you called it yourself,\n");
 503         print_string("you have triggered a bug in Factor. Please report.\n");
 504         factorbug();
 505 }
 506
 507 PRIMITIVE(die)
 508 {
 509         PRIMITIVE_GETVM()->primitive_die();
 510 }
 511
 512 }