OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [bfd/] [libbfd.c] - Blame information for rev 14

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 14 khays
/* Assorted BFD support routines, only used internally.
2
   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3
   2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
4
   Free Software Foundation, Inc.
5
   Written by Cygnus Support.
6
 
7
   This file is part of BFD, the Binary File Descriptor library.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program; if not, write to the Free Software
21
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22
   MA 02110-1301, USA.  */
23
 
24
#include "sysdep.h"
25
#include "bfd.h"
26
#include "libbfd.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
/* A routine which is used in target vectors for unsupported
46
   operations.  */
47
 
48
bfd_boolean
49
bfd_false (bfd *ignore ATTRIBUTE_UNUSED)
50
{
51
  bfd_set_error (bfd_error_invalid_operation);
52
  return FALSE;
53
}
54
 
55
/* A routine which is used in target vectors for supported operations
56
   which do not actually do anything.  */
57
 
58
bfd_boolean
59
bfd_true (bfd *ignore ATTRIBUTE_UNUSED)
60
{
61
  return TRUE;
62
}
63
 
64
/* A routine which is used in target vectors for unsupported
65
   operations which return a pointer value.  */
66
 
67
void *
68
bfd_nullvoidptr (bfd *ignore ATTRIBUTE_UNUSED)
69
{
70
  bfd_set_error (bfd_error_invalid_operation);
71
  return NULL;
72
}
73
 
74
int
75
bfd_0 (bfd *ignore ATTRIBUTE_UNUSED)
76
{
77
  return 0;
78
}
79
 
80
unsigned int
81
bfd_0u (bfd *ignore ATTRIBUTE_UNUSED)
82
{
83
   return 0;
84
}
85
 
86
long
87
bfd_0l (bfd *ignore ATTRIBUTE_UNUSED)
88
{
89
  return 0;
90
}
91
 
92
/* A routine which is used in target vectors for unsupported
93
   operations which return -1 on error.  */
94
 
95
long
96
_bfd_n1 (bfd *ignore_abfd ATTRIBUTE_UNUSED)
97
{
98
  bfd_set_error (bfd_error_invalid_operation);
99
  return -1;
100
}
101
 
102
void
103
bfd_void (bfd *ignore ATTRIBUTE_UNUSED)
104
{
105
}
106
 
107
long
108
_bfd_norelocs_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
109
                                     asection *sec ATTRIBUTE_UNUSED)
110
{
111
  return sizeof (arelent *);
112
}
113
 
114
long
115
_bfd_norelocs_canonicalize_reloc (bfd *abfd ATTRIBUTE_UNUSED,
116
                                  asection *sec ATTRIBUTE_UNUSED,
117
                                  arelent **relptr,
118
                                  asymbol **symbols ATTRIBUTE_UNUSED)
119
{
120
  *relptr = NULL;
121
  return 0;
122
}
123
 
124
bfd_boolean
125
_bfd_nocore_core_file_matches_executable_p
126
  (bfd *ignore_core_bfd ATTRIBUTE_UNUSED,
127
   bfd *ignore_exec_bfd ATTRIBUTE_UNUSED)
128
{
129
  bfd_set_error (bfd_error_invalid_operation);
130
  return FALSE;
131
}
132
 
133
/* Routine to handle core_file_failing_command entry point for targets
134
   without core file support.  */
135
 
136
char *
137
_bfd_nocore_core_file_failing_command (bfd *ignore_abfd ATTRIBUTE_UNUSED)
138
{
139
  bfd_set_error (bfd_error_invalid_operation);
140
  return NULL;
141
}
142
 
143
/* Routine to handle core_file_failing_signal entry point for targets
144
   without core file support.  */
145
 
146
int
147
_bfd_nocore_core_file_failing_signal (bfd *ignore_abfd ATTRIBUTE_UNUSED)
148
{
149
  bfd_set_error (bfd_error_invalid_operation);
150
  return 0;
151
}
152
 
153
/* Routine to handle the core_file_pid entry point for targets without
154
   core file support.  */
155
 
156
int
157
_bfd_nocore_core_file_pid (bfd *ignore_abfd ATTRIBUTE_UNUSED)
158
{
159
  bfd_set_error (bfd_error_invalid_operation);
160
  return 0;
161
}
162
 
163
const bfd_target *
164
_bfd_dummy_target (bfd *ignore_abfd ATTRIBUTE_UNUSED)
165
{
166
  bfd_set_error (bfd_error_wrong_format);
167
  return 0;
168
}
169
 
170
/* Allocate memory using malloc.  */
171
 
172
void *
173
bfd_malloc (bfd_size_type size)
174
{
175
  void *ptr;
176
 
177
  if (size != (size_t) size)
178
    {
179
      bfd_set_error (bfd_error_no_memory);
180
      return NULL;
181
    }
182
 
183
  ptr = malloc ((size_t) size);
184
  if (ptr == NULL && (size_t) size != 0)
185
    bfd_set_error (bfd_error_no_memory);
186
 
187
  return ptr;
188
}
189
 
190
/* Allocate memory using malloc, nmemb * size with overflow checking.  */
191
 
192
void *
193
bfd_malloc2 (bfd_size_type nmemb, bfd_size_type size)
194
{
195
  void *ptr;
196
 
197
  if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
198
      && size != 0
199
      && nmemb > ~(bfd_size_type) 0 / size)
200
    {
201
      bfd_set_error (bfd_error_no_memory);
202
      return NULL;
203
    }
204
 
205
  size *= nmemb;
206
 
207
  if (size != (size_t) size)
208
    {
209
      bfd_set_error (bfd_error_no_memory);
210
      return NULL;
211
    }
212
 
213
  ptr = malloc ((size_t) size);
214
  if (ptr == NULL && (size_t) size != 0)
215
    bfd_set_error (bfd_error_no_memory);
216
 
217
  return ptr;
218
}
219
 
220
/* Reallocate memory using realloc.  */
221
 
222
void *
223
bfd_realloc (void *ptr, bfd_size_type size)
224
{
225
  void *ret;
226
 
227
  if (size != (size_t) size)
228
    {
229
      bfd_set_error (bfd_error_no_memory);
230
      return NULL;
231
    }
232
 
233
  if (ptr == NULL)
234
    ret = malloc ((size_t) size);
235
  else
236
    ret = realloc (ptr, (size_t) size);
237
 
238
  if (ret == NULL && (size_t) size != 0)
239
    bfd_set_error (bfd_error_no_memory);
240
 
241
  return ret;
242
}
243
 
244
/* Reallocate memory using realloc, nmemb * size with overflow checking.  */
245
 
246
void *
247
bfd_realloc2 (void *ptr, bfd_size_type nmemb, bfd_size_type size)
248
{
249
  void *ret;
250
 
251
  if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
252
      && size != 0
253
      && nmemb > ~(bfd_size_type) 0 / size)
254
    {
255
      bfd_set_error (bfd_error_no_memory);
256
      return NULL;
257
    }
258
 
259
  size *= nmemb;
260
 
261
  if (size != (size_t) size)
262
    {
263
      bfd_set_error (bfd_error_no_memory);
264
      return NULL;
265
    }
266
 
267
  if (ptr == NULL)
268
    ret = malloc ((size_t) size);
269
  else
270
    ret = realloc (ptr, (size_t) size);
271
 
272
  if (ret == NULL && (size_t) size != 0)
273
    bfd_set_error (bfd_error_no_memory);
274
 
275
  return ret;
276
}
277
 
278
/* Reallocate memory using realloc.
279
   If this fails the pointer is freed before returning.  */
280
 
281
void *
282
bfd_realloc_or_free (void *ptr, bfd_size_type size)
283
{
284
  size_t amount = (size_t) size;
285
  void *ret;
286
 
287
  if (size != amount)
288
    ret = NULL;
289
  else if (ptr == NULL)
290
    ret = malloc (amount);
291
  else
292
    ret = realloc (ptr, amount);
293
 
294
  if (ret == NULL)
295
    {
296
      if (amount > 0)
297
        bfd_set_error (bfd_error_no_memory);
298
 
299
      if (ptr != NULL)
300
        free (ptr);
301
    }
302
 
303
  return ret;
304
}
305
 
306
/* Allocate memory using malloc and clear it.  */
307
 
308
void *
309
bfd_zmalloc (bfd_size_type size)
310
{
311
  void *ptr;
312
 
313
  if (size != (size_t) size)
314
    {
315
      bfd_set_error (bfd_error_no_memory);
316
      return NULL;
317
    }
318
 
319
  ptr = malloc ((size_t) size);
320
 
321
  if ((size_t) size != 0)
322
    {
323
      if (ptr == NULL)
324
        bfd_set_error (bfd_error_no_memory);
325
      else
326
        memset (ptr, 0, (size_t) size);
327
    }
328
 
329
  return ptr;
330
}
331
 
332
/* Allocate memory using malloc (nmemb * size) with overflow checking
333
   and clear it.  */
334
 
335
void *
336
bfd_zmalloc2 (bfd_size_type nmemb, bfd_size_type size)
337
{
338
  void *ptr;
339
 
340
  if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
341
      && size != 0
342
      && nmemb > ~(bfd_size_type) 0 / size)
343
    {
344
      bfd_set_error (bfd_error_no_memory);
345
      return NULL;
346
    }
347
 
348
  size *= nmemb;
349
 
350
  if (size != (size_t) size)
351
    {
352
      bfd_set_error (bfd_error_no_memory);
353
      return NULL;
354
    }
355
 
356
  ptr = malloc ((size_t) size);
357
 
358
  if ((size_t) size != 0)
359
    {
360
      if (ptr == NULL)
361
        bfd_set_error (bfd_error_no_memory);
362
      else
363
        memset (ptr, 0, (size_t) size);
364
    }
365
 
366
  return ptr;
367
}
368
 
369
/*
370
INTERNAL_FUNCTION
371
        bfd_write_bigendian_4byte_int
372
 
373
SYNOPSIS
374
        bfd_boolean bfd_write_bigendian_4byte_int (bfd *, unsigned int);
375
 
376
DESCRIPTION
377
        Write a 4 byte integer @var{i} to the output BFD @var{abfd}, in big
378
        endian order regardless of what else is going on.  This is useful in
379
        archives.
380
 
381
*/
382
bfd_boolean
383
bfd_write_bigendian_4byte_int (bfd *abfd, unsigned int i)
384
{
385
  bfd_byte buffer[4];
386
  bfd_putb32 ((bfd_vma) i, buffer);
387
  return bfd_bwrite (buffer, (bfd_size_type) 4, abfd) == 4;
388
}
389
 
390
 
391
/** The do-it-yourself (byte) sex-change kit */
392
 
393
/* The middle letter e.g. get<b>short indicates Big or Little endian
394
   target machine.  It doesn't matter what the byte order of the host
395
   machine is; these routines work for either.  */
396
 
397
/* FIXME: Should these take a count argument?
398
   Answer (gnu@cygnus.com):  No, but perhaps they should be inline
399
                             functions in swap.h #ifdef __GNUC__.
400
                             Gprof them later and find out.  */
401
 
402
/*
403
FUNCTION
404
        bfd_put_size
405
FUNCTION
406
        bfd_get_size
407
 
408
DESCRIPTION
409
        These macros as used for reading and writing raw data in
410
        sections; each access (except for bytes) is vectored through
411
        the target format of the BFD and mangled accordingly. The
412
        mangling performs any necessary endian translations and
413
        removes alignment restrictions.  Note that types accepted and
414
        returned by these macros are identical so they can be swapped
415
        around in macros---for example, @file{libaout.h} defines <<GET_WORD>>
416
        to either <<bfd_get_32>> or <<bfd_get_64>>.
417
 
418
        In the put routines, @var{val} must be a <<bfd_vma>>.  If we are on a
419
        system without prototypes, the caller is responsible for making
420
        sure that is true, with a cast if necessary.  We don't cast
421
        them in the macro definitions because that would prevent <<lint>>
422
        or <<gcc -Wall>> from detecting sins such as passing a pointer.
423
        To detect calling these with less than a <<bfd_vma>>, use
424
        <<gcc -Wconversion>> on a host with 64 bit <<bfd_vma>>'s.
425
 
426
.
427
.{* Byte swapping macros for user section data.  *}
428
.
429
.#define bfd_put_8(abfd, val, ptr) \
430
.  ((void) (*((unsigned char *) (ptr)) = (val) & 0xff))
431
.#define bfd_put_signed_8 \
432
.  bfd_put_8
433
.#define bfd_get_8(abfd, ptr) \
434
.  (*(const unsigned char *) (ptr) & 0xff)
435
.#define bfd_get_signed_8(abfd, ptr) \
436
.  (((*(const unsigned char *) (ptr) & 0xff) ^ 0x80) - 0x80)
437
.
438
.#define bfd_put_16(abfd, val, ptr) \
439
.  BFD_SEND (abfd, bfd_putx16, ((val),(ptr)))
440
.#define bfd_put_signed_16 \
441
.  bfd_put_16
442
.#define bfd_get_16(abfd, ptr) \
443
.  BFD_SEND (abfd, bfd_getx16, (ptr))
444
.#define bfd_get_signed_16(abfd, ptr) \
445
.  BFD_SEND (abfd, bfd_getx_signed_16, (ptr))
446
.
447
.#define bfd_put_32(abfd, val, ptr) \
448
.  BFD_SEND (abfd, bfd_putx32, ((val),(ptr)))
449
.#define bfd_put_signed_32 \
450
.  bfd_put_32
451
.#define bfd_get_32(abfd, ptr) \
452
.  BFD_SEND (abfd, bfd_getx32, (ptr))
453
.#define bfd_get_signed_32(abfd, ptr) \
454
.  BFD_SEND (abfd, bfd_getx_signed_32, (ptr))
455
.
456
.#define bfd_put_64(abfd, val, ptr) \
457
.  BFD_SEND (abfd, bfd_putx64, ((val), (ptr)))
458
.#define bfd_put_signed_64 \
459
.  bfd_put_64
460
.#define bfd_get_64(abfd, ptr) \
461
.  BFD_SEND (abfd, bfd_getx64, (ptr))
462
.#define bfd_get_signed_64(abfd, ptr) \
463
.  BFD_SEND (abfd, bfd_getx_signed_64, (ptr))
464
.
465
.#define bfd_get(bits, abfd, ptr)                       \
466
.  ((bits) == 8 ? (bfd_vma) bfd_get_8 (abfd, ptr)       \
467
.   : (bits) == 16 ? bfd_get_16 (abfd, ptr)             \
468
.   : (bits) == 32 ? bfd_get_32 (abfd, ptr)             \
469
.   : (bits) == 64 ? bfd_get_64 (abfd, ptr)             \
470
.   : (abort (), (bfd_vma) - 1))
471
.
472
.#define bfd_put(bits, abfd, val, ptr)                  \
473
.  ((bits) == 8 ? bfd_put_8  (abfd, val, ptr)           \
474
.   : (bits) == 16 ? bfd_put_16 (abfd, val, ptr)                \
475
.   : (bits) == 32 ? bfd_put_32 (abfd, val, ptr)                \
476
.   : (bits) == 64 ? bfd_put_64 (abfd, val, ptr)                \
477
.   : (abort (), (void) 0))
478
.
479
*/
480
 
481
/*
482
FUNCTION
483
        bfd_h_put_size
484
        bfd_h_get_size
485
 
486
DESCRIPTION
487
        These macros have the same function as their <<bfd_get_x>>
488
        brethren, except that they are used for removing information
489
        for the header records of object files. Believe it or not,
490
        some object files keep their header records in big endian
491
        order and their data in little endian order.
492
.
493
.{* Byte swapping macros for file header data.  *}
494
.
495
.#define bfd_h_put_8(abfd, val, ptr) \
496
.  bfd_put_8 (abfd, val, ptr)
497
.#define bfd_h_put_signed_8(abfd, val, ptr) \
498
.  bfd_put_8 (abfd, val, ptr)
499
.#define bfd_h_get_8(abfd, ptr) \
500
.  bfd_get_8 (abfd, ptr)
501
.#define bfd_h_get_signed_8(abfd, ptr) \
502
.  bfd_get_signed_8 (abfd, ptr)
503
.
504
.#define bfd_h_put_16(abfd, val, ptr) \
505
.  BFD_SEND (abfd, bfd_h_putx16, (val, ptr))
506
.#define bfd_h_put_signed_16 \
507
.  bfd_h_put_16
508
.#define bfd_h_get_16(abfd, ptr) \
509
.  BFD_SEND (abfd, bfd_h_getx16, (ptr))
510
.#define bfd_h_get_signed_16(abfd, ptr) \
511
.  BFD_SEND (abfd, bfd_h_getx_signed_16, (ptr))
512
.
513
.#define bfd_h_put_32(abfd, val, ptr) \
514
.  BFD_SEND (abfd, bfd_h_putx32, (val, ptr))
515
.#define bfd_h_put_signed_32 \
516
.  bfd_h_put_32
517
.#define bfd_h_get_32(abfd, ptr) \
518
.  BFD_SEND (abfd, bfd_h_getx32, (ptr))
519
.#define bfd_h_get_signed_32(abfd, ptr) \
520
.  BFD_SEND (abfd, bfd_h_getx_signed_32, (ptr))
521
.
522
.#define bfd_h_put_64(abfd, val, ptr) \
523
.  BFD_SEND (abfd, bfd_h_putx64, (val, ptr))
524
.#define bfd_h_put_signed_64 \
525
.  bfd_h_put_64
526
.#define bfd_h_get_64(abfd, ptr) \
527
.  BFD_SEND (abfd, bfd_h_getx64, (ptr))
528
.#define bfd_h_get_signed_64(abfd, ptr) \
529
.  BFD_SEND (abfd, bfd_h_getx_signed_64, (ptr))
530
.
531
.{* Aliases for the above, which should eventually go away.  *}
532
.
533
.#define H_PUT_64  bfd_h_put_64
534
.#define H_PUT_32  bfd_h_put_32
535
.#define H_PUT_16  bfd_h_put_16
536
.#define H_PUT_8   bfd_h_put_8
537
.#define H_PUT_S64 bfd_h_put_signed_64
538
.#define H_PUT_S32 bfd_h_put_signed_32
539
.#define H_PUT_S16 bfd_h_put_signed_16
540
.#define H_PUT_S8  bfd_h_put_signed_8
541
.#define H_GET_64  bfd_h_get_64
542
.#define H_GET_32  bfd_h_get_32
543
.#define H_GET_16  bfd_h_get_16
544
.#define H_GET_8   bfd_h_get_8
545
.#define H_GET_S64 bfd_h_get_signed_64
546
.#define H_GET_S32 bfd_h_get_signed_32
547
.#define H_GET_S16 bfd_h_get_signed_16
548
.#define H_GET_S8  bfd_h_get_signed_8
549
.
550
.*/
551
 
552
/* Sign extension to bfd_signed_vma.  */
553
#define COERCE16(x) (((bfd_signed_vma) (x) ^ 0x8000) - 0x8000)
554
#define COERCE32(x) (((bfd_signed_vma) (x) ^ 0x80000000) - 0x80000000)
555
#define EIGHT_GAZILLION ((bfd_int64_t) 1 << 63)
556
#define COERCE64(x) \
557
  (((bfd_int64_t) (x) ^ EIGHT_GAZILLION) - EIGHT_GAZILLION)
558
 
559
bfd_vma
560
bfd_getb16 (const void *p)
561
{
562
  const bfd_byte *addr = (const bfd_byte *) p;
563
  return (addr[0] << 8) | addr[1];
564
}
565
 
566
bfd_vma
567
bfd_getl16 (const void *p)
568
{
569
  const bfd_byte *addr = (const bfd_byte *) p;
570
  return (addr[1] << 8) | addr[0];
571
}
572
 
573
bfd_signed_vma
574
bfd_getb_signed_16 (const void *p)
575
{
576
  const bfd_byte *addr = (const bfd_byte *) p;
577
  return COERCE16 ((addr[0] << 8) | addr[1]);
578
}
579
 
580
bfd_signed_vma
581
bfd_getl_signed_16 (const void *p)
582
{
583
  const bfd_byte *addr = (const bfd_byte *) p;
584
  return COERCE16 ((addr[1] << 8) | addr[0]);
585
}
586
 
587
void
588
bfd_putb16 (bfd_vma data, void *p)
589
{
590
  bfd_byte *addr = (bfd_byte *) p;
591
  addr[0] = (data >> 8) & 0xff;
592
  addr[1] = data & 0xff;
593
}
594
 
595
void
596
bfd_putl16 (bfd_vma data, void *p)
597
{
598
  bfd_byte *addr = (bfd_byte *) p;
599
  addr[0] = data & 0xff;
600
  addr[1] = (data >> 8) & 0xff;
601
}
602
 
603
bfd_vma
604
bfd_getb32 (const void *p)
605
{
606
  const bfd_byte *addr = (const bfd_byte *) p;
607
  unsigned long v;
608
 
609
  v = (unsigned long) addr[0] << 24;
610
  v |= (unsigned long) addr[1] << 16;
611
  v |= (unsigned long) addr[2] << 8;
612
  v |= (unsigned long) addr[3];
613
  return v;
614
}
615
 
616
bfd_vma
617
bfd_getl32 (const void *p)
618
{
619
  const bfd_byte *addr = (const bfd_byte *) p;
620
  unsigned long v;
621
 
622
  v = (unsigned long) addr[0];
623
  v |= (unsigned long) addr[1] << 8;
624
  v |= (unsigned long) addr[2] << 16;
625
  v |= (unsigned long) addr[3] << 24;
626
  return v;
627
}
628
 
629
bfd_signed_vma
630
bfd_getb_signed_32 (const void *p)
631
{
632
  const bfd_byte *addr = (const bfd_byte *) p;
633
  unsigned long v;
634
 
635
  v = (unsigned long) addr[0] << 24;
636
  v |= (unsigned long) addr[1] << 16;
637
  v |= (unsigned long) addr[2] << 8;
638
  v |= (unsigned long) addr[3];
639
  return COERCE32 (v);
640
}
641
 
642
bfd_signed_vma
643
bfd_getl_signed_32 (const void *p)
644
{
645
  const bfd_byte *addr = (const bfd_byte *) p;
646
  unsigned long v;
647
 
648
  v = (unsigned long) addr[0];
649
  v |= (unsigned long) addr[1] << 8;
650
  v |= (unsigned long) addr[2] << 16;
651
  v |= (unsigned long) addr[3] << 24;
652
  return COERCE32 (v);
653
}
654
 
655
bfd_uint64_t
656
bfd_getb64 (const void *p ATTRIBUTE_UNUSED)
657
{
658
#ifdef BFD_HOST_64_BIT
659
  const bfd_byte *addr = (const bfd_byte *) p;
660
  bfd_uint64_t v;
661
 
662
  v  = addr[0]; v <<= 8;
663
  v |= addr[1]; v <<= 8;
664
  v |= addr[2]; v <<= 8;
665
  v |= addr[3]; v <<= 8;
666
  v |= addr[4]; v <<= 8;
667
  v |= addr[5]; v <<= 8;
668
  v |= addr[6]; v <<= 8;
669
  v |= addr[7];
670
 
671
  return v;
672
#else
673
  BFD_FAIL();
674
  return 0;
675
#endif
676
}
677
 
678
bfd_uint64_t
679
bfd_getl64 (const void *p ATTRIBUTE_UNUSED)
680
{
681
#ifdef BFD_HOST_64_BIT
682
  const bfd_byte *addr = (const bfd_byte *) p;
683
  bfd_uint64_t v;
684
 
685
  v  = addr[7]; v <<= 8;
686
  v |= addr[6]; v <<= 8;
687
  v |= addr[5]; v <<= 8;
688
  v |= addr[4]; v <<= 8;
689
  v |= addr[3]; v <<= 8;
690
  v |= addr[2]; v <<= 8;
691
  v |= addr[1]; v <<= 8;
692
  v |= addr[0];
693
 
694
  return v;
695
#else
696
  BFD_FAIL();
697
  return 0;
698
#endif
699
 
700
}
701
 
702
bfd_int64_t
703
bfd_getb_signed_64 (const void *p ATTRIBUTE_UNUSED)
704
{
705
#ifdef BFD_HOST_64_BIT
706
  const bfd_byte *addr = (const bfd_byte *) p;
707
  bfd_uint64_t v;
708
 
709
  v  = addr[0]; v <<= 8;
710
  v |= addr[1]; v <<= 8;
711
  v |= addr[2]; v <<= 8;
712
  v |= addr[3]; v <<= 8;
713
  v |= addr[4]; v <<= 8;
714
  v |= addr[5]; v <<= 8;
715
  v |= addr[6]; v <<= 8;
716
  v |= addr[7];
717
 
718
  return COERCE64 (v);
719
#else
720
  BFD_FAIL();
721
  return 0;
722
#endif
723
}
724
 
725
bfd_int64_t
726
bfd_getl_signed_64 (const void *p ATTRIBUTE_UNUSED)
727
{
728
#ifdef BFD_HOST_64_BIT
729
  const bfd_byte *addr = (const bfd_byte *) p;
730
  bfd_uint64_t v;
731
 
732
  v  = addr[7]; v <<= 8;
733
  v |= addr[6]; v <<= 8;
734
  v |= addr[5]; v <<= 8;
735
  v |= addr[4]; v <<= 8;
736
  v |= addr[3]; v <<= 8;
737
  v |= addr[2]; v <<= 8;
738
  v |= addr[1]; v <<= 8;
739
  v |= addr[0];
740
 
741
  return COERCE64 (v);
742
#else
743
  BFD_FAIL();
744
  return 0;
745
#endif
746
}
747
 
748
void
749
bfd_putb32 (bfd_vma data, void *p)
750
{
751
  bfd_byte *addr = (bfd_byte *) p;
752
  addr[0] = (data >> 24) & 0xff;
753
  addr[1] = (data >> 16) & 0xff;
754
  addr[2] = (data >>  8) & 0xff;
755
  addr[3] = data & 0xff;
756
}
757
 
758
void
759
bfd_putl32 (bfd_vma data, void *p)
760
{
761
  bfd_byte *addr = (bfd_byte *) p;
762
  addr[0] = data & 0xff;
763
  addr[1] = (data >>  8) & 0xff;
764
  addr[2] = (data >> 16) & 0xff;
765
  addr[3] = (data >> 24) & 0xff;
766
}
767
 
768
void
769
bfd_putb64 (bfd_uint64_t data ATTRIBUTE_UNUSED, void *p ATTRIBUTE_UNUSED)
770
{
771
#ifdef BFD_HOST_64_BIT
772
  bfd_byte *addr = (bfd_byte *) p;
773
  addr[0] = (data >> (7*8)) & 0xff;
774
  addr[1] = (data >> (6*8)) & 0xff;
775
  addr[2] = (data >> (5*8)) & 0xff;
776
  addr[3] = (data >> (4*8)) & 0xff;
777
  addr[4] = (data >> (3*8)) & 0xff;
778
  addr[5] = (data >> (2*8)) & 0xff;
779
  addr[6] = (data >> (1*8)) & 0xff;
780
  addr[7] = (data >> (0*8)) & 0xff;
781
#else
782
  BFD_FAIL();
783
#endif
784
}
785
 
786
void
787
bfd_putl64 (bfd_uint64_t data ATTRIBUTE_UNUSED, void *p ATTRIBUTE_UNUSED)
788
{
789
#ifdef BFD_HOST_64_BIT
790
  bfd_byte *addr = (bfd_byte *) p;
791
  addr[7] = (data >> (7*8)) & 0xff;
792
  addr[6] = (data >> (6*8)) & 0xff;
793
  addr[5] = (data >> (5*8)) & 0xff;
794
  addr[4] = (data >> (4*8)) & 0xff;
795
  addr[3] = (data >> (3*8)) & 0xff;
796
  addr[2] = (data >> (2*8)) & 0xff;
797
  addr[1] = (data >> (1*8)) & 0xff;
798
  addr[0] = (data >> (0*8)) & 0xff;
799
#else
800
  BFD_FAIL();
801
#endif
802
}
803
 
804
void
805
bfd_put_bits (bfd_uint64_t data, void *p, int bits, bfd_boolean big_p)
806
{
807
  bfd_byte *addr = (bfd_byte *) p;
808
  int i;
809
  int bytes;
810
 
811
  if (bits % 8 != 0)
812
    abort ();
813
 
814
  bytes = bits / 8;
815
  for (i = 0; i < bytes; i++)
816
    {
817
      int addr_index = big_p ? bytes - i - 1 : i;
818
 
819
      addr[addr_index] = data & 0xff;
820
      data >>= 8;
821
    }
822
}
823
 
824
bfd_uint64_t
825
bfd_get_bits (const void *p, int bits, bfd_boolean big_p)
826
{
827
  const bfd_byte *addr = (const bfd_byte *) p;
828
  bfd_uint64_t data;
829
  int i;
830
  int bytes;
831
 
832
  if (bits % 8 != 0)
833
    abort ();
834
 
835
  data = 0;
836
  bytes = bits / 8;
837
  for (i = 0; i < bytes; i++)
838
    {
839
      int addr_index = big_p ? i : bytes - i - 1;
840
 
841
      data = (data << 8) | addr[addr_index];
842
    }
843
 
844
  return data;
845
}
846
 
847
/* Default implementation */
848
 
849
bfd_boolean
850
_bfd_generic_get_section_contents (bfd *abfd,
851
                                   sec_ptr section,
852
                                   void *location,
853
                                   file_ptr offset,
854
                                   bfd_size_type count)
855
{
856
  bfd_size_type sz;
857
  if (count == 0)
858
    return TRUE;
859
 
860
  if (section->compress_status != COMPRESS_SECTION_NONE)
861
    {
862
      (*_bfd_error_handler)
863
        (_("%B: unable to get decompressed section %A"),
864
         abfd, section);
865
      bfd_set_error (bfd_error_invalid_operation);
866
      return FALSE;
867
    }
868
 
869
  /* We do allow reading of a section after bfd_final_link has
870
     written the contents out to disk.  In that situation, rawsize is
871
     just a stale version of size, so ignore it.  Otherwise we must be
872
     reading an input section, where rawsize, if different to size,
873
     is the on-disk size.  */
874
  if (abfd->direction != write_direction && section->rawsize != 0)
875
    sz = section->rawsize;
876
  else
877
    sz = section->size;
878
  if (offset + count < count
879
      || offset + count > sz)
880
    {
881
      bfd_set_error (bfd_error_invalid_operation);
882
      return FALSE;
883
    }
884
 
885
  if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
886
      || bfd_bread (location, count, abfd) != count)
887
    return FALSE;
888
 
889
  return TRUE;
890
}
891
 
892
bfd_boolean
893
_bfd_generic_get_section_contents_in_window
894
  (bfd *abfd ATTRIBUTE_UNUSED,
895
   sec_ptr section ATTRIBUTE_UNUSED,
896
   bfd_window *w ATTRIBUTE_UNUSED,
897
   file_ptr offset ATTRIBUTE_UNUSED,
898
   bfd_size_type count ATTRIBUTE_UNUSED)
899
{
900
#ifdef USE_MMAP
901
  bfd_size_type sz;
902
 
903
  if (count == 0)
904
    return TRUE;
905
  if (abfd->xvec->_bfd_get_section_contents
906
      != _bfd_generic_get_section_contents)
907
    {
908
      /* We don't know what changes the bfd's get_section_contents
909
         method may have to make.  So punt trying to map the file
910
         window, and let get_section_contents do its thing.  */
911
      /* @@ FIXME : If the internal window has a refcount of 1 and was
912
         allocated with malloc instead of mmap, just reuse it.  */
913
      bfd_free_window (w);
914
      w->i = bfd_zmalloc (sizeof (bfd_window_internal));
915
      if (w->i == NULL)
916
        return FALSE;
917
      w->i->data = bfd_malloc (count);
918
      if (w->i->data == NULL)
919
        {
920
          free (w->i);
921
          w->i = NULL;
922
          return FALSE;
923
        }
924
      w->i->mapped = 0;
925
      w->i->refcount = 1;
926
      w->size = w->i->size = count;
927
      w->data = w->i->data;
928
      return bfd_get_section_contents (abfd, section, w->data, offset, count);
929
    }
930
  if (abfd->direction != write_direction && section->rawsize != 0)
931
    sz = section->rawsize;
932
  else
933
    sz = section->size;
934
  if (offset + count > sz
935
      || ! bfd_get_file_window (abfd, section->filepos + offset, count, w,
936
                                TRUE))
937
    return FALSE;
938
  return TRUE;
939
#else
940
  abort ();
941
#endif
942
}
943
 
944
/* This generic function can only be used in implementations where creating
945
   NEW sections is disallowed.  It is useful in patching existing sections
946
   in read-write files, though.  See other set_section_contents functions
947
   to see why it doesn't work for new sections.  */
948
bfd_boolean
949
_bfd_generic_set_section_contents (bfd *abfd,
950
                                   sec_ptr section,
951
                                   const void *location,
952
                                   file_ptr offset,
953
                                   bfd_size_type count)
954
{
955
  if (count == 0)
956
    return TRUE;
957
 
958
  if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
959
      || bfd_bwrite (location, count, abfd) != count)
960
    return FALSE;
961
 
962
  return TRUE;
963
}
964
 
965
/*
966
INTERNAL_FUNCTION
967
        bfd_log2
968
 
969
SYNOPSIS
970
        unsigned int bfd_log2 (bfd_vma x);
971
 
972
DESCRIPTION
973
        Return the log base 2 of the value supplied, rounded up.  E.g., an
974
        @var{x} of 1025 returns 11.  A @var{x} of 0 returns 0.
975
*/
976
 
977
unsigned int
978
bfd_log2 (bfd_vma x)
979
{
980
  unsigned int result = 0;
981
 
982
  if (x <= 1)
983
    return result;
984
  --x;
985
  do
986
    ++result;
987
  while ((x >>= 1) != 0);
988
  return result;
989
}
990
 
991
bfd_boolean
992
bfd_generic_is_local_label_name (bfd *abfd, const char *name)
993
{
994
  char locals_prefix = (bfd_get_symbol_leading_char (abfd) == '_') ? 'L' : '.';
995
 
996
  return name[0] == locals_prefix;
997
}
998
 
999
/*  Can be used from / for bfd_merge_private_bfd_data to check that
1000
    endianness matches between input and output file.  Returns
1001
    TRUE for a match, otherwise returns FALSE and emits an error.  */
1002
bfd_boolean
1003
_bfd_generic_verify_endian_match (bfd *ibfd, bfd *obfd)
1004
{
1005
  if (ibfd->xvec->byteorder != obfd->xvec->byteorder
1006
      && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
1007
      && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
1008
    {
1009
      const char *msg;
1010
 
1011
      if (bfd_big_endian (ibfd))
1012
        msg = _("%B: compiled for a big endian system and target is little endian");
1013
      else
1014
        msg = _("%B: compiled for a little endian system and target is big endian");
1015
 
1016
      (*_bfd_error_handler) (msg, ibfd);
1017
 
1018
      bfd_set_error (bfd_error_wrong_format);
1019
      return FALSE;
1020
    }
1021
 
1022
  return TRUE;
1023
}
1024
 
1025
/* Give a warning at runtime if someone compiles code which calls
1026
   old routines.  */
1027
 
1028
void
1029
warn_deprecated (const char *what,
1030
                 const char *file,
1031
                 int line,
1032
                 const char *func)
1033
{
1034
  /* Poor man's tracking of functions we've already warned about.  */
1035
  static size_t mask = 0;
1036
 
1037
  if (~(size_t) func & ~mask)
1038
    {
1039
      fflush (stdout);
1040
      /* Note: separate sentences in order to allow
1041
         for translation into other languages.  */
1042
      if (func)
1043
        fprintf (stderr, _("Deprecated %s called at %s line %d in %s\n"),
1044
                 what, file, line, func);
1045
      else
1046
        fprintf (stderr, _("Deprecated %s called\n"), what);
1047
      fflush (stderr);
1048
      mask |= ~(size_t) func;
1049
    }
1050
}
1051
 
1052
/* Helper function for reading uleb128 encoded data.  */
1053
 
1054
bfd_vma
1055
read_unsigned_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
1056
                      bfd_byte *buf,
1057
                      unsigned int *bytes_read_ptr)
1058
{
1059
  bfd_vma result;
1060
  unsigned int num_read;
1061
  unsigned int shift;
1062
  unsigned char byte;
1063
 
1064
  result = 0;
1065
  shift = 0;
1066
  num_read = 0;
1067
  do
1068
    {
1069
      byte = bfd_get_8 (abfd, buf);
1070
      buf++;
1071
      num_read++;
1072
      result |= (((bfd_vma) byte & 0x7f) << shift);
1073
      shift += 7;
1074
    }
1075
  while (byte & 0x80);
1076
  *bytes_read_ptr = num_read;
1077
  return result;
1078
}
1079
 
1080
/* Helper function for reading sleb128 encoded data.  */
1081
 
1082
bfd_signed_vma
1083
read_signed_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
1084
                    bfd_byte *buf,
1085
                    unsigned int *bytes_read_ptr)
1086
{
1087
  bfd_vma result;
1088
  unsigned int shift;
1089
  unsigned int num_read;
1090
  unsigned char byte;
1091
 
1092
  result = 0;
1093
  shift = 0;
1094
  num_read = 0;
1095
  do
1096
    {
1097
      byte = bfd_get_8 (abfd, buf);
1098
      buf ++;
1099
      num_read ++;
1100
      result |= (((bfd_vma) byte & 0x7f) << shift);
1101
      shift += 7;
1102
    }
1103
  while (byte & 0x80);
1104
  if (shift < 8 * sizeof (result) && (byte & 0x40))
1105
    result |= (((bfd_vma) -1) << shift);
1106
  *bytes_read_ptr = num_read;
1107
  return result;
1108
}
1109
 
1110
bfd_boolean
1111
_bfd_generic_find_line (bfd *abfd ATTRIBUTE_UNUSED,
1112
                       asymbol **symbols ATTRIBUTE_UNUSED,
1113
                       asymbol *symbol ATTRIBUTE_UNUSED,
1114
                       const char **filename_ptr ATTRIBUTE_UNUSED,
1115
                       unsigned int *linenumber_ptr ATTRIBUTE_UNUSED)
1116
{
1117
  return FALSE;
1118
}
1119
 
1120
bfd_boolean
1121
_bfd_generic_init_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
1122
                                        asection *isec ATTRIBUTE_UNUSED,
1123
                                        bfd *obfd ATTRIBUTE_UNUSED,
1124
                                        asection *osec ATTRIBUTE_UNUSED,
1125
                                        struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
1126
{
1127
  return TRUE;
1128
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.