+2018-08-15 David Malcolm <dmalcolm@redhat.com>
+
+ * common.opt (fdiagnostics-show-labels): New option.
+ * diagnostic-show-locus.c (class layout_range): Add field
+ "m_label".
+ (class layout): Add field "m_show_labels_p".
+ (layout_range::layout_range): Add param "label" and use it to
+ initialize m_label.
+ (make_range): Pass in NULL for new "label" param of layout_range's
+ ctor.
+ (layout::layout): Initialize m_show_labels_p.
+ (layout::maybe_add_location_range): Pass in loc_range->m_label
+ when constructing layout_range instances.
+ (struct line_label): New struct.
+ (layout::print_any_labels): New member function.
+ (layout::print_line): Call it if label-printing is enabled.
+ (selftest::test_one_liner_labels): New test.
+ (selftest::test_diagnostic_show_locus_one_liner): Call it.
+ * diagnostic.c (diagnostic_initialize): Initialize
+ context->show_labels_p.
+ * diagnostic.h (struct diagnostic_context): Add field
+ "show_labels_p".
+ * doc/invoke.texi (Diagnostic Message Formatting Options): Add
+ -fno-diagnostics-show-labels.
+ * dwarf2out.c (gen_producer_string): Add
+ OPT_fdiagnostics_show_labels to the ignored options.
+ * gcc-rich-location.c (gcc_rich_location::add_expr): Add "label"
+ param.
+ (gcc_rich_location::maybe_add_expr): Likewise.
+ * gcc-rich-location.h (gcc_rich_location::gcc_rich_location): Add
+ label" param, defaulting to NULL.
+ (gcc_rich_location::add_expr): Add "label" param.
+ (gcc_rich_location::maybe_add_expr): Likewise.
+ (class text_range_label): New class.
+ (class range_label_for_type_mismatch): New class.
+ * gimple-ssa-sprintf.c (fmtwarn): Pass NULL for new label params
+ of format_warning_va.
+ (fmtwarn_n): Likewise for new params of format_warning_n_va.
+ * lto-wrapper.c (merge_and_complain): Add
+ OPT_fdiagnostics_show_labels to the "pick one setting" options.
+ (append_compiler_options): Likewise to the dropped options.
+ (append_diag_options): Likewise to the passed-on options.
+ * opts.c (common_handle_option): Handle the new option.
+ * selftest-diagnostic.c
+ (test_diagnostic_context::test_diagnostic_context): Enable
+ show_labels_p.
+ * substring-locations.c: Include "gcc-rich-location.h".
+ (format_warning_n_va): Add "fmt_label" and "param_label" params
+ and use them as appropriate.
+ (format_warning_va): Add "fmt_label" and "param_label" params,
+ passing them on to format_warning_n_va.
+ (format_warning_at_substring): Likewise.
+ (format_warning_at_substring_n): Likewise.
+ * substring-locations.h (format_warning_va): Add "fmt_label" and
+ "param_label" params.
+ (format_warning_n_va): Likewise.
+ (format_warning_at_substring): Likewise.
+ (format_warning_at_substring_n): Likewise.
+ * toplev.c (general_init): Initialize global_dc->show_labels_p.
+
2018-08-15 Qing Zhao <qing.zhao@oracle.com>
PR testsuite/86519
+2018-08-15 David Malcolm <dmalcolm@redhat.com>
+
+ * c-format.c: Include "selftest-diagnostic.h" and
+ "gcc-rich-location.h".
+ (format_warning_at_char): Pass NULL for new label params of
+ format_warning_va.
+ (class indirection_suffix): New class.
+ (class range_label_for_format_type_mismatch): New class.
+ (format_type_warning): Move logic for generating "*" suffix to
+ class indirection_suffix. Create "fmt_label" and "param_label"
+ to show their types, and pass them to the
+ format_warning_at_substring calls.
+ (selftest::test_type_mismatch_range_labels): New test.
+ (selftest::c_format_c_tests): Call it.
+
2018-08-13 Martin Sebor <msebor@redhat.com>
PR tree-optimization/71625
#include "diagnostic.h"
#include "substring-locations.h"
#include "selftest.h"
+#include "selftest-diagnostic.h"
#include "builtins.h"
#include "attribs.h"
+#include "gcc-rich-location.h"
/* Handle attributes associated with format checking. */
substring_loc fmt_loc (fmt_string_loc, string_type, char_idx, char_idx,
char_idx);
- bool warned = format_warning_va (fmt_loc, UNKNOWN_LOCATION, NULL, opt,
- gmsgid, &ap);
+ bool warned = format_warning_va (fmt_loc, NULL, UNKNOWN_LOCATION, NULL,
+ NULL, opt, gmsgid, &ap);
va_end (ap);
return warned;
return result;
}
+/* Helper class for adding zero or more trailing '*' to types.
+
+ The format type and name exclude any '*' for pointers, so those
+ must be formatted manually. For all the types we currently have,
+ this is adequate, but formats taking pointers to functions or
+ arrays would require the full type to be built up in order to
+ print it with %T. */
+
+class indirection_suffix
+{
+ public:
+ indirection_suffix (int pointer_count) : m_pointer_count (pointer_count) {}
+
+ /* Determine the size of the buffer (including NUL-terminator). */
+
+ size_t get_buffer_size () const
+ {
+ return m_pointer_count + 2;
+ }
+
+ /* Write the '*' to DST and add a NUL-terminator. */
+
+ void fill_buffer (char *dst) const
+ {
+ if (m_pointer_count == 0)
+ dst[0] = 0;
+ else if (c_dialect_cxx ())
+ {
+ memset (dst, '*', m_pointer_count);
+ dst[m_pointer_count] = 0;
+ }
+ else
+ {
+ dst[0] = ' ';
+ memset (dst + 1, '*', m_pointer_count);
+ dst[m_pointer_count + 1] = 0;
+ }
+ }
+
+ private:
+ int m_pointer_count;
+};
+
+/* Subclass of range_label for labelling the range in the format string
+ with the type in question, adding trailing '*' for pointer_count. */
+
+class range_label_for_format_type_mismatch
+ : public range_label_for_type_mismatch
+{
+ public:
+ range_label_for_format_type_mismatch (tree labelled_type, tree other_type,
+ int pointer_count)
+ : range_label_for_type_mismatch (labelled_type, other_type),
+ m_pointer_count (pointer_count)
+ {
+ }
+
+ label_text get_text () const FINAL OVERRIDE
+ {
+ label_text text = range_label_for_type_mismatch::get_text ();
+ if (text.m_buffer == NULL)
+ return text;
+
+ indirection_suffix suffix (m_pointer_count);
+ char *p = (char *) alloca (suffix.get_buffer_size ());
+ suffix.fill_buffer (p);
+
+ char *result = concat (text.m_buffer, p, NULL);
+ text.maybe_free ();
+ return label_text (result, true);
+ }
+
+ private:
+ int m_pointer_count;
+};
+
/* Give a warning about a format argument of different type from that expected.
The range of the diagnostic is taken from WHOLE_FMT_LOC; the caret location
is based on the location of the char at TYPE->offset_loc.
int pointer_count = type->pointer_count;
int arg_num = type->arg_num;
- char *p;
/* If ARG_TYPE is a typedef with a misleading name (for example,
size_t but not the standard size_t expected by printf %zu), avoid
printing the typedef name. */
&& !strcmp (wanted_type_name,
lang_hooks.decl_printable_name (TYPE_NAME (arg_type), 2)))
arg_type = TYPE_MAIN_VARIANT (arg_type);
- /* The format type and name exclude any '*' for pointers, so those
- must be formatted manually. For all the types we currently have,
- this is adequate, but formats taking pointers to functions or
- arrays would require the full type to be built up in order to
- print it with %T. */
- p = (char *) alloca (pointer_count + 2);
- if (pointer_count == 0)
- p[0] = 0;
- else if (c_dialect_cxx ())
- {
- memset (p, '*', pointer_count);
- p[pointer_count] = 0;
- }
- else
- {
- p[0] = ' ';
- memset (p + 1, '*', pointer_count);
- p[pointer_count + 1] = 0;
- }
+
+ indirection_suffix suffix (pointer_count);
+ char *p = (char *) alloca (suffix.get_buffer_size ());
+ suffix.fill_buffer (p);
/* WHOLE_FMT_LOC has the caret at the end of the range.
Set the caret to be at the offset from TYPE. Subtract one
substring_loc fmt_loc (whole_fmt_loc);
fmt_loc.set_caret_index (type->offset_loc - 1);
+ range_label_for_format_type_mismatch fmt_label (wanted_type, arg_type,
+ pointer_count);
+ range_label_for_type_mismatch param_label (arg_type, wanted_type);
+
/* Get a string for use as a replacement fix-it hint for the range in
fmt_loc, or NULL. */
char *corrected_substring
{
if (arg_type)
format_warning_at_substring
- (fmt_loc, param_loc,
+ (fmt_loc, &fmt_label, param_loc, ¶m_label,
corrected_substring, OPT_Wformat_,
"%s %<%s%.*s%> expects argument of type %<%s%s%>, "
"but argument %d has type %qT",
wanted_type_name, p, arg_num, arg_type);
else
format_warning_at_substring
- (fmt_loc, param_loc,
+ (fmt_loc, &fmt_label, param_loc, ¶m_label,
corrected_substring, OPT_Wformat_,
"%s %<%s%.*s%> expects a matching %<%s%s%> argument",
gettext (kind_descriptions[kind]),
{
if (arg_type)
format_warning_at_substring
- (fmt_loc, param_loc,
+ (fmt_loc, &fmt_label, param_loc, ¶m_label,
corrected_substring, OPT_Wformat_,
"%s %<%s%.*s%> expects argument of type %<%T%s%>, "
"but argument %d has type %qT",
wanted_type, p, arg_num, arg_type);
else
format_warning_at_substring
- (fmt_loc, param_loc,
+ (fmt_loc, &fmt_label, param_loc, ¶m_label,
corrected_substring, OPT_Wformat_,
"%s %<%s%.*s%> expects a matching %<%T%s%> argument",
gettext (kind_descriptions[kind]),
#undef ASSERT_FORMAT_FOR_TYPE_STREQ
+/* Exercise the type-printing label code, to give some coverage
+ under "make selftest-valgrind" (in particular, to ensure that
+ the label-printing machinery doesn't leak). */
+
+static void
+test_type_mismatch_range_labels ()
+{
+ /* Create a tempfile and write some text to it.
+ ....................0000000001 11111111 12 22222222
+ ....................1234567890 12345678 90 12345678. */
+ const char *content = " printf (\"msg: %i\\n\", msg);\n";
+ temp_source_file tmp (SELFTEST_LOCATION, ".c", content);
+ line_table_test ltt;
+
+ linemap_add (line_table, LC_ENTER, false, tmp.get_filename (), 1);
+
+ location_t c17 = linemap_position_for_column (line_table, 17);
+ ASSERT_EQ (LOCATION_COLUMN (c17), 17);
+ location_t c18 = linemap_position_for_column (line_table, 18);
+ location_t c24 = linemap_position_for_column (line_table, 24);
+ location_t c26 = linemap_position_for_column (line_table, 26);
+
+ /* Don't attempt to run the tests if column data might be unavailable. */
+ if (c26 > LINE_MAP_MAX_LOCATION_WITH_COLS)
+ return;
+
+ location_t fmt = make_location (c18, c17, c18);
+ ASSERT_EQ (LOCATION_COLUMN (fmt), 18);
+
+ location_t param = make_location (c24, c24, c26);
+ ASSERT_EQ (LOCATION_COLUMN (param), 24);
+
+ range_label_for_format_type_mismatch fmt_label (char_type_node,
+ integer_type_node, 1);
+ range_label_for_type_mismatch param_label (integer_type_node,
+ char_type_node);
+ gcc_rich_location richloc (fmt, &fmt_label);
+ richloc.add_range (param, false, ¶m_label);
+
+ test_diagnostic_context dc;
+ diagnostic_show_locus (&dc, &richloc, DK_ERROR);
+ if (c_dialect_cxx ())
+ /* "char*", without a space. */
+ ASSERT_STREQ ("\n"
+ " printf (\"msg: %i\\n\", msg);\n"
+ " ~^ ~~~\n"
+ " | |\n"
+ " char* int\n",
+ pp_formatted_text (dc.printer));
+ else
+ /* "char *", with a space. */
+ ASSERT_STREQ ("\n"
+ " printf (\"msg: %i\\n\", msg);\n"
+ " ~^ ~~~\n"
+ " | |\n"
+ " | int\n"
+ " char *\n",
+ pp_formatted_text (dc.printer));
+}
+
/* Run all of the selftests within this file. */
void
test_get_modifier_for_format_len ();
test_get_format_for_type_printf ();
test_get_format_for_type_scanf ();
+ test_type_mismatch_range_labels ();
}
} // namespace selftest
+2018-08-15 David Malcolm <dmalcolm@redhat.com>
+
+ * c-objc-common.c: Include "gcc-rich-location.h".
+ (c_tree_printer): Move implemenation of '%T' to...
+ (print_type): ...this new function.
+ (range_label_for_type_mismatch::get_text): New function.
+ * c-typeck.c (convert_for_assignment): Add type labels to the rhs
+ range for the various ic_argpass cases.
+ (class maybe_range_label_for_tree_type_mismatch): New class.
+ (build_binary_op): Use it when calling binary_op_error.
+
2018-08-15 Prathamesh Kulkarni <prathamesh.kulkarni@linaro.org>
* c-decl.c (start_decl): Do not warn if variables is named as main
#include "gimple-pretty-print.h"
#include "langhooks.h"
#include "c-objc-common.h"
+#include "gcc-rich-location.h"
static bool c_tree_printer (pretty_printer *, text_info *, const char *,
int, bool, bool, bool, bool *, const char **);
return c_common_init ();
}
+/* Print T to CPP. */
+
+static void
+print_type (c_pretty_printer *cpp, tree t, bool *quoted)
+{
+ gcc_assert (TYPE_P (t));
+ struct obstack *ob = pp_buffer (cpp)->obstack;
+ char *p = (char *) obstack_base (ob);
+ /* Remember the end of the initial dump. */
+ int len = obstack_object_size (ob);
+
+ tree name = TYPE_NAME (t);
+ if (name && TREE_CODE (name) == TYPE_DECL && DECL_NAME (name))
+ pp_identifier (cpp, lang_hooks.decl_printable_name (name, 2));
+ else
+ cpp->type_id (t);
+
+ /* If we're printing a type that involves typedefs, also print the
+ stripped version. But sometimes the stripped version looks
+ exactly the same, so we don't want it after all. To avoid
+ printing it in that case, we play ugly obstack games. */
+ if (TYPE_CANONICAL (t) && t != TYPE_CANONICAL (t))
+ {
+ c_pretty_printer cpp2;
+ /* Print the stripped version into a temporary printer. */
+ cpp2.type_id (TYPE_CANONICAL (t));
+ struct obstack *ob2 = cpp2.buffer->obstack;
+ /* Get the stripped version from the temporary printer. */
+ const char *aka = (char *) obstack_base (ob2);
+ int aka_len = obstack_object_size (ob2);
+ int type1_len = obstack_object_size (ob) - len;
+
+ /* If they are identical, bail out. */
+ if (aka_len == type1_len && memcmp (p + len, aka, aka_len) == 0)
+ return;
+
+ /* They're not, print the stripped version now. */
+ if (*quoted)
+ pp_end_quote (cpp, pp_show_color (cpp));
+ pp_c_whitespace (cpp);
+ pp_left_brace (cpp);
+ pp_c_ws_string (cpp, _("aka"));
+ pp_c_whitespace (cpp);
+ if (*quoted)
+ pp_begin_quote (cpp, pp_show_color (cpp));
+ cpp->type_id (TYPE_CANONICAL (t));
+ if (*quoted)
+ pp_end_quote (cpp, pp_show_color (cpp));
+ pp_right_brace (cpp);
+ /* No further closing quotes are needed. */
+ *quoted = false;
+ }
+}
+
/* Called during diagnostic message formatting process to print a
source-level entity onto BUFFER. The meaning of the format specifiers
is as follows:
bool *quoted, const char **)
{
tree t = NULL_TREE;
- tree name;
// FIXME: the next cast should be a dynamic_cast, when it is permitted.
c_pretty_printer *cpp = (c_pretty_printer *) pp;
pp->padding = pp_none;
break;
case 'T':
- {
- gcc_assert (TYPE_P (t));
- struct obstack *ob = pp_buffer (cpp)->obstack;
- char *p = (char *) obstack_base (ob);
- /* Remember the end of the initial dump. */
- int len = obstack_object_size (ob);
-
- name = TYPE_NAME (t);
- if (name && TREE_CODE (name) == TYPE_DECL && DECL_NAME (name))
- pp_identifier (cpp, lang_hooks.decl_printable_name (name, 2));
- else
- cpp->type_id (t);
-
- /* If we're printing a type that involves typedefs, also print the
- stripped version. But sometimes the stripped version looks
- exactly the same, so we don't want it after all. To avoid
- printing it in that case, we play ugly obstack games. */
- if (TYPE_CANONICAL (t) && t != TYPE_CANONICAL (t))
- {
- c_pretty_printer cpp2;
- /* Print the stripped version into a temporary printer. */
- cpp2.type_id (TYPE_CANONICAL (t));
- struct obstack *ob2 = cpp2.buffer->obstack;
- /* Get the stripped version from the temporary printer. */
- const char *aka = (char *) obstack_base (ob2);
- int aka_len = obstack_object_size (ob2);
- int type1_len = obstack_object_size (ob) - len;
-
- /* If they are identical, bail out. */
- if (aka_len == type1_len && memcmp (p + len, aka, aka_len) == 0)
- return true;
-
- /* They're not, print the stripped version now. */
- if (*quoted)
- pp_end_quote (pp, pp_show_color (pp));
- pp_c_whitespace (cpp);
- pp_left_brace (cpp);
- pp_c_ws_string (cpp, _("aka"));
- pp_c_whitespace (cpp);
- if (*quoted)
- pp_begin_quote (pp, pp_show_color (pp));
- cpp->type_id (TYPE_CANONICAL (t));
- if (*quoted)
- pp_end_quote (pp, pp_show_color (pp));
- pp_right_brace (cpp);
- /* No further closing quotes are needed. */
- *quoted = false;
- }
- return true;
- }
+ print_type (cpp, t, quoted);
+ return true;
case 'E':
if (TREE_CODE (t) == IDENTIFIER_NODE)
return true;
}
+/* C-specific implementation of range_label::get_text () vfunc for
+ range_label_for_type_mismatch. */
+
+label_text
+range_label_for_type_mismatch::get_text () const
+{
+ if (m_labelled_type == NULL_TREE)
+ return label_text (NULL, false);
+
+ c_pretty_printer cpp;
+ bool quoted = false;
+ print_type (&cpp, m_labelled_type, "ed);
+ return label_text (xstrdup (pp_formatted_text (&cpp)), true);
+}
+
+
/* In C and ObjC, all decls have "C" linkage. */
bool
has_c_linkage (const_tree decl ATTRIBUTE_UNUSED)
switch (errtype)
{
case ic_argpass:
- if (pedwarn (expr_loc, OPT_Wpointer_sign,
- "pointer targets in passing argument %d of "
- "%qE differ in signedness", parmnum, rname))
- inform ((fundecl && !DECL_IS_BUILTIN (fundecl))
- ? DECL_SOURCE_LOCATION (fundecl) : expr_loc,
- "expected %qT but argument is of type %qT",
- type, rhstype);
+ {
+ range_label_for_type_mismatch rhs_label (rhstype, type);
+ gcc_rich_location richloc (expr_loc, &rhs_label);
+ if (pedwarn (&richloc, OPT_Wpointer_sign,
+ "pointer targets in passing argument %d of "
+ "%qE differ in signedness", parmnum, rname))
+ inform_for_arg (fundecl, expr_loc, parmnum, type,
+ rhstype);
+ }
break;
case ic_assign:
pedwarn (location, OPT_Wpointer_sign,
switch (errtype)
{
case ic_argpass:
- if (pedwarn (expr_loc, OPT_Wincompatible_pointer_types,
- "passing argument %d of %qE from incompatible "
- "pointer type", parmnum, rname))
- inform_for_arg (fundecl, expr_loc, parmnum, type, rhstype);
+ {
+ range_label_for_type_mismatch rhs_label (rhstype, type);
+ gcc_rich_location richloc (expr_loc, &rhs_label);
+ if (pedwarn (&richloc, OPT_Wincompatible_pointer_types,
+ "passing argument %d of %qE from incompatible "
+ "pointer type", parmnum, rname))
+ inform_for_arg (fundecl, expr_loc, parmnum, type, rhstype);
+ }
break;
case ic_assign:
pedwarn (location, OPT_Wincompatible_pointer_types,
switch (errtype)
{
case ic_argpass:
- if (pedwarn (expr_loc, OPT_Wint_conversion,
- "passing argument %d of %qE makes pointer from "
- "integer without a cast", parmnum, rname))
- inform_for_arg (fundecl, expr_loc, parmnum, type, rhstype);
+ {
+ range_label_for_type_mismatch rhs_label (rhstype, type);
+ gcc_rich_location richloc (expr_loc, &rhs_label);
+ if (pedwarn (&richloc, OPT_Wint_conversion,
+ "passing argument %d of %qE makes pointer from "
+ "integer without a cast", parmnum, rname))
+ inform_for_arg (fundecl, expr_loc, parmnum, type, rhstype);
+ }
break;
case ic_assign:
pedwarn (location, OPT_Wint_conversion,
switch (errtype)
{
case ic_argpass:
- if (pedwarn (expr_loc, OPT_Wint_conversion,
- "passing argument %d of %qE makes integer from "
- "pointer without a cast", parmnum, rname))
- inform_for_arg (fundecl, expr_loc, parmnum, type, rhstype);
+ {
+ range_label_for_type_mismatch rhs_label (rhstype, type);
+ gcc_rich_location richloc (expr_loc, &rhs_label);
+ if (pedwarn (&richloc, OPT_Wint_conversion,
+ "passing argument %d of %qE makes integer from "
+ "pointer without a cast", parmnum, rname))
+ inform_for_arg (fundecl, expr_loc, parmnum, type, rhstype);
+ }
break;
case ic_assign:
pedwarn (location, OPT_Wint_conversion,
switch (errtype)
{
case ic_argpass:
- error_at (expr_loc, "incompatible type for argument %d of %qE", parmnum,
- rname);
- inform_for_arg (fundecl, expr_loc, parmnum, type, rhstype);
+ {
+ range_label_for_type_mismatch rhs_label (rhstype, type);
+ gcc_rich_location richloc (expr_loc, &rhs_label);
+ error_at (&richloc, "incompatible type for argument %d of %qE", parmnum,
+ rname);
+ inform_for_arg (fundecl, expr_loc, parmnum, type, rhstype);
+ }
break;
case ic_assign:
error_at (location, "incompatible types when assigning to type %qT from "
return build3 (VEC_COND_EXPR, type, cmp, minus_one_vec, zero_vec);
}
+/* Subclass of range_label for labelling the type of EXPR when reporting
+ a type mismatch between EXPR and OTHER_EXPR.
+ Either or both of EXPR and OTHER_EXPR could be NULL. */
+
+class maybe_range_label_for_tree_type_mismatch : public range_label
+{
+ public:
+ maybe_range_label_for_tree_type_mismatch (tree expr, tree other_expr)
+ : m_expr (expr), m_other_expr (other_expr)
+ {
+ }
+
+ label_text get_text () const FINAL OVERRIDE
+ {
+ if (m_expr == NULL_TREE
+ || !EXPR_P (m_expr))
+ return label_text (NULL, false);
+ tree expr_type = TREE_TYPE (m_expr);
+
+ tree other_type = NULL_TREE;
+ if (m_other_expr && EXPR_P (m_other_expr))
+ other_type = TREE_TYPE (m_other_expr);
+
+ range_label_for_type_mismatch inner (expr_type, other_type);
+ return inner.get_text ();
+ }
+
+ private:
+ tree m_expr;
+ tree m_other_expr;
+};
+
/* Build a binary-operation expression without default conversions.
CODE is the kind of expression to build.
LOCATION is the operator's location.
|| !vector_types_compatible_elements_p (type0, type1)))
{
gcc_rich_location richloc (location);
- richloc.maybe_add_expr (orig_op0);
- richloc.maybe_add_expr (orig_op1);
+ maybe_range_label_for_tree_type_mismatch
+ label_for_op0 (orig_op0, orig_op1),
+ label_for_op1 (orig_op1, orig_op0);
+ richloc.maybe_add_expr (orig_op0, &label_for_op0);
+ richloc.maybe_add_expr (orig_op1, &label_for_op1);
binary_op_error (&richloc, code, type0, type1);
return error_mark_node;
}
if (!result_type)
{
gcc_rich_location richloc (location);
- richloc.maybe_add_expr (orig_op0);
- richloc.maybe_add_expr (orig_op1);
+ maybe_range_label_for_tree_type_mismatch
+ label_for_op0 (orig_op0, orig_op1),
+ label_for_op1 (orig_op1, orig_op0);
+ richloc.maybe_add_expr (orig_op0, &label_for_op0);
+ richloc.maybe_add_expr (orig_op1, &label_for_op1);
binary_op_error (&richloc, code, TREE_TYPE (op0), TREE_TYPE (op1));
return error_mark_node;
}
Common Var(flag_diagnostics_show_caret) Init(1)
Show the source line with a caret indicating the column.
+fdiagnostics-show-labels
+Common Var(flag_diagnostics_show_labels) Init(1)
+Show labels annotating ranges of source code when showing source
+
fdiagnostics-show-line-numbers
Common Var(flag_diagnostics_show_line_numbers) Init(1)
Show line numbers in the left margin when showing source
+2018-08-15 David Malcolm <dmalcolm@redhat.com>
+
+ * call.c: Include "gcc-rich-location.h".
+ (convert_like_real): Add range label for "invalid conversion"
+ diagnostic.
+ (perform_implicit_conversion_flags): Add type label to the
+ "could not convert" error.
+ * error.c: Include "gcc-rich-location.h".
+ (range_label_for_type_mismatch::get_text): New function.
+ * typeck.c (convert_for_assignment): Add type label to
+ the "cannot convert" error if a location is available.
+
2018-08-15 Paolo Carlini <paolo.carlini@oracle.com>
* decl.c (check_previous_goto_1): When decl_jump_unsafe returns 2
#include "internal-fn.h"
#include "stringpool.h"
#include "attribs.h"
+#include "gcc-rich-location.h"
/* The various kinds of conversion. */
break;
}
if (!complained)
- complained = permerror (loc, "invalid conversion from %qH to %qI",
- TREE_TYPE (expr), totype);
+ {
+ range_label_for_type_mismatch label (TREE_TYPE (expr), totype);
+ gcc_rich_location richloc (loc, &label);
+ complained = permerror (&richloc,
+ "invalid conversion from %qH to %qI",
+ TREE_TYPE (expr), totype);
+ }
if (complained && fn)
inform (get_fndecl_argument_location (fn, argnum),
" initializing argument %P of %qD", argnum, fn);
else if (invalid_nonstatic_memfn_p (loc, expr, complain))
/* We gave an error. */;
else
- error_at (loc, "could not convert %qE from %qH to %qI", expr,
- TREE_TYPE (expr), type);
+ {
+ range_label_for_type_mismatch label (TREE_TYPE (expr), type);
+ gcc_rich_location rich_loc (loc, &label);
+ error_at (&rich_loc, "could not convert %qE from %qH to %qI",
+ expr, TREE_TYPE (expr), type);
+ }
}
expr = error_mark_node;
}
#include "c-family/c-objc.h"
#include "ubsan.h"
#include "internal-fn.h"
+#include "gcc-rich-location.h"
#define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
#define pp_separate_with_semicolon(PP) pp_cxx_separate_with (PP, ';')
suggest_alternatives_for (location, name, true);
}
}
+
+/* C++-specific implementation of range_label::get_text () vfunc for
+ range_label_for_type_mismatch.
+
+ Compare with print_template_differences above. */
+
+label_text
+range_label_for_type_mismatch::get_text () const
+{
+ if (m_labelled_type == NULL_TREE)
+ return label_text (NULL, false);
+
+ const bool verbose = false;
+ const bool show_color = false;
+
+ const char *result;
+ if (m_other_type
+ && comparable_template_types_p (m_labelled_type, m_other_type))
+ result = type_to_string_with_compare (m_labelled_type, m_other_type,
+ verbose, show_color);
+ else
+ result = type_to_string (m_labelled_type, verbose, true, NULL, show_color);
+
+ /* Both of the above return GC-allocated buffers, so the caller mustn't
+ free them. */
+ return label_text (const_cast <char *> (result), false);
+}
}
else if (fndecl)
{
- error_at (cp_expr_loc_or_loc (rhs, input_location),
+ location_t loc = cp_expr_location (rhs);
+ range_label_for_type_mismatch rhs_label (rhstype, type);
+ range_label *label = &rhs_label;
+ if (loc == UNKNOWN_LOCATION)
+ {
+ loc = input_location;
+ label = NULL;
+ }
+ gcc_rich_location richloc (loc, label);
+ error_at (&richloc,
"cannot convert %qH to %qI",
rhstype, type);
inform (get_fndecl_argument_location (fndecl, parmnum),
layout_range (const expanded_location *start_exploc,
const expanded_location *finish_exploc,
bool show_caret_p,
- const expanded_location *caret_exploc);
+ const expanded_location *caret_exploc,
+ const range_label *label);
bool contains_point (linenum_type row, int column) const;
bool intersects_line_p (linenum_type row) const;
layout_point m_finish;
bool m_show_caret_p;
layout_point m_caret;
+ const range_label *m_label;
};
/* A struct for use by layout::print_source_line for telling
bool should_print_annotation_line_p (linenum_type row) const;
void start_annotation_line () const;
void print_annotation_line (linenum_type row, const line_bounds lbounds);
+ void print_any_labels (linenum_type row);
void print_trailing_fixits (linenum_type row);
bool annotation_line_showed_range_p (linenum_type line, int start_column,
expanded_location m_exploc;
colorizer m_colorizer;
bool m_colorize_source_p;
+ bool m_show_labels_p;
bool m_show_line_numbers_p;
auto_vec <layout_range> m_layout_ranges;
auto_vec <const fixit_hint *> m_fixit_hints;
layout_range::layout_range (const expanded_location *start_exploc,
const expanded_location *finish_exploc,
bool show_caret_p,
- const expanded_location *caret_exploc)
+ const expanded_location *caret_exploc,
+ const range_label *label)
: m_start (*start_exploc),
m_finish (*finish_exploc),
m_show_caret_p (show_caret_p),
- m_caret (*caret_exploc)
+ m_caret (*caret_exploc),
+ m_label (label)
{
}
const expanded_location finish_exploc
= {"test.c", end_line, end_col, NULL, false};
return layout_range (&start_exploc, &finish_exploc, false,
- &start_exploc);
+ &start_exploc, NULL);
}
/* Selftests for layout_range::contains_point and
m_exploc (richloc->get_expanded_location (0)),
m_colorizer (context, diagnostic_kind),
m_colorize_source_p (context->colorize_source_p),
+ m_show_labels_p (context->show_labels_p),
m_show_line_numbers_p (context->show_line_numbers_p),
m_layout_ranges (richloc->get_num_locations ()),
m_fixit_hints (richloc->get_num_fixit_hints ()),
/* Everything is now known to be in the correct source file,
but it may require further sanitization. */
- layout_range ri (&start, &finish, loc_range->m_show_caret_p, &caret);
+ layout_range ri (&start, &finish, loc_range->m_show_caret_p, &caret,
+ loc_range->m_label);
/* If we have a range that finishes before it starts (perhaps
from something built via macro expansion), printing the
print_newline ();
}
+/* Implementation detail of layout::print_any_labels.
+
+ A label within the given row of source. */
+
+struct line_label
+{
+ line_label (int state_idx, int column, label_text text)
+ : m_state_idx (state_idx), m_column (column),
+ m_text (text), m_length (strlen (text.m_buffer)),
+ m_label_line (0)
+ {}
+
+ /* Sorting is primarily by column, then by state index. */
+ static int comparator (const void *p1, const void *p2)
+ {
+ const line_label *ll1 = (const line_label *)p1;
+ const line_label *ll2 = (const line_label *)p2;
+ int column_cmp = compare (ll1->m_column, ll2->m_column);
+ if (column_cmp)
+ return column_cmp;
+ return compare (ll1->m_state_idx, ll2->m_state_idx);
+ }
+
+ int m_state_idx;
+ int m_column;
+ label_text m_text;
+ size_t m_length;
+ int m_label_line;
+};
+
+/* Print any labels in this row. */
+void
+layout::print_any_labels (linenum_type row)
+{
+ int i;
+ auto_vec<line_label> labels;
+
+ /* Gather the labels that are to be printed into "labels". */
+ {
+ layout_range *range;
+ FOR_EACH_VEC_ELT (m_layout_ranges, i, range)
+ {
+ /* Most ranges don't have labels, so reject this first. */
+ if (range->m_label == NULL)
+ continue;
+
+ /* The range's caret must be on this line. */
+ if (range->m_caret.m_line != row)
+ continue;
+
+ /* Reject labels that aren't fully visible due to clipping
+ by m_x_offset. */
+ if (range->m_caret.m_column <= m_x_offset)
+ continue;
+
+ label_text text;
+ text = range->m_label->get_text ();
+
+ /* Allow for labels that return NULL from their get_text
+ implementation (so e.g. such labels can control their own
+ visibility). */
+ if (text.m_buffer == NULL)
+ continue;
+
+ labels.safe_push (line_label (i, range->m_caret.m_column, text));
+ }
+ }
+
+ /* Bail out if there are no labels on this row. */
+ if (labels.length () == 0)
+ return;
+
+ /* Sort them. */
+ labels.qsort(line_label::comparator);
+
+ /* Figure out how many "label lines" we need, and which
+ one each label is printed in.
+
+ For example, if the labels aren't too densely packed,
+ we can fit them on the same line, giving two "label lines":
+
+ foo + bar
+ ~~~ ~~~
+ | | : label line 0
+ l0 l1 : label line 1
+
+ If they would touch each other or overlap, then we need
+ additional "label lines":
+
+ foo + bar
+ ~~~ ~~~
+ | | : label line 0
+ | label 1 : label line 1
+ label 0 : label line 2
+
+ Place the final label on label line 1, and work backwards, adding
+ label lines as needed.
+
+ If multiple labels are at the same place, put them on separate
+ label lines:
+
+ foo + bar
+ ^ : label line 0
+ | : label line 1
+ label 1 : label line 2
+ label 0 : label line 3. */
+
+ int max_label_line = 1;
+ {
+ int next_column = INT_MAX;
+ line_label *label;
+ FOR_EACH_VEC_ELT_REVERSE (labels, i, label)
+ {
+ /* Would this label "touch" or overlap the next label? */
+ if (label->m_column + label->m_length >= (size_t)next_column)
+ max_label_line++;
+
+ label->m_label_line = max_label_line;
+ next_column = label->m_column;
+ }
+ }
+
+ /* Print the "label lines". For each label within the line, print
+ either a vertical bar ('|') for the labels that are lower down, or the
+ labels themselves once we've reached their line. */
+ {
+ /* Keep track of in which column we last printed a vertical bar.
+ This allows us to suppress duplicate vertical bars for the case
+ where multiple labels are on one column. */
+ int last_vbar = 0;
+ for (int label_line = 0; label_line <= max_label_line; label_line++)
+ {
+ start_annotation_line ();
+ pp_space (m_pp);
+ int column = 1 + m_x_offset;
+ line_label *label;
+ FOR_EACH_VEC_ELT (labels, i, label)
+ {
+ if (label_line > label->m_label_line)
+ /* We've printed all the labels for this label line. */
+ break;
+
+ if (label_line == label->m_label_line)
+ {
+ gcc_assert (column <= label->m_column);
+ move_to_column (&column, label->m_column, true);
+ m_colorizer.set_range (label->m_state_idx);
+ pp_string (m_pp, label->m_text.m_buffer);
+ m_colorizer.set_normal_text ();
+ column += label->m_length;
+ }
+ else if (label->m_column != last_vbar)
+ {
+ gcc_assert (column <= label->m_column);
+ move_to_column (&column, label->m_column, true);
+ m_colorizer.set_range (label->m_state_idx);
+ pp_character (m_pp, '|');
+ m_colorizer.set_normal_text ();
+ last_vbar = column;
+ column++;
+ }
+ }
+ print_newline ();
+ }
+ }
+
+ /* Clean up. */
+ {
+ line_label *label;
+ FOR_EACH_VEC_ELT (labels, i, label)
+ label->m_text.maybe_free ();
+ }
+}
+
/* If there are any fixit hints inserting new lines before source line ROW,
print them.
print_source_line (row, line.get_buffer (), line.length (), &lbounds);
if (should_print_annotation_line_p (row))
print_annotation_line (row, lbounds);
+ if (m_show_labels_p)
+ print_any_labels (row);
print_trailing_fixits (row);
}
pp_formatted_text (dc.printer));
}
+/* Test of labeling the ranges within a rich_location. */
+
+static void
+test_one_liner_labels ()
+{
+ location_t foo
+ = make_location (linemap_position_for_column (line_table, 1),
+ linemap_position_for_column (line_table, 1),
+ linemap_position_for_column (line_table, 3));
+ location_t bar
+ = make_location (linemap_position_for_column (line_table, 7),
+ linemap_position_for_column (line_table, 7),
+ linemap_position_for_column (line_table, 9));
+ location_t field
+ = make_location (linemap_position_for_column (line_table, 11),
+ linemap_position_for_column (line_table, 11),
+ linemap_position_for_column (line_table, 15));
+
+ /* Example where all the labels fit on one line. */
+ {
+ text_range_label label0 ("0");
+ text_range_label label1 ("1");
+ text_range_label label2 ("2");
+ gcc_rich_location richloc (foo, &label0);
+ richloc.add_range (bar, false, &label1);
+ richloc.add_range (field, false, &label2);
+
+ {
+ test_diagnostic_context dc;
+ diagnostic_show_locus (&dc, &richloc, DK_ERROR);
+ ASSERT_STREQ ("\n"
+ " foo = bar.field;\n"
+ " ^~~ ~~~ ~~~~~\n"
+ " | | |\n"
+ " 0 1 2\n",
+ pp_formatted_text (dc.printer));
+ }
+
+ /* Verify that we can disable label-printing. */
+ {
+ test_diagnostic_context dc;
+ dc.show_labels_p = false;
+ diagnostic_show_locus (&dc, &richloc, DK_ERROR);
+ ASSERT_STREQ ("\n"
+ " foo = bar.field;\n"
+ " ^~~ ~~~ ~~~~~\n",
+ pp_formatted_text (dc.printer));
+ }
+ }
+
+ /* Example where the labels need extra lines. */
+ {
+ text_range_label label0 ("label 0");
+ text_range_label label1 ("label 1");
+ text_range_label label2 ("label 2");
+ gcc_rich_location richloc (foo, &label0);
+ richloc.add_range (bar, false, &label1);
+ richloc.add_range (field, false, &label2);
+
+ test_diagnostic_context dc;
+ diagnostic_show_locus (&dc, &richloc, DK_ERROR);
+ ASSERT_STREQ ("\n"
+ " foo = bar.field;\n"
+ " ^~~ ~~~ ~~~~~\n"
+ " | | |\n"
+ " | | label 2\n"
+ " | label 1\n"
+ " label 0\n",
+ pp_formatted_text (dc.printer));
+ }
+
+ /* Example of boundary conditions: label 0 and 1 have just enough clearance,
+ but label 1 just touches label 2. */
+ {
+ text_range_label label0 ("aaaaa");
+ text_range_label label1 ("bbbb");
+ text_range_label label2 ("c");
+ gcc_rich_location richloc (foo, &label0);
+ richloc.add_range (bar, false, &label1);
+ richloc.add_range (field, false, &label2);
+
+ test_diagnostic_context dc;
+ diagnostic_show_locus (&dc, &richloc, DK_ERROR);
+ ASSERT_STREQ ("\n"
+ " foo = bar.field;\n"
+ " ^~~ ~~~ ~~~~~\n"
+ " | | |\n"
+ " | | c\n"
+ " aaaaa bbbb\n",
+ pp_formatted_text (dc.printer));
+ }
+
+ /* Example of out-of-order ranges (thus requiring a sort). */
+ {
+ text_range_label label0 ("0");
+ text_range_label label1 ("1");
+ text_range_label label2 ("2");
+ gcc_rich_location richloc (field, &label0);
+ richloc.add_range (bar, false, &label1);
+ richloc.add_range (foo, false, &label2);
+
+ test_diagnostic_context dc;
+ diagnostic_show_locus (&dc, &richloc, DK_ERROR);
+ ASSERT_STREQ ("\n"
+ " foo = bar.field;\n"
+ " ~~~ ~~~ ^~~~~\n"
+ " | | |\n"
+ " 2 1 0\n",
+ pp_formatted_text (dc.printer));
+ }
+
+ /* Ensure we don't ICE if multiple ranges with labels are on
+ the same point. */
+ {
+ text_range_label label0 ("label 0");
+ text_range_label label1 ("label 1");
+ text_range_label label2 ("label 2");
+ gcc_rich_location richloc (bar, &label0);
+ richloc.add_range (bar, false, &label1);
+ richloc.add_range (bar, false, &label2);
+
+ test_diagnostic_context dc;
+ diagnostic_show_locus (&dc, &richloc, DK_ERROR);
+ ASSERT_STREQ ("\n"
+ " foo = bar.field;\n"
+ " ^~~\n"
+ " |\n"
+ " label 2\n"
+ " label 1\n"
+ " label 0\n",
+ pp_formatted_text (dc.printer));
+ }
+
+ /* Verify that a NULL result from range_label::get_text is
+ handled gracefully. */
+ {
+ text_range_label label (NULL);
+ gcc_rich_location richloc (bar, &label);
+
+ test_diagnostic_context dc;
+ diagnostic_show_locus (&dc, &richloc, DK_ERROR);
+ ASSERT_STREQ ("\n"
+ " foo = bar.field;\n"
+ " ^~~\n",
+ pp_formatted_text (dc.printer));
+ }
+
+ /* TODO: example of formatted printing (needs to be in
+ gcc-rich-location.c due to Makefile.in issues). */
+}
+
/* Run the various one-liner tests. */
static void
test_one_liner_fixit_validation_adhoc_locations ();
test_one_liner_many_fixits_1 ();
test_one_liner_many_fixits_2 ();
+ test_one_liner_labels ();
}
/* Verify that gcc_rich_location::add_location_if_nearby works. */
context->lock = 0;
context->inhibit_notes_p = false;
context->colorize_source_p = false;
+ context->show_labels_p = false;
context->show_line_numbers_p = false;
context->show_ruler_p = false;
context->parseable_fixits_p = false;
a token, which would look strange). */
bool colorize_source_p;
+ /* When printing source code, should labelled ranges be printed? */
+ bool show_labels_p;
+
/* When printing source code, should there be a left-hand margin
showing line numbers? */
bool show_line_numbers_p;
-fdiagnostics-show-location=@r{[}once@r{|}every-line@r{]} @gol
-fdiagnostics-color=@r{[}auto@r{|}never@r{|}always@r{]} @gol
-fno-diagnostics-show-option -fno-diagnostics-show-caret @gol
--fno-diagnostics-show-line-numbers @gol
+-fno-diagnostics-show-labels -fno-diagnostics-show-line-numbers @gol
-fdiagnostics-parseable-fixits -fdiagnostics-generate-patch @gol
-fdiagnostics-show-template-tree -fno-elide-type @gol
-fno-show-column}
to the terminal, the width is limited to the width given by the
@env{COLUMNS} environment variable or, if not set, to the terminal width.
+@item -fno-diagnostics-show-labels
+@opindex fno-diagnostics-show-labels
+@opindex fdiagnostics-show-labels
+By default, when printing source code (via @option{-fdiagnostics-show-caret}),
+diagnostics can label ranges of source code with pertinent information, such
+as the types of expressions:
+
+@smallexample
+ printf ("foo %s bar", long_i + long_j);
+ ~^ ~~~~~~~~~~~~~~~
+ | |
+ char * long int
+@end smallexample
+
+This option suppresses the printing of these labels (in the example above,
+the vertical bars and the ``char *'' and ``long int'' text).
+
@item -fno-diagnostics-show-line-numbers
@opindex fno-diagnostics-show-line-numbers
@opindex fdiagnostics-show-line-numbers
case OPT_fdiagnostics_show_location_:
case OPT_fdiagnostics_show_option:
case OPT_fdiagnostics_show_caret:
+ case OPT_fdiagnostics_show_labels:
case OPT_fdiagnostics_show_line_numbers:
case OPT_fdiagnostics_color_:
case OPT_fverbose_asm:
#include "cpplib.h"
#include "diagnostic.h"
-/* Add a range to the rich_location, covering expression EXPR. */
+/* Add a range to the rich_location, covering expression EXPR,
+ using LABEL if non-NULL. */
void
-gcc_rich_location::add_expr (tree expr)
+gcc_rich_location::add_expr (tree expr, range_label *label)
{
gcc_assert (expr);
if (CAN_HAVE_RANGE_P (expr))
- add_range (EXPR_LOCATION (expr), false);
+ add_range (EXPR_LOCATION (expr), false, label);
}
-/* If T is an expression, add a range for it to the rich_location. */
+/* If T is an expression, add a range for it to the rich_location,
+ using LABEL if non-NULL. */
void
-gcc_rich_location::maybe_add_expr (tree t)
+gcc_rich_location::maybe_add_expr (tree t, range_label *label)
{
if (EXPR_P (t))
- add_expr (t);
+ add_expr (t, label);
}
/* Add a fixit hint suggesting replacing the range at MISSPELLED_TOKEN_LOC
/* Constructors. */
/* Constructing from a location. */
- gcc_rich_location (source_location loc) :
- rich_location (line_table, loc) {}
+ gcc_rich_location (source_location loc, const range_label *label = NULL)
+ : rich_location (line_table, loc, label)
+ {
+ }
/* Methods for adding ranges via gcc entities. */
void
- add_expr (tree expr);
+ add_expr (tree expr, range_label *label);
void
- maybe_add_expr (tree t);
+ maybe_add_expr (tree t, range_label *label);
void add_fixit_misspelled_id (location_t misspelled_token_loc,
tree hint_id);
location_t indent);
};
+/* Concrete subclass of libcpp's range_label.
+ Simple implementation using a string literal. */
+
+class text_range_label : public range_label
+{
+ public:
+ text_range_label (const char *text) : m_text (text) {}
+
+ label_text get_text () const FINAL OVERRIDE
+ {
+ return label_text (const_cast <char *> (m_text), false);
+ }
+
+ private:
+ const char *m_text;
+};
+
+/* Concrete subclass of libcpp's range_label for use in
+ diagnostics involving mismatched types.
+
+ Each frontend that uses this should supply its own implementation.
+
+ Generate a label describing LABELLED_TYPE. The frontend may use
+ OTHER_TYPE where appropriate for highlighting the differences between
+ the two types (analogous to C++'s use of %H and %I with
+ template types).
+
+ Either or both of LABELLED_TYPE and OTHER_TYPE may be NULL_TREE.
+ If LABELLED_TYPE is NULL_TREE, then there is no label.
+
+ For example, this rich_location could use two instances of
+ range_label_for_type_mismatch:
+
+ printf ("arg0: %i arg1: %s arg2: %i",
+ ^~
+ |
+ const char *
+ 100, 101, 102);
+ ~~~
+ |
+ int
+
+ (a) the label for "%s" with LABELLED_TYPE for "const char*" and
+ (b) the label for "101" with LABELLED TYPE for "int"
+ where each one uses the other's type as OTHER_TYPE. */
+
+class range_label_for_type_mismatch : public range_label
+{
+ public:
+ range_label_for_type_mismatch (tree labelled_type, tree other_type)
+ : m_labelled_type (labelled_type), m_other_type (other_type)
+ {
+ }
+
+ label_text get_text () const OVERRIDE;
+
+ protected:
+ tree m_labelled_type;
+ tree m_other_type;
+};
+
#endif /* GCC_RICH_LOCATION_H */
{
va_list ap;
va_start (ap, gmsgid);
- bool warned = format_warning_va (fmt_loc, param_loc, corrected_substring,
- opt, gmsgid, &ap);
+ bool warned = format_warning_va (fmt_loc, NULL, param_loc, NULL,
+ corrected_substring, opt, gmsgid, &ap);
va_end (ap);
return warned;
{
va_list ap;
va_start (ap, plural_gmsgid);
- bool warned = format_warning_n_va (fmt_loc, param_loc, corrected_substring,
+ bool warned = format_warning_n_va (fmt_loc, NULL, param_loc, NULL,
+ corrected_substring,
opt, n, singular_gmsgid, plural_gmsgid,
&ap);
va_end (ap);
/* Fallthru. */
case OPT_fdiagnostics_show_caret:
+ case OPT_fdiagnostics_show_labels:
case OPT_fdiagnostics_show_line_numbers:
case OPT_fdiagnostics_show_option:
case OPT_fdiagnostics_show_location_:
switch (option->opt_index)
{
case OPT_fdiagnostics_show_caret:
+ case OPT_fdiagnostics_show_labels:
case OPT_fdiagnostics_show_line_numbers:
case OPT_fdiagnostics_show_option:
case OPT_fdiagnostics_show_location_:
{
case OPT_fdiagnostics_color_:
case OPT_fdiagnostics_show_caret:
+ case OPT_fdiagnostics_show_labels:
case OPT_fdiagnostics_show_line_numbers:
case OPT_fdiagnostics_show_option:
case OPT_fdiagnostics_show_location_:
dc->show_caret = value;
break;
+ case OPT_fdiagnostics_show_labels:
+ dc->show_labels_p = value;
+ break;
+
case OPT_fdiagnostics_show_line_numbers:
dc->show_line_numbers_p = value;
break;
{
diagnostic_initialize (this, 0);
show_caret = true;
+ show_labels_p = true;
show_column = true;
start_span = start_span_cb;
}
#include "tree.h"
#include "langhooks.h"
#include "substring-locations.h"
+#include "gcc-rich-location.h"
/* Emit a warning governed by option OPT, using SINGULAR_GMSGID as the
format string (or if PLURAL_GMSGID is different from SINGULAR_GMSGID,
printf(fmt, msg);
^~~ ~~~
+ If non-NULL, then FMT_LABEL will be used to label the location within the
+ string for cases 1 and 2; if non-NULL, then PARAM_LABEL will be used to label
+ the parameter. For example with case 1:
+
+ test.c:90:16: warning: '%s' here but arg 2 has 'long' type [-Wformat=]
+ printf ("foo %s bar", long_i + long_j);
+ ~^ ~~~~~~~~~~~~~~~
+ |
+ int
+
+ and with case 2:
+
+ test.c:90:10: warning: problem with '%i' here [-Wformat=]
+ printf("hello " INT_FMT " world", msg);
+ ^~~~~~~~~~~~~~~~~~~~~~~~~
+ test.c:19: note: format string is defined here
+ #define INT_FMT "%i"
+ ~^
+ |
+ int
+
If CORRECTED_SUBSTRING is non-NULL, use it for cases 1 and 2 to provide
a fix-it hint, suggesting that it should replace the text within the
substring range. For example:
bool
format_warning_n_va (const substring_loc &fmt_loc,
+ const range_label *fmt_label,
location_t param_loc,
+ const range_label *param_label,
const char *corrected_substring,
int opt, unsigned HOST_WIDE_INT n,
const char *singular_gmsgid,
}
}
- rich_location richloc (line_table, primary_loc);
+ /* Only use fmt_label in the initial warning for case 1. */
+ const range_label *primary_label = NULL;
+ if (substring_within_range)
+ primary_label = fmt_label;
+
+ gcc_rich_location richloc (primary_loc, primary_label);
if (param_loc != UNKNOWN_LOCATION)
- richloc.add_range (param_loc, false);
+ richloc.add_range (param_loc, false, param_label);
if (!err && corrected_substring && substring_within_range)
richloc.add_fixit_replace (fmt_substring_range, corrected_substring);
/* Case 2. */
if (warned)
{
- rich_location substring_richloc (line_table, fmt_substring_loc);
+ /* Use fmt_label in the note for case 2. */
+ rich_location substring_richloc (line_table, fmt_substring_loc,
+ fmt_label);
if (corrected_substring)
substring_richloc.add_fixit_replace (fmt_substring_range,
corrected_substring);
bool
format_warning_va (const substring_loc &fmt_loc,
+ const range_label *fmt_label,
location_t param_loc,
+ const range_label *param_label,
const char *corrected_substring,
int opt, const char *gmsgid, va_list *ap)
{
- return format_warning_n_va (fmt_loc, param_loc, corrected_substring, opt,
+ return format_warning_n_va (fmt_loc, fmt_label, param_loc, param_label,
+ corrected_substring, opt,
0, gmsgid, gmsgid, ap);
}
bool
format_warning_at_substring (const substring_loc &fmt_loc,
+ const range_label *fmt_label,
location_t param_loc,
+ const range_label *param_label,
const char *corrected_substring,
int opt, const char *gmsgid, ...)
{
va_list ap;
va_start (ap, gmsgid);
- bool warned = format_warning_va (fmt_loc, param_loc, corrected_substring,
- opt, gmsgid, &ap);
+ bool warned = format_warning_va (fmt_loc, fmt_label, param_loc, param_label,
+ corrected_substring, opt, gmsgid, &ap);
va_end (ap);
return warned;
bool
format_warning_at_substring_n (const substring_loc &fmt_loc,
+ const range_label *fmt_label,
location_t param_loc,
+ const range_label *param_label,
const char *corrected_substring,
int opt, unsigned HOST_WIDE_INT n,
const char *singular_gmsgid,
{
va_list ap;
va_start (ap, plural_gmsgid);
- bool warned = format_warning_n_va (fmt_loc, param_loc, corrected_substring,
+ bool warned = format_warning_n_va (fmt_loc, fmt_label, param_loc, param_label,
+ corrected_substring,
opt, n, singular_gmsgid, plural_gmsgid,
&ap);
va_end (ap);
/* Functions for emitting a warning about a format string. */
extern bool format_warning_va (const substring_loc &fmt_loc,
+ const range_label *fmt_label,
location_t param_loc,
+ const range_label *param_label,
const char *corrected_substring,
int opt, const char *gmsgid, va_list *ap)
- ATTRIBUTE_GCC_DIAG (5, 0);
+ ATTRIBUTE_GCC_DIAG (7, 0);
extern bool format_warning_n_va (const substring_loc &fmt_loc,
+ const range_label *fmt_label,
location_t param_loc,
+ const range_label *param_label,
const char *corrected_substring,
int opt, unsigned HOST_WIDE_INT n,
const char *singular_gmsgid,
const char *plural_gmsgid, va_list *ap)
- ATTRIBUTE_GCC_DIAG (6, 0) ATTRIBUTE_GCC_DIAG (7, 0);
+ ATTRIBUTE_GCC_DIAG (8, 0) ATTRIBUTE_GCC_DIAG (9, 0);
extern bool format_warning_at_substring (const substring_loc &fmt_loc,
+ const range_label *fmt_label,
location_t param_loc,
+ const range_label *param_label,
const char *corrected_substring,
int opt, const char *gmsgid, ...)
- ATTRIBUTE_GCC_DIAG (5, 6);
+ ATTRIBUTE_GCC_DIAG (7, 8);
extern bool format_warning_at_substring_n (const substring_loc &fmt_loc,
+ const range_label *fmt_label,
location_t param_loc,
+ const range_label *param_label,
const char *corrected_substring,
int opt, unsigned HOST_WIDE_INT n,
const char *singular_gmsgid,
const char *plural_gmsgid, ...)
- ATTRIBUTE_GCC_DIAG (6, 8) ATTRIBUTE_GCC_DIAG (7, 8);
+ ATTRIBUTE_GCC_DIAG (8, 10) ATTRIBUTE_GCC_DIAG (9, 10);
/* Implementation detail, for use when implementing
LANG_HOOKS_GET_SUBSTRING_LOCATION. */
+2018-08-15 David Malcolm <dmalcolm@redhat.com>
+
+ * g++.dg/diagnostic/aka3.C: New test.
+ * g++.dg/diagnostic/param-type-mismatch-2.C: Update expected
+ output to show range labels.
+ * g++.dg/diagnostic/param-type-mismatch.C: Likewise.
+ * g++.dg/plugin/plugin.exp (plugin_test_list): Add...
+ * g++.dg/plugin/show-template-tree-color-labels.C: New test.
+ * gcc.dg/bad-binary-ops.c: Update expected output to show range
+ labels. Add an "aka" example.
+ * gcc.dg/cpp/pr66415-1.c: Update expected output to show range
+ labels.
+ * gcc.dg/format/diagnostic-ranges.c: Likewise.
+ * gcc.dg/format/pr72858.c: Likewise.
+ * gcc.dg/format/pr78498.c: Likewise.
+ * gcc.dg/param-type-mismatch.c: Add "-Wpointer-sign" to options.
+ Update expected output to show range labels. Add examples of
+ -Wincompatible-pointer-types and -Wpointer-sign for parameters.
+ * gcc.dg/plugin/diagnostic-test-show-locus-bw-line-numbers.c:
+ Update expected output to show range labels.
+ * gcc.dg/plugin/diagnostic-test-show-locus-bw.c: Likewise.
+ (test_very_wide_line): Adjust so that label is at left-clipping
+ boundary.
+ (test_very_wide_line_2): New test.
+ * gcc.dg/plugin/diagnostic-test-show-locus-color-line-numbers.c:
+ Update expected output to show range labels.
+ * gcc.dg/plugin/diagnostic-test-show-locus-color.c: Likewise.
+ * gcc.dg/plugin/diagnostic-test-show-locus-no-labels.c: New test.
+ * gcc.dg/plugin/diagnostic_plugin_show_trees.c (show_tree): Update
+ for new param to gcc_rich_location::add_expr.
+ * gcc.dg/plugin/diagnostic_plugin_test_show_locus.c (add_range):
+ Add "label" param.
+ (test_show_locus): Add examples of labels to various tests. Tweak
+ the "very wide_line" test case and duplicate it, to cover the
+ boundary values for clipping of labels against the left-margin.
+ * gcc.dg/plugin/plugin.exp (plugin_test_list): Add
+ diagnostic-test-show-locus-no-labels.c.
+ * gcc.dg/pr69554-1.c: Update expected output to show range labels.
+ Update line numbers of dg-locus directives.
+ * gcc.dg/pr69627.c: Update expected output to show range labels.
+ * lib/multiline.exp (proc _build_multiline_regex): Remove
+ special-case handling of lines with trailing '|'.
+
2018-08-15 Qing Zhao <qing.zhao@oracle.com>
PR testsuite/86519
--- /dev/null
+/* Verify the "aka" descriptions for typedefs are correctly
+ quoted and shown within labels. */
+
+/* { dg-options "-fdiagnostics-show-caret" } */
+
+typedef struct s1 t1;
+typedef struct s2 {int i;} t2;
+
+int foo(t1 *);
+
+void test_1 () {
+ t2 pos;
+
+ foo (&pos); // { dg-error "cannot convert 't2\\*' {aka 's2\\*'} to 't1\\*' {aka 's1\\*'}" }
+ /* { dg-begin-multiline-output "" }
+ foo (&pos);
+ ^~~~
+ |
+ t2* {aka s2*}
+ { dg-end-multiline-output "" } */
+ /* { dg-begin-multiline-output "" }
+ int foo(t1 *);
+ ^~~~
+ { dg-end-multiline-output "" } */
+}
/* { dg-begin-multiline-output "" }
return callee_1 (first, second, third);
^~~~~~
+ |
+ const char*
{ dg-end-multiline-output "" } */
// { dg-message "initializing argument 2 of 'int callee_1\\(int, const char\\*\\*, float\\)'" "" { target *-*-* } callee_1 }
/* { dg-begin-multiline-output "" }
/* { dg-begin-multiline-output "" }
return callee_2 (first, second, third);
^~~~~~
+ |
+ const char*
{ dg-end-multiline-output "" } */
// { dg-message "initializing argument 2 of 'int callee_2\\(int, const char\\*\\*, float\\)'" "" { target *-*-* } callee_2 }
/* { dg-begin-multiline-output "" }
/* { dg-begin-multiline-output "" }
return callee_3 (first, second, third);
^~~~~~
+ |
+ const char*
{ dg-end-multiline-output "" } */
// { dg-message "initializing argument 2 of 'int callee_3\\(int, const char\\*\\*, float\\)'" "" { target *-*-* } callee_3 }
/* { dg-begin-multiline-output "" }
/* { dg-begin-multiline-output "" }
return callee_1 (first, second, third);
^~~~~~
+ |
+ int
{ dg-end-multiline-output "" } */
// { dg-message "initializing argument 2 of 'int callee_1\\(int, const char\\*, float\\)'" "" { target *-*-* } callee_1 }
/* { dg-begin-multiline-output "" }
/* { dg-begin-multiline-output "" }
return callee_2 (first, second, third);
^~~~~~
+ |
+ int
{ dg-end-multiline-output "" } */
// { dg-message "initializing argument 2 of 'int callee_2\\(int, const char\\*, float\\)'" "" { target *-*-* } callee_2 }
/* { dg-begin-multiline-output "" }
/* { dg-begin-multiline-output "" }
return callee_3 (first, second, third);
^~~~~~
+ |
+ int
{ dg-end-multiline-output "" } */
// { dg-message "initializing argument 2 of 'int callee_3\\(int, const char\\*, float\\)'" "" { target *-*-* } callee_3 }
/* { dg-begin-multiline-output "" }
/* { dg-begin-multiline-output "" }
return s4::member_1 (first, second, third);
^~~~~~
+ |
+ int
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
struct s4 { static int member_1 (int one, const char *two, float three); };
/* { dg-begin-multiline-output "" }
return inst.member_1 (first, second, third);
^~~~~~
+ |
+ int
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
struct s5 { int member_1 (int one, const char *two, float three); };
/* { dg-begin-multiline-output "" }
return ptr->member_1 (first, second, third);
^~~~~~
+ |
+ int
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
struct s6 { int member_1 (int one, const char *two, float three); };
/* { dg-begin-multiline-output "" }
return s8 <const char *>::member_1 (first, second, third);
^~~~~~
+ |
+ int
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
struct s8 { static int member_1 (int one, T two, float three); };
/* { dg-begin-multiline-output "" }
return inst.member_1 (first, second, third);
^~~~~~
+ |
+ int
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
struct s9 { int member_1 (int one, T two, float three); };
/* { dg-begin-multiline-output "" }
return callee_10 (first, second, third);
^~~~~~
+ |
+ int
{ dg-end-multiline-output "" } */
// { dg-message "initializing argument 2 of 'int callee_10\\(int, int \\(\\*\\)\\(int, int\\), float\\)'" "" { target *-*-* } callee_10 }
/* { dg-begin-multiline-output "" }
/* { dg-begin-multiline-output "" }
return callee_11 (first, second, third);
^~~~~~
+ |
+ int
{ dg-end-multiline-output "" } */
// { dg-message "initializing argument 2 of 'int callee_11\\(int, int \\(\\*\\)\\(int, int\\), float\\)'" "" { target *-*-* } callee_11 }
/* { dg-begin-multiline-output "" }
diagnostic-test-inlining-1.C } \
{ show_template_tree_color_plugin.c \
show-template-tree-color.C \
+ show-template-tree-color-labels.C \
show-template-tree-color-no-elide-type.C } \
{ comment_plugin.c comments-1.C } \
]
--- /dev/null
+/* Verify colorization of the labels in diagnostic-show-locus.c
+ for template comparisons.
+ Doing so requires a plugin; see the comments in the plugin for the
+ rationale. */
+
+// { dg-options "-fdiagnostics-color=always -fdiagnostics-show-caret" }
+
+template<typename> struct vector {};
+template<typename, typename> struct map {};
+
+void fn_1(vector<int>);
+void fn_2(map<int, int>);
+
+void test_1 (vector<double> vec)
+{
+ fn_1 (vec);
+ /* { dg-begin-multiline-output "" }
+could not convert '\e[01m\e[Kvec\e[m\e[K' from '\e[01m\e[Kvector<\e[01;32m\e[Kdouble\e[m\e[K>\e[m\e[K' to '\e[01m\e[Kvector<\e[01;32m\e[Kint\e[m\e[K>\e[m\e[K'
+ fn_1 (\e[01;31m\e[Kvec\e[m\e[K);
+ \e[01;31m\e[K^~~\e[m\e[K
+ \e[01;31m\e[K|\e[m\e[K
+ \e[01;31m\e[Kvector<double>\e[m\e[K
+ { dg-end-multiline-output "" } */
+ // TODO: we don't yet highlight the mismatching part with color
+}
+
+void test_2 (const map<int, double> &m)
+{
+ fn_2 (m);
+ /* { dg-begin-multiline-output "" }
+could not convert '\e[01m\e[Km\e[m\e[K' from '\e[01m\e[Kmap<[...],\e[01;32m\e[Kdouble\e[m\e[K>\e[m\e[K' to '\e[01m\e[Kmap<[...],\e[01;32m\e[Kint\e[m\e[K>\e[m\e[K'
+ fn_2 (\e[01;31m\e[Km\e[m\e[K);
+ \e[01;31m\e[K^\e[m\e[K
+ \e[01;31m\e[K|\e[m\e[K
+ \e[01;31m\e[Kmap<[...],double>\e[m\e[K
+ { dg-end-multiline-output "" } */
+ // TODO: we don't yet highlight the mismatching part with color
+}
{ dg-begin-multiline-output "" }
myvec[1]/ptr;
~~~~~~~~^
+ |
+ __m128
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
return (some_function ()
~~~~~~~~~~~~~~~~
+ |
+ struct s
+ some_other_function ());
^ ~~~~~~~~~~~~~~~~~~~~~~
+ |
+ struct t
{ dg-end-multiline-output "" } */
}
{ dg-end-multiline-output "" } */
/* TODO: ideally we'd underline both params here. */
}
+
+typedef struct s S;
+typedef struct t T;
+
+extern S callee_4a (void);
+extern T callee_4b (void);
+
+int test_4 (void)
+{
+ return callee_4a () + callee_4b (); /* { dg-error "invalid operands to binary \+" } */
+
+/* { dg-begin-multiline-output "" }
+ return callee_4a () + callee_4b ();
+ ~~~~~~~~~~~~ ^ ~~~~~~~~~~~~
+ | |
+ | T {aka struct t}
+ S {aka struct s}
+ { dg-end-multiline-output "" } */
+}
+
/* { dg-begin-multiline-output "" }
__builtin_printf ("xxxxxxxxxxxxxxxxx%dxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
~^
+ |
+ int
{ dg-end-multiline-output "" } */
}
/* { dg-begin-multiline-output "" }
printf("hello %i", msg);
~^ ~~~
+ | |
+ int const char *
%s
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
printf("hello %s", 42);
~^ ~~
+ | |
+ | int
+ char *
%d
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
printf("hello %i", (long)0);
~^ ~~~~~~~
+ | |
+ int long int
%li
{ dg-end-multiline-output "" } */
}
/* { dg-begin-multiline-output "" }
printf ("arg0: %i arg1: %s arg 2: %i",
~^
+ |
+ char *
%d
100, 101, 102);
~~~
+ |
+ int
{ dg-end-multiline-output "" } */
}
/* { dg-begin-multiline-output "" }
printf ("arg0: %i arg1: %s arg 2: %i",
~^
+ |
+ char *
%d
100, i + j, 102);
~~~~~
+ |
+ int
{ dg-end-multiline-output "" } */
}
~~
"d"
~^
+ |
+ int
{ dg-end-multiline-output "" } */
}
/* { dg-begin-multiline-output "" }
printf("hello \x25\x69", msg);
~~~~^~~~ ~~~
+ | |
+ int const char *
\x25s
{ dg-end-multiline-output "" } */
}
/* { dg-begin-multiline-output "" }
printf("hello \045\151", msg);
~~~~^~~~ ~~~
+ | |
+ int const char *
\045s
{ dg-end-multiline-output "" } */
}
^~~~~~~~
msg);
~~~
+ |
+ const char *
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
printf("prefix" "\x25" "\151" "suffix",
~~~~~~~~^~~~
+ |
+ int
\x25" "s
{ dg-end-multiline-output "" } */
}
/* { dg-begin-multiline-output "" }
printf(u8"hello %i", msg);
~^ ~~~
+ | |
+ int const char *
%s
{ dg-end-multiline-output "" } */
}
/* { dg-begin-multiline-output "" }
printf ("foo %s bar", long_i + long_j);
~^ ~~~~~~~~~~~~~~~
+ | |
+ char * long int
%ld
{ dg-end-multiline-output "" } */
}
/* { dg-begin-multiline-output "" }
printf (" %*.*d ", l, i1, i2);
~^~~~ ~
+ | |
+ int long int
{ dg-end-multiline-output "" } */
}
/* { dg-begin-multiline-output "" }
__builtin_sprintf (d, " %*ld ", foo, foo);
~^~~ ~~~
+ | |
+ int long int
{ dg-end-multiline-output "" } */
__builtin_sprintf (d, " %*ld ", foo + bar, foo); /* { dg-warning "28: field width specifier '\\*' expects argument of type 'int', but argument 3 has type 'long int'" } */
/* { dg-begin-multiline-output "" }
__builtin_sprintf (d, " %*ld ", foo + bar, foo);
~^~~ ~~~~~~~~~
+ | |
+ int long int
{ dg-end-multiline-output "" } */
}
/* { dg-begin-multiline-output "" }
__builtin_sprintf (d, " %.*ld ", foo, foo);
~~^~~ ~~~
+ | |
+ int long int
{ dg-end-multiline-output "" } */
__builtin_sprintf (d, " %.*ld ", foo + bar, foo); /* { dg-warning "29: field precision specifier '\\.\\*' expects argument of type 'int', but argument 3 has type 'long int'" } */
/* { dg-begin-multiline-output "" }
__builtin_sprintf (d, " %.*ld ", foo + bar, foo);
~~^~~ ~~~~~~~~~
+ | |
+ int long int
{ dg-end-multiline-output "" } */
}
/* { dg-begin-multiline-output "" }
printf("hello " INT_FMT " world", msg);
^~~~~~~~ ~~~
+ |
+ const char *
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
#define INT_FMT "%i"
~^
+ |
+ int
%s
{ dg-end-multiline-output "" } */
#undef INT_FMT
/* { dg-begin-multiline-output "" }
printf("hello %" PRIu32 " world", msg);
^~~~~~~~~ ~~~
+ |
+ const char *
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
#define PRIu32 "u"
^
+ |
+ unsigned int
{ dg-end-multiline-output "" } */
#undef PRIu32
}
/* { dg-begin-multiline-output "" }
#define FMT_STRING "hello %i world"
~^
+ |
+ int
%s
{ dg-end-multiline-output "" } */
#undef FMT_STRING
/* { dg-begin-multiline-output "" }
__builtin_printf(" %" "d ", 0.5);
^~~~ ~~~
+ |
+ double
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
__builtin_printf(" %" "d ", 0.5);
~~~~^
+ |
+ int
%" "f
{ dg-end-multiline-output "" } */
}
/* { dg-begin-multiline-output "" }
__builtin_printf(a, 0.5);
^ ~~~
+ |
+ double
{ dg-end-multiline-output "" } */
}
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8x ", lexpr);
~~~^ ~~~~~
+ | |
+ | long int
+ unsigned int
%-8lx
{ dg-end-multiline-output "" } */
sprintf (d, " %-8x ", ulexpr); /* { dg-warning "20: format '%x' expects argument of type 'unsigned int', but argument 3 has type 'long unsigned int'" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8x ", ulexpr);
~~~^ ~~~~~~
+ | |
+ | long unsigned int
+ unsigned int
%-8lx
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8x ", llexpr);
~~~^ ~~~~~~
+ | |
+ | long long int
+ unsigned int
%-8llx
{ dg-end-multiline-output "" } */
sprintf (d, " %-8x ", ullexpr); /* { dg-warning "20: format '%x' expects argument of type 'unsigned int', but argument 3 has type 'long long unsigned int'" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8x ", ullexpr);
~~~^ ~~~~~~~
+ | |
+ | long long unsigned int
+ unsigned int
%-8llx
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8x ", fexpr);
~~~^ ~~~~~
+ | |
+ | double
+ unsigned int
%-8f
{ dg-end-multiline-output "" } */
sprintf (d, " %-8x ", dexpr); /* { dg-warning "20: format '%x' expects argument of type 'unsigned int', but argument 3 has type 'double'" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8x ", dexpr);
~~~^ ~~~~~
+ | |
+ | double
+ unsigned int
%-8f
{ dg-end-multiline-output "" } */
sprintf (d, " %-8x ", ldexpr); /* { dg-warning "20: format '%x' expects argument of type 'unsigned int', but argument 3 has type 'long double'" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8x ", ldexpr);
~~~^ ~~~~~~
+ | |
+ | long double
+ unsigned int
%-8Lf
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8x ", ptr);
~~~^ ~~~
+ | |
+ | void *
+ unsigned int
%-8p
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8x ", s);
~~~^ ~
+ | |
+ | struct s
+ unsigned int
{ dg-end-multiline-output "" } */
}
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8lx ", iexpr);
~~~~^ ~~~~~
+ | |
+ | int
+ long unsigned int
%-8x
{ dg-end-multiline-output "" } */
sprintf (d, " %-8lx ", uiexpr); /* { dg-warning "21: format '%lx' expects argument of type 'long unsigned int', but argument 3 has type 'unsigned int'" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8lx ", uiexpr);
~~~~^ ~~~~~~
+ | |
+ | unsigned int
+ long unsigned int
%-8x
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8lx ", llexpr);
~~~~^ ~~~~~~
+ | |
+ | long long int
+ long unsigned int
%-8llx
{ dg-end-multiline-output "" } */
sprintf (d, " %-8lx ", ullexpr); /* { dg-warning "21: format '%lx' expects argument of type 'long unsigned int', but argument 3 has type 'long long unsigned int'" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8lx ", ullexpr);
~~~~^ ~~~~~~~
+ | |
+ | long long unsigned int
+ long unsigned int
%-8llx
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8lx ", fexpr);
~~~~^ ~~~~~
+ | |
+ | double
+ long unsigned int
%-8f
{ dg-end-multiline-output "" } */
sprintf (d, " %-8lx ", dexpr); /* { dg-warning "21: format '%lx' expects argument of type 'long unsigned int', but argument 3 has type 'double'" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8lx ", dexpr);
~~~~^ ~~~~~
+ | |
+ | double
+ long unsigned int
%-8f
{ dg-end-multiline-output "" } */
sprintf (d, " %-8lx ", ldexpr); /* { dg-warning "21: format '%lx' expects argument of type 'long unsigned int', but argument 3 has type 'long double'" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8lx ", ldexpr);
~~~~^ ~~~~~~
+ | |
+ | long double
+ long unsigned int
%-8Lf
{ dg-end-multiline-output "" } */
}
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8o ", lexpr);
~~~^ ~~~~~
+ | |
+ | long int
+ unsigned int
%-8lo
{ dg-end-multiline-output "" } */
sprintf (d, " %-8o ", ulexpr); /* { dg-warning "20: format '%o' expects argument of type 'unsigned int', but argument 3 has type 'long unsigned int'" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8o ", ulexpr);
~~~^ ~~~~~~
+ | |
+ | long unsigned int
+ unsigned int
%-8lo
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8o ", llexpr);
~~~^ ~~~~~~
+ | |
+ | long long int
+ unsigned int
%-8llo
{ dg-end-multiline-output "" } */
sprintf (d, " %-8o ", ullexpr); /* { dg-warning "20: format '%o' expects argument of type 'unsigned int', but argument 3 has type 'long long unsigned int'" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8o ", ullexpr);
~~~^ ~~~~~~~
+ | |
+ | long long unsigned int
+ unsigned int
%-8llo
{ dg-end-multiline-output "" } */
}
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8lo ", iexpr);
~~~~^ ~~~~~
+ | |
+ | int
+ long unsigned int
%-8o
{ dg-end-multiline-output "" } */
sprintf (d, " %-8lo ", uiexpr); /* { dg-warning "21: format '%lo' expects argument of type 'long unsigned int', but argument 3 has type 'unsigned int'" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8lo ", uiexpr);
~~~~^ ~~~~~~
+ | |
+ | unsigned int
+ long unsigned int
%-8o
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8lo ", llexpr);
~~~~^ ~~~~~~
+ | |
+ | long long int
+ long unsigned int
%-8llo
{ dg-end-multiline-output "" } */
sprintf (d, " %-8lo ", ullexpr); /* { dg-warning "21: format '%lo' expects argument of type 'long unsigned int', but argument 3 has type 'long long unsigned int'" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8lo ", ullexpr);
~~~~^ ~~~~~~~
+ | |
+ | long long unsigned int
+ long unsigned int
%-8llo
{ dg-end-multiline-output "" } */
}
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8e ", iexpr);
~~~^ ~~~~~
+ | |
+ | int
+ double
%-8d
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8e ", ldexpr);
~~~^ ~~~~~~
+ | |
+ | long double
+ double
%-8Le
{ dg-end-multiline-output "" } */
}
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8Le ", iexpr);
~~~~^ ~~~~~
+ | |
+ | int
+ long double
%-8d
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8Le ", fexpr);
~~~~^ ~~~~~
+ | |
+ | double
+ long double
%-8e
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8Le ", dexpr);
~~~~^ ~~~~~
+ | |
+ | double
+ long double
%-8e
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8E ", iexpr);
~~~^ ~~~~~
+ | |
+ | int
+ double
%-8d
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8E ", ldexpr);
~~~^ ~~~~~~
+ | |
+ | long double
+ double
%-8LE
{ dg-end-multiline-output "" } */
}
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8LE ", iexpr);
~~~~^ ~~~~~
+ | |
+ | int
+ long double
%-8d
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8LE ", fexpr);
~~~~^ ~~~~~
+ | |
+ | double
+ long double
%-8E
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
sprintf (d, " %-8LE ", dexpr);
~~~~^ ~~~~~
+ | |
+ | double
+ long double
%-8E
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
sprintf (d, "before %-+*.*lld after", lexpr, lexpr, lexpr);
~~~^~~~~~ ~~~~~
+ | |
+ int long int
{ dg-end-multiline-output "" } */
/* { dg-warning "28: field precision specifier '\\.\\*' expects argument of type 'int', but argument 4 has type 'long int'" "" { target *-*-* } test_everything_sprintf } */
/* { dg-begin-multiline-output "" }
sprintf (d, "before %-+*.*lld after", lexpr, lexpr, lexpr);
~~~~~^~~~ ~~~~~
+ | |
+ int long int
{ dg-end-multiline-output "" } */
/* { dg-warning "31: format '%lld' expects argument of type 'long long int', but argument 5 has type 'long int'" "" { target *-*-* } test_everything_sprintf } */
/* { dg-begin-multiline-output "" }
sprintf (d, "before %-+*.*lld after", lexpr, lexpr, lexpr);
~~~~~~~~^ ~~~~~
+ | |
+ long long int long int
%-+*.*ld
{ dg-end-multiline-output "" } */
}
/* { dg-begin-multiline-output "" }
__builtin_printf ("%i", "");
~^ ~~
+ | |
+ int char *
%s
{ dg-end-multiline-output "" } */
}
-/* { dg-options "-fdiagnostics-show-caret" } */
+/* { dg-options "-fdiagnostics-show-caret -Wpointer-sign" } */
/* A collection of calls where argument 2 is of the wrong type. */
/* { dg-begin-multiline-output "" }
return callee_1 (first, second, third);
^~~~~~
+ |
+ int
{ dg-end-multiline-output "" } */
/* { dg-message "expected 'const char \\*' but argument is of type 'int'" "" { target *-*-* } callee_1 } */
/* { dg-begin-multiline-output "" }
/* { dg-begin-multiline-output "" }
return callee_2 (first, second, third);
^~~~~~
+ |
+ int
{ dg-end-multiline-output "" } */
/* { dg-message "expected 'const char \\*' but argument is of type 'int'" "" { target *-*-* } callee_2 } */
/* { dg-begin-multiline-output "" }
/* { dg-begin-multiline-output "" }
return callee_3 (first, second, third);
^~~~~~
+ |
+ int
{ dg-end-multiline-output "" } */
/* { dg-message "expected 'const char \\*' but argument is of type 'int'" "" { target *-*-* } callee_3 } */
/* { dg-begin-multiline-output "" }
/* { dg-begin-multiline-output "" }
return callee_4 (first, second, third);
^~~~~~
+ |
+ const char *
{ dg-end-multiline-output "" } */
/* { dg-message "expected 'float' but argument is of type 'const char \\*'" "" { target *-*-* } callee_4 } */
/* { dg-begin-multiline-output "" }
/* { dg-begin-multiline-output "" }
return callee_5 (first, second, third);
^~~~~~
+ |
+ const char *
{ dg-end-multiline-output "" } */
/* { dg-message "expected 'float' but argument is of type 'const char \\*'" "" { target *-*-* } callee_5 } */
/* { dg-begin-multiline-output "" }
/* { dg-begin-multiline-output "" }
return callee_6 (first, second, third);
^~~~~~
+ |
+ int
{ dg-end-multiline-output "" } */
/* { dg-message " expected 'int \\(\\*\\)\\(int, int\\)' but argument is of type 'int'" "" { target *-*-* } callee_6 } */
/* { dg-begin-multiline-output "" }
/* { dg-begin-multiline-output "" }
return callee_7 (first, second, third);
^~~~~~
+ |
+ int
{ dg-end-multiline-output "" } */
/* { dg-message " expected 'int \\(\\*\\)\\(int, int\\)' but argument is of type 'int'" "" { target *-*-* } callee_7 } */
/* { dg-begin-multiline-output "" }
^~~~~~~~~~~~~~~~~
{ dg-end-multiline-output "" } */
}
+
+/* -Wincompatible-pointer-types for a parameter. */
+
+extern int callee_8 (int one, float *two, float (three)); /* { dg-line callee_8 } */
+
+int test_8 (int first, int *second, float third)
+{
+ return callee_8 (first, second, third); /* { dg-warning "passing argument 2 of 'callee_8' from incompatible pointer type" } */
+ /* { dg-begin-multiline-output "" }
+ return callee_8 (first, second, third);
+ ^~~~~~
+ |
+ int *
+ { dg-end-multiline-output "" } */
+ /* { dg-message "expected 'float \\*' but argument is of type 'int \\*'" "" { target *-*-* } callee_8 } */
+ /* { dg-begin-multiline-output "" }
+ extern int callee_8 (int one, float *two, float (three));
+ ~~~~~~~^~~
+ { dg-end-multiline-output "" } */
+}
+
+/* -Wpointer-sign for a parameter. */
+
+extern int callee_9 (int one, int *two, float (three)); /* { dg-line callee_9 } */
+
+int test_9 (int first, unsigned int *second, float third)
+{
+ return callee_9 (first, second, third); /* { dg-warning "pointer targets in passing argument 2 of 'callee_9' differ in signedness" } */
+ /* { dg-begin-multiline-output "" }
+ return callee_9 (first, second, third);
+ ^~~~~~
+ |
+ unsigned int *
+ { dg-end-multiline-output "" } */
+ /* { dg-message "expected 'int \\*' but argument is of type 'unsigned int \\*'" "" { target *-*-* } callee_9 } */
+ /* { dg-begin-multiline-output "" }
+ extern int callee_9 (int one, int *two, float (three));
+ ~~~~~^~~
+ { dg-end-multiline-output "" } */
+}
| ~~~~~~~~~~~~~~~~~
27 | + second_function ());
| ^ ~~~~~~~~~~~~~~~~~~
+ | |
+ | label
{ dg-end-multiline-output "" } */
#endif
}
| 0 0 0 0 0 0 1
| 4 5 6 7 8 9 0
| 0123456789012345678901234567890123456789012345678901234567890123456789
-41 | float f = foo * bar;
+43 | float f = foo * bar;
| ~~~~^~~~~
+ | |
+ | label
| bar * foo
{ dg-end-multiline-output "" } */
#endif
#if 0
int a[2][2] = { 0, 1 , 2, 3 }; /* { dg-warning "insertion hints" } */
/* { dg-begin-multiline-output "" }
-59 | int a[2][2] = { 0, 1 , 2, 3 };
+63 | int a[2][2] = { 0, 1 , 2, 3 };
| ^~~~
| { }
{ dg-end-multiline-output "" } */
#if 0
int a;; /* { dg-warning "example of a removal hint" } */
/* { dg-begin-multiline-output "" }
-73 | int a;;
+77 | int a;;
| ^
| -
{ dg-end-multiline-output "" } */
#if 0
gtk_widget_showall (dlg); /* { dg-warning "example of a replacement hint" } */
/* { dg-begin-multiline-output "" }
-87 | gtk_widget_showall (dlg);
+91 | gtk_widget_showall (dlg);
| ^~~~~~~~~~~~~~~~~~
| gtk_widget_show_all
{ dg-end-multiline-output "" } */
}
/* { dg-begin-multiline-output "" }
|+ break;
-106 | case 'b':
+110 | case 'b':
| ^~~~~~~~
{ dg-end-multiline-output "" } */
#endif
~~~~~~~~~~~~~~~~~
+ second_function ());
^ ~~~~~~~~~~~~~~~~~~
+ |
+ label
{ dg-end-multiline-output "" } */
#endif
}
/* { dg-begin-multiline-output "" }
x = (first_function_with_a_very_long_name (lorem, ipsum, dolor, sit, amet,
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ |
+ label 1
consectetur, adipiscing, elit,
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
sed, eiusmod, tempor,
~~~~~~~~~~~~~~~~~~~~~~
+ second_function_with_a_very_long_name (lorem, ipsum, dolor, sit,
^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ | |
+ | label 2
+ label 0
amet, consectetur,
~~~~~~~~~~~~~~~~~~
adipiscing, elit, sed,
void test_very_wide_line (void)
{
#if 0
- float f = foo * bar; /* { dg-warning "95: test" } */
+ float x = foo * bar; /* { dg-warning "95: test" } */
/* { dg-begin-multiline-output "" }
0 0 0 0 0 0 1
4 5 6 7 8 9 0
6789012345678901234567890123456789012345678901234567890123456789012345
- float f = foo * bar;
+ x = foo * bar;
+ ~ ~~~~^~~~~
+ | |
+ label 1 label 0
+ bar * foo
+ { dg-end-multiline-output "" } */
+#endif
+}
+
+void test_very_wide_line_2 (void)
+{
+#if 0
+ float x = foo * bar; /* { dg-warning "95: test" } */
+/* { dg-begin-multiline-output "" }
+ 0 0 0 0 0 0 1
+ 4 5 6 7 8 9 0
+ 6789012345678901234567890123456789012345678901234567890123456789012345
+ = foo * bar;
~~~~^~~~~
+ |
+ label 0
bar * foo
{ dg-end-multiline-output "" } */
#endif
^
Lorem ipsum dolor sit amet, consectetur adipiscing elit,
^~~~~ ^~~~~ ^~~~~ ^~~ ^~~~ ^~~~~~~~~~~ ^~~~~~~~~~ ^~~~
+ | | | | | | | |
+ | | | | label label label label
+ label label label label
LOREM IPSUM DOLOR SIT AMET CONSECTETUR ADIPISCING ELIT
sed do eiusmod tempor incididunt ut labore et dolore magna
^~~ ^~ ^~~~~~~ ^~~~~~ ^~~~~~~~~~ ^~ ^~~~~~ ^~ ^~~~~~ ^~~~~
+ | | | | | | | | | |
+ | | | | | | | | label label
+ | | | | | | label label
+ | | label label label label
+ | label
+ label
SED DO EIUSMOD TEMPOR INCIDIDUNT UT LABORE ET DOLORE MAGNA
aliqua. Ut enim ad minim veniam, quis nostrud exercitation
^~~~~~ ^~ ^~~~ ^~ ^~~~~ ^~~~~~ ^~~~ ^~~~~~~ ^~~~~~~~~~~~
+ | | | | | | | | |
+ | | | | | | | label label
+ | | | | label label label
+ | | | label
+ | | label
+ label label
ALIQUA UT ENIM AD MINIM VENIAM QUIS NOSTRUD EXERCITATION
ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis
^~~~~~~ ^~~~~~~ ^~~~ ^~ ^~~~~~~ ^~ ^~ ^~~~~~~ ^~~~~~~~~ ^~~~
+ | | | | | | | | | |
+ | | | | | | | label label label
+ | | | | | | label
+ | | | | label label
+ | | | label
+ label label label
ULLAMCO LABORIS NISI UT ALIQUIP EX EA COMMODO CONSEQUAT DUIS
aute irure dolor in reprehenderit in voluptate velit esse cillum
^~~~ ^~~~~ ^~~~~ ^~ ^~~~~~~~~~~~~ ^~ ^~~~~~~~~ ^~~~~ ^~~~ ^~~~~~
+ | | | | | | | | | |
+ | | | | | | | | | label
+ | | | | | | label label label
+ | | | | label label
+ | label label label
+ label
AUTE IRURE DOLOR IN REPREHENDERIT IN VOLUPTATE VELIT ESSE CILLUM
dolore eu fugiat nulla pariatur. Excepteur sint occaecat
^~~~~~ ^~ ^~~~~~ ^~~~~ ^~~~~~~~ ^~~~~~~~~ ^~~~ ^~~~~~~~
+ | | | | | | | |
+ | | | | | | | label
+ | | label label label label label
+ label label
DOLORE EU FUGIAT NULLA PARIATUR EXCEPTEUR SINT OCCAECAT
cupidatat non proident, sunt in culpa qui officia deserunt
^~~~~~~~~ ^~~ ^~~~~~~~ ^~~~ ^~ ^~~~~ ^~~ ^~~~~~~ ^~~~~~~~
+ | | | | | | | | |
+ | | | | | | | label label
+ | | | | | label label
+ | | | | label
+ | | label label
+ label label
CUPIDATAT NON PROIDENT SUNT IN CULPA QUI OFFICIA DESERUNT
mollit anim id est laborum.
^~~~~~ ^~~~ ^~ ^~~ ^~~~~~~
+ | | | | |
+ | | | | label
+ | | | label
+ | | label
+ label label
MOLLIT ANIM ID EST LABORUM
{ dg-end-multiline-output "" } */
}
| \e[32m\e[K~~~~~~~~~~~~~~~~~\e[m\e[K
15 | \e[01;35m\e[K+\e[m\e[K \e[34m\e[Ksecond_function ()\e[m\e[K);
| \e[01;35m\e[K^\e[m\e[K \e[34m\e[K~~~~~~~~~~~~~~~~~~\e[m\e[K
+ | \e[01;35m\e[K|\e[m\e[K
+ | \e[01;35m\e[Klabel\e[m\e[K
{ dg-end-multiline-output "" } */
#endif
}
\e[32m\e[K~~~~~~~~~~~~~~~~~\e[m\e[K
\e[01;35m\e[K+\e[m\e[K \e[34m\e[Ksecond_function ()\e[m\e[K);
\e[01;35m\e[K^\e[m\e[K \e[34m\e[K~~~~~~~~~~~~~~~~~~\e[m\e[K
+ \e[01;35m\e[K|\e[m\e[K
+ \e[01;35m\e[Klabel\e[m\e[K
{ dg-end-multiline-output "" } */
#endif
}
/* { dg-begin-multiline-output "" }
x = (\e[32m\e[Kfirst_function_with_a_very_long_name (lorem, ipsum, dolor, sit, amet,\e[m\e[K
\e[32m\e[K~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\e[m\e[K
+ \e[32m\e[K|\e[m\e[K
+ \e[32m\e[Klabel 1\e[m\e[K
\e[32m\e[K consectetur, adipiscing, elit,\e[m\e[K
\e[32m\e[K~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\e[m\e[K
\e[32m\e[K sed, eiusmod, tempor,\e[m\e[K
\e[32m\e[K~~~~~~~~~~~~~~~~~~~~~~\e[m\e[K
\e[01;35m\e[K+\e[m\e[K \e[34m\e[Ksecond_function_with_a_very_long_name (lorem, ipsum, dolor, sit,
\e[01;35m\e[K^\e[m\e[K \e[34m\e[K~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\e[m\e[K
+ \e[01;35m\e[K|\e[m\e[K \e[34m\e[K|\e[m\e[K
+ \e[01;35m\e[K|\e[m\e[K \e[34m\e[Klabel 2\e[m\e[K
+ \e[01;35m\e[Klabel 0\e[m\e[K
\e[34m\e[K amet, consectetur,\e[m\e[K
\e[34m\e[K~~~~~~~~~~~~~~~~~~\e[m\e[K
\e[34m\e[K adipiscing, elit, sed,\e[m\e[K
void test_very_wide_line (void)
{
#if 0
- float f = foo * bar; /* { dg-warning "95: test" } */
+ float x = foo * bar; /* { dg-warning "95: test" } */
/* { dg-begin-multiline-output "" }
0 0 0 0 0 0 1
4 5 6 7 8 9 0
6789012345678901234567890123456789012345678901234567890123456789012345
- float f = \e[01;35m\e[Kfoo * bar\e[m\e[K;
- \e[01;35m\e[K~~~~^~~~~\e[m\e[K
+ \e[32m\e[Kx\e[m\e[K = \e[01;35m\e[Kfoo * bar\e[m\e[K;
+ \e[32m\e[K~\e[m\e[K \e[01;35m\e[K~~~~^~~~~\e[m\e[K
+ \e[32m\e[K|\e[m\e[K \e[01;35m\e[K|\e[m\e[K
+ \e[32m\e[Klabel 1\e[m\e[K \e[01;35m\e[Klabel 0\e[m\e[K
\e[32m\e[Kbar * foo\e[m\e[K
{ dg-end-multiline-output "" } */
#endif
--- /dev/null
+/* { dg-do compile } */
+/* { dg-options "-O -fdiagnostics-show-caret -fno-diagnostics-show-labels" } */
+
+/* Verify that -fno-diagnostics-show-labels works. */
+
+/* This is a collection of unittests for diagnostic_show_locus;
+ see the overview in diagnostic_plugin_test_show_locus.c.
+
+ In particular, note the discussion of why we need a very long line here:
+01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
+ and that we can't use macros in this file. */
+
+void test_multiline (void)
+{
+#if 0
+ x = (first_function ()
+ + second_function ()); /* { dg-warning "test" } */
+
+ /* This shouldn't have a label. */
+ /* { dg-begin-multiline-output "" }
+ x = (first_function ()
+ ~~~~~~~~~~~~~~~~~
+ + second_function ());
+ ^ ~~~~~~~~~~~~~~~~~~
+ { dg-end-multiline-output "" } */
+#endif
+}
return;
gcc_rich_location richloc (EXPR_LOCATION (node));
- richloc.add_expr (node);
+ richloc.add_expr (node, NULL);
if (richloc.get_num_locations () < 2)
{
static void
add_range (rich_location *richloc, location_t start, location_t finish,
- bool show_caret_p)
+ bool show_caret_p, const range_label *label = NULL)
{
- richloc->add_range (make_location (start, start, finish), show_caret_p);
+ richloc->add_range (make_location (start, start, finish), show_caret_p,
+ label);
}
/* Exercise the diagnostic machinery to emit various warnings,
if (0 == strcmp (fnname, "test_multiline"))
{
const int line = fnstart_line + 2;
- rich_location richloc (line_table, get_loc (line + 1, 7));
+ text_range_label label ("label");
+ rich_location richloc (line_table, get_loc (line + 1, 7), &label);
add_range (&richloc, get_loc (line, 7), get_loc (line, 23), false);
add_range (&richloc, get_loc (line + 1, 9), get_loc (line + 1, 26),
false);
if (0 == strcmp (fnname, "test_many_lines"))
{
const int line = fnstart_line + 2;
- rich_location richloc (line_table, get_loc (line + 5, 7));
- add_range (&richloc, get_loc (line, 7), get_loc (line + 4, 65), false);
+ text_range_label label0 ("label 0");
+ text_range_label label1 ("label 1");
+ text_range_label label2 ("label 2");
+ rich_location richloc (line_table, get_loc (line + 5, 7), &label0);
+ add_range (&richloc, get_loc (line, 7), get_loc (line + 4, 65), false,
+ &label1);
add_range (&richloc, get_loc (line + 5, 9), get_loc (line + 10, 61),
- false);
+ false, &label2);
warning_at (&richloc, 0, "test");
}
}
/* Example of a very wide line, where the information of interest
- is beyond the width of the terminal (hardcoded above). */
+ is beyond the width of the terminal (hardcoded above), with
+ a secondary location that exactly fits on the left-margin. */
if (0 == strcmp (fnname, "test_very_wide_line"))
{
const int line = fnstart_line + 2;
global_dc->show_ruler_p = true;
+ text_range_label label0 ("label 0");
+ text_range_label label1 ("label 1");
+ rich_location richloc (line_table,
+ make_location (get_loc (line, 94),
+ get_loc (line, 90),
+ get_loc (line, 98)),
+ &label0);
+ richloc.add_range (get_loc (line, 35), false, &label1);
+ richloc.add_fixit_replace ("bar * foo");
+ warning_at (&richloc, 0, "test");
+ global_dc->show_ruler_p = false;
+ }
+
+ /* Likewise, but with a secondary location that's immediately before
+ the left margin; the location and label should be gracefully dropped. */
+ if (0 == strcmp (fnname, "test_very_wide_line_2"))
+ {
+ const int line = fnstart_line + 2;
+ global_dc->show_ruler_p = true;
+ text_range_label label0 ("label 0");
+ text_range_label label1 ("label 1");
rich_location richloc (line_table,
make_location (get_loc (line, 94),
get_loc (line, 90),
- get_loc (line, 98)));
+ get_loc (line, 98)),
+ &label0);
richloc.add_fixit_replace ("bar * foo");
+ richloc.add_range (get_loc (line, 34), false, &label1);
warning_at (&richloc, 0, "test");
global_dc->show_ruler_p = false;
}
/* Example of many locations and many fixits.
Underline (separately) every word in a comment, and convert them
- to upper case. */
+ to upper case. Give all of the ranges labels (sharing one label). */
if (0 == strcmp (fnname, "test_many_nested_locations"))
{
const char *file = LOCATION_FILE (fnstart);
const int start_line = fnstart_line + 2;
const int finish_line = start_line + 7;
location_t loc = get_loc (start_line - 1, 2);
+ text_range_label label ("label");
rich_location richloc (line_table, loc);
for (int line = start_line; line <= finish_line; line++)
{
location_t word
= make_location (start_of_word, start_of_word,
end_of_word);
- richloc.add_range (word, true);
+ richloc.add_range (word, true, &label);
/* Add a fixit, converting to upper case. */
char_span word_span = content.subspan (start_idx, idx - start_idx);
{ diagnostic_plugin_test_show_locus.c \
diagnostic-test-show-locus-bw.c \
diagnostic-test-show-locus-color.c \
+ diagnostic-test-show-locus-no-labels.c \
diagnostic-test-show-locus-bw-line-numbers.c \
diagnostic-test-show-locus-color-line-numbers.c \
diagnostic-test-show-locus-parseable-fixits.c \
/* { dg-begin-multiline-output "" }
return (p + 1) + (q + 1);
~~~~~~~ ^ ~~~~~~~
+ | |
+ | const char *
+ const char *
{ dg-end-multiline-output "" } */
}
/* { dg-begin-multiline-output "" }
return (p + 1)
~~~~~~~
+ |
+ const char *
+
^
(q + 1);
~~~~~~~
+ |
+ const char *
{ dg-end-multiline-output "" } */
}
+ /* { dg-error "invalid operands" } */
(q + 1);
-/* { dg-locus "12" "" { target *-*-* } "44" } */
+/* { dg-locus "12" "" { target *-*-* } "51" } */
/* { dg-begin-multiline-output "" }
return (p + 1)
~~~~~~~
+ |
+ const char *
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
+
^
(q + 1);
~~~~~~~
+ |
+ const char *
{ dg-end-multiline-output "" } */
}
/* { dg-begin-multiline-output "" }
return (p + 1)
~~~~~~~
+ |
+ const char *
+
^
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
(q + 1);
~~~~~~~
+ |
+ const char *
{ dg-end-multiline-output "" } */
}
+ /* { dg-error "invalid operands" } */
(q + 1); /* { dg-locus "14" } */
-/* { dg-locus "12" "" { target *-*-* } "88" } */
+/* { dg-locus "12" "" { target *-*-* } "103" } */
/* { dg-begin-multiline-output "" }
return (p + 1)
~~~~~~~
+ |
+ const char *
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
+
/* { dg-begin-multiline-output "" }
(q + 1);
~~~~~~~
+ |
+ const char *
{ dg-end-multiline-output "" } */
}
fringilla sapien elit vitae nisl. Fusce mattis commodo risus
nec convallis. */
(q + 1); /* { dg-locus "14" } */
-/* { dg-locus "12" "" { target *-*-* } "125" } */
+/* { dg-locus "12" "" { target *-*-* } "144" } */
/* { dg-begin-multiline-output "" }
return (p + 1)
~~~~~~~
+ |
+ const char *
{ dg-end-multiline-output "" } */
/* { dg-begin-multiline-output "" }
+
/* { dg-begin-multiline-output "" }
(q + 1);
~~~~~~~
+ |
+ const char *
{ dg-end-multiline-output "" } */
}
/* { dg-begin-multiline-output "" }
t[1] / s;
~~~~ ^
+ |
+ float
{ dg-end-multiline-output "" } */
}
/* { dg-begin-multiline-output "" }
t[1] / s[0];
~~~~ ^ ~~~~
+ | |
+ float const int *
{ dg-end-multiline-output "" } */
}
if {[string match "*^" $line] || [string match "*~" $line]} {
# Assume a line containing a caret/range. This must be
# an exact match.
- } elseif {[string match "*\\|" $line]} {
- # Assume a source line with a right-margin. Support
- # arbitrary text in place of any whitespace before the
- # right-margin, to deal with comments containing containing
- # DejaGnu directives.
-
- # Remove final "\|":
- set rexp [string range $rexp 0 [expr [string length $rexp] - 3]]
-
- # Trim off trailing whitespace:
- set old_length [string length $rexp]
- set rexp [string trimright $rexp]
- set new_length [string length $rexp]
-
- # Replace the trimmed whitespace with "." chars to match anything:
- set ws [string repeat "." [expr $old_length - $new_length]]
- set rexp "${rexp}${ws}"
-
- # Add back the trailing '\|':
- set rexp "${rexp}\\|"
} else {
# Assume that we have a quoted source line.
if {![string equal "" $line] } {
global_dc->show_caret
= global_options_init.x_flag_diagnostics_show_caret;
+ global_dc->show_labels_p
+ = global_options_init.x_flag_diagnostics_show_labels;
global_dc->show_line_numbers_p
= global_options_init.x_flag_diagnostics_show_line_numbers;
global_dc->show_option_requested
+2018-08-15 David Malcolm <dmalcolm@redhat.com>
+
+ * include/line-map.h (struct location_range): Add "m_label" field.
+ (class rich_location): Add description of labels to leading
+ comment.
+ (rich_location::rich_location): Add "label" param, defaulting to
+ NULL.
+ (rich_location::add_range): Likewise.
+ (struct label_text): New struct.
+ (class range_label): New abstract base class.
+ * line-map.c (rich_location::rich_location): Add "label" param;
+ use it.
+ (rich_location::add_range): Likewise.
+
2018-08-08 Nathan Sidwell <nathan@acm.org>
Make linemap::included_from a location
bool sysp;
} expanded_location;
+class range_label;
+
/* A location within a rich_location: a caret&range, with
- the caret potentially flagged for display. */
+ the caret potentially flagged for display, and an optional
+ label. */
struct location_range
{
where "1" and "2" are notionally carets. */
bool m_show_caret_p;
+
+ /* If non-NULL, the label for this range. */
+ const range_label *m_label;
};
/* A partially-embedded vec for use within rich_location for storing
Additional ranges may be added to help the user identify other
pertinent clauses in a diagnostic.
+ Ranges can (optionally) be given labels via class range_label.
+
rich_location instances are intended to be allocated on the stack
when generating diagnostics, and to be short-lived.
equal to their caret point. The frontend overrides the diagnostic
context's default caret character for these ranges.
- Example E
- *********
+ Example E (range labels)
+ ************************
printf ("arg0: %i arg1: %s arg2: %i",
^~
+ |
+ const char *
100, 101, 102);
~~~
+ |
+ int
This rich location has two ranges:
- range 0 is at the "%s" with start = caret = "%" and finish at
- the "s".
+ the "s". It has a range_label ("const char *").
- range 1 has start/finish covering the "101" and is not flagged for
- caret printing; it is perhaps at the start of "101".
-
+ caret printing. The caret is at the start of "101", where its
+ range_label is printed ("int").
Fix-it hints
------------
/* Constructors. */
/* Constructing from a location. */
- rich_location (line_maps *set, source_location loc);
+ rich_location (line_maps *set, source_location loc,
+ const range_label *label = NULL);
/* Destructor. */
~rich_location ();
source_location get_loc (unsigned int idx) const;
void
- add_range (source_location loc, bool show_caret_p);
+ add_range (source_location loc, bool show_caret_p,
+ const range_label *label = NULL);
void
set_range (unsigned int idx, source_location loc, bool show_caret_p);
bool m_fixits_cannot_be_auto_applied;
};
+/* A struct for the result of range_label::get_text: a NUL-terminated buffer
+ of localized text, and a flag to determine if the caller should "free" the
+ buffer. */
+
+struct label_text
+{
+ label_text ()
+ : m_buffer (NULL), m_caller_owned (false)
+ {}
+
+ label_text (char *buffer, bool caller_owned)
+ : m_buffer (buffer), m_caller_owned (caller_owned)
+ {}
+
+ void maybe_free ()
+ {
+ if (m_caller_owned)
+ free (m_buffer);
+ }
+
+ char *m_buffer;
+ bool m_caller_owned;
+};
+
+/* Abstract base class for labelling a range within a rich_location
+ (e.g. for labelling expressions with their type).
+
+ Generating the text could require non-trivial work, so this work
+ is delayed (via the "get_text" virtual function) until the diagnostic
+ printing code "knows" it needs it, thus avoiding doing it e.g. for
+ warnings that are filtered by command-line flags. This virtual
+ function also isolates libcpp and the diagnostics subsystem from
+ the front-end and middle-end-specific code for generating the text
+ for the labels.
+
+ Like the rich_location instances they annotate, range_label instances
+ are intended to be allocated on the stack when generating diagnostics,
+ and to be short-lived. */
+
+class range_label
+{
+ public:
+ virtual ~range_label () {}
+
+ /* Get localized text for the label. */
+ virtual label_text get_text () const = 0;
+};
+
/* A fix-it hint: a suggested insertion, replacement, or deletion of text.
We handle these three types of edit with one class, by representing
them as replacement of a half-open range:
/* Construct a rich_location with location LOC as its initial range. */
-rich_location::rich_location (line_maps *set, source_location loc) :
+rich_location::rich_location (line_maps *set, source_location loc,
+ const range_label *label) :
m_line_table (set),
m_ranges (),
m_column_override (0),
m_seen_impossible_fixit (false),
m_fixits_cannot_be_auto_applied (false)
{
- add_range (loc, true);
+ add_range (loc, true, label);
}
/* The destructor for class rich_location. */
/* Add the given range. */
void
-rich_location::add_range (source_location loc, bool show_caret_p)
+rich_location::add_range (source_location loc, bool show_caret_p,
+ const range_label *label)
{
location_range range;
range.m_loc = loc;
range.m_show_caret_p = show_caret_p;
+ range.m_label = label;
m_ranges.push (range);
}
projects / thirdparty / gcc.git / commitdiff
