1 /* coff object file format with bfd
2 Copyright (C) 1989, 1990, 1991 Free Software Foundation, Inc.
4 This file is part of GAS.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
22 How does this releate to the rest of GAS ?
24 Well, all the other files in gas are more or less a black box. It
25 takes care of opening files, parsing command lines, stripping blanks
26 etc etc. This module gets a chance to register what it wants to do by
27 saying that it is interested in various pseduo ops. The other big
28 change is write_object_file. This runs through all the data
29 structures that gas builds, and outputs the file in the format of our
32 Hacked for BFDness by steve chamberlain
34 This object module now supports the Hitachi H8/{3|5}00 and the AMD 29k
43 #include "../bfd/libbfd.h"
44 #include "../bfd/libcoff.h"
46 /* The NOP_OPCODE is for the alignment fill value. Fill with nop so
47 that we can stick sections together without causing trouble. */
49 #define NOP_OPCODE 0x00
52 #define MIN(a,b) ((a) < (b)? (a) : (b))
53 /* This vector is used to turn an internal segment into a section #
54 suitable for insertion into a coff symbol table
57 const short seg_N_TYPE
[] =
58 { /* in: segT out: N_TYPE bits */
70 C_UNDEF_SECTION
, /* SEG_UNKNOWN */
71 C_UNDEF_SECTION
, /* SEG_ABSENT */
72 C_UNDEF_SECTION
, /* SEG_PASS1 */
73 C_UNDEF_SECTION
, /* SEG_GOOF */
74 C_UNDEF_SECTION
, /* SEG_BIG */
75 C_UNDEF_SECTION
, /* SEG_DIFFERENCE */
76 C_DEBUG_SECTION
, /* SEG_DEBUG */
77 C_NTV_SECTION
, /* SEG_NTV */
78 C_PTV_SECTION
, /* SEG_PTV */
79 C_REGISTER_SECTION
, /* SEG_REGISTER */
83 int function_lineoff
= -1; /* Offset in line#s where the last function
84 started (the odd entry for line #0) */
87 static symbolS
*last_line_symbol
;
89 /* Add 4 to the real value to get the index and compensate the
90 negatives. This vector is used by S_GET_SEGMENT to turn a coff
91 section number into a segment number
93 static symbolS
*previous_file_symbol
= NULL
;
94 void c_symbol_merge ();
97 symbolS
*c_section_symbol ();
99 void EXFUN (bfd_as_write_hook
, (struct internal_filehdr
*,
102 static void EXFUN (fixup_segment
, (segment_info_type
*segP
,
103 segT this_segment_type
));
106 static void EXFUN (fixup_mdeps
, (fragS
*,
111 static void EXFUN (fill_section
, (bfd
* abfd
,
116 char *EXFUN (s_get_name
, (symbolS
* s
));
117 static symbolS
*EXFUN (tag_find_or_make
, (char *name
));
118 static symbolS
*EXFUN (tag_find
, (char *name
));
125 unsigned short line_number
,
129 static void EXFUN (w_symbols
,
132 symbolS
* symbol_rootP
));
136 static void EXFUN (obj_coff_def
, (int what
));
137 static void EXFUN (obj_coff_lcomm
, (void));
138 static void EXFUN (obj_coff_dim
, (void));
139 static void EXFUN (obj_coff_text
, (void));
140 static void EXFUN (obj_coff_data
, (void));
141 static void EXFUN( obj_coff_bss
,(void));
142 static void EXFUN( obj_coff_ident
,(void));
143 static void EXFUN (obj_coff_endef
, (void));
144 static void EXFUN (obj_coff_line
, (void));
145 static void EXFUN (obj_coff_ln
, (int));
146 static void EXFUN (obj_coff_scl
, (void));
147 static void EXFUN (obj_coff_size
, (void));
148 static void EXFUN (obj_coff_tag
, (void));
149 static void EXFUN (obj_coff_type
, (void));
150 static void EXFUN (obj_coff_val
, (void));
151 void EXFUN (obj_coff_section
, (void));
152 static void EXFUN (tag_init
, (void));
153 static void EXFUN (tag_insert
, (char *name
, symbolS
* symbolP
));
156 static struct hash_control
*tag_hash
;
157 static symbolS
*def_symbol_in_progress
= NULL
;
159 const pseudo_typeS obj_pseudo_table
[] =
161 {"def", obj_coff_def
, 0},
162 {"dim", obj_coff_dim
, 0},
163 {"endef", obj_coff_endef
, 0},
164 {"line", obj_coff_line
, 0},
165 {"ln", obj_coff_ln
, 0},
166 {"appline", obj_coff_ln
, 1},
167 {"scl", obj_coff_scl
, 0},
168 {"size", obj_coff_size
, 0},
169 {"tag", obj_coff_tag
, 0},
170 {"type", obj_coff_type
, 0},
171 {"val", obj_coff_val
, 0},
172 {"section", obj_coff_section
, 0},
173 {"use", obj_coff_section
, 0},
174 {"sect", obj_coff_section
, 0},
175 {"text", obj_coff_text
, 0},
176 {"data", obj_coff_data
, 0},
177 {"bss", obj_coff_bss
, 0},
178 {"ident", obj_coff_ident
, 0},
179 {"ABORT", s_abort
, 0},
180 {"lcomm", obj_coff_lcomm
, 0},
181 {NULL
} /* end sentinel */
182 }; /* obj_pseudo_table */
188 We allow more than just the standard 3 sections, infact, we allow
189 10 sections, (though the usual three have to be there).
191 This structure performs the mappings for us:
196 static struct internal_scnhdr bss_section_header;
197 struct internal_scnhdr data_section_header;
198 struct internal_scnhdr text_section_header;
200 const segT N_TYPE_seg [32] =
214 seg_info_type seg_info_off_by_4
[N_SEG
] =
245 #define SEG_INFO_FROM_SECTION_NUMBER(x) (seg_info_off_by_4[(x)+4])
246 #define SEG_INFO_FROM_SEG_NUMBER(x) (seg_info_off_by_4[(x)])
250 DEFUN (relax_align
, (address
, alignment
),
251 register relax_addressT address AND
252 register long alignment
)
255 relax_addressT new_address
;
257 mask
= ~((~0) << alignment
);
258 new_address
= (address
+ mask
) & (~mask
);
259 return (new_address
- address
);
260 } /* relax_align() */
264 DEFUN (s_get_segment
, (x
),
267 return SEG_INFO_FROM_SECTION_NUMBER (x
->sy_symbol
.ost_entry
.n_scnum
).seg_t
;
272 /* calculate the size of the frag chain and fill in the section header
273 to contain all of it, also fill in the addr of the sections */
275 DEFUN (size_section
, (abfd
, idx
),
280 unsigned int size
= 0;
281 fragS
*frag
= segment_info
[idx
].frchainP
->frch_root
;
284 size
= frag
->fr_address
;
285 if (frag
->fr_address
!= size
)
287 printf ("Out of step\n");
288 size
= frag
->fr_address
;
291 switch (frag
->fr_type
)
293 #ifdef TC_COFF_SIZEMACHDEP
294 case rs_machine_dependent
:
295 size
+= TC_COFF_SIZEMACHDEP (frag
);
300 size
+= frag
->fr_fix
;
301 size
+= frag
->fr_offset
* frag
->fr_var
;
304 size
+= frag
->fr_fix
;
305 size
+= relax_align (size
, frag
->fr_offset
);
307 frag
= frag
->fr_next
;
309 segment_info
[idx
].scnhdr
.s_size
= size
;
315 DEFUN (count_entries_in_chain
, (idx
),
318 unsigned int nrelocs
;
321 /* Count the relocations */
322 fixup_ptr
= segment_info
[idx
].fix_root
;
324 while (fixup_ptr
!= (fixS
*) NULL
)
326 if (TC_COUNT_RELOC (fixup_ptr
))
331 if (fixup_ptr
->fx_r_type
== RELOC_CONSTH
)
340 fixup_ptr
= fixup_ptr
->fx_next
;
345 /* output all the relocations for a section */
347 DEFUN (do_relocs_for
, (abfd
, h
, file_cursor
),
349 object_headers
* h AND
350 unsigned long *file_cursor
)
352 unsigned int nrelocs
;
354 unsigned long reloc_start
= *file_cursor
;
356 for (idx
= SEG_E0
; idx
< SEG_E9
; idx
++)
358 if (segment_info
[idx
].scnhdr
.s_name
[0])
360 struct external_reloc
*ext_ptr
;
361 struct external_reloc
*external_reloc_vec
;
362 unsigned int external_reloc_size
;
363 unsigned int base
= segment_info
[idx
].scnhdr
.s_paddr
;
364 fixS
*fix_ptr
= segment_info
[idx
].fix_root
;
365 nrelocs
= count_entries_in_chain (idx
);
368 /* Bypass this stuff if no relocs. This also incidentally
369 avoids a SCO bug, where free(malloc(0)) tends to crash. */
371 external_reloc_size
= nrelocs
* RELSZ
;
373 (struct external_reloc
*) malloc (external_reloc_size
);
375 ext_ptr
= external_reloc_vec
;
377 /* Fill in the internal coff style reloc struct from the
378 internal fix list. */
382 struct internal_reloc intr
;
384 /* Only output some of the relocations */
385 if (TC_COUNT_RELOC (fix_ptr
))
387 #ifdef TC_RELOC_MANGLE
388 TC_RELOC_MANGLE (fix_ptr
, &intr
, base
);
392 symbol_ptr
= fix_ptr
->fx_addsy
;
394 intr
.r_type
= TC_COFF_FIX2RTYPE (fix_ptr
);
396 base
+ fix_ptr
->fx_frag
->fr_address
+ fix_ptr
->fx_where
;
398 intr
.r_offset
= fix_ptr
->fx_offset
;
402 /* Turn the segment of the symbol into an offset. */
405 dot
= segment_info
[S_GET_SEGMENT (symbol_ptr
)].dot
;
408 intr
.r_symndx
= dot
->sy_number
;
412 intr
.r_symndx
= symbol_ptr
->sy_number
;
422 (void) bfd_coff_swap_reloc_out (abfd
, &intr
, ext_ptr
);
427 /* The 29k has a special kludge for the high 16 bit
428 reloc. Two relocations are emited, R_IHIHALF,
429 and R_IHCONST. The second one doesn't contain a
430 symbol, but uses the value for offset. */
432 if (intr
.r_type
== R_IHIHALF
)
434 /* now emit the second bit */
435 intr
.r_type
= R_IHCONST
;
436 intr
.r_symndx
= fix_ptr
->fx_addnumber
;
437 (void) bfd_coff_swap_reloc_out (abfd
, &intr
, ext_ptr
);
443 fix_ptr
= fix_ptr
->fx_next
;
446 /* Write out the reloc table */
447 bfd_write ((PTR
) external_reloc_vec
, 1, external_reloc_size
,
449 free (external_reloc_vec
);
451 /* Fill in section header info. */
452 segment_info
[idx
].scnhdr
.s_relptr
= *file_cursor
;
453 *file_cursor
+= external_reloc_size
;
454 segment_info
[idx
].scnhdr
.s_nreloc
= nrelocs
;
459 segment_info
[idx
].scnhdr
.s_relptr
= 0;
463 /* Set relocation_size field in file headers */
464 H_SET_RELOCATION_SIZE (h
, *file_cursor
- reloc_start
, 0);
468 /* run through a frag chain and write out the data to go with it, fill
469 in the scnhdrs with the info on the file postions
472 DEFUN (fill_section
, (abfd
, h
, file_cursor
),
474 object_headers
*h AND
475 unsigned long *file_cursor
)
479 unsigned int paddr
= 0;
481 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
483 unsigned int offset
= 0;
485 struct internal_scnhdr
*s
= &(segment_info
[i
].scnhdr
);
489 fragS
*frag
= segment_info
[i
].frchainP
->frch_root
;
496 buffer
= xmalloc (s
->s_size
);
497 s
->s_scnptr
= *file_cursor
;
499 know (s
->s_paddr
== paddr
);
501 if (strcmp (s
->s_name
, ".text") == 0)
502 s
->s_flags
|= STYP_TEXT
;
503 else if (strcmp (s
->s_name
, ".data") == 0)
504 s
->s_flags
|= STYP_DATA
;
505 else if (strcmp (s
->s_name
, ".bss") == 0)
508 s
->s_flags
|= STYP_BSS
;
511 /* Apparently the SVR3 linker is confused by noload
512 sections. So is the UDI mondfe program. */
513 s
->s_flags
|= STYP_NOLOAD
;
517 else if (strcmp (s
->s_name
, ".lit") == 0)
518 s
->s_flags
= STYP_LIT
| STYP_TEXT
;
519 else if (strcmp (s
->s_name
, ".init") == 0)
520 s
->s_flags
|= STYP_TEXT
;
521 else if (strcmp (s
->s_name
, ".fini") == 0)
522 s
->s_flags
|= STYP_TEXT
;
523 else if (strncmp (s
->s_name
, ".comment", 8) == 0)
524 s
->s_flags
|= STYP_INFO
;
528 unsigned int fill_size
;
529 switch (frag
->fr_type
)
531 case rs_machine_dependent
:
534 memcpy (buffer
+ frag
->fr_address
,
537 offset
+= frag
->fr_fix
;
546 memcpy (buffer
+ frag
->fr_address
,
549 offset
+= frag
->fr_fix
;
552 fill_size
= frag
->fr_var
;
553 if (fill_size
&& frag
->fr_offset
> 0)
556 unsigned int off
= frag
->fr_fix
;
557 for (count
= frag
->fr_offset
; count
; count
--)
559 if (fill_size
< s
->s_size
)
561 memcpy (buffer
+ frag
->fr_address
+ off
,
562 frag
->fr_literal
+ frag
->fr_fix
,
575 frag
= frag
->fr_next
;
580 if (s
->s_scnptr
!= 0)
582 bfd_write (buffer
, s
->s_size
, 1, abfd
);
583 *file_cursor
+= s
->s_size
;
592 /* Coff file generation & utilities */
595 DEFUN (coff_header_append
, (abfd
, h
),
603 bfd_seek (abfd
, 0, 0);
605 #ifndef OBJ_COFF_OMIT_OPTIONAL_HEADER
606 H_SET_MAGIC_NUMBER (h
, COFF_MAGIC
);
607 H_SET_VERSION_STAMP (h
, 0);
608 H_SET_ENTRY_POINT (h
, 0);
609 H_SET_TEXT_START (h
, segment_info
[SEG_E0
].frchainP
->frch_root
->fr_address
);
610 H_SET_DATA_START (h
, segment_info
[SEG_E1
].frchainP
->frch_root
->fr_address
);
611 H_SET_SIZEOF_OPTIONAL_HEADER (h
, bfd_coff_swap_aouthdr_out(abfd
, &h
->aouthdr
,
613 #else /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
614 H_SET_SIZEOF_OPTIONAL_HEADER (h
, 0);
615 #endif /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
617 i
= bfd_coff_swap_filehdr_out (abfd
, &h
->filehdr
, buffer
);
619 bfd_write (buffer
, i
, 1, abfd
);
620 bfd_write (buffero
, H_GET_SIZEOF_OPTIONAL_HEADER (h
), 1, abfd
);
622 for (i
= SEG_E0
; i
< SEG_E9
; i
++)
624 if (segment_info
[i
].scnhdr
.s_name
[0])
627 bfd_coff_swap_scnhdr_out (abfd
,
628 &(segment_info
[i
].scnhdr
),
630 bfd_write (buffer
, size
, 1, abfd
);
637 DEFUN (symbol_to_chars
, (abfd
, where
, symbolP
),
642 unsigned int numaux
= symbolP
->sy_symbol
.ost_entry
.n_numaux
;
646 /* Turn any symbols with register attributes into abs symbols */
647 if (S_GET_SEGMENT (symbolP
) == SEG_REGISTER
)
649 S_SET_SEGMENT (symbolP
, SEG_ABSOLUTE
);
651 /* At the same time, relocate all symbols to their output value */
653 val
= (segment_info
[S_GET_SEGMENT (symbolP
)].scnhdr
.s_paddr
654 + S_GET_VALUE (symbolP
));
656 S_SET_VALUE (symbolP
, val
);
658 symbolP
->sy_symbol
.ost_entry
.n_value
= val
;
660 where
+= bfd_coff_swap_sym_out (abfd
, &symbolP
->sy_symbol
.ost_entry
,
663 for (i
= 0; i
< numaux
; i
++)
665 where
+= bfd_coff_swap_aux_out (abfd
,
666 &symbolP
->sy_symbol
.ost_auxent
[i
],
667 S_GET_DATA_TYPE (symbolP
),
668 S_GET_STORAGE_CLASS (symbolP
),
677 obj_symbol_new_hook (symbolP
)
680 char underscore
= 0; /* Symbol has leading _ */
682 /* Effective symbol */
683 /* Store the pointer in the offset. */
684 S_SET_ZEROES (symbolP
, 0L);
685 S_SET_DATA_TYPE (symbolP
, T_NULL
);
686 S_SET_STORAGE_CLASS (symbolP
, 0);
687 S_SET_NUMBER_AUXILIARY (symbolP
, 0);
688 /* Additional information */
689 symbolP
->sy_symbol
.ost_flags
= 0;
690 /* Auxiliary entries */
691 bzero ((char *) &symbolP
->sy_symbol
.ost_auxent
[0], AUXESZ
);
693 #ifdef STRIP_UNDERSCORE
694 /* Remove leading underscore at the beginning of the symbol.
695 * This is to be compatible with the standard librairies.
697 if (*S_GET_NAME (symbolP
) == '_')
700 S_SET_NAME (symbolP
, S_GET_NAME (symbolP
) + 1);
701 } /* strip underscore */
702 #endif /* STRIP_UNDERSCORE */
704 if (S_IS_STRING (symbolP
))
705 SF_SET_STRING (symbolP
);
706 if (!underscore
&& S_IS_LOCAL (symbolP
))
707 SF_SET_LOCAL (symbolP
);
710 } /* obj_symbol_new_hook() */
714 stack_init (chunk_size
, element_size
)
715 unsigned long chunk_size
;
716 unsigned long element_size
;
720 if ((st
= (stack
*) malloc (sizeof (stack
))) == (stack
*) 0)
722 if ((st
->data
= malloc (chunk_size
)) == (char *) 0)
728 st
->size
= chunk_size
;
729 st
->chunk_size
= chunk_size
;
730 st
->element_size
= element_size
;
743 stack_push (st
, element
)
747 if (st
->pointer
+ st
->element_size
>= st
->size
)
749 st
->size
+= st
->chunk_size
;
750 if ((st
->data
= xrealloc (st
->data
, st
->size
)) == (char *) 0)
753 memcpy (st
->data
+ st
->pointer
, element
, st
->element_size
);
754 st
->pointer
+= st
->element_size
;
755 return st
->data
+ st
->pointer
;
762 if ((st
->pointer
-= st
->element_size
) < 0)
768 return st
->data
+ st
->pointer
;
775 return st
->data
+ st
->pointer
- st
->element_size
;
780 * Handle .ln directives.
784 obj_coff_ln (appline
)
789 if (! appline
&& def_symbol_in_progress
!= NULL
)
791 as_warn (".ln pseudo-op inside .def/.endef: ignored.");
792 demand_empty_rest_of_line ();
794 } /* wrong context */
797 obstack_next_free (&frags
) - frag_now
->fr_literal
,
798 l
= get_absolute_expression (),
808 listing_source_line (l
);
813 demand_empty_rest_of_line ();
815 } /* obj_coff_line() */
820 * Handle .def directives.
822 * One might ask : why can't we symbol_new if the symbol does not
823 * already exist and fill it with debug information. Because of
824 * the C_EFCN special symbol. It would clobber the value of the
825 * function symbol before we have a chance to notice that it is
826 * a C_EFCN. And a second reason is that the code is more clear this
827 * way. (at least I think it is :-).
831 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
832 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
833 *input_line_pointer == '\t') \
834 input_line_pointer++;
837 DEFUN (obj_coff_def
, (what
),
840 char name_end
; /* Char after the end of name */
841 char *symbol_name
; /* Name of the debug symbol */
842 char *symbol_name_copy
; /* Temporary copy of the name */
843 unsigned int symbol_name_length
;
844 /*$char* directiveP;$ *//* Name of the pseudo opcode */
845 /*$char directive[MAX_DIRECTIVE];$ *//* Backup of the directive */
846 /*$char end = 0;$ *//* If 1, stop parsing */
848 if (def_symbol_in_progress
!= NULL
)
850 as_warn (".def pseudo-op used inside of .def/.endef: ignored.");
851 demand_empty_rest_of_line ();
853 } /* if not inside .def/.endef */
857 def_symbol_in_progress
= (symbolS
*) obstack_alloc (¬es
, sizeof (*def_symbol_in_progress
));
858 bzero (def_symbol_in_progress
, sizeof (*def_symbol_in_progress
));
860 symbol_name
= input_line_pointer
;
861 name_end
= get_symbol_end ();
862 symbol_name_length
= strlen (symbol_name
);
863 symbol_name_copy
= xmalloc (symbol_name_length
+ 1);
864 strcpy (symbol_name_copy
, symbol_name
);
866 /* Initialize the new symbol */
867 #ifdef STRIP_UNDERSCORE
868 S_SET_NAME (def_symbol_in_progress
, (*symbol_name_copy
== '_'
869 ? symbol_name_copy
+ 1
870 : symbol_name_copy
));
871 #else /* STRIP_UNDERSCORE */
872 S_SET_NAME (def_symbol_in_progress
, symbol_name_copy
);
873 #endif /* STRIP_UNDERSCORE */
874 /* free(symbol_name_copy); */
875 def_symbol_in_progress
->sy_name_offset
= ~0;
876 def_symbol_in_progress
->sy_number
= ~0;
877 def_symbol_in_progress
->sy_frag
= &zero_address_frag
;
879 if (S_IS_STRING (def_symbol_in_progress
))
881 SF_SET_STRING (def_symbol_in_progress
);
884 *input_line_pointer
= name_end
;
886 demand_empty_rest_of_line ();
888 } /* obj_coff_def() */
890 unsigned int dim_index
;
892 DEFUN_VOID (obj_coff_endef
)
894 symbolS
*symbolP
= 0;
895 /* DIM BUG FIX sac@cygnus.com */
897 if (def_symbol_in_progress
== NULL
)
899 as_warn (".endef pseudo-op used outside of .def/.endef: ignored.");
900 demand_empty_rest_of_line ();
902 } /* if not inside .def/.endef */
904 /* Set the section number according to storage class. */
905 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress
))
910 SF_SET_TAG (def_symbol_in_progress
);
911 /* intentional fallthrough */
914 SF_SET_DEBUG (def_symbol_in_progress
);
915 S_SET_SEGMENT (def_symbol_in_progress
, SEG_DEBUG
);
919 SF_SET_LOCAL (def_symbol_in_progress
); /* Do not emit this symbol. */
920 /* intentional fallthrough */
922 SF_SET_PROCESS (def_symbol_in_progress
); /* Will need processing before writing */
923 /* intentional fallthrough */
925 S_SET_SEGMENT (def_symbol_in_progress
, SEG_E0
);
927 if (strcmp (S_GET_NAME (def_symbol_in_progress
), ".bf") == 0)
929 if (function_lineoff
< 0)
931 fprintf (stderr
, "`.bf' symbol without preceding function\n");
932 } /* missing function symbol */
933 SA_GET_SYM_LNNOPTR (last_line_symbol
) = function_lineoff
;
935 SF_SET_PROCESS (last_line_symbol
);
936 function_lineoff
= -1;
942 #endif /* C_AUTOARG */
952 SF_SET_DEBUG (def_symbol_in_progress
);
953 S_SET_SEGMENT (def_symbol_in_progress
, SEG_ABSOLUTE
);
959 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
965 as_warn ("unexpected storage class %d", S_GET_STORAGE_CLASS (def_symbol_in_progress
));
967 } /* switch on storage class */
969 /* Now that we have built a debug symbol, try to find if we should
970 merge with an existing symbol or not. If a symbol is C_EFCN or
971 SEG_ABSOLUTE or untagged SEG_DEBUG it never merges. We also
972 don't merge labels, which are in a different namespace, nor
973 symbols which have not yet been defined since they are typically
974 unique, nor do we merge tags with non-tags. */
976 /* Two cases for functions. Either debug followed by definition or
977 definition followed by debug. For definition first, we will
978 merge the debug symbol into the definition. For debug first, the
979 lineno entry MUST point to the definition function or else it
980 will point off into space when crawl_symbols() merges the debug
981 symbol into the real symbol. Therefor, let's presume the debug
982 symbol is a real function reference. */
984 /* FIXME-SOON If for some reason the definition label/symbol is
985 never seen, this will probably leave an undefined symbol at link
988 if (S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_EFCN
989 || S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_LABEL
990 || (S_GET_SEGMENT (def_symbol_in_progress
) == SEG_DEBUG
991 && !SF_GET_TAG (def_symbol_in_progress
))
992 || S_GET_SEGMENT (def_symbol_in_progress
) == SEG_ABSOLUTE
993 || def_symbol_in_progress
->sy_forward
!= NULL
994 || (symbolP
= symbol_find_base (S_GET_NAME (def_symbol_in_progress
), DO_NOT_STRIP
)) == NULL
995 || (SF_GET_TAG (def_symbol_in_progress
) != SF_GET_TAG (symbolP
)))
997 symbol_append (def_symbol_in_progress
, symbol_lastP
, &symbol_rootP
,
1002 /* This symbol already exists, merge the newly created symbol
1003 into the This is not mandatory. The linker can handle
1004 duplicate symbols correctly. But I guess that it save a *lot*
1005 of space if the assembly file defines a lot of
1008 /* The debug entry (def_symbol_in_progress) is merged into the
1009 previous definition. */
1011 c_symbol_merge (def_symbol_in_progress
, symbolP
);
1012 /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
1013 def_symbol_in_progress
= symbolP
;
1015 if (SF_GET_FUNCTION (def_symbol_in_progress
)
1016 || SF_GET_TAG (def_symbol_in_progress
))
1018 /* For functions, and tags, the symbol *must* be where the
1019 debug symbol appears. Move the existing symbol to the
1021 /* If it already is at the end of the symbol list, do nothing */
1022 if (def_symbol_in_progress
!= symbol_lastP
)
1024 symbol_remove (def_symbol_in_progress
, &symbol_rootP
,
1026 symbol_append (def_symbol_in_progress
, symbol_lastP
,
1027 &symbol_rootP
, &symbol_lastP
);
1028 } /* if not already in place */
1030 } /* normal or mergable */
1032 if (SF_GET_TAG (def_symbol_in_progress
)
1033 && symbol_find_base (S_GET_NAME (def_symbol_in_progress
), DO_NOT_STRIP
) == NULL
)
1035 tag_insert (S_GET_NAME (def_symbol_in_progress
), def_symbol_in_progress
);
1038 if (SF_GET_FUNCTION (def_symbol_in_progress
))
1040 know (sizeof (def_symbol_in_progress
) <= sizeof (long));
1042 = c_line_new (def_symbol_in_progress
, 0, 0, &zero_address_frag
);
1044 SF_SET_PROCESS (def_symbol_in_progress
);
1046 if (symbolP
== NULL
)
1048 /* That is, if this is the first time we've seen the
1050 symbol_table_insert (def_symbol_in_progress
);
1051 } /* definition follows debug */
1052 } /* Create the line number entry pointing to the function being defined */
1054 def_symbol_in_progress
= NULL
;
1055 demand_empty_rest_of_line ();
1060 DEFUN_VOID (obj_coff_dim
)
1062 register int dim_index
;
1064 if (def_symbol_in_progress
== NULL
)
1066 as_warn (".dim pseudo-op used outside of .def/.endef: ignored.");
1067 demand_empty_rest_of_line ();
1069 } /* if not inside .def/.endef */
1071 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
1073 for (dim_index
= 0; dim_index
< DIMNUM
; dim_index
++)
1075 SKIP_WHITESPACES ();
1076 SA_SET_SYM_DIMEN (def_symbol_in_progress
, dim_index
, get_absolute_expression ());
1078 switch (*input_line_pointer
)
1082 input_line_pointer
++;
1086 as_warn ("badly formed .dim directive ignored");
1087 /* intentional fallthrough */
1092 } /* switch on following character */
1093 } /* for each dimension */
1095 demand_empty_rest_of_line ();
1097 } /* obj_coff_dim() */
1104 if (def_symbol_in_progress
== NULL
)
1108 } /* if it looks like a stabs style line */
1110 this_base
= get_absolute_expression ();
1111 if (this_base
> line_base
)
1113 line_base
= this_base
;
1122 listing_source_line (line_base
);
1126 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
1127 SA_SET_SYM_LNNO (def_symbol_in_progress
, line_base
);
1129 demand_empty_rest_of_line ();
1131 } /* obj_coff_line() */
1136 if (def_symbol_in_progress
== NULL
)
1138 as_warn (".size pseudo-op used outside of .def/.endef ignored.");
1139 demand_empty_rest_of_line ();
1141 } /* if not inside .def/.endef */
1143 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
1144 SA_SET_SYM_SIZE (def_symbol_in_progress
, get_absolute_expression ());
1145 demand_empty_rest_of_line ();
1147 } /* obj_coff_size() */
1152 if (def_symbol_in_progress
== NULL
)
1154 as_warn (".scl pseudo-op used outside of .def/.endef ignored.");
1155 demand_empty_rest_of_line ();
1157 } /* if not inside .def/.endef */
1159 S_SET_STORAGE_CLASS (def_symbol_in_progress
, get_absolute_expression ());
1160 demand_empty_rest_of_line ();
1162 } /* obj_coff_scl() */
1170 if (def_symbol_in_progress
== NULL
)
1172 as_warn (".tag pseudo-op used outside of .def/.endef ignored.");
1173 demand_empty_rest_of_line ();
1175 } /* if not inside .def/.endef */
1177 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
1178 symbol_name
= input_line_pointer
;
1179 name_end
= get_symbol_end ();
1181 /* Assume that the symbol referred to by .tag is always defined. */
1182 /* This was a bad assumption. I've added find_or_make. xoxorich. */
1183 SA_SET_SYM_TAGNDX (def_symbol_in_progress
, (long) tag_find_or_make (symbol_name
));
1184 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress
) == 0L)
1186 as_warn ("tag not found for .tag %s", symbol_name
);
1189 SF_SET_TAGGED (def_symbol_in_progress
);
1190 *input_line_pointer
= name_end
;
1192 demand_empty_rest_of_line ();
1194 } /* obj_coff_tag() */
1199 if (def_symbol_in_progress
== NULL
)
1201 as_warn (".type pseudo-op used outside of .def/.endef ignored.");
1202 demand_empty_rest_of_line ();
1204 } /* if not inside .def/.endef */
1206 S_SET_DATA_TYPE (def_symbol_in_progress
, get_absolute_expression ());
1208 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress
)) &&
1209 S_GET_STORAGE_CLASS (def_symbol_in_progress
) != C_TPDEF
)
1211 SF_SET_FUNCTION (def_symbol_in_progress
);
1212 } /* is a function */
1214 demand_empty_rest_of_line ();
1216 } /* obj_coff_type() */
1221 if (def_symbol_in_progress
== NULL
)
1223 as_warn (".val pseudo-op used outside of .def/.endef ignored.");
1224 demand_empty_rest_of_line ();
1226 } /* if not inside .def/.endef */
1228 if (is_name_beginner (*input_line_pointer
))
1230 char *symbol_name
= input_line_pointer
;
1231 char name_end
= get_symbol_end ();
1233 if (!strcmp (symbol_name
, "."))
1235 def_symbol_in_progress
->sy_frag
= frag_now
;
1236 S_SET_VALUE (def_symbol_in_progress
, obstack_next_free (&frags
) - frag_now
->fr_literal
);
1237 /* If the .val is != from the .def (e.g. statics) */
1239 else if (strcmp (S_GET_NAME (def_symbol_in_progress
), symbol_name
))
1241 def_symbol_in_progress
->sy_forward
= symbol_find_or_make (symbol_name
);
1243 /* If the segment is undefined when the forward
1244 reference is solved, then copy the segment id
1245 from the forward symbol. */
1246 SF_SET_GET_SEGMENT (def_symbol_in_progress
);
1248 /* FIXME: gcc can generate address expressions
1249 here in unusual cases (search for "obscure"
1250 in sdbout.c). We just ignore the offset
1251 here, thus generating incorrect debugging
1252 information. We ignore the rest of the
1255 /* Otherwise, it is the name of a non debug symbol and
1256 its value will be calculated later. */
1257 *input_line_pointer
= name_end
;
1259 /* FIXME: this is to avoid an error message in the
1260 FIXME case mentioned just above. */
1261 while (! is_end_of_line
[*input_line_pointer
])
1262 ++input_line_pointer
;
1266 S_SET_VALUE (def_symbol_in_progress
, get_absolute_expression ());
1267 } /* if symbol based */
1269 demand_empty_rest_of_line ();
1271 } /* obj_coff_val() */
1274 * Maintain a list of the tagnames of the structres.
1280 tag_hash
= hash_new ();
1285 tag_insert (name
, symbolP
)
1289 register char *error_string
;
1291 if (*(error_string
= hash_jam (tag_hash
, name
, (char *) symbolP
)))
1293 as_fatal ("Inserting \"%s\" into structure table failed: %s",
1294 name
, error_string
);
1297 } /* tag_insert() */
1300 tag_find_or_make (name
)
1305 if ((symbolP
= tag_find (name
)) == NULL
)
1307 symbolP
= symbol_new (name
,
1310 &zero_address_frag
);
1312 tag_insert (S_GET_NAME (symbolP
), symbolP
);
1316 } /* tag_find_or_make() */
1322 #ifdef STRIP_UNDERSCORE
1325 #endif /* STRIP_UNDERSCORE */
1326 return ((symbolS
*) hash_find (tag_hash
, name
));
1330 obj_read_begin_hook ()
1332 /* These had better be the same. Usually 18 bytes. */
1334 know (sizeof (SYMENT
) == sizeof (AUXENT
));
1335 know (SYMESZ
== AUXESZ
);
1340 } /* obj_read_begin_hook() */
1342 /* This function runs through the symbol table and puts all the
1343 externals onto another chain */
1345 /* The chain of externals */
1346 symbolS
*symbol_externP
= NULL
;
1347 symbolS
*symbol_extern_lastP
= NULL
;
1350 symbolS
*last_functionP
= NULL
;
1354 DEFUN_VOID (yank_symbols
)
1357 unsigned int symbol_number
= 0;
1358 unsigned int last_file_symno
= 0;
1360 for (symbolP
= symbol_rootP
;
1362 symbolP
= symbolP
? symbol_next (symbolP
) : symbol_rootP
)
1364 if (!SF_GET_DEBUG (symbolP
))
1366 /* Debug symbols do not need all this rubbish */
1367 symbolS
*real_symbolP
;
1369 /* L* and C_EFCN symbols never merge. */
1370 if (!SF_GET_LOCAL (symbolP
)
1371 && S_GET_STORAGE_CLASS (symbolP
) != C_LABEL
1372 && symbolP
->sy_forward
== NULL
1373 && (real_symbolP
= symbol_find_base (S_GET_NAME (symbolP
), DO_NOT_STRIP
))
1374 && real_symbolP
!= symbolP
)
1376 /* FIXME-SOON: where do dups come from?
1377 Maybe tag references before definitions? xoxorich. */
1378 /* Move the debug data from the debug symbol to the
1379 real symbol. Do NOT do the oposite (i.e. move from
1380 real symbol to debug symbol and remove real symbol from the
1381 list.) Because some pointers refer to the real symbol
1382 whereas no pointers refer to the debug symbol. */
1383 c_symbol_merge (symbolP
, real_symbolP
);
1384 /* Replace the current symbol by the real one */
1385 /* The symbols will never be the last or the first
1386 because : 1st symbol is .file and 3 last symbols are
1387 .text, .data, .bss */
1388 symbol_remove (real_symbolP
, &symbol_rootP
, &symbol_lastP
);
1389 symbol_insert (real_symbolP
, symbolP
, &symbol_rootP
, &symbol_lastP
);
1390 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
1391 symbolP
= real_symbolP
;
1392 } /* if not local but dup'd */
1394 if (flagseen
['R'] && (S_GET_SEGMENT (symbolP
) == SEG_E1
))
1396 S_SET_SEGMENT (symbolP
, SEG_E0
);
1397 } /* push data into text */
1399 S_SET_VALUE (symbolP
,
1400 S_GET_VALUE (symbolP
) + symbolP
->sy_frag
->fr_address
);
1402 if (!S_IS_DEFINED (symbolP
) && !SF_GET_LOCAL (symbolP
))
1404 S_SET_EXTERNAL (symbolP
);
1406 else if (S_GET_STORAGE_CLASS (symbolP
) == C_NULL
)
1408 if (S_GET_SEGMENT (symbolP
) == SEG_E0
)
1410 S_SET_STORAGE_CLASS (symbolP
, C_LABEL
);
1414 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
1418 /* Mainly to speed up if not -g */
1419 if (SF_GET_PROCESS (symbolP
))
1421 /* Handle the nested blocks auxiliary info. */
1422 if (S_GET_STORAGE_CLASS (symbolP
) == C_BLOCK
)
1424 if (!strcmp (S_GET_NAME (symbolP
), ".bb"))
1425 stack_push (block_stack
, (char *) &symbolP
);
1428 register symbolS
*begin_symbolP
;
1429 begin_symbolP
= *(symbolS
**) stack_pop (block_stack
);
1430 if (begin_symbolP
== (symbolS
*) 0)
1431 as_warn ("mismatched .eb");
1433 SA_SET_SYM_ENDNDX (begin_symbolP
, symbol_number
+ 2);
1436 /* If we are able to identify the type of a function, and we
1437 are out of a function (last_functionP == 0) then, the
1438 function symbol will be associated with an auxiliary
1440 if (last_functionP
== (symbolS
*) 0 &&
1441 SF_GET_FUNCTION (symbolP
))
1443 last_functionP
= symbolP
;
1445 if (S_GET_NUMBER_AUXILIARY (symbolP
) < 1)
1447 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
1448 } /* make it at least 1 */
1450 /* Clobber possible stale .dim information. */
1452 /* Iffed out by steve - this fries the lnnoptr info too */
1453 bzero (symbolP
->sy_symbol
.ost_auxent
[0].x_sym
.x_fcnary
.x_ary
.x_dimen
,
1454 sizeof (symbolP
->sy_symbol
.ost_auxent
[0].x_sym
.x_fcnary
.x_ary
.x_dimen
));
1457 /* The C_FCN doesn't need any additional information. I
1458 don't even know if this is needed for sdb. But the
1459 standard assembler generates it, so... */
1460 if (S_GET_STORAGE_CLASS (symbolP
) == C_EFCN
)
1462 if (last_functionP
== (symbolS
*) 0)
1463 as_fatal ("C_EFCN symbol out of scope");
1464 SA_SET_SYM_FSIZE (last_functionP
,
1465 (long) (S_GET_VALUE (symbolP
) -
1466 S_GET_VALUE (last_functionP
)));
1467 SA_SET_SYM_ENDNDX (last_functionP
, symbol_number
);
1468 last_functionP
= (symbolS
*) 0;
1472 else if (SF_GET_TAG (symbolP
))
1474 /* First descriptor of a structure must point to
1475 the first slot after the structure description. */
1476 last_tagP
= symbolP
;
1479 else if (S_GET_STORAGE_CLASS (symbolP
) == C_EOS
)
1481 /* +2 take in account the current symbol */
1482 SA_SET_SYM_ENDNDX (last_tagP
, symbol_number
+ 2);
1484 else if (S_GET_STORAGE_CLASS (symbolP
) == C_FILE
)
1486 if (S_GET_VALUE (symbolP
))
1488 S_SET_VALUE (symbolP
, last_file_symno
);
1489 last_file_symno
= symbol_number
;
1490 } /* no one points at the first .file symbol */
1491 } /* if debug or tag or eos or file */
1493 /* We must put the external symbols apart. The loader
1494 does not bomb if we do not. But the references in
1495 the endndx field for a .bb symbol are not corrected
1496 if an external symbol is removed between .bb and .be.
1497 I.e in the following case :
1498 [20] .bb endndx = 22
1501 ld will move the symbol 21 to the end of the list but
1502 endndx will still be 22 instead of 21. */
1505 if (SF_GET_LOCAL (symbolP
))
1507 /* remove C_EFCN and LOCAL (L...) symbols */
1508 /* next pointer remains valid */
1509 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
1512 else if (!S_IS_DEFINED (symbolP
)
1513 && !S_IS_DEBUG (symbolP
)
1514 && !SF_GET_STATICS (symbolP
) &&
1515 S_GET_STORAGE_CLASS (symbolP
) == C_EXT
)
1516 { /* C_EXT && !SF_GET_FUNCTION(symbolP)) */
1517 /* if external, Remove from the list */
1518 symbolS
*hold
= symbol_previous (symbolP
);
1520 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
1521 symbol_clear_list_pointers (symbolP
);
1522 symbol_append (symbolP
, symbol_extern_lastP
, &symbol_externP
, &symbol_extern_lastP
);
1527 if (SF_GET_STRING (symbolP
))
1529 symbolP
->sy_name_offset
= string_byte_count
;
1530 string_byte_count
+= strlen (S_GET_NAME (symbolP
)) + 1;
1534 symbolP
->sy_name_offset
= 0;
1535 } /* fix "long" names */
1537 symbolP
->sy_number
= symbol_number
;
1538 symbol_number
+= 1 + S_GET_NUMBER_AUXILIARY (symbolP
);
1539 } /* if local symbol */
1540 } /* traverse the symbol list */
1541 return symbol_number
;
1547 DEFUN_VOID (glue_symbols
)
1549 unsigned int symbol_number
= 0;
1551 for (symbolP
= symbol_externP
; symbol_externP
;)
1553 symbolS
*tmp
= symbol_externP
;
1556 symbol_remove (tmp
, &symbol_externP
, &symbol_extern_lastP
);
1557 symbol_append (tmp
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
1560 if (SF_GET_STRING (tmp
))
1562 tmp
->sy_name_offset
= string_byte_count
;
1563 string_byte_count
+= strlen (S_GET_NAME (tmp
)) + 1;
1567 tmp
->sy_name_offset
= 0;
1568 } /* fix "long" names */
1570 tmp
->sy_number
= symbol_number
;
1571 symbol_number
+= 1 + S_GET_NUMBER_AUXILIARY (tmp
);
1572 } /* append the entire extern chain */
1573 return symbol_number
;
1578 DEFUN_VOID (tie_tags
)
1580 unsigned int symbol_number
= 0;
1583 for (symbolP
= symbol_rootP
; symbolP
; symbolP
=
1584 symbol_next (symbolP
))
1586 symbolP
->sy_number
= symbol_number
;
1590 if (SF_GET_TAGGED (symbolP
))
1594 ((symbolS
*) SA_GET_SYM_TAGNDX (symbolP
))->sy_number
);
1597 symbol_number
+= 1 + S_GET_NUMBER_AUXILIARY (symbolP
);
1599 return symbol_number
;
1604 DEFUN (crawl_symbols
, (h
, abfd
),
1605 object_headers
*h AND
1612 /* Initialize the stack used to keep track of the matching .bb .be */
1614 block_stack
= stack_init (512, sizeof (symbolS
*));
1615 /* JF deal with forward references first... */
1616 for (symbolP
= symbol_rootP
; symbolP
; symbolP
= symbol_next (symbolP
))
1617 if (symbolP
->sy_forward
)
1619 S_SET_VALUE (symbolP
, (S_GET_VALUE (symbolP
)
1620 + S_GET_VALUE (symbolP
->sy_forward
)
1621 + symbolP
->sy_forward
->sy_frag
->fr_address
));
1622 if (SF_GET_GET_SEGMENT (symbolP
))
1623 S_SET_SEGMENT (symbolP
, S_GET_SEGMENT (symbolP
->sy_forward
));
1626 /* The symbol list should be ordered according to the following sequence
1629 * . debug entries for functions
1630 * . fake symbols for the sections, including.text .data and .bss
1632 * . undefined symbols
1633 * But this is not mandatory. The only important point is to put the
1634 * undefined symbols at the end of the list.
1637 if (symbol_rootP
== NULL
1638 || S_GET_STORAGE_CLASS (symbol_rootP
) != C_FILE
)
1640 c_dot_file_symbol ("fake");
1642 /* Is there a .file symbol ? If not insert one at the beginning. */
1645 * Build up static symbols for the sections, they are filled in later
1649 for (i
= SEG_E0
; i
< SEG_E9
; i
++)
1651 if (segment_info
[i
].scnhdr
.s_name
[0])
1655 strncpy (name
, segment_info
[i
].scnhdr
.s_name
, 8);
1657 segment_info
[i
].dot
= c_section_symbol (name
, i
- SEG_E0
+ 1);
1662 /* Take all the externals out and put them into another chain */
1663 H_SET_SYMBOL_TABLE_SIZE (h
, yank_symbols ());
1664 /* Take the externals and glue them onto the end.*/
1665 H_SET_SYMBOL_TABLE_SIZE (h
, H_GET_SYMBOL_COUNT (h
) + glue_symbols ());
1667 H_SET_SYMBOL_TABLE_SIZE (h
, tie_tags ());
1668 know (symbol_externP
== NULL
);
1669 know (symbol_extern_lastP
== NULL
);
1675 * Find strings by crawling along symbol table chain.
1679 DEFUN (w_strings
, (where
),
1684 /* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
1685 md_number_to_chars (where
, string_byte_count
, 4);
1687 for (symbolP
= symbol_rootP
;
1689 symbolP
= symbol_next (symbolP
))
1693 if (SF_GET_STRING (symbolP
))
1695 size
= strlen (S_GET_NAME (symbolP
)) + 1;
1697 memcpy (where
, S_GET_NAME (symbolP
), size
);
1706 DEFUN (do_linenos_for
, (abfd
, h
, file_cursor
),
1708 object_headers
* h AND
1709 unsigned long *file_cursor
)
1712 unsigned long start
= *file_cursor
;
1714 for (idx
= SEG_E0
; idx
< SEG_E9
; idx
++)
1716 segment_info_type
*s
= segment_info
+ idx
;
1719 if (s
->scnhdr
.s_nlnno
!= 0)
1721 struct lineno_list
*line_ptr
;
1723 struct external_lineno
*buffer
=
1724 (struct external_lineno
*) xmalloc (s
->scnhdr
.s_nlnno
* LINESZ
);
1726 struct external_lineno
*dst
= buffer
;
1728 /* Run through the table we've built and turn it into its external
1729 form, take this chance to remove duplicates */
1731 for (line_ptr
= s
->lineno_list_head
;
1732 line_ptr
!= (struct lineno_list
*) NULL
;
1733 line_ptr
= line_ptr
->next
)
1736 if (line_ptr
->line
.l_lnno
== 0)
1738 /* Turn a pointer to a symbol into the symbols' index */
1739 line_ptr
->line
.l_addr
.l_symndx
=
1740 ((symbolS
*) line_ptr
->line
.l_addr
.l_symndx
)->sy_number
;
1744 line_ptr
->line
.l_addr
.l_paddr
+= ((struct frag
*) (line_ptr
->frag
))->fr_address
;
1748 (void) bfd_coff_swap_lineno_out (abfd
, &(line_ptr
->line
), dst
);
1753 s
->scnhdr
.s_lnnoptr
= *file_cursor
;
1755 bfd_write (buffer
, 1, s
->scnhdr
.s_nlnno
* LINESZ
, abfd
);
1758 *file_cursor
+= s
->scnhdr
.s_nlnno
* LINESZ
;
1761 H_SET_LINENO_SIZE (h
, *file_cursor
- start
);
1765 /* Now we run through the list of frag chains in a segment and
1766 make all the subsegment frags appear at the end of the
1767 list, as if the seg 0 was extra long */
1770 DEFUN_VOID (remove_subsegs
)
1774 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
1776 frchainS
*head
= segment_info
[i
].frchainP
;
1778 fragS
*prev_frag
= &dummy
;
1780 while (head
&& head
->frch_seg
== i
)
1782 prev_frag
->fr_next
= head
->frch_root
;
1783 prev_frag
= head
->frch_last
;
1784 head
= head
->frch_next
;
1786 prev_frag
->fr_next
= 0;
1793 DEFUN_VOID (write_object_file
)
1796 struct frchain
*frchain_ptr
;
1798 object_headers headers
;
1799 unsigned long file_cursor
;
1802 abfd
= bfd_openw (out_file_name
, TARGET_FORMAT
);
1807 as_perror ("FATAL: Can't create %s", out_file_name
);
1810 bfd_set_format (abfd
, bfd_object
);
1811 bfd_set_arch_mach (abfd
, BFD_ARCH
, machine
);
1813 string_byte_count
= 4;
1815 for (frchain_ptr
= frchain_root
;
1816 frchain_ptr
!= (struct frchain
*) NULL
;
1817 frchain_ptr
= frchain_ptr
->frch_next
)
1819 /* Run through all the sub-segments and align them up. Also close any
1820 open frags. We tack a .fill onto the end of the frag chain so
1821 that any .align's size can be worked by looking at the next
1824 subseg_new (frchain_ptr
->frch_seg
, frchain_ptr
->frch_subseg
);
1825 #ifndef SUB_SEGMENT_ALIGN
1826 #define SUB_SEGMENT_ALIGN(SEG) 1
1828 frag_align (SUB_SEGMENT_ALIGN (now_seg
), NOP_OPCODE
);
1829 frag_wane (frag_now
);
1830 frag_now
->fr_fix
= 0;
1831 know (frag_now
->fr_next
== NULL
);
1838 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
1840 relax_segment (segment_info
[i
].frchainP
->frch_root
, i
);
1843 H_SET_NUMBER_OF_SECTIONS (&headers
, 0);
1845 /* Find out how big the sections are, and set the addresses. */
1847 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
1851 segment_info
[i
].scnhdr
.s_paddr
= addr
;
1852 segment_info
[i
].scnhdr
.s_vaddr
= addr
;
1854 if (segment_info
[i
].scnhdr
.s_name
[0])
1856 H_SET_NUMBER_OF_SECTIONS (&headers
,
1857 H_GET_NUMBER_OF_SECTIONS (&headers
) + 1);
1860 size
= size_section (abfd
, i
);
1864 H_SET_TEXT_SIZE (&headers
, size
);
1865 else if (i
== SEG_E1
)
1866 H_SET_DATA_SIZE (&headers
, size
);
1867 else if (i
== SEG_E2
)
1868 H_SET_BSS_SIZE (&headers
, size
);
1871 /* Turn the gas native symbol table shape into a coff symbol table */
1872 crawl_symbols (&headers
, abfd
);
1874 if (string_byte_count
== 4)
1875 string_byte_count
= 0;
1877 H_SET_STRING_SIZE (&headers
, string_byte_count
);
1879 #if !defined(TC_H8300) && !defined(TC_Z8K)
1880 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
1882 fixup_mdeps (segment_info
[i
].frchainP
->frch_root
, &headers
, i
);
1883 fixup_segment (&segment_info
[i
], i
);
1887 file_cursor
= H_GET_TEXT_FILE_OFFSET (&headers
);
1889 bfd_seek (abfd
, file_cursor
, 0);
1891 /* Plant the data */
1893 fill_section (abfd
, &headers
, &file_cursor
);
1895 do_relocs_for (abfd
, &headers
, &file_cursor
);
1897 do_linenos_for (abfd
, &headers
, &file_cursor
);
1899 H_SET_FILE_MAGIC_NUMBER (&headers
, COFF_MAGIC
);
1900 #ifndef OBJ_COFF_OMIT_TIMESTAMP
1901 H_SET_TIME_STAMP (&headers
, (long)time((long*)0));
1903 H_SET_TIME_STAMP (&headers
, 0);
1906 #ifdef KEEP_RELOC_INFO
1907 H_SET_FLAGS (&headers
, ((H_GET_LINENO_SIZE(&headers
) ? 0 : F_LNNO
) |
1908 COFF_FLAGS
| coff_flags
));
1910 H_SET_FLAGS (&headers
, ((H_GET_LINENO_SIZE(&headers
) ? 0 : F_LNNO
) |
1911 (H_GET_RELOCATION_SIZE(&headers
) ? 0 : F_RELFLG
) |
1912 COFF_FLAGS
| coff_flags
));
1916 unsigned int symtable_size
= H_GET_SYMBOL_TABLE_SIZE (&headers
);
1917 char *buffer1
= xmalloc (symtable_size
+ string_byte_count
+ 1);
1918 char *ptr
= buffer1
;
1919 H_SET_SYMBOL_TABLE_POINTER (&headers
, bfd_tell (abfd
));
1920 w_symbols (abfd
, buffer1
, symbol_rootP
);
1921 if (string_byte_count
> 0)
1922 w_strings (buffer1
+ symtable_size
);
1923 bfd_write (buffer1
, 1, symtable_size
+ string_byte_count
, abfd
);
1927 coff_header_append (abfd
, &headers
);
1929 if (bfd_close_all_done (abfd
) == false)
1930 as_fatal ("Can't close %s: %s", out_file_name
,
1931 bfd_errmsg (bfd_error
));
1936 DEFUN (change_to_section
, (name
, len
, exp
),
1938 unsigned int len AND
1942 /* Find out if we've already got a section of this name etc */
1943 for (i
= SEG_E0
; i
< SEG_E9
&& segment_info
[i
].scnhdr
.s_name
[0]; i
++)
1945 if (strncmp (segment_info
[i
].scnhdr
.s_name
, name
, len
) == 0)
1947 subseg_new (i
, exp
);
1951 /* No section, add one */
1952 strncpy (segment_info
[i
].scnhdr
.s_name
, name
, 8);
1953 segment_info
[i
].scnhdr
.s_flags
= STYP_REG
;
1954 subseg_new (i
, exp
);
1958 * implement the .section pseudo op:
1959 * .section name {, "flags"}
1961 * | +--- optional flags: 'b' for bss
1963 * +-- section name 'l' for lib
1968 * But if the argument is not a quoted string, treat it as a
1969 * subsegment number.
1973 DEFUN_VOID (obj_coff_section
)
1975 /* Strip out the section name */
1977 char *section_name_end
;
1984 section_name
= input_line_pointer
;
1985 c
= get_symbol_end ();
1986 section_name_end
= input_line_pointer
;
1988 len
= section_name_end
- section_name
;
1989 input_line_pointer
++;
1995 else if (*input_line_pointer
== ',')
1998 ++input_line_pointer
;
2006 if (*input_line_pointer
!= '"')
2007 exp
= get_absolute_expression ();
2010 ++input_line_pointer
;
2011 while (*input_line_pointer
!= '"'
2012 && ! is_end_of_line
[*input_line_pointer
])
2014 switch (*input_line_pointer
)
2016 case 'b': flags
|= STYP_BSS
; break;
2017 case 'i': flags
|= STYP_INFO
; break;
2018 case 'l': flags
|= STYP_LIB
; break;
2019 case 'n': flags
|= STYP_NOLOAD
; break;
2020 case 'o': flags
|= STYP_OVER
; break;
2021 case 'w': flags
|= STYP_DATA
; break;
2022 case 'x': flags
|= STYP_TEXT
; break;
2024 as_warn("unknown section attribute '%c'",
2025 *input_line_pointer
);
2028 ++input_line_pointer
;
2030 if (*input_line_pointer
== '"')
2031 ++input_line_pointer
;
2035 change_to_section (section_name
, len
, exp
);
2037 segment_info
[now_seg
].scnhdr
.s_flags
|= flags
;
2039 *section_name_end
= c
;
2046 change_to_section (".text", 5, get_absolute_expression ());
2053 change_to_section (".data", 5, get_absolute_expression ());
2059 if (*input_line_pointer
== '\n') /* .bss */
2060 change_to_section(".bss",4, get_absolute_expression());
2061 else /* .bss id,expr */
2068 segT current_seg
= now_seg
; /* save current seg */
2069 subsegT current_subseg
= now_subseg
;
2070 change_to_section (".comment", 8, 0); /* .comment seg */
2071 stringer (1); /* read string */
2072 subseg_new (current_seg
, current_subseg
); /* restore current seg */
2076 c_symbol_merge (debug
, normal
)
2080 S_SET_DATA_TYPE (normal
, S_GET_DATA_TYPE (debug
));
2081 S_SET_STORAGE_CLASS (normal
, S_GET_STORAGE_CLASS (debug
));
2083 if (S_GET_NUMBER_AUXILIARY (debug
) > S_GET_NUMBER_AUXILIARY (normal
))
2085 S_SET_NUMBER_AUXILIARY (normal
, S_GET_NUMBER_AUXILIARY (debug
));
2086 } /* take the most we have */
2088 if (S_GET_NUMBER_AUXILIARY (debug
) > 0)
2090 memcpy ((char *) &normal
->sy_symbol
.ost_auxent
[0], (char *) &debug
->sy_symbol
.ost_auxent
[0], S_GET_NUMBER_AUXILIARY (debug
) * AUXESZ
);
2091 } /* Move all the auxiliary information */
2093 /* Move the debug flags. */
2094 SF_SET_DEBUG_FIELD (normal
, SF_GET_DEBUG_FIELD (debug
));
2095 } /* c_symbol_merge() */
2098 DEFUN (c_line_new
, (symbol
, paddr
, line_number
, frag
),
2099 symbolS
* symbol AND
2101 unsigned short line_number AND
2104 struct lineno_list
*new_line
=
2105 (struct lineno_list
*) xmalloc (sizeof (struct lineno_list
));
2107 segment_info_type
*s
= segment_info
+ now_seg
;
2108 new_line
->line
.l_lnno
= line_number
;
2110 if (line_number
== 0)
2112 last_line_symbol
= symbol
;
2113 new_line
->line
.l_addr
.l_symndx
= (long) symbol
;
2117 new_line
->line
.l_addr
.l_paddr
= paddr
;
2120 new_line
->frag
= (char *) frag
;
2121 new_line
->next
= (struct lineno_list
*) NULL
;
2124 if (s
->lineno_list_head
== (struct lineno_list
*) NULL
)
2126 s
->lineno_list_head
= new_line
;
2130 s
->lineno_list_tail
->next
= new_line
;
2132 s
->lineno_list_tail
= new_line
;
2133 return LINESZ
* s
->scnhdr
.s_nlnno
++;
2137 c_dot_file_symbol (filename
)
2142 symbolP
= symbol_new (".file",
2145 &zero_address_frag
);
2147 S_SET_STORAGE_CLASS (symbolP
, C_FILE
);
2148 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
2149 SA_SET_FILE_FNAME (symbolP
, filename
);
2155 listing_source_file (filename
);
2161 SF_SET_DEBUG (symbolP
);
2162 S_SET_VALUE (symbolP
, (long) previous_file_symbol
);
2164 previous_file_symbol
= symbolP
;
2166 /* Make sure that the symbol is first on the symbol chain */
2167 if (symbol_rootP
!= symbolP
)
2169 if (symbolP
== symbol_lastP
)
2171 symbol_lastP
= symbol_lastP
->sy_previous
;
2172 } /* if it was the last thing on the list */
2174 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
2175 symbol_insert (symbolP
, symbol_rootP
, &symbol_rootP
, &symbol_lastP
);
2176 symbol_rootP
= symbolP
;
2177 } /* if not first on the list */
2179 } /* c_dot_file_symbol() */
2182 * Build a 'section static' symbol.
2186 c_section_symbol (name
, idx
)
2192 symbolP
= symbol_new (name
, idx
,
2194 &zero_address_frag
);
2196 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2197 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
2199 SF_SET_STATICS (symbolP
);
2202 } /* c_section_symbol() */
2205 DEFUN (w_symbols
, (abfd
, where
, symbol_rootP
),
2208 symbolS
* symbol_rootP
)
2213 /* First fill in those values we have only just worked out */
2214 for (i
= SEG_E0
; i
< SEG_E9
; i
++)
2216 symbolP
= segment_info
[i
].dot
;
2220 SA_SET_SCN_SCNLEN (symbolP
, segment_info
[i
].scnhdr
.s_size
);
2221 SA_SET_SCN_NRELOC (symbolP
, segment_info
[i
].scnhdr
.s_nreloc
);
2222 SA_SET_SCN_NLINNO (symbolP
, segment_info
[i
].scnhdr
.s_nlnno
);
2228 * Emit all symbols left in the symbol chain.
2230 for (symbolP
= symbol_rootP
; symbolP
; symbolP
= symbol_next (symbolP
))
2232 /* Used to save the offset of the name. It is used to point
2233 to the string in memory but must be a file offset. */
2234 register char *temp
;
2236 tc_coff_symbol_emit_hook (symbolP
);
2238 temp
= S_GET_NAME (symbolP
);
2239 if (SF_GET_STRING (symbolP
))
2241 S_SET_OFFSET (symbolP
, symbolP
->sy_name_offset
);
2242 S_SET_ZEROES (symbolP
, 0);
2246 bzero (symbolP
->sy_symbol
.ost_entry
.n_name
, SYMNMLEN
);
2247 strncpy (symbolP
->sy_symbol
.ost_entry
.n_name
, temp
, SYMNMLEN
);
2249 where
= symbol_to_chars (abfd
, where
, symbolP
);
2250 S_SET_NAME (symbolP
, temp
);
2256 DEFUN_VOID (obj_coff_lcomm
)
2264 name
= input_line_pointer
;
2266 c
= get_symbol_end ();
2267 p
= input_line_pointer
;
2270 if (*input_line_pointer
!= ',')
2272 as_bad ("Expected comma after name");
2273 ignore_rest_of_line ();
2276 if (*input_line_pointer
== '\n')
2278 as_bad ("Missing size expression");
2281 input_line_pointer
++;
2282 if ((temp
= get_absolute_expression ()) < 0)
2284 as_warn ("lcomm length (%d.) <0! Ignored.", temp
);
2285 ignore_rest_of_line ();
2290 symbolP
= symbol_find_or_make(name
);
2292 if (S_GET_SEGMENT(symbolP
) == SEG_UNKNOWN
&&
2293 S_GET_VALUE(symbolP
) == 0)
2298 segT current_seg
= now_seg
; /* save current seg */
2299 subsegT current_subseg
= now_subseg
;
2301 subseg_new (SEG_E2
, 1);
2302 symbolP
->sy_frag
= frag_now
;
2303 p
= frag_var(rs_org
, 1, 1, (relax_substateT
)0, symbolP
,
2306 subseg_new (current_seg
, current_subseg
); /* restore current seg */
2307 S_SET_SEGMENT(symbolP
, SEG_E2
);
2308 S_SET_STORAGE_CLASS(symbolP
, C_STAT
);
2312 as_bad("Symbol %s already defined", name
);
2314 demand_empty_rest_of_line();
2318 DEFUN (fixup_mdeps
, (frags
, h
, this_segment
),
2320 object_headers
* h AND
2323 subseg_change (this_segment
, 0);
2326 switch (frags
->fr_type
)
2330 frags
->fr_type
= rs_fill
;
2332 (frags
->fr_next
->fr_address
- frags
->fr_address
- frags
->fr_fix
);
2334 case rs_machine_dependent
:
2335 md_convert_frag (h
, frags
);
2341 frags
= frags
->fr_next
;
2347 DEFUN (fixup_segment
, (segP
, this_segment_type
),
2348 segment_info_type
* segP AND
2349 segT this_segment_type
)
2351 register fixS
* fixP
;
2352 register symbolS
*add_symbolP
;
2353 register symbolS
*sub_symbolP
;
2354 register long add_number
;
2356 register char *place
;
2357 register long where
;
2358 register char pcrel
;
2359 register fragS
*fragP
;
2360 register segT add_symbol_segment
= SEG_ABSOLUTE
;
2363 for (fixP
= segP
->fix_root
; fixP
; fixP
= fixP
->fx_next
)
2365 fragP
= fixP
->fx_frag
;
2367 where
= fixP
->fx_where
;
2368 place
= fragP
->fr_literal
+ where
;
2369 size
= fixP
->fx_size
;
2370 add_symbolP
= fixP
->fx_addsy
;
2372 if (fixP
->fx_callj
&& TC_S_IS_CALLNAME (add_symbolP
))
2374 /* Relocation should be done via the
2375 associated 'bal' entry point
2378 if (!TC_S_IS_BALNAME (tc_get_bal_of_call (add_symbolP
)))
2380 as_bad ("No 'bal' entry point for leafproc %s",
2381 S_GET_NAME (add_symbolP
));
2384 fixP
->fx_addsy
= add_symbolP
= tc_get_bal_of_call (add_symbolP
);
2385 } /* callj relocation */
2387 sub_symbolP
= fixP
->fx_subsy
;
2388 add_number
= fixP
->fx_offset
;
2389 pcrel
= fixP
->fx_pcrel
;
2393 add_symbol_segment
= S_GET_SEGMENT (add_symbolP
);
2394 } /* if there is an addend */
2401 if (S_GET_SEGMENT (sub_symbolP
) != SEG_ABSOLUTE
)
2403 as_bad ("Negative of non-absolute symbol %s", S_GET_NAME (sub_symbolP
));
2404 } /* not absolute */
2406 add_number
-= S_GET_VALUE (sub_symbolP
);
2409 /* if sub_symbol is in the same segment that add_symbol
2410 and add_symbol is either in DATA, TEXT, BSS or ABSOLUTE */
2412 else if ((S_GET_SEGMENT (sub_symbolP
) == add_symbol_segment
)
2413 && (SEG_NORMAL (add_symbol_segment
)
2414 || (add_symbol_segment
== SEG_ABSOLUTE
)))
2416 /* Difference of 2 symbols from same segment. */
2417 /* Can't make difference of 2 undefineds: 'value' means */
2418 /* something different for N_UNDF. */
2420 /* Makes no sense to use the difference of 2 arbitrary symbols
2421 as the target of a call instruction. */
2424 as_bad ("callj to difference of 2 symbols");
2426 #endif /* TC_I960 */
2427 add_number
+= S_GET_VALUE (add_symbolP
) -
2428 S_GET_VALUE (sub_symbolP
);
2431 fixP
->fx_addsy
= NULL
;
2435 /* Different segments in subtraction. */
2436 know (!(S_IS_EXTERNAL (sub_symbolP
) && (S_GET_SEGMENT (sub_symbolP
) == SEG_ABSOLUTE
)));
2438 if ((S_GET_SEGMENT (sub_symbolP
) == SEG_ABSOLUTE
))
2440 add_number
-= S_GET_VALUE (sub_symbolP
);
2444 as_bad ("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %d.",
2445 segment_name (S_GET_SEGMENT (sub_symbolP
)),
2446 S_GET_NAME (sub_symbolP
), fragP
->fr_address
+ where
);
2449 } /* if sub_symbolP */
2453 if (add_symbol_segment
== this_segment_type
&& pcrel
)
2456 * This fixup was made when the symbol's segment was
2457 * SEG_UNKNOWN, but it is now in the local segment.
2458 * So we know how to do the address without relocation.
2461 /* reloc_callj() may replace a 'call' with a 'calls' or a 'bal',
2462 * in which cases it modifies *fixP as appropriate. In the case
2463 * of a 'calls', no further work is required, and *fixP has been
2464 * set up to make the rest of the code below a no-op.
2467 #endif /* TC_I960 */
2469 add_number
+= S_GET_VALUE (add_symbolP
);
2470 add_number
-= md_pcrel_from (fixP
);
2472 /* On the 386 we must adjust by the segment
2473 vaddr as well. Ian Taylor. */
2474 add_number
-= segP
->scnhdr
.s_vaddr
;
2476 pcrel
= 0; /* Lie. Don't want further pcrel processing. */
2477 fixP
->fx_addsy
= NULL
; /* No relocations please. */
2481 switch (add_symbol_segment
)
2485 reloc_callj (fixP
); /* See comment about reloc_callj() above*/
2486 #endif /* TC_I960 */
2487 add_number
+= S_GET_VALUE (add_symbolP
);
2488 fixP
->fx_addsy
= NULL
;
2494 /* This really should be handled in the linker, but
2495 backward compatibility forbids. */
2496 add_number
+= S_GET_VALUE (add_symbolP
);
2498 add_number
+= S_GET_VALUE (add_symbolP
) +
2499 segment_info
[S_GET_SEGMENT (add_symbolP
)].scnhdr
.s_paddr
;
2505 if ((int) fixP
->fx_bit_fixP
== 13)
2507 /* This is a COBR instruction. They have only a
2508 * 13-bit displacement and are only to be used
2509 * for local branches: flag as error, don't generate
2512 as_bad ("can't use COBR format with external label");
2513 fixP
->fx_addsy
= NULL
; /* No relocations please. */
2516 #endif /* TC_I960 */
2518 /* 386 COFF uses a peculiar format in
2519 which the value of a common symbol is
2520 stored in the .text segment (I've
2521 checked this on SVR3.2 and SCO 3.2.2)
2522 Ian Taylor <ian@cygnus.com>. */
2523 if (S_IS_COMMON (add_symbolP
))
2524 add_number
+= S_GET_VALUE (add_symbolP
);
2529 } /* switch on symbol seg */
2530 } /* if not in local seg */
2531 } /* if there was a + symbol */
2535 add_number
-= md_pcrel_from (fixP
);
2536 if (add_symbolP
== 0)
2538 fixP
->fx_addsy
= &abs_symbol
;
2539 } /* if there's an add_symbol */
2541 /* On the 386 we must adjust by the segment vaddr
2542 as well. Ian Taylor. */
2543 add_number
-= segP
->scnhdr
.s_vaddr
;
2547 if (!fixP
->fx_bit_fixP
)
2550 (add_number
& ~0xFF) && ((add_number
& ~0xFF) != (-1 & ~0xFF))) ||
2552 (add_number
& ~0xFFFF) && ((add_number
& ~0xFFFF) != (-1 & ~0xFFFF))))
2554 as_bad ("Value of %d too large for field of %d bytes at 0x%x",
2555 add_number
, size
, fragP
->fr_address
+ where
);
2556 } /* generic error checking */
2557 #ifdef WARN_SIGNED_OVERFLOW_WORD
2558 /* Warn if a .word value is too large when treated as
2559 a signed number. We already know it is not too
2560 negative. This is to catch over-large switches
2561 generated by gcc on the 68k. */
2564 && add_number
> 0x7fff)
2565 as_bad ("Signed .word overflow; switch may be too large; %d at 0x%x",
2566 add_number
, fragP
->fr_address
+ where
);
2568 } /* not a bit fix */
2569 /* once this fix has been applied, we don't have to output anything
2570 nothing more need be done -*/
2571 md_apply_fix (fixP
, add_number
);
2572 } /* For each fixS in this segment. */
2573 } /* fixup_segment() */