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