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