libiberty/simple-object.c

   1 /* simple-object.c -- simple routines to read and write object files.
   2    Copyright (C) 2010-2018 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 1 if NAME is a LTO debug section, 0 if not.  */
 255
 256 static char *
 257 handle_lto_debug_sections (const char *name)
 258 {
 259   char *newname = XCNEWVEC (char, strlen (name) + 1);
 260
 261   /* ???  So we can't use .gnu.lto_ prefixed sections as the assembler
 262      complains about bogus section flags.  Which means we need to arrange
 263      for that to be fixed or .gnu.debuglto_ marked as SHF_EXCLUDE (to make
 264      fat lto object tooling work for the fat part).  */
 265   /* Also include corresponding reloc sections.  */
 266   if (strncmp (name, ".rela", sizeof (".rela") - 1) == 0)
 267     {
 268       strncpy (newname, name, sizeof (".rela") - 1);
 269       name += sizeof (".rela") - 1;
 270     }
 271   else if (strncmp (name, ".rel", sizeof (".rel") - 1) == 0)
 272     {
 273       strncpy (newname, name, sizeof (".rel") - 1);
 274       name += sizeof (".rel") - 1;
 275     }
 276   /* ???  For now this handles both .gnu.lto_ and .gnu.debuglto_ prefixed
 277      sections.  */
 278   /* Copy LTO debug sections and rename them to their non-LTO name.  */
 279   if (strncmp (name, ".gnu.debuglto_", sizeof (".gnu.debuglto_") - 1) == 0)
 280     return strcat (newname, name + sizeof (".gnu.debuglto_") - 1);
 281   else if (strncmp (name, ".gnu.lto_.debug_",
 282                     sizeof (".gnu.lto_.debug_") -1) == 0)
 283     return strcat (newname, name + sizeof (".gnu.lto_") - 1);
 284   /* Copy over .note.GNU-stack section under the same name if present.  */
 285   else if (strcmp (name, ".note.GNU-stack") == 0)
 286     return strcpy (newname, name);
 287   return NULL;
 288 }
 289
 290 /* Copy LTO debug sections.  */
 291
 292 const char *
 293 simple_object_copy_lto_debug_sections (simple_object_read *sobj,
 294                                        const char *dest, int *err)
 295 {
 296   const char *errmsg;
 297   simple_object_write *dest_sobj;
 298   simple_object_attributes *attrs;
 299   int outfd;
 300
 301   if (! sobj->functions->copy_lto_debug_sections)
 302     {
 303       *err = EINVAL;
 304       return "simple_object_copy_lto_debug_sections not implemented";
 305     }
 306
 307   attrs = simple_object_fetch_attributes (sobj, &errmsg, err);
 308   if (! attrs)
 309     return errmsg;
 310   dest_sobj = simple_object_start_write (attrs, NULL, &errmsg, err);
 311   simple_object_release_attributes (attrs);
 312   if (! dest_sobj)
 313     return errmsg;
 314
 315   errmsg = sobj->functions->copy_lto_debug_sections (sobj, dest_sobj,
 316                                                      handle_lto_debug_sections,
 317                                                      err);
 318   if (errmsg)
 319     {
 320       simple_object_release_write (dest_sobj);
 321       return errmsg;
 322     }
 323
 324   outfd = creat (dest, 00777);
 325   if (outfd == -1)
 326     {
 327       *err = errno;
 328       simple_object_release_write (dest_sobj);
 329       return "open failed";
 330     }
 331
 332   errmsg = simple_object_write_to_file (dest_sobj, outfd, err);
 333   close (outfd);
 334   if (errmsg)
 335     {
 336       simple_object_release_write (dest_sobj);
 337       return errmsg;
 338     }
 339
 340   simple_object_release_write (dest_sobj);
 341   return NULL;
 342 }
 343
 344 /* Fetch attributes.  */
 345
 346 simple_object_attributes *
 347 simple_object_fetch_attributes (simple_object_read *sobj, const char **errmsg,
 348                                 int *err)
 349 {
 350   void *data;
 351   simple_object_attributes *ret;
 352
 353   data = sobj->functions->fetch_attributes (sobj, errmsg, err);
 354   if (data == NULL)
 355     return NULL;
 356   ret = XNEW (simple_object_attributes);
 357   ret->functions = sobj->functions;
 358   ret->data = data;
 359   return ret;
 360 }
 361
 362 /* Release an simple_object_read.  */
 363
 364 void
 365 simple_object_release_read (simple_object_read *sobj)
 366 {
 367   sobj->functions->release_read (sobj->data);
 368   XDELETE (sobj);
 369 }
 370
 371 /* Merge attributes.  */
 372
 373 const char *
 374 simple_object_attributes_merge (simple_object_attributes *to,
 375                                 simple_object_attributes *from,
 376                                 int *err)
 377 {
 378   if (to->functions != from->functions)
 379     {
 380       *err = 0;
 381       return "different object file format";
 382     }
 383   return to->functions->attributes_merge (to->data, from->data, err);
 384 }
 385
 386 /* Release an attributes structure.  */
 387
 388 void
 389 simple_object_release_attributes (simple_object_attributes *attrs)
 390 {
 391   attrs->functions->release_attributes (attrs->data);
 392   XDELETE (attrs);
 393 }
 394
 395 /* Start creating an object file.  */
 396
 397 simple_object_write *
 398 simple_object_start_write (simple_object_attributes *attrs,
 399                            const char *segment_name, const char **errmsg,
 400                            int *err)
 401 {
 402   void *data;
 403   simple_object_write *ret;
 404
 405   data = attrs->functions->start_write (attrs->data, errmsg, err);
 406   if (data == NULL)
 407     return NULL;
 408   ret = XNEW (simple_object_write);
 409   ret->functions = attrs->functions;
 410   ret->segment_name = segment_name ? xstrdup (segment_name) : NULL;
 411   ret->sections = NULL;
 412   ret->last_section = NULL;
 413   ret->data = data;
 414   return ret;
 415 }
 416
 417 /* Start creating a section.  */
 418
 419 simple_object_write_section *
 420 simple_object_write_create_section (simple_object_write *sobj, const char *name,
 421                                     unsigned int align,
 422                                     const char **errmsg ATTRIBUTE_UNUSED,
 423                                     int *err ATTRIBUTE_UNUSED)
 424 {
 425   simple_object_write_section *ret;
 426
 427   ret = XNEW (simple_object_write_section);
 428   ret->next = NULL;
 429   ret->name = xstrdup (name);
 430   ret->align = align;
 431   ret->buffers = NULL;
 432   ret->last_buffer = NULL;
 433
 434   if (sobj->last_section == NULL)
 435     {
 436       sobj->sections = ret;
 437       sobj->last_section = ret;
 438     }
 439   else
 440     {
 441       sobj->last_section->next = ret;
 442       sobj->last_section = ret;
 443     }
 444
 445   return ret;
 446 }
 447
 448 /* Add data to a section.  */
 449
 450 const char *
 451 simple_object_write_add_data (simple_object_write *sobj ATTRIBUTE_UNUSED,
 452                               simple_object_write_section *section,
 453                               const void *buffer,
 454                               size_t size, int copy,
 455                               int *err ATTRIBUTE_UNUSED)
 456 {
 457   struct simple_object_write_section_buffer *wsb;
 458
 459   wsb = XNEW (struct simple_object_write_section_buffer);
 460   wsb->next = NULL;
 461   wsb->size = size;
 462
 463   if (!copy)
 464     {
 465       wsb->buffer = buffer;
 466       wsb->free_buffer = NULL;
 467     }
 468   else
 469     {
 470       wsb->free_buffer = (void *) XNEWVEC (char, size);
 471       memcpy (wsb->free_buffer, buffer, size);
 472       wsb->buffer = wsb->free_buffer;
 473     }
 474
 475   if (section->last_buffer == NULL)
 476     {
 477       section->buffers = wsb;
 478       section->last_buffer = wsb;
 479     }
 480   else
 481     {
 482       section->last_buffer->next = wsb;
 483       section->last_buffer = wsb;
 484     }
 485
 486   return NULL;
 487 }
 488
 489 /* Write the complete object file.  */
 490
 491 const char *
 492 simple_object_write_to_file (simple_object_write *sobj, int descriptor,
 493                              int *err)
 494 {
 495   return sobj->functions->write_to_file (sobj, descriptor, err);
 496 }
 497
 498 /* Release an simple_object_write.  */
 499
 500 void
 501 simple_object_release_write (simple_object_write *sobj)
 502 {
 503   simple_object_write_section *section;
 504
 505   free (sobj->segment_name);
 506
 507   section = sobj->sections;
 508   while (section != NULL)
 509     {
 510       struct simple_object_write_section_buffer *buffer;
 511       simple_object_write_section *next_section;
 512
 513       buffer = section->buffers;
 514       while (buffer != NULL)
 515         {
 516           struct simple_object_write_section_buffer *next_buffer;
 517
 518           if (buffer->free_buffer != NULL)
 519             XDELETEVEC (buffer->free_buffer);
 520           next_buffer = buffer->next;
 521           XDELETE (buffer);
 522           buffer = next_buffer;
 523         }
 524
 525       next_section = section->next;
 526       free (section->name);
 527       XDELETE (section);
 528       section = next_section;
 529     }
 530
 531   sobj->functions->release_write (sobj->data);
 532   XDELETE (sobj);
 533 }