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