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 }