bfd/tekhex.c

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