From patchwork Mon May 14 12:51:49 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?q?Martin_Li=C5=A1ka?= X-Patchwork-Id: 912912 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (mailfrom) smtp.mailfrom=gcc.gnu.org (client-ip=209.132.180.131; helo=sourceware.org; envelope-from=gcc-patches-return-477634-incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=suse.cz Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.b="pX+xn/eV"; dkim-atps=neutral Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 40l0vm1YpWz9rxs for ; Mon, 14 May 2018 22:52:03 +1000 (AEST) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender :subject:from:to:references:message-id:date:mime-version :in-reply-to:content-type; q=dns; s=default; b=NUezrC9v+G00u5sCp bHYIRQ8v6WRGZuSZr4HKIdc7JV41O+8smzhceGoZ16VQq5MmkfL85gmPCb+QbZ+b nHAvzcOJDi7luitRKb0SNLvjKWiTazjXzOitWFw05/W21T9D09QjgnGbEaM8hlMl SM7OPK/KhhjWW3O+7RiaaX8K5I= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender :subject:from:to:references:message-id:date:mime-version :in-reply-to:content-type; s=default; bh=ZRa9S6FBAyhSWr6fgpHG90R hBlw=; b=pX+xn/eV0wZ8LGsWhyXocSztbI3ngXbrCVrFgtOdLUDLRjckTIihd+u 0J86CszLPrmMsyiEuT0841o7PEYwmWioiPCGvRFOzgUwtqsF84JuSwFBrxlWm5XM NYiv71Cvr64BQV1qtjNQheOBVHj3XL3thzQCj4uOf03NPFMOFDd4= Received: (qmail 82146 invoked by alias); 14 May 2018 12:51:55 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 82131 invoked by uid 89); 14 May 2018 12:51:55 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-26.9 required=5.0 tests=BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, SPF_PASS autolearn=ham version=3.3.2 spammy= X-HELO: mx2.suse.de Received: from mx2.suse.de (HELO mx2.suse.de) (195.135.220.15) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Mon, 14 May 2018 12:51:52 +0000 Received: from relay1.suse.de (charybdis-ext.suse.de [195.135.220.254]) by mx2.suse.de (Postfix) with ESMTP id 082B7AD0E; Mon, 14 May 2018 12:51:50 +0000 (UTC) Subject: [PATCH 3/3] Come up with new --completion option. From: =?utf-8?q?Martin_Li=C5=A1ka?= To: David Malcolm , "gcc-patches@gcc.gnu.org" References: <3c2e7f32-438a-57a3-96a8-3e9d3fc7f605@suse.cz> <1524587261.5688.193.camel@redhat.com> <1524698011.2961.15.camel@redhat.com> <90a24d87-2fc2-1818-f2ff-eb03e4d099af@suse.cz> Message-ID: Date: Mon, 14 May 2018 14:51:49 +0200 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Thunderbird/52.7.0 MIME-Version: 1.0 In-Reply-To: <90a24d87-2fc2-1818-f2ff-eb03e4d099af@suse.cz> X-IsSubscribed: yes Main part where I still need to write ChangeLog file and gcc.sh needs to be moved to bash-completions project. Martin From cb544b3136559eb3710790dcd582d7bbf36d3792 Mon Sep 17 00:00:00 2001 From: marxin Date: Mon, 14 May 2018 11:49:52 +0200 Subject: [PATCH 3/3] Come up with new --completion option. --- gcc.sh | 51 +++++++++ gcc/common.opt | 4 + gcc/gcc.c | 15 +++ gcc/opt-suggestions.c | 290 +++++++++++++++++++++++++++++++++++++++++++++-- gcc/opt-suggestions.h | 15 ++- gcc/opts.c | 3 + gcc/selftest-run-tests.c | 1 + gcc/selftest.c | 33 ++++++ gcc/selftest.h | 21 ++++ 9 files changed, 418 insertions(+), 15 deletions(-) create mode 100644 gcc.sh diff --git a/gcc.sh b/gcc.sh new file mode 100644 index 00000000000..06b16b3152b --- /dev/null +++ b/gcc.sh @@ -0,0 +1,51 @@ +# Please add "source /path/to/bash-autocomplete.sh" to your .bashrc to use this. + +log() +{ + echo $1 >> /tmp/bash-completion.log +} + +_gcc() +{ + local cur prev prev2 words cword argument prefix + _init_completion || return + _expand || return + + # extract also for situations like: -fsanitize=add + if [[ $cword > 2 ]]; then + prev2="${COMP_WORDS[$cword - 2]}" + fi + + log "cur: '$cur', prev: '$prev': prev2: '$prev2' cword: '$cword'" + + # sample: -fsan + if [[ "$cur" == -* ]]; then + argument=$cur + # sample: -fsanitize= + elif [[ "$cur" == "=" && $prev == -* ]]; then + argument=$prev$cur + prefix=$prev$cur + # sample: -fsanitize=add + elif [[ "$prev" == "=" && $prev2 == -* ]]; then + argument=$prev2$prev$cur + prefix=$prev2$prev + # sample: --param lto- + elif [[ "$prev" == "--param" ]]; then + argument="$prev $cur" + prefix="$prev " + fi + + log "argument: '$argument', prefix: '$prefix'" + + if [[ "$argument" == "" ]]; then + _filedir + else + # In situation like '-fsanitize=add' $cur is equal to last token. + # Thus we need to strip the beginning of suggested option. + flags=$( gcc --completion="$argument" 2>/dev/null | sed "s/^$prefix//") + log "compgen: $flags" + [[ "${flags: -1}" == '=' ]] && compopt -o nospace 2> /dev/null + COMPREPLY=( $( compgen -W "$flags" -- "") ) + fi +} +complete -F _gcc gcc diff --git a/gcc/common.opt b/gcc/common.opt index d6ef85928f3..c57edfb9c94 100644 --- a/gcc/common.opt +++ b/gcc/common.opt @@ -254,6 +254,10 @@ Driver Alias(S) -compile Driver Alias(c) +-completion= +Common Driver Joined Undocumented +Provide bash completion for options starting with provided string. + -coverage Driver Alias(coverage) diff --git a/gcc/gcc.c b/gcc/gcc.c index 08e76c92df4..c02c2d73b12 100644 --- a/gcc/gcc.c +++ b/gcc/gcc.c @@ -221,6 +221,10 @@ static int print_help_list; static int print_version; +/* Flag that stores string value for which we provide bash completion. */ + +static const char *completion = NULL; + /* Flag indicating whether we should ONLY print the command and arguments (like verbose_flag) without executing the command. Displayed arguments are quoted so that the generated command @@ -3819,6 +3823,11 @@ driver_handle_option (struct gcc_options *opts, add_linker_option ("--version", strlen ("--version")); break; + case OPT__completion_: + validated = true; + completion = decoded->arg; + break; + case OPT__help: print_help_list = 1; @@ -7292,6 +7301,12 @@ driver::main (int argc, char **argv) maybe_putenv_OFFLOAD_TARGETS (); handle_unrecognized_options (); + if (completion) + { + m_option_proposer.suggest_completion (completion); + return 0; + } + if (!maybe_print_and_exit ()) return 0; diff --git a/gcc/opt-suggestions.c b/gcc/opt-suggestions.c index e322fcd91c5..2da094a5960 100644 --- a/gcc/opt-suggestions.c +++ b/gcc/opt-suggestions.c @@ -28,18 +28,6 @@ along with GCC; see the file COPYING3. If not see #include "opt-suggestions.h" #include "selftest.h" -option_proposer::~option_proposer () -{ - if (m_option_suggestions) - { - int i; - char *str; - FOR_EACH_VEC_ELT (*m_option_suggestions, i, str) - free (str); - delete m_option_suggestions; - } -} - const char * option_proposer::suggest_option (const char *bad_opt) { @@ -54,6 +42,58 @@ option_proposer::suggest_option (const char *bad_opt) (auto_vec *) m_option_suggestions); } +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 parameters. */ + 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 (); + 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)); + } + } +} + +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 (void) { @@ -127,3 +167,229 @@ option_proposer::build_option_suggestions (void) } } } + +void +option_proposer::find_param_completions (const char separator, + const char *option_prefix, + auto_string_vec &results) +{ + char separator_str[] {separator, '\0'}; + size_t length = strlen (option_prefix); + for (unsigned i = 0; i < get_num_compiler_params (); ++i) + { + const char *candidate = compiler_params[i].option; + if (strlen (candidate) >= length + && strstr (candidate, option_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); + 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 */ diff --git a/gcc/opt-suggestions.h b/gcc/opt-suggestions.h index 5e3ee9e2671..d0c32af7e5c 100644 --- a/gcc/opt-suggestions.h +++ b/gcc/opt-suggestions.h @@ -33,9 +33,6 @@ public: option_proposer (): m_option_suggestions (NULL) {} - /* Default destructor. */ - ~option_proposer (); - /* Helper function for driver::handle_unrecognized_options. Given an unrecognized option BAD_OPT (without the leading dash), @@ -45,12 +42,24 @@ public: The returned string is owned by the option_proposer instance. */ const char *suggest_option (const char *bad_opt); + /* Print to stdout all options that start with OPTION_PREFIX. */ + void suggest_completion (const char *option_prefix); + + /* Build completions that start with OPTION_PREFIX and save them + into RESULTS vector. */ + void get_completions (const char *option_prefix, auto_string_vec &results); + private: /* Helper function for option_proposer::suggest_option. Populate m_option_suggestions with candidate strings for misspelled options. The strings will be freed by the option_proposer's dtor. */ void build_option_suggestions (); + /* Find parameter completions for --param format with SEPARATOR. + Again, save the completions into results. */ + void find_param_completions (const char separator, const char *option_prefix, + auto_string_vec &results); + private: /* Cache with all suggestions. */ auto_vec *m_option_suggestions; diff --git a/gcc/opts.c b/gcc/opts.c index 33efcc0d6e7..ed102c05c22 100644 --- a/gcc/opts.c +++ b/gcc/opts.c @@ -1982,6 +1982,9 @@ common_handle_option (struct gcc_options *opts, opts->x_exit_after_options = true; break; + case OPT__completion_: + break; + case OPT_fsanitize_: opts->x_flag_sanitize = parse_sanitizer_options (arg, loc, code, diff --git a/gcc/selftest-run-tests.c b/gcc/selftest-run-tests.c index fe221ff8946..0b45c479192 100644 --- a/gcc/selftest-run-tests.c +++ b/gcc/selftest-run-tests.c @@ -70,6 +70,7 @@ selftest::run_tests () fibonacci_heap_c_tests (); typed_splay_tree_c_tests (); unique_ptr_tests_cc_tests (); + opt_proposer_c_tests (); /* Mid-level data structures. */ input_c_tests (); diff --git a/gcc/selftest.c b/gcc/selftest.c index 74adc63e65c..78ae778ca14 100644 --- a/gcc/selftest.c +++ b/gcc/selftest.c @@ -125,6 +125,39 @@ assert_str_contains (const location &loc, desc_haystack, desc_needle, val_haystack, val_needle); } +/* Implementation detail of ASSERT_STR_STARTSWITH. + Use strstr to determine if val_haystack starts with val_needle. + ::selftest::pass if it starts. + ::selftest::fail if it does not start. */ + +void +assert_str_startswith (const location &loc, + const char *desc_str, + const char *desc_prefix, + const char *val_str, + const char *val_prefix) +{ + /* If val_str is NULL, fail with a custom error message. */ + if (val_str == NULL) + fail_formatted (loc, "ASSERT_STR_STARTSWITH (%s, %s) str=NULL", + desc_str, desc_prefix); + + /* If val_prefix is NULL, fail with a custom error message. */ + if (val_prefix == NULL) + fail_formatted (loc, + "ASSERT_STR_STARTSWITH (%s, %s) str=\"%s\" prefix=NULL", + desc_str, desc_prefix, val_str); + + const char *test = strstr (val_str, val_prefix); + if (test == val_str) + pass (loc, "ASSERT_STR_STARTSWITH"); + else + fail_formatted + (loc, "ASSERT_STR_STARTSWITH (%s, %s) str=\"%s\" prefix=\"%s\"", + desc_str, desc_prefix, val_str, val_prefix); +} + + /* Constructor. Generate a name for the file. */ named_temp_file::named_temp_file (const char *suffix) diff --git a/gcc/selftest.h b/gcc/selftest.h index fc47b2c9ad1..c68205d3e62 100644 --- a/gcc/selftest.h +++ b/gcc/selftest.h @@ -78,6 +78,15 @@ extern void assert_str_contains (const location &loc, const char *val_haystack, const char *val_needle); +/* Implementation detail of ASSERT_STR_STARTSWITH. */ + +extern void assert_str_startswith (const location &loc, + const char *desc_str, + const char *desc_prefix, + const char *val_str, + const char *val_prefix); + + /* A named temporary file for use in selftests. Usable for writing out files, and as the base class for temp_source_file. @@ -216,6 +225,7 @@ extern void unique_ptr_tests_cc_tests (); extern void vec_c_tests (); extern void vec_perm_indices_c_tests (); extern void wide_int_cc_tests (); +extern void opt_proposer_c_tests (); extern int num_passes; @@ -401,6 +411,17 @@ extern int num_passes; (HAYSTACK), (NEEDLE)); \ SELFTEST_END_STMT +/* Evaluate STRING and PREFIX and use strstr to determine if STRING + starts with PREFIX. + ::selftest::pass if starts. + ::selftest::fail if does not start. */ + +#define ASSERT_STR_STARTSWITH(STR, PREFIX) \ + SELFTEST_BEGIN_STMT \ + ::selftest::assert_str_startswith (SELFTEST_LOCATION, #STR, #PREFIX, \ + (STR), (PREFIX)); \ + SELFTEST_END_STMT + /* Evaluate PRED1 (VAL1), calling ::selftest::pass if it is true, ::selftest::fail if it is false. */ -- 2.16.3