Bug Summary

File:src/gnu/usr.bin/binutils-2.17/bfd/tekhex.c
Warning:line 642, column 17
Value stored to 's' during its initialization is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

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