From patchwork Thu Aug 2 03:23:21 2012 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Dehao Chen X-Patchwork-Id: 174680 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) by ozlabs.org (Postfix) with SMTP id C48AA2C008E for ; Thu, 2 Aug 2012 13:23:59 +1000 (EST) Comment: DKIM? See http://www.dkim.org DKIM-Signature: v=1; a=rsa-sha1; c=relaxed/relaxed; d=gcc.gnu.org; s=default; x=1344482640; h=Comment: DomainKey-Signature:Received:Received:Received:Received:Received: MIME-Version:Received:Received:In-Reply-To:References:Date: Message-ID:Subject:From:To:Cc:Content-Type:Mailing-List: Precedence:List-Id:List-Unsubscribe:List-Archive:List-Post: List-Help:Sender:Delivered-To; bh=8L70Kl20DgMl8+mVlr1Jn45OOvo=; b=Wm7lkEqkWhYIdqIj/8ChSWeIMqIgnkIk+i4Dr57Yt3+BilD03RZniZnB3vTGVX 0Fb/QfPZacWSMzYZqNdU/tv6S3yXm2oHbsDg4GOj6tNRs/CEy52rJVh9C+5ZuuIc tmkMa0oLn+4fkZyh/AzhwkGu7A3Kx6/oAUwVBG19Lb2PI= Comment: DomainKeys? See http://antispam.yahoo.com/domainkeys DomainKey-Signature: a=rsa-sha1; q=dns; c=nofws; s=default; d=gcc.gnu.org; h=Received:Received:X-SWARE-Spam-Status:X-Spam-Check-By:Received:Received:X-Google-DKIM-Signature:Received:MIME-Version:Received:Received:In-Reply-To:References:Date:Message-ID:Subject:From:To:Cc:Content-Type:X-System-Of-Record:X-Gm-Message-State:X-IsSubscribed:Mailing-List:Precedence:List-Id:List-Unsubscribe:List-Archive:List-Post:List-Help:Sender:Delivered-To; b=Elni6hBmNDLABdOCxwYs+AoA2CaCFT/XV0QwN0G98c+J5uWd1oKn7ldlGuy5I9 0OJAhzfvtvG1IHQuogd8mHUeOgxckkhy7JU8fodl/F/n4uih43JJ1knxMiv28gZQ 0kFUy/h+Id8H8V/9p5zvKn6P0nvxDuNs4UzRCTMIAlNp0=; Received: (qmail 22100 invoked by alias); 2 Aug 2012 03:23:55 -0000 Received: (qmail 22074 invoked by uid 22791); 2 Aug 2012 03:23:45 -0000 X-SWARE-Spam-Status: No, hits=-5.4 required=5.0 tests=AWL, BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, KHOP_RCVD_TRUST, KHOP_THREADED, RCVD_IN_DNSWL_LOW, RCVD_IN_HOSTKARMA_YE, TW_DD, TW_LR, TW_TM, T_RP_MATCHES_RCVD, URIBL_DBL_REDIR X-Spam-Check-By: sourceware.org Received: from mail-gg0-f175.google.com (HELO mail-gg0-f175.google.com) (209.85.161.175) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Thu, 02 Aug 2012 03:23:22 +0000 Received: by ggnp4 with SMTP id p4so8240237ggn.20 for ; Wed, 01 Aug 2012 20:23:21 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20120113; h=mime-version:in-reply-to:references:date:message-id:subject:from:to :cc:content-type:x-system-of-record:x-gm-message-state; bh=9nxRhCsx6vN1JxO3RoBizdY7ekyZtbX2t4jneaBWz9Q=; b=B/AWYVfAJ4cj++Nz/aE65ZwN9oA3QbZi3BOhQ3JjFmrxm4up26T0E4OmjFe13yuPaY yulQ2YWgPcwKbs7L1nWJ4LnYtJwQEQMUy+GQbYDRo/GRLaFJpxe+stdc3swDbfb01+Wa N/USrCzluOdM73dnjQ6Gl0dsaDgS2MKXZ1Fsfzlhdz/tPVFmOj7iXE39ZVMmnRcQqXAO bFXWCuhQg20pyCOY21fs/Esc+avQBiub0qITpyku2T51zkjMhCzFe46glHsVil0hXrL5 1CcG3LJeftKZodxKAlRHZG6ZjlzPWXryPGNFyF6yOlA3H/wcIE6BLjfqLax0U2X+5gq9 VDSw== Received: by 10.50.94.133 with SMTP id dc5mr782470igb.16.1343877801486; Wed, 01 Aug 2012 20:23:21 -0700 (PDT) MIME-Version: 1.0 Received: by 10.50.94.133 with SMTP id dc5mr782443igb.16.1343877801214; Wed, 01 Aug 2012 20:23:21 -0700 (PDT) Received: by 10.50.104.134 with HTTP; Wed, 1 Aug 2012 20:23:21 -0700 (PDT) In-Reply-To: References: Date: Thu, 2 Aug 2012 11:23:21 +0800 Message-ID: Subject: Re: [PATCH] Combine location with block using block_locations From: Dehao Chen To: Richard Guenther Cc: gcc-patches@gcc.gnu.org, Dodji Seketeli , Jakub Jelinek , Jan Hubicka , David Li X-System-Of-Record: true X-Gm-Message-State: ALoCoQmB31SUZkEyHIPdi0QOD0KTuYWzmlJluCKWXGLPBd5rO/O5Lu8ZO+GMAtowRUaAhdu0wkd9j0gfMe5J1AUh7AoQZyx8vmG6bpfQ0xljXA2EZAZEy1knEf7FmiwT5WvjvMz8Xwo0CJKsYrsXCHKeoH9BnF6FZ9r7tvcmp8DdkAy70ofEWYT4a8wJbYdKbX7nGx8UF1VJ X-IsSubscribed: yes Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org On Thu, Aug 2, 2012 at 2:07 AM, Richard Guenther wrote: > On Wed, Aug 1, 2012 at 7:35 AM, Dehao Chen wrote: >> Hi, >> >> This patch: >> >> * Integrates location with block into an integrated index. >> * Removes gimple->gsbase.block and tree->exp.block fields. >> * Updates inline/clone as well as tree liveness analysis to ensure the >> associated blocks are updated correctly. >> >> With this patch, the association between source location and its block >> are greatly enhanced, which produces much better inline stack in the >> debug info. >> >> Bootstrapped and regression tested on x86. >> >> OK for trunk? > > Nice. But the LTO changes mean that you simply drop all BLOCK > associations on the floor ... Why? I've invoked TREE_SET_BLOCK in tree-streamer-in.c to read in the block info. So it should at least provide the same info as the original impl. > they at least look very incomplete. Did you actually run LTO tests? Thanks for the reminder, I've added the following change to this patch: I think BLOCK associations works fine for LTO. I've run check-gcc, and there's no regression on LTO tests. I also manually write some tests, and the generated final assembly has block info as expected. > > lto/ has its own ChangeLog Thanks, I'll update the ChangeLog accordingly. > and I wonder why no frontends are affected > by this patch? Which files are you referring to? Thanks, Dehao > > Richard. > >> Thanks, >> Dehao >> >> You can also find the patch in http://codereview.appspot.com/6454077 >> >> gcc/ChangeLog >> 2012-08-01 Dehao Chen >> >> * toplev.c (general_init): Init block_locations. >> * tree.c (tree_set_block): New. >> (tree_block): Change to use LOCATION_BLOCK. >> * tree.h (TREE_SET_BLOCK): New. >> * final.c (reemit_insn_block_notes): Change to use LOCATION_BLOCK. >> (final_start_function): Likewise. >> * input.c (expand_location_1): Likewise. >> * input.h (LOCATION_LOCUS): New. >> (LOCATION_BLOCK): New. >> (IS_UNKNOWN_LOCATION): New. >> * fold-const.c (expr_location_or): Change to use new location. >> * reorg.c (emit_delay_sequence): Likewise. >> (try_merge_delay_insns): Likewise. >> * modulo-sched.c (dump_insn_location): Likewise. >> * lto-streamer-out.c (lto_output_location_bitpack): Likewise. >> * jump.c (rtx_renumbered_equal_p): Likewise. >> * ifcvt.c (noce_try_move): Likewise. >> (noce_try_store_flag): Likewise. >> (noce_try_store_flag_constants): Likewise. >> (noce_try_addcc): Likewise. >> (noce_try_store_flag_mask): Likewise. >> (noce_try_cmove): Likewise. >> (noce_try_cmove_arith): Likewise. >> (noce_try_minmax): Likewise. >> (noce_try_abs): Likewise. >> (noce_try_sign_mask): Likewise. >> (noce_try_bitop): Likewise. >> (noce_process_if_block): Likewise. >> (cond_move_process_if_block): Likewise. >> (find_cond_trap): Likewise. >> * dewarf2out.c (add_src_coords_attributes): Likewise. >> * expr.c (expand_expr_real): Likewise. >> * tree-parloops.c (create_loop_fn): Likewise. >> * recog.c (peep2_attempt): Likewise. >> * function.c (free_after_compilation): Likewise. >> (expand_function_end): Likewise. >> (set_insn_locations): Likewise. >> (thread_prologue_and_epilogue_insns): Likewise. >> * print-rtl.c (print_rtx): Likewise. >> * profile.c (branch_prob): Likewise. >> * trans-mem.c (ipa_tm_scan_irr_block): Likewise. >> * gimplify.c (gimplify_call_expr): Likewise. >> * except.c (duplicate_eh_regions_1): Likewise. >> * emit-rtl.c (try_split): Likewise. >> (make_insn_raw): Likewise. >> (make_debug_insn_raw): Likewise. >> (make_jump_insn_raw): Likewise. >> (make_call_insn_raw): Likewise. >> (emit_pattern_after_setloc): Likewise. >> (emit_pattern_after): Likewise. >> (emit_debug_insn_after): Likewise. >> (emit_pattern_before): Likewise. >> (emit_insn_before_setloc): Likewise. >> (emit_jump_insn_before): Likewise. >> (emit_call_insn_before_setloc): Likewise. >> (emit_call_insn_before): Likeise. >> (emit_debug_insn_before_setloc): Likewise. >> (emit_copy_of_insn_after): Likewise. >> (insn_locators_alloc): Remove. >> (insn_locators_finalize): Remove. >> (insn_locators_free): Remove. >> (set_curr_insn_source_location): Remove. >> (get_curr_insn_source_location): Remove. >> (set_curr_insn_block): Remove. >> (get_curr_insn_block): Remove. >> (locator_scope): Remove. >> (insn_scope): Change to use new location. >> (locator_location): Remove. >> (insn_line): Change to use new location. >> (locator_file): Remove. >> (insn_file): Change to use new location. >> (locator_eq): Remove. >> (insn_locations_init): New. >> (insn_locations_finalize): New. >> (set_curr_insn_location): New. >> (curr_insn_location): New. >> * cfgexpand.c (gimple_assign_rhs_to_tree): Change to use new location. >> (expand_gimple_cond): Likewise. >> (expand_call_stmt): Likewise. >> (expand_gimple_stmt_1): Likewise. >> (expand_gimple_basic_block): Likewise. >> (construct_exit_block): Likewise. >> (gimple_expand_cfg): Likewise. >> * cfgcleanup.c (try_forward_edges): Likewise. >> * tree-ssa-live.c (remove_unused_scope_block_p): Likewise. >> (dump_scope_block): Likewise. >> (remove_unused_locals): Likewise. >> * lto/lto.c (lto_fixup_prevailing_decls): Likewise. >> * rtl.c (rtx_equal_p_cb): Likewise. >> (rtx_equal_p): Likewise. >> * rtl.h (XUINT): New. >> (INSN_LOCATOR): Remove. >> (CURR_INSN_LOCATION): Remove. >> (INSN_LOCATION): New. >> (INSN_HAS_LOCATION): New. >> * tree-inline.c (remap_gimple_op_r): Change to use new location. >> (copy_tree_body_r): Likewise. >> (copy_phis_for_bb): Likewise. >> (expand_call_inline): Likewise. >> * tree-streamer-in.c (lto_input_ts_exp_tree_pointers): Likewise. >> * combine.c (try_combine): Likewise. >> * tree-outof-ssa.c (set_location_for_edge): Likewise. >> (insert_partition_copy_on_edge): Likewise. >> (insert_value_copy_on_edge): Likewise. >> (insert_rtx_to_part_on_edge): Likewise. >> (insert_part_to_rtx_on_edge): Likewise. >> * basic-block.h (edge_def): Remove field. >> * gimple.h (gimple_statement_base): Remove field. >> (gimple_bb): Change to use new location. >> (gimple_set_block): Likewise. >> (gimple_has_location): Likewise. >> * tree-cfg.c (make_cond_expr_edges): Likewise. >> (make_goto_expr_edges): Likewise. >> (gimple_can_merge_blocks_p): Likewise. >> (move_stmt_op): Likewise. >> (move_block_to_fn): Likewise. >> * config/alpha/alpha.c (alpha_output_mi_thunk_osf): Likewise. >> * config/sparc/sparc.c (sparc_output_mi_thunk): Likewise. >> * config/i386/i386.c (x86_output_mi_thunk): Likewise. >> * config/tilegx/tilegx.c (tilegx_output_mi_thunk): Likewise. >> * config/sh/sh.c (sh_output_mi_thunk): Likewise. >> * config/ia64/ia64.c (ia64_output_mi_thunk): Likewise. >> * config/rs6000/rs6000.c (rs6000_output_mi_thunk): Likewise. >> * config/score/score.c (score_output_mi_thunk): Likewise. >> * config/tilepro/tilepro.c (tilepro_asm_output_mi_thunk): Likewise. >> * config/mips/mips.c (mips_output_mi_thunk): Likewise. >> * cfgrtl.c (unique_locus_on_edge_between_p): Likewise. >> (unique_locus_on_edge_between_p): Likewise. >> (emit_nop_for_unique_locus_between): Likewise. >> (force_nonfallthru_and_redirect): Likewise. >> (fixup_reorder_chain): Likewise. >> (cfg_layout_merge_blocks): Likewise. >> * stmt.c (emit_case_nodes): Likewise. >> >> libcpp/ChangeLog >> 2012-08-01 Dehao Chen >> >> * include/line-map.h (MAX_SOURCE_LOCATION): New value. >> (location_block_init): New. >> (location_block_fini): New. >> (get_combine_location): New. >> (get_block_from_location): New. >> (get_locus_from_location): New. >> (COMBINE_LOCATION): New. >> (IS_COMBINED_LOCATION): New. >> (expanded_location): New field. >> * line-map.c (location_block): New. >> (location_block_htab): New. >> (curr_combined_location): New. >> (location_blocks): New. >> (allocated_location_blocks): New. >> (location_block_hash): New. >> (location_block_eq): New. >> (location_block_update): New. >> (get_combine_location): New. >> (get_block_from_location): New. >> (get_locus_from_location): New. >> (location_block_init): New. >> (location_block_fini): New. >> (linemap_lookup): Change to use new location. >> (linemap_ordinary_map_lookup): Likewise. >> (linemap_macro_map_lookup): Likewise. >> (linemap_macro_map_loc_to_def_point): Likewise. >> (linemap_macro_map_loc_unwind_toward_spel): Likewise. >> (linemap_get_expansion_line): Likewise. >> (linemap_get_expansion_filename): Likewise. >> (linemap_location_in_system_header_p): Likewise. >> (linemap_location_from_macro_expansion_p): Likewise. >> (linemap_macro_loc_to_spelling_point): Likewise. >> (linemap_macro_loc_to_def_point): Likewise. >> (linemap_macro_loc_to_exp_point): Likewise. >> (linemap_resolve_location): Likewise. >> (linemap_unwind_toward_expansion): Likewise. >> (linemap_unwind_to_first_non_reserved_loc): Likewise. >> (linemap_expand_location): Likewise. >> (linemap_dump_location): Likewise. >> >> Index: gcc/tree.c >> =================================================================== >> --- gcc/tree.c (revision 189835) >> +++ gcc/tree.c (working copy) >> @@ -3765,7 +3765,6 @@ >> TREE_TYPE (t) = type; >> SET_EXPR_LOCATION (t, UNKNOWN_LOCATION); >> TREE_OPERAND (t, 0) = node; >> - TREE_BLOCK (t) = NULL_TREE; >> if (node && !TYPE_P (node)) >> { >> TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node); >> @@ -10867,17 +10866,28 @@ >> } >> >> >> -tree * >> +tree >> tree_block (tree t) >> { >> char const c = TREE_CODE_CLASS (TREE_CODE (t)); >> >> if (IS_EXPR_CODE_CLASS (c)) >> - return &t->exp.block; >> + return LOCATION_BLOCK (t->exp.locus); >> gcc_unreachable (); >> return NULL; >> } >> >> +void >> +tree_set_block (tree t, tree b) >> +{ >> + char const c = TREE_CODE_CLASS (TREE_CODE (t)); >> + >> + if (IS_EXPR_CODE_CLASS (c)) >> + t->exp.locus = COMBINE_LOCATION (t->exp.locus, b); >> + else >> + gcc_unreachable (); >> +} >> + >> /* Create a nameless artificial label and put it in the current >> function context. The label has a location of LOC. Returns the >> newly created label. */ >> Index: gcc/tree.h >> =================================================================== >> --- gcc/tree.h (revision 189835) >> +++ gcc/tree.h (working copy) >> @@ -999,7 +999,8 @@ >> >> #endif >> >> -#define TREE_BLOCK(NODE) *(tree_block (NODE)) >> +#define TREE_BLOCK(NODE) (tree_block (NODE)) >> +#define TREE_SET_BLOCK(T, B) (tree_set_block ((T), (B))) >> >> #include "tree-check.h" >> >> @@ -1702,7 +1703,7 @@ >> #define EXPR_LOCATION(NODE) \ >> (CAN_HAVE_LOCATION_P ((NODE)) ? (NODE)->exp.locus : UNKNOWN_LOCATION) >> #define SET_EXPR_LOCATION(NODE, LOCUS) EXPR_CHECK ((NODE))->exp.locus = (LOCUS) >> -#define EXPR_HAS_LOCATION(NODE) (EXPR_LOCATION (NODE) != UNKNOWN_LOCATION) >> +#define EXPR_HAS_LOCATION(NODE) (!IS_UNKNOWN_LOCATION (EXPR_LOCATION (NODE))) >> /* The location to be used in a diagnostic about this expression. Do not >> use this macro if the location will be assigned to other expressions. */ >> #define EXPR_LOC_OR_HERE(NODE) (EXPR_HAS_LOCATION (NODE) ? >> (NODE)->exp.locus : input_location) >> @@ -1881,7 +1882,7 @@ >> OMP_CLAUSE_PRIVATE, \ >> OMP_CLAUSE_COPYPRIVATE), 0) >> #define OMP_CLAUSE_HAS_LOCATION(NODE) \ >> - ((OMP_CLAUSE_CHECK (NODE))->omp_clause.locus != UNKNOWN_LOCATION) >> + (!IS_UNKNOWN_LOCATION ((OMP_CLAUSE_CHECK (NODE))->omp_clause.locus)) >> #define OMP_CLAUSE_LOCATION(NODE) (OMP_CLAUSE_CHECK (NODE))->omp_clause.locus >> >> /* True on an OMP_SECTION statement that was the last lexical member. >> @@ -1972,7 +1973,6 @@ >> struct GTY(()) tree_exp { >> struct tree_typed typed; >> location_t locus; >> - tree block; >> tree GTY ((special ("tree_exp"), >> desc ("TREE_CODE ((tree) &%0)"))) >> operands[1]; >> @@ -5164,7 +5164,7 @@ >> static inline bool >> inlined_function_outer_scope_p (const_tree block) >> { >> - return BLOCK_SOURCE_LOCATION (block) != UNKNOWN_LOCATION; >> + return !IS_UNKNOWN_LOCATION (BLOCK_SOURCE_LOCATION (block)); >> } >> >> /* Loop over all function arguments of FNTYPE. In each iteration, PTR is set >> @@ -5539,7 +5539,8 @@ >> extern HOST_WIDE_INT int_cst_value (const_tree); >> extern HOST_WIDEST_INT widest_int_cst_value (const_tree); >> >> -extern tree *tree_block (tree); >> +extern tree tree_block (tree); >> +extern void tree_set_block (tree, tree); >> extern location_t *block_nonartificial_location (tree); >> extern location_t tree_nonartificial_location (tree); >> >> Index: gcc/final.c >> =================================================================== >> --- gcc/final.c (revision 189835) >> +++ gcc/final.c (working copy) >> @@ -1605,7 +1605,7 @@ >> insn_scope (XVECEXP (body, 0, i))); >> } >> if (! this_block) >> - continue; >> + this_block = DECL_INITIAL (cfun->decl); >> >> if (this_block != cur_block) >> { >> @@ -1640,8 +1640,8 @@ >> >> this_is_asm_operands = 0; >> >> - last_filename = locator_file (prologue_locator); >> - last_linenum = locator_line (prologue_locator); >> + last_filename = LOCATION_FILE (prologue_location); >> + last_linenum = LOCATION_LINE (prologue_location); >> last_discriminator = discriminator = 0; >> >> high_block_linenum = high_function_linenum = last_linenum; >> Index: gcc/input.c >> =================================================================== >> --- gcc/input.c (revision 189835) >> +++ gcc/input.c (working copy) >> @@ -51,6 +51,13 @@ >> expanded_location xloc; >> const struct line_map *map; >> enum location_resolution_kind lrk = LRK_MACRO_EXPANSION_POINT; >> + tree block = NULL; >> + >> + if (IS_COMBINED_LOCATION (loc)) >> + { >> + block = LOCATION_BLOCK (loc); >> + loc = LOCATION_LOCUS (loc); >> + } >> >> memset (&xloc, 0, sizeof (xloc)); >> >> @@ -74,6 +81,7 @@ >> xloc = linemap_expand_location (line_table, map, loc); >> } >> >> + xloc.block = block; >> if (loc <= BUILTINS_LOCATION) >> xloc.file = loc == UNKNOWN_LOCATION ? NULL : _(""); >> >> Index: gcc/input.h >> =================================================================== >> --- gcc/input.h (revision 189835) >> +++ gcc/input.h (working copy) >> @@ -51,6 +51,14 @@ >> #define LOCATION_FILE(LOC) ((expand_location (LOC)).file) >> #define LOCATION_LINE(LOC) ((expand_location (LOC)).line) >> #define LOCATION_COLUMN(LOC)((expand_location (LOC)).column) >> +#define LOCATION_LOCUS(LOC) \ >> + ((IS_COMBINED_LOCATION(LOC)) ? get_locus_from_location (LOC) : (LOC)) >> +#define LOCATION_BLOCK(LOC) \ >> + ((tree) ((IS_COMBINED_LOCATION (LOC)) ? get_block_from_location (LOC) \ >> + : NULL)) >> +#define IS_UNKNOWN_LOCATION(LOC) \ >> + ((IS_COMBINED_LOCATION (LOC)) ? get_locus_from_location (LOC) == 0 \ >> + : (LOC) == 0) >> >> #define input_line LOCATION_LINE (input_location) >> #define input_filename LOCATION_FILE (input_location) >> Index: gcc/fold-const.c >> =================================================================== >> --- gcc/fold-const.c (revision 189835) >> +++ gcc/fold-const.c (working copy) >> @@ -145,7 +145,7 @@ >> expr_location_or (tree t, location_t loc) >> { >> location_t tloc = EXPR_LOCATION (t); >> - return tloc != UNKNOWN_LOCATION ? tloc : loc; >> + return IS_UNKNOWN_LOCATION (tloc) ? loc : tloc; >> } >> >> /* Similar to protected_set_expr_location, but never modify x in place, >> Index: gcc/toplev.c >> =================================================================== >> --- gcc/toplev.c (revision 189835) >> +++ gcc/toplev.c (working copy) >> @@ -1140,6 +1140,7 @@ >> linemap_init (line_table); >> line_table->reallocator = realloc_for_line_map; >> line_table->round_alloc_size = ggc_round_alloc_size; >> + location_block_init (); >> init_ttree (); >> >> /* Initialize register usage now so switches may override. */ >> @@ -1946,6 +1947,7 @@ >> invoke_plugin_callbacks (PLUGIN_FINISH, NULL); >> >> finalize_plugins (); >> + location_block_fini (); >> if (seen_error ()) >> return (FATAL_EXIT_CODE); >> >> Index: gcc/reorg.c >> =================================================================== >> --- gcc/reorg.c (revision 189835) >> +++ gcc/reorg.c (working copy) >> @@ -545,7 +545,7 @@ >> INSN_DELETED_P (delay_insn) = 0; >> PREV_INSN (delay_insn) = PREV_INSN (seq_insn); >> >> - INSN_LOCATOR (seq_insn) = INSN_LOCATOR (delay_insn); >> + INSN_LOCATION (seq_insn) = INSN_LOCATION (delay_insn); >> >> for (li = list; li; li = XEXP (li, 1), i++) >> { >> @@ -561,9 +561,9 @@ >> >> /* SPARC assembler, for instance, emit warning when debug info is output >> into the delay slot. */ >> - if (INSN_LOCATOR (tem) && !INSN_LOCATOR (seq_insn)) >> - INSN_LOCATOR (seq_insn) = INSN_LOCATOR (tem); >> - INSN_LOCATOR (tem) = 0; >> + if (INSN_LOCATION (tem) && !INSN_LOCATION (seq_insn)) >> + INSN_LOCATION (seq_insn) = INSN_LOCATION (tem); >> + INSN_LOCATION (tem) = 0; >> >> for (note = REG_NOTES (tem); note; note = next) >> { >> @@ -4087,7 +4087,7 @@ >> for (link = crtl->epilogue_delay_list; >> link; >> link = XEXP (link, 1)) >> - INSN_LOCATOR (XEXP (link, 0)) = 0; >> + INSN_LOCATION (XEXP (link, 0)) = 0; >> } >> >> #endif >> Index: gcc/modulo-sched.c >> =================================================================== >> --- gcc/modulo-sched.c (revision 189835) >> +++ gcc/modulo-sched.c (working copy) >> @@ -1246,9 +1246,9 @@ >> /* Dump file:line from INSN's location info to dump_file. */ >> >> static void >> -dump_insn_locator (rtx insn) >> +dump_insn_location (rtx insn) >> { >> - if (dump_file && INSN_LOCATOR (insn)) >> + if (dump_file && INSN_LOCATION (insn)) >> { >> const char *file = insn_file (insn); >> if (file) >> @@ -1282,7 +1282,7 @@ >> rtx insn = BB_END (loop->header); >> >> fprintf (dump_file, "SMS loop many exits"); >> - dump_insn_locator (insn); >> + dump_insn_location (insn); >> fprintf (dump_file, "\n"); >> } >> return false; >> @@ -1295,7 +1295,7 @@ >> rtx insn = BB_END (loop->header); >> >> fprintf (dump_file, "SMS loop many BBs."); >> - dump_insn_locator (insn); >> + dump_insn_location (insn); >> fprintf (dump_file, "\n"); >> } >> return false; >> @@ -1421,7 +1421,7 @@ >> rtx insn = BB_END (loop->header); >> >> fprintf (dump_file, "SMS loop num: %d", loop->num); >> - dump_insn_locator (insn); >> + dump_insn_location (insn); >> fprintf (dump_file, "\n"); >> } >> >> @@ -1450,7 +1450,7 @@ >> { >> if (dump_file) >> { >> - dump_insn_locator (tail); >> + dump_insn_location (tail); >> fprintf (dump_file, "\nSMS single-bb-loop\n"); >> if (profile_info && flag_branch_probabilities) >> { >> @@ -1556,7 +1556,7 @@ >> rtx insn = BB_END (loop->header); >> >> fprintf (dump_file, "SMS loop num: %d", loop->num); >> - dump_insn_locator (insn); >> + dump_insn_location (insn); >> fprintf (dump_file, "\n"); >> >> print_ddg (dump_file, g); >> @@ -1571,7 +1571,7 @@ >> >> if (dump_file) >> { >> - dump_insn_locator (tail); >> + dump_insn_location (tail); >> fprintf (dump_file, "\nSMS single-bb-loop\n"); >> if (profile_info && flag_branch_probabilities) >> { >> @@ -1714,7 +1714,7 @@ >> >> if (dump_file) >> { >> - dump_insn_locator (tail); >> + dump_insn_location (tail); >> fprintf (dump_file, " SMS succeeded %d %d (with ii, sc)\n", >> ps->ii, stage_count); >> print_partial_schedule (ps, dump_file); >> Index: gcc/lto-streamer-out.c >> =================================================================== >> --- gcc/lto-streamer-out.c (revision 189835) >> +++ gcc/lto-streamer-out.c (working copy) >> @@ -155,6 +155,7 @@ >> { >> expanded_location xloc; >> >> + loc = LOCATION_LOCUS (loc); >> bp_pack_value (bp, loc == UNKNOWN_LOCATION, 1); >> if (loc == UNKNOWN_LOCATION) >> return; >> Index: gcc/jump.c >> =================================================================== >> --- gcc/jump.c (revision 189835) >> +++ gcc/jump.c (working copy) >> @@ -1818,8 +1818,7 @@ >> if (XINT (x, i) != XINT (y, i)) >> { >> if (((code == ASM_OPERANDS && i == 6) >> - || (code == ASM_INPUT && i == 1)) >> - && locator_eq (XINT (x, i), XINT (y, i))) >> + || (code == ASM_INPUT && i == 1))) >> break; >> return 0; >> } >> Index: gcc/ifcvt.c >> =================================================================== >> --- gcc/ifcvt.c (revision 189835) >> +++ gcc/ifcvt.c (working copy) >> @@ -1019,7 +1019,7 @@ >> return FALSE; >> >> emit_insn_before_setloc (seq, if_info->jump, >> - INSN_LOCATOR (if_info->insn_a)); >> + INSN_LOCATION (if_info->insn_a)); >> } >> return TRUE; >> } >> @@ -1064,7 +1064,7 @@ >> return FALSE; >> >> emit_insn_before_setloc (seq, if_info->jump, >> - INSN_LOCATOR (if_info->insn_a)); >> + INSN_LOCATION (if_info->insn_a)); >> return TRUE; >> } >> else >> @@ -1195,7 +1195,7 @@ >> return FALSE; >> >> emit_insn_before_setloc (seq, if_info->jump, >> - INSN_LOCATOR (if_info->insn_a)); >> + INSN_LOCATION (if_info->insn_a)); >> return TRUE; >> } >> >> @@ -1243,7 +1243,7 @@ >> return FALSE; >> >> emit_insn_before_setloc (seq, if_info->jump, >> - INSN_LOCATOR (if_info->insn_a)); >> + INSN_LOCATION (if_info->insn_a)); >> return TRUE; >> } >> end_sequence (); >> @@ -1283,7 +1283,7 @@ >> return FALSE; >> >> emit_insn_before_setloc (seq, if_info->jump, >> - INSN_LOCATOR (if_info->insn_a)); >> + INSN_LOCATION (if_info->insn_a)); >> return TRUE; >> } >> end_sequence (); >> @@ -1332,7 +1332,7 @@ >> return FALSE; >> >> emit_insn_before_setloc (seq, if_info->jump, >> - INSN_LOCATOR (if_info->insn_a)); >> + INSN_LOCATION (if_info->insn_a)); >> return TRUE; >> } >> >> @@ -1481,7 +1481,7 @@ >> return FALSE; >> >> emit_insn_before_setloc (seq, if_info->jump, >> - INSN_LOCATOR (if_info->insn_a)); >> + INSN_LOCATION (if_info->insn_a)); >> return TRUE; >> } >> else >> @@ -1682,7 +1682,7 @@ >> if (!tmp) >> return FALSE; >> >> - emit_insn_before_setloc (tmp, if_info->jump, INSN_LOCATOR (if_info->insn_a)); >> + emit_insn_before_setloc (tmp, if_info->jump, INSN_LOCATION >> (if_info->insn_a)); >> return TRUE; >> >> end_seq_and_fail: >> @@ -1929,7 +1929,7 @@ >> if (!seq) >> return FALSE; >> >> - emit_insn_before_setloc (seq, if_info->jump, INSN_LOCATOR (if_info->insn_a)); >> + emit_insn_before_setloc (seq, if_info->jump, INSN_LOCATION >> (if_info->insn_a)); >> if_info->cond = cond; >> if_info->cond_earliest = earliest; >> >> @@ -2076,7 +2076,7 @@ >> if (!seq) >> return FALSE; >> >> - emit_insn_before_setloc (seq, if_info->jump, INSN_LOCATOR (if_info->insn_a)); >> + emit_insn_before_setloc (seq, if_info->jump, INSN_LOCATION >> (if_info->insn_a)); >> if_info->cond = cond; >> if_info->cond_earliest = earliest; >> >> @@ -2155,7 +2155,7 @@ >> if (!seq) >> return FALSE; >> >> - emit_insn_before_setloc (seq, if_info->jump, INSN_LOCATOR (if_info->insn_a)); >> + emit_insn_before_setloc (seq, if_info->jump, INSN_LOCATION >> (if_info->insn_a)); >> return TRUE; >> } >> >> @@ -2255,7 +2255,7 @@ >> return FALSE; >> >> emit_insn_before_setloc (seq, if_info->jump, >> - INSN_LOCATOR (if_info->insn_a)); >> + INSN_LOCATION (if_info->insn_a)); >> } >> return TRUE; >> } >> @@ -2656,7 +2656,7 @@ >> unshare_all_rtl_in_chain (seq); >> end_sequence (); >> >> - emit_insn_before_setloc (seq, BB_END (test_bb), INSN_LOCATOR (insn_a)); >> + emit_insn_before_setloc (seq, BB_END (test_bb), INSN_LOCATION (insn_a)); >> } >> >> /* The original THEN and ELSE blocks may now be removed. The test block >> @@ -2937,7 +2937,7 @@ >> loc_insn = first_active_insn (else_bb); >> gcc_assert (loc_insn); >> } >> - emit_insn_before_setloc (seq, jump, INSN_LOCATOR (loc_insn)); >> + emit_insn_before_setloc (seq, jump, INSN_LOCATION (loc_insn)); >> >> if (else_bb) >> { >> @@ -3655,7 +3655,7 @@ >> return FALSE; >> >> /* Emit the new insns before cond_earliest. */ >> - emit_insn_before_setloc (seq, cond_earliest, INSN_LOCATOR (trap)); >> + emit_insn_before_setloc (seq, cond_earliest, INSN_LOCATION (trap)); >> >> /* Delete the trap block if possible. */ >> remove_edge (trap_bb == then_bb ? then_edge : else_edge); >> Index: gcc/dwarf2out.c >> =================================================================== >> --- gcc/dwarf2out.c (revision 189835) >> +++ gcc/dwarf2out.c (working copy) >> @@ -15506,7 +15506,7 @@ >> { >> expanded_location s; >> >> - if (DECL_SOURCE_LOCATION (decl) == UNKNOWN_LOCATION) >> + if (IS_UNKNOWN_LOCATION (DECL_SOURCE_LOCATION (decl))) >> return; >> s = expand_location (DECL_SOURCE_LOCATION (decl)); >> add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file)); >> Index: gcc/expr.c >> =================================================================== >> --- gcc/expr.c (revision 189835) >> +++ gcc/expr.c (working copy) >> @@ -7802,19 +7802,14 @@ >> if (cfun && EXPR_HAS_LOCATION (exp)) >> { >> location_t saved_location = input_location; >> - location_t saved_curr_loc = get_curr_insn_source_location (); >> - tree saved_block = get_curr_insn_block (); >> + location_t saved_curr_loc = curr_insn_location (); >> input_location = EXPR_LOCATION (exp); >> - set_curr_insn_source_location (input_location); >> - >> - /* Record where the insns produced belong. */ >> - set_curr_insn_block (TREE_BLOCK (exp)); >> + set_curr_insn_location (input_location); >> >> ret = expand_expr_real_1 (exp, target, tmode, modifier, alt_rtl); >> >> input_location = saved_location; >> - set_curr_insn_block (saved_block); >> - set_curr_insn_source_location (saved_curr_loc); >> + set_curr_insn_location (saved_curr_loc); >> } >> else >> { >> Index: gcc/predict.c >> =================================================================== >> --- gcc/predict.c (revision 189835) >> +++ gcc/predict.c (working copy) >> @@ -2177,7 +2177,7 @@ >> { >> unsigned nb_loops; >> >> - loop_optimizer_init (0); >> + loop_optimizer_init (LOOPS_NORMAL); >> if (dump_file && (dump_flags & TDF_DETAILS)) >> flow_loops_dump (dump_file, NULL, 0); >> >> Index: gcc/tree-parloops.c >> =================================================================== >> --- gcc/tree-parloops.c (revision 189835) >> +++ gcc/tree-parloops.c (working copy) >> @@ -1415,6 +1415,7 @@ >> struct function *act_cfun = cfun; >> static unsigned loopfn_num; >> >> + loc = LOCATION_LOCUS (loc); >> snprintf (buf, 100, "%s.$loopfn", current_function_name ()); >> ASM_FORMAT_PRIVATE_NAME (tname, buf, loopfn_num++); >> clean_symbol_name (tname); >> Index: gcc/recog.c >> =================================================================== >> --- gcc/recog.c (revision 189835) >> +++ gcc/recog.c (working copy) >> @@ -3333,7 +3333,7 @@ >> /* Replace the old sequence with the new. */ >> last = emit_insn_after_setloc (attempt, >> peep2_insn_data[i].insn, >> - INSN_LOCATOR (peep2_insn_data[i].insn)); >> + INSN_LOCATION (peep2_insn_data[i].insn)); >> before_try = PREV_INSN (insn); >> delete_insn_chain (insn, peep2_insn_data[i].insn, false); >> >> Index: gcc/function.c >> =================================================================== >> --- gcc/function.c (revision 189835) >> +++ gcc/function.c (working copy) >> @@ -133,7 +133,7 @@ >> static void prepare_function_start (void); >> static void do_clobber_return_reg (rtx, void *); >> static void do_use_return_reg (rtx, void *); >> -static void set_insn_locators (rtx, int) ATTRIBUTE_UNUSED; >> +static void set_insn_locations (rtx, int) ATTRIBUTE_UNUSED; >> >> /* Stack of nested functions. */ >> /* Keep track of the cfun stack. */ >> @@ -200,7 +200,6 @@ >> f->cfg = NULL; >> >> regno_reg_rtx = NULL; >> - insn_locators_free (); >> } >> >> /* Return size needed for stack frame based on slots so far allocated. >> @@ -4979,7 +4978,7 @@ >> probe_stack_range (STACK_OLD_CHECK_PROTECT, max_frame_size); >> seq = get_insns (); >> end_sequence (); >> - set_insn_locators (seq, prologue_locator); >> + set_insn_locations (seq, prologue_location); >> emit_insn_before (seq, stack_check_probe_note); >> break; >> } >> @@ -4994,7 +4993,7 @@ >> >> /* Output a linenumber for the end of the function. >> SDB depends on this. */ >> - set_curr_insn_source_location (input_location); >> + set_curr_insn_location (input_location); >> >> /* Before the return label (if any), clobber the return >> registers so that they are not propagated live to the rest of >> @@ -5277,14 +5276,14 @@ >> *slot = copy; >> } >> >> -/* Set the locator of the insn chain starting at INSN to LOC. */ >> +/* Set the location of the insn chain starting at INSN to LOC. */ >> static void >> -set_insn_locators (rtx insn, int loc) >> +set_insn_locations (rtx insn, int loc) >> { >> while (insn != NULL_RTX) >> { >> if (INSN_P (insn)) >> - INSN_LOCATOR (insn) = loc; >> + INSN_LOCATION (insn) = loc; >> insn = NEXT_INSN (insn); >> } >> } >> @@ -5893,7 +5892,7 @@ >> end_sequence (); >> >> record_insns (split_prologue_seq, NULL, &prologue_insn_hash); >> - set_insn_locators (split_prologue_seq, prologue_locator); >> + set_insn_locations (split_prologue_seq, prologue_location); >> #endif >> } >> >> @@ -5922,7 +5921,7 @@ >> >> prologue_seq = get_insns (); >> end_sequence (); >> - set_insn_locators (prologue_seq, prologue_locator); >> + set_insn_locations (prologue_seq, prologue_location); >> } >> #endif >> >> @@ -6418,7 +6417,7 @@ >> >> /* Retain a map of the epilogue insns. */ >> record_insns (seq, NULL, &epilogue_insn_hash); >> - set_insn_locators (seq, epilogue_locator); >> + set_insn_locations (seq, epilogue_location); >> >> seq = get_insns (); >> returnjump = get_last_insn (); >> @@ -6608,7 +6607,7 @@ >> avoid getting rid of sibcall epilogue insns. Do this before we >> actually emit the sequence. */ >> record_insns (seq, NULL, &epilogue_insn_hash); >> - set_insn_locators (seq, epilogue_locator); >> + set_insn_locations (seq, epilogue_location); >> >> emit_insn_before (seq, insn); >> } >> Index: gcc/print-rtl.c >> =================================================================== >> --- gcc/print-rtl.c (revision 189835) >> +++ gcc/print-rtl.c (working copy) >> @@ -416,10 +416,10 @@ >> if (i == 5 && INSN_P (in_rtx)) >> { >> #ifndef GENERATOR_FILE >> - /* Pretty-print insn locators. Ignore scoping as it is mostly >> + /* Pretty-print insn locations. Ignore scoping as it is mostly >> redundant with line number information and do not print anything >> when there is no location information available. */ >> - if (INSN_LOCATOR (in_rtx) && insn_file (in_rtx)) >> + if (INSN_LOCATION (in_rtx) && insn_file (in_rtx)) >> fprintf(outfile, " %s:%i", insn_file (in_rtx), insn_line (in_rtx)); >> #endif >> } >> @@ -427,16 +427,16 @@ >> { >> #ifndef GENERATOR_FILE >> fprintf (outfile, " %s:%i", >> - locator_file (ASM_OPERANDS_SOURCE_LOCATION (in_rtx)), >> - locator_line (ASM_OPERANDS_SOURCE_LOCATION (in_rtx))); >> + LOCATION_FILE (ASM_OPERANDS_SOURCE_LOCATION (in_rtx)), >> + LOCATION_LINE (ASM_OPERANDS_SOURCE_LOCATION (in_rtx))); >> #endif >> } >> else if (i == 1 && GET_CODE (in_rtx) == ASM_INPUT) >> { >> #ifndef GENERATOR_FILE >> fprintf (outfile, " %s:%i", >> - locator_file (ASM_INPUT_SOURCE_LOCATION (in_rtx)), >> - locator_line (ASM_INPUT_SOURCE_LOCATION (in_rtx))); >> + LOCATION_FILE (ASM_INPUT_SOURCE_LOCATION (in_rtx)), >> + LOCATION_LINE (ASM_INPUT_SOURCE_LOCATION (in_rtx))); >> #endif >> } >> else if (i == 6 && NOTE_P (in_rtx)) >> Index: gcc/profile.c >> =================================================================== >> --- gcc/profile.c (revision 189835) >> +++ gcc/profile.c (working copy) >> @@ -966,7 +966,7 @@ >> is not computed twice. */ >> if (last >> && gimple_has_location (last) >> - && e->goto_locus != UNKNOWN_LOCATION >> + && !IS_UNKNOWN_LOCATION (e->goto_locus) >> && !single_succ_p (bb) >> && (LOCATION_FILE (e->goto_locus) >> != LOCATION_FILE (gimple_location (last)) >> @@ -976,7 +976,6 @@ >> basic_block new_bb = split_edge (e); >> edge ne = single_succ_edge (new_bb); >> ne->goto_locus = e->goto_locus; >> - ne->goto_block = e->goto_block; >> } >> if ((e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL)) >> && e->dest != EXIT_BLOCK_PTR) >> @@ -1188,7 +1187,7 @@ >> >> /* Notice GOTO expressions eliminated while constructing the CFG. */ >> if (single_succ_p (bb) >> - && single_succ_edge (bb)->goto_locus != UNKNOWN_LOCATION) >> + && !IS_UNKNOWN_LOCATION (single_succ_edge (bb)->goto_locus)) >> { >> expanded_location curr_location >> = expand_location (single_succ_edge (bb)->goto_locus); >> Index: gcc/trans-mem.c >> =================================================================== >> --- gcc/trans-mem.c (revision 189835) >> +++ gcc/trans-mem.c (working copy) >> @@ -3796,7 +3796,6 @@ >> { >> tree t = build1 (NOP_EXPR, void_type_node, size_zero_node); >> SET_EXPR_LOCATION (t, gimple_location (stmt)); >> - TREE_BLOCK (t) = gimple_block (stmt); >> error ("%Kasm not allowed in % function", t); >> } >> return true; >> Index: gcc/gimplify.c >> =================================================================== >> --- gcc/gimplify.c (revision 189835) >> +++ gcc/gimplify.c (working copy) >> @@ -2600,7 +2600,6 @@ >> = CALL_EXPR_RETURN_SLOT_OPT (call); >> CALL_FROM_THUNK_P (*expr_p) = CALL_FROM_THUNK_P (call); >> SET_EXPR_LOCATION (*expr_p, EXPR_LOCATION (call)); >> - TREE_BLOCK (*expr_p) = TREE_BLOCK (call); >> >> /* Set CALL_EXPR_VA_ARG_PACK. */ >> CALL_EXPR_VA_ARG_PACK (*expr_p) = 1; >> Index: gcc/except.c >> =================================================================== >> --- gcc/except.c (revision 189835) >> +++ gcc/except.c (working copy) >> @@ -526,7 +526,10 @@ >> break; >> >> case ERT_MUST_NOT_THROW: >> - new_r->u.must_not_throw = old_r->u.must_not_throw; >> + new_r->u.must_not_throw.failure_loc = >> + LOCATION_LOCUS (old_r->u.must_not_throw.failure_loc); >> + new_r->u.must_not_throw.failure_decl = >> + old_r->u.must_not_throw.failure_decl; >> break; >> } >> >> Index: gcc/emit-rtl.c >> =================================================================== >> --- gcc/emit-rtl.c (revision 189835) >> +++ gcc/emit-rtl.c (working copy) >> @@ -3634,7 +3634,7 @@ >> } >> } >> >> - tem = emit_insn_after_setloc (seq, trial, INSN_LOCATOR (trial)); >> + tem = emit_insn_after_setloc (seq, trial, INSN_LOCATION (trial)); >> >> delete_insn (trial); >> if (has_barrier) >> @@ -3670,7 +3670,7 @@ >> PATTERN (insn) = pattern; >> INSN_CODE (insn) = -1; >> REG_NOTES (insn) = NULL; >> - INSN_LOCATOR (insn) = curr_insn_locator (); >> + INSN_LOCATION (insn) = curr_insn_location (); >> BLOCK_FOR_INSN (insn) = NULL; >> >> #ifdef ENABLE_RTL_CHECKING >> @@ -3703,7 +3703,7 @@ >> PATTERN (insn) = pattern; >> INSN_CODE (insn) = -1; >> REG_NOTES (insn) = NULL; >> - INSN_LOCATOR (insn) = curr_insn_locator (); >> + INSN_LOCATION (insn) = curr_insn_location (); >> BLOCK_FOR_INSN (insn) = NULL; >> >> return insn; >> @@ -3723,7 +3723,7 @@ >> INSN_CODE (insn) = -1; >> REG_NOTES (insn) = NULL; >> JUMP_LABEL (insn) = NULL; >> - INSN_LOCATOR (insn) = curr_insn_locator (); >> + INSN_LOCATION (insn) = curr_insn_location (); >> BLOCK_FOR_INSN (insn) = NULL; >> >> return insn; >> @@ -3743,7 +3743,7 @@ >> INSN_CODE (insn) = -1; >> REG_NOTES (insn) = NULL; >> CALL_INSN_FUNCTION_USAGE (insn) = NULL; >> - INSN_LOCATOR (insn) = curr_insn_locator (); >> + INSN_LOCATION (insn) = curr_insn_location (); >> BLOCK_FOR_INSN (insn) = NULL; >> >> return insn; >> @@ -4416,8 +4416,8 @@ >> after = NEXT_INSN (after); >> while (1) >> { >> - if (active_insn_p (after) && !INSN_LOCATOR (after)) >> - INSN_LOCATOR (after) = loc; >> + if (active_insn_p (after) && !INSN_LOCATION (after)) >> + INSN_LOCATION (after) = loc; >> if (after == last) >> break; >> after = NEXT_INSN (after); >> @@ -4440,62 +4440,62 @@ >> prev = PREV_INSN (prev); >> >> if (INSN_P (prev)) >> - return emit_pattern_after_setloc (pattern, after, INSN_LOCATOR (prev), >> + return emit_pattern_after_setloc (pattern, after, INSN_LOCATION (prev), >> make_raw); >> else >> return emit_pattern_after_noloc (pattern, after, NULL, make_raw); >> } >> >> -/* Like emit_insn_after_noloc, but set INSN_LOCATOR according to LOC. */ >> +/* Like emit_insn_after_noloc, but set INSN_LOCATION according to LOC. */ >> rtx >> emit_insn_after_setloc (rtx pattern, rtx after, int loc) >> { >> return emit_pattern_after_setloc (pattern, after, loc, make_insn_raw); >> } >> >> -/* Like emit_insn_after_noloc, but set INSN_LOCATOR according to AFTER. */ >> +/* Like emit_insn_after_noloc, but set INSN_LOCATION according to AFTER. */ >> rtx >> emit_insn_after (rtx pattern, rtx after) >> { >> return emit_pattern_after (pattern, after, true, make_insn_raw); >> } >> >> -/* Like emit_jump_insn_after_noloc, but set INSN_LOCATOR according to LOC. */ >> +/* Like emit_jump_insn_after_noloc, but set INSN_LOCATION according to LOC. */ >> rtx >> emit_jump_insn_after_setloc (rtx pattern, rtx after, int loc) >> { >> return emit_pattern_after_setloc (pattern, after, loc, make_jump_insn_raw); >> } >> >> -/* Like emit_jump_insn_after_noloc, but set INSN_LOCATOR according to >> AFTER. */ >> +/* Like emit_jump_insn_after_noloc, but set INSN_LOCATION according >> to AFTER. */ >> rtx >> emit_jump_insn_after (rtx pattern, rtx after) >> { >> return emit_pattern_after (pattern, after, true, make_jump_insn_raw); >> } >> >> -/* Like emit_call_insn_after_noloc, but set INSN_LOCATOR according to LOC. */ >> +/* Like emit_call_insn_after_noloc, but set INSN_LOCATION according to LOC. */ >> rtx >> emit_call_insn_after_setloc (rtx pattern, rtx after, int loc) >> { >> return emit_pattern_after_setloc (pattern, after, loc, make_call_insn_raw); >> } >> >> -/* Like emit_call_insn_after_noloc, but set INSN_LOCATOR according to >> AFTER. */ >> +/* Like emit_call_insn_after_noloc, but set INSN_LOCATION according >> to AFTER. */ >> rtx >> emit_call_insn_after (rtx pattern, rtx after) >> { >> return emit_pattern_after (pattern, after, true, make_call_insn_raw); >> } >> >> -/* Like emit_debug_insn_after_noloc, but set INSN_LOCATOR according to LOC. */ >> +/* Like emit_debug_insn_after_noloc, but set INSN_LOCATION according >> to LOC. */ >> rtx >> emit_debug_insn_after_setloc (rtx pattern, rtx after, int loc) >> { >> return emit_pattern_after_setloc (pattern, after, loc, make_debug_insn_raw); >> } >> >> -/* Like emit_debug_insn_after_noloc, but set INSN_LOCATOR according >> to AFTER. */ >> +/* Like emit_debug_insn_after_noloc, but set INSN_LOCATION according >> to AFTER. */ >> rtx >> emit_debug_insn_after (rtx pattern, rtx after) >> { >> @@ -4525,8 +4525,8 @@ >> first = NEXT_INSN (first); >> while (1) >> { >> - if (active_insn_p (first) && !INSN_LOCATOR (first)) >> - INSN_LOCATOR (first) = loc; >> + if (active_insn_p (first) && !INSN_LOCATION (first)) >> + INSN_LOCATION (first) = loc; >> if (first == last) >> break; >> first = NEXT_INSN (first); >> @@ -4550,7 +4550,7 @@ >> next = PREV_INSN (next); >> >> if (INSN_P (next)) >> - return emit_pattern_before_setloc (pattern, before, INSN_LOCATOR (next), >> + return emit_pattern_before_setloc (pattern, before, INSN_LOCATION (next), >> insnp, make_raw); >> else >> return emit_pattern_before_noloc (pattern, before, >> @@ -4558,7 +4558,7 @@ >> NULL, make_raw); >> } >> >> -/* Like emit_insn_before_noloc, but set INSN_LOCATOR according to LOC. */ >> +/* Like emit_insn_before_noloc, but set INSN_LOCATION according to LOC. */ >> rtx >> emit_insn_before_setloc (rtx pattern, rtx before, int loc) >> { >> @@ -4566,14 +4566,14 @@ >> make_insn_raw); >> } >> >> -/* Like emit_insn_before_noloc, but set INSN_LOCATOR according to BEFORE. */ >> +/* Like emit_insn_before_noloc, but set INSN_LOCATION according to BEFORE. */ >> rtx >> emit_insn_before (rtx pattern, rtx before) >> { >> return emit_pattern_before (pattern, before, true, true, make_insn_raw); >> } >> >> -/* like emit_insn_before_noloc, but set INSN_LOCATOR according to LOC. */ >> +/* like emit_insn_before_noloc, but set INSN_LOCATION according to LOC. */ >> rtx >> emit_jump_insn_before_setloc (rtx pattern, rtx before, int loc) >> { >> @@ -4581,7 +4581,7 @@ >> make_jump_insn_raw); >> } >> >> -/* Like emit_jump_insn_before_noloc, but set INSN_LOCATOR according >> to BEFORE. */ >> +/* Like emit_jump_insn_before_noloc, but set INSN_LOCATION according >> to BEFORE. */ >> rtx >> emit_jump_insn_before (rtx pattern, rtx before) >> { >> @@ -4589,7 +4589,7 @@ >> make_jump_insn_raw); >> } >> >> -/* Like emit_insn_before_noloc, but set INSN_LOCATOR according to LOC. */ >> +/* Like emit_insn_before_noloc, but set INSN_LOCATION according to LOC. */ >> rtx >> emit_call_insn_before_setloc (rtx pattern, rtx before, int loc) >> { >> @@ -4598,7 +4598,7 @@ >> } >> >> /* Like emit_call_insn_before_noloc, >> - but set insn_locator according to BEFORE. */ >> + but set insn_location according to BEFORE. */ >> rtx >> emit_call_insn_before (rtx pattern, rtx before) >> { >> @@ -4606,7 +4606,7 @@ >> make_call_insn_raw); >> } >> >> -/* Like emit_insn_before_noloc, but set INSN_LOCATOR according to LOC. */ >> +/* Like emit_insn_before_noloc, but set INSN_LOCATION according to LOC. */ >> rtx >> emit_debug_insn_before_setloc (rtx pattern, rtx before, int loc) >> { >> @@ -4615,7 +4615,7 @@ >> } >> >> /* Like emit_debug_insn_before_noloc, >> - but set insn_locator according to BEFORE. */ >> + but set insn_location according to BEFORE. */ >> rtx >> emit_debug_insn_before (rtx pattern, rtx before) >> { >> @@ -5865,7 +5865,7 @@ >> /* Update LABEL_NUSES. */ >> mark_jump_label (PATTERN (new_rtx), new_rtx, 0); >> >> - INSN_LOCATOR (new_rtx) = INSN_LOCATOR (insn); >> + INSN_LOCATION (new_rtx) = INSN_LOCATION (insn); >> >> /* If the old insn is frame related, then so is the new one. This is >> primarily needed for IA-64 unwind info which marks epilogue insns, >> @@ -5900,250 +5900,66 @@ >> gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (mode, regno))); >> } >> >> -/* Data structures representing mapping of INSN_LOCATOR into scope blocks, line >> - numbers and files. In order to be GGC friendly we need to use separate >> - varrays. This also slightly improve the memory locality in binary search. >> - The _locs array contains locators where the given property change. The >> - block_locators_blocks contains the scope block that is used for all insn >> - locator greater than corresponding block_locators_locs value and smaller >> - than the following one. Similarly for the other properties. */ >> -static VEC(int,heap) *block_locators_locs; >> -static GTY(()) VEC(tree,gc) *block_locators_blocks; >> -static VEC(int,heap) *locations_locators_locs; >> -DEF_VEC_O(location_t); >> -DEF_VEC_ALLOC_O(location_t,heap); >> -static VEC(location_t,heap) *locations_locators_vals; >> -int prologue_locator; >> -int epilogue_locator; >> +location_t prologue_location; >> +location_t epilogue_location; >> >> /* Hold current location information and last location information, so the >> datastructures are built lazily only when some instructions in given >> place are needed. */ >> static location_t curr_location, last_location; >> -static tree curr_block, last_block; >> -static int curr_rtl_loc = -1; >> >> -/* Allocate insn locator datastructure. */ >> +/* Allocate insn location datastructure. */ >> void >> -insn_locators_alloc (void) >> +insn_locations_init (void) >> { >> - prologue_locator = epilogue_locator = 0; >> - >> - block_locators_locs = VEC_alloc (int, heap, 32); >> - block_locators_blocks = VEC_alloc (tree, gc, 32); >> - locations_locators_locs = VEC_alloc (int, heap, 32); >> - locations_locators_vals = VEC_alloc (location_t, heap, 32); >> - >> + prologue_location = epilogue_location = 0; >> curr_location = UNKNOWN_LOCATION; >> last_location = UNKNOWN_LOCATION; >> - curr_block = NULL; >> - last_block = NULL; >> - curr_rtl_loc = 0; >> } >> >> /* At the end of emit stage, clear current location. */ >> void >> -insn_locators_finalize (void) >> -{ >> - if (curr_rtl_loc >= 0) >> - epilogue_locator = curr_insn_locator (); >> - curr_rtl_loc = -1; >> -} >> - >> -/* Allocate insn locator datastructure. */ >> -void >> -insn_locators_free (void) >> +insn_locations_finalize (void) >> { >> - prologue_locator = epilogue_locator = 0; >> - >> - VEC_free (int, heap, block_locators_locs); >> - VEC_free (tree,gc, block_locators_blocks); >> - VEC_free (int, heap, locations_locators_locs); >> - VEC_free (location_t, heap, locations_locators_vals); >> + epilogue_location = curr_location; >> + curr_location = UNKNOWN_LOCATION; >> } >> >> /* Set current location. */ >> void >> -set_curr_insn_source_location (location_t location) >> +set_curr_insn_location (location_t location) >> { >> - /* IV opts calls into RTL expansion to compute costs of operations. At this >> - time locators are not initialized. */ >> - if (curr_rtl_loc == -1) >> - return; >> curr_location = location; >> } >> >> /* Get current location. */ >> location_t >> -get_curr_insn_source_location (void) >> +curr_insn_location (void) >> { >> return curr_location; >> } >> >> -/* Set current scope block. */ >> -void >> -set_curr_insn_block (tree b) >> -{ >> - /* IV opts calls into RTL expansion to compute costs of operations. At this >> - time locators are not initialized. */ >> - if (curr_rtl_loc == -1) >> - return; >> - if (b) >> - curr_block = b; >> -} >> - >> -/* Get current scope block. */ >> -tree >> -get_curr_insn_block (void) >> -{ >> - return curr_block; >> -} >> - >> -/* Return current insn locator. */ >> -int >> -curr_insn_locator (void) >> -{ >> - if (curr_rtl_loc == -1 || curr_location == UNKNOWN_LOCATION) >> - return 0; >> - if (last_block != curr_block) >> - { >> - curr_rtl_loc++; >> - VEC_safe_push (int, heap, block_locators_locs, curr_rtl_loc); >> - VEC_safe_push (tree, gc, block_locators_blocks, curr_block); >> - last_block = curr_block; >> - } >> - if (last_location != curr_location) >> - { >> - curr_rtl_loc++; >> - VEC_safe_push (int, heap, locations_locators_locs, curr_rtl_loc); >> - VEC_safe_push (location_t, heap, locations_locators_vals, >> &curr_location); >> - last_location = curr_location; >> - } >> - return curr_rtl_loc; >> -} >> - >> - >> -/* Return lexical scope block locator belongs to. */ >> -static tree >> -locator_scope (int loc) >> -{ >> - int max = VEC_length (int, block_locators_locs); >> - int min = 0; >> - >> - /* When block_locators_locs was initialized, the pro- and epilogue >> - insns didn't exist yet and can therefore not be found this way. >> - But we know that they belong to the outer most block of the >> - current function. >> - Without this test, the prologue would be put inside the block of >> - the first valid instruction in the function and when that first >> - insn is part of an inlined function then the low_pc of that >> - inlined function is messed up. Likewise for the epilogue and >> - the last valid instruction. */ >> - if (loc == prologue_locator || loc == epilogue_locator) >> - return DECL_INITIAL (cfun->decl); >> - >> - if (!max || !loc) >> - return NULL; >> - while (1) >> - { >> - int pos = (min + max) / 2; >> - int tmp = VEC_index (int, block_locators_locs, pos); >> - >> - if (tmp <= loc && min != pos) >> - min = pos; >> - else if (tmp > loc && max != pos) >> - max = pos; >> - else >> - { >> - min = pos; >> - break; >> - } >> - } >> - return VEC_index (tree, block_locators_blocks, min); >> -} >> - >> /* Return lexical scope block insn belongs to. */ >> tree >> insn_scope (const_rtx insn) >> { >> - return locator_scope (INSN_LOCATOR (insn)); >> -} >> - >> -/* Return line number of the statement specified by the locator. */ >> -location_t >> -locator_location (int loc) >> -{ >> - int max = VEC_length (int, locations_locators_locs); >> - int min = 0; >> - >> - while (1) >> - { >> - int pos = (min + max) / 2; >> - int tmp = VEC_index (int, locations_locators_locs, pos); >> - >> - if (tmp <= loc && min != pos) >> - min = pos; >> - else if (tmp > loc && max != pos) >> - max = pos; >> - else >> - { >> - min = pos; >> - break; >> - } >> - } >> - return *VEC_index (location_t, locations_locators_vals, min); >> -} >> - >> -/* Return source line of the statement that produced this insn. */ >> -int >> -locator_line (int loc) >> -{ >> - expanded_location xloc; >> - if (!loc) >> - return 0; >> - else >> - xloc = expand_location (locator_location (loc)); >> - return xloc.line; >> + return LOCATION_BLOCK (INSN_LOCATION (insn)); >> } >> >> /* Return line number of the statement that produced this insn. */ >> int >> insn_line (const_rtx insn) >> { >> - return locator_line (INSN_LOCATOR (insn)); >> -} >> - >> -/* Return source file of the statement specified by LOC. */ >> -const char * >> -locator_file (int loc) >> -{ >> - expanded_location xloc; >> - if (!loc) >> - return 0; >> - else >> - xloc = expand_location (locator_location (loc)); >> - return xloc.file; >> + return LOCATION_LINE (INSN_LOCATION (insn)); >> } >> >> /* Return source file of the statement that produced this insn. */ >> const char * >> insn_file (const_rtx insn) >> { >> - return locator_file (INSN_LOCATOR (insn)); >> + return LOCATION_FILE (INSN_LOCATION (insn)); >> } >> >> -/* Return true if LOC1 and LOC2 locators have the same location and scope. */ >> -bool >> -locator_eq (int loc1, int loc2) >> -{ >> - if (loc1 == loc2) >> - return true; >> - if (locator_location (loc1) != locator_location (loc2)) >> - return false; >> - return locator_scope (loc1) == locator_scope (loc2); >> -} >> - >> - >> /* Return true if memory model MODEL requires a pre-operation (release-style) >> barrier or a post-operation (acquire-style) barrier. While not universal, >> this function matches behavior of several targets. */ >> Index: gcc/cfgexpand.c >> =================================================================== >> --- gcc/cfgexpand.c (revision 189835) >> +++ gcc/cfgexpand.c (working copy) >> @@ -92,8 +92,7 @@ >> && gimple_location (stmt) != EXPR_LOCATION (t)) >> || (gimple_block (stmt) >> && currently_expanding_to_rtl >> - && EXPR_P (t) >> - && gimple_block (stmt) != TREE_BLOCK (t))) >> + && EXPR_P (t))) >> t = copy_node (t); >> } >> else >> @@ -101,8 +100,6 @@ >> >> if (gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (t)) >> SET_EXPR_LOCATION (t, gimple_location (stmt)); >> - if (gimple_block (stmt) && currently_expanding_to_rtl && EXPR_P (t)) >> - TREE_BLOCK (t) = gimple_block (stmt); >> >> return t; >> } >> @@ -1804,8 +1801,7 @@ >> last2 = last = get_last_insn (); >> >> extract_true_false_edges_from_block (bb, &true_edge, &false_edge); >> - set_curr_insn_source_location (gimple_location (stmt)); >> - set_curr_insn_block (gimple_block (stmt)); >> + set_curr_insn_location (gimple_location (stmt)); >> >> /* These flags have no purpose in RTL land. */ >> true_edge->flags &= ~EDGE_TRUE_VALUE; >> @@ -1818,13 +1814,8 @@ >> jumpif_1 (code, op0, op1, label_rtx_for_bb (true_edge->dest), >> true_edge->probability); >> maybe_dump_rtl_for_gimple_stmt (stmt, last); >> - if (true_edge->goto_locus) >> - { >> - set_curr_insn_source_location (true_edge->goto_locus); >> - set_curr_insn_block (true_edge->goto_block); >> - true_edge->goto_locus = curr_insn_locator (); >> - } >> - true_edge->goto_block = NULL; >> + if (!IS_UNKNOWN_LOCATION (true_edge->goto_locus)) >> + set_curr_insn_location (true_edge->goto_locus); >> false_edge->flags |= EDGE_FALLTHRU; >> maybe_cleanup_end_of_block (false_edge, last); >> return NULL; >> @@ -1834,13 +1825,8 @@ >> jumpifnot_1 (code, op0, op1, label_rtx_for_bb (false_edge->dest), >> false_edge->probability); >> maybe_dump_rtl_for_gimple_stmt (stmt, last); >> - if (false_edge->goto_locus) >> - { >> - set_curr_insn_source_location (false_edge->goto_locus); >> - set_curr_insn_block (false_edge->goto_block); >> - false_edge->goto_locus = curr_insn_locator (); >> - } >> - false_edge->goto_block = NULL; >> + if (!IS_UNKNOWN_LOCATION (false_edge->goto_locus)) >> + set_curr_insn_location (false_edge->goto_locus); >> true_edge->flags |= EDGE_FALLTHRU; >> maybe_cleanup_end_of_block (true_edge, last); >> return NULL; >> @@ -1849,13 +1835,8 @@ >> jumpif_1 (code, op0, op1, label_rtx_for_bb (true_edge->dest), >> true_edge->probability); >> last = get_last_insn (); >> - if (false_edge->goto_locus) >> - { >> - set_curr_insn_source_location (false_edge->goto_locus); >> - set_curr_insn_block (false_edge->goto_block); >> - false_edge->goto_locus = curr_insn_locator (); >> - } >> - false_edge->goto_block = NULL; >> + if (!IS_UNKNOWN_LOCATION (false_edge->goto_locus)) >> + set_curr_insn_location (false_edge->goto_locus); >> emit_jump (label_rtx_for_bb (false_edge->dest)); >> >> BB_END (bb) = last; >> @@ -1880,13 +1861,11 @@ >> >> maybe_dump_rtl_for_gimple_stmt (stmt, last2); >> >> - if (true_edge->goto_locus) >> + if (!IS_UNKNOWN_LOCATION (true_edge->goto_locus)) >> { >> - set_curr_insn_source_location (true_edge->goto_locus); >> - set_curr_insn_block (true_edge->goto_block); >> - true_edge->goto_locus = curr_insn_locator (); >> + set_curr_insn_location (true_edge->goto_locus); >> + true_edge->goto_locus = curr_insn_location (); >> } >> - true_edge->goto_block = NULL; >> >> return new_bb; >> } >> @@ -1986,7 +1965,6 @@ >> CALL_FROM_THUNK_P (exp) = gimple_call_from_thunk_p (stmt); >> CALL_EXPR_VA_ARG_PACK (exp) = gimple_call_va_arg_pack_p (stmt); >> SET_EXPR_LOCATION (exp, gimple_location (stmt)); >> - TREE_BLOCK (exp) = gimple_block (stmt); >> >> /* Ensure RTL is created for debug args. */ >> if (decl && DECL_HAS_DEBUG_ARGS_P (decl)) >> @@ -2021,8 +1999,7 @@ >> { >> tree op0; >> >> - set_curr_insn_source_location (gimple_location (stmt)); >> - set_curr_insn_block (gimple_block (stmt)); >> + set_curr_insn_location (gimple_location (stmt)); >> >> switch (gimple_code (stmt)) >> { >> @@ -3766,8 +3743,7 @@ >> tree op; >> gimple def; >> >> - location_t sloc = get_curr_insn_source_location (); >> - tree sblock = get_curr_insn_block (); >> + location_t sloc = curr_insn_location (); >> >> /* Look for SSA names that have their last use here (TERed >> names always have only one real use). */ >> @@ -3800,8 +3776,7 @@ >> rtx val; >> enum machine_mode mode; >> >> - set_curr_insn_source_location (gimple_location (def)); >> - set_curr_insn_block (gimple_block (def)); >> + set_curr_insn_location (gimple_location (def)); >> >> DECL_ARTIFICIAL (vexpr) = 1; >> TREE_TYPE (vexpr) = TREE_TYPE (value); >> @@ -3828,8 +3803,7 @@ >> } >> } >> } >> - set_curr_insn_source_location (sloc); >> - set_curr_insn_block (sblock); >> + set_curr_insn_location (sloc); >> } >> >> currently_expanding_gimple_stmt = stmt; >> @@ -3844,8 +3818,7 @@ >> } >> else if (gimple_debug_bind_p (stmt)) >> { >> - location_t sloc = get_curr_insn_source_location (); >> - tree sblock = get_curr_insn_block (); >> + location_t sloc = curr_insn_location (); >> gimple_stmt_iterator nsi = gsi; >> >> for (;;) >> @@ -3867,8 +3840,7 @@ >> >> last = get_last_insn (); >> >> - set_curr_insn_source_location (gimple_location (stmt)); >> - set_curr_insn_block (gimple_block (stmt)); >> + set_curr_insn_location (gimple_location (stmt)); >> >> if (DECL_P (var)) >> mode = DECL_MODE (var); >> @@ -3906,13 +3878,11 @@ >> break; >> } >> >> - set_curr_insn_source_location (sloc); >> - set_curr_insn_block (sblock); >> + set_curr_insn_location (sloc); >> } >> else if (gimple_debug_source_bind_p (stmt)) >> { >> - location_t sloc = get_curr_insn_source_location (); >> - tree sblock = get_curr_insn_block (); >> + location_t sloc = curr_insn_location (); >> tree var = gimple_debug_source_bind_get_var (stmt); >> tree value = gimple_debug_source_bind_get_value (stmt); >> rtx val; >> @@ -3920,8 +3890,7 @@ >> >> last = get_last_insn (); >> >> - set_curr_insn_source_location (gimple_location (stmt)); >> - set_curr_insn_block (gimple_block (stmt)); >> + set_curr_insn_location (gimple_location (stmt)); >> >> mode = DECL_MODE (var); >> >> @@ -3939,8 +3908,7 @@ >> PAT_VAR_LOCATION_LOC (val) = (rtx)value; >> } >> >> - set_curr_insn_source_location (sloc); >> - set_curr_insn_block (sblock); >> + set_curr_insn_location (sloc); >> } >> else >> { >> @@ -3981,13 +3949,8 @@ >> /* Expand implicit goto and convert goto_locus. */ >> FOR_EACH_EDGE (e, ei, bb->succs) >> { >> - if (e->goto_locus && e->goto_block) >> - { >> - set_curr_insn_source_location (e->goto_locus); >> - set_curr_insn_block (e->goto_block); >> - e->goto_locus = curr_insn_locator (); >> - } >> - e->goto_block = NULL; >> + if (!IS_UNKNOWN_LOCATION (e->goto_locus)) >> + set_curr_insn_location (e->goto_locus); >> if ((e->flags & EDGE_FALLTHRU) && e->dest != bb->next_bb) >> { >> emit_jump (label_rtx_for_bb (e->dest)); >> @@ -4107,12 +4070,9 @@ >> >> /* Make sure the locus is set to the end of the function, so that >> epilogue line numbers and warnings are set properly. */ >> - if (cfun->function_end_locus != UNKNOWN_LOCATION) >> + if (!IS_UNKNOWN_LOCATION (cfun->function_end_locus)) >> input_location = cfun->function_end_locus; >> >> - /* The following insns belong to the top scope. */ >> - set_curr_insn_block (DECL_INITIAL (current_function_decl)); >> - >> /* Generate rtl for function exit. */ >> expand_function_end (); >> >> @@ -4331,20 +4291,19 @@ >> >> rtl_profile_for_bb (ENTRY_BLOCK_PTR); >> >> - insn_locators_alloc (); >> + insn_locations_init (); >> if (!DECL_IS_BUILTIN (current_function_decl)) >> { >> /* Eventually, all FEs should explicitly set function_start_locus. */ >> - if (cfun->function_start_locus == UNKNOWN_LOCATION) >> - set_curr_insn_source_location >> + if (IS_UNKNOWN_LOCATION (cfun->function_start_locus)) >> + set_curr_insn_location >> (DECL_SOURCE_LOCATION (current_function_decl)); >> else >> - set_curr_insn_source_location (cfun->function_start_locus); >> + set_curr_insn_location (cfun->function_start_locus); >> } >> else >> - set_curr_insn_source_location (UNKNOWN_LOCATION); >> - set_curr_insn_block (DECL_INITIAL (current_function_decl)); >> - prologue_locator = curr_insn_locator (); >> + set_curr_insn_location (UNKNOWN_LOCATION); >> + prologue_location = curr_insn_location (); >> >> #ifdef INSN_SCHEDULING >> init_sched_attrs (); >> @@ -4514,8 +4473,7 @@ >> free_histograms (); >> >> construct_exit_block (); >> - set_curr_insn_block (DECL_INITIAL (current_function_decl)); >> - insn_locators_finalize (); >> + insn_locations_finalize (); >> >> /* Zap the tree EH table. */ >> set_eh_throw_stmt_table (cfun, NULL); >> Index: gcc/cfgcleanup.c >> =================================================================== >> --- gcc/cfgcleanup.c (revision 189835) >> +++ gcc/cfgcleanup.c (working copy) >> @@ -481,13 +481,15 @@ >> int new_locus = single_succ_edge (target)->goto_locus; >> int locus = goto_locus; >> >> - if (new_locus && locus && !locator_eq (new_locus, locus)) >> + if (!IS_UNKNOWN_LOCATION (new_locus) >> + && !IS_UNKNOWN_LOCATION (locus) >> + && new_locus != locus) >> new_target = NULL; >> else >> { >> rtx last; >> >> - if (new_locus) >> + if (!IS_UNKNOWN_LOCATION (new_locus)) >> locus = new_locus; >> >> last = BB_END (target); >> @@ -495,13 +497,15 @@ >> last = prev_nondebug_insn (last); >> >> new_locus = last && INSN_P (last) >> - ? INSN_LOCATOR (last) : 0; >> + ? INSN_LOCATION (last) : 0; >> >> - if (new_locus && locus && !locator_eq (new_locus, locus)) >> + if (!IS_UNKNOWN_LOCATION (new_locus) >> + && !IS_UNKNOWN_LOCATION (locus) >> + && new_locus != locus) >> new_target = NULL; >> else >> { >> - if (new_locus) >> + if (!IS_UNKNOWN_LOCATION (new_locus)) >> locus = new_locus; >> >> goto_locus = locus; >> Index: gcc/tree-ssa-live.c >> =================================================================== >> --- gcc/tree-ssa-live.c (revision 189835) >> +++ gcc/tree-ssa-live.c (working copy) >> @@ -587,7 +587,7 @@ >> else >> /* Verfify that only blocks with source location set >> are entry points to the inlined functions. */ >> - gcc_assert (BLOCK_SOURCE_LOCATION (scope) == UNKNOWN_LOCATION); >> + gcc_assert (IS_UNKNOWN_LOCATION (BLOCK_SOURCE_LOCATION (scope))); >> >> TREE_USED (scope) = !unused; >> return unused; >> @@ -615,7 +615,7 @@ >> fprintf (file, "\n%*s{ Scope block #%i%s%s",indent, "" , >> BLOCK_NUMBER (scope), >> TREE_USED (scope) ? "" : " (unused)", >> BLOCK_ABSTRACT (scope) ? " (abstract)": ""); >> - if (BLOCK_SOURCE_LOCATION (scope) != UNKNOWN_LOCATION) >> + if (!IS_UNKNOWN_LOCATION (BLOCK_SOURCE_LOCATION (scope))) >> { >> expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (scope)); >> fprintf (file, " %s:%i", s.file, s.line); >> @@ -765,13 +765,18 @@ >> FOR_EACH_PHI_ARG (arg_p, phi, i, SSA_OP_ALL_USES) >> { >> tree arg = USE_FROM_PTR (arg_p); >> + int index = PHI_ARG_INDEX_FROM_USE (arg_p); >> + tree block = >> + LOCATION_BLOCK (gimple_phi_arg_location (phi, index)); >> + if (block != NULL) >> + TREE_USED (block) = true; >> mark_all_vars_used (&arg, global_unused_vars); >> } >> } >> >> FOR_EACH_EDGE (e, ei, bb->succs) >> if (e->goto_locus) >> - TREE_USED (e->goto_block) = true; >> + TREE_USED (LOCATION_BLOCK (e->goto_locus)) = true; >> } >> >> /* We do a two-pass approach about the out-of-scope clobbers. We want >> Index: gcc/lto/lto.c >> =================================================================== >> --- gcc/lto/lto.c (revision 189835) >> +++ gcc/lto/lto.c (working copy) >> @@ -1603,7 +1603,6 @@ >> else if (EXPR_P (t)) >> { >> int i; >> - LTO_NO_PREVAIL (t->exp.block); >> for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i) >> LTO_SET_PREVAIL (TREE_OPERAND (t, i)); >> } >> Index: gcc/rtl.c >> =================================================================== >> --- gcc/rtl.c (revision 189835) >> +++ gcc/rtl.c (working copy) >> @@ -440,7 +440,7 @@ >> #ifndef GENERATOR_FILE >> if (((code == ASM_OPERANDS && i == 6) >> || (code == ASM_INPUT && i == 1)) >> - && locator_eq (XINT (x, i), XINT (y, i))) >> + && XINT (x, i) == XINT (y, i)) >> break; >> #endif >> return 0; >> @@ -579,7 +579,7 @@ >> #ifndef GENERATOR_FILE >> if (((code == ASM_OPERANDS && i == 6) >> || (code == ASM_INPUT && i == 1)) >> - && locator_eq (XINT (x, i), XINT (y, i))) >> + && XINT (x, i) == XINT (y, i)) >> break; >> #endif >> return 0; >> Index: gcc/rtl.h >> =================================================================== >> --- gcc/rtl.h (revision 189835) >> +++ gcc/rtl.h (working copy) >> @@ -739,6 +739,7 @@ >> #endif >> >> #define XINT(RTX, N) (RTL_CHECK2 (RTX, N, 'i', 'n').rt_int) >> +#define XUINT(RTX, N) (RTL_CHECK2 (RTX, N, 'i', 'n').rt_uint) >> #define XSTR(RTX, N) (RTL_CHECK2 (RTX, N, 's', 'S').rt_str) >> #define XEXP(RTX, N) (RTL_CHECK2 (RTX, N, 'e', 'u').rt_rtx) >> #define XVEC(RTX, N) (RTL_CHECK2 (RTX, N, 'E', 'V').rt_rtvec) >> @@ -802,13 +803,13 @@ >> /* The body of an insn. */ >> #define PATTERN(INSN) XEXP (INSN, 4) >> >> -#define INSN_LOCATOR(INSN) XINT (INSN, 5) >> +#define INSN_LOCATION(INSN) XUINT (INSN, 5) >> + >> +#define INSN_HAS_LOCATION(INSN) (!IS_UNKNOWN_LOCATION (INSN_LOCATION (INSN))) >> + >> /* LOCATION of an RTX if relevant. */ >> #define RTL_LOCATION(X) (INSN_P (X) ? \ >> - locator_location (INSN_LOCATOR (X)) \ >> - : UNKNOWN_LOCATION) >> -/* LOCATION of current INSN. */ >> -#define CURR_INSN_LOCATION (locator_location (curr_insn_locator ())) >> + INSN_LOCATION (X) : UNKNOWN_LOCATION) >> >> /* Code number of instruction, from when it was recognized. >> -1 means this instruction has not been recognized yet. */ >> @@ -1807,12 +1808,8 @@ >> /* In emit-rtl.c */ >> extern int insn_line (const_rtx); >> extern const char * insn_file (const_rtx); >> -extern location_t locator_location (int); >> -extern int locator_line (int); >> -extern const char * locator_file (int); >> -extern bool locator_eq (int, int); >> -extern int prologue_locator, epilogue_locator; >> extern tree insn_scope (const_rtx); >> +extern location_t prologue_location, epilogue_location; >> >> /* In jump.c */ >> extern enum rtx_code reverse_condition (enum rtx_code); >> @@ -2648,14 +2645,10 @@ >> /* Keep this for the nonce. */ >> #define gen_lowpart rtl_hooks.gen_lowpart >> >> -extern void insn_locators_alloc (void); >> -extern void insn_locators_free (void); >> -extern void insn_locators_finalize (void); >> -extern void set_curr_insn_source_location (location_t); >> -extern location_t get_curr_insn_source_location (void); >> -extern void set_curr_insn_block (tree); >> -extern tree get_curr_insn_block (void); >> -extern int curr_insn_locator (void); >> +extern void insn_locations_init (void); >> +extern void insn_locations_finalize (void); >> +extern void set_curr_insn_location (location_t); >> +extern location_t curr_insn_location (void); >> extern bool optimize_insn_for_size_p (void); >> extern bool optimize_insn_for_speed_p (void); >> >> Index: gcc/tree-inline.c >> =================================================================== >> --- gcc/tree-inline.c (revision 189835) >> +++ gcc/tree-inline.c (working copy) >> @@ -852,10 +852,6 @@ >> /* Otherwise, just copy the node. Note that copy_tree_r already >> knows not to copy VAR_DECLs, etc., so this is safe. */ >> >> - /* We should never have TREE_BLOCK set on non-statements. */ >> - if (EXPR_P (*tp)) >> - gcc_assert (!TREE_BLOCK (*tp)); >> - >> if (TREE_CODE (*tp) == MEM_REF) >> { >> tree ptr = TREE_OPERAND (*tp, 0); >> @@ -901,13 +897,9 @@ >> { >> /* Variable substitution need not be simple. In particular, >> the MEM_REF substitution above. Make sure that >> - TREE_CONSTANT and friends are up-to-date. But make sure >> - to not improperly set TREE_BLOCK on some sub-expressions. */ >> + TREE_CONSTANT and friends are up-to-date. */ >> int invariant = is_gimple_min_invariant (*tp); >> - tree block = id->block; >> - id->block = NULL_TREE; >> walk_tree (&TREE_OPERAND (*tp, 0), remap_gimple_op_r, data, NULL); >> - id->block = block; >> recompute_tree_invariant_for_addr_expr (*tp); >> >> /* If this used to be invariant, but is not any longer, >> @@ -919,6 +911,22 @@ >> } >> } >> >> + /* Update the TREE_BLOCK for the cloned expr. */ >> + if (EXPR_P (*tp)) >> + { >> + tree new_block = id->remapping_type_depth == 0 ? id->block : NULL; >> + tree old_block = TREE_BLOCK (*tp); >> + if (old_block) >> + { >> + tree *n; >> + n = (tree *) pointer_map_contains (id->decl_map, >> + TREE_BLOCK (*tp)); >> + if (n) >> + new_block = *n; >> + } >> + TREE_SET_BLOCK (*tp, new_block); >> + } >> + >> /* Keep iterating. */ >> return NULL_TREE; >> } >> @@ -1144,11 +1152,10 @@ >> tree *n; >> n = (tree *) pointer_map_contains (id->decl_map, >> TREE_BLOCK (*tp)); >> - gcc_assert (n || id->remapping_type_depth != 0); >> if (n) >> new_block = *n; >> } >> - TREE_BLOCK (*tp) = new_block; >> + TREE_SET_BLOCK (*tp, new_block); >> } >> >> if (TREE_CODE (*tp) != OMP_CLAUSE) >> @@ -2020,6 +2027,7 @@ >> tree new_arg; >> tree block = id->block; >> edge_iterator ei2; >> + location_t locus; >> >> /* When doing partial cloning, we allow PHIs on the entry block >> as long as all the arguments are the same. Find any input >> @@ -2031,9 +2039,7 @@ >> >> arg = PHI_ARG_DEF_FROM_EDGE (phi, old_edge); >> new_arg = arg; >> - id->block = NULL_TREE; >> walk_tree (&new_arg, copy_tree_body_r, id, NULL); >> - id->block = block; >> gcc_assert (new_arg); >> /* With return slot optimization we can end up with >> non-gimple (foo *)&this->m, fix that here. */ >> @@ -2046,8 +2052,19 @@ >> gsi_insert_seq_on_edge (new_edge, stmts); >> inserted = true; >> } >> + locus = gimple_phi_arg_location_from_edge (phi, old_edge); >> + block = id->block; >> + if (LOCATION_BLOCK (locus)) >> + { >> + tree *n; >> + n = (tree *) pointer_map_contains (id->decl_map, >> + LOCATION_BLOCK (locus)); >> + gcc_assert (n); >> + block = *n; >> + } >> + >> add_phi_arg (new_phi, new_arg, new_edge, >> - gimple_phi_arg_location_from_edge (phi, old_edge)); >> + COMBINE_LOCATION (locus, block)); >> } >> } >> } >> @@ -3946,7 +3963,8 @@ >> id->block = make_node (BLOCK); >> BLOCK_ABSTRACT_ORIGIN (id->block) = fn; >> BLOCK_SOURCE_LOCATION (id->block) = input_location; >> - prepend_lexical_block (gimple_block (stmt), id->block); >> + if (gimple_block (stmt)) >> + prepend_lexical_block (gimple_block (stmt), id->block); >> >> /* Local declarations will be replaced by their equivalents in this >> map. */ >> Index: gcc/tree-streamer-in.c >> =================================================================== >> --- gcc/tree-streamer-in.c (revision 189835) >> +++ gcc/tree-streamer-in.c (working copy) >> @@ -776,7 +776,7 @@ >> >> loc = lto_input_location (ib, data_in); >> SET_EXPR_LOCATION (expr, loc); >> - TREE_BLOCK (expr) = stream_read_tree (ib, data_in); >> + TREE_SET_BLOCK (expr, stream_read_tree (ib, data_in)); >> } >> >> >> Index: gcc/combine.c >> =================================================================== >> --- gcc/combine.c (revision 189835) >> +++ gcc/combine.c (working copy) >> @@ -2896,7 +2896,7 @@ >> >> i1 = gen_rtx_INSN (VOIDmode, INSN_UID (i2), NULL_RTX, i2, >> BLOCK_FOR_INSN (i2), XVECEXP (PATTERN (i2), 0, 1), >> - INSN_LOCATOR (i2), -1, NULL_RTX); >> + INSN_LOCATION (i2), -1, NULL_RTX); >> >> SUBST (PATTERN (i2), XVECEXP (PATTERN (i2), 0, 0)); >> SUBST (XEXP (SET_SRC (PATTERN (i2)), 0), >> Index: gcc/tree-outof-ssa.c >> =================================================================== >> --- gcc/tree-outof-ssa.c (revision 189835) >> +++ gcc/tree-outof-ssa.c (working copy) >> @@ -108,8 +108,7 @@ >> { >> if (e->goto_locus) >> { >> - set_curr_insn_source_location (e->goto_locus); >> - set_curr_insn_block (e->goto_block); >> + set_curr_insn_location (e->goto_locus); >> } >> else >> { >> @@ -125,8 +124,7 @@ >> continue; >> if (gimple_has_location (stmt) || gimple_block (stmt)) >> { >> - set_curr_insn_source_location (gimple_location (stmt)); >> - set_curr_insn_block (gimple_block (stmt)); >> + set_curr_insn_location (gimple_location (stmt)); >> return; >> } >> } >> @@ -191,7 +189,7 @@ >> set_location_for_edge (e); >> /* If a locus is provided, override the default. */ >> if (locus) >> - set_curr_insn_source_location (locus); >> + set_curr_insn_location (locus); >> >> var = partition_to_var (SA.map, src); >> seq = emit_partition_copy (SA.partition_to_pseudo[dest], >> @@ -228,7 +226,7 @@ >> set_location_for_edge (e); >> /* If a locus is provided, override the default. */ >> if (locus) >> - set_curr_insn_source_location (locus); >> + set_curr_insn_location (locus); >> >> start_sequence (); >> >> @@ -284,7 +282,7 @@ >> set_location_for_edge (e); >> /* If a locus is provided, override the default. */ >> if (locus) >> - set_curr_insn_source_location (locus); >> + set_curr_insn_location (locus); >> >> /* We give the destination as sizeexp in case src/dest are BLKmode >> mems. Usually we give the source. As we result from SSA names >> @@ -320,7 +318,7 @@ >> set_location_for_edge (e); >> /* If a locus is provided, override the default. */ >> if (locus) >> - set_curr_insn_source_location (locus); >> + set_curr_insn_location (locus); >> >> var = partition_to_var (SA.map, src); >> seq = emit_partition_copy (dest, >> Index: gcc/basic-block.h >> =================================================================== >> --- gcc/basic-block.h (revision 189835) >> +++ gcc/basic-block.h (working copy) >> @@ -47,8 +47,7 @@ >> /* Auxiliary info specific to a pass. */ >> PTR GTY ((skip (""))) aux; >> >> - /* Location of any goto implicit in the edge and associated BLOCK. */ >> - tree goto_block; >> + /* Location of any goto implicit in the edge. */ >> location_t goto_locus; >> >> /* The index number corresponding to this edge in the edge vector >> Index: gcc/gimple.h >> =================================================================== >> --- gcc/gimple.h (revision 189835) >> +++ gcc/gimple.h (working copy) >> @@ -210,10 +210,6 @@ >> and the prev pointer being the last. */ >> gimple next; >> gimple GTY((skip)) prev; >> - >> - /* [ WORD 6 ] >> - Lexical block holding this statement. */ >> - tree block; >> }; >> >> >> @@ -1198,7 +1194,7 @@ >> static inline tree >> gimple_block (const_gimple g) >> { >> - return g->gsbase.block; >> + return LOCATION_BLOCK (g->gsbase.location); >> } >> >> >> @@ -1207,7 +1203,7 @@ >> static inline void >> gimple_set_block (gimple g, tree block) >> { >> - g->gsbase.block = block; >> + g->gsbase.location = COMBINE_LOCATION (g->gsbase.location, block); >> } >> >> >> @@ -1242,7 +1238,7 @@ >> static inline bool >> gimple_has_location (const_gimple g) >> { >> - return gimple_location (g) != UNKNOWN_LOCATION; >> + return !IS_UNKNOWN_LOCATION (gimple_location (g)); >> } >> >> >> Index: gcc/tree-cfg.c >> =================================================================== >> --- gcc/tree-cfg.c (revision 189835) >> +++ gcc/tree-cfg.c (working copy) >> @@ -808,15 +808,11 @@ >> e = make_edge (bb, then_bb, EDGE_TRUE_VALUE); >> assign_discriminator (entry_locus, then_bb); >> e->goto_locus = gimple_location (then_stmt); >> - if (e->goto_locus) >> - e->goto_block = gimple_block (then_stmt); >> e = make_edge (bb, else_bb, EDGE_FALSE_VALUE); >> if (e) >> { >> assign_discriminator (entry_locus, else_bb); >> e->goto_locus = gimple_location (else_stmt); >> - if (e->goto_locus) >> - e->goto_block = gimple_block (else_stmt); >> } >> >> /* We do not need the labels anymore. */ >> @@ -1026,8 +1022,6 @@ >> edge e = make_edge (bb, label_bb, EDGE_FALLTHRU); >> e->goto_locus = gimple_location (goto_t); >> assign_discriminator (e->goto_locus, label_bb); >> - if (e->goto_locus) >> - e->goto_block = gimple_block (goto_t); >> gsi_remove (&last, true); >> return; >> } >> @@ -1501,7 +1495,7 @@ >> >> /* When not optimizing, don't merge if we'd lose goto_locus. */ >> if (!optimize >> - && single_succ_edge (a)->goto_locus != UNKNOWN_LOCATION) >> + && single_succ_edge (a)->goto_locus) >> { >> location_t goto_locus = single_succ_edge (a)->goto_locus; >> gimple_stmt_iterator prev, next; >> @@ -5987,9 +5981,7 @@ >> tree t = *tp; >> >> if (EXPR_P (t)) >> - /* We should never have TREE_BLOCK set on non-statements. */ >> - gcc_assert (!TREE_BLOCK (t)); >> - >> + ; >> else if (DECL_P (t) || TREE_CODE (t) == SSA_NAME) >> { >> if (TREE_CODE (t) == SSA_NAME) >> @@ -6294,12 +6286,12 @@ >> } >> >> FOR_EACH_EDGE (e, ei, bb->succs) >> - if (e->goto_locus) >> + if (!IS_UNKNOWN_LOCATION (e->goto_locus)) >> { >> - tree block = e->goto_block; >> + tree block = LOCATION_BLOCK (e->goto_locus); >> if (d->orig_block == NULL_TREE >> || block == d->orig_block) >> - e->goto_block = d->new_block; >> + e->goto_locus = COMBINE_LOCATION (e->goto_locus, d->new_block); >> #ifdef ENABLE_CHECKING >> else if (block != d->new_block) >> { >> Index: gcc/config/alpha/alpha.c >> =================================================================== >> --- gcc/config/alpha/alpha.c (revision 189835) >> +++ gcc/config/alpha/alpha.c (working copy) >> @@ -8352,7 +8352,6 @@ >> instruction scheduling worth while. Note that use_thunk calls >> assemble_start_function and assemble_end_function. */ >> insn = get_insns (); >> - insn_locators_alloc (); >> shorten_branches (insn); >> final_start_function (insn, file, 1); >> final (insn, file, 1); >> Index: gcc/config/sparc/sparc.c >> =================================================================== >> --- gcc/config/sparc/sparc.c (revision 189835) >> +++ gcc/config/sparc/sparc.c (working copy) >> @@ -10654,7 +10654,6 @@ >> instruction scheduling worth while. Note that use_thunk calls >> assemble_start_function and assemble_end_function. */ >> insn = get_insns (); >> - insn_locators_alloc (); >> shorten_branches (insn); >> final_start_function (insn, file, 1); >> final (insn, file, 1); >> Index: gcc/config/i386/i386.c >> =================================================================== >> --- gcc/config/i386/i386.c (revision 189835) >> +++ gcc/config/i386/i386.c (working copy) >> @@ -33063,7 +33063,6 @@ >> /* Emit just enough of rest_of_compilation to get the insns emitted. >> Note that use_thunk calls assemble_start_function et al. */ >> tmp = get_insns (); >> - insn_locators_alloc (); >> shorten_branches (tmp); >> final_start_function (tmp, file, 1); >> final (tmp, file, 1); >> Index: gcc/config/tilegx/tilegx.c >> =================================================================== >> --- gcc/config/tilegx/tilegx.c (revision 189835) >> +++ gcc/config/tilegx/tilegx.c (working copy) >> @@ -4804,7 +4804,6 @@ >> serial except for the tail call, so we're only wasting one cycle. >> */ >> insn = get_insns (); >> - insn_locators_alloc (); >> shorten_branches (insn); >> final_start_function (insn, file, 1); >> final (insn, file, 1); >> Index: gcc/config/sh/sh.c >> =================================================================== >> --- gcc/config/sh/sh.c (revision 189835) >> +++ gcc/config/sh/sh.c (working copy) >> @@ -11979,7 +11979,6 @@ >> the insns emitted. Note that use_thunk calls >> assemble_start_function and assemble_end_function. */ >> >> - insn_locators_alloc (); >> insns = get_insns (); >> >> if (optimize > 0) >> Index: gcc/config/ia64/ia64.c >> =================================================================== >> --- gcc/config/ia64/ia64.c (revision 189835) >> +++ gcc/config/ia64/ia64.c (working copy) >> @@ -10848,7 +10848,6 @@ >> instruction scheduling worth while. Note that use_thunk calls >> assemble_start_function and assemble_end_function. */ >> >> - insn_locators_alloc (); >> emit_all_insn_group_barriers (NULL); >> insn = get_insns (); >> shorten_branches (insn); >> Index: gcc/config/rs6000/rs6000.c >> =================================================================== >> --- gcc/config/rs6000/rs6000.c (revision 189835) >> +++ gcc/config/rs6000/rs6000.c (working copy) >> @@ -21664,7 +21664,6 @@ >> instruction scheduling worth while. Note that use_thunk calls >> assemble_start_function and assemble_end_function. */ >> insn = get_insns (); >> - insn_locators_alloc (); >> shorten_branches (insn); >> final_start_function (insn, file, 1); >> final (insn, file, 1); >> Index: gcc/config/score/score.c >> =================================================================== >> --- gcc/config/score/score.c (revision 189835) >> +++ gcc/config/score/score.c (working copy) >> @@ -505,7 +505,6 @@ >> /* Run just enough of rest_of_compilation. This sequence was >> "borrowed" from alpha.c. */ >> insn = get_insns (); >> - insn_locators_alloc (); >> split_all_insns_noflow (); >> shorten_branches (insn); >> final_start_function (insn, file, 1); >> Index: gcc/config/tilepro/tilepro.c >> =================================================================== >> --- gcc/config/tilepro/tilepro.c (revision 189835) >> +++ gcc/config/tilepro/tilepro.c (working copy) >> @@ -4407,7 +4407,6 @@ >> serial except for the tail call, so we're only wasting one cycle. >> */ >> insn = get_insns (); >> - insn_locators_alloc (); >> shorten_branches (insn); >> final_start_function (insn, file, 1); >> final (insn, file, 1); >> Index: gcc/config/mips/mips.c >> =================================================================== >> --- gcc/config/mips/mips.c (revision 189835) >> +++ gcc/config/mips/mips.c (working copy) >> @@ -15637,7 +15637,6 @@ >> /* Run just enough of rest_of_compilation. This sequence was >> "borrowed" from alpha.c. */ >> insn = get_insns (); >> - insn_locators_alloc (); >> split_all_insns_noflow (); >> mips16_lay_out_constants (); >> shorten_branches (insn); >> Index: gcc/cfgrtl.c >> =================================================================== >> --- gcc/cfgrtl.c (revision 189835) >> +++ gcc/cfgrtl.c (working copy) >> @@ -720,19 +720,19 @@ >> static bool >> unique_locus_on_edge_between_p (basic_block a, basic_block b) >> { >> - const int goto_locus = EDGE_SUCC (a, 0)->goto_locus; >> + const location_t goto_locus = EDGE_SUCC (a, 0)->goto_locus; >> rtx insn, end; >> >> - if (!goto_locus) >> + if (IS_UNKNOWN_LOCATION (goto_locus)) >> return false; >> >> /* First scan block A backward. */ >> insn = BB_END (a); >> end = PREV_INSN (BB_HEAD (a)); >> - while (insn != end && (!NONDEBUG_INSN_P (insn) || INSN_LOCATOR (insn) == 0)) >> + while (insn != end && (!NONDEBUG_INSN_P (insn) || !INSN_HAS_LOCATION (insn))) >> insn = PREV_INSN (insn); >> >> - if (insn != end && locator_eq (INSN_LOCATOR (insn), goto_locus)) >> + if (insn != end && INSN_LOCATION (insn) == goto_locus) >> return false; >> >> /* Then scan block B forward. */ >> @@ -743,8 +743,8 @@ >> while (insn != end && !NONDEBUG_INSN_P (insn)) >> insn = NEXT_INSN (insn); >> >> - if (insn != end && INSN_LOCATOR (insn) != 0 >> - && locator_eq (INSN_LOCATOR (insn), goto_locus)) >> + if (insn != end && INSN_HAS_LOCATION (insn) >> + && INSN_LOCATION (insn) == goto_locus) >> return false; >> } >> >> @@ -761,7 +761,7 @@ >> return; >> >> BB_END (a) = emit_insn_after_noloc (gen_nop (), BB_END (a), a); >> - INSN_LOCATOR (BB_END (a)) = EDGE_SUCC (a, 0)->goto_locus; >> + INSN_LOCATION (BB_END (a)) = EDGE_SUCC (a, 0)->goto_locus; >> } >> >> /* Blocks A and B are to be merged into a single block A. The insns >> @@ -1478,7 +1478,7 @@ >> else >> jump_block = e->src; >> >> - if (e->goto_locus && e->goto_block == NULL) >> + if (!IS_UNKNOWN_LOCATION (e->goto_locus)) >> loc = e->goto_locus; >> else >> loc = 0; >> @@ -3337,7 +3337,8 @@ >> edge_iterator ei; >> >> FOR_EACH_EDGE (e, ei, bb->succs) >> - if (e->goto_locus && !(e->flags & EDGE_ABNORMAL)) >> + if (!IS_UNKNOWN_LOCATION (e->goto_locus) >> + && !(e->flags & EDGE_ABNORMAL)) >> { >> edge e2; >> edge_iterator ei2; >> @@ -3347,15 +3348,15 @@ >> insn = BB_END (e->src); >> end = PREV_INSN (BB_HEAD (e->src)); >> while (insn != end >> - && (!NONDEBUG_INSN_P (insn) || INSN_LOCATOR (insn) == 0)) >> + && (!NONDEBUG_INSN_P (insn) || !INSN_HAS_LOCATION (insn))) >> insn = PREV_INSN (insn); >> if (insn != end >> - && locator_eq (INSN_LOCATOR (insn), (int) e->goto_locus)) >> + && INSN_LOCATION (insn) == e->goto_locus) >> continue; >> if (simplejump_p (BB_END (e->src)) >> - && INSN_LOCATOR (BB_END (e->src)) == 0) >> + && !INSN_HAS_LOCATION (BB_END (e->src))) >> { >> - INSN_LOCATOR (BB_END (e->src)) = e->goto_locus; >> + INSN_LOCATION (BB_END (e->src)) = e->goto_locus; >> continue; >> } >> dest = e->dest; >> @@ -3371,24 +3372,24 @@ >> end = NEXT_INSN (BB_END (dest)); >> while (insn != end && !NONDEBUG_INSN_P (insn)) >> insn = NEXT_INSN (insn); >> - if (insn != end && INSN_LOCATOR (insn) >> - && locator_eq (INSN_LOCATOR (insn), (int) e->goto_locus)) >> + if (insn != end && INSN_HAS_LOCATION (insn) >> + && INSN_LOCATION (insn) == e->goto_locus) >> continue; >> } >> nb = split_edge (e); >> if (!INSN_P (BB_END (nb))) >> BB_END (nb) = emit_insn_after_noloc (gen_nop (), BB_END (nb), >> nb); >> - INSN_LOCATOR (BB_END (nb)) = e->goto_locus; >> + INSN_LOCATION (BB_END (nb)) = e->goto_locus; >> >> /* If there are other incoming edges to the destination block >> with the same goto locus, redirect them to the new block as >> well, this can prevent other such blocks from being created >> in subsequent iterations of the loop. */ >> for (ei2 = ei_start (dest->preds); (e2 = ei_safe_edge (ei2)); ) >> - if (e2->goto_locus >> + if (!IS_UNKNOWN_LOCATION (e2->goto_locus) >> && !(e2->flags & (EDGE_ABNORMAL | EDGE_FALLTHRU)) >> - && locator_eq (e->goto_locus, e2->goto_locus)) >> + && e->goto_locus == e2->goto_locus) >> redirect_edge_and_branch (e2, nb); >> else >> ei_next (&ei2); >> @@ -4088,7 +4089,7 @@ >> } >> >> /* If B was a forwarder block, propagate the locus on the edge. */ >> - if (forwarder_p && !EDGE_SUCC (b, 0)->goto_locus) >> + if (forwarder_p && IS_UNKNOWN_LOCATION (EDGE_SUCC (b, 0)->goto_locus)) >> EDGE_SUCC (b, 0)->goto_locus = EDGE_SUCC (a, 0)->goto_locus; >> >> if (dump_file) >> Index: gcc/stmt.c >> =================================================================== >> --- gcc/stmt.c (revision 189835) >> +++ gcc/stmt.c (working copy) >> @@ -2397,7 +2397,7 @@ >> then emit the code for one side at a time. */ >> >> tree test_label >> - = build_decl (CURR_INSN_LOCATION, >> + = build_decl (curr_insn_location (), >> LABEL_DECL, NULL_TREE, NULL_TREE); >> >> /* See if the value is on the right. */ >> @@ -2521,7 +2521,7 @@ >> /* Right hand node requires testing. >> Branch to a label where we will handle it later. */ >> >> - test_label = build_decl (CURR_INSN_LOCATION, >> + test_label = build_decl (curr_insn_location (), >> LABEL_DECL, NULL_TREE, NULL_TREE); >> emit_cmp_and_jump_insns (index, >> convert_modes >> Index: libcpp/include/line-map.h >> =================================================================== >> --- libcpp/include/line-map.h (revision 189835) >> +++ libcpp/include/line-map.h (working copy) >> @@ -89,7 +89,7 @@ >> >> /* This is the highest possible source location encoded within an >> ordinary or macro map. */ >> -#define MAX_SOURCE_LOCATION 0xFFFFFFFF >> +#define MAX_SOURCE_LOCATION 0x7FFFFFFF >> >> struct cpp_hashnode; >> >> @@ -408,6 +408,16 @@ >> #define LINEMAPS_LAST_ALLOCATED_MACRO_MAP(SET) \ >> LINEMAPS_LAST_ALLOCATED_MAP (SET, true) >> >> +extern void location_block_init (void); >> +extern void location_block_fini (void); >> +extern source_location get_combine_location (source_location, void *); >> +extern void *get_block_from_location (source_location); >> +extern source_location get_locus_from_location (source_location); >> + >> +#define COMBINE_LOCATION(LOC, BLOCK) \ >> + ((BLOCK) ? get_combine_location ((LOC), (BLOCK)) : (LOC)) >> +#define IS_COMBINED_LOCATION(LOC) (((LOC) & MAX_SOURCE_LOCATION) != (LOC)) >> + >> /* Initialize a line map set. */ >> extern void linemap_init (struct line_maps *); >> >> @@ -594,6 +604,8 @@ >> >> int column; >> >> + void *block; >> + >> /* In a system header?. */ >> bool sysp; >> } expanded_location; >> Index: libcpp/line-map.c >> =================================================================== >> --- libcpp/line-map.c (revision 189835) >> +++ libcpp/line-map.c (working copy) >> @@ -25,6 +25,7 @@ >> #include "line-map.h" >> #include "cpplib.h" >> #include "internal.h" >> +#include "hashtab.h" >> >> static void trace_include (const struct line_maps *, const struct line_map *); >> static const struct line_map * linemap_ordinary_map_lookup (struct line_maps *, >> @@ -50,6 +51,121 @@ >> extern unsigned num_expanded_macros_counter; >> extern unsigned num_macro_tokens_counter; >> >> +struct location_block { >> + source_location locus; >> + void *block; >> +}; >> + >> +static htab_t location_block_htab; >> +static source_location curr_combined_location; >> +static struct location_block *location_blocks; >> +static unsigned int allocated_location_blocks; >> + >> +/* Hash function for location_block hashtable. */ >> + >> +static hashval_t >> +location_block_hash (const void *l) >> +{ >> + const struct location_block *lb = (const struct location_block *) l; >> + return (hashval_t) lb->locus + (size_t) &lb->block; >> +} >> + >> +/* Compare function for location_block hashtable. */ >> + >> +static int >> +location_block_eq (const void *l1, const void *l2) >> +{ >> + const struct location_block *lb1 = (const struct location_block *) l1; >> + const struct location_block *lb2 = (const struct location_block *) l2; >> + return lb1->locus == lb2->locus && lb1->block == lb2->block; >> +} >> + >> +/* Update the hashtable when location_blocks is reallocated. */ >> + >> +static int >> +location_block_update (void **slot, void *data) >> +{ >> + *((char **) slot) += ((char *) location_blocks - (char *) data); >> + return 1; >> +} >> + >> +/* Combine LOCUS and BLOCK to a combined location. */ >> + >> +source_location >> +get_combine_location (source_location locus, void *block) >> +{ >> + struct location_block lb; >> + struct location_block **slot; >> + >> + linemap_assert (block); >> + >> + if (IS_COMBINED_LOCATION (locus)) >> + locus = location_blocks[locus & MAX_SOURCE_LOCATION].locus; >> + if (locus == 0 && block == NULL) >> + return 0; >> + lb.locus = locus; >> + lb.block = block; >> + slot = (struct location_block **) >> + htab_find_slot (location_block_htab, &lb, INSERT); >> + if (*slot == NULL) >> + { >> + *slot = location_blocks + curr_combined_location; >> + location_blocks[curr_combined_location] = lb; >> + if (++curr_combined_location >= allocated_location_blocks) >> + { >> + char *orig_location_blocks = (char *) location_blocks; >> + allocated_location_blocks *= 2; >> + location_blocks = XRESIZEVEC (struct location_block, >> + location_blocks, >> + allocated_location_blocks); >> + htab_traverse (location_block_htab, location_block_update, >> + orig_location_blocks); >> + } >> + } >> + return ((*slot) - location_blocks) | 0x80000000; >> +} >> + >> +/* Return the block for LOCATION. */ >> + >> +void * >> +get_block_from_location (source_location location) >> +{ >> + linemap_assert (IS_COMBINED_LOCATION (location)); >> + return location_blocks[location & MAX_SOURCE_LOCATION].block; >> +} >> + >> +/* Return the locus for LOCATION. */ >> + >> +source_location >> +get_locus_from_location (source_location location) >> +{ >> + linemap_assert (IS_COMBINED_LOCATION (location)); >> + return location_blocks[location & MAX_SOURCE_LOCATION].locus; >> +} >> + >> +/* Initialize the location_block structure. */ >> + >> +void >> +location_block_init (void) >> +{ >> + location_block_htab = htab_create (100, location_block_hash, >> + location_block_eq, NULL); >> + curr_combined_location = 0; >> + allocated_location_blocks = 100; >> + location_blocks = XNEWVEC (struct location_block, >> + allocated_location_blocks); >> +} >> + >> +/* Finalize the location_block structure. */ >> + >> +void >> +location_block_fini (void) >> +{ >> + allocated_location_blocks = 0; >> + XDELETEVEC (location_blocks); >> + htab_delete (location_block_htab); >> +} >> + >> /* Initialize a line map set. */ >> >> void >> @@ -509,6 +625,8 @@ >> const struct line_map* >> linemap_lookup (struct line_maps *set, source_location line) >> { >> + if (IS_COMBINED_LOCATION (line)) >> + line = location_blocks[line & MAX_SOURCE_LOCATION].locus; >> if (linemap_location_from_macro_expansion_p (set, line)) >> return linemap_macro_map_lookup (set, line); >> return linemap_ordinary_map_lookup (set, line); >> @@ -525,6 +643,9 @@ >> unsigned int md, mn, mx; >> const struct line_map *cached, *result; >> >> + if (IS_COMBINED_LOCATION (line)) >> + line = location_blocks[line & MAX_SOURCE_LOCATION].locus; >> + >> if (set == NULL || line < RESERVED_LOCATION_COUNT) >> return NULL; >> >> @@ -570,6 +691,9 @@ >> unsigned int md, mn, mx; >> const struct line_map *cached, *result; >> >> + if (IS_COMBINED_LOCATION (line)) >> + line = location_blocks[line & MAX_SOURCE_LOCATION].locus; >> + >> linemap_assert (line >= LINEMAPS_MACRO_LOWEST_LOCATION (set)); >> >> if (set == NULL) >> @@ -648,6 +772,9 @@ >> { >> unsigned token_no; >> >> + if (IS_COMBINED_LOCATION (location)) >> + location = location_blocks[location & MAX_SOURCE_LOCATION].locus; >> + >> linemap_assert (linemap_macro_expansion_map_p (map) >> && location >= MAP_START_LOCATION (map)); >> linemap_assert (location >= RESERVED_LOCATION_COUNT); >> @@ -672,6 +799,9 @@ >> { >> unsigned token_no; >> >> + if (IS_COMBINED_LOCATION (location)) >> + location = location_blocks[location & MAX_SOURCE_LOCATION].locus; >> + >> linemap_assert (linemap_macro_expansion_map_p (map) >> && location >= MAP_START_LOCATION (map)); >> linemap_assert (location >= RESERVED_LOCATION_COUNT); >> @@ -696,6 +826,9 @@ >> { >> const struct line_map *map = NULL; >> >> + i > ... > > [Message clipped] Index: gcc/tree-streamer-out.c =================================================================== --- gcc/tree-streamer-out.c (revision 189835) +++ gcc/tree-streamer-out.c (working copy) @@ -471,7 +471,7 @@ { stream_write_tree (ob, DECL_NAME (expr), ref_p); stream_write_tree (ob, DECL_CONTEXT (expr), ref_p); - lto_output_location (ob, DECL_SOURCE_LOCATION (expr)); + lto_output_location (ob, LOCATION_LOCUS (DECL_SOURCE_LOCATION (expr))); } @@ -668,7 +668,7 @@ streamer_write_hwi (ob, TREE_OPERAND_LENGTH (expr)); for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++) stream_write_tree (ob, TREE_OPERAND (expr, i), ref_p); - lto_output_location (ob, EXPR_LOCATION (expr)); + lto_output_location (ob, LOCATION_LOCUS (EXPR_LOCATION (expr))); stream_write_tree (ob, TREE_BLOCK (expr), ref_p); }