[thirdparty/gcc.git] / gcc / opt-suggestions.c

/* Provide option suggestion for --complete option and a misspelled
   used by a user.
   Copyright (C) 2016-2019 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "opts.h"
#include "params.h"
#include "spellcheck.h"
#include "opt-suggestions.h"
#include "common/common-target.h"
#include "selftest.h"

option_proposer::~option_proposer ()
{
  delete m_option_suggestions;
}

const char *
option_proposer::suggest_option (const char *bad_opt)
{
  /* Lazily populate m_option_suggestions.  */
  if (!m_option_suggestions)
    build_option_suggestions (NULL);
  gcc_assert (m_option_suggestions);

  /* "m_option_suggestions" is now populated.  Use it.  */
  return find_closest_string
    (bad_opt,
     (auto_vec <const char *> *) m_option_suggestions);
}

/* Populate RESULTS with valid completions of options that begin
   with OPTION_PREFIX.  */

void
option_proposer::get_completions (const char *option_prefix,
				  auto_string_vec &results)
{
  /* Bail out for an invalid input.  */
  if (option_prefix == NULL || option_prefix[0] == '\0')
    return;

  /* Option suggestions are built without first leading dash character.  */
  if (option_prefix[0] == '-')
    option_prefix++;

  size_t length = strlen (option_prefix);

  /* Handle OPTION_PREFIX starting with "-param".  */
  const char *prefix = "-param";
  if (length >= strlen (prefix)
      && strstr (option_prefix, prefix) == option_prefix)
    {
      /* We support both '-param-xyz=123' and '-param xyz=123' */
      option_prefix += strlen (prefix);
      char separator = option_prefix[0];
      option_prefix++;
      if (separator == ' ' || separator == '=')
	find_param_completions (separator, option_prefix, results);
    }
  else
    {
      /* Lazily populate m_option_suggestions.  */
      if (!m_option_suggestions)
	build_option_suggestions (option_prefix);
      gcc_assert (m_option_suggestions);

      for (unsigned i = 0; i < m_option_suggestions->length (); i++)
	{
	  char *candidate = (*m_option_suggestions)[i];
	  if (strlen (candidate) >= length
	      && strstr (candidate, option_prefix) == candidate)
	    results.safe_push (concat ("-", candidate, NULL));
	}
    }
}

/* Print on stdout a list of valid options that begin with OPTION_PREFIX,
   one per line, suitable for use by Bash completion.

   Implementation of the "-completion=" option.  */

void
option_proposer::suggest_completion (const char *option_prefix)
{
  auto_string_vec results;
  get_completions (option_prefix, results);
  for (unsigned i = 0; i < results.length (); i++)
    printf ("%s\n", results[i]);
}

void
option_proposer::build_option_suggestions (const char *prefix)
{
  gcc_assert (m_option_suggestions == NULL);
  m_option_suggestions = new auto_string_vec ();

  /* We build a vec of m_option_suggestions, using add_misspelling_candidates
     to add copies of strings, without a leading dash.  */

  for (unsigned int i = 0; i < cl_options_count; i++)
    {
      const struct cl_option *option = &cl_options[i];
      const char *opt_text = option->opt_text;
      switch (i)
	{
	default:
	  if (option->var_type == CLVC_ENUM)
	    {
	      const struct cl_enum *e = &cl_enums[option->var_enum];
	      for (unsigned j = 0; e->values[j].arg != NULL; j++)
		{
		  char *with_arg = concat (opt_text, e->values[j].arg, NULL);
		  add_misspelling_candidates (m_option_suggestions, option,
					      with_arg);
		  free (with_arg);
		}

	      /* Add also variant without an option argument.  */
	      add_misspelling_candidates (m_option_suggestions, option,
					  opt_text);
	    }
	  else
	    {
	      bool option_added = false;
	      if (option->flags & CL_TARGET)
		{
		  vec<const char *> option_values
		    = targetm_common.get_valid_option_values (i, prefix);
		  if (!option_values.is_empty ())
		    {
		      option_added = true;
		      for (unsigned j = 0; j < option_values.length (); j++)
			{
			  char *with_arg = concat (opt_text, option_values[j],
						   NULL);
			  add_misspelling_candidates (m_option_suggestions, option,
						      with_arg);
			  free (with_arg);
			}
		    }
		  option_values.release ();
		}

	      if (!option_added)
		add_misspelling_candidates (m_option_suggestions, option,
					    opt_text);
	    }
	  break;

	case OPT_fsanitize_:
	case OPT_fsanitize_recover_:
	  /* -fsanitize= and -fsanitize-recover= can take
	     a comma-separated list of arguments.  Given that combinations
	     are supported, we can't add all potential candidates to the
	     vec, but if we at least add them individually without commas,
	     we should do a better job e.g. correcting
	       "-sanitize=address"
	     to
	       "-fsanitize=address"
	     rather than to "-Wframe-address" (PR driver/69265).  */
	  {
	    /* Add also variant without an option argument.  */
	    add_misspelling_candidates (m_option_suggestions, option,
					opt_text);

	    for (int j = 0; sanitizer_opts[j].name != NULL; ++j)
	      {
		struct cl_option optb;
		/* -fsanitize=all is not valid, only -fno-sanitize=all.
		   So don't register the positive misspelling candidates
		   for it.  */
		if (sanitizer_opts[j].flag == ~0U && i == OPT_fsanitize_)
		  {
		    optb = *option;
		    optb.opt_text = opt_text = "-fno-sanitize=";
		    optb.cl_reject_negative = true;
		    option = &optb;
		  }
		/* Get one arg at a time e.g. "-fsanitize=address".  */
		char *with_arg = concat (opt_text,
					 sanitizer_opts[j].name,
					 NULL);
		/* Add with_arg and all of its variant spellings e.g.
		   "-fno-sanitize=address" to candidates (albeit without
		   leading dashes).  */
		add_misspelling_candidates (m_option_suggestions, option,
					    with_arg);
		free (with_arg);
	      }
	  }
	  break;
	}
    }
}

/* Find parameter completions for --param format with SEPARATOR.
   Again, save the completions into results.  */

void
option_proposer::find_param_completions (const char separator,
					 const char *param_prefix,
					 auto_string_vec &results)
{
  char separator_str[] = {separator, '\0'};
  size_t length = strlen (param_prefix);
  for (unsigned i = 0; i < get_num_compiler_params (); ++i)
    {
      const char *candidate = compiler_params[i].option;
      if (strlen (candidate) >= length
	  && strstr (candidate, param_prefix) == candidate)
	results.safe_push (concat ("--param", separator_str, candidate, NULL));
    }
}

#if CHECKING_P

namespace selftest {

/* Verify that PROPOSER generates sane auto-completion suggestions
   for OPTION_PREFIX.  */

static void
verify_autocompletions (option_proposer &proposer, const char *option_prefix)
{
  auto_string_vec suggestions;
  proposer.get_completions (option_prefix, suggestions);

  /* There must be at least one suggestion, and every suggestion must
     indeed begin with OPTION_PREFIX.  */

  ASSERT_GT (suggestions.length (), 0);

  for (unsigned i = 0; i < suggestions.length (); i++)
    ASSERT_STR_STARTSWITH (suggestions[i], option_prefix);
}

/* Verify that valid options are auto-completed correctly.  */

static void
test_completion_valid_options (option_proposer &proposer)
{
  const char *option_prefixes[] =
  {
    "-fno-var-tracking-assignments-toggle",
    "-fpredictive-commoning",
    "--param=stack-clash-protection-guard-size",
    "--param=max-predicted-iterations",
    "-ftree-loop-distribute-patterns",
    "-fno-var-tracking",
    "-Walloc-zero",
    "--param=ipa-cp-value-list-size",
    "-Wsync-nand",
    "-Wno-attributes",
    "--param=tracer-dynamic-coverage-feedback",
    "-Wno-format-contains-nul",
    "-Wnamespaces",
    "-fisolate-erroneous-paths-attribute",
    "-Wno-underflow",
    "-Wtarget-lifetime",
    "--param=asan-globals",
    "-Wno-empty-body",
    "-Wno-odr",
    "-Wformat-zero-length",
    "-Wstringop-truncation",
    "-fno-ipa-vrp",
    "-fmath-errno",
    "-Warray-temporaries",
    "-Wno-unused-label",
    "-Wreturn-local-addr",
    "--param=sms-dfa-history",
    "--param=asan-instrument-reads",
    "-Wreturn-type",
    "-Wc++17-compat",
    "-Wno-effc++",
    "--param=max-fields-for-field-sensitive",
    "-fisolate-erroneous-paths-dereference",
    "-fno-defer-pop",
    "-Wcast-align=strict",
    "-foptimize-strlen",
    "-Wpacked-not-aligned",
    "-funroll-loops",
    "-fif-conversion2",
    "-Wdesignated-init",
    "--param=max-iterations-computation-cost",
    "-Wmultiple-inheritance",
    "-fno-sel-sched-reschedule-pipelined",
    "-Wassign-intercept",
    "-Wno-format-security",
    "-fno-sched-stalled-insns",
    "-fbtr-bb-exclusive",
    "-fno-tree-tail-merge",
    "-Wlong-long",
    "-Wno-unused-but-set-parameter",
    NULL
  };

  for (const char **ptr = option_prefixes; *ptr != NULL; ptr++)
    verify_autocompletions (proposer, *ptr);
}

/* Verify that valid parameters are auto-completed correctly,
   both with the "--param=PARAM" form and the "--param PARAM" form.  */

static void
test_completion_valid_params (option_proposer &proposer)
{
  const char *option_prefixes[] =
  {
    "--param=sched-state-edge-prob-cutoff",
    "--param=iv-consider-all-candidates-bound",
    "--param=align-threshold",
    "--param=prefetch-min-insn-to-mem-ratio",
    "--param=max-unrolled-insns",
    "--param=max-early-inliner-iterations",
    "--param=max-vartrack-reverse-op-size",
    "--param=ipa-cp-loop-hint-bonus",
    "--param=tracer-min-branch-ratio",
    "--param=graphite-max-arrays-per-scop",
    "--param=sink-frequency-threshold",
    "--param=max-cse-path-length",
    "--param=sra-max-scalarization-size-Osize",
    "--param=prefetch-latency",
    "--param=dse-max-object-size",
    "--param=asan-globals",
    "--param=max-vartrack-size",
    "--param=case-values-threshold",
    "--param=max-slsr-cand-scan",
    "--param=min-insn-to-prefetch-ratio",
    "--param=tracer-min-branch-probability",
    "--param sink-frequency-threshold",
    "--param max-cse-path-length",
    "--param sra-max-scalarization-size-Osize",
    "--param prefetch-latency",
    "--param dse-max-object-size",
    "--param asan-globals",
    "--param max-vartrack-size",
    NULL
  };

  for (const char **ptr = option_prefixes; *ptr != NULL; ptr++)
    verify_autocompletions (proposer, *ptr);
}

/* Return true when EXPECTED is one of completions for OPTION_PREFIX string.  */

static bool
in_completion_p (option_proposer &proposer, const char *option_prefix,
		 const char *expected)
{
  auto_string_vec suggestions;
  proposer.get_completions (option_prefix, suggestions);

  for (unsigned i = 0; i < suggestions.length (); i++)
    {
      char *r = suggestions[i];
      if (strcmp (r, expected) == 0)
	return true;
    }

  return false;
}

/* Return true when PROPOSER does not find any partial completion
   for OPTION_PREFIX.  */

static bool
empty_completion_p (option_proposer &proposer, const char *option_prefix)
{
  auto_string_vec suggestions;
  proposer.get_completions (option_prefix, suggestions);
  return suggestions.is_empty ();
}

/* Verify autocompletions of partially-complete options.  */

static void
test_completion_partial_match (option_proposer &proposer)
{
  ASSERT_TRUE (in_completion_p (proposer, "-fsani", "-fsanitize=address"));
  ASSERT_TRUE (in_completion_p (proposer, "-fsani",
				"-fsanitize-address-use-after-scope"));
  ASSERT_TRUE (in_completion_p (proposer, "-fipa-icf", "-fipa-icf-functions"));
  ASSERT_TRUE (in_completion_p (proposer, "-fipa-icf", "-fipa-icf"));
  ASSERT_TRUE (in_completion_p (proposer, "--param=",
				"--param=max-vartrack-reverse-op-size"));
  ASSERT_TRUE (in_completion_p (proposer, "--param ",
				"--param max-vartrack-reverse-op-size"));

  ASSERT_FALSE (in_completion_p (proposer, "-fipa-icf", "-fipa"));
  ASSERT_FALSE (in_completion_p (proposer, "-fipa-icf-functions", "-fipa-icf"));

  ASSERT_FALSE (empty_completion_p (proposer, "-"));
  ASSERT_FALSE (empty_completion_p (proposer, "-fipa"));
  ASSERT_FALSE (empty_completion_p (proposer, "--par"));
}

/* Verify that autocompletion does not return any match for garbage inputs.  */

static void
test_completion_garbage (option_proposer &proposer)
{
  ASSERT_TRUE (empty_completion_p (proposer, NULL));
  ASSERT_TRUE (empty_completion_p (proposer, ""));
  ASSERT_TRUE (empty_completion_p (proposer, "- "));
  ASSERT_TRUE (empty_completion_p (proposer, "123456789"));
  ASSERT_TRUE (empty_completion_p (proposer, "---------"));
  ASSERT_TRUE (empty_completion_p (proposer, "#########"));
  ASSERT_TRUE (empty_completion_p (proposer, "- - - - - -"));
  ASSERT_TRUE (empty_completion_p (proposer, "-fsanitize=address2"));
}

/* Run all of the selftests within this file.  */

void
opt_proposer_c_tests ()
{
  option_proposer proposer;

  test_completion_valid_options (proposer);
  test_completion_valid_params (proposer);
  test_completion_partial_match (proposer);
  test_completion_garbage (proposer);
}

} // namespace selftest

#endif /* #if CHECKING_P */
Commit	Line	Data
2abdff38	1	/* Provide option suggestion for --complete option and a misspelled
2abdff38	2	used by a user.
fbd26352	3	Copyright (C) 2016-2019 Free Software Foundation, Inc.
2abdff38	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"
b2903606	29	#include "common/common-target.h"
2abdff38	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)
b2903606	42	build_option_suggestions (NULL);
2abdff38	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
6e8a18d1	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)
b2903606	84	build_option_suggestions (option_prefix);
6e8a18d1	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
2abdff38	111	void
b2903606	112	option_proposer::build_option_suggestions (const char *prefix)
2abdff38	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	}
806ba310	137
	138	/* Add also variant without an option argument. */
	139	add_misspelling_candidates (m_option_suggestions, option,
	140	opt_text);
2abdff38	141	}
2abdff38	142	else
b2903606	143	{
037b9c2b	144	bool option_added = false;
b2903606	145	if (option->flags & CL_TARGET)
	146	{
	147	vec<const char *> option_values
	148	= targetm_common.get_valid_option_values (i, prefix);
	149	if (!option_values.is_empty ())
	150	{
037b9c2b	151	option_added = true;
b2903606	152	for (unsigned j = 0; j < option_values.length (); j++)
	153	{
	154	char *with_arg = concat (opt_text, option_values[j],
	155	NULL);
	156	add_misspelling_candidates (m_option_suggestions, option,
	157	with_arg);
	158	free (with_arg);
	159	}
	160	}
b363f27e	161	option_values.release ();
b2903606	162	}
037b9c2b	163
037b9c2b	164	if (!option_added)
b2903606	165	add_misspelling_candidates (m_option_suggestions, option,
	166	opt_text);
	167	}
2abdff38	168	break;
	169
	170	case OPT_fsanitize_:
	171	case OPT_fsanitize_recover_:
	172	/* -fsanitize= and -fsanitize-recover= can take
	173	a comma-separated list of arguments. Given that combinations
	174	are supported, we can't add all potential candidates to the
	175	vec, but if we at least add them individually without commas,
	176	we should do a better job e.g. correcting
	177	"-sanitize=address"
	178	to
	179	"-fsanitize=address"
	180	rather than to "-Wframe-address" (PR driver/69265). */
	181	{
806ba310	182	/* Add also variant without an option argument. */
	183	add_misspelling_candidates (m_option_suggestions, option,
	184	opt_text);
	185
2abdff38	186	for (int j = 0; sanitizer_opts[j].name != NULL; ++j)
	187	{
	188	struct cl_option optb;
	189	/* -fsanitize=all is not valid, only -fno-sanitize=all.
	190	So don't register the positive misspelling candidates
	191	for it. */
	192	if (sanitizer_opts[j].flag == ~0U && i == OPT_fsanitize_)
	193	{
	194	optb = *option;
	195	optb.opt_text = opt_text = "-fno-sanitize=";
	196	optb.cl_reject_negative = true;
	197	option = &optb;
	198	}
	199	/* Get one arg at a time e.g. "-fsanitize=address". */
	200	char *with_arg = concat (opt_text,
	201	sanitizer_opts[j].name,
	202	NULL);
	203	/* Add with_arg and all of its variant spellings e.g.
	204	"-fno-sanitize=address" to candidates (albeit without
	205	leading dashes). */
	206	add_misspelling_candidates (m_option_suggestions, option,
	207	with_arg);
	208	free (with_arg);
	209	}
	210	}
	211	break;
	212	}
	213	}
	214	}
6e8a18d1	215
	216	/* Find parameter completions for --param format with SEPARATOR.
	217	Again, save the completions into results. */
	218
	219	void
	220	option_proposer::find_param_completions (const char separator,
	221	const char *param_prefix,
	222	auto_string_vec &results)
	223	{
	224	char separator_str[] = {separator, '\0'};
	225	size_t length = strlen (param_prefix);
	226	for (unsigned i = 0; i < get_num_compiler_params (); ++i)
	227	{
	228	const char *candidate = compiler_params[i].option;
	229	if (strlen (candidate) >= length
	230	&& strstr (candidate, param_prefix) == candidate)
	231	results.safe_push (concat ("--param", separator_str, candidate, NULL));
	232	}
	233	}
	234
	235	#if CHECKING_P
	236
	237	namespace selftest {
	238
	239	/* Verify that PROPOSER generates sane auto-completion suggestions
	240	for OPTION_PREFIX. */
	241
	242	static void
	243	verify_autocompletions (option_proposer &proposer, const char *option_prefix)
	244	{
	245	auto_string_vec suggestions;
	246	proposer.get_completions (option_prefix, suggestions);
	247
	248	/* There must be at least one suggestion, and every suggestion must
	249	indeed begin with OPTION_PREFIX. */
	250
	251	ASSERT_GT (suggestions.length (), 0);
	252
	253	for (unsigned i = 0; i < suggestions.length (); i++)
	254	ASSERT_STR_STARTSWITH (suggestions[i], option_prefix);
	255	}
	256
	257	/* Verify that valid options are auto-completed correctly. */
	258
	259	static void
	260	test_completion_valid_options (option_proposer &proposer)
	261	{
	262	const char *option_prefixes[] =
	263	{
	264	"-fno-var-tracking-assignments-toggle",
	265	"-fpredictive-commoning",
	266	"--param=stack-clash-protection-guard-size",
	267	"--param=max-predicted-iterations",
	268	"-ftree-loop-distribute-patterns",
	269	"-fno-var-tracking",
	270	"-Walloc-zero",
	271	"--param=ipa-cp-value-list-size",
	272	"-Wsync-nand",
	273	"-Wno-attributes",
	274	"--param=tracer-dynamic-coverage-feedback",
	275	"-Wno-format-contains-nul",
	276	"-Wnamespaces",
	277	"-fisolate-erroneous-paths-attribute",
	278	"-Wno-underflow",
279	"-Wtarget-lifetime",
280	"--param=asan-globals",
281	"-Wno-empty-body",
282	"-Wno-odr",
283	"-Wformat-zero-length",
284	"-Wstringop-truncation",
285	"-fno-ipa-vrp",
286	"-fmath-errno",
287	"-Warray-temporaries",
288	"-Wno-unused-label",
289	"-Wreturn-local-addr",
290	"--param=sms-dfa-history",
291	"--param=asan-instrument-reads",
292	"-Wreturn-type",
293	"-Wc++17-compat",
294	"-Wno-effc++",
295	"--param=max-fields-for-field-sensitive",
296	"-fisolate-erroneous-paths-dereference",
297	"-fno-defer-pop",
298	"-Wcast-align=strict",
299	"-foptimize-strlen",
300	"-Wpacked-not-aligned",
301	"-funroll-loops",
302	"-fif-conversion2",
303	"-Wdesignated-init",
304	"--param=max-iterations-computation-cost",
305	"-Wmultiple-inheritance",
306	"-fno-sel-sched-reschedule-pipelined",
307	"-Wassign-intercept",
308	"-Wno-format-security",
309	"-fno-sched-stalled-insns",
310	"-fbtr-bb-exclusive",
311	"-fno-tree-tail-merge",
312	"-Wlong-long",
313	"-Wno-unused-but-set-parameter",
314	NULL
315	};
316
317	for (const char *ptr = option_prefixes; ptr != NULL; ptr++)
318	verify_autocompletions (proposer, *ptr);
319	}
320
321	/* Verify that valid parameters are auto-completed correctly,
322	both with the "--param=PARAM" form and the "--param PARAM" form. */
323
324	static void
325	test_completion_valid_params (option_proposer &proposer)
326	{
327	const char *option_prefixes[] =
328	{
329	"--param=sched-state-edge-prob-cutoff",
330	"--param=iv-consider-all-candidates-bound",
331	"--param=align-threshold",
332	"--param=prefetch-min-insn-to-mem-ratio",
333	"--param=max-unrolled-insns",
334	"--param=max-early-inliner-iterations",
335	"--param=max-vartrack-reverse-op-size",
336	"--param=ipa-cp-loop-hint-bonus",
337	"--param=tracer-min-branch-ratio",
338	"--param=graphite-max-arrays-per-scop",
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	"--param=case-values-threshold",
347	"--param=max-slsr-cand-scan",
348	"--param=min-insn-to-prefetch-ratio",
349	"--param=tracer-min-branch-probability",
350	"--param sink-frequency-threshold",
351	"--param max-cse-path-length",
352	"--param sra-max-scalarization-size-Osize",
353	"--param prefetch-latency",
354	"--param dse-max-object-size",
355	"--param asan-globals",
356	"--param max-vartrack-size",
357	NULL
358	};
359
360	for (const char *ptr = option_prefixes; ptr != NULL; ptr++)
361	verify_autocompletions (proposer, *ptr);
362	}
363
364	/* Return true when EXPECTED is one of completions for OPTION_PREFIX string. */
365
366	static bool
367	in_completion_p (option_proposer &proposer, const char *option_prefix,
368	const char *expected)
369	{
370	auto_string_vec suggestions;
371	proposer.get_completions (option_prefix, suggestions);
372
373	for (unsigned i = 0; i < suggestions.length (); i++)
374	{
375	char *r = suggestions[i];
376	if (strcmp (r, expected) == 0)
377	return true;
378	}
379
380	return false;
381	}
382
383	/* Return true when PROPOSER does not find any partial completion
384	for OPTION_PREFIX. */
385
386	static bool
387	empty_completion_p (option_proposer &proposer, const char *option_prefix)
388	{
389	auto_string_vec suggestions;
390	proposer.get_completions (option_prefix, suggestions);
391	return suggestions.is_empty ();
392	}
393
394	/* Verify autocompletions of partially-complete options. */
395
396	static void
397	test_completion_partial_match (option_proposer &proposer)
398	{
399	ASSERT_TRUE (in_completion_p (proposer, "-fsani", "-fsanitize=address"));
400	ASSERT_TRUE (in_completion_p (proposer, "-fsani",
401	"-fsanitize-address-use-after-scope"));
402	ASSERT_TRUE (in_completion_p (proposer, "-fipa-icf", "-fipa-icf-functions"));
403	ASSERT_TRUE (in_completion_p (proposer, "-fipa-icf", "-fipa-icf"));
404	ASSERT_TRUE (in_completion_p (proposer, "--param=",
405	"--param=max-vartrack-reverse-op-size"));
406	ASSERT_TRUE (in_completion_p (proposer, "--param ",
407	"--param max-vartrack-reverse-op-size"));
408
409	ASSERT_FALSE (in_completion_p (proposer, "-fipa-icf", "-fipa"));
410	ASSERT_FALSE (in_completion_p (proposer, "-fipa-icf-functions", "-fipa-icf"));
411
412	ASSERT_FALSE (empty_completion_p (proposer, "-"));
413	ASSERT_FALSE (empty_completion_p (proposer, "-fipa"));
414	ASSERT_FALSE (empty_completion_p (proposer, "--par"));
415	}
416
417	/* Verify that autocompletion does not return any match for garbage inputs. */
418
419	static void
420	test_completion_garbage (option_proposer &proposer)
421	{
422	ASSERT_TRUE (empty_completion_p (proposer, NULL));
423	ASSERT_TRUE (empty_completion_p (proposer, ""));
424	ASSERT_TRUE (empty_completion_p (proposer, "- "));
425	ASSERT_TRUE (empty_completion_p (proposer, "123456789"));
426	ASSERT_TRUE (empty_completion_p (proposer, "---------"));
427	ASSERT_TRUE (empty_completion_p (proposer, "#########"));
428	ASSERT_TRUE (empty_completion_p (proposer, "- - - - - -"));
429	ASSERT_TRUE (empty_completion_p (proposer, "-fsanitize=address2"));
430	}
431
432	/* Run all of the selftests within this file. */
433
434	void
435	opt_proposer_c_tests ()
436	{
437	option_proposer proposer;
438
439	test_completion_valid_options (proposer);
440	test_completion_valid_params (proposer);
441	test_completion_partial_match (proposer);
442	test_completion_garbage (proposer);
443	}
444
445	} // namespace selftest
446
447	#endif /* #if CHECKING_P */