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

   1 /*
   2  * Copyright (C) 1995-2007 University of Karlsruhe.  All right reserved.
   3  *
   4  * This file is part of libFirm.
   5  *
   6  * This file may be distributed and/or modified under the terms of the
   7  * GNU General Public License version 2 as published by the Free Software
   8  * Foundation and appearing in the file LICENSE.GPL included in the
   9  * packaging of this file.
  10  *
  11  * Licensees holding valid libFirm Professional Edition licenses may use
  12  * this file in accordance with the libFirm Commercial License.
  13  * Agreement provided with the Software.
  14  *
  15  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  16  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE.
  18  */
  19
  20 /**
  21  * @file
  22  * @brief     Helper function for integrated debug support
  23  * @author    Michael Beck
  24  * @date      2005
  25  * @version   $Id$
  26  */
  27 #ifdef HAVE_CONFIG_H
  28 #include "config.h"
  29 #endif
  30
  31 #include "firm_config.h"
  32
  33 #ifdef DEBUG_libfirm
  34
  35 #ifdef _WIN32
  36 #define WIN32_LEAN_AND_MEAN
  37 #include <windows.h>
  38
  39 #define strncasecmp strnicmp
  40 #endif
  41
  42 #ifdef HAVE_STDLIB_H
  43 #include <stdlib.h>
  44 #endif
  45
  46 #include <stdio.h>
  47 #include <signal.h>
  48
  49 #ifdef HAVE_STRING_H
  50 #include <string.h>
  51 #endif
  52 #ifdef HAVE_STRINGS_H
  53 #include <strings.h>
  54 #endif
  55
  56 #include <ctype.h>
  57
  58 #include "set.h"
  59 #include "ident.h"
  60 #include "irhooks.h"
  61 #include "irgraph_t.h"
  62 #include "entity_t.h"
  63 #include "irprintf.h"
  64 #include "irdump.h"
  65 #include "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 == '.') {
 988                 /* command begins here */
 989                 int len = 0;
 990
 991                 do {
 992                         c = next_char();
 993                         ++len;
 994                 } while (isalpha(c));
 995                 unput();
 996
 997                 --len;
 998                 for (i = sizeof(reserved)/sizeof(reserved[0]) - 1; i >= 0; --i) {
 999                         if (strncasecmp(lexer.tok_start + 1, reserved[i], len) == 0 && reserved[i][len] == '\0')
1000                                 break;
1001                 }
1002                 if (i >= 0)
1003                         return 256 + i;
1004                 return tok_error;
1005         } else if (isalpha(c)) {
1006                 /* identifier */
1007                 lexer.s = lexer.curr_pos - 1;
1008
1009                 do {
1010                         c = next_char();
1011                 } while (isgraph(c));
1012                 unput();
1013                 lexer.len = lexer.curr_pos - lexer.s;
1014                 return tok_identifier;
1015         } else if (isdigit(c) || c == '-') {
1016                 unsigned number = 0;
1017                 unsigned sign   = 0;
1018
1019                 /* we support negative numbers as well, so one can easily set all bits with -1 */
1020                 if (c == '-') {
1021                         sign = 1;
1022                         c    = next_char();
1023                 }
1024
1025                 if (c == '0') {
1026                         c = next_char();
1027
1028                         if (c == 'x' || c == 'X') {
1029                                 for (;;) {
1030                                         c = next_char();
1031
1032                                         if (! isxdigit(c))
1033                                                 break;
1034                                         if (isdigit(c))
1035                                                 number = (number << 4) | (c - '0');
1036                                         else
1037                                                 number = (number << 4) | (toupper(c) - 'A' + 10);
1038                                 }
1039                                 unput();
1040                                 lexer.number = number;
1041                                 return tok_number;
1042                         }
1043                 }
1044                 for (;;) {
1045                         if (! isdigit(c))
1046                                 break;
1047                         number = number * 10 + (c - '0');
1048                         c = next_char();
1049                 }
1050                 unput();
1051                 lexer.number = sign ? 0 - number : number;
1052                 return tok_number;
1053         }
1054         else if (c == '\0')
1055                 return tok_eof;
1056         return c;
1057 }  /* get_token */
1058
1059 /**
1060  * High level function to use from debugger interface
1061  *
1062  * Supported commands:
1063  *  .create nr    break if node nr was created
1064  *  .help         list all commands
1065  */
1066 void firm_debug(const char *cmd) {
1067         char name[1024], fname[1024];
1068         int len;
1069
1070         init_lexer(cmd);
1071
1072         for (;;) {
1073                 unsigned token;
1074
1075                 token = get_token();
1076
1077                 switch (token) {
1078                 case tok_eof:
1079                         goto leave;
1080
1081                 case tok_create:
1082                         token = get_token();
1083                         if (token != tok_number)
1084                                 goto error;
1085                         break_on_nr(lexer.number, BP_ON_NEW_NODE);
1086                         break;
1087
1088                 case tok_replace:
1089                         token = get_token();
1090                         if (token != tok_number)
1091                                 goto error;
1092                         break_on_nr(lexer.number, BP_ON_REPLACE);
1093                         break;
1094
1095                 case tok_lower:
1096                         token = get_token();
1097                         if (token != tok_number)
1098                                 goto error;
1099                         break_on_nr(lexer.number, BP_ON_LOWER);
1100                         break;
1101
1102                 case tok_remirg:
1103                         token = get_token();
1104
1105                         if (token == tok_number)
1106                                 break_on_nr(lexer.number, BP_ON_REMIRG);
1107                         else if (token == tok_identifier) {
1108                                 len = MIN(lexer.len, 1023);
1109                                 strncpy(name, lexer.s, len);
1110                                 name[len] = '\0';
1111                                 break_on_ident(name, BP_ON_REMIRG);
1112                         } else
1113                                 goto error;
1114                         break;
1115
1116                 case tok_newent:
1117                         token = get_token();
1118
1119                         if (token == tok_number)
1120                                 break_on_nr(lexer.number, BP_ON_NEW_ENT);
1121                         else if (token == tok_identifier) {
1122                                 len = MIN(lexer.len, 1023);
1123                                 strncpy(name, lexer.s, len);
1124                                 name[len] = '\0';
1125                                 break_on_ident(name, BP_ON_NEW_ENT);
1126                         } else
1127                                 goto error;
1128                         break;
1129
1130                 case tok_newtype:
1131                         token = get_token();
1132
1133                         if (token == tok_number)
1134                                 break_on_nr(lexer.number, BP_ON_NEW_TYPE);
1135                         else if (token == tok_identifier) {
1136                                 len = MIN(lexer.len, 1023);
1137                                 strncpy(name, lexer.s, len);
1138                                 name[len] = '\0';
1139                                 break_on_ident(name, BP_ON_NEW_TYPE);
1140                         } else
1141                                 goto error;
1142                         break;
1143
1144                 case tok_showtype:
1145                         token = get_token();
1146
1147                         if (token == tok_number)
1148                                 show_firm_object(find_type_nr(lexer.number));
1149                         else if (token == tok_identifier) {
1150                                 len = MIN(lexer.len, 1023);
1151                                 strncpy(name, lexer.s, len);
1152                                 name[len] = '\0';
1153                                 show_firm_object(find_type_name(name));
1154                         } else
1155                                 goto error;
1156                         break;
1157
1158                 case tok_showent:
1159                         token = get_token();
1160
1161                         if (token == tok_number)
1162                                 show_firm_object(find_entity_nr(lexer.number));
1163                         else if (token == tok_identifier) {
1164                                 len = MIN(lexer.len, 1023);
1165                                 strncpy(name, lexer.s, len);
1166                                 name[len] = '\0';
1167                                 show_firm_object(find_entity_name(name));
1168                         } else
1169                                 goto error;
1170                         break;
1171
1172                 case tok_init:
1173                         break_on_init = 1;
1174                         break;
1175
1176                 case tok_bp:
1177                         show_bp();
1178                         break;
1179
1180                 case tok_enable:
1181                         token = get_token();
1182                         if (token != tok_number)
1183                                 goto error;
1184                         bp_activate(lexer.number, 1);
1185                         break;
1186
1187                 case tok_disable:
1188                         token = get_token();
1189                         if (token != tok_number)
1190                                 goto error;
1191                         bp_activate(lexer.number, 0);
1192                         break;
1193
1194                 case tok_setmask:
1195                         token = get_token();
1196                         if (token != tok_identifier)
1197                                 goto error;
1198                         len = MIN(lexer.len, 1023);
1199                         strncpy(name, lexer.s, len);
1200                         name[len] = '\0';
1201
1202                         token = get_token();
1203                         if (token != tok_number)
1204                                 goto error;
1205                         set_dbg_level(name, lexer.number);
1206                         break;
1207
1208                 case tok_setlvl:
1209                         token = get_token();
1210                         if (token != tok_identifier)
1211                                 goto error;
1212                         len = MIN(lexer.len, 1023);
1213                         strncpy(name, lexer.s, len);
1214                         name[len] = '\0';
1215
1216                         token = get_token();
1217                         if (token != tok_number)
1218                                 goto error;
1219                         set_dbg_level(name, (1 << lexer.number) - 1);
1220                         break;
1221
1222                 case tok_setoutfile:
1223                         token = get_token();
1224                         if (token != tok_identifier)
1225                                 goto error;
1226                         len = MIN(lexer.len, 1023);
1227                         strncpy(name, lexer.s, len);
1228                         name[len] = '\0';
1229
1230                         token = get_token();
1231                         if (token != tok_identifier)
1232                                 goto error;
1233                         len = MIN(lexer.len, 1023);
1234                         strncpy(fname, lexer.s, len);
1235                         fname[len] = '\0';
1236                         set_dbg_outfile(name, fname);
1237
1238                 case tok_irgname:
1239                         token = get_token();
1240                         if (token != tok_identifier)
1241                                 goto error;
1242                         len = MIN(lexer.len, 1023);
1243                         strncpy(name, lexer.s, len);
1244                         name[len] = '\0';
1245                         irg_name(name);
1246
1247                 case tok_irgldname:
1248                         token = get_token();
1249                         if (token != tok_identifier)
1250                                 goto error;
1251                         len = MIN(lexer.len, 1023);
1252                         strncpy(name, lexer.s, len);
1253                         name[len] = '\0';
1254                         irg_ld_name(name);
1255                         break;
1256
1257                 case tok_help:
1258                         show_commands();
1259                         break;
1260
1261                 case tok_error:
1262                 default:
1263 error:
1264                         printf("Error: before %s\n", lexer.tok_start);
1265                         show_commands();
1266                         goto leave;
1267                 }
1268
1269                 token = get_token();
1270                 if (token == tok_eof)
1271                         break;
1272                 if (token != ';')
1273                         goto error;
1274         }
1275 leave:
1276         ;
1277 }  /* firm_debug */
1278
1279 /* creates the debugger tables */
1280 void firm_init_debugger(void)
1281 {
1282         char *env;
1283
1284         bp_numbers = new_set(cmp_nr_bp, 8);
1285         bp_idents  = new_set(cmp_ident_bp, 8);
1286
1287         env = getenv("FIRMDBG");
1288
1289         is_active = 1;
1290
1291         if (env)
1292                 firm_debug(env);
1293
1294         if (break_on_init)
1295                 firm_debug_break();
1296 }  /* firm_init_debugger */
1297
1298 /**
1299  * A gdb helper function to print firm objects.
1300  */
1301 const char *gdb_node_helper(void *firm_object) {
1302         static char buf[1024];
1303         ir_snprintf(buf, sizeof(buf), "%+F", firm_object);
1304         return buf;
1305 }
1306
1307 /**
1308  * A gdb helper function to print tarvals.
1309  */
1310 const char *gdb_tarval_helper(void *tv_object) {
1311         static char buf[1024];
1312         ir_snprintf(buf, sizeof(buf), "%+T", tv_object);
1313         return buf;
1314 }
1315
1316 const char *gdb_out_edge_helper(const ir_node *node) {
1317         static char buf[4*1024];
1318         char *b = buf;
1319         size_t l;
1320         size_t len = sizeof(buf);
1321         const ir_edge_t *edge;
1322         foreach_out_edge(node, edge) {
1323                 ir_node *n = get_edge_src_irn(edge);
1324
1325                 ir_snprintf(b, len, "%+F  ", n);
1326                 l = strlen(b);
1327                 len -= l;
1328                 b += l;
1329         }
1330
1331         return buf;
1332 }
1333
1334 #else
1335
1336 /* some picky compiler do not allow empty files */
1337 static int _firm_only_that_you_can_compile_with_NDEBUG_defined;
1338
1339 #endif /* NDEBUG */
1340
1341 /**
1342  * @page debugger   The Firm debugger extension
1343  *
1344  * Firm contains a debugger extension. This allows to set debugger breakpoints
1345  * an various events.
1346  * The extension uses a text interface which can be accessed from most debuggers.
1347  * More than one command can be given separated by ';'.
1348  *
1349  * @section sec_cmd Supported commands
1350  *
1351  * The following commands are currently supported:
1352  *
1353  * @b .init
1354  *
1355  * Break immediately after the debugger extension was initialized.
1356  * Typically this command is used in the environment to stop the execution
1357  * of a Firm compiler right after the initialization, like this:
1358  *
1359  * $export FIRMDBG=".init"
1360  *
1361  * @b .create nr
1362  *
1363  * Break if a new IR-node with node number nr was created.
1364  * Typically used to find the place where wrong nodes are created.
1365  *
1366  * @b .replace nr
1367  *
1368  * Break before IR-node with node number nr is replaced by another node.
1369  *
1370  * @b .lower nr
1371  *
1372  * Break before IR-node with node number nr is lowered.
1373  *
1374  * @b .remirg nr
1375  *
1376  * Break if the irg with graph number nr is deleted.
1377  *
1378  * @b .remirg name
1379  *
1380  * Break if the irg of entity name is deleted.
1381  *
1382  * @b .newent nr
1383  *
1384  * Break if the entity with number nr was created.
1385  *
1386  * @b .newent name
1387  *
1388  * Break if the entity name was created.
1389  *
1390  * @b .newtype nr
1391  *
1392  * Break if the type with number nr was created.
1393  *
1394  * @b .newtype name
1395  *
1396  * Break if the type name was created.
1397  *
1398  * @b .bp
1399  *
1400  * Show all Firm internal breakpoints.
1401  *
1402  * @b .enable nr
1403  *
1404  * Enables breakpoint nr.
1405  *
1406  * @b .disable nr
1407  *
1408  * Disables breakpoint nr.
1409  *
1410  * @b .showent nr
1411  *
1412  * Show the content of entity nr.
1413  *
1414  * @b .showent name
1415  *
1416  * Show the content of entity name.
1417  *
1418  * @b .showtype nr
1419  *
1420  * Show the content of type nr.
1421  *
1422  * @b .showtype name
1423  *
1424  * Show the content of type name.
1425  *
1426  * @b .setmask name msk
1427  *
1428  * Sets the debug module name to mask msk.
1429  *
1430  * @b .setlvl name lvl
1431  *
1432  * Sets the debug module name to level lvl.
1433  *
1434  * @b .setoutfile name file
1435  *
1436  * Redirects debug output of module name to file.
1437  *
1438  * @b .irgname name
1439  *
1440  * Prints address and graph number of a method given by its name.
1441  *
1442  * @b .irgldname name
1443  *
1444  * Prints address and graph number of a method given by its linker name.
1445  *
1446  * @b .help
1447  *
1448  * List all commands.
1449  *
1450  *
1451  * The Firm debugger extension can be accessed using the function firm_debug().
1452  * The following example shows how to set a creation breakpoint in GDB when
1453  * node 2101 is created.
1454  *
1455  * -# set FIRMDBG=".init"
1456  * -# start gdb with your compiler
1457  * -# after gdb breaks, issue
1458  *
1459  * call firm_debug(".create 2101")
1460  *
1461  * On the console the following text should be issued:
1462  *
1463  * Firm BP 1: creation of Node 2101
1464  *
1465  *
1466  * @section gdb_macro GDB macro
1467  *
1468  * Add the following to your .gdbinit file:
1469  * @code
1470  #
1471  # define firm "cmd"  Firm debugger extension
1472  #
1473  define firm
1474  call firm_debug($arg0)
1475  end
1476  * @endcode
1477  *
1478  * Then, all Firm debugger extension commands can be accessed in the gdb
1479  * console using the firm prefix, eg.:
1480  *
1481  * firm ".create 2101"
1482  *
1483  * firm ".help"
1484  */