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 */
735 SF_SET_DEBUG (def_symbol_in_progress);
736 S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
743 S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
753 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
760 as_warn (_("unexpected storage class %d"),
761 S_GET_STORAGE_CLASS (def_symbol_in_progress));
763 } /* switch on storage class */
765 /* Now that we have built a debug symbol, try to find if we should
766 merge with an existing symbol or not. If a symbol is C_EFCN or
767 absolute_section or untagged SEG_DEBUG it never merges. We also
768 don't merge labels, which are in a different namespace, nor
769 symbols which have not yet been defined since they are typically
770 unique, nor do we merge tags with non-tags. */
772 /* Two cases for functions. Either debug followed by definition or
773 definition followed by debug. For definition first, we will
774 merge the debug symbol into the definition. For debug first, the
775 lineno entry MUST point to the definition function or else it
776 will point off into space when obj_crawl_symbol_chain() merges
777 the debug symbol into the real symbol. Therefor, let's presume
778 the debug symbol is a real function reference. */
780 /* FIXME-SOON If for some reason the definition label/symbol is
781 never seen, this will probably leave an undefined symbol at link
784 if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN
785 || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_LABEL
786 || (!strcmp (bfd_get_section_name (stdoutput,
787 S_GET_SEGMENT (def_symbol_in_progress)),
789 && !SF_GET_TAG (def_symbol_in_progress))
790 || S_GET_SEGMENT (def_symbol_in_progress) == absolute_section
791 || ! symbol_constant_p (def_symbol_in_progress)
792 || (symbolP = symbol_find_base (S_GET_NAME (def_symbol_in_progress),
793 DO_NOT_STRIP)) == NULL
794 || SF_GET_TAG (def_symbol_in_progress) != SF_GET_TAG (symbolP))
796 /* If it already is at the end of the symbol list, do nothing */
797 if (def_symbol_in_progress != symbol_lastP)
799 symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
800 symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP,
806 /* This symbol already exists, merge the newly created symbol
807 into the old one. This is not mandatory. The linker can
808 handle duplicate symbols correctly. But I guess that it save
809 a *lot* of space if the assembly file defines a lot of
812 /* The debug entry (def_symbol_in_progress) is merged into the
813 previous definition. */
815 c_symbol_merge (def_symbol_in_progress, symbolP);
816 symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
818 def_symbol_in_progress = symbolP;
820 if (SF_GET_FUNCTION (def_symbol_in_progress)
821 || SF_GET_TAG (def_symbol_in_progress)
822 || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_STAT)
824 /* For functions, and tags, and static symbols, the symbol
825 *must* be where the debug symbol appears. Move the
826 existing symbol to the current place. */
827 /* If it already is at the end of the symbol list, do nothing */
828 if (def_symbol_in_progress != symbol_lastP)
830 symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
831 symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP, &symbol_lastP);
836 if (SF_GET_TAG (def_symbol_in_progress))
840 oldtag = symbol_find_base (S_GET_NAME (def_symbol_in_progress),
842 if (oldtag == NULL || ! SF_GET_TAG (oldtag))
843 tag_insert (S_GET_NAME (def_symbol_in_progress),
844 def_symbol_in_progress);
847 if (SF_GET_FUNCTION (def_symbol_in_progress))
849 know (sizeof (def_symbol_in_progress) <= sizeof (long));
850 set_function (def_symbol_in_progress);
851 SF_SET_PROCESS (def_symbol_in_progress);
855 /* That is, if this is the first time we've seen the
857 symbol_table_insert (def_symbol_in_progress);
858 } /* definition follows debug */
859 } /* Create the line number entry pointing to the function being defined */
861 def_symbol_in_progress = NULL;
862 demand_empty_rest_of_line ();
866 obj_coff_dim (ignore)
867 int ignore ATTRIBUTE_UNUSED;
871 if (def_symbol_in_progress == NULL)
873 as_warn (_(".dim pseudo-op used outside of .def/.endef: ignored."));
874 demand_empty_rest_of_line ();
876 } /* if not inside .def/.endef */
878 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
880 for (dim_index = 0; dim_index < DIMNUM; dim_index++)
883 SA_SET_SYM_DIMEN (def_symbol_in_progress, dim_index,
884 get_absolute_expression ());
886 switch (*input_line_pointer)
889 input_line_pointer++;
893 as_warn (_("badly formed .dim directive ignored"));
894 /* intentional fallthrough */
902 demand_empty_rest_of_line ();
906 obj_coff_line (ignore)
907 int ignore ATTRIBUTE_UNUSED;
911 if (def_symbol_in_progress == NULL)
913 /* Probably stabs-style line? */
918 this_base = get_absolute_expression ();
919 if (!strcmp (".bf", S_GET_NAME (def_symbol_in_progress)))
920 coff_line_base = this_base;
922 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
923 SA_SET_SYM_LNNO (def_symbol_in_progress, this_base);
925 demand_empty_rest_of_line ();
928 if (strcmp (".bf", S_GET_NAME (def_symbol_in_progress)) == 0)
933 listing_source_line ((unsigned int) this_base);
939 obj_coff_size (ignore)
940 int ignore ATTRIBUTE_UNUSED;
942 if (def_symbol_in_progress == NULL)
944 as_warn (_(".size pseudo-op used outside of .def/.endef ignored."));
945 demand_empty_rest_of_line ();
947 } /* if not inside .def/.endef */
949 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
950 SA_SET_SYM_SIZE (def_symbol_in_progress, get_absolute_expression ());
951 demand_empty_rest_of_line ();
955 obj_coff_scl (ignore)
956 int ignore ATTRIBUTE_UNUSED;
958 if (def_symbol_in_progress == NULL)
960 as_warn (_(".scl pseudo-op used outside of .def/.endef ignored."));
961 demand_empty_rest_of_line ();
963 } /* if not inside .def/.endef */
965 S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ());
966 demand_empty_rest_of_line ();
970 obj_coff_tag (ignore)
971 int ignore ATTRIBUTE_UNUSED;
976 if (def_symbol_in_progress == NULL)
978 as_warn (_(".tag pseudo-op used outside of .def/.endef ignored."));
979 demand_empty_rest_of_line ();
983 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
984 symbol_name = input_line_pointer;
985 name_end = get_symbol_end ();
987 #ifdef tc_canonicalize_symbol_name
988 symbol_name = tc_canonicalize_symbol_name (symbol_name);
991 /* Assume that the symbol referred to by .tag is always defined.
992 This was a bad assumption. I've added find_or_make. xoxorich. */
993 SA_SET_SYM_TAGNDX (def_symbol_in_progress,
994 tag_find_or_make (symbol_name));
995 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L)
997 as_warn (_("tag not found for .tag %s"), symbol_name);
1000 SF_SET_TAGGED (def_symbol_in_progress);
1001 *input_line_pointer = name_end;
1003 demand_empty_rest_of_line ();
1007 obj_coff_type (ignore)
1008 int ignore ATTRIBUTE_UNUSED;
1010 if (def_symbol_in_progress == NULL)
1012 as_warn (_(".type pseudo-op used outside of .def/.endef ignored."));
1013 demand_empty_rest_of_line ();
1015 } /* if not inside .def/.endef */
1017 S_SET_DATA_TYPE (def_symbol_in_progress, get_absolute_expression ());
1019 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress)) &&
1020 S_GET_STORAGE_CLASS (def_symbol_in_progress) != C_TPDEF)
1022 SF_SET_FUNCTION (def_symbol_in_progress);
1023 } /* is a function */
1025 demand_empty_rest_of_line ();
1029 obj_coff_val (ignore)
1030 int ignore ATTRIBUTE_UNUSED;
1032 if (def_symbol_in_progress == NULL)
1034 as_warn (_(".val pseudo-op used outside of .def/.endef ignored."));
1035 demand_empty_rest_of_line ();
1037 } /* if not inside .def/.endef */
1039 if (is_name_beginner (*input_line_pointer))
1041 char *symbol_name = input_line_pointer;
1042 char name_end = get_symbol_end ();
1044 #ifdef tc_canonicalize_symbol_name
1045 symbol_name = tc_canonicalize_symbol_name (symbol_name);
1047 if (!strcmp (symbol_name, "."))
1049 symbol_set_frag (def_symbol_in_progress, frag_now);
1050 S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
1051 /* If the .val is != from the .def (e.g. statics) */
1053 else if (strcmp (S_GET_NAME (def_symbol_in_progress), symbol_name))
1057 exp.X_op = O_symbol;
1058 exp.X_add_symbol = symbol_find_or_make (symbol_name);
1059 exp.X_op_symbol = NULL;
1060 exp.X_add_number = 0;
1061 symbol_set_value_expression (def_symbol_in_progress, &exp);
1063 /* If the segment is undefined when the forward reference is
1064 resolved, then copy the segment id from the forward
1066 SF_SET_GET_SEGMENT (def_symbol_in_progress);
1068 /* FIXME: gcc can generate address expressions here in
1069 unusual cases (search for "obscure" in sdbout.c). We
1070 just ignore the offset here, thus generating incorrect
1071 debugging information. We ignore the rest of the line
1074 /* Otherwise, it is the name of a non debug symbol and its value
1075 will be calculated later. */
1076 *input_line_pointer = name_end;
1080 S_SET_VALUE (def_symbol_in_progress, get_absolute_expression ());
1081 } /* if symbol based */
1083 demand_empty_rest_of_line ();
1087 coff_obj_read_begin_hook ()
1089 /* These had better be the same. Usually 18 bytes. */
1091 know (sizeof (SYMENT) == sizeof (AUXENT));
1092 know (SYMESZ == AUXESZ);
1098 symbolS *coff_last_function;
1099 static symbolS *coff_last_bf;
1102 coff_frob_symbol (symp, punt)
1106 static symbolS *last_tagP;
1107 static stack *block_stack;
1108 static symbolS *set_end;
1109 symbolS *next_set_end = NULL;
1111 if (symp == &abs_symbol)
1117 if (current_lineno_sym)
1118 coff_add_linesym ((symbolS *) 0);
1121 block_stack = stack_init (512, sizeof (symbolS*));
1123 if (S_IS_WEAK (symp))
1126 S_SET_STORAGE_CLASS (symp, C_NT_WEAK);
1128 S_SET_STORAGE_CLASS (symp, C_WEAKEXT);
1132 if (!S_IS_DEFINED (symp)
1133 && !S_IS_WEAK (symp)
1134 && S_GET_STORAGE_CLASS (symp) != C_STAT)
1135 S_SET_STORAGE_CLASS (symp, C_EXT);
1137 if (!SF_GET_DEBUG (symp))
1140 if (!SF_GET_LOCAL (symp)
1141 && !SF_GET_STATICS (symp)
1142 && (real = symbol_find_base (S_GET_NAME (symp), DO_NOT_STRIP))
1145 c_symbol_merge (symp, real);
1148 if (!S_IS_DEFINED (symp) && !SF_GET_LOCAL (symp))
1150 assert (S_GET_VALUE (symp) == 0);
1151 S_SET_EXTERNAL (symp);
1153 else if (S_GET_STORAGE_CLASS (symp) == C_NULL)
1155 if (S_GET_SEGMENT (symp) == text_section
1156 && symp != seg_info (text_section)->sym)
1157 S_SET_STORAGE_CLASS (symp, C_LABEL);
1159 S_SET_STORAGE_CLASS (symp, C_STAT);
1161 if (SF_GET_PROCESS (symp))
1163 if (S_GET_STORAGE_CLASS (symp) == C_BLOCK)
1165 if (!strcmp (S_GET_NAME (symp), ".bb"))
1166 stack_push (block_stack, (char *) &symp);
1170 begin = *(symbolS **) stack_pop (block_stack);
1172 as_warn (_("mismatched .eb"));
1174 next_set_end = begin;
1177 if (coff_last_function == 0 && SF_GET_FUNCTION (symp))
1179 union internal_auxent *auxp;
1180 coff_last_function = symp;
1181 if (S_GET_NUMBER_AUXILIARY (symp) < 1)
1182 S_SET_NUMBER_AUXILIARY (symp, 1);
1183 auxp = SYM_AUXENT (symp);
1184 memset (auxp->x_sym.x_fcnary.x_ary.x_dimen, 0,
1185 sizeof (auxp->x_sym.x_fcnary.x_ary.x_dimen));
1187 if (S_GET_STORAGE_CLASS (symp) == C_EFCN)
1189 if (coff_last_function == 0)
1190 as_fatal (_("C_EFCN symbol out of scope"));
1191 SA_SET_SYM_FSIZE (coff_last_function,
1192 (long) (S_GET_VALUE (symp)
1193 - S_GET_VALUE (coff_last_function)));
1194 next_set_end = coff_last_function;
1195 coff_last_function = 0;
1198 if (S_IS_EXTERNAL (symp))
1199 S_SET_STORAGE_CLASS (symp, C_EXT);
1200 else if (SF_GET_LOCAL (symp))
1203 if (SF_GET_FUNCTION (symp))
1204 symbol_get_bfdsym (symp)->flags |= BSF_FUNCTION;
1209 /* Double check weak symbols. */
1210 if (S_IS_WEAK (symp) && S_IS_COMMON (symp))
1211 as_bad (_("Symbol `%s' can not be both weak and common"),
1214 if (SF_GET_TAG (symp))
1216 else if (S_GET_STORAGE_CLASS (symp) == C_EOS)
1217 next_set_end = last_tagP;
1220 /* This is pretty horrible, but we have to set *punt correctly in
1221 order to call SA_SET_SYM_ENDNDX correctly. */
1222 if (! symbol_used_in_reloc_p (symp)
1223 && ((symbol_get_bfdsym (symp)->flags & BSF_SECTION_SYM) != 0
1224 || (! S_IS_EXTERNAL (symp)
1225 && ! symbol_get_tc (symp)->output
1226 && S_GET_STORAGE_CLASS (symp) != C_FILE)))
1230 if (set_end != (symbolS *) NULL
1232 && ((symbol_get_bfdsym (symp)->flags & BSF_NOT_AT_END) != 0
1233 || (S_IS_DEFINED (symp)
1234 && ! S_IS_COMMON (symp)
1235 && (! S_IS_EXTERNAL (symp) || SF_GET_FUNCTION (symp)))))
1237 SA_SET_SYM_ENDNDX (set_end, symp);
1241 if (next_set_end != NULL)
1243 if (set_end != NULL)
1244 as_warn ("Warning: internal error: forgetting to set endndx of %s",
1245 S_GET_NAME (set_end));
1246 set_end = next_set_end;
1250 && S_GET_STORAGE_CLASS (symp) == C_FCN
1251 && strcmp (S_GET_NAME (symp), ".bf") == 0)
1253 if (coff_last_bf != NULL)
1254 SA_SET_SYM_ENDNDX (coff_last_bf, symp);
1255 coff_last_bf = symp;
1258 if (coffsymbol (symbol_get_bfdsym (symp))->lineno)
1261 struct line_no *lptr;
1264 lptr = (struct line_no *) coffsymbol (symbol_get_bfdsym (symp))->lineno;
1265 for (i = 0; lptr; lptr = lptr->next)
1267 lptr = (struct line_no *) coffsymbol (symbol_get_bfdsym (symp))->lineno;
1269 /* We need i entries for line numbers, plus 1 for the first
1270 entry which BFD will override, plus 1 for the last zero
1271 entry (a marker for BFD). */
1272 l = (alent *) xmalloc ((i + 2) * sizeof (alent));
1273 coffsymbol (symbol_get_bfdsym (symp))->lineno = l;
1274 l[i + 1].line_number = 0;
1275 l[i + 1].u.sym = NULL;
1279 lptr->l.u.offset += lptr->frag->fr_address / OCTETS_PER_BYTE;
1287 coff_adjust_section_syms (abfd, sec, x)
1288 bfd *abfd ATTRIBUTE_UNUSED;
1290 PTR x ATTRIBUTE_UNUSED;
1293 segment_info_type *seginfo = seg_info (sec);
1294 int nlnno, nrelocs = 0;
1296 /* RS/6000 gas creates a .debug section manually in ppc_frob_file in
1297 tc-ppc.c. Do not get confused by it. */
1298 if (seginfo == NULL)
1301 if (!strcmp (sec->name, ".text"))
1302 nlnno = coff_n_line_nos;
1306 /* @@ Hope that none of the fixups expand to more than one reloc
1308 fixS *fixp = seginfo->fix_root;
1311 if (! fixp->fx_done)
1313 fixp = fixp->fx_next;
1316 if (bfd_get_section_size_before_reloc (sec) == 0
1319 && sec != text_section
1320 && sec != data_section
1321 && sec != bss_section)
1323 secsym = section_symbol (sec);
1324 /* This is an estimate; we'll plug in the real value using
1325 SET_SECTION_RELOCS later */
1326 SA_SET_SCN_NRELOC (secsym, nrelocs);
1327 SA_SET_SCN_NLINNO (secsym, nlnno);
1331 coff_frob_file_after_relocs ()
1333 bfd_map_over_sections (stdoutput, coff_adjust_section_syms, (char*) 0);
1337 * implement the .section pseudo op:
1338 * .section name {, "flags"}
1340 * | +--- optional flags: 'b' for bss
1342 * +-- section name 'l' for lib
1346 * 'd' (apparently m88k for data)
1348 * 'r' for read-only data
1349 * 's' for shared data (PE)
1350 * But if the argument is not a quoted string, treat it as a
1351 * subsegment number.
1355 obj_coff_section (ignore)
1356 int ignore ATTRIBUTE_UNUSED;
1358 /* Strip out the section name */
1363 flagword flags, oldflags;
1374 section_name = input_line_pointer;
1375 c = get_symbol_end ();
1377 name = xmalloc (input_line_pointer - section_name + 1);
1378 strcpy (name, section_name);
1380 *input_line_pointer = c;
1385 flags = SEC_NO_FLAGS;
1387 if (*input_line_pointer == ',')
1389 ++input_line_pointer;
1391 if (*input_line_pointer != '"')
1392 exp = get_absolute_expression ();
1395 ++input_line_pointer;
1396 while (*input_line_pointer != '"'
1397 && ! is_end_of_line[(unsigned char) *input_line_pointer])
1399 switch (*input_line_pointer)
1401 case 'b': flags |= SEC_ALLOC; flags &=~ SEC_LOAD; break;
1402 case 'n': flags &=~ SEC_LOAD; break;
1403 case 'd': flags |= SEC_DATA | SEC_LOAD; /* fall through */
1404 case 'w': flags &=~ SEC_READONLY; break;
1405 case 'x': flags |= SEC_CODE | SEC_LOAD; break;
1406 case 'r': flags |= SEC_READONLY; break;
1407 case 's': flags |= SEC_SHARED; break;
1409 case 'i': /* STYP_INFO */
1410 case 'l': /* STYP_LIB */
1411 case 'o': /* STYP_OVER */
1412 as_warn (_("unsupported section attribute '%c'"),
1413 *input_line_pointer);
1417 as_warn(_("unknown section attribute '%c'"),
1418 *input_line_pointer);
1421 ++input_line_pointer;
1423 if (*input_line_pointer == '"')
1424 ++input_line_pointer;
1428 sec = subseg_new (name, (subsegT) exp);
1430 oldflags = bfd_get_section_flags (stdoutput, sec);
1431 if (oldflags == SEC_NO_FLAGS)
1433 /* Set section flags for a new section just created by subseg_new.
1434 Provide a default if no flags were parsed. */
1435 if (flags == SEC_NO_FLAGS)
1436 flags = TC_COFF_SECTION_DEFAULT_ATTRIBUTES;
1438 #ifdef COFF_LONG_SECTION_NAMES
1439 /* Add SEC_LINK_ONCE and SEC_LINK_DUPLICATES_DISCARD to .gnu.linkonce
1440 sections so adjust_reloc_syms in write.c will correctly handle
1441 relocs which refer to non-local symbols in these sections. */
1442 if (strncmp (name, ".gnu.linkonce", sizeof(".gnu.linkonce") - 1) == 0)
1443 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1446 if (! bfd_set_section_flags (stdoutput, sec, flags))
1447 as_warn (_("error setting flags for \"%s\": %s"),
1448 bfd_section_name (stdoutput, sec),
1449 bfd_errmsg (bfd_get_error ()));
1451 else if (flags != SEC_NO_FLAGS)
1453 /* This section's attributes have already been set. Warn if the
1454 attributes don't match. */
1455 flagword matchflags = SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE
1456 | SEC_DATA | SEC_SHARED;
1457 if ((flags ^ oldflags) & matchflags)
1458 as_warn (_("Ignoring changed section attributes for %s"), name);
1461 demand_empty_rest_of_line ();
1465 coff_adjust_symtab ()
1467 if (symbol_rootP == NULL
1468 || S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
1469 c_dot_file_symbol ("fake");
1473 coff_frob_section (sec)
1479 bfd_vma size, n_entries, mask;
1480 bfd_vma align_power = (bfd_vma)sec->alignment_power + OCTETS_PER_BYTE_POWER;
1482 /* The COFF back end in BFD requires that all section sizes be
1483 rounded up to multiples of the corresponding section alignments,
1484 supposedly because standard COFF has no other way of encoding alignment
1485 for sections. If your COFF flavor has a different way of encoding
1486 section alignment, then skip this step, as TICOFF does. */
1487 size = bfd_get_section_size_before_reloc (sec);
1488 mask = ((bfd_vma) 1 << align_power) - 1;
1489 #if !defined(TICOFF)
1492 size = (size + mask) & ~mask;
1493 bfd_set_section_size (stdoutput, sec, size);
1497 /* If the section size is non-zero, the section symbol needs an aux
1498 entry associated with it, indicating the size. We don't know
1499 all the values yet; coff_frob_symbol will fill them in later. */
1502 || sec == text_section
1503 || sec == data_section
1504 || sec == bss_section)
1507 symbolS *secsym = section_symbol (sec);
1509 S_SET_STORAGE_CLASS (secsym, C_STAT);
1510 S_SET_NUMBER_AUXILIARY (secsym, 1);
1511 SF_SET_STATICS (secsym);
1512 SA_SET_SCN_SCNLEN (secsym, size);
1515 /* @@ these should be in a "stabs.h" file, or maybe as.h */
1516 #ifndef STAB_SECTION_NAME
1517 #define STAB_SECTION_NAME ".stab"
1519 #ifndef STAB_STRING_SECTION_NAME
1520 #define STAB_STRING_SECTION_NAME ".stabstr"
1522 if (strcmp (STAB_STRING_SECTION_NAME, sec->name))
1526 sec = subseg_get (STAB_SECTION_NAME, 0);
1527 /* size is already rounded up, since other section will be listed first */
1528 size = bfd_get_section_size_before_reloc (strsec);
1530 n_entries = bfd_get_section_size_before_reloc (sec) / 12 - 1;
1532 /* Find first non-empty frag. It should be large enough. */
1533 fragp = seg_info (sec)->frchainP->frch_root;
1534 while (fragp && fragp->fr_fix == 0)
1535 fragp = fragp->fr_next;
1536 assert (fragp != 0 && fragp->fr_fix >= 12);
1538 /* Store the values. */
1539 p = fragp->fr_literal;
1540 bfd_h_put_16 (stdoutput, n_entries, (bfd_byte *) p + 6);
1541 bfd_h_put_32 (stdoutput, size, (bfd_byte *) p + 8);
1545 obj_coff_init_stab_section (seg)
1551 unsigned int stroff;
1553 /* Make space for this first symbol. */
1557 as_where (&file, (unsigned int *) NULL);
1558 stabstr_name = (char *) alloca (strlen (seg->name) + 4);
1559 strcpy (stabstr_name, seg->name);
1560 strcat (stabstr_name, "str");
1561 stroff = get_stab_string_offset (file, stabstr_name);
1563 md_number_to_chars (p, stroff, 4);
1572 return ((s == NULL) ? "(NULL)" : S_GET_NAME (s));
1580 for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
1582 printf(_("0x%lx: \"%s\" type = %ld, class = %d, segment = %d\n"),
1583 (unsigned long) symbolP,
1584 S_GET_NAME(symbolP),
1585 (long) S_GET_DATA_TYPE(symbolP),
1586 S_GET_STORAGE_CLASS(symbolP),
1587 (int) S_GET_SEGMENT(symbolP));
1593 #else /* not BFD_ASSEMBLER */
1596 /* This is needed because we include internal bfd things. */
1600 #include "libcoff.h"
1603 #include "coff/pe.h"
1606 /* The NOP_OPCODE is for the alignment fill value. Fill with nop so
1607 that we can stick sections together without causing trouble. */
1609 #define NOP_OPCODE 0x00
1612 /* The zeroes if symbol name is longer than 8 chars */
1613 #define S_SET_ZEROES(s,v) ((s)->sy_symbol.ost_entry.n_zeroes = (v))
1615 #define MIN(a,b) ((a) < (b)? (a) : (b))
1617 /* This vector is used to turn a gas internal segment number into a
1618 section number suitable for insertion into a coff symbol table.
1619 This must correspond to seg_info_off_by_4. */
1621 const short seg_N_TYPE[] =
1622 { /* in: segT out: N_TYPE bits */
1624 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
1625 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
1626 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
1627 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
1628 C_UNDEF_SECTION, /* SEG_UNKNOWN */
1629 C_UNDEF_SECTION, /* SEG_GOOF */
1630 C_UNDEF_SECTION, /* SEG_EXPR */
1631 C_DEBUG_SECTION, /* SEG_DEBUG */
1632 C_NTV_SECTION, /* SEG_NTV */
1633 C_PTV_SECTION, /* SEG_PTV */
1634 C_REGISTER_SECTION, /* SEG_REGISTER */
1637 int function_lineoff = -1; /* Offset in line#s where the last function
1638 started (the odd entry for line #0) */
1640 /* structure used to keep the filenames which
1641 are too long around so that we can stick them
1642 into the string table */
1643 struct filename_list
1646 struct filename_list *next;
1649 static struct filename_list *filename_list_head;
1650 static struct filename_list *filename_list_tail;
1652 static symbolS *last_line_symbol;
1654 /* Add 4 to the real value to get the index and compensate the
1655 negatives. This vector is used by S_GET_SEGMENT to turn a coff
1656 section number into a segment number
1658 static symbolS *previous_file_symbol;
1659 void c_symbol_merge ();
1660 static int line_base;
1662 symbolS *c_section_symbol ();
1665 static void fixup_segment PARAMS ((segment_info_type *segP,
1666 segT this_segment_type));
1669 static void fixup_mdeps PARAMS ((fragS *,
1674 static void fill_section PARAMS ((bfd * abfd,
1679 static int c_line_new PARAMS ((symbolS * symbol, long paddr,
1684 static void w_symbols PARAMS ((bfd * abfd, char *where,
1685 symbolS * symbol_rootP));
1687 static void adjust_stab_section PARAMS ((bfd *abfd, segT seg));
1689 static void obj_coff_lcomm PARAMS ((int));
1690 static void obj_coff_text PARAMS ((int));
1691 static void obj_coff_data PARAMS ((int));
1692 void obj_coff_section PARAMS ((int));
1694 /* When not using BFD_ASSEMBLER, we permit up to 40 sections.
1696 This array maps a COFF section number into a gas section number.
1697 Because COFF uses negative section numbers, you must add 4 to the
1698 COFF section number when indexing into this array; this is done via
1699 the SEG_INFO_FROM_SECTION_NUMBER macro. This must correspond to
1702 static const segT seg_info_off_by_4[] =
1709 SEG_E0, SEG_E1, SEG_E2, SEG_E3, SEG_E4,
1710 SEG_E5, SEG_E6, SEG_E7, SEG_E8, SEG_E9,
1711 SEG_E10, SEG_E11, SEG_E12, SEG_E13, SEG_E14,
1712 SEG_E15, SEG_E16, SEG_E17, SEG_E18, SEG_E19,
1713 SEG_E20, SEG_E21, SEG_E22, SEG_E23, SEG_E24,
1714 SEG_E25, SEG_E26, SEG_E27, SEG_E28, SEG_E29,
1715 SEG_E30, SEG_E31, SEG_E32, SEG_E33, SEG_E34,
1716 SEG_E35, SEG_E36, SEG_E37, SEG_E38, SEG_E39,
1729 #define SEG_INFO_FROM_SECTION_NUMBER(x) (seg_info_off_by_4[(x)+4])
1731 static relax_addressT
1732 relax_align (address, alignment)
1733 relax_addressT address;
1736 relax_addressT mask;
1737 relax_addressT new_address;
1739 mask = ~((~0) << alignment);
1740 new_address = (address + mask) & (~mask);
1741 return (new_address - address);
1749 return SEG_INFO_FROM_SECTION_NUMBER (x->sy_symbol.ost_entry.n_scnum);
1752 /* calculate the size of the frag chain and fill in the section header
1753 to contain all of it, also fill in the addr of the sections */
1755 size_section (abfd, idx)
1756 bfd *abfd ATTRIBUTE_UNUSED;
1760 unsigned int size = 0;
1761 fragS *frag = segment_info[idx].frchainP->frch_root;
1764 size = frag->fr_address;
1765 if (frag->fr_address != size)
1767 fprintf (stderr, _("Out of step\n"));
1768 size = frag->fr_address;
1771 switch (frag->fr_type)
1773 #ifdef TC_COFF_SIZEMACHDEP
1774 case rs_machine_dependent:
1775 size += TC_COFF_SIZEMACHDEP (frag);
1779 assert (frag->fr_symbol == 0);
1782 size += frag->fr_fix;
1783 size += frag->fr_offset * frag->fr_var;
1790 size += frag->fr_fix;
1791 off = relax_align (size, frag->fr_offset);
1792 if (frag->fr_subtype != 0 && off > frag->fr_subtype)
1798 BAD_CASE (frag->fr_type);
1801 frag = frag->fr_next;
1803 segment_info[idx].scnhdr.s_size = size;
1809 count_entries_in_chain (idx)
1812 unsigned int nrelocs;
1815 /* Count the relocations */
1816 fixup_ptr = segment_info[idx].fix_root;
1818 while (fixup_ptr != (fixS *) NULL)
1820 if (fixup_ptr->fx_done == 0 && TC_COUNT_RELOC (fixup_ptr))
1823 if (fixup_ptr->fx_r_type == RELOC_CONSTH)
1832 fixup_ptr = fixup_ptr->fx_next;
1839 static int compare_external_relocs PARAMS ((const PTR, const PTR));
1841 /* AUX's ld expects relocations to be sorted */
1843 compare_external_relocs (x, y)
1847 struct external_reloc *a = (struct external_reloc *) x;
1848 struct external_reloc *b = (struct external_reloc *) y;
1849 bfd_vma aadr = bfd_getb32 (a->r_vaddr);
1850 bfd_vma badr = bfd_getb32 (b->r_vaddr);
1851 return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
1856 /* output all the relocations for a section */
1858 do_relocs_for (abfd, h, file_cursor)
1861 unsigned long *file_cursor;
1863 unsigned int nrelocs;
1865 unsigned long reloc_start = *file_cursor;
1867 for (idx = SEG_E0; idx < SEG_LAST; idx++)
1869 if (segment_info[idx].scnhdr.s_name[0])
1871 struct external_reloc *ext_ptr;
1872 struct external_reloc *external_reloc_vec;
1873 unsigned int external_reloc_size;
1874 unsigned int base = segment_info[idx].scnhdr.s_paddr;
1875 fixS *fix_ptr = segment_info[idx].fix_root;
1876 nrelocs = count_entries_in_chain (idx);
1879 /* Bypass this stuff if no relocs. This also incidentally
1880 avoids a SCO bug, where free(malloc(0)) tends to crash. */
1882 external_reloc_size = nrelocs * RELSZ;
1883 external_reloc_vec =
1884 (struct external_reloc *) malloc (external_reloc_size);
1886 ext_ptr = external_reloc_vec;
1888 /* Fill in the internal coff style reloc struct from the
1889 internal fix list. */
1892 struct internal_reloc intr;
1894 /* Only output some of the relocations */
1895 if (fix_ptr->fx_done == 0 && TC_COUNT_RELOC (fix_ptr))
1897 #ifdef TC_RELOC_MANGLE
1898 TC_RELOC_MANGLE (&segment_info[idx], fix_ptr, &intr,
1903 symbolS *symbol_ptr = fix_ptr->fx_addsy;
1905 intr.r_type = TC_COFF_FIX2RTYPE (fix_ptr);
1907 base + fix_ptr->fx_frag->fr_address + fix_ptr->fx_where;
1909 #ifdef TC_KEEP_FX_OFFSET
1910 intr.r_offset = fix_ptr->fx_offset;
1915 while (symbol_ptr->sy_value.X_op == O_symbol
1916 && (! S_IS_DEFINED (symbol_ptr)
1917 || S_IS_COMMON (symbol_ptr)))
1921 /* We must avoid looping, as that can occur
1922 with a badly written program. */
1923 n = symbol_ptr->sy_value.X_add_symbol;
1924 if (n == symbol_ptr)
1929 /* Turn the segment of the symbol into an offset. */
1932 resolve_symbol_value (symbol_ptr, 1);
1933 if (! symbol_ptr->sy_resolved)
1938 if (expr_symbol_where (symbol_ptr, &file, &line))
1939 as_bad_where (file, line,
1940 _("unresolved relocation"));
1942 as_bad (_("bad relocation: symbol `%s' not in symbol table"),
1943 S_GET_NAME (symbol_ptr));
1945 dot = segment_info[S_GET_SEGMENT (symbol_ptr)].dot;
1948 intr.r_symndx = dot->sy_number;
1952 intr.r_symndx = symbol_ptr->sy_number;
1962 (void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
1965 #if defined(TC_A29K)
1967 /* The 29k has a special kludge for the high 16 bit
1968 reloc. Two relocations are emited, R_IHIHALF,
1969 and R_IHCONST. The second one doesn't contain a
1970 symbol, but uses the value for offset. */
1972 if (intr.r_type == R_IHIHALF)
1974 /* now emit the second bit */
1975 intr.r_type = R_IHCONST;
1976 intr.r_symndx = fix_ptr->fx_addnumber;
1977 (void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
1983 fix_ptr = fix_ptr->fx_next;
1987 /* Sort the reloc table */
1988 qsort ((PTR) external_reloc_vec, nrelocs,
1989 sizeof (struct external_reloc), compare_external_relocs);
1992 /* Write out the reloc table */
1993 bfd_write ((PTR) external_reloc_vec, 1, external_reloc_size,
1995 free (external_reloc_vec);
1997 /* Fill in section header info. */
1998 segment_info[idx].scnhdr.s_relptr = *file_cursor;
1999 *file_cursor += external_reloc_size;
2000 segment_info[idx].scnhdr.s_nreloc = nrelocs;
2005 segment_info[idx].scnhdr.s_relptr = 0;
2009 /* Set relocation_size field in file headers */
2010 H_SET_RELOCATION_SIZE (h, *file_cursor - reloc_start, 0);
2014 /* run through a frag chain and write out the data to go with it, fill
2015 in the scnhdrs with the info on the file postions
2018 fill_section (abfd, h, file_cursor)
2020 object_headers *h ATTRIBUTE_UNUSED;
2021 unsigned long *file_cursor;
2025 unsigned int paddr = 0;
2027 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
2029 unsigned int offset = 0;
2030 struct internal_scnhdr *s = &(segment_info[i].scnhdr);
2036 fragS *frag = segment_info[i].frchainP->frch_root;
2043 buffer = xmalloc (s->s_size);
2044 s->s_scnptr = *file_cursor;
2046 know (s->s_paddr == paddr);
2048 if (strcmp (s->s_name, ".text") == 0)
2049 s->s_flags |= STYP_TEXT;
2050 else if (strcmp (s->s_name, ".data") == 0)
2051 s->s_flags |= STYP_DATA;
2052 else if (strcmp (s->s_name, ".bss") == 0)
2055 s->s_flags |= STYP_BSS;
2057 /* @@ Should make the i386 and a29k coff targets define
2058 COFF_NOLOAD_PROBLEM, and have only one test here. */
2061 #ifndef COFF_NOLOAD_PROBLEM
2062 /* Apparently the SVR3 linker (and exec syscall) and UDI
2063 mondfe progrem are confused by noload sections. */
2064 s->s_flags |= STYP_NOLOAD;
2069 else if (strcmp (s->s_name, ".lit") == 0)
2070 s->s_flags = STYP_LIT | STYP_TEXT;
2071 else if (strcmp (s->s_name, ".init") == 0)
2072 s->s_flags |= STYP_TEXT;
2073 else if (strcmp (s->s_name, ".fini") == 0)
2074 s->s_flags |= STYP_TEXT;
2075 else if (strncmp (s->s_name, ".comment", 8) == 0)
2076 s->s_flags |= STYP_INFO;
2080 unsigned int fill_size;
2081 switch (frag->fr_type)
2083 case rs_machine_dependent:
2086 memcpy (buffer + frag->fr_address,
2088 (unsigned int) frag->fr_fix);
2089 offset += frag->fr_fix;
2094 assert (frag->fr_symbol == 0);
2101 memcpy (buffer + frag->fr_address,
2103 (unsigned int) frag->fr_fix);
2104 offset += frag->fr_fix;
2107 fill_size = frag->fr_var;
2108 if (fill_size && frag->fr_offset > 0)
2111 unsigned int off = frag->fr_fix;
2112 for (count = frag->fr_offset; count; count--)
2114 if (fill_size + frag->fr_address + off <= s->s_size)
2116 memcpy (buffer + frag->fr_address + off,
2117 frag->fr_literal + frag->fr_fix,
2120 offset += fill_size;
2125 case rs_broken_word:
2130 frag = frag->fr_next;
2135 if (s->s_scnptr != 0)
2137 bfd_write (buffer, s->s_size, 1, abfd);
2138 *file_cursor += s->s_size;
2147 /* Coff file generation & utilities */
2150 coff_header_append (abfd, h)
2157 #ifdef COFF_LONG_SECTION_NAMES
2158 unsigned long string_size = 4;
2161 bfd_seek (abfd, 0, 0);
2163 #ifndef OBJ_COFF_OMIT_OPTIONAL_HEADER
2164 H_SET_MAGIC_NUMBER (h, COFF_MAGIC);
2165 H_SET_VERSION_STAMP (h, 0);
2166 H_SET_ENTRY_POINT (h, 0);
2167 H_SET_TEXT_START (h, segment_info[SEG_E0].frchainP->frch_root->fr_address);
2168 H_SET_DATA_START (h, segment_info[SEG_E1].frchainP->frch_root->fr_address);
2169 H_SET_SIZEOF_OPTIONAL_HEADER (h, bfd_coff_swap_aouthdr_out(abfd, &h->aouthdr,
2171 #else /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
2172 H_SET_SIZEOF_OPTIONAL_HEADER (h, 0);
2173 #endif /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
2175 i = bfd_coff_swap_filehdr_out (abfd, &h->filehdr, buffer);
2177 bfd_write (buffer, i, 1, abfd);
2178 bfd_write (buffero, H_GET_SIZEOF_OPTIONAL_HEADER (h), 1, abfd);
2180 for (i = SEG_E0; i < SEG_LAST; i++)
2182 if (segment_info[i].scnhdr.s_name[0])
2186 #ifdef COFF_LONG_SECTION_NAMES
2187 /* Support long section names as found in PE. This code
2188 must coordinate with that in write_object_file and
2190 if (strlen (segment_info[i].name) > SCNNMLEN)
2192 memset (segment_info[i].scnhdr.s_name, 0, SCNNMLEN);
2193 sprintf (segment_info[i].scnhdr.s_name, "/%lu", string_size);
2194 string_size += strlen (segment_info[i].name) + 1;
2198 size = bfd_coff_swap_scnhdr_out (abfd,
2199 &(segment_info[i].scnhdr),
2202 as_bad (_("bfd_coff_swap_scnhdr_out failed"));
2203 bfd_write (buffer, size, 1, abfd);
2210 symbol_to_chars (abfd, where, symbolP)
2215 unsigned int numaux = symbolP->sy_symbol.ost_entry.n_numaux;
2219 /* Turn any symbols with register attributes into abs symbols */
2220 if (S_GET_SEGMENT (symbolP) == reg_section)
2222 S_SET_SEGMENT (symbolP, absolute_section);
2224 /* At the same time, relocate all symbols to their output value */
2227 val = (segment_info[S_GET_SEGMENT (symbolP)].scnhdr.s_paddr
2228 + S_GET_VALUE (symbolP));
2230 val = S_GET_VALUE (symbolP);
2233 S_SET_VALUE (symbolP, val);
2235 symbolP->sy_symbol.ost_entry.n_value = val;
2237 where += bfd_coff_swap_sym_out (abfd, &symbolP->sy_symbol.ost_entry,
2240 for (i = 0; i < numaux; i++)
2242 where += bfd_coff_swap_aux_out (abfd,
2243 &symbolP->sy_symbol.ost_auxent[i],
2244 S_GET_DATA_TYPE (symbolP),
2245 S_GET_STORAGE_CLASS (symbolP),
2253 coff_obj_symbol_new_hook (symbolP)
2256 char underscore = 0; /* Symbol has leading _ */
2258 /* Effective symbol */
2259 /* Store the pointer in the offset. */
2260 S_SET_ZEROES (symbolP, 0L);
2261 S_SET_DATA_TYPE (symbolP, T_NULL);
2262 S_SET_STORAGE_CLASS (symbolP, 0);
2263 S_SET_NUMBER_AUXILIARY (symbolP, 0);
2264 /* Additional information */
2265 symbolP->sy_symbol.ost_flags = 0;
2266 /* Auxiliary entries */
2267 memset ((char *) &symbolP->sy_symbol.ost_auxent[0], 0, AUXESZ);
2269 if (S_IS_STRING (symbolP))
2270 SF_SET_STRING (symbolP);
2271 if (!underscore && S_IS_LOCAL (symbolP))
2272 SF_SET_LOCAL (symbolP);
2276 * Handle .ln directives.
2280 obj_coff_ln (appline)
2285 if (! appline && def_symbol_in_progress != NULL)
2287 as_warn (_(".ln pseudo-op inside .def/.endef: ignored."));
2288 demand_empty_rest_of_line ();
2290 } /* wrong context */
2292 l = get_absolute_expression ();
2293 c_line_new (0, frag_now_fix (), l, frag_now);
2296 new_logical_line ((char *) NULL, l - 1);
2306 listing_source_line ((unsigned int) l);
2311 demand_empty_rest_of_line ();
2317 * Handle .def directives.
2319 * One might ask : why can't we symbol_new if the symbol does not
2320 * already exist and fill it with debug information. Because of
2321 * the C_EFCN special symbol. It would clobber the value of the
2322 * function symbol before we have a chance to notice that it is
2323 * a C_EFCN. And a second reason is that the code is more clear this
2324 * way. (at least I think it is :-).
2328 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
2329 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
2330 *input_line_pointer == '\t') \
2331 input_line_pointer++;
2335 int what ATTRIBUTE_UNUSED;
2337 char name_end; /* Char after the end of name */
2338 char *symbol_name; /* Name of the debug symbol */
2339 char *symbol_name_copy; /* Temporary copy of the name */
2340 unsigned int symbol_name_length;
2342 if (def_symbol_in_progress != NULL)
2344 as_warn (_(".def pseudo-op used inside of .def/.endef: ignored."));
2345 demand_empty_rest_of_line ();
2347 } /* if not inside .def/.endef */
2349 SKIP_WHITESPACES ();
2351 def_symbol_in_progress = (symbolS *) obstack_alloc (¬es, sizeof (*def_symbol_in_progress));
2352 memset (def_symbol_in_progress, 0, sizeof (*def_symbol_in_progress));
2354 symbol_name = input_line_pointer;
2355 name_end = get_symbol_end ();
2356 symbol_name_length = strlen (symbol_name);
2357 symbol_name_copy = xmalloc (symbol_name_length + 1);
2358 strcpy (symbol_name_copy, symbol_name);
2359 #ifdef tc_canonicalize_symbol_name
2360 symbol_name_copy = tc_canonicalize_symbol_name (symbol_name_copy);
2363 /* Initialize the new symbol */
2364 #ifdef STRIP_UNDERSCORE
2365 S_SET_NAME (def_symbol_in_progress, (*symbol_name_copy == '_'
2366 ? symbol_name_copy + 1
2367 : symbol_name_copy));
2368 #else /* STRIP_UNDERSCORE */
2369 S_SET_NAME (def_symbol_in_progress, symbol_name_copy);
2370 #endif /* STRIP_UNDERSCORE */
2371 /* free(symbol_name_copy); */
2372 def_symbol_in_progress->sy_name_offset = (unsigned long) ~0;
2373 def_symbol_in_progress->sy_number = ~0;
2374 def_symbol_in_progress->sy_frag = &zero_address_frag;
2375 S_SET_VALUE (def_symbol_in_progress, 0);
2377 if (S_IS_STRING (def_symbol_in_progress))
2378 SF_SET_STRING (def_symbol_in_progress);
2380 *input_line_pointer = name_end;
2382 demand_empty_rest_of_line ();
2385 unsigned int dim_index;
2389 obj_coff_endef (ignore)
2390 int ignore ATTRIBUTE_UNUSED;
2392 symbolS *symbolP = 0;
2393 /* DIM BUG FIX sac@cygnus.com */
2395 if (def_symbol_in_progress == NULL)
2397 as_warn (_(".endef pseudo-op used outside of .def/.endef: ignored."));
2398 demand_empty_rest_of_line ();
2400 } /* if not inside .def/.endef */
2402 /* Set the section number according to storage class. */
2403 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))
2408 SF_SET_TAG (def_symbol_in_progress);
2409 /* intentional fallthrough */
2412 SF_SET_DEBUG (def_symbol_in_progress);
2413 S_SET_SEGMENT (def_symbol_in_progress, SEG_DEBUG);
2417 SF_SET_LOCAL (def_symbol_in_progress); /* Do not emit this symbol. */
2418 /* intentional fallthrough */
2420 SF_SET_PROCESS (def_symbol_in_progress); /* Will need processing before writing */
2421 /* intentional fallthrough */
2423 S_SET_SEGMENT (def_symbol_in_progress, SEG_E0);
2425 if (strcmp (S_GET_NAME (def_symbol_in_progress), ".bf") == 0)
2427 if (function_lineoff < 0)
2429 fprintf (stderr, _("`.bf' symbol without preceding function\n"));
2430 } /* missing function symbol */
2431 SA_GET_SYM_LNNOPTR (last_line_symbol) = function_lineoff;
2433 SF_SET_PROCESS (last_line_symbol);
2434 SF_SET_ADJ_LNNOPTR (last_line_symbol);
2435 SF_SET_PROCESS (def_symbol_in_progress);
2436 function_lineoff = -1;
2438 /* Value is always set to . */
2439 def_symbol_in_progress->sy_frag = frag_now;
2440 S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
2445 #endif /* C_AUTOARG */
2455 SF_SET_DEBUG (def_symbol_in_progress);
2456 S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
2466 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
2472 as_warn (_("unexpected storage class %d"), S_GET_STORAGE_CLASS (def_symbol_in_progress));
2474 } /* switch on storage class */
2476 /* Now that we have built a debug symbol, try to find if we should
2477 merge with an existing symbol or not. If a symbol is C_EFCN or
2478 absolute_section or untagged SEG_DEBUG it never merges. We also
2479 don't merge labels, which are in a different namespace, nor
2480 symbols which have not yet been defined since they are typically
2481 unique, nor do we merge tags with non-tags. */
2483 /* Two cases for functions. Either debug followed by definition or
2484 definition followed by debug. For definition first, we will
2485 merge the debug symbol into the definition. For debug first, the
2486 lineno entry MUST point to the definition function or else it
2487 will point off into space when crawl_symbols() merges the debug
2488 symbol into the real symbol. Therefor, let's presume the debug
2489 symbol is a real function reference. */
2491 /* FIXME-SOON If for some reason the definition label/symbol is
2492 never seen, this will probably leave an undefined symbol at link
2495 if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN
2496 || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_LABEL
2497 || (S_GET_SEGMENT (def_symbol_in_progress) == SEG_DEBUG
2498 && !SF_GET_TAG (def_symbol_in_progress))
2499 || S_GET_SEGMENT (def_symbol_in_progress) == absolute_section
2500 || def_symbol_in_progress->sy_value.X_op != O_constant
2501 || (symbolP = symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP)) == NULL
2502 || (SF_GET_TAG (def_symbol_in_progress) != SF_GET_TAG (symbolP)))
2504 symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP,
2509 /* This symbol already exists, merge the newly created symbol
2510 into the old one. This is not mandatory. The linker can
2511 handle duplicate symbols correctly. But I guess that it save
2512 a *lot* of space if the assembly file defines a lot of
2515 /* The debug entry (def_symbol_in_progress) is merged into the
2516 previous definition. */
2518 c_symbol_merge (def_symbol_in_progress, symbolP);
2519 /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
2520 def_symbol_in_progress = symbolP;
2522 if (SF_GET_FUNCTION (def_symbol_in_progress)
2523 || SF_GET_TAG (def_symbol_in_progress)
2524 || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_STAT)
2526 /* For functions, and tags, and static symbols, the symbol
2527 *must* be where the debug symbol appears. Move the
2528 existing symbol to the current place. */
2529 /* If it already is at the end of the symbol list, do nothing */
2530 if (def_symbol_in_progress != symbol_lastP)
2532 symbol_remove (def_symbol_in_progress, &symbol_rootP,
2534 symbol_append (def_symbol_in_progress, symbol_lastP,
2535 &symbol_rootP, &symbol_lastP);
2536 } /* if not already in place */
2538 } /* normal or mergable */
2540 if (SF_GET_TAG (def_symbol_in_progress))
2544 oldtag = symbol_find_base (S_GET_NAME (def_symbol_in_progress),
2546 if (oldtag == NULL || ! SF_GET_TAG (oldtag))
2547 tag_insert (S_GET_NAME (def_symbol_in_progress),
2548 def_symbol_in_progress);
2551 if (SF_GET_FUNCTION (def_symbol_in_progress))
2553 know (sizeof (def_symbol_in_progress) <= sizeof (long));
2555 = c_line_new (def_symbol_in_progress, 0, 0, &zero_address_frag);
2557 SF_SET_PROCESS (def_symbol_in_progress);
2559 if (symbolP == NULL)
2561 /* That is, if this is the first time we've seen the
2563 symbol_table_insert (def_symbol_in_progress);
2564 } /* definition follows debug */
2565 } /* Create the line number entry pointing to the function being defined */
2567 def_symbol_in_progress = NULL;
2568 demand_empty_rest_of_line ();
2572 obj_coff_dim (ignore)
2573 int ignore ATTRIBUTE_UNUSED;
2577 if (def_symbol_in_progress == NULL)
2579 as_warn (_(".dim pseudo-op used outside of .def/.endef: ignored."));
2580 demand_empty_rest_of_line ();
2582 } /* if not inside .def/.endef */
2584 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2586 for (dim_index = 0; dim_index < DIMNUM; dim_index++)
2588 SKIP_WHITESPACES ();
2589 SA_SET_SYM_DIMEN (def_symbol_in_progress, dim_index,
2590 get_absolute_expression ());
2592 switch (*input_line_pointer)
2595 input_line_pointer++;
2599 as_warn (_("badly formed .dim directive ignored"));
2600 /* intentional fallthrough */
2608 demand_empty_rest_of_line ();
2612 obj_coff_line (ignore)
2613 int ignore ATTRIBUTE_UNUSED;
2618 if (def_symbol_in_progress == NULL)
2624 name = S_GET_NAME (def_symbol_in_progress);
2625 this_base = get_absolute_expression ();
2627 /* Only .bf symbols indicate the use of a new base line number; the
2628 line numbers associated with .ef, .bb, .eb are relative to the
2629 start of the containing function. */
2630 if (!strcmp (".bf", name))
2632 #if 0 /* XXX Can we ever have line numbers going backwards? */
2633 if (this_base > line_base)
2636 line_base = this_base;
2644 listing_source_line ((unsigned int) line_base);
2650 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2651 SA_SET_SYM_LNNO (def_symbol_in_progress, this_base);
2653 demand_empty_rest_of_line ();
2657 obj_coff_size (ignore)
2658 int ignore ATTRIBUTE_UNUSED;
2660 if (def_symbol_in_progress == NULL)
2662 as_warn (_(".size pseudo-op used outside of .def/.endef ignored."));
2663 demand_empty_rest_of_line ();
2665 } /* if not inside .def/.endef */
2667 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2668 SA_SET_SYM_SIZE (def_symbol_in_progress, get_absolute_expression ());
2669 demand_empty_rest_of_line ();
2673 obj_coff_scl (ignore)
2674 int ignore ATTRIBUTE_UNUSED;
2676 if (def_symbol_in_progress == NULL)
2678 as_warn (_(".scl pseudo-op used outside of .def/.endef ignored."));
2679 demand_empty_rest_of_line ();
2681 } /* if not inside .def/.endef */
2683 S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ());
2684 demand_empty_rest_of_line ();
2688 obj_coff_tag (ignore)
2689 int ignore ATTRIBUTE_UNUSED;
2694 if (def_symbol_in_progress == NULL)
2696 as_warn (_(".tag pseudo-op used outside of .def/.endef ignored."));
2697 demand_empty_rest_of_line ();
2701 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2702 symbol_name = input_line_pointer;
2703 name_end = get_symbol_end ();
2704 #ifdef tc_canonicalize_symbol_name
2705 symbol_name = tc_canonicalize_symbol_name (symbol_name);
2708 /* Assume that the symbol referred to by .tag is always defined.
2709 This was a bad assumption. I've added find_or_make. xoxorich. */
2710 SA_SET_SYM_TAGNDX (def_symbol_in_progress,
2711 (long) tag_find_or_make (symbol_name));
2712 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L)
2714 as_warn (_("tag not found for .tag %s"), symbol_name);
2717 SF_SET_TAGGED (def_symbol_in_progress);
2718 *input_line_pointer = name_end;
2720 demand_empty_rest_of_line ();
2724 obj_coff_type (ignore)
2725 int ignore ATTRIBUTE_UNUSED;
2727 if (def_symbol_in_progress == NULL)
2729 as_warn (_(".type pseudo-op used outside of .def/.endef ignored."));
2730 demand_empty_rest_of_line ();
2732 } /* if not inside .def/.endef */
2734 S_SET_DATA_TYPE (def_symbol_in_progress, get_absolute_expression ());
2736 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress)) &&
2737 S_GET_STORAGE_CLASS (def_symbol_in_progress) != C_TPDEF)
2739 SF_SET_FUNCTION (def_symbol_in_progress);
2740 } /* is a function */
2742 demand_empty_rest_of_line ();
2746 obj_coff_val (ignore)
2747 int ignore ATTRIBUTE_UNUSED;
2749 if (def_symbol_in_progress == NULL)
2751 as_warn (_(".val pseudo-op used outside of .def/.endef ignored."));
2752 demand_empty_rest_of_line ();
2754 } /* if not inside .def/.endef */
2756 if (is_name_beginner (*input_line_pointer))
2758 char *symbol_name = input_line_pointer;
2759 char name_end = get_symbol_end ();
2761 #ifdef tc_canonicalize_symbol_name
2762 symbol_name = tc_canonicalize_symbol_name (symbol_name);
2765 if (!strcmp (symbol_name, "."))
2767 def_symbol_in_progress->sy_frag = frag_now;
2768 S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
2769 /* If the .val is != from the .def (e.g. statics) */
2771 else if (strcmp (S_GET_NAME (def_symbol_in_progress), symbol_name))
2773 def_symbol_in_progress->sy_value.X_op = O_symbol;
2774 def_symbol_in_progress->sy_value.X_add_symbol =
2775 symbol_find_or_make (symbol_name);
2776 def_symbol_in_progress->sy_value.X_op_symbol = NULL;
2777 def_symbol_in_progress->sy_value.X_add_number = 0;
2779 /* If the segment is undefined when the forward reference is
2780 resolved, then copy the segment id from the forward
2782 SF_SET_GET_SEGMENT (def_symbol_in_progress);
2784 /* FIXME: gcc can generate address expressions here in
2785 unusual cases (search for "obscure" in sdbout.c). We
2786 just ignore the offset here, thus generating incorrect
2787 debugging information. We ignore the rest of the line
2790 /* Otherwise, it is the name of a non debug symbol and
2791 its value will be calculated later. */
2792 *input_line_pointer = name_end;
2794 /* FIXME: this is to avoid an error message in the
2795 FIXME case mentioned just above. */
2796 while (! is_end_of_line[(unsigned char) *input_line_pointer])
2797 ++input_line_pointer;
2801 S_SET_VALUE (def_symbol_in_progress,
2802 (valueT) get_absolute_expression ());
2803 } /* if symbol based */
2805 demand_empty_rest_of_line ();
2810 /* Handle the .linkonce pseudo-op. This is parsed by s_linkonce in
2811 read.c, which then calls this object file format specific routine. */
2814 obj_coff_pe_handle_link_once (type)
2815 enum linkonce_type type;
2817 seg_info (now_seg)->scnhdr.s_flags |= IMAGE_SCN_LNK_COMDAT;
2819 /* We store the type in the seg_info structure, and use it to set up
2820 the auxiliary entry for the section symbol in c_section_symbol. */
2821 seg_info (now_seg)->linkonce = type;
2827 coff_obj_read_begin_hook ()
2829 /* These had better be the same. Usually 18 bytes. */
2831 know (sizeof (SYMENT) == sizeof (AUXENT));
2832 know (SYMESZ == AUXESZ);
2837 /* This function runs through the symbol table and puts all the
2838 externals onto another chain */
2840 /* The chain of globals. */
2841 symbolS *symbol_globalP;
2842 symbolS *symbol_global_lastP;
2844 /* The chain of externals */
2845 symbolS *symbol_externP;
2846 symbolS *symbol_extern_lastP;
2849 symbolS *last_functionP;
2850 static symbolS *last_bfP;
2857 unsigned int symbol_number = 0;
2858 unsigned int last_file_symno = 0;
2860 struct filename_list *filename_list_scan = filename_list_head;
2862 for (symbolP = symbol_rootP;
2864 symbolP = symbolP ? symbol_next (symbolP) : symbol_rootP)
2866 if (symbolP->sy_mri_common)
2868 if (S_GET_STORAGE_CLASS (symbolP) == C_EXT
2870 || S_GET_STORAGE_CLASS (symbolP) == C_NT_WEAK
2872 || S_GET_STORAGE_CLASS (symbolP) == C_WEAKEXT)
2873 as_bad (_("%s: global symbols not supported in common sections"),
2874 S_GET_NAME (symbolP));
2875 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2879 if (!SF_GET_DEBUG (symbolP))
2881 /* Debug symbols do not need all this rubbish */
2882 symbolS *real_symbolP;
2884 /* L* and C_EFCN symbols never merge. */
2885 if (!SF_GET_LOCAL (symbolP)
2886 && !SF_GET_STATICS (symbolP)
2887 && S_GET_STORAGE_CLASS (symbolP) != C_LABEL
2888 && symbolP->sy_value.X_op == O_constant
2889 && (real_symbolP = symbol_find_base (S_GET_NAME (symbolP), DO_NOT_STRIP))
2890 && real_symbolP != symbolP)
2892 /* FIXME-SOON: where do dups come from?
2893 Maybe tag references before definitions? xoxorich. */
2894 /* Move the debug data from the debug symbol to the
2895 real symbol. Do NOT do the oposite (i.e. move from
2896 real symbol to debug symbol and remove real symbol from the
2897 list.) Because some pointers refer to the real symbol
2898 whereas no pointers refer to the debug symbol. */
2899 c_symbol_merge (symbolP, real_symbolP);
2900 /* Replace the current symbol by the real one */
2901 /* The symbols will never be the last or the first
2902 because : 1st symbol is .file and 3 last symbols are
2903 .text, .data, .bss */
2904 symbol_remove (real_symbolP, &symbol_rootP, &symbol_lastP);
2905 symbol_insert (real_symbolP, symbolP, &symbol_rootP, &symbol_lastP);
2906 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2907 symbolP = real_symbolP;
2908 } /* if not local but dup'd */
2910 if (flag_readonly_data_in_text && (S_GET_SEGMENT (symbolP) == SEG_E1))
2912 S_SET_SEGMENT (symbolP, SEG_E0);
2913 } /* push data into text */
2915 resolve_symbol_value (symbolP, 1);
2917 if (S_GET_STORAGE_CLASS (symbolP) == C_NULL)
2919 if (!S_IS_DEFINED (symbolP) && !SF_GET_LOCAL (symbolP))
2921 S_SET_EXTERNAL (symbolP);
2923 else if (S_GET_SEGMENT (symbolP) == SEG_E0)
2925 S_SET_STORAGE_CLASS (symbolP, C_LABEL);
2929 S_SET_STORAGE_CLASS (symbolP, C_STAT);
2933 /* Mainly to speed up if not -g */
2934 if (SF_GET_PROCESS (symbolP))
2936 /* Handle the nested blocks auxiliary info. */
2937 if (S_GET_STORAGE_CLASS (symbolP) == C_BLOCK)
2939 if (!strcmp (S_GET_NAME (symbolP), ".bb"))
2940 stack_push (block_stack, (char *) &symbolP);
2943 register symbolS *begin_symbolP;
2944 begin_symbolP = *(symbolS **) stack_pop (block_stack);
2945 if (begin_symbolP == (symbolS *) 0)
2946 as_warn (_("mismatched .eb"));
2948 SA_SET_SYM_ENDNDX (begin_symbolP, symbol_number + 2);
2951 /* If we are able to identify the type of a function, and we
2952 are out of a function (last_functionP == 0) then, the
2953 function symbol will be associated with an auxiliary
2955 if (last_functionP == (symbolS *) 0 &&
2956 SF_GET_FUNCTION (symbolP))
2958 last_functionP = symbolP;
2960 if (S_GET_NUMBER_AUXILIARY (symbolP) < 1)
2962 S_SET_NUMBER_AUXILIARY (symbolP, 1);
2963 } /* make it at least 1 */
2965 /* Clobber possible stale .dim information. */
2967 /* Iffed out by steve - this fries the lnnoptr info too */
2968 bzero (symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen,
2969 sizeof (symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen));
2972 if (S_GET_STORAGE_CLASS (symbolP) == C_FCN)
2974 if (strcmp (S_GET_NAME (symbolP), ".bf") == 0)
2976 if (last_bfP != NULL)
2977 SA_SET_SYM_ENDNDX (last_bfP, symbol_number);
2981 else if (S_GET_STORAGE_CLASS (symbolP) == C_EFCN)
2983 /* I don't even know if this is needed for sdb. But
2984 the standard assembler generates it, so... */
2985 if (last_functionP == (symbolS *) 0)
2986 as_fatal (_("C_EFCN symbol out of scope"));
2987 SA_SET_SYM_FSIZE (last_functionP,
2988 (long) (S_GET_VALUE (symbolP) -
2989 S_GET_VALUE (last_functionP)));
2990 SA_SET_SYM_ENDNDX (last_functionP, symbol_number);
2991 last_functionP = (symbolS *) 0;
2995 else if (SF_GET_TAG (symbolP))
2997 /* First descriptor of a structure must point to
2998 the first slot after the structure description. */
2999 last_tagP = symbolP;
3002 else if (S_GET_STORAGE_CLASS (symbolP) == C_EOS)
3004 /* +2 take in account the current symbol */
3005 SA_SET_SYM_ENDNDX (last_tagP, symbol_number + 2);
3007 else if (S_GET_STORAGE_CLASS (symbolP) == C_FILE)
3009 /* If the filename was too long to fit in the
3010 auxent, put it in the string table */
3011 if (SA_GET_FILE_FNAME_ZEROS (symbolP) == 0
3012 && SA_GET_FILE_FNAME_OFFSET (symbolP) != 0)
3014 SA_SET_FILE_FNAME_OFFSET (symbolP, string_byte_count);
3015 string_byte_count += strlen (filename_list_scan->filename) + 1;
3016 filename_list_scan = filename_list_scan->next;
3018 if (S_GET_VALUE (symbolP))
3020 S_SET_VALUE (symbolP, last_file_symno);
3021 last_file_symno = symbol_number;
3022 } /* no one points at the first .file symbol */
3023 } /* if debug or tag or eos or file */
3025 #ifdef tc_frob_coff_symbol
3026 tc_frob_coff_symbol (symbolP);
3029 /* We must put the external symbols apart. The loader
3030 does not bomb if we do not. But the references in
3031 the endndx field for a .bb symbol are not corrected
3032 if an external symbol is removed between .bb and .be.
3033 I.e in the following case :
3034 [20] .bb endndx = 22
3037 ld will move the symbol 21 to the end of the list but
3038 endndx will still be 22 instead of 21. */
3041 if (SF_GET_LOCAL (symbolP))
3043 /* remove C_EFCN and LOCAL (L...) symbols */
3044 /* next pointer remains valid */
3045 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3048 else if (symbolP->sy_value.X_op == O_symbol
3049 && (! S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP)))
3051 /* Skip symbols which were equated to undefined or common
3053 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3055 else if (!S_IS_DEFINED (symbolP)
3056 && !S_IS_DEBUG (symbolP)
3057 && !SF_GET_STATICS (symbolP)
3058 && (S_GET_STORAGE_CLASS (symbolP) == C_EXT
3060 || S_GET_STORAGE_CLASS (symbolP) == C_NT_WEAK
3062 || S_GET_STORAGE_CLASS (symbolP) == C_WEAKEXT))
3064 /* if external, Remove from the list */
3065 symbolS *hold = symbol_previous (symbolP);
3067 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3068 symbol_clear_list_pointers (symbolP);
3069 symbol_append (symbolP, symbol_extern_lastP, &symbol_externP, &symbol_extern_lastP);
3072 else if (! S_IS_DEBUG (symbolP)
3073 && ! SF_GET_STATICS (symbolP)
3074 && ! SF_GET_FUNCTION (symbolP)
3075 && (S_GET_STORAGE_CLASS (symbolP) == C_EXT
3077 || S_GET_STORAGE_CLASS (symbolP) == C_NT_WEAK
3079 || S_GET_STORAGE_CLASS (symbolP) == C_NT_WEAK))
3081 symbolS *hold = symbol_previous (symbolP);
3083 /* The O'Reilly COFF book says that defined global symbols
3084 come at the end of the symbol table, just before
3085 undefined global symbols. */
3087 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3088 symbol_clear_list_pointers (symbolP);
3089 symbol_append (symbolP, symbol_global_lastP, &symbol_globalP,
3090 &symbol_global_lastP);
3095 if (SF_GET_STRING (symbolP))
3097 symbolP->sy_name_offset = string_byte_count;
3098 string_byte_count += strlen (S_GET_NAME (symbolP)) + 1;
3102 symbolP->sy_name_offset = 0;
3103 } /* fix "long" names */
3105 symbolP->sy_number = symbol_number;
3106 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (symbolP);
3107 } /* if local symbol */
3108 } /* traverse the symbol list */
3109 return symbol_number;
3115 glue_symbols (head, tail)
3119 unsigned int symbol_number = 0;
3121 while (*head != NULL)
3123 symbolS *tmp = *head;
3126 symbol_remove (tmp, head, tail);
3127 symbol_append (tmp, symbol_lastP, &symbol_rootP, &symbol_lastP);
3130 if (SF_GET_STRING (tmp))
3132 tmp->sy_name_offset = string_byte_count;
3133 string_byte_count += strlen (S_GET_NAME (tmp)) + 1;
3137 tmp->sy_name_offset = 0;
3138 } /* fix "long" names */
3140 tmp->sy_number = symbol_number;
3141 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (tmp);
3142 } /* append the entire extern chain */
3144 return symbol_number;
3150 unsigned int symbol_number = 0;
3153 for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
3155 symbolP->sy_number = symbol_number;
3157 if (SF_GET_TAGGED (symbolP))
3161 ((symbolS *) SA_GET_SYM_TAGNDX (symbolP))->sy_number);
3164 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (symbolP);
3167 return symbol_number;
3171 crawl_symbols (h, abfd)
3173 bfd *abfd ATTRIBUTE_UNUSED;
3177 /* Initialize the stack used to keep track of the matching .bb .be */
3179 block_stack = stack_init (512, sizeof (symbolS *));
3181 /* The symbol list should be ordered according to the following sequence
3184 * . debug entries for functions
3185 * . fake symbols for the sections, including .text .data and .bss
3187 * . undefined symbols
3188 * But this is not mandatory. The only important point is to put the
3189 * undefined symbols at the end of the list.
3192 /* Is there a .file symbol ? If not insert one at the beginning. */
3193 if (symbol_rootP == NULL
3194 || S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
3196 c_dot_file_symbol ("fake");
3200 * Build up static symbols for the sections, they are filled in later
3204 for (i = SEG_E0; i < SEG_LAST; i++)
3205 if (segment_info[i].scnhdr.s_name[0])
3206 segment_info[i].dot = c_section_symbol (segment_info[i].name,
3209 /* Take all the externals out and put them into another chain */
3210 H_SET_SYMBOL_TABLE_SIZE (h, yank_symbols ());
3211 /* Take the externals and glue them onto the end.*/
3212 H_SET_SYMBOL_TABLE_SIZE (h,
3213 (H_GET_SYMBOL_COUNT (h)
3214 + glue_symbols (&symbol_globalP,
3215 &symbol_global_lastP)
3216 + glue_symbols (&symbol_externP,
3217 &symbol_extern_lastP)));
3219 H_SET_SYMBOL_TABLE_SIZE (h, tie_tags ());
3220 know (symbol_globalP == NULL);
3221 know (symbol_global_lastP == NULL);
3222 know (symbol_externP == NULL);
3223 know (symbol_extern_lastP == NULL);
3227 * Find strings by crawling along symbol table chain.
3235 struct filename_list *filename_list_scan = filename_list_head;
3237 /* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
3238 md_number_to_chars (where, (valueT) string_byte_count, 4);
3241 #ifdef COFF_LONG_SECTION_NAMES
3242 /* Support long section names as found in PE. This code must
3243 coordinate with that in coff_header_append and write_object_file. */
3247 for (i = SEG_E0; i < SEG_LAST; i++)
3249 if (segment_info[i].scnhdr.s_name[0]
3250 && strlen (segment_info[i].name) > SCNNMLEN)
3254 size = strlen (segment_info[i].name) + 1;
3255 memcpy (where, segment_info[i].name, size);
3260 #endif /* COFF_LONG_SECTION_NAMES */
3262 for (symbolP = symbol_rootP;
3264 symbolP = symbol_next (symbolP))
3268 if (SF_GET_STRING (symbolP))
3270 size = strlen (S_GET_NAME (symbolP)) + 1;
3271 memcpy (where, S_GET_NAME (symbolP), size);
3274 if (S_GET_STORAGE_CLASS (symbolP) == C_FILE
3275 && SA_GET_FILE_FNAME_ZEROS (symbolP) == 0
3276 && SA_GET_FILE_FNAME_OFFSET (symbolP) != 0)
3278 size = strlen (filename_list_scan->filename) + 1;
3279 memcpy (where, filename_list_scan->filename, size);
3280 filename_list_scan = filename_list_scan ->next;
3287 do_linenos_for (abfd, h, file_cursor)
3290 unsigned long *file_cursor;
3293 unsigned long start = *file_cursor;
3295 for (idx = SEG_E0; idx < SEG_LAST; idx++)
3297 segment_info_type *s = segment_info + idx;
3300 if (s->scnhdr.s_nlnno != 0)
3302 struct lineno_list *line_ptr;
3304 struct external_lineno *buffer =
3305 (struct external_lineno *) xmalloc (s->scnhdr.s_nlnno * LINESZ);
3307 struct external_lineno *dst = buffer;
3309 /* Run through the table we've built and turn it into its external
3310 form, take this chance to remove duplicates */
3312 for (line_ptr = s->lineno_list_head;
3313 line_ptr != (struct lineno_list *) NULL;
3314 line_ptr = line_ptr->next)
3317 if (line_ptr->line.l_lnno == 0)
3319 /* Turn a pointer to a symbol into the symbols' index */
3320 line_ptr->line.l_addr.l_symndx =
3321 ((symbolS *) line_ptr->line.l_addr.l_symndx)->sy_number;
3325 line_ptr->line.l_addr.l_paddr += ((struct frag *) (line_ptr->frag))->fr_address;
3329 (void) bfd_coff_swap_lineno_out (abfd, &(line_ptr->line), dst);
3334 s->scnhdr.s_lnnoptr = *file_cursor;
3336 bfd_write (buffer, 1, s->scnhdr.s_nlnno * LINESZ, abfd);
3339 *file_cursor += s->scnhdr.s_nlnno * LINESZ;
3342 H_SET_LINENO_SIZE (h, *file_cursor - start);
3346 /* Now we run through the list of frag chains in a segment and
3347 make all the subsegment frags appear at the end of the
3348 list, as if the seg 0 was extra long */
3355 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3357 frchainS *head = segment_info[i].frchainP;
3359 fragS *prev_frag = &dummy;
3361 while (head && head->frch_seg == i)
3363 prev_frag->fr_next = head->frch_root;
3364 prev_frag = head->frch_last;
3365 head = head->frch_next;
3367 prev_frag->fr_next = 0;
3371 unsigned long machine;
3374 write_object_file ()
3378 struct frchain *frchain_ptr;
3380 object_headers headers;
3381 unsigned long file_cursor;
3384 abfd = bfd_openw (out_file_name, TARGET_FORMAT);
3389 as_perror (_("FATAL: Can't create %s"), out_file_name);
3390 exit (EXIT_FAILURE);
3392 bfd_set_format (abfd, bfd_object);
3393 bfd_set_arch_mach (abfd, BFD_ARCH, machine);
3395 string_byte_count = 4;
3397 for (frchain_ptr = frchain_root;
3398 frchain_ptr != (struct frchain *) NULL;
3399 frchain_ptr = frchain_ptr->frch_next)
3401 /* Run through all the sub-segments and align them up. Also
3402 close any open frags. We tack a .fill onto the end of the
3403 frag chain so that any .align's size can be worked by looking
3404 at the next frag. */
3406 subseg_set (frchain_ptr->frch_seg, frchain_ptr->frch_subseg);
3408 #ifndef SUB_SEGMENT_ALIGN
3409 #define SUB_SEGMENT_ALIGN(SEG) 1
3412 md_do_align (SUB_SEGMENT_ALIGN (now_seg), (char *) NULL, 0, 0,
3415 frag_align (SUB_SEGMENT_ALIGN (now_seg),
3416 subseg_text_p (now_seg) ? NOP_OPCODE : 0,
3421 frag_wane (frag_now);
3422 frag_now->fr_fix = 0;
3423 know (frag_now->fr_next == NULL);
3430 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3432 relax_segment (segment_info[i].frchainP->frch_root, i);
3435 H_SET_NUMBER_OF_SECTIONS (&headers, 0);
3437 /* Find out how big the sections are, and set the addresses. */
3439 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3443 segment_info[i].scnhdr.s_paddr = addr;
3444 segment_info[i].scnhdr.s_vaddr = addr;
3446 if (segment_info[i].scnhdr.s_name[0])
3448 H_SET_NUMBER_OF_SECTIONS (&headers,
3449 H_GET_NUMBER_OF_SECTIONS (&headers) + 1);
3451 #ifdef COFF_LONG_SECTION_NAMES
3452 /* Support long section names as found in PE. This code
3453 must coordinate with that in coff_header_append and
3458 len = strlen (segment_info[i].name);
3460 string_byte_count += len + 1;
3462 #endif /* COFF_LONG_SECTION_NAMES */
3465 size = size_section (abfd, (unsigned int) i);
3468 /* I think the section alignment is only used on the i960; the
3469 i960 needs it, and it should do no harm on other targets. */
3470 #ifdef ALIGNMENT_IN_S_FLAGS
3471 segment_info[i].scnhdr.s_flags |= (section_alignment[i] & 0xF) << 8;
3473 segment_info[i].scnhdr.s_align = 1 << section_alignment[i];
3477 H_SET_TEXT_SIZE (&headers, size);
3478 else if (i == SEG_E1)
3479 H_SET_DATA_SIZE (&headers, size);
3480 else if (i == SEG_E2)
3481 H_SET_BSS_SIZE (&headers, size);
3484 /* Turn the gas native symbol table shape into a coff symbol table */
3485 crawl_symbols (&headers, abfd);
3487 if (string_byte_count == 4)
3488 string_byte_count = 0;
3490 H_SET_STRING_SIZE (&headers, string_byte_count);
3496 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3498 fixup_mdeps (segment_info[i].frchainP->frch_root, &headers, i);
3499 fixup_segment (&segment_info[i], i);
3502 /* Look for ".stab" segments and fill in their initial symbols
3504 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3506 name = segment_info[i].name;
3509 && strncmp (".stab", name, 5) == 0
3510 && strncmp (".stabstr", name, 8) != 0)
3511 adjust_stab_section (abfd, i);
3514 file_cursor = H_GET_TEXT_FILE_OFFSET (&headers);
3516 bfd_seek (abfd, (file_ptr) file_cursor, 0);
3518 /* Plant the data */
3520 fill_section (abfd, &headers, &file_cursor);
3522 do_relocs_for (abfd, &headers, &file_cursor);
3524 do_linenos_for (abfd, &headers, &file_cursor);
3526 H_SET_FILE_MAGIC_NUMBER (&headers, COFF_MAGIC);
3527 #ifndef OBJ_COFF_OMIT_TIMESTAMP
3528 H_SET_TIME_STAMP (&headers, (long)time((time_t *)0));
3530 H_SET_TIME_STAMP (&headers, 0);
3532 #ifdef TC_COFF_SET_MACHINE
3533 TC_COFF_SET_MACHINE (&headers);
3537 #define COFF_FLAGS 0
3540 #ifdef KEEP_RELOC_INFO
3541 H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
3542 COFF_FLAGS | coff_flags));
3544 H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
3545 (H_GET_RELOCATION_SIZE(&headers) ? 0 : F_RELFLG) |
3546 COFF_FLAGS | coff_flags));
3550 unsigned int symtable_size = H_GET_SYMBOL_TABLE_SIZE (&headers);
3551 char *buffer1 = xmalloc (symtable_size + string_byte_count + 1);
3553 H_SET_SYMBOL_TABLE_POINTER (&headers, bfd_tell (abfd));
3554 w_symbols (abfd, buffer1, symbol_rootP);
3555 if (string_byte_count > 0)
3556 w_strings (buffer1 + symtable_size);
3557 bfd_write (buffer1, 1, symtable_size + string_byte_count, abfd);
3561 coff_header_append (abfd, &headers);
3563 /* Recent changes to write need this, but where it should
3564 go is up to Ken.. */
3565 if (bfd_close_all_done (abfd) == false)
3566 as_fatal (_("Can't close %s: %s"), out_file_name,
3567 bfd_errmsg (bfd_get_error ()));
3570 extern bfd *stdoutput;
3577 /* Add a new segment. This is called from subseg_new via the
3578 obj_new_segment macro. */
3581 obj_coff_add_segment (name)
3586 #ifndef COFF_LONG_SECTION_NAMES
3587 char buf[SCNNMLEN + 1];
3589 strncpy (buf, name, SCNNMLEN);
3590 buf[SCNNMLEN] = '\0';
3594 for (i = SEG_E0; i < SEG_LAST && segment_info[i].scnhdr.s_name[0]; i++)
3595 if (strcmp (name, segment_info[i].name) == 0)
3600 as_bad (_("Too many new sections; can't add \"%s\""), name);
3604 /* Add a new section. */
3605 strncpy (segment_info[i].scnhdr.s_name, name,
3606 sizeof (segment_info[i].scnhdr.s_name));
3607 segment_info[i].scnhdr.s_flags = STYP_REG;
3608 segment_info[i].name = xstrdup (name);
3614 * implement the .section pseudo op:
3615 * .section name {, "flags"}
3617 * | +--- optional flags: 'b' for bss
3619 * +-- section name 'l' for lib
3623 * 'd' (apparently m88k for data)
3625 * 'r' for read-only data
3626 * But if the argument is not a quoted string, treat it as a
3627 * subsegment number.
3631 obj_coff_section (ignore)
3632 int ignore ATTRIBUTE_UNUSED;
3634 /* Strip out the section name */
3635 char *section_name, *name;
3648 else if (type == 'D')
3650 segment_info[now_seg].scnhdr.s_flags |= flags;
3655 section_name = input_line_pointer;
3656 c = get_symbol_end ();
3658 name = xmalloc (input_line_pointer - section_name + 1);
3659 strcpy (name, section_name);
3661 *input_line_pointer = c;
3667 if (*input_line_pointer == ',')
3669 ++input_line_pointer;
3672 if (*input_line_pointer != '"')
3673 exp = get_absolute_expression ();
3676 ++input_line_pointer;
3677 while (*input_line_pointer != '"'
3678 && ! is_end_of_line[(unsigned char) *input_line_pointer])
3680 switch (*input_line_pointer)
3682 case 'b': flags |= STYP_BSS; break;
3683 case 'i': flags |= STYP_INFO; break;
3684 case 'l': flags |= STYP_LIB; break;
3685 case 'n': flags |= STYP_NOLOAD; break;
3686 case 'o': flags |= STYP_OVER; break;
3688 case 'w': flags |= STYP_DATA; break;
3689 case 'x': flags |= STYP_TEXT; break;
3690 case 'r': flags |= STYP_LIT; break;
3692 as_warn(_("unknown section attribute '%c'"),
3693 *input_line_pointer);
3696 ++input_line_pointer;
3698 if (*input_line_pointer == '"')
3699 ++input_line_pointer;
3703 subseg_new (name, (subsegT) exp);
3705 segment_info[now_seg].scnhdr.s_flags |= flags;
3707 demand_empty_rest_of_line ();
3712 obj_coff_text (ignore)
3713 int ignore ATTRIBUTE_UNUSED;
3715 subseg_new (".text", get_absolute_expression ());
3720 obj_coff_data (ignore)
3721 int ignore ATTRIBUTE_UNUSED;
3723 if (flag_readonly_data_in_text)
3724 subseg_new (".text", get_absolute_expression () + 1000);
3726 subseg_new (".data", get_absolute_expression ());
3730 obj_coff_ident (ignore)
3731 int ignore ATTRIBUTE_UNUSED;
3733 segT current_seg = now_seg; /* save current seg */
3734 subsegT current_subseg = now_subseg;
3735 subseg_new (".comment", 0); /* .comment seg */
3736 stringer (1); /* read string */
3737 subseg_set (current_seg, current_subseg); /* restore current seg */
3741 c_symbol_merge (debug, normal)
3745 S_SET_DATA_TYPE (normal, S_GET_DATA_TYPE (debug));
3746 S_SET_STORAGE_CLASS (normal, S_GET_STORAGE_CLASS (debug));
3748 if (S_GET_NUMBER_AUXILIARY (debug) > S_GET_NUMBER_AUXILIARY (normal))
3750 S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));
3751 } /* take the most we have */
3753 if (S_GET_NUMBER_AUXILIARY (debug) > 0)
3755 memcpy ((char *) &normal->sy_symbol.ost_auxent[0],
3756 (char *) &debug->sy_symbol.ost_auxent[0],
3757 (unsigned int) (S_GET_NUMBER_AUXILIARY (debug) * AUXESZ));
3758 } /* Move all the auxiliary information */
3760 /* Move the debug flags. */
3761 SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
3762 } /* c_symbol_merge() */
3765 c_line_new (symbol, paddr, line_number, frag)
3771 struct lineno_list *new_line =
3772 (struct lineno_list *) xmalloc (sizeof (struct lineno_list));
3774 segment_info_type *s = segment_info + now_seg;
3775 new_line->line.l_lnno = line_number;
3777 if (line_number == 0)
3779 last_line_symbol = symbol;
3780 new_line->line.l_addr.l_symndx = (long) symbol;
3784 new_line->line.l_addr.l_paddr = paddr;
3787 new_line->frag = (char *) frag;
3788 new_line->next = (struct lineno_list *) NULL;
3791 if (s->lineno_list_head == (struct lineno_list *) NULL)
3793 s->lineno_list_head = new_line;
3797 s->lineno_list_tail->next = new_line;
3799 s->lineno_list_tail = new_line;
3800 return LINESZ * s->scnhdr.s_nlnno++;
3804 c_dot_file_symbol (filename)
3809 symbolP = symbol_new (".file",
3812 &zero_address_frag);
3814 S_SET_STORAGE_CLASS (symbolP, C_FILE);
3815 S_SET_NUMBER_AUXILIARY (symbolP, 1);
3817 if (strlen (filename) > FILNMLEN)
3819 /* Filename is too long to fit into an auxent,
3820 we stick it into the string table instead. We keep
3821 a linked list of the filenames we find so we can emit
3823 struct filename_list *f = ((struct filename_list *)
3824 xmalloc (sizeof (struct filename_list)));
3826 f->filename = filename;
3829 SA_SET_FILE_FNAME_ZEROS (symbolP, 0);
3830 SA_SET_FILE_FNAME_OFFSET (symbolP, 1);
3832 if (filename_list_tail)
3833 filename_list_tail->next = f;
3835 filename_list_head = f;
3836 filename_list_tail = f;
3840 SA_SET_FILE_FNAME (symbolP, filename);
3847 listing_source_file (filename);
3853 SF_SET_DEBUG (symbolP);
3854 S_SET_VALUE (symbolP, (valueT) previous_file_symbol);
3856 previous_file_symbol = symbolP;
3858 /* Make sure that the symbol is first on the symbol chain */
3859 if (symbol_rootP != symbolP)
3861 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3862 symbol_insert (symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
3864 } /* c_dot_file_symbol() */
3867 * Build a 'section static' symbol.
3871 c_section_symbol (name, idx)
3877 symbolP = symbol_find_base (name, DO_NOT_STRIP);
3878 if (symbolP == NULL)
3879 symbolP = symbol_new (name, idx, 0, &zero_address_frag);
3882 /* Mmmm. I just love violating interfaces. Makes me feel...dirty. */
3883 S_SET_SEGMENT (symbolP, idx);
3884 symbolP->sy_frag = &zero_address_frag;
3887 S_SET_STORAGE_CLASS (symbolP, C_STAT);
3888 S_SET_NUMBER_AUXILIARY (symbolP, 1);
3890 SF_SET_STATICS (symbolP);
3893 /* manfred@s-direktnet.de: section symbols *must* have the LOCAL bit cleared,
3894 which is set by the new definition of LOCAL_LABEL in tc-m68k.h. */
3895 SF_CLEAR_LOCAL (symbolP);
3898 /* If the .linkonce pseudo-op was used for this section, we must
3899 store the information in the auxiliary entry for the section
3901 if (segment_info[idx].linkonce != LINKONCE_UNSET)
3905 switch (segment_info[idx].linkonce)
3909 case LINKONCE_DISCARD:
3910 type = IMAGE_COMDAT_SELECT_ANY;
3912 case LINKONCE_ONE_ONLY:
3913 type = IMAGE_COMDAT_SELECT_NODUPLICATES;
3915 case LINKONCE_SAME_SIZE:
3916 type = IMAGE_COMDAT_SELECT_SAME_SIZE;
3918 case LINKONCE_SAME_CONTENTS:
3919 type = IMAGE_COMDAT_SELECT_EXACT_MATCH;
3923 SYM_AUXENT (symbolP)->x_scn.x_comdat = type;
3928 } /* c_section_symbol() */
3931 w_symbols (abfd, where, symbol_rootP)
3934 symbolS * symbol_rootP;
3939 /* First fill in those values we have only just worked out */
3940 for (i = SEG_E0; i < SEG_LAST; i++)
3942 symbolP = segment_info[i].dot;
3945 SA_SET_SCN_SCNLEN (symbolP, segment_info[i].scnhdr.s_size);
3946 SA_SET_SCN_NRELOC (symbolP, segment_info[i].scnhdr.s_nreloc);
3947 SA_SET_SCN_NLINNO (symbolP, segment_info[i].scnhdr.s_nlnno);
3952 * Emit all symbols left in the symbol chain.
3954 for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
3956 /* Used to save the offset of the name. It is used to point
3957 to the string in memory but must be a file offset. */
3958 register char *temp;
3960 /* We can't fix the lnnoptr field in yank_symbols with the other
3961 adjustments, because we have to wait until we know where they
3963 if (SF_GET_ADJ_LNNOPTR (symbolP))
3965 SA_GET_SYM_LNNOPTR (symbolP) +=
3966 segment_info[S_GET_SEGMENT (symbolP)].scnhdr.s_lnnoptr;
3969 tc_coff_symbol_emit_hook (symbolP);
3971 temp = S_GET_NAME (symbolP);
3972 if (SF_GET_STRING (symbolP))
3974 S_SET_OFFSET (symbolP, symbolP->sy_name_offset);
3975 S_SET_ZEROES (symbolP, 0);
3979 memset (symbolP->sy_symbol.ost_entry.n_name, 0, SYMNMLEN);
3980 strncpy (symbolP->sy_symbol.ost_entry.n_name, temp, SYMNMLEN);
3982 where = symbol_to_chars (abfd, where, symbolP);
3983 S_SET_NAME (symbolP, temp);
3989 obj_coff_lcomm (ignore)
3990 int ignore ATTRIBUTE_UNUSED;
4002 name = input_line_pointer;
4004 c = get_symbol_end ();
4005 p = input_line_pointer;
4008 if (*input_line_pointer != ',')
4010 as_bad (_("Expected comma after name"));
4011 ignore_rest_of_line ();
4014 if (*input_line_pointer == '\n')
4016 as_bad (_("Missing size expression"));
4019 input_line_pointer++;
4020 if ((temp = get_absolute_expression ()) < 0)
4022 as_warn (_("lcomm length (%d.) <0! Ignored."), temp);
4023 ignore_rest_of_line ();
4028 symbolP = symbol_find_or_make(name);
4030 if (S_GET_SEGMENT(symbolP) == SEG_UNKNOWN &&
4031 S_GET_VALUE(symbolP) == 0)
4036 segT current_seg = now_seg; /* save current seg */
4037 subsegT current_subseg = now_subseg;
4039 subseg_set (SEG_E2, 1);
4040 symbolP->sy_frag = frag_now;
4041 p = frag_var(rs_org, 1, 1, (relax_substateT)0, symbolP,
4042 (offsetT) temp, (char *) 0);
4044 subseg_set (current_seg, current_subseg); /* restore current seg */
4045 S_SET_SEGMENT(symbolP, SEG_E2);
4046 S_SET_STORAGE_CLASS(symbolP, C_STAT);
4050 as_bad(_("Symbol %s already defined"), name);
4052 demand_empty_rest_of_line();
4057 fixup_mdeps (frags, h, this_segment)
4062 subseg_change (this_segment, 0);
4065 switch (frags->fr_type)
4071 HANDLE_ALIGN (frags);
4073 frags->fr_type = rs_fill;
4075 ((frags->fr_next->fr_address - frags->fr_address - frags->fr_fix)
4078 case rs_machine_dependent:
4079 md_convert_frag (h, this_segment, frags);
4085 frags = frags->fr_next;
4091 #ifndef TC_FORCE_RELOCATION
4092 #define TC_FORCE_RELOCATION(fix) 0
4096 fixup_segment (segP, this_segment_type)
4097 segment_info_type * segP;
4098 segT this_segment_type;
4100 register fixS * fixP;
4101 register symbolS *add_symbolP;
4102 register symbolS *sub_symbolP;
4105 register char *place;
4106 register long where;
4107 register char pcrel;
4108 register fragS *fragP;
4109 register segT add_symbol_segment = absolute_section;
4111 for (fixP = segP->fix_root; fixP; fixP = fixP->fx_next)
4113 fragP = fixP->fx_frag;
4115 where = fixP->fx_where;
4116 place = fragP->fr_literal + where;
4117 size = fixP->fx_size;
4118 add_symbolP = fixP->fx_addsy;
4119 sub_symbolP = fixP->fx_subsy;
4120 add_number = fixP->fx_offset;
4121 pcrel = fixP->fx_pcrel;
4123 /* We want function-relative stabs to work on systems which
4124 may use a relaxing linker; thus we must handle the sym1-sym2
4125 fixups function-relative stabs generates.
4127 Of course, if you actually enable relaxing in the linker, the
4128 line and block scoping information is going to be incorrect
4129 in some cases. The only way to really fix this is to support
4130 a reloc involving the difference of two symbols. */
4132 && (!sub_symbolP || pcrel))
4136 if (fixP->fx_tcbit && SF_GET_CALLNAME (add_symbolP))
4138 /* Relocation should be done via the associated 'bal' entry
4141 if (!SF_GET_BALNAME (tc_get_bal_of_call (add_symbolP)))
4143 as_bad_where (fixP->fx_file, fixP->fx_line,
4144 _("No 'bal' entry point for leafproc %s"),
4145 S_GET_NAME (add_symbolP));
4148 fixP->fx_addsy = add_symbolP = tc_get_bal_of_call (add_symbolP);
4152 /* Make sure the symbols have been resolved; this may not have
4153 happened if these are expression symbols. */
4154 if (add_symbolP != NULL && ! add_symbolP->sy_resolved)
4155 resolve_symbol_value (add_symbolP, 1);
4157 if (add_symbolP != NULL)
4159 /* If this fixup is against a symbol which has been equated
4160 to another symbol, convert it to the other symbol. */
4161 if (add_symbolP->sy_value.X_op == O_symbol
4162 && (! S_IS_DEFINED (add_symbolP)
4163 || S_IS_COMMON (add_symbolP)))
4165 while (add_symbolP->sy_value.X_op == O_symbol
4166 && (! S_IS_DEFINED (add_symbolP)
4167 || S_IS_COMMON (add_symbolP)))
4171 /* We must avoid looping, as that can occur with a
4172 badly written program. */
4173 n = add_symbolP->sy_value.X_add_symbol;
4174 if (n == add_symbolP)
4176 add_number += add_symbolP->sy_value.X_add_number;
4179 fixP->fx_addsy = add_symbolP;
4180 fixP->fx_offset = add_number;
4184 if (sub_symbolP != NULL && ! sub_symbolP->sy_resolved)
4185 resolve_symbol_value (sub_symbolP, 1);
4187 if (add_symbolP != NULL
4188 && add_symbolP->sy_mri_common)
4190 know (add_symbolP->sy_value.X_op == O_symbol);
4191 add_number += S_GET_VALUE (add_symbolP);
4192 fixP->fx_offset = add_number;
4193 add_symbolP = fixP->fx_addsy = add_symbolP->sy_value.X_add_symbol;
4198 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
4199 } /* if there is an addend */
4203 if (add_symbolP == NULL || add_symbol_segment == absolute_section)
4205 if (add_symbolP != NULL)
4207 add_number += S_GET_VALUE (add_symbolP);
4209 fixP->fx_addsy = NULL;
4212 /* It's just -sym. */
4213 if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
4215 add_number -= S_GET_VALUE (sub_symbolP);
4222 as_bad_where (fixP->fx_file, fixP->fx_line,
4223 _("Negative of non-absolute symbol %s"),
4224 S_GET_NAME (sub_symbolP));
4226 add_number -= S_GET_VALUE (sub_symbolP);
4227 } /* not absolute */
4229 /* if sub_symbol is in the same segment that add_symbol
4230 and add_symbol is either in DATA, TEXT, BSS or ABSOLUTE */
4232 else if (S_GET_SEGMENT (sub_symbolP) == add_symbol_segment
4233 && SEG_NORMAL (add_symbol_segment))
4235 /* Difference of 2 symbols from same segment. Can't
4236 make difference of 2 undefineds: 'value' means
4237 something different for N_UNDF. */
4239 /* Makes no sense to use the difference of 2 arbitrary symbols
4240 as the target of a call instruction. */
4243 as_bad_where (fixP->fx_file, fixP->fx_line,
4244 _("callj to difference of 2 symbols"));
4246 #endif /* TC_I960 */
4247 add_number += S_GET_VALUE (add_symbolP) -
4248 S_GET_VALUE (sub_symbolP);
4251 if (!TC_FORCE_RELOCATION (fixP))
4253 fixP->fx_addsy = NULL;
4254 fixP->fx_subsy = NULL;
4256 #ifdef TC_M68K /* is this right? */
4264 /* Different segments in subtraction. */
4265 know (!(S_IS_EXTERNAL (sub_symbolP) && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
4267 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
4269 add_number -= S_GET_VALUE (sub_symbolP);
4272 else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
4273 #if 0 /* Okay for 68k, at least... */
4278 /* Make it pc-relative. */
4279 add_number += (md_pcrel_from (fixP)
4280 - S_GET_VALUE (sub_symbolP));
4289 as_bad_where (fixP->fx_file, fixP->fx_line,
4290 _("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %ld."),
4291 segment_name (S_GET_SEGMENT (sub_symbolP)),
4292 S_GET_NAME (sub_symbolP),
4293 (long) (fragP->fr_address + where));
4296 } /* if sub_symbolP */
4300 if (add_symbol_segment == this_segment_type && pcrel)
4303 * This fixup was made when the symbol's segment was
4304 * SEG_UNKNOWN, but it is now in the local segment.
4305 * So we know how to do the address without relocation.
4308 /* reloc_callj() may replace a 'call' with a 'calls' or a 'bal',
4309 * in which cases it modifies *fixP as appropriate. In the case
4310 * of a 'calls', no further work is required, and *fixP has been
4311 * set up to make the rest of the code below a no-op.
4314 #endif /* TC_I960 */
4316 add_number += S_GET_VALUE (add_symbolP);
4317 add_number -= md_pcrel_from (fixP);
4320 add_number -= segP->scnhdr.s_vaddr;
4321 if defined (TC_I386) || defined (TE_LYNX). I now
4322 think that was an error propagated from the case when
4323 we are going to emit the relocation. If we are not
4324 going to emit the relocation, then we just want to
4325 set add_number to the difference between the symbols.
4326 This is a case that would only arise when there is a
4327 PC relative reference from a section other than .text
4328 to a symbol defined in the same section, and the
4329 reference is not relaxed. Since jump instructions on
4330 the i386 are relaxed, this could only arise with a
4331 call instruction. */
4333 pcrel = 0; /* Lie. Don't want further pcrel processing. */
4334 if (!TC_FORCE_RELOCATION (fixP))
4336 fixP->fx_addsy = NULL;
4342 switch (add_symbol_segment)
4344 case absolute_section:
4346 reloc_callj (fixP); /* See comment about reloc_callj() above*/
4347 #endif /* TC_I960 */
4348 add_number += S_GET_VALUE (add_symbolP);
4351 if (!TC_FORCE_RELOCATION (fixP))
4353 fixP->fx_addsy = NULL;
4360 #if defined(TC_A29K) || (defined(TE_PE) && defined(TC_I386)) || defined(TC_M88K)
4361 /* This really should be handled in the linker, but
4362 backward compatibility forbids. */
4363 add_number += S_GET_VALUE (add_symbolP);
4365 add_number += S_GET_VALUE (add_symbolP) +
4366 segment_info[S_GET_SEGMENT (add_symbolP)].scnhdr.s_paddr;
4372 if ((int) fixP->fx_bit_fixP == 13)
4374 /* This is a COBR instruction. They have only a
4375 * 13-bit displacement and are only to be used
4376 * for local branches: flag as error, don't generate
4379 as_bad_where (fixP->fx_file, fixP->fx_line,
4380 _("can't use COBR format with external label"));
4381 fixP->fx_addsy = NULL;
4385 #endif /* TC_I960 */
4386 #if ((defined (TC_I386) || defined (TE_LYNX) || defined (TE_AUX)) && !defined(TE_PE)) || defined (COFF_COMMON_ADDEND)
4387 /* 386 COFF uses a peculiar format in which the
4388 value of a common symbol is stored in the .text
4389 segment (I've checked this on SVR3.2 and SCO
4390 3.2.2) Ian Taylor <ian@cygnus.com>. */
4391 /* This is also true for 68k COFF on sysv machines
4392 (Checked on Motorola sysv68 R3V6 and R3V7.1, and also on
4393 UNIX System V/M68000, Release 1.0 from ATT/Bell Labs)
4394 Philippe De Muyter <phdm@info.ucl.ac.be>. */
4395 if (S_IS_COMMON (add_symbolP))
4396 add_number += S_GET_VALUE (add_symbolP);
4401 } /* switch on symbol seg */
4402 } /* if not in local seg */
4403 } /* if there was a + symbol */
4407 #if !defined(TC_M88K) && !(defined(TE_PE) && defined(TC_I386)) && !defined(TC_A29K)
4408 /* This adjustment is not correct on the m88k, for which the
4409 linker does all the computation. */
4410 add_number -= md_pcrel_from (fixP);
4412 if (add_symbolP == 0)
4414 fixP->fx_addsy = &abs_symbol;
4415 } /* if there's an add_symbol */
4416 #if defined (TC_I386) || defined (TE_LYNX) || defined (TC_I960) || defined (TC_M68K)
4417 /* On the 386 we must adjust by the segment vaddr as well.
4420 I changed the i960 to work this way as well. This is
4421 compatible with the current GNU linker behaviour. I do
4422 not know what other i960 COFF assemblers do. This is not
4423 a common case: normally, only assembler code will contain
4424 a PC relative reloc, and only branches which do not
4425 originate in the .text section will have a non-zero
4428 I changed the m68k to work this way as well. This will
4429 break existing PC relative relocs from sections which do
4430 not start at address 0, but it will make ld -r work.
4431 Ian Taylor, 4 Oct 96. */
4433 add_number -= segP->scnhdr.s_vaddr;
4437 #ifdef MD_APPLY_FIX3
4438 md_apply_fix3 (fixP, (valueT *) &add_number, this_segment_type);
4440 md_apply_fix (fixP, add_number);
4443 if (!fixP->fx_bit_fixP && ! fixP->fx_no_overflow)
4446 /* The m88k uses the offset field of the reloc to get around
4449 && ((add_number & ~0xFF)
4450 || (fixP->fx_signed && (add_number & 0x80)))
4451 && ((add_number & ~0xFF) != (-1 & ~0xFF)
4452 || (add_number & 0x80) == 0))
4454 && ((add_number & ~0xFFFF)
4455 || (fixP->fx_signed && (add_number & 0x8000)))
4456 && ((add_number & ~0xFFFF) != (-1 & ~0xFFFF)
4457 || (add_number & 0x8000) == 0)))
4459 as_bad_where (fixP->fx_file, fixP->fx_line,
4460 _("Value of %ld too large for field of %d bytes at 0x%lx"),
4461 (long) add_number, size,
4462 (unsigned long) (fragP->fr_address + where));
4465 #ifdef WARN_SIGNED_OVERFLOW_WORD
4466 /* Warn if a .word value is too large when treated as a
4467 signed number. We already know it is not too negative.
4468 This is to catch over-large switches generated by gcc on
4470 if (!flag_signed_overflow_ok
4472 && add_number > 0x7fff)
4473 as_bad_where (fixP->fx_file, fixP->fx_line,
4474 _("Signed .word overflow; switch may be too large; %ld at 0x%lx"),
4476 (unsigned long) (fragP->fr_address + where));
4478 } /* not a bit fix */
4479 } /* For each fixS in this segment. */
4480 } /* fixup_segment() */
4484 /* The first entry in a .stab section is special. */
4487 obj_coff_init_stab_section (seg)
4493 unsigned int stroff;
4495 /* Make space for this first symbol. */
4499 as_where (&file, (unsigned int *) NULL);
4500 stabstr_name = (char *) alloca (strlen (segment_info[seg].name) + 4);
4501 strcpy (stabstr_name, segment_info[seg].name);
4502 strcat (stabstr_name, "str");
4503 stroff = get_stab_string_offset (file, stabstr_name);
4505 md_number_to_chars (p, stroff, 4);
4508 /* Fill in the counts in the first entry in a .stab section. */
4511 adjust_stab_section(abfd, seg)
4515 segT stabstrseg = SEG_UNKNOWN;
4516 const char *secname, *name2;
4519 int i, strsz = 0, nsyms;
4520 fragS *frag = segment_info[seg].frchainP->frch_root;
4522 /* Look for the associated string table section. */
4524 secname = segment_info[seg].name;
4525 name = (char *) alloca (strlen (secname) + 4);
4526 strcpy (name, secname);
4527 strcat (name, "str");
4529 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
4531 name2 = segment_info[i].name;
4532 if (name2 != NULL && strncmp(name2, name, 8) == 0)
4539 /* If we found the section, get its size. */
4540 if (stabstrseg != SEG_UNKNOWN)
4541 strsz = size_section (abfd, stabstrseg);
4543 nsyms = size_section (abfd, seg) / 12 - 1;
4545 /* Look for the first frag of sufficient size for the initial stab
4546 symbol, and collect a pointer to it. */
4547 while (frag && frag->fr_fix < 12)
4548 frag = frag->fr_next;
4550 p = frag->fr_literal;
4553 /* Write in the number of stab symbols and the size of the string
4555 bfd_h_put_16 (abfd, (bfd_vma) nsyms, (bfd_byte *) p + 6);
4556 bfd_h_put_32 (abfd, (bfd_vma) strsz, (bfd_byte *) p + 8);
4559 #endif /* not BFD_ASSEMBLER */
4561 const pseudo_typeS coff_pseudo_table[] =
4563 {"def", obj_coff_def, 0},
4564 {"dim", obj_coff_dim, 0},
4565 {"endef", obj_coff_endef, 0},
4566 {"line", obj_coff_line, 0},
4567 {"ln", obj_coff_ln, 0},
4568 #ifdef BFD_ASSEMBLER
4569 {"loc", obj_coff_loc, 0},
4571 {"appline", obj_coff_ln, 1},
4572 {"scl", obj_coff_scl, 0},
4573 {"size", obj_coff_size, 0},
4574 {"tag", obj_coff_tag, 0},
4575 {"type", obj_coff_type, 0},
4576 {"val", obj_coff_val, 0},
4577 {"section", obj_coff_section, 0},
4578 {"sect", obj_coff_section, 0},
4579 /* FIXME: We ignore the MRI short attribute. */
4580 {"section.s", obj_coff_section, 0},
4581 {"sect.s", obj_coff_section, 0},
4582 /* We accept the .bss directive for backward compatibility with
4583 earlier versions of gas. */
4584 {"bss", obj_coff_bss, 0},
4585 {"weak", obj_coff_weak, 0},
4586 {"ident", obj_coff_ident, 0},
4587 #ifndef BFD_ASSEMBLER
4588 {"use", obj_coff_section, 0},
4589 {"text", obj_coff_text, 0},
4590 {"data", obj_coff_data, 0},
4591 {"lcomm", obj_coff_lcomm, 0},
4593 {"optim", s_ignore, 0}, /* For sun386i cc (?) */
4595 {"version", s_ignore, 0},
4596 {"ABORT", s_abort, 0},
4598 /* The m88k uses sdef instead of def. */
4599 {"sdef", obj_coff_def, 0},
4601 {NULL, NULL, 0} /* end sentinel */
4602 }; /* coff_pseudo_table */
4604 #ifdef BFD_ASSEMBLER
4606 /* Support for a COFF emulation. */
4608 static void coff_pop_insert PARAMS ((void));
4609 static int coff_separate_stab_sections PARAMS ((void));
4614 pop_insert (coff_pseudo_table);
4618 coff_separate_stab_sections ()
4623 const struct format_ops coff_format_ops =
4625 bfd_target_coff_flavour,
4626 0, /* dfl_leading_underscore */
4627 1, /* emit_section_symbols */
4632 coff_frob_file_after_relocs,
4635 0, /* s_get_align */
4636 0, /* s_set_align */
4637 0, /* s_get_other */
4638 0, /* s_set_other */
4643 0, /* copy_symbol_attributes */
4644 0, /* generate_asm_lineno */
4645 0, /* process_stab */
4646 coff_separate_stab_sections,
4647 obj_coff_init_stab_section,
4648 0, /* sec_sym_ok_for_reloc */
4650 0, /* ecoff_set_ext */
4651 coff_obj_read_begin_hook,
4652 coff_obj_symbol_new_hook