projects / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
build file symbol fwd pointers properly, don't deref symbol #s as pointers
[binutils-gdb.git] / gas / config / obj-coffbfd.c
1 /* coff object file format with bfd
2 Copyright (C) 1989, 1990, 1991 Free Software Foundation, Inc.
3
4 This file is part of GAS.
5
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19
20 /*
21
22 How does this releate to the rest of GAS ?
23
24 Well, all the other files in gas are more or less a black box. It
25 takes care of opening files, parsing command lines, stripping blanks
26 etc etc. This module gets a chance to register what it wants to do by
27 saying that it is interested in various pseduo ops. The other big
28 change is write_object_file. This runs through all the data
29 structures that gas builds, and outputs the file in the format of our
30 choice.
31
32 Hacked for BFDness by steve chamberlain
33
34 This object module now supports the Hitachi H8/{3|5}00 and the AMD 29k
35
36 sac@cygnus.com
37 */
38
39 #include "as.h"
40 #include "obstack.h"
41 #include "subsegs.h"
42 #include "frags.h"
43 #include "../bfd/libbfd.h"
44 #include "../bfd/libcoff.h"
45
46 /* The NOP_OPCODE is for the alignment fill value. Fill with nop so
47 that we can stick sections together without causing trouble. */
48 #ifndef NOP_OPCODE
49 #define NOP_OPCODE 0x00
50 #endif
51
52 #define MIN(a,b) ((a) < (b)? (a) : (b))
53 /* This vector is used to turn an internal segment into a section #
54 suitable for insertion into a coff symbol table
55 */
56
57 const short seg_N_TYPE[] =
58 { /* in: segT out: N_TYPE bits */
59 C_ABS_SECTION,
60 1,
61 2,
62 3,
63 4,
64 5,
65 6,
66 7,
67 8,
68 9,
69 10,
70 C_UNDEF_SECTION, /* SEG_UNKNOWN */
71 C_UNDEF_SECTION, /* SEG_ABSENT */
72 C_UNDEF_SECTION, /* SEG_PASS1 */
73 C_UNDEF_SECTION, /* SEG_GOOF */
74 C_UNDEF_SECTION, /* SEG_BIG */
75 C_UNDEF_SECTION, /* SEG_DIFFERENCE */
76 C_DEBUG_SECTION, /* SEG_DEBUG */
77 C_NTV_SECTION, /* SEG_NTV */
78 C_PTV_SECTION, /* SEG_PTV */
79 C_REGISTER_SECTION, /* SEG_REGISTER */
80 };
81
82
83 int function_lineoff = -1; /* Offset in line#s where the last function
84 started (the odd entry for line #0) */
85
86
87 static symbolS *last_line_symbol;
88
89 /* Add 4 to the real value to get the index and compensate the
90 negatives. This vector is used by S_GET_SEGMENT to turn a coff
91 section number into a segment number
92 */
93 static symbolS *previous_file_symbol = NULL;
94 void c_symbol_merge ();
95 static int line_base;
96
97 symbolS *c_section_symbol ();
98 bfd *abfd;
99 void EXFUN (bfd_as_write_hook, (struct internal_filehdr *,
100 bfd * abfd));
101
102 static void EXFUN (fixup_segment, (segment_info_type *segP,
103 segT this_segment_type));
104
105
106 static void EXFUN (fixup_mdeps, (fragS *,
107 object_headers *,
108 segT));
109
110
111 static void EXFUN (fill_section, (bfd * abfd,
112 object_headers *,
113 unsigned long *));
114
115
116 char *EXFUN (s_get_name, (symbolS * s));
117 static symbolS *EXFUN (tag_find_or_make, (char *name));
118 static symbolS *EXFUN (tag_find, (char *name));
119
120
121 static int
122 EXFUN (c_line_new, (
123 symbolS * symbol,
124 long paddr,
125 unsigned short line_number,
126 fragS * frag));
127
128
129 static void EXFUN (w_symbols,
130 (bfd * abfd,
131 char *where,
132 symbolS * symbol_rootP));
133
134
135
136 static void EXFUN (obj_coff_def, (int what));
137 static void EXFUN (obj_coff_lcomm, (void));
138 static void EXFUN (obj_coff_dim, (void));
139 static void EXFUN (obj_coff_text, (void));
140 static void EXFUN (obj_coff_data, (void));
141 static void EXFUN( obj_coff_bss,(void));
142 static void EXFUN( obj_coff_ident,(void));
143 static void EXFUN (obj_coff_endef, (void));
144 static void EXFUN (obj_coff_line, (void));
145 static void EXFUN (obj_coff_ln, (void));
146 static void EXFUN (obj_coff_scl, (void));
147 static void EXFUN (obj_coff_size, (void));
148 static void EXFUN (obj_coff_tag, (void));
149 static void EXFUN (obj_coff_type, (void));
150 static void EXFUN (obj_coff_val, (void));
151 void EXFUN (obj_coff_section, (void));
152 static void EXFUN (tag_init, (void));
153 static void EXFUN (tag_insert, (char *name, symbolS * symbolP));
154
155
156 static struct hash_control *tag_hash;
157 static symbolS *def_symbol_in_progress = NULL;
158
159 const pseudo_typeS obj_pseudo_table[] =
160 {
161 {"def", obj_coff_def, 0},
162 {"dim", obj_coff_dim, 0},
163 {"endef", obj_coff_endef, 0},
164 {"line", obj_coff_line, 0},
165 {"ln", obj_coff_ln, 0},
166 {"scl", obj_coff_scl, 0},
167 {"size", obj_coff_size, 0},
168 {"tag", obj_coff_tag, 0},
169 {"type", obj_coff_type, 0},
170 {"val", obj_coff_val, 0},
171 {"section", obj_coff_section, 0},
172 {"use", obj_coff_section, 0},
173 {"sect", obj_coff_section, 0},
174 {"text", obj_coff_text, 0},
175 {"data", obj_coff_data, 0},
176 {"bss", obj_coff_bss, 0},
177 {"ident", obj_coff_ident, 0},
178 {"ABORT", s_abort, 0},
179 {"lcomm", obj_coff_lcomm, 0},
180 {NULL} /* end sentinel */
181 }; /* obj_pseudo_table */
182
183
184
185 /* Section stuff
186
187 We allow more than just the standard 3 sections, infact, we allow
188 10 sections, (though the usual three have to be there).
189
190 This structure performs the mappings for us:
191
192 */
193
194 /* OBS stuff
195 static struct internal_scnhdr bss_section_header;
196 struct internal_scnhdr data_section_header;
197 struct internal_scnhdr text_section_header;
198
199 const segT N_TYPE_seg [32] =
200 {
201
202 };
203
204 */
205
206 #define N_SEG 32
207 typedef struct
208 {
209 segT seg_t;
210 int i;
211 } seg_info_type;
212
213 seg_info_type seg_info_off_by_4[N_SEG] =
214 {
215 {SEG_PTV, },
216 {SEG_NTV, },
217 {SEG_DEBUG, },
218 {SEG_ABSOLUTE, },
219 {SEG_UNKNOWN, },
220 {SEG_E0},
221 {SEG_E1},
222 {SEG_E2},
223 {SEG_E3},
224 {SEG_E4},
225 {SEG_E5},
226 {SEG_E6},
227 {SEG_E7},
228 {SEG_E8},
229 {SEG_E9},
230 {(segT)15},
231 {(segT)16},
232 {(segT)17},
233 {(segT)18},
234 {(segT)19},
235 {(segT)20},
236 {(segT)0},
237 {(segT)0},
238 {(segT)0},
239 {SEG_REGISTER}
240 };
241
242
243
244 #define SEG_INFO_FROM_SECTION_NUMBER(x) (seg_info_off_by_4[(x)+4])
245 #define SEG_INFO_FROM_SEG_NUMBER(x) (seg_info_off_by_4[(x)])
246
247
248 relax_addressT
249 DEFUN (relax_align, (address, alignment),
250 register relax_addressT address AND
251 register long alignment)
252 {
253 relax_addressT mask;
254 relax_addressT new_address;
255
256 mask = ~((~0) << alignment);
257 new_address = (address + mask) & (~mask);
258 return (new_address - address);
259 } /* relax_align() */
260
261
262 segT
263 DEFUN (s_get_segment, (x),
264 symbolS * x)
265 {
266 return SEG_INFO_FROM_SECTION_NUMBER (x->sy_symbol.ost_entry.n_scnum).seg_t;
267 }
268
269
270
271 /* calculate the size of the frag chain and fill in the section header
272 to contain all of it, also fill in the addr of the sections */
273 static unsigned int
274 DEFUN (size_section, (abfd, idx),
275 bfd * abfd AND
276 unsigned int idx)
277 {
278
279 unsigned int size = 0;
280 fragS *frag = segment_info[idx].frchainP->frch_root;
281 while (frag)
282 {
283 size = frag->fr_address;
284 if (frag->fr_address != size)
285 {
286 printf ("Out of step\n");
287 size = frag->fr_address;
288 }
289
290 switch (frag->fr_type)
291 {
292 #ifdef TC_COFF_SIZEMACHDEP
293 case rs_machine_dependent:
294 size += TC_COFF_SIZEMACHDEP (frag);
295 break;
296 #endif
297 case rs_fill:
298 case rs_org:
299 size += frag->fr_fix;
300 size += frag->fr_offset * frag->fr_var;
301 break;
302 case rs_align:
303 size += frag->fr_fix;
304 size += relax_align (size, frag->fr_offset);
305 }
306 frag = frag->fr_next;
307 }
308 segment_info[idx].scnhdr.s_size = size;
309 return size;
310 }
311
312
313 static unsigned int
314 DEFUN (count_entries_in_chain, (idx),
315 unsigned int idx)
316 {
317 unsigned int nrelocs;
318 fixS *fixup_ptr;
319
320 /* Count the relocations */
321 fixup_ptr = segment_info[idx].fix_root;
322 nrelocs = 0;
323 while (fixup_ptr != (fixS *) NULL)
324 {
325 if (TC_COUNT_RELOC (fixup_ptr))
326 {
327
328 #ifdef TC_A29K
329
330 if (fixup_ptr->fx_r_type == RELOC_CONSTH)
331 nrelocs += 2;
332 else
333 nrelocs++;
334 #else
335 nrelocs++;
336 #endif
337 }
338
339 fixup_ptr = fixup_ptr->fx_next;
340 }
341 return nrelocs;
342 }
343
344 /* output all the relocations for a section */
345 void
346 DEFUN (do_relocs_for, (abfd, h, file_cursor),
347 bfd * abfd AND
348 object_headers * h AND
349 unsigned long *file_cursor)
350 {
351 unsigned int nrelocs;
352 unsigned int idx;
353 unsigned long reloc_start = *file_cursor;
354
355 for (idx = SEG_E0; idx < SEG_E9; idx++)
356 {
357 if (segment_info[idx].scnhdr.s_name[0])
358 {
359 struct external_reloc *ext_ptr;
360 struct external_reloc *external_reloc_vec;
361 unsigned int external_reloc_size;
362 unsigned int count = 0;
363 unsigned int base = segment_info[idx].scnhdr.s_paddr;
364 fixS *fix_ptr = segment_info[idx].fix_root;
365 nrelocs = count_entries_in_chain (idx);
366
367 if (nrelocs)
368 /* Bypass this stuff if no relocs. This also incidentally
369 avoids a SCO bug, where free(malloc(0)) tends to crash. */
370 {
371 external_reloc_size = nrelocs * RELSZ;
372 external_reloc_vec =
373 (struct external_reloc *) malloc (external_reloc_size);
374
375 ext_ptr = external_reloc_vec;
376
377 /* Fill in the internal coff style reloc struct from the
378 internal fix list. */
379 while (fix_ptr)
380 {
381 symbolS *symbol_ptr;
382 struct internal_reloc intr;
383
384 /* Only output some of the relocations */
385 if (TC_COUNT_RELOC (fix_ptr))
386 {
387 #ifdef TC_RELOC_MANGLE
388 TC_RELOC_MANGLE (fix_ptr, &intr, base);
389
390 #else
391 symbolS *dot;
392 symbol_ptr = fix_ptr->fx_addsy;
393
394 intr.r_type = TC_COFF_FIX2RTYPE (fix_ptr);
395 intr.r_vaddr =
396 base + fix_ptr->fx_frag->fr_address + fix_ptr->fx_where;
397
398 intr.r_offset = fix_ptr->fx_offset;
399
400 intr.r_offset = 0;
401
402 /* Turn the segment of the symbol into an offset. */
403 if (symbol_ptr)
404 {
405 dot = segment_info[S_GET_SEGMENT (symbol_ptr)].dot;
406 if (dot)
407 {
408 intr.r_symndx = dot->sy_number;
409 }
410 else
411 {
412 intr.r_symndx = symbol_ptr->sy_number;
413 }
414
415 }
416 else
417 {
418 intr.r_symndx = -1;
419 }
420 #endif
421
422 (void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
423 ext_ptr++;
424
425 #if defined(TC_A29K)
426
427 /* The 29k has a special kludge for the high 16 bit
428 reloc. Two relocations are emited, R_IHIHALF,
429 and R_IHCONST. The second one doesn't contain a
430 symbol, but uses the value for offset. */
431
432 if (intr.r_type == R_IHIHALF)
433 {
434 /* now emit the second bit */
435 intr.r_type = R_IHCONST;
436 intr.r_symndx = fix_ptr->fx_addnumber;
437 (void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
438 ext_ptr++;
439 }
440 #endif
441 }
442
443 fix_ptr = fix_ptr->fx_next;
444 }
445
446 /* Write out the reloc table */
447 bfd_write ((PTR) external_reloc_vec, 1, external_reloc_size,
448 abfd);
449 free (external_reloc_vec);
450
451 /* Fill in section header info. */
452 segment_info[idx].scnhdr.s_relptr = *file_cursor;
453 *file_cursor += external_reloc_size;
454 segment_info[idx].scnhdr.s_nreloc = nrelocs;
455 }
456 else
457 {
458 /* No relocs */
459 segment_info[idx].scnhdr.s_relptr = 0;
460 }
461 }
462 }
463 /* Set relocation_size field in file headers */
464 H_SET_RELOCATION_SIZE (h, *file_cursor - reloc_start, 0);
465 }
466
467
468 /* run through a frag chain and write out the data to go with it, fill
469 in the scnhdrs with the info on the file postions
470 */
471 static void
472 DEFUN (fill_section, (abfd, h, file_cursor),
473 bfd * abfd AND
474 object_headers *h AND
475 unsigned long *file_cursor)
476 {
477
478 unsigned int i;
479 unsigned int paddr = 0;
480
481 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
482 {
483 unsigned int offset = 0;
484
485 struct internal_scnhdr *s = &(segment_info[i].scnhdr);
486
487 if (s->s_name[0])
488 {
489 fragS *frag = segment_info[i].frchainP->frch_root;
490 char *buffer;
491
492 if (s->s_size == 0)
493 s->s_scnptr = 0;
494 else
495 {
496 buffer = xmalloc (s->s_size);
497 s->s_scnptr = *file_cursor;
498 }
499 know (s->s_paddr == paddr);
500
501 s->s_flags = STYP_REG;
502 if (strcmp (s->s_name, ".text") == 0)
503 s->s_flags |= STYP_TEXT;
504 else if (strcmp (s->s_name, ".data") == 0)
505 s->s_flags |= STYP_DATA;
506 else if (strcmp (s->s_name, ".bss") == 0)
507 {
508 s->s_scnptr = 0;
509 s->s_flags |= STYP_BSS;
510 #ifndef TC_I386
511 #ifndef TC_A29K
512 /* Apparently the SVR3 linker is confused by noload
513 sections. So is the UDI mondfe program. */
514 s->s_flags |= STYP_NOLOAD;
515 #endif
516 #endif
517 }
518 else if (strcmp (s->s_name, ".lit") == 0)
519 s->s_flags = STYP_LIT | STYP_TEXT;
520 else if (strcmp (s->s_name, ".init") == 0)
521 s->s_flags |= STYP_TEXT;
522 else if (strcmp (s->s_name, ".fini") == 0)
523 s->s_flags |= STYP_TEXT;
524 else if (strncmp (s->s_name, ".comment", 8) == 0)
525 s->s_flags |= STYP_INFO;
526
527 while (frag)
528 {
529 unsigned int fill_size;
530 switch (frag->fr_type)
531 {
532 case rs_machine_dependent:
533 if (frag->fr_fix)
534 {
535 memcpy (buffer + frag->fr_address,
536 frag->fr_literal,
537 frag->fr_fix);
538 offset += frag->fr_fix;
539 }
540
541 break;
542 case rs_fill:
543 case rs_align:
544 case rs_org:
545 if (frag->fr_fix)
546 {
547 memcpy (buffer + frag->fr_address,
548 frag->fr_literal,
549 frag->fr_fix);
550 offset += frag->fr_fix;
551 }
552
553 fill_size = frag->fr_var;
554 if (fill_size)
555 {
556 unsigned int count;
557 unsigned int off = frag->fr_fix;
558 for (count = frag->fr_offset; count; count--)
559 {
560 if (fill_size < s->s_size)
561 {
562 memcpy (buffer + frag->fr_address + off,
563 frag->fr_literal + frag->fr_fix,
564 fill_size);
565 off += fill_size;
566 offset += fill_size;
567 }
568 }
569 }
570 break;
571 case rs_broken_word:
572 break;
573 default:
574 abort ();
575 }
576 frag = frag->fr_next;
577 }
578
579 if (s->s_size != 0)
580 {
581 if (s->s_scnptr != 0)
582 {
583 bfd_write (buffer, s->s_size, 1, abfd);
584 *file_cursor += s->s_size;
585 }
586 free (buffer);
587 }
588 paddr += s->s_size;
589 }
590 }
591 }
592
593 /* Coff file generation & utilities */
594
595 static void
596 DEFUN (coff_header_append, (abfd, h),
597 bfd * abfd AND
598 object_headers * h)
599 {
600 unsigned int i;
601 char buffer[1000];
602 char buffero[1000];
603
604 bfd_seek (abfd, 0, 0);
605
606 #ifndef OBJ_COFF_OMIT_OPTIONAL_HEADER
607 H_SET_MAGIC_NUMBER (h, COFF_MAGIC);
608 H_SET_VERSION_STAMP (h, 0);
609 H_SET_ENTRY_POINT (h, 0);
610 H_SET_TEXT_START (h, segment_info[SEG_E0].frchainP->frch_root->fr_address);
611 H_SET_DATA_START (h, segment_info[SEG_E1].frchainP->frch_root->fr_address);
612 H_SET_SIZEOF_OPTIONAL_HEADER (h, bfd_coff_swap_aouthdr_out(abfd, &h->aouthdr,
613 buffero));
614 #else /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
615 H_SET_SIZEOF_OPTIONAL_HEADER (h, 0);
616 #endif /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
617
618 i = bfd_coff_swap_filehdr_out (abfd, &h->filehdr, buffer);
619
620 bfd_write (buffer, i, 1, abfd);
621 bfd_write (buffero, H_GET_SIZEOF_OPTIONAL_HEADER (h), 1, abfd);
622
623 for (i = SEG_E0; i < SEG_E9; i++)
624 {
625 if (segment_info[i].scnhdr.s_name[0])
626 {
627 unsigned int size =
628 bfd_coff_swap_scnhdr_out (abfd,
629 &(segment_info[i].scnhdr),
630 buffer);
631 bfd_write (buffer, size, 1, abfd);
632 }
633 }
634 }
635
636
637 char *
638 DEFUN (symbol_to_chars, (abfd, where, symbolP),
639 bfd * abfd AND
640 char *where AND
641 symbolS * symbolP)
642 {
643 unsigned int numaux = symbolP->sy_symbol.ost_entry.n_numaux;
644 unsigned int i;
645
646 /* Turn any symbols with register attributes into abs symbols */
647 if (S_GET_SEGMENT (symbolP) == SEG_REGISTER)
648 {
649 S_SET_SEGMENT (symbolP, SEG_ABSOLUTE);
650 }
651 /* At the same time, relocate all symbols to their output value */
652
653 S_SET_VALUE (symbolP,
654 segment_info[S_GET_SEGMENT (symbolP)].scnhdr.s_paddr
655 + S_GET_VALUE (symbolP));
656
657 where += bfd_coff_swap_sym_out (abfd, &symbolP->sy_symbol.ost_entry,
658 where);
659
660 for (i = 0; i < numaux; i++)
661 {
662 where += bfd_coff_swap_aux_out (abfd,
663 &symbolP->sy_symbol.ost_auxent[i],
664 S_GET_DATA_TYPE (symbolP),
665 S_GET_STORAGE_CLASS (symbolP),
666 where);
667 }
668 return where;
669
670 }
671
672
673
674
675 void
676 obj_symbol_new_hook (symbolP)
677 symbolS *symbolP;
678 {
679 char underscore = 0; /* Symbol has leading _ */
680
681 /* Effective symbol */
682 /* Store the pointer in the offset. */
683 S_SET_ZEROES (symbolP, 0L);
684 S_SET_DATA_TYPE (symbolP, T_NULL);
685 S_SET_STORAGE_CLASS (symbolP, 0);
686 S_SET_NUMBER_AUXILIARY (symbolP, 0);
687 /* Additional information */
688 symbolP->sy_symbol.ost_flags = 0;
689 /* Auxiliary entries */
690 bzero ((char *) &symbolP->sy_symbol.ost_auxent[0], AUXESZ);
691
692 #ifdef STRIP_UNDERSCORE
693 /* Remove leading underscore at the beginning of the symbol.
694 * This is to be compatible with the standard librairies.
695 */
696 if (*S_GET_NAME (symbolP) == '_')
697 {
698 underscore = 1;
699 S_SET_NAME (symbolP, S_GET_NAME (symbolP) + 1);
700 } /* strip underscore */
701 #endif /* STRIP_UNDERSCORE */
702
703 if (S_IS_STRING (symbolP))
704 SF_SET_STRING (symbolP);
705 if (!underscore && S_IS_LOCAL (symbolP))
706 SF_SET_LOCAL (symbolP);
707
708 return;
709 } /* obj_symbol_new_hook() */
710
711 /* stack stuff */
712 stack *
713 stack_init (chunk_size, element_size)
714 unsigned long chunk_size;
715 unsigned long element_size;
716 {
717 stack *st;
718
719 if ((st = (stack *) malloc (sizeof (stack))) == (stack *) 0)
720 return (stack *) 0;
721 if ((st->data = malloc (chunk_size)) == (char *) 0)
722 {
723 free (st);
724 return (stack *) 0;
725 }
726 st->pointer = 0;
727 st->size = chunk_size;
728 st->chunk_size = chunk_size;
729 st->element_size = element_size;
730 return st;
731 } /* stack_init() */
732
733 void
734 stack_delete (st)
735 stack *st;
736 {
737 free (st->data);
738 free (st);
739 }
740
741 char *
742 stack_push (st, element)
743 stack *st;
744 char *element;
745 {
746 if (st->pointer + st->element_size >= st->size)
747 {
748 st->size += st->chunk_size;
749 if ((st->data = xrealloc (st->data, st->size)) == (char *) 0)
750 return (char *) 0;
751 }
752 memcpy (st->data + st->pointer, element, st->element_size);
753 st->pointer += st->element_size;
754 return st->data + st->pointer;
755 } /* stack_push() */
756
757 char *
758 stack_pop (st)
759 stack *st;
760 {
761 if ((st->pointer -= st->element_size) < 0)
762 {
763 st->pointer = 0;
764 return (char *) 0;
765 }
766
767 return st->data + st->pointer;
768 }
769
770 char *
771 stack_top (st)
772 stack *st;
773 {
774 return st->data + st->pointer - st->element_size;
775 }
776
777
778 /*
779 * Handle .ln directives.
780 */
781
782 static void
783 obj_coff_ln ()
784 {
785 int l;
786
787 if (def_symbol_in_progress != NULL)
788 {
789 as_warn (".ln pseudo-op inside .def/.endef: ignored.");
790 demand_empty_rest_of_line ();
791 return;
792 } /* wrong context */
793
794 c_line_new (0,
795 obstack_next_free (&frags) - frag_now->fr_literal,
796 l = get_absolute_expression (),
797 frag_now);
798 #ifndef NO_LISTING
799 {
800 extern int listing;
801
802 if (listing)
803 {
804 listing_source_line (l + line_base - 1);
805 }
806
807 }
808 #endif
809 demand_empty_rest_of_line ();
810 return;
811 } /* obj_coff_line() */
812
813 /*
814 * def()
815 *
816 * Handle .def directives.
817 *
818 * One might ask : why can't we symbol_new if the symbol does not
819 * already exist and fill it with debug information. Because of
820 * the C_EFCN special symbol. It would clobber the value of the
821 * function symbol before we have a chance to notice that it is
822 * a C_EFCN. And a second reason is that the code is more clear this
823 * way. (at least I think it is :-).
824 *
825 */
826
827 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
828 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
829 *input_line_pointer == '\t') \
830 input_line_pointer++;
831
832 static void
833 DEFUN (obj_coff_def, (what),
834 int what)
835 {
836 char name_end; /* Char after the end of name */
837 char *symbol_name; /* Name of the debug symbol */
838 char *symbol_name_copy; /* Temporary copy of the name */
839 unsigned int symbol_name_length;
840 /*$char* directiveP;$ *//* Name of the pseudo opcode */
841 /*$char directive[MAX_DIRECTIVE];$ *//* Backup of the directive */
842 /*$char end = 0;$ *//* If 1, stop parsing */
843
844 if (def_symbol_in_progress != NULL)
845 {
846 as_warn (".def pseudo-op used inside of .def/.endef: ignored.");
847 demand_empty_rest_of_line ();
848 return;
849 } /* if not inside .def/.endef */
850
851 SKIP_WHITESPACES ();
852
853 def_symbol_in_progress = (symbolS *) obstack_alloc (&notes, sizeof (*def_symbol_in_progress));
854 bzero (def_symbol_in_progress, sizeof (*def_symbol_in_progress));
855
856 symbol_name = input_line_pointer;
857 name_end = get_symbol_end ();
858 symbol_name_length = strlen (symbol_name);
859 symbol_name_copy = xmalloc (symbol_name_length + 1);
860 strcpy (symbol_name_copy, symbol_name);
861
862 /* Initialize the new symbol */
863 #ifdef STRIP_UNDERSCORE
864 S_SET_NAME (def_symbol_in_progress, (*symbol_name_copy == '_'
865 ? symbol_name_copy + 1
866 : symbol_name_copy));
867 #else /* STRIP_UNDERSCORE */
868 S_SET_NAME (def_symbol_in_progress, symbol_name_copy);
869 #endif /* STRIP_UNDERSCORE */
870 /* free(symbol_name_copy); */
871 def_symbol_in_progress->sy_name_offset = ~0;
872 def_symbol_in_progress->sy_number = ~0;
873 def_symbol_in_progress->sy_frag = &zero_address_frag;
874
875 if (S_IS_STRING (def_symbol_in_progress))
876 {
877 SF_SET_STRING (def_symbol_in_progress);
878 } /* "long" name */
879
880 *input_line_pointer = name_end;
881
882 demand_empty_rest_of_line ();
883 return;
884 } /* obj_coff_def() */
885
886 unsigned int dim_index;
887 static void
888 DEFUN_VOID (obj_coff_endef)
889 {
890 symbolS *symbolP = 0;
891 /* DIM BUG FIX sac@cygnus.com */
892 dim_index = 0;
893 if (def_symbol_in_progress == NULL)
894 {
895 as_warn (".endef pseudo-op used outside of .def/.endef: ignored.");
896 demand_empty_rest_of_line ();
897 return;
898 } /* if not inside .def/.endef */
899
900 /* Set the section number according to storage class. */
901 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))
902 {
903 case C_STRTAG:
904 case C_ENTAG:
905 case C_UNTAG:
906 SF_SET_TAG (def_symbol_in_progress);
907 /* intentional fallthrough */
908 case C_FILE:
909 case C_TPDEF:
910 SF_SET_DEBUG (def_symbol_in_progress);
911 S_SET_SEGMENT (def_symbol_in_progress, SEG_DEBUG);
912 break;
913
914 case C_EFCN:
915 SF_SET_LOCAL (def_symbol_in_progress); /* Do not emit this symbol. */
916 /* intentional fallthrough */
917 case C_BLOCK:
918 SF_SET_PROCESS (def_symbol_in_progress); /* Will need processing before writing */
919 /* intentional fallthrough */
920 case C_FCN:
921 S_SET_SEGMENT (def_symbol_in_progress, SEG_E0);
922
923 if (strcmp (S_GET_NAME (def_symbol_in_progress), ".bf") == 0)
924 { /* .bf */
925 if (function_lineoff < 0)
926 {
927 fprintf (stderr, "`.bf' symbol without preceding function\n");
928 } /* missing function symbol */
929 SA_GET_SYM_LNNOPTR (last_line_symbol) = function_lineoff;
930
931 SF_SET_PROCESS (last_line_symbol);
932 function_lineoff = -1;
933 }
934 break;
935
936 #ifdef C_AUTOARG
937 case C_AUTOARG:
938 #endif /* C_AUTOARG */
939 case C_AUTO:
940 case C_REG:
941 case C_MOS:
942 case C_MOE:
943 case C_MOU:
944 case C_ARG:
945 case C_REGPARM:
946 case C_FIELD:
947 case C_EOS:
948 SF_SET_DEBUG (def_symbol_in_progress);
949 S_SET_SEGMENT (def_symbol_in_progress, SEG_ABSOLUTE);
950 break;
951
952 case C_EXT:
953 case C_STAT:
954 case C_LABEL:
955 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
956 break;
957
958 case C_USTATIC:
959 case C_EXTDEF:
960 case C_ULABEL:
961 as_warn ("unexpected storage class %d", S_GET_STORAGE_CLASS (def_symbol_in_progress));
962 break;
963 } /* switch on storage class */
964
965 /* Now that we have built a debug symbol, try to find if
966 we should merge with an existing symbol or not. If a
967 symbol is C_EFCN or SEG_ABSOLUTE or untagged
968 SEG_DEBUG it never merges. We also don't merge
969 labels, which are in a different namespace, nor
970 symbols which have not yet been defined since they
971 are typically unique, nor do we merge tags with
972 non-tags. */
973
974 /* Two cases for functions. Either debug followed
975 by definition or definition followed by debug.
976 For definition first, we will merge the debug
977 symbol into the definition. For debug first, the
978 lineno entry MUST point to the definition
979 function or else it will point off into space
980 when crawl_symbols() merges the debug
981 symbol into the real symbol. Therefor, let's
982 presume the debug symbol is a real function
983 reference. */
984
985 /* FIXME-SOON If for some reason the definition
986 label/symbol is never seen, this will probably
987 leave an undefined symbol at link time. */
988
989 if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN
990 || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_LABEL
991 || (S_GET_SEGMENT (def_symbol_in_progress) == SEG_DEBUG
992 && !SF_GET_TAG (def_symbol_in_progress))
993 || S_GET_SEGMENT (def_symbol_in_progress) == SEG_ABSOLUTE
994 || def_symbol_in_progress->sy_forward != NULL
995 || (symbolP = symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP)) == NULL
996 || (SF_GET_TAG (def_symbol_in_progress) != SF_GET_TAG (symbolP)))
997 {
998
999 symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP, &symbol_lastP);
1000
1001 }
1002 else
1003 {
1004 /* This symbol already exists, merge the
1005 newly created symbol into the old one.
1006 This is not mandatory. The linker can
1007 handle duplicate symbols correctly. But I
1008 guess that it save a *lot* of space if
1009 the assembly file defines a lot of
1010 symbols. [loic] */
1011
1012 /* The debug entry (def_symbol_in_progress)
1013 is merged into the previous definition. */
1014
1015 c_symbol_merge (def_symbol_in_progress, symbolP);
1016 /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
1017 def_symbol_in_progress = symbolP;
1018
1019 if (SF_GET_FUNCTION (def_symbol_in_progress)
1020 || SF_GET_TAG (def_symbol_in_progress))
1021 {
1022 /* For functions, and tags, the symbol *must* be where the debug symbol
1023 appears. Move the existing symbol to the current place. */
1024 /* If it already is at the end of the symbol list, do nothing */
1025 if (def_symbol_in_progress != symbol_lastP)
1026 {
1027 symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
1028 symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP, &symbol_lastP);
1029 } /* if not already in place */
1030 } /* if function */
1031 } /* normal or mergable */
1032
1033 if (SF_GET_TAG (def_symbol_in_progress)
1034 && symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP) == NULL)
1035 {
1036 tag_insert (S_GET_NAME (def_symbol_in_progress), def_symbol_in_progress);
1037 } /* If symbol is a {structure,union} tag, associate symbol to its name. */
1038
1039 if (SF_GET_FUNCTION (def_symbol_in_progress))
1040 {
1041 know (sizeof (def_symbol_in_progress) <= sizeof (long));
1042 function_lineoff
1043 = c_line_new (def_symbol_in_progress, 0, 0, &zero_address_frag);
1044
1045
1046
1047 SF_SET_PROCESS (def_symbol_in_progress);
1048
1049 if (symbolP == NULL)
1050 {
1051 /* That is, if this is the first
1052 time we've seen the function... */
1053 symbol_table_insert (def_symbol_in_progress);
1054 } /* definition follows debug */
1055 } /* Create the line number entry pointing to the function being defined */
1056
1057 def_symbol_in_progress = NULL;
1058 demand_empty_rest_of_line ();
1059 return;
1060 } /* obj_coff_endef() */
1061
1062 static void
1063 DEFUN_VOID (obj_coff_dim)
1064 {
1065 register int dim_index;
1066
1067 if (def_symbol_in_progress == NULL)
1068 {
1069 as_warn (".dim pseudo-op used outside of .def/.endef: ignored.");
1070 demand_empty_rest_of_line ();
1071 return;
1072 } /* if not inside .def/.endef */
1073
1074 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
1075
1076 for (dim_index = 0; dim_index < DIMNUM; dim_index++)
1077 {
1078 SKIP_WHITESPACES ();
1079 SA_SET_SYM_DIMEN (def_symbol_in_progress, dim_index, get_absolute_expression ());
1080
1081 switch (*input_line_pointer)
1082 {
1083
1084 case ',':
1085 input_line_pointer++;
1086 break;
1087
1088 default:
1089 as_warn ("badly formed .dim directive ignored");
1090 /* intentional fallthrough */
1091 case '\n':
1092 case ';':
1093 dim_index = DIMNUM;
1094 break;
1095 } /* switch on following character */
1096 } /* for each dimension */
1097
1098 demand_empty_rest_of_line ();
1099 return;
1100 } /* obj_coff_dim() */
1101
1102 static void
1103 obj_coff_line ()
1104 {
1105 int this_base;
1106
1107 if (def_symbol_in_progress == NULL)
1108 {
1109 obj_coff_ln ();
1110 return;
1111 } /* if it looks like a stabs style line */
1112
1113 this_base = get_absolute_expression ();
1114 if (this_base > line_base)
1115 {
1116 line_base = this_base;
1117 }
1118
1119
1120 #ifndef NO_LISTING
1121 {
1122 extern int listing;
1123 if (listing && 0)
1124 {
1125 listing_source_line (line_base);
1126 }
1127 }
1128 #endif
1129 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
1130 SA_SET_SYM_LNNO (def_symbol_in_progress, line_base);
1131
1132 demand_empty_rest_of_line ();
1133 return;
1134 } /* obj_coff_line() */
1135
1136 static void
1137 obj_coff_size ()
1138 {
1139 if (def_symbol_in_progress == NULL)
1140 {
1141 as_warn (".size pseudo-op used outside of .def/.endef ignored.");
1142 demand_empty_rest_of_line ();
1143 return;
1144 } /* if not inside .def/.endef */
1145
1146 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
1147 SA_SET_SYM_SIZE (def_symbol_in_progress, get_absolute_expression ());
1148 demand_empty_rest_of_line ();
1149 return;
1150 } /* obj_coff_size() */
1151
1152 static void
1153 obj_coff_scl ()
1154 {
1155 if (def_symbol_in_progress == NULL)
1156 {
1157 as_warn (".scl pseudo-op used outside of .def/.endef ignored.");
1158 demand_empty_rest_of_line ();
1159 return;
1160 } /* if not inside .def/.endef */
1161
1162 S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ());
1163 demand_empty_rest_of_line ();
1164 return;
1165 } /* obj_coff_scl() */
1166
1167 static void
1168 obj_coff_tag ()
1169 {
1170 char *symbol_name;
1171 char name_end;
1172
1173 if (def_symbol_in_progress == NULL)
1174 {
1175 as_warn (".tag pseudo-op used outside of .def/.endef ignored.");
1176 demand_empty_rest_of_line ();
1177 return;
1178 } /* if not inside .def/.endef */
1179
1180 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
1181 symbol_name = input_line_pointer;
1182 name_end = get_symbol_end ();
1183
1184 /* Assume that the symbol referred to by .tag is always defined. */
1185 /* This was a bad assumption. I've added find_or_make. xoxorich. */
1186 SA_SET_SYM_TAGNDX (def_symbol_in_progress, (long) tag_find_or_make (symbol_name));
1187 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L)
1188 {
1189 as_warn ("tag not found for .tag %s", symbol_name);
1190 } /* not defined */
1191
1192 SF_SET_TAGGED (def_symbol_in_progress);
1193 *input_line_pointer = name_end;
1194
1195 demand_empty_rest_of_line ();
1196 return;
1197 } /* obj_coff_tag() */
1198
1199 static void
1200 obj_coff_type ()
1201 {
1202 if (def_symbol_in_progress == NULL)
1203 {
1204 as_warn (".type pseudo-op used outside of .def/.endef ignored.");
1205 demand_empty_rest_of_line ();
1206 return;
1207 } /* if not inside .def/.endef */
1208
1209 S_SET_DATA_TYPE (def_symbol_in_progress, get_absolute_expression ());
1210
1211 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress)) &&
1212 S_GET_STORAGE_CLASS (def_symbol_in_progress) != C_TPDEF)
1213 {
1214 SF_SET_FUNCTION (def_symbol_in_progress);
1215 } /* is a function */
1216
1217 demand_empty_rest_of_line ();
1218 return;
1219 } /* obj_coff_type() */
1220
1221 static void
1222 obj_coff_val ()
1223 {
1224 if (def_symbol_in_progress == NULL)
1225 {
1226 as_warn (".val pseudo-op used outside of .def/.endef ignored.");
1227 demand_empty_rest_of_line ();
1228 return;
1229 } /* if not inside .def/.endef */
1230
1231 if (is_name_beginner (*input_line_pointer))
1232 {
1233 char *symbol_name = input_line_pointer;
1234 char name_end = get_symbol_end ();
1235
1236 if (!strcmp (symbol_name, "."))
1237 {
1238 def_symbol_in_progress->sy_frag = frag_now;
1239 S_SET_VALUE (def_symbol_in_progress, obstack_next_free (&frags) - frag_now->fr_literal);
1240 /* If the .val is != from the .def (e.g. statics) */
1241 }
1242 else if (strcmp (S_GET_NAME (def_symbol_in_progress), symbol_name))
1243 {
1244 def_symbol_in_progress->sy_forward = symbol_find_or_make (symbol_name);
1245
1246 /* If the segment is undefined when the forward
1247 reference is solved, then copy the segment id
1248 from the forward symbol. */
1249 SF_SET_GET_SEGMENT (def_symbol_in_progress);
1250
1251 /* FIXME: gcc can generate address expressions
1252 here in unusual cases (search for "obscure"
1253 in sdbout.c). We just ignore the offset
1254 here, thus generating incorrect debugging
1255 information. We ignore the rest of the
1256 line just below. */
1257 }
1258 /* Otherwise, it is the name of a non debug symbol and
1259 its value will be calculated later. */
1260 *input_line_pointer = name_end;
1261
1262 /* FIXME: this is to avoid an error message in the
1263 FIXME case mentioned just above. */
1264 while (! is_end_of_line[*input_line_pointer])
1265 ++input_line_pointer;
1266 }
1267 else
1268 {
1269 S_SET_VALUE (def_symbol_in_progress, get_absolute_expression ());
1270 } /* if symbol based */
1271
1272 demand_empty_rest_of_line ();
1273 return;
1274 } /* obj_coff_val() */
1275
1276 /*
1277 * Maintain a list of the tagnames of the structres.
1278 */
1279
1280 static void
1281 tag_init ()
1282 {
1283 tag_hash = hash_new ();
1284 return;
1285 } /* tag_init() */
1286
1287 static void
1288 tag_insert (name, symbolP)
1289 char *name;
1290 symbolS *symbolP;
1291 {
1292 register char *error_string;
1293
1294 if (*(error_string = hash_jam (tag_hash, name, (char *) symbolP)))
1295 {
1296 as_fatal ("Inserting \"%s\" into structure table failed: %s",
1297 name, error_string);
1298 }
1299 return;
1300 } /* tag_insert() */
1301
1302 static symbolS *
1303 tag_find_or_make (name)
1304 char *name;
1305 {
1306 symbolS *symbolP;
1307
1308 if ((symbolP = tag_find (name)) == NULL)
1309 {
1310 symbolP = symbol_new (name,
1311 SEG_UNKNOWN,
1312 0,
1313 &zero_address_frag);
1314
1315 tag_insert (S_GET_NAME (symbolP), symbolP);
1316 } /* not found */
1317
1318 return (symbolP);
1319 } /* tag_find_or_make() */
1320
1321 static symbolS *
1322 tag_find (name)
1323 char *name;
1324 {
1325 #ifdef STRIP_UNDERSCORE
1326 if (*name == '_')
1327 name++;
1328 #endif /* STRIP_UNDERSCORE */
1329 return ((symbolS *) hash_find (tag_hash, name));
1330 } /* tag_find() */
1331
1332 void
1333 obj_read_begin_hook ()
1334 {
1335 /* These had better be the same. Usually 18 bytes. */
1336 #ifndef BFD_HEADERS
1337 know (sizeof (SYMENT) == sizeof (AUXENT));
1338 know (SYMESZ == AUXESZ);
1339 #endif
1340 tag_init ();
1341
1342 return;
1343 } /* obj_read_begin_hook() */
1344
1345 /* This function runs through the symbol table and puts all the
1346 externals onto another chain */
1347
1348 /* The chain of externals */
1349 symbolS *symbol_externP = NULL;
1350 symbolS *symbol_extern_lastP = NULL;
1351
1352 stack *block_stack;
1353 symbolS *last_functionP = NULL;
1354 symbolS *last_tagP;
1355
1356 static unsigned int
1357 DEFUN_VOID (yank_symbols)
1358 {
1359 symbolS *symbolP;
1360 unsigned int symbol_number = 0;
1361 unsigned int last_file_symno = 0;
1362
1363 for (symbolP = symbol_rootP;
1364 symbolP;
1365 symbolP = symbolP ? symbol_next (symbolP) : symbol_rootP)
1366 {
1367 if (!SF_GET_DEBUG (symbolP))
1368 {
1369 /* Debug symbols do not need all this rubbish */
1370 symbolS *real_symbolP;
1371
1372 /* L* and C_EFCN symbols never merge. */
1373 if (!SF_GET_LOCAL (symbolP)
1374 && S_GET_STORAGE_CLASS (symbolP) != C_LABEL
1375 && (real_symbolP = symbol_find_base (S_GET_NAME (symbolP), DO_NOT_STRIP))
1376 && real_symbolP != symbolP)
1377 {
1378 /* FIXME-SOON: where do dups come from?
1379 Maybe tag references before definitions? xoxorich. */
1380 /* Move the debug data from the debug symbol to the
1381 real symbol. Do NOT do the oposite (i.e. move from
1382 real symbol to debug symbol and remove real symbol from the
1383 list.) Because some pointers refer to the real symbol
1384 whereas no pointers refer to the debug symbol. */
1385 c_symbol_merge (symbolP, real_symbolP);
1386 /* Replace the current symbol by the real one */
1387 /* The symbols will never be the last or the first
1388 because : 1st symbol is .file and 3 last symbols are
1389 .text, .data, .bss */
1390 symbol_remove (real_symbolP, &symbol_rootP, &symbol_lastP);
1391 symbol_insert (real_symbolP, symbolP, &symbol_rootP, &symbol_lastP);
1392 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
1393 symbolP = real_symbolP;
1394 } /* if not local but dup'd */
1395
1396 if (flagseen['R'] && (S_GET_SEGMENT (symbolP) == SEG_E1))
1397 {
1398 S_SET_SEGMENT (symbolP, SEG_E0);
1399 } /* push data into text */
1400
1401 S_SET_VALUE (symbolP,
1402 S_GET_VALUE (symbolP) + symbolP->sy_frag->fr_address);
1403
1404 if (!S_IS_DEFINED (symbolP) && !SF_GET_LOCAL (symbolP))
1405 {
1406 S_SET_EXTERNAL (symbolP);
1407 }
1408 else if (S_GET_STORAGE_CLASS (symbolP) == C_NULL)
1409 {
1410 if (S_GET_SEGMENT (symbolP) == SEG_E0)
1411 {
1412 S_SET_STORAGE_CLASS (symbolP, C_LABEL);
1413 }
1414 else
1415 {
1416 S_SET_STORAGE_CLASS (symbolP, C_STAT);
1417 }
1418 }
1419
1420 /* Mainly to speed up if not -g */
1421 if (SF_GET_PROCESS (symbolP))
1422 {
1423 /* Handle the nested blocks auxiliary info. */
1424 if (S_GET_STORAGE_CLASS (symbolP) == C_BLOCK)
1425 {
1426 if (!strcmp (S_GET_NAME (symbolP), ".bb"))
1427 stack_push (block_stack, (char *) &symbolP);
1428 else
1429 { /* .eb */
1430 register symbolS *begin_symbolP;
1431 begin_symbolP = *(symbolS **) stack_pop (block_stack);
1432 if (begin_symbolP == (symbolS *) 0)
1433 as_warn ("mismatched .eb");
1434 else
1435 SA_SET_SYM_ENDNDX (begin_symbolP, symbol_number + 2);
1436 }
1437 }
1438 /* If we are able to identify the type of a function, and we
1439 are out of a function (last_functionP == 0) then, the
1440 function symbol will be associated with an auxiliary
1441 entry. */
1442 if (last_functionP == (symbolS *) 0 &&
1443 SF_GET_FUNCTION (symbolP))
1444 {
1445 last_functionP = symbolP;
1446
1447 if (S_GET_NUMBER_AUXILIARY (symbolP) < 1)
1448 {
1449 S_SET_NUMBER_AUXILIARY (symbolP, 1);
1450 } /* make it at least 1 */
1451
1452 /* Clobber possible stale .dim information. */
1453 #if 0
1454 /* Iffed out by steve - this fries the lnnoptr info too */
1455 bzero (symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen,
1456 sizeof (symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen));
1457 #endif
1458 }
1459 /* The C_FCN doesn't need any additional information. I
1460 don't even know if this is needed for sdb. But the
1461 standard assembler generates it, so... */
1462 if (S_GET_STORAGE_CLASS (symbolP) == C_EFCN)
1463 {
1464 if (last_functionP == (symbolS *) 0)
1465 as_fatal ("C_EFCN symbol out of scope");
1466 SA_SET_SYM_FSIZE (last_functionP,
1467 (long) (S_GET_VALUE (symbolP) -
1468 S_GET_VALUE (last_functionP)));
1469 SA_SET_SYM_ENDNDX (last_functionP, symbol_number);
1470 last_functionP = (symbolS *) 0;
1471 }
1472 }
1473 }
1474 else if (SF_GET_TAG (symbolP))
1475 {
1476 /* First descriptor of a structure must point to
1477 the first slot after the structure description. */
1478 last_tagP = symbolP;
1479
1480 }
1481 else if (S_GET_STORAGE_CLASS (symbolP) == C_EOS)
1482 {
1483 /* +2 take in account the current symbol */
1484 SA_SET_SYM_ENDNDX (last_tagP, symbol_number + 2);
1485 }
1486 else if (S_GET_STORAGE_CLASS (symbolP) == C_FILE)
1487 {
1488 if (S_GET_VALUE (symbolP))
1489 {
1490 S_SET_VALUE (symbolP, last_file_symno);
1491 last_file_symno = symbol_number;
1492 } /* no one points at the first .file symbol */
1493 } /* if debug or tag or eos or file */
1494
1495 /* We must put the external symbols apart. The loader
1496 does not bomb if we do not. But the references in
1497 the endndx field for a .bb symbol are not corrected
1498 if an external symbol is removed between .bb and .be.
1499 I.e in the following case :
1500 [20] .bb endndx = 22
1501 [21] foo external
1502 [22] .be
1503 ld will move the symbol 21 to the end of the list but
1504 endndx will still be 22 instead of 21. */
1505
1506
1507 if (SF_GET_LOCAL (symbolP))
1508 {
1509 /* remove C_EFCN and LOCAL (L...) symbols */
1510 /* next pointer remains valid */
1511 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
1512
1513 }
1514 else if (!S_IS_DEFINED (symbolP)
1515 && !S_IS_DEBUG (symbolP)
1516 && !SF_GET_STATICS (symbolP) &&
1517 S_GET_STORAGE_CLASS (symbolP) == C_EXT)
1518 { /* C_EXT && !SF_GET_FUNCTION(symbolP)) */
1519 /* if external, Remove from the list */
1520 symbolS *hold = symbol_previous (symbolP);
1521
1522 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
1523 symbol_clear_list_pointers (symbolP);
1524 symbol_append (symbolP, symbol_extern_lastP, &symbol_externP, &symbol_extern_lastP);
1525 symbolP = hold;
1526 }
1527 else
1528 {
1529 if (SF_GET_STRING (symbolP))
1530 {
1531 symbolP->sy_name_offset = string_byte_count;
1532 string_byte_count += strlen (S_GET_NAME (symbolP)) + 1;
1533 }
1534 else
1535 {
1536 symbolP->sy_name_offset = 0;
1537 } /* fix "long" names */
1538
1539 symbolP->sy_number = symbol_number;
1540 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (symbolP);
1541 } /* if local symbol */
1542 } /* traverse the symbol list */
1543 return symbol_number;
1544
1545 }
1546
1547
1548 static unsigned int
1549 DEFUN_VOID (glue_symbols)
1550 {
1551 unsigned int symbol_number = 0;
1552 symbolS *symbolP;
1553 for (symbolP = symbol_externP; symbol_externP;)
1554 {
1555 symbolS *tmp = symbol_externP;
1556
1557 /* append */
1558 symbol_remove (tmp, &symbol_externP, &symbol_extern_lastP);
1559 symbol_append (tmp, symbol_lastP, &symbol_rootP, &symbol_lastP);
1560
1561 /* and process */
1562 if (SF_GET_STRING (tmp))
1563 {
1564 tmp->sy_name_offset = string_byte_count;
1565 string_byte_count += strlen (S_GET_NAME (tmp)) + 1;
1566 }
1567 else
1568 {
1569 tmp->sy_name_offset = 0;
1570 } /* fix "long" names */
1571
1572 tmp->sy_number = symbol_number;
1573 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (tmp);
1574 } /* append the entire extern chain */
1575 return symbol_number;
1576
1577 }
1578
1579 static unsigned int
1580 DEFUN_VOID (tie_tags)
1581 {
1582 unsigned int symbol_number = 0;
1583
1584 symbolS *symbolP;
1585 for (symbolP = symbol_rootP; symbolP; symbolP =
1586 symbol_next (symbolP))
1587 {
1588 symbolP->sy_number = symbol_number;
1589
1590
1591
1592 if (SF_GET_TAGGED (symbolP))
1593 {
1594 SA_SET_SYM_TAGNDX
1595 (symbolP,
1596 ((symbolS *) SA_GET_SYM_TAGNDX (symbolP))->sy_number);
1597 }
1598
1599 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (symbolP);
1600 }
1601 return symbol_number;
1602
1603 }
1604
1605 static void
1606 DEFUN (crawl_symbols, (h, abfd),
1607 object_headers *h AND
1608 bfd * abfd)
1609 {
1610
1611 unsigned int i;
1612 unsigned int ptr = 0;
1613
1614
1615 symbolS *symbolP;
1616
1617 /* Initialize the stack used to keep track of the matching .bb .be */
1618
1619 block_stack = stack_init (512, sizeof (symbolS *));
1620 /* JF deal with forward references first... */
1621 for (symbolP = symbol_rootP;
1622 symbolP;
1623 symbolP = symbol_next (symbolP))
1624 {
1625
1626 if (symbolP->sy_forward)
1627 {
1628 S_SET_VALUE (symbolP, (S_GET_VALUE (symbolP)
1629 + S_GET_VALUE (symbolP->sy_forward)
1630 + symbolP->sy_forward->sy_frag->fr_address));
1631
1632 if (SF_GET_GET_SEGMENT (symbolP))
1633 {
1634 S_SET_SEGMENT (symbolP, S_GET_SEGMENT (symbolP->sy_forward));
1635 } /* forward segment also */
1636
1637 symbolP->sy_forward = 0;
1638 } /* if it has a forward reference */
1639 } /* walk the symbol chain */
1640
1641
1642 /* The symbol list should be ordered according to the following sequence
1643 * order :
1644 * . .file symbol
1645 * . debug entries for functions
1646 * . fake symbols for the sections, including.text .data and .bss
1647 * . defined symbols
1648 * . undefined symbols
1649 * But this is not mandatory. The only important point is to put the
1650 * undefined symbols at the end of the list.
1651 */
1652
1653 if (symbol_rootP == NULL
1654 || S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
1655 {
1656 c_dot_file_symbol ("fake");
1657 }
1658 /* Is there a .file symbol ? If not insert one at the beginning. */
1659
1660 /*
1661 * Build up static symbols for the sections, they are filled in later
1662 */
1663
1664
1665 for (i = SEG_E0; i < SEG_E9; i++)
1666 {
1667 if (segment_info[i].scnhdr.s_name[0])
1668 {
1669 char name[9];
1670
1671 strncpy (name, segment_info[i].scnhdr.s_name, 8);
1672 name[8] = '\0';
1673 segment_info[i].dot = c_section_symbol (name, i - SEG_E0 + 1);
1674 }
1675 }
1676
1677
1678 /* Take all the externals out and put them into another chain */
1679 H_SET_SYMBOL_TABLE_SIZE (h, yank_symbols ());
1680 /* Take the externals and glue them onto the end.*/
1681 H_SET_SYMBOL_TABLE_SIZE (h, H_GET_SYMBOL_COUNT (h) + glue_symbols ());
1682
1683 H_SET_SYMBOL_TABLE_SIZE (h, tie_tags ());
1684 know (symbol_externP == NULL);
1685 know (symbol_extern_lastP == NULL);
1686
1687 return;
1688 }
1689
1690 /*
1691 * Find strings by crawling along symbol table chain.
1692 */
1693
1694 void
1695 DEFUN (w_strings, (where),
1696 char *where)
1697 {
1698 symbolS *symbolP;
1699
1700 /* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
1701 md_number_to_chars (where, string_byte_count, sizeof (string_byte_count));
1702 where += sizeof (string_byte_count);
1703 for (symbolP = symbol_rootP;
1704 symbolP;
1705 symbolP = symbol_next (symbolP))
1706 {
1707 unsigned int size;
1708
1709 if (SF_GET_STRING (symbolP))
1710 {
1711 size = strlen (S_GET_NAME (symbolP)) + 1;
1712
1713 memcpy (where, S_GET_NAME (symbolP), size);
1714 where += size;
1715
1716 }
1717 }
1718
1719 }
1720
1721 static void
1722 DEFUN (do_linenos_for, (abfd, h, file_cursor),
1723 bfd * abfd AND
1724 object_headers * h AND
1725 unsigned long *file_cursor)
1726 {
1727 unsigned int idx;
1728 unsigned long start = *file_cursor;
1729
1730 for (idx = SEG_E0; idx < SEG_E9; idx++)
1731 {
1732 segment_info_type *s = segment_info + idx;
1733
1734
1735 if (s->scnhdr.s_nlnno != 0)
1736 {
1737 struct lineno_list *line_ptr;
1738
1739 struct external_lineno *buffer =
1740 (struct external_lineno *) xmalloc (s->scnhdr.s_nlnno * LINESZ);
1741
1742 struct external_lineno *dst = buffer;
1743
1744 /* Run through the table we've built and turn it into its external
1745 form, take this chance to remove duplicates */
1746
1747 for (line_ptr = s->lineno_list_head;
1748 line_ptr != (struct lineno_list *) NULL;
1749 line_ptr = line_ptr->next)
1750 {
1751
1752 if (line_ptr->line.l_lnno == 0)
1753 {
1754 /* Turn a pointer to a symbol into the symbols' index */
1755 line_ptr->line.l_addr.l_symndx =
1756 ((symbolS *) line_ptr->line.l_addr.l_symndx)->sy_number;
1757 }
1758 else
1759 {
1760 line_ptr->line.l_addr.l_paddr += ((struct frag *) (line_ptr->frag))->fr_address;
1761 }
1762
1763
1764 (void) bfd_coff_swap_lineno_out (abfd, &(line_ptr->line), dst);
1765 dst++;
1766
1767 }
1768
1769 s->scnhdr.s_lnnoptr = *file_cursor;
1770
1771 bfd_write (buffer, 1, s->scnhdr.s_nlnno * LINESZ, abfd);
1772 free (buffer);
1773
1774 *file_cursor += s->scnhdr.s_nlnno * LINESZ;
1775 }
1776 }
1777 H_SET_LINENO_SIZE (h, *file_cursor - start);
1778 }
1779
1780
1781 /* Now we run through the list of frag chains in a segment and
1782 make all the subsegment frags appear at the end of the
1783 list, as if the seg 0 was extra long */
1784
1785 static void
1786 DEFUN_VOID (remove_subsegs)
1787 {
1788 unsigned int i;
1789
1790 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
1791 {
1792 frchainS *head = segment_info[i].frchainP;
1793 fragS dummy;
1794 fragS *prev_frag = &dummy;
1795
1796 while (head && head->frch_seg == i)
1797 {
1798 prev_frag->fr_next = head->frch_root;
1799 prev_frag = head->frch_last;
1800 head = head->frch_next;
1801 }
1802 prev_frag->fr_next = 0;
1803 }
1804 }
1805
1806 int machine;
1807 int coff_flags;
1808 extern void
1809 DEFUN_VOID (write_object_file)
1810 {
1811 int i;
1812 struct frchain *frchain_ptr;
1813
1814 object_headers headers;
1815 unsigned long file_cursor;
1816 bfd *abfd;
1817 unsigned int addr;
1818 abfd = bfd_openw (out_file_name, TARGET_FORMAT);
1819
1820
1821 if (abfd == 0)
1822 {
1823 as_perror ("FATAL: Can't create %s", out_file_name);
1824 exit (42);
1825 }
1826 bfd_set_format (abfd, bfd_object);
1827 bfd_set_arch_mach (abfd, BFD_ARCH, machine);
1828
1829 string_byte_count = 4;
1830
1831 for (frchain_ptr = frchain_root;
1832 frchain_ptr != (struct frchain *) NULL;
1833 frchain_ptr = frchain_ptr->frch_next)
1834 {
1835 /* Run through all the sub-segments and align them up. Also close any
1836 open frags. We tack a .fill onto the end of the frag chain so
1837 that any .align's size can be worked by looking at the next
1838 frag */
1839
1840 subseg_new (frchain_ptr->frch_seg, frchain_ptr->frch_subseg);
1841 #ifndef SUB_SEGMENT_ALIGN
1842 #define SUB_SEGMENT_ALIGN(SEG) 1
1843 #endif
1844 frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE);
1845 frag_wane (frag_now);
1846 frag_now->fr_fix = 0;
1847 know (frag_now->fr_next == NULL);
1848 }
1849
1850
1851 remove_subsegs ();
1852
1853
1854 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
1855 {
1856 relax_segment (segment_info[i].frchainP->frch_root, i);
1857 }
1858
1859 H_SET_NUMBER_OF_SECTIONS (&headers, 0);
1860
1861 /* Find out how big the sections are, and set the addresses. */
1862 addr = 0;
1863 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
1864 {
1865 long size;
1866
1867 segment_info[i].scnhdr.s_paddr = addr;
1868 segment_info[i].scnhdr.s_vaddr = addr;
1869
1870 if (segment_info[i].scnhdr.s_name[0])
1871 {
1872 H_SET_NUMBER_OF_SECTIONS (&headers,
1873 H_GET_NUMBER_OF_SECTIONS (&headers) + 1);
1874 }
1875
1876 size = size_section (abfd, i);
1877 addr += size;
1878
1879 if (i == SEG_E0)
1880 H_SET_TEXT_SIZE (&headers, size);
1881 else if (i == SEG_E1)
1882 H_SET_DATA_SIZE (&headers, size);
1883 else if (i == SEG_E2)
1884 H_SET_BSS_SIZE (&headers, size);
1885 }
1886
1887 /* Turn the gas native symbol table shape into a coff symbol table */
1888 crawl_symbols (&headers, abfd);
1889
1890 if (string_byte_count == 4)
1891 string_byte_count = 0;
1892
1893 H_SET_STRING_SIZE (&headers, string_byte_count);
1894
1895 #if !defined(TC_H8300) && !defined(TC_Z8K)
1896 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
1897 {
1898 fixup_mdeps (segment_info[i].frchainP->frch_root, &headers, i);
1899 fixup_segment (&segment_info[i], i);
1900 }
1901 #endif
1902
1903 file_cursor = H_GET_TEXT_FILE_OFFSET (&headers);
1904
1905 bfd_seek (abfd, file_cursor, 0);
1906
1907 /* Plant the data */
1908
1909 fill_section (abfd, &headers, &file_cursor);
1910
1911 do_relocs_for (abfd, &headers, &file_cursor);
1912
1913 do_linenos_for (abfd, &headers, &file_cursor);
1914
1915 H_SET_FILE_MAGIC_NUMBER (&headers, COFF_MAGIC);
1916 #ifndef OBJ_COFF_OMIT_TIMESTAMP
1917 H_SET_TIME_STAMP (&headers, (long)time((long*)0));
1918 #else
1919 H_SET_TIME_STAMP (&headers, 0);
1920 #endif
1921
1922 #ifdef KEEP_RELOC_INFO
1923 H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
1924 COFF_FLAGS | coff_flags));
1925 #else
1926 H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
1927 (H_GET_RELOCATION_SIZE(&headers) ? 0 : F_RELFLG) |
1928 COFF_FLAGS | coff_flags));
1929 #endif
1930
1931 {
1932 unsigned int symtable_size = H_GET_SYMBOL_TABLE_SIZE (&headers);
1933 char *buffer1 = xmalloc (symtable_size + string_byte_count + 1);
1934 char *ptr = buffer1;
1935 H_SET_SYMBOL_TABLE_POINTER (&headers, bfd_tell (abfd));
1936 w_symbols (abfd, buffer1, symbol_rootP);
1937 if (string_byte_count > 0)
1938 w_strings (buffer1 + symtable_size);
1939 bfd_write (buffer1, 1, symtable_size + string_byte_count, abfd);
1940 free (buffer1);
1941 }
1942
1943 coff_header_append (abfd, &headers);
1944
1945 if (bfd_close_all_done (abfd) == false)
1946 as_fatal ("Can't close %s: %s", out_file_name,
1947 bfd_errmsg (bfd_error));
1948 }
1949
1950
1951 static void
1952 DEFUN (change_to_section, (name, len, exp),
1953 char *name AND
1954 unsigned int len AND
1955 unsigned int exp)
1956 {
1957 unsigned int i;
1958 /* Find out if we've already got a section of this name etc */
1959 for (i = SEG_E0; i < SEG_E9 && segment_info[i].scnhdr.s_name[0]; i++)
1960 {
1961 if (strncmp (segment_info[i].scnhdr.s_name, name, len) == 0)
1962 {
1963 subseg_new (i, exp);
1964 return;
1965
1966 }
1967 }
1968 /* No section, add one */
1969 strncpy (segment_info[i].scnhdr.s_name, name, 8);
1970 subseg_new (i, exp);
1971 }
1972
1973 /*
1974 * implement the .section pseudo op:
1975 * .section name {, "flags"}
1976 * ^ ^
1977 * | +--- optional flags: 'b' for bss
1978 * | 'i' for info
1979 * +-- section name 'l' for lib
1980 * 'n' for noload
1981 * 'o' for over
1982 * 'w' for data
1983 * 'x' for text
1984 * But if the argument is not a quoted string, treat it as a
1985 * subsegment number.
1986 */
1987
1988 void
1989 DEFUN_VOID (obj_coff_section)
1990 {
1991 /* Strip out the section name */
1992 char *section_name;
1993 char *section_name_end;
1994 char c;
1995 int argp;
1996 unsigned int len;
1997 unsigned int exp;
1998 long flags;
1999
2000 section_name = input_line_pointer;
2001 c = get_symbol_end ();
2002 section_name_end = input_line_pointer;
2003
2004 len = section_name_end - section_name;
2005 input_line_pointer++;
2006 SKIP_WHITESPACE ();
2007
2008 argp = 0;
2009 if (c == ',')
2010 argp = 1;
2011 else if (*input_line_pointer == ',')
2012 {
2013 argp = 1;
2014 ++input_line_pointer;
2015 SKIP_WHITESPACE ();
2016 }
2017
2018 exp = 0;
2019 flags = 0;
2020 if (argp)
2021 {
2022 if (*input_line_pointer != '"')
2023 exp = get_absolute_expression ();
2024 else
2025 {
2026 ++input_line_pointer;
2027 while (*input_line_pointer != '"'
2028 && ! is_end_of_line[*input_line_pointer])
2029 {
2030 switch (*input_line_pointer)
2031 {
2032 case 'b': flags |= STYP_BSS; break;
2033 case 'i': flags |= STYP_INFO; break;
2034 case 'l': flags |= STYP_LIB; break;
2035 case 'n': flags |= STYP_NOLOAD; break;
2036 case 'o': flags |= STYP_OVER; break;
2037 case 'w': flags |= STYP_DATA; break;
2038 case 'x': flags |= STYP_TEXT; break;
2039 default:
2040 as_warn("unknown section attribute '%c'",
2041 *input_line_pointer);
2042 break;
2043 }
2044 ++input_line_pointer;
2045 }
2046 if (*input_line_pointer == '"')
2047 ++input_line_pointer;
2048 }
2049 }
2050
2051 change_to_section (section_name, len, exp);
2052
2053 segment_info[now_seg].scnhdr.s_flags |= flags;
2054
2055 *section_name_end = c;
2056 }
2057
2058
2059 static void
2060 obj_coff_text ()
2061 {
2062 change_to_section (".text", 5, get_absolute_expression ());
2063 }
2064
2065
2066 static void
2067 obj_coff_data ()
2068 {
2069 change_to_section (".data", 5, get_absolute_expression ());
2070 }
2071
2072 static void
2073 obj_coff_bss()
2074 {
2075 if (*input_line_pointer == '\n') /* .bss */
2076 change_to_section(".bss",4, get_absolute_expression());
2077 else /* .bss id,expr */
2078 obj_coff_lcomm();
2079 }
2080
2081 static void
2082 obj_coff_ident()
2083 {
2084 segT current_seg = now_seg; /* save current seg */
2085 subsegT current_subseg = now_subseg;
2086 change_to_section (".comment", 8, 0); /* .comment seg */
2087 stringer (1); /* read string */
2088 subseg_new (current_seg, current_subseg); /* restore current seg */
2089 }
2090
2091 void
2092 c_symbol_merge (debug, normal)
2093 symbolS *debug;
2094 symbolS *normal;
2095 {
2096 S_SET_DATA_TYPE (normal, S_GET_DATA_TYPE (debug));
2097 S_SET_STORAGE_CLASS (normal, S_GET_STORAGE_CLASS (debug));
2098
2099 if (S_GET_NUMBER_AUXILIARY (debug) > S_GET_NUMBER_AUXILIARY (normal))
2100 {
2101 S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));
2102 } /* take the most we have */
2103
2104 if (S_GET_NUMBER_AUXILIARY (debug) > 0)
2105 {
2106 memcpy ((char *) &normal->sy_symbol.ost_auxent[0], (char *) &debug->sy_symbol.ost_auxent[0], S_GET_NUMBER_AUXILIARY (debug) * AUXESZ);
2107 } /* Move all the auxiliary information */
2108
2109 /* Move the debug flags. */
2110 SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
2111 } /* c_symbol_merge() */
2112
2113 static int
2114 DEFUN (c_line_new, (symbol, paddr, line_number, frag),
2115 symbolS * symbol AND
2116 long paddr AND
2117 unsigned short line_number AND
2118 fragS * frag)
2119 {
2120 struct lineno_list *new_line =
2121 (struct lineno_list *) xmalloc (sizeof (struct lineno_list));
2122
2123 segment_info_type *s = segment_info + now_seg;
2124 new_line->line.l_lnno = line_number;
2125
2126 if (line_number == 0)
2127 {
2128 last_line_symbol = symbol;
2129 new_line->line.l_addr.l_symndx = (long) symbol;
2130 }
2131 else
2132 {
2133 new_line->line.l_addr.l_paddr = paddr;
2134 }
2135
2136 new_line->frag = (char *) frag;
2137 new_line->next = (struct lineno_list *) NULL;
2138
2139
2140 if (s->lineno_list_head == (struct lineno_list *) NULL)
2141 {
2142 s->lineno_list_head = new_line;
2143 }
2144 else
2145 {
2146 s->lineno_list_tail->next = new_line;
2147 }
2148 s->lineno_list_tail = new_line;
2149 return LINESZ * s->scnhdr.s_nlnno++;
2150 }
2151
2152 void
2153 c_dot_file_symbol (filename)
2154 char *filename;
2155 {
2156 symbolS *symbolP;
2157
2158 symbolP = symbol_new (".file",
2159 SEG_DEBUG,
2160 0,
2161 &zero_address_frag);
2162
2163 S_SET_STORAGE_CLASS (symbolP, C_FILE);
2164 S_SET_NUMBER_AUXILIARY (symbolP, 1);
2165 SA_SET_FILE_FNAME (symbolP, filename);
2166 #ifndef NO_LISTING
2167 {
2168 extern int listing;
2169 if (listing)
2170 {
2171 listing_source_file (filename);
2172 }
2173
2174 }
2175
2176 #endif
2177 SF_SET_DEBUG (symbolP);
2178 S_SET_VALUE (symbolP, (long) previous_file_symbol);
2179
2180 previous_file_symbol = symbolP;
2181
2182 /* Make sure that the symbol is first on the symbol chain */
2183 if (symbol_rootP != symbolP)
2184 {
2185 if (symbolP == symbol_lastP)
2186 {
2187 symbol_lastP = symbol_lastP->sy_previous;
2188 } /* if it was the last thing on the list */
2189
2190 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2191 symbol_insert (symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
2192 symbol_rootP = symbolP;
2193 } /* if not first on the list */
2194
2195 } /* c_dot_file_symbol() */
2196
2197 /*
2198 * Build a 'section static' symbol.
2199 */
2200
2201 symbolS *
2202 c_section_symbol (name, idx)
2203 char *name;
2204 int idx;
2205 {
2206 symbolS *symbolP;
2207
2208 symbolP = symbol_new (name, idx,
2209 0,
2210 &zero_address_frag);
2211
2212 S_SET_STORAGE_CLASS (symbolP, C_STAT);
2213 S_SET_NUMBER_AUXILIARY (symbolP, 1);
2214
2215 SF_SET_STATICS (symbolP);
2216
2217 return symbolP;
2218 } /* c_section_symbol() */
2219
2220 static void
2221 DEFUN (w_symbols, (abfd, where, symbol_rootP),
2222 bfd * abfd AND
2223 char *where AND
2224 symbolS * symbol_rootP)
2225 {
2226 symbolS *symbolP;
2227 unsigned int i;
2228
2229 /* First fill in those values we have only just worked out */
2230 for (i = SEG_E0; i < SEG_E9; i++)
2231 {
2232 symbolP = segment_info[i].dot;
2233 if (symbolP)
2234 {
2235
2236 SA_SET_SCN_SCNLEN (symbolP, segment_info[i].scnhdr.s_size);
2237 SA_SET_SCN_NRELOC (symbolP, segment_info[i].scnhdr.s_nreloc);
2238 SA_SET_SCN_NLINNO (symbolP, segment_info[i].scnhdr.s_nlnno);
2239
2240 }
2241 }
2242
2243 /*
2244 * Emit all symbols left in the symbol chain.
2245 */
2246 for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
2247 {
2248 /* Used to save the offset of the name. It is used to point
2249 to the string in memory but must be a file offset. */
2250 register char *temp;
2251
2252 tc_coff_symbol_emit_hook (symbolP);
2253
2254 temp = S_GET_NAME (symbolP);
2255 if (SF_GET_STRING (symbolP))
2256 {
2257 S_SET_OFFSET (symbolP, symbolP->sy_name_offset);
2258 S_SET_ZEROES (symbolP, 0);
2259 }
2260 else
2261 {
2262 bzero (symbolP->sy_symbol.ost_entry.n_name, SYMNMLEN);
2263 strncpy (symbolP->sy_symbol.ost_entry.n_name, temp, SYMNMLEN);
2264 }
2265 where = symbol_to_chars (abfd, where, symbolP);
2266 S_SET_NAME (symbolP, temp);
2267 }
2268
2269 } /* w_symbols() */
2270
2271 static void
2272 DEFUN_VOID (obj_coff_lcomm)
2273 {
2274 char *name;
2275 char c;
2276 int temp;
2277 char *p;
2278
2279 symbolS *symbolP;
2280 name = input_line_pointer;
2281
2282 c = get_symbol_end ();
2283 p = input_line_pointer;
2284 *p = c;
2285 SKIP_WHITESPACE ();
2286 if (*input_line_pointer != ',')
2287 {
2288 as_bad ("Expected comma after name");
2289 ignore_rest_of_line ();
2290 return;
2291 }
2292 if (*input_line_pointer == '\n')
2293 {
2294 as_bad ("Missing size expression");
2295 return;
2296 }
2297 input_line_pointer++;
2298 if ((temp = get_absolute_expression ()) < 0)
2299 {
2300 as_warn ("lcomm length (%d.) <0! Ignored.", temp);
2301 ignore_rest_of_line ();
2302 return;
2303 }
2304 *p = 0;
2305
2306 symbolP = symbol_find_or_make(name);
2307
2308 if (S_GET_SEGMENT(symbolP) == SEG_UNKNOWN &&
2309 S_GET_VALUE(symbolP) == 0)
2310 {
2311 if (! need_pass_2)
2312 {
2313 char *p;
2314 segT current_seg = now_seg; /* save current seg */
2315 subsegT current_subseg = now_subseg;
2316
2317 subseg_new (SEG_E2, 1);
2318 symbolP->sy_frag = frag_now;
2319 p = frag_var(rs_org, 1, 1, (relax_substateT)0, symbolP,
2320 temp, (char *)0);
2321 *p = 0;
2322 subseg_new (current_seg, current_subseg); /* restore current seg */
2323 S_SET_SEGMENT(symbolP, SEG_E2);
2324 S_SET_STORAGE_CLASS(symbolP, C_STAT);
2325 }
2326 }
2327 else
2328 as_bad("Symbol %s already defined", name);
2329
2330 demand_empty_rest_of_line();
2331 }
2332
2333 static void
2334 DEFUN (fixup_mdeps, (frags, h, this_segment),
2335 fragS * frags AND
2336 object_headers * h AND
2337 segT this_segment)
2338 {
2339 subseg_change (this_segment, 0);
2340 while (frags)
2341 {
2342 switch (frags->fr_type)
2343 {
2344 case rs_align:
2345 case rs_org:
2346 frags->fr_type = rs_fill;
2347 frags->fr_offset =
2348 (frags->fr_next->fr_address - frags->fr_address - frags->fr_fix);
2349 break;
2350 case rs_machine_dependent:
2351 md_convert_frag (h, frags);
2352 frag_wane (frags);
2353 break;
2354 default:
2355 ;
2356 }
2357 frags = frags->fr_next;
2358 }
2359 }
2360
2361 #if 1
2362 static void
2363 DEFUN (fixup_segment, (segP, this_segment_type),
2364 segment_info_type * segP AND
2365 segT this_segment_type)
2366 {
2367 register fixS * fixP;
2368 register symbolS *add_symbolP;
2369 register symbolS *sub_symbolP;
2370 register long add_number;
2371 register int size;
2372 register char *place;
2373 register long where;
2374 register char pcrel;
2375 register fragS *fragP;
2376 register segT add_symbol_segment = SEG_ABSOLUTE;
2377
2378
2379 for (fixP = segP->fix_root; fixP; fixP = fixP->fx_next)
2380 {
2381 fragP = fixP->fx_frag;
2382 know (fragP);
2383 where = fixP->fx_where;
2384 place = fragP->fr_literal + where;
2385 size = fixP->fx_size;
2386 add_symbolP = fixP->fx_addsy;
2387 #ifdef TC_I960
2388 if (fixP->fx_callj && TC_S_IS_CALLNAME (add_symbolP))
2389 {
2390 /* Relocation should be done via the
2391 associated 'bal' entry point
2392 symbol. */
2393
2394 if (!TC_S_IS_BALNAME (tc_get_bal_of_call (add_symbolP)))
2395 {
2396 as_bad ("No 'bal' entry point for leafproc %s",
2397 S_GET_NAME (add_symbolP));
2398 continue;
2399 }
2400 fixP->fx_addsy = add_symbolP = tc_get_bal_of_call (add_symbolP);
2401 } /* callj relocation */
2402 #endif
2403 sub_symbolP = fixP->fx_subsy;
2404 add_number = fixP->fx_offset;
2405 pcrel = fixP->fx_pcrel;
2406
2407 if (add_symbolP)
2408 {
2409 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
2410 } /* if there is an addend */
2411
2412 if (sub_symbolP)
2413 {
2414 if (!add_symbolP)
2415 {
2416 /* Its just -sym */
2417 if (S_GET_SEGMENT (sub_symbolP) != SEG_ABSOLUTE)
2418 {
2419 as_bad ("Negative of non-absolute symbol %s", S_GET_NAME (sub_symbolP));
2420 } /* not absolute */
2421
2422 add_number -= S_GET_VALUE (sub_symbolP);
2423 fixP->fx_subsy = 0;
2424
2425 /* if sub_symbol is in the same segment that add_symbol
2426 and add_symbol is either in DATA, TEXT, BSS or ABSOLUTE */
2427 }
2428 else if ((S_GET_SEGMENT (sub_symbolP) == add_symbol_segment)
2429 && (SEG_NORMAL (add_symbol_segment)
2430 || (add_symbol_segment == SEG_ABSOLUTE)))
2431 {
2432 /* Difference of 2 symbols from same segment. */
2433 /* Can't make difference of 2 undefineds: 'value' means */
2434 /* something different for N_UNDF. */
2435 #ifdef TC_I960
2436 /* Makes no sense to use the difference of 2 arbitrary symbols
2437 as the target of a call instruction. */
2438 if (fixP->fx_callj)
2439 {
2440 as_bad ("callj to difference of 2 symbols");
2441 }
2442 #endif /* TC_I960 */
2443 add_number += S_GET_VALUE (add_symbolP) -
2444 S_GET_VALUE (sub_symbolP);
2445
2446 add_symbolP = NULL;
2447 fixP->fx_addsy = NULL;
2448 }
2449 else
2450 {
2451 /* Different segments in subtraction. */
2452 know (!(S_IS_EXTERNAL (sub_symbolP) && (S_GET_SEGMENT (sub_symbolP) == SEG_ABSOLUTE)));
2453
2454 if ((S_GET_SEGMENT (sub_symbolP) == SEG_ABSOLUTE))
2455 {
2456 add_number -= S_GET_VALUE (sub_symbolP);
2457 }
2458 else
2459 {
2460 as_bad ("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %d.",
2461 segment_name (S_GET_SEGMENT (sub_symbolP)),
2462 S_GET_NAME (sub_symbolP), fragP->fr_address + where);
2463 } /* if absolute */
2464 }
2465 } /* if sub_symbolP */
2466
2467 if (add_symbolP)
2468 {
2469 if (add_symbol_segment == this_segment_type && pcrel)
2470 {
2471 /*
2472 * This fixup was made when the symbol's segment was
2473 * SEG_UNKNOWN, but it is now in the local segment.
2474 * So we know how to do the address without relocation.
2475 */
2476 #ifdef TC_I960
2477 /* reloc_callj() may replace a 'call' with a 'calls' or a 'bal',
2478 * in which cases it modifies *fixP as appropriate. In the case
2479 * of a 'calls', no further work is required, and *fixP has been
2480 * set up to make the rest of the code below a no-op.
2481 */
2482 reloc_callj (fixP);
2483 #endif /* TC_I960 */
2484
2485 add_number += S_GET_VALUE (add_symbolP);
2486 add_number -= md_pcrel_from (fixP);
2487 #ifdef TC_I386
2488 /* On the 386 we must adjust by the segment
2489 vaddr as well. Ian Taylor. */
2490 add_number -= segP->scnhdr.s_vaddr;
2491 #endif
2492 pcrel = 0; /* Lie. Don't want further pcrel processing. */
2493 fixP->fx_addsy = NULL; /* No relocations please. */
2494 }
2495 else
2496 {
2497 switch (add_symbol_segment)
2498 {
2499 case SEG_ABSOLUTE:
2500 #ifdef TC_I960
2501 reloc_callj (fixP); /* See comment about reloc_callj() above*/
2502 #endif /* TC_I960 */
2503 add_number += S_GET_VALUE (add_symbolP);
2504 fixP->fx_addsy = NULL;
2505 add_symbolP = NULL;
2506 break;
2507 default:
2508
2509 #ifdef TC_A29K
2510 /* This really should be handled in the linker, but
2511 backward compatibility forbids. */
2512 add_number += S_GET_VALUE (add_symbolP);
2513 #else
2514 add_number += S_GET_VALUE (add_symbolP) +
2515 segment_info[S_GET_SEGMENT (add_symbolP)].scnhdr.s_paddr;
2516 #endif
2517 break;
2518
2519 case SEG_UNKNOWN:
2520 #ifdef TC_I960
2521 if ((int) fixP->fx_bit_fixP == 13)
2522 {
2523 /* This is a COBR instruction. They have only a
2524 * 13-bit displacement and are only to be used
2525 * for local branches: flag as error, don't generate
2526 * relocation.
2527 */
2528 as_bad ("can't use COBR format with external label");
2529 fixP->fx_addsy = NULL; /* No relocations please. */
2530 continue;
2531 } /* COBR */
2532 #endif /* TC_I960 */
2533 #ifdef TC_I386
2534 /* 386 COFF uses a peculiar format in
2535 which the value of a common symbol is
2536 stored in the .text segment (I've
2537 checked this on SVR3.2 and SCO 3.2.2)
2538 Ian Taylor <ian@cygnus.com>. */
2539 if (S_IS_COMMON (add_symbolP))
2540 add_number += S_GET_VALUE (add_symbolP);
2541 #endif
2542 break;
2543
2544
2545 } /* switch on symbol seg */
2546 } /* if not in local seg */
2547 } /* if there was a + symbol */
2548
2549 if (pcrel)
2550 {
2551 add_number -= md_pcrel_from (fixP);
2552 if (add_symbolP == 0)
2553 {
2554 fixP->fx_addsy = &abs_symbol;
2555 } /* if there's an add_symbol */
2556 #ifdef TC_I386
2557 /* On the 386 we must adjust by the segment vaddr
2558 as well. Ian Taylor. */
2559 add_number -= segP->scnhdr.s_vaddr;
2560 #endif
2561 } /* if pcrel */
2562
2563 if (!fixP->fx_bit_fixP)
2564 {
2565 if ((size == 1 &&
2566 (add_number & ~0xFF) && ((add_number & ~0xFF) != (-1 & ~0xFF))) ||
2567 (size == 2 &&
2568 (add_number & ~0xFFFF) && ((add_number & ~0xFFFF) != (-1 & ~0xFFFF))))
2569 {
2570 as_bad ("Value of %d too large for field of %d bytes at 0x%x",
2571 add_number, size, fragP->fr_address + where);
2572 } /* generic error checking */
2573 #ifdef WARN_SIGNED_OVERFLOW_WORD
2574 /* Warn if a .word value is too large when treated as
2575 a signed number. We already know it is not too
2576 negative. This is to catch over-large switches
2577 generated by gcc on the 68k. */
2578 if (!flagseen['J']
2579 && size == 2
2580 && add_number > 0x7fff)
2581 as_bad ("Signed .word overflow; switch may be too large; %d at 0x%x",
2582 add_number, fragP->fr_address + where);
2583 #endif
2584 } /* not a bit fix */
2585 /* once this fix has been applied, we don't have to output anything
2586 nothing more need be done -*/
2587 md_apply_fix (fixP, add_number);
2588 } /* For each fixS in this segment. */
2589 } /* fixup_segment() */
2590
2591 #endif