Automatic date update in version.in
[external/binutils.git] / libiberty / simple-object.c
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.
4
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.
9
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.
14
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.  */
19
20 #include "config.h"
21 #include "libiberty.h"
22 #include "simple-object.h"
23
24 #include <errno.h>
25 #include <fcntl.h>
26
27 #ifdef HAVE_STDLIB_H
28 #include <stdlib.h>
29 #endif
30
31 #ifdef HAVE_STDINT_H
32 #include <stdint.h>
33 #endif
34
35 #ifdef HAVE_STRING_H
36 #include <string.h>
37 #endif
38
39 #ifdef HAVE_INTTYPES_H
40 #include <inttypes.h>
41 #endif
42
43 #ifndef SEEK_SET
44 #define SEEK_SET 0
45 #endif
46
47 #include "simple-object-common.h"
48
49 /* The known object file formats.  */
50
51 static const struct simple_object_functions * const format_functions[] =
52 {
53   &simple_object_elf_functions,
54   &simple_object_mach_o_functions,
55   &simple_object_coff_functions,
56   &simple_object_xcoff_functions
57 };
58
59 /* Read data from a file using the simple_object error reporting
60    conventions.  */
61
62 int
63 simple_object_internal_read (int descriptor, off_t offset,
64                              unsigned char *buffer, size_t size,
65                              const char **errmsg, int *err)
66 {
67   if (lseek (descriptor, offset, SEEK_SET) < 0)
68     {
69       *errmsg = "lseek";
70       *err = errno;
71       return 0;
72     }
73
74   do
75     {
76       ssize_t got = read (descriptor, buffer, size);
77       if (got == 0)
78         break;
79       else if (got > 0)
80         {
81           buffer += got;
82           size -= got;
83         }
84       else if (errno != EINTR)
85         {
86           *errmsg = "read";
87           *err = errno;
88           return 0;
89         }
90     }
91   while (size > 0);
92
93   if (size > 0)
94     {
95       *errmsg = "file too short";
96       *err = 0;
97       return 0;
98     }
99
100   return 1;
101 }
102
103 /* Write data to a file using the simple_object error reporting
104    conventions.  */
105
106 int
107 simple_object_internal_write (int descriptor, off_t offset,
108                               const unsigned char *buffer, size_t size,
109                               const char **errmsg, int *err)
110 {
111   if (lseek (descriptor, offset, SEEK_SET) < 0)
112     {
113       *errmsg = "lseek";
114       *err = errno;
115       return 0;
116     }
117
118   do
119     {
120       ssize_t wrote = write (descriptor, buffer, size);
121       if (wrote == 0)
122         break;
123       else if (wrote > 0)
124         {
125           buffer += wrote;
126           size -= wrote;
127         }
128       else if (errno != EINTR)
129         {
130           *errmsg = "write";
131           *err = errno;
132           return 0;
133         }
134     }
135   while (size > 0);
136
137   if (size > 0)
138     {
139       *errmsg = "short write";
140       *err = 0;
141       return 0;
142     }
143
144   return 1;
145 }
146
147 /* Open for read.  */
148
149 simple_object_read *
150 simple_object_start_read (int descriptor, off_t offset,
151                           const char *segment_name, const char **errmsg,
152                           int *err)
153 {
154   unsigned char header[SIMPLE_OBJECT_MATCH_HEADER_LEN];
155   size_t len, i;
156
157   if (!simple_object_internal_read (descriptor, offset, header,
158                                     SIMPLE_OBJECT_MATCH_HEADER_LEN,
159                                     errmsg, err))
160     return NULL;
161
162   len = sizeof (format_functions) / sizeof (format_functions[0]);
163   for (i = 0; i < len; ++i)
164     {
165       void *data;
166
167       data = format_functions[i]->match (header, descriptor, offset,
168                                          segment_name, errmsg, err);
169       if (data != NULL)
170         {
171           simple_object_read *ret;
172
173           ret = XNEW (simple_object_read);
174           ret->descriptor = descriptor;
175           ret->offset = offset;
176           ret->functions = format_functions[i];
177           ret->data = data;
178           return ret;
179         }
180     }
181
182   *errmsg = "file not recognized";
183   *err = 0;
184   return NULL;
185 }
186
187 /* Find all sections.  */
188
189 const char *
190 simple_object_find_sections (simple_object_read *sobj,
191                              int (*pfn) (void *, const char *, off_t, off_t),
192                              void *data,
193                              int *err)
194 {
195   return sobj->functions->find_sections (sobj, pfn, data, err);
196 }
197
198 /* Internal data passed to find_one_section.  */
199
200 struct find_one_section_data
201 {
202   /* The section we are looking for.  */
203   const char *name;
204   /* Where to store the section offset.  */
205   off_t *offset;
206   /* Where to store the section length.  */
207   off_t *length;
208   /* Set if the name is found.  */
209   int found;
210 };
211
212 /* Internal function passed to find_sections.  */
213
214 static int
215 find_one_section (void *data, const char *name, off_t offset, off_t length)
216 {
217   struct find_one_section_data *fosd = (struct find_one_section_data *) data;
218
219   if (strcmp (name, fosd->name) != 0)
220     return 1;
221
222   *fosd->offset = offset;
223   *fosd->length = length;
224   fosd->found = 1;
225
226   /* Stop iteration.  */
227   return 0;
228 }
229
230 /* Find a section.  */
231
232 int
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)
236 {
237   struct find_one_section_data fosd;
238
239   fosd.name = name;
240   fosd.offset = offset;
241   fosd.length = length;
242   fosd.found = 0;
243
244   *errmsg = simple_object_find_sections (sobj, find_one_section,
245                                          (void *) &fosd, err);
246   if (*errmsg != NULL)
247     return 0;
248   if (!fosd.found)
249     return 0;
250   return 1;
251 }
252
253 /* Callback to identify and rename LTO debug sections by name.
254    Returns non-NULL if NAME is a LTO debug section, NULL if not.
255    If RENAME is true it will rename LTO debug sections to non-LTO
256    ones.  */
257
258 static char *
259 handle_lto_debug_sections (const char *name, int rename)
260 {
261   char *newname = rename ? XCNEWVEC (char, strlen (name) + 1)
262                          : xstrdup (name);
263
264   /* ???  So we can't use .gnu.lto_ prefixed sections as the assembler
265      complains about bogus section flags.  Which means we need to arrange
266      for that to be fixed or .gnu.debuglto_ marked as SHF_EXCLUDE (to make
267      fat lto object tooling work for the fat part).  */
268   /* Also include corresponding reloc sections.  */
269   if (strncmp (name, ".rela", sizeof (".rela") - 1) == 0)
270     {
271       if (rename)
272         strncpy (newname, name, sizeof (".rela") - 1);
273       name += sizeof (".rela") - 1;
274     }
275   else if (strncmp (name, ".rel", sizeof (".rel") - 1) == 0)
276     {
277       if (rename)
278         strncpy (newname, name, sizeof (".rel") - 1);
279       name += sizeof (".rel") - 1;
280     }
281   /* ???  For now this handles both .gnu.lto_ and .gnu.debuglto_ prefixed
282      sections.  */
283   /* Copy LTO debug sections and rename them to their non-LTO name.  */
284   if (strncmp (name, ".gnu.debuglto_", sizeof (".gnu.debuglto_") - 1) == 0)
285     return rename ? strcat (newname, name + sizeof (".gnu.debuglto_") - 1) : newname;
286   else if (strncmp (name, ".gnu.lto_.debug_",
287                     sizeof (".gnu.lto_.debug_") -1) == 0)
288     return rename ? strcat (newname, name + sizeof (".gnu.lto_") - 1) : newname;
289   /* Copy over .note.GNU-stack section under the same name if present.  */
290   else if (strcmp (name, ".note.GNU-stack") == 0)
291     return strcpy (newname, name);
292   /* Copy over .comment section under the same name if present.  Solaris
293      ld uses them to relax its checking of ELF gABI access rules for
294      COMDAT sections in objects produced by GCC.  */
295   else if (strcmp (name, ".comment") == 0)
296     return strcpy (newname, name);
297   free (newname);
298   return NULL;
299 }
300
301 /* Wrapper for handle_lto_debug_sections.  */
302
303 static char *
304 handle_lto_debug_sections_rename (const char *name)
305 {
306   return handle_lto_debug_sections (name, 1);
307 }
308
309 /* Wrapper for handle_lto_debug_sections.  */
310
311 static char *
312 handle_lto_debug_sections_norename (const char *name)
313 {
314   return handle_lto_debug_sections (name, 0);
315 }
316
317 /* Copy LTO debug sections.  */
318
319 const char *
320 simple_object_copy_lto_debug_sections (simple_object_read *sobj,
321                                        const char *dest, int *err, int rename)
322 {
323   const char *errmsg;
324   simple_object_write *dest_sobj;
325   simple_object_attributes *attrs;
326   int outfd;
327
328   if (! sobj->functions->copy_lto_debug_sections)
329     {
330       *err = EINVAL;
331       return "simple_object_copy_lto_debug_sections not implemented";
332     }
333
334   attrs = simple_object_fetch_attributes (sobj, &errmsg, err);
335   if (! attrs)
336     return errmsg;
337   dest_sobj = simple_object_start_write (attrs, NULL, &errmsg, err);
338   simple_object_release_attributes (attrs);
339   if (! dest_sobj)
340     return errmsg;
341
342   errmsg = sobj->functions->copy_lto_debug_sections
343                  (sobj, dest_sobj,
344                   rename ? handle_lto_debug_sections_rename
345                          : handle_lto_debug_sections_norename,  err);
346   if (errmsg)
347     {
348       simple_object_release_write (dest_sobj);
349       return errmsg;
350     }
351
352   outfd = creat (dest, 00777);
353   if (outfd == -1)
354     {
355       *err = errno;
356       simple_object_release_write (dest_sobj);
357       return "open failed";
358     }
359
360   errmsg = simple_object_write_to_file (dest_sobj, outfd, err);
361   close (outfd);
362   if (errmsg)
363     {
364       simple_object_release_write (dest_sobj);
365       return errmsg;
366     }
367
368   simple_object_release_write (dest_sobj);
369   return NULL;
370 }
371
372 /* Fetch attributes.  */
373
374 simple_object_attributes *
375 simple_object_fetch_attributes (simple_object_read *sobj, const char **errmsg,
376                                 int *err)
377 {
378   void *data;
379   simple_object_attributes *ret;
380
381   data = sobj->functions->fetch_attributes (sobj, errmsg, err);
382   if (data == NULL)
383     return NULL;
384   ret = XNEW (simple_object_attributes);
385   ret->functions = sobj->functions;
386   ret->data = data;
387   return ret;
388 }
389
390 /* Release an simple_object_read.  */
391
392 void
393 simple_object_release_read (simple_object_read *sobj)
394 {
395   sobj->functions->release_read (sobj->data);
396   XDELETE (sobj);
397 }
398
399 /* Merge attributes.  */
400
401 const char *
402 simple_object_attributes_merge (simple_object_attributes *to,
403                                 simple_object_attributes *from,
404                                 int *err)
405 {
406   if (to->functions != from->functions)
407     {
408       *err = 0;
409       return "different object file format";
410     }
411   return to->functions->attributes_merge (to->data, from->data, err);
412 }
413
414 /* Release an attributes structure.  */
415
416 void
417 simple_object_release_attributes (simple_object_attributes *attrs)
418 {
419   attrs->functions->release_attributes (attrs->data);
420   XDELETE (attrs);
421 }
422
423 /* Start creating an object file.  */
424
425 simple_object_write *
426 simple_object_start_write (simple_object_attributes *attrs,
427                            const char *segment_name, const char **errmsg,
428                            int *err)
429 {
430   void *data;
431   simple_object_write *ret;
432
433   data = attrs->functions->start_write (attrs->data, errmsg, err);
434   if (data == NULL)
435     return NULL;
436   ret = XNEW (simple_object_write);
437   ret->functions = attrs->functions;
438   ret->segment_name = segment_name ? xstrdup (segment_name) : NULL;
439   ret->sections = NULL;
440   ret->last_section = NULL;
441   ret->data = data;
442   return ret;
443 }
444
445 /* Start creating a section.  */
446
447 simple_object_write_section *
448 simple_object_write_create_section (simple_object_write *sobj, const char *name,
449                                     unsigned int align,
450                                     const char **errmsg ATTRIBUTE_UNUSED,
451                                     int *err ATTRIBUTE_UNUSED)
452 {
453   simple_object_write_section *ret;
454
455   ret = XNEW (simple_object_write_section);
456   ret->next = NULL;
457   ret->name = xstrdup (name);
458   ret->align = align;
459   ret->buffers = NULL;
460   ret->last_buffer = NULL;
461
462   if (sobj->last_section == NULL)
463     {
464       sobj->sections = ret;
465       sobj->last_section = ret;
466     }
467   else
468     {
469       sobj->last_section->next = ret;
470       sobj->last_section = ret;
471     }
472
473   return ret;
474 }
475
476 /* Add data to a section.  */
477
478 const char *
479 simple_object_write_add_data (simple_object_write *sobj ATTRIBUTE_UNUSED,
480                               simple_object_write_section *section,
481                               const void *buffer,
482                               size_t size, int copy,
483                               int *err ATTRIBUTE_UNUSED)
484 {
485   struct simple_object_write_section_buffer *wsb;
486
487   wsb = XNEW (struct simple_object_write_section_buffer);
488   wsb->next = NULL;
489   wsb->size = size;
490
491   if (!copy)
492     {
493       wsb->buffer = buffer;
494       wsb->free_buffer = NULL;
495     }
496   else
497     {
498       wsb->free_buffer = (void *) XNEWVEC (char, size);
499       memcpy (wsb->free_buffer, buffer, size);
500       wsb->buffer = wsb->free_buffer;
501     }
502
503   if (section->last_buffer == NULL)
504     {
505       section->buffers = wsb;
506       section->last_buffer = wsb;
507     }
508   else
509     {
510       section->last_buffer->next = wsb;
511       section->last_buffer = wsb;
512     }
513
514   return NULL;
515 }
516
517 /* Write the complete object file.  */
518
519 const char *
520 simple_object_write_to_file (simple_object_write *sobj, int descriptor,
521                              int *err)
522 {
523   return sobj->functions->write_to_file (sobj, descriptor, err);
524 }
525
526 /* Release an simple_object_write.  */
527
528 void
529 simple_object_release_write (simple_object_write *sobj)
530 {
531   simple_object_write_section *section;
532
533   free (sobj->segment_name);
534
535   section = sobj->sections;
536   while (section != NULL)
537     {
538       struct simple_object_write_section_buffer *buffer;
539       simple_object_write_section *next_section;
540
541       buffer = section->buffers;
542       while (buffer != NULL)
543         {
544           struct simple_object_write_section_buffer *next_buffer;
545
546           if (buffer->free_buffer != NULL)
547             XDELETEVEC (buffer->free_buffer);
548           next_buffer = buffer->next;
549           XDELETE (buffer);
550           buffer = next_buffer;
551         }
552
553       next_section = section->next;
554       free (section->name);
555       XDELETE (section);
556       section = next_section;
557     }
558
559   sobj->functions->release_write (sobj->data);
560   XDELETE (sobj);
561 }