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         ir_entity *ent = (ir_entity *)tore;
 770         find_env_t *env = ctx;
 771
 772         if (is_entity(ent))
 773                 if (get_entity_nr(ent) == env->u.nr) {
 774                         env->res = ent;
 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         ir_entity *ent = (ir_entity *)tore;
 783         find_env_t *env = ctx;
 784
 785         if (is_entity(ent))
 786                 if (strcmp(get_entity_name(ent), env->u.name) == 0) {
 787                         env->res = ent;
 788                 }
 789 }  /* check_ent_name */
 790
 791 /**
 792  * Find a firm entity by its number.
 793  */
 794 static ir_entity *find_entity_nr(long nr) {
 795         find_env_t env;
 796
 797         env.u.nr = nr;
 798         env.res  = NULL;
 799         type_walk(check_ent_nr, NULL, &env);
 800         return env.res;
 801 }  /* find_entity_nr */
 802
 803 /**
 804  * Find a firm entity by its name.
 805  */
 806 static ir_entity *find_entity_name(const char *name) {
 807         find_env_t env;
 808
 809         env.u.name = name;
 810         env.res    = NULL;
 811         type_walk(check_ent_name, NULL, &env);
 812         return env.res;
 813 }  /* find_entity_name */
 814
 815 /**
 816  * Search methods for a name.
 817  */
 818 static void show_by_name(type_or_ent *tore, void *env) {
 819         ident *id = (ident *)env;
 820
 821         if (is_entity(tore)) {
 822                 ir_entity *ent = (ir_entity *)tore;
 823
 824                 if (is_method_entity(ent)) {
 825                         if (get_entity_ident(ent) == id) {
 826                                 ir_type *owner = get_entity_owner(ent);
 827                                 ir_graph *irg = get_entity_irg(ent);
 828
 829                                 if (owner != get_glob_type()) {
 830                                         printf("%s::%s", get_type_name(owner), get_id_str(id));
 831                                 } else {
 832                                         printf("%s", get_id_str(id));
 833                                 }
 834                                 if (irg)
 835                                         printf("[%ld] (%p)\n", get_irg_graph_nr(irg), irg);
 836                                 else
 837                                         printf(" NULL\n");
 838                         }
 839                 }
 840         }
 841 }  /* show_by_name */
 842
 843 /**
 844  * Search methods for a ldname.
 845  */
 846 static void show_by_ldname(type_or_ent *tore, void *env) {
 847         ident *id = (ident *)env;
 848
 849         if (is_entity(tore)) {
 850                 ir_entity *ent = (ir_entity *)tore;
 851
 852                 if (is_method_entity(ent)) {
 853                         if (get_entity_ld_ident(ent) == id) {
 854                                 ir_type *owner = get_entity_owner(ent);
 855                                 ir_graph *irg = get_entity_irg(ent);
 856
 857                                 if (owner != get_glob_type()) {
 858                                         printf("%s::%s", get_type_name(owner), get_id_str(id));
 859                                 } else {
 860                                         printf("%s", get_id_str(id));
 861                                 }
 862                                 if (irg)
 863                                         printf("[%ld] (%p)\n", get_irg_graph_nr(irg), irg);
 864                                 else
 865                                         printf(" NULL\n");
 866                         }
 867                 }
 868         }
 869 }  /* show_by_ldname */
 870
 871 /**
 872  * prints the address and graph number of all irgs with given name
 873  */
 874 static void irg_name(const char *name) {
 875         ident *id = new_id_from_str(name);
 876
 877         type_walk(show_by_name, NULL, (void *)id);
 878 }  /* irg_name */
 879
 880 /**
 881  * prints the address and graph number of all irgs with given ld_name
 882  */
 883 static void irg_ld_name(const char *name) {
 884         ident *id = new_id_from_str(name);
 885
 886         type_walk(show_by_ldname, NULL, (void *)id);
 887 }  /* irg_ld_name */
 888
 889 enum tokens {
 890         tok_create = 256,
 891         tok_replace,
 892         tok_lower,
 893         tok_remirg,
 894         tok_newent,
 895         tok_newtype,
 896         tok_showtype,
 897         tok_showent,
 898         tok_init,
 899         tok_bp,
 900         tok_enable,
 901         tok_disable,
 902         tok_setmask,
 903         tok_setlvl,
 904         tok_setoutfile,
 905         tok_irgname,
 906         tok_irgldname,
 907         tok_help,
 908         tok_identifier,
 909         tok_number,
 910         tok_eof,
 911         tok_error
 912 };
 913
 914 static const char *reserved[] = {
 915         "create",
 916         "replace",
 917         "lower",
 918         "remirg",
 919         "newent",
 920         "newtype",
 921         "showtype",
 922         "showent",
 923         "init",
 924         "bp",
 925         "enable",
 926         "disable",
 927         "setmask",
 928         "setlvl",
 929         "setoutfile",
 930         "irgname",
 931         "irgldname",
 932         "help"
 933 };
 934
 935 /**
 936  * The Lexer data.
 937  */
 938 static struct lexer {
 939         int has_token;        /**< set if a token is cached. */
 940         unsigned cur_token;   /**< current token. */
 941         unsigned number;      /**< current token attribute. */
 942         const char *s;        /**< current token attribute. */
 943         unsigned len;         /**< current token attribute. */
 944
 945         const char *curr_pos;
 946         const char *end_pos;
 947         const char *tok_start;
 948 } lexer;
 949
 950 /**
 951  * Initialize the lexer.
 952  */
 953 static void init_lexer(const char *input) {
 954         lexer.has_token = 0;
 955         lexer.curr_pos  = input;
 956         lexer.end_pos   = input + strlen(input);
 957 }  /* init_lexer */
 958
 959
 960 /**
 961  * Get the next char from the input.
 962  */
 963 static char next_char(void) {
 964         if (lexer.curr_pos >= lexer.end_pos)
 965                 return '\0';
 966         return *lexer.curr_pos++;
 967 }  /* next_char */
 968
 969 #define unput()         if (lexer.curr_pos < lexer.end_pos) --lexer.curr_pos
 970
 971 #undef MIN
 972 #define MIN(a, b) (a) < (b) ? (a) : (b)
 973
 974 /**
 975  * The lexer.
 976  */
 977 static unsigned get_token(void) {
 978         char c;
 979         int i;
 980
 981         /* skip white space */
 982         do {
 983                 c = next_char();
 984         } while (c != '\0' && isspace(c));
 985
 986         lexer.tok_start = lexer.curr_pos - 1;
 987         if (c == '.' || isalpha(c)) {
 988                 /* command begins here */
 989                 int         len = 0;
 990                 const char* tok_start;
 991
 992                 do {
 993                         c = next_char();
 994                         ++len;
 995                 } while (isgraph(c));
 996                 unput();
 997
 998                 tok_start = lexer.tok_start;
 999                 if (*tok_start == '.') {
1000                         ++tok_start;
1001                         --len;
1002                 }
1003                 for (i = sizeof(reserved)/sizeof(reserved[0]) - 1; i >= 0; --i) {
1004                         if (strncasecmp(tok_start, reserved[i], len) == 0 && reserved[i][len] == '\0')
1005                                 return 256 + i;
1006                 }
1007
1008                 /* identifier */
1009                 lexer.s   = lexer.tok_start;
1010                 lexer.len = lexer.curr_pos - lexer.s;
1011                 return tok_identifier;
1012         } else if (isdigit(c) || c == '-') {
1013                 unsigned number = 0;
1014                 unsigned sign   = 0;
1015
1016                 /* we support negative numbers as well, so one can easily set all bits with -1 */
1017                 if (c == '-') {
1018                         sign = 1;
1019                         c    = next_char();
1020                 }
1021
1022                 if (c == '0') {
1023                         c = next_char();
1024
1025                         if (c == 'x' || c == 'X') {
1026                                 for (;;) {
1027                                         c = next_char();
1028
1029                                         if (! isxdigit(c))
1030                                                 break;
1031                                         if (isdigit(c))
1032                                                 number = (number << 4) | (c - '0');
1033                                         else
1034                                                 number = (number << 4) | (toupper(c) - 'A' + 10);
1035                                 }
1036                                 unput();
1037                                 lexer.number = number;
1038                                 return tok_number;
1039                         }
1040                 }
1041                 for (;;) {
1042                         if (! isdigit(c))
1043                                 break;
1044                         number = number * 10 + (c - '0');
1045                         c = next_char();
1046                 }
1047                 unput();
1048                 lexer.number = sign ? 0 - number : number;
1049                 return tok_number;
1050         }
1051         else if (c == '\0')
1052                 return tok_eof;
1053         return c;
1054 }  /* get_token */
1055
1056 /**
1057  * High level function to use from debugger interface
1058  *
1059  * See show_commands() for supported commands.
1060  */
1061 void firm_debug(const char *cmd) {
1062         char name[1024], fname[1024];
1063         int len;
1064
1065         init_lexer(cmd);
1066
1067         for (;;) {
1068                 unsigned token;
1069
1070                 token = get_token();
1071
1072                 switch (token) {
1073                 case tok_eof:
1074                         goto leave;
1075
1076                 case tok_create:
1077                         token = get_token();
1078                         if (token != tok_number)
1079                                 goto error;
1080                         break_on_nr(lexer.number, BP_ON_NEW_NODE);
1081                         break;
1082
1083                 case tok_replace:
1084                         token = get_token();
1085                         if (token != tok_number)
1086                                 goto error;
1087                         break_on_nr(lexer.number, BP_ON_REPLACE);
1088                         break;
1089
1090                 case tok_lower:
1091                         token = get_token();
1092                         if (token != tok_number)
1093                                 goto error;
1094                         break_on_nr(lexer.number, BP_ON_LOWER);
1095                         break;
1096
1097                 case tok_remirg:
1098                         token = get_token();
1099
1100                         if (token == tok_number)
1101                                 break_on_nr(lexer.number, BP_ON_REMIRG);
1102                         else if (token == tok_identifier) {
1103                                 len = MIN(lexer.len, 1023);
1104                                 strncpy(name, lexer.s, len);
1105                                 name[len] = '\0';
1106                                 break_on_ident(name, BP_ON_REMIRG);
1107                         } else
1108                                 goto error;
1109                         break;
1110
1111                 case tok_newent:
1112                         token = get_token();
1113
1114                         if (token == tok_number)
1115                                 break_on_nr(lexer.number, BP_ON_NEW_ENT);
1116                         else if (token == tok_identifier) {
1117                                 len = MIN(lexer.len, 1023);
1118                                 strncpy(name, lexer.s, len);
1119                                 name[len] = '\0';
1120                                 break_on_ident(name, BP_ON_NEW_ENT);
1121                         } else
1122                                 goto error;
1123                         break;
1124
1125                 case tok_newtype:
1126                         token = get_token();
1127
1128                         if (token == tok_number)
1129                                 break_on_nr(lexer.number, BP_ON_NEW_TYPE);
1130                         else if (token == tok_identifier) {
1131                                 len = MIN(lexer.len, 1023);
1132                                 strncpy(name, lexer.s, len);
1133                                 name[len] = '\0';
1134                                 break_on_ident(name, BP_ON_NEW_TYPE);
1135                         } else
1136                                 goto error;
1137                         break;
1138
1139                 case tok_showtype:
1140                         token = get_token();
1141
1142                         if (token == tok_number)
1143                                 show_firm_object(find_type_nr(lexer.number));
1144                         else if (token == tok_identifier) {
1145                                 len = MIN(lexer.len, 1023);
1146                                 strncpy(name, lexer.s, len);
1147                                 name[len] = '\0';
1148                                 show_firm_object(find_type_name(name));
1149                         } else
1150                                 goto error;
1151                         break;
1152
1153                 case tok_showent:
1154                         token = get_token();
1155
1156                         if (token == tok_number)
1157                                 show_firm_object(find_entity_nr(lexer.number));
1158                         else if (token == tok_identifier) {
1159                                 len = MIN(lexer.len, 1023);
1160                                 strncpy(name, lexer.s, len);
1161                                 name[len] = '\0';
1162                                 show_firm_object(find_entity_name(name));
1163                         } else
1164                                 goto error;
1165                         break;
1166
1167                 case tok_init:
1168                         break_on_init = 1;
1169                         break;
1170
1171                 case tok_bp:
1172                         show_bp();
1173                         break;
1174
1175                 case tok_enable:
1176                         token = get_token();
1177                         if (token != tok_number)
1178                                 goto error;
1179                         bp_activate(lexer.number, 1);
1180                         break;
1181
1182                 case tok_disable:
1183                         token = get_token();
1184                         if (token != tok_number)
1185                                 goto error;
1186                         bp_activate(lexer.number, 0);
1187                         break;
1188
1189                 case tok_setmask:
1190                         token = get_token();
1191                         if (token != tok_identifier)
1192                                 goto error;
1193                         len = MIN(lexer.len, 1023);
1194                         strncpy(name, lexer.s, len);
1195                         name[len] = '\0';
1196
1197                         token = get_token();
1198                         if (token != tok_number)
1199                                 goto error;
1200                         set_dbg_level(name, lexer.number);
1201                         break;
1202
1203                 case tok_setlvl:
1204                         token = get_token();
1205                         if (token != tok_identifier)
1206                                 goto error;
1207                         len = MIN(lexer.len, 1023);
1208                         strncpy(name, lexer.s, len);
1209                         name[len] = '\0';
1210
1211                         token = get_token();
1212                         if (token != tok_number)
1213                                 goto error;
1214                         set_dbg_level(name, (1 << lexer.number) - 1);
1215                         break;
1216
1217                 case tok_setoutfile:
1218                         token = get_token();
1219                         if (token != tok_identifier)
1220                                 goto error;
1221                         len = MIN(lexer.len, 1023);
1222                         strncpy(name, lexer.s, len);
1223                         name[len] = '\0';
1224
1225                         token = get_token();
1226                         if (token != tok_identifier)
1227                                 goto error;
1228                         len = MIN(lexer.len, 1023);
1229                         strncpy(fname, lexer.s, len);
1230                         fname[len] = '\0';
1231                         set_dbg_outfile(name, fname);
1232
1233                 case tok_irgname:
1234                         token = get_token();
1235                         if (token != tok_identifier)
1236                                 goto error;
1237                         len = MIN(lexer.len, 1023);
1238                         strncpy(name, lexer.s, len);
1239                         name[len] = '\0';
1240                         irg_name(name);
1241
1242                 case tok_irgldname:
1243                         token = get_token();
1244                         if (token != tok_identifier)
1245                                 goto error;
1246                         len = MIN(lexer.len, 1023);
1247                         strncpy(name, lexer.s, len);
1248                         name[len] = '\0';
1249                         irg_ld_name(name);
1250                         break;
1251
1252                 case tok_help:
1253                         show_commands();
1254                         break;
1255
1256                 case tok_error:
1257                 default:
1258 error:
1259                         printf("Error: before %s\n", lexer.tok_start);
1260                         show_commands();
1261                         goto leave;
1262                 }
1263
1264                 token = get_token();
1265                 if (token == tok_eof)
1266                         break;
1267                 if (token != ';')
1268                         goto error;
1269         }
1270 leave:
1271         ;
1272 }  /* firm_debug */
1273
1274 /* creates the debugger tables */
1275 void firm_init_debugger(void)
1276 {
1277         char *env;
1278
1279         bp_numbers = new_set(cmp_nr_bp, 8);
1280         bp_idents  = new_set(cmp_ident_bp, 8);
1281
1282         env = getenv("FIRMDBG");
1283
1284         is_active = 1;
1285
1286         if (env)
1287                 firm_debug(env);
1288
1289         if (break_on_init)
1290                 firm_debug_break();
1291 }  /* firm_init_debugger */
1292
1293 /**
1294  * A gdb helper function to print firm objects.
1295  */
1296 const char *gdb_node_helper(void *firm_object) {
1297         static char buf[1024];
1298         ir_snprintf(buf, sizeof(buf), "%+F", firm_object);
1299         return buf;
1300 }
1301
1302 /**
1303  * A gdb helper function to print tarvals.
1304  */
1305 const char *gdb_tarval_helper(void *tv_object) {
1306         static char buf[1024];
1307         ir_snprintf(buf, sizeof(buf), "%+T", tv_object);
1308         return buf;
1309 }
1310
1311 const char *gdb_out_edge_helper(const ir_node *node) {
1312         static char buf[4*1024];
1313         char *b = buf;
1314         size_t l;
1315         size_t len = sizeof(buf);
1316         const ir_edge_t *edge;
1317         foreach_out_edge(node, edge) {
1318                 ir_node *n = get_edge_src_irn(edge);
1319
1320                 ir_snprintf(b, len, "%+F  ", n);
1321                 l = strlen(b);
1322                 len -= l;
1323                 b += l;
1324         }
1325
1326         return buf;
1327 }
1328
1329 #else
1330
1331 /* some picky compiler do not allow empty files */
1332 static int __attribute__((unused)) _firm_only_that_you_can_compile_with_NDEBUG_defined;
1333
1334 #endif /* NDEBUG */
1335
1336 /**
1337  * @page debugger   The Firm debugger extension
1338  *
1339  * Firm contains a debugger extension. This allows to set debugger breakpoints
1340  * an various events.
1341  * The extension uses a text interface which can be accessed from most debuggers.
1342  * More than one command can be given separated by ';'.
1343  *
1344  * @section sec_cmd Supported commands
1345  *
1346  * Historically all debugger commands start with a dot.  This isn't needed in newer
1347  * versions, but still supported, ie the commands ".init" and "init" are equal.
1348  * The following commands are currently supported:
1349  *
1350  * @b init
1351  *
1352  * Break immediately after the debugger extension was initialized.
1353  * Typically this command is used in the environment to stop the execution
1354  * of a Firm compiler right after the initialization, like this:
1355  *
1356  * $export FIRMDBG=".init"
1357  *
1358  * @b create nr
1359  *
1360  * Break if a new IR-node with node number nr was created.
1361  * Typically used to find the place where wrong nodes are created.
1362  *
1363  * @b replace nr
1364  *
1365  * Break before IR-node with node number nr is replaced by another node.
1366  *
1367  * @b lower nr
1368  *
1369  * Break before IR-node with node number nr is lowered.
1370  *
1371  * @b remirg nr
1372  *
1373  * Break if the irg with graph number nr is deleted.
1374  *
1375  * @b remirg name
1376  *
1377  * Break if the irg of entity name is deleted.
1378  *
1379  * @b newent nr
1380  *
1381  * Break if the entity with number nr was created.
1382  *
1383  * @b newent name
1384  *
1385  * Break if the entity name was created.
1386  *
1387  * @b newtype nr
1388  *
1389  * Break if the type with number nr was created.
1390  *
1391  * @b newtype name
1392  *
1393  * Break if the type name was created.
1394  *
1395  * @b bp
1396  *
1397  * Show all Firm internal breakpoints.
1398  *
1399  * @b enable nr
1400  *
1401  * Enables breakpoint nr.
1402  *
1403  * @b disable nr
1404  *
1405  * Disables breakpoint nr.
1406  *
1407  * @b showent nr
1408  *
1409  * Show the content of entity nr.
1410  *
1411  * @b showent name
1412  *
1413  * Show the content of entity name.
1414  *
1415  * @b showtype nr
1416  *
1417  * Show the content of type nr.
1418  *
1419  * @b showtype name
1420  *
1421  * Show the content of type name.
1422  *
1423  * @b setmask name msk
1424  *
1425  * Sets the debug module name to mask msk.
1426  *
1427  * @b setlvl name lvl
1428  *
1429  * Sets the debug module name to level lvl.
1430  *
1431  * @b setoutfile name file
1432  *
1433  * Redirects debug output of module name to file.
1434  *
1435  * @b irgname name
1436  *
1437  * Prints address and graph number of a method given by its name.
1438  *
1439  * @b irgldname name
1440  *
1441  * Prints address and graph number of a method given by its linker name.
1442  *
1443  * @b help
1444  *
1445  * List all commands.
1446  *
1447  *
1448  * The Firm debugger extension can be accessed using the function firm_debug().
1449  * The following example shows how to set a creation breakpoint in GDB when
1450  * node 2101 is created.
1451  *
1452  * -# set FIRMDBG="init"
1453  * -# start gdb with your compiler
1454  * -# after gdb breaks, issue
1455  *
1456  * call firm_debug("create 2101")
1457  *
1458  * On the console the following text should be issued:
1459  *
1460  * Firm BP 1: creation of Node 2101
1461  *
1462  *
1463  * @section gdb_macro GDB macro
1464  *
1465  * Add the following to your .gdbinit file:
1466  * @code
1467  #
1468  # define firm "cmd"  Firm debugger extension
1469  #
1470  define firm
1471  call firm_debug($arg0)
1472  end
1473  * @endcode
1474  *
1475  * Then, all Firm debugger extension commands can be accessed in the gdb
1476  * console using the firm prefix, eg.:
1477  *
1478  * firm "create 2101"
1479  *
1480  * firm "help"
1481  */