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         {
 404                 bp_ident_t key, *elem;
 405
 406                 key.id        = get_type_ident(tp);
 407                 key.bp.reason = BP_ON_NEW_TYPE;
 408
 409                 elem = set_find(bp_idents, &key, sizeof(key), HASH_IDENT_BP(key));
 410                 if (elem && elem->bp.active) {
 411                         dbg_printf("Firm BP %u reached, %+F was created\n", elem->bp.bpnr, tp);
 412                         firm_debug_break();
 413                 }
 414         }
 415 }  /* dbg_new_type */
 416
 417 /**
 418  * Return the reason string.
 419  */
 420 static const char *reason_str(bp_reasons_t reason)
 421 {
 422         switch (reason) {
 423         case BP_ON_NEW_NODE: return "node creation";
 424         case BP_ON_REPLACE:  return "node replace";
 425         case BP_ON_LOWER:    return "node lowering";
 426         case BP_ON_REMIRG:   return "removing IRG";
 427         case BP_ON_NEW_ENT:  return "entity creation";
 428         case BP_ON_NEW_TYPE: return "type creation";
 429         case BP_MAX_REASON:  break;
 430         }
 431         panic("unsupported reason");
 432 }  /* reason_str */
 433
 434 /**
 435  * Compare two number breakpoints.
 436  */
 437 static int cmp_nr_bp(const void *elt, const void *key, size_t size)
 438 {
 439         const bp_nr_t *e1 = elt;
 440         const bp_nr_t *e2 = key;
 441         (void) size;
 442
 443         return (e1->nr - e2->nr) | (e1->bp.reason - e2->bp.reason);
 444 }  /* cmp_nr_bp */
 445
 446 /**
 447  * Compare two ident breakpoints.
 448  */
 449 static int cmp_ident_bp(const void *elt, const void *key, size_t size)
 450 {
 451         const bp_ident_t *e1 = elt;
 452         const bp_ident_t *e2 = key;
 453         (void) size;
 454
 455         return (e1->id != e2->id) | (e1->bp.reason - e2->bp.reason);
 456 }  /* cmp_ident_bp */
 457
 458 /**
 459  * Update the hooks.
 460  */
 461 static void update_hooks(breakpoint *bp)
 462 {
 463 #define CASE_ON(a, b)  case a: if (! IS_HOOKED(hook_##b)) HOOK(hook_##b, dbg_##b); break
 464 #define CASE_OFF(a, b) case a: if (IS_HOOKED(hook_##b)) UNHOOK(hook_##b); break
 465
 466         if (bp->active)
 467                 ++num_active_bp[bp->reason];
 468         else
 469                 --num_active_bp[bp->reason];
 470
 471         if (num_active_bp[bp->reason] > 0) {
 472                 /* register the hooks on demand */
 473                 switch (bp->reason) {
 474                 CASE_ON(BP_ON_NEW_NODE, new_node);
 475                 CASE_ON(BP_ON_REPLACE, replace);
 476                 CASE_ON(BP_ON_LOWER, lower);
 477                 CASE_ON(BP_ON_REMIRG, free_graph);
 478                 CASE_ON(BP_ON_NEW_ENT, new_entity);
 479                 CASE_ON(BP_ON_NEW_TYPE, new_type);
 480                 default:
 481                         ;
 482                 }
 483         }
 484         else {
 485                 /* unregister the hook on demand */
 486                 switch (bp->reason) {
 487                 CASE_OFF(BP_ON_NEW_NODE, new_node);
 488                 CASE_OFF(BP_ON_REPLACE, replace);
 489                 CASE_OFF(BP_ON_LOWER, lower);
 490                 CASE_OFF(BP_ON_REMIRG, free_graph);
 491                 CASE_OFF(BP_ON_NEW_ENT, new_entity);
 492                 CASE_OFF(BP_ON_NEW_TYPE, new_type);
 493                 default:
 494                         ;
 495                 }
 496         }
 497 #undef CASE_ON
 498 #undef CASE_OFF
 499 }  /* update_hooks */
 500
 501 /**
 502  * Break if nr is reached.
 503  */
 504 static void break_on_nr(long nr, bp_reasons_t reason)
 505 {
 506         bp_nr_t key, *elem;
 507
 508         key.bp.kind   = BP_NR;
 509         key.bp.bpnr   = 0;
 510         key.bp.active = 1;
 511         key.bp.reason = reason;
 512         key.nr        = nr;
 513
 514         elem = set_insert(bp_numbers, &key, sizeof(key), HASH_NR_BP(key));
 515
 516         if (elem->bp.bpnr == 0) {
 517                 /* new break point */
 518                 elem->bp.bpnr = ++bp_num;
 519                 elem->bp.next = bp_list;
 520                 bp_list = &elem->bp;
 521
 522                 dbg_printf("Firm BP %u: %s of Nr %ld\n", elem->bp.bpnr, reason_str(reason), nr);
 523
 524                 update_hooks(&elem->bp);
 525         }
 526 }  /* break_on_nr */
 527
 528 /**
 529  * Break if ident name is reached.
 530  */
 531 static void break_on_ident(const char *name, bp_reasons_t reason) {
 532         bp_ident_t key, *elem;
 533
 534         key.bp.kind   = BP_IDENT;
 535         key.bp.bpnr   = 0;
 536         key.bp.active = 1;
 537         key.bp.reason = reason;
 538         key.id        = new_id_from_str(name);
 539
 540         elem = set_insert(bp_idents, &key, sizeof(key), HASH_IDENT_BP(key));
 541
 542         if (elem->bp.bpnr == 0) {
 543                 /* new break point */
 544                 elem->bp.bpnr = ++bp_num;
 545                 elem->bp.next = bp_list;
 546                 bp_list = &elem->bp;
 547
 548                 dbg_printf("Firm BP %u: %s of ident \"%s\"\n", elem->bp.bpnr, reason_str(reason), name);
 549
 550                 update_hooks(&elem->bp);
 551         }
 552 }  /* break_on_ident */
 553
 554 /**
 555  * Sets/resets the active flag of breakpoint bp.
 556  */
 557 static void bp_activate(unsigned bp, int active)
 558 {
 559         breakpoint *p;
 560
 561         for (p = bp_list; p; p = p->next) {
 562                 if (p->bpnr == bp) {
 563                         if (p->active != active) {
 564                                 p->active = active;
 565                                 update_hooks(p);
 566                         }
 567
 568                         dbg_printf("Firm BP %u is now %s\n", bp, active ? "enabled" : "disabled");
 569                         return;
 570                 }
 571         }
 572         dbg_printf("Error: Firm BP %u not exists.\n", bp);
 573 }  /* bp_activate */
 574
 575
 576 /**
 577  * Show a list of supported commands
 578  */
 579 static void show_commands(void) {
 580         dbg_printf("Internal Firm debugger extension $Revision$ commands:\n"
 581                 "init                  break after initialization\n"
 582                 "create nr             break if node nr was created\n"
 583                 "replace nr            break if node nr is replaced by another node\n"
 584                 "lower nr              break before node nr is lowered\n"
 585                 "remirg nr|name        break if the irg of nr or entity name is deleted\n"
 586                 "newent nr|name        break if the entity nr or name was created\n"
 587                 "newtype nr|name       break if the type nr or name was created\n"
 588                 "bp                    show all breakpoints\n"
 589                 "enable nr             enable breakpoint nr\n"
 590                 "disable nr            disable breakpoint nr\n"
 591                 "showtype nr|name      show content of the type nr or name\n"
 592                 "showent nr|name       show content of the entity nr or name\n"
 593                 "setmask name msk      sets the debug module name to mask msk\n"
 594                 "setlvl  name lvl      sets the debug module name to level lvl\n"
 595                 "setoutfile name file  redirects debug output of module name to file\n"
 596                 "irgname name          prints address and graph number of a method given by its name\n"
 597                 "irgldname ldname      prints address and graph number of a method given by its ldname\n"
 598                 "help                  list all commands\n"
 599                 );
 600 }  /* show_commands */
 601
 602 /**
 603  * Shows all Firm breakpoints.
 604  */
 605 static void show_bp(void) {
 606         breakpoint *p;
 607         bp_nr_t  *node_p;
 608         bp_ident_t *ident_p;
 609         int have_one = 0;
 610
 611         dbg_printf("Firm Breakpoints:");
 612         for (p = bp_list; p; p = p->next) {
 613                 have_one = 1;
 614                 dbg_printf("+\n  BP %u: ", p->bpnr);
 615
 616                 switch (p->kind) {
 617                 case BP_NR:
 618                         node_p = (bp_nr_t *)p;
 619                         dbg_printf("%s of Nr %ld ", reason_str(p->reason), node_p->nr);
 620                         break;
 621
 622                 case BP_IDENT:
 623                         ident_p = (bp_ident_t *)p;
 624                         dbg_printf("+%s of ident \"%s\" ", reason_str(p->reason), get_id_str(ident_p->id));
 625                         break;
 626                 }
 627
 628                 dbg_printf(p->active ? "+enabled" : "+disabled");
 629         }
 630         dbg_printf(have_one ? "+\n" : "+ NONE\n");
 631 }  /* show_bp */
 632
 633 /**
 634  * firm_dbg_register() expects that the name is stored persistent.
 635  * So we need this little helper function
 636  */
 637 static firm_dbg_module_t *dbg_register(const char *name) {
 638         ident *id = new_id_from_str(name);
 639
 640         return firm_dbg_register(get_id_str(id));
 641 }  /* dbg_register */
 642
 643 /**
 644  * Sets the debug mask of module name to lvl
 645  */
 646 static void set_dbg_level(const char *name, unsigned lvl)
 647 {
 648         firm_dbg_module_t *module = dbg_register(name);
 649
 650         if (firm_dbg_get_mask(module) != lvl) {
 651                 firm_dbg_set_mask(module, lvl);
 652
 653                 dbg_printf("Setting debug mask of module %s to %u\n", name, lvl);
 654         }
 655 }  /* set_dbg_level */
 656
 657 /**
 658  * Redirects the debug output of module name to fname
 659  */
 660 static void set_dbg_outfile(const char *name, const char *fname)
 661 {
 662         firm_dbg_module_t *module = dbg_register(name);
 663         FILE *f = fopen(fname, "w");
 664
 665         if (! f) {
 666                 perror(fname);
 667                 return;
 668         }
 669
 670         firm_dbg_set_file(module, f);
 671         dbg_printf("Redirecting debug output of module %s to file %s\n", name, fname);
 672 }  /* set_dbg_outfile */
 673
 674 /**
 675  * Show info about a firm thing.
 676  */
 677 static void show_firm_object(void *firm_thing) {
 678         FILE *f = stdout;
 679
 680         if (firm_thing == NULL) {
 681                 fprintf(f, "<NULL>\n");
 682                 return;
 683         }
 684         switch (get_kind(firm_thing)) {
 685         case k_BAD:
 686                 fprintf(f, "BAD: (%p)\n", firm_thing);
 687                 break;
 688         case k_entity:
 689                 dump_entity_to_file(f, firm_thing, dump_verbosity_max);
 690                 break;
 691         case k_type:
 692                 dump_type_to_file(f, firm_thing, dump_verbosity_max);
 693                 break;
 694         case k_ir_graph:
 695         case k_ir_node:
 696         case k_ir_mode:
 697         case k_ir_op:
 698         case k_tarval:
 699         case k_ir_loop:
 700         case k_ir_compound_graph_path:
 701         case k_ir_extblk:
 702         case k_ir_prog:
 703                 fprintf(f, "NIY\n");
 704                 break;
 705         default:
 706                 fprintf(f, "Cannot identify thing at (%p).\n", firm_thing);
 707         }
 708 }  /* show_firm_object */
 709
 710 /**
 711  * Find a firm type by its number.
 712  */
 713 static ir_type *find_type_nr(long nr) {
 714         int i, n = get_irp_n_types();
 715         ir_type *tp;
 716
 717         for (i = 0; i < n; ++i) {
 718                 tp = get_irp_type(i);
 719                 if (get_type_nr(tp) == nr)
 720                         return tp;
 721         }
 722         tp = get_glob_type();
 723         if (get_type_nr(tp) == nr)
 724                 return tp;
 725         return NULL;
 726 }  /* find_type_nr */
 727
 728 /**
 729  * Find a firm type by its name.
 730  */
 731 static ir_type *find_type_name(const char *name) {
 732         int i, n = get_irp_n_types();
 733         ir_type *tp;
 734
 735         for (i = 0; i < n; ++i) {
 736                 tp = get_irp_type(i);
 737                 if (strcmp(get_type_name(tp), name) == 0)
 738                         return tp;
 739         }
 740         tp = get_glob_type();
 741         if (strcmp(get_type_name(tp), name) == 0)
 742                 return tp;
 743         return NULL;
 744 }  /* find_type_name */
 745
 746 /** The environment for the entity search functions. */
 747 typedef struct find_env {
 748         union {
 749                 long        nr;   /**< the number that is searched for */
 750                 const char *name; /**< the name that is searched for */
 751         } u;
 752         ir_entity *res;     /**< the result */
 753 } find_env_t;
 754
 755 /**
 756  * Type-walker: Find an entity with given number.
 757  */
 758 static void check_ent_nr(type_or_ent tore, void *ctx) {
 759         find_env_t *env = ctx;
 760
 761         if (is_entity(tore.ent)) {
 762                 if (get_entity_nr(tore.ent) == env->u.nr) {
 763                         env->res = tore.ent;
 764                 }
 765         }
 766 }  /* check_ent_nr */
 767
 768 /**
 769  * Type-walker: Find an entity with given name.
 770  */
 771 static void check_ent_name(type_or_ent tore, void *ctx) {
 772         find_env_t *env = ctx;
 773
 774         if (is_entity(tore.ent))
 775                 if (strcmp(get_entity_name(tore.ent), env->u.name) == 0) {
 776                         env->res = tore.ent;
 777                 }
 778 }  /* check_ent_name */
 779
 780 /**
 781  * Find a firm entity by its number.
 782  */
 783 static ir_entity *find_entity_nr(long nr) {
 784         find_env_t env;
 785
 786         env.u.nr = nr;
 787         env.res  = NULL;
 788         type_walk(check_ent_nr, NULL, &env);
 789         return env.res;
 790 }  /* find_entity_nr */
 791
 792 /**
 793  * Find a firm entity by its name.
 794  */
 795 static ir_entity *find_entity_name(const char *name) {
 796         find_env_t env;
 797
 798         env.u.name = name;
 799         env.res    = NULL;
 800         type_walk(check_ent_name, NULL, &env);
 801         return env.res;
 802 }  /* find_entity_name */
 803
 804 /**
 805  * Search methods for a name.
 806  */
 807 static void show_by_name(type_or_ent tore, void *env) {
 808         ident *id = (ident *)env;
 809
 810         if (is_entity(tore.ent)) {
 811                 ir_entity *ent = tore.ent;
 812
 813                 if (is_method_entity(ent)) {
 814                         if (get_entity_ident(ent) == id) {
 815                                 ir_type *owner = get_entity_owner(ent);
 816                                 ir_graph *irg = get_entity_irg(ent);
 817
 818                                 if (owner != get_glob_type()) {
 819                                         printf("%s::%s", get_type_name(owner), get_id_str(id));
 820                                 } else {
 821                                         printf("%s", get_id_str(id));
 822                                 }
 823                                 if (irg)
 824                                         printf("[%ld] (%p)\n", get_irg_graph_nr(irg), irg);
 825                                 else
 826                                         printf(" NULL\n");
 827                         }
 828                 }
 829         }
 830 }  /* show_by_name */
 831
 832 /**
 833  * Search methods for a ldname.
 834  */
 835 static void show_by_ldname(type_or_ent tore, void *env) {
 836         ident *id = (ident *)env;
 837
 838         if (is_entity(tore.ent)) {
 839                 ir_entity *ent = tore.ent;
 840
 841                 if (is_method_entity(ent)) {
 842                         if (get_entity_ld_ident(ent) == id) {
 843                                 ir_type *owner = get_entity_owner(ent);
 844                                 ir_graph *irg = get_entity_irg(ent);
 845
 846                                 if (owner != get_glob_type()) {
 847                                         printf("%s::%s", get_type_name(owner), get_id_str(id));
 848                                 } else {
 849                                         printf("%s", get_id_str(id));
 850                                 }
 851                                 if (irg)
 852                                         printf("[%ld] (%p)\n", get_irg_graph_nr(irg), irg);
 853                                 else
 854                                         printf(" NULL\n");
 855                         }
 856                 }
 857         }
 858 }  /* show_by_ldname */
 859
 860 /**
 861  * prints the address and graph number of all irgs with given name
 862  */
 863 static void irg_name(const char *name) {
 864         ident *id = new_id_from_str(name);
 865
 866         type_walk(show_by_name, NULL, (void *)id);
 867 }  /* irg_name */
 868
 869 /**
 870  * prints the address and graph number of all irgs with given ld_name
 871  */
 872 static void irg_ld_name(const char *name) {
 873         ident *id = new_id_from_str(name);
 874
 875         type_walk(show_by_ldname, NULL, (void *)id);
 876 }  /* irg_ld_name */
 877
 878 enum tokens {
 879         tok_create = 256,
 880         tok_replace,
 881         tok_lower,
 882         tok_remirg,
 883         tok_newent,
 884         tok_newtype,
 885         tok_showtype,
 886         tok_showent,
 887         tok_init,
 888         tok_bp,
 889         tok_enable,
 890         tok_disable,
 891         tok_setmask,
 892         tok_setlvl,
 893         tok_setoutfile,
 894         tok_irgname,
 895         tok_irgldname,
 896         tok_help,
 897         tok_identifier,
 898         tok_number,
 899         tok_eof,
 900         tok_error
 901 };
 902
 903 static const char *reserved[] = {
 904         "create",
 905         "replace",
 906         "lower",
 907         "remirg",
 908         "newent",
 909         "newtype",
 910         "showtype",
 911         "showent",
 912         "init",
 913         "bp",
 914         "enable",
 915         "disable",
 916         "setmask",
 917         "setlvl",
 918         "setoutfile",
 919         "irgname",
 920         "irgldname",
 921         "help"
 922 };
 923
 924 /**
 925  * The Lexer data.
 926  */
 927 static struct lexer {
 928         int has_token;        /**< set if a token is cached. */
 929         unsigned cur_token;   /**< current token. */
 930         unsigned number;      /**< current token attribute. */
 931         const char *s;        /**< current token attribute. */
 932         unsigned len;         /**< current token attribute. */
 933
 934         const char *curr_pos;
 935         const char *end_pos;
 936         const char *tok_start;
 937 } lexer;
 938
 939 /**
 940  * Initialize the lexer.
 941  */
 942 static void init_lexer(const char *input) {
 943         lexer.has_token = 0;
 944         lexer.curr_pos  = input;
 945         lexer.end_pos   = input + strlen(input);
 946 }  /* init_lexer */
 947
 948
 949 /**
 950  * Get the next char from the input.
 951  */
 952 static char next_char(void) {
 953         if (lexer.curr_pos >= lexer.end_pos)
 954                 return '\0';
 955         return *lexer.curr_pos++;
 956 }  /* next_char */
 957
 958 #define unput()         if (lexer.curr_pos < lexer.end_pos) --lexer.curr_pos
 959
 960 #undef MIN
 961 #define MIN(a, b) (a) < (b) ? (a) : (b)
 962
 963 /**
 964  * The lexer.
 965  */
 966 static unsigned get_token(void) {
 967         char c;
 968         int i;
 969
 970         /* skip white space */
 971         do {
 972                 c = next_char();
 973         } while (c != '\0' && isspace(c));
 974
 975         lexer.tok_start = lexer.curr_pos - 1;
 976         if (c == '.' || isalpha(c)) {
 977                 /* command begins here */
 978                 int         len = 0;
 979                 const char* tok_start;
 980
 981                 do {
 982                         c = next_char();
 983                         ++len;
 984                 } while (isgraph(c));
 985                 unput();
 986
 987                 tok_start = lexer.tok_start;
 988                 if (*tok_start == '.') {
 989                         ++tok_start;
 990                         --len;
 991                 }
 992                 for (i = sizeof(reserved)/sizeof(reserved[0]) - 1; i >= 0; --i) {
 993                         if (strncasecmp(tok_start, reserved[i], len) == 0 && reserved[i][len] == '\0')
 994                                 return 256 + i;
 995                 }
 996
 997                 /* identifier */
 998                 lexer.s   = lexer.tok_start;
 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  * See show_commands() for supported commands.
1049  */
1050 void firm_debug(const char *cmd) {
1051         char name[1024], fname[1024];
1052         int len;
1053
1054         init_lexer(cmd);
1055
1056         for (;;) {
1057                 unsigned token;
1058
1059                 token = get_token();
1060
1061                 switch (token) {
1062                 case tok_eof:
1063                         goto leave;
1064
1065                 case tok_create:
1066                         token = get_token();
1067                         if (token != tok_number)
1068                                 goto error;
1069                         break_on_nr(lexer.number, BP_ON_NEW_NODE);
1070                         break;
1071
1072                 case tok_replace:
1073                         token = get_token();
1074                         if (token != tok_number)
1075                                 goto error;
1076                         break_on_nr(lexer.number, BP_ON_REPLACE);
1077                         break;
1078
1079                 case tok_lower:
1080                         token = get_token();
1081                         if (token != tok_number)
1082                                 goto error;
1083                         break_on_nr(lexer.number, BP_ON_LOWER);
1084                         break;
1085
1086                 case tok_remirg:
1087                         token = get_token();
1088
1089                         if (token == tok_number)
1090                                 break_on_nr(lexer.number, BP_ON_REMIRG);
1091                         else if (token == tok_identifier) {
1092                                 len = MIN(lexer.len, 1023);
1093                                 strncpy(name, lexer.s, len);
1094                                 name[len] = '\0';
1095                                 break_on_ident(name, BP_ON_REMIRG);
1096                         } else
1097                                 goto error;
1098                         break;
1099
1100                 case tok_newent:
1101                         token = get_token();
1102
1103                         if (token == tok_number)
1104                                 break_on_nr(lexer.number, BP_ON_NEW_ENT);
1105                         else if (token == tok_identifier) {
1106                                 len = MIN(lexer.len, 1023);
1107                                 strncpy(name, lexer.s, len);
1108                                 name[len] = '\0';
1109                                 break_on_ident(name, BP_ON_NEW_ENT);
1110                         } else
1111                                 goto error;
1112                         break;
1113
1114                 case tok_newtype:
1115                         token = get_token();
1116
1117                         if (token == tok_number)
1118                                 break_on_nr(lexer.number, BP_ON_NEW_TYPE);
1119                         else if (token == tok_identifier) {
1120                                 len = MIN(lexer.len, 1023);
1121                                 strncpy(name, lexer.s, len);
1122                                 name[len] = '\0';
1123                                 break_on_ident(name, BP_ON_NEW_TYPE);
1124                         } else
1125                                 goto error;
1126                         break;
1127
1128                 case tok_showtype:
1129                         token = get_token();
1130
1131                         if (token == tok_number)
1132                                 show_firm_object(find_type_nr(lexer.number));
1133                         else if (token == tok_identifier) {
1134                                 len = MIN(lexer.len, 1023);
1135                                 strncpy(name, lexer.s, len);
1136                                 name[len] = '\0';
1137                                 show_firm_object(find_type_name(name));
1138                         } else
1139                                 goto error;
1140                         break;
1141
1142                 case tok_showent:
1143                         token = get_token();
1144
1145                         if (token == tok_number)
1146                                 show_firm_object(find_entity_nr(lexer.number));
1147                         else if (token == tok_identifier) {
1148                                 len = MIN(lexer.len, 1023);
1149                                 strncpy(name, lexer.s, len);
1150                                 name[len] = '\0';
1151                                 show_firm_object(find_entity_name(name));
1152                         } else
1153                                 goto error;
1154                         break;
1155
1156                 case tok_init:
1157                         break_on_init = 1;
1158                         break;
1159
1160                 case tok_bp:
1161                         show_bp();
1162                         break;
1163
1164                 case tok_enable:
1165                         token = get_token();
1166                         if (token != tok_number)
1167                                 goto error;
1168                         bp_activate(lexer.number, 1);
1169                         break;
1170
1171                 case tok_disable:
1172                         token = get_token();
1173                         if (token != tok_number)
1174                                 goto error;
1175                         bp_activate(lexer.number, 0);
1176                         break;
1177
1178                 case tok_setmask:
1179                         token = get_token();
1180                         if (token != tok_identifier)
1181                                 goto error;
1182                         len = MIN(lexer.len, 1023);
1183                         strncpy(name, lexer.s, len);
1184                         name[len] = '\0';
1185
1186                         token = get_token();
1187                         if (token != tok_number)
1188                                 goto error;
1189                         set_dbg_level(name, lexer.number);
1190                         break;
1191
1192                 case tok_setlvl:
1193                         token = get_token();
1194                         if (token != tok_identifier)
1195                                 goto error;
1196                         len = MIN(lexer.len, 1023);
1197                         strncpy(name, lexer.s, len);
1198                         name[len] = '\0';
1199
1200                         token = get_token();
1201                         if (token != tok_number)
1202                                 goto error;
1203                         set_dbg_level(name, (1 << lexer.number) - 1);
1204                         break;
1205
1206                 case tok_setoutfile:
1207                         token = get_token();
1208                         if (token != tok_identifier)
1209                                 goto error;
1210                         len = MIN(lexer.len, 1023);
1211                         strncpy(name, lexer.s, len);
1212                         name[len] = '\0';
1213
1214                         token = get_token();
1215                         if (token != tok_identifier)
1216                                 goto error;
1217                         len = MIN(lexer.len, 1023);
1218                         strncpy(fname, lexer.s, len);
1219                         fname[len] = '\0';
1220                         set_dbg_outfile(name, fname);
1221
1222                 case tok_irgname:
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_name(name);
1230
1231                 case tok_irgldname:
1232                         token = get_token();
1233                         if (token != tok_identifier)
1234                                 goto error;
1235                         len = MIN(lexer.len, 1023);
1236                         strncpy(name, lexer.s, len);
1237                         name[len] = '\0';
1238                         irg_ld_name(name);
1239                         break;
1240
1241                 case tok_help:
1242                         show_commands();
1243                         break;
1244
1245                 case tok_error:
1246                 default:
1247 error:
1248                         printf("Error: before %s\n", lexer.tok_start);
1249                         show_commands();
1250                         goto leave;
1251                 }
1252
1253                 token = get_token();
1254                 if (token == tok_eof)
1255                         break;
1256                 if (token != ';')
1257                         goto error;
1258         }
1259 leave:
1260         ;
1261 }  /* firm_debug */
1262
1263 /* creates the debugger tables */
1264 void firm_init_debugger(void)
1265 {
1266         char *env;
1267
1268         bp_numbers = new_set(cmp_nr_bp, 8);
1269         bp_idents  = new_set(cmp_ident_bp, 8);
1270
1271         env = getenv("FIRMDBG");
1272
1273         is_active = 1;
1274
1275         if (env)
1276                 firm_debug(env);
1277
1278         if (break_on_init)
1279                 firm_debug_break();
1280 }  /* firm_init_debugger */
1281
1282 /**
1283  * A gdb helper function to print firm objects.
1284  */
1285 const char *gdb_node_helper(void *firm_object) {
1286         static char buf[1024];
1287         ir_snprintf(buf, sizeof(buf), "%+F", firm_object);
1288         return buf;
1289 }
1290
1291 /**
1292  * A gdb helper function to print tarvals.
1293  */
1294 const char *gdb_tarval_helper(void *tv_object) {
1295         static char buf[1024];
1296         ir_snprintf(buf, sizeof(buf), "%+T", tv_object);
1297         return buf;
1298 }
1299
1300 const char *gdb_out_edge_helper(const ir_node *node) {
1301         static char buf[4*1024];
1302         char *b = buf;
1303         size_t l;
1304         size_t len = sizeof(buf);
1305         const ir_edge_t *edge;
1306         foreach_out_edge(node, edge) {
1307                 ir_node *n = get_edge_src_irn(edge);
1308
1309                 ir_snprintf(b, len, "%+F  ", n);
1310                 l = strlen(b);
1311                 len -= l;
1312                 b += l;
1313         }
1314
1315         return buf;
1316 }
1317
1318 #else
1319
1320 /* some picky compiler do not allow empty files */
1321 static int __attribute__((unused)) _firm_only_that_you_can_compile_with_NDEBUG_defined;
1322
1323 #endif /* NDEBUG */
1324
1325 /**
1326  * @page debugger   The Firm debugger extension
1327  *
1328  * Firm contains a debugger extension. This allows to set debugger breakpoints
1329  * an various events.
1330  * The extension uses a text interface which can be accessed from most debuggers.
1331  * More than one command can be given separated by ';'.
1332  *
1333  * @section sec_cmd Supported commands
1334  *
1335  * Historically all debugger commands start with a dot.  This isn't needed in newer
1336  * versions, but still supported, ie the commands ".init" and "init" are equal.
1337  * The following commands are currently supported:
1338  *
1339  * @b init
1340  *
1341  * Break immediately after the debugger extension was initialized.
1342  * Typically this command is used in the environment to stop the execution
1343  * of a Firm compiler right after the initialization, like this:
1344  *
1345  * $export FIRMDBG=".init"
1346  *
1347  * @b create nr
1348  *
1349  * Break if a new IR-node with node number nr was created.
1350  * Typically used to find the place where wrong nodes are created.
1351  *
1352  * @b replace nr
1353  *
1354  * Break before IR-node with node number nr is replaced by another node.
1355  *
1356  * @b lower nr
1357  *
1358  * Break before IR-node with node number nr is lowered.
1359  *
1360  * @b remirg nr
1361  *
1362  * Break if the irg with graph number nr is deleted.
1363  *
1364  * @b remirg name
1365  *
1366  * Break if the irg of entity name is deleted.
1367  *
1368  * @b newent nr
1369  *
1370  * Break if the entity with number nr was created.
1371  *
1372  * @b newent name
1373  *
1374  * Break if the entity name was created.
1375  *
1376  * @b newtype nr
1377  *
1378  * Break if the type with number nr was created.
1379  *
1380  * @b newtype name
1381  *
1382  * Break if the type name was created.
1383  *
1384  * @b bp
1385  *
1386  * Show all Firm internal breakpoints.
1387  *
1388  * @b enable nr
1389  *
1390  * Enables breakpoint nr.
1391  *
1392  * @b disable nr
1393  *
1394  * Disables breakpoint nr.
1395  *
1396  * @b showent nr
1397  *
1398  * Show the content of entity nr.
1399  *
1400  * @b showent name
1401  *
1402  * Show the content of entity name.
1403  *
1404  * @b showtype nr
1405  *
1406  * Show the content of type nr.
1407  *
1408  * @b showtype name
1409  *
1410  * Show the content of type name.
1411  *
1412  * @b setmask name msk
1413  *
1414  * Sets the debug module name to mask msk.
1415  *
1416  * @b setlvl name lvl
1417  *
1418  * Sets the debug module name to level lvl.
1419  *
1420  * @b setoutfile name file
1421  *
1422  * Redirects debug output of module name to file.
1423  *
1424  * @b irgname name
1425  *
1426  * Prints address and graph number of a method given by its name.
1427  *
1428  * @b irgldname name
1429  *
1430  * Prints address and graph number of a method given by its linker name.
1431  *
1432  * @b help
1433  *
1434  * List all commands.
1435  *
1436  *
1437  * The Firm debugger extension can be accessed using the function firm_debug().
1438  * The following example shows how to set a creation breakpoint in GDB when
1439  * node 2101 is created.
1440  *
1441  * -# set FIRMDBG="init"
1442  * -# start gdb with your compiler
1443  * -# after gdb breaks, issue
1444  *
1445  * call firm_debug("create 2101")
1446  *
1447  * On the console the following text should be issued:
1448  *
1449  * Firm BP 1: creation of Node 2101
1450  *
1451  *
1452  * @section gdb_macro GDB macro
1453  *
1454  * Add the following to your .gdbinit file:
1455  * @code
1456  #
1457  # define firm "cmd"  Firm debugger extension
1458  #
1459  define firm
1460  call firm_debug($arg0)
1461  end
1462  * @endcode
1463  *
1464  * Then, all Firm debugger extension commands can be accessed in the gdb
1465  * console using the firm prefix, eg.:
1466  *
1467  * firm "create 2101"
1468  *
1469  * firm "help"
1470  */