/* Assorted BFD support routines, only used internally.
- Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- 2000, 2001, 2002, 2003
- Free Software Foundation, Inc.
+ Copyright (C) 1990-2016 Free Software Foundation, Inc.
Written by Cygnus Support.
This file is part of BFD, the Binary File Descriptor library.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+ Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+ MA 02110-1301, USA. */
-#include "bfd.h"
#include "sysdep.h"
+#include "bfd.h"
#include "libbfd.h"
#ifndef HAVE_GETPAGESIZE
/*
SECTION
+ Implementation details
+
+SUBSECTION
Internal functions
DESCRIPTION
{
}
+long
+_bfd_norelocs_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
+ asection *sec ATTRIBUTE_UNUSED)
+{
+ return sizeof (arelent *);
+}
+
+long
+_bfd_norelocs_canonicalize_reloc (bfd *abfd ATTRIBUTE_UNUSED,
+ asection *sec ATTRIBUTE_UNUSED,
+ arelent **relptr,
+ asymbol **symbols ATTRIBUTE_UNUSED)
+{
+ *relptr = NULL;
+ return 0;
+}
+
bfd_boolean
_bfd_nocore_core_file_matches_executable_p
(bfd *ignore_core_bfd ATTRIBUTE_UNUSED,
return 0;
}
+/* Routine to handle the core_file_pid entry point for targets without
+ core file support. */
+
+int
+_bfd_nocore_core_file_pid (bfd *ignore_abfd ATTRIBUTE_UNUSED)
+{
+ bfd_set_error (bfd_error_invalid_operation);
+ return 0;
+}
+
const bfd_target *
_bfd_dummy_target (bfd *ignore_abfd ATTRIBUTE_UNUSED)
{
bfd_malloc (bfd_size_type size)
{
void *ptr;
+ size_t sz = (size_t) size;
- if (size != (size_t) size)
+ if (size != sz
+ /* This is to pacify memory checkers like valgrind. */
+ || ((signed long) sz) < 0)
{
bfd_set_error (bfd_error_no_memory);
return NULL;
}
- ptr = malloc ((size_t) size);
- if (ptr == NULL && (size_t) size != 0)
+ ptr = malloc (sz);
+ if (ptr == NULL && sz != 0)
bfd_set_error (bfd_error_no_memory);
return ptr;
}
+/* Allocate memory using malloc, nmemb * size with overflow checking. */
+
+void *
+bfd_malloc2 (bfd_size_type nmemb, bfd_size_type size)
+{
+ if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
+ && size != 0
+ && nmemb > ~(bfd_size_type) 0 / size)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ return NULL;
+ }
+
+ return bfd_malloc (size * nmemb);
+}
+
/* Reallocate memory using realloc. */
void *
bfd_realloc (void *ptr, bfd_size_type size)
{
void *ret;
+ size_t sz = (size_t) size;
+
+ if (ptr == NULL)
+ return bfd_malloc (size);
- if (size != (size_t) size)
+ if (size != sz
+ /* This is to pacify memory checkers like valgrind. */
+ || ((signed long) sz) < 0)
{
bfd_set_error (bfd_error_no_memory);
return NULL;
}
- if (ptr == NULL)
- ret = malloc ((size_t) size);
- else
- ret = realloc (ptr, (size_t) size);
+ ret = realloc (ptr, sz);
- if (ret == NULL && (size_t) size != 0)
+ if (ret == NULL && sz != 0)
bfd_set_error (bfd_error_no_memory);
return ret;
}
-/* Allocate memory using malloc and clear it. */
+/* Reallocate memory using realloc, nmemb * size with overflow checking. */
void *
-bfd_zmalloc (bfd_size_type size)
+bfd_realloc2 (void *ptr, bfd_size_type nmemb, bfd_size_type size)
{
- void *ptr;
-
- if (size != (size_t) size)
+ if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
+ && size != 0
+ && nmemb > ~(bfd_size_type) 0 / size)
{
bfd_set_error (bfd_error_no_memory);
return NULL;
}
- ptr = malloc ((size_t) size);
+ return bfd_realloc (ptr, size * nmemb);
+}
+
+/* Reallocate memory using realloc.
+ If this fails the pointer is freed before returning. */
+
+void *
+bfd_realloc_or_free (void *ptr, bfd_size_type size)
+{
+ void *ret = bfd_realloc (ptr, size);
+
+ if (ret == NULL && ptr != NULL)
+ free (ptr);
+
+ return ret;
+}
+
+/* Allocate memory using malloc and clear it. */
+
+void *
+bfd_zmalloc (bfd_size_type size)
+{
+ void *ptr = bfd_malloc (size);
+
+ if (ptr != NULL && size > 0)
+ memset (ptr, 0, (size_t) size);
+
+ return ptr;
+}
+
+/* Allocate memory using malloc (nmemb * size) with overflow checking
+ and clear it. */
+
+void *
+bfd_zmalloc2 (bfd_size_type nmemb, bfd_size_type size)
+{
+ void *ptr = bfd_malloc2 (nmemb, size);
- if ((size_t) size != 0)
+ if (ptr != NULL)
{
- if (ptr == NULL)
- bfd_set_error (bfd_error_no_memory);
- else
- memset (ptr, 0, (size_t) size);
+ size_t sz = nmemb * size;
+
+ if (sz > 0)
+ memset (ptr, 0, sz);
}
return ptr;
}
+
/*
INTERNAL_FUNCTION
bfd_write_bigendian_4byte_int
.{* Byte swapping macros for user section data. *}
.
.#define bfd_put_8(abfd, val, ptr) \
-. ((void) (*((unsigned char *) (ptr)) = (unsigned char) (val)))
+. ((void) (*((unsigned char *) (ptr)) = (val) & 0xff))
.#define bfd_put_signed_8 \
. bfd_put_8
.#define bfd_get_8(abfd, ptr) \
-. (*(unsigned char *) (ptr) & 0xff)
+. (*(const unsigned char *) (ptr) & 0xff)
.#define bfd_get_signed_8(abfd, ptr) \
-. (((*(unsigned char *) (ptr) & 0xff) ^ 0x80) - 0x80)
+. (((*(const unsigned char *) (ptr) & 0xff) ^ 0x80) - 0x80)
.
.#define bfd_put_16(abfd, val, ptr) \
. BFD_SEND (abfd, bfd_putx16, ((val),(ptr)))
.#define bfd_h_get_signed_64(abfd, ptr) \
. BFD_SEND (abfd, bfd_h_getx_signed_64, (ptr))
.
-.{* Refinements on the above, which should eventually go away. Save
-. cluttering the source with (bfd_vma) and (bfd_byte *) casts. *}
-.
-.#define H_PUT_64(abfd, val, where) \
-. bfd_h_put_64 ((abfd), (bfd_vma) (val), (bfd_byte *) (where))
+.{* Aliases for the above, which should eventually go away. *}
.
-.#define H_PUT_32(abfd, val, where) \
-. bfd_h_put_32 ((abfd), (bfd_vma) (val), (bfd_byte *) (where))
-.
-.#define H_PUT_16(abfd, val, where) \
-. bfd_h_put_16 ((abfd), (bfd_vma) (val), (bfd_byte *) (where))
-.
-.#define H_PUT_8 bfd_h_put_8
-.
-.#define H_PUT_S64(abfd, val, where) \
-. bfd_h_put_signed_64 ((abfd), (bfd_vma) (val), (bfd_byte *) (where))
-.
-.#define H_PUT_S32(abfd, val, where) \
-. bfd_h_put_signed_32 ((abfd), (bfd_vma) (val), (bfd_byte *) (where))
-.
-.#define H_PUT_S16(abfd, val, where) \
-. bfd_h_put_signed_16 ((abfd), (bfd_vma) (val), (bfd_byte *) (where))
-.
-.#define H_PUT_S8 bfd_h_put_signed_8
-.
-.#define H_GET_64(abfd, where) \
-. bfd_h_get_64 ((abfd), (bfd_byte *) (where))
-.
-.#define H_GET_32(abfd, where) \
-. bfd_h_get_32 ((abfd), (bfd_byte *) (where))
-.
-.#define H_GET_16(abfd, where) \
-. bfd_h_get_16 ((abfd), (bfd_byte *) (where))
-.
-.#define H_GET_8 bfd_h_get_8
-.
-.#define H_GET_S64(abfd, where) \
-. bfd_h_get_signed_64 ((abfd), (bfd_byte *) (where))
-.
-.#define H_GET_S32(abfd, where) \
-. bfd_h_get_signed_32 ((abfd), (bfd_byte *) (where))
-.
-.#define H_GET_S16(abfd, where) \
-. bfd_h_get_signed_16 ((abfd), (bfd_byte *) (where))
-.
-.#define H_GET_S8 bfd_h_get_signed_8
+.#define H_PUT_64 bfd_h_put_64
+.#define H_PUT_32 bfd_h_put_32
+.#define H_PUT_16 bfd_h_put_16
+.#define H_PUT_8 bfd_h_put_8
+.#define H_PUT_S64 bfd_h_put_signed_64
+.#define H_PUT_S32 bfd_h_put_signed_32
+.#define H_PUT_S16 bfd_h_put_signed_16
+.#define H_PUT_S8 bfd_h_put_signed_8
+.#define H_GET_64 bfd_h_get_64
+.#define H_GET_32 bfd_h_get_32
+.#define H_GET_16 bfd_h_get_16
+.#define H_GET_8 bfd_h_get_8
+.#define H_GET_S64 bfd_h_get_signed_64
+.#define H_GET_S32 bfd_h_get_signed_32
+.#define H_GET_S16 bfd_h_get_signed_16
+.#define H_GET_S8 bfd_h_get_signed_8
.
.*/
/* Sign extension to bfd_signed_vma. */
-#define COERCE16(x) (((bfd_signed_vma) (x) ^ 0x8000) - 0x8000)
-#define COERCE32(x) (((bfd_signed_vma) (x) ^ 0x80000000) - 0x80000000)
-#define EIGHT_GAZILLION ((BFD_HOST_64_BIT) 1 << 63)
+#define COERCE16(x) (((bfd_vma) (x) ^ 0x8000) - 0x8000)
+#define COERCE32(x) (((bfd_vma) (x) ^ 0x80000000) - 0x80000000)
#define COERCE64(x) \
- (((bfd_signed_vma) (x) ^ EIGHT_GAZILLION) - EIGHT_GAZILLION)
+ (((bfd_uint64_t) (x) ^ ((bfd_uint64_t) 1 << 63)) - ((bfd_uint64_t) 1 << 63))
bfd_vma
-bfd_getb16 (const bfd_byte *addr)
+bfd_getb16 (const void *p)
{
+ const bfd_byte *addr = (const bfd_byte *) p;
return (addr[0] << 8) | addr[1];
}
bfd_vma
-bfd_getl16 (const bfd_byte *addr)
+bfd_getl16 (const void *p)
{
+ const bfd_byte *addr = (const bfd_byte *) p;
return (addr[1] << 8) | addr[0];
}
bfd_signed_vma
-bfd_getb_signed_16 (const bfd_byte *addr)
+bfd_getb_signed_16 (const void *p)
{
+ const bfd_byte *addr = (const bfd_byte *) p;
return COERCE16 ((addr[0] << 8) | addr[1]);
}
bfd_signed_vma
-bfd_getl_signed_16 (const bfd_byte *addr)
+bfd_getl_signed_16 (const void *p)
{
+ const bfd_byte *addr = (const bfd_byte *) p;
return COERCE16 ((addr[1] << 8) | addr[0]);
}
void
-bfd_putb16 (bfd_vma data, bfd_byte *addr)
+bfd_putb16 (bfd_vma data, void *p)
{
- addr[0] = (bfd_byte) (data >> 8);
- addr[1] = (bfd_byte) data;
+ bfd_byte *addr = (bfd_byte *) p;
+ addr[0] = (data >> 8) & 0xff;
+ addr[1] = data & 0xff;
}
void
-bfd_putl16 (bfd_vma data, bfd_byte *addr)
+bfd_putl16 (bfd_vma data, void *p)
{
- addr[0] = (bfd_byte) data;
- addr[1] = (bfd_byte) (data >> 8);
+ bfd_byte *addr = (bfd_byte *) p;
+ addr[0] = data & 0xff;
+ addr[1] = (data >> 8) & 0xff;
}
bfd_vma
-bfd_getb32 (const bfd_byte *addr)
+bfd_getb32 (const void *p)
{
+ const bfd_byte *addr = (const bfd_byte *) p;
unsigned long v;
v = (unsigned long) addr[0] << 24;
}
bfd_vma
-bfd_getl32 (const bfd_byte *addr)
+bfd_getl32 (const void *p)
{
+ const bfd_byte *addr = (const bfd_byte *) p;
unsigned long v;
v = (unsigned long) addr[0];
}
bfd_signed_vma
-bfd_getb_signed_32 (const bfd_byte *addr)
+bfd_getb_signed_32 (const void *p)
{
+ const bfd_byte *addr = (const bfd_byte *) p;
unsigned long v;
v = (unsigned long) addr[0] << 24;
}
bfd_signed_vma
-bfd_getl_signed_32 (const bfd_byte *addr)
+bfd_getl_signed_32 (const void *p)
{
+ const bfd_byte *addr = (const bfd_byte *) p;
unsigned long v;
v = (unsigned long) addr[0];
return COERCE32 (v);
}
-bfd_vma
-bfd_getb64 (const bfd_byte *addr ATTRIBUTE_UNUSED)
+bfd_uint64_t
+bfd_getb64 (const void *p ATTRIBUTE_UNUSED)
{
-#ifdef BFD64
- bfd_vma v;
+#ifdef BFD_HOST_64_BIT
+ const bfd_byte *addr = (const bfd_byte *) p;
+ bfd_uint64_t v;
v = addr[0]; v <<= 8;
v |= addr[1]; v <<= 8;
#endif
}
-bfd_vma
-bfd_getl64 (const bfd_byte *addr ATTRIBUTE_UNUSED)
+bfd_uint64_t
+bfd_getl64 (const void *p ATTRIBUTE_UNUSED)
{
-#ifdef BFD64
- bfd_vma v;
+#ifdef BFD_HOST_64_BIT
+ const bfd_byte *addr = (const bfd_byte *) p;
+ bfd_uint64_t v;
v = addr[7]; v <<= 8;
v |= addr[6]; v <<= 8;
}
-bfd_signed_vma
-bfd_getb_signed_64 (addr)
- register const bfd_byte *addr ATTRIBUTE_UNUSED;
+bfd_int64_t
+bfd_getb_signed_64 (const void *p ATTRIBUTE_UNUSED)
{
-#ifdef BFD64
- bfd_vma v;
+#ifdef BFD_HOST_64_BIT
+ const bfd_byte *addr = (const bfd_byte *) p;
+ bfd_uint64_t v;
v = addr[0]; v <<= 8;
v |= addr[1]; v <<= 8;
#endif
}
-bfd_signed_vma
-bfd_getl_signed_64 (addr)
- register const bfd_byte *addr ATTRIBUTE_UNUSED;
+bfd_int64_t
+bfd_getl_signed_64 (const void *p ATTRIBUTE_UNUSED)
{
-#ifdef BFD64
- bfd_vma v;
+#ifdef BFD_HOST_64_BIT
+ const bfd_byte *addr = (const bfd_byte *) p;
+ bfd_uint64_t v;
v = addr[7]; v <<= 8;
v |= addr[6]; v <<= 8;
}
void
-bfd_putb32 (bfd_vma data, bfd_byte *addr)
+bfd_putb32 (bfd_vma data, void *p)
{
- addr[0] = (bfd_byte) (data >> 24);
- addr[1] = (bfd_byte) (data >> 16);
- addr[2] = (bfd_byte) (data >> 8);
- addr[3] = (bfd_byte) data;
+ bfd_byte *addr = (bfd_byte *) p;
+ addr[0] = (data >> 24) & 0xff;
+ addr[1] = (data >> 16) & 0xff;
+ addr[2] = (data >> 8) & 0xff;
+ addr[3] = data & 0xff;
}
void
-bfd_putl32 (bfd_vma data, bfd_byte *addr)
+bfd_putl32 (bfd_vma data, void *p)
{
- addr[0] = (bfd_byte) data;
- addr[1] = (bfd_byte) (data >> 8);
- addr[2] = (bfd_byte) (data >> 16);
- addr[3] = (bfd_byte) (data >> 24);
+ bfd_byte *addr = (bfd_byte *) p;
+ addr[0] = data & 0xff;
+ addr[1] = (data >> 8) & 0xff;
+ addr[2] = (data >> 16) & 0xff;
+ addr[3] = (data >> 24) & 0xff;
}
void
-bfd_putb64 (bfd_vma data ATTRIBUTE_UNUSED, bfd_byte *addr ATTRIBUTE_UNUSED)
-{
-#ifdef BFD64
- addr[0] = (bfd_byte) (data >> (7*8));
- addr[1] = (bfd_byte) (data >> (6*8));
- addr[2] = (bfd_byte) (data >> (5*8));
- addr[3] = (bfd_byte) (data >> (4*8));
- addr[4] = (bfd_byte) (data >> (3*8));
- addr[5] = (bfd_byte) (data >> (2*8));
- addr[6] = (bfd_byte) (data >> (1*8));
- addr[7] = (bfd_byte) (data >> (0*8));
+bfd_putb64 (bfd_uint64_t data ATTRIBUTE_UNUSED, void *p ATTRIBUTE_UNUSED)
+{
+#ifdef BFD_HOST_64_BIT
+ bfd_byte *addr = (bfd_byte *) p;
+ addr[0] = (data >> (7*8)) & 0xff;
+ addr[1] = (data >> (6*8)) & 0xff;
+ addr[2] = (data >> (5*8)) & 0xff;
+ addr[3] = (data >> (4*8)) & 0xff;
+ addr[4] = (data >> (3*8)) & 0xff;
+ addr[5] = (data >> (2*8)) & 0xff;
+ addr[6] = (data >> (1*8)) & 0xff;
+ addr[7] = (data >> (0*8)) & 0xff;
#else
BFD_FAIL();
#endif
}
void
-bfd_putl64 (bfd_vma data ATTRIBUTE_UNUSED, bfd_byte *addr ATTRIBUTE_UNUSED)
-{
-#ifdef BFD64
- addr[7] = (bfd_byte) (data >> (7*8));
- addr[6] = (bfd_byte) (data >> (6*8));
- addr[5] = (bfd_byte) (data >> (5*8));
- addr[4] = (bfd_byte) (data >> (4*8));
- addr[3] = (bfd_byte) (data >> (3*8));
- addr[2] = (bfd_byte) (data >> (2*8));
- addr[1] = (bfd_byte) (data >> (1*8));
- addr[0] = (bfd_byte) (data >> (0*8));
+bfd_putl64 (bfd_uint64_t data ATTRIBUTE_UNUSED, void *p ATTRIBUTE_UNUSED)
+{
+#ifdef BFD_HOST_64_BIT
+ bfd_byte *addr = (bfd_byte *) p;
+ addr[7] = (data >> (7*8)) & 0xff;
+ addr[6] = (data >> (6*8)) & 0xff;
+ addr[5] = (data >> (5*8)) & 0xff;
+ addr[4] = (data >> (4*8)) & 0xff;
+ addr[3] = (data >> (3*8)) & 0xff;
+ addr[2] = (data >> (2*8)) & 0xff;
+ addr[1] = (data >> (1*8)) & 0xff;
+ addr[0] = (data >> (0*8)) & 0xff;
#else
BFD_FAIL();
#endif
}
void
-bfd_put_bits (bfd_vma data, bfd_byte *addr, int bits, bfd_boolean big_p)
+bfd_put_bits (bfd_uint64_t data, void *p, int bits, bfd_boolean big_p)
{
+ bfd_byte *addr = (bfd_byte *) p;
int i;
int bytes;
bytes = bits / 8;
for (i = 0; i < bytes; i++)
{
- int index = big_p ? bytes - i - 1 : i;
+ int addr_index = big_p ? bytes - i - 1 : i;
- addr[index] = (bfd_byte) data;
+ addr[addr_index] = data & 0xff;
data >>= 8;
}
}
-bfd_vma
-bfd_get_bits (bfd_byte *addr, int bits, bfd_boolean big_p)
+bfd_uint64_t
+bfd_get_bits (const void *p, int bits, bfd_boolean big_p)
{
- bfd_vma data;
+ const bfd_byte *addr = (const bfd_byte *) p;
+ bfd_uint64_t data;
int i;
int bytes;
bytes = bits / 8;
for (i = 0; i < bytes; i++)
{
- int index = big_p ? i : bytes - i - 1;
+ int addr_index = big_p ? i : bytes - i - 1;
- data = (data << 8) | addr[index];
+ data = (data << 8) | addr[addr_index];
}
return data;
file_ptr offset,
bfd_size_type count)
{
+ bfd_size_type sz;
if (count == 0)
return TRUE;
- if (offset + count > section->_raw_size)
+ if (section->compress_status != COMPRESS_SECTION_NONE)
+ {
+ (*_bfd_error_handler)
+ (_("%B: unable to get decompressed section %A"),
+ abfd, section);
+ bfd_set_error (bfd_error_invalid_operation);
+ return FALSE;
+ }
+
+ /* We do allow reading of a section after bfd_final_link has
+ written the contents out to disk. In that situation, rawsize is
+ just a stale version of size, so ignore it. Otherwise we must be
+ reading an input section, where rawsize, if different to size,
+ is the on-disk size. */
+ if (abfd->direction != write_direction && section->rawsize != 0)
+ sz = section->rawsize;
+ else
+ sz = section->size;
+ if (offset + count < count
+ || offset + count > sz)
{
bfd_set_error (bfd_error_invalid_operation);
return FALSE;
bfd_size_type count ATTRIBUTE_UNUSED)
{
#ifdef USE_MMAP
+ bfd_size_type sz;
+
if (count == 0)
return TRUE;
if (abfd->xvec->_bfd_get_section_contents
w->data = w->i->data;
return bfd_get_section_contents (abfd, section, w->data, offset, count);
}
- if (offset + count > section->_raw_size
+ if (abfd->direction != write_direction && section->rawsize != 0)
+ sz = section->rawsize;
+ else
+ sz = section->size;
+ if (offset + count > sz
|| ! bfd_get_file_window (abfd, section->filepos + offset, count, w,
TRUE))
return FALSE;
{
unsigned int result = 0;
- while ((x = (x >> 1)) != 0)
+ if (x <= 1)
+ return result;
+ --x;
+ do
++result;
+ while ((x >>= 1) != 0);
return result;
}
const char *msg;
if (bfd_big_endian (ibfd))
- msg = _("%s: compiled for a big endian system and target is little endian");
+ msg = _("%B: compiled for a big endian system and target is little endian");
else
- msg = _("%s: compiled for a little endian system and target is big endian");
+ msg = _("%B: compiled for a little endian system and target is big endian");
- (*_bfd_error_handler) (msg, bfd_archive_filename (ibfd));
+ (*_bfd_error_handler) (msg, ibfd);
bfd_set_error (bfd_error_wrong_format);
return FALSE;
if (~(size_t) func & ~mask)
{
+ fflush (stdout);
/* Note: separate sentences in order to allow
for translation into other languages. */
if (func)
what, file, line, func);
else
fprintf (stderr, _("Deprecated %s called\n"), what);
+ fflush (stderr);
mask |= ~(size_t) func;
}
}
+
+/* Helper function for reading uleb128 encoded data. */
+
+bfd_vma
+read_unsigned_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
+ bfd_byte *buf,
+ unsigned int *bytes_read_ptr)
+{
+ bfd_vma result;
+ unsigned int num_read;
+ unsigned int shift;
+ unsigned char byte;
+
+ result = 0;
+ shift = 0;
+ num_read = 0;
+ do
+ {
+ byte = bfd_get_8 (abfd, buf);
+ buf++;
+ num_read++;
+ result |= (((bfd_vma) byte & 0x7f) << shift);
+ shift += 7;
+ }
+ while (byte & 0x80);
+ *bytes_read_ptr = num_read;
+ return result;
+}
+
+/* Read in a LEB128 encoded value from ABFD starting at DATA.
+ If SIGN is true, return a signed LEB128 value.
+ If LENGTH_RETURN is not NULL, return in it the number of bytes read.
+ No bytes will be read at address END or beyond. */
+
+bfd_vma
+safe_read_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
+ bfd_byte *data,
+ unsigned int *length_return,
+ bfd_boolean sign,
+ const bfd_byte * const end)
+{
+ bfd_vma result = 0;
+ unsigned int num_read = 0;
+ unsigned int shift = 0;
+ unsigned char byte = 0;
+
+ while (data < end)
+ {
+ byte = bfd_get_8 (abfd, data);
+ data++;
+ num_read++;
+
+ result |= ((bfd_vma) (byte & 0x7f)) << shift;
+
+ shift += 7;
+ if ((byte & 0x80) == 0)
+ break;
+ }
+
+ if (length_return != NULL)
+ *length_return = num_read;
+
+ if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
+ result |= -((bfd_vma) 1 << shift);
+
+ return result;
+}
+
+/* Helper function for reading sleb128 encoded data. */
+
+bfd_signed_vma
+read_signed_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
+ bfd_byte *buf,
+ unsigned int *bytes_read_ptr)
+{
+ bfd_vma result;
+ unsigned int shift;
+ unsigned int num_read;
+ unsigned char byte;
+
+ result = 0;
+ shift = 0;
+ num_read = 0;
+ do
+ {
+ byte = bfd_get_8 (abfd, buf);
+ buf ++;
+ num_read ++;
+ result |= (((bfd_vma) byte & 0x7f) << shift);
+ shift += 7;
+ }
+ while (byte & 0x80);
+ if (shift < 8 * sizeof (result) && (byte & 0x40))
+ result |= (((bfd_vma) -1) << shift);
+ *bytes_read_ptr = num_read;
+ return result;
+}
+
+bfd_boolean
+_bfd_generic_init_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
+ asection *isec ATTRIBUTE_UNUSED,
+ bfd *obfd ATTRIBUTE_UNUSED,
+ asection *osec ATTRIBUTE_UNUSED,
+ struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
+{
+ return TRUE;
+}
projects / deliverable / binutils-gdb.git / blobdiff