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