libiberty/simple-object.c

   1 /* simple-object.c -- simple routines to read and write object files.
   2    Copyright (C) 2010-2023 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 #ifndef O_BINARY
  48 #define O_BINARY 0
  49 #endif
  50
  51 #include "simple-object-common.h"
  52
  53 /* The known object file formats.  */
  54
  55 static const struct simple_object_functions * const format_functions[] =
  56 {
  57   &simple_object_elf_functions,
  58   &simple_object_mach_o_functions,
  59   &simple_object_coff_functions,
  60   &simple_object_xcoff_functions
  61 };
  62
  63 /* Read data from a file using the simple_object error reporting
  64    conventions.  */
  65
  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)
  70 {
  71   if (lseek (descriptor, offset, SEEK_SET) < 0)
  72     {
  73       *errmsg = "lseek";
  74       *err = errno;
  75       return 0;
  76     }
  77
  78   do
  79     {
  80       ssize_t got = read (descriptor, buffer, size);
  81       if (got == 0)
  82         break;
  83       else if (got > 0)
  84         {
  85           buffer += got;
  86           size -= got;
  87         }
  88       else if (errno != EINTR)
  89         {
  90           *errmsg = "read";
  91           *err = errno;
  92           return 0;
  93         }
  94     }
  95   while (size > 0);
  96
  97   if (size > 0)
  98     {
  99       *errmsg = "file too short";
 100       *err = 0;
 101       return 0;
 102     }
 103
 104   return 1;
 105 }
 106
 107 /* Write data to a file using the simple_object error reporting
 108    conventions.  */
 109
 110 int
 111 simple_object_internal_write (int descriptor, off_t offset,
 112                               const unsigned char *buffer, size_t size,
 113                               const char **errmsg, int *err)
 114 {
 115   if (lseek (descriptor, offset, SEEK_SET) < 0)
 116     {
 117       *errmsg = "lseek";
 118       *err = errno;
 119       return 0;
 120     }
 121
 122   do
 123     {
 124       ssize_t wrote = write (descriptor, buffer, size);
 125       if (wrote == 0)
 126         break;
 127       else if (wrote > 0)
 128         {
 129           buffer += wrote;
 130           size -= wrote;
 131         }
 132       else if (errno != EINTR)
 133         {
 134           *errmsg = "write";
 135           *err = errno;
 136           return 0;
 137         }
 138     }
 139   while (size > 0);
 140
 141   if (size > 0)
 142     {
 143       *errmsg = "short write";
 144       *err = 0;
 145       return 0;
 146     }
 147
 148   return 1;
 149 }
 150
 151 /* Open for read.  */
 152
 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)
 157 {
 158   unsigned char header[SIMPLE_OBJECT_MATCH_HEADER_LEN];
 159   size_t len, i;
 160
 161   if (!simple_object_internal_read (descriptor, offset, header,
 162                                     SIMPLE_OBJECT_MATCH_HEADER_LEN,
 163                                     errmsg, err))
 164     return NULL;
 165
 166   len = sizeof (format_functions) / sizeof (format_functions[0]);
 167   for (i = 0; i < len; ++i)
 168     {
 169       void *data;
 170
 171       data = format_functions[i]->match (header, descriptor, offset,
 172                                          segment_name, errmsg, err);
 173       if (data != NULL)
 174         {
 175           simple_object_read *ret;
 176
 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;
 183         }
 184     }
 185
 186   *errmsg = "file not recognized";
 187   *err = 0;
 188   return NULL;
 189 }
 190
 191 /* Find all sections.  */
 192
 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)
 198 {
 199   return sobj->functions->find_sections (sobj, pfn, data, err);
 200 }
 201
 202 /* Internal data passed to find_one_section.  */
 203
 204 struct find_one_section_data
 205 {
 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;
 214 };
 215
 216 /* Internal function passed to find_sections.  */
 217
 218 static int
 219 find_one_section (void *data, const char *name, off_t offset, off_t length)
 220 {
 221   struct find_one_section_data *fosd = (struct find_one_section_data *) data;
 222
 223   if (strcmp (name, fosd->name) != 0)
 224     return 1;
 225
 226   *fosd->offset = offset;
 227   *fosd->length = length;
 228   fosd->found = 1;
 229
 230   /* Stop iteration.  */
 231   return 0;
 232 }
 233
 234 /* Find a section.  */
 235
 236 int
 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)
 240 {
 241   struct find_one_section_data fosd;
 242
 243   fosd.name = name;
 244   fosd.offset = offset;
 245   fosd.length = length;
 246   fosd.found = 0;
 247
 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;
 255 }
 256
 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.  */
 261
 262 static char *
 263 handle_lto_debug_sections (const char *name, int rename)
 264 {
 265   char *newname = rename ? XCNEWVEC (char, strlen (name) + 1)
 266                          : xstrdup (name);
 267
 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)
 274     {
 275       if (rename)
 276         strncpy (newname, name, sizeof (".rela") - 1);
 277       name += sizeof (".rela") - 1;
 278     }
 279   else if (strncmp (name, ".rel", sizeof (".rel") - 1) == 0)
 280     {
 281       if (rename)
 282         strncpy (newname, name, sizeof (".rel") - 1);
 283       name += sizeof (".rel") - 1;
 284     }
 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 .note.gnu.property section under the same name if present.  */
 297   else if (strcmp (name, ".note.gnu.property") == 0)
 298     return strcpy (newname, name);
 299   /* Copy over .comment section under the same name if present.  Solaris
 300      ld uses them to relax its checking of ELF gABI access rules for
 301      COMDAT sections in objects produced by GCC.  */
 302   else if (strcmp (name, ".comment") == 0)
 303     return strcpy (newname, name);
 304   /* Copy over .GCC.command.line section under the same name if present.  */
 305   else if (strcmp (name, ".GCC.command.line") == 0)
 306     return strcpy (newname, name);
 307   /* Copy over .ctf section under the same name if present.  */
 308   else if (strcmp (name, ".ctf") == 0)
 309     return strcpy (newname, name);
 310   /* Copy over .BTF section under the same name if present.  */
 311   else if (strcmp (name, ".BTF") == 0)
 312     return strcpy (newname, name);
 313   free (newname);
 314   return NULL;
 315 }
 316
 317 /* Wrapper for handle_lto_debug_sections.  */
 318
 319 static char *
 320 handle_lto_debug_sections_rename (const char *name)
 321 {
 322   return handle_lto_debug_sections (name, 1);
 323 }
 324
 325 /* Wrapper for handle_lto_debug_sections.  */
 326
 327 static char *
 328 handle_lto_debug_sections_norename (const char *name)
 329 {
 330   return handle_lto_debug_sections (name, 0);
 331 }
 332
 333 /* Copy LTO debug sections.  */
 334
 335 const char *
 336 simple_object_copy_lto_debug_sections (simple_object_read *sobj,
 337                                        const char *dest, int *err, int rename)
 338 {
 339   const char *errmsg;
 340   simple_object_write *dest_sobj;
 341   simple_object_attributes *attrs;
 342   int outfd;
 343
 344   if (! sobj->functions->copy_lto_debug_sections)
 345     {
 346       *err = EINVAL;
 347       return "simple_object_copy_lto_debug_sections not implemented";
 348     }
 349
 350   attrs = simple_object_fetch_attributes (sobj, &errmsg, err);
 351   if (! attrs)
 352     return errmsg;
 353   dest_sobj = simple_object_start_write (attrs, NULL, &errmsg, err);
 354   simple_object_release_attributes (attrs);
 355   if (! dest_sobj)
 356     return errmsg;
 357
 358   errmsg = sobj->functions->copy_lto_debug_sections
 359                  (sobj, dest_sobj,
 360                   rename ? handle_lto_debug_sections_rename
 361                          : handle_lto_debug_sections_norename,  err);
 362   if (errmsg)
 363     {
 364       simple_object_release_write (dest_sobj);
 365       return errmsg;
 366     }
 367
 368   outfd = open (dest, O_CREAT|O_WRONLY|O_TRUNC|O_BINARY, 00777);
 369   if (outfd == -1)
 370     {
 371       *err = errno;
 372       simple_object_release_write (dest_sobj);
 373       return "open failed";
 374     }
 375
 376   errmsg = simple_object_write_to_file (dest_sobj, outfd, err);
 377   close (outfd);
 378   if (errmsg)
 379     {
 380       simple_object_release_write (dest_sobj);
 381       return errmsg;
 382     }
 383
 384   simple_object_release_write (dest_sobj);
 385   return NULL;
 386 }
 387
 388 /* Fetch attributes.  */
 389
 390 simple_object_attributes *
 391 simple_object_fetch_attributes (simple_object_read *sobj, const char **errmsg,
 392                                 int *err)
 393 {
 394   void *data;
 395   simple_object_attributes *ret;
 396
 397   data = sobj->functions->fetch_attributes (sobj, errmsg, err);
 398   if (data == NULL)
 399     return NULL;
 400   ret = XNEW (simple_object_attributes);
 401   ret->functions = sobj->functions;
 402   ret->data = data;
 403   return ret;
 404 }
 405
 406 /* Release an simple_object_read.  */
 407
 408 void
 409 simple_object_release_read (simple_object_read *sobj)
 410 {
 411   sobj->functions->release_read (sobj->data);
 412   XDELETE (sobj);
 413 }
 414
 415 /* Merge attributes.  */
 416
 417 const char *
 418 simple_object_attributes_merge (simple_object_attributes *to,
 419                                 simple_object_attributes *from,
 420                                 int *err)
 421 {
 422   if (to->functions != from->functions)
 423     {
 424       *err = 0;
 425       return "different object file format";
 426     }
 427   return to->functions->attributes_merge (to->data, from->data, err);
 428 }
 429
 430 /* Release an attributes structure.  */
 431
 432 void
 433 simple_object_release_attributes (simple_object_attributes *attrs)
 434 {
 435   attrs->functions->release_attributes (attrs->data);
 436   XDELETE (attrs);
 437 }
 438
 439 /* Start creating an object file.  */
 440
 441 simple_object_write *
 442 simple_object_start_write (simple_object_attributes *attrs,
 443                            const char *segment_name, const char **errmsg,
 444                            int *err)
 445 {
 446   void *data;
 447   simple_object_write *ret;
 448
 449   data = attrs->functions->start_write (attrs->data, errmsg, err);
 450   if (data == NULL)
 451     return NULL;
 452   ret = XNEW (simple_object_write);
 453   ret->functions = attrs->functions;
 454   ret->segment_name = segment_name ? xstrdup (segment_name) : NULL;
 455   ret->sections = NULL;
 456   ret->last_section = NULL;
 457   ret->data = data;
 458   return ret;
 459 }
 460
 461 /* Start creating a section.  */
 462
 463 simple_object_write_section *
 464 simple_object_write_create_section (simple_object_write *sobj, const char *name,
 465                                     unsigned int align,
 466                                     const char **errmsg ATTRIBUTE_UNUSED,
 467                                     int *err ATTRIBUTE_UNUSED)
 468 {
 469   simple_object_write_section *ret;
 470
 471   ret = XNEW (simple_object_write_section);
 472   ret->next = NULL;
 473   ret->name = xstrdup (name);
 474   ret->align = align;
 475   ret->buffers = NULL;
 476   ret->last_buffer = NULL;
 477
 478   if (sobj->last_section == NULL)
 479     {
 480       sobj->sections = ret;
 481       sobj->last_section = ret;
 482     }
 483   else
 484     {
 485       sobj->last_section->next = ret;
 486       sobj->last_section = ret;
 487     }
 488
 489   return ret;
 490 }
 491
 492 /* Add data to a section.  */
 493
 494 const char *
 495 simple_object_write_add_data (simple_object_write *sobj ATTRIBUTE_UNUSED,
 496                               simple_object_write_section *section,
 497                               const void *buffer,
 498                               size_t size, int copy,
 499                               int *err ATTRIBUTE_UNUSED)
 500 {
 501   struct simple_object_write_section_buffer *wsb;
 502
 503   wsb = XNEW (struct simple_object_write_section_buffer);
 504   wsb->next = NULL;
 505   wsb->size = size;
 506
 507   if (!copy)
 508     {
 509       wsb->buffer = buffer;
 510       wsb->free_buffer = NULL;
 511     }
 512   else
 513     {
 514       wsb->free_buffer = (void *) XNEWVEC (char, size);
 515       memcpy (wsb->free_buffer, buffer, size);
 516       wsb->buffer = wsb->free_buffer;
 517     }
 518
 519   if (section->last_buffer == NULL)
 520     {
 521       section->buffers = wsb;
 522       section->last_buffer = wsb;
 523     }
 524   else
 525     {
 526       section->last_buffer->next = wsb;
 527       section->last_buffer = wsb;
 528     }
 529
 530   return NULL;
 531 }
 532
 533 /* Write the complete object file.  */
 534
 535 const char *
 536 simple_object_write_to_file (simple_object_write *sobj, int descriptor,
 537                              int *err)
 538 {
 539   return sobj->functions->write_to_file (sobj, descriptor, err);
 540 }
 541
 542 /* Release an simple_object_write.  */
 543
 544 void
 545 simple_object_release_write (simple_object_write *sobj)
 546 {
 547   simple_object_write_section *section;
 548
 549   free (sobj->segment_name);
 550
 551   section = sobj->sections;
 552   while (section != NULL)
 553     {
 554       struct simple_object_write_section_buffer *buffer;
 555       simple_object_write_section *next_section;
 556
 557       buffer = section->buffers;
 558       while (buffer != NULL)
 559         {
 560           struct simple_object_write_section_buffer *next_buffer;
 561
 562           if (buffer->free_buffer != NULL)
 563             XDELETEVEC (buffer->free_buffer);
 564           next_buffer = buffer->next;
 565           XDELETE (buffer);
 566           buffer = next_buffer;
 567         }
 568
 569       next_section = section->next;
 570       free (section->name);
 571       XDELETE (section);
 572       section = next_section;
 573     }
 574
 575   sobj->functions->release_write (sobj->data);
 576   XDELETE (sobj);
 577 }