remove a bunch of unimplemented/obsolete commandline switches

diff --git a/driver/firm_cmdline.c b/driver/firm_cmdline.c
index d9a690a..b812255 100644 (file)
--- a/driver/firm_cmdline.c
+++ b/driver/firm_cmdline.c
@@ -15,8 +15,6 @@
 
 /* optimization settings */
 struct a_firm_opt firm_opt = {
-  /* enabled         = */ TRUE,
-  /* debug_mode      = */ DBG_MODE_NONE,
   /* const_folding   = */ TRUE,
   /* cse             = */ TRUE,
   /* confirm         = */ TRUE,
@@ -26,22 +24,13 @@ struct a_firm_opt firm_opt = {
   /* alias_analysis  = */ TRUE,
   /* strict_alias    = */ FALSE,
   /* no_alias        = */ FALSE,
-  /* cc_opt          = */ TRUE,
   /* fp_model        = */ fp_model_precise,
   /* verify          = */ FIRM_VERIFICATION_ON,
   /* check_all       = */ FALSE,
-  /* lower           = */ TRUE,
-  /* honor_restrict  = */ TRUE,
-  /* lower_bitfields = */ TRUE,
-  /* pic             = */ FALSE,
   /* clone_threshold = */ DEFAULT_CLONE_THRESHOLD,
   /* inline_maxsize  = */ 750,
   /* inline_threshold= */ 0,
   /* verify_edges    = */ FALSE,
-  /* grs_simd_opt    = */ 0,
-  /* grs_create_pattern = */ 0,
-  /* enable_statev   = */ FALSE,
-  /* statev_filter   = */ "",
 };
 
 /* dumping options */
@@ -84,9 +73,6 @@ static const struct params {
   { X("help"),                   NULL,                       0, "print FCC related help options" },
 
   /* firm optimization options */
-  { X("pic"),                    &firm_opt.pic,              1, "firm: generate position independent code" },
-  { X("g0"),                     &firm_opt.debug_mode,       DBG_MODE_BACKSTORE, "firm: Debug Mode: use back stores" },
-  { X("g1"),                     &firm_opt.debug_mode,       DBG_MODE_FULL,      "firm: Debug Mode: no register variables" },
   { X("no-opt"),                 NULL,                       0, "firm: disable all FIRM optimizations" },
   { X("cse"),                    &firm_opt.cse,              1, "firm: enable common subexpression elimination" },
   { X("no-cse"),                 &firm_opt.cse,              0, "firm: disable common subexpression elimination" },
@@ -112,13 +98,8 @@ static const struct params {
   { X("fp-precise"),             &firm_opt.fp_model,         fp_model_precise, "firm: precise fp model" },
   { X("fp-fast"),                &firm_opt.fp_model,         fp_model_fast,    "firm: fast fp model" },
   { X("fp-strict"),              &firm_opt.fp_model,         fp_model_strict,  "firm: strict fp model" },
-  { X("opt-cc"),                 &firm_opt.cc_opt,           1, "firm: enable calling conventions optimization" },
-  { X("no-opt-cc"),              &firm_opt.cc_opt,           0, "firm: disable calling conventions optimization" },
 
   /* other firm regarding options */
-  { X("restrict"),               &firm_opt.honor_restrict,   1, "firm: honor restrict keyword" },
-  { X("no-restrict"),            &firm_opt.honor_restrict,   1, "firm: restrict keyword is meaningless" },
-  { X("no-lower"),               &firm_opt.lower,            0, "firm: disable lowering" },
   { X("verify-off"),             &firm_opt.verify,           FIRM_VERIFICATION_OFF, "firm: disable node verification" },
   { X("verify-on"),              &firm_opt.verify,           FIRM_VERIFICATION_ON, "firm: enable node verification" },
   { X("verify-report"),          &firm_opt.verify,           FIRM_VERIFICATION_REPORT, "firm: node verification, report only" },
@@ -196,7 +177,6 @@ static void disable_opts(void) {
   firm_opt.alias_analysis  = FALSE;
   firm_opt.strict_alias    = FALSE;
   firm_opt.no_alias        = FALSE;
-  firm_opt.cc_opt          = FALSE;
   disable_all_opts();
 }  /* disable_opts */
 
@@ -212,7 +192,6 @@ int firm_option(const char *opt)
 {
   int i, len    = strlen(opt);
   const char *p = opt;
-  int res;
 
   if (strncmp("dump-filter=", opt, 12) == 0) {
     opt = &opt[12];
@@ -253,14 +232,6 @@ int firm_option(const char *opt)
       else
         *firm_options[i].flag = firm_options[i].set;
 
-      if (firm_options[i].flag == &firm_opt.debug_mode && firm_opt.debug_mode > DBG_MODE_NONE) {
-        if (firm_opt.debug_mode == DBG_MODE_FULL)
-          disable_opts();
-        res = 1;
-        res &= be_parse_arg("omitfp=0");
-        res &= be_parse_arg("stabs");
-        return res;
-      }
       break;
     }
   }

diff --git a/driver/firm_cmdline.h b/driver/firm_cmdline.h
index ae71c7e..17b21e0 100644 (file)
--- a/driver/firm_cmdline.h
+++ b/driver/firm_cmdline.h
@@ -12,16 +12,8 @@
 
 #include "fe_common.h"
 
-enum a_debug_mode {
-  DBG_MODE_NONE      = 0,   /**< no special debug support */
-  DBG_MODE_BACKSTORE = 1,   /**< backstores are created */
-  DBG_MODE_FULL      = 2,   /**< no register valiables */
-};
-
 /* optimization settings */
 struct a_firm_opt {
-  a_byte      enabled;         /**< enable all optimizations */
-  a_byte      debug_mode;      /**< debug mode: store all local variables */
   a_byte      const_folding;   /**< enable constant folding */
   a_byte      cse;             /**< enable common-subexpression elimination */
   a_byte      confirm;         /**< enable Confirm optimization */
@@ -31,22 +23,13 @@ struct a_firm_opt {
   a_byte      alias_analysis;  /**< enable Alias Analysis */
   a_byte      strict_alias;    /**< enable strict Alias Analysis (using type based AA) */
   a_byte      no_alias;        /**< no aliasing possible. */
-  a_byte      cc_opt;          /**< optimize calling conventions */
   a_byte      fp_model;        /**< fp model */
   a_byte      verify;          /**< Firm verifier setting */
   a_byte      check_all;       /**< enable checking all Firm phases */
-  a_byte      lower;           /**< enable Firm lowering */
-  a_byte      honor_restrict;  /**< enable restrict keyword */
-  a_byte      lower_bitfields; /**< lower bitfield access */
-  a_byte      pic;             /**< generate position independent code */
   int         clone_threshold; /**< The threshold value for procedure cloning. */
   unsigned    inline_maxsize;  /**< Maximum function size for inlining. */
   unsigned    inline_threshold;/**< Inlining benefice threshold. */
   a_byte      verify_edges;    /**< verify edges */
-  a_byte      grs_simd_opt;
-  a_byte      grs_create_pattern;
-  a_byte      enable_statev;   /**< enable statev output */
-  const char *statev_filter;  /**< statev filter */
 };
 
 /** statistic options */

diff --git a/driver/firm_opt.c b/driver/firm_opt.c
index 338ce4a..bb7385d 100644 (file)
--- a/driver/firm_opt.c
+++ b/driver/firm_opt.c
@@ -159,7 +159,7 @@ static void do_optimize_funccalls(void)
 
 static void do_lower_highlevel(ir_graph *irg)
 {
-       lower_highlevel_graph(irg, firm_opt.lower_bitfields);
+       lower_highlevel_graph(irg, false);
 }
 
 static void do_stred(ir_graph *irg)
@@ -263,6 +263,7 @@ static opt_config_t opts[] = {
        IRP("opt-proc-clone",    do_cloning,               "procedure cloning",                                     OPT_FLAG_NONE),
        IRP("remove-unused",     garbage_collect_entities, "removal of unused functions/variables",                 OPT_FLAG_NO_DUMP | OPT_FLAG_NO_VERIFY),
        IRP("rts",               rts_map,                  "optimization of known library functions",               OPT_FLAG_HIDE_OPTIONS),
+       IRP("opt-cc",            mark_private_methods,     "calling conventions optimization",                      OPT_FLAG_NONE),
 #undef IRP
 #undef IRG
 };
@@ -388,6 +389,7 @@ static void enable_safe_defaults(void)
        set_opt_enabled("target-lowering", true);
        set_opt_enabled("rts", true);
        set_opt_enabled("parallelize-mem", true);
+       set_opt_enabled("opt-cc", true);
 }
 
 /**
@@ -544,43 +546,37 @@ static void do_firm_lowering(const char *input_filename)
        if (firm_dump.statistic & STAT_AFTER_LOWER)
                stat_dump_snapshot(input_filename, "low");
 
-       if (firm_opt.enabled) {
-               timer_start(t_all_opt);
+       timer_start(t_all_opt);
 
-               for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
-                       ir_graph *irg = get_irp_irg(i);
+       for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+               ir_graph *irg = get_irp_irg(i);
+
+               do_irg_opt(irg, "local");
+               do_irg_opt(irg, "place");
+               do_irg_opt(irg, "control-flow");
+               do_irg_opt(irg, "opt-load-store");
+               do_irg_opt(irg, "local");
+               do_irg_opt(irg, "control-flow");
 
+               if (do_irg_opt(irg, "vrp")) {
                        do_irg_opt(irg, "local");
-                       do_irg_opt(irg, "place");
                        do_irg_opt(irg, "control-flow");
-                       do_irg_opt(irg, "opt-load-store");
+                       do_irg_opt(irg, "vrp");
                        do_irg_opt(irg, "local");
                        do_irg_opt(irg, "control-flow");
-
-                       if (do_irg_opt(irg, "vrp")) {
-                               do_irg_opt(irg, "local");
-                               do_irg_opt(irg, "control-flow");
-                               do_irg_opt(irg, "vrp");
-                               do_irg_opt(irg, "local");
-                               do_irg_opt(irg, "control-flow");
-                       }
-
-                       if (do_irg_opt(irg, "if-conversion")) {
-                               do_irg_opt(irg, "local");
-                               do_irg_opt(irg, "control-flow");
-                       }
-
-                       do_irg_opt(irg, "parallelize-mem");
                }
-               timer_stop(t_all_opt);
 
-               do_irp_opt("remove-unused");
+               if (do_irg_opt(irg, "if-conversion")) {
+                       do_irg_opt(irg, "local");
+                       do_irg_opt(irg, "control-flow");
+               }
 
-               dump_all("low-opt");
+               do_irg_opt(irg, "parallelize-mem");
        }
-
-       if (firm_opt.cc_opt)
-               mark_private_methods();
+       do_irp_opt("remove-unused");
+       do_irp_opt("opt-cc");
+       timer_stop(t_all_opt);
+       dump_all("low-opt");
 
        if (firm_dump.statistic & STAT_FINAL) {
                stat_dump_snapshot(input_filename, "final");
@@ -636,16 +632,12 @@ void gen_firm_init(void)
        if (firm_dump.no_blocks)
                ir_remove_dump_flags(ir_dump_flag_blocks_as_subgraphs);
 
-       if (firm_opt.enabled) {
-               set_optimize(1);
-               set_opt_constant_folding(firm_opt.const_folding);
-               set_opt_algebraic_simplification(firm_opt.const_folding);
-               set_opt_cse(firm_opt.cse);
-               set_opt_global_cse(0);
-               set_opt_unreachable_code(1);
-       } else {
-               set_optimize(0);
-       }
+       set_optimize(1);
+       set_opt_constant_folding(firm_opt.const_folding);
+       set_opt_algebraic_simplification(firm_opt.const_folding);
+       set_opt_cse(firm_opt.cse);
+       set_opt_global_cse(0);
+       set_opt_unreachable_code(1);
 }
 
 /**
@@ -662,15 +654,6 @@ void gen_firm_finish(FILE *out, const char *input_filename,
 {
        int i;
 
-#if 0
-       if (firm_opt.enable_statev) {
-               char buf[1024];
-               snprintf(buf, sizeof(buf), "%s.ev", input_filename);
-               ir_stat_ev_begin(input_filename, firm_opt.statev_filter);
-               ir_stat_ev_compilation_unit(input_filename);
-       }
-#endif
-
        firm_const_exists = new_firm_const_exists;
 
        /* the general for dumping option must be set, or the others will not work*/
@@ -718,11 +701,8 @@ void gen_firm_finish(FILE *out, const char *input_filename,
                stat_dump_snapshot(input_filename, "noopt");
        }
 
-       if (firm_opt.enabled)
-               do_firm_optimizations(input_filename);
-
-       if (firm_opt.lower)
-               do_firm_lowering(input_filename);
+       do_firm_optimizations(input_filename);
+       do_firm_lowering(input_filename);
 
        /* set the phase to low */
        for (i = get_irp_n_irgs() - 1; i >= 0; --i)

diff --git a/main.c b/main.c
index a512c28..687c59f 100644 (file)
--- a/main.c
+++ b/main.c
@@ -1294,9 +1294,6 @@ int main(int argc, char **argv)
                return EXIT_FAILURE;
        }
 
-       /* we do the lowering in ast2firm */
-       firm_opt.lower_bitfields = FALSE;
-
        /* set the c_mode here, types depends on it */
        c_mode |= features_on;
        c_mode &= ~features_off;