1 /* coff object file format
2 Copyright (C) 1989, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000
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 /* The BFD_ASSEMBLER version of obj_coff_section will use this macro to set
34 a new section's attributes when a directive has no valid flags or the
35 "w" flag is used. This default should be appropriate for most. */
36 #ifndef TC_COFF_SECTION_DEFAULT_ATTRIBUTES
37 #define TC_COFF_SECTION_DEFAULT_ATTRIBUTES (SEC_LOAD | SEC_DATA)
40 static void obj_coff_bss PARAMS ((int));
41 const char *s_get_name PARAMS ((symbolS * s));
42 static void obj_coff_ln PARAMS ((int));
43 static void obj_coff_def PARAMS ((int));
44 static void obj_coff_endef PARAMS ((int));
45 static void obj_coff_dim PARAMS ((int));
46 static void obj_coff_line PARAMS ((int));
47 static void obj_coff_size PARAMS ((int));
48 static void obj_coff_scl PARAMS ((int));
49 static void obj_coff_tag PARAMS ((int));
50 static void obj_coff_val PARAMS ((int));
51 static void obj_coff_type PARAMS ((int));
52 static void obj_coff_ident PARAMS ((int));
54 static void obj_coff_loc PARAMS((int));
57 /* This is used to hold the symbol built by a sequence of pseudo-ops
58 from .def and .endef. */
59 static symbolS *def_symbol_in_progress;
64 unsigned long chunk_size;
65 unsigned long element_size;
68 unsigned long pointer;
73 stack_init (chunk_size, element_size)
74 unsigned long chunk_size;
75 unsigned long element_size;
79 st = (stack *) malloc (sizeof (stack));
82 st->data = malloc (chunk_size);
89 st->size = chunk_size;
90 st->chunk_size = chunk_size;
91 st->element_size = element_size;
96 /* Not currently used. */
107 stack_push (st, element)
111 if (st->pointer + st->element_size >= st->size)
113 st->size += st->chunk_size;
114 if ((st->data = xrealloc (st->data, st->size)) == (char *) 0)
117 memcpy (st->data + st->pointer, element, st->element_size);
118 st->pointer += st->element_size;
119 return st->data + st->pointer;
126 if (st->pointer < st->element_size)
131 st->pointer -= st->element_size;
132 return st->data + st->pointer;
136 * Maintain a list of the tagnames of the structres.
139 static struct hash_control *tag_hash;
144 tag_hash = hash_new ();
148 tag_insert (name, symbolP)
152 const char *error_string;
154 if ((error_string = hash_jam (tag_hash, name, (char *) symbolP)))
156 as_fatal (_("Inserting \"%s\" into structure table failed: %s"),
165 #ifdef STRIP_UNDERSCORE
168 #endif /* STRIP_UNDERSCORE */
169 return (symbolS *) hash_find (tag_hash, name);
173 tag_find_or_make (name)
178 if ((symbolP = tag_find (name)) == NULL)
180 symbolP = symbol_new (name, undefined_section,
181 0, &zero_address_frag);
183 tag_insert (S_GET_NAME (symbolP), symbolP);
185 symbol_table_insert (symbolP);
192 /* We accept the .bss directive to set the section for backward
193 compatibility with earlier versions of gas. */
196 obj_coff_bss (ignore)
197 int ignore ATTRIBUTE_UNUSED;
199 if (*input_line_pointer == '\n')
200 subseg_new (".bss", get_absolute_expression ());
205 /* Handle .weak. This is a GNU extension. */
208 obj_coff_weak (ignore)
209 int ignore ATTRIBUTE_UNUSED;
217 name = input_line_pointer;
218 c = get_symbol_end ();
219 symbolP = symbol_find_or_make (name);
220 *input_line_pointer = c;
224 S_SET_WEAK (symbolP);
228 S_SET_STORAGE_CLASS (symbolP, C_NT_WEAK);
230 S_SET_STORAGE_CLASS (symbolP, C_WEAKEXT);
235 input_line_pointer++;
237 if (*input_line_pointer == '\n')
243 demand_empty_rest_of_line ();
248 static void SA_SET_SYM_TAGNDX PARAMS ((symbolS *, symbolS *));
250 #define GET_FILENAME_STRING(X) \
251 ((char*)(&((X)->sy_symbol.ost_auxent->x_file.x_n.x_offset))[1])
255 fetch_coff_debug_section ()
257 static segT debug_section;
261 s = bfd_make_debug_symbol (stdoutput, (char *) 0, 0);
263 debug_section = s->section;
265 return debug_section;
269 SA_SET_SYM_ENDNDX (sym, val)
273 combined_entry_type *entry, *p;
275 entry = &coffsymbol (symbol_get_bfdsym (sym))->native[1];
276 p = coffsymbol (symbol_get_bfdsym (val))->native;
277 entry->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p = p;
282 SA_SET_SYM_TAGNDX (sym, val)
286 combined_entry_type *entry, *p;
288 entry = &coffsymbol (symbol_get_bfdsym (sym))->native[1];
289 p = coffsymbol (symbol_get_bfdsym (val))->native;
290 entry->u.auxent.x_sym.x_tagndx.p = p;
295 S_GET_DATA_TYPE (sym)
298 return coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_type;
302 S_SET_DATA_TYPE (sym, val)
306 coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_type = val;
311 S_GET_STORAGE_CLASS (sym)
314 return coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_sclass;
318 S_SET_STORAGE_CLASS (sym, val)
322 coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_sclass = val;
326 /* Merge a debug symbol containing debug information into a normal symbol. */
329 c_symbol_merge (debug, normal)
333 S_SET_DATA_TYPE (normal, S_GET_DATA_TYPE (debug));
334 S_SET_STORAGE_CLASS (normal, S_GET_STORAGE_CLASS (debug));
336 if (S_GET_NUMBER_AUXILIARY (debug) > S_GET_NUMBER_AUXILIARY (normal))
338 /* take the most we have */
339 S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));
342 if (S_GET_NUMBER_AUXILIARY (debug) > 0)
344 /* Move all the auxiliary information. */
345 memcpy (SYM_AUXINFO (normal), SYM_AUXINFO (debug),
346 (S_GET_NUMBER_AUXILIARY (debug)
347 * sizeof (*SYM_AUXINFO (debug))));
350 /* Move the debug flags. */
351 SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
355 c_dot_file_symbol (filename)
356 const char *filename;
360 /* BFD converts filename to a .file symbol with an aux entry. It
361 also handles chaining. */
362 symbolP = symbol_new (filename, bfd_abs_section_ptr, 0, &zero_address_frag);
364 S_SET_STORAGE_CLASS (symbolP, C_FILE);
365 S_SET_NUMBER_AUXILIARY (symbolP, 1);
367 symbol_get_bfdsym (symbolP)->flags = BSF_DEBUGGING;
374 listing_source_file (filename);
379 /* Make sure that the symbol is first on the symbol chain */
380 if (symbol_rootP != symbolP)
382 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
383 symbol_insert (symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
384 } /* if not first on the list */
387 /* Line number handling */
390 struct line_no *next;
397 /* Symbol of last function, which we should hang line#s off of. */
398 static symbolS *line_fsym;
400 #define in_function() (line_fsym != 0)
401 #define clear_function() (line_fsym = 0)
402 #define set_function(F) (line_fsym = (F), coff_add_linesym (F))
406 coff_obj_symbol_new_hook (symbolP)
409 long sz = (OBJ_COFF_MAX_AUXENTRIES + 1) * sizeof (combined_entry_type);
410 char * s = (char *) xmalloc (sz);
413 coffsymbol (symbol_get_bfdsym (symbolP))->native = (combined_entry_type *) s;
415 S_SET_DATA_TYPE (symbolP, T_NULL);
416 S_SET_STORAGE_CLASS (symbolP, 0);
417 S_SET_NUMBER_AUXILIARY (symbolP, 0);
419 if (S_IS_STRING (symbolP))
420 SF_SET_STRING (symbolP);
422 if (S_IS_LOCAL (symbolP))
423 SF_SET_LOCAL (symbolP);
428 * Handle .ln directives.
431 static symbolS *current_lineno_sym;
432 static struct line_no *line_nos;
433 /* @@ Blindly assume all .ln directives will be in the .text section... */
437 add_lineno (frag, offset, num)
442 struct line_no *new_line =
443 (struct line_no *) xmalloc (sizeof (struct line_no));
444 if (!current_lineno_sym)
450 /* Zero is used as an end marker in the file. */
451 as_warn (_("Line numbers must be positive integers\n"));
454 new_line->next = line_nos;
455 new_line->frag = frag;
456 new_line->l.line_number = num;
457 new_line->l.u.offset = offset;
463 coff_add_linesym (sym)
468 coffsymbol (symbol_get_bfdsym (current_lineno_sym))->lineno =
473 current_lineno_sym = sym;
477 obj_coff_ln (appline)
482 if (! appline && def_symbol_in_progress != NULL)
484 as_warn (_(".ln pseudo-op inside .def/.endef: ignored."));
485 demand_empty_rest_of_line ();
489 l = get_absolute_expression ();
492 add_lineno (frag_now, frag_now_fix (), l);
496 new_logical_line ((char *) NULL, l - 1);
505 l += coff_line_base - 1;
506 listing_source_line (l);
511 demand_empty_rest_of_line ();
514 /* .loc is essentially the same as .ln; parse it for assembler
518 obj_coff_loc (ignore)
519 int ignore ATTRIBUTE_UNUSED;
523 /* FIXME: Why do we need this check? We need it for ECOFF, but why
524 do we need it for COFF? */
525 if (now_seg != text_section)
527 as_warn (_(".loc outside of .text"));
528 demand_empty_rest_of_line ();
532 if (def_symbol_in_progress != NULL)
534 as_warn (_(".loc pseudo-op inside .def/.endef: ignored."));
535 demand_empty_rest_of_line ();
539 /* Skip the file number. */
541 get_absolute_expression ();
544 lineno = get_absolute_expression ();
552 lineno += coff_line_base - 1;
553 listing_source_line (lineno);
558 demand_empty_rest_of_line ();
560 add_lineno (frag_now, frag_now_fix (), lineno);
563 /* Handle the .ident pseudo-op. */
566 obj_coff_ident (ignore)
567 int ignore ATTRIBUTE_UNUSED;
569 segT current_seg = now_seg;
570 subsegT current_subseg = now_subseg;
576 /* We could put it in .comment, but that creates an extra section
577 that shouldn't be loaded into memory, which requires linker
578 changes... For now, until proven otherwise, use .rdata. */
579 sec = subseg_new (".rdata$zzz", 0);
580 bfd_set_section_flags (stdoutput, sec,
581 ((SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA)
582 & bfd_applicable_section_flags (stdoutput)));
585 subseg_new (".comment", 0);
589 subseg_set (current_seg, current_subseg);
595 * Handle .def directives.
597 * One might ask : why can't we symbol_new if the symbol does not
598 * already exist and fill it with debug information. Because of
599 * the C_EFCN special symbol. It would clobber the value of the
600 * function symbol before we have a chance to notice that it is
601 * a C_EFCN. And a second reason is that the code is more clear this
602 * way. (at least I think it is :-).
606 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
607 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
608 *input_line_pointer == '\t') \
609 input_line_pointer++;
613 int what ATTRIBUTE_UNUSED;
615 char name_end; /* Char after the end of name */
616 char *symbol_name; /* Name of the debug symbol */
617 char *symbol_name_copy; /* Temporary copy of the name */
618 unsigned int symbol_name_length;
620 if (def_symbol_in_progress != NULL)
622 as_warn (_(".def pseudo-op used inside of .def/.endef: ignored."));
623 demand_empty_rest_of_line ();
625 } /* if not inside .def/.endef */
629 symbol_name = input_line_pointer;
630 #ifdef STRIP_UNDERSCORE
631 if (symbol_name[0] == '_' && symbol_name[1] != 0)
633 #endif /* STRIP_UNDERSCORE */
635 name_end = get_symbol_end ();
636 symbol_name_length = strlen (symbol_name);
637 symbol_name_copy = xmalloc (symbol_name_length + 1);
638 strcpy (symbol_name_copy, symbol_name);
639 #ifdef tc_canonicalize_symbol_name
640 symbol_name_copy = tc_canonicalize_symbol_name (symbol_name_copy);
643 /* Initialize the new symbol */
644 def_symbol_in_progress = symbol_make (symbol_name_copy);
645 symbol_set_frag (def_symbol_in_progress, &zero_address_frag);
646 S_SET_VALUE (def_symbol_in_progress, 0);
648 if (S_IS_STRING (def_symbol_in_progress))
649 SF_SET_STRING (def_symbol_in_progress);
651 *input_line_pointer = name_end;
653 demand_empty_rest_of_line ();
656 unsigned int dim_index;
659 obj_coff_endef (ignore)
660 int ignore ATTRIBUTE_UNUSED;
662 symbolS *symbolP = NULL;
664 /* DIM BUG FIX sac@cygnus.com */
666 if (def_symbol_in_progress == NULL)
668 as_warn (_(".endef pseudo-op used outside of .def/.endef: ignored."));
669 demand_empty_rest_of_line ();
671 } /* if not inside .def/.endef */
673 /* Set the section number according to storage class. */
674 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))
679 SF_SET_TAG (def_symbol_in_progress);
680 /* intentional fallthrough */
683 SF_SET_DEBUG (def_symbol_in_progress);
684 S_SET_SEGMENT (def_symbol_in_progress, fetch_coff_debug_section ());
688 SF_SET_LOCAL (def_symbol_in_progress); /* Do not emit this symbol. */
689 /* intentional fallthrough */
691 SF_SET_PROCESS (def_symbol_in_progress); /* Will need processing before writing */
692 /* intentional fallthrough */
696 S_SET_SEGMENT (def_symbol_in_progress, text_section);
698 name = S_GET_NAME (def_symbol_in_progress);
699 if (name[0] == '.' && name[2] == 'f' && name[3] == '\0')
705 if (! in_function ())
706 as_warn (_("`%s' symbol without preceding function"), name);
707 /* Will need relocating. */
708 SF_SET_PROCESS (def_symbol_in_progress);
714 /* The MS compilers output the actual endline, not the
715 function-relative one... we want to match without
716 changing the assembler input. */
717 SA_SET_SYM_LNNO (def_symbol_in_progress,
718 (SA_GET_SYM_LNNO (def_symbol_in_progress)
729 #endif /* C_AUTOARG */
736 /* According to the COFF documentation:
738 http://osr5doc.sco.com:1996/topics/COFF_SectNumFld.html
740 A special section number (-2) marks symbolic debugging symbols,
741 including structure/union/enumeration tag names, typedefs, and
742 the name of the file. A section number of -1 indicates that the
743 symbol has a value but is not relocatable. Examples of
744 absolute-valued symbols include automatic and register variables,
745 function arguments, and .eos symbols.
747 But from Ian Lance Taylor:
749 http://sources.redhat.com/ml/binutils/2000-08/msg00202.html
751 the actual tools all marked them as section -1. So the GNU COFF
752 assembler follows historical COFF assemblers.
754 However, it causes problems for djgpp
756 http://sources.redhat.com/ml/binutils/2000-08/msg00210.html
758 By defining STRICTCOFF, a COFF port can make the assembler to
759 follow the documented behavior. */
766 SF_SET_DEBUG (def_symbol_in_progress);
767 S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
775 S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
786 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
793 as_warn (_("unexpected storage class %d"),
794 S_GET_STORAGE_CLASS (def_symbol_in_progress));
796 } /* switch on storage class */
798 /* Now that we have built a debug symbol, try to find if we should
799 merge with an existing symbol or not. If a symbol is C_EFCN or
800 absolute_section or untagged SEG_DEBUG it never merges. We also
801 don't merge labels, which are in a different namespace, nor
802 symbols which have not yet been defined since they are typically
803 unique, nor do we merge tags with non-tags. */
805 /* Two cases for functions. Either debug followed by definition or
806 definition followed by debug. For definition first, we will
807 merge the debug symbol into the definition. For debug first, the
808 lineno entry MUST point to the definition function or else it
809 will point off into space when obj_crawl_symbol_chain() merges
810 the debug symbol into the real symbol. Therefor, let's presume
811 the debug symbol is a real function reference. */
813 /* FIXME-SOON If for some reason the definition label/symbol is
814 never seen, this will probably leave an undefined symbol at link
817 if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN
818 || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_LABEL
819 || (!strcmp (bfd_get_section_name (stdoutput,
820 S_GET_SEGMENT (def_symbol_in_progress)),
822 && !SF_GET_TAG (def_symbol_in_progress))
823 || S_GET_SEGMENT (def_symbol_in_progress) == absolute_section
824 || ! symbol_constant_p (def_symbol_in_progress)
825 || (symbolP = symbol_find_base (S_GET_NAME (def_symbol_in_progress),
826 DO_NOT_STRIP)) == NULL
827 || SF_GET_TAG (def_symbol_in_progress) != SF_GET_TAG (symbolP))
829 /* If it already is at the end of the symbol list, do nothing */
830 if (def_symbol_in_progress != symbol_lastP)
832 symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
833 symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP,
839 /* This symbol already exists, merge the newly created symbol
840 into the old one. This is not mandatory. The linker can
841 handle duplicate symbols correctly. But I guess that it save
842 a *lot* of space if the assembly file defines a lot of
845 /* The debug entry (def_symbol_in_progress) is merged into the
846 previous definition. */
848 c_symbol_merge (def_symbol_in_progress, symbolP);
849 symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
851 def_symbol_in_progress = symbolP;
853 if (SF_GET_FUNCTION (def_symbol_in_progress)
854 || SF_GET_TAG (def_symbol_in_progress)
855 || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_STAT)
857 /* For functions, and tags, and static symbols, the symbol
858 *must* be where the debug symbol appears. Move the
859 existing symbol to the current place. */
860 /* If it already is at the end of the symbol list, do nothing */
861 if (def_symbol_in_progress != symbol_lastP)
863 symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
864 symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP, &symbol_lastP);
869 if (SF_GET_TAG (def_symbol_in_progress))
873 oldtag = symbol_find_base (S_GET_NAME (def_symbol_in_progress),
875 if (oldtag == NULL || ! SF_GET_TAG (oldtag))
876 tag_insert (S_GET_NAME (def_symbol_in_progress),
877 def_symbol_in_progress);
880 if (SF_GET_FUNCTION (def_symbol_in_progress))
882 know (sizeof (def_symbol_in_progress) <= sizeof (long));
883 set_function (def_symbol_in_progress);
884 SF_SET_PROCESS (def_symbol_in_progress);
888 /* That is, if this is the first time we've seen the
890 symbol_table_insert (def_symbol_in_progress);
891 } /* definition follows debug */
892 } /* Create the line number entry pointing to the function being defined */
894 def_symbol_in_progress = NULL;
895 demand_empty_rest_of_line ();
899 obj_coff_dim (ignore)
900 int ignore ATTRIBUTE_UNUSED;
904 if (def_symbol_in_progress == NULL)
906 as_warn (_(".dim pseudo-op used outside of .def/.endef: ignored."));
907 demand_empty_rest_of_line ();
909 } /* if not inside .def/.endef */
911 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
913 for (dim_index = 0; dim_index < DIMNUM; dim_index++)
916 SA_SET_SYM_DIMEN (def_symbol_in_progress, dim_index,
917 get_absolute_expression ());
919 switch (*input_line_pointer)
922 input_line_pointer++;
926 as_warn (_("badly formed .dim directive ignored"));
927 /* intentional fallthrough */
935 demand_empty_rest_of_line ();
939 obj_coff_line (ignore)
940 int ignore ATTRIBUTE_UNUSED;
944 if (def_symbol_in_progress == NULL)
946 /* Probably stabs-style line? */
951 this_base = get_absolute_expression ();
952 if (!strcmp (".bf", S_GET_NAME (def_symbol_in_progress)))
953 coff_line_base = this_base;
955 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
956 SA_SET_SYM_LNNO (def_symbol_in_progress, this_base);
958 demand_empty_rest_of_line ();
961 if (strcmp (".bf", S_GET_NAME (def_symbol_in_progress)) == 0)
966 listing_source_line ((unsigned int) this_base);
972 obj_coff_size (ignore)
973 int ignore ATTRIBUTE_UNUSED;
975 if (def_symbol_in_progress == NULL)
977 as_warn (_(".size pseudo-op used outside of .def/.endef ignored."));
978 demand_empty_rest_of_line ();
980 } /* if not inside .def/.endef */
982 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
983 SA_SET_SYM_SIZE (def_symbol_in_progress, get_absolute_expression ());
984 demand_empty_rest_of_line ();
988 obj_coff_scl (ignore)
989 int ignore ATTRIBUTE_UNUSED;
991 if (def_symbol_in_progress == NULL)
993 as_warn (_(".scl pseudo-op used outside of .def/.endef ignored."));
994 demand_empty_rest_of_line ();
996 } /* if not inside .def/.endef */
998 S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ());
999 demand_empty_rest_of_line ();
1003 obj_coff_tag (ignore)
1004 int ignore ATTRIBUTE_UNUSED;
1009 if (def_symbol_in_progress == NULL)
1011 as_warn (_(".tag pseudo-op used outside of .def/.endef ignored."));
1012 demand_empty_rest_of_line ();
1016 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
1017 symbol_name = input_line_pointer;
1018 name_end = get_symbol_end ();
1020 #ifdef tc_canonicalize_symbol_name
1021 symbol_name = tc_canonicalize_symbol_name (symbol_name);
1024 /* Assume that the symbol referred to by .tag is always defined.
1025 This was a bad assumption. I've added find_or_make. xoxorich. */
1026 SA_SET_SYM_TAGNDX (def_symbol_in_progress,
1027 tag_find_or_make (symbol_name));
1028 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L)
1030 as_warn (_("tag not found for .tag %s"), symbol_name);
1033 SF_SET_TAGGED (def_symbol_in_progress);
1034 *input_line_pointer = name_end;
1036 demand_empty_rest_of_line ();
1040 obj_coff_type (ignore)
1041 int ignore ATTRIBUTE_UNUSED;
1043 if (def_symbol_in_progress == NULL)
1045 as_warn (_(".type pseudo-op used outside of .def/.endef ignored."));
1046 demand_empty_rest_of_line ();
1048 } /* if not inside .def/.endef */
1050 S_SET_DATA_TYPE (def_symbol_in_progress, get_absolute_expression ());
1052 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress)) &&
1053 S_GET_STORAGE_CLASS (def_symbol_in_progress) != C_TPDEF)
1055 SF_SET_FUNCTION (def_symbol_in_progress);
1056 } /* is a function */
1058 demand_empty_rest_of_line ();
1062 obj_coff_val (ignore)
1063 int ignore ATTRIBUTE_UNUSED;
1065 if (def_symbol_in_progress == NULL)
1067 as_warn (_(".val pseudo-op used outside of .def/.endef ignored."));
1068 demand_empty_rest_of_line ();
1070 } /* if not inside .def/.endef */
1072 if (is_name_beginner (*input_line_pointer))
1074 char *symbol_name = input_line_pointer;
1075 char name_end = get_symbol_end ();
1077 #ifdef tc_canonicalize_symbol_name
1078 symbol_name = tc_canonicalize_symbol_name (symbol_name);
1080 if (!strcmp (symbol_name, "."))
1082 symbol_set_frag (def_symbol_in_progress, frag_now);
1083 S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
1084 /* If the .val is != from the .def (e.g. statics) */
1086 else if (strcmp (S_GET_NAME (def_symbol_in_progress), symbol_name))
1090 exp.X_op = O_symbol;
1091 exp.X_add_symbol = symbol_find_or_make (symbol_name);
1092 exp.X_op_symbol = NULL;
1093 exp.X_add_number = 0;
1094 symbol_set_value_expression (def_symbol_in_progress, &exp);
1096 /* If the segment is undefined when the forward reference is
1097 resolved, then copy the segment id from the forward
1099 SF_SET_GET_SEGMENT (def_symbol_in_progress);
1101 /* FIXME: gcc can generate address expressions here in
1102 unusual cases (search for "obscure" in sdbout.c). We
1103 just ignore the offset here, thus generating incorrect
1104 debugging information. We ignore the rest of the line
1107 /* Otherwise, it is the name of a non debug symbol and its value
1108 will be calculated later. */
1109 *input_line_pointer = name_end;
1113 S_SET_VALUE (def_symbol_in_progress, get_absolute_expression ());
1114 } /* if symbol based */
1116 demand_empty_rest_of_line ();
1120 coff_obj_read_begin_hook ()
1122 /* These had better be the same. Usually 18 bytes. */
1124 know (sizeof (SYMENT) == sizeof (AUXENT));
1125 know (SYMESZ == AUXESZ);
1130 symbolS *coff_last_function;
1131 static symbolS *coff_last_bf;
1134 coff_frob_symbol (symp, punt)
1138 static symbolS *last_tagP;
1139 static stack *block_stack;
1140 static symbolS *set_end;
1141 symbolS *next_set_end = NULL;
1143 if (symp == &abs_symbol)
1149 if (current_lineno_sym)
1150 coff_add_linesym ((symbolS *) 0);
1153 block_stack = stack_init (512, sizeof (symbolS*));
1155 if (S_IS_WEAK (symp))
1158 S_SET_STORAGE_CLASS (symp, C_NT_WEAK);
1160 S_SET_STORAGE_CLASS (symp, C_WEAKEXT);
1164 if (!S_IS_DEFINED (symp)
1165 && !S_IS_WEAK (symp)
1166 && S_GET_STORAGE_CLASS (symp) != C_STAT)
1167 S_SET_STORAGE_CLASS (symp, C_EXT);
1169 if (!SF_GET_DEBUG (symp))
1172 if (!SF_GET_LOCAL (symp)
1173 && !SF_GET_STATICS (symp)
1174 && S_GET_STORAGE_CLASS (symp) != C_LABEL
1175 && symbol_constant_p(symp)
1176 && (real = symbol_find_base (S_GET_NAME (symp), DO_NOT_STRIP))
1179 c_symbol_merge (symp, real);
1183 if (!S_IS_DEFINED (symp) && !SF_GET_LOCAL (symp))
1185 assert (S_GET_VALUE (symp) == 0);
1186 S_SET_EXTERNAL (symp);
1188 else if (S_GET_STORAGE_CLASS (symp) == C_NULL)
1190 if (S_GET_SEGMENT (symp) == text_section
1191 && symp != seg_info (text_section)->sym)
1192 S_SET_STORAGE_CLASS (symp, C_LABEL);
1194 S_SET_STORAGE_CLASS (symp, C_STAT);
1196 if (SF_GET_PROCESS (symp))
1198 if (S_GET_STORAGE_CLASS (symp) == C_BLOCK)
1200 if (!strcmp (S_GET_NAME (symp), ".bb"))
1201 stack_push (block_stack, (char *) &symp);
1205 begin = *(symbolS **) stack_pop (block_stack);
1207 as_warn (_("mismatched .eb"));
1209 next_set_end = begin;
1212 if (coff_last_function == 0 && SF_GET_FUNCTION (symp))
1214 union internal_auxent *auxp;
1215 coff_last_function = symp;
1216 if (S_GET_NUMBER_AUXILIARY (symp) < 1)
1217 S_SET_NUMBER_AUXILIARY (symp, 1);
1218 auxp = SYM_AUXENT (symp);
1219 memset (auxp->x_sym.x_fcnary.x_ary.x_dimen, 0,
1220 sizeof (auxp->x_sym.x_fcnary.x_ary.x_dimen));
1222 if (S_GET_STORAGE_CLASS (symp) == C_EFCN)
1224 if (coff_last_function == 0)
1225 as_fatal (_("C_EFCN symbol out of scope"));
1226 SA_SET_SYM_FSIZE (coff_last_function,
1227 (long) (S_GET_VALUE (symp)
1228 - S_GET_VALUE (coff_last_function)));
1229 next_set_end = coff_last_function;
1230 coff_last_function = 0;
1233 if (S_IS_EXTERNAL (symp))
1234 S_SET_STORAGE_CLASS (symp, C_EXT);
1235 else if (SF_GET_LOCAL (symp))
1238 if (SF_GET_FUNCTION (symp))
1239 symbol_get_bfdsym (symp)->flags |= BSF_FUNCTION;
1244 /* Double check weak symbols. */
1245 if (S_IS_WEAK (symp) && S_IS_COMMON (symp))
1246 as_bad (_("Symbol `%s' can not be both weak and common"),
1249 if (SF_GET_TAG (symp))
1251 else if (S_GET_STORAGE_CLASS (symp) == C_EOS)
1252 next_set_end = last_tagP;
1255 /* This is pretty horrible, but we have to set *punt correctly in
1256 order to call SA_SET_SYM_ENDNDX correctly. */
1257 if (! symbol_used_in_reloc_p (symp)
1258 && ((symbol_get_bfdsym (symp)->flags & BSF_SECTION_SYM) != 0
1259 || (! S_IS_EXTERNAL (symp)
1260 && ! symbol_get_tc (symp)->output
1261 && S_GET_STORAGE_CLASS (symp) != C_FILE)))
1265 if (set_end != (symbolS *) NULL
1267 && ((symbol_get_bfdsym (symp)->flags & BSF_NOT_AT_END) != 0
1268 || (S_IS_DEFINED (symp)
1269 && ! S_IS_COMMON (symp)
1270 && (! S_IS_EXTERNAL (symp) || SF_GET_FUNCTION (symp)))))
1272 SA_SET_SYM_ENDNDX (set_end, symp);
1276 if (next_set_end != NULL)
1278 if (set_end != NULL)
1279 as_warn ("Warning: internal error: forgetting to set endndx of %s",
1280 S_GET_NAME (set_end));
1281 set_end = next_set_end;
1285 && S_GET_STORAGE_CLASS (symp) == C_FCN
1286 && strcmp (S_GET_NAME (symp), ".bf") == 0)
1288 if (coff_last_bf != NULL)
1289 SA_SET_SYM_ENDNDX (coff_last_bf, symp);
1290 coff_last_bf = symp;
1293 if (coffsymbol (symbol_get_bfdsym (symp))->lineno)
1296 struct line_no *lptr;
1299 lptr = (struct line_no *) coffsymbol (symbol_get_bfdsym (symp))->lineno;
1300 for (i = 0; lptr; lptr = lptr->next)
1302 lptr = (struct line_no *) coffsymbol (symbol_get_bfdsym (symp))->lineno;
1304 /* We need i entries for line numbers, plus 1 for the first
1305 entry which BFD will override, plus 1 for the last zero
1306 entry (a marker for BFD). */
1307 l = (alent *) xmalloc ((i + 2) * sizeof (alent));
1308 coffsymbol (symbol_get_bfdsym (symp))->lineno = l;
1309 l[i + 1].line_number = 0;
1310 l[i + 1].u.sym = NULL;
1314 lptr->l.u.offset += lptr->frag->fr_address / OCTETS_PER_BYTE;
1322 coff_adjust_section_syms (abfd, sec, x)
1323 bfd *abfd ATTRIBUTE_UNUSED;
1325 PTR x ATTRIBUTE_UNUSED;
1328 segment_info_type *seginfo = seg_info (sec);
1329 int nlnno, nrelocs = 0;
1331 /* RS/6000 gas creates a .debug section manually in ppc_frob_file in
1332 tc-ppc.c. Do not get confused by it. */
1333 if (seginfo == NULL)
1336 if (!strcmp (sec->name, ".text"))
1337 nlnno = coff_n_line_nos;
1341 /* @@ Hope that none of the fixups expand to more than one reloc
1343 fixS *fixp = seginfo->fix_root;
1346 if (! fixp->fx_done)
1348 fixp = fixp->fx_next;
1351 if (bfd_get_section_size_before_reloc (sec) == 0
1354 && sec != text_section
1355 && sec != data_section
1356 && sec != bss_section)
1358 secsym = section_symbol (sec);
1359 /* This is an estimate; we'll plug in the real value using
1360 SET_SECTION_RELOCS later */
1361 SA_SET_SCN_NRELOC (secsym, nrelocs);
1362 SA_SET_SCN_NLINNO (secsym, nlnno);
1366 coff_frob_file_after_relocs ()
1368 bfd_map_over_sections (stdoutput, coff_adjust_section_syms, (char*) 0);
1372 * implement the .section pseudo op:
1373 * .section name {, "flags"}
1375 * | +--- optional flags: 'b' for bss
1377 * +-- section name 'l' for lib
1381 * 'd' (apparently m88k for data)
1383 * 'r' for read-only data
1384 * 's' for shared data (PE)
1385 * But if the argument is not a quoted string, treat it as a
1386 * subsegment number.
1390 obj_coff_section (ignore)
1391 int ignore ATTRIBUTE_UNUSED;
1393 /* Strip out the section name */
1398 flagword flags, oldflags;
1409 section_name = input_line_pointer;
1410 c = get_symbol_end ();
1412 name = xmalloc (input_line_pointer - section_name + 1);
1413 strcpy (name, section_name);
1415 *input_line_pointer = c;
1420 flags = SEC_NO_FLAGS;
1422 if (*input_line_pointer == ',')
1424 ++input_line_pointer;
1426 if (*input_line_pointer != '"')
1427 exp = get_absolute_expression ();
1430 ++input_line_pointer;
1431 while (*input_line_pointer != '"'
1432 && ! is_end_of_line[(unsigned char) *input_line_pointer])
1434 switch (*input_line_pointer)
1436 case 'b': flags |= SEC_ALLOC; flags &=~ SEC_LOAD; break;
1437 case 'n': flags &=~ SEC_LOAD; break;
1438 case 'd': flags |= SEC_DATA | SEC_LOAD; /* fall through */
1439 case 'w': flags &=~ SEC_READONLY; break;
1440 case 'x': flags |= SEC_CODE | SEC_LOAD; break;
1441 case 'r': flags |= SEC_READONLY; break;
1442 case 's': flags |= SEC_SHARED; break;
1444 case 'i': /* STYP_INFO */
1445 case 'l': /* STYP_LIB */
1446 case 'o': /* STYP_OVER */
1447 as_warn (_("unsupported section attribute '%c'"),
1448 *input_line_pointer);
1452 as_warn(_("unknown section attribute '%c'"),
1453 *input_line_pointer);
1456 ++input_line_pointer;
1458 if (*input_line_pointer == '"')
1459 ++input_line_pointer;
1463 sec = subseg_new (name, (subsegT) exp);
1465 oldflags = bfd_get_section_flags (stdoutput, sec);
1466 if (oldflags == SEC_NO_FLAGS)
1468 /* Set section flags for a new section just created by subseg_new.
1469 Provide a default if no flags were parsed. */
1470 if (flags == SEC_NO_FLAGS)
1471 flags = TC_COFF_SECTION_DEFAULT_ATTRIBUTES;
1473 #ifdef COFF_LONG_SECTION_NAMES
1474 /* Add SEC_LINK_ONCE and SEC_LINK_DUPLICATES_DISCARD to .gnu.linkonce
1475 sections so adjust_reloc_syms in write.c will correctly handle
1476 relocs which refer to non-local symbols in these sections. */
1477 if (strncmp (name, ".gnu.linkonce", sizeof(".gnu.linkonce") - 1) == 0)
1478 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1481 if (! bfd_set_section_flags (stdoutput, sec, flags))
1482 as_warn (_("error setting flags for \"%s\": %s"),
1483 bfd_section_name (stdoutput, sec),
1484 bfd_errmsg (bfd_get_error ()));
1486 else if (flags != SEC_NO_FLAGS)
1488 /* This section's attributes have already been set. Warn if the
1489 attributes don't match. */
1490 flagword matchflags = SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE
1491 | SEC_DATA | SEC_SHARED;
1492 if ((flags ^ oldflags) & matchflags)
1493 as_warn (_("Ignoring changed section attributes for %s"), name);
1496 demand_empty_rest_of_line ();
1500 coff_adjust_symtab ()
1502 if (symbol_rootP == NULL
1503 || S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
1504 c_dot_file_symbol ("fake");
1508 coff_frob_section (sec)
1514 bfd_vma size, n_entries, mask;
1515 bfd_vma align_power = (bfd_vma)sec->alignment_power + OCTETS_PER_BYTE_POWER;
1517 /* The COFF back end in BFD requires that all section sizes be
1518 rounded up to multiples of the corresponding section alignments,
1519 supposedly because standard COFF has no other way of encoding alignment
1520 for sections. If your COFF flavor has a different way of encoding
1521 section alignment, then skip this step, as TICOFF does. */
1522 size = bfd_get_section_size_before_reloc (sec);
1523 mask = ((bfd_vma) 1 << align_power) - 1;
1524 #if !defined(TICOFF)
1530 new_size = (size + mask) & ~mask;
1531 bfd_set_section_size (stdoutput, sec, new_size);
1533 /* If the size had to be rounded up, add some padding in
1534 the last non-empty frag. */
1535 fragp = seg_info (sec)->frchainP->frch_root;
1536 last = seg_info (sec)->frchainP->frch_last;
1537 while (fragp->fr_next != last)
1538 fragp = fragp->fr_next;
1539 last->fr_address = size;
1540 fragp->fr_offset += new_size - size;
1544 /* If the section size is non-zero, the section symbol needs an aux
1545 entry associated with it, indicating the size. We don't know
1546 all the values yet; coff_frob_symbol will fill them in later. */
1549 || sec == text_section
1550 || sec == data_section
1551 || sec == bss_section)
1554 symbolS *secsym = section_symbol (sec);
1556 S_SET_STORAGE_CLASS (secsym, C_STAT);
1557 S_SET_NUMBER_AUXILIARY (secsym, 1);
1558 SF_SET_STATICS (secsym);
1559 SA_SET_SCN_SCNLEN (secsym, size);
1562 /* @@ these should be in a "stabs.h" file, or maybe as.h */
1563 #ifndef STAB_SECTION_NAME
1564 #define STAB_SECTION_NAME ".stab"
1566 #ifndef STAB_STRING_SECTION_NAME
1567 #define STAB_STRING_SECTION_NAME ".stabstr"
1569 if (strcmp (STAB_STRING_SECTION_NAME, sec->name))
1573 sec = subseg_get (STAB_SECTION_NAME, 0);
1574 /* size is already rounded up, since other section will be listed first */
1575 size = bfd_get_section_size_before_reloc (strsec);
1577 n_entries = bfd_get_section_size_before_reloc (sec) / 12 - 1;
1579 /* Find first non-empty frag. It should be large enough. */
1580 fragp = seg_info (sec)->frchainP->frch_root;
1581 while (fragp && fragp->fr_fix == 0)
1582 fragp = fragp->fr_next;
1583 assert (fragp != 0 && fragp->fr_fix >= 12);
1585 /* Store the values. */
1586 p = fragp->fr_literal;
1587 bfd_h_put_16 (stdoutput, n_entries, (bfd_byte *) p + 6);
1588 bfd_h_put_32 (stdoutput, size, (bfd_byte *) p + 8);
1592 obj_coff_init_stab_section (seg)
1598 unsigned int stroff;
1600 /* Make space for this first symbol. */
1604 as_where (&file, (unsigned int *) NULL);
1605 stabstr_name = (char *) alloca (strlen (seg->name) + 4);
1606 strcpy (stabstr_name, seg->name);
1607 strcat (stabstr_name, "str");
1608 stroff = get_stab_string_offset (file, stabstr_name);
1610 md_number_to_chars (p, stroff, 4);
1619 return ((s == NULL) ? "(NULL)" : S_GET_NAME (s));
1627 for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
1629 printf(_("0x%lx: \"%s\" type = %ld, class = %d, segment = %d\n"),
1630 (unsigned long) symbolP,
1631 S_GET_NAME(symbolP),
1632 (long) S_GET_DATA_TYPE(symbolP),
1633 S_GET_STORAGE_CLASS(symbolP),
1634 (int) S_GET_SEGMENT(symbolP));
1640 #else /* not BFD_ASSEMBLER */
1643 /* This is needed because we include internal bfd things. */
1647 #include "libcoff.h"
1650 #include "coff/pe.h"
1653 /* The NOP_OPCODE is for the alignment fill value. Fill with nop so
1654 that we can stick sections together without causing trouble. */
1656 #define NOP_OPCODE 0x00
1659 /* The zeroes if symbol name is longer than 8 chars */
1660 #define S_SET_ZEROES(s,v) ((s)->sy_symbol.ost_entry.n_zeroes = (v))
1662 #define MIN(a,b) ((a) < (b)? (a) : (b))
1664 /* This vector is used to turn a gas internal segment number into a
1665 section number suitable for insertion into a coff symbol table.
1666 This must correspond to seg_info_off_by_4. */
1668 const short seg_N_TYPE[] =
1669 { /* in: segT out: N_TYPE bits */
1671 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
1672 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
1673 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
1674 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
1675 C_UNDEF_SECTION, /* SEG_UNKNOWN */
1676 C_UNDEF_SECTION, /* SEG_GOOF */
1677 C_UNDEF_SECTION, /* SEG_EXPR */
1678 C_DEBUG_SECTION, /* SEG_DEBUG */
1679 C_NTV_SECTION, /* SEG_NTV */
1680 C_PTV_SECTION, /* SEG_PTV */
1681 C_REGISTER_SECTION, /* SEG_REGISTER */
1684 int function_lineoff = -1; /* Offset in line#s where the last function
1685 started (the odd entry for line #0) */
1687 /* structure used to keep the filenames which
1688 are too long around so that we can stick them
1689 into the string table */
1690 struct filename_list
1693 struct filename_list *next;
1696 static struct filename_list *filename_list_head;
1697 static struct filename_list *filename_list_tail;
1699 static symbolS *last_line_symbol;
1701 /* Add 4 to the real value to get the index and compensate the
1702 negatives. This vector is used by S_GET_SEGMENT to turn a coff
1703 section number into a segment number
1705 static symbolS *previous_file_symbol;
1706 void c_symbol_merge ();
1707 static int line_base;
1709 symbolS *c_section_symbol ();
1712 static void fixup_segment PARAMS ((segment_info_type *segP,
1713 segT this_segment_type));
1715 static void fixup_mdeps PARAMS ((fragS *,
1719 static void fill_section PARAMS ((bfd * abfd,
1723 static int c_line_new PARAMS ((symbolS * symbol, long paddr,
1727 static void w_symbols PARAMS ((bfd * abfd, char *where,
1728 symbolS * symbol_rootP));
1730 static void adjust_stab_section PARAMS ((bfd *abfd, segT seg));
1732 static void obj_coff_lcomm PARAMS ((int));
1733 static void obj_coff_text PARAMS ((int));
1734 static void obj_coff_data PARAMS ((int));
1735 void obj_coff_section PARAMS ((int));
1737 /* When not using BFD_ASSEMBLER, we permit up to 40 sections.
1739 This array maps a COFF section number into a gas section number.
1740 Because COFF uses negative section numbers, you must add 4 to the
1741 COFF section number when indexing into this array; this is done via
1742 the SEG_INFO_FROM_SECTION_NUMBER macro. This must correspond to
1745 static const segT seg_info_off_by_4[] =
1752 SEG_E0, SEG_E1, SEG_E2, SEG_E3, SEG_E4,
1753 SEG_E5, SEG_E6, SEG_E7, SEG_E8, SEG_E9,
1754 SEG_E10, SEG_E11, SEG_E12, SEG_E13, SEG_E14,
1755 SEG_E15, SEG_E16, SEG_E17, SEG_E18, SEG_E19,
1756 SEG_E20, SEG_E21, SEG_E22, SEG_E23, SEG_E24,
1757 SEG_E25, SEG_E26, SEG_E27, SEG_E28, SEG_E29,
1758 SEG_E30, SEG_E31, SEG_E32, SEG_E33, SEG_E34,
1759 SEG_E35, SEG_E36, SEG_E37, SEG_E38, SEG_E39,
1772 #define SEG_INFO_FROM_SECTION_NUMBER(x) (seg_info_off_by_4[(x)+4])
1774 static relax_addressT
1775 relax_align (address, alignment)
1776 relax_addressT address;
1779 relax_addressT mask;
1780 relax_addressT new_address;
1782 mask = ~((~0) << alignment);
1783 new_address = (address + mask) & (~mask);
1784 return (new_address - address);
1791 return SEG_INFO_FROM_SECTION_NUMBER (x->sy_symbol.ost_entry.n_scnum);
1794 /* calculate the size of the frag chain and fill in the section header
1795 to contain all of it, also fill in the addr of the sections */
1797 size_section (abfd, idx)
1798 bfd *abfd ATTRIBUTE_UNUSED;
1802 unsigned int size = 0;
1803 fragS *frag = segment_info[idx].frchainP->frch_root;
1806 size = frag->fr_address;
1807 if (frag->fr_address != size)
1809 fprintf (stderr, _("Out of step\n"));
1810 size = frag->fr_address;
1813 switch (frag->fr_type)
1815 #ifdef TC_COFF_SIZEMACHDEP
1816 case rs_machine_dependent:
1817 size += TC_COFF_SIZEMACHDEP (frag);
1821 assert (frag->fr_symbol == 0);
1824 size += frag->fr_fix;
1825 size += frag->fr_offset * frag->fr_var;
1832 size += frag->fr_fix;
1833 off = relax_align (size, frag->fr_offset);
1834 if (frag->fr_subtype != 0 && off > frag->fr_subtype)
1840 BAD_CASE (frag->fr_type);
1843 frag = frag->fr_next;
1845 segment_info[idx].scnhdr.s_size = size;
1850 count_entries_in_chain (idx)
1853 unsigned int nrelocs;
1856 /* Count the relocations */
1857 fixup_ptr = segment_info[idx].fix_root;
1859 while (fixup_ptr != (fixS *) NULL)
1861 if (fixup_ptr->fx_done == 0 && TC_COUNT_RELOC (fixup_ptr))
1864 if (fixup_ptr->fx_r_type == RELOC_CONSTH)
1873 fixup_ptr = fixup_ptr->fx_next;
1880 static int compare_external_relocs PARAMS ((const PTR, const PTR));
1882 /* AUX's ld expects relocations to be sorted */
1884 compare_external_relocs (x, y)
1888 struct external_reloc *a = (struct external_reloc *) x;
1889 struct external_reloc *b = (struct external_reloc *) y;
1890 bfd_vma aadr = bfd_getb32 (a->r_vaddr);
1891 bfd_vma badr = bfd_getb32 (b->r_vaddr);
1892 return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
1897 /* output all the relocations for a section */
1899 do_relocs_for (abfd, h, file_cursor)
1902 unsigned long *file_cursor;
1904 unsigned int nrelocs;
1906 unsigned long reloc_start = *file_cursor;
1908 for (idx = SEG_E0; idx < SEG_LAST; idx++)
1910 if (segment_info[idx].scnhdr.s_name[0])
1912 struct external_reloc *ext_ptr;
1913 struct external_reloc *external_reloc_vec;
1914 unsigned int external_reloc_size;
1915 unsigned int base = segment_info[idx].scnhdr.s_paddr;
1916 fixS *fix_ptr = segment_info[idx].fix_root;
1917 nrelocs = count_entries_in_chain (idx);
1920 /* Bypass this stuff if no relocs. This also incidentally
1921 avoids a SCO bug, where free(malloc(0)) tends to crash. */
1923 external_reloc_size = nrelocs * RELSZ;
1924 external_reloc_vec =
1925 (struct external_reloc *) malloc (external_reloc_size);
1927 ext_ptr = external_reloc_vec;
1929 /* Fill in the internal coff style reloc struct from the
1930 internal fix list. */
1933 struct internal_reloc intr;
1935 /* Only output some of the relocations */
1936 if (fix_ptr->fx_done == 0 && TC_COUNT_RELOC (fix_ptr))
1938 #ifdef TC_RELOC_MANGLE
1939 TC_RELOC_MANGLE (&segment_info[idx], fix_ptr, &intr,
1944 symbolS *symbol_ptr = fix_ptr->fx_addsy;
1946 intr.r_type = TC_COFF_FIX2RTYPE (fix_ptr);
1948 base + fix_ptr->fx_frag->fr_address + fix_ptr->fx_where;
1950 #ifdef TC_KEEP_FX_OFFSET
1951 intr.r_offset = fix_ptr->fx_offset;
1956 while (symbol_ptr->sy_value.X_op == O_symbol
1957 && (! S_IS_DEFINED (symbol_ptr)
1958 || S_IS_COMMON (symbol_ptr)))
1962 /* We must avoid looping, as that can occur
1963 with a badly written program. */
1964 n = symbol_ptr->sy_value.X_add_symbol;
1965 if (n == symbol_ptr)
1970 /* Turn the segment of the symbol into an offset. */
1973 resolve_symbol_value (symbol_ptr, 1);
1974 if (! symbol_ptr->sy_resolved)
1979 if (expr_symbol_where (symbol_ptr, &file, &line))
1980 as_bad_where (file, line,
1981 _("unresolved relocation"));
1983 as_bad (_("bad relocation: symbol `%s' not in symbol table"),
1984 S_GET_NAME (symbol_ptr));
1986 dot = segment_info[S_GET_SEGMENT (symbol_ptr)].dot;
1989 intr.r_symndx = dot->sy_number;
1993 intr.r_symndx = symbol_ptr->sy_number;
2003 (void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
2006 #if defined(TC_A29K)
2008 /* The 29k has a special kludge for the high 16 bit
2009 reloc. Two relocations are emited, R_IHIHALF,
2010 and R_IHCONST. The second one doesn't contain a
2011 symbol, but uses the value for offset. */
2013 if (intr.r_type == R_IHIHALF)
2015 /* now emit the second bit */
2016 intr.r_type = R_IHCONST;
2017 intr.r_symndx = fix_ptr->fx_addnumber;
2018 (void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
2024 fix_ptr = fix_ptr->fx_next;
2028 /* Sort the reloc table */
2029 qsort ((PTR) external_reloc_vec, nrelocs,
2030 sizeof (struct external_reloc), compare_external_relocs);
2033 /* Write out the reloc table */
2034 bfd_write ((PTR) external_reloc_vec, 1, external_reloc_size,
2036 free (external_reloc_vec);
2038 /* Fill in section header info. */
2039 segment_info[idx].scnhdr.s_relptr = *file_cursor;
2040 *file_cursor += external_reloc_size;
2041 segment_info[idx].scnhdr.s_nreloc = nrelocs;
2046 segment_info[idx].scnhdr.s_relptr = 0;
2050 /* Set relocation_size field in file headers */
2051 H_SET_RELOCATION_SIZE (h, *file_cursor - reloc_start, 0);
2054 /* run through a frag chain and write out the data to go with it, fill
2055 in the scnhdrs with the info on the file postions
2058 fill_section (abfd, h, file_cursor)
2060 object_headers *h ATTRIBUTE_UNUSED;
2061 unsigned long *file_cursor;
2065 unsigned int paddr = 0;
2067 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
2069 unsigned int offset = 0;
2070 struct internal_scnhdr *s = &(segment_info[i].scnhdr);
2076 fragS *frag = segment_info[i].frchainP->frch_root;
2083 buffer = xmalloc (s->s_size);
2084 s->s_scnptr = *file_cursor;
2086 know (s->s_paddr == paddr);
2088 if (strcmp (s->s_name, ".text") == 0)
2089 s->s_flags |= STYP_TEXT;
2090 else if (strcmp (s->s_name, ".data") == 0)
2091 s->s_flags |= STYP_DATA;
2092 else if (strcmp (s->s_name, ".bss") == 0)
2095 s->s_flags |= STYP_BSS;
2097 /* @@ Should make the i386 and a29k coff targets define
2098 COFF_NOLOAD_PROBLEM, and have only one test here. */
2101 #ifndef COFF_NOLOAD_PROBLEM
2102 /* Apparently the SVR3 linker (and exec syscall) and UDI
2103 mondfe progrem are confused by noload sections. */
2104 s->s_flags |= STYP_NOLOAD;
2109 else if (strcmp (s->s_name, ".lit") == 0)
2110 s->s_flags = STYP_LIT | STYP_TEXT;
2111 else if (strcmp (s->s_name, ".init") == 0)
2112 s->s_flags |= STYP_TEXT;
2113 else if (strcmp (s->s_name, ".fini") == 0)
2114 s->s_flags |= STYP_TEXT;
2115 else if (strncmp (s->s_name, ".comment", 8) == 0)
2116 s->s_flags |= STYP_INFO;
2120 unsigned int fill_size;
2121 switch (frag->fr_type)
2123 case rs_machine_dependent:
2126 memcpy (buffer + frag->fr_address,
2128 (unsigned int) frag->fr_fix);
2129 offset += frag->fr_fix;
2134 assert (frag->fr_symbol == 0);
2141 memcpy (buffer + frag->fr_address,
2143 (unsigned int) frag->fr_fix);
2144 offset += frag->fr_fix;
2147 fill_size = frag->fr_var;
2148 if (fill_size && frag->fr_offset > 0)
2151 unsigned int off = frag->fr_fix;
2152 for (count = frag->fr_offset; count; count--)
2154 if (fill_size + frag->fr_address + off <= s->s_size)
2156 memcpy (buffer + frag->fr_address + off,
2157 frag->fr_literal + frag->fr_fix,
2160 offset += fill_size;
2165 case rs_broken_word:
2170 frag = frag->fr_next;
2175 if (s->s_scnptr != 0)
2177 bfd_write (buffer, s->s_size, 1, abfd);
2178 *file_cursor += s->s_size;
2187 /* Coff file generation & utilities */
2190 coff_header_append (abfd, h)
2197 #ifdef COFF_LONG_SECTION_NAMES
2198 unsigned long string_size = 4;
2201 bfd_seek (abfd, 0, 0);
2203 #ifndef OBJ_COFF_OMIT_OPTIONAL_HEADER
2204 H_SET_MAGIC_NUMBER (h, COFF_MAGIC);
2205 H_SET_VERSION_STAMP (h, 0);
2206 H_SET_ENTRY_POINT (h, 0);
2207 H_SET_TEXT_START (h, segment_info[SEG_E0].frchainP->frch_root->fr_address);
2208 H_SET_DATA_START (h, segment_info[SEG_E1].frchainP->frch_root->fr_address);
2209 H_SET_SIZEOF_OPTIONAL_HEADER (h, bfd_coff_swap_aouthdr_out(abfd, &h->aouthdr,
2211 #else /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
2212 H_SET_SIZEOF_OPTIONAL_HEADER (h, 0);
2213 #endif /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
2215 i = bfd_coff_swap_filehdr_out (abfd, &h->filehdr, buffer);
2217 bfd_write (buffer, i, 1, abfd);
2218 bfd_write (buffero, H_GET_SIZEOF_OPTIONAL_HEADER (h), 1, abfd);
2220 for (i = SEG_E0; i < SEG_LAST; i++)
2222 if (segment_info[i].scnhdr.s_name[0])
2226 #ifdef COFF_LONG_SECTION_NAMES
2227 /* Support long section names as found in PE. This code
2228 must coordinate with that in write_object_file and
2230 if (strlen (segment_info[i].name) > SCNNMLEN)
2232 memset (segment_info[i].scnhdr.s_name, 0, SCNNMLEN);
2233 sprintf (segment_info[i].scnhdr.s_name, "/%lu", string_size);
2234 string_size += strlen (segment_info[i].name) + 1;
2238 size = bfd_coff_swap_scnhdr_out (abfd,
2239 &(segment_info[i].scnhdr),
2242 as_bad (_("bfd_coff_swap_scnhdr_out failed"));
2243 bfd_write (buffer, size, 1, abfd);
2249 symbol_to_chars (abfd, where, symbolP)
2254 unsigned int numaux = symbolP->sy_symbol.ost_entry.n_numaux;
2258 /* Turn any symbols with register attributes into abs symbols */
2259 if (S_GET_SEGMENT (symbolP) == reg_section)
2261 S_SET_SEGMENT (symbolP, absolute_section);
2263 /* At the same time, relocate all symbols to their output value */
2266 val = (segment_info[S_GET_SEGMENT (symbolP)].scnhdr.s_paddr
2267 + S_GET_VALUE (symbolP));
2269 val = S_GET_VALUE (symbolP);
2272 S_SET_VALUE (symbolP, val);
2274 symbolP->sy_symbol.ost_entry.n_value = val;
2276 where += bfd_coff_swap_sym_out (abfd, &symbolP->sy_symbol.ost_entry,
2279 for (i = 0; i < numaux; i++)
2281 where += bfd_coff_swap_aux_out (abfd,
2282 &symbolP->sy_symbol.ost_auxent[i],
2283 S_GET_DATA_TYPE (symbolP),
2284 S_GET_STORAGE_CLASS (symbolP),
2292 coff_obj_symbol_new_hook (symbolP)
2295 char underscore = 0; /* Symbol has leading _ */
2297 /* Effective symbol */
2298 /* Store the pointer in the offset. */
2299 S_SET_ZEROES (symbolP, 0L);
2300 S_SET_DATA_TYPE (symbolP, T_NULL);
2301 S_SET_STORAGE_CLASS (symbolP, 0);
2302 S_SET_NUMBER_AUXILIARY (symbolP, 0);
2303 /* Additional information */
2304 symbolP->sy_symbol.ost_flags = 0;
2305 /* Auxiliary entries */
2306 memset ((char *) &symbolP->sy_symbol.ost_auxent[0], 0, AUXESZ);
2308 if (S_IS_STRING (symbolP))
2309 SF_SET_STRING (symbolP);
2310 if (!underscore && S_IS_LOCAL (symbolP))
2311 SF_SET_LOCAL (symbolP);
2315 * Handle .ln directives.
2319 obj_coff_ln (appline)
2324 if (! appline && def_symbol_in_progress != NULL)
2326 as_warn (_(".ln pseudo-op inside .def/.endef: ignored."));
2327 demand_empty_rest_of_line ();
2329 } /* wrong context */
2331 l = get_absolute_expression ();
2332 c_line_new (0, frag_now_fix (), l, frag_now);
2335 new_logical_line ((char *) NULL, l - 1);
2345 listing_source_line ((unsigned int) l);
2350 demand_empty_rest_of_line ();
2356 * Handle .def directives.
2358 * One might ask : why can't we symbol_new if the symbol does not
2359 * already exist and fill it with debug information. Because of
2360 * the C_EFCN special symbol. It would clobber the value of the
2361 * function symbol before we have a chance to notice that it is
2362 * a C_EFCN. And a second reason is that the code is more clear this
2363 * way. (at least I think it is :-).
2367 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
2368 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
2369 *input_line_pointer == '\t') \
2370 input_line_pointer++;
2374 int what ATTRIBUTE_UNUSED;
2376 char name_end; /* Char after the end of name */
2377 char *symbol_name; /* Name of the debug symbol */
2378 char *symbol_name_copy; /* Temporary copy of the name */
2379 unsigned int symbol_name_length;
2381 if (def_symbol_in_progress != NULL)
2383 as_warn (_(".def pseudo-op used inside of .def/.endef: ignored."));
2384 demand_empty_rest_of_line ();
2386 } /* if not inside .def/.endef */
2388 SKIP_WHITESPACES ();
2390 def_symbol_in_progress = (symbolS *) obstack_alloc (¬es, sizeof (*def_symbol_in_progress));
2391 memset (def_symbol_in_progress, 0, sizeof (*def_symbol_in_progress));
2393 symbol_name = input_line_pointer;
2394 name_end = get_symbol_end ();
2395 symbol_name_length = strlen (symbol_name);
2396 symbol_name_copy = xmalloc (symbol_name_length + 1);
2397 strcpy (symbol_name_copy, symbol_name);
2398 #ifdef tc_canonicalize_symbol_name
2399 symbol_name_copy = tc_canonicalize_symbol_name (symbol_name_copy);
2402 /* Initialize the new symbol */
2403 #ifdef STRIP_UNDERSCORE
2404 S_SET_NAME (def_symbol_in_progress, (*symbol_name_copy == '_'
2405 ? symbol_name_copy + 1
2406 : symbol_name_copy));
2407 #else /* STRIP_UNDERSCORE */
2408 S_SET_NAME (def_symbol_in_progress, symbol_name_copy);
2409 #endif /* STRIP_UNDERSCORE */
2410 /* free(symbol_name_copy); */
2411 def_symbol_in_progress->sy_name_offset = (unsigned long) ~0;
2412 def_symbol_in_progress->sy_number = ~0;
2413 def_symbol_in_progress->sy_frag = &zero_address_frag;
2414 S_SET_VALUE (def_symbol_in_progress, 0);
2416 if (S_IS_STRING (def_symbol_in_progress))
2417 SF_SET_STRING (def_symbol_in_progress);
2419 *input_line_pointer = name_end;
2421 demand_empty_rest_of_line ();
2424 unsigned int dim_index;
2427 obj_coff_endef (ignore)
2428 int ignore ATTRIBUTE_UNUSED;
2430 symbolS *symbolP = 0;
2431 /* DIM BUG FIX sac@cygnus.com */
2433 if (def_symbol_in_progress == NULL)
2435 as_warn (_(".endef pseudo-op used outside of .def/.endef: ignored."));
2436 demand_empty_rest_of_line ();
2438 } /* if not inside .def/.endef */
2440 /* Set the section number according to storage class. */
2441 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))
2446 SF_SET_TAG (def_symbol_in_progress);
2447 /* intentional fallthrough */
2450 SF_SET_DEBUG (def_symbol_in_progress);
2451 S_SET_SEGMENT (def_symbol_in_progress, SEG_DEBUG);
2455 SF_SET_LOCAL (def_symbol_in_progress); /* Do not emit this symbol. */
2456 /* intentional fallthrough */
2458 SF_SET_PROCESS (def_symbol_in_progress); /* Will need processing before writing */
2459 /* intentional fallthrough */
2461 S_SET_SEGMENT (def_symbol_in_progress, SEG_E0);
2463 if (strcmp (S_GET_NAME (def_symbol_in_progress), ".bf") == 0)
2465 if (function_lineoff < 0)
2467 fprintf (stderr, _("`.bf' symbol without preceding function\n"));
2468 } /* missing function symbol */
2469 SA_GET_SYM_LNNOPTR (last_line_symbol) = function_lineoff;
2471 SF_SET_PROCESS (last_line_symbol);
2472 SF_SET_ADJ_LNNOPTR (last_line_symbol);
2473 SF_SET_PROCESS (def_symbol_in_progress);
2474 function_lineoff = -1;
2476 /* Value is always set to . */
2477 def_symbol_in_progress->sy_frag = frag_now;
2478 S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
2483 #endif /* C_AUTOARG */
2493 SF_SET_DEBUG (def_symbol_in_progress);
2494 S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
2504 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
2510 as_warn (_("unexpected storage class %d"), S_GET_STORAGE_CLASS (def_symbol_in_progress));
2512 } /* switch on storage class */
2514 /* Now that we have built a debug symbol, try to find if we should
2515 merge with an existing symbol or not. If a symbol is C_EFCN or
2516 absolute_section or untagged SEG_DEBUG it never merges. We also
2517 don't merge labels, which are in a different namespace, nor
2518 symbols which have not yet been defined since they are typically
2519 unique, nor do we merge tags with non-tags. */
2521 /* Two cases for functions. Either debug followed by definition or
2522 definition followed by debug. For definition first, we will
2523 merge the debug symbol into the definition. For debug first, the
2524 lineno entry MUST point to the definition function or else it
2525 will point off into space when crawl_symbols() merges the debug
2526 symbol into the real symbol. Therefor, let's presume the debug
2527 symbol is a real function reference. */
2529 /* FIXME-SOON If for some reason the definition label/symbol is
2530 never seen, this will probably leave an undefined symbol at link
2533 if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN
2534 || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_LABEL
2535 || (S_GET_SEGMENT (def_symbol_in_progress) == SEG_DEBUG
2536 && !SF_GET_TAG (def_symbol_in_progress))
2537 || S_GET_SEGMENT (def_symbol_in_progress) == absolute_section
2538 || def_symbol_in_progress->sy_value.X_op != O_constant
2539 || (symbolP = symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP)) == NULL
2540 || (SF_GET_TAG (def_symbol_in_progress) != SF_GET_TAG (symbolP)))
2542 symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP,
2547 /* This symbol already exists, merge the newly created symbol
2548 into the old one. This is not mandatory. The linker can
2549 handle duplicate symbols correctly. But I guess that it save
2550 a *lot* of space if the assembly file defines a lot of
2553 /* The debug entry (def_symbol_in_progress) is merged into the
2554 previous definition. */
2556 c_symbol_merge (def_symbol_in_progress, symbolP);
2557 /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
2558 def_symbol_in_progress = symbolP;
2560 if (SF_GET_FUNCTION (def_symbol_in_progress)
2561 || SF_GET_TAG (def_symbol_in_progress)
2562 || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_STAT)
2564 /* For functions, and tags, and static symbols, the symbol
2565 *must* be where the debug symbol appears. Move the
2566 existing symbol to the current place. */
2567 /* If it already is at the end of the symbol list, do nothing */
2568 if (def_symbol_in_progress != symbol_lastP)
2570 symbol_remove (def_symbol_in_progress, &symbol_rootP,
2572 symbol_append (def_symbol_in_progress, symbol_lastP,
2573 &symbol_rootP, &symbol_lastP);
2574 } /* if not already in place */
2576 } /* normal or mergable */
2578 if (SF_GET_TAG (def_symbol_in_progress))
2582 oldtag = symbol_find_base (S_GET_NAME (def_symbol_in_progress),
2584 if (oldtag == NULL || ! SF_GET_TAG (oldtag))
2585 tag_insert (S_GET_NAME (def_symbol_in_progress),
2586 def_symbol_in_progress);
2589 if (SF_GET_FUNCTION (def_symbol_in_progress))
2591 know (sizeof (def_symbol_in_progress) <= sizeof (long));
2593 = c_line_new (def_symbol_in_progress, 0, 0, &zero_address_frag);
2595 SF_SET_PROCESS (def_symbol_in_progress);
2597 if (symbolP == NULL)
2599 /* That is, if this is the first time we've seen the
2601 symbol_table_insert (def_symbol_in_progress);
2602 } /* definition follows debug */
2603 } /* Create the line number entry pointing to the function being defined */
2605 def_symbol_in_progress = NULL;
2606 demand_empty_rest_of_line ();
2610 obj_coff_dim (ignore)
2611 int ignore ATTRIBUTE_UNUSED;
2615 if (def_symbol_in_progress == NULL)
2617 as_warn (_(".dim pseudo-op used outside of .def/.endef: ignored."));
2618 demand_empty_rest_of_line ();
2620 } /* if not inside .def/.endef */
2622 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2624 for (dim_index = 0; dim_index < DIMNUM; dim_index++)
2626 SKIP_WHITESPACES ();
2627 SA_SET_SYM_DIMEN (def_symbol_in_progress, dim_index,
2628 get_absolute_expression ());
2630 switch (*input_line_pointer)
2633 input_line_pointer++;
2637 as_warn (_("badly formed .dim directive ignored"));
2638 /* intentional fallthrough */
2646 demand_empty_rest_of_line ();
2650 obj_coff_line (ignore)
2651 int ignore ATTRIBUTE_UNUSED;
2656 if (def_symbol_in_progress == NULL)
2662 name = S_GET_NAME (def_symbol_in_progress);
2663 this_base = get_absolute_expression ();
2665 /* Only .bf symbols indicate the use of a new base line number; the
2666 line numbers associated with .ef, .bb, .eb are relative to the
2667 start of the containing function. */
2668 if (!strcmp (".bf", name))
2670 #if 0 /* XXX Can we ever have line numbers going backwards? */
2671 if (this_base > line_base)
2674 line_base = this_base;
2682 listing_source_line ((unsigned int) line_base);
2688 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2689 SA_SET_SYM_LNNO (def_symbol_in_progress, this_base);
2691 demand_empty_rest_of_line ();
2695 obj_coff_size (ignore)
2696 int ignore ATTRIBUTE_UNUSED;
2698 if (def_symbol_in_progress == NULL)
2700 as_warn (_(".size pseudo-op used outside of .def/.endef ignored."));
2701 demand_empty_rest_of_line ();
2703 } /* if not inside .def/.endef */
2705 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2706 SA_SET_SYM_SIZE (def_symbol_in_progress, get_absolute_expression ());
2707 demand_empty_rest_of_line ();
2711 obj_coff_scl (ignore)
2712 int ignore ATTRIBUTE_UNUSED;
2714 if (def_symbol_in_progress == NULL)
2716 as_warn (_(".scl pseudo-op used outside of .def/.endef ignored."));
2717 demand_empty_rest_of_line ();
2719 } /* if not inside .def/.endef */
2721 S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ());
2722 demand_empty_rest_of_line ();
2726 obj_coff_tag (ignore)
2727 int ignore ATTRIBUTE_UNUSED;
2732 if (def_symbol_in_progress == NULL)
2734 as_warn (_(".tag pseudo-op used outside of .def/.endef ignored."));
2735 demand_empty_rest_of_line ();
2739 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2740 symbol_name = input_line_pointer;
2741 name_end = get_symbol_end ();
2742 #ifdef tc_canonicalize_symbol_name
2743 symbol_name = tc_canonicalize_symbol_name (symbol_name);
2746 /* Assume that the symbol referred to by .tag is always defined.
2747 This was a bad assumption. I've added find_or_make. xoxorich. */
2748 SA_SET_SYM_TAGNDX (def_symbol_in_progress,
2749 (long) tag_find_or_make (symbol_name));
2750 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L)
2752 as_warn (_("tag not found for .tag %s"), symbol_name);
2755 SF_SET_TAGGED (def_symbol_in_progress);
2756 *input_line_pointer = name_end;
2758 demand_empty_rest_of_line ();
2762 obj_coff_type (ignore)
2763 int ignore ATTRIBUTE_UNUSED;
2765 if (def_symbol_in_progress == NULL)
2767 as_warn (_(".type pseudo-op used outside of .def/.endef ignored."));
2768 demand_empty_rest_of_line ();
2770 } /* if not inside .def/.endef */
2772 S_SET_DATA_TYPE (def_symbol_in_progress, get_absolute_expression ());
2774 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress)) &&
2775 S_GET_STORAGE_CLASS (def_symbol_in_progress) != C_TPDEF)
2777 SF_SET_FUNCTION (def_symbol_in_progress);
2778 } /* is a function */
2780 demand_empty_rest_of_line ();
2784 obj_coff_val (ignore)
2785 int ignore ATTRIBUTE_UNUSED;
2787 if (def_symbol_in_progress == NULL)
2789 as_warn (_(".val pseudo-op used outside of .def/.endef ignored."));
2790 demand_empty_rest_of_line ();
2792 } /* if not inside .def/.endef */
2794 if (is_name_beginner (*input_line_pointer))
2796 char *symbol_name = input_line_pointer;
2797 char name_end = get_symbol_end ();
2799 #ifdef tc_canonicalize_symbol_name
2800 symbol_name = tc_canonicalize_symbol_name (symbol_name);
2803 if (!strcmp (symbol_name, "."))
2805 def_symbol_in_progress->sy_frag = frag_now;
2806 S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
2807 /* If the .val is != from the .def (e.g. statics) */
2809 else if (strcmp (S_GET_NAME (def_symbol_in_progress), symbol_name))
2811 def_symbol_in_progress->sy_value.X_op = O_symbol;
2812 def_symbol_in_progress->sy_value.X_add_symbol =
2813 symbol_find_or_make (symbol_name);
2814 def_symbol_in_progress->sy_value.X_op_symbol = NULL;
2815 def_symbol_in_progress->sy_value.X_add_number = 0;
2817 /* If the segment is undefined when the forward reference is
2818 resolved, then copy the segment id from the forward
2820 SF_SET_GET_SEGMENT (def_symbol_in_progress);
2822 /* FIXME: gcc can generate address expressions here in
2823 unusual cases (search for "obscure" in sdbout.c). We
2824 just ignore the offset here, thus generating incorrect
2825 debugging information. We ignore the rest of the line
2828 /* Otherwise, it is the name of a non debug symbol and
2829 its value will be calculated later. */
2830 *input_line_pointer = name_end;
2832 /* FIXME: this is to avoid an error message in the
2833 FIXME case mentioned just above. */
2834 while (! is_end_of_line[(unsigned char) *input_line_pointer])
2835 ++input_line_pointer;
2839 S_SET_VALUE (def_symbol_in_progress,
2840 (valueT) get_absolute_expression ());
2841 } /* if symbol based */
2843 demand_empty_rest_of_line ();
2848 /* Handle the .linkonce pseudo-op. This is parsed by s_linkonce in
2849 read.c, which then calls this object file format specific routine. */
2852 obj_coff_pe_handle_link_once (type)
2853 enum linkonce_type type;
2855 seg_info (now_seg)->scnhdr.s_flags |= IMAGE_SCN_LNK_COMDAT;
2857 /* We store the type in the seg_info structure, and use it to set up
2858 the auxiliary entry for the section symbol in c_section_symbol. */
2859 seg_info (now_seg)->linkonce = type;
2865 coff_obj_read_begin_hook ()
2867 /* These had better be the same. Usually 18 bytes. */
2869 know (sizeof (SYMENT) == sizeof (AUXENT));
2870 know (SYMESZ == AUXESZ);
2875 /* This function runs through the symbol table and puts all the
2876 externals onto another chain */
2878 /* The chain of globals. */
2879 symbolS *symbol_globalP;
2880 symbolS *symbol_global_lastP;
2882 /* The chain of externals */
2883 symbolS *symbol_externP;
2884 symbolS *symbol_extern_lastP;
2887 symbolS *last_functionP;
2888 static symbolS *last_bfP;
2895 unsigned int symbol_number = 0;
2896 unsigned int last_file_symno = 0;
2898 struct filename_list *filename_list_scan = filename_list_head;
2900 for (symbolP = symbol_rootP;
2902 symbolP = symbolP ? symbol_next (symbolP) : symbol_rootP)
2904 if (symbolP->sy_mri_common)
2906 if (S_GET_STORAGE_CLASS (symbolP) == C_EXT
2908 || S_GET_STORAGE_CLASS (symbolP) == C_NT_WEAK
2910 || S_GET_STORAGE_CLASS (symbolP) == C_WEAKEXT)
2911 as_bad (_("%s: global symbols not supported in common sections"),
2912 S_GET_NAME (symbolP));
2913 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2917 if (!SF_GET_DEBUG (symbolP))
2919 /* Debug symbols do not need all this rubbish */
2920 symbolS *real_symbolP;
2922 /* L* and C_EFCN symbols never merge. */
2923 if (!SF_GET_LOCAL (symbolP)
2924 && !SF_GET_STATICS (symbolP)
2925 && S_GET_STORAGE_CLASS (symbolP) != C_LABEL
2926 && symbolP->sy_value.X_op == O_constant
2927 && (real_symbolP = symbol_find_base (S_GET_NAME (symbolP), DO_NOT_STRIP))
2928 && real_symbolP != symbolP)
2930 /* FIXME-SOON: where do dups come from?
2931 Maybe tag references before definitions? xoxorich. */
2932 /* Move the debug data from the debug symbol to the
2933 real symbol. Do NOT do the oposite (i.e. move from
2934 real symbol to debug symbol and remove real symbol from the
2935 list.) Because some pointers refer to the real symbol
2936 whereas no pointers refer to the debug symbol. */
2937 c_symbol_merge (symbolP, real_symbolP);
2938 /* Replace the current symbol by the real one */
2939 /* The symbols will never be the last or the first
2940 because : 1st symbol is .file and 3 last symbols are
2941 .text, .data, .bss */
2942 symbol_remove (real_symbolP, &symbol_rootP, &symbol_lastP);
2943 symbol_insert (real_symbolP, symbolP, &symbol_rootP, &symbol_lastP);
2944 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2945 symbolP = real_symbolP;
2946 } /* if not local but dup'd */
2948 if (flag_readonly_data_in_text && (S_GET_SEGMENT (symbolP) == SEG_E1))
2950 S_SET_SEGMENT (symbolP, SEG_E0);
2951 } /* push data into text */
2953 resolve_symbol_value (symbolP, 1);
2955 if (S_GET_STORAGE_CLASS (symbolP) == C_NULL)
2957 if (!S_IS_DEFINED (symbolP) && !SF_GET_LOCAL (symbolP))
2959 S_SET_EXTERNAL (symbolP);
2961 else if (S_GET_SEGMENT (symbolP) == SEG_E0)
2963 S_SET_STORAGE_CLASS (symbolP, C_LABEL);
2967 S_SET_STORAGE_CLASS (symbolP, C_STAT);
2971 /* Mainly to speed up if not -g */
2972 if (SF_GET_PROCESS (symbolP))
2974 /* Handle the nested blocks auxiliary info. */
2975 if (S_GET_STORAGE_CLASS (symbolP) == C_BLOCK)
2977 if (!strcmp (S_GET_NAME (symbolP), ".bb"))
2978 stack_push (block_stack, (char *) &symbolP);
2981 register symbolS *begin_symbolP;
2982 begin_symbolP = *(symbolS **) stack_pop (block_stack);
2983 if (begin_symbolP == (symbolS *) 0)
2984 as_warn (_("mismatched .eb"));
2986 SA_SET_SYM_ENDNDX (begin_symbolP, symbol_number + 2);
2989 /* If we are able to identify the type of a function, and we
2990 are out of a function (last_functionP == 0) then, the
2991 function symbol will be associated with an auxiliary
2993 if (last_functionP == (symbolS *) 0 &&
2994 SF_GET_FUNCTION (symbolP))
2996 last_functionP = symbolP;
2998 if (S_GET_NUMBER_AUXILIARY (symbolP) < 1)
3000 S_SET_NUMBER_AUXILIARY (symbolP, 1);
3001 } /* make it at least 1 */
3003 /* Clobber possible stale .dim information. */
3005 /* Iffed out by steve - this fries the lnnoptr info too */
3006 bzero (symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen,
3007 sizeof (symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen));
3010 if (S_GET_STORAGE_CLASS (symbolP) == C_FCN)
3012 if (strcmp (S_GET_NAME (symbolP), ".bf") == 0)
3014 if (last_bfP != NULL)
3015 SA_SET_SYM_ENDNDX (last_bfP, symbol_number);
3019 else if (S_GET_STORAGE_CLASS (symbolP) == C_EFCN)
3021 /* I don't even know if this is needed for sdb. But
3022 the standard assembler generates it, so... */
3023 if (last_functionP == (symbolS *) 0)
3024 as_fatal (_("C_EFCN symbol out of scope"));
3025 SA_SET_SYM_FSIZE (last_functionP,
3026 (long) (S_GET_VALUE (symbolP) -
3027 S_GET_VALUE (last_functionP)));
3028 SA_SET_SYM_ENDNDX (last_functionP, symbol_number);
3029 last_functionP = (symbolS *) 0;
3033 else if (SF_GET_TAG (symbolP))
3035 /* First descriptor of a structure must point to
3036 the first slot after the structure description. */
3037 last_tagP = symbolP;
3040 else if (S_GET_STORAGE_CLASS (symbolP) == C_EOS)
3042 /* +2 take in account the current symbol */
3043 SA_SET_SYM_ENDNDX (last_tagP, symbol_number + 2);
3045 else if (S_GET_STORAGE_CLASS (symbolP) == C_FILE)
3047 /* If the filename was too long to fit in the
3048 auxent, put it in the string table */
3049 if (SA_GET_FILE_FNAME_ZEROS (symbolP) == 0
3050 && SA_GET_FILE_FNAME_OFFSET (symbolP) != 0)
3052 SA_SET_FILE_FNAME_OFFSET (symbolP, string_byte_count);
3053 string_byte_count += strlen (filename_list_scan->filename) + 1;
3054 filename_list_scan = filename_list_scan->next;
3056 if (S_GET_VALUE (symbolP))
3058 S_SET_VALUE (symbolP, last_file_symno);
3059 last_file_symno = symbol_number;
3060 } /* no one points at the first .file symbol */
3061 } /* if debug or tag or eos or file */
3063 #ifdef tc_frob_coff_symbol
3064 tc_frob_coff_symbol (symbolP);
3067 /* We must put the external symbols apart. The loader
3068 does not bomb if we do not. But the references in
3069 the endndx field for a .bb symbol are not corrected
3070 if an external symbol is removed between .bb and .be.
3071 I.e in the following case :
3072 [20] .bb endndx = 22
3075 ld will move the symbol 21 to the end of the list but
3076 endndx will still be 22 instead of 21. */
3078 if (SF_GET_LOCAL (symbolP))
3080 /* remove C_EFCN and LOCAL (L...) symbols */
3081 /* next pointer remains valid */
3082 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3085 else if (symbolP->sy_value.X_op == O_symbol
3086 && (! S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP)))
3088 /* Skip symbols which were equated to undefined or common
3090 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3092 else if (!S_IS_DEFINED (symbolP)
3093 && !S_IS_DEBUG (symbolP)
3094 && !SF_GET_STATICS (symbolP)
3095 && (S_GET_STORAGE_CLASS (symbolP) == C_EXT
3097 || S_GET_STORAGE_CLASS (symbolP) == C_NT_WEAK
3099 || S_GET_STORAGE_CLASS (symbolP) == C_WEAKEXT))
3101 /* if external, Remove from the list */
3102 symbolS *hold = symbol_previous (symbolP);
3104 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3105 symbol_clear_list_pointers (symbolP);
3106 symbol_append (symbolP, symbol_extern_lastP, &symbol_externP, &symbol_extern_lastP);
3109 else if (! S_IS_DEBUG (symbolP)
3110 && ! SF_GET_STATICS (symbolP)
3111 && ! SF_GET_FUNCTION (symbolP)
3112 && (S_GET_STORAGE_CLASS (symbolP) == C_EXT
3114 || S_GET_STORAGE_CLASS (symbolP) == C_NT_WEAK
3116 || S_GET_STORAGE_CLASS (symbolP) == C_NT_WEAK))
3118 symbolS *hold = symbol_previous (symbolP);
3120 /* The O'Reilly COFF book says that defined global symbols
3121 come at the end of the symbol table, just before
3122 undefined global symbols. */
3124 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3125 symbol_clear_list_pointers (symbolP);
3126 symbol_append (symbolP, symbol_global_lastP, &symbol_globalP,
3127 &symbol_global_lastP);
3132 if (SF_GET_STRING (symbolP))
3134 symbolP->sy_name_offset = string_byte_count;
3135 string_byte_count += strlen (S_GET_NAME (symbolP)) + 1;
3139 symbolP->sy_name_offset = 0;
3140 } /* fix "long" names */
3142 symbolP->sy_number = symbol_number;
3143 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (symbolP);
3144 } /* if local symbol */
3145 } /* traverse the symbol list */
3146 return symbol_number;
3151 glue_symbols (head, tail)
3155 unsigned int symbol_number = 0;
3157 while (*head != NULL)
3159 symbolS *tmp = *head;
3162 symbol_remove (tmp, head, tail);
3163 symbol_append (tmp, symbol_lastP, &symbol_rootP, &symbol_lastP);
3166 if (SF_GET_STRING (tmp))
3168 tmp->sy_name_offset = string_byte_count;
3169 string_byte_count += strlen (S_GET_NAME (tmp)) + 1;
3173 tmp->sy_name_offset = 0;
3174 } /* fix "long" names */
3176 tmp->sy_number = symbol_number;
3177 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (tmp);
3178 } /* append the entire extern chain */
3180 return symbol_number;
3186 unsigned int symbol_number = 0;
3189 for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
3191 symbolP->sy_number = symbol_number;
3193 if (SF_GET_TAGGED (symbolP))
3197 ((symbolS *) SA_GET_SYM_TAGNDX (symbolP))->sy_number);
3200 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (symbolP);
3203 return symbol_number;
3207 crawl_symbols (h, abfd)
3209 bfd *abfd ATTRIBUTE_UNUSED;
3213 /* Initialize the stack used to keep track of the matching .bb .be */
3215 block_stack = stack_init (512, sizeof (symbolS *));
3217 /* The symbol list should be ordered according to the following sequence
3220 * . debug entries for functions
3221 * . fake symbols for the sections, including .text .data and .bss
3223 * . undefined symbols
3224 * But this is not mandatory. The only important point is to put the
3225 * undefined symbols at the end of the list.
3228 /* Is there a .file symbol ? If not insert one at the beginning. */
3229 if (symbol_rootP == NULL
3230 || S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
3232 c_dot_file_symbol ("fake");
3236 * Build up static symbols for the sections, they are filled in later
3239 for (i = SEG_E0; i < SEG_LAST; i++)
3240 if (segment_info[i].scnhdr.s_name[0])
3241 segment_info[i].dot = c_section_symbol (segment_info[i].name,
3244 /* Take all the externals out and put them into another chain */
3245 H_SET_SYMBOL_TABLE_SIZE (h, yank_symbols ());
3246 /* Take the externals and glue them onto the end.*/
3247 H_SET_SYMBOL_TABLE_SIZE (h,
3248 (H_GET_SYMBOL_COUNT (h)
3249 + glue_symbols (&symbol_globalP,
3250 &symbol_global_lastP)
3251 + glue_symbols (&symbol_externP,
3252 &symbol_extern_lastP)));
3254 H_SET_SYMBOL_TABLE_SIZE (h, tie_tags ());
3255 know (symbol_globalP == NULL);
3256 know (symbol_global_lastP == NULL);
3257 know (symbol_externP == NULL);
3258 know (symbol_extern_lastP == NULL);
3262 * Find strings by crawling along symbol table chain.
3270 struct filename_list *filename_list_scan = filename_list_head;
3272 /* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
3273 md_number_to_chars (where, (valueT) string_byte_count, 4);
3276 #ifdef COFF_LONG_SECTION_NAMES
3277 /* Support long section names as found in PE. This code must
3278 coordinate with that in coff_header_append and write_object_file. */
3282 for (i = SEG_E0; i < SEG_LAST; i++)
3284 if (segment_info[i].scnhdr.s_name[0]
3285 && strlen (segment_info[i].name) > SCNNMLEN)
3289 size = strlen (segment_info[i].name) + 1;
3290 memcpy (where, segment_info[i].name, size);
3295 #endif /* COFF_LONG_SECTION_NAMES */
3297 for (symbolP = symbol_rootP;
3299 symbolP = symbol_next (symbolP))
3303 if (SF_GET_STRING (symbolP))
3305 size = strlen (S_GET_NAME (symbolP)) + 1;
3306 memcpy (where, S_GET_NAME (symbolP), size);
3309 if (S_GET_STORAGE_CLASS (symbolP) == C_FILE
3310 && SA_GET_FILE_FNAME_ZEROS (symbolP) == 0
3311 && SA_GET_FILE_FNAME_OFFSET (symbolP) != 0)
3313 size = strlen (filename_list_scan->filename) + 1;
3314 memcpy (where, filename_list_scan->filename, size);
3315 filename_list_scan = filename_list_scan ->next;
3322 do_linenos_for (abfd, h, file_cursor)
3325 unsigned long *file_cursor;
3328 unsigned long start = *file_cursor;
3330 for (idx = SEG_E0; idx < SEG_LAST; idx++)
3332 segment_info_type *s = segment_info + idx;
3334 if (s->scnhdr.s_nlnno != 0)
3336 struct lineno_list *line_ptr;
3338 struct external_lineno *buffer =
3339 (struct external_lineno *) xmalloc (s->scnhdr.s_nlnno * LINESZ);
3341 struct external_lineno *dst = buffer;
3343 /* Run through the table we've built and turn it into its external
3344 form, take this chance to remove duplicates */
3346 for (line_ptr = s->lineno_list_head;
3347 line_ptr != (struct lineno_list *) NULL;
3348 line_ptr = line_ptr->next)
3351 if (line_ptr->line.l_lnno == 0)
3353 /* Turn a pointer to a symbol into the symbols' index */
3354 line_ptr->line.l_addr.l_symndx =
3355 ((symbolS *) line_ptr->line.l_addr.l_symndx)->sy_number;
3359 line_ptr->line.l_addr.l_paddr += ((struct frag *) (line_ptr->frag))->fr_address;
3362 (void) bfd_coff_swap_lineno_out (abfd, &(line_ptr->line), dst);
3367 s->scnhdr.s_lnnoptr = *file_cursor;
3369 bfd_write (buffer, 1, s->scnhdr.s_nlnno * LINESZ, abfd);
3372 *file_cursor += s->scnhdr.s_nlnno * LINESZ;
3375 H_SET_LINENO_SIZE (h, *file_cursor - start);
3378 /* Now we run through the list of frag chains in a segment and
3379 make all the subsegment frags appear at the end of the
3380 list, as if the seg 0 was extra long */
3387 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3389 frchainS *head = segment_info[i].frchainP;
3391 fragS *prev_frag = &dummy;
3393 while (head && head->frch_seg == i)
3395 prev_frag->fr_next = head->frch_root;
3396 prev_frag = head->frch_last;
3397 head = head->frch_next;
3399 prev_frag->fr_next = 0;
3403 unsigned long machine;
3406 write_object_file ()
3410 struct frchain *frchain_ptr;
3412 object_headers headers;
3413 unsigned long file_cursor;
3416 abfd = bfd_openw (out_file_name, TARGET_FORMAT);
3420 as_perror (_("FATAL: Can't create %s"), out_file_name);
3421 exit (EXIT_FAILURE);
3423 bfd_set_format (abfd, bfd_object);
3424 bfd_set_arch_mach (abfd, BFD_ARCH, machine);
3426 string_byte_count = 4;
3428 for (frchain_ptr = frchain_root;
3429 frchain_ptr != (struct frchain *) NULL;
3430 frchain_ptr = frchain_ptr->frch_next)
3432 /* Run through all the sub-segments and align them up. Also
3433 close any open frags. We tack a .fill onto the end of the
3434 frag chain so that any .align's size can be worked by looking
3435 at the next frag. */
3437 subseg_set (frchain_ptr->frch_seg, frchain_ptr->frch_subseg);
3439 #ifndef SUB_SEGMENT_ALIGN
3440 #define SUB_SEGMENT_ALIGN(SEG) 1
3443 md_do_align (SUB_SEGMENT_ALIGN (now_seg), (char *) NULL, 0, 0,
3446 frag_align (SUB_SEGMENT_ALIGN (now_seg),
3447 subseg_text_p (now_seg) ? NOP_OPCODE : 0,
3452 frag_wane (frag_now);
3453 frag_now->fr_fix = 0;
3454 know (frag_now->fr_next == NULL);
3459 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3461 relax_segment (segment_info[i].frchainP->frch_root, i);
3464 H_SET_NUMBER_OF_SECTIONS (&headers, 0);
3466 /* Find out how big the sections are, and set the addresses. */
3468 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3472 segment_info[i].scnhdr.s_paddr = addr;
3473 segment_info[i].scnhdr.s_vaddr = addr;
3475 if (segment_info[i].scnhdr.s_name[0])
3477 H_SET_NUMBER_OF_SECTIONS (&headers,
3478 H_GET_NUMBER_OF_SECTIONS (&headers) + 1);
3480 #ifdef COFF_LONG_SECTION_NAMES
3481 /* Support long section names as found in PE. This code
3482 must coordinate with that in coff_header_append and
3487 len = strlen (segment_info[i].name);
3489 string_byte_count += len + 1;
3491 #endif /* COFF_LONG_SECTION_NAMES */
3494 size = size_section (abfd, (unsigned int) i);
3497 /* I think the section alignment is only used on the i960; the
3498 i960 needs it, and it should do no harm on other targets. */
3499 #ifdef ALIGNMENT_IN_S_FLAGS
3500 segment_info[i].scnhdr.s_flags |= (section_alignment[i] & 0xF) << 8;
3502 segment_info[i].scnhdr.s_align = 1 << section_alignment[i];
3506 H_SET_TEXT_SIZE (&headers, size);
3507 else if (i == SEG_E1)
3508 H_SET_DATA_SIZE (&headers, size);
3509 else if (i == SEG_E2)
3510 H_SET_BSS_SIZE (&headers, size);
3513 /* Turn the gas native symbol table shape into a coff symbol table */
3514 crawl_symbols (&headers, abfd);
3516 if (string_byte_count == 4)
3517 string_byte_count = 0;
3519 H_SET_STRING_SIZE (&headers, string_byte_count);
3525 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3527 fixup_mdeps (segment_info[i].frchainP->frch_root, &headers, i);
3528 fixup_segment (&segment_info[i], i);
3531 /* Look for ".stab" segments and fill in their initial symbols
3533 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3535 name = segment_info[i].name;
3538 && strncmp (".stab", name, 5) == 0
3539 && strncmp (".stabstr", name, 8) != 0)
3540 adjust_stab_section (abfd, i);
3543 file_cursor = H_GET_TEXT_FILE_OFFSET (&headers);
3545 bfd_seek (abfd, (file_ptr) file_cursor, 0);
3547 /* Plant the data */
3549 fill_section (abfd, &headers, &file_cursor);
3551 do_relocs_for (abfd, &headers, &file_cursor);
3553 do_linenos_for (abfd, &headers, &file_cursor);
3555 H_SET_FILE_MAGIC_NUMBER (&headers, COFF_MAGIC);
3556 #ifndef OBJ_COFF_OMIT_TIMESTAMP
3557 H_SET_TIME_STAMP (&headers, (long)time((time_t *)0));
3559 H_SET_TIME_STAMP (&headers, 0);
3561 #ifdef TC_COFF_SET_MACHINE
3562 TC_COFF_SET_MACHINE (&headers);
3566 #define COFF_FLAGS 0
3569 #ifdef KEEP_RELOC_INFO
3570 H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
3571 COFF_FLAGS | coff_flags));
3573 H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
3574 (H_GET_RELOCATION_SIZE(&headers) ? 0 : F_RELFLG) |
3575 COFF_FLAGS | coff_flags));
3579 unsigned int symtable_size = H_GET_SYMBOL_TABLE_SIZE (&headers);
3580 char *buffer1 = xmalloc (symtable_size + string_byte_count + 1);
3582 H_SET_SYMBOL_TABLE_POINTER (&headers, bfd_tell (abfd));
3583 w_symbols (abfd, buffer1, symbol_rootP);
3584 if (string_byte_count > 0)
3585 w_strings (buffer1 + symtable_size);
3586 bfd_write (buffer1, 1, symtable_size + string_byte_count, abfd);
3590 coff_header_append (abfd, &headers);
3592 /* Recent changes to write need this, but where it should
3593 go is up to Ken.. */
3594 if (bfd_close_all_done (abfd) == false)
3595 as_fatal (_("Can't close %s: %s"), out_file_name,
3596 bfd_errmsg (bfd_get_error ()));
3599 extern bfd *stdoutput;
3606 /* Add a new segment. This is called from subseg_new via the
3607 obj_new_segment macro. */
3610 obj_coff_add_segment (name)
3615 #ifndef COFF_LONG_SECTION_NAMES
3616 char buf[SCNNMLEN + 1];
3618 strncpy (buf, name, SCNNMLEN);
3619 buf[SCNNMLEN] = '\0';
3623 for (i = SEG_E0; i < SEG_LAST && segment_info[i].scnhdr.s_name[0]; i++)
3624 if (strcmp (name, segment_info[i].name) == 0)
3629 as_bad (_("Too many new sections; can't add \"%s\""), name);
3633 /* Add a new section. */
3634 strncpy (segment_info[i].scnhdr.s_name, name,
3635 sizeof (segment_info[i].scnhdr.s_name));
3636 segment_info[i].scnhdr.s_flags = STYP_REG;
3637 segment_info[i].name = xstrdup (name);
3643 * implement the .section pseudo op:
3644 * .section name {, "flags"}
3646 * | +--- optional flags: 'b' for bss
3648 * +-- section name 'l' for lib
3652 * 'd' (apparently m88k for data)
3654 * 'r' for read-only data
3655 * But if the argument is not a quoted string, treat it as a
3656 * subsegment number.
3660 obj_coff_section (ignore)
3661 int ignore ATTRIBUTE_UNUSED;
3663 /* Strip out the section name */
3664 char *section_name, *name;
3677 else if (type == 'D')
3679 segment_info[now_seg].scnhdr.s_flags |= flags;
3684 section_name = input_line_pointer;
3685 c = get_symbol_end ();
3687 name = xmalloc (input_line_pointer - section_name + 1);
3688 strcpy (name, section_name);
3690 *input_line_pointer = c;
3696 if (*input_line_pointer == ',')
3698 ++input_line_pointer;
3701 if (*input_line_pointer != '"')
3702 exp = get_absolute_expression ();
3705 ++input_line_pointer;
3706 while (*input_line_pointer != '"'
3707 && ! is_end_of_line[(unsigned char) *input_line_pointer])
3709 switch (*input_line_pointer)
3711 case 'b': flags |= STYP_BSS; break;
3712 case 'i': flags |= STYP_INFO; break;
3713 case 'l': flags |= STYP_LIB; break;
3714 case 'n': flags |= STYP_NOLOAD; break;
3715 case 'o': flags |= STYP_OVER; break;
3717 case 'w': flags |= STYP_DATA; break;
3718 case 'x': flags |= STYP_TEXT; break;
3719 case 'r': flags |= STYP_LIT; break;
3721 as_warn(_("unknown section attribute '%c'"),
3722 *input_line_pointer);
3725 ++input_line_pointer;
3727 if (*input_line_pointer == '"')
3728 ++input_line_pointer;
3732 subseg_new (name, (subsegT) exp);
3734 segment_info[now_seg].scnhdr.s_flags |= flags;
3736 demand_empty_rest_of_line ();
3740 obj_coff_text (ignore)
3741 int ignore ATTRIBUTE_UNUSED;
3743 subseg_new (".text", get_absolute_expression ());
3747 obj_coff_data (ignore)
3748 int ignore ATTRIBUTE_UNUSED;
3750 if (flag_readonly_data_in_text)
3751 subseg_new (".text", get_absolute_expression () + 1000);
3753 subseg_new (".data", get_absolute_expression ());
3757 obj_coff_ident (ignore)
3758 int ignore ATTRIBUTE_UNUSED;
3760 segT current_seg = now_seg; /* save current seg */
3761 subsegT current_subseg = now_subseg;
3762 subseg_new (".comment", 0); /* .comment seg */
3763 stringer (1); /* read string */
3764 subseg_set (current_seg, current_subseg); /* restore current seg */
3768 c_symbol_merge (debug, normal)
3772 S_SET_DATA_TYPE (normal, S_GET_DATA_TYPE (debug));
3773 S_SET_STORAGE_CLASS (normal, S_GET_STORAGE_CLASS (debug));
3775 if (S_GET_NUMBER_AUXILIARY (debug) > S_GET_NUMBER_AUXILIARY (normal))
3777 S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));
3778 } /* take the most we have */
3780 if (S_GET_NUMBER_AUXILIARY (debug) > 0)
3782 memcpy ((char *) &normal->sy_symbol.ost_auxent[0],
3783 (char *) &debug->sy_symbol.ost_auxent[0],
3784 (unsigned int) (S_GET_NUMBER_AUXILIARY (debug) * AUXESZ));
3785 } /* Move all the auxiliary information */
3787 /* Move the debug flags. */
3788 SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
3789 } /* c_symbol_merge() */
3792 c_line_new (symbol, paddr, line_number, frag)
3798 struct lineno_list *new_line =
3799 (struct lineno_list *) xmalloc (sizeof (struct lineno_list));
3801 segment_info_type *s = segment_info + now_seg;
3802 new_line->line.l_lnno = line_number;
3804 if (line_number == 0)
3806 last_line_symbol = symbol;
3807 new_line->line.l_addr.l_symndx = (long) symbol;
3811 new_line->line.l_addr.l_paddr = paddr;
3814 new_line->frag = (char *) frag;
3815 new_line->next = (struct lineno_list *) NULL;
3817 if (s->lineno_list_head == (struct lineno_list *) NULL)
3819 s->lineno_list_head = new_line;
3823 s->lineno_list_tail->next = new_line;
3825 s->lineno_list_tail = new_line;
3826 return LINESZ * s->scnhdr.s_nlnno++;
3830 c_dot_file_symbol (filename)
3835 symbolP = symbol_new (".file",
3838 &zero_address_frag);
3840 S_SET_STORAGE_CLASS (symbolP, C_FILE);
3841 S_SET_NUMBER_AUXILIARY (symbolP, 1);
3843 if (strlen (filename) > FILNMLEN)
3845 /* Filename is too long to fit into an auxent,
3846 we stick it into the string table instead. We keep
3847 a linked list of the filenames we find so we can emit
3849 struct filename_list *f = ((struct filename_list *)
3850 xmalloc (sizeof (struct filename_list)));
3852 f->filename = filename;
3855 SA_SET_FILE_FNAME_ZEROS (symbolP, 0);
3856 SA_SET_FILE_FNAME_OFFSET (symbolP, 1);
3858 if (filename_list_tail)
3859 filename_list_tail->next = f;
3861 filename_list_head = f;
3862 filename_list_tail = f;
3866 SA_SET_FILE_FNAME (symbolP, filename);
3873 listing_source_file (filename);
3879 SF_SET_DEBUG (symbolP);
3880 S_SET_VALUE (symbolP, (valueT) previous_file_symbol);
3882 previous_file_symbol = symbolP;
3884 /* Make sure that the symbol is first on the symbol chain */
3885 if (symbol_rootP != symbolP)
3887 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3888 symbol_insert (symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
3890 } /* c_dot_file_symbol() */
3893 * Build a 'section static' symbol.
3897 c_section_symbol (name, idx)
3903 symbolP = symbol_find_base (name, DO_NOT_STRIP);
3904 if (symbolP == NULL)
3905 symbolP = symbol_new (name, idx, 0, &zero_address_frag);
3908 /* Mmmm. I just love violating interfaces. Makes me feel...dirty. */
3909 S_SET_SEGMENT (symbolP, idx);
3910 symbolP->sy_frag = &zero_address_frag;
3913 S_SET_STORAGE_CLASS (symbolP, C_STAT);
3914 S_SET_NUMBER_AUXILIARY (symbolP, 1);
3916 SF_SET_STATICS (symbolP);
3919 /* manfred@s-direktnet.de: section symbols *must* have the LOCAL bit cleared,
3920 which is set by the new definition of LOCAL_LABEL in tc-m68k.h. */
3921 SF_CLEAR_LOCAL (symbolP);
3924 /* If the .linkonce pseudo-op was used for this section, we must
3925 store the information in the auxiliary entry for the section
3927 if (segment_info[idx].linkonce != LINKONCE_UNSET)
3931 switch (segment_info[idx].linkonce)
3935 case LINKONCE_DISCARD:
3936 type = IMAGE_COMDAT_SELECT_ANY;
3938 case LINKONCE_ONE_ONLY:
3939 type = IMAGE_COMDAT_SELECT_NODUPLICATES;
3941 case LINKONCE_SAME_SIZE:
3942 type = IMAGE_COMDAT_SELECT_SAME_SIZE;
3944 case LINKONCE_SAME_CONTENTS:
3945 type = IMAGE_COMDAT_SELECT_EXACT_MATCH;
3949 SYM_AUXENT (symbolP)->x_scn.x_comdat = type;
3954 } /* c_section_symbol() */
3957 w_symbols (abfd, where, symbol_rootP)
3960 symbolS * symbol_rootP;
3965 /* First fill in those values we have only just worked out */
3966 for (i = SEG_E0; i < SEG_LAST; i++)
3968 symbolP = segment_info[i].dot;
3971 SA_SET_SCN_SCNLEN (symbolP, segment_info[i].scnhdr.s_size);
3972 SA_SET_SCN_NRELOC (symbolP, segment_info[i].scnhdr.s_nreloc);
3973 SA_SET_SCN_NLINNO (symbolP, segment_info[i].scnhdr.s_nlnno);
3978 * Emit all symbols left in the symbol chain.
3980 for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
3982 /* Used to save the offset of the name. It is used to point
3983 to the string in memory but must be a file offset. */
3984 register char *temp;
3986 /* We can't fix the lnnoptr field in yank_symbols with the other
3987 adjustments, because we have to wait until we know where they
3989 if (SF_GET_ADJ_LNNOPTR (symbolP))
3991 SA_GET_SYM_LNNOPTR (symbolP) +=
3992 segment_info[S_GET_SEGMENT (symbolP)].scnhdr.s_lnnoptr;
3995 tc_coff_symbol_emit_hook (symbolP);
3997 temp = S_GET_NAME (symbolP);
3998 if (SF_GET_STRING (symbolP))
4000 S_SET_OFFSET (symbolP, symbolP->sy_name_offset);
4001 S_SET_ZEROES (symbolP, 0);
4005 memset (symbolP->sy_symbol.ost_entry.n_name, 0, SYMNMLEN);
4006 strncpy (symbolP->sy_symbol.ost_entry.n_name, temp, SYMNMLEN);
4008 where = symbol_to_chars (abfd, where, symbolP);
4009 S_SET_NAME (symbolP, temp);
4015 obj_coff_lcomm (ignore)
4016 int ignore ATTRIBUTE_UNUSED;
4028 name = input_line_pointer;
4030 c = get_symbol_end ();
4031 p = input_line_pointer;
4034 if (*input_line_pointer != ',')
4036 as_bad (_("Expected comma after name"));
4037 ignore_rest_of_line ();
4040 if (*input_line_pointer == '\n')
4042 as_bad (_("Missing size expression"));
4045 input_line_pointer++;
4046 if ((temp = get_absolute_expression ()) < 0)
4048 as_warn (_("lcomm length (%d.) <0! Ignored."), temp);
4049 ignore_rest_of_line ();
4054 symbolP = symbol_find_or_make(name);
4056 if (S_GET_SEGMENT(symbolP) == SEG_UNKNOWN &&
4057 S_GET_VALUE(symbolP) == 0)
4062 segT current_seg = now_seg; /* save current seg */
4063 subsegT current_subseg = now_subseg;
4065 subseg_set (SEG_E2, 1);
4066 symbolP->sy_frag = frag_now;
4067 p = frag_var(rs_org, 1, 1, (relax_substateT)0, symbolP,
4068 (offsetT) temp, (char *) 0);
4070 subseg_set (current_seg, current_subseg); /* restore current seg */
4071 S_SET_SEGMENT(symbolP, SEG_E2);
4072 S_SET_STORAGE_CLASS(symbolP, C_STAT);
4076 as_bad(_("Symbol %s already defined"), name);
4078 demand_empty_rest_of_line();
4083 fixup_mdeps (frags, h, this_segment)
4088 subseg_change (this_segment, 0);
4091 switch (frags->fr_type)
4097 HANDLE_ALIGN (frags);
4099 frags->fr_type = rs_fill;
4101 ((frags->fr_next->fr_address - frags->fr_address - frags->fr_fix)
4104 case rs_machine_dependent:
4105 md_convert_frag (h, this_segment, frags);
4111 frags = frags->fr_next;
4117 #ifndef TC_FORCE_RELOCATION
4118 #define TC_FORCE_RELOCATION(fix) 0
4122 fixup_segment (segP, this_segment_type)
4123 segment_info_type * segP;
4124 segT this_segment_type;
4126 register fixS * fixP;
4127 register symbolS *add_symbolP;
4128 register symbolS *sub_symbolP;
4131 register char *place;
4132 register long where;
4133 register char pcrel;
4134 register fragS *fragP;
4135 register segT add_symbol_segment = absolute_section;
4137 for (fixP = segP->fix_root; fixP; fixP = fixP->fx_next)
4139 fragP = fixP->fx_frag;
4141 where = fixP->fx_where;
4142 place = fragP->fr_literal + where;
4143 size = fixP->fx_size;
4144 add_symbolP = fixP->fx_addsy;
4145 sub_symbolP = fixP->fx_subsy;
4146 add_number = fixP->fx_offset;
4147 pcrel = fixP->fx_pcrel;
4149 /* We want function-relative stabs to work on systems which
4150 may use a relaxing linker; thus we must handle the sym1-sym2
4151 fixups function-relative stabs generates.
4153 Of course, if you actually enable relaxing in the linker, the
4154 line and block scoping information is going to be incorrect
4155 in some cases. The only way to really fix this is to support
4156 a reloc involving the difference of two symbols. */
4158 && (!sub_symbolP || pcrel))
4162 if (fixP->fx_tcbit && SF_GET_CALLNAME (add_symbolP))
4164 /* Relocation should be done via the associated 'bal' entry
4167 if (!SF_GET_BALNAME (tc_get_bal_of_call (add_symbolP)))
4169 as_bad_where (fixP->fx_file, fixP->fx_line,
4170 _("No 'bal' entry point for leafproc %s"),
4171 S_GET_NAME (add_symbolP));
4174 fixP->fx_addsy = add_symbolP = tc_get_bal_of_call (add_symbolP);
4178 /* Make sure the symbols have been resolved; this may not have
4179 happened if these are expression symbols. */
4180 if (add_symbolP != NULL && ! add_symbolP->sy_resolved)
4181 resolve_symbol_value (add_symbolP, 1);
4183 if (add_symbolP != NULL)
4185 /* If this fixup is against a symbol which has been equated
4186 to another symbol, convert it to the other symbol. */
4187 if (add_symbolP->sy_value.X_op == O_symbol
4188 && (! S_IS_DEFINED (add_symbolP)
4189 || S_IS_COMMON (add_symbolP)))
4191 while (add_symbolP->sy_value.X_op == O_symbol
4192 && (! S_IS_DEFINED (add_symbolP)
4193 || S_IS_COMMON (add_symbolP)))
4197 /* We must avoid looping, as that can occur with a
4198 badly written program. */
4199 n = add_symbolP->sy_value.X_add_symbol;
4200 if (n == add_symbolP)
4202 add_number += add_symbolP->sy_value.X_add_number;
4205 fixP->fx_addsy = add_symbolP;
4206 fixP->fx_offset = add_number;
4210 if (sub_symbolP != NULL && ! sub_symbolP->sy_resolved)
4211 resolve_symbol_value (sub_symbolP, 1);
4213 if (add_symbolP != NULL
4214 && add_symbolP->sy_mri_common)
4216 know (add_symbolP->sy_value.X_op == O_symbol);
4217 add_number += S_GET_VALUE (add_symbolP);
4218 fixP->fx_offset = add_number;
4219 add_symbolP = fixP->fx_addsy = add_symbolP->sy_value.X_add_symbol;
4224 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
4225 } /* if there is an addend */
4229 if (add_symbolP == NULL || add_symbol_segment == absolute_section)
4231 if (add_symbolP != NULL)
4233 add_number += S_GET_VALUE (add_symbolP);
4235 fixP->fx_addsy = NULL;
4238 /* It's just -sym. */
4239 if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
4241 add_number -= S_GET_VALUE (sub_symbolP);
4248 as_bad_where (fixP->fx_file, fixP->fx_line,
4249 _("Negative of non-absolute symbol %s"),
4250 S_GET_NAME (sub_symbolP));
4252 add_number -= S_GET_VALUE (sub_symbolP);
4253 } /* not absolute */
4255 /* if sub_symbol is in the same segment that add_symbol
4256 and add_symbol is either in DATA, TEXT, BSS or ABSOLUTE */
4258 else if (S_GET_SEGMENT (sub_symbolP) == add_symbol_segment
4259 && SEG_NORMAL (add_symbol_segment))
4261 /* Difference of 2 symbols from same segment. Can't
4262 make difference of 2 undefineds: 'value' means
4263 something different for N_UNDF. */
4265 /* Makes no sense to use the difference of 2 arbitrary symbols
4266 as the target of a call instruction. */
4269 as_bad_where (fixP->fx_file, fixP->fx_line,
4270 _("callj to difference of 2 symbols"));
4272 #endif /* TC_I960 */
4273 add_number += S_GET_VALUE (add_symbolP) -
4274 S_GET_VALUE (sub_symbolP);
4277 if (!TC_FORCE_RELOCATION (fixP))
4279 fixP->fx_addsy = NULL;
4280 fixP->fx_subsy = NULL;
4282 #ifdef TC_M68K /* is this right? */
4290 /* Different segments in subtraction. */
4291 know (!(S_IS_EXTERNAL (sub_symbolP) && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
4293 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
4295 add_number -= S_GET_VALUE (sub_symbolP);
4298 else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
4299 #if 0 /* Okay for 68k, at least... */
4304 /* Make it pc-relative. */
4305 add_number += (md_pcrel_from (fixP)
4306 - S_GET_VALUE (sub_symbolP));
4315 as_bad_where (fixP->fx_file, fixP->fx_line,
4316 _("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %ld."),
4317 segment_name (S_GET_SEGMENT (sub_symbolP)),
4318 S_GET_NAME (sub_symbolP),
4319 (long) (fragP->fr_address + where));
4322 } /* if sub_symbolP */
4326 if (add_symbol_segment == this_segment_type && pcrel)
4329 * This fixup was made when the symbol's segment was
4330 * SEG_UNKNOWN, but it is now in the local segment.
4331 * So we know how to do the address without relocation.
4334 /* reloc_callj() may replace a 'call' with a 'calls' or a 'bal',
4335 * in which cases it modifies *fixP as appropriate. In the case
4336 * of a 'calls', no further work is required, and *fixP has been
4337 * set up to make the rest of the code below a no-op.
4340 #endif /* TC_I960 */
4342 add_number += S_GET_VALUE (add_symbolP);
4343 add_number -= md_pcrel_from (fixP);
4346 add_number -= segP->scnhdr.s_vaddr;
4347 if defined (TC_I386) || defined (TE_LYNX). I now
4348 think that was an error propagated from the case when
4349 we are going to emit the relocation. If we are not
4350 going to emit the relocation, then we just want to
4351 set add_number to the difference between the symbols.
4352 This is a case that would only arise when there is a
4353 PC relative reference from a section other than .text
4354 to a symbol defined in the same section, and the
4355 reference is not relaxed. Since jump instructions on
4356 the i386 are relaxed, this could only arise with a
4357 call instruction. */
4359 pcrel = 0; /* Lie. Don't want further pcrel processing. */
4360 if (!TC_FORCE_RELOCATION (fixP))
4362 fixP->fx_addsy = NULL;
4368 switch (add_symbol_segment)
4370 case absolute_section:
4372 reloc_callj (fixP); /* See comment about reloc_callj() above*/
4373 #endif /* TC_I960 */
4374 add_number += S_GET_VALUE (add_symbolP);
4377 if (!TC_FORCE_RELOCATION (fixP))
4379 fixP->fx_addsy = NULL;
4385 #if defined(TC_A29K) || (defined(TE_PE) && defined(TC_I386)) || defined(TC_M88K)
4386 /* This really should be handled in the linker, but
4387 backward compatibility forbids. */
4388 add_number += S_GET_VALUE (add_symbolP);
4390 add_number += S_GET_VALUE (add_symbolP) +
4391 segment_info[S_GET_SEGMENT (add_symbolP)].scnhdr.s_paddr;
4397 if ((int) fixP->fx_bit_fixP == 13)
4399 /* This is a COBR instruction. They have only a
4400 * 13-bit displacement and are only to be used
4401 * for local branches: flag as error, don't generate
4404 as_bad_where (fixP->fx_file, fixP->fx_line,
4405 _("can't use COBR format with external label"));
4406 fixP->fx_addsy = NULL;
4410 #endif /* TC_I960 */
4411 #if ((defined (TC_I386) || defined (TE_LYNX) || defined (TE_AUX)) && !defined(TE_PE)) || defined (COFF_COMMON_ADDEND)
4412 /* 386 COFF uses a peculiar format in which the
4413 value of a common symbol is stored in the .text
4414 segment (I've checked this on SVR3.2 and SCO
4415 3.2.2) Ian Taylor <ian@cygnus.com>. */
4416 /* This is also true for 68k COFF on sysv machines
4417 (Checked on Motorola sysv68 R3V6 and R3V7.1, and also on
4418 UNIX System V/M68000, Release 1.0 from ATT/Bell Labs)
4419 Philippe De Muyter <phdm@info.ucl.ac.be>. */
4420 if (S_IS_COMMON (add_symbolP))
4421 add_number += S_GET_VALUE (add_symbolP);
4425 } /* switch on symbol seg */
4426 } /* if not in local seg */
4427 } /* if there was a + symbol */
4431 #if !defined(TC_M88K) && !(defined(TE_PE) && defined(TC_I386)) && !defined(TC_A29K)
4432 /* This adjustment is not correct on the m88k, for which the
4433 linker does all the computation. */
4434 add_number -= md_pcrel_from (fixP);
4436 if (add_symbolP == 0)
4438 fixP->fx_addsy = &abs_symbol;
4439 } /* if there's an add_symbol */
4440 #if defined (TC_I386) || defined (TE_LYNX) || defined (TC_I960) || defined (TC_M68K)
4441 /* On the 386 we must adjust by the segment vaddr as well.
4444 I changed the i960 to work this way as well. This is
4445 compatible with the current GNU linker behaviour. I do
4446 not know what other i960 COFF assemblers do. This is not
4447 a common case: normally, only assembler code will contain
4448 a PC relative reloc, and only branches which do not
4449 originate in the .text section will have a non-zero
4452 I changed the m68k to work this way as well. This will
4453 break existing PC relative relocs from sections which do
4454 not start at address 0, but it will make ld -r work.
4455 Ian Taylor, 4 Oct 96. */
4457 add_number -= segP->scnhdr.s_vaddr;
4461 #ifdef MD_APPLY_FIX3
4462 md_apply_fix3 (fixP, (valueT *) &add_number, this_segment_type);
4464 md_apply_fix (fixP, add_number);
4467 if (!fixP->fx_bit_fixP && ! fixP->fx_no_overflow)
4470 /* The m88k uses the offset field of the reloc to get around
4473 && ((add_number & ~0xFF)
4474 || (fixP->fx_signed && (add_number & 0x80)))
4475 && ((add_number & ~0xFF) != (-1 & ~0xFF)
4476 || (add_number & 0x80) == 0))
4478 && ((add_number & ~0xFFFF)
4479 || (fixP->fx_signed && (add_number & 0x8000)))
4480 && ((add_number & ~0xFFFF) != (-1 & ~0xFFFF)
4481 || (add_number & 0x8000) == 0)))
4483 as_bad_where (fixP->fx_file, fixP->fx_line,
4484 _("Value of %ld too large for field of %d bytes at 0x%lx"),
4485 (long) add_number, size,
4486 (unsigned long) (fragP->fr_address + where));
4489 #ifdef WARN_SIGNED_OVERFLOW_WORD
4490 /* Warn if a .word value is too large when treated as a
4491 signed number. We already know it is not too negative.
4492 This is to catch over-large switches generated by gcc on
4494 if (!flag_signed_overflow_ok
4496 && add_number > 0x7fff)
4497 as_bad_where (fixP->fx_file, fixP->fx_line,
4498 _("Signed .word overflow; switch may be too large; %ld at 0x%lx"),
4500 (unsigned long) (fragP->fr_address + where));
4502 } /* not a bit fix */
4503 } /* For each fixS in this segment. */
4504 } /* fixup_segment() */
4508 /* The first entry in a .stab section is special. */
4511 obj_coff_init_stab_section (seg)
4517 unsigned int stroff;
4519 /* Make space for this first symbol. */
4523 as_where (&file, (unsigned int *) NULL);
4524 stabstr_name = (char *) alloca (strlen (segment_info[seg].name) + 4);
4525 strcpy (stabstr_name, segment_info[seg].name);
4526 strcat (stabstr_name, "str");
4527 stroff = get_stab_string_offset (file, stabstr_name);
4529 md_number_to_chars (p, stroff, 4);
4532 /* Fill in the counts in the first entry in a .stab section. */
4535 adjust_stab_section(abfd, seg)
4539 segT stabstrseg = SEG_UNKNOWN;
4540 const char *secname, *name2;
4543 int i, strsz = 0, nsyms;
4544 fragS *frag = segment_info[seg].frchainP->frch_root;
4546 /* Look for the associated string table section. */
4548 secname = segment_info[seg].name;
4549 name = (char *) alloca (strlen (secname) + 4);
4550 strcpy (name, secname);
4551 strcat (name, "str");
4553 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
4555 name2 = segment_info[i].name;
4556 if (name2 != NULL && strncmp(name2, name, 8) == 0)
4563 /* If we found the section, get its size. */
4564 if (stabstrseg != SEG_UNKNOWN)
4565 strsz = size_section (abfd, stabstrseg);
4567 nsyms = size_section (abfd, seg) / 12 - 1;
4569 /* Look for the first frag of sufficient size for the initial stab
4570 symbol, and collect a pointer to it. */
4571 while (frag && frag->fr_fix < 12)
4572 frag = frag->fr_next;
4574 p = frag->fr_literal;
4577 /* Write in the number of stab symbols and the size of the string
4579 bfd_h_put_16 (abfd, (bfd_vma) nsyms, (bfd_byte *) p + 6);
4580 bfd_h_put_32 (abfd, (bfd_vma) strsz, (bfd_byte *) p + 8);
4583 #endif /* not BFD_ASSEMBLER */
4585 const pseudo_typeS coff_pseudo_table[] =
4587 {"def", obj_coff_def, 0},
4588 {"dim", obj_coff_dim, 0},
4589 {"endef", obj_coff_endef, 0},
4590 {"line", obj_coff_line, 0},
4591 {"ln", obj_coff_ln, 0},
4592 #ifdef BFD_ASSEMBLER
4593 {"loc", obj_coff_loc, 0},
4595 {"appline", obj_coff_ln, 1},
4596 {"scl", obj_coff_scl, 0},
4597 {"size", obj_coff_size, 0},
4598 {"tag", obj_coff_tag, 0},
4599 {"type", obj_coff_type, 0},
4600 {"val", obj_coff_val, 0},
4601 {"section", obj_coff_section, 0},
4602 {"sect", obj_coff_section, 0},
4603 /* FIXME: We ignore the MRI short attribute. */
4604 {"section.s", obj_coff_section, 0},
4605 {"sect.s", obj_coff_section, 0},
4606 /* We accept the .bss directive for backward compatibility with
4607 earlier versions of gas. */
4608 {"bss", obj_coff_bss, 0},
4609 {"weak", obj_coff_weak, 0},
4610 {"ident", obj_coff_ident, 0},
4611 #ifndef BFD_ASSEMBLER
4612 {"use", obj_coff_section, 0},
4613 {"text", obj_coff_text, 0},
4614 {"data", obj_coff_data, 0},
4615 {"lcomm", obj_coff_lcomm, 0},
4617 {"optim", s_ignore, 0}, /* For sun386i cc (?) */
4619 {"version", s_ignore, 0},
4620 {"ABORT", s_abort, 0},
4622 /* The m88k uses sdef instead of def. */
4623 {"sdef", obj_coff_def, 0},
4625 {NULL, NULL, 0} /* end sentinel */
4626 }; /* coff_pseudo_table */
4628 #ifdef BFD_ASSEMBLER
4630 /* Support for a COFF emulation. */
4632 static void coff_pop_insert PARAMS ((void));
4633 static int coff_separate_stab_sections PARAMS ((void));
4638 pop_insert (coff_pseudo_table);
4642 coff_separate_stab_sections ()
4647 const struct format_ops coff_format_ops =
4649 bfd_target_coff_flavour,
4650 0, /* dfl_leading_underscore */
4651 1, /* emit_section_symbols */
4656 0, /* frob_file_before_adjust */
4657 coff_frob_file_after_relocs,
4660 0, /* s_get_align */
4661 0, /* s_set_align */
4662 0, /* s_get_other */
4663 0, /* s_set_other */
4668 0, /* copy_symbol_attributes */
4669 0, /* generate_asm_lineno */
4670 0, /* process_stab */
4671 coff_separate_stab_sections,
4672 obj_coff_init_stab_section,
4673 0, /* sec_sym_ok_for_reloc */
4675 0, /* ecoff_set_ext */
4676 coff_obj_read_begin_hook,
4677 coff_obj_symbol_new_hook