nsz Git - libfirm/blob - win32/firmEvaluator/firm.c

   1 /*
   2  * Firm - Evaluator
   3  *
   4  * (C) 2005 Michael Beck    beck@ipd.info.uni-karlsruhe.de
   5  */
   6 #define WIN32_LEAN_AND_MEAN
   7 #include <windows.h>
   8 #include <tchar.h>
   9 #include <malloc.h>
  10 #include <stdarg.h>
  11
  12 #include "config.h"
  13
  14 /* ugly, but I must include array.h WITHOUT NDEBUG */
  15 #ifdef NDEBUG
  16 #undef NDEBUG
  17 #include "array_t.h"
  18 #define NDEBUG
  19 #else
  20 #include "array.h"
  21 #endif
  22
  23 #include "entity_t.h"
  24 #include "irgraph_t.h"
  25 #include "irnode_t.h"
  26 #include "irmode_t.h"
  27 #include "tv_t.h"
  28 #include "irloop_t.h"
  29 #include "irextbb_t.h"
  30 #include "irprog_t.h"
  31 #include "compound_path_t.h"
  32 #include "tpop_t.h"
  33 #include "strcalc.h"
  34 #include "fltcalc.h"
  35
  36 #include "set.h"
  37 #include "pset.h"
  38 #include "pdeq.h"
  39 #include "bitset.h"
  40
  41 #include "firmEvaluator.h"
  42
  43 /** get the address of a pointer */
  44 #define ADD_ADR(p, off)  ((void *)((char *)(p) + (off)))
  45
  46 /** debug output */
  47 static void debug(char *fmt, ...)
  48 {
  49   va_list ap;
  50   char buf[1024];
  51
  52   va_start(ap, fmt);
  53   vsprintf(buf, fmt, ap);
  54
  55   OutputDebugString(buf);
  56   va_end(ap);
  57 }  /* debug */
  58
  59 /**
  60  * return the size of a firm object
  61  */
  62 int get_firm_object_size(firm_kind kind)
  63 {
  64   switch (kind) {
  65   case k_entity:     /* an entity */
  66     return sizeof(ir_entity);
  67   case k_type:       /* a type */
  68     return sizeof(ir_type);
  69   case k_ir_graph:   /* an ir graph */
  70     return sizeof(ir_graph);
  71   case k_ir_node:    /* an ir node */
  72     return sizeof(ir_node);
  73   case k_ir_mode:    /* an ir mode */
  74     return sizeof(ir_mode);
  75   case k_ir_op:      /* an ir opcode */
  76     return sizeof(ir_op);
  77   case k_tarval:     /* a tarval */
  78     return sizeof(tarval);
  79   case k_ir_loop:    /* a loop */
  80     return sizeof(ir_loop);
  81   case k_ir_compound_graph_path: /* a compound graph path, see entity.h */
  82     return sizeof(compound_graph_path);
  83   case k_ir_extblk:  /* an extended block */
  84     return sizeof(ir_extblk);
  85   case k_ir_prog:    /* a program representation (irp) */
  86     return sizeof(ir_prog);
  87   default:
  88     return 0;
  89   }
  90 }  /* get_firm_object_size */
  91
  92 /**
  93  * returns the string length of a string in debuggee space
  94  *
  95  * @return string length or negative value on error
  96  */
  97 static int strlen_debuggee(DEBUGHELPER *pHelper, const void *address, size_t max)
  98 {
  99   size_t i;
 100   char v;
 101   const char *p = address;
 102
 103   for (i = 0; i < max; ++i) {
 104     if (copy_from_debuggee(p + i, pHelper, &v, sizeof(v)) != S_OK)
 105       return -1;
 106
 107     if (! v)
 108       return i;
 109   }
 110   return i;
 111 }  /* strlen_debuggee */
 112
 113 /**
 114  * Format an ident
 115  */
 116 HRESULT format_ident(DEBUGHELPER *pHelper, const void *address, char *pResult, size_t max)
 117 {
 118   set_entry *data = NULL;
 119   set_entry id;
 120   size_t len, slen;
 121
 122   if (copy_from_debuggee(address, pHelper, &id, sizeof(id)) != S_OK)
 123     return E_FAIL;
 124
 125   /* safety check */
 126   if (id.size < 1 || id.size > 256)
 127     return E_FAIL;
 128
 129   slen = id.size + 1;
 130   len = offsetof(set_entry, dptr) + slen;
 131
 132   data = alloca(len);
 133
 134   if (copy_from_debuggee(address, pHelper, data, len) != S_OK)
 135     return E_FAIL;
 136
 137   _tcsncpy(pResult, (const char *)data->dptr, max);
 138   return S_OK;
 139 }  /* format_ident */
 140
 141 /**
 142  * Format a tp_op
 143  */
 144 static HRESULT format_tp_op(DEBUGHELPER *pHelper, const void *addr, char *pResult, size_t max)
 145 {
 146   tp_op op;
 147
 148 #define X(a)     case tpo_##a: _tcsncpy(pResult, #a, max); return S_OK
 149 #define Y(a, b)  case tpo_##a: _tcsncpy(pResult, b, max); return S_OK
 150
 151   if (copy_from_debuggee(addr, pHelper, &op, sizeof(op)) != S_OK)
 152     return E_FAIL;
 153
 154   switch (op.code) {
 155   X(uninitialized);
 156   X(class);
 157   X(struct);
 158   X(method);
 159   X(union);
 160   X(array);
 161   Y(enumeration, "enum");
 162   Y(pointer, "ptr");
 163   Y(primitive, "prim");
 164   X(none);
 165   X(unknown);
 166   default:
 167     return E_FAIL;
 168   }
 169 #undef X
 170 #undef Y
 171 }  /* format_tp_op */
 172
 173 /**
 174  * Checks whether a type is the global type
 175  *
 176  * @param type  the address of the type in debuggee's space
 177  */
 178 static HRESULT is_global_type(DEBUGHELPER *pHelper, const void *type, int *flag)
 179 {
 180   ir_type tp;
 181
 182   *flag = 0;
 183   if (copy_from_debuggee(type, pHelper, &tp, sizeof(tp)) != S_OK)
 184     return E_FAIL;
 185
 186   *flag = tp.flags & tf_global_type;
 187   return S_OK;
 188 }  /* is_global_type */
 189
 190 /**
 191  * format an entity
 192  */
 193 static HRESULT format_entity(DEBUGHELPER *pHelper, int nBase, const void *addr, char *pResult, size_t max, int top)
 194 {
 195   ir_entity ent;
 196   ir_type owner;
 197   char name[256];
 198   int is_global;
 199
 200   if (copy_from_debuggee(addr, pHelper, &ent, sizeof(ent)) != S_OK) {
 201     return E_FAIL;
 202   }
 203   if (is_global_type(pHelper, ent.owner, &is_global) != S_OK)
 204     return E_FAIL;
 205
 206   *pResult = '\0';
 207   if (top)
 208     _tcsncpy(pResult, "ENT: ", max);
 209
 210   if (! is_global) {
 211     if (copy_from_debuggee(ent.owner, pHelper, &owner, sizeof(owner)) != S_OK)
 212       return E_FAIL;
 213     if (format_ident(pHelper, (void *)owner.name, name, sizeof(name)) != S_OK)
 214       return E_FAIL;
 215     _tcsncat(pResult, name, max);
 216     _tcsncat(pResult, "::", max);
 217   }
 218
 219   if (format_ident(pHelper, (void *)ent.name, name, sizeof(name)) != S_OK)
 220     return E_FAIL;
 221   _tcsncat(pResult, name, max);
 222
 223   switch (nBase) {
 224   case 16:
 225     _snprintf(name, sizeof(name), " [0x%lx]", ent.nr);
 226     break;
 227   case 8:
 228     _snprintf(name, sizeof(name), " [0%lo]", ent.nr);
 229     break;
 230   default:
 231     _snprintf(name, sizeof(name), " [%ld]", ent.nr);
 232   }
 233   _tcsncat(pResult, name, max);
 234
 235   return S_OK;
 236 }  /* format_entity */
 237
 238 /**
 239  * format a type
 240  */
 241 static HRESULT format_type(DEBUGHELPER *pHelper, int nBase, const void *addr, char *pResult, size_t max, int top)
 242 {
 243   ir_type tp;
 244   char name[256];
 245
 246   if (copy_from_debuggee(addr, pHelper, &tp, sizeof(tp)) != S_OK)
 247     return E_FAIL;
 248
 249   pResult[0] = '\0';
 250   if (top) {
 251     if (format_tp_op(pHelper, tp.type_op, pResult, max) != S_OK)
 252       return E_FAIL;
 253
 254     _tcsncat(pResult, " ", max);
 255   }
 256
 257   if (format_ident(pHelper, tp.name, name, sizeof(name)) != S_OK)
 258     return E_FAIL;
 259
 260   _tcsncat(pResult, name, max);
 261   switch (nBase) {
 262   case 16:
 263     _snprintf(name, sizeof(name), " [0x%lx]", tp.nr);
 264     break;
 265   case 8:
 266     _snprintf(name, sizeof(name), " [0%lo]", tp.nr);
 267     break;
 268   default:
 269     _snprintf(name, sizeof(name), " [%ld]", tp.nr);
 270   }
 271   _tcsncat(pResult, name, max);
 272
 273   return S_OK;
 274 }  /* format_type */
 275
 276 /**
 277  * format an irg
 278  */
 279 static HRESULT format_irg(DEBUGHELPER *pHelper, int nBase, const void *addr, char *pResult, size_t max, int top)
 280 {
 281   ir_graph irg;
 282   char name[256];
 283
 284   if (copy_from_debuggee(addr, pHelper, &irg, sizeof(irg)) != S_OK)
 285     return E_FAIL;
 286
 287   *pResult = '\0';
 288   if (top)
 289     _tcsncpy(pResult, "IRG: ", max);
 290
 291   if (irg.ent) {
 292     ir_entity ent;
 293     ir_type owner;
 294     int is_global;
 295
 296     if (copy_from_debuggee(irg.ent, pHelper, &ent, sizeof(ent)) != S_OK)
 297       return E_FAIL;
 298     if (is_global_type(pHelper, ent.owner, &is_global) != S_OK)
 299       return E_FAIL;
 300     if (! is_global) {
 301       if (copy_from_debuggee(ent.owner, pHelper, &owner, sizeof(owner)) != S_OK)
 302         return E_FAIL;
 303       if (format_ident(pHelper, (void *)owner.name, name, sizeof(name)) != S_OK)
 304         return E_FAIL;
 305       _tcsncat(pResult, name, max);
 306       _tcsncat(pResult, "::", max);
 307     }
 308     if (format_ident(pHelper, ent.name, name, sizeof(name)) != S_OK)
 309       return E_FAIL;
 310     _tcsncat(pResult, name, max);
 311   }
 312   else
 313     _tcsncat(pResult, "NULL", max);
 314
 315   switch (nBase) {
 316   case 16:
 317     _snprintf(name, sizeof(name), " [0x%lx, 0x%u nodes]", irg.graph_nr, irg.last_node_idx);
 318     break;
 319   case 8:
 320     _snprintf(name, sizeof(name), " [0%lo, 0%o nodes]", irg.graph_nr, irg.last_node_idx);
 321     break;
 322   default:
 323     _snprintf(name, sizeof(name), " [%ld, %u nodes]", irg.graph_nr, irg.last_node_idx);
 324   }
 325   _tcsncat(pResult, name, max);
 326   return S_OK;
 327 }  /* format_irg */
 328
 329 /**
 330  * format an ir_op
 331  */
 332 HRESULT format_op(DEBUGHELPER *pHelper, const void *addr, char *pResult, size_t max)
 333 {
 334   ir_op op;
 335
 336   if (copy_from_debuggee(addr, pHelper, &op, sizeof(op)) != S_OK)
 337     return E_FAIL;
 338   if (format_ident(pHelper, op.name, pResult, max) != S_OK)
 339     return E_FAIL;
 340   return S_OK;
 341 }  /* format_op */
 342
 343 /**
 344  * format an ir_mode
 345  */
 346 static HRESULT format_mode(DEBUGHELPER *pHelper, const void *addr, char *pResult, size_t max)
 347 {
 348   ir_mode mode;
 349
 350   if (copy_from_debuggee(addr, pHelper, &mode, sizeof(mode)) != S_OK)
 351     return E_FAIL;
 352   if (format_ident(pHelper, mode.name, pResult, max) != S_OK)
 353     return E_FAIL;
 354   return S_OK;
 355 }  /* format_mode */
 356
 357 /** get a temporary string */
 358 #define get_string(str)                                         \
 359 do {                                                            \
 360   int len;                                                      \
 361   char *s;                                                      \
 362   if (str) {                                                    \
 363     len = strlen_debuggee(pHelper, str, 256);                   \
 364     if (len < 0)                                                \
 365       return E_FAIL;                                            \
 366     s = alloca(len + 1);                                        \
 367     if (copy_from_debuggee(str, pHelper, s, (DWORD)len) != S_OK) \
 368       return E_FAIL;                                            \
 369     s[len] = '\0';                                              \
 370     str = s;                                                    \
 371   }                                                             \
 372 } while (0)
 373
 374 /**
 375  * format a tarval
 376  */
 377 static HRESULT format_tarval(DEBUGHELPER *pHelper, int nBase, const void *addr, char *pResult, size_t max)
 378 {
 379   tarval tv;
 380   char *value;
 381   ir_mode mode;
 382   unsigned len;
 383   tarval_mode_info modinfo;
 384
 385   {
 386     static int initialized = 0;
 387
 388     if (! initialized) {
 389       /* from init_tarval_1() */
 390       init_strcalc(68);
 391       init_fltcalc(0);
 392
 393       initialized = 1;
 394     }
 395   }
 396
 397   if (copy_from_debuggee(addr, pHelper, &tv, sizeof(tv)) != S_OK)
 398     return E_FAIL;
 399
 400   /* ir_mode */
 401   if (tv.mode == NULL)
 402     return E_FAIL;
 403
 404   if (copy_from_debuggee(tv.mode, pHelper, &mode, sizeof(mode)) != S_OK)
 405     return E_FAIL;
 406
 407   tv.mode = &mode;
 408
 409   if (mode_is_int(&mode)) {
 410     switch (nBase) {
 411     case 16:
 412       modinfo.mode_output = TVO_HEX;
 413       modinfo.mode_prefix = "0x";
 414       modinfo.mode_suffix = "";
 415       break;
 416     case 8:
 417       modinfo.mode_output = TVO_OCTAL;
 418       modinfo.mode_prefix = "0";
 419       modinfo.mode_suffix = "";
 420       break;
 421     default:
 422       modinfo.mode_output = TVO_DECIMAL;
 423       modinfo.mode_prefix = "";
 424       modinfo.mode_suffix = "";
 425     }
 426   }
 427   else {
 428     if (mode.tv_priv) {
 429       if (copy_from_debuggee(mode.tv_priv, pHelper, &modinfo, sizeof(modinfo)) != S_OK)
 430         return E_FAIL;
 431
 432       get_string(modinfo.mode_prefix);
 433       get_string(modinfo.mode_suffix);
 434     }
 435   }
 436   mode.tv_priv = &modinfo;
 437
 438   len = tv.length;
 439   if (len) {
 440     if (len > 256)
 441       return E_FAIL;
 442
 443     value = alloca(len);
 444
 445     if (copy_from_debuggee(tv.value, pHelper, value, len) != S_OK)
 446       return E_FAIL;
 447
 448     tv.value = value;
 449
 450     tarval_snprintf(pResult, max, &tv);
 451   }
 452   else {
 453     /* might be a reserved tarval */
 454     int resid = PTR_TO_INT(tv.value);
 455
 456     switch (resid) {
 457     case resid_tarval_bad:
 458       _tcsncat(pResult, "BAD", max);
 459       break;
 460     case resid_tarval_undefined:
 461       _tcsncat(pResult, "UNDEF", max);
 462       break;
 463     case resid_tarval_b_false:
 464       _tcsncat(pResult, "FALSE", max);
 465       break;
 466     case resid_tarval_b_true:
 467       _tcsncat(pResult, "TRUE", max);
 468       break;
 469     default:
 470       /* try it */
 471       tarval_snprintf(pResult, max, &tv);
 472     }
 473   }
 474   return S_OK;
 475 }  /* format_tarval */
 476
 477 /**
 478  * format an ir_node
 479  */
 480 static HRESULT format_node(DEBUGHELPER *pHelper, int nBase, const void *addr, char *pResult, size_t max, int top)
 481 {
 482   ir_node n;
 483   char name[256];
 484   ir_op op;
 485
 486   if (copy_from_debuggee(addr, pHelper, &n, sizeof(n)) != S_OK)
 487     return E_FAIL;
 488
 489   /* ir_op */
 490   if (format_op(pHelper, n.op, pResult, max) != S_OK)
 491     return E_FAIL;
 492
 493   /* ir_mode */
 494   if (format_mode(pHelper, n.mode, name, sizeof(name)) != S_OK)
 495     return E_FAIL;
 496   _tcsncat(pResult, name, max);
 497
 498   if (copy_from_debuggee(n.op, pHelper, &op, sizeof(op)) != S_OK)
 499     return E_FAIL;
 500
 501   /* show show node attributes */
 502   switch (op.code) {
 503   case iro_Const:
 504     if (format_tarval(pHelper, nBase, n.attr.con.tv, name, sizeof(name)) != S_OK) {
 505       _tcsncat(pResult, "<???>", max);
 506     }
 507     else {
 508       _tcsncat(pResult, "<", max);
 509       _tcsncat(pResult, name, max);
 510       _tcsncat(pResult, ">", max);
 511     }
 512     break;
 513   case iro_SymConst:
 514     _tcsncat(pResult, "<", max);
 515     switch (n.attr.symc.kind) {
 516     case symconst_type_tag:
 517       _tcsncat(pResult, "TAG:", max);
 518       if (format_type(pHelper, nBase, n.attr.symc.sym.type_p, name, sizeof(name), 0) != S_OK)
 519         return E_FAIL;
 520       _tcsncat(pResult, name, max);
 521       break;
 522     case symconst_type_size:
 523       _tcsncat(pResult, "SIZE:", max);
 524       if (format_type(pHelper, nBase, n.attr.symc.sym.type_p, name, sizeof(name), 0) != S_OK)
 525         return E_FAIL;
 526       _tcsncat(pResult, name, max);
 527       break;
 528     case symconst_type_align:
 529       _tcsncat(pResult, "ALGN:", max);
 530       if (format_type(pHelper, nBase, n.attr.symc.sym.type_p, name, sizeof(name), 0) != S_OK)
 531         return E_FAIL;
 532       _tcsncat(pResult, name, max);
 533       break;
 534     case symconst_addr_ent:
 535       _tcsncat(pResult, "ENT:", max);
 536       if (format_entity(pHelper, nBase, n.attr.symc.sym.entity_p, name, sizeof(name), 0) != S_OK)
 537         return E_FAIL;
 538       _tcsncat(pResult, name, max);
 539       break;
 540     }
 541     _tcsncat(pResult, ">", max);
 542     break;
 543   case iro_Sel:
 544     _tcsncat(pResult, "<", max);
 545     if (format_entity(pHelper, nBase, n.attr.sel.entity, name, sizeof(name), 0) != S_OK)
 546       return E_FAIL;
 547     _tcsncat(pResult, name, max);
 548     _tcsncat(pResult, ">", max);
 549     break;
 550   case iro_Cast:
 551     _tcsncat(pResult, "<", max);
 552     if (format_type(pHelper, nBase, n.attr.cast.type, name, sizeof(name), 0) != S_OK)
 553       return E_FAIL;
 554     _tcsncat(pResult, name, max);
 555     _tcsncat(pResult, ">", max);
 556     break;
 557   case iro_Alloc:
 558     _tcsncat(pResult, "<", max);
 559     if (format_type(pHelper, nBase, n.attr.alloc.type, name, sizeof(name), 0) != S_OK)
 560       return E_FAIL;
 561     _tcsncat(pResult, name, max);
 562     _snprintf(name, sizeof(name), ", %s", n.attr.alloc.where == stack_alloc ? "stack" : "heap");
 563     _tcsncat(pResult, name, max);
 564     _tcsncat(pResult, ">", max);
 565     break;
 566   case iro_Free:
 567     _tcsncat(pResult, "<", max);
 568     if (format_type(pHelper, nBase, n.attr.free.type, name, sizeof(name), 0) != S_OK)
 569       return E_FAIL;
 570     _tcsncat(pResult, name, max);
 571     _snprintf(name, sizeof(name), ", %s", n.attr.free.where == stack_alloc ? "stack" : "heap");
 572     _tcsncat(pResult, name, max);
 573     _tcsncat(pResult, ">", max);
 574     break;
 575   case iro_CopyB:
 576     _tcsncat(pResult, "<", max);
 577     if (format_type(pHelper, nBase, n.attr.copyb.type, name, sizeof(name), 0) != S_OK)
 578       return E_FAIL;
 579     _tcsncat(pResult, name, max);
 580     _tcsncat(pResult, ">", max);
 581     break;
 582   }
 583
 584   switch (nBase) {
 585   case 16:
 586     _snprintf(name, sizeof(name), " [0x%lx:0x%x]", n.node_nr, n.node_idx);
 587     break;
 588   case 8:
 589     _snprintf(name, sizeof(name), " [0%lo:0%o]", n.node_nr, n.node_idx);
 590     break;
 591   default:
 592     _snprintf(name, sizeof(name), " [%ld:%u]", n.node_nr, n.node_idx);
 593   }
 594   _tcsncat(pResult, name, max);
 595
 596   return S_OK;
 597 }  /* format_node */
 598
 599 /**
 600  * format a loop
 601  */
 602 static HRESULT format_loop(DEBUGHELPER *pHelper, const void *addr, char *pResult, size_t max)
 603 {
 604   ir_loop loop;
 605
 606   if (copy_from_debuggee(addr, pHelper, &loop, sizeof(loop)) != S_OK)
 607     return E_FAIL;
 608   return E_FAIL;
 609 }  /* format_loop */
 610
 611 /**
 612  * Get an array descriptor
 613  */
 614 static HRESULT get_array_desc(DEBUGHELPER *pHelper, const void *address, ir_arr_descr *desc)
 615 {
 616   address = ARR_DESCR(address);
 617   if (copy_from_debuggee(address, pHelper, desc, sizeof(*desc)) != S_OK)
 618     return E_FAIL;
 619
 620   return S_OK;
 621 }  /* get_array_desc */
 622
 623 /**
 624  * format an extended block
 625  */
 626 static HRESULT format_extblk(DEBUGHELPER *pHelper, int nBase, const void *addr, char *pResult, size_t max)
 627 {
 628   ir_extblk extbb;
 629   ir_arr_descr blocks;
 630   ir_node *blks = NULL;
 631   char name[256];
 632   int len;
 633
 634   if (copy_from_debuggee(addr, pHelper, &extbb, sizeof(extbb)) != S_OK)
 635     return E_FAIL;
 636   if (extbb.blks == NULL)
 637     return E_FAIL;
 638
 639   if (get_array_desc(pHelper, extbb.blks, &blocks) != S_OK)
 640     return E_FAIL;
 641
 642   len = ARR_LEN(&blocks.v.elts);
 643
 644   if (len > 0) {
 645     if (copy_from_debuggee(extbb.blks, pHelper, &blks, sizeof(blks)) != S_OK)
 646       return E_FAIL;
 647   }
 648
 649   if (blks) {
 650     switch (nBase) {
 651     case 16:
 652       _snprintf(name, sizeof(name), "0x%x 0x%x blocks", blks->node_nr, len);
 653       break;
 654     case 8:
 655       _snprintf(name, sizeof(name), "0%o 0%o blocks", blks->node_nr, len);
 656       break;
 657     default:
 658       _snprintf(name, sizeof(name), "%d %d blocks", blks->node_nr, len);
 659     }
 660     _tcsncpy(pResult, name, max);
 661   }
 662   else
 663     _tcsncpy(pResult, "<EMPTY>", max);
 664   return S_OK;
 665 }  /* format_extblk */
 666
 667
 668 /**
 669  * format a ir_prog
 670  */
 671 static HRESULT format_prog(DEBUGHELPER *pHelper, int nBase, const void *addr, char *pResult, size_t max)
 672 {
 673   ir_prog irp;
 674   ir_arr_descr graphs, types;
 675   char name[256];
 676
 677   if (copy_from_debuggee(addr, pHelper, &irp, sizeof(irp)) != S_OK)
 678     return E_FAIL;
 679   if (irp.graphs) {
 680     if (get_array_desc(pHelper, irp.graphs, &graphs) != S_OK)
 681       return E_FAIL;
 682
 683     irp.graphs = (ir_graph**)&graphs.v.elts;
 684   }
 685
 686   if (irp.types) {
 687     if (get_array_desc(pHelper, irp.types, &types) != S_OK)
 688       return E_FAIL;
 689
 690     irp.types = (ir_type**)&types.v.elts;
 691   }
 692
 693   switch (nBase) {
 694   case 16:
 695     _snprintf(name, sizeof(name), "0x%x graphs 0x%x types", ARR_LEN(irp.graphs), ARR_LEN(irp.types));
 696     break;
 697   case 8:
 698     _snprintf(name, sizeof(name), "0%o graphs 0%o types", ARR_LEN(irp.graphs), ARR_LEN(irp.types));
 699     break;
 700   default:
 701     _snprintf(name, sizeof(name), "%d graphs %d types", ARR_LEN(irp.graphs), ARR_LEN(irp.types));
 702   }
 703   _tcsncpy(pResult, name, max);
 704
 705   return S_OK;
 706 }  /* format_prog */
 707
 708 /*
 709  * Format an array descriptor
 710  */
 711 HRESULT format_arr_descr(DEBUGHELPER *pHelper, int nBase, const void *addr, char *pResult, size_t max)
 712 {
 713   ir_arr_descr desc;
 714   char name[256];
 715
 716   if (copy_from_debuggee(addr, pHelper, &desc, sizeof(desc)) != S_OK)
 717     return E_FAIL;
 718
 719   switch (desc.magic) {
 720   case ARR_D_MAGIC:
 721     _tcsncpy(pResult, "DynArr ", max); break;
 722   case ARR_A_MAGIC:
 723     _tcsncpy(pResult, "AutoArr ", max); break;
 724   case ARR_F_MAGIC:
 725     _tcsncpy(pResult, "FlexArr ", max); break;
 726   default:
 727     _tcsncpy(pResult, "UNKN ", max);
 728   }
 729
 730   switch (nBase) {
 731   case 16:
 732     _snprintf(name, sizeof(name), "nelts 0x%x", desc.nelts);
 733     break;
 734   case 8:
 735     _snprintf(name, sizeof(name), "nelts 0%o", desc.nelts);
 736     break;
 737   default:
 738     _snprintf(name, sizeof(name), "nelts %d", desc.nelts);
 739   }
 740   _tcsncat(pResult, name, max);
 741
 742   return S_OK;
 743 }  /* format_arr_descr */
 744
 745 /*
 746  * format a firm object
 747  */
 748 HRESULT FormatFirmObject(DEBUGHELPER *pHelper, int nBase, firm_kind kind, const void *addr, char *pResult, size_t max)
 749 {
 750   switch (kind) {
 751   case k_entity:     /* an entity */
 752     return format_entity(pHelper, nBase, addr, pResult, max, 1);
 753   case k_type:       /* a type */
 754     return format_type(pHelper, nBase, addr, pResult, max, 1);
 755   case k_ir_graph:   /* an ir graph */
 756     return format_irg(pHelper, nBase, addr, pResult, max, 1);
 757   case k_ir_node:    /* an ir node */
 758     return format_node(pHelper, nBase, addr, pResult, max, 1);
 759   case k_ir_mode:    /* an ir mode */
 760     return format_mode(pHelper, addr, pResult, max);
 761   case k_ir_op:      /* an ir opcode */
 762     return format_op(pHelper, addr, pResult, max);
 763   case k_tarval:     /* a tarval */
 764     return format_tarval(pHelper, nBase, addr, pResult, max);
 765   case k_ir_loop:    /* a loop */
 766     return format_loop(pHelper, addr, pResult, max);
 767   case k_ir_compound_graph_path: /* a compound graph path, see entity.h */
 768     return E_FAIL;
 769   case k_ir_extblk:  /* an extended block */
 770     return format_extblk(pHelper, nBase, addr, pResult, max);
 771   case k_ir_prog:    /* a program representation (irp) */
 772     return format_prog(pHelper, nBase, addr, pResult, max);
 773   default:
 774     return E_FAIL;
 775   }
 776 }  /* FormatFirmObject */
 777
 778 #define SEGMENT_SIZE_SHIFT      8
 779 #define SEGMENT_SIZE            (1 << SEGMENT_SIZE_SHIFT)
 780 #define DIRECTORY_SIZE_SHIFT    8
 781 #define DIRECTORY_SIZE          (1 << DIRECTORY_SIZE_SHIFT)
 782 #define MAX_LOAD_FACTOR         4
 783
 784 typedef struct pset_element {
 785   struct pset_element *chain;   /**< for chaining Elements */
 786   pset_entry entry;
 787 } pset_Element, *pset_Segment;
 788
 789 /* not visible from outside */
 790 struct pset {
 791   unsigned p;              /**< Next bucket to be split */
 792   unsigned maxp;           /**< upper bound on p during expansion */
 793   unsigned nkey;           /**< current # keys */
 794   unsigned nseg;           /**< current # segments */
 795   pset_Segment *dir[DIRECTORY_SIZE];
 796   int (*cmp)();            /**< function comparing entries */
 797   unsigned iter_i, iter_j;
 798   pset_Element *iter_tail; /**< non-NULL while iterating over elts */
 799   pset_Element *free_list; /**< list of free Elements */
 800   struct obstack obst;     /**< obstack for allocation all data */
 801 #ifdef STATS
 802   int naccess, ncollision, ndups;
 803   int max_chain_len;
 804 #endif
 805 #ifdef DEBUG
 806   const char *tag;         /**< an optionally tag for distinguishing sets */
 807 #endif
 808 };
 809
 810 typedef struct set_element {
 811   struct set_element *chain;    /**< for chaining Elements */
 812   set_entry entry;
 813 } set_Element, *set_Segment;
 814
 815 /* not visible from outside */
 816 struct set {
 817   unsigned p;              /**< Next bucket to be split */
 818   unsigned maxp;           /**< upper bound on p during expansion */
 819   unsigned nkey;           /**< current # keys */
 820   unsigned nseg;           /**< current # segments */
 821   set_Segment *dir[DIRECTORY_SIZE];
 822   int (*cmp)();            /**< function comparing entries */
 823   unsigned iter_i, iter_j;
 824   set_Element *iter_tail;  /**< non-NULL while iterating over elts */
 825   struct obstack obst;     /**< obstack for allocation all data */
 826 #ifdef STATS
 827   int naccess, ncollision, ndups;
 828   int max_chain_len;
 829 #endif
 830 #ifdef DEBUG
 831   const char *tag;         /**< an optionally tag for distinguishing sets */
 832 #endif
 833 };
 834
 835 /**
 836  * Find the longest chain of a pset
 837  */
 838 static HRESULT find_longest_pset_chain(DEBUGHELPER *pHelper, pset *set,
 839                                        int *chains, int *lenght, size_t *size) {
 840   unsigned i, j;
 841   pset_Segment *seg, *curr;
 842   pset_Element elem;
 843   void *address;
 844   int len, nchains = 0, max_len = 0;
 845   size_t dyns = 0;
 846
 847   for (i = 0; i < set->nseg; ++i) {
 848     seg = set->dir[i];
 849
 850     dyns += sizeof(seg[j]) * SEGMENT_SIZE;
 851     for (j = 0; j < SEGMENT_SIZE; ++j) {
 852       if (copy_from_debuggee(&seg[j], pHelper, &curr, sizeof(curr)) != S_OK)
 853         return E_FAIL;
 854
 855       address = curr;
 856       if (address)
 857         ++nchains;
 858       for (len = 0; address != NULL; address = elem.chain) {
 859         if (copy_from_debuggee(address, pHelper, &elem, sizeof(elem)) != S_OK)
 860           return E_FAIL;
 861         dyns += sizeof(pset_Element);
 862         ++len;
 863       }
 864       if (len > max_len)
 865         max_len = len;
 866     }
 867   }
 868
 869   *chains = nchains;
 870   *lenght = max_len;
 871   *size   = dyns;
 872   return S_OK;
 873 }  /* find_longest_pset_chain */
 874
 875 /**
 876  * Find the longest chain of a set
 877  */
 878 static HRESULT find_longest_set_chain(DEBUGHELPER *pHelper, set *set,
 879                                       int *chains, int *lenght, size_t *size) {
 880   unsigned i, j;
 881   set_Segment *seg, *curr;
 882   set_Element elem;
 883   void *address;
 884   int len, nchains = 0, max_len = 0;
 885   size_t dyns = 0;
 886
 887   for (i = 0; i < set->nseg; ++i) {
 888     seg = set->dir[i];
 889
 890     dyns += sizeof(seg[j]) * SEGMENT_SIZE;
 891     for (j = 0; j < SEGMENT_SIZE; ++j) {
 892       if (copy_from_debuggee(&seg[j], pHelper, &curr, sizeof(curr)) != S_OK)
 893           return E_FAIL;
 894
 895       address = curr;
 896       if (address)
 897         ++nchains;
 898       for (len = 0; address != NULL; address = elem.chain) {
 899         if (copy_from_debuggee(address, pHelper, &elem, sizeof(elem)) != S_OK)
 900           return E_FAIL;
 901         dyns += offsetof(set_Element, entry.dptr) + elem.entry.size;
 902         ++len;
 903       }
 904       if (len > max_len)
 905         max_len = len;
 906     }
 907   }
 908
 909   *chains = nchains;
 910   *lenght = max_len;
 911   *size   = dyns;
 912   return S_OK;
 913 }  /* find_longest_set_chain */
 914
 915 /*
 916  * Format a pset
 917  */
 918 HRESULT format_pset(DEBUGHELPER *pHelper, int nBase, const void *address, char *pResult, size_t max)
 919 {
 920   pset set;
 921   char name[256];
 922   int nchains, chain_len;
 923   size_t size;
 924
 925   if (copy_from_debuggee(address, pHelper, &set, sizeof(set)) != S_OK)
 926     return E_FAIL;
 927
 928   if (find_longest_pset_chain(pHelper, &set, &nchains, &chain_len, &size) != S_OK)
 929     return E_FAIL;
 930
 931   switch (nBase) {
 932   case 16:
 933     _snprintf(name, sizeof(name), "nkey 0x%x nseg 0x%x nchain 0x%x maxlen 0x%x size %u kB", set.nkey, set.nseg, nchains, chain_len, (size + 1023) >> 10);
 934     break;
 935   case 8:
 936     _snprintf(name, sizeof(name), "nkey 0%o nseg 0%o nchain 0%o maxlen 0%o size %u kB", set.nkey, set.nseg, nchains, chain_len, (size + 1023) >> 10);
 937     break;
 938   default:
 939     _snprintf(name, sizeof(name), "nkey %u nseg %d nchain %d maxlen %d size %u kB", set.nkey, set.nseg, nchains, chain_len, (size + 1023) >> 10);
 940   }
 941   _tcsncpy(pResult, name, max);
 942
 943   return S_OK;
 944 }  /* format_pset */
 945
 946 /*
 947  * Format a set
 948  */
 949 HRESULT format_set(DEBUGHELPER *pHelper, int nBase, const void *address, char *pResult, size_t max)
 950 {
 951   set set;
 952   char name[256];
 953   int nchains, chain_len;
 954   size_t size;
 955
 956   if (copy_from_debuggee(address, pHelper, &set, sizeof(set)) != S_OK)
 957     return E_FAIL;
 958
 959   if (find_longest_set_chain(pHelper, &set, &nchains, &chain_len, &size) != S_OK)
 960     return E_FAIL;
 961
 962   switch (nBase) {
 963   case 16:
 964     _snprintf(name, sizeof(name), "nkey 0x%x nseg 0x%x nchain 0x%x maxlen 0x%x size %u kB", set.nkey, set.nseg, nchains, chain_len, (size + 1023) >> 10);
 965     break;
 966   case 8:
 967     _snprintf(name, sizeof(name), "nkey 0%o nseg 0%o nchain 0%o maxlen 0%o size %u kB", set.nkey, set.nseg, nchains, chain_len, (size + 1023) >> 10);
 968     break;
 969   default:
 970     _snprintf(name, sizeof(name), "nkey %u nseg %d nchain %d maxlen %d size %u kB", set.nkey, set.nseg, nchains, chain_len, (size + 1023) >> 10);
 971   }
 972   _tcsncpy(pResult, name, max);
 973
 974   return S_OK;
 975 }  /* format_set */
 976
 977 struct pdeq {
 978   unsigned magic;       /**< debug magic, only available in DEBUG builds */
 979   pdeq *l_end, *r_end;  /**< left and right ends of the queue */
 980   pdeq *l, *r;          /**< left and right neighbor */
 981   int n;                /**< number of elements in the current chunk */
 982   int p;                /**< the read/write pointer */
 983   const void *data[1];  /**< storage for elements */
 984 };
 985
 986 /** Returns the length of a double ended pointer list. */
 987 static int get_pdeq_len(DEBUGHELPER *pHelper, pdeq *dq)
 988 {
 989   int n;
 990   pdeq *q;
 991   pdeq pdeq;
 992
 993   n = 0;
 994   q = dq->l_end;
 995
 996   if (copy_from_debuggee(q, pHelper, &pdeq, sizeof(pdeq)) != S_OK)
 997     return -1;
 998   q = &pdeq;
 999
1000   for (;;) {
1001     n += q->n;
1002     q = q->r;
1003     if (! q)
1004       break;
1005
1006     if (copy_from_debuggee(q, pHelper, &pdeq, sizeof(pdeq)) != S_OK)
1007       return -1;
1008     q = &pdeq;
1009   };
1010
1011   return n;
1012 }  /* get_pdeq_len */
1013
1014 /*
1015  * Format a pdeq
1016  */
1017 HRESULT format_pdeq(DEBUGHELPER *pHelper, int nBase, const void *address, char *pResult, size_t max)
1018 {
1019   pdeq pdeq;
1020   char name[256];
1021   int len;
1022
1023   if (copy_from_debuggee(address, pHelper, &pdeq, sizeof(pdeq)) != S_OK)
1024     return E_FAIL;
1025
1026   len = get_pdeq_len(pHelper, &pdeq);
1027   if (len < 0)
1028     return E_FAIL;
1029
1030   switch (nBase) {
1031   case 16:
1032     _snprintf(name, sizeof(name), "pdeq 0x%x elem", len);
1033     break;
1034   case 8:
1035     _snprintf(name, sizeof(name), "pdeq 0%o elem", len);
1036     break;
1037   default:
1038     _snprintf(name, sizeof(name), "pdeq %d elem", len);
1039   }
1040   _tcsncpy(pResult, name, max);
1041
1042   return S_OK;
1043 }  /* format_pdeq */
1044
1045 /** show the first 2 units */
1046 static HRESULT fill_bits(DEBUGHELPER *pHelper, bitset_t *bs, char *pResult)
1047 {
1048   bitset_pos_t i, units = bs->units;
1049   int l = 0, o = 0, breaked = 0;
1050   unsigned j;
1051
1052   for (i = 0; i < units; ++i) {
1053     bitset_unit_t data;
1054
1055     if (copy_from_debuggee((void *)(BS_DATA(bs)[i]), pHelper, &data, sizeof(data)) != S_OK)
1056       return E_FAIL;
1057
1058     for (j = 0; j < 32; ++j) {
1059       if (data & (1 << j)) {
1060         sprintf(pResult + l, "%d,", i * sizeof(data) * 8 + j);
1061         l += strlen(pResult + l);
1062         ++o;
1063         if (o >= 10) {
1064           breaked = 1;
1065           goto end;
1066         }
1067       }
1068     }
1069   }
1070 end:
1071   if (breaked) {
1072     sprintf(pResult + l, "...");
1073     l += 3;
1074   }
1075   sprintf(pResult + l, "}");
1076   return S_OK;
1077 }  /* fill_bits */
1078
1079 /*
1080  * Format a bitset
1081  */
1082 HRESULT format_bitset(DEBUGHELPER *pHelper, int nBase, const void *address, char *pResult, size_t max)
1083 {
1084   bitset_t bs;
1085   char name[256];
1086   bitset_pos_t l;
1087
1088   if (copy_from_debuggee(address, pHelper, &bs, sizeof(bs)) != S_OK)
1089     return E_FAIL;
1090
1091   switch (nBase) {
1092   case 16:
1093     _snprintf(name, sizeof(name), "bitset{0x%x:", bs.size);
1094     break;
1095   case 8:
1096     _snprintf(name, sizeof(name), "bitset{0%o:", bs.size);
1097     break;
1098   default:
1099     _snprintf(name, sizeof(name), "bitset{%u:", bs.size);
1100   }
1101
1102   l = strlen(name);
1103   if (fill_bits(pHelper, &bs, &name[l]) != S_OK)
1104     return E_FAIL;
1105
1106
1107   _tcsncpy(pResult, name, max);
1108
1109   return S_OK;
1110 }  /* format_bitset */