nsz Git - libfirm/blob - ir/debug/debugger.c

   1 /*
   2  * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
   3  *
   4  * This file is part of libFirm.
   5  *
   6  * This file may be distributed and/or modified under the terms of the
   7  * GNU General Public License version 2 as published by the Free Software
   8  * Foundation and appearing in the file LICENSE.GPL included in the
   9  * packaging of this file.
  10  *
  11  * Licensees holding valid libFirm Professional Edition licenses may use
  12  * this file in accordance with the libFirm Commercial License.
  13  * Agreement provided with the Software.
  14  *
  15  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  16  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE.
  18  */
  19
  20 /**
  21  * @file
  22  * @brief     Helper function for integrated debug support
  23  * @author    Michael Beck
  24  * @date      2005
  25  * @version   $Id$
  26  */
  27 #include "config.h"
  28
  29 #ifdef DEBUG_libfirm
  30
  31 #ifdef _WIN32
  32 #define WIN32_LEAN_AND_MEAN
  33 #include <windows.h>
  34 #endif
  35
  36 #include <stdlib.h>
  37 #include <stdio.h>
  38 #include <signal.h>
  39 #include <string.h>
  40
  41 #ifdef HAVE_STRINGS_H
  42 #include <strings.h>
  43 #endif
  44
  45 #include <ctype.h>
  46
  47 #include "set.h"
  48 #include "ident.h"
  49 #include "irhooks.h"
  50 #include "irgraph_t.h"
  51 #include "entity_t.h"
  52 #include "irprintf.h"
  53 #include "irdump.h"
  54 #include "iredges_t.h"
  55 #include "debug.h"
  56 #include "error.h"
  57
  58 #ifdef _WIN32
  59 /* Break into the debugger. The Win32 way. */
  60 void firm_debug_break(void)
  61 {
  62         DebugBreak();
  63 }
  64 #elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64))
  65 /* Break into the debugger. The ia32/x86_64 way under GCC. */
  66 void firm_debug_break(void)
  67 {
  68         __asm__ __volatile__("int3");
  69 }
  70 #else
  71 /* Break into the debugger. Poor Unix way. */
  72 void firm_debug_break(void)
  73 {
  74         raise(SIGINT);
  75 }
  76 #endif /* _WIN32 */
  77
  78 /** supported breakpoint kinds */
  79 typedef enum {
  80         BP_NR    = 'n',   /**< break on node number. */
  81         BP_IDENT = 'i'    /**< break on ident. */
  82 } bp_kind;
  83
  84 /**
  85  * Reasons for node number breakpoints.
  86  */
  87 typedef enum _bp_reasons_t {
  88         BP_ON_NEW_NODE,    /**< break if node with number is created */
  89         BP_ON_REPLACE,     /**< break if node with number is replaced */
  90         BP_ON_LOWER,       /**< break if node with number is lowered */
  91         BP_ON_REMIRG,      /**< break if an IRG is removed */
  92         BP_ON_NEW_ENT,     /**< break if a new entity is created */
  93         BP_ON_NEW_TYPE,    /**< break if a new type is created */
  94         BP_MAX_REASON
  95 } bp_reasons_t;
  96
  97 /** A breakpoint. */
  98 typedef struct _breakpoint {
  99         bp_kind      kind;        /**< the kind of this break point */
 100         unsigned     bpnr;        /**< break point number */
 101         int          active;      /**< non-zero, if this break point is active */
 102         bp_reasons_t reason;      /**< reason for the breakpoint */
 103         struct _breakpoint *next; /**< link to the next one */
 104 } breakpoint;
 105
 106 /** A number breakpoint. */
 107 typedef struct {
 108         breakpoint   bp;       /**< the breakpoint data */
 109         long         nr;       /**< the node number */
 110 } bp_nr_t;
 111
 112 /** Calculate the hash value for a node breakpoint. */
 113 #define HASH_NR_BP(key) (((key).nr << 2) ^ (key).bp.reason)
 114
 115 /** An ident breakpoint. */
 116 typedef struct {
 117         breakpoint   bp;       /**< the breakpoint data */
 118         ident        *id;      /**< the ident */
 119 } bp_ident_t;
 120
 121 /** Calculate the hash value for an ident breakpoint. */
 122 #define HASH_IDENT_BP(key) (HASH_PTR((key).id) ^ (key).bp.reason)
 123
 124 /** The set containing the breakpoints on node numbers. */
 125 static set *bp_numbers;
 126
 127 /** The set containing the breakpoints on idents. */
 128 static set *bp_idents;
 129
 130 /**< the list of all breakpoints */
 131 static breakpoint *bp_list;
 132
 133 /** number of the current break point */
 134 static unsigned bp_num = 0;
 135
 136 /** set if break on init command was issued. */
 137 static int break_on_init = 0;
 138
 139 /** the hook entries for the Firm debugger module. */
 140 static hook_entry_t debugger_hooks[hook_last];
 141
 142 /** number of active breakpoints to maintain hooks. */
 143 static unsigned num_active_bp[BP_MAX_REASON];
 144
 145 /**
 146  * The debug message buffer
 147  */
 148 static char firm_dbg_msg_buf[2048];
 149
 150 /**
 151  * If set, the debug extension writes all output to the
 152  * firm_dbg_msg_buf buffer
 153  */
 154 static int redir_output = 0;
 155
 156 /**
 157  * Is set to one, if the debug extension is active
 158  */
 159 static int is_active = 0;
 160
 161 /** hook the hook h with function fkt. */
 162 #define HOOK(h, fkt) \
 163 do {                                      \
 164         debugger_hooks[h].hook._##h = fkt;    \
 165         register_hook(h, &debugger_hooks[h]); \
 166 } while (0)
 167
 168 /** unhook the hook h */
 169 #define UNHOOK(h) \
 170 do {                                        \
 171         unregister_hook(h, &debugger_hooks[h]); \
 172         debugger_hooks[h].hook._##h = NULL;     \
 173 } while (0)
 174
 175 /** returns non-zero if a entry hook h is used */
 176 #define IS_HOOKED(h) (debugger_hooks[h].hook._##h != NULL)
 177
 178 /* some macros needed to create the info string */
 179 #define _DBG_VERSION(major, minor)  #major "." #minor
 180 #define DBG_VERSION(major, minor)   _DBG_VERSION(major, minor)
 181 #define API_VERSION(major, minor)   "API:" DBG_VERSION(major, minor)
 182
 183 /* the API version: change if needed */
 184 #define FIRM_DBG_MAJOR  1
 185 #define FIRM_DBG_MINOR  0
 186
 187 /** for automatic detection of the debug extension */
 188 static const char firm_debug_info_string[] =
 189         API_VERSION(FIRM_DBG_MAJOR, FIRM_DBG_MINOR);
 190
 191 /**
 192  * Returns non-zero, if the debug extension is active
 193  */
 194 int firm_debug_active(void)
 195 {
 196         return is_active;
 197 }  /* firm_debug_active */
 198
 199 /**
 200  * Reset the debug text buffer.
 201  */
 202 static void reset_dbg_buf(void)
 203 {
 204         firm_dbg_msg_buf[0] = '\0';
 205 }  /* reset_dbg_buf */
 206
 207 /**
 208  * Add text to the debug text buffer.
 209  */
 210 static void add_to_dbg_buf(const char *buf)
 211 {
 212         strncat(firm_dbg_msg_buf, buf, sizeof(firm_dbg_msg_buf));
 213 }  /* add_to_dbg_buf */
 214
 215 /**
 216  * Return the content of the debug text buffer.
 217  *
 218  * To be called from the debugger.
 219  */
 220 const char *firm_debug_text(void)
 221 {
 222         firm_dbg_msg_buf[sizeof(firm_dbg_msg_buf) - 1] = '\0';
 223         return firm_dbg_msg_buf;
 224 }  /* firm_debug_text */
 225
 226 /**
 227  * debug output
 228  */
 229 static void dbg_printf(const char *fmt, ...)
 230 {
 231         char buf[1024];
 232
 233         va_list args;
 234         va_start(args, fmt);
 235
 236         if (fmt[0] != '+')
 237                 reset_dbg_buf();
 238         else
 239                 ++fmt;
 240
 241         ir_vsnprintf(buf, sizeof(buf), fmt, args);
 242         va_end(args);
 243
 244         if (redir_output)
 245                 add_to_dbg_buf(buf);
 246         else
 247                 puts(buf);
 248 }  /* dbg_printf */
 249
 250 /**
 251  * A new node is created.
 252  *
 253  * @param ctx   the hook context
 254  * @param irg   the IR graph on which the node is created
 255  * @param node  the new IR node that was created
 256  */
 257 static void dbg_new_node(void *ctx, ir_graph *irg, ir_node *node)
 258 {
 259         bp_nr_t key, *elem;
 260         (void) ctx;
 261         (void) irg;
 262
 263         key.nr        = get_irn_node_nr(node);
 264         key.bp.reason = BP_ON_NEW_NODE;
 265
 266         elem = set_find(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
 267         if (elem && elem->bp.active) {
 268                 dbg_printf("Firm BP %u reached, %+F created\n", elem->bp.bpnr, node);
 269                 firm_debug_break();
 270         }
 271 }  /* dbg_new_node */
 272
 273 /**
 274  * A node is replaced.
 275  *
 276  * @param ctx   the hook context
 277  * @param old   the IR node the is replaced
 278  * @param nw    the new IR node that will replace old
 279  */
 280 static void dbg_replace(void *ctx, ir_node *old, ir_node *nw)
 281 {
 282         bp_nr_t key, *elem;
 283         (void) ctx;
 284
 285         key.nr        = get_irn_node_nr(old);
 286         key.bp.reason = BP_ON_REPLACE;
 287
 288         elem = set_find(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
 289         if (elem && elem->bp.active) {
 290                 dbg_printf("Firm BP %u reached, %+F will be replaced by %+F\n", elem->bp.bpnr, old, nw);
 291                 firm_debug_break();
 292         }
 293 }  /* dbg_replace */
 294
 295 /**
 296  * A new node is lowered.
 297  *
 298  * @param ctx   the hook context
 299  * @param node  the new IR node that will be lowered
 300  */
 301 static void dbg_lower(void *ctx, ir_node *node)
 302 {
 303         bp_nr_t key, *elem;
 304         (void) ctx;
 305
 306         key.nr        = get_irn_node_nr(node);
 307         key.bp.reason = BP_ON_LOWER;
 308
 309         elem = set_find(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
 310         if (elem && elem->bp.active) {
 311                 dbg_printf("Firm BP %u reached, %+F will be lowered\n", elem->bp.bpnr, node);
 312                 firm_debug_break();
 313         }
 314 }  /* dbg_lower */
 315
 316 /**
 317  * A graph will be deleted.
 318  *
 319  * @param ctx   the hook context
 320  * @param irg   the IR graph that will be deleted
 321  */
 322 static void dbg_free_graph(void *ctx, ir_graph *irg)
 323 {
 324         (void) ctx;
 325         {
 326                 bp_nr_t key, *elem;
 327                 key.nr        = get_irg_graph_nr(irg);
 328                 key.bp.reason = BP_ON_REMIRG;
 329
 330                 elem = set_find(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
 331                 if (elem && elem->bp.active) {
 332                         ir_printf("Firm BP %u reached, %+F will be deleted\n", elem->bp.bpnr, irg);
 333                         firm_debug_break();
 334                 }
 335         }
 336         {
 337                 bp_ident_t key, *elem;
 338                 ir_entity *ent = get_irg_entity(irg);
 339
 340                 if (! ent)
 341                         return;
 342
 343                 key.id        = get_entity_ident(ent);
 344                 key.bp.reason = BP_ON_REMIRG;
 345
 346                 elem = set_find(bp_idents, &key, sizeof(key), HASH_IDENT_BP(key));
 347                 if (elem && elem->bp.active) {
 348                         dbg_printf("Firm BP %u reached, %+F will be deleted\n", elem->bp.bpnr, ent);
 349                         firm_debug_break();
 350                 }
 351         }
 352 }  /* dbg_free_graph */
 353
 354 /**
 355  * An entity was created.
 356  *
 357  * @param ctx   the hook context
 358  * @param ent   the newly created entity
 359  */
 360 static void dbg_new_entity(void *ctx, ir_entity *ent)
 361 {
 362         (void) ctx;
 363         {
 364                 bp_ident_t key, *elem;
 365
 366                 key.id        = get_entity_ident(ent);
 367                 key.bp.reason = BP_ON_NEW_ENT;
 368
 369                 elem = set_find(bp_idents, &key, sizeof(key), HASH_IDENT_BP(key));
 370                 if (elem && elem->bp.active) {
 371                         ir_printf("Firm BP %u reached, %+F was created\n", elem->bp.bpnr, ent);
 372                         firm_debug_break();
 373                 }
 374         }
 375         {
 376                 bp_nr_t key, *elem;
 377
 378                 key.nr        = get_entity_nr(ent);
 379                 key.bp.reason = BP_ON_NEW_ENT;
 380
 381                 elem = set_find(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
 382                 if (elem && elem->bp.active) {
 383                         dbg_printf("Firm BP %u reached, %+F was created\n", elem->bp.bpnr, ent);
 384                         firm_debug_break();
 385                 }
 386         }
 387 }  /* dbg_new_entity */
 388
 389 /**
 390  * A type was created.
 391  *
 392  * @param ctx   the hook context
 393  * @param tp    the newly created type
 394  */
 395 static void dbg_new_type(void *ctx, ir_type *tp)
 396 {
 397         (void) ctx;
 398         {
 399                 bp_nr_t key, *elem;
 400
 401                 key.nr        = get_type_nr(tp);
 402                 key.bp.reason = BP_ON_NEW_TYPE;
 403
 404                 elem = set_find(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
 405                 if (elem && elem->bp.active) {
 406                         ir_printf("Firm BP %u reached, %+F was created\n", elem->bp.bpnr, tp);
 407                         firm_debug_break();
 408                 }
 409         }
 410 }  /* dbg_new_type */
 411
 412 /**
 413  * Return the reason string.
 414  */
 415 static const char *reason_str(bp_reasons_t reason)
 416 {
 417         switch (reason) {
 418         case BP_ON_NEW_NODE: return "node creation";
 419         case BP_ON_REPLACE:  return "node replace";
 420         case BP_ON_LOWER:    return "node lowering";
 421         case BP_ON_REMIRG:   return "removing IRG";
 422         case BP_ON_NEW_ENT:  return "entity creation";
 423         case BP_ON_NEW_TYPE: return "type creation";
 424         case BP_MAX_REASON:  break;
 425         }
 426         panic("unsupported reason");
 427 }  /* reason_str */
 428
 429 /**
 430  * Compare two number breakpoints.
 431  */
 432 static int cmp_nr_bp(const void *elt, const void *key, size_t size)
 433 {
 434         const bp_nr_t *e1 = elt;
 435         const bp_nr_t *e2 = key;
 436         (void) size;
 437
 438         return (e1->nr - e2->nr) | (e1->bp.reason - e2->bp.reason);
 439 }  /* cmp_nr_bp */
 440
 441 /**
 442  * Compare two ident breakpoints.
 443  */
 444 static int cmp_ident_bp(const void *elt, const void *key, size_t size)
 445 {
 446         const bp_ident_t *e1 = elt;
 447         const bp_ident_t *e2 = key;
 448         (void) size;
 449
 450         return (e1->id != e2->id) | (e1->bp.reason - e2->bp.reason);
 451 }  /* cmp_ident_bp */
 452
 453 /**
 454  * Update the hooks.
 455  */
 456 static void update_hooks(breakpoint *bp)
 457 {
 458 #define CASE_ON(a, b)  case a: if (! IS_HOOKED(hook_##b)) HOOK(hook_##b, dbg_##b); break
 459 #define CASE_OFF(a, b) case a: if (IS_HOOKED(hook_##b)) UNHOOK(hook_##b); break
 460
 461         if (bp->active)
 462                 ++num_active_bp[bp->reason];
 463         else
 464                 --num_active_bp[bp->reason];
 465
 466         if (num_active_bp[bp->reason] > 0) {
 467                 /* register the hooks on demand */
 468                 switch (bp->reason) {
 469                 CASE_ON(BP_ON_NEW_NODE, new_node);
 470                 CASE_ON(BP_ON_REPLACE, replace);
 471                 CASE_ON(BP_ON_LOWER, lower);
 472                 CASE_ON(BP_ON_REMIRG, free_graph);
 473                 CASE_ON(BP_ON_NEW_ENT, new_entity);
 474                 CASE_ON(BP_ON_NEW_TYPE, new_type);
 475                 default:
 476                         ;
 477                 }
 478         }
 479         else {
 480                 /* unregister the hook on demand */
 481                 switch (bp->reason) {
 482                 CASE_OFF(BP_ON_NEW_NODE, new_node);
 483                 CASE_OFF(BP_ON_REPLACE, replace);
 484                 CASE_OFF(BP_ON_LOWER, lower);
 485                 CASE_OFF(BP_ON_REMIRG, free_graph);
 486                 CASE_OFF(BP_ON_NEW_ENT, new_entity);
 487                 CASE_OFF(BP_ON_NEW_TYPE, new_type);
 488                 default:
 489                         ;
 490                 }
 491         }
 492 #undef CASE_ON
 493 #undef CASE_OFF
 494 }  /* update_hooks */
 495
 496 /**
 497  * Break if nr is reached.
 498  */
 499 static void break_on_nr(long nr, bp_reasons_t reason)
 500 {
 501         bp_nr_t key, *elem;
 502
 503         key.bp.kind   = BP_NR;
 504         key.bp.bpnr   = 0;
 505         key.bp.active = 1;
 506         key.bp.reason = reason;
 507         key.nr        = nr;
 508
 509         elem = set_insert(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
 510
 511         if (elem->bp.bpnr == 0) {
 512                 /* new break point */
 513                 elem->bp.bpnr = ++bp_num;
 514                 elem->bp.next = bp_list;
 515                 bp_list = &elem->bp;
 516
 517                 dbg_printf("Firm BP %u: %s of Nr %ld\n", elem->bp.bpnr, reason_str(reason), nr);
 518
 519                 update_hooks(&elem->bp);
 520         }
 521 }  /* break_on_nr */
 522
 523 /**
 524  * Break if ident name is reached.
 525  */
 526 static void break_on_ident(const char *name, bp_reasons_t reason)
 527 {
 528         bp_ident_t key, *elem;
 529
 530         key.bp.kind   = BP_IDENT;
 531         key.bp.bpnr   = 0;
 532         key.bp.active = 1;
 533         key.bp.reason = reason;
 534         key.id        = new_id_from_str(name);
 535
 536         elem = set_insert(bp_idents, &key, sizeof(key), HASH_IDENT_BP(key));
 537
 538         if (elem->bp.bpnr == 0) {
 539                 /* new break point */
 540                 elem->bp.bpnr = ++bp_num;
 541                 elem->bp.next = bp_list;
 542                 bp_list = &elem->bp;
 543
 544                 dbg_printf("Firm BP %u: %s of ident \"%s\"\n", elem->bp.bpnr, reason_str(reason), name);
 545
 546                 update_hooks(&elem->bp);
 547         }
 548 }  /* break_on_ident */
 549
 550 /**
 551  * Sets/resets the active flag of breakpoint bp.
 552  */
 553 static void bp_activate(unsigned bp, int active)
 554 {
 555         breakpoint *p;
 556
 557         for (p = bp_list; p; p = p->next) {
 558                 if (p->bpnr == bp) {
 559                         if (p->active != active) {
 560                                 p->active = active;
 561                                 update_hooks(p);
 562                         }
 563
 564                         dbg_printf("Firm BP %u is now %s\n", bp, active ? "enabled" : "disabled");
 565                         return;
 566                 }
 567         }
 568         dbg_printf("Error: Firm BP %u not exists.\n", bp);
 569 }  /* bp_activate */
 570
 571
 572 /**
 573  * Show a list of supported commands
 574  */
 575 static void show_commands(void)
 576 {
 577         dbg_printf("Internal Firm debugger extension $Revision$ commands:\n"
 578                 "init                  break after initialization\n"
 579                 "create nr             break if node nr was created\n"
 580                 "replace nr            break if node nr is replaced by another node\n"
 581                 "lower nr              break before node nr is lowered\n"
 582                 "remirg nr|name        break if the irg of nr or entity name is deleted\n"
 583                 "newent nr|name        break if the entity nr or name was created\n"
 584                 "newtype nr|name       break if the type nr or name was created\n"
 585                 "bp                    show all breakpoints\n"
 586                 "enable nr             enable breakpoint nr\n"
 587                 "disable nr            disable breakpoint nr\n"
 588                 "showtype nr|name      show content of the type nr or name\n"
 589                 "showent nr|name       show content of the entity nr or name\n"
 590                 "setmask name msk      sets the debug module name to mask msk\n"
 591                 "setlvl  name lvl      sets the debug module name to level lvl\n"
 592                 "setoutfile name file  redirects debug output of module name to file\n"
 593                 "irgname name          prints address and graph number of a method given by its name\n"
 594                 "irgldname ldname      prints address and graph number of a method given by its ldname\n"
 595                 "help                  list all commands\n"
 596                 );
 597 }  /* show_commands */
 598
 599 /**
 600  * Shows all Firm breakpoints.
 601  */
 602 static void show_bp(void)
 603 {
 604         breakpoint *p;
 605         bp_nr_t  *node_p;
 606         bp_ident_t *ident_p;
 607         int have_one = 0;
 608
 609         dbg_printf("Firm Breakpoints:");
 610         for (p = bp_list; p; p = p->next) {
 611                 have_one = 1;
 612                 dbg_printf("+\n  BP %u: ", p->bpnr);
 613
 614                 switch (p->kind) {
 615                 case BP_NR:
 616                         node_p = (bp_nr_t *)p;
 617                         dbg_printf("%s of Nr %ld ", reason_str(p->reason), node_p->nr);
 618                         break;
 619
 620                 case BP_IDENT:
 621                         ident_p = (bp_ident_t *)p;
 622                         dbg_printf("+%s of ident \"%s\" ", reason_str(p->reason), get_id_str(ident_p->id));
 623                         break;
 624                 }
 625
 626                 dbg_printf(p->active ? "+enabled" : "+disabled");
 627         }
 628         dbg_printf(have_one ? "+\n" : "+ NONE\n");
 629 }  /* show_bp */
 630
 631 /**
 632  * firm_dbg_register() expects that the name is stored persistent.
 633  * So we need this little helper function
 634  */
 635 static firm_dbg_module_t *dbg_register(const char *name)
 636 {
 637         ident *id = new_id_from_str(name);
 638
 639         return firm_dbg_register(get_id_str(id));
 640 }  /* dbg_register */
 641
 642 /**
 643  * Sets the debug mask of module name to lvl
 644  */
 645 static void set_dbg_level(const char *name, unsigned lvl)
 646 {
 647         firm_dbg_module_t *module = dbg_register(name);
 648
 649         if (firm_dbg_get_mask(module) != lvl) {
 650                 firm_dbg_set_mask(module, lvl);
 651
 652                 dbg_printf("Setting debug mask of module %s to %u\n", name, lvl);
 653         }
 654 }  /* set_dbg_level */
 655
 656 /**
 657  * Redirects the debug output of module name to fname
 658  */
 659 static void set_dbg_outfile(const char *name, const char *fname)
 660 {
 661         firm_dbg_module_t *module = dbg_register(name);
 662         FILE *f = fopen(fname, "w");
 663
 664         if (! f) {
 665                 perror(fname);
 666                 return;
 667         }
 668
 669         firm_dbg_set_file(module, f);
 670         dbg_printf("Redirecting debug output of module %s to file %s\n", name, fname);
 671 }  /* set_dbg_outfile */
 672
 673 /**
 674  * Show info about a firm thing.
 675  */
 676 static void show_firm_object(void *firm_thing)
 677 {
 678         FILE *f = stdout;
 679
 680         if (firm_thing == NULL) {
 681                 fprintf(f, "<NULL>\n");
 682                 return;
 683         }
 684         switch (get_kind(firm_thing)) {
 685         case k_BAD:
 686                 fprintf(f, "BAD: (%p)\n", firm_thing);
 687                 break;
 688         case k_entity:
 689                 dump_entity_to_file(f, firm_thing, dump_verbosity_max);
 690                 break;
 691         case k_type:
 692                 dump_type_to_file(f, firm_thing, dump_verbosity_max);
 693                 break;
 694         case k_ir_graph:
 695         case k_ir_node:
 696         case k_ir_mode:
 697         case k_ir_op:
 698         case k_tarval:
 699         case k_ir_loop:
 700         case k_ir_compound_graph_path:
 701         case k_ir_extblk:
 702         case k_ir_prog:
 703                 fprintf(f, "NIY\n");
 704                 break;
 705         default:
 706                 fprintf(f, "Cannot identify thing at (%p).\n", firm_thing);
 707         }
 708 }  /* show_firm_object */
 709
 710 /**
 711  * Find a firm type by its number.
 712  */
 713 static ir_type *find_type_nr(long nr)
 714 {
 715         int i, n = get_irp_n_types();
 716         ir_type *tp;
 717
 718         for (i = 0; i < n; ++i) {
 719                 tp = get_irp_type(i);
 720                 if (get_type_nr(tp) == nr)
 721                         return tp;
 722         }
 723         tp = get_glob_type();
 724         if (get_type_nr(tp) == nr)
 725                 return tp;
 726         return NULL;
 727 }  /* find_type_nr */
 728
 729 /**
 730  * Find a firm type by its name.
 731  */
 732 static ir_type *find_type_name(const char *name)
 733 {
 734         int i, n = get_irp_n_types();
 735         ir_type *tp;
 736
 737         for (i = 0; i < n; ++i) {
 738                 tp = get_irp_type(i);
 739                 if (!is_compound_type(tp))
 740                         continue;
 741
 742                 if (strcmp(get_compound_name(tp), name) == 0)
 743                         return tp;
 744         }
 745         tp = get_glob_type();
 746         if (strcmp(get_compound_name(tp), name) == 0)
 747                 return tp;
 748         return NULL;
 749 }  /* find_type_name */
 750
 751 /** The environment for the entity search functions. */
 752 typedef struct find_env {
 753         union {
 754                 long        nr;   /**< the number that is searched for */
 755                 const char *name; /**< the name that is searched for */
 756         } u;
 757         ir_entity *res;     /**< the result */
 758 } find_env_t;
 759
 760 /**
 761  * Type-walker: Find an entity with given number.
 762  */
 763 static void check_ent_nr(type_or_ent tore, void *ctx)
 764 {
 765         find_env_t *env = ctx;
 766
 767         if (is_entity(tore.ent)) {
 768                 if (get_entity_nr(tore.ent) == env->u.nr) {
 769                         env->res = tore.ent;
 770                 }
 771         }
 772 }  /* check_ent_nr */
 773
 774 /**
 775  * Type-walker: Find an entity with given name.
 776  */
 777 static void check_ent_name(type_or_ent tore, void *ctx)
 778 {
 779         find_env_t *env = ctx;
 780
 781         if (is_entity(tore.ent))
 782                 if (strcmp(get_entity_name(tore.ent), env->u.name) == 0) {
 783                         env->res = tore.ent;
 784                 }
 785 }  /* check_ent_name */
 786
 787 /**
 788  * Find a firm entity by its number.
 789  */
 790 static ir_entity *find_entity_nr(long nr)
 791 {
 792         find_env_t env;
 793
 794         env.u.nr = nr;
 795         env.res  = NULL;
 796         type_walk(check_ent_nr, NULL, &env);
 797         return env.res;
 798 }  /* find_entity_nr */
 799
 800 /**
 801  * Find a firm entity by its name.
 802  */
 803 static ir_entity *find_entity_name(const char *name)
 804 {
 805         find_env_t env;
 806
 807         env.u.name = name;
 808         env.res    = NULL;
 809         type_walk(check_ent_name, NULL, &env);
 810         return env.res;
 811 }  /* find_entity_name */
 812
 813 /**
 814  * Search methods for a name.
 815  */
 816 static void show_by_name(type_or_ent tore, void *env)
 817 {
 818         ident *id = (ident *)env;
 819
 820         if (is_entity(tore.ent)) {
 821                 ir_entity *ent = tore.ent;
 822
 823                 if (is_method_entity(ent)) {
 824                         if (get_entity_ident(ent) == id) {
 825                                 ir_type *owner = get_entity_owner(ent);
 826                                 ir_graph *irg = get_entity_irg(ent);
 827
 828                                 if (owner != get_glob_type()) {
 829                                         printf("%s::%s", get_compound_name(owner), get_id_str(id));
 830                                 } else {
 831                                         printf("%s", get_id_str(id));
 832                                 }
 833                                 if (irg)
 834                                         printf("[%ld] (%p)\n", get_irg_graph_nr(irg), irg);
 835                                 else
 836                                         printf(" NULL\n");
 837                         }
 838                 }
 839         }
 840 }  /* show_by_name */
 841
 842 /**
 843  * Search methods for a ldname.
 844  */
 845 static void show_by_ldname(type_or_ent tore, void *env)
 846 {
 847         ident *id = (ident *)env;
 848
 849         if (is_entity(tore.ent)) {
 850                 ir_entity *ent = tore.ent;
 851
 852                 if (is_method_entity(ent)) {
 853                         if (get_entity_ld_ident(ent) == id) {
 854                                 ir_type *owner = get_entity_owner(ent);
 855                                 ir_graph *irg = get_entity_irg(ent);
 856
 857                                 if (owner != get_glob_type()) {
 858                                         printf("%s::%s", get_compound_name(owner), get_id_str(id));
 859                                 } else {
 860                                         printf("%s", get_id_str(id));
 861                                 }
 862                                 if (irg)
 863                                         printf("[%ld] (%p)\n", get_irg_graph_nr(irg), irg);
 864                                 else
 865                                         printf(" NULL\n");
 866                         }
 867                 }
 868         }
 869 }  /* show_by_ldname */
 870
 871 /**
 872  * prints the address and graph number of all irgs with given name
 873  */
 874 static void irg_name(const char *name)
 875 {
 876         ident *id = new_id_from_str(name);
 877
 878         type_walk(show_by_name, NULL, (void *)id);
 879 }  /* irg_name */
 880
 881 /**
 882  * prints the address and graph number of all irgs with given ld_name
 883  */
 884 static void irg_ld_name(const char *name)
 885 {
 886         ident *id = new_id_from_str(name);
 887
 888         type_walk(show_by_ldname, NULL, (void *)id);
 889 }  /* irg_ld_name */
 890
 891 enum tokens {
 892         tok_create = 256,
 893         tok_replace,
 894         tok_lower,
 895         tok_remirg,
 896         tok_newent,
 897         tok_newtype,
 898         tok_showtype,
 899         tok_showent,
 900         tok_init,
 901         tok_bp,
 902         tok_enable,
 903         tok_disable,
 904         tok_setmask,
 905         tok_setlvl,
 906         tok_setoutfile,
 907         tok_irgname,
 908         tok_irgldname,
 909         tok_help,
 910         tok_identifier,
 911         tok_number,
 912         tok_eof,
 913         tok_error
 914 };
 915
 916 static const char *reserved[] = {
 917         "create",
 918         "replace",
 919         "lower",
 920         "remirg",
 921         "newent",
 922         "newtype",
 923         "showtype",
 924         "showent",
 925         "init",
 926         "bp",
 927         "enable",
 928         "disable",
 929         "setmask",
 930         "setlvl",
 931         "setoutfile",
 932         "irgname",
 933         "irgldname",
 934         "help"
 935 };
 936
 937 /**
 938  * The Lexer data.
 939  */
 940 static struct lexer {
 941         int has_token;        /**< set if a token is cached. */
 942         unsigned cur_token;   /**< current token. */
 943         unsigned number;      /**< current token attribute. */
 944         const char *s;        /**< current token attribute. */
 945         unsigned len;         /**< current token attribute. */
 946
 947         const char *curr_pos;
 948         const char *end_pos;
 949         const char *tok_start;
 950 } lexer;
 951
 952 /**
 953  * Initialize the lexer.
 954  */
 955 static void init_lexer(const char *input)
 956 {
 957         lexer.has_token = 0;
 958         lexer.curr_pos  = input;
 959         lexer.end_pos   = input + strlen(input);
 960 }  /* init_lexer */
 961
 962
 963 /**
 964  * Get the next char from the input.
 965  */
 966 static char next_char(void)
 967 {
 968         if (lexer.curr_pos >= lexer.end_pos)
 969                 return '\0';
 970         return *lexer.curr_pos++;
 971 }  /* next_char */
 972
 973 #define unput()         if (lexer.curr_pos < lexer.end_pos) --lexer.curr_pos
 974
 975 #undef MIN
 976 #define MIN(a, b) (a) < (b) ? (a) : (b)
 977
 978 /**
 979  * The lexer.
 980  */
 981 static unsigned get_token(void)
 982 {
 983         char c;
 984         int i;
 985
 986         /* skip white space */
 987         do {
 988                 c = next_char();
 989         } while (c != '\0' && isspace(c));
 990
 991         lexer.tok_start = lexer.curr_pos - 1;
 992         if (c == '.' || isalpha(c)) {
 993                 /* command begins here */
 994                 int         len = 0;
 995                 const char* tok_start;
 996
 997                 do {
 998                         c = next_char();
 999                         ++len;
1000                 } while (isgraph(c));
1001                 unput();
1002
1003                 tok_start = lexer.tok_start;
1004                 if (*tok_start == '.') {
1005                         ++tok_start;
1006                         --len;
1007                 }
1008                 for (i = sizeof(reserved)/sizeof(reserved[0]) - 1; i >= 0; --i) {
1009                         if (strncasecmp(tok_start, reserved[i], len) == 0 && reserved[i][len] == '\0')
1010                                 return 256 + i;
1011                 }
1012
1013                 /* identifier */
1014                 lexer.s   = lexer.tok_start;
1015                 lexer.len = lexer.curr_pos - lexer.s;
1016                 return tok_identifier;
1017         } else if (isdigit(c) || c == '-') {
1018                 unsigned number = 0;
1019                 unsigned sign   = 0;
1020
1021                 /* we support negative numbers as well, so one can easily set all bits with -1 */
1022                 if (c == '-') {
1023                         sign = 1;
1024                         c    = next_char();
1025                 }
1026
1027                 if (c == '0') {
1028                         c = next_char();
1029
1030                         if (c == 'x' || c == 'X') {
1031                                 for (;;) {
1032                                         c = next_char();
1033
1034                                         if (! isxdigit(c))
1035                                                 break;
1036                                         if (isdigit(c))
1037                                                 number = (number << 4) | (c - '0');
1038                                         else
1039                                                 number = (number << 4) | (toupper(c) - 'A' + 10);
1040                                 }
1041                                 unput();
1042                                 lexer.number = number;
1043                                 return tok_number;
1044                         }
1045                 }
1046                 for (;;) {
1047                         if (! isdigit(c))
1048                                 break;
1049                         number = number * 10 + (c - '0');
1050                         c = next_char();
1051                 }
1052                 unput();
1053                 lexer.number = sign ? 0 - number : number;
1054                 return tok_number;
1055         }
1056         else if (c == '\0')
1057                 return tok_eof;
1058         return c;
1059 }  /* get_token */
1060
1061 /**
1062  * High level function to use from debugger interface
1063  *
1064  * See show_commands() for supported commands.
1065  */
1066 void firm_debug(const char *cmd)
1067 {
1068         char name[1024], fname[1024];
1069         int len;
1070
1071         init_lexer(cmd);
1072
1073         for (;;) {
1074                 unsigned token;
1075
1076                 token = get_token();
1077
1078                 switch (token) {
1079                 case tok_eof:
1080                         goto leave;
1081
1082                 case tok_create:
1083                         token = get_token();
1084                         if (token != tok_number)
1085                                 goto error;
1086                         break_on_nr(lexer.number, BP_ON_NEW_NODE);
1087                         break;
1088
1089                 case tok_replace:
1090                         token = get_token();
1091                         if (token != tok_number)
1092                                 goto error;
1093                         break_on_nr(lexer.number, BP_ON_REPLACE);
1094                         break;
1095
1096                 case tok_lower:
1097                         token = get_token();
1098                         if (token != tok_number)
1099                                 goto error;
1100                         break_on_nr(lexer.number, BP_ON_LOWER);
1101                         break;
1102
1103                 case tok_remirg:
1104                         token = get_token();
1105
1106                         if (token == tok_number)
1107                                 break_on_nr(lexer.number, BP_ON_REMIRG);
1108                         else if (token == tok_identifier) {
1109                                 len = MIN(lexer.len, 1023);
1110                                 strncpy(name, lexer.s, len);
1111                                 name[len] = '\0';
1112                                 break_on_ident(name, BP_ON_REMIRG);
1113                         } else
1114                                 goto error;
1115                         break;
1116
1117                 case tok_newent:
1118                         token = get_token();
1119
1120                         if (token == tok_number)
1121                                 break_on_nr(lexer.number, BP_ON_NEW_ENT);
1122                         else if (token == tok_identifier) {
1123                                 len = MIN(lexer.len, 1023);
1124                                 strncpy(name, lexer.s, len);
1125                                 name[len] = '\0';
1126                                 break_on_ident(name, BP_ON_NEW_ENT);
1127                         } else
1128                                 goto error;
1129                         break;
1130
1131                 case tok_newtype:
1132                         token = get_token();
1133
1134                         if (token == tok_number)
1135                                 break_on_nr(lexer.number, BP_ON_NEW_TYPE);
1136                         else if (token == tok_identifier) {
1137                                 len = MIN(lexer.len, 1023);
1138                                 strncpy(name, lexer.s, len);
1139                                 name[len] = '\0';
1140                                 break_on_ident(name, BP_ON_NEW_TYPE);
1141                         } else
1142                                 goto error;
1143                         break;
1144
1145                 case tok_showtype:
1146                         token = get_token();
1147
1148                         if (token == tok_number)
1149                                 show_firm_object(find_type_nr(lexer.number));
1150                         else if (token == tok_identifier) {
1151                                 len = MIN(lexer.len, 1023);
1152                                 strncpy(name, lexer.s, len);
1153                                 name[len] = '\0';
1154                                 show_firm_object(find_type_name(name));
1155                         } else
1156                                 goto error;
1157                         break;
1158
1159                 case tok_showent:
1160                         token = get_token();
1161
1162                         if (token == tok_number)
1163                                 show_firm_object(find_entity_nr(lexer.number));
1164                         else if (token == tok_identifier) {
1165                                 len = MIN(lexer.len, 1023);
1166                                 strncpy(name, lexer.s, len);
1167                                 name[len] = '\0';
1168                                 show_firm_object(find_entity_name(name));
1169                         } else
1170                                 goto error;
1171                         break;
1172
1173                 case tok_init:
1174                         break_on_init = 1;
1175                         break;
1176
1177                 case tok_bp:
1178                         show_bp();
1179                         break;
1180
1181                 case tok_enable:
1182                         token = get_token();
1183                         if (token != tok_number)
1184                                 goto error;
1185                         bp_activate(lexer.number, 1);
1186                         break;
1187
1188                 case tok_disable:
1189                         token = get_token();
1190                         if (token != tok_number)
1191                                 goto error;
1192                         bp_activate(lexer.number, 0);
1193                         break;
1194
1195                 case tok_setmask:
1196                         token = get_token();
1197                         if (token != tok_identifier)
1198                                 goto error;
1199                         len = MIN(lexer.len, 1023);
1200                         strncpy(name, lexer.s, len);
1201                         name[len] = '\0';
1202
1203                         token = get_token();
1204                         if (token != tok_number)
1205                                 goto error;
1206                         set_dbg_level(name, lexer.number);
1207                         break;
1208
1209                 case tok_setlvl:
1210                         token = get_token();
1211                         if (token != tok_identifier)
1212                                 goto error;
1213                         len = MIN(lexer.len, 1023);
1214                         strncpy(name, lexer.s, len);
1215                         name[len] = '\0';
1216
1217                         token = get_token();
1218                         if (token != tok_number)
1219                                 goto error;
1220                         set_dbg_level(name, (1 << lexer.number) - 1);
1221                         break;
1222
1223                 case tok_setoutfile:
1224                         token = get_token();
1225                         if (token != tok_identifier)
1226                                 goto error;
1227                         len = MIN(lexer.len, 1023);
1228                         strncpy(name, lexer.s, len);
1229                         name[len] = '\0';
1230
1231                         token = get_token();
1232                         if (token != tok_identifier)
1233                                 goto error;
1234                         len = MIN(lexer.len, 1023);
1235                         strncpy(fname, lexer.s, len);
1236                         fname[len] = '\0';
1237                         set_dbg_outfile(name, fname);
1238
1239                 case tok_irgname:
1240                         token = get_token();
1241                         if (token != tok_identifier)
1242                                 goto error;
1243                         len = MIN(lexer.len, 1023);
1244                         strncpy(name, lexer.s, len);
1245                         name[len] = '\0';
1246                         irg_name(name);
1247
1248                 case tok_irgldname:
1249                         token = get_token();
1250                         if (token != tok_identifier)
1251                                 goto error;
1252                         len = MIN(lexer.len, 1023);
1253                         strncpy(name, lexer.s, len);
1254                         name[len] = '\0';
1255                         irg_ld_name(name);
1256                         break;
1257
1258                 case tok_help:
1259                         show_commands();
1260                         break;
1261
1262                 case tok_error:
1263                 default:
1264 error:
1265                         printf("Error: before %s\n", lexer.tok_start);
1266                         show_commands();
1267                         goto leave;
1268                 }
1269
1270                 token = get_token();
1271                 if (token == tok_eof)
1272                         break;
1273                 if (token != ';')
1274                         goto error;
1275         }
1276 leave:
1277         ;
1278 }  /* firm_debug */
1279
1280 /* creates the debugger tables */
1281 void firm_init_debugger(void)
1282 {
1283         char *env;
1284
1285         bp_numbers = new_set(cmp_nr_bp, 8);
1286         bp_idents  = new_set(cmp_ident_bp, 8);
1287
1288         env = getenv("FIRMDBG");
1289
1290         is_active = 1;
1291
1292         if (env)
1293                 firm_debug(env);
1294
1295         if (break_on_init)
1296                 firm_debug_break();
1297 }  /* firm_init_debugger */
1298
1299 /**
1300  * A gdb helper function to print firm objects.
1301  */
1302 const char *gdb_node_helper(void *firm_object)
1303 {
1304         static char buf[1024];
1305         ir_snprintf(buf, sizeof(buf), "%+F", firm_object);
1306         return buf;
1307 }
1308
1309 /**
1310  * A gdb helper function to print tarvals.
1311  */
1312 const char *gdb_tarval_helper(void *tv_object)
1313 {
1314         static char buf[1024];
1315         ir_snprintf(buf, sizeof(buf), "%+T", tv_object);
1316         return buf;
1317 }
1318
1319 const char *gdb_out_edge_helper(const ir_node *node)
1320 {
1321         static char buf[4*1024];
1322         char *b = buf;
1323         size_t l;
1324         size_t len = sizeof(buf);
1325         const ir_edge_t *edge;
1326         foreach_out_edge(node, edge) {
1327                 ir_node *n = get_edge_src_irn(edge);
1328
1329                 ir_snprintf(b, len, "%+F  ", n);
1330                 l = strlen(b);
1331                 len -= l;
1332                 b += l;
1333         }
1334
1335         return buf;
1336 }
1337
1338 #else
1339
1340 /* some picky compiler do not allow empty files */
1341 static int __attribute__((unused)) _firm_only_that_you_can_compile_with_NDEBUG_defined;
1342
1343 #endif /* NDEBUG */
1344
1345 /**
1346  * @page debugger   The Firm debugger extension
1347  *
1348  * Firm contains a debugger extension. This allows to set debugger breakpoints
1349  * an various events.
1350  * The extension uses a text interface which can be accessed from most debuggers.
1351  * More than one command can be given separated by ';'.
1352  *
1353  * @section sec_cmd Supported commands
1354  *
1355  * Historically all debugger commands start with a dot.  This isn't needed in newer
1356  * versions, but still supported, ie the commands ".init" and "init" are equal.
1357  * The following commands are currently supported:
1358  *
1359  * @b init
1360  *
1361  * Break immediately after the debugger extension was initialized.
1362  * Typically this command is used in the environment to stop the execution
1363  * of a Firm compiler right after the initialization, like this:
1364  *
1365  * $export FIRMDBG=".init"
1366  *
1367  * @b create nr
1368  *
1369  * Break if a new IR-node with node number nr was created.
1370  * Typically used to find the place where wrong nodes are created.
1371  *
1372  * @b replace nr
1373  *
1374  * Break before IR-node with node number nr is replaced by another node.
1375  *
1376  * @b lower nr
1377  *
1378  * Break before IR-node with node number nr is lowered.
1379  *
1380  * @b remirg nr
1381  *
1382  * Break if the irg with graph number nr is deleted.
1383  *
1384  * @b remirg name
1385  *
1386  * Break if the irg of entity name is deleted.
1387  *
1388  * @b newent nr
1389  *
1390  * Break if the entity with number nr was created.
1391  *
1392  * @b newent name
1393  *
1394  * Break if the entity name was created.
1395  *
1396  * @b newtype nr
1397  *
1398  * Break if the type with number nr was created.
1399  *
1400  * @b newtype name
1401  *
1402  * Break if the type name was created.
1403  *
1404  * @b bp
1405  *
1406  * Show all Firm internal breakpoints.
1407  *
1408  * @b enable nr
1409  *
1410  * Enables breakpoint nr.
1411  *
1412  * @b disable nr
1413  *
1414  * Disables breakpoint nr.
1415  *
1416  * @b showent nr
1417  *
1418  * Show the content of entity nr.
1419  *
1420  * @b showent name
1421  *
1422  * Show the content of entity name.
1423  *
1424  * @b showtype nr
1425  *
1426  * Show the content of type nr.
1427  *
1428  * @b showtype name
1429  *
1430  * Show the content of type name.
1431  *
1432  * @b setmask name msk
1433  *
1434  * Sets the debug module name to mask msk.
1435  *
1436  * @b setlvl name lvl
1437  *
1438  * Sets the debug module name to level lvl.
1439  *
1440  * @b setoutfile name file
1441  *
1442  * Redirects debug output of module name to file.
1443  *
1444  * @b irgname name
1445  *
1446  * Prints address and graph number of a method given by its name.
1447  *
1448  * @b irgldname name
1449  *
1450  * Prints address and graph number of a method given by its linker name.
1451  *
1452  * @b help
1453  *
1454  * List all commands.
1455  *
1456  *
1457  * The Firm debugger extension can be accessed using the function firm_debug().
1458  * The following example shows how to set a creation breakpoint in GDB when
1459  * node 2101 is created.
1460  *
1461  * -# set FIRMDBG="init"
1462  * -# start gdb with your compiler
1463  * -# after gdb breaks, issue
1464  *
1465  * call firm_debug("create 2101")
1466  *
1467  * On the console the following text should be issued:
1468  *
1469  * Firm BP 1: creation of Node 2101
1470  *
1471  *
1472  * @section gdb_macro GDB macro
1473  *
1474  * Add the following to your .gdbinit file:
1475  * @code
1476  #
1477  # define firm "cmd"  Firm debugger extension
1478  #
1479  define firm
1480  call firm_debug($arg0)
1481  end
1482  * @endcode
1483  *
1484  * Then, all Firm debugger extension commands can be accessed in the gdb
1485  * console using the firm prefix, eg.:
1486  *
1487  * firm "create 2101"
1488  *
1489  * firm "help"
1490  */