2 * @file firm_cmdline.c -- Additional Firm generating backend parameters
4 * Compile when BACK_END_IS_CP_FIRM_BE is defined
6 * (C) 2005 Michael Beck beck@ipd.info.uni-karlsruhe.de
11 #include "../adt/strutil.h"
12 #include "../adt/util.h"
13 #include "firm_cmdline.h"
15 #include <libfirm/firm.h>
16 #include <libfirm/be.h>
18 /* optimization settings */
19 struct a_firm_opt firm_opt = {
20 /* const_folding = */ true,
26 /* alias_analysis = */ true,
27 /* strict_alias = */ false,
28 /* no_alias = */ false,
29 /* fp_model = */ fp_model_precise,
30 /* verify = */ FIRM_VERIFICATION_ON,
31 /* check_all = */ true,
32 /* clone_threshold = */ DEFAULT_CLONE_THRESHOLD,
33 /* inline_maxsize = */ 750,
34 /* inline_threshold= */ 0,
35 /* verify_edges = */ false,
39 struct a_firm_dump firm_dump = {
40 /* debug_print = */ false,
41 /* all_types = */ false,
42 /* no_blocks = */ false,
44 /* ir_graph = */ false,
45 /* all_phases = */ false,
46 /* statistic = */ STAT_NONE,
47 /* stat_pattern = */ 0,
52 #define X(a) a, sizeof(a)-1
54 /** Parameter description structure */
55 static const struct params {
56 const char *option; /**< name of the option */
57 size_t opt_len; /**< length of the option string */
58 bool *flag; /**< address of variable to set/reset */
59 bool set; /**< iff true, variable will be set, else reset */
60 const char *description; /**< description of this option */
62 /* this must be first */
63 { X("help"), NULL, 0, "print FCC related help options" },
65 /* firm optimization options */
66 { X("no-opt"), NULL, 0, "firm: disable all FIRM optimizations" },
67 { X("cse"), &firm_opt.cse, 1, "firm: enable common subexpression elimination" },
68 { X("no-cse"), &firm_opt.cse, 0, "firm: disable common subexpression elimination" },
69 { X("const-fold"), &firm_opt.const_folding, 1, "firm: enable constant folding" },
70 { X("no-const-fold"), &firm_opt.const_folding, 0, "firm: disable constant folding" },
71 { X("inline-max-size=<size>"), NULL, 0, "firm: set maximum size for function inlining" },
72 { X("inline-threshold=<size>"),NULL, 0, "firm: set benefice threshold for function inlining" },
73 { X("confirm"), &firm_opt.confirm, 1, "firm: enable Confirm optimization" },
74 { X("no-confirm"), &firm_opt.confirm, 0, "firm: disable Confirm optimization" },
75 { X("opt-mul"), &firm_opt.muls, 0, "firm: enable multiplication optimization" },
76 { X("no-opt-mul"), &firm_opt.muls, 0, "firm: disable multiplication optimization" },
77 { X("opt-div"), &firm_opt.divs, 0, "firm: enable division optimization" },
78 { X("no-opt-div"), &firm_opt.divs, 0, "firm: disable division optimization" },
79 { X("opt-mod"), &firm_opt.mods, 0, "firm: enable remainder optimization" },
80 { X("no-opt-mod"), &firm_opt.mods, 0, "firm: disable remainder optimization" },
81 { X("opt-alias"), &firm_opt.alias_analysis, 1, "firm: enable alias analysis" },
82 { X("no-opt-alias"), &firm_opt.alias_analysis, 0, "firm: disable alias analysis" },
83 { X("alias"), &firm_opt.no_alias, 0, "firm: aliasing occurs" },
84 { X("no-alias"), &firm_opt.no_alias, 1, "firm: no aliasing occurs" },
85 { X("strict-aliasing"), &firm_opt.strict_alias, 1, "firm: strict alias rules" },
86 { X("no-strict-aliasing"), &firm_opt.strict_alias, 0, "firm: strict alias rules" },
87 { X("clone-threshold=<value>"),NULL, 0, "firm: set clone threshold to <value>" },
88 { X("fp-precise"), &firm_opt.fp_model, fp_model_precise, "firm: precise fp model" },
89 { X("fp-fast"), &firm_opt.fp_model, fp_model_fast, "firm: fast fp model" },
90 { X("fp-strict"), &firm_opt.fp_model, fp_model_strict, "firm: strict fp model" },
92 /* other firm regarding options */
93 { X("verify-off"), &firm_opt.verify, FIRM_VERIFICATION_OFF, "firm: disable node verification" },
94 { X("verify-on"), &firm_opt.verify, FIRM_VERIFICATION_ON, "firm: enable node verification" },
95 { X("verify-report"), &firm_opt.verify, FIRM_VERIFICATION_REPORT, "firm: node verification, report only" },
96 { X("check-all"), &firm_opt.check_all, 1, "firm: enable checking all Firm phases" },
97 { X("no-check-all"), &firm_opt.check_all, 0, "firm: disable checking all Firm phases" },
98 { X("verify-edges-on"), &firm_opt.verify_edges, 1, "firm: enable out edge verification" },
99 { X("verify-edges-off"), &firm_opt.verify_edges, 0, "firm: disable out edge verification" },
102 { X("dump-ir"), &firm_dump.ir_graph, 1, "firm: dump IR graph" },
103 { X("dump-all-types"), &firm_dump.all_types, 1, "firm: dump graph of all types" },
104 { X("dump-no-blocks"), &firm_dump.no_blocks, 1, "firm: dump non-blocked graph" },
105 { X("dump-extbb"), &firm_dump.extbb, 1, "firm: dump extended basic blocks" },
106 { X("dump-all-phases"), &firm_dump.all_phases, 1, "firm: dump graphs for all optimization phases" },
109 { X("stat-before-opt"), &firm_dump.statistic, STAT_BEFORE_OPT, "misc: Firm statistic output before optimizations" },
110 { X("stat-after-opt"), &firm_dump.statistic, STAT_AFTER_OPT, "misc: Firm statistic output after optimizations" },
111 { X("stat-after-lower"), &firm_dump.statistic, STAT_AFTER_LOWER, "misc: Firm statistic output after lowering" },
112 { X("stat-final-ir"), &firm_dump.statistic, STAT_FINAL_IR, "misc: Firm statistic after final optimization" },
113 { X("stat-final"), &firm_dump.statistic, STAT_FINAL, "misc: Firm statistic after code generation" },
114 { X("stat-pattern"), &firm_dump.stat_pattern, 1, "misc: Firm statistic calculates most used pattern" },
115 { X("stat-dag"), &firm_dump.stat_dag, 1, "misc: Firm calculates DAG statistics" },
118 { X("dump-filter=<string>"), NULL, 0, "misc: set dumper filter" },
123 /** A strdup replacement */
124 static char *StrDup(const char *s) {
126 char *r = malloc(l+1);
134 * Set a dumper filter.
136 static void set_dump_filter(const char *filter)
138 firm_dump.filter = StrDup(filter);
139 } /* set_dump_filter */
141 /** Disable all optimizations. */
142 static void disable_opts(void) {
143 firm_opt.cse = false;
144 firm_opt.confirm = false;
145 firm_opt.muls = false;
146 firm_opt.divs = false;
147 firm_opt.mods = false;
148 firm_opt.alias_analysis = false;
149 firm_opt.strict_alias = false;
150 firm_opt.no_alias = false;
154 void print_option_help(const char *name, const char *description)
156 printf("-f %-20s %s\n", name, description);
160 * Handles a firm option.
162 int firm_option(char const *const opt)
165 if ((val = strstart(opt, "dump-filter="))) {
166 set_dump_filter(val);
168 } else if ((val = strstart(opt, "clone-threshold="))) {
169 sscanf(val, "%d", &firm_opt.clone_threshold);
171 } else if ((val = strstart(opt, "inline-max-size="))) {
172 sscanf(val, "%u", &firm_opt.inline_maxsize);
174 } else if ((val = strstart(opt, "inline-threshold="))) {
175 sscanf(val, "%u", &firm_opt.inline_threshold);
177 } else if (streq(opt, "no-opt")) {
182 size_t const len = strlen(opt);
183 for (size_t i = lengthof(firm_options); i != 0;) {
184 struct params const* const o = &firm_options[--i];
185 if (len == o->opt_len && strncmp(opt, o->option, len) == 0) {
188 print_option_help(firm_options[0].option, firm_options[0].description);
189 firm_opt_option_help();
190 for (size_t k = 1; k != lengthof(firm_options); ++k) {
191 print_option_help(firm_options[k].option, firm_options[k].description);
196 /* statistic options do accumulate */
197 if (o->flag == &firm_dump.statistic)
198 *o->flag = (bool) (*o->flag | o->set);
206 /* maybe this enables/disables optimisations */
207 if (firm_opt_option(opt))