1 /* coff object file format
2 Copyright 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 Free Software Foundation, Inc.
6 This file is part of GAS.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
23 #define OBJ_HEADER "obj-coff.h"
29 /* I think this is probably always correct. */
30 #ifndef KEEP_RELOC_INFO
31 #define KEEP_RELOC_INFO
34 /* The BFD_ASSEMBLER version of obj_coff_section will use this macro to set
35 a new section's attributes when a directive has no valid flags or the
36 "w" flag is used. This default should be appropriate for most. */
37 #ifndef TC_COFF_SECTION_DEFAULT_ATTRIBUTES
38 #define TC_COFF_SECTION_DEFAULT_ATTRIBUTES (SEC_LOAD | SEC_DATA)
41 /* This is used to hold the symbol built by a sequence of pseudo-ops
42 from .def and .endef. */
43 static symbolS *def_symbol_in_progress;
47 unsigned long chunk_size;
48 unsigned long element_size;
51 unsigned long pointer;
55 static stack *stack_init PARAMS ((unsigned long, unsigned long));
56 static char *stack_push PARAMS ((stack *, char *));
57 static char *stack_pop PARAMS ((stack *));
58 static void tag_init PARAMS ((void));
59 static void tag_insert PARAMS ((const char *, symbolS *));
60 static symbolS *tag_find PARAMS ((char *));
61 static symbolS *tag_find_or_make PARAMS ((char *));
62 static void obj_coff_bss PARAMS ((int));
63 static void obj_coff_weak PARAMS ((int));
64 const char *s_get_name PARAMS ((symbolS * s));
65 static void obj_coff_ln PARAMS ((int));
66 static void obj_coff_def PARAMS ((int));
67 static void obj_coff_endef PARAMS ((int));
68 static void obj_coff_dim PARAMS ((int));
69 static void obj_coff_line PARAMS ((int));
70 static void obj_coff_size PARAMS ((int));
71 static void obj_coff_scl PARAMS ((int));
72 static void obj_coff_tag PARAMS ((int));
73 static void obj_coff_val PARAMS ((int));
74 static void obj_coff_type PARAMS ((int));
75 static void obj_coff_ident PARAMS ((int));
77 static void obj_coff_loc PARAMS((int));
83 stack_init (chunk_size, element_size)
84 unsigned long chunk_size;
85 unsigned long element_size;
89 st = (stack *) malloc (sizeof (stack));
92 st->data = malloc (chunk_size);
99 st->size = chunk_size;
100 st->chunk_size = chunk_size;
101 st->element_size = element_size;
106 /* Not currently used. */
117 stack_push (st, element)
121 if (st->pointer + st->element_size >= st->size)
123 st->size += st->chunk_size;
124 if ((st->data = xrealloc (st->data, st->size)) == (char *) 0)
127 memcpy (st->data + st->pointer, element, st->element_size);
128 st->pointer += st->element_size;
129 return st->data + st->pointer;
136 if (st->pointer < st->element_size)
141 st->pointer -= st->element_size;
142 return st->data + st->pointer;
146 * Maintain a list of the tagnames of the structres.
149 static struct hash_control *tag_hash;
154 tag_hash = hash_new ();
158 tag_insert (name, symbolP)
162 const char *error_string;
164 if ((error_string = hash_jam (tag_hash, name, (char *) symbolP)))
166 as_fatal (_("Inserting \"%s\" into structure table failed: %s"),
175 #ifdef STRIP_UNDERSCORE
178 #endif /* STRIP_UNDERSCORE */
179 return (symbolS *) hash_find (tag_hash, name);
183 tag_find_or_make (name)
188 if ((symbolP = tag_find (name)) == NULL)
190 symbolP = symbol_new (name, undefined_section,
191 0, &zero_address_frag);
193 tag_insert (S_GET_NAME (symbolP), symbolP);
195 symbol_table_insert (symbolP);
202 /* We accept the .bss directive to set the section for backward
203 compatibility with earlier versions of gas. */
206 obj_coff_bss (ignore)
207 int ignore ATTRIBUTE_UNUSED;
209 if (*input_line_pointer == '\n')
210 subseg_new (".bss", get_absolute_expression ());
215 /* Handle .weak. This is a GNU extension. */
218 obj_coff_weak (ignore)
219 int ignore ATTRIBUTE_UNUSED;
227 name = input_line_pointer;
228 c = get_symbol_end ();
229 symbolP = symbol_find_or_make (name);
230 *input_line_pointer = c;
233 #if defined BFD_ASSEMBLER || defined S_SET_WEAK
234 S_SET_WEAK (symbolP);
238 S_SET_STORAGE_CLASS (symbolP, C_NT_WEAK);
240 S_SET_STORAGE_CLASS (symbolP, C_WEAKEXT);
245 input_line_pointer++;
247 if (*input_line_pointer == '\n')
253 demand_empty_rest_of_line ();
258 static segT fetch_coff_debug_section PARAMS ((void));
259 static void SA_SET_SYM_TAGNDX PARAMS ((symbolS *, symbolS *));
260 static int S_GET_DATA_TYPE PARAMS ((symbolS *));
261 void c_symbol_merge PARAMS ((symbolS *, symbolS *));
262 static void add_lineno PARAMS ((fragS *, addressT, int));
264 #define GET_FILENAME_STRING(X) \
265 ((char*) (&((X)->sy_symbol.ost_auxent->x_file.x_n.x_offset))[1])
269 fetch_coff_debug_section ()
271 static segT debug_section;
275 s = bfd_make_debug_symbol (stdoutput, (char *) 0, 0);
277 debug_section = s->section;
279 return debug_section;
283 SA_SET_SYM_ENDNDX (sym, val)
287 combined_entry_type *entry, *p;
289 entry = &coffsymbol (symbol_get_bfdsym (sym))->native[1];
290 p = coffsymbol (symbol_get_bfdsym (val))->native;
291 entry->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p = p;
296 SA_SET_SYM_TAGNDX (sym, val)
300 combined_entry_type *entry, *p;
302 entry = &coffsymbol (symbol_get_bfdsym (sym))->native[1];
303 p = coffsymbol (symbol_get_bfdsym (val))->native;
304 entry->u.auxent.x_sym.x_tagndx.p = p;
309 S_GET_DATA_TYPE (sym)
312 return coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_type;
316 S_SET_DATA_TYPE (sym, val)
320 coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_type = val;
325 S_GET_STORAGE_CLASS (sym)
328 return coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_sclass;
332 S_SET_STORAGE_CLASS (sym, val)
336 coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_sclass = val;
340 /* Merge a debug symbol containing debug information into a normal symbol. */
343 c_symbol_merge (debug, normal)
347 S_SET_DATA_TYPE (normal, S_GET_DATA_TYPE (debug));
348 S_SET_STORAGE_CLASS (normal, S_GET_STORAGE_CLASS (debug));
350 if (S_GET_NUMBER_AUXILIARY (debug) > S_GET_NUMBER_AUXILIARY (normal))
352 /* take the most we have */
353 S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));
356 if (S_GET_NUMBER_AUXILIARY (debug) > 0)
358 /* Move all the auxiliary information. */
359 memcpy (SYM_AUXINFO (normal), SYM_AUXINFO (debug),
360 (S_GET_NUMBER_AUXILIARY (debug)
361 * sizeof (*SYM_AUXINFO (debug))));
364 /* Move the debug flags. */
365 SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
369 c_dot_file_symbol (filename)
370 const char *filename;
374 /* BFD converts filename to a .file symbol with an aux entry. It
375 also handles chaining. */
376 symbolP = symbol_new (filename, bfd_abs_section_ptr, 0, &zero_address_frag);
378 S_SET_STORAGE_CLASS (symbolP, C_FILE);
379 S_SET_NUMBER_AUXILIARY (symbolP, 1);
381 symbol_get_bfdsym (symbolP)->flags = BSF_DEBUGGING;
388 listing_source_file (filename);
393 /* Make sure that the symbol is first on the symbol chain */
394 if (symbol_rootP != symbolP)
396 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
397 symbol_insert (symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
398 } /* if not first on the list */
401 /* Line number handling */
404 struct line_no *next;
411 /* Symbol of last function, which we should hang line#s off of. */
412 static symbolS *line_fsym;
414 #define in_function() (line_fsym != 0)
415 #define clear_function() (line_fsym = 0)
416 #define set_function(F) (line_fsym = (F), coff_add_linesym (F))
420 coff_obj_symbol_new_hook (symbolP)
423 long sz = (OBJ_COFF_MAX_AUXENTRIES + 1) * sizeof (combined_entry_type);
424 char * s = (char *) xmalloc (sz);
427 coffsymbol (symbol_get_bfdsym (symbolP))->native = (combined_entry_type *) s;
429 S_SET_DATA_TYPE (symbolP, T_NULL);
430 S_SET_STORAGE_CLASS (symbolP, 0);
431 S_SET_NUMBER_AUXILIARY (symbolP, 0);
433 if (S_IS_STRING (symbolP))
434 SF_SET_STRING (symbolP);
436 if (S_IS_LOCAL (symbolP))
437 SF_SET_LOCAL (symbolP);
442 * Handle .ln directives.
445 static symbolS *current_lineno_sym;
446 static struct line_no *line_nos;
447 /* @@ Blindly assume all .ln directives will be in the .text section... */
451 add_lineno (frag, offset, num)
456 struct line_no *new_line =
457 (struct line_no *) xmalloc (sizeof (struct line_no));
458 if (!current_lineno_sym)
464 /* The native aix assembler accepts negative line number */
468 /* Zero is used as an end marker in the file. */
469 as_warn (_("Line numbers must be positive integers\n"));
472 #endif /* OBJ_XCOFF */
473 new_line->next = line_nos;
474 new_line->frag = frag;
475 new_line->l.line_number = num;
476 new_line->l.u.offset = offset;
482 coff_add_linesym (sym)
487 coffsymbol (symbol_get_bfdsym (current_lineno_sym))->lineno =
492 current_lineno_sym = sym;
496 obj_coff_ln (appline)
501 if (! appline && def_symbol_in_progress != NULL)
503 as_warn (_(".ln pseudo-op inside .def/.endef: ignored."));
504 demand_empty_rest_of_line ();
508 l = get_absolute_expression ();
510 /* If there is no lineno symbol, treat a .ln
511 directive as if it were a .appline directive. */
512 if (appline || current_lineno_sym == NULL)
513 new_logical_line ((char *) NULL, l - 1);
515 add_lineno (frag_now, frag_now_fix (), l);
524 l += coff_line_base - 1;
525 listing_source_line (l);
530 demand_empty_rest_of_line ();
533 /* .loc is essentially the same as .ln; parse it for assembler
537 obj_coff_loc (ignore)
538 int ignore ATTRIBUTE_UNUSED;
542 /* FIXME: Why do we need this check? We need it for ECOFF, but why
543 do we need it for COFF? */
544 if (now_seg != text_section)
546 as_warn (_(".loc outside of .text"));
547 demand_empty_rest_of_line ();
551 if (def_symbol_in_progress != NULL)
553 as_warn (_(".loc pseudo-op inside .def/.endef: ignored."));
554 demand_empty_rest_of_line ();
558 /* Skip the file number. */
560 get_absolute_expression ();
563 lineno = get_absolute_expression ();
571 lineno += coff_line_base - 1;
572 listing_source_line (lineno);
577 demand_empty_rest_of_line ();
579 add_lineno (frag_now, frag_now_fix (), lineno);
582 /* Handle the .ident pseudo-op. */
585 obj_coff_ident (ignore)
586 int ignore ATTRIBUTE_UNUSED;
588 segT current_seg = now_seg;
589 subsegT current_subseg = now_subseg;
595 /* We could put it in .comment, but that creates an extra section
596 that shouldn't be loaded into memory, which requires linker
597 changes... For now, until proven otherwise, use .rdata. */
598 sec = subseg_new (".rdata$zzz", 0);
599 bfd_set_section_flags (stdoutput, sec,
600 ((SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA)
601 & bfd_applicable_section_flags (stdoutput)));
604 subseg_new (".comment", 0);
608 subseg_set (current_seg, current_subseg);
614 * Handle .def directives.
616 * One might ask : why can't we symbol_new if the symbol does not
617 * already exist and fill it with debug information. Because of
618 * the C_EFCN special symbol. It would clobber the value of the
619 * function symbol before we have a chance to notice that it is
620 * a C_EFCN. And a second reason is that the code is more clear this
621 * way. (at least I think it is :-).
625 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
626 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
627 *input_line_pointer == '\t') \
628 input_line_pointer++;
632 int what ATTRIBUTE_UNUSED;
634 char name_end; /* Char after the end of name */
635 char *symbol_name; /* Name of the debug symbol */
636 char *symbol_name_copy; /* Temporary copy of the name */
637 unsigned int symbol_name_length;
639 if (def_symbol_in_progress != NULL)
641 as_warn (_(".def pseudo-op used inside of .def/.endef: ignored."));
642 demand_empty_rest_of_line ();
644 } /* if not inside .def/.endef */
648 symbol_name = input_line_pointer;
649 #ifdef STRIP_UNDERSCORE
650 if (symbol_name[0] == '_' && symbol_name[1] != 0)
652 #endif /* STRIP_UNDERSCORE */
654 name_end = get_symbol_end ();
655 symbol_name_length = strlen (symbol_name);
656 symbol_name_copy = xmalloc (symbol_name_length + 1);
657 strcpy (symbol_name_copy, symbol_name);
658 #ifdef tc_canonicalize_symbol_name
659 symbol_name_copy = tc_canonicalize_symbol_name (symbol_name_copy);
662 /* Initialize the new symbol */
663 def_symbol_in_progress = symbol_make (symbol_name_copy);
664 symbol_set_frag (def_symbol_in_progress, &zero_address_frag);
665 S_SET_VALUE (def_symbol_in_progress, 0);
667 if (S_IS_STRING (def_symbol_in_progress))
668 SF_SET_STRING (def_symbol_in_progress);
670 *input_line_pointer = name_end;
672 demand_empty_rest_of_line ();
675 unsigned int dim_index;
678 obj_coff_endef (ignore)
679 int ignore ATTRIBUTE_UNUSED;
681 symbolS *symbolP = NULL;
683 /* DIM BUG FIX sac@cygnus.com */
685 if (def_symbol_in_progress == NULL)
687 as_warn (_(".endef pseudo-op used outside of .def/.endef: ignored."));
688 demand_empty_rest_of_line ();
690 } /* if not inside .def/.endef */
692 /* Set the section number according to storage class. */
693 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))
698 SF_SET_TAG (def_symbol_in_progress);
699 /* intentional fallthrough */
702 SF_SET_DEBUG (def_symbol_in_progress);
703 S_SET_SEGMENT (def_symbol_in_progress, fetch_coff_debug_section ());
707 SF_SET_LOCAL (def_symbol_in_progress); /* Do not emit this symbol. */
708 /* intentional fallthrough */
710 SF_SET_PROCESS (def_symbol_in_progress); /* Will need processing before writing */
711 /* intentional fallthrough */
715 S_SET_SEGMENT (def_symbol_in_progress, text_section);
717 name = S_GET_NAME (def_symbol_in_progress);
718 if (name[0] == '.' && name[2] == 'f' && name[3] == '\0')
724 if (! in_function ())
725 as_warn (_("`%s' symbol without preceding function"), name);
726 /* Will need relocating. */
727 SF_SET_PROCESS (def_symbol_in_progress);
733 /* The MS compilers output the actual endline, not the
734 function-relative one... we want to match without
735 changing the assembler input. */
736 SA_SET_SYM_LNNO (def_symbol_in_progress,
737 (SA_GET_SYM_LNNO (def_symbol_in_progress)
748 #endif /* C_AUTOARG */
755 /* According to the COFF documentation:
757 http://osr5doc.sco.com:1996/topics/COFF_SectNumFld.html
759 A special section number (-2) marks symbolic debugging symbols,
760 including structure/union/enumeration tag names, typedefs, and
761 the name of the file. A section number of -1 indicates that the
762 symbol has a value but is not relocatable. Examples of
763 absolute-valued symbols include automatic and register variables,
764 function arguments, and .eos symbols.
766 But from Ian Lance Taylor:
768 http://sources.redhat.com/ml/binutils/2000-08/msg00202.html
770 the actual tools all marked them as section -1. So the GNU COFF
771 assembler follows historical COFF assemblers.
773 However, it causes problems for djgpp
775 http://sources.redhat.com/ml/binutils/2000-08/msg00210.html
777 By defining STRICTCOFF, a COFF port can make the assembler to
778 follow the documented behavior. */
785 SF_SET_DEBUG (def_symbol_in_progress);
786 S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
794 S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
805 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
812 as_warn (_("unexpected storage class %d"),
813 S_GET_STORAGE_CLASS (def_symbol_in_progress));
815 } /* switch on storage class */
817 /* Now that we have built a debug symbol, try to find if we should
818 merge with an existing symbol or not. If a symbol is C_EFCN or
819 absolute_section or untagged SEG_DEBUG it never merges. We also
820 don't merge labels, which are in a different namespace, nor
821 symbols which have not yet been defined since they are typically
822 unique, nor do we merge tags with non-tags. */
824 /* Two cases for functions. Either debug followed by definition or
825 definition followed by debug. For definition first, we will
826 merge the debug symbol into the definition. For debug first, the
827 lineno entry MUST point to the definition function or else it
828 will point off into space when obj_crawl_symbol_chain() merges
829 the debug symbol into the real symbol. Therefor, let's presume
830 the debug symbol is a real function reference. */
832 /* FIXME-SOON If for some reason the definition label/symbol is
833 never seen, this will probably leave an undefined symbol at link
836 if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN
837 || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_LABEL
838 || (!strcmp (bfd_get_section_name (stdoutput,
839 S_GET_SEGMENT (def_symbol_in_progress)),
841 && !SF_GET_TAG (def_symbol_in_progress))
842 || S_GET_SEGMENT (def_symbol_in_progress) == absolute_section
843 || ! symbol_constant_p (def_symbol_in_progress)
844 || (symbolP = symbol_find_base (S_GET_NAME (def_symbol_in_progress),
845 DO_NOT_STRIP)) == NULL
846 || SF_GET_TAG (def_symbol_in_progress) != SF_GET_TAG (symbolP))
848 /* If it already is at the end of the symbol list, do nothing */
849 if (def_symbol_in_progress != symbol_lastP)
851 symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
852 symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP,
858 /* This symbol already exists, merge the newly created symbol
859 into the old one. This is not mandatory. The linker can
860 handle duplicate symbols correctly. But I guess that it save
861 a *lot* of space if the assembly file defines a lot of
864 /* The debug entry (def_symbol_in_progress) is merged into the
865 previous definition. */
867 c_symbol_merge (def_symbol_in_progress, symbolP);
868 symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
870 def_symbol_in_progress = symbolP;
872 if (SF_GET_FUNCTION (def_symbol_in_progress)
873 || SF_GET_TAG (def_symbol_in_progress)
874 || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_STAT)
876 /* For functions, and tags, and static symbols, the symbol
877 *must* be where the debug symbol appears. Move the
878 existing symbol to the current place. */
879 /* If it already is at the end of the symbol list, do nothing */
880 if (def_symbol_in_progress != symbol_lastP)
882 symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
883 symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP, &symbol_lastP);
888 if (SF_GET_TAG (def_symbol_in_progress))
892 oldtag = symbol_find_base (S_GET_NAME (def_symbol_in_progress),
894 if (oldtag == NULL || ! SF_GET_TAG (oldtag))
895 tag_insert (S_GET_NAME (def_symbol_in_progress),
896 def_symbol_in_progress);
899 if (SF_GET_FUNCTION (def_symbol_in_progress))
901 know (sizeof (def_symbol_in_progress) <= sizeof (long));
902 set_function (def_symbol_in_progress);
903 SF_SET_PROCESS (def_symbol_in_progress);
907 /* That is, if this is the first time we've seen the
909 symbol_table_insert (def_symbol_in_progress);
910 } /* definition follows debug */
911 } /* Create the line number entry pointing to the function being defined */
913 def_symbol_in_progress = NULL;
914 demand_empty_rest_of_line ();
918 obj_coff_dim (ignore)
919 int ignore ATTRIBUTE_UNUSED;
923 if (def_symbol_in_progress == NULL)
925 as_warn (_(".dim pseudo-op used outside of .def/.endef: ignored."));
926 demand_empty_rest_of_line ();
928 } /* if not inside .def/.endef */
930 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
932 for (dim_index = 0; dim_index < DIMNUM; dim_index++)
935 SA_SET_SYM_DIMEN (def_symbol_in_progress, dim_index,
936 get_absolute_expression ());
938 switch (*input_line_pointer)
941 input_line_pointer++;
945 as_warn (_("badly formed .dim directive ignored"));
946 /* intentional fallthrough */
954 demand_empty_rest_of_line ();
958 obj_coff_line (ignore)
959 int ignore ATTRIBUTE_UNUSED;
963 if (def_symbol_in_progress == NULL)
965 /* Probably stabs-style line? */
970 this_base = get_absolute_expression ();
971 if (!strcmp (".bf", S_GET_NAME (def_symbol_in_progress)))
972 coff_line_base = this_base;
974 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
975 SA_SET_SYM_LNNO (def_symbol_in_progress, this_base);
977 demand_empty_rest_of_line ();
980 if (strcmp (".bf", S_GET_NAME (def_symbol_in_progress)) == 0)
985 listing_source_line ((unsigned int) this_base);
991 obj_coff_size (ignore)
992 int ignore ATTRIBUTE_UNUSED;
994 if (def_symbol_in_progress == NULL)
996 as_warn (_(".size pseudo-op used outside of .def/.endef ignored."));
997 demand_empty_rest_of_line ();
999 } /* if not inside .def/.endef */
1001 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
1002 SA_SET_SYM_SIZE (def_symbol_in_progress, get_absolute_expression ());
1003 demand_empty_rest_of_line ();
1007 obj_coff_scl (ignore)
1008 int ignore ATTRIBUTE_UNUSED;
1010 if (def_symbol_in_progress == NULL)
1012 as_warn (_(".scl pseudo-op used outside of .def/.endef ignored."));
1013 demand_empty_rest_of_line ();
1015 } /* if not inside .def/.endef */
1017 S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ());
1018 demand_empty_rest_of_line ();
1022 obj_coff_tag (ignore)
1023 int ignore ATTRIBUTE_UNUSED;
1028 if (def_symbol_in_progress == NULL)
1030 as_warn (_(".tag pseudo-op used outside of .def/.endef ignored."));
1031 demand_empty_rest_of_line ();
1035 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
1036 symbol_name = input_line_pointer;
1037 name_end = get_symbol_end ();
1039 #ifdef tc_canonicalize_symbol_name
1040 symbol_name = tc_canonicalize_symbol_name (symbol_name);
1043 /* Assume that the symbol referred to by .tag is always defined.
1044 This was a bad assumption. I've added find_or_make. xoxorich. */
1045 SA_SET_SYM_TAGNDX (def_symbol_in_progress,
1046 tag_find_or_make (symbol_name));
1047 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L)
1049 as_warn (_("tag not found for .tag %s"), symbol_name);
1052 SF_SET_TAGGED (def_symbol_in_progress);
1053 *input_line_pointer = name_end;
1055 demand_empty_rest_of_line ();
1059 obj_coff_type (ignore)
1060 int ignore ATTRIBUTE_UNUSED;
1062 if (def_symbol_in_progress == NULL)
1064 as_warn (_(".type pseudo-op used outside of .def/.endef ignored."));
1065 demand_empty_rest_of_line ();
1067 } /* if not inside .def/.endef */
1069 S_SET_DATA_TYPE (def_symbol_in_progress, get_absolute_expression ());
1071 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress)) &&
1072 S_GET_STORAGE_CLASS (def_symbol_in_progress) != C_TPDEF)
1074 SF_SET_FUNCTION (def_symbol_in_progress);
1075 } /* is a function */
1077 demand_empty_rest_of_line ();
1081 obj_coff_val (ignore)
1082 int ignore ATTRIBUTE_UNUSED;
1084 if (def_symbol_in_progress == NULL)
1086 as_warn (_(".val pseudo-op used outside of .def/.endef ignored."));
1087 demand_empty_rest_of_line ();
1089 } /* if not inside .def/.endef */
1091 if (is_name_beginner (*input_line_pointer))
1093 char *symbol_name = input_line_pointer;
1094 char name_end = get_symbol_end ();
1096 #ifdef tc_canonicalize_symbol_name
1097 symbol_name = tc_canonicalize_symbol_name (symbol_name);
1099 if (!strcmp (symbol_name, "."))
1101 symbol_set_frag (def_symbol_in_progress, frag_now);
1102 S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
1103 /* If the .val is != from the .def (e.g. statics) */
1105 else if (strcmp (S_GET_NAME (def_symbol_in_progress), symbol_name))
1109 exp.X_op = O_symbol;
1110 exp.X_add_symbol = symbol_find_or_make (symbol_name);
1111 exp.X_op_symbol = NULL;
1112 exp.X_add_number = 0;
1113 symbol_set_value_expression (def_symbol_in_progress, &exp);
1115 /* If the segment is undefined when the forward reference is
1116 resolved, then copy the segment id from the forward
1118 SF_SET_GET_SEGMENT (def_symbol_in_progress);
1120 /* FIXME: gcc can generate address expressions here in
1121 unusual cases (search for "obscure" in sdbout.c). We
1122 just ignore the offset here, thus generating incorrect
1123 debugging information. We ignore the rest of the line
1126 /* Otherwise, it is the name of a non debug symbol and its value
1127 will be calculated later. */
1128 *input_line_pointer = name_end;
1132 S_SET_VALUE (def_symbol_in_progress, get_absolute_expression ());
1133 } /* if symbol based */
1135 demand_empty_rest_of_line ();
1139 coff_obj_read_begin_hook ()
1141 /* These had better be the same. Usually 18 bytes. */
1143 know (sizeof (SYMENT) == sizeof (AUXENT));
1144 know (SYMESZ == AUXESZ);
1149 symbolS *coff_last_function;
1150 static symbolS *coff_last_bf;
1153 coff_frob_symbol (symp, punt)
1157 static symbolS *last_tagP;
1158 static stack *block_stack;
1159 static symbolS *set_end;
1160 symbolS *next_set_end = NULL;
1162 if (symp == &abs_symbol)
1168 if (current_lineno_sym)
1169 coff_add_linesym ((symbolS *) 0);
1172 block_stack = stack_init (512, sizeof (symbolS*));
1174 if (S_IS_WEAK (symp))
1177 S_SET_STORAGE_CLASS (symp, C_NT_WEAK);
1179 S_SET_STORAGE_CLASS (symp, C_WEAKEXT);
1183 if (!S_IS_DEFINED (symp)
1184 && !S_IS_WEAK (symp)
1185 && S_GET_STORAGE_CLASS (symp) != C_STAT)
1186 S_SET_STORAGE_CLASS (symp, C_EXT);
1188 if (!SF_GET_DEBUG (symp))
1192 if (!SF_GET_LOCAL (symp)
1193 && !SF_GET_STATICS (symp)
1194 && S_GET_STORAGE_CLASS (symp) != C_LABEL
1195 && symbol_constant_p(symp)
1196 && (real = symbol_find_base (S_GET_NAME (symp), DO_NOT_STRIP))
1197 && S_GET_STORAGE_CLASS (real) == C_NULL
1200 c_symbol_merge (symp, real);
1205 if (!S_IS_DEFINED (symp) && !SF_GET_LOCAL (symp))
1207 assert (S_GET_VALUE (symp) == 0);
1208 S_SET_EXTERNAL (symp);
1210 else if (S_GET_STORAGE_CLASS (symp) == C_NULL)
1212 if (S_GET_SEGMENT (symp) == text_section
1213 && symp != seg_info (text_section)->sym)
1214 S_SET_STORAGE_CLASS (symp, C_LABEL);
1216 S_SET_STORAGE_CLASS (symp, C_STAT);
1219 if (SF_GET_PROCESS (symp))
1221 if (S_GET_STORAGE_CLASS (symp) == C_BLOCK)
1223 if (!strcmp (S_GET_NAME (symp), ".bb"))
1224 stack_push (block_stack, (char *) &symp);
1229 begin = *(symbolS **) stack_pop (block_stack);
1231 as_warn (_("mismatched .eb"));
1233 next_set_end = begin;
1237 if (coff_last_function == 0 && SF_GET_FUNCTION (symp))
1239 union internal_auxent *auxp;
1241 coff_last_function = symp;
1242 if (S_GET_NUMBER_AUXILIARY (symp) < 1)
1243 S_SET_NUMBER_AUXILIARY (symp, 1);
1244 auxp = SYM_AUXENT (symp);
1245 memset (auxp->x_sym.x_fcnary.x_ary.x_dimen, 0,
1246 sizeof (auxp->x_sym.x_fcnary.x_ary.x_dimen));
1249 if (S_GET_STORAGE_CLASS (symp) == C_EFCN)
1251 if (coff_last_function == 0)
1252 as_fatal (_("C_EFCN symbol out of scope"));
1253 SA_SET_SYM_FSIZE (coff_last_function,
1254 (long) (S_GET_VALUE (symp)
1255 - S_GET_VALUE (coff_last_function)));
1256 next_set_end = coff_last_function;
1257 coff_last_function = 0;
1261 if (S_IS_EXTERNAL (symp))
1262 S_SET_STORAGE_CLASS (symp, C_EXT);
1263 else if (SF_GET_LOCAL (symp))
1266 if (SF_GET_FUNCTION (symp))
1267 symbol_get_bfdsym (symp)->flags |= BSF_FUNCTION;
1272 /* Double check weak symbols. */
1273 if (S_IS_WEAK (symp) && S_IS_COMMON (symp))
1274 as_bad (_("Symbol `%s' can not be both weak and common"),
1277 if (SF_GET_TAG (symp))
1279 else if (S_GET_STORAGE_CLASS (symp) == C_EOS)
1280 next_set_end = last_tagP;
1283 /* This is pretty horrible, but we have to set *punt correctly in
1284 order to call SA_SET_SYM_ENDNDX correctly. */
1285 if (! symbol_used_in_reloc_p (symp)
1286 && ((symbol_get_bfdsym (symp)->flags & BSF_SECTION_SYM) != 0
1287 || (! S_IS_EXTERNAL (symp)
1288 && ! symbol_get_tc (symp)->output
1289 && S_GET_STORAGE_CLASS (symp) != C_FILE)))
1293 if (set_end != (symbolS *) NULL
1295 && ((symbol_get_bfdsym (symp)->flags & BSF_NOT_AT_END) != 0
1296 || (S_IS_DEFINED (symp)
1297 && ! S_IS_COMMON (symp)
1298 && (! S_IS_EXTERNAL (symp) || SF_GET_FUNCTION (symp)))))
1300 SA_SET_SYM_ENDNDX (set_end, symp);
1304 if (next_set_end != NULL)
1306 if (set_end != NULL)
1307 as_warn ("Warning: internal error: forgetting to set endndx of %s",
1308 S_GET_NAME (set_end));
1309 set_end = next_set_end;
1313 && S_GET_STORAGE_CLASS (symp) == C_FCN
1314 && strcmp (S_GET_NAME (symp), ".bf") == 0)
1316 if (coff_last_bf != NULL)
1317 SA_SET_SYM_ENDNDX (coff_last_bf, symp);
1318 coff_last_bf = symp;
1321 if (coffsymbol (symbol_get_bfdsym (symp))->lineno)
1324 struct line_no *lptr;
1327 lptr = (struct line_no *) coffsymbol (symbol_get_bfdsym (symp))->lineno;
1328 for (i = 0; lptr; lptr = lptr->next)
1330 lptr = (struct line_no *) coffsymbol (symbol_get_bfdsym (symp))->lineno;
1332 /* We need i entries for line numbers, plus 1 for the first
1333 entry which BFD will override, plus 1 for the last zero
1334 entry (a marker for BFD). */
1335 l = (alent *) xmalloc ((i + 2) * sizeof (alent));
1336 coffsymbol (symbol_get_bfdsym (symp))->lineno = l;
1337 l[i + 1].line_number = 0;
1338 l[i + 1].u.sym = NULL;
1342 lptr->l.u.offset += lptr->frag->fr_address / OCTETS_PER_BYTE;
1350 coff_adjust_section_syms (abfd, sec, x)
1351 bfd *abfd ATTRIBUTE_UNUSED;
1353 PTR x ATTRIBUTE_UNUSED;
1356 segment_info_type *seginfo = seg_info (sec);
1357 int nlnno, nrelocs = 0;
1359 /* RS/6000 gas creates a .debug section manually in ppc_frob_file in
1360 tc-ppc.c. Do not get confused by it. */
1361 if (seginfo == NULL)
1364 if (!strcmp (sec->name, ".text"))
1365 nlnno = coff_n_line_nos;
1369 /* @@ Hope that none of the fixups expand to more than one reloc
1371 fixS *fixp = seginfo->fix_root;
1374 if (! fixp->fx_done)
1376 fixp = fixp->fx_next;
1379 if (bfd_get_section_size_before_reloc (sec) == 0
1382 && sec != text_section
1383 && sec != data_section
1384 && sec != bss_section)
1386 secsym = section_symbol (sec);
1387 /* This is an estimate; we'll plug in the real value using
1388 SET_SECTION_RELOCS later */
1389 SA_SET_SCN_NRELOC (secsym, nrelocs);
1390 SA_SET_SCN_NLINNO (secsym, nlnno);
1394 coff_frob_file_after_relocs ()
1396 bfd_map_over_sections (stdoutput, coff_adjust_section_syms, (char*) 0);
1400 * implement the .section pseudo op:
1401 * .section name {, "flags"}
1403 * | +--- optional flags: 'b' for bss
1405 * +-- section name 'l' for lib
1409 * 'd' (apparently m88k for data)
1411 * 'r' for read-only data
1412 * 's' for shared data (PE)
1413 * But if the argument is not a quoted string, treat it as a
1414 * subsegment number.
1418 obj_coff_section (ignore)
1419 int ignore ATTRIBUTE_UNUSED;
1421 /* Strip out the section name */
1426 flagword flags, oldflags;
1437 section_name = input_line_pointer;
1438 c = get_symbol_end ();
1440 name = xmalloc (input_line_pointer - section_name + 1);
1441 strcpy (name, section_name);
1443 *input_line_pointer = c;
1448 flags = SEC_NO_FLAGS;
1450 if (*input_line_pointer == ',')
1452 ++input_line_pointer;
1454 if (*input_line_pointer != '"')
1455 exp = get_absolute_expression ();
1458 ++input_line_pointer;
1459 while (*input_line_pointer != '"'
1460 && ! is_end_of_line[(unsigned char) *input_line_pointer])
1462 switch (*input_line_pointer)
1464 case 'b': flags |= SEC_ALLOC; flags &=~ SEC_LOAD; break;
1465 case 'n': flags &=~ SEC_LOAD; flags |= SEC_NEVER_LOAD; break;
1466 case 'd': flags |= SEC_DATA | SEC_LOAD; /* fall through */
1467 case 'w': flags &=~ SEC_READONLY; break;
1468 case 'x': flags |= SEC_CODE | SEC_LOAD; break;
1469 case 'r': flags |= SEC_READONLY; break;
1470 case 's': flags |= SEC_SHARED; break;
1472 case 'i': /* STYP_INFO */
1473 case 'l': /* STYP_LIB */
1474 case 'o': /* STYP_OVER */
1475 as_warn (_("unsupported section attribute '%c'"),
1476 *input_line_pointer);
1480 as_warn(_("unknown section attribute '%c'"),
1481 *input_line_pointer);
1484 ++input_line_pointer;
1486 if (*input_line_pointer == '"')
1487 ++input_line_pointer;
1491 sec = subseg_new (name, (subsegT) exp);
1493 oldflags = bfd_get_section_flags (stdoutput, sec);
1494 if (oldflags == SEC_NO_FLAGS)
1496 /* Set section flags for a new section just created by subseg_new.
1497 Provide a default if no flags were parsed. */
1498 if (flags == SEC_NO_FLAGS)
1499 flags = TC_COFF_SECTION_DEFAULT_ATTRIBUTES;
1501 #ifdef COFF_LONG_SECTION_NAMES
1502 /* Add SEC_LINK_ONCE and SEC_LINK_DUPLICATES_DISCARD to .gnu.linkonce
1503 sections so adjust_reloc_syms in write.c will correctly handle
1504 relocs which refer to non-local symbols in these sections. */
1505 if (strncmp (name, ".gnu.linkonce", sizeof (".gnu.linkonce") - 1) == 0)
1506 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1509 if (! bfd_set_section_flags (stdoutput, sec, flags))
1510 as_warn (_("error setting flags for \"%s\": %s"),
1511 bfd_section_name (stdoutput, sec),
1512 bfd_errmsg (bfd_get_error ()));
1514 else if (flags != SEC_NO_FLAGS)
1516 /* This section's attributes have already been set. Warn if the
1517 attributes don't match. */
1518 flagword matchflags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE
1519 | SEC_DATA | SEC_SHARED | SEC_NEVER_LOAD);
1520 if ((flags ^ oldflags) & matchflags)
1521 as_warn (_("Ignoring changed section attributes for %s"), name);
1524 demand_empty_rest_of_line ();
1528 coff_adjust_symtab ()
1530 if (symbol_rootP == NULL
1531 || S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
1532 c_dot_file_symbol ("fake");
1536 coff_frob_section (sec)
1542 bfd_vma size, n_entries, mask;
1543 bfd_vma align_power = (bfd_vma)sec->alignment_power + OCTETS_PER_BYTE_POWER;
1545 /* The COFF back end in BFD requires that all section sizes be
1546 rounded up to multiples of the corresponding section alignments,
1547 supposedly because standard COFF has no other way of encoding alignment
1548 for sections. If your COFF flavor has a different way of encoding
1549 section alignment, then skip this step, as TICOFF does. */
1550 size = bfd_get_section_size_before_reloc (sec);
1551 mask = ((bfd_vma) 1 << align_power) - 1;
1552 #if !defined(TICOFF)
1558 new_size = (size + mask) & ~mask;
1559 bfd_set_section_size (stdoutput, sec, new_size);
1561 /* If the size had to be rounded up, add some padding in
1562 the last non-empty frag. */
1563 fragp = seg_info (sec)->frchainP->frch_root;
1564 last = seg_info (sec)->frchainP->frch_last;
1565 while (fragp->fr_next != last)
1566 fragp = fragp->fr_next;
1567 last->fr_address = size;
1568 fragp->fr_offset += new_size - size;
1572 /* If the section size is non-zero, the section symbol needs an aux
1573 entry associated with it, indicating the size. We don't know
1574 all the values yet; coff_frob_symbol will fill them in later. */
1577 || sec == text_section
1578 || sec == data_section
1579 || sec == bss_section)
1582 symbolS *secsym = section_symbol (sec);
1584 S_SET_STORAGE_CLASS (secsym, C_STAT);
1585 S_SET_NUMBER_AUXILIARY (secsym, 1);
1586 SF_SET_STATICS (secsym);
1587 SA_SET_SCN_SCNLEN (secsym, size);
1590 /* @@ these should be in a "stabs.h" file, or maybe as.h */
1591 #ifndef STAB_SECTION_NAME
1592 #define STAB_SECTION_NAME ".stab"
1594 #ifndef STAB_STRING_SECTION_NAME
1595 #define STAB_STRING_SECTION_NAME ".stabstr"
1597 if (strcmp (STAB_STRING_SECTION_NAME, sec->name))
1601 sec = subseg_get (STAB_SECTION_NAME, 0);
1602 /* size is already rounded up, since other section will be listed first */
1603 size = bfd_get_section_size_before_reloc (strsec);
1605 n_entries = bfd_get_section_size_before_reloc (sec) / 12 - 1;
1607 /* Find first non-empty frag. It should be large enough. */
1608 fragp = seg_info (sec)->frchainP->frch_root;
1609 while (fragp && fragp->fr_fix == 0)
1610 fragp = fragp->fr_next;
1611 assert (fragp != 0 && fragp->fr_fix >= 12);
1613 /* Store the values. */
1614 p = fragp->fr_literal;
1615 bfd_h_put_16 (stdoutput, n_entries, (bfd_byte *) p + 6);
1616 bfd_h_put_32 (stdoutput, size, (bfd_byte *) p + 8);
1620 obj_coff_init_stab_section (seg)
1626 unsigned int stroff;
1628 /* Make space for this first symbol. */
1632 as_where (&file, (unsigned int *) NULL);
1633 stabstr_name = (char *) alloca (strlen (seg->name) + 4);
1634 strcpy (stabstr_name, seg->name);
1635 strcat (stabstr_name, "str");
1636 stroff = get_stab_string_offset (file, stabstr_name);
1638 md_number_to_chars (p, stroff, 4);
1647 return ((s == NULL) ? "(NULL)" : S_GET_NAME (s));
1655 for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
1657 printf (_("0x%lx: \"%s\" type = %ld, class = %d, segment = %d\n"),
1658 (unsigned long) symbolP,
1659 S_GET_NAME(symbolP),
1660 (long) S_GET_DATA_TYPE(symbolP),
1661 S_GET_STORAGE_CLASS(symbolP),
1662 (int) S_GET_SEGMENT(symbolP));
1668 #else /* not BFD_ASSEMBLER */
1671 /* This is needed because we include internal bfd things. */
1675 #include "libcoff.h"
1678 #include "coff/pe.h"
1681 /* The NOP_OPCODE is for the alignment fill value. Fill with nop so
1682 that we can stick sections together without causing trouble. */
1684 #define NOP_OPCODE 0x00
1687 /* The zeroes if symbol name is longer than 8 chars */
1688 #define S_SET_ZEROES(s,v) ((s)->sy_symbol.ost_entry.n_zeroes = (v))
1690 #define MIN(a,b) ((a) < (b)? (a) : (b))
1692 /* This vector is used to turn a gas internal segment number into a
1693 section number suitable for insertion into a coff symbol table.
1694 This must correspond to seg_info_off_by_4. */
1696 const short seg_N_TYPE[] =
1697 { /* in: segT out: N_TYPE bits */
1699 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
1700 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
1701 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
1702 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
1703 C_UNDEF_SECTION, /* SEG_UNKNOWN */
1704 C_UNDEF_SECTION, /* SEG_GOOF */
1705 C_UNDEF_SECTION, /* SEG_EXPR */
1706 C_DEBUG_SECTION, /* SEG_DEBUG */
1707 C_NTV_SECTION, /* SEG_NTV */
1708 C_PTV_SECTION, /* SEG_PTV */
1709 C_REGISTER_SECTION, /* SEG_REGISTER */
1712 int function_lineoff = -1; /* Offset in line#s where the last function
1713 started (the odd entry for line #0) */
1715 /* structure used to keep the filenames which
1716 are too long around so that we can stick them
1717 into the string table */
1718 struct filename_list
1721 struct filename_list *next;
1724 static struct filename_list *filename_list_head;
1725 static struct filename_list *filename_list_tail;
1727 static symbolS *last_line_symbol;
1729 /* Add 4 to the real value to get the index and compensate the
1730 negatives. This vector is used by S_GET_SEGMENT to turn a coff
1731 section number into a segment number
1733 static symbolS *previous_file_symbol;
1734 void c_symbol_merge ();
1735 static int line_base;
1737 symbolS *c_section_symbol ();
1740 static void fixup_segment PARAMS ((segment_info_type *segP,
1741 segT this_segment_type));
1743 static void fixup_mdeps PARAMS ((fragS *,
1747 static void fill_section PARAMS ((bfd * abfd,
1751 static int c_line_new PARAMS ((symbolS * symbol, long paddr,
1755 static void w_symbols PARAMS ((bfd * abfd, char *where,
1756 symbolS * symbol_rootP));
1758 static void adjust_stab_section PARAMS ((bfd *abfd, segT seg));
1760 static void obj_coff_lcomm PARAMS ((int));
1761 static void obj_coff_text PARAMS ((int));
1762 static void obj_coff_data PARAMS ((int));
1763 void obj_coff_section PARAMS ((int));
1765 /* When not using BFD_ASSEMBLER, we permit up to 40 sections.
1767 This array maps a COFF section number into a gas section number.
1768 Because COFF uses negative section numbers, you must add 4 to the
1769 COFF section number when indexing into this array; this is done via
1770 the SEG_INFO_FROM_SECTION_NUMBER macro. This must correspond to
1773 static const segT seg_info_off_by_4[] =
1780 SEG_E0, SEG_E1, SEG_E2, SEG_E3, SEG_E4,
1781 SEG_E5, SEG_E6, SEG_E7, SEG_E8, SEG_E9,
1782 SEG_E10, SEG_E11, SEG_E12, SEG_E13, SEG_E14,
1783 SEG_E15, SEG_E16, SEG_E17, SEG_E18, SEG_E19,
1784 SEG_E20, SEG_E21, SEG_E22, SEG_E23, SEG_E24,
1785 SEG_E25, SEG_E26, SEG_E27, SEG_E28, SEG_E29,
1786 SEG_E30, SEG_E31, SEG_E32, SEG_E33, SEG_E34,
1787 SEG_E35, SEG_E36, SEG_E37, SEG_E38, SEG_E39,
1800 #define SEG_INFO_FROM_SECTION_NUMBER(x) (seg_info_off_by_4[(x)+4])
1802 static relax_addressT
1803 relax_align (address, alignment)
1804 relax_addressT address;
1807 relax_addressT mask;
1808 relax_addressT new_address;
1810 mask = ~((~0) << alignment);
1811 new_address = (address + mask) & (~mask);
1812 return (new_address - address);
1819 return SEG_INFO_FROM_SECTION_NUMBER (x->sy_symbol.ost_entry.n_scnum);
1822 /* calculate the size of the frag chain and fill in the section header
1823 to contain all of it, also fill in the addr of the sections */
1825 size_section (abfd, idx)
1826 bfd *abfd ATTRIBUTE_UNUSED;
1830 unsigned int size = 0;
1831 fragS *frag = segment_info[idx].frchainP->frch_root;
1834 size = frag->fr_address;
1835 if (frag->fr_address != size)
1837 fprintf (stderr, _("Out of step\n"));
1838 size = frag->fr_address;
1841 switch (frag->fr_type)
1843 #ifdef TC_COFF_SIZEMACHDEP
1844 case rs_machine_dependent:
1845 size += TC_COFF_SIZEMACHDEP (frag);
1851 size += frag->fr_fix;
1852 size += frag->fr_offset * frag->fr_var;
1860 size += frag->fr_fix;
1861 off = relax_align (size, frag->fr_offset);
1862 if (frag->fr_subtype != 0 && off > frag->fr_subtype)
1868 BAD_CASE (frag->fr_type);
1871 frag = frag->fr_next;
1873 segment_info[idx].scnhdr.s_size = size;
1878 count_entries_in_chain (idx)
1881 unsigned int nrelocs;
1884 /* Count the relocations */
1885 fixup_ptr = segment_info[idx].fix_root;
1887 while (fixup_ptr != (fixS *) NULL)
1889 if (fixup_ptr->fx_done == 0 && TC_COUNT_RELOC (fixup_ptr))
1892 if (fixup_ptr->fx_r_type == RELOC_CONSTH)
1901 fixup_ptr = fixup_ptr->fx_next;
1908 static int compare_external_relocs PARAMS ((const PTR, const PTR));
1910 /* AUX's ld expects relocations to be sorted */
1912 compare_external_relocs (x, y)
1916 struct external_reloc *a = (struct external_reloc *) x;
1917 struct external_reloc *b = (struct external_reloc *) y;
1918 bfd_vma aadr = bfd_getb32 (a->r_vaddr);
1919 bfd_vma badr = bfd_getb32 (b->r_vaddr);
1920 return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
1925 /* output all the relocations for a section */
1927 do_relocs_for (abfd, h, file_cursor)
1930 unsigned long *file_cursor;
1932 unsigned int nrelocs;
1934 unsigned long reloc_start = *file_cursor;
1936 for (idx = SEG_E0; idx < SEG_LAST; idx++)
1938 if (segment_info[idx].scnhdr.s_name[0])
1940 struct external_reloc *ext_ptr;
1941 struct external_reloc *external_reloc_vec;
1942 unsigned int external_reloc_size;
1943 unsigned int base = segment_info[idx].scnhdr.s_paddr;
1944 fixS *fix_ptr = segment_info[idx].fix_root;
1945 nrelocs = count_entries_in_chain (idx);
1948 /* Bypass this stuff if no relocs. This also incidentally
1949 avoids a SCO bug, where free(malloc(0)) tends to crash. */
1951 external_reloc_size = nrelocs * RELSZ;
1952 external_reloc_vec =
1953 (struct external_reloc *) malloc (external_reloc_size);
1955 ext_ptr = external_reloc_vec;
1957 /* Fill in the internal coff style reloc struct from the
1958 internal fix list. */
1961 struct internal_reloc intr;
1963 /* Only output some of the relocations */
1964 if (fix_ptr->fx_done == 0 && TC_COUNT_RELOC (fix_ptr))
1966 #ifdef TC_RELOC_MANGLE
1967 TC_RELOC_MANGLE (&segment_info[idx], fix_ptr, &intr,
1972 symbolS *symbol_ptr = fix_ptr->fx_addsy;
1974 intr.r_type = TC_COFF_FIX2RTYPE (fix_ptr);
1976 base + fix_ptr->fx_frag->fr_address + fix_ptr->fx_where;
1978 #ifdef TC_KEEP_FX_OFFSET
1979 intr.r_offset = fix_ptr->fx_offset;
1984 while (symbol_ptr->sy_value.X_op == O_symbol
1985 && (! S_IS_DEFINED (symbol_ptr)
1986 || S_IS_COMMON (symbol_ptr)))
1990 /* We must avoid looping, as that can occur
1991 with a badly written program. */
1992 n = symbol_ptr->sy_value.X_add_symbol;
1993 if (n == symbol_ptr)
1998 /* Turn the segment of the symbol into an offset. */
2001 resolve_symbol_value (symbol_ptr);
2002 if (! symbol_ptr->sy_resolved)
2007 if (expr_symbol_where (symbol_ptr, &file, &line))
2008 as_bad_where (file, line,
2009 _("unresolved relocation"));
2011 as_bad (_("bad relocation: symbol `%s' not in symbol table"),
2012 S_GET_NAME (symbol_ptr));
2014 dot = segment_info[S_GET_SEGMENT (symbol_ptr)].dot;
2017 intr.r_symndx = dot->sy_number;
2021 intr.r_symndx = symbol_ptr->sy_number;
2031 (void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
2034 #if defined(TC_A29K)
2036 /* The 29k has a special kludge for the high 16 bit
2037 reloc. Two relocations are emited, R_IHIHALF,
2038 and R_IHCONST. The second one doesn't contain a
2039 symbol, but uses the value for offset. */
2041 if (intr.r_type == R_IHIHALF)
2043 /* now emit the second bit */
2044 intr.r_type = R_IHCONST;
2045 intr.r_symndx = fix_ptr->fx_addnumber;
2046 (void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
2052 fix_ptr = fix_ptr->fx_next;
2056 /* Sort the reloc table */
2057 qsort ((PTR) external_reloc_vec, nrelocs,
2058 sizeof (struct external_reloc), compare_external_relocs);
2061 /* Write out the reloc table */
2062 bfd_write ((PTR) external_reloc_vec, 1, external_reloc_size,
2064 free (external_reloc_vec);
2066 /* Fill in section header info. */
2067 segment_info[idx].scnhdr.s_relptr = *file_cursor;
2068 *file_cursor += external_reloc_size;
2069 segment_info[idx].scnhdr.s_nreloc = nrelocs;
2074 segment_info[idx].scnhdr.s_relptr = 0;
2078 /* Set relocation_size field in file headers */
2079 H_SET_RELOCATION_SIZE (h, *file_cursor - reloc_start, 0);
2082 /* run through a frag chain and write out the data to go with it, fill
2083 in the scnhdrs with the info on the file postions
2086 fill_section (abfd, h, file_cursor)
2088 object_headers *h ATTRIBUTE_UNUSED;
2089 unsigned long *file_cursor;
2093 unsigned int paddr = 0;
2095 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
2097 unsigned int offset = 0;
2098 struct internal_scnhdr *s = &(segment_info[i].scnhdr);
2104 fragS *frag = segment_info[i].frchainP->frch_root;
2105 char *buffer = NULL;
2111 buffer = xmalloc (s->s_size);
2112 s->s_scnptr = *file_cursor;
2114 know (s->s_paddr == paddr);
2116 if (strcmp (s->s_name, ".text") == 0)
2117 s->s_flags |= STYP_TEXT;
2118 else if (strcmp (s->s_name, ".data") == 0)
2119 s->s_flags |= STYP_DATA;
2120 else if (strcmp (s->s_name, ".bss") == 0)
2123 s->s_flags |= STYP_BSS;
2125 /* @@ Should make the i386 and a29k coff targets define
2126 COFF_NOLOAD_PROBLEM, and have only one test here. */
2129 #ifndef COFF_NOLOAD_PROBLEM
2130 /* Apparently the SVR3 linker (and exec syscall) and UDI
2131 mondfe progrem are confused by noload sections. */
2132 s->s_flags |= STYP_NOLOAD;
2137 else if (strcmp (s->s_name, ".lit") == 0)
2138 s->s_flags = STYP_LIT | STYP_TEXT;
2139 else if (strcmp (s->s_name, ".init") == 0)
2140 s->s_flags |= STYP_TEXT;
2141 else if (strcmp (s->s_name, ".fini") == 0)
2142 s->s_flags |= STYP_TEXT;
2143 else if (strncmp (s->s_name, ".comment", 8) == 0)
2144 s->s_flags |= STYP_INFO;
2148 unsigned int fill_size;
2149 switch (frag->fr_type)
2151 case rs_machine_dependent:
2154 memcpy (buffer + frag->fr_address,
2156 (unsigned int) frag->fr_fix);
2157 offset += frag->fr_fix;
2169 memcpy (buffer + frag->fr_address,
2171 (unsigned int) frag->fr_fix);
2172 offset += frag->fr_fix;
2175 fill_size = frag->fr_var;
2176 if (fill_size && frag->fr_offset > 0)
2179 unsigned int off = frag->fr_fix;
2180 for (count = frag->fr_offset; count; count--)
2182 if (fill_size + frag->fr_address + off <= s->s_size)
2184 memcpy (buffer + frag->fr_address + off,
2185 frag->fr_literal + frag->fr_fix,
2188 offset += fill_size;
2193 case rs_broken_word:
2198 frag = frag->fr_next;
2203 if (s->s_scnptr != 0)
2205 bfd_write (buffer, s->s_size, 1, abfd);
2206 *file_cursor += s->s_size;
2215 /* Coff file generation & utilities */
2218 coff_header_append (abfd, h)
2225 #ifdef COFF_LONG_SECTION_NAMES
2226 unsigned long string_size = 4;
2229 bfd_seek (abfd, 0, 0);
2231 #ifndef OBJ_COFF_OMIT_OPTIONAL_HEADER
2232 H_SET_MAGIC_NUMBER (h, COFF_MAGIC);
2233 H_SET_VERSION_STAMP (h, 0);
2234 H_SET_ENTRY_POINT (h, 0);
2235 H_SET_TEXT_START (h, segment_info[SEG_E0].frchainP->frch_root->fr_address);
2236 H_SET_DATA_START (h, segment_info[SEG_E1].frchainP->frch_root->fr_address);
2237 H_SET_SIZEOF_OPTIONAL_HEADER (h, bfd_coff_swap_aouthdr_out(abfd, &h->aouthdr,
2239 #else /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
2240 H_SET_SIZEOF_OPTIONAL_HEADER (h, 0);
2241 #endif /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
2243 i = bfd_coff_swap_filehdr_out (abfd, &h->filehdr, buffer);
2245 bfd_write (buffer, i, 1, abfd);
2246 bfd_write (buffero, H_GET_SIZEOF_OPTIONAL_HEADER (h), 1, abfd);
2248 for (i = SEG_E0; i < SEG_LAST; i++)
2250 if (segment_info[i].scnhdr.s_name[0])
2254 #ifdef COFF_LONG_SECTION_NAMES
2255 /* Support long section names as found in PE. This code
2256 must coordinate with that in write_object_file and
2258 if (strlen (segment_info[i].name) > SCNNMLEN)
2260 memset (segment_info[i].scnhdr.s_name, 0, SCNNMLEN);
2261 sprintf (segment_info[i].scnhdr.s_name, "/%lu", string_size);
2262 string_size += strlen (segment_info[i].name) + 1;
2266 size = bfd_coff_swap_scnhdr_out (abfd,
2267 &(segment_info[i].scnhdr),
2270 as_bad (_("bfd_coff_swap_scnhdr_out failed"));
2271 bfd_write (buffer, size, 1, abfd);
2277 symbol_to_chars (abfd, where, symbolP)
2282 unsigned int numaux = symbolP->sy_symbol.ost_entry.n_numaux;
2286 /* Turn any symbols with register attributes into abs symbols */
2287 if (S_GET_SEGMENT (symbolP) == reg_section)
2289 S_SET_SEGMENT (symbolP, absolute_section);
2291 /* At the same time, relocate all symbols to their output value */
2294 val = (segment_info[S_GET_SEGMENT (symbolP)].scnhdr.s_paddr
2295 + S_GET_VALUE (symbolP));
2297 val = S_GET_VALUE (symbolP);
2300 S_SET_VALUE (symbolP, val);
2302 symbolP->sy_symbol.ost_entry.n_value = val;
2304 where += bfd_coff_swap_sym_out (abfd, &symbolP->sy_symbol.ost_entry,
2307 for (i = 0; i < numaux; i++)
2309 where += bfd_coff_swap_aux_out (abfd,
2310 &symbolP->sy_symbol.ost_auxent[i],
2311 S_GET_DATA_TYPE (symbolP),
2312 S_GET_STORAGE_CLASS (symbolP),
2320 coff_obj_symbol_new_hook (symbolP)
2323 char underscore = 0; /* Symbol has leading _ */
2325 /* Effective symbol */
2326 /* Store the pointer in the offset. */
2327 S_SET_ZEROES (symbolP, 0L);
2328 S_SET_DATA_TYPE (symbolP, T_NULL);
2329 S_SET_STORAGE_CLASS (symbolP, 0);
2330 S_SET_NUMBER_AUXILIARY (symbolP, 0);
2331 /* Additional information */
2332 symbolP->sy_symbol.ost_flags = 0;
2333 /* Auxiliary entries */
2334 memset ((char *) &symbolP->sy_symbol.ost_auxent[0], 0, AUXESZ);
2336 if (S_IS_STRING (symbolP))
2337 SF_SET_STRING (symbolP);
2338 if (!underscore && S_IS_LOCAL (symbolP))
2339 SF_SET_LOCAL (symbolP);
2343 * Handle .ln directives.
2347 obj_coff_ln (appline)
2352 if (! appline && def_symbol_in_progress != NULL)
2354 as_warn (_(".ln pseudo-op inside .def/.endef: ignored."));
2355 demand_empty_rest_of_line ();
2357 } /* wrong context */
2359 l = get_absolute_expression ();
2360 c_line_new (0, frag_now_fix (), l, frag_now);
2363 new_logical_line ((char *) NULL, l - 1);
2373 listing_source_line ((unsigned int) l);
2378 demand_empty_rest_of_line ();
2384 * Handle .def directives.
2386 * One might ask : why can't we symbol_new if the symbol does not
2387 * already exist and fill it with debug information. Because of
2388 * the C_EFCN special symbol. It would clobber the value of the
2389 * function symbol before we have a chance to notice that it is
2390 * a C_EFCN. And a second reason is that the code is more clear this
2391 * way. (at least I think it is :-).
2395 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
2396 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
2397 *input_line_pointer == '\t') \
2398 input_line_pointer++;
2402 int what ATTRIBUTE_UNUSED;
2404 char name_end; /* Char after the end of name */
2405 char *symbol_name; /* Name of the debug symbol */
2406 char *symbol_name_copy; /* Temporary copy of the name */
2407 unsigned int symbol_name_length;
2409 if (def_symbol_in_progress != NULL)
2411 as_warn (_(".def pseudo-op used inside of .def/.endef: ignored."));
2412 demand_empty_rest_of_line ();
2414 } /* if not inside .def/.endef */
2416 SKIP_WHITESPACES ();
2418 def_symbol_in_progress = (symbolS *) obstack_alloc (¬es, sizeof (*def_symbol_in_progress));
2419 memset (def_symbol_in_progress, 0, sizeof (*def_symbol_in_progress));
2421 symbol_name = input_line_pointer;
2422 name_end = get_symbol_end ();
2423 symbol_name_length = strlen (symbol_name);
2424 symbol_name_copy = xmalloc (symbol_name_length + 1);
2425 strcpy (symbol_name_copy, symbol_name);
2426 #ifdef tc_canonicalize_symbol_name
2427 symbol_name_copy = tc_canonicalize_symbol_name (symbol_name_copy);
2430 /* Initialize the new symbol */
2431 #ifdef STRIP_UNDERSCORE
2432 S_SET_NAME (def_symbol_in_progress, (*symbol_name_copy == '_'
2433 ? symbol_name_copy + 1
2434 : symbol_name_copy));
2435 #else /* STRIP_UNDERSCORE */
2436 S_SET_NAME (def_symbol_in_progress, symbol_name_copy);
2437 #endif /* STRIP_UNDERSCORE */
2438 /* free(symbol_name_copy); */
2439 def_symbol_in_progress->sy_name_offset = (unsigned long) ~0;
2440 def_symbol_in_progress->sy_number = ~0;
2441 def_symbol_in_progress->sy_frag = &zero_address_frag;
2442 S_SET_VALUE (def_symbol_in_progress, 0);
2444 if (S_IS_STRING (def_symbol_in_progress))
2445 SF_SET_STRING (def_symbol_in_progress);
2447 *input_line_pointer = name_end;
2449 demand_empty_rest_of_line ();
2452 unsigned int dim_index;
2455 obj_coff_endef (ignore)
2456 int ignore ATTRIBUTE_UNUSED;
2458 symbolS *symbolP = 0;
2459 /* DIM BUG FIX sac@cygnus.com */
2461 if (def_symbol_in_progress == NULL)
2463 as_warn (_(".endef pseudo-op used outside of .def/.endef: ignored."));
2464 demand_empty_rest_of_line ();
2466 } /* if not inside .def/.endef */
2468 /* Set the section number according to storage class. */
2469 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))
2474 SF_SET_TAG (def_symbol_in_progress);
2475 /* intentional fallthrough */
2478 SF_SET_DEBUG (def_symbol_in_progress);
2479 S_SET_SEGMENT (def_symbol_in_progress, SEG_DEBUG);
2483 SF_SET_LOCAL (def_symbol_in_progress); /* Do not emit this symbol. */
2484 /* intentional fallthrough */
2486 SF_SET_PROCESS (def_symbol_in_progress); /* Will need processing before writing */
2487 /* intentional fallthrough */
2489 S_SET_SEGMENT (def_symbol_in_progress, SEG_E0);
2491 if (strcmp (S_GET_NAME (def_symbol_in_progress), ".bf") == 0)
2493 if (function_lineoff < 0)
2495 fprintf (stderr, _("`.bf' symbol without preceding function\n"));
2496 } /* missing function symbol */
2497 SA_GET_SYM_LNNOPTR (last_line_symbol) = function_lineoff;
2499 SF_SET_PROCESS (last_line_symbol);
2500 SF_SET_ADJ_LNNOPTR (last_line_symbol);
2501 SF_SET_PROCESS (def_symbol_in_progress);
2502 function_lineoff = -1;
2504 /* Value is always set to . */
2505 def_symbol_in_progress->sy_frag = frag_now;
2506 S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
2511 #endif /* C_AUTOARG */
2521 SF_SET_DEBUG (def_symbol_in_progress);
2522 S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
2532 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
2538 as_warn (_("unexpected storage class %d"), S_GET_STORAGE_CLASS (def_symbol_in_progress));
2540 } /* switch on storage class */
2542 /* Now that we have built a debug symbol, try to find if we should
2543 merge with an existing symbol or not. If a symbol is C_EFCN or
2544 absolute_section or untagged SEG_DEBUG it never merges. We also
2545 don't merge labels, which are in a different namespace, nor
2546 symbols which have not yet been defined since they are typically
2547 unique, nor do we merge tags with non-tags. */
2549 /* Two cases for functions. Either debug followed by definition or
2550 definition followed by debug. For definition first, we will
2551 merge the debug symbol into the definition. For debug first, the
2552 lineno entry MUST point to the definition function or else it
2553 will point off into space when crawl_symbols() merges the debug
2554 symbol into the real symbol. Therefor, let's presume the debug
2555 symbol is a real function reference. */
2557 /* FIXME-SOON If for some reason the definition label/symbol is
2558 never seen, this will probably leave an undefined symbol at link
2561 if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN
2562 || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_LABEL
2563 || (S_GET_SEGMENT (def_symbol_in_progress) == SEG_DEBUG
2564 && !SF_GET_TAG (def_symbol_in_progress))
2565 || S_GET_SEGMENT (def_symbol_in_progress) == absolute_section
2566 || def_symbol_in_progress->sy_value.X_op != O_constant
2567 || (symbolP = symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP)) == NULL
2568 || (SF_GET_TAG (def_symbol_in_progress) != SF_GET_TAG (symbolP)))
2570 symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP,
2575 /* This symbol already exists, merge the newly created symbol
2576 into the old one. This is not mandatory. The linker can
2577 handle duplicate symbols correctly. But I guess that it save
2578 a *lot* of space if the assembly file defines a lot of
2581 /* The debug entry (def_symbol_in_progress) is merged into the
2582 previous definition. */
2584 c_symbol_merge (def_symbol_in_progress, symbolP);
2585 /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
2586 def_symbol_in_progress = symbolP;
2588 if (SF_GET_FUNCTION (def_symbol_in_progress)
2589 || SF_GET_TAG (def_symbol_in_progress)
2590 || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_STAT)
2592 /* For functions, and tags, and static symbols, the symbol
2593 *must* be where the debug symbol appears. Move the
2594 existing symbol to the current place. */
2595 /* If it already is at the end of the symbol list, do nothing */
2596 if (def_symbol_in_progress != symbol_lastP)
2598 symbol_remove (def_symbol_in_progress, &symbol_rootP,
2600 symbol_append (def_symbol_in_progress, symbol_lastP,
2601 &symbol_rootP, &symbol_lastP);
2602 } /* if not already in place */
2604 } /* normal or mergable */
2606 if (SF_GET_TAG (def_symbol_in_progress))
2610 oldtag = symbol_find_base (S_GET_NAME (def_symbol_in_progress),
2612 if (oldtag == NULL || ! SF_GET_TAG (oldtag))
2613 tag_insert (S_GET_NAME (def_symbol_in_progress),
2614 def_symbol_in_progress);
2617 if (SF_GET_FUNCTION (def_symbol_in_progress))
2619 know (sizeof (def_symbol_in_progress) <= sizeof (long));
2621 = c_line_new (def_symbol_in_progress, 0, 0, &zero_address_frag);
2623 SF_SET_PROCESS (def_symbol_in_progress);
2625 if (symbolP == NULL)
2627 /* That is, if this is the first time we've seen the
2629 symbol_table_insert (def_symbol_in_progress);
2630 } /* definition follows debug */
2631 } /* Create the line number entry pointing to the function being defined */
2633 def_symbol_in_progress = NULL;
2634 demand_empty_rest_of_line ();
2638 obj_coff_dim (ignore)
2639 int ignore ATTRIBUTE_UNUSED;
2643 if (def_symbol_in_progress == NULL)
2645 as_warn (_(".dim pseudo-op used outside of .def/.endef: ignored."));
2646 demand_empty_rest_of_line ();
2648 } /* if not inside .def/.endef */
2650 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2652 for (dim_index = 0; dim_index < DIMNUM; dim_index++)
2654 SKIP_WHITESPACES ();
2655 SA_SET_SYM_DIMEN (def_symbol_in_progress, dim_index,
2656 get_absolute_expression ());
2658 switch (*input_line_pointer)
2661 input_line_pointer++;
2665 as_warn (_("badly formed .dim directive ignored"));
2666 /* intentional fallthrough */
2674 demand_empty_rest_of_line ();
2678 obj_coff_line (ignore)
2679 int ignore ATTRIBUTE_UNUSED;
2684 if (def_symbol_in_progress == NULL)
2690 name = S_GET_NAME (def_symbol_in_progress);
2691 this_base = get_absolute_expression ();
2693 /* Only .bf symbols indicate the use of a new base line number; the
2694 line numbers associated with .ef, .bb, .eb are relative to the
2695 start of the containing function. */
2696 if (!strcmp (".bf", name))
2698 #if 0 /* XXX Can we ever have line numbers going backwards? */
2699 if (this_base > line_base)
2702 line_base = this_base;
2710 listing_source_line ((unsigned int) line_base);
2716 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2717 SA_SET_SYM_LNNO (def_symbol_in_progress, this_base);
2719 demand_empty_rest_of_line ();
2723 obj_coff_size (ignore)
2724 int ignore ATTRIBUTE_UNUSED;
2726 if (def_symbol_in_progress == NULL)
2728 as_warn (_(".size pseudo-op used outside of .def/.endef ignored."));
2729 demand_empty_rest_of_line ();
2731 } /* if not inside .def/.endef */
2733 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2734 SA_SET_SYM_SIZE (def_symbol_in_progress, get_absolute_expression ());
2735 demand_empty_rest_of_line ();
2739 obj_coff_scl (ignore)
2740 int ignore ATTRIBUTE_UNUSED;
2742 if (def_symbol_in_progress == NULL)
2744 as_warn (_(".scl pseudo-op used outside of .def/.endef ignored."));
2745 demand_empty_rest_of_line ();
2747 } /* if not inside .def/.endef */
2749 S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ());
2750 demand_empty_rest_of_line ();
2754 obj_coff_tag (ignore)
2755 int ignore ATTRIBUTE_UNUSED;
2760 if (def_symbol_in_progress == NULL)
2762 as_warn (_(".tag pseudo-op used outside of .def/.endef ignored."));
2763 demand_empty_rest_of_line ();
2767 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2768 symbol_name = input_line_pointer;
2769 name_end = get_symbol_end ();
2770 #ifdef tc_canonicalize_symbol_name
2771 symbol_name = tc_canonicalize_symbol_name (symbol_name);
2774 /* Assume that the symbol referred to by .tag is always defined.
2775 This was a bad assumption. I've added find_or_make. xoxorich. */
2776 SA_SET_SYM_TAGNDX (def_symbol_in_progress,
2777 (long) tag_find_or_make (symbol_name));
2778 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L)
2780 as_warn (_("tag not found for .tag %s"), symbol_name);
2783 SF_SET_TAGGED (def_symbol_in_progress);
2784 *input_line_pointer = name_end;
2786 demand_empty_rest_of_line ();
2790 obj_coff_type (ignore)
2791 int ignore ATTRIBUTE_UNUSED;
2793 if (def_symbol_in_progress == NULL)
2795 as_warn (_(".type pseudo-op used outside of .def/.endef ignored."));
2796 demand_empty_rest_of_line ();
2798 } /* if not inside .def/.endef */
2800 S_SET_DATA_TYPE (def_symbol_in_progress, get_absolute_expression ());
2802 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress)) &&
2803 S_GET_STORAGE_CLASS (def_symbol_in_progress) != C_TPDEF)
2805 SF_SET_FUNCTION (def_symbol_in_progress);
2806 } /* is a function */
2808 demand_empty_rest_of_line ();
2812 obj_coff_val (ignore)
2813 int ignore ATTRIBUTE_UNUSED;
2815 if (def_symbol_in_progress == NULL)
2817 as_warn (_(".val pseudo-op used outside of .def/.endef ignored."));
2818 demand_empty_rest_of_line ();
2820 } /* if not inside .def/.endef */
2822 if (is_name_beginner (*input_line_pointer))
2824 char *symbol_name = input_line_pointer;
2825 char name_end = get_symbol_end ();
2827 #ifdef tc_canonicalize_symbol_name
2828 symbol_name = tc_canonicalize_symbol_name (symbol_name);
2831 if (!strcmp (symbol_name, "."))
2833 def_symbol_in_progress->sy_frag = frag_now;
2834 S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
2835 /* If the .val is != from the .def (e.g. statics) */
2837 else if (strcmp (S_GET_NAME (def_symbol_in_progress), symbol_name))
2839 def_symbol_in_progress->sy_value.X_op = O_symbol;
2840 def_symbol_in_progress->sy_value.X_add_symbol =
2841 symbol_find_or_make (symbol_name);
2842 def_symbol_in_progress->sy_value.X_op_symbol = NULL;
2843 def_symbol_in_progress->sy_value.X_add_number = 0;
2845 /* If the segment is undefined when the forward reference is
2846 resolved, then copy the segment id from the forward
2848 SF_SET_GET_SEGMENT (def_symbol_in_progress);
2850 /* FIXME: gcc can generate address expressions here in
2851 unusual cases (search for "obscure" in sdbout.c). We
2852 just ignore the offset here, thus generating incorrect
2853 debugging information. We ignore the rest of the line
2856 /* Otherwise, it is the name of a non debug symbol and
2857 its value will be calculated later. */
2858 *input_line_pointer = name_end;
2860 /* FIXME: this is to avoid an error message in the
2861 FIXME case mentioned just above. */
2862 while (! is_end_of_line[(unsigned char) *input_line_pointer])
2863 ++input_line_pointer;
2867 S_SET_VALUE (def_symbol_in_progress,
2868 (valueT) get_absolute_expression ());
2869 } /* if symbol based */
2871 demand_empty_rest_of_line ();
2876 /* Handle the .linkonce pseudo-op. This is parsed by s_linkonce in
2877 read.c, which then calls this object file format specific routine. */
2880 obj_coff_pe_handle_link_once (type)
2881 enum linkonce_type type;
2883 seg_info (now_seg)->scnhdr.s_flags |= IMAGE_SCN_LNK_COMDAT;
2885 /* We store the type in the seg_info structure, and use it to set up
2886 the auxiliary entry for the section symbol in c_section_symbol. */
2887 seg_info (now_seg)->linkonce = type;
2893 coff_obj_read_begin_hook ()
2895 /* These had better be the same. Usually 18 bytes. */
2897 know (sizeof (SYMENT) == sizeof (AUXENT));
2898 know (SYMESZ == AUXESZ);
2903 /* This function runs through the symbol table and puts all the
2904 externals onto another chain */
2906 /* The chain of globals. */
2907 symbolS *symbol_globalP;
2908 symbolS *symbol_global_lastP;
2910 /* The chain of externals */
2911 symbolS *symbol_externP;
2912 symbolS *symbol_extern_lastP;
2915 symbolS *last_functionP;
2916 static symbolS *last_bfP;
2923 unsigned int symbol_number = 0;
2924 unsigned int last_file_symno = 0;
2926 struct filename_list *filename_list_scan = filename_list_head;
2928 for (symbolP = symbol_rootP;
2930 symbolP = symbolP ? symbol_next (symbolP) : symbol_rootP)
2932 if (symbolP->sy_mri_common)
2934 if (S_GET_STORAGE_CLASS (symbolP) == C_EXT
2936 || S_GET_STORAGE_CLASS (symbolP) == C_NT_WEAK
2938 || S_GET_STORAGE_CLASS (symbolP) == C_WEAKEXT)
2939 as_bad (_("%s: global symbols not supported in common sections"),
2940 S_GET_NAME (symbolP));
2941 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2945 if (!SF_GET_DEBUG (symbolP))
2947 /* Debug symbols do not need all this rubbish */
2948 symbolS *real_symbolP;
2950 /* L* and C_EFCN symbols never merge. */
2951 if (!SF_GET_LOCAL (symbolP)
2952 && !SF_GET_STATICS (symbolP)
2953 && S_GET_STORAGE_CLASS (symbolP) != C_LABEL
2954 && symbolP->sy_value.X_op == O_constant
2955 && (real_symbolP = symbol_find_base (S_GET_NAME (symbolP), DO_NOT_STRIP))
2956 && real_symbolP != symbolP)
2958 /* FIXME-SOON: where do dups come from?
2959 Maybe tag references before definitions? xoxorich. */
2960 /* Move the debug data from the debug symbol to the
2961 real symbol. Do NOT do the oposite (i.e. move from
2962 real symbol to debug symbol and remove real symbol from the
2963 list.) Because some pointers refer to the real symbol
2964 whereas no pointers refer to the debug symbol. */
2965 c_symbol_merge (symbolP, real_symbolP);
2966 /* Replace the current symbol by the real one */
2967 /* The symbols will never be the last or the first
2968 because : 1st symbol is .file and 3 last symbols are
2969 .text, .data, .bss */
2970 symbol_remove (real_symbolP, &symbol_rootP, &symbol_lastP);
2971 symbol_insert (real_symbolP, symbolP, &symbol_rootP, &symbol_lastP);
2972 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2973 symbolP = real_symbolP;
2974 } /* if not local but dup'd */
2976 if (flag_readonly_data_in_text && (S_GET_SEGMENT (symbolP) == SEG_E1))
2978 S_SET_SEGMENT (symbolP, SEG_E0);
2979 } /* push data into text */
2981 resolve_symbol_value (symbolP);
2983 if (S_GET_STORAGE_CLASS (symbolP) == C_NULL)
2985 if (!S_IS_DEFINED (symbolP) && !SF_GET_LOCAL (symbolP))
2987 S_SET_EXTERNAL (symbolP);
2989 else if (S_GET_SEGMENT (symbolP) == SEG_E0)
2991 S_SET_STORAGE_CLASS (symbolP, C_LABEL);
2995 S_SET_STORAGE_CLASS (symbolP, C_STAT);
2999 /* Mainly to speed up if not -g */
3000 if (SF_GET_PROCESS (symbolP))
3002 /* Handle the nested blocks auxiliary info. */
3003 if (S_GET_STORAGE_CLASS (symbolP) == C_BLOCK)
3005 if (!strcmp (S_GET_NAME (symbolP), ".bb"))
3006 stack_push (block_stack, (char *) &symbolP);
3009 register symbolS *begin_symbolP;
3010 begin_symbolP = *(symbolS **) stack_pop (block_stack);
3011 if (begin_symbolP == (symbolS *) 0)
3012 as_warn (_("mismatched .eb"));
3014 SA_SET_SYM_ENDNDX (begin_symbolP, symbol_number + 2);
3017 /* If we are able to identify the type of a function, and we
3018 are out of a function (last_functionP == 0) then, the
3019 function symbol will be associated with an auxiliary
3021 if (last_functionP == (symbolS *) 0 &&
3022 SF_GET_FUNCTION (symbolP))
3024 last_functionP = symbolP;
3026 if (S_GET_NUMBER_AUXILIARY (symbolP) < 1)
3028 S_SET_NUMBER_AUXILIARY (symbolP, 1);
3029 } /* make it at least 1 */
3031 /* Clobber possible stale .dim information. */
3033 /* Iffed out by steve - this fries the lnnoptr info too */
3034 bzero (symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen,
3035 sizeof (symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen));
3038 if (S_GET_STORAGE_CLASS (symbolP) == C_FCN)
3040 if (strcmp (S_GET_NAME (symbolP), ".bf") == 0)
3042 if (last_bfP != NULL)
3043 SA_SET_SYM_ENDNDX (last_bfP, symbol_number);
3047 else if (S_GET_STORAGE_CLASS (symbolP) == C_EFCN)
3049 /* I don't even know if this is needed for sdb. But
3050 the standard assembler generates it, so... */
3051 if (last_functionP == (symbolS *) 0)
3052 as_fatal (_("C_EFCN symbol out of scope"));
3053 SA_SET_SYM_FSIZE (last_functionP,
3054 (long) (S_GET_VALUE (symbolP) -
3055 S_GET_VALUE (last_functionP)));
3056 SA_SET_SYM_ENDNDX (last_functionP, symbol_number);
3057 last_functionP = (symbolS *) 0;
3061 else if (SF_GET_TAG (symbolP))
3063 /* First descriptor of a structure must point to
3064 the first slot after the structure description. */
3065 last_tagP = symbolP;
3068 else if (S_GET_STORAGE_CLASS (symbolP) == C_EOS)
3070 /* +2 take in account the current symbol */
3071 SA_SET_SYM_ENDNDX (last_tagP, symbol_number + 2);
3073 else if (S_GET_STORAGE_CLASS (symbolP) == C_FILE)
3075 /* If the filename was too long to fit in the
3076 auxent, put it in the string table */
3077 if (SA_GET_FILE_FNAME_ZEROS (symbolP) == 0
3078 && SA_GET_FILE_FNAME_OFFSET (symbolP) != 0)
3080 SA_SET_FILE_FNAME_OFFSET (symbolP, string_byte_count);
3081 string_byte_count += strlen (filename_list_scan->filename) + 1;
3082 filename_list_scan = filename_list_scan->next;
3084 if (S_GET_VALUE (symbolP))
3086 S_SET_VALUE (symbolP, last_file_symno);
3087 last_file_symno = symbol_number;
3088 } /* no one points at the first .file symbol */
3089 } /* if debug or tag or eos or file */
3091 #ifdef tc_frob_coff_symbol
3092 tc_frob_coff_symbol (symbolP);
3095 /* We must put the external symbols apart. The loader
3096 does not bomb if we do not. But the references in
3097 the endndx field for a .bb symbol are not corrected
3098 if an external symbol is removed between .bb and .be.
3099 I.e in the following case :
3100 [20] .bb endndx = 22
3103 ld will move the symbol 21 to the end of the list but
3104 endndx will still be 22 instead of 21. */
3106 if (SF_GET_LOCAL (symbolP))
3108 /* remove C_EFCN and LOCAL (L...) symbols */
3109 /* next pointer remains valid */
3110 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3113 else if (symbolP->sy_value.X_op == O_symbol
3114 && (! S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP)))
3116 /* Skip symbols which were equated to undefined or common
3118 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3120 else if (!S_IS_DEFINED (symbolP)
3121 && !S_IS_DEBUG (symbolP)
3122 && !SF_GET_STATICS (symbolP)
3123 && (S_GET_STORAGE_CLASS (symbolP) == C_EXT
3125 || S_GET_STORAGE_CLASS (symbolP) == C_NT_WEAK
3127 || S_GET_STORAGE_CLASS (symbolP) == C_WEAKEXT))
3129 /* if external, Remove from the list */
3130 symbolS *hold = symbol_previous (symbolP);
3132 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3133 symbol_clear_list_pointers (symbolP);
3134 symbol_append (symbolP, symbol_extern_lastP, &symbol_externP, &symbol_extern_lastP);
3137 else if (! S_IS_DEBUG (symbolP)
3138 && ! SF_GET_STATICS (symbolP)
3139 && ! SF_GET_FUNCTION (symbolP)
3140 && (S_GET_STORAGE_CLASS (symbolP) == C_EXT
3142 || S_GET_STORAGE_CLASS (symbolP) == C_NT_WEAK
3144 || S_GET_STORAGE_CLASS (symbolP) == C_NT_WEAK))
3146 symbolS *hold = symbol_previous (symbolP);
3148 /* The O'Reilly COFF book says that defined global symbols
3149 come at the end of the symbol table, just before
3150 undefined global symbols. */
3152 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3153 symbol_clear_list_pointers (symbolP);
3154 symbol_append (symbolP, symbol_global_lastP, &symbol_globalP,
3155 &symbol_global_lastP);
3160 if (SF_GET_STRING (symbolP))
3162 symbolP->sy_name_offset = string_byte_count;
3163 string_byte_count += strlen (S_GET_NAME (symbolP)) + 1;
3167 symbolP->sy_name_offset = 0;
3168 } /* fix "long" names */
3170 symbolP->sy_number = symbol_number;
3171 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (symbolP);
3172 } /* if local symbol */
3173 } /* traverse the symbol list */
3174 return symbol_number;
3179 glue_symbols (head, tail)
3183 unsigned int symbol_number = 0;
3185 while (*head != NULL)
3187 symbolS *tmp = *head;
3190 symbol_remove (tmp, head, tail);
3191 symbol_append (tmp, symbol_lastP, &symbol_rootP, &symbol_lastP);
3194 if (SF_GET_STRING (tmp))
3196 tmp->sy_name_offset = string_byte_count;
3197 string_byte_count += strlen (S_GET_NAME (tmp)) + 1;
3201 tmp->sy_name_offset = 0;
3202 } /* fix "long" names */
3204 tmp->sy_number = symbol_number;
3205 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (tmp);
3206 } /* append the entire extern chain */
3208 return symbol_number;
3214 unsigned int symbol_number = 0;
3217 for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
3219 symbolP->sy_number = symbol_number;
3221 if (SF_GET_TAGGED (symbolP))
3225 ((symbolS *) SA_GET_SYM_TAGNDX (symbolP))->sy_number);
3228 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (symbolP);
3231 return symbol_number;
3235 crawl_symbols (h, abfd)
3237 bfd *abfd ATTRIBUTE_UNUSED;
3241 /* Initialize the stack used to keep track of the matching .bb .be */
3243 block_stack = stack_init (512, sizeof (symbolS *));
3245 /* The symbol list should be ordered according to the following sequence
3248 * . debug entries for functions
3249 * . fake symbols for the sections, including .text .data and .bss
3251 * . undefined symbols
3252 * But this is not mandatory. The only important point is to put the
3253 * undefined symbols at the end of the list.
3256 /* Is there a .file symbol ? If not insert one at the beginning. */
3257 if (symbol_rootP == NULL
3258 || S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
3260 c_dot_file_symbol ("fake");
3264 * Build up static symbols for the sections, they are filled in later
3267 for (i = SEG_E0; i < SEG_LAST; i++)
3268 if (segment_info[i].scnhdr.s_name[0])
3269 segment_info[i].dot = c_section_symbol (segment_info[i].name,
3272 /* Take all the externals out and put them into another chain */
3273 H_SET_SYMBOL_TABLE_SIZE (h, yank_symbols ());
3274 /* Take the externals and glue them onto the end.*/
3275 H_SET_SYMBOL_TABLE_SIZE (h,
3276 (H_GET_SYMBOL_COUNT (h)
3277 + glue_symbols (&symbol_globalP,
3278 &symbol_global_lastP)
3279 + glue_symbols (&symbol_externP,
3280 &symbol_extern_lastP)));
3282 H_SET_SYMBOL_TABLE_SIZE (h, tie_tags ());
3283 know (symbol_globalP == NULL);
3284 know (symbol_global_lastP == NULL);
3285 know (symbol_externP == NULL);
3286 know (symbol_extern_lastP == NULL);
3290 * Find strings by crawling along symbol table chain.
3298 struct filename_list *filename_list_scan = filename_list_head;
3300 /* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
3301 md_number_to_chars (where, (valueT) string_byte_count, 4);
3304 #ifdef COFF_LONG_SECTION_NAMES
3305 /* Support long section names as found in PE. This code must
3306 coordinate with that in coff_header_append and write_object_file. */
3310 for (i = SEG_E0; i < SEG_LAST; i++)
3312 if (segment_info[i].scnhdr.s_name[0]
3313 && strlen (segment_info[i].name) > SCNNMLEN)
3317 size = strlen (segment_info[i].name) + 1;
3318 memcpy (where, segment_info[i].name, size);
3323 #endif /* COFF_LONG_SECTION_NAMES */
3325 for (symbolP = symbol_rootP;
3327 symbolP = symbol_next (symbolP))
3331 if (SF_GET_STRING (symbolP))
3333 size = strlen (S_GET_NAME (symbolP)) + 1;
3334 memcpy (where, S_GET_NAME (symbolP), size);
3337 if (S_GET_STORAGE_CLASS (symbolP) == C_FILE
3338 && SA_GET_FILE_FNAME_ZEROS (symbolP) == 0
3339 && SA_GET_FILE_FNAME_OFFSET (symbolP) != 0)
3341 size = strlen (filename_list_scan->filename) + 1;
3342 memcpy (where, filename_list_scan->filename, size);
3343 filename_list_scan = filename_list_scan ->next;
3350 do_linenos_for (abfd, h, file_cursor)
3353 unsigned long *file_cursor;
3356 unsigned long start = *file_cursor;
3358 for (idx = SEG_E0; idx < SEG_LAST; idx++)
3360 segment_info_type *s = segment_info + idx;
3362 if (s->scnhdr.s_nlnno != 0)
3364 struct lineno_list *line_ptr;
3366 struct external_lineno *buffer =
3367 (struct external_lineno *) xmalloc (s->scnhdr.s_nlnno * LINESZ);
3369 struct external_lineno *dst = buffer;
3371 /* Run through the table we've built and turn it into its external
3372 form, take this chance to remove duplicates */
3374 for (line_ptr = s->lineno_list_head;
3375 line_ptr != (struct lineno_list *) NULL;
3376 line_ptr = line_ptr->next)
3378 if (line_ptr->line.l_lnno == 0)
3380 /* Turn a pointer to a symbol into the symbols' index,
3381 provided that it has been initialised. */
3382 if (line_ptr->line.l_addr.l_symndx)
3383 line_ptr->line.l_addr.l_symndx =
3384 ((symbolS *) line_ptr->line.l_addr.l_symndx)->sy_number;
3388 line_ptr->line.l_addr.l_paddr += ((struct frag *) (line_ptr->frag))->fr_address;
3391 (void) bfd_coff_swap_lineno_out (abfd, &(line_ptr->line), dst);
3396 s->scnhdr.s_lnnoptr = *file_cursor;
3398 bfd_write (buffer, 1, s->scnhdr.s_nlnno * LINESZ, abfd);
3401 *file_cursor += s->scnhdr.s_nlnno * LINESZ;
3404 H_SET_LINENO_SIZE (h, *file_cursor - start);
3407 /* Now we run through the list of frag chains in a segment and
3408 make all the subsegment frags appear at the end of the
3409 list, as if the seg 0 was extra long */
3416 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3418 frchainS *head = segment_info[i].frchainP;
3420 fragS *prev_frag = &dummy;
3422 while (head && head->frch_seg == i)
3424 prev_frag->fr_next = head->frch_root;
3425 prev_frag = head->frch_last;
3426 head = head->frch_next;
3428 prev_frag->fr_next = 0;
3432 unsigned long machine;
3435 write_object_file ()
3439 struct frchain *frchain_ptr;
3441 object_headers headers;
3442 unsigned long file_cursor;
3445 abfd = bfd_openw (out_file_name, TARGET_FORMAT);
3449 as_perror (_("FATAL: Can't create %s"), out_file_name);
3450 exit (EXIT_FAILURE);
3452 bfd_set_format (abfd, bfd_object);
3453 bfd_set_arch_mach (abfd, BFD_ARCH, machine);
3455 string_byte_count = 4;
3457 for (frchain_ptr = frchain_root;
3458 frchain_ptr != (struct frchain *) NULL;
3459 frchain_ptr = frchain_ptr->frch_next)
3461 /* Run through all the sub-segments and align them up. Also
3462 close any open frags. We tack a .fill onto the end of the
3463 frag chain so that any .align's size can be worked by looking
3464 at the next frag. */
3466 subseg_set (frchain_ptr->frch_seg, frchain_ptr->frch_subseg);
3468 #ifndef SUB_SEGMENT_ALIGN
3469 #define SUB_SEGMENT_ALIGN(SEG) 1
3472 md_do_align (SUB_SEGMENT_ALIGN (now_seg), (char *) NULL, 0, 0,
3475 if (subseg_text_p (now_seg))
3476 frag_align_code (SUB_SEGMENT_ALIGN (now_seg), 0);
3478 frag_align (SUB_SEGMENT_ALIGN (now_seg), 0, 0);
3484 frag_wane (frag_now);
3485 frag_now->fr_fix = 0;
3486 know (frag_now->fr_next == NULL);
3491 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3493 relax_segment (segment_info[i].frchainP->frch_root, i);
3496 /* Relaxation has completed. Freeze all syms. */
3499 H_SET_NUMBER_OF_SECTIONS (&headers, 0);
3501 /* Find out how big the sections are, and set the addresses. */
3503 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3507 segment_info[i].scnhdr.s_paddr = addr;
3508 segment_info[i].scnhdr.s_vaddr = addr;
3510 if (segment_info[i].scnhdr.s_name[0])
3512 H_SET_NUMBER_OF_SECTIONS (&headers,
3513 H_GET_NUMBER_OF_SECTIONS (&headers) + 1);
3515 #ifdef COFF_LONG_SECTION_NAMES
3516 /* Support long section names as found in PE. This code
3517 must coordinate with that in coff_header_append and
3522 len = strlen (segment_info[i].name);
3524 string_byte_count += len + 1;
3526 #endif /* COFF_LONG_SECTION_NAMES */
3529 size = size_section (abfd, (unsigned int) i);
3532 /* I think the section alignment is only used on the i960; the
3533 i960 needs it, and it should do no harm on other targets. */
3534 #ifdef ALIGNMENT_IN_S_FLAGS
3535 segment_info[i].scnhdr.s_flags |= (section_alignment[i] & 0xF) << 8;
3537 segment_info[i].scnhdr.s_align = 1 << section_alignment[i];
3541 H_SET_TEXT_SIZE (&headers, size);
3542 else if (i == SEG_E1)
3543 H_SET_DATA_SIZE (&headers, size);
3544 else if (i == SEG_E2)
3545 H_SET_BSS_SIZE (&headers, size);
3548 /* Turn the gas native symbol table shape into a coff symbol table */
3549 crawl_symbols (&headers, abfd);
3551 if (string_byte_count == 4)
3552 string_byte_count = 0;
3554 H_SET_STRING_SIZE (&headers, string_byte_count);
3560 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3562 fixup_mdeps (segment_info[i].frchainP->frch_root, &headers, i);
3563 fixup_segment (&segment_info[i], i);
3566 /* Look for ".stab" segments and fill in their initial symbols
3568 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3570 name = segment_info[i].name;
3573 && strncmp (".stab", name, 5) == 0
3574 && strncmp (".stabstr", name, 8) != 0)
3575 adjust_stab_section (abfd, i);
3578 file_cursor = H_GET_TEXT_FILE_OFFSET (&headers);
3580 bfd_seek (abfd, (file_ptr) file_cursor, 0);
3582 /* Plant the data */
3584 fill_section (abfd, &headers, &file_cursor);
3586 do_relocs_for (abfd, &headers, &file_cursor);
3588 do_linenos_for (abfd, &headers, &file_cursor);
3590 H_SET_FILE_MAGIC_NUMBER (&headers, COFF_MAGIC);
3591 #ifndef OBJ_COFF_OMIT_TIMESTAMP
3592 H_SET_TIME_STAMP (&headers, (long)time((time_t *)0));
3594 H_SET_TIME_STAMP (&headers, 0);
3596 #ifdef TC_COFF_SET_MACHINE
3597 TC_COFF_SET_MACHINE (&headers);
3601 #define COFF_FLAGS 0
3604 #ifdef KEEP_RELOC_INFO
3605 H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
3606 COFF_FLAGS | coff_flags));
3608 H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
3609 (H_GET_RELOCATION_SIZE(&headers) ? 0 : F_RELFLG) |
3610 COFF_FLAGS | coff_flags));
3614 unsigned int symtable_size = H_GET_SYMBOL_TABLE_SIZE (&headers);
3615 char *buffer1 = xmalloc (symtable_size + string_byte_count + 1);
3617 H_SET_SYMBOL_TABLE_POINTER (&headers, bfd_tell (abfd));
3618 w_symbols (abfd, buffer1, symbol_rootP);
3619 if (string_byte_count > 0)
3620 w_strings (buffer1 + symtable_size);
3621 bfd_write (buffer1, 1, symtable_size + string_byte_count, abfd);
3625 coff_header_append (abfd, &headers);
3627 /* Recent changes to write need this, but where it should
3628 go is up to Ken.. */
3629 if (bfd_close_all_done (abfd) == false)
3630 as_fatal (_("Can't close %s: %s"), out_file_name,
3631 bfd_errmsg (bfd_get_error ()));
3634 extern bfd *stdoutput;
3641 /* Add a new segment. This is called from subseg_new via the
3642 obj_new_segment macro. */
3645 obj_coff_add_segment (name)
3650 #ifndef COFF_LONG_SECTION_NAMES
3651 char buf[SCNNMLEN + 1];
3653 strncpy (buf, name, SCNNMLEN);
3654 buf[SCNNMLEN] = '\0';
3658 for (i = SEG_E0; i < SEG_LAST && segment_info[i].scnhdr.s_name[0]; i++)
3659 if (strcmp (name, segment_info[i].name) == 0)
3664 as_bad (_("Too many new sections; can't add \"%s\""), name);
3668 /* Add a new section. */
3669 strncpy (segment_info[i].scnhdr.s_name, name,
3670 sizeof (segment_info[i].scnhdr.s_name));
3671 segment_info[i].scnhdr.s_flags = STYP_REG;
3672 segment_info[i].name = xstrdup (name);
3678 * implement the .section pseudo op:
3679 * .section name {, "flags"}
3681 * | +--- optional flags: 'b' for bss
3683 * +-- section name 'l' for lib
3687 * 'd' (apparently m88k for data)
3689 * 'r' for read-only data
3690 * But if the argument is not a quoted string, treat it as a
3691 * subsegment number.
3695 obj_coff_section (ignore)
3696 int ignore ATTRIBUTE_UNUSED;
3698 /* Strip out the section name */
3699 char *section_name, *name;
3712 else if (type == 'D')
3714 segment_info[now_seg].scnhdr.s_flags |= flags;
3719 section_name = input_line_pointer;
3720 c = get_symbol_end ();
3722 name = xmalloc (input_line_pointer - section_name + 1);
3723 strcpy (name, section_name);
3725 *input_line_pointer = c;
3731 if (*input_line_pointer == ',')
3733 ++input_line_pointer;
3736 if (*input_line_pointer != '"')
3737 exp = get_absolute_expression ();
3740 ++input_line_pointer;
3741 while (*input_line_pointer != '"'
3742 && ! is_end_of_line[(unsigned char) *input_line_pointer])
3744 switch (*input_line_pointer)
3746 case 'b': flags |= STYP_BSS; break;
3747 case 'i': flags |= STYP_INFO; break;
3748 case 'l': flags |= STYP_LIB; break;
3749 case 'n': flags |= STYP_NOLOAD; break;
3750 case 'o': flags |= STYP_OVER; break;
3752 case 'w': flags |= STYP_DATA; break;
3753 case 'x': flags |= STYP_TEXT; break;
3754 case 'r': flags |= STYP_LIT; break;
3756 as_warn(_("unknown section attribute '%c'"),
3757 *input_line_pointer);
3760 ++input_line_pointer;
3762 if (*input_line_pointer == '"')
3763 ++input_line_pointer;
3767 subseg_new (name, (subsegT) exp);
3769 segment_info[now_seg].scnhdr.s_flags |= flags;
3771 demand_empty_rest_of_line ();
3775 obj_coff_text (ignore)
3776 int ignore ATTRIBUTE_UNUSED;
3778 subseg_new (".text", get_absolute_expression ());
3782 obj_coff_data (ignore)
3783 int ignore ATTRIBUTE_UNUSED;
3785 if (flag_readonly_data_in_text)
3786 subseg_new (".text", get_absolute_expression () + 1000);
3788 subseg_new (".data", get_absolute_expression ());
3792 obj_coff_ident (ignore)
3793 int ignore ATTRIBUTE_UNUSED;
3795 segT current_seg = now_seg; /* save current seg */
3796 subsegT current_subseg = now_subseg;
3797 subseg_new (".comment", 0); /* .comment seg */
3798 stringer (1); /* read string */
3799 subseg_set (current_seg, current_subseg); /* restore current seg */
3803 c_symbol_merge (debug, normal)
3807 S_SET_DATA_TYPE (normal, S_GET_DATA_TYPE (debug));
3808 S_SET_STORAGE_CLASS (normal, S_GET_STORAGE_CLASS (debug));
3810 if (S_GET_NUMBER_AUXILIARY (debug) > S_GET_NUMBER_AUXILIARY (normal))
3812 S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));
3813 } /* take the most we have */
3815 if (S_GET_NUMBER_AUXILIARY (debug) > 0)
3817 memcpy ((char *) &normal->sy_symbol.ost_auxent[0],
3818 (char *) &debug->sy_symbol.ost_auxent[0],
3819 (unsigned int) (S_GET_NUMBER_AUXILIARY (debug) * AUXESZ));
3820 } /* Move all the auxiliary information */
3822 /* Move the debug flags. */
3823 SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
3824 } /* c_symbol_merge() */
3827 c_line_new (symbol, paddr, line_number, frag)
3833 struct lineno_list *new_line =
3834 (struct lineno_list *) xmalloc (sizeof (struct lineno_list));
3836 segment_info_type *s = segment_info + now_seg;
3837 new_line->line.l_lnno = line_number;
3839 if (line_number == 0)
3841 last_line_symbol = symbol;
3842 new_line->line.l_addr.l_symndx = (long) symbol;
3846 new_line->line.l_addr.l_paddr = paddr;
3849 new_line->frag = (char *) frag;
3850 new_line->next = (struct lineno_list *) NULL;
3852 if (s->lineno_list_head == (struct lineno_list *) NULL)
3854 s->lineno_list_head = new_line;
3858 s->lineno_list_tail->next = new_line;
3860 s->lineno_list_tail = new_line;
3861 return LINESZ * s->scnhdr.s_nlnno++;
3865 c_dot_file_symbol (filename)
3870 symbolP = symbol_new (".file",
3873 &zero_address_frag);
3875 S_SET_STORAGE_CLASS (symbolP, C_FILE);
3876 S_SET_NUMBER_AUXILIARY (symbolP, 1);
3878 if (strlen (filename) > FILNMLEN)
3880 /* Filename is too long to fit into an auxent,
3881 we stick it into the string table instead. We keep
3882 a linked list of the filenames we find so we can emit
3884 struct filename_list *f = ((struct filename_list *)
3885 xmalloc (sizeof (struct filename_list)));
3887 f->filename = filename;
3890 SA_SET_FILE_FNAME_ZEROS (symbolP, 0);
3891 SA_SET_FILE_FNAME_OFFSET (symbolP, 1);
3893 if (filename_list_tail)
3894 filename_list_tail->next = f;
3896 filename_list_head = f;
3897 filename_list_tail = f;
3901 SA_SET_FILE_FNAME (symbolP, filename);
3908 listing_source_file (filename);
3914 SF_SET_DEBUG (symbolP);
3915 S_SET_VALUE (symbolP, (valueT) previous_file_symbol);
3917 previous_file_symbol = symbolP;
3919 /* Make sure that the symbol is first on the symbol chain */
3920 if (symbol_rootP != symbolP)
3922 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3923 symbol_insert (symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
3925 } /* c_dot_file_symbol() */
3928 * Build a 'section static' symbol.
3932 c_section_symbol (name, idx)
3938 symbolP = symbol_find_base (name, DO_NOT_STRIP);
3939 if (symbolP == NULL)
3940 symbolP = symbol_new (name, idx, 0, &zero_address_frag);
3943 /* Mmmm. I just love violating interfaces. Makes me feel...dirty. */
3944 S_SET_SEGMENT (symbolP, idx);
3945 symbolP->sy_frag = &zero_address_frag;
3948 S_SET_STORAGE_CLASS (symbolP, C_STAT);
3949 S_SET_NUMBER_AUXILIARY (symbolP, 1);
3951 SF_SET_STATICS (symbolP);
3954 /* manfred@s-direktnet.de: section symbols *must* have the LOCAL bit cleared,
3955 which is set by the new definition of LOCAL_LABEL in tc-m68k.h. */
3956 SF_CLEAR_LOCAL (symbolP);
3959 /* If the .linkonce pseudo-op was used for this section, we must
3960 store the information in the auxiliary entry for the section
3962 if (segment_info[idx].linkonce != LINKONCE_UNSET)
3966 switch (segment_info[idx].linkonce)
3970 case LINKONCE_DISCARD:
3971 type = IMAGE_COMDAT_SELECT_ANY;
3973 case LINKONCE_ONE_ONLY:
3974 type = IMAGE_COMDAT_SELECT_NODUPLICATES;
3976 case LINKONCE_SAME_SIZE:
3977 type = IMAGE_COMDAT_SELECT_SAME_SIZE;
3979 case LINKONCE_SAME_CONTENTS:
3980 type = IMAGE_COMDAT_SELECT_EXACT_MATCH;
3984 SYM_AUXENT (symbolP)->x_scn.x_comdat = type;
3989 } /* c_section_symbol() */
3992 w_symbols (abfd, where, symbol_rootP)
3995 symbolS * symbol_rootP;
4000 /* First fill in those values we have only just worked out */
4001 for (i = SEG_E0; i < SEG_LAST; i++)
4003 symbolP = segment_info[i].dot;
4006 SA_SET_SCN_SCNLEN (symbolP, segment_info[i].scnhdr.s_size);
4007 SA_SET_SCN_NRELOC (symbolP, segment_info[i].scnhdr.s_nreloc);
4008 SA_SET_SCN_NLINNO (symbolP, segment_info[i].scnhdr.s_nlnno);
4013 * Emit all symbols left in the symbol chain.
4015 for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
4017 /* Used to save the offset of the name. It is used to point
4018 to the string in memory but must be a file offset. */
4019 register char *temp;
4021 /* We can't fix the lnnoptr field in yank_symbols with the other
4022 adjustments, because we have to wait until we know where they
4024 if (SF_GET_ADJ_LNNOPTR (symbolP))
4026 SA_GET_SYM_LNNOPTR (symbolP) +=
4027 segment_info[S_GET_SEGMENT (symbolP)].scnhdr.s_lnnoptr;
4030 tc_coff_symbol_emit_hook (symbolP);
4032 temp = S_GET_NAME (symbolP);
4033 if (SF_GET_STRING (symbolP))
4035 S_SET_OFFSET (symbolP, symbolP->sy_name_offset);
4036 S_SET_ZEROES (symbolP, 0);
4040 memset (symbolP->sy_symbol.ost_entry.n_name, 0, SYMNMLEN);
4041 strncpy (symbolP->sy_symbol.ost_entry.n_name, temp, SYMNMLEN);
4043 where = symbol_to_chars (abfd, where, symbolP);
4044 S_SET_NAME (symbolP, temp);
4050 obj_coff_lcomm (ignore)
4051 int ignore ATTRIBUTE_UNUSED;
4063 name = input_line_pointer;
4065 c = get_symbol_end ();
4066 p = input_line_pointer;
4069 if (*input_line_pointer != ',')
4071 as_bad (_("Expected comma after name"));
4072 ignore_rest_of_line ();
4075 if (*input_line_pointer == '\n')
4077 as_bad (_("Missing size expression"));
4080 input_line_pointer++;
4081 if ((temp = get_absolute_expression ()) < 0)
4083 as_warn (_("lcomm length (%d.) <0! Ignored."), temp);
4084 ignore_rest_of_line ();
4089 symbolP = symbol_find_or_make (name);
4091 if (S_GET_SEGMENT (symbolP) == SEG_UNKNOWN &&
4092 S_GET_VALUE (symbolP) == 0)
4097 segT current_seg = now_seg; /* save current seg */
4098 subsegT current_subseg = now_subseg;
4100 subseg_set (SEG_E2, 1);
4101 symbolP->sy_frag = frag_now;
4102 p = frag_var(rs_org, 1, 1, (relax_substateT)0, symbolP,
4103 (offsetT) temp, (char *) 0);
4105 subseg_set (current_seg, current_subseg); /* restore current seg */
4106 S_SET_SEGMENT (symbolP, SEG_E2);
4107 S_SET_STORAGE_CLASS (symbolP, C_STAT);
4111 as_bad (_("Symbol %s already defined"), name);
4113 demand_empty_rest_of_line ();
4118 fixup_mdeps (frags, h, this_segment)
4123 subseg_change (this_segment, 0);
4126 switch (frags->fr_type)
4133 HANDLE_ALIGN (frags);
4135 frags->fr_type = rs_fill;
4137 ((frags->fr_next->fr_address - frags->fr_address - frags->fr_fix)
4140 case rs_machine_dependent:
4141 md_convert_frag (h, this_segment, frags);
4147 frags = frags->fr_next;
4153 #ifndef TC_FORCE_RELOCATION
4154 #define TC_FORCE_RELOCATION(fix) 0
4158 fixup_segment (segP, this_segment_type)
4159 segment_info_type * segP;
4160 segT this_segment_type;
4162 register fixS * fixP;
4163 register symbolS *add_symbolP;
4164 register symbolS *sub_symbolP;
4167 register char *place;
4168 register long where;
4169 register char pcrel;
4170 register fragS *fragP;
4171 register segT add_symbol_segment = absolute_section;
4173 for (fixP = segP->fix_root; fixP; fixP = fixP->fx_next)
4175 fragP = fixP->fx_frag;
4177 where = fixP->fx_where;
4178 place = fragP->fr_literal + where;
4179 size = fixP->fx_size;
4180 add_symbolP = fixP->fx_addsy;
4181 sub_symbolP = fixP->fx_subsy;
4182 add_number = fixP->fx_offset;
4183 pcrel = fixP->fx_pcrel;
4185 /* We want function-relative stabs to work on systems which
4186 may use a relaxing linker; thus we must handle the sym1-sym2
4187 fixups function-relative stabs generates.
4189 Of course, if you actually enable relaxing in the linker, the
4190 line and block scoping information is going to be incorrect
4191 in some cases. The only way to really fix this is to support
4192 a reloc involving the difference of two symbols. */
4194 && (!sub_symbolP || pcrel))
4198 if (fixP->fx_tcbit && SF_GET_CALLNAME (add_symbolP))
4200 /* Relocation should be done via the associated 'bal' entry
4203 if (!SF_GET_BALNAME (tc_get_bal_of_call (add_symbolP)))
4205 as_bad_where (fixP->fx_file, fixP->fx_line,
4206 _("No 'bal' entry point for leafproc %s"),
4207 S_GET_NAME (add_symbolP));
4210 fixP->fx_addsy = add_symbolP = tc_get_bal_of_call (add_symbolP);
4214 /* Make sure the symbols have been resolved; this may not have
4215 happened if these are expression symbols. */
4216 if (add_symbolP != NULL && ! add_symbolP->sy_resolved)
4217 resolve_symbol_value (add_symbolP);
4219 if (add_symbolP != NULL)
4221 /* If this fixup is against a symbol which has been equated
4222 to another symbol, convert it to the other symbol. */
4223 if (add_symbolP->sy_value.X_op == O_symbol
4224 && (! S_IS_DEFINED (add_symbolP)
4225 || S_IS_COMMON (add_symbolP)))
4227 while (add_symbolP->sy_value.X_op == O_symbol
4228 && (! S_IS_DEFINED (add_symbolP)
4229 || S_IS_COMMON (add_symbolP)))
4233 /* We must avoid looping, as that can occur with a
4234 badly written program. */
4235 n = add_symbolP->sy_value.X_add_symbol;
4236 if (n == add_symbolP)
4238 add_number += add_symbolP->sy_value.X_add_number;
4241 fixP->fx_addsy = add_symbolP;
4242 fixP->fx_offset = add_number;
4246 if (sub_symbolP != NULL && ! sub_symbolP->sy_resolved)
4247 resolve_symbol_value (sub_symbolP);
4249 if (add_symbolP != NULL
4250 && add_symbolP->sy_mri_common)
4252 know (add_symbolP->sy_value.X_op == O_symbol);
4253 add_number += S_GET_VALUE (add_symbolP);
4254 fixP->fx_offset = add_number;
4255 add_symbolP = fixP->fx_addsy = add_symbolP->sy_value.X_add_symbol;
4260 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
4261 } /* if there is an addend */
4265 if (add_symbolP == NULL || add_symbol_segment == absolute_section)
4267 if (add_symbolP != NULL)
4269 add_number += S_GET_VALUE (add_symbolP);
4271 fixP->fx_addsy = NULL;
4274 /* It's just -sym. */
4275 if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
4277 add_number -= S_GET_VALUE (sub_symbolP);
4284 as_bad_where (fixP->fx_file, fixP->fx_line,
4285 _("Negative of non-absolute symbol %s"),
4286 S_GET_NAME (sub_symbolP));
4288 add_number -= S_GET_VALUE (sub_symbolP);
4289 } /* not absolute */
4291 /* if sub_symbol is in the same segment that add_symbol
4292 and add_symbol is either in DATA, TEXT, BSS or ABSOLUTE */
4294 else if (S_GET_SEGMENT (sub_symbolP) == add_symbol_segment
4295 && SEG_NORMAL (add_symbol_segment))
4297 /* Difference of 2 symbols from same segment. Can't
4298 make difference of 2 undefineds: 'value' means
4299 something different for N_UNDF. */
4301 /* Makes no sense to use the difference of 2 arbitrary symbols
4302 as the target of a call instruction. */
4305 as_bad_where (fixP->fx_file, fixP->fx_line,
4306 _("callj to difference of 2 symbols"));
4308 #endif /* TC_I960 */
4309 add_number += S_GET_VALUE (add_symbolP) -
4310 S_GET_VALUE (sub_symbolP);
4313 if (!TC_FORCE_RELOCATION (fixP))
4315 fixP->fx_addsy = NULL;
4316 fixP->fx_subsy = NULL;
4318 #ifdef TC_M68K /* is this right? */
4326 /* Different segments in subtraction. */
4327 know (!(S_IS_EXTERNAL (sub_symbolP) && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
4329 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
4331 add_number -= S_GET_VALUE (sub_symbolP);
4334 else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
4335 #if 0 /* Okay for 68k, at least... */
4340 /* Make it pc-relative. */
4341 add_number += (md_pcrel_from (fixP)
4342 - S_GET_VALUE (sub_symbolP));
4351 as_bad_where (fixP->fx_file, fixP->fx_line,
4352 _("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %ld."),
4353 segment_name (S_GET_SEGMENT (sub_symbolP)),
4354 S_GET_NAME (sub_symbolP),
4355 (long) (fragP->fr_address + where));
4358 } /* if sub_symbolP */
4362 if (add_symbol_segment == this_segment_type && pcrel)
4365 * This fixup was made when the symbol's segment was
4366 * SEG_UNKNOWN, but it is now in the local segment.
4367 * So we know how to do the address without relocation.
4370 /* reloc_callj() may replace a 'call' with a 'calls' or a 'bal',
4371 * in which cases it modifies *fixP as appropriate. In the case
4372 * of a 'calls', no further work is required, and *fixP has been
4373 * set up to make the rest of the code below a no-op.
4376 #endif /* TC_I960 */
4378 add_number += S_GET_VALUE (add_symbolP);
4379 add_number -= md_pcrel_from (fixP);
4382 add_number -= segP->scnhdr.s_vaddr;
4383 if defined (TC_I386) || defined (TE_LYNX). I now
4384 think that was an error propagated from the case when
4385 we are going to emit the relocation. If we are not
4386 going to emit the relocation, then we just want to
4387 set add_number to the difference between the symbols.
4388 This is a case that would only arise when there is a
4389 PC relative reference from a section other than .text
4390 to a symbol defined in the same section, and the
4391 reference is not relaxed. Since jump instructions on
4392 the i386 are relaxed, this could only arise with a
4393 call instruction. */
4395 pcrel = 0; /* Lie. Don't want further pcrel processing. */
4396 if (!TC_FORCE_RELOCATION (fixP))
4398 fixP->fx_addsy = NULL;
4404 switch (add_symbol_segment)
4406 case absolute_section:
4408 reloc_callj (fixP); /* See comment about reloc_callj() above*/
4409 #endif /* TC_I960 */
4410 add_number += S_GET_VALUE (add_symbolP);
4413 if (!TC_FORCE_RELOCATION (fixP))
4415 fixP->fx_addsy = NULL;
4421 #if defined(TC_A29K) || (defined(TE_PE) && defined(TC_I386)) || defined(TC_M88K)
4422 /* This really should be handled in the linker, but
4423 backward compatibility forbids. */
4424 add_number += S_GET_VALUE (add_symbolP);
4426 add_number += S_GET_VALUE (add_symbolP) +
4427 segment_info[S_GET_SEGMENT (add_symbolP)].scnhdr.s_paddr;
4433 if ((int) fixP->fx_bit_fixP == 13)
4435 /* This is a COBR instruction. They have only a
4436 * 13-bit displacement and are only to be used
4437 * for local branches: flag as error, don't generate
4440 as_bad_where (fixP->fx_file, fixP->fx_line,
4441 _("can't use COBR format with external label"));
4442 fixP->fx_addsy = NULL;
4446 #endif /* TC_I960 */
4447 #if ((defined (TC_I386) || defined (TE_LYNX) || defined (TE_AUX)) && !defined(TE_PE)) || defined (COFF_COMMON_ADDEND)
4448 /* 386 COFF uses a peculiar format in which the
4449 value of a common symbol is stored in the .text
4450 segment (I've checked this on SVR3.2 and SCO
4451 3.2.2) Ian Taylor <ian@cygnus.com>. */
4452 /* This is also true for 68k COFF on sysv machines
4453 (Checked on Motorola sysv68 R3V6 and R3V7.1, and also on
4454 UNIX System V/M68000, Release 1.0 from ATT/Bell Labs)
4455 Philippe De Muyter <phdm@info.ucl.ac.be>. */
4456 if (S_IS_COMMON (add_symbolP))
4457 add_number += S_GET_VALUE (add_symbolP);
4461 } /* switch on symbol seg */
4462 } /* if not in local seg */
4463 } /* if there was a + symbol */
4467 #if !defined(TC_M88K) && !(defined(TE_PE) && defined(TC_I386)) && !defined(TC_A29K)
4468 /* This adjustment is not correct on the m88k, for which the
4469 linker does all the computation. */
4470 add_number -= md_pcrel_from (fixP);
4472 if (add_symbolP == 0)
4474 fixP->fx_addsy = &abs_symbol;
4475 } /* if there's an add_symbol */
4476 #if defined (TC_I386) || defined (TE_LYNX) || defined (TC_I960) || defined (TC_M68K)
4477 /* On the 386 we must adjust by the segment vaddr as well.
4480 I changed the i960 to work this way as well. This is
4481 compatible with the current GNU linker behaviour. I do
4482 not know what other i960 COFF assemblers do. This is not
4483 a common case: normally, only assembler code will contain
4484 a PC relative reloc, and only branches which do not
4485 originate in the .text section will have a non-zero
4488 I changed the m68k to work this way as well. This will
4489 break existing PC relative relocs from sections which do
4490 not start at address 0, but it will make ld -r work.
4491 Ian Taylor, 4 Oct 96. */
4493 add_number -= segP->scnhdr.s_vaddr;
4497 #ifdef MD_APPLY_FIX3
4498 md_apply_fix3 (fixP, (valueT *) &add_number, this_segment_type);
4500 md_apply_fix (fixP, add_number);
4503 if (!fixP->fx_bit_fixP && ! fixP->fx_no_overflow)
4506 /* The m88k uses the offset field of the reloc to get around
4509 && ((add_number & ~0xFF)
4510 || (fixP->fx_signed && (add_number & 0x80)))
4511 && ((add_number & ~0xFF) != (-1 & ~0xFF)
4512 || (add_number & 0x80) == 0))
4514 && ((add_number & ~0xFFFF)
4515 || (fixP->fx_signed && (add_number & 0x8000)))
4516 && ((add_number & ~0xFFFF) != (-1 & ~0xFFFF)
4517 || (add_number & 0x8000) == 0)))
4519 as_bad_where (fixP->fx_file, fixP->fx_line,
4520 _("Value of %ld too large for field of %d bytes at 0x%lx"),
4521 (long) add_number, size,
4522 (unsigned long) (fragP->fr_address + where));
4525 #ifdef WARN_SIGNED_OVERFLOW_WORD
4526 /* Warn if a .word value is too large when treated as a
4527 signed number. We already know it is not too negative.
4528 This is to catch over-large switches generated by gcc on
4530 if (!flag_signed_overflow_ok
4532 && add_number > 0x7fff)
4533 as_bad_where (fixP->fx_file, fixP->fx_line,
4534 _("Signed .word overflow; switch may be too large; %ld at 0x%lx"),
4536 (unsigned long) (fragP->fr_address + where));
4538 } /* not a bit fix */
4539 } /* For each fixS in this segment. */
4540 } /* fixup_segment() */
4544 /* The first entry in a .stab section is special. */
4547 obj_coff_init_stab_section (seg)
4553 unsigned int stroff;
4555 /* Make space for this first symbol. */
4559 as_where (&file, (unsigned int *) NULL);
4560 stabstr_name = (char *) alloca (strlen (segment_info[seg].name) + 4);
4561 strcpy (stabstr_name, segment_info[seg].name);
4562 strcat (stabstr_name, "str");
4563 stroff = get_stab_string_offset (file, stabstr_name);
4565 md_number_to_chars (p, stroff, 4);
4568 /* Fill in the counts in the first entry in a .stab section. */
4571 adjust_stab_section(abfd, seg)
4575 segT stabstrseg = SEG_UNKNOWN;
4576 const char *secname, *name2;
4579 int i, strsz = 0, nsyms;
4580 fragS *frag = segment_info[seg].frchainP->frch_root;
4582 /* Look for the associated string table section. */
4584 secname = segment_info[seg].name;
4585 name = (char *) alloca (strlen (secname) + 4);
4586 strcpy (name, secname);
4587 strcat (name, "str");
4589 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
4591 name2 = segment_info[i].name;
4592 if (name2 != NULL && strncmp(name2, name, 8) == 0)
4599 /* If we found the section, get its size. */
4600 if (stabstrseg != SEG_UNKNOWN)
4601 strsz = size_section (abfd, stabstrseg);
4603 nsyms = size_section (abfd, seg) / 12 - 1;
4605 /* Look for the first frag of sufficient size for the initial stab
4606 symbol, and collect a pointer to it. */
4607 while (frag && frag->fr_fix < 12)
4608 frag = frag->fr_next;
4610 p = frag->fr_literal;
4613 /* Write in the number of stab symbols and the size of the string
4615 bfd_h_put_16 (abfd, (bfd_vma) nsyms, (bfd_byte *) p + 6);
4616 bfd_h_put_32 (abfd, (bfd_vma) strsz, (bfd_byte *) p + 8);
4619 #endif /* not BFD_ASSEMBLER */
4621 const pseudo_typeS coff_pseudo_table[] =
4623 {"def", obj_coff_def, 0},
4624 {"dim", obj_coff_dim, 0},
4625 {"endef", obj_coff_endef, 0},
4626 {"line", obj_coff_line, 0},
4627 {"ln", obj_coff_ln, 0},
4628 #ifdef BFD_ASSEMBLER
4629 {"loc", obj_coff_loc, 0},
4631 {"appline", obj_coff_ln, 1},
4632 {"scl", obj_coff_scl, 0},
4633 {"size", obj_coff_size, 0},
4634 {"tag", obj_coff_tag, 0},
4635 {"type", obj_coff_type, 0},
4636 {"val", obj_coff_val, 0},
4637 {"section", obj_coff_section, 0},
4638 {"sect", obj_coff_section, 0},
4639 /* FIXME: We ignore the MRI short attribute. */
4640 {"section.s", obj_coff_section, 0},
4641 {"sect.s", obj_coff_section, 0},
4642 /* We accept the .bss directive for backward compatibility with
4643 earlier versions of gas. */
4644 {"bss", obj_coff_bss, 0},
4645 {"weak", obj_coff_weak, 0},
4646 {"ident", obj_coff_ident, 0},
4647 #ifndef BFD_ASSEMBLER
4648 {"use", obj_coff_section, 0},
4649 {"text", obj_coff_text, 0},
4650 {"data", obj_coff_data, 0},
4651 {"lcomm", obj_coff_lcomm, 0},
4653 {"optim", s_ignore, 0}, /* For sun386i cc (?) */
4655 {"version", s_ignore, 0},
4656 {"ABORT", s_abort, 0},
4658 /* The m88k uses sdef instead of def. */
4659 {"sdef", obj_coff_def, 0},
4661 {NULL, NULL, 0} /* end sentinel */
4662 }; /* coff_pseudo_table */
4664 #ifdef BFD_ASSEMBLER
4666 /* Support for a COFF emulation. */
4668 static void coff_pop_insert PARAMS ((void));
4669 static int coff_separate_stab_sections PARAMS ((void));
4674 pop_insert (coff_pseudo_table);
4678 coff_separate_stab_sections ()
4683 const struct format_ops coff_format_ops =
4685 bfd_target_coff_flavour,
4686 0, /* dfl_leading_underscore */
4687 1, /* emit_section_symbols */
4692 0, /* frob_file_before_adjust */
4693 coff_frob_file_after_relocs,
4696 0, /* s_get_align */
4697 0, /* s_set_align */
4698 0, /* s_get_other */
4699 0, /* s_set_other */
4704 0, /* copy_symbol_attributes */
4705 0, /* generate_asm_lineno */
4706 0, /* process_stab */
4707 coff_separate_stab_sections,
4708 obj_coff_init_stab_section,
4709 0, /* sec_sym_ok_for_reloc */
4711 0, /* ecoff_set_ext */
4712 coff_obj_read_begin_hook,
4713 coff_obj_symbol_new_hook