Back to index

cell-binutils  2.17cvs20070401
Classes | Defines | Typedefs | Functions | Variables
tekhex.c File Reference
#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
#include "libiberty.h"

Go to the source code of this file.

Classes

struct  addr_range_type
struct  tekhex_symbol_struct
struct  tekhex_data_list_struct
struct  data_struct
struct  tekhex_data_struct

Defines

#define NOT_HEX   20
#define NIBBLE(x)   hex_value(x)
#define HEX(buffer)   ((NIBBLE ((buffer)[0]) << 4) + NIBBLE ((buffer)[1]))
#define ISHEX(x)   hex_p(x)
#define TOHEX(d, x)
#define MAXCHUNK   0xff
#define CHUNK   21
#define CHUNK_MASK   0x1fff
#define enda(x)   (x->vma + x->size)
#define tekhex_close_and_cleanup   _bfd_generic_close_and_cleanup
#define tekhex_bfd_free_cached_info   _bfd_generic_bfd_free_cached_info
#define tekhex_new_section_hook   _bfd_generic_new_section_hook
#define tekhex_bfd_is_target_special_symbol   ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
#define tekhex_bfd_is_local_label_name   bfd_generic_is_local_label_name
#define tekhex_get_lineno   _bfd_nosymbols_get_lineno
#define tekhex_find_nearest_line   _bfd_nosymbols_find_nearest_line
#define tekhex_find_inliner_info   _bfd_nosymbols_find_inliner_info
#define tekhex_bfd_make_debug_symbol   _bfd_nosymbols_bfd_make_debug_symbol
#define tekhex_read_minisymbols   _bfd_generic_read_minisymbols
#define tekhex_minisymbol_to_symbol   _bfd_generic_minisymbol_to_symbol
#define tekhex_bfd_get_relocated_section_contents   bfd_generic_get_relocated_section_contents
#define tekhex_bfd_relax_section   bfd_generic_relax_section
#define tekhex_bfd_gc_sections   bfd_generic_gc_sections
#define tekhex_bfd_merge_sections   bfd_generic_merge_sections
#define tekhex_bfd_is_group_section   bfd_generic_is_group_section
#define tekhex_bfd_discard_group   bfd_generic_discard_group
#define tekhex_section_already_linked   _bfd_generic_section_already_linked
#define tekhex_bfd_link_hash_table_create   _bfd_generic_link_hash_table_create
#define tekhex_bfd_link_hash_table_free   _bfd_generic_link_hash_table_free
#define tekhex_bfd_link_add_symbols   _bfd_generic_link_add_symbols
#define tekhex_bfd_link_just_syms   _bfd_generic_link_just_syms
#define tekhex_bfd_final_link   _bfd_generic_final_link
#define tekhex_bfd_link_split_section   _bfd_generic_link_split_section
#define tekhex_get_section_contents_in_window   _bfd_generic_get_section_contents_in_window

Typedefs

typedef struct tekhex_symbol_struct tekhex_symbol_type
typedef struct tekhex_data_list_struct
typedef struct tekhex_data_struct tdata_type

Functions

static void tekhex_init (void)
static bfd_boolean getvalue (char **srcp, bfd_vma *valuep)
static bfd_boolean getsym (char *dstp, char **srcp, unsigned int *lenp)
static struct data_structfind_chunk (bfd *abfd, bfd_vma vma)
static void insert_byte (bfd *abfd, int value, bfd_vma addr)
static bfd_boolean first_phase (bfd *abfd, int type, char *src)
static bfd_boolean pass_over (bfd *abfd, bfd_boolean(*func)(bfd *, int, char *))
static long tekhex_canonicalize_symtab (bfd *abfd, asymbol **table)
static long tekhex_get_symtab_upper_bound (bfd *abfd)
static bfd_boolean tekhex_mkobject (bfd *abfd)
static const bfd_targettekhex_object_p (bfd *abfd)
static void move_section_contents (bfd *abfd, asection *section, const void *locationp, file_ptr offset, bfd_size_type count, bfd_boolean get)
static bfd_boolean tekhex_get_section_contents (bfd *abfd, asection *section, void *locationp, file_ptr offset, bfd_size_type count)
static bfd_boolean tekhex_set_arch_mach (bfd *abfd, enum bfd_architecture arch, unsigned long machine)
static bfd_boolean tekhex_set_section_contents (bfd *abfd, sec_ptr section, const void *locationp, file_ptr offset, bfd_size_type bytes_to_do)
static void writevalue (char **dst, bfd_vma value)
static void writesym (char **dst, const char *sym)
static void out (bfd *abfd, int type, char *start, char *end)
static bfd_boolean tekhex_write_object_contents (bfd *abfd)
static int tekhex_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info ATTRIBUTE_UNUSED)
static asymboltekhex_make_empty_symbol (bfd *abfd)
static void tekhex_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED, asymbol *symbol, symbol_info *ret)
static void tekhex_print_symbol (bfd *abfd, void *filep, asymbol *symbol, bfd_print_symbol_type how)

Variables

static const char digs [] = "0123456789ABCDEF"
static char sum_block [256]
const bfd_target tekhex_vec

Class Documentation

struct addr_range_type

Definition at line 73 of file tekhex.c.

Class Members
bfd_vma high
bfd_vma low
struct tekhex_symbol_struct

Definition at line 79 of file tekhex.c.

Collaboration diagram for tekhex_symbol_struct:
Class Members
struct tekhex_symbol_struct * prev
asymbol symbol
struct tekhex_data_list_struct

Definition at line 237 of file tekhex.c.

Collaboration diagram for tekhex_data_list_struct:
Class Members
unsigned char * data
struct tekhex_data_list_struct * next
bfd_size_type size
bfd_vma where
struct data_struct

Definition at line 249 of file tekhex.c.

Collaboration diagram for data_struct:
Class Members
char chunk_data
char chunk_init
struct data_struct * next
bfd_vma vma
struct tekhex_data_struct

Definition at line 257 of file tekhex.c.

Collaboration diagram for tekhex_data_struct:
Class Members
struct data_struct * data
tekhex_data_list_type * head
struct tekhex_symbol_struct * symbols
unsigned int type

Define Documentation

#define CHUNK   21

Definition at line 232 of file tekhex.c.

#define CHUNK_MASK   0x1fff

Definition at line 247 of file tekhex.c.

#define enda (   x)    (x->vma + x->size)

Definition at line 265 of file tekhex.c.

#define HEX (   buffer)    ((NIBBLE ((buffer)[0]) << 4) + NIBBLE ((buffer)[1]))

Definition at line 91 of file tekhex.c.

#define ISHEX (   x)    hex_p(x)

Definition at line 92 of file tekhex.c.

#define MAXCHUNK   0xff

Definition at line 230 of file tekhex.c.

#define NIBBLE (   x)    hex_value(x)

Definition at line 90 of file tekhex.c.

#define NOT_HEX   20

Definition at line 89 of file tekhex.c.

Definition at line 940 of file tekhex.c.

Definition at line 946 of file tekhex.c.

Definition at line 925 of file tekhex.c.

Definition at line 937 of file tekhex.c.

Definition at line 935 of file tekhex.c.

Definition at line 939 of file tekhex.c.

Definition at line 928 of file tekhex.c.

Definition at line 927 of file tekhex.c.

Definition at line 944 of file tekhex.c.

Definition at line 942 of file tekhex.c.

Definition at line 943 of file tekhex.c.

Definition at line 945 of file tekhex.c.

Definition at line 947 of file tekhex.c.

Definition at line 932 of file tekhex.c.

Definition at line 938 of file tekhex.c.

Definition at line 936 of file tekhex.c.

Definition at line 924 of file tekhex.c.

Definition at line 931 of file tekhex.c.

Definition at line 930 of file tekhex.c.

Definition at line 929 of file tekhex.c.

Definition at line 948 of file tekhex.c.

Definition at line 934 of file tekhex.c.

Definition at line 926 of file tekhex.c.

Definition at line 933 of file tekhex.c.

Definition at line 941 of file tekhex.c.

#define TOHEX (   d,
  x 
)
Value:
(d)[1] = digs[(x) & 0xf]; \
  (d)[0] = digs[((x)>>4)&0xf];

Definition at line 93 of file tekhex.c.


Typedef Documentation

Definition at line 245 of file tekhex.c.


Function Documentation

static struct data_struct* find_chunk ( bfd abfd,
bfd_vma  vma 
) [static, read]

Definition at line 314 of file tekhex.c.

{
  struct data_struct *d = abfd->tdata.tekhex_data->data;

  vma &= ~CHUNK_MASK;
  while (d && (d->vma) != vma)
    d = d->next;

  if (!d)
    {
      /* No chunk for this address, so make one up.  */
      d = bfd_zalloc (abfd, (bfd_size_type) sizeof (struct data_struct));

      if (!d)
       return NULL;

      d->next = abfd->tdata.tekhex_data->data;
      d->vma = vma;
      abfd->tdata.tekhex_data->data = d;
    }
  return d;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean first_phase ( bfd abfd,
int  type,
char *  src 
) [static]

Definition at line 351 of file tekhex.c.

{
  asection *section = bfd_abs_section_ptr;
  unsigned int len;
  bfd_vma val;
  char sym[17];                    /* A symbol can only be 16chars long.  */

  switch (type)
    {
    case '6':
      /* Data record - read it and store it.  */
      {
       bfd_vma addr;

       if (!getvalue (&src, &addr))
         return FALSE;

       while (*src)
         {
           insert_byte (abfd, HEX (src), addr);
           src += 2;
           addr++;
         }
      }

      return TRUE;
    case '3':
      /* Symbol record, read the segment.  */
      if (!getsym (sym, &src, &len))
       return FALSE;
      section = bfd_get_section_by_name (abfd, sym);
      if (section == NULL)
       {
         char *n = bfd_alloc (abfd, (bfd_size_type) len + 1);

         if (!n)
           return FALSE;
         memcpy (n, sym, len + 1);
         section = bfd_make_section (abfd, n);
       }
      while (*src)
       {
         switch (*src)
           {
           case '1':        /* Section range.  */
             src++;
             if (!getvalue (&src, &section->vma))
              return FALSE;
             if (!getvalue (&src, &val))
              return FALSE;
             section->size = val - section->vma;
             section->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
             break;
           case '0':
           case '2':
           case '3':
           case '4':
           case '6':
           case '7':
           case '8':
             /* Symbols, add to section.  */
             {
              bfd_size_type amt = sizeof (tekhex_symbol_type);
              tekhex_symbol_type *new = bfd_alloc (abfd, amt);
              char stype = (*src);

              if (!new)
                return FALSE;
              new->symbol.the_bfd = abfd;
              src++;
              abfd->symcount++;
              abfd->flags |= HAS_SYMS;
              new->prev = abfd->tdata.tekhex_data->symbols;
              abfd->tdata.tekhex_data->symbols = new;
              if (!getsym (sym, &src, &len))
                return FALSE;
              new->symbol.name = bfd_alloc (abfd, (bfd_size_type) len + 1);
              if (!new->symbol.name)
                return FALSE;
              memcpy ((char *) (new->symbol.name), sym, len + 1);
              new->symbol.section = section;
              if (stype <= '4')
                new->symbol.flags = (BSF_GLOBAL | BSF_EXPORT);
              else
                new->symbol.flags = BSF_LOCAL;
              if (!getvalue (&src, &val))
                return FALSE;
              new->symbol.value = val - section->vma;
              break;
             }
           default:
             return FALSE;
           }
       }
    }

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean getsym ( char *  dstp,
char **  srcp,
unsigned int lenp 
) [static]

Definition at line 293 of file tekhex.c.

{
  char *src = *srcp;
  unsigned int i;
  unsigned int len;
  
  if (!ISHEX (*src))
    return FALSE;

  len = hex_value (*src++);
  if (len == 0)
    len = 16;
  for (i = 0; i < len; i++)
    dstp[i] = src[i];
  dstp[i] = 0;
  *srcp = src + i;
  *lenp = len;
  return TRUE;
}

Here is the caller graph for this function:

static bfd_boolean getvalue ( char **  srcp,
bfd_vma valuep 
) [static]

Definition at line 268 of file tekhex.c.

{
  char *src = *srcp;
  bfd_vma value = 0;
  unsigned int len;

  if (!ISHEX (*src))
    return FALSE;

  len = hex_value (*src++);
  if (len == 0)
    len = 16;
  while (len--)
    {
      if (!ISHEX (*src))
       return FALSE;
      value = value << 4 | hex_value (*src++);
    }

  *srcp = src;
  *valuep = value;
  return TRUE;
}

Here is the caller graph for this function:

static void insert_byte ( bfd abfd,
int  value,
bfd_vma  addr 
) [static]

Definition at line 338 of file tekhex.c.

{
  /* Find the chunk that this byte needs and put it in.  */
  struct data_struct *d = find_chunk (abfd, addr);

  d->chunk_data[addr & CHUNK_MASK] = value;
  d->chunk_init[addr & CHUNK_MASK] = 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void move_section_contents ( bfd abfd,
asection section,
const void *  locationp,
file_ptr  offset,
bfd_size_type  count,
bfd_boolean  get 
) [static]

Definition at line 568 of file tekhex.c.

{
  bfd_vma addr;
  char *location = (char *) locationp;
  bfd_vma prev_number = 1;  /* Nothing can have this as a high bit.  */
  struct data_struct *d = NULL;

  BFD_ASSERT (offset == 0);
  for (addr = section->vma; count != 0; count--, addr++)
    {
      /* Get high bits of address.  */
      bfd_vma chunk_number = addr & ~(bfd_vma) CHUNK_MASK;
      bfd_vma low_bits = addr & CHUNK_MASK;

      if (chunk_number != prev_number)
       /* Different chunk, so move pointer. */
       d = find_chunk (abfd, chunk_number);

      if (get)
       {
         if (d->chunk_init[low_bits])
           *location = d->chunk_data[low_bits];
         else
           *location = 0;
       }
      else
       {
         d->chunk_data[low_bits] = *location;
         d->chunk_init[low_bits] = (*location != 0);
       }

      location++;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void out ( bfd abfd,
int  type,
char *  start,
char *  end 
) [static]

Definition at line 727 of file tekhex.c.

{
  int sum = 0;
  char *s;
  char front[6];
  bfd_size_type wrlen;

  front[0] = '%';
  TOHEX (front + 1, end - start + 5);
  front[3] = type;

  for (s = start; s < end; s++)
    sum += sum_block[(unsigned char) *s];

  sum += sum_block[(unsigned char) front[1]];    /* Length.  */
  sum += sum_block[(unsigned char) front[2]];
  sum += sum_block[(unsigned char) front[3]];    /* Type.  */
  TOHEX (front + 4, sum);
  if (bfd_bwrite (front, (bfd_size_type) 6, abfd) != 6)
    abort ();
  end[0] = '\n';
  wrlen = end - start + 1;
  if (bfd_bwrite (start, wrlen, abfd) != wrlen)
    abort ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean pass_over ( bfd abfd,
bfd_boolean(*)(bfd *, int, char *)  func 
) [static]

Definition at line 454 of file tekhex.c.

{
  unsigned int chars_on_line;
  bfd_boolean eof = FALSE;

  /* To the front of the file.  */
  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
    return FALSE;
  while (! eof)
    {
      char src[MAXCHUNK];
      char type;

      /* Find first '%'.  */
      eof = (bfd_boolean) (bfd_bread (src, (bfd_size_type) 1, abfd) != 1);
      while (*src != '%' && !eof)
       eof = (bfd_boolean) (bfd_bread (src, (bfd_size_type) 1, abfd) != 1);

      if (eof)
       break;

      /* Fetch the type and the length and the checksum.  */
      if (bfd_bread (src, (bfd_size_type) 5, abfd) != 5)
       return FALSE;

      type = src[2];

      if (!ISHEX (src[0]) || !ISHEX (src[1]))
       break;

      /* Already read five chars.  */
      chars_on_line = HEX (src) - 5;

      if (chars_on_line >= MAXCHUNK)
       return FALSE;

      if (bfd_bread (src, (bfd_size_type) chars_on_line, abfd) != chars_on_line)
       return FALSE;

      /* Put a null at the end.  */
      src[chars_on_line] = 0;

      if (!func (abfd, type, src))
       return FALSE;
    }

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static long tekhex_canonicalize_symtab ( bfd abfd,
asymbol **  table 
) [static]

Definition at line 504 of file tekhex.c.

{
  tekhex_symbol_type *p = abfd->tdata.tekhex_data->symbols;
  unsigned int c = bfd_get_symcount (abfd);

  table[c] = 0;
  while (p)
    {
      table[--c] = &(p->symbol);
      p = p->prev;
    }

  return bfd_get_symcount (abfd);
}

Here is the call graph for this function:

static bfd_boolean tekhex_get_section_contents ( bfd abfd,
asection section,
void *  locationp,
file_ptr  offset,
bfd_size_type  count 
) [static]

Definition at line 609 of file tekhex.c.

{
  if (section->flags & (SEC_LOAD | SEC_ALLOC))
    {
      move_section_contents (abfd, section, locationp, offset, count, TRUE);
      return TRUE;
    }

  return FALSE;
}

Here is the call graph for this function:

static void tekhex_get_symbol_info ( bfd *abfd  ATTRIBUTE_UNUSED,
asymbol symbol,
symbol_info ret 
) [static]

Definition at line 889 of file tekhex.c.

{
  bfd_symbol_info (symbol, ret);
}

Here is the call graph for this function:

static long tekhex_get_symtab_upper_bound ( bfd abfd) [static]

Definition at line 520 of file tekhex.c.

{
  return (abfd->symcount + 1) * (sizeof (struct tekhex_asymbol_struct *));

}
static void tekhex_init ( void  ) [static]

Definition at line 203 of file tekhex.c.

{
  unsigned int i;
  static bfd_boolean inited = FALSE;
  int val;

  if (! inited)
    {
      inited = TRUE;
      hex_init ();
      val = 0;
      for (i = 0; i < 10; i++)
       sum_block[i + '0'] = val++;

      for (i = 'A'; i <= 'Z'; i++)
       sum_block[i] = val++;

      sum_block['$'] = val++;
      sum_block['%'] = val++;
      sum_block['.'] = val++;
      sum_block['_'] = val++;
      for (i = 'a'; i <= 'z'; i++)
       sum_block[i] = val++;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static asymbol* tekhex_make_empty_symbol ( bfd abfd) [static]

Definition at line 876 of file tekhex.c.

{
  bfd_size_type amt = sizeof (struct tekhex_symbol_struct);
  tekhex_symbol_type *new = bfd_zalloc (abfd, amt);

  if (!new)
    return NULL;
  new->symbol.the_bfd = abfd;
  new->prev =  NULL;
  return &(new->symbol);
}

Here is the call graph for this function:

static bfd_boolean tekhex_mkobject ( bfd abfd) [static]

Definition at line 527 of file tekhex.c.

{
  tdata_type *tdata;

  tdata = bfd_alloc (abfd, (bfd_size_type) sizeof (tdata_type));
  if (!tdata)
    return FALSE;
  abfd->tdata.tekhex_data = tdata;
  tdata->type = 1;
  tdata->head =  NULL;
  tdata->symbols = NULL;
  tdata->data = NULL;
  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static const bfd_target* tekhex_object_p ( bfd abfd) [static]

Definition at line 546 of file tekhex.c.

{
  char b[4];

  tekhex_init ();

  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
      || bfd_bread (b, (bfd_size_type) 4, abfd) != 4)
    return NULL;

  if (b[0] != '%' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3]))
    return NULL;

  tekhex_mkobject (abfd);

  if (!pass_over (abfd, first_phase))
    return NULL;

  return abfd->xvec;
}

Here is the call graph for this function:

static void tekhex_print_symbol ( bfd abfd,
void *  filep,
asymbol symbol,
bfd_print_symbol_type  how 
) [static]

Definition at line 897 of file tekhex.c.

{
  FILE *file = (FILE *) filep;

  switch (how)
    {
    case bfd_print_symbol_name:
      fprintf (file, "%s", symbol->name);
      break;
    case bfd_print_symbol_more:
      break;

    case bfd_print_symbol_all:
      {
       const char *section_name = symbol->section->name;

       bfd_print_symbol_vandf (abfd, (void *) file, symbol);

       fprintf (file, " %-5s %s",
               section_name, symbol->name);
      }
    }
}

Here is the call graph for this function:

static bfd_boolean tekhex_set_arch_mach ( bfd abfd,
enum bfd_architecture  arch,
unsigned long  machine 
) [static]

Definition at line 625 of file tekhex.c.

{
  return bfd_default_set_arch_mach (abfd, arch, machine);
}

Here is the call graph for this function:

static bfd_boolean tekhex_set_section_contents ( bfd abfd,
sec_ptr  section,
const void *  locationp,
file_ptr  offset,
bfd_size_type  bytes_to_do 
) [static]

Definition at line 635 of file tekhex.c.

{
  if (! abfd->output_has_begun)
    {
      /* The first time around, allocate enough sections to hold all the chunks.  */
      asection *s = abfd->sections;
      bfd_vma vma;

      for (s = abfd->sections; s; s = s->next)
       {
         if (s->flags & SEC_LOAD)
           {
             for (vma = s->vma & ~(bfd_vma) CHUNK_MASK;
                 vma < s->vma + s->size;
                 vma += CHUNK_MASK)
              find_chunk (abfd, vma);
           }
       }
    }

  if (section->flags & (SEC_LOAD | SEC_ALLOC))
    {
      move_section_contents (abfd, section, locationp, offset, bytes_to_do,
                          FALSE);
      return TRUE;
    }

  return FALSE;
}

Here is the call graph for this function:

static int tekhex_sizeof_headers ( bfd *abfd  ATTRIBUTE_UNUSED,
struct bfd_link_info *info  ATTRIBUTE_UNUSED 
) [static]

Definition at line 869 of file tekhex.c.

{
  return 0;
}
static bfd_boolean tekhex_write_object_contents ( bfd abfd) [static]

Definition at line 754 of file tekhex.c.

{
  char buffer[100];
  asymbol **p;
  asection *s;
  struct data_struct *d;

  tekhex_init ();

  /* And the raw data.  */
  for (d = abfd->tdata.tekhex_data->data;
       d != NULL;
       d = d->next)
    {
      int low;

      const int span = 32;
      int addr;

      /* Write it in blocks of 32 bytes.  */
      for (addr = 0; addr < CHUNK_MASK + 1; addr += span)
       {
         int need = 0;

         /* Check to see if necessary.  */
         for (low = 0; !need && low < span; low++)
           if (d->chunk_init[addr + low])
             need = 1;

         if (need)
           {
             char *dst = buffer;

             writevalue (&dst, addr + d->vma);
             for (low = 0; low < span; low++)
              {
                TOHEX (dst, d->chunk_data[addr + low]);
                dst += 2;
              }
             out (abfd, '6', buffer, dst);
           }
       }
    }

  /* Write all the section headers for the sections.  */
  for (s = abfd->sections; s != NULL; s = s->next)
    {
      char *dst = buffer;

      writesym (&dst, s->name);
      *dst++ = '1';
      writevalue (&dst, s->vma);
      writevalue (&dst, s->vma + s->size);
      out (abfd, '3', buffer, dst);
    }

  /* And the symbols.  */
  if (abfd->outsymbols)
    {
      for (p = abfd->outsymbols; *p; p++)
       {
         int section_code = bfd_decode_symclass (*p);

         if (section_code != '?')
           {
             /* Do not include debug symbols.  */
             asymbol *sym = *p;
             char *dst = buffer;

             writesym (&dst, sym->section->name);

             switch (section_code)
              {
              case 'A':
                *dst++ = '2';
                break;
              case 'a':
                *dst++ = '6';
                break;
              case 'D':
              case 'B':
              case 'O':
                *dst++ = '4';
                break;
              case 'd':
              case 'b':
              case 'o':
                *dst++ = '8';
                break;
              case 'T':
                *dst++ = '3';
                break;
              case 't':
                *dst++ = '7';
                break;
              case 'C':
              case 'U':
                bfd_set_error (bfd_error_wrong_format);
                return FALSE;
              }

             writesym (&dst, sym->name);
             writevalue (&dst, sym->value + sym->section->vma);
             out (abfd, '3', buffer, dst);
           }
       }
    }

  /* And the terminator.  */
  if (bfd_bwrite ("%0781010\n", (bfd_size_type) 9, abfd) != 9)
    abort ();
  return TRUE;
}

Here is the call graph for this function:

static void writesym ( char **  dst,
const char *  sym 
) [static]

Definition at line 698 of file tekhex.c.

{
  char *p = *dst;
  int len = (sym ? strlen (sym) : 0);

  if (len >= 16)
    {
      *p++ = '0';
      len = 16;
    }
  else
    {
      if (len == 0)
       {
         *p++ = '1';
         sym = "$";
         len = 1;
       }
      else
       *p++ = digs[len];
    }

  while (len--)
    *p++ = *sym++;

  *dst = p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void writevalue ( char **  dst,
bfd_vma  value 
) [static]

Definition at line 670 of file tekhex.c.

{
  char *p = *dst;
  int len;
  int shift;

  for (len = 8, shift = 28; shift; shift -= 4, len--)
    {
      if ((value >> shift) & 0xf)
       {
         *p++ = len + '0';
         while (len)
           {
             *p++ = digs[(value >> shift) & 0xf];
             shift -= 4;
             len--;
           }
         *dst = p;
         return;

       }
    }
  *p++ = '1';
  *p++ = '0';
  *dst = p;
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

const char digs[] = "0123456789ABCDEF" [static]

Definition at line 85 of file tekhex.c.

char sum_block[256] [static]

Definition at line 87 of file tekhex.c.

Definition at line 950 of file tekhex.c.