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;
1314 && S_GET_STORAGE_CLASS (symp) == C_FCN
1315 && strcmp (S_GET_NAME (symp), ".bf") == 0)
1317 if (coff_last_bf != NULL)
1318 SA_SET_SYM_ENDNDX (coff_last_bf, symp);
1319 coff_last_bf = symp;
1322 if (coffsymbol (symbol_get_bfdsym (symp))->lineno)
1325 struct line_no *lptr;
1328 lptr = (struct line_no *) coffsymbol (symbol_get_bfdsym (symp))->lineno;
1329 for (i = 0; lptr; lptr = lptr->next)
1331 lptr = (struct line_no *) coffsymbol (symbol_get_bfdsym (symp))->lineno;
1333 /* We need i entries for line numbers, plus 1 for the first
1334 entry which BFD will override, plus 1 for the last zero
1335 entry (a marker for BFD). */
1336 l = (alent *) xmalloc ((i + 2) * sizeof (alent));
1337 coffsymbol (symbol_get_bfdsym (symp))->lineno = l;
1338 l[i + 1].line_number = 0;
1339 l[i + 1].u.sym = NULL;
1343 lptr->l.u.offset += lptr->frag->fr_address / OCTETS_PER_BYTE;
1351 coff_adjust_section_syms (abfd, sec, x)
1352 bfd *abfd ATTRIBUTE_UNUSED;
1354 PTR x ATTRIBUTE_UNUSED;
1357 segment_info_type *seginfo = seg_info (sec);
1358 int nlnno, nrelocs = 0;
1360 /* RS/6000 gas creates a .debug section manually in ppc_frob_file in
1361 tc-ppc.c. Do not get confused by it. */
1362 if (seginfo == NULL)
1365 if (!strcmp (sec->name, ".text"))
1366 nlnno = coff_n_line_nos;
1370 /* @@ Hope that none of the fixups expand to more than one reloc
1372 fixS *fixp = seginfo->fix_root;
1375 if (! fixp->fx_done)
1377 fixp = fixp->fx_next;
1380 if (bfd_get_section_size_before_reloc (sec) == 0
1383 && sec != text_section
1384 && sec != data_section
1385 && sec != bss_section)
1387 secsym = section_symbol (sec);
1388 /* This is an estimate; we'll plug in the real value using
1389 SET_SECTION_RELOCS later */
1390 SA_SET_SCN_NRELOC (secsym, nrelocs);
1391 SA_SET_SCN_NLINNO (secsym, nlnno);
1395 coff_frob_file_after_relocs ()
1397 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
1416 Note the 'a' flag is silently ignored. This allows the same
1417 .section directive to be parsed in both ELF and COFF formats. */
1420 obj_coff_section (ignore)
1421 int ignore ATTRIBUTE_UNUSED;
1423 /* Strip out the section name */
1428 flagword flags, oldflags;
1439 section_name = input_line_pointer;
1440 c = get_symbol_end ();
1442 name = xmalloc (input_line_pointer - section_name + 1);
1443 strcpy (name, section_name);
1445 *input_line_pointer = c;
1450 flags = SEC_NO_FLAGS;
1452 if (*input_line_pointer == ',')
1454 ++input_line_pointer;
1456 if (*input_line_pointer != '"')
1457 exp = get_absolute_expression ();
1460 ++input_line_pointer;
1461 while (*input_line_pointer != '"'
1462 && ! is_end_of_line[(unsigned char) *input_line_pointer])
1464 switch (*input_line_pointer)
1466 case 'b': flags |= SEC_ALLOC; flags &=~ SEC_LOAD; break;
1467 case 'n': flags &=~ SEC_LOAD; flags |= SEC_NEVER_LOAD; break;
1469 case 's': flags |= SEC_SHARED; /* fall through */
1470 case 'd': flags |= SEC_DATA | SEC_LOAD; /* fall through */
1471 case 'w': flags &=~ SEC_READONLY; break;
1473 case 'a': break; /* For compatability with ELF. */
1474 case 'x': flags |= SEC_CODE | SEC_LOAD; break;
1475 case 'r': flags |= SEC_READONLY; break;
1477 case 'i': /* STYP_INFO */
1478 case 'l': /* STYP_LIB */
1479 case 'o': /* STYP_OVER */
1480 as_warn (_("unsupported section attribute '%c'"),
1481 *input_line_pointer);
1485 as_warn(_("unknown section attribute '%c'"),
1486 *input_line_pointer);
1489 ++input_line_pointer;
1491 if (*input_line_pointer == '"')
1492 ++input_line_pointer;
1496 sec = subseg_new (name, (subsegT) exp);
1498 oldflags = bfd_get_section_flags (stdoutput, sec);
1499 if (oldflags == SEC_NO_FLAGS)
1501 /* Set section flags for a new section just created by subseg_new.
1502 Provide a default if no flags were parsed. */
1503 if (flags == SEC_NO_FLAGS)
1504 flags = TC_COFF_SECTION_DEFAULT_ATTRIBUTES;
1506 #ifdef COFF_LONG_SECTION_NAMES
1507 /* Add SEC_LINK_ONCE and SEC_LINK_DUPLICATES_DISCARD to .gnu.linkonce
1508 sections so adjust_reloc_syms in write.c will correctly handle
1509 relocs which refer to non-local symbols in these sections. */
1510 if (strncmp (name, ".gnu.linkonce", sizeof (".gnu.linkonce") - 1) == 0)
1511 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1514 if (! bfd_set_section_flags (stdoutput, sec, flags))
1515 as_warn (_("error setting flags for \"%s\": %s"),
1516 bfd_section_name (stdoutput, sec),
1517 bfd_errmsg (bfd_get_error ()));
1519 else if (flags != SEC_NO_FLAGS)
1521 /* This section's attributes have already been set. Warn if the
1522 attributes don't match. */
1523 flagword matchflags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE
1524 | SEC_DATA | SEC_SHARED | SEC_NEVER_LOAD);
1525 if ((flags ^ oldflags) & matchflags)
1526 as_warn (_("Ignoring changed section attributes for %s"), name);
1529 demand_empty_rest_of_line ();
1533 coff_adjust_symtab ()
1535 if (symbol_rootP == NULL
1536 || S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
1537 c_dot_file_symbol ("fake");
1541 coff_frob_section (sec)
1547 bfd_vma size, n_entries, mask;
1548 bfd_vma align_power = (bfd_vma)sec->alignment_power + OCTETS_PER_BYTE_POWER;
1550 /* The COFF back end in BFD requires that all section sizes be
1551 rounded up to multiples of the corresponding section alignments,
1552 supposedly because standard COFF has no other way of encoding alignment
1553 for sections. If your COFF flavor has a different way of encoding
1554 section alignment, then skip this step, as TICOFF does. */
1555 size = bfd_get_section_size_before_reloc (sec);
1556 mask = ((bfd_vma) 1 << align_power) - 1;
1557 #if !defined(TICOFF)
1563 new_size = (size + mask) & ~mask;
1564 bfd_set_section_size (stdoutput, sec, new_size);
1566 /* If the size had to be rounded up, add some padding in
1567 the last non-empty frag. */
1568 fragp = seg_info (sec)->frchainP->frch_root;
1569 last = seg_info (sec)->frchainP->frch_last;
1570 while (fragp->fr_next != last)
1571 fragp = fragp->fr_next;
1572 last->fr_address = size;
1573 fragp->fr_offset += new_size - size;
1577 /* If the section size is non-zero, the section symbol needs an aux
1578 entry associated with it, indicating the size. We don't know
1579 all the values yet; coff_frob_symbol will fill them in later. */
1582 || sec == text_section
1583 || sec == data_section
1584 || sec == bss_section)
1587 symbolS *secsym = section_symbol (sec);
1589 S_SET_STORAGE_CLASS (secsym, C_STAT);
1590 S_SET_NUMBER_AUXILIARY (secsym, 1);
1591 SF_SET_STATICS (secsym);
1592 SA_SET_SCN_SCNLEN (secsym, size);
1595 /* @@ these should be in a "stabs.h" file, or maybe as.h */
1596 #ifndef STAB_SECTION_NAME
1597 #define STAB_SECTION_NAME ".stab"
1599 #ifndef STAB_STRING_SECTION_NAME
1600 #define STAB_STRING_SECTION_NAME ".stabstr"
1602 if (strcmp (STAB_STRING_SECTION_NAME, sec->name))
1606 sec = subseg_get (STAB_SECTION_NAME, 0);
1607 /* size is already rounded up, since other section will be listed first */
1608 size = bfd_get_section_size_before_reloc (strsec);
1610 n_entries = bfd_get_section_size_before_reloc (sec) / 12 - 1;
1612 /* Find first non-empty frag. It should be large enough. */
1613 fragp = seg_info (sec)->frchainP->frch_root;
1614 while (fragp && fragp->fr_fix == 0)
1615 fragp = fragp->fr_next;
1616 assert (fragp != 0 && fragp->fr_fix >= 12);
1618 /* Store the values. */
1619 p = fragp->fr_literal;
1620 bfd_h_put_16 (stdoutput, n_entries, (bfd_byte *) p + 6);
1621 bfd_h_put_32 (stdoutput, size, (bfd_byte *) p + 8);
1625 obj_coff_init_stab_section (seg)
1631 unsigned int stroff;
1633 /* Make space for this first symbol. */
1637 as_where (&file, (unsigned int *) NULL);
1638 stabstr_name = (char *) xmalloc (strlen (seg->name) + 4);
1639 strcpy (stabstr_name, seg->name);
1640 strcat (stabstr_name, "str");
1641 stroff = get_stab_string_offset (file, stabstr_name);
1643 md_number_to_chars (p, stroff, 4);
1652 return ((s == NULL) ? "(NULL)" : S_GET_NAME (s));
1660 for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
1662 printf (_("0x%lx: \"%s\" type = %ld, class = %d, segment = %d\n"),
1663 (unsigned long) symbolP,
1664 S_GET_NAME(symbolP),
1665 (long) S_GET_DATA_TYPE(symbolP),
1666 S_GET_STORAGE_CLASS(symbolP),
1667 (int) S_GET_SEGMENT(symbolP));
1673 #else /* not BFD_ASSEMBLER */
1676 /* This is needed because we include internal bfd things. */
1680 #include "libcoff.h"
1683 #include "coff/pe.h"
1686 /* The NOP_OPCODE is for the alignment fill value. Fill with nop so
1687 that we can stick sections together without causing trouble. */
1689 #define NOP_OPCODE 0x00
1692 /* The zeroes if symbol name is longer than 8 chars */
1693 #define S_SET_ZEROES(s,v) ((s)->sy_symbol.ost_entry.n_zeroes = (v))
1695 #define MIN(a,b) ((a) < (b)? (a) : (b))
1697 /* This vector is used to turn a gas internal segment number into a
1698 section number suitable for insertion into a coff symbol table.
1699 This must correspond to seg_info_off_by_4. */
1701 const short seg_N_TYPE[] =
1702 { /* in: segT out: N_TYPE bits */
1704 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
1705 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
1706 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
1707 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
1708 C_UNDEF_SECTION, /* SEG_UNKNOWN */
1709 C_UNDEF_SECTION, /* SEG_GOOF */
1710 C_UNDEF_SECTION, /* SEG_EXPR */
1711 C_DEBUG_SECTION, /* SEG_DEBUG */
1712 C_NTV_SECTION, /* SEG_NTV */
1713 C_PTV_SECTION, /* SEG_PTV */
1714 C_REGISTER_SECTION, /* SEG_REGISTER */
1717 int function_lineoff = -1; /* Offset in line#s where the last function
1718 started (the odd entry for line #0) */
1720 /* Structure used to keep the filenames which
1721 are too long around so that we can stick them
1722 into the string table. */
1723 struct filename_list
1726 struct filename_list *next;
1729 static struct filename_list *filename_list_head;
1730 static struct filename_list *filename_list_tail;
1732 static symbolS *last_line_symbol;
1734 /* Add 4 to the real value to get the index and compensate the
1735 negatives. This vector is used by S_GET_SEGMENT to turn a coff
1736 section number into a segment number. */
1739 static symbolS *previous_file_symbol;
1740 static int line_base;
1742 void c_symbol_merge PARAMS ((symbolS *, symbolS *));
1743 symbolS *c_section_symbol PARAMS ((char *, int));
1744 void obj_coff_section PARAMS ((int));
1745 void do_relocs_for PARAMS ((bfd *, object_headers *, unsigned long *));
1746 char * symbol_to_chars PARAMS ((bfd *, char *, symbolS *));
1747 void w_strings PARAMS ((char *));
1749 static void fixup_segment PARAMS ((segment_info_type *, segT));
1750 static void fixup_mdeps PARAMS ((fragS *, object_headers *, segT));
1751 static void fill_section PARAMS ((bfd *, object_headers *, unsigned long *));
1752 static int c_line_new PARAMS ((symbolS *, long, int, fragS *));
1753 static void w_symbols PARAMS ((bfd *, char *, symbolS *));
1754 static void adjust_stab_section PARAMS ((bfd *, segT));
1755 static void obj_coff_lcomm PARAMS ((int));
1756 static void obj_coff_text PARAMS ((int));
1757 static void obj_coff_data PARAMS ((int));
1758 static unsigned int count_entries_in_chain PARAMS ((unsigned int));
1759 static void coff_header_append PARAMS ((bfd *, object_headers *));
1760 static unsigned int yank_symbols PARAMS ((void));
1761 static unsigned int glue_symbols PARAMS ((symbolS **, symbolS **));
1762 static unsigned int tie_tags PARAMS ((void));
1763 static void crawl_symbols PARAMS ((object_headers *, bfd *));
1764 static void do_linenos_for PARAMS ((bfd *, object_headers *, unsigned long *));
1765 static void remove_subsegs PARAMS ((void));
1769 /* When not using BFD_ASSEMBLER, we permit up to 40 sections.
1771 This array maps a COFF section number into a gas section number.
1772 Because COFF uses negative section numbers, you must add 4 to the
1773 COFF section number when indexing into this array; this is done via
1774 the SEG_INFO_FROM_SECTION_NUMBER macro. This must correspond to
1777 static const segT seg_info_off_by_4[] =
1784 SEG_E0, SEG_E1, SEG_E2, SEG_E3, SEG_E4,
1785 SEG_E5, SEG_E6, SEG_E7, SEG_E8, SEG_E9,
1786 SEG_E10, SEG_E11, SEG_E12, SEG_E13, SEG_E14,
1787 SEG_E15, SEG_E16, SEG_E17, SEG_E18, SEG_E19,
1788 SEG_E20, SEG_E21, SEG_E22, SEG_E23, SEG_E24,
1789 SEG_E25, SEG_E26, SEG_E27, SEG_E28, SEG_E29,
1790 SEG_E30, SEG_E31, SEG_E32, SEG_E33, SEG_E34,
1791 SEG_E35, SEG_E36, SEG_E37, SEG_E38, SEG_E39,
1804 #define SEG_INFO_FROM_SECTION_NUMBER(x) (seg_info_off_by_4[(x)+4])
1806 static relax_addressT relax_align PARAMS ((relax_addressT, long));
1808 static relax_addressT
1809 relax_align (address, alignment)
1810 relax_addressT address;
1813 relax_addressT mask;
1814 relax_addressT new_address;
1816 mask = ~((~0) << alignment);
1817 new_address = (address + mask) & (~mask);
1818 return (new_address - address);
1825 return SEG_INFO_FROM_SECTION_NUMBER (x->sy_symbol.ost_entry.n_scnum);
1828 static unsigned int size_section PARAMS ((bfd *, unsigned int));
1830 /* Calculate the size of the frag chain and fill in the section header
1831 to contain all of it, also fill in the addr of the sections. */
1834 size_section (abfd, idx)
1835 bfd *abfd ATTRIBUTE_UNUSED;
1839 unsigned int size = 0;
1840 fragS *frag = segment_info[idx].frchainP->frch_root;
1844 size = frag->fr_address;
1845 if (frag->fr_address != size)
1847 fprintf (stderr, _("Out of step\n"));
1848 size = frag->fr_address;
1851 switch (frag->fr_type)
1853 #ifdef TC_COFF_SIZEMACHDEP
1854 case rs_machine_dependent:
1855 size += TC_COFF_SIZEMACHDEP (frag);
1861 size += frag->fr_fix;
1862 size += frag->fr_offset * frag->fr_var;
1870 size += frag->fr_fix;
1871 off = relax_align (size, frag->fr_offset);
1872 if (frag->fr_subtype != 0 && off > frag->fr_subtype)
1878 BAD_CASE (frag->fr_type);
1881 frag = frag->fr_next;
1883 segment_info[idx].scnhdr.s_size = size;
1888 count_entries_in_chain (idx)
1891 unsigned int nrelocs;
1894 /* Count the relocations. */
1895 fixup_ptr = segment_info[idx].fix_root;
1897 while (fixup_ptr != (fixS *) NULL)
1899 if (fixup_ptr->fx_done == 0 && TC_COUNT_RELOC (fixup_ptr))
1901 #if defined(TC_A29K) || defined(TC_OR32)
1902 if (fixup_ptr->fx_r_type == RELOC_CONSTH)
1911 fixup_ptr = fixup_ptr->fx_next;
1918 static int compare_external_relocs PARAMS ((const PTR, const PTR));
1920 /* AUX's ld expects relocations to be sorted. */
1923 compare_external_relocs (x, y)
1927 struct external_reloc *a = (struct external_reloc *) x;
1928 struct external_reloc *b = (struct external_reloc *) y;
1929 bfd_vma aadr = bfd_getb32 (a->r_vaddr);
1930 bfd_vma badr = bfd_getb32 (b->r_vaddr);
1931 return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
1936 /* Output all the relocations for a section. */
1939 do_relocs_for (abfd, h, file_cursor)
1942 unsigned long *file_cursor;
1944 unsigned int nrelocs;
1946 unsigned long reloc_start = *file_cursor;
1948 for (idx = SEG_E0; idx < SEG_LAST; idx++)
1950 if (segment_info[idx].scnhdr.s_name[0])
1952 struct external_reloc *ext_ptr;
1953 struct external_reloc *external_reloc_vec;
1954 unsigned int external_reloc_size;
1955 unsigned int base = segment_info[idx].scnhdr.s_paddr;
1956 fixS *fix_ptr = segment_info[idx].fix_root;
1957 nrelocs = count_entries_in_chain (idx);
1960 /* Bypass this stuff if no relocs. This also incidentally
1961 avoids a SCO bug, where free(malloc(0)) tends to crash. */
1963 external_reloc_size = nrelocs * RELSZ;
1964 external_reloc_vec =
1965 (struct external_reloc *) malloc (external_reloc_size);
1967 ext_ptr = external_reloc_vec;
1969 /* Fill in the internal coff style reloc struct from the
1970 internal fix list. */
1973 struct internal_reloc intr;
1975 /* Only output some of the relocations. */
1976 if (fix_ptr->fx_done == 0 && TC_COUNT_RELOC (fix_ptr))
1978 #ifdef TC_RELOC_MANGLE
1979 TC_RELOC_MANGLE (&segment_info[idx], fix_ptr, &intr,
1983 symbolS *symbol_ptr = fix_ptr->fx_addsy;
1985 intr.r_type = TC_COFF_FIX2RTYPE (fix_ptr);
1987 base + fix_ptr->fx_frag->fr_address + fix_ptr->fx_where;
1989 #ifdef TC_KEEP_FX_OFFSET
1990 intr.r_offset = fix_ptr->fx_offset;
1995 while (symbol_ptr->sy_value.X_op == O_symbol
1996 && (! S_IS_DEFINED (symbol_ptr)
1997 || S_IS_COMMON (symbol_ptr)))
2001 /* We must avoid looping, as that can occur
2002 with a badly written program. */
2003 n = symbol_ptr->sy_value.X_add_symbol;
2004 if (n == symbol_ptr)
2009 /* Turn the segment of the symbol into an offset. */
2012 resolve_symbol_value (symbol_ptr);
2013 if (! symbol_ptr->sy_resolved)
2018 if (expr_symbol_where (symbol_ptr, &file, &line))
2019 as_bad_where (file, line,
2020 _("unresolved relocation"));
2022 as_bad (_("bad relocation: symbol `%s' not in symbol table"),
2023 S_GET_NAME (symbol_ptr));
2026 dot = segment_info[S_GET_SEGMENT (symbol_ptr)].dot;
2028 intr.r_symndx = dot->sy_number;
2030 intr.r_symndx = symbol_ptr->sy_number;
2035 (void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
2037 #if defined(TC_A29K)
2038 /* The 29k has a special kludge for the high 16 bit
2039 reloc. Two relocations are emited, R_IHIHALF,
2040 and R_IHCONST. The second one doesn't contain a
2041 symbol, but uses the value for offset. */
2042 if (intr.r_type == R_IHIHALF)
2044 /* Now emit the second bit. */
2045 intr.r_type = R_IHCONST;
2046 intr.r_symndx = fix_ptr->fx_addnumber;
2047 (void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
2051 #if defined(TC_OR32)
2052 /* The or32 has a special kludge for the high 16 bit
2053 reloc. Two relocations are emited, R_IHIHALF,
2054 and R_IHCONST. The second one doesn't contain a
2055 symbol, but uses the value for offset. */
2056 if (intr.r_type == R_IHIHALF)
2058 /* Now emit the second bit. */
2059 intr.r_type = R_IHCONST;
2060 intr.r_symndx = fix_ptr->fx_addnumber;
2061 (void) bfd_coff_swap_reloc_out (abfd, & intr, ext_ptr);
2067 fix_ptr = fix_ptr->fx_next;
2070 /* Sort the reloc table. */
2071 qsort ((PTR) external_reloc_vec, nrelocs,
2072 sizeof (struct external_reloc), compare_external_relocs);
2074 /* Write out the reloc table. */
2075 bfd_bwrite ((PTR) external_reloc_vec,
2076 (bfd_size_type) external_reloc_size, abfd);
2077 free (external_reloc_vec);
2079 /* Fill in section header info. */
2080 segment_info[idx].scnhdr.s_relptr = *file_cursor;
2081 *file_cursor += external_reloc_size;
2082 segment_info[idx].scnhdr.s_nreloc = nrelocs;
2087 segment_info[idx].scnhdr.s_relptr = 0;
2092 /* Set relocation_size field in file headers. */
2093 H_SET_RELOCATION_SIZE (h, *file_cursor - reloc_start, 0);
2096 /* Run through a frag chain and write out the data to go with it, fill
2097 in the scnhdrs with the info on the file postions. */
2100 fill_section (abfd, h, file_cursor)
2102 object_headers *h ATTRIBUTE_UNUSED;
2103 unsigned long *file_cursor;
2106 unsigned int paddr = 0;
2108 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
2110 unsigned int offset = 0;
2111 struct internal_scnhdr *s = &(segment_info[i].scnhdr);
2117 fragS *frag = segment_info[i].frchainP->frch_root;
2118 char *buffer = NULL;
2124 buffer = xmalloc (s->s_size);
2125 s->s_scnptr = *file_cursor;
2127 know (s->s_paddr == paddr);
2129 if (strcmp (s->s_name, ".text") == 0)
2130 s->s_flags |= STYP_TEXT;
2131 else if (strcmp (s->s_name, ".data") == 0)
2132 s->s_flags |= STYP_DATA;
2133 else if (strcmp (s->s_name, ".bss") == 0)
2136 s->s_flags |= STYP_BSS;
2138 /* @@ Should make the i386 and a29k coff targets define
2139 COFF_NOLOAD_PROBLEM, and have only one test here. */
2143 #ifndef COFF_NOLOAD_PROBLEM
2144 /* Apparently the SVR3 linker (and exec syscall) and UDI
2145 mondfe progrem are confused by noload sections. */
2146 s->s_flags |= STYP_NOLOAD;
2152 else if (strcmp (s->s_name, ".lit") == 0)
2153 s->s_flags = STYP_LIT | STYP_TEXT;
2154 else if (strcmp (s->s_name, ".init") == 0)
2155 s->s_flags |= STYP_TEXT;
2156 else if (strcmp (s->s_name, ".fini") == 0)
2157 s->s_flags |= STYP_TEXT;
2158 else if (strncmp (s->s_name, ".comment", 8) == 0)
2159 s->s_flags |= STYP_INFO;
2163 unsigned int fill_size;
2164 switch (frag->fr_type)
2166 case rs_machine_dependent:
2169 memcpy (buffer + frag->fr_address,
2171 (unsigned int) frag->fr_fix);
2172 offset += frag->fr_fix;
2184 memcpy (buffer + frag->fr_address,
2186 (unsigned int) frag->fr_fix);
2187 offset += frag->fr_fix;
2190 fill_size = frag->fr_var;
2191 if (fill_size && frag->fr_offset > 0)
2194 unsigned int off = frag->fr_fix;
2195 for (count = frag->fr_offset; count; count--)
2197 if (fill_size + frag->fr_address + off <= s->s_size)
2199 memcpy (buffer + frag->fr_address + off,
2200 frag->fr_literal + frag->fr_fix,
2203 offset += fill_size;
2208 case rs_broken_word:
2213 frag = frag->fr_next;
2218 if (s->s_scnptr != 0)
2220 bfd_bwrite (buffer, s->s_size, abfd);
2221 *file_cursor += s->s_size;
2230 /* Coff file generation & utilities. */
2233 coff_header_append (abfd, h)
2240 #ifdef COFF_LONG_SECTION_NAMES
2241 unsigned long string_size = 4;
2244 bfd_seek (abfd, (file_ptr) 0, 0);
2246 #ifndef OBJ_COFF_OMIT_OPTIONAL_HEADER
2247 H_SET_MAGIC_NUMBER (h, COFF_MAGIC);
2248 H_SET_VERSION_STAMP (h, 0);
2249 H_SET_ENTRY_POINT (h, 0);
2250 H_SET_TEXT_START (h, segment_info[SEG_E0].frchainP->frch_root->fr_address);
2251 H_SET_DATA_START (h, segment_info[SEG_E1].frchainP->frch_root->fr_address);
2252 H_SET_SIZEOF_OPTIONAL_HEADER (h, bfd_coff_swap_aouthdr_out(abfd, &h->aouthdr,
2254 #else /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
2255 H_SET_SIZEOF_OPTIONAL_HEADER (h, 0);
2256 #endif /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
2258 i = bfd_coff_swap_filehdr_out (abfd, &h->filehdr, buffer);
2260 bfd_bwrite (buffer, (bfd_size_type) i, abfd);
2261 bfd_bwrite (buffero, (bfd_size_type) H_GET_SIZEOF_OPTIONAL_HEADER (h), abfd);
2263 for (i = SEG_E0; i < SEG_LAST; i++)
2265 if (segment_info[i].scnhdr.s_name[0])
2269 #ifdef COFF_LONG_SECTION_NAMES
2270 /* Support long section names as found in PE. This code
2271 must coordinate with that in write_object_file and
2273 if (strlen (segment_info[i].name) > SCNNMLEN)
2275 memset (segment_info[i].scnhdr.s_name, 0, SCNNMLEN);
2276 sprintf (segment_info[i].scnhdr.s_name, "/%lu", string_size);
2277 string_size += strlen (segment_info[i].name) + 1;
2280 size = bfd_coff_swap_scnhdr_out (abfd,
2281 &(segment_info[i].scnhdr),
2284 as_bad (_("bfd_coff_swap_scnhdr_out failed"));
2285 bfd_bwrite (buffer, (bfd_size_type) size, abfd);
2291 symbol_to_chars (abfd, where, symbolP)
2296 unsigned int numaux = symbolP->sy_symbol.ost_entry.n_numaux;
2300 /* Turn any symbols with register attributes into abs symbols. */
2301 if (S_GET_SEGMENT (symbolP) == reg_section)
2302 S_SET_SEGMENT (symbolP, absolute_section);
2304 /* At the same time, relocate all symbols to their output value. */
2306 val = (segment_info[S_GET_SEGMENT (symbolP)].scnhdr.s_paddr
2307 + S_GET_VALUE (symbolP));
2309 val = S_GET_VALUE (symbolP);
2312 S_SET_VALUE (symbolP, val);
2314 symbolP->sy_symbol.ost_entry.n_value = val;
2316 where += bfd_coff_swap_sym_out (abfd, &symbolP->sy_symbol.ost_entry,
2319 for (i = 0; i < numaux; i++)
2321 where += bfd_coff_swap_aux_out (abfd,
2322 &symbolP->sy_symbol.ost_auxent[i],
2323 S_GET_DATA_TYPE (symbolP),
2324 S_GET_STORAGE_CLASS (symbolP),
2332 coff_obj_symbol_new_hook (symbolP)
2335 char underscore = 0; /* Symbol has leading _ */
2337 /* Effective symbol. */
2338 /* Store the pointer in the offset. */
2339 S_SET_ZEROES (symbolP, 0L);
2340 S_SET_DATA_TYPE (symbolP, T_NULL);
2341 S_SET_STORAGE_CLASS (symbolP, 0);
2342 S_SET_NUMBER_AUXILIARY (symbolP, 0);
2343 /* Additional information. */
2344 symbolP->sy_symbol.ost_flags = 0;
2345 /* Auxiliary entries. */
2346 memset ((char *) &symbolP->sy_symbol.ost_auxent[0], 0, AUXESZ);
2348 if (S_IS_STRING (symbolP))
2349 SF_SET_STRING (symbolP);
2350 if (!underscore && S_IS_LOCAL (symbolP))
2351 SF_SET_LOCAL (symbolP);
2354 /* Handle .ln directives. */
2357 obj_coff_ln (appline)
2362 if (! appline && def_symbol_in_progress != NULL)
2364 /* Wrong context. */
2365 as_warn (_(".ln pseudo-op inside .def/.endef: ignored."));
2366 demand_empty_rest_of_line ();
2370 l = get_absolute_expression ();
2371 c_line_new (0, frag_now_fix (), l, frag_now);
2374 new_logical_line ((char *) NULL, l - 1);
2384 listing_source_line ((unsigned int) l);
2389 demand_empty_rest_of_line ();
2392 /* Handle .def directives.
2394 One might ask : why can't we symbol_new if the symbol does not
2395 already exist and fill it with debug information. Because of
2396 the C_EFCN special symbol. It would clobber the value of the
2397 function symbol before we have a chance to notice that it is
2398 a C_EFCN. And a second reason is that the code is more clear this
2399 way. (at least I think it is :-). */
2401 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
2402 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
2403 *input_line_pointer == '\t') \
2404 input_line_pointer++;
2408 int what ATTRIBUTE_UNUSED;
2410 char name_end; /* Char after the end of name. */
2411 char *symbol_name; /* Name of the debug symbol. */
2412 char *symbol_name_copy; /* Temporary copy of the name. */
2413 unsigned int symbol_name_length;
2415 if (def_symbol_in_progress != NULL)
2417 as_warn (_(".def pseudo-op used inside of .def/.endef: ignored."));
2418 demand_empty_rest_of_line ();
2422 SKIP_WHITESPACES ();
2424 def_symbol_in_progress = (symbolS *) obstack_alloc (¬es, sizeof (*def_symbol_in_progress));
2425 memset (def_symbol_in_progress, 0, sizeof (*def_symbol_in_progress));
2427 symbol_name = input_line_pointer;
2428 name_end = get_symbol_end ();
2429 symbol_name_length = strlen (symbol_name);
2430 symbol_name_copy = xmalloc (symbol_name_length + 1);
2431 strcpy (symbol_name_copy, symbol_name);
2432 #ifdef tc_canonicalize_symbol_name
2433 symbol_name_copy = tc_canonicalize_symbol_name (symbol_name_copy);
2436 /* Initialize the new symbol. */
2437 #ifdef STRIP_UNDERSCORE
2438 S_SET_NAME (def_symbol_in_progress, (*symbol_name_copy == '_'
2439 ? symbol_name_copy + 1
2440 : symbol_name_copy));
2441 #else /* STRIP_UNDERSCORE */
2442 S_SET_NAME (def_symbol_in_progress, symbol_name_copy);
2443 #endif /* STRIP_UNDERSCORE */
2444 /* free(symbol_name_copy); */
2445 def_symbol_in_progress->sy_name_offset = (unsigned long) ~0;
2446 def_symbol_in_progress->sy_number = ~0;
2447 def_symbol_in_progress->sy_frag = &zero_address_frag;
2448 S_SET_VALUE (def_symbol_in_progress, 0);
2450 if (S_IS_STRING (def_symbol_in_progress))
2451 SF_SET_STRING (def_symbol_in_progress);
2453 *input_line_pointer = name_end;
2455 demand_empty_rest_of_line ();
2458 unsigned int dim_index;
2461 obj_coff_endef (ignore)
2462 int ignore ATTRIBUTE_UNUSED;
2464 symbolS *symbolP = 0;
2465 /* DIM BUG FIX sac@cygnus.com */
2467 if (def_symbol_in_progress == NULL)
2469 as_warn (_(".endef pseudo-op used outside of .def/.endef: ignored."));
2470 demand_empty_rest_of_line ();
2474 /* Set the section number according to storage class. */
2475 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))
2480 SF_SET_TAG (def_symbol_in_progress);
2481 /* Intentional fallthrough. */
2485 SF_SET_DEBUG (def_symbol_in_progress);
2486 S_SET_SEGMENT (def_symbol_in_progress, SEG_DEBUG);
2490 /* Do not emit this symbol. */
2491 SF_SET_LOCAL (def_symbol_in_progress);
2492 /* Intentional fallthrough. */
2495 /* Will need processing before writing. */
2496 SF_SET_PROCESS (def_symbol_in_progress);
2497 /* Intentional fallthrough. */
2500 S_SET_SEGMENT (def_symbol_in_progress, SEG_E0);
2502 if (strcmp (S_GET_NAME (def_symbol_in_progress), ".bf") == 0)
2504 if (function_lineoff < 0)
2505 fprintf (stderr, _("`.bf' symbol without preceding function\n"));
2507 SA_GET_SYM_LNNOPTR (last_line_symbol) = function_lineoff;
2509 SF_SET_PROCESS (last_line_symbol);
2510 SF_SET_ADJ_LNNOPTR (last_line_symbol);
2511 SF_SET_PROCESS (def_symbol_in_progress);
2512 function_lineoff = -1;
2515 /* Value is always set to . */
2516 def_symbol_in_progress->sy_frag = frag_now;
2517 S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
2522 #endif /* C_AUTOARG */
2532 SF_SET_DEBUG (def_symbol_in_progress);
2533 S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
2543 /* Valid but set somewhere else (s_comm, s_lcomm, colon). */
2549 as_warn (_("unexpected storage class %d"), S_GET_STORAGE_CLASS (def_symbol_in_progress));
2553 /* Now that we have built a debug symbol, try to find if we should
2554 merge with an existing symbol or not. If a symbol is C_EFCN or
2555 absolute_section or untagged SEG_DEBUG it never merges. We also
2556 don't merge labels, which are in a different namespace, nor
2557 symbols which have not yet been defined since they are typically
2558 unique, nor do we merge tags with non-tags. */
2560 /* Two cases for functions. Either debug followed by definition or
2561 definition followed by debug. For definition first, we will
2562 merge the debug symbol into the definition. For debug first, the
2563 lineno entry MUST point to the definition function or else it
2564 will point off into space when crawl_symbols() merges the debug
2565 symbol into the real symbol. Therefor, let's presume the debug
2566 symbol is a real function reference. */
2568 /* FIXME-SOON If for some reason the definition label/symbol is
2569 never seen, this will probably leave an undefined symbol at link
2572 if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN
2573 || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_LABEL
2574 || (S_GET_SEGMENT (def_symbol_in_progress) == SEG_DEBUG
2575 && !SF_GET_TAG (def_symbol_in_progress))
2576 || S_GET_SEGMENT (def_symbol_in_progress) == absolute_section
2577 || def_symbol_in_progress->sy_value.X_op != O_constant
2578 || (symbolP = symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP)) == NULL
2579 || (SF_GET_TAG (def_symbol_in_progress) != SF_GET_TAG (symbolP)))
2581 symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP,
2586 /* This symbol already exists, merge the newly created symbol
2587 into the old one. This is not mandatory. The linker can
2588 handle duplicate symbols correctly. But I guess that it save
2589 a *lot* of space if the assembly file defines a lot of
2592 /* The debug entry (def_symbol_in_progress) is merged into the
2593 previous definition. */
2595 c_symbol_merge (def_symbol_in_progress, symbolP);
2596 /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
2597 def_symbol_in_progress = symbolP;
2599 if (SF_GET_FUNCTION (def_symbol_in_progress)
2600 || SF_GET_TAG (def_symbol_in_progress)
2601 || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_STAT)
2603 /* For functions, and tags, and static symbols, the symbol
2604 *must* be where the debug symbol appears. Move the
2605 existing symbol to the current place. */
2606 /* If it already is at the end of the symbol list, do nothing. */
2607 if (def_symbol_in_progress != symbol_lastP)
2609 symbol_remove (def_symbol_in_progress, &symbol_rootP,
2611 symbol_append (def_symbol_in_progress, symbol_lastP,
2612 &symbol_rootP, &symbol_lastP);
2617 if (SF_GET_TAG (def_symbol_in_progress))
2621 oldtag = symbol_find_base (S_GET_NAME (def_symbol_in_progress),
2623 if (oldtag == NULL || ! SF_GET_TAG (oldtag))
2624 tag_insert (S_GET_NAME (def_symbol_in_progress),
2625 def_symbol_in_progress);
2628 if (SF_GET_FUNCTION (def_symbol_in_progress))
2630 know (sizeof (def_symbol_in_progress) <= sizeof (long));
2632 = c_line_new (def_symbol_in_progress, 0, 0, &zero_address_frag);
2634 SF_SET_PROCESS (def_symbol_in_progress);
2636 if (symbolP == NULL)
2638 /* That is, if this is the first time we've seen the
2640 symbol_table_insert (def_symbol_in_progress);
2644 def_symbol_in_progress = NULL;
2645 demand_empty_rest_of_line ();
2649 obj_coff_dim (ignore)
2650 int ignore ATTRIBUTE_UNUSED;
2654 if (def_symbol_in_progress == NULL)
2656 as_warn (_(".dim pseudo-op used outside of .def/.endef: ignored."));
2657 demand_empty_rest_of_line ();
2661 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2663 for (dim_index = 0; dim_index < DIMNUM; dim_index++)
2665 SKIP_WHITESPACES ();
2666 SA_SET_SYM_DIMEN (def_symbol_in_progress, dim_index,
2667 get_absolute_expression ());
2669 switch (*input_line_pointer)
2672 input_line_pointer++;
2676 as_warn (_("badly formed .dim directive ignored"));
2677 /* Intentional fallthrough. */
2686 demand_empty_rest_of_line ();
2690 obj_coff_line (ignore)
2691 int ignore ATTRIBUTE_UNUSED;
2696 if (def_symbol_in_progress == NULL)
2702 name = S_GET_NAME (def_symbol_in_progress);
2703 this_base = get_absolute_expression ();
2705 /* Only .bf symbols indicate the use of a new base line number; the
2706 line numbers associated with .ef, .bb, .eb are relative to the
2707 start of the containing function. */
2708 if (!strcmp (".bf", name))
2710 #if 0 /* XXX Can we ever have line numbers going backwards? */
2711 if (this_base > line_base)
2713 line_base = this_base;
2719 listing_source_line ((unsigned int) line_base);
2724 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2725 SA_SET_SYM_LNNO (def_symbol_in_progress, this_base);
2727 demand_empty_rest_of_line ();
2731 obj_coff_size (ignore)
2732 int ignore ATTRIBUTE_UNUSED;
2734 if (def_symbol_in_progress == NULL)
2736 as_warn (_(".size pseudo-op used outside of .def/.endef ignored."));
2737 demand_empty_rest_of_line ();
2741 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2742 SA_SET_SYM_SIZE (def_symbol_in_progress, get_absolute_expression ());
2743 demand_empty_rest_of_line ();
2747 obj_coff_scl (ignore)
2748 int ignore ATTRIBUTE_UNUSED;
2750 if (def_symbol_in_progress == NULL)
2752 as_warn (_(".scl pseudo-op used outside of .def/.endef ignored."));
2753 demand_empty_rest_of_line ();
2757 S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ());
2758 demand_empty_rest_of_line ();
2762 obj_coff_tag (ignore)
2763 int ignore ATTRIBUTE_UNUSED;
2768 if (def_symbol_in_progress == NULL)
2770 as_warn (_(".tag pseudo-op used outside of .def/.endef ignored."));
2771 demand_empty_rest_of_line ();
2775 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2776 symbol_name = input_line_pointer;
2777 name_end = get_symbol_end ();
2778 #ifdef tc_canonicalize_symbol_name
2779 symbol_name = tc_canonicalize_symbol_name (symbol_name);
2782 /* Assume that the symbol referred to by .tag is always defined.
2783 This was a bad assumption. I've added find_or_make. xoxorich. */
2784 SA_SET_SYM_TAGNDX (def_symbol_in_progress,
2785 (long) tag_find_or_make (symbol_name));
2786 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L)
2787 as_warn (_("tag not found for .tag %s"), symbol_name);
2789 SF_SET_TAGGED (def_symbol_in_progress);
2790 *input_line_pointer = name_end;
2792 demand_empty_rest_of_line ();
2796 obj_coff_type (ignore)
2797 int ignore ATTRIBUTE_UNUSED;
2799 if (def_symbol_in_progress == NULL)
2801 as_warn (_(".type pseudo-op used outside of .def/.endef ignored."));
2802 demand_empty_rest_of_line ();
2806 S_SET_DATA_TYPE (def_symbol_in_progress, get_absolute_expression ());
2808 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress)) &&
2809 S_GET_STORAGE_CLASS (def_symbol_in_progress) != C_TPDEF)
2810 SF_SET_FUNCTION (def_symbol_in_progress);
2812 demand_empty_rest_of_line ();
2816 obj_coff_val (ignore)
2817 int ignore ATTRIBUTE_UNUSED;
2819 if (def_symbol_in_progress == NULL)
2821 as_warn (_(".val pseudo-op used outside of .def/.endef ignored."));
2822 demand_empty_rest_of_line ();
2826 if (is_name_beginner (*input_line_pointer))
2828 char *symbol_name = input_line_pointer;
2829 char name_end = get_symbol_end ();
2831 #ifdef tc_canonicalize_symbol_name
2832 symbol_name = tc_canonicalize_symbol_name (symbol_name);
2835 if (!strcmp (symbol_name, "."))
2837 def_symbol_in_progress->sy_frag = frag_now;
2838 S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
2839 /* If the .val is != from the .def (e.g. statics). */
2841 else if (strcmp (S_GET_NAME (def_symbol_in_progress), symbol_name))
2843 def_symbol_in_progress->sy_value.X_op = O_symbol;
2844 def_symbol_in_progress->sy_value.X_add_symbol =
2845 symbol_find_or_make (symbol_name);
2846 def_symbol_in_progress->sy_value.X_op_symbol = NULL;
2847 def_symbol_in_progress->sy_value.X_add_number = 0;
2849 /* If the segment is undefined when the forward reference is
2850 resolved, then copy the segment id from the forward
2852 SF_SET_GET_SEGMENT (def_symbol_in_progress);
2854 /* FIXME: gcc can generate address expressions here in
2855 unusual cases (search for "obscure" in sdbout.c). We
2856 just ignore the offset here, thus generating incorrect
2857 debugging information. We ignore the rest of the line
2860 /* Otherwise, it is the name of a non debug symbol and
2861 its value will be calculated later. */
2862 *input_line_pointer = name_end;
2864 /* FIXME: this is to avoid an error message in the
2865 FIXME case mentioned just above. */
2866 while (! is_end_of_line[(unsigned char) *input_line_pointer])
2867 ++input_line_pointer;
2871 S_SET_VALUE (def_symbol_in_progress,
2872 (valueT) get_absolute_expression ());
2873 } /* if symbol based */
2875 demand_empty_rest_of_line ();
2880 /* Handle the .linkonce pseudo-op. This is parsed by s_linkonce in
2881 read.c, which then calls this object file format specific routine. */
2884 obj_coff_pe_handle_link_once (type)
2885 enum linkonce_type type;
2887 seg_info (now_seg)->scnhdr.s_flags |= IMAGE_SCN_LNK_COMDAT;
2889 /* We store the type in the seg_info structure, and use it to set up
2890 the auxiliary entry for the section symbol in c_section_symbol. */
2891 seg_info (now_seg)->linkonce = type;
2897 coff_obj_read_begin_hook ()
2899 /* These had better be the same. Usually 18 bytes. */
2901 know (sizeof (SYMENT) == sizeof (AUXENT));
2902 know (SYMESZ == AUXESZ);
2907 /* This function runs through the symbol table and puts all the
2908 externals onto another chain. */
2910 /* The chain of globals. */
2911 symbolS *symbol_globalP;
2912 symbolS *symbol_global_lastP;
2914 /* The chain of externals. */
2915 symbolS *symbol_externP;
2916 symbolS *symbol_extern_lastP;
2919 symbolS *last_functionP;
2920 static symbolS *last_bfP;
2927 unsigned int symbol_number = 0;
2928 unsigned int last_file_symno = 0;
2930 struct filename_list *filename_list_scan = filename_list_head;
2932 for (symbolP = symbol_rootP;
2934 symbolP = symbolP ? symbol_next (symbolP) : symbol_rootP)
2936 if (symbolP->sy_mri_common)
2938 if (S_GET_STORAGE_CLASS (symbolP) == C_EXT
2940 || S_GET_STORAGE_CLASS (symbolP) == C_NT_WEAK
2942 || S_GET_STORAGE_CLASS (symbolP) == C_WEAKEXT)
2943 as_bad (_("%s: global symbols not supported in common sections"),
2944 S_GET_NAME (symbolP));
2945 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2949 if (!SF_GET_DEBUG (symbolP))
2951 /* Debug symbols do not need all this rubbish. */
2952 symbolS *real_symbolP;
2954 /* L* and C_EFCN symbols never merge. */
2955 if (!SF_GET_LOCAL (symbolP)
2956 && !SF_GET_STATICS (symbolP)
2957 && S_GET_STORAGE_CLASS (symbolP) != C_LABEL
2958 && symbolP->sy_value.X_op == O_constant
2959 && (real_symbolP = symbol_find_base (S_GET_NAME (symbolP), DO_NOT_STRIP))
2960 && real_symbolP != symbolP)
2962 /* FIXME-SOON: where do dups come from?
2963 Maybe tag references before definitions? xoxorich. */
2964 /* Move the debug data from the debug symbol to the
2965 real symbol. Do NOT do the oposite (i.e. move from
2966 real symbol to debug symbol and remove real symbol from the
2967 list.) Because some pointers refer to the real symbol
2968 whereas no pointers refer to the debug symbol. */
2969 c_symbol_merge (symbolP, real_symbolP);
2970 /* Replace the current symbol by the real one. */
2971 /* The symbols will never be the last or the first
2972 because : 1st symbol is .file and 3 last symbols are
2973 .text, .data, .bss. */
2974 symbol_remove (real_symbolP, &symbol_rootP, &symbol_lastP);
2975 symbol_insert (real_symbolP, symbolP, &symbol_rootP, &symbol_lastP);
2976 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2977 symbolP = real_symbolP;
2980 if (flag_readonly_data_in_text && (S_GET_SEGMENT (symbolP) == SEG_E1))
2981 S_SET_SEGMENT (symbolP, SEG_E0);
2983 resolve_symbol_value (symbolP);
2985 if (S_GET_STORAGE_CLASS (symbolP) == C_NULL)
2987 if (!S_IS_DEFINED (symbolP) && !SF_GET_LOCAL (symbolP))
2989 S_SET_EXTERNAL (symbolP);
2992 else if (S_GET_SEGMENT (symbolP) == SEG_E0)
2993 S_SET_STORAGE_CLASS (symbolP, C_LABEL);
2996 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);
3010 symbolS *begin_symbolP;
3012 begin_symbolP = *(symbolS **) stack_pop (block_stack);
3013 if (begin_symbolP == (symbolS *) 0)
3014 as_warn (_("mismatched .eb"));
3016 SA_SET_SYM_ENDNDX (begin_symbolP, symbol_number + 2);
3019 /* If we are able to identify the type of a function, and we
3020 are out of a function (last_functionP == 0) then, the
3021 function symbol will be associated with an auxiliary
3023 if (last_functionP == (symbolS *) 0 &&
3024 SF_GET_FUNCTION (symbolP))
3026 last_functionP = symbolP;
3028 if (S_GET_NUMBER_AUXILIARY (symbolP) < 1)
3029 S_SET_NUMBER_AUXILIARY (symbolP, 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;
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. */
3151 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3152 symbol_clear_list_pointers (symbolP);
3153 symbol_append (symbolP, symbol_global_lastP, &symbol_globalP,
3154 &symbol_global_lastP);
3159 if (SF_GET_STRING (symbolP))
3161 symbolP->sy_name_offset = string_byte_count;
3162 string_byte_count += strlen (S_GET_NAME (symbolP)) + 1;
3166 symbolP->sy_name_offset = 0;
3169 symbolP->sy_number = symbol_number;
3170 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (symbolP);
3174 return symbol_number;
3178 glue_symbols (head, tail)
3182 unsigned int symbol_number = 0;
3184 while (*head != NULL)
3186 symbolS *tmp = *head;
3189 symbol_remove (tmp, head, tail);
3190 symbol_append (tmp, symbol_lastP, &symbol_rootP, &symbol_lastP);
3193 if (SF_GET_STRING (tmp))
3195 tmp->sy_name_offset = string_byte_count;
3196 string_byte_count += strlen (S_GET_NAME (tmp)) + 1;
3200 /* Fix "long" names. */
3201 tmp->sy_name_offset = 0;
3204 tmp->sy_number = symbol_number;
3205 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (tmp);
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;
3236 crawl_symbols (h, abfd)
3238 bfd *abfd ATTRIBUTE_UNUSED;
3242 /* Initialize the stack used to keep track of the matching .bb .be. */
3244 block_stack = stack_init (512, sizeof (symbolS *));
3246 /* The symbol list should be ordered according to the following sequence
3249 . debug entries for functions
3250 . fake symbols for the sections, including .text .data and .bss
3253 But this is not mandatory. The only important point is to put the
3254 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)
3259 c_dot_file_symbol ("fake");
3261 /* Build up static symbols for the sections, they are filled in later. */
3263 for (i = SEG_E0; i < SEG_LAST; i++)
3264 if (segment_info[i].scnhdr.s_name[0])
3265 segment_info[i].dot = c_section_symbol ((char *) segment_info[i].name,
3268 /* Take all the externals out and put them into another chain. */
3269 H_SET_SYMBOL_TABLE_SIZE (h, yank_symbols ());
3270 /* Take the externals and glue them onto the end. */
3271 H_SET_SYMBOL_TABLE_SIZE (h,
3272 (H_GET_SYMBOL_COUNT (h)
3273 + glue_symbols (&symbol_globalP,
3274 &symbol_global_lastP)
3275 + glue_symbols (&symbol_externP,
3276 &symbol_extern_lastP)));
3278 H_SET_SYMBOL_TABLE_SIZE (h, tie_tags ());
3279 know (symbol_globalP == NULL);
3280 know (symbol_global_lastP == NULL);
3281 know (symbol_externP == NULL);
3282 know (symbol_extern_lastP == NULL);
3285 /* Find strings by crawling along symbol table chain. */
3292 struct filename_list *filename_list_scan = filename_list_head;
3294 /* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK. */
3295 md_number_to_chars (where, (valueT) string_byte_count, 4);
3298 #ifdef COFF_LONG_SECTION_NAMES
3299 /* Support long section names as found in PE. This code must
3300 coordinate with that in coff_header_append and write_object_file. */
3304 for (i = SEG_E0; i < SEG_LAST; i++)
3306 if (segment_info[i].scnhdr.s_name[0]
3307 && strlen (segment_info[i].name) > SCNNMLEN)
3311 size = strlen (segment_info[i].name) + 1;
3312 memcpy (where, segment_info[i].name, size);
3317 #endif /* COFF_LONG_SECTION_NAMES */
3319 for (symbolP = symbol_rootP;
3321 symbolP = symbol_next (symbolP))
3325 if (SF_GET_STRING (symbolP))
3327 size = strlen (S_GET_NAME (symbolP)) + 1;
3328 memcpy (where, S_GET_NAME (symbolP), size);
3331 if (S_GET_STORAGE_CLASS (symbolP) == C_FILE
3332 && SA_GET_FILE_FNAME_ZEROS (symbolP) == 0
3333 && SA_GET_FILE_FNAME_OFFSET (symbolP) != 0)
3335 size = strlen (filename_list_scan->filename) + 1;
3336 memcpy (where, filename_list_scan->filename, size);
3337 filename_list_scan = filename_list_scan ->next;
3344 do_linenos_for (abfd, h, file_cursor)
3347 unsigned long *file_cursor;
3350 unsigned long start = *file_cursor;
3352 for (idx = SEG_E0; idx < SEG_LAST; idx++)
3354 segment_info_type *s = segment_info + idx;
3356 if (s->scnhdr.s_nlnno != 0)
3358 struct lineno_list *line_ptr;
3360 struct external_lineno *buffer =
3361 (struct external_lineno *) xmalloc (s->scnhdr.s_nlnno * LINESZ);
3363 struct external_lineno *dst = buffer;
3365 /* Run through the table we've built and turn it into its external
3366 form, take this chance to remove duplicates. */
3368 for (line_ptr = s->lineno_list_head;
3369 line_ptr != (struct lineno_list *) NULL;
3370 line_ptr = line_ptr->next)
3372 if (line_ptr->line.l_lnno == 0)
3374 /* Turn a pointer to a symbol into the symbols' index,
3375 provided that it has been initialised. */
3376 if (line_ptr->line.l_addr.l_symndx)
3377 line_ptr->line.l_addr.l_symndx =
3378 ((symbolS *) line_ptr->line.l_addr.l_symndx)->sy_number;
3381 line_ptr->line.l_addr.l_paddr += ((struct frag *) (line_ptr->frag))->fr_address;
3383 (void) bfd_coff_swap_lineno_out (abfd, &(line_ptr->line), dst);
3387 s->scnhdr.s_lnnoptr = *file_cursor;
3389 bfd_bwrite (buffer, (bfd_size_type) s->scnhdr.s_nlnno * LINESZ, abfd);
3392 *file_cursor += s->scnhdr.s_nlnno * LINESZ;
3396 H_SET_LINENO_SIZE (h, *file_cursor - start);
3399 /* Now we run through the list of frag chains in a segment and
3400 make all the subsegment frags appear at the end of the
3401 list, as if the seg 0 was extra long. */
3408 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3410 frchainS *head = segment_info[i].frchainP;
3412 fragS *prev_frag = &dummy;
3414 while (head && head->frch_seg == i)
3416 prev_frag->fr_next = head->frch_root;
3417 prev_frag = head->frch_last;
3418 head = head->frch_next;
3420 prev_frag->fr_next = 0;
3424 unsigned long machine;
3427 #ifndef SUB_SEGMENT_ALIGN
3429 /* The last subsegment gets an aligment corresponding to the alignment
3430 of the section. This allows proper nop-filling at the end of
3431 code-bearing sections. */
3432 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
3433 (!(FRCHAIN)->frch_next || (FRCHAIN)->frch_next->frch_seg != (SEG) \
3434 ? get_recorded_alignment (SEG) : 0)
3436 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 1
3441 write_object_file ()
3445 struct frchain *frchain_ptr;
3447 object_headers headers;
3448 unsigned long file_cursor;
3451 abfd = bfd_openw (out_file_name, TARGET_FORMAT);
3455 as_perror (_("FATAL: Can't create %s"), out_file_name);
3456 exit (EXIT_FAILURE);
3458 bfd_set_format (abfd, bfd_object);
3459 bfd_set_arch_mach (abfd, BFD_ARCH, machine);
3461 string_byte_count = 4;
3463 /* Run through all the sub-segments and align them up. Also
3464 close any open frags. We tack a .fill onto the end of the
3465 frag chain so that any .align's size can be worked by looking
3466 at the next frag. */
3467 for (frchain_ptr = frchain_root;
3468 frchain_ptr != (struct frchain *) NULL;
3469 frchain_ptr = frchain_ptr->frch_next)
3473 subseg_set (frchain_ptr->frch_seg, frchain_ptr->frch_subseg);
3475 alignment = SUB_SEGMENT_ALIGN (now_seg, frchain_ptr);
3478 md_do_align (alignment, (char *) NULL, 0, 0, alignment_done);
3480 if (subseg_text_p (now_seg))
3481 frag_align_code (alignment, 0);
3483 frag_align (alignment, 0, 0);
3489 frag_wane (frag_now);
3490 frag_now->fr_fix = 0;
3491 know (frag_now->fr_next == NULL);
3496 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3497 relax_segment (segment_info[i].frchainP->frch_root, i);
3499 /* Relaxation has completed. Freeze all syms. */
3502 H_SET_NUMBER_OF_SECTIONS (&headers, 0);
3504 /* Find out how big the sections are, and set the addresses. */
3506 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3510 segment_info[i].scnhdr.s_paddr = addr;
3511 segment_info[i].scnhdr.s_vaddr = addr;
3513 if (segment_info[i].scnhdr.s_name[0])
3515 H_SET_NUMBER_OF_SECTIONS (&headers,
3516 H_GET_NUMBER_OF_SECTIONS (&headers) + 1);
3518 #ifdef COFF_LONG_SECTION_NAMES
3519 /* Support long section names as found in PE. This code
3520 must coordinate with that in coff_header_append and
3525 len = strlen (segment_info[i].name);
3527 string_byte_count += len + 1;
3529 #endif /* COFF_LONG_SECTION_NAMES */
3532 size = size_section (abfd, (unsigned int) i);
3535 /* I think the section alignment is only used on the i960; the
3536 i960 needs it, and it should do no harm on other targets. */
3537 #ifdef ALIGNMENT_IN_S_FLAGS
3538 segment_info[i].scnhdr.s_flags |= (section_alignment[i] & 0xF) << 8;
3540 segment_info[i].scnhdr.s_align = 1 << section_alignment[i];
3544 H_SET_TEXT_SIZE (&headers, size);
3545 else if (i == SEG_E1)
3546 H_SET_DATA_SIZE (&headers, size);
3547 else if (i == SEG_E2)
3548 H_SET_BSS_SIZE (&headers, size);
3551 /* Turn the gas native symbol table shape into a coff symbol table. */
3552 crawl_symbols (&headers, abfd);
3554 if (string_byte_count == 4)
3555 string_byte_count = 0;
3557 H_SET_STRING_SIZE (&headers, string_byte_count);
3563 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3565 fixup_mdeps (segment_info[i].frchainP->frch_root, &headers, i);
3566 fixup_segment (&segment_info[i], i);
3569 /* Look for ".stab" segments and fill in their initial symbols
3571 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3573 name = segment_info[i].name;
3576 && strncmp (".stab", name, 5) == 0
3577 && strncmp (".stabstr", name, 8) != 0)
3578 adjust_stab_section (abfd, i);
3581 file_cursor = H_GET_TEXT_FILE_OFFSET (&headers);
3583 bfd_seek (abfd, (file_ptr) file_cursor, 0);
3585 /* Plant the data. */
3586 fill_section (abfd, &headers, &file_cursor);
3588 do_relocs_for (abfd, &headers, &file_cursor);
3590 do_linenos_for (abfd, &headers, &file_cursor);
3592 H_SET_FILE_MAGIC_NUMBER (&headers, COFF_MAGIC);
3593 #ifndef OBJ_COFF_OMIT_TIMESTAMP
3594 H_SET_TIME_STAMP (&headers, (long)time((time_t *)0));
3596 H_SET_TIME_STAMP (&headers, 0);
3598 #ifdef TC_COFF_SET_MACHINE
3599 TC_COFF_SET_MACHINE (&headers);
3603 #define COFF_FLAGS 0
3606 #ifdef KEEP_RELOC_INFO
3607 H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
3608 COFF_FLAGS | coff_flags));
3610 H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
3611 (H_GET_RELOCATION_SIZE(&headers) ? 0 : F_RELFLG) |
3612 COFF_FLAGS | coff_flags));
3616 unsigned int symtable_size = H_GET_SYMBOL_TABLE_SIZE (&headers);
3617 char *buffer1 = xmalloc (symtable_size + string_byte_count + 1);
3619 H_SET_SYMBOL_TABLE_POINTER (&headers, bfd_tell (abfd));
3620 w_symbols (abfd, buffer1, symbol_rootP);
3621 if (string_byte_count > 0)
3622 w_strings (buffer1 + symtable_size);
3623 bfd_bwrite (buffer1, (bfd_size_type) symtable_size + string_byte_count,
3628 coff_header_append (abfd, &headers);
3630 /* Recent changes to write need this, but where it should
3631 go is up to Ken.. */
3632 if (!bfd_close_all_done (abfd))
3633 as_fatal (_("Can't close %s: %s"), out_file_name,
3634 bfd_errmsg (bfd_get_error ()));
3637 extern bfd *stdoutput;
3644 /* Add a new segment. This is called from subseg_new via the
3645 obj_new_segment macro. */
3648 obj_coff_add_segment (name)
3653 #ifndef COFF_LONG_SECTION_NAMES
3654 char buf[SCNNMLEN + 1];
3656 strncpy (buf, name, SCNNMLEN);
3657 buf[SCNNMLEN] = '\0';
3661 for (i = SEG_E0; i < SEG_LAST && segment_info[i].scnhdr.s_name[0]; i++)
3662 if (strcmp (name, segment_info[i].name) == 0)
3667 as_bad (_("Too many new sections; can't add \"%s\""), name);
3671 /* Add a new section. */
3672 strncpy (segment_info[i].scnhdr.s_name, name,
3673 sizeof (segment_info[i].scnhdr.s_name));
3674 segment_info[i].scnhdr.s_flags = STYP_REG;
3675 segment_info[i].name = xstrdup (name);
3680 /* Implement the .section pseudo op:
3681 .section name {, "flags"}
3683 | +--- optional flags: 'b' for bss
3685 +-- section name 'l' for lib
3689 'd' (apparently m88k for data)
3691 'r' for read-only data
3692 But if the argument is not a quoted string, treat it as a
3693 subsegment number. */
3696 obj_coff_section (ignore)
3697 int ignore ATTRIBUTE_UNUSED;
3699 /* Strip out the section name. */
3700 char *section_name, *name;
3713 else if (type == 'D')
3715 segment_info[now_seg].scnhdr.s_flags |= flags;
3720 section_name = input_line_pointer;
3721 c = get_symbol_end ();
3723 name = xmalloc (input_line_pointer - section_name + 1);
3724 strcpy (name, section_name);
3726 *input_line_pointer = c;
3732 if (*input_line_pointer == ',')
3734 ++input_line_pointer;
3737 if (*input_line_pointer != '"')
3738 exp = get_absolute_expression ();
3741 ++input_line_pointer;
3742 while (*input_line_pointer != '"'
3743 && ! is_end_of_line[(unsigned char) *input_line_pointer])
3745 switch (*input_line_pointer)
3747 case 'b': flags |= STYP_BSS; break;
3748 case 'i': flags |= STYP_INFO; break;
3749 case 'l': flags |= STYP_LIB; break;
3750 case 'n': flags |= STYP_NOLOAD; break;
3751 case 'o': flags |= STYP_OVER; break;
3753 case 'w': flags |= STYP_DATA; break;
3754 case 'x': flags |= STYP_TEXT; break;
3755 case 'r': flags |= STYP_LIT; break;
3757 as_warn(_("unknown section attribute '%c'"),
3758 *input_line_pointer);
3761 ++input_line_pointer;
3763 if (*input_line_pointer == '"')
3764 ++input_line_pointer;
3768 subseg_new (name, (subsegT) exp);
3770 segment_info[now_seg].scnhdr.s_flags |= flags;
3772 demand_empty_rest_of_line ();
3776 obj_coff_text (ignore)
3777 int ignore ATTRIBUTE_UNUSED;
3779 subseg_new (".text", get_absolute_expression ());
3783 obj_coff_data (ignore)
3784 int ignore ATTRIBUTE_UNUSED;
3786 if (flag_readonly_data_in_text)
3787 subseg_new (".text", get_absolute_expression () + 1000);
3789 subseg_new (".data", get_absolute_expression ());
3793 obj_coff_ident (ignore)
3794 int ignore ATTRIBUTE_UNUSED;
3796 segT current_seg = now_seg; /* Save current seg. */
3797 subsegT current_subseg = now_subseg;
3799 subseg_new (".comment", 0); /* .comment seg. */
3800 stringer (1); /* Read string. */
3801 subseg_set (current_seg, current_subseg); /* Restore current seg. */
3805 c_symbol_merge (debug, normal)
3809 S_SET_DATA_TYPE (normal, S_GET_DATA_TYPE (debug));
3810 S_SET_STORAGE_CLASS (normal, S_GET_STORAGE_CLASS (debug));
3812 if (S_GET_NUMBER_AUXILIARY (debug) > S_GET_NUMBER_AUXILIARY (normal))
3813 S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));
3815 if (S_GET_NUMBER_AUXILIARY (debug) > 0)
3816 memcpy ((char *) &normal->sy_symbol.ost_auxent[0],
3817 (char *) &debug->sy_symbol.ost_auxent[0],
3818 (unsigned int) (S_GET_NUMBER_AUXILIARY (debug) * AUXESZ));
3820 /* Move the debug flags. */
3821 SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
3825 c_line_new (symbol, paddr, line_number, frag)
3831 struct lineno_list *new_line =
3832 (struct lineno_list *) xmalloc (sizeof (struct lineno_list));
3834 segment_info_type *s = segment_info + now_seg;
3835 new_line->line.l_lnno = line_number;
3837 if (line_number == 0)
3839 last_line_symbol = symbol;
3840 new_line->line.l_addr.l_symndx = (long) symbol;
3844 new_line->line.l_addr.l_paddr = paddr;
3847 new_line->frag = (char *) frag;
3848 new_line->next = (struct lineno_list *) NULL;
3850 if (s->lineno_list_head == (struct lineno_list *) NULL)
3851 s->lineno_list_head = new_line;
3853 s->lineno_list_tail->next = new_line;
3855 s->lineno_list_tail = new_line;
3856 return LINESZ * s->scnhdr.s_nlnno++;
3860 c_dot_file_symbol (filename)
3865 symbolP = symbol_new (".file",
3868 &zero_address_frag);
3870 S_SET_STORAGE_CLASS (symbolP, C_FILE);
3871 S_SET_NUMBER_AUXILIARY (symbolP, 1);
3873 if (strlen (filename) > FILNMLEN)
3875 /* Filename is too long to fit into an auxent,
3876 we stick it into the string table instead. We keep
3877 a linked list of the filenames we find so we can emit
3879 struct filename_list *f = ((struct filename_list *)
3880 xmalloc (sizeof (struct filename_list)));
3882 f->filename = filename;
3885 SA_SET_FILE_FNAME_ZEROS (symbolP, 0);
3886 SA_SET_FILE_FNAME_OFFSET (symbolP, 1);
3888 if (filename_list_tail)
3889 filename_list_tail->next = f;
3891 filename_list_head = f;
3892 filename_list_tail = f;
3896 SA_SET_FILE_FNAME (symbolP, filename);
3902 listing_source_file (filename);
3905 SF_SET_DEBUG (symbolP);
3906 S_SET_VALUE (symbolP, (valueT) previous_file_symbol);
3908 previous_file_symbol = symbolP;
3910 /* Make sure that the symbol is first on the symbol chain. */
3911 if (symbol_rootP != symbolP)
3913 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3914 symbol_insert (symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
3918 /* Build a 'section static' symbol. */
3921 c_section_symbol (name, idx)
3927 symbolP = symbol_find_base (name, DO_NOT_STRIP);
3928 if (symbolP == NULL)
3929 symbolP = symbol_new (name, idx, 0, &zero_address_frag);
3932 /* Mmmm. I just love violating interfaces. Makes me feel...dirty. */
3933 S_SET_SEGMENT (symbolP, idx);
3934 symbolP->sy_frag = &zero_address_frag;
3937 S_SET_STORAGE_CLASS (symbolP, C_STAT);
3938 S_SET_NUMBER_AUXILIARY (symbolP, 1);
3940 SF_SET_STATICS (symbolP);
3943 /* manfred@s-direktnet.de: section symbols *must* have the LOCAL bit cleared,
3944 which is set by the new definition of LOCAL_LABEL in tc-m68k.h. */
3945 SF_CLEAR_LOCAL (symbolP);
3948 /* If the .linkonce pseudo-op was used for this section, we must
3949 store the information in the auxiliary entry for the section
3951 if (segment_info[idx].linkonce != LINKONCE_UNSET)
3955 switch (segment_info[idx].linkonce)
3959 case LINKONCE_DISCARD:
3960 type = IMAGE_COMDAT_SELECT_ANY;
3962 case LINKONCE_ONE_ONLY:
3963 type = IMAGE_COMDAT_SELECT_NODUPLICATES;
3965 case LINKONCE_SAME_SIZE:
3966 type = IMAGE_COMDAT_SELECT_SAME_SIZE;
3968 case LINKONCE_SAME_CONTENTS:
3969 type = IMAGE_COMDAT_SELECT_EXACT_MATCH;
3973 SYM_AUXENT (symbolP)->x_scn.x_comdat = type;
3981 w_symbols (abfd, where, symbol_rootP)
3984 symbolS * symbol_rootP;
3989 /* First fill in those values we have only just worked out. */
3990 for (i = SEG_E0; i < SEG_LAST; i++)
3992 symbolP = segment_info[i].dot;
3995 SA_SET_SCN_SCNLEN (symbolP, segment_info[i].scnhdr.s_size);
3996 SA_SET_SCN_NRELOC (symbolP, segment_info[i].scnhdr.s_nreloc);
3997 SA_SET_SCN_NLINNO (symbolP, segment_info[i].scnhdr.s_nlnno);
4001 /* Emit all symbols left in the symbol chain. */
4002 for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
4004 /* Used to save the offset of the name. It is used to point
4005 to the string in memory but must be a file offset. */
4008 /* We can't fix the lnnoptr field in yank_symbols with the other
4009 adjustments, because we have to wait until we know where they
4011 if (SF_GET_ADJ_LNNOPTR (symbolP))
4012 SA_GET_SYM_LNNOPTR (symbolP) +=
4013 segment_info[S_GET_SEGMENT (symbolP)].scnhdr.s_lnnoptr;
4015 tc_coff_symbol_emit_hook (symbolP);
4017 temp = S_GET_NAME (symbolP);
4018 if (SF_GET_STRING (symbolP))
4020 S_SET_OFFSET (symbolP, symbolP->sy_name_offset);
4021 S_SET_ZEROES (symbolP, 0);
4025 memset (symbolP->sy_symbol.ost_entry.n_name, 0, SYMNMLEN);
4026 strncpy (symbolP->sy_symbol.ost_entry.n_name, temp, SYMNMLEN);
4028 where = symbol_to_chars (abfd, where, symbolP);
4029 S_SET_NAME (symbolP, temp);
4034 obj_coff_lcomm (ignore)
4035 int ignore ATTRIBUTE_UNUSED;
4047 name = input_line_pointer;
4049 c = get_symbol_end ();
4050 p = input_line_pointer;
4053 if (*input_line_pointer != ',')
4055 as_bad (_("Expected comma after name"));
4056 ignore_rest_of_line ();
4059 if (*input_line_pointer == '\n')
4061 as_bad (_("Missing size expression"));
4064 input_line_pointer++;
4065 if ((temp = get_absolute_expression ()) < 0)
4067 as_warn (_("lcomm length (%d.) <0! Ignored."), temp);
4068 ignore_rest_of_line ();
4073 symbolP = symbol_find_or_make (name);
4075 if (S_GET_SEGMENT (symbolP) == SEG_UNKNOWN &&
4076 S_GET_VALUE (symbolP) == 0)
4081 segT current_seg = now_seg; /* Save current seg. */
4082 subsegT current_subseg = now_subseg;
4084 subseg_set (SEG_E2, 1);
4085 symbolP->sy_frag = frag_now;
4086 p = frag_var(rs_org, 1, 1, (relax_substateT)0, symbolP,
4087 (offsetT) temp, (char *) 0);
4089 subseg_set (current_seg, current_subseg); /* Restore current seg. */
4090 S_SET_SEGMENT (symbolP, SEG_E2);
4091 S_SET_STORAGE_CLASS (symbolP, C_STAT);
4095 as_bad (_("Symbol %s already defined"), name);
4097 demand_empty_rest_of_line ();
4102 fixup_mdeps (frags, h, this_segment)
4107 subseg_change (this_segment, 0);
4111 switch (frags->fr_type)
4118 HANDLE_ALIGN (frags);
4120 frags->fr_type = rs_fill;
4122 ((frags->fr_next->fr_address - frags->fr_address - frags->fr_fix)
4125 case rs_machine_dependent:
4126 md_convert_frag (h, this_segment, frags);
4132 frags = frags->fr_next;
4138 #ifndef TC_FORCE_RELOCATION
4139 #define TC_FORCE_RELOCATION(fix) 0
4143 fixup_segment (segP, this_segment_type)
4144 segment_info_type * segP;
4145 segT this_segment_type;
4148 symbolS *add_symbolP;
4149 symbolS *sub_symbolP;
4156 segT add_symbol_segment = absolute_section;
4158 for (fixP = segP->fix_root; fixP; fixP = fixP->fx_next)
4160 fragP = fixP->fx_frag;
4162 where = fixP->fx_where;
4163 place = fragP->fr_literal + where;
4164 size = fixP->fx_size;
4165 add_symbolP = fixP->fx_addsy;
4166 sub_symbolP = fixP->fx_subsy;
4167 add_number = fixP->fx_offset;
4168 pcrel = fixP->fx_pcrel;
4170 /* We want function-relative stabs to work on systems which
4171 may use a relaxing linker; thus we must handle the sym1-sym2
4172 fixups function-relative stabs generates.
4174 Of course, if you actually enable relaxing in the linker, the
4175 line and block scoping information is going to be incorrect
4176 in some cases. The only way to really fix this is to support
4177 a reloc involving the difference of two symbols. */
4179 && (!sub_symbolP || pcrel))
4183 if (fixP->fx_tcbit && SF_GET_CALLNAME (add_symbolP))
4185 /* Relocation should be done via the associated 'bal' entry
4188 if (!SF_GET_BALNAME (tc_get_bal_of_call (add_symbolP)))
4190 as_bad_where (fixP->fx_file, fixP->fx_line,
4191 _("No 'bal' entry point for leafproc %s"),
4192 S_GET_NAME (add_symbolP));
4195 fixP->fx_addsy = add_symbolP = tc_get_bal_of_call (add_symbolP);
4199 /* Make sure the symbols have been resolved; this may not have
4200 happened if these are expression symbols. */
4201 if (add_symbolP != NULL && ! add_symbolP->sy_resolved)
4202 resolve_symbol_value (add_symbolP);
4204 if (add_symbolP != NULL)
4206 /* If this fixup is against a symbol which has been equated
4207 to another symbol, convert it to the other symbol. */
4208 if (add_symbolP->sy_value.X_op == O_symbol
4209 && (! S_IS_DEFINED (add_symbolP)
4210 || S_IS_COMMON (add_symbolP)))
4212 while (add_symbolP->sy_value.X_op == O_symbol
4213 && (! S_IS_DEFINED (add_symbolP)
4214 || S_IS_COMMON (add_symbolP)))
4218 /* We must avoid looping, as that can occur with a
4219 badly written program. */
4220 n = add_symbolP->sy_value.X_add_symbol;
4221 if (n == add_symbolP)
4223 add_number += add_symbolP->sy_value.X_add_number;
4226 fixP->fx_addsy = add_symbolP;
4227 fixP->fx_offset = add_number;
4231 if (sub_symbolP != NULL && ! sub_symbolP->sy_resolved)
4232 resolve_symbol_value (sub_symbolP);
4234 if (add_symbolP != NULL
4235 && add_symbolP->sy_mri_common)
4237 know (add_symbolP->sy_value.X_op == O_symbol);
4238 add_number += S_GET_VALUE (add_symbolP);
4239 fixP->fx_offset = add_number;
4240 add_symbolP = fixP->fx_addsy = add_symbolP->sy_value.X_add_symbol;
4244 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
4248 if (add_symbolP == NULL || add_symbol_segment == absolute_section)
4250 if (add_symbolP != NULL)
4252 add_number += S_GET_VALUE (add_symbolP);
4254 fixP->fx_addsy = NULL;
4257 /* It's just -sym. */
4258 if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
4260 add_number -= S_GET_VALUE (sub_symbolP);
4267 as_bad_where (fixP->fx_file, fixP->fx_line,
4268 _("Negative of non-absolute symbol %s"),
4269 S_GET_NAME (sub_symbolP));
4271 add_number -= S_GET_VALUE (sub_symbolP);
4272 } /* not absolute */
4274 /* if sub_symbol is in the same segment that add_symbol
4275 and add_symbol is either in DATA, TEXT, BSS or ABSOLUTE. */
4277 else if (S_GET_SEGMENT (sub_symbolP) == add_symbol_segment
4278 && SEG_NORMAL (add_symbol_segment))
4280 /* Difference of 2 symbols from same segment. Can't
4281 make difference of 2 undefineds: 'value' means
4282 something different for N_UNDF. */
4284 /* Makes no sense to use the difference of 2 arbitrary symbols
4285 as the target of a call instruction. */
4287 as_bad_where (fixP->fx_file, fixP->fx_line,
4288 _("callj to difference of 2 symbols"));
4289 #endif /* TC_I960 */
4290 add_number += S_GET_VALUE (add_symbolP) -
4291 S_GET_VALUE (sub_symbolP);
4294 if (!TC_FORCE_RELOCATION (fixP))
4296 fixP->fx_addsy = NULL;
4297 fixP->fx_subsy = NULL;
4299 #ifdef TC_M68K /* is this right? */
4307 /* Different segments in subtraction. */
4308 know (!(S_IS_EXTERNAL (sub_symbolP) && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
4310 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
4311 add_number -= S_GET_VALUE (sub_symbolP);
4314 else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
4315 #if 0 /* Okay for 68k, at least... */
4320 /* Make it pc-relative. */
4321 add_number += (md_pcrel_from (fixP)
4322 - S_GET_VALUE (sub_symbolP));
4331 as_bad_where (fixP->fx_file, fixP->fx_line,
4332 _("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %ld."),
4333 segment_name (S_GET_SEGMENT (sub_symbolP)),
4334 S_GET_NAME (sub_symbolP),
4335 (long) (fragP->fr_address + where));
4342 if (add_symbol_segment == this_segment_type && pcrel)
4344 /* This fixup was made when the symbol's segment was
4345 SEG_UNKNOWN, but it is now in the local segment.
4346 So we know how to do the address without relocation. */
4348 /* reloc_callj() may replace a 'call' with a 'calls' or a 'bal',
4349 in which cases it modifies *fixP as appropriate. In the case
4350 of a 'calls', no further work is required, and *fixP has been
4351 set up to make the rest of the code below a no-op. */
4353 #endif /* TC_I960 */
4355 add_number += S_GET_VALUE (add_symbolP);
4356 add_number -= md_pcrel_from (fixP);
4359 add_number -= segP->scnhdr.s_vaddr;
4360 if defined (TC_I386) || defined (TE_LYNX). I now
4361 think that was an error propagated from the case when
4362 we are going to emit the relocation. If we are not
4363 going to emit the relocation, then we just want to
4364 set add_number to the difference between the symbols.
4365 This is a case that would only arise when there is a
4366 PC relative reference from a section other than .text
4367 to a symbol defined in the same section, and the
4368 reference is not relaxed. Since jump instructions on
4369 the i386 are relaxed, this could only arise with a
4370 call instruction. */
4372 pcrel = 0; /* Lie. Don't want further pcrel processing. */
4373 if (!TC_FORCE_RELOCATION (fixP))
4375 fixP->fx_addsy = NULL;
4381 switch (add_symbol_segment)
4383 case absolute_section:
4385 /* See comment about reloc_callj() above. */
4387 #endif /* TC_I960 */
4388 add_number += S_GET_VALUE (add_symbolP);
4391 if (!TC_FORCE_RELOCATION (fixP))
4393 fixP->fx_addsy = NULL;
4399 #if defined(TC_A29K) || (defined(TE_PE) && defined(TC_I386)) || defined(TC_M88K) || defined(TC_OR32)
4400 /* This really should be handled in the linker, but
4401 backward compatibility forbids. */
4402 add_number += S_GET_VALUE (add_symbolP);
4404 add_number += S_GET_VALUE (add_symbolP) +
4405 segment_info[S_GET_SEGMENT (add_symbolP)].scnhdr.s_paddr;
4411 if ((int) fixP->fx_bit_fixP == 13)
4413 /* This is a COBR instruction. They have only a
4414 13-bit displacement and are only to be used
4415 for local branches: flag as error, don't generate
4417 as_bad_where (fixP->fx_file, fixP->fx_line,
4418 _("can't use COBR format with external label"));
4419 fixP->fx_addsy = NULL;
4423 #endif /* TC_I960 */
4424 #if ((defined (TC_I386) || defined (TE_LYNX) || defined (TE_AUX)) && !defined(TE_PE)) || defined (COFF_COMMON_ADDEND)
4425 /* 386 COFF uses a peculiar format in which the
4426 value of a common symbol is stored in the .text
4427 segment (I've checked this on SVR3.2 and SCO
4428 3.2.2) Ian Taylor <ian@cygnus.com>. */
4429 /* This is also true for 68k COFF on sysv machines
4430 (Checked on Motorola sysv68 R3V6 and R3V7.1, and also on
4431 UNIX System V/M68000, Release 1.0 from ATT/Bell Labs)
4432 Philippe De Muyter <phdm@info.ucl.ac.be>. */
4433 if (S_IS_COMMON (add_symbolP))
4434 add_number += S_GET_VALUE (add_symbolP);
4444 #if !defined(TC_M88K) && !(defined(TE_PE) && defined(TC_I386)) && !defined(TC_A29K) && !defined(TC_OR32)
4445 /* This adjustment is not correct on the m88k, for which the
4446 linker does all the computation. */
4447 add_number -= md_pcrel_from (fixP);
4449 if (add_symbolP == 0)
4450 fixP->fx_addsy = &abs_symbol;
4451 #if defined (TC_I386) || defined (TE_LYNX) || defined (TC_I960) || defined (TC_M68K)
4452 /* On the 386 we must adjust by the segment vaddr as well.
4455 I changed the i960 to work this way as well. This is
4456 compatible with the current GNU linker behaviour. I do
4457 not know what other i960 COFF assemblers do. This is not
4458 a common case: normally, only assembler code will contain
4459 a PC relative reloc, and only branches which do not
4460 originate in the .text section will have a non-zero
4463 I changed the m68k to work this way as well. This will
4464 break existing PC relative relocs from sections which do
4465 not start at address 0, but it will make ld -r work.
4466 Ian Taylor, 4 Oct 96. */
4468 add_number -= segP->scnhdr.s_vaddr;
4472 md_apply_fix3 (fixP, (valueT *) & add_number, this_segment_type);
4474 if (!fixP->fx_bit_fixP && ! fixP->fx_no_overflow)
4477 /* The m88k uses the offset field of the reloc to get around
4480 && ((add_number & ~0xFF)
4481 || (fixP->fx_signed && (add_number & 0x80)))
4482 && ((add_number & ~0xFF) != (-1 & ~0xFF)
4483 || (add_number & 0x80) == 0))
4485 && ((add_number & ~0xFFFF)
4486 || (fixP->fx_signed && (add_number & 0x8000)))
4487 && ((add_number & ~0xFFFF) != (-1 & ~0xFFFF)
4488 || (add_number & 0x8000) == 0)))
4490 as_bad_where (fixP->fx_file, fixP->fx_line,
4491 _("Value of %ld too large for field of %d bytes at 0x%lx"),
4492 (long) add_number, size,
4493 (unsigned long) (fragP->fr_address + where));
4496 #ifdef WARN_SIGNED_OVERFLOW_WORD
4497 /* Warn if a .word value is too large when treated as a
4498 signed number. We already know it is not too negative.
4499 This is to catch over-large switches generated by gcc on
4501 if (!flag_signed_overflow_ok
4503 && add_number > 0x7fff)
4504 as_bad_where (fixP->fx_file, fixP->fx_line,
4505 _("Signed .word overflow; switch may be too large; %ld at 0x%lx"),
4507 (unsigned long) (fragP->fr_address + where));
4515 /* The first entry in a .stab section is special. */
4518 obj_coff_init_stab_section (seg)
4524 unsigned int stroff;
4526 /* Make space for this first symbol. */
4530 as_where (&file, (unsigned int *) NULL);
4531 stabstr_name = (char *) alloca (strlen (segment_info[seg].name) + 4);
4532 strcpy (stabstr_name, segment_info[seg].name);
4533 strcat (stabstr_name, "str");
4534 stroff = get_stab_string_offset (file, stabstr_name);
4536 md_number_to_chars (p, stroff, 4);
4539 /* Fill in the counts in the first entry in a .stab section. */
4542 adjust_stab_section(abfd, seg)
4546 segT stabstrseg = SEG_UNKNOWN;
4547 const char *secname, *name2;
4550 int i, strsz = 0, nsyms;
4551 fragS *frag = segment_info[seg].frchainP->frch_root;
4553 /* Look for the associated string table section. */
4555 secname = segment_info[seg].name;
4556 name = (char *) alloca (strlen (secname) + 4);
4557 strcpy (name, secname);
4558 strcat (name, "str");
4560 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
4562 name2 = segment_info[i].name;
4563 if (name2 != NULL && strncmp(name2, name, 8) == 0)
4570 /* If we found the section, get its size. */
4571 if (stabstrseg != SEG_UNKNOWN)
4572 strsz = size_section (abfd, stabstrseg);
4574 nsyms = size_section (abfd, seg) / 12 - 1;
4576 /* Look for the first frag of sufficient size for the initial stab
4577 symbol, and collect a pointer to it. */
4578 while (frag && frag->fr_fix < 12)
4579 frag = frag->fr_next;
4581 p = frag->fr_literal;
4584 /* Write in the number of stab symbols and the size of the string
4586 bfd_h_put_16 (abfd, (bfd_vma) nsyms, (bfd_byte *) p + 6);
4587 bfd_h_put_32 (abfd, (bfd_vma) strsz, (bfd_byte *) p + 8);
4590 #endif /* not BFD_ASSEMBLER */
4592 const pseudo_typeS coff_pseudo_table[] =
4594 {"def", obj_coff_def, 0},
4595 {"dim", obj_coff_dim, 0},
4596 {"endef", obj_coff_endef, 0},
4597 {"line", obj_coff_line, 0},
4598 {"ln", obj_coff_ln, 0},
4599 #ifdef BFD_ASSEMBLER
4600 {"loc", obj_coff_loc, 0},
4602 {"appline", obj_coff_ln, 1},
4603 {"scl", obj_coff_scl, 0},
4604 {"size", obj_coff_size, 0},
4605 {"tag", obj_coff_tag, 0},
4606 {"type", obj_coff_type, 0},
4607 {"val", obj_coff_val, 0},
4608 {"section", obj_coff_section, 0},
4609 {"sect", obj_coff_section, 0},
4610 /* FIXME: We ignore the MRI short attribute. */
4611 {"section.s", obj_coff_section, 0},
4612 {"sect.s", obj_coff_section, 0},
4613 /* We accept the .bss directive for backward compatibility with
4614 earlier versions of gas. */
4615 {"bss", obj_coff_bss, 0},
4616 {"weak", obj_coff_weak, 0},
4617 {"ident", obj_coff_ident, 0},
4618 #ifndef BFD_ASSEMBLER
4619 {"use", obj_coff_section, 0},
4620 {"text", obj_coff_text, 0},
4621 {"data", obj_coff_data, 0},
4622 {"lcomm", obj_coff_lcomm, 0},
4624 {"optim", s_ignore, 0}, /* For sun386i cc (?) */
4626 {"version", s_ignore, 0},
4627 {"ABORT", s_abort, 0},
4628 #if defined( TC_M88K ) || defined ( TC_TIC4X )
4629 /* The m88k and tic4x uses sdef instead of def. */
4630 {"sdef", obj_coff_def, 0},
4632 {NULL, NULL, 0} /* end sentinel */
4633 }; /* coff_pseudo_table */
4635 #ifdef BFD_ASSEMBLER
4637 /* Support for a COFF emulation. */
4639 static void coff_pop_insert PARAMS ((void));
4640 static int coff_separate_stab_sections PARAMS ((void));
4645 pop_insert (coff_pseudo_table);
4649 coff_separate_stab_sections ()
4654 const struct format_ops coff_format_ops =
4656 bfd_target_coff_flavour,
4657 0, /* dfl_leading_underscore */
4658 1, /* emit_section_symbols */
4663 0, /* frob_file_before_adjust */
4664 0, /* frob_file_before_fix */
4665 coff_frob_file_after_relocs,
4668 0, /* s_get_align */
4669 0, /* s_set_align */
4670 0, /* s_get_other */
4671 0, /* s_set_other */
4676 0, /* copy_symbol_attributes */
4677 0, /* generate_asm_lineno */
4678 0, /* process_stab */
4679 coff_separate_stab_sections,
4680 obj_coff_init_stab_section,
4681 0, /* sec_sym_ok_for_reloc */
4683 0, /* ecoff_set_ext */
4684 coff_obj_read_begin_hook,
4685 coff_obj_symbol_new_hook