[binutils, ARM, 5/16] BF insns infrastructure with new global reloc R_ARM_THM_BF16
[binutils-gdb.git] / libiberty / simple-object.c
blobb00c265128c9dbca6984cea556af010df99f5427
1 /* simple-object.c -- simple routines to read and write object files.
2 Copyright (C) 2010-2019 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
8 later version.
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. */
20 #include "config.h"
21 #include "libiberty.h"
22 #include "simple-object.h"
24 #include <errno.h>
25 #include <fcntl.h>
27 #ifdef HAVE_STDLIB_H
28 #include <stdlib.h>
29 #endif
31 #ifdef HAVE_STDINT_H
32 #include <stdint.h>
33 #endif
35 #ifdef HAVE_STRING_H
36 #include <string.h>
37 #endif
39 #ifdef HAVE_INTTYPES_H
40 #include <inttypes.h>
41 #endif
43 #ifndef SEEK_SET
44 #define SEEK_SET 0
45 #endif
47 #ifndef O_BINARY
48 #define O_BINARY 0
49 #endif
51 #include "simple-object-common.h"
53 /* The known object file formats. */
55 static const struct simple_object_functions * const format_functions[] =
57 &simple_object_elf_functions,
58 &simple_object_mach_o_functions,
59 &simple_object_coff_functions,
60 &simple_object_xcoff_functions
63 /* Read data from a file using the simple_object error reporting
64 conventions. */
66 int
67 simple_object_internal_read (int descriptor, off_t offset,
68 unsigned char *buffer, size_t size,
69 const char **errmsg, int *err)
71 if (lseek (descriptor, offset, SEEK_SET) < 0)
73 *errmsg = "lseek";
74 *err = errno;
75 return 0;
80 ssize_t got = read (descriptor, buffer, size);
81 if (got == 0)
82 break;
83 else if (got > 0)
85 buffer += got;
86 size -= got;
88 else if (errno != EINTR)
90 *errmsg = "read";
91 *err = errno;
92 return 0;
95 while (size > 0);
97 if (size > 0)
99 *errmsg = "file too short";
100 *err = 0;
101 return 0;
104 return 1;
107 /* Write data to a file using the simple_object error reporting
108 conventions. */
111 simple_object_internal_write (int descriptor, off_t offset,
112 const unsigned char *buffer, size_t size,
113 const char **errmsg, int *err)
115 if (lseek (descriptor, offset, SEEK_SET) < 0)
117 *errmsg = "lseek";
118 *err = errno;
119 return 0;
124 ssize_t wrote = write (descriptor, buffer, size);
125 if (wrote == 0)
126 break;
127 else if (wrote > 0)
129 buffer += wrote;
130 size -= wrote;
132 else if (errno != EINTR)
134 *errmsg = "write";
135 *err = errno;
136 return 0;
139 while (size > 0);
141 if (size > 0)
143 *errmsg = "short write";
144 *err = 0;
145 return 0;
148 return 1;
151 /* Open for read. */
153 simple_object_read *
154 simple_object_start_read (int descriptor, off_t offset,
155 const char *segment_name, const char **errmsg,
156 int *err)
158 unsigned char header[SIMPLE_OBJECT_MATCH_HEADER_LEN];
159 size_t len, i;
161 if (!simple_object_internal_read (descriptor, offset, header,
162 SIMPLE_OBJECT_MATCH_HEADER_LEN,
163 errmsg, err))
164 return NULL;
166 len = sizeof (format_functions) / sizeof (format_functions[0]);
167 for (i = 0; i < len; ++i)
169 void *data;
171 data = format_functions[i]->match (header, descriptor, offset,
172 segment_name, errmsg, err);
173 if (data != NULL)
175 simple_object_read *ret;
177 ret = XNEW (simple_object_read);
178 ret->descriptor = descriptor;
179 ret->offset = offset;
180 ret->functions = format_functions[i];
181 ret->data = data;
182 return ret;
186 *errmsg = "file not recognized";
187 *err = 0;
188 return NULL;
191 /* Find all sections. */
193 const char *
194 simple_object_find_sections (simple_object_read *sobj,
195 int (*pfn) (void *, const char *, off_t, off_t),
196 void *data,
197 int *err)
199 return sobj->functions->find_sections (sobj, pfn, data, err);
202 /* Internal data passed to find_one_section. */
204 struct find_one_section_data
206 /* The section we are looking for. */
207 const char *name;
208 /* Where to store the section offset. */
209 off_t *offset;
210 /* Where to store the section length. */
211 off_t *length;
212 /* Set if the name is found. */
213 int found;
216 /* Internal function passed to find_sections. */
218 static int
219 find_one_section (void *data, const char *name, off_t offset, off_t length)
221 struct find_one_section_data *fosd = (struct find_one_section_data *) data;
223 if (strcmp (name, fosd->name) != 0)
224 return 1;
226 *fosd->offset = offset;
227 *fosd->length = length;
228 fosd->found = 1;
230 /* Stop iteration. */
231 return 0;
234 /* Find a section. */
237 simple_object_find_section (simple_object_read *sobj, const char *name,
238 off_t *offset, off_t *length,
239 const char **errmsg, int *err)
241 struct find_one_section_data fosd;
243 fosd.name = name;
244 fosd.offset = offset;
245 fosd.length = length;
246 fosd.found = 0;
248 *errmsg = simple_object_find_sections (sobj, find_one_section,
249 (void *) &fosd, err);
250 if (*errmsg != NULL)
251 return 0;
252 if (!fosd.found)
253 return 0;
254 return 1;
257 /* Callback to identify and rename LTO debug sections by name.
258 Returns non-NULL if NAME is a LTO debug section, NULL if not.
259 If RENAME is true it will rename LTO debug sections to non-LTO
260 ones. */
262 static char *
263 handle_lto_debug_sections (const char *name, int rename)
265 char *newname = rename ? XCNEWVEC (char, strlen (name) + 1)
266 : xstrdup (name);
268 /* ??? So we can't use .gnu.lto_ prefixed sections as the assembler
269 complains about bogus section flags. Which means we need to arrange
270 for that to be fixed or .gnu.debuglto_ marked as SHF_EXCLUDE (to make
271 fat lto object tooling work for the fat part). */
272 /* Also include corresponding reloc sections. */
273 if (strncmp (name, ".rela", sizeof (".rela") - 1) == 0)
275 if (rename)
276 strncpy (newname, name, sizeof (".rela") - 1);
277 name += sizeof (".rela") - 1;
279 else if (strncmp (name, ".rel", sizeof (".rel") - 1) == 0)
281 if (rename)
282 strncpy (newname, name, sizeof (".rel") - 1);
283 name += sizeof (".rel") - 1;
285 /* ??? For now this handles both .gnu.lto_ and .gnu.debuglto_ prefixed
286 sections. */
287 /* Copy LTO debug sections and rename them to their non-LTO name. */
288 if (strncmp (name, ".gnu.debuglto_", sizeof (".gnu.debuglto_") - 1) == 0)
289 return rename ? strcat (newname, name + sizeof (".gnu.debuglto_") - 1) : newname;
290 else if (strncmp (name, ".gnu.lto_.debug_",
291 sizeof (".gnu.lto_.debug_") -1) == 0)
292 return rename ? strcat (newname, name + sizeof (".gnu.lto_") - 1) : newname;
293 /* Copy over .note.GNU-stack section under the same name if present. */
294 else if (strcmp (name, ".note.GNU-stack") == 0)
295 return strcpy (newname, name);
296 /* Copy over .comment section under the same name if present. Solaris
297 ld uses them to relax its checking of ELF gABI access rules for
298 COMDAT sections in objects produced by GCC. */
299 else if (strcmp (name, ".comment") == 0)
300 return strcpy (newname, name);
301 free (newname);
302 return NULL;
305 /* Wrapper for handle_lto_debug_sections. */
307 static char *
308 handle_lto_debug_sections_rename (const char *name)
310 return handle_lto_debug_sections (name, 1);
313 /* Wrapper for handle_lto_debug_sections. */
315 static char *
316 handle_lto_debug_sections_norename (const char *name)
318 return handle_lto_debug_sections (name, 0);
321 /* Copy LTO debug sections. */
323 const char *
324 simple_object_copy_lto_debug_sections (simple_object_read *sobj,
325 const char *dest, int *err, int rename)
327 const char *errmsg;
328 simple_object_write *dest_sobj;
329 simple_object_attributes *attrs;
330 int outfd;
332 if (! sobj->functions->copy_lto_debug_sections)
334 *err = EINVAL;
335 return "simple_object_copy_lto_debug_sections not implemented";
338 attrs = simple_object_fetch_attributes (sobj, &errmsg, err);
339 if (! attrs)
340 return errmsg;
341 dest_sobj = simple_object_start_write (attrs, NULL, &errmsg, err);
342 simple_object_release_attributes (attrs);
343 if (! dest_sobj)
344 return errmsg;
346 errmsg = sobj->functions->copy_lto_debug_sections
347 (sobj, dest_sobj,
348 rename ? handle_lto_debug_sections_rename
349 : handle_lto_debug_sections_norename, err);
350 if (errmsg)
352 simple_object_release_write (dest_sobj);
353 return errmsg;
356 outfd = open (dest, O_CREAT|O_WRONLY|O_TRUNC|O_BINARY, 00777);
357 if (outfd == -1)
359 *err = errno;
360 simple_object_release_write (dest_sobj);
361 return "open failed";
364 errmsg = simple_object_write_to_file (dest_sobj, outfd, err);
365 close (outfd);
366 if (errmsg)
368 simple_object_release_write (dest_sobj);
369 return errmsg;
372 simple_object_release_write (dest_sobj);
373 return NULL;
376 /* Fetch attributes. */
378 simple_object_attributes *
379 simple_object_fetch_attributes (simple_object_read *sobj, const char **errmsg,
380 int *err)
382 void *data;
383 simple_object_attributes *ret;
385 data = sobj->functions->fetch_attributes (sobj, errmsg, err);
386 if (data == NULL)
387 return NULL;
388 ret = XNEW (simple_object_attributes);
389 ret->functions = sobj->functions;
390 ret->data = data;
391 return ret;
394 /* Release an simple_object_read. */
396 void
397 simple_object_release_read (simple_object_read *sobj)
399 sobj->functions->release_read (sobj->data);
400 XDELETE (sobj);
403 /* Merge attributes. */
405 const char *
406 simple_object_attributes_merge (simple_object_attributes *to,
407 simple_object_attributes *from,
408 int *err)
410 if (to->functions != from->functions)
412 *err = 0;
413 return "different object file format";
415 return to->functions->attributes_merge (to->data, from->data, err);
418 /* Release an attributes structure. */
420 void
421 simple_object_release_attributes (simple_object_attributes *attrs)
423 attrs->functions->release_attributes (attrs->data);
424 XDELETE (attrs);
427 /* Start creating an object file. */
429 simple_object_write *
430 simple_object_start_write (simple_object_attributes *attrs,
431 const char *segment_name, const char **errmsg,
432 int *err)
434 void *data;
435 simple_object_write *ret;
437 data = attrs->functions->start_write (attrs->data, errmsg, err);
438 if (data == NULL)
439 return NULL;
440 ret = XNEW (simple_object_write);
441 ret->functions = attrs->functions;
442 ret->segment_name = segment_name ? xstrdup (segment_name) : NULL;
443 ret->sections = NULL;
444 ret->last_section = NULL;
445 ret->data = data;
446 return ret;
449 /* Start creating a section. */
451 simple_object_write_section *
452 simple_object_write_create_section (simple_object_write *sobj, const char *name,
453 unsigned int align,
454 const char **errmsg ATTRIBUTE_UNUSED,
455 int *err ATTRIBUTE_UNUSED)
457 simple_object_write_section *ret;
459 ret = XNEW (simple_object_write_section);
460 ret->next = NULL;
461 ret->name = xstrdup (name);
462 ret->align = align;
463 ret->buffers = NULL;
464 ret->last_buffer = NULL;
466 if (sobj->last_section == NULL)
468 sobj->sections = ret;
469 sobj->last_section = ret;
471 else
473 sobj->last_section->next = ret;
474 sobj->last_section = ret;
477 return ret;
480 /* Add data to a section. */
482 const char *
483 simple_object_write_add_data (simple_object_write *sobj ATTRIBUTE_UNUSED,
484 simple_object_write_section *section,
485 const void *buffer,
486 size_t size, int copy,
487 int *err ATTRIBUTE_UNUSED)
489 struct simple_object_write_section_buffer *wsb;
491 wsb = XNEW (struct simple_object_write_section_buffer);
492 wsb->next = NULL;
493 wsb->size = size;
495 if (!copy)
497 wsb->buffer = buffer;
498 wsb->free_buffer = NULL;
500 else
502 wsb->free_buffer = (void *) XNEWVEC (char, size);
503 memcpy (wsb->free_buffer, buffer, size);
504 wsb->buffer = wsb->free_buffer;
507 if (section->last_buffer == NULL)
509 section->buffers = wsb;
510 section->last_buffer = wsb;
512 else
514 section->last_buffer->next = wsb;
515 section->last_buffer = wsb;
518 return NULL;
521 /* Write the complete object file. */
523 const char *
524 simple_object_write_to_file (simple_object_write *sobj, int descriptor,
525 int *err)
527 return sobj->functions->write_to_file (sobj, descriptor, err);
530 /* Release an simple_object_write. */
532 void
533 simple_object_release_write (simple_object_write *sobj)
535 simple_object_write_section *section;
537 free (sobj->segment_name);
539 section = sobj->sections;
540 while (section != NULL)
542 struct simple_object_write_section_buffer *buffer;
543 simple_object_write_section *next_section;
545 buffer = section->buffers;
546 while (buffer != NULL)
548 struct simple_object_write_section_buffer *next_buffer;
550 if (buffer->free_buffer != NULL)
551 XDELETEVEC (buffer->free_buffer);
552 next_buffer = buffer->next;
553 XDELETE (buffer);
554 buffer = next_buffer;
557 next_section = section->next;
558 free (section->name);
559 XDELETE (section);
560 section = next_section;
563 sobj->functions->release_write (sobj->data);
564 XDELETE (sobj);