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   name[0] = '\0';
 258   if (tp.name) {
 259     if (format_ident(pHelper, tp.name, name, sizeof(name)) != S_OK)
 260       return E_FAIL;
 261   } else {
 262     if (format_mode(pHelper, tp.mode, name, sizeof(name)) != S_OK)
 263       return E_FAIL;
 264   }
 265
 266   _tcsncat(pResult, name, max);
 267   switch (nBase) {
 268   case 16:
 269     _snprintf(name, sizeof(name), " [0x%lx]", tp.nr);
 270     break;
 271   case 8:
 272     _snprintf(name, sizeof(name), " [0%lo]", tp.nr);
 273     break;
 274   default:
 275     _snprintf(name, sizeof(name), " [%ld]", tp.nr);
 276   }
 277   _tcsncat(pResult, name, max);
 278
 279   return S_OK;
 280 }  /* format_type */
 281
 282 /**
 283  * format an irg
 284  */
 285 static HRESULT format_irg(DEBUGHELPER *pHelper, int nBase, const void *addr, char *pResult, size_t max, int top)
 286 {
 287   ir_graph irg;
 288   char name[256];
 289
 290   if (copy_from_debuggee(addr, pHelper, &irg, sizeof(irg)) != S_OK)
 291     return E_FAIL;
 292
 293   *pResult = '\0';
 294   if (top)
 295     _tcsncpy(pResult, "IRG: ", max);
 296
 297   if (irg.ent) {
 298     ir_entity ent;
 299     ir_type owner;
 300     int is_global;
 301
 302     if (copy_from_debuggee(irg.ent, pHelper, &ent, sizeof(ent)) != S_OK)
 303       return E_FAIL;
 304     if (is_global_type(pHelper, ent.owner, &is_global) != S_OK)
 305       return E_FAIL;
 306     if (! is_global) {
 307       if (copy_from_debuggee(ent.owner, pHelper, &owner, sizeof(owner)) != S_OK)
 308         return E_FAIL;
 309       if (format_ident(pHelper, (void *)owner.name, name, sizeof(name)) != S_OK)
 310         return E_FAIL;
 311       _tcsncat(pResult, name, max);
 312       _tcsncat(pResult, "::", max);
 313     }
 314     if (format_ident(pHelper, ent.name, name, sizeof(name)) != S_OK)
 315       return E_FAIL;
 316     _tcsncat(pResult, name, max);
 317   }
 318   else
 319     _tcsncat(pResult, "NULL", max);
 320
 321   switch (nBase) {
 322   case 16:
 323     _snprintf(name, sizeof(name), " [0x%lx, 0x%u nodes]", irg.graph_nr, irg.last_node_idx);
 324     break;
 325   case 8:
 326     _snprintf(name, sizeof(name), " [0%lo, 0%o nodes]", irg.graph_nr, irg.last_node_idx);
 327     break;
 328   default:
 329     _snprintf(name, sizeof(name), " [%ld, %u nodes]", irg.graph_nr, irg.last_node_idx);
 330   }
 331   _tcsncat(pResult, name, max);
 332   return S_OK;
 333 }  /* format_irg */
 334
 335 /**
 336  * format an ir_op
 337  */
 338 HRESULT format_op(DEBUGHELPER *pHelper, const void *addr, char *pResult, size_t max)
 339 {
 340   ir_op op;
 341
 342   if (copy_from_debuggee(addr, pHelper, &op, sizeof(op)) != S_OK)
 343     return E_FAIL;
 344   if (format_ident(pHelper, op.name, pResult, max) != S_OK)
 345     return E_FAIL;
 346   return S_OK;
 347 }  /* format_op */
 348
 349 /**
 350  * format an ir_mode
 351  */
 352 static HRESULT format_mode(DEBUGHELPER *pHelper, const void *addr, char *pResult, size_t max)
 353 {
 354   ir_mode mode;
 355
 356   if (copy_from_debuggee(addr, pHelper, &mode, sizeof(mode)) != S_OK)
 357     return E_FAIL;
 358   if (format_ident(pHelper, mode.name, pResult, max) != S_OK)
 359     return E_FAIL;
 360   return S_OK;
 361 }  /* format_mode */
 362
 363 /** get a temporary string */
 364 #define get_string(str)                                         \
 365 do {                                                            \
 366   int len;                                                      \
 367   char *s;                                                      \
 368   if (str) {                                                    \
 369     len = strlen_debuggee(pHelper, str, 256);                   \
 370     if (len < 0)                                                \
 371       return E_FAIL;                                            \
 372     s = alloca(len + 1);                                        \
 373     if (copy_from_debuggee(str, pHelper, s, (DWORD)len) != S_OK) \
 374       return E_FAIL;                                            \
 375     s[len] = '\0';                                              \
 376     str = s;                                                    \
 377   }                                                             \
 378 } while (0)
 379
 380 /**
 381  * format a tarval
 382  */
 383 static HRESULT format_tarval(DEBUGHELPER *pHelper, int nBase, const void *addr, char *pResult, size_t max)
 384 {
 385   tarval tv;
 386   char *value;
 387   ir_mode mode;
 388   unsigned len;
 389   tarval_mode_info modinfo;
 390
 391   {
 392     static int initialized = 0;
 393
 394     if (! initialized) {
 395       /* from init_tarval_1() */
 396       init_strcalc(68);
 397       init_fltcalc(0);
 398
 399       initialized = 1;
 400     }
 401   }
 402
 403   if (copy_from_debuggee(addr, pHelper, &tv, sizeof(tv)) != S_OK)
 404     return E_FAIL;
 405
 406   /* ir_mode */
 407   if (tv.mode == NULL)
 408     return E_FAIL;
 409
 410   if (copy_from_debuggee(tv.mode, pHelper, &mode, sizeof(mode)) != S_OK)
 411     return E_FAIL;
 412
 413   tv.mode = &mode;
 414
 415   if (mode_is_int(&mode)) {
 416     switch (nBase) {
 417     case 16:
 418       modinfo.mode_output = TVO_HEX;
 419       modinfo.mode_prefix = "0x";
 420       modinfo.mode_suffix = "";
 421       break;
 422     case 8:
 423       modinfo.mode_output = TVO_OCTAL;
 424       modinfo.mode_prefix = "0";
 425       modinfo.mode_suffix = "";
 426       break;
 427     default:
 428       modinfo.mode_output = TVO_DECIMAL;
 429       modinfo.mode_prefix = "";
 430       modinfo.mode_suffix = "";
 431     }
 432   }
 433   else {
 434     if (mode.tv_priv) {
 435       if (copy_from_debuggee(mode.tv_priv, pHelper, &modinfo, sizeof(modinfo)) != S_OK)
 436         return E_FAIL;
 437
 438       get_string(modinfo.mode_prefix);
 439       get_string(modinfo.mode_suffix);
 440     }
 441   }
 442   mode.tv_priv = &modinfo;
 443
 444   len = tv.length;
 445   if (len) {
 446     if (len > 256)
 447       return E_FAIL;
 448
 449     value = alloca(len);
 450
 451     if (copy_from_debuggee(tv.value, pHelper, value, len) != S_OK)
 452       return E_FAIL;
 453
 454     tv.value = value;
 455
 456     tarval_snprintf(pResult, max, &tv);
 457   }
 458   else {
 459     /* might be a reserved tarval */
 460     int resid = PTR_TO_INT(tv.value);
 461
 462     switch (resid) {
 463     case resid_tarval_bad:
 464       _tcsncat(pResult, "BAD", max);
 465       break;
 466     case resid_tarval_undefined:
 467       _tcsncat(pResult, "UNDEF", max);
 468       break;
 469     case resid_tarval_b_false:
 470       _tcsncat(pResult, "FALSE", max);
 471       break;
 472     case resid_tarval_b_true:
 473       _tcsncat(pResult, "TRUE", max);
 474       break;
 475     default:
 476       /* try it */
 477       tarval_snprintf(pResult, max, &tv);
 478     }
 479   }
 480   return S_OK;
 481 }  /* format_tarval */
 482
 483 /**
 484  * format an ir_node
 485  */
 486 static HRESULT format_node(DEBUGHELPER *pHelper, int nBase, const void *addr, char *pResult, size_t max, int top)
 487 {
 488   ir_node n;
 489   char name[256];
 490   ir_op op;
 491
 492   if (copy_from_debuggee(addr, pHelper, &n, sizeof(n)) != S_OK)
 493     return E_FAIL;
 494
 495   /* ir_op */
 496   if (format_op(pHelper, n.op, pResult, max) != S_OK)
 497     return E_FAIL;
 498
 499   /* ir_mode */
 500   if (format_mode(pHelper, n.mode, name, sizeof(name)) != S_OK)
 501     return E_FAIL;
 502   _tcsncat(pResult, name, max);
 503
 504   if (copy_from_debuggee(n.op, pHelper, &op, sizeof(op)) != S_OK)
 505     return E_FAIL;
 506
 507   /* show show node attributes */
 508   switch (op.code) {
 509   case iro_Const:
 510     if (format_tarval(pHelper, nBase, n.attr.con.tv, name, sizeof(name)) != S_OK) {
 511       _tcsncat(pResult, "<???>", max);
 512     }
 513     else {
 514       _tcsncat(pResult, "<", max);
 515       _tcsncat(pResult, name, max);
 516       _tcsncat(pResult, ">", max);
 517     }
 518     break;
 519   case iro_SymConst:
 520     _tcsncat(pResult, "<", max);
 521     switch (n.attr.symc.kind) {
 522     case symconst_type_tag:
 523       _tcsncat(pResult, "TAG:", 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_size:
 529       _tcsncat(pResult, "SIZE:", 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_type_align:
 535       _tcsncat(pResult, "ALGN:", max);
 536       if (format_type(pHelper, nBase, n.attr.symc.sym.type_p, name, sizeof(name), 0) != S_OK)
 537         return E_FAIL;
 538       _tcsncat(pResult, name, max);
 539       break;
 540     case symconst_addr_ent:
 541       _tcsncat(pResult, "ENT:", max);
 542       if (format_entity(pHelper, nBase, n.attr.symc.sym.entity_p, name, sizeof(name), 0) != S_OK)
 543         return E_FAIL;
 544       _tcsncat(pResult, name, max);
 545       break;
 546     }
 547     _tcsncat(pResult, ">", max);
 548     break;
 549   case iro_Sel:
 550     _tcsncat(pResult, "<", max);
 551     if (format_entity(pHelper, nBase, n.attr.sel.entity, name, sizeof(name), 0) != S_OK)
 552       return E_FAIL;
 553     _tcsncat(pResult, name, max);
 554     _tcsncat(pResult, ">", max);
 555     break;
 556   case iro_Cast:
 557     _tcsncat(pResult, "<", max);
 558     if (format_type(pHelper, nBase, n.attr.cast.type, name, sizeof(name), 0) != S_OK)
 559       return E_FAIL;
 560     _tcsncat(pResult, name, max);
 561     _tcsncat(pResult, ">", max);
 562     break;
 563   case iro_Alloc:
 564     _tcsncat(pResult, "<", max);
 565     if (format_type(pHelper, nBase, n.attr.alloc.type, name, sizeof(name), 0) != S_OK)
 566       return E_FAIL;
 567     _tcsncat(pResult, name, max);
 568     _snprintf(name, sizeof(name), ", %s", n.attr.alloc.where == stack_alloc ? "stack" : "heap");
 569     _tcsncat(pResult, name, max);
 570     _tcsncat(pResult, ">", max);
 571     break;
 572   case iro_Free:
 573     _tcsncat(pResult, "<", max);
 574     if (format_type(pHelper, nBase, n.attr.free.type, name, sizeof(name), 0) != S_OK)
 575       return E_FAIL;
 576     _tcsncat(pResult, name, max);
 577     _snprintf(name, sizeof(name), ", %s", n.attr.free.where == stack_alloc ? "stack" : "heap");
 578     _tcsncat(pResult, name, max);
 579     _tcsncat(pResult, ">", max);
 580     break;
 581   case iro_CopyB:
 582     _tcsncat(pResult, "<", max);
 583     if (format_type(pHelper, nBase, n.attr.copyb.type, name, sizeof(name), 0) != S_OK)
 584       return E_FAIL;
 585     _tcsncat(pResult, name, max);
 586     _tcsncat(pResult, ">", max);
 587     break;
 588   }
 589
 590   switch (nBase) {
 591   case 16:
 592     _snprintf(name, sizeof(name), " [0x%lx:0x%x]", n.node_nr, n.node_idx);
 593     break;
 594   case 8:
 595     _snprintf(name, sizeof(name), " [0%lo:0%o]", n.node_nr, n.node_idx);
 596     break;
 597   default:
 598     _snprintf(name, sizeof(name), " [%ld:%u]", n.node_nr, n.node_idx);
 599   }
 600   _tcsncat(pResult, name, max);
 601
 602   return S_OK;
 603 }  /* format_node */
 604
 605 /**
 606  * format a loop
 607  */
 608 static HRESULT format_loop(DEBUGHELPER *pHelper, const void *addr, char *pResult, size_t max)
 609 {
 610   ir_loop loop;
 611
 612   if (copy_from_debuggee(addr, pHelper, &loop, sizeof(loop)) != S_OK)
 613     return E_FAIL;
 614   return E_FAIL;
 615 }  /* format_loop */
 616
 617 /**
 618  * Get an array descriptor
 619  */
 620 static HRESULT get_array_desc(DEBUGHELPER *pHelper, const void *address, ir_arr_descr *desc)
 621 {
 622   address = ARR_DESCR(address);
 623   if (copy_from_debuggee(address, pHelper, desc, sizeof(*desc)) != S_OK)
 624     return E_FAIL;
 625
 626   return S_OK;
 627 }  /* get_array_desc */
 628
 629 /**
 630  * format an extended block
 631  */
 632 static HRESULT format_extblk(DEBUGHELPER *pHelper, int nBase, const void *addr, char *pResult, size_t max)
 633 {
 634   ir_extblk extbb;
 635   ir_arr_descr blocks;
 636   ir_node *blks = NULL;
 637   char name[256];
 638   int len;
 639
 640   if (copy_from_debuggee(addr, pHelper, &extbb, sizeof(extbb)) != S_OK)
 641     return E_FAIL;
 642   if (extbb.blks == NULL)
 643     return E_FAIL;
 644
 645   if (get_array_desc(pHelper, extbb.blks, &blocks) != S_OK)
 646     return E_FAIL;
 647
 648   len = ARR_LEN(&blocks.v.elts);
 649
 650   if (len > 0) {
 651     if (copy_from_debuggee(extbb.blks, pHelper, &blks, sizeof(blks)) != S_OK)
 652       return E_FAIL;
 653   }
 654
 655   if (blks) {
 656     switch (nBase) {
 657     case 16:
 658       _snprintf(name, sizeof(name), "0x%x 0x%x blocks", blks->node_nr, len);
 659       break;
 660     case 8:
 661       _snprintf(name, sizeof(name), "0%o 0%o blocks", blks->node_nr, len);
 662       break;
 663     default:
 664       _snprintf(name, sizeof(name), "%d %d blocks", blks->node_nr, len);
 665     }
 666     _tcsncpy(pResult, name, max);
 667   }
 668   else
 669     _tcsncpy(pResult, "<EMPTY>", max);
 670   return S_OK;
 671 }  /* format_extblk */
 672
 673
 674 /**
 675  * format a ir_prog
 676  */
 677 static HRESULT format_prog(DEBUGHELPER *pHelper, int nBase, const void *addr, char *pResult, size_t max)
 678 {
 679   ir_prog irp;
 680   ir_arr_descr graphs, types;
 681   char name[256];
 682
 683   if (copy_from_debuggee(addr, pHelper, &irp, sizeof(irp)) != S_OK)
 684     return E_FAIL;
 685   if (irp.graphs) {
 686     if (get_array_desc(pHelper, irp.graphs, &graphs) != S_OK)
 687       return E_FAIL;
 688
 689     irp.graphs = (ir_graph**)&graphs.v.elts;
 690   }
 691
 692   if (irp.types) {
 693     if (get_array_desc(pHelper, irp.types, &types) != S_OK)
 694       return E_FAIL;
 695
 696     irp.types = (ir_type**)&types.v.elts;
 697   }
 698
 699   switch (nBase) {
 700   case 16:
 701     _snprintf(name, sizeof(name), "0x%x graphs 0x%x types", ARR_LEN(irp.graphs), ARR_LEN(irp.types));
 702     break;
 703   case 8:
 704     _snprintf(name, sizeof(name), "0%o graphs 0%o types", ARR_LEN(irp.graphs), ARR_LEN(irp.types));
 705     break;
 706   default:
 707     _snprintf(name, sizeof(name), "%d graphs %d types", ARR_LEN(irp.graphs), ARR_LEN(irp.types));
 708   }
 709   _tcsncpy(pResult, name, max);
 710
 711   return S_OK;
 712 }  /* format_prog */
 713
 714 /*
 715  * Format an array descriptor
 716  */
 717 HRESULT format_arr_descr(DEBUGHELPER *pHelper, int nBase, const void *addr, char *pResult, size_t max)
 718 {
 719   ir_arr_descr desc;
 720   char name[256];
 721
 722   if (copy_from_debuggee(addr, pHelper, &desc, sizeof(desc)) != S_OK)
 723     return E_FAIL;
 724
 725   switch (desc.magic) {
 726   case ARR_D_MAGIC:
 727     _tcsncpy(pResult, "DynArr ", max); break;
 728   case ARR_A_MAGIC:
 729     _tcsncpy(pResult, "AutoArr ", max); break;
 730   case ARR_F_MAGIC:
 731     _tcsncpy(pResult, "FlexArr ", max); break;
 732   default:
 733     _tcsncpy(pResult, "UNKN ", max);
 734   }
 735
 736   switch (nBase) {
 737   case 16:
 738     _snprintf(name, sizeof(name), "nelts 0x%x", desc.nelts);
 739     break;
 740   case 8:
 741     _snprintf(name, sizeof(name), "nelts 0%o", desc.nelts);
 742     break;
 743   default:
 744     _snprintf(name, sizeof(name), "nelts %d", desc.nelts);
 745   }
 746   _tcsncat(pResult, name, max);
 747
 748   return S_OK;
 749 }  /* format_arr_descr */
 750
 751 /*
 752  * format a firm object
 753  */
 754 HRESULT FormatFirmObject(DEBUGHELPER *pHelper, int nBase, firm_kind kind, const void *addr, char *pResult, size_t max)
 755 {
 756   switch (kind) {
 757   case k_entity:     /* an entity */
 758     return format_entity(pHelper, nBase, addr, pResult, max, 1);
 759   case k_type:       /* a type */
 760     return format_type(pHelper, nBase, addr, pResult, max, 1);
 761   case k_ir_graph:   /* an ir graph */
 762     return format_irg(pHelper, nBase, addr, pResult, max, 1);
 763   case k_ir_node:    /* an ir node */
 764     return format_node(pHelper, nBase, addr, pResult, max, 1);
 765   case k_ir_mode:    /* an ir mode */
 766     return format_mode(pHelper, addr, pResult, max);
 767   case k_ir_op:      /* an ir opcode */
 768     return format_op(pHelper, addr, pResult, max);
 769   case k_tarval:     /* a tarval */
 770     return format_tarval(pHelper, nBase, addr, pResult, max);
 771   case k_ir_loop:    /* a loop */
 772     return format_loop(pHelper, addr, pResult, max);
 773   case k_ir_compound_graph_path: /* a compound graph path, see entity.h */
 774     return E_FAIL;
 775   case k_ir_extblk:  /* an extended block */
 776     return format_extblk(pHelper, nBase, addr, pResult, max);
 777   case k_ir_prog:    /* a program representation (irp) */
 778     return format_prog(pHelper, nBase, addr, pResult, max);
 779   default:
 780     return E_FAIL;
 781   }
 782 }  /* FormatFirmObject */
 783
 784 #define SEGMENT_SIZE_SHIFT      8
 785 #define SEGMENT_SIZE            (1 << SEGMENT_SIZE_SHIFT)
 786 #define DIRECTORY_SIZE_SHIFT    8
 787 #define DIRECTORY_SIZE          (1 << DIRECTORY_SIZE_SHIFT)
 788 #define MAX_LOAD_FACTOR         4
 789
 790 typedef struct pset_element {
 791   struct pset_element *chain;   /**< for chaining Elements */
 792   pset_entry entry;
 793 } pset_Element, *pset_Segment;
 794
 795 /* not visible from outside */
 796 struct pset {
 797   unsigned p;              /**< Next bucket to be split */
 798   unsigned maxp;           /**< upper bound on p during expansion */
 799   unsigned nkey;           /**< current # keys */
 800   unsigned nseg;           /**< current # segments */
 801   pset_Segment *dir[DIRECTORY_SIZE];
 802   int (*cmp)();            /**< function comparing entries */
 803   unsigned iter_i, iter_j;
 804   pset_Element *iter_tail; /**< non-NULL while iterating over elts */
 805   pset_Element *free_list; /**< list of free Elements */
 806   struct obstack obst;     /**< obstack for allocation all data */
 807 #ifdef STATS
 808   int naccess, ncollision, ndups;
 809   int max_chain_len;
 810 #endif
 811 #ifdef DEBUG
 812   const char *tag;         /**< an optionally tag for distinguishing sets */
 813 #endif
 814 };
 815
 816 typedef struct set_element {
 817   struct set_element *chain;    /**< for chaining Elements */
 818   set_entry entry;
 819 } set_Element, *set_Segment;
 820
 821 /* not visible from outside */
 822 struct set {
 823   unsigned p;              /**< Next bucket to be split */
 824   unsigned maxp;           /**< upper bound on p during expansion */
 825   unsigned nkey;           /**< current # keys */
 826   unsigned nseg;           /**< current # segments */
 827   set_Segment *dir[DIRECTORY_SIZE];
 828   int (*cmp)();            /**< function comparing entries */
 829   unsigned iter_i, iter_j;
 830   set_Element *iter_tail;  /**< non-NULL while iterating over elts */
 831   struct obstack obst;     /**< obstack for allocation all data */
 832 #ifdef STATS
 833   int naccess, ncollision, ndups;
 834   int max_chain_len;
 835 #endif
 836 #ifdef DEBUG
 837   const char *tag;         /**< an optionally tag for distinguishing sets */
 838 #endif
 839 };
 840
 841 /**
 842  * Find the longest chain of a pset
 843  */
 844 static HRESULT find_longest_pset_chain(DEBUGHELPER *pHelper, pset *set,
 845                                        int *chains, int *lenght, size_t *size)
 846 {
 847   unsigned i, j;
 848   pset_Segment *seg, *curr;
 849   pset_Element elem;
 850   void *address;
 851   int len, nchains = 0, max_len = 0;
 852   size_t dyns = 0;
 853
 854   for (i = 0; i < set->nseg; ++i) {
 855     seg = set->dir[i];
 856
 857     dyns += sizeof(seg[j]) * SEGMENT_SIZE;
 858     for (j = 0; j < SEGMENT_SIZE; ++j) {
 859       if (copy_from_debuggee(&seg[j], pHelper, &curr, sizeof(curr)) != S_OK)
 860         return E_FAIL;
 861
 862       address = curr;
 863       if (address)
 864         ++nchains;
 865       for (len = 0; address != NULL; address = elem.chain) {
 866         if (copy_from_debuggee(address, pHelper, &elem, sizeof(elem)) != S_OK)
 867           return E_FAIL;
 868         dyns += sizeof(pset_Element);
 869         ++len;
 870       }
 871       if (len > max_len)
 872         max_len = len;
 873     }
 874   }
 875
 876   *chains = nchains;
 877   *lenght = max_len;
 878   *size   = dyns;
 879   return S_OK;
 880 }  /* find_longest_pset_chain */
 881
 882 /**
 883  * Find the longest chain of a set
 884  */
 885 static HRESULT find_longest_set_chain(DEBUGHELPER *pHelper, set *set,
 886                                       int *chains, int *lenght, size_t *size)
 887 {
 888   unsigned i, j;
 889   set_Segment *seg, *curr;
 890   set_Element elem;
 891   void *address;
 892   int len, nchains = 0, max_len = 0;
 893   size_t dyns = 0;
 894
 895   for (i = 0; i < set->nseg; ++i) {
 896     seg = set->dir[i];
 897
 898     dyns += sizeof(seg[j]) * SEGMENT_SIZE;
 899     for (j = 0; j < SEGMENT_SIZE; ++j) {
 900       if (copy_from_debuggee(&seg[j], pHelper, &curr, sizeof(curr)) != S_OK)
 901           return E_FAIL;
 902
 903       address = curr;
 904       if (address)
 905         ++nchains;
 906       for (len = 0; address != NULL; address = elem.chain) {
 907         if (copy_from_debuggee(address, pHelper, &elem, sizeof(elem)) != S_OK)
 908           return E_FAIL;
 909         dyns += offsetof(set_Element, entry.dptr) + elem.entry.size;
 910         ++len;
 911       }
 912       if (len > max_len)
 913         max_len = len;
 914     }
 915   }
 916
 917   *chains = nchains;
 918   *lenght = max_len;
 919   *size   = dyns;
 920   return S_OK;
 921 }  /* find_longest_set_chain */
 922
 923 /*
 924  * Format a pset
 925  */
 926 HRESULT format_pset(DEBUGHELPER *pHelper, int nBase, const void *address, char *pResult, size_t max)
 927 {
 928   pset set;
 929   char name[256];
 930   int nchains, chain_len;
 931   size_t size;
 932
 933   if (copy_from_debuggee(address, pHelper, &set, sizeof(set)) != S_OK)
 934     return E_FAIL;
 935
 936   if (find_longest_pset_chain(pHelper, &set, &nchains, &chain_len, &size) != S_OK)
 937     return E_FAIL;
 938
 939   switch (nBase) {
 940   case 16:
 941     _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);
 942     break;
 943   case 8:
 944     _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);
 945     break;
 946   default:
 947     _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);
 948   }
 949   _tcsncpy(pResult, name, max);
 950
 951   return S_OK;
 952 }  /* format_pset */
 953
 954 /*
 955  * Format a set
 956  */
 957 HRESULT format_set(DEBUGHELPER *pHelper, int nBase, const void *address, char *pResult, size_t max)
 958 {
 959   set set;
 960   char name[256];
 961   int nchains, chain_len;
 962   size_t size;
 963
 964   if (copy_from_debuggee(address, pHelper, &set, sizeof(set)) != S_OK)
 965     return E_FAIL;
 966
 967   if (find_longest_set_chain(pHelper, &set, &nchains, &chain_len, &size) != S_OK)
 968     return E_FAIL;
 969
 970   switch (nBase) {
 971   case 16:
 972     _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);
 973     break;
 974   case 8:
 975     _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);
 976     break;
 977   default:
 978     _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);
 979   }
 980   _tcsncpy(pResult, name, max);
 981
 982   return S_OK;
 983 }  /* format_set */
 984
 985 struct pdeq {
 986   unsigned magic;       /**< debug magic, only available in DEBUG builds */
 987   pdeq *l_end, *r_end;  /**< left and right ends of the queue */
 988   pdeq *l, *r;          /**< left and right neighbor */
 989   int n;                /**< number of elements in the current chunk */
 990   int p;                /**< the read/write pointer */
 991   const void *data[1];  /**< storage for elements */
 992 };
 993
 994 /** Returns the length of a double ended pointer list. */
 995 static int get_pdeq_len(DEBUGHELPER *pHelper, pdeq *dq)
 996 {
 997   int n;
 998   pdeq *q;
 999   pdeq pdeq;
1000
1001   n = 0;
1002   q = dq->l_end;
1003
1004   if (copy_from_debuggee(q, pHelper, &pdeq, sizeof(pdeq)) != S_OK)
1005     return -1;
1006   q = &pdeq;
1007
1008   for (;;) {
1009     n += q->n;
1010     q = q->r;
1011     if (! q)
1012       break;
1013
1014     if (copy_from_debuggee(q, pHelper, &pdeq, sizeof(pdeq)) != S_OK)
1015       return -1;
1016     q = &pdeq;
1017   };
1018
1019   return n;
1020 }  /* get_pdeq_len */
1021
1022 /*
1023  * Format a pdeq
1024  */
1025 HRESULT format_pdeq(DEBUGHELPER *pHelper, int nBase, const void *address, char *pResult, size_t max)
1026 {
1027   pdeq pdeq;
1028   char name[256];
1029   int len;
1030
1031   if (copy_from_debuggee(address, pHelper, &pdeq, sizeof(pdeq)) != S_OK)
1032     return E_FAIL;
1033
1034   len = get_pdeq_len(pHelper, &pdeq);
1035   if (len < 0)
1036     return E_FAIL;
1037
1038   switch (nBase) {
1039   case 16:
1040     _snprintf(name, sizeof(name), "pdeq 0x%x elem", len);
1041     break;
1042   case 8:
1043     _snprintf(name, sizeof(name), "pdeq 0%o elem", len);
1044     break;
1045   default:
1046     _snprintf(name, sizeof(name), "pdeq %d elem", len);
1047   }
1048   _tcsncpy(pResult, name, max);
1049
1050   return S_OK;
1051 }  /* format_pdeq */
1052
1053 /** show the first 2 units */
1054 static HRESULT fill_bits(DEBUGHELPER *pHelper, bitset_t *bs, char *pResult)
1055 {
1056   bitset_pos_t i, units = bs->units;
1057   int l = 0, o = 0, breaked = 0;
1058   unsigned j;
1059
1060   for (i = 0; i < units; ++i) {
1061     bitset_unit_t data;
1062
1063     if (copy_from_debuggee((void *)(BS_DATA(bs)[i]), pHelper, &data, sizeof(data)) != S_OK)
1064       return E_FAIL;
1065
1066     for (j = 0; j < 32; ++j) {
1067       if (data & (1 << j)) {
1068         sprintf(pResult + l, "%d,", i * sizeof(data) * 8 + j);
1069         l += strlen(pResult + l);
1070         ++o;
1071         if (o >= 10) {
1072           breaked = 1;
1073           goto end;
1074         }
1075       }
1076     }
1077   }
1078 end:
1079   if (breaked) {
1080     sprintf(pResult + l, "...");
1081     l += 3;
1082   }
1083   sprintf(pResult + l, "}");
1084   return S_OK;
1085 }  /* fill_bits */
1086
1087 /*
1088  * Format a bitset
1089  */
1090 HRESULT format_bitset(DEBUGHELPER *pHelper, int nBase, const void *address, char *pResult, size_t max)
1091 {
1092   bitset_t bs;
1093   char name[256];
1094   bitset_pos_t l;
1095
1096   if (copy_from_debuggee(address, pHelper, &bs, sizeof(bs)) != S_OK)
1097     return E_FAIL;
1098
1099   switch (nBase) {
1100   case 16:
1101     _snprintf(name, sizeof(name), "bitset{0x%x:", bs.size);
1102     break;
1103   case 8:
1104     _snprintf(name, sizeof(name), "bitset{0%o:", bs.size);
1105     break;
1106   default:
1107     _snprintf(name, sizeof(name), "bitset{%u:", bs.size);
1108   }
1109
1110   l = strlen(name);
1111   if (fill_bits(pHelper, &bs, &name[l]) != S_OK)
1112     return E_FAIL;
1113
1114
1115   _tcsncpy(pResult, name, max);
1116
1117   return S_OK;
1118 }  /* format_bitset */