OSDN Git Service

gcc/java/
authoraldyh <aldyh@138bc75d-0d04-0410-961f-82ee72b054a4>
Fri, 12 Jun 2009 22:06:47 +0000 (22:06 +0000)
committeraldyh <aldyh@138bc75d-0d04-0410-961f-82ee72b054a4>
Fri, 12 Jun 2009 22:06:47 +0000 (22:06 +0000)
* java-gimplify.c (java_gimplify_block): New argument to
build_empty_stmt.
* expr.c (force_evaluation_order): Same.
* typeck.c: Add location to build_decl or PUSH_FIELD calls.
* class.c: Same.
* decl.c: Same.
* jcf-parse.c: Same.
* constants.c: Same.
* resource.c: Same.
* except.c: Same.
* builtins.c: Same.
* expr.c: Same.
* java-tree.h (PUSH_FIELD): Add location field.
gcc/objc/
* objc-act.c (finish_var_decl): Pass location to finish_decl.
(objc_get_parm_info): Same.
(get_super_receiver): Same.
* objc-act.c (objc_build_component_ref): Pass location to
build_compound_ref.
(build_module_initializer_routine): Pass location to
c_end_compound_stmt.
(objc_generate_static_init_call): Pass location to build_stmt.
(build_typed_selector_reference): New location argument.
(build_selector_reference): Same.
(objc_substitute_decl): Pass location to build_array_ref.
(next_sjlj_build_try_catch_finally): Pass location to build_stmt.
(objc_begin_catch_clause): Same.
(objc_finish_try_stmt): Same.
(objc_finish_catch_clause): Pass location to c_end_compound_stmt.
(objc_build_throw_stmt): New argument.
(generate_shared_structures): Pass location to build_c_cast.
(objc_build_message_expr): Use local location.
(objc_finish_message_expr): Use input_location.
(build_objc_method_call): New argument.
(objc_build_selector_expr): Same.
(get_super_receiver): Pass location to build_c_cast,
build_modify_expr, build_compound_expr.
* objc-act.c: Add location to all calls to start_struct, build_decl,
finish_struct.
gcc/
* tree-pretty-print.c (dump_generic_node): Dump column numbers.
* gimple-pretty-print.c (dump_gimple_stmt): Same.
* gimplify.c (gimplify_modify_expr): Set location for GIMPLE_ASSIGNs
created.
* c-parser.c (c_parser_binary_expression): Use current column while
building binary operations.
* common.opt (fshow-column): Enable by default.
* tree-vrp.c (check_array_ref): Use warning_at.
(check_array_bounds): Use location from call back if expr has no
location.
* tree.h: Add location argument to maybe_fold_*.
* tree-ssa-ccp.c (ccp_fold): Pass location to maybe_fold_*.
(maybe_fold_offset_to_array_ref): Add location argument and use it.
(maybe_fold_offset_to_component_ref): Same.
(maybe_fold_offset_to_reference): Same.
(maybe_fold_offset_to_address): Same.
(maybe_fold_stmt_indirect): Same.
(maybe_fold_stmt_addition): Same.
(fold_stmt_r): Pass location to maybe_fold_*.
(fold_gimple_assign): Same.
* c-tree.h: Add location argument to finish_decl,
default_function_array_conversion, store_init_value.
* c-decl.c (define_label): Use error_at.
(c_make_fname_decl): Pass location to finish_decl.
(finish_decl): New location argument.
(build_compound_literal): Pass location to store_init_value.
(grokdeclarator): Pass location to finish_decl.
(grokfield): Same.
* c-typeck.c (array_to_pointer_conversion): New location argument.
(function_to_pointer_conversion): Same.
(default_function_array_conversion): Same.
(parser_build_unary_op): Pass location to overflow_warning.
(parser_build_binary_op): Same.  Use warning_at.
(build_unary_op): Pass location to array_to_pointer_conversion.
(build_c_cast): Pass location to digest_init.
(build_modify_expr): New location argument.
(convert_for_assignment): Same.
(store_init_value): Same.
(digest_init): Same.
(output_init_element): Pass location to digest_init and
array_to_pointer_conversion.
(c_finish_return): Pass location to convert_for_assignment.
* gimplify.c (gimplify_conversion): Pass location to
maybe_fold_offset_to_address.
* tree-ssa-forwprop.c (forward_propagate_addr_expr_1): Pass location
to maybe_fold_stmt_addition.
* c-omp.c (c_finish_omp_atomic): Pass new location to
build_modify_expr.
(c_finish_omp_for): Same.
* c-common.c (overflow_warning): New argument.
* c-common.h: New argument to build_modify_expr, overflow_warning.
* c-parser.c (c_parser_declaration_or_fndef): Pass location to
finish_decl.
(c_parser_initializer): Pass location to
default_function_array_conversion.
(c_parser_initelt): Same.
(c_parser_initval): Same.
(c_parser_asm_operands): Same.
(c_parser_expr_no_commas): Same.  Pass location to build_modify_expr.
(c_parser_conditional_expression): Same.
(c_parser_binary_expression): Add location info to stack.  Use it.
(c_parser_unary_expression): Pass location to
default_function_array_conversion, parser_build_unary_op,
build_indirect_ref, c_parser_postfix_expression_after_primary.
(c_parser_postfix_expression_after_primary): New location argument.
Use it.
(c_parser_expression_conv): Pass location to
default_function_array_conversion.
(c_parser_expr_list): Same.
(c_parser_omp_atomic): Same.
(c_parser_omp_for_loop): Same.
* c-tree.h: (struct c_declarator): Add comment to id_loc.
(build_array_declarator): New argument.
* c-decl.c (build_array_declarator): Add location argument.
(grokdeclarator): Set id_loc for cdk_array.
* c-parser.c (c_parser_direct_declarator_inner): Pass location to
build_array_declarator.
* tree.c (build_omp_clause): Add location argument.
* tree.h (OMP_CLAUSE_HAS_LOCATION): New macro.
(OMP_CLAUSE_LOCATION): New macro.
(struct tree_omp_clause): Add location field.
(build_omp_clause): Add argument.
* testsuite/gcc.dg/gomp/for-1.c: Fix column.
* cp/pt.c (tsubst_omp_for_iterator): Pass location to
build_omp_clause.
* cp/parser.c (cp_parser_omp_var_list_no_open): Same.
(cp_parser_omp_clause_collapse): Same.
(cp_parser_omp_clause_default): Same.
(cp_parser_omp_clause_if): Same.
(cp_parser_omp_clause_nowait): Same.
(cp_parser_omp_clause_num_threads): Same.
(cp_parser_omp_clause_ordered): Same.
(cp_parser_omp_clause_schedule): Same.
(cp_parser_omp_clause_untied): Same.
(cp_parser_omp_for_loop): Same.
(cp_parser_omp_parallel): Pass location to c_split_parallel_clauses.
* c-tree.h (c_start_case): Add location argument.
(c_process_expr_stmt): Same.
(c_finish_goto_*): Same.
* tree-parloops.c (initialize_reductions): Pass location to
build_omp_clause.
(create_parallel_loop): Same.
* fortran/trans-openmp.c (gfc_trans_omp_variable_list): Same.
(gfc_trans_omp_reduction_list): Same.
(gfc_trans_omp_clauses): Same.
(gfc_trans_omp_do): Same.
* c-typeck.c (c_finish_goto_label): Same.
(c_finish_goto_ptr): New location argument.
(c_start_case): Same.
(emit_side_effect_warnings): Same.
(c_process_expr_stmt): Same.
(c_finish_stmt_expr): Same.
(c_finish_omp_clauses): Use error_at instead of error.
* gimplify.c (gimplify_adjust_omp_clauses_1): Pass location to
build_omp_clause.
* c-omp.c (c_split_parallel_clauses): New location argument.
* tree-nested.c (convert_nonlocal_reference_stmt): Pass location
to build_omp_clause.
(convert_local_reference_stmt): Same.
(convert_gimple_call): Same.
* c-common.h (c_split_parallel_clauses): New argument.
* c-parser.c (c_parser_statement_after_labels): Pass location to
c_finish_goto_label.
(c_parser_switch_statement): Pass location to c_start_case.
(c_parser_for_statement): Pass location to c_finish_expr_stmt,
and c_process_expr_stmt.
(c_parser_omp_variable_list): Add location argument.
(c_parser_omp_clause_collapse): Pass location to
build_omp_clause.
(c_parser_omp_clause_default): Same.
(c_parser_omp_clause_if): Same.
(c_parser_omp_clause_num_threads): Same.
(-c_parser_omp_clause_ordered): Same.
(c_parser_omp_clause_reduction): Pass location to
c_parser_omp_variable_list.
(c_parser_omp_clause_schedule): Pass location to build_omp_clause.
(c_parser_omp_clause_untied): Same.
(c_parser_omp_for_loop): Pass location to c_process_expr_stmt.
(c_parser_omp_parallel): Pass location to
c_split_parallel_clauses.
* c-tree.h (check_for_loop_decls, undeclared_variable,
build_component_ref, build_array_ref, build_external_ref,
c_expr_sizeof_expr, c_expr_sizeof_type, parser_build_unary_op,
build_conditional_expr, build_compound_expr, c_cast_expr,
build_c_cast, build_asm_expr, c_end_compound_stmt, c_finish_stmt_expr,
c_finish_return, c_finish_omp_parallel, c_finish_omp_task): New
argument.
* c-semantics.c (build_stmt): Same.
(build_case_label): Same.
* c-decl.c (c_finish_incomplete_decl): Pass location on down.
(undeclared_variable): New argument.
(make_label): Same.
(lookup_label): Pass location on down.
(define_label): Same.
(finish_decl): Same.
(build_compound_literal): Same.
(finish_struct): Same.
(finish_function): Do not set location here.
(check_for_loop_decls): New argument.
* tree.c (save_expr): Set location.
(build_empty_stmt): New argument.
* tree.h (build_empty_stmt): New argument to build_empty_stmt.
(CAN_HAVE_LOCATION_P): Make sure we have a non empty node.
* builtins.c (gimplify_va_arg_expr): Use locations.
(expand_builtin_sync_operation): Same.
* c-typeck.c (build_component_ref): New argument.
(build_array_ref): Same.
(build_external_ref): Same.
(c_expr_sizeof_expr): Same.
(c_expr_sizeof_type): Same.
(parser_build_unary_op): Same.
(build_conditional_expr): Same.
(build_compound_expr): Pass location on down.
(build_compound_expr): New argument.
(build_c_cast): Same.
(c_cast_expr): Same.
(build_asm_expr): Same.
(c_finish_return): Same.
(c_process_expr_stmt): Pass location on down.
(c_finish_stmt_expr): New argument.
(push_clenaup): Same.
(c_finish_omp_parallel): Same.
(c_finish_omp_task): Same.
* gimplify.c (gimplify_call_expr): Pass location on down.
* c-omp.c (c_finish_omp_master): New argument.
(c_finish_omp_critical): Same.
(c_finish_omp_ordered): Same.
(c_finish_omp_barrier): Same.
(-c_finish_omp_taskwait): Same.
(c_finish_omp_atomic): Same.
(c_finish_omp_flush): Same.
* tree-inline.c (copy_tree_body_r): Pass location on down.
(inline_forbidden_p): Remove use of input_location.
* c-gimplify.c (c_build_bind_expr): New argument.
* c-common.c (c_common_truthvalue_conversion): Pass location on down.
(c_sizeof_or_alignof_type): New argument.
(c_alignof_expr): Same.
(build_va_arg): Same.
(c_add_case_label): Same.
* c-common.h (c_sizeof_or_alignof_type, c_alignof_expr,
c_sizeof, c_alignof, build_va_arg, build_stmt, build_case_label,
c_build_bind_expr, objc_build_selector_expr, objc_build_throw_stmt,
c_finish_omp_master, c_finish_omp_critical, c_finish_omp_ordered,
c_finish_omp_barrier, c_finish_omp_atomic, c_finish_omp_flush,
c_finish_omp_taskwait, c_finish_omp_for, c_split_parallel_clauses):
New argument.
* stub-objc.c (objc_build_selector_expr): Same.
(objc_build_throw_stmt): Same.
* c-parser.c (c_parser_declaration_or_fndef): Pass location on down.
(c_parser_initelt): Same.
(c_parser_compound_statement): Same.
(c_parser_compound_statement_nostart): Same.
(c_parser_label): Same.
(c_parser_statement_after_labels): Same.
(c_parser_if_body): Same.
(c_parser_else_body): Same.
(c_parser_if_statement): Same.
(c_parser_switch_statement): Same.
(c_parser_while_statement): Same.
(c_parser_do_statement): Same.
(c_parser_for_statement): Same.
(c_parser_asm_statement): Same.
(c_parser_conditional_expression): Same.
(c_parser_binary_expression): Same.
(c_parser_cast_expression): Same.
(c_parser_unary_expression): Same.
(c_parser_sizeof_expression): Same.
(c_parser_alignof_expression): Same.
(c_parser_postfix_expression): Same.
(c_parser_expression): Same.
(c_parser_objc_receiver): Same.
(c_parser_omp_variable_list): Same.
(c_parser_omp_structured_block): Same.
(c_parser_omp_atomic): New argument.
(c_parser_omp_barrier): Same.
(c_parser_omp_critical): Same.
(c_parser_omp_flush): Pass location on down.
(c_parser_omp_for_loop): New argument.
(c_parser_omp_for): Same.
(c_parser_omp_master): Same.
(c_parser_omp_ordered): Same.
(c_parser_omp_sections_scope): Same.
(c_parser_omp_sections): Same.
(c_parser_omp_parallel): Same.
(c_parser_omp_single): Same.
(c_parser_omp_task): Same.
(c_parser_omp_taskwait): Pass location on down.
(c_parser_omp_construct): Same.
(c_parser_omp_threadprivate): Same.
* dwarf2asm.c, targhooks.c, optabs.c, tree.c, tree.h, target.h,
builtins.c, omp-low.c, cgraphunit.c, tree-call-cdce.c,
tree-ssa-alias.c, gimple-low.c, c-tree.h, expr.c, tree-parloops.c,
c-decl.c, tree-eh.c, langhooks.c, function.c, stor-layout.c,
c-typeck.c, gimplify.c, c-pragma.c, expmed.c, except.c, coverage.c,
emit-rtl.c, cfgexpand.c, tree-mudflap.c, varasm.c, tree-nested.c,
rtl.h, tree-inline.c, tree-profile.c, c-common.c, c-common.h,
tree-switch-conversion.c, tree-cfg.c, ipa-struct-reorg.c, c-parser.c,
config/i386/i386.c, stmt.c:
Add location argument to the following function definitions and/or
function calls: build_decl, objcp_start_struct, objcp_finish_struct,
start_struct, finish_struct, PUSH_FIELD, create_artificial_label,
cp_make_fname_decl, pushtag, implicitly_declare, c_make_fname_decl,
build_compound_literal, parser_xref_tag, resolve_overloaded_builtin,
do_case, c_finish_bc_stmt, build_compound_literal,
build_function_call.
* c-decl.c (build_compound_literal): Add location argument.
Make all diagnostic calls use location.
(start_struct): Same.
(finish_struct): Same.
(start_enum): Same.
(build_enumerator): Same.
(start_function): Same.
(grokdeclarator): Make all diagnostic calls use location.
(store_parm_decls_oldstyle): Same.
* c-typeck.c (build_function_call): Add location argument.
Make all diagnostic calls use location.
(do_case): Same.
(c_finish_bc_stmt): Same.
* tree-nested.c (get_trampoline_type): Add argument.
Pass location to build_decl.
(lookup_tramp_for_decl): Pass location to get_trampoline_type.
* rtl.h (RTL_LOCATION): New.
* c-common.c (c_add_case_label): Add location argument.
Make all diagnostic calls use location.
* c-common.h: Add location argument to make_fname_decl, do_case,
c_add_case_label, build_function_call, resolve_overloaded_builtin.
* c-parser.c (c_parser_enum_specifier): Rename ident_loc to enum_loc.
Set it appropriately for every case.  Pass enum_loc to start_enum
call.  Pass value_loc first to build_enumerator.  Pass enum_loc to
parser_xref_tag.
(c_parser_struct_or_union_specifier): Save location.  Use it for
start_struct, finish_struct, and parser_xref_tag.
gcc/testsuite/
* gcc.dg/old-style-prom-3.c: Add column info.
* gcc.dg/overflow-warn-1.c
* gcc.dg/gomp/pr27415.c
* gcc.dg/gomp/for-1.c: Same.
* gcc.dg/enum-compat-1.c: Same.
* gcc.dg/c99-tag-3.c: Same.
* gcc.dg/Wredundant-decls-2.c: Same.
* gcc.dg/func-ptr-conv-1.c: Same.
* gcc.dg/asm-wide-1.c: Same.
* gcc.dg/nofixed-point-2.c: Same.
* gcc.dg/cpp/line3.c: Same.
* gcc.dg/array-10.c: Same.
* gcc.dg/c99-vla-jump-1.c: Same.
* gcc.dg/pr20368-1.c: Same.
* gcc.dg/Wshadow-3.c: Same.
* gcc.dg/c90-const-expr-8.c: Same.
* gcc.dg/label-decl-2.c: Same.
* gcc.dg/dremf-type-compat-2.c: Same.
* gcc.dg/c90-const-expr-5.c: Same.
* gcc.dg/builtins-30.c: Same.
* gcc.dg/Warray-bounds.c: Same.
* gcc.dg/Wcxx-compat-2.c: Same.
* gcc.dg/tree-ssa/col-1.c: Same.
* gcc.dg/old-style-prom-2.c: Same.
* gcc.dg/cast-function-1.c: Same.
* gcc.dg/pr15698-1.c: Same.
* gcc.dg/dremf-type-compat-3.c: Same.
* gcc.dg/vla-8.c: Same.
* gcc.dg/gomp/pr27415.c: Move firstprivate diagnostics to correct
line.
* gcc.dg/label-decl-2.c: Move label diagnostic to correct line.
* gcc.dg/old-style-prom-3.c: Check for error on the correct line.
* gcc.dg/enum-compat-1.c: Same.
* gcc.dg/dremf-type-compat-2.c: Same.
* gcc.dg/old-style-prom-2.c: Same.
* gcc.dg/pr15698-1.c: Same.
* gcc.dg/pr20368-1.c: Same.
* gcc.dg/dremf-type-compat-3.c: Same.
* gcc.dg/builtins-30.c: Same.  Test for columns.
gcc/objcp/
* objcp-decl.h (c_end_compound_stmt): New argument.
* objcp-decl.c (objcp_start_struct): Add argument.
(objcp_finish_struct): Same.
gcc/cp/
* typeck.c (cp_build_binary_op): Pass location to overflow_warning.
(build_modify_expr): New arg.
* semantics.c (finish_unary_op_expr): Pass location to
overflow_warning.
(handle_omp_for_class_iterator): Pass location to build_modify_expr.
* typeck.c (cxx_sizeof_or_alignof_type): Pass location to
c_sizeof_or_alignof_type.
(build_array_ref): New argument.
(build_compound_expr): Same.
(build_const_cast): Same.
(build_ptrmemfunc): Pass location to build_c_cast.
* init.c (avoid_placement_new_aliasing): Pass location to
build_stmt.
(build_vec_delete_1): Pass location to cp_build_modify_expr,
build_compound_expr.
* class.c (build_vtbl_ref_1): Pass location to build_array_ref.
* decl.c (poplevel): Pass location to c_build_bind_expr.
(finish_case_label): Pass location to build_case_label.
(finish_constructor_body): Same.
(finish_destructor_body): Pass location to build_stmt.
(cxx_maybe_build_cleanup): Same, but to build_compound_expr.
* call.c (build_new_op): Pass location to build_array_ref.
(build_x_va_arg): Pass location to build_va_arg.
* except.c (expand_end_catch_block): Pass location to
build_stmt.
* cp-tree.h (build_array_ref): New argument.
(build_compound_expr): Same.
(build_c_cast): Same.
* cp-gimplify.c (gimplify_if_stmt): Pass location on down.
(gimplify_switch_stmt): Same.
* typeck2.c (split_nonconstant_init_1): Same.
* pt.c (tsubst_copy): Same.
* semantics.c (add_decl_expr): Same.
(do_poplevel): Same.
(push_cleanup): Same.
(finish_goto_stmt): Same.
(finish_expr_stmt): Same.
(begin_if_stmt): Same.
(begin_while_stmt): Same.
(begin_do_stmt): Same.
(finish_return_stmt): Same.
(begin_for_stmt): Same.
(finish_break_stmt): Same.
(finish_continue_stmt): Same.
(begin_switch_stmt): Same.
(begin_try_block): Same.
(begin_handler): Same.
(finish_asm_stmt): Same.
(finish_label_stmt): Same.
(finish_stmt_expr_expr): Same.
(finalize_nrv_r): Same.
(finish_omp_atomic): Same.
* name-lookup.c (do_using_directive): Same.
* decl2.c (grok_array_decl): Same.
* parser.c (cp_parser_cast_expression): Same.
(cp_parser_selection_statement): Same.
(cp_parser_implicitly_scoped_statement): Same.
(cp_parser_objc_selector_expression): Same.
(cp_parser_objc_synchronized_statement): Same.
(cp_parser_objc_throw_statement): Same.
(cp_parser_omp_critical): Same.
(cp_parser_omp_master): Same.
* typeck.c (build_function_call): Add location argument.
* init.c: Add location argument to all build_decl calls.
* class.c: Same.
* method.c: Same.
* rtti.c: Same.
* tree.c: Same.
* pt.c: Same.
* semantics.c: Same.
* lex.c: Same.
* decl2.c: Same.
* cp-gimplify.c: Same.
* decl.c: Same.
(cp_make_fname_decl): Add location argument.  Pass location ot
build_decl.
(finish_case_label): Same.
* cp-tree.h (finish_case_label): Add location argument.
* parser.c (cp_parser_label_for_labeled_statement): Pass location to
finish_case_label.
gcc/fortran/
* trans-array.c (gfc_trans_allocate_array_storage): Pass
location on down.
(gfc_trans_array_constructor_value): Same.
(gfc_trans_scalarized_loop_end): Same.
(gfc_conv_ss_startstride): Same.
(gfc_trans_g77_array): Same.
(gfc_trans_dummy_array_bias): Same.
(gfc_conv_array_parameter): Same.
(structure_alloc_comps): Same.
* trans-expr.c (gfc_conv_function_call): Same.
(fill_with_spaces): Same.
(gfc_trans_string_copy): Same.
(gfc_trans_scalar_assign): Same.
* trans-stmt.c (gfc_trans_goto): Same.
(gfc_trans_if_1): Same.
(gfc_trans_simple_do): Same.
(gfc_trans_do): Same.
(gfc_trans_do_while): Same.
(gfc_trans_logical_select): Same.
(gfc_trans_select): Same.
(gfc_trans_forall_loop): Same.
(gfc_trans_nested_forall_loop): Same.
(generate_loop_for_temp_to_lhs): Same.
(generate_loop_for_rhs_to_temp): Same.
(gfc_trans_forall_1): Same.
(gfc_trans_where_assign): Same.
(gfc_trans_where_3): Same.
(gfc_trans_allocate): Same.
* trans.c (gfc_finish_block): Same.
(gfc_trans_runtime_check): Same.
(gfc_call_malloc): Same.
(gfc_allocate_with_status): Same.
(gfc_call_free): Same.
(gfc_deallocate_with_status): Same.
(gfc_call_realloc): Same.
(gfc_trans_code): Same.
* trans-decl.c (gfc_init_default_dt): Same.
(gfc_generate_constructors): Same.
* trans-io.c (gfc_trans_io_runtime_check): Same.
* trans-intrinsic.c (gfc_conv_intrinsic_ctime): Same.
(gfc_conv_intrinsic_fdate): Same.
(gfc_conv_intrinsic_ttynam): Same.
(gfc_conv_intrinsic_minmax): Same.
(gfc_conv_intrinsic_minmax_char): Same.
(gfc_conv_intrinsic_anyall): Same.
(gfc_conv_intrinsic_count): Same.
(gfc_conv_intrinsic_arith): Same.
(gfc_conv_intrinsic_minmaxloc): Same.
(gfc_conv_intrinsic_minmaxval): Same.
(gfc_conv_intrinsic_rrspacing): Same.
(gfc_conv_intrinsic_array_transfer): Same.
(gfc_conv_intrinsic_trim): Same.
(gfc_conv_intrinsic_repeat): Same.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@148442 138bc75d-0d04-0410-961f-82ee72b054a4

128 files changed:
gcc/ChangeLog
gcc/builtins.c
gcc/c-common.c
gcc/c-common.h
gcc/c-decl.c
gcc/c-gimplify.c
gcc/c-omp.c
gcc/c-parser.c
gcc/c-pragma.c
gcc/c-semantics.c
gcc/c-tree.h
gcc/c-typeck.c
gcc/cfgexpand.c
gcc/cgraphunit.c
gcc/config/i386/i386.c
gcc/coverage.c
gcc/cp/ChangeLog
gcc/cp/call.c
gcc/cp/class.c
gcc/cp/cp-gimplify.c
gcc/cp/cp-tree.h
gcc/cp/decl.c
gcc/cp/decl2.c
gcc/cp/except.c
gcc/cp/init.c
gcc/cp/lex.c
gcc/cp/method.c
gcc/cp/name-lookup.c
gcc/cp/parser.c
gcc/cp/pt.c
gcc/cp/rtti.c
gcc/cp/semantics.c
gcc/cp/tree.c
gcc/cp/typeck.c
gcc/cp/typeck2.c
gcc/dwarf2asm.c
gcc/emit-rtl.c
gcc/except.c
gcc/expmed.c
gcc/expr.c
gcc/fortran/ChangeLog
gcc/fortran/trans-array.c
gcc/fortran/trans-common.c
gcc/fortran/trans-decl.c
gcc/fortran/trans-expr.c
gcc/fortran/trans-intrinsic.c
gcc/fortran/trans-io.c
gcc/fortran/trans-openmp.c
gcc/fortran/trans-stmt.c
gcc/fortran/trans-types.c
gcc/fortran/trans.c
gcc/function.c
gcc/gimple-low.c
gcc/gimple-pretty-print.c
gcc/gimplify.c
gcc/ipa-struct-reorg.c
gcc/java/ChangeLog
gcc/java/builtins.c
gcc/java/class.c
gcc/java/constants.c
gcc/java/decl.c
gcc/java/except.c
gcc/java/expr.c
gcc/java/java-gimplify.c
gcc/java/java-tree.h
gcc/java/jcf-parse.c
gcc/java/resource.c
gcc/java/typeck.c
gcc/langhooks.c
gcc/objc/ChangeLog
gcc/objc/objc-act.c
gcc/objcp/ChangeLog
gcc/objcp/objcp-decl.c
gcc/objcp/objcp-decl.h
gcc/omp-low.c
gcc/optabs.c
gcc/rtl.h
gcc/stmt.c
gcc/stor-layout.c
gcc/stub-objc.c
gcc/target.h
gcc/targhooks.c
gcc/testsuite/ChangeLog
gcc/testsuite/gcc.dg/Warray-bounds.c
gcc/testsuite/gcc.dg/Wcxx-compat-2.c
gcc/testsuite/gcc.dg/Wredundant-decls-2.c
gcc/testsuite/gcc.dg/Wshadow-3.c
gcc/testsuite/gcc.dg/array-10.c
gcc/testsuite/gcc.dg/asm-wide-1.c
gcc/testsuite/gcc.dg/builtins-30.c
gcc/testsuite/gcc.dg/c90-const-expr-5.c
gcc/testsuite/gcc.dg/c90-const-expr-8.c
gcc/testsuite/gcc.dg/c99-tag-3.c
gcc/testsuite/gcc.dg/c99-vla-jump-1.c
gcc/testsuite/gcc.dg/cast-function-1.c
gcc/testsuite/gcc.dg/cpp/line3.c
gcc/testsuite/gcc.dg/dremf-type-compat-2.c
gcc/testsuite/gcc.dg/dremf-type-compat-3.c
gcc/testsuite/gcc.dg/enum-compat-1.c
gcc/testsuite/gcc.dg/func-ptr-conv-1.c
gcc/testsuite/gcc.dg/gomp/for-1.c
gcc/testsuite/gcc.dg/gomp/pr27415.c
gcc/testsuite/gcc.dg/label-decl-2.c
gcc/testsuite/gcc.dg/nofixed-point-2.c
gcc/testsuite/gcc.dg/old-style-prom-2.c
gcc/testsuite/gcc.dg/old-style-prom-3.c
gcc/testsuite/gcc.dg/overflow-warn-1.c
gcc/testsuite/gcc.dg/pr15698-1.c
gcc/testsuite/gcc.dg/pr20368-1.c
gcc/testsuite/gcc.dg/tree-ssa/col-1.c [new file with mode: 0644]
gcc/testsuite/gcc.dg/vla-8.c
gcc/tree-call-cdce.c
gcc/tree-cfg.c
gcc/tree-eh.c
gcc/tree-inline.c
gcc/tree-mudflap.c
gcc/tree-nested.c
gcc/tree-parloops.c
gcc/tree-profile.c
gcc/tree-ssa-ccp.c
gcc/tree-ssa-forwprop.c
gcc/tree-ssa-operands.c
gcc/tree-ssa.c
gcc/tree-switch-conversion.c
gcc/tree-vrp.c
gcc/tree.c
gcc/tree.h
gcc/varasm.c

index d8c08aa..d1c91f4 100644 (file)
@@ -1,3 +1,299 @@
+2009-06-12  Aldy Hernandez  <aldyh@redhat.com>
+
+       * tree-pretty-print.c (dump_generic_node): Dump column numbers.
+       * gimple-pretty-print.c (dump_gimple_stmt): Same.
+       * gimplify.c (gimplify_modify_expr): Set location for GIMPLE_ASSIGNs
+       created.
+       * c-parser.c (c_parser_binary_expression): Use current column while
+       building binary operations.
+       * common.opt (fshow-column): Enable by default.
+       * tree-vrp.c (check_array_ref): Use warning_at.
+       (check_array_bounds): Use location from call back if expr has no
+       location.
+       * tree.h: Add location argument to maybe_fold_*.
+       * tree-ssa-ccp.c (ccp_fold): Pass location to maybe_fold_*.
+       (maybe_fold_offset_to_array_ref): Add location argument and use it.
+       (maybe_fold_offset_to_component_ref): Same.
+       (maybe_fold_offset_to_reference): Same.
+       (maybe_fold_offset_to_address): Same.
+       (maybe_fold_stmt_indirect): Same.
+       (maybe_fold_stmt_addition): Same.
+       (fold_stmt_r): Pass location to maybe_fold_*.
+       (fold_gimple_assign): Same.
+       * c-tree.h: Add location argument to finish_decl,
+       default_function_array_conversion, store_init_value.
+       * c-decl.c (define_label): Use error_at.
+       (c_make_fname_decl): Pass location to finish_decl.
+       (finish_decl): New location argument.
+       (build_compound_literal): Pass location to store_init_value.
+       (grokdeclarator): Pass location to finish_decl.
+       (grokfield): Same.
+       * c-typeck.c (array_to_pointer_conversion): New location argument.
+       (function_to_pointer_conversion): Same.
+       (default_function_array_conversion): Same.
+       (parser_build_unary_op): Pass location to overflow_warning.
+       (parser_build_binary_op): Same.  Use warning_at.
+       (build_unary_op): Pass location to array_to_pointer_conversion.
+       (build_c_cast): Pass location to digest_init.
+       (build_modify_expr): New location argument.
+       (convert_for_assignment): Same.
+       (store_init_value): Same.
+       (digest_init): Same.
+       (output_init_element): Pass location to digest_init and
+       array_to_pointer_conversion.
+       (c_finish_return): Pass location to convert_for_assignment.
+       * gimplify.c (gimplify_conversion): Pass location to
+       maybe_fold_offset_to_address.
+       * tree-ssa-forwprop.c (forward_propagate_addr_expr_1): Pass location
+       to maybe_fold_stmt_addition.
+       * c-omp.c (c_finish_omp_atomic): Pass new location to
+       build_modify_expr.
+       (c_finish_omp_for): Same.
+       * c-common.c (overflow_warning): New argument.
+       * c-common.h: New argument to build_modify_expr, overflow_warning.
+       * c-parser.c (c_parser_declaration_or_fndef): Pass location to
+       finish_decl.
+       (c_parser_initializer): Pass location to
+       default_function_array_conversion.
+       (c_parser_initelt): Same.
+       (c_parser_initval): Same.
+       (c_parser_asm_operands): Same.
+       (c_parser_expr_no_commas): Same.  Pass location to build_modify_expr.
+       (c_parser_conditional_expression): Same.
+       (c_parser_binary_expression): Add location info to stack.  Use it.
+       (c_parser_unary_expression): Pass location to
+       default_function_array_conversion, parser_build_unary_op,
+       build_indirect_ref, c_parser_postfix_expression_after_primary.
+       (c_parser_postfix_expression_after_primary): New location argument.
+       Use it.
+       (c_parser_expression_conv): Pass location to
+       default_function_array_conversion.
+       (c_parser_expr_list): Same.
+       (c_parser_omp_atomic): Same.
+       (c_parser_omp_for_loop): Same.
+       * c-tree.h: (struct c_declarator): Add comment to id_loc.
+       (build_array_declarator): New argument.
+       * c-decl.c (build_array_declarator): Add location argument.
+       (grokdeclarator): Set id_loc for cdk_array.
+       * c-parser.c (c_parser_direct_declarator_inner): Pass location to
+       build_array_declarator.
+       * tree.c (build_omp_clause): Add location argument.
+       * tree.h (OMP_CLAUSE_HAS_LOCATION): New macro.
+       (OMP_CLAUSE_LOCATION): New macro.
+       (struct tree_omp_clause): Add location field.
+       (build_omp_clause): Add argument.
+       * testsuite/gcc.dg/gomp/for-1.c: Fix column.
+       * cp/pt.c (tsubst_omp_for_iterator): Pass location to
+       build_omp_clause.
+       * cp/parser.c (cp_parser_omp_var_list_no_open): Same.
+       (cp_parser_omp_clause_collapse): Same.
+       (cp_parser_omp_clause_default): Same.
+       (cp_parser_omp_clause_if): Same.
+       (cp_parser_omp_clause_nowait): Same.
+       (cp_parser_omp_clause_num_threads): Same.
+       (cp_parser_omp_clause_ordered): Same.
+       (cp_parser_omp_clause_schedule): Same.
+       (cp_parser_omp_clause_untied): Same.
+       (cp_parser_omp_for_loop): Same.
+       (cp_parser_omp_parallel): Pass location to c_split_parallel_clauses.
+       * c-tree.h (c_start_case): Add location argument.
+       (c_process_expr_stmt): Same.
+       (c_finish_goto_*): Same.
+       * tree-parloops.c (initialize_reductions): Pass location to
+       build_omp_clause.
+       (create_parallel_loop): Same.
+       * fortran/trans-openmp.c (gfc_trans_omp_variable_list): Same.
+       (gfc_trans_omp_reduction_list): Same.
+       (gfc_trans_omp_clauses): Same.
+       (gfc_trans_omp_do): Same.
+       * c-typeck.c (c_finish_goto_label): Same.
+       (c_finish_goto_ptr): New location argument.
+       (c_start_case): Same.
+       (emit_side_effect_warnings): Same.
+       (c_process_expr_stmt): Same.
+       (c_finish_stmt_expr): Same.
+       (c_finish_omp_clauses): Use error_at instead of error.
+       * gimplify.c (gimplify_adjust_omp_clauses_1): Pass location to
+       build_omp_clause.
+       * c-omp.c (c_split_parallel_clauses): New location argument.
+       * tree-nested.c (convert_nonlocal_reference_stmt): Pass location
+       to build_omp_clause.
+       (convert_local_reference_stmt): Same.
+       (convert_gimple_call): Same.
+       * c-common.h (c_split_parallel_clauses): New argument.
+       * c-parser.c (c_parser_statement_after_labels): Pass location to
+       c_finish_goto_label.
+       (c_parser_switch_statement): Pass location to c_start_case.
+       (c_parser_for_statement): Pass location to c_finish_expr_stmt,
+       and c_process_expr_stmt.
+       (c_parser_omp_variable_list): Add location argument.
+       (c_parser_omp_clause_collapse): Pass location to
+       build_omp_clause.
+       (c_parser_omp_clause_default): Same.
+       (c_parser_omp_clause_if): Same.
+       (c_parser_omp_clause_num_threads): Same.
+       (-c_parser_omp_clause_ordered): Same.
+       (c_parser_omp_clause_reduction): Pass location to
+       c_parser_omp_variable_list.
+       (c_parser_omp_clause_schedule): Pass location to build_omp_clause.
+       (c_parser_omp_clause_untied): Same.
+       (c_parser_omp_for_loop): Pass location to c_process_expr_stmt.
+       (c_parser_omp_parallel): Pass location to
+       c_split_parallel_clauses.
+
+       * c-tree.h (check_for_loop_decls, undeclared_variable,
+       build_component_ref, build_array_ref, build_external_ref,
+       c_expr_sizeof_expr, c_expr_sizeof_type, parser_build_unary_op,
+       build_conditional_expr, build_compound_expr, c_cast_expr,
+       build_c_cast, build_asm_expr, c_end_compound_stmt, c_finish_stmt_expr,
+       c_finish_return, c_finish_omp_parallel, c_finish_omp_task): New
+       argument.
+       * c-semantics.c (build_stmt): Same.
+       (build_case_label): Same.
+       * c-decl.c (c_finish_incomplete_decl): Pass location on down.
+       (undeclared_variable): New argument.
+       (make_label): Same.
+       (lookup_label): Pass location on down.
+       (define_label): Same.
+       (finish_decl): Same.
+       (build_compound_literal): Same.
+       (finish_struct): Same.
+       (finish_function): Do not set location here.
+       (check_for_loop_decls): New argument.
+       * tree.c (save_expr): Set location.
+       (build_empty_stmt): New argument.
+       * tree.h (build_empty_stmt): New argument to build_empty_stmt.
+       (CAN_HAVE_LOCATION_P): Make sure we have a non empty node.
+       * builtins.c (gimplify_va_arg_expr): Use locations.
+       (expand_builtin_sync_operation): Same.
+       * c-typeck.c (build_component_ref): New argument.
+       (build_array_ref): Same.
+       (build_external_ref): Same.
+       (c_expr_sizeof_expr): Same.
+       (c_expr_sizeof_type): Same.
+       (parser_build_unary_op): Same.
+       (build_conditional_expr): Same.
+       (build_compound_expr): Pass location on down.
+       (build_compound_expr): New argument.
+       (build_c_cast): Same.
+       (c_cast_expr): Same.
+       (build_asm_expr): Same.
+       (c_finish_return): Same.
+       (c_process_expr_stmt): Pass location on down.
+       (c_finish_stmt_expr): New argument.
+       (push_clenaup): Same.
+       (c_finish_omp_parallel): Same.
+       (c_finish_omp_task): Same.
+       * gimplify.c (gimplify_call_expr): Pass location on down.
+       * c-omp.c (c_finish_omp_master): New argument.
+       (c_finish_omp_critical): Same.
+       (c_finish_omp_ordered): Same.
+       (c_finish_omp_barrier): Same.
+       (-c_finish_omp_taskwait): Same.
+       (c_finish_omp_atomic): Same.
+       (c_finish_omp_flush): Same.
+       * tree-inline.c (copy_tree_body_r): Pass location on down.
+       (inline_forbidden_p): Remove use of input_location.
+       * c-gimplify.c (c_build_bind_expr): New argument.
+       * c-common.c (c_common_truthvalue_conversion): Pass location on down.
+       (c_sizeof_or_alignof_type): New argument.
+       (c_alignof_expr): Same.
+       (build_va_arg): Same.
+       (c_add_case_label): Same.
+       * c-common.h (c_sizeof_or_alignof_type, c_alignof_expr,
+       c_sizeof, c_alignof, build_va_arg, build_stmt, build_case_label,
+       c_build_bind_expr, objc_build_selector_expr, objc_build_throw_stmt,
+       c_finish_omp_master, c_finish_omp_critical, c_finish_omp_ordered,
+       c_finish_omp_barrier, c_finish_omp_atomic, c_finish_omp_flush,
+       c_finish_omp_taskwait, c_finish_omp_for, c_split_parallel_clauses):
+       New argument.
+       * stub-objc.c (objc_build_selector_expr): Same.
+       (objc_build_throw_stmt): Same.
+       * c-parser.c (c_parser_declaration_or_fndef): Pass location on down.
+       (c_parser_initelt): Same.
+       (c_parser_compound_statement): Same.
+       (c_parser_compound_statement_nostart): Same.
+       (c_parser_label): Same.
+       (c_parser_statement_after_labels): Same.
+       (c_parser_if_body): Same.
+       (c_parser_else_body): Same.
+       (c_parser_if_statement): Same.
+       (c_parser_switch_statement): Same.
+       (c_parser_while_statement): Same.
+       (c_parser_do_statement): Same.
+       (c_parser_for_statement): Same.
+       (c_parser_asm_statement): Same.
+       (c_parser_conditional_expression): Same.
+       (c_parser_binary_expression): Same.
+       (c_parser_cast_expression): Same.
+       (c_parser_unary_expression): Same.
+       (c_parser_sizeof_expression): Same.
+       (c_parser_alignof_expression): Same.
+       (c_parser_postfix_expression): Same.
+       (c_parser_expression): Same.
+       (c_parser_objc_receiver): Same.
+       (c_parser_omp_variable_list): Same.
+       (c_parser_omp_structured_block): Same.
+       (c_parser_omp_atomic): New argument.
+       (c_parser_omp_barrier): Same.
+       (c_parser_omp_critical): Same.
+       (c_parser_omp_flush): Pass location on down.
+       (c_parser_omp_for_loop): New argument.
+       (c_parser_omp_for): Same.
+       (c_parser_omp_master): Same.
+       (c_parser_omp_ordered): Same.
+       (c_parser_omp_sections_scope): Same.
+       (c_parser_omp_sections): Same.
+       (c_parser_omp_parallel): Same.
+       (c_parser_omp_single): Same.
+       (c_parser_omp_task): Same.
+       (c_parser_omp_taskwait): Pass location on down.
+       (c_parser_omp_construct): Same.
+       (c_parser_omp_threadprivate): Same.
+       * dwarf2asm.c, targhooks.c, optabs.c, tree.c, tree.h, target.h,
+       builtins.c, omp-low.c, cgraphunit.c, tree-call-cdce.c,
+       tree-ssa-alias.c, gimple-low.c, c-tree.h, expr.c, tree-parloops.c,
+       c-decl.c, tree-eh.c, langhooks.c, function.c, stor-layout.c,
+       c-typeck.c, gimplify.c, c-pragma.c, expmed.c, except.c, coverage.c,
+       emit-rtl.c, cfgexpand.c, tree-mudflap.c, varasm.c, tree-nested.c,
+       rtl.h, tree-inline.c, tree-profile.c, c-common.c, c-common.h,
+       tree-switch-conversion.c, tree-cfg.c, ipa-struct-reorg.c, c-parser.c,
+       config/i386/i386.c, stmt.c:
+       Add location argument to the following function definitions and/or
+       function calls: build_decl, objcp_start_struct, objcp_finish_struct,
+       start_struct, finish_struct, PUSH_FIELD, create_artificial_label,
+       cp_make_fname_decl, pushtag, implicitly_declare, c_make_fname_decl,
+       build_compound_literal, parser_xref_tag, resolve_overloaded_builtin,
+       do_case, c_finish_bc_stmt, build_compound_literal,
+       build_function_call.
+       * c-decl.c (build_compound_literal): Add location argument.
+       Make all diagnostic calls use location.
+       (start_struct): Same.
+       (finish_struct): Same.
+       (start_enum): Same.
+       (build_enumerator): Same.
+       (start_function): Same.
+       (grokdeclarator): Make all diagnostic calls use location.
+       (store_parm_decls_oldstyle): Same.
+       * c-typeck.c (build_function_call): Add location argument.
+       Make all diagnostic calls use location.
+       (do_case): Same.
+       (c_finish_bc_stmt): Same.
+       * tree-nested.c (get_trampoline_type): Add argument.
+       Pass location to build_decl.
+       (lookup_tramp_for_decl): Pass location to get_trampoline_type.
+       * rtl.h (RTL_LOCATION): New.
+       * c-common.c (c_add_case_label): Add location argument.
+       Make all diagnostic calls use location.
+       * c-common.h: Add location argument to make_fname_decl, do_case,
+       c_add_case_label, build_function_call, resolve_overloaded_builtin.
+       * c-parser.c (c_parser_enum_specifier): Rename ident_loc to enum_loc.
+       Set it appropriately for every case.  Pass enum_loc to start_enum
+       call.  Pass value_loc first to build_enumerator.  Pass enum_loc to
+       parser_xref_tag.
+       (c_parser_struct_or_union_specifier): Save location.  Use it for
+       start_struct, finish_struct, and parser_xref_tag.
+
 2009-06-12  Ian Lance Taylor  <iant@google.com>
 
        * fold-const.c (fold_unary): Rename local variable and to
index 9891978..a6d26ef 100644 (file)
@@ -4975,6 +4975,8 @@ gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
   tree valist = TREE_OPERAND (*expr_p, 0);
   tree type = TREE_TYPE (*expr_p);
   tree t;
+  location_t loc = EXPR_HAS_LOCATION (*expr_p) ? EXPR_LOCATION (*expr_p) :
+    UNKNOWN_LOCATION;
 
   /* Verify that valist is of the proper type.  */
   have_va_type = TREE_TYPE (valist);
@@ -4984,7 +4986,7 @@ gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
 
   if (have_va_type == NULL_TREE)
     {
-      error ("first argument to %<va_arg%> not of type %<va_list%>");
+      error_at (loc, "first argument to %<va_arg%> not of type %<va_list%>");
       return GS_ERROR;
     }
 
@@ -4999,19 +5001,20 @@ gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
       /* Unfortunately, this is merely undefined, rather than a constraint
         violation, so we cannot make this an error.  If this call is never
         executed, the program is still strictly conforming.  */
-      warned = warning (0, "%qT is promoted to %qT when passed through %<...%>",
-                       type, promoted_type);
+      warned = warning_at (loc, 0,
+                          "%qT is promoted to %qT when passed through %<...%>",
+                          type, promoted_type);
       if (!gave_help && warned)
        {
          gave_help = true;
-         inform (input_location, "(so you should pass %qT not %qT to %<va_arg%>)",
-                  promoted_type, type);
+         inform (loc, "(so you should pass %qT not %qT to %<va_arg%>)",
+                 promoted_type, type);
        }
 
       /* We can, however, treat "undefined" any way we please.
         Call abort to encourage the user to fix the program.  */
       if (warned)
-       inform (input_location, "if this code is reached, the program will abort");
+       inform (loc, "if this code is reached, the program will abort");
       /* Before the abort, allow the evaluation of the va_list
         expression to exit or longjmp.  */
       gimplify_and_add (valist, pre_p);
@@ -5984,7 +5987,8 @@ expand_builtin_fork_or_exec (tree fn, tree exp, rtx target, int ignore)
       gcc_unreachable ();
     }
 
-  decl = build_decl (FUNCTION_DECL, id, TREE_TYPE (fn));
+  decl = build_decl (DECL_SOURCE_LOCATION (fn),
+                    FUNCTION_DECL, id, TREE_TYPE (fn));
   DECL_EXTERNAL (decl) = 1;
   TREE_PUBLIC (decl) = 1;
   DECL_ARTIFICIAL (decl) = 1;
@@ -6050,6 +6054,7 @@ expand_builtin_sync_operation (enum machine_mode mode, tree exp,
 {
   rtx val, mem;
   enum machine_mode old_mode;
+  location_t loc = EXPR_LOCATION (exp);
 
   if (code == NOT && warn_sync_nand)
     {
@@ -6070,8 +6075,7 @@ expand_builtin_sync_operation (enum machine_mode mode, tree exp,
            break;
 
          fndecl = implicit_built_in_decls[BUILT_IN_FETCH_AND_NAND_N];
-         inform (input_location,
-                 "%qD changed semantics in GCC 4.4", fndecl);
+         inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
          warned_f_a_n = true;
          break;
 
@@ -6085,8 +6089,7 @@ expand_builtin_sync_operation (enum machine_mode mode, tree exp,
            break;
 
          fndecl = implicit_built_in_decls[BUILT_IN_NAND_AND_FETCH_N];
-         inform (input_location,
-                 "%qD changed semantics in GCC 4.4", fndecl);
+         inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
          warned_n_a_f = true;
          break;
 
index b26662d..139a5d2 100644 (file)
@@ -440,7 +440,7 @@ int max_tinst_depth = 500;
    type names and storage classes.  It is indexed by a RID_... value.  */
 tree *ridpointers;
 
-tree (*make_fname_decl) (tree, int);
+tree (*make_fname_decl) (location_t, tree, int);
 
 /* Nonzero means the expression being parsed will never be evaluated.
    This is a count, since unevaluated expressions can nest.  */
@@ -971,7 +971,7 @@ fname_decl (location_t loc, unsigned int rid, tree id)
       input_location = UNKNOWN_LOCATION;
 
       stmts = push_stmt_list ();
-      decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
+      decl = (*make_fname_decl) (loc, id, fname_vars[ix].pretty);
       stmts = pop_stmt_list (stmts);
       if (!IS_EMPTY_STMT (stmts))
        saved_function_name_decls
@@ -1505,33 +1505,36 @@ constant_expression_error (tree value)
    already overflowed.  */
 
 void
-overflow_warning (tree value)
+overflow_warning (location_t loc, tree value)
 {
   if (skip_evaluation) return;
 
   switch (TREE_CODE (value))
     {
     case INTEGER_CST:
-      warning (OPT_Woverflow, "integer overflow in expression");
+      warning_at (loc, OPT_Woverflow, "integer overflow in expression");
       break;
       
     case REAL_CST:
-      warning (OPT_Woverflow, "floating point overflow in expression");
+      warning_at (loc, OPT_Woverflow,
+                 "floating point overflow in expression");
       break;
       
     case FIXED_CST:
-      warning (OPT_Woverflow, "fixed-point overflow in expression");
+      warning_at (loc, OPT_Woverflow, "fixed-point overflow in expression");
       break;
 
     case VECTOR_CST:
-      warning (OPT_Woverflow, "vector overflow in expression");
+      warning_at (loc, OPT_Woverflow, "vector overflow in expression");
       break;
       
     case COMPLEX_CST:
       if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
-       warning (OPT_Woverflow, "complex integer overflow in expression");
+       warning_at (loc, OPT_Woverflow,
+                   "complex integer overflow in expression");
       else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
-       warning (OPT_Woverflow, "complex floating point overflow in expression");
+       warning_at (loc, OPT_Woverflow,
+                   "complex floating point overflow in expression");
       break;
 
     default:
@@ -3224,7 +3227,8 @@ c_register_builtin_type (tree type, const char* name)
 {
   tree decl;
 
-  decl = build_decl (TYPE_DECL, get_identifier (name), type);
+  decl = build_decl (UNKNOWN_LOCATION,
+                    TYPE_DECL, get_identifier (name), type);
   DECL_ARTIFICIAL (decl) = 1;
   if (!TYPE_NAME (type))
     TYPE_NAME (type) = decl;
@@ -3799,8 +3803,9 @@ c_common_truthvalue_conversion (location_t location, tree expr)
     case ORDERED_EXPR: case UNORDERED_EXPR:
       if (TREE_TYPE (expr) == truthvalue_type_node)
        return expr;
-      return build2 (TREE_CODE (expr), truthvalue_type_node,
+      expr = build2 (TREE_CODE (expr), truthvalue_type_node,
                     TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
+      goto ret;
 
     case TRUTH_ANDIF_EXPR:
     case TRUTH_ORIF_EXPR:
@@ -3809,18 +3814,20 @@ c_common_truthvalue_conversion (location_t location, tree expr)
     case TRUTH_XOR_EXPR:
       if (TREE_TYPE (expr) == truthvalue_type_node)
        return expr;
-      return build2 (TREE_CODE (expr), truthvalue_type_node,
-                c_common_truthvalue_conversion (location, 
-                                                TREE_OPERAND (expr, 0)),
-                c_common_truthvalue_conversion (location,
-                                                TREE_OPERAND (expr, 1)));
+      expr = build2 (TREE_CODE (expr), truthvalue_type_node,
+                    c_common_truthvalue_conversion (location, 
+                                                    TREE_OPERAND (expr, 0)),
+                    c_common_truthvalue_conversion (location,
+                                                    TREE_OPERAND (expr, 1)));
+      goto ret;
 
     case TRUTH_NOT_EXPR:
       if (TREE_TYPE (expr) == truthvalue_type_node)
        return expr;
-      return build1 (TREE_CODE (expr), truthvalue_type_node,
-                c_common_truthvalue_conversion (location,
-                                                TREE_OPERAND (expr, 0)));
+      expr = build1 (TREE_CODE (expr), truthvalue_type_node,
+                    c_common_truthvalue_conversion (location,
+                                                    TREE_OPERAND (expr, 0)));
+      goto ret;
 
     case ERROR_MARK:
       return expr;
@@ -3866,14 +3873,17 @@ c_common_truthvalue_conversion (location_t location, tree expr)
          }
 
        if (TREE_SIDE_EFFECTS (inner))
-         return build2 (COMPOUND_EXPR, truthvalue_type_node,
-                        inner, truthvalue_true_node);
+         {
+           expr = build2 (COMPOUND_EXPR, truthvalue_type_node,
+                          inner, truthvalue_true_node);
+           goto ret;
+         }
        else
          return truthvalue_true_node;
       }
 
     case COMPLEX_EXPR:
-      return build_binary_op (EXPR_LOCATION (expr),
+      expr = build_binary_op (EXPR_LOCATION (expr),
                              (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
                               ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
                c_common_truthvalue_conversion (location,
@@ -3881,6 +3891,7 @@ c_common_truthvalue_conversion (location_t location, tree expr)
                c_common_truthvalue_conversion (location,
                                                TREE_OPERAND (expr, 1)),
                              0);
+      goto ret;
 
     case NEGATE_EXPR:
     case ABS_EXPR:
@@ -3894,10 +3905,13 @@ c_common_truthvalue_conversion (location_t location, tree expr)
       /* These don't change whether an object is zero or nonzero, but
         we can't ignore them if their second arg has side-effects.  */
       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
-       return build2 (COMPOUND_EXPR, truthvalue_type_node,
-                      TREE_OPERAND (expr, 1),
-                      c_common_truthvalue_conversion 
-                       (location, TREE_OPERAND (expr, 0)));
+       {
+         expr = build2 (COMPOUND_EXPR, truthvalue_type_node,
+                        TREE_OPERAND (expr, 1),
+                        c_common_truthvalue_conversion 
+                        (location, TREE_OPERAND (expr, 0)));
+         goto ret;
+       }
       else
        return c_common_truthvalue_conversion (location,
                                               TREE_OPERAND (expr, 0));
@@ -3905,22 +3919,28 @@ c_common_truthvalue_conversion (location_t location, tree expr)
     case COND_EXPR:
       /* Distribute the conversion into the arms of a COND_EXPR.  */
       if (c_dialect_cxx ())
-       return fold_build3 (COND_EXPR, truthvalue_type_node,
-                           TREE_OPERAND (expr, 0),
-                           c_common_truthvalue_conversion (location,
-                                                           TREE_OPERAND (expr,
-                                                                         1)),
-                           c_common_truthvalue_conversion (location,
-                                                           TREE_OPERAND (expr,
-                                                                         2)));
+       {
+         expr = fold_build3 (COND_EXPR, truthvalue_type_node,
+                             TREE_OPERAND (expr, 0),
+                             c_common_truthvalue_conversion (location,
+                                                             TREE_OPERAND (expr,
+                                                                           1)),
+                             c_common_truthvalue_conversion (location,
+                                                             TREE_OPERAND (expr,
+                                                                           2)));
+         goto ret;
+       }
       else
-       /* Folding will happen later for C.  */
-       return build3 (COND_EXPR, truthvalue_type_node,
-                      TREE_OPERAND (expr, 0),
-                      c_common_truthvalue_conversion (location,
-                                                      TREE_OPERAND (expr, 1)),
-                      c_common_truthvalue_conversion (location,
-                                                      TREE_OPERAND (expr, 2)));
+       {
+         /* Folding will happen later for C.  */
+         expr = build3 (COND_EXPR, truthvalue_type_node,
+                        TREE_OPERAND (expr, 0),
+                        c_common_truthvalue_conversion (location,
+                                                        TREE_OPERAND (expr, 1)),
+                        c_common_truthvalue_conversion (location,
+                                                        TREE_OPERAND (expr, 2)));
+         goto ret;
+       }
 
     CASE_CONVERT:
       /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
@@ -3952,7 +3972,7 @@ c_common_truthvalue_conversion (location_t location, tree expr)
   if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
     {
       tree t = c_save_expr (expr);
-      return (build_binary_op
+      expr = (build_binary_op
              (EXPR_LOCATION (expr),
               (TREE_SIDE_EFFECTS (expr)
                ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
@@ -3963,6 +3983,7 @@ c_common_truthvalue_conversion (location_t location, tree expr)
               (location,
                build_unary_op (location, IMAGPART_EXPR, t, 0)),
               0));
+      goto ret;
     }
 
   if (TREE_CODE (TREE_TYPE (expr)) == FIXED_POINT_TYPE)
@@ -3972,8 +3993,12 @@ c_common_truthvalue_conversion (location_t location, tree expr)
                                                   (TREE_TYPE (expr))));
       return build_binary_op (location, NE_EXPR, expr, fixed_zero_node, 1);
     }
+  else
+    return build_binary_op (location, NE_EXPR, expr, integer_zero_node, 1);
 
-  return build_binary_op (location, NE_EXPR, expr, integer_zero_node, 1);
+ ret:
+  protected_set_expr_location (expr, location);
+  return expr;
 }
 \f
 static void def_builtin_1  (enum built_in_function fncode,
@@ -4214,13 +4239,15 @@ c_common_get_alias_set (tree t)
   return -1;
 }
 \f
-/* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
-   second parameter indicates which OPERATOR is being applied.  The COMPLAIN
-   flag controls whether we should diagnose possibly ill-formed
-   constructs or not.  */
+/* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where
+   the second parameter indicates which OPERATOR is being applied.
+   The COMPLAIN flag controls whether we should diagnose possibly
+   ill-formed constructs or not.  LOC is the location of the SIZEOF or
+   TYPEOF operator.  */
 
 tree
-c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
+c_sizeof_or_alignof_type (location_t loc,
+                         tree type, bool is_sizeof, int complain)
 {
   const char *op_name;
   tree value = NULL;
@@ -4233,7 +4260,7 @@ c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
       if (is_sizeof)
        {
          if (complain && (pedantic || warn_pointer_arith))
-           pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 
+           pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 
                     "invalid application of %<sizeof%> to a function type");
           else if (!complain)
             return error_mark_node;
@@ -4246,7 +4273,7 @@ c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
     {
       if (type_code == VOID_TYPE
          && complain && (pedantic || warn_pointer_arith))
-       pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 
+       pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 
                 "invalid application of %qs to a void type", op_name);
       else if (!complain)
         return error_mark_node;
@@ -4255,8 +4282,8 @@ c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
   else if (!COMPLETE_TYPE_P (type))
     {
       if (complain)
-       error ("invalid application of %qs to incomplete type %qT ",
-              op_name, type);
+       error_at (loc, "invalid application of %qs to incomplete type %qT ",
+                 op_name, type);
       value = size_zero_node;
     }
   else
@@ -4283,10 +4310,11 @@ c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
 /* Implement the __alignof keyword: Return the minimum required
    alignment of EXPR, measured in bytes.  For VAR_DECLs,
    FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
-   from an "aligned" __attribute__ specification).  */
+   from an "aligned" __attribute__ specification).  LOC is the
+   location of the ALIGNOF operator.  */
 
 tree
-c_alignof_expr (tree expr)
+c_alignof_expr (location_t loc, tree expr)
 {
   tree t;
 
@@ -4296,7 +4324,7 @@ c_alignof_expr (tree expr)
   else if (TREE_CODE (expr) == COMPONENT_REF
           && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
     {
-      error ("%<__alignof%> applied to a bit-field");
+      error_at (loc, "%<__alignof%> applied to a bit-field");
       t = size_one_node;
     }
   else if (TREE_CODE (expr) == COMPONENT_REF
@@ -4319,10 +4347,10 @@ c_alignof_expr (tree expr)
          if (thisalign > bestalign)
            best = t, bestalign = thisalign;
        }
-      return c_alignof (TREE_TYPE (TREE_TYPE (best)));
+      return c_alignof (loc, TREE_TYPE (TREE_TYPE (best)));
     }
   else
-    return c_alignof (TREE_TYPE (expr));
+    return c_alignof (loc, TREE_TYPE (expr));
 
   return fold_convert (size_type_node, t);
 }
@@ -4570,31 +4598,41 @@ c_common_nodes_and_builtins (void)
 
   /* These are types that c_common_type_for_size and
      c_common_type_for_mode use.  */
-  lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
+  lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
+                                        TYPE_DECL, NULL_TREE,
                                         intQI_type_node));
-  lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
+  lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
+                                        TYPE_DECL, NULL_TREE,
                                         intHI_type_node));
-  lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
+  lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
+                                        TYPE_DECL, NULL_TREE,
                                         intSI_type_node));
-  lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
+  lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
+                                        TYPE_DECL, NULL_TREE,
                                         intDI_type_node));
 #if HOST_BITS_PER_WIDE_INT >= 64
   if (targetm.scalar_mode_supported_p (TImode))
-    lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
+    lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
+                                          TYPE_DECL,
                                           get_identifier ("__int128_t"),
                                           intTI_type_node));
 #endif
-  lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
+  lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
+                                        TYPE_DECL, NULL_TREE,
                                         unsigned_intQI_type_node));
-  lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
+  lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
+                                        TYPE_DECL, NULL_TREE,
                                         unsigned_intHI_type_node));
-  lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
+  lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
+                                        TYPE_DECL, NULL_TREE,
                                         unsigned_intSI_type_node));
-  lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
+  lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
+                                        TYPE_DECL, NULL_TREE,
                                         unsigned_intDI_type_node));
 #if HOST_BITS_PER_WIDE_INT >= 64
   if (targetm.scalar_mode_supported_p (TImode))
-    lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
+    lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
+                                          TYPE_DECL,
                                           get_identifier ("__uint128_t"),
                                           unsigned_intTI_type_node));
 #endif
@@ -4602,12 +4640,14 @@ c_common_nodes_and_builtins (void)
   /* Create the widest literal types.  */
   widest_integer_literal_type_node
     = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
-  lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
+  lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
+                                        TYPE_DECL, NULL_TREE,
                                         widest_integer_literal_type_node));
 
   widest_unsigned_literal_type_node
     = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
-  lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
+  lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
+                                        TYPE_DECL, NULL_TREE,
                                         widest_unsigned_literal_type_node));
 
   /* `unsigned long' is the standard type for sizeof.
@@ -4699,17 +4739,21 @@ c_common_nodes_and_builtins (void)
 
     }
 
-  lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
+  lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
+                                        TYPE_DECL,
                                         get_identifier ("complex int"),
                                         complex_integer_type_node));
-  lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
+  lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
+                                        TYPE_DECL,
                                         get_identifier ("complex float"),
                                         complex_float_type_node));
-  lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
+  lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
+                                        TYPE_DECL,
                                         get_identifier ("complex double"),
                                         complex_double_type_node));
   lang_hooks.decls.pushdecl
-    (build_decl (TYPE_DECL, get_identifier ("complex long double"),
+    (build_decl (UNKNOWN_LOCATION,
+                TYPE_DECL, get_identifier ("complex long double"),
                 complex_long_double_type_node));
 
   if (c_dialect_cxx ())
@@ -4903,7 +4947,8 @@ c_common_nodes_and_builtins (void)
   unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
 
   lang_hooks.decls.pushdecl
-    (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
+    (build_decl (UNKNOWN_LOCATION,
+                TYPE_DECL, get_identifier ("__builtin_va_list"),
                 va_list_type_node));
 #ifdef TARGET_ENUM_VA_LIST
   {
@@ -4913,7 +4958,8 @@ c_common_nodes_and_builtins (void)
     for (l = 0; TARGET_ENUM_VA_LIST (l, &pname, &ptype); ++l)
       {
        lang_hooks.decls.pushdecl
-         (build_decl (TYPE_DECL, get_identifier (pname),
+         (build_decl (UNKNOWN_LOCATION,
+                      TYPE_DECL, get_identifier (pname),
                       ptype));
 
       }
@@ -4999,9 +5045,11 @@ set_compound_literal_name (tree decl)
 }
 
 tree
-build_va_arg (tree expr, tree type)
+build_va_arg (location_t loc, tree expr, tree type)
 {
-  return build1 (VA_ARG_EXPR, type, expr);
+  expr = build1 (VA_ARG_EXPR, type, expr);
+  SET_EXPR_LOCATION (expr, loc);
+  return expr;
 }
 
 
@@ -5183,17 +5231,18 @@ case_compare (splay_tree_key k1, splay_tree_key k2)
   return tree_int_cst_compare ((tree) k1, (tree) k2);
 }
 
-/* Process a case label for the range LOW_VALUE ... HIGH_VALUE.  If
-   LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
-   actually a `default' label.  If only HIGH_VALUE is NULL_TREE, then
-   case label was declared using the usual C/C++ syntax, rather than
-   the GNU case range extension.  CASES is a tree containing all the
-   case ranges processed so far; COND is the condition for the
-   switch-statement itself.  Returns the CASE_LABEL_EXPR created, or
-   ERROR_MARK_NODE if no CASE_LABEL_EXPR is created.  */
+/* Process a case label, located at LOC, for the range LOW_VALUE
+   ... HIGH_VALUE.  If LOW_VALUE and HIGH_VALUE are both NULL_TREE
+   then this case label is actually a `default' label.  If only
+   HIGH_VALUE is NULL_TREE, then case label was declared using the
+   usual C/C++ syntax, rather than the GNU case range extension.
+   CASES is a tree containing all the case ranges processed so far;
+   COND is the condition for the switch-statement itself.  Returns the
+   CASE_LABEL_EXPR created, or ERROR_MARK_NODE if no CASE_LABEL_EXPR
+   is created.  */
 
 tree
-c_add_case_label (splay_tree cases, tree cond, tree orig_type,
+c_add_case_label (location_t loc, splay_tree cases, tree cond, tree orig_type,
                  tree low_value, tree high_value)
 {
   tree type;
@@ -5202,7 +5251,7 @@ c_add_case_label (splay_tree cases, tree cond, tree orig_type,
   splay_tree_node node;
 
   /* Create the LABEL_DECL itself.  */
-  label = create_artificial_label ();
+  label = create_artificial_label (loc);
 
   /* If there was an error processing the switch condition, bail now
      before we get more confused.  */
@@ -5214,13 +5263,13 @@ c_add_case_label (splay_tree cases, tree cond, tree orig_type,
       || (high_value && TREE_TYPE (high_value)
          && POINTER_TYPE_P (TREE_TYPE (high_value))))
     {
-      error ("pointers are not permitted as case values");
+      error_at (loc, "pointers are not permitted as case values");
       goto error_out;
     }
 
   /* Case ranges are a GNU extension.  */
   if (high_value)
-    pedwarn (input_location, OPT_pedantic, 
+    pedwarn (loc, OPT_pedantic, 
             "range expressions in switch statements are non-standard");
 
   type = TREE_TYPE (cond);
@@ -5247,7 +5296,7 @@ c_add_case_label (splay_tree cases, tree cond, tree orig_type,
       if (tree_int_cst_equal (low_value, high_value))
        high_value = NULL_TREE;
       else if (!tree_int_cst_lt (low_value, high_value))
-       warning (0, "empty range specified");
+       warning_at (loc, 0, "empty range specified");
     }
 
   /* See if the case is in range of the type of the original testing
@@ -5307,24 +5356,26 @@ c_add_case_label (splay_tree cases, tree cond, tree orig_type,
 
       if (high_value)
        {
-         error ("duplicate (or overlapping) case value");
-         error ("%Jthis is the first entry overlapping that value", duplicate);
+         error_at (loc, "duplicate (or overlapping) case value");
+         error_at (DECL_SOURCE_LOCATION (duplicate),
+                   "this is the first entry overlapping that value");
        }
       else if (low_value)
        {
-         error ("duplicate case value") ;
-         error ("%Jpreviously used here", duplicate);
+         error_at (loc, "duplicate case value") ;
+         error_at (DECL_SOURCE_LOCATION (duplicate), "previously used here");
        }
       else
        {
-         error ("multiple default labels in one switch");
-         error ("%Jthis is the first default label", duplicate);
+         error_at (loc, "multiple default labels in one switch");
+         error_at (DECL_SOURCE_LOCATION (duplicate),
+                   "this is the first default label");
        }
       goto error_out;
     }
 
   /* Add a CASE_LABEL to the statement-tree.  */
-  case_label = add_stmt (build_case_label (low_value, high_value, label));
+  case_label = add_stmt (build_case_label (loc, low_value, high_value, label));
   /* Register this case label in the splay tree.  */
   splay_tree_insert (cases,
                     (splay_tree_key) low_value,
@@ -5338,8 +5389,8 @@ c_add_case_label (splay_tree cases, tree cond, tree orig_type,
      that just leads to duplicates and thence to failure later on.  */
   if (!cases->root)
     {
-      tree t = create_artificial_label ();
-      add_stmt (build_stmt (LABEL_EXPR, t));
+      tree t = create_artificial_label (loc);
+      add_stmt (build_stmt (loc, LABEL_EXPR, t));
     }
   return error_mark_node;
 }
@@ -8615,13 +8666,15 @@ sync_resolve_return (tree first_param, tree result)
    function should be called immediately after parsing the call expression
    before surrounding code has committed to the type of the expression.
 
+   LOC is the location of the builtin call.
+
    FUNCTION is the DECL that has been invoked; it is known to be a builtin.
    PARAMS is the argument list for the call.  The return value is non-null
    when expansion is complete, and null if normal processing should
    continue.  */
 
 tree
-resolve_overloaded_builtin (tree function, VEC(tree,gc) *params)
+resolve_overloaded_builtin (location_t loc, tree function, VEC(tree,gc) *params)
 {
   enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
   switch (DECL_BUILT_IN_CLASS (function))
@@ -8630,7 +8683,7 @@ resolve_overloaded_builtin (tree function, VEC(tree,gc) *params)
       break;
     case BUILT_IN_MD:
       if (targetm.resolve_overloaded_builtin)
-       return targetm.resolve_overloaded_builtin (function, params);
+       return targetm.resolve_overloaded_builtin (loc, function, params);
       else
        return NULL_TREE;
     default:
@@ -8668,7 +8721,7 @@ resolve_overloaded_builtin (tree function, VEC(tree,gc) *params)
          return error_mark_node;
 
        first_param = VEC_index (tree, params, 0);
-       result = build_function_call_vec (new_function, params, NULL);
+       result = build_function_call_vec (loc, new_function, params, NULL);
        if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
            && orig_code != BUILT_IN_LOCK_RELEASE_N)
          result = sync_resolve_return (first_param, result);
index b17020a..eecb189 100644 (file)
@@ -418,7 +418,7 @@ extern void push_cleanup (tree, tree, bool);
 extern tree pushdecl_top_level (tree);
 extern tree pushdecl (tree);
 extern tree build_modify_expr (location_t, tree, tree, enum tree_code,
-                              tree, tree);
+                              location_t, tree, tree);
 extern tree build_indirect_ref (location_t, tree, const char *);
 
 extern int c_expand_decl (tree);
@@ -754,7 +754,7 @@ extern const struct attribute_spec c_common_format_attribute_table[];
    TYPE_DEP indicates whether it depends on type of the function or not
    (i.e. __PRETTY_FUNCTION__).  */
 
-extern tree (*make_fname_decl) (tree, int);
+extern tree (*make_fname_decl) (location_t, tree, int);
 
 extern tree identifier_global_value (tree);
 extern void record_builtin_type (enum rid, const char *, tree);
@@ -791,8 +791,8 @@ extern tree decl_constant_value_for_optimization (tree);
 extern tree c_save_expr (tree);
 extern tree c_common_truthvalue_conversion (location_t, tree);
 extern void c_apply_type_quals_to_decl (int, tree);
-extern tree c_sizeof_or_alignof_type (tree, bool, int);
-extern tree c_alignof_expr (tree);
+extern tree c_sizeof_or_alignof_type (location_t, tree, bool, int);
+extern tree c_alignof_expr (location_t, tree);
 /* Print an error message for invalid operands to arith operation CODE.
    NOP_EXPR is used as a special case (see truthvalue_conversion).  */
 extern void binary_op_error (location_t, enum tree_code, tree, tree);
@@ -803,7 +803,7 @@ extern void constant_expression_error (tree);
 extern bool strict_aliasing_warning (tree, tree, tree);
 extern void warnings_for_convert_and_check (tree, tree, tree);
 extern tree convert_and_check (tree, tree);
-extern void overflow_warning (tree);
+extern void overflow_warning (location_t, tree);
 extern void warn_logical_operator (location_t, enum tree_code, tree,
                                   enum tree_code, tree, enum tree_code, tree);
 extern void check_main_parameter_types (tree decl);
@@ -815,8 +815,8 @@ extern void set_float_const_decimal64 (void);
 extern void clear_float_const_decimal64 (void);
 extern bool float_const_decimal64_p (void);
 
-#define c_sizeof(T)  c_sizeof_or_alignof_type (T, true, 1)
-#define c_alignof(T) c_sizeof_or_alignof_type (T, false, 1)
+#define c_sizeof(LOC, T)  c_sizeof_or_alignof_type (LOC, T, true, 1)
+#define c_alignof(LOC, T) c_sizeof_or_alignof_type (LOC, T, false, 1)
 
 /* Subroutine of build_binary_op, used for certain operations.  */
 extern tree shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwise);
@@ -841,7 +841,7 @@ extern void disable_builtin_function (const char *);
 
 extern void set_compound_literal_name (tree decl);
 
-extern tree build_va_arg (tree, tree);
+extern tree build_va_arg (location_t, tree, tree);
 
 extern unsigned int c_common_init_options (unsigned int, const char **);
 extern bool c_common_post_options (const char **);
@@ -896,9 +896,9 @@ extern void finish_file     (void);
 #define CLEAR_DECL_C_BIT_FIELD(NODE) \
   (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) = 0)
 
-extern tree do_case (tree, tree);
-extern tree build_stmt (enum tree_code, ...);
-extern tree build_case_label (tree, tree, tree);
+extern tree do_case (location_t, tree, tree);
+extern tree build_stmt (location_t, enum tree_code, ...);
+extern tree build_case_label (location_t, tree, tree, tree);
 
 /* These functions must be defined by each front-end which implements
    a variant of the C language.  They are used in c-common.c.  */
@@ -924,15 +924,16 @@ extern tree boolean_increment (enum tree_code, tree);
 
 extern int case_compare (splay_tree_key, splay_tree_key);
 
-extern tree c_add_case_label (splay_tree, tree, tree, tree, tree);
+extern tree c_add_case_label (location_t, splay_tree, tree, tree, tree, tree);
 
 extern void c_do_switch_warnings (splay_tree, location_t, tree, tree);
 
-extern tree build_function_call (tree, tree);
+extern tree build_function_call (location_t, tree, tree);
 
-extern tree build_function_call_vec (tree, VEC(tree,gc) *, VEC(tree,gc) *);
+extern tree build_function_call_vec (location_t, tree,
+                                    VEC(tree,gc) *, VEC(tree,gc) *);
 
-extern tree resolve_overloaded_builtin (tree, VEC(tree,gc) *);
+extern tree resolve_overloaded_builtin (location_t, tree, VEC(tree,gc) *);
 
 extern tree finish_label_address_expr (tree, location_t);
 
@@ -1021,7 +1022,7 @@ extern VEC(tree,gc) *make_tree_vector_copy (const VEC(tree,gc) *);
 /* In c-gimplify.c  */
 extern void c_genericize (tree);
 extern int c_gimplify_expr (tree *, gimple_seq *, gimple_seq *);
-extern tree c_build_bind_expr (tree, tree);
+extern tree c_build_bind_expr (location_t, tree, tree);
 
 /* In c-pch.c  */
 extern void pch_init (void);
@@ -1065,7 +1066,7 @@ extern void objc_declare_class (tree);
 extern void objc_declare_protocols (tree);
 extern tree objc_build_message_expr (tree);
 extern tree objc_finish_message_expr (tree, tree, tree);
-extern tree objc_build_selector_expr (tree);
+extern tree objc_build_selector_expr (location_t, tree);
 extern tree objc_build_protocol_expr (tree);
 extern tree objc_build_encode_expr (tree);
 extern tree objc_build_string_object (tree);
@@ -1089,7 +1090,7 @@ extern void objc_start_method_definition (tree);
 extern void objc_finish_method_definition (tree);
 extern void objc_add_instance_variable (tree);
 extern tree objc_build_keyword_decl (tree, tree, tree);
-extern tree objc_build_throw_stmt (tree);
+extern tree objc_build_throw_stmt (location_t, tree);
 extern void objc_begin_try_stmt (location_t, tree);
 extern tree objc_finish_try_stmt (void);
 extern void objc_begin_catch_clause (tree);
@@ -1113,15 +1114,15 @@ extern void pp_dir_change (cpp_reader *, const char *);
 extern bool check_missing_format_attribute (tree, tree);
 
 /* In c-omp.c  */
-extern tree c_finish_omp_master (tree);
-extern tree c_finish_omp_critical (tree, tree);
-extern tree c_finish_omp_ordered (tree);
-extern void c_finish_omp_barrier (void);
-extern tree c_finish_omp_atomic (enum tree_code, tree, tree);
-extern void c_finish_omp_flush (void);
-extern void c_finish_omp_taskwait (void);
+extern tree c_finish_omp_master (location_t, tree);
+extern tree c_finish_omp_critical (location_t, tree, tree);
+extern tree c_finish_omp_ordered (location_t, tree);
+extern void c_finish_omp_barrier (location_t);
+extern tree c_finish_omp_atomic (location_t, enum tree_code, tree, tree);
+extern void c_finish_omp_flush (location_t);
+extern void c_finish_omp_taskwait (location_t);
 extern tree c_finish_omp_for (location_t, tree, tree, tree, tree, tree, tree);
-extern void c_split_parallel_clauses (tree, tree *, tree *);
+extern void c_split_parallel_clauses (location_t, tree, tree *, tree *);
 extern enum omp_clause_default_kind c_omp_predetermined_sharing (tree);
 
 /* Not in c-omp.c; provided by the front end.  */
index 9159b3c..03d6dbd 100644 (file)
@@ -443,7 +443,7 @@ static bool next_is_function_body;
 
 /* Forward declarations.  */
 static tree lookup_name_in_scope (tree, struct c_scope *);
-static tree c_make_fname_decl (tree, int);
+static tree c_make_fname_decl (location_t, tree, int);
 static tree grokdeclarator (const struct c_declarator *,
                            struct c_declspecs *,
                            enum decl_context, bool, tree *, tree *, tree *,
@@ -584,7 +584,8 @@ c_finish_incomplete_decl (tree decl)
          && !DECL_EXTERNAL (decl)
          && TYPE_DOMAIN (type) == 0)
        {
-         warning (0, "array %q+D assumed to have one element", decl);
+         warning_at (DECL_SOURCE_LOCATION (decl),
+                     0, "array %q+D assumed to have one element", decl);
 
          complete_array_type (&TREE_TYPE (decl), NULL_TREE, true);
 
@@ -843,7 +844,8 @@ pop_scope (void)
     context = current_function_decl;
   else if (scope == file_scope)
     {
-      tree file_decl = build_decl (TRANSLATION_UNIT_DECL, 0, 0);
+      tree file_decl = build_decl (UNKNOWN_LOCATION,
+                                  TRANSLATION_UNIT_DECL, 0, 0);
       TREE_CHAIN (file_decl) = all_translation_units;
       all_translation_units = file_decl;
       context = file_decl;
@@ -1089,13 +1091,14 @@ pop_file_scope (void)
 \f
 /* Push a definition or a declaration of struct, union or enum tag "name".
    "type" should be the type node.
-   We assume that the tag "name" is not already defined.
+   We assume that the tag "name" is not already defined, and has a location
+   of LOC.
 
    Note that the definition may really be just a forward reference.
    In that case, the TYPE_SIZE will be zero.  */
 
 static void
-pushtag (tree name, tree type, location_t loc)
+pushtag (location_t loc, tree name, tree type)
 {
   /* Record the identifier as the type's name if it has none.  */
   if (name && !TYPE_NAME (type))
@@ -1109,7 +1112,8 @@ pushtag (tree name, tree type, location_t loc)
      us a convenient place to record the "scope start" address for the
      tagged type.  */
 
-  TYPE_STUB_DECL (type) = pushdecl (build_decl (TYPE_DECL, NULL_TREE, type));
+  TYPE_STUB_DECL (type) = pushdecl (build_decl (loc,
+                                               TYPE_DECL, NULL_TREE, type));
 
   /* An approximation for now, so we can tell this is a function-scope tag.
      This will be updated in pop_scope.  */
@@ -2457,11 +2461,11 @@ implicit_decl_warning (tree id, tree olddecl)
     }
 }
 
-/* Generate an implicit declaration for identifier FUNCTIONID as a
+/* Generate an implicit declaration for identifier FUNCTIONID at LOC as a
    function of type int ().  */
 
 tree
-implicitly_declare (tree functionid)
+implicitly_declare (location_t loc, tree functionid)
 {
   struct c_binding *b;
   tree decl = 0;
@@ -2514,8 +2518,8 @@ implicitly_declare (tree functionid)
                                                      (TREE_TYPE (decl)));
              if (!comptypes (newtype, TREE_TYPE (decl)))
                {
-                 warning (0, "incompatible implicit declaration of built-in"
-                          " function %qD", decl);
+                 warning_at (loc, 0, "incompatible implicit declaration of "
+                             "built-in function %qD", decl);
                  newtype = TREE_TYPE (decl);
                }
            }
@@ -2523,8 +2527,7 @@ implicitly_declare (tree functionid)
            {
              if (!comptypes (newtype, TREE_TYPE (decl)))
                {
-                 error ("incompatible implicit declaration of function %qD",
-                        decl);
+                 error_at (loc, "incompatible implicit declaration of function %qD", decl);
                  locate_old_decl (decl);
                }
            }
@@ -2538,7 +2541,7 @@ implicitly_declare (tree functionid)
     }
 
   /* Not seen before.  */
-  decl = build_decl (FUNCTION_DECL, functionid, default_function_type);
+  decl = build_decl (loc, FUNCTION_DECL, functionid, default_function_type);
   DECL_EXTERNAL (decl) = 1;
   TREE_PUBLIC (decl) = 1;
   C_DECL_IMPLICIT (decl) = 1;
@@ -2570,7 +2573,7 @@ implicitly_declare (tree functionid)
    in an appropriate scope, which will suppress further errors for the
    same identifier.  The error message should be given location LOC.  */
 void
-undeclared_variable (tree id, location_t loc)
+undeclared_variable (location_t loc, tree id)
 {
   static bool already = false;
   struct c_scope *scope;
@@ -2603,13 +2606,12 @@ undeclared_variable (tree id, location_t loc)
    LABEL_DECL with all the proper frills.  */
 
 static tree
-make_label (tree name, location_t location)
+make_label (location_t location, tree name)
 {
-  tree label = build_decl (LABEL_DECL, name, void_type_node);
+  tree label = build_decl (location, LABEL_DECL, name, void_type_node);
 
   DECL_CONTEXT (label) = current_function_decl;
   DECL_MODE (label) = VOIDmode;
-  DECL_SOURCE_LOCATION (label) = location;
 
   return label;
 }
@@ -2646,7 +2648,7 @@ lookup_label (tree name)
     }
 
   /* No label binding for that identifier; make one.  */
-  label = make_label (name, input_location);
+  label = make_label (input_location, name);
 
   /* Ordinary labels go in the current function scope.  */
   bind (name, label, current_function_scope,
@@ -2675,7 +2677,7 @@ declare_label (tree name)
       return b->decl;
     }
 
-  label = make_label (name, input_location);
+  label = make_label (input_location, name);
   C_DECLARED_LABEL_FLAG (label) = 1;
 
   /* Declared labels go in the current scope.  */
@@ -2704,7 +2706,7 @@ define_label (location_t location, tree name)
          || (DECL_CONTEXT (label) != current_function_decl
              && C_DECLARED_LABEL_FLAG (label))))
     {
-      error ("%Hduplicate label %qD", &location, label);
+      error_at (location, "duplicate label %qD", label);
       locate_old_decl (label);
       return 0;
     }
@@ -2714,16 +2716,16 @@ define_label (location_t location, tree name)
         but not defined.  Update its location to point to this
         definition.  */
       if (C_DECL_UNDEFINABLE_STMT_EXPR (label))
-       error ("%Jjump into statement expression", label);
+       error_at (location, "jump into statement expression");
       if (C_DECL_UNDEFINABLE_VM (label))
-       error ("%Jjump into scope of identifier with variably modified type",
-              label);
+       error_at (location,
+                 "jump into scope of identifier with variably modified type");
       DECL_SOURCE_LOCATION (label) = location;
     }
   else
     {
       /* No label binding for that identifier; make one.  */
-      label = make_label (name, location);
+      label = make_label (location, name);
 
       /* Ordinary labels go in the current function scope.  */
       bind (name, label, current_function_scope,
@@ -2731,8 +2733,9 @@ define_label (location_t location, tree name)
     }
 
   if (!in_system_header && lookup_name (name))
-    warning (OPT_Wtraditional, "%Htraditional C lacks a separate namespace "
-            "for labels, identifier %qE conflicts", &location, name);
+    warning_at (location, OPT_Wtraditional,
+               "traditional C lacks a separate namespace "
+               "for labels, identifier %qE conflicts", name);
 
   nlist_se = XOBNEW (&parser_obstack, struct c_label_list);
   nlist_se->next = label_context_stack_se->labels_def;
@@ -2882,7 +2885,7 @@ c_init_decl_processing (void)
   truthvalue_false_node = integer_zero_node;
 
   /* Even in C99, which has a real boolean type.  */
-  pushdecl (build_decl (TYPE_DECL, get_identifier ("_Bool"),
+  pushdecl (build_decl (UNKNOWN_LOCATION, TYPE_DECL, get_identifier ("_Bool"),
                        boolean_type_node));
 
   input_location = save_loc;
@@ -2893,15 +2896,16 @@ c_init_decl_processing (void)
   start_fname_decls ();
 }
 
-/* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
-   decl, NAME is the initialization string and TYPE_DEP indicates whether
-   NAME depended on the type of the function.  As we don't yet implement
-   delayed emission of static data, we mark the decl as emitted
-   so it is not placed in the output.  Anything using it must therefore pull
-   out the STRING_CST initializer directly.  FIXME.  */
+/* Create the VAR_DECL at LOC for __FUNCTION__ etc. ID is the name to
+   give the decl, NAME is the initialization string and TYPE_DEP
+   indicates whether NAME depended on the type of the function.  As we
+   don't yet implement delayed emission of static data, we mark the
+   decl as emitted so it is not placed in the output.  Anything using
+   it must therefore pull out the STRING_CST initializer directly.
+   FIXME.  */
 
 static tree
-c_make_fname_decl (tree id, int type_dep)
+c_make_fname_decl (location_t loc, tree id, int type_dep)
 {
   const char *name = fname_as_string (type_dep);
   tree decl, type, init;
@@ -2911,7 +2915,7 @@ c_make_fname_decl (tree id, int type_dep)
                           build_index_type (size_int (length)));
   type = c_build_qualified_type (type, TYPE_QUAL_CONST);
 
-  decl = build_decl (VAR_DECL, id, type);
+  decl = build_decl (loc, VAR_DECL, id, type);
 
   TREE_STATIC (decl) = 1;
   TREE_READONLY (decl) = 1;
@@ -2940,7 +2944,7 @@ c_make_fname_decl (tree id, int type_dep)
            /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
     }
 
-  finish_decl (decl, init, NULL_TREE, NULL_TREE);
+  finish_decl (decl, loc, init, NULL_TREE, NULL_TREE);
 
   return decl;
 }
@@ -3078,7 +3082,7 @@ shadow_tag_warned (const struct c_declspecs *declspecs, int warned)
              if (t == 0)
                {
                  t = make_node (code);
-                 pushtag (name, t, input_location);
+                 pushtag (input_location, name, t);
                }
            }
        }
@@ -3174,21 +3178,24 @@ quals_from_declspecs (const struct c_declspecs *specs)
   return quals;
 }
 
-/* Construct an array declarator.  EXPR is the expression inside [],
-   or NULL_TREE.  QUALS are the type qualifiers inside the [] (to be
-   applied to the pointer to which a parameter array is converted).
-   STATIC_P is true if "static" is inside the [], false otherwise.
-   VLA_UNSPEC_P is true if the array is [*], a VLA of unspecified
-   length which is nevertheless a complete type, false otherwise.  The
-   field for the contained declarator is left to be filled in by
-   set_array_declarator_inner.  */
+/* Construct an array declarator.  LOC is the location of the
+   beginning of the array (usually the opening brace).  EXPR is the
+   expression inside [], or NULL_TREE.  QUALS are the type qualifiers
+   inside the [] (to be applied to the pointer to which a parameter
+   array is converted).  STATIC_P is true if "static" is inside the
+   [], false otherwise.  VLA_UNSPEC_P is true if the array is [*], a
+   VLA of unspecified length which is nevertheless a complete type,
+   false otherwise.  The field for the contained declarator is left to
+   be filled in by set_array_declarator_inner.  */
 
 struct c_declarator *
-build_array_declarator (tree expr, struct c_declspecs *quals, bool static_p,
+build_array_declarator (location_t loc,
+                       tree expr, struct c_declspecs *quals, bool static_p,
                        bool vla_unspec_p)
 {
   struct c_declarator *declarator = XOBNEW (&parser_obstack,
                                            struct c_declarator);
+  declarator->id_loc = loc;
   declarator->kind = cdk_array;
   declarator->declarator = 0;
   declarator->u.array.dimen = expr;
@@ -3207,11 +3214,11 @@ build_array_declarator (tree expr, struct c_declspecs *quals, bool static_p,
   if (!flag_isoc99)
     {
       if (static_p || quals != NULL)
-       pedwarn (input_location, OPT_pedantic,
+       pedwarn (loc, OPT_pedantic,
                 "ISO C90 does not support %<static%> or type "
                 "qualifiers in parameter array declarators");
       if (vla_unspec_p)
-       pedwarn (input_location, OPT_pedantic,
+       pedwarn (loc, OPT_pedantic,
                 "ISO C90 does not support %<[*]%> array declarators");
     }
   if (vla_unspec_p)
@@ -3219,7 +3226,8 @@ build_array_declarator (tree expr, struct c_declspecs *quals, bool static_p,
       if (!current_scope->parm_flag)
        {
          /* C99 6.7.5.2p4 */
-         error ("%<[*]%> not allowed in other than function prototype scope");
+         error_at (loc, "%<[*]%> not allowed in other than "
+                   "function prototype scope");
          declarator->u.array.vla_unspec_p = false;
          return NULL;
        }
@@ -3514,10 +3522,13 @@ c_maybe_initialize_eh (void)
    install its initial value.
    If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
    If the length of an array type is not known before,
-   it must be determined now, from the initial value, or it is an error.  */
+   it must be determined now, from the initial value, or it is an error.
+
+   INIT_LOC is the location of the initial value.  */
 
 void
-finish_decl (tree decl, tree init, tree origtype, tree asmspec_tree)
+finish_decl (tree decl, location_t init_loc, tree init,
+            tree origtype, tree asmspec_tree)
 {
   tree type;
   bool was_incomplete = (DECL_SIZE (decl) == 0);
@@ -3539,7 +3550,7 @@ finish_decl (tree decl, tree init, tree origtype, tree asmspec_tree)
     init = 0;
 
   if (init)
-    store_init_value (decl, init, origtype);
+    store_init_value (init_loc, decl, init, origtype);
 
   if (c_dialect_objc () && (TREE_CODE (decl) == VAR_DECL
                            || TREE_CODE (decl) == FUNCTION_DECL
@@ -3747,7 +3758,8 @@ finish_decl (tree decl, tree init, tree origtype, tree asmspec_tree)
                  add_stmt (bind);
                  BIND_EXPR_BODY (bind) = push_stmt_list ();
                }
-             add_stmt (build_stmt (DECL_EXPR, decl));
+             add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl),
+                                   DECL_EXPR, decl));
            }
        }
 
@@ -3772,7 +3784,7 @@ finish_decl (tree decl, tree init, tree origtype, tree asmspec_tree)
     {
       if (!DECL_FILE_SCOPE_P (decl)
          && variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
-       add_stmt (build_stmt (DECL_EXPR, decl));
+       add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl));
 
       rest_of_decl_compilation (decl, DECL_FILE_SCOPE_P (decl), 0);
     }
@@ -3798,7 +3810,8 @@ finish_decl (tree decl, tree init, tree origtype, tree asmspec_tree)
          cleanup = build_unary_op (input_location, ADDR_EXPR, decl, 0);
          vec = VEC_alloc (tree, gc, 1);
          VEC_quick_push (tree, vec, cleanup);
-         cleanup = build_function_call_vec (cleanup_decl, vec, NULL);
+         cleanup = build_function_call_vec (DECL_SOURCE_LOCATION (decl),
+                                            cleanup_decl, vec, NULL);
          VEC_free (tree, gc, vec);
 
          /* Don't warn about decl unused; the cleanup uses it.  */
@@ -3842,7 +3855,7 @@ push_parm_decl (const struct c_parm *parm)
 
   decl = pushdecl (decl);
 
-  finish_decl (decl, NULL_TREE, NULL_TREE, NULL_TREE);
+  finish_decl (decl, input_location, NULL_TREE, NULL_TREE, NULL_TREE);
 }
 
 /* Mark all the parameter declarations to date as forward decls.
@@ -3867,12 +3880,12 @@ mark_forward_parm_decls (void)
 \f
 /* Build a COMPOUND_LITERAL_EXPR.  TYPE is the type given in the compound
    literal, which may be an incomplete array type completed by the
-   initializer; INIT is a CONSTRUCTOR that initializes the compound
+   initializer; INIT is a CONSTRUCTOR at LOC that initializes the compound
    literal.  NON_CONST is true if the initializers contain something
    that cannot occur in a constant expression.  */
 
 tree
-build_compound_literal (tree type, tree init, bool non_const)
+build_compound_literal (location_t loc, tree type, tree init, bool non_const)
 {
   /* We do not use start_decl here because we have a type, not a declarator;
      and do not use finish_decl because the decl should be stored inside
@@ -3884,7 +3897,7 @@ build_compound_literal (tree type, tree init, bool non_const)
   if (type == error_mark_node)
     return error_mark_node;
 
-  decl = build_decl (VAR_DECL, NULL_TREE, type);
+  decl = build_decl (loc, VAR_DECL, NULL_TREE, type);
   DECL_EXTERNAL (decl) = 0;
   TREE_PUBLIC (decl) = 0;
   TREE_STATIC (decl) = (current_scope == file_scope);
@@ -3892,7 +3905,7 @@ build_compound_literal (tree type, tree init, bool non_const)
   TREE_USED (decl) = 1;
   TREE_TYPE (decl) = type;
   TREE_READONLY (decl) = TYPE_READONLY (type);
-  store_init_value (decl, init, NULL_TREE);
+  store_init_value (loc, decl, init, NULL_TREE);
 
   if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
     {
@@ -3907,7 +3920,7 @@ build_compound_literal (tree type, tree init, bool non_const)
   if (type == error_mark_node || !COMPLETE_TYPE_P (type))
     return error_mark_node;
 
-  stmt = build_stmt (DECL_EXPR, decl);
+  stmt = build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl);
   complit = build1 (COMPOUND_LITERAL_EXPR, type, stmt);
   TREE_SIDE_EFFECTS (complit) = 1;
 
@@ -3938,7 +3951,7 @@ build_compound_literal (tree type, tree init, bool non_const)
    is valid for C++.  */
 
 void
-check_compound_literal_type (struct c_type_name *type_name, location_t loc)
+check_compound_literal_type (location_t loc, struct c_type_name *type_name)
 {
   if (warn_cxx_compat && type_name->specs->tag_defined_p)
     warning_at (loc, OPT_Wc___compat,
@@ -4202,6 +4215,7 @@ grokdeclarator (const struct c_declarator *declarator,
   bool bitfield = width != NULL;
   tree element_type;
   struct c_arg_info *arg_info = 0;
+  location_t loc = UNKNOWN_LOCATION;
   const char *errmsg;
   tree expr_dummy;
   bool expr_const_operands_dummy;
@@ -4225,8 +4239,11 @@ grokdeclarator (const struct c_declarator *declarator,
     while (decl)
       switch (decl->kind)
        {
-       case cdk_function:
        case cdk_array:
+         loc = decl->id_loc;
+         /* FALL THRU.  */
+
+       case cdk_function:
        case cdk_pointer:
          funcdef_syntax = (decl->kind == cdk_function);
          decl = decl->declarator;
@@ -4237,6 +4254,7 @@ grokdeclarator (const struct c_declarator *declarator,
          break;
 
        case cdk_id:
+         loc = decl->id_loc;
          if (decl->u.id)
            name = decl->u.id;
          decl = 0;
@@ -4275,9 +4293,9 @@ grokdeclarator (const struct c_declarator *declarator,
       && variably_modified_type_p (type, NULL_TREE))
     {
       if (name)
-       error ("variably modified %qE at file scope", name);
+       error_at (loc, "variably modified %qE at file scope", name);
       else
-       error ("variably modified field at file scope");
+       error_at (loc, "variably modified field at file scope");
       type = integer_type_node;
     }
 
@@ -4296,7 +4314,7 @@ grokdeclarator (const struct c_declarator *declarator,
       else
        {
          if (name)
-           pedwarn_c99 (input_location, flag_isoc99 ? 0 : OPT_Wimplicit_int, 
+           pedwarn_c99 (loc, flag_isoc99 ? 0 : OPT_Wimplicit_int, 
                         "type defaults to %<int%> in declaration of %qE",
                         name);
          else
@@ -4330,11 +4348,11 @@ grokdeclarator (const struct c_declarator *declarator,
   if (pedantic && !flag_isoc99)
     {
       if (constp > 1)
-       pedwarn (input_location, OPT_pedantic, "duplicate %<const%>");
+       pedwarn (loc, OPT_pedantic, "duplicate %<const%>");
       if (restrictp > 1)
-       pedwarn (input_location, OPT_pedantic, "duplicate %<restrict%>");
+       pedwarn (loc, OPT_pedantic, "duplicate %<restrict%>");
       if (volatilep > 1)
-       pedwarn (input_location, OPT_pedantic, "duplicate %<volatile%>");
+       pedwarn (loc, OPT_pedantic, "duplicate %<volatile%>");
     }
   if (!flag_gen_aux_info && (TYPE_QUALS (element_type)))
     type = TYPE_MAIN_VARIANT (type);
@@ -4352,15 +4370,15 @@ grokdeclarator (const struct c_declarator *declarator,
          || storage_class == csc_typedef))
     {
       if (storage_class == csc_auto)
-       pedwarn (input_location
+       pedwarn (loc
                 (current_scope == file_scope) ? 0 : OPT_pedantic, 
                 "function definition declared %<auto%>");
       if (storage_class == csc_register)
-       error ("function definition declared %<register%>");
+       error_at (loc, "function definition declared %<register%>");
       if (storage_class == csc_typedef)
-       error ("function definition declared %<typedef%>");
+       error_at (loc, "function definition declared %<typedef%>");
       if (threadp)
-       error ("function definition declared %<__thread%>");
+       error_at (loc, "function definition declared %<__thread%>");
       threadp = false;
       if (storage_class == csc_auto
          || storage_class == csc_register
@@ -4377,19 +4395,20 @@ grokdeclarator (const struct c_declarator *declarator,
            {
            case FIELD:
              if (name)
-               error ("storage class specified for structure field %qE",
-                      name);
+               error_at (loc, "storage class specified for structure "
+                         "field %qE", name);
              else
-               error ("storage class specified for structure field");
+               error_at (loc, "storage class specified for structure field");
              break;
            case PARM:
              if (name)
-               error ("storage class specified for parameter %qE", name);
+               error_at (loc, "storage class specified for parameter %qE",
+                         name);
              else
-               error ("storage class specified for unnamed parameter");
+               error_at (loc, "storage class specified for unnamed parameter");
              break;
            default:
-             error ("storage class specified for typename");
+             error_at (loc, "storage class specified for typename");
              break;
            }
          storage_class = csc_none;
@@ -4406,15 +4425,17 @@ grokdeclarator (const struct c_declarator *declarator,
            /* It is fine to have 'extern const' when compiling at C
               and C++ intersection.  */
            if (!(warn_cxx_compat && constp))
-             warning (0, "%qE initialized and declared %<extern%>", name);
+             warning_at (loc, 0, "%qE initialized and declared %<extern%>",
+                        name);
          }
       else
-       error ("%qE has both %<extern%> and initializer", name);
+       error_at (loc, "%qE has both %<extern%> and initializer", name);
     }
   else if (current_scope == file_scope)
     {
       if (storage_class == csc_auto)
-       error ("file-scope declaration of %qE specifies %<auto%>", name);
+       error_at (loc, "file-scope declaration of %qE specifies %<auto%>",
+                 name);
       if (pedantic && storage_class == csc_register)
        pedwarn (input_location, OPT_pedantic,
                 "file-scope declaration of %qE specifies %<register%>", name);
@@ -4422,12 +4443,12 @@ grokdeclarator (const struct c_declarator *declarator,
   else
     {
       if (storage_class == csc_extern && funcdef_flag)
-       error ("nested function %qE declared %<extern%>", name);
+       error_at (loc, "nested function %qE declared %<extern%>", name);
       else if (threadp && storage_class == csc_none)
        {
-         error ("function-scope %qE implicitly auto and declared "
-                "%<__thread%>",
-                name);
+         error_at (loc, "function-scope %qE implicitly auto and declared "
+                   "%<__thread%>",
+                   name);
          threadp = false;
        }
     }
@@ -4472,7 +4493,7 @@ grokdeclarator (const struct c_declarator *declarator,
          /* Only the innermost declarator (making a parameter be of
             array type which is converted to pointer type)
             may have static or type qualifiers.  */
-         error ("static or type qualifiers in non-parameter array declarator");
+         error_at (loc, "static or type qualifiers in non-parameter array declarator");
          array_ptr_quals = TYPE_UNQUALIFIED;
          array_ptr_attrs = NULL_TREE;
          array_parm_static = 0;
@@ -4520,23 +4541,25 @@ grokdeclarator (const struct c_declarator *declarator,
            if (VOID_TYPE_P (type))
              {
                if (name)
-                 error ("declaration of %qE as array of voids", name);
+                 error_at (loc, "declaration of %qE as array of voids", name);
                else
-                 error ("declaration of type name as array of voids");
+                 error_at (loc, "declaration of type name as array of voids");
                type = error_mark_node;
              }
 
            if (TREE_CODE (type) == FUNCTION_TYPE)
              {
                if (name)
-                 error ("declaration of %qE as array of functions", name);
+                 error_at (loc, "declaration of %qE as array of functions",
+                           name);
                else
-                 error ("declaration of type name as array of functions");
+                 error_at (loc, "declaration of type name as array of "
+                           "functions");
                type = error_mark_node;
              }
 
            if (pedantic && !in_system_header && flexible_array_type_p (type))
-             pedwarn (input_location, OPT_pedantic,
+             pedwarn (loc, OPT_pedantic,
                       "invalid use of structure with flexible array member");
 
            if (size == error_mark_node)
@@ -4563,9 +4586,11 @@ grokdeclarator (const struct c_declarator *declarator,
                if (!INTEGRAL_TYPE_P (TREE_TYPE (size)))
                  {
                    if (name)
-                     error ("size of array %qE has non-integer type", name);
+                     error_at (loc, "size of array %qE has non-integer type",
+                               name);
                    else
-                     error ("size of unnamed array has non-integer type");
+                     error_at (loc,
+                               "size of unnamed array has non-integer type");
                    size = integer_one_node;
                  }
 
@@ -4574,10 +4599,10 @@ grokdeclarator (const struct c_declarator *declarator,
                if (pedantic && size_maybe_const && integer_zerop (size))
                  {
                    if (name)
-                     pedwarn (input_location, OPT_pedantic,
+                     pedwarn (loc, OPT_pedantic,
                               "ISO C forbids zero-size array %qE", name);
                    else
-                     pedwarn (input_location, OPT_pedantic,
+                     pedwarn (loc, OPT_pedantic,
                               "ISO C forbids zero-size array");
                  }
 
@@ -4587,9 +4612,9 @@ grokdeclarator (const struct c_declarator *declarator,
                    if (tree_int_cst_sgn (size) < 0)
                      {
                        if (name)
-                         error ("size of array %qE is negative", name);
+                         error_at (loc, "size of array %qE is negative", name);
                        else
-                         error ("size of unnamed array is negative");
+                         error_at (loc, "size of unnamed array is negative");
                        size = integer_one_node;
                      }
                    /* Handle a size folded to an integer constant but
@@ -4614,7 +4639,7 @@ grokdeclarator (const struct c_declarator *declarator,
                else if ((decl_context == NORMAL || decl_context == FIELD)
                         && current_scope == file_scope)
                  {
-                   error ("variably modified %qE at file scope", name);
+                   error_at (loc, "variably modified %qE at file scope", name);
                    size = integer_one_node;
                  }
                else
@@ -4665,9 +4690,10 @@ grokdeclarator (const struct c_declarator *declarator,
                        && TREE_OVERFLOW (itype))
                      {
                        if (name)
-                         error ("size of array %qE is too large", name);
+                         error_at (loc, "size of array %qE is too large",
+                                   name);
                        else
-                         error ("size of unnamed array is too large");
+                         error_at (loc, "size of unnamed array is too large");
                        type = error_mark_node;
                        continue;
                      }
@@ -4703,7 +4729,7 @@ grokdeclarator (const struct c_declarator *declarator,
                  }
                if (flexible_array_member
                    && pedantic && !flag_isoc99 && !in_system_header)
-                 pedwarn (input_location, OPT_pedantic,
+                 pedwarn (loc, OPT_pedantic,
                           "ISO C90 does not support flexible array members");
 
                /* ISO C99 Flexible array members are effectively
@@ -4738,7 +4764,7 @@ grokdeclarator (const struct c_declarator *declarator,
             /* Complain about arrays of incomplete types.  */
            if (!COMPLETE_TYPE_P (type))
              {
-               error ("array type has incomplete element type");
+               error_at (loc, "array type has incomplete element type");
                type = error_mark_node;
              }
            else
@@ -4788,7 +4814,7 @@ grokdeclarator (const struct c_declarator *declarator,
                    || array_ptr_attrs != NULL_TREE
                    || array_parm_static))
              {
-               error ("static or type qualifiers in non-parameter array declarator");
+               error_at (loc, "static or type qualifiers in non-parameter array declarator");
                array_ptr_quals = TYPE_UNQUALIFIED;
                array_ptr_attrs = NULL_TREE;
                array_parm_static = 0;
@@ -4821,19 +4847,21 @@ grokdeclarator (const struct c_declarator *declarator,
            if (TREE_CODE (type) == FUNCTION_TYPE)
              {
                if (name)
-                 error ("%qE declared as function returning a function",
-                        name);
+                 error_at (loc, "%qE declared as function returning a "
+                                "function", name);
                else
-                 error ("type name declared as function "
-                        "returning a function");
+                 error_at (loc, "type name declared as function "
+                           "returning a function");
                type = integer_type_node;
              }
            if (TREE_CODE (type) == ARRAY_TYPE)
              {
                if (name)
-                 error ("%qE declared as function returning an array", name);
+                 error_at (loc, "%qE declared as function returning an array",
+                           name);
                else
-                 error ("type name declared as function returning an array");
+                 error_at (loc, "type name declared as function returning "
+                           "an array");
                type = integer_type_node;
              }
            errmsg = targetm.invalid_return_type (type);
@@ -4861,10 +4889,10 @@ grokdeclarator (const struct c_declarator *declarator,
                   function definitions in ISO C; GCC used to used
                   them for noreturn functions.  */
                if (VOID_TYPE_P (type) && really_funcdef)
-                 pedwarn (input_location, 0,
+                 pedwarn (loc, 0,
                           "function definition has qualified void return type");
                else
-                 warning (OPT_Wignored_qualifiers,
+                 warning_at (loc, OPT_Wignored_qualifiers,
                           "type qualifiers ignored on function return type");
 
                type = c_build_qualified_type (type, type_quals);
@@ -4894,7 +4922,7 @@ grokdeclarator (const struct c_declarator *declarator,
 
            if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
                && type_quals)
-             pedwarn (input_location, OPT_pedantic,
+             pedwarn (loc, OPT_pedantic,
                       "ISO C forbids qualified function types");
            if (type_quals)
              type = c_build_qualified_type (type, type_quals);
@@ -4927,10 +4955,10 @@ grokdeclarator (const struct c_declarator *declarator,
                && (decl_context == NORMAL || decl_context == FIELD)
                && variably_modified_type_p (type, NULL_TREE))
              {
-               tree decl = build_decl (TYPE_DECL, NULL_TREE, type);
+               tree decl = build_decl (loc, TYPE_DECL, NULL_TREE, type);
                DECL_ARTIFICIAL (decl) = 1;
                pushdecl (decl);
-               finish_decl (decl, NULL_TREE, NULL_TREE, NULL_TREE);
+               finish_decl (decl, loc, NULL_TREE, NULL_TREE, NULL_TREE);
                TYPE_NAME (type) = decl;
              }
 
@@ -4964,9 +4992,9 @@ grokdeclarator (const struct c_declarator *declarator,
       && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
     {
       if (name)
-       error ("size of array %qE is too large", name);
+       error_at (loc, "size of array %qE is too large", name);
       else
-       error ("size of unnamed array is too large");
+       error_at (loc, "size of unnamed array is too large");
       /* If we proceed with the array type as it is, we'll eventually
         crash in tree_low_cst().  */
       type = error_mark_node;
@@ -4979,16 +5007,16 @@ grokdeclarator (const struct c_declarator *declarator,
       tree decl;
       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
          && type_quals)
-       pedwarn (input_location, OPT_pedantic,
+       pedwarn (loc, OPT_pedantic,
                 "ISO C forbids qualified function types");
       if (type_quals)
        type = c_build_qualified_type (type, type_quals);
-      decl = build_decl (TYPE_DECL, declarator->u.id, type);
-      DECL_SOURCE_LOCATION (decl) = declarator->id_loc;
+      decl = build_decl (declarator->id_loc,
+                        TYPE_DECL, declarator->u.id, type);
       if (declspecs->explicit_signed_p)
        C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
       if (declspecs->inline_p)
-       pedwarn (input_location, 0,"typedef %q+D declared %<inline%>", decl);
+       pedwarn (loc, 0,"typedef %q+D declared %<inline%>", decl);
 
       if (warn_cxx_compat && declarator->u.id != NULL_TREE)
        {
@@ -5023,7 +5051,7 @@ grokdeclarator (const struct c_declarator *declarator,
                  && !declspecs->inline_p);
       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
          && type_quals)
-       pedwarn (input_location, OPT_pedantic,
+       pedwarn (loc, OPT_pedantic,
                 "ISO C forbids const or volatile function types");
       if (type_quals)
        type = c_build_qualified_type (type, type_quals);
@@ -5034,8 +5062,8 @@ grokdeclarator (const struct c_declarator *declarator,
       && variably_modified_type_p (type, NULL_TREE))
     {
       /* C99 6.7.2.1p8 */
-      pedwarn (input_location, OPT_pedantic, 
-              "a member of a structure or union cannot have a variably modified type");
+      pedwarn (loc, OPT_pedantic, "a member of a structure or union cannot "
+              "have a variably modified type");
     }
 
   /* Aside from typedefs and type names (handle above),
@@ -5051,7 +5079,7 @@ grokdeclarator (const struct c_declarator *declarator,
                    && !(storage_class == csc_static
                         || storage_class == csc_register)))))
     {
-      error ("variable or field %qE declared void", name);
+      error_at (loc, "variable or field %qE declared void", name);
       type = integer_type_node;
     }
 
@@ -5081,15 +5109,15 @@ grokdeclarator (const struct c_declarator *declarator,
 
            /* We don't yet implement attributes in this context.  */
            if (array_ptr_attrs != NULL_TREE)
-             warning (OPT_Wattributes,
-                      "attributes in parameter array declarator ignored");
+             warning_at (loc, OPT_Wattributes,
+                         "attributes in parameter array declarator ignored");
 
            size_varies = 0;
          }
        else if (TREE_CODE (type) == FUNCTION_TYPE)
          {
            if (type_quals)
-             pedwarn (input_location, OPT_pedantic,
+             pedwarn (loc, OPT_pedantic,
                       "ISO C forbids qualified function types");
            if (type_quals)
              type = c_build_qualified_type (type, type_quals);
@@ -5099,8 +5127,8 @@ grokdeclarator (const struct c_declarator *declarator,
        else if (type_quals)
          type = c_build_qualified_type (type, type_quals);
 
-       decl = build_decl (PARM_DECL, declarator->u.id, type);
-       DECL_SOURCE_LOCATION (decl) = declarator->id_loc;
+       decl = build_decl (declarator->id_loc,
+                          PARM_DECL, declarator->u.id, type);
        if (size_varies)
          C_DECL_VARIABLE_SIZE (decl) = 1;
 
@@ -5116,7 +5144,7 @@ grokdeclarator (const struct c_declarator *declarator,
 
        DECL_ARG_TYPE (decl) = promoted_type;
        if (declspecs->inline_p)
-         pedwarn (input_location, 0, "parameter %q+D declared %<inline%>", decl);
+         pedwarn (loc, 0, "parameter %q+D declared %<inline%>", decl);
       }
     else if (decl_context == FIELD)
       {
@@ -5129,21 +5157,21 @@ grokdeclarator (const struct c_declarator *declarator,
 
        if (TREE_CODE (type) == FUNCTION_TYPE)
          {
-           error ("field %qE declared as a function", name);
+           error_at (loc, "field %qE declared as a function", name);
            type = build_pointer_type (type);
          }
        else if (TREE_CODE (type) != ERROR_MARK
                 && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type))
          {
            if (name)
-             error ("field %qE has incomplete type", name);
+             error_at (loc, "field %qE has incomplete type", name);
            else
-             error ("unnamed field has incomplete type");
+             error_at (loc, "unnamed field has incomplete type");
            type = error_mark_node;
          }
        type = c_build_qualified_type (type, type_quals);
-       decl = build_decl (FIELD_DECL, declarator->u.id, type);
-       DECL_SOURCE_LOCATION (decl) = declarator->id_loc;
+       decl = build_decl (declarator->id_loc,
+                          FIELD_DECL, declarator->u.id, type);
        DECL_NONADDRESSABLE_P (decl) = bitfield;
        if (bitfield && !declarator->u.id)
          TREE_NO_WARNING (decl) = 1;
@@ -5155,7 +5183,7 @@ grokdeclarator (const struct c_declarator *declarator,
       {
        if (storage_class == csc_register || threadp)
          {
-           error ("invalid storage class for function %qE", name);
+           error_at (loc, "invalid storage class for function %qE", name);
           }
        else if (current_scope != file_scope)
          {
@@ -5165,11 +5193,11 @@ grokdeclarator (const struct c_declarator *declarator,
               GCC allows 'auto', perhaps with 'inline', to support
               nested functions.  */
            if (storage_class == csc_auto)
-               pedwarn (input_location, OPT_pedantic,
+               pedwarn (loc, OPT_pedantic,
                         "invalid storage class for function %qE", name);
            else if (storage_class == csc_static)
              {
-               error ("invalid storage class for function %qE", name);
+               error_at (loc, "invalid storage class for function %qE", name);
                if (funcdef_flag)
                  storage_class = declspecs->storage_class = csc_none;
                else
@@ -5177,19 +5205,19 @@ grokdeclarator (const struct c_declarator *declarator,
              }
          }
 
-       decl = build_decl (FUNCTION_DECL, declarator->u.id, type);
-       DECL_SOURCE_LOCATION (decl) = declarator->id_loc;
+       decl = build_decl (declarator->id_loc,
+                          FUNCTION_DECL, declarator->u.id, type);
        decl = build_decl_attribute_variant (decl, decl_attr);
 
        if (pedantic && type_quals && !DECL_IN_SYSTEM_HEADER (decl))
-         pedwarn (input_location, OPT_pedantic,
+         pedwarn (loc, OPT_pedantic,
                   "ISO C forbids qualified function types");
 
        /* GNU C interprets a volatile-qualified function type to indicate
           that the function does not return.  */
        if ((type_quals & TYPE_QUAL_VOLATILE)
            && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
-         warning (0, "%<noreturn%> function returns non-void value");
+         warning_at (loc, 0, "%<noreturn%> function returns non-void value");
 
        /* Every function declaration is an external reference
           (DECL_EXTERNAL) except for those which are not at file
@@ -5225,7 +5253,7 @@ grokdeclarator (const struct c_declarator *declarator,
        if (flag_hosted && MAIN_NAME_P (declarator->u.id))
          {
            if (declspecs->inline_p)
-             pedwarn (input_location, 0, "cannot inline function %<main%>");
+             pedwarn (loc, 0, "cannot inline function %<main%>");
          }
        else if (declspecs->inline_p)
          /* Record that the function is declared `inline'.  */
@@ -5254,17 +5282,17 @@ grokdeclarator (const struct c_declarator *declarator,
                && global_decl != visible_decl
                && TREE_CODE (global_decl) == VAR_DECL
                && !TREE_PUBLIC (global_decl))
-             error ("variable previously declared %<static%> redeclared "
-                    "%<extern%>");
+             error_at (loc, "variable previously declared %<static%> "
+                       "redeclared %<extern%>");
          }
 
-       decl = build_decl (VAR_DECL, declarator->u.id, type);
-       DECL_SOURCE_LOCATION (decl) = declarator->id_loc;
+       decl = build_decl (declarator->id_loc,
+                          VAR_DECL, declarator->u.id, type);
        if (size_varies)
          C_DECL_VARIABLE_SIZE (decl) = 1;
 
        if (declspecs->inline_p)
-         pedwarn (input_location, 0, "variable %q+D declared %<inline%>", decl);
+         pedwarn (loc, 0, "variable %q+D declared %<inline%>", decl);
 
        /* At file scope, an initialized extern declaration may follow
           a static declaration.  In that case, DECL_EXTERNAL will be
@@ -5299,9 +5327,10 @@ grokdeclarator (const struct c_declarator *declarator,
       {
        /* C99 6.7.5.2p2 */
        if (TREE_CODE (type) == FUNCTION_TYPE)
-         error ("non-nested function with variably modified type");
+         error_at (loc, "non-nested function with variably modified type");
        else
-         error ("object with variably modified type must have no linkage");
+         error_at (loc, "object with variably modified type must have "
+                   "no linkage");
       }
 
     /* Record `register' declaration for warnings on &
@@ -5634,11 +5663,12 @@ get_parm_info (bool ellipsis)
 }
 \f
 /* Get the struct, enum or union (CODE says which) with tag NAME.
-   Define the tag as a forward-reference if it is not defined.
-   Return a c_typespec structure for the type specifier.  */
+   Define the tag as a forward-reference with location LOC if it is
+   not defined.  Return a c_typespec structure for the type
+   specifier.  */
 
 struct c_typespec
-parser_xref_tag (enum tree_code code, tree name, location_t loc)
+parser_xref_tag (location_t loc, enum tree_code code, tree name)
 {
   struct c_typespec ret;
   tree ref;
@@ -5717,7 +5747,7 @@ parser_xref_tag (enum tree_code code, tree name, location_t loc)
       TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
     }
 
-  pushtag (name, ref, loc);
+  pushtag (loc, name, ref);
 
   ret.spec = ref;
   return ret;
@@ -5730,11 +5760,12 @@ parser_xref_tag (enum tree_code code, tree name, location_t loc)
 tree
 xref_tag (enum tree_code code, tree name)
 {
-  return parser_xref_tag (code, name, UNKNOWN_LOCATION).spec;
+  return parser_xref_tag (input_location, code, name).spec;
 }
 \f
 /* Make sure that the tag NAME is defined *in the current scope*
    at least as a forward reference.
+   LOC is the location of the struct's definition.
    CODE says which kind of tag NAME ought to be.
 
    This stores the current value of the file static IN_STRUCT in
@@ -5744,8 +5775,9 @@ xref_tag (enum tree_code code, tree name)
    finish_struct.  */
 
 tree
-start_struct (enum tree_code code, tree name, bool *enclosing_in_struct,
-             VEC(tree,heap) **enclosing_struct_types, location_t loc)
+start_struct (location_t loc, enum tree_code code, tree name,
+             bool *enclosing_in_struct,
+             VEC(tree,heap) **enclosing_struct_types)
 {
   /* If there is already a tag defined at this scope
      (as a forward reference), just return it.  */
@@ -5787,7 +5819,7 @@ start_struct (enum tree_code code, tree name, bool *enclosing_in_struct,
   if (ref == NULL_TREE || TREE_CODE (ref) != code)
     {
       ref = make_node (code);
-      pushtag (name, ref, loc);
+      pushtag (loc, name, ref);
     }
 
   C_TYPE_BEING_DEFINED (ref) = 1;
@@ -5881,7 +5913,7 @@ grokfield (location_t loc,
                          width ? &width : NULL, decl_attrs, NULL, NULL,
                          DEPRECATED_NORMAL);
 
-  finish_decl (value, NULL_TREE, NULL_TREE, NULL_TREE);
+  finish_decl (value, loc, NULL_TREE, NULL_TREE, NULL_TREE);
   DECL_INITIAL (value) = width;
 
   return value;
@@ -5945,6 +5977,7 @@ detect_field_duplicates (tree fieldlist)
 }
 
 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
+   LOC is the location of the RECORD_TYPE or UNION_TYPE's definition.
    FIELDLIST is a chain of FIELD_DECL nodes for the fields.
    ATTRIBUTES are attributes to be applied to the structure.
 
@@ -5954,7 +5987,7 @@ detect_field_duplicates (tree fieldlist)
    for any type defined in the current struct.  */
 
 tree
-finish_struct (tree t, tree fieldlist, tree attributes,
+finish_struct (location_t loc, tree t, tree fieldlist, tree attributes,
               bool enclosing_in_struct,
               VEC(tree,heap) *enclosing_struct_types)
 {
@@ -5981,16 +6014,16 @@ finish_struct (tree t, tree fieldlist, tree attributes,
          if (TREE_CODE (t) == UNION_TYPE)
            {
              if (fieldlist)
-               pedwarn (input_location, OPT_pedantic, "union has no named members");
+               pedwarn (loc, OPT_pedantic, "union has no named members");
              else
-               pedwarn (input_location, OPT_pedantic, "union has no members");
+               pedwarn (loc, OPT_pedantic, "union has no members");
            }
          else
            {
              if (fieldlist)
-               pedwarn (input_location, OPT_pedantic, "struct has no named members");
+               pedwarn (loc, OPT_pedantic, "struct has no named members");
              else
-               pedwarn (input_location, OPT_pedantic, "struct has no members");
+               pedwarn (loc, OPT_pedantic, "struct has no members");
            }
        }
     }
@@ -6054,24 +6087,28 @@ finish_struct (tree t, tree fieldlist, tree attributes,
        {
          if (TREE_CODE (t) == UNION_TYPE)
            {
-             error ("%Jflexible array member in union", x);
+             error_at (DECL_SOURCE_LOCATION (x),
+                       "%Jflexible array member in union", x);
              TREE_TYPE (x) = error_mark_node;
            }
          else if (TREE_CHAIN (x) != NULL_TREE)
            {
-             error ("%Jflexible array member not at end of struct", x);
+             error_at (DECL_SOURCE_LOCATION (x),
+                       "%Jflexible array member not at end of struct", x);
              TREE_TYPE (x) = error_mark_node;
            }
          else if (!saw_named_field)
            {
-             error ("%Jflexible array member in otherwise empty struct", x);
+             error_at (DECL_SOURCE_LOCATION (x),
+                       "%Jflexible array member in otherwise empty struct",
+                       x);
              TREE_TYPE (x) = error_mark_node;
            }
        }
 
       if (pedantic && !in_system_header && TREE_CODE (t) == RECORD_TYPE
          && flexible_array_type_p (TREE_TYPE (x)))
-       pedwarn (input_location, OPT_pedantic, 
+       pedwarn (loc, OPT_pedantic, 
                 "%Jinvalid use of structure with flexible array member", x);
 
       if (DECL_NAME (x))
@@ -6181,7 +6218,7 @@ finish_struct (tree t, tree fieldlist, tree attributes,
       && (!TYPE_FIELDS (t) || TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t))))
     {
       TYPE_TRANSPARENT_UNION (t) = 0;
-      warning (0, "union cannot be made transparent");
+      warning_at (loc, 0, "union cannot be made transparent");
     }
 
   /* If this structure or union completes the type of any previous
@@ -6212,7 +6249,8 @@ finish_struct (tree t, tree fieldlist, tree attributes,
      parsing parameters, then arrange for the size of a variable sized type
      to be bound now.  */
   if (cur_stmt_list && variably_modified_type_p (t, NULL_TREE))
-    add_stmt (build_stmt (DECL_EXPR, build_decl (TYPE_DECL, NULL, t)));
+    add_stmt (build_stmt (loc,
+                         DECL_EXPR, build_decl (loc, TYPE_DECL, NULL, t)));
 
   /* Set the C_TYPE_DEFINED_IN_STRUCT flag for each type defined in
      the current struct.  We do this now at the end of the struct
@@ -6247,12 +6285,13 @@ layout_array_type (tree t)
 \f
 /* Begin compiling the definition of an enumeration type.
    NAME is its name (or null if anonymous).
+   LOC is the enum's location.
    Returns the type object, as yet incomplete.
    Also records info about it so that build_enumerator
    may be used to declare the individual values as they are read.  */
 
 tree
-start_enum (struct c_enum_contents *the_enum, tree name, location_t loc)
+start_enum (location_t loc, struct c_enum_contents *the_enum, tree name)
 {
   tree enumtype = NULL_TREE;
   location_t enumloc = UNKNOWN_LOCATION;
@@ -6267,7 +6306,7 @@ start_enum (struct c_enum_contents *the_enum, tree name, location_t loc)
   if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
     {
       enumtype = make_node (ENUMERAL_TYPE);
-      pushtag (name, enumtype, loc);
+      pushtag (loc, name, enumtype);
     }
 
   if (C_TYPE_BEING_DEFINED (enumtype))
@@ -6452,12 +6491,13 @@ finish_enum (tree enumtype, tree values, tree attributes)
 
 /* Build and install a CONST_DECL for one value of the
    current enumeration type (one that was begun with start_enum).
+   LOC is the location of the enumerator.
    Return a tree-list containing the CONST_DECL and its value.
    Assignment of sequential values by default is handled here.  */
 
 tree
-build_enumerator (struct c_enum_contents *the_enum, tree name, tree value,
-                 location_t value_loc)
+build_enumerator (location_t loc,
+                 struct c_enum_contents *the_enum, tree name, tree value)
 {
   tree decl, type;
 
@@ -6471,7 +6511,8 @@ build_enumerator (struct c_enum_contents *the_enum, tree name, tree value,
        value = 0;
       else if (!INTEGRAL_TYPE_P (TREE_TYPE (value)))
        {
-         error ("enumerator value for %qE is not an integer constant", name);
+         error_at (loc, "enumerator value for %qE is not an integer constant",
+                   name);
          value = 0;
        }
       else
@@ -6480,7 +6521,7 @@ build_enumerator (struct c_enum_contents *the_enum, tree name, tree value,
            {
              value = c_fully_fold (value, false, NULL);
              if (TREE_CODE (value) == INTEGER_CST)
-               pedwarn (value_loc, OPT_pedantic,
+               pedwarn (loc, OPT_pedantic,
                         "enumerator value for %qE is not an integer "
                         "constant expression", name);
            }
@@ -6505,14 +6546,14 @@ build_enumerator (struct c_enum_contents *the_enum, tree name, tree value,
     {
       value = the_enum->enum_next_value;
       if (the_enum->enum_overflow)
-       error ("overflow in enumeration values");
+       error_at (loc, "overflow in enumeration values");
     }
   /* Even though the underlying type of an enum is unspecified, the
      type of enumeration constants is explicitly defined as int
      (6.4.4.3/2 in the C99 Standard).  GCC allows any integer type as
      an extension.  */
   else if (!int_fits_type_p (value, integer_type_node))
-    pedwarn (value_loc, OPT_pedantic, 
+    pedwarn (loc, OPT_pedantic, 
             "ISO C restricts enumerator values to range of %<int%>");
 
   /* The ISO C Standard mandates enumerators to have type int, even
@@ -6543,7 +6584,7 @@ build_enumerator (struct c_enum_contents *the_enum, tree name, tree value,
                                  >= TYPE_PRECISION (integer_type_node)
                                  && TYPE_UNSIGNED (type)));
 
-  decl = build_decl (CONST_DECL, name, type);
+  decl = build_decl (loc, CONST_DECL, name, type);
   DECL_INITIAL (decl) = convert (type, value);
   pushdecl (decl);
 
@@ -6571,6 +6612,7 @@ start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
   tree restype, resdecl;
   struct c_label_context_se *nstack_se;
   struct c_label_context_vm *nstack_vm;
+  location_t loc;
 
   current_function_returns_value = 0;  /* Assume, until we see it does.  */
   current_function_returns_null = 0;
@@ -6608,13 +6650,16 @@ start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
       return 0;
     }
 
+  loc = DECL_SOURCE_LOCATION (decl1);
+
   decl_attributes (&decl1, attributes, 0);
 
   if (DECL_DECLARED_INLINE_P (decl1)
       && DECL_UNINLINABLE (decl1)
       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1)))
-    warning (OPT_Wattributes, "inline function %q+D given attribute noinline",
-            decl1);
+    warning_at (loc, OPT_Wattributes,
+               "inline function %qD given attribute noinline",
+               decl1);
 
   /* Handle gnu_inline attribute.  */
   if (declspecs->inline_p
@@ -6631,7 +6676,7 @@ start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
 
   if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1))))
     {
-      error ("return type is an incomplete type");
+      error_at (loc, "return type is an incomplete type");
       /* Make it return void instead.  */
       TREE_TYPE (decl1)
        = build_function_type (void_type_node,
@@ -6639,7 +6684,7 @@ start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
     }
 
   if (warn_about_return_type)
-    pedwarn_c99 (input_location, flag_isoc99 ? 0 
+    pedwarn_c99 (loc, flag_isoc99 ? 0 
                 : (warn_return_type ? OPT_Wreturn_type : OPT_Wimplicit_int),
                 "return type defaults to %<int%>");
 
@@ -6706,15 +6751,16 @@ start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
       && old_decl != error_mark_node
       && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
       && C_DECL_ISNT_PROTOTYPE (old_decl))
-    warning (OPT_Wstrict_prototypes,
-            "function declaration isn%'t a prototype");
+    warning_at (loc, OPT_Wstrict_prototypes,
+               "function declaration isn%'t a prototype");
   /* Optionally warn of any global def with no previous prototype.  */
   else if (warn_missing_prototypes
           && old_decl != error_mark_node
           && TREE_PUBLIC (decl1)
           && !MAIN_NAME_P (DECL_NAME (decl1))
           && C_DECL_ISNT_PROTOTYPE (old_decl))
-    warning (OPT_Wmissing_prototypes, "no previous prototype for %q+D", decl1);
+    warning_at (loc, OPT_Wmissing_prototypes,
+               "no previous prototype for %qD", decl1);
   /* Optionally warn of any def with no previous prototype
      if the function has already been used.  */
   else if (warn_missing_prototypes
@@ -6722,15 +6768,16 @@ start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
           && old_decl != error_mark_node
           && TREE_USED (old_decl)
           && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
-    warning (OPT_Wmissing_prototypes,
-            "%q+D was used with no prototype before its definition", decl1);
+    warning_at (loc, OPT_Wmissing_prototypes,
+               "%qD was used with no prototype before its definition", decl1);
   /* Optionally warn of any global def with no previous declaration.  */
   else if (warn_missing_declarations
           && TREE_PUBLIC (decl1)
           && old_decl == 0
           && !MAIN_NAME_P (DECL_NAME (decl1)))
-    warning (OPT_Wmissing_declarations, "no previous declaration for %q+D",
-            decl1);
+    warning_at (loc, OPT_Wmissing_declarations,
+               "no previous declaration for %qD",
+               decl1);
   /* Optionally warn of any def with no previous declaration
      if the function has already been used.  */
   else if (warn_missing_declarations
@@ -6738,8 +6785,8 @@ start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
           && old_decl != error_mark_node
           && TREE_USED (old_decl)
           && C_DECL_IMPLICIT (old_decl))
-    warning (OPT_Wmissing_declarations,
-            "%q+D was used with no declaration before its definition", decl1);
+    warning_at (loc, OPT_Wmissing_declarations,
+               "%qD was used with no declaration before its definition", decl1);
 
   /* This function exists in static storage.
      (This does not mean `static' in the C sense!)  */
@@ -6762,12 +6809,13 @@ start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
     {
       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
          != integer_type_node)
-       pedwarn (input_location, OPT_Wmain, "return type of %q+D is not %<int%>", decl1);
+       pedwarn (loc, OPT_Wmain, "return type of %qD is not %<int%>", decl1);
 
       check_main_parameter_types (decl1);
 
       if (!TREE_PUBLIC (decl1))
-       pedwarn (input_location, OPT_Wmain, "%q+D is normally a non-static function", decl1);
+       pedwarn (loc, OPT_Wmain,
+                "%qD is normally a non-static function", decl1);
     }
 
   /* Record the decl so that the function name is defined.
@@ -6780,7 +6828,7 @@ start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
   declare_parm_level ();
 
   restype = TREE_TYPE (TREE_TYPE (current_function_decl));
-  resdecl = build_decl (RESULT_DECL, NULL_TREE, restype);
+  resdecl = build_decl (loc, RESULT_DECL, NULL_TREE, restype);
   DECL_ARTIFICIAL (resdecl) = 1;
   DECL_IGNORED_P (resdecl) = 1;
   DECL_RESULT (current_function_decl) = resdecl;
@@ -6866,8 +6914,8 @@ store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info)
   struct pointer_set_t *seen_args = pointer_set_create ();
 
   if (!in_system_header)
-    warning (OPT_Wold_style_definition, "%Jold-style function definition",
-            fndecl);
+    warning_at (DECL_SOURCE_LOCATION (fndecl),
+               OPT_Wold_style_definition, "old-style function definition");
 
   /* Match each formal parameter name with its declaration.  Save each
      decl in the appropriate TREE_PURPOSE slot of the parmids chain.  */
@@ -6875,7 +6923,8 @@ store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info)
     {
       if (TREE_VALUE (parm) == 0)
        {
-         error ("%Jparameter name missing from parameter list", fndecl);
+         error_at (DECL_SOURCE_LOCATION (fndecl),
+                   "parameter name missing from parameter list");
          TREE_PURPOSE (parm) = 0;
          continue;
        }
@@ -6886,12 +6935,14 @@ store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info)
          decl = b->decl;
          /* If we got something other than a PARM_DECL it is an error.  */
          if (TREE_CODE (decl) != PARM_DECL)
-           error ("%q+D declared as a non-parameter", decl);
+           error_at (DECL_SOURCE_LOCATION (decl),
+                     "%qD declared as a non-parameter", decl);
          /* If the declaration is already marked, we have a duplicate
             name.  Complain and ignore the duplicate.  */
          else if (pointer_set_contains (seen_args, decl))
            {
-             error ("multiple parameters named %q+D", decl);
+             error_at (DECL_SOURCE_LOCATION (decl),
+                       "multiple parameters named %qD", decl);
              TREE_PURPOSE (parm) = 0;
              continue;
            }
@@ -6899,7 +6950,8 @@ store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info)
             an int.  */
          else if (VOID_TYPE_P (TREE_TYPE (decl)))
            {
-             error ("parameter %q+D declared with void type", decl);
+             error_at (DECL_SOURCE_LOCATION (decl),
+                       "parameter %qD declared with void type", decl);
              TREE_TYPE (decl) = integer_type_node;
              DECL_ARG_TYPE (decl) = integer_type_node;
              layout_decl (decl, 0);
@@ -6909,16 +6961,30 @@ store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info)
       /* If no declaration found, default to int.  */
       else
        {
-         decl = build_decl (PARM_DECL, TREE_VALUE (parm), integer_type_node);
+         /* FIXME diagnostics: This should be the location of the argument,
+            not the FNDECL.  E.g., for an old-style declaration
+
+              int f10(v) { blah; }
+
+            We should use the location of the V, not the F10.
+            Unfortunately, the V is an IDENTIFIER_NODE which has no
+            location.  In the future we need locations for c_arg_info
+            entries.
+
+            See gcc.dg/Wshadow-3.c for an example of this problem. */
+         decl = build_decl (DECL_SOURCE_LOCATION (fndecl),
+                            PARM_DECL, TREE_VALUE (parm), integer_type_node);
          DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
-         DECL_SOURCE_LOCATION (decl) = DECL_SOURCE_LOCATION (fndecl);
          pushdecl (decl);
          warn_if_shadowing (decl);
 
          if (flag_isoc99)
-           pedwarn (input_location, 0, "type of %q+D defaults to %<int%>", decl);
+           pedwarn (DECL_SOURCE_LOCATION (decl),
+                    0, "type of %qD defaults to %<int%>", decl);
          else 
-           warning (OPT_Wmissing_parameter_type, "type of %q+D defaults to %<int%>", decl);
+           warning_at (DECL_SOURCE_LOCATION (decl),
+                       OPT_Wmissing_parameter_type,
+                       "type of %qD defaults to %<int%>", decl);
        }
 
       TREE_PURPOSE (parm) = decl;
@@ -6937,13 +7003,16 @@ store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info)
       if (TREE_TYPE (parm) != error_mark_node
          && !COMPLETE_TYPE_P (TREE_TYPE (parm)))
        {
-         error ("parameter %q+D has incomplete type", parm);
+         error_at (DECL_SOURCE_LOCATION (parm),
+                   "parameter %qD has incomplete type", parm);
          TREE_TYPE (parm) = error_mark_node;
        }
 
       if (!pointer_set_contains (seen_args, parm))
        {
-         error ("declaration for parameter %q+D but no such parameter", parm);
+         error_at (DECL_SOURCE_LOCATION (parm),
+                   "declaration for parameter %qD but no such parameter",
+                   parm);
 
          /* Pretend the parameter was not missing.
             This gets us to a standard state and minimizes
@@ -6993,13 +7062,22 @@ store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info)
              || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
            {
              if (current_function_prototype_built_in)
-               warning (0, "number of arguments doesn%'t match "
-                        "built-in prototype");
+               warning_at (DECL_SOURCE_LOCATION (fndecl),
+                           0, "number of arguments doesn%'t match "
+                           "built-in prototype");
              else
                {
-                 error ("number of arguments doesn%'t match prototype");
-                 error ("%Hprototype declaration",
-                        &current_function_prototype_locus);
+                 /* FIXME diagnostics: This should be the location of
+                    FNDECL, but there is bug when a prototype is
+                    declared inside function context, but defined
+                    outside of it (e.g., gcc.dg/pr15698-2.c).  In
+                    which case FNDECL gets the location of the
+                    prototype, not the definition.  */
+                 error_at (input_location,
+                           "number of arguments doesn%'t match prototype");
+
+                 error_at (current_function_prototype_locus,
+                           "prototype declaration");
                }
              break;
            }
@@ -7032,11 +7110,13 @@ store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info)
                     been diagnosed as conflicting with an
                     old-style definition and discarded?  */
                  if (current_function_prototype_built_in)
-                   warning (OPT_pedantic, "promoted argument %qD "
-                            "doesn%'t match built-in prototype", parm);
+                   warning_at (DECL_SOURCE_LOCATION (parm),
+                               OPT_pedantic, "promoted argument %qD "
+                               "doesn%'t match built-in prototype", parm);
                  else
                    {
-                     pedwarn (input_location, OPT_pedantic, "promoted argument %qD "
+                     pedwarn (DECL_SOURCE_LOCATION (parm),
+                              OPT_pedantic, "promoted argument %qD "
                               "doesn%'t match prototype", parm);
                      pedwarn (current_function_prototype_locus, OPT_pedantic,
                               "prototype declaration");
@@ -7045,13 +7125,15 @@ store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info)
              else
                {
                  if (current_function_prototype_built_in)
-                   warning (0, "argument %qD doesn%'t match "
-                            "built-in prototype", parm);
+                   warning_at (DECL_SOURCE_LOCATION (parm),
+                               0, "argument %qD doesn%'t match "
+                               "built-in prototype", parm);
                  else
                    {
-                     error ("argument %qD doesn%'t match prototype", parm);
-                     error ("%Hprototype declaration",
-                            &current_function_prototype_locus);
+                     error_at (DECL_SOURCE_LOCATION (parm),
+                               "argument %qD doesn%'t match prototype", parm);
+                     error_at (current_function_prototype_locus,
+                               "prototype declaration");
                    }
                }
            }
@@ -7228,14 +7310,13 @@ finish_function (void)
       && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
       == integer_type_node && flag_isoc99)
     {
-      tree stmt = c_finish_return (integer_zero_node, NULL_TREE);
       /* Hack.  We don't want the middle-end to warn that this return
         is unreachable, so we mark its location as special.  Using
         UNKNOWN_LOCATION has the problem that it gets clobbered in
         annotate_one_with_locus.  A cleaner solution might be to
         ensure ! should_carry_locus_p (stmt), but that needs a flag.
       */
-      SET_EXPR_LOCATION (stmt, BUILTINS_LOCATION);
+      c_finish_return (BUILTINS_LOCATION, integer_zero_node, NULL_TREE);
     }
 
   /* Tie off the statement tree for this function.  */
@@ -7315,10 +7396,11 @@ finish_function (void)
 }
 \f
 /* Check the declarations given in a for-loop for satisfying the C99
-   constraints.  If exactly one such decl is found, return it.  */
+   constraints.  If exactly one such decl is found, return it.  LOC is
+   the location of the opening parenthesis of the for loop.  */
 
 tree
-check_for_loop_decls (void)
+check_for_loop_decls (location_t loc)
 {
   struct c_binding *b;
   tree one_decl = NULL_TREE;
@@ -7330,10 +7412,11 @@ check_for_loop_decls (void)
       /* If we get here, declarations have been used in a for loop without
         the C99 for loop scope.  This doesn't make much sense, so don't
         allow it.  */
-      error ("%<for%> loop initial declarations are only allowed in C99 mode");
+      error_at (loc, "%<for%> loop initial declarations "
+               "are only allowed in C99 mode");
       if (hint)
        {
-         inform (input_location, 
+         inform (loc,
                  "use option -std=c99 or -std=gnu99 to compile your code");
          hint = false;
        }
@@ -7364,29 +7447,36 @@ check_for_loop_decls (void)
       switch (TREE_CODE (decl))
        {
        case VAR_DECL:
-         if (TREE_STATIC (decl))
-           error ("declaration of static variable %q+D in %<for%> loop "
-                  "initial declaration", decl);
-         else if (DECL_EXTERNAL (decl))
-           error ("declaration of %<extern%> variable %q+D in %<for%> loop "
-                  "initial declaration", decl);
+         {
+           location_t decl_loc = DECL_SOURCE_LOCATION (decl);
+           if (TREE_STATIC (decl))
+             error_at (decl_loc,
+                       "declaration of static variable %qD in %<for%> loop "
+                       "initial declaration", decl);
+           else if (DECL_EXTERNAL (decl))
+             error_at (decl_loc,
+                       "declaration of %<extern%> variable %qD in %<for%> loop "
+                       "initial declaration", decl);
+         }
          break;
 
        case RECORD_TYPE:
-         error ("%<struct %E%> declared in %<for%> loop initial declaration",
-                id);
+         error_at (loc,
+                   "%<struct %E%> declared in %<for%> loop initial "
+                   "declaration", id);
          break;
        case UNION_TYPE:
-         error ("%<union %E%> declared in %<for%> loop initial declaration",
-                id);
+         error_at (loc,
+                   "%<union %E%> declared in %<for%> loop initial declaration",
+                   id);
          break;
        case ENUMERAL_TYPE:
-         error ("%<enum %E%> declared in %<for%> loop initial declaration",
-                id);
+         error_at (loc, "%<enum %E%> declared in %<for%> loop "
+                   "initial declaration", id);
          break;
        default:
-         error ("declaration of non-variable %q+D in %<for%> loop "
-                "initial declaration", decl);
+         error_at (loc, "declaration of non-variable "
+                   "%qD in %<for%> loop initial declaration", decl);
        }
 
       n_decls++;
@@ -7506,7 +7596,7 @@ record_builtin_type (enum rid rid_index, const char *name, tree type)
     id = ridpointers[(int) rid_index];
   else
     id = get_identifier (name);
-  decl = build_decl (TYPE_DECL, id, type);
+  decl = build_decl (UNKNOWN_LOCATION, TYPE_DECL, id, type);
   pushdecl (decl);
   if (debug_hooks->type_decl)
     debug_hooks->type_decl (decl, false);
index 9cb4a0b..6595fc8 100644 (file)
@@ -140,7 +140,7 @@ add_block_to_enclosing (tree block)
      genericized.  */
 
 tree
-c_build_bind_expr (tree block, tree body)
+c_build_bind_expr (location_t loc, tree block, tree body)
 {
   tree decls, bind;
 
@@ -162,11 +162,12 @@ c_build_bind_expr (tree block, tree body)
     }
 
   if (!body)
-    body = build_empty_stmt ();
+    body = build_empty_stmt (loc);
   if (decls || block)
     {
       bind = build3 (BIND_EXPR, void_type_node, decls, body, block);
       TREE_SIDE_EFFECTS (bind) = 1;
+      SET_EXPR_LOCATION (bind, loc);
     }
   else
     bind = body;
index d31fb07..5ec9f94 100644 (file)
@@ -35,72 +35,81 @@ along with GCC; see the file COPYING3.  If not see
 
 
 /* Complete a #pragma omp master construct.  STMT is the structured-block
-   that follows the pragma.  */
+   that follows the pragma.  LOC is the l*/
 
 tree
-c_finish_omp_master (tree stmt)
+c_finish_omp_master (location_t loc, tree stmt)
 {
-  return add_stmt (build1 (OMP_MASTER, void_type_node, stmt));
+  tree t = add_stmt (build1 (OMP_MASTER, void_type_node, stmt));
+  SET_EXPR_LOCATION (t, loc);
+  return t;
 }
 
 /* Complete a #pragma omp critical construct.  STMT is the structured-block
    that follows the pragma, NAME is the identifier in the pragma, or null
-   if it was omitted.  */
+   if it was omitted.  LOC is the location of the #pragma.  */
 
 tree
-c_finish_omp_critical (tree body, tree name)
+c_finish_omp_critical (location_t loc, tree body, tree name)
 {
   tree stmt = make_node (OMP_CRITICAL);
   TREE_TYPE (stmt) = void_type_node;
   OMP_CRITICAL_BODY (stmt) = body;
   OMP_CRITICAL_NAME (stmt) = name;
+  SET_EXPR_LOCATION (stmt, loc);
   return add_stmt (stmt);
 }
 
 /* Complete a #pragma omp ordered construct.  STMT is the structured-block
-   that follows the pragma.  */
+   that follows the pragma.  LOC is the location of the #pragma.  */
 
 tree
-c_finish_omp_ordered (tree stmt)
+c_finish_omp_ordered (location_t loc, tree stmt)
 {
-  return add_stmt (build1 (OMP_ORDERED, void_type_node, stmt));
+  tree t = build1 (OMP_ORDERED, void_type_node, stmt);
+  SET_EXPR_LOCATION (t, loc);
+  return add_stmt (t);
 }
 
 
-/* Complete a #pragma omp barrier construct.  */
+/* Complete a #pragma omp barrier construct.  LOC is the location of
+   the #pragma.  */
 
 void
-c_finish_omp_barrier (void)
+c_finish_omp_barrier (location_t loc)
 {
   tree x;
 
   x = built_in_decls[BUILT_IN_GOMP_BARRIER];
   x = build_call_expr (x, 0);
+  SET_EXPR_LOCATION (x, loc);
   add_stmt (x);
 }
 
 
-/* Complete a #pragma omp taskwait construct.  */
+/* Complete a #pragma omp taskwait construct.  LOC is the location of the
+   pragma.  */
 
 void
-c_finish_omp_taskwait (void)
+c_finish_omp_taskwait (location_t loc)
 {
   tree x;
 
   x = built_in_decls[BUILT_IN_GOMP_TASKWAIT];
   x = build_call_expr (x, 0);
+  SET_EXPR_LOCATION (x, loc);
   add_stmt (x);
 }
 
 
-/* Complete a #pragma omp atomic construct.  The expression to be 
-   implemented atomically is LHS code= RHS.  The value returned is
-   either error_mark_node (if the construct was erroneous) or an
-   OMP_ATOMIC node which should be added to the current statement tree
-   with add_stmt.  */
+/* Complete a #pragma omp atomic construct.  The expression to be
+   implemented atomically is LHS code= RHS.  LOC is the location of
+   the atomic statement.  The value returned is either error_mark_node
+   (if the construct was erroneous) or an OMP_ATOMIC node which should
+   be added to the current statement tree with add_stmt.*/
 
 tree
-c_finish_omp_atomic (enum tree_code code, tree lhs, tree rhs)
+c_finish_omp_atomic (location_t loc, enum tree_code code, tree lhs, tree rhs)
 {
   tree x, type, addr;
 
@@ -116,7 +125,7 @@ c_finish_omp_atomic (enum tree_code code, tree lhs, tree rhs)
       && !POINTER_TYPE_P (type)
       && !SCALAR_FLOAT_TYPE_P (type))
     {
-      error ("invalid expression type for %<#pragma omp atomic%>");
+      error_at (loc, "invalid expression type for %<#pragma omp atomic%>");
       return error_mark_node;
     }
 
@@ -124,7 +133,7 @@ c_finish_omp_atomic (enum tree_code code, tree lhs, tree rhs)
 
   /* Take and save the address of the lhs.  From then on we'll reference it
      via indirection.  */
-  addr = build_unary_op (input_location, ADDR_EXPR, lhs, 0);
+  addr = build_unary_op (loc, ADDR_EXPR, lhs, 0);
   if (addr == error_mark_node)
     return error_mark_node;
   addr = save_expr (addr);
@@ -137,32 +146,37 @@ c_finish_omp_atomic (enum tree_code code, tree lhs, tree rhs)
       tree var = create_tmp_var_raw (TREE_TYPE (addr), NULL);
       addr = build4 (TARGET_EXPR, TREE_TYPE (addr), var, addr, NULL, NULL);
     }
-  lhs = build_indirect_ref (input_location, addr, NULL);
+  lhs = build_indirect_ref (loc, addr, NULL);
 
   /* There are lots of warnings, errors, and conversions that need to happen
      in the course of interpreting a statement.  Use the normal mechanisms
      to do this, and then take it apart again.  */
-  x = build_modify_expr (input_location, lhs, NULL_TREE, code, rhs, NULL_TREE);
+  x = build_modify_expr (input_location, lhs, NULL_TREE, code,
+                        input_location, rhs, NULL_TREE);
   if (x == error_mark_node)
     return error_mark_node;
   gcc_assert (TREE_CODE (x) == MODIFY_EXPR);  
   rhs = TREE_OPERAND (x, 1);
 
   /* Punt the actual generation of atomic operations to common code.  */
-  return build2 (OMP_ATOMIC, void_type_node, addr, rhs);
+  x = build2 (OMP_ATOMIC, void_type_node, addr, rhs);
+  SET_EXPR_LOCATION (x, loc);
+  return x;
 }
 
 
-/* Complete a #pragma omp flush construct.  We don't do anything with the
-   variable list that the syntax allows.  */
+/* Complete a #pragma omp flush construct.  We don't do anything with
+   the variable list that the syntax allows.  LOC is the location of
+   the #pragma.  */
 
 void
-c_finish_omp_flush (void)
+c_finish_omp_flush (location_t loc)
 {
   tree x;
 
   x = built_in_decls[BUILT_IN_SYNCHRONIZE];
   x = build_call_expr (x, 0);
+  SET_EXPR_LOCATION (x, loc);
   add_stmt (x);
 }
 
@@ -260,7 +274,11 @@ c_finish_omp_for (location_t locus, tree declv, tree initv, tree condv,
              fail = true;
            }
 
-         init = build_modify_expr (elocus, decl, NULL_TREE, NOP_EXPR, init,
+         init = build_modify_expr (elocus, decl, NULL_TREE, NOP_EXPR, 
+                                   /* FIXME diagnostics: This should
+                                      be the location of the INIT.  */
+                                   elocus,
+                                   init,
                                    NULL_TREE);
        }
       gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
@@ -448,18 +466,20 @@ c_finish_omp_for (location_t locus, tree declv, tree initv, tree condv,
 }
 
 
-/* Divide CLAUSES into two lists: those that apply to a parallel construct,
-   and those that apply to a work-sharing construct.  Place the results in
-   *PAR_CLAUSES and *WS_CLAUSES respectively.  In addition, add a nowait
-   clause to the work-sharing list.  */
+/* Divide CLAUSES into two lists: those that apply to a parallel
+   construct, and those that apply to a work-sharing construct.  Place
+   the results in *PAR_CLAUSES and *WS_CLAUSES respectively.  In
+   addition, add a nowait clause to the work-sharing list.  LOC is the
+   location of the OMP_PARALLEL*.  */
 
 void
-c_split_parallel_clauses (tree clauses, tree *par_clauses, tree *ws_clauses)
+c_split_parallel_clauses (location_t loc, tree clauses,
+                         tree *par_clauses, tree *ws_clauses)
 {
   tree next;
 
   *par_clauses = NULL;
-  *ws_clauses = build_omp_clause (OMP_CLAUSE_NOWAIT);
+  *ws_clauses = build_omp_clause (loc, OMP_CLAUSE_NOWAIT);
 
   for (; clauses ; clauses = next)
     {
index 2847086..6c7b830 100644 (file)
@@ -916,6 +916,7 @@ static struct c_expr c_parser_postfix_expression_after_paren_type (c_parser *,
                                                                   struct c_type_name *,
                                                                   location_t);
 static struct c_expr c_parser_postfix_expression_after_primary (c_parser *,
+                                                               location_t loc,
                                                                struct c_expr);
 static struct c_expr c_parser_expression (c_parser *);
 static struct c_expr c_parser_expression_conv (c_parser *);
@@ -1224,6 +1225,7 @@ c_parser_declaration_or_fndef (c_parser *parser, bool fndef_ok, bool empty_ok,
            {
              tree d;
              struct c_expr init;
+             location_t init_loc;
              c_parser_consume_token (parser);
              /* The declaration of the variable is in effect while
                 its initializer is parsed.  */
@@ -1232,12 +1234,14 @@ c_parser_declaration_or_fndef (c_parser *parser, bool fndef_ok, bool empty_ok,
              if (!d)
                d = error_mark_node;
              start_init (d, asm_name, global_bindings_p ());
+             init_loc = c_parser_peek_token (parser)->location;
              init = c_parser_initializer (parser);
              finish_init ();
              if (d != error_mark_node)
                {
                  maybe_warn_string_init (TREE_TYPE (d), init);
-                 finish_decl (d, init.value, init.original_type, asm_name);
+                 finish_decl (d, init_loc, init.value,
+                              init.original_type, asm_name);
                }
            }
          else
@@ -1246,7 +1250,8 @@ c_parser_declaration_or_fndef (c_parser *parser, bool fndef_ok, bool empty_ok,
                                   chainon (postfix_attrs,
                                            all_prefix_attrs));
              if (d)
-               finish_decl (d, NULL_TREE, NULL_TREE, asm_name);
+               finish_decl (d, UNKNOWN_LOCATION, NULL_TREE,
+                            NULL_TREE, asm_name);
            }
          if (c_parser_next_token_is (parser, CPP_COMMA))
            {
@@ -1319,7 +1324,7 @@ c_parser_declaration_or_fndef (c_parser *parser, bool fndef_ok, bool empty_ok,
          add_stmt (fnbody);
          finish_function ();
          c_pop_function_context ();
-         add_stmt (build_stmt (DECL_EXPR, decl));
+         add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl));
        }
       else
        {
@@ -1628,6 +1633,7 @@ c_parser_enum_specifier (c_parser *parser)
   enum_loc = c_parser_peek_token (parser)->location;
   c_parser_consume_token (parser);
   attrs = c_parser_attributes (parser);
+  enum_loc = c_parser_peek_token (parser)->location;
   /* Set the location in case we create a decl now.  */
   c_parser_set_source_position_from_token (c_parser_peek_token (parser));
   if (c_parser_next_token_is (parser, CPP_NAME))
@@ -1641,7 +1647,7 @@ c_parser_enum_specifier (c_parser *parser)
     {
       /* Parse an enum definition.  */
       struct c_enum_contents the_enum;
-      tree type = start_enum (&the_enum, ident, enum_loc);
+      tree type = start_enum (enum_loc, &the_enum, ident);
       tree postfix_attrs;
       /* We chain the enumerators in reverse order, then put them in
         forward order at the end.  */
@@ -1677,8 +1683,8 @@ c_parser_enum_specifier (c_parser *parser)
            }
          else
            enum_value = NULL_TREE;
-         enum_decl = build_enumerator (&the_enum, enum_id, enum_value, 
-                                       value_loc);
+         enum_decl = build_enumerator (value_loc,
+                                       &the_enum, enum_id, enum_value);
          TREE_CHAIN (enum_decl) = values;
          values = enum_decl;
          seen_comma = false;
@@ -1720,13 +1726,13 @@ c_parser_enum_specifier (c_parser *parser)
       ret.expr_const_operands = true;
       return ret;
     }
-  ret = parser_xref_tag (ENUMERAL_TYPE, ident, ident_loc);
+  ret = parser_xref_tag (ident_loc, ENUMERAL_TYPE, ident);
   /* In ISO C, enumerated types can be referred to only if already
      defined.  */
   if (pedantic && !COMPLETE_TYPE_P (ret.spec))
     {
       gcc_assert (ident);
-      pedwarn (ident_loc, OPT_pedantic,
+      pedwarn (enum_loc, OPT_pedantic,
               "ISO C forbids forward references to %<enum%> types");
     }
   return ret;
@@ -1794,8 +1800,10 @@ c_parser_struct_or_union_specifier (c_parser *parser)
   struct_loc = c_parser_peek_token (parser)->location;
   c_parser_consume_token (parser);
   attrs = c_parser_attributes (parser);
+
   /* Set the location in case we create a decl now.  */
   c_parser_set_source_position_from_token (c_parser_peek_token (parser));
+
   if (c_parser_next_token_is (parser, CPP_NAME))
     {
       ident = c_parser_peek_token (parser)->value;
@@ -1809,8 +1817,8 @@ c_parser_struct_or_union_specifier (c_parser *parser)
         tag before parsing components.  */
       bool in_struct;
       VEC(tree,heap) *struct_types;
-      tree type = start_struct (code, ident, &in_struct, &struct_types,
-                               struct_loc);
+      tree type = start_struct (struct_loc, code, ident,
+                               &in_struct, &struct_types);
       tree postfix_attrs;
       /* We chain the components in reverse order, then put them in
         forward order at the end.  Each struct-declaration may
@@ -1899,7 +1907,7 @@ c_parser_struct_or_union_specifier (c_parser *parser)
            }
        }
       postfix_attrs = c_parser_attributes (parser);
-      ret.spec = finish_struct (type, nreverse (contents),
+      ret.spec = finish_struct (struct_loc, type, nreverse (contents),
                                chainon (attrs, postfix_attrs),
                                in_struct, struct_types);
       ret.kind = ctsk_tagdef;
@@ -1916,7 +1924,7 @@ c_parser_struct_or_union_specifier (c_parser *parser)
       ret.expr_const_operands = true;
       return ret;
     }
-  ret = parser_xref_tag (code, ident, ident_loc);
+  ret = parser_xref_tag (ident_loc, code, ident);
   return ret;
 }
 
@@ -2366,6 +2374,7 @@ c_parser_direct_declarator_inner (c_parser *parser, bool id_present,
   /* Parse a sequence of array declarators and parameter lists.  */
   if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
     {
+      location_t brace_loc = c_parser_peek_token (parser)->location; 
       struct c_declarator *declarator;
       struct c_declspecs *quals_attrs = build_null_declspecs ();
       bool static_seen;
@@ -2423,8 +2432,8 @@ c_parser_direct_declarator_inner (c_parser *parser, bool id_present,
                                     "expected %<]%>");
          return NULL;
        }
-      declarator = build_array_declarator (dimen, quals_attrs, static_seen,
-                                          star_seen);
+      declarator = build_array_declarator (brace_loc, dimen, quals_attrs,
+                                          static_seen, star_seen);
       if (declarator == NULL)
        return NULL;
       inner = set_array_declarator_inner (declarator, inner);
@@ -3020,10 +3029,11 @@ c_parser_initializer (c_parser *parser)
   else
     {
       struct c_expr ret;
+      location_t loc = c_parser_peek_token (parser)->location;
       ret = c_parser_expr_no_commas (parser, NULL);
       if (TREE_CODE (ret.value) != STRING_CST
          && TREE_CODE (ret.value) != COMPOUND_LITERAL_EXPR)
-       ret = default_function_array_conversion (ret);
+       ret = default_function_array_conversion (loc, ret);
       return ret;
     }
 }
@@ -3189,10 +3199,13 @@ c_parser_initelt (c_parser *parser)
                  while (c_parser_next_token_is (parser, CPP_COMMA))
                    {
                      struct c_expr next;
+                     location_t comma_loc, exp_loc;
+                     comma_loc = c_parser_peek_token (parser)->location;
                      c_parser_consume_token (parser);
+                     exp_loc = c_parser_peek_token (parser)->location;
                      next = c_parser_expr_no_commas (parser, NULL);
-                     next = default_function_array_conversion (next);
-                     rec = build_compound_expr (rec, next.value);
+                     next = default_function_array_conversion (exp_loc, next);
+                     rec = build_compound_expr (comma_loc, rec, next.value);
                    }
                parse_message_args:
                  /* Now parse the objc-message-args.  */
@@ -3279,11 +3292,12 @@ c_parser_initval (c_parser *parser, struct c_expr *after)
     init = c_parser_braced_init (parser, NULL_TREE, true);
   else
     {
+      location_t loc = c_parser_peek_token (parser)->location;
       init = c_parser_expr_no_commas (parser, after);
       if (init.value != NULL_TREE
          && TREE_CODE (init.value) != STRING_CST
          && TREE_CODE (init.value) != COMPOUND_LITERAL_EXPR)
-       init = default_function_array_conversion (init);
+       init = default_function_array_conversion (loc, init);
     }
   process_init_element (init, false);
 }
@@ -3345,17 +3359,19 @@ static tree
 c_parser_compound_statement (c_parser *parser)
 {
   tree stmt;
+  location_t brace_loc;
+  brace_loc = c_parser_peek_token (parser)->location;
   if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
     {
       /* Ensure a scope is entered and left anyway to avoid confusion
         if we have just prepared to enter a function body.  */
       stmt = c_begin_compound_stmt (true);
-      c_end_compound_stmt (stmt, true);
+      c_end_compound_stmt (brace_loc, stmt, true);
       return error_mark_node;
     }
   stmt = c_begin_compound_stmt (true);
   c_parser_compound_statement_nostart (parser);
-  return c_end_compound_stmt (stmt, true);
+  return c_end_compound_stmt (brace_loc, stmt, true);
 }
 
 /* Parse a compound statement except for the opening brace.  This is
@@ -3377,12 +3393,12 @@ c_parser_compound_statement_nostart (c_parser *parser)
   mark_valid_location_for_stdc_pragma (true);
   if (c_parser_next_token_is_keyword (parser, RID_LABEL))
     {
-      location_t err_loc = c_parser_peek_token (parser)->location;
       /* Read zero or more forward-declarations for labels that nested
         functions can jump to.  */
       mark_valid_location_for_stdc_pragma (false);
       while (c_parser_next_token_is_keyword (parser, RID_LABEL))
        {
+         label_loc = c_parser_peek_token (parser)->location;
          c_parser_consume_token (parser);
          /* Any identifiers, including those declared as type names,
             are OK here.  */
@@ -3397,7 +3413,7 @@ c_parser_compound_statement_nostart (c_parser *parser)
              label
                = declare_label (c_parser_peek_token (parser)->value);
              C_DECLARED_LABEL_FLAG (label) = 1;
-             add_stmt (build_stmt (DECL_EXPR, label));
+             add_stmt (build_stmt (label_loc, DECL_EXPR, label));
              c_parser_consume_token (parser);
              if (c_parser_next_token_is (parser, CPP_COMMA))
                c_parser_consume_token (parser);
@@ -3406,7 +3422,7 @@ c_parser_compound_statement_nostart (c_parser *parser)
            }
          c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
        }
-      pedwarn (err_loc, OPT_pedantic, "ISO C forbids label declarations");
+      pedwarn (label_loc, OPT_pedantic, "ISO C forbids label declarations");
     }
   /* We must now have at least one statement, label or declaration.  */
   if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
@@ -3557,14 +3573,14 @@ c_parser_label (c_parser *parser)
       if (c_parser_next_token_is (parser, CPP_COLON))
        {
          c_parser_consume_token (parser);
-         label = do_case (exp1, NULL_TREE);
+         label = do_case (loc1, exp1, NULL_TREE);
        }
       else if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
        {
          c_parser_consume_token (parser);
          exp2 = c_parser_expr_no_commas (parser, NULL).value;
          if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
-           label = do_case (exp1, exp2);
+           label = do_case (loc1, exp1, exp2);
        }
       else
        c_parser_error (parser, "expected %<:%> or %<...%>");
@@ -3573,7 +3589,7 @@ c_parser_label (c_parser *parser)
     {
       c_parser_consume_token (parser);
       if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
-       label = do_case (NULL_TREE, NULL_TREE);
+       label = do_case (loc1, NULL_TREE, NULL_TREE);
     }
   else
     {
@@ -3590,12 +3606,11 @@ c_parser_label (c_parser *parser)
       if (tlab)
        {
          decl_attributes (&tlab, attrs, 0);
-         label = add_stmt (build_stmt (LABEL_EXPR, tlab));
+         label = add_stmt (build_stmt (loc1, LABEL_EXPR, tlab));
        }
     }
   if (label)
     {
-      SET_EXPR_LOCATION (label, loc1);
       if (c_parser_next_token_starts_declspecs (parser)
          && !(c_parser_next_token_is (parser, CPP_NAME)
               && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
@@ -3754,36 +3769,38 @@ c_parser_statement_after_labels (c_parser *parser)
          c_parser_consume_token (parser);
          if (c_parser_next_token_is (parser, CPP_NAME))
            {
-             stmt = c_finish_goto_label (c_parser_peek_token (parser)->value);
+             stmt = c_finish_goto_label (loc,
+                                         c_parser_peek_token (parser)->value);
              c_parser_consume_token (parser);
            }
          else if (c_parser_next_token_is (parser, CPP_MULT))
            {
              c_parser_consume_token (parser);
-             stmt = c_finish_goto_ptr (c_parser_expression (parser).value);
+             stmt = c_finish_goto_ptr (loc,
+                                       c_parser_expression (parser).value);
            }
          else
            c_parser_error (parser, "expected identifier or %<*%>");
          goto expect_semicolon;
        case RID_CONTINUE:
          c_parser_consume_token (parser);
-         stmt = c_finish_bc_stmt (&c_cont_label, false);
+         stmt = c_finish_bc_stmt (loc, &c_cont_label, false);
          goto expect_semicolon;
        case RID_BREAK:
          c_parser_consume_token (parser);
-         stmt = c_finish_bc_stmt (&c_break_label, true);
+         stmt = c_finish_bc_stmt (loc, &c_break_label, true);
          goto expect_semicolon;
        case RID_RETURN:
          c_parser_consume_token (parser);
          if (c_parser_next_token_is (parser, CPP_SEMICOLON))
            {
-             stmt = c_finish_return (NULL_TREE, NULL_TREE);
+             stmt = c_finish_return (loc, NULL_TREE, NULL_TREE);
              c_parser_consume_token (parser);
            }
          else
            {
              struct c_expr expr = c_parser_expression_conv (parser);
-             stmt = c_finish_return (expr.value, expr.original_type);
+             stmt = c_finish_return (loc, expr.value, expr.original_type);
              goto expect_semicolon;
            }
          break;
@@ -3795,14 +3812,14 @@ c_parser_statement_after_labels (c_parser *parser)
          c_parser_consume_token (parser);
          if (c_parser_next_token_is (parser, CPP_SEMICOLON))
            {
-             stmt = objc_build_throw_stmt (NULL_TREE);
+             stmt = objc_build_throw_stmt (loc, NULL_TREE);
              c_parser_consume_token (parser);
            }
          else
            {
              tree expr = c_parser_expression (parser).value;
              expr = c_fully_fold (expr, false, NULL);
-             stmt = objc_build_throw_stmt (expr);
+             stmt = objc_build_throw_stmt (loc, expr);
              goto expect_semicolon;
            }
          break;
@@ -3835,7 +3852,7 @@ c_parser_statement_after_labels (c_parser *parser)
       break;
     default:
     expr_stmt:
-      stmt = c_finish_expr_stmt (c_parser_expression_conv (parser).value);
+      stmt = c_finish_expr_stmt (loc, c_parser_expression_conv (parser).value);
     expect_semicolon:
       c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
       break;
@@ -3850,7 +3867,9 @@ c_parser_statement_after_labels (c_parser *parser)
      (recursively) all of the component statements should already have
      line numbers assigned.  ??? Can we discard no-op statements
      earlier?  */
-  protected_set_expr_location (stmt, loc);
+  if (CAN_HAVE_LOCATION_P (stmt)
+      && EXPR_LOCATION (stmt) == UNKNOWN_LOCATION)
+    SET_EXPR_LOCATION (stmt, loc);
 
   parser->in_if_block = in_if_block;
 }
@@ -3860,9 +3879,8 @@ c_parser_statement_after_labels (c_parser *parser)
 static tree
 c_parser_condition (c_parser *parser)
 {
-  location_t loc;
+  location_t loc = c_parser_peek_token (parser)->location;
   tree cond;
-  loc = c_parser_peek_token (parser)->location;
   cond = c_parser_expression_conv (parser).value;
   cond = c_objc_common_truthvalue_conversion (loc, cond);
   cond = c_fully_fold (cond, false, NULL);
@@ -3893,8 +3911,9 @@ static tree
 c_parser_c99_block_statement (c_parser *parser)
 {
   tree block = c_begin_compound_stmt (flag_isoc99);
+  location_t loc = c_parser_peek_token (parser)->location;
   c_parser_statement (parser);
-  return c_end_compound_stmt (block, flag_isoc99);
+  return c_end_compound_stmt (loc, block, flag_isoc99);
 }
 
 /* Parse the body of an if statement.  This is just parsing a
@@ -3909,6 +3928,7 @@ static tree
 c_parser_if_body (c_parser *parser, bool *if_p)
 {
   tree block = c_begin_compound_stmt (flag_isoc99);
+  location_t body_loc = c_parser_peek_token (parser)->location;
   while (c_parser_next_token_is_keyword (parser, RID_CASE)
         || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
         || (c_parser_next_token_is (parser, CPP_NAME)
@@ -3918,7 +3938,7 @@ c_parser_if_body (c_parser *parser, bool *if_p)
   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
     {
       location_t loc = c_parser_peek_token (parser)->location;
-      add_stmt (build_empty_stmt ());
+      add_stmt (build_empty_stmt (loc));
       c_parser_consume_token (parser);
       if (!c_parser_next_token_is_keyword (parser, RID_ELSE))
        warning_at (loc, OPT_Wempty_body,
@@ -3928,7 +3948,7 @@ c_parser_if_body (c_parser *parser, bool *if_p)
     add_stmt (c_parser_compound_statement (parser));
   else
     c_parser_statement_after_labels (parser);
-  return c_end_compound_stmt (block, flag_isoc99);
+  return c_end_compound_stmt (body_loc, block, flag_isoc99);
 }
 
 /* Parse the else body of an if statement.  This is just parsing a
@@ -3938,6 +3958,7 @@ c_parser_if_body (c_parser *parser, bool *if_p)
 static tree
 c_parser_else_body (c_parser *parser)
 {
+  location_t else_loc = c_parser_peek_token (parser)->location;
   tree block = c_begin_compound_stmt (flag_isoc99);
   while (c_parser_next_token_is_keyword (parser, RID_CASE)
         || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
@@ -3946,15 +3967,16 @@ c_parser_else_body (c_parser *parser)
     c_parser_label (parser);
   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
     {
-      warning_at (c_parser_peek_token (parser)->location,
+      location_t loc = c_parser_peek_token (parser)->location;
+      warning_at (loc,
                  OPT_Wempty_body,
                 "suggest braces around empty body in an %<else%> statement");
-      add_stmt (build_empty_stmt ());
+      add_stmt (build_empty_stmt (loc));
       c_parser_consume_token (parser);
     }
   else 
     c_parser_statement_after_labels (parser);
-  return c_end_compound_stmt (block, flag_isoc99);
+  return c_end_compound_stmt (else_loc, block, flag_isoc99);
 }
 
 /* Parse an if statement (C90 6.6.4, C99 6.8.4).
@@ -3991,7 +4013,7 @@ c_parser_if_statement (c_parser *parser)
   else
     second_body = NULL_TREE;
   c_finish_if_stmt (loc, cond, first_body, second_body, first_if);
-  add_stmt (c_end_compound_stmt (block, flag_isoc99));
+  add_stmt (c_end_compound_stmt (loc, block, flag_isoc99));
 }
 
 /* Parse a switch statement (C90 6.6.4, C99 6.8.4).
@@ -4004,25 +4026,36 @@ static void
 c_parser_switch_statement (c_parser *parser)
 {
   tree block, expr, body, save_break;
+  location_t switch_loc = c_parser_peek_token (parser)->location;
+  location_t switch_cond_loc;
   gcc_assert (c_parser_next_token_is_keyword (parser, RID_SWITCH));
   c_parser_consume_token (parser);
   block = c_begin_compound_stmt (flag_isoc99);
   if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
     {
+      switch_cond_loc = c_parser_peek_token (parser)->location;
       expr = c_parser_expression (parser).value;
       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
     }
   else
-    expr = error_mark_node;
-  c_start_case (expr);
+    {
+      switch_cond_loc = UNKNOWN_LOCATION;
+      expr = error_mark_node;
+    }
+  c_start_case (switch_loc, switch_cond_loc, expr);
   save_break = c_break_label;
   c_break_label = NULL_TREE;
   body = c_parser_c99_block_statement (parser);
   c_finish_case (body);
   if (c_break_label)
-    add_stmt (build1 (LABEL_EXPR, void_type_node, c_break_label));
+    {
+      location_t here = c_parser_peek_token (parser)->location;
+      tree t = build1 (LABEL_EXPR, void_type_node, c_break_label);
+      SET_EXPR_LOCATION (t, here);
+      add_stmt (t);
+    }
   c_break_label = save_break;
-  add_stmt (c_end_compound_stmt (block, flag_isoc99));
+  add_stmt (c_end_compound_stmt (switch_loc, block, flag_isoc99));
 }
 
 /* Parse a while statement (C90 6.6.5, C99 6.8.5).
@@ -4047,7 +4080,7 @@ c_parser_while_statement (c_parser *parser)
   c_cont_label = NULL_TREE;
   body = c_parser_c99_block_statement (parser);
   c_finish_loop (loc, cond, NULL, body, c_break_label, c_cont_label, true);
-  add_stmt (c_end_compound_stmt (block, flag_isoc99));
+  add_stmt (c_end_compound_stmt (loc, block, flag_isoc99));
   c_break_label = save_break;
   c_cont_label = save_cont;
 }
@@ -4085,7 +4118,7 @@ c_parser_do_statement (c_parser *parser)
   if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
     c_parser_skip_to_end_of_block_or_statement (parser);
   c_finish_loop (loc, cond, NULL, body, new_break, new_cont, false);
-  add_stmt (c_end_compound_stmt (block, flag_isoc99));
+  add_stmt (c_end_compound_stmt (loc, block, flag_isoc99));
 }
 
 /* Parse a for statement (C90 6.6.5, C99 6.8.5).
@@ -4108,9 +4141,9 @@ static void
 c_parser_for_statement (c_parser *parser)
 {
   tree block, cond, incr, save_break, save_cont, body;
-  location_t loc;
+  location_t loc = c_parser_peek_token (parser)->location;
+  location_t for_loc = c_parser_peek_token (parser)->location;
   gcc_assert (c_parser_next_token_is_keyword (parser, RID_FOR));
-  loc = c_parser_peek_token (parser)->location;
   c_parser_consume_token (parser);
   block = c_begin_compound_stmt (flag_isoc99);
   if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
@@ -4119,12 +4152,12 @@ c_parser_for_statement (c_parser *parser)
       if (c_parser_next_token_is (parser, CPP_SEMICOLON))
        {
          c_parser_consume_token (parser);
-         c_finish_expr_stmt (NULL_TREE);
+         c_finish_expr_stmt (loc, NULL_TREE);
        }
       else if (c_parser_next_token_starts_declspecs (parser))
        {
          c_parser_declaration_or_fndef (parser, true, true, true, true);
-         check_for_loop_decls ();
+         check_for_loop_decls (for_loc);
        }
       else if (c_parser_next_token_is_keyword (parser, RID_EXTENSION))
        {
@@ -4143,7 +4176,7 @@ c_parser_for_statement (c_parser *parser)
              c_parser_consume_token (parser);
              c_parser_declaration_or_fndef (parser, true, true, true, true);
              restore_extension_diagnostics (ext);
-             check_for_loop_decls ();
+             check_for_loop_decls (for_loc);
            }
          else
            goto init_expr;
@@ -4151,7 +4184,7 @@ c_parser_for_statement (c_parser *parser)
       else
        {
        init_expr:
-         c_finish_expr_stmt (c_parser_expression (parser).value);
+         c_finish_expr_stmt (loc, c_parser_expression (parser).value);
          c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
        }
       /* Parse the loop condition.  */
@@ -4167,9 +4200,9 @@ c_parser_for_statement (c_parser *parser)
        }
       /* Parse the increment expression.  */
       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
-       incr = c_process_expr_stmt (NULL_TREE);
+       incr = c_process_expr_stmt (loc, NULL_TREE);
       else
-       incr = c_process_expr_stmt (c_parser_expression (parser).value);
+       incr = c_process_expr_stmt (loc, c_parser_expression (parser).value);
       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
     }
   else
@@ -4183,7 +4216,7 @@ c_parser_for_statement (c_parser *parser)
   c_cont_label = NULL_TREE;
   body = c_parser_c99_block_statement (parser);
   c_finish_loop (loc, cond, incr, body, c_break_label, c_cont_label, true);
-  add_stmt (c_end_compound_stmt (block, flag_isoc99));
+  add_stmt (c_end_compound_stmt (loc, block, flag_isoc99));
   c_break_label = save_break;
   c_cont_label = save_cont;
 }
@@ -4209,6 +4242,7 @@ c_parser_asm_statement (c_parser *parser)
 {
   tree quals, str, outputs, inputs, clobbers, ret;
   bool simple;
+  location_t asm_loc = c_parser_peek_token (parser)->location;
   gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM));
   c_parser_consume_token (parser);
   if (c_parser_next_token_is_keyword (parser, RID_VOLATILE))
@@ -4304,7 +4338,7 @@ c_parser_asm_statement (c_parser *parser)
     }
   if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
     c_parser_skip_to_end_of_block_or_statement (parser);
-  ret = build_asm_stmt (quals, build_asm_expr (str, outputs, inputs,
+  ret = build_asm_stmt (quals, build_asm_expr (asm_loc, str, outputs, inputs,
                                               clobbers, simple));
   return ret;
 }
@@ -4326,6 +4360,7 @@ static tree
 c_parser_asm_operands (c_parser *parser, bool convert_p)
 {
   tree list = NULL_TREE;
+  location_t loc;
   while (true)
     {
       tree name, str;
@@ -4360,9 +4395,10 @@ c_parser_asm_operands (c_parser *parser, bool convert_p)
          parser->lex_untranslated_string = true;
          return NULL_TREE;
        }
+      loc = c_parser_peek_token (parser)->location;
       expr = c_parser_expression (parser);
       if (convert_p)
-       expr = default_function_array_conversion (expr);
+       expr = default_function_array_conversion (loc, expr);
       expr.value = c_fully_fold (expr.value, false, NULL);
       parser->lex_untranslated_string = true;
       if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
@@ -4427,7 +4463,7 @@ c_parser_expr_no_commas (c_parser *parser, struct c_expr *after)
 {
   struct c_expr lhs, rhs, ret;
   enum tree_code code;
-  location_t op_location;
+  location_t op_location, exp_location;
   gcc_assert (!after || c_dialect_objc ());
   lhs = c_parser_conditional_expression (parser, after);
   op_location = c_parser_peek_token (parser)->location;
@@ -4470,10 +4506,12 @@ c_parser_expr_no_commas (c_parser *parser, struct c_expr *after)
       return lhs;
     }
   c_parser_consume_token (parser);
+  exp_location = c_parser_peek_token (parser)->location;
   rhs = c_parser_expr_no_commas (parser, NULL);
-  rhs = default_function_array_conversion (rhs);
+  rhs = default_function_array_conversion (exp_location, rhs);
   ret.value = build_modify_expr (op_location, lhs.value, lhs.original_type,
-                                code, rhs.value, rhs.original_type);
+                                code, exp_location, rhs.value,
+                                rhs.original_type);
   if (code == NOP_EXPR)
     ret.original_code = MODIFY_EXPR;
   else
@@ -4507,12 +4545,12 @@ c_parser_conditional_expression (c_parser *parser, struct c_expr *after)
 
   gcc_assert (!after || c_dialect_objc ());
 
-  cond_loc = c_parser_peek_token (parser)->location;
   cond = c_parser_binary_expression (parser, after);
 
   if (c_parser_next_token_is_not (parser, CPP_QUERY))
     return cond;
-  cond = default_function_array_conversion (cond);
+  cond_loc = c_parser_peek_token (parser)->location;
+  cond = default_function_array_conversion (cond_loc, cond);
   c_parser_consume_token (parser);
   if (c_parser_next_token_is (parser, CPP_COLON))
     {
@@ -4552,8 +4590,11 @@ c_parser_conditional_expression (c_parser *parser, struct c_expr *after)
       ret.original_type = NULL;
       return ret;
     }
-  exp2 = c_parser_conditional_expression (parser, NULL);
-  exp2 = default_function_array_conversion (exp2);
+  {
+    location_t exp2_loc = c_parser_peek_token (parser)->location;
+    exp2 = c_parser_conditional_expression (parser, NULL);
+    exp2 = default_function_array_conversion (exp2_loc, exp2);
+  }
   skip_evaluation -= cond.value == truthvalue_true_node;
   ret.value = build_conditional_expr (colon_loc, cond.value,
                                      cond.original_code == C_MAYBE_CONST_EXPR,
@@ -4702,9 +4743,10 @@ c_parser_binary_expression (c_parser *parser, struct c_expr *after)
        break;                                                                \
       }                                                                              \
     stack[sp - 1].expr                                                       \
-      = default_function_array_conversion (stack[sp - 1].expr);                      \
+      = default_function_array_conversion (stack[sp - 1].loc,                \
+                                          stack[sp - 1].expr);               \
     stack[sp].expr                                                           \
-      = default_function_array_conversion (stack[sp].expr);                  \
+      = default_function_array_conversion (stack[sp].loc, stack[sp].expr);    \
     stack[sp - 1].expr = parser_build_binary_op (stack[sp].loc,                      \
                                                 stack[sp].op,                \
                                                 stack[sp - 1].expr,          \
@@ -4809,14 +4851,16 @@ c_parser_binary_expression (c_parser *parser, struct c_expr *after)
        {
        case TRUTH_ANDIF_EXPR:
          stack[sp].expr
-           = default_function_array_conversion (stack[sp].expr);
+           = default_function_array_conversion (stack[sp].loc,
+                                                stack[sp].expr);
          stack[sp].expr.value = c_objc_common_truthvalue_conversion
            (stack[sp].loc, default_conversion (stack[sp].expr.value));
          skip_evaluation += stack[sp].expr.value == truthvalue_false_node;
          break;
        case TRUTH_ORIF_EXPR:
          stack[sp].expr
-           = default_function_array_conversion (stack[sp].expr);
+           = default_function_array_conversion (stack[sp].loc,
+                                                stack[sp].expr);
          stack[sp].expr.value = c_objc_common_truthvalue_conversion
            (stack[sp].loc, default_conversion (stack[sp].expr.value));
          skip_evaluation += stack[sp].expr.value == truthvalue_true_node;
@@ -4829,6 +4873,7 @@ c_parser_binary_expression (c_parser *parser, struct c_expr *after)
       stack[sp].expr = c_parser_cast_expression (parser, NULL);
       stack[sp].prec = oprec;
       stack[sp].op = ocode;
+      stack[sp].loc = binary_loc;
     }
  out:
   while (sp > 0)
@@ -4849,9 +4894,11 @@ c_parser_binary_expression (c_parser *parser, struct c_expr *after)
 static struct c_expr
 c_parser_cast_expression (c_parser *parser, struct c_expr *after)
 {
+  location_t cast_loc = c_parser_peek_token (parser)->location;
   gcc_assert (!after || c_dialect_objc ());
   if (after)
-    return c_parser_postfix_expression_after_primary (parser, *after);
+    return c_parser_postfix_expression_after_primary (parser,
+                                                     cast_loc, *after);
   /* If the expression begins with a parenthesized type name, it may
      be either a cast or a compound literal; we need to see whether
      the next character is '{' to tell the difference.  If not, it is
@@ -4859,12 +4906,10 @@ c_parser_cast_expression (c_parser *parser, struct c_expr *after)
   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
       && c_token_starts_typename (c_parser_peek_2nd_token (parser)))
     {
-      location_t loc;
       struct c_type_name *type_name;
       struct c_expr ret;
       struct c_expr expr;
       c_parser_consume_token (parser);
-      loc = c_parser_peek_token (parser)->location;
       type_name = c_parser_type_name (parser);
       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
       if (type_name == NULL)
@@ -4880,10 +4925,13 @@ c_parser_cast_expression (c_parser *parser, struct c_expr *after)
 
       if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
        return c_parser_postfix_expression_after_paren_type (parser, type_name,
-                                                            loc);
-      expr = c_parser_cast_expression (parser, NULL);
-      expr = default_function_array_conversion (expr);
-      ret.value = c_cast_expr (type_name, expr.value, loc);
+                                                            cast_loc);
+      {
+       location_t expr_loc = c_parser_peek_token (parser)->location;
+       expr = c_parser_cast_expression (parser, NULL);
+       expr = default_function_array_conversion (expr_loc, expr);
+      }
+      ret.value = c_cast_expr (cast_loc, type_name, expr.value);
       ret.original_code = ERROR_MARK;
       ret.original_type = NULL;
       return ret;
@@ -4924,63 +4972,70 @@ c_parser_unary_expression (c_parser *parser)
 {
   int ext;
   struct c_expr ret, op;
-  location_t loc = c_parser_peek_token (parser)->location;
+  location_t op_loc = c_parser_peek_token (parser)->location;
+  location_t exp_loc;
   ret.original_code = ERROR_MARK;
   ret.original_type = NULL;
   switch (c_parser_peek_token (parser)->type)
     {
     case CPP_PLUS_PLUS:
       c_parser_consume_token (parser);
+      exp_loc = c_parser_peek_token (parser)->location;
       op = c_parser_cast_expression (parser, NULL);
-      op = default_function_array_conversion (op);
-      return parser_build_unary_op (PREINCREMENT_EXPR, op, loc);
+      op = default_function_array_conversion (exp_loc, op);
+      return parser_build_unary_op (op_loc, PREINCREMENT_EXPR, op);
     case CPP_MINUS_MINUS:
       c_parser_consume_token (parser);
+      exp_loc = c_parser_peek_token (parser)->location;
       op = c_parser_cast_expression (parser, NULL);
-      op = default_function_array_conversion (op);
-      return parser_build_unary_op (PREDECREMENT_EXPR, op, loc);
+      op = default_function_array_conversion (exp_loc, op);
+      return parser_build_unary_op (op_loc, PREDECREMENT_EXPR, op);
     case CPP_AND:
       c_parser_consume_token (parser);
-      return parser_build_unary_op (ADDR_EXPR,
-                                   c_parser_cast_expression (parser, NULL),
-                                   loc);
+      return parser_build_unary_op (op_loc, ADDR_EXPR,
+                                   c_parser_cast_expression (parser, NULL));
     case CPP_MULT:
       c_parser_consume_token (parser);
+      exp_loc = c_parser_peek_token (parser)->location;
       op = c_parser_cast_expression (parser, NULL);
-      op = default_function_array_conversion (op);
-      ret.value = build_indirect_ref (loc, op.value, "unary *");
+      op = default_function_array_conversion (exp_loc, op);
+      ret.value = build_indirect_ref (op_loc, op.value, "unary *");
       return ret;
     case CPP_PLUS:
       if (!c_dialect_objc () && !in_system_header)
-       warning_at (c_parser_peek_token (parser)->location,
+       warning_at (op_loc,
                    OPT_Wtraditional,
                    "traditional C rejects the unary plus operator");
       c_parser_consume_token (parser);
+      exp_loc = c_parser_peek_token (parser)->location;
       op = c_parser_cast_expression (parser, NULL);
-      op = default_function_array_conversion (op);
-      return parser_build_unary_op (CONVERT_EXPR, op, loc);
+      op = default_function_array_conversion (exp_loc, op);
+      return parser_build_unary_op (op_loc, CONVERT_EXPR, op);
     case CPP_MINUS:
       c_parser_consume_token (parser);
+      exp_loc = c_parser_peek_token (parser)->location;
       op = c_parser_cast_expression (parser, NULL);
-      op = default_function_array_conversion (op);
-      return parser_build_unary_op (NEGATE_EXPR, op, loc);
+      op = default_function_array_conversion (exp_loc, op);
+      return parser_build_unary_op (op_loc, NEGATE_EXPR, op);
     case CPP_COMPL:
       c_parser_consume_token (parser);
+      exp_loc = c_parser_peek_token (parser)->location;
       op = c_parser_cast_expression (parser, NULL);
-      op = default_function_array_conversion (op);
-      return parser_build_unary_op (BIT_NOT_EXPR, op, loc);
+      op = default_function_array_conversion (exp_loc, op);
+      return parser_build_unary_op (op_loc, BIT_NOT_EXPR, op);
     case CPP_NOT:
       c_parser_consume_token (parser);
+      exp_loc = c_parser_peek_token (parser)->location;
       op = c_parser_cast_expression (parser, NULL);
-      op = default_function_array_conversion (op);
-      return parser_build_unary_op (TRUTH_NOT_EXPR, op, loc);
+      op = default_function_array_conversion (exp_loc, op);
+      return parser_build_unary_op (op_loc, TRUTH_NOT_EXPR, op);
     case CPP_AND_AND:
       /* Refer to the address of a label as a pointer.  */
       c_parser_consume_token (parser);
       if (c_parser_next_token_is (parser, CPP_NAME))
        {
          ret.value = finish_label_address_expr
-           (c_parser_peek_token (parser)->value, loc);
+           (c_parser_peek_token (parser)->value, op_loc);
          c_parser_consume_token (parser);
        }
       else
@@ -5004,14 +5059,16 @@ c_parser_unary_expression (c_parser *parser)
          return ret;
        case RID_REALPART:
          c_parser_consume_token (parser);
+         exp_loc = c_parser_peek_token (parser)->location;
          op = c_parser_cast_expression (parser, NULL);
-         op = default_function_array_conversion (op);
-         return parser_build_unary_op (REALPART_EXPR, op, loc);
+         op = default_function_array_conversion (exp_loc, op);
+         return parser_build_unary_op (op_loc, REALPART_EXPR, op);
        case RID_IMAGPART:
          c_parser_consume_token (parser);
+         exp_loc = c_parser_peek_token (parser)->location;
          op = c_parser_cast_expression (parser, NULL);
-         op = default_function_array_conversion (op);
-         return parser_build_unary_op (IMAGPART_EXPR, op, loc);
+         op = default_function_array_conversion (exp_loc, op);
+         return parser_build_unary_op (op_loc, IMAGPART_EXPR, op);
        default:
          return c_parser_postfix_expression (parser);
        }
@@ -5061,7 +5118,7 @@ c_parser_sizeof_expression (c_parser *parser)
       /* sizeof ( type-name ).  */
       skip_evaluation--;
       in_sizeof--;
-      return c_expr_sizeof_type (type_name);
+      return c_expr_sizeof_type (expr_loc, type_name);
     }
   else
     {
@@ -5073,7 +5130,7 @@ c_parser_sizeof_expression (c_parser *parser)
       if (TREE_CODE (expr.value) == COMPONENT_REF
          && DECL_C_BIT_FIELD (TREE_OPERAND (expr.value, 1)))
        error_at (expr_loc, "%<sizeof%> applied to a bit-field");
-      return c_expr_sizeof_expr (expr);
+      return c_expr_sizeof_expr (expr_loc, expr);
     }
 }
 
@@ -5083,6 +5140,7 @@ static struct c_expr
 c_parser_alignof_expression (c_parser *parser)
 {
   struct c_expr expr;
+  location_t loc = c_parser_peek_token (parser)->location;
   gcc_assert (c_parser_next_token_is_keyword (parser, RID_ALIGNOF));
   c_parser_consume_token (parser);
   skip_evaluation++;
@@ -5119,7 +5177,7 @@ c_parser_alignof_expression (c_parser *parser)
       /* alignof ( type-name ).  */
       skip_evaluation--;
       in_alignof--;
-      ret.value = c_alignof (groktypename (type_name, NULL, NULL));
+      ret.value = c_alignof (loc, groktypename (type_name, NULL, NULL));
       ret.original_code = ERROR_MARK;
       ret.original_type = NULL;
       return ret;
@@ -5131,7 +5189,7 @@ c_parser_alignof_expression (c_parser *parser)
     alignof_expr:
       skip_evaluation--;
       in_alignof--;
-      ret.value = c_alignof_expr (expr.value);
+      ret.value = c_alignof_expr (loc, expr.value);
       ret.original_code = ERROR_MARK;
       ret.original_type = NULL;
       return ret;
@@ -5196,7 +5254,7 @@ c_parser_postfix_expression (c_parser *parser)
 {
   struct c_expr expr, e1, e2, e3;
   struct c_type_name *t1, *t2;
-  location_t loc;
+  location_t loc = c_parser_peek_token (parser)->location;;
   expr.original_code = ERROR_MARK;
   expr.original_type = NULL;
   switch (c_parser_peek_token (parser)->type)
@@ -5242,11 +5300,10 @@ c_parser_postfix_expression (c_parser *parser)
        }
       {
        tree id = c_parser_peek_token (parser)->value;
-       location_t loc = c_parser_peek_token (parser)->location;
        c_parser_consume_token (parser);
-       expr.value = build_external_ref (id,
+       expr.value = build_external_ref (loc, id,
                                         (c_parser_peek_token (parser)->type
-                                         == CPP_OPEN_PAREN), loc,
+                                         == CPP_OPEN_PAREN),
                                         &expr.original_type);
       }
       break;
@@ -5257,12 +5314,13 @@ c_parser_postfix_expression (c_parser *parser)
        {
          /* A statement expression.  */
          tree stmt;
-         location_t here = c_parser_peek_token (parser)->location;
+         location_t brace_loc;
          c_parser_consume_token (parser);
+         brace_loc = c_parser_peek_token (parser)->location;
          c_parser_consume_token (parser);
          if (cur_stmt_list == NULL)
            {
-             error_at (here, "braced-group within expression allowed "
+             error_at (loc, "braced-group within expression allowed "
                        "only inside a function");
              parser->error = true;
              c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
@@ -5274,9 +5332,9 @@ c_parser_postfix_expression (c_parser *parser)
          c_parser_compound_statement_nostart (parser);
          c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
                                     "expected %<)%>");
-         pedwarn (here, OPT_pedantic, 
+         pedwarn (loc, OPT_pedantic, 
                   "ISO C forbids braced-groups within expressions");
-         expr.value = c_finish_stmt_expr (stmt);
+         expr.value = c_finish_stmt_expr (brace_loc, stmt);
        }
       else if (c_token_starts_typename (c_parser_peek_2nd_token (parser)))
        {
@@ -5320,7 +5378,7 @@ c_parser_postfix_expression (c_parser *parser)
        case RID_FUNCTION_NAME:
        case RID_PRETTY_FUNCTION_NAME:
        case RID_C99_FUNCTION_NAME:
-         expr.value = fname_decl (c_parser_peek_token (parser)->location,
+         expr.value = fname_decl (loc,
                                   c_parser_peek_token (parser)->keyword,
                                   c_parser_peek_token (parser)->value);
          c_parser_consume_token (parser);
@@ -5351,9 +5409,8 @@ c_parser_postfix_expression (c_parser *parser)
          else
            {
              tree type_expr = NULL_TREE;
-             expr.value = c_build_va_arg (e1.value,
-                                          groktypename (t1, &type_expr, NULL),
-                                          loc);
+             expr.value = c_build_va_arg (loc, e1.value,
+                                          groktypename (t1, &type_expr, NULL));
              if (type_expr)
                {
                  expr.value = build2 (C_MAYBE_CONST_EXPR,
@@ -5388,14 +5445,17 @@ c_parser_postfix_expression (c_parser *parser)
            if (type == error_mark_node)
              offsetof_ref = error_mark_node;
            else
-             offsetof_ref = build1 (INDIRECT_REF, type, null_pointer_node);
+             {
+               offsetof_ref = build1 (INDIRECT_REF, type, null_pointer_node);
+               SET_EXPR_LOCATION (offsetof_ref, loc);
+             }
            /* Parse the second argument to __builtin_offsetof.  We
               must have one identifier, and beyond that we want to
               accept sub structure and sub array references.  */
            if (c_parser_next_token_is (parser, CPP_NAME))
              {
                offsetof_ref = build_component_ref
-                 (offsetof_ref, c_parser_peek_token (parser)->value);
+                 (loc, offsetof_ref, c_parser_peek_token (parser)->value);
                c_parser_consume_token (parser);
                while (c_parser_next_token_is (parser, CPP_DOT)
                       || c_parser_next_token_is (parser,
@@ -5406,9 +5466,9 @@ c_parser_postfix_expression (c_parser *parser)
                    if (c_parser_next_token_is (parser, CPP_DEREF))
                      {
                        loc = c_parser_peek_token (parser)->location;
-                       offsetof_ref = build_array_ref (offsetof_ref,
-                                                       integer_zero_node,
-                                                       loc);
+                       offsetof_ref = build_array_ref (loc,
+                                                       offsetof_ref,
+                                                       integer_zero_node);
                        goto do_dot;
                      }
                    else if (c_parser_next_token_is (parser, CPP_DOT))
@@ -5422,7 +5482,7 @@ c_parser_postfix_expression (c_parser *parser)
                            break;
                          }
                        offsetof_ref = build_component_ref
-                         (offsetof_ref,
+                         (loc, offsetof_ref,
                           c_parser_peek_token (parser)->value);
                        c_parser_consume_token (parser);
                      }
@@ -5435,7 +5495,7 @@ c_parser_postfix_expression (c_parser *parser)
                        idx = c_fully_fold (idx, false, NULL);
                        c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
                                                   "expected %<]%>");
-                       offsetof_ref = build_array_ref (offsetof_ref, idx, loc);
+                       offsetof_ref = build_array_ref (loc, offsetof_ref, idx);
                      }
                  }
              }
@@ -5534,7 +5594,7 @@ c_parser_postfix_expression (c_parser *parser)
            tree sel = c_parser_objc_selector_arg (parser);
            c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
                                       "expected %<)%>");
-           expr.value = objc_build_selector_expr (sel);
+           expr.value = objc_build_selector_expr (loc, sel);
          }
          break;
        case RID_AT_PROTOCOL:
@@ -5608,7 +5668,7 @@ c_parser_postfix_expression (c_parser *parser)
       expr.value = error_mark_node;
       break;
     }
-  return c_parser_postfix_expression_after_primary (parser, expr);
+  return c_parser_postfix_expression_after_primary (parser, loc, expr);
 }
 
 /* Parse a postfix expression after a parenthesized type name: the
@@ -5633,7 +5693,7 @@ c_parser_postfix_expression_after_paren_type (c_parser *parser,
   location_t start_loc;
   tree type_expr = NULL_TREE;
   bool type_expr_const = true;
-  check_compound_literal_type (type_name, type_loc);
+  check_compound_literal_type (type_loc, type_name);
   start_init (NULL_TREE, NULL, 0);
   type = groktypename (type_name, &type_expr, &type_expr_const);
   start_loc = c_parser_peek_token (parser)->location;
@@ -5652,7 +5712,7 @@ c_parser_postfix_expression_after_paren_type (c_parser *parser,
               ? CONSTRUCTOR_NON_CONST (init.value)
               : init.original_code == C_MAYBE_CONST_EXPR);
   non_const |= !type_expr_const;
-  expr.value = build_compound_literal (type, init.value, non_const);
+  expr.value = build_compound_literal (start_loc, type, init.value, non_const);
   expr.original_code = ERROR_MARK;
   expr.original_type = NULL;
   if (type_expr)
@@ -5669,33 +5729,35 @@ c_parser_postfix_expression_after_paren_type (c_parser *parser,
                               type_expr, expr.value);
        }
     }
-  return c_parser_postfix_expression_after_primary (parser, expr);
+  return c_parser_postfix_expression_after_primary (parser, start_loc, expr);
 }
 
 /* Parse a postfix expression after the initial primary or compound
-   literal; that is, parse a series of postfix operators.  */
+   literal; that is, parse a series of postfix operators.
+
+   EXPR_LOC is the location of the primary expression.  */
 
 static struct c_expr
 c_parser_postfix_expression_after_primary (c_parser *parser,
+                                          location_t expr_loc,
                                           struct c_expr expr)
 {
   struct c_expr orig_expr;
   tree ident, idx;
   VEC(tree,gc) *exprlist;
   VEC(tree,gc) *origtypes;
-  location_t loc = c_parser_peek_token (parser)->location;
   while (true)
     {
+      location_t op_loc = c_parser_peek_token (parser)->location;
       switch (c_parser_peek_token (parser)->type)
        {
        case CPP_OPEN_SQUARE:
          /* Array reference.  */
-         loc = c_parser_peek_token (parser)->location;
          c_parser_consume_token (parser);
          idx = c_parser_expression (parser).value;
          c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
                                     "expected %<]%>");
-         expr.value = build_array_ref (expr.value, idx, loc);
+         expr.value = build_array_ref (op_loc, expr.value, idx);
          expr.original_code = ERROR_MARK;
          expr.original_type = NULL;
          break;
@@ -5709,7 +5771,9 @@ c_parser_postfix_expression_after_primary (c_parser *parser,
          c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
                                     "expected %<)%>");
          orig_expr = expr;
-         expr.value = build_function_call_vec (expr.value, exprlist,
+         /* FIXME diagnostics: Ideally we want the FUNCNAME, not the
+            "(" after the FUNCNAME, which is what we have now.    */
+         expr.value = build_function_call_vec (op_loc, expr.value, exprlist,
                                                origtypes);
          expr.original_code = ERROR_MARK;
          if (TREE_CODE (expr.value) == INTEGER_CST
@@ -5727,7 +5791,7 @@ c_parser_postfix_expression_after_primary (c_parser *parser,
        case CPP_DOT:
          /* Structure element reference.  */
          c_parser_consume_token (parser);
-         expr = default_function_array_conversion (expr);
+         expr = default_function_array_conversion (expr_loc, expr);
          if (c_parser_next_token_is (parser, CPP_NAME))
            ident = c_parser_peek_token (parser)->value;
          else
@@ -5739,7 +5803,7 @@ c_parser_postfix_expression_after_primary (c_parser *parser,
              return expr;
            }
          c_parser_consume_token (parser);
-         expr.value = build_component_ref (expr.value, ident);
+         expr.value = build_component_ref (op_loc, expr.value, ident);
          expr.original_code = ERROR_MARK;
          if (TREE_CODE (expr.value) != COMPONENT_REF)
            expr.original_type = NULL;
@@ -5756,7 +5820,7 @@ c_parser_postfix_expression_after_primary (c_parser *parser,
        case CPP_DEREF:
          /* Structure element reference.  */
          c_parser_consume_token (parser);
-         expr = default_function_array_conversion (expr);
+         expr = default_function_array_conversion (expr_loc, expr);
          if (c_parser_next_token_is (parser, CPP_NAME))
            ident = c_parser_peek_token (parser)->value;
          else
@@ -5768,7 +5832,8 @@ c_parser_postfix_expression_after_primary (c_parser *parser,
              return expr;
            }
          c_parser_consume_token (parser);
-         expr.value = build_component_ref (build_indirect_ref (loc,
+         expr.value = build_component_ref (op_loc,
+                                           build_indirect_ref (op_loc,
                                                                expr.value,
                                                                "->"),
                                            ident);
@@ -5788,8 +5853,8 @@ c_parser_postfix_expression_after_primary (c_parser *parser,
        case CPP_PLUS_PLUS:
          /* Postincrement.  */
          c_parser_consume_token (parser);
-         expr = default_function_array_conversion (expr);
-         expr.value = build_unary_op (loc,
+         expr = default_function_array_conversion (expr_loc, expr);
+         expr.value = build_unary_op (op_loc,
                                       POSTINCREMENT_EXPR, expr.value, 0);
          expr.original_code = ERROR_MARK;
          expr.original_type = NULL;
@@ -5797,8 +5862,8 @@ c_parser_postfix_expression_after_primary (c_parser *parser,
        case CPP_MINUS_MINUS:
          /* Postdecrement.  */
          c_parser_consume_token (parser);
-         expr = default_function_array_conversion (expr);
-         expr.value = build_unary_op (loc,
+         expr = default_function_array_conversion (expr_loc, expr);
+         expr.value = build_unary_op (op_loc,
                                       POSTDECREMENT_EXPR, expr.value, 0);
          expr.original_code = ERROR_MARK;
          expr.original_type = NULL;
@@ -5824,10 +5889,13 @@ c_parser_expression (c_parser *parser)
   while (c_parser_next_token_is (parser, CPP_COMMA))
     {
       struct c_expr next;
+      location_t loc = c_parser_peek_token (parser)->location;
+      location_t expr_loc;
       c_parser_consume_token (parser);
+      expr_loc = c_parser_peek_token (parser)->location;
       next = c_parser_expr_no_commas (parser, NULL);
-      next = default_function_array_conversion (next);
-      expr.value = build_compound_expr (expr.value, next.value);
+      next = default_function_array_conversion (expr_loc, next);
+      expr.value = build_compound_expr (loc, expr.value, next.value);
       expr.original_code = COMPOUND_EXPR;
       expr.original_type = next.original_type;
     }
@@ -5841,8 +5909,9 @@ static struct c_expr
 c_parser_expression_conv (c_parser *parser)
 {
   struct c_expr expr;
+  location_t loc = c_parser_peek_token (parser)->location;
   expr = c_parser_expression (parser);
-  expr = default_function_array_conversion (expr);
+  expr = default_function_array_conversion (loc, expr);
   return expr;
 }
 
@@ -5861,6 +5930,7 @@ c_parser_expr_list (c_parser *parser, bool convert_p, bool fold_p,
   VEC(tree,gc) *ret;
   VEC(tree,gc) *orig_types;
   struct c_expr expr;
+  location_t loc = c_parser_peek_token (parser)->location;
 
   ret = make_tree_vector ();
   if (p_orig_types == NULL)
@@ -5870,7 +5940,7 @@ c_parser_expr_list (c_parser *parser, bool convert_p, bool fold_p,
 
   expr = c_parser_expr_no_commas (parser, NULL);
   if (convert_p)
-    expr = default_function_array_conversion (expr);
+    expr = default_function_array_conversion (loc, expr);
   if (fold_p)
     expr.value = c_fully_fold (expr.value, false, NULL);
   VEC_quick_push (tree, ret, expr.value);
@@ -5879,9 +5949,10 @@ c_parser_expr_list (c_parser *parser, bool convert_p, bool fold_p,
   while (c_parser_next_token_is (parser, CPP_COMMA))
     {
       c_parser_consume_token (parser);
+      loc = c_parser_peek_token (parser)->location;
       expr = c_parser_expr_no_commas (parser, NULL);
       if (convert_p)
-       expr = default_function_array_conversion (expr);
+       expr = default_function_array_conversion (loc, expr);
       if (fold_p)
        expr.value = c_fully_fold (expr.value, false, NULL);
       VEC_safe_push (tree, gc, ret, expr.value);
@@ -6998,7 +7069,8 @@ check_no_duplicate_clause (tree clauses, enum omp_clause_code code,
   for (c = clauses; c ; c = OMP_CLAUSE_CHAIN (c))
     if (OMP_CLAUSE_CODE (c) == code)
       {
-       error ("too many %qs clauses", name);
+       location_t loc = OMP_CLAUSE_LOCATION (c);
+       error_at (loc, "too many %qs clauses", name);
        break;
       }
 }
@@ -7008,14 +7080,17 @@ check_no_duplicate_clause (tree clauses, enum omp_clause_code code,
      identifier
      variable-list , identifier
 
-   If KIND is nonzero, create the appropriate node and install the decl
-   in OMP_CLAUSE_DECL and add the node to the head of the list.
+   If KIND is nonzero, create the appropriate node and install the
+   decl in OMP_CLAUSE_DECL and add the node to the head of the list.
+   If KIND is nonzero, CLAUSE_LOC is the location of the clause.
 
    If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
    return the list created.  */
 
 static tree
-c_parser_omp_variable_list (c_parser *parser, enum omp_clause_code kind,
+c_parser_omp_variable_list (c_parser *parser,
+                           location_t clause_loc,
+                           enum omp_clause_code kind,
                             tree list)
 {
   if (c_parser_next_token_is_not (parser, CPP_NAME)
@@ -7028,13 +7103,13 @@ c_parser_omp_variable_list (c_parser *parser, enum omp_clause_code kind,
       tree t = lookup_name (c_parser_peek_token (parser)->value);
 
       if (t == NULL_TREE)
-       undeclared_variable (c_parser_peek_token (parser)->value,
-                            c_parser_peek_token (parser)->location);
+       undeclared_variable (c_parser_peek_token (parser)->location,
+                            c_parser_peek_token (parser)->value);
       else if (t == error_mark_node)
        ;
       else if (kind != 0)
        {
-         tree u = build_omp_clause (kind);
+         tree u = build_omp_clause (clause_loc, kind);
          OMP_CLAUSE_DECL (u) = t;
          OMP_CLAUSE_CHAIN (u) = list;
          list = u;
@@ -7060,9 +7135,12 @@ static tree
 c_parser_omp_var_list_parens (c_parser *parser, enum omp_clause_code kind,
                              tree list)
 {
+  /* The clauses location.  */
+  location_t loc = c_parser_peek_token (parser)->location;
+
   if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
     {
-      list = c_parser_omp_variable_list (parser, kind, list);
+      list = c_parser_omp_variable_list (parser, loc, kind, list);
       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
     }
   return list;
@@ -7097,7 +7175,7 @@ c_parser_omp_clause_collapse (c_parser *parser, tree list)
                "collapse argument needs positive constant integer expression");
       return list;
     }
-  c = build_omp_clause (OMP_CLAUSE_COLLAPSE);
+  c = build_omp_clause (loc, OMP_CLAUSE_COLLAPSE);
   OMP_CLAUSE_COLLAPSE_EXPR (c) = num;
   OMP_CLAUSE_CHAIN (c) = list;
   return c;
@@ -7128,6 +7206,7 @@ static tree
 c_parser_omp_clause_default (c_parser *parser, tree list)
 {
   enum omp_clause_default_kind kind = OMP_CLAUSE_DEFAULT_UNSPECIFIED;
+  location_t loc = c_parser_peek_token (parser)->location;
   tree c;
 
   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
@@ -7167,7 +7246,7 @@ c_parser_omp_clause_default (c_parser *parser, tree list)
     return list;
 
   check_no_duplicate_clause (list, OMP_CLAUSE_DEFAULT, "default");
-  c = build_omp_clause (OMP_CLAUSE_DEFAULT);
+  c = build_omp_clause (loc, OMP_CLAUSE_DEFAULT);
   OMP_CLAUSE_CHAIN (c) = list;
   OMP_CLAUSE_DEFAULT_KIND (c) = kind;
 
@@ -7189,6 +7268,7 @@ c_parser_omp_clause_firstprivate (c_parser *parser, tree list)
 static tree
 c_parser_omp_clause_if (c_parser *parser, tree list)
 {
+  location_t loc = c_parser_peek_token (parser)->location;
   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
     {
       tree t = c_parser_paren_condition (parser);
@@ -7196,7 +7276,7 @@ c_parser_omp_clause_if (c_parser *parser, tree list)
 
       check_no_duplicate_clause (list, OMP_CLAUSE_IF, "if");
 
-      c = build_omp_clause (OMP_CLAUSE_IF);
+      c = build_omp_clause (loc, OMP_CLAUSE_IF);
       OMP_CLAUSE_IF_EXPR (c) = t;
       OMP_CLAUSE_CHAIN (c) = list;
       list = c;
@@ -7223,10 +7303,11 @@ static tree
 c_parser_omp_clause_nowait (c_parser *parser ATTRIBUTE_UNUSED, tree list)
 {
   tree c;
+  location_t loc = c_parser_peek_token (parser)->location;
 
   check_no_duplicate_clause (list, OMP_CLAUSE_NOWAIT, "nowait");
 
-  c = build_omp_clause (OMP_CLAUSE_NOWAIT);
+  c = build_omp_clause (loc, OMP_CLAUSE_NOWAIT);
   OMP_CLAUSE_CHAIN (c) = list;
   return c;
 }
@@ -7237,6 +7318,7 @@ c_parser_omp_clause_nowait (c_parser *parser ATTRIBUTE_UNUSED, tree list)
 static tree
 c_parser_omp_clause_num_threads (c_parser *parser, tree list)
 {
+  location_t num_threads_loc = c_parser_peek_token (parser)->location;
   if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
     {
       location_t expr_loc = c_parser_peek_token (parser)->location;
@@ -7254,6 +7336,8 @@ c_parser_omp_clause_num_threads (c_parser *parser, tree list)
       /* Attempt to statically determine when the number isn't positive.  */
       c = fold_build2 (LE_EXPR, boolean_type_node, t,
                       build_int_cst (TREE_TYPE (t), 0));
+      if (CAN_HAVE_LOCATION_P (c))
+       SET_EXPR_LOCATION (c, expr_loc);
       if (c == boolean_true_node)
        {
          warning_at (expr_loc, 0,
@@ -7263,7 +7347,7 @@ c_parser_omp_clause_num_threads (c_parser *parser, tree list)
 
       check_no_duplicate_clause (list, OMP_CLAUSE_NUM_THREADS, "num_threads");
 
-      c = build_omp_clause (OMP_CLAUSE_NUM_THREADS);
+      c = build_omp_clause (num_threads_loc, OMP_CLAUSE_NUM_THREADS);
       OMP_CLAUSE_NUM_THREADS_EXPR (c) = t;
       OMP_CLAUSE_CHAIN (c) = list;
       list = c;
@@ -7276,14 +7360,16 @@ c_parser_omp_clause_num_threads (c_parser *parser, tree list)
    ordered */
 
 static tree
-c_parser_omp_clause_ordered (c_parser *parser ATTRIBUTE_UNUSED, tree list)
+c_parser_omp_clause_ordered (c_parser *parser, tree list)
 {
   tree c;
 
   check_no_duplicate_clause (list, OMP_CLAUSE_ORDERED, "ordered");
 
-  c = build_omp_clause (OMP_CLAUSE_ORDERED);
+  c = build_omp_clause (c_parser_peek_token (parser)->location,
+                       OMP_CLAUSE_ORDERED);
   OMP_CLAUSE_CHAIN (c) = list;
+
   return c;
 }
 
@@ -7305,6 +7391,7 @@ c_parser_omp_clause_private (c_parser *parser, tree list)
 static tree
 c_parser_omp_clause_reduction (c_parser *parser, tree list)
 {
+  location_t clause_loc = c_parser_peek_token (parser)->location;
   if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
     {
       enum tree_code code;
@@ -7347,7 +7434,8 @@ c_parser_omp_clause_reduction (c_parser *parser, tree list)
        {
          tree nl, c;
 
-         nl = c_parser_omp_variable_list (parser, OMP_CLAUSE_REDUCTION, list);
+         nl = c_parser_omp_variable_list (parser, clause_loc,
+                                          OMP_CLAUSE_REDUCTION, list);
          for (c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
            OMP_CLAUSE_REDUCTION_CODE (c) = code;
 
@@ -7370,11 +7458,12 @@ static tree
 c_parser_omp_clause_schedule (c_parser *parser, tree list)
 {
   tree c, t;
+  location_t loc = c_parser_peek_token (parser)->location;
 
   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
     return list;
 
-  c = build_omp_clause (OMP_CLAUSE_SCHEDULE);
+  c = build_omp_clause (loc, OMP_CLAUSE_SCHEDULE);
 
   if (c_parser_next_token_is (parser, CPP_NAME))
     {
@@ -7470,8 +7559,10 @@ c_parser_omp_clause_untied (c_parser *parser ATTRIBUTE_UNUSED, tree list)
   /* FIXME: Should we allow duplicates?  */
   check_no_duplicate_clause (list, OMP_CLAUSE_UNTIED, "untied");
 
-  c = build_omp_clause (OMP_CLAUSE_UNTIED);
+  c = build_omp_clause (c_parser_peek_token (parser)->location,
+                       OMP_CLAUSE_UNTIED);
   OMP_CLAUSE_CHAIN (c) = list;
+
   return c;
 }
 
@@ -7607,10 +7698,12 @@ c_parser_omp_structured_block (c_parser *parser)
    binop:
      +, *, -, /, &, ^, |, <<, >>
 
-  where x is an lvalue expression with scalar type.  */
+  where x is an lvalue expression with scalar type.  
+
+  LOC is the location of the #pragma token.  */
 
 static void
-c_parser_omp_atomic (c_parser *parser)
+c_parser_omp_atomic (location_t loc, c_parser *parser)
 {
   tree lhs, rhs;
   tree stmt;
@@ -7679,13 +7772,16 @@ c_parser_omp_atomic (c_parser *parser)
        }
 
       c_parser_consume_token (parser);
-      rhs_expr = c_parser_expression (parser);
-      rhs_expr = default_function_array_conversion (rhs_expr);
+      {
+       location_t rhs_loc = c_parser_peek_token (parser)->location;
+       rhs_expr = c_parser_expression (parser);
+       rhs_expr = default_function_array_conversion (rhs_loc, rhs_expr);
+      }
       rhs = rhs_expr.value;
       rhs = c_fully_fold (rhs, false, NULL);
       break;
     }
-  stmt = c_finish_omp_atomic (code, lhs, rhs);
+  stmt = c_finish_omp_atomic (loc, code, lhs, rhs);
   if (stmt != error_mark_node)
     add_stmt (stmt);
   c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
@@ -7699,19 +7795,21 @@ c_parser_omp_atomic (c_parser *parser)
 static void
 c_parser_omp_barrier (c_parser *parser)
 {
+  location_t loc = c_parser_peek_token (parser)->location;
   c_parser_consume_pragma (parser);
   c_parser_skip_to_pragma_eol (parser);
 
-  c_finish_omp_barrier ();
+  c_finish_omp_barrier (loc);
 }
 
 /* OpenMP 2.5:
    # pragma omp critical [(name)] new-line
      structured-block
-*/
+
+  LOC is the location of the #pragma itself.  */
 
 static tree
-c_parser_omp_critical (c_parser *parser)
+c_parser_omp_critical (location_t loc, c_parser *parser)
 {
   tree stmt, name = NULL;
 
@@ -7732,7 +7830,7 @@ c_parser_omp_critical (c_parser *parser)
   c_parser_skip_to_pragma_eol (parser);
 
   stmt = c_parser_omp_structured_block (parser);
-  return c_finish_omp_critical (stmt, name);
+  return c_finish_omp_critical (loc, stmt, name);
 }
 
 /* OpenMP 2.5:
@@ -7744,6 +7842,7 @@ c_parser_omp_critical (c_parser *parser)
 static void
 c_parser_omp_flush (c_parser *parser)
 {
+  location_t loc = c_parser_peek_token (parser)->location;
   c_parser_consume_pragma (parser);
   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
     c_parser_omp_var_list_parens (parser, OMP_CLAUSE_ERROR, NULL);
@@ -7751,21 +7850,23 @@ c_parser_omp_flush (c_parser *parser)
     c_parser_error (parser, "expected %<(%> or end of line");
   c_parser_skip_to_pragma_eol (parser);
 
-  c_finish_omp_flush ();
+  c_finish_omp_flush (loc);
 }
 
 /* Parse the restricted form of the for statement allowed by OpenMP.
    The real trick here is to determine the loop control variable early
-   so that we can push a new decl if necessary to make it private.  */
+   so that we can push a new decl if necessary to make it private.
+   LOC is the location of the OMP in "#pragma omp".  */
 
 static tree
-c_parser_omp_for_loop (c_parser *parser, tree clauses, tree *par_clauses)
+c_parser_omp_for_loop (location_t loc,
+                      c_parser *parser, tree clauses, tree *par_clauses)
 {
   tree decl, cond, incr, save_break, save_cont, body, init, stmt, cl;
   tree declv, condv, incrv, initv, for_block = NULL, ret = NULL;
-  location_t loc;
   bool fail = false, open_brace_parsed = false;
   int i, collapse = 1, nbraces = 0;
+  location_t for_loc;
 
   for (cl = clauses; cl; cl = OMP_CLAUSE_CHAIN (cl))
     if (OMP_CLAUSE_CODE (cl) == OMP_CLAUSE_COLLAPSE)
@@ -7783,7 +7884,7 @@ c_parser_omp_for_loop (c_parser *parser, tree clauses, tree *par_clauses)
       c_parser_error (parser, "for statement expected");
       return NULL;
     }
-  loc = c_parser_peek_token (parser)->location;
+  for_loc = c_parser_peek_token (parser)->location;
   c_parser_consume_token (parser);
 
   for (i = 0; i < collapse; i++)
@@ -7800,7 +7901,7 @@ c_parser_omp_for_loop (c_parser *parser, tree clauses, tree *par_clauses)
            for_block
              = tree_cons (NULL, c_begin_compound_stmt (true), for_block);
          c_parser_declaration_or_fndef (parser, true, true, true, true);
-         decl = check_for_loop_decls ();
+         decl = check_for_loop_decls (for_loc);
          if (decl == NULL)
            goto error_init;
          if (DECL_INITIAL (decl) == error_mark_node)
@@ -7818,14 +7919,14 @@ c_parser_omp_for_loop (c_parser *parser, tree clauses, tree *par_clauses)
          decl = decl_exp.value;
 
          c_parser_require (parser, CPP_EQ, "expected %<=%>");
-         init_loc = c_parser_peek_token (parser)->location;
 
+         init_loc = c_parser_peek_token (parser)->location;
          init_exp = c_parser_expr_no_commas (parser, NULL);
-         init_exp = default_function_array_conversion (init_exp);
+         init_exp = default_function_array_conversion (init_loc, init_exp);
          init = build_modify_expr (init_loc, decl, decl_exp.original_type,
-                                   NOP_EXPR, init_exp.value,
+                                   NOP_EXPR, init_loc, init_exp.value,
                                    init_exp.original_type);
-         init = c_process_expr_stmt (init);
+         init = c_process_expr_stmt (init_loc, init);
 
          c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
        }
@@ -7873,8 +7974,8 @@ c_parser_omp_for_loop (c_parser *parser, tree clauses, tree *par_clauses)
        {
          location_t incr_loc = c_parser_peek_token (parser)->location;
 
-         incr = c_process_expr_stmt (c_parser_expression (parser).value);
-         protected_set_expr_location (incr, incr_loc);
+         incr = c_process_expr_stmt (incr_loc,
+                                     c_parser_expression (parser).value);
        }
       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
 
@@ -7937,14 +8038,19 @@ c_parser_omp_for_loop (c_parser *parser, tree clauses, tree *par_clauses)
 
   if (open_brace_parsed)
     {
+      location_t here = c_parser_peek_token (parser)->location;
       stmt = c_begin_compound_stmt (true);
       c_parser_compound_statement_nostart (parser);
-      add_stmt (c_end_compound_stmt (stmt, true));
+      add_stmt (c_end_compound_stmt (here, stmt, true));
     }
   else
     add_stmt (c_parser_c99_block_statement (parser));
   if (c_cont_label)
-    add_stmt (build1 (LABEL_EXPR, void_type_node, c_cont_label));
+    {
+      tree t = build1 (LABEL_EXPR, void_type_node, c_cont_label);
+      SET_EXPR_LOCATION (t, loc);
+      add_stmt (t);
+    }
 
   body = pop_stmt_list (body);
   c_break_label = save_break;
@@ -7964,10 +8070,11 @@ c_parser_omp_for_loop (c_parser *parser, tree clauses, tree *par_clauses)
          c_parser_error (parser, "collapsed loops not perfectly nested");
          while (nbraces)
            {
+             location_t here = c_parser_peek_token (parser)->location;
              stmt = c_begin_compound_stmt (true);
              add_stmt (body);
              c_parser_compound_statement_nostart (parser);
-             body = c_end_compound_stmt (stmt, true);
+             body = c_end_compound_stmt (here, stmt, true);
              nbraces--;
            }
          goto pop_scopes;
@@ -8007,7 +8114,8 @@ c_parser_omp_for_loop (c_parser *parser, tree clauses, tree *par_clauses)
                        /* Copy lastprivate (decl) clause to OMP_FOR_CLAUSES,
                           change it to shared (decl) in
                           OMP_PARALLEL_CLAUSES.  */
-                       tree l = build_omp_clause (OMP_CLAUSE_LASTPRIVATE);
+                       tree l = build_omp_clause (OMP_CLAUSE_LOCATION (*c),
+                                                  OMP_CLAUSE_LASTPRIVATE);
                        OMP_CLAUSE_DECL (l) = OMP_CLAUSE_DECL (*c);
                        OMP_CLAUSE_CHAIN (l) = clauses;
                        clauses = l;
@@ -8022,7 +8130,10 @@ c_parser_omp_for_loop (c_parser *parser, tree clauses, tree *par_clauses)
 pop_scopes:
   while (for_block)
     {
-      stmt = c_end_compound_stmt (TREE_VALUE (for_block), true);
+      /* FIXME diagnostics: LOC below should be the actual location of
+        this particular for block.  We need to build a list of
+        locations to go along with FOR_BLOCK.  */
+      stmt = c_end_compound_stmt (loc, TREE_VALUE (for_block), true);
       add_stmt (stmt);
       for_block = TREE_CHAIN (for_block);
     }
@@ -8032,6 +8143,8 @@ pop_scopes:
 /* OpenMP 2.5:
    #pragma omp for for-clause[optseq] new-line
      for-loop
+
+   LOC is the location of the #pragma token.
 */
 
 #define OMP_FOR_CLAUSE_MASK                            \
@@ -8045,7 +8158,7 @@ pop_scopes:
        | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
 
 static tree
-c_parser_omp_for (c_parser *parser)
+c_parser_omp_for (location_t loc, c_parser *parser)
 {
   tree block, clauses, ret;
 
@@ -8053,8 +8166,8 @@ c_parser_omp_for (c_parser *parser)
                                      "#pragma omp for");
 
   block = c_begin_compound_stmt (true);
-  ret = c_parser_omp_for_loop (parser, clauses, NULL);
-  block = c_end_compound_stmt (block, true);
+  ret = c_parser_omp_for_loop (loc, parser, clauses, NULL);
+  block = c_end_compound_stmt (loc, block, true);
   add_stmt (block);
 
   return ret;
@@ -8063,25 +8176,29 @@ c_parser_omp_for (c_parser *parser)
 /* OpenMP 2.5:
    # pragma omp master new-line
      structured-block
+
+   LOC is the location of the #pragma token.
 */
 
 static tree
-c_parser_omp_master (c_parser *parser)
+c_parser_omp_master (location_t loc, c_parser *parser)
 {
   c_parser_skip_to_pragma_eol (parser);
-  return c_finish_omp_master (c_parser_omp_structured_block (parser));
+  return c_finish_omp_master (loc, c_parser_omp_structured_block (parser));
 }
 
 /* OpenMP 2.5:
    # pragma omp ordered new-line
      structured-block
+
+   LOC is the location of the #pragma itself.
 */
 
 static tree
-c_parser_omp_ordered (c_parser *parser)
+c_parser_omp_ordered (location_t loc, c_parser *parser)
 {
   c_parser_skip_to_pragma_eol (parser);
-  return c_finish_omp_ordered (c_parser_omp_structured_block (parser));
+  return c_finish_omp_ordered (loc, c_parser_omp_structured_block (parser));
 }
 
 /* OpenMP 2.5:
@@ -8091,15 +8208,18 @@ c_parser_omp_ordered (c_parser *parser)
 
    section-sequence:
      section-directive[opt] structured-block
-     section-sequence section-directive structured-block  */
+     section-sequence section-directive structured-block  
+
+    SECTIONS_LOC is the location of the #pragma omp sections.  */
 
 static tree
-c_parser_omp_sections_scope (c_parser *parser)
+c_parser_omp_sections_scope (location_t sections_loc, c_parser *parser)
 {
   tree stmt, substmt;
   bool error_suppress = false;
   location_t loc;
 
+  loc = c_parser_peek_token (parser)->location;
   if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
     {
       /* Avoid skipping until the end of the block.  */
@@ -8109,7 +8229,6 @@ c_parser_omp_sections_scope (c_parser *parser)
 
   stmt = push_stmt_list ();
 
-  loc = c_parser_peek_token (parser)->location;
   if (c_parser_peek_token (parser)->pragma_kind != PRAGMA_OMP_SECTION)
     {
       substmt = push_stmt_list ();
@@ -8163,6 +8282,7 @@ c_parser_omp_sections_scope (c_parser *parser)
   substmt = pop_stmt_list (stmt);
 
   stmt = make_node (OMP_SECTIONS);
+  SET_EXPR_LOCATION (stmt, sections_loc);
   TREE_TYPE (stmt) = void_type_node;
   OMP_SECTIONS_BODY (stmt) = substmt;
 
@@ -8172,6 +8292,8 @@ c_parser_omp_sections_scope (c_parser *parser)
 /* OpenMP 2.5:
    # pragma omp sections sections-clause[optseq] newline
      sections-scope
+
+   LOC is the location of the #pragma token.
 */
 
 #define OMP_SECTIONS_CLAUSE_MASK                       \
@@ -8182,7 +8304,7 @@ c_parser_omp_sections_scope (c_parser *parser)
        | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
 
 static tree
-c_parser_omp_sections (c_parser *parser)
+c_parser_omp_sections (location_t loc, c_parser *parser)
 {
   tree block, clauses, ret;
 
@@ -8190,10 +8312,10 @@ c_parser_omp_sections (c_parser *parser)
                                      "#pragma omp sections");
 
   block = c_begin_compound_stmt (true);
-  ret = c_parser_omp_sections_scope (parser);
+  ret = c_parser_omp_sections_scope (loc, parser);
   if (ret)
     OMP_SECTIONS_CLAUSES (ret) = clauses;
-  block = c_end_compound_stmt (block, true);
+  block = c_end_compound_stmt (loc, block, true);
   add_stmt (block);
 
   return ret;
@@ -8203,6 +8325,8 @@ c_parser_omp_sections (c_parser *parser)
    # pragma parallel parallel-clause new-line
    # pragma parallel for parallel-for-clause new-line
    # pragma parallel sections parallel-sections-clause new-line
+
+   LOC is the location of the #pragma token.
 */
 
 #define OMP_PARALLEL_CLAUSE_MASK                       \
@@ -8216,7 +8340,7 @@ c_parser_omp_sections (c_parser *parser)
        | (1u << PRAGMA_OMP_CLAUSE_NUM_THREADS))
 
 static tree
-c_parser_omp_parallel (c_parser *parser)
+c_parser_omp_parallel (location_t loc, c_parser *parser)
 {
   enum pragma_kind p_kind = PRAGMA_OMP_PARALLEL;
   const char *p_name = "#pragma omp parallel";
@@ -8251,24 +8375,24 @@ c_parser_omp_parallel (c_parser *parser)
     case PRAGMA_OMP_PARALLEL:
       block = c_begin_omp_parallel ();
       c_parser_statement (parser);
-      stmt = c_finish_omp_parallel (clauses, block);
+      stmt = c_finish_omp_parallel (loc, clauses, block);
       break;
 
     case PRAGMA_OMP_PARALLEL_FOR:
       block = c_begin_omp_parallel ();
-      c_split_parallel_clauses (clauses, &par_clause, &ws_clause);
-      c_parser_omp_for_loop (parser, ws_clause, &par_clause);
-      stmt = c_finish_omp_parallel (par_clause, block);
+      c_split_parallel_clauses (loc, clauses, &par_clause, &ws_clause);
+      c_parser_omp_for_loop (loc, parser, ws_clause, &par_clause);
+      stmt = c_finish_omp_parallel (loc, par_clause, block);
       OMP_PARALLEL_COMBINED (stmt) = 1;
       break;
 
     case PRAGMA_OMP_PARALLEL_SECTIONS:
       block = c_begin_omp_parallel ();
-      c_split_parallel_clauses (clauses, &par_clause, &ws_clause);
-      stmt = c_parser_omp_sections_scope (parser);
+      c_split_parallel_clauses (loc, clauses, &par_clause, &ws_clause);
+      stmt = c_parser_omp_sections_scope (loc, parser);
       if (stmt)
        OMP_SECTIONS_CLAUSES (stmt) = ws_clause;
-      stmt = c_finish_omp_parallel (par_clause, block);
+      stmt = c_finish_omp_parallel (loc, par_clause, block);
       OMP_PARALLEL_COMBINED (stmt) = 1;
       break;
 
@@ -8282,6 +8406,8 @@ c_parser_omp_parallel (c_parser *parser)
 /* OpenMP 2.5:
    # pragma omp single single-clause[optseq] new-line
      structured-block
+
+   LOC is the location of the #pragma.
 */
 
 #define OMP_SINGLE_CLAUSE_MASK                         \
@@ -8291,9 +8417,10 @@ c_parser_omp_parallel (c_parser *parser)
        | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
 
 static tree
-c_parser_omp_single (c_parser *parser)
+c_parser_omp_single (location_t loc, c_parser *parser)
 {
   tree stmt = make_node (OMP_SINGLE);
+  SET_EXPR_LOCATION (stmt, loc);
   TREE_TYPE (stmt) = void_type_node;
 
   OMP_SINGLE_CLAUSES (stmt)
@@ -8306,6 +8433,8 @@ c_parser_omp_single (c_parser *parser)
 
 /* OpenMP 3.0:
    # pragma omp task task-clause[optseq] new-line
+
+   LOC is the location of the #pragma.
 */
 
 #define OMP_TASK_CLAUSE_MASK                           \
@@ -8317,7 +8446,7 @@ c_parser_omp_single (c_parser *parser)
        | (1u << PRAGMA_OMP_CLAUSE_SHARED))
 
 static tree
-c_parser_omp_task (c_parser *parser)
+c_parser_omp_task (location_t loc, c_parser *parser)
 {
   tree clauses, block;
 
@@ -8326,7 +8455,7 @@ c_parser_omp_task (c_parser *parser)
 
   block = c_begin_omp_task ();
   c_parser_statement (parser);
-  return c_finish_omp_task (clauses, block);
+  return c_finish_omp_task (loc, clauses, block);
 }
 
 /* OpenMP 3.0:
@@ -8336,10 +8465,11 @@ c_parser_omp_task (c_parser *parser)
 static void
 c_parser_omp_taskwait (c_parser *parser)
 {
+  location_t loc = c_parser_peek_token (parser)->location;
   c_parser_consume_pragma (parser);
   c_parser_skip_to_pragma_eol (parser);
 
-  c_finish_omp_taskwait ();
+  c_finish_omp_taskwait (loc);
 }
 
 /* Main entry point to parsing most OpenMP pragmas.  */
@@ -8364,38 +8494,38 @@ c_parser_omp_construct (c_parser *parser)
   switch (p_kind)
     {
     case PRAGMA_OMP_ATOMIC:
-      c_parser_omp_atomic (parser);
+      c_parser_omp_atomic (loc, parser);
       return;
     case PRAGMA_OMP_CRITICAL:
-      stmt = c_parser_omp_critical (parser);
+      stmt = c_parser_omp_critical (loc, parser);
       break;
     case PRAGMA_OMP_FOR:
-      stmt = c_parser_omp_for (parser);
+      stmt = c_parser_omp_for (loc, parser);
       break;
     case PRAGMA_OMP_MASTER:
-      stmt = c_parser_omp_master (parser);
+      stmt = c_parser_omp_master (loc, parser);
       break;
     case PRAGMA_OMP_ORDERED:
-      stmt = c_parser_omp_ordered (parser);
+      stmt = c_parser_omp_ordered (loc, parser);
       break;
     case PRAGMA_OMP_PARALLEL:
-      stmt = c_parser_omp_parallel (parser);
+      stmt = c_parser_omp_parallel (loc, parser);
       break;
     case PRAGMA_OMP_SECTIONS:
-      stmt = c_parser_omp_sections (parser);
+      stmt = c_parser_omp_sections (loc, parser);
       break;
     case PRAGMA_OMP_SINGLE:
-      stmt = c_parser_omp_single (parser);
+      stmt = c_parser_omp_single (loc, parser);
       break;
     case PRAGMA_OMP_TASK:
-      stmt = c_parser_omp_task (parser);
+      stmt = c_parser_omp_task (loc, parser);
       break;
     default:
       gcc_unreachable ();
     }
 
   if (stmt)
-    SET_EXPR_LOCATION (stmt, loc);
+    gcc_assert (EXPR_LOCATION (stmt) != UNKNOWN_LOCATION);
 }
 
 
@@ -8406,8 +8536,10 @@ static void
 c_parser_omp_threadprivate (c_parser *parser)
 {
   tree vars, t;
+  location_t loc;
 
   c_parser_consume_pragma (parser);
+  loc = c_parser_peek_token (parser)->location;
   vars = c_parser_omp_var_list_parens (parser, OMP_CLAUSE_ERROR, NULL);
 
   /* Mark every variable in VARS to be assigned thread local storage.  */
@@ -8415,18 +8547,24 @@ c_parser_omp_threadprivate (c_parser *parser)
     {
       tree v = TREE_PURPOSE (t);
 
+      /* FIXME diagnostics: Ideally we should keep individual
+        locations for all the variables in the var list to make the
+        following errors more precise.  Perhaps
+        c_parser_omp_var_list_parens() should construct a list of
+        locations to go along with the var list.  */
+
       /* If V had already been marked threadprivate, it doesn't matter
         whether it had been used prior to this point.  */
       if (TREE_CODE (v) != VAR_DECL)
-       error ("%qD is not a variable", v);
+       error_at (loc, "%qD is not a variable", v);
       else if (TREE_USED (v) && !C_DECL_THREADPRIVATE_P (v))
-       error ("%qE declared %<threadprivate%> after first use", v);
+       error_at (loc, "%qE declared %<threadprivate%> after first use", v);
       else if (! TREE_STATIC (v) && ! DECL_EXTERNAL (v))
-       error ("automatic variable %qE cannot be %<threadprivate%>", v);
+       error_at (loc, "automatic variable %qE cannot be %<threadprivate%>", v);
       else if (TREE_TYPE (v) == error_mark_node)
        ;
       else if (! COMPLETE_TYPE_P (TREE_TYPE (v)))
-       error ("%<threadprivate%> %qE has incomplete type", v);
+       error_at (loc, "%<threadprivate%> %qE has incomplete type", v);
       else
        {
          if (! DECL_THREAD_LOCAL_P (v))
index 751c895..c91ee99 100644 (file)
@@ -455,7 +455,8 @@ maybe_apply_pending_pragma_weaks (void)
       if (TREE_VALUE (t) == NULL)
        continue;
 
-      decl = build_decl (FUNCTION_DECL, alias_id, default_function_type);
+      decl = build_decl (UNKNOWN_LOCATION,
+                        FUNCTION_DECL, alias_id, default_function_type);
 
       DECL_ARTIFICIAL (decl) = 1;
       TREE_PUBLIC (decl) = 1;
index b6c3a27..2bfad47 100644 (file)
@@ -103,12 +103,12 @@ pop_stmt_list (tree t)
 
 /* Build a generic statement based on the given type of node and
    arguments. Similar to `build_nt', except that we set
-   EXPR_LOCATION to be the current source location.  */
+   EXPR_LOCATION to LOC. */
 /* ??? This should be obsolete with the lineno_stmt productions
    in the grammar.  */
 
 tree
-build_stmt (enum tree_code code, ...)
+build_stmt (location_t loc, enum tree_code code, ...)
 {
   tree ret;
   int length, i;
@@ -123,7 +123,7 @@ build_stmt (enum tree_code code, ...)
   ret = make_node (code);
   TREE_TYPE (ret) = void_type_node;
   length = TREE_CODE_LENGTH (code);
-  SET_EXPR_LOCATION (ret, input_location);
+  SET_EXPR_LOCATION (ret, loc);
 
   /* TREE_SIDE_EFFECTS will already be set for statements with
      implicit side effects.  Here we make sure it is set for other
@@ -148,7 +148,8 @@ build_stmt (enum tree_code code, ...)
 /* Create a CASE_LABEL_EXPR tree node and return it.  */
 
 tree
-build_case_label (tree low_value, tree high_value, tree label_decl)
+build_case_label (location_t loc,
+                 tree low_value, tree high_value, tree label_decl)
 {
-  return build_stmt (CASE_LABEL_EXPR, low_value, high_value, label_decl);
+  return build_stmt (loc, CASE_LABEL_EXPR, low_value, high_value, label_decl);
 }
index 880cc1b..d606217 100644 (file)
@@ -360,7 +360,7 @@ struct c_declarator {
   enum c_declarator_kind kind;
   /* Except for cdk_id, the contained declarator.  For cdk_id, NULL.  */
   struct c_declarator *declarator;
-  location_t id_loc; /* Currently only set for cdk_id. */
+  location_t id_loc; /* Currently only set for cdk_id, cdk_array. */
   union {
     /* For identifiers, an IDENTIFIER_NODE or NULL_TREE if an abstract
        declarator.  */
@@ -505,26 +505,27 @@ extern void c_init_decl_processing (void);
 extern void c_dup_lang_specific_decl (tree);
 extern void c_print_identifier (FILE *, tree, int);
 extern int quals_from_declspecs (const struct c_declspecs *);
-extern struct c_declarator *build_array_declarator (tree, struct c_declspecs *,
+extern struct c_declarator *build_array_declarator (location_t, tree,
+                                                   struct c_declspecs *,
                                                    bool, bool);
-extern tree build_enumerator (struct c_enum_contents *, tree, tree, location_t);
-extern tree check_for_loop_decls (void);
+extern tree build_enumerator (location_t, struct c_enum_contents *, tree, tree);
+extern tree check_for_loop_decls (location_t);
 extern void mark_forward_parm_decls (void);
 extern void declare_parm_level (void);
-extern void undeclared_variable (tree, location_t);
+extern void undeclared_variable (location_t, tree);
 extern tree declare_label (tree);
 extern tree define_label (location_t, tree);
 extern void c_maybe_initialize_eh (void);
-extern void finish_decl (tree, tree, tree, tree);
+extern void finish_decl (tree, location_t, tree, tree, tree);
 extern tree finish_enum (tree, tree, tree);
 extern void finish_function (void);
-extern tree finish_struct (tree, tree, tree, bool, VEC(tree,heap) *);
+extern tree finish_struct (location_t, tree, tree, tree, bool, VEC(tree,heap) *);
 extern struct c_arg_info *get_parm_info (bool);
 extern tree grokfield (location_t, struct c_declarator *,
                       struct c_declspecs *, tree, tree *);
 extern tree groktypename (struct c_type_name *, tree *, bool *);
 extern tree grokparm (const struct c_parm *);
-extern tree implicitly_declare (tree);
+extern tree implicitly_declare (location_t, tree);
 extern void keep_next_level (void);
 extern void pending_xref_error (void);
 extern void c_push_function_context (void);
@@ -536,16 +537,15 @@ extern tree c_builtin_function (tree);
 extern tree c_builtin_function_ext_scope (tree);
 extern void shadow_tag (const struct c_declspecs *);
 extern void shadow_tag_warned (const struct c_declspecs *, int);
-extern tree start_enum (struct c_enum_contents *, tree, location_t);
+extern tree start_enum (location_t, struct c_enum_contents *, tree);
 extern int  start_function (struct c_declspecs *, struct c_declarator *, tree);
 extern tree start_decl (struct c_declarator *, struct c_declspecs *, bool,
                        tree);
-extern tree start_struct (enum tree_code, tree, bool *, VEC(tree,heap) **,
-                         location_t);
+extern tree start_struct (location_t, enum tree_code, tree, bool *, VEC(tree,heap) **);
 extern void store_parm_decls (void);
 extern void store_parm_decls_from (struct c_arg_info *);
 extern tree xref_tag (enum tree_code, tree);
-extern struct c_typespec parser_xref_tag (enum tree_code, tree, location_t);
+extern struct c_typespec parser_xref_tag (location_t, enum tree_code, tree);
 extern int c_expand_decl (tree);
 extern struct c_parm *build_c_parm (struct c_declspecs *, tree,
                                    struct c_declarator *);
@@ -594,24 +594,25 @@ extern bool c_vla_type_p (const_tree);
 extern bool c_mark_addressable (tree);
 extern void c_incomplete_type_error (const_tree, const_tree);
 extern tree c_type_promotes_to (tree);
-extern struct c_expr default_function_array_conversion (struct c_expr);
+extern struct c_expr default_function_array_conversion (location_t,
+                                                       struct c_expr);
 extern tree composite_type (tree, tree);
-extern tree build_component_ref (tree, tree);
-extern tree build_array_ref (tree, tree, location_t);
-extern tree build_external_ref (tree, int, location_t, tree *);
+extern tree build_component_ref (location_t, tree, tree);
+extern tree build_array_ref (location_t, tree, tree);
+extern tree build_external_ref (location_t, tree, int, tree *);
 extern void pop_maybe_used (bool);
-extern struct c_expr c_expr_sizeof_expr (struct c_expr);
-extern struct c_expr c_expr_sizeof_type (struct c_type_name *);
-extern struct c_expr parser_build_unary_op (enum tree_code, struct c_expr,
-                                           location_t);
+extern struct c_expr c_expr_sizeof_expr (location_t, struct c_expr);
+extern struct c_expr c_expr_sizeof_type (location_t, struct c_type_name *);
+extern struct c_expr parser_build_unary_op (location_t, enum tree_code,
+                                           struct c_expr);
 extern struct c_expr parser_build_binary_op (location_t, 
                                             enum tree_code, struct c_expr,
                                             struct c_expr);
 extern tree build_conditional_expr (location_t, tree, bool, tree, tree);
-extern tree build_compound_expr (tree, tree);
-extern tree c_cast_expr (struct c_type_name *, tree, location_t);
-extern tree build_c_cast (tree, tree);
-extern void store_init_value (tree, tree, tree);
+extern tree build_compound_expr (location_t, tree, tree);
+extern tree c_cast_expr (location_t, struct c_type_name *, tree);
+extern tree build_c_cast (location_t, tree, tree);
+extern void store_init_value (location_t, tree, tree, tree);
 extern void error_init (const char *);
 extern void pedwarn_init (location_t, int opt, const char *);
 extern void maybe_warn_string_init (tree, struct c_expr);
@@ -623,34 +624,34 @@ extern struct c_expr pop_init_level (int);
 extern void set_init_index (tree, tree);
 extern void set_init_label (tree);
 extern void process_init_element (struct c_expr, bool);
-extern tree build_compound_literal (tree, tree, bool);
-extern void check_compound_literal_type (struct c_type_name *, location_t);
-extern tree c_start_case (tree);
+extern tree build_compound_literal (location_t, tree, tree, bool);
+extern void check_compound_literal_type (location_t, struct c_type_name *);
+extern tree c_start_case (location_t, location_t, tree);
 extern void c_finish_case (tree);
-extern tree build_asm_expr (tree, tree, tree, tree, bool);
+extern tree build_asm_expr (location_t, tree, tree, tree, tree, bool);
 extern tree build_asm_stmt (tree, tree);
 extern int c_types_compatible_p (tree, tree);
 extern tree c_begin_compound_stmt (bool);
-extern tree c_end_compound_stmt (tree, bool);
+extern tree c_end_compound_stmt (location_t, tree, bool);
 extern void c_finish_if_stmt (location_t, tree, tree, tree, bool);
 extern void c_finish_loop (location_t, tree, tree, tree, tree, tree, bool);
 extern tree c_begin_stmt_expr (void);
-extern tree c_finish_stmt_expr (tree);
-extern tree c_process_expr_stmt (tree);
-extern tree c_finish_expr_stmt (tree);
-extern tree c_finish_return (tree, tree);
-extern tree c_finish_bc_stmt (tree *, bool);
-extern tree c_finish_goto_label (tree);
-extern tree c_finish_goto_ptr (tree);
+extern tree c_finish_stmt_expr (location_t, tree);
+extern tree c_process_expr_stmt (location_t, tree);
+extern tree c_finish_expr_stmt (location_t, tree);
+extern tree c_finish_return (location_t, tree, tree);
+extern tree c_finish_bc_stmt (location_t, tree *, bool);
+extern tree c_finish_goto_label (location_t, tree);
+extern tree c_finish_goto_ptr (location_t, tree);
 extern void c_begin_vm_scope (unsigned int);
 extern void c_end_vm_scope (unsigned int);
 extern tree c_expr_to_decl (tree, bool *, bool *);
 extern tree c_begin_omp_parallel (void);
-extern tree c_finish_omp_parallel (tree, tree);
+extern tree c_finish_omp_parallel (location_t, tree, tree);
 extern tree c_begin_omp_task (void);
-extern tree c_finish_omp_task (tree, tree);
+extern tree c_finish_omp_task (location_t, tree, tree);
 extern tree c_finish_omp_clauses (tree);
-extern tree c_build_va_arg (tree, tree, location_t);
+extern tree c_build_va_arg (location_t, tree, tree);
 
 /* Set to 0 at beginning of a function definition, set to 1 if
    a return statement that specifies a return value is seen.  */
index 6c86b92..978e95c 100644 (file)
@@ -98,7 +98,7 @@ static void push_member_name (tree);
 static int spelling_length (void);
 static char *print_spelling (char *);
 static void warning_init (int, const char *);
-static tree digest_init (tree, tree, tree, bool, bool, int);
+static tree digest_init (location_t, tree, tree, tree, bool, bool, int);
 static void output_init_element (tree, tree, bool, tree, tree, int, bool);
 static void output_pending_init_elements (int);
 static int set_designator (int);
@@ -1659,7 +1659,7 @@ decl_constant_value (tree decl)
 
 /* Convert the array expression EXP to a pointer.  */
 static tree
-array_to_pointer_conversion (tree exp)
+array_to_pointer_conversion (location_t loc, tree exp)
 {
   tree orig_exp = exp;
   tree type = TREE_TYPE (exp);
@@ -1679,13 +1679,13 @@ array_to_pointer_conversion (tree exp)
   if (TREE_CODE (exp) == INDIRECT_REF)
     return convert (ptrtype, TREE_OPERAND (exp, 0));
 
-  adr = build_unary_op (EXPR_LOCATION (exp), ADDR_EXPR, exp, 1);
+  adr = build_unary_op (loc, ADDR_EXPR, exp, 1);
   return convert (ptrtype, adr);
 }
 
 /* Convert the function expression EXP to a pointer.  */
 static tree
-function_to_pointer_conversion (tree exp)
+function_to_pointer_conversion (location_t loc, tree exp)
 {
   tree orig_exp = exp;
 
@@ -1696,15 +1696,17 @@ function_to_pointer_conversion (tree exp)
   if (TREE_NO_WARNING (orig_exp))
     TREE_NO_WARNING (exp) = 1;
 
-  return build_unary_op (EXPR_LOCATION (exp), ADDR_EXPR, exp, 0);
+  return build_unary_op (loc, ADDR_EXPR, exp, 0);
 }
 
 /* Perform the default conversion of arrays and functions to pointers.
    Return the result of converting EXP.  For any other expression, just
-   return EXP.  */
+   return EXP.
+
+   LOC is the location of the expression.  */
 
 struct c_expr
-default_function_array_conversion (struct c_expr exp)
+default_function_array_conversion (location_t loc, struct c_expr exp)
 {
   tree orig_exp = exp.value;
   tree type = TREE_TYPE (exp.value);
@@ -1739,11 +1741,11 @@ default_function_array_conversion (struct c_expr exp)
            return exp;
          }
 
-       exp.value = array_to_pointer_conversion (exp.value);
+       exp.value = array_to_pointer_conversion (loc, exp.value);
       }
       break;
     case FUNCTION_TYPE:
-      exp.value = function_to_pointer_conversion (exp.value);
+      exp.value = function_to_pointer_conversion (loc, exp.value);
       break;
     default:
       break;
@@ -1944,11 +1946,12 @@ lookup_field (tree decl, tree component)
   return tree_cons (NULL_TREE, field, NULL_TREE);
 }
 
-/* Make an expression to refer to the COMPONENT field of
-   structure or union value DATUM.  COMPONENT is an IDENTIFIER_NODE.  */
+/* Make an expression to refer to the COMPONENT field of structure or
+   union value DATUM.  COMPONENT is an IDENTIFIER_NODE.  LOC is the
+   location of the COMPONENT_REF.  */
 
 tree
-build_component_ref (tree datum, tree component)
+build_component_ref (location_t loc, tree datum, tree component)
 {
   tree type = TREE_TYPE (datum);
   enum tree_code code = TREE_CODE (type);
@@ -1973,7 +1976,7 @@ build_component_ref (tree datum, tree component)
 
       if (!field)
        {
-         error ("%qT has no member named %qE", type, component);
+         error_at (loc, "%qT has no member named %qE", type, component);
          return error_mark_node;
        }
 
@@ -2006,6 +2009,7 @@ build_component_ref (tree datum, tree component)
 
          ref = build3 (COMPONENT_REF, subtype, datum, subdatum,
                        NULL_TREE);
+         SET_EXPR_LOCATION (ref, loc);
          if (TREE_READONLY (subdatum)
              || (use_datum_quals && TREE_READONLY (datum)))
            TREE_READONLY (ref) = 1;
@@ -2025,8 +2029,9 @@ build_component_ref (tree datum, tree component)
       return ref;
     }
   else if (code != ERROR_MARK)
-    error ("request for member %qE in something not a structure or union",
-          component);
+    error_at (loc,
+             "request for member %qE in something not a structure or union",
+             component);
 
   return error_mark_node;
 }
@@ -2113,7 +2118,7 @@ build_indirect_ref (location_t loc, tree ptr, const char *errorstring)
    LOC is the location to use for the returned expression.  */
 
 tree
-build_array_ref (tree array, tree index, location_t loc)
+build_array_ref (location_t loc, tree array, tree index)
 {
   tree ret;
   bool swapped = false;
@@ -2243,7 +2248,7 @@ build_array_ref (tree array, tree index, location_t loc)
    for CONST_DECLs defined as enum constants.  If the type of the
    identifier is not available, *TYPE is set to NULL.  */
 tree
-build_external_ref (tree id, int fun, location_t loc, tree *type)
+build_external_ref (location_t loc, tree id, int fun, tree *type)
 {
   tree ref;
   tree decl = lookup_name (id);
@@ -2260,14 +2265,14 @@ build_external_ref (tree id, int fun, location_t loc, tree *type)
     }
   else if (fun)
     /* Implicit function declaration.  */
-    ref = implicitly_declare (id);
+    ref = implicitly_declare (loc, id);
   else if (decl == error_mark_node)
     /* Don't complain about something that's already been
        complained about.  */
     return error_mark_node;
   else
     {
-      undeclared_variable (id, loc);
+      undeclared_variable (loc, id);
       return error_mark_node;
     }
 
@@ -2393,7 +2398,7 @@ pop_maybe_used (bool used)
 /* Return the result of sizeof applied to EXPR.  */
 
 struct c_expr
-c_expr_sizeof_expr (struct c_expr expr)
+c_expr_sizeof_expr (location_t loc, struct c_expr expr)
 {
   struct c_expr ret;
   if (expr.value == error_mark_node)
@@ -2408,7 +2413,7 @@ c_expr_sizeof_expr (struct c_expr expr)
       bool expr_const_operands = true;
       tree folded_expr = c_fully_fold (expr.value, require_constant_value,
                                       &expr_const_operands);
-      ret.value = c_sizeof (TREE_TYPE (folded_expr));
+      ret.value = c_sizeof (loc, TREE_TYPE (folded_expr));
       ret.original_code = ERROR_MARK;
       ret.original_type = NULL;
       if (c_vla_type_p (TREE_TYPE (folded_expr)))
@@ -2417,6 +2422,7 @@ c_expr_sizeof_expr (struct c_expr expr)
          ret.value = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (ret.value),
                              folded_expr, ret.value);
          C_MAYBE_CONST_EXPR_NON_CONST (ret.value) = !expr_const_operands;
+         SET_EXPR_LOCATION (ret.value, loc);
        }
       pop_maybe_used (C_TYPE_VARIABLE_SIZE (TREE_TYPE (folded_expr)));
     }
@@ -2424,17 +2430,18 @@ c_expr_sizeof_expr (struct c_expr expr)
 }
 
 /* Return the result of sizeof applied to T, a structure for the type
-   name passed to sizeof (rather than the type itself).  */
+   name passed to sizeof (rather than the type itself).  LOC is the
+   location of the original expression.  */
 
 struct c_expr
-c_expr_sizeof_type (struct c_type_name *t)
+c_expr_sizeof_type (location_t loc, struct c_type_name *t)
 {
   tree type;
   struct c_expr ret;
   tree type_expr = NULL_TREE;
   bool type_expr_const = true;
   type = groktypename (t, &type_expr, &type_expr_const);
-  ret.value = c_sizeof (type);
+  ret.value = c_sizeof (loc, type);
   ret.original_code = ERROR_MARK;
   ret.original_type = NULL;
   if ((type_expr || TREE_CODE (ret.value) == INTEGER_CST)
@@ -2459,12 +2466,13 @@ c_expr_sizeof_type (struct c_type_name *t)
 }
 
 /* Build a function call to function FUNCTION with parameters PARAMS.
+   The function call is at LOC.
    PARAMS is a list--a chain of TREE_LIST nodes--in which the
    TREE_VALUE of each node is a parameter-expression.
    FUNCTION's data type may be a function type or a pointer-to-function.  */
 
 tree
-build_function_call (tree function, tree params)
+build_function_call (location_t loc, tree function, tree params)
 {
   VEC(tree,gc) *vec;
   tree ret;
@@ -2472,7 +2480,7 @@ build_function_call (tree function, tree params)
   vec = VEC_alloc (tree, gc, list_length (params));
   for (; params; params = TREE_CHAIN (params))
     VEC_quick_push (tree, vec, TREE_VALUE (params));
-  ret = build_function_call_vec (function, vec, NULL);
+  ret = build_function_call_vec (loc, function, vec, NULL);
   VEC_free (tree, gc, vec);
   return ret;
 }
@@ -2486,7 +2494,7 @@ build_function_call (tree function, tree params)
    PARAMS.  */
 
 tree
-build_function_call_vec (tree function, VEC(tree,gc) *params,
+build_function_call_vec (location_t loc, tree function, VEC(tree,gc) *params,
                         VEC(tree,gc) *origtypes)
 {
   tree fntype, fundecl = 0;
@@ -2506,7 +2514,7 @@ build_function_call_vec (tree function, VEC(tree,gc) *params,
         resolve_overloaded_builtin and targetm.resolve_overloaded_builtin
         handle all the type checking.  The result is a complete expression
         that implements this function call.  */
-      tem = resolve_overloaded_builtin (function, params);
+      tem = resolve_overloaded_builtin (loc, function, params);
       if (tem)
        return tem;
 
@@ -2514,7 +2522,7 @@ build_function_call_vec (tree function, VEC(tree,gc) *params,
       fundecl = function;
     }
   if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE)
-    function = function_to_pointer_conversion (function);
+    function = function_to_pointer_conversion (loc, function);
 
   /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
      expressions, like those used for ObjC messenger dispatches.  */
@@ -2532,7 +2540,7 @@ build_function_call_vec (tree function, VEC(tree,gc) *params,
   if (!(TREE_CODE (fntype) == POINTER_TYPE
        && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
     {
-      error ("called object %qE is not a function", function);
+      error_at (loc, "called object %qE is not a function", function);
       return error_mark_node;
     }
 
@@ -2561,17 +2569,17 @@ build_function_call_vec (tree function, VEC(tree,gc) *params,
       && !comptypes (fntype, TREE_TYPE (tem)))
     {
       tree return_type = TREE_TYPE (fntype);
-      tree trap = build_function_call (built_in_decls[BUILT_IN_TRAP],
+      tree trap = build_function_call (loc, built_in_decls[BUILT_IN_TRAP],
                                       NULL_TREE);
       int i;
 
       /* This situation leads to run-time undefined behavior.  We can't,
         therefore, simply error unless we can prove that all possible
         executions of the program must execute the code.  */
-      if (warning (0, "function called through a non-compatible type"))
+      if (warning_at (loc, 0, "function called through a non-compatible type"))
        /* We can, however, treat "undefined" any way we please.
           Call abort to encourage the user to fix the program.  */
-       inform (input_location, "if this code is reached, the program will abort");
+       inform (loc, "if this code is reached, the program will abort");
       /* Before the abort, allow the function arguments to exit or
         call longjmp.  */
       for (i = 0; i < nargs; i++)
@@ -2590,7 +2598,7 @@ build_function_call_vec (tree function, VEC(tree,gc) *params,
          tree rhs;
 
          if (AGGREGATE_TYPE_P (return_type))
-           rhs = build_compound_literal (return_type,
+           rhs = build_compound_literal (loc, return_type,
                                          build_constructor (return_type, 0),
                                          false);
          else
@@ -2856,7 +2864,8 @@ convert_arguments (tree typelist, VEC(tree,gc) *values,
                           and the actual arg is that enum type.  */
                        ;
                      else if (formal_prec != TYPE_PRECISION (type1))
-                       warning (OPT_Wtraditional_conversion, "passing argument %d of %qE "
+                       warning (OPT_Wtraditional_conversion,
+                                "passing argument %d of %qE "
                                 "with different width due to prototype",
                                 argnum, rname);
                      else if (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (type1))
@@ -2879,11 +2888,13 @@ convert_arguments (tree typelist, VEC(tree,gc) *values,
                               && TYPE_UNSIGNED (valtype))
                        ;
                      else if (TYPE_UNSIGNED (type))
-                       warning (OPT_Wtraditional_conversion, "passing argument %d of %qE "
+                       warning (OPT_Wtraditional_conversion,
+                                "passing argument %d of %qE "
                                 "as unsigned due to prototype",
                                 argnum, rname);
                      else
-                       warning (OPT_Wtraditional_conversion, "passing argument %d of %qE "
+                       warning (OPT_Wtraditional_conversion,
+                                "passing argument %d of %qE "
                                 "as signed due to prototype", argnum, rname);
                    }
                }
@@ -2957,7 +2968,7 @@ convert_arguments (tree typelist, VEC(tree,gc) *values,
 */
 
 struct c_expr
-parser_build_unary_op (enum tree_code code, struct c_expr arg, location_t loc)
+parser_build_unary_op (location_t loc, enum tree_code code, struct c_expr arg)
 {
   struct c_expr result;
 
@@ -2966,7 +2977,7 @@ parser_build_unary_op (enum tree_code code, struct c_expr arg, location_t loc)
   result.original_type = NULL;
 
   if (TREE_OVERFLOW_P (result.value) && !TREE_OVERFLOW_P (arg.value))
-    overflow_warning (result.value);
+    overflow_warning (loc, result.value);
 
   return result;
 }
@@ -3020,16 +3031,18 @@ parser_build_binary_op (location_t location, enum tree_code code,
     {
       if ((code1 == STRING_CST && !integer_zerop (arg2.value))
          || (code2 == STRING_CST && !integer_zerop (arg1.value)))
-       warning (OPT_Waddress, "comparison with string literal results in unspecified behavior");
+       warning_at (location, OPT_Waddress,
+                   "comparison with string literal results in unspecified behavior");
     }
   else if (TREE_CODE_CLASS (code) == tcc_comparison
           && (code1 == STRING_CST || code2 == STRING_CST))
-    warning (OPT_Waddress, "comparison with string literal results in unspecified behavior");
+    warning_at (location, OPT_Waddress,
+               "comparison with string literal results in unspecified behavior");
 
   if (TREE_OVERFLOW_P (result.value) 
       && !TREE_OVERFLOW_P (arg1.value) 
       && !TREE_OVERFLOW_P (arg2.value))
-    overflow_warning (result.value);
+    overflow_warning (location, result.value);
 
   /* Warn about comparisons of different enum types.  */
   if (warn_enum_compare
@@ -3478,7 +3491,8 @@ build_unary_op (location_t location,
            return error_mark_node;
          return build_binary_op (location, PLUS_EXPR,
                                  (TREE_CODE (TREE_TYPE (op0)) == ARRAY_TYPE
-                                  ? array_to_pointer_conversion (op0)
+                                  ? array_to_pointer_conversion (location,
+                                                                 op0)
                                   : op0),
                                  TREE_OPERAND (arg, 1), 1);
        }
@@ -3755,7 +3769,7 @@ c_mark_addressable (tree exp)
    IFEXP_BCP then the condition is a call to __builtin_constant_p, and
    if folded to an integer constant then the unselected half may
    contain arbitrary operations not normally permitted in constant
-   expressions.  */
+   expressions.  Set the location of the expression to LOC.  */
 
 tree
 build_conditional_expr (location_t colon_loc, tree ifexp, bool ifexp_bcp,
@@ -3983,7 +3997,7 @@ build_conditional_expr (location_t colon_loc, tree ifexp, bool ifexp_bcp,
        result_type = void_type_node;
       else
        {
-         error ("type mismatch in conditional expression");
+         error_at (colon_loc, "type mismatch in conditional expression");
          return error_mark_node;
        }
     }
@@ -4032,14 +4046,17 @@ build_conditional_expr (location_t colon_loc, tree ifexp, bool ifexp_bcp,
   if (ep_result_type)
     ret = build1 (EXCESS_PRECISION_EXPR, ep_result_type, ret);
 
+  protected_set_expr_location (ret, colon_loc);
   return ret;
 }
 \f
 /* Return a compound expression that performs two expressions and
-   returns the value of the second of them.  */
+   returns the value of the second of them.
+
+   LOC is the location of the COMPOUND_EXPR.  */
 
 tree
-build_compound_expr (tree expr1, tree expr2)
+build_compound_expr (location_t loc, tree expr1, tree expr2)
 {
   bool expr1_int_operands, expr2_int_operands;
   tree eptype = NULL_TREE;
@@ -4075,8 +4092,8 @@ build_compound_expr (tree expr1, tree expr2)
                   && CONVERT_EXPR_P (TREE_OPERAND (expr1, 1)))
            ; /* (void) a, (void) b, c */
          else
-           warning (OPT_Wunused_value, 
-                    "left-hand operand of comma expression has no effect");
+           warning_at (loc, OPT_Wunused_value, 
+                       "left-hand operand of comma expression has no effect");
        }
     }
 
@@ -4085,7 +4102,7 @@ build_compound_expr (tree expr1, tree expr2)
      `foo() + bar(), baz()' the result of the `+' operator is not used,
      so we should issue a warning.  */
   else if (warn_unused_value)
-    warn_if_unused_value (expr1, input_location);
+    warn_if_unused_value (expr1, loc);
 
   if (expr2 == error_mark_node)
     return error_mark_node;
@@ -4100,6 +4117,7 @@ build_compound_expr (tree expr1, tree expr2)
   if (eptype)
     ret = build1 (EXCESS_PRECISION_EXPR, eptype, ret);
 
+  protected_set_expr_location (ret, loc);
   return ret;
 }
 
@@ -4190,10 +4208,11 @@ handle_warn_cast_qual (tree type, tree otype)
   while (TREE_CODE (in_type) == POINTER_TYPE);
 }
 
-/* Build an expression representing a cast to type TYPE of expression EXPR.  */
+/* Build an expression representing a cast to type TYPE of expression EXPR.  
+   LOC is the location of the cast-- typically the open paren of the cast.  */
 
 tree
-build_c_cast (tree type, tree expr)
+build_c_cast (location_t loc, tree type, tree expr)
 {
   tree value;
 
@@ -4215,13 +4234,13 @@ build_c_cast (tree type, tree expr)
 
   if (TREE_CODE (type) == ARRAY_TYPE)
     {
-      error ("cast specifies array type");
+      error_at (loc, "cast specifies array type");
       return error_mark_node;
     }
 
   if (TREE_CODE (type) == FUNCTION_TYPE)
     {
-      error ("cast specifies function type");
+      error_at (loc, "cast specifies function type");
       return error_mark_node;
     }
 
@@ -4236,7 +4255,7 @@ build_c_cast (tree type, tree expr)
     {
       if (TREE_CODE (type) == RECORD_TYPE
          || TREE_CODE (type) == UNION_TYPE)
-       pedwarn (input_location, OPT_pedantic, 
+       pedwarn (loc, OPT_pedantic, 
                 "ISO C forbids casting nonscalar to the same type");
     }
   else if (TREE_CODE (type) == UNION_TYPE)
@@ -4253,15 +4272,14 @@ build_c_cast (tree type, tree expr)
        {
          tree t;
 
-         pedwarn (input_location, OPT_pedantic,
-                  "ISO C forbids casts to union type");
-         t = digest_init (type,
+         pedwarn (loc, OPT_pedantic, "ISO C forbids casts to union type");
+         t = digest_init (loc, type,
                           build_constructor_single (type, field, value),
                           NULL_TREE, false, true, 0);
          TREE_CONSTANT (t) = TREE_CONSTANT (value);
          return t;
        }
-      error ("cast to union type from type not present in union");
+      error_at (loc, "cast to union type from type not present in union");
       return error_mark_node;
     }
   else
@@ -4269,7 +4287,11 @@ build_c_cast (tree type, tree expr)
       tree otype, ovalue;
 
       if (type == void_type_node)
-       return build1 (CONVERT_EXPR, type, value);
+       {
+         tree t = build1 (CONVERT_EXPR, type, value);
+         SET_EXPR_LOCATION (t, loc);
+         return t;
+       }
 
       otype = TREE_TYPE (value);
 
@@ -4291,8 +4313,8 @@ build_c_cast (tree type, tree expr)
                || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
               && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
          && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
-       warning (OPT_Wcast_align,
-                "cast increases required alignment of target type");
+       warning_at (loc, OPT_Wcast_align,
+                   "cast increases required alignment of target type");
 
       if (TREE_CODE (type) == INTEGER_TYPE
          && TREE_CODE (otype) == POINTER_TYPE
@@ -4302,21 +4324,23 @@ build_c_cast (tree type, tree expr)
          of cases such as SIG_*, warn about converting constant
          pointers to integers. In some cases it may cause unwanted
          sign extension, and a warning is appropriate.  */
-       warning (OPT_Wpointer_to_int_cast,
-                "cast from pointer to integer of different size");
+       warning_at (loc, OPT_Wpointer_to_int_cast,
+                   "cast from pointer to integer of different size");
 
       if (TREE_CODE (value) == CALL_EXPR
          && TREE_CODE (type) != TREE_CODE (otype))
-       warning (OPT_Wbad_function_cast, "cast from function call of type %qT "
-                "to non-matching type %qT", otype, type);
+       warning_at (loc, OPT_Wbad_function_cast,
+                   "cast from function call of type %qT "
+                   "to non-matching type %qT", otype, type);
 
       if (TREE_CODE (type) == POINTER_TYPE
          && TREE_CODE (otype) == INTEGER_TYPE
          && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
          /* Don't warn about converting any constant.  */
          && !TREE_CONSTANT (value))
-       warning (OPT_Wint_to_pointer_cast, "cast to pointer from integer "
-                "of different size");
+       warning_at (loc,
+                   OPT_Wint_to_pointer_cast, "cast to pointer from integer "
+                   "of different size");
 
       if (warn_strict_aliasing <= 2)
         strict_aliasing_warning (otype, type, expr);
@@ -4329,7 +4353,7 @@ build_c_cast (tree type, tree expr)
          && TREE_CODE (otype) == POINTER_TYPE
          && TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE
          && TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE)
-       pedwarn (input_location, OPT_pedantic, "ISO C forbids "
+       pedwarn (loc, OPT_pedantic, "ISO C forbids "
                 "conversion of function pointer to object pointer type");
 
       if (pedantic
@@ -4338,7 +4362,7 @@ build_c_cast (tree type, tree expr)
          && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
          && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
          && !null_pointer_constant_p (value))
-       pedwarn (input_location, OPT_pedantic, "ISO C forbids "
+       pedwarn (loc, OPT_pedantic, "ISO C forbids "
                 "conversion of object pointer to function pointer type");
 
       ovalue = value;
@@ -4382,12 +4406,16 @@ build_c_cast (tree type, tree expr)
               || TREE_CODE (expr) == COMPLEX_CST)))
       value = build1 (NOP_EXPR, type, value);
 
+  if (CAN_HAVE_LOCATION_P (value))
+    SET_EXPR_LOCATION (value, loc);
   return value;
 }
 
-/* Interpret a cast of expression EXPR to type TYPE.  */
+/* Interpret a cast of expression EXPR to type TYPE.  LOC is the
+   location of the open paren of the cast, or the position of the cast
+   expr.  */
 tree
-c_cast_expr (struct c_type_name *type_name, tree expr, location_t loc)
+c_cast_expr (location_t loc, struct c_type_name *type_name, tree expr)
 {
   tree type;
   tree type_expr = NULL_TREE;
@@ -4402,11 +4430,12 @@ c_cast_expr (struct c_type_name *type_name, tree expr, location_t loc)
   type = groktypename (type_name, &type_expr, &type_expr_const);
   warn_strict_prototypes = saved_wsp;
 
-  ret = build_c_cast (type, expr);
+  ret = build_c_cast (loc, type, expr);
   if (type_expr)
     {
       ret = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (ret), type_expr, ret);
       C_MAYBE_CONST_EXPR_NON_CONST (ret) = !type_expr_const;
+      SET_EXPR_LOCATION (ret, loc);
     }
 
   if (CAN_HAVE_LOCATION_P (ret) && !EXPR_HAS_LOCATION (ret))
@@ -4429,11 +4458,13 @@ c_cast_expr (struct c_type_name *type_name, tree expr, location_t loc)
    If RHS_ORIGTYPE is not NULL_TREE, it is the original type of RHS,
    which may differ from TREE_TYPE (RHS) for an enum value.
 
-   LOCATION is the location of the MODIFYCODE operator.  */
+   LOCATION is the location of the MODIFYCODE operator.
+   RHS_LOC is the location of the RHS.  */
 
 tree
 build_modify_expr (location_t location, tree lhs, tree lhs_origtype,
-                  enum tree_code modifycode, tree rhs, tree rhs_origtype)
+                  enum tree_code modifycode, 
+                  location_t rhs_loc, tree rhs, tree rhs_origtype)
 {
   tree result;
   tree newrhs;
@@ -4463,7 +4494,7 @@ build_modify_expr (location_t location, tree lhs, tree lhs_origtype,
   if (TREE_CODE (lhs) == C_MAYBE_CONST_EXPR)
     {
       tree inner = build_modify_expr (location, C_MAYBE_CONST_EXPR_EXPR (lhs),
-                                     lhs_origtype, modifycode, rhs,
+                                     lhs_origtype, modifycode, rhs_loc, rhs,
                                      rhs_origtype);
       if (inner == error_mark_node)
        return error_mark_node;
@@ -4596,6 +4627,7 @@ build_modify_expr (location_t location, tree lhs, tree lhs_origtype,
    ERRTYPE says whether it is argument passing, assignment,
    initialization or return.
 
+   LOCATION is the location of the RHS.
    FUNCTION is a tree for the function being called.
    PARMNUM is the number of the argument, for printing in error messages.  */
 
@@ -4634,14 +4666,14 @@ convert_for_assignment (location_t location, tree type, tree rhs,
   /* This macro is used to emit diagnostics to ensure that all format
      strings are complete sentences, visible to gettext and checked at
      compile time.  */
-#define WARN_FOR_ASSIGNMENT(LOCATION, OPT, AR, AS, IN, RE)               \
+#define WARN_FOR_ASSIGNMENT(LOCATION, OPT, AR, AS, IN, RE)                      \
   do {                                                                   \
     switch (errtype)                                                     \
       {                                                                  \
       case ic_argpass:                                                   \
         if (pedwarn (LOCATION, OPT, AR, parmnum, rname))                 \
-          inform ((fundecl && !DECL_IS_BUILTIN (fundecl))                \
-                 ? DECL_SOURCE_LOCATION (fundecl) : LOCATION,           \
+          inform ((fundecl && !DECL_IS_BUILTIN (fundecl))               \
+                 ? DECL_SOURCE_LOCATION (fundecl) : LOCATION,           \
                   "expected %qT but argument is of type %qT",            \
                   type, rhstype);                                        \
         break;                                                           \
@@ -4652,7 +4684,7 @@ convert_for_assignment (location_t location, tree type, tree rhs,
         pedwarn (LOCATION, OPT, IN);                                     \
         break;                                                           \
       case ic_return:                                                    \
-        pedwarn (LOCATION, OPT, RE);                                     \
+        pedwarn (LOCATION, OPT, RE);                                    \
         break;                                                           \
       default:                                                           \
         gcc_unreachable ();                                              \
@@ -4723,7 +4755,7 @@ convert_for_assignment (location_t location, tree type, tree rhs,
         an unprototyped function, it is compile-time undefined;
         making it a constraint in that case was rejected in
         DR#252.  */
-      error ("void value not ignored as it ought to be");
+      error_at (location, "void value not ignored as it ought to be");
       return error_mark_node;
     }
   rhs = require_complete_type (rhs);
@@ -4737,12 +4769,13 @@ convert_for_assignment (location_t location, tree type, tree rhs,
     {
       if (!lvalue_p (rhs))
        {
-         error ("cannot pass rvalue to reference parameter");
+         error_at (location, "cannot pass rvalue to reference parameter");
          return error_mark_node;
        }
       if (!c_mark_addressable (rhs))
        return error_mark_node;
       rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
+      SET_EXPR_LOCATION (rhs, location);
 
       /* We already know that these two types are compatible, but they
         may not be exactly identical.  In fact, `TREE_TYPE (type)' is
@@ -4750,9 +4783,13 @@ convert_for_assignment (location_t location, tree type, tree rhs,
         likely to be va_list, a typedef to __builtin_va_list, which
         is different enough that it will cause problems later.  */
       if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
-       rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
+       {
+         rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
+         SET_EXPR_LOCATION (rhs, location);
+       }
 
       rhs = build1 (NOP_EXPR, type, rhs);
+      SET_EXPR_LOCATION (rhs, location);
       return rhs;
     }
   /* Some types can interconvert without explicit casts.  */
@@ -4859,7 +4896,7 @@ convert_for_assignment (location_t location, tree type, tree rhs,
                     function where an ordinary one is wanted, but not
                     vice-versa.  */
                  if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
-                   WARN_FOR_ASSIGNMENT (input_location, 0,
+                   WARN_FOR_ASSIGNMENT (location, 0,
                                         G_("passing argument %d of %qE "
                                            "makes qualified function "
                                            "pointer from unqualified"),
@@ -4873,7 +4910,7 @@ convert_for_assignment (location_t location, tree type, tree rhs,
                                            "pointer from unqualified"));
                }
              else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
-               WARN_FOR_ASSIGNMENT (input_location, 0,
+               WARN_FOR_ASSIGNMENT (location, 0,
                                     G_("passing argument %d of %qE discards "
                                        "qualifiers from pointer target type"),
                                     G_("assignment discards qualifiers "