1 /* coff object file format
2 Copyright (C) 1989, 90, 91, 92, 93, 94, 95, 96, 97, 98, 1999
3 Free Software Foundation, Inc.
5 This file is part of GAS.
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)
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.
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 the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22 #define OBJ_HEADER "obj-coff.h"
28 /* I think this is probably always correct. */
29 #ifndef KEEP_RELOC_INFO
30 #define KEEP_RELOC_INFO
33 static void obj_coff_bss PARAMS ((int));
34 const char *s_get_name PARAMS ((symbolS * s));
35 static symbolS *def_symbol_in_progress;
41 unsigned long chunk_size;
42 unsigned long element_size;
45 unsigned long pointer;
50 stack_init (chunk_size, element_size)
51 unsigned long chunk_size;
52 unsigned long element_size;
56 st = (stack *) malloc (sizeof (stack));
59 st->data = malloc (chunk_size);
66 st->size = chunk_size;
67 st->chunk_size = chunk_size;
68 st->element_size = element_size;
73 /* Not currently used. */
84 stack_push (st, element)
88 if (st->pointer + st->element_size >= st->size)
90 st->size += st->chunk_size;
91 if ((st->data = xrealloc (st->data, st->size)) == (char *) 0)
94 memcpy (st->data + st->pointer, element, st->element_size);
95 st->pointer += st->element_size;
96 return st->data + st->pointer;
103 if (st->pointer < st->element_size)
108 st->pointer -= st->element_size;
109 return st->data + st->pointer;
113 * Maintain a list of the tagnames of the structres.
116 static struct hash_control *tag_hash;
121 tag_hash = hash_new ();
125 tag_insert (name, symbolP)
129 const char *error_string;
131 if ((error_string = hash_jam (tag_hash, name, (char *) symbolP)))
133 as_fatal (_("Inserting \"%s\" into structure table failed: %s"),
142 #ifdef STRIP_UNDERSCORE
145 #endif /* STRIP_UNDERSCORE */
146 return (symbolS *) hash_find (tag_hash, name);
150 tag_find_or_make (name)
155 if ((symbolP = tag_find (name)) == NULL)
157 symbolP = symbol_new (name, undefined_section,
158 0, &zero_address_frag);
160 tag_insert (S_GET_NAME (symbolP), symbolP);
162 symbol_table_insert (symbolP);
169 /* We accept the .bss directive to set the section for backward
170 compatibility with earlier versions of gas. */
173 obj_coff_bss (ignore)
176 if (*input_line_pointer == '\n')
177 subseg_new (".bss", get_absolute_expression ());
182 /* Handle .weak. This is a GNU extension. */
185 obj_coff_weak (ignore)
194 name = input_line_pointer;
195 c = get_symbol_end ();
196 symbolP = symbol_find_or_make (name);
197 *input_line_pointer = c;
201 S_SET_WEAK (symbolP);
205 S_SET_STORAGE_CLASS (symbolP, C_NT_WEAK);
207 S_SET_STORAGE_CLASS (symbolP, C_WEAKEXT);
212 input_line_pointer++;
214 if (*input_line_pointer == '\n')
220 demand_empty_rest_of_line ();
225 static void SA_SET_SYM_TAGNDX PARAMS ((symbolS *, symbolS *));
227 #define GET_FILENAME_STRING(X) \
228 ((char*)(&((X)->sy_symbol.ost_auxent->x_file.x_n.x_offset))[1])
232 fetch_coff_debug_section ()
234 static segT debug_section;
238 s = bfd_make_debug_symbol (stdoutput, (char *) 0, 0);
240 debug_section = s->section;
242 return debug_section;
246 SA_SET_SYM_ENDNDX (sym, val)
250 combined_entry_type *entry, *p;
252 entry = &coffsymbol (symbol_get_bfdsym (sym))->native[1];
253 p = coffsymbol (symbol_get_bfdsym (val))->native;
254 entry->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p = p;
259 SA_SET_SYM_TAGNDX (sym, val)
263 combined_entry_type *entry, *p;
265 entry = &coffsymbol (symbol_get_bfdsym (sym))->native[1];
266 p = coffsymbol (symbol_get_bfdsym (val))->native;
267 entry->u.auxent.x_sym.x_tagndx.p = p;
272 S_GET_DATA_TYPE (sym)
275 return coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_type;
279 S_SET_DATA_TYPE (sym, val)
283 coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_type = val;
288 S_GET_STORAGE_CLASS (sym)
291 return coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_sclass;
295 S_SET_STORAGE_CLASS (sym, val)
299 coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_sclass = val;
303 /* Merge a debug symbol containing debug information into a normal symbol. */
306 c_symbol_merge (debug, normal)
310 S_SET_DATA_TYPE (normal, S_GET_DATA_TYPE (debug));
311 S_SET_STORAGE_CLASS (normal, S_GET_STORAGE_CLASS (debug));
313 if (S_GET_NUMBER_AUXILIARY (debug) > S_GET_NUMBER_AUXILIARY (normal))
315 /* take the most we have */
316 S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));
319 if (S_GET_NUMBER_AUXILIARY (debug) > 0)
321 /* Move all the auxiliary information. */
322 memcpy (SYM_AUXINFO (normal), SYM_AUXINFO (debug),
323 (S_GET_NUMBER_AUXILIARY (debug)
324 * sizeof (*SYM_AUXINFO (debug))));
327 /* Move the debug flags. */
328 SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
332 c_dot_file_symbol (filename)
337 symbolP = symbol_new (filename, bfd_abs_section_ptr, 0, &zero_address_frag);
339 S_SET_STORAGE_CLASS (symbolP, C_FILE);
340 S_SET_NUMBER_AUXILIARY (symbolP, 1);
342 symbol_get_bfdsym (symbolP)->flags = BSF_DEBUGGING;
349 listing_source_file (filename);
354 /* Make sure that the symbol is first on the symbol chain */
355 if (symbol_rootP != symbolP)
357 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
358 symbol_insert (symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
359 } /* if not first on the list */
362 /* Line number handling */
365 struct line_no *next;
372 /* Symbol of last function, which we should hang line#s off of. */
373 static symbolS *line_fsym;
375 #define in_function() (line_fsym != 0)
376 #define clear_function() (line_fsym = 0)
377 #define set_function(F) (line_fsym = (F), coff_add_linesym (F))
381 coff_obj_symbol_new_hook (symbolP)
384 long sz = (OBJ_COFF_MAX_AUXENTRIES + 1) * sizeof (combined_entry_type);
385 char * s = (char *) xmalloc (sz);
388 coffsymbol (symbol_get_bfdsym (symbolP))->native = (combined_entry_type *) s;
390 S_SET_DATA_TYPE (symbolP, T_NULL);
391 S_SET_STORAGE_CLASS (symbolP, 0);
392 S_SET_NUMBER_AUXILIARY (symbolP, 0);
394 if (S_IS_STRING (symbolP))
395 SF_SET_STRING (symbolP);
397 if (S_IS_LOCAL (symbolP))
398 SF_SET_LOCAL (symbolP);
403 * Handle .ln directives.
406 static symbolS *current_lineno_sym;
407 static struct line_no *line_nos;
408 /* @@ Blindly assume all .ln directives will be in the .text section... */
412 add_lineno (frag, offset, num)
417 struct line_no *new_line =
418 (struct line_no *) xmalloc (sizeof (struct line_no));
419 if (!current_lineno_sym)
423 new_line->next = line_nos;
424 new_line->frag = frag;
425 new_line->l.line_number = num;
426 new_line->l.u.offset = offset;
432 coff_add_linesym (sym)
437 coffsymbol (symbol_get_bfdsym (current_lineno_sym))->lineno =
442 current_lineno_sym = sym;
446 obj_coff_ln (appline)
451 if (! appline && def_symbol_in_progress != NULL)
453 as_warn (_(".ln pseudo-op inside .def/.endef: ignored."));
454 demand_empty_rest_of_line ();
458 l = get_absolute_expression ();
461 add_lineno (frag_now, frag_now_fix (), l);
465 new_logical_line ((char *) NULL, l - 1);
474 l += coff_line_base - 1;
475 listing_source_line (l);
480 demand_empty_rest_of_line ();
486 * Handle .def directives.
488 * One might ask : why can't we symbol_new if the symbol does not
489 * already exist and fill it with debug information. Because of
490 * the C_EFCN special symbol. It would clobber the value of the
491 * function symbol before we have a chance to notice that it is
492 * a C_EFCN. And a second reason is that the code is more clear this
493 * way. (at least I think it is :-).
497 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
498 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
499 *input_line_pointer == '\t') \
500 input_line_pointer++;
506 char name_end; /* Char after the end of name */
507 char *symbol_name; /* Name of the debug symbol */
508 char *symbol_name_copy; /* Temporary copy of the name */
509 unsigned int symbol_name_length;
511 if (def_symbol_in_progress != NULL)
513 as_warn (_(".def pseudo-op used inside of .def/.endef: ignored."));
514 demand_empty_rest_of_line ();
516 } /* if not inside .def/.endef */
520 symbol_name = input_line_pointer;
521 #ifdef STRIP_UNDERSCORE
522 if (symbol_name[0] == '_' && symbol_name[1] != 0)
524 #endif /* STRIP_UNDERSCORE */
526 name_end = get_symbol_end ();
527 symbol_name_length = strlen (symbol_name);
528 symbol_name_copy = xmalloc (symbol_name_length + 1);
529 strcpy (symbol_name_copy, symbol_name);
530 #ifdef tc_canonicalize_symbol_name
531 symbol_name_copy = tc_canonicalize_symbol_name (symbol_name_copy);
534 /* Initialize the new symbol */
535 def_symbol_in_progress = symbol_make (symbol_name_copy);
536 symbol_set_frag (def_symbol_in_progress, &zero_address_frag);
537 S_SET_VALUE (def_symbol_in_progress, 0);
539 if (S_IS_STRING (def_symbol_in_progress))
540 SF_SET_STRING (def_symbol_in_progress);
542 *input_line_pointer = name_end;
544 demand_empty_rest_of_line ();
547 unsigned int dim_index;
550 obj_coff_endef (ignore)
555 /* DIM BUG FIX sac@cygnus.com */
557 if (def_symbol_in_progress == NULL)
559 as_warn (_(".endef pseudo-op used outside of .def/.endef: ignored."));
560 demand_empty_rest_of_line ();
562 } /* if not inside .def/.endef */
564 /* Set the section number according to storage class. */
565 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))
570 SF_SET_TAG (def_symbol_in_progress);
571 /* intentional fallthrough */
574 SF_SET_DEBUG (def_symbol_in_progress);
575 S_SET_SEGMENT (def_symbol_in_progress, fetch_coff_debug_section ());
579 SF_SET_LOCAL (def_symbol_in_progress); /* Do not emit this symbol. */
580 /* intentional fallthrough */
582 SF_SET_PROCESS (def_symbol_in_progress); /* Will need processing before writing */
583 /* intentional fallthrough */
587 S_SET_SEGMENT (def_symbol_in_progress, text_section);
589 name = S_GET_NAME (def_symbol_in_progress);
590 if (name[1] == 'b' && name[2] == 'f')
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);
604 #endif /* C_AUTOARG */
610 SF_SET_DEBUG (def_symbol_in_progress);
611 S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
618 S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
628 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
635 as_warn (_("unexpected storage class %d"),
636 S_GET_STORAGE_CLASS (def_symbol_in_progress));
638 } /* switch on storage class */
640 /* Now that we have built a debug symbol, try to find if we should
641 merge with an existing symbol or not. If a symbol is C_EFCN or
642 SEG_ABSOLUTE or untagged SEG_DEBUG it never merges. */
644 /* Two cases for functions. Either debug followed by definition or
645 definition followed by debug. For definition first, we will
646 merge the debug symbol into the definition. For debug first, the
647 lineno entry MUST point to the definition function or else it
648 will point off into space when obj_crawl_symbol_chain() merges
649 the debug symbol into the real symbol. Therefor, let's presume
650 the debug symbol is a real function reference. */
652 /* FIXME-SOON If for some reason the definition label/symbol is
653 never seen, this will probably leave an undefined symbol at link
656 if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN
657 || (!strcmp (bfd_get_section_name (stdoutput,
658 S_GET_SEGMENT (def_symbol_in_progress)),
660 && !SF_GET_TAG (def_symbol_in_progress))
661 || S_GET_SEGMENT (def_symbol_in_progress) == absolute_section
662 || (symbolP = symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP)) == NULL)
664 if (def_symbol_in_progress != symbol_lastP)
665 symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP,
670 /* This symbol already exists, merge the newly created symbol
671 into the old one. This is not mandatory. The linker can
672 handle duplicate symbols correctly. But I guess that it save
673 a *lot* of space if the assembly file defines a lot of
676 /* The debug entry (def_symbol_in_progress) is merged into the
677 previous definition. */
679 c_symbol_merge (def_symbol_in_progress, symbolP);
680 symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
682 def_symbol_in_progress = symbolP;
684 if (SF_GET_FUNCTION (def_symbol_in_progress)
685 || SF_GET_TAG (def_symbol_in_progress)
686 || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_STAT)
688 /* For functions, and tags, and static symbols, the symbol
689 *must* be where the debug symbol appears. Move the
690 existing symbol to the current place. */
691 /* If it already is at the end of the symbol list, do nothing */
692 if (def_symbol_in_progress != symbol_lastP)
694 symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
695 symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP, &symbol_lastP);
700 if (SF_GET_TAG (def_symbol_in_progress))
704 oldtag = symbol_find_base (S_GET_NAME (def_symbol_in_progress),
706 if (oldtag == NULL || ! SF_GET_TAG (oldtag))
707 tag_insert (S_GET_NAME (def_symbol_in_progress),
708 def_symbol_in_progress);
711 if (SF_GET_FUNCTION (def_symbol_in_progress))
713 know (sizeof (def_symbol_in_progress) <= sizeof (long));
714 set_function (def_symbol_in_progress);
715 SF_SET_PROCESS (def_symbol_in_progress);
719 /* That is, if this is the first time we've seen the
721 symbol_table_insert (def_symbol_in_progress);
722 } /* definition follows debug */
723 } /* Create the line number entry pointing to the function being defined */
725 def_symbol_in_progress = NULL;
726 demand_empty_rest_of_line ();
730 obj_coff_dim (ignore)
735 if (def_symbol_in_progress == NULL)
737 as_warn (_(".dim pseudo-op used outside of .def/.endef: ignored."));
738 demand_empty_rest_of_line ();
740 } /* if not inside .def/.endef */
742 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
744 for (dim_index = 0; dim_index < DIMNUM; dim_index++)
747 SA_SET_SYM_DIMEN (def_symbol_in_progress, dim_index,
748 get_absolute_expression ());
750 switch (*input_line_pointer)
753 input_line_pointer++;
757 as_warn (_("badly formed .dim directive ignored"));
758 /* intentional fallthrough */
766 demand_empty_rest_of_line ();
770 obj_coff_line (ignore)
775 if (def_symbol_in_progress == NULL)
777 /* Probably stabs-style line? */
782 this_base = get_absolute_expression ();
783 if (!strcmp (".bf", S_GET_NAME (def_symbol_in_progress)))
784 coff_line_base = this_base;
786 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
787 SA_SET_SYM_LNNO (def_symbol_in_progress, coff_line_base);
789 demand_empty_rest_of_line ();
792 if (strcmp (".bf", S_GET_NAME (def_symbol_in_progress)) == 0)
797 listing_source_line ((unsigned int) coff_line_base);
803 obj_coff_size (ignore)
806 if (def_symbol_in_progress == NULL)
808 as_warn (_(".size pseudo-op used outside of .def/.endef ignored."));
809 demand_empty_rest_of_line ();
811 } /* if not inside .def/.endef */
813 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
814 SA_SET_SYM_SIZE (def_symbol_in_progress, get_absolute_expression ());
815 demand_empty_rest_of_line ();
819 obj_coff_scl (ignore)
822 if (def_symbol_in_progress == NULL)
824 as_warn (_(".scl pseudo-op used outside of .def/.endef ignored."));
825 demand_empty_rest_of_line ();
827 } /* if not inside .def/.endef */
829 S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ());
830 demand_empty_rest_of_line ();
834 obj_coff_tag (ignore)
840 if (def_symbol_in_progress == NULL)
842 as_warn (_(".tag pseudo-op used outside of .def/.endef ignored."));
843 demand_empty_rest_of_line ();
847 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
848 symbol_name = input_line_pointer;
849 name_end = get_symbol_end ();
851 #ifdef tc_canonicalize_symbol_name
852 symbol_name = tc_canonicalize_symbol_name (symbol_name);
855 /* Assume that the symbol referred to by .tag is always defined.
856 This was a bad assumption. I've added find_or_make. xoxorich. */
857 SA_SET_SYM_TAGNDX (def_symbol_in_progress,
858 tag_find_or_make (symbol_name));
859 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L)
861 as_warn (_("tag not found for .tag %s"), symbol_name);
864 SF_SET_TAGGED (def_symbol_in_progress);
865 *input_line_pointer = name_end;
867 demand_empty_rest_of_line ();
871 obj_coff_type (ignore)
874 if (def_symbol_in_progress == NULL)
876 as_warn (_(".type pseudo-op used outside of .def/.endef ignored."));
877 demand_empty_rest_of_line ();
879 } /* if not inside .def/.endef */
881 S_SET_DATA_TYPE (def_symbol_in_progress, get_absolute_expression ());
883 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress)) &&
884 S_GET_STORAGE_CLASS (def_symbol_in_progress) != C_TPDEF)
886 SF_SET_FUNCTION (def_symbol_in_progress);
887 } /* is a function */
889 demand_empty_rest_of_line ();
893 obj_coff_val (ignore)
896 if (def_symbol_in_progress == NULL)
898 as_warn (_(".val pseudo-op used outside of .def/.endef ignored."));
899 demand_empty_rest_of_line ();
901 } /* if not inside .def/.endef */
903 if (is_name_beginner (*input_line_pointer))
905 char *symbol_name = input_line_pointer;
906 char name_end = get_symbol_end ();
908 #ifdef tc_canonicalize_symbol_name
909 symbol_name = tc_canonicalize_symbol_name (symbol_name);
911 if (!strcmp (symbol_name, "."))
913 symbol_set_frag (def_symbol_in_progress, frag_now);
914 S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
915 /* If the .val is != from the .def (e.g. statics) */
917 else if (strcmp (S_GET_NAME (def_symbol_in_progress), symbol_name))
922 exp.X_add_symbol = symbol_find_or_make (symbol_name);
923 exp.X_op_symbol = NULL;
924 exp.X_add_number = 0;
925 symbol_set_value_expression (def_symbol_in_progress, &exp);
927 /* If the segment is undefined when the forward reference is
928 resolved, then copy the segment id from the forward
930 SF_SET_GET_SEGMENT (def_symbol_in_progress);
932 /* Otherwise, it is the name of a non debug symbol and its value will be calculated later. */
933 *input_line_pointer = name_end;
937 S_SET_VALUE (def_symbol_in_progress, get_absolute_expression ());
938 } /* if symbol based */
940 demand_empty_rest_of_line ();
944 coff_obj_read_begin_hook ()
946 /* These had better be the same. Usually 18 bytes. */
948 know (sizeof (SYMENT) == sizeof (AUXENT));
949 know (SYMESZ == AUXESZ);
955 symbolS *coff_last_function;
956 static symbolS *coff_last_bf;
959 coff_frob_symbol (symp, punt)
963 static symbolS *last_tagP;
964 static stack *block_stack;
965 static symbolS *set_end;
966 symbolS *next_set_end = NULL;
968 if (symp == &abs_symbol)
974 if (current_lineno_sym)
975 coff_add_linesym ((symbolS *) 0);
978 block_stack = stack_init (512, sizeof (symbolS*));
980 if (S_IS_WEAK (symp))
983 S_SET_STORAGE_CLASS (symp, C_NT_WEAK);
985 S_SET_STORAGE_CLASS (symp, C_WEAKEXT);
989 if (!S_IS_DEFINED (symp)
991 && S_GET_STORAGE_CLASS (symp) != C_STAT)
992 S_SET_STORAGE_CLASS (symp, C_EXT);
994 if (!SF_GET_DEBUG (symp))
997 if (!SF_GET_LOCAL (symp)
998 && !SF_GET_STATICS (symp)
999 && (real = symbol_find_base (S_GET_NAME (symp), DO_NOT_STRIP))
1002 c_symbol_merge (symp, real);
1005 if (!S_IS_DEFINED (symp) && !SF_GET_LOCAL (symp))
1007 assert (S_GET_VALUE (symp) == 0);
1008 S_SET_EXTERNAL (symp);
1010 else if (S_GET_STORAGE_CLASS (symp) == C_NULL)
1012 if (S_GET_SEGMENT (symp) == text_section
1013 && symp != seg_info (text_section)->sym)
1014 S_SET_STORAGE_CLASS (symp, C_LABEL);
1016 S_SET_STORAGE_CLASS (symp, C_STAT);
1018 if (SF_GET_PROCESS (symp))
1020 if (S_GET_STORAGE_CLASS (symp) == C_BLOCK)
1022 if (!strcmp (S_GET_NAME (symp), ".bb"))
1023 stack_push (block_stack, (char *) &symp);
1027 begin = *(symbolS **) stack_pop (block_stack);
1029 as_warn (_("mismatched .eb"));
1031 next_set_end = begin;
1034 if (coff_last_function == 0 && SF_GET_FUNCTION (symp))
1036 union internal_auxent *auxp;
1037 coff_last_function = symp;
1038 if (S_GET_NUMBER_AUXILIARY (symp) < 1)
1039 S_SET_NUMBER_AUXILIARY (symp, 1);
1041 &coffsymbol (symbol_get_bfdsym (symp))->native[1].u.auxent;
1042 memset (auxp->x_sym.x_fcnary.x_ary.x_dimen, 0,
1043 sizeof (auxp->x_sym.x_fcnary.x_ary.x_dimen));
1045 if (S_GET_STORAGE_CLASS (symp) == C_EFCN)
1047 if (coff_last_function == 0)
1048 as_fatal (_("C_EFCN symbol out of scope"));
1049 SA_SET_SYM_FSIZE (coff_last_function,
1050 (long) (S_GET_VALUE (symp)
1051 - S_GET_VALUE (coff_last_function)));
1052 next_set_end = coff_last_function;
1053 coff_last_function = 0;
1056 if (S_IS_EXTERNAL (symp))
1057 S_SET_STORAGE_CLASS (symp, C_EXT);
1058 else if (SF_GET_LOCAL (symp))
1061 if (SF_GET_FUNCTION (symp))
1062 symbol_get_bfdsym (symp)->flags |= BSF_FUNCTION;
1067 if (SF_GET_TAG (symp))
1069 else if (S_GET_STORAGE_CLASS (symp) == C_EOS)
1070 next_set_end = last_tagP;
1073 /* This is pretty horrible, but we have to set *punt correctly in
1074 order to call SA_SET_SYM_ENDNDX correctly. */
1075 if (! symbol_used_in_reloc_p (symp)
1076 && ((symbol_get_bfdsym (symp)->flags & BSF_SECTION_SYM) != 0
1077 || (! S_IS_EXTERNAL (symp)
1078 && ! symbol_get_tc (symp)->output
1079 && S_GET_STORAGE_CLASS (symp) != C_FILE)))
1083 if (set_end != (symbolS *) NULL
1085 && ((symbol_get_bfdsym (symp)->flags & BSF_NOT_AT_END) != 0
1086 || (S_IS_DEFINED (symp)
1087 && ! S_IS_COMMON (symp)
1088 && (! S_IS_EXTERNAL (symp) || SF_GET_FUNCTION (symp)))))
1090 SA_SET_SYM_ENDNDX (set_end, symp);
1094 if (next_set_end != NULL
1096 set_end = next_set_end;
1099 && S_GET_STORAGE_CLASS (symp) == C_FCN
1100 && strcmp (S_GET_NAME (symp), ".bf") == 0)
1102 if (coff_last_bf != NULL)
1103 SA_SET_SYM_ENDNDX (coff_last_bf, symp);
1104 coff_last_bf = symp;
1107 if (coffsymbol (symbol_get_bfdsym (symp))->lineno)
1110 struct line_no *lptr;
1113 lptr = (struct line_no *) coffsymbol (symbol_get_bfdsym (symp))->lineno;
1114 for (i = 0; lptr; lptr = lptr->next)
1116 lptr = (struct line_no *) coffsymbol (symbol_get_bfdsym (symp))->lineno;
1118 /* We need i entries for line numbers, plus 1 for the first
1119 entry which BFD will override, plus 1 for the last zero
1120 entry (a marker for BFD). */
1121 l = (alent *) xmalloc ((i + 2) * sizeof (alent));
1122 coffsymbol (symbol_get_bfdsym (symp))->lineno = l;
1123 l[i + 1].line_number = 0;
1124 l[i + 1].u.sym = NULL;
1128 lptr->l.u.offset += lptr->frag->fr_address;
1136 coff_adjust_section_syms (abfd, sec, x)
1142 segment_info_type *seginfo = seg_info (sec);
1143 int nlnno, nrelocs = 0;
1145 /* RS/6000 gas creates a .debug section manually in ppc_frob_file in
1146 tc-ppc.c. Do not get confused by it. */
1147 if (seginfo == NULL)
1150 if (!strcmp (sec->name, ".text"))
1151 nlnno = coff_n_line_nos;
1155 /* @@ Hope that none of the fixups expand to more than one reloc
1157 fixS *fixp = seginfo->fix_root;
1160 if (! fixp->fx_done)
1162 fixp = fixp->fx_next;
1165 if (bfd_get_section_size_before_reloc (sec) == 0
1168 && sec != text_section
1169 && sec != data_section
1170 && sec != bss_section)
1172 secsym = section_symbol (sec);
1173 SA_SET_SCN_NRELOC (secsym, nrelocs);
1174 SA_SET_SCN_NLINNO (secsym, nlnno);
1178 coff_frob_file_after_relocs ()
1180 bfd_map_over_sections (stdoutput, coff_adjust_section_syms, (char*) 0);
1184 * implement the .section pseudo op:
1185 * .section name {, "flags"}
1187 * | +--- optional flags: 'b' for bss
1189 * +-- section name 'l' for lib
1193 * 'd' (apparently m88k for data)
1195 * 'r' for read-only data
1196 * But if the argument is not a quoted string, treat it as a
1197 * subsegment number.
1201 obj_coff_section (ignore)
1204 /* Strip out the section name */
1220 section_name = input_line_pointer;
1221 c = get_symbol_end ();
1223 name = xmalloc (input_line_pointer - section_name + 1);
1224 strcpy (name, section_name);
1226 *input_line_pointer = c;
1231 flags = SEC_NO_FLAGS;
1233 if (*input_line_pointer == ',')
1235 ++input_line_pointer;
1237 if (*input_line_pointer != '"')
1238 exp = get_absolute_expression ();
1241 ++input_line_pointer;
1242 while (*input_line_pointer != '"'
1243 && ! is_end_of_line[(unsigned char) *input_line_pointer])
1245 switch (*input_line_pointer)
1247 case 'b': flags |= SEC_ALLOC; flags &=~ SEC_LOAD; break;
1248 case 'n': flags &=~ SEC_LOAD; break;
1250 case 'w': flags |= SEC_DATA; flags &=~ SEC_READONLY; break;
1251 case 'x': flags |= SEC_CODE; break;
1252 case 'r': flags |= SEC_READONLY; break;
1254 case 'i': /* STYP_INFO */
1255 case 'l': /* STYP_LIB */
1256 case 'o': /* STYP_OVER */
1257 as_warn (_("unsupported section attribute '%c'"),
1258 *input_line_pointer);
1262 as_warn(_("unknown section attribute '%c'"),
1263 *input_line_pointer);
1266 ++input_line_pointer;
1268 if (*input_line_pointer == '"')
1269 ++input_line_pointer;
1273 sec = subseg_new (name, (subsegT) exp);
1275 if (flags != SEC_NO_FLAGS)
1279 oldflags = bfd_get_section_flags (stdoutput, sec);
1280 oldflags &= SEC_LINK_ONCE | SEC_LINK_DUPLICATES;
1283 if (! bfd_set_section_flags (stdoutput, sec, flags))
1284 as_warn (_("error setting flags for \"%s\": %s"),
1285 bfd_section_name (stdoutput, sec),
1286 bfd_errmsg (bfd_get_error ()));
1289 demand_empty_rest_of_line ();
1293 coff_adjust_symtab ()
1295 if (symbol_rootP == NULL
1296 || S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
1297 c_dot_file_symbol ("fake");
1301 coff_frob_section (sec)
1307 bfd_vma size, n_entries, mask;
1309 /* The COFF back end in BFD requires that all section sizes be
1310 rounded up to multiples of the corresponding section alignments.
1311 Seems kinda silly to me, but that's the way it is. */
1312 size = bfd_get_section_size_before_reloc (sec);
1313 mask = ((bfd_vma) 1 << (bfd_vma) sec->alignment_power) - 1;
1316 size = (size + mask) & ~mask;
1317 bfd_set_section_size (stdoutput, sec, size);
1320 /* If the section size is non-zero, the section symbol needs an aux
1321 entry associated with it, indicating the size. We don't know
1322 all the values yet; coff_frob_symbol will fill them in later. */
1324 || sec == text_section
1325 || sec == data_section
1326 || sec == bss_section)
1328 symbolS *secsym = section_symbol (sec);
1330 S_SET_STORAGE_CLASS (secsym, C_STAT);
1331 S_SET_NUMBER_AUXILIARY (secsym, 1);
1332 SF_SET_STATICS (secsym);
1333 SA_SET_SCN_SCNLEN (secsym, size);
1336 /* @@ these should be in a "stabs.h" file, or maybe as.h */
1337 #ifndef STAB_SECTION_NAME
1338 #define STAB_SECTION_NAME ".stab"
1340 #ifndef STAB_STRING_SECTION_NAME
1341 #define STAB_STRING_SECTION_NAME ".stabstr"
1343 if (strcmp (STAB_STRING_SECTION_NAME, sec->name))
1347 sec = subseg_get (STAB_SECTION_NAME, 0);
1348 /* size is already rounded up, since other section will be listed first */
1349 size = bfd_get_section_size_before_reloc (strsec);
1351 n_entries = bfd_get_section_size_before_reloc (sec) / 12 - 1;
1353 /* Find first non-empty frag. It should be large enough. */
1354 fragp = seg_info (sec)->frchainP->frch_root;
1355 while (fragp && fragp->fr_fix == 0)
1356 fragp = fragp->fr_next;
1357 assert (fragp != 0 && fragp->fr_fix >= 12);
1359 /* Store the values. */
1360 p = fragp->fr_literal;
1361 bfd_h_put_16 (stdoutput, n_entries, (bfd_byte *) p + 6);
1362 bfd_h_put_32 (stdoutput, size, (bfd_byte *) p + 8);
1366 obj_coff_init_stab_section (seg)
1372 unsigned int stroff;
1374 /* Make space for this first symbol. */
1378 as_where (&file, (unsigned int *) NULL);
1379 stabstr_name = (char *) alloca (strlen (seg->name) + 4);
1380 strcpy (stabstr_name, seg->name);
1381 strcat (stabstr_name, "str");
1382 stroff = get_stab_string_offset (file, stabstr_name);
1384 md_number_to_chars (p, stroff, 4);
1393 return ((s == NULL) ? "(NULL)" : S_GET_NAME (s));
1401 for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
1403 printf(_("0x%lx: \"%s\" type = %ld, class = %d, segment = %d\n"),
1404 (unsigned long) symbolP,
1405 S_GET_NAME(symbolP),
1406 (long) S_GET_DATA_TYPE(symbolP),
1407 S_GET_STORAGE_CLASS(symbolP),
1408 (int) S_GET_SEGMENT(symbolP));
1414 #else /* not BFD_ASSEMBLER */
1417 /* This is needed because we include internal bfd things. */
1421 #include "libcoff.h"
1424 #include "coff/pe.h"
1427 /* The NOP_OPCODE is for the alignment fill value. Fill with nop so
1428 that we can stick sections together without causing trouble. */
1430 #define NOP_OPCODE 0x00
1433 /* The zeroes if symbol name is longer than 8 chars */
1434 #define S_SET_ZEROES(s,v) ((s)->sy_symbol.ost_entry.n_zeroes = (v))
1436 #define MIN(a,b) ((a) < (b)? (a) : (b))
1437 /* This vector is used to turn an internal segment into a section #
1438 suitable for insertion into a coff symbol table
1441 const short seg_N_TYPE[] =
1442 { /* in: segT out: N_TYPE bits */
1444 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
1445 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
1446 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
1447 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
1448 C_UNDEF_SECTION, /* SEG_UNKNOWN */
1449 C_UNDEF_SECTION, /* SEG_GOOF */
1450 C_UNDEF_SECTION, /* SEG_EXPR */
1451 C_DEBUG_SECTION, /* SEG_DEBUG */
1452 C_NTV_SECTION, /* SEG_NTV */
1453 C_PTV_SECTION, /* SEG_PTV */
1454 C_REGISTER_SECTION, /* SEG_REGISTER */
1457 int function_lineoff = -1; /* Offset in line#s where the last function
1458 started (the odd entry for line #0) */
1460 /* structure used to keep the filenames which
1461 are too long around so that we can stick them
1462 into the string table */
1463 struct filename_list
1466 struct filename_list *next;
1469 static struct filename_list *filename_list_head;
1470 static struct filename_list *filename_list_tail;
1472 static symbolS *last_line_symbol;
1474 /* Add 4 to the real value to get the index and compensate the
1475 negatives. This vector is used by S_GET_SEGMENT to turn a coff
1476 section number into a segment number
1478 static symbolS *previous_file_symbol;
1479 void c_symbol_merge ();
1480 static int line_base;
1482 symbolS *c_section_symbol ();
1485 static void fixup_segment PARAMS ((segment_info_type *segP,
1486 segT this_segment_type));
1489 static void fixup_mdeps PARAMS ((fragS *,
1494 static void fill_section PARAMS ((bfd * abfd,
1499 static int c_line_new PARAMS ((symbolS * symbol, long paddr,
1504 static void w_symbols PARAMS ((bfd * abfd, char *where,
1505 symbolS * symbol_rootP));
1507 static void adjust_stab_section PARAMS ((bfd *abfd, segT seg));
1509 static void obj_coff_lcomm PARAMS ((int));
1510 static void obj_coff_text PARAMS ((int));
1511 static void obj_coff_data PARAMS ((int));
1512 static void obj_coff_ident PARAMS ((int));
1513 void obj_coff_section PARAMS ((int));
1517 We allow more than just the standard 3 sections, infact, we allow
1518 40 sections, (though the usual three have to be there).
1520 This structure performs the mappings for us:
1530 static const seg_info_type seg_info_off_by_4[] =
1537 {SEG_E0}, {SEG_E1}, {SEG_E2}, {SEG_E3}, {SEG_E4},
1538 {SEG_E5}, {SEG_E6}, {SEG_E7}, {SEG_E8}, {SEG_E9},
1539 {SEG_E10},{SEG_E11},{SEG_E12},{SEG_E13},{SEG_E14},
1540 {SEG_E15},{SEG_E16},{SEG_E17},{SEG_E18},{SEG_E19},
1541 {SEG_E20},{SEG_E21},{SEG_E22},{SEG_E23},{SEG_E24},
1542 {SEG_E25},{SEG_E26},{SEG_E27},{SEG_E28},{SEG_E29},
1543 {SEG_E30},{SEG_E31},{SEG_E32},{SEG_E33},{SEG_E34},
1544 {SEG_E35},{SEG_E36},{SEG_E37},{SEG_E38},{SEG_E39},
1559 #define SEG_INFO_FROM_SECTION_NUMBER(x) (seg_info_off_by_4[(x)+4])
1561 static relax_addressT
1562 relax_align (address, alignment)
1563 relax_addressT address;
1566 relax_addressT mask;
1567 relax_addressT new_address;
1569 mask = ~((~0) << alignment);
1570 new_address = (address + mask) & (~mask);
1571 return (new_address - address);
1579 return SEG_INFO_FROM_SECTION_NUMBER (x->sy_symbol.ost_entry.n_scnum).seg_t;
1582 /* calculate the size of the frag chain and fill in the section header
1583 to contain all of it, also fill in the addr of the sections */
1585 size_section (abfd, idx)
1590 unsigned int size = 0;
1591 fragS *frag = segment_info[idx].frchainP->frch_root;
1594 size = frag->fr_address;
1595 if (frag->fr_address != size)
1597 fprintf (stderr, _("Out of step\n"));
1598 size = frag->fr_address;
1601 switch (frag->fr_type)
1603 #ifdef TC_COFF_SIZEMACHDEP
1604 case rs_machine_dependent:
1605 size += TC_COFF_SIZEMACHDEP (frag);
1609 assert (frag->fr_symbol == 0);
1612 size += frag->fr_fix;
1613 size += frag->fr_offset * frag->fr_var;
1620 size += frag->fr_fix;
1621 off = relax_align (size, frag->fr_offset);
1622 if (frag->fr_subtype != 0 && off > frag->fr_subtype)
1628 BAD_CASE (frag->fr_type);
1631 frag = frag->fr_next;
1633 segment_info[idx].scnhdr.s_size = size;
1639 count_entries_in_chain (idx)
1642 unsigned int nrelocs;
1645 /* Count the relocations */
1646 fixup_ptr = segment_info[idx].fix_root;
1648 while (fixup_ptr != (fixS *) NULL)
1650 if (fixup_ptr->fx_done == 0 && TC_COUNT_RELOC (fixup_ptr))
1653 if (fixup_ptr->fx_r_type == RELOC_CONSTH)
1662 fixup_ptr = fixup_ptr->fx_next;
1669 static int compare_external_relocs PARAMS ((const PTR, const PTR));
1671 /* AUX's ld expects relocations to be sorted */
1673 compare_external_relocs (x, y)
1677 struct external_reloc *a = (struct external_reloc *) x;
1678 struct external_reloc *b = (struct external_reloc *) y;
1679 bfd_vma aadr = bfd_getb32 (a->r_vaddr);
1680 bfd_vma badr = bfd_getb32 (b->r_vaddr);
1681 return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
1686 /* output all the relocations for a section */
1688 do_relocs_for (abfd, h, file_cursor)
1691 unsigned long *file_cursor;
1693 unsigned int nrelocs;
1695 unsigned long reloc_start = *file_cursor;
1697 for (idx = SEG_E0; idx < SEG_LAST; idx++)
1699 if (segment_info[idx].scnhdr.s_name[0])
1701 struct external_reloc *ext_ptr;
1702 struct external_reloc *external_reloc_vec;
1703 unsigned int external_reloc_size;
1704 unsigned int base = segment_info[idx].scnhdr.s_paddr;
1705 fixS *fix_ptr = segment_info[idx].fix_root;
1706 nrelocs = count_entries_in_chain (idx);
1709 /* Bypass this stuff if no relocs. This also incidentally
1710 avoids a SCO bug, where free(malloc(0)) tends to crash. */
1712 external_reloc_size = nrelocs * RELSZ;
1713 external_reloc_vec =
1714 (struct external_reloc *) malloc (external_reloc_size);
1716 ext_ptr = external_reloc_vec;
1718 /* Fill in the internal coff style reloc struct from the
1719 internal fix list. */
1722 struct internal_reloc intr;
1724 /* Only output some of the relocations */
1725 if (fix_ptr->fx_done == 0 && TC_COUNT_RELOC (fix_ptr))
1727 #ifdef TC_RELOC_MANGLE
1728 TC_RELOC_MANGLE (&segment_info[idx], fix_ptr, &intr,
1733 symbolS *symbol_ptr = fix_ptr->fx_addsy;
1735 intr.r_type = TC_COFF_FIX2RTYPE (fix_ptr);
1737 base + fix_ptr->fx_frag->fr_address + fix_ptr->fx_where;
1739 #ifdef TC_KEEP_FX_OFFSET
1740 intr.r_offset = fix_ptr->fx_offset;
1745 while (symbol_ptr->sy_value.X_op == O_symbol
1746 && (! S_IS_DEFINED (symbol_ptr)
1747 || S_IS_COMMON (symbol_ptr)))
1751 /* We must avoid looping, as that can occur
1752 with a badly written program. */
1753 n = symbol_ptr->sy_value.X_add_symbol;
1754 if (n == symbol_ptr)
1759 /* Turn the segment of the symbol into an offset. */
1762 resolve_symbol_value (symbol_ptr, 1);
1763 if (! symbol_ptr->sy_resolved)
1768 if (expr_symbol_where (symbol_ptr, &file, &line))
1769 as_bad_where (file, line,
1770 _("unresolved relocation"));
1772 as_bad (_("bad relocation: symbol `%s' not in symbol table"),
1773 S_GET_NAME (symbol_ptr));
1775 dot = segment_info[S_GET_SEGMENT (symbol_ptr)].dot;
1778 intr.r_symndx = dot->sy_number;
1782 intr.r_symndx = symbol_ptr->sy_number;
1792 (void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
1795 #if defined(TC_A29K)
1797 /* The 29k has a special kludge for the high 16 bit
1798 reloc. Two relocations are emited, R_IHIHALF,
1799 and R_IHCONST. The second one doesn't contain a
1800 symbol, but uses the value for offset. */
1802 if (intr.r_type == R_IHIHALF)
1804 /* now emit the second bit */
1805 intr.r_type = R_IHCONST;
1806 intr.r_symndx = fix_ptr->fx_addnumber;
1807 (void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
1813 fix_ptr = fix_ptr->fx_next;
1817 /* Sort the reloc table */
1818 qsort ((PTR) external_reloc_vec, nrelocs,
1819 sizeof (struct external_reloc), compare_external_relocs);
1822 /* Write out the reloc table */
1823 bfd_write ((PTR) external_reloc_vec, 1, external_reloc_size,
1825 free (external_reloc_vec);
1827 /* Fill in section header info. */
1828 segment_info[idx].scnhdr.s_relptr = *file_cursor;
1829 *file_cursor += external_reloc_size;
1830 segment_info[idx].scnhdr.s_nreloc = nrelocs;
1835 segment_info[idx].scnhdr.s_relptr = 0;
1839 /* Set relocation_size field in file headers */
1840 H_SET_RELOCATION_SIZE (h, *file_cursor - reloc_start, 0);
1844 /* run through a frag chain and write out the data to go with it, fill
1845 in the scnhdrs with the info on the file postions
1848 fill_section (abfd, h, file_cursor)
1851 unsigned long *file_cursor;
1855 unsigned int paddr = 0;
1857 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
1859 unsigned int offset = 0;
1860 struct internal_scnhdr *s = &(segment_info[i].scnhdr);
1866 fragS *frag = segment_info[i].frchainP->frch_root;
1873 buffer = xmalloc (s->s_size);
1874 s->s_scnptr = *file_cursor;
1876 know (s->s_paddr == paddr);
1878 if (strcmp (s->s_name, ".text") == 0)
1879 s->s_flags |= STYP_TEXT;
1880 else if (strcmp (s->s_name, ".data") == 0)
1881 s->s_flags |= STYP_DATA;
1882 else if (strcmp (s->s_name, ".bss") == 0)
1885 s->s_flags |= STYP_BSS;
1887 /* @@ Should make the i386 and a29k coff targets define
1888 COFF_NOLOAD_PROBLEM, and have only one test here. */
1891 #ifndef COFF_NOLOAD_PROBLEM
1892 /* Apparently the SVR3 linker (and exec syscall) and UDI
1893 mondfe progrem are confused by noload sections. */
1894 s->s_flags |= STYP_NOLOAD;
1899 else if (strcmp (s->s_name, ".lit") == 0)
1900 s->s_flags = STYP_LIT | STYP_TEXT;
1901 else if (strcmp (s->s_name, ".init") == 0)
1902 s->s_flags |= STYP_TEXT;
1903 else if (strcmp (s->s_name, ".fini") == 0)
1904 s->s_flags |= STYP_TEXT;
1905 else if (strncmp (s->s_name, ".comment", 8) == 0)
1906 s->s_flags |= STYP_INFO;
1910 unsigned int fill_size;
1911 switch (frag->fr_type)
1913 case rs_machine_dependent:
1916 memcpy (buffer + frag->fr_address,
1918 (unsigned int) frag->fr_fix);
1919 offset += frag->fr_fix;
1924 assert (frag->fr_symbol == 0);
1931 memcpy (buffer + frag->fr_address,
1933 (unsigned int) frag->fr_fix);
1934 offset += frag->fr_fix;
1937 fill_size = frag->fr_var;
1938 if (fill_size && frag->fr_offset > 0)
1941 unsigned int off = frag->fr_fix;
1942 for (count = frag->fr_offset; count; count--)
1944 if (fill_size + frag->fr_address + off <= s->s_size)
1946 memcpy (buffer + frag->fr_address + off,
1947 frag->fr_literal + frag->fr_fix,
1950 offset += fill_size;
1955 case rs_broken_word:
1960 frag = frag->fr_next;
1965 if (s->s_scnptr != 0)
1967 bfd_write (buffer, s->s_size, 1, abfd);
1968 *file_cursor += s->s_size;
1977 /* Coff file generation & utilities */
1980 coff_header_append (abfd, h)
1987 #ifdef COFF_LONG_SECTION_NAMES
1988 unsigned long string_size = 4;
1991 bfd_seek (abfd, 0, 0);
1993 #ifndef OBJ_COFF_OMIT_OPTIONAL_HEADER
1994 H_SET_MAGIC_NUMBER (h, COFF_MAGIC);
1995 H_SET_VERSION_STAMP (h, 0);
1996 H_SET_ENTRY_POINT (h, 0);
1997 H_SET_TEXT_START (h, segment_info[SEG_E0].frchainP->frch_root->fr_address);
1998 H_SET_DATA_START (h, segment_info[SEG_E1].frchainP->frch_root->fr_address);
1999 H_SET_SIZEOF_OPTIONAL_HEADER (h, bfd_coff_swap_aouthdr_out(abfd, &h->aouthdr,
2001 #else /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
2002 H_SET_SIZEOF_OPTIONAL_HEADER (h, 0);
2003 #endif /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
2005 i = bfd_coff_swap_filehdr_out (abfd, &h->filehdr, buffer);
2007 bfd_write (buffer, i, 1, abfd);
2008 bfd_write (buffero, H_GET_SIZEOF_OPTIONAL_HEADER (h), 1, abfd);
2010 for (i = SEG_E0; i < SEG_LAST; i++)
2012 if (segment_info[i].scnhdr.s_name[0])
2016 #ifdef COFF_LONG_SECTION_NAMES
2017 /* Support long section names as found in PE. This code
2018 must coordinate with that in write_object_file and
2020 if (strlen (segment_info[i].name) > SCNNMLEN)
2022 memset (segment_info[i].scnhdr.s_name, 0, SCNNMLEN);
2023 sprintf (segment_info[i].scnhdr.s_name, "/%lu", string_size);
2024 string_size += strlen (segment_info[i].name) + 1;
2028 size = bfd_coff_swap_scnhdr_out (abfd,
2029 &(segment_info[i].scnhdr),
2032 as_bad (_("bfd_coff_swap_scnhdr_out failed"));
2033 bfd_write (buffer, size, 1, abfd);
2040 symbol_to_chars (abfd, where, symbolP)
2045 unsigned int numaux = symbolP->sy_symbol.ost_entry.n_numaux;
2049 /* Turn any symbols with register attributes into abs symbols */
2050 if (S_GET_SEGMENT (symbolP) == reg_section)
2052 S_SET_SEGMENT (symbolP, absolute_section);
2054 /* At the same time, relocate all symbols to their output value */
2057 val = (segment_info[S_GET_SEGMENT (symbolP)].scnhdr.s_paddr
2058 + S_GET_VALUE (symbolP));
2060 val = S_GET_VALUE (symbolP);
2063 S_SET_VALUE (symbolP, val);
2065 symbolP->sy_symbol.ost_entry.n_value = val;
2067 where += bfd_coff_swap_sym_out (abfd, &symbolP->sy_symbol.ost_entry,
2070 for (i = 0; i < numaux; i++)
2072 where += bfd_coff_swap_aux_out (abfd,
2073 &symbolP->sy_symbol.ost_auxent[i],
2074 S_GET_DATA_TYPE (symbolP),
2075 S_GET_STORAGE_CLASS (symbolP),
2083 coff_obj_symbol_new_hook (symbolP)
2086 char underscore = 0; /* Symbol has leading _ */
2088 /* Effective symbol */
2089 /* Store the pointer in the offset. */
2090 S_SET_ZEROES (symbolP, 0L);
2091 S_SET_DATA_TYPE (symbolP, T_NULL);
2092 S_SET_STORAGE_CLASS (symbolP, 0);
2093 S_SET_NUMBER_AUXILIARY (symbolP, 0);
2094 /* Additional information */
2095 symbolP->sy_symbol.ost_flags = 0;
2096 /* Auxiliary entries */
2097 memset ((char *) &symbolP->sy_symbol.ost_auxent[0], 0, AUXESZ);
2099 if (S_IS_STRING (symbolP))
2100 SF_SET_STRING (symbolP);
2101 if (!underscore && S_IS_LOCAL (symbolP))
2102 SF_SET_LOCAL (symbolP);
2106 * Handle .ln directives.
2110 obj_coff_ln (appline)
2115 if (! appline && def_symbol_in_progress != NULL)
2117 as_warn (_(".ln pseudo-op inside .def/.endef: ignored."));
2118 demand_empty_rest_of_line ();
2120 } /* wrong context */
2122 l = get_absolute_expression ();
2123 c_line_new (0, frag_now_fix (), l, frag_now);
2126 new_logical_line ((char *) NULL, l - 1);
2136 listing_source_line ((unsigned int) l);
2141 demand_empty_rest_of_line ();
2147 * Handle .def directives.
2149 * One might ask : why can't we symbol_new if the symbol does not
2150 * already exist and fill it with debug information. Because of
2151 * the C_EFCN special symbol. It would clobber the value of the
2152 * function symbol before we have a chance to notice that it is
2153 * a C_EFCN. And a second reason is that the code is more clear this
2154 * way. (at least I think it is :-).
2158 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
2159 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
2160 *input_line_pointer == '\t') \
2161 input_line_pointer++;
2167 char name_end; /* Char after the end of name */
2168 char *symbol_name; /* Name of the debug symbol */
2169 char *symbol_name_copy; /* Temporary copy of the name */
2170 unsigned int symbol_name_length;
2172 if (def_symbol_in_progress != NULL)
2174 as_warn (_(".def pseudo-op used inside of .def/.endef: ignored."));
2175 demand_empty_rest_of_line ();
2177 } /* if not inside .def/.endef */
2179 SKIP_WHITESPACES ();
2181 def_symbol_in_progress = (symbolS *) obstack_alloc (¬es, sizeof (*def_symbol_in_progress));
2182 memset (def_symbol_in_progress, 0, sizeof (*def_symbol_in_progress));
2184 symbol_name = input_line_pointer;
2185 name_end = get_symbol_end ();
2186 symbol_name_length = strlen (symbol_name);
2187 symbol_name_copy = xmalloc (symbol_name_length + 1);
2188 strcpy (symbol_name_copy, symbol_name);
2189 #ifdef tc_canonicalize_symbol_name
2190 symbol_name_copy = tc_canonicalize_symbol_name (symbol_name_copy);
2193 /* Initialize the new symbol */
2194 #ifdef STRIP_UNDERSCORE
2195 S_SET_NAME (def_symbol_in_progress, (*symbol_name_copy == '_'
2196 ? symbol_name_copy + 1
2197 : symbol_name_copy));
2198 #else /* STRIP_UNDERSCORE */
2199 S_SET_NAME (def_symbol_in_progress, symbol_name_copy);
2200 #endif /* STRIP_UNDERSCORE */
2201 /* free(symbol_name_copy); */
2202 def_symbol_in_progress->sy_name_offset = (unsigned long) ~0;
2203 def_symbol_in_progress->sy_number = ~0;
2204 def_symbol_in_progress->sy_frag = &zero_address_frag;
2205 S_SET_VALUE (def_symbol_in_progress, 0);
2207 if (S_IS_STRING (def_symbol_in_progress))
2208 SF_SET_STRING (def_symbol_in_progress);
2210 *input_line_pointer = name_end;
2212 demand_empty_rest_of_line ();
2215 unsigned int dim_index;
2219 obj_coff_endef (ignore)
2222 symbolS *symbolP = 0;
2223 /* DIM BUG FIX sac@cygnus.com */
2225 if (def_symbol_in_progress == NULL)
2227 as_warn (_(".endef pseudo-op used outside of .def/.endef: ignored."));
2228 demand_empty_rest_of_line ();
2230 } /* if not inside .def/.endef */
2232 /* Set the section number according to storage class. */
2233 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))
2238 SF_SET_TAG (def_symbol_in_progress);
2239 /* intentional fallthrough */
2242 SF_SET_DEBUG (def_symbol_in_progress);
2243 S_SET_SEGMENT (def_symbol_in_progress, SEG_DEBUG);
2247 SF_SET_LOCAL (def_symbol_in_progress); /* Do not emit this symbol. */
2248 /* intentional fallthrough */
2250 SF_SET_PROCESS (def_symbol_in_progress); /* Will need processing before writing */
2251 /* intentional fallthrough */
2253 S_SET_SEGMENT (def_symbol_in_progress, SEG_E0);
2255 if (strcmp (S_GET_NAME (def_symbol_in_progress), ".bf") == 0)
2257 if (function_lineoff < 0)
2259 fprintf (stderr, _("`.bf' symbol without preceding function\n"));
2260 } /* missing function symbol */
2261 SA_GET_SYM_LNNOPTR (last_line_symbol) = function_lineoff;
2263 SF_SET_PROCESS (last_line_symbol);
2264 SF_SET_ADJ_LNNOPTR (last_line_symbol);
2265 SF_SET_PROCESS (def_symbol_in_progress);
2266 function_lineoff = -1;
2268 /* Value is always set to . */
2269 def_symbol_in_progress->sy_frag = frag_now;
2270 S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
2275 #endif /* C_AUTOARG */
2285 SF_SET_DEBUG (def_symbol_in_progress);
2286 S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
2296 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
2302 as_warn (_("unexpected storage class %d"), S_GET_STORAGE_CLASS (def_symbol_in_progress));
2304 } /* switch on storage class */
2306 /* Now that we have built a debug symbol, try to find if we should
2307 merge with an existing symbol or not. If a symbol is C_EFCN or
2308 absolute_section or untagged SEG_DEBUG it never merges. We also
2309 don't merge labels, which are in a different namespace, nor
2310 symbols which have not yet been defined since they are typically
2311 unique, nor do we merge tags with non-tags. */
2313 /* Two cases for functions. Either debug followed by definition or
2314 definition followed by debug. For definition first, we will
2315 merge the debug symbol into the definition. For debug first, the
2316 lineno entry MUST point to the definition function or else it
2317 will point off into space when crawl_symbols() merges the debug
2318 symbol into the real symbol. Therefor, let's presume the debug
2319 symbol is a real function reference. */
2321 /* FIXME-SOON If for some reason the definition label/symbol is
2322 never seen, this will probably leave an undefined symbol at link
2325 if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN
2326 || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_LABEL
2327 || (S_GET_SEGMENT (def_symbol_in_progress) == SEG_DEBUG
2328 && !SF_GET_TAG (def_symbol_in_progress))
2329 || S_GET_SEGMENT (def_symbol_in_progress) == absolute_section
2330 || def_symbol_in_progress->sy_value.X_op != O_constant
2331 || (symbolP = symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP)) == NULL
2332 || (SF_GET_TAG (def_symbol_in_progress) != SF_GET_TAG (symbolP)))
2334 symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP,
2339 /* This symbol already exists, merge the newly created symbol
2340 into the old one. This is not mandatory. The linker can
2341 handle duplicate symbols correctly. But I guess that it save
2342 a *lot* of space if the assembly file defines a lot of
2345 /* The debug entry (def_symbol_in_progress) is merged into the
2346 previous definition. */
2348 c_symbol_merge (def_symbol_in_progress, symbolP);
2349 /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
2350 def_symbol_in_progress = symbolP;
2352 if (SF_GET_FUNCTION (def_symbol_in_progress)
2353 || SF_GET_TAG (def_symbol_in_progress)
2354 || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_STAT)
2356 /* For functions, and tags, and static symbols, the symbol
2357 *must* be where the debug symbol appears. Move the
2358 existing symbol to the current place. */
2359 /* If it already is at the end of the symbol list, do nothing */
2360 if (def_symbol_in_progress != symbol_lastP)
2362 symbol_remove (def_symbol_in_progress, &symbol_rootP,
2364 symbol_append (def_symbol_in_progress, symbol_lastP,
2365 &symbol_rootP, &symbol_lastP);
2366 } /* if not already in place */
2368 } /* normal or mergable */
2370 if (SF_GET_TAG (def_symbol_in_progress))
2374 oldtag = symbol_find_base (S_GET_NAME (def_symbol_in_progress),
2376 if (oldtag == NULL || ! SF_GET_TAG (oldtag))
2377 tag_insert (S_GET_NAME (def_symbol_in_progress),
2378 def_symbol_in_progress);
2381 if (SF_GET_FUNCTION (def_symbol_in_progress))
2383 know (sizeof (def_symbol_in_progress) <= sizeof (long));
2385 = c_line_new (def_symbol_in_progress, 0, 0, &zero_address_frag);
2387 SF_SET_PROCESS (def_symbol_in_progress);
2389 if (symbolP == NULL)
2391 /* That is, if this is the first time we've seen the
2393 symbol_table_insert (def_symbol_in_progress);
2394 } /* definition follows debug */
2395 } /* Create the line number entry pointing to the function being defined */
2397 def_symbol_in_progress = NULL;
2398 demand_empty_rest_of_line ();
2402 obj_coff_dim (ignore)
2407 if (def_symbol_in_progress == NULL)
2409 as_warn (_(".dim pseudo-op used outside of .def/.endef: ignored."));
2410 demand_empty_rest_of_line ();
2412 } /* if not inside .def/.endef */
2414 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2416 for (dim_index = 0; dim_index < DIMNUM; dim_index++)
2418 SKIP_WHITESPACES ();
2419 SA_SET_SYM_DIMEN (def_symbol_in_progress, dim_index,
2420 get_absolute_expression ());
2422 switch (*input_line_pointer)
2425 input_line_pointer++;
2429 as_warn (_("badly formed .dim directive ignored"));
2430 /* intentional fallthrough */
2438 demand_empty_rest_of_line ();
2442 obj_coff_line (ignore)
2448 if (def_symbol_in_progress == NULL)
2454 name = S_GET_NAME (def_symbol_in_progress);
2455 this_base = get_absolute_expression ();
2457 /* Only .bf symbols indicate the use of a new base line number; the
2458 line numbers associated with .ef, .bb, .eb are relative to the
2459 start of the containing function. */
2460 if (!strcmp (".bf", name))
2462 #if 0 /* XXX Can we ever have line numbers going backwards? */
2463 if (this_base > line_base)
2466 line_base = this_base;
2474 listing_source_line ((unsigned int) line_base);
2480 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2481 SA_SET_SYM_LNNO (def_symbol_in_progress, this_base);
2483 demand_empty_rest_of_line ();
2487 obj_coff_size (ignore)
2490 if (def_symbol_in_progress == NULL)
2492 as_warn (_(".size pseudo-op used outside of .def/.endef ignored."));
2493 demand_empty_rest_of_line ();
2495 } /* if not inside .def/.endef */
2497 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2498 SA_SET_SYM_SIZE (def_symbol_in_progress, get_absolute_expression ());
2499 demand_empty_rest_of_line ();
2503 obj_coff_scl (ignore)
2506 if (def_symbol_in_progress == NULL)
2508 as_warn (_(".scl pseudo-op used outside of .def/.endef ignored."));
2509 demand_empty_rest_of_line ();
2511 } /* if not inside .def/.endef */
2513 S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ());
2514 demand_empty_rest_of_line ();
2518 obj_coff_tag (ignore)
2524 if (def_symbol_in_progress == NULL)
2526 as_warn (_(".tag pseudo-op used outside of .def/.endef ignored."));
2527 demand_empty_rest_of_line ();
2531 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2532 symbol_name = input_line_pointer;
2533 name_end = get_symbol_end ();
2534 #ifdef tc_canonicalize_symbol_name
2535 symbol_name = tc_canonicalize_symbol_name (symbol_name);
2538 /* Assume that the symbol referred to by .tag is always defined.
2539 This was a bad assumption. I've added find_or_make. xoxorich. */
2540 SA_SET_SYM_TAGNDX (def_symbol_in_progress,
2541 (long) tag_find_or_make (symbol_name));
2542 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L)
2544 as_warn (_("tag not found for .tag %s"), symbol_name);
2547 SF_SET_TAGGED (def_symbol_in_progress);
2548 *input_line_pointer = name_end;
2550 demand_empty_rest_of_line ();
2554 obj_coff_type (ignore)
2557 if (def_symbol_in_progress == NULL)
2559 as_warn (_(".type pseudo-op used outside of .def/.endef ignored."));
2560 demand_empty_rest_of_line ();
2562 } /* if not inside .def/.endef */
2564 S_SET_DATA_TYPE (def_symbol_in_progress, get_absolute_expression ());
2566 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress)) &&
2567 S_GET_STORAGE_CLASS (def_symbol_in_progress) != C_TPDEF)
2569 SF_SET_FUNCTION (def_symbol_in_progress);
2570 } /* is a function */
2572 demand_empty_rest_of_line ();
2576 obj_coff_val (ignore)
2579 if (def_symbol_in_progress == NULL)
2581 as_warn (_(".val pseudo-op used outside of .def/.endef ignored."));
2582 demand_empty_rest_of_line ();
2584 } /* if not inside .def/.endef */
2586 if (is_name_beginner (*input_line_pointer))
2588 char *symbol_name = input_line_pointer;
2589 char name_end = get_symbol_end ();
2591 #ifdef tc_canonicalize_symbol_name
2592 symbol_name = tc_canonicalize_symbol_name (symbol_name);
2595 if (!strcmp (symbol_name, "."))
2597 def_symbol_in_progress->sy_frag = frag_now;
2598 S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
2599 /* If the .val is != from the .def (e.g. statics) */
2601 else if (strcmp (S_GET_NAME (def_symbol_in_progress), symbol_name))
2603 def_symbol_in_progress->sy_value.X_op = O_symbol;
2604 def_symbol_in_progress->sy_value.X_add_symbol =
2605 symbol_find_or_make (symbol_name);
2606 def_symbol_in_progress->sy_value.X_op_symbol = NULL;
2607 def_symbol_in_progress->sy_value.X_add_number = 0;
2609 /* If the segment is undefined when the forward reference is
2610 resolved, then copy the segment id from the forward
2612 SF_SET_GET_SEGMENT (def_symbol_in_progress);
2614 /* FIXME: gcc can generate address expressions
2615 here in unusual cases (search for "obscure"
2616 in sdbout.c). We just ignore the offset
2617 here, thus generating incorrect debugging
2618 information. We ignore the rest of the
2621 /* Otherwise, it is the name of a non debug symbol and
2622 its value will be calculated later. */
2623 *input_line_pointer = name_end;
2625 /* FIXME: this is to avoid an error message in the
2626 FIXME case mentioned just above. */
2627 while (! is_end_of_line[(unsigned char) *input_line_pointer])
2628 ++input_line_pointer;
2632 S_SET_VALUE (def_symbol_in_progress,
2633 (valueT) get_absolute_expression ());
2634 } /* if symbol based */
2636 demand_empty_rest_of_line ();
2641 /* Handle the .linkonce pseudo-op. This is parsed by s_linkonce in
2642 read.c, which then calls this object file format specific routine. */
2645 obj_coff_pe_handle_link_once (type)
2646 enum linkonce_type type;
2648 seg_info (now_seg)->scnhdr.s_flags |= IMAGE_SCN_LNK_COMDAT;
2650 /* We store the type in the seg_info structure, and use it to set up
2651 the auxiliary entry for the section symbol in c_section_symbol. */
2652 seg_info (now_seg)->linkonce = type;
2658 coff_obj_read_begin_hook ()
2660 /* These had better be the same. Usually 18 bytes. */
2662 know (sizeof (SYMENT) == sizeof (AUXENT));
2663 know (SYMESZ == AUXESZ);
2668 /* This function runs through the symbol table and puts all the
2669 externals onto another chain */
2671 /* The chain of globals. */
2672 symbolS *symbol_globalP;
2673 symbolS *symbol_global_lastP;
2675 /* The chain of externals */
2676 symbolS *symbol_externP;
2677 symbolS *symbol_extern_lastP;
2680 symbolS *last_functionP;
2681 static symbolS *last_bfP;
2688 unsigned int symbol_number = 0;
2689 unsigned int last_file_symno = 0;
2691 struct filename_list *filename_list_scan = filename_list_head;
2693 for (symbolP = symbol_rootP;
2695 symbolP = symbolP ? symbol_next (symbolP) : symbol_rootP)
2697 if (symbolP->sy_mri_common)
2699 if (S_GET_STORAGE_CLASS (symbolP) == C_EXT
2701 || S_GET_STORAGE_CLASS (symbolP) == C_NT_WEAK
2703 || S_GET_STORAGE_CLASS (symbolP) == C_WEAKEXT)
2704 as_bad (_("%s: global symbols not supported in common sections"),
2705 S_GET_NAME (symbolP));
2706 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2710 if (!SF_GET_DEBUG (symbolP))
2712 /* Debug symbols do not need all this rubbish */
2713 symbolS *real_symbolP;
2715 /* L* and C_EFCN symbols never merge. */
2716 if (!SF_GET_LOCAL (symbolP)
2717 && !SF_GET_STATICS (symbolP)
2718 && S_GET_STORAGE_CLASS (symbolP) != C_LABEL
2719 && symbolP->sy_value.X_op == O_constant
2720 && (real_symbolP = symbol_find_base (S_GET_NAME (symbolP), DO_NOT_STRIP))
2721 && real_symbolP != symbolP)
2723 /* FIXME-SOON: where do dups come from?
2724 Maybe tag references before definitions? xoxorich. */
2725 /* Move the debug data from the debug symbol to the
2726 real symbol. Do NOT do the oposite (i.e. move from
2727 real symbol to debug symbol and remove real symbol from the
2728 list.) Because some pointers refer to the real symbol
2729 whereas no pointers refer to the debug symbol. */
2730 c_symbol_merge (symbolP, real_symbolP);
2731 /* Replace the current symbol by the real one */
2732 /* The symbols will never be the last or the first
2733 because : 1st symbol is .file and 3 last symbols are
2734 .text, .data, .bss */
2735 symbol_remove (real_symbolP, &symbol_rootP, &symbol_lastP);
2736 symbol_insert (real_symbolP, symbolP, &symbol_rootP, &symbol_lastP);
2737 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2738 symbolP = real_symbolP;
2739 } /* if not local but dup'd */
2741 if (flag_readonly_data_in_text && (S_GET_SEGMENT (symbolP) == SEG_E1))
2743 S_SET_SEGMENT (symbolP, SEG_E0);
2744 } /* push data into text */
2746 resolve_symbol_value (symbolP, 1);
2748 if (S_GET_STORAGE_CLASS (symbolP) == C_NULL)
2750 if (!S_IS_DEFINED (symbolP) && !SF_GET_LOCAL (symbolP))
2752 S_SET_EXTERNAL (symbolP);
2754 else if (S_GET_SEGMENT (symbolP) == SEG_E0)
2756 S_SET_STORAGE_CLASS (symbolP, C_LABEL);
2760 S_SET_STORAGE_CLASS (symbolP, C_STAT);
2764 /* Mainly to speed up if not -g */
2765 if (SF_GET_PROCESS (symbolP))
2767 /* Handle the nested blocks auxiliary info. */
2768 if (S_GET_STORAGE_CLASS (symbolP) == C_BLOCK)
2770 if (!strcmp (S_GET_NAME (symbolP), ".bb"))
2771 stack_push (block_stack, (char *) &symbolP);
2774 register symbolS *begin_symbolP;
2775 begin_symbolP = *(symbolS **) stack_pop (block_stack);
2776 if (begin_symbolP == (symbolS *) 0)
2777 as_warn (_("mismatched .eb"));
2779 SA_SET_SYM_ENDNDX (begin_symbolP, symbol_number + 2);
2782 /* If we are able to identify the type of a function, and we
2783 are out of a function (last_functionP == 0) then, the
2784 function symbol will be associated with an auxiliary
2786 if (last_functionP == (symbolS *) 0 &&
2787 SF_GET_FUNCTION (symbolP))
2789 last_functionP = symbolP;
2791 if (S_GET_NUMBER_AUXILIARY (symbolP) < 1)
2793 S_SET_NUMBER_AUXILIARY (symbolP, 1);
2794 } /* make it at least 1 */
2796 /* Clobber possible stale .dim information. */
2798 /* Iffed out by steve - this fries the lnnoptr info too */
2799 bzero (symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen,
2800 sizeof (symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen));
2803 if (S_GET_STORAGE_CLASS (symbolP) == C_FCN)
2805 if (strcmp (S_GET_NAME (symbolP), ".bf") == 0)
2807 if (last_bfP != NULL)
2808 SA_SET_SYM_ENDNDX (last_bfP, symbol_number);
2812 else if (S_GET_STORAGE_CLASS (symbolP) == C_EFCN)
2814 /* I don't even know if this is needed for sdb. But
2815 the standard assembler generates it, so... */
2816 if (last_functionP == (symbolS *) 0)
2817 as_fatal (_("C_EFCN symbol out of scope"));
2818 SA_SET_SYM_FSIZE (last_functionP,
2819 (long) (S_GET_VALUE (symbolP) -
2820 S_GET_VALUE (last_functionP)));
2821 SA_SET_SYM_ENDNDX (last_functionP, symbol_number);
2822 last_functionP = (symbolS *) 0;
2826 else if (SF_GET_TAG (symbolP))
2828 /* First descriptor of a structure must point to
2829 the first slot after the structure description. */
2830 last_tagP = symbolP;
2833 else if (S_GET_STORAGE_CLASS (symbolP) == C_EOS)
2835 /* +2 take in account the current symbol */
2836 SA_SET_SYM_ENDNDX (last_tagP, symbol_number + 2);
2838 else if (S_GET_STORAGE_CLASS (symbolP) == C_FILE)
2840 /* If the filename was too long to fit in the
2841 auxent, put it in the string table */
2842 if (SA_GET_FILE_FNAME_ZEROS (symbolP) == 0
2843 && SA_GET_FILE_FNAME_OFFSET (symbolP) != 0)
2845 SA_SET_FILE_FNAME_OFFSET (symbolP, string_byte_count);
2846 string_byte_count += strlen (filename_list_scan->filename) + 1;
2847 filename_list_scan = filename_list_scan->next;
2849 if (S_GET_VALUE (symbolP))
2851 S_SET_VALUE (symbolP, last_file_symno);
2852 last_file_symno = symbol_number;
2853 } /* no one points at the first .file symbol */
2854 } /* if debug or tag or eos or file */
2856 #ifdef tc_frob_coff_symbol
2857 tc_frob_coff_symbol (symbolP);
2860 /* We must put the external symbols apart. The loader
2861 does not bomb if we do not. But the references in
2862 the endndx field for a .bb symbol are not corrected
2863 if an external symbol is removed between .bb and .be.
2864 I.e in the following case :
2865 [20] .bb endndx = 22
2868 ld will move the symbol 21 to the end of the list but
2869 endndx will still be 22 instead of 21. */
2872 if (SF_GET_LOCAL (symbolP))
2874 /* remove C_EFCN and LOCAL (L...) symbols */
2875 /* next pointer remains valid */
2876 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2879 else if (symbolP->sy_value.X_op == O_symbol
2880 && (! S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP)))
2882 /* Skip symbols which were equated to undefined or common
2884 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2886 else if (!S_IS_DEFINED (symbolP)
2887 && !S_IS_DEBUG (symbolP)
2888 && !SF_GET_STATICS (symbolP)
2889 && (S_GET_STORAGE_CLASS (symbolP) == C_EXT
2891 || S_GET_STORAGE_CLASS (symbolP) == C_NT_WEAK
2893 || S_GET_STORAGE_CLASS (symbolP) == C_WEAKEXT))
2895 /* if external, Remove from the list */
2896 symbolS *hold = symbol_previous (symbolP);
2898 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2899 symbol_clear_list_pointers (symbolP);
2900 symbol_append (symbolP, symbol_extern_lastP, &symbol_externP, &symbol_extern_lastP);
2903 else if (! S_IS_DEBUG (symbolP)
2904 && ! SF_GET_STATICS (symbolP)
2905 && ! SF_GET_FUNCTION (symbolP)
2906 && (S_GET_STORAGE_CLASS (symbolP) == C_EXT
2908 || S_GET_STORAGE_CLASS (symbolP) == C_NT_WEAK
2910 || S_GET_STORAGE_CLASS (symbolP) == C_NT_WEAK))
2912 symbolS *hold = symbol_previous (symbolP);
2914 /* The O'Reilly COFF book says that defined global symbols
2915 come at the end of the symbol table, just before
2916 undefined global symbols. */
2918 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2919 symbol_clear_list_pointers (symbolP);
2920 symbol_append (symbolP, symbol_global_lastP, &symbol_globalP,
2921 &symbol_global_lastP);
2926 if (SF_GET_STRING (symbolP))
2928 symbolP->sy_name_offset = string_byte_count;
2929 string_byte_count += strlen (S_GET_NAME (symbolP)) + 1;
2933 symbolP->sy_name_offset = 0;
2934 } /* fix "long" names */
2936 symbolP->sy_number = symbol_number;
2937 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (symbolP);
2938 } /* if local symbol */
2939 } /* traverse the symbol list */
2940 return symbol_number;
2946 glue_symbols (head, tail)
2950 unsigned int symbol_number = 0;
2952 while (*head != NULL)
2954 symbolS *tmp = *head;
2957 symbol_remove (tmp, head, tail);
2958 symbol_append (tmp, symbol_lastP, &symbol_rootP, &symbol_lastP);
2961 if (SF_GET_STRING (tmp))
2963 tmp->sy_name_offset = string_byte_count;
2964 string_byte_count += strlen (S_GET_NAME (tmp)) + 1;
2968 tmp->sy_name_offset = 0;
2969 } /* fix "long" names */
2971 tmp->sy_number = symbol_number;
2972 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (tmp);
2973 } /* append the entire extern chain */
2975 return symbol_number;
2981 unsigned int symbol_number = 0;
2984 for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
2986 symbolP->sy_number = symbol_number;
2988 if (SF_GET_TAGGED (symbolP))
2992 ((symbolS *) SA_GET_SYM_TAGNDX (symbolP))->sy_number);
2995 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (symbolP);
2998 return symbol_number;
3002 crawl_symbols (h, abfd)
3008 /* Initialize the stack used to keep track of the matching .bb .be */
3010 block_stack = stack_init (512, sizeof (symbolS *));
3012 /* The symbol list should be ordered according to the following sequence
3015 * . debug entries for functions
3016 * . fake symbols for the sections, including .text .data and .bss
3018 * . undefined symbols
3019 * But this is not mandatory. The only important point is to put the
3020 * undefined symbols at the end of the list.
3023 /* Is there a .file symbol ? If not insert one at the beginning. */
3024 if (symbol_rootP == NULL
3025 || S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
3027 c_dot_file_symbol ("fake");
3031 * Build up static symbols for the sections, they are filled in later
3035 for (i = SEG_E0; i < SEG_LAST; i++)
3036 if (segment_info[i].scnhdr.s_name[0])
3037 segment_info[i].dot = c_section_symbol (segment_info[i].name,
3040 /* Take all the externals out and put them into another chain */
3041 H_SET_SYMBOL_TABLE_SIZE (h, yank_symbols ());
3042 /* Take the externals and glue them onto the end.*/
3043 H_SET_SYMBOL_TABLE_SIZE (h,
3044 (H_GET_SYMBOL_COUNT (h)
3045 + glue_symbols (&symbol_globalP,
3046 &symbol_global_lastP)
3047 + glue_symbols (&symbol_externP,
3048 &symbol_extern_lastP)));
3050 H_SET_SYMBOL_TABLE_SIZE (h, tie_tags ());
3051 know (symbol_globalP == NULL);
3052 know (symbol_global_lastP == NULL);
3053 know (symbol_externP == NULL);
3054 know (symbol_extern_lastP == NULL);
3058 * Find strings by crawling along symbol table chain.
3066 struct filename_list *filename_list_scan = filename_list_head;
3068 /* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
3069 md_number_to_chars (where, (valueT) string_byte_count, 4);
3072 #ifdef COFF_LONG_SECTION_NAMES
3073 /* Support long section names as found in PE. This code must
3074 coordinate with that in coff_header_append and write_object_file. */
3078 for (i = SEG_E0; i < SEG_LAST; i++)
3080 if (segment_info[i].scnhdr.s_name[0]
3081 && strlen (segment_info[i].name) > SCNNMLEN)
3085 size = strlen (segment_info[i].name) + 1;
3086 memcpy (where, segment_info[i].name, size);
3091 #endif /* COFF_LONG_SECTION_NAMES */
3093 for (symbolP = symbol_rootP;
3095 symbolP = symbol_next (symbolP))
3099 if (SF_GET_STRING (symbolP))
3101 size = strlen (S_GET_NAME (symbolP)) + 1;
3102 memcpy (where, S_GET_NAME (symbolP), size);
3105 if (S_GET_STORAGE_CLASS (symbolP) == C_FILE
3106 && SA_GET_FILE_FNAME_ZEROS (symbolP) == 0
3107 && SA_GET_FILE_FNAME_OFFSET (symbolP) != 0)
3109 size = strlen (filename_list_scan->filename) + 1;
3110 memcpy (where, filename_list_scan->filename, size);
3111 filename_list_scan = filename_list_scan ->next;
3118 do_linenos_for (abfd, h, file_cursor)
3121 unsigned long *file_cursor;
3124 unsigned long start = *file_cursor;
3126 for (idx = SEG_E0; idx < SEG_LAST; idx++)
3128 segment_info_type *s = segment_info + idx;
3131 if (s->scnhdr.s_nlnno != 0)
3133 struct lineno_list *line_ptr;
3135 struct external_lineno *buffer =
3136 (struct external_lineno *) xmalloc (s->scnhdr.s_nlnno * LINESZ);
3138 struct external_lineno *dst = buffer;
3140 /* Run through the table we've built and turn it into its external
3141 form, take this chance to remove duplicates */
3143 for (line_ptr = s->lineno_list_head;
3144 line_ptr != (struct lineno_list *) NULL;
3145 line_ptr = line_ptr->next)
3148 if (line_ptr->line.l_lnno == 0)
3150 /* Turn a pointer to a symbol into the symbols' index */
3151 line_ptr->line.l_addr.l_symndx =
3152 ((symbolS *) line_ptr->line.l_addr.l_symndx)->sy_number;
3156 line_ptr->line.l_addr.l_paddr += ((struct frag *) (line_ptr->frag))->fr_address;
3160 (void) bfd_coff_swap_lineno_out (abfd, &(line_ptr->line), dst);
3165 s->scnhdr.s_lnnoptr = *file_cursor;
3167 bfd_write (buffer, 1, s->scnhdr.s_nlnno * LINESZ, abfd);
3170 *file_cursor += s->scnhdr.s_nlnno * LINESZ;
3173 H_SET_LINENO_SIZE (h, *file_cursor - start);
3177 /* Now we run through the list of frag chains in a segment and
3178 make all the subsegment frags appear at the end of the
3179 list, as if the seg 0 was extra long */
3186 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3188 frchainS *head = segment_info[i].frchainP;
3190 fragS *prev_frag = &dummy;
3192 while (head && head->frch_seg == i)
3194 prev_frag->fr_next = head->frch_root;
3195 prev_frag = head->frch_last;
3196 head = head->frch_next;
3198 prev_frag->fr_next = 0;
3202 unsigned long machine;
3205 write_object_file ()
3209 struct frchain *frchain_ptr;
3211 object_headers headers;
3212 unsigned long file_cursor;
3215 abfd = bfd_openw (out_file_name, TARGET_FORMAT);
3220 as_perror (_("FATAL: Can't create %s"), out_file_name);
3221 exit (EXIT_FAILURE);
3223 bfd_set_format (abfd, bfd_object);
3224 bfd_set_arch_mach (abfd, BFD_ARCH, machine);
3226 string_byte_count = 4;
3228 for (frchain_ptr = frchain_root;
3229 frchain_ptr != (struct frchain *) NULL;
3230 frchain_ptr = frchain_ptr->frch_next)
3232 /* Run through all the sub-segments and align them up. Also
3233 close any open frags. We tack a .fill onto the end of the
3234 frag chain so that any .align's size can be worked by looking
3235 at the next frag. */
3237 subseg_set (frchain_ptr->frch_seg, frchain_ptr->frch_subseg);
3239 #ifndef SUB_SEGMENT_ALIGN
3240 #define SUB_SEGMENT_ALIGN(SEG) 1
3243 md_do_align (SUB_SEGMENT_ALIGN (now_seg), (char *) NULL, 0, 0,
3246 frag_align (SUB_SEGMENT_ALIGN (now_seg),
3247 subseg_text_p (now_seg) ? NOP_OPCODE : 0,
3252 frag_wane (frag_now);
3253 frag_now->fr_fix = 0;
3254 know (frag_now->fr_next == NULL);
3261 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3263 relax_segment (segment_info[i].frchainP->frch_root, i);
3266 H_SET_NUMBER_OF_SECTIONS (&headers, 0);
3268 /* Find out how big the sections are, and set the addresses. */
3270 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3274 segment_info[i].scnhdr.s_paddr = addr;
3275 segment_info[i].scnhdr.s_vaddr = addr;
3277 if (segment_info[i].scnhdr.s_name[0])
3279 H_SET_NUMBER_OF_SECTIONS (&headers,
3280 H_GET_NUMBER_OF_SECTIONS (&headers) + 1);
3282 #ifdef COFF_LONG_SECTION_NAMES
3283 /* Support long section names as found in PE. This code
3284 must coordinate with that in coff_header_append and
3289 len = strlen (segment_info[i].name);
3291 string_byte_count += len + 1;
3293 #endif /* COFF_LONG_SECTION_NAMES */
3296 size = size_section (abfd, (unsigned int) i);
3299 /* I think the section alignment is only used on the i960; the
3300 i960 needs it, and it should do no harm on other targets. */
3301 #ifdef ALIGNMENT_IN_S_FLAGS
3302 segment_info[i].scnhdr.s_flags |= (section_alignment[i] & 0xF) << 8;
3304 segment_info[i].scnhdr.s_align = 1 << section_alignment[i];
3308 H_SET_TEXT_SIZE (&headers, size);
3309 else if (i == SEG_E1)
3310 H_SET_DATA_SIZE (&headers, size);
3311 else if (i == SEG_E2)
3312 H_SET_BSS_SIZE (&headers, size);
3315 /* Turn the gas native symbol table shape into a coff symbol table */
3316 crawl_symbols (&headers, abfd);
3318 if (string_byte_count == 4)
3319 string_byte_count = 0;
3321 H_SET_STRING_SIZE (&headers, string_byte_count);
3327 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3329 fixup_mdeps (segment_info[i].frchainP->frch_root, &headers, i);
3330 fixup_segment (&segment_info[i], i);
3333 /* Look for ".stab" segments and fill in their initial symbols
3335 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3337 name = segment_info[i].name;
3340 && strncmp (".stab", name, 5) == 0
3341 && strncmp (".stabstr", name, 8) != 0)
3342 adjust_stab_section (abfd, i);
3345 file_cursor = H_GET_TEXT_FILE_OFFSET (&headers);
3347 bfd_seek (abfd, (file_ptr) file_cursor, 0);
3349 /* Plant the data */
3351 fill_section (abfd, &headers, &file_cursor);
3353 do_relocs_for (abfd, &headers, &file_cursor);
3355 do_linenos_for (abfd, &headers, &file_cursor);
3357 H_SET_FILE_MAGIC_NUMBER (&headers, COFF_MAGIC);
3358 #ifndef OBJ_COFF_OMIT_TIMESTAMP
3359 H_SET_TIME_STAMP (&headers, (long)time((time_t *)0));
3361 H_SET_TIME_STAMP (&headers, 0);
3363 #ifdef TC_COFF_SET_MACHINE
3364 TC_COFF_SET_MACHINE (&headers);
3368 #define COFF_FLAGS 0
3371 #ifdef KEEP_RELOC_INFO
3372 H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
3373 COFF_FLAGS | coff_flags));
3375 H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
3376 (H_GET_RELOCATION_SIZE(&headers) ? 0 : F_RELFLG) |
3377 COFF_FLAGS | coff_flags));
3381 unsigned int symtable_size = H_GET_SYMBOL_TABLE_SIZE (&headers);
3382 char *buffer1 = xmalloc (symtable_size + string_byte_count + 1);
3384 H_SET_SYMBOL_TABLE_POINTER (&headers, bfd_tell (abfd));
3385 w_symbols (abfd, buffer1, symbol_rootP);
3386 if (string_byte_count > 0)
3387 w_strings (buffer1 + symtable_size);
3388 bfd_write (buffer1, 1, symtable_size + string_byte_count, abfd);
3392 coff_header_append (abfd, &headers);
3394 /* Recent changes to write need this, but where it should
3395 go is up to Ken.. */
3396 if (bfd_close_all_done (abfd) == false)
3397 as_fatal (_("Can't close %s: %s"), out_file_name,
3398 bfd_errmsg (bfd_get_error ()));
3401 extern bfd *stdoutput;
3408 /* Add a new segment. This is called from subseg_new via the
3409 obj_new_segment macro. */
3412 obj_coff_add_segment (name)
3417 #ifndef COFF_LONG_SECTION_NAMES
3418 char buf[SCNNMLEN + 1];
3420 strncpy (buf, name, SCNNMLEN);
3421 buf[SCNNMLEN] = '\0';
3425 for (i = SEG_E0; i < SEG_LAST && segment_info[i].scnhdr.s_name[0]; i++)
3426 if (strcmp (name, segment_info[i].name) == 0)
3431 as_bad (_("Too many new sections; can't add \"%s\""), name);
3435 /* Add a new section. */
3436 strncpy (segment_info[i].scnhdr.s_name, name,
3437 sizeof (segment_info[i].scnhdr.s_name));
3438 segment_info[i].scnhdr.s_flags = STYP_REG;
3439 segment_info[i].name = xstrdup (name);
3445 * implement the .section pseudo op:
3446 * .section name {, "flags"}
3448 * | +--- optional flags: 'b' for bss
3450 * +-- section name 'l' for lib
3454 * 'd' (apparently m88k for data)
3456 * 'r' for read-only data
3457 * But if the argument is not a quoted string, treat it as a
3458 * subsegment number.
3462 obj_coff_section (ignore)
3465 /* Strip out the section name */
3466 char *section_name, *name;
3479 else if (type == 'D')
3481 segment_info[now_seg].scnhdr.s_flags |= flags;
3486 section_name = input_line_pointer;
3487 c = get_symbol_end ();
3489 name = xmalloc (input_line_pointer - section_name + 1);
3490 strcpy (name, section_name);
3492 *input_line_pointer = c;
3498 if (*input_line_pointer == ',')
3500 ++input_line_pointer;
3503 if (*input_line_pointer != '"')
3504 exp = get_absolute_expression ();
3507 ++input_line_pointer;
3508 while (*input_line_pointer != '"'
3509 && ! is_end_of_line[(unsigned char) *input_line_pointer])
3511 switch (*input_line_pointer)
3513 case 'b': flags |= STYP_BSS; break;
3514 case 'i': flags |= STYP_INFO; break;
3515 case 'l': flags |= STYP_LIB; break;
3516 case 'n': flags |= STYP_NOLOAD; break;
3517 case 'o': flags |= STYP_OVER; break;
3519 case 'w': flags |= STYP_DATA; break;
3520 case 'x': flags |= STYP_TEXT; break;
3521 case 'r': flags |= STYP_LIT; break;
3523 as_warn(_("unknown section attribute '%c'"),
3524 *input_line_pointer);
3527 ++input_line_pointer;
3529 if (*input_line_pointer == '"')
3530 ++input_line_pointer;
3534 subseg_new (name, (subsegT) exp);
3536 segment_info[now_seg].scnhdr.s_flags |= flags;
3538 demand_empty_rest_of_line ();
3543 obj_coff_text (ignore)
3546 subseg_new (".text", get_absolute_expression ());
3551 obj_coff_data (ignore)
3554 if (flag_readonly_data_in_text)
3555 subseg_new (".text", get_absolute_expression () + 1000);
3557 subseg_new (".data", get_absolute_expression ());
3561 obj_coff_ident (ignore)
3564 segT current_seg = now_seg; /* save current seg */
3565 subsegT current_subseg = now_subseg;
3566 subseg_new (".comment", 0); /* .comment seg */
3567 stringer (1); /* read string */
3568 subseg_set (current_seg, current_subseg); /* restore current seg */
3572 c_symbol_merge (debug, normal)
3576 S_SET_DATA_TYPE (normal, S_GET_DATA_TYPE (debug));
3577 S_SET_STORAGE_CLASS (normal, S_GET_STORAGE_CLASS (debug));
3579 if (S_GET_NUMBER_AUXILIARY (debug) > S_GET_NUMBER_AUXILIARY (normal))
3581 S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));
3582 } /* take the most we have */
3584 if (S_GET_NUMBER_AUXILIARY (debug) > 0)
3586 memcpy ((char *) &normal->sy_symbol.ost_auxent[0],
3587 (char *) &debug->sy_symbol.ost_auxent[0],
3588 (unsigned int) (S_GET_NUMBER_AUXILIARY (debug) * AUXESZ));
3589 } /* Move all the auxiliary information */
3591 /* Move the debug flags. */
3592 SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
3593 } /* c_symbol_merge() */
3596 c_line_new (symbol, paddr, line_number, frag)
3602 struct lineno_list *new_line =
3603 (struct lineno_list *) xmalloc (sizeof (struct lineno_list));
3605 segment_info_type *s = segment_info + now_seg;
3606 new_line->line.l_lnno = line_number;
3608 if (line_number == 0)
3610 last_line_symbol = symbol;
3611 new_line->line.l_addr.l_symndx = (long) symbol;
3615 new_line->line.l_addr.l_paddr = paddr;
3618 new_line->frag = (char *) frag;
3619 new_line->next = (struct lineno_list *) NULL;
3622 if (s->lineno_list_head == (struct lineno_list *) NULL)
3624 s->lineno_list_head = new_line;
3628 s->lineno_list_tail->next = new_line;
3630 s->lineno_list_tail = new_line;
3631 return LINESZ * s->scnhdr.s_nlnno++;
3635 c_dot_file_symbol (filename)
3640 symbolP = symbol_new (".file",
3643 &zero_address_frag);
3645 S_SET_STORAGE_CLASS (symbolP, C_FILE);
3646 S_SET_NUMBER_AUXILIARY (symbolP, 1);
3648 if (strlen (filename) > FILNMLEN)
3650 /* Filename is too long to fit into an auxent,
3651 we stick it into the string table instead. We keep
3652 a linked list of the filenames we find so we can emit
3654 struct filename_list *f = ((struct filename_list *)
3655 xmalloc (sizeof (struct filename_list)));
3657 f->filename = filename;
3660 SA_SET_FILE_FNAME_ZEROS (symbolP, 0);
3661 SA_SET_FILE_FNAME_OFFSET (symbolP, 1);
3663 if (filename_list_tail)
3664 filename_list_tail->next = f;
3666 filename_list_head = f;
3667 filename_list_tail = f;
3671 SA_SET_FILE_FNAME (symbolP, filename);
3678 listing_source_file (filename);
3684 SF_SET_DEBUG (symbolP);
3685 S_SET_VALUE (symbolP, (valueT) previous_file_symbol);
3687 previous_file_symbol = symbolP;
3689 /* Make sure that the symbol is first on the symbol chain */
3690 if (symbol_rootP != symbolP)
3692 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3693 symbol_insert (symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
3695 } /* c_dot_file_symbol() */
3698 * Build a 'section static' symbol.
3702 c_section_symbol (name, idx)
3708 symbolP = symbol_find_base (name, DO_NOT_STRIP);
3709 if (symbolP == NULL)
3710 symbolP = symbol_new (name, idx, 0, &zero_address_frag);
3713 /* Mmmm. I just love violating interfaces. Makes me feel...dirty. */
3714 S_SET_SEGMENT (symbolP, idx);
3715 symbolP->sy_frag = &zero_address_frag;
3718 S_SET_STORAGE_CLASS (symbolP, C_STAT);
3719 S_SET_NUMBER_AUXILIARY (symbolP, 1);
3721 SF_SET_STATICS (symbolP);
3724 /* manfred@s-direktnet.de: section symbols *must* have the LOCAL bit cleared,
3725 which is set by the new definition of LOCAL_LABEL in tc-m68k.h. */
3726 SF_CLEAR_LOCAL (symbolP);
3729 /* If the .linkonce pseudo-op was used for this section, we must
3730 store the information in the auxiliary entry for the section
3732 if (segment_info[idx].linkonce != LINKONCE_UNSET)
3736 switch (segment_info[idx].linkonce)
3740 case LINKONCE_DISCARD:
3741 type = IMAGE_COMDAT_SELECT_ANY;
3743 case LINKONCE_ONE_ONLY:
3744 type = IMAGE_COMDAT_SELECT_NODUPLICATES;
3746 case LINKONCE_SAME_SIZE:
3747 type = IMAGE_COMDAT_SELECT_SAME_SIZE;
3749 case LINKONCE_SAME_CONTENTS:
3750 type = IMAGE_COMDAT_SELECT_EXACT_MATCH;
3754 SYM_AUXENT (symbolP)->x_scn.x_comdat = type;
3759 } /* c_section_symbol() */
3762 w_symbols (abfd, where, symbol_rootP)
3765 symbolS * symbol_rootP;
3770 /* First fill in those values we have only just worked out */
3771 for (i = SEG_E0; i < SEG_LAST; i++)
3773 symbolP = segment_info[i].dot;
3776 SA_SET_SCN_SCNLEN (symbolP, segment_info[i].scnhdr.s_size);
3777 SA_SET_SCN_NRELOC (symbolP, segment_info[i].scnhdr.s_nreloc);
3778 SA_SET_SCN_NLINNO (symbolP, segment_info[i].scnhdr.s_nlnno);
3783 * Emit all symbols left in the symbol chain.
3785 for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
3787 /* Used to save the offset of the name. It is used to point
3788 to the string in memory but must be a file offset. */
3789 register char *temp;
3791 /* We can't fix the lnnoptr field in yank_symbols with the other
3792 adjustments, because we have to wait until we know where they
3794 if (SF_GET_ADJ_LNNOPTR (symbolP))
3796 SA_GET_SYM_LNNOPTR (symbolP) +=
3797 segment_info[S_GET_SEGMENT (symbolP)].scnhdr.s_lnnoptr;
3800 tc_coff_symbol_emit_hook (symbolP);
3802 temp = S_GET_NAME (symbolP);
3803 if (SF_GET_STRING (symbolP))
3805 S_SET_OFFSET (symbolP, symbolP->sy_name_offset);
3806 S_SET_ZEROES (symbolP, 0);
3810 memset (symbolP->sy_symbol.ost_entry.n_name, 0, SYMNMLEN);
3811 strncpy (symbolP->sy_symbol.ost_entry.n_name, temp, SYMNMLEN);
3813 where = symbol_to_chars (abfd, where, symbolP);
3814 S_SET_NAME (symbolP, temp);
3820 obj_coff_lcomm (ignore)
3833 name = input_line_pointer;
3835 c = get_symbol_end ();
3836 p = input_line_pointer;
3839 if (*input_line_pointer != ',')
3841 as_bad (_("Expected comma after name"));
3842 ignore_rest_of_line ();
3845 if (*input_line_pointer == '\n')
3847 as_bad (_("Missing size expression"));
3850 input_line_pointer++;
3851 if ((temp = get_absolute_expression ()) < 0)
3853 as_warn (_("lcomm length (%d.) <0! Ignored."), temp);
3854 ignore_rest_of_line ();
3859 symbolP = symbol_find_or_make(name);
3861 if (S_GET_SEGMENT(symbolP) == SEG_UNKNOWN &&
3862 S_GET_VALUE(symbolP) == 0)
3867 segT current_seg = now_seg; /* save current seg */
3868 subsegT current_subseg = now_subseg;
3870 subseg_set (SEG_E2, 1);
3871 symbolP->sy_frag = frag_now;
3872 p = frag_var(rs_org, 1, 1, (relax_substateT)0, symbolP,
3873 (offsetT) temp, (char *) 0);
3875 subseg_set (current_seg, current_subseg); /* restore current seg */
3876 S_SET_SEGMENT(symbolP, SEG_E2);
3877 S_SET_STORAGE_CLASS(symbolP, C_STAT);
3881 as_bad(_("Symbol %s already defined"), name);
3883 demand_empty_rest_of_line();
3888 fixup_mdeps (frags, h, this_segment)
3893 subseg_change (this_segment, 0);
3896 switch (frags->fr_type)
3902 HANDLE_ALIGN (frags);
3904 frags->fr_type = rs_fill;
3906 ((frags->fr_next->fr_address - frags->fr_address - frags->fr_fix)
3909 case rs_machine_dependent:
3910 md_convert_frag (h, this_segment, frags);
3916 frags = frags->fr_next;
3922 #ifndef TC_FORCE_RELOCATION
3923 #define TC_FORCE_RELOCATION(fix) 0
3927 fixup_segment (segP, this_segment_type)
3928 segment_info_type * segP;
3929 segT this_segment_type;
3931 register fixS * fixP;
3932 register symbolS *add_symbolP;
3933 register symbolS *sub_symbolP;
3936 register char *place;
3937 register long where;
3938 register char pcrel;
3939 register fragS *fragP;
3940 register segT add_symbol_segment = absolute_section;
3942 for (fixP = segP->fix_root; fixP; fixP = fixP->fx_next)
3944 fragP = fixP->fx_frag;
3946 where = fixP->fx_where;
3947 place = fragP->fr_literal + where;
3948 size = fixP->fx_size;
3949 add_symbolP = fixP->fx_addsy;
3950 sub_symbolP = fixP->fx_subsy;
3951 add_number = fixP->fx_offset;
3952 pcrel = fixP->fx_pcrel;
3954 /* We want function-relative stabs to work on systems which
3955 may use a relaxing linker; thus we must handle the sym1-sym2
3956 fixups function-relative stabs generates.
3958 Of course, if you actually enable relaxing in the linker, the
3959 line and block scoping information is going to be incorrect
3960 in some cases. The only way to really fix this is to support
3961 a reloc involving the difference of two symbols. */
3963 && (!sub_symbolP || pcrel))
3967 if (fixP->fx_tcbit && SF_GET_CALLNAME (add_symbolP))
3969 /* Relocation should be done via the associated 'bal' entry
3972 if (!SF_GET_BALNAME (tc_get_bal_of_call (add_symbolP)))
3974 as_bad_where (fixP->fx_file, fixP->fx_line,
3975 _("No 'bal' entry point for leafproc %s"),
3976 S_GET_NAME (add_symbolP));
3979 fixP->fx_addsy = add_symbolP = tc_get_bal_of_call (add_symbolP);
3983 /* Make sure the symbols have been resolved; this may not have
3984 happened if these are expression symbols. */
3985 if (add_symbolP != NULL && ! add_symbolP->sy_resolved)
3986 resolve_symbol_value (add_symbolP, 1);
3988 if (add_symbolP != NULL)
3990 /* If this fixup is against a symbol which has been equated
3991 to another symbol, convert it to the other symbol. */
3992 if (add_symbolP->sy_value.X_op == O_symbol
3993 && (! S_IS_DEFINED (add_symbolP)
3994 || S_IS_COMMON (add_symbolP)))
3996 while (add_symbolP->sy_value.X_op == O_symbol
3997 && (! S_IS_DEFINED (add_symbolP)
3998 || S_IS_COMMON (add_symbolP)))
4002 /* We must avoid looping, as that can occur with a
4003 badly written program. */
4004 n = add_symbolP->sy_value.X_add_symbol;
4005 if (n == add_symbolP)
4007 add_number += add_symbolP->sy_value.X_add_number;
4010 fixP->fx_addsy = add_symbolP;
4011 fixP->fx_offset = add_number;
4015 if (sub_symbolP != NULL && ! sub_symbolP->sy_resolved)
4016 resolve_symbol_value (sub_symbolP, 1);
4018 if (add_symbolP != NULL
4019 && add_symbolP->sy_mri_common)
4021 know (add_symbolP->sy_value.X_op == O_symbol);
4022 add_number += S_GET_VALUE (add_symbolP);
4023 fixP->fx_offset = add_number;
4024 add_symbolP = fixP->fx_addsy = add_symbolP->sy_value.X_add_symbol;
4029 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
4030 } /* if there is an addend */
4034 if (add_symbolP == NULL || add_symbol_segment == absolute_section)
4036 if (add_symbolP != NULL)
4038 add_number += S_GET_VALUE (add_symbolP);
4040 fixP->fx_addsy = NULL;
4043 /* It's just -sym. */
4044 if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
4046 add_number -= S_GET_VALUE (sub_symbolP);
4053 as_bad_where (fixP->fx_file, fixP->fx_line,
4054 _("Negative of non-absolute symbol %s"),
4055 S_GET_NAME (sub_symbolP));
4057 add_number -= S_GET_VALUE (sub_symbolP);
4058 } /* not absolute */
4060 /* if sub_symbol is in the same segment that add_symbol
4061 and add_symbol is either in DATA, TEXT, BSS or ABSOLUTE */
4063 else if (S_GET_SEGMENT (sub_symbolP) == add_symbol_segment
4064 && SEG_NORMAL (add_symbol_segment))
4066 /* Difference of 2 symbols from same segment. Can't
4067 make difference of 2 undefineds: 'value' means
4068 something different for N_UNDF. */
4070 /* Makes no sense to use the difference of 2 arbitrary symbols
4071 as the target of a call instruction. */
4074 as_bad_where (fixP->fx_file, fixP->fx_line,
4075 _("callj to difference of 2 symbols"));
4077 #endif /* TC_I960 */
4078 add_number += S_GET_VALUE (add_symbolP) -
4079 S_GET_VALUE (sub_symbolP);
4082 if (!TC_FORCE_RELOCATION (fixP))
4084 fixP->fx_addsy = NULL;
4085 fixP->fx_subsy = NULL;
4087 #ifdef TC_M68K /* is this right? */
4095 /* Different segments in subtraction. */
4096 know (!(S_IS_EXTERNAL (sub_symbolP) && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
4098 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
4100 add_number -= S_GET_VALUE (sub_symbolP);
4103 else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
4104 #if 0 /* Okay for 68k, at least... */
4109 /* Make it pc-relative. */
4110 add_number += (md_pcrel_from (fixP)
4111 - S_GET_VALUE (sub_symbolP));
4120 as_bad_where (fixP->fx_file, fixP->fx_line,
4121 _("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %ld."),
4122 segment_name (S_GET_SEGMENT (sub_symbolP)),
4123 S_GET_NAME (sub_symbolP),
4124 (long) (fragP->fr_address + where));
4127 } /* if sub_symbolP */
4131 if (add_symbol_segment == this_segment_type && pcrel)
4134 * This fixup was made when the symbol's segment was
4135 * SEG_UNKNOWN, but it is now in the local segment.
4136 * So we know how to do the address without relocation.
4139 /* reloc_callj() may replace a 'call' with a 'calls' or a 'bal',
4140 * in which cases it modifies *fixP as appropriate. In the case
4141 * of a 'calls', no further work is required, and *fixP has been
4142 * set up to make the rest of the code below a no-op.
4145 #endif /* TC_I960 */
4147 add_number += S_GET_VALUE (add_symbolP);
4148 add_number -= md_pcrel_from (fixP);
4151 add_number -= segP->scnhdr.s_vaddr;
4152 if defined (TC_I386) || defined (TE_LYNX). I now
4153 think that was an error propagated from the case when
4154 we are going to emit the relocation. If we are not
4155 going to emit the relocation, then we just want to
4156 set add_number to the difference between the symbols.
4157 This is a case that would only arise when there is a
4158 PC relative reference from a section other than .text
4159 to a symbol defined in the same section, and the
4160 reference is not relaxed. Since jump instructions on
4161 the i386 are relaxed, this could only arise with a
4162 call instruction. */
4164 pcrel = 0; /* Lie. Don't want further pcrel processing. */
4165 if (!TC_FORCE_RELOCATION (fixP))
4167 fixP->fx_addsy = NULL;
4173 switch (add_symbol_segment)
4175 case absolute_section:
4177 reloc_callj (fixP); /* See comment about reloc_callj() above*/
4178 #endif /* TC_I960 */
4179 add_number += S_GET_VALUE (add_symbolP);
4182 if (!TC_FORCE_RELOCATION (fixP))
4184 fixP->fx_addsy = NULL;
4191 #if defined(TC_A29K) || (defined(TE_PE) && defined(TC_I386)) || defined(TC_M88K)
4192 /* This really should be handled in the linker, but
4193 backward compatibility forbids. */
4194 add_number += S_GET_VALUE (add_symbolP);
4196 add_number += S_GET_VALUE (add_symbolP) +
4197 segment_info[S_GET_SEGMENT (add_symbolP)].scnhdr.s_paddr;
4203 if ((int) fixP->fx_bit_fixP == 13)
4205 /* This is a COBR instruction. They have only a
4206 * 13-bit displacement and are only to be used
4207 * for local branches: flag as error, don't generate
4210 as_bad_where (fixP->fx_file, fixP->fx_line,
4211 _("can't use COBR format with external label"));
4212 fixP->fx_addsy = NULL;
4216 #endif /* TC_I960 */
4217 #if ((defined (TC_I386) || defined (TE_LYNX) || defined (TE_AUX)) && !defined(TE_PE)) || defined (COFF_COMMON_ADDEND)
4218 /* 386 COFF uses a peculiar format in which the
4219 value of a common symbol is stored in the .text
4220 segment (I've checked this on SVR3.2 and SCO
4221 3.2.2) Ian Taylor <ian@cygnus.com>. */
4222 /* This is also true for 68k COFF on sysv machines
4223 (Checked on Motorola sysv68 R3V6 and R3V7.1, and also on
4224 UNIX System V/M68000, Release 1.0 from ATT/Bell Labs)
4225 Philippe De Muyter <phdm@info.ucl.ac.be>. */
4226 if (S_IS_COMMON (add_symbolP))
4227 add_number += S_GET_VALUE (add_symbolP);
4232 } /* switch on symbol seg */
4233 } /* if not in local seg */
4234 } /* if there was a + symbol */
4238 #if !defined(TC_M88K) && !(defined(TE_PE) && defined(TC_I386)) && !defined(TC_A29K)
4239 /* This adjustment is not correct on the m88k, for which the
4240 linker does all the computation. */
4241 add_number -= md_pcrel_from (fixP);
4243 if (add_symbolP == 0)
4245 fixP->fx_addsy = &abs_symbol;
4246 } /* if there's an add_symbol */
4247 #if defined (TC_I386) || defined (TE_LYNX) || defined (TC_I960) || defined (TC_M68K)
4248 /* On the 386 we must adjust by the segment vaddr as well.
4251 I changed the i960 to work this way as well. This is
4252 compatible with the current GNU linker behaviour. I do
4253 not know what other i960 COFF assemblers do. This is not
4254 a common case: normally, only assembler code will contain
4255 a PC relative reloc, and only branches which do not
4256 originate in the .text section will have a non-zero
4259 I changed the m68k to work this way as well. This will
4260 break existing PC relative relocs from sections which do
4261 not start at address 0, but it will make ld -r work.
4262 Ian Taylor, 4 Oct 96. */
4264 add_number -= segP->scnhdr.s_vaddr;
4268 #ifdef MD_APPLY_FIX3
4269 md_apply_fix3 (fixP, (valueT *) &add_number, this_segment_type);
4271 md_apply_fix (fixP, add_number);
4274 if (!fixP->fx_bit_fixP && ! fixP->fx_no_overflow)
4277 /* The m88k uses the offset field of the reloc to get around
4280 && ((add_number & ~0xFF)
4281 || (fixP->fx_signed && (add_number & 0x80)))
4282 && ((add_number & ~0xFF) != (-1 & ~0xFF)
4283 || (add_number & 0x80) == 0))
4285 && ((add_number & ~0xFFFF)
4286 || (fixP->fx_signed && (add_number & 0x8000)))
4287 && ((add_number & ~0xFFFF) != (-1 & ~0xFFFF)
4288 || (add_number & 0x8000) == 0)))
4290 as_bad_where (fixP->fx_file, fixP->fx_line,
4291 _("Value of %ld too large for field of %d bytes at 0x%lx"),
4292 (long) add_number, size,
4293 (unsigned long) (fragP->fr_address + where));
4296 #ifdef WARN_SIGNED_OVERFLOW_WORD
4297 /* Warn if a .word value is too large when treated as a
4298 signed number. We already know it is not too negative.
4299 This is to catch over-large switches generated by gcc on
4301 if (!flag_signed_overflow_ok
4303 && add_number > 0x7fff)
4304 as_bad_where (fixP->fx_file, fixP->fx_line,
4305 _("Signed .word overflow; switch may be too large; %ld at 0x%lx"),
4307 (unsigned long) (fragP->fr_address + where));
4309 } /* not a bit fix */
4310 } /* For each fixS in this segment. */
4311 } /* fixup_segment() */
4315 /* The first entry in a .stab section is special. */
4318 obj_coff_init_stab_section (seg)
4324 unsigned int stroff;
4326 /* Make space for this first symbol. */
4330 as_where (&file, (unsigned int *) NULL);
4331 stabstr_name = (char *) alloca (strlen (segment_info[seg].name) + 4);
4332 strcpy (stabstr_name, segment_info[seg].name);
4333 strcat (stabstr_name, "str");
4334 stroff = get_stab_string_offset (file, stabstr_name);
4336 md_number_to_chars (p, stroff, 4);
4339 /* Fill in the counts in the first entry in a .stab section. */
4342 adjust_stab_section(abfd, seg)
4346 segT stabstrseg = SEG_UNKNOWN;
4347 const char *secname, *name2;
4350 int i, strsz = 0, nsyms;
4351 fragS *frag = segment_info[seg].frchainP->frch_root;
4353 /* Look for the associated string table section. */
4355 secname = segment_info[seg].name;
4356 name = (char *) alloca (strlen (secname) + 4);
4357 strcpy (name, secname);
4358 strcat (name, "str");
4360 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
4362 name2 = segment_info[i].name;
4363 if (name2 != NULL && strncmp(name2, name, 8) == 0)
4370 /* If we found the section, get its size. */
4371 if (stabstrseg != SEG_UNKNOWN)
4372 strsz = size_section (abfd, stabstrseg);
4374 nsyms = size_section (abfd, seg) / 12 - 1;
4376 /* Look for the first frag of sufficient size for the initial stab
4377 symbol, and collect a pointer to it. */
4378 while (frag && frag->fr_fix < 12)
4379 frag = frag->fr_next;
4381 p = frag->fr_literal;
4384 /* Write in the number of stab symbols and the size of the string
4386 bfd_h_put_16 (abfd, (bfd_vma) nsyms, (bfd_byte *) p + 6);
4387 bfd_h_put_32 (abfd, (bfd_vma) strsz, (bfd_byte *) p + 8);
4390 #endif /* not BFD_ASSEMBLER */
4392 const pseudo_typeS obj_pseudo_table[] =
4394 {"def", obj_coff_def, 0},
4395 {"dim", obj_coff_dim, 0},
4396 {"endef", obj_coff_endef, 0},
4397 {"line", obj_coff_line, 0},
4398 {"ln", obj_coff_ln, 0},
4399 {"appline", obj_coff_ln, 1},
4400 {"scl", obj_coff_scl, 0},
4401 {"size", obj_coff_size, 0},
4402 {"tag", obj_coff_tag, 0},
4403 {"type", obj_coff_type, 0},
4404 {"val", obj_coff_val, 0},
4405 {"section", obj_coff_section, 0},
4406 {"sect", obj_coff_section, 0},
4407 /* FIXME: We ignore the MRI short attribute. */
4408 {"section.s", obj_coff_section, 0},
4409 {"sect.s", obj_coff_section, 0},
4410 /* We accept the .bss directive for backward compatibility with
4411 earlier versions of gas. */
4412 {"bss", obj_coff_bss, 0},
4413 {"weak", obj_coff_weak, 0},
4414 #ifndef BFD_ASSEMBLER
4415 {"use", obj_coff_section, 0},
4416 {"text", obj_coff_text, 0},
4417 {"data", obj_coff_data, 0},
4418 {"lcomm", obj_coff_lcomm, 0},
4419 {"ident", obj_coff_ident, 0},
4421 {"optim", s_ignore, 0}, /* For sun386i cc (?) */
4422 {"ident", s_ignore, 0}, /* we don't yet handle this. */
4424 {"version", s_ignore, 0},
4425 {"ABORT", s_abort, 0},
4427 /* The m88k uses sdef instead of def. */
4428 {"sdef", obj_coff_def, 0},
4430 {NULL} /* end sentinel */
4431 }; /* obj_pseudo_table */
4433 #ifdef BFD_ASSEMBLER
4435 /* Support for a COFF emulation. */
4440 pop_insert (obj_pseudo_table);
4444 coff_sec_sym_ok_for_reloc (sec)
4456 const struct format_ops coff_format_ops =
4458 bfd_target_coff_flavour,
4463 coff_frob_file_after_relocs,
4468 obj_generate_asm_lineno,
4477 coff_sec_sym_ok_for_reloc,
4484 coff_obj_read_begin_hook,
4485 coff_obj_symbol_new_hook,