|
131
|
1 /* Provide option suggestion for --complete option and a misspelled
|
|
|
2 used by a user.
|
|
|
3 Copyright (C) 2016-2018 Free Software Foundation, Inc.
|
|
|
4
|
|
|
5 This file is part of GCC.
|
|
|
6
|
|
|
7 GCC is free software; you can redistribute it and/or modify it under
|
|
|
8 the terms of the GNU General Public License as published by the Free
|
|
|
9 Software Foundation; either version 3, or (at your option) any later
|
|
|
10 version.
|
|
|
11
|
|
|
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
15 for more details.
|
|
|
16
|
|
|
17 You should have received a copy of the GNU General Public License
|
|
|
18 along with GCC; see the file COPYING3. If not see
|
|
|
19 <http://www.gnu.org/licenses/>. */
|
|
|
20
|
|
|
21 #include "config.h"
|
|
|
22 #include "system.h"
|
|
|
23 #include "coretypes.h"
|
|
|
24 #include "tm.h"
|
|
|
25 #include "opts.h"
|
|
|
26 #include "params.h"
|
|
|
27 #include "spellcheck.h"
|
|
|
28 #include "opt-suggestions.h"
|
|
|
29 #include "common/common-target.h"
|
|
|
30 #include "selftest.h"
|
|
|
31
|
|
|
32 option_proposer::~option_proposer ()
|
|
|
33 {
|
|
|
34 delete m_option_suggestions;
|
|
|
35 }
|
|
|
36
|
|
|
37 const char *
|
|
|
38 option_proposer::suggest_option (const char *bad_opt)
|
|
|
39 {
|
|
|
40 /* Lazily populate m_option_suggestions. */
|
|
|
41 if (!m_option_suggestions)
|
|
|
42 build_option_suggestions (NULL);
|
|
|
43 gcc_assert (m_option_suggestions);
|
|
|
44
|
|
|
45 /* "m_option_suggestions" is now populated. Use it. */
|
|
|
46 return find_closest_string
|
|
|
47 (bad_opt,
|
|
|
48 (auto_vec <const char *> *) m_option_suggestions);
|
|
|
49 }
|
|
|
50
|
|
|
51 /* Populate RESULTS with valid completions of options that begin
|
|
|
52 with OPTION_PREFIX. */
|
|
|
53
|
|
|
54 void
|
|
|
55 option_proposer::get_completions (const char *option_prefix,
|
|
|
56 auto_string_vec &results)
|
|
|
57 {
|
|
|
58 /* Bail out for an invalid input. */
|
|
|
59 if (option_prefix == NULL || option_prefix[0] == '\0')
|
|
|
60 return;
|
|
|
61
|
|
|
62 /* Option suggestions are built without first leading dash character. */
|
|
|
63 if (option_prefix[0] == '-')
|
|
|
64 option_prefix++;
|
|
|
65
|
|
|
66 size_t length = strlen (option_prefix);
|
|
|
67
|
|
|
68 /* Handle OPTION_PREFIX starting with "-param". */
|
|
|
69 const char *prefix = "-param";
|
|
|
70 if (length >= strlen (prefix)
|
|
|
71 && strstr (option_prefix, prefix) == option_prefix)
|
|
|
72 {
|
|
|
73 /* We support both '-param-xyz=123' and '-param xyz=123' */
|
|
|
74 option_prefix += strlen (prefix);
|
|
|
75 char separator = option_prefix[0];
|
|
|
76 option_prefix++;
|
|
|
77 if (separator == ' ' || separator == '=')
|
|
|
78 find_param_completions (separator, option_prefix, results);
|
|
|
79 }
|
|
|
80 else
|
|
|
81 {
|
|
|
82 /* Lazily populate m_option_suggestions. */
|
|
|
83 if (!m_option_suggestions)
|
|
|
84 build_option_suggestions (option_prefix);
|
|
|
85 gcc_assert (m_option_suggestions);
|
|
|
86
|
|
|
87 for (unsigned i = 0; i < m_option_suggestions->length (); i++)
|
|
|
88 {
|
|
|
89 char *candidate = (*m_option_suggestions)[i];
|
|
|
90 if (strlen (candidate) >= length
|
|
|
91 && strstr (candidate, option_prefix) == candidate)
|
|
|
92 results.safe_push (concat ("-", candidate, NULL));
|
|
|
93 }
|
|
|
94 }
|
|
|
95 }
|
|
|
96
|
|
|
97 /* Print on stdout a list of valid options that begin with OPTION_PREFIX,
|
|
|
98 one per line, suitable for use by Bash completion.
|
|
|
99
|
|
|
100 Implementation of the "-completion=" option. */
|
|
|
101
|
|
|
102 void
|
|
|
103 option_proposer::suggest_completion (const char *option_prefix)
|
|
|
104 {
|
|
|
105 auto_string_vec results;
|
|
|
106 get_completions (option_prefix, results);
|
|
|
107 for (unsigned i = 0; i < results.length (); i++)
|
|
|
108 printf ("%s\n", results[i]);
|
|
|
109 }
|
|
|
110
|
|
|
111 void
|
|
|
112 option_proposer::build_option_suggestions (const char *prefix)
|
|
|
113 {
|
|
|
114 gcc_assert (m_option_suggestions == NULL);
|
|
|
115 m_option_suggestions = new auto_string_vec ();
|
|
|
116
|
|
|
117 /* We build a vec of m_option_suggestions, using add_misspelling_candidates
|
|
|
118 to add copies of strings, without a leading dash. */
|
|
|
119
|
|
|
120 for (unsigned int i = 0; i < cl_options_count; i++)
|
|
|
121 {
|
|
|
122 const struct cl_option *option = &cl_options[i];
|
|
|
123 const char *opt_text = option->opt_text;
|
|
|
124 switch (i)
|
|
|
125 {
|
|
|
126 default:
|
|
|
127 if (option->var_type == CLVC_ENUM)
|
|
|
128 {
|
|
|
129 const struct cl_enum *e = &cl_enums[option->var_enum];
|
|
|
130 for (unsigned j = 0; e->values[j].arg != NULL; j++)
|
|
|
131 {
|
|
|
132 char *with_arg = concat (opt_text, e->values[j].arg, NULL);
|
|
|
133 add_misspelling_candidates (m_option_suggestions, option,
|
|
|
134 with_arg);
|
|
|
135 free (with_arg);
|
|
|
136 }
|
|
|
137 }
|
|
|
138 else
|
|
|
139 {
|
|
|
140 if (option->flags & CL_TARGET)
|
|
|
141 {
|
|
|
142 vec<const char *> option_values
|
|
|
143 = targetm_common.get_valid_option_values (i, prefix);
|
|
|
144 if (!option_values.is_empty ())
|
|
|
145 {
|
|
|
146 for (unsigned j = 0; j < option_values.length (); j++)
|
|
|
147 {
|
|
|
148 char *with_arg = concat (opt_text, option_values[j],
|
|
|
149 NULL);
|
|
|
150 add_misspelling_candidates (m_option_suggestions, option,
|
|
|
151 with_arg);
|
|
|
152 free (with_arg);
|
|
|
153 }
|
|
|
154 }
|
|
|
155 option_values.release ();
|
|
|
156 }
|
|
|
157 else
|
|
|
158 add_misspelling_candidates (m_option_suggestions, option,
|
|
|
159 opt_text);
|
|
|
160 }
|
|
|
161 break;
|
|
|
162
|
|
|
163 case OPT_fsanitize_:
|
|
|
164 case OPT_fsanitize_recover_:
|
|
|
165 /* -fsanitize= and -fsanitize-recover= can take
|
|
|
166 a comma-separated list of arguments. Given that combinations
|
|
|
167 are supported, we can't add all potential candidates to the
|
|
|
168 vec, but if we at least add them individually without commas,
|
|
|
169 we should do a better job e.g. correcting
|
|
|
170 "-sanitize=address"
|
|
|
171 to
|
|
|
172 "-fsanitize=address"
|
|
|
173 rather than to "-Wframe-address" (PR driver/69265). */
|
|
|
174 {
|
|
|
175 for (int j = 0; sanitizer_opts[j].name != NULL; ++j)
|
|
|
176 {
|
|
|
177 struct cl_option optb;
|
|
|
178 /* -fsanitize=all is not valid, only -fno-sanitize=all.
|
|
|
179 So don't register the positive misspelling candidates
|
|
|
180 for it. */
|
|
|
181 if (sanitizer_opts[j].flag == ~0U && i == OPT_fsanitize_)
|
|
|
182 {
|
|
|
183 optb = *option;
|
|
|
184 optb.opt_text = opt_text = "-fno-sanitize=";
|
|
|
185 optb.cl_reject_negative = true;
|
|
|
186 option = &optb;
|
|
|
187 }
|
|
|
188 /* Get one arg at a time e.g. "-fsanitize=address". */
|
|
|
189 char *with_arg = concat (opt_text,
|
|
|
190 sanitizer_opts[j].name,
|
|
|
191 NULL);
|
|
|
192 /* Add with_arg and all of its variant spellings e.g.
|
|
|
193 "-fno-sanitize=address" to candidates (albeit without
|
|
|
194 leading dashes). */
|
|
|
195 add_misspelling_candidates (m_option_suggestions, option,
|
|
|
196 with_arg);
|
|
|
197 free (with_arg);
|
|
|
198 }
|
|
|
199 }
|
|
|
200 break;
|
|
|
201 }
|
|
|
202 }
|
|
|
203 }
|
|
|
204
|
|
|
205 /* Find parameter completions for --param format with SEPARATOR.
|
|
|
206 Again, save the completions into results. */
|
|
|
207
|
|
|
208 void
|
|
|
209 option_proposer::find_param_completions (const char separator,
|
|
|
210 const char *param_prefix,
|
|
|
211 auto_string_vec &results)
|
|
|
212 {
|
|
|
213 char separator_str[] = {separator, '\0'};
|
|
|
214 size_t length = strlen (param_prefix);
|
|
|
215 for (unsigned i = 0; i < get_num_compiler_params (); ++i)
|
|
|
216 {
|
|
|
217 const char *candidate = compiler_params[i].option;
|
|
|
218 if (strlen (candidate) >= length
|
|
|
219 && strstr (candidate, param_prefix) == candidate)
|
|
|
220 results.safe_push (concat ("--param", separator_str, candidate, NULL));
|
|
|
221 }
|
|
|
222 }
|
|
|
223
|
|
|
224 #if CHECKING_P
|
|
|
225
|
|
|
226 namespace selftest {
|
|
|
227
|
|
|
228 /* Verify that PROPOSER generates sane auto-completion suggestions
|
|
|
229 for OPTION_PREFIX. */
|
|
|
230
|
|
|
231 static void
|
|
|
232 verify_autocompletions (option_proposer &proposer, const char *option_prefix)
|
|
|
233 {
|
|
|
234 auto_string_vec suggestions;
|
|
|
235 proposer.get_completions (option_prefix, suggestions);
|
|
|
236
|
|
|
237 /* There must be at least one suggestion, and every suggestion must
|
|
|
238 indeed begin with OPTION_PREFIX. */
|
|
|
239
|
|
|
240 ASSERT_GT (suggestions.length (), 0);
|
|
|
241
|
|
|
242 for (unsigned i = 0; i < suggestions.length (); i++)
|
|
|
243 ASSERT_STR_STARTSWITH (suggestions[i], option_prefix);
|
|
|
244 }
|
|
|
245
|
|
|
246 /* Verify that valid options are auto-completed correctly. */
|
|
|
247
|
|
|
248 static void
|
|
|
249 test_completion_valid_options (option_proposer &proposer)
|
|
|
250 {
|
|
|
251 const char *option_prefixes[] =
|
|
|
252 {
|
|
|
253 "-fno-var-tracking-assignments-toggle",
|
|
|
254 "-fpredictive-commoning",
|
|
|
255 "--param=stack-clash-protection-guard-size",
|
|
|
256 "--param=max-predicted-iterations",
|
|
|
257 "-ftree-loop-distribute-patterns",
|
|
|
258 "-fno-var-tracking",
|
|
|
259 "-Walloc-zero",
|
|
|
260 "--param=ipa-cp-value-list-size",
|
|
|
261 "-Wsync-nand",
|
|
|
262 "-Wno-attributes",
|
|
|
263 "--param=tracer-dynamic-coverage-feedback",
|
|
|
264 "-Wno-format-contains-nul",
|
|
|
265 "-Wnamespaces",
|
|
|
266 "-fisolate-erroneous-paths-attribute",
|
|
|
267 "-Wno-underflow",
|
|
|
268 "-Wtarget-lifetime",
|
|
|
269 "--param=asan-globals",
|
|
|
270 "-Wno-empty-body",
|
|
|
271 "-Wno-odr",
|
|
|
272 "-Wformat-zero-length",
|
|
|
273 "-Wstringop-truncation",
|
|
|
274 "-fno-ipa-vrp",
|
|
|
275 "-fmath-errno",
|
|
|
276 "-Warray-temporaries",
|
|
|
277 "-Wno-unused-label",
|
|
|
278 "-Wreturn-local-addr",
|
|
|
279 "--param=sms-dfa-history",
|
|
|
280 "--param=asan-instrument-reads",
|
|
|
281 "-Wreturn-type",
|
|
|
282 "-Wc++17-compat",
|
|
|
283 "-Wno-effc++",
|
|
|
284 "--param=max-fields-for-field-sensitive",
|
|
|
285 "-fisolate-erroneous-paths-dereference",
|
|
|
286 "-fno-defer-pop",
|
|
|
287 "-Wcast-align=strict",
|
|
|
288 "-foptimize-strlen",
|
|
|
289 "-Wpacked-not-aligned",
|
|
|
290 "-funroll-loops",
|
|
|
291 "-fif-conversion2",
|
|
|
292 "-Wdesignated-init",
|
|
|
293 "--param=max-iterations-computation-cost",
|
|
|
294 "-Wmultiple-inheritance",
|
|
|
295 "-fno-sel-sched-reschedule-pipelined",
|
|
|
296 "-Wassign-intercept",
|
|
|
297 "-Wno-format-security",
|
|
|
298 "-fno-sched-stalled-insns",
|
|
|
299 "-fbtr-bb-exclusive",
|
|
|
300 "-fno-tree-tail-merge",
|
|
|
301 "-Wlong-long",
|
|
|
302 "-Wno-unused-but-set-parameter",
|
|
|
303 NULL
|
|
|
304 };
|
|
|
305
|
|
|
306 for (const char **ptr = option_prefixes; *ptr != NULL; ptr++)
|
|
|
307 verify_autocompletions (proposer, *ptr);
|
|
|
308 }
|
|
|
309
|
|
|
310 /* Verify that valid parameters are auto-completed correctly,
|
|
|
311 both with the "--param=PARAM" form and the "--param PARAM" form. */
|
|
|
312
|
|
|
313 static void
|
|
|
314 test_completion_valid_params (option_proposer &proposer)
|
|
|
315 {
|
|
|
316 const char *option_prefixes[] =
|
|
|
317 {
|
|
|
318 "--param=sched-state-edge-prob-cutoff",
|
|
|
319 "--param=iv-consider-all-candidates-bound",
|
|
|
320 "--param=align-threshold",
|
|
|
321 "--param=prefetch-min-insn-to-mem-ratio",
|
|
|
322 "--param=max-unrolled-insns",
|
|
|
323 "--param=max-early-inliner-iterations",
|
|
|
324 "--param=max-vartrack-reverse-op-size",
|
|
|
325 "--param=ipa-cp-loop-hint-bonus",
|
|
|
326 "--param=tracer-min-branch-ratio",
|
|
|
327 "--param=graphite-max-arrays-per-scop",
|
|
|
328 "--param=sink-frequency-threshold",
|
|
|
329 "--param=max-cse-path-length",
|
|
|
330 "--param=sra-max-scalarization-size-Osize",
|
|
|
331 "--param=prefetch-latency",
|
|
|
332 "--param=dse-max-object-size",
|
|
|
333 "--param=asan-globals",
|
|
|
334 "--param=max-vartrack-size",
|
|
|
335 "--param=case-values-threshold",
|
|
|
336 "--param=max-slsr-cand-scan",
|
|
|
337 "--param=min-insn-to-prefetch-ratio",
|
|
|
338 "--param=tracer-min-branch-probability",
|
|
|
339 "--param sink-frequency-threshold",
|
|
|
340 "--param max-cse-path-length",
|
|
|
341 "--param sra-max-scalarization-size-Osize",
|
|
|
342 "--param prefetch-latency",
|
|
|
343 "--param dse-max-object-size",
|
|
|
344 "--param asan-globals",
|
|
|
345 "--param max-vartrack-size",
|
|
|
346 NULL
|
|
|
347 };
|
|
|
348
|
|
|
349 for (const char **ptr = option_prefixes; *ptr != NULL; ptr++)
|
|
|
350 verify_autocompletions (proposer, *ptr);
|
|
|
351 }
|
|
|
352
|
|
|
353 /* Return true when EXPECTED is one of completions for OPTION_PREFIX string. */
|
|
|
354
|
|
|
355 static bool
|
|
|
356 in_completion_p (option_proposer &proposer, const char *option_prefix,
|
|
|
357 const char *expected)
|
|
|
358 {
|
|
|
359 auto_string_vec suggestions;
|
|
|
360 proposer.get_completions (option_prefix, suggestions);
|
|
|
361
|
|
|
362 for (unsigned i = 0; i < suggestions.length (); i++)
|
|
|
363 {
|
|
|
364 char *r = suggestions[i];
|
|
|
365 if (strcmp (r, expected) == 0)
|
|
|
366 return true;
|
|
|
367 }
|
|
|
368
|
|
|
369 return false;
|
|
|
370 }
|
|
|
371
|
|
|
372 /* Return true when PROPOSER does not find any partial completion
|
|
|
373 for OPTION_PREFIX. */
|
|
|
374
|
|
|
375 static bool
|
|
|
376 empty_completion_p (option_proposer &proposer, const char *option_prefix)
|
|
|
377 {
|
|
|
378 auto_string_vec suggestions;
|
|
|
379 proposer.get_completions (option_prefix, suggestions);
|
|
|
380 return suggestions.is_empty ();
|
|
|
381 }
|
|
|
382
|
|
|
383 /* Verify autocompletions of partially-complete options. */
|
|
|
384
|
|
|
385 static void
|
|
|
386 test_completion_partial_match (option_proposer &proposer)
|
|
|
387 {
|
|
|
388 ASSERT_TRUE (in_completion_p (proposer, "-fsani", "-fsanitize=address"));
|
|
|
389 ASSERT_TRUE (in_completion_p (proposer, "-fsani",
|
|
|
390 "-fsanitize-address-use-after-scope"));
|
|
|
391 ASSERT_TRUE (in_completion_p (proposer, "-fipa-icf", "-fipa-icf-functions"));
|
|
|
392 ASSERT_TRUE (in_completion_p (proposer, "-fipa-icf", "-fipa-icf"));
|
|
|
393 ASSERT_TRUE (in_completion_p (proposer, "--param=",
|
|
|
394 "--param=max-vartrack-reverse-op-size"));
|
|
|
395 ASSERT_TRUE (in_completion_p (proposer, "--param ",
|
|
|
396 "--param max-vartrack-reverse-op-size"));
|
|
|
397
|
|
|
398 ASSERT_FALSE (in_completion_p (proposer, "-fipa-icf", "-fipa"));
|
|
|
399 ASSERT_FALSE (in_completion_p (proposer, "-fipa-icf-functions", "-fipa-icf"));
|
|
|
400
|
|
|
401 ASSERT_FALSE (empty_completion_p (proposer, "-"));
|
|
|
402 ASSERT_FALSE (empty_completion_p (proposer, "-fipa"));
|
|
|
403 ASSERT_FALSE (empty_completion_p (proposer, "--par"));
|
|
|
404 }
|
|
|
405
|
|
|
406 /* Verify that autocompletion does not return any match for garbage inputs. */
|
|
|
407
|
|
|
408 static void
|
|
|
409 test_completion_garbage (option_proposer &proposer)
|
|
|
410 {
|
|
|
411 ASSERT_TRUE (empty_completion_p (proposer, NULL));
|
|
|
412 ASSERT_TRUE (empty_completion_p (proposer, ""));
|
|
|
413 ASSERT_TRUE (empty_completion_p (proposer, "- "));
|
|
|
414 ASSERT_TRUE (empty_completion_p (proposer, "123456789"));
|
|
|
415 ASSERT_TRUE (empty_completion_p (proposer, "---------"));
|
|
|
416 ASSERT_TRUE (empty_completion_p (proposer, "#########"));
|
|
|
417 ASSERT_TRUE (empty_completion_p (proposer, "- - - - - -"));
|
|
|
418 ASSERT_TRUE (empty_completion_p (proposer, "-fsanitize=address2"));
|
|
|
419 }
|
|
|
420
|
|
|
421 /* Run all of the selftests within this file. */
|
|
|
422
|
|
|
423 void
|
|
|
424 opt_proposer_c_tests ()
|
|
|
425 {
|
|
|
426 option_proposer proposer;
|
|
|
427
|
|
|
428 test_completion_valid_options (proposer);
|
|
|
429 test_completion_valid_params (proposer);
|
|
|
430 test_completion_partial_match (proposer);
|
|
|
431 test_completion_garbage (proposer);
|
|
|
432 }
|
|
|
433
|
|
|
434 } // namespace selftest
|
|
|
435
|
|
|
436 #endif /* #if CHECKING_P */
|
