gcc/include/simple-object.h

213 lines
8.1 KiB
C
Raw Normal View History

/* simple-object.h -- simple routines to read and write object files
Copyright (C) 2010-2017 Free Software Foundation, Inc.
Written by Ian Lance Taylor, Google.
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, 51 Franklin Street - Fifth Floor,
Boston, MA 02110-1301, USA. */
#ifndef SIMPLE_OBJECT_H
#define SIMPLE_OBJECT_H
#include <stddef.h>
#include <sys/types.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* This header file provides four types with associated functions.
They are used to read and write object files. This is a minimal
interface, intended to support the needs of gcc without bringing in
all the power and complexity of BFD. */
/* The type simple_object_read * is used to read an existing object
file. */
typedef struct simple_object_read_struct simple_object_read;
/* Create an simple_object_read given DESCRIPTOR, an open file
descriptor, and OFFSET, an offset within the file. The offset is
for use with archives, and should be 0 for an ordinary object file.
The descriptor must remain open until done with the returned
simple_object_read. SEGMENT_NAME is used on Mach-O and is required
on that platform: it means to only look at sections within the
segment with that name. It is ignored for other object file
formats. On error, this function returns NULL, and sets *ERRMSG to
an error string and sets *ERR to an errno value or 0 if there is no
relevant errno. */
extern simple_object_read *
simple_object_start_read (int descriptor, off_t offset,
const char *segment_name, const char **errmsg,
int *err);
/* Call PFN for each section in SIMPLE_OBJECT, passing it the section
name, offset within the file of the section contents, and length of
the section contents. The offset within the file is relative to
the offset passed to simple_object_start_read. The DATA argument
to simple_object_find_sections is passed on to PFN. If PFN returns
0, the loop is stopped and simple_object_find_sections returns. If
PFN returns non-zero, the loop continues. On success this returns
NULL. On error it returns an error string, and sets *ERR to an
errno value or 0 if there is no relevant errno. */
extern const char *
simple_object_find_sections (simple_object_read *simple_object,
int (*pfn) (void *data, const char *,
off_t offset, off_t length),
void *data,
int *err);
/* Look for the section NAME in SIMPLE_OBJECT. This returns
information for the first section NAME in SIMPLE_OBJECT. Note that
calling this multiple times is inefficient; use
simple_object_find_sections instead.
If found, return 1 and set *OFFSET to the offset in the file of the
section contents and set *LENGTH to the length of the section
contents. *OFFSET will be relative to the offset passed to
simple_object_start_read.
If the section is not found, and no error occurs, return 0 and set
*ERRMSG to NULL.
If an error occurs, return 0, set *ERRMSG to an error message, and
set *ERR to an errno value or 0 if there is no relevant errno. */
extern int
simple_object_find_section (simple_object_read *simple_object,
const char *name, off_t *offset, off_t *length,
const char **errmsg, int *err);
/* Release all resources associated with SIMPLE_OBJECT. This does not
close the file descriptor. */
extern void
simple_object_release_read (simple_object_read *);
/* The type simple_object_attributes holds the attributes of an object
file that matter for creating a file or ensuring that two files are
compatible. This is a set of magic numbers. */
typedef struct simple_object_attributes_struct simple_object_attributes;
/* Fetch the attributes of SIMPLE_OBJECT. This information will
persist until simple_object_attributes_release is called, even if
SIMPLE_OBJECT is closed. On error this returns NULL, sets *ERRMSG
to an error message, and sets *ERR to an errno value or 0 if there
isn't one. */
extern simple_object_attributes *
simple_object_fetch_attributes (simple_object_read *simple_object,
const char **errmsg, int *err);
/* Merge the FROM attributes into TO. If two objects with these
attributes could be linked together without error, returns NULL.
Otherwise, returns an error message, and sets *ERR to an errno
value or 0 if there isn't one. */
extern const char *
simple_object_attributes_merge (simple_object_attributes *to,
simple_object_attributes *from,
int *err);
/* Release all resources associated with ATTRS. */
extern void
simple_object_release_attributes (simple_object_attributes *attrs);
/* The type simple_object_write is used to create a new object file. */
typedef struct simple_object_write_struct simple_object_write;
/* Start creating a new object file which is like ATTRS. You must
fetch attribute information from an existing object file before you
can create a new one. There is currently no support for creating
an object file de novo. The segment name is only used on Mach-O,
where it is required. It means that all sections are created
within that segment. It is ignored for other object file formats.
On error this function returns NULL, sets *ERRMSG to an error
message, and sets *ERR to an errno value or 0 if there isn't
one. */
extern simple_object_write *
simple_object_start_write (simple_object_attributes *attrs,
const char *segment_name,
const char **errmsg, int *err);
/* The type simple_object_write_section is a handle for a section
which is being written. */
typedef struct simple_object_write_section_struct simple_object_write_section;
/* Add a section to SIMPLE_OBJECT. NAME is the name of the new
section. ALIGN is the required alignment expressed as the number
of required low-order 0 bits (e.g., 2 for alignment to a 32-bit
boundary). The section is created as containing data, readable,
not writable, not executable, not loaded at runtime. On error this
returns NULL, sets *ERRMSG to an error message, and sets *ERR to an
errno value or 0 if there isn't one. */
extern simple_object_write_section *
simple_object_write_create_section (simple_object_write *simple_object,
const char *name, unsigned int align,
const char **errmsg, int *err);
/* Add data BUFFER/SIZE to SECTION in SIMPLE_OBJECT. If COPY is
non-zero, the data will be copied into memory if necessary. If
COPY is zero, BUFFER must persist until SIMPLE_OBJECT is released.
On success this returns NULL. On error this returns an error
message, and sets *ERR to an errno value or 0 if there isn't
one. */
extern const char *
simple_object_write_add_data (simple_object_write *simple_object,
simple_object_write_section *section,
const void *buffer, size_t size,
int copy, int *err);
/* Write the complete object file to DESCRIPTOR, an open file
descriptor. This returns NULL on success. On error this returns
an error message, and sets *ERR to an errno value or 0 if there
isn't one. */
extern const char *
simple_object_write_to_file (simple_object_write *simple_object,
int descriptor, int *err);
/* Release all resources associated with SIMPLE_OBJECT, including any
simple_object_write_section's that may have been created. */
extern void
simple_object_release_write (simple_object_write *);
re PR go/78628 (GO fails to build a translation unit decl) 2017-08-21 Richard Biener <rguenther@suse.de> include/ * simple-object.h (simple_object_copy_lto_debug_sections): New function. libiberty/ * simple-object-common.h (struct simple_object_functions): Add copy_lto_debug_sections hook. * simple-object.c: Include fcntl.h. (handle_lto_debug_sections): New helper function. (simple_object_copy_lto_debug_sections): New function copying early LTO debug sections to regular debug sections in a new file. (simple_object_start_write): Handle NULL segment_name. * simple-object-coff.c (simple_object_coff_functions): Adjust for not implemented copy_lto_debug_sections hook. * simple-object-mach-o.c (simple_object_mach_o_functions): Likewise. * simple-object-xcoff.c (simple_object_xcoff_functions): Likewise. * simple-object-elf.c (SHT_NULL, SHT_SYMTAB, SHT_RELA, SHT_REL, SHT_GROUP): Add various sectopn header types. (SHF_EXCLUDE): Add flag. (Elf32_External_Sym, Elf64_External_Sym): Add symbol struct. (ELF_ST_BIND, ELF_ST_TYPE, ELF_ST_INFO): Add accessors. (STT_OBJECT, STT_FUNC, STT_TLS, STT_GNU_IFUNC): Add Symbol types. (STV_DEFAULT): Add symbol visibility. (SHN_COMMON): Add special section index name. (struct simple_object_elf_write): New. (simple_object_elf_start_write): Adjust for new private data. (simple_object_elf_write_shdr): Pass in values for all fields we write. (simple_object_elf_write_to_file): Adjust. Copy from recorded section headers if requested. (simple_object_elf_release_write): Release private data. (simple_object_elf_copy_lto_debug_sections): Copy and rename sections as denoted by PFN and all their dependences, symbols and relocations to the empty destination file. (simple_object_elf_functions): Adjust for copy_lto_debug_sections hook. gcc/ * 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. (get_ultimate_context): Split out from is_cxx. (is_cxx): Use get_ultimate_context. (is_fortran): Add decl overload. (compute_comp_unit_symbol): Split out worker from compute_section_prefix. (compute_section_prefix): Call compute_comp_unit_symbol and set comdat_type_p 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. Remove obsolete call to dwarf2out_abstract_function for non-function/block origins. (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. As suggested place a gcc_unreachable for the DECL_ABSTRACT_P case. (gen_subprogram_die): 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. Do not call dwarf2out_abstract_function late. (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. (modified_type_die): Check for decl_ultimate_origin being self before recursing. (gen_type_die_with_usage): Likewise. (gen_typedef_die): Allow decl_ultimate_origin being self. (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 and call set_decl_origin_self. If the DIE has an abstract origin don't do anything. * tree.c (free_lang_data): Build a dummy TRANSLATION_UNIT_DECL if we have none yet (Go fails to build one, PR78628). (variably_modified_type_p): Prevent endless recursion for Ada cyclic pointer types. * 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. * cfgexpand.c (pass_expand::execute): Do not call the outlining_inline_function hook here. * 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. testsuite/ * 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. * c-c++-common/asan/alloca_big_alignment.c: Likewise. * c-c++-common/asan/alloca_detect_custom_size.c: Likewise. * c-c++-common/asan/alloca_overflow_partial.c: Likewise. * c-c++-common/asan/alloca_overflow_right.c: Likewise. * c-c++-common/asan/alloca_underflow_left.c: Likewise. * g++.dg/asan/large-func-test-1.C: Likewise. * gfortran.dg/save_6.f90: Add -flto -g variant of save_5.f90. From-SVN: r251220
2017-08-21 12:29:00 +02:00
/* Copy LTO debug sections from SRC_OBJECT to DEST.
If an error occurs, return the errno value in ERR and an error string. */
extern const char *
simple_object_copy_lto_debug_sections (simple_object_read *src_object,
const char *dest,
int *err);
#ifdef __cplusplus
}
#endif
#endif