Coverage Report

Created: 2024-05-21 06:29

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