bfd/tekhex.c

   1 /* BFD backend for Extended Tektronix Hex Format  objects.
   2    Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002,
   3    2003, 2004 Free Software Foundation, Inc.
   4    Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
   5
   6    This file is part of BFD, the Binary File Descriptor library.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  21
  22 /* SUBSECTION
  23         Tektronix Hex Format handling
  24
  25    DESCRIPTION
  26
  27         Tek Hex records can hold symbols and data, but not
  28         relocations. Their main application is communication with
  29         devices like PROM programmers and ICE equipment.
  30
  31         It seems that the sections are described as being really big,
  32         the example I have says that the text section is 0..ffffffff.
  33         BFD would barf with this, many apps would try to alloc 4GB to
  34         read in the file.
  35
  36         Tex Hex may contain many sections, but the data which comes in
  37         has no tag saying which section it belongs to, so we create
  38         one section for each block of data, called "blknnnn" which we
  39         stick all the data into.
  40
  41         TekHex may come out of  order and there is no header, so an
  42         initial scan is required  to discover the minimum and maximum
  43         addresses used to create the vma and size of the sections we
  44         create.
  45         We read in the data into pages of CHUNK_MASK+1 size and read
  46         them out from that whenever we need to.
  47
  48         Any number of sections may be created for output, we save them
  49         up and output them when it's time to close the bfd.
  50
  51         A TekHex record looks like:
  52   EXAMPLE
  53         %<block length><type><checksum><stuff><cr>
  54
  55   DESCRIPTION
  56         Where
  57         o length
  58         is the number of bytes in the record not including the % sign.
  59         o type
  60         is one of:
  61         3) symbol record
  62         6) data record
  63         8) termination record
  64
  65   The data can come out of order, and may be discontigous. This is a
  66   serial protocol, so big files are unlikely, so we keep a list of 8k chunks.  */
  67
  68 #include "bfd.h"
  69 #include "sysdep.h"
  70 #include "libbfd.h"
  71 #include "libiberty.h"
  72
  73 typedef struct
  74 {
  75   bfd_vma low;
  76   bfd_vma high;
  77 } addr_range_type;
  78
  79 typedef struct tekhex_symbol_struct
  80 {
  81   asymbol symbol;
  82   struct tekhex_symbol_struct *prev;
  83 } tekhex_symbol_type;
  84
  85 static const char digs[] = "0123456789ABCDEF";
  86
  87 static char sum_block[256];
  88
  89 #define NOT_HEX      20
  90 #define NIBBLE(x)    hex_value(x)
  91 #define HEX(buffer) ((NIBBLE ((buffer)[0]) << 4) + NIBBLE ((buffer)[1]))
  92 #define ISHEX(x)    hex_p(x)
  93 #define TOHEX(d, x) \
  94   (d)[1] = digs[(x) & 0xf]; \
  95   (d)[0] = digs[((x)>>4)&0xf];
  96
  97 /* Here's an example
  98    %3A6C6480004E56FFFC4E717063B0AEFFFC6D0652AEFFFC60F24E5E4E75
  99    %1B3709T_SEGMENT1108FFFFFFFF
 100    %2B3AB9T_SEGMENT7Dgcc_compiled$1087hello$c10
 101    %373829T_SEGMENT80int$t1$r1$$214741080char$t2$r2$0$12710
 102    %373769T_SEGMENT80long$int$t3$r1$$1080unsigned$int$t4$10
 103    %373CA9T_SEGMENT80long$unsigned$in1080short$int$t6$r1$10
 104    %373049T_SEGMENT80long$long$int$t71080short$unsigned$i10
 105    %373A29T_SEGMENT80long$long$unsign1080signed$char$t10$10
 106    %373D69T_SEGMENT80unsigned$char$t11080float$t12$r1$4$010
 107    %373D19T_SEGMENT80double$t13$r1$8$1080long$double$t14$10
 108    %2734D9T_SEGMENT8Bvoid$t15$151035_main10
 109    %2F3CA9T_SEGMENT81$1081$1681$1E81$21487main$F110
 110    %2832F9T_SEGMENT83i$18FFFFFFFC81$1481$214
 111    %07 8 10 10
 112
 113    explanation:
 114    %3A6C6480004E56FFFC4E717063B0AEFFFC6D0652AEFFFC60F24E5E4E75
 115     ^ ^^ ^     ^-data
 116     | || +------ 4 char integer 0x8000
 117     | |+-------- checksum
 118     | +--------- type 6 (data record)
 119     +----------- length 3a chars
 120    <---------------------- 3a (58 chars) ------------------->
 121
 122    %1B3709T_SEGMENT1108FFFFFFFF
 123          ^         ^^ ^- 8 character integer 0xffffffff
 124          |         |+-   1 character integer 0
 125          |         +--   type 1 symbol (section definition)
 126          +------------   9 char symbol T_SEGMENT
 127
 128    %2B3AB9T_SEGMENT7Dgcc_compiled$1087hello$c10
 129    %373829T_SEGMENT80int$t1$r1$$214741080char$t2$r2$0$12710
 130    %373769T_SEGMENT80long$int$t3$r1$$1080unsigned$int$t4$10
 131    %373CA9T_SEGMENT80long$unsigned$in1080short$int$t6$r1$10
 132    %373049T_SEGMENT80long$long$int$t71080short$unsigned$i10
 133    %373A29T_SEGMENT80long$long$unsign1080signed$char$t10$10
 134    %373D69T_SEGMENT80unsigned$char$t11080float$t12$r1$4$010
 135    %373D19T_SEGMENT80double$t13$r1$8$1080long$double$t14$10
 136    %2734D9T_SEGMENT8Bvoid$t15$151035_main10
 137    %2F3CA9T_SEGMENT81$1081$1681$1E81$21487main$F110
 138    %2832F9T_SEGMENT83i$18FFFFFFFC81$1481$214
 139    %0781010
 140
 141    Turns into
 142    sac@thepub$ ./objdump -dx -m m68k f
 143
 144    f:     file format tekhex
 145    -----x--- 9/55728 -134219416 Sep 29 15:13 1995 f
 146    architecture: UNKNOWN!, flags 0x00000010:
 147    HAS_SYMS
 148    start address 0x00000000
 149    SECTION 0 [D00000000]        : size 00020000 vma 00000000 align 2**0
 150    ALLOC, LOAD
 151    SECTION 1 [D00008000]        : size 00002001 vma 00008000 align 2**0
 152
 153    SECTION 2 [T_SEGMENT]        : size ffffffff vma 00000000 align 2**0
 154
 155    SYMBOL TABLE:
 156    00000000  g       T_SEGMENT gcc_compiled$
 157    00000000  g       T_SEGMENT hello$c
 158    00000000  g       T_SEGMENT int$t1$r1$$21474
 159    00000000  g       T_SEGMENT char$t2$r2$0$127
 160    00000000  g       T_SEGMENT long$int$t3$r1$$
 161    00000000  g       T_SEGMENT unsigned$int$t4$
 162    00000000  g       T_SEGMENT long$unsigned$in
 163    00000000  g       T_SEGMENT short$int$t6$r1$
 164    00000000  g       T_SEGMENT long$long$int$t7
 165    00000000  g       T_SEGMENT short$unsigned$i
 166    00000000  g       T_SEGMENT long$long$unsign
 167    00000000  g       T_SEGMENT signed$char$t10$
 168    00000000  g       T_SEGMENT unsigned$char$t1
 169    00000000  g       T_SEGMENT float$t12$r1$4$0
 170    00000000  g       T_SEGMENT double$t13$r1$8$
 171    00000000  g       T_SEGMENT long$double$t14$
 172    00000000  g       T_SEGMENT void$t15$15
 173    00000000  g       T_SEGMENT _main
 174    00000000  g       T_SEGMENT $
 175    00000000  g       T_SEGMENT $
 176    00000000  g       T_SEGMENT $
 177    00000010  g       T_SEGMENT $
 178    00000000  g       T_SEGMENT main$F1
 179    fcffffff  g       T_SEGMENT i$1
 180    00000000  g       T_SEGMENT $
 181    00000010  g       T_SEGMENT $
 182
 183    RELOCATION RECORDS FOR [D00000000]: (none)
 184
 185    RELOCATION RECORDS FOR [D00008000]: (none)
 186
 187    RELOCATION RECORDS FOR [T_SEGMENT]: (none)
 188
 189    Disassembly of section D00000000:
 190    ...
 191    00008000 ($+)7ff0 linkw fp,#-4
 192    00008004 ($+)7ff4 nop
 193    00008006 ($+)7ff6 movel #99,d0
 194    00008008 ($+)7ff8 cmpl fp@(-4),d0
 195    0000800c ($+)7ffc blts 00008014 ($+)8004
 196    0000800e ($+)7ffe addql #1,fp@(-4)
 197    00008012 ($+)8002 bras 00008006 ($+)7ff6
 198    00008014 ($+)8004 unlk fp
 199    00008016 ($+)8006 rts
 200    ...  */
 201
 202 static void
 203 tekhex_init (void)
 204 {
 205   unsigned int i;
 206   static bfd_boolean inited = FALSE;
 207   int val;
 208
 209   if (! inited)
 210     {
 211       inited = TRUE;
 212       hex_init ();
 213       val = 0;
 214       for (i = 0; i < 10; i++)
 215         sum_block[i + '0'] = val++;
 216
 217       for (i = 'A'; i <= 'Z'; i++)
 218         sum_block[i] = val++;
 219
 220       sum_block['$'] = val++;
 221       sum_block['%'] = val++;
 222       sum_block['.'] = val++;
 223       sum_block['_'] = val++;
 224       for (i = 'a'; i <= 'z'; i++)
 225         sum_block[i] = val++;
 226     }
 227 }
 228
 229 /* The maximum number of bytes on a line is FF.  */
 230 #define MAXCHUNK 0xff
 231 /* The number of bytes we fit onto a line on output.  */
 232 #define CHUNK 21
 233
 234 /* We cannot output our tekhexords as we see them, we have to glue them
 235    together, this is done in this structure : */
 236
 237 struct tekhex_data_list_struct
 238 {
 239   unsigned char *data;
 240   bfd_vma where;
 241   bfd_size_type size;
 242   struct tekhex_data_list_struct *next;
 243
 244 };
 245 typedef struct tekhex_data_list_struct tekhex_data_list_type;
 246
 247 #define CHUNK_MASK 0x1fff
 248
 249 struct data_struct
 250 {
 251   char chunk_data[CHUNK_MASK + 1];
 252   char chunk_init[CHUNK_MASK + 1];
 253   bfd_vma vma;
 254   struct data_struct *next;
 255 };
 256
 257 typedef struct tekhex_data_struct
 258 {
 259   tekhex_data_list_type *head;
 260   unsigned int type;
 261   struct tekhex_symbol_struct *symbols;
 262   struct data_struct *data;
 263 } tdata_type;
 264
 265 #define enda(x) (x->vma + x->size)
 266
 267 static bfd_boolean
 268 getvalue (char **srcp, bfd_vma *valuep)
 269 {
 270   char *src = *srcp;
 271   bfd_vma value = 0;
 272   unsigned int len;
 273
 274   if (!ISHEX (*src))
 275     return FALSE;
 276
 277   len = hex_value (*src++);
 278   if (len == 0)
 279     len = 16;
 280   while (len--)
 281     {
 282       if (!ISHEX (*src))
 283         return FALSE;
 284       value = value << 4 | hex_value (*src++);
 285     }
 286
 287   *srcp = src;
 288   *valuep = value;
 289   return TRUE;
 290 }
 291
 292 static bfd_boolean
 293 getsym (char *dstp, char **srcp, unsigned int *lenp)
 294 {
 295   char *src = *srcp;
 296   unsigned int i;
 297   unsigned int len;
 298
 299   if (!ISHEX (*src))
 300     return FALSE;
 301
 302   len = hex_value (*src++);
 303   if (len == 0)
 304     len = 16;
 305   for (i = 0; i < len; i++)
 306     dstp[i] = src[i];
 307   dstp[i] = 0;
 308   *srcp = src + i;
 309   *lenp = len;
 310   return TRUE;
 311 }
 312
 313 static struct data_struct *
 314 find_chunk (bfd *abfd, bfd_vma vma)
 315 {
 316   struct data_struct *d = abfd->tdata.tekhex_data->data;
 317
 318   vma &= ~CHUNK_MASK;
 319   while (d && (d->vma) != vma)
 320     d = d->next;
 321
 322   if (!d)
 323     {
 324       /* No chunk for this address, so make one up.  */
 325       d = bfd_zalloc (abfd, (bfd_size_type) sizeof (struct data_struct));
 326
 327       if (!d)
 328         return NULL;
 329
 330       d->next = abfd->tdata.tekhex_data->data;
 331       d->vma = vma;
 332       abfd->tdata.tekhex_data->data = d;
 333     }
 334   return d;
 335 }
 336
 337 static void
 338 insert_byte (bfd *abfd, int value, bfd_vma addr)
 339 {
 340   /* Find the chunk that this byte needs and put it in.  */
 341   struct data_struct *d = find_chunk (abfd, addr);
 342
 343   d->chunk_data[addr & CHUNK_MASK] = value;
 344   d->chunk_init[addr & CHUNK_MASK] = 1;
 345 }
 346
 347 /* The first pass is to find the names of all the sections, and see
 348   how big the data is.  */
 349
 350 static bfd_boolean
 351 first_phase (bfd *abfd, int type, char *src)
 352 {
 353   asection *section = bfd_abs_section_ptr;
 354   unsigned int len;
 355   bfd_vma val;
 356   char sym[17];                 /* A symbol can only be 16chars long.  */
 357
 358   switch (type)
 359     {
 360     case '6':
 361       /* Data record - read it and store it.  */
 362       {
 363         bfd_vma addr;
 364
 365         if (!getvalue (&src, &addr))
 366           return FALSE;
 367
 368         while (*src)
 369           {
 370             insert_byte (abfd, HEX (src), addr);
 371             src += 2;
 372             addr++;
 373           }
 374       }
 375
 376       return TRUE;
 377     case '3':
 378       /* Symbol record, read the segment.  */
 379       if (!getsym (sym, &src, &len))
 380         return FALSE;
 381       section = bfd_get_section_by_name (abfd, sym);
 382       if (section == NULL)
 383         {
 384           char *n = bfd_alloc (abfd, (bfd_size_type) len + 1);
 385
 386           if (!n)
 387             return FALSE;
 388           memcpy (n, sym, len + 1);
 389           section = bfd_make_section (abfd, n);
 390         }
 391       while (*src)
 392         {
 393           switch (*src)
 394             {
 395             case '1':           /* Section range.  */
 396               src++;
 397               if (!getvalue (&src, &section->vma))
 398                 return FALSE;
 399               if (!getvalue (&src, &val))
 400                 return FALSE;
 401               section->size = val - section->vma;
 402               section->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC;
 403               break;
 404             case '0':
 405             case '2':
 406             case '3':
 407             case '4':
 408             case '6':
 409             case '7':
 410             case '8':
 411               /* Symbols, add to section.  */
 412               {
 413                 bfd_size_type amt = sizeof (tekhex_symbol_type);
 414                 tekhex_symbol_type *new = bfd_alloc (abfd, amt);
 415                 char stype = (*src);
 416
 417                 if (!new)
 418                   return FALSE;
 419                 new->symbol.the_bfd = abfd;
 420                 src++;
 421                 abfd->symcount++;
 422                 abfd->flags |= HAS_SYMS;
 423                 new->prev = abfd->tdata.tekhex_data->symbols;
 424                 abfd->tdata.tekhex_data->symbols = new;
 425                 if (!getsym (sym, &src, &len))
 426                   return FALSE;
 427                 new->symbol.name = bfd_alloc (abfd, (bfd_size_type) len + 1);
 428                 if (!new->symbol.name)
 429                   return FALSE;
 430                 memcpy ((char *) (new->symbol.name), sym, len + 1);
 431                 new->symbol.section = section;
 432                 if (stype <= '4')
 433                   new->symbol.flags = (BSF_GLOBAL | BSF_EXPORT);
 434                 else
 435                   new->symbol.flags = BSF_LOCAL;
 436                 if (!getvalue (&src, &val))
 437                   return FALSE;
 438                 new->symbol.value = val - section->vma;
 439               }
 440             default:
 441               return FALSE;
 442             }
 443         }
 444     }
 445
 446   return TRUE;
 447 }
 448
 449 /* Pass over a tekhex, calling one of the above functions on each
 450    record.  */
 451
 452 static bfd_boolean
 453 pass_over (bfd *abfd, bfd_boolean (*func) (bfd *, int, char *))
 454 {
 455   unsigned int chars_on_line;
 456   bfd_boolean eof = FALSE;
 457
 458   /* To the front of the file.  */
 459   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
 460     abort ();
 461   while (! eof)
 462     {
 463       char buffer[MAXCHUNK];
 464       char *src = buffer;
 465       char type;
 466
 467       /* Find first '%'.  */
 468       eof = (bfd_boolean) (bfd_bread (src, (bfd_size_type) 1, abfd) != 1);
 469       while (*src != '%' && !eof)
 470         eof = (bfd_boolean) (bfd_bread (src, (bfd_size_type) 1, abfd) != 1);
 471
 472       if (eof)
 473         break;
 474       src++;
 475
 476       /* Fetch the type and the length and the checksum.  */
 477       if (bfd_bread (src, (bfd_size_type) 5, abfd) != 5)
 478         abort (); /* FIXME.  */
 479
 480       type = src[2];
 481
 482       if (!ISHEX (src[0]) || !ISHEX (src[1]))
 483         break;
 484
 485       /* Already read five char.  */
 486       chars_on_line = HEX (src) - 5;
 487
 488       if (bfd_bread (src, (bfd_size_type) chars_on_line, abfd) != chars_on_line)
 489         abort (); /* FIXME.  */
 490
 491       /* Put a null at the end.  */
 492       src[chars_on_line] = 0;
 493
 494       if (!func (abfd, type, src))
 495         return FALSE;
 496     }
 497
 498   return TRUE;
 499 }
 500
 501 static long
 502 tekhex_canonicalize_symtab (bfd *abfd, asymbol **table)
 503 {
 504   tekhex_symbol_type *p = abfd->tdata.tekhex_data->symbols;
 505   unsigned int c = bfd_get_symcount (abfd);
 506
 507   table[c] = 0;
 508   while (p)
 509     {
 510       table[--c] = &(p->symbol);
 511       p = p->prev;
 512     }
 513
 514   return bfd_get_symcount (abfd);
 515 }
 516
 517 static long
 518 tekhex_get_symtab_upper_bound (bfd *abfd)
 519 {
 520   return (abfd->symcount + 1) * (sizeof (struct tekhex_asymbol_struct *));
 521
 522 }
 523
 524 static bfd_boolean
 525 tekhex_mkobject (bfd *abfd)
 526 {
 527   tdata_type *tdata;
 528
 529   tdata = bfd_alloc (abfd, (bfd_size_type) sizeof (tdata_type));
 530   if (!tdata)
 531     return FALSE;
 532   abfd->tdata.tekhex_data = tdata;
 533   tdata->type = 1;
 534   tdata->head =  NULL;
 535   tdata->symbols = NULL;
 536   tdata->data = NULL;
 537   return TRUE;
 538 }
 539
 540 /* Return TRUE if the file looks like it's in TekHex format. Just look
 541    for a percent sign and some hex digits.  */
 542
 543 static const bfd_target *
 544 tekhex_object_p (bfd *abfd)
 545 {
 546   char b[4];
 547
 548   tekhex_init ();
 549
 550   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
 551       || bfd_bread (b, (bfd_size_type) 4, abfd) != 4)
 552     return NULL;
 553
 554   if (b[0] != '%' || !ISHEX (b[1]) || !ISHEX (b[2]) || !ISHEX (b[3]))
 555     return NULL;
 556
 557   tekhex_mkobject (abfd);
 558
 559   if (!pass_over (abfd, first_phase))
 560     return NULL;
 561
 562   return abfd->xvec;
 563 }
 564
 565 static void
 566 move_section_contents (bfd *abfd,
 567                        asection *section,
 568                        const void * locationp,
 569                        file_ptr offset,
 570                        bfd_size_type count,
 571                        bfd_boolean get)
 572 {
 573   bfd_vma addr;
 574   char *location = (char *) locationp;
 575   bfd_vma prev_number = 1;      /* Nothing can have this as a high bit.  */
 576   struct data_struct *d = NULL;
 577
 578   BFD_ASSERT (offset == 0);
 579   for (addr = section->vma; count != 0; count--, addr++)
 580     {
 581       /* Get high bits of address.  */
 582       bfd_vma chunk_number = addr & ~(bfd_vma) CHUNK_MASK;
 583       bfd_vma low_bits = addr & CHUNK_MASK;
 584
 585       if (chunk_number != prev_number)
 586         /* Different chunk, so move pointer. */
 587         d = find_chunk (abfd, chunk_number);
 588
 589       if (get)
 590         {
 591           if (d->chunk_init[low_bits])
 592             *location = d->chunk_data[low_bits];
 593           else
 594             *location = 0;
 595         }
 596       else
 597         {
 598           d->chunk_data[low_bits] = *location;
 599           d->chunk_init[low_bits] = (*location != 0);
 600         }
 601
 602       location++;
 603     }
 604 }
 605
 606 static bfd_boolean
 607 tekhex_get_section_contents (bfd *abfd,
 608                              asection *section,
 609                              void * locationp,
 610                              file_ptr offset,
 611                              bfd_size_type count)
 612 {
 613   if (section->flags & (SEC_LOAD | SEC_ALLOC))
 614     {
 615       move_section_contents (abfd, section, locationp, offset, count, TRUE);
 616       return TRUE;
 617     }
 618
 619   return FALSE;
 620 }
 621
 622 static bfd_boolean
 623 tekhex_set_arch_mach (bfd *abfd,
 624                       enum bfd_architecture arch,
 625                       unsigned long machine)
 626 {
 627   return bfd_default_set_arch_mach (abfd, arch, machine);
 628 }
 629
 630 /* We have to save up all the Tekhexords for a splurge before output.  */
 631
 632 static bfd_boolean
 633 tekhex_set_section_contents (bfd *abfd,
 634                              sec_ptr section,
 635                              const void * locationp,
 636                              file_ptr offset,
 637                              bfd_size_type bytes_to_do)
 638 {
 639   if (! abfd->output_has_begun)
 640     {
 641       /* The first time around, allocate enough sections to hold all the chunks.  */
 642       asection *s = abfd->sections;
 643       bfd_vma vma;
 644
 645       for (s = abfd->sections; s; s = s->next)
 646         {
 647           if (s->flags & SEC_LOAD)
 648             {
 649               for (vma = s->vma & ~(bfd_vma) CHUNK_MASK;
 650                    vma < s->vma + s->size;
 651                    vma += CHUNK_MASK)
 652                 find_chunk (abfd, vma);
 653             }
 654         }
 655     }
 656
 657   if (section->flags & (SEC_LOAD | SEC_ALLOC))
 658     {
 659       move_section_contents (abfd, section, locationp, offset, bytes_to_do,
 660                              FALSE);
 661       return TRUE;
 662     }
 663
 664   return FALSE;
 665 }
 666
 667 static void
 668 writevalue (char **dst, bfd_vma value)
 669 {
 670   char *p = *dst;
 671   int len;
 672   int shift;
 673
 674   for (len = 8, shift = 28; shift; shift -= 4, len--)
 675     {
 676       if ((value >> shift) & 0xf)
 677         {
 678           *p++ = len + '0';
 679           while (len)
 680             {
 681               *p++ = digs[(value >> shift) & 0xf];
 682               shift -= 4;
 683               len--;
 684             }
 685           *dst = p;
 686           return;
 687
 688         }
 689     }
 690   *p++ = '1';
 691   *p++ = '0';
 692   *dst = p;
 693 }
 694
 695 static void
 696 writesym (char **dst, const char *sym)
 697 {
 698   char *p = *dst;
 699   int len = (sym ? strlen (sym) : 0);
 700
 701   if (len >= 16)
 702     {
 703       *p++ = '0';
 704       len = 16;
 705     }
 706   else
 707     {
 708       if (len == 0)
 709         {
 710           *p++ = '1';
 711           sym = "$";
 712           len = 1;
 713         }
 714       else
 715         *p++ = digs[len];
 716     }
 717
 718   while (len--)
 719     *p++ = *sym++;
 720
 721   *dst = p;
 722 }
 723
 724 static void
 725 out (bfd *abfd, int type, char *start, char *end)
 726 {
 727   int sum = 0;
 728   char *s;
 729   char front[6];
 730   bfd_size_type wrlen;
 731
 732   front[0] = '%';
 733   TOHEX (front + 1, end - start + 5);
 734   front[3] = type;
 735
 736   for (s = start; s < end; s++)
 737     sum += sum_block[(unsigned char) *s];
 738
 739   sum += sum_block[(unsigned char) front[1]];   /* Length.  */
 740   sum += sum_block[(unsigned char) front[2]];
 741   sum += sum_block[(unsigned char) front[3]];   /* Type.  */
 742   TOHEX (front + 4, sum);
 743   if (bfd_bwrite (front, (bfd_size_type) 6, abfd) != 6)
 744     abort ();
 745   end[0] = '\n';
 746   wrlen = end - start + 1;
 747   if (bfd_bwrite (start, wrlen, abfd) != wrlen)
 748     abort ();
 749 }
 750
 751 static bfd_boolean
 752 tekhex_write_object_contents (bfd *abfd)
 753 {
 754   char buffer[100];
 755   asymbol **p;
 756   asection *s;
 757   struct data_struct *d;
 758
 759   tekhex_init ();
 760
 761   /* And the raw data.  */
 762   for (d = abfd->tdata.tekhex_data->data;
 763        d != NULL;
 764        d = d->next)
 765     {
 766       int low;
 767
 768       const int span = 32;
 769       int addr;
 770
 771       /* Write it in blocks of 32 bytes.  */
 772       for (addr = 0; addr < CHUNK_MASK + 1; addr += span)
 773         {
 774           int need = 0;
 775
 776           /* Check to see if necessary.  */
 777           for (low = 0; !need && low < span; low++)
 778             if (d->chunk_init[addr + low])
 779               need = 1;
 780
 781           if (need)
 782             {
 783               char *dst = buffer;
 784
 785               writevalue (&dst, addr + d->vma);
 786               for (low = 0; low < span; low++)
 787                 {
 788                   TOHEX (dst, d->chunk_data[addr + low]);
 789                   dst += 2;
 790                 }
 791               out (abfd, '6', buffer, dst);
 792             }
 793         }
 794     }
 795
 796   /* Write all the section headers for the sections.  */
 797   for (s = abfd->sections; s != NULL; s = s->next)
 798     {
 799       char *dst = buffer;
 800
 801       writesym (&dst, s->name);
 802       *dst++ = '1';
 803       writevalue (&dst, s->vma);
 804       writevalue (&dst, s->vma + s->size);
 805       out (abfd, '3', buffer, dst);
 806     }
 807
 808   /* And the symbols.  */
 809   if (abfd->outsymbols)
 810     {
 811       for (p = abfd->outsymbols; *p; p++)
 812         {
 813           int section_code = bfd_decode_symclass (*p);
 814
 815           if (section_code != '?')
 816             {
 817               /* Do not include debug symbols.  */
 818               asymbol *sym = *p;
 819               char *dst = buffer;
 820
 821               writesym (&dst, sym->section->name);
 822
 823               switch (section_code)
 824                 {
 825                 case 'A':
 826                   *dst++ = '2';
 827                   break;
 828                 case 'a':
 829                   *dst++ = '6';
 830                   break;
 831                 case 'D':
 832                 case 'B':
 833                 case 'O':
 834                   *dst++ = '4';
 835                   break;
 836                 case 'd':
 837                 case 'b':
 838                 case 'o':
 839                   *dst++ = '8';
 840                   break;
 841                 case 'T':
 842                   *dst++ = '3';
 843                   break;
 844                 case 't':
 845                   *dst++ = '7';
 846                   break;
 847                 case 'C':
 848                 case 'U':
 849                   bfd_set_error (bfd_error_wrong_format);
 850                   return FALSE;
 851                 }
 852
 853               writesym (&dst, sym->name);
 854               writevalue (&dst, sym->value + sym->section->vma);
 855               out (abfd, '3', buffer, dst);
 856             }
 857         }
 858     }
 859
 860   /* And the terminator.  */
 861   if (bfd_bwrite ("%0781010\n", (bfd_size_type) 9, abfd) != 9)
 862     abort ();
 863   return TRUE;
 864 }
 865
 866 static int
 867 tekhex_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
 868                        bfd_boolean exec ATTRIBUTE_UNUSED)
 869 {
 870   return 0;
 871 }
 872
 873 static asymbol *
 874 tekhex_make_empty_symbol (bfd *abfd)
 875 {
 876   bfd_size_type amt = sizeof (struct tekhex_symbol_struct);
 877   tekhex_symbol_type *new = bfd_zalloc (abfd, amt);
 878
 879   if (!new)
 880     return NULL;
 881   new->symbol.the_bfd = abfd;
 882   new->prev =  NULL;
 883   return &(new->symbol);
 884 }
 885
 886 static void
 887 tekhex_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
 888                         asymbol *symbol,
 889                         symbol_info *ret)
 890 {
 891   bfd_symbol_info (symbol, ret);
 892 }
 893
 894 static void
 895 tekhex_print_symbol (bfd *abfd,
 896                      void * filep,
 897                      asymbol *symbol,
 898                      bfd_print_symbol_type how)
 899 {
 900   FILE *file = (FILE *) filep;
 901
 902   switch (how)
 903     {
 904     case bfd_print_symbol_name:
 905       fprintf (file, "%s", symbol->name);
 906       break;
 907     case bfd_print_symbol_more:
 908       break;
 909
 910     case bfd_print_symbol_all:
 911       {
 912         const char *section_name = symbol->section->name;
 913
 914         bfd_print_symbol_vandf (abfd, (void *) file, symbol);
 915
 916         fprintf (file, " %-5s %s",
 917                  section_name, symbol->name);
 918       }
 919     }
 920 }
 921
 922 #define tekhex_close_and_cleanup                    _bfd_generic_close_and_cleanup
 923 #define tekhex_bfd_free_cached_info                 _bfd_generic_bfd_free_cached_info
 924 #define tekhex_new_section_hook                     _bfd_generic_new_section_hook
 925 #define tekhex_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
 926 #define tekhex_bfd_is_local_label_name               bfd_generic_is_local_label_name
 927 #define tekhex_get_lineno                           _bfd_nosymbols_get_lineno
 928 #define tekhex_find_nearest_line                    _bfd_nosymbols_find_nearest_line
 929 #define tekhex_find_inliner_info                    _bfd_nosymbols_find_inliner_info
 930 #define tekhex_bfd_make_debug_symbol                _bfd_nosymbols_bfd_make_debug_symbol
 931 #define tekhex_read_minisymbols                     _bfd_generic_read_minisymbols
 932 #define tekhex_minisymbol_to_symbol                 _bfd_generic_minisymbol_to_symbol
 933 #define tekhex_bfd_get_relocated_section_contents   bfd_generic_get_relocated_section_contents
 934 #define tekhex_bfd_relax_section                    bfd_generic_relax_section
 935 #define tekhex_bfd_gc_sections                      bfd_generic_gc_sections
 936 #define tekhex_bfd_merge_sections                   bfd_generic_merge_sections
 937 #define tekhex_bfd_is_group_section                 bfd_generic_is_group_section
 938 #define tekhex_bfd_discard_group                    bfd_generic_discard_group
 939 #define tekhex_section_already_linked               _bfd_generic_section_already_linked
 940 #define tekhex_bfd_link_hash_table_create           _bfd_generic_link_hash_table_create
 941 #define tekhex_bfd_link_hash_table_free             _bfd_generic_link_hash_table_free
 942 #define tekhex_bfd_link_add_symbols                 _bfd_generic_link_add_symbols
 943 #define tekhex_bfd_link_just_syms                   _bfd_generic_link_just_syms
 944 #define tekhex_bfd_final_link                       _bfd_generic_final_link
 945 #define tekhex_bfd_link_split_section               _bfd_generic_link_split_section
 946 #define tekhex_get_section_contents_in_window       _bfd_generic_get_section_contents_in_window
 947
 948 const bfd_target tekhex_vec =
 949 {
 950   "tekhex",                     /* Name.  */
 951   bfd_target_tekhex_flavour,
 952   BFD_ENDIAN_UNKNOWN,           /* Target byte order.  */
 953   BFD_ENDIAN_UNKNOWN,           /* Target headers byte order.  */
 954   (EXEC_P |                     /* Object flags.  */
 955    HAS_SYMS | HAS_LINENO | HAS_DEBUG |
 956    HAS_RELOC | HAS_LOCALS | WP_TEXT | D_PAGED),
 957   (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
 958    | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags.  */
 959   0,                            /* Leading underscore.  */
 960   ' ',                          /* AR_pad_char.  */
 961   16,                           /* AR_max_namelen.  */
 962   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
 963   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
 964   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Data.  */
 965   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
 966   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
 967   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Headers.  */
 968
 969   {
 970     _bfd_dummy_target,
 971     tekhex_object_p,            /* bfd_check_format.  */
 972     _bfd_dummy_target,
 973     _bfd_dummy_target,
 974   },
 975   {
 976     bfd_false,
 977     tekhex_mkobject,
 978     _bfd_generic_mkarchive,
 979     bfd_false,
 980   },
 981   {                             /* bfd_write_contents.  */
 982     bfd_false,
 983     tekhex_write_object_contents,
 984     _bfd_write_archive_contents,
 985     bfd_false,
 986   },
 987
 988   BFD_JUMP_TABLE_GENERIC (tekhex),
 989   BFD_JUMP_TABLE_COPY (_bfd_generic),
 990   BFD_JUMP_TABLE_CORE (_bfd_nocore),
 991   BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
 992   BFD_JUMP_TABLE_SYMBOLS (tekhex),
 993   BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
 994   BFD_JUMP_TABLE_WRITE (tekhex),
 995   BFD_JUMP_TABLE_LINK (tekhex),
 996   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 997
 998   NULL,
 999
1000   NULL
1001 };