bfd/elf-sframe.c

   1 /* .sframe section processing.
   2    Copyright (C) 2022-2024 Free Software Foundation, Inc.
   3
   4    This file is part of BFD, the Binary File Descriptor library.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20
  21 #include "sysdep.h"
  22 #include "bfd.h"
  23 #include "libbfd.h"
  24 #include "elf-bfd.h"
  25 #include "sframe-api.h"
  26
  27 /* Return TRUE if the function has been marked for deletion during the linking
  28    process.  */
  29
  30 static bool
  31 sframe_decoder_func_deleted_p (struct sframe_dec_info *sfd_info,
  32                                unsigned int func_idx)
  33 {
  34   if (func_idx < sfd_info->sfd_fde_count)
  35     return sfd_info->sfd_func_bfdinfo[func_idx].func_deleted_p;
  36
  37   return false;
  38 }
  39
  40 /* Mark the function in the decoder info for deletion.  */
  41
  42 static void
  43 sframe_decoder_mark_func_deleted (struct sframe_dec_info *sfd_info,
  44                                   unsigned int func_idx)
  45 {
  46   if (func_idx < sfd_info->sfd_fde_count)
  47     sfd_info->sfd_func_bfdinfo[func_idx].func_deleted_p = true;
  48 }
  49
  50 /* Get the relocation offset from the decoder info for the given function.  */
  51
  52 static unsigned int
  53 sframe_decoder_get_func_r_offset (struct sframe_dec_info *sfd_info,
  54                                   unsigned int func_idx)
  55 {
  56   BFD_ASSERT (func_idx < sfd_info->sfd_fde_count);
  57   unsigned int func_r_offset
  58     = sfd_info->sfd_func_bfdinfo[func_idx].func_r_offset;
  59   /* There must have been a reloc.  */
  60   BFD_ASSERT (func_r_offset);
  61   return func_r_offset;
  62 }
  63
  64 /* Bookkeep the function relocation offset in the decoder info.  */
  65
  66 static void
  67 sframe_decoder_set_func_r_offset (struct sframe_dec_info *sfd_info,
  68                                   unsigned int func_idx,
  69                                   unsigned int r_offset)
  70 {
  71   if (func_idx < sfd_info->sfd_fde_count)
  72     sfd_info->sfd_func_bfdinfo[func_idx].func_r_offset = r_offset;
  73 }
  74
  75 /* Get the relocation index in the elf_reloc_cookie for the function.  */
  76
  77 static unsigned int
  78 sframe_decoder_get_func_reloc_index (struct sframe_dec_info *sfd_info,
  79                                      unsigned int func_idx)
  80 {
  81   BFD_ASSERT (func_idx < sfd_info->sfd_fde_count);
  82   return sfd_info->sfd_func_bfdinfo[func_idx].func_reloc_index;
  83 }
  84
  85 /* Bookkeep the relocation index in the elf_reloc_cookie for the function.  */
  86
  87 static void
  88 sframe_decoder_set_func_reloc_index (struct sframe_dec_info *sfd_info,
  89                                      unsigned int func_idx,
  90                                      unsigned int reloc_index)
  91 {
  92   if (func_idx < sfd_info->sfd_fde_count)
  93     sfd_info->sfd_func_bfdinfo[func_idx].func_reloc_index = reloc_index;
  94 }
  95
  96 /* Initialize the set of additional information in CFD_INFO,
  97    needed for linking SEC.  Returns TRUE if setup is done successfully.  */
  98
  99 static bool
 100 sframe_decoder_init_func_bfdinfo (asection *sec,
 101                                   struct sframe_dec_info *sfd_info,
 102                                   struct elf_reloc_cookie *cookie)
 103 {
 104   unsigned int fde_count;
 105   unsigned int func_bfdinfo_size, i;
 106
 107   fde_count = sframe_decoder_get_num_fidx (sfd_info->sfd_ctx);
 108   sfd_info->sfd_fde_count = fde_count;
 109
 110   /* Allocate and clear the memory.  */
 111   func_bfdinfo_size = (sizeof (struct sframe_func_bfdinfo)) * fde_count;
 112   sfd_info->sfd_func_bfdinfo
 113     = (struct sframe_func_bfdinfo*) bfd_malloc (func_bfdinfo_size);
 114   if (sfd_info->sfd_func_bfdinfo == NULL)
 115     return false;
 116   memset (sfd_info->sfd_func_bfdinfo, 0, func_bfdinfo_size);
 117
 118   /* For linker generated .sframe sections, we have no relocs.  Skip.  */
 119   if ((sec->flags & SEC_LINKER_CREATED) && cookie->rels == NULL)
 120     return true;
 121
 122   for (i = 0; i < fde_count; i++)
 123     {
 124       cookie->rel = cookie->rels + i;
 125       BFD_ASSERT (cookie->rel < cookie->relend);
 126       /* Bookkeep the relocation offset and relocation index of each function
 127          for later use.  */
 128       sframe_decoder_set_func_r_offset (sfd_info, i, cookie->rel->r_offset);
 129       sframe_decoder_set_func_reloc_index (sfd_info, i,
 130                                            (cookie->rel - cookie->rels));
 131
 132       cookie->rel++;
 133     }
 134   BFD_ASSERT (cookie->rel == cookie->relend);
 135
 136   return true;
 137 }
 138
 139 /* Read the value from CONTENTS at the specified OFFSET for the given ABFD.  */
 140
 141 static bfd_vma
 142 sframe_read_value (bfd *abfd, bfd_byte *contents, unsigned int offset,
 143                    unsigned int width)
 144 {
 145   BFD_ASSERT (contents && offset);
 146   /* Supporting the usecase of reading only the 4-byte relocated
 147      value (signed offset for func start addr) for now.  */
 148   BFD_ASSERT (width == 4);
 149   /* FIXME endianness ?? */
 150   unsigned char *buf = contents + offset;
 151   bfd_vma value = bfd_get_signed_32 (abfd, buf);
 152   return value;
 153 }
 154
 155 /* Return true if there is at least one non-empty .sframe section in
 156    input files.  Can only be called after ld has mapped input to
 157    output sections, and before sections are stripped.  */
 158
 159 bool
 160 _bfd_elf_sframe_present (struct bfd_link_info *info)
 161 {
 162   asection *sframe = bfd_get_section_by_name (info->output_bfd, ".sframe");
 163
 164   if (sframe == NULL)
 165     return false;
 166
 167   /* Count only sections which have at least a single FDE.  */
 168   for (sframe = sframe->map_head.s; sframe != NULL; sframe = sframe->map_head.s)
 169     /* Note that this may become an approximate check in the future when
 170        some ABI/arch begin to use the sfh_auxhdr_len.  When sfh_auxhdr_len has
 171        non-zero value, it will need to be accounted for in the calculation of
 172        the SFrame header size.  */
 173     if (sframe->size > sizeof (sframe_header))
 174       return true;
 175   return false;
 176 }
 177
 178 /* Try to parse .sframe section SEC, which belongs to ABFD.  Store the
 179    information in the section's sec_info field on success.  COOKIE
 180    describes the relocations in SEC.
 181
 182    Returns TRUE if success, FALSE if any error or failure.  */
 183
 184 bool
 185 _bfd_elf_parse_sframe (bfd *abfd,
 186                        struct bfd_link_info *info ATTRIBUTE_UNUSED,
 187                        asection *sec, struct elf_reloc_cookie *cookie)
 188 {
 189   bfd_byte *sfbuf = NULL;
 190   struct sframe_dec_info *sfd_info;
 191   sframe_decoder_ctx *sfd_ctx;
 192   bfd_size_type sf_size;
 193   int decerr = 0;
 194
 195   if (sec->size == 0
 196       || (sec->flags & SEC_HAS_CONTENTS) == 0
 197       || sec->sec_info_type != SEC_INFO_TYPE_NONE)
 198     {
 199       /* This file does not contain .sframe information.  */
 200       return false;
 201     }
 202
 203   if (bfd_is_abs_section (sec->output_section))
 204     {
 205       /* At least one of the sections is being discarded from the
 206          link, so we should just ignore them.  */
 207       return false;
 208     }
 209
 210   /* Read the SFrame stack trace information from abfd.  */
 211   if (!_bfd_elf_mmap_section_contents (abfd, sec, &sfbuf))
 212     goto fail_no_free;
 213
 214   /* Decode the buffer and keep decoded contents for later use.
 215      Relocations are performed later, but are such that the section's
 216      size is unaffected.  */
 217   sfd_info = bfd_malloc (sizeof (struct sframe_dec_info));
 218   sf_size = sec->size;
 219
 220   sfd_info->sfd_ctx = sframe_decode ((const char*)sfbuf, sf_size, &decerr);
 221   sfd_ctx = sfd_info->sfd_ctx;
 222   if (!sfd_ctx)
 223     /* Free'ing up any memory held by decoder context is done by
 224        sframe_decode in case of error.  */
 225     goto fail_no_free;
 226
 227   if (!sframe_decoder_init_func_bfdinfo (sec, sfd_info, cookie))
 228     {
 229       sframe_decoder_free (&sfd_ctx);
 230       goto fail_no_free;
 231     }
 232
 233   elf_section_data (sec)->sec_info = sfd_info;
 234   sec->sec_info_type = SEC_INFO_TYPE_SFRAME;
 235
 236   goto success;
 237
 238 fail_no_free:
 239   _bfd_error_handler
 240    (_("error in %pB(%pA); no .sframe will be created"),
 241     abfd, sec);
 242   return false;
 243 success:
 244   _bfd_elf_munmap_section_contents (sec, sfbuf);
 245   return true;
 246 }
 247
 248 /* This function is called for each input file before the .sframe section
 249    is relocated.  It marks the SFrame FDE for the discarded functions for
 250    deletion.
 251
 252    The function returns TRUE iff any entries have been deleted.  */
 253
 254 bool
 255 _bfd_elf_discard_section_sframe
 256    (asection *sec,
 257     bool (*reloc_symbol_deleted_p) (bfd_vma, void *),
 258     struct elf_reloc_cookie *cookie)
 259 {
 260   bool changed;
 261   bool keep;
 262   unsigned int i;
 263   unsigned int func_desc_offset;
 264   unsigned int num_fidx;
 265   struct sframe_dec_info *sfd_info;
 266
 267   changed = false;
 268   /* FIXME - if relocatable link and changed = true, how does the final
 269      .rela.sframe get updated ?.  */
 270   keep = false;
 271
 272   sfd_info = (struct sframe_dec_info *) elf_section_data (sec)->sec_info;
 273
 274   /* Skip checking for the linker created .sframe sections
 275      (for PLT sections).  */
 276   if ((sec->flags & SEC_LINKER_CREATED) == 0 || cookie->rels != NULL)
 277     {
 278       num_fidx = sframe_decoder_get_num_fidx (sfd_info->sfd_ctx);
 279       for (i = 0; i < num_fidx; i++)
 280         {
 281           func_desc_offset = sframe_decoder_get_func_r_offset (sfd_info, i);
 282
 283           cookie->rel = cookie->rels
 284             + sframe_decoder_get_func_reloc_index (sfd_info, i);
 285           keep = !(*reloc_symbol_deleted_p) (func_desc_offset, cookie);
 286
 287           if (!keep)
 288             {
 289               sframe_decoder_mark_func_deleted (sfd_info, i);
 290               changed = true;
 291             }
 292         }
 293     }
 294   return changed;
 295 }
 296
 297 /* Update the reference to the output .sframe section in the output ELF
 298    BFD ABFD.  Returns true if no error.  */
 299
 300 bool
 301 _bfd_elf_set_section_sframe (bfd *abfd,
 302                                 struct bfd_link_info *info)
 303 {
 304   asection *cfsec;
 305
 306   cfsec = bfd_get_section_by_name (info->output_bfd, ".sframe");
 307   if (!cfsec)
 308     return false;
 309
 310   elf_sframe (abfd) = cfsec;
 311
 312   return true;
 313 }
 314
 315 /* Merge .sframe section SEC.  This is called with the relocated
 316    CONTENTS.  */
 317
 318 bool
 319 _bfd_elf_merge_section_sframe (bfd *abfd,
 320                                struct bfd_link_info *info,
 321                                asection *sec,
 322                                bfd_byte *contents)
 323 {
 324   struct sframe_dec_info *sfd_info;
 325   struct sframe_enc_info *sfe_info;
 326   sframe_decoder_ctx *sfd_ctx;
 327   sframe_encoder_ctx *sfe_ctx;
 328   uint8_t sfd_ctx_abi_arch;
 329   int8_t sfd_ctx_fixed_fp_offset;
 330   int8_t sfd_ctx_fixed_ra_offset;
 331   uint8_t dctx_version;
 332   uint8_t ectx_version;
 333   int encerr = 0;
 334
 335   struct elf_link_hash_table *htab;
 336   asection *cfsec;
 337
 338   /* Sanity check - handle SFrame sections only.  */
 339   if (sec->sec_info_type != SEC_INFO_TYPE_SFRAME)
 340     return false;
 341
 342   sfd_info = (struct sframe_dec_info *) elf_section_data (sec)->sec_info;
 343   sfd_ctx = sfd_info->sfd_ctx;
 344
 345   htab = elf_hash_table (info);
 346   sfe_info = &(htab->sfe_info);
 347   sfe_ctx = sfe_info->sfe_ctx;
 348
 349   /* All input bfds are expected to have a valid SFrame section.  Even if
 350      the SFrame section is empty with only a header, there must be a valid
 351      SFrame decoder context by now.  The SFrame encoder context, however,
 352      will get set later here, if this is the first call to the function.  */
 353   if (sfd_ctx == NULL || sfe_info == NULL)
 354     return false;
 355
 356   if (htab->sfe_info.sfe_ctx == NULL)
 357     {
 358       sfd_ctx_abi_arch = sframe_decoder_get_abi_arch (sfd_ctx);
 359       sfd_ctx_fixed_fp_offset = sframe_decoder_get_fixed_fp_offset (sfd_ctx);
 360       sfd_ctx_fixed_ra_offset = sframe_decoder_get_fixed_ra_offset (sfd_ctx);
 361
 362       /* Valid values are non-zero.  */
 363       if (!sfd_ctx_abi_arch)
 364         return false;
 365
 366       htab->sfe_info.sfe_ctx = sframe_encode (SFRAME_VERSION_2,
 367                                               0, /* SFrame flags.  */
 368                                               sfd_ctx_abi_arch,
 369                                               sfd_ctx_fixed_fp_offset,
 370                                               sfd_ctx_fixed_ra_offset,
 371                                               &encerr);
 372       /* Handle errors from sframe_encode.  */
 373       if (htab->sfe_info.sfe_ctx == NULL)
 374         return false;
 375     }
 376   sfe_ctx = sfe_info->sfe_ctx;
 377
 378   if (sfe_info->sframe_section == NULL)
 379     {
 380       /* Make sure things are set for an eventual write.
 381          Size of the output section is not known until
 382          _bfd_elf_write_section_sframe is ready with the buffer
 383          to write out.  */
 384       cfsec = bfd_get_section_by_name (info->output_bfd, ".sframe");
 385       if (cfsec)
 386         {
 387           sfe_info->sframe_section = cfsec;
 388           // elf_sframe (abfd) = cfsec;
 389         }
 390       else
 391         return false;
 392     }
 393
 394   /* Check that all .sframe sections being linked have the same
 395      ABI/arch.  */
 396   if (sframe_decoder_get_abi_arch (sfd_ctx)
 397       != sframe_encoder_get_abi_arch (sfe_ctx))
 398     {
 399       _bfd_error_handler
 400         (_("input SFrame sections with different abi prevent .sframe"
 401           " generation"));
 402       return false;
 403     }
 404
 405   /* Check that all .sframe sections being linked have the same version.  */
 406   dctx_version = sframe_decoder_get_version (sfd_ctx);
 407   ectx_version = sframe_encoder_get_version (sfe_ctx);
 408   if (dctx_version != SFRAME_VERSION_2 || dctx_version != ectx_version)
 409     {
 410       _bfd_error_handler
 411         (_("input SFrame sections with different format versions prevent"
 412           " .sframe generation"));
 413       return false;
 414     }
 415
 416
 417   /* Iterate over the function descriptor entries and the FREs of the
 418      function from the decoder context.  Add each of them to the encoder
 419      context, if suitable.  */
 420   uint32_t i = 0, j = 0, cur_fidx = 0;
 421
 422   uint32_t num_fidx = sframe_decoder_get_num_fidx (sfd_ctx);
 423   uint32_t num_enc_fidx = sframe_encoder_get_num_fidx (sfe_ctx);
 424
 425   for (i = 0; i < num_fidx; i++)
 426     {
 427       unsigned int num_fres = 0;
 428       int32_t func_start_addr;
 429       bfd_vma address;
 430       uint32_t func_size = 0;
 431       unsigned char func_info = 0;
 432       unsigned int r_offset = 0;
 433       bool pltn_reloc_by_hand = false;
 434       unsigned int pltn_r_offset = 0;
 435       uint8_t rep_block_size = 0;
 436
 437       if (!sframe_decoder_get_funcdesc_v2 (sfd_ctx, i, &num_fres, &func_size,
 438                                            &func_start_addr, &func_info,
 439                                            &rep_block_size))
 440         {
 441           /* If function belongs to a deleted section, skip editing the
 442              function descriptor entry.  */
 443           if (sframe_decoder_func_deleted_p(sfd_info, i))
 444             continue;
 445
 446           /* Don't edit function descriptor entries for relocatable link.  */
 447           if (!bfd_link_relocatable (info))
 448             {
 449               if (!(sec->flags & SEC_LINKER_CREATED))
 450                 {
 451                   /* Get relocated contents by reading the value of the
 452                      relocated function start address at the beginning of the
 453                      function descriptor entry.  */
 454                   r_offset = sframe_decoder_get_func_r_offset (sfd_info, i);
 455                 }
 456               else
 457                 {
 458                   /* Expected to land here when SFrame stack trace info is
 459                      created dynamically for the .plt* sections.  These
 460                      sections are expected to have upto two SFrame FDE entries.
 461                      Although the code should work for > 2,  leaving this
 462                      assert here for safety.  */
 463                   BFD_ASSERT (num_fidx <= 2);
 464                   /* For the first entry, we know the offset of the SFrame FDE's
 465                      sfde_func_start_address.  Side note: see how the value
 466                      of PLT_SFRAME_FDE_START_OFFSET is also set to the
 467                      same.  */
 468                   r_offset = sframe_decoder_get_hdr_size (sfd_ctx);
 469                   /* For any further SFrame FDEs, the generator has already put
 470                      in an offset in place of sfde_func_start_address of the
 471                      corresponding FDE.  We will use it by hand to relocate.  */
 472                   if (i > 0)
 473                     {
 474                       pltn_r_offset
 475                         = r_offset + (i * sizeof (sframe_func_desc_entry));
 476                       pltn_reloc_by_hand = true;
 477                     }
 478                 }
 479
 480               /* Get the SFrame FDE function start address after relocation.  */
 481               address = sframe_read_value (abfd, contents, r_offset, 4);
 482               if (pltn_reloc_by_hand)
 483                 address += sframe_read_value (abfd, contents,
 484                                               pltn_r_offset, 4);
 485               address += (sec->output_offset + r_offset);
 486
 487               /* FIXME For testing only. Cleanup later.  */
 488               // address += (sec->output_section->vma);
 489
 490               func_start_addr = address;
 491             }
 492
 493           /* Update the encoder context with updated content.  */
 494           int err = sframe_encoder_add_funcdesc_v2 (sfe_ctx, func_start_addr,
 495                                                     func_size, func_info,
 496                                                     rep_block_size, num_fres);
 497           cur_fidx++;
 498           BFD_ASSERT (!err);
 499         }
 500
 501       for (j = 0; j < num_fres; j++)
 502         {
 503           sframe_frame_row_entry fre;
 504           if (!sframe_decoder_get_fre (sfd_ctx, i, j, &fre))
 505             {
 506               int err = sframe_encoder_add_fre (sfe_ctx,
 507                                                 cur_fidx-1+num_enc_fidx,
 508                                                 &fre);
 509               BFD_ASSERT (!err);
 510             }
 511         }
 512     }
 513   /* Free the SFrame decoder context.  */
 514   sframe_decoder_free (&sfd_ctx);
 515
 516   return true;
 517 }
 518
 519 /* Write out the .sframe section.  This must be called after
 520    _bfd_elf_merge_section_sframe has been called on all input
 521    .sframe sections.  */
 522
 523 bool
 524 _bfd_elf_write_section_sframe (bfd *abfd, struct bfd_link_info *info)
 525 {
 526   bool retval = true;
 527
 528   struct elf_link_hash_table *htab;
 529   struct sframe_enc_info *sfe_info;
 530   sframe_encoder_ctx *sfe_ctx;
 531   asection *sec;
 532   void *contents;
 533   size_t sec_size;
 534   int err = 0;
 535
 536   htab = elf_hash_table (info);
 537   sfe_info = &htab->sfe_info;
 538   sec = sfe_info->sframe_section;
 539   sfe_ctx = sfe_info->sfe_ctx;
 540
 541   if (sec == NULL)
 542     return true;
 543
 544   contents = sframe_encoder_write (sfe_ctx, &sec_size, &err);
 545   sec->size = (bfd_size_type) sec_size;
 546
 547   if (!bfd_set_section_contents (abfd, sec->output_section, contents,
 548                                  (file_ptr) sec->output_offset,
 549                                  sec->size))
 550     retval = false;
 551   else if (!bfd_link_relocatable (info))
 552     {
 553       Elf_Internal_Shdr *hdr = &elf_section_data (sec)->this_hdr;
 554       hdr->sh_size = sec->size;
 555     }
 556   /* For relocatable links, do not update the section size as the section
 557      contents have not been relocated.  */
 558
 559   sframe_encoder_free (&sfe_ctx);
 560
 561   return retval;
 562 }