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

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