Coverage Report

Created: 2024-05-21 06:29

/src/binutils-gdb/bfd/libbfd.c
Line
Count
Source (jump to first uncovered line)
1
/* Assorted BFD support routines, only used internally.
2
   Copyright (C) 1990-2024 Free Software Foundation, Inc.
3
   Written by Cygnus Support.
4
5
   This file is part of BFD, the Binary File Descriptor library.
6
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 3 of the License, or
10
   (at your option) any later version.
11
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
17
   You should have received a copy of the GNU General Public License
18
   along with this program; if not, write to the Free Software
19
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20
   MA 02110-1301, USA.  */
21
22
#include "sysdep.h"
23
#include "bfd.h"
24
#include "elf-bfd.h"
25
#include "libbfd.h"
26
#include "objalloc.h"
27
28
#ifndef HAVE_GETPAGESIZE
29
#define getpagesize() 2048
30
#endif
31
32
/*
33
SECTION
34
  Implementation details
35
36
SUBSECTION
37
  Internal functions
38
39
DESCRIPTION
40
  These routines are used within BFD.
41
  They are not intended for export, but are documented here for
42
  completeness.
43
*/
44
45
bool
46
_bfd_bool_bfd_false (bfd *abfd ATTRIBUTE_UNUSED)
47
0
{
48
0
  return false;
49
0
}
50
51
bool
52
_bfd_bool_bfd_asymbol_false (bfd *abfd ATTRIBUTE_UNUSED,
53
           asymbol *sym ATTRIBUTE_UNUSED)
54
1.59M
{
55
1.59M
  return false;
56
1.59M
}
57
58
/* A routine which is used in target vectors for unsupported
59
   operations.  */
60
61
bool
62
_bfd_bool_bfd_false_error (bfd *ignore ATTRIBUTE_UNUSED)
63
10.0k
{
64
10.0k
  bfd_set_error (bfd_error_invalid_operation);
65
10.0k
  return false;
66
10.0k
}
67
68
bool
69
_bfd_bool_bfd_link_false_error (bfd *abfd,
70
        struct bfd_link_info *info ATTRIBUTE_UNUSED)
71
0
{
72
0
  return _bfd_bool_bfd_false_error (abfd);
73
0
}
74
75
/* A routine which is used in target vectors for supported operations
76
   which do not actually do anything.  */
77
78
bool
79
_bfd_bool_bfd_true (bfd *ignore ATTRIBUTE_UNUSED)
80
19.2k
{
81
19.2k
  return true;
82
19.2k
}
83
84
bool
85
_bfd_bool_bfd_link_true (bfd *abfd ATTRIBUTE_UNUSED,
86
       struct bfd_link_info *info ATTRIBUTE_UNUSED)
87
0
{
88
0
  return true;
89
0
}
90
91
bool
92
_bfd_bool_bfd_bfd_true (bfd *ibfd ATTRIBUTE_UNUSED,
93
      bfd *obfd ATTRIBUTE_UNUSED)
94
6
{
95
6
  return true;
96
6
}
97
98
bool
99
_bfd_bool_bfd_uint_true (bfd *abfd ATTRIBUTE_UNUSED,
100
       unsigned int flags ATTRIBUTE_UNUSED)
101
0
{
102
0
  return true;
103
0
}
104
105
bool
106
_bfd_bool_bfd_asection_bfd_asection_true (bfd *ibfd ATTRIBUTE_UNUSED,
107
            asection *isec ATTRIBUTE_UNUSED,
108
            bfd *obfd ATTRIBUTE_UNUSED,
109
            asection *osec ATTRIBUTE_UNUSED)
110
0
{
111
0
  return true;
112
0
}
113
114
bool
115
_bfd_bool_bfd_asymbol_bfd_asymbol_true (bfd *ibfd ATTRIBUTE_UNUSED,
116
          asymbol *isym ATTRIBUTE_UNUSED,
117
          bfd *obfd ATTRIBUTE_UNUSED,
118
          asymbol *osym ATTRIBUTE_UNUSED)
119
772
{
120
772
  return true;
121
772
}
122
123
bool
124
_bfd_bool_bfd_ptr_true (bfd *abfd ATTRIBUTE_UNUSED,
125
      void *ptr ATTRIBUTE_UNUSED)
126
5.02k
{
127
5.02k
  return true;
128
5.02k
}
129
130
/* A routine which is used in target vectors for unsupported
131
   operations which return a pointer value.  */
132
133
void *
134
_bfd_ptr_bfd_null_error (bfd *ignore ATTRIBUTE_UNUSED)
135
115k
{
136
115k
  bfd_set_error (bfd_error_invalid_operation);
137
115k
  return NULL;
138
115k
}
139
140
int
141
_bfd_int_bfd_0 (bfd *ignore ATTRIBUTE_UNUSED)
142
0
{
143
0
  return 0;
144
0
}
145
146
unsigned int
147
_bfd_uint_bfd_0 (bfd *ignore ATTRIBUTE_UNUSED)
148
0
{
149
0
   return 0;
150
0
}
151
152
long
153
_bfd_long_bfd_0 (bfd *ignore ATTRIBUTE_UNUSED)
154
0
{
155
0
  return 0;
156
0
}
157
158
/* A routine which is used in target vectors for unsupported
159
   operations which return -1 on error.  */
160
161
long
162
_bfd_long_bfd_n1_error (bfd *ignore_abfd ATTRIBUTE_UNUSED)
163
26.7k
{
164
26.7k
  bfd_set_error (bfd_error_invalid_operation);
165
26.7k
  return -1;
166
26.7k
}
167
168
void
169
_bfd_void_bfd (bfd *ignore ATTRIBUTE_UNUSED)
170
3.37M
{
171
3.37M
}
172
173
void
174
_bfd_void_bfd_link (bfd *abfd ATTRIBUTE_UNUSED,
175
        struct bfd_link_info *info ATTRIBUTE_UNUSED)
176
0
{
177
0
}
178
179
void
180
_bfd_void_bfd_asection (bfd *abfd ATTRIBUTE_UNUSED,
181
      asection *sec ATTRIBUTE_UNUSED)
182
0
{
183
0
}
184
185
long
186
_bfd_norelocs_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
187
             asection *sec ATTRIBUTE_UNUSED)
188
0
{
189
0
  return sizeof (arelent *);
190
0
}
191
192
long
193
_bfd_norelocs_canonicalize_reloc (bfd *abfd ATTRIBUTE_UNUSED,
194
          asection *sec ATTRIBUTE_UNUSED,
195
          arelent **relptr,
196
          asymbol **symbols ATTRIBUTE_UNUSED)
197
0
{
198
0
  *relptr = NULL;
199
0
  return 0;
200
0
}
201
202
void
203
_bfd_norelocs_set_reloc (bfd *abfd ATTRIBUTE_UNUSED,
204
       asection *sec ATTRIBUTE_UNUSED,
205
       arelent **relptr ATTRIBUTE_UNUSED,
206
       unsigned int count ATTRIBUTE_UNUSED)
207
0
{
208
  /* Do nothing.  */
209
0
}
210
211
bool
212
_bfd_nocore_core_file_matches_executable_p
213
  (bfd *ignore_core_bfd ATTRIBUTE_UNUSED,
214
   bfd *ignore_exec_bfd ATTRIBUTE_UNUSED)
215
0
{
216
0
  bfd_set_error (bfd_error_invalid_operation);
217
0
  return false;
218
0
}
219
220
/* Routine to handle core_file_failing_command entry point for targets
221
   without core file support.  */
222
223
char *
224
_bfd_nocore_core_file_failing_command (bfd *ignore_abfd ATTRIBUTE_UNUSED)
225
0
{
226
0
  bfd_set_error (bfd_error_invalid_operation);
227
0
  return NULL;
228
0
}
229
230
/* Routine to handle core_file_failing_signal entry point for targets
231
   without core file support.  */
232
233
int
234
_bfd_nocore_core_file_failing_signal (bfd *ignore_abfd ATTRIBUTE_UNUSED)
235
0
{
236
0
  bfd_set_error (bfd_error_invalid_operation);
237
0
  return 0;
238
0
}
239
240
/* Routine to handle the core_file_pid entry point for targets without
241
   core file support.  */
242
243
int
244
_bfd_nocore_core_file_pid (bfd *ignore_abfd ATTRIBUTE_UNUSED)
245
0
{
246
0
  bfd_set_error (bfd_error_invalid_operation);
247
0
  return 0;
248
0
}
249
250
bfd_cleanup
251
_bfd_dummy_target (bfd *ignore_abfd ATTRIBUTE_UNUSED)
252
8.37M
{
253
8.37M
  bfd_set_error (bfd_error_wrong_format);
254
8.37M
  return 0;
255
8.37M
}
256

257
/* Allocate memory using malloc.  */
258
259
#ifndef SSIZE_MAX
260
20.6M
#define SSIZE_MAX ((size_t) -1 >> 1)
261
#endif
262
263
/*
264
INTERNAL_FUNCTION
265
  bfd_malloc
266
267
SYNOPSIS
268
  void *bfd_malloc (bfd_size_type {*size*});
269
270
DESCRIPTION
271
  Returns a pointer to an allocated block of memory that is at least
272
  SIZE bytes long.  If SIZE is 0 then it will be treated as if it were
273
  1.  If SIZE is too big then NULL will be returned.
274
  
275
  Returns NULL upon error and sets bfd_error.
276
*/
277
void *
278
bfd_malloc (bfd_size_type size)
279
20.5M
{
280
20.5M
  void *ptr;
281
20.5M
  size_t sz = (size_t) size;
282
283
20.5M
  if (size != sz
284
      /* This is to pacify memory checkers like valgrind.  */
285
20.5M
      || sz > SSIZE_MAX)
286
0
    {
287
0
      bfd_set_error (bfd_error_no_memory);
288
0
      return NULL;
289
0
    }
290
291
20.5M
  ptr = malloc (sz ? sz : 1);
292
20.5M
  if (ptr == NULL)
293
0
    bfd_set_error (bfd_error_no_memory);
294
295
20.5M
  return ptr;
296
20.5M
}
297
298
/*
299
INTERNAL_FUNCTION
300
  bfd_realloc
301
302
SYNOPSIS
303
  void *bfd_realloc (void *{*mem*}, bfd_size_type {*size*});
304
305
DESCRIPTION
306
  Returns a pointer to an allocated block of memory that is at least
307
  SIZE bytes long.  If SIZE is 0 then it will be treated as if it were
308
  1.  If SIZE is too big then NULL will be returned.
309
  
310
  If MEM is not NULL then it must point to an allocated block of memory.
311
  If this block is large enough then MEM may be used as the return
312
  value for this function, but this is not guaranteed.
313
314
  If MEM is not returned then the first N bytes in the returned block
315
  will be identical to the first N bytes in region pointed to by MEM,
316
  where N is the lessor of SIZE and the length of the region of memory
317
  currently addressed by MEM.
318
319
  Returns NULL upon error and sets bfd_error.
320
*/
321
void *
322
bfd_realloc (void *ptr, bfd_size_type size)
323
158k
{
324
158k
  void *ret;
325
158k
  size_t sz = (size_t) size;
326
327
158k
  if (ptr == NULL)
328
52.0k
    return bfd_malloc (size);
329
330
106k
  if (size != sz
331
      /* This is to pacify memory checkers like valgrind.  */
332
106k
      || sz > SSIZE_MAX)
333
0
    {
334
0
      bfd_set_error (bfd_error_no_memory);
335
0
      return NULL;
336
0
    }
337
338
  /* The behaviour of realloc(0) is implementation defined,
339
     but for this function we always allocate memory.  */
340
106k
  ret = realloc (ptr, sz ? sz : 1);
341
342
106k
  if (ret == NULL)
343
0
    bfd_set_error (bfd_error_no_memory);
344
345
106k
  return ret;
346
106k
}
347
348
/*
349
INTERNAL_FUNCTION
350
  bfd_realloc_or_free
351
352
SYNOPSIS
353
  void *bfd_realloc_or_free (void *{*mem*}, bfd_size_type {*size*});
354
355
DESCRIPTION
356
  Returns a pointer to an allocated block of memory that is at least
357
  SIZE bytes long.  If SIZE is 0 then no memory will be allocated,
358
  MEM will be freed, and NULL will be returned.  This will not cause
359
  bfd_error to be set.
360
361
  If SIZE is too big then NULL will be returned and bfd_error will be
362
  set. 
363
  
364
  If MEM is not NULL then it must point to an allocated block of memory.
365
  If this block is large enough then MEM may be used as the return
366
  value for this function, but this is not guaranteed.
367
368
  If MEM is not returned then the first N bytes in the returned block
369
  will be identical to the first N bytes in region pointed to by MEM,
370
  where N is the lessor of SIZE and the length of the region of memory
371
  currently addressed by MEM.
372
*/
373
void *
374
bfd_realloc_or_free (void *ptr, bfd_size_type size)
375
78.9k
{
376
78.9k
  void *ret;
377
378
  /* The behaviour of realloc(0) is implementation defined, but
379
     for this function we treat it is always freeing the memory.  */
380
78.9k
  if (size == 0)
381
0
    {
382
0
      free (ptr);
383
0
      return NULL;
384
0
    }
385
      
386
78.9k
  ret = bfd_realloc (ptr, size);
387
78.9k
  if (ret == NULL)
388
0
    free (ptr);
389
390
78.9k
  return ret;
391
78.9k
}
392
393
/*
394
INTERNAL_FUNCTION
395
  bfd_zmalloc
396
397
SYNOPSIS
398
  void *bfd_zmalloc (bfd_size_type {*size*});
399
400
DESCRIPTION
401
  Returns a pointer to an allocated block of memory that is at least
402
  SIZE bytes long.  If SIZE is 0 then it will be treated as if it were
403
  1.  If SIZE is too big then NULL will be returned.
404
  
405
  Returns NULL upon error and sets bfd_error.
406
407
  If NULL is not returned then the allocated block of memory will
408
  have been cleared.
409
*/
410
void *
411
bfd_zmalloc (bfd_size_type size)
412
4.01M
{
413
4.01M
  void *ptr = bfd_malloc (size);
414
415
4.01M
  if (ptr != NULL)
416
4.01M
    memset (ptr, 0, size ? (size_t) size : 1);
417
418
4.01M
  return ptr;
419
4.01M
}
420
421
/*
422
FUNCTION
423
  bfd_alloc
424
425
SYNOPSIS
426
  void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
427
428
DESCRIPTION
429
  Allocate a block of @var{wanted} bytes of memory attached to
430
  <<abfd>> and return a pointer to it.
431
*/
432
433
void *
434
bfd_alloc (bfd *abfd, bfd_size_type size)
435
942M
{
436
942M
  void *ret;
437
942M
  unsigned long ul_size = (unsigned long) size;
438
439
942M
  if (size != ul_size
440
      /* Note - although objalloc_alloc takes an unsigned long as its
441
   argument, internally the size is treated as a signed long.  This can
442
   lead to problems where, for example, a request to allocate -1 bytes
443
   can result in just 1 byte being allocated, rather than
444
   ((unsigned long) -1) bytes.  Also memory checkers will often
445
   complain about attempts to allocate a negative amount of memory.
446
   So to stop these problems we fail if the size is negative.  */
447
942M
      || ((signed long) ul_size) < 0)
448
0
    {
449
0
      bfd_set_error (bfd_error_no_memory);
450
0
      return NULL;
451
0
    }
452
453
942M
  ret = objalloc_alloc ((struct objalloc *) abfd->memory, ul_size);
454
942M
  if (ret == NULL)
455
0
    bfd_set_error (bfd_error_no_memory);
456
942M
  else
457
942M
    abfd->alloc_size += size;
458
942M
  return ret;
459
942M
}
460
461
/*
462
FUNCTION
463
  bfd_zalloc
464
465
SYNOPSIS
466
  void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
467
468
DESCRIPTION
469
  Allocate a block of @var{wanted} bytes of zeroed memory
470
  attached to <<abfd>> and return a pointer to it.
471
*/
472
473
void *
474
bfd_zalloc (bfd *abfd, bfd_size_type size)
475
274M
{
476
274M
  void *res;
477
478
274M
  res = bfd_alloc (abfd, size);
479
274M
  if (res)
480
274M
    memset (res, 0, (size_t) size);
481
274M
  return res;
482
274M
}
483
484
/*
485
FUNCTION
486
  bfd_release
487
488
SYNOPSIS
489
  void bfd_release (bfd *, void *);
490
491
DESCRIPTION
492
  Free a block allocated for a BFD.
493
  Note: Also frees all more recently allocated blocks!
494
*/
495
496
void
497
bfd_release (bfd *abfd, void *block)
498
537M
{
499
537M
  objalloc_free_block ((struct objalloc *) abfd->memory, block);
500
537M
}
501
502
/*
503
INTERNAL_FUNCTION
504
  bfd_write_bigendian_4byte_int
505
506
SYNOPSIS
507
  bool bfd_write_bigendian_4byte_int (bfd *, unsigned int);
508
509
DESCRIPTION
510
  Write a 4 byte integer @var{i} to the output BFD @var{abfd}, in big
511
  endian order regardless of what else is going on.  This is useful in
512
  archives.
513
514
*/
515
bool
516
bfd_write_bigendian_4byte_int (bfd *abfd, unsigned int i)
517
0
{
518
0
  bfd_byte buffer[4];
519
0
  bfd_putb32 (i, buffer);
520
0
  return bfd_write (buffer, 4, abfd) == 4;
521
0
}
522
523

524
/** The do-it-yourself (byte) sex-change kit */
525
526
/* The middle letter e.g. get<b>short indicates Big or Little endian
527
   target machine.  It doesn't matter what the byte order of the host
528
   machine is; these routines work for either.  */
529
530
/* FIXME: Should these take a count argument?
531
   Answer (gnu@cygnus.com):  No, but perhaps they should be inline
532
           functions in swap.h #ifdef __GNUC__.
533
           Gprof them later and find out.  */
534
535
/*
536
FUNCTION
537
  bfd_put_size
538
FUNCTION
539
  bfd_get_size
540
541
DESCRIPTION
542
  These macros as used for reading and writing raw data in
543
  sections; each access (except for bytes) is vectored through
544
  the target format of the BFD and mangled accordingly. The
545
  mangling performs any necessary endian translations and
546
  removes alignment restrictions.  Note that types accepted and
547
  returned by these macros are identical so they can be swapped
548
  around in macros---for example, @file{libaout.h} defines <<GET_WORD>>
549
  to either <<bfd_get_32>> or <<bfd_get_64>>.
550
551
  In the put routines, @var{val} must be a <<bfd_vma>>.  If we are on a
552
  system without prototypes, the caller is responsible for making
553
  sure that is true, with a cast if necessary.  We don't cast
554
  them in the macro definitions because that would prevent <<lint>>
555
  or <<gcc -Wall>> from detecting sins such as passing a pointer.
556
  To detect calling these with less than a <<bfd_vma>>, use
557
  <<gcc -Wconversion>> on a host with 64 bit <<bfd_vma>>'s.
558
559
.
560
.{* Byte swapping macros for user section data.  *}
561
.
562
.#define bfd_put_8(abfd, val, ptr) \
563
.  ((void) (*((bfd_byte *) (ptr)) = (val) & 0xff))
564
.#define bfd_put_signed_8 \
565
.  bfd_put_8
566
.#define bfd_get_8(abfd, ptr) \
567
.  ((bfd_vma) *(const bfd_byte *) (ptr) & 0xff)
568
.#define bfd_get_signed_8(abfd, ptr) \
569
.  ((((bfd_signed_vma) *(const bfd_byte *) (ptr) & 0xff) ^ 0x80) - 0x80)
570
.
571
.#define bfd_put_16(abfd, val, ptr) \
572
.  BFD_SEND (abfd, bfd_putx16, ((val),(ptr)))
573
.#define bfd_put_signed_16 \
574
.  bfd_put_16
575
.#define bfd_get_16(abfd, ptr) \
576
.  BFD_SEND (abfd, bfd_getx16, (ptr))
577
.#define bfd_get_signed_16(abfd, ptr) \
578
.  BFD_SEND (abfd, bfd_getx_signed_16, (ptr))
579
.
580
.#define bfd_put_24(abfd, val, ptr) \
581
.  do         \
582
.    if (bfd_big_endian (abfd))   \
583
.      bfd_putb24 ((val), (ptr)); \
584
.    else       \
585
.      bfd_putl24 ((val), (ptr)); \
586
.  while (0)
587
.
588
.bfd_vma bfd_getb24 (const void *p);
589
.bfd_vma bfd_getl24 (const void *p);
590
.
591
.#define bfd_get_24(abfd, ptr) \
592
.  (bfd_big_endian (abfd) ? bfd_getb24 (ptr) : bfd_getl24 (ptr))
593
.
594
.#define bfd_put_32(abfd, val, ptr) \
595
.  BFD_SEND (abfd, bfd_putx32, ((val),(ptr)))
596
.#define bfd_put_signed_32 \
597
.  bfd_put_32
598
.#define bfd_get_32(abfd, ptr) \
599
.  BFD_SEND (abfd, bfd_getx32, (ptr))
600
.#define bfd_get_signed_32(abfd, ptr) \
601
.  BFD_SEND (abfd, bfd_getx_signed_32, (ptr))
602
.
603
.#define bfd_put_64(abfd, val, ptr) \
604
.  BFD_SEND (abfd, bfd_putx64, ((val), (ptr)))
605
.#define bfd_put_signed_64 \
606
.  bfd_put_64
607
.#define bfd_get_64(abfd, ptr) \
608
.  BFD_SEND (abfd, bfd_getx64, (ptr))
609
.#define bfd_get_signed_64(abfd, ptr) \
610
.  BFD_SEND (abfd, bfd_getx_signed_64, (ptr))
611
.
612
.#define bfd_get(bits, abfd, ptr)     \
613
.  ((bits) == 8 ? bfd_get_8 (abfd, ptr)     \
614
.   : (bits) == 16 ? bfd_get_16 (abfd, ptr)   \
615
.   : (bits) == 32 ? bfd_get_32 (abfd, ptr)   \
616
.   : (bits) == 64 ? bfd_get_64 (abfd, ptr)   \
617
.   : (abort (), (bfd_vma) - 1))
618
.
619
.#define bfd_put(bits, abfd, val, ptr)      \
620
.  ((bits) == 8 ? bfd_put_8  (abfd, val, ptr)   \
621
.   : (bits) == 16 ? bfd_put_16 (abfd, val, ptr)  \
622
.   : (bits) == 32 ? bfd_put_32 (abfd, val, ptr)  \
623
.   : (bits) == 64 ? bfd_put_64 (abfd, val, ptr)  \
624
.   : (abort (), (void) 0))
625
.
626
*/
627
628
/*
629
FUNCTION
630
  bfd_h_put_size
631
  bfd_h_get_size
632
633
DESCRIPTION
634
  These macros have the same function as their <<bfd_get_x>>
635
  brethren, except that they are used for removing information
636
  for the header records of object files. Believe it or not,
637
  some object files keep their header records in big endian
638
  order and their data in little endian order.
639
.
640
.{* Byte swapping macros for file header data.  *}
641
.
642
.#define bfd_h_put_8(abfd, val, ptr) \
643
.  bfd_put_8 (abfd, val, ptr)
644
.#define bfd_h_put_signed_8(abfd, val, ptr) \
645
.  bfd_put_8 (abfd, val, ptr)
646
.#define bfd_h_get_8(abfd, ptr) \
647
.  bfd_get_8 (abfd, ptr)
648
.#define bfd_h_get_signed_8(abfd, ptr) \
649
.  bfd_get_signed_8 (abfd, ptr)
650
.
651
.#define bfd_h_put_16(abfd, val, ptr) \
652
.  BFD_SEND (abfd, bfd_h_putx16, (val, ptr))
653
.#define bfd_h_put_signed_16 \
654
.  bfd_h_put_16
655
.#define bfd_h_get_16(abfd, ptr) \
656
.  BFD_SEND (abfd, bfd_h_getx16, (ptr))
657
.#define bfd_h_get_signed_16(abfd, ptr) \
658
.  BFD_SEND (abfd, bfd_h_getx_signed_16, (ptr))
659
.
660
.#define bfd_h_put_32(abfd, val, ptr) \
661
.  BFD_SEND (abfd, bfd_h_putx32, (val, ptr))
662
.#define bfd_h_put_signed_32 \
663
.  bfd_h_put_32
664
.#define bfd_h_get_32(abfd, ptr) \
665
.  BFD_SEND (abfd, bfd_h_getx32, (ptr))
666
.#define bfd_h_get_signed_32(abfd, ptr) \
667
.  BFD_SEND (abfd, bfd_h_getx_signed_32, (ptr))
668
.
669
.#define bfd_h_put_64(abfd, val, ptr) \
670
.  BFD_SEND (abfd, bfd_h_putx64, (val, ptr))
671
.#define bfd_h_put_signed_64 \
672
.  bfd_h_put_64
673
.#define bfd_h_get_64(abfd, ptr) \
674
.  BFD_SEND (abfd, bfd_h_getx64, (ptr))
675
.#define bfd_h_get_signed_64(abfd, ptr) \
676
.  BFD_SEND (abfd, bfd_h_getx_signed_64, (ptr))
677
.
678
.{* Aliases for the above, which should eventually go away.  *}
679
.
680
.#define H_PUT_64  bfd_h_put_64
681
.#define H_PUT_32  bfd_h_put_32
682
.#define H_PUT_16  bfd_h_put_16
683
.#define H_PUT_8   bfd_h_put_8
684
.#define H_PUT_S64 bfd_h_put_signed_64
685
.#define H_PUT_S32 bfd_h_put_signed_32
686
.#define H_PUT_S16 bfd_h_put_signed_16
687
.#define H_PUT_S8  bfd_h_put_signed_8
688
.#define H_GET_64  bfd_h_get_64
689
.#define H_GET_32  bfd_h_get_32
690
.#define H_GET_16  bfd_h_get_16
691
.#define H_GET_8   bfd_h_get_8
692
.#define H_GET_S64 bfd_h_get_signed_64
693
.#define H_GET_S32 bfd_h_get_signed_32
694
.#define H_GET_S16 bfd_h_get_signed_16
695
.#define H_GET_S8  bfd_h_get_signed_8
696
.
697
.*/
698
699
/* Sign extension to bfd_signed_vma.  */
700
92.0k
#define COERCE16(x) (((bfd_vma) (x) ^ 0x8000) - 0x8000)
701
54.3M
#define COERCE32(x) (((bfd_vma) (x) ^ 0x80000000) - 0x80000000)
702
#define COERCE64(x) \
703
20.2M
  (((uint64_t) (x) ^ ((uint64_t) 1 << 63)) - ((uint64_t) 1 << 63))
704
705
/*
706
FUNCTION
707
  Byte swapping routines.
708
709
SYNOPSIS
710
  uint64_t bfd_getb64 (const void *);
711
  uint64_t bfd_getl64 (const void *);
712
  int64_t bfd_getb_signed_64 (const void *);
713
  int64_t bfd_getl_signed_64 (const void *);
714
  bfd_vma bfd_getb32 (const void *);
715
  bfd_vma bfd_getl32 (const void *);
716
  bfd_signed_vma bfd_getb_signed_32 (const void *);
717
  bfd_signed_vma bfd_getl_signed_32 (const void *);
718
  bfd_vma bfd_getb16 (const void *);
719
  bfd_vma bfd_getl16 (const void *);
720
  bfd_signed_vma bfd_getb_signed_16 (const void *);
721
  bfd_signed_vma bfd_getl_signed_16 (const void *);
722
  void bfd_putb64 (uint64_t, void *);
723
  void bfd_putl64 (uint64_t, void *);
724
  void bfd_putb32 (bfd_vma, void *);
725
  void bfd_putl32 (bfd_vma, void *);
726
  void bfd_putb24 (bfd_vma, void *);
727
  void bfd_putl24 (bfd_vma, void *);
728
  void bfd_putb16 (bfd_vma, void *);
729
  void bfd_putl16 (bfd_vma, void *);
730
  uint64_t bfd_get_bits (const void *, int, bool);
731
  void bfd_put_bits (uint64_t, void *, int, bool);
732
733
DESCRIPTION
734
  Read and write integers in a particular endian order.  getb
735
  and putb functions handle big-endian, getl and putl handle
736
  little-endian.  bfd_get_bits and bfd_put_bits specify
737
  big-endian by passing TRUE in the last parameter,
738
  little-endian by passing FALSE.
739
*/
740
741
bfd_vma
742
bfd_getb16 (const void *p)
743
245M
{
744
245M
  const bfd_byte *addr = (const bfd_byte *) p;
745
245M
  return (addr[0] << 8) | addr[1];
746
245M
}
747
748
bfd_vma
749
bfd_getl16 (const void *p)
750
696M
{
751
696M
  const bfd_byte *addr = (const bfd_byte *) p;
752
696M
  return (addr[1] << 8) | addr[0];
753
696M
}
754
755
bfd_signed_vma
756
bfd_getb_signed_16 (const void *p)
757
16
{
758
16
  const bfd_byte *addr = (const bfd_byte *) p;
759
16
  return COERCE16 ((addr[0] << 8) | addr[1]);
760
16
}
761
762
bfd_signed_vma
763
bfd_getl_signed_16 (const void *p)
764
92.0k
{
765
92.0k
  const bfd_byte *addr = (const bfd_byte *) p;
766
92.0k
  return COERCE16 ((addr[1] << 8) | addr[0]);
767
92.0k
}
768
769
void
770
bfd_putb16 (bfd_vma data, void *p)
771
7.65k
{
772
7.65k
  bfd_byte *addr = (bfd_byte *) p;
773
7.65k
  addr[0] = (data >> 8) & 0xff;
774
7.65k
  addr[1] = data & 0xff;
775
7.65k
}
776
777
void
778
bfd_putl16 (bfd_vma data, void *p)
779
130k
{
780
130k
  bfd_byte *addr = (bfd_byte *) p;
781
130k
  addr[0] = data & 0xff;
782
130k
  addr[1] = (data >> 8) & 0xff;
783
130k
}
784
785
void
786
bfd_putb24 (bfd_vma data, void *p)
787
0
{
788
0
  bfd_byte *addr = (bfd_byte *) p;
789
0
  addr[0] = (data >> 16) & 0xff;
790
0
  addr[1] = (data >> 8) & 0xff;
791
0
  addr[2] = data & 0xff;
792
0
}
793
794
void
795
bfd_putl24 (bfd_vma data, void *p)
796
0
{
797
0
  bfd_byte *addr = (bfd_byte *) p;
798
0
  addr[0] = data & 0xff;
799
0
  addr[1] = (data >> 8) & 0xff;
800
0
  addr[2] = (data >> 16) & 0xff;
801
0
}
802
803
bfd_vma
804
bfd_getb24 (const void *p)
805
0
{
806
0
  const bfd_byte *addr = (const bfd_byte *) p;
807
0
  uint32_t v;
808
809
0
  v =  (uint32_t) addr[0] << 16;
810
0
  v |= (uint32_t) addr[1] << 8;
811
0
  v |= (uint32_t) addr[2];
812
0
  return v;
813
0
}
814
815
bfd_vma
816
bfd_getl24 (const void *p)
817
0
{
818
0
  const bfd_byte *addr = (const bfd_byte *) p;
819
0
  uint32_t v;
820
821
0
  v = (uint32_t) addr[0];
822
0
  v |= (uint32_t) addr[1] << 8;
823
0
  v |= (uint32_t) addr[2] << 16;
824
0
  return v;
825
0
}
826
827
bfd_vma
828
bfd_getb32 (const void *p)
829
557M
{
830
557M
  const bfd_byte *addr = (const bfd_byte *) p;
831
557M
  uint32_t v;
832
833
557M
  v = (uint32_t) addr[0] << 24;
834
557M
  v |= (uint32_t) addr[1] << 16;
835
557M
  v |= (uint32_t) addr[2] << 8;
836
557M
  v |= (uint32_t) addr[3];
837
557M
  return v;
838
557M
}
839
840
bfd_vma
841
bfd_getl32 (const void *p)
842
1.39G
{
843
1.39G
  const bfd_byte *addr = (const bfd_byte *) p;
844
1.39G
  uint32_t v;
845
846
1.39G
  v = (uint32_t) addr[0];
847
1.39G
  v |= (uint32_t) addr[1] << 8;
848
1.39G
  v |= (uint32_t) addr[2] << 16;
849
1.39G
  v |= (uint32_t) addr[3] << 24;
850
1.39G
  return v;
851
1.39G
}
852
853
bfd_signed_vma
854
bfd_getb_signed_32 (const void *p)
855
237k
{
856
237k
  const bfd_byte *addr = (const bfd_byte *) p;
857
237k
  uint32_t v;
858
859
237k
  v = (uint32_t) addr[0] << 24;
860
237k
  v |= (uint32_t) addr[1] << 16;
861
237k
  v |= (uint32_t) addr[2] << 8;
862
237k
  v |= (uint32_t) addr[3];
863
237k
  return COERCE32 (v);
864
237k
}
865
866
bfd_signed_vma
867
bfd_getl_signed_32 (const void *p)
868
54.0M
{
869
54.0M
  const bfd_byte *addr = (const bfd_byte *) p;
870
54.0M
  uint32_t v;
871
872
54.0M
  v = (uint32_t) addr[0];
873
54.0M
  v |= (uint32_t) addr[1] << 8;
874
54.0M
  v |= (uint32_t) addr[2] << 16;
875
54.0M
  v |= (uint32_t) addr[3] << 24;
876
54.0M
  return COERCE32 (v);
877
54.0M
}
878
879
uint64_t
880
bfd_getb64 (const void *p)
881
43.6M
{
882
43.6M
  const bfd_byte *addr = (const bfd_byte *) p;
883
43.6M
  uint64_t v;
884
885
43.6M
  v  = addr[0]; v <<= 8;
886
43.6M
  v |= addr[1]; v <<= 8;
887
43.6M
  v |= addr[2]; v <<= 8;
888
43.6M
  v |= addr[3]; v <<= 8;
889
43.6M
  v |= addr[4]; v <<= 8;
890
43.6M
  v |= addr[5]; v <<= 8;
891
43.6M
  v |= addr[6]; v <<= 8;
892
43.6M
  v |= addr[7];
893
894
43.6M
  return v;
895
43.6M
}
896
897
uint64_t
898
bfd_getl64 (const void *p)
899
111M
{
900
111M
  const bfd_byte *addr = (const bfd_byte *) p;
901
111M
  uint64_t v;
902
903
111M
  v  = addr[7]; v <<= 8;
904
111M
  v |= addr[6]; v <<= 8;
905
111M
  v |= addr[5]; v <<= 8;
906
111M
  v |= addr[4]; v <<= 8;
907
111M
  v |= addr[3]; v <<= 8;
908
111M
  v |= addr[2]; v <<= 8;
909
111M
  v |= addr[1]; v <<= 8;
910
111M
  v |= addr[0];
911
912
111M
  return v;
913
111M
}
914
915
int64_t
916
bfd_getb_signed_64 (const void *p)
917
85.7k
{
918
85.7k
  const bfd_byte *addr = (const bfd_byte *) p;
919
85.7k
  uint64_t v;
920
921
85.7k
  v  = addr[0]; v <<= 8;
922
85.7k
  v |= addr[1]; v <<= 8;
923
85.7k
  v |= addr[2]; v <<= 8;
924
85.7k
  v |= addr[3]; v <<= 8;
925
85.7k
  v |= addr[4]; v <<= 8;
926
85.7k
  v |= addr[5]; v <<= 8;
927
85.7k
  v |= addr[6]; v <<= 8;
928
85.7k
  v |= addr[7];
929
930
85.7k
  return COERCE64 (v);
931
85.7k
}
932
933
int64_t
934
bfd_getl_signed_64 (const void *p)
935
20.1M
{
936
20.1M
  const bfd_byte *addr = (const bfd_byte *) p;
937
20.1M
  uint64_t v;
938
939
20.1M
  v  = addr[7]; v <<= 8;
940
20.1M
  v |= addr[6]; v <<= 8;
941
20.1M
  v |= addr[5]; v <<= 8;
942
20.1M
  v |= addr[4]; v <<= 8;
943
20.1M
  v |= addr[3]; v <<= 8;
944
20.1M
  v |= addr[2]; v <<= 8;
945
20.1M
  v |= addr[1]; v <<= 8;
946
20.1M
  v |= addr[0];
947
948
20.1M
  return COERCE64 (v);
949
20.1M
}
950
951
void
952
bfd_putb32 (bfd_vma data, void *p)
953
3.54M
{
954
3.54M
  bfd_byte *addr = (bfd_byte *) p;
955
3.54M
  addr[0] = (data >> 24) & 0xff;
956
3.54M
  addr[1] = (data >> 16) & 0xff;
957
3.54M
  addr[2] = (data >>  8) & 0xff;
958
3.54M
  addr[3] = data & 0xff;
959
3.54M
}
960
961
void
962
bfd_putl32 (bfd_vma data, void *p)
963
181k
{
964
181k
  bfd_byte *addr = (bfd_byte *) p;
965
181k
  addr[0] = data & 0xff;
966
181k
  addr[1] = (data >>  8) & 0xff;
967
181k
  addr[2] = (data >> 16) & 0xff;
968
181k
  addr[3] = (data >> 24) & 0xff;
969
181k
}
970
971
void
972
bfd_putb64 (uint64_t data, void *p)
973
3.98k
{
974
3.98k
  bfd_byte *addr = (bfd_byte *) p;
975
3.98k
  addr[0] = (data >> (7*8)) & 0xff;
976
3.98k
  addr[1] = (data >> (6*8)) & 0xff;
977
3.98k
  addr[2] = (data >> (5*8)) & 0xff;
978
3.98k
  addr[3] = (data >> (4*8)) & 0xff;
979
3.98k
  addr[4] = (data >> (3*8)) & 0xff;
980
3.98k
  addr[5] = (data >> (2*8)) & 0xff;
981
3.98k
  addr[6] = (data >> (1*8)) & 0xff;
982
3.98k
  addr[7] = (data >> (0*8)) & 0xff;
983
3.98k
}
984
985
void
986
bfd_putl64 (uint64_t data, void *p)
987
355k
{
988
355k
  bfd_byte *addr = (bfd_byte *) p;
989
355k
  addr[7] = (data >> (7*8)) & 0xff;
990
355k
  addr[6] = (data >> (6*8)) & 0xff;
991
355k
  addr[5] = (data >> (5*8)) & 0xff;
992
355k
  addr[4] = (data >> (4*8)) & 0xff;
993
355k
  addr[3] = (data >> (3*8)) & 0xff;
994
355k
  addr[2] = (data >> (2*8)) & 0xff;
995
355k
  addr[1] = (data >> (1*8)) & 0xff;
996
355k
  addr[0] = (data >> (0*8)) & 0xff;
997
355k
}
998
999
void
1000
bfd_put_bits (uint64_t data, void *p, int bits, bool big_p)
1001
48.5k
{
1002
48.5k
  bfd_byte *addr = (bfd_byte *) p;
1003
48.5k
  int i;
1004
48.5k
  int bytes;
1005
1006
48.5k
  if (bits % 8 != 0)
1007
0
    abort ();
1008
1009
48.5k
  bytes = bits / 8;
1010
224k
  for (i = 0; i < bytes; i++)
1011
176k
    {
1012
176k
      int addr_index = big_p ? bytes - i - 1 : i;
1013
1014
176k
      addr[addr_index] = data & 0xff;
1015
176k
      data >>= 8;
1016
176k
    }
1017
48.5k
}
1018
1019
uint64_t
1020
bfd_get_bits (const void *p, int bits, bool big_p)
1021
300M
{
1022
300M
  const bfd_byte *addr = (const bfd_byte *) p;
1023
300M
  uint64_t data;
1024
300M
  int i;
1025
300M
  int bytes;
1026
1027
300M
  if (bits % 8 != 0)
1028
0
    abort ();
1029
1030
300M
  data = 0;
1031
300M
  bytes = bits / 8;
1032
1.11G
  for (i = 0; i < bytes; i++)
1033
811M
    {
1034
811M
      int addr_index = big_p ? i : bytes - i - 1;
1035
1036
811M
      data = (data << 8) | addr[addr_index];
1037
811M
    }
1038
1039
300M
  return data;
1040
300M
}
1041

1042
#ifdef USE_MMAP
1043
/* Allocate a page to track mmapped memory and return the page and
1044
   the first entry.  Return NULL if mmap fails.  */
1045
1046
static struct bfd_mmapped *
1047
bfd_allocate_mmapped_page (bfd *abfd, struct bfd_mmapped_entry **entry)
1048
158
{
1049
158
  struct bfd_mmapped * mmapped
1050
158
    = (struct bfd_mmapped *) mmap (NULL, _bfd_pagesize,
1051
158
           PROT_READ | PROT_WRITE,
1052
158
           MAP_PRIVATE | MAP_ANONYMOUS,
1053
158
           -1, 0);
1054
158
  if (mmapped == MAP_FAILED)
1055
0
    return NULL;
1056
1057
158
  mmapped->next = abfd->mmapped;
1058
158
  mmapped->max_entry
1059
158
    = ((_bfd_pagesize - offsetof (struct bfd_mmapped, entries))
1060
158
       / sizeof (struct bfd_mmapped_entry));
1061
158
  mmapped->next_entry = 1;
1062
158
  abfd->mmapped = mmapped;
1063
158
  *entry = mmapped->entries;
1064
158
  return mmapped;
1065
158
}
1066
1067
/* Mmap a memory region of RSIZE bytes with PROT at the current offset.
1068
   Return mmap address and size in MAP_ADDR and MAP_SIZE.  Return NULL
1069
   on invalid input and MAP_FAILED for mmap failure.  */
1070
1071
static void *
1072
bfd_mmap_local (bfd *abfd, size_t rsize, int prot, void **map_addr,
1073
    size_t *map_size)
1074
4.08k
{
1075
  /* We mmap on the underlying file.  In an archive it might be nice
1076
     to limit RSIZE to the element size, but that can be fuzzed and
1077
     the offset returned by bfd_tell is relative to the start of the
1078
     element.  Therefore to reliably stop access beyond the end of a
1079
     file (and resulting bus errors) we must work with the underlying
1080
     file offset and size, and trust that callers will limit access to
1081
     within an archive element.  */
1082
7.59k
  while (abfd->my_archive != NULL
1083
7.59k
   && !bfd_is_thin_archive (abfd->my_archive))
1084
3.51k
    abfd = abfd->my_archive;
1085
1086
4.08k
  ufile_ptr filesize = bfd_get_size (abfd);
1087
4.08k
  ufile_ptr offset = bfd_tell (abfd);
1088
4.08k
  if (filesize < offset || filesize - offset < rsize)
1089
3.65k
    {
1090
3.65k
      bfd_set_error (bfd_error_file_truncated);
1091
3.65k
      return NULL;
1092
3.65k
    }
1093
1094
426
  void *mem;
1095
426
  mem = bfd_mmap (abfd, NULL, rsize, prot, MAP_PRIVATE, offset,
1096
426
      map_addr, map_size);
1097
426
  return mem;
1098
4.08k
}
1099
1100
/* Mmap a readonly memory region of RSIZE bytes at the current offset.
1101
   Return mmap address and size in MAP_ADDR and MAP_SIZE.  Return NULL
1102
   on invalid input and MAP_FAILED for mmap failure.  */
1103
1104
void *
1105
_bfd_mmap_readonly_temporary (bfd *abfd, size_t rsize, void **map_addr,
1106
            size_t *map_size)
1107
4.70k
{
1108
  /* Use mmap only if section size >= the minimum mmap section size.  */
1109
4.70k
  if (rsize < _bfd_minimum_mmap_size)
1110
4.54k
    {
1111
4.54k
      void *mem = _bfd_malloc_and_read (abfd, rsize, rsize);
1112
      /* NB: Set *MAP_ADDR to MEM and *MAP_SIZE to 0 to indicate that
1113
   _bfd_malloc_and_read is called.  */
1114
4.54k
      *map_addr = mem;
1115
4.54k
      *map_size = 0;
1116
4.54k
      return mem;
1117
4.54k
    }
1118
1119
157
  return bfd_mmap_local (abfd, rsize, PROT_READ, map_addr, map_size);
1120
4.70k
}
1121
1122
/* Munmap RSIZE bytes at PTR.  */
1123
1124
void
1125
_bfd_munmap_readonly_temporary (void *ptr, size_t rsize)
1126
69.5k
{
1127
  /* NB: Since _bfd_munmap_readonly_temporary is called like free, PTR
1128
     may be NULL.  Otherwise, PTR and RSIZE must be valid.  If RSIZE is
1129
     0, _bfd_malloc_and_read is called.  */
1130
69.5k
  if (ptr == NULL)
1131
62.0k
    return;
1132
7.58k
  if (rsize != 0)
1133
152
    {
1134
152
      if (munmap (ptr, rsize) != 0)
1135
0
  abort ();
1136
152
    }
1137
7.43k
  else
1138
7.43k
    free (ptr);
1139
7.58k
}
1140
1141
/* Mmap a readonly memory region of RSIZE bytes at the current offset.
1142
   Return NULL on invalid input or mmap failure.  */
1143
1144
void *
1145
_bfd_mmap_readonly_persistent (bfd *abfd, size_t rsize)
1146
186k
{
1147
  /* Use mmap only if section size >= the minimum mmap section size.  */
1148
186k
  if (rsize < _bfd_minimum_mmap_size)
1149
182k
    return _bfd_alloc_and_read (abfd, rsize, rsize);
1150
1151
3.92k
  void *mem, *map_addr;
1152
3.92k
  size_t map_size;
1153
3.92k
  mem = bfd_mmap_local (abfd, rsize, PROT_READ, &map_addr, &map_size);
1154
3.92k
  if (mem == NULL)
1155
3.65k
    return mem;
1156
274
  if (mem == MAP_FAILED)
1157
0
    return _bfd_alloc_and_read (abfd, rsize, rsize);
1158
1159
274
  struct bfd_mmapped_entry *entry;
1160
274
  unsigned int next_entry;
1161
274
  struct bfd_mmapped *mmapped = abfd->mmapped;
1162
274
  if (mmapped != NULL
1163
274
      && (next_entry = mmapped->next_entry) < mmapped->max_entry)
1164
116
    {
1165
116
      entry = &mmapped->entries[next_entry];
1166
116
      mmapped->next_entry++;
1167
116
    }
1168
158
  else
1169
158
    {
1170
158
      mmapped = bfd_allocate_mmapped_page (abfd, &entry);
1171
158
      if (mmapped == NULL)
1172
0
  {
1173
0
    munmap (map_addr, map_size);
1174
0
    return NULL;
1175
0
  }
1176
158
    }
1177
1178
274
  entry->addr = map_addr;
1179
274
  entry->size = map_size;
1180
1181
274
  return mem;
1182
274
}
1183
#endif
1184
1185
/* Attempt to read *SIZE_P bytes from ABFD's iostream to *DATA_P.
1186
   Return true if the full the amount has been read.  If *DATA_P is
1187
   NULL, mmap should be used, return the memory address at the
1188
   current offset in *DATA_P as well as return mmap address and size
1189
   in *MMAP_BASE and *SIZE_P.  Otherwise, return NULL in *MMAP_BASE
1190
   and 0 in *SIZE_P.  If FINAL_LINK is true, this is called from
1191
   elf_link_read_relocs_from_section.  */
1192
1193
bool
1194
_bfd_mmap_read_temporary (void **data_p, size_t *size_p,
1195
        void **mmap_base, bfd *abfd,
1196
        bool final_link ATTRIBUTE_UNUSED)
1197
32.5k
{
1198
32.5k
  void *data = *data_p;
1199
32.5k
  size_t size = *size_p;
1200
1201
32.5k
#ifdef USE_MMAP
1202
  /* NB: When FINAL_LINK is true, the size of the preallocated buffer
1203
     is _bfd_minimum_mmap_size and use mmap if the data size >=
1204
     _bfd_minimum_mmap_size.  Otherwise, use mmap if ABFD isn't an IR
1205
     input or the data size >= _bfd_minimum_mmap_size.  */
1206
32.5k
  bool use_mmmap;
1207
32.5k
  bool mmap_size = size >= _bfd_minimum_mmap_size;
1208
32.5k
  if (final_link)
1209
0
    use_mmmap = mmap_size;
1210
32.5k
  else
1211
32.5k
    use_mmmap = (mmap_size
1212
32.5k
     && data == NULL
1213
32.5k
     && (abfd->flags & BFD_PLUGIN) == 0);
1214
32.5k
  if (use_mmmap)
1215
104
    {
1216
104
      void *mmaped = _bfd_mmap_readonly_temporary (abfd, size,
1217
104
               mmap_base,
1218
104
               size_p);
1219
      /* MAP_FAILED is returned when called from GDB on an object with
1220
   opncls_iovec.  Use bfd_read in this case.  */
1221
104
      if (mmaped != MAP_FAILED)
1222
104
  {
1223
104
    if (mmaped == NULL)
1224
0
      abort ();
1225
104
    *data_p = mmaped;
1226
104
    return true;
1227
104
  }
1228
104
    }
1229
32.4k
#endif
1230
1231
32.4k
  if (data == NULL)
1232
3.23k
    {
1233
3.23k
      data = bfd_malloc (size);
1234
3.23k
      if (data == NULL)
1235
0
  return false;
1236
3.23k
      *data_p = data;
1237
      /* NB: _bfd_munmap_readonly_temporary will free *MMAP_BASE if
1238
   *SIZE_P == 0.  */
1239
3.23k
      *mmap_base = data;
1240
3.23k
    }
1241
29.2k
  else
1242
29.2k
    *mmap_base = NULL;
1243
32.4k
  *size_p = 0;
1244
32.4k
  return bfd_read (data, size, abfd) == size;
1245
32.4k
}
1246
1247
/* Default implementation */
1248
1249
bool
1250
_bfd_generic_get_section_contents (bfd *abfd,
1251
           sec_ptr section,
1252
           void *location,
1253
           file_ptr offset,
1254
           bfd_size_type count)
1255
1.44M
{
1256
1.44M
  bfd_size_type sz;
1257
1.44M
  if (count == 0)
1258
0
    return true;
1259
1260
1.44M
  if (section->compress_status != COMPRESS_SECTION_NONE)
1261
0
    {
1262
0
      _bfd_error_handler
1263
  /* xgettext:c-format */
1264
0
  (_("%pB: unable to get decompressed section %pA"),
1265
0
   abfd, section);
1266
0
      bfd_set_error (bfd_error_invalid_operation);
1267
0
      return false;
1268
0
    }
1269
1270
1.44M
#ifdef USE_MMAP
1271
1.44M
  if (section->mmapped_p
1272
1.44M
      && (section->contents != NULL || location != NULL))
1273
0
    {
1274
0
      _bfd_error_handler
1275
  /* xgettext:c-format */
1276
0
  (_("%pB: mapped section %pA has non-NULL buffer"),
1277
0
   abfd, section);
1278
0
      bfd_set_error (bfd_error_invalid_operation);
1279
0
      return false;
1280
0
    }
1281
1.44M
#endif
1282
1283
1.44M
  sz = bfd_get_section_limit_octets (abfd, section);
1284
1.44M
  if (offset + count < count
1285
1.44M
      || offset + count > sz
1286
1.44M
      || (abfd->my_archive != NULL
1287
1.44M
    && !bfd_is_thin_archive (abfd->my_archive)
1288
1.44M
    && ((ufile_ptr) section->filepos + offset + count
1289
192k
        > arelt_size (abfd))))
1290
81.3k
    {
1291
81.3k
      bfd_set_error (bfd_error_invalid_operation);
1292
81.3k
      return false;
1293
81.3k
    }
1294
1295
1.36M
  if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
1296
41.6k
    return false;
1297
1298
1.32M
#ifdef USE_MMAP
1299
1.32M
  if (section->mmapped_p)
1300
0
    {
1301
0
      if (location != 0
1302
0
    || bfd_get_flavour (abfd) != bfd_target_elf_flavour)
1303
0
  abort ();
1304
1305
0
      int prot = ((section->reloc_count == 0)
1306
0
      ? PROT_READ : PROT_READ | PROT_WRITE);
1307
1308
0
      location = bfd_mmap_local
1309
0
  (abfd, count, prot, &elf_section_data (section)->contents_addr,
1310
0
   &elf_section_data (section)->contents_size);
1311
1312
0
      if (location == NULL)
1313
0
  return false;
1314
1315
      /* Check for iovec not supporting mmap.  */
1316
0
      if (location != MAP_FAILED)
1317
0
  {
1318
0
    section->contents = location;
1319
0
    return true;
1320
0
  }
1321
1322
      /* Malloc the buffer and call bfd_read.  */
1323
0
      location = (bfd_byte *) bfd_malloc (count);
1324
0
      if (location == NULL)
1325
0
  {
1326
0
    if (bfd_get_error () == bfd_error_no_memory)
1327
0
      _bfd_error_handler
1328
        /* xgettext:c-format */
1329
0
        (_("error: %pB(%pA) is too large (%#" PRIx64 " bytes)"),
1330
0
         abfd, section, (uint64_t) count);
1331
0
    return false;
1332
0
  }
1333
0
      section->contents = location;
1334
0
    }
1335
1.32M
#endif
1336
1337
1.32M
  if (bfd_read (location, count, abfd) != count)
1338
842k
    return false;
1339
1340
479k
  return true;
1341
1.32M
}
1342
1343
/* This generic function can only be used in implementations where creating
1344
   NEW sections is disallowed.  It is useful in patching existing sections
1345
   in read-write files, though.  See other set_section_contents functions
1346
   to see why it doesn't work for new sections.  */
1347
bool
1348
_bfd_generic_set_section_contents (bfd *abfd,
1349
           sec_ptr section,
1350
           const void *location,
1351
           file_ptr offset,
1352
           bfd_size_type count)
1353
911
{
1354
911
  if (count == 0)
1355
0
    return true;
1356
1357
911
  if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
1358
911
      || bfd_write (location, count, abfd) != count)
1359
0
    return false;
1360
1361
911
  return true;
1362
911
}
1363
1364
/*
1365
INTERNAL_FUNCTION
1366
  bfd_log2
1367
1368
SYNOPSIS
1369
  unsigned int bfd_log2 (bfd_vma x);
1370
1371
DESCRIPTION
1372
  Return the log base 2 of the value supplied, rounded up.  E.g., an
1373
  @var{x} of 1025 returns 11.  A @var{x} of 0 returns 0.
1374
*/
1375
1376
unsigned int
1377
bfd_log2 (bfd_vma x)
1378
1.79M
{
1379
1.79M
  unsigned int result = 0;
1380
1381
1.79M
  if (x <= 1)
1382
802k
    return result;
1383
997k
  --x;
1384
997k
  do
1385
13.2M
    ++result;
1386
13.2M
  while ((x >>= 1) != 0);
1387
997k
  return result;
1388
1.79M
}
1389
1390
bool
1391
bfd_generic_is_local_label_name (bfd *abfd, const char *name)
1392
0
{
1393
0
  char locals_prefix = (bfd_get_symbol_leading_char (abfd) == '_') ? 'L' : '.';
1394
1395
0
  return name[0] == locals_prefix;
1396
0
}
1397
1398
/* Helper function for reading uleb128 encoded data.  */
1399
1400
bfd_vma
1401
_bfd_read_unsigned_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
1402
         bfd_byte *buf,
1403
         unsigned int *bytes_read_ptr)
1404
0
{
1405
0
  bfd_vma result;
1406
0
  unsigned int num_read;
1407
0
  unsigned int shift;
1408
0
  bfd_byte byte;
1409
1410
0
  result = 0;
1411
0
  shift = 0;
1412
0
  num_read = 0;
1413
0
  do
1414
0
    {
1415
0
      byte = bfd_get_8 (abfd, buf);
1416
0
      buf++;
1417
0
      num_read++;
1418
0
      if (shift < 8 * sizeof (result))
1419
0
  {
1420
0
    result |= (((bfd_vma) byte & 0x7f) << shift);
1421
0
    shift += 7;
1422
0
  }
1423
0
    }
1424
0
  while (byte & 0x80);
1425
0
  *bytes_read_ptr = num_read;
1426
0
  return result;
1427
0
}
1428
1429
/* Read in a LEB128 encoded value from ABFD starting at *PTR.
1430
   If SIGN is true, return a signed LEB128 value.
1431
   *PTR is incremented by the number of bytes read.
1432
   No bytes will be read at address END or beyond.  */
1433
1434
bfd_vma
1435
_bfd_safe_read_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
1436
           bfd_byte **ptr,
1437
           bool sign,
1438
           const bfd_byte * const end)
1439
2.26M
{
1440
2.26M
  bfd_vma result = 0;
1441
2.26M
  unsigned int shift = 0;
1442
2.26M
  bfd_byte byte = 0;
1443
2.26M
  bfd_byte *data = *ptr;
1444
1445
2.71M
  while (data < end)
1446
2.70M
    {
1447
2.70M
      byte = bfd_get_8 (abfd, data);
1448
2.70M
      data++;
1449
2.70M
      if (shift < 8 * sizeof (result))
1450
2.63M
  {
1451
2.63M
    result |= ((bfd_vma) (byte & 0x7f)) << shift;
1452
2.63M
    shift += 7;
1453
2.63M
  }
1454
2.70M
      if ((byte & 0x80) == 0)
1455
2.25M
  break;
1456
2.70M
    }
1457
1458
2.26M
  *ptr = data;
1459
1460
2.26M
  if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
1461
120k
    result |= -((bfd_vma) 1 << shift);
1462
1463
2.26M
  return result;
1464
2.26M
}
1465
1466
/* Helper function for reading sleb128 encoded data.  */
1467
1468
bfd_signed_vma
1469
_bfd_read_signed_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
1470
       bfd_byte *buf,
1471
       unsigned int *bytes_read_ptr)
1472
0
{
1473
0
  bfd_vma result;
1474
0
  unsigned int shift;
1475
0
  unsigned int num_read;
1476
0
  bfd_byte byte;
1477
1478
0
  result = 0;
1479
0
  shift = 0;
1480
0
  num_read = 0;
1481
0
  do
1482
0
    {
1483
0
      byte = bfd_get_8 (abfd, buf);
1484
0
      buf ++;
1485
0
      num_read ++;
1486
0
      if (shift < 8 * sizeof (result))
1487
0
  {
1488
0
    result |= (((bfd_vma) byte & 0x7f) << shift);
1489
0
    shift += 7;
1490
0
  }
1491
0
    }
1492
0
  while (byte & 0x80);
1493
0
  if (shift < 8 * sizeof (result) && (byte & 0x40))
1494
0
    result |= (((bfd_vma) -1) << shift);
1495
0
  *bytes_read_ptr = num_read;
1496
0
  return result;
1497
0
}
1498
1499
/* Write VAL in uleb128 format to P.
1500
   END indicates the last byte of allocated space for the uleb128 value to fit
1501
   in.
1502
   Return a pointer to the byte following the last byte that was written, or
1503
   NULL if the uleb128 value does not fit in the allocated space between P and
1504
   END.  */
1505
bfd_byte *
1506
_bfd_write_unsigned_leb128 (bfd_byte *p, bfd_byte *end, bfd_vma val)
1507
0
{
1508
0
  bfd_byte c;
1509
0
  do
1510
0
    {
1511
0
      if (p > end)
1512
0
  return NULL;
1513
0
      c = val & 0x7f;
1514
0
      val >>= 7;
1515
0
      if (val)
1516
0
  c |= 0x80;
1517
0
      *(p++) = c;
1518
0
    }
1519
0
  while (val);
1520
0
  return p;
1521
0
}
1522
1523
bool
1524
_bfd_generic_init_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
1525
          asection *isec ATTRIBUTE_UNUSED,
1526
          bfd *obfd ATTRIBUTE_UNUSED,
1527
          asection *osec ATTRIBUTE_UNUSED,
1528
          struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
1529
0
{
1530
0
  return true;
1531
0
}
1532
1533
#ifdef HAVE_MMAP
1534
uintptr_t _bfd_pagesize;
1535
uintptr_t _bfd_pagesize_m1;
1536
uintptr_t _bfd_minimum_mmap_size;
1537
1538
__attribute__ ((unused, constructor))
1539
static void
1540
bfd_init_pagesize (void)
1541
52
{
1542
52
  _bfd_pagesize = getpagesize ();
1543
52
  if (_bfd_pagesize == 0)
1544
0
    abort ();
1545
52
  _bfd_pagesize_m1 = _bfd_pagesize - 1;
1546
  /* The minimum section size to use mmap.  */
1547
52
  _bfd_minimum_mmap_size = _bfd_pagesize * 4;
1548
52
}
1549
#endif