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 "firm_opt.h"
  13 #include <libfirm/firm.h>
  14 #include <libfirm/be.h>
  15
  16 #if defined(_WIN32) || defined(__CYGWIN__)
  17 #define DEFAULT_OS OS_SUPPORT_MINGW
  18 #elif defined(__APPLE__)
  19 #define DEFAULT_OS OS_SUPPORT_MACHO
  20 #else
  21 #define DEFAULT_OS OS_SUPPORT_LINUX
  22 #endif
  23
  24 /* optimization settings */
  25 struct a_firm_opt firm_opt = {
  26   /* enabled         = */ TRUE,
  27   /* debug_mode      = */ DBG_MODE_NONE,
  28   /* const_folding   = */ TRUE,
  29   /* cse             = */ TRUE,
  30   /* gcse            = */ TRUE,
  31   /* confirm         = */ TRUE,
  32   /* muls            = */ TRUE,
  33   /* divs            = */ TRUE,
  34   /* mods            = */ TRUE,
  35   /* alias_analysis  = */ TRUE,
  36   /* strict_alias    = */ FALSE,
  37   /* no_alias        = */ FALSE,
  38   /* cc_opt          = */ TRUE,
  39   /* freestanding;   = */ FALSE,
  40   /* fp_model        = */ fp_model_precise,
  41   /* verify          = */ FIRM_VERIFICATION_ON,
  42   /* check_all       = */ FALSE,
  43   /* lower           = */ TRUE,
  44   /* os_support      = */ DEFAULT_OS,
  45   /* honor_restrict  = */ TRUE,
  46   /* lower_bitfields = */ TRUE,
  47   /* pic             = */ FALSE,
  48   /* clone_threshold = */ DEFAULT_CLONE_THRESHOLD,
  49   /* inline_maxsize  = */ 750,
  50   /* inline_threshold= */ 0,
  51   /* verify_edges    = */ FALSE,
  52   /* grs_simd_opt    = */ 0,
  53   /* grs_create_pattern = */ 0,
  54   /* enable_statev   = */ FALSE,
  55   /* statev_filter   = */ "",
  56 };
  57
  58 /* dumping options */
  59 struct a_firm_dump firm_dump = {
  60   /* debug_print  = */ FALSE,
  61   /* all_types    = */ FALSE,
  62   /* no_blocks    = */ FALSE,
  63   /* extbb        = */ FALSE,
  64   /* ir_graph     = */ FALSE,
  65   /* all_phases   = */ FALSE,
  66   /* statistic    = */ STAT_NONE,
  67   /* stat_pattern = */ 0,
  68   /* stat_dag     = */ 0,
  69   /* filter       = */ NULL
  70 };
  71
  72 #ifdef FIRM_EXT_GRS
  73 struct a_firm_ext_grs firm_ext_grs = {
  74   /* simd_opt       = */ FALSE,
  75   /* create_pattern = */ FALSE
  76 };
  77 #endif
  78
  79 struct a_firm_be_opt firm_be_opt = {
  80   /* selection = */ BE_FIRM_BE,
  81   /* node_stat = */ 0,
  82 };
  83
  84 #define X(a)    a, sizeof(a)-1
  85
  86 /** Parameter description structure */
  87 static const struct params {
  88   const char *option;      /**< name of the option */
  89   int        opt_len;      /**< length of the option string */
  90   a_byte     *flag;        /**< address of variable to set/reset */
  91   a_byte     set;          /**< iff true, variable will be set, else reset */
  92   const char *description; /**< description of this option */
  93 } firm_options[] = {
  94   /* this must be first */
  95   { X("help"),                   NULL,                       0, "print FCC related help options" },
  96
  97   /* firm optimization options */
  98   { X("pic"),                    &firm_opt.pic,              1, "firm: generate position independent code" },
  99   { X("g0"),                     &firm_opt.debug_mode,       DBG_MODE_BACKSTORE, "firm: Debug Mode: use back stores" },
 100   { X("g1"),                     &firm_opt.debug_mode,       DBG_MODE_FULL,      "firm: Debug Mode: no register variables" },
 101   { X("no-opt"),                 NULL,                       0, "firm: disable all FIRM optimizations" },
 102   { X("cse"),                    &firm_opt.cse,              1, "firm: enable common subexpression elimination" },
 103   { X("no-cse"),                 &firm_opt.cse,              0, "firm: disable common subexpression elimination" },
 104   { X("const-fold"),             &firm_opt.const_folding,    1, "firm: enable constant folding" },
 105   { X("no-const-fold"),          &firm_opt.const_folding,    0, "firm: disable constant folding" },
 106   { X("gcse"),                   &firm_opt.gcse,             1, "firm: enable global common subexpression elimination" },
 107   { X("no-gcse"),                &firm_opt.gcse,             0, "firm: disable global common subexpression elimination" },
 108   { X("inline-max-size=<size>"), NULL,                       0, "firm: set maximum size for function inlining" },
 109   { X("inline-threshold=<size>"),NULL,                       0, "firm: set benefice threshold for function inlining" },
 110   { X("confirm"),                &firm_opt.confirm,          1, "firm: enable Confirm optimization" },
 111   { X("no-confirm"),             &firm_opt.confirm,          0, "firm: disable Confirm optimization" },
 112   { X("opt-mul"),                &firm_opt.muls,             0, "firm: enable multiplication optimization" },
 113   { X("no-opt-mul"),             &firm_opt.muls,             0, "firm: disable multiplication optimization" },
 114   { X("opt-div"),                &firm_opt.divs,             0, "firm: enable division optimization" },
 115   { X("no-opt-div"),             &firm_opt.divs,             0, "firm: disable division optimization" },
 116   { X("opt-mod"),                &firm_opt.mods,             0, "firm: enable remainder optimization" },
 117   { X("no-opt-mod"),             &firm_opt.mods,             0, "firm: disable remainder optimization" },
 118   { X("opt-alias"),              &firm_opt.alias_analysis,   1, "firm: enable alias analysis" },
 119   { X("no-opt-alias"),           &firm_opt.alias_analysis,   0, "firm: disable alias analysis" },
 120   { X("alias"),                  &firm_opt.no_alias,         0, "firm: aliasing occurs" },
 121   { X("no-alias"),               &firm_opt.no_alias,         1, "firm: no aliasing occurs" },
 122   { X("strict-aliasing"),        &firm_opt.strict_alias,     1, "firm: strict alias rules" },
 123   { X("no-strict-aliasing"),     &firm_opt.strict_alias,     0, "firm: strict alias rules" },
 124   { X("clone-threshold=<value>"),NULL,                       0, "firm: set clone threshold to <value>" },
 125   { X("fp-precise"),             &firm_opt.fp_model,         fp_model_precise, "firm: precise fp model" },
 126   { X("fp-fast"),                &firm_opt.fp_model,         fp_model_fast,    "firm: fast fp model" },
 127   { X("fp-strict"),              &firm_opt.fp_model,         fp_model_strict,  "firm: strict fp model" },
 128   { X("opt-cc"),                 &firm_opt.cc_opt,           1, "firm: enable calling conventions optimization" },
 129   { X("no-opt-cc"),              &firm_opt.cc_opt,           0, "firm: disable calling conventions optimization" },
 130   { X("freestanding"),           &firm_opt.freestanding,     1, "firm: freestanding environment" },
 131   { X("hosted"),                 &firm_opt.freestanding,     0, "firm: hosted environment" },
 132
 133   /* other firm regarding options */
 134   { X("restrict"),               &firm_opt.honor_restrict,   1, "firm: honor restrict keyword" },
 135   { X("no-restrict"),            &firm_opt.honor_restrict,   1, "firm: restrict keyword is meaningless" },
 136   { X("no-lower"),               &firm_opt.lower,            0, "firm: disable lowering" },
 137   { X("verify-off"),             &firm_opt.verify,           FIRM_VERIFICATION_OFF, "firm: disable node verification" },
 138   { X("verify-on"),              &firm_opt.verify,           FIRM_VERIFICATION_ON, "firm: enable node verification" },
 139   { X("verify-report"),          &firm_opt.verify,           FIRM_VERIFICATION_REPORT, "firm: node verification, report only" },
 140   { X("check-all"),              &firm_opt.check_all,        1, "firm: enable checking all Firm phases" },
 141   { X("no-check-all"),           &firm_opt.check_all,        0, "firm: disable checking all Firm phases" },
 142   { X("verify-edges-on"),        &firm_opt.verify_edges,     1, "firm: enable out edge verification" },
 143   { X("verify-edges-off"),       &firm_opt.verify_edges,     0, "firm: disable out edge verification" },
 144
 145   /* dumping */
 146 #if defined(_DEBUG) || defined(FIRM_DEBUG)
 147   { X("debug"),                  &firm_dump.debug_print,     1, "firm: enable debug output" },
 148 #endif
 149
 150   { X("dump-ir"),                &firm_dump.ir_graph,        1, "firm: dump IR graph" },
 151   { X("dump-all-types"),         &firm_dump.all_types,       1, "firm: dump graph of all types" },
 152   { X("dump-no-blocks"),         &firm_dump.no_blocks,       1, "firm: dump non-blocked graph" },
 153   { X("dump-extbb"),             &firm_dump.extbb,           1, "firm: dump extended basic blocks" },
 154   { X("dump-all-phases"),        &firm_dump.all_phases,      1, "firm: dump graphs for all optimization phases" },
 155
 156   /* code generation */
 157   { X("no-codegen"),             &firm_be_opt.selection,     BE_NONE, "cg: disable code generator" },
 158
 159 #ifdef FIRM_EXT_GRS
 160   { X("grs-simd-opt"),           &firm_ext_grs.simd_opt,       1, "firm: do simd optimization" },
 161   { X("grs-create-pattern"),     &firm_ext_grs.create_pattern, 1, "firm: create patterns for simd optimization" },
 162   { X("no-grs-simd-opt"),        &firm_ext_grs.simd_opt,       0, "firm: do simd optimization" },
 163   { X("no-grs-create-pattern"),  &firm_ext_grs.create_pattern, 0, "firm: create patterns for simd optimization" },
 164 #endif
 165
 166   { X("be-firm"),                &firm_be_opt.selection,     BE_FIRM_BE, "backend: firm backend facility" },
 167 #ifdef FIRM2C_BACKEND
 168   { X("be-firm2c"),              &firm_be_opt.selection,     BE_FIRM2C, "backend: firm2C" },
 169 #endif /* FIRM2C_BACKEND */
 170
 171   /* misc */
 172   { X("stat-before-opt"),        &firm_dump.statistic,       STAT_BEFORE_OPT,  "misc: Firm statistic output before optimizations" },
 173   { X("stat-after-opt"),         &firm_dump.statistic,       STAT_AFTER_OPT,   "misc: Firm statistic output after optimizations" },
 174   { X("stat-after-lower"),       &firm_dump.statistic,       STAT_AFTER_LOWER, "misc: Firm statistic output after lowering" },
 175   { X("stat-final-ir"),          &firm_dump.statistic,       STAT_FINAL_IR,    "misc: Firm statistic after final optimization" },
 176   { X("stat-final"),             &firm_dump.statistic,       STAT_FINAL,       "misc: Firm statistic after code generation" },
 177   { X("stat-pattern"),           &firm_dump.stat_pattern,    1, "misc: Firm statistic calculates most used pattern" },
 178   { X("stat-dag"),               &firm_dump.stat_dag,        1, "misc: Firm calculates DAG statistics" },
 179   { X("win32"),                  &firm_opt.os_support,       OS_SUPPORT_MINGW, "misc: generate MinGW Win32 code" },
 180   { X("mac"),                    &firm_opt.os_support,       OS_SUPPORT_MACHO, "misc: generate MacOS code" },
 181   { X("linux"),                  &firm_opt.os_support,       OS_SUPPORT_LINUX, "misc: generate Linux-ELF code" },
 182
 183   /* string options */
 184   { X("dump-filter=<string>"),   NULL,                       0, "misc: set dumper filter" },
 185 };
 186
 187 #undef X
 188
 189 /** A strdup replacement */
 190 static char *StrDup(const char *s) {
 191   int   l = strlen(s);
 192   char *r = malloc(l+1);
 193
 194   if (r != NULL)
 195     memcpy(r, s, l+1);
 196   return r;
 197 }
 198
 199 /**
 200  * Set a dumper filter.
 201  */
 202 static void set_dump_filter(const char *filter)
 203 {
 204   firm_dump.filter = StrDup(filter);
 205 }  /* set_dump_filter */
 206
 207 /** Disable all optimizations. */
 208 static void disable_opts(void) {
 209   firm_opt.cse             = FALSE;
 210   firm_opt.gcse            = FALSE;
 211   firm_opt.confirm         = FALSE;
 212   firm_opt.muls            = FALSE;
 213   firm_opt.divs            = FALSE;
 214   firm_opt.mods            = FALSE;
 215   firm_opt.alias_analysis  = FALSE;
 216   firm_opt.strict_alias    = FALSE;
 217   firm_opt.no_alias        = FALSE;
 218   firm_opt.cc_opt          = FALSE;
 219   firm_opt.freestanding    = TRUE;
 220   disable_all_opts();
 221 }  /* disable_opts */
 222
 223 void print_option_help(const char *name, const char *description)
 224 {
 225         printf("-f %-20s %s\n", name, description);
 226 }
 227
 228 /**
 229  * Handles a firm option.
 230  */
 231 int firm_option(const char *opt)
 232 {
 233   int i, len    = strlen(opt);
 234   const char *p = opt;
 235   int res;
 236
 237   if (strncmp("dump-filter=", opt, 12) == 0) {
 238     opt = &opt[12];
 239     set_dump_filter(opt);
 240     return 1;
 241   }
 242   else if (strncmp("clone-threshold=", opt, 16) == 0) {
 243     sscanf(&opt[16], "%d", &firm_opt.clone_threshold);
 244     return 1;
 245   }
 246   else if (strncmp("inline-max-size=", opt, 16) == 0) {
 247     sscanf(&opt[16], "%u", &firm_opt.inline_maxsize);
 248     return 1;
 249   }
 250   else if (strncmp("inline-threshold=", opt, 17) == 0) {
 251     sscanf(&opt[17], "%u", &firm_opt.inline_threshold);
 252     return 1;
 253   }
 254   else if (strcmp("no-opt", opt) == 0) {
 255     disable_opts();
 256     return 1;
 257   }
 258
 259   for (i = sizeof(firm_options) / sizeof(firm_options[0]) - 1; i >= 0; --i) {
 260     if (len == firm_options[i].opt_len && strncmp(p, firm_options[i].option, len) == 0) {
 261       if (!firm_options[i].flag) {
 262         /* help option */
 263         print_option_help(firm_options[0].option, firm_options[0].description);
 264         firm_opt_option_help();
 265         for (i = 1; i < (int) (sizeof(firm_options)/sizeof(firm_options[0])); ++i) {
 266           print_option_help(firm_options[i].option, firm_options[i].description);
 267         }
 268         return -1;
 269       }
 270       /* statistic options do accumulate */
 271       if (firm_options[i].flag == &firm_dump.statistic)
 272         *firm_options[i].flag = (a_byte) (*firm_options[i].flag | firm_options[i].set);
 273       else
 274         *firm_options[i].flag = firm_options[i].set;
 275
 276       if (firm_options[i].flag == &firm_opt.debug_mode && firm_opt.debug_mode > DBG_MODE_NONE) {
 277         if (firm_opt.debug_mode == DBG_MODE_FULL)
 278           disable_opts();
 279         res = 1;
 280         res &= be_parse_arg("omitfp=0");
 281         res &= be_parse_arg("stabs");
 282         return res;
 283       }
 284       break;
 285     }
 286   }
 287
 288   if (i >= 0)
 289     return 1;
 290
 291   /* maybe this enables/disables an optimisations */
 292   if (firm_opt_option(p))
 293     return 1;
 294
 295   return 0;
 296 }  /* firm_option */
 297
 298 /**
 299  * prints the firm version number
 300  */
 301 void print_firm_version(FILE *f) {
 302   const char *revision = ir_get_version_revision();
 303   const char *build    = ir_get_version_build();
 304
 305   fprintf(f, "Firm C-Compiler using libFirm (%u.%u",
 306           ir_get_version_major(), ir_get_version_minor());
 307   if (revision[0] != 0) {
 308         fputc(' ', f);
 309     fputs(revision, f);
 310   }
 311    if(build[0] != 0) {
 312         fputc(' ', f);
 313     fputs(build, f);
 314   }
 315   fprintf(f, "}\n"
 316                      "(C) 2005-2008 Michael Beck\n"
 317              "(C) 1995-2008 University of Karlsruhe\n"
 318              "Using ");
 319 }  /* print_firm_version */