/usr/src/gnu/usr.bin/binutils/bfd/ihex.c

Bug Summary

File:	src/gnu/usr.bin/binutils/bfd/ihex.c
Warning:	line 637, column 9 Array access results in a null pointer dereference
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ihex.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/binutils/obj/bfd -resource-dir /usr/local/lib/clang/13.0.0 -D HAVE_CONFIG_H -I . -I /usr/src/gnu/usr.bin/binutils/bfd -I . -D _GNU_SOURCE -D NETBSD_CORE -I . -I /usr/src/gnu/usr.bin/binutils/bfd -I /usr/src/gnu/usr.bin/binutils/bfd/../include -I /usr/src/gnu/usr.bin/binutils/bfd/../intl -I ../intl -D PIE_DEFAULT=1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/gnu/usr.bin/binutils/obj/bfd -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/gnu/usr.bin/binutils/bfd/ihex.c
1/* BFD back-end for Intel Hex objects.
 Copyright 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003
 Free Software Foundation, Inc.
 Written by Ian Lance Taylor of Cygnus Support <ian@cygnus.com>.

 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
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 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.  */

22/* This is what Intel Hex files look like:

INTEL FORMATS

26A. Intel 1

 16-bit address-field format, for files 64k bytes in length or less.

 DATA RECORD
 Byte 1	Header = colon(:)
 2..3		The number of data bytes in hex notation
 4..5		High byte of the record load address
 6..7		Low byte of the record load address
 8..9		Record type, must be "00"
 10..x	Data bytes in hex notation:
x = (number of bytes - 1) * 2 + 11
 x+1..x+2	Checksum in hex notation
 x+3..x+4	Carriage return, line feed

 END RECORD
 Byte 1	Header = colon (:)
 2..3		The byte count, must be "00"
 4..7		Transfer-address (usually "0000")
the jump-to address, execution start address
 8..9		Record type, must be "01"
 10..11	Checksum, in hex notation
 12..13	Carriage return, line feed

50B. INTEL 2

 MCS-86 format, using a 20-bit address for files larger than 64K bytes.

 DATA RECORD
 Byte 1	Header = colon (:)
 2..3		The byte count of this record, hex notation
 4..5		High byte of the record load address
 6..7		Low byte of the record load address
 8..9		Record type, must be "00"
 10..x	The data bytes in hex notation:
x = (number of data bytes - 1) * 2 + 11
 x+1..x+2	Checksum in hex notation
 x+3..x+4	Carriage return, line feed

 EXTENDED ADDRESS RECORD
 Byte 1	Header = colon(:)
 2..3		The byte count, must be "02"
 4..7		Load address, must be "0000"
 8..9		Record type, must be "02"
 10..11	High byte of the offset address
 12..13	Low byte of the offset address
 14..15	Checksum in hex notation
 16..17	Carriage return, line feed

 The checksums are the two's complement of the 8-bit sum
 without carry of the byte count, offset address, and the
 record type.

 START ADDRESS RECORD
 Byte 1	Header = colon (:)
 2..3		The byte count, must be "04"
 4..7		Load address, must be "0000"
 8..9		Record type, must be "03"
 10..13	8086 CS value
 14..17	8086 IP value
 18..19	Checksum in hex notation
 20..21	Carriage return, line feed

89Another document reports these additional types:

 EXTENDED LINEAR ADDRESS RECORD
 Byte 1	Header = colon (:)
 2..3		The byte count, must be "02"
 4..7		Load address, must be "0000"
 8..9		Record type, must be "04"
 10..13	Upper 16 bits of address of subsequent records
 14..15	Checksum in hex notation
 16..17	Carriage return, line feed

 START LINEAR ADDRESS RECORD
 Byte 1	Header = colon (:)
 2..3		The byte count, must be "02"
 4..7		Load address, must be "0000"
 8..9		Record type, must be "05"
 10..13	Upper 16 bits of start address
 14..15	Checksum in hex notation
 16..17	Carriage return, line feed

109The MRI compiler uses this, which is a repeat of type 5:

EXTENDED START RECORD
 Byte 1	Header = colon (:)
 2..3		The byte count, must be "04"
 4..7		Load address, must be "0000"
 8..9		Record type, must be "05"
 10..13	Upper 16 bits of start address
 14..17	Lower 16 bits of start address
 18..19	Checksum in hex notation
 20..21	Carriage return, line feed
120*/

122#include "bfd.h"
123#include "sysdep.h"
124#include "libbfd.h"
125#include "libiberty.h"
126#include "safe-ctype.h"

128static void ihex_init
PARAMS ((void))(void);
130static bfd_boolean ihex_mkobject
PARAMS ((bfd *))(bfd *);
132static INLINE__inline__ int ihex_get_byte
PARAMS ((bfd *, bfd_boolean *))(bfd *, bfd_boolean *);
134static void ihex_bad_byte
PARAMS ((bfd *, unsigned int, int, bfd_boolean))(bfd *, unsigned int, int, bfd_boolean);
136static bfd_boolean ihex_scan
PARAMS ((bfd *))(bfd *);
138static const bfd_target *ihex_object_p
PARAMS ((bfd *))(bfd *);
140static bfd_boolean ihex_read_section
PARAMS ((bfd *, asection *, bfd_byte *))(bfd *, asection *, bfd_byte *);
142static bfd_boolean ihex_get_section_contents
PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type))(bfd *, asection *, void *, file_ptr, bfd_size_type);
144static bfd_boolean ihex_set_section_contents
PARAMS ((bfd *, asection *, const PTR, file_ptr, bfd_size_type))(bfd *, asection *, const void *, file_ptr, bfd_size_type);
146static bfd_boolean ihex_write_record
PARAMS ((bfd *, size_t, unsigned int, unsigned int, bfd_byte *))(bfd *, size_t, unsigned int, unsigned int, bfd_byte *);
148static bfd_boolean ihex_write_object_contents
PARAMS ((bfd *))(bfd *);
150static bfd_boolean ihex_set_arch_mach
PARAMS ((bfd *, enum bfd_architecture, unsigned long))(bfd *, enum bfd_architecture, unsigned long);
152static int ihex_sizeof_headers
PARAMS ((bfd *, bfd_boolean))(bfd *, bfd_boolean);

155/* The number of bytes we put on one line during output.  */

157#define CHUNK16 16

159/* Macros for converting between hex and binary.  */

161#define NIBBLE(x)(((unsigned int) _hex_value[(unsigned char) (x)]))    (hex_value (x)((unsigned int) _hex_value[(unsigned char) (x)]))
162#define HEX2(buffer)(((((unsigned int) _hex_value[(unsigned char) ((buffer)[0])])
) << 4) + (((unsigned int) _hex_value[(unsigned char) (
(buffer)[1])]))) ((NIBBLE ((buffer)[0])(((unsigned int) _hex_value[(unsigned char) ((buffer)[0])])) << 4) + NIBBLE ((buffer)[1])(((unsigned int) _hex_value[(unsigned char) ((buffer)[1])])))
163#define HEX4(buffer)(((((((unsigned int) _hex_value[(unsigned char) ((buffer)[0])
])) << 4) + (((unsigned int) _hex_value[(unsigned char)
 ((buffer)[1])]))) << 8) + (((((unsigned int) _hex_value
[(unsigned char) (((buffer) + 2)[0])])) << 4) + (((unsigned
 int) _hex_value[(unsigned char) (((buffer) + 2)[1])])))) ((HEX2 (buffer)(((((unsigned int) _hex_value[(unsigned char) ((buffer)[0])])
) << 4) + (((unsigned int) _hex_value[(unsigned char) (
(buffer)[1])]))) << 8) + HEX2 ((buffer) + 2)(((((unsigned int) _hex_value[(unsigned char) (((buffer) + 2)
[0])])) << 4) + (((unsigned int) _hex_value[(unsigned char
) (((buffer) + 2)[1])]))))
164#define ISHEX(x)((((unsigned int) _hex_value[(unsigned char) (x)]) != 99))     (hex_p (x)(((unsigned int) _hex_value[(unsigned char) (x)]) != 99))

166/* When we write out an ihex value, the values can not be output as
 they are seen.  Instead, we hold them in memory in this structure.  */

169struct ihex_data_list
170{
struct ihex_data_list *next;
bfd_byte *data;
bfd_vma where;
bfd_size_type size;
175};

177/* The ihex tdata information.  */

179struct ihex_data_struct
180{
struct ihex_data_list *head;
struct ihex_data_list *tail;
183};

185/* Initialize by filling in the hex conversion array.  */

187static void
188ihex_init ()
189{
static bfd_boolean inited;

if (! inited)
  {
    inited = TRUE1;
    hex_init ();
  }
197}

199/* Create an ihex object.  */

201static bfd_boolean
202ihex_mkobject (abfd)
   bfd *abfd;
204{
struct ihex_data_struct *tdata;
bfd_size_type amt = sizeof (struct ihex_data_struct);

tdata = (struct ihex_data_struct *) bfd_alloc (abfd, amt);
if (tdata == NULL((void*)0))
  return FALSE0;

abfd->tdata.ihex_data = tdata;
tdata->head = NULL((void*)0);
tdata->tail = NULL((void*)0);
return TRUE1;
216}

218/* Read a byte from a BFD.  Set *ERRORPTR if an error occurred.
 Return EOF on error or end of file.  */

221static INLINE__inline__ int
222ihex_get_byte (abfd, errorptr)
   bfd *abfd;
   bfd_boolean *errorptr;
225{
bfd_byte c;

if (bfd_bread (&c, (bfd_size_type) 1, abfd) != 1)
  {
    if (bfd_get_error () != bfd_error_file_truncated)
*errorptr = TRUE1;
    return EOF(-1);
  }

return (int) (c & 0xff);
236}

238/* Report a problem in an Intel Hex file.  */

240static void
241ihex_bad_byte (abfd, lineno, c, error)
   bfd *abfd;
   unsigned int lineno;
   int c;
   bfd_boolean error;
246{
if (c == EOF(-1))
  {
    if (! error)
bfd_set_error (bfd_error_file_truncated);
  }
else
  {
    char buf[10];

    if (! ISPRINT (c)(_sch_istable[(c) & 0xff] & (unsigned short)(_sch_isprint
)))
sprintf (buf, "\\%03o", (unsigned int) c);
    else
{
 buf[0] = c;
 buf[1] = '\0';
}
    (*_bfd_error_handler)
(_("%s:%d: unexpected character `%s' in Intel Hex file\n")("%s:%d: unexpected character `%s' in Intel Hex file\n"),
bfd_archive_filename (abfd), lineno, buf);
    bfd_set_error (bfd_error_bad_value);
  }
268}

270/* Read an Intel hex file and turn it into sections.  We create a new
 section for each contiguous set of bytes.  */

273static bfd_boolean
274ihex_scan (abfd)
   bfd *abfd;
276{
bfd_vma segbase;
bfd_vma extbase;
asection *sec;
unsigned int lineno;
bfd_boolean error;
bfd_byte *buf = NULL((void*)0);
size_t bufsize;
int c;

if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET0) != 0)
  goto error_return;

abfd->start_address = 0;

segbase = 0;
extbase = 0;
sec = NULL((void*)0);
lineno = 1;
error = FALSE0;
bufsize = 0;

while ((c = ihex_get_byte (abfd, &error)) != EOF(-1))
  {
    if (c == '\r')
continue;
    else if (c == '\n')
{
 ++lineno;
 continue;
}
    else if (c != ':')
{
 ihex_bad_byte (abfd, lineno, c, error);
 goto error_return;
}
    else
{
 file_ptr pos;
 char hdr[8];
 unsigned int i;
 unsigned int len;
 bfd_vma addr;
 unsigned int type;
 unsigned int chars;
 unsigned int chksum;

 /* This is a data record.  */
 pos = bfd_tell (abfd) - 1;

 /* Read the header bytes.  */
 if (bfd_bread (hdr, (bfd_size_type) 8, abfd) != 8)
   goto error_return;

 for (i = 0; i < 8; i++)
   {
     if (! ISHEX (hdr[i])((((unsigned int) _hex_value[(unsigned char) (hdr[i])]) != 99
)))
{
  ihex_bad_byte (abfd, lineno, hdr[i], error);
  goto error_return;
}
   }

 len = HEX2 (hdr)(((((unsigned int) _hex_value[(unsigned char) ((hdr)[0])])) <<
 4) + (((unsigned int) _hex_value[(unsigned char) ((hdr)[1])]
)));
 addr = HEX4 (hdr + 2)(((((((unsigned int) _hex_value[(unsigned char) ((hdr + 2)[0]
)])) << 4) + (((unsigned int) _hex_value[(unsigned char
) ((hdr + 2)[1])]))) << 8) + (((((unsigned int) _hex_value
[(unsigned char) (((hdr + 2) + 2)[0])])) << 4) + (((unsigned
 int) _hex_value[(unsigned char) (((hdr + 2) + 2)[1])]))));
 type = HEX2 (hdr + 6)(((((unsigned int) _hex_value[(unsigned char) ((hdr + 6)[0])]
)) << 4) + (((unsigned int) _hex_value[(unsigned char) (
(hdr + 6)[1])])));

 /* Read the data bytes.  */
 chars = len * 2 + 2;
 if (chars >= bufsize)
   {
     buf = (bfd_byte *) bfd_realloc (buf, (bfd_size_type) chars);
     if (buf == NULL((void*)0))
goto error_return;
     bufsize = chars;
   }

 if (bfd_bread (buf, (bfd_size_type) chars, abfd) != chars)
   goto error_return;

 for (i = 0; i < chars; i++)
   {
     if (! ISHEX (buf[i])((((unsigned int) _hex_value[(unsigned char) (buf[i])]) != 99
)))
{
  ihex_bad_byte (abfd, lineno, hdr[i], error);
  goto error_return;
}
   }

 /* Check the checksum.  */
 chksum = len + addr + (addr >> 8) + type;
 for (i = 0; i < len; i++)
   chksum += HEX2 (buf + 2 * i)(((((unsigned int) _hex_value[(unsigned char) ((buf + 2 * i)[
0])])) << 4) + (((unsigned int) _hex_value[(unsigned char
) ((buf + 2 * i)[1])])));
 if (((- chksum) & 0xff) != (unsigned int) HEX2 (buf + 2 * i)(((((unsigned int) _hex_value[(unsigned char) ((buf + 2 * i)[
0])])) << 4) + (((unsigned int) _hex_value[(unsigned char
) ((buf + 2 * i)[1])]))))
   {
     (*_bfd_error_handler)
(_("%s:%u: bad checksum in Intel Hex file (expected %u, found %u)")("%s:%u: bad checksum in Intel Hex file (expected %u, found %u)"
),
 bfd_archive_filename (abfd), lineno,
 (- chksum) & 0xff, (unsigned int) HEX2 (buf + 2 * i)(((((unsigned int) _hex_value[(unsigned char) ((buf + 2 * i)[
0])])) << 4) + (((unsigned int) _hex_value[(unsigned char
) ((buf + 2 * i)[1])]))));
     bfd_set_error (bfd_error_bad_value);
     goto error_return;
   }

 switch (type)
   {
   case 0:
     /* This is a data record.  */
     if (sec != NULL((void*)0)
  && sec->vma + sec->_raw_size == extbase + segbase + addr)
{
  /* This data goes at the end of the section we are
                   currently building.  */
  sec->_raw_size += len;
}
     else if (len > 0)
{
  char secbuf[20];
  char *secname;
  bfd_size_type amt;

  sprintf (secbuf, ".sec%d", bfd_count_sections (abfd)((abfd)->section_count) + 1);
  amt = strlen (secbuf) + 1;
  secname = (char *) bfd_alloc (abfd, amt);
  if (secname == NULL((void*)0))
    goto error_return;
  strcpy (secname, secbuf);
  sec = bfd_make_section (abfd, secname);
  if (sec == NULL((void*)0))
    goto error_return;
  sec->flags = SEC_HAS_CONTENTS0x200 | SEC_LOAD0x002 | SEC_ALLOC0x001;
  sec->vma = extbase + segbase + addr;
  sec->lma = extbase + segbase + addr;
  sec->_raw_size = len;
  sec->filepos = pos;
}
     break;

   case 1:
     /* An end record.  */
     if (abfd->start_address == 0)
abfd->start_address = addr;
     if (buf != NULL((void*)0))
free (buf);
     return TRUE1;

   case 2:
     /* An extended address record.  */
     if (len != 2)
{
  (*_bfd_error_handler)
    (_("%s:%u: bad extended address record length in Intel Hex file")("%s:%u: bad extended address record length in Intel Hex file"
),
     bfd_archive_filename (abfd), lineno);
  bfd_set_error (bfd_error_bad_value);
  goto error_return;
}

     segbase = HEX4 (buf)(((((((unsigned int) _hex_value[(unsigned char) ((buf)[0])]))
 << 4) + (((unsigned int) _hex_value[(unsigned char) ((
buf)[1])]))) << 8) + (((((unsigned int) _hex_value[(unsigned
 char) (((buf) + 2)[0])])) << 4) + (((unsigned int) _hex_value
[(unsigned char) (((buf) + 2)[1])])))) << 4;

     sec = NULL((void*)0);

     break;

   case 3:
     /* An extended start address record.  */
     if (len != 4)
{
  (*_bfd_error_handler)
    (_("%s:%u: bad extended start address length in Intel Hex file")("%s:%u: bad extended start address length in Intel Hex file"
),
     bfd_archive_filename (abfd), lineno);
  bfd_set_error (bfd_error_bad_value);
  goto error_return;
}

     abfd->start_address += (HEX4 (buf)(((((((unsigned int) _hex_value[(unsigned char) ((buf)[0])]))
 << 4) + (((unsigned int) _hex_value[(unsigned char) ((
buf)[1])]))) << 8) + (((((unsigned int) _hex_value[(unsigned
 char) (((buf) + 2)[0])])) << 4) + (((unsigned int) _hex_value
[(unsigned char) (((buf) + 2)[1])])))) << 4) + HEX4 (buf + 4)(((((((unsigned int) _hex_value[(unsigned char) ((buf + 4)[0]
)])) << 4) + (((unsigned int) _hex_value[(unsigned char
) ((buf + 4)[1])]))) << 8) + (((((unsigned int) _hex_value
[(unsigned char) (((buf + 4) + 2)[0])])) << 4) + (((unsigned
 int) _hex_value[(unsigned char) (((buf + 4) + 2)[1])]))));

     sec = NULL((void*)0);

     break;

   case 4:
     /* An extended linear address record.  */
     if (len != 2)
{
  (*_bfd_error_handler)
    (_("%s:%u: bad extended linear address record length in Intel Hex file")("%s:%u: bad extended linear address record length in Intel Hex file"
),
     bfd_archive_filename (abfd), lineno);
  bfd_set_error (bfd_error_bad_value);
  goto error_return;
}

     extbase = HEX4 (buf)(((((((unsigned int) _hex_value[(unsigned char) ((buf)[0])]))
 << 4) + (((unsigned int) _hex_value[(unsigned char) ((
buf)[1])]))) << 8) + (((((unsigned int) _hex_value[(unsigned
 char) (((buf) + 2)[0])])) << 4) + (((unsigned int) _hex_value
[(unsigned char) (((buf) + 2)[1])])))) << 16;

     sec = NULL((void*)0);

     break;

   case 5:
     /* An extended linear start address record.  */
     if (len != 2 && len != 4)
{
  (*_bfd_error_handler)
    (_("%s:%u: bad extended linear start address length in Intel Hex file")("%s:%u: bad extended linear start address length in Intel Hex file"
),
     bfd_archive_filename (abfd), lineno);
  bfd_set_error (bfd_error_bad_value);
  goto error_return;
}

     if (len == 2)
abfd->start_address += HEX4 (buf)(((((((unsigned int) _hex_value[(unsigned char) ((buf)[0])]))
 << 4) + (((unsigned int) _hex_value[(unsigned char) ((
buf)[1])]))) << 8) + (((((unsigned int) _hex_value[(unsigned
 char) (((buf) + 2)[0])])) << 4) + (((unsigned int) _hex_value
[(unsigned char) (((buf) + 2)[1])])))) << 16;
     else
abfd->start_address = (HEX4 (buf)(((((((unsigned int) _hex_value[(unsigned char) ((buf)[0])]))
 << 4) + (((unsigned int) _hex_value[(unsigned char) ((
buf)[1])]))) << 8) + (((((unsigned int) _hex_value[(unsigned
 char) (((buf) + 2)[0])])) << 4) + (((unsigned int) _hex_value
[(unsigned char) (((buf) + 2)[1])])))) << 16) + HEX4 (buf + 4)(((((((unsigned int) _hex_value[(unsigned char) ((buf + 4)[0]
)])) << 4) + (((unsigned int) _hex_value[(unsigned char
) ((buf + 4)[1])]))) << 8) + (((((unsigned int) _hex_value
[(unsigned char) (((buf + 4) + 2)[0])])) << 4) + (((unsigned
 int) _hex_value[(unsigned char) (((buf + 4) + 2)[1])]))));

     sec = NULL((void*)0);

     break;

   default:
     (*_bfd_error_handler)
(_("%s:%u: unrecognized ihex type %u in Intel Hex file\n")("%s:%u: unrecognized ihex type %u in Intel Hex file\n"),
 bfd_archive_filename (abfd), lineno, type);
     bfd_set_error (bfd_error_bad_value);
     goto error_return;
   }
}
  }

if (error)
  goto error_return;

if (buf != NULL((void*)0))
  free (buf);

return TRUE1;

error_return:
if (buf != NULL((void*)0))
  free (buf);
return FALSE0;
514}

516/* Try to recognize an Intel Hex file.  */

518static const bfd_target *
519ihex_object_p (abfd)
   bfd *abfd;
521{
PTRvoid * tdata_save;
bfd_byte b[9];
unsigned int i;
unsigned int type;

ihex_init ();

if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET0) != 0)
  return NULL((void*)0);
if (bfd_bread (b, (bfd_size_type) 9, abfd) != 9)
  {
    if (bfd_get_error () == bfd_error_file_truncated)
bfd_set_error (bfd_error_wrong_format);
    return NULL((void*)0);
  }

if (b[0] != ':')
  {
    bfd_set_error (bfd_error_wrong_format);
    return NULL((void*)0);
  }

for (i = 1; i < 9; i++)
  {
    if (! ISHEX (b[i])((((unsigned int) _hex_value[(unsigned char) (b[i])]) != 99)))
{
 bfd_set_error (bfd_error_wrong_format);
 return NULL((void*)0);
}
  }

type = HEX2 (b + 7)(((((unsigned int) _hex_value[(unsigned char) ((b + 7)[0])]))
 << 4) + (((unsigned int) _hex_value[(unsigned char) ((
b + 7)[1])])));
if (type > 5)
  {
    bfd_set_error (bfd_error_wrong_format);
    return NULL((void*)0);
  }

/* OK, it looks like it really is an Intel Hex file.  */
tdata_save = abfd->tdata.any;
if (! ihex_mkobject (abfd) || ! ihex_scan (abfd))
  {
    if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL((void*)0))
bfd_release (abfd, abfd->tdata.any);
    abfd->tdata.any = tdata_save;
    return NULL((void*)0);
  }

return abfd->xvec;
571}

573/* Read the contents of a section in an Intel Hex file.  */

575static bfd_boolean
576ihex_read_section (abfd, section, contents)
   bfd *abfd;
   asection *section;
   bfd_byte *contents;
580{
int c;
bfd_byte *p;
bfd_byte *buf = NULL((void*)0);
6
←
'buf' initialized to a null pointer value→
size_t bufsize;
bfd_boolean error;

if (bfd_seek (abfd, section->filepos, SEEK_SET0) != 0)
7
←
Assuming the condition is false→
8
←
Taking false branch→
  goto error_return;

p = contents;
bufsize = 0;
error = FALSE0;
while ((c = ihex_get_byte (abfd, &error)) != EOF(-1))
9
←
Loop condition is true.  Entering loop body→
  {
    char hdr[8];
    unsigned int len;
    bfd_vma addr;
    unsigned int type;
    unsigned int i;

    if (c == '\r' || c == '\n')
10
←
Assuming the condition is false→
11
←
Assuming the condition is false→
12
←
Taking false branch→
continue;

    /* This is called after ihex_scan has succeeded, so we ought to
       know the exact format.  */
    BFD_ASSERT (c == ':'){ if (!(c == ':')) bfd_assert("/usr/src/gnu/usr.bin/binutils/bfd/ihex.c"
,606); };
13
←
Assuming the condition is true→
14
←
Taking false branch→

    if (bfd_bread (hdr, (bfd_size_type) 8, abfd) != 8)
15
←
Assuming the condition is false→
16
←
Taking false branch→
goto error_return;

    len = HEX2 (hdr)(((((unsigned int) _hex_value[(unsigned char) ((hdr)[0])])) <<
 4) + (((unsigned int) _hex_value[(unsigned char) ((hdr)[1])]
)));
    addr = HEX4 (hdr + 2)(((((((unsigned int) _hex_value[(unsigned char) ((hdr + 2)[0]
)])) << 4) + (((unsigned int) _hex_value[(unsigned char
) ((hdr + 2)[1])]))) << 8) + (((((unsigned int) _hex_value
[(unsigned char) (((hdr + 2) + 2)[0])])) << 4) + (((unsigned
 int) _hex_value[(unsigned char) (((hdr + 2) + 2)[1])]))));
    type = HEX2 (hdr + 6)(((((unsigned int) _hex_value[(unsigned char) ((hdr + 6)[0])]
)) << 4) + (((unsigned int) _hex_value[(unsigned char) (
(hdr + 6)[1])])));

    /* We should only see type 0 records here.  */
    if (type != 0)
17
←
Assuming 'type' is equal to 0→
18
←
Taking false branch→
{
 (*_bfd_error_handler)
   (_("%s: internal error in ihex_read_section")("%s: internal error in ihex_read_section"),
    bfd_archive_filename (abfd));
 bfd_set_error (bfd_error_bad_value);
 goto error_return;
}

    if (len * 2 > bufsize)
19
←
Assuming the condition is false→
20
←
Taking false branch→
{
 buf = (bfd_byte *) bfd_realloc (buf, (bfd_size_type) len * 2);
 if (buf == NULL((void*)0))
   goto error_return;
 bufsize = len * 2;
}

    if (bfd_bread (buf, (bfd_size_type) len * 2, abfd) != len * 2)
21
←
Assuming the condition is false→
22
←
Taking false branch→
goto error_return;

    for (i = 0; i < len; i++)
23
←
Assuming 'i' is < 'len'→
24
←
Loop condition is true.  Entering loop body→
*p++ = HEX2 (buf + 2 * i)(((((unsigned int) _hex_value[(unsigned char) ((buf + 2 * i)[
0])])) << 4) + (((unsigned int) _hex_value[(unsigned char
) ((buf + 2 * i)[1])])));
25
←
Array access results in a null pointer dereference
    if ((bfd_size_type) (p - contents) >= section->_raw_size)
{
 /* We've read everything in the section.  */
 if (buf != NULL((void*)0))
   free (buf);
 return TRUE1;
}

    /* Skip the checksum.  */
    if (bfd_bread (buf, (bfd_size_type) 2, abfd) != 2)
goto error_return;
  }

if ((bfd_size_type) (p - contents) < section->_raw_size)
  {
    (*_bfd_error_handler)
(_("%s: bad section length in ihex_read_section")("%s: bad section length in ihex_read_section"),
bfd_archive_filename (abfd));
    bfd_set_error (bfd_error_bad_value);
    goto error_return;
  }

if (buf != NULL((void*)0))
  free (buf);

return TRUE1;

error_return:
if (buf != NULL((void*)0))
  free (buf);
return FALSE0;
669}

671/* Get the contents of a section in an Intel Hex file.  */

673static bfd_boolean
674ihex_get_section_contents (abfd, section, location, offset, count)
   bfd *abfd;
   asection *section;
   PTRvoid * location;
   file_ptr offset;
   bfd_size_type count;
680{
if (section->used_by_bfd == NULL((void*)0))
1
Assuming field 'used_by_bfd' is equal to NULL→
2
←
Taking true branch→
  {
    section->used_by_bfd = bfd_alloc (abfd, section->_raw_size);
    if (section->used_by_bfd == NULL((void*)0))
3
←
Assuming field 'used_by_bfd' is not equal to NULL→
4
←
Taking false branch→
return FALSE0;
    if (! ihex_read_section (abfd, section, section->used_by_bfd))
5
←
Calling 'ihex_read_section'→
return FALSE0;
  }

memcpy (location, (bfd_byte *) section->used_by_bfd + offset,
 (size_t) count);

return TRUE1;
694}

696/* Set the contents of a section in an Intel Hex file.  */

698static bfd_boolean
699ihex_set_section_contents (abfd, section, location, offset, count)
   bfd *abfd;
   asection *section;
   const PTRvoid * location;
   file_ptr offset;
   bfd_size_type count;
705{
struct ihex_data_list *n;
bfd_byte *data;
struct ihex_data_struct *tdata;
bfd_size_type amt;

if (count == 0
    || (section->flags & SEC_ALLOC0x001) == 0
    || (section->flags & SEC_LOAD0x002) == 0)
  return TRUE1;

amt = sizeof (struct ihex_data_list);
n = (struct ihex_data_list *) bfd_alloc (abfd, amt);
if (n == NULL((void*)0))
  return FALSE0;

data = (bfd_byte *) bfd_alloc (abfd, count);
if (data == NULL((void*)0))
  return FALSE0;
memcpy (data, location, (size_t) count);

n->data = data;
n->where = section->lma + offset;
n->size = count;

/* Sort the records by address.  Optimize for the common case of
   adding a record to the end of the list.  */
tdata = abfd->tdata.ihex_data;
if (tdata->tail != NULL((void*)0)
    && n->where >= tdata->tail->where)
  {
    tdata->tail->next = n;
    n->next = NULL((void*)0);
    tdata->tail = n;
  }
else
  {
    register struct ihex_data_list **pp;

    for (pp = &tdata->head;
  *pp != NULL((void*)0) && (*pp)->where < n->where;
  pp = &(*pp)->next)
;
    n->next = *pp;
    *pp = n;
    if (n->next == NULL((void*)0))
tdata->tail = n;
  }

return TRUE1;
755}

757/* Write a record out to an Intel Hex file.  */

759static bfd_boolean
760ihex_write_record (abfd, count, addr, type, data)
   bfd *abfd;
   size_t count;
   unsigned int addr;
   unsigned int type;
   bfd_byte *data;
766{
static const char digs[] = "0123456789ABCDEF";
char buf[9 + CHUNK16 * 2 + 4];
char *p;
unsigned int chksum;
unsigned int i;
size_t total;

774#define TOHEX(buf, v)((buf)[0] = digs[((v) >> 4) & 0xf], (buf)[1] = digs
[(v) & 0xf]) \
((buf)[0] = digs[((v) >> 4) & 0xf], (buf)[1] = digs[(v) & 0xf])

buf[0] = ':';
TOHEX (buf + 1, count)((buf + 1)[0] = digs[((count) >> 4) & 0xf], (buf + 1
)[1] = digs[(count) & 0xf]);
TOHEX (buf + 3, (addr >> 8) & 0xff)((buf + 3)[0] = digs[(((addr >> 8) & 0xff) >>
 4) & 0xf], (buf + 3)[1] = digs[((addr >> 8) & 0xff
) & 0xf]);
TOHEX (buf + 5, addr & 0xff)((buf + 5)[0] = digs[((addr & 0xff) >> 4) & 0xf
], (buf + 5)[1] = digs[(addr & 0xff) & 0xf]);
TOHEX (buf + 7, type)((buf + 7)[0] = digs[((type) >> 4) & 0xf], (buf + 7
)[1] = digs[(type) & 0xf]);

chksum = count + addr + (addr >> 8) + type;

for (i = 0, p = buf + 9; i < count; i++, p += 2, data++)
  {
    TOHEX (p, *data)((p)[0] = digs[((*data) >> 4) & 0xf], (p)[1] = digs
[(*data) & 0xf]);
    chksum += *data;
  }

TOHEX (p, (- chksum) & 0xff)((p)[0] = digs[(((- chksum) & 0xff) >> 4) & 0xf
], (p)[1] = digs[((- chksum) & 0xff) & 0xf]);
p[2] = '\r';
p[3] = '\n';

total = 9 + count * 2 + 4;
if (bfd_bwrite (buf, (bfd_size_type) total, abfd) != total)
  return FALSE0;

return TRUE1;
800}

802/* Write out an Intel Hex file.  */

804static bfd_boolean
805ihex_write_object_contents (abfd)
   bfd *abfd;
807{
bfd_vma segbase;
bfd_vma extbase;
struct ihex_data_list *l;

segbase = 0;
extbase = 0;
for (l = abfd->tdata.ihex_data->head; l != NULL((void*)0); l = l->next)
  {
    bfd_vma where;
    bfd_byte *p;
    bfd_size_type count;

    where = l->where;
    p = l->data;
    count = l->size;
    while (count > 0)
{
 size_t now;
 unsigned int rec_addr;

 now = count;
 if (count > CHUNK16)
   now = CHUNK16;

 if (where > segbase + extbase + 0xffff)
   {
     bfd_byte addr[2];

     /* We need a new base address.  */
     if (where <= 0xfffff)
{
  /* The addresses should be sorted.  */
  BFD_ASSERT (extbase == 0){ if (!(extbase == 0)) bfd_assert("/usr/src/gnu/usr.bin/binutils/bfd/ihex.c"
,840); };

  segbase = where & 0xf0000;
  addr[0] = (bfd_byte)(segbase >> 12) & 0xff;
  addr[1] = (bfd_byte)(segbase >> 4) & 0xff;
  if (! ihex_write_record (abfd, 2, 0, 2, addr))
    return FALSE0;
}
     else
{
  /* The extended address record and the extended
                   linear address record are combined, at least by
                   some readers.  We need an extended linear address
                   record here, so if we've already written out an
                   extended address record, zero it out to avoid
                   confusion.  */
  if (segbase != 0)
    {
      addr[0] = 0;
      addr[1] = 0;
      if (! ihex_write_record (abfd, 2, 0, 2, addr))
	return FALSE0;
      segbase = 0;
    }

  extbase = where & 0xffff0000;
  if (where > extbase + 0xffff)
    {
      char buf[20];

      sprintf_vma (buf, where)sprintf (buf, "%016lx", where);
      (*_bfd_error_handler)
	(_("%s: address 0x%s out of range for Intel Hex file")("%s: address 0x%s out of range for Intel Hex file"),
	 bfd_get_filename (abfd)((char *) (abfd)->filename), buf);
      bfd_set_error (bfd_error_bad_value);
      return FALSE0;
    }
  addr[0] = (bfd_byte)(extbase >> 24) & 0xff;
  addr[1] = (bfd_byte)(extbase >> 16) & 0xff;
  if (! ihex_write_record (abfd, 2, 0, 4, addr))
    return FALSE0;
}
   }

 rec_addr = where - (extbase + segbase);

        /* Output records shouldn't cross 64K boundaries.  */
        if (rec_addr + now > 0xffff)
          now = 0x10000 - rec_addr;

 if (! ihex_write_record (abfd, now, rec_addr, 0, p))
   return FALSE0;

 where += now;
 p += now;
 count -= now;
}
  }

if (abfd->start_address != 0)
  {
    bfd_vma start;
    bfd_byte startbuf[4];

    start = abfd->start_address;

    if (start <= 0xfffff)
{
 startbuf[0] = (bfd_byte)((start & 0xf0000) >> 12) & 0xff;
 startbuf[1] = 0;
 startbuf[2] = (bfd_byte)(start >> 8) & 0xff;
 startbuf[3] = (bfd_byte)start & 0xff;
 if (! ihex_write_record (abfd, 4, 0, 3, startbuf))
   return FALSE0;
}
    else
{
 startbuf[0] = (bfd_byte)(start >> 24) & 0xff;
 startbuf[1] = (bfd_byte)(start >> 16) & 0xff;
 startbuf[2] = (bfd_byte)(start >> 8) & 0xff;
 startbuf[3] = (bfd_byte)start & 0xff;
 if (! ihex_write_record (abfd, 4, 0, 5, startbuf))
   return FALSE0;
}
  }

if (! ihex_write_record (abfd, 0, 0, 1, NULL((void*)0)))
  return FALSE0;

return TRUE1;
930}

932/* Set the architecture for the output file.  The architecture is
 irrelevant, so we ignore errors about unknown architectures.  */

935static bfd_boolean
936ihex_set_arch_mach (abfd, arch, mach)
   bfd *abfd;
   enum bfd_architecture arch;
   unsigned long mach;
940{
if (! bfd_default_set_arch_mach (abfd, arch, mach))
  {
    if (arch != bfd_arch_unknown)
return FALSE0;
  }
return TRUE1;
947}

949/* Get the size of the headers, for the linker.  */

951static int
952ihex_sizeof_headers (abfd, exec)
   bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__));
   bfd_boolean exec ATTRIBUTE_UNUSED__attribute__ ((__unused__));
955{
return 0;
957}

959/* Some random definitions for the target vector.  */

961#define	ihex_close_and_cleanupbfd_true _bfd_generic_close_and_cleanupbfd_true
962#define ihex_bfd_free_cached_infobfd_true _bfd_generic_bfd_free_cached_infobfd_true
963#define ihex_new_section_hook((bfd_boolean (*) (bfd *, asection *)) bfd_true) _bfd_generic_new_section_hook((bfd_boolean (*) (bfd *, asection *)) bfd_true)
964#define ihex_get_section_contents_in_window_bfd_generic_get_section_contents_in_window \
_bfd_generic_get_section_contents_in_window

967#define ihex_get_symtab_upper_boundbfd_0l bfd_0l
968#define ihex_canonicalize_symtab((long (*) (bfd *, asymbol **)) bfd_0l) \
((long (*) PARAMS ((bfd *, asymbol **))(bfd *, asymbol **)) bfd_0l)
970#define ihex_make_empty_symbol_bfd_generic_make_empty_symbol _bfd_generic_make_empty_symbol
971#define ihex_print_symbol((void (*) (bfd *, void *, asymbol *, bfd_print_symbol_type))
 bfd_void) _bfd_nosymbols_print_symbol((void (*) (bfd *, void *, asymbol *, bfd_print_symbol_type))
 bfd_void)
972#define ihex_get_symbol_info((void (*) (bfd *, asymbol *, symbol_info *)) bfd_void) _bfd_nosymbols_get_symbol_info((void (*) (bfd *, asymbol *, symbol_info *)) bfd_void)
973#define ihex_bfd_is_local_label_name((bfd_boolean (*) (bfd *, const char *)) bfd_false) _bfd_nosymbols_bfd_is_local_label_name((bfd_boolean (*) (bfd *, const char *)) bfd_false)
974#define ihex_get_lineno((alent *(*) (bfd *, asymbol *)) bfd_nullvoidptr) _bfd_nosymbols_get_lineno((alent *(*) (bfd *, asymbol *)) bfd_nullvoidptr)
975#define ihex_find_nearest_line((bfd_boolean (*) (bfd *, asection *, asymbol **, bfd_vma, const
 char **, const char **, unsigned int *)) bfd_false) _bfd_nosymbols_find_nearest_line((bfd_boolean (*) (bfd *, asection *, asymbol **, bfd_vma, const
 char **, const char **, unsigned int *)) bfd_false)
976#define ihex_bfd_make_debug_symbol((asymbol *(*) (bfd *, void *, unsigned long)) bfd_nullvoidptr
) _bfd_nosymbols_bfd_make_debug_symbol((asymbol *(*) (bfd *, void *, unsigned long)) bfd_nullvoidptr
)
977#define ihex_read_minisymbols((long (*) (bfd *, bfd_boolean, void **, unsigned int *)) _bfd_n1
) _bfd_nosymbols_read_minisymbols((long (*) (bfd *, bfd_boolean, void **, unsigned int *)) _bfd_n1
)
978#define ihex_minisymbol_to_symbol((asymbol *(*) (bfd *, bfd_boolean, const void *, asymbol *))
 bfd_nullvoidptr) _bfd_nosymbols_minisymbol_to_symbol((asymbol *(*) (bfd *, bfd_boolean, const void *, asymbol *))
 bfd_nullvoidptr)

980#define ihex_get_reloc_upper_bound((long (*) (bfd *, asection *)) bfd_0l) \
((long (*) PARAMS ((bfd *, asection *))(bfd *, asection *)) bfd_0l)
982#define ihex_canonicalize_reloc((long (*) (bfd *, asection *, arelent **, asymbol **)) bfd_0l
) \
((long (*) PARAMS ((bfd *, asection *, arelent **, asymbol **))(bfd *, asection *, arelent **, asymbol **)) bfd_0l)
984#define ihex_bfd_reloc_type_lookup((reloc_howto_type *(*) (bfd *, bfd_reloc_code_real_type)) bfd_nullvoidptr
) _bfd_norelocs_bfd_reloc_type_lookup((reloc_howto_type *(*) (bfd *, bfd_reloc_code_real_type)) bfd_nullvoidptr
)

986#define ihex_bfd_get_relocated_section_contentsbfd_generic_get_relocated_section_contents \
bfd_generic_get_relocated_section_contents
988#define ihex_bfd_relax_sectionbfd_generic_relax_section bfd_generic_relax_section
989#define ihex_bfd_gc_sectionsbfd_generic_gc_sections bfd_generic_gc_sections
990#define ihex_bfd_merge_sectionsbfd_generic_merge_sections bfd_generic_merge_sections
991#define ihex_bfd_discard_groupbfd_generic_discard_group bfd_generic_discard_group
992#define ihex_bfd_link_hash_table_create_bfd_generic_link_hash_table_create _bfd_generic_link_hash_table_create
993#define ihex_bfd_link_hash_table_free_bfd_generic_link_hash_table_free _bfd_generic_link_hash_table_free
994#define ihex_bfd_link_add_symbols_bfd_generic_link_add_symbols _bfd_generic_link_add_symbols
995#define ihex_bfd_link_just_syms_bfd_generic_link_just_syms _bfd_generic_link_just_syms
996#define ihex_bfd_final_link_bfd_generic_final_link _bfd_generic_final_link
997#define ihex_bfd_link_split_section_bfd_generic_link_split_section _bfd_generic_link_split_section

999/* The Intel Hex target vector.  */

1001const bfd_target ihex_vec =
1002{
"ihex",			/* name */
bfd_target_ihex_flavour,
BFD_ENDIAN_UNKNOWN,		/* target byte order */
BFD_ENDIAN_UNKNOWN,		/* target headers byte order */
0,				/* object flags */
(SEC_HAS_CONTENTS0x200 | SEC_ALLOC0x001 | SEC_LOAD0x002),	/* section flags */
0,				/* leading underscore */
' ',				/* ar_pad_char */
16,				/* ar_max_namelen */
bfd_getb64, bfd_getb_signed_64, bfd_putb64,
bfd_getb32, bfd_getb_signed_32, bfd_putb32,
bfd_getb16, bfd_getb_signed_16, bfd_putb16,	/* data */
bfd_getb64, bfd_getb_signed_64, bfd_putb64,
bfd_getb32, bfd_getb_signed_32, bfd_putb32,
bfd_getb16, bfd_getb_signed_16, bfd_putb16,	/* hdrs */

{
  _bfd_dummy_target,
  ihex_object_p,		/* bfd_check_format */
  _bfd_dummy_target,
  _bfd_dummy_target,
},
{
  bfd_false,
  ihex_mkobject,
  _bfd_generic_mkarchive,
  bfd_false,
},
{				/* bfd_write_contents */
  bfd_false,
  ihex_write_object_contents,
  _bfd_write_archive_contents,
  bfd_false,
},

BFD_JUMP_TABLE_GENERIC (ihex)bfd_true, bfd_true, ((bfd_boolean (*) (bfd *, asection *)) bfd_true
), ihex_get_section_contents, _bfd_generic_get_section_contents_in_window,
BFD_JUMP_TABLE_COPY (_bfd_generic)((bfd_boolean (*) (bfd *, bfd *)) bfd_true), ((bfd_boolean (*
) (bfd *, bfd *)) bfd_true), ((bfd_boolean (*) (bfd *, asection
 *, bfd *, asection *)) bfd_true), ((bfd_boolean (*) (bfd *, asymbol
 *, bfd *, asymbol *)) bfd_true), ((bfd_boolean (*) (bfd *, flagword
)) bfd_true), ((bfd_boolean (*) (bfd *, void *)) bfd_true),
BFD_JUMP_TABLE_CORE (_bfd_nocore)_bfd_nocore_core_file_failing_command, _bfd_nocore_core_file_failing_signal
, _bfd_nocore_core_file_matches_executable_p,
BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive)bfd_false, bfd_false, ((bfd_boolean (*) (bfd *, char **, bfd_size_type
 *, const char **)) bfd_false), ((void (*) (bfd *, const char
 *, char *)) bfd_void), ((bfd_boolean (*) (bfd *, unsigned int
, struct orl *, unsigned int, int)) bfd_false), bfd_nullvoidptr
, ((bfd *(*) (bfd *, bfd *)) bfd_nullvoidptr), ((bfd *(*) (bfd
 *, symindex)) bfd_nullvoidptr), bfd_generic_stat_arch_elt, bfd_false,
BFD_JUMP_TABLE_SYMBOLS (ihex)bfd_0l, ((long (*) (bfd *, asymbol **)) bfd_0l), _bfd_generic_make_empty_symbol
, ((void (*) (bfd *, void *, asymbol *, bfd_print_symbol_type
)) bfd_void), ((void (*) (bfd *, asymbol *, symbol_info *)) bfd_void
), ((bfd_boolean (*) (bfd *, const char *)) bfd_false), ((alent
 *(*) (bfd *, asymbol *)) bfd_nullvoidptr), ((bfd_boolean (*)
 (bfd *, asection *, asymbol **, bfd_vma, const char **, const
 char **, unsigned int *)) bfd_false), ((asymbol *(*) (bfd *,
 void *, unsigned long)) bfd_nullvoidptr), ((long (*) (bfd *,
 bfd_boolean, void **, unsigned int *)) _bfd_n1), ((asymbol *
(*) (bfd *, bfd_boolean, const void *, asymbol *)) bfd_nullvoidptr
),
BFD_JUMP_TABLE_RELOCS (ihex)((long (*) (bfd *, asection *)) bfd_0l), ((long (*) (bfd *, asection
 *, arelent **, asymbol **)) bfd_0l), ((reloc_howto_type *(*)
 (bfd *, bfd_reloc_code_real_type)) bfd_nullvoidptr),
BFD_JUMP_TABLE_WRITE (ihex)ihex_set_arch_mach, ihex_set_section_contents,
BFD_JUMP_TABLE_LINK (ihex)ihex_sizeof_headers, bfd_generic_get_relocated_section_contents
, bfd_generic_relax_section, _bfd_generic_link_hash_table_create
, _bfd_generic_link_hash_table_free, _bfd_generic_link_add_symbols
, _bfd_generic_link_just_syms, _bfd_generic_final_link, _bfd_generic_link_split_section
, bfd_generic_gc_sections, bfd_generic_merge_sections, bfd_generic_discard_group,
BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic)_bfd_n1, ((long (*) (bfd *, asymbol **)) _bfd_n1), _bfd_n1, (
(long (*) (bfd *, arelent **, asymbol **)) _bfd_n1),

NULL((void*)0),

(PTRvoid *) 0
1051};