projects / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
* config/obj-coff.c (size_section, fill_section, fixup_mdeps): Treat
[binutils-gdb.git] / gas / config / obj-coff.c
1 /* coff object file format
2 Copyright (C) 1989, 1990, 1991, 1992, 1993, 1994
3 Free Software Foundation, Inc.
4
5 This file is part of GAS.
6
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
21 #include "as.h"
22 #include "obstack.h"
23 #include "subsegs.h"
24
25 /* I think this is probably always correct. */
26 #ifndef KEEP_RELOC_INFO
27 #define KEEP_RELOC_INFO
28 #endif
29
30
31 /* structure used to keep the filenames which
32 are too long around so that we can stick them
33 into the string table */
34 struct filename_list
35 {
36 char *filename;
37 struct filename_list *next;
38 };
39
40 static struct filename_list *filename_list_head;
41 static struct filename_list *filename_list_tail;
42
43 const char *s_get_name PARAMS ((symbolS * s));
44 static symbolS *def_symbol_in_progress;
45
46 \f
47 /* stack stuff */
48 typedef struct
49 {
50 unsigned long chunk_size;
51 unsigned long element_size;
52 unsigned long size;
53 char *data;
54 unsigned long pointer;
55 }
56 stack;
57
58 static stack *
59 stack_init (chunk_size, element_size)
60 unsigned long chunk_size;
61 unsigned long element_size;
62 {
63 stack *st;
64
65 st = (stack *) malloc (sizeof (stack));
66 if (!st)
67 return 0;
68 st->data = malloc (chunk_size);
69 if (!st->data)
70 {
71 free (st);
72 return 0;
73 }
74 st->pointer = 0;
75 st->size = chunk_size;
76 st->chunk_size = chunk_size;
77 st->element_size = element_size;
78 return st;
79 }
80
81 #if 0
82 /* Not currently used. */
83 static void
84 stack_delete (st)
85 stack *st;
86 {
87 free (st->data);
88 free (st);
89 }
90 #endif
91
92 static char *
93 stack_push (st, element)
94 stack *st;
95 char *element;
96 {
97 if (st->pointer + st->element_size >= st->size)
98 {
99 st->size += st->chunk_size;
100 if ((st->data = xrealloc (st->data, st->size)) == (char *) 0)
101 return (char *) 0;
102 }
103 memcpy (st->data + st->pointer, element, st->element_size);
104 st->pointer += st->element_size;
105 return st->data + st->pointer;
106 }
107
108 static char *
109 stack_pop (st)
110 stack *st;
111 {
112 if (st->pointer < st->element_size)
113 {
114 st->pointer = 0;
115 return (char *) 0;
116 }
117 st->pointer -= st->element_size;
118 return st->data + st->pointer;
119 }
120 \f
121 /*
122 * Maintain a list of the tagnames of the structres.
123 */
124
125 static struct hash_control *tag_hash;
126
127 static void
128 tag_init ()
129 {
130 tag_hash = hash_new ();
131 }
132
133 static void
134 tag_insert (name, symbolP)
135 const char *name;
136 symbolS *symbolP;
137 {
138 const char *error_string;
139
140 if ((error_string = hash_jam (tag_hash, name, (char *) symbolP)))
141 {
142 as_fatal ("Inserting \"%s\" into structure table failed: %s",
143 name, error_string);
144 }
145 }
146
147 static symbolS *
148 tag_find (name)
149 char *name;
150 {
151 #ifdef STRIP_UNDERSCORE
152 if (*name == '_')
153 name++;
154 #endif /* STRIP_UNDERSCORE */
155 return (symbolS *) hash_find (tag_hash, name);
156 }
157
158 static symbolS *
159 tag_find_or_make (name)
160 char *name;
161 {
162 symbolS *symbolP;
163
164 if ((symbolP = tag_find (name)) == NULL)
165 {
166 symbolP = symbol_new (name, undefined_section,
167 0, &zero_address_frag);
168
169 tag_insert (S_GET_NAME (symbolP), symbolP);
170 #ifdef BFD_ASSEMBLER
171 symbol_table_insert (symbolP);
172 #endif
173 } /* not found */
174
175 return symbolP;
176 }
177
178
179
180 #ifdef BFD_ASSEMBLER
181
182 static void SA_SET_SYM_TAGNDX PARAMS ((symbolS *, symbolS *));
183
184 #define GET_FILENAME_STRING(X) \
185 ((char*)(&((X)->sy_symbol.ost_auxent->x_file.x_n.x_offset))[1])
186
187 /* @@ Ick. */
188 static segT
189 fetch_coff_debug_section ()
190 {
191 static segT debug_section;
192 if (!debug_section)
193 {
194 CONST asymbol *s;
195 s = bfd_make_debug_symbol (stdoutput, (char *) 0, 0);
196 assert (s != 0);
197 debug_section = s->section;
198 }
199 return debug_section;
200 }
201
202 void
203 SA_SET_SYM_ENDNDX (sym, val)
204 symbolS *sym;
205 symbolS *val;
206 {
207 combined_entry_type *entry, *p;
208
209 entry = &coffsymbol (sym->bsym)->native[1];
210 p = coffsymbol (val->bsym)->native;
211 entry->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p = p;
212 entry->fix_end = 1;
213 }
214
215 static void
216 SA_SET_SYM_TAGNDX (sym, val)
217 symbolS *sym;
218 symbolS *val;
219 {
220 combined_entry_type *entry, *p;
221
222 entry = &coffsymbol (sym->bsym)->native[1];
223 p = coffsymbol (val->bsym)->native;
224 entry->u.auxent.x_sym.x_tagndx.p = p;
225 entry->fix_tag = 1;
226 }
227
228 static int
229 S_GET_DATA_TYPE (sym)
230 symbolS *sym;
231 {
232 return coffsymbol (sym->bsym)->native->u.syment.n_type;
233 }
234
235 int
236 S_SET_DATA_TYPE (sym, val)
237 symbolS *sym;
238 int val;
239 {
240 coffsymbol (sym->bsym)->native->u.syment.n_type = val;
241 return val;
242 }
243
244 int
245 S_GET_STORAGE_CLASS (sym)
246 symbolS *sym;
247 {
248 return coffsymbol (sym->bsym)->native->u.syment.n_sclass;
249 }
250
251 int
252 S_SET_STORAGE_CLASS (sym, val)
253 symbolS *sym;
254 int val;
255 {
256 coffsymbol (sym->bsym)->native->u.syment.n_sclass = val;
257 return val;
258 }
259
260 /* Merge a debug symbol containing debug information into a normal symbol. */
261
262 void
263 c_symbol_merge (debug, normal)
264 symbolS *debug;
265 symbolS *normal;
266 {
267 S_SET_DATA_TYPE (normal, S_GET_DATA_TYPE (debug));
268 S_SET_STORAGE_CLASS (normal, S_GET_STORAGE_CLASS (debug));
269
270 if (S_GET_NUMBER_AUXILIARY (debug) > S_GET_NUMBER_AUXILIARY (normal))
271 /* take the most we have */
272 S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));
273
274 if (S_GET_NUMBER_AUXILIARY (debug) > 0)
275 {
276 /* Move all the auxiliary information. */
277 /* @@ How many fields do we want to preserve? Would it make more
278 sense to pick and choose those we want to copy? Should look
279 into this further.... [raeburn:19920512.2209EST] */
280 alent *linenos;
281 linenos = coffsymbol (normal->bsym)->lineno;
282 memcpy ((char *) &coffsymbol (normal->bsym)->native,
283 (char *) &coffsymbol (debug->bsym)->native,
284 S_GET_NUMBER_AUXILIARY(debug) * AUXESZ);
285 coffsymbol (normal->bsym)->lineno = linenos;
286 }
287
288 /* Move the debug flags. */
289 SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
290 }
291
292 static symbolS *previous_file_symbol;
293 void
294 c_dot_file_symbol (filename)
295 char *filename;
296 {
297 symbolS *symbolP;
298
299 symbolP = symbol_new (filename, bfd_abs_section_ptr, 0, &zero_address_frag);
300
301 S_SET_STORAGE_CLASS (symbolP, C_FILE);
302 S_SET_NUMBER_AUXILIARY (symbolP, 1);
303
304 symbolP->bsym->flags = BSF_DEBUGGING;
305
306 #ifndef NO_LISTING
307 {
308 extern int listing;
309 if (listing)
310 {
311 listing_source_file (filename);
312 }
313 }
314 #endif
315
316 S_SET_VALUE (symbolP, (long) previous_file_symbol);
317
318 previous_file_symbol = symbolP;
319
320 /* Make sure that the symbol is first on the symbol chain */
321 if (symbol_rootP != symbolP)
322 {
323 if (symbolP == symbol_lastP)
324 {
325 symbol_lastP = symbol_lastP->sy_previous;
326 } /* if it was the last thing on the list */
327
328 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
329 symbol_insert (symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
330 symbol_rootP = symbolP;
331 } /* if not first on the list */
332 }
333
334 /*
335 * Build a 'section static' symbol.
336 */
337
338 char *
339 c_section_symbol (name, value, length, nreloc, nlnno)
340 char *name;
341 long value;
342 long length;
343 unsigned short nreloc;
344 unsigned short nlnno;
345 {
346 symbolS *symbolP;
347
348 symbolP = symbol_new (name,
349 (name[1] == 't'
350 ? text_section
351 : name[1] == 'd'
352 ? data_section
353 : bss_section),
354 value,
355 &zero_address_frag);
356
357 S_SET_STORAGE_CLASS (symbolP, C_STAT);
358 S_SET_NUMBER_AUXILIARY (symbolP, 1);
359
360 SA_SET_SCN_SCNLEN (symbolP, length);
361 SA_SET_SCN_NRELOC (symbolP, nreloc);
362 SA_SET_SCN_NLINNO (symbolP, nlnno);
363
364 SF_SET_STATICS (symbolP);
365
366 return (char *) symbolP;
367 }
368
369 /* Line number handling */
370
371 struct line_no {
372 struct line_no *next;
373 fragS *frag;
374 alent l;
375 };
376
377 int coff_line_base;
378
379 /* Symbol of last function, which we should hang line#s off of. */
380 static symbolS *line_fsym;
381
382 #define in_function() (line_fsym != 0)
383 #define clear_function() (line_fsym = 0)
384 #define set_function(F) (line_fsym = (F), coff_add_linesym (F))
385
386 \f
387 void
388 obj_symbol_new_hook (symbolP)
389 symbolS *symbolP;
390 {
391 char underscore = 0; /* Symbol has leading _ */
392
393 {
394 long sz = (OBJ_COFF_MAX_AUXENTRIES + 1) * sizeof (combined_entry_type);
395 char *s = (char *) bfd_alloc_by_size_t (stdoutput, sz);
396 memset (s, 0, sz);
397 coffsymbol (symbolP->bsym)->native = (combined_entry_type *) s;
398 }
399 S_SET_DATA_TYPE (symbolP, T_NULL);
400 S_SET_STORAGE_CLASS (symbolP, 0);
401 S_SET_NUMBER_AUXILIARY (symbolP, 0);
402
403 if (S_IS_STRING (symbolP))
404 SF_SET_STRING (symbolP);
405 if (!underscore && S_IS_LOCAL (symbolP))
406 SF_SET_LOCAL (symbolP);
407 }
408
409 \f
410 /*
411 * Handle .ln directives.
412 */
413
414 static symbolS *current_lineno_sym;
415 static struct line_no *line_nos;
416 /* @@ Blindly assume all .ln directives will be in the .text section... */
417 int coff_n_line_nos;
418
419 static void
420 add_lineno (frag, offset, num)
421 fragS *frag;
422 int offset;
423 int num;
424 {
425 struct line_no *new_line = (struct line_no *) bfd_alloc_by_size_t (stdoutput,
426 sizeof (struct line_no));
427 if (!current_lineno_sym)
428 {
429 abort ();
430 }
431 new_line->next = line_nos;
432 new_line->frag = frag;
433 new_line->l.line_number = num;
434 new_line->l.u.offset = offset;
435 line_nos = new_line;
436 coff_n_line_nos++;
437 }
438
439 void
440 coff_add_linesym (sym)
441 symbolS *sym;
442 {
443 if (line_nos)
444 {
445 coffsymbol (current_lineno_sym->bsym)->lineno = (alent *) line_nos;
446 coff_n_line_nos++;
447 line_nos = 0;
448 }
449 current_lineno_sym = sym;
450 }
451
452 static void
453 obj_coff_ln (appline)
454 int appline;
455 {
456 int l;
457
458 if (! appline && def_symbol_in_progress != NULL)
459 {
460 as_warn (".ln pseudo-op inside .def/.endef: ignored.");
461 demand_empty_rest_of_line ();
462 return;
463 }
464
465 l = get_absolute_expression ();
466 if (!appline)
467 {
468 add_lineno (frag_now, frag_now_fix (), l);
469 }
470
471 #ifndef NO_LISTING
472 {
473 extern int listing;
474
475 if (listing)
476 {
477 if (! appline)
478 l += coff_line_base - 1;
479 listing_source_line (l);
480 }
481 }
482 #endif
483
484 demand_empty_rest_of_line ();
485 }
486
487 /*
488 * def()
489 *
490 * Handle .def directives.
491 *
492 * One might ask : why can't we symbol_new if the symbol does not
493 * already exist and fill it with debug information. Because of
494 * the C_EFCN special symbol. It would clobber the value of the
495 * function symbol before we have a chance to notice that it is
496 * a C_EFCN. And a second reason is that the code is more clear this
497 * way. (at least I think it is :-).
498 *
499 */
500
501 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
502 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
503 *input_line_pointer == '\t') \
504 input_line_pointer++;
505
506 static void
507 obj_coff_def (what)
508 int what;
509 {
510 char name_end; /* Char after the end of name */
511 char *symbol_name; /* Name of the debug symbol */
512 char *symbol_name_copy; /* Temporary copy of the name */
513 unsigned int symbol_name_length;
514
515 if (def_symbol_in_progress != NULL)
516 {
517 as_warn (".def pseudo-op used inside of .def/.endef: ignored.");
518 demand_empty_rest_of_line ();
519 return;
520 } /* if not inside .def/.endef */
521
522 SKIP_WHITESPACES ();
523
524 symbol_name = input_line_pointer;
525 #ifdef STRIP_UNDERSCORE
526 if (symbol_name[0] == '_' && symbol_name[1] != 0)
527 symbol_name++;
528 #endif /* STRIP_UNDERSCORE */
529
530 name_end = get_symbol_end ();
531 symbol_name_length = strlen (symbol_name);
532 symbol_name_copy = xmalloc (symbol_name_length + 1);
533 strcpy (symbol_name_copy, symbol_name);
534
535 /* Initialize the new symbol */
536 def_symbol_in_progress = symbol_make (symbol_name_copy);
537 def_symbol_in_progress->sy_frag = &zero_address_frag;
538 S_SET_VALUE (def_symbol_in_progress, 0);
539
540 if (S_IS_STRING (def_symbol_in_progress))
541 SF_SET_STRING (def_symbol_in_progress);
542
543 *input_line_pointer = name_end;
544
545 demand_empty_rest_of_line ();
546 }
547
548 unsigned int dim_index;
549
550 static void
551 obj_coff_endef (ignore)
552 int ignore;
553 {
554 symbolS *symbolP;
555 /* DIM BUG FIX sac@cygnus.com */
556 dim_index = 0;
557 if (def_symbol_in_progress == NULL)
558 {
559 as_warn (".endef pseudo-op used outside of .def/.endef: ignored.");
560 demand_empty_rest_of_line ();
561 return;
562 } /* if not inside .def/.endef */
563
564 /* Set the section number according to storage class. */
565 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))
566 {
567 case C_STRTAG:
568 case C_ENTAG:
569 case C_UNTAG:
570 SF_SET_TAG (def_symbol_in_progress);
571 /* intentional fallthrough */
572 case C_FILE:
573 case C_TPDEF:
574 SF_SET_DEBUG (def_symbol_in_progress);
575 S_SET_SEGMENT (def_symbol_in_progress, fetch_coff_debug_section ());
576 break;
577
578 case C_EFCN:
579 SF_SET_LOCAL (def_symbol_in_progress); /* Do not emit this symbol. */
580 /* intentional fallthrough */
581 case C_BLOCK:
582 SF_SET_PROCESS (def_symbol_in_progress); /* Will need processing before writing */
583 /* intentional fallthrough */
584 case C_FCN:
585 {
586 CONST char *name;
587 S_SET_SEGMENT (def_symbol_in_progress, text_section);
588
589 name = bfd_asymbol_name (def_symbol_in_progress->bsym);
590 if (name[1] == 'b' && name[2] == 'f')
591 {
592 if (! in_function ())
593 as_warn ("`%s' symbol without preceding function", name);
594 /* SA_SET_SYM_LNNO (def_symbol_in_progress, 12345);*/
595 /* Will need relocating */
596 SF_SET_PROCESS (def_symbol_in_progress);
597 clear_function ();
598 }
599 }
600 break;
601
602 #ifdef C_AUTOARG
603 case C_AUTOARG:
604 #endif /* C_AUTOARG */
605 case C_AUTO:
606 case C_REG:
607 case C_MOS:
608 case C_MOE:
609 case C_MOU:
610 case C_ARG:
611 case C_REGPARM:
612 case C_FIELD:
613 case C_EOS:
614 SF_SET_DEBUG (def_symbol_in_progress);
615 S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
616 break;
617
618 case C_EXT:
619 case C_STAT:
620 case C_LABEL:
621 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
622 break;
623
624 case C_USTATIC:
625 case C_EXTDEF:
626 case C_ULABEL:
627 as_warn ("unexpected storage class %d",
628 S_GET_STORAGE_CLASS (def_symbol_in_progress));
629 break;
630 } /* switch on storage class */
631
632 /* Now that we have built a debug symbol, try to find if we should
633 merge with an existing symbol or not. If a symbol is C_EFCN or
634 SEG_ABSOLUTE or untagged SEG_DEBUG it never merges. */
635
636 /* Two cases for functions. Either debug followed by definition or
637 definition followed by debug. For definition first, we will
638 merge the debug symbol into the definition. For debug first, the
639 lineno entry MUST point to the definition function or else it
640 will point off into space when obj_crawl_symbol_chain() merges
641 the debug symbol into the real symbol. Therefor, let's presume
642 the debug symbol is a real function reference. */
643
644 /* FIXME-SOON If for some reason the definition label/symbol is
645 never seen, this will probably leave an undefined symbol at link
646 time. */
647
648 if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN
649 || (!strcmp (bfd_get_section_name (stdoutput,
650 S_GET_SEGMENT (def_symbol_in_progress)),
651 "*DEBUG*")
652 && !SF_GET_TAG (def_symbol_in_progress))
653 || S_GET_SEGMENT (def_symbol_in_progress) == absolute_section
654 || (symbolP = symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP)) == NULL)
655 {
656 if (def_symbol_in_progress != symbol_lastP)
657 symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP,
658 &symbol_lastP);
659 }
660 else
661 {
662 /* This symbol already exists, merge the newly created symbol
663 into the old one. This is not mandatory. The linker can
664 handle duplicate symbols correctly. But I guess that it save
665 a *lot* of space if the assembly file defines a lot of
666 symbols. [loic] */
667
668 /* The debug entry (def_symbol_in_progress) is merged into the
669 previous definition. */
670
671 c_symbol_merge (def_symbol_in_progress, symbolP);
672 /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
673 def_symbol_in_progress = symbolP;
674
675 if (SF_GET_FUNCTION (def_symbol_in_progress)
676 || SF_GET_TAG (def_symbol_in_progress))
677 {
678 /* For functions, and tags, the symbol *must* be where the
679 debug symbol appears. Move the existing symbol to the
680 current place. */
681 /* If it already is at the end of the symbol list, do nothing */
682 if (def_symbol_in_progress != symbol_lastP)
683 {
684 symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
685 symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP, &symbol_lastP);
686 }
687 }
688 }
689
690 if (SF_GET_TAG (def_symbol_in_progress)
691 && symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP) == NULL)
692 {
693 tag_insert (S_GET_NAME (def_symbol_in_progress), def_symbol_in_progress);
694 }
695
696 if (SF_GET_FUNCTION (def_symbol_in_progress))
697 {
698 know (sizeof (def_symbol_in_progress) <= sizeof (long));
699 set_function (def_symbol_in_progress);
700 SF_SET_PROCESS (def_symbol_in_progress);
701
702 if (symbolP == NULL)
703 {
704 /* That is, if this is the first time we've seen the
705 function... */
706 symbol_table_insert (def_symbol_in_progress);
707 } /* definition follows debug */
708 } /* Create the line number entry pointing to the function being defined */
709
710 def_symbol_in_progress = NULL;
711 demand_empty_rest_of_line ();
712 }
713
714 static void
715 obj_coff_dim (ignore)
716 int ignore;
717 {
718 int dim_index;
719
720 if (def_symbol_in_progress == NULL)
721 {
722 as_warn (".dim pseudo-op used outside of .def/.endef: ignored.");
723 demand_empty_rest_of_line ();
724 return;
725 } /* if not inside .def/.endef */
726
727 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
728
729 for (dim_index = 0; dim_index < DIMNUM; dim_index++)
730 {
731 SKIP_WHITESPACES ();
732 SA_SET_SYM_DIMEN (def_symbol_in_progress, dim_index,
733 get_absolute_expression ());
734
735 switch (*input_line_pointer)
736 {
737 case ',':
738 input_line_pointer++;
739 break;
740
741 default:
742 as_warn ("badly formed .dim directive ignored");
743 /* intentional fallthrough */
744 case '\n':
745 case ';':
746 dim_index = DIMNUM;
747 break;
748 }
749 }
750
751 demand_empty_rest_of_line ();
752 }
753
754 static void
755 obj_coff_line (ignore)
756 int ignore;
757 {
758 int this_base;
759
760 if (def_symbol_in_progress == NULL)
761 {
762 /* Probably stabs-style line? */
763 obj_coff_ln (0);
764 return;
765 }
766
767 this_base = get_absolute_expression ();
768 if (!strcmp (".bf", S_GET_NAME (def_symbol_in_progress)))
769 coff_line_base = this_base;
770
771 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
772 SA_SET_SYM_LNNO (def_symbol_in_progress, coff_line_base);
773
774 demand_empty_rest_of_line ();
775
776 #ifndef NO_LISTING
777 if (strcmp (".bf", S_GET_NAME (def_symbol_in_progress)) == 0)
778 {
779 extern int listing;
780
781 if (listing)
782 listing_source_line ((unsigned int) coff_line_base);
783 }
784 #endif
785 }
786
787 static void
788 obj_coff_size (ignore)
789 int ignore;
790 {
791 if (def_symbol_in_progress == NULL)
792 {
793 as_warn (".size pseudo-op used outside of .def/.endef ignored.");
794 demand_empty_rest_of_line ();
795 return;
796 } /* if not inside .def/.endef */
797
798 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
799 SA_SET_SYM_SIZE (def_symbol_in_progress, get_absolute_expression ());
800 demand_empty_rest_of_line ();
801 }
802
803 static void
804 obj_coff_scl (ignore)
805 int ignore;
806 {
807 if (def_symbol_in_progress == NULL)
808 {
809 as_warn (".scl pseudo-op used outside of .def/.endef ignored.");
810 demand_empty_rest_of_line ();
811 return;
812 } /* if not inside .def/.endef */
813
814 S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ());
815 demand_empty_rest_of_line ();
816 }
817
818 static void
819 obj_coff_tag (ignore)
820 int ignore;
821 {
822 char *symbol_name;
823 char name_end;
824
825 if (def_symbol_in_progress == NULL)
826 {
827 as_warn (".tag pseudo-op used outside of .def/.endef ignored.");
828 demand_empty_rest_of_line ();
829 return;
830 }
831
832 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
833 symbol_name = input_line_pointer;
834 name_end = get_symbol_end ();
835
836 /* Assume that the symbol referred to by .tag is always defined.
837 This was a bad assumption. I've added find_or_make. xoxorich. */
838 SA_SET_SYM_TAGNDX (def_symbol_in_progress,
839 tag_find_or_make (symbol_name));
840 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L)
841 {
842 as_warn ("tag not found for .tag %s", symbol_name);
843 } /* not defined */
844
845 SF_SET_TAGGED (def_symbol_in_progress);
846 *input_line_pointer = name_end;
847
848 demand_empty_rest_of_line ();
849 }
850
851 static void
852 obj_coff_type (ignore)
853 int ignore;
854 {
855 if (def_symbol_in_progress == NULL)
856 {
857 as_warn (".type pseudo-op used outside of .def/.endef ignored.");
858 demand_empty_rest_of_line ();
859 return;
860 } /* if not inside .def/.endef */
861
862 S_SET_DATA_TYPE (def_symbol_in_progress, get_absolute_expression ());
863
864 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress)) &&
865 S_GET_STORAGE_CLASS (def_symbol_in_progress) != C_TPDEF)
866 {
867 SF_SET_FUNCTION (def_symbol_in_progress);
868 } /* is a function */
869
870 demand_empty_rest_of_line ();
871 }
872
873 static void
874 obj_coff_val (ignore)
875 int ignore;
876 {
877 if (def_symbol_in_progress == NULL)
878 {
879 as_warn (".val pseudo-op used outside of .def/.endef ignored.");
880 demand_empty_rest_of_line ();
881 return;
882 } /* if not inside .def/.endef */
883
884 if (is_name_beginner (*input_line_pointer))
885 {
886 char *symbol_name = input_line_pointer;
887 char name_end = get_symbol_end ();
888
889 if (!strcmp (symbol_name, "."))
890 {
891 def_symbol_in_progress->sy_frag = frag_now;
892 S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
893 /* If the .val is != from the .def (e.g. statics) */
894 }
895 else if (strcmp (S_GET_NAME (def_symbol_in_progress), symbol_name))
896 {
897 def_symbol_in_progress->sy_value.X_op = O_symbol;
898 def_symbol_in_progress->sy_value.X_add_symbol =
899 symbol_find_or_make (symbol_name);
900 def_symbol_in_progress->sy_value.X_op_symbol = NULL;
901 def_symbol_in_progress->sy_value.X_add_number = 0;
902
903 /* If the segment is undefined when the forward reference is
904 resolved, then copy the segment id from the forward
905 symbol. */
906 SF_SET_GET_SEGMENT (def_symbol_in_progress);
907 }
908 /* Otherwise, it is the name of a non debug symbol and its value will be calculated later. */
909 *input_line_pointer = name_end;
910 }
911 else
912 {
913 S_SET_VALUE (def_symbol_in_progress, get_absolute_expression ());
914 } /* if symbol based */
915
916 demand_empty_rest_of_line ();
917 }
918
919 void
920 obj_read_begin_hook ()
921 {
922 /* These had better be the same. Usually 18 bytes. */
923 #ifndef BFD_HEADERS
924 know (sizeof (SYMENT) == sizeof (AUXENT));
925 know (SYMESZ == AUXESZ);
926 #endif
927 tag_init ();
928 }
929
930
931 symbolS *coff_last_function;
932
933 void
934 coff_frob_symbol (symp, punt)
935 symbolS *symp;
936 int *punt;
937 {
938 static symbolS *last_tagP;
939 static stack *block_stack;
940 static symbolS *set_end;
941 symbolS *next_set_end = NULL;
942
943 if (symp == &abs_symbol)
944 {
945 *punt = 1;
946 return;
947 }
948
949 if (current_lineno_sym)
950 coff_add_linesym ((symbolS *) 0);
951
952 if (!block_stack)
953 block_stack = stack_init (512, sizeof (symbolS*));
954
955 if (!S_IS_DEFINED (symp) && S_GET_STORAGE_CLASS (symp) != C_STAT)
956 S_SET_STORAGE_CLASS (symp, C_EXT);
957
958 if (!SF_GET_DEBUG (symp))
959 {
960 symbolS *real;
961 if (!SF_GET_LOCAL (symp)
962 && (real = symbol_find_base (S_GET_NAME (symp), DO_NOT_STRIP))
963 && real != symp)
964 {
965 c_symbol_merge (symp, real);
966 *punt = 1;
967 }
968 if (!S_IS_DEFINED (symp) && !SF_GET_LOCAL (symp))
969 {
970 assert (S_GET_VALUE (symp) == 0);
971 S_SET_EXTERNAL (symp);
972 }
973 else if (S_GET_STORAGE_CLASS (symp) == C_NULL)
974 {
975 if (S_GET_SEGMENT (symp) == text_section
976 && symp != seg_info (text_section)->sym)
977 S_SET_STORAGE_CLASS (symp, C_LABEL);
978 else
979 S_SET_STORAGE_CLASS (symp, C_STAT);
980 }
981 if (SF_GET_PROCESS (symp))
982 {
983 if (S_GET_STORAGE_CLASS (symp) == C_BLOCK)
984 {
985 if (!strcmp (S_GET_NAME (symp), ".bb"))
986 stack_push (block_stack, (char *) &symp);
987 else
988 {
989 symbolS *begin;
990 begin = *(symbolS **) stack_pop (block_stack);
991 if (begin == 0)
992 as_warn ("mismatched .eb");
993 else
994 next_set_end = begin;
995 }
996 }
997 if (coff_last_function == 0 && SF_GET_FUNCTION (symp))
998 {
999 union internal_auxent *auxp;
1000 coff_last_function = symp;
1001 if (S_GET_NUMBER_AUXILIARY (symp) < 1)
1002 S_SET_NUMBER_AUXILIARY (symp, 1);
1003 auxp = &coffsymbol (symp->bsym)->native[1].u.auxent;
1004 memset (auxp->x_sym.x_fcnary.x_ary.x_dimen, 0,
1005 sizeof (auxp->x_sym.x_fcnary.x_ary.x_dimen));
1006 }
1007 if (S_GET_STORAGE_CLASS (symp) == C_EFCN)
1008 {
1009 if (coff_last_function == 0)
1010 as_fatal ("C_EFCN symbol out of scope");
1011 SA_SET_SYM_FSIZE (coff_last_function,
1012 (long) (S_GET_VALUE (symp)
1013 - S_GET_VALUE (coff_last_function)));
1014 next_set_end = coff_last_function;
1015 coff_last_function = 0;
1016 }
1017 }
1018 else if (SF_GET_TAG (symp))
1019 last_tagP = symp;
1020 else if (S_GET_STORAGE_CLASS (symp) == C_EOS)
1021 next_set_end = last_tagP;
1022 else if (S_GET_STORAGE_CLASS (symp) == C_FILE)
1023 {
1024 if (S_GET_VALUE (symp))
1025 {
1026 S_SET_VALUE ((symbolS *) S_GET_VALUE (symp), 0xdeadbeef);
1027 S_SET_VALUE (symp, 0);
1028 }
1029 }
1030 if (S_IS_EXTERNAL (symp))
1031 S_SET_STORAGE_CLASS (symp, C_EXT);
1032 else if (SF_GET_LOCAL (symp))
1033 *punt = 1;
1034
1035 if (SF_GET_FUNCTION (symp))
1036 symp->bsym->flags |= BSF_FUNCTION;
1037
1038 /* more ... */
1039 }
1040
1041 #ifdef OBJ_XCOFF
1042 /* This is pretty horrible, but we have to set *punt correctly in
1043 order to call SA_SET_SYM_ENDNDX correctly. */
1044 if (! symp->sy_used_in_reloc
1045 && ((symp->bsym->flags & BSF_SECTION_SYM) != 0
1046 || (! S_IS_EXTERNAL (symp)
1047 && ! symp->sy_tc.output
1048 && S_GET_STORAGE_CLASS (symp) != C_FILE)))
1049 *punt = 1;
1050 #endif
1051
1052 if (set_end != (symbolS *) NULL
1053 && ! *punt)
1054 {
1055 SA_SET_SYM_ENDNDX (set_end, symp);
1056 set_end = NULL;
1057 }
1058
1059 if (next_set_end != NULL
1060 && ! *punt)
1061 set_end = next_set_end;
1062
1063 if (coffsymbol (symp->bsym)->lineno)
1064 {
1065 int i;
1066 struct line_no *lptr;
1067 alent *l;
1068
1069 lptr = (struct line_no *) coffsymbol (symp->bsym)->lineno;
1070 for (i = 0; lptr; lptr = lptr->next)
1071 i++;
1072 lptr = (struct line_no *) coffsymbol (symp->bsym)->lineno;
1073
1074 /* We need i entries for line numbers, plus 1 for the first
1075 entry which BFD will override, plus 1 for the last zero
1076 entry (a marker for BFD). */
1077 l = (alent *) bfd_alloc_by_size_t (stdoutput, (i + 2) * sizeof (alent));
1078 coffsymbol (symp->bsym)->lineno = l;
1079 l[i + 1].line_number = 0;
1080 l[i + 1].u.sym = NULL;
1081 for (; i > 0; i--)
1082 {
1083 if (lptr->frag)
1084 lptr->l.u.offset += lptr->frag->fr_address;
1085 l[i] = lptr->l;
1086 lptr = lptr->next;
1087 }
1088 }
1089 }
1090
1091 void
1092 coff_adjust_section_syms (abfd, sec, x)
1093 bfd *abfd;
1094 asection *sec;
1095 PTR x;
1096 {
1097 symbolS *secsym;
1098 segment_info_type *seginfo = seg_info (sec);
1099 int nlnno, nrelocs = 0;
1100
1101 /* RS/6000 gas creates a .debug section manually in ppc_frob_file in
1102 tc-ppc.c. Do not get confused by it. */
1103 if (seginfo == NULL)
1104 return;
1105
1106 if (!strcmp (sec->name, ".text"))
1107 nlnno = coff_n_line_nos;
1108 else
1109 nlnno = 0;
1110 {
1111 /* @@ Hope that none of the fixups expand to more than one reloc
1112 entry... */
1113 fixS *fixp = seginfo->fix_root;
1114 while (fixp)
1115 {
1116 fixp = fixp->fx_next;
1117 nrelocs++;
1118 }
1119 }
1120 if (bfd_get_section_size_before_reloc (sec) == 0
1121 && nrelocs == 0 && nlnno == 0)
1122 return;
1123 secsym = section_symbol (sec);
1124 SA_SET_SCN_NRELOC (secsym, nrelocs);
1125 SA_SET_SCN_NLINNO (secsym, nlnno);
1126 }
1127
1128 void
1129 coff_frob_file ()
1130 {
1131 bfd_map_over_sections (stdoutput, coff_adjust_section_syms, (char*) 0);
1132 }
1133
1134 /*
1135 * implement the .section pseudo op:
1136 * .section name {, "flags"}
1137 * ^ ^
1138 * | +--- optional flags: 'b' for bss
1139 * | 'i' for info
1140 * +-- section name 'l' for lib
1141 * 'n' for noload
1142 * 'o' for over
1143 * 'w' for data
1144 * 'd' (apparently m88k for data)
1145 * 'x' for text
1146 * But if the argument is not a quoted string, treat it as a
1147 * subsegment number.
1148 */
1149
1150 void
1151 obj_coff_section (ignore)
1152 int ignore;
1153 {
1154 /* Strip out the section name */
1155 char *section_name;
1156 char c;
1157 char *name;
1158 unsigned int exp;
1159 flagword flags;
1160 asection *sec;
1161
1162 if (flag_mri)
1163 {
1164 char type;
1165
1166 s_mri_sect (&type);
1167 return;
1168 }
1169
1170 section_name = input_line_pointer;
1171 c = get_symbol_end ();
1172
1173 name = xmalloc (input_line_pointer - section_name + 1);
1174 strcpy (name, section_name);
1175
1176 *input_line_pointer = c;
1177
1178 SKIP_WHITESPACE ();
1179
1180 exp = 0;
1181 flags = SEC_NO_FLAGS;
1182
1183 if (*input_line_pointer == ',')
1184 {
1185 ++input_line_pointer;
1186 SKIP_WHITESPACE ();
1187 if (*input_line_pointer != '"')
1188 exp = get_absolute_expression ();
1189 else
1190 {
1191 ++input_line_pointer;
1192 while (*input_line_pointer != '"'
1193 && ! is_end_of_line[(unsigned char) *input_line_pointer])
1194 {
1195 switch (*input_line_pointer)
1196 {
1197 case 'b': flags |= SEC_ALLOC; flags &=~ SEC_LOAD; break;
1198 case 'n': flags &=~ SEC_LOAD; break;
1199 case 'd':
1200 case 'w': flags &=~ SEC_READONLY; break;
1201 case 'x': flags |= SEC_CODE; break;
1202
1203 case 'i': /* STYP_INFO */
1204 case 'l': /* STYP_LIB */
1205 case 'o': /* STYP_OVER */
1206 as_warn ("unsupported section attribute '%c'",
1207 *input_line_pointer);
1208 break;
1209
1210 default:
1211 as_warn("unknown section attribute '%c'",
1212 *input_line_pointer);
1213 break;
1214 }
1215 ++input_line_pointer;
1216 }
1217 if (*input_line_pointer == '"')
1218 ++input_line_pointer;
1219 }
1220 }
1221
1222 sec = subseg_new (name, (subsegT) exp);
1223
1224 if (flags != SEC_NO_FLAGS)
1225 {
1226 if (! bfd_set_section_flags (stdoutput, sec, flags))
1227 as_warn ("error setting flags for \"%s\": %s",
1228 bfd_section_name (stdoutput, sec),
1229 bfd_errmsg (bfd_get_error ()));
1230 }
1231 }
1232
1233 void
1234 coff_adjust_symtab ()
1235 {
1236 if (symbol_rootP == NULL
1237 || S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
1238 {
1239 assert (previous_file_symbol == 0);
1240 c_dot_file_symbol ("fake");
1241 }
1242 }
1243
1244 void
1245 coff_frob_section (sec)
1246 segT sec;
1247 {
1248 segT strsec;
1249 char *strname, *p;
1250 fragS *fragp;
1251 bfd_vma size, n_entries, mask;
1252
1253 /* The COFF back end in BFD requires that all section sizes be
1254 rounded up to multiples of the corresponding section alignments.
1255 Seems kinda silly to me, but that's the way it is. */
1256 size = bfd_get_section_size_before_reloc (sec);
1257 mask = ((bfd_vma) 1 << (bfd_vma) sec->alignment_power) - 1;
1258 if (size & mask)
1259 {
1260 size = (size + mask) & ~mask;
1261 bfd_set_section_size (stdoutput, sec, size);
1262 }
1263
1264 /* If the section size is non-zero, the section symbol needs an aux
1265 entry associated with it, indicating the size. We don't know
1266 all the values yet; coff_frob_symbol will fill them in later. */
1267 if (size)
1268 {
1269 symbolS *secsym = section_symbol (sec);
1270
1271 S_SET_STORAGE_CLASS (secsym, C_STAT);
1272 S_SET_NUMBER_AUXILIARY (secsym, 1);
1273 SF_SET_STATICS (secsym);
1274 SA_SET_SCN_SCNLEN (secsym, size);
1275 }
1276
1277 /* @@ these should be in a "stabs.h" file, or maybe as.h */
1278 #ifndef STAB_SECTION_NAME
1279 #define STAB_SECTION_NAME ".stab"
1280 #endif
1281 #ifndef STAB_STRING_SECTION_NAME
1282 #define STAB_STRING_SECTION_NAME ".stabstr"
1283 #endif
1284 if (strcmp (STAB_STRING_SECTION_NAME, sec->name))
1285 return;
1286
1287 strsec = sec;
1288 sec = subseg_get (STAB_SECTION_NAME, 0);
1289 /* size is already rounded up, since other section will be listed first */
1290 size = bfd_get_section_size_before_reloc (strsec);
1291
1292 n_entries = bfd_get_section_size_before_reloc (sec) / 12 - 1;
1293
1294 /* Find first non-empty frag. It should be large enough. */
1295 fragp = seg_info (sec)->frchainP->frch_root;
1296 while (fragp && fragp->fr_fix == 0)
1297 fragp = fragp->fr_next;
1298 assert (fragp != 0 && fragp->fr_fix >= 12);
1299
1300 /* Store the values. */
1301 p = fragp->fr_literal;
1302 bfd_h_put_16 (stdoutput, n_entries, (bfd_byte *) p + 6);
1303 bfd_h_put_32 (stdoutput, size, (bfd_byte *) p + 8);
1304 }
1305
1306 void
1307 obj_coff_init_stab_section (seg)
1308 segT seg;
1309 {
1310 char *file;
1311 char *p;
1312 char *stabstr_name;
1313 unsigned int stroff;
1314
1315 /* Make space for this first symbol. */
1316 p = frag_more (12);
1317 /* Zero it out. */
1318 memset (p, 0, 12);
1319 as_where (&file, (unsigned int *) NULL);
1320 stabstr_name = (char *) alloca (strlen (seg->name) + 4);
1321 strcpy (stabstr_name, seg->name);
1322 strcat (stabstr_name, "str");
1323 stroff = get_stab_string_offset (file, stabstr_name);
1324 know (stroff == 1);
1325 md_number_to_chars (p, stroff, 4);
1326 }
1327
1328 #ifdef DEBUG
1329 /* for debugging */
1330 const char *
1331 s_get_name (s)
1332 symbolS *s;
1333 {
1334 return ((s == NULL) ? "(NULL)" : S_GET_NAME (s));
1335 }
1336
1337 void
1338 symbol_dump ()
1339 {
1340 symbolS *symbolP;
1341
1342 for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
1343 {
1344 printf("0x%lx: \"%s\" type = %ld, class = %d, segment = %d\n",
1345 (unsigned long) symbolP,
1346 S_GET_NAME(symbolP),
1347 (long) S_GET_DATA_TYPE(symbolP),
1348 S_GET_STORAGE_CLASS(symbolP),
1349 (int) S_GET_SEGMENT(symbolP));
1350 }
1351 }
1352
1353 #endif /* DEBUG */
1354
1355 #else /* not BFD_ASSEMBLER */
1356
1357 #include "frags.h"
1358 /* This is needed because we include internal bfd things. */
1359 #include <time.h>
1360
1361 #include "libbfd.h"
1362 #include "libcoff.h"
1363
1364 /* The NOP_OPCODE is for the alignment fill value. Fill with nop so
1365 that we can stick sections together without causing trouble. */
1366 #ifndef NOP_OPCODE
1367 #define NOP_OPCODE 0x00
1368 #endif
1369
1370 /* The zeroes if symbol name is longer than 8 chars */
1371 #define S_SET_ZEROES(s,v) ((s)->sy_symbol.ost_entry.n_zeroes = (v))
1372
1373 #define MIN(a,b) ((a) < (b)? (a) : (b))
1374 /* This vector is used to turn an internal segment into a section #
1375 suitable for insertion into a coff symbol table
1376 */
1377
1378 const short seg_N_TYPE[] =
1379 { /* in: segT out: N_TYPE bits */
1380 C_ABS_SECTION,
1381 1,
1382 2,
1383 3,
1384 4,
1385 5,
1386 6,
1387 7,
1388 8,
1389 9,
1390 10,
1391 C_UNDEF_SECTION, /* SEG_UNKNOWN */
1392 C_UNDEF_SECTION, /* SEG_GOOF */
1393 C_UNDEF_SECTION, /* SEG_EXPR */
1394 C_DEBUG_SECTION, /* SEG_DEBUG */
1395 C_NTV_SECTION, /* SEG_NTV */
1396 C_PTV_SECTION, /* SEG_PTV */
1397 C_REGISTER_SECTION, /* SEG_REGISTER */
1398 };
1399
1400 int function_lineoff = -1; /* Offset in line#s where the last function
1401 started (the odd entry for line #0) */
1402
1403 static symbolS *last_line_symbol;
1404
1405 /* Add 4 to the real value to get the index and compensate the
1406 negatives. This vector is used by S_GET_SEGMENT to turn a coff
1407 section number into a segment number
1408 */
1409 static symbolS *previous_file_symbol;
1410 void c_symbol_merge ();
1411 static int line_base;
1412
1413 symbolS *c_section_symbol ();
1414 bfd *abfd;
1415
1416 static void fixup_segment PARAMS ((segment_info_type *segP,
1417 segT this_segment_type));
1418
1419
1420 static void fixup_mdeps PARAMS ((fragS *,
1421 object_headers *,
1422 segT));
1423
1424
1425 static void fill_section PARAMS ((bfd * abfd,
1426 object_headers *,
1427 unsigned long *));
1428
1429
1430 static int c_line_new PARAMS ((symbolS * symbol, long paddr,
1431 int line_number,
1432 fragS * frag));
1433
1434
1435 static void w_symbols PARAMS ((bfd * abfd, char *where,
1436 symbolS * symbol_rootP));
1437
1438 static void adjust_stab_section PARAMS ((bfd *abfd, segT seg));
1439
1440 static void obj_coff_lcomm PARAMS ((int));
1441 static void obj_coff_text PARAMS ((int));
1442 static void obj_coff_data PARAMS ((int));
1443 static void obj_coff_bss PARAMS ((int));
1444 static void obj_coff_ident PARAMS ((int));
1445 void obj_coff_section PARAMS ((int));
1446
1447 /* Section stuff
1448
1449 We allow more than just the standard 3 sections, infact, we allow
1450 10 sections, (though the usual three have to be there).
1451
1452 This structure performs the mappings for us:
1453
1454 */
1455
1456 #define N_SEG 32
1457 typedef struct
1458 {
1459 segT seg_t;
1460 int i;
1461 } seg_info_type;
1462
1463 static const seg_info_type seg_info_off_by_4[N_SEG] =
1464 {
1465 {SEG_PTV, },
1466 {SEG_NTV, },
1467 {SEG_DEBUG, },
1468 {SEG_ABSOLUTE, },
1469 {SEG_UNKNOWN, },
1470 {SEG_E0},
1471 {SEG_E1},
1472 {SEG_E2},
1473 {SEG_E3},
1474 {SEG_E4},
1475 {SEG_E5},
1476 {SEG_E6},
1477 {SEG_E7},
1478 {SEG_E8},
1479 {SEG_E9},
1480 {(segT)15},
1481 {(segT)16},
1482 {(segT)17},
1483 {(segT)18},
1484 {(segT)19},
1485 {(segT)20},
1486 {(segT)0},
1487 {(segT)0},
1488 {(segT)0},
1489 {SEG_REGISTER}
1490 };
1491
1492
1493
1494 #define SEG_INFO_FROM_SECTION_NUMBER(x) (seg_info_off_by_4[(x)+4])
1495
1496 static relax_addressT
1497 relax_align (address, alignment)
1498 relax_addressT address;
1499 long alignment;
1500 {
1501 relax_addressT mask;
1502 relax_addressT new_address;
1503
1504 mask = ~((~0) << alignment);
1505 new_address = (address + mask) & (~mask);
1506 return (new_address - address);
1507 }
1508
1509
1510 segT
1511 s_get_segment (x)
1512 symbolS * x;
1513 {
1514 return SEG_INFO_FROM_SECTION_NUMBER (x->sy_symbol.ost_entry.n_scnum).seg_t;
1515 }
1516
1517
1518
1519 /* calculate the size of the frag chain and fill in the section header
1520 to contain all of it, also fill in the addr of the sections */
1521 static unsigned int
1522 size_section (abfd, idx)
1523 bfd * abfd;
1524 unsigned int idx;
1525 {
1526
1527 unsigned int size = 0;
1528 fragS *frag = segment_info[idx].frchainP->frch_root;
1529 while (frag)
1530 {
1531 size = frag->fr_address;
1532 if (frag->fr_address != size)
1533 {
1534 fprintf (stderr, "Out of step\n");
1535 size = frag->fr_address;
1536 }
1537
1538 switch (frag->fr_type)
1539 {
1540 #ifdef TC_COFF_SIZEMACHDEP
1541 case rs_machine_dependent:
1542 size += TC_COFF_SIZEMACHDEP (frag);
1543 break;
1544 #endif
1545 case rs_space:
1546 assert (frag->fr_symbol == 0);
1547 case rs_fill:
1548 case rs_org:
1549 size += frag->fr_fix;
1550 size += frag->fr_offset * frag->fr_var;
1551 break;
1552 case rs_align:
1553 case rs_align_code:
1554 size += frag->fr_fix;
1555 size += relax_align (size, frag->fr_offset);
1556 break;
1557 default:
1558 BAD_CASE (frag->fr_type);
1559 break;
1560 }
1561 frag = frag->fr_next;
1562 }
1563 segment_info[idx].scnhdr.s_size = size;
1564 return size;
1565 }
1566
1567
1568 static unsigned int
1569 count_entries_in_chain (idx)
1570 unsigned int idx;
1571 {
1572 unsigned int nrelocs;
1573 fixS *fixup_ptr;
1574
1575 /* Count the relocations */
1576 fixup_ptr = segment_info[idx].fix_root;
1577 nrelocs = 0;
1578 while (fixup_ptr != (fixS *) NULL)
1579 {
1580 if (TC_COUNT_RELOC (fixup_ptr))
1581 {
1582 #ifdef TC_A29K
1583 if (fixup_ptr->fx_r_type == RELOC_CONSTH)
1584 nrelocs += 2;
1585 else
1586 nrelocs++;
1587 #else
1588 nrelocs++;
1589 #endif
1590 }
1591
1592 fixup_ptr = fixup_ptr->fx_next;
1593 }
1594 return nrelocs;
1595 }
1596
1597 /* output all the relocations for a section */
1598 void
1599 do_relocs_for (abfd, h, file_cursor)
1600 bfd * abfd;
1601 object_headers * h;
1602 unsigned long *file_cursor;
1603 {
1604 unsigned int nrelocs;
1605 unsigned int idx;
1606 unsigned long reloc_start = *file_cursor;
1607
1608 for (idx = SEG_E0; idx < SEG_E9; idx++)
1609 {
1610 if (segment_info[idx].scnhdr.s_name[0])
1611 {
1612 struct external_reloc *ext_ptr;
1613 struct external_reloc *external_reloc_vec;
1614 unsigned int external_reloc_size;
1615 unsigned int base = segment_info[idx].scnhdr.s_paddr;
1616 fixS *fix_ptr = segment_info[idx].fix_root;
1617 nrelocs = count_entries_in_chain (idx);
1618
1619 if (nrelocs)
1620 /* Bypass this stuff if no relocs. This also incidentally
1621 avoids a SCO bug, where free(malloc(0)) tends to crash. */
1622 {
1623 external_reloc_size = nrelocs * RELSZ;
1624 external_reloc_vec =
1625 (struct external_reloc *) malloc (external_reloc_size);
1626
1627 ext_ptr = external_reloc_vec;
1628
1629 /* Fill in the internal coff style reloc struct from the
1630 internal fix list. */
1631 while (fix_ptr)
1632 {
1633 struct internal_reloc intr;
1634
1635 /* Only output some of the relocations */
1636 if (TC_COUNT_RELOC (fix_ptr))
1637 {
1638 #ifdef TC_RELOC_MANGLE
1639 TC_RELOC_MANGLE (&segment_info[idx], fix_ptr, &intr,
1640 base);
1641
1642 #else
1643 symbolS *dot;
1644 symbolS *symbol_ptr = fix_ptr->fx_addsy;
1645
1646 intr.r_type = TC_COFF_FIX2RTYPE (fix_ptr);
1647 intr.r_vaddr =
1648 base + fix_ptr->fx_frag->fr_address + fix_ptr->fx_where;
1649
1650 #ifdef TC_KEEP_FX_OFFSET
1651 intr.r_offset = fix_ptr->fx_offset;
1652 #else
1653 intr.r_offset = 0;
1654 #endif
1655
1656 /* Turn the segment of the symbol into an offset. */
1657 if (symbol_ptr)
1658 {
1659 dot = segment_info[S_GET_SEGMENT (symbol_ptr)].dot;
1660 if (dot)
1661 {
1662 intr.r_symndx = dot->sy_number;
1663 }
1664 else
1665 {
1666 intr.r_symndx = symbol_ptr->sy_number;
1667 }
1668
1669 }
1670 else
1671 {
1672 intr.r_symndx = -1;
1673 }
1674 #endif
1675
1676 (void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
1677 ext_ptr++;
1678
1679 #if defined(TC_A29K)
1680
1681 /* The 29k has a special kludge for the high 16 bit
1682 reloc. Two relocations are emited, R_IHIHALF,
1683 and R_IHCONST. The second one doesn't contain a
1684 symbol, but uses the value for offset. */
1685
1686 if (intr.r_type == R_IHIHALF)
1687 {
1688 /* now emit the second bit */
1689 intr.r_type = R_IHCONST;
1690 intr.r_symndx = fix_ptr->fx_addnumber;
1691 (void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
1692 ext_ptr++;
1693 }
1694 #endif
1695 }
1696
1697 fix_ptr = fix_ptr->fx_next;
1698 }
1699
1700 /* Write out the reloc table */
1701 bfd_write ((PTR) external_reloc_vec, 1, external_reloc_size,
1702 abfd);
1703 free (external_reloc_vec);
1704
1705 /* Fill in section header info. */
1706 segment_info[idx].scnhdr.s_relptr = *file_cursor;
1707 *file_cursor += external_reloc_size;
1708 segment_info[idx].scnhdr.s_nreloc = nrelocs;
1709 }
1710 else
1711 {
1712 /* No relocs */
1713 segment_info[idx].scnhdr.s_relptr = 0;
1714 }
1715 }
1716 }
1717 /* Set relocation_size field in file headers */
1718 H_SET_RELOCATION_SIZE (h, *file_cursor - reloc_start, 0);
1719 }
1720
1721
1722 /* run through a frag chain and write out the data to go with it, fill
1723 in the scnhdrs with the info on the file postions
1724 */
1725 static void
1726 fill_section (abfd, h, file_cursor)
1727 bfd * abfd;
1728 object_headers *h;
1729 unsigned long *file_cursor;
1730 {
1731
1732 unsigned int i;
1733 unsigned int paddr = 0;
1734
1735 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
1736 {
1737 unsigned int offset = 0;
1738 struct internal_scnhdr *s = &(segment_info[i].scnhdr);
1739
1740 PROGRESS (1);
1741
1742 if (s->s_name[0])
1743 {
1744 fragS *frag = segment_info[i].frchainP->frch_root;
1745 char *buffer;
1746
1747 if (s->s_size == 0)
1748 s->s_scnptr = 0;
1749 else
1750 {
1751 buffer = xmalloc (s->s_size);
1752 s->s_scnptr = *file_cursor;
1753 }
1754 know (s->s_paddr == paddr);
1755
1756 if (strcmp (s->s_name, ".text") == 0)
1757 s->s_flags |= STYP_TEXT;
1758 else if (strcmp (s->s_name, ".data") == 0)
1759 s->s_flags |= STYP_DATA;
1760 else if (strcmp (s->s_name, ".bss") == 0)
1761 {
1762 s->s_scnptr = 0;
1763 s->s_flags |= STYP_BSS;
1764
1765 /* @@ Should make the i386 and a29k coff targets define
1766 COFF_NOLOAD_PROBLEM, and have only one test here. */
1767 #ifndef TC_I386
1768 #ifndef TC_A29K
1769 #ifndef COFF_NOLOAD_PROBLEM
1770 /* Apparently the SVR3 linker (and exec syscall) and UDI
1771 mondfe progrem are confused by noload sections. */
1772 s->s_flags |= STYP_NOLOAD;
1773 #endif
1774 #endif
1775 #endif
1776 }
1777 else if (strcmp (s->s_name, ".lit") == 0)
1778 s->s_flags = STYP_LIT | STYP_TEXT;
1779 else if (strcmp (s->s_name, ".init") == 0)
1780 s->s_flags |= STYP_TEXT;
1781 else if (strcmp (s->s_name, ".fini") == 0)
1782 s->s_flags |= STYP_TEXT;
1783 else if (strncmp (s->s_name, ".comment", 8) == 0)
1784 s->s_flags |= STYP_INFO;
1785
1786 while (frag)
1787 {
1788 unsigned int fill_size;
1789 switch (frag->fr_type)
1790 {
1791 case rs_machine_dependent:
1792 if (frag->fr_fix)
1793 {
1794 memcpy (buffer + frag->fr_address,
1795 frag->fr_literal,
1796 (unsigned int) frag->fr_fix);
1797 offset += frag->fr_fix;
1798 }
1799
1800 break;
1801 case rs_space:
1802 assert (frag->fr_symbol == 0);
1803 case rs_fill:
1804 case rs_align:
1805 case rs_align_code:
1806 case rs_org:
1807 if (frag->fr_fix)
1808 {
1809 memcpy (buffer + frag->fr_address,
1810 frag->fr_literal,
1811 (unsigned int) frag->fr_fix);
1812 offset += frag->fr_fix;
1813 }
1814
1815 fill_size = frag->fr_var;
1816 if (fill_size && frag->fr_offset > 0)
1817 {
1818 unsigned int count;
1819 unsigned int off = frag->fr_fix;
1820 for (count = frag->fr_offset; count; count--)
1821 {
1822 if (fill_size + frag->fr_address + off <= s->s_size)
1823 {
1824 memcpy (buffer + frag->fr_address + off,
1825 frag->fr_literal + frag->fr_fix,
1826 fill_size);
1827 off += fill_size;
1828 offset += fill_size;
1829 }
1830 }
1831 }
1832 break;
1833 case rs_broken_word:
1834 break;
1835 default:
1836 abort ();
1837 }
1838 frag = frag->fr_next;
1839 }
1840
1841 if (s->s_size != 0)
1842 {
1843 if (s->s_scnptr != 0)
1844 {
1845 bfd_write (buffer, s->s_size, 1, abfd);
1846 *file_cursor += s->s_size;
1847 }
1848 free (buffer);
1849 }
1850 paddr += s->s_size;
1851 }
1852 }
1853 }
1854
1855 /* Coff file generation & utilities */
1856
1857 static void
1858 coff_header_append (abfd, h)
1859 bfd * abfd;
1860 object_headers * h;
1861 {
1862 unsigned int i;
1863 char buffer[1000];
1864 char buffero[1000];
1865
1866 bfd_seek (abfd, 0, 0);
1867
1868 #ifndef OBJ_COFF_OMIT_OPTIONAL_HEADER
1869 H_SET_MAGIC_NUMBER (h, COFF_MAGIC);
1870 H_SET_VERSION_STAMP (h, 0);
1871 H_SET_ENTRY_POINT (h, 0);
1872 H_SET_TEXT_START (h, segment_info[SEG_E0].frchainP->frch_root->fr_address);
1873 H_SET_DATA_START (h, segment_info[SEG_E1].frchainP->frch_root->fr_address);
1874 H_SET_SIZEOF_OPTIONAL_HEADER (h, bfd_coff_swap_aouthdr_out(abfd, &h->aouthdr,
1875 buffero));
1876 #else /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
1877 H_SET_SIZEOF_OPTIONAL_HEADER (h, 0);
1878 #endif /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
1879
1880 i = bfd_coff_swap_filehdr_out (abfd, &h->filehdr, buffer);
1881
1882 bfd_write (buffer, i, 1, abfd);
1883 bfd_write (buffero, H_GET_SIZEOF_OPTIONAL_HEADER (h), 1, abfd);
1884
1885 for (i = SEG_E0; i < SEG_E9; i++)
1886 {
1887 if (segment_info[i].scnhdr.s_name[0])
1888 {
1889 unsigned int size =
1890 bfd_coff_swap_scnhdr_out (abfd,
1891 &(segment_info[i].scnhdr),
1892 buffer);
1893 if (size == 0)
1894 as_bad ("bfd_coff_swap_scnhdr_out failed");
1895 bfd_write (buffer, size, 1, abfd);
1896 }
1897 }
1898 }
1899
1900
1901 char *
1902 symbol_to_chars (abfd, where, symbolP)
1903 bfd * abfd;
1904 char *where;
1905 symbolS * symbolP;
1906 {
1907 unsigned int numaux = symbolP->sy_symbol.ost_entry.n_numaux;
1908 unsigned int i;
1909 valueT val;
1910
1911 /* Turn any symbols with register attributes into abs symbols */
1912 if (S_GET_SEGMENT (symbolP) == reg_section)
1913 {
1914 S_SET_SEGMENT (symbolP, absolute_section);
1915 }
1916 /* At the same time, relocate all symbols to their output value */
1917
1918 val = (segment_info[S_GET_SEGMENT (symbolP)].scnhdr.s_paddr
1919 + S_GET_VALUE (symbolP));
1920
1921 S_SET_VALUE (symbolP, val);
1922
1923 symbolP->sy_symbol.ost_entry.n_value = val;
1924
1925 where += bfd_coff_swap_sym_out (abfd, &symbolP->sy_symbol.ost_entry,
1926 where);
1927
1928 for (i = 0; i < numaux; i++)
1929 {
1930 where += bfd_coff_swap_aux_out (abfd,
1931 &symbolP->sy_symbol.ost_auxent[i],
1932 S_GET_DATA_TYPE (symbolP),
1933 S_GET_STORAGE_CLASS (symbolP),
1934 i, numaux, where);
1935 }
1936 return where;
1937
1938 }
1939
1940 void
1941 obj_symbol_new_hook (symbolP)
1942 symbolS *symbolP;
1943 {
1944 char underscore = 0; /* Symbol has leading _ */
1945
1946 /* Effective symbol */
1947 /* Store the pointer in the offset. */
1948 S_SET_ZEROES (symbolP, 0L);
1949 S_SET_DATA_TYPE (symbolP, T_NULL);
1950 S_SET_STORAGE_CLASS (symbolP, 0);
1951 S_SET_NUMBER_AUXILIARY (symbolP, 0);
1952 /* Additional information */
1953 symbolP->sy_symbol.ost_flags = 0;
1954 /* Auxiliary entries */
1955 memset ((char *) &symbolP->sy_symbol.ost_auxent[0], 0, AUXESZ);
1956
1957 if (S_IS_STRING (symbolP))
1958 SF_SET_STRING (symbolP);
1959 if (!underscore && S_IS_LOCAL (symbolP))
1960 SF_SET_LOCAL (symbolP);
1961 }
1962
1963 /*
1964 * Handle .ln directives.
1965 */
1966
1967 static void
1968 obj_coff_ln (appline)
1969 int appline;
1970 {
1971 int l;
1972
1973 if (! appline && def_symbol_in_progress != NULL)
1974 {
1975 as_warn (".ln pseudo-op inside .def/.endef: ignored.");
1976 demand_empty_rest_of_line ();
1977 return;
1978 } /* wrong context */
1979
1980 l = get_absolute_expression ();
1981 c_line_new (0, frag_now_fix (), l, frag_now);
1982 #ifndef NO_LISTING
1983 {
1984 extern int listing;
1985
1986 if (listing)
1987 {
1988 if (! appline)
1989 l += line_base - 1;
1990 listing_source_line ((unsigned int) l);
1991 }
1992
1993 }
1994 #endif
1995 demand_empty_rest_of_line ();
1996 }
1997
1998 /*
1999 * def()
2000 *
2001 * Handle .def directives.
2002 *
2003 * One might ask : why can't we symbol_new if the symbol does not
2004 * already exist and fill it with debug information. Because of
2005 * the C_EFCN special symbol. It would clobber the value of the
2006 * function symbol before we have a chance to notice that it is
2007 * a C_EFCN. And a second reason is that the code is more clear this
2008 * way. (at least I think it is :-).
2009 *
2010 */
2011
2012 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
2013 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
2014 *input_line_pointer == '\t') \
2015 input_line_pointer++;
2016
2017 static void
2018 obj_coff_def (what)
2019 int what;
2020 {
2021 char name_end; /* Char after the end of name */
2022 char *symbol_name; /* Name of the debug symbol */
2023 char *symbol_name_copy; /* Temporary copy of the name */
2024 unsigned int symbol_name_length;
2025
2026 if (def_symbol_in_progress != NULL)
2027 {
2028 as_warn (".def pseudo-op used inside of .def/.endef: ignored.");
2029 demand_empty_rest_of_line ();
2030 return;
2031 } /* if not inside .def/.endef */
2032
2033 SKIP_WHITESPACES ();
2034
2035 def_symbol_in_progress = (symbolS *) obstack_alloc (&notes, sizeof (*def_symbol_in_progress));
2036 memset (def_symbol_in_progress, 0, sizeof (*def_symbol_in_progress));
2037
2038 symbol_name = input_line_pointer;
2039 name_end = get_symbol_end ();
2040 symbol_name_length = strlen (symbol_name);
2041 symbol_name_copy = xmalloc (symbol_name_length + 1);
2042 strcpy (symbol_name_copy, symbol_name);
2043
2044 /* Initialize the new symbol */
2045 #ifdef STRIP_UNDERSCORE
2046 S_SET_NAME (def_symbol_in_progress, (*symbol_name_copy == '_'
2047 ? symbol_name_copy + 1
2048 : symbol_name_copy));
2049 #else /* STRIP_UNDERSCORE */
2050 S_SET_NAME (def_symbol_in_progress, symbol_name_copy);
2051 #endif /* STRIP_UNDERSCORE */
2052 /* free(symbol_name_copy); */
2053 def_symbol_in_progress->sy_name_offset = (unsigned long) ~0;
2054 def_symbol_in_progress->sy_number = ~0;
2055 def_symbol_in_progress->sy_frag = &zero_address_frag;
2056 S_SET_VALUE (def_symbol_in_progress, 0);
2057
2058 if (S_IS_STRING (def_symbol_in_progress))
2059 SF_SET_STRING (def_symbol_in_progress);
2060
2061 *input_line_pointer = name_end;
2062
2063 demand_empty_rest_of_line ();
2064 }
2065
2066 unsigned int dim_index;
2067
2068
2069 static void
2070 obj_coff_endef (ignore)
2071 int ignore;
2072 {
2073 symbolS *symbolP = 0;
2074 /* DIM BUG FIX sac@cygnus.com */
2075 dim_index = 0;
2076 if (def_symbol_in_progress == NULL)
2077 {
2078 as_warn (".endef pseudo-op used outside of .def/.endef: ignored.");
2079 demand_empty_rest_of_line ();
2080 return;
2081 } /* if not inside .def/.endef */
2082
2083 /* Set the section number according to storage class. */
2084 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))
2085 {
2086 case C_STRTAG:
2087 case C_ENTAG:
2088 case C_UNTAG:
2089 SF_SET_TAG (def_symbol_in_progress);
2090 /* intentional fallthrough */
2091 case C_FILE:
2092 case C_TPDEF:
2093 SF_SET_DEBUG (def_symbol_in_progress);
2094 S_SET_SEGMENT (def_symbol_in_progress, SEG_DEBUG);
2095 break;
2096
2097 case C_EFCN:
2098 SF_SET_LOCAL (def_symbol_in_progress); /* Do not emit this symbol. */
2099 /* intentional fallthrough */
2100 case C_BLOCK:
2101 SF_SET_PROCESS (def_symbol_in_progress); /* Will need processing before writing */
2102 /* intentional fallthrough */
2103 case C_FCN:
2104 S_SET_SEGMENT (def_symbol_in_progress, SEG_E0);
2105
2106 if (strcmp (S_GET_NAME (def_symbol_in_progress), ".bf") == 0)
2107 { /* .bf */
2108 if (function_lineoff < 0)
2109 {
2110 fprintf (stderr, "`.bf' symbol without preceding function\n");
2111 } /* missing function symbol */
2112 SA_GET_SYM_LNNOPTR (last_line_symbol) = function_lineoff;
2113
2114 SF_SET_PROCESS (last_line_symbol);
2115 function_lineoff = -1;
2116 }
2117 /* Value is always set to . */
2118 def_symbol_in_progress->sy_frag = frag_now;
2119 S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
2120 break;
2121
2122 #ifdef C_AUTOARG
2123 case C_AUTOARG:
2124 #endif /* C_AUTOARG */
2125 case C_AUTO:
2126 case C_REG:
2127 case C_MOS:
2128 case C_MOE:
2129 case C_MOU:
2130 case C_ARG:
2131 case C_REGPARM:
2132 case C_FIELD:
2133 case C_EOS:
2134 SF_SET_DEBUG (def_symbol_in_progress);
2135 S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
2136 break;
2137
2138 case C_EXT:
2139 case C_STAT:
2140 case C_LABEL:
2141 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
2142 break;
2143
2144 case C_USTATIC:
2145 case C_EXTDEF:
2146 case C_ULABEL:
2147 as_warn ("unexpected storage class %d", S_GET_STORAGE_CLASS (def_symbol_in_progress));
2148 break;
2149 } /* switch on storage class */
2150
2151 /* Now that we have built a debug symbol, try to find if we should
2152 merge with an existing symbol or not. If a symbol is C_EFCN or
2153 absolute_section or untagged SEG_DEBUG it never merges. We also
2154 don't merge labels, which are in a different namespace, nor
2155 symbols which have not yet been defined since they are typically
2156 unique, nor do we merge tags with non-tags. */
2157
2158 /* Two cases for functions. Either debug followed by definition or
2159 definition followed by debug. For definition first, we will
2160 merge the debug symbol into the definition. For debug first, the
2161 lineno entry MUST point to the definition function or else it
2162 will point off into space when crawl_symbols() merges the debug
2163 symbol into the real symbol. Therefor, let's presume the debug
2164 symbol is a real function reference. */
2165
2166 /* FIXME-SOON If for some reason the definition label/symbol is
2167 never seen, this will probably leave an undefined symbol at link
2168 time. */
2169
2170 if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN
2171 || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_LABEL
2172 || (S_GET_SEGMENT (def_symbol_in_progress) == SEG_DEBUG
2173 && !SF_GET_TAG (def_symbol_in_progress))
2174 || S_GET_SEGMENT (def_symbol_in_progress) == absolute_section
2175 || def_symbol_in_progress->sy_value.X_op != O_constant
2176 || (symbolP = symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP)) == NULL
2177 || (SF_GET_TAG (def_symbol_in_progress) != SF_GET_TAG (symbolP)))
2178 {
2179 symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP,
2180 &symbol_lastP);
2181 }
2182 else
2183 {
2184 /* This symbol already exists, merge the newly created symbol
2185 into the old one. This is not mandatory. The linker can
2186 handle duplicate symbols correctly. But I guess that it save
2187 a *lot* of space if the assembly file defines a lot of
2188 symbols. [loic] */
2189
2190 /* The debug entry (def_symbol_in_progress) is merged into the
2191 previous definition. */
2192
2193 c_symbol_merge (def_symbol_in_progress, symbolP);
2194 /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
2195 def_symbol_in_progress = symbolP;
2196
2197 if (SF_GET_FUNCTION (def_symbol_in_progress)
2198 || SF_GET_TAG (def_symbol_in_progress))
2199 {
2200 /* For functions, and tags, the symbol *must* be where the
2201 debug symbol appears. Move the existing symbol to the
2202 current place. */
2203 /* If it already is at the end of the symbol list, do nothing */
2204 if (def_symbol_in_progress != symbol_lastP)
2205 {
2206 symbol_remove (def_symbol_in_progress, &symbol_rootP,
2207 &symbol_lastP);
2208 symbol_append (def_symbol_in_progress, symbol_lastP,
2209 &symbol_rootP, &symbol_lastP);
2210 } /* if not already in place */
2211 } /* if function */
2212 } /* normal or mergable */
2213
2214 if (SF_GET_TAG (def_symbol_in_progress)
2215 && symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP) == NULL)
2216 {
2217 tag_insert (S_GET_NAME (def_symbol_in_progress), def_symbol_in_progress);
2218 }
2219
2220 if (SF_GET_FUNCTION (def_symbol_in_progress))
2221 {
2222 know (sizeof (def_symbol_in_progress) <= sizeof (long));
2223 function_lineoff
2224 = c_line_new (def_symbol_in_progress, 0, 0, &zero_address_frag);
2225
2226 SF_SET_PROCESS (def_symbol_in_progress);
2227
2228 if (symbolP == NULL)
2229 {
2230 /* That is, if this is the first time we've seen the
2231 function... */
2232 symbol_table_insert (def_symbol_in_progress);
2233 } /* definition follows debug */
2234 } /* Create the line number entry pointing to the function being defined */
2235
2236 def_symbol_in_progress = NULL;
2237 demand_empty_rest_of_line ();
2238 }
2239
2240 static void
2241 obj_coff_dim (ignore)
2242 int ignore;
2243 {
2244 int dim_index;
2245
2246 if (def_symbol_in_progress == NULL)
2247 {
2248 as_warn (".dim pseudo-op used outside of .def/.endef: ignored.");
2249 demand_empty_rest_of_line ();
2250 return;
2251 } /* if not inside .def/.endef */
2252
2253 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2254
2255 for (dim_index = 0; dim_index < DIMNUM; dim_index++)
2256 {
2257 SKIP_WHITESPACES ();
2258 SA_SET_SYM_DIMEN (def_symbol_in_progress, dim_index,
2259 get_absolute_expression ());
2260
2261 switch (*input_line_pointer)
2262 {
2263 case ',':
2264 input_line_pointer++;
2265 break;
2266
2267 default:
2268 as_warn ("badly formed .dim directive ignored");
2269 /* intentional fallthrough */
2270 case '\n':
2271 case ';':
2272 dim_index = DIMNUM;
2273 break;
2274 }
2275 }
2276
2277 demand_empty_rest_of_line ();
2278 }
2279
2280 static void
2281 obj_coff_line (ignore)
2282 int ignore;
2283 {
2284 int this_base;
2285 const char *name;
2286
2287 if (def_symbol_in_progress == NULL)
2288 {
2289 obj_coff_ln (0);
2290 return;
2291 }
2292
2293 name = S_GET_NAME (def_symbol_in_progress);
2294 this_base = get_absolute_expression ();
2295
2296 /* Only .bf symbols indicate the use of a new base line number; the
2297 line numbers associated with .ef, .bb, .eb are relative to the
2298 start of the containing function. */
2299 if (!strcmp (".bf", name))
2300 {
2301 #if 0 /* XXX Can we ever have line numbers going backwards? */
2302 if (this_base > line_base)
2303 #endif
2304 {
2305 line_base = this_base;
2306 }
2307
2308 #ifndef NO_LISTING
2309 {
2310 extern int listing;
2311 if (listing)
2312 {
2313 listing_source_line ((unsigned int) line_base);
2314 }
2315 }
2316 #endif
2317 }
2318
2319 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2320 SA_SET_SYM_LNNO (def_symbol_in_progress, this_base);
2321
2322 demand_empty_rest_of_line ();
2323 }
2324
2325 static void
2326 obj_coff_size (ignore)
2327 int ignore;
2328 {
2329 if (def_symbol_in_progress == NULL)
2330 {
2331 as_warn (".size pseudo-op used outside of .def/.endef ignored.");
2332 demand_empty_rest_of_line ();
2333 return;
2334 } /* if not inside .def/.endef */
2335
2336 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2337 SA_SET_SYM_SIZE (def_symbol_in_progress, get_absolute_expression ());
2338 demand_empty_rest_of_line ();
2339 }
2340
2341 static void
2342 obj_coff_scl (ignore)
2343 int ignore;
2344 {
2345 if (def_symbol_in_progress == NULL)
2346 {
2347 as_warn (".scl pseudo-op used outside of .def/.endef ignored.");
2348 demand_empty_rest_of_line ();
2349 return;
2350 } /* if not inside .def/.endef */
2351
2352 S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ());
2353 demand_empty_rest_of_line ();
2354 }
2355
2356 static void
2357 obj_coff_tag (ignore)
2358 int ignore;
2359 {
2360 char *symbol_name;
2361 char name_end;
2362
2363 if (def_symbol_in_progress == NULL)
2364 {
2365 as_warn (".tag pseudo-op used outside of .def/.endef ignored.");
2366 demand_empty_rest_of_line ();
2367 return;
2368 }
2369
2370 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2371 symbol_name = input_line_pointer;
2372 name_end = get_symbol_end ();
2373
2374 /* Assume that the symbol referred to by .tag is always defined.
2375 This was a bad assumption. I've added find_or_make. xoxorich. */
2376 SA_SET_SYM_TAGNDX (def_symbol_in_progress,
2377 (long) tag_find_or_make (symbol_name));
2378 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L)
2379 {
2380 as_warn ("tag not found for .tag %s", symbol_name);
2381 } /* not defined */
2382
2383 SF_SET_TAGGED (def_symbol_in_progress);
2384 *input_line_pointer = name_end;
2385
2386 demand_empty_rest_of_line ();
2387 }
2388
2389 static void
2390 obj_coff_type (ignore)
2391 int ignore;
2392 {
2393 if (def_symbol_in_progress == NULL)
2394 {
2395 as_warn (".type pseudo-op used outside of .def/.endef ignored.");
2396 demand_empty_rest_of_line ();
2397 return;
2398 } /* if not inside .def/.endef */
2399
2400 S_SET_DATA_TYPE (def_symbol_in_progress, get_absolute_expression ());
2401
2402 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress)) &&
2403 S_GET_STORAGE_CLASS (def_symbol_in_progress) != C_TPDEF)
2404 {
2405 SF_SET_FUNCTION (def_symbol_in_progress);
2406 } /* is a function */
2407
2408 demand_empty_rest_of_line ();
2409 }
2410
2411 static void
2412 obj_coff_val (ignore)
2413 int ignore;
2414 {
2415 if (def_symbol_in_progress == NULL)
2416 {
2417 as_warn (".val pseudo-op used outside of .def/.endef ignored.");
2418 demand_empty_rest_of_line ();
2419 return;
2420 } /* if not inside .def/.endef */
2421
2422 if (is_name_beginner (*input_line_pointer))
2423 {
2424 char *symbol_name = input_line_pointer;
2425 char name_end = get_symbol_end ();
2426
2427 if (!strcmp (symbol_name, "."))
2428 {
2429 def_symbol_in_progress->sy_frag = frag_now;
2430 S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
2431 /* If the .val is != from the .def (e.g. statics) */
2432 }
2433 else if (strcmp (S_GET_NAME (def_symbol_in_progress), symbol_name))
2434 {
2435 def_symbol_in_progress->sy_value.X_op = O_symbol;
2436 def_symbol_in_progress->sy_value.X_add_symbol =
2437 symbol_find_or_make (symbol_name);
2438 def_symbol_in_progress->sy_value.X_op_symbol = NULL;
2439 def_symbol_in_progress->sy_value.X_add_number = 0;
2440
2441 /* If the segment is undefined when the forward reference is
2442 resolved, then copy the segment id from the forward
2443 symbol. */
2444 SF_SET_GET_SEGMENT (def_symbol_in_progress);
2445
2446 /* FIXME: gcc can generate address expressions
2447 here in unusual cases (search for "obscure"
2448 in sdbout.c). We just ignore the offset
2449 here, thus generating incorrect debugging
2450 information. We ignore the rest of the
2451 line just below. */
2452 }
2453 /* Otherwise, it is the name of a non debug symbol and
2454 its value will be calculated later. */
2455 *input_line_pointer = name_end;
2456
2457 /* FIXME: this is to avoid an error message in the
2458 FIXME case mentioned just above. */
2459 while (! is_end_of_line[(unsigned char) *input_line_pointer])
2460 ++input_line_pointer;
2461 }
2462 else
2463 {
2464 S_SET_VALUE (def_symbol_in_progress,
2465 (valueT) get_absolute_expression ());
2466 } /* if symbol based */
2467
2468 demand_empty_rest_of_line ();
2469 }
2470
2471 void
2472 obj_read_begin_hook ()
2473 {
2474 /* These had better be the same. Usually 18 bytes. */
2475 #ifndef BFD_HEADERS
2476 know (sizeof (SYMENT) == sizeof (AUXENT));
2477 know (SYMESZ == AUXESZ);
2478 #endif
2479 tag_init ();
2480 }
2481
2482 /* This function runs through the symbol table and puts all the
2483 externals onto another chain */
2484
2485 /* The chain of globals. */
2486 symbolS *symbol_globalP;
2487 symbolS *symbol_global_lastP;
2488
2489 /* The chain of externals */
2490 symbolS *symbol_externP;
2491 symbolS *symbol_extern_lastP;
2492
2493 stack *block_stack;
2494 symbolS *last_functionP;
2495 symbolS *last_tagP;
2496
2497 static unsigned int
2498 yank_symbols ()
2499 {
2500 symbolS *symbolP;
2501 unsigned int symbol_number = 0;
2502 unsigned int last_file_symno = 0;
2503
2504 struct filename_list *filename_list_scan = filename_list_head;
2505
2506 for (symbolP = symbol_rootP;
2507 symbolP;
2508 symbolP = symbolP ? symbol_next (symbolP) : symbol_rootP)
2509 {
2510 if (symbolP->sy_mri_common)
2511 {
2512 if (S_GET_STORAGE_CLASS (symbolP) == C_EXT)
2513 as_bad ("%s: global symbols not supported in common sections",
2514 S_GET_NAME (symbolP));
2515 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2516 continue;
2517 }
2518
2519 if (!SF_GET_DEBUG (symbolP))
2520 {
2521 /* Debug symbols do not need all this rubbish */
2522 symbolS *real_symbolP;
2523
2524 /* L* and C_EFCN symbols never merge. */
2525 if (!SF_GET_LOCAL (symbolP)
2526 && S_GET_STORAGE_CLASS (symbolP) != C_LABEL
2527 && symbolP->sy_value.X_op == O_constant
2528 && (real_symbolP = symbol_find_base (S_GET_NAME (symbolP), DO_NOT_STRIP))
2529 && real_symbolP != symbolP)
2530 {
2531 /* FIXME-SOON: where do dups come from?
2532 Maybe tag references before definitions? xoxorich. */
2533 /* Move the debug data from the debug symbol to the
2534 real symbol. Do NOT do the oposite (i.e. move from
2535 real symbol to debug symbol and remove real symbol from the
2536 list.) Because some pointers refer to the real symbol
2537 whereas no pointers refer to the debug symbol. */
2538 c_symbol_merge (symbolP, real_symbolP);
2539 /* Replace the current symbol by the real one */
2540 /* The symbols will never be the last or the first
2541 because : 1st symbol is .file and 3 last symbols are
2542 .text, .data, .bss */
2543 symbol_remove (real_symbolP, &symbol_rootP, &symbol_lastP);
2544 symbol_insert (real_symbolP, symbolP, &symbol_rootP, &symbol_lastP);
2545 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2546 symbolP = real_symbolP;
2547 } /* if not local but dup'd */
2548
2549 if (flag_readonly_data_in_text && (S_GET_SEGMENT (symbolP) == SEG_E1))
2550 {
2551 S_SET_SEGMENT (symbolP, SEG_E0);
2552 } /* push data into text */
2553
2554 resolve_symbol_value (symbolP);
2555
2556 if (S_GET_STORAGE_CLASS (symbolP) == C_NULL)
2557 {
2558 if (!S_IS_DEFINED (symbolP) && !SF_GET_LOCAL (symbolP))
2559 {
2560 S_SET_EXTERNAL (symbolP);
2561 }
2562 else if (S_GET_SEGMENT (symbolP) == SEG_E0)
2563 {
2564 S_SET_STORAGE_CLASS (symbolP, C_LABEL);
2565 }
2566 else
2567 {
2568 S_SET_STORAGE_CLASS (symbolP, C_STAT);
2569 }
2570 }
2571
2572 /* Mainly to speed up if not -g */
2573 if (SF_GET_PROCESS (symbolP))
2574 {
2575 /* Handle the nested blocks auxiliary info. */
2576 if (S_GET_STORAGE_CLASS (symbolP) == C_BLOCK)
2577 {
2578 if (!strcmp (S_GET_NAME (symbolP), ".bb"))
2579 stack_push (block_stack, (char *) &symbolP);
2580 else
2581 { /* .eb */
2582 register symbolS *begin_symbolP;
2583 begin_symbolP = *(symbolS **) stack_pop (block_stack);
2584 if (begin_symbolP == (symbolS *) 0)
2585 as_warn ("mismatched .eb");
2586 else
2587 SA_SET_SYM_ENDNDX (begin_symbolP, symbol_number + 2);
2588 }
2589 }
2590 /* If we are able to identify the type of a function, and we
2591 are out of a function (last_functionP == 0) then, the
2592 function symbol will be associated with an auxiliary
2593 entry. */
2594 if (last_functionP == (symbolS *) 0 &&
2595 SF_GET_FUNCTION (symbolP))
2596 {
2597 last_functionP = symbolP;
2598
2599 if (S_GET_NUMBER_AUXILIARY (symbolP) < 1)
2600 {
2601 S_SET_NUMBER_AUXILIARY (symbolP, 1);
2602 } /* make it at least 1 */
2603
2604 /* Clobber possible stale .dim information. */
2605 #if 0
2606 /* Iffed out by steve - this fries the lnnoptr info too */
2607 bzero (symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen,
2608 sizeof (symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen));
2609 #endif
2610 }
2611 /* The C_FCN doesn't need any additional information. I
2612 don't even know if this is needed for sdb. But the
2613 standard assembler generates it, so... */
2614 if (S_GET_STORAGE_CLASS (symbolP) == C_EFCN)
2615 {
2616 if (last_functionP == (symbolS *) 0)
2617 as_fatal ("C_EFCN symbol out of scope");
2618 SA_SET_SYM_FSIZE (last_functionP,
2619 (long) (S_GET_VALUE (symbolP) -
2620 S_GET_VALUE (last_functionP)));
2621 SA_SET_SYM_ENDNDX (last_functionP, symbol_number);
2622 last_functionP = (symbolS *) 0;
2623 }
2624 }
2625 }
2626 else if (SF_GET_TAG (symbolP))
2627 {
2628 /* First descriptor of a structure must point to
2629 the first slot after the structure description. */
2630 last_tagP = symbolP;
2631
2632 }
2633 else if (S_GET_STORAGE_CLASS (symbolP) == C_EOS)
2634 {
2635 /* +2 take in account the current symbol */
2636 SA_SET_SYM_ENDNDX (last_tagP, symbol_number + 2);
2637 }
2638 else if (S_GET_STORAGE_CLASS (symbolP) == C_FILE)
2639 {
2640 /* If the filename was too long to fit in the
2641 auxent, put it in the string table */
2642 if (SA_GET_FILE_FNAME_ZEROS (symbolP) == 0)
2643 {
2644 SA_SET_FILE_FNAME_OFFSET (symbolP, string_byte_count);
2645 string_byte_count += strlen (filename_list_scan->filename) + 1;
2646 filename_list_scan = filename_list_scan->next;
2647 }
2648 if (S_GET_VALUE (symbolP))
2649 {
2650 S_SET_VALUE (symbolP, last_file_symno);
2651 last_file_symno = symbol_number;
2652 } /* no one points at the first .file symbol */
2653 } /* if debug or tag or eos or file */
2654
2655 /* We must put the external symbols apart. The loader
2656 does not bomb if we do not. But the references in
2657 the endndx field for a .bb symbol are not corrected
2658 if an external symbol is removed between .bb and .be.
2659 I.e in the following case :
2660 [20] .bb endndx = 22
2661 [21] foo external
2662 [22] .be
2663 ld will move the symbol 21 to the end of the list but
2664 endndx will still be 22 instead of 21. */
2665
2666
2667 if (SF_GET_LOCAL (symbolP))
2668 {
2669 /* remove C_EFCN and LOCAL (L...) symbols */
2670 /* next pointer remains valid */
2671 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2672
2673 }
2674 else if (!S_IS_DEFINED (symbolP)
2675 && !S_IS_DEBUG (symbolP)
2676 && !SF_GET_STATICS (symbolP) &&
2677 S_GET_STORAGE_CLASS (symbolP) == C_EXT)
2678 { /* C_EXT && !SF_GET_FUNCTION(symbolP)) */
2679 /* if external, Remove from the list */
2680 symbolS *hold = symbol_previous (symbolP);
2681
2682 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2683 symbol_clear_list_pointers (symbolP);
2684 symbol_append (symbolP, symbol_extern_lastP, &symbol_externP, &symbol_extern_lastP);
2685 symbolP = hold;
2686 }
2687 else if (! S_IS_DEBUG (symbolP)
2688 && ! SF_GET_STATICS (symbolP)
2689 && ! SF_GET_FUNCTION (symbolP)
2690 && S_GET_STORAGE_CLASS (symbolP) == C_EXT)
2691 {
2692 symbolS *hold = symbol_previous (symbolP);
2693
2694 /* The O'Reilly COFF book says that defined global symbols
2695 come at the end of the symbol table, just before
2696 undefined global symbols. */
2697
2698 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2699 symbol_clear_list_pointers (symbolP);
2700 symbol_append (symbolP, symbol_global_lastP, &symbol_globalP,
2701 &symbol_global_lastP);
2702 symbolP = hold;
2703 }
2704 else
2705 {
2706 if (SF_GET_STRING (symbolP))
2707 {
2708 symbolP->sy_name_offset = string_byte_count;
2709 string_byte_count += strlen (S_GET_NAME (symbolP)) + 1;
2710 }
2711 else
2712 {
2713 symbolP->sy_name_offset = 0;
2714 } /* fix "long" names */
2715
2716 symbolP->sy_number = symbol_number;
2717 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (symbolP);
2718 } /* if local symbol */
2719 } /* traverse the symbol list */
2720 return symbol_number;
2721
2722 }
2723
2724
2725 static unsigned int
2726 glue_symbols (head, tail)
2727 symbolS **head;
2728 symbolS **tail;
2729 {
2730 unsigned int symbol_number = 0;
2731 symbolS *symbolP;
2732
2733 for (symbolP = *head; *head != NULL;)
2734 {
2735 symbolS *tmp = *head;
2736
2737 /* append */
2738 symbol_remove (tmp, head, tail);
2739 symbol_append (tmp, symbol_lastP, &symbol_rootP, &symbol_lastP);
2740
2741 /* and process */
2742 if (SF_GET_STRING (tmp))
2743 {
2744 tmp->sy_name_offset = string_byte_count;
2745 string_byte_count += strlen (S_GET_NAME (tmp)) + 1;
2746 }
2747 else
2748 {
2749 tmp->sy_name_offset = 0;
2750 } /* fix "long" names */
2751
2752 tmp->sy_number = symbol_number;
2753 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (tmp);
2754 } /* append the entire extern chain */
2755
2756 return symbol_number;
2757 }
2758
2759 static unsigned int
2760 tie_tags ()
2761 {
2762 unsigned int symbol_number = 0;
2763
2764 symbolS *symbolP;
2765 for (symbolP = symbol_rootP; symbolP; symbolP =
2766 symbol_next (symbolP))
2767 {
2768 symbolP->sy_number = symbol_number;
2769
2770
2771
2772 if (SF_GET_TAGGED (symbolP))
2773 {
2774 SA_SET_SYM_TAGNDX
2775 (symbolP,
2776 ((symbolS *) SA_GET_SYM_TAGNDX (symbolP))->sy_number);
2777 }
2778
2779 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (symbolP);
2780 }
2781 return symbol_number;
2782
2783 }
2784
2785 static void
2786 crawl_symbols (h, abfd)
2787 object_headers *h;
2788 bfd * abfd;
2789 {
2790 unsigned int i;
2791
2792 /* Initialize the stack used to keep track of the matching .bb .be */
2793
2794 block_stack = stack_init (512, sizeof (symbolS *));
2795
2796 /* The symbol list should be ordered according to the following sequence
2797 * order :
2798 * . .file symbol
2799 * . debug entries for functions
2800 * . fake symbols for the sections, including.text .data and .bss
2801 * . defined symbols
2802 * . undefined symbols
2803 * But this is not mandatory. The only important point is to put the
2804 * undefined symbols at the end of the list.
2805 */
2806
2807 if (symbol_rootP == NULL
2808 || S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
2809 {
2810 c_dot_file_symbol ("fake");
2811 }
2812 /* Is there a .file symbol ? If not insert one at the beginning. */
2813
2814 /*
2815 * Build up static symbols for the sections, they are filled in later
2816 */
2817
2818
2819 for (i = SEG_E0; i < SEG_E9; i++)
2820 {
2821 if (segment_info[i].scnhdr.s_name[0])
2822 {
2823 char name[9];
2824
2825 strncpy (name, segment_info[i].scnhdr.s_name, 8);
2826 name[8] = '\0';
2827 segment_info[i].dot = c_section_symbol (name, i - SEG_E0 + 1);
2828 }
2829 }
2830
2831
2832 /* Take all the externals out and put them into another chain */
2833 H_SET_SYMBOL_TABLE_SIZE (h, yank_symbols ());
2834 /* Take the externals and glue them onto the end.*/
2835 H_SET_SYMBOL_TABLE_SIZE (h,
2836 (H_GET_SYMBOL_COUNT (h)
2837 + glue_symbols (&symbol_globalP,
2838 &symbol_global_lastP)
2839 + glue_symbols (&symbol_externP,
2840 &symbol_extern_lastP)));
2841
2842 H_SET_SYMBOL_TABLE_SIZE (h, tie_tags ());
2843 know (symbol_globalP == NULL);
2844 know (symbol_global_lastP == NULL);
2845 know (symbol_externP == NULL);
2846 know (symbol_extern_lastP == NULL);
2847 }
2848
2849 /*
2850 * Find strings by crawling along symbol table chain.
2851 */
2852
2853 void
2854 w_strings (where)
2855 char *where;
2856 {
2857 symbolS *symbolP;
2858 struct filename_list *filename_list_scan = filename_list_head;
2859
2860 /* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
2861 md_number_to_chars (where, (valueT) string_byte_count, 4);
2862 where += 4;
2863 for (symbolP = symbol_rootP;
2864 symbolP;
2865 symbolP = symbol_next (symbolP))
2866 {
2867 unsigned int size;
2868
2869 if (SF_GET_STRING (symbolP))
2870 {
2871 size = strlen (S_GET_NAME (symbolP)) + 1;
2872 memcpy (where, S_GET_NAME (symbolP), size);
2873 where += size;
2874 }
2875 if (S_GET_STORAGE_CLASS (symbolP) == C_FILE
2876 && SA_GET_FILE_FNAME_ZEROS (symbolP) == 0)
2877 {
2878 size = strlen (filename_list_scan->filename) + 1;
2879 memcpy (where, filename_list_scan->filename, size);
2880 filename_list_scan = filename_list_scan ->next;
2881 where += size;
2882 }
2883 }
2884 }
2885
2886 static void
2887 do_linenos_for (abfd, h, file_cursor)
2888 bfd * abfd;
2889 object_headers * h;
2890 unsigned long *file_cursor;
2891 {
2892 unsigned int idx;
2893 unsigned long start = *file_cursor;
2894
2895 for (idx = SEG_E0; idx < SEG_E9; idx++)
2896 {
2897 segment_info_type *s = segment_info + idx;
2898
2899
2900 if (s->scnhdr.s_nlnno != 0)
2901 {
2902 struct lineno_list *line_ptr;
2903
2904 struct external_lineno *buffer =
2905 (struct external_lineno *) xmalloc (s->scnhdr.s_nlnno * LINESZ);
2906
2907 struct external_lineno *dst = buffer;
2908
2909 /* Run through the table we've built and turn it into its external
2910 form, take this chance to remove duplicates */
2911
2912 for (line_ptr = s->lineno_list_head;
2913 line_ptr != (struct lineno_list *) NULL;
2914 line_ptr = line_ptr->next)
2915 {
2916
2917 if (line_ptr->line.l_lnno == 0)
2918 {
2919 /* Turn a pointer to a symbol into the symbols' index */
2920 line_ptr->line.l_addr.l_symndx =
2921 ((symbolS *) line_ptr->line.l_addr.l_symndx)->sy_number;
2922 }
2923 else
2924 {
2925 line_ptr->line.l_addr.l_paddr += ((struct frag *) (line_ptr->frag))->fr_address;
2926 }
2927
2928
2929 (void) bfd_coff_swap_lineno_out (abfd, &(line_ptr->line), dst);
2930 dst++;
2931
2932 }
2933
2934 s->scnhdr.s_lnnoptr = *file_cursor;
2935
2936 bfd_write (buffer, 1, s->scnhdr.s_nlnno * LINESZ, abfd);
2937 free (buffer);
2938
2939 *file_cursor += s->scnhdr.s_nlnno * LINESZ;
2940 }
2941 }
2942 H_SET_LINENO_SIZE (h, *file_cursor - start);
2943 }
2944
2945
2946 /* Now we run through the list of frag chains in a segment and
2947 make all the subsegment frags appear at the end of the
2948 list, as if the seg 0 was extra long */
2949
2950 static void
2951 remove_subsegs ()
2952 {
2953 unsigned int i;
2954
2955 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
2956 {
2957 frchainS *head = segment_info[i].frchainP;
2958 fragS dummy;
2959 fragS *prev_frag = &dummy;
2960
2961 while (head && head->frch_seg == i)
2962 {
2963 prev_frag->fr_next = head->frch_root;
2964 prev_frag = head->frch_last;
2965 head = head->frch_next;
2966 }
2967 prev_frag->fr_next = 0;
2968 }
2969 }
2970
2971 unsigned long machine;
2972 int coff_flags;
2973 extern void
2974 write_object_file ()
2975 {
2976 int i;
2977 char *name;
2978 struct frchain *frchain_ptr;
2979
2980 object_headers headers;
2981 unsigned long file_cursor;
2982 bfd *abfd;
2983 unsigned int addr;
2984 abfd = bfd_openw (out_file_name, TARGET_FORMAT);
2985
2986
2987 if (abfd == 0)
2988 {
2989 as_perror ("FATAL: Can't create %s", out_file_name);
2990 exit (EXIT_FAILURE);
2991 }
2992 bfd_set_format (abfd, bfd_object);
2993 bfd_set_arch_mach (abfd, BFD_ARCH, machine);
2994
2995 string_byte_count = 4;
2996
2997 for (frchain_ptr = frchain_root;
2998 frchain_ptr != (struct frchain *) NULL;
2999 frchain_ptr = frchain_ptr->frch_next)
3000 {
3001 /* Run through all the sub-segments and align them up. Also
3002 close any open frags. We tack a .fill onto the end of the
3003 frag chain so that any .align's size can be worked by looking
3004 at the next frag. */
3005
3006 subseg_set (frchain_ptr->frch_seg, frchain_ptr->frch_subseg);
3007 #ifndef SUB_SEGMENT_ALIGN
3008 #define SUB_SEGMENT_ALIGN(SEG) 1
3009 #endif
3010 #ifdef md_do_align
3011 {
3012 static char nop = NOP_OPCODE;
3013 md_do_align (SUB_SEGMENT_ALIGN (now_seg), &nop, alignment_done);
3014 }
3015 #endif
3016 frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE);
3017 #ifdef md_do_align
3018 alignment_done:
3019 #endif
3020 frag_wane (frag_now);
3021 frag_now->fr_fix = 0;
3022 know (frag_now->fr_next == NULL);
3023 }
3024
3025
3026 remove_subsegs ();
3027
3028
3029 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3030 {
3031 relax_segment (segment_info[i].frchainP->frch_root, i);
3032 }
3033
3034 H_SET_NUMBER_OF_SECTIONS (&headers, 0);
3035
3036 /* Find out how big the sections are, and set the addresses. */
3037 addr = 0;
3038 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3039 {
3040 long size;
3041
3042 segment_info[i].scnhdr.s_paddr = addr;
3043 segment_info[i].scnhdr.s_vaddr = addr;
3044
3045 if (segment_info[i].scnhdr.s_name[0])
3046 {
3047 H_SET_NUMBER_OF_SECTIONS (&headers,
3048 H_GET_NUMBER_OF_SECTIONS (&headers) + 1);
3049 }
3050
3051 size = size_section (abfd, (unsigned int) i);
3052 addr += size;
3053
3054 /* I think the section alignment is only used on the i960; the
3055 i960 needs it, and it should do no harm on other targets. */
3056 segment_info[i].scnhdr.s_align = section_alignment[i];
3057
3058 if (i == SEG_E0)
3059 H_SET_TEXT_SIZE (&headers, size);
3060 else if (i == SEG_E1)
3061 H_SET_DATA_SIZE (&headers, size);
3062 else if (i == SEG_E2)
3063 H_SET_BSS_SIZE (&headers, size);
3064 }
3065
3066 /* Turn the gas native symbol table shape into a coff symbol table */
3067 crawl_symbols (&headers, abfd);
3068
3069 if (string_byte_count == 4)
3070 string_byte_count = 0;
3071
3072 H_SET_STRING_SIZE (&headers, string_byte_count);
3073
3074 #ifdef tc_frob_file
3075 tc_frob_file ();
3076 #endif
3077
3078 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3079 {
3080 fixup_mdeps (segment_info[i].frchainP->frch_root, &headers, i);
3081 fixup_segment (&segment_info[i], i);
3082 }
3083
3084 /* Look for ".stab" segments and fill in their initial symbols
3085 correctly. */
3086 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3087 {
3088 name = segment_info[i].scnhdr.s_name;
3089
3090 if (name != NULL
3091 && strncmp (".stab", name, 5) == 0
3092 && strncmp (".stabstr", name, 8) != 0)
3093 adjust_stab_section (abfd, i);
3094 }
3095
3096 file_cursor = H_GET_TEXT_FILE_OFFSET (&headers);
3097
3098 bfd_seek (abfd, (file_ptr) file_cursor, 0);
3099
3100 /* Plant the data */
3101
3102 fill_section (abfd, &headers, &file_cursor);
3103
3104 do_relocs_for (abfd, &headers, &file_cursor);
3105
3106 do_linenos_for (abfd, &headers, &file_cursor);
3107
3108 H_SET_FILE_MAGIC_NUMBER (&headers, COFF_MAGIC);
3109 #ifndef OBJ_COFF_OMIT_TIMESTAMP
3110 H_SET_TIME_STAMP (&headers, (long)time((time_t *)0));
3111 #else
3112 H_SET_TIME_STAMP (&headers, 0);
3113 #endif
3114 #ifdef TC_COFF_SET_MACHINE
3115 TC_COFF_SET_MACHINE (&headers);
3116 #endif
3117
3118 #ifndef COFF_FLAGS
3119 #define COFF_FLAGS 0
3120 #endif
3121
3122 #ifdef KEEP_RELOC_INFO
3123 H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
3124 COFF_FLAGS | coff_flags));
3125 #else
3126 H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
3127 (H_GET_RELOCATION_SIZE(&headers) ? 0 : F_RELFLG) |
3128 COFF_FLAGS | coff_flags));
3129 #endif
3130
3131 {
3132 unsigned int symtable_size = H_GET_SYMBOL_TABLE_SIZE (&headers);
3133 char *buffer1 = xmalloc (symtable_size + string_byte_count + 1);
3134
3135 H_SET_SYMBOL_TABLE_POINTER (&headers, bfd_tell (abfd));
3136 w_symbols (abfd, buffer1, symbol_rootP);
3137 if (string_byte_count > 0)
3138 w_strings (buffer1 + symtable_size);
3139 bfd_write (buffer1, 1, symtable_size + string_byte_count, abfd);
3140 free (buffer1);
3141 }
3142
3143 coff_header_append (abfd, &headers);
3144 #if 0
3145 /* Recent changes to write need this, but where it should
3146 go is up to Ken.. */
3147 if (bfd_close_all_done (abfd) == false)
3148 as_fatal ("Can't close %s: %s", out_file_name,
3149 bfd_errmsg (bfd_get_error ()));
3150 #else
3151 {
3152 extern bfd *stdoutput;
3153 stdoutput = abfd;
3154 }
3155 #endif
3156
3157 }
3158
3159 /* Add a new segment. This is called from subseg_new via the
3160 obj_new_segment macro. */
3161
3162 segT
3163 obj_coff_add_segment (name)
3164 const char *name;
3165 {
3166 unsigned int len;
3167 unsigned int i;
3168
3169 /* Find out if we've already got a section of this name. */
3170 len = strlen (name);
3171 if (len < sizeof (segment_info[i].scnhdr.s_name))
3172 ++len;
3173 else
3174 len = sizeof (segment_info[i].scnhdr.s_name);
3175 for (i = SEG_E0; i < SEG_E9 && segment_info[i].scnhdr.s_name[0]; i++)
3176 if (strncmp (segment_info[i].scnhdr.s_name, name, len) == 0
3177 && (len == sizeof (segment_info[i].scnhdr.s_name)
3178 || segment_info[i].scnhdr.s_name[len] == '\0'))
3179 return (segT) i;
3180
3181 if (i == SEG_E9)
3182 {
3183 as_bad ("Too many new sections; can't add \"%s\"", name);
3184 return now_seg;
3185 }
3186
3187 /* Add a new section. */
3188 strncpy (segment_info[i].scnhdr.s_name, name,
3189 sizeof (segment_info[i].scnhdr.s_name));
3190 segment_info[i].scnhdr.s_flags = STYP_REG;
3191
3192 return (segT) i;
3193 }
3194
3195 /*
3196 * implement the .section pseudo op:
3197 * .section name {, "flags"}
3198 * ^ ^
3199 * | +--- optional flags: 'b' for bss
3200 * | 'i' for info
3201 * +-- section name 'l' for lib
3202 * 'n' for noload
3203 * 'o' for over
3204 * 'w' for data
3205 * 'd' (apparently m88k for data)
3206 * 'x' for text
3207 * But if the argument is not a quoted string, treat it as a
3208 * subsegment number.
3209 */
3210
3211 void
3212 obj_coff_section (ignore)
3213 int ignore;
3214 {
3215 /* Strip out the section name */
3216 char *section_name;
3217 char *section_name_end;
3218 char c;
3219 int argp;
3220 unsigned int len;
3221 unsigned int exp;
3222 long flags;
3223
3224 if (flag_mri)
3225 {
3226 char type;
3227
3228 s_mri_sect (&type);
3229 flags = 0;
3230 if (type == 'C')
3231 flags = STYP_TEXT;
3232 else if (type == 'D')
3233 flags = STYP_DATA;
3234 segment_info[now_seg].scnhdr.s_flags |= flags;
3235
3236 return;
3237 }
3238
3239 section_name = input_line_pointer;
3240 c = get_symbol_end ();
3241 section_name_end = input_line_pointer;
3242
3243 len = section_name_end - section_name;
3244 input_line_pointer++;
3245 SKIP_WHITESPACE ();
3246
3247 argp = 0;
3248 if (c == ',')
3249 argp = 1;
3250 else if (*input_line_pointer == ',')
3251 {
3252 argp = 1;
3253 ++input_line_pointer;
3254 SKIP_WHITESPACE ();
3255 }
3256
3257 exp = 0;
3258 flags = 0;
3259 if (argp)
3260 {
3261 if (*input_line_pointer != '"')
3262 exp = get_absolute_expression ();
3263 else
3264 {
3265 ++input_line_pointer;
3266 while (*input_line_pointer != '"'
3267 && ! is_end_of_line[(unsigned char) *input_line_pointer])
3268 {
3269 switch (*input_line_pointer)
3270 {
3271 case 'b': flags |= STYP_BSS; break;
3272 case 'i': flags |= STYP_INFO; break;
3273 case 'l': flags |= STYP_LIB; break;
3274 case 'n': flags |= STYP_NOLOAD; break;
3275 case 'o': flags |= STYP_OVER; break;
3276 case 'd':
3277 case 'w': flags |= STYP_DATA; break;
3278 case 'x': flags |= STYP_TEXT; break;
3279 default:
3280 as_warn("unknown section attribute '%c'",
3281 *input_line_pointer);
3282 break;
3283 }
3284 ++input_line_pointer;
3285 }
3286 if (*input_line_pointer == '"')
3287 ++input_line_pointer;
3288 }
3289 }
3290
3291 subseg_new (section_name, (subsegT) exp);
3292
3293 segment_info[now_seg].scnhdr.s_flags |= flags;
3294
3295 *section_name_end = c;
3296 }
3297
3298
3299 static void
3300 obj_coff_text (ignore)
3301 int ignore;
3302 {
3303 subseg_new (".text", get_absolute_expression ());
3304 }
3305
3306
3307 static void
3308 obj_coff_data (ignore)
3309 int ignore;
3310 {
3311 if (flag_readonly_data_in_text)
3312 subseg_new (".text", get_absolute_expression () + 1000);
3313 else
3314 subseg_new (".data", get_absolute_expression ());
3315 }
3316
3317 static void
3318 obj_coff_bss (ignore)
3319 int ignore;
3320 {
3321 if (*input_line_pointer == '\n') /* .bss */
3322 subseg_new(".bss", get_absolute_expression());
3323 else /* .bss id,expr */
3324 obj_coff_lcomm(0);
3325 }
3326
3327 static void
3328 obj_coff_ident (ignore)
3329 int ignore;
3330 {
3331 segT current_seg = now_seg; /* save current seg */
3332 subsegT current_subseg = now_subseg;
3333 subseg_new (".comment", 0); /* .comment seg */
3334 stringer (1); /* read string */
3335 subseg_set (current_seg, current_subseg); /* restore current seg */
3336 }
3337
3338 void
3339 c_symbol_merge (debug, normal)
3340 symbolS *debug;
3341 symbolS *normal;
3342 {
3343 S_SET_DATA_TYPE (normal, S_GET_DATA_TYPE (debug));
3344 S_SET_STORAGE_CLASS (normal, S_GET_STORAGE_CLASS (debug));
3345
3346 if (S_GET_NUMBER_AUXILIARY (debug) > S_GET_NUMBER_AUXILIARY (normal))
3347 {
3348 S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));
3349 } /* take the most we have */
3350
3351 if (S_GET_NUMBER_AUXILIARY (debug) > 0)
3352 {
3353 memcpy ((char *) &normal->sy_symbol.ost_auxent[0],
3354 (char *) &debug->sy_symbol.ost_auxent[0],
3355 (unsigned int) (S_GET_NUMBER_AUXILIARY (debug) * AUXESZ));
3356 } /* Move all the auxiliary information */
3357
3358 /* Move the debug flags. */
3359 SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
3360 } /* c_symbol_merge() */
3361
3362 static int
3363 c_line_new (symbol, paddr, line_number, frag)
3364 symbolS * symbol;
3365 long paddr;
3366 int line_number;
3367 fragS * frag;
3368 {
3369 struct lineno_list *new_line =
3370 (struct lineno_list *) xmalloc (sizeof (struct lineno_list));
3371
3372 segment_info_type *s = segment_info + now_seg;
3373 new_line->line.l_lnno = line_number;
3374
3375 if (line_number == 0)
3376 {
3377 last_line_symbol = symbol;
3378 new_line->line.l_addr.l_symndx = (long) symbol;
3379 }
3380 else
3381 {
3382 new_line->line.l_addr.l_paddr = paddr;
3383 }
3384
3385 new_line->frag = (char *) frag;
3386 new_line->next = (struct lineno_list *) NULL;
3387
3388
3389 if (s->lineno_list_head == (struct lineno_list *) NULL)
3390 {
3391 s->lineno_list_head = new_line;
3392 }
3393 else
3394 {
3395 s->lineno_list_tail->next = new_line;
3396 }
3397 s->lineno_list_tail = new_line;
3398 return LINESZ * s->scnhdr.s_nlnno++;
3399 }
3400
3401 void
3402 c_dot_file_symbol (filename)
3403 char *filename;
3404 {
3405 symbolS *symbolP;
3406
3407 symbolP = symbol_new (".file",
3408 SEG_DEBUG,
3409 0,
3410 &zero_address_frag);
3411
3412 S_SET_STORAGE_CLASS (symbolP, C_FILE);
3413 S_SET_NUMBER_AUXILIARY (symbolP, 1);
3414
3415 if (strlen (filename) > FILNMLEN)
3416 {
3417 /* Filename is too long to fit into an auxent,
3418 we stick it into the string table instead. We keep
3419 a linked list of the filenames we find so we can emit
3420 them later.*/
3421 struct filename_list *f = ((struct filename_list *)
3422 xmalloc (sizeof (struct filename_list)));
3423
3424 f->filename = filename;
3425 f->next = 0;
3426
3427 SA_SET_FILE_FNAME_ZEROS (symbolP, 0);
3428 SA_SET_FILE_FNAME_OFFSET (symbolP, 0);
3429
3430 if (filename_list_tail)
3431 filename_list_tail->next = f;
3432 else
3433 filename_list_head = f;
3434 filename_list_tail = f;
3435 }
3436 else
3437 {
3438 SA_SET_FILE_FNAME (symbolP, filename);
3439 }
3440 #ifndef NO_LISTING
3441 {
3442 extern int listing;
3443 if (listing)
3444 {
3445 listing_source_file (filename);
3446 }
3447
3448 }
3449
3450 #endif
3451 SF_SET_DEBUG (symbolP);
3452 S_SET_VALUE (symbolP, (valueT) previous_file_symbol);
3453
3454 previous_file_symbol = symbolP;
3455
3456 /* Make sure that the symbol is first on the symbol chain */
3457 if (symbol_rootP != symbolP)
3458 {
3459 if (symbolP == symbol_lastP)
3460 {
3461 symbol_lastP = symbol_lastP->sy_previous;
3462 } /* if it was the last thing on the list */
3463
3464 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3465 symbol_insert (symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
3466 symbol_rootP = symbolP;
3467 } /* if not first on the list */
3468
3469 } /* c_dot_file_symbol() */
3470
3471 /*
3472 * Build a 'section static' symbol.
3473 */
3474
3475 symbolS *
3476 c_section_symbol (name, idx)
3477 char *name;
3478 int idx;
3479 {
3480 symbolS *symbolP;
3481
3482 symbolP = symbol_new (name, idx,
3483 0,
3484 &zero_address_frag);
3485
3486 S_SET_STORAGE_CLASS (symbolP, C_STAT);
3487 S_SET_NUMBER_AUXILIARY (symbolP, 1);
3488
3489 SF_SET_STATICS (symbolP);
3490
3491 return symbolP;
3492 } /* c_section_symbol() */
3493
3494 static void
3495 w_symbols (abfd, where, symbol_rootP)
3496 bfd * abfd;
3497 char *where;
3498 symbolS * symbol_rootP;
3499 {
3500 symbolS *symbolP;
3501 unsigned int i;
3502
3503 /* First fill in those values we have only just worked out */
3504 for (i = SEG_E0; i < SEG_E9; i++)
3505 {
3506 symbolP = segment_info[i].dot;
3507 if (symbolP)
3508 {
3509 SA_SET_SCN_SCNLEN (symbolP, segment_info[i].scnhdr.s_size);
3510 SA_SET_SCN_NRELOC (symbolP, segment_info[i].scnhdr.s_nreloc);
3511 SA_SET_SCN_NLINNO (symbolP, segment_info[i].scnhdr.s_nlnno);
3512 }
3513 }
3514
3515 /*
3516 * Emit all symbols left in the symbol chain.
3517 */
3518 for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
3519 {
3520 /* Used to save the offset of the name. It is used to point
3521 to the string in memory but must be a file offset. */
3522 register char *temp;
3523
3524 tc_coff_symbol_emit_hook (symbolP);
3525
3526 temp = S_GET_NAME (symbolP);
3527 if (SF_GET_STRING (symbolP))
3528 {
3529 S_SET_OFFSET (symbolP, symbolP->sy_name_offset);
3530 S_SET_ZEROES (symbolP, 0);
3531 }
3532 else
3533 {
3534 memset (symbolP->sy_symbol.ost_entry.n_name, 0, SYMNMLEN);
3535 strncpy (symbolP->sy_symbol.ost_entry.n_name, temp, SYMNMLEN);
3536 }
3537 where = symbol_to_chars (abfd, where, symbolP);
3538 S_SET_NAME (symbolP, temp);
3539 }
3540
3541 } /* w_symbols() */
3542
3543 static void
3544 obj_coff_lcomm (ignore)
3545 int ignore;
3546 {
3547 s_lcomm(0);
3548 return;
3549 #if 0
3550 char *name;
3551 char c;
3552 int temp;
3553 char *p;
3554
3555 symbolS *symbolP;
3556
3557 name = input_line_pointer;
3558
3559 c = get_symbol_end ();
3560 p = input_line_pointer;
3561 *p = c;
3562 SKIP_WHITESPACE ();
3563 if (*input_line_pointer != ',')
3564 {
3565 as_bad ("Expected comma after name");
3566 ignore_rest_of_line ();
3567 return;
3568 }
3569 if (*input_line_pointer == '\n')
3570 {
3571 as_bad ("Missing size expression");
3572 return;
3573 }
3574 input_line_pointer++;
3575 if ((temp = get_absolute_expression ()) < 0)
3576 {
3577 as_warn ("lcomm length (%d.) <0! Ignored.", temp);
3578 ignore_rest_of_line ();
3579 return;
3580 }
3581 *p = 0;
3582
3583 symbolP = symbol_find_or_make(name);
3584
3585 if (S_GET_SEGMENT(symbolP) == SEG_UNKNOWN &&
3586 S_GET_VALUE(symbolP) == 0)
3587 {
3588 if (! need_pass_2)
3589 {
3590 char *p;
3591 segT current_seg = now_seg; /* save current seg */
3592 subsegT current_subseg = now_subseg;
3593
3594 subseg_set (SEG_E2, 1);
3595 symbolP->sy_frag = frag_now;
3596 p = frag_var(rs_org, 1, 1, (relax_substateT)0, symbolP,
3597 temp, (char *)0);
3598 *p = 0;
3599 subseg_set (current_seg, current_subseg); /* restore current seg */
3600 S_SET_SEGMENT(symbolP, SEG_E2);
3601 S_SET_STORAGE_CLASS(symbolP, C_STAT);
3602 }
3603 }
3604 else
3605 as_bad("Symbol %s already defined", name);
3606
3607 demand_empty_rest_of_line();
3608 #endif
3609 }
3610
3611 static void
3612 fixup_mdeps (frags, h, this_segment)
3613 fragS * frags;
3614 object_headers * h;
3615 segT this_segment;
3616 {
3617 subseg_change (this_segment, 0);
3618 while (frags)
3619 {
3620 switch (frags->fr_type)
3621 {
3622 case rs_align:
3623 case rs_align_code:
3624 case rs_org:
3625 #ifdef HANDLE_ALIGN
3626 HANDLE_ALIGN (frags);
3627 #endif
3628 frags->fr_type = rs_fill;
3629 frags->fr_offset =
3630 (frags->fr_next->fr_address - frags->fr_address - frags->fr_fix);
3631 break;
3632 case rs_machine_dependent:
3633 md_convert_frag (h, this_segment, frags);
3634 frag_wane (frags);
3635 break;
3636 default:
3637 ;
3638 }
3639 frags = frags->fr_next;
3640 }
3641 }
3642
3643 #if 1
3644
3645 #ifndef TC_FORCE_RELOCATION
3646 #define TC_FORCE_RELOCATION(fix) 0
3647 #endif
3648
3649 static void
3650 fixup_segment (segP, this_segment_type)
3651 segment_info_type * segP;
3652 segT this_segment_type;
3653 {
3654 register fixS * fixP;
3655 register symbolS *add_symbolP;
3656 register symbolS *sub_symbolP;
3657 long add_number;
3658 register int size;
3659 register char *place;
3660 register long where;
3661 register char pcrel;
3662 register fragS *fragP;
3663 register segT add_symbol_segment = absolute_section;
3664
3665 if (linkrelax)
3666 return;
3667
3668 for (fixP = segP->fix_root; fixP; fixP = fixP->fx_next)
3669 {
3670 fragP = fixP->fx_frag;
3671 know (fragP);
3672 where = fixP->fx_where;
3673 place = fragP->fr_literal + where;
3674 size = fixP->fx_size;
3675 add_symbolP = fixP->fx_addsy;
3676 #ifdef TC_I960
3677 if (fixP->fx_tcbit && SF_GET_CALLNAME (add_symbolP))
3678 {
3679 /* Relocation should be done via the associated 'bal' entry
3680 point symbol. */
3681
3682 if (!SF_GET_BALNAME (tc_get_bal_of_call (add_symbolP)))
3683 {
3684 as_bad_where (fixP->fx_file, fixP->fx_line,
3685 "No 'bal' entry point for leafproc %s",
3686 S_GET_NAME (add_symbolP));
3687 continue;
3688 }
3689 fixP->fx_addsy = add_symbolP = tc_get_bal_of_call (add_symbolP);
3690 }
3691 #endif
3692 sub_symbolP = fixP->fx_subsy;
3693 add_number = fixP->fx_offset;
3694 pcrel = fixP->fx_pcrel;
3695
3696 if (add_symbolP != NULL
3697 && add_symbolP->sy_mri_common)
3698 {
3699 know (add_symbolP->sy_value.X_op == O_symbol);
3700 add_number += S_GET_VALUE (add_symbolP);
3701 fixP->fx_offset = add_number;
3702 add_symbolP = fixP->fx_addsy = add_symbolP->sy_value.X_add_symbol;
3703 }
3704
3705 if (add_symbolP)
3706 {
3707 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
3708 } /* if there is an addend */
3709
3710 if (sub_symbolP)
3711 {
3712 if (add_symbolP == NULL || add_symbol_segment == absolute_section)
3713 {
3714 if (add_symbolP != NULL)
3715 {
3716 add_number += S_GET_VALUE (add_symbolP);
3717 add_symbolP = NULL;
3718 fixP->fx_addsy = NULL;
3719 }
3720
3721 /* It's just -sym. */
3722 if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
3723 {
3724 add_number -= S_GET_VALUE (sub_symbolP);
3725 fixP->fx_subsy = 0;
3726 fixP->fx_done = 1;
3727 }
3728 else
3729 {
3730 #ifndef TC_M68K
3731 as_bad_where (fixP->fx_file, fixP->fx_line,
3732 "Negative of non-absolute symbol %s",
3733 S_GET_NAME (sub_symbolP));
3734 #endif
3735 add_number -= S_GET_VALUE (sub_symbolP);
3736 } /* not absolute */
3737
3738 /* if sub_symbol is in the same segment that add_symbol
3739 and add_symbol is either in DATA, TEXT, BSS or ABSOLUTE */
3740 }
3741 else if (S_GET_SEGMENT (sub_symbolP) == add_symbol_segment
3742 && SEG_NORMAL (add_symbol_segment))
3743 {
3744 /* Difference of 2 symbols from same segment. Can't
3745 make difference of 2 undefineds: 'value' means
3746 something different for N_UNDF. */
3747 #ifdef TC_I960
3748 /* Makes no sense to use the difference of 2 arbitrary symbols
3749 as the target of a call instruction. */
3750 if (fixP->fx_tcbit)
3751 {
3752 as_bad_where (fixP->fx_file, fixP->fx_line,
3753 "callj to difference of 2 symbols");
3754 }
3755 #endif /* TC_I960 */
3756 add_number += S_GET_VALUE (add_symbolP) -
3757 S_GET_VALUE (sub_symbolP);
3758 add_symbolP = NULL;
3759
3760 if (!TC_FORCE_RELOCATION (fixP))
3761 {
3762 fixP->fx_addsy = NULL;
3763 fixP->fx_subsy = NULL;
3764 fixP->fx_done = 1;
3765 #ifdef TC_M68K /* is this right? */
3766 pcrel = 0;
3767 fixP->fx_pcrel = 0;
3768 #endif
3769 }
3770 }
3771 else
3772 {
3773 /* Different segments in subtraction. */
3774 know (!(S_IS_EXTERNAL (sub_symbolP) && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
3775
3776 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
3777 {
3778 add_number -= S_GET_VALUE (sub_symbolP);
3779 }
3780 #ifdef DIFF_EXPR_OK
3781 else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
3782 #if 0 /* Okay for 68k, at least... */
3783 && !pcrel
3784 #endif
3785 )
3786 {
3787 /* Make it pc-relative. */
3788 add_number += (md_pcrel_from (fixP)
3789 - S_GET_VALUE (sub_symbolP));
3790 pcrel = 1;
3791 fixP->fx_pcrel = 1;
3792 sub_symbolP = 0;
3793 fixP->fx_subsy = 0;
3794 }
3795 #endif
3796 else
3797 {
3798 as_bad_where (fixP->fx_file, fixP->fx_line,
3799 "Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %ld.",
3800 segment_name (S_GET_SEGMENT (sub_symbolP)),
3801 S_GET_NAME (sub_symbolP),
3802 (long) (fragP->fr_address + where));
3803 } /* if absolute */
3804 }
3805 } /* if sub_symbolP */
3806
3807 if (add_symbolP)
3808 {
3809 if (add_symbol_segment == this_segment_type && pcrel)
3810 {
3811 /*
3812 * This fixup was made when the symbol's segment was
3813 * SEG_UNKNOWN, but it is now in the local segment.
3814 * So we know how to do the address without relocation.
3815 */
3816 #ifdef TC_I960
3817 /* reloc_callj() may replace a 'call' with a 'calls' or a 'bal',
3818 * in which cases it modifies *fixP as appropriate. In the case
3819 * of a 'calls', no further work is required, and *fixP has been
3820 * set up to make the rest of the code below a no-op.
3821 */
3822 reloc_callj (fixP);
3823 #endif /* TC_I960 */
3824
3825 add_number += S_GET_VALUE (add_symbolP);
3826 add_number -= md_pcrel_from (fixP);
3827 #if defined (TC_I386) || defined (TE_LYNX)
3828 /* On the 386 we must adjust by the segment
3829 vaddr as well. Ian Taylor. */
3830 add_number -= segP->scnhdr.s_vaddr;
3831 #endif
3832 pcrel = 0; /* Lie. Don't want further pcrel processing. */
3833 if (!TC_FORCE_RELOCATION (fixP))
3834 {
3835 fixP->fx_addsy = NULL;
3836 fixP->fx_done = 1;
3837 }
3838 }
3839 else
3840 {
3841 switch (add_symbol_segment)
3842 {
3843 case absolute_section:
3844 #ifdef TC_I960
3845 reloc_callj (fixP); /* See comment about reloc_callj() above*/
3846 #endif /* TC_I960 */
3847 add_number += S_GET_VALUE (add_symbolP);
3848 add_symbolP = NULL;
3849
3850 if (!TC_FORCE_RELOCATION (fixP))
3851 {
3852 fixP->fx_addsy = NULL;
3853 fixP->fx_done = 1;
3854 }
3855 break;
3856 default:
3857
3858
3859 #if defined(TC_A29K) || (defined(TE_PE) && defined(TC_I386)) || defined(TC_M88K)
3860 /* This really should be handled in the linker, but
3861 backward compatibility forbids. */
3862 add_number += S_GET_VALUE (add_symbolP);
3863 #else
3864 add_number += S_GET_VALUE (add_symbolP) +
3865 segment_info[S_GET_SEGMENT (add_symbolP)].scnhdr.s_paddr;
3866 #endif
3867 break;
3868
3869 case SEG_UNKNOWN:
3870 #ifdef TC_I960
3871 if ((int) fixP->fx_bit_fixP == 13)
3872 {
3873 /* This is a COBR instruction. They have only a
3874 * 13-bit displacement and are only to be used
3875 * for local branches: flag as error, don't generate
3876 * relocation.
3877 */
3878 as_bad_where (fixP->fx_file, fixP->fx_line,
3879 "can't use COBR format with external label");
3880 fixP->fx_addsy = NULL;
3881 fixP->fx_done = 1;
3882 continue;
3883 } /* COBR */
3884 #endif /* TC_I960 */
3885 #if (defined (TC_I386) || defined (TE_LYNX)) && !defined(TE_PE)
3886 /* 386 COFF uses a peculiar format in which the
3887 value of a common symbol is stored in the .text
3888 segment (I've checked this on SVR3.2 and SCO
3889 3.2.2) Ian Taylor <ian@cygnus.com>. */
3890 if (S_IS_COMMON (add_symbolP))
3891 add_number += S_GET_VALUE (add_symbolP);
3892 #endif
3893 break;
3894
3895
3896 } /* switch on symbol seg */
3897 } /* if not in local seg */
3898 } /* if there was a + symbol */
3899
3900 if (pcrel)
3901 {
3902 #if !defined(TC_M88K) && !(defined(TE_PE) && defined(TC_I386)) && !defined(TC_A29K)
3903 /* This adjustment is not correct on the m88k, for which the
3904 linker does all the computation. */
3905 add_number -= md_pcrel_from (fixP);
3906 #endif
3907 if (add_symbolP == 0)
3908 {
3909 fixP->fx_addsy = &abs_symbol;
3910 } /* if there's an add_symbol */
3911 #if defined (TC_I386) || defined (TE_LYNX)
3912 /* On the 386 we must adjust by the segment vaddr
3913 as well. Ian Taylor. */
3914 add_number -= segP->scnhdr.s_vaddr;
3915 #endif
3916 } /* if pcrel */
3917
3918 if (!fixP->fx_bit_fixP)
3919 {
3920 #ifndef TC_M88K
3921 /* The m88k uses the offset field of the reloc to get around
3922 this problem. */
3923 if ((size == 1
3924 && (add_number & ~0xFF)
3925 && ((add_number & ~0xFF) != (-1 & ~0xFF)))
3926 || (size == 2
3927 && (add_number & ~0xFFFF)
3928 && ((add_number & ~0xFFFF) != (-1 & ~0xFFFF))))
3929 {
3930 as_bad_where (fixP->fx_file, fixP->fx_line,
3931 "Value of %ld too large for field of %d bytes at 0x%lx",
3932 (long) add_number, size,
3933 (unsigned long) (fragP->fr_address + where));
3934 }
3935 #endif
3936 #ifdef WARN_SIGNED_OVERFLOW_WORD
3937 /* Warn if a .word value is too large when treated as a
3938 signed number. We already know it is not too negative.
3939 This is to catch over-large switches generated by gcc on
3940 the 68k. */
3941 if (!flag_signed_overflow_ok
3942 && size == 2
3943 && add_number > 0x7fff)
3944 as_bad_where (fixP->fx_file, fixP->fx_line,
3945 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
3946 (long) add_number,
3947 (unsigned long) (fragP->fr_address + where));
3948 #endif
3949 } /* not a bit fix */
3950 /* Once this fix has been applied, we don't have to output
3951 anything nothing more need be done. */
3952 #ifdef MD_APPLY_FIX3
3953 md_apply_fix3 (fixP, &add_number, this_segment_type);
3954 #else
3955 md_apply_fix (fixP, add_number);
3956 #endif
3957 } /* For each fixS in this segment. */
3958 } /* fixup_segment() */
3959
3960 #endif
3961
3962 /* The first entry in a .stab section is special. */
3963
3964 void
3965 obj_coff_init_stab_section (seg)
3966 segT seg;
3967 {
3968 char *file;
3969 char *p;
3970 char *stabstr_name;
3971 unsigned int stroff;
3972
3973 /* Make space for this first symbol. */
3974 p = frag_more (12);
3975 /* Zero it out. */
3976 memset (p, 0, 12);
3977 as_where (&file, (unsigned int *) NULL);
3978 stabstr_name = (char *) alloca (strlen (segment_info[seg].scnhdr.s_name) + 4);
3979 strcpy (stabstr_name, segment_info[seg].scnhdr.s_name);
3980 strcat (stabstr_name, "str");
3981 stroff = get_stab_string_offset (file, stabstr_name);
3982 know (stroff == 1);
3983 md_number_to_chars (p, stroff, 4);
3984 }
3985
3986 /* Fill in the counts in the first entry in a .stab section. */
3987
3988 static void
3989 adjust_stab_section(abfd, seg)
3990 bfd *abfd;
3991 segT seg;
3992 {
3993 segT stabstrseg = SEG_UNKNOWN;
3994 char *secname, *name, *name2;
3995 char *p = NULL;
3996 int i, strsz = 0, nsyms;
3997 fragS *frag = segment_info[seg].frchainP->frch_root;
3998
3999 /* Look for the associated string table section. */
4000
4001 secname = segment_info[seg].scnhdr.s_name;
4002 name = (char *) alloca (strlen (secname) + 4);
4003 strcpy (name, secname);
4004 strcat (name, "str");
4005
4006 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
4007 {
4008 name2 = segment_info[i].scnhdr.s_name;
4009 if (name2 != NULL && strncmp(name2, name, 8) == 0)
4010 {
4011 stabstrseg = i;
4012 break;
4013 }
4014 }
4015
4016 /* If we found the section, get its size. */
4017 if (stabstrseg != SEG_UNKNOWN)
4018 strsz = size_section (abfd, stabstrseg);
4019
4020 nsyms = size_section (abfd, seg) / 12 - 1;
4021
4022 /* Look for the first frag of sufficient size for the initial stab
4023 symbol, and collect a pointer to it. */
4024 while (frag && frag->fr_fix < 12)
4025 frag = frag->fr_next;
4026 assert (frag != 0);
4027 p = frag->fr_literal;
4028 assert (p != 0);
4029
4030 /* Write in the number of stab symbols and the size of the string
4031 table. */
4032 bfd_h_put_16 (abfd, (bfd_vma) nsyms, (bfd_byte *) p + 6);
4033 bfd_h_put_32 (abfd, (bfd_vma) strsz, (bfd_byte *) p + 8);
4034 }
4035
4036 #endif /* not BFD_ASSEMBLER */
4037
4038 const pseudo_typeS obj_pseudo_table[] =
4039 {
4040 {"def", obj_coff_def, 0},
4041 {"dim", obj_coff_dim, 0},
4042 {"endef", obj_coff_endef, 0},
4043 {"line", obj_coff_line, 0},
4044 {"ln", obj_coff_ln, 0},
4045 {"appline", obj_coff_ln, 1},
4046 {"scl", obj_coff_scl, 0},
4047 {"size", obj_coff_size, 0},
4048 {"tag", obj_coff_tag, 0},
4049 {"type", obj_coff_type, 0},
4050 {"val", obj_coff_val, 0},
4051 {"section", obj_coff_section, 0},
4052 {"sect", obj_coff_section, 0},
4053 /* FIXME: We ignore the MRI short attribute. */
4054 {"section.s", obj_coff_section, 0},
4055 {"sect.s", obj_coff_section, 0},
4056 #ifndef BFD_ASSEMBLER
4057 {"use", obj_coff_section, 0},
4058 {"text", obj_coff_text, 0},
4059 {"data", obj_coff_data, 0},
4060 {"bss", obj_coff_bss, 0},
4061 {"lcomm", obj_coff_lcomm, 0},
4062 {"ident", obj_coff_ident, 0},
4063 #else
4064 {"optim", s_ignore, 0}, /* For sun386i cc (?) */
4065 {"ident", s_ignore, 0}, /* we don't yet handle this. */
4066 #endif
4067 {"ABORT", s_abort, 0},
4068 #ifdef TC_M88K
4069 /* The m88k uses sdef instead of def. */
4070 {"sdef", obj_coff_def, 0},
4071 #endif
4072 {NULL} /* end sentinel */
4073 }; /* obj_pseudo_table */