vm/debug.cpp

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