OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /
    from Rev 715 to Rev 716
    ↔ Reverse comparison
  •

Rev 715 → Rev 716

/openrisc/trunk/gnu-dev/or1k-gcc/gcc/lto/lto.c
0,0 → 1,2953
/* Top-level LTO routines.
Copyright 2009, 2010, 2011 Free Software Foundation, Inc.
Contributed by CodeSourcery, Inc.
 
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 "opts.h"
#include "toplev.h"
#include "tree.h"
#include "tree-flow.h"
#include "diagnostic-core.h"
#include "tm.h"
#include "cgraph.h"
#include "ggc.h"
#include "tree-ssa-operands.h"
#include "tree-pass.h"
#include "langhooks.h"
#include "vec.h"
#include "bitmap.h"
#include "pointer-set.h"
#include "ipa-prop.h"
#include "common.h"
#include "debug.h"
#include "timevar.h"
#include "gimple.h"
#include "lto.h"
#include "lto-tree.h"
#include "lto-streamer.h"
#include "tree-streamer.h"
#include "splay-tree.h"
#include "params.h"
#include "ipa-inline.h"
#include "ipa-utils.h"
 
static GTY(()) tree first_personality_decl;
 
/* Returns a hash code for P. */
 
static hashval_t
hash_name (const void *p)
{
const struct lto_section_slot *ds = (const struct lto_section_slot *) p;
return (hashval_t) htab_hash_string (ds->name);
}
 
 
/* Returns nonzero if P1 and P2 are equal. */
 
static int
eq_name (const void *p1, const void *p2)
{
const struct lto_section_slot *s1 =
(const struct lto_section_slot *) p1;
const struct lto_section_slot *s2 =
(const struct lto_section_slot *) p2;
 
return strcmp (s1->name, s2->name) == 0;
}
 
/* Free lto_section_slot */
 
static void
free_with_string (void *arg)
{
struct lto_section_slot *s = (struct lto_section_slot *)arg;
 
free (CONST_CAST (char *, s->name));
free (arg);
}
 
/* Create section hash table */
 
htab_t
lto_obj_create_section_hash_table (void)
{
return htab_create (37, hash_name, eq_name, free_with_string);
}
 
/* Delete an allocated integer KEY in the splay tree. */
 
static void
lto_splay_tree_delete_id (splay_tree_key key)
{
free ((void *) key);
}
 
/* Compare splay tree node ids A and B. */
 
static int
lto_splay_tree_compare_ids (splay_tree_key a, splay_tree_key b)
{
unsigned HOST_WIDE_INT ai;
unsigned HOST_WIDE_INT bi;
 
ai = *(unsigned HOST_WIDE_INT *) a;
bi = *(unsigned HOST_WIDE_INT *) b;
 
if (ai < bi)
return -1;
else if (ai > bi)
return 1;
return 0;
}
 
/* Look up splay tree node by ID in splay tree T. */
 
static splay_tree_node
lto_splay_tree_lookup (splay_tree t, unsigned HOST_WIDE_INT id)
{
return splay_tree_lookup (t, (splay_tree_key) &id);
}
 
/* Check if KEY has ID. */
 
static bool
lto_splay_tree_id_equal_p (splay_tree_key key, unsigned HOST_WIDE_INT id)
{
return *(unsigned HOST_WIDE_INT *) key == id;
}
 
/* Insert a splay tree node into tree T with ID as key and FILE_DATA as value.
The ID is allocated separately because we need HOST_WIDE_INTs which may
be wider than a splay_tree_key. */
 
static void
lto_splay_tree_insert (splay_tree t, unsigned HOST_WIDE_INT id,
struct lto_file_decl_data *file_data)
{
unsigned HOST_WIDE_INT *idp = XCNEW (unsigned HOST_WIDE_INT);
*idp = id;
splay_tree_insert (t, (splay_tree_key) idp, (splay_tree_value) file_data);
}
 
/* Create a splay tree. */
 
static splay_tree
lto_splay_tree_new (void)
{
return splay_tree_new (lto_splay_tree_compare_ids,
lto_splay_tree_delete_id,
NULL);
}
 
/* Read the constructors and inits. */
 
static void
lto_materialize_constructors_and_inits (struct lto_file_decl_data * file_data)
{
size_t len;
const char *data = lto_get_section_data (file_data,
LTO_section_static_initializer,
NULL, &len);
lto_input_constructors_and_inits (file_data, data);
lto_free_section_data (file_data, LTO_section_static_initializer, NULL,
data, len);
}
 
/* Return true when NODE has a clone that is analyzed (i.e. we need
to load its body even if the node itself is not needed). */
 
static bool
has_analyzed_clone_p (struct cgraph_node *node)
{
struct cgraph_node *orig = node;
node = node->clones;
if (node)
while (node != orig)
{
if (node->analyzed)
return true;
if (node->clones)
node = node->clones;
else if (node->next_sibling_clone)
node = node->next_sibling_clone;
else
{
while (node != orig && !node->next_sibling_clone)
node = node->clone_of;
if (node != orig)
node = node->next_sibling_clone;
}
}
return false;
}
 
/* Read the function body for the function associated with NODE. */
 
static void
lto_materialize_function (struct cgraph_node *node)
{
tree decl;
struct lto_file_decl_data *file_data;
const char *data, *name;
size_t len;
 
decl = node->decl;
/* Read in functions with body (analyzed nodes)
and also functions that are needed to produce virtual clones. */
if (cgraph_function_with_gimple_body_p (node) || has_analyzed_clone_p (node))
{
/* Clones and thunks don't need to be read. */
if (node->clone_of)
return;
 
/* Load the function body only if not operating in WPA mode. In
WPA mode, the body of the function is not needed. */
if (!flag_wpa)
{
file_data = node->local.lto_file_data;
name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 
/* We may have renamed the declaration, e.g., a static function. */
name = lto_get_decl_name_mapping (file_data, name);
 
data = lto_get_section_data (file_data, LTO_section_function_body,
name, &len);
if (!data)
fatal_error ("%s: section %s is missing",
file_data->file_name,
name);
 
gcc_assert (DECL_STRUCT_FUNCTION (decl) == NULL);
 
allocate_struct_function (decl, false);
announce_function (decl);
lto_input_function_body (file_data, decl, data);
if (DECL_FUNCTION_PERSONALITY (decl) && !first_personality_decl)
first_personality_decl = DECL_FUNCTION_PERSONALITY (decl);
lto_stats.num_function_bodies++;
lto_free_section_data (file_data, LTO_section_function_body, name,
data, len);
ggc_collect ();
}
}
 
/* Let the middle end know about the function. */
rest_of_decl_compilation (decl, 1, 0);
}
 
 
/* Decode the content of memory pointed to by DATA in the in decl
state object STATE. DATA_IN points to a data_in structure for
decoding. Return the address after the decoded object in the
input. */
 
static const uint32_t *
lto_read_in_decl_state (struct data_in *data_in, const uint32_t *data,
struct lto_in_decl_state *state)
{
uint32_t ix;
tree decl;
uint32_t i, j;
 
ix = *data++;
decl = streamer_tree_cache_get (data_in->reader_cache, ix);
if (TREE_CODE (decl) != FUNCTION_DECL)
{
gcc_assert (decl == void_type_node);
decl = NULL_TREE;
}
state->fn_decl = decl;
 
for (i = 0; i < LTO_N_DECL_STREAMS; i++)
{
uint32_t size = *data++;
tree *decls = ggc_alloc_vec_tree (size);
 
for (j = 0; j < size; j++)
decls[j] = streamer_tree_cache_get (data_in->reader_cache, data[j]);
 
state->streams[i].size = size;
state->streams[i].trees = decls;
data += size;
}
 
return data;
}
 
/* A hashtable of trees that potentially refer to variables or functions
that must be replaced with their prevailing variant. */
static GTY((if_marked ("ggc_marked_p"), param_is (union tree_node))) htab_t
tree_with_vars;
 
/* Remember that T is a tree that (potentially) refers to a variable
or function decl that may be replaced with its prevailing variant. */
static void
remember_with_vars (tree t)
{
*(tree *) htab_find_slot (tree_with_vars, t, INSERT) = t;
}
 
#define GIMPLE_REGISTER_TYPE(tt) \
(TREE_VISITED (tt) ? gimple_register_type (tt) : tt)
 
#define LTO_FIXUP_TREE(tt) \
do \
{ \
if (tt) \
{ \
if (TYPE_P (tt)) \
(tt) = GIMPLE_REGISTER_TYPE (tt); \
if (VAR_OR_FUNCTION_DECL_P (tt) && TREE_PUBLIC (tt)) \
remember_with_vars (t); \
} \
} while (0)
 
static void lto_fixup_types (tree);
 
/* Fix up fields of a tree_typed T. */
 
static void
lto_ft_typed (tree t)
{
LTO_FIXUP_TREE (TREE_TYPE (t));
}
 
/* Fix up fields of a tree_common T. */
 
static void
lto_ft_common (tree t)
{
lto_ft_typed (t);
LTO_FIXUP_TREE (TREE_CHAIN (t));
}
 
/* Fix up fields of a decl_minimal T. */
 
static void
lto_ft_decl_minimal (tree t)
{
lto_ft_common (t);
LTO_FIXUP_TREE (DECL_NAME (t));
LTO_FIXUP_TREE (DECL_CONTEXT (t));
}
 
/* Fix up fields of a decl_common T. */
 
static void
lto_ft_decl_common (tree t)
{
lto_ft_decl_minimal (t);
LTO_FIXUP_TREE (DECL_SIZE (t));
LTO_FIXUP_TREE (DECL_SIZE_UNIT (t));
LTO_FIXUP_TREE (DECL_INITIAL (t));
LTO_FIXUP_TREE (DECL_ATTRIBUTES (t));
LTO_FIXUP_TREE (DECL_ABSTRACT_ORIGIN (t));
}
 
/* Fix up fields of a decl_with_vis T. */
 
static void
lto_ft_decl_with_vis (tree t)
{
lto_ft_decl_common (t);
 
/* Accessor macro has side-effects, use field-name here. */
LTO_FIXUP_TREE (t->decl_with_vis.assembler_name);
LTO_FIXUP_TREE (DECL_SECTION_NAME (t));
}
 
/* Fix up fields of a decl_non_common T. */
 
static void
lto_ft_decl_non_common (tree t)
{
lto_ft_decl_with_vis (t);
LTO_FIXUP_TREE (DECL_ARGUMENT_FLD (t));
LTO_FIXUP_TREE (DECL_RESULT_FLD (t));
LTO_FIXUP_TREE (DECL_VINDEX (t));
/* The C frontends may create exact duplicates for DECL_ORIGINAL_TYPE
like for 'typedef enum foo foo'. We have no way of avoiding to
merge them and dwarf2out.c cannot deal with this,
so fix this up by clearing DECL_ORIGINAL_TYPE in this case. */
if (TREE_CODE (t) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (t) == TREE_TYPE (t))
DECL_ORIGINAL_TYPE (t) = NULL_TREE;
}
 
/* Fix up fields of a decl_non_common T. */
 
static void
lto_ft_function (tree t)
{
lto_ft_decl_non_common (t);
LTO_FIXUP_TREE (DECL_FUNCTION_PERSONALITY (t));
}
 
/* Fix up fields of a field_decl T. */
 
static void
lto_ft_field_decl (tree t)
{
lto_ft_decl_common (t);
LTO_FIXUP_TREE (DECL_FIELD_OFFSET (t));
LTO_FIXUP_TREE (DECL_BIT_FIELD_TYPE (t));
LTO_FIXUP_TREE (DECL_QUALIFIER (t));
LTO_FIXUP_TREE (DECL_FIELD_BIT_OFFSET (t));
LTO_FIXUP_TREE (DECL_FCONTEXT (t));
}
 
/* Fix up fields of a type T. */
 
static void
lto_ft_type (tree t)
{
lto_ft_common (t);
LTO_FIXUP_TREE (TYPE_CACHED_VALUES (t));
LTO_FIXUP_TREE (TYPE_SIZE (t));
LTO_FIXUP_TREE (TYPE_SIZE_UNIT (t));
LTO_FIXUP_TREE (TYPE_ATTRIBUTES (t));
LTO_FIXUP_TREE (TYPE_NAME (t));
 
/* Accessors are for derived node types only. */
if (!POINTER_TYPE_P (t))
LTO_FIXUP_TREE (TYPE_MINVAL (t));
LTO_FIXUP_TREE (TYPE_MAXVAL (t));
 
/* Accessor is for derived node types only. */
LTO_FIXUP_TREE (t->type_non_common.binfo);
 
LTO_FIXUP_TREE (TYPE_CONTEXT (t));
}
 
/* Fix up fields of a BINFO T. */
 
static void
lto_ft_binfo (tree t)
{
unsigned HOST_WIDE_INT i, n;
tree base, saved_base;
 
lto_ft_common (t);
LTO_FIXUP_TREE (BINFO_VTABLE (t));
LTO_FIXUP_TREE (BINFO_OFFSET (t));
LTO_FIXUP_TREE (BINFO_VIRTUALS (t));
LTO_FIXUP_TREE (BINFO_VPTR_FIELD (t));
n = VEC_length (tree, BINFO_BASE_ACCESSES (t));
for (i = 0; i < n; i++)
{
saved_base = base = BINFO_BASE_ACCESS (t, i);
LTO_FIXUP_TREE (base);
if (base != saved_base)
VEC_replace (tree, BINFO_BASE_ACCESSES (t), i, base);
}
LTO_FIXUP_TREE (BINFO_INHERITANCE_CHAIN (t));
LTO_FIXUP_TREE (BINFO_SUBVTT_INDEX (t));
LTO_FIXUP_TREE (BINFO_VPTR_INDEX (t));
n = BINFO_N_BASE_BINFOS (t);
for (i = 0; i < n; i++)
{
saved_base = base = BINFO_BASE_BINFO (t, i);
LTO_FIXUP_TREE (base);
if (base != saved_base)
VEC_replace (tree, BINFO_BASE_BINFOS (t), i, base);
}
}
 
/* Fix up fields of a CONSTRUCTOR T. */
 
static void
lto_ft_constructor (tree t)
{
unsigned HOST_WIDE_INT idx;
constructor_elt *ce;
 
lto_ft_typed (t);
 
for (idx = 0;
VEC_iterate(constructor_elt, CONSTRUCTOR_ELTS (t), idx, ce);
idx++)
{
LTO_FIXUP_TREE (ce->index);
LTO_FIXUP_TREE (ce->value);
}
}
 
/* Fix up fields of an expression tree T. */
 
static void
lto_ft_expr (tree t)
{
int i;
lto_ft_typed (t);
for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i)
LTO_FIXUP_TREE (TREE_OPERAND (t, i));
}
 
/* Given a tree T fixup fields of T by replacing types with their merged
variant and other entities by an equal entity from an earlier compilation
unit, or an entity being canonical in a different way. This includes
for instance integer or string constants. */
 
static void
lto_fixup_types (tree t)
{
switch (TREE_CODE (t))
{
case IDENTIFIER_NODE:
break;
 
case TREE_LIST:
LTO_FIXUP_TREE (TREE_VALUE (t));
LTO_FIXUP_TREE (TREE_PURPOSE (t));
LTO_FIXUP_TREE (TREE_CHAIN (t));
break;
 
case FIELD_DECL:
lto_ft_field_decl (t);
break;
 
case LABEL_DECL:
case CONST_DECL:
case PARM_DECL:
case RESULT_DECL:
case IMPORTED_DECL:
lto_ft_decl_common (t);
break;
 
case VAR_DECL:
lto_ft_decl_with_vis (t);
break;
 
case TYPE_DECL:
lto_ft_decl_non_common (t);
break;
 
case FUNCTION_DECL:
lto_ft_function (t);
break;
 
case TREE_BINFO:
lto_ft_binfo (t);
break;
 
case PLACEHOLDER_EXPR:
lto_ft_common (t);
break;
 
case BLOCK:
case TRANSLATION_UNIT_DECL:
case OPTIMIZATION_NODE:
case TARGET_OPTION_NODE:
break;
 
default:
if (TYPE_P (t))
lto_ft_type (t);
else if (TREE_CODE (t) == CONSTRUCTOR)
lto_ft_constructor (t);
else if (CONSTANT_CLASS_P (t))
LTO_FIXUP_TREE (TREE_TYPE (t));
else if (EXPR_P (t))
{
lto_ft_expr (t);
}
else
{
remember_with_vars (t);
}
}
}
 
 
/* Return the resolution for the decl with index INDEX from DATA_IN. */
 
static enum ld_plugin_symbol_resolution
get_resolution (struct data_in *data_in, unsigned index)
{
if (data_in->globals_resolution)
{
ld_plugin_symbol_resolution_t ret;
/* We can have references to not emitted functions in
DECL_FUNCTION_PERSONALITY at least. So we can and have
to indeed return LDPR_UNKNOWN in some cases. */
if (VEC_length (ld_plugin_symbol_resolution_t,
data_in->globals_resolution) <= index)
return LDPR_UNKNOWN;
ret = VEC_index (ld_plugin_symbol_resolution_t,
data_in->globals_resolution,
index);
return ret;
}
else
/* Delay resolution finding until decl merging. */
return LDPR_UNKNOWN;
}
 
 
/* Register DECL with the global symbol table and change its
name if necessary to avoid name clashes for static globals across
different files. */
 
static void
lto_register_var_decl_in_symtab (struct data_in *data_in, tree decl)
{
tree context;
 
/* Variable has file scope, not local. Need to ensure static variables
between different files don't clash unexpectedly. */
if (!TREE_PUBLIC (decl)
&& !((context = decl_function_context (decl))
&& auto_var_in_fn_p (decl, context)))
{
/* ??? We normally pre-mangle names before we serialize them
out. Here, in lto1, we do not know the language, and
thus cannot do the mangling again. Instead, we just
append a suffix to the mangled name. The resulting name,
however, is not a properly-formed mangled name, and will
confuse any attempt to unmangle it. */
const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
char *label;
 
ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
rest_of_decl_compilation (decl, 1, 0);
VEC_safe_push (tree, gc, lto_global_var_decls, decl);
}
 
/* If this variable has already been declared, queue the
declaration for merging. */
if (TREE_PUBLIC (decl))
{
unsigned ix;
if (!streamer_tree_cache_lookup (data_in->reader_cache, decl, &ix))
gcc_unreachable ();
lto_symtab_register_decl (decl, get_resolution (data_in, ix),
data_in->file_data);
}
}
 
 
/* Register DECL with the global symbol table and change its
name if necessary to avoid name clashes for static globals across
different files. DATA_IN contains descriptors and tables for the
file being read. */
 
static void
lto_register_function_decl_in_symtab (struct data_in *data_in, tree decl)
{
/* Need to ensure static entities between different files
don't clash unexpectedly. */
if (!TREE_PUBLIC (decl))
{
/* We must not use the DECL_ASSEMBLER_NAME macro here, as it
may set the assembler name where it was previously empty. */
tree old_assembler_name = decl->decl_with_vis.assembler_name;
 
/* FIXME lto: We normally pre-mangle names before we serialize
them out. Here, in lto1, we do not know the language, and
thus cannot do the mangling again. Instead, we just append a
suffix to the mangled name. The resulting name, however, is
not a properly-formed mangled name, and will confuse any
attempt to unmangle it. */
const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
char *label;
 
ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
 
/* We may arrive here with the old assembler name not set
if the function body is not needed, e.g., it has been
inlined away and does not appear in the cgraph. */
if (old_assembler_name)
{
tree new_assembler_name = DECL_ASSEMBLER_NAME (decl);
 
/* Make the original assembler name available for later use.
We may have used it to indicate the section within its
object file where the function body may be found.
FIXME lto: Find a better way to maintain the function decl
to body section mapping so we don't need this hack. */
lto_record_renamed_decl (data_in->file_data,
IDENTIFIER_POINTER (old_assembler_name),
IDENTIFIER_POINTER (new_assembler_name));
}
}
 
/* If this variable has already been declared, queue the
declaration for merging. */
if (TREE_PUBLIC (decl) && !DECL_ABSTRACT (decl))
{
unsigned ix;
if (!streamer_tree_cache_lookup (data_in->reader_cache, decl, &ix))
gcc_unreachable ();
lto_symtab_register_decl (decl, get_resolution (data_in, ix),
data_in->file_data);
}
}
 
 
/* Given a streamer cache structure DATA_IN (holding a sequence of trees
for one compilation unit) go over all trees starting at index FROM until the
end of the sequence and replace fields of those trees, and the trees
themself with their canonical variants as per gimple_register_type. */
 
static void
uniquify_nodes (struct data_in *data_in, unsigned from)
{
struct streamer_tree_cache_d *cache = data_in->reader_cache;
unsigned len = VEC_length (tree, cache->nodes);
unsigned i;
 
/* Go backwards because children streamed for the first time come
as part of their parents, and hence are created after them. */
 
/* First register all the types in the cache. This makes sure to
have the original structure in the type cycles when registering
them and computing hashes. */
for (i = len; i-- > from;)
{
tree t = VEC_index (tree, cache->nodes, i);
if (t && TYPE_P (t))
{
tree newt = gimple_register_type (t);
/* Mark non-prevailing types so we fix them up. No need
to reset that flag afterwards - nothing that refers
to those types is left and they are collected. */
if (newt != t)
TREE_VISITED (t) = 1;
}
}
 
/* Second fixup all trees in the new cache entries. */
for (i = len; i-- > from;)
{
tree t = VEC_index (tree, cache->nodes, i);
tree oldt = t;
if (!t)
continue;
 
/* First fixup the fields of T. */
lto_fixup_types (t);
 
if (!TYPE_P (t))
continue;
 
/* Now try to find a canonical variant of T itself. */
t = GIMPLE_REGISTER_TYPE (t);
 
if (t == oldt)
{
/* The following re-creates proper variant lists while fixing up
the variant leaders. We do not stream TYPE_NEXT_VARIANT so the
variant list state before fixup is broken. */
tree tem, mv;
 
/* Remove us from our main variant list if we are not the
variant leader. */
if (TYPE_MAIN_VARIANT (t) != t)
{
tem = TYPE_MAIN_VARIANT (t);
while (tem && TYPE_NEXT_VARIANT (tem) != t)
tem = TYPE_NEXT_VARIANT (tem);
if (tem)
TYPE_NEXT_VARIANT (tem) = TYPE_NEXT_VARIANT (t);
TYPE_NEXT_VARIANT (t) = NULL_TREE;
}
 
/* Query our new main variant. */
mv = GIMPLE_REGISTER_TYPE (TYPE_MAIN_VARIANT (t));
 
/* If we were the variant leader and we get replaced ourselves drop
all variants from our list. */
if (TYPE_MAIN_VARIANT (t) == t
&& mv != t)
{
tem = t;
while (tem)
{
tree tem2 = TYPE_NEXT_VARIANT (tem);
TYPE_NEXT_VARIANT (tem) = NULL_TREE;
tem = tem2;
}
}
 
/* If we are not our own variant leader link us into our new leaders
variant list. */
if (mv != t)
{
TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (mv);
TYPE_NEXT_VARIANT (mv) = t;
if (RECORD_OR_UNION_TYPE_P (t))
TYPE_BINFO (t) = TYPE_BINFO (mv);
}
 
/* Finally adjust our main variant and fix it up. */
TYPE_MAIN_VARIANT (t) = mv;
 
/* The following reconstructs the pointer chains
of the new pointed-to type if we are a main variant. We do
not stream those so they are broken before fixup. */
if (TREE_CODE (t) == POINTER_TYPE
&& TYPE_MAIN_VARIANT (t) == t)
{
TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (TREE_TYPE (t));
TYPE_POINTER_TO (TREE_TYPE (t)) = t;
}
else if (TREE_CODE (t) == REFERENCE_TYPE
&& TYPE_MAIN_VARIANT (t) == t)
{
TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (TREE_TYPE (t));
TYPE_REFERENCE_TO (TREE_TYPE (t)) = t;
}
}
 
else
{
if (RECORD_OR_UNION_TYPE_P (t))
{
tree f1, f2;
if (TYPE_FIELDS (t) != TYPE_FIELDS (oldt))
for (f1 = TYPE_FIELDS (t), f2 = TYPE_FIELDS (oldt);
f1 && f2; f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2))
{
unsigned ix;
gcc_assert (f1 != f2 && DECL_NAME (f1) == DECL_NAME (f2));
if (!streamer_tree_cache_lookup (cache, f2, &ix))
gcc_unreachable ();
/* If we're going to replace an element which we'd
still visit in the next iterations, we wouldn't
handle it, so do it here. We do have to handle it
even though the field_decl itself will be removed,
as it could refer to e.g. integer_cst which we
wouldn't reach via any other way, hence they
(and their type) would stay uncollected. */
/* ??? We should rather make sure to replace all
references to f2 with f1. That means handling
COMPONENT_REFs and CONSTRUCTOR elements in
lto_fixup_types and special-case the field-decl
operand handling. */
if (ix < i)
lto_fixup_types (f2);
streamer_tree_cache_insert_at (cache, f1, ix);
}
}
 
/* If we found a tree that is equal to oldt replace it in the
cache, so that further users (in the various LTO sections)
make use of it. */
streamer_tree_cache_insert_at (cache, t, i);
}
}
 
/* Finally compute the canonical type of all TREE_TYPEs and register
VAR_DECL and FUNCTION_DECL nodes in the symbol table.
From this point there are no longer any types with
TYPE_STRUCTURAL_EQUALITY_P and its type-based alias problems.
This step requires the TYPE_POINTER_TO lists being present, so
make sure it is done last. */
for (i = len; i-- > from;)
{
tree t = VEC_index (tree, cache->nodes, i);
if (t == NULL_TREE)
continue;
 
if (TREE_CODE (t) == VAR_DECL)
lto_register_var_decl_in_symtab (data_in, t);
else if (TREE_CODE (t) == FUNCTION_DECL && !DECL_BUILT_IN (t))
lto_register_function_decl_in_symtab (data_in, t);
else if (!flag_wpa
&& TREE_CODE (t) == TYPE_DECL)
debug_hooks->type_decl (t, !DECL_FILE_SCOPE_P (t));
else if (TYPE_P (t) && !TYPE_CANONICAL (t))
TYPE_CANONICAL (t) = gimple_register_canonical_type (t);
}
}
 
 
/* Read all the symbols from buffer DATA, using descriptors in DECL_DATA.
RESOLUTIONS is the set of symbols picked by the linker (read from the
resolution file when the linker plugin is being used). */
 
static void
lto_read_decls (struct lto_file_decl_data *decl_data, const void *data,
VEC(ld_plugin_symbol_resolution_t,heap) *resolutions)
{
const struct lto_decl_header *header = (const struct lto_decl_header *) data;
const int decl_offset = sizeof (struct lto_decl_header);
const int main_offset = decl_offset + header->decl_state_size;
const int string_offset = main_offset + header->main_size;
struct lto_input_block ib_main;
struct data_in *data_in;
unsigned int i;
const uint32_t *data_ptr, *data_end;
uint32_t num_decl_states;
 
LTO_INIT_INPUT_BLOCK (ib_main, (const char *) data + main_offset, 0,
header->main_size);
 
data_in = lto_data_in_create (decl_data, (const char *) data + string_offset,
header->string_size, resolutions);
 
/* We do not uniquify the pre-loaded cache entries, those are middle-end
internal types that should not be merged. */
 
/* Read the global declarations and types. */
while (ib_main.p < ib_main.len)
{
tree t;
unsigned from = VEC_length (tree, data_in->reader_cache->nodes);
t = stream_read_tree (&ib_main, data_in);
gcc_assert (t && ib_main.p <= ib_main.len);
uniquify_nodes (data_in, from);
}
 
/* Read in lto_in_decl_state objects. */
data_ptr = (const uint32_t *) ((const char*) data + decl_offset);
data_end =
(const uint32_t *) ((const char*) data_ptr + header->decl_state_size);
num_decl_states = *data_ptr++;
gcc_assert (num_decl_states > 0);
decl_data->global_decl_state = lto_new_in_decl_state ();
data_ptr = lto_read_in_decl_state (data_in, data_ptr,
decl_data->global_decl_state);
 
/* Read in per-function decl states and enter them in hash table. */
decl_data->function_decl_states =
htab_create_ggc (37, lto_hash_in_decl_state, lto_eq_in_decl_state, NULL);
 
for (i = 1; i < num_decl_states; i++)
{
struct lto_in_decl_state *state = lto_new_in_decl_state ();
void **slot;
 
data_ptr = lto_read_in_decl_state (data_in, data_ptr, state);
slot = htab_find_slot (decl_data->function_decl_states, state, INSERT);
gcc_assert (*slot == NULL);
*slot = state;
}
 
if (data_ptr != data_end)
internal_error ("bytecode stream: garbage at the end of symbols section");
 
/* Set the current decl state to be the global state. */
decl_data->current_decl_state = decl_data->global_decl_state;
 
lto_data_in_delete (data_in);
}
 
/* Custom version of strtoll, which is not portable. */
 
static HOST_WIDEST_INT
lto_parse_hex (const char *p)
{
HOST_WIDEST_INT ret = 0;
 
for (; *p != '\0'; ++p)
{
char c = *p;
unsigned char part;
ret <<= 4;
if (c >= '0' && c <= '9')
part = c - '0';
else if (c >= 'a' && c <= 'f')
part = c - 'a' + 10;
else if (c >= 'A' && c <= 'F')
part = c - 'A' + 10;
else
internal_error ("could not parse hex number");
ret |= part;
}
 
return ret;
}
 
/* Read resolution for file named FILE_NAME. The resolution is read from
RESOLUTION. */
 
static void
lto_resolution_read (splay_tree file_ids, FILE *resolution, lto_file *file)
{
/* We require that objects in the resolution file are in the same
order as the lto1 command line. */
unsigned int name_len;
char *obj_name;
unsigned int num_symbols;
unsigned int i;
struct lto_file_decl_data *file_data;
unsigned max_index = 0;
splay_tree_node nd = NULL;
 
if (!resolution)
return;
 
name_len = strlen (file->filename);
obj_name = XNEWVEC (char, name_len + 1);
fscanf (resolution, " "); /* Read white space. */
 
fread (obj_name, sizeof (char), name_len, resolution);
obj_name[name_len] = '\0';
if (filename_cmp (obj_name, file->filename) != 0)
internal_error ("unexpected file name %s in linker resolution file. "
"Expected %s", obj_name, file->filename);
if (file->offset != 0)
{
int t;
char offset_p[17];
HOST_WIDEST_INT offset;
t = fscanf (resolution, "@0x%16s", offset_p);
if (t != 1)
internal_error ("could not parse file offset");
offset = lto_parse_hex (offset_p);
if (offset != file->offset)
internal_error ("unexpected offset");
}
 
free (obj_name);
 
fscanf (resolution, "%u", &num_symbols);
 
for (i = 0; i < num_symbols; i++)
{
int t;
unsigned index;
unsigned HOST_WIDE_INT id;
char r_str[27];
enum ld_plugin_symbol_resolution r = (enum ld_plugin_symbol_resolution) 0;
unsigned int j;
unsigned int lto_resolution_str_len =
sizeof (lto_resolution_str) / sizeof (char *);
 
t = fscanf (resolution, "%u " HOST_WIDE_INT_PRINT_HEX_PURE " %26s %*[^\n]\n",
&index, &id, r_str);
if (t != 3)
internal_error ("invalid line in the resolution file");
if (index > max_index)
max_index = index;
 
for (j = 0; j < lto_resolution_str_len; j++)
{
if (strcmp (lto_resolution_str[j], r_str) == 0)
{
r = (enum ld_plugin_symbol_resolution) j;
break;
}
}
if (j == lto_resolution_str_len)
internal_error ("invalid resolution in the resolution file");
 
if (!(nd && lto_splay_tree_id_equal_p (nd->key, id)))
{
nd = lto_splay_tree_lookup (file_ids, id);
if (nd == NULL)
internal_error ("resolution sub id " HOST_WIDE_INT_PRINT_HEX_PURE
" not in object file", id);
}
 
file_data = (struct lto_file_decl_data *)nd->value;
VEC_safe_grow_cleared (ld_plugin_symbol_resolution_t, heap,
file_data->resolutions,
max_index + 1);
VEC_replace (ld_plugin_symbol_resolution_t,
file_data->resolutions, index, r);
}
}
 
/* List of file_decl_datas */
struct file_data_list
{
struct lto_file_decl_data *first, *last;
};
 
/* Is the name for a id'ed LTO section? */
 
static int
lto_section_with_id (const char *name, unsigned HOST_WIDE_INT *id)
{
const char *s;
 
if (strncmp (name, LTO_SECTION_NAME_PREFIX, strlen (LTO_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 */
 
static int
create_subid_section_table (struct lto_section_slot *ls, splay_tree file_ids,
struct file_data_list *list)
{
struct lto_section_slot s_slot, *new_slot;
unsigned HOST_WIDE_INT id;
splay_tree_node nd;
void **hash_slot;
char *new_name;
struct lto_file_decl_data *file_data;
 
if (!lto_section_with_id (ls->name, &id))
return 1;
/* Find hash table of sub module id */
nd = lto_splay_tree_lookup (file_ids, id);
if (nd != NULL)
{
file_data = (struct lto_file_decl_data *)nd->value;
}
else
{
file_data = ggc_alloc_lto_file_decl_data ();
memset(file_data, 0, sizeof (struct lto_file_decl_data));
file_data->id = id;
file_data->section_hash_table = lto_obj_create_section_hash_table ();;
lto_splay_tree_insert (file_ids, id, file_data);
 
/* Maintain list in linker order */
if (!list->first)
list->first = file_data;
if (list->last)
list->last->next = file_data;
list->last = file_data;
}
 
/* Copy section into sub module hash table */
new_name = XDUPVEC (char, ls->name, strlen (ls->name) + 1);
s_slot.name = new_name;
hash_slot = htab_find_slot (file_data->section_hash_table, &s_slot, INSERT);
gcc_assert (*hash_slot == NULL);
 
new_slot = XDUP (struct lto_section_slot, ls);
new_slot->name = new_name;
*hash_slot = new_slot;
return 1;
}
 
/* Read declarations and other initializations for a FILE_DATA. */
 
static void
lto_file_finalize (struct lto_file_decl_data *file_data, lto_file *file)
{
const char *data;
size_t len;
 
file_data->renaming_hash_table = lto_create_renaming_table ();
file_data->file_name = file->filename;
data = lto_get_section_data (file_data, LTO_section_decls, NULL, &len);
if (data == NULL)
{
internal_error ("cannot read LTO decls from %s", file_data->file_name);
return;
}
lto_read_decls (file_data, data, file_data->resolutions);
lto_free_section_data (file_data, LTO_section_decls, NULL, data, len);
}
 
/* Finalize FILE_DATA in FILE and increase COUNT. */
 
static int
lto_create_files_from_ids (lto_file *file, struct lto_file_decl_data *file_data,
int *count)
{
lto_file_finalize (file_data, file);
if (cgraph_dump_file)
fprintf (cgraph_dump_file, "Creating file %s with sub id " HOST_WIDE_INT_PRINT_HEX "\n",
file_data->file_name, file_data->id);
(*count)++;
return 0;
}
 
/* Generate a TREE representation for all types and external decls
entities in FILE.
 
Read all of the globals out of the file. Then read the cgraph
and process the .o index into the cgraph nodes so that it can open
the .o file to load the functions and ipa information. */
 
static struct lto_file_decl_data *
lto_file_read (lto_file *file, FILE *resolution_file, int *count)
{
struct lto_file_decl_data *file_data = NULL;
splay_tree file_ids;
htab_t section_hash_table;
struct lto_section_slot *section;
struct file_data_list file_list;
struct lto_section_list section_list;
memset (&section_list, 0, sizeof (struct lto_section_list));
section_hash_table = lto_obj_build_section_table (file, &section_list);
 
/* Find all sub modules in the object and put their sections into new hash
tables in a splay tree. */
file_ids = lto_splay_tree_new ();
memset (&file_list, 0, sizeof (struct file_data_list));
for (section = section_list.first; section != NULL; section = section->next)
create_subid_section_table (section, file_ids, &file_list);
 
/* Add resolutions to file ids */
lto_resolution_read (file_ids, resolution_file, file);
 
/* Finalize each lto file for each submodule in the merged object */
for (file_data = file_list.first; file_data != NULL; file_data = file_data->next)
lto_create_files_from_ids (file, file_data, count);
splay_tree_delete (file_ids);
htab_delete (section_hash_table);
 
return file_list.first;
}
 
#if HAVE_MMAP_FILE && HAVE_SYSCONF && defined _SC_PAGE_SIZE
#define LTO_MMAP_IO 1
#endif
 
#if LTO_MMAP_IO
/* Page size of machine is used for mmap and munmap calls. */
static size_t page_mask;
#endif
 
/* Get the section data of length LEN from FILENAME starting at
OFFSET. The data segment must be freed by the caller when the
caller is finished. Returns NULL if all was not well. */
 
static char *
lto_read_section_data (struct lto_file_decl_data *file_data,
intptr_t offset, size_t len)
{
char *result;
static int fd = -1;
static char *fd_name;
#if LTO_MMAP_IO
intptr_t computed_len;
intptr_t computed_offset;
intptr_t diff;
#endif
 
/* Keep a single-entry file-descriptor cache. The last file we
touched will get closed at exit.
??? Eventually we want to add a more sophisticated larger cache
or rather fix function body streaming to not stream them in
practically random order. */
if (fd != -1
&& filename_cmp (fd_name, file_data->file_name) != 0)
{
free (fd_name);
close (fd);
fd = -1;
}
if (fd == -1)
{
fd = open (file_data->file_name, O_RDONLY|O_BINARY);
if (fd == -1)
{
fatal_error ("Cannot open %s", file_data->file_name);
return NULL;
}
fd_name = xstrdup (file_data->file_name);
}
 
#if LTO_MMAP_IO
if (!page_mask)
{
size_t page_size = sysconf (_SC_PAGE_SIZE);
page_mask = ~(page_size - 1);
}
 
computed_offset = offset & page_mask;
diff = offset - computed_offset;
computed_len = len + diff;
 
result = (char *) mmap (NULL, computed_len, PROT_READ, MAP_PRIVATE,
fd, computed_offset);
if (result == MAP_FAILED)
{
fatal_error ("Cannot map %s", file_data->file_name);
return NULL;
}
 
return result + diff;
#else
result = (char *) xmalloc (len);
if (lseek (fd, offset, SEEK_SET) != offset
|| read (fd, result, len) != (ssize_t) len)
{
free (result);
fatal_error ("Cannot read %s", file_data->file_name);
result = NULL;
}
#ifdef __MINGW32__
/* Native windows doesn't supports delayed unlink on opened file. So
we close file here again. This produces higher I/O load, but at least
it prevents to have dangling file handles preventing unlink. */
free (fd_name);
fd_name = NULL;
close (fd);
fd = -1;
#endif
return result;
#endif
}
 
 
/* Get the section data from FILE_DATA of SECTION_TYPE with NAME.
NAME will be NULL unless the section type is for a function
body. */
 
static const char *
get_section_data (struct lto_file_decl_data *file_data,
enum lto_section_type section_type,
const char *name,
size_t *len)
{
htab_t section_hash_table = file_data->section_hash_table;
struct lto_section_slot *f_slot;
struct lto_section_slot s_slot;
const char *section_name = lto_get_section_name (section_type, name, file_data);
char *data = NULL;
 
*len = 0;
s_slot.name = section_name;
f_slot = (struct lto_section_slot *) htab_find (section_hash_table, &s_slot);
if (f_slot)
{
data = lto_read_section_data (file_data, f_slot->start, f_slot->len);
*len = f_slot->len;
}
 
free (CONST_CAST (char *, section_name));
return data;
}
 
 
/* Free the section data from FILE_DATA of SECTION_TYPE with NAME that
starts at OFFSET and has LEN bytes. */
 
static void
free_section_data (struct lto_file_decl_data *file_data ATTRIBUTE_UNUSED,
enum lto_section_type section_type ATTRIBUTE_UNUSED,
const char *name ATTRIBUTE_UNUSED,
const char *offset, size_t len ATTRIBUTE_UNUSED)
{
#if LTO_MMAP_IO
intptr_t computed_len;
intptr_t computed_offset;
intptr_t diff;
#endif
 
#if LTO_MMAP_IO
computed_offset = ((intptr_t) offset) & page_mask;
diff = (intptr_t) offset - computed_offset;
computed_len = len + diff;
 
munmap ((caddr_t) computed_offset, computed_len);
#else
free (CONST_CAST(char *, offset));
#endif
}
 
/* Structure describing ltrans partitions. */
 
struct ltrans_partition_def
{
cgraph_node_set cgraph_set;
varpool_node_set varpool_set;
const char * name;
int insns;
};
 
typedef struct ltrans_partition_def *ltrans_partition;
DEF_VEC_P(ltrans_partition);
DEF_VEC_ALLOC_P(ltrans_partition,heap);
 
static VEC(ltrans_partition, heap) *ltrans_partitions;
 
static void add_cgraph_node_to_partition (ltrans_partition part, struct cgraph_node *node);
static void add_varpool_node_to_partition (ltrans_partition part, struct varpool_node *vnode);
 
/* Create new partition with name NAME. */
static ltrans_partition
new_partition (const char *name)
{
ltrans_partition part = XCNEW (struct ltrans_partition_def);
part->cgraph_set = cgraph_node_set_new ();
part->varpool_set = varpool_node_set_new ();
part->name = name;
part->insns = 0;
VEC_safe_push (ltrans_partition, heap, ltrans_partitions, part);
return part;
}
 
/* Free memory used by ltrans datastructures. */
static void
free_ltrans_partitions (void)
{
unsigned int idx;
ltrans_partition part;
for (idx = 0; VEC_iterate (ltrans_partition, ltrans_partitions, idx, part); idx++)
{
free_cgraph_node_set (part->cgraph_set);
free (part);
}
VEC_free (ltrans_partition, heap, ltrans_partitions);
}
 
/* See all references that go to comdat objects and bring them into partition too. */
static void
add_references_to_partition (ltrans_partition part, struct ipa_ref_list *refs)
{
int i;
struct ipa_ref *ref;
for (i = 0; ipa_ref_list_reference_iterate (refs, i, ref); i++)
{
if (ref->refered_type == IPA_REF_CGRAPH
&& DECL_COMDAT (cgraph_function_node (ipa_ref_node (ref), NULL)->decl)
&& !cgraph_node_in_set_p (ipa_ref_node (ref), part->cgraph_set))
add_cgraph_node_to_partition (part, ipa_ref_node (ref));
else
if (ref->refered_type == IPA_REF_VARPOOL
&& DECL_COMDAT (ipa_ref_varpool_node (ref)->decl)
&& !varpool_node_in_set_p (ipa_ref_varpool_node (ref), part->varpool_set))
add_varpool_node_to_partition (part, ipa_ref_varpool_node (ref));
}
}
 
/* Worker for add_cgraph_node_to_partition. */
 
static bool
add_cgraph_node_to_partition_1 (struct cgraph_node *node, void *data)
{
ltrans_partition part = (ltrans_partition) data;
 
/* non-COMDAT aliases of COMDAT functions needs to be output just once. */
if (!DECL_COMDAT (node->decl)
&& !node->global.inlined_to
&& node->aux)
{
gcc_assert (node->thunk.thunk_p || node->alias);
return false;
}
 
if (node->aux)
{
node->in_other_partition = 1;
if (cgraph_dump_file)
fprintf (cgraph_dump_file, "Node %s/%i now used in multiple partitions\n",
cgraph_node_name (node), node->uid);
}
node->aux = (void *)((size_t)node->aux + 1);
cgraph_node_set_add (part->cgraph_set, node);
return false;
}
 
/* Add NODE to partition as well as the inline callees and referred comdats into partition PART. */
 
static void
add_cgraph_node_to_partition (ltrans_partition part, struct cgraph_node *node)
{
struct cgraph_edge *e;
cgraph_node_set_iterator csi;
struct cgraph_node *n;
 
/* We always decide on functions, not associated thunks and aliases. */
node = cgraph_function_node (node, NULL);
 
/* If NODE is already there, we have nothing to do. */
csi = cgraph_node_set_find (part->cgraph_set, node);
if (!csi_end_p (csi))
return;
 
cgraph_for_node_thunks_and_aliases (node, add_cgraph_node_to_partition_1, part, true);
 
part->insns += inline_summary (node)->self_size;
 
 
cgraph_node_set_add (part->cgraph_set, node);
 
for (e = node->callees; e; e = e->next_callee)
if ((!e->inline_failed
|| DECL_COMDAT (cgraph_function_node (e->callee, NULL)->decl))
&& !cgraph_node_in_set_p (e->callee, part->cgraph_set))
add_cgraph_node_to_partition (part, e->callee);
 
add_references_to_partition (part, &node->ref_list);
 
if (node->same_comdat_group)
for (n = node->same_comdat_group; n != node; n = n->same_comdat_group)
add_cgraph_node_to_partition (part, n);
}
 
/* Add VNODE to partition as well as comdat references partition PART. */
 
static void
add_varpool_node_to_partition (ltrans_partition part, struct varpool_node *vnode)
{
varpool_node_set_iterator vsi;
 
vnode = varpool_variable_node (vnode, NULL);
 
/* If NODE is already there, we have nothing to do. */
vsi = varpool_node_set_find (part->varpool_set, vnode);
if (!vsi_end_p (vsi))
return;
 
varpool_node_set_add (part->varpool_set, vnode);
 
if (vnode->aux)
{
vnode->in_other_partition = 1;
if (cgraph_dump_file)
fprintf (cgraph_dump_file, "Varpool node %s now used in multiple partitions\n",
varpool_node_name (vnode));
}
vnode->aux = (void *)((size_t)vnode->aux + 1);
 
add_references_to_partition (part, &vnode->ref_list);
 
if (vnode->same_comdat_group
&& !varpool_node_in_set_p (vnode->same_comdat_group, part->varpool_set))
add_varpool_node_to_partition (part, vnode->same_comdat_group);
}
 
/* Undo all additions until number of cgraph nodes in PARITION is N_CGRAPH_NODES
and number of varpool nodes is N_VARPOOL_NODES. */
 
static void
undo_partition (ltrans_partition partition, unsigned int n_cgraph_nodes,
unsigned int n_varpool_nodes)
{
while (VEC_length (cgraph_node_ptr, partition->cgraph_set->nodes) >
n_cgraph_nodes)
{
struct cgraph_node *node = VEC_index (cgraph_node_ptr,
partition->cgraph_set->nodes,
n_cgraph_nodes);
partition->insns -= inline_summary (node)->self_size;
cgraph_node_set_remove (partition->cgraph_set, node);
node->aux = (void *)((size_t)node->aux - 1);
}
while (VEC_length (varpool_node_ptr, partition->varpool_set->nodes) >
n_varpool_nodes)
{
struct varpool_node *node = VEC_index (varpool_node_ptr,
partition->varpool_set->nodes,
n_varpool_nodes);
varpool_node_set_remove (partition->varpool_set, node);
node->aux = (void *)((size_t)node->aux - 1);
}
}
 
/* Return true if NODE should be partitioned.
This means that partitioning algorithm should put NODE into one of partitions.
This apply to most functions with bodies. Functions that are not partitions
are put into every unit needing them. This is the case of i.e. COMDATs. */
 
static bool
partition_cgraph_node_p (struct cgraph_node *node)
{
/* We will get proper partition based on function they are inlined to. */
if (node->global.inlined_to)
return false;
/* Nodes without a body do not need partitioning. */
if (!node->analyzed)
return false;
/* Extern inlines and comdat are always only in partitions they are needed. */
if (DECL_EXTERNAL (node->decl)
|| (DECL_COMDAT (node->decl)
&& !cgraph_used_from_object_file_p (node)))
return false;
if (lookup_attribute ("weakref", DECL_ATTRIBUTES (node->decl)))
return false;
return true;
}
 
/* Return true if VNODE should be partitioned.
This means that partitioning algorithm should put VNODE into one of partitions. */
 
static bool
partition_varpool_node_p (struct varpool_node *vnode)
{
if (vnode->alias || !vnode->needed)
return false;
/* Constant pool and comdat are always only in partitions they are needed. */
if (DECL_IN_CONSTANT_POOL (vnode->decl)
|| (DECL_COMDAT (vnode->decl)
&& !vnode->force_output
&& !varpool_used_from_object_file_p (vnode)))
return false;
if (lookup_attribute ("weakref", DECL_ATTRIBUTES (vnode->decl)))
return false;
return true;
}
 
/* Group cgrah nodes by input files. This is used mainly for testing
right now. */
 
static void
lto_1_to_1_map (void)
{
struct cgraph_node *node;
struct varpool_node *vnode;
struct lto_file_decl_data *file_data;
struct pointer_map_t *pmap;
ltrans_partition partition;
void **slot;
int npartitions = 0;
 
timevar_push (TV_WHOPR_WPA);
 
pmap = pointer_map_create ();
 
for (node = cgraph_nodes; node; node = node->next)
{
if (!partition_cgraph_node_p (node)
|| node->aux)
continue;
 
file_data = node->local.lto_file_data;
 
if (file_data)
{
slot = pointer_map_contains (pmap, file_data);
if (slot)
partition = (ltrans_partition) *slot;
else
{
partition = new_partition (file_data->file_name);
slot = pointer_map_insert (pmap, file_data);
*slot = partition;
npartitions++;
}
}
else if (!file_data
&& VEC_length (ltrans_partition, ltrans_partitions))
partition = VEC_index (ltrans_partition, ltrans_partitions, 0);
else
{
partition = new_partition ("");
slot = pointer_map_insert (pmap, NULL);
*slot = partition;
npartitions++;
}
 
add_cgraph_node_to_partition (partition, node);
}
 
for (vnode = varpool_nodes; vnode; vnode = vnode->next)
{
if (!partition_varpool_node_p (vnode)
|| vnode->aux)
continue;
file_data = vnode->lto_file_data;
slot = pointer_map_contains (pmap, file_data);
if (slot)
partition = (ltrans_partition) *slot;
else
{
partition = new_partition (file_data->file_name);
slot = pointer_map_insert (pmap, file_data);
*slot = partition;
npartitions++;
}
 
add_varpool_node_to_partition (partition, vnode);
}
for (node = cgraph_nodes; node; node = node->next)
node->aux = NULL;
for (vnode = varpool_nodes; vnode; vnode = vnode->next)
vnode->aux = NULL;
 
/* If the cgraph is empty, create one cgraph node set so that there is still
an output file for any variables that need to be exported in a DSO. */
if (!npartitions)
new_partition ("empty");
 
pointer_map_destroy (pmap);
 
timevar_pop (TV_WHOPR_WPA);
 
lto_stats.num_cgraph_partitions += VEC_length (ltrans_partition,
ltrans_partitions);
}
 
/* Helper function for qsort; sort nodes by order. */
static int
node_cmp (const void *pa, const void *pb)
{
const struct cgraph_node *a = *(const struct cgraph_node * const *) pa;
const struct cgraph_node *b = *(const struct cgraph_node * const *) pb;
return b->order - a->order;
}
 
/* Helper function for qsort; sort nodes by order. */
static int
varpool_node_cmp (const void *pa, const void *pb)
{
const struct varpool_node *a = *(const struct varpool_node * const *) pa;
const struct varpool_node *b = *(const struct varpool_node * const *) pb;
return b->order - a->order;
}
 
/* Group cgraph nodes into equally-sized partitions.
 
The partitioning algorithm is simple: nodes are taken in predefined order.
The order corresponds to the order we want functions to have in the final
output. In the future this will be given by function reordering pass, but
at the moment we use the topological order, which is a good approximation.
 
The goal is to partition this linear order into intervals (partitions) so
that all the partitions have approximately the same size and the number of
callgraph or IPA reference edges crossing boundaries is minimal.
 
This is a lot faster (O(n) in size of callgraph) than algorithms doing
priority-based graph clustering that are generally O(n^2) and, since
WHOPR is designed to make things go well across partitions, it leads
to good results.
 
We compute the expected size of a partition as:
 
max (total_size / lto_partitions, min_partition_size)
 
We use dynamic expected size of partition so small programs are partitioned
into enough partitions to allow use of multiple CPUs, while large programs
are not partitioned too much. Creating too many partitions significantly
increases the streaming overhead.
 
In the future, we would like to bound the maximal size of partitions so as
to prevent the LTRANS stage from consuming too much memory. At the moment,
however, the WPA stage is the most memory intensive for large benchmarks,
since too many types and declarations are read into memory.
 
The function implements a simple greedy algorithm. Nodes are being added
to the current partition until after 3/4 of the expected partition size is
reached. Past this threshold, we keep track of boundary size (number of
edges going to other partitions) and continue adding functions until after
the current partition has grown to twice the expected partition size. Then
the process is undone to the point where the minimal ratio of boundary size
and in-partition calls was reached. */
 
static void
lto_balanced_map (void)
{
int n_nodes = 0;
int n_varpool_nodes = 0, varpool_pos = 0;
struct cgraph_node **postorder =
XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
struct cgraph_node **order = XNEWVEC (struct cgraph_node *, cgraph_max_uid);
struct varpool_node **varpool_order = NULL;
int i, postorder_len;
struct cgraph_node *node;
int total_size = 0, best_total_size = 0;
int partition_size;
ltrans_partition partition;
unsigned int last_visited_cgraph_node = 0, last_visited_varpool_node = 0;
struct varpool_node *vnode;
int cost = 0, internal = 0;
int best_n_nodes = 0, best_n_varpool_nodes = 0, best_i = 0, best_cost =
INT_MAX, best_internal = 0;
int npartitions;
int current_order = -1;
 
for (vnode = varpool_nodes; vnode; vnode = vnode->next)
gcc_assert (!vnode->aux);
/* Until we have better ordering facility, use toplogical order.
Include only nodes we will partition and compute estimate of program
size. Note that since nodes that are not partitioned might be put into
multiple partitions, this is just an estimate of real size. This is why
we keep partition_size updated after every partition is finalized. */
postorder_len = ipa_reverse_postorder (postorder);
for (i = 0; i < postorder_len; i++)
{
node = postorder[i];
if (partition_cgraph_node_p (node))
{
order[n_nodes++] = node;
total_size += inline_summary (node)->size;
}
}
free (postorder);
 
if (!flag_toplevel_reorder)
{
qsort (order, n_nodes, sizeof (struct cgraph_node *), node_cmp);
 
for (vnode = varpool_nodes; vnode; vnode = vnode->next)
if (partition_varpool_node_p (vnode))
n_varpool_nodes++;
varpool_order = XNEWVEC (struct varpool_node *, n_varpool_nodes);
 
n_varpool_nodes = 0;
for (vnode = varpool_nodes; vnode; vnode = vnode->next)
if (partition_varpool_node_p (vnode))
varpool_order[n_varpool_nodes++] = vnode;
qsort (varpool_order, n_varpool_nodes, sizeof (struct varpool_node *),
varpool_node_cmp);
}
 
/* Compute partition size and create the first partition. */
partition_size = total_size / PARAM_VALUE (PARAM_LTO_PARTITIONS);
if (partition_size < PARAM_VALUE (MIN_PARTITION_SIZE))
partition_size = PARAM_VALUE (MIN_PARTITION_SIZE);
npartitions = 1;
partition = new_partition ("");
if (cgraph_dump_file)
fprintf (cgraph_dump_file, "Total unit size: %i, partition size: %i\n",
total_size, partition_size);
 
for (i = 0; i < n_nodes; i++)
{
if (order[i]->aux)
continue;
 
current_order = order[i]->order;
 
if (!flag_toplevel_reorder)
while (varpool_pos < n_varpool_nodes && varpool_order[varpool_pos]->order < current_order)
{
if (!varpool_order[varpool_pos]->aux)
add_varpool_node_to_partition (partition, varpool_order[varpool_pos]);
varpool_pos++;
}
 
add_cgraph_node_to_partition (partition, order[i]);
total_size -= inline_summary (order[i])->size;
 
/* Once we added a new node to the partition, we also want to add
all referenced variables unless they was already added into some
earlier partition.
add_cgraph_node_to_partition adds possibly multiple nodes and
variables that are needed to satisfy needs of ORDER[i].
We remember last visited cgraph and varpool node from last iteration
of outer loop that allows us to process every new addition.
 
At the same time we compute size of the boundary into COST. Every
callgraph or IPA reference edge leaving the partition contributes into
COST. Every edge inside partition was earlier computed as one leaving
it and thus we need to subtract it from COST. */
while (last_visited_cgraph_node <
VEC_length (cgraph_node_ptr, partition->cgraph_set->nodes)
|| last_visited_varpool_node < VEC_length (varpool_node_ptr,
partition->varpool_set->
nodes))
{
struct ipa_ref_list *refs;
int j;
struct ipa_ref *ref;
bool cgraph_p = false;
 
if (last_visited_cgraph_node <
VEC_length (cgraph_node_ptr, partition->cgraph_set->nodes))
{
struct cgraph_edge *edge;
 
cgraph_p = true;
node = VEC_index (cgraph_node_ptr, partition->cgraph_set->nodes,
last_visited_cgraph_node);
refs = &node->ref_list;
 
last_visited_cgraph_node++;
 
gcc_assert (node->analyzed);
 
/* Compute boundary cost of callgraph edges. */
for (edge = node->callees; edge; edge = edge->next_callee)
if (edge->callee->analyzed)
{
int edge_cost = edge->frequency;
cgraph_node_set_iterator csi;
 
if (!edge_cost)
edge_cost = 1;
gcc_assert (edge_cost > 0);
csi = cgraph_node_set_find (partition->cgraph_set, edge->callee);
if (!csi_end_p (csi)
&& csi.index < last_visited_cgraph_node - 1)
cost -= edge_cost, internal+= edge_cost;
else
cost += edge_cost;
}
for (edge = node->callers; edge; edge = edge->next_caller)
{
int edge_cost = edge->frequency;
cgraph_node_set_iterator csi;
 
gcc_assert (edge->caller->analyzed);
if (!edge_cost)
edge_cost = 1;
gcc_assert (edge_cost > 0);
csi = cgraph_node_set_find (partition->cgraph_set, edge->caller);
if (!csi_end_p (csi)
&& csi.index < last_visited_cgraph_node)
cost -= edge_cost;
else
cost += edge_cost;
}
}
else
{
refs =
&VEC_index (varpool_node_ptr, partition->varpool_set->nodes,
last_visited_varpool_node)->ref_list;
last_visited_varpool_node++;
}
 
/* Compute boundary cost of IPA REF edges and at the same time look into
variables referenced from current partition and try to add them. */
for (j = 0; ipa_ref_list_reference_iterate (refs, j, ref); j++)
if (ref->refered_type == IPA_REF_VARPOOL)
{
varpool_node_set_iterator vsi;
 
vnode = ipa_ref_varpool_node (ref);
if (!vnode->finalized)
continue;
if (!vnode->aux && flag_toplevel_reorder
&& partition_varpool_node_p (vnode))
add_varpool_node_to_partition (partition, vnode);
vsi = varpool_node_set_find (partition->varpool_set, vnode);
if (!vsi_end_p (vsi)
&& vsi.index < last_visited_varpool_node - !cgraph_p)
cost--, internal++;
else
cost++;
}
else
{
cgraph_node_set_iterator csi;
 
node = ipa_ref_node (ref);
if (!node->analyzed)
continue;
csi = cgraph_node_set_find (partition->cgraph_set, node);
if (!csi_end_p (csi)
&& csi.index < last_visited_cgraph_node - cgraph_p)
cost--, internal++;
else
cost++;
}
for (j = 0; ipa_ref_list_refering_iterate (refs, j, ref); j++)
if (ref->refering_type == IPA_REF_VARPOOL)
{
varpool_node_set_iterator vsi;
 
vnode = ipa_ref_refering_varpool_node (ref);
gcc_assert (vnode->finalized);
if (!vnode->aux && flag_toplevel_reorder
&& partition_varpool_node_p (vnode))
add_varpool_node_to_partition (partition, vnode);
vsi = varpool_node_set_find (partition->varpool_set, vnode);
if (!vsi_end_p (vsi)
&& vsi.index < last_visited_varpool_node)
cost--;
else
cost++;
}
else
{
cgraph_node_set_iterator csi;
 
node = ipa_ref_refering_node (ref);
gcc_assert (node->analyzed);
csi = cgraph_node_set_find (partition->cgraph_set, node);
if (!csi_end_p (csi)
&& csi.index < last_visited_cgraph_node)
cost--;
else
cost++;
}
}
 
/* If the partition is large enough, start looking for smallest boundary cost. */
if (partition->insns < partition_size * 3 / 4
|| best_cost == INT_MAX
|| ((!cost
|| (best_internal * (HOST_WIDE_INT) cost
> (internal * (HOST_WIDE_INT)best_cost)))
&& partition->insns < partition_size * 5 / 4))
{
best_cost = cost;
best_internal = internal;
best_i = i;
best_n_nodes = VEC_length (cgraph_node_ptr,
partition->cgraph_set->nodes);
best_n_varpool_nodes = VEC_length (varpool_node_ptr,
partition->varpool_set->nodes);
best_total_size = total_size;
}
if (cgraph_dump_file)
fprintf (cgraph_dump_file, "Step %i: added %s/%i, size %i, cost %i/%i best %i/%i, step %i\n", i,
cgraph_node_name (order[i]), order[i]->uid, partition->insns, cost, internal,
best_cost, best_internal, best_i);
/* Partition is too large, unwind into step when best cost was reached and
start new partition. */
if (partition->insns > 2 * partition_size)
{
if (best_i != i)
{
if (cgraph_dump_file)
fprintf (cgraph_dump_file, "Unwinding %i insertions to step %i\n",
i - best_i, best_i);
undo_partition (partition, best_n_nodes, best_n_varpool_nodes);
}
i = best_i;
/* When we are finished, avoid creating empty partition. */
while (i < n_nodes - 1 && order[i + 1]->aux)
i++;
if (i == n_nodes - 1)
break;
partition = new_partition ("");
last_visited_cgraph_node = 0;
last_visited_varpool_node = 0;
total_size = best_total_size;
cost = 0;
 
if (cgraph_dump_file)
fprintf (cgraph_dump_file, "New partition\n");
best_n_nodes = 0;
best_n_varpool_nodes = 0;
best_cost = INT_MAX;
 
/* Since the size of partitions is just approximate, update the size after
we finished current one. */
if (npartitions < PARAM_VALUE (PARAM_LTO_PARTITIONS))
partition_size = total_size
/ (PARAM_VALUE (PARAM_LTO_PARTITIONS) - npartitions);
else
partition_size = INT_MAX;
 
if (partition_size < PARAM_VALUE (MIN_PARTITION_SIZE))
partition_size = PARAM_VALUE (MIN_PARTITION_SIZE);
npartitions ++;
}
}
 
/* Varables that are not reachable from the code go into last partition. */
if (flag_toplevel_reorder)
{
for (vnode = varpool_nodes; vnode; vnode = vnode->next)
if (partition_varpool_node_p (vnode) && !vnode->aux)
add_varpool_node_to_partition (partition, vnode);
}
else
{
while (varpool_pos < n_varpool_nodes)
{
if (!varpool_order[varpool_pos]->aux)
add_varpool_node_to_partition (partition, varpool_order[varpool_pos]);
varpool_pos++;
}
free (varpool_order);
}
free (order);
}
 
/* Promote variable VNODE to be static. */
 
static bool
promote_var (struct varpool_node *vnode)
{
if (TREE_PUBLIC (vnode->decl) || DECL_EXTERNAL (vnode->decl))
return false;
gcc_assert (flag_wpa);
TREE_PUBLIC (vnode->decl) = 1;
DECL_VISIBILITY (vnode->decl) = VISIBILITY_HIDDEN;
DECL_VISIBILITY_SPECIFIED (vnode->decl) = true;
if (cgraph_dump_file)
fprintf (cgraph_dump_file,
"Promoting var as hidden: %s\n", varpool_node_name (vnode));
return true;
}
 
/* Promote function NODE to be static. */
 
static bool
promote_fn (struct cgraph_node *node)
{
gcc_assert (flag_wpa);
if (TREE_PUBLIC (node->decl) || DECL_EXTERNAL (node->decl))
return false;
TREE_PUBLIC (node->decl) = 1;
DECL_VISIBILITY (node->decl) = VISIBILITY_HIDDEN;
DECL_VISIBILITY_SPECIFIED (node->decl) = true;
if (cgraph_dump_file)
fprintf (cgraph_dump_file,
"Promoting function as hidden: %s/%i\n",
cgraph_node_name (node), node->uid);
return true;
}
 
/* Find out all static decls that need to be promoted to global because
of cross file sharing. This function must be run in the WPA mode after
all inlinees are added. */
 
static void
lto_promote_cross_file_statics (void)
{
struct varpool_node *vnode;
unsigned i, n_sets;
cgraph_node_set set;
varpool_node_set vset;
cgraph_node_set_iterator csi;
varpool_node_set_iterator vsi;
VEC(varpool_node_ptr, heap) *promoted_initializers = NULL;
struct pointer_set_t *inserted = pointer_set_create ();
 
gcc_assert (flag_wpa);
 
n_sets = VEC_length (ltrans_partition, ltrans_partitions);
for (i = 0; i < n_sets; i++)
{
ltrans_partition part
= VEC_index (ltrans_partition, ltrans_partitions, i);
set = part->cgraph_set;
vset = part->varpool_set;
 
/* If node called or referred to from other partition, it needs to be
globalized. */
for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
{
struct cgraph_node *node = csi_node (csi);
if (node->local.externally_visible)
continue;
if (node->global.inlined_to)
continue;
if ((!DECL_EXTERNAL (node->decl) && !DECL_COMDAT (node->decl))
&& (referenced_from_other_partition_p (&node->ref_list, set, vset)
|| reachable_from_other_partition_p (node, set)))
promote_fn (node);
}
for (vsi = vsi_start (vset); !vsi_end_p (vsi); vsi_next (&vsi))
{
vnode = vsi_node (vsi);
/* Constant pool references use internal labels and thus can not
be made global. It is sensible to keep those ltrans local to
allow better optimization. */
if (!DECL_IN_CONSTANT_POOL (vnode->decl) && !DECL_COMDAT (vnode->decl)
&& !vnode->externally_visible && vnode->analyzed
&& referenced_from_other_partition_p (&vnode->ref_list,
set, vset))
promote_var (vnode);
}
 
/* We export the initializer of a read-only var into each partition
referencing the var. Folding might take declarations from the
initializer and use them, so everything referenced from the
initializer can be accessed from this partition after folding.
 
This means that we need to promote all variables and functions
referenced from all initializers of read-only vars referenced
from this partition that are not in this partition. This needs
to be done recursively. */
for (vnode = varpool_nodes; vnode; vnode = vnode->next)
if (const_value_known_p (vnode->decl)
&& DECL_INITIAL (vnode->decl)
&& !varpool_node_in_set_p (vnode, vset)
&& referenced_from_this_partition_p (&vnode->ref_list, set, vset)
&& !pointer_set_insert (inserted, vnode))
VEC_safe_push (varpool_node_ptr, heap, promoted_initializers, vnode);
 
while (!VEC_empty (varpool_node_ptr, promoted_initializers))
{
int i;
struct ipa_ref *ref;
 
vnode = VEC_pop (varpool_node_ptr, promoted_initializers);
for (i = 0;
ipa_ref_list_reference_iterate (&vnode->ref_list, i, ref);
i++)
{
if (ref->refered_type == IPA_REF_CGRAPH)
{
struct cgraph_node *n = ipa_ref_node (ref);
gcc_assert (!n->global.inlined_to);
if (!n->local.externally_visible
&& !cgraph_node_in_set_p (n, set))
promote_fn (n);
}
else
{
struct varpool_node *v = ipa_ref_varpool_node (ref);
if (varpool_node_in_set_p (v, vset))
continue;
 
/* Constant pool references use internal labels and thus
cannot be made global. It is sensible to keep those
ltrans local to allow better optimization. */
if (DECL_IN_CONSTANT_POOL (v->decl))
{
if (!pointer_set_insert (inserted, vnode))
VEC_safe_push (varpool_node_ptr, heap,
promoted_initializers, v);
}
else if (!v->externally_visible && v->analyzed)
{
if (promote_var (v)
&& DECL_INITIAL (v->decl)
&& const_value_known_p (v->decl)
&& !pointer_set_insert (inserted, vnode))
VEC_safe_push (varpool_node_ptr, heap,
promoted_initializers, v);
}
}
}
}
}
pointer_set_destroy (inserted);
}
 
static lto_file *current_lto_file;
 
/* Helper for qsort; compare partitions and return one with smaller size.
We sort from greatest to smallest so parallel build doesn't stale on the
longest compilation being executed too late. */
 
static int
cmp_partitions_size (const void *a, const void *b)
{
const struct ltrans_partition_def *pa
= *(struct ltrans_partition_def *const *)a;
const struct ltrans_partition_def *pb
= *(struct ltrans_partition_def *const *)b;
return pb->insns - pa->insns;
}
 
/* Helper for qsort; compare partitions and return one with smaller order. */
 
static int
cmp_partitions_order (const void *a, const void *b)
{
const struct ltrans_partition_def *pa
= *(struct ltrans_partition_def *const *)a;
const struct ltrans_partition_def *pb
= *(struct ltrans_partition_def *const *)b;
int ordera = -1, orderb = -1;
 
if (VEC_length (cgraph_node_ptr, pa->cgraph_set->nodes))
ordera = VEC_index (cgraph_node_ptr, pa->cgraph_set->nodes, 0)->order;
else if (VEC_length (varpool_node_ptr, pa->varpool_set->nodes))
ordera = VEC_index (varpool_node_ptr, pa->varpool_set->nodes, 0)->order;
if (VEC_length (cgraph_node_ptr, pb->cgraph_set->nodes))
orderb = VEC_index (cgraph_node_ptr, pb->cgraph_set->nodes, 0)->order;
else if (VEC_length (varpool_node_ptr, pb->varpool_set->nodes))
orderb = VEC_index (varpool_node_ptr, pb->varpool_set->nodes, 0)->order;
return orderb - ordera;
}
 
/* Write all output files in WPA mode and the file with the list of
LTRANS units. */
 
static void
lto_wpa_write_files (void)
{
unsigned i, n_sets;
lto_file *file;
cgraph_node_set set;
varpool_node_set vset;
ltrans_partition part;
FILE *ltrans_output_list_stream;
char *temp_filename;
size_t blen;
 
/* Open the LTRANS output list. */
if (!ltrans_output_list)
fatal_error ("no LTRANS output list filename provided");
ltrans_output_list_stream = fopen (ltrans_output_list, "w");
if (ltrans_output_list_stream == NULL)
fatal_error ("opening LTRANS output list %s: %m", ltrans_output_list);
 
timevar_push (TV_WHOPR_WPA);
 
FOR_EACH_VEC_ELT (ltrans_partition, ltrans_partitions, i, part)
lto_stats.num_output_cgraph_nodes += VEC_length (cgraph_node_ptr,
part->cgraph_set->nodes);
 
/* Find out statics that need to be promoted
to globals with hidden visibility because they are accessed from multiple
partitions. */
lto_promote_cross_file_statics ();
 
timevar_pop (TV_WHOPR_WPA);
 
timevar_push (TV_WHOPR_WPA_IO);
 
/* Generate a prefix for the LTRANS unit files. */
blen = strlen (ltrans_output_list);
temp_filename = (char *) xmalloc (blen + sizeof ("2147483648.o"));
strcpy (temp_filename, ltrans_output_list);
if (blen > sizeof (".out")
&& strcmp (temp_filename + blen - sizeof (".out") + 1,
".out") == 0)
temp_filename[blen - sizeof (".out") + 1] = '\0';
blen = strlen (temp_filename);
 
n_sets = VEC_length (ltrans_partition, ltrans_partitions);
 
/* Sort partitions by size so small ones are compiled last.
FIXME: Even when not reordering we may want to output one list for parallel make
and other for final link command. */
VEC_qsort (ltrans_partition, ltrans_partitions,
flag_toplevel_reorder ? cmp_partitions_size : cmp_partitions_order);
for (i = 0; i < n_sets; i++)
{
size_t len;
ltrans_partition part = VEC_index (ltrans_partition, ltrans_partitions, i);
 
set = part->cgraph_set;
vset = part->varpool_set;
 
/* Write all the nodes in SET. */
sprintf (temp_filename + blen, "%u.o", i);
file = lto_obj_file_open (temp_filename, true);
if (!file)
fatal_error ("lto_obj_file_open() failed");
 
if (!quiet_flag)
fprintf (stderr, " %s (%s %i insns)", temp_filename, part->name, part->insns);
if (cgraph_dump_file)
{
fprintf (cgraph_dump_file, "Writing partition %s to file %s, %i insns\n",
part->name, temp_filename, part->insns);
fprintf (cgraph_dump_file, "cgraph nodes:");
dump_cgraph_node_set (cgraph_dump_file, set);
fprintf (cgraph_dump_file, "varpool nodes:");
dump_varpool_node_set (cgraph_dump_file, vset);
}
gcc_checking_assert (cgraph_node_set_nonempty_p (set)
|| varpool_node_set_nonempty_p (vset) || !i);
 
lto_set_current_out_file (file);
 
ipa_write_optimization_summaries (set, vset);
 
lto_set_current_out_file (NULL);
lto_obj_file_close (file);
 
len = strlen (temp_filename);
if (fwrite (temp_filename, 1, len, ltrans_output_list_stream) < len
|| fwrite ("\n", 1, 1, ltrans_output_list_stream) < 1)
fatal_error ("writing to LTRANS output list %s: %m",
ltrans_output_list);
}
 
lto_stats.num_output_files += n_sets;
 
/* Close the LTRANS output list. */
if (fclose (ltrans_output_list_stream))
fatal_error ("closing LTRANS output list %s: %m", ltrans_output_list);
 
free_ltrans_partitions();
 
timevar_pop (TV_WHOPR_WPA_IO);
}
 
 
/* If TT is a variable or function decl replace it with its
prevailing variant. */
#define LTO_SET_PREVAIL(tt) \
do {\
if ((tt) && VAR_OR_FUNCTION_DECL_P (tt)) \
tt = lto_symtab_prevailing_decl (tt); \
} while (0)
 
/* Ensure that TT isn't a replacable var of function decl. */
#define LTO_NO_PREVAIL(tt) \
gcc_assert (!(tt) || !VAR_OR_FUNCTION_DECL_P (tt))
 
/* Given a tree T replace all fields referring to variables or functions
with their prevailing variant. */
static void
lto_fixup_prevailing_decls (tree t)
{
enum tree_code code = TREE_CODE (t);
LTO_NO_PREVAIL (TREE_TYPE (t));
if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
LTO_NO_PREVAIL (TREE_CHAIN (t));
if (DECL_P (t))
{
LTO_NO_PREVAIL (DECL_NAME (t));
LTO_SET_PREVAIL (DECL_CONTEXT (t));
if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
{
LTO_SET_PREVAIL (DECL_SIZE (t));
LTO_SET_PREVAIL (DECL_SIZE_UNIT (t));
LTO_SET_PREVAIL (DECL_INITIAL (t));
LTO_NO_PREVAIL (DECL_ATTRIBUTES (t));
LTO_SET_PREVAIL (DECL_ABSTRACT_ORIGIN (t));
}
if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
{
LTO_NO_PREVAIL (t->decl_with_vis.assembler_name);
LTO_NO_PREVAIL (DECL_SECTION_NAME (t));
}
if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
{
LTO_NO_PREVAIL (DECL_ARGUMENT_FLD (t));
LTO_NO_PREVAIL (DECL_RESULT_FLD (t));
LTO_NO_PREVAIL (DECL_VINDEX (t));
}
if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
LTO_SET_PREVAIL (DECL_FUNCTION_PERSONALITY (t));
if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
{
LTO_NO_PREVAIL (DECL_FIELD_OFFSET (t));
LTO_NO_PREVAIL (DECL_BIT_FIELD_TYPE (t));
LTO_NO_PREVAIL (DECL_QUALIFIER (t));
LTO_NO_PREVAIL (DECL_FIELD_BIT_OFFSET (t));
LTO_NO_PREVAIL (DECL_FCONTEXT (t));
}
}
else if (TYPE_P (t))
{
LTO_NO_PREVAIL (TYPE_CACHED_VALUES (t));
LTO_SET_PREVAIL (TYPE_SIZE (t));
LTO_SET_PREVAIL (TYPE_SIZE_UNIT (t));
LTO_NO_PREVAIL (TYPE_ATTRIBUTES (t));
LTO_NO_PREVAIL (TYPE_NAME (t));
 
LTO_SET_PREVAIL (TYPE_MINVAL (t));
LTO_SET_PREVAIL (TYPE_MAXVAL (t));
LTO_SET_PREVAIL (t->type_non_common.binfo);
 
LTO_SET_PREVAIL (TYPE_CONTEXT (t));
 
LTO_NO_PREVAIL (TYPE_CANONICAL (t));
LTO_NO_PREVAIL (TYPE_MAIN_VARIANT (t));
LTO_NO_PREVAIL (TYPE_NEXT_VARIANT (t));
}
else if (EXPR_P (t))
{
int i;
LTO_NO_PREVAIL (t->exp.block);
for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i)
LTO_SET_PREVAIL (TREE_OPERAND (t, i));
}
else
{
switch (code)
{
case TREE_LIST:
LTO_SET_PREVAIL (TREE_VALUE (t));
LTO_SET_PREVAIL (TREE_PURPOSE (t));
break;
default:
gcc_unreachable ();
}
}
}
#undef LTO_SET_PREVAIL
#undef LTO_NO_PREVAIL
 
/* Helper function of lto_fixup_decls. Walks the var and fn streams in STATE,
replaces var and function decls with the corresponding prevailing def. */
 
static void
lto_fixup_state (struct lto_in_decl_state *state)
{
unsigned i, si;
struct lto_tree_ref_table *table;
 
/* Although we only want to replace FUNCTION_DECLs and VAR_DECLs,
we still need to walk from all DECLs to find the reachable
FUNCTION_DECLs and VAR_DECLs. */
for (si = 0; si < LTO_N_DECL_STREAMS; si++)
{
table = &state->streams[si];
for (i = 0; i < table->size; i++)
{
tree *tp = table->trees + i;
if (VAR_OR_FUNCTION_DECL_P (*tp))
*tp = lto_symtab_prevailing_decl (*tp);
}
}
}
 
/* A callback of htab_traverse. Just extracts a state from SLOT
and calls lto_fixup_state. */
 
static int
lto_fixup_state_aux (void **slot, void *aux ATTRIBUTE_UNUSED)
{
struct lto_in_decl_state *state = (struct lto_in_decl_state *) *slot;
lto_fixup_state (state);
return 1;
}
 
/* Fix the decls from all FILES. Replaces each decl with the corresponding
prevailing one. */
 
static void
lto_fixup_decls (struct lto_file_decl_data **files)
{
unsigned int i;
htab_iterator hi;
tree t;
 
FOR_EACH_HTAB_ELEMENT (tree_with_vars, t, tree, hi)
lto_fixup_prevailing_decls (t);
 
for (i = 0; files[i]; i++)
{
struct lto_file_decl_data *file = files[i];
struct lto_in_decl_state *state = file->global_decl_state;
lto_fixup_state (state);
 
htab_traverse (file->function_decl_states, lto_fixup_state_aux, NULL);
}
}
 
static GTY((length ("lto_stats.num_input_files + 1"))) struct lto_file_decl_data **all_file_decl_data;
 
/* Turn file datas for sub files into a single array, so that they look
like separate files for further passes. */
 
static void
lto_flatten_files (struct lto_file_decl_data **orig, int count, int last_file_ix)
{
struct lto_file_decl_data *n, *next;
int i, k;
 
lto_stats.num_input_files = count;
all_file_decl_data
= ggc_alloc_cleared_vec_lto_file_decl_data_ptr (count + 1);
/* Set the hooks so that all of the ipa passes can read in their data. */
lto_set_in_hooks (all_file_decl_data, get_section_data, free_section_data);
for (i = 0, k = 0; i < last_file_ix; i++)
{
for (n = orig[i]; n != NULL; n = next)
{
all_file_decl_data[k++] = n;
next = n->next;
n->next = NULL;
}
}
all_file_decl_data[k] = NULL;
gcc_assert (k == count);
}
 
/* Input file data before flattening (i.e. splitting them to subfiles to support
incremental linking. */
static int real_file_count;
static GTY((length ("real_file_count + 1"))) struct lto_file_decl_data **real_file_decl_data;
 
/* Read all the symbols from the input files FNAMES. NFILES is the
number of files requested in the command line. Instantiate a
global call graph by aggregating all the sub-graphs found in each
file. */
 
static void
read_cgraph_and_symbols (unsigned nfiles, const char **fnames)
{
unsigned int i, last_file_ix;
FILE *resolution;
struct cgraph_node *node;
int count = 0;
struct lto_file_decl_data **decl_data;
 
init_cgraph ();
 
timevar_push (TV_IPA_LTO_DECL_IN);
 
real_file_decl_data
= decl_data = ggc_alloc_cleared_vec_lto_file_decl_data_ptr (nfiles + 1);
real_file_count = nfiles;
 
/* Read the resolution file. */
resolution = NULL;
if (resolution_file_name)
{
int t;
unsigned num_objects;
 
resolution = fopen (resolution_file_name, "r");
if (resolution == NULL)
fatal_error ("could not open symbol resolution file: %m");
 
t = fscanf (resolution, "%u", &num_objects);
gcc_assert (t == 1);
 
/* True, since the plugin splits the archives. */
gcc_assert (num_objects == nfiles);
}
 
tree_with_vars = htab_create_ggc (101, htab_hash_pointer, htab_eq_pointer,
NULL);
 
if (!quiet_flag)
fprintf (stderr, "Reading object files:");
 
/* Read all of the object files specified on the command line. */
for (i = 0, last_file_ix = 0; i < nfiles; ++i)
{
struct lto_file_decl_data *file_data = NULL;
if (!quiet_flag)
{
fprintf (stderr, " %s", fnames[i]);
fflush (stderr);
}
 
current_lto_file = lto_obj_file_open (fnames[i], false);
if (!current_lto_file)
break;
 
file_data = lto_file_read (current_lto_file, resolution, &count);
if (!file_data)
{
lto_obj_file_close (current_lto_file);
current_lto_file = NULL;
break;
}
 
decl_data[last_file_ix++] = file_data;
 
lto_obj_file_close (current_lto_file);
current_lto_file = NULL;
ggc_collect ();
}
 
lto_flatten_files (decl_data, count, last_file_ix);
lto_stats.num_input_files = count;
ggc_free(decl_data);
real_file_decl_data = NULL;
 
if (resolution_file_name)
fclose (resolution);
 
/* Set the hooks so that all of the ipa passes can read in their data. */
lto_set_in_hooks (all_file_decl_data, get_section_data, free_section_data);
 
timevar_pop (TV_IPA_LTO_DECL_IN);
 
if (!quiet_flag)
fprintf (stderr, "\nReading the callgraph\n");
 
timevar_push (TV_IPA_LTO_CGRAPH_IO);
/* Read the callgraph. */
input_cgraph ();
timevar_pop (TV_IPA_LTO_CGRAPH_IO);
 
if (!quiet_flag)
fprintf (stderr, "Merging declarations\n");
 
timevar_push (TV_IPA_LTO_DECL_MERGE);
/* Merge global decls. */
lto_symtab_merge_decls ();
 
/* If there were errors during symbol merging bail out, we have no
good way to recover here. */
if (seen_error ())
fatal_error ("errors during merging of translation units");
 
/* Fixup all decls and types and free the type hash tables. */
lto_fixup_decls (all_file_decl_data);
htab_delete (tree_with_vars);
tree_with_vars = NULL;
free_gimple_type_tables ();
ggc_collect ();
 
timevar_pop (TV_IPA_LTO_DECL_MERGE);
/* Each pass will set the appropriate timer. */
 
if (!quiet_flag)
fprintf (stderr, "Reading summaries\n");
 
/* Read the IPA summary data. */
if (flag_ltrans)
ipa_read_optimization_summaries ();
else
ipa_read_summaries ();
 
/* Finally merge the cgraph according to the decl merging decisions. */
timevar_push (TV_IPA_LTO_CGRAPH_MERGE);
if (cgraph_dump_file)
{
fprintf (cgraph_dump_file, "Before merging:\n");
dump_cgraph (cgraph_dump_file);
dump_varpool (cgraph_dump_file);
}
lto_symtab_merge_cgraph_nodes ();
ggc_collect ();
 
if (flag_ltrans)
for (node = cgraph_nodes; node; node = node->next)
{
/* FIXME: ipa_transforms_to_apply holds list of passes that have optimization
summaries computed and needs to apply changes. At the moment WHOPR only
supports inlining, so we can push it here by hand. In future we need to stream
this field into ltrans compilation. */
if (node->analyzed)
VEC_safe_push (ipa_opt_pass, heap,
node->ipa_transforms_to_apply,
(ipa_opt_pass)&pass_ipa_inline);
}
lto_symtab_free ();
 
timevar_pop (TV_IPA_LTO_CGRAPH_MERGE);
 
timevar_push (TV_IPA_LTO_DECL_INIT_IO);
 
/* FIXME lto. This loop needs to be changed to use the pass manager to
call the ipa passes directly. */
if (!seen_error ())
for (i = 0; i < last_file_ix; i++)
{
struct lto_file_decl_data *file_data = all_file_decl_data [i];
lto_materialize_constructors_and_inits (file_data);
}
 
/* Indicate that the cgraph is built and ready. */
cgraph_function_flags_ready = true;
 
timevar_pop (TV_IPA_LTO_DECL_INIT_IO);
ggc_free (all_file_decl_data);
all_file_decl_data = NULL;
}
 
 
/* Materialize all the bodies for all the nodes in the callgraph. */
 
static void
materialize_cgraph (void)
{
tree decl;
struct cgraph_node *node;
unsigned i;
timevar_id_t lto_timer;
 
if (!quiet_flag)
fprintf (stderr,
flag_wpa ? "Materializing decls:" : "Reading function bodies:");
 
 
/* Now that we have input the cgraph, we need to clear all of the aux
nodes and read the functions if we are not running in WPA mode. */
timevar_push (TV_IPA_LTO_GIMPLE_IN);
 
for (node = cgraph_nodes; node; node = node->next)
{
if (node->local.lto_file_data)
{
lto_materialize_function (node);
lto_stats.num_input_cgraph_nodes++;
}
}
 
timevar_pop (TV_IPA_LTO_GIMPLE_IN);
 
/* Start the appropriate timer depending on the mode that we are
operating in. */
lto_timer = (flag_wpa) ? TV_WHOPR_WPA
: (flag_ltrans) ? TV_WHOPR_LTRANS
: TV_LTO;
timevar_push (lto_timer);
 
current_function_decl = NULL;
set_cfun (NULL);
 
/* Inform the middle end about the global variables we have seen. */
FOR_EACH_VEC_ELT (tree, lto_global_var_decls, i, decl)
rest_of_decl_compilation (decl, 1, 0);
 
if (!quiet_flag)
fprintf (stderr, "\n");
 
timevar_pop (lto_timer);
}
 
 
/* Perform whole program analysis (WPA) on the callgraph and write out the
optimization plan. */
 
static void
do_whole_program_analysis (void)
{
/* Note that since we are in WPA mode, materialize_cgraph will not
actually read in all the function bodies. It only materializes
the decls and cgraph nodes so that analysis can be performed. */
materialize_cgraph ();
 
/* Reading in the cgraph uses different timers, start timing WPA now. */
timevar_push (TV_WHOPR_WPA);
 
if (pre_ipa_mem_report)
{
fprintf (stderr, "Memory consumption before IPA\n");
dump_memory_report (false);
}
 
cgraph_function_flags_ready = true;
 
if (cgraph_dump_file)
{
dump_cgraph (cgraph_dump_file);
dump_varpool (cgraph_dump_file);
}
bitmap_obstack_initialize (NULL);
cgraph_state = CGRAPH_STATE_IPA_SSA;
 
execute_ipa_pass_list (all_regular_ipa_passes);
 
if (cgraph_dump_file)
{
fprintf (cgraph_dump_file, "Optimized ");
dump_cgraph (cgraph_dump_file);
dump_varpool (cgraph_dump_file);
}
verify_cgraph ();
bitmap_obstack_release (NULL);
 
/* We are about to launch the final LTRANS phase, stop the WPA timer. */
timevar_pop (TV_WHOPR_WPA);
 
if (flag_lto_partition_1to1)
lto_1_to_1_map ();
else
lto_balanced_map ();
 
if (!quiet_flag)
{
fprintf (stderr, "\nStreaming out");
fflush (stderr);
}
lto_wpa_write_files ();
ggc_collect ();
if (!quiet_flag)
fprintf (stderr, "\n");
 
if (post_ipa_mem_report)
{
fprintf (stderr, "Memory consumption after IPA\n");
dump_memory_report (false);
}
 
/* Show the LTO report before launching LTRANS. */
if (flag_lto_report)
print_lto_report ();
}
 
 
static GTY(()) tree lto_eh_personality_decl;
 
/* Return the LTO personality function decl. */
 
tree
lto_eh_personality (void)
{
if (!lto_eh_personality_decl)
{
/* Use the first personality DECL for our personality if we don't
support multiple ones. This ensures that we don't artificially
create the need for them in a single-language program. */
if (first_personality_decl && !dwarf2out_do_cfi_asm ())
lto_eh_personality_decl = first_personality_decl;
else
lto_eh_personality_decl = lhd_gcc_personality ();
}
 
return lto_eh_personality_decl;
}
 
/* Set the process name based on the LTO mode. */
 
static void
lto_process_name (void)
{
if (flag_lto)
setproctitle ("lto1-lto");
if (flag_wpa)
setproctitle ("lto1-wpa");
if (flag_ltrans)
setproctitle ("lto1-ltrans");
}
 
 
/* Initialize the LTO front end. */
 
static void
lto_init (void)
{
lto_process_name ();
lto_streamer_hooks_init ();
lto_reader_init ();
lto_set_in_hooks (NULL, get_section_data, free_section_data);
memset (&lto_stats, 0, sizeof (lto_stats));
bitmap_obstack_initialize (NULL);
gimple_register_cfg_hooks ();
}
 
 
/* Main entry point for the GIMPLE front end. This front end has
three main personalities:
 
- LTO (-flto). All the object files on the command line are
loaded in memory and processed as a single translation unit.
This is the traditional link-time optimization behavior.
 
- WPA (-fwpa). Only the callgraph and summary information for
files in the command file are loaded. A single callgraph
(without function bodies) is instantiated for the whole set of
files. IPA passes are only allowed to analyze the call graph
and make transformation decisions. The callgraph is
partitioned, each partition is written to a new object file
together with the transformation decisions.
 
- LTRANS (-fltrans). Similar to -flto but it prevents the IPA
summary files from running again. Since WPA computed summary
information and decided what transformations to apply, LTRANS
simply applies them. */
 
void
lto_main (void)
{
/* Initialize the LTO front end. */
lto_init ();
 
/* Read all the symbols and call graph from all the files in the
command line. */
read_cgraph_and_symbols (num_in_fnames, in_fnames);
 
if (!seen_error ())
{
/* If WPA is enabled analyze the whole call graph and create an
optimization plan. Otherwise, read in all the function
bodies and continue with optimization. */
if (flag_wpa)
do_whole_program_analysis ();
else
{
materialize_cgraph ();
 
/* Let the middle end know that we have read and merged all of
the input files. */
cgraph_optimize ();
 
/* FIXME lto, if the processes spawned by WPA fail, we miss
the chance to print WPA's report, so WPA will call
print_lto_report before launching LTRANS. If LTRANS was
launched directly by the driver we would not need to do
this. */
if (flag_lto_report)
print_lto_report ();
}
}
}
 
#include "gt-lto-lto.h"
/openrisc/trunk/gnu-dev/or1k-gcc/gcc/lto/Make-lang.in
0,0 → 1,95
# Top level -*- makefile -*- fragment for LTO
# Copyright (C) 2009, 2010
# Free Software Foundation, Inc.
 
#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/>.
 
# Variables
 
# The name of the LTO compiler.
LTO_EXE = lto1$(exeext)
# The LTO-specific object files inclued in $(LTO_EXE).
LTO_OBJS = lto/lto-lang.o lto/lto.o lto/lto-object.o attribs.o
LTO_H = lto/lto.h $(HASHTAB_H)
LINKER_PLUGIN_API_H = $(srcdir)/../include/plugin-api.h
LTO_TREE_H = lto/lto-tree.h $(LINKER_PLUGIN_API_H)
 
 
# Rules
 
# These hooks are used by the main GCC Makefile. Consult that
# Makefile for documentation.
lto.all.cross: $(LTO_EXE)
lto.start.encap: $(LTO_EXE)
lto.rest.encap:
lto.tags:
lto.install-common:
lto.install-man:
lto.install-info:
lto.dvi:
lto.pdf:
lto.install-pdf:
lto.html:
lto.install-html:
lto.uninstall:
lto.info:
lto.man:
lto.srcextra:
lto.srcman:
lto.srcinfo:
lto.install-plugin:
 
lto.mostlyclean:
rm -f $(LTO_OBJS) $(LTO_EXE)
 
lto.clean:
lto.distclean:
lto.maintainer-clean:
lto.stage1:
lto.stage2:
lto.stage3:
lto.stage4:
lto.stageprofile:
lto.stagefeedback:
 
# LTO rules.
 
# Use strict warnings for this front end.
lto-warn = $(STRICT_WARN)
 
$(LTO_EXE): $(LTO_OBJS) $(BACKEND) $(LIBDEPS)
+$(LINKER) $(ALL_LINKERFLAGS) $(LDFLAGS) -o $@ \
$(LTO_OBJS) $(BACKEND) $(BACKENDLIBS) $(LIBS)
 
# Dependencies
lto/lto-lang.o: lto/lto-lang.c $(CONFIG_H) coretypes.h debug.h \
flags.h $(GGC_H) langhooks.h $(LANGHOOKS_DEF_H) $(SYSTEM_H) \
$(TARGET_H) $(LTO_H) $(GIMPLE_H) gtype-lto.h gt-lto-lto-lang.h \
$(EXPR_H) $(LTO_STREAMER_H)
lto/lto.o: lto/lto.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(OPTS_H) \
toplev.h $(TREE_H) $(TREE_FLOW_H) $(DIAGNOSTIC_CORE_H) $(TM_H) \
$(CGRAPH_H) $(GGC_H) tree-ssa-operands.h $(TREE_PASS_H) \
langhooks.h $(VEC_H) $(BITMAP_H) pointer-set.h $(IPA_PROP_H) \
$(COMMON_H) debug.h $(TIMEVAR_H) $(GIMPLE_H) $(LTO_H) $(LTO_TREE_H) \
$(LTO_TAGS_H) $(LTO_STREAMER_H) $(SPLAY_TREE_H) gt-lto-lto.h $(PARAMS_H) \
ipa-inline.h $(IPA_UTILS_H) $(TREE_STREAMER_H)
lto/lto-object.o: lto/lto-object.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
$(DIAGNOSTIC_CORE_H) $(LTO_H) $(TM_H) $(LTO_STREAMER_H) \
../include/simple-object.h
 
# LTO testing is done as part of C/C++/Fortran etc. testing.
check-lto:
/openrisc/trunk/gnu-dev/or1k-gcc/gcc/lto/lto-tree.h
0,0 → 1,58
/* Language-dependent trees for LTO.
Copyright 2009, 2010 Free Software Foundation, Inc.
Contributed by CodeSourcery, Inc.
 
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/>. */
 
#ifndef GCC_LTO_TREE_H
#define GCC_LTO_TREE_H
 
#include "plugin-api.h"
 
struct GTY(()) lang_identifier
{
struct tree_identifier base;
};
 
struct GTY(()) lang_decl
{
int dummy; /* Added because ggc does not like empty structs. */
};
 
struct GTY((variable_size)) lang_type
{
int dummy; /* Added because ggc does not like empty structs. */
};
 
struct GTY(()) language_function
{
int dummy; /* Added because ggc does not like empty structs. */
};
 
enum lto_tree_node_structure_enum {
TS_LTO_GENERIC
};
 
union GTY((desc ("lto_tree_node_structure (&%h)"),
chain_next ("CODE_CONTAINS_STRUCT (TREE_CODE (&%h.generic), TS_COMMON) ? ((union lang_tree_node *) TREE_CHAIN (&%h.generic)) : NULL")))
lang_tree_node
{
union tree_node GTY ((tag ("TS_LTO_GENERIC"),
desc ("tree_node_structure (&%h)"))) generic;
};
 
#endif /* GCC_LTO_TREE_H */
/openrisc/trunk/gnu-dev/or1k-gcc/gcc/lto/lang-specs.h
0,0 → 1,24
/* LTO driver specs.
Copyright 2009 Free Software Foundation, Inc.
Contributed by CodeSourcery, Inc.
 
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/>. */
 
/* LTO contributions to the "compilers" array in gcc.c. */
{"@lto", "lto1 %(cc1_options) %i %{!fsyntax-only:%(invoke_as)}",
/*cpp_spec=*/NULL, /*combinable=*/1, /*needs_preprocessing=*/0},
/openrisc/trunk/gnu-dev/or1k-gcc/gcc/lto/lang.opt
0,0 → 1,43
; Options for the LTO front end.
; Copyright (C) 2008, 2010 Free Software Foundation, Inc.
;
; 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/>.
 
; See the GCC internals manual for a description of this file's format.
 
; Please try to keep this file in ASCII collating order.
 
Language
LTO
 
fltrans
LTO Report Var(flag_ltrans) Optimization
Run the link-time optimizer in local transformation (LTRANS) mode.
 
fltrans-output-list=
LTO Joined Var(ltrans_output_list)
Specify a file to which a list of files output by LTRANS is written.
 
fwpa
LTO Driver Report Var(flag_wpa) Optimization
Run the link-time optimizer in whole program analysis (WPA) mode.
 
fresolution=
LTO Joined
The resolution file
 
; This comment is to ensure we retain the blank line above.
/openrisc/trunk/gnu-dev/or1k-gcc/gcc/lto/lto-object.c
0,0 → 1,381
/* LTO routines to use object files.
Copyright 2010 Free Software Foundation, Inc.
Written by Ian Lance Taylor, Google.
 
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 "diagnostic-core.h"
#include "lto.h"
#include "tm.h"
#include "lto-streamer.h"
#include "simple-object.h"
 
/* Segment name for LTO sections. This is only used for Mach-O.
FIXME: This needs to be kept in sync with darwin.c. */
 
#define LTO_SEGMENT_NAME "__GNU_LTO"
 
/* An LTO file wrapped around an simple_object. */
 
struct lto_simple_object
{
/* The base information. */
lto_file base;
 
/* The system file descriptor. */
int fd;
 
/* The simple_object if we are reading the file. */
simple_object_read *sobj_r;
 
/* The simple_object if we are writing the file. */
simple_object_write *sobj_w;
 
/* The currently active section. */
simple_object_write_section *section;
};
 
/* Saved simple_object attributes. FIXME: Once set, this is never
cleared. */
 
static simple_object_attributes *saved_attributes;
 
/* Initialize FILE, an LTO file object for FILENAME. */
 
static void
lto_file_init (lto_file *file, const char *filename, off_t offset)
{
file->filename = filename;
file->offset = offset;
}
 
/* Open the file FILENAME. It WRITABLE is true, the file is opened
for write and, if necessary, created. Otherwise, the file is
opened for reading. Returns the opened file. */
 
lto_file *
lto_obj_file_open (const char *filename, bool writable)
{
const char *offset_p;
long loffset;
int consumed;
char *fname;
off_t offset;
struct lto_simple_object *lo;
const char *errmsg;
int err;
 
offset_p = strrchr (filename, '@');
if (offset_p != NULL
&& offset_p != filename
&& sscanf (offset_p, "@%li%n", &loffset, &consumed) >= 1
&& strlen (offset_p) == (unsigned int) consumed)
{
fname = XNEWVEC (char, offset_p - filename + 1);
memcpy (fname, filename, offset_p - filename);
fname[offset_p - filename] = '\0';
offset = (off_t) loffset;
}
else
{
fname = xstrdup (filename);
offset = 0;
}
 
lo = XCNEW (struct lto_simple_object);
lto_file_init ((lto_file *) lo, fname, offset);
 
lo->fd = open (fname,
(writable
? O_WRONLY | O_CREAT | O_BINARY
: O_RDONLY | O_BINARY),
0666);
if (lo->fd == -1)
{
error ("open %s failed: %s", fname, xstrerror (errno));
goto fail;
}
 
if (!writable)
{
simple_object_attributes *attrs;
 
lo->sobj_r = simple_object_start_read (lo->fd, offset, LTO_SEGMENT_NAME,
&errmsg, &err);
if (lo->sobj_r == NULL)
goto fail_errmsg;
 
attrs = simple_object_fetch_attributes (lo->sobj_r, &errmsg, &err);
if (attrs == NULL)
goto fail_errmsg;
 
if (saved_attributes == NULL)
saved_attributes = attrs;
else
{
errmsg = simple_object_attributes_merge (saved_attributes, attrs,
&err);
if (errmsg != NULL)
goto fail_errmsg;
}
}
else
{
gcc_assert (saved_attributes != NULL);
lo->sobj_w = simple_object_start_write (saved_attributes,
LTO_SEGMENT_NAME,
&errmsg, &err);
if (lo->sobj_w == NULL)
goto fail_errmsg;
}
 
return &lo->base;
 
fail_errmsg:
if (err == 0)
error ("%s: %s", fname, errmsg);
else
error ("%s: %s: %s", fname, errmsg, xstrerror (err));
fail:
if (lo != NULL)
lto_obj_file_close ((lto_file *) lo);
return NULL;
}
 
/* Close FILE. If FILE was opened for writing, it is written out
now. */
 
void
lto_obj_file_close (lto_file *file)
{
struct lto_simple_object *lo = (struct lto_simple_object *) file;
 
if (lo->sobj_r != NULL)
simple_object_release_read (lo->sobj_r);
else if (lo->sobj_w != NULL)
{
const char *errmsg;
int err;
 
gcc_assert (lo->base.offset == 0);
 
errmsg = simple_object_write_to_file (lo->sobj_w, lo->fd, &err);
if (errmsg != NULL)
{
if (err == 0)
fatal_error ("%s", errmsg);
else
fatal_error ("%s: %s", errmsg, xstrerror (err));
}
 
simple_object_release_write (lo->sobj_w);
}
 
if (lo->fd != -1)
{
if (close (lo->fd) < 0)
fatal_error ("close: %s", xstrerror (errno));
}
}
 
/* This is passed to lto_obj_add_section. */
 
struct lto_obj_add_section_data
{
/* The hash table of sections. */
htab_t section_hash_table;
/* The offset of this file. */
off_t base_offset;
/* List in linker order */
struct lto_section_list *list;
};
 
/* This is called for each section in the file. */
 
static int
lto_obj_add_section (void *data, const char *name, off_t offset,
off_t length)
{
struct lto_obj_add_section_data *loasd =
(struct lto_obj_add_section_data *) data;
htab_t section_hash_table = (htab_t) loasd->section_hash_table;
char *new_name;
struct lto_section_slot s_slot;
void **slot;
struct lto_section_list *list = loasd->list;
 
if (strncmp (name, LTO_SECTION_NAME_PREFIX,
strlen (LTO_SECTION_NAME_PREFIX)) != 0)
return 1;
 
new_name = xstrdup (name);
s_slot.name = new_name;
slot = htab_find_slot (section_hash_table, &s_slot, INSERT);
if (*slot == NULL)
{
struct lto_section_slot *new_slot = XCNEW (struct lto_section_slot);
 
new_slot->name = new_name;
new_slot->start = loasd->base_offset + offset;
new_slot->len = length;
*slot = new_slot;
 
if (list != NULL)
{
if (!list->first)
list->first = new_slot;
if (list->last)
list->last->next = new_slot;
list->last = new_slot;
}
}
else
{
error ("two or more sections for %s", new_name);
return 0;
}
 
return 1;
}
 
/* Build a hash table whose key is the section name and whose data is
the start and size of each section in the .o file. */
 
htab_t
lto_obj_build_section_table (lto_file *lto_file, struct lto_section_list *list)
{
struct lto_simple_object *lo = (struct lto_simple_object *) lto_file;
htab_t section_hash_table;
struct lto_obj_add_section_data loasd;
const char *errmsg;
int err;
 
section_hash_table = lto_obj_create_section_hash_table ();
 
gcc_assert (lo->sobj_r != NULL && lo->sobj_w == NULL);
loasd.section_hash_table = section_hash_table;
loasd.base_offset = lo->base.offset;
loasd.list = list;
errmsg = simple_object_find_sections (lo->sobj_r, lto_obj_add_section,
&loasd, &err);
if (errmsg != NULL)
{
if (err == 0)
error ("%s", errmsg);
else
error ("%s: %s", errmsg, xstrerror (err));
htab_delete (section_hash_table);
return NULL;
}
 
return section_hash_table;
}
 
/* The current output file. */
 
static lto_file *current_out_file;
 
/* Set the current output file. Return the old one. */
 
lto_file *
lto_set_current_out_file (lto_file *file)
{
lto_file *old_file;
 
old_file = current_out_file;
current_out_file = file;
return old_file;
}
 
/* Return the current output file. */
 
lto_file *
lto_get_current_out_file (void)
{
return current_out_file;
}
 
/* Begin writing a new section named NAME in the current output
file. */
 
void
lto_obj_begin_section (const char *name)
{
struct lto_simple_object *lo;
int align;
const char *errmsg;
int err;
 
lo = (struct lto_simple_object *) current_out_file;
gcc_assert (lo != NULL
&& lo->sobj_r == NULL
&& lo->sobj_w != NULL
&& lo->section == NULL);
 
align = exact_log2 (POINTER_SIZE / BITS_PER_UNIT);
lo->section = simple_object_write_create_section (lo->sobj_w, name, align,
&errmsg, &err);
if (lo->section == NULL)
{
if (err == 0)
fatal_error ("%s", errmsg);
else
fatal_error ("%s: %s", errmsg, xstrerror (errno));
}
}
 
/* Add data to a section. BLOCK is a pointer to memory containing
DATA. */
 
void
lto_obj_append_data (const void *data, size_t len, void *block)
{
struct lto_simple_object *lo;
const char *errmsg;
int err;
 
lo = (struct lto_simple_object *) current_out_file;
gcc_assert (lo != NULL && lo->section != NULL);
 
errmsg = simple_object_write_add_data (lo->sobj_w, lo->section, data, len,
1, &err);
if (errmsg != NULL)
{
if (err == 0)
fatal_error ("%s", errmsg);
else
fatal_error ("%s: %s", errmsg, xstrerror (errno));
}
 
free (block);
}
 
/* Stop writing to the current output section. */
 
void
lto_obj_end_section (void)
{
struct lto_simple_object *lo;
 
lo = (struct lto_simple_object *) current_out_file;
gcc_assert (lo != NULL && lo->section != NULL);
lo->section = NULL;
}
/openrisc/trunk/gnu-dev/or1k-gcc/gcc/lto/lto.h
0,0 → 1,71
/* LTO declarations.
Copyright 2009, 2010 Free Software Foundation, Inc.
Contributed by CodeSourcery, Inc.
 
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/>. */
 
#ifndef LTO_H
#define LTO_H
 
#include "hashtab.h"
 
/* A file. */
typedef struct lto_file_struct
{
/* The name of the file. */
const char *filename;
/* The offset for the object inside an ar archive file (or zero). */
off_t offset;
} lto_file;
 
/* In lto-lang.c */
extern const char *resolution_file_name;
 
/* In lto.c */
extern tree lto_eh_personality (void);
extern void lto_main (void);
extern void lto_read_all_file_options (void);
 
/* In lto-elf.c or lto-coff.c */
extern lto_file *lto_obj_file_open (const char *filename, bool writable);
extern void lto_obj_file_close (lto_file *file);
struct lto_section_list;
extern htab_t lto_obj_build_section_table (lto_file *file, struct lto_section_list *list);
extern htab_t lto_obj_create_section_hash_table (void);
extern void lto_obj_begin_section (const char *name);
extern void lto_obj_append_data (const void *data, size_t len, void *block);
extern void lto_obj_end_section (void);
extern lto_file *lto_set_current_out_file (lto_file *file);
extern lto_file *lto_get_current_out_file (void);
 
/* Hash table entry to hold the start offset and length of an LTO
section in a .o file. */
struct lto_section_slot
{
const char *name;
intptr_t start;
size_t len;
struct lto_section_slot *next;
};
 
/* A list of section slots */
struct lto_section_list
{
struct lto_section_slot *first, *last;
};
 
#endif /* LTO_H */
/openrisc/trunk/gnu-dev/or1k-gcc/gcc/lto/ChangeLog
0,0 → 1,3721
2012-02-28 Richard Guenther <rguenther@suse.de>
 
PR lto/52400
* lto.c (lto_register_function_decl_in_symtab): Do not register
a reverse renamed decl mapping.
 
2012-01-06 Jakub Jelinek <jakub@redhat.com>
 
PR lto/51774
* lto-lang.c (handle_returns_twice_attribute): New function.
(lto_attribute_table): Add returns_twice attribute.
 
2011-12-21 Richard Guenther <rguenther@suse.de>
 
* lto.c (GIMPLE_REGISTER_TYPE): New define.
(LTO_FIXUP_TREE): Use it.
(uniquify_nodes): Mark new non-prevailing types and avoid
calling gimple_register_type on others.
(lto_read_decls): Add comment.
 
2011-12-13 Eric Botcazou <ebotcazou@adacore.com>
 
* lto.h (lto_parse_hex): Delete.
* lto.c (lto_read_decls): Use 'int' for offsets.
(lto_parse_hex): Make static and return proper 64-bit host type.
(lto_resolution_read): Use proper 64-bit host type.
 
2011-12-13 Richard Guenther <rguenther@suse.de>
 
PR lto/48354
* lto.c (lto_ft_decl_non_common): When we merged DECL_ORIGINAL_TYPE
with the type of the TYPE_DECL clear DECL_ORIGINAL_TYPE.
 
2011-12-01 Uros Bizjak <ubizjak@gmail.com>
 
* lto-lang.c (lto_attribute_table): Handle *tm regparm.
(ignore_attribute): New.
 
2011-11-21 Aldy Hernandez <aldyh@redhat.com>
 
* lto-lang.c (lto_attribute_table): Handle transaction_pure.
(handle_transaction_pure_attribute): New.
 
2011-11-03 Richard Guenther <rguenther@suse.de>
 
PR lto/44965
* lto-lang.c (lto_post_options): Do not read file options.
* lto.c (lto_read_all_file_options): Remove.
(lto_init): Call lto_set_in_hooks here.
 
2011-10-09 Jan Hubicka <jh@suse.cz>
 
* lto.c (node_cmp, varpool_node_cmp): New functions.
(lto_balanced_map): Honnor -fno-toplevel-reorder of vars&functions.
(cmp_partitions): Rename to ...
(cmp_partitions_size): ... this one.
(cmp_partitions_order): New function.
(lto_wpa_write_files): Sort partitions by order when
-fno-toplevel-reorder is used.
 
2011-10-09 Andi Kleen <ak@linux.intel.com>
 
* lto.c (lto_section_read): Call fatal_error on IO or mmap errors.
 
2011-10-11 Michael Meissner <meissner@linux.vnet.ibm.com>
 
* lto-lang.c (def_builtin_1): Delete old interface with two
parallel arrays to hold standard builtin declarations, and replace
it with a function based interface that can support creating
builtins on the fly in the future. Change all uses, and poison
the old names. Make sure 0 is not a legitimate builtin index.
 
2011-10-02 Andi Kleen <ak@linux.intel.com>
 
* lto-object.c (lto_obj_add_section_data): Add list.
(lto_obj_add_section): Fill in list.
(ltoobj_build_section_table): Pass through list.
* lto.c (file_data_list): Declare.
(create_subid_section_table): Pass arguments directly.
Fill in list of file_datas.
(lwstate): Delete.
(lto_create_files_from_ids): Pass in direct arguments.
Don't maintain list.
(lto_file_read): Use explicit section and file data lists.
(lto_read_all_file_options): Pass in section_list.
* lto.h (lto_obj_build_section_table): Add list.
(lto_section_slot): Add next.
(lto_section_list): Declare.
 
2011-10-02 Jan Hubicka <jh@suse.cz>
 
PR lto/47247
* common.c (lto_resolution_str): Add new resolution.
* common.h (lto_resolution_str): Likewise.
 
2011-09-30 H.J. Lu <hongjiu.lu@intel.com>
Andi Kleen <ak@linux.intel.com>
 
PR lto/50568
* lto.c (lto_splay_tree_delete_id): New.
(lto_splay_tree_compare_ids): Likewise.
(lto_splay_tree_lookup): Likewise.
(lto_splay_tree_id_equal_p): Likewise.
(lto_splay_tree_insert): Likewise.
(lto_splay_tree_new): Likewise.
(lto_resolution_read): Change id to unsigned HOST_WIDE_INT.
Use lto_splay_tree_id_equal_p and lto_splay_tree_lookup.
(create_subid_section_table): Use lto_splay_tree_lookup and
lto_splay_tree_insert.
(lto_file_read): Use lto_splay_tree_new.
 
2011-09-26 Andi Kleen <ak@linux.intel.com>
 
* lto.c (lto_resolution_read): Remove id dumping.
(lto_section_with_id): Turn id HOST_WIDE_ID.
(create_subid_section_table): Dito.
 
2011-08-28 Dodji Seketeli <dodji@redhat.com>
 
* lto-lang.c (lto_init): Likewise. Also, avoid calling
linemap_add twice.
 
2011-08-11 Martin Jambor <mjambor@suse.cz>
 
* lto.c (uniquify_nodes): Use main variant's BINFO too.
 
2011-08-08 Diego Novillo <dnovillo@google.com>
 
* Make-lang.in (lto/lto.o): Add TREE_STREAMER_H.
* lto.c: Include tree-streamer.h.
 
2011-07-06 Richard Guenther <rguenther@suse.de>
 
* lto-lang.c (lto_init):
Merge calls to build_common_tree_nodes and build_common_tree_nodes_2.
 
2011-06-11 Jan Hubicka <jh@suse.cz>
 
PR lto/48246
* lto.c (lto_1_to_1_map): Don't create empty partitions.
(lto_balanced_map): Likewise.
 
2011-06-11 Jan Hubicka <jh@suse.cz>
 
* lto.c (add_cgraph_node_to_partition_1): Break out from ...
(add_cgraph_node_to_partition) ... here; walk aliases.
(lto_1_to_1_map): Remove same body alias code.
(promote_fn): Likewise.
(lto_promote_cross_file_statics): Update comment.
 
 
2011-06-07 Diego Novillo <dnovillo@google.com>
 
* lto.c (uniquify_nodes): Move code to register decls to
the loop that computes canonical types.
 
2011-06-07 Richard Guenther <rguenther@suse.de>
 
* lto-lang.c (lto_init): Do not set
size_type_node or call set_sizetype.
 
2011-06-04 Diego Novillo <dnovillo@google.com>
 
* lto.c (lto_init): New.
(lto_main): Call it.
 
2011-06-03 Diego Novillo <dnovillo@google.com>
 
* lto.c (get_resolution): Move from lto-streamer-in.c.
(lto_register_var_decl_in_symtab): Likewise.
(lto_register_function_decl_in_symtab): Likewise.
(uniquify_nodes): Call lto_register_var_decl and
lto_register_function_decl_in_symtab after reading a new
VAR_DECL or FUNCTION_DECL.
 
2011-06-01 Richard Guenther <rguenther@suse.de>
 
* lto-lang.c (lto_register_canonical_types): New function.
(lto_init): Register common nodes with the canonical type machinery.
Do not play tricks with char_type_node.
 
2011-05-26 Richard Guenther <rguenther@suse.de>
 
* lto.c (uniquify_nodes): Fix bug in one of the previous changes.
 
2011-05-25 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_ft_typed): New function.
(lto_ft_common): Call it.
(lto_ft_constructor): Likewise.
(lto_ft_expr): Likewise.
(lto_fixup_prevailing_decls): Check for TS_COMMON before accessing
TREE_CHAIN.
 
2011-05-20 Richard Guenther <rguenther@suse.de>
 
* lto.c (lto_ft_common): Remove pointer-to chain teardown.
(lto_ft_type): Move main-variant and pointer-to chain building ...
(uniquify_nodes): ... here. Compute TYPE_CANONICAL also here,
in a separate final loop.
 
2011-05-19 Richard Guenther <rguenther@suse.de>
 
* lto.c (uniquify_nodes): First register all types before
fixing up the tree SCC.
 
2011-05-11 Jan Hubicka <jh@suse.cz>
 
PR lto/48952
* lto.c (do_whole_program_analysis): Do not register cgraph hooks.
 
2011-05-11 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_ft_type): Use TYPE_MINVAL and TYPE_MAXVAL. Adjust
location of binfo field.
(lto_fixup_prevailing_decls): Likewise.
 
2011-05-10 Nathan Froyd <froydnj@codesourcery.com>
 
* lto-lang.c (def_fn_type): Don't call build_function_type, call
build_function_type_array or build_varargs_function_type_array
instead.
 
2011-05-07 Eric Botcazou <ebotcazou@adacore.com>
 
* lto-lang.c (global_bindings_p): Return bool.
 
2011-05-07 Jan Hubicka <jh@suse.cz>
 
* lto.c (lto_materialize_function): Use
cgraph_function_with_gimple_body_p.
(add_cgraph_node_to_partition): Do not re-add items to partition;
handle thunks.
(add_varpool_node_to_partition): Do not re-add items to partition.
 
2011-05-03 Jan Hubicka <jh@suse.cz>
 
* lto.c (free_ltrans_partitions): Fix accidental commit.
 
2011-05-03 Jan Hubicka <jh@suse.cz>
 
* lto.c (ltrans_partition_def): Remove GTY annotations.
(ltrans_partitions): Move to heap.
(new_partition): Update.
(free_ltrans_partitions): New function.
(lto_wpa_write_files): Use it.
 
2011-04-29 Martin Jambor <mjambor@suse.cz>
 
* lto.c: Include ipa-utils.h.
(lto_balanced_map): Update call to ipa_reverse_postorder.
* Make-lang.in (lto/lto.o): Add IPA_UTILS_H to dependencies.
 
2011-04-29 Michael Matz <matz@suse.de>
 
* lto.c (toplevel): Include tree-flow.h.
(lto_read_in_decl_state): Don't merge types here.
(tree_with_vars): New static hash table.
(remember_with_vars): New static functions.
(LTO_FIXUP_TYPE): New macro.
(lto_ft_common, lto_ft_decl_minimal, lto_ft_decl_common,
lto_ft_decl_with_vis, lto_ft_decl_non_common, lto_ft_function,
lto_ft_field_decl, lto_ft_type, lto_ft_binfo, lto_ft_constructor,
lto_ft_expr, lto_fixup_types, uniquify_nodes): New static functions.
(lto_read_decls): Uniquify while reading in trees.
(lto_fixup_data_t, LTO_FIXUP_SUBTREE,
LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE, no_fixup_p, lto_fixup_common,
lto_fixup_decl_minimal, lto_fixup_decl_common, lto_fixup_decl_with_vis,
lto_fixup_decl_non_common, lto_fixup_function, lto_fixup_field_decl,
lto_fixup_type, lto_fixup_binfo, lto_fixup_constructor,
lto_fixup_tree): Remove.
(lto_fixup_state): Remove data argument. Use
lto_symtab_prevailing_decl.
(LTO_SET_PREVAIL, LTO_NO_PREVAIL): New macros.
(lto_fixup_prevailing_decls): New function.
(lto_fixup_state_aux): Argument aux is unused.
(lto_fixup_decls): Don't allocate pointer sets, don't use
lto_fixup_tree, use lto_fixup_prevailing_decls.
(read_cgraph_and_symbols): Allocate and remove tree_with_vars.
* Make-lang.in (lto/lto.o): Depend on $(TREE_FLOW_H).
 
2011-04-16 Eric Botcazou <ebotcazou@adacore.com>
 
* lto.c (lto_balanced_map): Fix typos in head comment.
(lto_promote_cross_file_statics): Fix long lines and remove redundant
test.
 
2011-04-16 Jan Hubicka <jh@suse.cz>
 
* lto.c (lto_balanced_map): Update.
 
2011-04-14 Jan Hubicka <jh@suse.cz>
 
* 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.
 
2011-04-12 Nathan Froyd <froydnj@codesourcery.com>
 
* lto-tree.h (union lang_tree_node): Check for TS_COMMON before
calling TREE_CHAIN.
* lto.c (lto_fixup_common): Likewise.
 
2011-04-08 Nathan Froyd <froydnj@codesourcery.com>
 
* lto-lang.c (handle_sentinel_attribute): Don't use TYPE_ARG_TYPES.
(handle_type_generic_attribute): Likewise.
 
2011-04-03 Michael Matz <matz@suse.de>
 
* lto.c (lto_materialize_function): Don't read and then discard
sections in WPA mode.
(lto_read_in_decl_state): Adjust call to lto_streamer_cache_get.
 
* lto-lang.c (registered_builtin_fndecls): Remove.
(lto_getdecls): Return NULL_TREE.
(lto_builtin_function): Don't remember in registered_builtin_fndecls.
 
2011-03-31 Richard Guenther <rguenther@suse.de>
 
PR lto/48246
* lto.c (lto_wpa_write_files): Disable assert for non-empty
partitions when checking is not enabled.
 
2011-03-25 Kai Tietz <ktietz@redhat.com>
 
* lto.c (lto_resolution_read): Use filename_cmp instead
of strcmp.
(lto_read_section_data): Likewise.
 
2011-03-25 Jeff Law <law@redhat.com>
 
* lto/lto-lang.c (def_fn_type): Add missing va_end.
 
2011-03-21 Kai Tietz <ktietz@redhat.com>
 
PR target/12171
* lto-lang.c (lto_attribute_table): Adjust table.
 
2011-02-18 Jakub Jelinek <jakub@redhat.com>
 
PR bootstrap/47807
* Make-lang.in (lto/lto-lang.o): Depend on $(LTO_STREAMER_H) instead
of lto-streamer.h.
 
2011-02-18 Richard Guenther <rguenther@suse.de>
 
PR lto/47798
* lto-tree.h (lto_global_var_decls): Do not declare here.
* lto-lang.c: Include lto-streamer.h.
* Make-lang.in (lto-lang.o): Adjust dependencies.
 
2011-02-10 Kai Tietz <kai.tietz@onevision.com>
 
PR lto/47241
* lto.c (lto_read_section_data): Free
fd_name in failure case.
For mingw targets don't hash file-descriptor.
(read_cgraph_and_symbols): Close current_lto_file
in failure case.
 
2011-01-11 Jan Hubicka <jh@suse.cz>
 
PR lto/45721
PR lto/45375
* lto.c (partition_cgraph_node_p, partition_varpool_node_p): Weakrefs
are not partitioned.
 
2010-12-22 Nathan Froyd <froydnj@codesourcery.com>
 
* lto-lang.c (handle_nonnull_attribute, handle_sentinel_attribute):
Use prototype_p.
 
2010-12-06 Richard Guenther <rguenther@suse.de>
 
PR lto/46796
* lto-lang.c (lto_init): Give names to basic types.
 
2010-11-30 Joseph Myers <joseph@codesourcery.com>
 
* lto-object.c: Don't include toplev.h.
* Make-lang.in (lto/lto-object.o): Don't depend on toplev.h.
 
2010-11-30 Joseph Myers <joseph@codesourcery.com>
 
* Make-lang.in (lto/lto-object.o): Depend on toplev.h instead of
$(TOPLEV_H).
 
2010-11-29 Joseph Myers <joseph@codesourcery.com>
 
* lto-endian.h: Delete.
* lto-object.c: Don't include "libiberty.h".
(O_BINARY): Don't define.
* lto.c: Don't include "libiberty.h" or <sys/mman.h>.
(O_BINARY): Don't define.
 
2010-11-23 Richard Guenther <rguenther@suse.de>
 
* lto.c (read_cgraph_and_symbols): Remove newline from diagnostic.
 
2010-11-23 Richard Guenther <rguenther@suse.de>
 
PR lto/46605
* lto.c (read_cgraph_and_symbols): Bail out after errors.
 
2010-11-17 Joseph Myers <joseph@codesourcery.com>
 
* lto.c (lto_main): Take no arguments.
* lto.h (lto_main): Update prototype.
 
2010-11-16 Ian Lance Taylor <iant@google.com>
 
* lto-object.c (lto_obj_file_open): Call
simple_object_attributes_merge rather than
simple_object_attributes_compare.
 
2010-11-12 Joseph Myers <joseph@codesourcery.com>
 
* Make-lang.in (lto/lto.o): Use $(OPTS_H).
* lto-lang.c (lto_handle_option): Take location_t parameter.
 
2010-11-10 Joseph Myers <joseph@codesourcery.com>
 
* lto.c (lto_resolution_read): Start diagnostics with lowercase
letters and remove trailing '.'.
(lto_file_finalize): Start diagnostic with a lowercase letter.
 
2010-11-02 Ian Lance Taylor <iant@google.com>
 
* lto-object.c: New file.
* lto-elf.c: Remove file.
* lto-macho.c: Remove file.
* lto-macho.h: Remove file.
* lto-coff.c: Remove file.
* lto-coff.h: Remove file.
* Make-lang.in (LTO_OBJS): Change lto/$(LTO_BINARY_READER).o to
lto/lto-object.o.
($(LTO_EXE)): Remove $(LTO_USE_LIBELF)
(lto/lto-objfile.o): New target.
(lto/lto-elf.o, lto/lto-coff.o, lto/lto-macho.o): Remove targets.
(lto/lto.o): Remove $(LIBIBERTY_H).
 
2010-10-22 Jan Hubicka <jh@suse.cz>
 
* lto.c (add_cgraph_node_to_partition,
add_varpool_node_to_partition): Add debug info.
(lto_1_to_1_map, lto_balanced_map): Do not re-add already
partitioned nodes.
(do_whole_program_analysis): Set function flags before dumping.
 
2010-10-22 Richard Guenther <rguenther@suse.de>
 
* lto.c (lto_fixup_type): Fixup TYPE_CANONICAL again, via
the new gimple_register_canonical_type.
 
2010-10-20 H.J. Lu <hongjiu.lu@intel.com>
 
PR bootstrap/45954
* config-lang.in (boot_language): Set to $enable_lto.
 
2010-10-18 Jakub Jelinek <jakub@redhat.com>
 
PR lto/45638
* Make-lang.in (check-lto): New dummy target.
 
2010-10-14 Eric Botcazou <ebotcazou@adacore.com>
 
* lto-elf.c (SHN_XINDEX): Define if not already defined.
 
2010-10-08 Joseph Myers <joseph@codesourcery.com>
 
* lto-lang.c (lto_init_options): Change to
lto_init_options_struct. Update parameters.
(LANG_HOOKS_INIT_OPTIONS): Don't define.
(LANG_HOOKS_INIT_OPTIONS_STRUCT): Define.
 
2010-10-06 Jan Hubicka <jh@suse.cz>
 
* lto.c (lto_balanced_map): Fix accounting of program size.
 
2010-10-06 Jan Hubicka <jh@suse.cz>
 
* lto.c (lto_balanced_map): Do not produce empty partitions.
 
2010-10-06 Andi Kleen <ak@linux.intel.com>
 
* lto.c (lto_process_name): Add.
(lto_main): Call lto_process_name.
 
2010-10-06 Jan Hubicka <jh@suse.cz>
 
* lto.c (partition_cgraph_node_p, partition_varpool_node_p): Handle
COMDATs required by the linker.
 
2010-10-05 Ian Lance Taylor <iant@google.com>
 
* lto.c (lto_section_with_id): Make s a const pointer.
 
2010-10-05 Jan Hubicka <jh@suse.cz>
 
* lto.c: Include params.h.
(add_cgraph_node_to_partition, add_varpool_node_to_partition): Do
refcounting in aux field.
(undo_partition, partition_cgraph_node_p, partition_varpool_node_p):
New functions.
(lto_1_to_1_map): Simplify.
(lto_balanced_map): New function.
(do_whole_program_analysis): Chose proper partitioning alg.
* Make-lang.in (lto.o): Add dependency on params.h
 
2010-10-04 Andi Kleen <ak@linux.intel.com>
 
* Make-lang.in (lto1): Add + to build rule.
 
2010-10-03 Andi Kleen <ak@linux.intel.com>
 
* lto.c (lto_file_finalize): Replace gcc_assert for missing section
with fatal_error.
 
2010-09-28 Jan Hubicka <jh@suse.cz>
 
* lto-lang.c (handle_leaf_attribute): New function.
(lto_attribute_tables): Add leaf.
 
2010-09-25 Jie Zhang <jie@codesourcery.com>
 
* lto.c (lto_read_all_file_options): Start a new line after
printing out file names.
 
2010-09-24 Jan Hubicka <jh@suse.cz>
 
* lto.c (lto_promote_cross_file_statics): Use const_value_known_p.
 
2010-09-20 Jan Hubicka <jh@suse.cz>
 
PR tree-optimize/45605
* lto.c (lto_promote_cross_file_statics): Use const_value_known_p.
 
2010-09-18 Gerald Pfeifer <gerald@pfeifer.com>
 
* lto-elf.c (lto_obj_file_open): Also provide filename when
elf_begin fails.
 
2010-09-17 Jan Hubicka <jh@suse.cz>
 
* lto.c (lto_promote_cross_file_statics): Use const_value_known.
 
2010-09-17 Richard Guenther <rguenther@suse.de>
 
* lang.opt (flag_wpa): Also enable for the driver.
 
2010-09-16 Jan Hubicka <jh@suse.cz>
 
* lto.c (lto_materialize_function): Do not tamper with STATIC and
EXTERNAL flags.
 
2010-09-15 Laurynas Biveinis <laurynas.biveinis@gmail.com>
 
* lto-tree.h (struct lang_type): Add variable_size GTY option.
 
2010-09-08 Jan Hubicka <jh@suse.cz>
 
* lto.c (real_file_count, real_file_decl_data): New static vars.
(read_cgraph_and_symbols): Use it.
 
2010-09-08 Richard Guenther <rguenther@suse.de>
 
* lto.c (read_cgraph_and_symbols): Collect again after each
file.
 
2010-09-07 Jan Hubicka <jh@suse.cz>
 
* lto.c (promote_var, promote_fn): Set DECL_VISIBILITY_SPECIFIED.
 
2010-09-03 Richard Guenther <rguenther@suse.de>
 
* lto-elf.c (validate_file): Always error if validation fails.
 
2010-08-20 Jan Hubicka <jh@suse.cz>
 
* lto.c (lto_1_to_1_map): Be prepared for node to have no file data.
(lto_wpa_write_files): Update comments.
 
2010-08-20 H.J. Lu <hongjiu.lu@intel.com>
 
PR bootstrap/45357
* lto.c (lto_materialize_function): Replace has_analyzed_clone
with has_analyzed_clone_p.
 
2010-08-20 Jan Hubicka <jh@suse.cz>
 
* lto.c (has_analyzed_clone_p): New function
(lto_materialize_function): Use callgraph to determine if
body is needed.
(materialize_cgraph): Remove DECL_IS_BUILTIN check.
 
2010-08-20 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c: Use FOR_EACH_VEC_ELT.
 
2010-07-27 Andi Kleen <ak@linux.intel.com>
 
* Make-lang.in (lto.o): Add dependency to splay-tree.h
 
2010-07-27 Joseph Myers <joseph@codesourcery.com>
 
* lto-lang.c (lto_handle_option): Update prototype and return
value type. Remove duplicate assignment to result.
 
2010-07-27 Joseph Myers <joseph@codesourcery.com>
 
* lto-lang.c (lto_option_lang_mask, lto_complain_wrong_lang_p):
New.
(lto_init_options): Update prototype.
(LANG_HOOKS_OPTION_LANG_MASK, LANG_HOOKS_COMPLAIN_WRONG_LANG_P):
Define.
 
2010-07-10 Andi Kleen <ak@linux.intel.com>
 
PR lto/44992
* lto.c: Include splay-tree.h
(lto_resolution_read): Change to walk file_ids tree and parse
extra file_id in resolution file.
(lto_section_with_id): Add.
(create_subid_section_table): Add.
(lwstate): Add.
(lto_create_files_from_ids): Add.
(lto_file_read): Change to handle sub file ids and create list
of file_datas. Add output argument for count.
(get_section_data): Pass file_data to lto_get_section_name.
(lto_flatten_file): Add.
(read_cgraph_and_symbols): Handle linked lists of file_datas.
 
2010-07-10 Andi Kleen <ak@linux.intel.com>
 
* lto-coff.c (hash_name, eq_name): Move.
(lto_obj_build_section_table): Call lto_obj_create_section_hash_table.
* lto-elf.c: (hash_name, eq_name): Move.
(lto_obj_build_section_table): Call lto_obj_create_section_hash_table.
* lto-macho.c: (hash_name, eq_name): Move.
(lto_obj_build_section_table): Call lto_obj_create_section_hash_table.
* lto.c: (hash_name, eq_name): Move from lto-*.c
(lto_obj_create_section_hash_table): Add.
(free_with_string): Add.
 
2010-07-08 Manuel López-Ibáñez <manu@gcc.gnu.org>
 
* lto-coff.c: Include diagnostic-core.h in every file that
includes toplev.h.
* lto-elf.c: Likewise.
* lto-lang.c: Likewise.
* lto-macho.c: Likewise.
 
2010-07-07 Jakub Jelinek <jakub@redhat.com>
 
* lto-elf.c (ELFOSABI_NONE, ELFOSABI_LINUX): Define if not defined.
(validate_file): Allow merging of ELFOSABI_NONE with ELFOSABI_LINUX
objects.
 
2010-07-05 Jan Hubicka <jh@suse.cz>
 
* lto.c (add_cgraph_node_to_partition): Forward declare; walk also
nodes from same comdat group as well as all comdat functions referenced
here.
(add_varpool_node_to_partition, add_references_to_partition): New
function.
(lto_1_1_map): Skip COMDAT fnctions/variables; use
add_varpool_node_to_partition; clear aux flags when done.
(lto_promote_cross_file_statics): Do not promote stuff that gets
duplicated to each ltrans.
 
2010-07-04 Jan Hubicka <jh@suse.cz>
 
* lto.c (read_cgraph_and_symbols): Dump cgraph before merging.
 
2010-06-13 Richard Guenther <rguenther@suse.de>
 
* lto.c (lto_fixup_type): Do not register or fixup TYPE_CANONICAL.
 
2010-06-09 Kai Tietz <kai.tietz@onevision.com>
 
* lto.c (lto_resolution_read): Pre-initialize local variable r.
* lto-coff.c (coff_write_object_file): Add braces to if.
 
2010-06-08 Laurynas Biveinis <laurynas.biveinis@gmail.com>
 
* lto.c (lto_read_in_decl_state): Use typed GC allocation.
(lto_file_read): Likewise.
(new_partition): Likewise.
(read_cgraph_and_symbols): Likewise.
 
2010-06-07 Joseph Myers <joseph@codesourcery.com>
 
* lto-lang.c (flag_no_builtin, flag_no_nonansi_builtin): Remove.
(lto_handle_option): Don't set flag_signed_char here.
 
2010-06-04 Richard Guenther <rguenther@suse.de>
 
PR lto/41584
* lto.c (lto_1_to_1_map): Use the proper file_data for
varpool nodes.
 
2010-05-30 Jan Hubicka <jh@suse.cz>
 
* lto.c (promote_var, promote_fn, lto_wpa_write_files): Dump
partitioning decisions.
 
2010-05-29 Jan Hubicka <jh@suse.cz>
 
* lto.c (bitmap vector): Remove.
(lto_cgraph_node_sets, lto_varpool_node_sets): Remove.
(ltrans_partition_def): New structure.
(ltrans_partition): New type and VECtor.
(new_partition): New function.
(add_cgraph_node_to_partition): New function.
(lto_1_to_1_map): Reorganize for partitions.
(lto_add_inline_clones): Remove.
(lto_add_all_inlinees): Remove.
(lto_promote_cross_file_statics): Use partitions.
(cmp_partitions): New function.
(lto_wpa_write_files): Do not call lto_add_all_inlinees;
use partitions; output files sorted by size.
 
2010-05-29 Steven Bosscher <steven@gcc.gnu.org>
 
* Make-lang.in: Replace vec.h dependency with VEC_H.
 
2010-05-28 Joseph Myers <joseph@codesourcery.com>
 
* lto-coff.c (coff_errmsg): Remove.
(lto_coff_begin_section_with_type, lto_obj_append_data): Use %m in
errors instead of coff_errmsg (-1).
* lto-macho.c (mach_o_errmsg): Remove.
(lto_obj_begin_section, lto_obj_append_data): Use %m in errors
instead of mach_o_errmsg (-1).
* lto.c (read_cgraph_and_symbols): Use %m in errors instead of
xstrerror (errno).
 
2010-05-28 Richard Guenther <rguenther@suse.de>
 
* lto.c (prefix_name_with_star): Removed.
(strip_extension): Likewise.
(get_filename_for_set): Likewise.
(lto_write_ltrans_list): Fold into ...
(lto_wpa_write_files): ... this. Name LTRANS units
by suffixing the ltrans output list filename.
(do_whole_program_analysis): Adjust.
 
2010-05-27 Joseph Myers <joseph@codesourcery.com>
 
* 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.
 
2010-05-27 Eric Botcazou <ebotcazou@adacore.com>
 
PR lto/44230
* lto.h (lto_eh_personality): New prototype.
* lto.c: Include debug.h.
(first_personality_decl): New static variable.
(lto_materialize_function): Set it to DECL_FUNCTION_PERSONALITY of the
first function for which it is non-null.
(lto_eh_personality_decl): New static variable.
(lto_eh_personality): New function.
* lto-lang.c (LANG_HOOKS_EH_PERSONALITY): Redefine to above function.
* Make-lang.in (lto/lto.o): Add dependency on debug.h.
 
2010-05-26 Steven Bosscher <steven@gcc.gnu.org>
 
* lto-lang.c: Do not include expr.h.
 
2010-05-24 Richard Guenther <rguenther@suse.de>
 
* lto-elf.c (lto_obj_build_section_table): Work around
FreeBSD libelf issue.
 
2010-05-22 Richard Guenther <rguenther@suse.de>
 
* lto.c (read_cgraph_and_symbols): Do not collect.
 
2010-05-20 Jan Hubicka <jh@suse.cz>
 
* lto.c (promote_var, promote_fn): New functions.
(lto_promote_cross_file_statics): Compute correctly boundary including
static initializers of readonly vars.
 
2010-05-18 Jan Hubicka <jh@suse.cz>
 
* lto.c (lto_1_to_1_map): Partition non-inline clones.
(lto_promote_cross_file_statics): Deal with non-inline clones.
 
2010-05-18 Jan Hubicka <jh@suse.cz>
 
* lto.c (lto_materialize_function): Announce function when
reading body; allocate_struct_function only when reading body;
do not finalize local statics; ggc_collect after reading;
do not mark reachable node.
(materialize_cgraph): Do not announce function.
 
2010-05-11 Jan Hubicka <jh@suse.cz>
 
* lto.c (materialize_cgraph): Revert my previous patch.
 
2010-05-11 Kai Tietz <kai.tietz@onevision.com>
 
* lto-coff.c (IMAGE_FILE_MACHINE_ADM64): Rename to
IMAGE_FILE_MACHINE_AMD64.
* lto-coff.c (IMAGE_FILE_MACHINE_ADM64): Likewise.
 
2010-05-11 Jan Hubicka <jh@suse.cz>
 
* lto.c (lto_fixup_decls): Remove global var decls freeing here.
(materialize_cgraph): Add it here.
 
2010-05-11 Jan Hubicka <jh@suse.cz>
 
* lto.c (lto_fixup_decls): Free no longer needed lto_global_var_decls
vector.
 
2010-05-11 Jan Hubicka <jh@suse.cz>
 
* lto.c (lto_1_to_1_map): Remove some no longer needed checks.
(lto_promote_cross_file_statics): Never promote DECL_EXTERNAL;
use reachable_from_other_partition_p and
referenced_from_other_partition_p test.
 
2010-05-11 Kai Tietz <kai.tietz@onevision.com>
 
* lto-coff.c (validate_file): Add x64-coff support.
* lto-coff.h (IMAGE_FILE_MACHINE_ADM64): New.
(COFF_KNOWN_MACHINES): Add IMAGE_FILE_MACHINE_ADM64.
* lto-lang.c (lto_build_c_type_nodes): Add check for
'long long unsigned int' for x64-windows.
(lto_init): Likewise.
 
 
2010-05-07 Steven Bosscher <steven@gcc.gnu.org>
 
* lto.h (struct lto_file_struct): Document offset member.
* lto-endian.h: New file.
* lto-macho.h: New file.
* lto-macho.c: New file.
* Make-lang.in: Add rule for lto-macho.o.
 
2010-05-07 Richard Guenther <rguenther@suse.de>
 
PR lto/43857
PR lto/43371
* lang.opt (fresolution): Change to ...
(fresolution=): ... this.
* lto-lang.c (lto_handle_option): Adjust.
 
2010-05-07 Richard Guenther <rguenther@suse.de>
 
* lto.c (DUMPBASE_SUFFIX): Remove.
(lto_execute_ltrans): Move functionality to lto-wrapper.c.
Rename to ...
(lto_write_ltrans_list): ... only output the list of ltrans files.
(lto_maybe_unlink): Remove.
(do_whole_program_analysis): Do not execute LTRANS phase
from here.
 
2010-05-06 H.J. Lu <hongjiu.lu@intel.com>
 
* lto-lang.c (lto_handle_option): Add argument kind.
 
2010-05-05 Jan Hubicka <jh@suse.cz>
 
* lto.c (lto_promote_cross_file_statics): Compute boundary based on
refs.
 
2010-05-05 Jan Hubicka <jh@suse.cz>
 
* lto.c (lto_1_to_1_map): Partition only needed nodes.
 
2010-04-30 Jan Hubicka <jh@suse.cz>
 
* lto.c (get_filename_for_set): Look for cgraph node and if none found,
use default name.
(lto_wpa_write_files): Write any non-empty partition.
 
2010-04-30 Jan Hubicka <jh@suse.cz>
 
* lto.c: Do not attempt to make constant pool references global.
 
2010-04-28 Jan Hubicka <jh@suse.cz>
 
* lto/lto.c (lto_read_in_decl_state): Use GGC.
(lto_wpa_write_files): Announce what we are writting.
(all_file_decl_data): New.
(read_cgraph_and_symbols): Use GGC; correct timevars.
(do_whole_program_analysis): Collect.
* lto/Make-lang.in (lto.o): Fix dependency.
* Makefile.in (GTFILES): Add lto-streamer.h.
* varpool.c (varpool_analyze_pending_decls): Use TV_VARPOOL.
(varpool_assemble_pending_decls): Use VAROUT.
* lto-streamer.h (lto_tree_ref_table): Annotate.
(lto_in_decl_state): Annotate.
(lto_file_decl_data): Annotate.
 
2010-04-28 Jan Hubicka <jh@suse.cz>
 
* lto.c (lto_varpool_node_sets): New.
(lto_1_to_1_map): Partition varpool too.
(globalize_context_t, globalize_cross_file_statics,
lto_scan_statics_in_ref_table, lto_scan_statics_in_cgraph_node,
lto_scan_statics_in_remaining_global_vars): Remove.
(lto_promote_cross_file_statics): Rewrite.
(get_filename_for_set): Take vset argument.
(lto_wpa_write_files): Pass around vsets.
 
2010-04-27 Dave Korn <dave.korn.cygwin@gmail.com>
 
PR lto/42776
* Make-lang.in (LTO_OBJS): Use LTO_BINARY_READER instead of
hardcoding 'lto-elf.o'.
($(LTO_EXE)): Use LTO_USE_LIBELF instead of hardcoding '-lelf'.
 
* lto-coff.h: New file.
* lto-coff.c: Likewise.
 
2010-04-26 Richard Guenther <rguenther@suse.de>
 
* lto.c (lto_fixup_type): Deal with non-type TYPE_CONTEXT.
 
2010-04-26 Dave Korn <dave.korn.cygwin@gmail.com>
 
* lto.h (lto_elf_file_open): Rename prototype from this ...
(lto_obj_file_open): ... to this.
(lto_elf_file_close): Likewise ...
(lto_obj_file_close): ... and likewise.
(lto_elf_build_section_table): Likewise ...
(lto_obj_build_section_table): ... and likewise.
(lto_elf_begin_section): Likewise ...
(lto_obj_begin_section): ... and likewise.
(lto_elf_append_data): Likewise ...
(lto_obj_append_data): ... and likewise.
(lto_elf_end_section): Likewise ...
(lto_obj_end_section): ... and likewise.
* lto.c (lto_file_read): Update references to the above.
(lto_wpa_write_files): Likewise.
(lto_read_all_file_options): Likewise.
(read_cgraph_and_symbols): Likewise.
* lto-lang.c (LANG_HOOKS_BEGIN_SECTION): Likewise.
(LANG_HOOKS_APPEND_DATA): Likewise.
(LANG_HOOKS_END_SECTION): Likewise.
* lto-elf.c (lto_elf_file_open): Rename from this ...
(lto_obj_file_open): ... to this, updating any references.
(lto_elf_file_close): Likewise ...
(lto_obj_file_close): ... and likewise.
(lto_elf_build_section_table): Likewise ...
(lto_obj_build_section_table): ... and likewise.
(lto_elf_begin_section): Likewise ...
(lto_obj_begin_section): ... and likewise.
(lto_elf_append_data): Likewise ...
(lto_obj_append_data): ... and likewise.
(lto_elf_end_section): Likewise ...
(lto_obj_end_section): ... and likewise.
 
2010-04-21 Jan Hubicka <jh@suse.cz>
 
* lto.c (lto_fixup_tree): Do not call wpa fixup.
(materialize_cgraph): Likewise.
 
2010-04-21 Jan Hubicka <jh@suse.cz>
 
* lto.c (lto_wpa_write_files): Update.
(read_cgraph_and_symbols): Be more verbose.
(materialize_cgraph): Likewise.
(do_whole_program_analysis): Likewise.
 
2010-04-21 Jan Hubicka <jh@suse.cz>
 
* lto.c (globalize_cross_file_statics): When function has address taken,
it needs to be public.
 
2010-04-20 Jan Hubicka <jh@suse.cz>
 
* lto.c (lto_add_inline_clones): Do not track inlined_decls.
(lto_add_all_inlinees): Likewise.
(lto_wpa_write_files): Likewise.
 
2010-04-18 Eric Botcazou <ebotcazou@adacore.com>
 
* lto-lang.c (lto_init): Remove second argument in call to
build_common_tree_nodes.
 
2010-04-16 Rainer Orth <ro@CeBiTec.Uni-Bielefeld.DE>
 
* lto-elf.c [!HAVE_ELF_GETSHDRSTRNDX] (elf_getshdrstrndx): New
function.
 
2010-03-09 Eric Botcazou <ebotcazou@adacore.com>
 
PR bootstrap/43276
* lto-elf.c: Define EM_* constants if not already defined.
 
2010-03-03 Eric Botcazou <ebotcazou@adacore.com>
 
* lto-elf.c (is_compatible_architecture): New static function.
(DEFINE_VALIDATE_EHDR): Use it to validate the architecture.
 
2010-02-11 Richard Guenther <rguenther@suse.de>
 
PR driver/43021
* lto-elf.c (lto_elf_file_open): Handle file@offset case more
appropriately.
 
2010-01-11 Andy Hutchinson <hutchinsonandy@gcc.gnu.org>
 
* lto.c (O_BINARY): Define.
(lto_read_section_data): Open file in binary mode.
* lto-elf.c (O_BINARY): Define.
(lto_elf_file_open): Open file in binary mode.
 
2010-01-08 Richard Guenther <rguenther@suse.de>
 
PR lto/42528
* lto-lang.c (lto_handle_option): Handle -f[un]signed-char.
(lto_init): Do not init char_type_node in a standard way
but according to flag_signed_char.
 
2010-01-03 H.J. Lu <hongjiu.lu@intel.com>
 
PR lto/41564
* lto.c (DUMPBASE_SUFFIX): New.
(lto_execute_ltrans): Append a sequence number to -dumpbase
for LTRANS.
 
2010-01-02 H.J. Lu <hongjiu.lu@intel.com>
 
PR lto/42580
* lto-elf.c (lto_elf_file_open): Stop if the command line
option file is missing.
 
2009-12-15 Richard Guenther <rguenther@suse.de>
 
* lto.c (lto_fixup_field_decl): Fixup DECL_FIELD_OFFSET.
(lto_post_options): Do not disable debuginfo.
 
2009-12-14 Dmitry Gorbachev <d.g.gorbachev@gmail.com>
 
* Make-lang.in ($(LTO_EXE)): Use $(LINKER).
 
2009-12-11 Richard Guenther <rguenther@suse.de>
 
PR lto/42037
* lto.c (lto_resolution_read): Properly grow the vector.
 
2009-12-11 Richard Guenther <rguenther@suse.de>
 
PR lto/41915
* lto-lang.c (lto_init_options): Initialize flag_complex_method
to the C99 default. Do not set flag_unit_at_a_time.
 
2009-11-28 Jakub Jelinek <jakub@redhat.com>
 
* lto-lang.c (handle_nonnull_attribute): Remove unused attr_arg_num
variable.
 
2009-11-19 Rafael Avila de Espindola <espindola@google.com>
 
PR bootstrap/42096
* lto-elf.c (lto_elf_file_open): Use lto_parse_hex.
* lto.c (lto_parse_hex): New.
(lto_resolution_read): Use lto_parse_hex.
* lto.h (lto_parse_hex): New.
 
2009-11-17 Rafael Avila de Espindola <espindola@google.com>
 
* lto-elf.c (lto_file_init): Add offset argument.
(lto_elf_file_open): Record the offset.
* lto.c (lto_resolution_read): Change file_name into a lto_file
argument. Check offsets.
(lto_file_read): Update call to lto_resolution_read.
* lto.h (lto_file_struct): Add the offset field.
 
2009-11-16 Rafael Avila de Espindola <espindola@google.com>
 
* lto-elf.c (lto_elf_file_open): Use strtoll to parse the offset.
 
2009-11-14 Jan Hubicka <jh@suse.cz>
 
* lto.c (read_cgraph_and_symbols): Set also ipa_transforms_to_apply.
 
2009-11-12 Rafael Avila de Espindola <espindola@google.com>
 
* lang.opt (fresolution): Renamed from resolution.
* lto-lang.c (lto_handle_option): Handle new option name.
* lto.c (lto_resolution_read): Add more checks. Discard rest of line.
 
2009-11-04 Richard Guenther <rguenther@suse.de>
Rafael Avila de Espindola <espindola@google.com>
 
* lto-elf.c (lto_elf_build_section_table): Add the base offset.
(lto_elf_file_open): Handle offsets in arguments name@offest.
 
2009-10-30 Richard Guenther <rguenther@suse.de>
 
PR lto/41858
* lto.c (lto_file_read): Do not set file_data->fd.
(lto_read_section_data): Use a single-entry file-descriptor cache.
Do not check the result of xmalloc.
(free_section_data): Do not use file_data->fd.
(lto_read_all_file_options): Likewise.
 
2009-10-22 Richard Guenther <rguenther@suse.de>
 
* lto.c (lto_fixup_jump_functions): Remove.
(lto_fixup_decls): Do not fixup jump functions.
(read_cgraph_and_symbols): Schedule cgraph merging after
summary reading. Schedule type and decl fixup before
summary reading.
 
2009-10-22 Richard Guenther <rguenther@suse.de>
 
* lto.c (lto_fixup_data_t): Remove free_list member.
(lto_fixup_tree): Do not insert into free_list.
(free_decl): Remove.
(lto_fixup_decls): Remove free-list handling.
 
2009-10-22 Jan Hubicka <jh@suse.cz>
 
* lto.c (lto_fixup_jump_functions): New function.
(lto_fixup_decls): Use it.
 
2009-10-16 Richard Guenther <rguenther@suse.de>
 
PR lto/41715
* lto.c (lto_fixup_tree): Revert last change.
 
2009-10-14 Richard Guenther <rguenther@suse.de>
 
* lto.c (lto_fixup_tree): In case the prevailing decl is not
compatible with the one we replace wrap it around a
VIEW_CONVERT_EXPR.
 
2009-10-09 Richard Guenther <rguenther@suse.de>
 
PR lto/41635
PR lto/41636
* lto.c (read_cgraph_and_symbols): Do not assert we can open
a file.
* lto-elf.c (init_shdr##BITS): Fix i18n problems.
(init_ehdr##BITS): Likewise.
 
2009-10-08 Joseph Myers <joseph@codesourcery.com>
 
* lto-elf.c (init_shdr##BITS, lto_elf_begin_section_with_type,
init_ehdr##BITS, lto_elf_file_close): Remove trailing "." from
diagnostics.
* lto-lang.c (lto_post_options): Remove trailing "." from
diagnostics.
 
2009-10-08 Richard Guenther <rguenther@suse.de>
 
* lto.c (read_cgraph_and_symbols): Free the gimple type merging
hash tables.
 
2009-10-07 Joseph Myers <joseph@codesourcery.com>
 
* lto.c: Only include <sys/mman.h> if HAVE_MMAP_FILE.
 
2009-10-07 Jan Hubicka <jh@suse.cz>
 
* lto.c (read_cgraph_and_symbols): Mark functions neccesary only at
ltrans stage; explain why this is needed and should not.
 
2009-10-05 Richard Guenther <rguenther@suse.de>
 
PR lto/41552
PR lto/41487
* lto.c (lto_read_decls): Do not register deferred decls.
(read_cgraph_and_symbols): Delay symbol and cgraph merging
until after reading the IPA summaries.
 
2009-10-02 Rafael Avila de Espindola <espindola@google.com>
 
* Make-lang.in (lto/lto-lang.o): Don't depend on lto/common.h.
(lto-lang.c): Don't include lto/common.h.
 
2009-10-02 Rafael Avila de Espindola <espindola@google.com>
 
* Make-lang.in (LTO_OBJS): Remove lto/common.o.
(lto/common.o): Remove.
* common.c: Remove.
* common.h (lto_kind_str): Remove.
(lto_visibility_str): Remove.
(lto_resolution_str): Make it static.
 
2009-10-01 Diego Novillo <dnovillo@google.com>
 
* lto.c (lto_read_decls): Add comment.
Call internal_error instead of gcc_assert.
(lto_resolution_read): Likewise.
(lto_add_all_inlinees): Tidy.
* Make-lang.in: Fix copyright boilerplate.
(lto.pdf): New.
(lto.install-pdf): New.
* lto-tree.h: Fix copyright boilerplate.
* lang-specs.h: Likewise.
Remove ".lto" entry from compilers fragment.
* lto-elf.c: Move inclusion of gelf.h after config.h.
Tidy formatting everywhere.
* lto.h: Fix copyright boilerplate.
Tidy formatting everywhere.
* common.c: Likewise.
* config-lang.in: Likewise.
* common.h: Likewise.
* lto-lang.c: Likewise.
 
2009-10-01 Richard Guenther <rguenther@suse.de>
 
* lto.c (lto_read_section_data): Use plain lseek/read.
 
2009-10-01 Richard Guenther <rguenther@suse.de>
 
* lto.c (LTO_MMAP_IO): Define if we can mmap files and
use sysconf to query the system page size.
(lto_file_read): Implement fallback using stdio.
(free_section_data): Likewise.
 
2009-09-29 Diego Novillo <dnovillo@google.com>
 
* lto-lang.c (lto_init): Really fix call to
build_common_builtin_nodes.
 
2009-09-29 Diego Novillo <dnovillo@google.com>
 
* lto-lang.c (lto_init): Fix call to
build_common_builtin_nodes.
 
2009-09-29 Richard Guenther <rguenther@suse.de>
 
PR lto/40754
* lto-elf.c (init_shdr##BITS): Properly specify alignment
in bytes.
(first_data_block): New static variable.
(lto_elf_append_data): Align the first data block in each
section.
 
2009-09-28 Diego Novillo <dnovillo@google.com>
 
* lto-lang.c: Tidy. Remove stale FIXME lto markers.
* lto.c (strip_extension): New.
(get_filename_for_set): Call it. Do not call make_cwd_temp_file.
(lto_execute_ltrans): Tidy.
Do not pass -fwpa nor -fltrans-* to LTRANS.
* opts.c: Tidy formatting and remove stale FIXME lto markers.
* tree.c (need_assembler_name_p): Call
lang_hooks.decls.may_need_assembler_name_p if set.
* varasm.c (default_binds_local_p_1): Remove check for
flag_ltrans.
* varpool.c (decide_is_variable_needed): Do not test for
in_lto_p.
 
2009-09-22 Richard Guenther <rguenther@suse.de>
 
PR lto/39276
* lto.c (lto_execute_ltrans): Perform ltrans phase manually.
* Make-lang.in: Remove ltrans-driver stuff.
* config-lang.in: Likewise.
* lang.opt (fltrans-driver): Remove.
* lto-lang.c (lto_init_options): Remove code initializing
ltrans_driver.
* ltrans-driver: Remove.
 
2009-09-21 Diego Novillo <dnovillo@google.com>
 
* lto-lang.c (lto_define_builtins): Remove superfluous
calls to targetm.init_builtins and build_common_builtin_nodes.
(lto_init): Add targetm.arm_eabi_unwinder as parameter to
build_common_builtin_nodes.
* lto.c (lto_materialize_function): Do nothing if NODE is a
clone.
 
2009-09-03 Diego Novillo <dnovillo@google.com>
 
* lto-elf.c (validate_file): Replace call to
elf_getshstrndx with call to elf_getshdrstrndx.
 
2009-08-19 Richard Guenther <rguenther@suse.de>
 
* lto-lang.c (lto_init): Merge char_type_node with the
appropriately signed variant.
 
2009-08-19 Richard Guenther <rguenther@suse.de>
 
PR lto/41071
* lto.c (lto_fixup_common): Re-build the pointer-to chain part one.
(lto_fixup_type): Re-build the pointer-to chain part two.
 
2009-08-19 Richard Guenther <rguenther@suse.de>
 
PR lto/41071
* lto.c (lto_fixup_type): Re-build the type variant chain.
 
2009-08-19 Richard Guenther <rguenther@suse.de>
 
PR lto/41071
* lto.c (lto_fixup_constructor): New function.
(lto_fixup_tree): Replace all types. Properly fixup
constructors and constants.
 
2009-08-14 Richard Guenther <rguenther@suse.de>
 
* lto.c (read_cgraph_and_symbols): Exchange TREE_CHAIN use
for DECL_LANG_SPECIFIC.
 
2009-08-13 Richard Guenther <rguenther@suse.de>
 
PR lto/41032
* lto-lang.c (LANG_HOOKS_TYPES_COMPATIBLE_P): Define to NULL.
 
2009-07-30 Richard Guenther <rguenther@suse.de>
 
PR lto/40903
* lto.c (read_cgraph_and_symbols): After fixing up decls choose
the largest decl for output and free TREE_CHAIN for further
use.
 
2009-07-24 Diego Novillo <dnovillo@google.com>
 
* Make-lang.in: Add empty lto.install-plugin target.
 
2009-07-13 Diego Novillo <dnovillo@google.com>
 
* lto.c (lto_fixup_tree): Handle IMPORTED_DECL.
 
2009-07-11 Richard Guenther <rguenther@suse.de>
 
* lto-lang.c (lto_write_globals): Wrapup global decls.
 
2009-07-10 Richard Guenther <rguenther@suse.de>
 
* lto-lang.c (lto_init): Allocate one more location to make
BUILTINS_LOCATION correct.
 
2009-07-09 Rainer Orth <ro@TechFak.Uni-Bielefeld.DE>
 
* lto.c (free_section_data): Cast computed_offset to caddr_t.
 
2009-07-06 Diego Novillo <dnovillo@google.com>
 
* lto.c (lto_fixup_type): Fixup TYPE_SIZE and
TYPE_SIZE_UNIT.
 
2009-07-06 Diego Novillo <dnovillo@google.com>
 
* lto.c (preload_common_nodes): Remove.
(lto_read_in_decl_state): Call lto_streamer_cache_get.
(lto_read_decls): Call lto_data_in_create and
lto_data_in_delete.
(free_decl): Do not call ggc_free.
(lto_main): Call lto_init_reader.
* lto-lang.c (lto_type_for_size): Handle intTI_type_node.
(lto_init): Initialize main_identifier_node if needed.
Make ptrdiff_type_node be integer_type_node.
 
2009-06-19 Diego Novillo <dnovillo@google.com>
 
* lto.c: Remove code guarded by #ifdef LTO_STREAM_DEBUGGING.
Remove code guarded by #ifdef GLOBAL_STREAMER_TRACE.
Remove code guarded by #ifdef LOCAL_TRACE.
 
2009-06-18 Diego Novillo <dnovillo@google.com>
 
* lto.c: Update license to GPLv3.
* lto-elf.c: Likewise.
* common.c: Likewise.
* lto-lang.c: Likewise.
* lto.h: Remove superfluous include files. Update all
users.
 
2009-06-17 Diego Novillo <dnovillo@google.com>
 
* lto.c (read_cgraph_and_symbols): Call input_cgraph.
 
2009-06-02 Diego Novillo <dnovillo@google.com>
 
* lto.c (lto_1_to_1_map): Ignore nodes that have not been
read in.
(materialize_cgraph): Only materialize nodes that have a
representation on file.
 
2009-06-01 Diego Novillo <dnovillo@google.com>
 
* lto-lang.c (lto_handle_option): Hanlde OPT_Wabi.
 
2009-05-31 Diego Novillo <dnovillo@google.com>
 
* lto-lang.c (lto_type_for_mode): Handle all the modes
handled in c_common_type_for_mode.
 
2009-05-21 Diego Novillo <dnovillo@google.com>
 
* lto-elf.c: Always include <gelf.h>.
* config-lang.in (target_libs): Remove.
(build_by_default): Set to no.
 
2009-05-15 Diego Novillo <dnovillo@google.com>
 
* lto.c (lto_materialize_function): Assert that DECL is
not a builtin.
(materialize_cgraph): Don't try to materialize builtin
functions.
* lto-section-out.c (write_symbol_vec): Do not write
builtin functions.
 
2009-05-13 Diego Novillo <dnovillo@google.com>
 
* lto-lang.c (LANG_HOOKS_GET_ALIAS_SET): Define.
 
2009-05-07 Diego Novillo <dnovillo@google.com>
 
* lto.c (lto_resolution_read): Add type casts for C++ warnings.
(LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE): Define.
(lto_fixup_type): Call it for TYPE_POINTER_TO,
TYPE_REFERENCE_TO, TYPE_CONTEXT and TYPE_CANONICAL.
(lto_fixup_tree): Call gimple_register_type when *TP is a
type.
(lto_main): Call bitmap_obstack_initialize.
 
2009-04-22 Diego Novillo <dnovillo@google.com>
 
* lto.c (free_section_data): Tidy.
(lto_1_to_1_map): Tidy.
(lto_add_all_inlinees): Tidy.
(prefix_name_with_star): New.
(get_filename_for_set): New.
(lto_wpa_write_files): Call cgraph_node_set_needs_ltrans_p
to determine what cgraph node sets to write.
Call get_filename_for_set to compute temporary file
names.
(lto_execute_ltrans): Do not execute LTRANS on files with
names that start with '*'.
Move logic to execute LTRANS together so that LTRANS is
invoked only if there are any files to compile.
(do_whole_program_analysis): Only remove output files
that do not start with '*'.
 
2009-04-06 Diego Novillo <dnovillo@google.com>
 
* lto-lang.c (lto_post_options): Set flag_excess_precision_cmdline.
* lto.c (read_cgraph_and_symbols): Set cgraph_function_flags_ready.
(lto_add_all_inlinees): Tidy.
 
2009-03-26 Diego Novillo <dnovillo@google.com>
 
* lto.c: Include gimple.h.
(lto_read_in_decl_state): Call gimple_register_type for
every type in every stream.
(lto_fixup_common): Call gimple_register_type if T has a
type.
(do_whole_program_analysis): Call print_lto_report.
(lto_main): Call print_lto_report after cgraph_optimize.
* Make-lang.in (lto.o): Add dependency on GIMPLE_H.
 
2009-03-24 Diego Novillo <dnovillo@google.com>
 
* Make-lang.in (lto-lang.o): Add dependency on TARGET_H and EXPR_H.
(lto.o): Add dependency on GIMPLE_H.
 
2009-03-10 Simon Baldwin <simonb@google.com>
 
* lto.c (lto_read_all_file_options): Close any open file descriptor
contained in file_data before freeing.
 
2009-02-24 Rafael Avila de Espindola <espindola@google.com>
 
* lto.c (lto_add_inline_clones): Don't add the master clone. Check
for a decl in the original bitmap, not a node.
(lto_add_all_inlinees): Remove original nodes that are not needed.
(lto_scan_statics_in_cgraph_node): Don't care if the node is the master.
 
2009-02-24 Diego Novillo <dnovillo@google.com>
 
* lto.c (lto_materialize_function): Update
lto_stats.num_function_bodies.
(get_section_data): Initialize *LEN to 0.
(lto_1_to_1_map): Update lto_stats.num_cgraph_partitions.
(lto_wpa_write_files): Update lto_stats.num_cgraph_nodes.
Update lto_stats.num_output_files.
(read_cgraph_and_symbols): Update lto_stats.num_input_files.
(materialize_cgraph): Update lto_stats.num_input_cgraph_nodes.
(lto_main): Initialize lto_stats.
If flag_lto_report is set, call print_lto_report.
 
2009-02-19 Diego Novillo <dnovillo@google.com>
 
Revert
 
2009-02-19 Rafael Avila de Espindola <espindola@google.com>
 
* lto.c (lto_add_inline_clones): Don't add the
master clone. Check for a decl in the original
bitmap, not a node.
(lto_add_all_inlinees): Remove original nodes
that are not needed.
(lto_scan_statics_in_cgraph_node): Don't care if
the node is the master.
(lto_promote_cross_file_statics): Use a new
context.seen_node_decls for each set
 
2009-02-19 Rafael Avila de Espindola <espindola@google.com>
 
* lto.c (lto_add_inline_clones): Don't add the master clone. Check
for a decl in the original bitmap, not a node.
(lto_add_all_inlinees): Remove original nodes that are not needed.
(lto_scan_statics_in_cgraph_node): Don't care if the node is the master.
(lto_promote_cross_file_statics): Use a new context.seen_node_decls
for each set
 
2009-02-18 Diego Novillo <dnovillo@google.com>
 
* lto.c (lto_wpa_write_files): Use timers TV_WHOPR_WPA
and TV_WHOPR_WPA_IO.
(lto_execute_ltrans): Use timer TV_WHOPR_WPA_LTRANS_EXEC.
(read_cgraph_and_symbols): Use timer TV_IPA_LTO_DECL_IO.
(materialize_cgraph): Use timer TV_IPA_LTO_GIMPLE_IO.
Use timer TV_WHOPR_WPA or TV_WHOPR_LTRANS or TV_LTO
depending on command line flags.
(do_whole_program_analysis): Use timer TV_WHOPR_WPA.
(lto_main): Remove timer uses.
 
2009-02-18 Rafael Avila de Espindola <espindola@google.com>
 
* lto.c (lto_materialize_function): Don't set DECL_EXTERN to 0.
(lto_wpa_write_files): Update calls to renamed functions.
 
2009-02-17 Diego Novillo <dnovillo@google.com>
 
PR 39203
* lto-lang.c (lto_post_options): Disable -fwhole-program
when running LTRANS.
 
2009-02-10 Diego Novillo <dnovillo@google.com>
 
* lto.c (read_cgraph_and_symbols): Fix comment.
 
2009-02-10 Diego Novillo <dnovillo@google.com>
 
* lto.c (read_cgraph_and_symbols): Read options from all
IL files.
 
2009-02-10 Diego Novillo <dnovillo@google.com>
 
* lto.c (read_cgraph_and_symbols): Factor out of lto_main.
(materialize_cgraph): Likewise.
(do_whole_program_analysis): Likewise.
(lto_main): Call read_cgraph_and_symbols,
materialize_cgraph and do_whole_program_analysis.
 
2009-02-10 Simon Baldwin <simonb@google.com>
 
* lto.c: Include lto-opts.h.
* (lto_main): Clear file options at loop start, read any saved
options from the first file handled, and re-issue options.
* Makefile.in (lto.o): Add dependency on lto-opts.h.
 
2009-02-02 Diego Novillo <dnovillo@google.com>
 
* lto.c (lto_main): Stop LTO_TIMER and use
TV_WHOPR_WPA_LTRANS_EXEC when launching LTRANS.
 
2009-01-30 H.J. Lu <hongjiu.lu@intel.com>
 
PR lto/38995
* lto-elf.c (init_shdr##BITS): Set the sh_addralign field
to POINTER_SIZE.
 
2009-01-29 Ramana Radhakrishnan <ramana.r@gmail.com>
 
* Make-lang.in (LTO_EXE): Link with all
BACKENDLIBS and not only GMPLIBS
 
2009-01-28 H.J. Lu <hongjiu.lu@intel.com>
 
PR bootstrap/38992
* lto-elf.c: Include gelf.h instead of libelf.h.
(lto_elf_file_close): Replace elfx_update_shstrndx with
gelf_getehdr, elf_getscn, gelf_getshdr, gelf_update_shdr and
gelf_update_ehdr.
 
2009-01-28 H.J. Lu <hongjiu.lu@intel.com>
 
PR middle-end/38996
* lto-elf.c (DEFINE_INIT_EHDR): Initialize e_version.
 
2009-01-26 Diego Novillo <dnovillo@google.com>
 
* lto-lang.c (LANG_HOOKS_TYPES_COMPATIBLE_P): Update.
 
2009-01-26 Diego Novillo <dnovillo@google.com>
 
* lto-lang.c (lto_types_compatible_p): Move to gimple.c
and rename into gimple_types_compatible_p.
 
2009-01-12 Rafael Avila de Espindola <espindola@google.com>
 
* lto-lang.c (lang_hooks): Remove the const qualifier.
 
2009-01-06 Diego Novillo <dnovillo@google.com>
 
* ltrans-driver: Mark 'all' target as phony.
 
2008-12-31 Diego Novillo <dnovillo@google.com>
 
* ltrans-driver: Execute a NOP action for target 'all'.
 
2008-12-19 Diego Novillo <dnovillo@google.com>
 
* lto.c (lto_1_to_1_map): Tidy.
 
2008-12-19 Diego Novillo <dnovillo@google.com>
 
* lto-elf.c (lto_elf_file_open): When FILENAME cannot
be opened, show its name.
* ltrans-driver: If $verbose is set, do not use parallelism.
 
2008-12-17 Rafael Avila de Espindola <espindola@google.com>
 
* lto.c (lto_fixup_function): New.
(lto_fixup_tree): Call lto_fixup_function.
 
2008-12-14 Doug Kwan <dougkwan@google.com>
 
* lto.c (lto_1_to_1_map): Create a cgraph node set for any global
variables if there is no function.
 
2008-12-10 Simon Baldwin <simonb@google.com>
 
* ltrans-driver: Always run make in silent mode, to avoid make's
trace on stdout interfering with lto-wrapper output.
 
2008-12-10 Doug Kwan <dougkwan@google.com>
 
* lto.c (lto_add_inline_clones): Do not force master clones of
inlined functions already in SET to be static inline.
 
2008-12-04 Doug Kwan <dougkwan@google.com>
 
* lto.c (globalize_context_t): New type to store states in
globalization of cross-file statics.
(globalize_cross_file_statics): New.
(lto_scan_statics_in_ref_table): Walk tree to look for reachable
static decls that need to be fixed up.
(lto_scan_statics_in_cgraph_node): Change call interface to use
a globalize_context_t CONTEXT for all states used.
(lto_scan_statics_in_remaining_global_vars): New.
(lto_promote_cross_file_statics): Use new call interface of
LTO_SCAN_STATICS_IN_CGRAPH_NODE. Handle remaining externally
visible vars in the last set.
 
2008-12-03 Diego Novillo <dnovillo@google.com>
 
* lto.c (lto_fixup_tree): Do not emit an error when
PREVAILING throw but T doesn't.
 
2008-12-02 Doug Kwan <dougkwan@google.com>
 
* lto.c (lto_scan_statics_in_ref_table): New function factored out
from code in ...
(lto_scan_statics_in_cgraph_node): Handle both file-scope static
variables and functions.
(lto_promote_cross_file_statics): Rename bitmaps to SEEN_DECLS
and GLOBAL_DECLS from SEEN_VARS and GLOBAL_VARS.
 
2008-11-29 Diego Novillo <dnovillo@google.com>
 
* lto.c: Include timevar.h.
(lto_materialize_function): Tidy. Add comments.
(lto_wpa_write_files): Tidy.
(lto_execute_ltrans): Tidy.
(lto_main): Add local variable LTO_TIMER. Initialize it
to one of TV_WHOPR_WPA, TV_WHOPR_LTRANS or TV_LTO.
Start and stop the timer.
Tidy comments.
* Make-lang.in (lto.o): Add dependency on timevar.h.
* ltrans-driver: React to -v and -save-temps.
Use simple heuristic to determine how much parallelism to
use when executing make.
 
2008-11-12 Doug Kwan <dougkwan@google.com>
 
* lto.c (lto_bitmap_obstack): Remove var.
(lto_materialize_function): Do nothing instead of marking function
body in file if flag_wpa is true.
(lto_add_all_inlinees): Use bitmap functions in lto-utils.c.
(lto_scan_statics_in_cgraph_node): New function.
(lto_promote_cross_file_statics): Same.
(lto_wpa_write_files): Call lto_promote_cross_file_statics.
Use bitmap functions in lto-utils.c. Remove unsued label OUT.
* Make-lang.in (lto/lto.o): Add lto-utils.h to dependency list.
 
2008-11-09 Diego Novillo <dnovillo@google.com>
 
* lto/lto.c (lto_fixup_tree): Change error message locus
information to include location of mismatching
declaration.
Use TREE_NO_WARNING to avoid repeated messages.
(lto_main): If lto_fixup_decls emitted any errors, exit.
* lto/lto-lang.c: Don't include libfuncs.h and except.h
(lto_init_options): Don't enable exceptions by default.
(lto_eh_runtime_type): Move to lto-function-in.c
(lto_init_eh): Likewise.
(lto_init): Don't call lto_init_eh.
* lto/Make-lang.in (lto-lang.o): Remove dependency on
libfuncs.h and except.h.
 
2008-10-30 Diego Novillo <dnovillo@google.com>
 
* lto.c (lto_read_decls): Declare debug_main only if
LTO_STREAM_DEBUGGING is enabled.
 
2008-10-30 Simon Baldwin <simonb@google.com>
 
* lto.c (lto_wpa_write_files): Create intermediate files with
make_cwd_temp_file().
(lto_maybe_unlink): New. Delete intermediate WPA files unless
WPA_SAVE_LTRANS is set.
(lto_main): Call lto_maybe_unlink() for intermediate WPA files.
* ltrans-driver: Do not strip directory from output files.
 
2008-10-29 Doug Kwan <dougkwan@google.com>
 
* lto.c (free_decl): Call lto_symtab_clear_resolution when freeing
DECL.
* Make-lang.in (LTO_OBJS): Remove lto/lto-symtab.o
(lto/lto-symtab.o): Remove rule.
* lto-tree.h (struct lang_identifier): Remove LTO specific fields.
(struct lang_decl): Remove RESOLUTION and add DUMMY in struct.
(LANG_IDENTIFIER_CAST, LTO_IDENTIFIER_DECL, LTO_DECL_RESOLUTION):
Remove macros.
lto-symtab.c (File): Move up one level.
lto-lang.c (cgraph.h): Remove include.
(input_overwrite_node, input_node, input_edge, input_cgraph_1,
input_cgraph): Move to lto-cgraph.c in gcc directory above.
(LANG_HOOKS_INPUT_CGRAPH): Remove use of macro.
 
2008-10-24 Rafael Espindola <espindola@google.com>
 
* lto-function-in.c (get_resolution): Return LDPR_PREEMPTED_IR for
non prevailing weak symbols.
 
2008-10-24 Rafael Espindola <espindola@google.com>
 
* lto-lang.c (input_cgraph_1): Iterate over nodes, not cgraph_nodes.
 
2008-10-24 Rafael Espindola <espindola@google.com>
 
* lto-lang.c (input_node): Avoid casts from pointers to ints of
different types.
 
2008-10-23 Simon Baldwin <simonb@google.com>
 
* lto-lang.c (input_node): Save the node reference, rather than the
node pointer, in node->inlined_to.
(input_cgraph_1): Convert node references into node pointers.
 
2008-10-22 Diego Novillo <dnovillo@google.com>
Rafael Espindola <espindola@google.com>
 
* lto.c (lto_resolution_read): Tidy.
* lto-symtab.c (lto_symtab_prevailing_decl): Do not
abort if RET is NULL.
 
2008-10-22 Doug Kwan <dougkwan@google.com>
 
* lto.c (lto_fixup_tree): Check for NOTHROW conflict only if
exceptions flag is given.
* lto-lang.c: (lto_init_options) Set default exceptions flag.
(lto_init_eh): Remove exceptions flag initialization.
(lto_init): Only call lto_init_eh if exceptions flag is set.
 
2008-10-21 Diego Novillo <dnovillo@google.com>
 
* lto.c: Tidy some formatting.
* lto.h: Likewise.
 
2008-10-21 Simon Baldwin <simonb@google.com>
 
* lto-symtab.c: (lto_same_type_p): Types cannot be equal if one of
them is NULL (but not the other).
 
2008-10-17 Diego Novillo <dnovillo@google.com>
 
* ltrans-driver: Divert output from make to a temporary file.
Show it if the call to make failed.
 
2008-10-15 Diego Novillo <dnovillo@google.com>
 
* lto.c (lto_wpa_write_files): Reformat do-while loop.
Do not print TEMP_FILENAME
* ltrans-driver: Call make with -s.
 
2008-10-15 Diego Novillo <dnovillo@google.com>
 
* lto-symtab.c (lto_symtab_merge_decl): Do not force
TREE_STATIC on global symbols.
 
2008-10-14 Ollie Wild <aaw@google.com>
 
* Make-lang.in (LTRANS_DRIVER_INSTALL_NAME): Remove.
(LTRANS_DRIVER_EXE): Add.
(lto.all.cross): Add LTRANS_DRIVER_EXE.
(lto.all.encap): Add LTRANS_DRIVER_EXE.
(lto.install.common): Remove ltrans-driver.
(lto.mostlyclean): Add LTRANS_DRIVER_EXE.
(LTRANS_DRIVER_EXE): New build rule.
* config-lang.in (compilers): Add ltrans-driver.
 
2008-10-14 Diego Novillo <dnovillo@google.com>
 
* Make-lang.in (LTRANS_DRIVER_INSTALL_NAME): Disable transformation
of program name.
 
2008-10-13 Ollie Wild <aaw@google.com>
 
* lang-spec.h (@lto): Replace lto1_options with cc1_options.
* lto.c (lto_execute_ltrans): Add "-fno-wpa -fltrans -xlto" to CFLAGS.
* ltrans-driver (LTRANS_FLAGS): Remove.
 
2008-10-08 Doug Kwan <dougkwan@google.com>
 
* lto.c (lto_fixup_tree): Remove ATTRIBUTE_UNUSED from DATA.
Handle new tree codes RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE
and TREE_BINFO. Also move code handling FUNCTION_DECL and VAR_DECL
from lto_fixup_state to here.
(lto_fixup_state): Take an lto_fixup_data_t object DATA instead of
just a free-list. Fix up types also. Move decl merging code to
lto_fixup_tree.
(lto_fixup_state_aux): Change AUX to point to an lto_fixup_data_t
object.
(lto_fixup_decls): Use another pointer set to avoid multiple
walking of nodes except for DECLs to be replaced. Pass an
lto_fixup_data_t object to tree-walker.
 
2008-10-08 Rafael Espindola <espindola@google.com>
 
* lto-symtab.c (lto_symtab_set_resolution): New.
(lto_symtab_merge_decl): Use lto_symtab_set_resolution and
lto_symtab_get_resolution.
(lto_symtab_prevailing_decl): Return decl for non public decls.
(lto_symtab_get_resolution): New.
* lto.c (lto_fixup_tree, lto_fixup_state): Remove unecessary checks.
 
2008-10-06 Rafael Espindola <espindola@google.com>
 
* lto-lang.c: Include cgraph.h.
(input_overwrite_node, input_node, input_edge, input_cgraph_1,
input_cgraph): Moved from lto-cgraph.c.
(LANG_HOOKS_INPUT_CGRAPH): New.
 
2008-10-03 Rafael Espindola <espindola@google.com>
 
* lto.c (lto_fixup_tree, lto_fixup_state): Fix the FIXME.
 
2008-10-03 Rafael Espindola <espindola@google.com>
 
* lto-symtab.c (lto_symtab_overwrite_decl): Remove. Remove all calls.
(lto_symtab_merge_decl): Update LTO_IDENTIFIER_DECL the reflect the
prevailing definition. Don't mark TREE_NOTHROW differences.
* lto.c (lto_fixup_tree): New.
(lto_fixup_state): New.
(lto_fixup_state_aux): New.
(free_decl): New.
(lto_fixup_decls): New.
(lto_main): Call lto_fixup_decls.
 
2008-10-02 Ollie Wild <aaw@google.com>
 
* lang.opt (fltrans): Moved from common.opt. Remove RejectNegative
and Init.
(fwpa): Moved from common.opt. Remove RejectNegative and Init.
* lto-lang.c (lto_post_options): Add validation and fixups for
-fltrans and -fwpa.
 
2008-10-02 Rafael Espindola <espindola@google.com>
 
* lto-symtab.c (lto_symtab_merge_var, lto_symtab_merge_fn,
lto_symtab_merge_decl): Return void.
(lto_symtab_prevailing_decl): New.
 
2008-09-30 Rafael Espindola <espindola@google.com>
 
* lto-symtab.c (lto_symtab_compatible): Remove the check for already
defined symbols.
(lto_symtab_overwrite_decl): Copy LTO_DECL_RESOLUTION.
(lto_symtab_merge_decl): Store symbol resolution in LTO_DECL_RESOLUTION.
Check for already defined symbols.
* lto-tree.h (lang_decl): Remove dummy and add resolution fields.
(LTO_IDENTIFIER_RESOLUTION): Remove.
(LTO_DECL_RESOLUTION): New.
 
2008-09-30 Rafael Espindola <espindola@google.com>
 
* lto.c (lto_read_decls): Use new input_tree signature.
 
2008-09-26 Doug Kwan <dougkwan@google.com>
 
* lto.c (lto_main): Call lto_fixup_nothrow_decls to fix up function
bodies affected by exception attribute merging of DECLs.
* lto-symtab.c (lto_symtab_merge_decl): Handle exception attribute
merging.
 
2008-09-25 Rafael Espindola <espindola@google.com>
 
* Make-lang.in (PLUGIN_API_H, LTO_TREE_H): New.
(lto/lto-lang.o, lto/lto.o, lto/lto-symtab.o) Use LTO_TREE_H.
* lto-symtab.c (lto_symtab_compatible): New.
(lto_symtab_overwrite_decl): New.
(lto_symtab_merge_decl): Refactor to use the above functions
and the resolution from lang_identifier.
* lto-tree.h: Include plugin-api.h.
(lang_identifier): Add resolution.
(LTO_IDENTIFIER_RESOLUTION): New.
 
2008-09-25 Ollie Wild <aaw@google.com>
 
* lang.opt (fltrans-output-list=): New option.
* lto.c (lto_execute_ltrans): Output file names to ltrans_output_list.
 
2008-09-25 Rafael Espindola <espindola@google.com>
 
* lto.c (lto_resolution_read): Initialize ret;
 
2008-09-24 Ollie Wild <aaw@google.com>
 
* lto.c (sys/mman.h): Move include.
(lto_wpa_write_files): Return a list of written files.
(lto_execute_ltrans): New function.
(lto_main): Call lto_execute_ltrans.
(ltrans-driver): New file.
* lto-lang.c (DEFAULT_LTRANS_DRIVER): New macro.
(DEAULT_LTRANS_DRIVER_LEN): New macro.
(lto_init_options): Initialize ltrans_driver.
(lto_handle_option): Fix incorrect default output value.
* lang.opt (fltrans-driver=): New option.
* Make-lang.in (LTRANS_DRIVER_INSTALL_NAME): New variable.
(lto.install-common): Add lto/ltrans-driver.
 
2008-09-24 Rafael Espindola <espindola@google.com>
 
* Make-lang.in (LTO_OBJS): Add lto/common.o.
(lto/lto.o): Depend on lto/common.h.
(lto/common.o): New.
* lang.opt (resolution): New.
* lto-lang.c (resolution_file_name): New.
(lto_handle_option): Handle OPT_resolution.
* lto-symtab.c (lto_symtab_merge_decl): Add a resolution argument.
(lto_symtab_merge_var,lto_symtab_merge_fn): Add a resolution argument.
pass it to lto_symtab_merge_decl.
* lto.c: Include common.h.
(lto_read_decls): Add resolutions and resolutions_size arguments.
Initialize data_in.globals_resolution and
data_in.globals_resolution_size.
(index_and_symbol_resolution): New.
(lto_resolution_read): New.
(lto_file_read): Add argument resolution_file.
Read resolution.
* lto.h (resolution_file_name): New.
 
2008-09-23 Rafael Espindola <espindola@google.com>
 
* common.c: Update description.
* common.h: Update description.
 
2008-09-23 Rafael Espindola <espindola@google.com>
 
* common.c: Moved from lto-plugin.
* common.h: Moved from lto-plugin.
 
2008-09-22 Doug Kwan <dougkwan@google.com>
 
* lto.c (VEC(bitmap,heap)): Declare.
(lto_materialize_function): Handle WAP mode specially.
(lto_add_inline_clones): New.
(lto_add_all_inlinees): Changle algorithm and to use bitmaps. Also
return a bitmap of inlined decls.
(lto_wpa_write_files): Handle all DECLs brought in by inlining.
(lto_main): Call reset_inline_failed to reset inlining states.
Check call-graph after WPA inlining.
* lto-lang.c (lto_init): Do not clear flag_generate_lto
unconditionally.
 
2008-09-19 Doug Kwan <dougkwan@google.com>
 
lto.c (lto_main): Remove unsued wrapper code.
lang-specs.h (@lto): Use lto1_options instead of cc1_options.
 
2008-09-19 Rafael Espindola <espindola@google.com>
 
* lto-symtab.c: Include lto-tree-in.h.
* lto-tree.h (lto_symtab_merge_var, lto_symtab_merge_fn): Remove.
* lto.h (lto_symtab_merge_var, lto_symtab_merge_fn): Remove
* Make-lang.in (lto/lto-symtab.o): Add lto-tree-in.h.
 
2008-09-17 Paolo Bonzini <bonzini@gnu.org>
Rafael Avila de Espindola <espindola@google.com>
 
* lto-lang.c (COMPOUND_LITERAL_EXPR_DECL_STMT,
COMPOUND_LITERAL_EXPR_DECL): Remove.
(emit_local_var): Remove.
(lto_expand_expr): Remove.
(lto_staticp): Remove.
(LANG_HOOKS_EXPAND_EXPR): Remove.
(LANG_HOOKS_STATICP): Remove.
 
2008-09-11 Diego Novillo <dnovillo@google.com>
 
* lto-lang.c: Include except.h and libfuncs.h.
(lto_init_eh): New.
(lto_init): Call it.
Set flag_generate_lto to 0.
* Make-lang.in (lto-lang.o): Add dependency on except.h
and libfuncs.h.
 
2008-09-09 Bill Maddox <maddox@google.com>
 
* lto-lang.c: Include header file expr.h.
(COMPOUND_LITERAL_EXPR_DECL_STMT,
COMPOUND_LITERAL_EXPR_DECL): Copied from c-common.h.
(emit_local_var): Copied from c-semantics.c.
(lto_expand_expr, lto_staticp): Copied from c_expand_expr
and c_staticp in c-common.c.
(LANG_HOOKS_EXPAND_EXPR,LANG_HOOKS_STATICP): Redefined.
 
2008-09-08 Diego Novillo <dnovillo@google.com>
 
* lto-lang.c (lto_global_bindings_p): Return 1 during
IPA passes.
 
2008-09-07 Diego Novillo <dnovillo@google.com>
 
* lto.c: Tidy formatting.
 
2008-08-04 Bill Maddox <maddox@google.com>
 
* lto-symtab.c (lto_symtab_merge_decl): Add comment.
2008-09-03 Doug Kwan <dougkwan@google.com>
 
lto.c (lto_add_all_inlinees): Reset FAILED_REASON of edges to
CIF_OK instead of NULL.
 
2008-09-02 Diego Novillo <dnovillo@google.com>
Simon Baldwin <simonb@google.com>
 
* lto-lang.c (lto_type_for_size): Rewrite. Adapt from
c_common_type_for_size.
(lto_type_for_mode): Remove ATTRIBUTE_UNUSED markers.
(lto_init): Call linemap_add.
(signed_and_unsigned_types): Remove.
 
2008-08-29 Diego Novillo <dnovillo@google.com>
 
* lto-lang.c (handle_noreturn_attribute): New local function.
(handle_const_attribute): New local function.
(handle_malloc_attribute): New local function.
(handle_pure_attribute): New local function.
(handle_novops_attribute): New local function.
(handle_nonnull_attribute): New local function.
(handle_nothrow_attribute): New local function.
(handle_sentinel_attribute): New local function.
(handle_type_generic_attribute): New local function.
(handle_format_attribute): New local function.
(handle_format_arg_attribute): New local function.
(lto_attribute_table): Declare.
(lto_format_attribute_table): Declare.
(lto_init_attributes): New local function.
(lto_define_builtins): Call it.
Call targetm.init_builtins and build_common_builtin_nodes.
(LANG_HOOKS_COMMON_ATTRIBUTE_TABLE): Define.
(LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE): Define.
 
2008-08-28 Diego Novillo <dnovillo@google.com>
 
* Make-lang.in (lto-lang.o): Replace tree-gimple.h with
$(GIMPLE_H).
(lto-symtab.o): Add dependency on $(GIMPLE_H).
* lto-lang.c: Include gimple.h instead of tree-gimple.h.
* lto-symtab.c: Include gimple.h.
* lto-tree.h (chain_next): Replace GENERIC_NEXT with
TREE_CHAIN.
 
2008-08-27 Doug Kwan <dougkwan@google.com>
 
* lto.c (vec.h, bitmap.h, pointer-set.h, ipa-prop.h, ggc.h,
gt-lto-lto.h): New includes.
(lto_materialize_function): Do not read in function body in WPA mode.
Format a line to fit in 80 columns.
(lto_cgraph_node_sets): New garbage collected variable.
(lto_1_to_1_map, lto_add_all_inlinees, lto_wpa_write_files):
New functions.
(lto_main): Initialize bitmap obstack. Add code to handle WPA mode.
* Make-lang.in (LTO_H): Replace filename lto-section-in.h with
variable LTO_SECTION_IN_H.
(lto/lto.o): Include gt-lto-lto-c.h ggc.h ,VEC_H, BITMAP_H,
pointer-set.h and IPA_PROP_H. Also replace filename lto-section-in.h
with variable LTO_SECTION_IN_H.
* config-lang.in (gtfiles): Add lto/lto.c.
* lto-symtab.c (lto_symtab_merge_decl): Set DECL_CONTEXT of
merged DECL_RESULT correctly.
 
2008-08-26 Bill Maddox <maddox@google.com>
 
* lto-lang.c Include tree-gimple.h.
(lto_mark_addressable): Call mark_addressable rather than
asserting.
(lto_post_options): Suppress debug info generation.
* Make-lang.in: Add dependency of lto-lang.o on tree-gimple.h.
2008-08-25 Bill Maddox <maddox@google.com>
 
* lto-symtab.c (lto_symtab_merge_decl): Remove a suspect
assertion and leave an explanatory comment in its place.
2008-08-21 Doug Kwan <dougkwan@google.com>
 
* lto.c (preload_common_nodes): Call lto_get_common_nodes to get a list
of common nodes instead of computing locallly.
(lto_read_in_decl_state): New.
(lto_read_decls): Change code for udpate in struct lto_decl_header.
Read global and per-function in-decl states.
* Make-lang.in (LTO_H): Update dependency.
(lto/lto.o): Same.
(lto-symtab.c): Merge (revision 139039)
* lto-symtab.c (lto_symtab_merge_decl): Merge DECL_RESULT.
 
2008-08-21 Rafael Espindola <espindola@google.com>
 
* config-lang.in (target_libs): New.
 
2008-08-20 Bill Maddox <maddox@google.com>
 
* lto.c (current_lto_file): Remove GTY marker from static
variable. Remove include of file gt-lto-lto.h.
* Make-lang.in: Remove dependency of lto/lto.o on
gt-lto-lto.h.
* lto-elf.c (lto_file_close): Removed.
(lto_elf_file_open): Use XCNEW instead of GGC_CNEW to
allocate lto_elf_file object.
(lto_elf_file_close): Free lto_elf_file object after close.
* lto.h (struct lto_file_struct): Remove GTY marker.
* config-lang.in: Remove lto/lto.h and lto/lto.c from
gtfiles.
2008-08-20 Bill Maddox <maddox@google.com>
 
* lto.c (lto_read_decls): Provide dummy argument to input_tree
to conform to its new signature.
* lto-symtab.c (lto_symtab_merge_decl): Do not invoke ggc_free
on discarded node here, now called in global_vector_fixup.
2008-08-09 Bill Maddox <maddox@google.com>
 
* lto.c (preload_common_nodes): Verify that fileptr_type_node
has not been set to a front-end-specific value.
2008-08-05 Doug Kwan <dougkwan@google.com>
* Make-lang.in (lto-symtab.o): Add missing dependencies to fix
build breakage.
 
2008-07-30 Bill Maddox <maddox@google.com>
 
* lto.c (lto_materialize_function): Call lto_original_decl_name.
Remove obsolete comments.
(lto_read_decls): Remove initialization of deleted field data_in.global.
Tidy up comments.
(lto_main): Remove redundant initialization of section_hash_table.
* lto-elf.c: Removed obsolete comments.
* lto.h: Tidy up comments.
* lto-symtab.c (lto_least_common_multiple): New function.
(lto_symtab_merge_decl): Merge variable alignments in some cases.
Tidy up comments.
 
2008-07-25 Diego Novillo <dnovillo@google.com>
Bill Maddox <maddox@google.com>
 
* lto.c: Re-order include files.
Include lto-section-out.h.
(preload_common_nodes): Add debugging output.
Add new local INDEX_TABLE.
Call preload_common_node.
* Make-lang.in (lto.o): Add dependency on lto-section-out.h
 
2008-07-13 Bill Maddox <maddox@google.com>
 
* lto.c (lto_read_decls): Cast pointer to const char * to avoid
unwanted scaling during pointer addition.
 
2008-07-11 Bill Maddox <maddox@google.com>
Diego Novillo <dnovillo@google.com>
 
* lto.c (lto_read_decls): Fix C++ compatibility warnings.
Make code const-correct.
(lto_file_read): Fix C++ compatibility warnings.
(lto_read_section_data): Fix C++ compatibility warnings.
(lto_get_section_data): Use CONST_CAST to avoid warning when
const pointer passed to free.
* lto-elf.c (lto_elf_build_section_table): Fix C++
compatibility warnings.
(lto_elf_append_data): Fix C++ compatibility warnings. Use CONST_CAST
to avoid warning assigning const pointer to d_buf field of Elf_Data.
(lto_get_current_out_file): Fix C++ compatibility warnings.
 
2008-07-11 Diego Novillo <dnovillo@google.com>
 
* Make-lang.in (lto-warn): Define.
 
2008-07-03 Simon Baldwin <simonb@google.com>
 
* lto.c (lto_read_decls): Wrapped debug-only data items within #ifdef
LTO_STREAM_DEBUGGING.
 
2008-06-27 Ollie Wild <aaw@google.com>
 
* lto-elf.c (lto-section-out.h): New include.
(struct lto_elf_file): Remove bits member. Add scn, shstrtab_stream,
and data members.
(cached_file_attrs): New static variable.
(lto_elf_get_shdr, lto_elf_free_shdr): Remove elf_file parameter.
Use cached_file_attrs for checking bits.
(lto_elf_build_section_table): Remove elf_file argument from
lto_elf_get_shdr and lto_elf_free_shdr calls.
(DEFINE_INIT_SHDR): New macro.
(init_shdr32, init_shdr64): New functions defined via the
DEFINE_INIT_SHDR macro.
(lto_elf_begin_section_with_type): New function.
(lto_elf_begin_section): New function.
(lto_elf_append_data): New function.
(lto_elf_end_section): New function.
(DEFINE_VALIDATE_EHDR): New macro.
(validate_ehdr32, validate_ehdr64): New functions defined via the
DEFINE_VALIDATE_EHDR macro.
(validate_file): New function.
(DEFINE_INIT_EHDR): New macro.
(init_ehdr32, init_ehdr64): New functions defined via the
DEFINE_INIT_EHDR macro.
(init_ehdr): New function.
(lto_elf_file_open): Add support for writable files. Move some
validation logic to validate_file.
(lto_elf_file_close): Add support for writable files. Write file data
and free data blocks.
(current_out_file): New static variable.
(lto_set_current_out_file): New function.
(lto_get_current_out_file): New function.
* lto.c (lto_main): Add writable argument to lto_elf_file_open calls.
Add temporary initialization for testing ELF serialization.
* lto.h (lto-section-out.h): New include.
(struct lto_file_struct): Slight modification to comment.
(lto_elf_file_open): Add writable parameter.
(lto_elf_begin_section): New function declaration.
(lto_elf_append_data): New function declaration.
(lto_elf_end_section): New function declaration.
(lto_set_current_out_file, lto_get_current_out_file): New function
declarations.
* lto-lang.c (LANG_HOOKS_BEGIN_SECTION): Set as lto_elf_begin_section.
(LANG_HOOKS_APPEND_DATA): Set as lto_elf_append_data.
(LANG_HOOKS_END_SECTION): Set as lto_elf_end_section.
* Make-lang.in (LTO_H): Add lto-section-out.h.
 
2008-06-12 Ollie Wild <aaw@google.com>
 
* lto.h (struct lto_file_vtable_struct): Remove.
(struct lto_file_struct): Remove vtable member.
* lto-elf.c (lto_file_init): Remove vtable argument.
(lto_elf_map_optional_lto_section): Remove.
(lto_elf_unmap_section): Remove.
(lto_elf_file_vtable): Remove.
(lto_elf_file_open): Remove lto_elf_file_vtable argument from
lto_file_init call.
(lto_elf_find_section_data): Remove.
 
2008-06-11 Ollie Wild <aaw@google.com>
 
* lto.c (lto_file_read): Add const qualifier to data variable.
 
2008-06-11 Diego Novillo <dnovillo@google.com>
 
Merge from lto-streamber sub-branch.
 
2008-06-04 Ollie Wild <aaw@google.com>
 
* lto.c: Remove inclusion of dwarf2.h and dwarf2out.h.
* Make-lang.in (lto.o): Remove dependency on dwarf2.h.
 
2008-05-28 Bill Maddox <maddox@google.com>
 
Replace the DWARF reader in the LTO front-end.
 
* lto.c: Include lto-tree-in.h, lto-tags.h.
(enum DWARF2_class, DW_cl_constant, struct
DWARF2_form_data, struct lto_context,
lto_fd_init, lto_info_fd_init,
lto_abbrev_fd_init, lto_info_fd_close,
lto_file_init, lto_file_close,
lto_file_corrupt_error, lto_abi_mismatch_error,
LTO_CHECK_INT_VAL, LTO_READ_TYPE,
lto_read_uleb128, lto_read_sleb128,
lto_read_initial_length, lto_abbrev_read_attrs,
lto_abbrev_read, lto_abbrev_read_lookup,
lto_read_section_offset,
lto_read_comp_unit_header, find_cu_for_offset,
lto_get_file_name,
lto_resolve_reference,lto_read_form,
attribute_value_as_int,
make_signed_host_wide_int,
attribute_value_as_constant, lto_cache_hash,
lto_cache_eq, lto_cache_store_DIE,
lto_cache_lookup_DIE, lto_find_integral_type,
lto_find_integral_type_1,
LTO_BEGIN_READ_ATTRS_UNCHECKED,
LTO_BEGIN_READ_ATTRS, LTO_END_READ_ATTRS,
lto_unsupported_attr_error, lto_get_identifier,
lto_read_referenced_type_DIE,
lto_read_compile_unit_DIE,
lto_read_array_type_DIE,
lto_read_structure_union_class_type_DIE,
lto_read_enumerator_DIE,
lto_read_enumeration_type_DIE,
lto_read_only_for_child_DIEs,
lto_read_only_for_child_DIEs,
lto_read_member_DIE, lto_read_abbrev,
lto_read_variable_formal_parameter_constant_DIE,
lto_get_body): Removed.
(preload_common_nodes): New function.
(lto_read_decls): Convert for new global streamer.
(lto_materialze_file_data,
lto_read_subroutine_type_subprogram_die,
lto_read_unspecified_parameters_DIE,
lto_read_typedef_DIE,
lto_read_pointer_reference_type_DIE,
lto_read_subrange_type_DIE,
lto_read_base_type_DIE,
lto_read_const_volatile_restrict_type_DIE,
lto_read_namespace_DIE,
lto_read_unspecified_type_DIE, lto_read_DIE,
lto_read_child_DIEs, lto_collect_child_DIEs):
Removed.
(lto_info_read, lto_set_cu_context): Removed.
(lto_file_read): Convert for new global streamer.
(lto_resolve_type_ref, lto_read_DIE_at_ptr,
lto_resolve_var_ref, lto_resolve_fn_ref,
lto_resolve_field_ref, lto_resolve_typedecl_ref,
lto_resolve_namespacedecl_ref): Removed.
(lto_file_init, lto_file_close): Moved to lto-elf.c.
* lto-tree.h (lto_symtab_merge_var,
lto_symtab_mergee_fun): Declare here.
* lto-elf.c (lto_file_init, lto_file_close): Moved from lto.c.
(lto_elf_file_open): Removed code to read DWARF debug sections.
* lto.h (lto_context, DWARF2_attr, DWARF2_abbrev,
DWARF2_CompUnit, lto_die_ptr,
lto_die_cache_entry, lto_fd, lto_info_fd,
lto_abbrev_fd): Removed.
(lto_file): Removed debug_info and debug_abbrev fields.
(lto_ref): Removed.
(lto_file_init, lto_file_close,
lto_resolve_type_ref, lto_resolve_var_ref,
lto_resolve_fn_ref, lto_resolve_field_ref,
lto_resolve_typedecl_ref,
lto_resolve_namespacedecl_ref,
lto_get_file_name): Removed declarations.
(lto_symtab_merge_var, lto_symtab_merge_fn):
Declarations moved to lto-tree.h.
* lto-symtab.c (lto_compatible_attributes_p):
Lobotomize this, as it barfs on "Hello, world!".
* lto-section-out.c: Include lto-tree-out.h.
(lto_hash_global_slot_node,
lto_eq_global_slot_node, preload_common_nodes,
write_global_stream, write_global_references):
New functions.
(produce_asm_for_decls): Convert for new global streamer.
* lto-section-out.h (lto_hash_global_slot_node,
lto_eq_global_slot_node): Declare.
 
2008-06-07 Kenneth Zadeck <zadeck@naturalbridge.com>
Jan Hubicka <jh@suse.cz>
* lto.c (sys/mman.h, tree-pass.h): New includes.
(lto_materialize_constructors_and_inits,
lto_materialize_function): Keeps length of section.
(lto_materialize_cgraph): Removed.
(lto_read_decls): Initialize fd field.
(lto_file_read): Different return type and removed much code to
lto_main.
(page_mask): New variable.
(lto_read_section_data, get_section_data, free_section_data): New
functions.
(lto_main): Now calls pass manager, sets the hooks so that the ipa
passes can get the section data.
2008-05-27 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto.h (lto_read_decls): Made local.
(lto_input_function_body, lto_input_constructors_and_inits,
lto_input_cgraph): Declarations moved to lto-section-in.h.
* lto-section-in.c: Moved to .. .
* lto-cgraph-in.c: Ditto.
* lto-section-in.h: Ditto.
* lto-function-in.c: Ditto.
* lto-lang.c (lto_handle_option): Added ATTRIBUTE_UNUSED to parms.
(lto_insert_block): Removed.
(LANG_HOOKS_INSERT_BLOCK): Removed.
* Make-lang.in (lto-cgraph-in.o, lto-function-in.o,
lto-section-in.o): Rules moved to lto/Makefile.in.
 
2008-05-16 Ollie Wild <aaw@google.com>
 
* lto-lang.c (tree-inline.h): Include.
(lto_post_options): New function.
(LANG_HOOKS_POST_OPTIONS): Define.
* lto-cgraph-in.c (overwrite_node): Set node->global.insns.
* lto-function-in.c (input_bb): Set TREE_BLOCK (stmt).
 
2008-05-13 Diego Novillo <dnovillo@google.com>
 
* lto-function-in.c (input_ssa_names): Call
make_ssa_name_fn instead of make_ssa_name.
 
2008-05-12 Diego Novillo <dnovillo@google.com>
 
* lto-cgraph-in.c (overwrite_node): Update references to
inline summary fields.
* lto-function-in.c (input_expr_operand): Do not handle
STRUCT_FIELD_TAG.
 
2008-05-09 Ollie Wild <aaw@google.com>
 
* lang.opt: New file.
* lto-lang.c (lto_init_options): New function.
(lto_handle_option): New function.
(lto_init): Move initialization of flag_unit_at_a_time to
lto_init_options.
(LANG_HOOKS_INIT_OPTIONS): Define.
(LANG_HOOKS_HANDLE_OPTION): Define.
 
2008-04-29 Ollie Wild <aaw@google.com>
 
* lto.c (lto_read_namespace_DIE): New function.
(lto_read_DIE): Add lto_read_namespace_DIE callback. Cache
NAMESPACE_DECL DIE's.
(lto_resolve_namespacedecl_ref): New function.
* lto.h (lto_resolve_namespacedecl_ref): New function.
* lto-section-in.c (lto_read_decls): Read namespace declarations.
* lto-section-in.h (struct lto_file_decl_data): Add namespace_decls
and num_namespace_decls.
* lto-function-in.c (input_expr_operand): Add NAMESPACE_DECL case.
* lto-lang.c (lto_init_ts): New function.
(LANG_HOOKS_INIT_TS): Set as lto_init_ts.
 
2008-04-16 Ollie Wild <aaw@google.com>
 
* lto-function-in.c (input_type_ref): Updated function description.
 
2008-04-16 Ollie Wild <aaw@google.com>
 
* lto-function-in.c (input_type_ref_1): New function.
(input_type_ref): Split into two functions.
(input_function): Add support for type contexts.
 
2008-04-16 Ollie Wild <aaw@google.com>
 
* lto.c (lto_materialize_function): Use DECL_ASSEMBLER_NAME to compute
section name
 
2008-04-16 Ollie Wild <aaw@google.com>
 
* lto.c (lto_read_compile_unit_DIE): Add DW_LANG_C_plus_plus to the
list of supported languages.
 
2008-03-25 Kenneth Zadeck <zadeck@naturalbridge.com>
 
Merge with mainline @133491.
 
2008-03-05 Kenneth Zadeck <zadeck@naturalbridge.com>
Jan Hubicka <jh@suse.cz>
 
* lto.c (lto_info_fd_init, lto_info_fd_close): Get rid of
fd->unmaterialized_fndecls.
(lto_get_file_name, lto_materialize_cgraph): New function.
(lto_materialize_constructors_and_inits,
lto_materialize_function): Read info directly from elf file.
(lto_file_read): Made local and initialize dictionary so that
other lto sections can be read without reprocessing the elf file.
(lto_main): Read all functions after all files have been processed
for their types, globals and cgraph.
* Make-lang.in (lto.o, lto-cgraph-in.c, lto-section-in): Changed
dependencies.
* lto-elf.c (lto_elf_file): Removed strtab, symtab fields.
(hash_name, eq_name, lto_elf_build_section_table): New functions.
(lto_elf_read_symtab): Removed function.
(lto_elf_file_open): Removed call to lto_elf_read_symtab.
* lto.h (lto_info_fd_struct): Removed unmaterialized_fndecls.
(lto_file_read): Made local.
(lto_get_file_name, lto_elf_build_section_table,
lto_input_cgraph):
New function.
* lto-section-in.c (lto_read_section_data, lto_get_section_data):
New functions.
(lto_read_decls): Get the file name.
* lto-cgraph-in.c: New file.
* lto-function-in.c (tag_to_expr): Stops at LTO_tree_last_tag.
(input_expr_operand, lto_read_body): Set lto_debug_context.tag_names.
(input_labels): Fixed latent sizeof issue.
(input_function): Build stmt array to set call sites into cgraph
edges.
(lto_read_body): Reset cfun->curr_properties.
* lto_section_in.h (lto_section_slot): New structure.
(section_hash_table.lto_file_decl_data): New field.
 
2008-02-09 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto.c (lto_read_variable_formal_parameter_const): Remove code to
reconstruct static initializers.
(lto_get_body, lto_materialize_function): Add lto_section_type as
a parameter.
(lto_materialize_constructors_and_inits,
lto_materialize_file_data): New function.
(lto_materialize_function,
lto_read_subroutine_type_subprogram_DIE): Renamed unmap_fn_body to
unmap_section and map_fn_body to map_section.
(lto_set_cu_context): Process functions and static inits
differently.
* Make-lang.in (LTO_H, lto/lto-function-in.o,
lto/lto-section-in.o): Update dependencies.
* lto/lto-elf.c (lto_elf_map_optional_lto_section): Add
lto_section_type parameter.
(lto_elf_unmap_fn_body): Renamed to lto_elf_unmap_section.
* lto.h (lto_file_vtable_struct): Removed two of the fields and
renamed the other two so that there is only one map function and
one unmap function and each takes a section type parameter.
(lto_read_function_body): Renamed to lto_input_function_body and
added file_data parameter.
(lto_read_var_init): Removed.
(lto_input_constructors_and_inits): New function.
* lto-section-in.c (lto_read_decls): New function.
* lto-function-in.c (data_in): Moved fields field_decls, fn_decls,
var_decls, type_decls, types to lto_file_decl_data.
(input_type_ref, input_expr_operand, lto_read_body): Get
field_decls, fn_decls, var_decls, type_decls, types from different
structure.
(input_globals, input_constructor, lto_read_var_init): Removed.
(input_constructors_or_inits): New function.
(lto_read_function_body, lto_input_constructors_and_inits):
Renamed to lto_input_function_body and takes file_data parameter.
* lto-section-in.h (lto_file_decl_data): New structure.
2008-01-28 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-function-in.c (input_globals.c): Changed input type to
lto_function_header.
(input_bb): Removed code to deserialize the stmt number.
(input_function): Renumber all stmts after they are input.
(lto_read_body, lto_read_function_body, lto_read_var_init):
Changed to used new header format and enum section_type.
*lto-lang.c (success): Removed.
2008-01-28 Nathan Froyd <froydnj@codesourcery.com>
 
* lto-elf.c (lto_elf_lookup_sym): Remove unused function.
(lto_elf_free_sym): Likewise.
 
* lto-elf.c (lto_elf_read_var_init): Remove unused function.
(lto_elf_build_init): Likewise.
 
2008-01-14 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-read.c: Renamed to lto-function-in.c.
(input_1_unsigned): Moved to lto-section-in.c and renamed
lto_input_1_unsigned.
(input_uleb128): Moved to lto-section-in.c and renamed
lto_input_uleb128.
(input_widest_uint_uleb128): Moved to lto-section-in.c and renamed
lto_input_widest_uint_uleb128.
(input_sleb128): Moved to lto-section-in.c and renamed
lto_input_sleb128.
(input_integer): Moved to lto-section-in.c and renamed
lto_input_integer.
(debug_in_fun): Moved to lto-section-in.c and renamed
lto_debug_in_fun.
(input_block): Moved to lto-section-in.h and renamed
lto_input_block.
(input_expr_operand): Fixed to allow lists with more than one
element.
* lto-section-in.h: New file.
* lto-section-in.c: New file with changes from above.
* Make-lang.in (lto-read.o): Renamed lto-function-in.c.
(lto-section-in.o): New rule.
2007-12-29 Nathan Froyd <froydnj@codesourcery.com>
 
* lto-read.c (input_expr_operand): Mark static and external
VAR_DECLs as needed.
 
2007-12-29 Nathan Froyd <froydnj@codesourcery.com>
 
* lto-read.c (input_integer): Use the correct shift amount.
 
2007-12-29 Nathan Froyd <froydnj@codesourcery.com>
 
* lto-lang.c (lto_pushdecl): Do nothing instead of aborting.
(LANG_HOOKS_NAME): Define.
 
2007-12-27 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_find_integral_type): Define as a macro. Rename the
original function to...
(lto_find_integral_type_1): ...this. Consult UNSIGNEDP if we
don't have a base type.
(lto_read_enumeration_type_DIE): Examine the values of the
enumeration to determine whether we can use an unsigned type for
the base type of the enumeration.
 
2007-12-24 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_read_structure_union_class_type_DIE): Set TYPE_MODE
and TYPE_ALIGN on UNION_TYPEs as soon as possible.
 
2007-12-22 Nathan Froyd <froydnj@codesourcery.com>
 
* lto-lang.c (lto_types_compatible_p): New function.
(LANG_HOOKS_TYPES_COMPATIBLE_P): Define.
 
2007-12-22 Nathan Froyd <froydnj@codesourcery.com>
Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-read.c (input_expr_operand): Fixed uninitialize var warning.
(input_local_vars): Read in DECL_INITIAL and context for local
statics that need to be put in unexpanded_vars_list.
 
2007-12-21 Nathan Froyd <froydnj@codesourcery.com>
 
* lto-read.c (input_real): Use a separate null-terminated buffer
for calling real_from_string.
(input_expr_operand): If we take the address of a FUNCTION_DECL,
tell cgraph that it's needed.
 
2007-12-19 Doug Kwan <dougkwan@google.com>
 
* lto.c (lto_read_base_type_DIE): Handle complex integer types.
 
2007-12-18 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_read_DIE): Call lto_read_only_for_child_DIEs instead.
(lto_file_read): Reset the members of 'context' every time we read
a toplevel DIE, with special attention to last_param_type.
 
2007-12-18 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_read_subroutine_type_subprogram_DIE): Initialize
'declaration'. Set the assembler name for non-public functions.
 
2007-12-17 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto_read.c (data_in.unexpanded_indexes): New array.
(input_local_var): Added code to read in unexpanded_var_list
indexes for variables. Only read in DECL_CHAIN field for
parameters.
(input_local_vars): Added code to rebuild unexpanded_var_list in
order using unexpanded_indexes.
(input_function): Added code to set DECL_CONTEXT for functions.
 
2007-12-13 Doug Kwan <dougkwan@google.com>
 
* lto.c (lto_read_pointer_reference_type_DIE): Handle optional name
in pointer and reference types.
 
2007-12-13 Nathan Froyd <froydnj@codesourcery.com>
 
* lto-read.c (input_expr_operand): Use DECL_RESULT when reading a
RESULT_DECL.
 
2007-12-13 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_read_array_type_DIE): Return the cached DIE if we've
already read the DIE.
(lto_get_body): New function, split out from...
(lto_materialize_function): ...here. Call it.
(lto_read_subroutine_type_subprogram_DIE): Call lto_get_body to
determine DECL_EXTERNAL.
* lto-symtab.c (lto_symtab_merge_decl): Merge the DECL_RESULTs of
FUNCTION_DECLs when necessary. Use the type of the actual
function definition if we are unable to easily merge types. Ignore
spurious DECL_MODE mismatches on VAR_DECLs. Merge DECL_MODEs when
necessary.
 
2007-12-13 Nathan Froyd <froydnj@codesourcery.com>
 
* lto-lang.c (LANG_HOOKS_REDUCE_BIT_FIELD_OPERATIONS): Define.
 
2007-12-12 Bill Maddox <maddox@google.com>
 
Revert
2007-12-07 Bill Maddox <maddox@google.com>
 
* lto.c (lto_str_fd_init): New function.
(lto_str_fd_close): New function.
(lto_file_init): Call lto_str_fd_init.
(lto_file_close): Call lto_str_fd_close.
(lto_str_read): New function. Read debug string table.
(lto_str_lookup): New function. Get string for debug
string table offset.
(lto_read_form): Recognize DW_FORM_strp.
(lto_file_read): Invoke lto_str_read.
 
* lto-elf.c (lto_elf_file_open): Read raw section data
for the .debug_str section, if present.
 
* lto.h (struct lto_str_fd_struct): New struct.
(struct lto_file_struct): Added new field DEBUG_STR
to hold the file descriptor for the debug string table.
2007-12-07 Bill Maddox <maddox@google.com>
 
* lto.c (lto_str_fd_init): New function.
(lto_str_fd_close): New function.
(lto_file_init): Call lto_str_fd_init.
(lto_file_close): Call lto_str_fd_close.
(lto_str_read): New function. Read debug string table.
(lto_str_lookup): New function. Get string for debug
string table offset.
(lto_read_form): Recognize DW_FORM_strp.
(lto_file_read): Invoke lto_str_read.
 
* lto-elf.c (lto_elf_file_open): Read raw section data
for the .debug_str section, if present.
 
* lto.h (struct lto_str_fd_struct): New struct.
(struct lto_file_struct): Added new field DEBUG_STR
to hold the file descriptor for the debug string table.
 
2007-12-07 Nathan Froyd <froydnj@codesourcery.com>
 
* lto-read.c (input_cfg): Call init_empty_tree_cfg_for_function.
Grow the basic_block_info and label_to_block_map vectors if
necessary. Read in the block chain.
 
2007-12-06 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_read_DIE): Set TYPE_ALIAS_SET where necessary.
 
2007-12-06 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_read_form): Add DW_cl_address for DW_AT_const_value.
 
2007-12-06 Nathan Froyd <froydnj@codesourcery.com>
 
* lto-read.c (input_expr_operand): Don't check for MTAGs.
(lto_read_body): Don't declare PROP_alias.
 
2007-12-06 Nathan Froyd <froydnj@codesourcery.com>
 
* lto-symtab.c (lto_symtab_merge_decl): Handle FUNCTION_DECLs without
argument type information.
 
2007-12-03 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_read_variable_formal_parameter_constant_DIE): Set
TREE_THIS_VOLATILE if the associated type is a volatile type.
(lto_materialize_function): Remove call to init_ssa_operands.
* lto-read.c (input_expr_operand): Add SSA_NAME_VAR as a referenced
variable when reading an SSA_NAME. Do the same when reading a
RESULT_DECL, a RETURN_EXPR, or an MTAG.
(input_cfg): Call init_ssa_operands.
(input_ssa_names): Set the default def of an SSA_NAME if necessary.
Move call to init_tree_ssa...
(lto_read_body): ...here. Use push_cfun and pop_cfun. Call
add_referenced_var on any variables referenced from the body of the
function. Inform the rest of the compiler we are in SSA form and
inform later passes about the current properties.
 
2007-11-30 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_materialize_function): Add FIXME.
 
2007-11-29 Nathan Froyd <froydnj@codesourcery.com>
 
* lto-lang.c (enum built_in_attribute): New enum.
(flag_no_builtin, flag_no_nonansi_builtin, flag_isoc94, flag_isoc99,
built_in_attributes): New variables.
(def_builtin_1): New function.
(lto_define_builtins): #define DEF_BUILTIN and include builtins.def.
 
2007-11-28 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_read_variable_formal_parameter_constant_DIE): Set
DECL_SOURCE_LOCATION for debugging purposes.
(lto_read_member_DIE): Set DECL_SOURCE_LOCATION. If we have read a
bitfield, use the type specified by the DIE for TREE_TYPE and defer
laying out the decl until later.
(lto_read_subroutine_type_subprogram_DIE): Compare the function's
name with DECL_ASSEMBLER_NAME. Set DECL_SOURCE_LOCATION and
TREE_ADDRESSABLE.
* lto-read.c (input_expr_operand): Set TREE_ADDRESSABLE on the
operand of an ADDR_EXPR.
* lto-lang.c (enum lto_builtin_type): New enum.
(builtin_type): New typedef.
(builtin_types, string_type_node, const_string_type_node,
wint_type_node, intmax_type_node, uintmax_type_node,
signed_size_type_node): New variables.
(def_fn_type, builtin_type_for_size, lto_define_builtins,
lto_build_c_type_nodes): New functions.
(lto_init): Initialize builtin types.
(lto_set_decl_assembler_name): Let the target machine mangle the
name if the decl is TREE_PUBLIC, otherwise uniquify it.
 
2007-11-21 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_read_variable_formal_parameter_constant_DIE): Don't
set TREE_ADDRESSABLE. Do set DECL_COMDAT. Set TREE_READONLY if
the type is a constant type. Set the assembler name and inform
the rest of the compiler about the new decl if the decl is not
public.
(lto_read_subroutine_type_subprogram_DIE): Don't check for equivalency
of DECL_ASSEMBLER_NAME when determining if we have a builtin. Don't
try to read in function bodies for functions that already have bodies.
* lto-symtab.c (lto_same_type_p): Check for unbounded array
equivalency.
(lto_symtab_merge_decl): Don't merge decls that aren't TREE_PUBLIC.
Check for whether we matched a builtin function type before calling
lto_same_type_p on the generated type. Permit cases where the
declaration of an array is unbounded, but the definition is bounded.
Don't combine TREE_PUBLIC flags. Copy over DECL_SIZE and
DECL_SIZE_UNIT if necessary.
 
2007-11-16 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-read.c (input_expr_operand): Get types right
for COMPLEX_CST.
 
2007-11-16 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-read.c (make_new_block, input_cfg): Properly set
n_basic_blocks.
2007-11-16 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_read_array_type_DIE): Handle DIEs with DW_AT_GNU_vector
set properly by building a VECTOR_TYPE instead of an ARRAY_TYPE.
 
2007-11-16 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_read_base_type_DIE): Use make_bitfield_integer_type to
construct the integer type for bitfields.
 
2007-11-16 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-read.c (data_in.current_node_has_loc): Removed.
(input_line_info): Returns true if node needs line set.
(set_line_info): Always sets line if called.
(clear_line_info): Removed reference to current_node_needs_loc.
(input_expr_operand): Keeps track locally if current node needs a loc.
(input_local_var): Added code to handle DECL_INITIAL for
static local vars. Only set loc if necessary.
2007-11-15 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_read_subroutine_type_subprogram_DIE): Fix thinko'd
DECL_CONTEXT.
 
2007-11-15 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c: Include langhooks.h.
(lto_find_integral_type): Rework logic to handle the case where
got_byte_size is true, but the bitsize requested and that of the
base_type doesn't match.
(lto_read_variable_formal_parameter_constant_DIE): Only check for
asm_name if we are creating a VAR_DECL.
(lto_materialize_function): Set DECL_EXTERNAL if we can't find a
definition.
(lto_read_subroutine_type_subprogram_DIE): Check for a builtin
function reference and use the builtin's decl if so. Set the
DECL_CONTEXT of the RESULT_DECL for the function.
* lto-lang.c (registered_builtin_fndecls): New variable.
(lto_getdecls): Return it.
(lto_builtin_function): Chain the new decl onto
registered_builtin_fndecls.
 
2007-11-15 Kenneth Zadeck <zadeck@naturalbridge.com>
* lto-read.c (process_tree_flags, lto_static_init_local):
Renamed to ADD_CLASS_EXPR_FLAG. ADD_CLASS_DECL_FLAG New Macro.
(input_line_info, clear_line_info): Fixed new line number code.
(input_expr_operand): Added type to SWITCH_EXPR.
(lto_read_body): Properly initialized data_in.
Clear line info when leaving.
2007-11-13 Diego Novillo <dnovillo@google.com>
 
* lto.c (lto_read_variable_formal_parameter_constant_DIE):
Initialize ARTIFICIAL.
(lto_read_subroutine_type_subprogram_DIE): Initialize
SAVED_SCOPE.
* lto-read.c (set_line_info): Remove ; from calls to
LINEMAP_POSITION_FOR_COLUMN.
 
2007-11-13 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-read.c (input_type_ref): Renamed from get_type_ref.
(input_expr_operand, input_local_var): Renamed get_type_ref to
input_type_ref.
(input_expr_operand): Get the types correct for
vector-cst. Get SSA_NAME_DEF_STMT correct for return_exprs.
2007-11-13 Doug Kwan <dougkwan@google.com>
 
* lto-read.c (input_widest_uint_uleb128): New function.
(input_tree_flags, process_tree_flags, input_line_info,
input_expr_operand, input_local_var, input_phi, input_ssa_names):
Change to use lto_flags_type and BITS_PER_LTO_FLAGS_TYPES instead of
unsigned HOST_WIDE_INT and HOST_BITS_PER_WIDE_INT.
(lto_static_init_local): Add code to assert that lto_flags_type is
wide enough.
 
2007-11-13 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_read_array_type_DIE): Handle DW_AT_GNU_vector.
(lto_read_subroutine_type_subprogram_DIE): Handle
DW_AT_static_link and DW_AT_specification. Return the
specification if present.
(lto_read_base_type_DIE): Handle DW_ATE_complex_float.
2007-11-13 Nathan Froyd <froydnj@codesourcery.com>
 
* lto-lang.c: Include target.h.
(registered_builtin_types): New variable.
(lto_type_for_mode): Increase number of modes handled.
(lto_builtin_function): Fix argument list and return the decl.
(lto_register_builtin_type): New function.
(lto_init): Initialize target builtins and language-independent
nodes.
(LANG_HOOKS_REGISTER_BUILTIN_TYPE): Define.
 
2007-11-13 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-read.c (input_expr_operand): Added code to properly handle
index filed. Added new RANGE_EXPR case.
2007-11-11 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-read.c (ADD_FUNC_FLAG): Deleted macro.
(data_in): Added current_node_has_loc field.
(input_line_info, set_line_info, clear_line_info): Added a support
for USE_MAPPED_LOCATION and not adding line numbers to nodes that
did not have on on the source side.
(input_expr_operand): Make sure that GIMPLE_MODIFY_STMTS get line
numbers too.
 
2007-11-09 Doug Kwan <dougkwan@google.com>
 
* lto-read.c (input_expr_operand): Change type of operand 2 of
BIT_FIELD_REF expression to be bitsizetype instead of sizetype.
 
2007-11-09 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c: Include lto-tree.h. Effect small spaces->tabs cleanup.
(lto_read_variable_formal_parameter_constant_DIE): Transfer bits
from a DW_AT_specification or DW_AT_abstract_origin attribute to
the new decl we are creating. Move informing the middle end about
the new decl to...
(lto_main): ...here. Inform the middle end about global variables
after we have read in all the input files.
* lto-symtab.c (lto_symtab_merge_decl): We really do need to merge
variables with internal linkage, so delete the check for internal
linkage. Combine TREE_PUBLIC flags.
 
2007-11-08 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_read_subroutine_type_subprogram_DIE): Handle
DW_AT_decl_line.
* lto-symtab.c (lto_symtab_merge_decl): Handle redefinition of a
builtin specially. Move check for attribute compatibility
earlier.
 
2007-11-07 Nathan Froyd <froydnj@codesourcery.com>
 
* Make-lang.in (lto/lto.o): Depend on gt-lto-lto.h.
* config-lang.in (gtfiles): Add lto.h and lto.c.
* lto-elf.c: Include ggc.h.
(lto_elf_file_open): Allocate elf_file from GC memory.
* lto.c: Include tree-ssa-operands.h and gt-lto-lto.h
(lto_info_fd_init): Allocate the die_cache and unmaterialized_fndecls
in GC memory.
(lto_info_fd_close): Free unmaterialized_fndecls from GC memory.
(lto_file_close): Free file from GC memory.
(lto_cache_store_DIE): Allocate the new entry in GC memory.
(lto_read_member_DIE): Fix declaration.
(lto_read_subroutine_type_subprogram_DIE): unmaterialized_fndecls lives
in GC memory.
(current_lto_file): New variable.
(lto_main): Use it.
(DWARF2_attr, DWARF2_abbrev, lto_die_ptr, DWARF2_CompUnit,
lto_die_cache_entry): Move to...
* lto.h: ...here and add GTY markers as appropriate. Delete forward
declarations accordingly.
(struct lto_file_struct): Declare.
(lto_file_vtable): Use it instead of lto_file.
 
2007-11-06 Alon Dayan <alond@il.ibm.com>
Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-read.c (process_flags, lto_static_init_local):
read flags of VAR_DECL and FUNCTION_DECL of size>1.
change global array num_flags_for_code to flags_length_for_code.
(set_line_info): Make decls work in USE_MAPPED_LOCATION mode.
2007-11-05 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_read_structure_union_class_type_DIE): Use proper record
layout functions to compute information about the newly constructed
type.
 
2007-11-02 Nathan Froyd <froydnj@codesourcery.com>
 
* lto-read.c (input_expr_operand): Change the LTO_return_expr1
case to use DECL_RESULT if necessary.
 
2007-11-01 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-read.c (input_tree_list): Removed.
(input_tree_flags): Added parameter to force flags no matter what
tree code.
(input_expr_operand): Added parameter to input_tree_flags.
Added case for IDENTIFIER_NODE and TREE_LIST. Changed ASM to call
input_expr_operand rather than input_tree_lists.
(input_local_var): Use input_expr_operand to read attributes
rather then input_tree_list.
(input_phi, input_ssa_names): Added parameter to input_tree_flags.
 
2007-10-31 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_read_typedef_DIE): Fix comment typo.
(lto_resolve_typedecl_ref): Fetch the referred-to type and build a fake
TYPE_DECL for it.
* lto-read.c (lto_read_body): Use correct sizes for calculating
type_decls_offset and types_offset.
 
2007-10-30 Nathan Froyd <froydnj@codesourcery.com>
 
* lto-tree.h (union lang_tree_node): Change GTY description to chain
with GENERIC_NEXT.
* config-lang.in (gtfiles): Add lto-lang.c.
* lto-lang.c: Include gt-lto-lto-lang.h.
* Make-lang.in (lto/lto-lang.o): Add dependency on gt-lto-lto-lang.h
(lto/lto-symtab.o): Depend on LTO_H instead of TREE_H.
(lto/lto-read.o): Likewise.
 
2007-10-29 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-read.c (data_in): Added type_decls and current_col fields.
(string_slot): New type to hold canonized file name.
(hash_string_slot_node, eq_string_slot_node, canon_file_name,
input_line_info, set_line_info, clear_line_info): New functions.
(file_name_hash_table): New hash table.
(input_local_var, input_labels, input_local_vars_index,
input_local_var, input_local_vars, input_ssa_names): Reorganized parameters.
(input_uleb128): Changed type of byte var.
(input_expr_operand): Large number of changes to get line numbers
correct. Added TYPE_DECL case.
(input_globals): Added code to get TYPE_DECLs processed.
(input_local_var): Added code to process line numbers and
TREE_CHAIN and DECL_CONTEXT.
(input_function, input_constructor): Added call to
clear_line_number.
(lto_static_init_local): Added code to get line numbers correct.
(lto_read_body): Added code to get TYPE_DECLS read and to change
parameters to the calls above that had their parms reorganized.
 
2007-10-29 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.h (lto_resolve_typedecl_ref): Declare.
* lto.c (lto_resolve_typedecl_ref): New function.
 
2007-10-29 Mark Mitchell <mark@codesourcery.com>
Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_read_subroutine_type_subprogram_DIE): Read the child
DIEs even if we find an abstract origin for this DIE.
 
2007-10-29 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_read_subroutine_type_subprogram_DIE): Build the
RESULT_DECL slightly earlier. Only remember the decl for later
if we successfully merge declarations.
 
2007-10-24 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-read.c (input_expr_operand): Give label_values the proper
context and provide switch statements with a default type.
2007-10-23 Nathan Froyd <froydnj@codesourcery.com>
 
* lto-read.c (lto_read_body): Move call to init_ssa_operands...
* lto.c (lto_materialize_function): ...to here.
 
2007-10-22 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.h (struct lto_info_fd): Add field unmaterialized_fndecls.
* lto.c (lto_info_fd_init): Initialize it.
(lto_info_fd_close): Free it.
(lto_materialize_function): New function.
(lto_read_subroutine_type_subprogram_DIE): Save the result decl on
unmaterialized_fndecls.
(lto_file_read): Read in all the function bodies after we have read
all of the DWARF info.
* lto-read.c (lto_read_body): Call init_ssa_operands if we are
reading a function body.
 
2007-10-20 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-read.c (input_tree_flags): Renamed from input_flags to be
semetric with output_tree_flags. Added call to log flags.
(process_tree_flags): Renamed from process_flags. Fixed a lot of
type issues to make everything consistent with flags being
unsigned HOST_WIDE_INTS.
(input_expr_operand): Added call to
recompute_tree_invariant_for_addr_expr.
(input_local_var): Added debugging for tree_chains. Now calls
input_tree_flags.
(input_phi): Made flags unsigned HOST_WIDE_INT.
(input_ssa_names): Now calls input_tree_flags.
(lto_read_body): Now sets cfun.
(lto_read_function_body): Now sets current_function_pointer.
2007-10-19 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_read_variable_formal_parameter_constant_DIE): Check
definitively whether SPECIFICATION or ABSTRACT_ORIGIN exist before
inspecting fields within.
(lto_read_DIE_at_ptr): Delete check for null result; let callers
handle this appropriately.
 
2007-10-19 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_read_variable_formal_parameter_constant_DIE): Handle
DW_AT_abstract_origin properly. Ensure that we're not dealing with
both DW_AT_abstract_origin and DW_AT_specification.
(lto_read_subroutine_type_subprogram_DIE): Handle
DW_AT_abstract_origin.
(lto_read_DIE): Use lto_read_only_for_child_DIEs for labels.
(lto_read_DIE_at_ptr): Define as static to match declaration.
Lookup the PTR in the cache before reading it from the file.
(lto_resolve_var_ref): Adjust accordingly.
(lto_resolve_fn_ref): Adjust accordingly. Tweak comment.
(lto_resolve_field_ref): Adjust accordingly. Tweak comment.
 
2007-10-19 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_read_DIE_at_ptr): New function.
(lto_resolve_var_ref): Use it.
(lto_resolve_fn_ref): Use it.
(lto_resolve_field_ref): Use it.
(lto_read_variable_formal_parameter_constant_DIE): Follow
DW_AT_specification and return the associated decl when appropriate.
 
2007-10-18 Nathan Froyd <froydnj@codesourcery.com>
 
* lto-lang.c (lto_type_for_mode): Move after lto_type_for_size.
Implement for scalar integer modes.
(lto_init): Initialize size_type_node.
 
2007-10-18 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-read.c (input_expr_operand): Remove ssa name asserts.
(input_local_var): Add chaining for params.
(input_ssa_names): Add cfun parameter.
(input_function): Remove unnecessary else.
 
2007-10-17 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_read_only_for_child_DIEs): Mark die parameter as unused.
(lto_resolve_var_ref): Use proper types.
(lto_resolve_fn_ref): Likewise.
(lto_resolve_field_ref): Likewise.
 
2007-10-17 Nathan Froyd <froydnj@codesourcery.com>
 
* lto-read.c (input_expr_operand): Remove case.
 
2007-10-17 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_read_only_for_child_DIEs): New function.
(lto_read_DIE): Use it for lexical_block and inlined_subroutine DIEs.
* lto-elf.c (lto_elf_map_lto_section): Remove.
(lto_elf_file_vtable): Use lto_elf_map_optional_lto_section instead.
* lto-read.c (input_expr_operand): Assert that we never read a NULL
SSA_NAME. Add missing case for mechanical codes.
(input_cfg): Use basic_block_info_for_function instead of
basic_block_info.
 
2007-10-16 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-read.c (input_sleb128, input_integer): Use proper casts.
(input_list): Renamed input_tree_list and modified to follow same
protocol as lto-function-out.c:output_tree_list.
(input_expr_operand): Make asm operands use input_tree_list.
(input_local_var): Now uses input_tree_list.
(lto_read_body): Change placement for setting context of debug_labels.
2007-10-16 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-read.c (input_real): Output debugging in proper order.
(input_integer): Compute bit lengths properly.
(input_list): Clean up declaration.
(input_expr_operand): Change calls to input_real to match fix.
Make reading of LTO_bit_field_ref1 match output.
(input_local_var): Make reading of attributes match what is being
written.
(dump_debug_stream): Also print char in hex.
(debug_out_fun): Fix signed unsigned mismatch.
2007-10-10 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c (lto_read_form): Handle DW_AT_MIPS_linkage_name and
DW_AT_GNU_vector specially, as they are not contiguous with the
specified set of attribute names. Use class_mask to check for
errors at the end of the function
(lto_resolve_var_ref): Read the DIE if it is not cached.
(lto_resolve_fn_ref): Likewise.
(lto_resolve_field_ref): Likewise.
 
2007-10-05 Nathan Froyd <froydnj@codesourcery.com>
 
* lto.c: Include dwarf2out.h.
(lto_cache_store_DIE): Assert that we never change the value.
(LTO_BEGIN_READ_ATTRS): Print an informative error message.
(lto_read_compile_unit_DIE): Handle DW_AT_entry_pc.
(lto_read_array_type_DIE): Don't error on ndims == 0; build a
sensible type instead.
(lto_read_structure_union_class_type_DIE): Store the newly
created type prior to reading the members of the structure to
avoid infinite recursion. Avoid computing types and alignments
for structures whose sizes are unknown.
(lto_read_variable_formal_parameter_const): Handle DW_AT_artificial
and set DECL_ARTIFICIAL accordingly. Ignore DW_AT_abstract_origin,
DW_AT_const_value, and DW_AT_specification.
(lto_read_subroutine_type_subprogram_DIE): Handle DW_AT_declaration.
Return early if we have already constructed the function type.
(lto_read_typedef_DIE): Check to see if the type has been cached
already. Cache the type before reading any children.
(lto_read_const_volatile_restrict_type_DIE): Handle DW_AT_name.
(lto_read_DIE): Unset context->skip_non_parameters around reading
the DIE.
(lto_resolve_fn_ref): Delete trailing whitespace.
 
2007-09-11 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-read.c (input_expr_operand): Added type for STRING_CST.
2007-09-10 Nathan Froyd <froydnj@codesourcery.com>
 
* lto-read.c (lto_read): Set the type of the newly created CALL_EXPR.
 
2007-09-07 Nathan Froyd <froydnj@codesourcery.com>
 
* lto-lang.c (signed_and_unsigned_types): New variable.
(lto_type_for_size): Consult signed_and_unsigned_types to find
an approprite type, creating it if necessary.
(lto_set_decl_assembler_name): Add actual method body.
 
2007-09-06 Jim Blandy <jimb@codesourcery.com>
 
* lto.c (lto_read_variable_formal_parameter_constant_DIE): If we
can't find a var init for this variable, leave its DECL_INITIAL.
* lto-elf.c (lto_elf_map_optional_lto_section): Renamed from
lto_elf_map_fn_body.
(lto_map_lto_section): New function.
(lto_elf_file_vtable): Use lto_elf_map_lto_section for function
bodies, and lto_elf_map_optional_lto_section for variable
initializers.
(lto_elf_find_section_data): Quietly return NULL if the section is
missing.
(lto_elf_file_open): Check for a NULL from lto_elf_find_section_data.
 
* lto-elf.c (lto_elf_find_section_data): Remove dead code.
 
* lto-read.c (lto_read_body): Doc fix.
 
2007-08-29 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-read.c (fun_in): Renamed to data_in.
(input_expr_operand, input_local_var, input_string_internal,
input_string, input_real, input_list, get_label_decl,
get_type_ref, input_expr_operand, input_globals, input_labels,
input_local_vars_index, input_local_var, input_local_vars,
input_cfg, input_phi, input_ssa_names, input_bb, ): Renamed fun_in to data_in.
(input_constructor): New function.
(lto_read_function_body): Renamed to lto_read_body and generalized
to handle both functions and constructors.
(lto_read_function_body, lto_read_var_init): New function.
2007-08-28 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-read.c (input_expr_operand): Assert that there really is a
FUNCTION_DECL.
(input_globals): Removed checks on 0 section.
2007-08-28 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-read.c (fun_in): Added local_decls_index and
local_decls_index_d.
(input_expr_operand): Changed inputting of PARM_DECLs and VAR_DECLs.
(input_globals): Enabled code to handle FIELD_DECLs.
(input_local_vars_index, input_local_vars): New function.
(input_local_var): Changed to allow locals to be input randomly.
(lto_read_function_body): Added code to input the
local_decls_index and to free various structures.
2007-08-17 Jim Blandy <jimb@codesourcery.com>
 
* lto.c (lto_read_variable_formal_parameter_constant_DIE): Remove
ATTRIBUTE_UNUSED from 'die' formal.
 
Use enum LTO_tags where appropriate, instead of 'unsigned int'.
* lto-read.c (input_record_start): Fix return type, type of 'tag'.
(input_list): Fix type of 'tag'.
(input_expr_operand): Fix type of 'tag' argument. Update
declaration. Fix type of 'ctag'. Add default case to switch,
since the type of the switched value is now an enum.
(input_local_vars): Fix type of 'tag'.
(input_bb): Fix type of 'tag' argument.
(input_function): Fix type of 'tag' argument.
 
2007-08-16 Jim Blandy <jimb@codesourcery.com>
 
* lto.c (lto_read_member_DIE): Record the tree we create in
fd->die_cache. (Our 'die' argument is no longer unused.)
(lto_resolve_field_ref): New function.
* lto.h (lto_resolve_field_ref): New declaration.
 
2007-08-15 Jim Blandy <jimb@codesourcery.com>
 
* lto-read.c (lto_read_var_init): Mark arguments as unused.
 
2007-08-07 Jim Blandy <jimb@codesourcery.com>
 
* lto.c (lto_read_form): Complete attr_classes table.
(DWARF2_form_data): Doc fix.
2007-08-05 Mark Mitchell <mark@codesourcery.com>
 
* lto.h (lto_file_vtable): Remove read_var_init. Add map_var_init
and unmap_var_init.
(lto_read_var_init): Declare.
* lto.c (lto_read_variable_formal_parameter_constant_DIE): Use new
interface for reading variable initializers.
* lto-elf.c (lto_elf_read_var_init): Remove.
(lto_elf_file_vtable): Update initializer.
(lto_elf_read_var_init): Add comment about unused-ness.
* lto-read.c (lto_read_var_init): New.
 
* lto.c (lto_read_form): Add entry for DW_AT_inline.
 
2007-08-02 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-read.c (lto_read_function_body): Moved declaration of fn
outside of ifdef.
2007-08-01 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-read.c (input_uleb128, input_string_internal, input_real,
input_integer, input_record_start, input_list, get_type_ref,
input_flags, input_expr_operand, input_expr_operand,
input_expr_operand, input_local_vars, input_cfg, input_phi,
input_ssa_names, input_bb, input_function): Added semicolons.
 
2007-07-31 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-read.c (input_globals): Remove debugging.
(input_function): Set DECL_ARGUMENTS.
 
2007-07-31 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-read.c (input_expr_operand): Fixed code for COND_EXEC,
RETURN_EXPR, MODIFY_EXPR and processing of flags.
(input_phi): Made work with operands other than SSA_NAMES and
fixed processing of flags.
(input_ssa_names): Initialize SSA_NAME_DEF_STMT to empty stmt.
(input_flags): New function.
* lto-lang.c (lto_init): Changed state of in_lto_p.
2007-07-24 Mark Mitchell <mark@codesourcery.com>
 
* lto-tree.h (lto_varargs_cookie): Remove.
* lto.c (lto_context): Add last_parm_type, varargs_p, skip_all,
skip_non_parameters, skip_parameters.
(lto_varargs_cookie): Remove.
(lto_read_variable_formal_parameter_constant_DIE): Keep track of
parameter types.
(lto_read_abbrev): New function.
(lto_read_subroutine_type_subprogram_DIE): Make two passes over
child DIEs.
(lto_read_unspecified_parameters_DIE): Set context->varargs_p.
(lto_read_DIE): Use lto_read_abbrev. Honor skip_* flags.
(lto_file_read): Initialize new context fields.
* lto-lang.c (lto_type_for_mode): Return NULL_TREE.
(lto_unsigned_type): Remove.
(lto_signed_type): Likewise.
(lto_signed_or_unsigned_type): Likewise.
(lto_init): Do not create lto_varargs_cookie.
(LANG_HOOKS_UNSIGNED_TYPE): Do not define.
(LANG_HOOKS_SIGNED_TYPE): Likewise.
(LANG_HOOKS_SIGNED_OR_UNSIGNED_TYPE): Likewise.
 
2007-07-19 Jan Hubicka <jh@suse.cz>
 
* lto-read.c (lto_read_function_body): Produce empty scope block
to avoid crash.
 
2007-07-18 Mark Mitchell <mark@codesourcery.com>
 
* lto.c (lto_read_variable_formal_parameter_constant_DIE): Do not
process local variables.
(lto_read_subroutine_type_subprogram_DIE): Read child DIEs.
 
2007-07-13 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-read.c (input_list, input_expr_operand): Added struct
function parameter.
(init_cfg, finalize_cfg): Removed function.
(input_expr_operand): Added SSA_NAME and GIMPLE_MODIFY_STMT cases.
(input_labels, input_local_vars): Now takes input_block parameter rather than
synthsyzing it.
(input_cfg, input_phi, input_ssa_names): New functions.
(input_bb): Now passes in input_blocks. Does not construct cfg
and processes the list of phi functions.
(input_function): Now builds both the cfg and ssa_names table.
(lto_read_function_body): Processes new header fields to construct
streams for the ssa_names and cfg and their debugging.
* lto/lto-lang.c (lto_init): Set in_lto_p.
2007-06-28 Mark Mitchell <mark@codesourcery.com>
 
* lto.h (lto_file_vtable): Add read_var_init.
* lto.c (lto_read_variable_formal_parameter_constant_DIE): Read
initializers.
(lto_main): Remove bogus asserts.
* lto-elf.c (tm.h): Include it.
(libiberty.y): Likewise.
(lto_elf_file): Add strtab and symtab. Rename
string_table_section_index to sec_strtab.
(lto_elf_file_vtable): Add lto_elf_read_var_init.
(lto_elf_get_shdr): New function.
(lto_elf_free_shdr): Likewise.
(lto_elf_find_section_data): Use them.
(lto_elf_read_symtab): New function.
(lto_elf_lookup_sym): Likewise.
(lto_elf_free_sym): Likewise.
(lto_elf_file_open): Tidy. Call lto_elf_read_symtab.
(lto_elf_built_init): New function.
(lto_elf_read_var_init): Likewise.
* Make-lang.in (lto/lto-elf.o): Depend on $(TM_H).
 
2007-06-26 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto-read (make_new_block): Initialize the stmt_list.
(lto_static_init_local): Add debugging for missing codes.
2007-06-26 Mark Mitchell <mark@codesourcery.com>
 
* lto.c (lto_read_subroutine_type_subprogram_DIE): Handle
unprototyped functions.
 
2007-06-23 Mark Mitchell <mark@codesourcery.com>
 
* lto.c (lto_read_variable_formal_parameter_constant_DIE):
Handle DW_AT_MIPS_linkage_name.
(lto_read_subroutine_type_subprogram): Likewise. Correct
compilation errors.
(lto_main): Remove incorrect assertions.
* lto-symbtab.c: Build function types out of TREE_LISTs.
 
* lto-elf.c (<libelf>): Check for HAVE_LIBELF_H.
* Make-lang.in (LTO_OBJS): Depend on attribs.o.
2007-06-21 Kenneth Zadeck <zadeck@naturalbridge.com>
 
* lto/lto-tree.h (lang_decl, lang_type, language_function): Added
dummy since ggc does not like empty structs.
* lto/lto-elf.c (libelf.h): Changed to libelf/libelf.h.
* lto/lto-read.c (ADD_CLASS_FLAG, ADD_EXPR_FLAG): Changed
expr->common to expr->base.
(make_new_block): Moved stmt_list to proper place.
 
 
2007-03-14 Robert Kennedy <jimbob@google.com>
 
Eliminate use of lang_hooks.set_decl_assembler_name from LTO
* lto.c (lto_read_subroutine_type_subprogram_DIE) Get DECL
assembler name from DWARF.
* lto-lang.c (lto_set_decl_assembler_name) New function.
 
2006-09-10 Mark Mitchell <mark@codesourcery.com>
 
* lto.h (lto_file_vtable): New structure.
(lto_file): Add vtable pointer.
(lto_file_init): Add vtable paramter.
(lto_read_function_body): New function.
(lto_symtab_merge_fn): New function.
* lto.c (lto_file_init): Add vtable parameter.
(lto_read_form): Fill in entries for DW_AT_prototyped,
DW_AT_frame_base.
(lto_read_subroutine_type_subprogram_DIE): New function.
(lto_read_DIE): Fill in entries for DW_TAG_subroutine_type and
DW_TAG_subprogram.
* lto-elf.c (lto_elf_vile_vtable): New variable.
(lto_elf_file_open): Pass it to lto_file_init.
(lto_elf_map_fn_body): New function.
(lto_elf_unmap_fn_body): Likewise.
* lto-read.c: New file.
* lto-symtab.c (lto_symtab_merge_fn): New function.
* lto-lang.c (LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION): Define to
tree_rest_of_compilation.
* Make-lang.in (LTO_OBJS): Add lto-read.o
(lto-read.o): New target.
 
2006-09-03 Mark Mitchell <mark@codesourcery.com>
 
* lto.c (<inttypes.h>): Don't include it.
(lto_context): Don't typedef it.
(lto_resolve_reference): New function.
(lto_read_form): Use it.
(lto_resolve_type_ref): New function.
(lto_resolve_var_ref): Likewise.
(lto_resolve_fn_ref): Likewise.
* lto.h (<inttypes.h>): Include it.
(lto_context): New type.
(lto_ref): New structure.
(lto_resolve_type_ref): Declare.
(lto_resolve_var_ref): Likewise.
(lto_resolve_fn_ref): Likewise.
 
2006-08-18 Mark Mitchell <mark@codesourcery.com>
 
* lang-specs.h: New file.
 
2006-08-14 Mark Mitchell <mark@codesourcery.com>
 
* lto.c (lto_info_fd_init): Allocate the DIE cache.
(lto_info_fd_close): Deallocate it.
(lto_die_cache_entry): New structure.
(lto_cache_hash): New function.
(lto_cache_eq): Likewise.
(lto_cache_store_DIE): Likewise.
(lto_cache_lookup_DIE): Likewise.
(lto_read_referenced_type_DIE): Use the cache.
(lto_read_pointer_type_DIE): Robustify.
(lto_read_DIE): Use the cache.
* lto.h (hashtab.h): Include.
(lto_info_fd): Add DIE cache.
* Make-lang.in (LTO_H): New variable.
(lto/lto-lang.o): Use LTO_H.
(lto/lto-elf.o): Likewise.
(lto/lto-symtab.o): Likewise.
 
2006-07-09 Mark Mitchell <mark@codesourcery.com>
 
* lto.c (lto_abi_mismatch_error): New function.
(lto_abbrev_read): Initialize num_abbrevs.
(lto_read_form): Specify allowed form classes for
DW_AT_declaration. Adjust for change to lto_set_cu_context.
(lto_read_variable_formal_parameter_constant_DIE): Handle
DW_AT_declaration. Call lto_symtab_merge_var.
(lto_read_pointer_type_DIE): New function.
(lto_read_base_type_DIE): Use build_nonstandard_integer_type. Do
not creat TYPE_DECLs for types that already have them.
(lto_read_DIE): Add lto_read_pointer_type_DIE.
(lto_set_cu_context): Make cu_start point to the header, not the
first DIE.
(lto_file_read): Adjust for change to lto_set_cu_context.
* Make-lang.in (LTO_OBJS): Add lto-symtab.o.
(lto/lto-symtab.o): New rule.
* lto-tree.h (lang_identifier): Add decl field.
(LANG_IDENTIFIER_CAST): New macro.
(LTO_IDENTIFIER_DECL): Likewise.
(lto_symtab_merge_var): Declare.
* lto-symtab.c: New file.
 
2006-07-02 Daniel Berlin <dberlin@dberlin.org>
 
* lto.c (lto_context): Add current_cu and info_fd members.
(DWARF2_CompUnit): New structure.
(lto_read_DIE): Take lto_info_fd *.
(lto_read_child_DIEs): Ditto.
(lto_file_corrupt_error): Constify argument.
(lto_set_cu_context): New function
(lto_info_fd_init): Ditto.
(lto_info_fd_close): Ditto.
(lto_file_init): Use lto_info_fd_init.
(lto_file_close): Use lto_info_fd_close.
(lto_read_initial_length): Pass in pointer to header size.
(lto_read_comp_unit_header): Correct cu_length to
real length from beginning of header. Take lto_info_fd * as
argument.
(find_cu_for_offset): New function.
(lto_read_form): Change first argument to lto_info_fd *.
Add FORM_CONTEXT argument.
Handle DW_FORM_ref_addr.
(lto_read_tag_DIE): Change first argument to lto_info_fd *.
(LTO_BEGIN_READ_ATTRS_UNCHECKED): Save old context.
Swap contexts if necessary for form.
(LTO_BEGIN_READ_ATTRS): Cast fd to right type for
lto_file_corrupt_error.
(LTO_END_READ_ATTRS): Swap contexts back if it had changed.
(lto_read_referenced_type_DIE): Change first argument to
lto_info_fd *. Access lto_fd fields through base pointer.
(lto_read_compile_unit_DIE): Change first argument to an
lto_info_fd *.
(lto_read_variable_formal_parameter_constant_DIE): Ditto.
(lto_read_base_type_DIE): Ditto.
(lto_read_child_DIEs): Ditto.
(lto_read_DIE): Ditto. Change type of function pointer.
(lto_info_read): New function.
(lto_set_cu_context): Ditto.
(lto_file_read): Use lto_info_read, walk resulting CU's
(lto_main): Update for lto_info_fd change.
* lto-elf.c (lto_elf_file_open): Cast lto_info_fd to lto_fd where
necessary.
* lto.h (DWARF2_CompUnit): New structure.
(lto_info_fd): Ditto.
(lto_file): Change debug_info to be an lto_info_fd.
2006-06-25 Mark Mitchell <mark@codesourcery.com>
 
* lto.c (toplev.h): Include it.
(dwarf2.h): Likewise.
(tree.h): Likewise.
(tm.h): Likewise.
(cgraph.h): Likewise.
(ggc.h): Likewise.
(inttypes.h): Likewise.
(DWARF2_attr): New type.
(DWARF2_abbrev): Likewise.
(DWARF2_class): Likewise.
(DWARF2_form_data): Likewise.
(lto_context): Likewise.
(lto_fd_init): New function.
(lto_abbrev_fd_init): Likewise.
(lto_abbrev_fd_close): Likewise.
(lto_file_init): Use them.
(lto_file_close): New function.
(lto_file_corrupt_error): Likewise.
(LTO_CHECK_INT_VAL): New macro.
(lto_check_size_t_val): New function.
(lto_check_int_val): Likewise.
(LTO_READ_TYPE): New macro.
(lto_read_ubyte): New function.
(lto_read_uhalf): Likewise.
(lto_read_uword): Likewise.
(lto_read_uleb128): Likewise.
(lto_read_initial_length): Likewise.
(lto_abbrev_read_attrs): Likewise.
(lto_abbrev_read): Likewise.
(lto_abbrev_lookup): Likewise.
(lto_read_section_offset): Likewise.
(lto_read_comp_unit_header): Likewise.
(lto_read_form): Likewise.
(LTO_BEGIN_READ_ATTRS_UNCHECKED): New macro.
(LTO_BEGIN_READ_ATTRS): Likewise.
(LTO_END_READ_ATTRS): Likewise.
(lto_unsupported_attr_error): New function.
(lto_get_identifier): Likewise.
(lto_read_referenced_type_DIE): Likewise.
(lto_read_compile_unit_DIE): Likewise.
(lto_read_variable_formal_parameter_constant_DIE): Likewise.
(lto_read_base_type_DIE): Likewise.
(lto_read_DIE): Likewise.
(lto_read_child_DIEs): Likewise.
(lto_file_read): Read DIEs.
(lto_main): Ask middle end to emit entities.
* lto-tree.h (lang_identifier): Inherit from tree_identifier.
* lto-elf.c (lto_elf_file_open): Adjust for interface changes.
(lto_elf_file_close): Likewise.
* lto.h (lto_file): Declare.
(DWARF2_abbrev): Likewise.
(lto_fd): New type.
(lto_abbrev_fd): Likewise.
(lto_file): Use new types.
(lto_file_close): Declare.
* lto-lang.c (lto_init): Always use unit-at-a-time mode.
2006-06-18 Mark Mitchell <mark@codesourcery.com>
 
* lto.h: New file.
* lto.c: New file.
* lto-elf.c: New file.
* lto-lang.c (flags.h): Include it.
(lto.h): Likewise.
(lto_init): New function.
(lto_write_globals): Remove.
(LANG_HOOKS_WRITE_GLOBALS): Define to lhd_do_nothing.
(LANG_HOOKS_INIT): Define.
(LANG_HOOKS_PARSE_FILE): Likewise.
* Make-lang.in (LTO_OBJS): Add lto.o and lto-elf.o.
(LTO_EXE): Link with libelf.
(lto/lto-lang.o): Update dependencies.
(lto/lto.o): New target.
(lto/lto-elf.o): Likewise.
 
2006-06-12 Mark Mitchell <mark@codesourcery.com>
 
* config-lang.in: New file.
* Make-lang.in: Likewise.
* lto-tree.h: Likewise.
* lto-lang.c: Likewise.
 
/openrisc/trunk/gnu-dev/or1k-gcc/gcc/lto/common.c
0,0 → 1,47
/* Common code for the plugin and lto1.
Copyright (C) 2009 Free Software Foundation, Inc.
Contributed by Rafael Avila de Espindola (espindola@google.com).
 
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 3 of the License, 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, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
02110-1301, USA. */
 
#include "common.h"
 
const char *lto_kind_str[5] __attribute__ ((visibility ("hidden"))) =
{
"DEF", "WEAKDEF", "UNDEF",
"WEAKUNDEF", "COMMON"
};
 
const char *lto_visibility_str[4] __attribute__ ((visibility ("hidden"))) =
{
"DEFAULT", "PROTECTED",
"INTERNAL", "HIDDEN"
};
 
const char *lto_resolution_str[10] __attribute__ ((visibility ("hidden"))) =
{
"UNKNOWN",
"UNDEF",
"PREVAILING_DEF",
"PREVAILING_DEF_IRONLY",
"PREEMPTED_REG",
"PREEMPTED_IR",
"RESOLVED_IR",
"RESOLVED_EXEC",
"RESOLVED_DYN",
"PREVAILING_DEF_IRONLY_EXP",
};
 
/openrisc/trunk/gnu-dev/or1k-gcc/gcc/lto/config-lang.in
0,0 → 1,35
# Top level configure fragment for LTO
# Copyright (C) 2009, 2010
# Free Software Foundation, Inc.
 
#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/>.
 
language="lto"
compilers="lto1\$(exeext)"
stagestuff="lto1\$(exeext)"
 
gtfiles="\$(srcdir)/lto/lto-tree.h \$(srcdir)/lto/lto-lang.c \$(srcdir)/lto/lto.c"
 
# LTO is a special front end. From a user's perspective it is not
# really a language, but a middle end feature. However, the GIMPLE
# reading module is implemented as a front end, so enabling LTO means
# enabling this "language". To enable LTO functionality, use
# --enable-lto when configuring the compiler.
build_by_default=no
 
# Add LTO to boot language if it is enabled.
boot_language=$enable_lto
/openrisc/trunk/gnu-dev/or1k-gcc/gcc/lto/common.h
0,0 → 1,35
/* Common code for the plugin and lto1.
Copyright (C) 2008 Free Software Foundation, Inc.
Contributed by Rafael Avila de Espindola (espindola@google.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/>. */
 
 
 
static const char *lto_resolution_str[10] =
{
"UNKNOWN",
"UNDEF",
"PREVAILING_DEF",
"PREVAILING_DEF_IRONLY",
"PREEMPTED_REG",
"PREEMPTED_IR",
"RESOLVED_IR",
"RESOLVED_EXEC",
"RESOLVED_DYN",
"PREVAILING_DEF_IRONLY_EXP",
};
/openrisc/trunk/gnu-dev/or1k-gcc/gcc/lto/lto-lang.c
0,0 → 1,1305
/* Language-dependent hooks for LTO.
Copyright 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
Contributed by CodeSourcery, Inc.
 
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 "flags.h"
#include "tm.h"
#include "tree.h"
#include "target.h"
#include "langhooks.h"
#include "langhooks-def.h"
#include "debug.h"
#include "lto-tree.h"
#include "lto.h"
#include "tree-inline.h"
#include "gimple.h"
#include "diagnostic-core.h"
#include "toplev.h"
#include "lto-streamer.h"
 
static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
static tree handle_leaf_attribute (tree *, tree, tree, int, bool *);
static tree handle_const_attribute (tree *, tree, tree, int, bool *);
static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
static tree handle_transaction_pure_attribute (tree *, tree, tree, int, bool *);
static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
static tree ignore_attribute (tree *, tree, tree, int, bool *);
 
static tree handle_format_attribute (tree *, tree, tree, int, bool *);
static tree handle_format_arg_attribute (tree *, tree, tree, int, bool *);
 
/* Table of machine-independent attributes supported in GIMPLE. */
const struct attribute_spec lto_attribute_table[] =
{
/* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
do_diagnostic } */
{ "noreturn", 0, 0, true, false, false,
handle_noreturn_attribute, false },
{ "leaf", 0, 0, true, false, false,
handle_leaf_attribute, false },
/* The same comments as for noreturn attributes apply to const ones. */
{ "const", 0, 0, true, false, false,
handle_const_attribute, false },
{ "malloc", 0, 0, true, false, false,
handle_malloc_attribute, false },
{ "pure", 0, 0, true, false, false,
handle_pure_attribute, false },
{ "no vops", 0, 0, true, false, false,
handle_novops_attribute, false },
{ "nonnull", 0, -1, false, true, true,
handle_nonnull_attribute, false },
{ "nothrow", 0, 0, true, false, false,
handle_nothrow_attribute, false },
{ "returns_twice", 0, 0, true, false, false,
handle_returns_twice_attribute, false },
{ "sentinel", 0, 1, false, true, true,
handle_sentinel_attribute, false },
{ "type generic", 0, 0, false, true, true,
handle_type_generic_attribute, false },
{ "transaction_pure", 0, 0, false, true, true,
handle_transaction_pure_attribute, false },
/* For internal use only. The leading '*' both prevents its usage in
source code and signals that it may be overridden by machine tables. */
{ "*tm regparm", 0, 0, false, true, true,
ignore_attribute, false },
{ NULL, 0, 0, false, false, false, NULL, false }
};
 
/* Give the specifications for the format attributes, used by C and all
descendants. */
 
const struct attribute_spec lto_format_attribute_table[] =
{
/* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
affects_type_identity } */
{ "format", 3, 3, false, true, true,
handle_format_attribute, false },
{ "format_arg", 1, 1, false, true, true,
handle_format_arg_attribute, false },
{ NULL, 0, 0, false, false, false, NULL, false }
};
 
enum built_in_attribute
{
#define DEF_ATTR_NULL_TREE(ENUM) ENUM,
#define DEF_ATTR_INT(ENUM, VALUE) ENUM,
#define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
#define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
#include "builtin-attrs.def"
#undef DEF_ATTR_NULL_TREE
#undef DEF_ATTR_INT
#undef DEF_ATTR_IDENT
#undef DEF_ATTR_TREE_LIST
ATTR_LAST
};
 
static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
 
/* Builtin types. */
 
enum lto_builtin_type
{
#define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
#define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
#define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
#define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
#define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
#define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
#define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
#define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
#define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
#define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
#define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
#define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
#define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
#define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
#define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
NAME,
#define DEF_POINTER_TYPE(NAME, TYPE) NAME,
#include "builtin-types.def"
#undef DEF_PRIMITIVE_TYPE
#undef DEF_FUNCTION_TYPE_0
#undef DEF_FUNCTION_TYPE_1
#undef DEF_FUNCTION_TYPE_2
#undef DEF_FUNCTION_TYPE_3
#undef DEF_FUNCTION_TYPE_4
#undef DEF_FUNCTION_TYPE_5
#undef DEF_FUNCTION_TYPE_6
#undef DEF_FUNCTION_TYPE_7
#undef DEF_FUNCTION_TYPE_VAR_0
#undef DEF_FUNCTION_TYPE_VAR_1
#undef DEF_FUNCTION_TYPE_VAR_2
#undef DEF_FUNCTION_TYPE_VAR_3
#undef DEF_FUNCTION_TYPE_VAR_4
#undef DEF_FUNCTION_TYPE_VAR_5
#undef DEF_POINTER_TYPE
BT_LAST
};
 
typedef enum lto_builtin_type builtin_type;
 
static GTY(()) tree builtin_types[(int) BT_LAST + 1];
 
static GTY(()) tree string_type_node;
static GTY(()) tree const_string_type_node;
static GTY(()) tree wint_type_node;
static GTY(()) tree intmax_type_node;
static GTY(()) tree uintmax_type_node;
static GTY(()) tree signed_size_type_node;
 
/* Flags needed to process builtins.def. */
int flag_isoc94;
int flag_isoc99;
 
/* Attribute handlers. */
 
/* Handle a "noreturn" attribute; arguments as in
struct attribute_spec.handler. */
 
static tree
handle_noreturn_attribute (tree *node, tree ARG_UNUSED (name),
tree ARG_UNUSED (args), int ARG_UNUSED (flags),
bool * ARG_UNUSED (no_add_attrs))
{
tree type = TREE_TYPE (*node);
 
if (TREE_CODE (*node) == FUNCTION_DECL)
TREE_THIS_VOLATILE (*node) = 1;
else if (TREE_CODE (type) == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
TREE_TYPE (*node)
= build_pointer_type
(build_type_variant (TREE_TYPE (type),
TYPE_READONLY (TREE_TYPE (type)), 1));
else
gcc_unreachable ();
 
return NULL_TREE;
}
 
/* Handle a "leaf" attribute; arguments as in
struct attribute_spec.handler. */
 
static tree
handle_leaf_attribute (tree *node, tree name,
tree ARG_UNUSED (args),
int ARG_UNUSED (flags), bool *no_add_attrs)
{
if (TREE_CODE (*node) != FUNCTION_DECL)
{
warning (OPT_Wattributes, "%qE attribute ignored", name);
*no_add_attrs = true;
}
if (!TREE_PUBLIC (*node))
{
warning (OPT_Wattributes, "%qE attribute has no effect on unit local functions", name);
*no_add_attrs = true;
}
 
return NULL_TREE;
}
 
/* Handle a "const" attribute; arguments as in
struct attribute_spec.handler. */
 
static tree
handle_const_attribute (tree *node, tree ARG_UNUSED (name),
tree ARG_UNUSED (args), int ARG_UNUSED (flags),
bool * ARG_UNUSED (no_add_attrs))
{
tree type = TREE_TYPE (*node);
 
/* See FIXME comment on noreturn in c_common_attribute_table. */
if (TREE_CODE (*node) == FUNCTION_DECL)
TREE_READONLY (*node) = 1;
else if (TREE_CODE (type) == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
TREE_TYPE (*node)
= build_pointer_type
(build_type_variant (TREE_TYPE (type), 1,
TREE_THIS_VOLATILE (TREE_TYPE (type))));
else
gcc_unreachable ();
 
return NULL_TREE;
}
 
 
/* Handle a "malloc" attribute; arguments as in
struct attribute_spec.handler. */
 
static tree
handle_malloc_attribute (tree *node, tree ARG_UNUSED (name),
tree ARG_UNUSED (args), int ARG_UNUSED (flags),
bool * ARG_UNUSED (no_add_attrs))
{
if (TREE_CODE (*node) == FUNCTION_DECL
&& POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
DECL_IS_MALLOC (*node) = 1;
else
gcc_unreachable ();
 
return NULL_TREE;
}
 
 
/* Handle a "pure" attribute; arguments as in
struct attribute_spec.handler. */
 
static tree
handle_pure_attribute (tree *node, tree ARG_UNUSED (name),
tree ARG_UNUSED (args), int ARG_UNUSED (flags),
bool * ARG_UNUSED (no_add_attrs))
{
if (TREE_CODE (*node) == FUNCTION_DECL)
DECL_PURE_P (*node) = 1;
else
gcc_unreachable ();
 
return NULL_TREE;
}
 
 
/* Handle a "no vops" attribute; arguments as in
struct attribute_spec.handler. */
 
static tree
handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
tree ARG_UNUSED (args), int ARG_UNUSED (flags),
bool *ARG_UNUSED (no_add_attrs))
{
gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
DECL_IS_NOVOPS (*node) = 1;
return NULL_TREE;
}
 
 
/* Helper for nonnull attribute handling; fetch the operand number
from the attribute argument list. */
 
static bool
get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
{
/* Verify the arg number is a constant. */
if (TREE_CODE (arg_num_expr) != INTEGER_CST
|| TREE_INT_CST_HIGH (arg_num_expr) != 0)
return false;
 
*valp = TREE_INT_CST_LOW (arg_num_expr);
return true;
}
 
/* Handle the "nonnull" attribute. */
 
static tree
handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
tree args, int ARG_UNUSED (flags),
bool * ARG_UNUSED (no_add_attrs))
{
tree type = *node;
 
/* If no arguments are specified, all pointer arguments should be
non-null. Verify a full prototype is given so that the arguments
will have the correct types when we actually check them later. */
if (!args)
{
gcc_assert (prototype_p (type));
return NULL_TREE;
}
 
/* Argument list specified. Verify that each argument number references
a pointer argument. */
for (; args; args = TREE_CHAIN (args))
{
tree argument;
unsigned HOST_WIDE_INT arg_num = 0, ck_num;
 
if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
gcc_unreachable ();
 
argument = TYPE_ARG_TYPES (type);
if (argument)
{
for (ck_num = 1; ; ck_num++)
{
if (!argument || ck_num == arg_num)
break;
argument = TREE_CHAIN (argument);
}
 
gcc_assert (argument
&& TREE_CODE (TREE_VALUE (argument)) == POINTER_TYPE);
}
}
 
return NULL_TREE;
}
 
 
/* Handle a "nothrow" attribute; arguments as in
struct attribute_spec.handler. */
 
static tree
handle_nothrow_attribute (tree *node, tree ARG_UNUSED (name),
tree ARG_UNUSED (args), int ARG_UNUSED (flags),
bool * ARG_UNUSED (no_add_attrs))
{
if (TREE_CODE (*node) == FUNCTION_DECL)
TREE_NOTHROW (*node) = 1;
else
gcc_unreachable ();
 
return NULL_TREE;
}
 
 
/* Handle a "sentinel" attribute. */
 
static tree
handle_sentinel_attribute (tree *node, tree ARG_UNUSED (name), tree args,
int ARG_UNUSED (flags),
bool * ARG_UNUSED (no_add_attrs))
{
gcc_assert (stdarg_p (*node));
 
if (args)
{
tree position = TREE_VALUE (args);
gcc_assert (TREE_CODE (position) == INTEGER_CST);
if (tree_int_cst_lt (position, integer_zero_node))
gcc_unreachable ();
}
 
return NULL_TREE;
}
 
/* Handle a "type_generic" attribute. */
 
static tree
handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
tree ARG_UNUSED (args), int ARG_UNUSED (flags),
bool * ARG_UNUSED (no_add_attrs))
{
/* Ensure we have a function type. */
gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
/* Ensure we have a variadic function. */
gcc_assert (!prototype_p (*node) || stdarg_p (*node));
 
return NULL_TREE;
}
 
/* Handle a "transaction_pure" attribute. */
 
static tree
handle_transaction_pure_attribute (tree *node, tree ARG_UNUSED (name),
tree ARG_UNUSED (args),
int ARG_UNUSED (flags),
bool * ARG_UNUSED (no_add_attrs))
{
/* Ensure we have a function type. */
gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
 
return NULL_TREE;
}
 
/* Handle a "returns_twice" attribute. */
 
static tree
handle_returns_twice_attribute (tree *node, tree ARG_UNUSED (name),
tree ARG_UNUSED (args),
int ARG_UNUSED (flags),
bool * ARG_UNUSED (no_add_attrs))
{
gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
 
DECL_IS_RETURNS_TWICE (*node) = 1;
 
return NULL_TREE;
}
 
/* Ignore the given attribute. Used when this attribute may be usefully
overridden by the target, but is not used generically. */
 
static tree
ignore_attribute (tree * ARG_UNUSED (node), tree ARG_UNUSED (name),
tree ARG_UNUSED (args), int ARG_UNUSED (flags),
bool *no_add_attrs)
{
*no_add_attrs = true;
return NULL_TREE;
}
 
/* Handle a "format" attribute; arguments as in
struct attribute_spec.handler. */
 
static tree
handle_format_attribute (tree * ARG_UNUSED (node), tree ARG_UNUSED (name),
tree ARG_UNUSED (args), int ARG_UNUSED (flags),
bool *no_add_attrs)
{
*no_add_attrs = true;
return NULL_TREE;
}
 
 
/* Handle a "format_arg" attribute; arguments as in
struct attribute_spec.handler. */
 
tree
handle_format_arg_attribute (tree * ARG_UNUSED (node), tree ARG_UNUSED (name),
tree ARG_UNUSED (args), int ARG_UNUSED (flags),
bool *no_add_attrs)
{
*no_add_attrs = true;
return NULL_TREE;
}
 
 
/* Cribbed from c-common.c. */
 
static void
def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
{
tree t;
tree *args = XALLOCAVEC (tree, n);
va_list list;
int i;
 
va_start (list, n);
for (i = 0; i < n; ++i)
{
builtin_type a = (builtin_type) va_arg (list, int);
t = builtin_types[a];
if (t == error_mark_node)
goto egress;
args[i] = t;
}
va_end (list);
 
t = builtin_types[ret];
if (t == error_mark_node)
goto egress;
if (var)
t = build_varargs_function_type_array (t, n, args);
else
t = build_function_type_array (t, n, args);
 
egress:
builtin_types[def] = t;
va_end (list);
}
 
/* Used to help initialize the builtin-types.def table. When a type of
the correct size doesn't exist, use error_mark_node instead of NULL.
The later results in segfaults even when a decl using the type doesn't
get invoked. */
 
static tree
builtin_type_for_size (int size, bool unsignedp)
{
tree type = lang_hooks.types.type_for_size (size, unsignedp);
return type ? type : error_mark_node;
}
 
/* Support for DEF_BUILTIN. */
 
static void
def_builtin_1 (enum built_in_function fncode, const char *name,
enum built_in_class fnclass, tree fntype, tree libtype,
bool both_p, bool fallback_p, bool nonansi_p,
tree fnattrs, bool implicit_p)
{
tree decl;
const char *libname;
 
if (fntype == error_mark_node)
return;
 
libname = name + strlen ("__builtin_");
decl = add_builtin_function (name, fntype, fncode, fnclass,
(fallback_p ? libname : NULL),
fnattrs);
 
if (both_p
&& !flag_no_builtin
&& !(nonansi_p && flag_no_nonansi_builtin))
add_builtin_function (libname, libtype, fncode, fnclass,
NULL, fnattrs);
 
set_builtin_decl (fncode, decl, implicit_p);
}
 
 
/* Initialize the attribute table for all the supported builtins. */
 
static void
lto_init_attributes (void)
{
/* Fill in the built_in_attributes array. */
#define DEF_ATTR_NULL_TREE(ENUM) \
built_in_attributes[(int) ENUM] = NULL_TREE;
#define DEF_ATTR_INT(ENUM, VALUE) \
built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
#define DEF_ATTR_IDENT(ENUM, STRING) \
built_in_attributes[(int) ENUM] = get_identifier (STRING);
#define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
built_in_attributes[(int) ENUM] \
= tree_cons (built_in_attributes[(int) PURPOSE], \
built_in_attributes[(int) VALUE], \
built_in_attributes[(int) CHAIN]);
#include "builtin-attrs.def"
#undef DEF_ATTR_NULL_TREE
#undef DEF_ATTR_INT
#undef DEF_ATTR_IDENT
#undef DEF_ATTR_TREE_LIST
}
 
/* Create builtin types and functions. VA_LIST_REF_TYPE_NODE and
VA_LIST_ARG_TYPE_NODE are used in builtin-types.def. */
 
static void
lto_define_builtins (tree va_list_ref_type_node ATTRIBUTE_UNUSED,
tree va_list_arg_type_node ATTRIBUTE_UNUSED)
{
#define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
builtin_types[ENUM] = VALUE;
#define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
def_fn_type (ENUM, RETURN, 0, 0);
#define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
def_fn_type (ENUM, RETURN, 0, 1, ARG1);
#define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
#define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
#define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
#define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
#define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
ARG6) \
def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
#define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
ARG6, ARG7) \
def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
#define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
def_fn_type (ENUM, RETURN, 1, 0);
#define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
def_fn_type (ENUM, RETURN, 1, 1, ARG1);
#define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
#define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
#define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
#define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
#define DEF_POINTER_TYPE(ENUM, TYPE) \
builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
 
#include "builtin-types.def"
 
#undef DEF_PRIMITIVE_TYPE
#undef DEF_FUNCTION_TYPE_1
#undef DEF_FUNCTION_TYPE_2
#undef DEF_FUNCTION_TYPE_3
#undef DEF_FUNCTION_TYPE_4
#undef DEF_FUNCTION_TYPE_5
#undef DEF_FUNCTION_TYPE_6
#undef DEF_FUNCTION_TYPE_VAR_0
#undef DEF_FUNCTION_TYPE_VAR_1
#undef DEF_FUNCTION_TYPE_VAR_2
#undef DEF_FUNCTION_TYPE_VAR_3
#undef DEF_FUNCTION_TYPE_VAR_4
#undef DEF_FUNCTION_TYPE_VAR_5
#undef DEF_POINTER_TYPE
builtin_types[(int) BT_LAST] = NULL_TREE;
 
lto_init_attributes ();
 
#define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P,\
NONANSI_P, ATTRS, IMPLICIT, COND) \
if (NAME && COND) \
def_builtin_1 (ENUM, NAME, CLASS, builtin_types[(int) TYPE], \
builtin_types[(int) LIBTYPE], BOTH_P, FALLBACK_P, \
NONANSI_P, built_in_attributes[(int) ATTRS], IMPLICIT);
#include "builtins.def"
#undef DEF_BUILTIN
}
 
static GTY(()) tree registered_builtin_types;
 
/* Language hooks. */
 
static unsigned int
lto_option_lang_mask (void)
{
return CL_LTO;
}
 
static bool
lto_complain_wrong_lang_p (const struct cl_option *option ATTRIBUTE_UNUSED)
{
/* The LTO front end inherits all the options from the first front
end that was used. However, not all the original front end
options make sense in LTO.
 
A real solution would be to filter this in collect2, but collect2
does not have access to all the option attributes to know what to
filter. So, in lto1 we silently accept inherited flags and do
nothing about it. */
return false;
}
 
static void
lto_init_options_struct (struct gcc_options *opts)
{
/* By default, C99-like requirements for complex multiply and divide.
??? Until the complex method is encoded in the IL this is the only
safe choice. This will pessimize Fortran code with LTO unless
people specify a complex method manually or use -ffast-math. */
opts->x_flag_complex_method = 2;
}
 
/* Handle command-line option SCODE. If the option takes an argument, it is
stored in ARG, which is otherwise NULL. VALUE holds either a numerical
argument or a binary value indicating whether the positive or negative form
of the option was supplied. */
 
const char *resolution_file_name;
static bool
lto_handle_option (size_t scode, const char *arg,
int value ATTRIBUTE_UNUSED, int kind ATTRIBUTE_UNUSED,
location_t loc ATTRIBUTE_UNUSED,
const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
{
enum opt_code code = (enum opt_code) scode;
bool result = true;
 
switch (code)
{
case OPT_fresolution_:
resolution_file_name = arg;
break;
 
case OPT_Wabi:
warn_psabi = value;
break;
 
default:
break;
}
 
return result;
}
 
/* Perform post-option processing. Does additional initialization based on
command-line options. PFILENAME is the main input filename. Returns false
to enable subsequent back-end initialization. */
 
static bool
lto_post_options (const char **pfilename ATTRIBUTE_UNUSED)
{
/* -fltrans and -fwpa are mutually exclusive. Check for that here. */
if (flag_wpa && flag_ltrans)
error ("-fwpa and -fltrans are mutually exclusive");
 
if (flag_ltrans)
{
flag_generate_lto = 0;
 
/* During LTRANS, we are not looking at the whole program, only
a subset of the whole callgraph. */
flag_whole_program = 0;
}
 
if (flag_wpa)
flag_generate_lto = 1;
 
/* Excess precision other than "fast" requires front-end
support. */
flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
 
/* Initialize the compiler back end. */
return false;
}
 
/* Return an integer type with PRECISION bits of precision,
that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
 
static tree
lto_type_for_size (unsigned precision, int unsignedp)
{
if (precision == TYPE_PRECISION (integer_type_node))
return unsignedp ? unsigned_type_node : integer_type_node;
 
if (precision == TYPE_PRECISION (signed_char_type_node))
return unsignedp ? unsigned_char_type_node : signed_char_type_node;
 
if (precision == TYPE_PRECISION (short_integer_type_node))
return unsignedp ? short_unsigned_type_node : short_integer_type_node;
 
if (precision == TYPE_PRECISION (long_integer_type_node))
return unsignedp ? long_unsigned_type_node : long_integer_type_node;
 
if (precision == TYPE_PRECISION (long_long_integer_type_node))
return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node;
 
if (precision <= TYPE_PRECISION (intQI_type_node))
return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
 
if (precision <= TYPE_PRECISION (intHI_type_node))
return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
 
if (precision <= TYPE_PRECISION (intSI_type_node))
return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
 
if (precision <= TYPE_PRECISION (intDI_type_node))
return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
 
if (precision <= TYPE_PRECISION (intTI_type_node))
return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
 
return NULL_TREE;
}
 
 
/* Return a data type that has machine mode MODE.
If the mode is an integer,
then UNSIGNEDP selects between signed and unsigned types.
If the mode is a fixed-point mode,
then UNSIGNEDP selects between saturating and nonsaturating types. */
 
static tree
lto_type_for_mode (enum machine_mode mode, int unsigned_p)
{
tree t;
 
if (mode == TYPE_MODE (integer_type_node))
return unsigned_p ? unsigned_type_node : integer_type_node;
 
if (mode == TYPE_MODE (signed_char_type_node))
return unsigned_p ? unsigned_char_type_node : signed_char_type_node;
 
if (mode == TYPE_MODE (short_integer_type_node))
return unsigned_p ? short_unsigned_type_node : short_integer_type_node;
 
if (mode == TYPE_MODE (long_integer_type_node))
return unsigned_p ? long_unsigned_type_node : long_integer_type_node;
 
if (mode == TYPE_MODE (long_long_integer_type_node))
return unsigned_p ? long_long_unsigned_type_node : long_long_integer_type_node;
 
if (mode == QImode)
return unsigned_p ? unsigned_intQI_type_node : intQI_type_node;
 
if (mode == HImode)
return unsigned_p ? unsigned_intHI_type_node : intHI_type_node;
 
if (mode == SImode)
return unsigned_p ? unsigned_intSI_type_node : intSI_type_node;
 
if (mode == DImode)
return unsigned_p ? unsigned_intDI_type_node : intDI_type_node;
 
#if HOST_BITS_PER_WIDE_INT >= 64
if (mode == TYPE_MODE (intTI_type_node))
return unsigned_p ? unsigned_intTI_type_node : intTI_type_node;
#endif
 
if (mode == TYPE_MODE (float_type_node))
return float_type_node;
 
if (mode == TYPE_MODE (double_type_node))
return double_type_node;
 
if (mode == TYPE_MODE (long_double_type_node))
return long_double_type_node;
 
if (mode == TYPE_MODE (void_type_node))
return void_type_node;
 
if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
return (unsigned_p
? make_unsigned_type (GET_MODE_PRECISION (mode))
: make_signed_type (GET_MODE_PRECISION (mode)));
 
if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
return (unsigned_p
? make_unsigned_type (GET_MODE_PRECISION (mode))
: make_signed_type (GET_MODE_PRECISION (mode)));
 
if (COMPLEX_MODE_P (mode))
{
enum machine_mode inner_mode;
tree inner_type;
 
if (mode == TYPE_MODE (complex_float_type_node))
return complex_float_type_node;
if (mode == TYPE_MODE (complex_double_type_node))
return complex_double_type_node;
if (mode == TYPE_MODE (complex_long_double_type_node))
return complex_long_double_type_node;
 
if (mode == TYPE_MODE (complex_integer_type_node) && !unsigned_p)
return complex_integer_type_node;
 
inner_mode = GET_MODE_INNER (mode);
inner_type = lto_type_for_mode (inner_mode, unsigned_p);
if (inner_type != NULL_TREE)
return build_complex_type (inner_type);
}
else if (VECTOR_MODE_P (mode))
{
enum machine_mode inner_mode = GET_MODE_INNER (mode);
tree inner_type = lto_type_for_mode (inner_mode, unsigned_p);
if (inner_type != NULL_TREE)
return build_vector_type_for_mode (inner_type, mode);
}
 
if (mode == TYPE_MODE (dfloat32_type_node))
return dfloat32_type_node;
if (mode == TYPE_MODE (dfloat64_type_node))
return dfloat64_type_node;
if (mode == TYPE_MODE (dfloat128_type_node))
return dfloat128_type_node;
 
if (ALL_SCALAR_FIXED_POINT_MODE_P (mode))
{
if (mode == TYPE_MODE (short_fract_type_node))
return unsigned_p ? sat_short_fract_type_node : short_fract_type_node;
if (mode == TYPE_MODE (fract_type_node))
return unsigned_p ? sat_fract_type_node : fract_type_node;
if (mode == TYPE_MODE (long_fract_type_node))
return unsigned_p ? sat_long_fract_type_node : long_fract_type_node;
if (mode == TYPE_MODE (long_long_fract_type_node))
return unsigned_p ? sat_long_long_fract_type_node
: long_long_fract_type_node;
 
if (mode == TYPE_MODE (unsigned_short_fract_type_node))
return unsigned_p ? sat_unsigned_short_fract_type_node
: unsigned_short_fract_type_node;
if (mode == TYPE_MODE (unsigned_fract_type_node))
return unsigned_p ? sat_unsigned_fract_type_node
: unsigned_fract_type_node;
if (mode == TYPE_MODE (unsigned_long_fract_type_node))
return unsigned_p ? sat_unsigned_long_fract_type_node
: unsigned_long_fract_type_node;
if (mode == TYPE_MODE (unsigned_long_long_fract_type_node))
return unsigned_p ? sat_unsigned_long_long_fract_type_node
: unsigned_long_long_fract_type_node;
 
if (mode == TYPE_MODE (short_accum_type_node))
return unsigned_p ? sat_short_accum_type_node : short_accum_type_node;
if (mode == TYPE_MODE (accum_type_node))
return unsigned_p ? sat_accum_type_node : accum_type_node;
if (mode == TYPE_MODE (long_accum_type_node))
return unsigned_p ? sat_long_accum_type_node : long_accum_type_node;
if (mode == TYPE_MODE (long_long_accum_type_node))
return unsigned_p ? sat_long_long_accum_type_node
: long_long_accum_type_node;
 
if (mode == TYPE_MODE (unsigned_short_accum_type_node))
return unsigned_p ? sat_unsigned_short_accum_type_node
: unsigned_short_accum_type_node;
if (mode == TYPE_MODE (unsigned_accum_type_node))
return unsigned_p ? sat_unsigned_accum_type_node
: unsigned_accum_type_node;
if (mode == TYPE_MODE (unsigned_long_accum_type_node))
return unsigned_p ? sat_unsigned_long_accum_type_node
: unsigned_long_accum_type_node;
if (mode == TYPE_MODE (unsigned_long_long_accum_type_node))
return unsigned_p ? sat_unsigned_long_long_accum_type_node
: unsigned_long_long_accum_type_node;
 
if (mode == QQmode)
return unsigned_p ? sat_qq_type_node : qq_type_node;
if (mode == HQmode)
return unsigned_p ? sat_hq_type_node : hq_type_node;
if (mode == SQmode)
return unsigned_p ? sat_sq_type_node : sq_type_node;
if (mode == DQmode)
return unsigned_p ? sat_dq_type_node : dq_type_node;
if (mode == TQmode)
return unsigned_p ? sat_tq_type_node : tq_type_node;
 
if (mode == UQQmode)
return unsigned_p ? sat_uqq_type_node : uqq_type_node;
if (mode == UHQmode)
return unsigned_p ? sat_uhq_type_node : uhq_type_node;
if (mode == USQmode)
return unsigned_p ? sat_usq_type_node : usq_type_node;
if (mode == UDQmode)
return unsigned_p ? sat_udq_type_node : udq_type_node;
if (mode == UTQmode)
return unsigned_p ? sat_utq_type_node : utq_type_node;
 
if (mode == HAmode)
return unsigned_p ? sat_ha_type_node : ha_type_node;
if (mode == SAmode)
return unsigned_p ? sat_sa_type_node : sa_type_node;
if (mode == DAmode)
return unsigned_p ? sat_da_type_node : da_type_node;
if (mode == TAmode)
return unsigned_p ? sat_ta_type_node : ta_type_node;
 
if (mode == UHAmode)
return unsigned_p ? sat_uha_type_node : uha_type_node;
if (mode == USAmode)
return unsigned_p ? sat_usa_type_node : usa_type_node;
if (mode == UDAmode)
return unsigned_p ? sat_uda_type_node : uda_type_node;
if (mode == UTAmode)
return unsigned_p ? sat_uta_type_node : uta_type_node;
}
 
for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
if (TYPE_MODE (TREE_VALUE (t)) == mode)
return TREE_VALUE (t);
 
return NULL_TREE;
}
 
/* Return true if we are in the global binding level. */
 
static bool
lto_global_bindings_p (void)
{
return cfun == NULL;
}
 
static void
lto_set_decl_assembler_name (tree decl)
{
/* This is almost the same as lhd_set_decl_assembler_name, except that
we need to uniquify file-scope names, even if they are not
TREE_PUBLIC, to avoid conflicts between individual files. */
tree id;
 
if (TREE_PUBLIC (decl))
id = targetm.mangle_decl_assembler_name (decl, DECL_NAME (decl));
else
{
const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
char *label;
 
ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
id = get_identifier (label);
}
 
SET_DECL_ASSEMBLER_NAME (decl, id);
}
 
static tree
lto_pushdecl (tree t ATTRIBUTE_UNUSED)
{
/* Do nothing, since we get all information from DWARF and LTO
sections. */
return NULL_TREE;
}
 
static tree
lto_getdecls (void)
{
/* We have our own write_globals langhook, hence the getdecls
langhook shouldn't be used, except by dbxout.c, so we can't
just abort here. */
return NULL_TREE;
}
 
static void
lto_write_globals (void)
{
tree *vec = VEC_address (tree, lto_global_var_decls);
int len = VEC_length (tree, lto_global_var_decls);
wrapup_global_declarations (vec, len);
emit_debug_global_declarations (vec, len);
VEC_free (tree, gc, lto_global_var_decls);
}
 
static tree
lto_builtin_function (tree decl)
{
return decl;
}
 
static void
lto_register_builtin_type (tree type, const char *name)
{
tree decl;
 
decl = build_decl (UNKNOWN_LOCATION, TYPE_DECL, get_identifier (name), type);
DECL_ARTIFICIAL (decl) = 1;
if (!TYPE_NAME (type))
TYPE_NAME (type) = decl;
 
registered_builtin_types = tree_cons (0, type, registered_builtin_types);
}
 
/* Build nodes that would have be created by the C front-end; necessary
for including builtin-types.def and ultimately builtins.def. */
 
static void
lto_build_c_type_nodes (void)
{
gcc_assert (void_type_node);
 
void_list_node = build_tree_list (NULL_TREE, void_type_node);
string_type_node = build_pointer_type (char_type_node);
const_string_type_node
= build_pointer_type (build_qualified_type (char_type_node, TYPE_QUAL_CONST));
 
if (strcmp (SIZE_TYPE, "unsigned int") == 0)
{
intmax_type_node = integer_type_node;
uintmax_type_node = unsigned_type_node;
signed_size_type_node = integer_type_node;
}
else if (strcmp (SIZE_TYPE, "long unsigned int") == 0)
{
intmax_type_node = long_integer_type_node;
uintmax_type_node = long_unsigned_type_node;
signed_size_type_node = long_integer_type_node;
}
else if (strcmp (SIZE_TYPE, "long long unsigned int") == 0)
{
intmax_type_node = long_long_integer_type_node;
uintmax_type_node = long_long_unsigned_type_node;
signed_size_type_node = long_long_integer_type_node;
}
else
gcc_unreachable ();
 
wint_type_node = unsigned_type_node;
pid_type_node = integer_type_node;
}
 
/* Re-compute TYPE_CANONICAL for NODE and related types. */
 
static void
lto_register_canonical_types (tree node)
{
if (!node
|| !TYPE_P (node))
return;
 
TYPE_CANONICAL (node) = NULL_TREE;
TYPE_CANONICAL (node) = gimple_register_canonical_type (node);
 
if (POINTER_TYPE_P (node)
|| TREE_CODE (node) == COMPLEX_TYPE
|| TREE_CODE (node) == ARRAY_TYPE)
lto_register_canonical_types (TREE_TYPE (node));
}
 
/* Perform LTO-specific initialization. */
 
static bool
lto_init (void)
{
unsigned i;
 
/* We need to generate LTO if running in WPA mode. */
flag_generate_lto = flag_wpa;
 
/* Initialize libcpp line maps for gcc_assert to work. */
linemap_add (line_table, LC_ENTER, 0, NULL, 0);
 
/* Create the basic integer types. */
build_common_tree_nodes (flag_signed_char, /*short_double=*/false);
 
/* The global tree for the main identifier is filled in by
language-specific front-end initialization that is not run in the
LTO back-end. It appears that all languages that perform such
initialization currently do so in the same way, so we do it here. */
if (main_identifier_node == NULL_TREE)
main_identifier_node = get_identifier ("main");
 
/* In the C++ front-end, fileptr_type_node is defined as a variant
copy of of ptr_type_node, rather than ptr_node itself. The
distinction should only be relevant to the front-end, so we
always use the C definition here in lto1. */
gcc_assert (fileptr_type_node == ptr_type_node);
gcc_assert (TYPE_MAIN_VARIANT (fileptr_type_node) == ptr_type_node);
 
ptrdiff_type_node = integer_type_node;
 
lto_build_c_type_nodes ();
gcc_assert (va_list_type_node);
 
if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
{
tree x = build_pointer_type (TREE_TYPE (va_list_type_node));
lto_define_builtins (x, x);
}
else
{
lto_define_builtins (va_list_type_node,
build_reference_type (va_list_type_node));
}
 
targetm.init_builtins ();
build_common_builtin_nodes ();
 
/* Assign names to the builtin types, otherwise they'll end up
as __unknown__ in debug info.
??? We simply need to stop pre-seeding the streamer cache.
Below is modeled after from c-common.c:c_common_nodes_and_builtins */
#define NAME_TYPE(t,n) \
if (t) \
TYPE_NAME (t) = build_decl (UNKNOWN_LOCATION, TYPE_DECL, \
get_identifier (n), t)
NAME_TYPE (integer_type_node, "int");
NAME_TYPE (char_type_node, "char");
NAME_TYPE (long_integer_type_node, "long int");
NAME_TYPE (unsigned_type_node, "unsigned int");
NAME_TYPE (long_unsigned_type_node, "long unsigned int");
NAME_TYPE (long_long_integer_type_node, "long long int");
NAME_TYPE (long_long_unsigned_type_node, "long long unsigned int");
NAME_TYPE (short_integer_type_node, "short int");
NAME_TYPE (short_unsigned_type_node, "short unsigned int");
if (signed_char_type_node != char_type_node)
NAME_TYPE (signed_char_type_node, "signed char");
if (unsigned_char_type_node != char_type_node)
NAME_TYPE (unsigned_char_type_node, "unsigned char");
NAME_TYPE (float_type_node, "float");
NAME_TYPE (double_type_node, "double");
NAME_TYPE (long_double_type_node, "long double");
NAME_TYPE (void_type_node, "void");
NAME_TYPE (boolean_type_node, "bool");
#undef NAME_TYPE
 
/* Register the common node types with the canonical type machinery so
we properly share alias-sets across languages and TUs. Do not
expose the common nodes as type merge target - those that should be
are already exposed so by pre-loading the LTO streamer caches. */
for (i = 0; i < itk_none; ++i)
lto_register_canonical_types (integer_types[i]);
/* The sizetypes are not used to access data so we do not need to
do anything about them. */
for (i = 0; i < TI_MAX; ++i)
lto_register_canonical_types (global_trees[i]);
 
/* Initialize LTO-specific data structures. */
lto_global_var_decls = VEC_alloc (tree, gc, 256);
in_lto_p = true;
 
return true;
}
 
/* Initialize tree structures required by the LTO front end. */
 
static void lto_init_ts (void)
{
tree_contains_struct[NAMESPACE_DECL][TS_DECL_MINIMAL] = 1;
}
 
#undef LANG_HOOKS_NAME
#define LANG_HOOKS_NAME "GNU GIMPLE"
#undef LANG_HOOKS_OPTION_LANG_MASK
#define LANG_HOOKS_OPTION_LANG_MASK lto_option_lang_mask
#undef LANG_HOOKS_COMPLAIN_WRONG_LANG_P
#define LANG_HOOKS_COMPLAIN_WRONG_LANG_P lto_complain_wrong_lang_p
#undef LANG_HOOKS_INIT_OPTIONS_STRUCT
#define LANG_HOOKS_INIT_OPTIONS_STRUCT lto_init_options_struct
#undef LANG_HOOKS_HANDLE_OPTION
#define LANG_HOOKS_HANDLE_OPTION lto_handle_option
#undef LANG_HOOKS_POST_OPTIONS
#define LANG_HOOKS_POST_OPTIONS lto_post_options
#undef LANG_HOOKS_GET_ALIAS_SET
#define LANG_HOOKS_GET_ALIAS_SET gimple_get_alias_set
#undef LANG_HOOKS_TYPE_FOR_MODE
#define LANG_HOOKS_TYPE_FOR_MODE lto_type_for_mode
#undef LANG_HOOKS_TYPE_FOR_SIZE
#define LANG_HOOKS_TYPE_FOR_SIZE lto_type_for_size
#undef LANG_HOOKS_SET_DECL_ASSEMBLER_NAME
#define LANG_HOOKS_SET_DECL_ASSEMBLER_NAME lto_set_decl_assembler_name
#undef LANG_HOOKS_GLOBAL_BINDINGS_P
#define LANG_HOOKS_GLOBAL_BINDINGS_P lto_global_bindings_p
#undef LANG_HOOKS_PUSHDECL
#define LANG_HOOKS_PUSHDECL lto_pushdecl
#undef LANG_HOOKS_GETDECLS
#define LANG_HOOKS_GETDECLS lto_getdecls
#undef LANG_HOOKS_WRITE_GLOBALS
#define LANG_HOOKS_WRITE_GLOBALS lto_write_globals
#undef LANG_HOOKS_REGISTER_BUILTIN_TYPE
#define LANG_HOOKS_REGISTER_BUILTIN_TYPE lto_register_builtin_type
#undef LANG_HOOKS_BUILTIN_FUNCTION
#define LANG_HOOKS_BUILTIN_FUNCTION lto_builtin_function
#undef LANG_HOOKS_INIT
#define LANG_HOOKS_INIT lto_init
#undef LANG_HOOKS_PARSE_FILE
#define LANG_HOOKS_PARSE_FILE lto_main
#undef LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION
#define LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION tree_rest_of_compilation
#undef LANG_HOOKS_REDUCE_BIT_FIELD_OPERATIONS
#define LANG_HOOKS_REDUCE_BIT_FIELD_OPERATIONS true
#undef LANG_HOOKS_TYPES_COMPATIBLE_P
#define LANG_HOOKS_TYPES_COMPATIBLE_P NULL
#undef LANG_HOOKS_EH_PERSONALITY
#define LANG_HOOKS_EH_PERSONALITY lto_eh_personality
 
/* Attribute hooks. */
#undef LANG_HOOKS_COMMON_ATTRIBUTE_TABLE
#define LANG_HOOKS_COMMON_ATTRIBUTE_TABLE lto_attribute_table
#undef LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE
#define LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE lto_format_attribute_table
 
#undef LANG_HOOKS_BEGIN_SECTION
#define LANG_HOOKS_BEGIN_SECTION lto_obj_begin_section
#undef LANG_HOOKS_APPEND_DATA
#define LANG_HOOKS_APPEND_DATA lto_obj_append_data
#undef LANG_HOOKS_END_SECTION
#define LANG_HOOKS_END_SECTION lto_obj_end_section
 
#undef LANG_HOOKS_INIT_TS
#define LANG_HOOKS_INIT_TS lto_init_ts
 
struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
 
/* Language hooks that are not part of lang_hooks. */
 
tree
convert (tree type ATTRIBUTE_UNUSED, tree expr ATTRIBUTE_UNUSED)
{
gcc_unreachable ();
}
 
/* Tree walking support. */
 
static enum lto_tree_node_structure_enum
lto_tree_node_structure (union lang_tree_node *t ATTRIBUTE_UNUSED)
{
return TS_LTO_GENERIC;
}
 
#include "ggc.h"
#include "gtype-lto.h"
#include "gt-lto-lto-lang.h"

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.