nsz Git - cparser/blob - driver/firm_cmdline.c

   1 /**
   2  * @file firm_cmdline.c -- Additional Firm generating backend parameters
   3  *
   4  * Compile when BACK_END_IS_CP_FIRM_BE is defined
   5  *
   6  * (C) 2005  Michael Beck  beck@ipd.info.uni-karlsruhe.de
   7  *
   8  * $Id$
   9  */
  10 #include <string.h>
  11 #include "firm_cmdline.h"
  12 #include <libfirm/firm.h>
  13 #include <libfirm/be.h>
  14
  15 #ifdef _WIN32
  16 #define DEFAULT_OS OS_SUPPORT_MINGW
  17 #else
  18 #define DEFAULT_OS OS_SUPPORT_LINUX
  19 #endif
  20
  21 /* optimization settings */
  22 struct a_firm_opt firm_opt = {
  23   /* enabled         = */ TRUE,
  24   /* debug_mode      = */ DBG_MODE_NONE,
  25   /* const_folding   = */ TRUE,
  26   /* reassoc         = */ TRUE,
  27   /* cse             = */ TRUE,
  28   /* control_flow    = */ TRUE,
  29   /* combo;          = */ FALSE,
  30   /* gcse            = */ TRUE,
  31   /* gvn_pre         = */ FALSE,
  32   /* cond_eval       = */ FALSE,
  33   /* if_conversion   = */ FALSE,
  34   /* func_calls      = */ TRUE,
  35   /* do_inline       = */ FALSE,
  36   /* auto_inline     = */ TRUE,
  37   /* tail_rec        = */ TRUE,
  38   /* strength_red    = */ TRUE,
  39   /* scalar_replace  = */ TRUE,
  40   /* confirm         = */ TRUE,
  41   /* muls            = */ TRUE,
  42   /* divs            = */ TRUE,
  43   /* mods            = */ TRUE,
  44   /* fragile_ops     = */ TRUE,
  45   /* load_store      = */ TRUE,
  46   /* modes           = */ FALSE,
  47   /* precise_exc     = */ FALSE,        /* never needed for C */
  48   /* use_DivMod      = */ FALSE,
  49   /* remove_unused   = */ TRUE,
  50   /* jmp_tbls        = */ TRUE,
  51   /* cloning         = */ FALSE,
  52   /* auto_sync       = */ TRUE,
  53   /* alias_analysis  = */ TRUE,
  54   /* strict_alias    = */ FALSE,
  55   /* no_alias        = */ FALSE,
  56   /* luffig          = */ FALSE,
  57   /* deconv          = */ FALSE,
  58   /* cc_opt          = */ TRUE,
  59   /* bool_opt        = */ FALSE,
  60   /* freestanding;   = */ FALSE,
  61   /* fp_model        = */ fp_model_precise,
  62   /* lower_ll        = */ FALSE,
  63   /* vrfy            = */ FIRM_VERIFICATION_ON,
  64   /* check_all       = */ FALSE,
  65   /* lower           = */ TRUE,
  66   /* os_support      = */ DEFAULT_OS,
  67   /* honor_restrict  = */ TRUE,
  68   /* lower_bitfields = */ TRUE,
  69   /* pic             = */ FALSE,
  70   /* ycomp_dbg       = */ FALSE,
  71   /* ycomp_host      = */ FIRM_YCOMP_DEFAULT_HOST,
  72   /* ycomp_port      = */ FIRM_YCOMP_DEFAULT_PORT,
  73   /* clone_threshold = */ DEFAULT_CLONE_THRESHOLD,
  74   /* vrfy_edges      = */ FALSE,
  75   /* grs_simd_opt    = */ 0,
  76   /* grs_create_pattern = */ 0,
  77   /* spare_size      = */ 128,
  78 };
  79
  80 /* dumping options */
  81 struct a_firm_dump firm_dump = {
  82   /* debug_print  = */ FALSE,
  83   /* all_types    = */ FALSE,
  84   /* no_blocks    = */ FALSE,
  85   /* extbb        = */ FALSE,
  86   /* ir_graph     = */ FALSE,
  87   /* all_phases   = */ FALSE,
  88   /* edge_labels  = */ FALSE,
  89   /* statistic    = */ STAT_NONE,
  90   /* stat_pattern = */ 0,
  91   /* stat_dag     = */ 0,
  92   /* gen_firm_asm = */ FALSE,
  93   /* filter       = */ NULL
  94 };
  95
  96 #ifdef FIRM_EXT_GRS
  97 struct a_firm_ext_grs firm_ext_grs = {
  98   /* simd_opt       = */ FALSE,
  99   /* create_pattern = */ FALSE
 100 };
 101 #endif
 102
 103 struct a_firm_be_opt firm_be_opt = {
 104   /* selection = */ BE_FIRM_BE,
 105   /* node_stat = */ 0,
 106 };
 107
 108 #define X(a)    a, sizeof(a)-1
 109
 110 /** Parameter description structure */
 111 static const struct params {
 112   const char *option;      /**< name of the option */
 113   int        opt_len;      /**< length of the option string */
 114   a_byte     *flag;        /**< address of variable to set/reset */
 115   a_byte     set;          /**< iff true, variable will be set, else reset */
 116   const char *description; /**< description of this option */
 117 } firm_options[] = {
 118   /* this must be first */
 119   { X("help"),                   NULL,                       0, "print FCC related help options" },
 120
 121   /* firm optimization options */
 122   { X("pic"),                    &firm_opt.pic,              1, "firm: generate position independent code" },
 123   { X("g0"),                     &firm_opt.debug_mode,       DBG_MODE_BACKSTORE, "firm: Debug Mode: use back stores" },
 124   { X("g1"),                     &firm_opt.debug_mode,       DBG_MODE_FULL,      "firm: Debug Mode: no register variables" },
 125   { X("no-opt"),                 NULL,                       0, "firm: disable all FIRM optimizations" },
 126   { X("cse"),                    &firm_opt.cse,              1, "firm: enable common subexpression elimination" },
 127   { X("no-cse"),                 &firm_opt.cse,              0, "firm: disable common subexpression elimination" },
 128   { X("const-fold"),             &firm_opt.const_folding,    1, "firm: enable constant folding" },
 129   { X("no-const-fold"),          &firm_opt.const_folding,    0, "firm: disable constant folding" },
 130   { X("control_flow"),           &firm_opt.control_flow,     1, "firm: enable control flow optimization" },
 131   { X("no-control-flow"),        &firm_opt.control_flow,     0, "firm: disable control flow optimization" },
 132   { X("combo"),                  &firm_opt.combo,            1, "firm: enable combined CCE, UCE and GVN" },
 133   { X("no-combo"),               &firm_opt.combo,            0, "firm: disable combined CCE, UCE and GVN" },
 134   { X("gcse"),                   &firm_opt.gcse,             1, "firm: enable global common subexpression elimination" },
 135   { X("no-gcse"),                &firm_opt.gcse,             0, "firm: disable global common subexpression elimination" },
 136   { X("gvn-pre"),                &firm_opt.gvn_pre,          1, "firm: enable GVN partial redundancy elimination" },
 137   { X("no-gvn-pre"),             &firm_opt.gvn_pre,          0, "firm: disable GVN partial redundancy elimination" },
 138   { X("cond-eval"),              &firm_opt.cond_eval,        1, "firm: enable partial condition evaluation optimization" },
 139   { X("no-cond-eval"),           &firm_opt.cond_eval,        0, "firm: disable partial condition evaluation optimization" },
 140   { X("if-conv"),                &firm_opt.if_conversion,    1, "firm: enable if-conversion optimization" },
 141   { X("no-if-conv"),             &firm_opt.if_conversion,    0, "firm: disable if-conversion optimization" },
 142   { X("opt-func-call"),          &firm_opt.func_calls,       1, "firm: enable function call optimization" },
 143   { X("no-opt-func-call"),       &firm_opt.func_calls,       0, "firm: disable function call optimization" },
 144   { X("reassociation"),          &firm_opt.reassoc,          1, "firm: enable reassociation" },
 145   { X("no-reassociation"),       &firm_opt.reassoc,          0, "firm: disable reassociation" },
 146   { X("inline"),                 &firm_opt.do_inline,        1, "firm: enable FIRM inlining" },
 147   { X("no-inline"),              &firm_opt.do_inline,        0, "firm: disable FIRM inlining" },
 148   { X("tail-rec"),               &firm_opt.tail_rec,         1, "firm: enable tail-recursion optimization" },
 149   { X("no-tail-rec"),            &firm_opt.tail_rec,         0, "firm: disable tail-recursion optimization" },
 150   { X("strength-red"),           &firm_opt.strength_red,     1, "firm: enable strength reduction for loops" },
 151   { X("no-strength-red"),        &firm_opt.strength_red,     0, "firm: disable strength reduction for loops" },
 152   { X("scalar-replace"),         &firm_opt.scalar_replace,   1, "firm: enable scalar replacement" },
 153   { X("no-scalar-replace"),      &firm_opt.scalar_replace,   0, "firm: disable scalar replacement" },
 154   { X("confirm"),                &firm_opt.confirm,          1, "firm: enable Confirm optimization" },
 155   { X("no-confirm"),             &firm_opt.confirm,          0, "firm: disable Confirm optimization" },
 156   { X("opt-mul"),                &firm_opt.muls,             0, "firm: enable multiplication optimization" },
 157   { X("no-opt-mul"),             &firm_opt.muls,             0, "firm: disable multiplication optimization" },
 158   { X("opt-div"),                &firm_opt.divs,             0, "firm: enable division optimization" },
 159   { X("no-opt-div"),             &firm_opt.divs,             0, "firm: disable division optimization" },
 160   { X("opt-mod"),                &firm_opt.mods,             0, "firm: enable remainder optimization" },
 161   { X("no-opt-mod"),             &firm_opt.mods,             0, "firm: disable remainder optimization" },
 162   { X("opt-fragile-ops"),        &firm_opt.fragile_ops,      1, "firm: enable fragile ops optimization" },
 163   { X("no-opt-fragile-ops"),     &firm_opt.fragile_ops,      0, "firm: disable fragile ops optimization" },
 164   { X("opt-load-store"),         &firm_opt.load_store,       1, "firm: enable load store optimization" },
 165   { X("no-opt-load-store"),      &firm_opt.load_store,       0, "firm: disable load store optimization" },
 166   { X("opt-modes"),              &firm_opt.modes,            1, "firm: optimize integer modes" },
 167   { X("no-opt-modes"),           &firm_opt.modes,            0, "firm: disable integer modes optimization" },
 168   { X("jmptbls"),                &firm_opt.jmp_tbls,         1, "firm: create jump table for switch" },
 169   { X("no-jmptbls"),             &firm_opt.jmp_tbls,         0, "firm: do not create jump table for switch" },
 170   { X("sync"),                   &firm_opt.auto_sync,        1, "firm: automatically create Sync nodes" },
 171   { X("no-sync"),                &firm_opt.auto_sync,        0, "firm: do not create Sync nodes" },
 172   { X("opt-alias"),              &firm_opt.alias_analysis,   1, "firm: enable alias analysis" },
 173   { X("no-opt-alias"),           &firm_opt.alias_analysis,   0, "firm: disable alias analysis" },
 174   { X("alias"),                  &firm_opt.no_alias,         0, "firm: aliasing occurs" },
 175   { X("no-alias"),               &firm_opt.no_alias,         1, "firm: no aliasing occurs" },
 176   { X("strict-aliasing"),        &firm_opt.strict_alias,     1, "firm: strict alias rules" },
 177   { X("no-strict-aliasing"),     &firm_opt.strict_alias,     0, "firm: strict alias rules" },
 178   { X("opt-proc-clone"),         &firm_opt.cloning,          1, "firm: enable procedure cloning" },
 179   { X("no-opt-proc-clone"),      &firm_opt.cloning,          0, "firm: disable procedure cloning" },
 180   { X("clone-threshold=<value>"),NULL,                       0, "firm: set clone threshold to <value>" },
 181   { X("DivMod"),                 &firm_opt.use_DivMod,       1, "firm: use DivMod nodes" },
 182   { X("no-DivMod"),              &firm_opt.use_DivMod,       0, "firm: don't use DivMod nodes" },
 183   { X("precise-except"),         &firm_opt.precise_exc,      1, "firm: precise exception context" },
 184   { X("no-precise-except"),      &firm_opt.precise_exc,      0, "firm: no precise exception context" },
 185   { X("remove-unused"),          &firm_opt.remove_unused,    1, "firm: remove unused functions" },
 186   { X("no-remove-unused"),       &firm_opt.remove_unused,    0, "firm: dont't remove unused functions" },
 187   { X("fp-precise"),             &firm_opt.fp_model,         fp_model_precise, "firm: precise fp model" },
 188   { X("fp-fast"),                &firm_opt.fp_model,         fp_model_fast,    "firm: fast fp model" },
 189   { X("fp-strict"),              &firm_opt.fp_model,         fp_model_strict,  "firm: strict fp model" },
 190   { X("luffig"),                 &firm_opt.luffig,           1, "firm: enable the fluffy load/store optimization" },
 191   { X("no-luffig"),              &firm_opt.luffig,           0, "firm: disable the fluffy load/store optimization" },
 192   { X("deconv"),                 &firm_opt.deconv,           1, "firm: enable the conv node optimization" },
 193   { X("no-deconv"),              &firm_opt.deconv,           0, "firm: disable the conv node optimization" },
 194   { X("opt-cc"),                 &firm_opt.cc_opt,           1, "firm: enable calling conventions optimization" },
 195   { X("no-opt-cc"),              &firm_opt.cc_opt,           0, "firm: disable calling conventions optimization" },
 196   { X("bool"),                   &firm_opt.bool_opt,         1, "firm: enable bool simplification optimization" },
 197   { X("no-bool"),                &firm_opt.bool_opt,         0, "firm: disable bool simplification optimization" },
 198   { X("freestanding"),           &firm_opt.freestanding,     1, "firm: freestanding environment" },
 199   { X("hosted"),                 &firm_opt.freestanding,     0, "firm: hosted environment" },
 200
 201   /* other firm regarding options */
 202   { X("restrict"),               &firm_opt.honor_restrict,   1, "firm: honor restrict keyword" },
 203   { X("no-restrict"),            &firm_opt.honor_restrict,   1, "firm: restrict keyword is meaningless" },
 204   { X("no-lower"),               &firm_opt.lower,            0, "firm: disable lowering" },
 205   { X("vrfy-off"),               &firm_opt.vrfy,             FIRM_VERIFICATION_OFF, "firm: disable node verification" },
 206   { X("vrfy-on"),                &firm_opt.vrfy,             FIRM_VERIFICATION_ON, "firm: enable node verification" },
 207   { X("vrfy-report"),            &firm_opt.vrfy,             FIRM_VERIFICATION_REPORT, "firm: node verification, report only" },
 208   { X("check-all"),              &firm_opt.check_all,        1, "firm: enable checking all Firm phases" },
 209   { X("no-check-all"),           &firm_opt.check_all,        0, "firm: disable checking all Firm phases" },
 210   { X("vrfy-edges-on"),          &firm_opt.vrfy_edges,       1, "firm: enable out edge verification" },
 211   { X("vrfy-edges-off"),         &firm_opt.vrfy_edges,       0, "firm: disable out edge verification" },
 212
 213   /* dumping */
 214 #if defined(_DEBUG) || defined(FIRM_DEBUG)
 215   { X("debug"),                  &firm_dump.debug_print,     1, "firm: enable debug output" },
 216 #endif
 217
 218   { X("dump-ir"),                &firm_dump.ir_graph,        1, "firm: dump IR graph" },
 219   { X("dump-all-types"),         &firm_dump.all_types,       1, "firm: dump graph of all types" },
 220   { X("dump-no-blocks"),         &firm_dump.no_blocks,       1, "firm: dump non-blocked graph" },
 221   { X("dump-extbb"),             &firm_dump.extbb,           1, "firm: dump extended basic blocks" },
 222   { X("dump-all-phases"),        &firm_dump.all_phases,      1, "firm: dump graphs for all optimization phases" },
 223   { X("dump-edge-labels"),       &firm_dump.edge_labels,     1, "firm: dump edge labels" },
 224
 225   /* code generation */
 226   { X("no-codegen"),             &firm_be_opt.selection,     BE_NONE, "cg: disable code generator" },
 227
 228 #ifdef FIRM_EXT_GRS
 229   { X("grs-simd-opt"),           &firm_ext_grs.simd_opt,                1, "firm: do simd optimization" },
 230   { X("grs-create-pattern"),     &firm_ext_grs.create_pattern,  1, "firm: create patterns for simd optimization" },
 231   { X("no-grs-simd-opt"),        &firm_ext_grs.simd_opt,                0, "firm: do simd optimization" },
 232   { X("no-grs-create-pattern"),  &firm_ext_grs.create_pattern,  0, "firm: create patterns for simd optimization" },
 233 #endif
 234
 235 #ifdef FIRM_BACKEND
 236   { X("be-firm"),                &firm_be_opt.selection,     BE_FIRM_BE, "backend: firm backend facility" },
 237 #endif /* FIRM_BACKEND */
 238 #ifdef FIRM2C_BACKEND
 239   { X("be-firm2c"),              &firm_be_opt.selection,     BE_FIRM2C, "backend: firm2C" },
 240 #endif /* FIRM2C_BACKEND */
 241
 242   /* misc */
 243   { X("stat-before-opt"),        &firm_dump.statistic,       STAT_BEFORE_OPT,  "misc: Firm statistic output before optimizations" },
 244   { X("stat-after-opt"),         &firm_dump.statistic,       STAT_AFTER_OPT,   "misc: Firm statistic output after optimizations" },
 245   { X("stat-after-lower"),       &firm_dump.statistic,       STAT_AFTER_LOWER, "misc: Firm statistic output after lowering" },
 246   { X("stat-final-ir"),          &firm_dump.statistic,       STAT_FINAL_IR,    "misc: Firm statistic after final optimization" },
 247   { X("stat-final"),             &firm_dump.statistic,       STAT_FINAL,       "misc: Firm statistic after code generation" },
 248   { X("stat-pattern"),           &firm_dump.stat_pattern,    1, "misc: Firm statistic calculates most used pattern" },
 249   { X("stat-dag"),               &firm_dump.stat_dag,        1, "misc: Firm calculates DAG statistics" },
 250   { X("firm-asm"),               &firm_dump.gen_firm_asm,    1, "misc: output Firm assembler" },
 251   { X("win32"),                  &firm_opt.os_support,       OS_SUPPORT_MINGW, "misc: generate MinGW Win32 code" },
 252   { X("mac"),                    &firm_opt.os_support,       OS_SUPPORT_MACHO, "misc: generate MacOS code" },
 253   { X("linux"),                  &firm_opt.os_support,       OS_SUPPORT_LINUX, "misc: generate Linux-ELF code" },
 254   { X("ycomp"),                  &firm_opt.ycomp_dbg,        1, "misc: enable yComp debugger extension" },
 255   { X("ycomp-host=<hostname>"),  NULL,                       0, "misc: yComp host" },
 256   { X("ycomp-port=<port>"),      NULL,                       0, "misc: yComp port" },
 257
 258   /* string options */
 259   { X("dump-filter=<string>"),   NULL,                       0, "misc: set dumper filter" },
 260 };
 261
 262 #undef X
 263
 264 /** A strdup replacement */
 265 static char *StrDup(const char *s) {
 266   int   l = strlen(s);
 267   char *r = malloc(l+1);
 268
 269   if (r != NULL)
 270     memcpy(r, s, l+1);
 271   return r;
 272 }
 273
 274 /**
 275  * Set a dumper filter.
 276  */
 277 static void set_dump_filter(const char *filter)
 278 {
 279   firm_dump.filter = StrDup(filter);
 280 }  /* set_dump_filter */
 281
 282 /**
 283  * Set ycomp host
 284  */
 285 static void set_ycomp_host(const char *host)
 286 {
 287   firm_opt.ycomp_host = StrDup(host);
 288 }  /* set_ycomp_host */
 289
 290 /** Disable all optimizations. */
 291 static void disable_opts(void) {
 292   /* firm_opt.const_folding */
 293   firm_opt.reassoc         = FALSE;
 294   firm_opt.cse             = FALSE;
 295   /* firm_opt.control_flow */
 296   firm_opt.gcse            = FALSE;
 297   firm_opt.gvn_pre         = FALSE;
 298   firm_opt.cond_eval       = FALSE;
 299   firm_opt.if_conversion   = FALSE;
 300   firm_opt.func_calls      = FALSE;
 301   firm_opt.do_inline       = FALSE;
 302   firm_opt.auto_inline     = FALSE;
 303   firm_opt.tail_rec        = FALSE;
 304   firm_opt.strength_red    = FALSE;
 305   firm_opt.scalar_replace  = FALSE;
 306   firm_opt.confirm         = FALSE;
 307   firm_opt.muls            = FALSE;
 308   firm_opt.divs            = FALSE;
 309   firm_opt.mods            = FALSE;
 310   firm_opt.fragile_ops     = FALSE;
 311   firm_opt.load_store      = FALSE;
 312   firm_opt.remove_unused   = FALSE;
 313   /* firm_opt.jmp_tbls */
 314   firm_opt.cloning         = FALSE;
 315   /* firm_opt.auto_sync */
 316   firm_opt.alias_analysis  = FALSE;
 317   firm_opt.strict_alias    = FALSE;
 318   firm_opt.no_alias        = FALSE;
 319   firm_opt.luffig          = FALSE;
 320   firm_opt.deconv          = FALSE;
 321   firm_opt.cc_opt          = FALSE;
 322   firm_opt.bool_opt        = FALSE;
 323   firm_opt.freestanding    = TRUE;
 324 }  /* disable_opts */
 325
 326 /**
 327  * Handles a firm option.
 328  */
 329 int firm_option(const char *opt)
 330 {
 331   int i, len    = strlen(opt);
 332   const char *p = opt;
 333   int res;
 334
 335   if (strncmp("dump-filter=", opt, 12) == 0) {
 336     opt = &opt[12];
 337     set_dump_filter(opt);
 338     return 1;
 339   }
 340   else if (strncmp("clone-threshold=", opt, 16) == 0) {
 341     sscanf(&opt[16], "%d", &firm_opt.clone_threshold);
 342     firm_opt.cloning = TRUE;
 343     return 1;
 344   }
 345   else if (strncmp("ycomp-host=", opt, 11) == 0) {
 346     opt = &opt[11];
 347     set_ycomp_host(opt);
 348     return 1;
 349   }
 350   else if (strncmp("ycomp-port=", opt, 11) == 0) {
 351     sscanf(&opt[11], "%d", &firm_opt.ycomp_port);
 352     return 1;
 353   }
 354   else if (strcmp("no-opt", opt) == 0) {
 355     disable_opts();
 356     return 1;
 357   }
 358
 359   for (i = sizeof(firm_options) / sizeof(firm_options[0]) - 1; i >= 0; --i) {
 360     if (len == firm_options[i].opt_len && strncmp(p, firm_options[i].option, len) == 0) {
 361       if (!firm_options[i].flag) {
 362         /* help option */
 363         for (i = 0; i < (int) (sizeof(firm_options)/sizeof(firm_options[0])); ++i) {
 364           printf("-f %-20s %s\n", firm_options[i].option,
 365                  firm_options[i].description);
 366         }
 367         return -1;
 368       }
 369       /* statistic options do accumulate */
 370       if (firm_options[i].flag == &firm_dump.statistic)
 371         *firm_options[i].flag = (a_byte) (*firm_options[i].flag | firm_options[i].set);
 372       else
 373         *firm_options[i].flag = firm_options[i].set;
 374
 375       if (firm_options[i].flag == &firm_opt.debug_mode && firm_opt.debug_mode > DBG_MODE_NONE) {
 376         if (firm_opt.debug_mode == DBG_MODE_FULL)
 377           disable_opts();
 378         res = 1;
 379         res &= firm_be_option("omitfp=0");
 380         res &= firm_be_option("stabs");
 381         return res;
 382       }
 383       break;
 384     }
 385   }
 386
 387   if (i < 0)
 388     return 0;
 389   return 1;
 390 }  /* firm_option */
 391
 392 /**
 393  * Handles a firm backend option.
 394  *
 395  * The options are here only checked for validity and later transmitted
 396  * to the firm backend (in the hope they do not fail ...)
 397  */
 398 int firm_be_option(const char *opt) {
 399 #ifdef FIRM_BACKEND
 400   return be_parse_arg(opt);
 401 #else
 402   return 0;
 403 #endif /* FIRM_BACKEND */
 404 }  /* firm_be_option */
 405
 406 /**
 407  * prints the firm version number
 408  */
 409 void print_firm_version(FILE *f) {
 410   firm_version_t version;
 411
 412   firm_get_version(&version);
 413
 414   fprintf(f, "Firm C-Compiler using libFirm (%u.%u", version.major, version.minor);
 415   if (version.revision[0] != 0) {
 416         fputc(' ', f);
 417     fputs(version.revision, f);
 418   }
 419    if(version.build[0] != 0) {
 420         fputc(' ', f);
 421     fputs(version.build, f);
 422   }
 423   fprintf(f, "}\n"
 424                      "(C) 2005-2008 Michael Beck\n"
 425              "(C) 1995-2008 University of Karlsruhe\n"
 426              "Using ");
 427 }  /* print_firm_version */