1 /* LTO routines to use object files.
2 Copyright (C) 2010-2015 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor, Google.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
28 #include "fold-const.h"
31 #include "hard-reg-set.h"
33 #include "basic-block.h"
34 #include "tree-ssa-alias.h"
35 #include "internal-fn.h"
36 #include "gimple-expr.h"
38 #include "diagnostic-core.h"
41 #include "lto-streamer.h"
42 #include "lto-section-names.h"
43 #include "simple-object.h"
45 /* An LTO file wrapped around an simple_object. */
47 struct lto_simple_object
49 /* The base information. */
52 /* The system file descriptor. */
55 /* The simple_object if we are reading the file. */
56 simple_object_read
*sobj_r
;
58 /* The simple_object if we are writing the file. */
59 simple_object_write
*sobj_w
;
61 /* The currently active section. */
62 simple_object_write_section
*section
;
65 /* Saved simple_object attributes. FIXME: Once set, this is never
68 static simple_object_attributes
*saved_attributes
;
70 /* Initialize FILE, an LTO file object for FILENAME. */
73 lto_file_init (lto_file
*file
, const char *filename
, off_t offset
)
75 file
->filename
= filename
;
76 file
->offset
= offset
;
79 /* Open the file FILENAME. It WRITABLE is true, the file is opened
80 for write and, if necessary, created. Otherwise, the file is
81 opened for reading. Returns the opened file. */
84 lto_obj_file_open (const char *filename
, bool writable
)
91 struct lto_simple_object
*lo
;
95 offset_p
= strrchr (filename
, '@');
97 && offset_p
!= filename
98 && sscanf (offset_p
, "@%li%n", &loffset
, &consumed
) >= 1
99 && strlen (offset_p
) == (unsigned int) consumed
)
101 fname
= XNEWVEC (char, offset_p
- filename
+ 1);
102 memcpy (fname
, filename
, offset_p
- filename
);
103 fname
[offset_p
- filename
] = '\0';
104 offset
= (off_t
) loffset
;
108 fname
= xstrdup (filename
);
112 lo
= XCNEW (struct lto_simple_object
);
113 lto_file_init ((lto_file
*) lo
, fname
, offset
);
115 lo
->fd
= open (fname
,
117 ? O_WRONLY
| O_CREAT
| O_BINARY
118 : O_RDONLY
| O_BINARY
),
122 error ("open %s failed: %s", fname
, xstrerror (errno
));
128 simple_object_attributes
*attrs
;
130 lo
->sobj_r
= simple_object_start_read (lo
->fd
, offset
, LTO_SEGMENT_NAME
,
132 if (lo
->sobj_r
== NULL
)
135 attrs
= simple_object_fetch_attributes (lo
->sobj_r
, &errmsg
, &err
);
139 if (saved_attributes
== NULL
)
140 saved_attributes
= attrs
;
143 errmsg
= simple_object_attributes_merge (saved_attributes
, attrs
,
154 gcc_assert (saved_attributes
!= NULL
);
155 lo
->sobj_w
= simple_object_start_write (saved_attributes
,
158 if (lo
->sobj_w
== NULL
)
166 error ("%s: %s", fname
, errmsg
);
168 error ("%s: %s: %s", fname
, errmsg
, xstrerror (err
));
172 lto_obj_file_close ((lto_file
*) lo
);
178 /* Close FILE. If FILE was opened for writing, it is written out
182 lto_obj_file_close (lto_file
*file
)
184 struct lto_simple_object
*lo
= (struct lto_simple_object
*) file
;
186 if (lo
->sobj_r
!= NULL
)
187 simple_object_release_read (lo
->sobj_r
);
188 else if (lo
->sobj_w
!= NULL
)
193 gcc_assert (lo
->base
.offset
== 0);
195 errmsg
= simple_object_write_to_file (lo
->sobj_w
, lo
->fd
, &err
);
199 fatal_error (input_location
, "%s", errmsg
);
201 fatal_error (input_location
, "%s: %s", errmsg
, xstrerror (err
));
204 simple_object_release_write (lo
->sobj_w
);
209 if (close (lo
->fd
) < 0)
210 fatal_error (input_location
, "close: %s", xstrerror (errno
));
214 /* This is passed to lto_obj_add_section. */
216 struct lto_obj_add_section_data
218 /* The hash table of sections. */
219 htab_t section_hash_table
;
220 /* The offset of this file. */
222 /* List in linker order */
223 struct lto_section_list
*list
;
226 /* This is called for each section in the file. */
229 lto_obj_add_section (void *data
, const char *name
, off_t offset
,
232 struct lto_obj_add_section_data
*loasd
=
233 (struct lto_obj_add_section_data
*) data
;
234 htab_t section_hash_table
= (htab_t
) loasd
->section_hash_table
;
236 struct lto_section_slot s_slot
;
238 struct lto_section_list
*list
= loasd
->list
;
240 if (strncmp (name
, section_name_prefix
, strlen (section_name_prefix
)))
243 new_name
= xstrdup (name
);
244 s_slot
.name
= new_name
;
245 slot
= htab_find_slot (section_hash_table
, &s_slot
, INSERT
);
248 struct lto_section_slot
*new_slot
= XCNEW (struct lto_section_slot
);
250 new_slot
->name
= new_name
;
251 new_slot
->start
= loasd
->base_offset
+ offset
;
252 new_slot
->len
= length
;
258 list
->first
= new_slot
;
260 list
->last
->next
= new_slot
;
261 list
->last
= new_slot
;
266 error ("two or more sections for %s", new_name
);
273 /* Build a hash table whose key is the section name and whose data is
274 the start and size of each section in the .o file. */
277 lto_obj_build_section_table (lto_file
*lto_file
, struct lto_section_list
*list
)
279 struct lto_simple_object
*lo
= (struct lto_simple_object
*) lto_file
;
280 htab_t section_hash_table
;
281 struct lto_obj_add_section_data loasd
;
285 section_hash_table
= lto_obj_create_section_hash_table ();
287 gcc_assert (lo
->sobj_r
!= NULL
&& lo
->sobj_w
== NULL
);
288 loasd
.section_hash_table
= section_hash_table
;
289 loasd
.base_offset
= lo
->base
.offset
;
291 errmsg
= simple_object_find_sections (lo
->sobj_r
, lto_obj_add_section
,
296 error ("%s", errmsg
);
298 error ("%s: %s", errmsg
, xstrerror (err
));
299 htab_delete (section_hash_table
);
303 return section_hash_table
;
306 /* The current output file. */
308 static lto_file
*current_out_file
;
310 /* Set the current output file. Return the old one. */
313 lto_set_current_out_file (lto_file
*file
)
317 old_file
= current_out_file
;
318 current_out_file
= file
;
322 /* Return the current output file. */
325 lto_get_current_out_file (void)
327 return current_out_file
;
330 /* Begin writing a new section named NAME in the current output
334 lto_obj_begin_section (const char *name
)
336 struct lto_simple_object
*lo
;
341 lo
= (struct lto_simple_object
*) current_out_file
;
342 gcc_assert (lo
!= NULL
343 && lo
->sobj_r
== NULL
344 && lo
->sobj_w
!= NULL
345 && lo
->section
== NULL
);
347 align
= ceil_log2 (POINTER_SIZE_UNITS
);
348 lo
->section
= simple_object_write_create_section (lo
->sobj_w
, name
, align
,
350 if (lo
->section
== NULL
)
353 fatal_error (input_location
, "%s", errmsg
);
355 fatal_error (input_location
, "%s: %s", errmsg
, xstrerror (errno
));
359 /* Add data to a section. BLOCK is a pointer to memory containing
363 lto_obj_append_data (const void *data
, size_t len
, void *)
365 struct lto_simple_object
*lo
;
369 lo
= (struct lto_simple_object
*) current_out_file
;
370 gcc_assert (lo
!= NULL
&& lo
->section
!= NULL
);
372 errmsg
= simple_object_write_add_data (lo
->sobj_w
, lo
->section
, data
, len
,
377 fatal_error (input_location
, "%s", errmsg
);
379 fatal_error (input_location
, "%s: %s", errmsg
, xstrerror (errno
));
383 /* Stop writing to the current output section. */
386 lto_obj_end_section (void)
388 struct lto_simple_object
*lo
;
390 lo
= (struct lto_simple_object
*) current_out_file
;
391 gcc_assert (lo
!= NULL
&& lo
->section
!= NULL
);