vm/debug.cpp

   1 #include "master.hpp"
   2
   3 namespace factor
   4 {
   5
   6 void factorvm::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 factorvm::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 factorvm::print_factor_string(string* str)
  32 {
  33         putchar('"');
  34         print_chars(str);
  35         putchar('"');
  36 }
  37
  38 void factorvm::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 factorvm::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 factorvm::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 factorvm::print_obj(cell obj)
 142 {
 143         print_nested_obj(obj,10);
 144 }
 145
 146 void factorvm::print_objects(cell *start, cell *end)
 147 {
 148         for(; start <= end; start++)
 149         {
 150                 print_obj(*start);
 151                 nl();
 152         }
 153 }
 154
 155 void factorvm::print_datastack()
 156 {
 157         print_string("==== DATA STACK:\n");
 158         print_objects((cell *)ds_bot,(cell *)ds);
 159 }
 160
 161 void factorvm::print_retainstack()
 162 {
 163         print_string("==== RETAIN STACK:\n");
 164         print_objects((cell *)rs_bot,(cell *)rs);
 165 }
 166
 167 void factorvm::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, factorvm *myvm)
 185 {
 186         return myvm->print_stack_frame(frame);
 187 }
 188
 189 void factorvm::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 factorvm::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 factorvm::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 factorvm::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 factorvm::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 factorvm::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
 267 void factorvm::find_data_references_step(cell *scan)
 268 {
 269         if(look_for == *scan)
 270         {
 271                 print_cell_hex_pad(obj);
 272                 print_string(" ");
 273                 print_nested_obj(obj,2);
 274                 nl();
 275         }
 276 }
 277
 278 void find_data_references_step(cell *scan,factorvm *myvm)
 279 {
 280         return myvm->find_data_references_step(scan);
 281 }
 282
 283 void factorvm::find_data_references(cell look_for_)
 284 {
 285         look_for = look_for_;
 286
 287         begin_scan();
 288
 289         while((obj = next_object()) != F)
 290                 do_slots(UNTAG(obj),factor::find_data_references_step);
 291
 292         end_scan();
 293 }
 294
 295 /* Dump all code blocks for debugging */
 296 void factorvm::dump_code_heap()
 297 {
 298         cell reloc_size = 0, literal_size = 0;
 299
 300         heap_block *scan = first_block(&code);
 301
 302         while(scan)
 303         {
 304                 const char *status;
 305                 switch(scan->status)
 306                 {
 307                 case B_FREE:
 308                         status = "free";
 309                         break;
 310                 case B_ALLOCATED:
 311                         reloc_size += object_size(((code_block *)scan)->relocation);
 312                         literal_size += object_size(((code_block *)scan)->literals);
 313                         status = "allocated";
 314                         break;
 315                 case B_MARKED:
 316                         reloc_size += object_size(((code_block *)scan)->relocation);
 317                         literal_size += object_size(((code_block *)scan)->literals);
 318                         status = "marked";
 319                         break;
 320                 default:
 321                         status = "invalid";
 322                         break;
 323                 }
 324
 325                 print_cell_hex((cell)scan); print_string(" ");
 326                 print_cell_hex(scan->size); print_string(" ");
 327                 print_string(status); print_string("\n");
 328
 329                 scan = next_block(&code,scan);
 330         }
 331
 332         print_cell(reloc_size); print_string(" bytes of relocation data\n");
 333         print_cell(literal_size); print_string(" bytes of literal data\n");
 334 }
 335
 336 void factorvm::factorbug()
 337 {
 338         if(fep_disabled)
 339         {
 340                 print_string("Low level debugger disabled\n");
 341                 exit(1);
 342         }
 343
 344         /* open_console(); */
 345
 346         print_string("Starting low level debugger...\n");
 347         print_string("  Basic commands:\n");
 348         print_string("q                -- continue executing Factor - NOT SAFE\n");
 349         print_string("im               -- save image to fep.image\n");
 350         print_string("x                -- exit Factor\n");
 351         print_string("  Advanced commands:\n");
 352         print_string("d <addr> <count> -- dump memory\n");
 353         print_string("u <addr>         -- dump object at tagged <addr>\n");
 354         print_string(". <addr>         -- print object at tagged <addr>\n");
 355         print_string("t                -- toggle output trimming\n");
 356         print_string("s r              -- dump data, retain stacks\n");
 357         print_string(".s .r .c         -- print data, retain, call stacks\n");
 358         print_string("e                -- dump environment\n");
 359         print_string("g                -- dump generations\n");
 360         print_string("card <addr>      -- print card containing address\n");
 361         print_string("addr <card>      -- print address containing card\n");
 362         print_string("data             -- data heap dump\n");
 363         print_string("words            -- words dump\n");
 364         print_string("tuples           -- tuples dump\n");
 365         print_string("refs <addr>      -- find data heap references to object\n");
 366         print_string("push <addr>      -- push object on data stack - NOT SAFE\n");
 367         print_string("code             -- code heap dump\n");
 368
 369         bool seen_command = false;
 370
 371         for(;;)
 372         {
 373                 char cmd[1024];
 374
 375                 print_string("READY\n");
 376                 fflush(stdout);
 377
 378                 if(scanf("%1000s",cmd) <= 0)
 379                 {
 380                         if(!seen_command)
 381                         {
 382                                 /* If we exit with an EOF immediately, then
 383                                 dump stacks. This is useful for builder and
 384                                 other cases where Factor is run with stdin
 385                                 redirected to /dev/null */
 386                                 fep_disabled = true;
 387
 388                                 print_datastack();
 389                                 print_retainstack();
 390                                 print_callstack();
 391                         }
 392
 393                         exit(1);
 394                 }
 395
 396                 seen_command = true;
 397
 398                 if(strcmp(cmd,"d") == 0)
 399                 {
 400                         cell addr = read_cell_hex();
 401                         if(scanf(" ") < 0) break;
 402                         cell count = read_cell_hex();
 403                         dump_memory(addr,addr+count);
 404                 }
 405                 else if(strcmp(cmd,"u") == 0)
 406                 {
 407                         cell addr = read_cell_hex();
 408                         cell count = object_size(addr);
 409                         dump_memory(addr,addr+count);
 410                 }
 411                 else if(strcmp(cmd,".") == 0)
 412                 {
 413                         cell addr = read_cell_hex();
 414                         print_obj(addr);
 415                         print_string("\n");
 416                 }
 417                 else if(strcmp(cmd,"t") == 0)
 418                         full_output = !full_output;
 419                 else if(strcmp(cmd,"s") == 0)
 420                         dump_memory(ds_bot,ds);
 421                 else if(strcmp(cmd,"r") == 0)
 422                         dump_memory(rs_bot,rs);
 423                 else if(strcmp(cmd,".s") == 0)
 424                         print_datastack();
 425                 else if(strcmp(cmd,".r") == 0)
 426                         print_retainstack();
 427                 else if(strcmp(cmd,".c") == 0)
 428                         print_callstack();
 429                 else if(strcmp(cmd,"e") == 0)
 430                 {
 431                         int i;
 432                         for(i = 0; i < USER_ENV; i++)
 433                                 dump_cell((cell)&userenv[i]);
 434                 }
 435                 else if(strcmp(cmd,"g") == 0)
 436                         dump_generations();
 437                 else if(strcmp(cmd,"card") == 0)
 438                 {
 439                         cell addr = read_cell_hex();
 440                         print_cell_hex((cell)addr_to_card(addr));
 441                         nl();
 442                 }
 443                 else if(strcmp(cmd,"addr") == 0)
 444                 {
 445                         card *ptr = (card *)read_cell_hex();
 446                         print_cell_hex(card_to_addr(ptr));
 447                         nl();
 448                 }
 449                 else if(strcmp(cmd,"q") == 0)
 450                         return;
 451                 else if(strcmp(cmd,"x") == 0)
 452                         exit(1);
 453                 else if(strcmp(cmd,"im") == 0)
 454                         save_image(STRING_LITERAL("fep.image"));
 455                 else if(strcmp(cmd,"data") == 0)
 456                         dump_objects(TYPE_COUNT);
 457                 else if(strcmp(cmd,"refs") == 0)
 458                 {
 459                         cell addr = read_cell_hex();
 460                         print_string("Data heap references:\n");
 461                         find_data_references(addr);
 462                         nl();
 463                 }
 464                 else if(strcmp(cmd,"words") == 0)
 465                         dump_objects(WORD_TYPE);
 466                 else if(strcmp(cmd,"tuples") == 0)
 467                         dump_objects(TUPLE_TYPE);
 468                 else if(strcmp(cmd,"push") == 0)
 469                 {
 470                         cell addr = read_cell_hex();
 471                         dpush(addr);
 472                 }
 473                 else if(strcmp(cmd,"code") == 0)
 474                         dump_code_heap();
 475                 else
 476                         print_string("unknown command\n");
 477         }
 478 }
 479
 480 inline void factorvm::primitive_die()
 481 {
 482         print_string("The die word was called by the library. Unless you called it yourself,\n");
 483         print_string("you have triggered a bug in Factor. Please report.\n");
 484         factorbug();
 485 }
 486
 487 PRIMITIVE(die)
 488 {
 489         PRIMITIVE_GETVM()->primitive_die();
 490 }
 491
 492 }