2009-10-03 23:10:11 +02:00
|
|
|
/* Input functions for reading LTO sections.
|
|
|
|
|
2014-01-02 23:23:26 +01:00
|
|
|
Copyright (C) 2009-2014 Free Software Foundation, Inc.
|
2009-10-03 23:10:11 +02:00
|
|
|
Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
|
|
|
|
|
|
|
|
This file is part of GCC.
|
|
|
|
|
|
|
|
GCC 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 3, or (at your option) any later
|
|
|
|
version.
|
|
|
|
|
|
|
|
GCC 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 GCC; see the file COPYING3. If not see
|
|
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
#include "system.h"
|
|
|
|
#include "coretypes.h"
|
|
|
|
#include "tm.h"
|
|
|
|
#include "tree.h"
|
2014-10-27 13:41:01 +01:00
|
|
|
#include "predict.h"
|
|
|
|
#include "vec.h"
|
|
|
|
#include "hashtab.h"
|
|
|
|
#include "hash-set.h"
|
|
|
|
#include "machmode.h"
|
|
|
|
#include "hard-reg-set.h"
|
|
|
|
#include "input.h"
|
|
|
|
#include "function.h"
|
2013-11-22 16:58:51 +01:00
|
|
|
#include "basic-block.h"
|
|
|
|
#include "tree-ssa-alias.h"
|
|
|
|
#include "internal-fn.h"
|
|
|
|
#include "gimple-expr.h"
|
|
|
|
#include "is-a.h"
|
2013-10-29 13:55:50 +01:00
|
|
|
#include "gimple.h"
|
2009-10-03 23:10:11 +02:00
|
|
|
#include "expr.h"
|
|
|
|
#include "flags.h"
|
|
|
|
#include "params.h"
|
diagnostic-core.h: New.
* diagnostic-core.h: New. Contents moved from diagnostic.h and
toplev.h.
* diagnostic.c: Don't include toplev.h.
(progname): Define. Moved from toplev.c.
(seen_error): New function.
* diagnostic.h: Include diagnostic-core.h.
(diagnostic_t, emit_diagnostic): Don't declare here.
* toplev.c (progname): Move to toplev.c.
(emit_debug_global_declarations, compile_file, finalize,
do_compile, toplev_main): Use seen_error.
* toplev.h: Include diagnostic-core.h.
(trim_filename, GCC_DIAG_STYLE, ATTRIBUTE_GCC_DIAG,
internal_error, warning, warning_at, error, error_n, error_at,
fatal_error, pedwarn, permerror, sorry, inform, inform_n,
verbatim, fnotice, progname): Move to diagnostic-core.h.
* builtins.c: Include diagnostic-core.h instead of diagnostic.h.
(expand_builtin_expect): Use seen_error.
* c-decl.c: Include diagnostic-core.h instead of diagnostic.h.
(c_make_fname_decl, c_write_global_declarations): Use seen_error.
* c-format.c: Include diagnostic-core.h instead of diagnostic.h.
* c-gimplify.c: Include diagnostic-core.h instead of diagnostic.h.
* c-lang.c: Include diagnostic-core.h instead of diagnostic.h.
* c-lex.c (c_lex_with_flags, interpret_float): Don't increment
errorcount for errors.
* c-opts.c (c_common_finish): Use seen_error.
* cgraph.c: Include diagnostic-core.h instead of diagnostic.h.
* cgraphunit.c (verify_cgraph_node, verify_cgraph,
cgraph_output_pending_asms, cgraph_optimize): Use seen_error.
* coverage.c: Include diagnostic-core.h instead of diagnostic.h.
(get_coverage_counts): Use seen_error.
* dwarf2out.c (dwarf2out_finish): Use seen_error.
* gimplify.c (gimplify_var_or_parm_decl, gimple_push_cleanup,
gimplify_body): Use seen_error.
* ipa-inline.c (cgraph_early_inlining): Use seen_error.
* ipa-pure-const.c (gate_pure_const): Use seen_error.
* ipa-reference.c (gate_reference): Use seen_error.
* jump.c: Include diagnostic-core.h instead of diagnostic.h.
* lambda-code.c: Include diagnostic-core.h instead of
diagnostic.h.
* lto-cgraph.c: Include diagnostic-core.h instead of diagnostic.h.
* lto-compress.c: Include diagnostic-core.h instead of
diagnostic.h.
* lto-section-in.c: Include diagnostic-core.h instead of
diagnostic.h.
* lto-streamer-out.c: Include diagnostic-core.h instead of
diagnostic.h.
* lto-streamer.c: Include diagnostic-core.h instead of
diagnostic.h.
(gate_lto_out): Use seen_error.
* matrix-reorg.c: Include diagnostic-core.h instead of
diagnostic.h.
* omega.c: Include diagnostic-core.h instead of diagnostic.h.
* omp-low.c: Include diagnostic-core.h instead of diagnostic.h.
(gate_expand_omp, lower_omp_1): Use seen_error.
* passes.c: Include diagnostic-core.h instead of diagnostic.h.
(rest_of_decl_compilation, rest_of_type_compilation,
gate_rest_of_compilation, ipa_write_summaries): Use seen_error.
* tree-cfg.c (label_to_block_fn): Use seen_error.
* tree-inline.c (optimize_inline_calls): Use seen_error.
* tree-mudflap.c (mudflap_finish_file): Use
seen_error.
* tree-optimize.c (gate_all_optimizations,
gate_all_early_local_passes, gate_all_early_optimizations): Use
seen_error.
* tree-ssa-structalias.c (gate_ipa_pta): Use seen_error.
* varpool.c: Include diagnostic-core.h instead of diagnostic.h.
(varpool_remove_unreferenced_decls,
varpool_assemble_pending_decls): Use seen_error.
* Makefile.in (DIAGNOSTIC_CORE_H): Define.
(TOPLEV_H, DIAGNOSTIC_H): Update.
(c-decl.o, c-lang.o, c-format.o, lto-compress.o, lto-cgraph.o,
lto-streamer-out.o, lto-section-in.o, lto-streamer.o,
c-gimplify.o, omp-low.o, omega.o, diagnostic.o, passes.o,
builtins.o, jump.o, cgraph.o, varpool.o, matrix-reorg.o,
coverage.o, lambda-code.o): Update dependencies.
cp:
* call.c: Include diagnostic-core.h instead of diagnostic.h.
* cp-lang.c: Don't include diagnostic.h
* name-lookup.c: Include diagnostic-core.h instead of
diagnostic.h.
(cp_emit_debug_info_for_using): Use seen_error.
* optimize.c: Include diagnostic-core.h instead of diagnostic.h.
* parser.c: Include diagnostic-core.h instead of diagnostic.h.
* pt.c (iterative_hash_template_arg): Use seen_error.
* repo.c: Include diagnostic-core.h instead of diagnostic.h.
* typeck2.c: Include diagnostic-core.h instead of diagnostic.h.
* Make-lang.in (cp/cp-lang.o, cp/typeck2.o, cp/call.o, cp/repo.o,
cp/optimize.o, cp/parser.o, cp/name-lookup.o): Update
dependencies.
lto:
* lto.c: Include diagnostic-core.h instead of diagnostic.h.
(read_cgraph_and_symbols, lto_main): Use seen_error.
* Make-lang.in (lto/lto.o): Update dependencies.
objc:
* objc-act.c: Include diagnostic-core.h instead of diagnostic.h.
* Make-lang.in (objc/objc-act.o): Update dependencies.
From-SVN: r159947
2010-05-27 22:16:07 +02:00
|
|
|
#include "diagnostic-core.h"
|
2009-10-03 23:10:11 +02:00
|
|
|
#include "except.h"
|
|
|
|
#include "timevar.h"
|
2014-10-28 17:17:19 +01:00
|
|
|
#include "hash-map.h"
|
|
|
|
#include "plugin-api.h"
|
|
|
|
#include "ipa-ref.h"
|
|
|
|
#include "cgraph.h"
|
2009-10-03 23:10:11 +02:00
|
|
|
#include "lto-streamer.h"
|
|
|
|
#include "lto-compress.h"
|
|
|
|
|
|
|
|
/* Section names. These must correspond to the values of
|
|
|
|
enum lto_section_type. */
|
|
|
|
const char *lto_section_name[LTO_N_SECTION_TYPES] =
|
|
|
|
{
|
|
|
|
"decls",
|
|
|
|
"function_body",
|
2010-07-23 07:24:47 +02:00
|
|
|
"statics",
|
2012-08-11 10:38:59 +02:00
|
|
|
"symtab",
|
2010-05-06 10:39:32 +02:00
|
|
|
"refs",
|
2011-09-30 16:56:01 +02:00
|
|
|
"asm",
|
2010-07-23 07:24:47 +02:00
|
|
|
"jmpfuncs",
|
|
|
|
"pureconst",
|
|
|
|
"reference",
|
2013-03-29 19:07:34 +01:00
|
|
|
"profile",
|
2012-08-11 17:49:48 +02:00
|
|
|
"symbol_nodes",
|
2010-05-18 01:02:47 +02:00
|
|
|
"opts",
|
cgraph.c (dump_cgraph_node): Do not dump inline summaries.
* cgraph.c (dump_cgraph_node): Do not dump inline summaries.
* cgraph.h (struct inline_summary): Move to ipa-inline.h
(cgraph_local_info): Remove inline_summary.
* ipa-cp.c: Include ipa-inline.h.
(ipcp_cloning_candidate_p, ipcp_estimate_growth,
ipcp_estimate_cloning_cost, ipcp_insert_stage): Use inline_summary
accesor.
* lto-cgraph.c (lto_output_node): Do not stream inline summary.
(input_overwrite_node): Do not set inline summary.
(input_node): Do not stream inline summary.
* ipa-inline.c (cgraph_decide_inlining): Dump inline summaries.
(cgraph_decide_inlining_incrementally): Do not try to estimate overall
growth; we do not have inline parameters computed for that anyway.
(cgraph_early_inlining): After inlining compute call_stmt_sizes.
* ipa-inline.h (struct inline_summary): Move here from ipa-inline.h
(inline_summary_t): New type and VECtor.
(debug_inline_summary, dump_inline_summaries): Declare.
(inline_summary): Use VOCtor.
(estimate_edge_growth): Kill hack computing call stmt size directly.
* lto-section-in.c (lto_section_name): Add inline section.
* ipa-inline-analysis.c: Include lto-streamer.h
(node_removal_hook_holder, node_duplication_hook_holder): New holders
(inline_node_removal_hook, inline_node_duplication_hook): New functions.
(inline_summary_vec): Define.
(inline_summary_alloc, dump_inline_summary, debug_inline_summary,
dump_inline_summaries): New functions.
(estimate_function_body_sizes): Properly compute size/time of outgoing calls.
(compute_inline_parameters): Alloc inline_summary; do not compute size/time
of incomming calls.
(estimate_edge_time): Avoid missing time summary hack.
(inline_read_summary): Read inline summary info.
(inline_write_summary): Write inline summary info.
(inline_free_summary): Free all hooks and inline summary vector.
* lto-streamer.h: Add LTO_section_inline_summary section.
* Makefile.in (ipa-cp.o, ipa-inline-analysis.o): Update dependencies.
* ipa.c (cgraph_remove_unreachable_nodes): Fix dump file formating.
* lto.c: Include ipa-inline.h
(add_cgraph_node_to_partition, undo_partition): Use inline_summary accessor.
(ipa_node_duplication_hook): Fix declaration.
* Make-lang.in (lto.o): Update dependencies.
From-SVN: r172430
2011-04-14 15:26:44 +02:00
|
|
|
"cgraphopt",
|
2012-11-07 16:55:54 +01:00
|
|
|
"inline",
|
2014-10-16 12:47:55 +02:00
|
|
|
"ipcp_trans",
|
2014-11-13 14:44:04 +01:00
|
|
|
"icf",
|
|
|
|
"offload_table"
|
2009-10-03 23:10:11 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/* Hooks so that the ipa passes can call into the lto front end to get
|
|
|
|
sections. */
|
|
|
|
|
2009-11-25 11:55:54 +01:00
|
|
|
static struct lto_file_decl_data ** file_decl_data;
|
2009-10-03 23:10:11 +02:00
|
|
|
static lto_get_section_data_f* get_section_f;
|
|
|
|
static lto_free_section_data_f* free_section_f;
|
|
|
|
|
|
|
|
|
|
|
|
/* This is called from the lto front end to set up the hooks that are
|
|
|
|
used by the ipa passes to get the data that they will
|
|
|
|
deserialize. */
|
|
|
|
|
2009-11-25 11:55:54 +01:00
|
|
|
void
|
|
|
|
lto_set_in_hooks (struct lto_file_decl_data ** data,
|
2009-10-03 23:10:11 +02:00
|
|
|
lto_get_section_data_f* get_f,
|
|
|
|
lto_free_section_data_f* free_f)
|
|
|
|
{
|
|
|
|
file_decl_data = data;
|
|
|
|
get_section_f = get_f;
|
|
|
|
free_section_f = free_f;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Return an array of file decl datas for all of the files passed to
|
|
|
|
this compilation. */
|
|
|
|
|
|
|
|
struct lto_file_decl_data **
|
|
|
|
lto_get_file_decl_data (void)
|
|
|
|
{
|
|
|
|
gcc_assert (file_decl_data);
|
|
|
|
return file_decl_data;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Buffer structure for accumulating data from compression callbacks. */
|
|
|
|
|
|
|
|
struct lto_buffer
|
|
|
|
{
|
|
|
|
char *data;
|
|
|
|
size_t length;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Compression callback, append LENGTH bytes from DATA to the buffer pointed
|
|
|
|
to by OPAQUE. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
lto_append_data (const char *data, unsigned length, void *opaque)
|
|
|
|
{
|
|
|
|
struct lto_buffer *buffer = (struct lto_buffer *) opaque;
|
|
|
|
|
|
|
|
buffer->data = (char *) xrealloc (buffer->data, buffer->length + length);
|
|
|
|
memcpy (buffer->data + buffer->length, data, length);
|
|
|
|
buffer->length += length;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Header placed in returned uncompressed data streams. Allows the
|
|
|
|
uncompressed allocated data to be mapped back to the underlying
|
|
|
|
compressed data for use with free_section_f. */
|
|
|
|
|
|
|
|
struct lto_data_header
|
|
|
|
{
|
|
|
|
const char *data;
|
|
|
|
size_t len;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Return a char pointer to the start of a data stream for an LTO pass
|
|
|
|
or function. FILE_DATA indicates where to obtain the data.
|
|
|
|
SECTION_TYPE is the type of information to be obtained. NAME is
|
|
|
|
the name of the function and is only used when finding a function
|
|
|
|
body; otherwise it is NULL. LEN is the size of the data
|
|
|
|
returned. */
|
|
|
|
|
|
|
|
const char *
|
2009-11-25 11:55:54 +01:00
|
|
|
lto_get_section_data (struct lto_file_decl_data *file_data,
|
2009-10-03 23:10:11 +02:00
|
|
|
enum lto_section_type section_type,
|
2009-11-25 11:55:54 +01:00
|
|
|
const char *name,
|
2009-10-03 23:10:11 +02:00
|
|
|
size_t *len)
|
|
|
|
{
|
|
|
|
const char *data = (get_section_f) (file_data, section_type, name, len);
|
|
|
|
const size_t header_length = sizeof (struct lto_data_header);
|
|
|
|
struct lto_data_header *header;
|
|
|
|
struct lto_buffer buffer;
|
|
|
|
struct lto_compression_stream *stream;
|
|
|
|
lto_stats.section_size[section_type] += *len;
|
|
|
|
|
|
|
|
if (data == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/* FIXME lto: WPA mode does not write compressed sections, so for now
|
|
|
|
suppress uncompression if flag_ltrans. */
|
2014-03-04 12:25:50 +01:00
|
|
|
if (!flag_ltrans)
|
|
|
|
{
|
|
|
|
/* Create a mapping header containing the underlying data and length,
|
|
|
|
and prepend this to the uncompression buffer. The uncompressed data
|
|
|
|
then follows, and a pointer to the start of the uncompressed data is
|
|
|
|
returned. */
|
|
|
|
header = (struct lto_data_header *) xmalloc (header_length);
|
|
|
|
header->data = data;
|
|
|
|
header->len = *len;
|
|
|
|
|
|
|
|
buffer.data = (char *) header;
|
|
|
|
buffer.length = header_length;
|
|
|
|
|
|
|
|
stream = lto_start_uncompression (lto_append_data, &buffer);
|
|
|
|
lto_uncompress_block (stream, data, *len);
|
|
|
|
lto_end_uncompression (stream);
|
|
|
|
|
|
|
|
*len = buffer.length - header_length;
|
|
|
|
data = buffer.data + header_length;
|
|
|
|
}
|
|
|
|
|
2014-03-04 13:52:13 +01:00
|
|
|
lto_check_version (((const lto_header *)data)->major_version,
|
|
|
|
((const lto_header *)data)->minor_version);
|
2014-03-04 12:25:50 +01:00
|
|
|
return data;
|
2009-10-03 23:10:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Free the data found from the above call. The first three
|
|
|
|
parameters are the same as above. DATA is the data to be freed and
|
|
|
|
LEN is the length of that data. */
|
|
|
|
|
2009-11-25 11:55:54 +01:00
|
|
|
void
|
|
|
|
lto_free_section_data (struct lto_file_decl_data *file_data,
|
2009-10-03 23:10:11 +02:00
|
|
|
enum lto_section_type section_type,
|
|
|
|
const char *name,
|
|
|
|
const char *data,
|
|
|
|
size_t len)
|
|
|
|
{
|
|
|
|
const size_t header_length = sizeof (struct lto_data_header);
|
|
|
|
const char *real_data = data - header_length;
|
|
|
|
const struct lto_data_header *header
|
|
|
|
= (const struct lto_data_header *) real_data;
|
|
|
|
|
|
|
|
gcc_assert (free_section_f);
|
|
|
|
|
|
|
|
/* FIXME lto: WPA mode does not write compressed sections, so for now
|
|
|
|
suppress uncompression mapping if flag_ltrans. */
|
|
|
|
if (flag_ltrans)
|
|
|
|
{
|
|
|
|
(free_section_f) (file_data, section_type, name, data, len);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The underlying data address has been extracted from the mapping header.
|
|
|
|
Free that, then free the allocated uncompression buffer. */
|
|
|
|
(free_section_f) (file_data, section_type, name, header->data, header->len);
|
|
|
|
free (CONST_CAST (char *, real_data));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Load a section of type SECTION_TYPE from FILE_DATA, parse the
|
|
|
|
header and then return an input block pointing to the section. The
|
|
|
|
raw pointer to the section is returned in DATAR and LEN. These are
|
|
|
|
used to free the section. Return NULL if the section is not present. */
|
|
|
|
|
|
|
|
struct lto_input_block *
|
2009-11-25 11:55:54 +01:00
|
|
|
lto_create_simple_input_block (struct lto_file_decl_data *file_data,
|
2009-10-03 23:10:11 +02:00
|
|
|
enum lto_section_type section_type,
|
|
|
|
const char **datar, size_t *len)
|
|
|
|
{
|
|
|
|
const char *data = lto_get_section_data (file_data, section_type, NULL, len);
|
2009-11-25 11:55:54 +01:00
|
|
|
const struct lto_simple_header * header
|
2009-10-03 23:10:11 +02:00
|
|
|
= (const struct lto_simple_header *) data;
|
|
|
|
|
2011-12-13 22:59:39 +01:00
|
|
|
int main_offset = sizeof (struct lto_simple_header);
|
2009-10-03 23:10:11 +02:00
|
|
|
|
|
|
|
if (!data)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
*datar = data;
|
2014-08-08 14:55:31 +02:00
|
|
|
return new lto_input_block (data + main_offset, header->main_size);
|
2009-10-03 23:10:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Close the section returned from a call to
|
|
|
|
LTO_CREATE_SIMPLE_INPUT_BLOCK. IB is the input block returned from
|
|
|
|
that call. The FILE_DATA and SECTION_TYPE are the same as what was
|
|
|
|
passed to that call and the DATA and LEN are what was returned from
|
|
|
|
that call. */
|
|
|
|
|
|
|
|
void
|
2009-11-25 11:55:54 +01:00
|
|
|
lto_destroy_simple_input_block (struct lto_file_decl_data *file_data,
|
2009-10-03 23:10:11 +02:00
|
|
|
enum lto_section_type section_type,
|
|
|
|
struct lto_input_block *ib,
|
|
|
|
const char *data, size_t len)
|
|
|
|
{
|
2014-08-08 14:55:31 +02:00
|
|
|
delete ib;
|
2009-10-03 23:10:11 +02:00
|
|
|
lto_free_section_data (file_data, section_type, NULL, data, len);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
/* Record renamings of static declarations */
|
|
|
|
/*****************************************************************************/
|
|
|
|
|
|
|
|
struct lto_renaming_slot
|
|
|
|
{
|
|
|
|
const char *old_name;
|
|
|
|
const char *new_name;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Returns a hash code for P. */
|
|
|
|
|
|
|
|
static hashval_t
|
|
|
|
hash_name (const void *p)
|
|
|
|
{
|
|
|
|
const struct lto_renaming_slot *ds = (const struct lto_renaming_slot *) p;
|
|
|
|
return (hashval_t) htab_hash_string (ds->new_name);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Returns nonzero if P1 and P2 are equal. */
|
|
|
|
|
|
|
|
static int
|
|
|
|
eq_name (const void *p1, const void *p2)
|
|
|
|
{
|
|
|
|
const struct lto_renaming_slot *s1 =
|
|
|
|
(const struct lto_renaming_slot *) p1;
|
|
|
|
const struct lto_renaming_slot *s2 =
|
|
|
|
(const struct lto_renaming_slot *) p2;
|
|
|
|
|
|
|
|
return strcmp (s1->new_name, s2->new_name) == 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Free a renaming table entry. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
renaming_slot_free (void *slot)
|
|
|
|
{
|
|
|
|
struct lto_renaming_slot *s = (struct lto_renaming_slot *) slot;
|
|
|
|
|
|
|
|
free (CONST_CAST (void *, (const void *) s->old_name));
|
|
|
|
free (CONST_CAST (void *, (const void *) s->new_name));
|
|
|
|
free ((void *) s);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create an empty hash table for recording declaration renamings. */
|
|
|
|
|
|
|
|
htab_t
|
|
|
|
lto_create_renaming_table (void)
|
|
|
|
{
|
|
|
|
return htab_create (37, hash_name, eq_name, renaming_slot_free);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Record a declaration name mapping OLD_NAME -> NEW_NAME. DECL_DATA
|
|
|
|
holds the renaming hash table to use. */
|
|
|
|
|
|
|
|
void
|
|
|
|
lto_record_renamed_decl (struct lto_file_decl_data *decl_data,
|
|
|
|
const char *old_name, const char *new_name)
|
|
|
|
{
|
|
|
|
void **slot;
|
|
|
|
struct lto_renaming_slot r_slot;
|
|
|
|
|
|
|
|
r_slot.new_name = new_name;
|
|
|
|
slot = htab_find_slot (decl_data->renaming_hash_table, &r_slot, INSERT);
|
|
|
|
if (*slot == NULL)
|
|
|
|
{
|
|
|
|
struct lto_renaming_slot *new_slot = XNEW (struct lto_renaming_slot);
|
|
|
|
new_slot->old_name = xstrdup (old_name);
|
|
|
|
new_slot->new_name = xstrdup (new_name);
|
|
|
|
*slot = new_slot;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
gcc_unreachable ();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Given a string NAME, return the string that it has been mapped to
|
|
|
|
by lto_record_renamed_decl. If NAME was not renamed, it is
|
|
|
|
returned unchanged. DECL_DATA holds the renaming hash table to use. */
|
|
|
|
|
|
|
|
const char *
|
|
|
|
lto_get_decl_name_mapping (struct lto_file_decl_data *decl_data,
|
|
|
|
const char *name)
|
|
|
|
{
|
|
|
|
htab_t renaming_hash_table = decl_data->renaming_hash_table;
|
|
|
|
struct lto_renaming_slot *slot;
|
|
|
|
struct lto_renaming_slot r_slot;
|
|
|
|
|
|
|
|
r_slot.new_name = name;
|
|
|
|
slot = (struct lto_renaming_slot *) htab_find (renaming_hash_table, &r_slot);
|
|
|
|
if (slot)
|
|
|
|
return slot->old_name;
|
|
|
|
else
|
|
|
|
return name;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
/* Input decl state object. */
|
|
|
|
/*****************************************************************************/
|
|
|
|
|
|
|
|
/* Return a newly created in-decl state object. */
|
|
|
|
|
|
|
|
struct lto_in_decl_state *
|
|
|
|
lto_new_in_decl_state (void)
|
|
|
|
{
|
2014-05-18 01:07:23 +02:00
|
|
|
return ggc_cleared_alloc<lto_in_decl_state> ();
|
2009-10-03 23:10:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Delete STATE and its components. */
|
|
|
|
|
|
|
|
void
|
|
|
|
lto_delete_in_decl_state (struct lto_in_decl_state *state)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < LTO_N_DECL_STREAMS; i++)
|
|
|
|
if (state->streams[i].trees)
|
2010-04-30 00:44:18 +02:00
|
|
|
ggc_free (state->streams[i].trees);
|
|
|
|
ggc_free (state);
|
2009-10-03 23:10:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Hashtable helpers. lto_in_decl_states are hash by their function decls. */
|
|
|
|
|
|
|
|
hashval_t
|
|
|
|
lto_hash_in_decl_state (const void *p)
|
|
|
|
{
|
|
|
|
const struct lto_in_decl_state *state = (const struct lto_in_decl_state *) p;
|
|
|
|
return htab_hash_pointer (state->fn_decl);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return true if the fn_decl field of the lto_in_decl_state pointed to by
|
|
|
|
P1 equals to the function decl P2. */
|
|
|
|
|
|
|
|
int
|
|
|
|
lto_eq_in_decl_state (const void *p1, const void *p2)
|
|
|
|
{
|
|
|
|
const struct lto_in_decl_state *state1 =
|
|
|
|
(const struct lto_in_decl_state *) p1;
|
|
|
|
const struct lto_in_decl_state *state2 =
|
|
|
|
(const struct lto_in_decl_state *) p2;
|
|
|
|
return state1->fn_decl == state2->fn_decl;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Search the in-decl state of a function FUNC contained in the file
|
|
|
|
associated with FILE_DATA. Return NULL if not found. */
|
|
|
|
|
|
|
|
struct lto_in_decl_state*
|
|
|
|
lto_get_function_in_decl_state (struct lto_file_decl_data *file_data,
|
|
|
|
tree func)
|
|
|
|
{
|
|
|
|
struct lto_in_decl_state temp;
|
|
|
|
void **slot;
|
|
|
|
|
|
|
|
temp.fn_decl = func;
|
|
|
|
slot = htab_find_slot (file_data->function_decl_states, &temp, NO_INSERT);
|
|
|
|
return slot? ((struct lto_in_decl_state*) *slot) : NULL;
|
|
|
|
}
|
2011-05-02 14:37:13 +02:00
|
|
|
|
2013-08-30 09:33:06 +02:00
|
|
|
/* Free decl_states. */
|
|
|
|
|
|
|
|
void
|
|
|
|
lto_free_function_in_decl_state (struct lto_in_decl_state *state)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < LTO_N_DECL_STREAMS; i++)
|
|
|
|
ggc_free (state->streams[i].trees);
|
|
|
|
ggc_free (state);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Free decl_states associated with NODE. This makes it possible to furhter
|
|
|
|
release trees needed by the NODE's body. */
|
|
|
|
|
|
|
|
void
|
2013-10-31 22:26:14 +01:00
|
|
|
lto_free_function_in_decl_state_for_node (symtab_node *node)
|
2013-08-30 09:33:06 +02:00
|
|
|
{
|
|
|
|
struct lto_in_decl_state temp;
|
|
|
|
void **slot;
|
|
|
|
|
2013-10-29 19:30:00 +01:00
|
|
|
if (!node->lto_file_data)
|
2013-08-30 09:33:06 +02:00
|
|
|
return;
|
|
|
|
|
2013-10-29 19:30:00 +01:00
|
|
|
temp.fn_decl = node->decl;
|
|
|
|
slot = htab_find_slot (node->lto_file_data->function_decl_states,
|
2013-08-30 09:33:06 +02:00
|
|
|
&temp, NO_INSERT);
|
|
|
|
if (slot && *slot)
|
|
|
|
{
|
|
|
|
lto_free_function_in_decl_state ((struct lto_in_decl_state*) *slot);
|
2013-10-29 19:30:00 +01:00
|
|
|
htab_clear_slot (node->lto_file_data->function_decl_states,
|
2013-08-30 09:33:06 +02:00
|
|
|
slot);
|
|
|
|
}
|
2013-10-29 19:30:00 +01:00
|
|
|
node->lto_file_data = NULL;
|
2013-08-30 09:33:06 +02:00
|
|
|
}
|
|
|
|
|
2011-05-02 14:37:13 +02:00
|
|
|
|
|
|
|
/* Report read pass end of the section. */
|
|
|
|
|
|
|
|
void
|
|
|
|
lto_section_overrun (struct lto_input_block *ib)
|
|
|
|
{
|
2011-05-25 14:07:38 +02:00
|
|
|
fatal_error ("bytecode stream: trying to read %d bytes "
|
|
|
|
"after the end of the input buffer", ib->p - ib->len);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Report out of range value. */
|
|
|
|
|
|
|
|
void
|
|
|
|
lto_value_range_error (const char *purpose, HOST_WIDE_INT val,
|
|
|
|
HOST_WIDE_INT min, HOST_WIDE_INT max)
|
|
|
|
{
|
|
|
|
fatal_error ("%s out of range: Range is %i to %i, value is %i",
|
|
|
|
purpose, (int)min, (int)max, (int)val);
|
2011-05-02 14:37:13 +02:00
|
|
|
}
|