URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
Compare Revisions
- This comparison shows the changes necessary to convert path
/
- from Rev 287 to Rev 288
- ↔ Reverse comparison
Rev 287 → Rev 288
/openrisc/trunk/gnu-src/gcc-4.5.1/gcc/lto/lto.c
0,0 → 1,2103
/* Top-level LTO routines. |
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/>. */ |
|
#include "config.h" |
#include "system.h" |
#include "coretypes.h" |
#include "opts.h" |
#include "toplev.h" |
#include "tree.h" |
#include "diagnostic.h" |
#include "tm.h" |
#include "libiberty.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 "timevar.h" |
#include "gimple.h" |
#include "lto.h" |
#include "lto-tree.h" |
#include "lto-streamer.h" |
|
/* This needs to be included after config.h. Otherwise, _GNU_SOURCE will not |
be defined in time to set __USE_GNU in the system headers, and strsignal |
will not be declared. */ |
#if HAVE_MMAP_FILE |
#include <sys/mman.h> |
#endif |
|
/* Handle opening elf files on hosts, such as Windows, that may use |
text file handling that will break binary access. */ |
|
#ifndef O_BINARY |
# define O_BINARY 0 |
#endif |
|
|
DEF_VEC_P(bitmap); |
DEF_VEC_ALLOC_P(bitmap,heap); |
|
/* 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); |
} |
|
/* Read the function body for the function associated with NODE if possible. */ |
|
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; |
tree step; |
|
/* Ignore clone nodes. Read the body only from the original one. |
We may find clone nodes during LTRANS after WPA has made inlining |
decisions. */ |
if (node->clone_of) |
return; |
|
decl = node->decl; |
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) |
{ |
struct function *fn; |
|
gcc_assert (!DECL_IS_BUILTIN (decl)); |
|
/* This function has a definition. */ |
TREE_STATIC (decl) = 1; |
|
gcc_assert (DECL_STRUCT_FUNCTION (decl) == NULL); |
allocate_struct_function (decl, false); |
|
/* 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) |
{ |
lto_input_function_body (file_data, decl, data); |
lto_stats.num_function_bodies++; |
} |
|
fn = DECL_STRUCT_FUNCTION (decl); |
lto_free_section_data (file_data, LTO_section_function_body, name, |
data, len); |
|
/* Look for initializers of constant variables and private |
statics. */ |
for (step = fn->local_decls; step; step = TREE_CHAIN (step)) |
{ |
tree decl = TREE_VALUE (step); |
if (TREE_CODE (decl) == VAR_DECL |
&& (TREE_STATIC (decl) && !DECL_EXTERNAL (decl)) |
&& flag_unit_at_a_time) |
varpool_finalize_decl (decl); |
} |
} |
else |
DECL_EXTERNAL (decl) = 1; |
|
/* Let the middle end know about the function. */ |
rest_of_decl_compilation (decl, 1, 0); |
if (cgraph_node (decl)->needed) |
cgraph_mark_reachable_node (cgraph_node (decl)); |
} |
|
|
/* Decode the content of memory pointed to by DATA in the 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 = lto_streamer_cache_get (data_in->reader_cache, (int) 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 = (tree *) xcalloc (size, sizeof (tree)); |
|
for (j = 0; j < size; j++) |
{ |
decls[j] = lto_streamer_cache_get (data_in->reader_cache, data[j]); |
|
/* Register every type in the global type table. If the |
type existed already, use the existing type. */ |
if (TYPE_P (decls[j])) |
decls[j] = gimple_register_type (decls[j]); |
} |
|
state->streams[i].size = size; |
state->streams[i].trees = decls; |
data += size; |
} |
|
return data; |
} |
|
|
/* 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 int32_t decl_offset = sizeof (struct lto_decl_header); |
const int32_t main_offset = decl_offset + header->decl_state_size; |
const int32_t 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); |
|
/* Read the global declarations and types. */ |
while (ib_main.p < ib_main.len) |
{ |
tree t = lto_input_tree (&ib_main, data_in); |
gcc_assert (t && ib_main.p <= ib_main.len); |
} |
|
/* 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 (37, lto_hash_in_decl_state, lto_eq_in_decl_state, free); |
|
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); |
} |
|
/* strtoll is not portable. */ |
int64_t |
lto_parse_hex (const char *p) { |
uint64_t 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. An array with the symbol resolution is returned. The array |
size is written to SIZE. */ |
|
static VEC(ld_plugin_symbol_resolution_t,heap) * |
lto_resolution_read (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; |
VEC(ld_plugin_symbol_resolution_t,heap) *ret = NULL; |
unsigned max_index = 0; |
|
if (!resolution) |
return NULL; |
|
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 (strcmp (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]; |
int64_t 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; |
char r_str[27]; |
enum ld_plugin_symbol_resolution r; |
unsigned int j; |
unsigned int lto_resolution_str_len = |
sizeof (lto_resolution_str) / sizeof (char *); |
|
t = fscanf (resolution, "%u %26s %*[^\n]\n", &index, r_str); |
if (t != 2) |
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."); |
|
VEC_safe_grow_cleared (ld_plugin_symbol_resolution_t, heap, ret, |
max_index + 1); |
VEC_replace (ld_plugin_symbol_resolution_t, ret, index, r); |
} |
|
return ret; |
} |
|
/* 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) |
{ |
struct lto_file_decl_data *file_data; |
const char *data; |
size_t len; |
VEC(ld_plugin_symbol_resolution_t,heap) *resolutions; |
|
resolutions = lto_resolution_read (resolution_file, file); |
|
file_data = XCNEW (struct lto_file_decl_data); |
file_data->file_name = file->filename; |
file_data->section_hash_table = lto_obj_build_section_table (file); |
file_data->renaming_hash_table = lto_create_renaming_table (); |
|
data = lto_get_section_data (file_data, LTO_section_decls, NULL, &len); |
lto_read_decls (file_data, data, resolutions); |
lto_free_section_data (file_data, LTO_section_decls, NULL, data, len); |
|
return file_data; |
} |
|
#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 |
&& strcmp (fd_name, file_data->file_name) != 0) |
{ |
free (fd_name); |
close (fd); |
fd = -1; |
} |
if (fd == -1) |
{ |
fd_name = xstrdup (file_data->file_name); |
fd = open (file_data->file_name, O_RDONLY|O_BINARY); |
if (fd == -1) |
return NULL; |
} |
|
#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) |
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); |
return NULL; |
} |
|
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); |
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 |
} |
|
/* Vector of all cgraph node sets. */ |
static GTY (()) VEC(cgraph_node_set, gc) *lto_cgraph_node_sets; |
|
|
/* 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 lto_file_decl_data *file_data; |
struct pointer_map_t *pmap; |
cgraph_node_set set; |
void **slot; |
|
timevar_push (TV_WHOPR_WPA); |
|
lto_cgraph_node_sets = VEC_alloc (cgraph_node_set, gc, 1); |
|
/* 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 (!cgraph_nodes) |
{ |
set = cgraph_node_set_new (); |
VEC_safe_push (cgraph_node_set, gc, lto_cgraph_node_sets, set); |
goto finish; |
} |
|
pmap = pointer_map_create (); |
|
for (node = cgraph_nodes; node; node = node->next) |
{ |
/* We only need to partition the nodes that we read from the |
gimple bytecode files. */ |
file_data = node->local.lto_file_data; |
if (file_data == NULL) |
continue; |
|
slot = pointer_map_contains (pmap, file_data); |
if (slot) |
set = (cgraph_node_set) *slot; |
else |
{ |
set = cgraph_node_set_new (); |
slot = pointer_map_insert (pmap, file_data); |
*slot = set; |
VEC_safe_push (cgraph_node_set, gc, lto_cgraph_node_sets, set); |
} |
|
cgraph_node_set_add (set, node); |
} |
|
pointer_map_destroy (pmap); |
|
finish: |
timevar_pop (TV_WHOPR_WPA); |
|
lto_stats.num_cgraph_partitions += VEC_length (cgraph_node_set, |
lto_cgraph_node_sets); |
} |
|
|
/* Add inlined clone NODE and its master clone to SET, if NODE itself has |
inlined callees, recursively add the callees. */ |
|
static void |
lto_add_inline_clones (cgraph_node_set set, struct cgraph_node *node, |
bitmap original_decls, bitmap inlined_decls) |
{ |
struct cgraph_node *callee; |
struct cgraph_edge *edge; |
|
cgraph_node_set_add (set, node); |
|
if (!bitmap_bit_p (original_decls, DECL_UID (node->decl))) |
bitmap_set_bit (inlined_decls, DECL_UID (node->decl)); |
|
/* Check to see if NODE has any inlined callee. */ |
for (edge = node->callees; edge != NULL; edge = edge->next_callee) |
{ |
callee = edge->callee; |
if (callee->global.inlined_to != NULL) |
lto_add_inline_clones (set, callee, original_decls, inlined_decls); |
} |
} |
|
/* Compute the transitive closure of inlining of SET based on the |
information in the callgraph. Returns a bitmap of decls that have |
been inlined into SET indexed by UID. */ |
|
static bitmap |
lto_add_all_inlinees (cgraph_node_set set) |
{ |
cgraph_node_set_iterator csi; |
struct cgraph_node *node; |
bitmap original_nodes = lto_bitmap_alloc (); |
bitmap original_decls = lto_bitmap_alloc (); |
bitmap inlined_decls = lto_bitmap_alloc (); |
bool changed; |
|
/* We are going to iterate SET while adding to it, mark all original |
nodes so that we only add node inlined to original nodes. */ |
for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi)) |
{ |
bitmap_set_bit (original_nodes, csi_node (csi)->uid); |
bitmap_set_bit (original_decls, DECL_UID (csi_node (csi)->decl)); |
} |
|
/* Some of the original nodes might not be needed anymore. |
Remove them. */ |
do |
{ |
changed = false; |
for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi)) |
{ |
struct cgraph_node *inlined_to; |
node = csi_node (csi); |
|
/* NODE was not inlined. We still need it. */ |
if (!node->global.inlined_to) |
continue; |
|
inlined_to = node->global.inlined_to; |
|
/* NODE should have only one caller. */ |
gcc_assert (!node->callers->next_caller); |
|
if (!bitmap_bit_p (original_nodes, inlined_to->uid)) |
{ |
bitmap_clear_bit (original_nodes, node->uid); |
cgraph_node_set_remove (set, node); |
changed = true; |
} |
} |
} |
while (changed); |
|
/* Transitively add to SET all the inline clones for every node that |
has been inlined. */ |
for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi)) |
{ |
node = csi_node (csi); |
if (bitmap_bit_p (original_nodes, node->uid)) |
lto_add_inline_clones (set, node, original_decls, inlined_decls); |
} |
|
lto_bitmap_free (original_nodes); |
lto_bitmap_free (original_decls); |
|
return inlined_decls; |
} |
|
/* Owing to inlining, we may need to promote a file-scope variable |
to a global variable. Consider this case: |
|
a.c: |
static int var; |
|
void |
foo (void) |
{ |
var++; |
} |
|
b.c: |
|
extern void foo (void); |
|
void |
bar (void) |
{ |
foo (); |
} |
|
If WPA inlines FOO inside BAR, then the static variable VAR needs to |
be promoted to global because BAR and VAR may be in different LTRANS |
files. */ |
|
/* This struct keeps track of states used in globalization. */ |
|
typedef struct |
{ |
/* Current cgraph node set. */ |
cgraph_node_set set; |
|
/* Function DECLs of cgraph nodes seen. */ |
bitmap seen_node_decls; |
|
/* Use in walk_tree to avoid multiple visits of a node. */ |
struct pointer_set_t *visited; |
|
/* static vars in this set. */ |
bitmap static_vars_in_set; |
|
/* static vars in all previous set. */ |
bitmap all_static_vars; |
|
/* all vars in all previous set. */ |
bitmap all_vars; |
} globalize_context_t; |
|
/* Callback for walk_tree. Examine the tree pointer to by TP and see if |
if its a file-scope static variable of function that need to be turned |
into a global. */ |
|
static tree |
globalize_cross_file_statics (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, |
void *data) |
{ |
globalize_context_t *context = (globalize_context_t *) data; |
tree t = *tp; |
|
if (t == NULL_TREE) |
return NULL; |
|
/* The logic for globalization of VAR_DECLs and FUNCTION_DECLs are |
different. For functions, we can simply look at the cgraph node sets |
to tell if there are references to static functions outside the set. |
The cgraph node sets do not keep track of vars, we need to traverse |
the trees to determine what vars need to be globalized. */ |
if (TREE_CODE (t) == VAR_DECL) |
{ |
if (!TREE_PUBLIC (t)) |
{ |
/* This file-scope static variable is reachable from more |
that one set. Make it global but with hidden visibility |
so that we do not export it in dynamic linking. */ |
if (bitmap_bit_p (context->all_static_vars, DECL_UID (t))) |
{ |
TREE_PUBLIC (t) = 1; |
DECL_VISIBILITY (t) = VISIBILITY_HIDDEN; |
} |
bitmap_set_bit (context->static_vars_in_set, DECL_UID (t)); |
} |
bitmap_set_bit (context->all_vars, DECL_UID (t)); |
walk_tree (&DECL_INITIAL (t), globalize_cross_file_statics, context, |
context->visited); |
} |
else if (TREE_CODE (t) == FUNCTION_DECL && !TREE_PUBLIC (t)) |
{ |
if (!cgraph_node_in_set_p (cgraph_node (t), context->set)) |
{ |
/* This file-scope static function is reachable from a set |
which does not contain the function DECL. Make it global |
but with hidden visibility. */ |
TREE_PUBLIC (t) = 1; |
DECL_VISIBILITY (t) = VISIBILITY_HIDDEN; |
} |
} |
|
return NULL; |
} |
|
/* Helper of lto_scan_statics_in_cgraph_node below. Scan TABLE for |
static decls that may be used in more than one LTRANS file. |
CONTEXT is a globalize_context_t for storing scanning states. */ |
|
static void |
lto_scan_statics_in_ref_table (struct lto_tree_ref_table *table, |
globalize_context_t *context) |
{ |
unsigned i; |
|
for (i = 0; i < table->size; i++) |
walk_tree (&table->trees[i], globalize_cross_file_statics, context, |
context->visited); |
} |
|
/* Promote file-scope decl reachable from NODE if necessary to global. |
CONTEXT is a globalize_context_t storing scanning states. */ |
|
static void |
lto_scan_statics_in_cgraph_node (struct cgraph_node *node, |
globalize_context_t *context) |
{ |
struct lto_in_decl_state *state; |
|
/* Do nothing if NODE has no function body. */ |
if (!node->analyzed) |
return; |
|
/* Return if the DECL of nodes has been visited before. */ |
if (bitmap_bit_p (context->seen_node_decls, DECL_UID (node->decl))) |
return; |
|
bitmap_set_bit (context->seen_node_decls, DECL_UID (node->decl)); |
|
state = lto_get_function_in_decl_state (node->local.lto_file_data, |
node->decl); |
gcc_assert (state); |
|
lto_scan_statics_in_ref_table (&state->streams[LTO_DECL_STREAM_VAR_DECL], |
context); |
lto_scan_statics_in_ref_table (&state->streams[LTO_DECL_STREAM_FN_DECL], |
context); |
} |
|
/* Scan all global variables that we have not yet seen so far. CONTEXT |
is a globalize_context_t storing scanning states. */ |
|
static void |
lto_scan_statics_in_remaining_global_vars (globalize_context_t *context) |
{ |
tree var, var_context; |
struct varpool_node *vnode; |
|
FOR_EACH_STATIC_VARIABLE (vnode) |
{ |
var = vnode->decl; |
var_context = DECL_CONTEXT (var); |
if (TREE_STATIC (var) |
&& TREE_PUBLIC (var) |
&& (!var_context || TREE_CODE (var_context) != FUNCTION_DECL) |
&& !bitmap_bit_p (context->all_vars, DECL_UID (var))) |
walk_tree (&var, globalize_cross_file_statics, context, |
context->visited); |
} |
} |
|
/* 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) |
{ |
unsigned i, n_sets; |
cgraph_node_set set; |
cgraph_node_set_iterator csi; |
globalize_context_t context; |
|
memset (&context, 0, sizeof (context)); |
context.all_vars = lto_bitmap_alloc (); |
context.all_static_vars = lto_bitmap_alloc (); |
|
n_sets = VEC_length (cgraph_node_set, lto_cgraph_node_sets); |
for (i = 0; i < n_sets; i++) |
{ |
set = VEC_index (cgraph_node_set, lto_cgraph_node_sets, i); |
context.set = set; |
context.visited = pointer_set_create (); |
context.static_vars_in_set = lto_bitmap_alloc (); |
context.seen_node_decls = lto_bitmap_alloc (); |
|
for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi)) |
lto_scan_statics_in_cgraph_node (csi_node (csi), &context); |
|
if (i == n_sets - 1) |
lto_scan_statics_in_remaining_global_vars (&context); |
|
bitmap_ior_into (context.all_static_vars, context.static_vars_in_set); |
|
pointer_set_destroy (context.visited); |
lto_bitmap_free (context.static_vars_in_set); |
lto_bitmap_free (context.seen_node_decls); |
} |
|
lto_bitmap_free (context.all_vars); |
lto_bitmap_free (context.all_static_vars); |
} |
|
|
/* Given a file name FNAME, return a string with FNAME prefixed with '*'. */ |
|
static char * |
prefix_name_with_star (const char *fname) |
{ |
char *star_fname; |
size_t len; |
|
len = strlen (fname) + 1 + 1; |
star_fname = XNEWVEC (char, len); |
snprintf (star_fname, len, "*%s", fname); |
|
return star_fname; |
} |
|
|
/* Return a copy of FNAME without the .o extension. */ |
|
static char * |
strip_extension (const char *fname) |
{ |
char *s = XNEWVEC (char, strlen (fname) - 2 + 1); |
gcc_assert (strstr (fname, ".o")); |
snprintf (s, strlen (fname) - 2 + 1, "%s", fname); |
|
return s; |
} |
|
|
/* Return a file name associated with cgraph node set SET. This may |
be a new temporary file name if SET needs to be processed by |
LTRANS, or the original file name if all the nodes in SET belong to |
the same input file. */ |
|
static char * |
get_filename_for_set (cgraph_node_set set) |
{ |
char *fname = NULL; |
static const size_t max_fname_len = 100; |
|
if (cgraph_node_set_needs_ltrans_p (set)) |
{ |
/* Create a new temporary file to store SET. To facilitate |
debugging, use file names from SET as part of the new |
temporary file name. */ |
cgraph_node_set_iterator si; |
struct pointer_set_t *pset = pointer_set_create (); |
for (si = csi_start (set); !csi_end_p (si); csi_next (&si)) |
{ |
struct cgraph_node *n = csi_node (si); |
const char *node_fname; |
char *f; |
|
/* Don't use the same file name more than once. */ |
if (pointer_set_insert (pset, n->local.lto_file_data)) |
continue; |
|
/* The first file name found in SET determines the output |
directory. For the remaining files, we use their |
base names. */ |
node_fname = n->local.lto_file_data->file_name; |
if (fname == NULL) |
{ |
fname = strip_extension (node_fname); |
continue; |
} |
|
f = strip_extension (lbasename (node_fname)); |
|
/* If the new name causes an excessively long file name, |
make the last component "___" to indicate overflow. */ |
if (strlen (fname) + strlen (f) > max_fname_len - 3) |
{ |
fname = reconcat (fname, fname, "___", NULL); |
break; |
} |
else |
{ |
fname = reconcat (fname, fname, "_", f, NULL); |
free (f); |
} |
} |
|
pointer_set_destroy (pset); |
|
/* Add the extension .wpa.o to indicate that this file has been |
produced by WPA. */ |
fname = reconcat (fname, fname, ".wpa.o", NULL); |
gcc_assert (fname); |
} |
else |
{ |
/* Since SET does not need to be processed by LTRANS, use |
the original file name and mark it with a '*' prefix so that |
lto_execute_ltrans knows not to process it. */ |
cgraph_node_set_iterator si = csi_start (set); |
struct cgraph_node *first = csi_node (si); |
fname = prefix_name_with_star (first->local.lto_file_data->file_name); |
} |
|
return fname; |
} |
|
static lto_file *current_lto_file; |
|
|
/* Write all output files in WPA mode. Returns a NULL-terminated array of |
output file names. */ |
|
static char ** |
lto_wpa_write_files (void) |
{ |
char **output_files; |
unsigned i, n_sets, last_out_file_ix, num_out_files; |
lto_file *file; |
cgraph_node_set set; |
bitmap decls; |
VEC(bitmap,heap) *inlined_decls = NULL; |
|
timevar_push (TV_WHOPR_WPA); |
|
/* Include all inlined functions and determine what sets need to be |
compiled by LTRANS. After this loop, only those sets that |
contain callgraph nodes from more than one file will need to be |
compiled by LTRANS. */ |
for (i = 0; VEC_iterate (cgraph_node_set, lto_cgraph_node_sets, i, set); i++) |
{ |
decls = lto_add_all_inlinees (set); |
VEC_safe_push (bitmap, heap, inlined_decls, decls); |
lto_stats.num_output_cgraph_nodes += VEC_length (cgraph_node_ptr, |
set->nodes); |
} |
|
/* After adding all inlinees, find out statics that need to be promoted |
to globals because of cross-file inlining. */ |
lto_promote_cross_file_statics (); |
|
timevar_pop (TV_WHOPR_WPA); |
|
timevar_push (TV_WHOPR_WPA_IO); |
|
/* The number of output files depends on the number of input files |
and how many callgraph node sets we create. Reserve enough space |
for the maximum of these two. */ |
num_out_files = MAX (VEC_length (cgraph_node_set, lto_cgraph_node_sets), |
num_in_fnames); |
output_files = XNEWVEC (char *, num_out_files + 1); |
|
n_sets = VEC_length (cgraph_node_set, lto_cgraph_node_sets); |
for (i = 0; i < n_sets; i++) |
{ |
char *temp_filename; |
|
set = VEC_index (cgraph_node_set, lto_cgraph_node_sets, i); |
temp_filename = get_filename_for_set (set); |
output_files[i] = temp_filename; |
|
if (cgraph_node_set_needs_ltrans_p (set)) |
{ |
/* Write all the nodes in SET to TEMP_FILENAME. */ |
file = lto_obj_file_open (temp_filename, true); |
if (!file) |
fatal_error ("lto_obj_file_open() failed"); |
|
lto_set_current_out_file (file); |
lto_new_extern_inline_states (); |
|
decls = VEC_index (bitmap, inlined_decls, i); |
lto_force_functions_extern_inline (decls); |
|
ipa_write_summaries_of_cgraph_node_set (set); |
lto_delete_extern_inline_states (); |
|
lto_set_current_out_file (NULL); |
lto_obj_file_close (file); |
} |
} |
|
last_out_file_ix = n_sets; |
|
lto_stats.num_output_files += n_sets; |
|
output_files[last_out_file_ix] = NULL; |
|
for (i = 0; VEC_iterate (bitmap, inlined_decls, i, decls); i++) |
lto_bitmap_free (decls); |
VEC_free (bitmap, heap, inlined_decls); |
|
timevar_pop (TV_WHOPR_WPA_IO); |
|
return output_files; |
} |
|
/* Template of LTRANS dumpbase suffix. */ |
#define DUMPBASE_SUFFIX ".ltrans18446744073709551615" |
|
/* Perform local transformations (LTRANS) on the files in the NULL-terminated |
FILES array. These should have been written previously by |
lto_wpa_write_files (). Transformations are performed via executing |
COLLECT_GCC for reach file. */ |
|
static void |
lto_execute_ltrans (char *const *files) |
{ |
struct pex_obj *pex; |
const char *collect_gcc_options, *collect_gcc; |
struct obstack env_obstack; |
const char **argv; |
const char **argv_ptr; |
const char *errmsg; |
size_t i, j; |
int err; |
int status; |
FILE *ltrans_output_list_stream = NULL; |
bool seen_dumpbase = false; |
char *dumpbase_suffix = NULL; |
|
timevar_push (TV_WHOPR_WPA_LTRANS_EXEC); |
|
/* Get the driver and options. */ |
collect_gcc = getenv ("COLLECT_GCC"); |
if (!collect_gcc) |
fatal_error ("environment variable COLLECT_GCC must be set"); |
|
/* Set the CFLAGS environment variable. */ |
collect_gcc_options = getenv ("COLLECT_GCC_OPTIONS"); |
if (!collect_gcc_options) |
fatal_error ("environment variable COLLECT_GCC_OPTIONS must be set"); |
|
/* Count arguments. */ |
i = 0; |
for (j = 0; collect_gcc_options[j] != '\0'; ++j) |
if (collect_gcc_options[j] == '\'') |
++i; |
|
if (i % 2 != 0) |
fatal_error ("malformed COLLECT_GCC_OPTIONS"); |
|
/* Initalize the arguments for the LTRANS driver. */ |
argv = XNEWVEC (const char *, 8 + i / 2); |
argv_ptr = argv; |
*argv_ptr++ = collect_gcc; |
*argv_ptr++ = "-xlto"; |
for (j = 0; collect_gcc_options[j] != '\0'; ++j) |
if (collect_gcc_options[j] == '\'') |
{ |
char *option; |
|
++j; |
i = j; |
while (collect_gcc_options[j] != '\'') |
++j; |
obstack_init (&env_obstack); |
obstack_grow (&env_obstack, &collect_gcc_options[i], j - i); |
if (seen_dumpbase) |
obstack_grow (&env_obstack, DUMPBASE_SUFFIX, |
sizeof (DUMPBASE_SUFFIX)); |
else |
obstack_1grow (&env_obstack, 0); |
option = XOBFINISH (&env_obstack, char *); |
if (seen_dumpbase) |
{ |
dumpbase_suffix = option + 7 + j - i; |
seen_dumpbase = false; |
} |
|
/* LTRANS does not need -fwpa nor -fltrans-*. */ |
if (strncmp (option, "-fwpa", 5) != 0 |
&& strncmp (option, "-fltrans-", 9) != 0) |
{ |
if (strncmp (option, "-dumpbase", 9) == 0) |
seen_dumpbase = true; |
*argv_ptr++ = option; |
} |
} |
*argv_ptr++ = "-fltrans"; |
|
/* Open the LTRANS output list. */ |
if (ltrans_output_list) |
{ |
ltrans_output_list_stream = fopen (ltrans_output_list, "w"); |
if (ltrans_output_list_stream == NULL) |
error ("opening LTRANS output list %s: %m", ltrans_output_list); |
} |
|
for (i = 0; files[i]; ++i) |
{ |
size_t len; |
|
/* If the file is prefixed with a '*', it means that we do not |
need to re-compile it with LTRANS because it has not been |
modified by WPA. Skip it from the command line to |
lto_execute_ltrans, but add it to ltrans_output_list_stream |
so it is linked after we are done. */ |
if (files[i][0] == '*') |
{ |
size_t len = strlen (files[i]) - 1; |
if (ltrans_output_list_stream) |
if (fwrite (&files[i][1], 1, len, ltrans_output_list_stream) < len |
|| fwrite ("\n", 1, 1, ltrans_output_list_stream) < 1) |
error ("writing to LTRANS output list %s: %m", |
ltrans_output_list); |
} |
else |
{ |
char *output_name; |
|
/* Otherwise, add FILES[I] to lto_execute_ltrans command line |
and add the resulting file to LTRANS output list. */ |
|
/* Replace the .o suffix with a .ltrans.o suffix and write |
the resulting name to the LTRANS output list. */ |
obstack_init (&env_obstack); |
obstack_grow (&env_obstack, files[i], strlen (files[i]) - 2); |
obstack_grow (&env_obstack, ".ltrans.o", sizeof (".ltrans.o")); |
output_name = XOBFINISH (&env_obstack, char *); |
if (ltrans_output_list_stream) |
{ |
len = strlen (output_name); |
|
if (fwrite (output_name, 1, len, ltrans_output_list_stream) < len |
|| fwrite ("\n", 1, 1, ltrans_output_list_stream) < 1) |
error ("writing to LTRANS output list %s: %m", |
ltrans_output_list); |
} |
|
argv_ptr[0] = "-o"; |
argv_ptr[1] = output_name; |
argv_ptr[2] = files[i]; |
argv_ptr[3] = NULL; |
|
/* Append a sequence number to -dumpbase for LTRANS. */ |
if (dumpbase_suffix) |
snprintf (dumpbase_suffix, sizeof (DUMPBASE_SUFFIX) - 7, |
"%lu", (unsigned long) i); |
|
/* Execute the driver. */ |
pex = pex_init (0, "lto1", NULL); |
if (pex == NULL) |
fatal_error ("pex_init failed: %s", xstrerror (errno)); |
|
errmsg = pex_run (pex, PEX_LAST | PEX_SEARCH, argv[0], |
CONST_CAST (char **, argv), NULL, NULL, &err); |
if (errmsg) |
fatal_error ("%s: %s", errmsg, xstrerror (err)); |
|
if (!pex_get_status (pex, 1, &status)) |
fatal_error ("can't get program status: %s", xstrerror (errno)); |
|
if (status) |
{ |
if (WIFSIGNALED (status)) |
{ |
int sig = WTERMSIG (status); |
fatal_error ("%s terminated with signal %d [%s]%s", |
argv[0], sig, strsignal (sig), |
WCOREDUMP (status) ? ", core dumped" : ""); |
} |
else |
fatal_error ("%s terminated with status %d", argv[0], status); |
} |
|
pex_free (pex); |
} |
} |
|
/* Close the LTRANS output list. */ |
if (ltrans_output_list_stream && fclose (ltrans_output_list_stream)) |
error ("closing LTRANS output list %s: %m", ltrans_output_list); |
|
obstack_free (&env_obstack, NULL); |
free (argv); |
|
timevar_pop (TV_WHOPR_WPA_LTRANS_EXEC); |
} |
|
|
typedef struct { |
struct pointer_set_t *seen; |
} lto_fixup_data_t; |
|
#define LTO_FIXUP_SUBTREE(t) \ |
do \ |
walk_tree (&(t), lto_fixup_tree, data, NULL); \ |
while (0) |
|
#define LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE(t) \ |
do \ |
{ \ |
if (t) \ |
(t) = gimple_register_type (t); \ |
walk_tree (&(t), lto_fixup_tree, data, NULL); \ |
} \ |
while (0) |
|
static tree lto_fixup_tree (tree *, int *, void *); |
|
/* Return true if T does not need to be fixed up recursively. */ |
|
static inline bool |
no_fixup_p (tree t) |
{ |
return (t == NULL |
|| CONSTANT_CLASS_P (t) |
|| TREE_CODE (t) == IDENTIFIER_NODE); |
} |
|
/* Fix up fields of a tree_common T. DATA points to fix-up states. */ |
|
static void |
lto_fixup_common (tree t, void *data) |
{ |
/* The following re-creates the TYPE_REFERENCE_TO and TYPE_POINTER_TO |
lists. We do not stream TYPE_REFERENCE_TO, TYPE_POINTER_TO or |
TYPE_NEXT_PTR_TO and TYPE_NEXT_REF_TO. |
First remove us from any pointer list we are on. */ |
if (TREE_CODE (t) == POINTER_TYPE) |
{ |
if (TYPE_POINTER_TO (TREE_TYPE (t)) == t) |
TYPE_POINTER_TO (TREE_TYPE (t)) = TYPE_NEXT_PTR_TO (t); |
else |
{ |
tree tem = TYPE_POINTER_TO (TREE_TYPE (t)); |
while (tem && TYPE_NEXT_PTR_TO (tem) != t) |
tem = TYPE_NEXT_PTR_TO (tem); |
if (tem) |
TYPE_NEXT_PTR_TO (tem) = TYPE_NEXT_PTR_TO (t); |
} |
TYPE_NEXT_PTR_TO (t) = NULL_TREE; |
} |
else if (TREE_CODE (t) == REFERENCE_TYPE) |
{ |
if (TYPE_REFERENCE_TO (TREE_TYPE (t)) == t) |
TYPE_REFERENCE_TO (TREE_TYPE (t)) = TYPE_NEXT_REF_TO (t); |
else |
{ |
tree tem = TYPE_REFERENCE_TO (TREE_TYPE (t)); |
while (tem && TYPE_NEXT_REF_TO (tem) != t) |
tem = TYPE_NEXT_REF_TO (tem); |
if (tem) |
TYPE_NEXT_REF_TO (tem) = TYPE_NEXT_REF_TO (t); |
} |
TYPE_NEXT_REF_TO (t) = NULL_TREE; |
} |
|
/* Fixup our type. */ |
LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TREE_TYPE (t)); |
|
/* Second put us on the list of pointers of the new pointed-to type |
if we are a main variant. This is done in lto_fixup_type after |
fixing up our main variant. */ |
|
/* This is not very efficient because we cannot do tail-recursion with |
a long chain of trees. */ |
LTO_FIXUP_SUBTREE (TREE_CHAIN (t)); |
} |
|
/* Fix up fields of a decl_minimal T. DATA points to fix-up states. */ |
|
static void |
lto_fixup_decl_minimal (tree t, void *data) |
{ |
lto_fixup_common (t, data); |
LTO_FIXUP_SUBTREE (DECL_NAME (t)); |
LTO_FIXUP_SUBTREE (DECL_CONTEXT (t)); |
} |
|
/* Fix up fields of a decl_common T. DATA points to fix-up states. */ |
|
static void |
lto_fixup_decl_common (tree t, void *data) |
{ |
lto_fixup_decl_minimal (t, data); |
LTO_FIXUP_SUBTREE (DECL_SIZE (t)); |
LTO_FIXUP_SUBTREE (DECL_SIZE_UNIT (t)); |
LTO_FIXUP_SUBTREE (DECL_INITIAL (t)); |
LTO_FIXUP_SUBTREE (DECL_ATTRIBUTES (t)); |
LTO_FIXUP_SUBTREE (DECL_ABSTRACT_ORIGIN (t)); |
} |
|
/* Fix up fields of a decl_with_vis T. DATA points to fix-up states. */ |
|
static void |
lto_fixup_decl_with_vis (tree t, void *data) |
{ |
lto_fixup_decl_common (t, data); |
|
/* Accessor macro has side-effects, use field-name here. */ |
LTO_FIXUP_SUBTREE (t->decl_with_vis.assembler_name); |
|
gcc_assert (no_fixup_p (DECL_SECTION_NAME (t))); |
} |
|
/* Fix up fields of a decl_non_common T. DATA points to fix-up states. */ |
|
static void |
lto_fixup_decl_non_common (tree t, void *data) |
{ |
lto_fixup_decl_with_vis (t, data); |
LTO_FIXUP_SUBTREE (DECL_ARGUMENT_FLD (t)); |
LTO_FIXUP_SUBTREE (DECL_RESULT_FLD (t)); |
LTO_FIXUP_SUBTREE (DECL_VINDEX (t)); |
|
/* SAVED_TREE should not cleared by now. Also no accessor for base type. */ |
gcc_assert (no_fixup_p (t->decl_non_common.saved_tree)); |
} |
|
/* Fix up fields of a decl_non_common T. DATA points to fix-up states. */ |
|
static void |
lto_fixup_function (tree t, void *data) |
{ |
lto_fixup_decl_non_common (t, data); |
LTO_FIXUP_SUBTREE (DECL_FUNCTION_PERSONALITY (t)); |
} |
|
/* Fix up fields of a field_decl T. DATA points to fix-up states. */ |
|
static void |
lto_fixup_field_decl (tree t, void *data) |
{ |
lto_fixup_decl_common (t, data); |
LTO_FIXUP_SUBTREE (DECL_FIELD_OFFSET (t)); |
LTO_FIXUP_SUBTREE (DECL_BIT_FIELD_TYPE (t)); |
LTO_FIXUP_SUBTREE (DECL_QUALIFIER (t)); |
gcc_assert (no_fixup_p (DECL_FIELD_BIT_OFFSET (t))); |
LTO_FIXUP_SUBTREE (DECL_FCONTEXT (t)); |
} |
|
/* Fix up fields of a type T. DATA points to fix-up states. */ |
|
static void |
lto_fixup_type (tree t, void *data) |
{ |
tree tem, mv; |
|
lto_fixup_common (t, data); |
LTO_FIXUP_SUBTREE (TYPE_CACHED_VALUES (t)); |
LTO_FIXUP_SUBTREE (TYPE_SIZE (t)); |
LTO_FIXUP_SUBTREE (TYPE_SIZE_UNIT (t)); |
LTO_FIXUP_SUBTREE (TYPE_ATTRIBUTES (t)); |
LTO_FIXUP_SUBTREE (TYPE_NAME (t)); |
|
/* Accessors are for derived node types only. */ |
if (!POINTER_TYPE_P (t)) |
LTO_FIXUP_SUBTREE (t->type.minval); |
LTO_FIXUP_SUBTREE (t->type.maxval); |
|
/* Accessor is for derived node types only. */ |
LTO_FIXUP_SUBTREE (t->type.binfo); |
|
if (TYPE_CONTEXT (t)) |
{ |
if (TYPE_P (TYPE_CONTEXT (t))) |
LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TYPE_CONTEXT (t)); |
else |
LTO_FIXUP_SUBTREE (TYPE_CONTEXT (t)); |
} |
LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TYPE_CANONICAL (t)); |
|
/* 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. */ |
|
/* 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; |
} |
|
/* Finally adjust our main variant and fix it up. */ |
TYPE_MAIN_VARIANT (t) = mv; |
LTO_FIXUP_SUBTREE (TYPE_MAIN_VARIANT (t)); |
|
/* As the second step of reconstructing the pointer chains put us |
on the list of pointers of the new pointed-to type |
if we are a main variant. See lto_fixup_common for the first step. */ |
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; |
} |
} |
|
/* Fix up fields of a BINFO T. DATA points to fix-up states. */ |
|
static void |
lto_fixup_binfo (tree t, void *data) |
{ |
unsigned HOST_WIDE_INT i, n; |
tree base, saved_base; |
|
lto_fixup_common (t, data); |
gcc_assert (no_fixup_p (BINFO_OFFSET (t))); |
LTO_FIXUP_SUBTREE (BINFO_VTABLE (t)); |
LTO_FIXUP_SUBTREE (BINFO_VIRTUALS (t)); |
LTO_FIXUP_SUBTREE (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_SUBTREE (base); |
if (base != saved_base) |
VEC_replace (tree, BINFO_BASE_ACCESSES (t), i, base); |
} |
LTO_FIXUP_SUBTREE (BINFO_INHERITANCE_CHAIN (t)); |
LTO_FIXUP_SUBTREE (BINFO_SUBVTT_INDEX (t)); |
LTO_FIXUP_SUBTREE (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_SUBTREE (base); |
if (base != saved_base) |
VEC_replace (tree, BINFO_BASE_BINFOS (t), i, base); |
} |
} |
|
/* Fix up fields of a CONSTRUCTOR T. DATA points to fix-up states. */ |
|
static void |
lto_fixup_constructor (tree t, void *data) |
{ |
unsigned HOST_WIDE_INT idx; |
constructor_elt *ce; |
|
LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TREE_TYPE (t)); |
|
for (idx = 0; |
VEC_iterate(constructor_elt, CONSTRUCTOR_ELTS (t), idx, ce); |
idx++) |
{ |
LTO_FIXUP_SUBTREE (ce->index); |
LTO_FIXUP_SUBTREE (ce->value); |
} |
} |
|
/* A walk_tree callback used by lto_fixup_state. TP is the pointer to the |
current tree. WALK_SUBTREES indicates if the subtrees will be walked. |
DATA is a pointer set to record visited nodes. */ |
|
static tree |
lto_fixup_tree (tree *tp, int *walk_subtrees, void *data) |
{ |
tree t; |
lto_fixup_data_t *fixup_data = (lto_fixup_data_t *) data; |
tree prevailing; |
|
t = *tp; |
*walk_subtrees = 0; |
if (pointer_set_contains (fixup_data->seen, t)) |
return NULL; |
|
if (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == FUNCTION_DECL) |
{ |
prevailing = lto_symtab_prevailing_decl (t); |
|
if (t != prevailing) |
{ |
if (TREE_CODE (t) == FUNCTION_DECL |
&& TREE_NOTHROW (prevailing) != TREE_NOTHROW (t)) |
{ |
/* If the prevailing definition does not throw but the |
declaration (T) was considered throwing, then we |
simply add PREVAILING to the list of throwing |
functions. However, if the opposite is true, then |
the call to PREVAILING was generated assuming that |
the function didn't throw, which means that CFG |
cleanup may have removed surrounding try/catch |
regions. |
|
Note that we currently accept these cases even when |
they occur within a single file. It's certainly a |
user error, but we silently allow the compiler to |
remove surrounding try/catch regions. Perhaps we |
could emit a warning here, instead of silently |
accepting the conflicting declaration. */ |
if (TREE_NOTHROW (prevailing)) |
lto_mark_nothrow_fndecl (prevailing); |
} |
|
/* Also replace t with prevailing defintion. We don't want to |
insert the other defintion in the seen set as we want to |
replace all instances of it. */ |
*tp = prevailing; |
t = prevailing; |
} |
} |
else if (TYPE_P (t)) |
{ |
/* Replace t with the prevailing type. We don't want to insert the |
other type in the seen set as we want to replace all instances of it. */ |
t = gimple_register_type (t); |
*tp = t; |
} |
|
if (pointer_set_insert (fixup_data->seen, t)) |
return NULL; |
|
/* walk_tree does not visit all reachable nodes that need to be fixed up. |
Hence we do special processing here for those kind of nodes. */ |
switch (TREE_CODE (t)) |
{ |
case FIELD_DECL: |
lto_fixup_field_decl (t, data); |
break; |
|
case LABEL_DECL: |
case CONST_DECL: |
case PARM_DECL: |
case RESULT_DECL: |
case IMPORTED_DECL: |
lto_fixup_decl_common (t, data); |
break; |
|
case VAR_DECL: |
lto_fixup_decl_with_vis (t, data); |
break; |
|
case TYPE_DECL: |
lto_fixup_decl_non_common (t, data); |
break; |
|
case FUNCTION_DECL: |
lto_fixup_function (t, data); |
break; |
|
case TREE_BINFO: |
lto_fixup_binfo (t, data); |
break; |
|
default: |
if (TYPE_P (t)) |
lto_fixup_type (t, data); |
else if (TREE_CODE (t) == CONSTRUCTOR) |
lto_fixup_constructor (t, data); |
else if (CONSTANT_CLASS_P (t)) |
LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TREE_TYPE (t)); |
else if (EXPR_P (t)) |
{ |
/* walk_tree only handles TREE_OPERANDs. Do the rest here. */ |
lto_fixup_common (t, data); |
LTO_FIXUP_SUBTREE (t->exp.block); |
*walk_subtrees = 1; |
} |
else |
{ |
/* Let walk_tree handle sub-trees. */ |
*walk_subtrees = 1; |
} |
} |
|
return NULL; |
} |
|
/* Helper function of lto_fixup_decls. Walks the var and fn streams in STATE, |
replaces var and function decls with the corresponding prevailing def and |
records the old decl in the free-list in DATA. We also record visted nodes |
in the seen-set in DATA to avoid multiple visit for nodes that need not |
to be replaced. */ |
|
static void |
lto_fixup_state (struct lto_in_decl_state *state, lto_fixup_data_t *data) |
{ |
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++) |
walk_tree (table->trees + i, lto_fixup_tree, data, NULL); |
} |
} |
|
/* A callback of htab_traverse. Just extract a state from SLOT and the |
lto_fixup_data_t object from AUX and calls lto_fixup_state. */ |
|
static int |
lto_fixup_state_aux (void **slot, void *aux) |
{ |
struct lto_in_decl_state *state = (struct lto_in_decl_state *) *slot; |
lto_fixup_state (state, (lto_fixup_data_t *) aux); |
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; |
tree decl; |
struct pointer_set_t *seen = pointer_set_create (); |
lto_fixup_data_t data; |
|
data.seen = seen; |
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, &data); |
|
htab_traverse (file->function_decl_states, lto_fixup_state_aux, &data); |
} |
|
for (i = 0; VEC_iterate (tree, lto_global_var_decls, i, decl); i++) |
{ |
tree saved_decl = decl; |
walk_tree (&decl, lto_fixup_tree, &data, NULL); |
if (decl != saved_decl) |
VEC_replace (tree, lto_global_var_decls, i, decl); |
} |
|
pointer_set_destroy (seen); |
} |
|
/* Unlink a temporary LTRANS file unless requested otherwise. */ |
|
static void |
lto_maybe_unlink (const char *file) |
{ |
if (!getenv ("WPA_SAVE_LTRANS")) |
{ |
if (unlink_if_ordinary (file)) |
error ("deleting LTRANS input file %s: %m", file); |
} |
else |
fprintf (stderr, "[Leaving LTRANS input file %s]\n", file); |
} |
|
/* Read the options saved from each file in the command line. Called |
from lang_hooks.post_options which is called by process_options |
right before all the options are used to initialize the compiler. |
This assumes that decode_options has already run, so the |
num_in_fnames and in_fnames are properly set. |
|
Note that this assumes that all the files had been compiled with |
the same options, which is not a good assumption. In general, |
options ought to be read from all the files in the set and merged. |
However, it is still unclear what the merge rules should be. */ |
|
void |
lto_read_all_file_options (void) |
{ |
size_t i; |
|
/* Clear any file options currently saved. */ |
lto_clear_file_options (); |
|
/* Set the hooks to read ELF sections. */ |
lto_set_in_hooks (NULL, get_section_data, free_section_data); |
|
for (i = 0; i < num_in_fnames; i++) |
{ |
struct lto_file_decl_data *file_data; |
lto_file *file = lto_obj_file_open (in_fnames[i], false); |
if (!file) |
break; |
|
file_data = XCNEW (struct lto_file_decl_data); |
file_data->file_name = file->filename; |
file_data->section_hash_table = lto_obj_build_section_table (file); |
|
lto_read_file_options (file_data); |
|
lto_obj_file_close (file); |
htab_delete (file_data->section_hash_table); |
free (file_data); |
} |
|
/* Apply globally the options read from all the files. */ |
lto_reissue_options (); |
} |
|
|
/* 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; |
struct lto_file_decl_data **all_file_decl_data; |
FILE *resolution; |
struct cgraph_node *node; |
|
lto_stats.num_input_files = nfiles; |
|
timevar_push (TV_IPA_LTO_DECL_IO); |
|
/* Set the hooks so that all of the ipa passes can read in their data. */ |
all_file_decl_data = XNEWVEC (struct lto_file_decl_data *, nfiles + 1); |
lto_set_in_hooks (all_file_decl_data, get_section_data, free_section_data); |
|
/* 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: %s", |
xstrerror (errno)); |
|
t = fscanf (resolution, "%u", &num_objects); |
gcc_assert (t == 1); |
|
/* True, since the plugin splits the archives. */ |
gcc_assert (num_objects == nfiles); |
} |
|
/* 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; |
|
current_lto_file = lto_obj_file_open (fnames[i], false); |
if (!current_lto_file) |
break; |
|
file_data = lto_file_read (current_lto_file, resolution); |
if (!file_data) |
break; |
|
all_file_decl_data[last_file_ix++] = file_data; |
|
lto_obj_file_close (current_lto_file); |
current_lto_file = NULL; |
} |
|
if (resolution_file_name) |
fclose (resolution); |
|
all_file_decl_data[last_file_ix] = NULL; |
|
/* 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); |
|
/* Each pass will set the appropriate timer. */ |
timevar_pop (TV_IPA_LTO_DECL_IO); |
|
/* Read the callgraph. */ |
input_cgraph (); |
|
/* Merge global decls. */ |
lto_symtab_merge_decls (); |
|
/* Fixup all decls and types and free the type hash tables. */ |
lto_fixup_decls (all_file_decl_data); |
free_gimple_type_tables (); |
|
/* Read the IPA summary data. */ |
ipa_read_summaries (); |
|
/* Finally merge the cgraph according to the decl merging decisions. */ |
lto_symtab_merge_cgraph_nodes (); |
|
/* Mark cgraph nodes needed in the merged cgraph |
This normally happens in whole-program pass, but for |
ltrans the pass was already run at WPA phase. |
|
FIXME: This is not valid way to do so; nodes can be needed |
for non-obvious reasons. We should stream the flags from WPA |
phase. */ |
if (flag_ltrans) |
for (node = cgraph_nodes; node; node = node->next) |
{ |
if (!node->global.inlined_to |
&& cgraph_decide_is_function_needed (node, node->decl)) |
cgraph_mark_needed_node (node); |
/* 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); |
} |
|
timevar_push (TV_IPA_LTO_DECL_IO); |
|
/* FIXME lto. This loop needs to be changed to use the pass manager to |
call the ipa passes directly. */ |
if (!errorcount) |
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_IO); |
} |
|
|
/* 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; |
|
/* 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_IO); |
|
for (node = cgraph_nodes; node; node = node->next) |
{ |
/* Some cgraph nodes get created on the fly, and they don't need |
to be materialized. For instance, nodes for nested functions |
where the parent function was not streamed out or builtin |
functions. Additionally, builtin functions should not be |
materialized and may, in fact, cause confusion because there |
may be a regular function in the file whose assembler name |
matches that of the function. |
See gcc.c-torture/execute/20030125-1.c and |
gcc.c-torture/execute/921215-1.c. */ |
if (node->local.lto_file_data |
&& !DECL_IS_BUILTIN (node->decl)) |
{ |
lto_materialize_function (node); |
lto_stats.num_input_cgraph_nodes++; |
} |
} |
|
timevar_pop (TV_IPA_LTO_GIMPLE_IO); |
|
/* 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 (i = 0; VEC_iterate (tree, lto_global_var_decls, i, decl); i++) |
rest_of_decl_compilation (decl, 1, 0); |
|
/* Fix up any calls to DECLs that have become not exception throwing. */ |
lto_fixup_nothrow_decls (); |
|
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) |
{ |
char **output_files; |
size_t i; |
struct cgraph_node *node; |
|
lto_1_to_1_map (); |
|
/* 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); |
|
/* FIXME lto. Hack. We should use the IPA passes. There are a |
number of issues with this now. 1. There is no convenient way to |
do this. 2. Some passes may depend on properties that requires |
the function bodies to compute. */ |
cgraph_function_flags_ready = true; |
bitmap_obstack_initialize (NULL); |
ipa_register_cgraph_hooks (); |
|
/* Reset inlining information before running IPA inliner. */ |
for (node = cgraph_nodes; node; node = node->next) |
reset_inline_failed (node); |
|
/* FIXME lto. We should not call this function directly. */ |
pass_ipa_inline.pass.execute (); |
|
verify_cgraph (); |
bitmap_obstack_release (NULL); |
|
/* We are about to launch the final LTRANS phase, stop the WPA timer. */ |
timevar_pop (TV_WHOPR_WPA); |
|
output_files = lto_wpa_write_files (); |
|
/* Show the LTO report before launching LTRANS. */ |
if (flag_lto_report) |
print_lto_report (); |
|
lto_execute_ltrans (output_files); |
|
for (i = 0; output_files[i]; ++i) |
{ |
if (output_files[i][0] != '*') |
lto_maybe_unlink (output_files[i]); |
|
free (output_files[i]); |
} |
|
XDELETEVEC (output_files); |
} |
|
|
/* 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 (int debug_p ATTRIBUTE_UNUSED) |
{ |
lto_init_reader (); |
|
/* 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 (!errorcount) |
{ |
/* 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-src/gcc-4.5.1/gcc/lto/lto.c
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: openrisc/trunk/gnu-src/gcc-4.5.1/gcc/lto/lto-endian.h
===================================================================
--- openrisc/trunk/gnu-src/gcc-4.5.1/gcc/lto/lto-endian.h (nonexistent)
+++ openrisc/trunk/gnu-src/gcc-4.5.1/gcc/lto/lto-endian.h (revision 288)
@@ -0,0 +1,205 @@
+/* Very simple endian-ness layer for LTO object file handling
+ Copyright 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
+
+#include
+
+static inline uint16_t
+get_uint16_le (const unsigned char *ptr)
+{
+ return ptr[0] | (ptr[1] << 8);
+}
+
+static inline uint32_t
+get_uint32_le (const unsigned char *ptr)
+{
+ return ptr[0] | (ptr[1] << 8) | (ptr[2] << 16) | (ptr[3] << 24);
+}
+
+static inline uint64_t
+get_uint64_le (const unsigned char *ptr_)
+{
+#define ptr (uint64_t) ptr_
+ return ptr[0] | (ptr[1] << 8) | (ptr[2] << 16) | (ptr[3] << 24)
+ | (ptr[4] << 32) | (ptr[5] << 40) | (ptr[6] << 48) | (ptr[7] << 56);
+#undef ptr
+}
+
+static inline uint16_t
+get_uint16_be (const unsigned char *ptr)
+{
+ return ptr[1] | (ptr[2] << 8);
+}
+
+static inline uint32_t
+get_uint32_be (const unsigned char *ptr)
+{
+ return ptr[3] | (ptr[2] << 8) | (ptr[1] << 16) | (ptr[0] << 24);
+}
+
+static inline uint64_t
+get_uint64_be (const unsigned char *ptr_)
+{
+#define ptr (uint64_t) ptr_
+ return ptr[7] | (ptr[6] << 8) | (ptr[5] << 16) | (ptr[4] << 24)
+ | (ptr[3] << 32) | (ptr[2] << 40) | (ptr[1] << 48) | (ptr[0] << 56);
+#undef ptr
+}
+
+static inline void
+put_uint16_le (unsigned char *ptr, uint16_t data)
+{
+ ptr[0] = data & 0xff;
+ ptr[1] = (data >> 8) & 0xff;
+}
+
+static inline void
+put_uint32_le (unsigned char *ptr, uint32_t data)
+{
+ ptr[0] = data & 0xff;
+ ptr[1] = (data >> 8) & 0xff;
+ ptr[2] = (data >> 16) & 0xff;
+ ptr[3] = (data >> 24) & 0xff;
+}
+
+static inline void
+put_uint64_le (unsigned char *ptr, uint64_t data)
+{
+ ptr[0] = data & 0xff;
+ ptr[1] = (data >> 8) & 0xff;
+ ptr[2] = (data >> 16) & 0xff;
+ ptr[3] = (data >> 24) & 0xff;
+ ptr[4] = (data >> 32) & 0xff;
+ ptr[5] = (data >> 40) & 0xff;
+ ptr[6] = (data >> 48) & 0xff;
+ ptr[7] = (data >> 56) & 0xff;
+}
+
+static inline void
+put_uint16_be (unsigned char *ptr, uint16_t data)
+{
+ ptr[1] = data & 0xff;
+ ptr[0] = (data >> 8) & 0xff;
+}
+
+static inline void
+put_uint32_be (unsigned char *ptr, uint32_t data)
+{
+ ptr[3] = data & 0xff;
+ ptr[2] = (data >> 8) & 0xff;
+ ptr[1] = (data >> 16) & 0xff;
+ ptr[0] = (data >> 24) & 0xff;
+}
+
+static inline void
+put_uint64_be (unsigned char *ptr, uint64_t data)
+{
+ ptr[7] = data & 0xff;
+ ptr[6] = (data >> 8) & 0xff;
+ ptr[5] = (data >> 16) & 0xff;
+ ptr[4] = (data >> 24) & 0xff;
+ ptr[3] = (data >> 32) & 0xff;
+ ptr[2] = (data >> 40) & 0xff;
+ ptr[1] = (data >> 48) & 0xff;
+ ptr[0] = (data >> 56) & 0xff;
+}
+
+static inline void
+get_string (unsigned char *ptr, char *dest, size_t len)
+{
+ memcpy (dest, ptr, len);
+}
+
+static inline void
+put_string (unsigned char *ptr, char *src, size_t len)
+{
+ memcpy (ptr, src, len);
+}
+
+/* Use the target macro BYTES_BIG_ENDIAN to choose. */
+
+static inline uint16_t
+get_uint16 (const unsigned char *ptr)
+{
+ if (BYTES_BIG_ENDIAN)
+ return get_uint16_be (ptr);
+ else
+ return get_uint16_le (ptr);
+}
+
+static inline uint32_t
+get_uint32 (const unsigned char *ptr)
+{
+ if (BYTES_BIG_ENDIAN)
+ return get_uint32_be (ptr);
+ else
+ return get_uint32_le (ptr);
+}
+
+static inline uint64_t
+get_uint64 (const unsigned char *ptr)
+{
+ if (BYTES_BIG_ENDIAN)
+ return get_uint64_be (ptr);
+ else
+ return get_uint64_le (ptr);
+}
+
+static inline void
+put_uint16 (unsigned char *ptr, uint16_t data)
+{
+ if (BYTES_BIG_ENDIAN)
+ put_uint16_be (ptr, data);
+ else
+ put_uint16_le (ptr, data);
+}
+
+static inline void
+put_uint32 (unsigned char *ptr, uint32_t data)
+{
+ if (BYTES_BIG_ENDIAN)
+ put_uint32_be (ptr, data);
+ else
+ put_uint32_le (ptr, data);
+}
+
+static inline void
+put_uint64 (unsigned char *ptr, uint64_t data)
+{
+ if (BYTES_BIG_ENDIAN)
+ put_uint64_be (ptr, data);
+ else
+ put_uint64_le (ptr, data);
+}
+
+#endif /* GCC_LTO_ENDIAN_H */
+
openrisc/trunk/gnu-src/gcc-4.5.1/gcc/lto/lto-endian.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: openrisc/trunk/gnu-src/gcc-4.5.1/gcc/lto/lto-tree.h
===================================================================
--- openrisc/trunk/gnu-src/gcc-4.5.1/gcc/lto/lto-tree.h (nonexistent)
+++ openrisc/trunk/gnu-src/gcc-4.5.1/gcc/lto/lto-tree.h (revision 288)
@@ -0,0 +1,61 @@
+/* Language-dependent trees for LTO.
+ 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
+
openrisc/trunk/gnu-src/gcc-4.5.1/gcc/lto/lto-tree.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: openrisc/trunk/gnu-src/gcc-4.5.1/gcc/lto/lang-specs.h
===================================================================
--- openrisc/trunk/gnu-src/gcc-4.5.1/gcc/lto/lang-specs.h (nonexistent)
+++ openrisc/trunk/gnu-src/gcc-4.5.1/gcc/lto/lang-specs.h (revision 288)
@@ -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
+
openrisc/trunk/gnu-src/gcc-4.5.1/gcc/lto/lang-specs.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: openrisc/trunk/gnu-src/gcc-4.5.1/gcc/lto/lang.opt
===================================================================
--- openrisc/trunk/gnu-src/gcc-4.5.1/gcc/lto/lang.opt (nonexistent)
+++ openrisc/trunk/gnu-src/gcc-4.5.1/gcc/lto/lang.opt (revision 288)
@@ -0,0 +1,43 @@
+; Options for the LTO front end.
+; Copyright (C) 2008 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
+;
+#include "lto.h"
+#include "tm.h"
+#include "libiberty.h"
+#include "ggc.h"
+#include "lto-streamer.h"
+
+/* Cater to hosts with half-backed file like HP-UX. */
+#ifndef EM_SPARC
+# define EM_SPARC 2
+#endif
+
+#ifndef EM_SPARC32PLUS
+# define EM_SPARC32PLUS 18
+#endif
+
+
+/* Handle opening elf files on hosts, such as Windows, that may use
+ text file handling that will break binary access. */
+#ifndef O_BINARY
+# define O_BINARY 0
+#endif
+
+
+/* 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;
+}
+
+/* An ELF file. */
+struct lto_elf_file
+{
+ /* The base information. */
+ lto_file base;
+
+ /* The system file descriptor for the file. */
+ int fd;
+
+ /* The libelf descriptor for the file. */
+ Elf *elf;
+
+ /* Section number of string table used for section names. */
+ size_t sec_strtab;
+
+ /* Writable file members. */
+
+ /* The currently active section. */
+ Elf_Scn *scn;
+
+ /* The output stream for section header names. */
+ struct lto_output_stream *shstrtab_stream;
+
+ /* Linked list of data which must be freed *after* the file has been
+ closed. This is an annoying limitation of libelf. */
+ struct lto_char_ptr_base *data;
+};
+typedef struct lto_elf_file lto_elf_file;
+
+/* Stores executable header attributes which must be shared by all ELF files.
+ This is used for validating input files and populating output files. */
+static struct {
+ bool initialized;
+ /* 32 or 64 bits? */
+ size_t bits;
+ unsigned char elf_ident[EI_NIDENT];
+ Elf64_Half elf_machine;
+} cached_file_attrs;
+
+
+/* Return the section header for SECTION. The return value is never
+ NULL. Call lto_elf_free_shdr to release the memory allocated. */
+
+static Elf64_Shdr *
+lto_elf_get_shdr (Elf_Scn *section)
+{
+ Elf64_Shdr *shdr;
+
+ switch (cached_file_attrs.bits)
+ {
+ case 32:
+ {
+ Elf32_Shdr *shdr32;
+
+ /* Read the 32-bit section header. */
+ shdr32 = elf32_getshdr (section);
+ if (!shdr32)
+ fatal_error ("could not read section header: %s", elf_errmsg (0));
+
+ /* Transform it into a 64-bit section header. */
+ shdr = XNEW (Elf64_Shdr);
+ shdr->sh_name = shdr32->sh_name;
+ shdr->sh_type = shdr32->sh_type;
+ shdr->sh_flags = shdr32->sh_flags;
+ shdr->sh_addr = shdr32->sh_addr;
+ shdr->sh_offset = shdr32->sh_offset;
+ shdr->sh_size = shdr32->sh_size;
+ shdr->sh_link = shdr32->sh_link;
+ shdr->sh_info = shdr32->sh_info;
+ shdr->sh_addralign = shdr32->sh_addralign;
+ shdr->sh_entsize = shdr32->sh_entsize;
+ break;
+ }
+ break;
+
+ case 64:
+ shdr = elf64_getshdr (section);
+ if (!shdr)
+ fatal_error ("could not read section header: %s", elf_errmsg (0));
+ break;
+
+ default:
+ gcc_unreachable ();
+ }
+
+ return shdr;
+}
+
+/* Free SHDR, previously allocated by lto_elf_get_shdr. */
+static void
+lto_elf_free_shdr (Elf64_Shdr *shdr)
+{
+ if (cached_file_attrs.bits != 64)
+ free (shdr);
+}
+
+
+/* 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;
+}
+
+
+/* Build a hash table whose key is the section names 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)
+{
+ lto_elf_file *elf_file = (lto_elf_file *)lto_file;
+ htab_t section_hash_table;
+ Elf_Scn *section;
+ size_t base_offset;
+
+ section_hash_table = htab_create (37, hash_name, eq_name, free);
+
+ base_offset = elf_getbase (elf_file->elf);
+ /* We are reasonably sure that elf_getbase does not fail at this
+ point. So assume that we run into the incompatibility with
+ the FreeBSD libelf implementation that has a non-working
+ elf_getbase for non-archive members in which case the offset
+ should be zero. */
+ if (base_offset == (size_t)-1)
+ base_offset = 0;
+ for (section = elf_getscn (elf_file->elf, 0);
+ section;
+ section = elf_nextscn (elf_file->elf, section))
+ {
+ Elf64_Shdr *shdr;
+ const char *name;
+ size_t offset;
+ char *new_name;
+ void **slot;
+ struct lto_section_slot s_slot;
+
+ /* Get the name of this section. */
+ shdr = lto_elf_get_shdr (section);
+ offset = shdr->sh_name;
+ name = elf_strptr (elf_file->elf,
+ elf_file->sec_strtab,
+ offset);
+
+ /* Only put lto stuff into the symtab. */
+ if (strncmp (name, LTO_SECTION_NAME_PREFIX,
+ strlen (LTO_SECTION_NAME_PREFIX)) != 0)
+ {
+ lto_elf_free_shdr (shdr);
+ continue;
+ }
+
+ new_name = XNEWVEC (char, strlen (name) + 1);
+ strcpy (new_name, 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 = XNEW (struct lto_section_slot);
+
+ new_slot->name = new_name;
+ /* The offset into the file for this section. */
+ new_slot->start = base_offset + shdr->sh_offset;
+ new_slot->len = shdr->sh_size;
+ *slot = new_slot;
+ }
+ else
+ {
+ error ("two or more sections for %s:", new_name);
+ return NULL;
+ }
+
+ lto_elf_free_shdr (shdr);
+ }
+
+ return section_hash_table;
+}
+
+
+/* Initialize the section header of section SCN. SH_NAME is the section name
+ as an index into the section header string table. SH_TYPE is the section
+ type, an SHT_* macro from libelf headers. */
+
+#define DEFINE_INIT_SHDR(BITS) \
+static void \
+init_shdr##BITS (Elf_Scn *scn, size_t sh_name, size_t sh_type) \
+{ \
+ Elf##BITS##_Shdr *shdr; \
+ \
+ shdr = elf##BITS##_getshdr (scn); \
+ if (!shdr) \
+ { \
+ if (BITS == 32) \
+ fatal_error ("elf32_getshdr() failed: %s", elf_errmsg (-1)); \
+ else \
+ fatal_error ("elf64_getshdr() failed: %s", elf_errmsg (-1)); \
+ } \
+ \
+ shdr->sh_name = sh_name; \
+ shdr->sh_type = sh_type; \
+ shdr->sh_addralign = POINTER_SIZE / BITS_PER_UNIT; \
+ shdr->sh_flags = 0; \
+ shdr->sh_entsize = 0; \
+}
+
+DEFINE_INIT_SHDR (32)
+DEFINE_INIT_SHDR (64)
+
+static bool first_data_block;
+
+/* Begin a new ELF section named NAME with type TYPE in the current output
+ file. TYPE is an SHT_* macro from the libelf headers. */
+
+static void
+lto_elf_begin_section_with_type (const char *name, size_t type)
+{
+ lto_elf_file *file;
+ Elf_Scn *scn;
+ size_t sh_name;
+
+ /* Grab the current output file and do some basic assertion checking. */
+ file = (lto_elf_file *) lto_get_current_out_file (),
+ gcc_assert (file);
+ gcc_assert (file->elf);
+ gcc_assert (!file->scn);
+
+ /* Create a new section. */
+ scn = elf_newscn (file->elf);
+ if (!scn)
+ fatal_error ("could not create a new ELF section: %s", elf_errmsg (-1));
+ file->scn = scn;
+
+ /* Add a string table entry and record the offset. */
+ gcc_assert (file->shstrtab_stream);
+ sh_name = file->shstrtab_stream->total_size;
+ lto_output_data_stream (file->shstrtab_stream, name, strlen (name) + 1);
+
+ /* Initialize the section header. */
+ switch (cached_file_attrs.bits)
+ {
+ case 32:
+ init_shdr32 (scn, sh_name, type);
+ break;
+
+ case 64:
+ init_shdr64 (scn, sh_name, type);
+ break;
+
+ default:
+ gcc_unreachable ();
+ }
+
+ first_data_block = true;
+}
+
+
+/* Begin a new ELF section named NAME in the current output file. */
+
+void
+lto_obj_begin_section (const char *name)
+{
+ lto_elf_begin_section_with_type (name, SHT_PROGBITS);
+}
+
+
+/* Append DATA of length LEN to the current output section. BASE is a pointer
+ to the output page containing DATA. It is freed once the output file has
+ been written. */
+
+void
+lto_obj_append_data (const void *data, size_t len, void *block)
+{
+ lto_elf_file *file;
+ Elf_Data *elf_data;
+ struct lto_char_ptr_base *base = (struct lto_char_ptr_base *) block;
+
+ /* Grab the current output file and do some basic assertion checking. */
+ file = (lto_elf_file *) lto_get_current_out_file ();
+ gcc_assert (file);
+ gcc_assert (file->scn);
+
+ elf_data = elf_newdata (file->scn);
+ if (!elf_data)
+ fatal_error ("could not append data to ELF section: %s", elf_errmsg (-1));
+
+ if (first_data_block)
+ {
+ elf_data->d_align = POINTER_SIZE / BITS_PER_UNIT;
+ first_data_block = false;
+ }
+ else
+ elf_data->d_align = 1;
+ elf_data->d_buf = CONST_CAST (void *, data);
+ elf_data->d_off = 0LL;
+ elf_data->d_size = len;
+ elf_data->d_type = ELF_T_BYTE;
+ elf_data->d_version = EV_CURRENT;
+
+ base->ptr = (char *)file->data;
+ file->data = base;
+}
+
+
+/* End the current output section. This just does some assertion checking
+ and sets the current output file's scn member to NULL. */
+
+void
+lto_obj_end_section (void)
+{
+ lto_elf_file *file;
+
+ /* Grab the current output file and validate some basic assertions. */
+ file = (lto_elf_file *) lto_get_current_out_file ();
+ gcc_assert (file);
+ gcc_assert (file->scn);
+
+ file->scn = NULL;
+}
+
+
+/* Return true if ELF_MACHINE is compatible with the cached value of the
+ architecture and possibly update the latter. Return false otherwise.
+
+ Note: if you want to add more EM_* cases, you'll need to provide the
+ corresponding definitions at the beginning of the file. */
+
+static bool
+is_compatible_architecture (Elf64_Half elf_machine)
+{
+ if (cached_file_attrs.elf_machine == elf_machine)
+ return true;
+
+ switch (cached_file_attrs.elf_machine)
+ {
+ case EM_SPARC:
+ if (elf_machine == EM_SPARC32PLUS)
+ {
+ cached_file_attrs.elf_machine = elf_machine;
+ return true;
+ }
+ break;
+
+ case EM_SPARC32PLUS:
+ if (elf_machine == EM_SPARC)
+ return true;
+ break;
+
+ default:
+ break;
+ }
+
+ return false;
+}
+
+
+/* Validate's ELF_FILE's executable header and, if cached_file_attrs is
+ uninitialized, caches the architecture. */
+
+#define DEFINE_VALIDATE_EHDR(BITS) \
+static bool \
+validate_ehdr##BITS (lto_elf_file *elf_file) \
+{ \
+ Elf##BITS##_Ehdr *elf_header; \
+ \
+ elf_header = elf##BITS##_getehdr (elf_file->elf); \
+ if (!elf_header) \
+ { \
+ error ("could not read ELF header: %s", elf_errmsg (0)); \
+ return false; \
+ } \
+ \
+ if (elf_header->e_type != ET_REL) \
+ { \
+ error ("not a relocatable ELF object file"); \
+ return false; \
+ } \
+ \
+ if (!cached_file_attrs.initialized) \
+ cached_file_attrs.elf_machine = elf_header->e_machine; \
+ else if (!is_compatible_architecture (elf_header->e_machine)) \
+ { \
+ error ("inconsistent file architecture detected"); \
+ return false; \
+ } \
+ \
+ return true; \
+}
+
+DEFINE_VALIDATE_EHDR (32)
+DEFINE_VALIDATE_EHDR (64)
+
+
+#ifndef HAVE_ELF_GETSHDRSTRNDX
+/* elf_getshdrstrndx replacement for systems that lack it, but provide
+ either the gABI conformant or Solaris 2 variant of elf_getshstrndx
+ instead. */
+
+static int
+elf_getshdrstrndx (Elf *elf, size_t *dst)
+{
+#ifdef HAVE_ELF_GETSHSTRNDX_GABI
+ return elf_getshstrndx (elf, dst);
+#else
+ return elf_getshstrndx (elf, dst) ? 0 : -1;
+#endif
+}
+#endif
+
+/* Validate's ELF_FILE's executable header and, if cached_file_attrs is
+ uninitialized, caches the results. Also records the section header string
+ table's section index. Returns true on success or false on failure. */
+
+static bool
+validate_file (lto_elf_file *elf_file)
+{
+ const char *elf_ident;
+
+ /* Some aspects of the libelf API are dependent on whether the
+ object file is a 32-bit or 64-bit file. Determine which kind of
+ file this is now. */
+ elf_ident = elf_getident (elf_file->elf, NULL);
+ if (!elf_ident)
+ {
+ error ("could not read ELF identification information: %s",
+ elf_errmsg (0));
+ return false;
+
+ }
+
+ if (!cached_file_attrs.initialized)
+ {
+ switch (elf_ident[EI_CLASS])
+ {
+ case ELFCLASS32:
+ cached_file_attrs.bits = 32;
+ break;
+
+ case ELFCLASS64:
+ cached_file_attrs.bits = 64;
+ break;
+
+ default:
+ error ("unsupported ELF file class");
+ return false;
+ }
+
+ memcpy (cached_file_attrs.elf_ident, elf_ident,
+ sizeof cached_file_attrs.elf_ident);
+ }
+
+ if (memcmp (elf_ident, cached_file_attrs.elf_ident,
+ sizeof cached_file_attrs.elf_ident))
+ return false;
+
+ /* Check that the input file is a relocatable object file with the correct
+ architecture. */
+ switch (cached_file_attrs.bits)
+ {
+ case 32:
+ if (!validate_ehdr32 (elf_file))
+ return false;
+ break;
+
+ case 64:
+ if (!validate_ehdr64 (elf_file))
+ return false;
+ break;
+
+ default:
+ gcc_unreachable ();
+ }
+
+ /* Read the string table used for section header names. */
+ if (elf_getshdrstrndx (elf_file->elf, &elf_file->sec_strtab) == -1)
+ {
+ error ("could not locate ELF string table: %s", elf_errmsg (0));
+ return false;
+ }
+
+ cached_file_attrs.initialized = true;
+ return true;
+}
+
+
+/* Helper functions used by init_ehdr. Initialize ELF_FILE's executable
+ header using cached data from previously read files. */
+
+#define DEFINE_INIT_EHDR(BITS) \
+static void \
+init_ehdr##BITS (lto_elf_file *elf_file) \
+{ \
+ Elf##BITS##_Ehdr *ehdr; \
+ \
+ gcc_assert (cached_file_attrs.bits); \
+ \
+ ehdr = elf##BITS##_newehdr (elf_file->elf); \
+ if (!ehdr) \
+ { \
+ if (BITS == 32) \
+ fatal_error ("elf32_newehdr() failed: %s", elf_errmsg (-1)); \
+ else \
+ fatal_error ("elf64_newehdr() failed: %s", elf_errmsg (-1)); \
+ } \
+ \
+ memcpy (ehdr->e_ident, cached_file_attrs.elf_ident, \
+ sizeof cached_file_attrs.elf_ident); \
+ ehdr->e_type = ET_REL; \
+ ehdr->e_version = EV_CURRENT; \
+ ehdr->e_machine = cached_file_attrs.elf_machine; \
+}
+
+DEFINE_INIT_EHDR (32)
+DEFINE_INIT_EHDR (64)
+
+
+/* Initialize ELF_FILE's executable header using cached data from previously
+ read files. */
+
+static void
+init_ehdr (lto_elf_file *elf_file)
+{
+ switch (cached_file_attrs.bits)
+ {
+ case 32:
+ init_ehdr32 (elf_file);
+ break;
+
+ case 64:
+ init_ehdr64 (elf_file);
+ break;
+
+ default:
+ gcc_unreachable ();
+ }
+}
+
+/* Open ELF file FILENAME. If 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)
+{
+ lto_elf_file *elf_file;
+ lto_file *result = NULL;
+ off_t offset;
+ long loffset;
+ off_t header_offset;
+ const char *offset_p;
+ char *fname;
+ int consumed;
+
+ offset_p = strrchr (filename, '@');
+ if (offset_p
+ && offset_p != filename
+ && sscanf (offset_p, "@%li%n", &loffset, &consumed) >= 1
+ && strlen (offset_p) == (unsigned int)consumed)
+ {
+ fname = (char *) xmalloc (offset_p - filename + 1);
+ memcpy (fname, filename, offset_p - filename);
+ fname[offset_p - filename] = '\0';
+ offset = (off_t)loffset;
+ /* elf_rand expects the offset to point to the ar header, not the
+ object itself. Subtract the size of the ar header (60 bytes).
+ We don't uses sizeof (struct ar_hd) to avoid including ar.h */
+ header_offset = offset - 60;
+ }
+ else
+ {
+ fname = xstrdup (filename);
+ offset = 0;
+ header_offset = 0;
+ }
+
+ /* Set up. */
+ elf_file = XCNEW (lto_elf_file);
+ result = (lto_file *) elf_file;
+ lto_file_init (result, fname, offset);
+ elf_file->fd = -1;
+
+ /* Open the file. */
+ elf_file->fd = open (fname, writable ? O_WRONLY|O_CREAT|O_BINARY
+ : O_RDONLY|O_BINARY, 0666);
+ if (elf_file->fd == -1)
+ {
+ error ("could not open file %s", fname);
+ goto fail;
+ }
+
+ /* Initialize the ELF library. */
+ if (elf_version (EV_CURRENT) == EV_NONE)
+ {
+ error ("ELF library is older than that used when building GCC");
+ goto fail;
+ }
+
+ /* Open the ELF file descriptor. */
+ elf_file->elf = elf_begin (elf_file->fd, writable ? ELF_C_WRITE : ELF_C_READ,
+ NULL);
+ if (!elf_file->elf)
+ {
+ error ("could not open ELF file: %s", elf_errmsg (0));
+ goto fail;
+ }
+
+ if (offset != 0)
+ {
+ Elf *e;
+ off_t t = elf_rand (elf_file->elf, header_offset);
+ if (t != header_offset)
+ {
+ error ("could not seek in archive");
+ goto fail;
+ }
+
+ e = elf_begin (elf_file->fd, ELF_C_READ, elf_file->elf);
+ if (e == NULL)
+ {
+ error("could not find archive member");
+ goto fail;
+ }
+ elf_end (elf_file->elf);
+ elf_file->elf = e;
+ }
+
+ if (writable)
+ {
+ init_ehdr (elf_file);
+ elf_file->shstrtab_stream = XCNEW (struct lto_output_stream);
+ /* Output an empty string to the section header table. This becomes the
+ name of the initial NULL section. */
+ lto_output_1_stream (elf_file->shstrtab_stream, '\0');
+ }
+ else
+ if (!validate_file (elf_file))
+ goto fail;
+
+ return result;
+
+ fail:
+ if (result)
+ lto_obj_file_close (result);
+ return NULL;
+}
+
+
+/* Close ELF file FILE and clean up any associated data structures. If FILE
+ was opened for writing, the file's ELF data is written at this time, and
+ any cached data buffers are freed. */
+
+void
+lto_obj_file_close (lto_file *file)
+{
+ lto_elf_file *elf_file = (lto_elf_file *) file;
+ struct lto_char_ptr_base *cur, *tmp;
+
+ /* Write the ELF section header string table. */
+ if (elf_file->shstrtab_stream)
+ {
+ size_t strtab;
+ GElf_Ehdr *ehdr_p, ehdr_buf;
+ lto_file *old_file = lto_set_current_out_file (file);
+
+ lto_elf_begin_section_with_type (".shstrtab", SHT_STRTAB);
+ ehdr_p = gelf_getehdr (elf_file->elf, &ehdr_buf);
+ if (ehdr_p == NULL)
+ fatal_error ("gelf_getehdr() failed: %s", elf_errmsg (-1));
+ strtab = elf_ndxscn (elf_file->scn);
+ if (strtab < SHN_LORESERVE)
+ ehdr_p->e_shstrndx = strtab;
+ else
+ {
+ GElf_Shdr *shdr_p, shdr_buf;
+ Elf_Scn *scn_p = elf_getscn (elf_file->elf, 0);
+ if (scn_p == NULL)
+ fatal_error ("elf_getscn() failed: %s", elf_errmsg (-1));
+ shdr_p = gelf_getshdr (scn_p, &shdr_buf);
+ if (shdr_p == NULL)
+ fatal_error ("gelf_getshdr() failed: %s", elf_errmsg (-1));
+ shdr_p->sh_link = strtab;
+ if (gelf_update_shdr (scn_p, shdr_p) == 0)
+ fatal_error ("gelf_update_shdr() failed: %s", elf_errmsg (-1));
+ ehdr_p->e_shstrndx = SHN_XINDEX;
+ }
+ if (gelf_update_ehdr (elf_file->elf, ehdr_p) == 0)
+ fatal_error ("gelf_update_ehdr() failed: %s", elf_errmsg (-1));
+ lto_write_stream (elf_file->shstrtab_stream);
+ lto_obj_end_section ();
+
+ lto_set_current_out_file (old_file);
+ free (elf_file->shstrtab_stream);
+
+ if (elf_update (elf_file->elf, ELF_C_WRITE) < 0)
+ fatal_error ("elf_update() failed: %s", elf_errmsg (-1));
+ }
+
+ if (elf_file->elf)
+ elf_end (elf_file->elf);
+ if (elf_file->fd != -1)
+ close (elf_file->fd);
+
+ /* Free any ELF data buffers. */
+ cur = elf_file->data;
+ while (cur)
+ {
+ tmp = cur;
+ cur = (struct lto_char_ptr_base *) cur->ptr;
+ free (tmp);
+ }
+
+ free (file);
+}
+
+
+/* The current output file. */
+static lto_file *current_out_file;
+
+
+/* Sets the current output file to FILE. Returns the old output file or
+ NULL. */
+
+lto_file *
+lto_set_current_out_file (lto_file *file)
+{
+ lto_file *old_file = current_out_file;
+ current_out_file = file;
+ return old_file;
+}
+
+
+/* Returns the current output file. */
+
+lto_file *
+lto_get_current_out_file (void)
+{
+ return current_out_file;
+}
openrisc/trunk/gnu-src/gcc-4.5.1/gcc/lto/lto-elf.c
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: openrisc/trunk/gnu-src/gcc-4.5.1/gcc/lto/lto.h
===================================================================
--- openrisc/trunk/gnu-src/gcc-4.5.1/gcc/lto/lto.h (nonexistent)
+++ openrisc/trunk/gnu-src/gcc-4.5.1/gcc/lto/lto.h (revision 288)
@@ -0,0 +1,63 @@
+/* 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
+
openrisc/trunk/gnu-src/gcc-4.5.1/gcc/lto/lto.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: openrisc/trunk/gnu-src/gcc-4.5.1/gcc/lto/ChangeLog
===================================================================
--- openrisc/trunk/gnu-src/gcc-4.5.1/gcc/lto/ChangeLog (nonexistent)
+++ openrisc/trunk/gnu-src/gcc-4.5.1/gcc/lto/ChangeLog (revision 288)
@@ -0,0 +1,2817 @@
+2010-07-31 Release Manager
+
+ * GCC 4.5.1 released.
+
+2010-07-10 Iain Sandoe
+
+ Added the following, missed from the previous commit.
+ * lto-endian.h: New file.
+ * lto-macho.h: New file.
+ * lto-macho.c: New file.
+
+2010-06-24 Steven Bosscher
+
+ Backport from mainline:
+ 2010-05-18 Steven Bosscher
+
+ * 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-06-14 Dave Korn
+
+ Backport from mainline:
+ 2010-04-27 Dave Korn
+
+ 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 Dave Korn
+
+ * 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-06-04 Rainer Orth
+
+ Backport from mainline:
+ 2010-04-16 Rainer Orth
+
+ * lto-elf.c [!HAVE_ELF_GETSHDRSTRNDX] (elf_getshdrstrndx): New
+ function.
+
+2010-05-24 Richard Guenther
+
+ PR lto/44256
+ * lto.c (lto_fixup_type): Deal with non-type TYPE_CONTEXT.
+
+2010-05-24 Richard Guenther
+
+ * lto-elf.c (lto_obj_build_section_table): Work around
+ FreeBSD libelf issue.
+
+2010-04-14 Release Manager
+
+ * GCC 4.5.0 released.
+
+2010-03-09 Eric Botcazou
+
+ PR bootstrap/43276
+ * lto-elf.c: Define EM_* constants if not already defined.
+
+2010-03-03 Eric Botcazou
+
+ * lto-elf.c (is_compatible_architecture): New static function.
+ (DEFINE_VALIDATE_EHDR): Use it to validate the architecture.
+
+2010-02-11 Richard Guenther
+
+ PR driver/43021
+ * lto-elf.c (lto_elf_file_open): Handle file@offset case more
+ appropriately.
+
+2010-01-11 Andy Hutchinson
+
+ * 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
+
+ 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
+
+ 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
+
+ PR lto/42580
+ * lto-elf.c (lto_elf_file_open): Stop if the command line
+ option file is missing.
+
+2009-12-15 Richard Guenther
+
+ * lto.c (lto_fixup_field_decl): Fixup DECL_FIELD_OFFSET.
+ (lto_post_options): Do not disable debuginfo.
+
+2009-12-14 Dmitry Gorbachev
+
+ * Make-lang.in ($(LTO_EXE)): Use $(LINKER).
+
+2009-12-11 Richard Guenther
+
+ PR lto/42037
+ * lto.c (lto_resolution_read): Properly grow the vector.
+
+2009-12-11 Richard Guenther
+
+ 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
+
+ * lto-lang.c (handle_nonnull_attribute): Remove unused attr_arg_num
+ variable.
+
+2009-11-19 Rafael Avila de Espindola
+
+ 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
+
+ * 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
+
+ * lto-elf.c (lto_elf_file_open): Use strtoll to parse the offset.
+
+2009-11-14 Jan Hubicka
+
+ * lto.c (read_cgraph_and_symbols): Set also ipa_transforms_to_apply.
+
+2009-11-12 Rafael Avila de Espindola
+
+ * 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
+ Rafael Avila de Espindola
+
+ * 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
+
+ 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
+
+ * 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
+
+ * 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
+
+ * lto.c (lto_fixup_jump_functions): New function.
+ (lto_fixup_decls): Use it.
+
+2009-10-16 Richard Guenther
+
+ PR lto/41715
+ * lto.c (lto_fixup_tree): Revert last change.
+
+2009-10-14 Richard Guenther
+
+ * 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
+
+ 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
+
+ * 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
+
+ * lto.c (read_cgraph_and_symbols): Free the gimple type merging
+ hash tables.
+
+2009-10-07 Joseph Myers
+
+ * lto.c: Only include if HAVE_MMAP_FILE.
+
+2009-10-07 Jan Hubicka
+
+ * 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
+
+ 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
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * lto.c (lto_read_section_data): Use plain lseek/read.
+
+2009-10-01 Richard Guenther
+
+ * 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
+
+ * lto-lang.c (lto_init): Really fix call to
+ build_common_builtin_nodes.
+
+2009-09-29 Diego Novillo
+
+ * lto-lang.c (lto_init): Fix call to
+ build_common_builtin_nodes.
+
+2009-09-29 Richard Guenther
+
+ 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
+
+ * 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
+
+ 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
+
+ * 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
+
+ * lto-elf.c (validate_file): Replace call to
+ elf_getshstrndx with call to elf_getshdrstrndx.
+
+2009-08-19 Richard Guenther
+
+ * lto-lang.c (lto_init): Merge char_type_node with the
+ appropriately signed variant.
+
+2009-08-19 Richard Guenther
+
+ 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
+
+ PR lto/41071
+ * lto.c (lto_fixup_type): Re-build the type variant chain.
+
+2009-08-19 Richard Guenther
+
+ 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
+
+ * lto.c (read_cgraph_and_symbols): Exchange TREE_CHAIN use
+ for DECL_LANG_SPECIFIC.
+
+2009-08-13 Richard Guenther
+
+ PR lto/41032
+ * lto-lang.c (LANG_HOOKS_TYPES_COMPATIBLE_P): Define to NULL.
+
+2009-07-30 Richard Guenther
+
+ 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
+
+ * Make-lang.in: Add empty lto.install-plugin target.
+
+2009-07-13 Diego Novillo
+
+ * lto.c (lto_fixup_tree): Handle IMPORTED_DECL.
+
+2009-07-11 Richard Guenther
+
+ * lto-lang.c (lto_write_globals): Wrapup global decls.
+
+2009-07-10 Richard Guenther
+
+ * lto-lang.c (lto_init): Allocate one more location to make
+ BUILTINS_LOCATION correct.
+
+2009-07-09 Rainer Orth
+
+ * lto.c (free_section_data): Cast computed_offset to caddr_t.
+
+2009-07-06 Diego Novillo
+
+ * lto.c (lto_fixup_type): Fixup TYPE_SIZE and
+ TYPE_SIZE_UNIT.
+
+2009-07-06 Diego Novillo
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * lto.c (read_cgraph_and_symbols): Call input_cgraph.
+
+2009-06-02 Diego Novillo
+
+ * 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
+
+ * lto-lang.c (lto_handle_option): Hanlde OPT_Wabi.
+
+2009-05-31 Diego Novillo
+
+ * lto-lang.c (lto_type_for_mode): Handle all the modes
+ handled in c_common_type_for_mode.
+
+2009-05-21 Diego Novillo
+
+ * lto-elf.c: Always include .
+ * config-lang.in (target_libs): Remove.
+ (build_by_default): Set to no.
+
+2009-05-15 Diego Novillo
+
+ * 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
+
+ * lto-lang.c (LANG_HOOKS_GET_ALIAS_SET): Define.
+
+2009-05-07 Diego Novillo
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * 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
+
+ Revert
+
+ 2009-02-19 Rafael Avila de Espindola
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * 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
+
+ PR 39203
+ * lto-lang.c (lto_post_options): Disable -fwhole-program
+ when running LTRANS.
+
+2009-02-10 Diego Novillo
+
+ * lto.c (read_cgraph_and_symbols): Fix comment.
+
+2009-02-10 Diego Novillo
+
+ * lto.c (read_cgraph_and_symbols): Read options from all
+ IL files.
+
+2009-02-10 Diego Novillo
+
+ * 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
+
+ * 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
+
+ * lto.c (lto_main): Stop LTO_TIMER and use
+ TV_WHOPR_WPA_LTRANS_EXEC when launching LTRANS.
+
+2009-01-30 H.J. Lu
+
+ PR lto/38995
+ * lto-elf.c (init_shdr##BITS): Set the sh_addralign field
+ to POINTER_SIZE.
+
+2009-01-29 Ramana Radhakrishnan
+
+ * Make-lang.in (LTO_EXE): Link with all
+ BACKENDLIBS and not only GMPLIBS
+
+2009-01-28 H.J. Lu
+
+ 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
+
+ PR middle-end/38996
+ * lto-elf.c (DEFINE_INIT_EHDR): Initialize e_version.
+
+2009-01-26 Diego Novillo
+
+ * lto-lang.c (LANG_HOOKS_TYPES_COMPATIBLE_P): Update.
+
+2009-01-26 Diego Novillo
+
+ * 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
+
+ * lto-lang.c (lang_hooks): Remove the const qualifier.
+
+2009-01-06 Diego Novillo
+
+ * ltrans-driver: Mark 'all' target as phony.
+
+2008-12-31 Diego Novillo
+
+ * ltrans-driver: Execute a NOP action for target 'all'.
+
+2008-12-19 Diego Novillo
+
+ * lto.c (lto_1_to_1_map): Tidy.
+
+2008-12-19 Diego Novillo
+
+ * 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
+
+ * lto.c (lto_fixup_function): New.
+ (lto_fixup_tree): Call lto_fixup_function.
+
+2008-12-14 Doug Kwan
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * lto.c (lto_fixup_tree): Do not emit an error when
+ PREVAILING throw but T doesn't.
+
+2008-12-02 Doug Kwan
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * lto.c (lto_read_decls): Declare debug_main only if
+ LTO_STREAM_DEBUGGING is enabled.
+
+2008-10-30 Simon Baldwin
+
+ * 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
+
+ * 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
+
+ * lto-function-in.c (get_resolution): Return LDPR_PREEMPTED_IR for
+ non prevailing weak symbols.
+
+2008-10-24 Rafael Espindola
+
+ * lto-lang.c (input_cgraph_1): Iterate over nodes, not cgraph_nodes.
+
+2008-10-24 Rafael Espindola
+
+ * lto-lang.c (input_node): Avoid casts from pointers to ints of
+ different types.
+
+2008-10-23 Simon Baldwin
+
+ * 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
+ Rafael Espindola
+
+ * 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
+
+ * 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
+
+ * lto.c: Tidy some formatting.
+ * lto.h: Likewise.
+
+2008-10-21 Simon Baldwin
+
+ * 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
+
+ * ltrans-driver: Divert output from make to a temporary file.
+ Show it if the call to make failed.
+
+2008-10-15 Diego Novillo
+
+ * 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
+
+ * lto-symtab.c (lto_symtab_merge_decl): Do not force
+ TREE_STATIC on global symbols.
+
+2008-10-14 Ollie Wild
+
+ * 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
+
+ * Make-lang.in (LTRANS_DRIVER_INSTALL_NAME): Disable transformation
+ of program name.
+
+2008-10-13 Ollie Wild
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * lto.c (lto_fixup_tree, lto_fixup_state): Fix the FIXME.
+
+2008-10-03 Rafael Espindola
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * lto.c (lto_read_decls): Use new input_tree signature.
+
+2008-09-26 Doug Kwan
+
+ * 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
+
+ * 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
+
+ * lang.opt (fltrans-output-list=): New option.
+ * lto.c (lto_execute_ltrans): Output file names to ltrans_output_list.
+
+2008-09-25 Rafael Espindola
+
+ * lto.c (lto_resolution_read): Initialize ret;
+
+2008-09-24 Ollie Wild
+
+ * 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
+
+ * 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
+
+ * common.c: Update description.
+ * common.h: Update description.
+
+2008-09-23 Rafael Espindola
+
+ * common.c: Moved from lto-plugin.
+ * common.h: Moved from lto-plugin.
+
+2008-09-22 Doug Kwan
+
+ * 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
+
+ lto.c (lto_main): Remove unsued wrapper code.
+ lang-specs.h (@lto): Use lto1_options instead of cc1_options.
+
+2008-09-19 Rafael Espindola
+
+ * 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
+ Rafael Avila de Espindola
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * lto-lang.c (lto_global_bindings_p): Return 1 during
+ IPA passes.
+
+2008-09-07 Diego Novillo
+
+ * lto.c: Tidy formatting.
+
+2008-08-04 Bill Maddox
+
+ * lto-symtab.c (lto_symtab_merge_decl): Add comment.
+
+2008-09-03 Doug Kwan
+
+ lto.c (lto_add_all_inlinees): Reset FAILED_REASON of edges to
+ CIF_OK instead of NULL.
+
+2008-09-02 Diego Novillo
+ Simon Baldwin
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * lto-symtab.c (lto_symtab_merge_decl): Remove a suspect
+ assertion and leave an explanatory comment in its place.
+
+2008-08-21 Doug Kwan
+
+ * 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
+
+ * config-lang.in (target_libs): New.
+
+2008-08-20 Bill Maddox
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * Make-lang.in (lto-symtab.o): Add missing dependencies to fix
+ build breakage.
+
+2008-07-30 Bill Maddox
+
+ * 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
+ Bill Maddox
+
+ * 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
+
+ * lto.c (lto_read_decls): Cast pointer to const char * to avoid
+ unwanted scaling during pointer addition.
+
+2008-07-11 Bill Maddox
+ Diego Novillo
+
+ * 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
+
+ * Make-lang.in (lto-warn): Define.
+
+2008-07-03 Simon Baldwin
+
+ * lto.c (lto_read_decls): Wrapped debug-only data items within #ifdef
+ LTO_STREAM_DEBUGGING.
+
+2008-06-27 Ollie Wild
+
+ * 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
+
+ * 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
+
+ * lto.c (lto_file_read): Add const qualifier to data variable.
+
+2008-06-11 Diego Novillo
+
+ Merge from lto-streamber sub-branch.
+
+ 2008-06-04 Ollie Wild
+
+ * 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
+
+ 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
+ Jan Hubicka
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * lto-function-in.c (input_ssa_names): Call
+ make_ssa_name_fn instead of make_ssa_name.
+
+2008-05-12 Diego Novillo
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * lto-function-in.c (input_type_ref): Updated function description.
+
+2008-04-16 Ollie Wild
+
+ * 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
+
+ * lto.c (lto_materialize_function): Use DECL_ASSEMBLER_NAME to compute
+ section name
+
+2008-04-16 Ollie Wild
+
+ * lto.c (lto_read_compile_unit_DIE): Add DW_LANG_C_plus_plus to the
+ list of supported languages.
+
+2008-03-25 Kenneth Zadeck
+
+ Merge with mainline @133491.
+
+2008-03-05 Kenneth Zadeck
+ Jan Hubicka
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * lto-read.c (input_expr_operand): Mark static and external
+ VAR_DECLs as needed.
+
+2007-12-29 Nathan Froyd
+
+ * lto-read.c (input_integer): Use the correct shift amount.
+
+2007-12-29 Nathan Froyd
+
+ * lto-lang.c (lto_pushdecl): Do nothing instead of aborting.
+ (LANG_HOOKS_NAME): Define.
+
+2007-12-27 Nathan Froyd
+
+ * 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
+
+ * 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
+
+ * lto-lang.c (lto_types_compatible_p): New function.
+ (LANG_HOOKS_TYPES_COMPATIBLE_P): Define.
+
+2007-12-22 Nathan Froyd
+ Kenneth Zadeck
+
+ * 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
+
+ * 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
+
+ * lto.c (lto_read_base_type_DIE): Handle complex integer types.
+
+2007-12-18 Nathan Froyd
+
+ * 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
+
+ * lto.c (lto_read_subroutine_type_subprogram_DIE): Initialize
+ 'declaration'. Set the assembler name for non-public functions.
+
+2007-12-17 Kenneth Zadeck
+
+ * 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
+
+ * lto.c (lto_read_pointer_reference_type_DIE): Handle optional name
+ in pointer and reference types.
+
+2007-12-13 Nathan Froyd
+
+ * lto-read.c (input_expr_operand): Use DECL_RESULT when reading a
+ RESULT_DECL.
+
+2007-12-13 Nathan Froyd
+
+ * 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
+
+ * lto-lang.c (LANG_HOOKS_REDUCE_BIT_FIELD_OPERATIONS): Define.
+
+2007-12-12 Bill Maddox
+
+ Revert
+ 2007-12-07 Bill Maddox
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * lto.c (lto_read_DIE): Set TYPE_ALIAS_SET where necessary.
+
+2007-12-06 Nathan Froyd
+
+ * lto.c (lto_read_form): Add DW_cl_address for DW_AT_const_value.
+
+2007-12-06 Nathan Froyd
+
+ * lto-read.c (input_expr_operand): Don't check for MTAGs.
+ (lto_read_body): Don't declare PROP_alias.
+
+2007-12-06 Nathan Froyd
+
+ * lto-symtab.c (lto_symtab_merge_decl): Handle FUNCTION_DECLs without
+ argument type information.
+
+2007-12-03 Nathan Froyd
+
+ * 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
+
+ * lto.c (lto_materialize_function): Add FIXME.
+
+2007-11-29 Nathan Froyd
+
+ * 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
+
+ * 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
+
+ * 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
+
+ * lto-read.c (input_expr_operand): Get types right
+ for COMPLEX_CST.
+
+2007-11-16 Kenneth Zadeck
+
+ * lto-read.c (make_new_block, input_cfg): Properly set
+ n_basic_blocks.
+
+2007-11-16 Nathan Froyd
+
+ * 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
+
+ * lto.c (lto_read_base_type_DIE): Use make_bitfield_integer_type to
+ construct the integer type for bitfields.
+
+2007-11-16 Kenneth Zadeck
+
+ * 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
+
+ * lto.c (lto_read_subroutine_type_subprogram_DIE): Fix thinko'd
+ DECL_CONTEXT.
+
+2007-11-15 Nathan Froyd
+
+ * 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
+
+ * 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