nsz Git - libfirm/blob - ir/be/bemain.c

   1 /**
   2  * Backend driver.
   3  * @author Sebastian Hack
   4  * @date   25.11.2004
   5  * @cvsid  $Id$
   6  */
   7 #ifdef HAVE_CONFIG_H
   8 #include "config.h"
   9 #endif
  10
  11 #include <stdarg.h>
  12
  13 #ifdef WITH_LIBCORE
  14 #include <libcore/lc_opts.h>
  15 #include <libcore/lc_opts_enum.h>
  16 #include <libcore/lc_timing.h>
  17 #endif /* WITH_LIBCORE */
  18
  19 #include "obst.h"
  20 #include "bitset.h"
  21
  22 #include "irprog.h"
  23 #include "irgopt.h"
  24 #include "irgraph.h"
  25 #include "irdump.h"
  26 #include "phiclass.h"
  27 #include "irdom_t.h"
  28 #include "iredges_t.h"
  29 #include "irloop_t.h"
  30 #include "irtools.h"
  31 #include "return.h"
  32 #include "firmstat.h"
  33
  34 #include "bearch.h"
  35 #include "firm/bearch_firm.h"
  36 #include "ia32/bearch_ia32.h"
  37 #include "arm/bearch_arm.h"
  38 #include "ppc32/bearch_ppc32.h"
  39 #include "mips/bearch_mips.h"
  40
  41 #include "be_t.h"
  42 #include "benumb_t.h"
  43 #include "beutil.h"
  44 #include "benode_t.h"
  45 #include "beirgmod.h"
  46 #include "besched_t.h"
  47 #include "belistsched.h"
  48 #include "belive_t.h"
  49 #include "bespillilp.h"
  50 #include "bespillbelady.h"
  51 #include "bera.h"
  52 #include "beraextern.h"
  53 #include "bechordal_t.h"
  54 #include "beifg.h"
  55 #include "beifg_impl.h"
  56 #include "becopyopt.h"
  57 #include "becopystat.h"
  58 #include "bessadestr.h"
  59 #include "beabi.h"
  60 #include "belower.h"
  61 #include "beschedmris.h"
  62 #include "bestat.h"
  63 #include "beverify.h"
  64
  65 /* options visible for anyone */
  66 static be_options_t be_options = {
  67         DUMP_NONE,                         /* dump options */
  68         BE_TIME_OFF,                       /* no timing */
  69         "i44pc52.info.uni-karlsruhe.de",   /* ilp server */
  70         "cplex"                            /* ilp solver */
  71 };
  72
  73 /* dump flags */
  74 static unsigned dump_flags = 0;
  75
  76 /* verify options */
  77 static unsigned vrfy_option = BE_VRFY_WARN;
  78
  79 /* register allocator to use. */
  80 static const be_ra_t *ra = &be_ra_chordal_allocator;
  81
  82 /* back end instruction set architecture to use */
  83 static const arch_isa_if_t *isa_if = &ia32_isa_if;
  84
  85 /* mris option */
  86 static int be_enable_mris = 0;
  87
  88 #ifdef WITH_LIBCORE
  89
  90 static lc_opt_entry_t *be_grp_root = NULL;
  91
  92 /* possible dumping options */
  93 static const lc_opt_enum_mask_items_t dump_items[] = {
  94         { "none",       DUMP_NONE },
  95         { "initial",    DUMP_INITIAL },
  96         { "abi",        DUMP_ABI    },
  97         { "sched",      DUMP_SCHED  },
  98         { "prepared",   DUMP_PREPARED },
  99         { "regalloc",   DUMP_RA },
 100         { "final",      DUMP_FINAL },
 101         { "be",         DUMP_BE },
 102         { "all",        2 * DUMP_BE - 1 },
 103         { NULL,         0 }
 104 };
 105
 106 /* register allocators */
 107 static const lc_opt_enum_const_ptr_items_t ra_items[] = {
 108         { "chordal",  &be_ra_chordal_allocator },
 109         { "external", &be_ra_external_allocator },
 110         { NULL,      NULL }
 111 };
 112
 113 /* instruction set architectures. */
 114 static const lc_opt_enum_const_ptr_items_t isa_items[] = {
 115         { "ia32",    &ia32_isa_if },
 116 #if 0
 117         { "arm",     &arm_isa_if },
 118         { "ppc32",   &ppc32_isa_if },
 119         { "mips",    &mips_isa_if },
 120 #endif
 121         { NULL,      NULL }
 122 };
 123
 124 /* verify options. */
 125 static const lc_opt_enum_int_items_t vrfy_items[] = {
 126         { "off",    BE_VRFY_OFF    },
 127         { "warn",   BE_VRFY_WARN   },
 128         { "assert", BE_VRFY_ASSERT },
 129         { NULL,     0 }
 130 };
 131
 132 static lc_opt_enum_mask_var_t dump_var = {
 133         &dump_flags, dump_items
 134 };
 135
 136 static lc_opt_enum_const_ptr_var_t ra_var = {
 137         (const void **) &ra, ra_items
 138 };
 139
 140 static lc_opt_enum_const_ptr_var_t isa_var = {
 141         (const void **) &isa_if, isa_items
 142 };
 143
 144 static lc_opt_enum_int_var_t vrfy_var = {
 145         &vrfy_option, vrfy_items
 146 };
 147
 148 static const lc_opt_table_entry_t be_main_options[] = {
 149         LC_OPT_ENT_ENUM_MASK("dump",     "dump irg on several occasions",     &dump_var),
 150         LC_OPT_ENT_ENUM_PTR ("ra",       "register allocator",                &ra_var),
 151         LC_OPT_ENT_ENUM_PTR ("isa",      "the instruction set architecture",  &isa_var),
 152         LC_OPT_ENT_NEGBOOL  ("noomitfp", "do not omit frame pointer",         &be_omit_fp),
 153         LC_OPT_ENT_BOOL     ("mris",     "enable mris schedule preparation",  &be_enable_mris),
 154         LC_OPT_ENT_ENUM_PTR ("vrfy",     "verify the backend irg (off, warn, assert)",  &vrfy_var),
 155         LC_OPT_ENT_BOOL     ("time",     "get backend timing statistics",     &be_options.timing),
 156
 157 #ifdef WITH_ILP
 158         LC_OPT_ENT_STR ("ilp.server", "the ilp server name", be_options.ilp_server, sizeof(be_options.ilp_server)),
 159         LC_OPT_ENT_STR ("ilp.solver", "the ilp solver name", be_options.ilp_solver, sizeof(be_options.ilp_solver)),
 160 #endif /* WITH_ILP */
 161         { NULL }
 162 };
 163
 164 #endif /* WITH_LIBCORE */
 165
 166 void be_opt_register(void)
 167 {
 168 #ifdef WITH_LIBCORE
 169         int i;
 170         lc_opt_entry_t *be_grp_ra;
 171         static int run_once = 0;
 172
 173         if (! run_once) {
 174                 run_once    = 1;
 175                 be_grp_root = lc_opt_get_grp(firm_opt_get_root(), "be");
 176                 be_grp_ra   = lc_opt_get_grp(be_grp_root, "ra");
 177
 178                 lc_opt_add_table(be_grp_root, be_main_options);
 179
 180                 /* register allocator options */
 181                 for(i = 0; ra_items[i].name != NULL; ++i) {
 182                         const be_ra_t *ra = ra_items[i].value;
 183                         ra->register_options(be_grp_ra);
 184                 }
 185
 186                 /* register isa options */
 187                 for(i = 0; isa_items[i].name != NULL; ++i) {
 188                         const arch_isa_if_t *isa = isa_items[i].value;
 189                         isa->register_options(be_grp_root);
 190                 }
 191         }
 192 #endif /* WITH_LIBCORE */
 193 }
 194
 195 /* Parse one argument. */
 196 int be_parse_arg(const char *arg) {
 197 #ifdef WITH_LIBCORE
 198         if (strcmp(arg, "help") == 0 || (arg[0] == '?' && arg[1] == '\0')) {
 199                 lc_opt_print_help(be_grp_root, stdout);
 200                 return -1;
 201         }
 202         return lc_opt_from_single_arg(be_grp_root, NULL, arg, NULL);
 203 #else
 204         return 0;
 205 #endif /* WITH_LIBCORE */
 206 }
 207
 208 /** The be parameters returned by default, all off. */
 209 const static backend_params be_params = {
 210         NULL,
 211         NULL,
 212         0,
 213         NULL,
 214 };
 215
 216 /* Perform schedule verification if requested. */
 217 static void be_sched_vrfy(ir_graph *irg, int vrfy_opt) {
 218         if (vrfy_opt == BE_VRFY_WARN) {
 219                 be_verify_schedule(irg);
 220         }
 221         else if (vrfy_opt == BE_VRFY_ASSERT) {
 222                 assert(be_verify_schedule(irg) && "Schedule verification failed.");
 223         }
 224 }
 225
 226 /* Initialize the Firm backend. Must be run BEFORE init_firm()! */
 227 const backend_params *be_init(void)
 228 {
 229         be_opt_register();
 230
 231         be_sched_init();
 232         be_liveness_init();
 233         be_numbering_init();
 234         be_copy_opt_init();
 235         copystat_init();
 236         phi_class_init();
 237
 238         if (isa_if->get_params)
 239                 return isa_if->get_params();
 240         return &be_params;
 241 }
 242
 243 /**
 244  * Initializes the main environment for the backend.
 245  *
 246  * @param env          an empty environment
 247  * @param file_handle  the file handle where the output will be written to
 248  */
 249 static be_main_env_t *be_init_env(be_main_env_t *env, FILE *file_handle)
 250 {
 251         memset(env, 0, sizeof(*env));
 252         obstack_init(&env->obst);
 253         env->arch_env = obstack_alloc(&env->obst, sizeof(env->arch_env[0]));
 254         env->options  = &be_options;
 255         env->options->dump_flags = dump_flags;
 256         FIRM_DBG_REGISTER(env->dbg, "be.main");
 257
 258         arch_env_init(env->arch_env, isa_if, file_handle);
 259
 260         /* Register the irn handler of the architecture */
 261         if (arch_isa_get_irn_handler(env->arch_env->isa))
 262                 arch_env_push_irn_handler(env->arch_env, arch_isa_get_irn_handler(env->arch_env->isa));
 263
 264         /*
 265          * Register the node handler of the back end infrastructure.
 266          * This irn handler takes care of the platform independent
 267          * spill, reload and perm nodes.
 268          */
 269         arch_env_push_irn_handler(env->arch_env, &be_node_irn_handler);
 270         env->phi_handler = be_phi_handler_new(env->arch_env);
 271         arch_env_push_irn_handler(env->arch_env, env->phi_handler);
 272
 273         return env;
 274 }
 275
 276 static void be_done_env(be_main_env_t *env)
 277 {
 278         env->arch_env->isa->impl->done(env->arch_env->isa);
 279         be_phi_handler_free(env->phi_handler);
 280         obstack_free(&env->obst, NULL);
 281 }
 282
 283 /**
 284  * A wrapper around a firm dumper. Dumps only, if
 285  * flags are enabled.
 286  *
 287  * @param mask    a bitmask containing the reason what will be dumped
 288  * @param irg     the IR graph to dump
 289  * @param suffix  the suffix for the dumper
 290  * @param dumper  the dumper to be called
 291  */
 292 static void dump(int mask, ir_graph *irg, const char *suffix,
 293                  void (*dumper)(ir_graph *, const char *))
 294 {
 295         if(dump_flags & mask)
 296                 be_dump(irg, suffix, dumper);
 297 }
 298
 299 /**
 300  * Prepare a backend graph for code generation.
 301  */
 302 static void prepare_graph(be_irg_t *birg)
 303 {
 304         ir_graph *irg = birg->irg;
 305
 306         /* Normalize proj nodes. */
 307         normalize_proj_nodes(irg);
 308
 309         /* Make just one return node. */
 310         normalize_one_return(irg);
 311
 312         /* Remove critical edges */
 313         remove_critical_cf_edges(irg);
 314
 315         /* Compute the dominance information. */
 316         free_dom(irg);
 317         compute_doms(irg);
 318
 319         /* Ensure, that the ir_edges are computed. */
 320         edges_activate(irg);
 321
 322         /* check, if the dominance property is fulfilled. */
 323         be_check_dominance(irg);
 324
 325         /* reset the phi handler. */
 326         be_phi_handler_reset(birg->main_env->phi_handler);
 327 }
 328
 329 /**
 330  * The Firm backend main loop.
 331  * Do architecture specific lowering for all graphs
 332  * and call the architecture specific code generator.
 333  *
 334  * @param file_handle   the file handle the output will be written to
 335  */
 336 static void be_main_loop(FILE *file_handle)
 337 {
 338         int i, n;
 339         arch_isa_t *isa;
 340         be_main_env_t env;
 341         unsigned num_nodes_b = 0;
 342         unsigned num_nodes_a = 0;
 343         unsigned num_nodes_r = 0;
 344         lc_timer_t *t_prolog, *t_abi, *t_codegen, *t_sched, *t_constr, *t_regalloc, *t_finish, *t_emit, *t_other, *t_verify;
 345         be_ra_timer_t *ra_timer;
 346
 347         if (be_options.timing == BE_TIME_ON) {
 348                 t_prolog   = lc_timer_register("prolog",   "prolog");
 349                 t_abi      = lc_timer_register("beabi",    "be abi introduction");
 350                 t_codegen  = lc_timer_register("codegen",  "codegeneration");
 351                 t_sched    = lc_timer_register("sched",    "scheduling");
 352                 t_constr   = lc_timer_register("constr",   "assure constraints");
 353                 t_regalloc = lc_timer_register("regalloc", "register allocation");
 354                 t_finish   = lc_timer_register("finish",   "graph finish");
 355                 t_emit     = lc_timer_register("emiter",   "code emiter");
 356                 t_verify   = lc_timer_register("verify",   "graph verification");
 357                 t_other    = lc_timer_register("other",    "other");
 358         }
 359
 360         be_init_env(&env, file_handle);
 361
 362         isa = arch_env_get_isa(env.arch_env);
 363
 364         /* for debugging, anchors helps */
 365         // dump_all_anchors(1);
 366
 367 #define BE_TIMER_PUSH(timer)  if (be_options.timing == BE_TIME_ON) lc_timer_push(timer)
 368 #define BE_TIMER_POP()        if (be_options.timing == BE_TIME_ON) lc_timer_pop()
 369 #define BE_TIMER_ONLY(code)   if (be_options.timing == BE_TIME_ON) do { code; } while(0)
 370
 371         /* For all graphs */
 372         for (i = 0, n = get_irp_n_irgs(); i < n; ++i) {
 373                 ir_graph *irg = get_irp_irg(i);
 374                 const arch_code_generator_if_t *cg_if;
 375                 be_irg_t birg;
 376                 optimization_state_t state;
 377
 378                 /* stop and reset timers */
 379                 if (be_options.timing == BE_TIME_ON) {
 380                         LC_STOP_AND_RESET_TIMER(t_prolog);
 381                         LC_STOP_AND_RESET_TIMER(t_abi);
 382                         LC_STOP_AND_RESET_TIMER(t_codegen);
 383                         LC_STOP_AND_RESET_TIMER(t_sched);
 384                         LC_STOP_AND_RESET_TIMER(t_constr);
 385                         LC_STOP_AND_RESET_TIMER(t_regalloc);
 386                         LC_STOP_AND_RESET_TIMER(t_finish);
 387                         LC_STOP_AND_RESET_TIMER(t_emit);
 388                         LC_STOP_AND_RESET_TIMER(t_verify);
 389                         LC_STOP_AND_RESET_TIMER(t_other);
 390                 }
 391                 BE_TIMER_PUSH(t_other);
 392
 393                 BE_TIMER_ONLY(num_nodes_b = get_num_reachable_nodes(irg));
 394
 395                 birg.irg      = irg;
 396                 birg.main_env = &env;
 397
 398                 DBG((env.dbg, LEVEL_2, "====> IRG: %F\n", irg));
 399                 dump(DUMP_INITIAL, irg, "-begin", dump_ir_block_graph);
 400
 401                 BE_TIMER_PUSH(t_prolog);
 402
 403                 be_stat_init_irg(env.arch_env, irg);
 404                 be_do_stat_nodes(irg, "01 Begin");
 405
 406                 /* set the current graph (this is important for several firm functions) */
 407                 current_ir_graph = birg.irg;
 408
 409                 /* Get the code generator interface. */
 410                 cg_if = isa->impl->get_code_generator_if(isa);
 411
 412                 /* get a code generator for this graph. */
 413                 birg.cg = cg_if->init(&birg);
 414
 415                 /* create the code generator and generate code. */
 416                 prepare_graph(&birg);
 417
 418                 /* some transformations need to be done before abi introduce */
 419                 arch_code_generator_before_abi(birg.cg);
 420
 421                 BE_TIMER_POP();
 422                 BE_TIMER_PUSH(t_abi);
 423
 424                 /* implement the ABI conventions. */
 425                 birg.abi = be_abi_introduce(&birg);
 426                 dump(DUMP_ABI, irg, "-abi", dump_ir_block_graph);
 427
 428                 be_do_stat_nodes(irg, "02 Abi");
 429
 430                 BE_TIMER_POP();
 431                 BE_TIMER_PUSH(t_codegen);
 432
 433                 /* generate code */
 434                 arch_code_generator_prepare_graph(birg.cg);
 435
 436                 be_do_stat_nodes(irg, "03 Prepare");
 437
 438                 /*
 439                  * Since the code generator made a lot of new nodes and skipped
 440                  * a lot of old ones, we should do dead node elimination here.
 441                  * Note that this requires disabling the edges here.
 442                  */
 443                 edges_deactivate(irg);
 444                 //dead_node_elimination(irg);
 445                 edges_activate(irg);
 446
 447                 /* Compute loop nesting information (for weighting copies) */
 448                 construct_cf_backedges(irg);
 449
 450                 dump(DUMP_PREPARED, irg, "-prepared", dump_ir_block_graph);
 451
 452                 BE_TIMER_POP();
 453                 BE_TIMER_ONLY(num_nodes_r = get_num_reachable_nodes(irg));
 454                 BE_TIMER_PUSH(t_codegen);
 455
 456                 /* Schedule the graphs. */
 457                 arch_code_generator_before_sched(birg.cg);
 458
 459                 BE_TIMER_POP();
 460                 BE_TIMER_PUSH(t_sched);
 461
 462                 list_sched(&birg, be_enable_mris);
 463                 dump(DUMP_SCHED, irg, "-sched", dump_ir_block_graph_sched);
 464
 465                 BE_TIMER_POP();
 466                 BE_TIMER_PUSH(t_verify);
 467
 468                 /* check schedule */
 469                 be_sched_vrfy(birg.irg, vrfy_option);
 470
 471                 be_do_stat_nodes(irg, "04 Schedule");
 472
 473                 BE_TIMER_POP();
 474                 BE_TIMER_PUSH(t_constr);
 475
 476                 /* we switch off optimizations here, because they might cause trouble */
 477                 save_optimization_state(&state);
 478                 set_optimize(0);
 479                 set_opt_normalize(0);
 480
 481                 /* add Keeps for should_be_different constrained nodes  */
 482                 /* beware: needs schedule due to usage of be_ssa_constr */
 483                 assure_constraints(&birg);
 484                 dump(DUMP_SCHED, irg, "-assured", dump_ir_block_graph_sched);
 485
 486                 be_do_stat_nodes(irg, "05 Constraints");
 487
 488                 /* connect all stack modifying nodes together (see beabi.c) */
 489                 be_abi_fix_stack_nodes(birg.abi);
 490                 BE_TIMER_POP();
 491
 492                 dump(DUMP_SCHED, irg, "-fix_stack", dump_ir_block_graph_sched);
 493
 494                 BE_TIMER_PUSH(t_verify);
 495                 /* check schedule */
 496                 be_sched_vrfy(birg.irg, vrfy_option);
 497                 BE_TIMER_POP();
 498
 499                 BE_TIMER_PUSH(t_codegen);
 500                 /* do some statistics */
 501                 be_do_stat_reg_pressure(&birg);
 502
 503                 /* stuff needs to be done after scheduling but before register allocation */
 504                 arch_code_generator_before_ra(birg.cg);
 505
 506                 BE_TIMER_POP();
 507
 508                 BE_TIMER_ONLY(lc_timer_start(t_regalloc));
 509
 510                 /* Do register allocation */
 511                 ra_timer = ra->allocate(&birg);
 512                 dump(DUMP_RA, irg, "-ra", dump_ir_block_graph_sched);
 513
 514                 BE_TIMER_ONLY(lc_timer_stop(t_regalloc));
 515
 516                 be_do_stat_nodes(irg, "06 Register Allocation");
 517
 518                 BE_TIMER_PUSH(t_finish);
 519
 520                 arch_code_generator_after_ra(birg.cg);
 521                 be_abi_fix_stack_bias(birg.abi);
 522
 523                 BE_TIMER_POP();
 524                 BE_TIMER_PUSH(t_verify);
 525
 526                 /* check schedule */
 527                 be_sched_vrfy(birg.irg, vrfy_option);
 528
 529                 BE_TIMER_POP();
 530                 BE_TIMER_PUSH(t_emit);
 531                 arch_code_generator_done(birg.cg);
 532                 BE_TIMER_POP();
 533
 534                 dump(DUMP_FINAL, irg, "-end", dump_ir_extblock_graph_sched);
 535                 be_abi_free(birg.abi);
 536
 537                 be_do_stat_nodes(irg, "07 Final");
 538                 restore_optimization_state(&state);
 539
 540                 BE_TIMER_ONLY(num_nodes_a = get_num_reachable_nodes(irg));
 541
 542                 /* switched off due to statistics (statistic module needs all irgs) */
 543                 if (! stat_is_active())
 544                         free_ir_graph(irg);
 545                 BE_TIMER_POP();
 546
 547 #define LC_EMIT(timer)    printf("%-20s: %.3lf msec\n", lc_timer_get_description(timer), (double)lc_timer_elapsed_usec(timer) / 1000.0)
 548 #define LC_EMIT_RA(timer) printf("\t%-20s: %.3lf msec\n", lc_timer_get_description(timer), (double)lc_timer_elapsed_usec(timer) / 1000.0)
 549                 if (be_options.timing == BE_TIME_ON) {
 550                         printf("==>> IRG %s <<==\n", get_entity_name(get_irg_entity(irg)));
 551                         printf("# nodes at begin:  %u\n", num_nodes_b);
 552                         printf("# nodes before ra: %u\n", num_nodes_r);
 553                         printf("# nodes at end:    %u\n\n", num_nodes_a);
 554                         LC_EMIT(t_prolog);
 555                         LC_EMIT(t_abi);
 556                         LC_EMIT(t_codegen);
 557                         LC_EMIT(t_sched);
 558                         LC_EMIT(t_constr);
 559                         LC_EMIT(t_regalloc);
 560                         LC_EMIT_RA(ra_timer->t_prolog);
 561                         LC_EMIT_RA(ra_timer->t_live);
 562                         LC_EMIT_RA(ra_timer->t_spill);
 563                         LC_EMIT_RA(ra_timer->t_color);
 564                         LC_EMIT_RA(ra_timer->t_ifg);
 565                         LC_EMIT_RA(ra_timer->t_copymin);
 566                         LC_EMIT_RA(ra_timer->t_ssa);
 567                         LC_EMIT_RA(ra_timer->t_epilog);
 568                         LC_EMIT_RA(ra_timer->t_verify);
 569                         LC_EMIT_RA(ra_timer->t_other);
 570                         LC_EMIT(t_finish);
 571                         LC_EMIT(t_emit);
 572                         LC_EMIT(t_verify);
 573                         LC_EMIT(t_other);
 574                 }
 575 #undef LC_EMIT
 576         }
 577         be_done_env(&env);
 578
 579 #undef BE_TIMER_POP
 580 #undef BE_TIMER_PUSH
 581 #undef BE_TIMER_ONLY
 582 }
 583
 584 /* Main interface to the frontend. */
 585 void be_main(FILE *file_handle)
 586 {
 587 #ifdef WITH_LIBCORE
 588         lc_timer_t *t;
 589
 590         if (be_options.timing == BE_TIME_ON) {
 591                 t = lc_timer_register("bemain", "measure complete bemain loop");
 592
 593                 if (lc_timer_enter_high_priority()) {
 594                         fprintf(stderr, "Warning: Could not enter high priority mode.\n");
 595                 }
 596
 597                 lc_timer_reset_and_start(t);
 598         }
 599 #endif /* WITH_LIBCORE */
 600
 601         /* never build code for pseudo irgs */
 602         set_visit_pseudo_irgs(0);
 603
 604         be_node_init();
 605         be_main_loop(file_handle);
 606
 607 #ifdef WITH_LIBCORE
 608         if (be_options.timing == BE_TIME_ON) {
 609                 lc_timer_stop(t);
 610                 lc_timer_leave_high_priority();
 611                 printf("%-20s: %lu msec\n", "BEMAINLOOP", lc_timer_elapsed_msec(t));
 612         }
 613 #endif /* WITH_LIBCORE */
 614 }
 615
 616 /** The debug info retriever function. */
 617 static retrieve_dbg_func retrieve_dbg = NULL;
 618
 619 /* Sets a debug info retriever. */
 620 void be_set_debug_retrieve(retrieve_dbg_func func) {
 621         retrieve_dbg = func;
 622 }
 623
 624 /* Retrieve the debug info. */
 625 const char *be_retrieve_dbg_info(const dbg_info *dbg, unsigned *line) {
 626         if (retrieve_dbg)
 627                 return retrieve_dbg(dbg, line);
 628         *line = 0;
 629         return NULL;
 630 }