bfd/tekhex.c

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