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

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