1 /* simple-object.c -- simple routines to read and write object files.
2 Copyright (C) 2010-2017 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor, Google.
5 This program is free software; you can redistribute it and/or modify it
6 under the terms of the GNU General Public License as published by the
7 Free Software Foundation; either version 2, or (at your option) any
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, 51 Franklin Street - Fifth Floor,
18 Boston, MA 02110-1301, USA. */
21 #include "libiberty.h"
22 #include "simple-object.h"
39 #ifdef HAVE_INTTYPES_H
47 #include "simple-object-common.h"
49 /* The known object file formats. */
51 static const struct simple_object_functions * const format_functions[] =
53 &simple_object_elf_functions,
54 &simple_object_mach_o_functions,
55 &simple_object_coff_functions,
56 &simple_object_xcoff_functions
59 /* Read data from a file using the simple_object error reporting
63 simple_object_internal_read (int descriptor, off_t offset,
64 unsigned char *buffer, size_t size,
65 const char **errmsg, int *err)
67 if (lseek (descriptor, offset, SEEK_SET) < 0)
76 ssize_t got = read (descriptor, buffer, size);
84 else if (errno != EINTR)
95 *errmsg = "file too short";
103 /* Write data to a file using the simple_object error reporting
107 simple_object_internal_write (int descriptor, off_t offset,
108 const unsigned char *buffer, size_t size,
109 const char **errmsg, int *err)
111 if (lseek (descriptor, offset, SEEK_SET) < 0)
120 ssize_t wrote = write (descriptor, buffer, size);
128 else if (errno != EINTR)
139 *errmsg = "short write";
150 simple_object_start_read (int descriptor, off_t offset,
151 const char *segment_name, const char **errmsg,
154 unsigned char header[SIMPLE_OBJECT_MATCH_HEADER_LEN];
157 if (!simple_object_internal_read (descriptor, offset, header,
158 SIMPLE_OBJECT_MATCH_HEADER_LEN,
162 len = sizeof (format_functions) / sizeof (format_functions[0]);
163 for (i = 0; i < len; ++i)
167 data = format_functions[i]->match (header, descriptor, offset,
168 segment_name, errmsg, err);
171 simple_object_read *ret;
173 ret = XNEW (simple_object_read);
174 ret->descriptor = descriptor;
175 ret->offset = offset;
176 ret->functions = format_functions[i];
182 *errmsg = "file not recognized";
187 /* Find all sections. */
190 simple_object_find_sections (simple_object_read *sobj,
191 int (*pfn) (void *, const char *, off_t, off_t),
195 return sobj->functions->find_sections (sobj, pfn, data, err);
198 /* Internal data passed to find_one_section. */
200 struct find_one_section_data
202 /* The section we are looking for. */
204 /* Where to store the section offset. */
206 /* Where to store the section length. */
208 /* Set if the name is found. */
212 /* Internal function passed to find_sections. */
215 find_one_section (void *data, const char *name, off_t offset, off_t length)
217 struct find_one_section_data *fosd = (struct find_one_section_data *) data;
219 if (strcmp (name, fosd->name) != 0)
222 *fosd->offset = offset;
223 *fosd->length = length;
226 /* Stop iteration. */
230 /* Find a section. */
233 simple_object_find_section (simple_object_read *sobj, const char *name,
234 off_t *offset, off_t *length,
235 const char **errmsg, int *err)
237 struct find_one_section_data fosd;
240 fosd.offset = offset;
241 fosd.length = length;
244 *errmsg = simple_object_find_sections (sobj, find_one_section,
245 (void *) &fosd, err);
253 /* Callback to identify and rename LTO debug sections by name.
254 Returns 1 if NAME is a LTO debug section, 0 if not. */
257 handle_lto_debug_sections (const char **name)
259 /* ??? So we can't use .gnu.lto_ prefixed sections as the assembler
260 complains about bogus section flags. Which means we need to arrange
261 for that to be fixed or .gnu.debuglto_ marked as SHF_EXCLUDE (to make
262 fat lto object tooling work for the fat part). */
263 /* ??? For now this handles both .gnu.lto_ and .gnu.debuglto_ prefixed
265 /* Copy LTO debug sections and rename them to their non-LTO name. */
266 if (strncmp (*name, ".gnu.debuglto_", sizeof (".gnu.debuglto_") - 1) == 0)
268 *name = *name + sizeof (".gnu.debuglto_") - 1;
271 else if (strncmp (*name, ".gnu.lto_.debug_", sizeof (".gnu.lto_.debug_") -1) == 0)
273 *name = *name + sizeof (".gnu.lto_") - 1;
279 /* Copy LTO debug sections. */
282 simple_object_copy_lto_debug_sections (simple_object_read *sobj,
283 const char *dest, int *err)
286 simple_object_write *dest_sobj;
287 simple_object_attributes *attrs;
290 if (! sobj->functions->copy_lto_debug_sections)
293 return "simple_object_copy_lto_debug_sections not implemented";
296 attrs = simple_object_fetch_attributes (sobj, &errmsg, err);
299 dest_sobj = simple_object_start_write (attrs, NULL, &errmsg, err);
300 simple_object_release_attributes (attrs);
304 errmsg = sobj->functions->copy_lto_debug_sections (sobj, dest_sobj,
305 handle_lto_debug_sections,
309 simple_object_release_write (dest_sobj);
313 outfd = creat (dest, 00777);
317 simple_object_release_write (dest_sobj);
318 return "open failed";
321 errmsg = simple_object_write_to_file (dest_sobj, outfd, err);
325 simple_object_release_write (dest_sobj);
329 simple_object_release_write (dest_sobj);
333 /* Fetch attributes. */
335 simple_object_attributes *
336 simple_object_fetch_attributes (simple_object_read *sobj, const char **errmsg,
340 simple_object_attributes *ret;
342 data = sobj->functions->fetch_attributes (sobj, errmsg, err);
345 ret = XNEW (simple_object_attributes);
346 ret->functions = sobj->functions;
351 /* Release an simple_object_read. */
354 simple_object_release_read (simple_object_read *sobj)
356 sobj->functions->release_read (sobj->data);
360 /* Merge attributes. */
363 simple_object_attributes_merge (simple_object_attributes *to,
364 simple_object_attributes *from,
367 if (to->functions != from->functions)
370 return "different object file format";
372 return to->functions->attributes_merge (to->data, from->data, err);
375 /* Release an attributes structure. */
378 simple_object_release_attributes (simple_object_attributes *attrs)
380 attrs->functions->release_attributes (attrs->data);
384 /* Start creating an object file. */
386 simple_object_write *
387 simple_object_start_write (simple_object_attributes *attrs,
388 const char *segment_name, const char **errmsg,
392 simple_object_write *ret;
394 data = attrs->functions->start_write (attrs->data, errmsg, err);
397 ret = XNEW (simple_object_write);
398 ret->functions = attrs->functions;
399 ret->segment_name = segment_name ? xstrdup (segment_name) : NULL;
400 ret->sections = NULL;
401 ret->last_section = NULL;
406 /* Start creating a section. */
408 simple_object_write_section *
409 simple_object_write_create_section (simple_object_write *sobj, const char *name,
411 const char **errmsg ATTRIBUTE_UNUSED,
412 int *err ATTRIBUTE_UNUSED)
414 simple_object_write_section *ret;
416 ret = XNEW (simple_object_write_section);
418 ret->name = xstrdup (name);
421 ret->last_buffer = NULL;
423 if (sobj->last_section == NULL)
425 sobj->sections = ret;
426 sobj->last_section = ret;
430 sobj->last_section->next = ret;
431 sobj->last_section = ret;
437 /* Add data to a section. */
440 simple_object_write_add_data (simple_object_write *sobj ATTRIBUTE_UNUSED,
441 simple_object_write_section *section,
443 size_t size, int copy,
444 int *err ATTRIBUTE_UNUSED)
446 struct simple_object_write_section_buffer *wsb;
448 wsb = XNEW (struct simple_object_write_section_buffer);
454 wsb->buffer = buffer;
455 wsb->free_buffer = NULL;
459 wsb->free_buffer = (void *) XNEWVEC (char, size);
460 memcpy (wsb->free_buffer, buffer, size);
461 wsb->buffer = wsb->free_buffer;
464 if (section->last_buffer == NULL)
466 section->buffers = wsb;
467 section->last_buffer = wsb;
471 section->last_buffer->next = wsb;
472 section->last_buffer = wsb;
478 /* Write the complete object file. */
481 simple_object_write_to_file (simple_object_write *sobj, int descriptor,
484 return sobj->functions->write_to_file (sobj, descriptor, err);
487 /* Release an simple_object_write. */
490 simple_object_release_write (simple_object_write *sobj)
492 simple_object_write_section *section;
494 free (sobj->segment_name);
496 section = sobj->sections;
497 while (section != NULL)
499 struct simple_object_write_section_buffer *buffer;
500 simple_object_write_section *next_section;
502 buffer = section->buffers;
503 while (buffer != NULL)
505 struct simple_object_write_section_buffer *next_buffer;
507 if (buffer->free_buffer != NULL)
508 XDELETEVEC (buffer->free_buffer);
509 next_buffer = buffer->next;
511 buffer = next_buffer;
514 next_section = section->next;
515 free (section->name);
517 section = next_section;
520 sobj->functions->release_write (sobj->data);