gcc/
* input.h (input_line): Remove.
(input_filename): Likewise.
(in_system_header): Likewise.
* tree.h (EXPR_LOC_OR_HERE): Remove.
* config/bfin/bfin.c (output_file_start): Remove use of
input_filename macro.
* builtins.c (c_strlen): Remove use of EXPR_LOC_OR_HERE macro.
* gimplify.c (internal_get_tmp_var): Likewise.
EXPR_LOC_OR_HERE macro.
(shortcut_cond_expr): Likewise.
* tree-diagnostic.c (diagnostic_report_current_function): Remove
use of input_filename macro.
* tree.c (get_file_function_name): Likewise.
gcc/ada
* gcc-interface/utils2.c (build_call_raise): Remove use of
input_line macro.
(build_call_raise_range): Likewise.
(build_call_raise_column): Likewise.
gcc/c-family
* c-common.c (unsafe_conversion_p): Remove use of
EXPR_LOC_OR_HERE macro.
(conversion_warning): Likewise.
(warnings_for_convert_and_check): Likewise.
(warn_for_collisions_1): Likewise.
(shorten_compare): Likewise, and remove use of in_system_header
macro, using the location from the former.
* c-lex.c (dump_one_header): Remove use of input_filename macro.
(cb_def_pragma): Remove use of in_system_header macro.
(lex_string): Likewise.
* c-pragma.c (handle_pragma_float_const_decimal64): Likewise.
gcc/c
* c-decl.c (define_label, shadow_tag_warned)
(check_bitfield_type_and_width, grokdeclarator, grokparms,
store_parm_decls_newstyle, store_parm_decls_oldstyle)
(declspecs_add_type): Remove use of in_system_header macro.
* c-parser.c (c_parser_unary_expression): Likewise.
* c-typeck.c (store_init_value, process_init_element)
(c_start_case): Likewise.
* c-decl.c (build_enumerator): Remove use of EXPR_LOC_OR_HERE
macro.
* c-parser.c (c_parser_set_source_position_from_token): Remove
reference to in_system_header from comment.
gcc/cp
* call.c (build_integral_nontype_arg_conv): Remove use of
EXPR_LOC_OR_HERE macro.
(convert_like_real): Likewise.
(convert_arg_to_ellipsis): Likewise.
(build_cxx_call): Likewise.
(perform_implicit_conversion_flags): Likewise.
(initialize_reference): Likewise.
* cvt.c (cp_convert_to_pointer): Likewise.
(convert_to_reference): Likewise.
(ocp_convert): Likewise.
(convert_to_void): Likewise.
* decl.c (pop_label): Update comment.
(pop_switch): Remove use of EXPR_LOC_OR_HERE macro.
(check_tag_decl): Remove use of in_system_header macro.
(make_rtl_for_nonlocal_decl): Remove use of input_filename
macro.
(compute_array_index_type): Remove use of in_system_header
macro.
(grokdeclarator): Likewise.
* error.c (dump_global_iord): Remove use of input_filename
macro.
(location_of): Remove use of EXPR_LOC_OR_HERE macro.
(maybe_warn_cpp0x): Remove use of in_system_header macro.
* init.c (build_new_1): Remove use of EXPR_LOC_OR_HERE macro.
* lex.c (handle_pragma_interface): Remove use of input_filename
macro.
(handle_pragma_implementation): Likewise.
(cxx_make_type): Likewise.
(in_main_input_context): Likewise.
* name-lookup.c (push_binding_level): Remove use of
input_line macro.
(leave_scope): Likewise.
(resume_scope): Likewise.
* parser.c (cp_parser_unqualified_id): Remove use of
in_system_header macro.
(cp_parser_cast_expression): Likewise.
(cp_parser_declaration_seq_opt): Likewise.
(cp_parser_enumerator_list): Likewise.
(cp_parser_parameter_declaration_clause): Likewise.
(cp_parser_exception_specification_opt): Likewise.
* pt.c (unify_arg_conversion): Remove use of EXPR_LOC_OR_HERE
macro.
(convert_nontype_argument): Likewise.
(push_tinst_level): Remove use of in_system_header macro.
(tsubst_copy_and_build): Remove use of EXPR_LOC_OR_HERE
macros.
(do_decl_instantiation): Remove use of in_system_header macro.
(do_type_instantiation): Likewise.
* semantics.c (finish_call_expr): Remove use of EXPR_LOC_OR_HERE
macro.
(begin_class_definition): Remove use of input_filename macro.
(cxx_eval_call_expression): Remove use of EXPR_LOC_OR_HERE
macro.
(cxx_eval_constant_expression): Likewise.
(potential_constant_expression_1): Likewise.
* typeck.c (decay_conversion): Likewise.
(rationalize_conditional_expr): Likewise.
(build_x_compound_expr_from_list): Likewise.
(convert_for_assignment): Likewise.
* typeck2.c (check_narrowing): Likewise.
gcc/fortran
* trans.c (trans_runtime_error_vararg): Remove use of input_line
macro.
gcc/java
* class.c (maybe_layout_super_class): Update comment.
* decl.c (java_add_stmt): Remove use of input_filename macro.
* jcf-parse.c (set_source_filename): Remove use of
input_filename macro.
(parse_class_file): Remove use of input_line and input_filename
macros.
(java_parse_file): Remove use of input_filename macro.
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@205262
138bc75d-0d04-0410-961f-
82ee72b054a4
+2013-11-22 David Malcolm <dmalcolm@redhat.com>
+
+ * input.h (input_line): Remove.
+ (input_filename): Likewise.
+ (in_system_header): Likewise.
+ * tree.h (EXPR_LOC_OR_HERE): Remove.
+ * config/bfin/bfin.c (output_file_start): Remove use of
+ input_filename macro.
+ * builtins.c (c_strlen): Remove use of EXPR_LOC_OR_HERE macro.
+ * gimplify.c (internal_get_tmp_var): Likewise.
+ EXPR_LOC_OR_HERE macro.
+ (shortcut_cond_expr): Likewise.
+ * tree-diagnostic.c (diagnostic_report_current_function): Remove
+ use of input_filename macro.
+ * tree.c (get_file_function_name): Likewise.
+
2013-11-22 Kenneth Zadeck <zadeck@naturalbridge.com>
* store-layout.c (place-field): Fix hwi test and accessor mismatch.
+2013-11-22 David Malcolm <dmalcolm@redhat.com>
+
+ * gcc-interface/utils2.c (build_call_raise): Remove use of
+ input_line macro.
+ (build_call_raise_range): Likewise.
+ (build_call_raise_column): Likewise.
+
2013-11-20 Kenneth Zadeck <zadeck@naturalbridge.com>
Mike Stump <mikestump@comcast.net>
Richard Sandiford <rdsandiford@googlemail.com>
filename = build_string (len, str);
line_number
= (gnat_node != Empty && Sloc (gnat_node) != No_Location)
- ? Get_Logical_Line_Number (Sloc(gnat_node)) : input_line;
+ ? Get_Logical_Line_Number (Sloc(gnat_node))
+ : LOCATION_LINE (input_location);
TREE_TYPE (filename) = build_array_type (unsigned_char_type_node,
build_index_type (size_int (len)));
}
else
{
- line_number = input_line;
+ line_number = LOCATION_LINE (input_location);
column_number = 0;
}
}
else
{
- line_number = input_line;
+ line_number = LOCATION_LINE (input_location);
column_number = 0;
}
&& (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
return c_strlen (TREE_OPERAND (src, 1), only_value);
- loc = EXPR_LOC_OR_HERE (src);
+ loc = EXPR_LOC_OR_LOC (src, input_location);
src = string_constant (src, &offset_node);
if (src == 0)
+2013-11-22 David Malcolm <dmalcolm@redhat.com>
+
+ * c-common.c (unsafe_conversion_p): Remove use of
+ EXPR_LOC_OR_HERE macro.
+ (conversion_warning): Likewise.
+ (warnings_for_convert_and_check): Likewise.
+ (warn_for_collisions_1): Likewise.
+ (shorten_compare): Likewise, and remove use of in_system_header
+ macro, using the location from the former.
+ * c-lex.c (dump_one_header): Remove use of input_filename macro.
+ (cb_def_pragma): Remove use of in_system_header macro.
+ (lex_string): Likewise.
+ * c-pragma.c (handle_pragma_float_const_decimal64): Likewise.
+
2013-11-20 Kenneth Zadeck <zadeck@naturalbridge.com>
Mike Stump <mikestump@comcast.net>
Richard Sandiford <rdsandiford@googlemail.com>
{
enum conversion_safety give_warning = SAFE_CONVERSION; /* is 0 or false */
tree expr_type = TREE_TYPE (expr);
- location_t loc = EXPR_LOC_OR_HERE (expr);
+ location_t loc = EXPR_LOC_OR_LOC (expr, input_location);
if (TREE_CODE (expr) == REAL_CST || TREE_CODE (expr) == INTEGER_CST)
{
conversion_warning (tree type, tree expr)
{
tree expr_type = TREE_TYPE (expr);
- location_t loc = EXPR_LOC_OR_HERE (expr);
+ location_t loc = EXPR_LOC_OR_LOC (expr, input_location);
enum conversion_safety conversion_kind;
if (!warn_conversion && !warn_sign_conversion && !warn_float_conversion)
void
warnings_for_convert_and_check (tree type, tree expr, tree result)
{
- location_t loc = EXPR_LOC_OR_HERE (expr);
+ location_t loc = EXPR_LOC_OR_LOC (expr, input_location);
if (TREE_CODE (expr) == INTEGER_CST
&& (TREE_CODE (type) == INTEGER_TYPE
&& (!only_writes || list->writer))
{
warned_ids = new_tlist (warned_ids, written, NULL_TREE);
- warning_at (EXPR_LOC_OR_HERE (writer),
+ warning_at (EXPR_LOC_OR_LOC (writer, input_location),
OPT_Wsequence_point, "operation on %qE may be undefined",
list->expr);
}
int real1, real2;
tree primop0, primop1;
enum tree_code code = *rescode_ptr;
- location_t loc = EXPR_LOC_OR_HERE (op0);
+ location_t loc = EXPR_LOC_OR_LOC (op0, input_location);
/* Throw away any conversions to wider types
already present in the operands. */
the comparison isn't an issue, so suppress the
warning. */
bool warn =
- warn_type_limits && !in_system_header
+ warn_type_limits && !in_system_header_at (loc)
&& c_inhibit_evaluation_warnings == 0
&& !(TREE_CODE (primop0) == INTEGER_CST
&& !TREE_OVERFLOW (convert (c_common_signed_type (type),
void
dump_time_statistics (void)
{
- struct c_fileinfo *file = get_fileinfo (input_filename);
+ struct c_fileinfo *file = get_fileinfo (LOCATION_FILE (input_location));
int this_time = get_run_time ();
file->time += this_time - body_time;
/* Issue a warning message if we have been asked to do so. Ignore
unknown pragmas in system headers unless an explicit
-Wunknown-pragmas has been given. */
- if (warn_unknown_pragmas > in_system_header)
+ if (warn_unknown_pragmas > in_system_header_at (input_location))
{
const unsigned char *space, *name;
const cpp_token *s;
if (concats)
strs = XOBFINISH (&str_ob, cpp_string *);
- if (concats && !objc_string && !in_system_header)
+ if (concats && !objc_string && !in_system_header_at (input_location))
warning (OPT_Wtraditional,
"traditional C rejects string constant concatenation");
{
if (c_dialect_cxx ())
{
- if (warn_unknown_pragmas > in_system_header)
+ if (warn_unknown_pragmas > in_system_header_at (input_location))
warning (OPT_Wunknown_pragmas,
"%<#pragma STDC FLOAT_CONST_DECIMAL64%> is not supported"
" for C++");
if (!targetm.decimal_float_supported_p ())
{
- if (warn_unknown_pragmas > in_system_header)
+ if (warn_unknown_pragmas > in_system_header_at (input_location))
warning (OPT_Wunknown_pragmas,
"%<#pragma STDC FLOAT_CONST_DECIMAL64%> is not supported"
" on this target");
+2013-11-22 David Malcolm <dmalcolm@redhat.com>
+
+ * c-decl.c (define_label, shadow_tag_warned)
+ (check_bitfield_type_and_width, grokdeclarator, grokparms,
+ store_parm_decls_newstyle, store_parm_decls_oldstyle)
+ (declspecs_add_type): Remove use of in_system_header macro.
+ * c-parser.c (c_parser_unary_expression): Likewise.
+ * c-typeck.c (store_init_value, process_init_element)
+ (c_start_case): Likewise.
+
+ * c-decl.c (build_enumerator): Remove use of EXPR_LOC_OR_HERE
+ macro.
+
+ * c-parser.c (c_parser_set_source_position_from_token): Remove
+ reference to in_system_header from comment.
+
2013-11-18 Richard Sandiford <rdsandiford@googlemail.com>
* c-decl.c (grokdeclarator): Update comment to refer to
bind_label (name, label, current_function_scope, label_vars);
}
- if (!in_system_header && lookup_name (name))
+ if (!in_system_header_at (input_location) && lookup_name (name))
warning_at (location, OPT_Wtraditional,
"traditional C lacks a separate namespace "
"for labels, identifier %qE conflicts", name);
}
else
{
- if (warned != 1 && !in_system_header)
+ if (warned != 1 && !in_system_header_at (input_location))
{
pedwarn (input_location, 0,
"useless type name in empty declaration");
}
}
}
- else if (warned != 1 && !in_system_header && declspecs->typedef_p)
+ else if (warned != 1 && !in_system_header_at (input_location)
+ && declspecs->typedef_p)
{
pedwarn (input_location, 0, "useless type name in empty declaration");
warned = 1;
warned = 1;
}
- if (!warned && !in_system_header && declspecs->storage_class != csc_none)
+ if (!warned && !in_system_header_at (input_location)
+ && declspecs->storage_class != csc_none)
{
warning (0, "useless storage class specifier in empty declaration");
warned = 2;
}
- if (!warned && !in_system_header && declspecs->thread_p)
+ if (!warned && !in_system_header_at (input_location) && declspecs->thread_p)
{
warning (0, "useless %qs in empty declaration",
declspecs->thread_gnu_p ? "__thread" : "_Thread_local");
warned = 2;
}
- if (!warned && !in_system_header && (declspecs->const_p
- || declspecs->volatile_p
- || declspecs->atomic_p
- || declspecs->restrict_p
- || declspecs->address_space))
+ if (!warned
+ && !in_system_header_at (input_location)
+ && (declspecs->const_p
+ || declspecs->volatile_p
+ || declspecs->atomic_p
+ || declspecs->restrict_p
+ || declspecs->address_space))
{
warning (0, "useless type qualifier in empty declaration");
warned = 2;
}
- if (!warned && !in_system_header && declspecs->alignas_p)
+ if (!warned && !in_system_header_at (input_location)
+ && declspecs->alignas_p)
{
warning (0, "useless %<_Alignas%> in empty declaration");
warned = 2;
}
type_mv = TYPE_MAIN_VARIANT (*type);
- if (!in_system_header
+ if (!in_system_header_at (input_location)
&& type_mv != integer_type_node
&& type_mv != unsigned_type_node
&& type_mv != boolean_type_node)
/* Diagnose defaulting to "int". */
- if (declspecs->default_int_p && !in_system_header)
+ if (declspecs->default_int_p && !in_system_header_at (input_location))
{
/* Issue a warning if this is an ISO C 99 program or if
-Wreturn-type and this is a function, or if -Wimplicit;
type = error_mark_node;
}
- if (pedantic && !in_system_header && flexible_array_type_p (type))
+ if (pedantic && !in_system_header_at (input_location)
+ && flexible_array_type_p (type))
pedwarn (loc, OPT_Wpedantic,
"invalid use of structure with flexible array member");
flexible_array_member = (t->kind == cdk_id);
}
if (flexible_array_member
- && pedantic && !flag_isoc99 && !in_system_header)
+ && pedantic && !flag_isoc99
+ && !in_system_header_at (input_location))
pedwarn (loc, OPT_Wpedantic,
"ISO C90 does not support flexible array members");
error ("%<[*]%> not allowed in other than function prototype scope");
}
- if (arg_types == 0 && !funcdef_flag && !in_system_header)
+ if (arg_types == 0 && !funcdef_flag
+ && !in_system_header_at (input_location))
warning (OPT_Wstrict_prototypes,
"function declaration isn%'t a prototype");
/* Set basis for default for next value. */
the_enum->enum_next_value
- = build_binary_op (EXPR_LOC_OR_HERE (value),
+ = build_binary_op (EXPR_LOC_OR_LOC (value, input_location),
PLUS_EXPR, value, integer_one_node, 0);
the_enum->enum_overflow = tree_int_cst_lt (the_enum->enum_next_value, value);
warning if we got here because ARG_INFO_TYPES was error_mark_node
(this happens when a function definition has just an ellipsis in
its parameter list). */
- else if (!in_system_header && !current_function_scope
+ else if (!in_system_header_at (input_location)
+ && !current_function_scope
&& arg_info->types != error_mark_node)
warning_at (DECL_SOURCE_LOCATION (fndecl), OPT_Wtraditional,
"traditional C rejects ISO C style function definitions");
tree parmids = arg_info->parms;
struct pointer_set_t *seen_args = pointer_set_create ();
- if (!in_system_header)
+ if (!in_system_header_at (input_location))
warning_at (DECL_SOURCE_LOCATION (fndecl),
OPT_Wold_style_definition, "old-style function definition");
error_at (loc, "%<__int128%> is not supported for this target");
return specs;
}
- if (!in_system_header)
+ if (!in_system_header_at (input_location))
pedwarn (loc, OPT_Wpedantic,
"ISO C does not support %<__int128%> type");
parser->in_pragma = true;
}
-/* Update the globals input_location and in_system_header from
- TOKEN. */
+/* Update the global input_location from TOKEN. */
static inline void
c_parser_set_source_position_from_token (c_token *token)
{
ret.value = build_indirect_ref (op_loc, op.value, RO_UNARY_STAR);
return ret;
case CPP_PLUS:
- if (!c_dialect_objc () && !in_system_header)
+ if (!c_dialect_objc () && !in_system_header_at (input_location))
warning_at (op_loc,
OPT_Wtraditional,
"traditional C rejects the unary plus operator");
/* Store the expression if valid; else report error. */
- if (!in_system_header
+ if (!in_system_header_at (input_location)
&& AGGREGATE_TYPE_P (TREE_TYPE (decl)) && !TREE_STATIC (decl))
warning (OPT_Wtraditional, "traditional C rejects automatic "
"aggregate initialization");
again on the assumption that this must be conditional on
__STDC__ anyway (and we've already complained about the
member-designator already). */
- if (!in_system_header && !constructor_designated
+ if (!in_system_header_at (input_location) && !constructor_designated
&& !(value.value && (integer_zerop (value.value)
|| real_zerop (value.value))))
warning (OPT_Wtraditional, "traditional C rejects initialization "
{
tree type = TYPE_MAIN_VARIANT (orig_type);
- if (!in_system_header
+ if (!in_system_header_at (input_location)
&& (type == long_integer_type_node
|| type == long_unsigned_type_node))
warning_at (switch_cond_loc,
FILE *file = asm_out_file;
int i;
- fprintf (file, ".file \"%s\";\n", input_filename);
+ fprintf (file, ".file \"%s\";\n", LOCATION_FILE (input_location));
for (i = 0; arg_regs[i] >= 0; i++)
;
+2013-11-22 David Malcolm <dmalcolm@redhat.com>
+
+ * call.c (build_integral_nontype_arg_conv): Remove use of
+ EXPR_LOC_OR_HERE macro.
+ (convert_like_real): Likewise.
+ (convert_arg_to_ellipsis): Likewise.
+ (build_cxx_call): Likewise.
+ (perform_implicit_conversion_flags): Likewise.
+ (initialize_reference): Likewise.
+ * cvt.c (cp_convert_to_pointer): Likewise.
+ (convert_to_reference): Likewise.
+ (ocp_convert): Likewise.
+ (convert_to_void): Likewise.
+ * decl.c (pop_label): Update comment.
+ (pop_switch): Remove use of EXPR_LOC_OR_HERE macro.
+ (check_tag_decl): Remove use of in_system_header macro.
+ (make_rtl_for_nonlocal_decl): Remove use of input_filename
+ macro.
+ (compute_array_index_type): Remove use of in_system_header
+ macro.
+ (grokdeclarator): Likewise.
+ * error.c (dump_global_iord): Remove use of input_filename
+ macro.
+ (location_of): Remove use of EXPR_LOC_OR_HERE macro.
+ (maybe_warn_cpp0x): Remove use of in_system_header macro.
+ * init.c (build_new_1): Remove use of EXPR_LOC_OR_HERE macro.
+ * lex.c (handle_pragma_interface): Remove use of input_filename
+ macro.
+ (handle_pragma_implementation): Likewise.
+ (cxx_make_type): Likewise.
+ (in_main_input_context): Likewise.
+ * name-lookup.c (push_binding_level): Remove use of
+ input_line macro.
+ (leave_scope): Likewise.
+ (resume_scope): Likewise.
+ * parser.c (cp_parser_unqualified_id): Remove use of
+ in_system_header macro.
+ (cp_parser_cast_expression): Likewise.
+ (cp_parser_declaration_seq_opt): Likewise.
+ (cp_parser_enumerator_list): Likewise.
+ (cp_parser_parameter_declaration_clause): Likewise.
+ (cp_parser_exception_specification_opt): Likewise.
+ * pt.c (unify_arg_conversion): Remove use of EXPR_LOC_OR_HERE
+ macro.
+ (convert_nontype_argument): Likewise.
+ (push_tinst_level): Remove use of in_system_header macro.
+ (tsubst_copy_and_build): Remove use of EXPR_LOC_OR_HERE
+ macros.
+ (do_decl_instantiation): Remove use of in_system_header macro.
+ (do_type_instantiation): Likewise.
+ * semantics.c (finish_call_expr): Remove use of EXPR_LOC_OR_HERE
+ macro.
+ (begin_class_definition): Remove use of input_filename macro.
+ (cxx_eval_call_expression): Remove use of EXPR_LOC_OR_HERE
+ macro.
+ (cxx_eval_constant_expression): Likewise.
+ (potential_constant_expression_1): Likewise.
+ * typeck.c (decay_conversion): Likewise.
+ (rationalize_conditional_expr): Likewise.
+ (build_x_compound_expr_from_list): Likewise.
+ (convert_for_assignment): Likewise.
+ * typeck2.c (check_narrowing): Likewise.
+
2013-11-22 Trevor Saunders <tsaunders@mozilla.com>
* parser.c, semantics.c: Change some local variables from vec to
conversion *conv;
void *p;
tree t;
- location_t loc = EXPR_LOC_OR_HERE (expr);
+ location_t loc = EXPR_LOC_OR_LOC (expr, input_location);
if (error_operand_p (expr))
return error_mark_node;
tree totype = convs->type;
diagnostic_t diag_kind;
int flags;
- location_t loc = EXPR_LOC_OR_HERE (expr);
+ location_t loc = EXPR_LOC_OR_LOC (expr, input_location);
if (convs->bad_p && !(complain & tf_error))
return error_mark_node;
convert_arg_to_ellipsis (tree arg, tsubst_flags_t complain)
{
tree arg_type;
- location_t loc = EXPR_LOC_OR_HERE (arg);
+ location_t loc = EXPR_LOC_OR_LOC (arg, input_location);
/* [expr.call]
int optimize_sav;
/* Remember roughly where this call is. */
- location_t loc = EXPR_LOC_OR_HERE (fn);
+ location_t loc = EXPR_LOC_OR_LOC (fn, input_location);
fn = build_call_a (fn, nargs, argarray);
SET_EXPR_LOCATION (fn, loc);
{
conversion *conv;
void *p;
- location_t loc = EXPR_LOC_OR_HERE (expr);
+ location_t loc = EXPR_LOC_OR_LOC (expr, input_location);
if (error_operand_p (expr))
return error_mark_node;
{
conversion *conv;
void *p;
- location_t loc = EXPR_LOC_OR_HERE (expr);
+ location_t loc = EXPR_LOC_OR_LOC (expr, input_location);
if (type == error_mark_node || error_operand_p (expr))
return error_mark_node;
tree intype = TREE_TYPE (expr);
enum tree_code form;
tree rval;
- location_t loc = EXPR_LOC_OR_HERE (expr);
+ location_t loc = EXPR_LOC_OR_LOC (expr, input_location);
if (intype == error_mark_node)
return error_mark_node;
tree rval = NULL_TREE;
tree rval_as_conversion = NULL_TREE;
bool can_convert_intype_to_type;
- location_t loc = EXPR_LOC_OR_HERE (expr);
+ location_t loc = EXPR_LOC_OR_LOC (expr, input_location);
if (TREE_CODE (type) == FUNCTION_TYPE
&& TREE_TYPE (expr) == unknown_type_node)
enum tree_code code = TREE_CODE (type);
const char *invalid_conv_diag;
tree e1;
- location_t loc = EXPR_LOC_OR_HERE (expr);
+ location_t loc = EXPR_LOC_OR_LOC (expr, input_location);
if (error_operand_p (e) || type == error_mark_node)
return error_mark_node;
tree
convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain)
{
- location_t loc = EXPR_LOC_OR_HERE (expr);
+ location_t loc = EXPR_LOC_OR_LOC (expr, input_location);
if (expr == error_mark_node
|| TREE_TYPE (expr) == error_mark_node)
location_t location;
error ("label %q+D used but not defined", label);
- location = input_location; /* FIXME want (input_filename, (line)0) */
+ location = input_location;
+ /* FIXME want (LOCATION_FILE (input_location), (line)0) */
/* Avoid crashing later. */
define_label (location, DECL_NAME (label));
}
location_t switch_location;
/* Emit warnings as needed. */
- switch_location = EXPR_LOC_OR_HERE (cs->switch_stmt);
+ switch_location = EXPR_LOC_OR_LOC (cs->switch_stmt, input_location);
if (!processing_template_decl)
c_do_switch_warnings (cs->cases, switch_location,
SWITCH_STMT_TYPE (cs->switch_stmt),
error ("multiple types in one declaration");
else if (declspecs->redefined_builtin_type)
{
- if (!in_system_header)
+ if (!in_system_header_at (input_location))
permerror (declspecs->locations[ds_redefined_builtin_type_spec],
"redeclaration of C++ built-in type %qT",
declspecs->redefined_builtin_type);
/* Anonymous unions are objects, so they can have specifiers. */;
SET_ANON_AGGR_TYPE_P (declared_type);
- if (TREE_CODE (declared_type) != UNION_TYPE && !in_system_header)
+ if (TREE_CODE (declared_type) != UNION_TYPE
+ && !in_system_header_at (input_location))
pedwarn (input_location, OPT_Wpedantic, "ISO C++ prohibits anonymous structs");
}
/* We try to defer namespace-scope static constants so that they are
not emitted into the object file unnecessarily. */
- filename = input_filename;
+ filename = LOCATION_FILE (input_location);
if (!DECL_VIRTUAL_P (decl)
&& TREE_READONLY (decl)
&& DECL_INITIAL (decl) != NULL_TREE
indicated by the state of complain), so that
another substitution can be found. */
return error_mark_node;
- else if (in_system_header)
+ else if (in_system_header_at (input_location))
/* Allow them in system headers because glibc uses them. */;
else if (name)
pedwarn (input_location, OPT_Wpedantic, "ISO C++ forbids zero-size array %qD", name);
if (type_was_error_mark_node)
/* We've already issued an error, don't complain more. */;
- else if (in_system_header || flag_ms_extensions)
+ else if (in_system_header_at (input_location) || flag_ms_extensions)
/* Allow it, sigh. */;
else if (! is_main)
permerror (input_location, "ISO C++ forbids declaration of %qs with no type", name);
error ("%<__int128%> is not supported by this target");
explicit_int128 = false;
}
- else if (pedantic && ! in_system_header)
+ else if (pedantic && ! in_system_header_at (input_location))
pedwarn (input_location, OPT_Wpedantic,
"ISO C++ does not support %<__int128%> for %qs", name);
}
else
gcc_unreachable ();
- pp_printf (pp, p, input_filename);
+ pp_printf (pp, p, LOCATION_FILE (input_location));
}
static void
if (DECL_P (t))
return DECL_SOURCE_LOCATION (t);
- return EXPR_LOC_OR_HERE (t);
+ return EXPR_LOC_OR_LOC (t, input_location);
}
/* Now the interfaces from error et al to dump_type et al. Each takes an
void
maybe_warn_cpp0x (cpp0x_warn_str str)
{
- if ((cxx_dialect == cxx98) && !in_system_header)
+ if ((cxx_dialect == cxx98) && !in_system_header_at (input_location))
/* We really want to suppress this warning in system headers,
because libstdc++ uses variadic templates even when we aren't
in C++0x mode. */
{
if (complain & tf_error)
{
- error_at (EXPR_LOC_OR_HERE (inner_nelts),
+ error_at (EXPR_LOC_OR_LOC (inner_nelts, input_location),
"array size in operator new must be constant");
cxx_constant_value(inner_nelts);
}
&& !TREE_CONSTANT (maybe_constant_value (outer_nelts)))
{
if (complain & tf_warning_or_error)
- pedwarn(EXPR_LOC_OR_HERE (outer_nelts), OPT_Wvla,
+ pedwarn(EXPR_LOC_OR_LOC (outer_nelts, input_location), OPT_Wvla,
"ISO C++ does not support variable-length array types");
else
return error_mark_node;
if (fname == error_mark_node)
return;
else if (fname == 0)
- filename = lbasename (input_filename);
+ filename = lbasename (LOCATION_FILE (input_location));
else
filename = TREE_STRING_POINTER (fname);
- finfo = get_fileinfo (input_filename);
+ finfo = get_fileinfo (LOCATION_FILE (input_location));
if (impl_file_chain == 0)
{
/* If this is zero at this point, then we are
auto-implementing. */
if (main_input_filename == 0)
- main_input_filename = input_filename;
+ main_input_filename = LOCATION_FILE (input_location);
}
finfo->interface_only = interface_strcmp (filename);
if (main_input_filename)
filename = main_input_filename;
else
- filename = input_filename;
+ filename = LOCATION_FILE (input_location);
filename = lbasename (filename);
}
else
/* Set up some flags that give proper default behavior. */
if (RECORD_OR_UNION_CODE_P (code))
{
- struct c_fileinfo *finfo = get_fileinfo (input_filename);
+ struct c_fileinfo *finfo = \
+ get_fileinfo (LOCATION_FILE (input_location));
SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, finfo->interface_unknown);
CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
}
return filename_cmp (main_input_filename,
LOCATION_FILE (tl->locus)) == 0;
else
- return filename_cmp (main_input_filename, input_filename) == 0;
+ return filename_cmp (main_input_filename, LOCATION_FILE (input_location)) == 0;
}
{
scope->binding_depth = binding_depth;
indent (binding_depth);
- cp_binding_level_debug (scope, input_line, "push");
+ cp_binding_level_debug (scope, LOCATION_LINE (input_location),
+ "push");
binding_depth++;
}
}
if (ENABLE_SCOPE_CHECKING)
{
indent (--binding_depth);
- cp_binding_level_debug (scope, input_line, "leave");
+ cp_binding_level_debug (scope, LOCATION_LINE (input_location),
+ "leave");
}
/* Move one nesting level up. */
{
b->binding_depth = binding_depth;
indent (binding_depth);
- cp_binding_level_debug (b, input_line, "resume");
+ cp_binding_level_debug (b, LOCATION_LINE (input_location), "resume");
binding_depth++;
}
}
{
/* 17.6.3.3.5 */
const char *name = UDLIT_OP_SUFFIX (id);
- if (name[0] != '_' && !in_system_header && declarator_p)
+ if (name[0] != '_' && !in_system_header_at (input_location)
+ && declarator_p)
warning (0, "literal operator suffixes not preceded by %<_%>"
" are reserved for future standardization");
}
/* Warn about old-style casts, if so requested. */
if (warn_old_style_cast
- && !in_system_header
+ && !in_system_header_at (input_location)
&& !VOID_TYPE_P (type)
&& current_lang_name != lang_name_c)
warning (OPT_Wold_style_cast, "use of old-style cast");
/* A declaration consisting of a single semicolon is
invalid. Allow it unless we're being pedantic. */
cp_lexer_consume_token (parser->lexer);
- if (!in_system_header)
+ if (!in_system_header_at (input_location))
pedwarn (input_location, OPT_Wpedantic, "extra %<;%>");
continue;
}
/* If the next token is a `}', there is a trailing comma. */
if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
{
- if (cxx_dialect < cxx11 && !in_system_header)
+ if (cxx_dialect < cxx11 && !in_system_header_at (input_location))
pedwarn (input_location, OPT_Wpedantic,
"comma at end of enumerator list");
break;
/* There are no parameters. */
{
#ifndef NO_IMPLICIT_EXTERN_C
- if (in_system_header && current_class_type == NULL
+ if (in_system_header_at (input_location)
+ && current_class_type == NULL
&& current_lang_name == lang_name_c)
return NULL_TREE;
else
#if 0
/* Enable this once a lot of code has transitioned to noexcept? */
- if (cxx_dialect >= cxx11 && !in_system_header)
+ if (cxx_dialect >= cxx11 && !in_system_header_at (input_location))
warning (OPT_Wdeprecated, "dynamic exception specifications are "
"deprecated in C++0x; use %<noexcept%> instead");
#endif
tree from_type, tree arg)
{
if (explain_p)
- inform (EXPR_LOC_OR_HERE (arg),
+ inform (EXPR_LOC_OR_LOC (arg, input_location),
" cannot convert %qE (type %qT) to type %qT",
arg, from_type, to_type);
return 1;
return NULL_TREE;
expr = cxx_constant_value (expr);
if (errorcount > errs || warningcount + werrorcount > warns)
- inform (EXPR_LOC_OR_HERE (expr),
+ inform (EXPR_LOC_OR_LOC (expr, input_location),
"in template argument for type %qT ", type);
if (expr == error_mark_node)
return NULL_TREE;
new_level->decl = d;
new_level->locus = input_location;
new_level->errors = errorcount+sorrycount;
- new_level->in_system_header_p = in_system_header;
+ new_level->in_system_header_p = in_system_header_at (input_location);
new_level->next = current_tinst_level;
current_tinst_level = new_level;
fn = TREE_OPERAND (fn, 1);
if (is_overloaded_fn (fn))
fn = get_first_fn (fn);
- if (permerror (EXPR_LOC_OR_HERE (t),
+ if (permerror (EXPR_LOC_OR_LOC (t, input_location),
"%qD was not declared in this scope, "
"and no declarations were found by "
"argument-dependent lookup at the point "
/* Can't say anything more. */;
else if (DECL_CLASS_SCOPE_P (fn))
{
- inform (EXPR_LOC_OR_HERE (t),
+ location_t loc = EXPR_LOC_OR_LOC (t,
+ input_location);
+ inform (loc,
"declarations in dependent base %qT are "
"not found by unqualified lookup",
DECL_CLASS_CONTEXT (fn));
if (current_class_ptr)
- inform (EXPR_LOC_OR_HERE (t),
+ inform (loc,
"use %<this->%D%> instead", function);
else
- inform (EXPR_LOC_OR_HERE (t),
+ inform (loc,
"use %<%T::%D%> instead",
current_class_name, function);
}
;
else if (storage == ridpointers[(int) RID_EXTERN])
{
- if (!in_system_header && (cxx_dialect == cxx98))
+ if (!in_system_header_at (input_location) && (cxx_dialect == cxx98))
pedwarn (input_location, OPT_Wpedantic,
"ISO C++ 1998 forbids the use of %<extern%> on explicit "
"instantiations");
if (storage != NULL_TREE)
{
- if (!in_system_header)
+ if (!in_system_header_at (input_location))
{
if (storage == ridpointers[(int) RID_EXTERN])
{
&& type_dependent_expression_p (current_class_ref)))
{
result = build_nt_call_vec (fn, *args);
- SET_EXPR_LOCATION (result, EXPR_LOC_OR_HERE (fn));
+ SET_EXPR_LOCATION (result, EXPR_LOC_OR_LOC (fn, input_location));
KOENIG_LOOKUP_P (result) = koenig_p;
if (cfun)
{
before. */
if (! TYPE_ANONYMOUS_P (t))
{
- struct c_fileinfo *finfo = get_fileinfo (input_filename);
+ struct c_fileinfo *finfo = \
+ get_fileinfo (LOCATION_FILE (input_location));
CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
SET_CLASSTYPE_INTERFACE_UNKNOWN_X
(t, finfo->interface_unknown);
bool allow_non_constant, bool addr,
bool *non_constant_p, bool *overflow_p)
{
- location_t loc = EXPR_LOC_OR_HERE (t);
+ location_t loc = EXPR_LOC_OR_LOC (t, input_location);
tree fun = get_function_named_in_call (t);
tree result;
constexpr_call new_call = { NULL, NULL, NULL, 0 };
&& !integer_zerop (op))
{
if (!allow_non_constant)
- error_at (EXPR_LOC_OR_HERE (t),
+ error_at (EXPR_LOC_OR_LOC (t, input_location),
"reinterpret_cast from integer to pointer");
*non_constant_p = true;
return t;
case EXPR_STMT:
case OFFSET_REF:
if (!allow_non_constant)
- error_at (EXPR_LOC_OR_HERE (t),
+ error_at (EXPR_LOC_OR_LOC (t, input_location),
"expression %qE is not a constant-expression", t);
*non_constant_p = true;
break;
{
if (flags & tf_error)
{
- error_at (EXPR_LOC_OR_HERE (t),
+ error_at (EXPR_LOC_OR_LOC (t, input_location),
"call to non-constexpr function %qD", fun);
explain_invalid_constexpr_fn (fun);
}
&& !integer_zerop (from))
{
if (flags & tf_error)
- error_at (EXPR_LOC_OR_HERE (t),
+ error_at (EXPR_LOC_OR_LOC (t, input_location),
"reinterpret_cast from integer to pointer");
return false;
}
{
tree type;
enum tree_code code;
- location_t loc = EXPR_LOC_OR_HERE (exp);
+ location_t loc = EXPR_LOC_OR_LOC (exp, input_location);
type = TREE_TYPE (exp);
if (type == error_mark_node)
rationalize_conditional_expr (enum tree_code code, tree t,
tsubst_flags_t complain)
{
+ location_t loc = EXPR_LOC_OR_LOC (t, input_location);
+
/* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that
the first operand is always the one to be used if both operands
are equal, so we know what conditional expression this used to be. */
gcc_assert (!TREE_SIDE_EFFECTS (op0)
&& !TREE_SIDE_EFFECTS (op1));
return
- build_conditional_expr (EXPR_LOC_OR_HERE (t),
- build_x_binary_op (EXPR_LOC_OR_HERE (t),
+ build_conditional_expr (loc,
+ build_x_binary_op (loc,
(TREE_CODE (t) == MIN_EXPR
? LE_EXPR : GE_EXPR),
op0, TREE_CODE (op0),
}
return
- build_conditional_expr (EXPR_LOC_OR_HERE (t), TREE_OPERAND (t, 0),
+ build_conditional_expr (loc, TREE_OPERAND (t, 0),
cp_build_unary_op (code, TREE_OPERAND (t, 1), 0,
complain),
cp_build_unary_op (code, TREE_OPERAND (t, 2), 0,
&& !CONSTRUCTOR_IS_DIRECT_INIT (expr))
{
if (complain & tf_error)
- pedwarn (EXPR_LOC_OR_HERE (expr), 0, "list-initializer for "
- "non-class type must not be parenthesized");
+ pedwarn (EXPR_LOC_OR_LOC (expr, input_location), 0,
+ "list-initializer for non-class type must not "
+ "be parenthesized");
else
return error_mark_node;
}
&& TREE_CODE (TREE_TYPE (rhs)) != BOOLEAN_TYPE
&& (complain & tf_warning))
{
- location_t loc = EXPR_LOC_OR_HERE (rhs);
+ location_t loc = EXPR_LOC_OR_LOC (rhs, input_location);
warning_at (loc, OPT_Wparentheses,
"suggest parentheses around assignment used as truth value");
if (!ok)
{
if (cxx_dialect >= cxx11)
- pedwarn (EXPR_LOC_OR_HERE (init), OPT_Wnarrowing,
+ pedwarn (EXPR_LOC_OR_LOC (init, input_location), OPT_Wnarrowing,
"narrowing conversion of %qE from %qT to %qT inside { }",
init, ftype, type);
else
- warning_at (EXPR_LOC_OR_HERE (init), OPT_Wnarrowing,
+ warning_at (EXPR_LOC_OR_LOC (init, input_location), OPT_Wnarrowing,
"narrowing conversion of %qE from %qT to %qT inside { } "
"is ill-formed in C++11", init, ftype, type);
}
+2013-11-22 David Malcolm <dmalcolm@redhat.com>
+
+ * trans.c (trans_runtime_error_vararg): Remove use of input_line
+ macro.
+
2013-11-17 Andrew MacLeod <amacleod@redhat.com>
* fortran/trans-intrinsic.c: Include tree-nested.h.
}
else
asprintf (&message, "In file '%s', around line %d",
- gfc_source_file, input_line + 1);
+ gfc_source_file, LOCATION_LINE (input_location) + 1);
arg = gfc_build_addr_expr (pchar_type_node,
gfc_build_localized_cstring_const (message));
mod = build2 (INIT_EXPR, TREE_TYPE (t), t, unshare_expr (val));
- SET_EXPR_LOCATION (mod, EXPR_LOC_OR_HERE (val));
+ SET_EXPR_LOCATION (mod, EXPR_LOC_OR_LOC (val, input_location));
/* gimplify_modify_expr might want to reduce this further. */
gimplify_and_add (mod, pre_p);
while (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
{
/* Keep the original source location on the first 'if'. */
- location_t locus = EXPR_LOC_OR_HERE (expr);
+ location_t locus = EXPR_LOC_OR_LOC (expr, input_location);
TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
/* Set the source location of the && on the second 'if'. */
if (EXPR_HAS_LOCATION (pred))
while (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
{
/* Keep the original source location on the first 'if'. */
- location_t locus = EXPR_LOC_OR_HERE (expr);
+ location_t locus = EXPR_LOC_OR_LOC (expr, input_location);
TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
/* Set the source location of the || on the second 'if'. */
if (EXPR_HAS_LOCATION (pred))
/* If there was nothing else in our arms, just forward the label(s). */
if (!then_se && !else_se)
return shortcut_cond_r (pred, true_label_p, false_label_p,
- EXPR_LOC_OR_HERE (expr));
+ EXPR_LOC_OR_LOC (expr, input_location));
/* If our last subexpression already has a terminal label, reuse it. */
if (else_se)
jump_over_else = block_may_fallthru (then_);
pred = shortcut_cond_r (pred, true_label_p, false_label_p,
- EXPR_LOC_OR_HERE (expr));
+ EXPR_LOC_OR_LOC (expr, input_location));
expr = NULL;
append_to_statement_list (pred, &expr);
((tree) ((IS_ADHOC_LOC (LOC)) ? get_data_from_adhoc_loc (line_table, (LOC)) \
: NULL))
-#define input_line LOCATION_LINE (input_location)
-#define input_filename LOCATION_FILE (input_location)
#define in_system_header_at(LOC) \
((linemap_location_in_system_header_p (line_table, LOC)))
-#define in_system_header (in_system_header_at (input_location))
void dump_line_table_statistics (void);
+2013-11-22 David Malcolm <dmalcolm@redhat.com>
+
+ * class.c (maybe_layout_super_class): Update comment.
+ * decl.c (java_add_stmt): Remove use of input_filename macro.
+ * jcf-parse.c (set_source_filename): Remove use of
+ input_filename macro.
+ (parse_class_file): Remove use of input_line and input_filename
+ macros.
+ (java_parse_file): Remove use of input_filename macro.
+
2013-11-18 Richard Sandiford <rdsandiford@googlemail.com>
* class.c, expr.c: Replace tree_low_cst (..., 0) with tree_to_shwi
}
/* safe_layout_class just makes sure that we can load a class without
- disrupting the current_class, input_file, input_line, etc, information
+ disrupting the current_class, input_location, etc, information
about the class processed currently. */
void
tree stmts = current_binding_level->stmts;
tree_stmt_iterator i;
- if (input_filename)
+ if (LOCATION_FILE (input_location))
walk_tree (&new_stmt, set_input_location, NULL, NULL);
if (stmts == NULL)
{
tree sfname_id = get_name_constant (jcf, index);
const char *sfname = IDENTIFIER_POINTER (sfname_id);
- const char *old_filename = input_filename;
+ const char *old_filename = LOCATION_FILE (input_location);
int new_len = IDENTIFIER_LENGTH (sfname_id);
if (old_filename != NULL)
{
int old_len = strlen (old_filename);
- /* Use the current input_filename (derived from the class name)
- if it has a directory prefix, but otherwise matches sfname. */
+ /* Use the filename from current input_location (derived from the
+ class name) if it has a directory prefix, but otherwise matches
+ sfname. */
if (old_len > new_len
&& filename_cmp (sfname, old_filename + old_len - new_len) == 0
&& (old_filename[old_len - new_len - 1] == '/'
linemap_add (line_table, LC_ENTER, 0, loc.file, loc.line);
}
file_start_location = input_location;
- (*debug_hooks->start_source_file) (input_line, input_filename);
+ (*debug_hooks->start_source_file) (LOCATION_LINE (input_location),
+ LOCATION_FILE (input_location));
java_mark_class_local (current_class);
for (ptr += 2; --i >= 0; ptr += 4)
{
int line = GET_u2 (ptr);
- /* Set initial input_line to smallest linenumber.
+ /* Set initial line of input_location to smallest
+ * linenumber.
* Needs to be set before init_function_start. */
if (min_line == 0 || line < min_line)
min_line = line;
int avail = 2000;
finput = fopen (main_input_filename, "r");
if (finput == NULL)
- fatal_error ("can%'t open %s: %m", input_filename);
+ fatal_error ("can%'t open %s: %m", LOCATION_FILE (input_location));
list = XNEWVEC (char, avail);
next = list;
for (;;)
if (count == 0)
{
if (! feof (finput))
- fatal_error ("error closing %s: %m", input_filename);
+ fatal_error ("error closing %s: %m",
+ LOCATION_FILE (input_location));
*next = '\0';
break;
}
diagnostic_info *diagnostic)
{
diagnostic_report_current_module (context, diagnostic->location);
- lang_hooks.print_error_function (context, input_filename, diagnostic);
+ lang_hooks.print_error_function (context, LOCATION_FILE (input_location),
+ diagnostic);
}
static void
{
const char *file = main_input_filename;
if (! file)
- file = input_filename;
+ file = LOCATION_FILE (input_location);
/* Just use the file's basename, because the full pathname
might be quite long. */
p = q = ASTRDUP (lbasename (file));
if (! name)
name = "";
if (! file)
- file = input_filename;
+ file = LOCATION_FILE (input_location);
len = strlen (file);
q = (char *) alloca (9 + 17 + len + 1);
!= UNKNOWN_LOCATION)
/* The location to be used in a diagnostic about this expression. Do not
use this macro if the location will be assigned to other expressions. */
-#define EXPR_LOC_OR_HERE(NODE) (EXPR_HAS_LOCATION (NODE) \
- ? (NODE)->exp.locus : input_location)
#define EXPR_LOC_OR_LOC(NODE, LOCUS) (EXPR_HAS_LOCATION (NODE) \
? (NODE)->exp.locus : (LOCUS))
#define EXPR_FILENAME(NODE) LOCATION_FILE (EXPR_CHECK ((NODE))->exp.locus)
projects / thirdparty / gcc.git / commitdiff
