From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 85890 invoked by alias); 7 Jun 2017 08:21:25 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 85857 invoked by uid 89); 7 Jun 2017 08:21:22 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-11.1 required=5.0 tests=BAYES_00,GIT_PATCH_1,GIT_PATCH_2,KAM_ASCII_DIVIDERS,SPF_PASS,T_RP_MATCHES_RCVD autolearn=ham version=3.3.2 spammy= X-HELO: mx1.suse.de Received: from mx2.suse.de (HELO mx1.suse.de) (195.135.220.15) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Wed, 07 Jun 2017 08:20:57 +0000 Received: from relay1.suse.de (charybdis-ext.suse.de [195.135.220.254]) by mx1.suse.de (Postfix) with ESMTP id 6717FAABA; Wed, 7 Jun 2017 08:20:59 +0000 (UTC) Date: Wed, 07 Jun 2017 08:21:00 -0000 From: Richard Biener To: gcc-patches@gcc.gnu.org cc: jason@redhat.com Subject: Re: [PATCH][2/2] early LTO debug, main part In-Reply-To: Message-ID: References: User-Agent: Alpine 2.20 (LSU 67 2015-01-07) MIME-Version: 1.0 Content-Type: text/plain; charset=US-ASCII X-SW-Source: 2017-06/txt/msg00397.txt.bz2 On Fri, 19 May 2017, Richard Biener wrote: > > This is a repost of the main part of the early LTO debug support. > The only changes relative to the last post is in the dwarf2out.c > pieces due to Jasons review and Jakubs introduction of > DW_OP_GNU_variable_value. > > I've also adjusted testcases for fallout (the asan backtraces do > give files / line numbers because libbacktrace doesn't understand > the DWARF) plus added a -flto run over the libstdc++ pretty printer > testsuite -- after all the goal was to make those work with LTO, > and they now nicely do. > > [LTO-]bootstrapped and tested on x86_64-unknown-linux-gnu. > > I've also tested with -flto -g and compared to before the patch and > the outcome doesn't contain any surprises. > > I've also ran the gdb testsuite with no differences (but I guess > it doesn't exercise LTO). > > I've also built SPEC 2k6 with -flto -g. > > I've also debugged optimized LTO bootstrapped cc1 a bit - not that > debugging (LTO) optimized cc1 is a pleasant experience, but at least > gdb doesn't crash. > > Ok for trunk? Ping. > Both darwin and mingw maintainers were not concerned about LTO with -g > being broken for them. > > This patch allows us to go forward with freeing more stuff after > the frontend finished, in particular remove LTO streaming of a lot > of type information that is referenced from trees (and, as a first > step, enable free-lang-data for non-LTO compiles). > > Thanks, > Richard. > > 2017-05-19 Richard Biener > > * debug.h (struct gcc_debug_hooks): Add die_ref_for_decl and > register_external_die hooks. > (debug_false_tree_charstarstar_uhwistar): Declare. > (debug_nothing_tree_charstar_uhwi): Likewise. > * debug.c (do_nothing_debug_hooks): Adjust. > (debug_false_tree_charstarstar_uhwistar): New do nothing. > (debug_nothing_tree_charstar_uhwi): Likewise. > * dbxout.c (dbx_debug_hooks): Adjust. > (xcoff_debug_hooks): Likewise. > * sdbout.c (sdb_debug_hooks): Likewise. > * vmsdbgout.c (vmsdbg_debug_hooks): Likewise. > > * dwarf2out.c (macinfo_label_base): New global. > (dwarf2out_register_external_die): New function for the > register_external_die hook. > (dwarf2out_die_ref_for_decl): Likewise for die_ref_for_decl. > (dwarf2_debug_hooks): Use them. > (dwarf2_lineno_debug_hooks): Adjust. > (struct die_struct): Add with_offset flag. > (DEBUG_LTO_DWO_INFO_SECTION, DEBUG_LTO_INFO_SECTION, > DEBUG_LTO_DWO_ABBREV_SECTION, DEBUG_LTO_ABBREV_SECTION, > DEBUG_LTO_DWO_MACINFO_SECTION, DEBUG_LTO_MACINFO_SECTION, > DEBUG_LTO_DWO_MACRO_SECTION, DEBUG_LTO_MACRO_SECTION, > DEBUG_LTO_LINE_SECTION, DEBUG_LTO_DWO_STR_OFFSETS_SECTION, > DEBUG_LTO_STR_DWO_SECTION, DEBUG_STR_LTO_SECTION): New macros > defining section names for the early LTO debug variants. > (reset_indirect_string): New helper. > (add_AT_external_die_ref): Helper for dwarf2out_register_external_die. > (print_dw_val): Add support for offsetted symbol references. > (compute_section_prefix_1): Split out worker to distinguish > the comdat from the LTO case. > (compute_section_prefix): Wrap old comdat case here. > (output_die): Skip DIE symbol output for the LTO added one. > Handle DIE symbol references with offset. > (output_comp_unit): Guard section name mangling properly. > For LTO debug sections emit a symbol at the section beginning > which we use to refer to its DIEs. > (add_abstract_origin_attribute): For DIEs registered via > dwarf2out_register_external_die directly refer to the early > DIE rather than indirectly through the shadow one we created. > (gen_array_type_die): When generating early LTO debug do > not emit DW_AT_string_length. > (gen_formal_parameter_die): Do not re-create DIEs for PARM_DECLs > late when in LTO. > (gen_subprogram_die): Adjust the check for whether we face > a concrete instance DIE for an inline we can reuse for the > late LTO case. Likewise avoid another specification DIE > for early built declarations/definitions for the late LTO case. > (gen_variable_die): Add type references for late duplicated VLA dies > when in late LTO. > (gen_inlined_subroutine_die): Do not call dwarf2out_abstract_function, > we have the abstract instance already. > (process_scope_var): Adjust decl DIE contexts in LTO which > first puts them in limbo. > (gen_decl_die): Do not generate type DIEs late apart from > types for VLAs or for decls we do not yet have a DIE. > (dwarf2out_early_global_decl): Make sure to create DIEs > for abstract instances of a decl first. > (dwarf2out_late_global_decl): Adjust comment. > (output_macinfo_op): With multiple macro sections use > macinfo_label_base to distinguish labels. > (output_macinfo): Likewise. Update macinfo_label_base. > Pass in the line info label. > (note_variable_value_in_expr): When generating LTO resolve > all variable values here by generating DIEs as needed. > (init_sections_and_labels): Add early LTO debug flag parameter > and generate different sections and names if set. Add generation > counter for the labels so we can have multiple of them. > (reset_dies): Helper to allow DIEs to be output multiple times. > (dwarf2out_finish): When outputting DIEs to the fat part of an > LTO object first reset DIEs. > (dwarf2out_early_finish): Output early DIEs when generating LTO. > > Cleanups we can do (and need) when removing the "old" LTO path and add > the early LTO path. > > (set_decl_abstract_flags): Remove. > (set_block_abstract_flags): Likewise. > (dwarf2out_abstract_function): Treat the early generated DIEs > as the abstract copy and only add DW_AT_inline and > DW_AT_artificial here. > > * tree.c (free_lang_data): Build a dummy TRANSLATION_UNIT_DECL > if we have none yet (Go fails to build one, PR78628). > * lto-streamer-in.c: Include debug.h. > (dref_queue): New global. > (lto_read_tree_1): Stream in DIE references. > (lto_input_tree): Register DIE references. > (input_function): Stream DECL_DEBUG_ARGS. > * lto-streamer-out.c: Include debug.h. > (lto_write_tree_1): Output DIE references. > (DFS::DFS_write_tree_body): Follow DECL_ABSTRACT_ORIGIN. > Force a TRANSLATION_UNIT_DECL DECL_CONTEXT for file-scope decls. > (output_function): Stream DECL_DEBUG_ARGS. > * tree-streamer-in.c (lto_input_ts_decl_common_tree_pointers): > Stream DECL_ABSTRACT_ORIGIN. > * tree-streamer-out.c (write_ts_decl_common_tree_pointers): Likewise. > (write_ts_decl_minimal_tree_pointers): Force a TRANSLATION_UNIT_DECL > DECL_CONTEXT for file-scope decls. > * lto-streamer.h (struct dref_entry): Declare. > (dref_queue): Likewise. > > * lto-wrapper.c (debug_obj): New global. > (tool_cleanup): Unlink it if required. > (debug_objcopy): New function. > (run_gcc): Handle early debug sections in the IL files by > extracting them to separate files, partially linkin them and > feeding the result back as result to the linker. > > * config/darwin.h (DEBUG_LTO_INFO_SECTION, DEBUG_LTO_ABBREV_SECTION, > DEBUG_LTO_MACINFO_SECTION, DEBUG_LTO_LINE_SECTION, > DEBUG_STR_LTO_SECTION, DEBUG_LTO_MACRO_SECTION): Put early debug > sections into a separate segment. > * config/darwin.c (darwin_asm_named_section): Handle __GNU_DWARF_LTO > segments. > (darwin_asm_dwarf_section): Likewise. > (darwin_asm_output_dwarf_offset): Likewise. > > * config/i386/i386.c (make_resolver_func): Set DECL_IGNORED_P. > > lto/ > * lto.c (unify_scc): Truncate DIE reference queue for dropped SCCs. > (lto_read_decls): Process TRANSLATION_UNIT_DECLs. Remove > TYPE_DECL debug processing, register DIE references from > prevailing SCCs with the debug machinery. > (lto_section_with_id): Handle LTO debug sections. > > libstdc++/ > * testsuite/libstdc++-prettyprinters/prettyprinters.exp: Run all > tests with -flto as well if supported. > > * c-c++-common/asan/global-overflow-1.c: Adjust diagnostic location > regex to handle the LTO case. > * c-c++-common/asan/heap-overflow-1.c: Likewise. > * c-c++-common/asan/misalign-1.c: Likewise. > * c-c++-common/asan/misalign-2.c: Likewise. > * c-c++-common/asan/null-deref-1.c: Likewise. > * c-c++-common/asan/stack-overflow-1.c: Likewise. > * c-c++-common/asan/strncpy-overflow-1.c: Likewise. > * c-c++-common/asan/use-after-free-1.c: Likewise. > * g++.dg/asan/large-func-test-1.C: Likewise. > * gfortran.dg/save_6.f90: Add -flto -g variant of save_5.f90. > > Index: early-lto-debug/gcc/dwarf2out.c > =================================================================== > *** early-lto-debug.orig/gcc/dwarf2out.c 2017-05-16 13:10:47.554202813 +0200 > --- early-lto-debug/gcc/dwarf2out.c 2017-05-19 12:29:43.933873285 +0200 > *************** static GTY(()) section *debug_aranges_se > *** 162,167 **** > --- 162,168 ---- > static GTY(()) section *debug_addr_section; > static GTY(()) section *debug_macinfo_section; > static const char *debug_macinfo_section_name; > + static unsigned macinfo_label_base = 1; > static GTY(()) section *debug_line_section; > static GTY(()) section *debug_skeleton_line_section; > static GTY(()) section *debug_loc_section; > *************** static void dwarf2out_begin_function (tr > *** 2686,2691 **** > --- 2687,2696 ---- > static void dwarf2out_end_function (unsigned int); > static void dwarf2out_register_main_translation_unit (tree unit); > static void dwarf2out_set_name (tree, tree); > + static void dwarf2out_register_external_die (tree decl, const char *sym, > + unsigned HOST_WIDE_INT off); > + static bool dwarf2out_die_ref_for_decl (tree decl, const char **sym, > + unsigned HOST_WIDE_INT *off); > > /* The debug hooks structure. */ > > *************** const struct gcc_debug_hooks dwarf2_debu > *** 2720,2725 **** > --- 2725,2732 ---- > dwarf2out_late_global_decl, > dwarf2out_type_decl, /* type_decl */ > dwarf2out_imported_module_or_decl, > + dwarf2out_die_ref_for_decl, > + dwarf2out_register_external_die, > debug_nothing_tree, /* deferred_inline_function */ > /* The DWARF 2 backend tries to reduce debugging bloat by not > emitting the abstract description of inline functions until > *************** const struct gcc_debug_hooks dwarf2_line > *** 2761,2766 **** > --- 2768,2775 ---- > debug_nothing_tree, /* late_global_decl */ > debug_nothing_tree_int, /* type_decl */ > debug_nothing_tree_tree_tree_bool, /* imported_module_or_decl */ > + debug_false_tree_charstarstar_uhwistar, /* die_ref_for_decl */ > + debug_nothing_tree_charstar_uhwi, /* register_external_die */ > debug_nothing_tree, /* deferred_inline_function */ > debug_nothing_tree, /* outlining_inline_function */ > debug_nothing_rtx_code_label, /* label */ > *************** typedef struct GTY((chain_circular ("%h. > *** 2889,2894 **** > --- 2898,2906 ---- > /* Die is used and must not be pruned as unused. */ > BOOL_BITFIELD die_perennial_p : 1; > BOOL_BITFIELD comdat_type_p : 1; /* DIE has a type signature */ > + /* For an external ref to die_symbol if die_offset contains an extra > + offset to that symbol. */ > + BOOL_BITFIELD with_offset : 1; > /* Whether this DIE was removed from the DIE tree, for example via > prune_unused_types. We don't consider those present from the > DIE lookup routines. */ > *************** new_addr_loc_descr (rtx addr, enum dtpre > *** 3692,3703 **** > --- 3704,3727 ---- > #ifndef DEBUG_DWO_INFO_SECTION > #define DEBUG_DWO_INFO_SECTION ".debug_info.dwo" > #endif > + #ifndef DEBUG_LTO_DWO_INFO_SECTION > + #define DEBUG_LTO_DWO_INFO_SECTION ".gnu.debuglto_.debug_info.dwo" > + #endif > + #ifndef DEBUG_LTO_INFO_SECTION > + #define DEBUG_LTO_INFO_SECTION ".gnu.debuglto_.debug_info" > + #endif > #ifndef DEBUG_ABBREV_SECTION > #define DEBUG_ABBREV_SECTION ".debug_abbrev" > #endif > #ifndef DEBUG_DWO_ABBREV_SECTION > #define DEBUG_DWO_ABBREV_SECTION ".debug_abbrev.dwo" > #endif > + #ifndef DEBUG_LTO_DWO_ABBREV_SECTION > + #define DEBUG_LTO_DWO_ABBREV_SECTION ".gnu.debuglto_.debug_abbrev.dwo" > + #endif > + #ifndef DEBUG_LTO_ABBREV_SECTION > + #define DEBUG_LTO_ABBREV_SECTION ".gnu.debuglto_.debug_abbrev" > + #endif > #ifndef DEBUG_ARANGES_SECTION > #define DEBUG_ARANGES_SECTION ".debug_aranges" > #endif > *************** new_addr_loc_descr (rtx addr, enum dtpre > *** 3710,3727 **** > --- 3734,3766 ---- > #ifndef DEBUG_DWO_MACINFO_SECTION > #define DEBUG_DWO_MACINFO_SECTION ".debug_macinfo.dwo" > #endif > + #ifndef DEBUG_LTO_DWO_MACINFO_SECTION > + #define DEBUG_LTO_DWO_MACINFO_SECTION ".gnu.debuglto_.debug_macinfo.dwo" > + #endif > + #ifndef DEBUG_LTO_MACINFO_SECTION > + #define DEBUG_LTO_MACINFO_SECTION ".gnu.debuglto_.debug_macinfo" > + #endif > #ifndef DEBUG_DWO_MACRO_SECTION > #define DEBUG_DWO_MACRO_SECTION ".debug_macro.dwo" > #endif > #ifndef DEBUG_MACRO_SECTION > #define DEBUG_MACRO_SECTION ".debug_macro" > #endif > + #ifndef DEBUG_LTO_DWO_MACRO_SECTION > + #define DEBUG_LTO_DWO_MACRO_SECTION ".gnu.debuglto_.debug_macro.dwo" > + #endif > + #ifndef DEBUG_LTO_MACRO_SECTION > + #define DEBUG_LTO_MACRO_SECTION ".gnu.debuglto_.debug_macro" > + #endif > #ifndef DEBUG_LINE_SECTION > #define DEBUG_LINE_SECTION ".debug_line" > #endif > #ifndef DEBUG_DWO_LINE_SECTION > #define DEBUG_DWO_LINE_SECTION ".debug_line.dwo" > #endif > + #ifndef DEBUG_LTO_LINE_SECTION > + #define DEBUG_LTO_LINE_SECTION ".gnu.debuglto_.debug_line.dwo" > + #endif > #ifndef DEBUG_LOC_SECTION > #define DEBUG_LOC_SECTION ".debug_loc" > #endif > *************** new_addr_loc_descr (rtx addr, enum dtpre > *** 3750,3761 **** > --- 3789,3809 ---- > #ifndef DEBUG_DWO_STR_OFFSETS_SECTION > #define DEBUG_DWO_STR_OFFSETS_SECTION ".debug_str_offsets.dwo" > #endif > + #ifndef DEBUG_LTO_DWO_STR_OFFSETS_SECTION > + #define DEBUG_LTO_DWO_STR_OFFSETS_SECTION ".gnu.debuglto_.debug_str_offsets.dwo" > + #endif > #ifndef DEBUG_STR_DWO_SECTION > #define DEBUG_STR_DWO_SECTION ".debug_str.dwo" > #endif > + #ifndef DEBUG_LTO_STR_DWO_SECTION > + #define DEBUG_LTO_STR_DWO_SECTION ".gnu.debuglto_.debug_str.dwo" > + #endif > #ifndef DEBUG_STR_SECTION > #define DEBUG_STR_SECTION ".debug_str" > #endif > + #ifndef DEBUG_LTO_STR_SECTION > + #define DEBUG_LTO_STR_SECTION ".gnu.debuglto_.debug_str" > + #endif > #ifndef DEBUG_RANGES_SECTION > #define DEBUG_RANGES_SECTION ".debug_ranges" > #endif > *************** new_addr_loc_descr (rtx addr, enum dtpre > *** 3780,3785 **** > --- 3828,3837 ---- > /* Section flags for .debug_str.dwo section. */ > #define DEBUG_STR_DWO_SECTION_FLAGS (SECTION_DEBUG | SECTION_EXCLUDE) > > + /* Attribute used to refer to the macro section. */ > + #define DEBUG_MACRO_ATTRIBUTE (dwarf_version >= 5 ? DW_AT_macros \ > + : dwarf_strict ? DW_AT_macro_info : DW_AT_GNU_macros) > + > /* Labels we insert at beginning sections we can reference instead of > the section names themselves. */ > > *************** set_indirect_string (struct indirect_str > *** 4368,4373 **** > --- 4420,4443 ---- > } > } > > + /* A helper function for dwarf2out_finish, called to reset indirect > + string decisions done for early LTO dwarf output before fat object > + dwarf output. */ > + > + int > + reset_indirect_string (indirect_string_node **h, void *) > + { > + struct indirect_string_node *node = *h; > + if (node->form == DW_FORM_strp || node->form == DW_FORM_GNU_str_index) > + { > + free (node->label); > + node->label = NULL; > + node->form = (dwarf_form) 0; > + node->index = 0; > + } > + return 1; > + } > + > /* Find out whether a string should be output inline in DIE > or out-of-line in .debug_str section. */ > > *************** lookup_decl_die (tree decl) > *** 5413,5418 **** > --- 5483,5668 ---- > return *die; > } > > + > + /* For DECL which might have early dwarf output query a SYMBOL + OFFSET > + style reference. Return true if we found one refering to a DIE for > + DECL, otherwise return false. */ > + > + static bool > + dwarf2out_die_ref_for_decl (tree decl, const char **sym, > + unsigned HOST_WIDE_INT *off) > + { > + dw_die_ref die; > + > + if (flag_wpa && !decl_die_table) > + return false; > + > + if (TREE_CODE (decl) == BLOCK) > + die = BLOCK_DIE (decl); > + else > + die = lookup_decl_die (decl); > + if (!die) > + return false; > + > + /* During WPA stage we currently use DIEs to store the > + decl <-> label + offset map. That's quite inefficient but it > + works for now. */ > + if (flag_wpa) > + { > + dw_die_ref ref = get_AT_ref (die, DW_AT_abstract_origin); > + if (!ref) > + { > + gcc_assert (die == comp_unit_die ()); > + return false; > + } > + *off = ref->die_offset; > + *sym = ref->die_id.die_symbol; > + return true; > + } > + > + /* Similar to get_ref_die_offset_label, but using the "correct" > + label. */ > + *off = die->die_offset; > + while (die->die_parent) > + die = die->die_parent; > + /* For the containing CU DIE we compute a die_symbol in > + compute_section_prefix. */ > + gcc_assert (die->die_tag == DW_TAG_compile_unit > + && die->die_id.die_symbol != NULL); > + *sym = die->die_id.die_symbol; > + return true; > + } > + > + /* Add a reference of kind ATTR_KIND to a DIE at SYMBOL + OFFSET to DIE. */ > + > + static void > + add_AT_external_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, > + const char *symbol, HOST_WIDE_INT offset) > + { > + /* Create a fake DIE that contains the reference. Don't use > + new_die because we don't want to end up in the limbo list. */ > + dw_die_ref ref = ggc_cleared_alloc (); > + ref->die_tag = die->die_tag; > + ref->die_id.die_symbol = IDENTIFIER_POINTER (get_identifier (symbol)); > + ref->die_offset = offset; > + ref->with_offset = 1; > + add_AT_die_ref (die, attr_kind, ref); > + } > + > + /* Create a DIE for DECL if required and add a reference to a DIE > + at SYMBOL + OFFSET which contains attributes dumped early. */ > + > + static void > + dwarf2out_register_external_die (tree decl, const char *sym, > + unsigned HOST_WIDE_INT off) > + { > + if (debug_info_level == DINFO_LEVEL_NONE) > + return; > + > + if (flag_wpa && !decl_die_table) > + decl_die_table = hash_table::create_ggc (1000); > + > + dw_die_ref die > + = TREE_CODE (decl) == BLOCK ? BLOCK_DIE (decl) : lookup_decl_die (decl); > + gcc_assert (!die); > + > + tree ctx; > + dw_die_ref parent = NULL; > + /* Need to lookup a DIE for the decls context - the containing > + function or translation unit. */ > + if (TREE_CODE (decl) == BLOCK) > + { > + ctx = BLOCK_SUPERCONTEXT (decl); > + /* ??? We do not output DIEs for all scopes thus skip as > + many DIEs as needed. */ > + while (TREE_CODE (ctx) == BLOCK > + && !BLOCK_DIE (ctx)) > + ctx = BLOCK_SUPERCONTEXT (ctx); > + } > + else > + ctx = DECL_CONTEXT (decl); > + while (ctx && TYPE_P (ctx)) > + ctx = TYPE_CONTEXT (ctx); > + if (ctx) > + { > + if (TREE_CODE (ctx) == BLOCK) > + parent = BLOCK_DIE (ctx); > + else if (TREE_CODE (ctx) == TRANSLATION_UNIT_DECL > + /* Keep the 1:1 association during WPA. */ > + && !flag_wpa) > + /* Otherwise all late annotations go to the main CU which > + imports the original CUs. */ > + parent = comp_unit_die (); > + else if (TREE_CODE (ctx) == FUNCTION_DECL > + && TREE_CODE (decl) != PARM_DECL > + && TREE_CODE (decl) != BLOCK) > + /* Leave function local entities parent determination to when > + we process scope vars. */ > + ; > + else > + parent = lookup_decl_die (ctx); > + } > + else > + /* ??? In some cases the C++ FE (at least) fails to > + set DECL_CONTEXT properly. Simply globalize stuff > + in this case. For example > + __dso_handle created via iostream line 74 col 25. */ > + parent = comp_unit_die (); > + /* Create a DIE "stub". */ > + switch (TREE_CODE (decl)) > + { > + case TRANSLATION_UNIT_DECL: > + if (! flag_wpa) > + { > + die = comp_unit_die (); > + dw_die_ref import = new_die (DW_TAG_imported_unit, die, NULL_TREE); > + add_AT_external_die_ref (import, DW_AT_import, sym, off); > + /* We re-target all CU decls to the LTRANS CU DIE, so no need > + to create a DIE for the original CUs. */ > + return; > + } > + /* Keep the 1:1 association during WPA. */ > + die = new_die (DW_TAG_compile_unit, NULL, decl); > + break; > + case NAMESPACE_DECL: > + /* ??? LANG issue - DW_TAG_module for fortran. Either look > + at the input language (if we have enough DECL_CONTEXT to follow) > + or use a bit in tree_decl_with_vis to record the distinction. */ > + die = new_die (DW_TAG_namespace, parent, decl); > + break; > + case FUNCTION_DECL: > + die = new_die (DW_TAG_subprogram, parent, decl); > + break; > + case VAR_DECL: > + die = new_die (DW_TAG_variable, parent, decl); > + break; > + case RESULT_DECL: > + die = new_die (DW_TAG_variable, parent, decl); > + break; > + case PARM_DECL: > + die = new_die (DW_TAG_formal_parameter, parent, decl); > + break; > + case CONST_DECL: > + die = new_die (DW_TAG_constant, parent, decl); > + break; > + case LABEL_DECL: > + die = new_die (DW_TAG_label, parent, decl); > + break; > + case BLOCK: > + die = new_die (DW_TAG_lexical_block, parent, decl); > + break; > + default: > + gcc_unreachable (); > + } > + if (TREE_CODE (decl) == BLOCK) > + BLOCK_DIE (decl) = die; > + else > + equate_decl_number_to_die (decl, die); > + > + /* Add a reference to the DIE providing early debug at $sym + off. */ > + add_AT_external_die_ref (die, DW_AT_abstract_origin, sym, off); > + } > + > /* Returns a hash value for X (which really is a var_loc_list). */ > > inline hashval_t > *************** print_dw_val (dw_val_node *val, bool rec > *** 5900,5906 **** > die->die_id.die_type_node->signature); > } > else if (die->die_id.die_symbol) > ! fprintf (outfile, "die -> label: %s", die->die_id.die_symbol); > else > fprintf (outfile, "die -> %ld", die->die_offset); > fprintf (outfile, " (%p)", (void *) die); > --- 6150,6160 ---- > die->die_id.die_type_node->signature); > } > else if (die->die_id.die_symbol) > ! { > ! fprintf (outfile, "die -> label: %s", die->die_id.die_symbol); > ! if (die->with_offset) > ! fprintf (outfile, " + %ld", die->die_offset); > ! } > else > fprintf (outfile, "die -> %ld", die->die_offset); > fprintf (outfile, " (%p)", (void *) die); > *************** static unsigned int comdat_symbol_number > *** 7216,7222 **** > children, and set comdat_symbol_id accordingly. */ > > static void > ! compute_section_prefix (dw_die_ref unit_die) > { > const char *die_name = get_AT_string (unit_die, DW_AT_name); > const char *base = die_name ? lbasename (die_name) : "anonymous"; > --- 7470,7476 ---- > children, and set comdat_symbol_id accordingly. */ > > static void > ! compute_section_prefix_1 (dw_die_ref unit_die, bool comdat_p) > { > const char *die_name = get_AT_string (unit_die, DW_AT_name); > const char *base = die_name ? lbasename (die_name) : "anonymous"; > *************** compute_section_prefix (dw_die_ref unit_ > *** 7235,7241 **** > unmark_all_dies (unit_die); > md5_finish_ctx (&ctx, checksum); > > ! sprintf (name, "%s.", base); > clean_symbol_name (name); > > p = name + strlen (name); > --- 7489,7499 ---- > unmark_all_dies (unit_die); > md5_finish_ctx (&ctx, checksum); > > ! /* When we this for comp_unit_die () we have a DW_AT_name that might > ! not start with a letter but with anything valid for filenames and > ! clean_symbol_name doesn't fix that up. Prepend 'g' if the first > ! character is not a letter. */ > ! sprintf (name, "%s%s.", ISALPHA (*base) ? "" : "g", base); > clean_symbol_name (name); > > p = name + strlen (name); > *************** compute_section_prefix (dw_die_ref unit_ > *** 7245,7251 **** > p += 2; > } > > ! comdat_symbol_id = unit_die->die_id.die_symbol = xstrdup (name); > comdat_symbol_number = 0; > } > > --- 7503,7517 ---- > p += 2; > } > > ! unit_die->die_id.die_symbol = xstrdup (name); > ! unit_die->comdat_type_p = comdat_p; > ! } > ! > ! static void > ! compute_section_prefix (dw_die_ref unit_die) > ! { > ! compute_section_prefix_1 (unit_die, true); > ! comdat_symbol_id = unit_die->die_id.die_symbol; > comdat_symbol_number = 0; > } > > *************** output_die (dw_die_ref die) > *** 9971,9977 **** > > /* If someone in another CU might refer to us, set up a symbol for > them to point to. */ > ! if (! die->comdat_type_p && die->die_id.die_symbol) > output_die_symbol (die); > > dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (%#lx) %s)", > --- 10237,10247 ---- > > /* If someone in another CU might refer to us, set up a symbol for > them to point to. */ > ! if (! die->comdat_type_p && die->die_id.die_symbol > ! /* Don't output the symbol twice. For LTO we want the label > ! on the section beginning, not on the actual DIE. */ > ! && (!flag_generate_lto > ! || die->die_tag != DW_TAG_compile_unit)) > output_die_symbol (die); > > dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (%#lx) %s)", > *************** output_die (dw_die_ref die) > *** 10164,10171 **** > size = DWARF2_ADDR_SIZE; > else > size = DWARF_OFFSET_SIZE; > ! dw2_asm_output_offset (size, sym, debug_info_section, "%s", > ! name); > } > } > else > --- 10434,10453 ---- > size = DWARF2_ADDR_SIZE; > else > size = DWARF_OFFSET_SIZE; > ! /* ??? We cannot unconditionally output die_offset if > ! non-zero - at least -feliminate-dwarf2-dups will > ! create references to those DIEs via symbols. And we > ! do not clear its DIE offset after outputting it > ! (and the label refers to the actual DIEs, not the > ! DWARF CU unit header which is when using label + offset > ! would be the correct thing to do). > ! ??? This is the reason for the with_offset flag. */ > ! if (AT_ref (a)->with_offset) > ! dw2_asm_output_offset (size, sym, AT_ref (a)->die_offset, > ! debug_info_section, "%s", name); > ! else > ! dw2_asm_output_offset (size, sym, debug_info_section, "%s", > ! name); > } > } > else > *************** output_comp_unit (dw_die_ref die, int ou > *** 10391,10397 **** > calc_die_sizes (die); > > oldsym = die->die_id.die_symbol; > ! if (oldsym) > { > tmp = XALLOCAVEC (char, strlen (oldsym) + 24); > > --- 10673,10679 ---- > calc_die_sizes (die); > > oldsym = die->die_id.die_symbol; > ! if (oldsym && die->comdat_type_p) > { > tmp = XALLOCAVEC (char, strlen (oldsym) + 24); > > *************** output_comp_unit (dw_die_ref die, int ou > *** 10407,10412 **** > --- 10689,10721 ---- > info_section_emitted = true; > } > > + /* For LTO cross unit DIE refs we want a symbol on the start of the > + debuginfo section, not on the CU DIE. > + ??? We could simply use the symbol as it would be output by output_die > + and account for the extra offset produced by the CU header which has fixed > + size. OTOH it currently only supports linkonce globals which would > + be less than ideal?. */ > + if (flag_generate_lto && oldsym) > + { > + /* ??? No way to get visibility assembled without a decl. */ > + tree decl = build_decl (UNKNOWN_LOCATION, VAR_DECL, > + get_identifier (oldsym), char_type_node); > + TREE_PUBLIC (decl) = true; > + TREE_STATIC (decl) = true; > + DECL_ARTIFICIAL (decl) = true; > + DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN; > + DECL_VISIBILITY_SPECIFIED (decl) = true; > + targetm.asm_out.assemble_visibility (decl, VISIBILITY_HIDDEN); > + #ifdef ASM_WEAKEN_LABEL > + /* We prefer a .weak because that handles duplicates from duplicate > + archive members in a graceful way. */ > + ASM_WEAKEN_LABEL (asm_out_file, oldsym); > + #else > + targetm.asm_out.globalize_label (asm_out_file, oldsym); > + #endif > + ASM_OUTPUT_LABEL (asm_out_file, oldsym); > + } > + > /* Output debugging information. */ > output_compilation_unit_header (dwo_id > ? DW_UT_split_compile : DW_UT_compile); > *************** parameter_ref_descriptor (rtx rtl) > *** 14523,14528 **** > --- 14832,14840 ---- > if (dwarf_strict) > return NULL; > gcc_assert (TREE_CODE (DEBUG_PARAMETER_REF_DECL (rtl)) == PARM_DECL); > + /* With LTO during LTRANS we get the late DIE that refers to the early > + DIE, thus we add another indirection here. This seems to confuse > + gdb enough to make gcc.dg/guality/pr68860-1.c FAIL with LTO. */ > ref = lookup_decl_die (DEBUG_PARAMETER_REF_DECL (rtl)); > ret = new_loc_descr (DW_OP_GNU_parameter_ref, 0, 0); > if (ref) > *************** add_abstract_origin_attribute (dw_die_re > *** 20216,20222 **** > } > > if (DECL_P (origin)) > ! origin_die = lookup_decl_die (origin); > else if (TYPE_P (origin)) > origin_die = lookup_type_die (origin); > else if (TREE_CODE (origin) == BLOCK) > --- 20528,20547 ---- > } > > if (DECL_P (origin)) > ! { > ! dw_die_ref c; > ! origin_die = lookup_decl_die (origin); > ! /* "Unwrap" the decls DIE which we put in the imported unit context. > ! ??? If we finish dwarf2out_function_decl refactoring we can > ! do this in a better way from the start and only lazily emit > ! the early DIE references. */ > ! if (in_lto_p > ! && origin_die > ! && (c = get_AT_ref (origin_die, DW_AT_abstract_origin)) > ! /* ??? Identify this better. */ > ! && c->with_offset) > ! origin_die = c; > ! } > else if (TYPE_P (origin)) > origin_die = lookup_type_die (origin); > else if (TREE_CODE (origin) == BLOCK) > *************** gen_array_type_die (tree type, dw_die_re > *** 20775,20781 **** > size = int_size_in_bytes (type); > if (size >= 0) > add_AT_unsigned (array_die, DW_AT_byte_size, size); > ! else if (TYPE_DOMAIN (type) != NULL_TREE > && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != NULL_TREE) > { > tree szdecl = TYPE_MAX_VALUE (TYPE_DOMAIN (type)); > --- 21100,21109 ---- > size = int_size_in_bytes (type); > if (size >= 0) > add_AT_unsigned (array_die, DW_AT_byte_size, size); > ! /* ??? We can't annotate types late, but for LTO we may not > ! generate a location early either (gfortran.dg/save_6.f90). */ > ! else if (! (early_dwarf && flag_generate_lto) > ! && TYPE_DOMAIN (type) != NULL_TREE > && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != NULL_TREE) > { > tree szdecl = TYPE_MAX_VALUE (TYPE_DOMAIN (type)); > *************** gen_formal_parameter_die (tree node, tre > *** 21188,21194 **** > thing. */ > if (parm_die && parm_die->die_parent != context_die) > { > ! if (!DECL_ABSTRACT_P (node)) > { > /* This can happen when creating an inlined instance, in > which case we need to create a new DIE that will get > --- 21516,21524 ---- > thing. */ > if (parm_die && parm_die->die_parent != context_die) > { > ! /* ??? The DIE parent is the "abstract" copy and the context_die > ! is the specification "copy". */ > ! if (!DECL_ABSTRACT_P (node) && !in_lto_p) > { > /* This can happen when creating an inlined instance, in > which case we need to create a new DIE that will get > *************** gen_type_die_for_member (tree type, tree > *** 21462,21468 **** > /* Forward declare these functions, because they are mutually recursive > with their set_block_* pairing functions. */ > static void set_decl_origin_self (tree); > - static void set_decl_abstract_flags (tree, vec &); > > /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the > given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so > --- 21792,21797 ---- > *************** set_decl_origin_self (tree decl) > *** 21535,21685 **** > } > } > > ! /* Given a pointer to some BLOCK node, set the BLOCK_ABSTRACT flag to 1 > ! and if it wasn't 1 before, push it to abstract_vec vector. > ! For all local decls and all local sub-blocks (recursively) do it > ! too. */ > ! > ! static void > ! set_block_abstract_flags (tree stmt, vec &abstract_vec) > ! { > ! tree local_decl; > ! tree subblock; > ! unsigned int i; > ! > ! if (!BLOCK_ABSTRACT (stmt)) > ! { > ! abstract_vec.safe_push (stmt); > ! BLOCK_ABSTRACT (stmt) = 1; > ! } > ! > ! for (local_decl = BLOCK_VARS (stmt); > ! local_decl != NULL_TREE; > ! local_decl = DECL_CHAIN (local_decl)) > ! if (! DECL_EXTERNAL (local_decl)) > ! set_decl_abstract_flags (local_decl, abstract_vec); > ! > ! for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (stmt); i++) > ! { > ! local_decl = BLOCK_NONLOCALIZED_VAR (stmt, i); > ! if ((VAR_P (local_decl) && !TREE_STATIC (local_decl)) > ! || TREE_CODE (local_decl) == PARM_DECL) > ! set_decl_abstract_flags (local_decl, abstract_vec); > ! } > ! > ! for (subblock = BLOCK_SUBBLOCKS (stmt); > ! subblock != NULL_TREE; > ! subblock = BLOCK_CHAIN (subblock)) > ! set_block_abstract_flags (subblock, abstract_vec); > ! } > ! > ! /* Given a pointer to some ..._DECL node, set DECL_ABSTRACT_P flag on it > ! to 1 and if it wasn't 1 before, push to abstract_vec vector. > ! In the case where the decl is a FUNCTION_DECL also set the abstract > ! flags for all of the parameters, local vars, local > ! blocks and sub-blocks (recursively). */ > ! > ! static void > ! set_decl_abstract_flags (tree decl, vec &abstract_vec) > ! { > ! if (!DECL_ABSTRACT_P (decl)) > ! { > ! abstract_vec.safe_push (decl); > ! DECL_ABSTRACT_P (decl) = 1; > ! } > ! > ! if (TREE_CODE (decl) == FUNCTION_DECL) > ! { > ! tree arg; > ! > ! for (arg = DECL_ARGUMENTS (decl); arg; arg = DECL_CHAIN (arg)) > ! if (!DECL_ABSTRACT_P (arg)) > ! { > ! abstract_vec.safe_push (arg); > ! DECL_ABSTRACT_P (arg) = 1; > ! } > ! if (DECL_INITIAL (decl) != NULL_TREE > ! && DECL_INITIAL (decl) != error_mark_node) > ! set_block_abstract_flags (DECL_INITIAL (decl), abstract_vec); > ! } > ! } > ! > ! /* Generate the DWARF2 info for the "abstract" instance of a function which we > ! may later generate inlined and/or out-of-line instances of. > ! > ! FIXME: In the early-dwarf world, this function, and most of the > ! DECL_ABSTRACT code should be obsoleted. The early DIE _is_ > ! the abstract instance. All we would need to do is annotate > ! the early DIE with the appropriate DW_AT_inline in late > ! dwarf (perhaps in gen_inlined_subroutine_die). > ! > ! However, we can't do this yet, because LTO streaming of DIEs > ! has not been implemented yet. */ > > static void > dwarf2out_abstract_function (tree decl) > { > dw_die_ref old_die; > - tree save_fn; > - tree context; > - hash_table *old_decl_loc_table; > - hash_table *old_cached_dw_loc_list_table; > - int old_call_site_count, old_tail_call_site_count; > - struct call_arg_loc_node *old_call_arg_locations; > > /* Make sure we have the actual abstract inline, not a clone. */ > decl = DECL_ORIGIN (decl); > > old_die = lookup_decl_die (decl); > ! if (old_die && get_AT (old_die, DW_AT_inline)) > /* We've already generated the abstract instance. */ > return; > > ! /* We can be called while recursively when seeing block defining inlined subroutine > ! DIE. Be sure to not clobber the outer location table nor use it or we would > ! get locations in abstract instantces. */ > ! old_decl_loc_table = decl_loc_table; > ! decl_loc_table = NULL; > ! old_cached_dw_loc_list_table = cached_dw_loc_list_table; > ! cached_dw_loc_list_table = NULL; > ! old_call_arg_locations = call_arg_locations; > ! call_arg_locations = NULL; > ! old_call_site_count = call_site_count; > ! call_site_count = -1; > ! old_tail_call_site_count = tail_call_site_count; > ! tail_call_site_count = -1; > ! > ! /* Be sure we've emitted the in-class declaration DIE (if any) first, so > ! we don't get confused by DECL_ABSTRACT_P. */ > ! if (debug_info_level > DINFO_LEVEL_TERSE) > { > ! context = decl_class_context (decl); > ! if (context) > ! gen_type_die_for_member > ! (context, decl, decl_function_context (decl) ? NULL : comp_unit_die ()); > } > > ! /* Pretend we've just finished compiling this function. */ > ! save_fn = current_function_decl; > ! current_function_decl = decl; > ! > ! auto_vec abstract_vec; > ! set_decl_abstract_flags (decl, abstract_vec); > ! dwarf2out_decl (decl); > ! unsigned int i; > ! tree t; > ! FOR_EACH_VEC_ELT (abstract_vec, i, t) > ! if (TREE_CODE (t) == BLOCK) > ! BLOCK_ABSTRACT (t) = 0; > ! else > ! DECL_ABSTRACT_P (t) = 0; > ! > ! current_function_decl = save_fn; > ! decl_loc_table = old_decl_loc_table; > ! cached_dw_loc_list_table = old_cached_dw_loc_list_table; > ! call_arg_locations = old_call_arg_locations; > ! call_site_count = old_call_site_count; > ! tail_call_site_count = old_tail_call_site_count; > } > > /* Helper function of premark_used_types() which gets called through > --- 21864,21908 ---- > } > } > > ! /* Mark the early DIE for DECL as the abstract instance. */ > > static void > dwarf2out_abstract_function (tree decl) > { > dw_die_ref old_die; > > /* Make sure we have the actual abstract inline, not a clone. */ > decl = DECL_ORIGIN (decl); > > + if (DECL_IGNORED_P (decl)) > + return; > + > old_die = lookup_decl_die (decl); > ! /* With early debug we always have an old DIE. */ > ! gcc_assert (old_die != NULL); > ! if (get_AT (old_die, DW_AT_inline)) > /* We've already generated the abstract instance. */ > return; > > ! /* Go ahead and put DW_AT_inline on the DIE. */ > ! if (DECL_DECLARED_INLINE_P (decl)) > { > ! if (cgraph_function_possibly_inlined_p (decl)) > ! add_AT_unsigned (old_die, DW_AT_inline, DW_INL_declared_inlined); > ! else > ! add_AT_unsigned (old_die, DW_AT_inline, DW_INL_declared_not_inlined); > ! } > ! else > ! { > ! if (cgraph_function_possibly_inlined_p (decl)) > ! add_AT_unsigned (old_die, DW_AT_inline, DW_INL_inlined); > ! else > ! add_AT_unsigned (old_die, DW_AT_inline, DW_INL_not_inlined); > } > > ! if (DECL_DECLARED_INLINE_P (decl) > ! && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl))) > ! add_AT_flag (old_die, DW_AT_artificial, 1); > } > > /* Helper function of premark_used_types() which gets called through > *************** gen_subprogram_die (tree decl, dw_die_re > *** 21901,21907 **** > if (old_die && old_die->die_parent == NULL) > add_child_die (context_die, old_die); > > ! if (old_die && get_AT_ref (old_die, DW_AT_abstract_origin)) > { > /* If we have a DW_AT_abstract_origin we have a working > cached version. */ > --- 22124,22135 ---- > if (old_die && old_die->die_parent == NULL) > add_child_die (context_die, old_die); > > ! dw_die_ref c; > ! if (old_die > ! && (c = get_AT_ref (old_die, DW_AT_abstract_origin)) > ! /* ??? In LTO all origin DIEs still refer to the early > ! debug copy. Detect that. */ > ! && get_AT (c, DW_AT_inline)) > { > /* If we have a DW_AT_abstract_origin we have a working > cached version. */ > *************** gen_subprogram_die (tree decl, dw_die_re > *** 21969,21975 **** > || (old_die->die_parent > && old_die->die_parent->die_tag == DW_TAG_module) > || context_die == NULL) > ! && (DECL_ARTIFICIAL (decl) > || (get_AT_file (old_die, DW_AT_decl_file) == file_index > && (get_AT_unsigned (old_die, DW_AT_decl_line) > == (unsigned) s.line) > --- 22197,22204 ---- > || (old_die->die_parent > && old_die->die_parent->die_tag == DW_TAG_module) > || context_die == NULL) > ! /* ??? In LTO we do not see any of the location attributes. */ > ! && ((DECL_ARTIFICIAL (decl) || in_lto_p) > || (get_AT_file (old_die, DW_AT_decl_file) == file_index > && (get_AT_unsigned (old_die, DW_AT_decl_line) > == (unsigned) s.line) > *************** gen_variable_die (tree decl, tree origin > *** 22836,22841 **** > --- 23065,23088 ---- > /* If a DIE was dumped early, it still needs location info. > Skip to where we fill the location bits. */ > var_die = old_die; > + > + /* ??? In LTRANS we cannot annotate early created variably > + modified type DIEs without copying them and adjusting all > + references to them. Thus we dumped them again, also add a > + reference to them. */ > + tree type = TREE_TYPE (decl_or_origin); > + if (in_lto_p > + && variably_modified_type_p > + (type, decl_function_context (decl_or_origin))) > + { > + if (decl_by_reference_p (decl_or_origin)) > + add_type_attribute (var_die, TREE_TYPE (type), > + TYPE_UNQUALIFIED, false, context_die); > + else > + add_type_attribute (var_die, type, decl_quals (decl_or_origin), > + false, context_die); > + } > + > goto gen_variable_die_location; > } > } > *************** gen_inlined_subroutine_die (tree stmt, d > *** 23236,23247 **** > gcc_checking_assert (DECL_ABSTRACT_P (decl) > || cgraph_function_possibly_inlined_p (decl)); > > - /* Emit info for the abstract instance first, if we haven't yet. We > - must emit this even if the block is abstract, otherwise when we > - emit the block below (or elsewhere), we may end up trying to emit > - a die whose origin die hasn't been emitted, and crashing. */ > - dwarf2out_abstract_function (decl); > - > if (! BLOCK_ABSTRACT (stmt)) > { > dw_die_ref subr_die > --- 23483,23488 ---- > *************** process_scope_var (tree stmt, tree decl, > *** 24868,24874 **** > stmt, context_die); > } > else > ! gen_decl_die (decl, origin, NULL, context_die); > } > > /* Generate all of the decls declared within a given scope and (recursively) > --- 25109,25128 ---- > stmt, context_die); > } > else > ! { > ! if (decl && DECL_P (decl)) > ! { > ! die = lookup_decl_die (decl); > ! > ! /* Early created DIEs do not have a parent as the decls refer > ! to the function as DECL_CONTEXT rather than the BLOCK. */ > ! if (in_lto_p > ! && die && die->die_parent == NULL) > ! add_child_die (context_die, die); > ! } > ! > ! gen_decl_die (decl, origin, NULL, context_die); > ! } > } > > /* Generate all of the decls declared within a given scope and (recursively) > *************** gen_decl_die (tree decl, tree origin, st > *** 25288,25295 **** > ? DECL_ORIGIN (origin) > : DECL_ABSTRACT_ORIGIN (decl)); > > ! /* If we're emitting an out-of-line copy of an inline function, > ! emit info for the abstract instance and set up to refer to it. */ > else if (cgraph_function_possibly_inlined_p (decl) > && ! DECL_ABSTRACT_P (decl) > && ! class_or_namespace_scope_p (context_die) > --- 25542,25549 ---- > ? DECL_ORIGIN (origin) > : DECL_ABSTRACT_ORIGIN (decl)); > > ! /* If we're emitting a possibly inlined function emit it as > ! abstract instance. */ > else if (cgraph_function_possibly_inlined_p (decl) > && ! DECL_ABSTRACT_P (decl) > && ! class_or_namespace_scope_p (context_die) > *************** gen_decl_die (tree decl, tree origin, st > *** 25303,25309 **** > } > > /* Otherwise we're emitting the primary DIE for this decl. */ > ! else if (debug_info_level > DINFO_LEVEL_TERSE) > { > /* Before we describe the FUNCTION_DECL itself, make sure that we > have its containing type. */ > --- 25557,25565 ---- > } > > /* Otherwise we're emitting the primary DIE for this decl. */ > ! else if (debug_info_level > DINFO_LEVEL_TERSE > ! /* Do not generate stray type DIEs in late LTO dumping. */ > ! && early_dwarf) > { > /* Before we describe the FUNCTION_DECL itself, make sure that we > have its containing type. */ > *************** gen_decl_die (tree decl, tree origin, st > *** 25370,25389 **** > if (debug_info_level <= DINFO_LEVEL_TERSE) > break; > > ! /* Output any DIEs that are needed to specify the type of this data > ! object. */ > ! if (decl_by_reference_p (decl_or_origin)) > ! gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die); > ! else > ! gen_type_die (TREE_TYPE (decl_or_origin), context_die); > > ! /* And its containing type. */ > ! class_origin = decl_class_context (decl_or_origin); > ! if (class_origin != NULL_TREE) > ! gen_type_die_for_member (class_origin, decl_or_origin, context_die); > > ! /* And its containing namespace. */ > ! context_die = declare_in_namespace (decl_or_origin, context_die); > > /* Now output the DIE to represent the data object itself. This gets > complicated because of the possibility that the VAR_DECL really > --- 25626,25661 ---- > if (debug_info_level <= DINFO_LEVEL_TERSE) > break; > > ! /* Avoid generating stray type DIEs during late dwarf dumping. > ! All types have been dumped early. */ > ! if (! lookup_decl_die (decl_or_origin) > ! /* ??? But in LTRANS we cannot annotate early created variably > ! modified type DIEs without copying them and adjusting all > ! references to them. Dump them again as happens for inlining > ! which copies both the decl and the types. */ > ! /* ??? And even non-LTO needs to re-visit type DIEs to fill > ! in VLA bound information for example. */ > ! || (decl && variably_modified_type_p (TREE_TYPE (decl), > ! current_function_decl))) > ! { > ! /* Output any DIEs that are needed to specify the type of this data > ! object. */ > ! if (decl_by_reference_p (decl_or_origin)) > ! gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die); > ! else > ! gen_type_die (TREE_TYPE (decl_or_origin), context_die); > ! } > > ! if (early_dwarf) > ! { > ! /* And its containing type. */ > ! class_origin = decl_class_context (decl_or_origin); > ! if (class_origin != NULL_TREE) > ! gen_type_die_for_member (class_origin, decl_or_origin, context_die); > > ! /* And its containing namespace. */ > ! context_die = declare_in_namespace (decl_or_origin, context_die); > ! } > > /* Now output the DIE to represent the data object itself. This gets > complicated because of the possibility that the VAR_DECL really > *************** gen_decl_die (tree decl, tree origin, st > *** 25413,25422 **** > break; > > case PARM_DECL: > ! if (DECL_BY_REFERENCE (decl_or_origin)) > ! gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die); > ! else > ! gen_type_die (TREE_TYPE (decl_or_origin), context_die); > return gen_formal_parameter_die (decl, origin, > true /* Emit name attribute. */, > context_die); > --- 25685,25707 ---- > break; > > case PARM_DECL: > ! /* Avoid generating stray type DIEs during late dwarf dumping. > ! All types have been dumped early. */ > ! if (! lookup_decl_die (decl_or_origin) > ! /* ??? But in LTRANS we cannot annotate early created variably > ! modified type DIEs without copying them and adjusting all > ! references to them. Dump them again as happens for inlining > ! which copies both the decl and the types. */ > ! /* ??? And even non-LTO needs to re-visit type DIEs to fill > ! in VLA bound information for example. */ > ! || (decl && variably_modified_type_p (TREE_TYPE (decl), > ! current_function_decl))) > ! { > ! if (DECL_BY_REFERENCE (decl_or_origin)) > ! gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die); > ! else > ! gen_type_die (TREE_TYPE (decl_or_origin), context_die); > ! } > return gen_formal_parameter_die (decl, origin, > true /* Emit name attribute. */, > context_die); > *************** dwarf2out_early_global_decl (tree decl) > *** 25493,25498 **** > --- 25778,25793 ---- > dwarf2out_decl (context); > } > > + /* Emit an abstract origin of a function first. This happens > + with C++ constructor clones for example and makes > + dwarf2out_abstract_function happy which requires the early > + DIE of the abstract instance to be present. */ > + if (DECL_ABSTRACT_ORIGIN (decl)) > + { > + current_function_decl = DECL_ABSTRACT_ORIGIN (decl); > + dwarf2out_decl (DECL_ABSTRACT_ORIGIN (decl)); > + } > + > current_function_decl = decl; > } > dwarf2out_decl (decl); > *************** dwarf2out_late_global_decl (tree decl) > *** 25515,25521 **** > { > dw_die_ref die = lookup_decl_die (decl); > > ! /* We have to generate early debug late for LTO. */ > if (! die && in_lto_p) > { > dwarf2out_decl (decl); > --- 25810,25818 ---- > { > dw_die_ref die = lookup_decl_die (decl); > > ! /* We may have to generate early debug late for LTO in case debug > ! was not enabled at compile-time or the target doesn't support > ! the LTO early debug scheme. */ > if (! die && in_lto_p) > { > dwarf2out_decl (decl); > *************** output_macinfo_op (macinfo_entry *ref) > *** 26892,26898 **** > case DW_MACRO_import: > dw2_asm_output_data (1, ref->code, "Import"); > ASM_GENERATE_INTERNAL_LABEL (label, > ! DEBUG_MACRO_SECTION_LABEL, ref->lineno); > dw2_asm_output_offset (DWARF_OFFSET_SIZE, label, NULL, NULL); > break; > default: > --- 27189,27196 ---- > case DW_MACRO_import: > dw2_asm_output_data (1, ref->code, "Import"); > ASM_GENERATE_INTERNAL_LABEL (label, > ! DEBUG_MACRO_SECTION_LABEL, > ! ref->lineno + macinfo_label_base); > dw2_asm_output_offset (DWARF_OFFSET_SIZE, label, NULL, NULL); > break; > default: > *************** save_macinfo_strings (void) > *** 27066,27072 **** > /* Output macinfo section(s). */ > > static void > ! output_macinfo (void) > { > unsigned i; > unsigned long length = vec_safe_length (macinfo_table); > --- 27364,27370 ---- > /* Output macinfo section(s). */ > > static void > ! output_macinfo (const char *debug_line_label, bool early_lto_debug) > { > unsigned i; > unsigned long length = vec_safe_length (macinfo_table); > *************** output_macinfo (void) > *** 27092,27100 **** > dw2_asm_output_data (1, 3, "Flags: 64-bit, lineptr present"); > else > dw2_asm_output_data (1, 2, "Flags: 32-bit, lineptr present"); > ! dw2_asm_output_offset (DWARF_OFFSET_SIZE, > ! (!dwarf_split_debug_info ? debug_line_section_label > ! : debug_skeleton_line_section_label), > debug_line_section, NULL); > } > > --- 27390,27396 ---- > dw2_asm_output_data (1, 3, "Flags: 64-bit, lineptr present"); > else > dw2_asm_output_data (1, 2, "Flags: 32-bit, lineptr present"); > ! dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_line_label, > debug_line_section, NULL); > } > > *************** output_macinfo (void) > *** 27148,27153 **** > --- 27444,27453 ---- > if (!macinfo_htab) > return; > > + /* Save the number of transparent includes so we can adjust the > + label number for the fat LTO object DWARF. */ > + unsigned macinfo_label_base_adj = macinfo_htab->elements (); > + > delete macinfo_htab; > macinfo_htab = NULL; > > *************** output_macinfo (void) > *** 27167,27177 **** > dw2_asm_output_data (1, 0, "End compilation unit"); > targetm.asm_out.named_section (debug_macinfo_section_name, > SECTION_DEBUG > ! | SECTION_LINKONCE, > comdat_key); > ASM_GENERATE_INTERNAL_LABEL (label, > DEBUG_MACRO_SECTION_LABEL, > ! ref->lineno); > ASM_OUTPUT_LABEL (asm_out_file, label); > ref->code = 0; > ref->info = NULL; > --- 27467,27479 ---- > dw2_asm_output_data (1, 0, "End compilation unit"); > targetm.asm_out.named_section (debug_macinfo_section_name, > SECTION_DEBUG > ! | SECTION_LINKONCE > ! | (early_lto_debug > ! ? SECTION_EXCLUDE : 0), > comdat_key); > ASM_GENERATE_INTERNAL_LABEL (label, > DEBUG_MACRO_SECTION_LABEL, > ! ref->lineno + macinfo_label_base); > ASM_OUTPUT_LABEL (asm_out_file, label); > ref->code = 0; > ref->info = NULL; > *************** output_macinfo (void) > *** 27192,27300 **** > default: > gcc_unreachable (); > } > } > > ! /* Initialize the various sections and labels for dwarf output. */ > > static void > ! init_sections_and_labels (void) > { > ! if (!dwarf_split_debug_info) > { > ! debug_info_section = get_section (DEBUG_INFO_SECTION, > ! SECTION_DEBUG, NULL); > ! debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION, > ! SECTION_DEBUG, NULL); > ! debug_loc_section = get_section (dwarf_version >= 5 > ! ? DEBUG_LOCLISTS_SECTION > ! : DEBUG_LOC_SECTION, > ! SECTION_DEBUG, NULL); > ! debug_macinfo_section_name > ! = (dwarf_strict && dwarf_version < 5) > ! ? DEBUG_MACINFO_SECTION : DEBUG_MACRO_SECTION; > ! debug_macinfo_section = get_section (debug_macinfo_section_name, > ! SECTION_DEBUG, NULL); > } > else > { > ! debug_info_section = get_section (DEBUG_DWO_INFO_SECTION, > ! SECTION_DEBUG | SECTION_EXCLUDE, NULL); > ! debug_abbrev_section = get_section (DEBUG_DWO_ABBREV_SECTION, > ! SECTION_DEBUG | SECTION_EXCLUDE, > ! NULL); > ! debug_addr_section = get_section (DEBUG_ADDR_SECTION, > ! SECTION_DEBUG, NULL); > ! debug_skeleton_info_section = get_section (DEBUG_INFO_SECTION, > ! SECTION_DEBUG, NULL); > ! debug_skeleton_abbrev_section = get_section (DEBUG_ABBREV_SECTION, > ! SECTION_DEBUG, NULL); > ! ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label, > ! DEBUG_SKELETON_ABBREV_SECTION_LABEL, 0); > ! > ! /* Somewhat confusing detail: The skeleton_[abbrev|info] sections stay in > ! the main .o, but the skeleton_line goes into the split off dwo. */ > ! debug_skeleton_line_section > ! = get_section (DEBUG_DWO_LINE_SECTION, > ! SECTION_DEBUG | SECTION_EXCLUDE, NULL); > ! ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label, > ! DEBUG_SKELETON_LINE_SECTION_LABEL, 0); > ! debug_str_offsets_section = get_section (DEBUG_DWO_STR_OFFSETS_SECTION, > ! SECTION_DEBUG | SECTION_EXCLUDE, > ! NULL); > ! ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label, > ! DEBUG_SKELETON_INFO_SECTION_LABEL, 0); > ! debug_loc_section = get_section (dwarf_version >= 5 > ! ? DEBUG_DWO_LOCLISTS_SECTION > ! : DEBUG_DWO_LOC_SECTION, > ! SECTION_DEBUG | SECTION_EXCLUDE, NULL); > ! debug_str_dwo_section = get_section (DEBUG_STR_DWO_SECTION, > ! DEBUG_STR_DWO_SECTION_FLAGS, NULL); > ! debug_macinfo_section_name > ! = (dwarf_strict && dwarf_version < 5) > ! ? DEBUG_DWO_MACINFO_SECTION : DEBUG_DWO_MACRO_SECTION; > ! debug_macinfo_section = get_section (debug_macinfo_section_name, > SECTION_DEBUG | SECTION_EXCLUDE, > NULL); > ! } > ! debug_aranges_section = get_section (DEBUG_ARANGES_SECTION, > ! SECTION_DEBUG, NULL); > ! debug_line_section = get_section (DEBUG_LINE_SECTION, > ! SECTION_DEBUG, NULL); > ! debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION, > ! SECTION_DEBUG, NULL); > ! debug_pubtypes_section = get_section (DEBUG_PUBTYPES_SECTION, > SECTION_DEBUG, NULL); > ! debug_str_section = get_section (DEBUG_STR_SECTION, > ! DEBUG_STR_SECTION_FLAGS, NULL); > ! if (!dwarf_split_debug_info && !DWARF2_ASM_LINE_DEBUG_INFO) > ! debug_line_str_section = get_section (DEBUG_LINE_STR_SECTION, > ! DEBUG_STR_SECTION_FLAGS, NULL); > ! > ! debug_ranges_section = get_section (dwarf_version >= 5 > ! ? DEBUG_RNGLISTS_SECTION > ! : DEBUG_RANGES_SECTION, > ! SECTION_DEBUG, NULL); > ! debug_frame_section = get_section (DEBUG_FRAME_SECTION, > ! SECTION_DEBUG, NULL); > > ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label, > ! DEBUG_ABBREV_SECTION_LABEL, 0); > ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label, > ! DEBUG_INFO_SECTION_LABEL, 0); > ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label, > ! DEBUG_LINE_SECTION_LABEL, 0); > ASM_GENERATE_INTERNAL_LABEL (ranges_section_label, > ! DEBUG_RANGES_SECTION_LABEL, 0); > if (dwarf_version >= 5 && dwarf_split_debug_info) > ASM_GENERATE_INTERNAL_LABEL (ranges_base_label, > ! DEBUG_RANGES_SECTION_LABEL, 1); > ASM_GENERATE_INTERNAL_LABEL (debug_addr_section_label, > ! DEBUG_ADDR_SECTION_LABEL, 0); > ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label, > (dwarf_strict && dwarf_version < 5) > ? DEBUG_MACINFO_SECTION_LABEL > ! : DEBUG_MACRO_SECTION_LABEL, 0); > ! ASM_GENERATE_INTERNAL_LABEL (loc_section_label, DEBUG_LOC_SECTION_LABEL, 0); > } > > /* Set up for Dwarf output at the start of compilation. */ > --- 27494,27685 ---- > default: > gcc_unreachable (); > } > + > + macinfo_label_base += macinfo_label_base_adj; > } > > ! /* Initialize the various sections and labels for dwarf output and prefix > ! them with PREFIX if non-NULL. */ > > static void > ! init_sections_and_labels (bool early_lto_debug) > { > ! /* As we may get called multiple times have a generation count for labels. */ > ! static unsigned generation = 0; > ! > ! if (early_lto_debug) > { > ! if (!dwarf_split_debug_info) > ! { > ! debug_info_section = get_section (DEBUG_LTO_INFO_SECTION, > ! SECTION_DEBUG | SECTION_EXCLUDE, > ! NULL); > ! debug_abbrev_section = get_section (DEBUG_LTO_ABBREV_SECTION, > ! SECTION_DEBUG | SECTION_EXCLUDE, > ! NULL); > ! debug_macinfo_section_name = ((dwarf_strict && dwarf_version < 5) > ! ? DEBUG_LTO_MACINFO_SECTION > ! : DEBUG_LTO_MACRO_SECTION); > ! debug_macinfo_section = get_section (debug_macinfo_section_name, > ! SECTION_DEBUG > ! | SECTION_EXCLUDE, NULL); > ! /* For macro info we have to refer to a debug_line section, so similar > ! to split-dwarf emit a skeleton one for early debug. */ > ! debug_skeleton_line_section > ! = get_section (DEBUG_LTO_LINE_SECTION, > ! SECTION_DEBUG | SECTION_EXCLUDE, NULL); > ! ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label, > ! DEBUG_SKELETON_LINE_SECTION_LABEL, > ! generation); > ! } > ! else > ! { > ! /* ??? Which of the following do we need early? */ > ! debug_info_section = get_section (DEBUG_LTO_DWO_INFO_SECTION, > ! SECTION_DEBUG | SECTION_EXCLUDE, > ! NULL); > ! debug_abbrev_section = get_section (DEBUG_LTO_DWO_ABBREV_SECTION, > ! SECTION_DEBUG | SECTION_EXCLUDE, > ! NULL); > ! debug_skeleton_info_section = get_section (DEBUG_LTO_INFO_SECTION, > ! SECTION_DEBUG > ! | SECTION_EXCLUDE, NULL); > ! debug_skeleton_abbrev_section = get_section (DEBUG_LTO_ABBREV_SECTION, > ! SECTION_DEBUG > ! | SECTION_EXCLUDE, NULL); > ! ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label, > ! DEBUG_SKELETON_ABBREV_SECTION_LABEL, > ! generation); > ! > ! /* Somewhat confusing detail: The skeleton_[abbrev|info] sections stay in > ! the main .o, but the skeleton_line goes into the split off dwo. */ > ! debug_skeleton_line_section > ! = get_section (DEBUG_LTO_LINE_SECTION, > ! SECTION_DEBUG | SECTION_EXCLUDE, NULL); > ! ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label, > ! DEBUG_SKELETON_LINE_SECTION_LABEL, > ! generation); > ! debug_str_offsets_section > ! = get_section (DEBUG_LTO_DWO_STR_OFFSETS_SECTION, > ! SECTION_DEBUG | SECTION_EXCLUDE, > ! NULL); > ! ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label, > ! DEBUG_SKELETON_INFO_SECTION_LABEL, > ! generation); > ! debug_str_dwo_section = get_section (DEBUG_LTO_STR_DWO_SECTION, > ! DEBUG_STR_DWO_SECTION_FLAGS, NULL); > ! debug_macinfo_section_name > ! = (dwarf_strict > ! ? DEBUG_LTO_DWO_MACINFO_SECTION : DEBUG_LTO_DWO_MACRO_SECTION); > ! debug_macinfo_section = get_section (debug_macinfo_section_name, > ! SECTION_DEBUG | SECTION_EXCLUDE, > ! NULL); > ! } > ! debug_str_section = get_section (DEBUG_LTO_STR_SECTION, > ! DEBUG_STR_SECTION_FLAGS > ! | SECTION_EXCLUDE, NULL); > } > else > { > ! if (!dwarf_split_debug_info) > ! { > ! debug_info_section = get_section (DEBUG_INFO_SECTION, > ! SECTION_DEBUG, NULL); > ! debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION, > ! SECTION_DEBUG, NULL); > ! debug_loc_section = get_section (DEBUG_LOC_SECTION, > ! SECTION_DEBUG, NULL); > ! debug_macinfo_section_name > ! = dwarf_strict ? DEBUG_MACINFO_SECTION : DEBUG_MACRO_SECTION; > ! debug_macinfo_section = get_section (debug_macinfo_section_name, > ! SECTION_DEBUG, NULL); > ! } > ! else > ! { > ! debug_info_section = get_section (DEBUG_DWO_INFO_SECTION, > ! SECTION_DEBUG | SECTION_EXCLUDE, > ! NULL); > ! debug_abbrev_section = get_section (DEBUG_DWO_ABBREV_SECTION, > ! SECTION_DEBUG | SECTION_EXCLUDE, > ! NULL); > ! debug_addr_section = get_section (DEBUG_ADDR_SECTION, > ! SECTION_DEBUG, NULL); > ! debug_skeleton_info_section = get_section (DEBUG_INFO_SECTION, > ! SECTION_DEBUG, NULL); > ! debug_skeleton_abbrev_section = get_section (DEBUG_ABBREV_SECTION, > ! SECTION_DEBUG, NULL); > ! ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label, > ! DEBUG_SKELETON_ABBREV_SECTION_LABEL, > ! generation); > ! > ! /* Somewhat confusing detail: The skeleton_[abbrev|info] sections > ! stay in the main .o, but the skeleton_line goes into the > ! split off dwo. */ > ! debug_skeleton_line_section > ! = get_section (DEBUG_DWO_LINE_SECTION, > ! SECTION_DEBUG | SECTION_EXCLUDE, NULL); > ! ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label, > ! DEBUG_SKELETON_LINE_SECTION_LABEL, > ! generation); > ! debug_str_offsets_section > ! = get_section (DEBUG_DWO_STR_OFFSETS_SECTION, > ! SECTION_DEBUG | SECTION_EXCLUDE, NULL); > ! ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label, > ! DEBUG_SKELETON_INFO_SECTION_LABEL, > ! generation); > ! debug_loc_section = get_section (DEBUG_DWO_LOC_SECTION, > SECTION_DEBUG | SECTION_EXCLUDE, > NULL); > ! debug_str_dwo_section = get_section (DEBUG_STR_DWO_SECTION, > ! DEBUG_STR_DWO_SECTION_FLAGS, > ! NULL); > ! debug_macinfo_section_name > ! = (dwarf_strict && dwarf_version < 5) > ! ? DEBUG_DWO_MACINFO_SECTION : DEBUG_DWO_MACRO_SECTION; > ! debug_macinfo_section = get_section (debug_macinfo_section_name, > ! SECTION_DEBUG | SECTION_EXCLUDE, > ! NULL); > ! } > ! debug_aranges_section = get_section (DEBUG_ARANGES_SECTION, > ! SECTION_DEBUG, NULL); > ! debug_line_section = get_section (DEBUG_LINE_SECTION, > SECTION_DEBUG, NULL); > ! debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION, > ! SECTION_DEBUG, NULL); > ! debug_pubtypes_section = get_section (DEBUG_PUBTYPES_SECTION, > ! SECTION_DEBUG, NULL); > ! debug_str_section = get_section (DEBUG_STR_SECTION, > ! DEBUG_STR_SECTION_FLAGS, NULL); > ! debug_ranges_section = get_section (dwarf_version >= 5 > ! ? DEBUG_RNGLISTS_SECTION > ! : DEBUG_RANGES_SECTION, > ! SECTION_DEBUG, NULL); > ! debug_frame_section = get_section (DEBUG_FRAME_SECTION, > ! SECTION_DEBUG, NULL); > ! } > > ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label, > ! DEBUG_ABBREV_SECTION_LABEL, generation); > ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label, > ! DEBUG_INFO_SECTION_LABEL, generation); > ! info_section_emitted = false; > ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label, > ! DEBUG_LINE_SECTION_LABEL, generation); > ASM_GENERATE_INTERNAL_LABEL (ranges_section_label, > ! DEBUG_RANGES_SECTION_LABEL, generation); > if (dwarf_version >= 5 && dwarf_split_debug_info) > ASM_GENERATE_INTERNAL_LABEL (ranges_base_label, > ! DEBUG_RANGES_SECTION_LABEL, 2 + generation); > ASM_GENERATE_INTERNAL_LABEL (debug_addr_section_label, > ! DEBUG_ADDR_SECTION_LABEL, generation); > ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label, > (dwarf_strict && dwarf_version < 5) > ? DEBUG_MACINFO_SECTION_LABEL > ! : DEBUG_MACRO_SECTION_LABEL, generation); > ! ASM_GENERATE_INTERNAL_LABEL (loc_section_label, DEBUG_LOC_SECTION_LABEL, > ! generation); > ! > ! ++generation; > } > > /* Set up for Dwarf output at the start of compilation. */ > *************** flush_limbo_die_list (void) > *** 29641,29646 **** > --- 30026,30047 ---- > } > } > > + /* Reset DIEs so we can output them again. */ > + > + static void > + reset_dies (dw_die_ref die) > + { > + dw_die_ref c; > + > + /* Remove stuff we re-generate. */ > + die->die_mark = 0; > + die->die_offset = 0; > + die->die_abbrev = 0; > + remove_AT (die, DW_AT_sibling); > + > + FOR_EACH_CHILD (die, c, reset_dies (c)); > + } > + > /* Output stuff that dwarf requires at the end of every file, > and generate the DWARF-2 debugging info. */ > > *************** dwarf2out_finish (const char *) > *** 29667,29672 **** > --- 30068,30113 ---- > > gen_remaining_tmpl_value_param_die_attribute (); > > + if (flag_generate_lto) > + { > + gcc_assert (flag_fat_lto_objects); > + > + /* Prune stuff so that dwarf2out_finish runs successfully > + for the fat part of the object. */ > + reset_dies (comp_unit_die ()); > + for (limbo_die_node *node = cu_die_list; node; node = node->next) > + reset_dies (node->die); > + > + hash_table comdat_type_table (100); > + for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next) > + { > + comdat_type_node **slot > + = comdat_type_table.find_slot (ctnode, INSERT); > + > + /* Don't reset types twice. */ > + if (*slot != HTAB_EMPTY_ENTRY) > + continue; > + > + /* Add a pointer to the line table for the main compilation unit > + so that the debugger can make sense of DW_AT_decl_file > + attributes. */ > + if (debug_info_level >= DINFO_LEVEL_TERSE) > + reset_dies (ctnode->root_die); > + > + *slot = ctnode; > + } > + > + /* Reset die CU symbol so we don't output it twice. */ > + comp_unit_die ()->die_id.die_symbol = NULL; > + > + /* Remove DW_AT_macro from the early output. */ > + if (have_macinfo) > + remove_AT (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE); > + > + /* Remove indirect string decisions. */ > + debug_str_hash->traverse (NULL); > + } > + > #if ENABLE_ASSERT_CHECKING > { > dw_die_ref die = comp_unit_die (), c; > *************** dwarf2out_finish (const char *) > *** 29677,29683 **** > move_marked_base_types (); > > /* Initialize sections and labels used for actual assembler output. */ > ! init_sections_and_labels (); > > /* Traverse the DIE's and add sibling attributes to those DIE's that > have children. */ > --- 30118,30124 ---- > move_marked_base_types (); > > /* Initialize sections and labels used for actual assembler output. */ > ! init_sections_and_labels (false); > > /* Traverse the DIE's and add sibling attributes to those DIE's that > have children. */ > *************** dwarf2out_finish (const char *) > *** 29772,29780 **** > debug_line_section_label); > > if (have_macinfo) > ! add_AT_macptr (comp_unit_die (), > ! dwarf_version >= 5 ? DW_AT_macros > ! : dwarf_strict ? DW_AT_macro_info : DW_AT_GNU_macros, > macinfo_section_label); > > if (dwarf_split_debug_info) > --- 30213,30219 ---- > debug_line_section_label); > > if (have_macinfo) > ! add_AT_macptr (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE, > macinfo_section_label); > > if (dwarf_split_debug_info) > *************** dwarf2out_finish (const char *) > *** 29979,29985 **** > { > switch_to_section (debug_macinfo_section); > ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label); > ! output_macinfo (); > dw2_asm_output_data (1, 0, "End compilation unit"); > } > > --- 30418,30425 ---- > { > switch_to_section (debug_macinfo_section); > ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label); > ! output_macinfo (!dwarf_split_debug_info ? debug_line_section_label > ! : debug_skeleton_line_section_label, false); > dw2_asm_output_data (1, 0, "End compilation unit"); > } > > *************** note_variable_value_in_expr (dw_die_ref > *** 30200,30205 **** > --- 30640,30659 ---- > { > tree decl = loc->dw_loc_oprnd1.v.val_decl_ref; > dw_die_ref ref = lookup_decl_die (decl); > + if (! ref && flag_generate_lto) > + { > + /* ??? This is somewhat a hack because we do not create DIEs > + for variables not in BLOCK trees early but when generating > + early LTO output we need the dw_val_class_decl_ref to be > + fully resolved. For fat LTO objects we'd also like to > + undo this after LTO dwarf output. */ > + gcc_assert (DECL_CONTEXT (decl)); > + dw_die_ref ctx = lookup_decl_die (DECL_CONTEXT (decl)); > + gcc_assert (ctx != NULL); > + gen_decl_die (decl, NULL_TREE, NULL, ctx); > + ref = lookup_decl_die (decl); > + gcc_assert (ref != NULL); > + } > if (ref) > { > loc->dw_loc_oprnd1.val_class = dw_val_class_die_ref; > *************** dwarf2out_early_finish (const char *file > *** 30410,30415 **** > --- 30864,30982 ---- > > /* The early debug phase is now finished. */ > early_dwarf_finished = true; > + > + /* Do not generate DWARF assembler now when not producing LTO bytecode. */ > + if (!flag_generate_lto) > + return; > + > + /* Now as we are going to output for LTO initialize sections and labels > + to the LTO variants. We don't need a random-seed postfix as other > + LTO sections as linking the LTO debug sections into one in a partial > + link is fine. */ > + init_sections_and_labels (true); > + > + /* The output below is modeled after dwarf2out_finish with all > + location related output removed and some LTO specific changes. > + Some refactoring might make both smaller and easier to match up. */ > + > + /* Traverse the DIE's and add add sibling attributes to those DIE's > + that have children. */ > + add_sibling_attributes (comp_unit_die ()); > + for (limbo_die_node *node = limbo_die_list; node; node = node->next) > + add_sibling_attributes (node->die); > + for (comdat_type_node *ctnode = comdat_type_list; > + ctnode != NULL; ctnode = ctnode->next) > + add_sibling_attributes (ctnode->root_die); > + > + if (have_macinfo) > + add_AT_macptr (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE, > + macinfo_section_label); > + > + save_macinfo_strings (); > + > + /* Output all of the compilation units. We put the main one last so that > + the offsets are available to output_pubnames. */ > + for (limbo_die_node *node = limbo_die_list; node; node = node->next) > + output_comp_unit (node->die, 0, NULL); > + > + hash_table comdat_type_table (100); > + for (comdat_type_node *ctnode = comdat_type_list; > + ctnode != NULL; ctnode = ctnode->next) > + { > + comdat_type_node **slot = comdat_type_table.find_slot (ctnode, INSERT); > + > + /* Don't output duplicate types. */ > + if (*slot != HTAB_EMPTY_ENTRY) > + continue; > + > + /* Add a pointer to the line table for the main compilation unit > + so that the debugger can make sense of DW_AT_decl_file > + attributes. */ > + if (debug_info_level >= DINFO_LEVEL_TERSE) > + add_AT_lineptr (ctnode->root_die, DW_AT_stmt_list, > + (!dwarf_split_debug_info > + ? debug_line_section_label > + : debug_skeleton_line_section_label)); > + > + output_comdat_type_unit (ctnode); > + *slot = ctnode; > + } > + > + /* The AT_pubnames attribute needs to go in all skeleton dies, including > + both the main_cu and all skeleton TUs. Making this call unconditional > + would end up either adding a second copy of the AT_pubnames attribute, or > + requiring a special case in add_top_level_skeleton_die_attrs. */ > + if (!dwarf_split_debug_info) > + add_AT_pubnames (comp_unit_die ()); > + > + /* Stick a unique symbol to the main debuginfo section. */ > + compute_section_prefix_1 (comp_unit_die (), false); > + > + /* Output the main compilation unit. We always need it if only for > + the CU symbol. */ > + output_comp_unit (comp_unit_die (), true, NULL); > + > + /* Output the abbreviation table. */ > + if (vec_safe_length (abbrev_die_table) != 1) > + { > + switch_to_section (debug_abbrev_section); > + ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label); > + output_abbrev_section (); > + } > + > + /* Have to end the macro section. */ > + if (have_macinfo) > + { > + /* We have to save macinfo state if we need to output it again > + for the FAT part of the object. */ > + vec *saved_macinfo_table = macinfo_table; > + if (flag_fat_lto_objects) > + macinfo_table = macinfo_table->copy (); > + > + switch_to_section (debug_macinfo_section); > + ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label); > + output_macinfo (debug_skeleton_line_section_label, true); > + dw2_asm_output_data (1, 0, "End compilation unit"); > + > + /* Emit a skeleton debug_line section. */ > + switch_to_section (debug_skeleton_line_section); > + ASM_OUTPUT_LABEL (asm_out_file, debug_skeleton_line_section_label); > + output_line_info (true); > + > + if (flag_fat_lto_objects) > + { > + vec_free (macinfo_table); > + macinfo_table = saved_macinfo_table; > + } > + } > + > + > + /* If we emitted any indirect strings, output the string table too. */ > + if (debug_str_hash || skeleton_debug_str_hash) > + output_indirect_strings (); > + > + /* Switch back to the text section. */ > + switch_to_section (text_section); > } > > /* Reset all state within dwarf2out.c so that we can rerun the compiler > Index: early-lto-debug/gcc/debug.h > =================================================================== > *** early-lto-debug.orig/gcc/debug.h 2017-05-16 13:10:47.554202813 +0200 > --- early-lto-debug/gcc/debug.h 2017-05-16 13:10:49.774239353 +0200 > *************** struct gcc_debug_hooks > *** 147,152 **** > --- 147,160 ---- > void (* imported_module_or_decl) (tree decl, tree name, > tree context, bool child); > > + /* Return true if a DIE for the tree is available and return a symbol > + and offset that can be used to refer to it externally. */ > + bool (* die_ref_for_decl) (tree, const char **, unsigned HOST_WIDE_INT *); > + > + /* Early debug information for the tree is available at symbol plus > + offset externally. */ > + void (* register_external_die) (tree, const char *, unsigned HOST_WIDE_INT); > + > /* DECL is an inline function, whose body is present, but which is > not being output at this point. */ > void (* deferred_inline_function) (tree decl); > *************** extern void debug_nothing_tree_tree_tree > *** 210,215 **** > --- 218,227 ---- > extern bool debug_true_const_tree (const_tree); > extern void debug_nothing_rtx_insn (rtx_insn *); > extern void debug_nothing_rtx_code_label (rtx_code_label *); > + extern bool debug_false_tree_charstarstar_uhwistar (tree, const char **, > + unsigned HOST_WIDE_INT *); > + extern void debug_nothing_tree_charstar_uhwi (tree, const char *, > + unsigned HOST_WIDE_INT); > > /* Hooks for various debug formats. */ > extern const struct gcc_debug_hooks do_nothing_debug_hooks; > Index: early-lto-debug/gcc/debug.c > =================================================================== > *** early-lto-debug.orig/gcc/debug.c 2017-05-16 13:10:47.554202813 +0200 > --- early-lto-debug/gcc/debug.c 2017-05-16 13:10:49.774239353 +0200 > *************** const struct gcc_debug_hooks do_nothing_ > *** 48,53 **** > --- 48,55 ---- > debug_nothing_tree, /* late_global_decl */ > debug_nothing_tree_int, /* type_decl */ > debug_nothing_tree_tree_tree_bool, /* imported_module_or_decl */ > + debug_false_tree_charstarstar_uhwistar, /* die_ref_for_decl */ > + debug_nothing_tree_charstar_uhwi, /* register_external_die */ > debug_nothing_tree, /* deferred_inline_function */ > debug_nothing_tree, /* outlining_inline_function */ > debug_nothing_rtx_code_label, /* label */ > *************** debug_nothing_tree_int (tree decl ATTRIB > *** 146,148 **** > --- 148,163 ---- > int local ATTRIBUTE_UNUSED) > { > } > + > + bool > + debug_false_tree_charstarstar_uhwistar (tree, const char **, > + unsigned HOST_WIDE_INT *) > + { > + return false; > + } > + > + void > + debug_nothing_tree_charstar_uhwi (tree, const char *, > + unsigned HOST_WIDE_INT) > + { > + } > Index: early-lto-debug/gcc/dbxout.c > =================================================================== > *** early-lto-debug.orig/gcc/dbxout.c 2017-05-16 13:10:47.554202813 +0200 > --- early-lto-debug/gcc/dbxout.c 2017-05-16 13:10:49.778239419 +0200 > *************** const struct gcc_debug_hooks dbx_debug_h > *** 372,377 **** > --- 372,379 ---- > dbxout_late_global_decl, /* late_global_decl */ > dbxout_type_decl, /* type_decl */ > debug_nothing_tree_tree_tree_bool, /* imported_module_or_decl */ > + debug_false_tree_charstarstar_uhwistar, /* die_ref_for_decl */ > + debug_nothing_tree_charstar_uhwi, /* register_external_die */ > debug_nothing_tree, /* deferred_inline_function */ > debug_nothing_tree, /* outlining_inline_function */ > debug_nothing_rtx_code_label, /* label */ > *************** const struct gcc_debug_hooks xcoff_debug > *** 412,417 **** > --- 414,421 ---- > dbxout_late_global_decl, /* late_global_decl */ > dbxout_type_decl, /* type_decl */ > debug_nothing_tree_tree_tree_bool, /* imported_module_or_decl */ > + debug_false_tree_charstarstar_uhwistar, /* die_ref_for_decl */ > + debug_nothing_tree_charstar_uhwi, /* register_external_die */ > debug_nothing_tree, /* deferred_inline_function */ > debug_nothing_tree, /* outlining_inline_function */ > debug_nothing_rtx_code_label, /* label */ > Index: early-lto-debug/gcc/sdbout.c > =================================================================== > *** early-lto-debug.orig/gcc/sdbout.c 2017-05-16 13:10:47.554202813 +0200 > --- early-lto-debug/gcc/sdbout.c 2017-05-16 13:10:49.778239419 +0200 > *************** const struct gcc_debug_hooks sdb_debug_h > *** 302,307 **** > --- 302,309 ---- > sdbout_late_global_decl, /* late_global_decl */ > sdbout_symbol, /* type_decl */ > debug_nothing_tree_tree_tree_bool, /* imported_module_or_decl */ > + debug_false_tree_charstarstar_uhwistar, /* die_ref_for_decl */ > + debug_nothing_tree_charstar_uhwi, /* register_external_die */ > debug_nothing_tree, /* deferred_inline_function */ > debug_nothing_tree, /* outlining_inline_function */ > sdbout_label, /* label */ > Index: early-lto-debug/gcc/lto/lto.c > =================================================================== > *** early-lto-debug.orig/gcc/lto/lto.c 2017-05-16 13:10:47.554202813 +0200 > --- early-lto-debug/gcc/lto/lto.c 2017-05-16 13:10:49.778239419 +0200 > *************** unify_scc (struct data_in *data_in, unsi > *** 1632,1637 **** > --- 1632,1640 ---- > free_node (scc->entries[i]); > } > > + /* Drop DIE references. */ > + dref_queue.truncate (0); > + > break; > } > > *************** lto_read_decls (struct lto_file_decl_dat > *** 1707,1714 **** > from); > if (len == 1 > && (TREE_CODE (first) == IDENTIFIER_NODE > ! || TREE_CODE (first) == INTEGER_CST > ! || TREE_CODE (first) == TRANSLATION_UNIT_DECL)) > continue; > > /* Try to unify the SCC with already existing ones. */ > --- 1710,1716 ---- > from); > if (len == 1 > && (TREE_CODE (first) == IDENTIFIER_NODE > ! || TREE_CODE (first) == INTEGER_CST)) > continue; > > /* Try to unify the SCC with already existing ones. */ > *************** lto_read_decls (struct lto_file_decl_dat > *** 1747,1762 **** > if (TREE_CODE (t) == INTEGER_CST > && !TREE_OVERFLOW (t)) > cache_integer_cst (t); > - /* Register TYPE_DECLs with the debuginfo machinery. */ > - if (!flag_wpa > - && TREE_CODE (t) == TYPE_DECL) > - { > - /* Dwarf2out needs location information. > - TODO: Moving this out of the streamer loop may noticealy > - improve ltrans linemap memory use. */ > - data_in->location_cache.apply_location_cache (); > - debug_hooks->type_decl (t, !DECL_FILE_SCOPE_P (t)); > - } > if (!flag_ltrans) > { > /* Register variables and functions with the > --- 1749,1754 ---- > *************** lto_read_decls (struct lto_file_decl_dat > *** 1772,1777 **** > --- 1764,1777 ---- > vec_safe_push (tree_with_vars, t); > } > } > + > + /* Register DECLs with the debuginfo machinery. */ > + while (!dref_queue.is_empty ()) > + { > + dref_entry e = dref_queue.pop (); > + debug_hooks->register_external_die (e.decl, e.sym, e.off); > + } > + > if (seen_type) > num_type_scc_trees += len; > } > *************** lto_section_with_id (const char *name, u > *** 1951,1957 **** > if (strncmp (name, section_name_prefix, strlen (section_name_prefix))) > return 0; > s = strrchr (name, '.'); > ! return s && sscanf (s, "." HOST_WIDE_INT_PRINT_HEX_PURE, id) == 1; > } > > /* Create file_data of each sub file id */ > --- 1951,1962 ---- > if (strncmp (name, section_name_prefix, strlen (section_name_prefix))) > return 0; > s = strrchr (name, '.'); > ! if (!s) > ! return 0; > ! /* If the section is not suffixed with an ID return. */ > ! if ((size_t)(s - name) == strlen (section_name_prefix)) > ! return 0; > ! return sscanf (s, "." HOST_WIDE_INT_PRINT_HEX_PURE, id) == 1; > } > > /* Create file_data of each sub file id */ > Index: early-lto-debug/gcc/lto-streamer-in.c > =================================================================== > *** early-lto-debug.orig/gcc/lto-streamer-in.c 2017-05-16 13:10:47.554202813 +0200 > --- early-lto-debug/gcc/lto-streamer-in.c 2017-05-16 13:10:49.858240736 +0200 > *************** along with GCC; see the file COPYING3. > *** 41,46 **** > --- 41,47 ---- > #include "except.h" > #include "cgraph.h" > #include "cfgloop.h" > + #include "debug.h" > > > struct freeing_string_slot_hasher : string_slot_hasher > *************** input_function (tree fn_decl, struct dat > *** 1038,1043 **** > --- 1039,1054 ---- > DECL_RESULT (fn_decl) = stream_read_tree (ib, data_in); > DECL_ARGUMENTS (fn_decl) = streamer_read_chain (ib, data_in); > > + /* Read debug args if available. */ > + unsigned n_debugargs = streamer_read_uhwi (ib); > + if (n_debugargs) > + { > + vec **debugargs = decl_debug_args_insert (fn_decl); > + vec_safe_grow (*debugargs, n_debugargs); > + for (unsigned i = 0; i < n_debugargs; ++i) > + (**debugargs)[i] = stream_read_tree (ib, data_in); > + } > + > /* Read the tree of lexical scopes for the function. */ > DECL_INITIAL (fn_decl) = stream_read_tree (ib, data_in); > unsigned block_leaf_count = streamer_read_uhwi (ib); > *************** lto_input_variable_constructor (struct l > *** 1318,1323 **** > --- 1329,1338 ---- > } > > > + /* Queue of acummulated decl -> DIE mappings. Similar to locations those > + are only applied to prevailing tree nodes during tree merging. */ > + vec dref_queue; > + > /* Read the physical representation of a tree node EXPR from > input block IB using the per-file context in DATA_IN. */ > > *************** lto_read_tree_1 (struct lto_input_block > *** 1337,1342 **** > --- 1352,1374 ---- > && TREE_CODE (expr) != FUNCTION_DECL > && TREE_CODE (expr) != TRANSLATION_UNIT_DECL) > DECL_INITIAL (expr) = stream_read_tree (ib, data_in); > + > + /* Stream references to early generated DIEs. Keep in sync with the > + trees handled in dwarf2out_register_external_die. */ > + if ((DECL_P (expr) > + && TREE_CODE (expr) != FIELD_DECL > + && TREE_CODE (expr) != DEBUG_EXPR_DECL > + && TREE_CODE (expr) != TYPE_DECL) > + || TREE_CODE (expr) == BLOCK) > + { > + const char *str = streamer_read_string (data_in, ib); > + if (str) > + { > + unsigned HOST_WIDE_INT off = streamer_read_uhwi (ib); > + dref_entry e = { expr, str, off }; > + dref_queue.safe_push (e); > + } > + } > } > > /* Read the physical representation of a tree node with tag TAG from > *************** lto_input_tree (struct lto_input_block * > *** 1482,1487 **** > --- 1514,1526 ---- > { > unsigned len, entry_len; > lto_input_scc (ib, data_in, &len, &entry_len); > + > + /* Register DECLs with the debuginfo machinery. */ > + while (!dref_queue.is_empty ()) > + { > + dref_entry e = dref_queue.pop (); > + debug_hooks->register_external_die (e.decl, e.sym, e.off); > + } > } > return lto_input_tree_1 (ib, data_in, tag, 0); > } > Index: early-lto-debug/gcc/lto-streamer-out.c > =================================================================== > *** early-lto-debug.orig/gcc/lto-streamer-out.c 2017-05-16 13:10:47.554202813 +0200 > --- early-lto-debug/gcc/lto-streamer-out.c 2017-05-16 13:10:49.858240736 +0200 > *************** along with GCC; see the file COPYING3. > *** 40,45 **** > --- 40,46 ---- > #include "cfgloop.h" > #include "builtins.h" > #include "gomp-constants.h" > + #include "debug.h" > > > static void lto_write_tree (struct output_block*, tree, bool); > *************** lto_write_tree_1 (struct output_block *o > *** 406,411 **** > --- 407,432 ---- > (ob->decl_state->symtab_node_encoder, expr); > stream_write_tree (ob, initial, ref_p); > } > + > + /* Stream references to early generated DIEs. Keep in sync with the > + trees handled in dwarf2out_die_ref_for_decl. */ > + if ((DECL_P (expr) > + && TREE_CODE (expr) != FIELD_DECL > + && TREE_CODE (expr) != DEBUG_EXPR_DECL > + && TREE_CODE (expr) != TYPE_DECL) > + || TREE_CODE (expr) == BLOCK) > + { > + const char *sym; > + unsigned HOST_WIDE_INT off; > + if (debug_info_level > DINFO_LEVEL_NONE > + && debug_hooks->die_ref_for_decl (expr, &sym, &off)) > + { > + streamer_write_string (ob, ob->main_stream, sym, true); > + streamer_write_uhwi (ob, off); > + } > + else > + streamer_write_string (ob, ob->main_stream, NULL, true); > + } > } > > /* Write a physical representation of tree node EXPR to output block > *************** DFS::DFS_write_tree_body (struct output_ > *** 745,751 **** > ; > else > DFS_follow_tree_edge (DECL_NAME (expr)); > ! DFS_follow_tree_edge (DECL_CONTEXT (expr)); > } > > if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) > --- 766,776 ---- > ; > else > DFS_follow_tree_edge (DECL_NAME (expr)); > ! if (TREE_CODE (expr) != TRANSLATION_UNIT_DECL > ! && ! DECL_CONTEXT (expr)) > ! DFS_follow_tree_edge ((*all_translation_units)[0]); > ! else > ! DFS_follow_tree_edge (DECL_CONTEXT (expr)); > } > > if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) > *************** DFS::DFS_write_tree_body (struct output_ > *** 765,770 **** > --- 790,796 ---- > declarations which should be eliminated by decl merging. Be sure none > leaks to this point. */ > gcc_assert (DECL_ABSTRACT_ORIGIN (expr) != error_mark_node); > + DFS_follow_tree_edge (DECL_ABSTRACT_ORIGIN (expr)); > > if ((VAR_P (expr) > || TREE_CODE (expr) == PARM_DECL) > *************** output_function (struct cgraph_node *nod > *** 2061,2066 **** > --- 2087,2103 ---- > stream_write_tree (ob, DECL_RESULT (function), true); > streamer_write_chain (ob, DECL_ARGUMENTS (function), true); > > + /* Output debug args if available. */ > + vec **debugargs = decl_debug_args_lookup (function); > + if (! debugargs) > + streamer_write_uhwi (ob, 0); > + else > + { > + streamer_write_uhwi (ob, (*debugargs)->length ()); > + for (unsigned i = 0; i < (*debugargs)->length (); ++i) > + stream_write_tree (ob, (**debugargs)[i], true); > + } > + > /* Output DECL_INITIAL for the function, which contains the tree of > lexical scopes. */ > stream_write_tree (ob, DECL_INITIAL (function), true); > Index: early-lto-debug/gcc/lto-streamer.h > =================================================================== > *** early-lto-debug.orig/gcc/lto-streamer.h 2017-05-16 13:10:47.554202813 +0200 > --- early-lto-debug/gcc/lto-streamer.h 2017-05-16 13:10:49.858240736 +0200 > *************** DEFINE_DECL_STREAM_FUNCS (TYPE_DECL, typ > *** 1212,1215 **** > --- 1212,1225 ---- > DEFINE_DECL_STREAM_FUNCS (NAMESPACE_DECL, namespace_decl) > DEFINE_DECL_STREAM_FUNCS (LABEL_DECL, label_decl) > > + /* Entry for the delayed registering of decl -> DIE references. */ > + struct dref_entry { > + tree decl; > + const char *sym; > + unsigned HOST_WIDE_INT off; > + }; > + > + extern vec dref_queue; > + > + > #endif /* GCC_LTO_STREAMER_H */ > Index: early-lto-debug/gcc/lto-wrapper.c > =================================================================== > *** early-lto-debug.orig/gcc/lto-wrapper.c 2017-05-16 13:10:47.554202813 +0200 > --- early-lto-debug/gcc/lto-wrapper.c 2017-05-16 13:10:49.858240736 +0200 > *************** static char **output_names; > *** 70,75 **** > --- 70,76 ---- > static char **offload_names; > static char *offload_objects_file_name; > static char *makefile; > + static char *debug_obj; > > const char tool_name[] = "lto-wrapper"; > > *************** tool_cleanup (bool) > *** 88,93 **** > --- 89,96 ---- > maybe_unlink (offload_objects_file_name); > if (makefile) > maybe_unlink (makefile); > + if (debug_obj) > + maybe_unlink (debug_obj); > for (i = 0; i < nr; ++i) > { > maybe_unlink (input_names[i]); > *************** find_and_merge_options (int fd, off_t fi > *** 938,943 **** > --- 941,1007 ---- > return true; > } > > + /* Copy early debug info sections from INFILE to a new file whose name > + is returned. Return NULL on error. */ > + > + const char * > + debug_objcopy (const char *infile) > + { > + const char *outfile; > + const char *errmsg; > + int err; > + > + const char *p; > + off_t inoff = 0; > + long loffset; > + int consumed; > + if ((p = strrchr (infile, '@')) > + && p != infile > + && sscanf (p, "@%li%n", &loffset, &consumed) >= 1 > + && strlen (p) == (unsigned int) consumed) > + { > + char *fname = xstrdup (infile); > + fname[p - infile] = '\0'; > + infile = fname; > + inoff = (off_t) loffset; > + } > + int infd = open (infile, O_RDONLY); > + if (infd == -1) > + return NULL; > + simple_object_read *inobj = simple_object_start_read (infd, inoff, > + "__GNU_LTO", > + &errmsg, &err); > + if (!inobj) > + return NULL; > + > + off_t off, len; > + if (simple_object_find_section (inobj, ".gnu.debuglto_.debug_info", > + &off, &len, &errmsg, &err) != 1) > + { > + if (errmsg) > + fatal_error (0, "%s: %s\n", errmsg, xstrerror (err)); > + > + simple_object_release_read (inobj); > + close (infd); > + return NULL; > + } > + > + outfile = make_temp_file ("debugobjtem"); > + errmsg = simple_object_copy_lto_debug_sections (inobj, outfile, &err); > + if (errmsg) > + { > + unlink_if_ordinary (outfile); > + fatal_error (0, "%s: %s\n", errmsg, xstrerror (err)); > + } > + > + simple_object_release_read (inobj); > + close (infd); > + > + return outfile; > + } > + > + > + > /* Execute gcc. ARGC is the number of arguments. ARGV contains the arguments. */ > > static void > *************** run_gcc (unsigned argc, char *argv[]) > *** 962,969 **** > int new_head_argc; > bool have_lto = false; > bool have_offload = false; > ! unsigned lto_argc = 0; > ! char **lto_argv; > > /* Get the driver and options. */ > collect_gcc = getenv ("COLLECT_GCC"); > --- 1026,1035 ---- > int new_head_argc; > bool have_lto = false; > bool have_offload = false; > ! unsigned lto_argc = 0, ltoobj_argc = 0; > ! char **lto_argv, **ltoobj_argv; > ! bool skip_debug = false; > ! unsigned n_debugobj; > > /* Get the driver and options. */ > collect_gcc = getenv ("COLLECT_GCC"); > *************** run_gcc (unsigned argc, char *argv[]) > *** 982,987 **** > --- 1048,1054 ---- > /* Allocate array for input object files with LTO IL, > and for possible preceding arguments. */ > lto_argv = XNEWVEC (char *, argc); > + ltoobj_argv = XNEWVEC (char *, argc); > > /* Look at saved options in the IL files. */ > for (i = 1; i < argc; ++i) > *************** run_gcc (unsigned argc, char *argv[]) > *** 1024,1030 **** > collect_gcc)) > { > have_lto = true; > ! lto_argv[lto_argc++] = argv[i]; > } > close (fd); > } > --- 1091,1097 ---- > collect_gcc)) > { > have_lto = true; > ! ltoobj_argv[ltoobj_argc++] = argv[i]; > } > close (fd); > } > *************** run_gcc (unsigned argc, char *argv[]) > *** 1085,1090 **** > --- 1152,1168 ---- > } > } > > + /* Output lto-wrapper invocation command. */ > + if (verbose) > + { > + for (i = 0; i < argc; ++i) > + { > + fputs (argv[i], stderr); > + fputc (' ', stderr); > + } > + fputc ('\n', stderr); > + } > + > if (no_partition) > { > lto_mode = LTO_MODE_LTO; > *************** cont1: > *** 1274,1291 **** > obstack_ptr_grow (&argv_obstack, "-fwpa"); > } > > ! /* Append the input objects and possible preceding arguments. */ > for (i = 0; i < lto_argc; ++i) > obstack_ptr_grow (&argv_obstack, lto_argv[i]); > obstack_ptr_grow (&argv_obstack, NULL); > > new_argv = XOBFINISH (&argv_obstack, const char **); > argv_ptr = &new_argv[new_head_argc]; > fork_execute (new_argv[0], CONST_CAST (char **, new_argv), true); > > if (lto_mode == LTO_MODE_LTO) > { > printf ("%s\n", flto_out); > free (flto_out); > flto_out = NULL; > } > --- 1352,1456 ---- > obstack_ptr_grow (&argv_obstack, "-fwpa"); > } > > ! /* Append input arguments. */ > for (i = 0; i < lto_argc; ++i) > obstack_ptr_grow (&argv_obstack, lto_argv[i]); > + /* Append the input objects. */ > + for (i = 0; i < ltoobj_argc; ++i) > + obstack_ptr_grow (&argv_obstack, ltoobj_argv[i]); > obstack_ptr_grow (&argv_obstack, NULL); > > new_argv = XOBFINISH (&argv_obstack, const char **); > argv_ptr = &new_argv[new_head_argc]; > fork_execute (new_argv[0], CONST_CAST (char **, new_argv), true); > > + /* Handle early generated debug information. At compile-time > + we output early DWARF debug info into .gnu.debuglto_ prefixed > + sections. LTRANS object DWARF debug info refers to that. > + So we need to transfer the .gnu.debuglto_ sections to the final > + link. Ideally the linker plugin interface would allow us to > + not claim those sections and instruct the linker to keep > + them, renaming them in the process. For now we extract and > + rename those sections via a simple-object interface to produce > + regular objects containing only the early debug info. We > + then partially link those to a single early debug info object > + and pass that as additional output back to the linker plugin. */ > + > + /* Prepare the partial link to gather the compile-time generated > + debug-info into a single input for the final link. */ > + debug_obj = make_temp_file ("debugobj"); > + obstack_ptr_grow (&argv_obstack, collect_gcc); > + for (i = 1; i < decoded_options_count; ++i) > + { > + /* Retain linker choice and -B. */ > + if (decoded_options[i].opt_index == OPT_B > + || decoded_options[i].opt_index == OPT_fuse_ld_bfd > + || decoded_options[i].opt_index == OPT_fuse_ld_gold) > + append_linker_options (&argv_obstack, &decoded_options[i-1], 2); > + /* Retain all target options, this preserves -m32 for example. */ > + if (cl_options[decoded_options[i].opt_index].flags & CL_TARGET) > + append_linker_options (&argv_obstack, &decoded_options[i-1], 2); > + /* Recognize -g0. */ > + if (decoded_options[i].opt_index == OPT_g > + && strcmp (decoded_options[i].arg, "0") == 0) > + skip_debug = true; > + } > + obstack_ptr_grow (&argv_obstack, "-r"); > + obstack_ptr_grow (&argv_obstack, "-nostdlib"); > + obstack_ptr_grow (&argv_obstack, "-o"); > + obstack_ptr_grow (&argv_obstack, debug_obj); > + > + /* Copy the early generated debug info from the objects to temporary > + files and append those to the partial link commandline. */ > + n_debugobj = 0; > + if (! skip_debug) > + for (i = 0; i < ltoobj_argc; ++i) > + { > + const char *tem; > + if ((tem = debug_objcopy (ltoobj_argv[i]))) > + { > + obstack_ptr_grow (&argv_obstack, tem); > + n_debugobj++; > + } > + } > + > + /* Link them all into a single object. Ideally this would reduce > + disk space usage mainly due to .debug_str merging but unfortunately > + GNU ld doesn't perform this with -r. */ > + if (n_debugobj) > + { > + obstack_ptr_grow (&argv_obstack, NULL); > + const char **debug_link_argv = XOBFINISH (&argv_obstack, const char **); > + fork_execute (debug_link_argv[0], > + CONST_CAST (char **, debug_link_argv), false); > + > + /* And dispose the temporaries. */ > + for (i = 0; debug_link_argv[i]; ++i) > + ; > + for (--i; i > 0; --i) > + { > + if (strcmp (debug_link_argv[i], debug_obj) == 0) > + break; > + maybe_unlink (debug_link_argv[i]); > + } > + } > + else > + { > + unlink_if_ordinary (debug_obj); > + free (debug_obj); > + debug_obj = NULL; > + skip_debug = true; > + } > + > if (lto_mode == LTO_MODE_LTO) > { > printf ("%s\n", flto_out); > + if (!skip_debug) > + { > + printf ("%s\n", debug_obj); > + free (debug_obj); > + debug_obj = NULL; > + } > free (flto_out); > flto_out = NULL; > } > *************** cont: > *** 1434,1439 **** > --- 1599,1610 ---- > for (i = 0; i < nr; ++i) > maybe_unlink (input_names[i]); > } > + if (!skip_debug) > + { > + printf ("%s\n", debug_obj); > + free (debug_obj); > + debug_obj = NULL; > + } > for (i = 0; i < nr; ++i) > { > fputs (output_names[i], stdout); > Index: early-lto-debug/gcc/tree-streamer-in.c > =================================================================== > *** early-lto-debug.orig/gcc/tree-streamer-in.c 2017-05-16 13:10:47.554202813 +0200 > --- early-lto-debug/gcc/tree-streamer-in.c 2017-05-16 13:10:49.862240801 +0200 > *************** lto_input_ts_decl_common_tree_pointers ( > *** 688,697 **** > DECL_SIZE (expr) = stream_read_tree (ib, data_in); > DECL_SIZE_UNIT (expr) = stream_read_tree (ib, data_in); > DECL_ATTRIBUTES (expr) = stream_read_tree (ib, data_in); > ! > ! /* Do not stream DECL_ABSTRACT_ORIGIN. We cannot handle debug information > ! for early inlining so drop it on the floor instead of ICEing in > ! dwarf2out.c. */ > > if ((VAR_P (expr) || TREE_CODE (expr) == PARM_DECL) > && DECL_HAS_VALUE_EXPR_P (expr)) > --- 688,694 ---- > DECL_SIZE (expr) = stream_read_tree (ib, data_in); > DECL_SIZE_UNIT (expr) = stream_read_tree (ib, data_in); > DECL_ATTRIBUTES (expr) = stream_read_tree (ib, data_in); > ! DECL_ABSTRACT_ORIGIN (expr) = stream_read_tree (ib, data_in); > > if ((VAR_P (expr) || TREE_CODE (expr) == PARM_DECL) > && DECL_HAS_VALUE_EXPR_P (expr)) > Index: early-lto-debug/gcc/tree-streamer-out.c > =================================================================== > *** early-lto-debug.orig/gcc/tree-streamer-out.c 2017-05-16 13:10:47.554202813 +0200 > --- early-lto-debug/gcc/tree-streamer-out.c 2017-05-16 13:10:49.862240801 +0200 > *************** write_ts_decl_minimal_tree_pointers (str > *** 566,572 **** > stream_write_tree (ob, NULL_TREE, ref_p); > else > stream_write_tree (ob, DECL_NAME (expr), ref_p); > ! stream_write_tree (ob, DECL_CONTEXT (expr), ref_p); > } > > > --- 566,576 ---- > stream_write_tree (ob, NULL_TREE, ref_p); > else > stream_write_tree (ob, DECL_NAME (expr), ref_p); > ! if (TREE_CODE (expr) != TRANSLATION_UNIT_DECL > ! && ! DECL_CONTEXT (expr)) > ! stream_write_tree (ob, (*all_translation_units)[0], ref_p); > ! else > ! stream_write_tree (ob, DECL_CONTEXT (expr), ref_p); > } > > > *************** write_ts_decl_common_tree_pointers (stru > *** 585,594 **** > special handling in LTO, it must be handled by streamer hooks. */ > > stream_write_tree (ob, DECL_ATTRIBUTES (expr), ref_p); > ! > ! /* Do not stream DECL_ABSTRACT_ORIGIN. We cannot handle debug information > ! for early inlining so drop it on the floor instead of ICEing in > ! dwarf2out.c. */ > > if ((VAR_P (expr) || TREE_CODE (expr) == PARM_DECL) > && DECL_HAS_VALUE_EXPR_P (expr)) > --- 589,595 ---- > special handling in LTO, it must be handled by streamer hooks. */ > > stream_write_tree (ob, DECL_ATTRIBUTES (expr), ref_p); > ! stream_write_tree (ob, DECL_ABSTRACT_ORIGIN (expr), ref_p); > > if ((VAR_P (expr) || TREE_CODE (expr) == PARM_DECL) > && DECL_HAS_VALUE_EXPR_P (expr)) > Index: early-lto-debug/gcc/config/darwin.c > =================================================================== > *** early-lto-debug.orig/gcc/config/darwin.c 2017-05-16 13:10:47.554202813 +0200 > --- early-lto-debug/gcc/config/darwin.c 2017-05-16 13:10:49.862240801 +0200 > *************** darwin_asm_lto_end (void) > *** 1959,1965 **** > } > > static void > ! darwin_asm_dwarf_section (const char *name, unsigned int flags, tree decl); > > /* Called for the TARGET_ASM_NAMED_SECTION hook. */ > > --- 1959,1966 ---- > } > > static void > ! darwin_asm_dwarf_section (const char *name, unsigned int flags, > ! tree decl, bool is_for_lto); > > /* Called for the TARGET_ASM_NAMED_SECTION hook. */ > > *************** darwin_asm_named_section (const char *na > *** 2001,2007 **** > vec_safe_push (lto_section_names, e); > } > else if (strncmp (name, "__DWARF,", 8) == 0) > ! darwin_asm_dwarf_section (name, flags, decl); > else > fprintf (asm_out_file, "\t.section %s\n", name); > } > --- 2002,2010 ---- > vec_safe_push (lto_section_names, e); > } > else if (strncmp (name, "__DWARF,", 8) == 0) > ! darwin_asm_dwarf_section (name, flags, decl, false); > ! else if (strncmp (name, "__GNU_DWARF_LTO,", 16) == 0) > ! darwin_asm_dwarf_section (name, flags, decl, true); > else > fprintf (asm_out_file, "\t.section %s\n", name); > } > *************** static GTY (()) vec *** 2783,2801 **** > > static void > darwin_asm_dwarf_section (const char *name, unsigned int flags, > ! tree ARG_UNUSED (decl)) > { > unsigned i; > ! int namelen; > ! const char * sname; > dwarf_sect_used_entry *ref; > bool found = false; > ! gcc_assert ((flags & (SECTION_DEBUG | SECTION_NAMED)) > ! == (SECTION_DEBUG | SECTION_NAMED)); > ! /* We know that the name starts with __DWARF, */ > ! sname = name + 8; > ! namelen = strchr (sname, ',') - sname; > ! gcc_assert (namelen); > if (dwarf_sect_names_table == NULL) > vec_alloc (dwarf_sect_names_table, 16); > else > --- 2786,2822 ---- > > static void > darwin_asm_dwarf_section (const char *name, unsigned int flags, > ! tree ARG_UNUSED (decl), bool is_for_lto) > { > unsigned i; > ! int namelen, extra = 0; > ! const char *sect, *lto_add = ""; > ! char sname[64]; > dwarf_sect_used_entry *ref; > bool found = false; > ! > ! gcc_checking_assert ((flags & (SECTION_DEBUG | SECTION_NAMED)) > ! == (SECTION_DEBUG | SECTION_NAMED)); > ! > ! /* We know that the name starts with __DWARF, or __GNU_DAWRF_LTO */ > ! sect = strchr (name, ',') + 1; > ! namelen = strchr (sect, ',') - sect; > ! gcc_checking_assert (namelen); > ! > ! /* The section switch is output as written... */ > ! fprintf (asm_out_file, "\t.section %s\n", name); > ! > ! /* ... but the string we keep to make section start labels needs > ! adjustment for lto cases. */ > ! if (is_for_lto) > ! { > ! lto_add = "_lto"; > ! extra = 4; > ! } > ! > ! snprintf (sname, 64, "%.*s%.*s", namelen, sect, extra, lto_add); > ! namelen += extra; > ! > if (dwarf_sect_names_table == NULL) > vec_alloc (dwarf_sect_names_table, 16); > else > *************** darwin_asm_dwarf_section (const char *na > *** 2813,2819 **** > } > } > > - fprintf (asm_out_file, "\t.section %s\n", name); > if (!found) > { > dwarf_sect_used_entry e; > --- 2834,2839 ---- > *************** darwin_asm_output_dwarf_offset (FILE *fi > *** 2866,2879 **** > HOST_WIDE_INT offset, section *base) > { > char sname[64]; > ! int namelen; > > ! gcc_assert (base->common.flags & SECTION_NAMED); > ! gcc_assert (strncmp (base->named.name, "__DWARF,", 8) == 0); > ! gcc_assert (strchr (base->named.name + 8, ',')); > ! > ! namelen = strchr (base->named.name + 8, ',') - (base->named.name + 8); > ! sprintf (sname, "*Lsection%.*s", namelen, base->named.name + 8); > darwin_asm_output_dwarf_delta (file, size, lab, sname, offset); > } > > --- 2886,2909 ---- > HOST_WIDE_INT offset, section *base) > { > char sname[64]; > ! int namelen, extra = 0; > ! bool is_for_lto; > ! const char *lto_add = ""; > ! > ! gcc_checking_assert (base->common.flags & SECTION_NAMED); > ! is_for_lto = strncmp (base->named.name, "__GNU_DWARF_LTO,", 16) == 0; > ! gcc_checking_assert (is_for_lto > ! || strncmp (base->named.name, "__DWARF,", 8) == 0); > ! const char *name = strchr (base->named.name, ',') + 1; > ! gcc_checking_assert (name); > > ! namelen = strchr (name, ',') - (name); > ! if (is_for_lto) > ! { > ! lto_add = "_lto"; > ! extra = 4; > ! } > ! snprintf (sname, 64, "*Lsection%.*s%.*s", namelen, name, extra, lto_add); > darwin_asm_output_dwarf_delta (file, size, lab, sname, offset); > } > > Index: early-lto-debug/gcc/config/darwin.h > =================================================================== > *** early-lto-debug.orig/gcc/config/darwin.h 2017-05-16 13:10:47.554202813 +0200 > --- early-lto-debug/gcc/config/darwin.h 2017-05-16 13:10:49.866240867 +0200 > *************** extern GTY(()) int darwin_ms_struct; > *** 445,451 **** > #define DEBUG_PUBTYPES_SECTION "__DWARF,__debug_pubtypes,regular,debug" > #define DEBUG_STR_SECTION "__DWARF,__debug_str,regular,debug" > #define DEBUG_RANGES_SECTION "__DWARF,__debug_ranges,regular,debug" > ! #define DEBUG_MACRO_SECTION "__DWARF,__debug_macro,regular,debug" > > #define TARGET_WANT_DEBUG_PUB_SECTIONS true > > --- 445,458 ---- > #define DEBUG_PUBTYPES_SECTION "__DWARF,__debug_pubtypes,regular,debug" > #define DEBUG_STR_SECTION "__DWARF,__debug_str,regular,debug" > #define DEBUG_RANGES_SECTION "__DWARF,__debug_ranges,regular,debug" > ! #define DEBUG_MACRO_SECTION "__DWARF,__debug_macro,regular,debug" > ! > ! #define DEBUG_LTO_INFO_SECTION "__GNU_DWARF_LTO,__debug_info,regular,debug" > ! #define DEBUG_LTO_ABBREV_SECTION "__GNU_DWARF_LTO,__debug_abbrev,regular,debug" > ! #define DEBUG_LTO_MACINFO_SECTION "__GNU_DWARF_LTO,__debug_macinfo,regular,debug" > ! #define DEBUG_LTO_LINE_SECTION "__GNU_DWARF_LTO,__debug_line,regular,debug" > ! #define DEBUG_LTO_STR_SECTION "__GNU_DWARF_LTO,__debug_str,regular,debug" > ! #define DEBUG_LTO_MACRO_SECTION "__GNU_DWARF_LTO,__debug_macro,regular,debug" > > #define TARGET_WANT_DEBUG_PUB_SECTIONS true > > Index: early-lto-debug/gcc/vmsdbgout.c > =================================================================== > *** early-lto-debug.orig/gcc/vmsdbgout.c 2017-05-16 13:10:47.554202813 +0200 > --- early-lto-debug/gcc/vmsdbgout.c 2017-05-16 13:10:49.866240867 +0200 > *************** const struct gcc_debug_hooks vmsdbg_debu > *** 198,203 **** > --- 198,205 ---- > vmsdbgout_late_global_decl, > vmsdbgout_type_decl, /* type_decl */ > debug_nothing_tree_tree_tree_bool, /* imported_module_or_decl */ > + debug_false_tree_charstarstar_uhwistar, /* die_ref_for_decl */ > + debug_nothing_tree_charstar_uhwi, /* register_external_die */ > debug_nothing_tree, /* deferred_inline_function */ > vmsdbgout_abstract_function, > debug_nothing_rtx_code_label, /* label */ > Index: early-lto-debug/gcc/tree.c > =================================================================== > *** early-lto-debug.orig/gcc/tree.c 2017-05-16 13:10:47.554202813 +0200 > --- early-lto-debug/gcc/tree.c 2017-05-16 13:10:49.870240933 +0200 > *************** free_lang_data (void) > *** 5974,5979 **** > --- 5974,5983 ---- > || (!flag_generate_lto && !flag_generate_offload)) > return 0; > > + /* Provide a dummy TRANSLATION_UNIT_DECL if the FE failed to provide one. */ > + if (vec_safe_is_empty (all_translation_units)) > + build_translation_unit_decl (NULL_TREE); > + > /* Allocate and assign alias sets to the standard integer types > while the slots are still in the way the frontends generated them. */ > for (i = 0; i < itk_none; ++i) > Index: early-lto-debug/gcc/testsuite/c-c++-common/asan/global-overflow-1.c > =================================================================== > *** early-lto-debug.orig/gcc/testsuite/c-c++-common/asan/global-overflow-1.c 2017-05-16 13:10:47.554202813 +0200 > --- early-lto-debug/gcc/testsuite/c-c++-common/asan/global-overflow-1.c 2017-05-16 13:10:49.870240933 +0200 > *************** int main() { > *** 23,28 **** > } > > /* { dg-output "READ of size 1 at 0x\[0-9a-f\]+ thread T0.*(\n|\r\n|\r)" } */ > ! /* { dg-output " #0 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*global-overflow-1.c:20|\[^\n\r]*:0)|\[(\])\[^\n\r]*(\n|\r\n|\r).*" } */ > /* { dg-output "0x\[0-9a-f\]+ is located 0 bytes to the right of global variable" } */ > /* { dg-output ".*YYY\[^\n\r]* of size 10\[^\n\r]*(\n|\r\n|\r)" } */ > --- 23,28 ---- > } > > /* { dg-output "READ of size 1 at 0x\[0-9a-f\]+ thread T0.*(\n|\r\n|\r)" } */ > ! /* { dg-output " #0 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*global-overflow-1.c:20|\[^\n\r]*:0|\[^\n\r]*\\+0x\[0-9a-z\]*)|\[(\])\[^\n\r]*(\n|\r\n|\r).*" } */ > /* { dg-output "0x\[0-9a-f\]+ is located 0 bytes to the right of global variable" } */ > /* { dg-output ".*YYY\[^\n\r]* of size 10\[^\n\r]*(\n|\r\n|\r)" } */ > Index: early-lto-debug/gcc/testsuite/c-c++-common/asan/heap-overflow-1.c > =================================================================== > *** early-lto-debug.orig/gcc/testsuite/c-c++-common/asan/heap-overflow-1.c 2017-05-16 13:10:47.554202813 +0200 > --- early-lto-debug/gcc/testsuite/c-c++-common/asan/heap-overflow-1.c 2017-05-16 13:10:49.870240933 +0200 > *************** int main(int argc, char **argv) { > *** 24,31 **** > } > > /* { dg-output "READ of size 1 at 0x\[0-9a-f\]+ thread T0.*(\n|\r\n|\r)" } */ > ! /* { dg-output " #0 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*heap-overflow-1.c:21|\[^\n\r]*:0)|\[(\]).*(\n|\r\n|\r)" } */ > /* { dg-output "\[^\n\r]*0x\[0-9a-f\]+ is located 0 bytes to the right of 10-byte region\[^\n\r]*(\n|\r\n|\r)" } */ > /* { dg-output "\[^\n\r]*allocated by thread T0 here:\[^\n\r]*(\n|\r\n|\r)" } */ > /* { dg-output " #0 0x\[0-9a-f\]+ +(in _*(interceptor_|wrap_|)malloc|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */ > ! /* { dg-output " #1 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*heap-overflow-1.c:19|\[^\n\r]*:0)|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */ > --- 24,31 ---- > } > > /* { dg-output "READ of size 1 at 0x\[0-9a-f\]+ thread T0.*(\n|\r\n|\r)" } */ > ! /* { dg-output " #0 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*heap-overflow-1.c:21|\[^\n\r]*:0|\[^\n\r]*\\+0x\[0-9a-z\]*)|\[(\]).*(\n|\r\n|\r)" } */ > /* { dg-output "\[^\n\r]*0x\[0-9a-f\]+ is located 0 bytes to the right of 10-byte region\[^\n\r]*(\n|\r\n|\r)" } */ > /* { dg-output "\[^\n\r]*allocated by thread T0 here:\[^\n\r]*(\n|\r\n|\r)" } */ > /* { dg-output " #0 0x\[0-9a-f\]+ +(in _*(interceptor_|wrap_|)malloc|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */ > ! /* { dg-output " #1 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*heap-overflow-1.c:19|\[^\n\r]*:0|\[^\n\r]*\\+0x\[0-9a-z\]*)|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */ > Index: early-lto-debug/gcc/testsuite/c-c++-common/asan/misalign-1.c > =================================================================== > *** early-lto-debug.orig/gcc/testsuite/c-c++-common/asan/misalign-1.c 2017-05-16 13:10:47.554202813 +0200 > --- early-lto-debug/gcc/testsuite/c-c++-common/asan/misalign-1.c 2017-05-16 13:10:49.870240933 +0200 > *************** main () > *** 39,43 **** > /* { dg-output "ERROR: AddressSanitizer:\[^\n\r]*on address\[^\n\r]*" } */ > /* { dg-output "0x\[0-9a-f\]+ at pc 0x\[0-9a-f\]+ bp 0x\[0-9a-f\]+ sp 0x\[0-9a-f\]+\[^\n\r]*(\n|\r\n|\r)" } */ > /* { dg-output "\[^\n\r]*READ of size 4 at 0x\[0-9a-f\]+ thread T0\[^\n\r]*(\n|\r\n|\r)" } */ > ! /* { dg-output " #0 0x\[0-9a-f\]+ +(in _*foo(\[^\n\r]*misalign-1.c:1\[01]|\[^\n\r]*:0)|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */ > ! /* { dg-output " #1 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*misalign-1.c:3\[45]|\[^\n\r]*:0)|\[(\]).*(\n|\r\n|\r)" } */ > --- 39,43 ---- > /* { dg-output "ERROR: AddressSanitizer:\[^\n\r]*on address\[^\n\r]*" } */ > /* { dg-output "0x\[0-9a-f\]+ at pc 0x\[0-9a-f\]+ bp 0x\[0-9a-f\]+ sp 0x\[0-9a-f\]+\[^\n\r]*(\n|\r\n|\r)" } */ > /* { dg-output "\[^\n\r]*READ of size 4 at 0x\[0-9a-f\]+ thread T0\[^\n\r]*(\n|\r\n|\r)" } */ > ! /* { dg-output " #0 0x\[0-9a-f\]+ +(in _*foo(\[^\n\r]*misalign-1.c:1\[01]|\[^\n\r]*:0|\[^\n\r]*\\+0x\[0-9a-z\]*)|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */ > ! /* { dg-output " #1 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*misalign-1.c:3\[45]|\[^\n\r]*:0|\[^\n\r]*\\+0x\[0-9a-z\]*)|\[(\]).*(\n|\r\n|\r)" } */ > Index: early-lto-debug/gcc/testsuite/c-c++-common/asan/misalign-2.c > =================================================================== > *** early-lto-debug.orig/gcc/testsuite/c-c++-common/asan/misalign-2.c 2017-05-16 13:10:47.554202813 +0200 > --- early-lto-debug/gcc/testsuite/c-c++-common/asan/misalign-2.c 2017-05-16 13:10:49.870240933 +0200 > *************** main () > *** 39,43 **** > /* { dg-output "ERROR: AddressSanitizer:\[^\n\r]*on address\[^\n\r]*" } */ > /* { dg-output "0x\[0-9a-f\]+ at pc 0x\[0-9a-f\]+ bp 0x\[0-9a-f\]+ sp 0x\[0-9a-f\]+\[^\n\r]*(\n|\r\n|\r)" } */ > /* { dg-output "\[^\n\r]*READ of size 4 at 0x\[0-9a-f\]+ thread T0\[^\n\r]*(\n|\r\n|\r)" } */ > ! /* { dg-output " #0 0x\[0-9a-f\]+ +(in _*baz(\[^\n\r]*misalign-2.c:2\[23]|\[^\n\r]*:0)|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */ > ! /* { dg-output " #1 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*misalign-2.c:3\[45]|\[^\n\r]*:0)|\[(\]).*(\n|\r\n|\r)" } */ > --- 39,43 ---- > /* { dg-output "ERROR: AddressSanitizer:\[^\n\r]*on address\[^\n\r]*" } */ > /* { dg-output "0x\[0-9a-f\]+ at pc 0x\[0-9a-f\]+ bp 0x\[0-9a-f\]+ sp 0x\[0-9a-f\]+\[^\n\r]*(\n|\r\n|\r)" } */ > /* { dg-output "\[^\n\r]*READ of size 4 at 0x\[0-9a-f\]+ thread T0\[^\n\r]*(\n|\r\n|\r)" } */ > ! /* { dg-output " #0 0x\[0-9a-f\]+ +(in _*baz(\[^\n\r]*misalign-2.c:2\[23]|\[^\n\r]*:0|\[^\n\r]*\\+0x\[0-9a-z\]*)|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */ > ! /* { dg-output " #1 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*misalign-2.c:3\[45]|\[^\n\r]*:0|\[^\n\r]*\\+0x\[0-9a-z\]*)|\[(\]).*(\n|\r\n|\r)" } */ > Index: early-lto-debug/gcc/testsuite/c-c++-common/asan/null-deref-1.c > =================================================================== > *** early-lto-debug.orig/gcc/testsuite/c-c++-common/asan/null-deref-1.c 2017-05-16 13:10:47.554202813 +0200 > --- early-lto-debug/gcc/testsuite/c-c++-common/asan/null-deref-1.c 2017-05-16 13:10:49.870240933 +0200 > *************** int main() > *** 18,22 **** > > /* { dg-output "ERROR: AddressSanitizer:? SEGV on unknown address\[^\n\r]*" } */ > /* { dg-output "0x\[0-9a-f\]+ \[^\n\r]*pc 0x\[0-9a-f\]+.*(\n|\r\n|\r)" } */ > ! /* { dg-output " #0 0x\[0-9a-f\]+ +(in \[^\n\r]*NullDeref\[^\n\r]* (\[^\n\r]*null-deref-1.c:10|\[^\n\r]*:0)|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */ > ! /* { dg-output " #1 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*null-deref-1.c:15|\[^\n\r]*:0)|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */ > --- 18,22 ---- > > /* { dg-output "ERROR: AddressSanitizer:? SEGV on unknown address\[^\n\r]*" } */ > /* { dg-output "0x\[0-9a-f\]+ \[^\n\r]*pc 0x\[0-9a-f\]+.*(\n|\r\n|\r)" } */ > ! /* { dg-output " #0 0x\[0-9a-f\]+ +(in \[^\n\r]*NullDeref\[^\n\r]* (\[^\n\r]*null-deref-1.c:10|\[^\n\r]*:0|\[^\n\r]*\\+0x\[0-9a-z\]*)|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */ > ! /* { dg-output " #1 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*null-deref-1.c:15|\[^\n\r]*:0|\[^\n\r]*\\+0x\[0-9a-z\]*)|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */ > Index: early-lto-debug/gcc/testsuite/c-c++-common/asan/stack-overflow-1.c > =================================================================== > *** early-lto-debug.orig/gcc/testsuite/c-c++-common/asan/stack-overflow-1.c 2017-05-16 13:10:47.554202813 +0200 > --- early-lto-debug/gcc/testsuite/c-c++-common/asan/stack-overflow-1.c 2017-05-16 13:10:49.874240999 +0200 > *************** int main() { > *** 18,23 **** > } > > /* { dg-output "READ of size 1 at 0x\[0-9a-f\]+ thread T0\[^\n\r]*(\n|\r\n|\r)" } */ > ! /* { dg-output " #0 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*stack-overflow-1.c:16|\[^\n\r]*:0)|\[(\]).*(\n|\r\n|\r)" } */ > /* { dg-output "\[^\n\r]*Address 0x\[0-9a-f\]+ is located in stack of thread T0.*(\n|\r\n|\r)" */ > /* { dg-output "\[^\n\r]*in main.*stack-overflow-1.c.*(\n|\r\n|\r)" */ > --- 18,23 ---- > } > > /* { dg-output "READ of size 1 at 0x\[0-9a-f\]+ thread T0\[^\n\r]*(\n|\r\n|\r)" } */ > ! /* { dg-output " #0 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*stack-overflow-1.c:16|\[^\n\r]*:0|\[^\n\r]*\\+0x\[0-9a-z\]*)|\[(\]).*(\n|\r\n|\r)" } */ > /* { dg-output "\[^\n\r]*Address 0x\[0-9a-f\]+ is located in stack of thread T0.*(\n|\r\n|\r)" */ > /* { dg-output "\[^\n\r]*in main.*stack-overflow-1.c.*(\n|\r\n|\r)" */ > Index: early-lto-debug/gcc/testsuite/c-c++-common/asan/strncpy-overflow-1.c > =================================================================== > *** early-lto-debug.orig/gcc/testsuite/c-c++-common/asan/strncpy-overflow-1.c 2017-05-16 13:10:47.554202813 +0200 > --- early-lto-debug/gcc/testsuite/c-c++-common/asan/strncpy-overflow-1.c 2017-05-16 13:10:49.874240999 +0200 > *************** int main(int argc, char **argv) { > *** 14,21 **** > > /* { dg-output "WRITE of size \[0-9\]* at 0x\[0-9a-f\]+ thread T0\[^\n\r]*(\n|\r\n|\r)" } */ > /* { dg-output " #0 0x\[0-9a-f\]+ +(in _*(interceptor_|wrap_|)strncpy|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */ > ! /* { dg-output " #1 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*strncpy-overflow-1.c:11|\[^\n\r]*:0)|\[(\]).*(\n|\r\n|\r)" } */ > /* { dg-output "\[^\n\r]*0x\[0-9a-f\]+ is located 0 bytes to the right of 9-byte region\[^\n\r]*(\n|\r\n|\r)" } */ > /* { dg-output "\[^\n\r]*allocated by thread T0 here:\[^\n\r]*(\n|\r\n|\r)" } */ > /* { dg-output " #0 0x\[0-9a-f\]+ +(in _*(interceptor_|wrap_|)malloc|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */ > ! /* { dg-output " #1 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*strncpy-overflow-1.c:10|\[^\n\r]*:0)|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */ > --- 14,21 ---- > > /* { dg-output "WRITE of size \[0-9\]* at 0x\[0-9a-f\]+ thread T0\[^\n\r]*(\n|\r\n|\r)" } */ > /* { dg-output " #0 0x\[0-9a-f\]+ +(in _*(interceptor_|wrap_|)strncpy|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */ > ! /* { dg-output " #1 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*strncpy-overflow-1.c:11|\[^\n\r]*:0|\[^\n\r]*\\+0x\[0-9a-z\]*)|\[(\]).*(\n|\r\n|\r)" } */ > /* { dg-output "\[^\n\r]*0x\[0-9a-f\]+ is located 0 bytes to the right of 9-byte region\[^\n\r]*(\n|\r\n|\r)" } */ > /* { dg-output "\[^\n\r]*allocated by thread T0 here:\[^\n\r]*(\n|\r\n|\r)" } */ > /* { dg-output " #0 0x\[0-9a-f\]+ +(in _*(interceptor_|wrap_|)malloc|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */ > ! /* { dg-output " #1 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*strncpy-overflow-1.c:10|\[^\n\r]*:0|\[^\n\r]*\\+0x\[0-9a-z\]*)|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */ > Index: early-lto-debug/gcc/testsuite/c-c++-common/asan/use-after-free-1.c > =================================================================== > *** early-lto-debug.orig/gcc/testsuite/c-c++-common/asan/use-after-free-1.c 2017-05-16 13:10:47.554202813 +0200 > --- early-lto-debug/gcc/testsuite/c-c++-common/asan/use-after-free-1.c 2017-05-16 13:10:49.874240999 +0200 > *************** int main() { > *** 12,22 **** > /* { dg-output "ERROR: AddressSanitizer:? heap-use-after-free on address\[^\n\r]*" } */ > /* { dg-output "0x\[0-9a-f\]+ at pc 0x\[0-9a-f\]+ bp 0x\[0-9a-f\]+ sp 0x\[0-9a-f\]+\[^\n\r]*(\n|\r\n|\r)" } */ > /* { dg-output "\[^\n\r]*READ of size 1 at 0x\[0-9a-f\]+ thread T0\[^\n\r]*(\n|\r\n|\r)" } */ > ! /* { dg-output " #0 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*use-after-free-1.c:9|\[^\n\r]*:0)|\[(\]).*(\n|\r\n|\r)" } */ > /* { dg-output "\[^\n\r]*0x\[0-9a-f\]+ is located 5 bytes inside of 10-byte region .0x\[0-9a-f\]+,0x\[0-9a-f\]+\[^\n\r]*(\n|\r\n|\r)" } */ > /* { dg-output "\[^\n\r]*freed by thread T0 here:\[^\n\r]*(\n|\r\n|\r)" } */ > /* { dg-output " #0 0x\[0-9a-f\]+ +(in _*(interceptor_|wrap_|)free|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */ > ! /* { dg-output " #1 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*use-after-free-1.c:8|\[^\n\r]*:0)|\[(\]).*(\n|\r\n|\r)" } */ > /* { dg-output "\[^\n\r]*previously allocated by thread T0 here:\[^\n\r]*(\n|\r\n|\r)" } */ > /* { dg-output " #0 0x\[0-9a-f\]+ +(in _*(interceptor_|wrap_|)malloc|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */ > ! /* { dg-output " #1 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*use-after-free-1.c:7|\[^\n\r]*:0)|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */ > --- 12,22 ---- > /* { dg-output "ERROR: AddressSanitizer:? heap-use-after-free on address\[^\n\r]*" } */ > /* { dg-output "0x\[0-9a-f\]+ at pc 0x\[0-9a-f\]+ bp 0x\[0-9a-f\]+ sp 0x\[0-9a-f\]+\[^\n\r]*(\n|\r\n|\r)" } */ > /* { dg-output "\[^\n\r]*READ of size 1 at 0x\[0-9a-f\]+ thread T0\[^\n\r]*(\n|\r\n|\r)" } */ > ! /* { dg-output " #0 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*use-after-free-1.c:9|\[^\n\r]*:0|\[^\n\r]*\\+0x\[0-9a-z\]*)|\[(\]).*(\n|\r\n|\r)" } */ > /* { dg-output "\[^\n\r]*0x\[0-9a-f\]+ is located 5 bytes inside of 10-byte region .0x\[0-9a-f\]+,0x\[0-9a-f\]+\[^\n\r]*(\n|\r\n|\r)" } */ > /* { dg-output "\[^\n\r]*freed by thread T0 here:\[^\n\r]*(\n|\r\n|\r)" } */ > /* { dg-output " #0 0x\[0-9a-f\]+ +(in _*(interceptor_|wrap_|)free|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */ > ! /* { dg-output " #1 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*use-after-free-1.c:8|\[^\n\r]*:0|\[^\n\r]*\\+0x\[0-9a-z\]*)|\[(\]).*(\n|\r\n|\r)" } */ > /* { dg-output "\[^\n\r]*previously allocated by thread T0 here:\[^\n\r]*(\n|\r\n|\r)" } */ > /* { dg-output " #0 0x\[0-9a-f\]+ +(in _*(interceptor_|wrap_|)malloc|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */ > ! /* { dg-output " #1 0x\[0-9a-f\]+ +(in _*main (\[^\n\r]*use-after-free-1.c:7|\[^\n\r]*:0|\[^\n\r]*\\+0x\[0-9a-z\]*)|\[(\])\[^\n\r]*(\n|\r\n|\r)" } */ > Index: early-lto-debug/gcc/testsuite/g++.dg/asan/large-func-test-1.C > =================================================================== > *** early-lto-debug.orig/gcc/testsuite/g++.dg/asan/large-func-test-1.C 2017-05-16 13:10:47.554202813 +0200 > --- early-lto-debug/gcc/testsuite/g++.dg/asan/large-func-test-1.C 2017-05-16 13:10:49.874240999 +0200 > *************** int main() { > *** 38,44 **** > // { dg-output "ERROR: AddressSanitizer:? heap-buffer-overflow on address\[^\n\r]*" } > // { dg-output "0x\[0-9a-f\]+ at pc 0x\[0-9a-f\]+ bp 0x\[0-9a-f\]+ sp 0x\[0-9a-f\]+\[^\n\r]*(\n|\r\n|\r)" } > // { dg-output "\[^\n\r]*READ of size 4 at 0x\[0-9a-f\]+ thread T0\[^\n\r]*(\n|\r\n|\r)" } > ! // { dg-output " #0 0x\[0-9a-f\]+ +(in \[^\n\r]*LargeFunction\[^\n\r]*(large-func-test-1.C:18|\[^\n\r]*:0)|\[(\]).*(\n|\r\n|\r)" } > // { dg-output "\[^\n\r]*0x\[0-9a-f\]+ is located 44 bytes to the right of 400-byte region.*(\n|\r\n|\r)" } > // { dg-output "\[^\n\r]*allocated by thread T0 here:\[^\n\r]*(\n|\r\n|\r)" } > // { dg-output " #0( 0x\[0-9a-f\]+ +(in _*(interceptor_|)malloc|\[(\])\[^\n\r]*(\n|\r\n|\r)" } > --- 38,44 ---- > // { dg-output "ERROR: AddressSanitizer:? heap-buffer-overflow on address\[^\n\r]*" } > // { dg-output "0x\[0-9a-f\]+ at pc 0x\[0-9a-f\]+ bp 0x\[0-9a-f\]+ sp 0x\[0-9a-f\]+\[^\n\r]*(\n|\r\n|\r)" } > // { dg-output "\[^\n\r]*READ of size 4 at 0x\[0-9a-f\]+ thread T0\[^\n\r]*(\n|\r\n|\r)" } > ! // { dg-output " #0 0x\[0-9a-f\]+ +(in \[^\n\r]*LargeFunction\[^\n\r]*(large-func-test-1.C:18|\[^\n\r]*:0|\[^\n\r]*\\+0x\[0-9a-z\]*)|\[(\]).*(\n|\r\n|\r)" } > // { dg-output "\[^\n\r]*0x\[0-9a-f\]+ is located 44 bytes to the right of 400-byte region.*(\n|\r\n|\r)" } > // { dg-output "\[^\n\r]*allocated by thread T0 here:\[^\n\r]*(\n|\r\n|\r)" } > // { dg-output " #0( 0x\[0-9a-f\]+ +(in _*(interceptor_|)malloc|\[(\])\[^\n\r]*(\n|\r\n|\r)" } > Index: early-lto-debug/libstdc++-v3/testsuite/libstdc++-prettyprinters/prettyprinters.exp > =================================================================== > *** early-lto-debug.orig/libstdc++-v3/testsuite/libstdc++-prettyprinters/prettyprinters.exp 2017-05-16 13:10:47.554202813 +0200 > --- early-lto-debug/libstdc++-v3/testsuite/libstdc++-prettyprinters/prettyprinters.exp 2017-05-16 13:10:49.874240999 +0200 > *************** > *** 15,20 **** > --- 15,21 ---- > # . > > load_lib gdb-test.exp > + load_lib target-supports.exp > > dg-init > v3-build_support > *************** global PCH_CXXFLAGS > *** 46,51 **** > --- 47,60 ---- > gdb-dg-runtest [lsort [glob $srcdir/$subdir/*.cc]] \ > "" "$DEFAULT_CXXFLAGS $PCH_CXXFLAGS" > > + if { [check_effective_target_lto] } { > + append cxxflags " -flto" > + # work around sourceware.org 20882 > + regsub {^(.*)-Wl,--gc-sections(.*)$} $cxxldflags {\1\2} cxxldflags > + gdb-dg-runtest [lsort [glob $srcdir/$subdir/*.cc]] \ > + "" "$DEFAULT_CXXFLAGS -flto $PCH_CXXFLAGS" > + } > + > if [info exists guality_gdb_name] { > unsetenv GUALITY_GDB_NAME > } > Index: early-lto-debug/gcc/testsuite/gfortran.dg/save_6.f90 > =================================================================== > *** /dev/null 1970-01-01 00:00:00.000000000 +0000 > --- early-lto-debug/gcc/testsuite/gfortran.dg/save_6.f90 2017-05-18 09:39:31.394914888 +0200 > *************** > *** 0 **** > --- 1,54 ---- > + ! { dg-do run } > + ! { dg-require-effective-target lto } > + ! { dg-options "-fno-automatic -flto -g" } > + ! > + ! PR fortran/55733 > + ! > + ! Check that -fno-automatic makes the local variable SAVEd > + ! Check that -flto -g works > + ! > + > + ! Scalar allocatable > + subroutine foo(i) > + integer :: i > + integer, allocatable :: j > + if (i == 1) j = 42 > + if (.not. allocated (j)) call abort () > + if (j /= 42) call abort () > + end > + > + ! Deferred-length string scalar > + subroutine bar() > + logical, save :: first = .true. > + character(len=:), allocatable :: str > + if (first) then > + first = .false. > + if (allocated (str)) call abort () > + str = "ABCDEF" > + end if > + if (.not. allocated (str)) call abort () > + if (len (str) /= 6) call abort () > + if (str(1:6) /= "ABCDEF") call abort () > + end subroutine bar > + > + ! Deferred-length string array > + subroutine bar_array() > + logical, save :: first = .true. > + character(len=:), allocatable :: str > + if (first) then > + first = .false. > + if (allocated (str)) call abort () > + str = "ABCDEF" > + end if > + if (.not. allocated (str)) call abort () > + if (len (str) /= 6) call abort () > + if (str(1:6) /= "ABCDEF") call abort () > + end subroutine bar_array > + > + call foo(1) > + call foo(2) > + call bar() > + call bar_array() > + call bar() > + call bar_array() > + end > Index: early-lto-debug/gcc/config/i386/i386.c > =================================================================== > *** early-lto-debug.orig/gcc/config/i386/i386.c 2017-05-15 10:57:19.923567540 +0200 > --- early-lto-debug/gcc/config/i386/i386.c 2017-05-19 11:27:19.565373271 +0200 > *************** make_resolver_func (const tree default_d > *** 33840,33846 **** > DECL_NAME (decl) = decl_name; > TREE_USED (decl) = 1; > DECL_ARTIFICIAL (decl) = 1; > ! DECL_IGNORED_P (decl) = 0; > /* IFUNC resolvers have to be externally visible. */ > TREE_PUBLIC (decl) = 1; > DECL_UNINLINABLE (decl) = 1; > --- 33840,33846 ---- > DECL_NAME (decl) = decl_name; > TREE_USED (decl) = 1; > DECL_ARTIFICIAL (decl) = 1; > ! DECL_IGNORED_P (decl) = 1; > /* IFUNC resolvers have to be externally visible. */ > TREE_PUBLIC (decl) = 1; > DECL_UNINLINABLE (decl) = 1; > -- Richard Biener SUSE LINUX GmbH, GF: Felix Imendoerffer, Jane Smithard, Graham Norton, HRB 21284 (AG Nuernberg)