+2019-05-16 Martin Sebor <msebor@redhat.com>
+
+ * builtins.c (expand_builtin_atomic_always_lock_free): Quote
+ identifiers, keywords, operators, and types in diagnostics. Correct
+ quoting, spelling, and sentence capitalization issues.
+ (expand_builtin_atomic_is_lock_free): Same.
+ (fold_builtin_next_arg): Same.
+ * cfgexpand.c (expand_one_var): Same.
+ (tree_conflicts_with_clobbers_p): Same.
+ (expand_asm_stmt): Same.
+ (verify_loop_structure): Same.
+ * cgraphunit.c (process_function_and_variable_attributes): Same.
+ * collect-utils.c (collect_execute): Same.
+ * collect2.c (maybe_run_lto_and_relink): Same.
+ (is_lto_object_file): Same.
+ (scan_prog_file): Same.
+ * convert.c (convert_to_real_1): Same.
+ * dwarf2out.c (dwarf2out_begin_prologue): Same.
+ * except.c (verify_eh_tree): Same.
+ * gcc.c (execute): Same.
+ (eval_spec_function): Same.
+ (run_attempt): Same.
+ (driver::set_up_specs): Same.
+ (compare_debug_auxbase_opt_spec_function): Same.
+ * gcov-tool.c (unlink_gcda_file): Same.
+ (do_merge): Same.
+ (do_rewrite): Same.
+ * gcse.c (gcse_or_cprop_is_too_expensive): Same.
+ * gimplify.c (gimplify_asm_expr): Same.
+ (gimplify_adjust_omp_clauses): Same.
+ * hsa-gen.c (gen_hsa_addr_insns): Same.
+ (gen_hsa_insns_for_load): Same.
+ (gen_hsa_cmp_insn_from_gimple): Same.
+ (gen_hsa_insns_for_operation_assignment): Same.
+ (gen_get_level): Same.
+ (gen_hsa_alloca): Same.
+ (omp_simple_builtin::generate): Same.
+ (gen_hsa_atomic_for_builtin): Same.
+ (gen_hsa_insns_for_call): Same.
+ * input.c (dump_location_info): Same.
+ * ipa-devirt.c (compare_virtual_tables): Same.
+ * ira.c (ira_setup_eliminable_regset): Same.
+ * lra-assigns.c (lra_assign): Same.
+ * lra-constraints.c (lra_constraints): Same.
+ * lto-streamer-in.c (lto_input_mode_table): Same.
+ * lto-wrapper.c (get_options_from_collect_gcc_options): Same.
+ (merge_and_complain): Same.
+ (compile_offload_image): Same.
+ (compile_images_for_offload_targets): Same.
+ (debug_objcopy): Same.
+ (run_gcc): Same.
+ (main): Same.
+ * opts.c (print_specific_help): Same.
+ (parse_no_sanitize_attribute): Same.
+ (print_help): Same.
+ (handle_param): Same.
+ * plugin.c (add_new_plugin): Same.
+ (parse_plugin_arg_opt): Same.
+ (try_init_one_plugin): Same.
+ * print-rtl.c (debug_bb_n_slim): Quote identifiers, keywords,
+ operators, and types in diagnostics. Correct quoting and spelling
+ issues.
+ * read-rtl-function.c (parse_edge_flag_token): Same.
+ (function_reader::parse_enum_value): Same.
+ * reg-stack.c (check_asm_stack_operands): Same.
+ * regcprop.c (validate_value_data): Same.
+ * sched-rgn.c (make_pass_sched_fusion): Same.
+ * stmt.c (check_unique_operand_names): Same.
+ * targhooks.c (default_target_option_pragma_parse): Same.
+ * tlink.c (recompile_files): Same.
+ * toplev.c (process_options): Same.
+ (do_compile): Same.
+ * trans-mem.c (diagnose_tm_1): Same.
+ (ipa_tm_scan_irr_block): Same.
+ (ipa_tm_diagnose_transaction): Same.
+ * tree-cfg.c (verify_address): Same. Use get_tree_code_name to
+ format a tree code name in a diagnostic.
+ (verify_types_in_gimple_min_lval): Same.
+ (verify_types_in_gimple_reference): Same.
+ (verify_gimple_call): Same.
+ (verify_gimple_assign_unary): Same.
+ (verify_gimple_assign_binary): Same.
+ (verify_gimple_assign_ternary): Same.
+ (verify_gimple_assign_single): Same.
+ (verify_gimple_switch): Same.
+ (verify_gimple_label): Same.
+ (verify_gimple_phi): Same.
+ (verify_gimple_in_seq): Same.
+ (verify_eh_throw_stmt_node): Same.
+ (collect_subblocks): Same.
+ (gimple_verify_flow_info): Same.
+ (do_warn_unused_result): Same.
+ * tree-inline.c (expand_call_inline): Same.
+ * tree-into-ssa.c (update_ssa): Same.
+ * tree.c (tree_int_cst_elt_check_failed): Same.
+ (tree_vec_elt_check_failed): Same.
+ (omp_clause_operand_check_failed): Same.
+ (verify_type_variant): Same.
+ (verify_type): Same.
+ * value-prof.c (verify_histograms): Same.
+ * varasm.c (assemble_start_function): Same.
+
+2019-05-16 Martin Sebor <msebor@redhat.com>
+
+ * config/i386/i386-expand.c (get_element_number): Quote keywords
+ and other internal names in diagnostics. Adjust other diagnostic
+ formatting issues noted by -Wformat-diag.
+ * config/i386/i386-features.c
+ (ix86_mangle_function_version_assembler_name): Same.
+ * config/i386/i386-options.c (ix86_handle_abi_attribute): Same.
+ * config/i386/i386.c (ix86_function_type_abi): Same.
+ (ix86_function_ms_hook_prologue): Same.
+ (classify_argument): Same.
+ (ix86_expand_prologue): Same.
+ (ix86_md_asm_adjust): Same.
+ (ix86_memmodel_check): Same.
+
2019-05-17 Dragan Mladjenovic <dmladjenovic@wavecomp.com>
* config/mips/mips.c (mips_dwarf_frame_reg_mode): Replace
+2019-05-16 Martin Sebor <msebor@redhat.com>
+
+ * gcc-interface/trans.c (check_inlining_for_nested_subprog): Quote
+ reserved names.
+
2019-05-08 Arnaud Charlet <charlet@adacore.com>
* standard.ads.h: New file.
if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (parent_decl)))
{
- error_at (loc1, "subprogram %q+F not marked Inline_Always", fndecl);
+ error_at (loc1, "subprogram %q+F not marked %<Inline_Always%>",
+ fndecl);
error_at (loc2, "parent subprogram cannot be inlined");
}
else
{
- warning_at (loc1, OPT_Winline, "subprogram %q+F not marked Inline",
+ warning_at (loc1, OPT_Winline, "subprogram %q+F not marked %<Inline%>",
fndecl);
warning_at (loc2, OPT_Winline, "parent subprogram cannot be inlined");
}
+2019-05-16 Martin Sebor <msebor@redhat.com>
+
+ * brigfrontend/brig-control-handler.cc
+ (brig_directive_control_handler::operator): Remove trailing newline
+ from a diagnostic.
+ * brigfrontend/brig-module-handler.cc
+ (brig_directive_module_handler::operator): Remove a duplicated space
+ from a diagnostic.
+
2019-01-01 Jakub Jelinek <jakub@redhat.com>
Update copyright years.
/* Unimplemented. */
break;
default:
- sorry ("Unsupported control directive %x.\n", inst->control);
+ sorry ("Unsupported control directive %x.", inst->control);
}
return base->byteCount;
}
const BrigDirectiveModule* mod = (const BrigDirectiveModule*)base;
m_parent.m_module_name = m_parent.get_string (mod->name).substr (1);
if (mod->hsailMajor != 1 || mod->hsailMinor != 0)
- fatal_error (UNKNOWN_LOCATION, PHSA_ERROR_PREFIX_INCOMPATIBLE_MODULE " "
+ fatal_error (UNKNOWN_LOCATION, PHSA_ERROR_PREFIX_INCOMPATIBLE_MODULE
"HSAIL version not supported. HSAIL 1.0 required.");
if (mod->machineModel != BRIG_MACHINE_LARGE)
- fatal_error (UNKNOWN_LOCATION, PHSA_ERROR_PREFIX_INCOMPATIBLE_MODULE " "
+ fatal_error (UNKNOWN_LOCATION, PHSA_ERROR_PREFIX_INCOMPATIBLE_MODULE
"Only HSA 'large' machine model supported.");
/* Do not check for the profile as the runtime conformance suite tests
with 'full' profile BRIGs even though they don't use any full profile
if (TREE_CODE (arg0) != INTEGER_CST)
{
- error ("non-constant argument 1 to __atomic_always_lock_free");
+ error ("non-constant argument 1 to %qs", "__atomic_always_lock_free");
return const0_rtx;
}
if (!INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
{
- error ("non-integer argument 1 to __atomic_is_lock_free");
+ error ("non-integer argument 1 to %qs", "__atomic_is_lock_free");
return NULL_RTX;
}
if (!stdarg_p (fntype))
{
- error ("%<va_start%> used in function with fixed args");
+ error ("%<va_start%> used in function with fixed arguments");
return true;
}
+2019-05-16 Martin Sebor <msebor@redhat.com>
+
+ * c-attribs.c (handle_no_sanitize_attribute): Quote identifiers,
+ keywords, operators, and types in diagnostics.
+ (handle_scalar_storage_order_attribute): Same.
+ (handle_mode_attribute): Same.
+ (handle_visibility_attribute): Same.
+ (handle_assume_aligned_attribute): Same.
+ (handle_no_split_stack_attribute): Same.
+ * c-common.c (shorten_compare): Same.
+ (c_common_truthvalue_conversion): Same.
+ (cb_get_source_date_epoch): Same.
+ * c-lex.c (cb_def_pragma): Quote keywords, operators, and types
+ in diagnostics.
+ (interpret_float): Same.
+ * c-omp.c (c_finish_omp_for): Same.
+ * c-opts.c (c_common_post_options): Same.
+ * c-pch.c (c_common_pch_pragma): Same.
+ * c-pragma.c (pop_alignment): Same.
+ (handle_pragma_pack): Same.
+ (apply_pragma_weak): Same.
+ (handle_pragma_weak): Same.
+ (handle_pragma_scalar_storage_order): Same.
+ (handle_pragma_redefine_extname): Same.
+ (add_to_renaming_pragma_list): Same.
+ (maybe_apply_renaming_pragma): Same.
+ (push_visibility): Same.
+ (handle_pragma_visibility): Same.
+ (handle_pragma_optimize): Same.
+ (handle_pragma_message): Same.
+ * c-warn.c (warn_for_omitted_condop): Same.
+ (lvalue_error): Same.
+
2019-05-15 Richard Biener <rguenther@suse.de>
PR c/90474
tree id = TREE_VALUE (args);
if (TREE_CODE (id) != STRING_CST)
{
- error ("no_sanitize argument not a string");
+ error ("%qE argument not a string", name);
return NULL_TREE;
}
if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN)
{
- error ("scalar_storage_order is not supported because endianness "
- "is not uniform");
+ error ("%qE attribute is not supported because endianness is not uniform",
+ name);
return NULL_TREE;
}
reverse = BYTES_BIG_ENDIAN;
else
{
- error ("scalar_storage_order argument must be one of \"big-endian\""
- " or \"little-endian\"");
+ error ("attribute %qE argument must be one of %qs or %qs",
+ name, "big-endian", "little-endian");
return NULL_TREE;
}
case MODE_VECTOR_ACCUM:
case MODE_VECTOR_UACCUM:
warning (OPT_Wattributes, "specifying vector types with "
- "__attribute__ ((mode)) is deprecated");
- warning (OPT_Wattributes,
- "use __attribute__ ((vector_size)) instead");
+ "%<__attribute__ ((mode))%> is deprecated");
+ inform (input_location,
+ "use %<__attribute__ ((vector_size))%> instead");
valid_mode = vector_mode_valid_p (mode);
break;
vis = VISIBILITY_PROTECTED;
else
{
- error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
+ error ("attribute %qE argument must be one of %qs, %qs, %qs, or %qs",
+ name, "default", "hidden", "protected", "internal");
vis = VISIBILITY_DEFAULT;
}
/* The misalignment specified by the second argument
must be non-negative and less than the alignment. */
warning (OPT_Wattributes,
- "%qE attribute argument %E is not in the range [0, %E)",
- name, val, align);
+ "%qE attribute argument %E is not in the range [0, %wu]",
+ name, val, tree_to_uhwi (align) - 1);
*no_add_attrs = true;
return NULL_TREE;
}
else if (DECL_INITIAL (decl))
{
error_at (DECL_SOURCE_LOCATION (decl),
- "can%'t set %qE attribute after definition", name);
+ "cannot set %qE attribute after definition", name);
*no_add_attrs = true;
}
else
else if (DECL_INITIAL (decl))
{
error_at (DECL_SOURCE_LOCATION (decl),
- "can%'t set %qE attribute after definition", name);
+ "cannot set %qE attribute after definition", name);
*no_add_attrs = true;
}
struct attribute_spec.handler. */
static tree
-handle_returns_nonnull_attribute (tree *node, tree, tree, int,
+handle_returns_nonnull_attribute (tree *node, tree name, tree, int,
bool *no_add_attrs)
{
// Even without a prototype we still have a return type we can check.
if (TREE_CODE (TREE_TYPE (*node)) != POINTER_TYPE)
{
- error ("returns_nonnull attribute on a function not returning a pointer");
+ error ("%qE attribute on a function not returning a pointer", name);
*no_add_attrs = true;
}
return NULL_TREE;
case GE_EXPR:
if (warn)
warning_at (loc, OPT_Wtype_limits,
- "comparison of unsigned expression >= 0 is always true");
+ "comparison of unsigned expression in %<>= 0%> "
+ "is always true");
value = truthvalue_true_node;
break;
case LT_EXPR:
if (warn)
warning_at (loc, OPT_Wtype_limits,
- "comparison of unsigned expression < 0 is always false");
+ "comparison of unsigned expression in %<< 0%> "
+ "is always false");
value = truthvalue_false_node;
break;
if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
&& !TYPE_UNSIGNED (TREE_TYPE (expr)))
warning_at (EXPR_LOCATION (expr), OPT_Wint_in_bool_context,
- "%<<<%> in boolean context, did you mean %<<%> ?");
+ "%<<<%> in boolean context, did you mean %<<%>?");
break;
case COND_EXPR:
&& (!integer_onep (val1)
|| !integer_onep (val2)))
warning_at (EXPR_LOCATION (expr), OPT_Wint_in_bool_context,
- "?: using integer constants in boolean context, "
+ "%<?:%> using integer constants in boolean context, "
"the expression will always evaluate to %<true%>");
else if ((TREE_CODE (val1) == INTEGER_CST
&& !integer_zerop (val1)
&& !integer_zerop (val2)
&& !integer_onep (val2)))
warning_at (EXPR_LOCATION (expr), OPT_Wint_in_bool_context,
- "?: using integer constants in boolean context");
+ "%<?:%> using integer constants in boolean context");
}
/* Distribute the conversion into the arms of a COND_EXPR. */
if (c_dialect_cxx ())
if (errno != 0 || endptr == source_date_epoch || *endptr != '\0'
|| epoch < 0 || epoch > MAX_SOURCE_DATE_EPOCH)
{
- error_at (input_location, "environment variable SOURCE_DATE_EPOCH must "
+ error_at (input_location, "environment variable %qs must "
"expand to a non-negative integer less than or equal to %wd",
- MAX_SOURCE_DATE_EPOCH);
+ "SOURCE_DATE_EPOCH", MAX_SOURCE_DATE_EPOCH);
return (time_t) -1;
}
name = cpp_token_as_text (pfile, s);
}
- warning_at (fe_loc, OPT_Wunknown_pragmas, "ignoring #pragma %s %s",
+ warning_at (fe_loc, OPT_Wunknown_pragmas, "ignoring %<#pragma %s %s%>",
space, name);
}
}
if (((flags & CPP_N_HEX) == 0) && ((flags & CPP_N_IMAGINARY) == 0))
{
warning (OPT_Wunsuffixed_float_constants,
- "unsuffixed float constant");
+ "unsuffixed floating constant");
if (float_const_decimal64_p ())
flags |= CPP_N_DFLOAT;
}
{
error_at (elocus,
"increment is not constant 1 or "
- "-1 for != condition");
+ "-1 for %<!=%> condition");
fail = true;
}
}
{
error_at (elocus,
"increment is not constant 1 or -1 for"
- " != condition");
+ " %<!=%> condition");
fail = true;
}
}
warn_return_type = 1;
if (num_in_fnames > 1)
- error ("too many filenames given. Type %s --help for usage",
- progname);
+ error ("too many filenames given; type %<%s %s%> for usage",
+ progname, "--help");
if (flag_preprocess_only)
{
debug formats we warn here and refuse to load any PCH files. */
if (write_symbols != NO_DEBUG && write_symbols != DWARF2_DEBUG)
warning (OPT_Wdeprecated,
- "the \"%s\" debug format cannot be used with "
+ "the %qs debug format cannot be used with "
"pre-compiled headers", debug_type_names[write_symbols]);
}
else if (write_symbols != NO_DEBUG && write_symbols != DWARF2_DEBUG)
f = fopen (pch_file, "w+b");
if (f == NULL)
- fatal_error (input_location, "can%'t create precompiled header %s: %m",
+ fatal_error (input_location, "cannot create precompiled header %s: %m",
pch_file);
pch_outfile = f;
|| fwrite (executable_checksum, 16, 1, f) != 1
|| fwrite (&v, sizeof (v), 1, f) != 1
|| fwrite (target_validity, v.target_data_length, 1, f) != 1)
- fatal_error (input_location, "can%'t write to %s: %m", pch_file);
+ fatal_error (input_location, "cannot write to %s: %m", pch_file);
/* Let the debugging format deal with the PCHness. */
(*debug_hooks->handle_pch) (0);
if (fseek (pch_outfile, 0, SEEK_SET) != 0
|| fwrite (get_ident (), IDENT_LENGTH, 1, pch_outfile) != 1)
- fatal_error (input_location, "can%'t write %s: %m", pch_file);
+ fatal_error (input_location, "cannot write %s: %m", pch_file);
fclose (pch_outfile);
sizeread = read (fd, ident, IDENT_LENGTH + 16);
if (sizeread == -1)
- fatal_error (input_location, "can%'t read %s: %m", name);
+ fatal_error (input_location, "cannot read %s: %m", name);
else if (sizeread != IDENT_LENGTH + 16)
{
if (cpp_get_options (pfile)->warn_invalid_pch)
executable, so it ought to be long enough that we can read a
c_pch_validity structure. */
if (read (fd, &v, sizeof (v)) != sizeof (v))
- fatal_error (input_location, "can%'t read %s: %m", name);
+ fatal_error (input_location, "cannot read %s: %m", name);
/* The allowable debug info combinations are that either the PCH file
was built with the same as is being used now, or the PCH file was
if ((size_t) read (fd, this_file_data, v.target_data_length)
!= v.target_data_length)
- fatal_error (input_location, "can%'t read %s: %m", name);
+ fatal_error (input_location, "cannot read %s: %m", name);
msg = targetm.pch_valid_p (this_file_data, v.target_data_length);
free (this_file_data);
if (msg != NULL)
if (!cpp_get_options (pfile)->preprocessed)
{
- error ("pch_preprocess pragma should only be used "
+ error ("%<pch_preprocess%> pragma should only be used "
"with %<-fpreprocessed%>");
- inform (input_location, "use #include instead");
+ inform (input_location, "use %<#include%> instead");
return;
}
align_stack * entry;
if (alignment_stack == NULL)
- GCC_BAD ("#pragma pack (pop) encountered without matching #pragma pack (push)");
+ GCC_BAD ("%<#pragma pack (pop)%> encountered without matching "
+ "%<#pragma pack (push)%>");
/* If we got an identifier, strip away everything above the target
entry so that the next step will restore the state just below it. */
break;
}
if (entry == NULL)
- warning (OPT_Wpragmas, "\
-#pragma pack(pop, %E) encountered without matching #pragma pack(push, %E)"
+ warning (OPT_Wpragmas,
+ "%<#pragma pack(pop, %E)%> encountered without matching "
+ "%<#pragma pack(push, %E)%>"
, id, id);
}
warning (OPT_Wpragmas, "junk at end of %<#pragma pack%>");
if (flag_pack_struct)
- GCC_BAD ("#pragma pack has no effect with %<-fpack-struct%> - ignored");
+ GCC_BAD ("%<#pragma pack%> has no effect with %<-fpack-struct%> - ignored");
if (action != pop)
switch (align)
&& !DECL_WEAK (decl) /* Don't complain about a redundant #pragma. */
&& DECL_ASSEMBLER_NAME_SET_P (decl)
&& TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
- warning (OPT_Wpragmas, "applying #pragma weak %q+D after first use "
+ warning (OPT_Wpragmas, "applying %<#pragma weak %+D%> after first use "
"results in unspecified behavior", decl);
declare_weak (decl);
value = 0;
if (pragma_lex (&name) != CPP_NAME)
- GCC_BAD ("malformed #pragma weak, ignored");
+ GCC_BAD ("malformed %<#pragma weak%>, ignored");
t = pragma_lex (&x);
if (t == CPP_EQ)
{
if (pragma_lex (&value) != CPP_NAME)
- GCC_BAD ("malformed #pragma weak, ignored");
+ GCC_BAD ("%<malformed #pragma weak%>, ignored");
t = pragma_lex (&x);
}
if (t != CPP_EOF)
if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN)
{
- error ("scalar_storage_order is not supported because endianness "
+ error ("%<scalar_storage_order%> is not supported because endianness "
"is not uniform");
return;
}
bool found;
if (pragma_lex (&oldname) != CPP_NAME)
- GCC_BAD ("malformed #pragma redefine_extname, ignored");
+ GCC_BAD ("malformed %<#pragma redefine_extname%>, ignored");
if (pragma_lex (&newname) != CPP_NAME)
- GCC_BAD ("malformed #pragma redefine_extname, ignored");
+ GCC_BAD ("malformed %<#pragma redefine_extname%>, ignored");
t = pragma_lex (&x);
if (t != CPP_EOF)
warning (OPT_Wpragmas, "junk at end of %<#pragma redefine_extname%>");
name = targetm.strip_name_encoding (name);
if (!id_equal (newname, name))
- warning (OPT_Wpragmas, "#pragma redefine_extname ignored due to "
- "conflict with previous rename");
+ warning (OPT_Wpragmas, "%<#pragma redefine_extname%> "
+ "ignored due to conflict with previous rename");
}
else
symtab->change_decl_assembler_name (decl, newname);
if (oldname == p->oldname)
{
if (p->newname != newname)
- warning (OPT_Wpragmas, "#pragma redefine_extname ignored due to "
- "conflict with previous #pragma redefine_extname");
+ warning (OPT_Wpragmas, "%<#pragma redefine_extname%> ignored due to "
+ "conflict with previous %<#pragma redefine_extname%>");
return;
}
oldname = targetm.strip_name_encoding (oldname);
if (asmname && strcmp (TREE_STRING_POINTER (asmname), oldname))
- warning (OPT_Wpragmas, "asm declaration ignored due to "
+ warning (OPT_Wpragmas, "%<asm%> declaration ignored due to "
"conflict with previous rename");
/* Take any pending redefine_extname off the list. */
{
/* Only warn if there is a conflict. */
if (!id_equal (p->newname, oldname))
- warning (OPT_Wpragmas, "#pragma redefine_extname ignored due to "
- "conflict with previous rename");
+ warning (OPT_Wpragmas, "%<#pragma redefine_extname%> ignored "
+ "due to conflict with previous rename");
pending_redefine_extname->unordered_remove (ix);
break;
{
if (strcmp (TREE_STRING_POINTER (asmname),
IDENTIFIER_POINTER (newname)) != 0)
- warning (OPT_Wpragmas, "#pragma redefine_extname ignored due to "
- "conflict with __asm__ declaration");
+ warning (OPT_Wpragmas, "%<#pragma redefine_extname%> ignored "
+ "due to conflict with %<asm%> declaration");
return asmname;
}
else if (!strcmp (str, "protected"))
default_visibility = VISIBILITY_PROTECTED;
else
- GCC_BAD ("#pragma GCC visibility push() must specify default, internal, hidden or protected");
+ GCC_BAD ("%<#pragma GCC visibility push()%> must specify %<default%>, "
+ "%<internal%>, %<hidden%> or %<protected%>");
visibility_options.inpragma = 1;
}
action = pop;
}
if (bad == action)
- GCC_BAD ("#pragma GCC visibility must be followed by push or pop");
+ GCC_BAD ("%<#pragma GCC visibility%> must be followed by %<push%> "
+ "or %<pop%>");
else
{
if (pop == action)
GCC_BAD ("missing %<(%> after %<#pragma GCC visibility push%> - ignored");
token = pragma_lex (&x);
if (token != CPP_NAME)
- GCC_BAD ("malformed #pragma GCC visibility push");
+ GCC_BAD ("malformed %<#pragma GCC visibility push%>");
else
push_visibility (IDENTIFIER_POINTER (x), 0);
if (pragma_lex (&x) != CPP_CLOSE_PAREN)
if (cfun)
{
- error ("#pragma GCC option is not allowed inside functions");
+ error ("%<#pragma GCC option%> is not allowed inside functions");
return;
}
if (token != CPP_EOF)
{
- error ("#pragma GCC target string... is badly formed");
+ error ("%<#pragma GCC target%> string is badly formed");
return;
}
if (cfun)
{
- error ("#pragma GCC optimize is not allowed inside functions");
+ error ("%<#pragma GCC optimize%> is not allowed inside functions");
return;
}
if (token != CPP_EOF)
{
- error ("#pragma GCC optimize string... is badly formed");
+ error ("%<#pragma GCC optimize%> string is badly formed");
return;
}
warning (OPT_Wpragmas, "junk at end of %<#pragma message%>");
if (TREE_STRING_LENGTH (message) > 1)
- inform (input_location, "#pragma message: %s", TREE_STRING_POINTER (message));
+ inform (input_location, "%<#pragma message: %s%>",
+ TREE_STRING_POINTER (message));
}
/* Mark whether the current location is valid for a STDC pragma. */
|| (TREE_TYPE (cond) != NULL_TREE
&& TREE_CODE (TREE_TYPE (cond)) == BOOLEAN_TYPE))
warning_at (location, OPT_Wparentheses,
- "the omitted middle operand in ?: will always be %<true%>, "
+ "the omitted middle operand in %<?:%> will always be %<true%>, "
"suggest explicit middle operand");
}
error_at (loc, "lvalue required as unary %<&%> operand");
break;
case lv_asm:
- error_at (loc, "lvalue required in asm statement");
+ error_at (loc, "lvalue required in %<asm%> statement");
break;
default:
gcc_unreachable ();
C ObjC C++ ObjC++ Var(warn_format_contains_nul) Warning LangEnabledBy(C ObjC C++ ObjC++,Wformat=, warn_format >= 1, 0)
Warn about format strings that contain NUL bytes.
+Wformat-diag
+C ObjC C++ ObjC++ Var(warn_format_diag) Warning LangEnabledBy(C ObjC C++ ObjC++,Wformat=, warn_format >= 1, 0)
+Warn about GCC format strings with strings unsuitable for diagnostics..
+
Wformat-extra-args
C ObjC C++ ObjC++ Var(warn_format_extra_args) Warning LangEnabledBy(C ObjC C++ ObjC++,Wformat=, warn_format >= 1, 0)
Warn if passing too many arguments to a function for its format string.
+2019-05-16 Martin Sebor <msebor@redhat.com>
+
+ * c-decl.c (start_decl): Quote keywords, operators, and
+ types in diagnostics.
+ (finish_decl): Same.
+ * c-parser.c (c_parser_asm_statement): Same.
+ (c_parser_conditional_expression): Same.
+ (c_parser_transaction_cancel): Same.
+ * c-typeck.c (c_common_type): Same.
+ (build_conditional_expr): Same.
+ (digest_init): Same.
+ (process_init_element): Same.
+ (build_binary_op): Same.
+
2019-05-17 Richard Biener <rguenther@suse.de>
* gimple-parser.c (c_parser_gimple_statement): Handle __VEC_PERM.
if (TREE_CHAIN (t) == NULL_TREE
&& TYPE_MAIN_VARIANT (type) != void_type_node)
{
- inform (input_location, "a parameter list with an ellipsis can%'t match "
- "an empty parameter name list declaration");
+ inform (input_location, "a parameter list with an ellipsis "
+ "cannot match an empty parameter name list declaration");
break;
}
if (c_type_promotes_to (type) != type)
{
- inform (input_location, "an argument type that has a default promotion can%'t match "
- "an empty parameter name list declaration");
+ inform (input_location, "an argument type that has a default "
+ "promotion cannot match an empty parameter name list "
+ "declaration");
break;
}
}
switch (TREE_CODE (decl))
{
case TYPE_DECL:
- error ("typedef %qD is initialized (use __typeof__ instead)", decl);
+ error ("typedef %qD is initialized (use %<__typeof__%> instead)", decl);
initialized = false;
break;
&& VAR_P (decl)
&& !C_DECL_REGISTER (decl)
&& !TREE_STATIC (decl))
- warning (0, "ignoring asm-specifier for non-static local "
+ warning (0, "ignoring %<asm%> specifier for non-static local "
"variable %q+D", decl);
else
set_user_assembler_name (decl, asmspec);
if (name)
pedwarn_c90 (input_location, OPT_Wvla,
"ISO C90 forbids array %qE whose size "
- "can%'t be evaluated", name);
+ "cannot be evaluated", name);
else
pedwarn_c90 (input_location, OPT_Wvla, "ISO C90 forbids array "
- "whose size can%'t be evaluated");
+ "whose size cannot be evaluated");
}
else
{
case RID_VOLATILE:
if (volatile_loc)
{
- error_at (loc, "duplicate asm qualifier %qE", token->value);
+ error_at (loc, "duplicate %<asm%> qualifier %qE", token->value);
inform (volatile_loc, "first seen here");
}
else
case RID_INLINE:
if (inline_loc)
{
- error_at (loc, "duplicate asm qualifier %qE", token->value);
+ error_at (loc, "duplicate %<asm%> qualifier %qE", token->value);
inform (inline_loc, "first seen here");
}
else
case RID_GOTO:
if (goto_loc)
{
- error_at (loc, "duplicate asm qualifier %qE", token->value);
+ error_at (loc, "duplicate %<asm%> qualifier %qE", token->value);
inform (goto_loc, "first seen here");
}
else
case RID_CONST:
case RID_RESTRICT:
- error_at (loc, "%qE is not an asm qualifier", token->value);
+ error_at (loc, "%qE is not a valid %<asm%> qualifier", token->value);
c_parser_consume_token (parser);
continue;
location_t middle_loc = c_parser_peek_token (parser)->location;
pedwarn (middle_loc, OPT_Wpedantic,
- "ISO C forbids omitting the middle term of a ?: expression");
+ "ISO C forbids omitting the middle term of a %<?:%> expression");
if (TREE_CODE (cond.value) == EXCESS_PRECISION_EXPR)
{
eptype = TREE_TYPE (cond.value);
&& !is_tm_may_cancel_outer (current_function_decl))
{
error_at (loc, "outer %<__transaction_cancel%> not "
- "within outer %<__transaction_atomic%>");
- error_at (loc, " or a %<transaction_may_cancel_outer%> function");
+ "within outer %<__transaction_atomic%> or "
+ "a %<transaction_may_cancel_outer%> function");
goto ret_error;
}
}
{
if (code1 == VECTOR_TYPE || code2 == VECTOR_TYPE)
{
- error ("can%'t mix operands of decimal float and vector types");
+ error ("cannot mix operands of decimal floating and vector types");
return error_mark_node;
}
if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
{
- error ("can%'t mix operands of decimal float and complex types");
+ error ("cannot mix operands of decimal floating and complex types");
return error_mark_node;
}
if (code1 == REAL_TYPE && code2 == REAL_TYPE)
{
- error ("can%'t mix operands of decimal float and other float types");
+ error ("cannot mix operands of decimal floating "
+ "and other floating types");
return error_mark_node;
}
}
/* OK */;
else if (unsigned_op2)
warning_at (op1_loc, OPT_Wsign_compare,
- "operand of ?: changes signedness from "
+ "operand of %<?:%> changes signedness from "
"%qT to %qT due to unsignedness of other "
"operand", TREE_TYPE (orig_op1),
TREE_TYPE (orig_op2));
else
warning_at (op2_loc, OPT_Wsign_compare,
- "operand of ?: changes signedness from "
+ "operand of %<?:%> changes signedness from "
"%qT to %qT due to unsignedness of other "
"operand", TREE_TYPE (orig_op2),
TREE_TYPE (orig_op1));
that is counted in the length of the constant. */
if (compare_tree_int (TYPE_SIZE_UNIT (type), len - unit) < 0)
pedwarn_init (init_loc, 0,
- ("initializer-string for array of chars "
- "is too long"));
+ ("initializer-string for array of %qT "
+ "is too long"), typ1);
else if (warn_cxx_compat
&& compare_tree_int (TYPE_SIZE_UNIT (type), len) < 0)
warning_at (init_loc, OPT_Wc___compat,
- ("initializer-string for array chars "
- "is too long for C++"));
+ ("initializer-string for array of %qT "
+ "is too long for C++"), typ1);
if (compare_tree_int (TYPE_SIZE_UNIT (type), len) < 0)
{
unsigned HOST_WIDE_INT size
&& integer_zerop (constructor_unfilled_index))
{
if (constructor_stack->replacement_value.value)
- error_init (loc, "excess elements in char array initializer");
+ error_init (loc, "excess elements in %<char%> array initializer");
constructor_stack->replacement_value = value;
return;
}
if (FLOAT_TYPE_P (type0) || FLOAT_TYPE_P (type1))
warning_at (location,
OPT_Wfloat_equal,
- "comparing floating point with == or != is unsafe");
+ "comparing floating point with %<==%> or %<!=%> is unsafe");
/* Result of comparison is always int,
but don't convert the args to int! */
build_type = integer_type_node;
{
if (lookup_attribute ("naked",
DECL_ATTRIBUTES (current_function_decl)))
- error ("cannot allocate stack for variable %q+D, naked function.",
+ error ("cannot allocate stack for variable %q+D, naked function",
var);
expand_one_stack_var (origvar);
if (overlap)
{
- error ("asm-specifier for variable %qE conflicts with asm clobber list",
+ error ("%<asm%> specifier for variable %qE conflicts with "
+ "%<asm%> clobber list",
DECL_NAME (overlap));
/* Reset registerness to stop multiple errors emitted for a single
if (allows_reg && TYPE_MODE (type) != BLKmode)
op = force_reg (TYPE_MODE (type), op);
else if (!allows_mem)
- warning (0, "asm operand %d probably doesn%'t match constraints",
+ warning (0, "%<asm%> operand %d probably does not match "
+ "constraints",
i + noutputs);
else if (MEM_P (op))
{
tripping over the under-construction body. */
for (unsigned k = 0; k < noutputs; ++k)
if (reg_overlap_mentioned_p (clobbered_reg, output_rvec[k]))
- internal_error ("asm clobber conflict with output operand");
+ internal_error ("%<asm%> clobber conflict with "
+ "output operand");
for (unsigned k = 0; k < ninputs - ninout; ++k)
if (reg_overlap_mentioned_p (clobbered_reg, input_rvec[k]))
- internal_error ("asm clobber conflict with input operand");
+ internal_error ("%<asm%> clobber conflict with "
+ "input operand");
}
XVECEXP (body, 0, i++) = gen_rtx_CLOBBER (VOIDmode, clobbered_reg);
/* redefining extern inline function makes it DECL_UNINLINABLE. */
&& !DECL_UNINLINABLE (decl))
warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wattributes,
- "always_inline function might not be inlinable");
-
+ "%<always_inline%> function might not be inlinable");
+
process_common_attributes (node, decl);
}
for (vnode = symtab->first_variable (); vnode != first_var;
int status;
if (!pex_get_status (pex, 1, &status))
- fatal_error (input_location, "can%'t get program status: %m");
+ fatal_error (input_location, "cannot get program status: %m");
pex_free (pex);
if (response_file && !save_temps)
pex = pex_init (0, "collect2", NULL);
if (pex == NULL)
- fatal_error (input_location, "pex_init failed: %m");
+ fatal_error (input_location, "%<pex_init%> failed: %m");
errmsg = pex_run (pex, flags, argv[0], argv, outname,
errname, &err);
size_t num_files;
if (!lto_wrapper)
- fatal_error (input_location, "COLLECT_LTO_WRAPPER must be set");
+ fatal_error (input_location, "environment variable "
+ "%<COLLECT_LTO_WRAPPER%> must be set");
num_lto_c_args++;
stream = fopen (list_filename, "r");
if (stream == NULL)
- fatal_error (input_location, "can%'t open %s: %m",
+ fatal_error (input_location, "cannot open %s: %m",
list_filename);
while (fgets (buf, sizeof buf, stream) != NULL)
return true;
if (errmsg)
- fatal_error (0, "%s: %s\n", errmsg, xstrerror (err));
+ fatal_error (0, "%s: %s", errmsg, xstrerror (err));
return false;
}
pex = pex_init (PEX_USE_PIPES, "collect2", NULL);
if (pex == NULL)
- fatal_error (input_location, "pex_init failed: %m");
+ fatal_error (input_location, "%<pex_init%> failed: %m");
errmsg = pex_run (pex, 0, nm_file_name, real_nm_argv, NULL, HOST_BIT_BUCKET,
&err);
inf = pex_read_output (pex, 0);
if (inf == NULL)
- fatal_error (input_location, "can%'t open nm output: %m");
+ fatal_error (input_location, "cannot open nm output: %m");
if (debug)
fprintf (stderr, "\nnm output with constructors/destructors.\n");
inf = pex_read_output (pex, 0);
if (inf == NULL)
- fatal_error (input_location, "can%'t open ldd output: %m");
+ fatal_error (input_location, "cannot open ldd output: %m");
if (debug)
notice ("\nldd output with constructors/destructors.\n");
enum aarch64_parse_opt_result res =
aarch64_parse_branch_protection (const_str, &str);
if (res == AARCH64_PARSE_INVALID_ARG)
- error ("invalid arg %<%s%> for %<-mbranch-protection=%>", str);
+ error ("invalid argument %<%s%> for %<-mbranch-protection=%>", str);
else if (res == AARCH64_PARSE_MISSING_ARG)
- error ("missing arg for %<-mbranch-protection=%>");
+ error ("missing argument for %<-mbranch-protection=%>");
free (str);
return res == AARCH64_PARSE_OK;
}
if (fndecl
&& (lookup_attribute ("interrupt",
TYPE_ATTRIBUTES (TREE_TYPE (fndecl)))))
- error ("interrupt service routine can%'t be called directly");
+ error ("interrupt service routine cannot be called directly");
}
else
fndecl = NULL_TREE;
if (!tree_fits_uhwi_p (arg)
|| (elt = tree_to_uhwi (arg), elt > max))
{
- error ("selector must be an integer constant in the range 0..%wi", max);
+ error ("selector must be an integer constant in the range "
+ "[0, %wi]", max);
return 0;
}
&& lookup_attribute ("gnu_inline",
DECL_ATTRIBUTES (decl)))
error_at (DECL_SOURCE_LOCATION (decl),
- "function versions cannot be marked as gnu_inline,"
+ "function versions cannot be marked as %<gnu_inline%>,"
" bodies have to be generated");
if (DECL_VIRTUAL_P (decl)
{
if (lookup_attribute ("sysv_abi", TYPE_ATTRIBUTES (*node)))
{
- error ("ms_abi and sysv_abi attributes are not compatible");
+ error ("%qs and %qs attributes are not compatible",
+ "ms_abi", "sysv_abi");
}
return NULL_TREE;
{
if (lookup_attribute ("ms_abi", TYPE_ATTRIBUTES (*node)))
{
- error ("ms_abi and sysv_abi attributes are not compatible");
+ error ("%qs and %qs attributes are not compatible",
+ "ms_abi", "sysv_abi");
}
return NULL_TREE;
error ("interrupt service routine can only have a pointer argument "
"and an optional integer argument");
if (! VOID_TYPE_P (return_type))
- error ("interrupt service routine can%'t have non-void return value");
+ error ("interrupt service routine must return %<void%>");
return NULL_TREE;
}
static int warned;
if (TARGET_X32 && !warned)
{
- error ("X32 does not support ms_abi attribute");
+ error ("X32 does not support %<ms_abi%> attribute");
warned = 1;
}
{
if (decl_function_context (fn) != NULL_TREE)
error_at (DECL_SOURCE_LOCATION (fn),
- "ms_hook_prologue is not compatible with nested function");
+ "%<ms_hook_prologue%> attribute is not compatible "
+ "with nested function");
else
return true;
}
{
warned = true;
inform (input_location,
- "the ABI of passing union with long double"
+ "the ABI of passing union with %<long double%>"
" has changed in GCC 4.4");
}
return 0;
{
warned = true;
inform (input_location,
- "the ABI of passing structure with complex float"
+ "the ABI of passing structure with %<complex float%>"
" member has changed in GCC 4.4");
}
classes[1] = X86_64_SSESF_CLASS;
/* Check if profiling is active and we shall use profiling before
prologue variant. If so sorry. */
if (crtl->profile && flag_fentry != 0)
- sorry ("ms_hook_prologue attribute isn%'t compatible "
+ sorry ("%<ms_hook_prologue%> attribute is not compatible "
"with %<-mfentry%> for 32-bit");
/* In ix86_asm_output_function_label we emitted:
con += 4;
if (strchr (con, ',') != NULL)
{
- error ("alternatives not allowed in asm flag output");
+ error ("alternatives not allowed in %<asm%> flag output");
continue;
}
}
if (code == UNKNOWN)
{
- error ("unknown asm flag output %qs", constraints[i]);
+ error ("unknown %<asm%> flag output %qs", constraints[i]);
continue;
}
if (invert)
machine_mode dest_mode = GET_MODE (dest);
if (!SCALAR_INT_MODE_P (dest_mode))
{
- error ("invalid type for asm flag output");
+ error ("invalid type for %<asm%> flag output");
continue;
}
if (val & IX86_HLE_ACQUIRE && !(is_mm_acquire (model) || strong))
{
warning (OPT_Winvalid_memory_model,
- "HLE_ACQUIRE not used with ACQUIRE or stronger memory model");
+ "%<HLE_ACQUIRE%> not used with %<ACQUIRE%> or stronger "
+ "memory model");
return MEMMODEL_SEQ_CST | IX86_HLE_ACQUIRE;
}
if (val & IX86_HLE_RELEASE && !(is_mm_release (model) || strong))
{
warning (OPT_Winvalid_memory_model,
- "HLE_RELEASE not used with RELEASE or stronger memory model");
+ "%<HLE_RELEASE%> not used with %<RELEASE%> or stronger "
+ "memory model");
return MEMMODEL_SEQ_CST | IX86_HLE_RELEASE;
}
return val;
case POINTER_TYPE:
case REFERENCE_TYPE:
- error ("pointer value used where a floating point value was expected");
+ error ("pointer value used where a floating point was expected");
return convert_to_real_1 (type, integer_zero_node, fold_p);
default:
- error ("aggregate value used where a float was expected");
+ error ("aggregate value used where a floating point was expected");
return convert_to_real_1 (type, integer_zero_node, fold_p);
}
}
case VECTOR_TYPE:
if (!tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (expr))))
{
- error ("can%'t convert a vector of type %qT"
+ error ("cannot convert a vector of type %qT"
" to type %qT which has different size",
TREE_TYPE (expr), type);
return error_mark_node;
case VECTOR_TYPE:
if (!tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (expr))))
{
- error ("can%'t convert a value of type %qT"
+ error ("cannot convert a value of type %qT"
" to vector type %qT which has different size",
TREE_TYPE (expr), type);
return error_mark_node;
return build1 (VIEW_CONVERT_EXPR, type, expr);
default:
- error ("can%'t convert value to a vector");
+ error ("cannot convert value to a vector");
return error_mark_node;
}
}
+2019-05-16 Martin Sebor <msebor@redhat.com>
+
+ * call.c (print_z_candidate): Wrap diagnostic text in a gettext
+ macro. Adjust.
+ (print_z_candidates): Same.
+ (build_conditional_expr_1): Quote keywords, operators, and types
+ in diagnostics.
+ (build_op_delete_call): Same.
+ (maybe_print_user_conv_context): Wrap diagnostic text in a gettext
+ macro.
+ (convert_like_real): Same.
+ (convert_arg_to_ellipsis): Quote keywords, operators, and types
+ in diagnostics.
+ (build_over_call): Same.
+ (joust): Break up an overlong line. Wrap diagnostic text in a gettext
+ macro.
+ * constexpr.c (cxx_eval_check_shift_p): Spell out >= in English.
+ (cxx_eval_constant_expression): Quote keywords, operators, and types
+ in diagnostics.
+ (potential_constant_expression_1): Same.
+ * cp-gimplify.c (cp_genericize_r): Same.
+ * cvt.c (maybe_warn_nodiscard): Quote keywords, operators, and types
+ in diagnostics.
+ (type_promotes_to): Same.
+ * decl.c (check_previous_goto_1): Same.
+ (check_goto): Same.
+ (start_decl): Same.
+ (cp_finish_decl): Avoid parenthesizing a sentence for consistency.
+ (grok_op_properties): Quote keywords, operators, and types
+ in diagnostics.
+ * decl2.c (grokfield): Same.
+ (coerce_delete_type): Same.
+ * except.c (is_admissible_throw_operand_or_catch_parameter): Same.
+ * friend.c (do_friend): Quote C++ tokens.
+ * init.c (build_new_1): Quote keywords, operators, and types
+ in diagnostics.
+ (build_vec_delete_1): Same.
+ (build_delete): Same.
+ * lex.c (parse_strconst_pragma): Same.
+ (handle_pragma_implementation): Same.
+ (unqualified_fn_lookup_error): Same.
+ * mangle.c (write_type): Same.
+ * method.c (defaulted_late_check): Avoid two consecutive punctuators.
+ * name-lookup.c (cp_binding_level_debug): Remove a trailing newline.
+ (pop_everything): Same.
+ * parser.c (cp_lexer_start_debugging): Quote a macro name.
+ in a diagnostic
+ (cp_lexer_stop_debugging): Same.
+ (cp_parser_userdef_numeric_literal): Quote a C++ header name
+ in a diagnostic.
+ (cp_parser_nested_name_specifier_opt): Quote keywords, operators,
+ and types in diagnostics.
+ (cp_parser_question_colon_clause): Same.
+ (cp_parser_asm_definition): Same.
+ (cp_parser_init_declarator): Same.
+ (cp_parser_template_declaration_after_parameters): Avoid capitalizing
+ a sentence in a diagnostic.
+ (cp_parser_omp_declare_reduction): Quote keywords, operators, and types
+ in diagnostics.
+ (cp_parser_transaction): Same.
+ * pt.c (maybe_process_partial_specialization): Replace second call
+ to permerror with inform for consistency with other uses.
+ (expand_integer_pack): Quote keywords, operators, and types
+ in diagnostics.
+ * rtti.c (get_typeid): Quote keywords, operators, and types
+ in diagnostics.
+ (build_dynamic_cast_1): Same.
+ * semantics.c (finish_asm_stmt): Same.
+ (finish_label_decl): Same.
+ (finish_bases): Same.
+ (finish_offsetof): Same.
+ (cp_check_omp_declare_reduction): Same.
+ (finish_decltype_type): Same.
+ * tree.c (handle_init_priority_attribute): Same. Add detail
+ to diagnostics.
+ (maybe_warn_zero_as_null_pointer_constant): Same.
+ * typeck.c (cp_build_binary_op): Quote keywords, operators, and types
+ in diagnostics.
+ (cp_build_unary_op): Same.
+ (check_for_casting_away_constness): Same.
+ (build_static_cast): Same.
+ (build_const_cast_1): Same.
+ (maybe_warn_about_returning_address_of_local): Same.
+ (check_return_expr): Same.
+ * typeck2.c (abstract_virtuals_error_sfinae): Same.
+ (digest_init_r): Replace a tab with spaces in a diagnostic.
+ (build_functional_cast): Quote keywords, operators, and types
+ in diagnostics.
+
2019-05-15 Jakub Jelinek <jakub@redhat.com>
PR debug/90197
{
const char *msg = (msgstr == NULL
? ""
- : ACONCAT ((msgstr, " ", NULL)));
+ : ACONCAT ((_(msgstr), " ", NULL)));
tree fn = candidate->fn;
if (flag_new_inheriting_ctors)
fn = strip_inheriting_ctors (fn);
{
cloc = loc;
if (candidate->num_convs == 3)
- inform (cloc, "%s%<%D(%T, %T, %T)%> <built-in>", msg, fn,
+ inform (cloc, "%s%<%D(%T, %T, %T)%> (built-in)", msg, fn,
candidate->convs[0]->type,
candidate->convs[1]->type,
candidate->convs[2]->type);
else if (candidate->num_convs == 2)
- inform (cloc, "%s%<%D(%T, %T)%> <built-in>", msg, fn,
+ inform (cloc, "%s%<%D(%T, %T)%> (built-in)", msg, fn,
candidate->convs[0]->type,
candidate->convs[1]->type);
else
- inform (cloc, "%s%<%D(%T)%> <built-in>", msg, fn,
+ inform (cloc, "%s%<%D(%T)%> (built-in)", msg, fn,
candidate->convs[0]->type);
}
else if (TYPE_P (fn))
- inform (cloc, "%s%qT <conversion>", msg, fn);
+ inform (cloc, "%s%qT (conversion)", msg, fn);
else if (candidate->viable == -1)
- inform (cloc, "%s%#qD <near match>", msg, fn);
+ inform (cloc, "%s%#qD (near match)", msg, fn);
else if (DECL_DELETED_FN (fn))
- inform (cloc, "%s%#qD <deleted>", msg, fn);
+ inform (cloc, "%s%#qD (deleted)", msg, fn);
else
inform (cloc, "%s%#qD", msg, fn);
if (fn != candidate->fn)
}
for (; candidates; candidates = candidates->next)
- print_z_candidate (loc, "candidate:", candidates);
+ print_z_candidate (loc, N_("candidate:"), candidates);
}
/* USER_SEQ is a user-defined conversion sequence, beginning with a
{
if (complain & tf_error)
pedwarn (loc, OPT_Wpedantic,
- "ISO C++ forbids omitting the middle term of a ?: expression");
+ "ISO C++ forbids omitting the middle term of "
+ "a %<?:%> expression");
if ((complain & tf_warning) && !truth_value_p (TREE_CODE (arg1)))
warn_for_omitted_condop (loc, arg1);
{
if (complain & tf_error)
{
- error_at (loc, "operands to ?: have different types %qT and %qT",
+ error_at (loc, "operands to %<?:%> have different types "
+ "%qT and %qT",
arg2_type, arg3_type);
if (conv2 && !conv2->bad_p && conv3 && !conv3->bad_p)
inform (loc, " and each type can be converted to the other");
if (!any_viable_p)
{
if (complain & tf_error)
- error_at (loc, "operands to ?: have different types %qT and %qT",
+ error_at (loc, "operands to %<?:%> have different types %qT and %qT",
arg2_type, arg3_type);
return error_mark_node;
}
if (!result_type)
{
if (complain & tf_error)
- error_at (loc, "operands to ?: have different types %qT and %qT",
+ error_at (loc, "operands to %<?:%> have different types %qT and %qT",
arg2_type, arg3_type);
return error_mark_node;
}
{
const char *const msg1
= G_("exception cleanup for this placement new selects "
- "non-placement operator delete");
+ "non-placement %<operator delete%>");
const char *const msg2
= G_("%qD is a usual (non-placement) deallocation "
- "function in C++14 (or with -fsized-deallocation)");
+ "function in C++14 (or with %<-fsized-deallocation%>)");
/* But if the class has an operator delete (void *), then that is
the usual deallocation function, so we shouldn't complain
for (conversion *t = convs; t; t = next_conversion (t))
if (t->kind == ck_user)
{
- print_z_candidate (0, " after user-defined conversion:",
+ print_z_candidate (0, N_(" after user-defined conversion:"),
t->cand);
break;
}
"from %qH to %qI", TREE_TYPE (expr),
totype);
if (complained)
- print_z_candidate (loc, "candidate is:", t->cand);
+ print_z_candidate (loc, N_("candidate is:"), t->cand);
expr = convert_like_real (t, expr, fn, argnum,
/*issue_conversion_warnings=*/false,
/*c_cast_p=*/false,
if (abi_version_crosses (6)
&& TYPE_MODE (TREE_TYPE (prom)) != TYPE_MODE (arg_type)
&& (complain & tf_warning))
- warning_at (loc, OPT_Wabi, "scoped enum %qT passed through ... as "
- "%qT before %<-fabi-version=6%>, %qT after", arg_type,
+ warning_at (loc, OPT_Wabi, "scoped enum %qT passed through %<...%>"
+ "as %qT before %<-fabi-version=6%>, %qT after",
+ arg_type,
TREE_TYPE (prom), ENUM_UNDERLYING_TYPE (arg_type));
if (!abi_version_at_least (6))
arg = prom;
if (is_std_init_list (type)
&& conv_binds_ref_to_prvalue (convs[1]))
warning_at (loc, OPT_Winit_list_lifetime,
- "assignment from temporary initializer_list does not "
- "extend the lifetime of the underlying array");
+ "assignment from temporary %<initializer_list%> does "
+ "not extend the lifetime of the underlying array");
arg = cp_build_fold_indirect_ref (arg);
val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg);
}
&& warning (OPT_Wconversion, " for conversion from %qH to %qI",
source, w->second_conv->type))
{
- inform (input_location, " because conversion sequence for the argument is better");
+ inform (input_location, " because conversion sequence "
+ "for the argument is better");
}
}
else
"though the worst conversion for the first is "
"better than the worst conversion for the second:"))
{
- print_z_candidate (input_location, _("candidate 1:"), w);
- print_z_candidate (input_location, _("candidate 2:"), l);
+ print_z_candidate (input_location, N_("candidate 1:"), w);
+ print_z_candidate (input_location, N_("candidate 2:"), l);
}
}
else
if (compare_tree_int (rhs, uprec) >= 0)
{
if (!ctx->quiet)
- permerror (loc, "right operand of shift expression %q+E is >= than "
- "the precision of the left operand",
- build2_loc (loc, code, type, lhs, rhs));
+ permerror (loc, "right operand of shift expression %q+E is greater "
+ "than or equal to the precision %wu of the left operand",
+ build2_loc (loc, code, type, lhs, rhs), uprec);
return (!flag_permissive || ctx->quiet);
}
if (!ctx->quiet)
error_at (cp_expr_loc_or_loc (t, input_location),
"%<constexpr%> evaluation operation count exceeds limit of "
- "%wd (use -fconstexpr-ops-limit= to increase the limit)",
+ "%wd (use %<-fconstexpr-ops-limit=%> to increase the limit)",
constexpr_ops_limit);
*ctx->constexpr_ops_count = INTTYPE_MINIMUM (HOST_WIDE_INT);
*non_constant_p = true;
{
if (!ctx->quiet)
error_at (cp_expr_loc_or_loc (t, input_location),
- "a reinterpret_cast is not a constant expression");
+ "%<reinterpret_cast%> is not a constant expression");
*non_constant_p = true;
return t;
}
if (REINTERPRET_CAST_P (t))
{
if (flags & tf_error)
- error_at (loc, "a reinterpret_cast is not a constant expression");
+ error_at (loc, "%<reinterpret_cast%> is not a constant expression");
return false;
}
/* FALLTHRU */
&& !integer_zerop (from))
{
if (flags & tf_error)
- error_at (loc, "reinterpret_cast from integer to pointer");
+ error_at (loc,
+ "%<reinterpret_cast%> from integer to pointer");
return false;
}
}
/* In C++2a virtual calls can be constexpr, don't give up yet. */
return true;
else if (flags & tf_error)
- error_at (loc, "virtual functions cannot be constexpr before C++2a");
+ error_at (loc,
+ "virtual functions cannot be %<constexpr%> before C++2a");
return false;
case TYPEID_EXPR:
&& TYPE_POLYMORPHIC_P (TREE_TYPE (e)))
{
if (flags & tf_error)
- error_at (loc, "typeid-expression is not a constant expression "
+ error_at (loc, "%<typeid%> is not a constant expression "
"because %qE is of polymorphic type", e);
return false;
}
{
auto_diagnostic_group d;
if (warning_at (loc, OPT_Wterminate,
- "throw will always call terminate()")
+ "%<throw%> will always call %<terminate%>")
&& cxx_dialect >= cxx11
&& DECL_DESTRUCTOR_P (current_function_decl))
- inform (loc, "in C++11 destructors default to noexcept");
+ inform (loc, "in C++11 destructors default to %<noexcept%>");
}
}
else
&& (get_defaulted_eh_spec (current_function_decl)
== empty_except_spec))
warning_at (loc, OPT_Wc__11_compat,
- "in C++11 this throw will terminate because "
- "destructors default to noexcept");
+ "in C++11 this %<throw%> will call %<terminate%> "
+ "because destructors default to %<noexcept%>");
}
}
break;
if (!COMPLETE_TYPE_P (intype))
{
if (complain & tf_error)
- error_at (loc, "can%'t convert from incomplete type %qH to %qI",
+ error_at (loc, "cannot convert from incomplete type %qH to %qI",
intype, type);
return error_mark_node;
}
auto_diagnostic_group d;
if (warning_at (loc, OPT_Wunused_result,
"ignoring return value of %qD, "
- "declared with attribute warn_unused_result",
+ "declared with attribute %<warn_unused_result%>",
fn))
inform (DECL_SOURCE_LOCATION (fn), "declared here");
}
else
warning_at (loc, OPT_Wunused_result,
"ignoring return value of function "
- "declared with attribute warn_unused_result");
+ "declared with attribute %<warn_unused_result%>");
}
}
if (TREE_CODE (cand) == TEMPLATE_DECL)
{
if (complain)
- error ("default type conversion can%'t deduce template"
+ error ("default type conversion cannot deduce template"
" argument for %qD", cand);
return error_mark_node;
}
{
if (abi_version_crosses (6)
&& TYPE_MODE (prom) != TYPE_MODE (type))
- warning (OPT_Wabi, "scoped enum %qT passed through ... as "
+ warning (OPT_Wabi, "scoped enum %qT passed through %<...%> as "
"%qT before %<-fabi-version=6%>, %qT after",
type, prom, ENUM_UNDERLYING_TYPE (type));
if (!abi_version_at_least (6))
{
case sk_try:
if (!saw_eh)
- inf = N_("enters try block");
+ inf = G_(" enters %<try%> block");
saw_eh = true;
break;
case sk_catch:
if (!saw_eh)
- inf = N_("enters catch block");
+ inf = G_(" enters %<catch%> block");
saw_eh = true;
break;
case sk_omp:
if (!saw_omp)
- inf = N_("enters OpenMP structured block");
+ inf = G_(" enters OpenMP structured block");
saw_omp = true;
break;
case sk_transaction:
if (!saw_tm)
- inf = N_("enters synchronized or atomic statement");
+ inf = G_(" enters synchronized or atomic statement");
saw_tm = true;
break;
case sk_block:
if (!saw_cxif && level_for_constexpr_if (b->level_chain))
{
- inf = N_("enters constexpr if statement");
+ inf = G_(" enters %<constexpr if%> statement");
loc = EXPR_LOCATION (b->level_chain->this_entity);
saw_cxif = true;
}
complained = identify_goto (decl, input_location, locus, DK_ERROR);
identified = 2;
if (complained)
- inform (loc, " %s", inf);
+ inform (loc, inf);
}
}
identified = 2;
}
if (complained)
- inform (DECL_SOURCE_LOCATION (bad), " enters catch block");
+ inform (DECL_SOURCE_LOCATION (bad), " enters %<catch%> block");
saw_catch = true;
}
else if (complained)
if (complained)
{
if (ent->in_try_scope)
- inform (input_location, " enters try block");
+ inform (input_location, " enters %<try%> block");
else if (ent->in_catch_scope && !saw_catch)
- inform (input_location, " enters catch block");
+ inform (input_location, " enters %<catch%> block");
else if (ent->in_transaction_scope)
inform (input_location, " enters synchronized or atomic statement");
else if (ent->in_constexpr_if)
- inform (input_location, " enters %<constexpr%> if statement");
+ inform (input_location, " enters %<constexpr if%> statement");
}
if (ent->in_omp_scope)
&& TREE_CODE (decl) == TYPE_DECL)
{
error_at (DECL_SOURCE_LOCATION (decl),
- "typedef %qD is initialized (use decltype instead)", decl);
+ "typedef %qD is initialized (use %qs instead)",
+ decl, "decltype");
return error_mark_node;
}
return;
if (TREE_CODE (type) == FUNCTION_TYPE)
{
- error ("initializer for %<decltype(auto) %D%> has function type "
- "(did you forget the %<()%> ?)", decl);
+ error ("initializer for %<decltype(auto) %D%> has function type; "
+ "did you forget the %<()%>?", decl);
TREE_TYPE (decl) = error_mark_node;
return;
}
error ("friend declaration not in class definition");
if (current_function_decl && funcdef_flag)
{
- error ("can%'t define friend function %qs in a local "
+ error ("cannot define friend function %qs in a local "
"class definition", name);
friendp = 0;
}
if (operator_code == COND_EXPR)
{
/* 13.4.0.3 */
- error_at (loc, "ISO C++ prohibits overloading operator ?:");
+ error_at (loc, "ISO C++ prohibits overloading %<operator ?:%>");
return false;
}
if (TREE_CODE (value) == TYPE_DECL && init)
{
error_at (cp_expr_loc_or_loc (init, DECL_SOURCE_LOCATION (value)),
- "typedef %qD is initialized (use decltype instead)", value);
+ "typedef %qD is initialized (use %qs instead)",
+ value, "decltype");
init = NULL_TREE;
}
else
/* A destroying operator delete shall be a class member function named
operator delete. */
- error_at (loc, "destroying operator delete must be a member function");
+ error_at (loc,
+ "destroying %<operator delete%> must be a member function");
const ovl_op_info_t *op = IDENTIFIER_OVL_OP_INFO (DECL_NAME (decl));
if (op->flags & OVL_OP_FLAG_VEC)
- error_at (loc, "operator delete[] cannot be a destroying delete");
+ error_at (loc, "%<operator delete[]%> cannot be a destroying delete");
if (!usual_deallocation_fn_p (decl))
- error_at (loc, "destroying operator delete must be a usual "
+ error_at (loc, "destroying %<operator delete%> must be a usual "
"deallocation function");
}
&& TYPE_REF_P (type)
&& TYPE_REF_IS_RVALUE (type))
{
- error ("cannot declare catch parameter to be of rvalue "
+ error ("cannot declare %<catch%> parameter to be of rvalue "
"reference type %qT", type);
return false;
}
"%q#D declares a non-template function", decl);
if (! explained && warned)
{
- inform (input_location, "(if this is not what you intended, make sure "
- "the function template has already been declared "
- "and add <> after the function name here) ");
+ inform (input_location, "(if this is not what you intended, "
+ "make sure the function template has already been "
+ "declared and add %<<>%> after the function name "
+ "here)");
explained = 1;
}
}
pedwarn (cp_expr_loc_or_loc (outer_nelts, input_location), OPT_Wvla,
typedef_variant_p (orig_type)
? G_("non-constant array new length must be specified "
- "directly, not by typedef")
+ "directly, not by %<typedef%>")
: G_("non-constant array new length must be specified "
"without parentheses around the type-id"));
}
if (VOID_TYPE_P (elt_type))
{
if (complain & tf_error)
- error ("invalid type %<void%> for new");
+ error ("invalid type %<void%> for %<new%>");
return error_mark_node;
}
if (is_std_init_list (elt_type))
warning (OPT_Winit_list_lifetime,
- "%<new%> of initializer_list does not "
+ "%<new%> of %<initializer_list%> does not "
"extend the lifetime of the underlying array");
if (abstract_virtuals_error_sfinae (ACU_NEW, elt_type, complain))
auto_diagnostic_group d;
if (warning (OPT_Wdelete_incomplete,
"possible problem detected in invocation of "
- "delete [] operator:"))
+ "operator %<delete []%>"))
{
cxx_incomplete_type_diagnostic (base, type, DK_WARNING);
inform (input_location, "neither the destructor nor the "
- "class-specific operator delete [] will be called, "
+ "class-specific operator %<delete []%> will be called, "
"even if they are declared when the class is defined");
}
}
{
auto_diagnostic_group d;
if (warning (OPT_Wdelete_incomplete,
- "possible problem detected in invocation of "
- "delete operator:"))
+ "possible problem detected in invocation of "
+ "%<operator delete%>"))
{
cxx_incomplete_type_diagnostic (addr, type, DK_WARNING);
inform (input_location,
- "neither the destructor nor the class-specific "
- "operator delete will be called, even if they "
- "are declared when the class is defined");
+ "neither the destructor nor the class-specific "
+ "%<operator delete%> will be called, even if "
+ "they are declared when the class is defined");
}
}
}
if (t == CPP_STRING)
{
if (pragma_lex (&x) != CPP_EOF)
- warning (0, "junk at end of #pragma %s", name);
+ warning (0, "junk at end of %<#pragma %s%>", name);
return result;
}
if (t == CPP_EOF && opt)
return NULL_TREE;
- error ("invalid #pragma %s", name);
+ error ("invalid %<#pragma %s%>", name);
return error_mark_node;
}
handle_pragma_vtable (cpp_reader* /*dfile*/)
{
parse_strconst_pragma ("vtable", 0);
- sorry ("#pragma vtable no longer supported");
+ sorry ("%<#pragma vtable%> no longer supported");
}
static void
{
filename = TREE_STRING_POINTER (fname);
if (cpp_included_before (parse_in, filename, input_location))
- warning (0, "#pragma implementation for %qs appears after "
+ warning (0, "%<#pragma implementation%> for %qs appears after "
"file is included", filename);
}
if (!hint)
{
inform (loc, "(if you use %<-fpermissive%>, G++ will accept your "
- "code, but allowing the use of an undeclared name is "
- "deprecated)");
+ "code, but allowing the use of an undeclared name is "
+ "deprecated)");
hint = true;
}
}
break;
case TYPEOF_TYPE:
- sorry ("mangling typeof, use decltype instead");
+ sorry ("mangling %<typeof%>, use %<decltype%> instead");
break;
case UNDERLYING_TYPE:
- sorry ("mangling __underlying_type");
+ sorry ("mangling %<__underlying_type%>");
break;
case LANG_TYPE:
if (CP_TYPE_CONST_P (expr_type))
{
- error ("non-static const member %q#D, can%'t use default "
+ error ("non-static const member %q#D, cannot use default "
"assignment operator", field);
continue;
}
else if (TYPE_REF_P (expr_type))
{
- error ("non-static reference member %q#D, can%'t use "
+ error ("non-static reference member %q#D, cannot use "
"default assignment operator", field);
continue;
}
if (CP_TYPE_CONST_P (mem_type) && !CLASS_TYPE_P (mem_type))
{
if (diag)
- error ("non-static const member %q#D, can%'t use default "
+ error ("non-static const member %q#D, cannot use default "
"assignment operator", field);
}
else if (TYPE_REF_P (mem_type))
{
if (diag)
- error ("non-static reference member %q#D, can%'t use "
+ error ("non-static reference member %q#D, cannot use "
"default assignment operator", field);
}
else
if (!CLASSTYPE_TEMPLATE_INSTANTIATION (ctx))
{
error ("explicitly defaulted function %q+D cannot be declared "
- "as %<constexpr%> because the implicit declaration is not "
- "%<constexpr%>:", fn);
+ "%qs because the implicit declaration is not %qs:",
+ fn, "constexpr", "constexpr");
explain_implicit_non_constexpr (fn);
}
DECL_DECLARED_CONSTEXPR_P (fn) = false;
{
const char *desc = cp_binding_level_descriptor (scope);
if (scope->this_entity)
- verbatim ("%s %<%s(%E)%> %p %d\n", action, desc,
+ verbatim ("%s %<%s(%E)%> %p %d", action, desc,
scope->this_entity, (void *) scope, line);
else
- verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
+ verbatim ("%s %s %p %d", action, desc, (void *) scope, line);
}
/* A chain of binding_level structures awaiting reuse. */
pop_everything (void)
{
if (ENABLE_SCOPE_CHECKING)
- verbatim ("XXX entering pop_everything ()\n");
+ verbatim ("XXX entering %<pop_everything ()%>");
while (!namespace_bindings_p ())
{
if (current_binding_level->kind == sk_class)
poplevel (0, 0, 0);
}
if (ENABLE_SCOPE_CHECKING)
- verbatim ("XXX leaving pop_everything ()\n");
+ verbatim ("XXX leaving %<pop_everything ()%>");
}
/* Emit debugging information for using declarations and directives.
{
if (!LEXER_DEBUGGING_ENABLED_P)
fatal_error (input_location,
- "LEXER_DEBUGGING_ENABLED_P is not set to true");
+ "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true");
lexer->debugging_p = true;
cp_lexer_debug_stream = stderr;
{
if (!LEXER_DEBUGGING_ENABLED_P)
fatal_error (input_location,
- "LEXER_DEBUGGING_ENABLED_P is not set to true");
+ "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true");
lexer->debugging_p = false;
cp_lexer_debug_stream = NULL;
else if (i14)
{
inform (token->location, "add %<using namespace std::complex_literals%> "
- "(from <complex>) to enable the C++14 user-defined literal "
+ "(from %<<complex>%>) to enable the C++14 user-defined literal "
"suffixes");
if (ext)
inform (token->location, "or use %<j%> instead of %<i%> for the "
== CPP_SCOPE))
{
token = cp_lexer_consume_token (parser->lexer);
- error_at (token->location, "decltype evaluates to %qT, "
+ error_at (token->location, "%<decltype%> evaluates to %qT, "
"which is not a class or enumeration type",
token->u.tree_check_value->value);
parser->scope = error_mark_node;
&& token->type == CPP_COLON)
{
pedwarn (token->location, OPT_Wpedantic,
- "ISO C++ does not allow ?: with omitted middle operand");
+ "ISO C++ does not allow %<?:%> with omitted middle operand");
/* Implicit true clause. */
expr = NULL_TREE;
c_inhibit_evaluation_warnings +=
{
if (cxx_dialect < cxx17)
pedwarn (input_location, OPT_Wpedantic,
- "static_assert without a message "
+ "%<static_assert%> without a message "
"only available with %<-std=c++17%> or %<-std=gnu++17%>");
/* Eat the ')' */
cp_lexer_consume_token (parser->lexer);
case RID_VOLATILE:
if (volatile_loc)
{
- error_at (loc, "duplicate asm qualifier %qT", token->u.value);
+ error_at (loc, "duplicate %<asm%> qualifier %qT",
+ token->u.value);
inform (volatile_loc, "first seen here");
}
else
{
if (!parser->in_function_body)
- warning_at (loc, 0, "asm qualifier %qT ignored outside of "
- "function body", token->u.value);
+ warning_at (loc, 0, "%<asm%> qualifier %qT ignored "
+ "outside of function body", token->u.value);
volatile_loc = loc;
}
cp_lexer_consume_token (parser->lexer);
case RID_INLINE:
if (inline_loc)
{
- error_at (loc, "duplicate asm qualifier %qT", token->u.value);
+ error_at (loc, "duplicate %<asm%> qualifier %qT",
+ token->u.value);
inform (inline_loc, "first seen here");
}
else
case RID_GOTO:
if (goto_loc)
{
- error_at (loc, "duplicate asm qualifier %qT", token->u.value);
+ error_at (loc, "duplicate %<asm%> qualifier %qT",
+ token->u.value);
inform (goto_loc, "first seen here");
}
else
case RID_CONST:
case RID_RESTRICT:
- error_at (loc, "%qT is not an asm qualifier", token->u.value);
+ error_at (loc, "%qT is not an %<asm%> qualifier", token->u.value);
cp_lexer_consume_token (parser->lexer);
continue;
if (!parser->in_function_body && (inline_p || goto_p))
{
- error_at (first_loc, "asm qualifier outside of function body");
+ error_at (first_loc, "%<asm%> qualifier outside of function body");
inline_p = goto_p = false;
}
on a function-definition. */
if (asm_specification)
error_at (asm_spec_start_token->location,
- "an asm-specification is not allowed "
+ "an %<asm%> specification is not allowed "
"on a function-definition");
if (attributes)
error_at (attributes_start_token->location,
{
if (cxx_dialect > cxx17)
error ("literal operator template %qD has invalid parameter list;"
- " Expected non-type template parameter pack <char...> "
+ " expected non-type template parameter pack %<<char...>%> "
"or single non-type parameter of class type",
decl);
else
- error ("literal operator template %qD has invalid parameter list."
- " Expected non-type template parameter pack <char...>",
+ error ("literal operator template %qD has invalid parameter list;"
+ " expected non-type template parameter pack %<<char...>%>",
decl);
}
}
error_at (loc, "reference type %qT in "
"%<#pragma omp declare reduction%>", type);
else if (TYPE_QUALS_NO_ADDR_SPACE (type))
- error_at (loc, "const, volatile or __restrict qualified type %qT in "
- "%<#pragma omp declare reduction%>", type);
+ error_at (loc, "%<const%>, %<volatile%> or %<__restrict%>-qualified "
+ "type %qT in %<#pragma omp declare reduction%>", type);
else
types.safe_push (type);
else if (keyword == RID_ATOMIC_CANCEL)
{
/* cancel-and-throw is unimplemented. */
- sorry ("atomic_cancel");
+ sorry ("%<atomic_cancel%>");
noex = NULL_TREE;
}
else
if (current_namespace
!= decl_namespace_context (tmpl))
{
- permerror (input_location,
- "specializing %q#T in different namespace", type);
- permerror (DECL_SOURCE_LOCATION (tmpl),
- " from definition of %q#D", tmpl);
+ if (permerror (input_location,
+ "specialization of %qD in different namespace",
+ type))
+ inform (DECL_SOURCE_LOCATION (tmpl),
+ "from definition of %q#D", tmpl);
}
/* Check for invalid specialization after instantiation:
{
if ((complain & tf_error)
&& hi != error_mark_node)
- error ("argument to __integer_pack must be between 0 and %d", max);
+ error ("argument to %<__integer_pack%> must be between 0 and %d",
+ max);
return error_mark_node;
}
if (name)
inform (loc, " %qD", name);
else
- inform (loc, " <anonymous>");
+ inform (loc, "
%s", "<anonymous>");
parameter_packs = TREE_CHAIN (parameter_packs);
}
{
if (explain_p)
inform (input_location,
- " can%'t deduce a template for %qT from non-template type %qT",
+ " cannot deduce a template for %qT from non-template type %qT",
parm, arg);
return unify_invalid (explain_p);
}
if (repo_file == 0)
{
- error ("can%'t create repository information file %qs", repo_name);
+ error ("cannot create repository information file %qs", repo_name);
flag_use_repository = 0;
}
|| type_memfn_rqual (type) != REF_QUAL_NONE))
{
if (complain & tf_error)
- error ("typeid of qualified function type %qT", type);
+ error ("%<typeid%> of qualified function type %qT", type);
return error_mark_node;
}
{
tree expr = throw_bad_cast ();
if (complain & tf_warning)
- warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
- old_expr, type);
+ warning (0, "%<dynamic_cast<%#T>(%#D)%> can never succeed",
+ type, old_expr);
/* Bash it to the expected type. */
TREE_TYPE (expr) = type;
return expr;
&& TREE_CODE (TREE_TYPE (op)) == RECORD_TYPE)
{
if (complain & tf_warning)
- warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
- op, type);
+ warning (0, "%<dynamic_cast<%#T>(%#D)%> can never succeed",
+ type, op);
retval = build_int_cst (type, 0);
return retval;
}
fail:
if (complain & tf_error)
- error ("cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)",
+ error ("cannot %<dynamic_cast%> %qE (of type %q#T) to type %q#T (%s)",
old_expr, TREE_TYPE (old_expr), type, errstr);
return error_mark_node;
}
resolve the overloading. */
if (TREE_TYPE (operand) == unknown_type_node)
{
- error ("type of asm operand %qE could not be determined",
+ error ("type of %<asm%> operand %qE could not be determined",
TREE_VALUE (t));
operand = error_mark_node;
}
{
if (!at_function_scope_p ())
{
- error ("__label__ declarations are only allowed in function scopes");
+ error ("%<__label__%> declarations are only allowed in function scopes");
return;
}
if (!processing_template_decl)
{
/* Parameter packs can only be used in templates */
- error ("Parameter pack __bases only valid in template declaration");
+ error ("parameter pack %<__bases%> only valid in template declaration");
return error_mark_node;
}
&& CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (object_ptr)))
&& CLASSTYPE_NON_STD_LAYOUT (TREE_TYPE (TREE_TYPE (object_ptr)))
&& cp_unevaluated_operand == 0)
- warning_at (loc, OPT_Winvalid_offsetof, "offsetof within "
+ warning_at (loc, OPT_Winvalid_offsetof, "%<offsetof%> within "
"non-standard-layout type %qT is conditionally-supported",
TREE_TYPE (TREE_TYPE (object_ptr)));
return fold_offsetof (expr);
}
else if (TYPE_QUALS_NO_ADDR_SPACE (type))
{
- error_at (loc, "const, volatile or __restrict qualified type %qT in "
- "%<#pragma omp declare reduction%>", type);
+ error_at (loc, "%<const%>, %<volatile%> or %<__restrict%>-qualified "
+ "type %qT in %<#pragma omp declare reduction%>", type);
return;
}
&& TYPE_P (TREE_OPERAND (expr, 0))))
{
if (complain & tf_error)
- error ("argument to decltype must be an expression");
+ error ("argument to %<decltype%> must be an expression");
return error_mark_node;
}
if (type_unknown_p (expr))
{
if (complain & tf_error)
- error ("decltype cannot resolve address of overloaded function");
+ error ("%<decltype%> cannot resolve address of overloaded function");
return error_mark_node;
}
if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
{
- error ("requested init_priority is not an integer constant");
+ error ("requested %<init_priority%> is not an integer constant");
cxx_constant_value (initp_expr);
*no_add_attrs = true;
return NULL_TREE;
if (pri > MAX_INIT_PRIORITY || pri <= 0)
{
- error ("requested init_priority is out of range");
+ error ("requested %<init_priority%> %i is out of range [0, %i]",
+ pri, MAX_INIT_PRIORITY);
*no_add_attrs = true;
return NULL_TREE;
}
if (pri <= MAX_RESERVED_INIT_PRIORITY)
{
warning
- (0, "requested init_priority is reserved for internal use");
+ (0, "requested %<init_priority%> %i is reserved for internal use",
+ pri);
}
if (SUPPORTS_INIT_PRIORITY)
void
lang_check_failed (const char* file, int line, const char* function)
{
- internal_error ("lang_* check: failed in %s, at %s:%d",
+ internal_error ("%<lang_*%> check: failed in %s, at %s:%d",
function, trim_filename (file), line);
}
#endif /* ENABLE_TREE_CHECKING */
&& c_inhibit_evaluation_warnings == 0
&& (FLOAT_TYPE_P (type0) || FLOAT_TYPE_P (type1)))
warning (OPT_Wfloat_equal,
- "comparing floating point with == or != is unsafe");
+ "comparing floating point with %<==%> or %<!=%> is unsafe");
if (complain & tf_warning)
{
tree stripped_orig_op0 = tree_strip_any_location_wrapper (orig_op0);
if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE
&& (complain & tf_warning)
&& warning_at (location, OPT_Wbool_operation,
- "%<~%> on an expression of type bool"))
+ "%<~%> on an expression of type %<bool%>"))
inform (location, "did you mean to use logical not (%<!%>)?");
arg = cp_perform_integral_promotions (arg, complain);
}
case STATIC_CAST_EXPR:
if (complain & tf_error)
- error ("static_cast from type %qT to type %qT casts away qualifiers",
+ error ("%<static_cast%> from type %qT to type %qT casts away "
+ "qualifiers",
src_type, dest_type);
return true;
case REINTERPRET_CAST_EXPR:
if (complain & tf_error)
- error ("reinterpret_cast from type %qT to type %qT casts away qualifiers",
+ error ("%<reinterpret_cast%> from type %qT to type %qT casts away "
+ "qualifiers",
src_type, dest_type);
return true;
if (complain & tf_error)
{
- error ("invalid static_cast from type %qT to type %qT",
+ error ("invalid %<static_cast%> from type %qT to type %qT",
TREE_TYPE (expr), type);
if ((TYPE_PTR_P (type) || TYPE_REF_P (type))
&& CLASS_TYPE_P (TREE_TYPE (type))
if (!INDIRECT_TYPE_P (dst_type) && !TYPE_PTRDATAMEM_P (dst_type))
{
if (complain & tf_error)
- error ("invalid use of const_cast with type %qT, "
+ error ("invalid use of %<const_cast%> with type %qT, "
"which is not a pointer, "
"reference, nor a pointer-to-data-member type", dst_type);
return error_mark_node;
if (TREE_CODE (TREE_TYPE (dst_type)) == FUNCTION_TYPE)
{
if (complain & tf_error)
- error ("invalid use of const_cast with type %qT, which is a pointer "
- "or reference to a function type", dst_type);
+ error ("invalid use of %<const_cast%> with type %qT, "
+ "which is a pointer or reference to a function type",
+ dst_type);
return error_mark_node;
}
else
{
if (complain & tf_error)
- error ("invalid const_cast of an rvalue of type %qT to type %qT",
+ error ("invalid %<const_cast%> of an rvalue of type %qT "
+ "to type %qT",
src_type, dst_type);
return error_mark_node;
}
}
if (complain & tf_error)
- error ("invalid const_cast from type %qT to type %qT",
+ error ("invalid %<const_cast%> from type %qT to type %qT",
src_type, dst_type);
return error_mark_node;
}
"returning reference to temporary");
else if (is_std_init_list (valtype))
warning_at (loc, OPT_Winit_list_lifetime,
- "returning temporary initializer_list does not extend "
+ "returning temporary %<initializer_list%> does not extend "
"the lifetime of the underlying array");
return true;
}
whats_returned);
else if (is_std_init_list (valtype))
w = warning_at (loc, OPT_Winit_list_lifetime,
- "returning local initializer_list variable %qD "
+ "returning local %<initializer_list%> variable %qD "
"does not extend the lifetime of the underlying array",
whats_returned);
else if (TREE_CODE (whats_returned) == LABEL_DECL)
&& ! flag_check_new
&& retval && null_ptr_cst_p (retval))
warning (0, "%<operator new%> must not return NULL unless it is "
- "declared %<throw()%> (or -fcheck-new is in effect)");
+ "declared %<throw()%> (or %<-fcheck-new%> is in effect)");
/* Effective C++ rule 15. See also start_function. */
if (warn_ecpp
"be used in throw-expression", type);
break;
case ACU_CATCH:
- error ("cannot declare catch parameter to be of abstract "
+ error ("cannot declare %<catch%> parameter to be of abstract "
"class type %qT", type);
break;
default:
FOR_EACH_VEC_ELT (*pure, ix, fn)
if (! DECL_CLONED_FUNCTION_P (fn)
|| DECL_COMPLETE_DESTRUCTOR_P (fn))
- inform (DECL_SOURCE_LOCATION (fn), "\t%#qD", fn);
+ inform (DECL_SOURCE_LOCATION (fn), " %#qD", fn);
/* Now truncate the vector. This leaves it non-null, so we know
there are pure virtuals, but empty so we don't list them out
be invalid. */
if (size < TREE_STRING_LENGTH (stripped_init))
{
- permerror (loc, "initializer-string for array "
- "of chars is too long");
+ permerror (loc, "initializer-string for %qT is too long",
+ type);
init = build_string (size,
TREE_STRING_POINTER (stripped_init));
if (type == error_mark_node)
{
if (complain & tf_error)
- error ("cannot deduce template arguments for %qT from ()",
+ error ("cannot deduce template arguments for %qT from %<()%>",
anode);
return error_mark_node;
}
+2019-05-16 Martin Sebor <msebor@redhat.com>
+
+ * d-builtins.cc (d_init_builtins): Quote keywords, operators,
+ and types in diagnostics.
+ * d-codegen.cc (get_array_length): Same. Replace can't with cannot.
+ * d-convert.cc (convert_expr): Same.
+ * d-frontend.cc (getTypeInfoType): Quote an option name in
+ a diagnostic.
+ * d-lang.cc (d_handle_option): Same.
+ (d_parse_file): Same.
+ * decl.cc: Remove a trailing period from a diagnostic.
+ * expr.cc: Use a directive for an apostrophe.
+ * toir.cc: Quote keywords, operators, and types in diagnostics.
+ * typeinfo.cc (build_typeinfo): Quote an option name in a diagnostic.
+
2019-04-25 Johannes Pfau <johannespfau@gmail.com>
* config-lang.in: Do not add target_libs if phobos is disabled.
Type::tvalist = build_frontend_type (va_list_type_node);
if (!Type::tvalist)
{
- error ("cannot represent built-in va_list type in D");
+ error ("cannot represent built-in %<va_list%> type in D");
gcc_unreachable ();
}
return d_array_length (exp);
default:
- error ("can't determine the length of a %qs", type->toChars ());
+ error ("cannot determine the length of a %qs", type->toChars ());
return error_mark_node;
}
}
}
else
{
- error ("can't convert a delegate expression to %qs",
+ error ("cannot convert a delegate expression to %qs",
totype->toChars ());
return error_mark_node;
}
}
else
{
- error ("can't convert struct %qs to %qs",
+ error ("cannot convert struct %qs to %qs",
etype->toChars (), totype->toChars ());
return error_mark_node;
}
if ((dim * esize) % tsize != 0)
{
- error ("cannot cast %qs to %qs since sizes don't line up",
+ error ("cannot cast %qs to %qs since sizes do not line up",
etype->toChars (), totype->toChars ());
return error_mark_node;
}
if (!warned)
{
error_at (make_location_t (loc),
- "%<object.TypeInfo%> cannot be used with -fno-rtti");
+ "%<object.TypeInfo%> cannot be used with %<-fno-rtti%>");
warned = 1;
}
}
break;
}
- error ("bad argument for -fdebug %qs", arg);
+ error ("bad argument for %<-fdebug%>: %qs", arg);
break;
case OPT_fdoc:
case OPT_fmodule_file_:
global.params.modFileAliasStrings->push (arg);
if (!strchr (arg, '='))
- error ("bad argument for -fmodule-file %qs", arg);
+ error ("bad argument for %<-fmodule-file%>: %qs", arg);
break;
case OPT_fmoduleinfo:
break;
}
- error ("bad argument for -fversion %qs", arg);
+ error ("bad argument for %<-fversion%>: %qs", arg);
break;
case OPT_H:
/* In this mode, the first file name is supposed to be a duplicate
of one of the input files. */
if (d_option.fonly && strcmp (d_option.fonly, main_input_filename) != 0)
- error ("-fonly= argument is different from first input file name");
+ error ("%<-fonly=%> argument is different from first input file name");
for (size_t i = 0; i < num_in_fnames; i++)
{
fd2->toPrettyChars ());
inform (make_location_t (d->loc),
"use %<alias %s = %s.%s;%> to introduce base class "
- "overload set.", fd->toChars (),
+ "overload set", fd->toChars (),
fd->parent->toChars (), fd->toChars ());
}
else
}
else
{
- error ("don't know how to delete %qs", e->e1->toChars ());
+ error ("don%'t know how to delete %qs", e->e1->toChars ());
this->result_ = error_mark_node;
}
}
}
if (ent->in_try_scope)
- error_at (make_location_t (from->loc), "cannot goto into try block");
+ error_at (make_location_t (from->loc),
+ "cannot %<goto%> into %<try%> block");
else if (ent->in_catch_scope)
- error_at (make_location_t (from->loc), "cannot goto into catch block");
+ error_at (make_location_t (from->loc),
+ "cannot %<goto%> into %<catch%> block");
}
/* Check that a previously seen jump to a newly defined label is valid.
{
location = make_location_t (fwdref->statement->loc);
if (b->kind == level_try)
- error_at (location, "cannot goto into try block");
+ error_at (location, "cannot %<goto%> into %<try%> block");
else
- error_at (location, "cannot goto into catch block");
+ error_at (location, "cannot %<goto%> into %<catch%> block");
}
else if (s->isCaseStatement ())
{
location = make_location_t (s->loc);
error_at (location, "case cannot be in different "
- "try block level from switch");
+ "%<try%> block level from %<switch%>");
}
else if (s->isDefaultStatement ())
{
location = make_location_t (s->loc);
error_at (location, "default cannot be in different "
- "try block level from switch");
+ "%<try%> block level from %<switch%>");
}
else
gcc_unreachable ();
static int warned = 0;
if (!warned)
{
- error_at (make_location_t (s->loc), "exception handling disabled, "
- "use -fexceptions to enable");
+ error_at (make_location_t (s->loc), "exception handling disabled; "
+ "use %<-fexceptions%> to enable");
warned = 1;
}
}
if (!warned)
{
error_at (make_location_t (loc),
- "%<object.TypeInfo%> cannot be used with -fno-rtti");
+ "%<object.TypeInfo%> cannot be used with %<-fno-rtti%>");
warned = 1;
}
}
function anymore. */
if (personality && current_unit_personality != personality)
sorry ("multiple EH personalities are supported only with assemblers "
- "supporting .cfi_personality directive");
+ "supporting %<.cfi_personality%> directive");
}
}
count_r++;
else
{
- error ("region_array is corrupted for region %i", r->index);
+ error ("%<region_array%> is corrupted for region %i", r->index);
err = true;
}
}
count_lp++;
else
{
- error ("lp_array is corrupted for lp %i", lp->index);
+ error ("%<lp_array%> is corrupted for lp %i", lp->index);
err = true;
}
}
{
if ((*fun->eh->region_array)[r->index] != r)
{
- error ("region_array is corrupted for region %i", r->index);
+ error ("%<region_array%> is corrupted for region %i", r->index);
err = true;
}
if (r->outer != outer)
{
if ((*fun->eh->lp_array)[lp->index] != lp)
{
- error ("lp_array is corrupted for lp %i", lp->index);
+ error ("%<lp_array%> is corrupted for lp %i", lp->index);
err = true;
}
if (lp->region != r)
}
if (count_r != nvisited_r)
{
- error ("region_array does not match region_tree");
+ error ("%<region_array%> does not match %<region_tree%>");
err = true;
}
if (count_lp != nvisited_lp)
{
- error ("lp_array does not match region_tree");
+ error ("%<lp_array%> does not match %<region_tree%>");
err = true;
}
if (err)
{
dump_eh_tree (stderr, fun);
- internal_error ("verify_eh_tree failed");
+ internal_error ("%qs failed", __func__);
}
}
\f
+2019-05-16 Martin Sebor <msebor@redhat.com>
+
+ * gfortranspec.c (append_arg): Spell out the word "argument."
+
2019-05-16 Jakub Jelinek <jakub@redhat.com>
PR fortran/90329
}
if (g77_newargc == newargsize)
- fatal_error (input_location, "overflowed output arg list for %qs",
+ fatal_error (input_location, "overflowed output argument list for %qs",
arg->orig_option_with_args_text);
g77_new_decoded_options[g77_newargc++] = *arg;
? PEX_RECORD_TIMES : 0),
progname, temp_filename);
if (pex == NULL)
- fatal_error (input_location, "pex_init failed: %m");
+ fatal_error (input_location, "%<pex_init%> failed: %m");
for (i = 0; i < n_commands; i++)
{
alloc_args ();
if (do_spec_2 (args, soft_matched_part) < 0)
- fatal_error (input_location, "error in args to spec function %qs", func);
+ fatal_error (input_location, "error in arguments to spec function %qs",
+ func);
/* argbuf_index is an index for the next argument to be inserted, and
so contains the count of the args already inserted. */
pex = pex_init (PEX_USE_PIPES, new_argv[0], NULL);
if (!pex)
- fatal_error (input_location, "pex_init failed: %m");
+ fatal_error (input_location, "%<pex_init%> failed: %m");
errmsg = pex_run (pex, pex_flags, new_argv[0],
CONST_CAST2 (char *const *, const char **, &new_argv[1]),
&& do_spec_2 (sysroot_suffix_spec, NULL) == 0)
{
if (argbuf.length () > 1)
- error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
+ error ("spec failure: more than one argument to "
+ "%<SYSROOT_SUFFIX_SPEC%>");
else if (argbuf.length () == 1)
target_sysroot_suffix = xstrdup (argbuf.last ());
}
&& do_spec_2 (sysroot_hdrs_suffix_spec, NULL) == 0)
{
if (argbuf.length () > 1)
- error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
+ error ("spec failure: more than one argument "
+ "to %<SYSROOT_HEADERS_SUFFIX_SPEC%>");
else if (argbuf.length () == 1)
target_sysroot_hdrs_suffix = xstrdup (argbuf.last ());
}
len = strlen (argv[0]);
if (len < 3 || strcmp (argv[0] + len - 3, ".gk") != 0)
fatal_error (input_location, "argument to %%:compare-debug-auxbase-opt "
- "does not end in .gk");
+ "does not end in %<.gk%>");
if (debug_auxbase_opt)
return debug_auxbase_opt;
ret = remove (name);
if (ret)
- fatal_error (input_location, "error in removing %s\n", name);
+ fatal_error (input_location, "error in removing %s", name);
return ret;
}
case 'w':
sscanf (optarg, "%d,%d", &w1, &w2);
if (w1 < 0 || w2 < 0)
- fatal_error (input_location, "weights need to be non-negative\n");
+ fatal_error (input_location, "weights need to be non-negative");
break;
default:
merge_usage ();
}
if (scale < 0.0)
- fatal_error (input_location, "scale needs to be non-negative\n");
+ fatal_error (input_location, "scale needs to be non-negative");
if (normalize_val != 0)
{
if (memory_request > MAX_GCSE_MEMORY)
{
warning (OPT_Wdisabled_optimization,
- "%s: %d basic blocks and %d registers; increase --param max-gcse-memory above %d",
+ "%s: %d basic blocks and %d registers; "
+ "increase %<--param max-gcse-memory%> above %d",
pass, n_basic_blocks_for_fn (cfun), max_reg_num (),
memory_request);
{
if (fwrite (&ptr, sizeof (void *), 1, state->f)
!= 1)
- fatal_error (input_location, "can%'t write PCH file: %m");
+ fatal_error (input_location, "cannot write PCH file: %m");
}
else
{
saving_htab->find_with_hash (ptr, POINTER_HASH (ptr));
if (fwrite (&new_ptr->new_addr, sizeof (void *), 1, state->f)
!= 1)
- fatal_error (input_location, "can%'t write PCH file: %m");
+ fatal_error (input_location, "cannot write PCH file: %m");
}
}
}
for (rt = gt_pch_scalar_rtab; *rt; rt++)
for (rti = *rt; rti->base != NULL; rti++)
if (fwrite (rti->base, rti->stride, 1, f) != 1)
- fatal_error (input_location, "can%'t write PCH file: %m");
+ fatal_error (input_location, "cannot write PCH file: %m");
/* Write out all the global pointers, after translation. */
write_pch_globals (gt_ggc_rtab, &state);
long o;
o = ftell (state.f) + sizeof (mmi);
if (o == -1)
- fatal_error (input_location, "can%'t get position in PCH file: %m");
+ fatal_error (input_location, "cannot get position in PCH file: %m");
mmi.offset = mmap_offset_alignment - o % mmap_offset_alignment;
if (mmi.offset == mmap_offset_alignment)
mmi.offset = 0;
mmi.offset += o;
}
if (fwrite (&mmi, sizeof (mmi), 1, state.f) != 1)
- fatal_error (input_location, "can%'t write PCH file: %m");
+ fatal_error (input_location, "cannot write PCH file: %m");
if (mmi.offset != 0
&& fseek (state.f, mmi.offset, SEEK_SET) != 0)
- fatal_error (input_location, "can%'t write padding to PCH file: %m");
+ fatal_error (input_location, "cannot write padding to PCH file: %m");
ggc_pch_prepare_write (state.d, state.f);
for (rt = gt_pch_scalar_rtab; *rt; rt++)
for (rti = *rt; rti->base != NULL; rti++)
if (fread (rti->base, rti->stride, 1, f) != 1)
- fatal_error (input_location, "can%'t read PCH file: %m");
+ fatal_error (input_location, "cannot read PCH file: %m");
/* Read in all the global pointers, in 6 easy loops. */
for (rt = gt_ggc_rtab; *rt; rt++)
for (i = 0; i < rti->nelt; i++)
if (fread ((char *)rti->base + rti->stride * i,
sizeof (void *), 1, f) != 1)
- fatal_error (input_location, "can%'t read PCH file: %m");
+ fatal_error (input_location, "cannot read PCH file: %m");
if (fread (&mmi, sizeof (mmi), 1, f) != 1)
- fatal_error (input_location, "can%'t read PCH file: %m");
+ fatal_error (input_location, "cannot read PCH file: %m");
result = host_hooks.gt_pch_use_address (mmi.preferred_base, mmi.size,
fileno (f), mmi.offset);
{
if (fseek (f, mmi.offset, SEEK_SET) != 0
|| fread (mmi.preferred_base, mmi.size, 1, f) != 1)
- fatal_error (input_location, "can%'t read PCH file: %m");
+ fatal_error (input_location, "cannot read PCH file: %m");
}
else if (fseek (f, mmi.offset + mmi.size, SEEK_SET) != 0)
- fatal_error (input_location, "can%'t read PCH file: %m");
+ fatal_error (input_location, "cannot read PCH file: %m");
ggc_pch_read (f, mmi.preferred_base);
}
if (fwrite (x, size, 1, f) != 1)
- fatal_error (input_location, "can%'t write PCH file: %m");
+ fatal_error (input_location, "cannot write PCH file: %m");
/* If SIZE is not the same as OBJECT_SIZE(order), then we need to pad the
object out to OBJECT_SIZE(order). This happens for strings. */
if (padding <= sizeof (emptyBytes))
{
if (fwrite (emptyBytes, 1, padding, f) != padding)
- fatal_error (input_location, "can%'t write PCH file");
+ fatal_error (input_location, "cannot write PCH file");
}
else
{
/* Larger than our buffer? Just default to fseek. */
if (fseek (f, padding, SEEK_CUR) != 0)
- fatal_error (input_location, "can%'t write PCH file");
+ fatal_error (input_location, "cannot write PCH file");
}
}
&& fseek (f, ROUND_UP_VALUE (d->d.totals[order] * OBJECT_SIZE (order),
G.pagesize),
SEEK_CUR) != 0)
- fatal_error (input_location, "can%'t write PCH file: %m");
+ fatal_error (input_location, "cannot write PCH file: %m");
}
void
ggc_pch_finish (struct ggc_pch_data *d, FILE *f)
{
if (fwrite (&d->d, sizeof (d->d), 1, f) != 1)
- fatal_error (input_location, "can%'t write PCH file: %m");
+ fatal_error (input_location, "cannot write PCH file: %m");
free (d);
}
/* Allocate the appropriate page-table entries for the pages read from
the PCH file. */
if (fread (&d, sizeof (d), 1, f) != 1)
- fatal_error (input_location, "can%'t read PCH file: %m");
+ fatal_error (input_location, "cannot read PCH file: %m");
for (i = 0; i < NUM_ORDERS; i++)
{
fb_lvalue | fb_mayfail);
if (tret == GS_ERROR)
{
- error ("invalid lvalue in asm output %d", i);
+ error ("invalid lvalue in %<asm%> output %d", i);
ret = tret;
}
{
warning_at (OMP_CLAUSE_LOCATION (c), 0,
"incompatible data clause with reduction "
- "on %qE; promoting to present_or_copy",
+ "on %qE; promoting to %<present_or_copy%>",
DECL_NAME (t));
OMP_CLAUSE_SET_MAP_KIND (c, GOMP_MAP_TOFROM);
}
{
HSA_SORRY_ATV (EXPR_LOCATION (val), "support for HSA does "
"not implement taking addresses of complex "
- "CONST_DECLs such as %E", val);
+ "%<CONST_DECL%> such as %E", val);
return;
}
{
HSA_SORRY_ATV (EXPR_LOCATION (rhs),
"support for HSA does not implement conversion "
- "of %E to the requested non-pointer type.", rhs);
+ "of %E to the requested non-pointer type", rhs);
return;
}
default:
HSA_SORRY_ATV (EXPR_LOCATION (lhs),
"support for HSA does not implement comparison tree "
- "code %s\n", get_tree_code_name (code));
+ "code %s", get_tree_code_name (code));
return;
}
case FLOOR_DIV_EXPR:
case ROUND_DIV_EXPR:
HSA_SORRY_AT (gimple_location (assign),
- "support for HSA does not implement CEIL_DIV_EXPR, "
- "FLOOR_DIV_EXPR or ROUND_DIV_EXPR");
+ "support for HSA does not implement %<CEIL_DIV_EXPR%>, "
+ "%<FLOOR_DIV_EXPR%> or %<ROUND_DIV_EXPR%>");
return;
case TRUNC_MOD_EXPR:
opcode = BRIG_OPCODE_REM;
case FLOOR_MOD_EXPR:
case ROUND_MOD_EXPR:
HSA_SORRY_AT (gimple_location (assign),
- "support for HSA does not implement CEIL_MOD_EXPR, "
- "FLOOR_MOD_EXPR or ROUND_MOD_EXPR");
+ "support for HSA does not implement %<CEIL_MOD_EXPR%>, "
+ "%<FLOOR_MOD_EXPR%> or %<ROUND_MOD_EXPR%>");
return;
case NEGATE_EXPR:
opcode = BRIG_OPCODE_NEG;
if (shadow_reg_ptr == NULL)
{
HSA_SORRY_AT (gimple_location (stmt),
- "support for HSA does not implement omp_get_level called "
- "from a function not being inlined within a kernel");
+ "support for HSA does not implement %<omp_get_level%> "
+ "called from a function not being inlined within a kernel");
return;
}
if (lhs == NULL_TREE)
return;
- built_in_function fn = DECL_FUNCTION_CODE (gimple_call_fndecl (call));
+ tree fndecl = gimple_call_fndecl (call);
+ built_in_function fn = DECL_FUNCTION_CODE (fndecl);
gcc_checking_assert (ALLOCA_FUNCTION_CODE_P (fn));
{
HSA_SORRY_ATV (gimple_location (call),
"support for HSA does not implement "
- "__builtin_alloca_with_align with a non-constant "
- "alignment: %E", alignment_tree);
+ "%qD with a non-constant alignment %E",
+ fndecl, alignment_tree);
}
bit_alignment = tree_to_uhwi (alignment_tree);
HSA_SORRY_AT (gimple_location (stmt), m_warning_message);
else
HSA_SORRY_ATV (gimple_location (stmt),
- "Support for HSA does not implement calls to %s\n",
+ "support for HSA does not implement calls to %qs",
m_name);
}
else if (m_warning_message != NULL)
{
HSA_SORRY_ATV (gimple_location (stmt),
"support for HSA does not implement memory model for "
- "ATOMIC_ST: %s", mmname);
+ "%<ATOMIC_ST%>: %s", mmname);
return;
}
}
gen_hsa_insns_for_direct_call (stmt, hbb);
else if (!gen_hsa_insns_for_known_library_call (stmt, hbb))
HSA_SORRY_AT (gimple_location (stmt),
- "HSA supports only calls of functions marked with pragma "
- "omp declare target");
+ "HSA supports only calls of functions marked with "
+ "%<#pragma omp declare target%>");
return;
}
case BUILT_IN_GOMP_PARALLEL:
HSA_SORRY_AT (gimple_location (stmt),
"support for HSA does not implement non-gridified "
- "OpenMP parallel constructs.");
+ "OpenMP parallel constructs");
break;
case BUILT_IN_OMP_GET_THREAD_NUM:
if (x == y)
{
if (x < MAP_START_LOCATION (map))
- inform (x, "token %u has x-location == y-location == %u", i, x);
+ inform (x, "token %u has %<x-location == y-location == %u%>",
+ i, x);
else
fprintf (stream,
"x-location == y-location == %u encodes token # %u\n",
}
else
{
- inform (x, "token %u has x-location == %u", i, x);
- inform (x, "token %u has y-location == %u", i, y);
+ inform (x, "token %u has %<x-location == %u%>", i, x);
+ inform (x, "token %u has %<y-location == %u%>", i, y);
}
}
fprintf (stream, "\n");
if (warning_at (DECL_SOURCE_LOCATION
(TYPE_NAME (DECL_CONTEXT (vtable->decl))), OPT_Wodr,
"virtual table of type %qD violates "
- "one definition rule ",
+ "one definition rule",
DECL_CONTEXT (vtable->decl)))
{
if (TREE_CODE (ref1->referred->decl) == FUNCTION_DECL)
SET_HARD_REG_BIT (ira_no_alloc_regs, eliminables[i].from);
}
else if (cannot_elim)
- error ("%s cannot be used in asm here",
+ error ("%s cannot be used in %<asm%> here",
reg_names[eliminables[i].from]);
else
df_set_regs_ever_live (eliminables[i].from, true);
SET_HARD_REG_BIT (ira_no_alloc_regs, HARD_FRAME_POINTER_REGNUM);
}
else if (frame_pointer_needed)
- error ("%s cannot be used in asm here",
+ error ("%s cannot be used in %<asm%> here",
reg_names[HARD_FRAME_POINTER_REGNUM]);
else
df_set_regs_ever_live (HARD_FRAME_POINTER_REGNUM, true);
&& (lra_assignment_iter_after_spill
> LRA_MAX_ASSIGNMENT_ITERATION_NUMBER))
internal_error
- ("Maximum number of LRA assignment passes is achieved (%d)\n",
+ ("maximum number of LRA assignment passes is achieved (%d)",
LRA_MAX_ASSIGNMENT_ITERATION_NUMBER);
return no_spills_p;
}
}
if (new_insns_num > MAX_RELOAD_INSNS_NUMBER)
internal_error
- ("Max. number of generated reload insns per insn is achieved (%d)\n",
+ ("maximum number of generated reload insns per insn achieved (%d)",
MAX_RELOAD_INSNS_NUMBER);
new_insns_num++;
if (DEBUG_INSN_P (curr_insn))
}
/* FALLTHRU */
default:
- fatal_error (UNKNOWN_LOCATION, "unsupported mode %s\n", mname);
+ fatal_error (UNKNOWN_LOCATION, "unsupported mode %qs", mname);
break;
}
}
do
{
if (argv_storage[j] == '\0')
- fatal_error (input_location, "malformed COLLECT_GCC_OPTIONS");
+ fatal_error (input_location,
+ "malformed %<COLLECT_GCC_OPTIONS%>");
else if (strncmp (&argv_storage[j], "'\\''", 4) == 0)
{
argv_storage[k++] = '\'';
append_option (decoded_options, decoded_options_count, foption);
else if (strcmp ((*decoded_options)[j].arg, foption->arg))
fatal_error (input_location,
- "Option %s with different values",
+ "option %s with different values",
foption->orig_option_with_args_text);
break;
append_option (decoded_options, decoded_options_count, foption);
else if (foption->value != (*decoded_options)[j].value)
fatal_error (input_location,
- "Option %s not used consistently in all LTO input"
+ "option %s not used consistently in all LTO input"
" files", foption->orig_option_with_args_text);
break;
if (!compiler)
fatal_error (input_location,
- "could not find %s in %s (consider using %<-B%>)\n",
+ "could not find %s in %s (consider using %<-B%>)",
suffix + 1, compiler_path);
/* Generate temporary output file name. */
linker_opts, linker_opt_count);
if (!offload_names[next_name_entry])
fatal_error (input_location,
- "problem with building target image for %s\n", names[i]);
+ "problem with building target image for %s", names[i]);
next_name_entry++;
}
}
if (i == n_paths)
fatal_error (input_location,
- "installation error, can%'t find crtoffloadtable.o");
+ "installation error, cannot find %<crtoffloadtable.o%>");
free_array_of_ptrs ((void **) paths, n_paths);
}
&off, &len, &errmsg, &err) != 1)
{
if (errmsg)
- fatal_error (0, "%s: %s\n", errmsg, xstrerror (err));
+ fatal_error (0, "%s: %s", errmsg, xstrerror (err));
simple_object_release_read (inobj);
close (infd);
if (errmsg)
{
unlink_if_ordinary (outfile);
- fatal_error (0, "%s: %s\n", errmsg, xstrerror (err));
+ fatal_error (0, "%s: %s", errmsg, xstrerror (err));
}
simple_object_release_read (inobj);
collect_gcc = getenv ("COLLECT_GCC");
if (!collect_gcc)
fatal_error (input_location,
- "environment variable COLLECT_GCC must be set");
+ "environment variable %<COLLECT_GCC%> must be set");
collect_gcc_options = getenv ("COLLECT_GCC_OPTIONS");
if (!collect_gcc_options)
fatal_error (input_location,
- "environment variable COLLECT_GCC_OPTIONS must be set");
+ "environment variable %<COLLECT_GCC_OPTIONS%> must be set");
get_options_from_collect_gcc_options (collect_gcc, collect_gcc_options,
CL_LANG_ALL,
&decoded_options,
int priority;
if (!stream)
- fatal_error (input_location, "fopen: %s: %m", ltrans_output_file);
+ fatal_error (input_location, "%<fopen%>: %s: %m", ltrans_output_file);
/* Parse the list of LTRANS inputs from the WPA stage. */
obstack_init (&env_obstack);
{
if (!feof (stream))
fatal_error (input_location,
- "Corrupted ltrans output file %s",
+ "corrupted ltrans output file %s",
ltrans_output_file);
break;
}
diagnostic_initialize (global_dc, 0);
if (atexit (lto_wrapper_cleanup) != 0)
- fatal_error (input_location, "atexit failed");
+ fatal_error (input_location, "%<atexit%> failed");
if (signal (SIGINT, SIG_IGN) != SIG_IGN)
signal (SIGINT, fatal_signal);
+2019-05-16 Martin Sebor <msebor@redhat.com>
+
+ * lto-dump.c (lto_main): Same.
+ * lto.c (stream_out): Same.
+
2019-05-10 Martin Liska <mliska@suse.cz>
* Make-lang.in: Use program_transform_name for lto-dump.
node->get_untransformed_body ();
if (!GATHER_STATISTICS)
warning_at (input_location, 0,
- "Not configured with --enable-gather-detailed-mem-stats.");
+ "Not configured with "
+ "%<--enable-gather-detailed-mem-stats%>.");
else
dump_gimple_statistics ();
}
/* Dump tree statistics. */
if (!GATHER_STATISTICS)
warning_at (input_location, 0,
- "Not configured with --enable-gather-detailed-mem-stats.");
+ "Not configured with "
+ "%<--enable-gather-detailed-mem-stats%>.");
else
{
printf ("Tree Statistics\n");
{
lto_file *file = lto_obj_file_open (temp_filename, true);
if (!file)
- fatal_error (input_location, "lto_obj_file_open() failed");
+ fatal_error (input_location, "%<lto_obj_file_open()%> failed");
lto_set_current_out_file (file);
gcc_assert (!dump_file);
+2019-05-16 Martin Sebor <msebor@redhat.com>
+
+ * objc-act.c (objc_begin_catch_clause): Quote keywords and options
+ in diagnostics.
+ (objc_build_throw_stmt): Same.
+ (objc_finish_message_expr): Same.
+ (get_super_receiver): Same.
+ * objc-next-runtime-abi-01.c (objc_next_runtime_abi_01_init): Spell
+ out "less than" in English./
+ * objc-next-runtime-abi-02.c (objc_next_runtime_abi_02_init): Spell
+ out "greater" in English.
+
2019-05-10 Jakub Jelinek <jakub@redhat.com>
PR pch/90326
char * const dumpname = concat (dump_base_name, ".decl", NULL);
gen_declaration_file = fopen (dumpname, "w");
if (gen_declaration_file == 0)
- fatal_error (input_location, "can%'t open %s: %m", dumpname);
+ fatal_error (input_location, "cannot open %s: %m", dumpname);
free (dumpname);
}
}
else if (!objc_type_valid_for_messaging (type, false))
{
- error ("@catch parameter is not a known Objective-C class type");
+ error ("%<@catch%> parameter is not a known Objective-C class type");
type = error_mark_node;
}
else if (TYPE_HAS_OBJC_INFO (TREE_TYPE (type))
&& TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (type)))
{
- error ("@catch parameter cannot be protocol-qualified");
+ error ("%<@catch%> parameter cannot be protocol-qualified");
type = error_mark_node;
}
else if (POINTER_TYPE_P (type) && objc_is_object_id (TREE_TYPE (type)))
if (cur_try_context == NULL
|| cur_try_context->current_catch == NULL)
{
- error_at (loc, "%<@throw%> (rethrow) used outside of a @catch block");
+ error_at (loc,
+ "%<@throw%> (rethrow) used outside of a %<@catch%> block");
return error_mark_node;
}
prototype. Emit a warning, then keep going (this
will use any method with a matching name, as if the
receiver was of type 'Class'). */
- warning (0, "@interface of class %qE not found", class_tree);
+ warning (0, "%<@interface%> of class %qE not found",
+ class_tree);
}
}
/* Handle `self' and `super'. */
warning, either include an @interface for the
class, or cast the receiver to 'id'. Note that
rtype is an IDENTIFIER_NODE at this point. */
- warning (0, "@interface of class %qE not found", rtype);
+ warning (0, "%<@interface%> of class %qE not found", rtype);
}
}
if (!warn_missing_methods)
{
warning_at (input_location,
- 0, "(Messages without a matching method signature");
- warning_at (input_location,
- 0, "will be assumed to return %<id%> and accept");
- warning_at (input_location,
- 0, "%<...%> as arguments.)");
+ 0, "(messages without a matching method signature "
+ "will be assumed to return %<id%> and accept "
+ "%<...%> as arguments)");
warn_missing_methods = true;
}
}
}
else
{
- error ("[super ...] must appear in a method context");
+ error ("%<[super ...]%> must appear in a method context");
return error_mark_node;
}
}
{
warning_at (UNKNOWN_LOCATION, OPT_Wall,
"%<-fobjc-sjlj-exceptions%> is the only supported exceptions "
- "system for %<-fnext-runtime%> with %<-fobjc-abi-version%> < 2");
+ "system for %<-fnext-runtime%> with %<-fobjc-abi-version%> "
+ "argument less than 2");
}
rthooks->initialize = next_runtime_01_initialize;
if (flag_objc_exceptions && flag_objc_sjlj_exceptions)
{
- inform (UNKNOWN_LOCATION, "%<-fobjc-sjlj-exceptions%> is ignored for "
- "%<-fnext-runtime%> when %<-fobjc-abi-version%> >= 2");
+ inform (UNKNOWN_LOCATION,
+ "%<-fobjc-sjlj-exceptions%> is ignored for "
+ "%<-fnext-runtime%> when %<-fobjc-abi-version%> "
+ "greater than 1");
flag_objc_sjlj_exceptions = 0;
}
description = _("The following options take joined arguments");
else
{
- internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
+ internal_error ("unrecognized %<include_flags 0x%x%> passed "
+ "to %<print_specific_help%>",
include_flags);
return;
}
if (sanitizer_opts[i].name == NULL)
warning (OPT_Wattributes,
- "%<%s%> attribute directive ignored", q);
+ "%qs attribute directive ignored", q);
q = strtok (NULL, ",");
}
*pflags |= lang_flag;
else
warning (0,
- "--help argument %q.*s is ambiguous, "
+ "%<--help%> argument %q.*s is ambiguous, "
"please be more specific",
len, a);
}
*pflags |= lang_flag;
else
warning (0,
- "unrecognized argument to --help= option: %q.*s",
+ "unrecognized argument to %<--help=%> option: %q.*s",
len, a);
if (comma == NULL)
arg = xstrdup (carg);
equal = strchr (arg, '=');
if (!equal)
- error_at (loc, "%s: --param arguments should be of the form NAME=VALUE",
- arg);
+ error_at (loc, "%s: %qs arguments should be of the form NAME=VALUE",
+ arg, "--param");
else
{
*equal = '\0';
{
const char *suggestion = find_param_fuzzy (arg);
if (suggestion)
- error_at (loc, "invalid --param name %qs; did you mean %qs?",
- arg, suggestion);
+ error_at (loc, "invalid %qs name %qs; did you mean %qs?",
+ "--param", arg, suggestion);
else
- error_at (loc, "invalid --param name %qs", arg);
+ error_at (loc, "invalid %qs name %qs", "--param", arg);
}
else
{
value = integral_argument (equal + 1);
if (value == -1)
- error_at (loc, "invalid --param value %qs", equal + 1);
+ error_at (loc, "invalid %qs value %qs", "--param", equal + 1);
else
set_param_value (arg, value,
opts->x_param_values, opts_set->x_param_values);
void
opt_pass::set_pass_param (unsigned int, bool)
{
- internal_error ("pass %s needs a set_pass_param implementation to handle the"
- " extra argument in NEXT_PASS", name);
+ internal_error ("pass %s needs a %<set_pass_param%> implementation "
+ "to handle the extra argument in %<NEXT_PASS%>", name);
}
bool
{
plugin = (struct plugin_name_args *) *slot;
if (strcmp (plugin->full_name, plugin_name))
- error ("plugin %s was specified with different paths:\n%s\n%s",
+ error ("plugin %qs was specified with different paths: %qs and %qs",
plugin->base_name, plugin->full_name, plugin_name);
return;
}
if (!key_start)
{
- error ("malformed option %<-fplugin-arg-%s%> (missing -<key>[=<value>])",
+ error ("malformed option %<-fplugin-arg-%s%>: "
+ "missing %<-<key>[=<value>]%>",
arg);
return;
}
dl_handle = dlopen (plugin->full_name, RTLD_NOW | RTLD_GLOBAL);
if (!dl_handle)
{
- error ("cannot load plugin %s\n%s", plugin->full_name, dlerror ());
+ error ("cannot load plugin %s: %s", plugin->full_name, dlerror ());
return false;
}
/* Check the plugin license. */
if (dlsym (dl_handle, str_license) == NULL)
fatal_error (input_location,
- "plugin %s is not licensed under a GPL-compatible license\n"
+ "plugin %s is not licensed under a GPL-compatible license"
"%s", plugin->full_name, dlerror ());
PTR_UNION_AS_VOID_PTR (plugin_init_union) =
if ((err = dlerror ()) != NULL)
{
dlclose(dl_handle);
- error ("cannot find %s in plugin %s\n%s", str_plugin_init_func_name,
+ error ("cannot find %s in plugin %s: %s", str_plugin_init_func_name,
plugin->full_name, err);
return false;
}
if ((*plugin_init) (plugin, &gcc_version))
{
dlclose(dl_handle);
- error ("fail to initialize plugin %s", plugin->full_name);
+ error ("failed to initialize plugin %s", plugin->full_name);
return false;
}
/* leak dl_handle on purpose to ensure the plugin is loaded for the
} while (0);
#include "cfg-flags.def"
#undef DEF_EDGE_FLAG
- error ("unrecognized edge flag: '%s'", tok);
+ error ("unrecognized edge flag: %qs", tok);
return 0;
}
if (strcmp (name.string, strings[i]) == 0)
return i;
}
- error ("unrecognized enum value: '%s'", name.string);
+ error ("unrecognized enum value: %qs", name.string);
return 0;
}
for (j = 0; j < n_clobbers; j++)
if (REGNO (recog_data.operand[i]) == REGNO (clobber_reg[j]))
{
- error_for_asm (insn, "output constraint %d cannot be specified together with \"%s\" clobber",
+ error_for_asm (insn, "output constraint %d cannot be "
+ "specified together with %qs clobber",
i, reg_names [REGNO (clobber_reg[j])]);
malformed_asm = 1;
break;
if (i != LAST_STACK_REG + 1)
{
- error_for_asm (insn, "output regs must be grouped at top of stack");
+ error_for_asm (insn, "output registers must be grouped at top of stack");
malformed_asm = 1;
}
if (i != LAST_STACK_REG + 1)
{
error_for_asm (insn,
- "implicitly popped regs must be grouped at top of stack");
+ "implicitly popped registers must be grouped "
+ "at top of stack");
malformed_asm = 1;
}
if (i != LAST_STACK_REG + 1)
{
error_for_asm (insn,
- "explicitly used regs must be grouped at top of stack");
+ "explicitly used registers must be grouped "
+ "at top of stack");
malformed_asm = 1;
}
if (vd->e[i].mode == VOIDmode)
{
if (vd->e[i].next_regno != INVALID_REGNUM)
- internal_error ("validate_value_data: [%u] Bad next_regno for empty chain (%u)",
- i, vd->e[i].next_regno);
+ internal_error ("%qs: [%u] bad %<next_regno%> for empty chain (%u)",
+ __func__, i, vd->e[i].next_regno);
continue;
}
j = vd->e[j].next_regno)
{
if (TEST_HARD_REG_BIT (set, j))
- internal_error ("validate_value_data: Loop in regno chain (%u)",
- j);
+ internal_error ("%qs: loop in %<next_regno%> chain (%u)",
+ __func__, j);
if (vd->e[j].oldest_regno != i)
- internal_error ("validate_value_data: [%u] Bad oldest_regno (%u)",
- j, vd->e[j].oldest_regno);
+ internal_error ("%qs: [%u] bad %<oldest_regno%> (%u)",
+ __func__, j, vd->e[j].oldest_regno);
SET_HARD_REG_BIT (set, j);
}
&& (vd->e[i].mode != VOIDmode
|| vd->e[i].oldest_regno != i
|| vd->e[i].next_regno != INVALID_REGNUM))
- internal_error ("validate_value_data: [%u] Non-empty reg in chain (%s %u %i)",
- i, GET_MODE_NAME (vd->e[i].mode), vd->e[i].oldest_regno,
+ internal_error ("%qs: [%u] non-empty register in chain (%s %u %i)",
+ __func__, i,
+ GET_MODE_NAME (vd->e[i].mode), vd->e[i].oldest_regno,
vd->e[i].next_regno);
}
switch (call_used)
{
case 0:
- error ("can%'t use %qs as a call-saved register", name);
+ error ("cannot use %qs as a call-saved register", name);
break;
case 1:
- error ("can%'t use %qs as a call-used register", name);
+ error ("cannot use %qs as a call-used register", name);
break;
default:
switch (call_used)
{
case 1:
- error ("can%'t use %qs as a fixed register", name);
+ error ("cannot use %qs as a fixed register", name);
break;
case 0:
spill_failure (rtx_insn *insn, enum reg_class rclass)
{
if (asm_noperands (PATTERN (insn)) >= 0)
- error_for_asm (insn, "can%'t find a register in class %qs while "
+ error_for_asm (insn, "cannot find a register in class %qs while "
"reloading %<asm%>",
reg_class_names[rclass]);
else
return true;
failure:
- error ("duplicate asm operand name %qs", TREE_STRING_POINTER (i_name));
+ error ("duplicate %<asm%> operand name %qs", TREE_STRING_POINTER (i_name));
return false;
}
do not have the "target" pragma. */
if (args)
warning (OPT_Wpragmas,
- "#pragma GCC target is not supported for this machine");
+ "%<#pragma GCC target%> is not supported for this machine");
return false;
}
+2019-05-16 Martin Sebor <msebor@redhat.com>
+
+ * c-c++-common/Wbool-operation-1.c: Adjust text of expected diagnostics.
+ * c-c++-common/Wvarargs-2.c: Same.
+ * c-c++-common/Wvarargs.c: Same.
+ * c-c++-common/pr51768.c: Same.
+ * c-c++-common/tm/inline-asm.c: Same.
+ * c-c++-common/tm/safe-1.c: Same.
+ * g++.dg/asm-qual-1.C: Same.
+ * g++.dg/asm-qual-3.C: Same.
+ * g++.dg/conversion/dynamic1.C: Same.
+ * g++.dg/cpp0x/constexpr-89599.C: Same.
+ * g++.dg/cpp0x/constexpr-cast.C: Same.
+ * g++.dg/cpp0x/constexpr-shift1.C: Same.
+ * g++.dg/cpp0x/lambda/lambda-conv11.C: Same.
+ * g++.dg/cpp0x/nullptr04.C: Same.
+ * g++.dg/cpp0x/static_assert12.C: Same.
+ * g++.dg/cpp0x/static_assert8.C: Same.
+ * g++.dg/cpp1y/lambda-conv1.C: Same.
+ * g++.dg/cpp1y/pr79393-3.C: Same.
+ * g++.dg/cpp1y/static_assert1.C: Same.
+ * g++.dg/cpp1z/constexpr-if4.C: Same.
+ * g++.dg/cpp1z/constexpr-if5.C: Same.
+ * g++.dg/cpp1z/constexpr-if9.C: Same.
+ * g++.dg/eh/goto2.C: Same.
+ * g++.dg/eh/goto3.C: Same.
+ * g++.dg/expr/static_cast8.C: Same.
+ * g++.dg/ext/flexary5.C: Same.
+ * g++.dg/ext/utf-array-short-wchar.C: Same.
+ * g++.dg/ext/utf-array.C: Same.
+ * g++.dg/ext/utf8-2.C: Same.
+ * g++.dg/gomp/loop-4.C: Same.
+ * g++.dg/gomp/macro-4.C: Same.
+ * g++.dg/gomp/udr-1.C: Same.
+ * g++.dg/init/initializer-string-too-long.C: Same.
+ * g++.dg/other/offsetof9.C: Same.
+ * g++.dg/ubsan/pr63956.C: Same.
+ * g++.dg/warn/Wbool-operation-1.C: Same.
+ * g++.dg/warn/Wtype-limits-Wextra.C: Same.
+ * g++.dg/warn/Wtype-limits.C: Same.
+ * g++.dg/wrappers/pr88680.C: Same.
+ * g++.old-deja/g++.mike/eh55.C: Same.
+ * gcc.dg/Wsign-compare-1.c: Same.
+ * gcc.dg/Wtype-limits-Wextra.c: Same.
+ * gcc.dg/Wtype-limits.c: Same.
+ * gcc.dg/Wunknownprag.c: Same.
+ * gcc.dg/Wunsuffixed-float-constants-1.c: Same.
+ * gcc.dg/asm-6.c: Same.
+ * gcc.dg/asm-qual-1.c: Same.
+ * gcc.dg/cast-1.c: Same.
+ * gcc.dg/cast-2.c: Same.
+ * gcc.dg/cast-3.c: Same.
+ * gcc.dg/cpp/source_date_epoch-2.c: Same.
+ * gcc.dg/debug/pr85252.c: Same.
+ * gcc.dg/dfp/cast-bad.c: Same.
+ * gcc.dg/format/gcc_diag-1.c: Same.
+ * gcc.dg/format/gcc_diag-11.c: Same.New test.
+ * gcc.dg/gcc_diag-11.c: Same.New test.
+ * gcc.dg/gnu-cond-expr-2.c: Same.
+ * gcc.dg/gnu-cond-expr-3.c: Same.
+ * gcc.dg/gomp/macro-4.c: Same.
+ * gcc.dg/init-bad-1.c: Same.
+ * gcc.dg/init-bad-2.c: Same.
+ * gcc.dg/init-bad-3.c: Same.
+ * gcc.dg/pr27528.c: Same.
+ * gcc.dg/pr48552-1.c: Same.
+ * gcc.dg/pr48552-2.c: Same.
+ * gcc.dg/pr59846.c: Same.
+ * gcc.dg/pr61096-1.c: Same.
+ * gcc.dg/pr8788-1.c: Same.
+ * gcc.dg/pr90082.c: Same.
+ * gcc.dg/simd-2.c: Same.
+ * gcc.dg/spellcheck-params-2.c: Same.
+ * gcc.dg/spellcheck-params.c: Same.
+ * gcc.dg/strlenopt-49.c: Same.
+ * gcc.dg/tm/pr52141.c: Same.
+ * gcc.dg/torture/pr51106-1.c: Same.
+ * gcc.dg/torture/pr51106-2.c: Same.
+ * gcc.dg/utf-array-short-wchar.c: Same.
+ * gcc.dg/utf-array.c: Same.
+ * gcc.dg/utf8-2.c: Same.
+ * gcc.dg/warn-sprintf-no-nul.c: Same.
+ * gcc.target/i386/asm-flag-0.c: Same.
+ * gcc.target/i386/inline_error.c: Same.
+ * gcc.target/i386/pr30848.c: Same.
+ * gcc.target/i386/pr39082-1.c: Same.
+ * gcc.target/i386/pr39678.c: Same.
+ * gcc.target/i386/pr57756.c: Same.
+ * gcc.target/i386/pr68843-1.c: Same.
+ * gcc.target/i386/pr79804.c: Same.
+ * gcc.target/i386/pr82673.c: Same.
+ * obj-c++.dg/class-protocol-1.mm: Same.
+ * obj-c++.dg/exceptions-3.mm: Same.
+ * obj-c++.dg/exceptions-4.mm: Same.
+ * obj-c++.dg/exceptions-5.mm: Same.
+ * obj-c++.dg/exceptions-6.mm: Same.
+ * obj-c++.dg/method-12.mm: Same.
+ * obj-c++.dg/method-13.mm: Same.
+ * obj-c++.dg/method-6.mm: Same.
+ * obj-c++.dg/method-7.mm: Same.
+ * obj-c++.dg/method-9.mm: Same.
+ * obj-c++.dg/method-lookup-1.mm: Same.
+ * obj-c++.dg/proto-lossage-4.mm: Same.
+ * obj-c++.dg/protocol-qualifier-2.mm: Same.
+ * objc.dg/call-super-2.m: Same.
+ * objc.dg/class-protocol-1.m: Same.
+ * objc.dg/desig-init-1.m: Same.
+ * objc.dg/exceptions-3.m: Same.
+ * objc.dg/exceptions-4.m: Same.
+ * objc.dg/exceptions-5.m: Same.
+ * objc.dg/exceptions-6.m: Same.
+ * objc.dg/method-19.m: Same.
+ * objc.dg/method-2.m: Same.
+ * objc.dg/method-5.m: Same.
+ * objc.dg/method-6.m: Same.
+ * objc.dg/method-7.m: Same.
+ * objc.dg/method-lookup-1.m: Same.
+ * objc.dg/proto-hier-1.m: Same.
+ * objc.dg/proto-lossage-4.m: Same.
+
2019-05-17 Dragan Mladjenovic <dmladjenovic@wavecomp.com>
* g++.dg/eh/o32-fp.C: New.
{
int r = 0;
- r += ~b; /* { dg-warning "on an expression of type bool|on a boolean expression" } */
- r += n + ~b; /* { dg-warning "on an expression of type bool|on a boolean expression" } */
- r += ~(n == 1); /* { dg-warning "on an expression of type bool|on a boolean expression" } */
- r += ~(n || 1); /* { dg-warning "on an expression of type bool|on a boolean expression" } */
- r += ~b == 1; /* { dg-warning "on an expression of type bool|on a boolean expression" } */
- r += ~(++n, n == 1); /* { dg-warning "on an expression of type bool|on a boolean expression" } */
- r += ~(++n, n > 1); /* { dg-warning "on an expression of type bool|on a boolean expression" } */
- r += ~(++n, n && 1); /* { dg-warning "on an expression of type bool|on a boolean expression" } */
- r += (++n, ~b); /* { dg-warning "on an expression of type bool|on a boolean expression" } */
- r += ~b3; /* { dg-warning "on an expression of type bool|on a boolean expression" } */
- r += ~foo (); /* { dg-warning "on an expression of type bool|on a boolean expression" } */
- r += ~(bool) !1; /* { dg-warning "on an expression of type bool|on a boolean expression" } */
+ r += ~b; /* { dg-warning "on an expression of type 'bool'|on a boolean expression" } */
+ r += n + ~b; /* { dg-warning "on an expression of type 'bool'|on a boolean expression" } */
+ r += ~(n == 1); /* { dg-warning "on an expression of type 'bool'|on a boolean expression" } */
+ r += ~(n || 1); /* { dg-warning "on an expression of type 'bool'|on a boolean expression" } */
+ r += ~b == 1; /* { dg-warning "on an expression of type 'bool'|on a boolean expression" } */
+ r += ~(++n, n == 1); /* { dg-warning "on an expression of type 'bool'|on a boolean expression" } */
+ r += ~(++n, n > 1); /* { dg-warning "on an expression of type 'bool'|on a boolean expression" } */
+ r += ~(++n, n && 1); /* { dg-warning "on an expression of type 'bool'|on a boolean expression" } */
+ r += (++n, ~b); /* { dg-warning "on an expression of type 'bool'|on a boolean expression" } */
+ r += ~b3; /* { dg-warning "on an expression of type 'bool'|on a boolean expression" } */
+ r += ~foo (); /* { dg-warning "on an expression of type 'bool'|on a boolean expression" } */
+ r += ~(bool) !1; /* { dg-warning "on an expression of type 'bool'|on a boolean expression" } */
v = ~v;
r += ~(int) b;
err (int a)
{
va_list vp;
- va_start (vp, a); // { dg-error "used in function with fixed args" }
+ va_start (vp, a); // { dg-error "used in function with fixed arguments" }
}
void
err (int a)
{
va_list vp;
- va_start (vp, a); // { dg-error "used in function with fixed args" }
+ va_start (vp, a); // { dg-error "used in function with fixed arguments" }
}
#pragma GCC diagnostic push
/* { dg-do compile } */
/* { dg-prune-output "changes the ABI" } */
typedef float v2sf __attribute__ ((vector_size (8)));
-v2sf sub (void) { return (v2sf) 0.0; } /* { dg-error "can't convert" } */
+v2sf sub (void) { return (v2sf) 0.0; } /* { dg-error "cannot convert" } */
void
foo (void)
{
- asm goto ("" : : : : lab, lab, lab2, lab); /* { dg-error "duplicate asm operand name" } */
+ asm goto ("" : : : : lab, lab, lab2, lab); /* { dg-error "duplicate 'asm' operand name" } */
lab:;
lab2:;
}
void
bar (void)
{
- asm goto ("" : : [lab] "i" (0) : : lab); /* { dg-error "duplicate asm operand name" } */
+ asm goto ("" : : [lab] "i" (0) : : lab); /* { dg-error "duplicate 'asm' operand name" } */
lab:;
}
baz (void)
{
int x;
- asm ("" : [lab] "=r" (x) : [lab] "r" (x)); /* { dg-error "duplicate asm operand name" } */
+ asm ("" : [lab] "=r" (x) : [lab] "r" (x)); /* { dg-error "duplicate 'asm' operand name" } */
}
f1 = ((int)998769576) + f0; /* { dg-error "conversion of scalar \[^\\n\]* to vector" "scalar to vector" { target { ! int16 } } } */
/* convert.c should take care of this. */
- i1 = sfl + i0; /* { dg-error "can't convert value to a vector|invalid operands" } */
- i1 = 1.5 + i0; /* { dg-error "can't convert value to a vector|invalid operands" } */
- v1 = d + v0; /* { dg-error "can't convert value to a vector|invalid operands" } */
+ i1 = sfl + i0; /* { dg-error "cannot convert value to a vector|invalid operands" } */
+ i1 = 1.5 + i0; /* { dg-error "cannot convert value to a vector|invalid operands" } */
+ v1 = d + v0; /* { dg-error "cannot convert value to a vector|invalid operands" } */
return 0;
}
static inline void
inline_death ()
{
- __asm__ (""); /* { dg-error "asm not allowed" } */
+ __asm__ (""); /* { dg-error "'asm' not allowed" } */
}
void
(*pi)(); /* { dg-error "unsafe indirect function call" } */
(*pu)(); /* { dg-error "unsafe indirect function call" } */
- asm(""); /* { dg-error "asm not allowed" } */
- asm("" : "=g"(i)); /* { dg-error "asm not allowed" } */
+ asm(""); /* { dg-error "'asm' not allowed" } */
+ asm("" : "=g"(i)); /* { dg-error "'asm' not allowed" } */
return fc(i);
}
(*pm)();
(*pu)(); /* { dg-error "unsafe indirect function call" } */
- asm(""); /* { dg-error "asm not allowed" } */
- asm("" : "=g"(i)); /* { dg-error "asm not allowed" } */
+ asm(""); /* { dg-error "'asm' not allowed" } */
+ asm("" : "=g"(i)); /* { dg-error "'asm' not allowed" } */
return fc(i);
}
{
asm volatile ("");
- asm const (""); // { dg-error {'const' is not an asm qualifier} }
+ asm const (""); // { dg-error {'const' is not an 'asm' qualifier} }
- asm __restrict (""); // { dg-error {'__restrict' is not an asm qualifier} }
+ asm __restrict (""); // { dg-error {'__restrict' is not an 'asm' qualifier} }
}
// { dg-do compile }
// { dg-options "-std=gnu++98" }
-asm const (""); // { dg-error {'const' is not an asm qualifier} }
-asm volatile (""); // { dg-warning {asm qualifier 'volatile' ignored outside of function body} }
+asm const (""); // { dg-error {'const' is not an 'asm' qualifier} }
+asm volatile (""); // { dg-warning {'asm' qualifier 'volatile' ignored outside of function body} }
asm restrict (""); // { dg-error {expected '\(' before 'restrict'} }
-asm inline (""); // { dg-error {asm qualifier outside of function body} }
-asm goto (""); // { dg-error {asm qualifier outside of function body} }
+asm inline (""); // { dg-error {'asm' qualifier outside of function body} }
+asm goto (""); // { dg-error {'asm' qualifier outside of function body} }
// There are many other things wrong with this code, so:
// { dg-excess-errors "" }
void baz()
{
- dynamic_cast<A&>( bar().foo ); // { dg-error "cannot dynamic_cast" }
+ dynamic_cast<A&>( bar().foo ); // { dg-error "cannot 'dynamic_cast'" }
}
// { dg-do compile { target c++11 } }
void foo (int x) {}
-constexpr void *arr[2] = { (void*) &foo, (void *) foo };// { dg-error "a reinterpret_cast is not a constant expression" }
-constexpr void *ptr = (void *) &foo; // { dg-error "a reinterpret_cast is not a constant expression" }
+constexpr void *arr[2] = { (void*) &foo, (void *) foo };// { dg-error "'reinterpret_cast' is not a constant expression" }
+constexpr void *ptr = (void *) &foo; // { dg-error "'reinterpret_cast' is not a constant expression" }
// The following was accepted due to bug 49171.
constexpr void *q = reinterpret_cast<void*>(&i); // { dg-error "not a constant expression" }
-constexpr void *r0 = reinterpret_cast<void*>(1); // { dg-error "not a constant expression|reinterpret_cast from integer to pointer" }
-constexpr void *r1 = reinterpret_cast<void*>(sizeof 'x'); // { dg-error ".reinterpret_cast<void\\*>\\(1\[ul\]\*\\). is not a constant expression" }
+constexpr void *r0 = reinterpret_cast<void*>(1); // { dg-error "not a constant expression|'reinterpret_cast' from integer to pointer" }
+constexpr void *r1 = reinterpret_cast<void*>(sizeof 'x'); // { dg-error "'reinterpret_cast<void\\*>\\(1\[ul\]\*\\)' is not a constant expression" }
template <class T>
constexpr bool f ()
constexpr int
fn2 (int i, int j)
{
- return i << j; // { dg-error "is >= than the precision of the left operand" }
+ return i << j; // { dg-error "is greater than or equal to the precision .. of the left operand" }
}
constexpr int i2 = fn2 (1, 200); // { dg-message "in .constexpr. expansion of " }
constexpr int
fn6 (unsigned int i, unsigned int j)
{
- return i << j; // { dg-error "is >= than the precision of the left operand" }
+ return i << j; // { dg-error "is greater than or equal to the precision .. of the left operand" }
}
constexpr int i6 = fn6 (1, -1); // { dg-message "in .constexpr. expansion of " }
constexpr int
fn9 (int i, int j)
{
- return i >> j; // { dg-error "is >= than the precision of the left operand" }
+ return i >> j; // { dg-error "is greater than or equal to the precision .. of the left operand" }
}
constexpr int i9 = fn9 (1, 200); // { dg-message "in .constexpr. expansion of " }
// { dg-do compile { target c++11 } }
-void f(char i, int j) = delete; // { dg-message "<deleted>" }
+void f(char i, int j) = delete; // { dg-message "(deleted)" }
void f(int i, ...); // { dg-message "void f" }
int main()
void foo()
{
int i;
- static_cast<void(*)()>([i]{}); // { dg-error "invalid static_cast" }
- static_cast<void(*)()>([=]{}); // { dg-error "invalid static_cast" }
- static_cast<void(*)()>([&]{}); // { dg-error "invalid static_cast" }
+ static_cast<void(*)()>([i]{}); // { dg-error "invalid 'static_cast'" }
+ static_cast<void(*)()>([=]{}); // { dg-error "invalid 'static_cast'" }
+ static_cast<void(*)()>([&]{}); // { dg-error "invalid 'static_cast'" }
}
__extension__ typedef __INTPTR_TYPE__ intptr_t;
-const int n4 = static_cast<const int>(nullptr); // { dg-error "invalid static_cast " }
+const int n4 = static_cast<const int>(nullptr); // { dg-error "invalid 'static_cast' " }
const short int n5 = reinterpret_cast<short int>(nullptr); // { dg-error "loses precision" }
const intptr_t n6 = reinterpret_cast<intptr_t>(nullptr);
const intptr_t n7 = (intptr_t)nullptr;
decltype(nullptr) mynull = 0;
-const int n8 = static_cast<const int>(mynull); // { dg-error "invalid static_cast " }
+const int n8 = static_cast<const int>(mynull); // { dg-error "invalid 'static_cast' " }
const short int n9 = reinterpret_cast<short int>(mynull); // { dg-error "loses precision" }
const intptr_t n10 = reinterpret_cast<intptr_t>(mynull);
const intptr_t n11 = (intptr_t)mynull;
float_thing(1);
}
-// { dg-warning "static_assert without a message only available with " "" { target *-*-* } 21 }
+// { dg-warning "'static_assert' without a message only available with " "" { target *-*-* } 21 }
static_assert (1 == 0, "oops"); // { dg-error "static assertion failed" }
-// { dg-error "static_assert without a message only available with " "" { target { ! c++17 } } 3 }
+// { dg-error "'static_assert' without a message only available with " "" { target { ! c++17 } } 3 }
void foo()
{
int i;
- static_cast<void(*)(int)>([i](auto){}); // { dg-error "invalid static_cast" }
- static_cast<void(*)(int)>([=](auto){}); // { dg-error "invalid static_cast" }
- static_cast<void(*)(int)>([&](auto){}); // { dg-error "invalid static_cast" }
- static_cast<float(*)(float)>([i](auto x){ return x; }); // { dg-error "invalid static_cast" }
- static_cast<float(*)(float)>([=](auto x){ return x; }); // { dg-error "invalid static_cast" }
- static_cast<float(*)(float)>([&](auto x){ return x; }); // { dg-error "invalid static_cast" }
+ static_cast<void(*)(int)>([i](auto){}); // { dg-error "invalid 'static_cast'" }
+ static_cast<void(*)(int)>([=](auto){}); // { dg-error "invalid 'static_cast'" }
+ static_cast<void(*)(int)>([&](auto){}); // { dg-error "invalid 'static_cast'" }
+ static_cast<float(*)(float)>([i](auto x){ return x; }); // { dg-error "invalid 'static_cast'" }
+ static_cast<float(*)(float)>([=](auto x){ return x; }); // { dg-error "invalid 'static_cast'" }
+ static_cast<float(*)(float)>([&](auto x){ return x; }); // { dg-error "invalid 'static_cast'" }
}
};
B::~B () {
- throw 1; // { dg-warning "will always call terminate" }
+ throw 1; // { dg-warning "will always call 'terminate'" }
}
struct C : virtual A
float_thing(1);
}
-// { dg-warning "static_assert without a message only available with " "" { target *-*-* } 21 }
+// { dg-warning "'static_assert' without a message only available with " "" { target *-*-* } 21 }
void f()
{
goto l; // { dg-message "from here" }
- if constexpr (false) // { dg-message "enters constexpr if" }
+ if constexpr (false) // { dg-message "enters 'constexpr if'" }
{
l:; // { dg-error "jump to label" }
}
void f()
{
- if constexpr (false) // { dg-message "enters constexpr if" }
+ if constexpr (false) // { dg-message "enters 'constexpr if'" }
{
goto l; // { dg-message "from here" }
}
void f(int i)
{
switch (i)
- if constexpr (false) // { dg-message "enters constexpr if" }
+ if constexpr (false) // { dg-message "enters 'constexpr if'" }
{
case 42:; // { dg-error "jump to case label" }
}
} catch (...)
{
l2: ; // { dg-error "jump to label 'l2'" }
- // { dg-message "enters catch block" "" { target *-*-*} .-1 }
- goto l1; // { dg-message "from here|enters try block" }
+ // { dg-message "enters 'catch' block" "" { target *-*-*} .-1 }
+ goto l1; // { dg-message "from here|enters 'try' block" }
}
} catch (...)
{
l2: ; // { dg-error "jump to label 'l2'" }
- // { dg-message "enters catch block" "" { target *-*-*} .-1 }
- goto l1; // { dg-message "from here|enters try block" }
+ // { dg-message "enters 'catch' block" "" { target *-*-*} .-1 }
+ goto l1; // { dg-message "from here|enters 'try' block" }
}
void pointers(C* c, A2* a2, B1* b1)
{
- (void) static_cast<A1*>(c); // { dg-error "invalid static_cast" }
- (void) static_cast<C*>(a2); // { dg-error "invalid static_cast" }
- (void) static_cast<B2*>(b1); // { dg-error "invalid static_cast" }
+ (void) static_cast<A1*>(c); // { dg-error "invalid 'static_cast'" }
+ (void) static_cast<C*>(a2); // { dg-error "invalid 'static_cast'" }
+ (void) static_cast<B2*>(b1); // { dg-error "invalid 'static_cast'" }
}
struct D1; // { dg-message "note: class type 'D1' is incomplete" }
void references(C& c, D2& d2, E1& e1)
{
- (void) static_cast<D1&>(c); // { dg-error "invalid static_cast" }
- (void) static_cast<C&>(d2); // { dg-error "invalid static_cast" }
- (void) static_cast<E2&>(e1); // { dg-error "invalid static_cast" }
+ (void) static_cast<D1&>(c); // { dg-error "invalid 'static_cast'" }
+ (void) static_cast<C&>(d2); // { dg-error "invalid 'static_cast'" }
+ (void) static_cast<E2&>(e1); // { dg-error "invalid 'static_cast'" }
}
// below is benign since GCC computes the expected value.
struct D5: E1, E2, NE { char a[]; };
-ASSERT_AT_END (D5, a); // { dg-warning "offsetof within non-standard-layout" }
+ASSERT_AT_END (D5, a); // { dg-warning "'offsetof' within non-standard-layout" }
struct A2x_1 {
size_t n;
struct D22: A5x, E1, E2 { };
-ASSERT_AT_END (D22, a); // { dg-warning "offsetof within non-standard-layout" }
+ASSERT_AT_END (D22, a); // { dg-warning "'offsetof' within non-standard-layout" }
struct D23: E1, A5x, E2 { };
-ASSERT_AT_END (D23, a); // { dg-warning "offsetof within non-standard-layout" }
+ASSERT_AT_END (D23, a); // { dg-warning "'offsetof' within non-standard-layout" }
struct D24: E1, E2, A5x { };
-ASSERT_AT_END (D24, a); // { dg-warning "offsetof within non-standard-layout" }
+ASSERT_AT_END (D24, a); // { dg-warning "'offsetof' within non-standard-layout" }
struct DA5x: A5x { };
struct D25: DA5x, E1, E2 { };
-ASSERT_AT_END (D25, a); // { dg-warning "offsetof within non-standard-layout" }
+ASSERT_AT_END (D25, a); // { dg-warning "'offsetof' within non-standard-layout" }
struct D26: E1, DA5x, E2 { };
-ASSERT_AT_END (D26, a); // { dg-warning "offsetof within non-standard-layout" }
+ASSERT_AT_END (D26, a); // { dg-warning "'offsetof' within non-standard-layout" }
struct D27: E1, E2, DA5x { };
-ASSERT_AT_END (D27, a); // { dg-warning "offsetof within non-standard-layout" }
+ASSERT_AT_END (D27, a); // { dg-warning "'offsetof' within non-standard-layout" }
// Verfify that a flexible array member is diagnosed even when deep
// in the base class hierarchy.
const char16_t s16_3[] = L"ab"; /* { dg-error "from a string literal with type array of .wchar_t." } */
const char16_t s16_4[] = u8"ab"; /* { dg-error "from a string literal with type array of .char." } */
-const char16_t s16_5[0] = u"ab"; /* { dg-error "chars is too long" } */
-const char16_t s16_6[1] = u"ab"; /* { dg-error "chars is too long" } */
-const char16_t s16_7[2] = u"ab"; /* { dg-error "chars is too long" } */
+const char16_t s16_5[0] = u"ab"; /* { dg-error "initializer-string for 'const char16_t \\\[0]' is too long" } */
+const char16_t s16_6[1] = u"ab"; /* { dg-error "initializer-string for 'const char16_t \\\[1]' is too long" } */
+const char16_t s16_7[2] = u"ab"; /* { dg-error "initializer-string for 'const char16_t \\\[2]' is too long" } */
const char16_t s16_8[3] = u"ab";
const char16_t s16_9[4] = u"ab";
const char32_t s32_3[] = L"ab"; /* { dg-error "from a string literal with type array of .wchar_t." } */
const char32_t s32_4[] = u8"ab"; /* { dg-error "from a string literal with type array of .char." } */
-const char32_t s32_5[0] = U"ab"; /* { dg-error "chars is too long" } */
-const char32_t s32_6[1] = U"ab"; /* { dg-error "chars is too long" } */
-const char32_t s32_7[2] = U"ab"; /* { dg-error "chars is too long" } */
+const char32_t s32_5[0] = U"ab"; /* { dg-error "initializer-string for 'const char32_t \\\[0]' is too long" } */
+const char32_t s32_6[1] = U"ab"; /* { dg-error "initializer-string for 'const char32_t \\\[1]' is too long" } */
+const char32_t s32_7[2] = U"ab"; /* { dg-error "initializer-string for 'const char32_t \\\[2]' is too long" } */
const char32_t s32_8[3] = U"ab";
const char32_t s32_9[4] = U"ab";
const char16_t s16_3[] = L"ab"; /* { dg-error "from a string literal with type array of .wchar_t." } */
const char16_t s16_4[] = u8"ab"; /* { dg-error "from a string literal with type array of .char." } */
-const char16_t s16_5[0] = u"ab"; /* { dg-error "chars is too long" } */
-const char16_t s16_6[1] = u"ab"; /* { dg-error "chars is too long" } */
-const char16_t s16_7[2] = u"ab"; /* { dg-error "chars is too long" } */
+const char16_t s16_5[0] = u"ab"; /* { dg-error "initializer-string for 'const char16_t \\\[0]' is too long" } */
+const char16_t s16_6[1] = u"ab"; /* { dg-error "initializer-string for 'const char16_t \\\[1]' is too long" } */
+const char16_t s16_7[2] = u"ab"; /* { dg-error "initializer-string for 'const char16_t \\\[2]' is too long" } */
const char16_t s16_8[3] = u"ab";
const char16_t s16_9[4] = u"ab";
const char32_t s32_3[] = L"ab"; /* { dg-error "from a string literal with type array of .wchar_t." } */
const char32_t s32_4[] = u8"ab"; /* { dg-error "from a string literal with type array of .char." } */
-const char32_t s32_5[0] = U"ab"; /* { dg-error "chars is too long" } */
-const char32_t s32_6[1] = U"ab"; /* { dg-error "chars is too long" } */
-const char32_t s32_7[2] = U"ab"; /* { dg-error "chars is too long" } */
+const char32_t s32_5[0] = U"ab"; /* { dg-error "initializer-string for 'const char32_t \\\[0]' is too long" } */
+const char32_t s32_6[1] = U"ab"; /* { dg-error "initializer-string for 'const char32_t \\\[1]' is too long" } */
+const char32_t s32_7[2] = U"ab"; /* { dg-error "initializer-string for 'const char32_t \\\[2]' is too long" } */
const char32_t s32_8[3] = U"ab";
const char32_t s32_9[4] = U"ab";
const char32_t s2[] = u8"ab"; // { dg-error "from a string literal with type array of .char." }
const wchar_t s3[] = u8"ab"; // { dg-error "from a string literal with type array of .char." }
-const u8_char_t t0[0] = u8"ab"; // { dg-error "chars is too long" }
-const u8_char_t t1[1] = u8"ab"; // { dg-error "chars is too long" }
-const u8_char_t t2[2] = u8"ab"; // { dg-error "chars is too long" }
+const u8_char_t t0[0] = u8"ab"; // { dg-error "initializer-string for 'const u8_char_t \\\[0]' {aka 'const char \\\[0]'} is too long" }
+const u8_char_t t1[1] = u8"ab"; // { dg-error "initializer-string for 'const u8_char_t \\\[1]' {aka 'const char \\\[1]'} is too long" }
+const u8_char_t t2[2] = u8"ab"; // { dg-error "initializer-string for 'const u8_char_t \\\[2]' {aka 'const char \\\[2]'} is too long" }
const u8_char_t t3[3] = u8"ab";
const u8_char_t t4[4] = u8"ab";
-const u8_char_t u0[0] = u8"\u2160."; // { dg-error "chars is too long" }
-const u8_char_t u1[1] = u8"\u2160."; // { dg-error "chars is too long" }
-const u8_char_t u2[2] = u8"\u2160."; // { dg-error "chars is too long" }
-const u8_char_t u3[3] = u8"\u2160."; // { dg-error "chars is too long" }
-const u8_char_t u4[4] = u8"\u2160."; // { dg-error "chars is too long" }
+const u8_char_t u0[0] = u8"\u2160."; // { dg-error "initializer-string for 'const u8_char_t \\\[0]' {aka 'const char \\\[0]'} is too long" }
+const u8_char_t u1[1] = u8"\u2160."; // { dg-error "initializer-string for 'const u8_char_t \\\[1]' {aka 'const char \\\[1]'} is too long" }
+const u8_char_t u2[2] = u8"\u2160."; // { dg-error "initializer-string for 'const u8_char_t \\\[2]' {aka 'const char \\\[2]'} is too long" }
+const u8_char_t u3[3] = u8"\u2160."; // { dg-error "initializer-string for 'const u8_char_t \\\[3]' {aka 'const char \\\[3]'} is too long" }
+const u8_char_t u4[4] = u8"\u2160."; // { dg-error "initializer-string for 'const u8_char_t \\\[4]' {aka 'const char \\\[4]'} is too long" }
const u8_char_t u5[5] = u8"\u2160.";
const u8_char_t u6[6] = u8"\u2160.";
for (i = 64; i != 0; i += k)
;
#pragma omp for
- for (i = 0; i != 64; i += m) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = 0; i != 64; i += m) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
#pragma omp for
- for (i = 64; i != 0; i -= m) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = 64; i != 0; i -= m) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
#pragma omp for
- for (i = 0; i != 64; i -= n) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = 0; i != 64; i -= n) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
#pragma omp for
- for (i = 64; i != 0; i += n) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = 64; i != 0; i += n) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
#pragma omp for
- for (i = 0; i != 64; i += o) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = 0; i != 64; i += o) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
#pragma omp for
- for (i = 64; i != 0; i -= o) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = 64; i != 0; i -= o) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
#pragma omp for
- for (i = 0; i != 64; i -= p) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = 0; i != 64; i -= p) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
#pragma omp for
- for (i = 64; i != 0; i += p) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = 64; i != 0; i += p) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
}
for (i = y; i != x; i = l + i)
;
#pragma omp for
- for (i = x; i != y; i = i + 2) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = x; i != y; i = i + 2) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
#pragma omp for
- for (i = x; i != y; i = 7 + i) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = x; i != y; i = 7 + i) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
#pragma omp for
- for (i = y; i != x; i = i - 2) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = y; i != x; i = i - 2) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
#pragma omp for
- for (i = y; i != x; i = -7 + i) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = y; i != x; i = -7 + i) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
#pragma omp for
- for (i = x; i != y; i = i + m) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = x; i != y; i = i + m) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
#pragma omp for
- for (i = x; i != y; i = m + i) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = x; i != y; i = m + i) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
#pragma omp for
- for (i = y; i != x; i = i - m) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = y; i != x; i = i - m) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
#pragma omp for
- for (i = y; i != x; i = -m + i) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = y; i != x; i = -m + i) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
#pragma omp for
- for (i = x; i != y; i = i - n) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = x; i != y; i = i - n) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
#pragma omp for
- for (i = x; i != y; i = -n + i) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = x; i != y; i = -n + i) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
#pragma omp for
- for (i = y; i != x; i = i + n) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = y; i != x; i = i + n) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
#pragma omp for
- for (i = y; i != x; i = n + i) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = y; i != x; i = n + i) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
#pragma omp for
- for (i = x; i != y; i = i + o) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = x; i != y; i = i + o) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
#pragma omp for
- for (i = x; i != y; i = o + i) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = x; i != y; i = o + i) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
#pragma omp for
- for (i = y; i != x; i = i - o) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = y; i != x; i = i - o) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
#pragma omp for
- for (i = y; i != x; i = -o + i) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = y; i != x; i = -o + i) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
#pragma omp for
- for (i = x; i != y; i = i - p) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = x; i != y; i = i - p) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
#pragma omp for
- for (i = x; i != y; i = -p + i) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = x; i != y; i = -p + i) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
#pragma omp for
- for (i = y; i != x; i = i + p) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = y; i != x; i = i + p) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
#pragma omp for
- for (i = y; i != x; i = p + i) // { dg-error "increment is not constant 1 or -1 for != condition" }
+ for (i = y; i != x; i = p + i) // { dg-error "increment is not constant 1 or -1 for '!=' condition" }
;
}
void
foo (void)
{
-#pragma omp p // { dg-warning "-:ignoring #pragma omp _Pragma" }
+#pragma omp p // { dg-warning "-:ignoring '#pragma omp _Pragma'" }
bar ();
- omp_p // { dg-warning "-:ignoring #pragma omp _Pragma" }
+ omp_p // { dg-warning "-:ignoring '#pragma omp _Pragma'" }
bar ();
}
void
baz (void)
{
-#pragma omp parallel // { dg-warning "-:ignoring #pragma omp serial" }
+#pragma omp parallel // { dg-warning "-:ignoring '#pragma omp serial'" }
bar ();
- omp_parallel // { dg-warning "-:ignoring #pragma omp serial" }
+ omp_parallel // { dg-warning "-:ignoring '#pragma omp serial'" }
bar ();
}
namespace N6
{
struct A { int a; A () : a (0) {} };
- #pragma omp declare reduction (| : const A : omp_out.a |= omp_in.a) // { dg-error "const, volatile or __restrict" }
- #pragma omp declare reduction (+ : __const A : omp_out.a += omp_in.a) // { dg-error "const, volatile or __restrict" }
+ #pragma omp declare reduction (| : const A : omp_out.a |= omp_in.a) // { dg-error "'const', 'volatile' or '__restrict'" }
+ #pragma omp declare reduction (+ : __const A : omp_out.a += omp_in.a) // { dg-error "'const', 'volatile' or '__restrict'" }
typedef volatile A T;
- #pragma omp declare reduction (min : T : omp_out.a += omp_in.a) // { dg-error "const, volatile or __restrict" }
- #pragma omp declare reduction (* : A *__restrict : omp_out->a *= omp_in->a)// { dg-error "const, volatile or __restrict" }
+ #pragma omp declare reduction (min : T : omp_out.a += omp_in.a) // { dg-error "'const', 'volatile' or '__restrict'" }
+ #pragma omp declare reduction (* : A *__restrict : omp_out->a *= omp_in->a)// { dg-error "'const', 'volatile' or '__restrict'" }
}
namespace N7
{
template <typename T1, typename T2, typename T3, typename T4>
struct S
{
- #pragma omp declare reduction (| : T1 : omp_out |= omp_in) // { dg-error "const, volatile or __restrict" }
- #pragma omp declare reduction (+ : T2 : omp_out += omp_in) // { dg-error "const, volatile or __restrict" }
+ #pragma omp declare reduction (| : T1 : omp_out |= omp_in) // { dg-error "'const', 'volatile' or '__restrict'" }
+ #pragma omp declare reduction (+ : T2 : omp_out += omp_in) // { dg-error "'const', 'volatile' or '__restrict'" }
typedef T3 T;
- #pragma omp declare reduction (min : T : omp_out += omp_in) // { dg-error "const, volatile or __restrict" }
- #pragma omp declare reduction (* : T4 : omp_out *= omp_in) // { dg-error "const, volatile or __restrict" }
+ #pragma omp declare reduction (min : T : omp_out += omp_in) // { dg-error "'const', 'volatile' or '__restrict'" }
+ #pragma omp declare reduction (* : T4 : omp_out *= omp_in) // { dg-error "'const', 'volatile' or '__restrict'" }
};
S<const A, __const A, volatile A, A *__restrict> s;
template <typename T1, typename T2, typename T3, typename T4>
int foo ()
{
- #pragma omp declare reduction (| : T1 : omp_out |= omp_in) // { dg-error "const, volatile or __restrict" }
- #pragma omp declare reduction (+ : T2 : omp_out += omp_in) // { dg-error "const, volatile or __restrict" }
+ #pragma omp declare reduction (| : T1 : omp_out |= omp_in) // { dg-error "'const', 'volatile' or '__restrict'" }
+ #pragma omp declare reduction (+ : T2 : omp_out += omp_in) // { dg-error "'const', 'volatile' or '__restrict'" }
typedef T3 T;
- #pragma omp declare reduction (min : T : omp_out += omp_in) // { dg-error "const, volatile or __restrict" }
- #pragma omp declare reduction (* : T4 : omp_out *= omp_in) // { dg-error "const, volatile or __restrict" }
+ #pragma omp declare reduction (min : T : omp_out += omp_in) // { dg-error "'const', 'volatile' or '__restrict'" }
+ #pragma omp declare reduction (* : T4 : omp_out *= omp_in) // { dg-error "'const', 'volatile' or '__restrict'" }
return 0;
}
int x = foo <const A, __const A, volatile A, A *__restrict> ();
/* Verify that we highlight *which* string is too long. */
-char test[3][4] = { "ok", "too long", "ok" }; // { dg-error "initializer-string for array of chars is too long" }
+char test[3][4] = { "ok", "too long", "ok" }; // { dg-error "initializer-string for 'char \\\[4]' is too long" }
/* { dg-begin-multiline-output "" }
char test[3][4] = { "ok", "too long", "ok" };
^~~~~~~~~~
struct A { int i; };
struct B : virtual A { };
-__SIZE_TYPE__ s = __builtin_offsetof (B, A::i); // { dg-warning "offsetof within non-standard-layout type" }
+__SIZE_TYPE__ s = __builtin_offsetof (B, A::i); // { dg-warning "'offsetof' within non-standard-layout type" }
template <typename T>
__SIZE_TYPE__
foo ()
{
- return __builtin_offsetof (T, A::i) // { dg-warning "offsetof within non-standard-layout type" }
- + __builtin_offsetof (B, A::i); // { dg-warning "offsetof within non-standard-layout type" }
+ return __builtin_offsetof (T, A::i) // { dg-warning "'offsetof' within non-standard-layout type" }
+ + __builtin_offsetof (B, A::i); // { dg-warning "'offsetof' within non-standard-layout type" }
}
__SIZE_TYPE__ t = foo<B> ();
if (b != 2)
a <<= b;
// { dg-error "5 << -2.. is negative" "" { target *-*-* } .-1 }
- // { dg-error "is >= than the precision of the left operand" "" { target *-*-* } .-2 }
+ // { dg-error "is greater than or equal to the precision of the left operand" "" { target *-*-* } .-2 }
// { dg-error "-2 << 4.. is negative" "" { target *-*-* } .-3 }
return a;
}
if (b != 2)
a >>= b;
// { dg-error "4 >> -1.. is negative" "" { target *-*-* } .-1 }
- // { dg-error "is >= than the precision of the left operand" "" { target *-*-* } .-2 }
+ // { dg-error "is greater than or equal to the precision of the left operand" "" { target *-*-* } .-2 }
return a;
}
decltype (~c{})
call ()
{
- return ~false; // { dg-warning "on an expression of type bool" }
+ return ~false; // { dg-warning "on an expression of type 'bool'" }
}
template int call<bool>();
void c (unsigned int x)
{
- if (x < 0) return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
- if (x >= 0) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
- if (0 > x) return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
- if (0 <= x) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
+ if (x < 0) return;/* { dg-warning "comparison of unsigned expression in '< 0' is always false" } */
+ if (x >= 0) return;/* { dg-warning "comparison of unsigned expression in '>= 0' is always true" } */
+ if (0 > x) return;/* { dg-warning "comparison of unsigned expression in '< 0' is always false" } */
+ if (0 <= x) return;/* { dg-warning "comparison of unsigned expression in '>= 0' is always true" } */
if (1U >= 0) return;
if (1U < 0) return;
if (0 <= 1U) return;
void d (unsigned long x)
{
- if (x < 0) return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
- if (x >= 0) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
- if (0 > x) return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
- if (0 <= x) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
+ if (x < 0) return;/* { dg-warning "comparison of unsigned expression in '< 0' is always false" } */
+ if (x >= 0) return;/* { dg-warning "comparison of unsigned expression in '>= 0' is always true" } */
+ if (0 > x) return;/* { dg-warning "comparison of unsigned expression in '< 0' is always false" } */
+ if (0 <= x) return;/* { dg-warning "comparison of unsigned expression in '>= 0' is always true" } */
}
void e (unsigned long long x)
{
- if (x < 0) return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
- if (x >= 0) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
- if (0 > x) return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
- if (0 <= x) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
+ if (x < 0) return;/* { dg-warning "comparison of unsigned expression in '< 0' is always false" } */
+ if (x >= 0) return;/* { dg-warning "comparison of unsigned expression in '>= 0' is always true" } */
+ if (0 > x) return;/* { dg-warning "comparison of unsigned expression in '< 0' is always false" } */
+ if (0 <= x) return;/* { dg-warning "comparison of unsigned expression in '>= 0' is always true" } */
}
int test (int x)
void c (unsigned int x)
{
- if (x < 0) return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
- if (x >= 0) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
- if (0 > x) return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
- if (0 <= x) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
+ if (x < 0) return;/* { dg-warning "comparison of unsigned expression in '< 0' is always false" } */
+ if (x >= 0) return;/* { dg-warning "comparison of unsigned expression in '>= 0' is always true" } */
+ if (0 > x) return;/* { dg-warning "comparison of unsigned expression in '< 0' is always false" } */
+ if (0 <= x) return;/* { dg-warning "comparison of unsigned expression in '>= 0' is always true" } */
if (1U >= 0) return;
if (1U < 0) return;
if (0 <= 1U) return;
void d (unsigned long x)
{
- if (x < 0) return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
- if (x >= 0) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
- if (0 > x) return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
- if (0 <= x) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
+ if (x < 0) return;/* { dg-warning "comparison of unsigned expression in '< 0' is always false" } */
+ if (x >= 0) return;/* { dg-warning "comparison of unsigned expression in '>= 0' is always true" } */
+ if (0 > x) return;/* { dg-warning "comparison of unsigned expression in '< 0' is always false" } */
+ if (0 <= x) return;/* { dg-warning "comparison of unsigned expression in '>= 0' is always true" } */
}
void e (unsigned long long x)
{
- if (x < 0) return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
- if (x >= 0) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
- if (0 > x) return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
- if (0 <= x) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
+ if (x < 0) return;/* { dg-warning "comparison of unsigned expression in '< 0' is always false" } */
+ if (x >= 0) return;/* { dg-warning "comparison of unsigned expression in '>= 0' is always true" } */
+ if (0 > x) return;/* { dg-warning "comparison of unsigned expression in '< 0' is always false" } */
+ if (0 <= x) return;/* { dg-warning "comparison of unsigned expression in '>= 0' is always true" } */
}
int test (int x)
return;
if (N >= FOO)
return;
- if (n >= 0) // { dg-warning ">= 0 is always true" }
+ if (n >= 0) // { dg-warning "'>= 0' is always true" }
return;
- if (n < 0) // { dg-warning "< 0 is always false" }
+ if (n < 0) // { dg-warning "'< 0' is always false" }
return;
if (n >= FOO)
return;
return;
if (0 <= FOO)
return;
- if (0 <= n) // { dg-warning ">= 0 is always true" }
+ if (0 <= n) // { dg-warning "'>= 0' is always true" }
return;
- if (0 > n) // { dg-warning "< 0 is always false" }
+ if (0 > n) // { dg-warning "'< 0' is always false" }
return;
if (N <= FOO)
return;
}
void throw_an_unexpected_exception() throw() {
- throw 1; // { dg-warning "throw will always call terminate" "" { target c++17 } }
+ throw 1; // { dg-warning "'throw' will always call 'terminate'" "" { target c++17 } }
}
int main() {
unsigned int
f0 (int x, unsigned int y)
{
- return x ? y : -1; /* { dg-warning "18:operand of \\?: changes signedness from 'int' to 'unsigned int'" } */
+ return x ? y : -1; /* { dg-warning "18:operand of '\\?:' changes signedness from 'int' to 'unsigned int'" } */
/* { dg-begin-multiline-output "" }
return x ? y : -1;
^~
unsigned int
f1 (int xxx, unsigned int yyy)
{
- return xxx ? yyy : -1; /* { dg-warning "22:operand of \\?: changes signedness from 'int' to 'unsigned int'" } */
+ return xxx ? yyy : -1; /* { dg-warning "22:operand of '\\?:' changes signedness from 'int' to 'unsigned int'" } */
/* { dg-begin-multiline-output "" }
return xxx ? yyy : -1;
^~
unsigned int
f2 (int xxx, unsigned int yyy)
{
- return xxx ? -1 : yyy; /* { dg-warning "16:operand of \\?: changes signedness from 'int' to 'unsigned int'" } */
+ return xxx ? -1 : yyy; /* { dg-warning "16:operand of '\\?:' changes signedness from 'int' to 'unsigned int'" } */
/* { dg-begin-multiline-output "" }
return xxx ? -1 : yyy;
^~
unsigned int
f3 (unsigned int yyy)
{
- return yyy ?: -1; /* { dg-warning "17:operand of \\?: changes signedness from 'int' to 'unsigned int'" } */
+ return yyy ?: -1; /* { dg-warning "17:operand of '\\?:' changes signedness from 'int' to 'unsigned int'" } */
/* { dg-begin-multiline-output "" }
return yyy ?: -1;
^~
unsigned int
f4 (int xxx, unsigned yyy, short uuu)
{
- return xxx ? yyy : uuu; /* { dg-warning "22:operand of \\?: changes signedness from 'short int' to 'unsigned int'" } */
+ return xxx ? yyy : uuu; /* { dg-warning "22:operand of '\\?:' changes signedness from 'short int' to 'unsigned int'" } */
/* { dg-begin-multiline-output "" }
return xxx ? yyy : uuu;
^~~
unsigned int
f5 (int xxx, unsigned yyy, short uuu)
{
- return xxx ? uuu : yyy; /* { dg-warning "16:operand of \\?: changes signedness from 'short int' to 'unsigned int'" } */
+ return xxx ? uuu : yyy; /* { dg-warning "16:operand of '\\?:' changes signedness from 'short int' to 'unsigned int'" } */
/* { dg-begin-multiline-output "" }
return xxx ? uuu : yyy;
^~~
unsigned int
f6 (int xxx, unsigned yyy, signed char uuu)
{
- return xxx ? yyy : uuu; /* { dg-warning "22:operand of \\?: changes signedness from 'signed char' to 'unsigned int'" } */
+ return xxx ? yyy : uuu; /* { dg-warning "22:operand of '\\?:' changes signedness from 'signed char' to 'unsigned int'" } */
/* { dg-begin-multiline-output "" }
return xxx ? yyy : uuu;
^~~
unsigned int
f7 (int xxx, unsigned yyy, signed char uuu)
{
- return xxx ? uuu : yyy; /* { dg-warning "16:operand of \\?: changes signedness from 'signed char' to 'unsigned int'" } */
+ return xxx ? uuu : yyy; /* { dg-warning "16:operand of '\\?:' changes signedness from 'signed char' to 'unsigned int'" } */
/* { dg-begin-multiline-output "" }
return xxx ? uuu : yyy;
^~~
}
void b (unsigned short x)
-{ /* { dg-warning "comparison of unsigned expression < 0 is always false" "" { target { ! int32plus } } .+1 } */
+{ /* { dg-warning "comparison of unsigned expression '< 0' is always false" "" { target { ! int32plus } } .+1 } */
if (x < 0) return;/* { dg-warning "comparison is always false due to limited range of data type" "" { target { int32plus } } } */
- /* { dg-warning "comparison of unsigned expression >= 0 is always true" "" { target { ! int32plus } } .+1 } */
+ /* { dg-warning "comparison of unsigned expression '>= 0' is always true" "" { target { ! int32plus } } .+1 } */
if (x >= 0) return;/* { dg-warning "comparison is always true due to limited range of data type" "" { target { int32plus } } } */
- /* { dg-warning "comparison of unsigned expression < 0 is always false" "" { target { ! int32plus } } .+1 } */
+ /* { dg-warning "comparison of unsigned expression '< 0' is always false" "" { target { ! int32plus } } .+1 } */
if (0 > x) return;/* { dg-warning "comparison is always false due to limited range of data type" "" { target { int32plus } } } */
- /* { dg-warning "comparison of unsigned expression >= 0 is always true" "" { target { ! int32plus } } .+1 } */
+ /* { dg-warning "comparison of unsigned expression '>= 0' is always true" "" { target { ! int32plus } } .+1 } */
if (0 <= x) return;/* { dg-warning "comparison is always true due to limited range of data type" "" { target { int32plus } } } */
}
void c (unsigned int x)
{
- if (x < 0) return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
- if (x >= 0) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
- if (0 > x) return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
- if (0 <= x) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
+ if (x < 0) return;/* { dg-warning "comparison of unsigned expression in '< 0' is always false" } */
+ if (x >= 0) return;/* { dg-warning "comparison of unsigned expression in '>= 0' is always true" } */
+ if (0 > x) return;/* { dg-warning "comparison of unsigned expression in '< 0' is always false" } */
+ if (0 <= x) return;/* { dg-warning "comparison of unsigned expression in '>= 0' is always true" } */
if (1U >= 0) return;
if (1U < 0) return;
if (0 <= 1U) return;
void d (unsigned long x)
{
- if (x < 0) return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
- if (x >= 0) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
- if (0 > x) return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
- if (0 <= x) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
+ if (x < 0) return;/* { dg-warning "comparison of unsigned expression in '< 0' is always false" } */
+ if (x >= 0) return;/* { dg-warning "comparison of unsigned expression in '>= 0' is always true" } */
+ if (0 > x) return;/* { dg-warning "comparison of unsigned expression in '< 0' is always false" } */
+ if (0 <= x) return;/* { dg-warning "comparison of unsigned expression in '>= 0' is always true" } */
}
void e (unsigned long long x)
{
- if (x < 0) return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
- if (x >= 0) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
- if (0 > x) return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
- if (0 <= x) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
+ if (x < 0) return;/* { dg-warning "comparison of unsigned expression in '< 0' is always false" } */
+ if (x >= 0) return;/* { dg-warning "comparison of unsigned expression in '>= 0' is always true" } */
+ if (0 > x) return;/* { dg-warning "comparison of unsigned expression in '< 0' is always false" } */
+ if (0 <= x) return;/* { dg-warning "comparison of unsigned expression in '>= 0' is always true" } */
}
int test (int x)
}
void b (unsigned short x)
-{ /* { dg-warning "comparison of unsigned expression < 0 is always false" "" { target { ! int32plus } } .+1 } */
+{ /* { dg-warning "comparison of unsigned expression in '< 0' is always false" "" { target { ! int32plus } } .+1 } */
if (x < 0) return;/* { dg-warning "comparison is always false due to limited range of data type" "" { target { int32plus } } } */
- /* { dg-warning "comparison of unsigned expression >= 0 is always true" "" { target { ! int32plus } } .+1 } */
+ /* { dg-warning "comparison of unsigned expression in '>= 0' is always true" "" { target { ! int32plus } } .+1 } */
if (x >= 0) return;/* { dg-warning "comparison is always true due to limited range of data type" "" { target { int32plus } } } */
- /* { dg-warning "comparison of unsigned expression < 0 is always false" "" { target { ! int32plus } } .+1 } */
+ /* { dg-warning "comparison of unsigned expression in '< 0' is always false" "" { target { ! int32plus } } .+1 } */
if (0 > x) return;/* { dg-warning "comparison is always false due to limited range of data type" "" { target { int32plus } } } */
- /* { dg-warning "comparison of unsigned expression >= 0 is always true" "" { target { ! int32plus } } .+1 } */
+ /* { dg-warning "comparison of unsigned expression in '>= 0' is always true" "" { target { ! int32plus } } .+1 } */
if (0 <= x) return;/* { dg-warning "comparison is always true due to limited range of data type" "" { target { int32plus } } } */
}
void c (unsigned int x)
{
- if (x < 0) return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
- if (x >= 0) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
- if (0 > x) return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
- if (0 <= x) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
+ if (x < 0) return;/* { dg-warning "comparison of unsigned expression in '< 0' is always false" } */
+ if (x >= 0) return;/* { dg-warning "comparison of unsigned expression in '>= 0' is always true" } */
+ if (0 > x) return;/* { dg-warning "comparison of unsigned expression in '< 0' is always false" } */
+ if (0 <= x) return;/* { dg-warning "comparison of unsigned expression in '>= 0' is always true" } */
if (1U >= 0) return;
if (1U < 0) return;
if (0 <= 1U) return;
void d (unsigned long x)
{
- if (x < 0) return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
- if (x >= 0) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
- if (0 > x) return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
- if (0 <= x) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
+ if (x < 0) return;/* { dg-warning "comparison of unsigned expression in '< 0' is always false" } */
+ if (x >= 0) return;/* { dg-warning "comparison of unsigned expression in '>= 0' is always true" } */
+ if (0 > x) return;/* { dg-warning "comparison of unsigned expression in '< 0' is always false" } */
+ if (0 <= x) return;/* { dg-warning "comparison of unsigned expression in '>= 0' is always true" } */
}
void e (unsigned long long x)
{
- if (x < 0) return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
- if (x >= 0) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
- if (0 > x) return;/* { dg-warning "comparison of unsigned expression < 0 is always false" } */
- if (0 <= x) return;/* { dg-warning "comparison of unsigned expression >= 0 is always true" } */
+ if (x < 0) return;/* { dg-warning "comparison of unsigned expression in '< 0' is always false" } */
+ if (x >= 0) return;/* { dg-warning "comparison of unsigned expression in '>= 0' is always true" } */
+ if (0 > x) return;/* { dg-warning "comparison of unsigned expression in '< 0' is always false" } */
+ if (0 <= x) return;/* { dg-warning "comparison of unsigned expression in '>= 0' is always true" } */
}
int test (int x)
/* We used to get "unspellable token: CPP_EOF" warnings. */
-#pragma /* { dg-warning "-:ignoring #pragma" } */
-#pragma ~ /* { dg-warning "-:ignoring #pragma" } */
-#pragma baz /* { dg-warning "-:ignoring #pragma" } */
-#pragma baz baz /* { dg-warning "-:ignoring #pragma" } */
+#pragma /* { dg-warning "-:ignoring '#pragma" } */
+#pragma ~ /* { dg-warning "-:ignoring '#pragma" } */
+#pragma baz /* { dg-warning "-:ignoring '#pragma" } */
+#pragma baz baz /* { dg-warning "-:ignoring '#pragma baz baz'" } */
/* With FLOAT_CONST_DECIMAL64 switched to ON these would have type
_Decimal64. */
-double b = VAL; /* { dg-warning "unsuffixed float constant" } */
-double c = 1.2; /* { dg-warning "unsuffixed float constant" } */
+double b = VAL; /* { dg-warning "unsuffixed floating constant" } */
+double c = 1.2; /* { dg-warning "unsuffixed floating constant" } */
/* With FLOAT_CONST_DECIMAL64 switched to ON these are still binary. */
void foo ()
{
int i;
- __asm__ ("" : [data] "=r" (i) : [data] "i" (100)); /* { dg-error "duplicate asm operand" } */
+ __asm__ ("" : [data] "=r" (i) : [data] "i" (100)); /* { dg-error "duplicate 'asm' operand" } */
__asm__ ("%[foo]" :: [bar] "i" (1)); /* { dg-error "undefined named operand" } */
}
{
asm volatile ("");
- asm const (""); /* { dg-error {'const' is not an asm qualifier} } */
+ asm const (""); /* { dg-error {'const' is not a valid 'asm' qualifier} } */
- asm restrict (""); /* { dg-error {'restrict' is not an asm qualifier} } */
+ asm restrict (""); /* { dg-error {'restrict' is not a valid 'asm' qualifier} } */
}
A (32767) void* fpv_32km1 (void); /* { dg-warning ".assume_aligned. attribute argument 32767 is not a power of 2" } */
-A (4, -1) void* fpv_4_m1 (void); /* { dg-warning ".assume_aligned. attribute argument -1 is not in the range \\\[0, 4\\\)" } */
+A (4, -1) void* fpv_4_m1 (void); /* { dg-warning ".assume_aligned. attribute argument -1 is not in the range \\\[0, 3]" } */
A (4, 0) void* fpv_4_0 (void);
A (4, 1) void* fpv_4_1 (void);
A (4, 2) void* fpv_4_2 (void);
A (4, 3) void* fpv_4_3 (void);
-A (4, 4) void* fpv_4_3 (void); /* { dg-warning ".assume_aligned. attribute argument 4 is not in the range \\\[0, 4\\\)" } */
+A (4, 4) void* fpv_4_3 (void); /* { dg-warning ".assume_aligned. attribute argument 4 is not in the range \\\[0, 3]" } */
A (4) void* gpv_4_3 (void);
A (2) void* gpv_4_3 (void);
__extension__ typedef __INTPTR_TYPE__ intptr_t;
/* PR 29116. */
-int n = 0, p[n * 0 + 1]; /* { dg-error "variabl|can't be evaluated" } */
+int n = 0, p[n * 0 + 1]; /* { dg-error "variabl|cannot be evaluated" } */
/* PR 31871. */
-extern int c[1 + ((intptr_t) (void *) 0)]; /* { dg-error "variab|can't be evaluated" } */
+extern int c[1 + ((intptr_t) (void *) 0)]; /* { dg-error "variab|cannot be evaluated" } */
/* Implicit conversions from floating-point constants are not OK,
although explicit ones are. */
-extern int c1[1.0 ? 1 : 0]; /* { dg-error "variab|can't be evaluated" } */
+extern int c1[1.0 ? 1 : 0]; /* { dg-error "variab|cannot be evaluated" } */
extern int c2[(int)1.0 ? 1 : 0];
-extern int c3[1.0 && 1]; /* { dg-error "variab|can't be evaluated" } */
+extern int c3[1.0 && 1]; /* { dg-error "variab|cannot be evaluated" } */
extern int c4[(int)1.0 && 1];
-extern int c5[1.0 || 1]; /* { dg-error "variab|can't be evaluated" } */
+extern int c5[1.0 || 1]; /* { dg-error "variab|cannot be evaluated" } */
extern int c6[(int)1.0 || 1];
void
f (int a)
{
- int v[1 + ((intptr_t) (void *) 0)]; /* { dg-error "variab|can't be evaluated" } */
+ int v[1 + ((intptr_t) (void *) 0)]; /* { dg-error "variab|cannot be evaluated" } */
switch (a)
{
case (n * 0 + 1): /* { dg-error "constant" } */
(union u) l; /* { dg-error "cast to union type from type not present in union" } */
(int) sv; /* { dg-error "aggregate value used where an integer was expected" } */
(int) uv; /* { dg-error "aggregate value used where an integer was expected" } */
- (float) sv; /* { dg-error "aggregate value used where a float was expected" } */
- (float) uv; /* { dg-error "aggregate value used where a float was expected" } */
+ (float) sv; /* { dg-error "aggregate value used where a floating point was expected" } */
+ (float) uv; /* { dg-error "aggregate value used where a floating point was expected" } */
(_Complex double) sv; /* { dg-error "aggregate value used where a complex was expected" } */
(_Complex double) uv; /* { dg-error "aggregate value used where a complex was expected" } */
(void *) sv; /* { dg-error "cannot convert to a pointer type" } */
(union u) l; /* { dg-error "cast to union type from type not present in union" } */
(int) sv; /* { dg-error "aggregate value used where an integer was expected" } */
(int) uv; /* { dg-error "aggregate value used where an integer was expected" } */
- (float) sv; /* { dg-error "aggregate value used where a float was expected" } */
- (float) uv; /* { dg-error "aggregate value used where a float was expected" } */
+ (float) sv; /* { dg-error "aggregate value used where a floating point was expected" } */
+ (float) uv; /* { dg-error "aggregate value used where a floating point was expected" } */
(_Complex double) sv; /* { dg-error "aggregate value used where a complex was expected" } */
(_Complex double) uv; /* { dg-error "aggregate value used where a complex was expected" } */
(void *) sv; /* { dg-error "cannot convert to a pointer type" } */
(union u) l; /* { dg-error "cast to union type from type not present in union" } */
(int) sv; /* { dg-error "aggregate value used where an integer was expected" } */
(int) uv; /* { dg-error "aggregate value used where an integer was expected" } */
- (float) sv; /* { dg-error "aggregate value used where a float was expected" } */
- (float) uv; /* { dg-error "aggregate value used where a float was expected" } */
+ (float) sv; /* { dg-error "aggregate value used where a floating point was expected" } */
+ (float) uv; /* { dg-error "aggregate value used where a floating point was expected" } */
(_Complex double) sv; /* { dg-error "aggregate value used where a complex was expected" } */
(_Complex double) uv; /* { dg-error "aggregate value used where a complex was expected" } */
(void *) sv; /* { dg-error "cannot convert to a pointer type" } */
int
main(void)
{
- __builtin_printf ("%s %s\n", __DATE__, __TIME__); /* { dg-error "SOURCE_DATE_EPOCH must expand" } */
+ __builtin_printf ("%s %s\n", __DATE__, __TIME__); /* { dg-error "environment variable 'SOURCE_DATE_EPOCH' must expand" } */
__builtin_printf ("%s %s\n", __DATE__, __TIME__);
return 0;
}
foo (void)
{
static char a[0] = "";
- static char b[0] = "b"; /* { dg-warning "initializer-string for array of chars is too long" } */
+ static char b[0] = "b"; /* { dg-warning "initializer-string for array of 'char' is too long" } */
static char c[1] = "c";
- static char d[1] = "de"; /* { dg-warning "initializer-string for array of chars is too long" } */
+ static char d[1] = "de"; /* { dg-warning "initializer-string for array of 'char' is too long" } */
}
(struct s) d128; /* { dg-error "conversion to non-scalar type requested" } */
(union u) d128; /* { dg-error "cast to union type from type not present in union" } */
- (_Decimal32) sv; /* { dg-error "aggregate value used where a float was expected" } */
- (_Decimal32) uv; /* { dg-error "aggregate value used where a float was expected" } */
- (_Decimal64) sv; /* { dg-error "aggregate value used where a float was expected" } */
- (_Decimal64) uv; /* { dg-error "aggregate value used where a float was expected" } */
- (_Decimal128) sv; /* { dg-error "aggregate value used where a float was expected" } */
- (_Decimal128) uv; /* { dg-error "aggregate value used where a float was expected" } */
+ (_Decimal32) sv; /* { dg-error "aggregate value used where a floating point was expected" } */
+ (_Decimal32) uv; /* { dg-error "aggregate value used where a floating point was expected" } */
+ (_Decimal64) sv; /* { dg-error "aggregate value used where a floating point was expected" } */
+ (_Decimal64) uv; /* { dg-error "aggregate value used where a floating point was expected" } */
+ (_Decimal128) sv; /* { dg-error "aggregate value used where a floating point was expected" } */
+ (_Decimal128) uv; /* { dg-error "aggregate value used where a floating point was expected" } */
}
--- /dev/null
+/* Test warnings for for GCC diagnostics.
+ { dg-do compile }
+ { dg-options "-Wformat -Wformat-diag" } */
+
+/* Magic identifiers must be set before the attribute is used. */
+
+typedef long long __gcc_host_wide_int__;
+
+typedef struct location_s
+{
+ const char *file;
+ int line;
+} location_t;
+
+union tree_node;
+typedef union tree_node *tree;
+
+/* Define gimple as a dummy type. The typedef must be provided for
+ the C test to find the symbol. */
+typedef struct gimple gimple;
+
+/* Likewise for gimple. */
+typedef struct cgraph_node cgraph_node;
+
+#define FORMAT(kind) __attribute__ ((format (__gcc_## kind ##__, 1, 2)))
+
+/* Basic formatting function like pp_format. */
+void diag (const char*, ...) FORMAT (diag);
+
+/* Diagnostic formatting function like error or warning declared
+ by the C front end. */
+void cdiag (const char*, ...) FORMAT (cdiag);
+
+/* Diagnostic formatting function like error or warning declared
+ by the middle-end or back-end. */
+void tdiag (const char*, ...) FORMAT (tdiag);
+
+/* Diagnostic formatting function like error or warning declared
+ by the C++ front-end. */
+void cxxdiag (const char*, ...) FORMAT (cxxdiag);
+
+void dump (const char*, ...) FORMAT (dump_printf);
+
+/* Verify that functions declared with the C/C++ front-end __gcc_cdiag__
+ attribute detect invalid whitespace in format strings. */
+
+void test_cdiag_whitespace (tree t, gimple *gc)
+{
+ (void)&t; (void)&gc;
+
+ cdiag (" a"); /* { dg-warning "spurious leading space character in format" } */
+ cdiag ("%< %>a");
+ cdiag ("%< %>a");
+ cdiag ("a b");
+ cdiag ("a b"); /* { dg-warning "unquoted sequence of 2 consecutive space characters" } */
+ cdiag ("a "); /* { dg-warning "spurious trailing space character" } */
+ cdiag ("a "); /* { dg-warning "spurious trailing space characters" } */
+ cdiag ("a%< %>");
+ cdiag ("a%< %>%< %>");
+ cdiag ("a%< %> "); /* { dg-warning "spurious trailing space character" } */
+ cdiag ("a%< %> %< %>"); /* { dg-warning "unquoted sequence of 2 consecutive space characters" } */
+
+ /* It's debatable whether the following two formst strings should
+ be cdiagnosed. They aren't only because it's simpler that way. */
+ cdiag ("a %< %>");
+ cdiag ("a%< %> %< %>");
+
+ /* Exercise other whitespace characters. */
+ cdiag ("a\fb"); /* { dg-warning "unquoted whitespace character '\\\\x0c'" } */
+ cdiag ("a\nb"); /* { dg-warning "unquoted whitespace character '\\\\x0a'" } */
+ cdiag ("a\rb"); /* { dg-warning "unquoted whitespace character '\\\\x0d'" } */
+ cdiag ("a\vb"); /* { dg-warning "unquoted whitespace character '\\\\x0b'" } */
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wformat-diag"
+
+ /* Verify that the warning can be suppressed. */
+ cdiag ("\ta\b c\vb\n");
+
+#pragma GCC diagnostic pop
+}
+
+
+void test_cdiag_control (tree t, gimple *gc)
+{
+ (void)&t; (void)&gc;
+
+ cdiag ("\1"); /* { dg-warning "unquoted control character '\\\\x01'" } */
+ cdiag ("a\ab"); /* { dg-warning "unquoted control character '\\\\x07'" } */
+ cdiag ("a\bb"); /* { dg-warning "unquoted control character '\\\\x08'" } */
+}
+
+
+void test_cdiag_punct (tree t, gimple *gc, int i)
+{
+ (void)&t; (void)&gc;
+
+ /* Exercise the period. */
+ cdiag (".abc"); /* { dg-warning "spurious leading punctuation character" } */
+ cdiag ("abc;"); /* { dg-warning "spurious trailing punctuation character" } */
+ /* Verify that sentences that start with an uppercase letter and end
+ in a period are not diagnosed. */
+ cdiag ("This is a full sentence.");
+ cdiag ("Capitalized sentence (with a parethetical note).");
+ cdiag ("Not a full sentence;"); /* { dg-warning "spurious trailing punctuation character" } */
+ cdiag ("Neither is this one,"); /* { dg-warning "spurious trailing punctuation character" } */
+
+ /* Exercise the ellipsis. */
+ cdiag ("this message...");
+ cdiag ("...continues here");
+ cdiag ("but...not here"); /* { dg-warning "unquoted sequence of 3 consecutive punctuation characters" } */
+
+ /* Exercise parentheses. */
+ cdiag ("null argument where non-null required (argument %i)", i);
+
+ /* Exercise C++. */
+ cdiag ("C++ is cool");
+ cdiag ("this is c++");
+ cdiag ("you can do this in C++ but not in C");
+
+ /* Exercise parenthetical note followed by a colon, semicolon,
+ or a comma. */
+ cdiag ("found a bug (here):");
+ cdiag ("because of another bug (over there); fix it");
+
+ cdiag ("found foo (123): go look at it");
+ cdiag ("missed bar (abc); will try harder next time");
+
+ cdiag ("expected this (or that), got something else (or who knows what)");
+}
+
+
+void test_cdiag_punct_balance (tree t, gimple *gc)
+{
+ (void)&t; (void)&gc;
+
+ cdiag ("f()"); /* { dg-warning "spurious trailing punctuation characters" } */
+ cdiag ("g(1)");
+ cdiag ("("); /* { dg-warning "spurious leading punctuation character|unbalanced" } */
+ cdiag ("()"); /* { dg-warning "spurious leading punctuation characters" } */
+ cdiag (")"); /* { dg-warning "unbalanced punctuation character '\\\)'" } */
+ cdiag ("f()g"); /* { dg-warning "unquoted sequence of 2 consecutive punctuation characters" } */
+ cdiag ("illegal operand (1)");
+}
+
+
+void test_cdiag_nongraph (tree t, gimple *gc)
+{
+ (void)&t; (void)&gc;
+
+ cdiag ("a\376b"); /* { dg-warning "unquoted non-graph character '\\\\xfe'" } */
+ cdiag ("a\377b"); /* { dg-warning "unquoted non-graph character '\\\\xff'" } */
+}
+
+
+void test_cdiag_attribute (tree t, gimple *gc)
+{
+ (void)&t; (void)&gc;
+
+ cdiag ("attribute foo");
+ cdiag ("this is attribute bar");
+ cdiag ("bad __attribute bar"); /* { dg-warning "unquoted attribute" } */
+ cdiag ("__attribute__ (foobar) bad"); /* { dg-warning "unquoted attribute" } */
+ cdiag ("__attribute__ ((foobar))"); /* { dg-warning "unquoted attribute" } */
+ cdiag ("__attribute__ (xxx))"); /* { dg-warning "unquoted attribute" } */
+ /* { dg-warning "unbalanced punctuation character '\\\)'" "xxx" { target *-*-* } .-1 } */
+ cdiag ("__attribute__ ((yyy)))"); /* { dg-warning "unquoted attribute" } */
+ /* { dg-warning "unbalanced punctuation character '\\\)'" "yyy" { target *-*-* } .-1 } */
+ cdiag ("__attribute__ ((zzz)"); /* { dg-warning "unquoted attribute" } */
+ /* { dg-warning "unbalanced punctuation character '\\\('" "zzz" { target *-*-* } .-1 } */
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wformat-diag"
+
+ /* Verify that the warning can be suppressed. */
+ cdiag ("__attribute__ (((");
+
+#pragma GCC diagnostic pop
+}
+
+void test_cdiag_builtin (tree t, gimple *gc)
+{
+ (void)&t; (void)&gc;
+
+ cdiag ("__builtin_abort"); /* { dg-warning "unquoted name of built-in function '__builtin_abort'" } */
+ cdiag ("in __builtin_trap"); /* { dg-warning "unquoted name of built-in function '__builtin_trap'" } */
+ cdiag ("__builtin_xyz bites");/* { dg-warning "unquoted name of built-in function '__builtin_xyz'" } */
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wformat-diag"
+
+ /* Verify that the warning can be suppressed. */
+ cdiag ("__builtin____with____lots__of__underscores");
+
+#pragma GCC diagnostic pop
+}
+
+void test_cdiag_option (tree t, gimple *gc)
+{
+ (void)&t; (void)&gc;
+
+ cdiag ("%<-Wall%>");
+ cdiag ("use option %<-Wextra%> to enable additinal warnings");
+
+ cdiag ("-O2 is fast"); /* { dg-warning "unquoted option name '-O2'" } */
+ cdiag ("but -O3 is faster"); /* { dg-warning "unquoted option name '-O3'" } */
+
+ cdiag ("get --help"); /* { dg-warning "unquoted option name '--help'" } */
+ cdiag ("enable -m32"); /* { dg-warning "unquoted option name '-m32'" } */
+ cdiag ("value is -12");
+ cdiag ("foo-O2");
+ cdiag ("a-W");
+}
+
+void test_cdiag_oper (tree t, gimple *gc)
+{
+ cdiag ("a == b"); /* { dg-warning "unquoted operator '=='" } */
+ cdiag ("++a"); /* { dg-warning "unquoted operator '\\\+\\\+'" } */
+ cdiag ("b--"); /* { dg-warning "unquoted operator '--'" } */
+}
void
f (void)
{
- c = (++a ? : b); /* { dg-warning "ISO C forbids omitting the middle term of a \\?: expression" } */
+ c = (++a ? : b); /* { dg-warning "ISO C forbids omitting the middle term of a '\\?:' expression" } */
}
void
f (void)
{
- c = (++a ? : b); /* { dg-error "ISO C forbids omitting the middle term of a \\?: expression" } */
+ c = (++a ? : b); /* { dg-error "ISO C forbids omitting the middle term of a '\\?:' expression" } */
}
void
foo (void)
{
-#pragma omp p /* { dg-warning "-:ignoring #pragma omp _Pragma" } */
+#pragma omp p /* { dg-warning "-:ignoring '#pragma omp _Pragma'" } */
bar ();
- omp_p /* { dg-warning "-:ignoring #pragma omp _Pragma" } */
+ omp_p /* { dg-warning "-:ignoring '#pragma omp _Pragma'" } */
bar ();
}
void
baz (void)
{
-#pragma omp parallel /* { dg-warning "-:ignoring #pragma omp serial" } */
+#pragma omp parallel /* { dg-warning "-:ignoring '#pragma omp serial'" } */
bar ();
- omp_parallel /* { dg-warning "-:ignoring #pragma omp serial" } */
+ omp_parallel /* { dg-warning "-:ignoring '#pragma omp serial'" } */
bar ();
}
char s[1] = "x";
char s1[1] = { "x" };
-char t[1] = "xy"; /* { dg-warning "initializer-string for array of chars is too long" } */
-char t1[1] = { "xy" }; /* { dg-warning "initializer-string for array of chars is too long" } */
-char u[1] = { "x", "x" }; /* { dg-error "excess elements in char array initializer" } */
+char t[1] = "xy"; /* { dg-warning "initializer-string for array of 'char' is too long" } */
+char t1[1] = { "xy" }; /* { dg-warning "initializer-string for array of 'char' is too long" } */
+char u[1] = { "x", "x" }; /* { dg-error "excess elements in 'char' array initializer" } */
/* { dg-message "near init" "near" { target *-*-* } .-1 } */
int i = { }; /* { dg-error "empty scalar initializer" } */
char s[1] = "x";
char s1[1] = { "x" };
-char t[1] = "xy"; /* { dg-warning "initializer-string for array of chars is too long" } */
-char t1[1] = { "xy" }; /* { dg-warning "initializer-string for array of chars is too long" } */
-char u[1] = { "x", "x" }; /* { dg-error "excess elements in char array initializer" } */
+char t[1] = "xy"; /* { dg-warning "initializer-string for array of 'char' is too long" } */
+char t1[1] = { "xy" }; /* { dg-warning "initializer-string for array of 'char' is too long" } */
+char u[1] = { "x", "x" }; /* { dg-error "excess elements in 'char' array initializer" } */
/* { dg-message "near init" "near" { target *-*-* } .-1 } */
int j = { 1 };
char s[1] = "x";
char s1[1] = { "x" };
-char t[1] = "xy"; /* { dg-error "initializer-string for array of chars is too long" } */
-char t1[1] = { "xy" }; /* { dg-error "initializer-string for array of chars is too long" } */
-char u[1] = { "x", "x" }; /* { dg-error "excess elements in char array initializer" } */
+char t[1] = "xy"; /* { dg-error "initializer-string for array of 'char' is too long" } */
+char t1[1] = { "xy" }; /* { dg-error "initializer-string for array of 'char' is too long" } */
+char u[1] = { "x", "x" }; /* { dg-error "excess elements in 'char' array initializer" } */
/* { dg-message "near init" "near" { target *-*-* } .-1 } */
int j = { 1 };
-/* Test diagnostics for parameter mismatches. Types that can't match
+/* Test diagnostics for parameter mismatches. Types that cannot match
(). */
/* Origin: Joseph Myers <joseph@codesourcery.com> */
/* { dg-do compile } */
void f0(); /* { dg-message "note: previous declaration of 'f0' was here" } */
void f0(int, ...); /* { dg-error "conflicting types for 'f0'" } */
-/* { dg-message "note: a parameter list with an ellipsis can't match an empty parameter name list declaration" "note" { target *-*-* } .-1 } */
+/* { dg-message "note: a parameter list with an ellipsis cannot match an empty parameter name list declaration" "note" { target *-*-* } .-1 } */
void f1(int, ...); /* { dg-message "note: previous declaration of 'f1' was here" } */
void f1(); /* { dg-error "conflicting types for 'f1'" } */
-/* { dg-message "note: a parameter list with an ellipsis can't match an empty parameter name list declaration" "note" { target *-*-* } .-1 } */
+/* { dg-message "note: a parameter list with an ellipsis cannot match an empty parameter name list declaration" "note" { target *-*-* } .-1 } */
void f2(); /* { dg-message "note: previous declaration of 'f2' was here" } */
void f2(char); /* { dg-error "conflicting types for 'f2'" } */
-/* { dg-message "note: an argument type that has a default promotion can't match an empty parameter name list declaration" "note" { target *-*-* } .-1 } */
+/* { dg-message "note: an argument type that has a default promotion cannot match an empty parameter name list declaration" "note" { target *-*-* } .-1 } */
void f3(char); /* { dg-message "note: previous declaration of 'f3' was here" } */
void f3(); /* { dg-error "conflicting types for 'f3'" } */
-/* { dg-message "note: an argument type that has a default promotion can't match an empty parameter name list declaration" "note" { target *-*-* } .-1 } */
+/* { dg-message "note: an argument type that has a default promotion cannot match an empty parameter name list declaration" "note" { target *-*-* } .-1 } */
foo (int *x, int y)
{
int constant = 0;
- asm ("# %0" :: "i" (x)); /* { dg-warning "probably doesn't match" } */
+ asm ("# %0" :: "i" (x)); /* { dg-warning "probably does not match" } */
/* { dg-error "impossible constraint" "" { target *-*-* } .-1 } */
- asm ("# %0" :: "i" (bar (*x))); /* { dg-warning "probably doesn't match" } */
+ asm ("# %0" :: "i" (bar (*x))); /* { dg-warning "probably does not match" } */
/* { dg-error "impossible constraint" "" { target *-*-* } .-1 } */
- asm ("# %0" :: "i" (*x + 0x11)); /* { dg-warning "probably doesn't match" } */
+ asm ("# %0" :: "i" (*x + 0x11)); /* { dg-warning "probably does not match" } */
/* { dg-error "impossible constraint" "" { target *-*-* } .-1 } */
- asm ("# %0" :: "i" (constant)); /* { dg-warning "probably doesn't match" } */
+ asm ("# %0" :: "i" (constant)); /* { dg-warning "probably does not match" } */
/* { dg-error "impossible constraint" "" { target *-*-* } .-1 } */
asm ("# %0" :: "i" (y * 0)); /* folded */
{
__asm volatile ("" : "=r" (*x)); /* { dg-warning "dereferencing" "deref" } */
} /* { dg-error "invalid use of void expression" "void expr" { target *-*-* } .-1 } */
- /* { dg-error "invalid lvalue in asm output 0" "invalid lvalue" { target *-*-* } .-2 } */
+ /* { dg-error "invalid lvalue in 'asm' output 0" "invalid lvalue" { target *-*-* } .-2 } */
void
f3 (void *x)
{
{
__asm volatile ("" : "=g" (*x)); /* { dg-warning "dereferencing" "deref" } */
} /* { dg-error "invalid use of void expression" "void expr" { target *-*-* } .-1 } */
- /* { dg-error "invalid lvalue in asm output 0" "invalid lvalue" { target *-*-* } .-2 } */
+ /* { dg-error "invalid lvalue in 'asm' output 0" "invalid lvalue" { target *-*-* } .-2 } */
void
f7 (struct S *x)
{
void
f8 (struct S *x)
{
- __asm volatile ("" : "=r" (*x)); /* { dg-error "invalid lvalue in asm output 0" } */
+ __asm volatile ("" : "=r" (*x)); /* { dg-error "invalid lvalue in 'asm' output 0" } */
}
{
__asm ("" : "=r" (*x)); /* { dg-warning "dereferencing" "deref" } */
} /* { dg-error "invalid use of void expression" "void expr" { target *-*-* } .-1 } */
- /* { dg-error "invalid lvalue in asm output 0" "invalid lvalue" { target *-*-* } .-2 } */
+ /* { dg-error "invalid lvalue in 'asm' output 0" "invalid lvalue" { target *-*-* } .-2 } */
void
f3 (void *x)
{
{
__asm ("" : "=g" (*x)); /* { dg-warning "dereferencing" "deref" } */
} /* { dg-error "invalid use of void expression" "void expr" { target *-*-* } .-1 } */
- /* { dg-error "invalid lvalue in asm output 0" "invalid lvalue" { target *-*-* } .-2 } */
+ /* { dg-error "invalid lvalue in 'asm' output 0" "invalid lvalue" { target *-*-* } .-2 } */
void
f7 (struct S *x)
{
void
f8 (struct S *x)
{
- __asm ("" : "=r" (*x)); /* { dg-error "invalid lvalue in asm output 0" } */
+ __asm ("" : "=r" (*x)); /* { dg-error "invalid lvalue in 'asm' output 0" } */
}
_Bool
fn3 (unsigned int p)
{
- return p >= 0U; /* { dg-warning "12:comparison of unsigned expression >= 0 is always true" } */
+ return p >= 0U; /* { dg-warning "12:comparison of unsigned expression in '>= 0' is always true" } */
}
_Bool
fn4 (unsigned int p)
{
- return p < 0U; /* { dg-warning "12:comparison of unsigned expression < 0 is always false" } */
+ return p < 0U; /* { dg-warning "12:comparison of unsigned expression in '< 0' is always false" } */
}
_Bool
__extension__ int a16[10] = {[2 ... 100] = 4 }; /* { dg-error "31:array index range in initializer exceeds array bounds" } */
int a17[] = { .B = 1 }; /* { dg-error "15:field name not in record or union initializer" } */
int a18[] = { e }; /* { dg-error "15:initializer element is not constant" } */
-char a19[1] = { "x", "x" }; /* { dg-error "22:excess elements in char array initializer" } */
+char a19[1] = { "x", "x" }; /* { dg-error "22:excess elements in 'char' array initializer" } */
void
bar (void)
void switch_to_stack (my_stack *stack){
asm ( /* { dg-error "impossible constraint" } */
-/* { dg-warning "asm operand 1" "asm operand 1" { target *-*-* } .-1 } */
+/* { dg-warning "'asm' operand 1" "asm operand 1" { target *-*-* } .-1 } */
"\n"
: "+r" (stack->regs)
);
{
if (__builtin_setjmp (buf) == 0)
__asm__ ("" : : "n" (a * 2)); /* { dg-error "impossible constraint in 'asm'" } */
- /* { dg-warning "asm operand 0 probably doesn't match constraints" "" { target *-*-* } .-1 } */
+ /* { dg-warning "'asm' operand 0 probably does not match constraints" "" { target *-*-* } .-1 } */
}
foo = (typeof (foo)) foo2;
/* Casted assignment between scalar and SIMD of different size. */
- foo1 = (typeof (foo1)) foo2; /* { dg-error "can't convert a vector of type" } */
+ foo1 = (typeof (foo1)) foo2; /* { dg-error "cannot convert a vector of type" } */
/* Operators on compatible SIMD types. */
a += b + b;
foo = a; /* { dg-error "incompatible types when assigning" } */
/* Casted assignment between scalar and SIMD of same size. */
- foo = (typeof (foo)) foo2; /* { dg-error "aggregate value used where a float was expected" } */
+ foo = (typeof (foo)) foo2; /* { dg-error "aggregate value used where a floating point was expected" } */
/* Casted assignment between scalar and SIMD of different size. */
- foo1 = (typeof (foo1)) foo2; /* { dg-error "aggregate value used where a float was expected" } */
+ foo1 = (typeof (foo1)) foo2; /* { dg-error "aggregate value used where a floating point was expected" } */
/* Operators on compatible SIMD types. */
a += b + b;
/* { dg-do compile } */
/* { dg-options "--param does-not-resemble-anything=42" } */
-/* { dg-error "invalid --param name .does-not-resemble-anything." "" { target *-*-* } 0 } */
+/* { dg-error "invalid '--param' name 'does-not-resemble-anything'" "" { target *-*-* } 0 } */
/* { dg-do compile } */
/* { dg-options "--param max-early-inliner-iteration=3" } */
-/* { dg-error "invalid --param name .max-early-inliner-iteration.; did you mean .max-early-inliner-iterations.?" "" { target *-*-* } 0 } */
+/* { dg-error "invalid '--param' name 'max-early-inliner-iteration'; did you mean 'max-early-inliner-iterations'?" "" { target *-*-* } 0 } */
const char a8[8] = "1234567\0";
const char a9[9] = "12345678\0";
-const char ax[9] = "12345678\0\0\0\0"; /* { dg-warning "initializer-string for array of chars is too long" } */
-const char ay[9] = "\00012345678\0\0\0\0"; /* { dg-warning "initializer-string for array of chars is too long" } */
+const char ax[9] = "12345678\0\0\0\0"; /* { dg-warning "initializer-string for array of 'char' is too long" } */
+const char ay[9] = "\00012345678\0\0\0\0"; /* { dg-warning "initializer-string for array of 'char' is too long" } */
int len1 (void)
__attribute__((always_inline))
static void asmfunc(void)
{
- __asm__ (""); /* { dg-error "asm not allowed in .transaction_safe" } */
+ __asm__ (""); /* { dg-error "'asm' not allowed in 'transaction_safe" } */
}
__attribute__((transaction_safe))
foo (int x)
{
asm goto ("" : : "i" (x) : : lab); /* { dg-error "impossible constraint" } */
- /* { dg-warning "probably doesn.t match constraints" "" { target *-*-* } .-1 } */
+ /* { dg-warning "probably does not match constraints" "" { target *-*-* } .-1 } */
return 1;
lab:
return 0;
bar (int x)
{
asm goto ("" : : "i" (x) : : lab); /* { dg-error "impossible constraint" } */
-/* { dg-warning "probably doesn.t match constraints" "" { target *-*-* } .-1 } */
+/* { dg-warning "probably does not match constraints" "" { target *-*-* } .-1 } */
__builtin_unreachable ();
lab:
return 0;
const char16_t s16_3[] = L"ab";
const char16_t s16_4[] = u8"ab"; /* { dg-error "from a string literal with type array of .char." } */
-const char16_t s16_5[0] = u"ab"; /* { dg-warning "chars is too long" } */
-const char16_t s16_6[1] = u"ab"; /* { dg-warning "chars is too long" } */
+const char16_t s16_5[0] = u"ab"; /* { dg-warning " is too long" } */
+const char16_t s16_6[1] = u"ab"; /* { dg-warning " is too long" } */
const char16_t s16_7[2] = u"ab";
const char16_t s16_8[3] = u"ab";
const char16_t s16_9[4] = u"ab";
const char32_t s32_3[] = L"ab"; /* { dg-error "from a string literal with type array of" } */
const char32_t s32_4[] = u8"ab"; /* { dg-error "from a string literal with type array of .char." } */
-const char32_t s32_5[0] = U"ab"; /* { dg-warning "chars is too long" } */
-const char32_t s32_6[1] = U"ab"; /* { dg-warning "chars is too long" } */
-const char32_t s32_7[2] = U"ab"; /* { dg-warning "chars is too long" "" { target "m32c-*-*" } } */
-const char32_t s32_8[3] = U"ab"; /* { dg-warning "chars is too long" "" { target "m32c-*-*" } } */
-const char32_t s32_9[4] = U"ab"; /* { dg-warning "chars is too long" "" { target "m32c-*-*" } } */
+const char32_t s32_5[0] = U"ab"; /* { dg-warning " is too long" } */
+const char32_t s32_6[1] = U"ab"; /* { dg-warning " is too long" } */
+const char32_t s32_7[2] = U"ab"; /* { dg-warning " is too long" "" { target "m32c-*-*" } } */
+const char32_t s32_8[3] = U"ab"; /* { dg-warning " is too long" "" { target "m32c-*-*" } } */
+const char32_t s32_9[4] = U"ab"; /* { dg-warning " is too long" "" { target "m32c-*-*" } } */
const wchar_t sw_0[] = "ab"; /* { dg-error "from a string literal with type array of .char." } */
const wchar_t sw_1[] = u"ab";
const char16_t s16_3[] = L"ab"; /* { dg-error "from a string literal with type array of .(long |short )?(unsigned )?int." "" { target { ! wchar_t_char16_t_compatible } } } */
const char16_t s16_4[] = u8"ab"; /* { dg-error "from a string literal with type array of .char." } */
-const char16_t s16_5[0] = u"ab"; /* { dg-warning "chars is too long" } */
-const char16_t s16_6[1] = u"ab"; /* { dg-warning "chars is too long" } */
+const char16_t s16_5[0] = u"ab"; /* { dg-warning " is too long" } */
+const char16_t s16_6[1] = u"ab"; /* { dg-warning " is too long" } */
const char16_t s16_7[2] = u"ab";
const char16_t s16_8[3] = u"ab";
const char16_t s16_9[4] = u"ab";
const char32_t s32_3[] = L"ab"; /* { dg-error "from a string literal with type array of .(long |short )?(unsigned )?int." "" { target { ! wchar_t_char32_t_compatible } } } */
const char32_t s32_4[] = u8"ab"; /* { dg-error "from a string literal with type array of .char." } */
-const char32_t s32_5[0] = U"ab"; /* { dg-warning "chars is too long" } */
-const char32_t s32_6[1] = U"ab"; /* { dg-warning "chars is too long" } */
-const char32_t s32_7[2] = U"ab"; /* { dg-warning "chars is too long" "" { target "m32c-*-*" } } */
-const char32_t s32_8[3] = U"ab"; /* { dg-warning "chars is too long" "" { target "m32c-*-*" } } */
-const char32_t s32_9[4] = U"ab"; /* { dg-warning "chars is too long" "" { target "m32c-*-*" } } */
+const char32_t s32_5[0] = U"ab"; /* { dg-warning " is too long" } */
+const char32_t s32_6[1] = U"ab"; /* { dg-warning " is too long" } */
+const char32_t s32_7[2] = U"ab"; /* { dg-warning " is too long" "" { target "m32c-*-*" } } */
+const char32_t s32_8[3] = U"ab"; /* { dg-warning " is too long" "" { target "m32c-*-*" } } */
+const char32_t s32_9[4] = U"ab"; /* { dg-warning " is too long" "" { target "m32c-*-*" } } */
const wchar_t sw_0[] = "ab"; /* { dg-error "from a string literal with type array of .char." } */
const wchar_t sw_1[] = u"ab"; /* { dg-error "from a string literal with type array of" "" { target { ! wchar_t_char16_t_compatible } } } */
const char32_t s2[] = u8"ab"; /* { dg-error "from a string literal with type array of .char." } */
const wchar_t s3[] = u8"ab"; /* { dg-error "from a string literal with type array of .char." } */
-const char t0[0] = u8"ab"; /* { dg-warning "chars is too long" } */
-const char t1[1] = u8"ab"; /* { dg-warning "chars is too long" } */
+const char t0[0] = u8"ab"; /* { dg-warning " is too long" } */
+const char t1[1] = u8"ab"; /* { dg-warning " is too long" } */
const char t2[2] = u8"ab";
const char t3[3] = u8"ab";
const char t4[4] = u8"ab";
-const char u0[0] = u8"\u2160."; /* { dg-warning "chars is too long" } */
-const char u1[1] = u8"\u2160."; /* { dg-warning "chars is too long" } */
-const char u2[2] = u8"\u2160."; /* { dg-warning "chars is too long" } */
-const char u3[3] = u8"\u2160."; /* { dg-warning "chars is too long" } */
+const char u0[0] = u8"\u2160."; /* { dg-warning " is too long" } */
+const char u1[1] = u8"\u2160."; /* { dg-warning " is too long" } */
+const char u2[2] = u8"\u2160."; /* { dg-warning " is too long" } */
+const char u3[3] = u8"\u2160."; /* { dg-warning " is too long" } */
const char u4[4] = u8"\u2160.";
const char u5[5] = u8"\u2160.";
const char u6[6] = u8"\u2160.";
const char a[5] = "12345"; /* { dg-message "declared here" } */
const char b[6] = "123456"; /* { dg-message "declared here" } */
const char a2[][3] = {
- "", "1", "12", "123", "123\000" /* { dg-warning "initializer-string for array of chars is too long" } */
+ "", "1", "12", "123", "123\000" /* { dg-warning "initializer-string for array of 'char' is too long" } */
};
void b(void)
{
char x;
- asm("" : "=@ccbad"(x)); /* { dg-error "unknown asm flag output" } */
+ asm("" : "=@ccbad"(x)); /* { dg-error "unknown 'asm' flag output" } */
}
/* { dg-options "-O0 -mno-popcnt" } */
inline int __attribute__ ((__gnu_inline__, __always_inline__, target("popcnt")))
-foo () /* { dg-error "inlining failed in call to always_inline .* target specific option mismatch" } */
+foo () /* { dg-error "inlining failed in call to 'always_inline' .* target specific option mismatch" } */
{
return 0;
}
error = error_code;
}
-extern int fn5 (void *) __attribute__ ((interrupt)); /* { dg-error "interrupt service routine can't have non-void return value" } */
+extern int fn5 (void *) __attribute__ ((interrupt)); /* { dg-error "interrupt service routine must return 'void'" } */
int
fn5 (void *frame)
void
foo (void)
{
- fn (&error); /* { dg-error "interrupt service routine can't be called directly" } */
+ fn (&error); /* { dg-error "interrupt service routine cannot be called directly" } */
}
void foo(double d)
{
- __asm__ ("" : "=u" (d)); /* { dg-error "output regs" } */
+ __asm__ ("" : "=u" (d)); /* { dg-error "output registers" } */
}
extern union un bar2 (int);
int
-foo1 (union un u) /* { dg-message "note: the ABI of passing union with long double has changed in GCC 4.4" } */
+foo1 (union un u) /* { dg-message "note: the ABI of passing union with 'long double' has changed in GCC 4.4" } */
{
bar1 (u);
return u.i;
struct X
foo (float *p)
-{ /* { dg-message "note: the ABI of passing structure with complex float member has changed in GCC 4.4" } */
+{ /* { dg-message "note: the ABI of passing structure with 'complex float' member has changed in GCC 4.4" } */
struct X x;
x.c = -3;
__real x.val = p[0];
/* callee cannot be inlined into caller because it has a higher target ISA. */
__attribute__((always_inline,target("sse4.2")))
-__inline int callee () /* { dg-error "inlining failed in call to always_inline" } */
+__inline int callee () /* { dg-error "inlining failed in call to 'always_inline'" } */
{
return 0;
}
test ()
{
double x = 1.0;
- asm ("fld %1" /* { dg-error "explicitly used regs must be grouped at top of stack" } */
+ asm ("fld %1" /* { dg-error "explicitly used registers must be grouped at top of stack" } */
: "=&t" (x)
: "u" (x));
return x;
register int r19 asm ("19");
asm volatile ("# %0" : "=r"(r19)); /* { dg-error "invalid use of register" } */
-} /* { dg-error "cannot be used in asm here" } */
+} /* { dg-error "cannot be used in 'asm' here" } */
bar (void) /* { dg-error "frame pointer required, but reserved" } */
{
B = &y;
-} /* { dg-error "bp cannot be used in asm here" } */
+} /* { dg-error "bp cannot be used in 'asm' here" } */
-- { dg-do compile }
--- { dg-error "not marked Inline_Always" "" { target *-*-* } 0 }
+-- { dg-error "not marked 'Inline_Always'" "" { target *-*-* } 0 }
-- { dg-error "cannot be inlined" "" { target *-*-* } 0 }
with Inline3_Pkg; use Inline3_Pkg;
-- { dg-do compile }
-- { dg-options "-O -gnatn -Winline" }
--- { dg-warning "not marked Inline" "" { target *-*-* } 0 }
+-- { dg-warning "not marked 'Inline'" "" { target *-*-* } 0 }
-- { dg-warning "cannot be inlined" "" { target *-*-* } 0 }
with Inline5_Pkg; use Inline5_Pkg;
-- { dg-do compile }
-- { dg-options "-O -gnatn -Winline" }
--- { dg-warning "not marked Inline" "" { target *-*-* } 0 }
+-- { dg-warning "not marked 'Inline'" "" { target *-*-* } 0 }
-- { dg-warning "cannot be inlined" "" { target *-*-* } 0 }
with Inline7_Pkg1; use Inline7_Pkg1;
-- { dg-do compile }
-- { dg-options "-O -gnatn -Winline" }
--- { dg-warning "not marked Inline" "" { target *-*-* } 0 }
+-- { dg-warning "not marked 'Inline'" "" { target *-*-* } 0 }
-- { dg-warning "cannot be inlined" "" { target *-*-* } 0 }
with Inline9_Pkg; use Inline9_Pkg;
return(0);
}
-/* { dg-warning "Messages without a matching method signature" "" { target *-*-* } 0 } */
-/* { dg-warning "will be assumed to return .id. and accept" "" { target *-*-* } 0 } */
-/* { dg-warning ".\.\.\.. as arguments" "" { target *-*-* } 0 } */
+/* { dg-warning "messages without a matching method signature will be assumed to return .id. and accept .\.\.\.. as arguments" "" { target *-*-* } 0 } */
int dummy = 0;
@try { @throw object; }
- @catch (int x) /* { dg-error "@catch parameter is not a known Objective-C class type" } */
+ @catch (int x) /* { dg-error "'@catch' parameter is not a known Objective-C class type" } */
{
dummy++;
}
@try { @throw object; }
- @catch (intTypedef x) /* { dg-error "@catch parameter is not a known Objective-C class type" } */
+ @catch (intTypedef x) /* { dg-error "'@catch' parameter is not a known Objective-C class type" } */
{
dummy++;
}
@try { @throw object; }
- @catch (int *x) /* { dg-error "@catch parameter is not a known Objective-C class type" } */
+ @catch (int *x) /* { dg-error "'@catch' parameter is not a known Objective-C class type" } */
{
dummy++;
}
}
@try { @throw object; }
- @catch (id <MyProtocol> x) /* { dg-error "@catch parameter cannot be protocol-qualified" } */
+ @catch (id <MyProtocol> x) /* { dg-error "'@catch' parameter cannot be protocol-qualified" } */
{
dummy++;
}
}
@try { @throw object; }
- @catch (MyObject <MyProtocol> *x) /* { dg-error "@catch parameter cannot be protocol-qualified" } */
+ @catch (MyObject <MyProtocol> *x) /* { dg-error "'@catch' parameter cannot be protocol-qualified" } */
{
dummy++;
}
@try { @throw object; }
- @catch (MyObject x) /* { dg-error "@catch parameter is not a known Objective-C class type" } */
+ @catch (MyObject x) /* { dg-error "'@catch' parameter is not a known Objective-C class type" } */
{ /* { dg-error "no matching function" "" { target *-*-* } .-1 } */
dummy++; /* { dg-message "MyObject" "" { target *-*-* } interface_MyObject } */
} /* { dg-message "candidate" "" { target *-*-* } interface_MyObject } */
}
@try { @throw object; }
- @catch (MyObjectTypedef <MyProtocol> *x) /* { dg-error "@catch parameter cannot be protocol-qualified" } */
+ @catch (MyObjectTypedef <MyProtocol> *x) /* { dg-error "'@catch' parameter cannot be protocol-qualified" } */
{
dummy++;
}
}
@try { @throw object; }
- @catch (Class x) /* { dg-error "@catch parameter is not a known Objective-C class type" } */
+ @catch (Class x) /* { dg-error "'@catch' parameter is not a known Objective-C class type" } */
{
dummy++;
}
@try { @throw object; }
@catch
{ /* { dg-error "expected" } */
- dummy++; /* { dg-error "@catch parameter is not a known Objective-C class type" "" { target *-*-* } .-1 } */
+ dummy++; /* { dg-error "'@catch' parameter is not a known Objective-C class type" "" { target *-*-* } .-1 } */
}
@catch () /* { dg-error "expected identifier before" } */
- { /* { dg-error "@catch parameter is not a known Objective-C class type" "" { target *-*-* } .-1 } */
+ { /* { dg-error "'@catch' parameter is not a known Objective-C class type" "" { target *-*-* } .-1 } */
dummy++;
}
@catch (i) /* { dg-error ".i. has not been declared" } */
- { /* { dg-error "@catch parameter is not a known Objective-C class type" "" { target *-*-* } .-1 } */
+ { /* { dg-error "'@catch' parameter is not a known Objective-C class type" "" { target *-*-* } .-1 } */
dummy++;
}
@catch (id <MyProtocol x) /* { dg-error "expected ... before .x." } */
- { /* { dg-error "@catch parameter cannot be protocol-qualified" "" { target *-*-* } .-1 } */
+ { /* { dg-error "'@catch' parameter cannot be protocol-qualified" "" { target *-*-* } .-1 } */
dummy++;
}
@catch MyObject *x /* { dg-error "expected ... before .MyObject." } */
int dummy = 0;
@try { @throw object; }
- @catch (int) /* { dg-error "@catch parameter is not a known Objective-C class type" } */
+ @catch (int) /* { dg-error "'@catch' parameter is not a known Objective-C class type" } */
{
dummy++;
}
@try { @throw object; }
- @catch (intTypedef) /* { dg-error "@catch parameter is not a known Objective-C class type" } */
+ @catch (intTypedef) /* { dg-error "'@catch' parameter is not a known Objective-C class type" } */
{
dummy++;
}
@try { @throw object; }
- @catch (int *) /* { dg-error "@catch parameter is not a known Objective-C class type" } */
+ @catch (int *) /* { dg-error "'@catch' parameter is not a known Objective-C class type" } */
{
dummy++;
}
}
@try { @throw object; }
- @catch (id <MyProtocol>) /* { dg-error "@catch parameter cannot be protocol-qualified" } */
+ @catch (id <MyProtocol>) /* { dg-error "'@catch' parameter cannot be protocol-qualified" } */
{
dummy++;
}
}
@try { @throw object; }
- @catch (MyObject <MyProtocol> *) /* { dg-error "@catch parameter cannot be protocol-qualified" } */
+ @catch (MyObject <MyProtocol> *) /* { dg-error "'@catch' parameter cannot be protocol-qualified" } */
{
dummy++;
}
@try { @throw object; }
- @catch (MyObject) /* { dg-error "@catch parameter is not a known Objective-C class type" } */
+ @catch (MyObject) /* { dg-error "'@catch' parameter is not a known Objective-C class type" } */
{ /* { dg-error "no matching function" "" { target *-*-* } .-1 } */
dummy++; /* { dg-message "MyObject" "" { target *-*-* } interface_MyObject } */
} /* { dg-message "candidate" "" { target *-*-* } interface_MyObject } */
}
@try { @throw object; }
- @catch (MyObjectTypedef <MyProtocol> *) /* { dg-error "@catch parameter cannot be protocol-qualified" } */
+ @catch (MyObjectTypedef <MyProtocol> *) /* { dg-error "'@catch' parameter cannot be protocol-qualified" } */
{
dummy++;
}
}
@try { @throw object; }
- @catch (Class) /* { dg-error "@catch parameter is not a known Objective-C class type" } */
+ @catch (Class) /* { dg-error "'@catch' parameter is not a known Objective-C class type" } */
{
dummy++;
}
void test (id object)
{
@throw object; /* Ok */
- @throw; /* { dg-error ".@throw. .rethrow. used outside of a @catch block" } */
+ @throw; /* { dg-error ".@throw. .rethrow. used outside of a '@catch' block" } */
@throw (object); /* Ok. */
@throw (id)0 /* { dg-error "expected" } */
}
/* { dg-message "also found .\\+\\(Protocol \\*\\)port." "" { target *-*-* } Derived_port_last } */
[receiver starboard]; /* { dg-warning "no .\\+starboard. method found" } */
- /* { dg-warning "Messages without a matching method signature" "" { target *-*-* } .-1 } */
- /* { dg-warning "will be assumed to return .id. and accept" "" { target *-*-* } .-2 } */
- /* { dg-warning ".\.\.\.. as arguments" "" { target *-*-* } .-3 } */
+ /* { dg-warning "messages without a matching method signature will be assumed to return .id. and accept .\.\.\.. as arguments" "" { target *-*-* } 0 } */
[Class port]; /* { dg-error ".Class. is not an Objective\\-C class name or alias" } */
}
TestsuiteObject *obj = [[TestsuiteObject alloc] init];
id obj2 = obj;
[obj setWindow:nil]; /* { dg-warning ".TestsuiteObject. may not respond to .\\-setWindow:." } */
- /* { dg-warning "Messages without a matching method signature" "" { target *-*-* } .-1 } */
- /* { dg-warning "will be assumed to return .id. and accept" "" { target *-*-* } .-2 } */
- /* { dg-warning ".\.\.\.. as arguments" "" { target *-*-* } .-3 } */
- [obj2 setWindow:nil]; /* { dg-warning "multiple methods named .\\-setWindow:. found" } */
+ /* { dg-warning "messages without a matching method signature will be assumed to return .id. and accept .\.\.\.. as arguments" "" { target *-*-* } 0 } */
+
+[obj2 setWindow:nil]; /* { dg-warning "multiple methods named .\\-setWindow:. found" } */
/* { dg-message "using .\\-\\(void\\)setWindow:\\(TestsuiteObject \\*\\)wdw." "" { target *-*-* } Class1_setWindow } */
/* { dg-message "also found .\\-\\(void\\)setWindow:\\(Class1 \\*\\)window." "" { target *-*-* } Class2_setWindow } */
@class NotKnown;
void foo(NotKnown *n) {
- [NotKnown new]; /* { dg-warning ".interface of class .NotKnown. not found" } */
- [n nonexistent_method]; /* { dg-warning ".interface of class .NotKnown. not found" } */
+ [NotKnown new]; /* { dg-warning "'.interface' of class .NotKnown. not found" } */
+ [n nonexistent_method]; /* { dg-warning "'.interface' of class .NotKnown. not found" } */
/* { dg-warning "no .\\-nonexistent_method. method found" "" { target *-*-* } .-1 } */
}
-/* { dg-warning "Messages without a matching method signature" "" { target *-*-* } 0 } */
-/* { dg-warning "will be assumed to return .id. and accept" "" { target *-*-* } 0 } */
-/* { dg-warning ".\.\.\.. as arguments" "" { target *-*-* } 0 } */
+/* { dg-warning "messages without a matching method signature will be assumed to return .id. and accept .\.\.\.. as arguments" "" { target *-*-* } 0 } */
[n nonexistent_method]; /* { dg-warning "invalid receiver type" } */
/* { dg-warning "no .\\-nonexistent_method. method found" "" { target *-*-* } .-1 } */
[NotAClass nonexistent_method]; /* { dg-error ".NotAClass. is not an Objective\\-C class name or alias" } */
- [u nonexistent_method]; /* { dg-warning ".interface of class .UnderSpecified. not found" } */
+ [u nonexistent_method]; /* { dg-warning "'.interface' of class .UnderSpecified. not found" } */
/* { dg-warning "no .\\-nonexistent_method. method found" "" { target *-*-* } .-1 } */
- [UnderSpecified nonexistent_method]; /* { dg-warning ".interface of class .UnderSpecified. not found" } */
+ [UnderSpecified nonexistent_method]; /* { dg-warning "'.interface' of class .UnderSpecified. not found" } */
/* { dg-warning "no .\\+nonexistent_method. method found" "" { target *-*-* } .-1 } */
}
-/* { dg-warning "Messages without a matching method signature" "" { target *-*-* } 0 } */
-/* { dg-warning "will be assumed to return .id. and accept" "" { target *-*-* } 0 } */
-/* { dg-warning ".\.\.\.. as arguments" "" { target *-*-* } 0 } */
+/* { dg-warning "messages without a matching method signature will be assumed to return .id. and accept .\.\.\.. as arguments" "" { target *-*-* } 0 } */
}
@end
-/* { dg-warning "Messages without a matching method signature" "" { target *-*-* } 0 } */
-/* { dg-warning "will be assumed to return .id. and accept" "" { target *-*-* } 0 } */
-/* { dg-warning ".\.\.\.. as arguments" "" { target *-*-* } 0 } */
-
+/* { dg-warning "messages without a matching method signature will be assumed to return .id. and accept .\.\.\.. as arguments" "" { target *-*-* } 0 } */
/* If a class is specified by name, the @interface must be available
to check what it responds to. */
- [NotKnown classMethod]; /* { dg-warning ".interface of class .NotKnown. not found" } */
+ [NotKnown classMethod]; /* { dg-warning "'.interface' of class .NotKnown. not found" } */
/* "id w" means that "w" responds to anything, both class and
because they expect the compiler to do type-checking; the
@interface must be available to do this check, otherwise the
compiler does not know what "a" responds to. */
- [a instanceMethod]; /* { dg-warning ".interface of class .NotKnown. not found" } */
+ [a instanceMethod]; /* { dg-warning "'.interface' of class .NotKnown. not found" } */
/* But, if you cast it to "id", then you're disabling type-checking
and the warnings should go away. */
return receiver;
}
-/* { dg-warning "Messages without a matching method signature" "" { target *-*-* } 0 } */
-/* { dg-warning "will be assumed to return .id. and accept" "" { target *-*-* } 0 } */
-/* { dg-warning ".\.\.\.. as arguments" "" { target *-*-* } 0 } */
+/* { dg-warning "messages without a matching method signature will be assumed to return .id. and accept .\.\.\.. as arguments" "" { target *-*-* } 0 } */
{
[object1 method]; /* Ok */
[object2 method]; /* { dg-warning ".MyClass. may not respond to ..method." } */
- /* { dg-warning "without a matching method" "" { target *-*-* } .-1 } */
- /* { dg-warning "will be assumed to return" "" { target *-*-* } .-2 } */
- /* { dg-warning "as arguments" "" { target *-*-* } .-3 } */
+
+ /* { dg-warning "messages without a matching method signature will be assumed to return .id. and accept '\.\.\.' as arguments" "" { target *-*-* } 0 } */
}
}
@end
-/* { dg-warning "Messages without a matching method signature" "" { target *-*-* } 0 } */
-/* { dg-warning "will be assumed to return .id. and accept" "" { target *-*-* } 0 } */
-/* { dg-warning ".\.\.\.. as arguments" "" { target *-*-* } 0 } */
+/* { dg-warning "messages without a matching method signature will be assumed to return .id. and accept .\.\.\.. as arguments" "" { target *-*-* } 0 } */
return(0);
}
-/* { dg-warning "Messages without a matching method signature" "" { target *-*-* } 0 } */
-/* { dg-warning "will be assumed to return .id. and accept" "" { target *-*-* } 0 } */
-/* { dg-warning ".\.\.\.. as arguments" "" { target *-*-* } 0 } */
+/* { dg-warning "messages without a matching method signature will be assumed to return .id. and accept .\.\.\.. as arguments" "" { target *-*-* } 0 } */
return 0;
}
-/* { dg-warning "Messages without a matching method signature" "" { target *-*-* } 0 } */
-/* { dg-warning "will be assumed to return .id. and accept" "" { target *-*-* } 0 } */
-/* { dg-warning ".\.\.\.. as arguments" "" { target *-*-* } 0 } */
-
-
+/* { dg-warning "messages without a matching method signature will be assumed to return .id. and accept .\.\.\.. as arguments" "" { target *-*-* } 0 } */
int dummy = 0;
@try { @throw object; }
- @catch (int x) /* { dg-error "@catch parameter is not a known Objective-C class type" } */
+ @catch (int x) /* { dg-error "'@catch' parameter is not a known Objective-C class type" } */
{
dummy++;
}
@try { @throw object; }
- @catch (intTypedef x) /* { dg-error "@catch parameter is not a known Objective-C class type" } */
+ @catch (intTypedef x) /* { dg-error "'@catch' parameter is not a known Objective-C class type" } */
{
dummy++;
}
@try { @throw object; }
- @catch (int *x) /* { dg-error "@catch parameter is not a known Objective-C class type" } */
+ @catch (int *x) /* { dg-error "'@catch' parameter is not a known Objective-C class type" } */
{
dummy++;
}
}
@try { @throw object; }
- @catch (id <MyProtocol> x) /* { dg-error "@catch parameter cannot be protocol-qualified" } */
+ @catch (id <MyProtocol> x) /* { dg-error "'@catch' parameter cannot be protocol-qualified" } */
{
dummy++;
}
}
@try { @throw object; }
- @catch (MyObject <MyProtocol> *x) /* { dg-error "@catch parameter cannot be protocol-qualified" } */
+ @catch (MyObject <MyProtocol> *x) /* { dg-error "'@catch' parameter cannot be protocol-qualified" } */
{
dummy++;
}
@try { @throw object; }
- @catch (MyObject x) /* { dg-error "@catch parameter is not a known Objective-C class type" } */
+ @catch (MyObject x) /* { dg-error "'@catch' parameter is not a known Objective-C class type" } */
{ /* { dg-error "conversion to non-scalar type requested" "" { target *-*-* } .-1 } */
dummy++;
}
}
@try { @throw object; }
- @catch (MyObjectTypedef <MyProtocol> *x) /* { dg-error "@catch parameter cannot be protocol-qualified" } */
+ @catch (MyObjectTypedef <MyProtocol> *x) /* { dg-error "'@catch' parameter cannot be protocol-qualified" } */
{
dummy++;
}
}
@try { @throw object; }
- @catch (Class x) /* { dg-error "@catch parameter is not a known Objective-C class type" } */
+ @catch (Class x) /* { dg-error "'@catch' parameter is not a known Objective-C class type" } */
{
dummy++;
}
dummy++;
}
@catch (id <MyProtocol x) /* { dg-error "expected ... before .x." } */
- { /* { dg-error "@catch parameter cannot be protocol-qualified" "" { target *-*-* } .-1 } */
+ { /* { dg-error "'@catch' parameter cannot be protocol-qualified" "" { target *-*-* } .-1 } */
dummy++;
}
@catch MyObject *x /* { dg-error "expected ... before .MyObject." } */
int dummy = 0;
@try { @throw object; }
- @catch (int) /* { dg-error "@catch parameter is not a known Objective-C class type" } */
+ @catch (int) /* { dg-error "'@catch' parameter is not a known Objective-C class type" } */
{
dummy++;
}
@try { @throw object; }
- @catch (intTypedef) /* { dg-error "@catch parameter is not a known Objective-C class type" } */
+ @catch (intTypedef) /* { dg-error "'@catch' parameter is not a known Objective-C class type" } */
{
dummy++;
}
@try { @throw object; }
- @catch (int *) /* { dg-error "@catch parameter is not a known Objective-C class type" } */
+ @catch (int *) /* { dg-error "'@catch' parameter is not a known Objective-C class type" } */
{
dummy++;
}
}
@try { @throw object; }
- @catch (id <MyProtocol>) /* { dg-error "@catch parameter cannot be protocol-qualified" } */
+ @catch (id <MyProtocol>) /* { dg-error "'@catch' parameter cannot be protocol-qualified" } */
{
dummy++;
}
}
@try { @throw object; }
- @catch (MyObject <MyProtocol> *) /* { dg-error "@catch parameter cannot be protocol-qualified" } */
+ @catch (MyObject <MyProtocol> *) /* { dg-error "'@catch' parameter cannot be protocol-qualified" } */
{
dummy++;
}
@try { @throw object; }
- @catch (MyObject) /* { dg-error "@catch parameter is not a known Objective-C class type" } */
+ @catch (MyObject) /* { dg-error "'@catch' parameter is not a known Objective-C class type" } */
{ /* { dg-error "conversion to non-scalar type requested" "" { target *-*-* } .-1 } */
dummy++;
}
}
@try { @throw object; }
- @catch (MyObjectTypedef <MyProtocol> *) /* { dg-error "@catch parameter cannot be protocol-qualified" } */
+ @catch (MyObjectTypedef <MyProtocol> *) /* { dg-error "'@catch' parameter cannot be protocol-qualified" } */
{
dummy++;
}
}
@try { @throw object; }
- @catch (Class) /* { dg-error "@catch parameter is not a known Objective-C class type" } */
+ @catch (Class) /* { dg-error "'@catch' parameter is not a known Objective-C class type" } */
{
dummy++;
}
void test (id object)
{
@throw object; /* Ok */
- @throw; /* { dg-error ".@throw. .rethrow. used outside of a @catch block" } */
+ @throw; /* { dg-error ".@throw. .rethrow. used outside of a '@catch' block" } */
@throw (object); /* Ok. */
@throw (id)0 /* { dg-error "expected" } */
}
@class NotKnown;
void foo(NotKnown *n) {
- [NotKnown new]; /* { dg-warning ".interface of class .NotKnown. not found" } */
- [n nonexistent_method]; /* { dg-warning ".interface of class .NotKnown. not found" } */
+ [NotKnown new]; /* { dg-warning "'.interface' of class .NotKnown. not found" } */
+ [n nonexistent_method]; /* { dg-warning "'.interface' of class .NotKnown. not found" } */
/* { dg-warning "no .\\-nonexistent_method. method found" "" { target *-*-* } .-1 } */
}
-/* { dg-warning "Messages without a matching method signature" "" { target *-*-* } 0 } */
-/* { dg-warning "will be assumed to return .id. and accept" "" { target *-*-* } 0 } */
-/* { dg-warning ".\.\.\.. as arguments" "" { target *-*-* } 0 } */
+/* { dg-warning "messages without a matching method signature will be assumed to return .id. and accept '\.\.\.' as arguments" "" { target *-*-* } 0 } */
[MyIntermediate rootInstanceMethod]; /* with the same name. */
[self instanceMethod]; /* { dg-warning ".MyDerived. may not respond to .\\+instanceMethod." } */
- /* { dg-warning "Messages without a matching method signature" "" { target *-*-* } .-1 } */
- /* { dg-warning "will be assumed to return .id. and accept" "" { target *-*-* } .-2 } */
- /* { dg-warning ".\.\.\.. as arguments" "" { target *-*-* } .-3 } */
+ /* { dg-warning "messages without a matching method signature will be assumed to return .id. and accept .\.\.\.. as arguments" "" { target *-*-* } 0 } */
[MyDerived instanceMethod]; /* { dg-warning ".MyDerived. may not respond to .\\+instanceMethod." } */
}
@end
[n nonexistent_method]; /* { dg-warning "invalid receiver type" } */
/* { dg-warning "no .\\-nonexistent_method. method found" "" { target *-*-* } .-1 } */
[NotAClass nonexistent_method]; /* { dg-error ".NotAClass. is not an Objective\\-C class name or alias" } */
- [u nonexistent_method]; /* { dg-warning ".interface of class .UnderSpecified. not found" } */
+ [u nonexistent_method]; /* { dg-warning "'.interface' of class .UnderSpecified. not found" } */
/* { dg-warning "no .\\-nonexistent_method. method found" "" { target *-*-* } .-1 } */
- [UnderSpecified nonexistent_method]; /* { dg-warning ".interface of class .UnderSpecified. not found" } */
+ [UnderSpecified nonexistent_method]; /* { dg-warning "'.interface' of class .UnderSpecified. not found" } */
/* { dg-warning "no .\\+nonexistent_method. method found" "" { target *-*-* } .-1 } */
}
-/* { dg-warning "Messages without a matching method signature" "" { target *-*-* } 0 } */
-/* { dg-warning "will be assumed to return .id. and accept" "" { target *-*-* } 0 } */
-/* { dg-warning ".\.\.\.. as arguments" "" { target *-*-* } 0 } */
+/* { dg-warning "messages without a matching method signature will be assumed to return .id. and accept .\.\.\.. as arguments" "" { target *-*-* } 0 } */
/* { dg-message "also found .\\+\\(Protocol \\*\\)port." "" { target *-*-* } Derived_port_last } */
[receiver starboard]; /* { dg-warning "no .\\+starboard. method found" } */
- /* { dg-warning "Messages without a matching method signature" "" { target *-*-* } .-1 } */
- /* { dg-warning "will be assumed to return .id. and accept" "" { target *-*-* } .-2 } */
- /* { dg-warning ".\.\.\.. as arguments" "" { target *-*-* } .-3 } */
+ /* { dg-warning "messages without a matching method signature will be assumed to return .id. and accept .\.\.\.. as arguments" "" { target *-*-* } 0 } */
[Class port]; /* { dg-error ".Class. is not an Objective\\-C class name or alias" } */
}
TestsuiteObject *obj = [[TestsuiteObject alloc] init];
id obj2 = obj;
[obj setWindow:nil]; /* { dg-warning ".TestsuiteObject. may not respond to .\\-setWindow:." } */
- /* { dg-warning "Messages without a matching method signature" "" { target *-*-* } .-1 } */
- /* { dg-warning "will be assumed to return .id. and accept" "" { target *-*-* } .-2 } */
- /* { dg-warning ".\.\.\.. as arguments" "" { target *-*-* } .-3 } */
+ /* { dg-warning "messages without a matching method signature will be assumed to return .id. and accept .\.\.\.. as arguments" "" { target *-*-* } 0 } */
[obj2 setWindow:nil]; /* { dg-warning "multiple methods named .\\-setWindow:. found" } */
/* { dg-message "using .\\-\\(void\\)setWindow:\\(TestsuiteObject \\*\\)wdw." "" { target *-*-* } Class1_setWindow } */
/* { dg-message "also found .\\-\\(void\\)setWindow:\\(Class1 \\*\\)window." "" { target *-*-* } Class2_setWindow } */
/* If a class is specified by name, the @interface must be available
to check what it responds to. */
- [NotKnown classMethod]; /* { dg-warning ".interface of class .NotKnown. not found" } */
+ [NotKnown classMethod]; /* { dg-warning "'.interface' of class .NotKnown. not found" } */
/* "id w" means that "w" responds to anything, both class and
because they expect the compiler to do type-checking; the
@interface must be available to do this check, otherwise the
compiler does not know what "a" responds to. */
- [a instanceMethod]; /* { dg-warning ".interface of class .NotKnown. not found" } */
+ [a instanceMethod]; /* { dg-warning "'.interface' of class .NotKnown. not found" } */
/* But, if you cast it to "id", then you're disabling type-checking
and the warnings should go away. */
return 0;
}
-/* { dg-warning "Messages without a matching method signature" "" { target *-*-* } 0 } */
-/* { dg-warning "will be assumed to return .id. and accept" "" { target *-*-* } 0 } */
-/* { dg-warning ".\.\.\.. as arguments" "" { target *-*-* } 0 } */
+/* { dg-warning "messages without a matching method signature will be assumed to return .id. and accept .\.\.\.. as arguments" "" { target *-*-* } 0 } */
return receiver;
}
-/* { dg-warning "Messages without a matching method signature" "" { target *-*-* } 0 } */
-/* { dg-warning "will be assumed to return .id. and accept" "" { target *-*-* } 0 } */
-/* { dg-warning ".\.\.\.. as arguments" "" { target *-*-* } 0 } */
+/* { dg-warning "messages without a matching method signature will be assumed to return .id. and accept .\.\.\.. as arguments" "" { target *-*-* } 0 } */
{
[object1 method]; /* Ok */
[object2 method]; /* { dg-warning ".MyClass. may not respond to ..method." } */
- /* { dg-warning "without a matching method" "" { target *-*-* } .-1 } */
- /* { dg-warning "will be assumed to return" "" { target *-*-* } .-2 } */
- /* { dg-warning "as arguments" "" { target *-*-* } .-3 } */
}
+/* { dg-warning "messages without a matching method signature will be assumed to return .id. and accept .\.\.\.' as arguments" "" { target *-*-* } 0 } */
the new file name already exists. Therefore, we explicitly
remove the old file first. */
if (remove (f->key) == -1)
- fatal_error (input_location, "removing .rpo file: %m");
+ fatal_error (input_location,
+ "removing repository file %qs: %m", f->key);
if (rename (outname, f->key) == -1)
- fatal_error (input_location, "renaming .rpo file: %m");
+ fatal_error (input_location, "renaming repository file from "
+ "%qs to %qs: %m", outname, f->key);
if (!f->args)
{
asm_file_name);
if (asm_out_file == 0)
fatal_error (UNKNOWN_LOCATION,
- "can%'t open %qs for writing: %m", asm_file_name);
+ "cannot open %qs for writing: %m", asm_file_name);
}
if (!flag_syntax_only)
filename = concat (aux_base_name, ".", ext, NULL);
file = fopen (filename, "w");
if (!file)
- fatal_error (input_location, "can%'t open %s for writing: %m", filename);
+ fatal_error (input_location, "cannot open %s for writing: %m", filename);
free (filename);
return file;
}
aux_info_file = fopen (aux_info_file_name, "w");
if (aux_info_file == 0)
fatal_error (UNKNOWN_LOCATION,
- "can%'t open %s: %m", aux_info_file_name);
+ "cannot open %s: %m", aux_info_file_name);
}
if (!targetm_common.have_named_sections)
{
warning_at (UNKNOWN_LOCATION, 0,
"%<-fstack-check=%> and %<-fstack-clash_protection%> are "
- "mutually exclusive. Disabling %<-fstack-check=%>");
+ "mutually exclusive; disabling %<-fstack-check=%>");
flag_stack_check = NO_STACK_CHECK;
}
on the squared numbers. */
if (mpfr_set_emin (2 * (min_exp - 1))
|| mpfr_set_emax (2 * (max_exp + 1)))
- sorry ("mpfr not configured to handle all float modes");
+ sorry ("mpfr not configured to handle all floating modes");
/* Set up the back-end if requested. */
if (!no_backend)
Either that or get the language spec to resurrect __tm_waiver. */
if (d->block_flags & DIAG_TM_SAFE)
error_at (gimple_location (stmt),
- "asm not allowed in atomic transaction");
+ "%<asm%> not allowed in atomic transaction");
else if (d->func_flags & DIAG_TM_SAFE)
error_at (gimple_location (stmt),
- "asm not allowed in %<transaction_safe%> function");
+ "%<asm%> not allowed in %<transaction_safe%> function");
break;
case GIMPLE_TRANSACTION:
{
tree t = build1 (NOP_EXPR, void_type_node, size_zero_node);
SET_EXPR_LOCATION (t, gimple_location (stmt));
- error ("%Kasm not allowed in %<transaction_safe%> function", t);
+ error ("%K%<asm%> not allowed in %<transaction_safe%> function",
+ t);
}
return true;
if (gimple_code (stmt) == GIMPLE_ASM)
{
error_at (gimple_location (stmt),
- "asm not allowed in atomic transaction");
+ "%<asm%> not allowed in atomic transaction");
continue;
}
if (old_constant != new_constant)
{
- error ("constant not recomputed when ADDR_EXPR changed");
+ error ("constant not recomputed when %<ADDR_EXPR%> changed");
return true;
}
if (old_side_effects != new_side_effects)
{
- error ("side effects not recomputed when ADDR_EXPR changed");
+ error ("side effects not recomputed when %<ADDR_EXPR%> changed");
return true;
}
if (DECL_GIMPLE_REG_P (base))
{
- error ("DECL_GIMPLE_REG_P set on a variable with address taken");
+ error ("%<DECL_GIMPLE_REG_P%> set on a variable with address taken");
return true;
}
if (verify_addressable && !TREE_ADDRESSABLE (base))
{
- error ("address taken, but ADDRESSABLE bit not set");
+ error ("address taken but %<TREE_ADDRESSABLE%> bit not set");
return true;
}
static bool
verify_types_in_gimple_reference (tree expr, bool require_lvalue)
{
+ const char *code_name = get_tree_code_name (TREE_CODE (expr));
+
if (TREE_CODE (expr) == REALPART_EXPR
|| TREE_CODE (expr) == IMAGPART_EXPR
|| TREE_CODE (expr) == BIT_FIELD_REF)
tree op = TREE_OPERAND (expr, 0);
if (!is_gimple_reg_type (TREE_TYPE (expr)))
{
- error ("non-scalar BIT_FIELD_REF, IMAGPART_EXPR or REALPART_EXPR");
+ error ("non-scalar %qs", code_name);
return true;
}
|| !types_compatible_p (bitsizetype, TREE_TYPE (t1))
|| !types_compatible_p (bitsizetype, TREE_TYPE (t2)))
{
- error ("invalid position or size operand to BIT_FIELD_REF");
+ error ("invalid position or size operand to %qs", code_name);
return true;
}
if (INTEGRAL_TYPE_P (TREE_TYPE (expr))
&& maybe_ne (TYPE_PRECISION (TREE_TYPE (expr)), size))
{
error ("integral result type precision does not match "
- "field size of BIT_FIELD_REF");
+ "field size of %qs", code_name);
return true;
}
else if (!INTEGRAL_TYPE_P (TREE_TYPE (expr))
size))
{
error ("mode size of non-integral result does not "
- "match field size of BIT_FIELD_REF");
+ "match field size of %qs",
+ code_name);
return true;
}
if (INTEGRAL_TYPE_P (TREE_TYPE (op))
&& !type_has_mode_precision_p (TREE_TYPE (op)))
{
- error ("BIT_FIELD_REF of non-mode-precision operand");
+ error ("%qs of non-mode-precision operand", code_name);
return true;
}
if (!AGGREGATE_TYPE_P (TREE_TYPE (op))
tree_to_poly_uint64 (TYPE_SIZE (TREE_TYPE (op)))))
{
error ("position plus size exceeds size of referenced object in "
- "BIT_FIELD_REF");
+ "%qs", code_name);
return true;
}
}
&& !useless_type_conversion_p (TREE_TYPE (expr),
TREE_TYPE (TREE_TYPE (op))))
{
- error ("type mismatch in real/imagpart reference");
+ error ("type mismatch in %qs reference", code_name);
debug_generic_stmt (TREE_TYPE (expr));
debug_generic_stmt (TREE_TYPE (TREE_TYPE (op)));
return true;
while (handled_component_p (expr))
{
+ code_name = get_tree_code_name (TREE_CODE (expr));
+
if (TREE_CODE (expr) == REALPART_EXPR
|| TREE_CODE (expr) == IMAGPART_EXPR
|| TREE_CODE (expr) == BIT_FIELD_REF)
{
- error ("non-top-level BIT_FIELD_REF, IMAGPART_EXPR or REALPART_EXPR");
+ error ("non-top-level %qs", code_name);
return true;
}
|| (TREE_OPERAND (expr, 3)
&& !is_gimple_val (TREE_OPERAND (expr, 3))))
{
- error ("invalid operands to array reference");
+ error ("invalid operands to %qs", code_name);
debug_generic_stmt (expr);
return true;
}
&& !useless_type_conversion_p (TREE_TYPE (expr),
TREE_TYPE (TREE_TYPE (op))))
{
- error ("type mismatch in array reference");
+ error ("type mismatch in %qs", code_name);
debug_generic_stmt (TREE_TYPE (expr));
debug_generic_stmt (TREE_TYPE (TREE_TYPE (op)));
return true;
&& !useless_type_conversion_p (TREE_TYPE (TREE_TYPE (expr)),
TREE_TYPE (TREE_TYPE (op))))
{
- error ("type mismatch in array range reference");
+ error ("type mismatch in %qs", code_name);
debug_generic_stmt (TREE_TYPE (TREE_TYPE (expr)));
debug_generic_stmt (TREE_TYPE (TREE_TYPE (op)));
return true;
if (TREE_OPERAND (expr, 2)
&& !is_gimple_val (TREE_OPERAND (expr, 2)))
{
- error ("invalid COMPONENT_REF offset operator");
+ error ("invalid %qs offset operator", code_name);
return true;
}
if (!useless_type_conversion_p (TREE_TYPE (expr),
TREE_TYPE (TREE_OPERAND (expr, 1))))
{
- error ("type mismatch in component reference");
+ error ("type mismatch in %qs", code_name);
debug_generic_stmt (TREE_TYPE (expr));
debug_generic_stmt (TREE_TYPE (TREE_OPERAND (expr, 1)));
return true;
&& (TREE_CODE (op) == SSA_NAME
|| is_gimple_min_invariant (op)))
{
- error ("conversion of an SSA_NAME on the left hand side");
+ error ("conversion of %qs on the left hand side of %qs",
+ get_tree_code_name (TREE_CODE (op)), code_name);
debug_generic_stmt (expr);
return true;
}
else if (TREE_CODE (op) == SSA_NAME
&& TYPE_SIZE (TREE_TYPE (expr)) != TYPE_SIZE (TREE_TYPE (op)))
{
- error ("conversion of register to a different size");
+ error ("conversion of register to a different size in %qs",
+ code_name);
debug_generic_stmt (expr);
return true;
}
expr = op;
}
+ code_name = get_tree_code_name (TREE_CODE (expr));
+
if (TREE_CODE (expr) == MEM_REF)
{
if (!is_gimple_mem_ref_addr (TREE_OPERAND (expr, 0))
|| (TREE_CODE (TREE_OPERAND (expr, 0)) == ADDR_EXPR
&& verify_address (TREE_OPERAND (expr, 0), false)))
{
- error ("invalid address operand in MEM_REF");
+ error ("invalid address operand in %qs", code_name);
debug_generic_stmt (expr);
return true;
}
if (!poly_int_tree_p (TREE_OPERAND (expr, 1))
|| !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 1))))
{
- error ("invalid offset operand in MEM_REF");
+ error ("invalid offset operand in %qs", code_name);
debug_generic_stmt (expr);
return true;
}
|| (TREE_CODE (TMR_BASE (expr)) == ADDR_EXPR
&& verify_address (TMR_BASE (expr), false)))
{
- error ("invalid address operand in TARGET_MEM_REF");
+ error ("invalid address operand in %qs", code_name);
return true;
}
if (!TMR_OFFSET (expr)
|| !poly_int_tree_p (TMR_OFFSET (expr))
|| !POINTER_TYPE_P (TREE_TYPE (TMR_OFFSET (expr))))
{
- error ("invalid offset operand in TARGET_MEM_REF");
+ error ("invalid offset operand in %qs", code_name);
debug_generic_stmt (expr);
return true;
}
}
else if (TREE_CODE (expr) == INDIRECT_REF)
{
- error ("INDIRECT_REF in gimple IL");
+ error ("%qs in gimple IL", code_name);
debug_generic_stmt (expr);
return true;
}
&& gimple_call_noreturn_p (stmt)
&& should_remove_lhs_p (lhs))
{
- error ("LHS in noreturn call");
+ error ("LHS in %<noreturn%> call");
return true;
}
return true;
}
+ const char* const code_name = get_tree_code_name (rhs_code);
+
/* First handle conversions. */
switch (rhs_code)
{
|| maybe_ne (2 * TYPE_VECTOR_SUBPARTS (lhs_type),
TYPE_VECTOR_SUBPARTS (rhs1_type)))
{
- error ("type mismatch in vector unpack expression");
+ error ("type mismatch in %qs expression", code_name);
debug_generic_expr (lhs_type);
debug_generic_expr (rhs1_type);
return true;
|| TYPE_UNSIGNED (rhs1_type)
|| element_precision (lhs_type) != element_precision (rhs1_type))
{
- error ("invalid types for ABSU_EXPR");
+ error ("invalid types for %qs", code_name);
debug_generic_expr (lhs_type);
debug_generic_expr (rhs1_type);
return true;
if (TREE_CODE (lhs_type) != VECTOR_TYPE
|| !useless_type_conversion_p (TREE_TYPE (lhs_type), rhs1_type))
{
- error ("vec_duplicate should be from a scalar to a like vector");
+ error ("%qs should be from a scalar to a like vector", code_name);
debug_generic_expr (lhs_type);
debug_generic_expr (rhs1_type);
return true;
return true;
}
+ const char* const code_name = get_tree_code_name (rhs_code);
+
/* First handle operations that involve different types. */
switch (rhs_code)
{
|| !(INTEGRAL_TYPE_P (rhs2_type)
|| SCALAR_FLOAT_TYPE_P (rhs2_type)))
{
- error ("type mismatch in complex expression");
+ error ("type mismatch in %qs", code_name);
debug_generic_expr (lhs_type);
debug_generic_expr (rhs1_type);
debug_generic_expr (rhs2_type);
&& INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type))))
|| !useless_type_conversion_p (lhs_type, rhs1_type))
{
- error ("type mismatch in shift expression");
+ error ("type mismatch in %qs", code_name);
debug_generic_expr (lhs_type);
debug_generic_expr (rhs1_type);
debug_generic_expr (rhs2_type);
|| TREE_CODE (rhs2) != INTEGER_CST
|| (2 * TYPE_PRECISION (rhs1_type) > TYPE_PRECISION (lhs_type)))
{
- error ("type mismatch in widening vector shift expression");
+ error ("type mismatch in %qs", code_name);
debug_generic_expr (lhs_type);
debug_generic_expr (rhs1_type);
debug_generic_expr (rhs2_type);
|| (2 * TYPE_PRECISION (TREE_TYPE (rhs1_type))
> TYPE_PRECISION (TREE_TYPE (lhs_type))))
{
- error ("type mismatch in widening vector shift expression");
+ error ("type mismatch in %qs", code_name);
debug_generic_expr (lhs_type);
debug_generic_expr (rhs1_type);
debug_generic_expr (rhs2_type);
if (TREE_CODE (rhs1_type) != VECTOR_TYPE
|| TREE_CODE (rhs2_type) != VECTOR_TYPE)
{
- error ("invalid non-vector operands to vector valued plus");
+ error ("invalid non-vector operands to %qs", code_name);
return true;
}
lhs_etype = TREE_TYPE (lhs_type);
|| POINTER_TYPE_P (rhs1_etype)
|| POINTER_TYPE_P (rhs2_etype))
{
- error ("invalid (pointer) operands to plus/minus");
+ error ("invalid (pointer) operands %qs", code_name);
return true;
}
|| !useless_type_conversion_p (lhs_type, rhs1_type)
|| !ptrofftype_p (rhs2_type))
{
- error ("type mismatch in pointer plus expression");
+ error ("type mismatch in %qs", code_name);
debug_generic_stmt (lhs_type);
debug_generic_stmt (rhs1_type);
debug_generic_stmt (rhs2_type);
|| TYPE_UNSIGNED (lhs_type)
|| TYPE_PRECISION (lhs_type) != TYPE_PRECISION (rhs1_type))
{
- error ("type mismatch in pointer diff expression");
+ error ("type mismatch in %qs", code_name);
debug_generic_stmt (lhs_type);
debug_generic_stmt (rhs1_type);
debug_generic_stmt (rhs2_type);
|| maybe_lt (GET_MODE_SIZE (element_mode (rhs2_type)),
2 * GET_MODE_SIZE (element_mode (rhs1_type))))
{
- error ("type mismatch in widening sum reduction");
+ error ("type mismatch in %qs", code_name);
debug_generic_expr (lhs_type);
debug_generic_expr (rhs1_type);
debug_generic_expr (rhs2_type);
|| maybe_ne (GET_MODE_SIZE (element_mode (lhs_type)),
2 * GET_MODE_SIZE (element_mode (rhs1_type))))
{
- error ("type mismatch in vector widening multiplication");
+ error ("type mismatch in %qs", code_name);
debug_generic_expr (lhs_type);
debug_generic_expr (rhs1_type);
debug_generic_expr (rhs2_type);
|| maybe_ne (2 * TYPE_VECTOR_SUBPARTS (rhs1_type),
TYPE_VECTOR_SUBPARTS (lhs_type)))
{
- error ("type mismatch in vector pack expression");
+ error ("type mismatch in %qs", code_name);
debug_generic_expr (lhs_type);
debug_generic_expr (rhs1_type);
debug_generic_expr (rhs2_type);
|| maybe_ne (2 * TYPE_VECTOR_SUBPARTS (rhs1_type),
TYPE_VECTOR_SUBPARTS (lhs_type)))
{
- error ("type mismatch in vector pack expression");
+ error ("type mismatch in %qs", code_name);
debug_generic_expr (lhs_type);
debug_generic_expr (rhs1_type);
debug_generic_expr (rhs2_type);
case VEC_SERIES_EXPR:
if (!useless_type_conversion_p (rhs1_type, rhs2_type))
{
- error ("type mismatch in series expression");
+ error ("type mismatch in %qs", code_name);
debug_generic_expr (rhs1_type);
debug_generic_expr (rhs2_type);
return true;
if (TREE_CODE (lhs_type) != VECTOR_TYPE
|| !useless_type_conversion_p (TREE_TYPE (lhs_type), rhs1_type))
{
- error ("vector type expected in series expression");
+ error ("vector type expected in %qs", code_name);
debug_generic_expr (lhs_type);
return true;
}
return true;
}
+ const char* const code_name = get_tree_code_name (rhs_code);
+
/* First handle operations that involve different types. */
switch (rhs_code)
{
|| 2 * TYPE_PRECISION (rhs1_type) > TYPE_PRECISION (lhs_type)
|| TYPE_PRECISION (rhs1_type) != TYPE_PRECISION (rhs2_type))
{
- error ("type mismatch in widening multiply-accumulate expression");
+ error ("type mismatch in %qs", code_name);
debug_generic_expr (lhs_type);
debug_generic_expr (rhs1_type);
debug_generic_expr (rhs2_type);
|| maybe_ne (TYPE_VECTOR_SUBPARTS (rhs1_type),
TYPE_VECTOR_SUBPARTS (lhs_type)))
{
- error ("the first argument of a VEC_COND_EXPR must be of a "
+ error ("the first argument of a %qs must be of a "
"boolean vector type of the same number of elements "
- "as the result");
+ "as the result", code_name);
debug_generic_expr (lhs_type);
debug_generic_expr (rhs1_type);
return true;
if (!useless_type_conversion_p (lhs_type, rhs2_type)
|| !useless_type_conversion_p (lhs_type, rhs3_type))
{
- error ("type mismatch in conditional expression");
+ error ("type mismatch in %qs", code_name);
debug_generic_expr (lhs_type);
debug_generic_expr (rhs2_type);
debug_generic_expr (rhs3_type);
if (!useless_type_conversion_p (lhs_type, rhs1_type)
|| !useless_type_conversion_p (lhs_type, rhs2_type))
{
- error ("type mismatch in vector permute expression");
+ error ("type mismatch in %qs", code_name);
debug_generic_expr (lhs_type);
debug_generic_expr (rhs1_type);
debug_generic_expr (rhs2_type);
|| TREE_CODE (rhs2_type) != VECTOR_TYPE
|| TREE_CODE (rhs3_type) != VECTOR_TYPE)
{
- error ("vector types expected in vector permute expression");
+ error ("vector types expected in %qs", code_name);
debug_generic_expr (lhs_type);
debug_generic_expr (rhs1_type);
debug_generic_expr (rhs2_type);
|| maybe_ne (TYPE_VECTOR_SUBPARTS (rhs3_type),
TYPE_VECTOR_SUBPARTS (lhs_type)))
{
- error ("vectors with different element number found "
- "in vector permute expression");
+ error ("vectors with different element number found in %qs",
+ code_name);
debug_generic_expr (lhs_type);
debug_generic_expr (rhs1_type);
debug_generic_expr (rhs2_type);
!= GET_MODE_BITSIZE (SCALAR_TYPE_MODE
(TREE_TYPE (rhs1_type))))))
{
- error ("invalid mask type in vector permute expression");
+ error ("invalid mask type in %qs", code_name);
debug_generic_expr (lhs_type);
debug_generic_expr (rhs1_type);
debug_generic_expr (rhs2_type);
|| 2 * GET_MODE_UNIT_BITSIZE (TYPE_MODE (TREE_TYPE (rhs1_type)))
> GET_MODE_UNIT_BITSIZE (TYPE_MODE (TREE_TYPE (lhs_type))))
{
- error ("type mismatch in sad expression");
+ error ("type mismatch in %qs", code_name);
debug_generic_expr (lhs_type);
debug_generic_expr (rhs1_type);
debug_generic_expr (rhs2_type);
|| TREE_CODE (rhs2_type) != VECTOR_TYPE
|| TREE_CODE (rhs3_type) != VECTOR_TYPE)
{
- error ("vector types expected in sad expression");
+ error ("vector types expected in %qs", code_name);
debug_generic_expr (lhs_type);
debug_generic_expr (rhs1_type);
debug_generic_expr (rhs2_type);
case BIT_INSERT_EXPR:
if (! useless_type_conversion_p (lhs_type, rhs1_type))
{
- error ("type mismatch in BIT_INSERT_EXPR");
+ error ("type mismatch in %qs", code_name);
debug_generic_expr (lhs_type);
debug_generic_expr (rhs1_type);
return true;
TYPE_VECTOR_SUBPARTS (rhs2_type))
&& multiple_of_p (bitsizetype, rhs3, TYPE_SIZE (rhs2_type)))))
{
- error ("not allowed type combination in BIT_INSERT_EXPR");
+ error ("not allowed type combination in %qs", code_name);
debug_generic_expr (rhs1_type);
debug_generic_expr (rhs2_type);
return true;
|| ! types_compatible_p (bitsizetype, TREE_TYPE (rhs3))
|| ! tree_fits_uhwi_p (TYPE_SIZE (rhs2_type)))
{
- error ("invalid position or size in BIT_INSERT_EXPR");
+ error ("invalid position or size in %qs", code_name);
return true;
}
if (INTEGRAL_TYPE_P (rhs1_type)
&& !type_has_mode_precision_p (rhs1_type))
{
- error ("BIT_INSERT_EXPR into non-mode-precision operand");
+ error ("%qs into non-mode-precision operand", code_name);
return true;
}
if (INTEGRAL_TYPE_P (rhs1_type))
|| (bitpos + TYPE_PRECISION (rhs2_type)
> TYPE_PRECISION (rhs1_type)))
{
- error ("insertion out of range in BIT_INSERT_EXPR");
+ error ("insertion out of range in %qs", code_name);
return true;
}
}
unsigned HOST_WIDE_INT bitsize = tree_to_uhwi (TYPE_SIZE (rhs2_type));
if (bitpos % bitsize != 0)
{
- error ("vector insertion not at element boundary");
+ error ("%qs not at element boundary", code_name);
return true;
}
}
|| maybe_lt (GET_MODE_SIZE (element_mode (rhs3_type)),
2 * GET_MODE_SIZE (element_mode (rhs1_type))))
{
- error ("type mismatch in dot product reduction");
+ error ("type mismatch in %qs", code_name);
debug_generic_expr (lhs_type);
debug_generic_expr (rhs1_type);
debug_generic_expr (rhs2_type);
tree rhs1_type = TREE_TYPE (rhs1);
bool res = false;
+ const char* const code_name = get_tree_code_name (rhs_code);
+
if (!useless_type_conversion_p (lhs_type, rhs1_type))
{
- error ("non-trivial conversion at assignment");
+ error ("non-trivial conversion in %qs", code_name);
debug_generic_expr (lhs_type);
debug_generic_expr (rhs1_type);
return true;
if (gimple_clobber_p (stmt)
&& !(DECL_P (lhs) || TREE_CODE (lhs) == MEM_REF))
{
- error ("non-decl/MEM_REF LHS in clobber statement");
+ error ("%qs LHS in clobber statement",
+ get_tree_code_name (TREE_CODE (lhs)));
debug_generic_expr (lhs);
return true;
}
tree op = TREE_OPERAND (rhs1, 0);
if (!is_gimple_addressable (op))
{
- error ("invalid operand in unary expression");
+ error ("invalid operand in %qs", code_name);
return true;
}
&& !one_pointer_to_useless_type_conversion_p (TREE_TYPE (rhs1),
TREE_TYPE (op)))
{
- error ("type mismatch in address expression");
+ error ("type mismatch in %qs", code_name);
debug_generic_stmt (TREE_TYPE (rhs1));
debug_generic_stmt (TREE_TYPE (op));
return true;
/* tcc_reference */
case INDIRECT_REF:
- error ("INDIRECT_REF in gimple IL");
+ error ("%qs in gimple IL", code_name);
return true;
case COMPONENT_REF:
if (!is_gimple_reg (lhs)
&& is_gimple_reg_type (TREE_TYPE (lhs)))
{
- error ("invalid rhs for gimple memory store");
+ error ("invalid RHS for gimple memory store: %qs", code_name);
debug_generic_stmt (lhs);
debug_generic_stmt (rhs1);
return true;
&& !is_gimple_reg (rhs1)
&& is_gimple_reg_type (TREE_TYPE (lhs)))
{
- error ("invalid rhs for gimple memory store");
+ error ("invalid RHS for gimple memory store: %qs", code_name);
debug_generic_stmt (lhs);
debug_generic_stmt (rhs1);
return true;
if (!useless_type_conversion_p (TREE_TYPE (rhs1_type),
TREE_TYPE (elt_t)))
{
- error ("incorrect type of vector CONSTRUCTOR"
- " elements");
+ error ("incorrect type of vector %qs elements",
+ code_name);
debug_generic_stmt (rhs1);
return true;
}
* TYPE_VECTOR_SUBPARTS (elt_t),
TYPE_VECTOR_SUBPARTS (rhs1_type)))
{
- error ("incorrect number of vector CONSTRUCTOR"
- " elements");
+ error ("incorrect number of vector %qs elements",
+ code_name);
debug_generic_stmt (rhs1);
return true;
}
else if (!useless_type_conversion_p (TREE_TYPE (rhs1_type),
elt_t))
{
- error ("incorrect type of vector CONSTRUCTOR elements");
+ error ("incorrect type of vector %qs elements",
+ code_name);
debug_generic_stmt (rhs1);
return true;
}
else if (maybe_gt (CONSTRUCTOR_NELTS (rhs1),
TYPE_VECTOR_SUBPARTS (rhs1_type)))
{
- error ("incorrect number of vector CONSTRUCTOR elements");
+ error ("incorrect number of vector %qs elements",
+ code_name);
debug_generic_stmt (rhs1);
return true;
}
|| TREE_CODE (elt_i) != INTEGER_CST
|| compare_tree_int (elt_i, i) != 0))
{
- error ("vector CONSTRUCTOR with non-NULL element index");
+ error ("vector %qs with non-NULL element index",
+ code_name);
debug_generic_stmt (rhs1);
return true;
}
if (!is_gimple_val (elt_v))
{
- error ("vector CONSTRUCTOR element is not a GIMPLE value");
+ error ("vector %qs element is not a GIMPLE value",
+ code_name);
debug_generic_stmt (rhs1);
return true;
}
}
else if (CONSTRUCTOR_NELTS (rhs1) != 0)
{
- error ("non-vector CONSTRUCTOR with elements");
+ error ("non-vector %qs with elements", code_name);
debug_generic_stmt (rhs1);
return true;
}
rhs1 = fold (ASSERT_EXPR_COND (rhs1));
if (rhs1 == boolean_false_node)
{
- error ("ASSERT_EXPR with an always-false condition");
+ error ("%qs with an always-false condition", code_name);
debug_generic_stmt (rhs1);
return true;
}
if (CASE_CHAIN (elt))
{
- error ("invalid CASE_CHAIN");
+ error ("invalid %<CASE_CHAIN%>");
debug_generic_expr (elt);
return true;
}
&& (uid == -1
|| (*label_to_block_map_for_fn (cfun))[uid] != gimple_bb (stmt)))
{
- error ("incorrect entry in label_to_block_map");
+ error ("incorrect entry in %<label_to_block_map%>");
err |= true;
}
if (!phi_result)
{
- error ("invalid PHI result");
+ error ("invalid %<PHI%> result");
return true;
}
|| (virtual_p
&& SSA_NAME_VAR (phi_result) != gimple_vop (cfun)))
{
- error ("invalid PHI result");
+ error ("invalid %<PHI%> result");
err = true;
}
if (!t)
{
- error ("missing PHI def");
+ error ("missing %<PHI%> def");
err |= true;
continue;
}
|| (!virtual_p
&& !is_gimple_val (t)))
{
- error ("invalid PHI argument");
+ error ("invalid %<PHI%> argument");
debug_generic_expr (t);
err |= true;
}
#ifdef ENABLE_TYPES_CHECKING
if (!useless_type_conversion_p (TREE_TYPE (phi_result), TREE_TYPE (t)))
{
- error ("incompatible types in PHI argument %u", i);
+ error ("incompatible types in %<PHI%> argument %u", i);
debug_generic_stmt (TREE_TYPE (phi_result));
debug_generic_stmt (TREE_TYPE (t));
err |= true;
{
timevar_push (TV_TREE_STMT_VERIFY);
if (verify_gimple_in_seq_2 (stmts))
- internal_error ("verify_gimple failed");
+ internal_error ("%<verify_gimple%> failed");
timevar_pop (TV_TREE_STMT_VERIFY);
}
{
if (!visited->contains (stmt))
{
- error ("dead STMT in EH table");
+ error ("dead statement in EH table");
debug_gimple_stmt (stmt);
eh_error_found = true;
}
}
}
+/* Disable warnings about missing quoting in GCC diagnostics for
+ the verification errors. Their format strings don't follow
+ GCC diagnostic conventions and trigger an ICE in the end. */
+#if __GNUC__ >= 10
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wformat-diag"
+#endif
+
/* Verify the GIMPLE statements in the CFG of FN. */
DEBUG_FUNCTION void
return err;
}
+#if __GNUC__ >= 10
+# pragma GCC diagnostic pop
+#endif
/* Updates phi nodes after creating a forwarder block joined
by edge FALLTHRU. */
if (fdecl)
warning_at (loc, OPT_Wunused_result,
- "ignoring return value of %qD, "
- "declared with attribute warn_unused_result",
+ "ignoring return value of %qD "
+ "declared with attribute %<warn_unused_result%>",
fdecl);
else
warning_at (loc, OPT_Wunused_result,
"ignoring return value of function "
- "declared with attribute warn_unused_result");
+ "declared with attribute %<warn_unused_result%>");
}
break;
/* PR 20090218-1_0.c. Body can be provided by another module. */
&& (reason != CIF_BODY_NOT_AVAILABLE || !flag_generate_lto))
{
- error ("inlining failed in call to always_inline %q+F: %s", fn,
+ error ("inlining failed in call to %<always_inline%> %q+F: %s", fn,
cgraph_inline_failed_string (reason));
if (gimple_location (stmt) != UNKNOWN_LOCATION)
inform (gimple_location (stmt), "called from here");
if (SSA_NAME_IN_FREE_LIST (use))
{
- error ("statement uses released SSA name:");
+ error ("statement uses released SSA name");
debug_gimple_stmt (stmt);
fprintf (stderr, "The use of ");
print_generic_expr (stderr, use);
omp_clause_check_failed (const_tree node, const char *file, int line,
const char *function, enum omp_clause_code code)
{
- internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d",
- omp_clause_code_name[code], get_tree_code_name (TREE_CODE (node)),
+ internal_error ("tree check: expected %<omp_clause %s%>, have %qs "
+ "in %s, at %s:%d",
+ omp_clause_code_name[code],
+ get_tree_code_name (TREE_CODE (node)),
function, trim_filename (file), line);
}
const char *function)
{
internal_error
- ("tree check: accessed elt %d of tree_int_cst with %d elts in %s, at %s:%d",
+ ("tree check: accessed elt %d of %<tree_int_cst%> with %d elts in %s, "
+ "at %s:%d",
idx + 1, len, function, trim_filename (file), line);
}
const char *function)
{
internal_error
- ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
+ ("tree check: accessed elt %d of %<tree_vec%> with %d elts in %s, at %s:%d",
idx + 1, len, function, trim_filename (file), line);
}
int line, const char *function)
{
internal_error
- ("tree check: accessed operand %d of omp_clause %s with %d operands "
+ ("tree check: accessed operand %d of %<omp_clause %s%> with %d operands "
"in %s, at %s:%d", idx + 1, omp_clause_code_name[OMP_CLAUSE_CODE (t)],
omp_clause_num_ops [OMP_CLAUSE_CODE (t)], function,
trim_filename (file), line);
{
gcc_assert (!operand_equal_p (TYPE_SIZE_UNIT (t),
TYPE_SIZE_UNIT (tv), 0));
- error ("type variant has different TYPE_SIZE_UNIT");
+ error ("type variant has different %<TYPE_SIZE_UNIT%>");
debug_tree (tv);
- error ("type variant%'s TYPE_SIZE_UNIT");
+ error ("type variant%'s %<TYPE_SIZE_UNIT%>");
debug_tree (TYPE_SIZE_UNIT (tv));
- error ("type%'s TYPE_SIZE_UNIT");
+ error ("type%'s %<TYPE_SIZE_UNIT%>");
debug_tree (TYPE_SIZE_UNIT (t));
return false;
}
verify_variant_match (TYPE_STRING_FLAG);
if (TYPE_ALIAS_SET_KNOWN_P (t))
{
- error ("type variant with TYPE_ALIAS_SET_KNOWN_P");
+ error ("type variant with %<TYPE_ALIAS_SET_KNOWN_P%>");
debug_tree (tv);
return false;
}
&& (in_lto_p || !TYPE_VFIELD (tv)
|| TREE_CODE (TYPE_VFIELD (tv)) != TREE_LIST))
{
- error ("type variant has different TYPE_VFIELD");
+ error ("type variant has different %<TYPE_VFIELD%>");
debug_tree (tv);
return false;
}
at LTO time only. */
&& (in_lto_p && odr_type_p (t)))
{
- error ("type variant has different TYPE_BINFO");
+ error ("type variant has different %<TYPE_BINFO%>");
debug_tree (tv);
- error ("type variant%'s TYPE_BINFO");
+ error ("type variant%'s %<TYPE_BINFO%>");
debug_tree (TYPE_BINFO (tv));
- error ("type%'s TYPE_BINFO");
+ error ("type%'s %<TYPE_BINFO%>");
debug_tree (TYPE_BINFO (t));
return false;
}
break;
if (f1 || f2)
{
- error ("type variant has different TYPE_FIELDS");
+ error ("type variant has different %<TYPE_FIELDS%>");
debug_tree (tv);
error ("first mismatch is field");
debug_tree (f1);
|| TYPE_MAIN_VARIANT (TREE_TYPE (t))
!= TYPE_MAIN_VARIANT (TREE_TYPE (tv))))
{
- error ("type variant has different TREE_TYPE");
+ error ("type variant has different %<TREE_TYPE%>");
debug_tree (tv);
- error ("type variant%'s TREE_TYPE");
+ error ("type variant%'s %<TREE_TYPE%>");
debug_tree (TREE_TYPE (tv));
- error ("type%'s TREE_TYPE");
+ error ("type%'s %<TREE_TYPE%>");
debug_tree (TREE_TYPE (t));
return false;
}
{
error ("type is not compatible with its variant");
debug_tree (tv);
- error ("type variant%'s TREE_TYPE");
+ error ("type variant%'s %<TREE_TYPE%>");
debug_tree (TREE_TYPE (tv));
- error ("type%'s TREE_TYPE");
+ error ("type%'s %<TREE_TYPE%>");
debug_tree (TREE_TYPE (t));
return false;
}
tree mv = TYPE_MAIN_VARIANT (t);
if (!mv)
{
- error ("Main variant is not defined");
+ error ("main variant is not defined");
error_found = true;
}
else if (mv != TYPE_MAIN_VARIANT (mv))
{
- error ("TYPE_MAIN_VARIANT has different TYPE_MAIN_VARIANT");
+ error ("%<TYPE_MAIN_VARIANT%> has different %<TYPE_MAIN_VARIANT%>");
debug_tree (mv);
error_found = true;
}
;
else if (TYPE_CANONICAL (t) != ct)
{
- error ("TYPE_CANONICAL has different TYPE_CANONICAL");
+ error ("%<TYPE_CANONICAL%> has different %<TYPE_CANONICAL%>");
debug_tree (ct);
error_found = true;
}
&& !gimple_canonical_types_compatible_p (t, ct, false)
&& COMPLETE_TYPE_P (t))
{
- error ("TYPE_CANONICAL is not compatible");
+ error ("%<TYPE_CANONICAL%> is not compatible");
debug_tree (ct);
error_found = true;
}
if (COMPLETE_TYPE_P (t) && TYPE_CANONICAL (t)
&& TYPE_MODE (t) != TYPE_MODE (TYPE_CANONICAL (t)))
{
- error ("TYPE_MODE of TYPE_CANONICAL is not compatible");
+ error ("%<TYPE_MODE%> of %<TYPE_CANONICAL%> is not compatible");
debug_tree (ct);
error_found = true;
}
if (TYPE_MAIN_VARIANT (t) == t && ct && TYPE_MAIN_VARIANT (ct) != ct)
{
- error ("TYPE_CANONICAL of main variant is not main variant");
+ error ("%<TYPE_CANONICAL%> of main variant is not main variant");
debug_tree (ct);
debug_tree (TYPE_MAIN_VARIANT (ct));
error_found = true;
&& TREE_CODE (TYPE_VFIELD (t)) != FIELD_DECL
&& TREE_CODE (TYPE_VFIELD (t)) != TREE_LIST)
{
- error ("TYPE_VFIELD is not FIELD_DECL nor TREE_LIST");
+ error ("%<TYPE_VFIELD%> is not %<FIELD_DECL%> nor %<TREE_LIST%>");
debug_tree (TYPE_VFIELD (t));
error_found = true;
}
if (TYPE_NEXT_PTR_TO (t)
&& TREE_CODE (TYPE_NEXT_PTR_TO (t)) != POINTER_TYPE)
{
- error ("TYPE_NEXT_PTR_TO is not POINTER_TYPE");
+ error ("%<TYPE_NEXT_PTR_TO%> is not %<POINTER_TYPE%>");
debug_tree (TYPE_NEXT_PTR_TO (t));
error_found = true;
}
if (TYPE_NEXT_REF_TO (t)
&& TREE_CODE (TYPE_NEXT_REF_TO (t)) != REFERENCE_TYPE)
{
- error ("TYPE_NEXT_REF_TO is not REFERENCE_TYPE");
+ error ("%<TYPE_NEXT_REF_TO%> is not %<REFERENCE_TYPE%>");
debug_tree (TYPE_NEXT_REF_TO (t));
error_found = true;
}
;
else if (TREE_CODE (TYPE_BINFO (t)) != TREE_BINFO)
{
- error ("TYPE_BINFO is not TREE_BINFO");
+ error ("%<TYPE_BINFO%> is not %<TREE_BINFO%>");
debug_tree (TYPE_BINFO (t));
error_found = true;
}
else if (TREE_TYPE (TYPE_BINFO (t)) != TYPE_MAIN_VARIANT (t))
{
- error ("TYPE_BINFO type is not TYPE_MAIN_VARIANT");
+ error ("%<TYPE_BINFO%> type is not %<TYPE_MAIN_VARIANT%>");
debug_tree (TREE_TYPE (TYPE_BINFO (t)));
error_found = true;
}
&& TREE_CODE (TYPE_METHOD_BASETYPE (t)) != RECORD_TYPE
&& TREE_CODE (TYPE_METHOD_BASETYPE (t)) != UNION_TYPE)
{
- error ("TYPE_METHOD_BASETYPE is not record nor union");
+ error ("%<TYPE_METHOD_BASETYPE%> is not record nor union");
debug_tree (TYPE_METHOD_BASETYPE (t));
error_found = true;
}
&& TREE_CODE (TYPE_OFFSET_BASETYPE (t)) != RECORD_TYPE
&& TREE_CODE (TYPE_OFFSET_BASETYPE (t)) != UNION_TYPE)
{
- error ("TYPE_OFFSET_BASETYPE is not record nor union");
+ error ("%<TYPE_OFFSET_BASETYPE%> is not record nor union");
debug_tree (TYPE_OFFSET_BASETYPE (t));
error_found = true;
}
if (TYPE_ARRAY_MAX_SIZE (t)
&& TREE_CODE (TYPE_ARRAY_MAX_SIZE (t)) != INTEGER_CST)
{
- error ("TYPE_ARRAY_MAX_SIZE not INTEGER_CST");
+ error ("%<TYPE_ARRAY_MAX_SIZE%> not %<INTEGER_CST%>");
debug_tree (TYPE_ARRAY_MAX_SIZE (t));
error_found = true;
}
}
else if (TYPE_MAX_VALUE_RAW (t))
{
- error ("TYPE_MAX_VALUE_RAW non-NULL");
+ error ("%<TYPE_MAX_VALUE_RAW%> non-NULL");
debug_tree (TYPE_MAX_VALUE_RAW (t));
error_found = true;
}
if (TYPE_LANG_SLOT_1 (t) && in_lto_p)
{
- error ("TYPE_LANG_SLOT_1 (binfo) field is non-NULL");
+ error ("%<TYPE_LANG_SLOT_1 (binfo)%> field is non-NULL");
debug_tree (TYPE_LANG_SLOT_1 (t));
error_found = true;
}
CONST_DECL of ENUMERAL TYPE. */
if (TREE_CODE (value) != INTEGER_CST && TREE_CODE (value) != CONST_DECL)
{
- error ("Enum value is not CONST_DECL or INTEGER_CST");
+ error ("enum value is not %<CONST_DECL%> or %<INTEGER_CST%>");
debug_tree (value);
debug_tree (name);
error_found = true;
if (TREE_CODE (TREE_TYPE (value)) != INTEGER_TYPE
&& !useless_type_conversion_p (const_cast <tree> (t), TREE_TYPE (value)))
{
- error ("Enum value type is not INTEGER_TYPE nor convertible to the enum");
+ error ("enum value type is not %<INTEGER_TYPE%> nor convertible "
+ "to the enum");
debug_tree (value);
debug_tree (name);
error_found = true;
}
if (TREE_CODE (name) != IDENTIFIER_NODE)
{
- error ("Enum value name is not IDENTIFIER_NODE");
+ error ("enum value name is not %<IDENTIFIER_NODE%>");
debug_tree (value);
debug_tree (name);
error_found = true;
{
if (TYPE_DOMAIN (t) && TREE_CODE (TYPE_DOMAIN (t)) != INTEGER_TYPE)
{
- error ("Array TYPE_DOMAIN is not integer type");
+ error ("array %<TYPE_DOMAIN%> is not integer type");
debug_tree (TYPE_DOMAIN (t));
error_found = true;
}
{
if (TYPE_FIELDS (t) && !COMPLETE_TYPE_P (t) && in_lto_p)
{
- error ("TYPE_FIELDS defined in incomplete type");
+ error ("%<TYPE_FIELDS%> defined in incomplete type");
error_found = true;
}
for (tree fld = TYPE_FIELDS (t); fld; fld = TREE_CHAIN (fld))
;
else
{
- error ("Wrong tree in TYPE_FIELDS list");
+ error ("wrong tree in %<TYPE_FIELDS%> list");
debug_tree (fld);
error_found = true;
}
{
if (TYPE_CACHED_VALUES_P (t) != (TYPE_CACHED_VALUES (t) != NULL))
{
- error ("TYPE_CACHED_VALUES_P is %i while TYPE_CACHED_VALUES is %p",
+ error ("%<TYPE_CACHED_VALUES_P%> is %i while %<TYPE_CACHED_VALUES%> "
+ "is %p",
TYPE_CACHED_VALUES_P (t), (void *)TYPE_CACHED_VALUES (t));
error_found = true;
}
else if (TYPE_CACHED_VALUES_P (t) && TREE_CODE (TYPE_CACHED_VALUES (t)) != TREE_VEC)
{
- error ("TYPE_CACHED_VALUES is not TREE_VEC");
+ error ("%<TYPE_CACHED_VALUES%> is not %<TREE_VEC%>");
debug_tree (TYPE_CACHED_VALUES (t));
error_found = true;
}
if (TREE_VEC_ELT (TYPE_CACHED_VALUES (t), i)
&& TREE_TYPE (TREE_VEC_ELT (TYPE_CACHED_VALUES (t), i)) != t)
{
- error ("wrong TYPE_CACHED_VALUES entry");
+ error ("wrong %<TYPE_CACHED_VALUES%> entry");
debug_tree (TREE_VEC_ELT (TYPE_CACHED_VALUES (t), i));
error_found = true;
break;
/* C++ FE uses TREE_PURPOSE to store initial values. */
if (TREE_PURPOSE (l) && in_lto_p)
{
- error ("TREE_PURPOSE is non-NULL in TYPE_ARG_TYPES list");
+ error ("%<TREE_PURPOSE%> is non-NULL in %<TYPE_ARG_TYPES%> list");
debug_tree (l);
error_found = true;
}
if (!TYPE_P (TREE_VALUE (l)))
{
- error ("Wrong entry in TYPE_ARG_TYPES list");
+ error ("wrong entry in %<TYPE_ARG_TYPES%> list");
debug_tree (l);
error_found = true;
}
}
else if (!is_lang_specific (t) && TYPE_VALUES_RAW (t))
{
- error ("TYPE_VALUES_RAW field is non-NULL");
+ error ("%<TYPE_VALUES_RAW%> field is non-NULL");
debug_tree (TYPE_VALUES_RAW (t));
error_found = true;
}
&& TREE_CODE (t) != POINTER_TYPE
&& TYPE_CACHED_VALUES_P (t))
{
- error ("TYPE_CACHED_VALUES_P is set while it should not");
+ error ("%<TYPE_CACHED_VALUES_P%> is set while it should not be");
error_found = true;
}
if (TYPE_STRING_FLAG (t)
&& TREE_CODE (t) != ARRAY_TYPE && TREE_CODE (t) != INTEGER_TYPE)
{
- error ("TYPE_STRING_FLAG is set on wrong type code");
+ error ("%<TYPE_STRING_FLAG%> is set on wrong type code");
error_found = true;
}
if (TREE_CODE (t) == METHOD_TYPE
&& TYPE_MAIN_VARIANT (TYPE_METHOD_BASETYPE (t)) != TYPE_METHOD_BASETYPE (t))
{
- error ("TYPE_METHOD_BASETYPE is not main variant");
+ error ("%<TYPE_METHOD_BASETYPE%> is not main variant");
error_found = true;
}
if (error_found)
{
debug_tree (const_cast <tree> (t));
- internal_error ("verify_type failed");
+ internal_error ("%qs failed", __func__);
}
}
{
if (hist->hvalue.stmt != stmt)
{
- error ("Histogram value statement does not correspond to "
+ error ("histogram value statement does not correspond to "
"the statement it is associated with");
debug_gimple_stmt (stmt);
dump_histogram_value (stderr, hist);
if (VALUE_HISTOGRAMS (cfun))
htab_traverse (VALUE_HISTOGRAMS (cfun), visit_hist, &visited_hists);
if (error_found)
- internal_error ("verify_histograms failed");
+ internal_error ("%qs failed", __func__);
}
/* Helper function for verify_histograms. For each histogram reachable via htab
if (patch_area_entry > patch_area_size)
{
if (patch_area_size > 0)
- warning (OPT_Wattributes, "patchable function entry > size");
+ warning (OPT_Wattributes,
+ "patchable function entry %wu exceeds size %wu",
+ patch_area_entry, patch_area_size);
patch_area_entry = 0;
}
{
if (((mask & 0xff) != 0xff))
{
- warning (0, "%s:tag `%x' is invalid\n", filename, tag);
+ warning (0, "%s:tag %qx is invalid", filename, tag);
break;
}
tag_depth--;
if (depth && depth < tag_depth)
{
if (!GCOV_TAG_IS_SUBTAG (tags[depth - 1], tag))
- warning (0, "%s:tag `%x' is incorrectly nested\n",
+ warning (0, "%s:tag %qx is incorrectly nested",
filename, tag);
}
depth = tag_depth;
actual_length = gcov_position () - base;
if (actual_length > length)
- warning (0, "%s:record size mismatch %lu bytes overread\n",
+ warning (0, "%s:record size mismatch %lu bytes overread",
filename, actual_length - length);
else if (length > actual_length)
- warning (0, "%s:record size mismatch %lu bytes unread\n",
+ warning (0, "%s:record size mismatch %lu bytes unread",
filename, length - actual_length);
}
gcov_sync (base, length);
if ((error = gcov_is_error ()))
{
- warning (0, error < 0 ? "%s:counter overflow at %lu\n" :
- "%s:read error at %lu\n", filename,
+ warning (0, error < 0 ? "%s:counter overflow at %lu" :
+ "%s:read error at %lu", filename,
(long unsigned) gcov_position ());
break;
}
void test01()
{
const any y(1);
- any_cast<int&>(y); // { dg-error "invalid static_cast" "" { target { *-*-* } } 461 }
+ any_cast<int&>(y); // { dg-error "invalid 'static_cast'" "" { target { *-*-* } } 461 }
// { dg-error "Template argument must be constructible from a const value" "" { target { *-*-* } } 457 }
}
void test03()
{
any y(1);
- any_cast<int&>(std::move(y)); // { dg-error "invalid static_cast" "" { target { *-*-* } } 501 }
+ any_cast<int&>(std::move(y)); // { dg-error "invalid 'static_cast'" "" { target { *-*-* } } 501 }
// { dg-error "Template argument must be constructible from an rvalue" "" { target { *-*-* } } 497 }
}
projects / thirdparty / gcc.git / commitdiff
