1 /* LTO routines to use object files.
2 Copyright 2010 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"
24 #include "diagnostic-core.h"
27 #include "lto-streamer.h"
28 #include "simple-object.h"
30 /* Segment name for LTO sections. This is only used for Mach-O.
31 FIXME: This needs to be kept in sync with darwin.c. */
33 #define LTO_SEGMENT_NAME "__GNU_LTO"
35 /* An LTO file wrapped around an simple_object. */
37 struct lto_simple_object
39 /* The base information. */
42 /* The system file descriptor. */
45 /* The simple_object if we are reading the file. */
46 simple_object_read
*sobj_r
;
48 /* The simple_object if we are writing the file. */
49 simple_object_write
*sobj_w
;
51 /* The currently active section. */
52 simple_object_write_section
*section
;
55 /* Saved simple_object attributes. FIXME: Once set, this is never
58 static simple_object_attributes
*saved_attributes
;
60 /* Initialize FILE, an LTO file object for FILENAME. */
63 lto_file_init (lto_file
*file
, const char *filename
, off_t offset
)
65 file
->filename
= filename
;
66 file
->offset
= offset
;
69 /* Open the file FILENAME. It WRITABLE is true, the file is opened
70 for write and, if necessary, created. Otherwise, the file is
71 opened for reading. Returns the opened file. */
74 lto_obj_file_open (const char *filename
, bool writable
)
81 struct lto_simple_object
*lo
;
85 offset_p
= strrchr (filename
, '@');
87 && offset_p
!= filename
88 && sscanf (offset_p
, "@%li%n", &loffset
, &consumed
) >= 1
89 && strlen (offset_p
) == (unsigned int) consumed
)
91 fname
= XNEWVEC (char, offset_p
- filename
+ 1);
92 memcpy (fname
, filename
, offset_p
- filename
);
93 fname
[offset_p
- filename
] = '\0';
94 offset
= (off_t
) loffset
;
98 fname
= xstrdup (filename
);
102 lo
= XCNEW (struct lto_simple_object
);
103 lto_file_init ((lto_file
*) lo
, fname
, offset
);
105 lo
->fd
= open (fname
,
107 ? O_WRONLY
| O_CREAT
| O_BINARY
108 : O_RDONLY
| O_BINARY
),
112 error ("open %s failed: %s", fname
, xstrerror (errno
));
118 simple_object_attributes
*attrs
;
120 lo
->sobj_r
= simple_object_start_read (lo
->fd
, offset
, LTO_SEGMENT_NAME
,
122 if (lo
->sobj_r
== NULL
)
125 attrs
= simple_object_fetch_attributes (lo
->sobj_r
, &errmsg
, &err
);
129 if (saved_attributes
== NULL
)
130 saved_attributes
= attrs
;
133 errmsg
= simple_object_attributes_merge (saved_attributes
, attrs
,
141 gcc_assert (saved_attributes
!= NULL
);
142 lo
->sobj_w
= simple_object_start_write (saved_attributes
,
145 if (lo
->sobj_w
== NULL
)
153 error ("%s: %s", fname
, errmsg
);
155 error ("%s: %s: %s", fname
, errmsg
, xstrerror (err
));
159 lto_obj_file_close ((lto_file
*) lo
);
163 /* Close FILE. If FILE was opened for writing, it is written out
167 lto_obj_file_close (lto_file
*file
)
169 struct lto_simple_object
*lo
= (struct lto_simple_object
*) file
;
171 if (lo
->sobj_r
!= NULL
)
172 simple_object_release_read (lo
->sobj_r
);
173 else if (lo
->sobj_w
!= NULL
)
178 gcc_assert (lo
->base
.offset
== 0);
180 errmsg
= simple_object_write_to_file (lo
->sobj_w
, lo
->fd
, &err
);
184 fatal_error ("%s", errmsg
);
186 fatal_error ("%s: %s", errmsg
, xstrerror (err
));
189 simple_object_release_write (lo
->sobj_w
);
194 if (close (lo
->fd
) < 0)
195 fatal_error ("close: %s", xstrerror (errno
));
199 /* This is passed to lto_obj_add_section. */
201 struct lto_obj_add_section_data
203 /* The hash table of sections. */
204 htab_t section_hash_table
;
205 /* The offset of this file. */
209 /* This is called for each section in the file. */
212 lto_obj_add_section (void *data
, const char *name
, off_t offset
,
215 struct lto_obj_add_section_data
*loasd
=
216 (struct lto_obj_add_section_data
*) data
;
217 htab_t section_hash_table
= (htab_t
) loasd
->section_hash_table
;
219 struct lto_section_slot s_slot
;
222 if (strncmp (name
, LTO_SECTION_NAME_PREFIX
,
223 strlen (LTO_SECTION_NAME_PREFIX
)) != 0)
226 new_name
= xstrdup (name
);
227 s_slot
.name
= new_name
;
228 slot
= htab_find_slot (section_hash_table
, &s_slot
, INSERT
);
231 struct lto_section_slot
*new_slot
= XNEW (struct lto_section_slot
);
233 new_slot
->name
= new_name
;
234 new_slot
->start
= loasd
->base_offset
+ offset
;
235 new_slot
->len
= length
;
240 error ("two or more sections for %s", new_name
);
247 /* Build a hash table whose key is the section name and whose data is
248 the start and size of each section in the .o file. */
251 lto_obj_build_section_table (lto_file
*lto_file
)
253 struct lto_simple_object
*lo
= (struct lto_simple_object
*) lto_file
;
254 htab_t section_hash_table
;
255 struct lto_obj_add_section_data loasd
;
259 section_hash_table
= lto_obj_create_section_hash_table ();
261 gcc_assert (lo
->sobj_r
!= NULL
&& lo
->sobj_w
== NULL
);
262 loasd
.section_hash_table
= section_hash_table
;
263 loasd
.base_offset
= lo
->base
.offset
;
264 errmsg
= simple_object_find_sections (lo
->sobj_r
, lto_obj_add_section
,
269 error ("%s", errmsg
);
271 error ("%s: %s", errmsg
, xstrerror (err
));
272 htab_delete (section_hash_table
);
276 return section_hash_table
;
279 /* The current output file. */
281 static lto_file
*current_out_file
;
283 /* Set the current output file. Return the old one. */
286 lto_set_current_out_file (lto_file
*file
)
290 old_file
= current_out_file
;
291 current_out_file
= file
;
295 /* Return the current output file. */
298 lto_get_current_out_file (void)
300 return current_out_file
;
303 /* Begin writing a new section named NAME in the current output
307 lto_obj_begin_section (const char *name
)
309 struct lto_simple_object
*lo
;
314 lo
= (struct lto_simple_object
*) current_out_file
;
315 gcc_assert (lo
!= NULL
316 && lo
->sobj_r
== NULL
317 && lo
->sobj_w
!= NULL
318 && lo
->section
== NULL
);
320 align
= exact_log2 (POINTER_SIZE
/ BITS_PER_UNIT
);
321 lo
->section
= simple_object_write_create_section (lo
->sobj_w
, name
, align
,
323 if (lo
->section
== NULL
)
326 fatal_error ("%s", errmsg
);
328 fatal_error ("%s: %s", errmsg
, xstrerror (errno
));
332 /* Add data to a section. BLOCK is a pointer to memory containing
336 lto_obj_append_data (const void *data
, size_t len
, void *block
)
338 struct lto_simple_object
*lo
;
342 lo
= (struct lto_simple_object
*) current_out_file
;
343 gcc_assert (lo
!= NULL
&& lo
->section
!= NULL
);
345 errmsg
= simple_object_write_add_data (lo
->sobj_w
, lo
->section
, data
, len
,
350 fatal_error ("%s", errmsg
);
352 fatal_error ("%s: %s", errmsg
, xstrerror (errno
));
358 /* Stop writing to the current output section. */
361 lto_obj_end_section (void)
363 struct lto_simple_object
*lo
;
365 lo
= (struct lto_simple_object
*) current_out_file
;
366 gcc_assert (lo
!= NULL
&& lo
->section
!= NULL
);