vm/debug.cpp

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