projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Delete this patch, it breaks the h8300 assembler.
[deliverable/binutils-gdb.git] / gas / config / obj-coff.c
1 /* coff object file format
2 Copyright (C) 1989, 1990, 1991, 1992, 1993, 1994
3 Free Software Foundation, Inc.
4
5 This file is part of GAS.
6
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to
19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
20
21 #include "as.h"
22 #include "obstack.h"
23 #include "subsegs.h"
24
25 /* I think this is probably always correct. */
26 #ifndef KEEP_RELOC_INFO
27 #define KEEP_RELOC_INFO
28 #endif
29
30 const char *s_get_name PARAMS ((symbolS * s));
31 static symbolS *def_symbol_in_progress;
32
33 \f
34 /* stack stuff */
35 typedef struct
36 {
37 unsigned long chunk_size;
38 unsigned long element_size;
39 unsigned long size;
40 char *data;
41 unsigned long pointer;
42 }
43 stack;
44
45 static stack *
46 stack_init (chunk_size, element_size)
47 unsigned long chunk_size;
48 unsigned long element_size;
49 {
50 stack *st;
51
52 st = (stack *) malloc (sizeof (stack));
53 if (!st)
54 return 0;
55 st->data = malloc (chunk_size);
56 if (!st->data)
57 {
58 free (st);
59 return 0;
60 }
61 st->pointer = 0;
62 st->size = chunk_size;
63 st->chunk_size = chunk_size;
64 st->element_size = element_size;
65 return st;
66 }
67
68 #if 0
69 /* Not currently used. */
70 static void
71 stack_delete (st)
72 stack *st;
73 {
74 free (st->data);
75 free (st);
76 }
77 #endif
78
79 static char *
80 stack_push (st, element)
81 stack *st;
82 char *element;
83 {
84 if (st->pointer + st->element_size >= st->size)
85 {
86 st->size += st->chunk_size;
87 if ((st->data = xrealloc (st->data, st->size)) == (char *) 0)
88 return (char *) 0;
89 }
90 memcpy (st->data + st->pointer, element, st->element_size);
91 st->pointer += st->element_size;
92 return st->data + st->pointer;
93 }
94
95 static char *
96 stack_pop (st)
97 stack *st;
98 {
99 if (st->pointer < st->element_size)
100 {
101 st->pointer = 0;
102 return (char *) 0;
103 }
104 st->pointer -= st->element_size;
105 return st->data + st->pointer;
106 }
107 \f
108 /*
109 * Maintain a list of the tagnames of the structres.
110 */
111
112 static struct hash_control *tag_hash;
113
114 static void
115 tag_init ()
116 {
117 tag_hash = hash_new ();
118 }
119
120 static void
121 tag_insert (name, symbolP)
122 const char *name;
123 symbolS *symbolP;
124 {
125 const char *error_string;
126
127 if ((error_string = hash_jam (tag_hash, name, (char *) symbolP)))
128 {
129 as_fatal ("Inserting \"%s\" into structure table failed: %s",
130 name, error_string);
131 }
132 }
133
134 static symbolS *
135 tag_find (name)
136 char *name;
137 {
138 #ifdef STRIP_UNDERSCORE
139 if (*name == '_')
140 name++;
141 #endif /* STRIP_UNDERSCORE */
142 return (symbolS *) hash_find (tag_hash, name);
143 }
144
145 static symbolS *
146 tag_find_or_make (name)
147 char *name;
148 {
149 symbolS *symbolP;
150
151 if ((symbolP = tag_find (name)) == NULL)
152 {
153 symbolP = symbol_new (name, undefined_section,
154 0, &zero_address_frag);
155
156 tag_insert (S_GET_NAME (symbolP), symbolP);
157 #ifdef BFD_ASSEMBLER
158 symbol_table_insert (symbolP);
159 #endif
160 } /* not found */
161
162 return symbolP;
163 }
164
165
166
167 #ifdef BFD_ASSEMBLER
168
169 static void SA_SET_SYM_TAGNDX PARAMS ((symbolS *, symbolS *));
170
171 #define GET_FILENAME_STRING(X) \
172 ((char*)(&((X)->sy_symbol.ost_auxent->x_file.x_n.x_offset))[1])
173
174 /* @@ Ick. */
175 static segT
176 fetch_coff_debug_section ()
177 {
178 static segT debug_section;
179 if (!debug_section)
180 {
181 CONST asymbol *s;
182 s = bfd_make_debug_symbol (stdoutput, (char *) 0, 0);
183 assert (s != 0);
184 debug_section = s->section;
185 }
186 return debug_section;
187 }
188
189 void
190 SA_SET_SYM_ENDNDX (sym, val)
191 symbolS *sym;
192 symbolS *val;
193 {
194 combined_entry_type *entry, *p;
195
196 entry = &coffsymbol (sym->bsym)->native[1];
197 p = coffsymbol (val->bsym)->native;
198 entry->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p = p;
199 entry->fix_end = 1;
200 }
201
202 static void
203 SA_SET_SYM_TAGNDX (sym, val)
204 symbolS *sym;
205 symbolS *val;
206 {
207 combined_entry_type *entry, *p;
208
209 entry = &coffsymbol (sym->bsym)->native[1];
210 p = coffsymbol (val->bsym)->native;
211 entry->u.auxent.x_sym.x_tagndx.p = p;
212 entry->fix_tag = 1;
213 }
214
215 static int
216 S_GET_DATA_TYPE (sym)
217 symbolS *sym;
218 {
219 return coffsymbol (sym->bsym)->native->u.syment.n_type;
220 }
221
222 int
223 S_SET_DATA_TYPE (sym, val)
224 symbolS *sym;
225 int val;
226 {
227 coffsymbol (sym->bsym)->native->u.syment.n_type = val;
228 return val;
229 }
230
231 int
232 S_GET_STORAGE_CLASS (sym)
233 symbolS *sym;
234 {
235 return coffsymbol (sym->bsym)->native->u.syment.n_sclass;
236 }
237
238 int
239 S_SET_STORAGE_CLASS (sym, val)
240 symbolS *sym;
241 int val;
242 {
243 coffsymbol (sym->bsym)->native->u.syment.n_sclass = val;
244 return val;
245 }
246
247 /* Merge a debug symbol containing debug information into a normal symbol. */
248
249 void
250 c_symbol_merge (debug, normal)
251 symbolS *debug;
252 symbolS *normal;
253 {
254 S_SET_DATA_TYPE (normal, S_GET_DATA_TYPE (debug));
255 S_SET_STORAGE_CLASS (normal, S_GET_STORAGE_CLASS (debug));
256
257 if (S_GET_NUMBER_AUXILIARY (debug) > S_GET_NUMBER_AUXILIARY (normal))
258 /* take the most we have */
259 S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));
260
261 if (S_GET_NUMBER_AUXILIARY (debug) > 0)
262 {
263 /* Move all the auxiliary information. */
264 /* @@ How many fields do we want to preserve? Would it make more
265 sense to pick and choose those we want to copy? Should look
266 into this further.... [raeburn:19920512.2209EST] */
267 alent *linenos;
268 linenos = coffsymbol (normal->bsym)->lineno;
269 memcpy ((char *) &coffsymbol (normal->bsym)->native,
270 (char *) &coffsymbol (debug->bsym)->native,
271 S_GET_NUMBER_AUXILIARY(debug) * AUXESZ);
272 coffsymbol (normal->bsym)->lineno = linenos;
273 }
274
275 /* Move the debug flags. */
276 SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
277 }
278
279 static symbolS *previous_file_symbol;
280 void
281 c_dot_file_symbol (filename)
282 char *filename;
283 {
284 symbolS *symbolP;
285
286 symbolP = symbol_new (filename, bfd_abs_section_ptr, 0, &zero_address_frag);
287
288 S_SET_STORAGE_CLASS (symbolP, C_FILE);
289 S_SET_NUMBER_AUXILIARY (symbolP, 1);
290
291 symbolP->bsym->flags = BSF_DEBUGGING;
292
293 #ifndef NO_LISTING
294 {
295 extern int listing;
296 if (listing)
297 {
298 listing_source_file (filename);
299 }
300 }
301 #endif
302
303 S_SET_VALUE (symbolP, (long) previous_file_symbol);
304
305 previous_file_symbol = symbolP;
306
307 /* Make sure that the symbol is first on the symbol chain */
308 if (symbol_rootP != symbolP)
309 {
310 if (symbolP == symbol_lastP)
311 {
312 symbol_lastP = symbol_lastP->sy_previous;
313 } /* if it was the last thing on the list */
314
315 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
316 symbol_insert (symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
317 symbol_rootP = symbolP;
318 } /* if not first on the list */
319 }
320
321 /*
322 * Build a 'section static' symbol.
323 */
324
325 char *
326 c_section_symbol (name, value, length, nreloc, nlnno)
327 char *name;
328 long value;
329 long length;
330 unsigned short nreloc;
331 unsigned short nlnno;
332 {
333 symbolS *symbolP;
334
335 symbolP = symbol_new (name,
336 (name[1] == 't'
337 ? text_section
338 : name[1] == 'd'
339 ? data_section
340 : bss_section),
341 value,
342 &zero_address_frag);
343
344 S_SET_STORAGE_CLASS (symbolP, C_STAT);
345 S_SET_NUMBER_AUXILIARY (symbolP, 1);
346
347 SA_SET_SCN_SCNLEN (symbolP, length);
348 SA_SET_SCN_NRELOC (symbolP, nreloc);
349 SA_SET_SCN_NLINNO (symbolP, nlnno);
350
351 SF_SET_STATICS (symbolP);
352
353 return (char *) symbolP;
354 }
355
356 /* Line number handling */
357
358 struct line_no {
359 struct line_no *next;
360 fragS *frag;
361 alent l;
362 };
363
364 int coff_line_base;
365
366 /* Symbol of last function, which we should hang line#s off of. */
367 static symbolS *line_fsym;
368
369 #define in_function() (line_fsym != 0)
370 #define clear_function() (line_fsym = 0)
371 #define set_function(F) (line_fsym = (F), coff_add_linesym (F))
372
373 \f
374 void
375 obj_symbol_new_hook (symbolP)
376 symbolS *symbolP;
377 {
378 char underscore = 0; /* Symbol has leading _ */
379
380 {
381 long sz = (OBJ_COFF_MAX_AUXENTRIES + 1) * sizeof (combined_entry_type);
382 char *s = (char *) bfd_alloc_by_size_t (stdoutput, sz);
383 memset (s, 0, sz);
384 coffsymbol (symbolP->bsym)->native = (combined_entry_type *) s;
385 }
386 S_SET_DATA_TYPE (symbolP, T_NULL);
387 S_SET_STORAGE_CLASS (symbolP, 0);
388 S_SET_NUMBER_AUXILIARY (symbolP, 0);
389
390 if (S_IS_STRING (symbolP))
391 SF_SET_STRING (symbolP);
392 if (!underscore && S_IS_LOCAL (symbolP))
393 SF_SET_LOCAL (symbolP);
394 }
395
396 \f
397 /*
398 * Handle .ln directives.
399 */
400
401 static symbolS *current_lineno_sym;
402 static struct line_no *line_nos;
403 /* @@ Blindly assume all .ln directives will be in the .text section... */
404 static int n_line_nos;
405
406 static void
407 add_lineno (frag, offset, num)
408 fragS *frag;
409 int offset;
410 int num;
411 {
412 struct line_no *new_line = (struct line_no *) bfd_alloc_by_size_t (stdoutput,
413 sizeof (struct line_no));
414 if (!current_lineno_sym)
415 {
416 abort ();
417 }
418 new_line->next = line_nos;
419 new_line->frag = frag;
420 new_line->l.line_number = num;
421 new_line->l.u.offset = offset;
422 line_nos = new_line;
423 n_line_nos++;
424 }
425
426 void
427 coff_add_linesym (sym)
428 symbolS *sym;
429 {
430 if (line_nos)
431 {
432 coffsymbol (current_lineno_sym->bsym)->lineno = (alent *) line_nos;
433 n_line_nos++;
434 line_nos = 0;
435 }
436 current_lineno_sym = sym;
437 }
438
439 static void
440 obj_coff_ln (appline)
441 int appline;
442 {
443 int l;
444
445 if (! appline && def_symbol_in_progress != NULL)
446 {
447 as_warn (".ln pseudo-op inside .def/.endef: ignored.");
448 demand_empty_rest_of_line ();
449 return;
450 }
451
452 l = get_absolute_expression ();
453 if (!appline)
454 {
455 add_lineno (frag_now, frag_now_fix (), l);
456 }
457
458 #ifndef NO_LISTING
459 {
460 extern int listing;
461
462 if (listing)
463 {
464 if (! appline)
465 l += coff_line_base - 1;
466 listing_source_line (l);
467 }
468 }
469 #endif
470
471 demand_empty_rest_of_line ();
472 }
473
474 /*
475 * def()
476 *
477 * Handle .def directives.
478 *
479 * One might ask : why can't we symbol_new if the symbol does not
480 * already exist and fill it with debug information. Because of
481 * the C_EFCN special symbol. It would clobber the value of the
482 * function symbol before we have a chance to notice that it is
483 * a C_EFCN. And a second reason is that the code is more clear this
484 * way. (at least I think it is :-).
485 *
486 */
487
488 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
489 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
490 *input_line_pointer == '\t') \
491 input_line_pointer++;
492
493 static void
494 obj_coff_def (what)
495 int what;
496 {
497 char name_end; /* Char after the end of name */
498 char *symbol_name; /* Name of the debug symbol */
499 char *symbol_name_copy; /* Temporary copy of the name */
500 unsigned int symbol_name_length;
501
502 if (def_symbol_in_progress != NULL)
503 {
504 as_warn (".def pseudo-op used inside of .def/.endef: ignored.");
505 demand_empty_rest_of_line ();
506 return;
507 } /* if not inside .def/.endef */
508
509 SKIP_WHITESPACES ();
510
511 symbol_name = input_line_pointer;
512 #ifdef STRIP_UNDERSCORE
513 if (symbol_name[0] == '_' && symbol_name[1] != 0)
514 symbol_name++;
515 #endif /* STRIP_UNDERSCORE */
516
517 name_end = get_symbol_end ();
518 symbol_name_length = strlen (symbol_name);
519 symbol_name_copy = xmalloc (symbol_name_length + 1);
520 strcpy (symbol_name_copy, symbol_name);
521
522 /* Initialize the new symbol */
523 def_symbol_in_progress = symbol_make (symbol_name_copy);
524 def_symbol_in_progress->sy_frag = &zero_address_frag;
525 S_SET_VALUE (def_symbol_in_progress, 0);
526
527 if (S_IS_STRING (def_symbol_in_progress))
528 SF_SET_STRING (def_symbol_in_progress);
529
530 *input_line_pointer = name_end;
531
532 demand_empty_rest_of_line ();
533 }
534
535 unsigned int dim_index;
536
537 static void
538 obj_coff_endef (ignore)
539 int ignore;
540 {
541 symbolS *symbolP;
542 /* DIM BUG FIX sac@cygnus.com */
543 dim_index = 0;
544 if (def_symbol_in_progress == NULL)
545 {
546 as_warn (".endef pseudo-op used outside of .def/.endef: ignored.");
547 demand_empty_rest_of_line ();
548 return;
549 } /* if not inside .def/.endef */
550
551 /* Set the section number according to storage class. */
552 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))
553 {
554 case C_STRTAG:
555 case C_ENTAG:
556 case C_UNTAG:
557 SF_SET_TAG (def_symbol_in_progress);
558 /* intentional fallthrough */
559 case C_FILE:
560 case C_TPDEF:
561 SF_SET_DEBUG (def_symbol_in_progress);
562 S_SET_SEGMENT (def_symbol_in_progress, fetch_coff_debug_section ());
563 break;
564
565 case C_EFCN:
566 SF_SET_LOCAL (def_symbol_in_progress); /* Do not emit this symbol. */
567 /* intentional fallthrough */
568 case C_BLOCK:
569 SF_SET_PROCESS (def_symbol_in_progress); /* Will need processing before writing */
570 /* intentional fallthrough */
571 case C_FCN:
572 {
573 CONST char *name;
574 S_SET_SEGMENT (def_symbol_in_progress, text_section);
575
576 name = bfd_asymbol_name (def_symbol_in_progress->bsym);
577 if (name[1] == 'b' && name[2] == 'f')
578 {
579 if (! in_function ())
580 as_warn ("`%s' symbol without preceding function", name);
581 /* SA_SET_SYM_LNNO (def_symbol_in_progress, 12345);*/
582 /* Will need relocating */
583 SF_SET_PROCESS (def_symbol_in_progress);
584 clear_function ();
585 }
586 }
587 break;
588
589 #ifdef C_AUTOARG
590 case C_AUTOARG:
591 #endif /* C_AUTOARG */
592 case C_AUTO:
593 case C_REG:
594 case C_MOS:
595 case C_MOE:
596 case C_MOU:
597 case C_ARG:
598 case C_REGPARM:
599 case C_FIELD:
600 case C_EOS:
601 SF_SET_DEBUG (def_symbol_in_progress);
602 S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
603 break;
604
605 case C_EXT:
606 case C_STAT:
607 case C_LABEL:
608 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
609 break;
610
611 case C_USTATIC:
612 case C_EXTDEF:
613 case C_ULABEL:
614 as_warn ("unexpected storage class %d",
615 S_GET_STORAGE_CLASS (def_symbol_in_progress));
616 break;
617 } /* switch on storage class */
618
619 /* Now that we have built a debug symbol, try to find if we should
620 merge with an existing symbol or not. If a symbol is C_EFCN or
621 SEG_ABSOLUTE or untagged SEG_DEBUG it never merges. */
622
623 /* Two cases for functions. Either debug followed by definition or
624 definition followed by debug. For definition first, we will
625 merge the debug symbol into the definition. For debug first, the
626 lineno entry MUST point to the definition function or else it
627 will point off into space when obj_crawl_symbol_chain() merges
628 the debug symbol into the real symbol. Therefor, let's presume
629 the debug symbol is a real function reference. */
630
631 /* FIXME-SOON If for some reason the definition label/symbol is
632 never seen, this will probably leave an undefined symbol at link
633 time. */
634
635 if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN
636 || (!strcmp (bfd_get_section_name (stdoutput,
637 S_GET_SEGMENT (def_symbol_in_progress)),
638 "*DEBUG*")
639 && !SF_GET_TAG (def_symbol_in_progress))
640 || S_GET_SEGMENT (def_symbol_in_progress) == absolute_section
641 || (symbolP = symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP)) == NULL)
642 {
643 if (def_symbol_in_progress != symbol_lastP)
644 symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP,
645 &symbol_lastP);
646 }
647 else
648 {
649 /* This symbol already exists, merge the newly created symbol
650 into the old one. This is not mandatory. The linker can
651 handle duplicate symbols correctly. But I guess that it save
652 a *lot* of space if the assembly file defines a lot of
653 symbols. [loic] */
654
655 /* The debug entry (def_symbol_in_progress) is merged into the
656 previous definition. */
657
658 c_symbol_merge (def_symbol_in_progress, symbolP);
659 /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
660 def_symbol_in_progress = symbolP;
661
662 if (SF_GET_FUNCTION (def_symbol_in_progress)
663 || SF_GET_TAG (def_symbol_in_progress))
664 {
665 /* For functions, and tags, the symbol *must* be where the
666 debug symbol appears. Move the existing symbol to the
667 current place. */
668 /* If it already is at the end of the symbol list, do nothing */
669 if (def_symbol_in_progress != symbol_lastP)
670 {
671 symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
672 symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP, &symbol_lastP);
673 }
674 }
675 }
676
677 if (SF_GET_TAG (def_symbol_in_progress)
678 && symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP) == NULL)
679 {
680 tag_insert (S_GET_NAME (def_symbol_in_progress), def_symbol_in_progress);
681 }
682
683 if (SF_GET_FUNCTION (def_symbol_in_progress))
684 {
685 know (sizeof (def_symbol_in_progress) <= sizeof (long));
686 set_function (def_symbol_in_progress);
687 SF_SET_PROCESS (def_symbol_in_progress);
688
689 if (symbolP == NULL)
690 {
691 /* That is, if this is the first time we've seen the
692 function... */
693 symbol_table_insert (def_symbol_in_progress);
694 } /* definition follows debug */
695 } /* Create the line number entry pointing to the function being defined */
696
697 def_symbol_in_progress = NULL;
698 demand_empty_rest_of_line ();
699 }
700
701 static void
702 obj_coff_dim (ignore)
703 int ignore;
704 {
705 int dim_index;
706
707 if (def_symbol_in_progress == NULL)
708 {
709 as_warn (".dim pseudo-op used outside of .def/.endef: ignored.");
710 demand_empty_rest_of_line ();
711 return;
712 } /* if not inside .def/.endef */
713
714 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
715
716 for (dim_index = 0; dim_index < DIMNUM; dim_index++)
717 {
718 SKIP_WHITESPACES ();
719 SA_SET_SYM_DIMEN (def_symbol_in_progress, dim_index,
720 get_absolute_expression ());
721
722 switch (*input_line_pointer)
723 {
724 case ',':
725 input_line_pointer++;
726 break;
727
728 default:
729 as_warn ("badly formed .dim directive ignored");
730 /* intentional fallthrough */
731 case '\n':
732 case ';':
733 dim_index = DIMNUM;
734 break;
735 }
736 }
737
738 demand_empty_rest_of_line ();
739 }
740
741 static void
742 obj_coff_line (ignore)
743 int ignore;
744 {
745 int this_base;
746
747 if (def_symbol_in_progress == NULL)
748 {
749 /* Probably stabs-style line? */
750 obj_coff_ln (0);
751 return;
752 }
753
754 this_base = get_absolute_expression ();
755 if (!strcmp (".bf", S_GET_NAME (def_symbol_in_progress)))
756 coff_line_base = this_base;
757
758 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
759 SA_SET_SYM_LNNO (def_symbol_in_progress, coff_line_base);
760
761 demand_empty_rest_of_line ();
762 }
763
764 static void
765 obj_coff_size (ignore)
766 int ignore;
767 {
768 if (def_symbol_in_progress == NULL)
769 {
770 as_warn (".size pseudo-op used outside of .def/.endef ignored.");
771 demand_empty_rest_of_line ();
772 return;
773 } /* if not inside .def/.endef */
774
775 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
776 SA_SET_SYM_SIZE (def_symbol_in_progress, get_absolute_expression ());
777 demand_empty_rest_of_line ();
778 }
779
780 static void
781 obj_coff_scl (ignore)
782 int ignore;
783 {
784 if (def_symbol_in_progress == NULL)
785 {
786 as_warn (".scl pseudo-op used outside of .def/.endef ignored.");
787 demand_empty_rest_of_line ();
788 return;
789 } /* if not inside .def/.endef */
790
791 S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ());
792 demand_empty_rest_of_line ();
793 }
794
795 static void
796 obj_coff_tag (ignore)
797 int ignore;
798 {
799 char *symbol_name;
800 char name_end;
801
802 if (def_symbol_in_progress == NULL)
803 {
804 as_warn (".tag pseudo-op used outside of .def/.endef ignored.");
805 demand_empty_rest_of_line ();
806 return;
807 }
808
809 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
810 symbol_name = input_line_pointer;
811 name_end = get_symbol_end ();
812
813 /* Assume that the symbol referred to by .tag is always defined.
814 This was a bad assumption. I've added find_or_make. xoxorich. */
815 SA_SET_SYM_TAGNDX (def_symbol_in_progress,
816 tag_find_or_make (symbol_name));
817 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L)
818 {
819 as_warn ("tag not found for .tag %s", symbol_name);
820 } /* not defined */
821
822 SF_SET_TAGGED (def_symbol_in_progress);
823 *input_line_pointer = name_end;
824
825 demand_empty_rest_of_line ();
826 }
827
828 static void
829 obj_coff_type (ignore)
830 int ignore;
831 {
832 if (def_symbol_in_progress == NULL)
833 {
834 as_warn (".type pseudo-op used outside of .def/.endef ignored.");
835 demand_empty_rest_of_line ();
836 return;
837 } /* if not inside .def/.endef */
838
839 S_SET_DATA_TYPE (def_symbol_in_progress, get_absolute_expression ());
840
841 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress)) &&
842 S_GET_STORAGE_CLASS (def_symbol_in_progress) != C_TPDEF)
843 {
844 SF_SET_FUNCTION (def_symbol_in_progress);
845 } /* is a function */
846
847 demand_empty_rest_of_line ();
848 }
849
850 static void
851 obj_coff_val (ignore)
852 int ignore;
853 {
854 if (def_symbol_in_progress == NULL)
855 {
856 as_warn (".val pseudo-op used outside of .def/.endef ignored.");
857 demand_empty_rest_of_line ();
858 return;
859 } /* if not inside .def/.endef */
860
861 if (is_name_beginner (*input_line_pointer))
862 {
863 char *symbol_name = input_line_pointer;
864 char name_end = get_symbol_end ();
865
866 if (!strcmp (symbol_name, "."))
867 {
868 def_symbol_in_progress->sy_frag = frag_now;
869 S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
870 /* If the .val is != from the .def (e.g. statics) */
871 }
872 else if (strcmp (S_GET_NAME (def_symbol_in_progress), symbol_name))
873 {
874 def_symbol_in_progress->sy_value.X_op = O_symbol;
875 def_symbol_in_progress->sy_value.X_add_symbol =
876 symbol_find_or_make (symbol_name);
877 def_symbol_in_progress->sy_value.X_op_symbol = NULL;
878 def_symbol_in_progress->sy_value.X_add_number = 0;
879
880 /* If the segment is undefined when the forward reference is
881 resolved, then copy the segment id from the forward
882 symbol. */
883 SF_SET_GET_SEGMENT (def_symbol_in_progress);
884 }
885 /* Otherwise, it is the name of a non debug symbol and its value will be calculated later. */
886 *input_line_pointer = name_end;
887 }
888 else
889 {
890 S_SET_VALUE (def_symbol_in_progress, get_absolute_expression ());
891 } /* if symbol based */
892
893 demand_empty_rest_of_line ();
894 }
895
896 void
897 obj_read_begin_hook ()
898 {
899 /* These had better be the same. Usually 18 bytes. */
900 #ifndef BFD_HEADERS
901 know (sizeof (SYMENT) == sizeof (AUXENT));
902 know (SYMESZ == AUXESZ);
903 #endif
904 tag_init ();
905 }
906
907
908 symbolS *coff_last_function;
909
910 void
911 coff_frob_symbol (symp, punt)
912 symbolS *symp;
913 int *punt;
914 {
915 static symbolS *last_tagP;
916 static stack *block_stack;
917 static symbolS *set_end;
918
919 if (symp == &abs_symbol)
920 {
921 *punt = 1;
922 return;
923 }
924
925 if (current_lineno_sym)
926 coff_add_linesym ((symbolS *) 0);
927
928 if (!block_stack)
929 block_stack = stack_init (512, sizeof (symbolS*));
930
931 if (!S_IS_DEFINED (symp) && S_GET_STORAGE_CLASS (symp) != C_STAT)
932 S_SET_STORAGE_CLASS (symp, C_EXT);
933
934 if (!SF_GET_DEBUG (symp))
935 {
936 symbolS *real;
937 if (!SF_GET_LOCAL (symp)
938 && (real = symbol_find_base (S_GET_NAME (symp), DO_NOT_STRIP))
939 && real != symp)
940 {
941 c_symbol_merge (symp, real);
942 *punt = 1;
943 }
944 if (!S_IS_DEFINED (symp) && !SF_GET_LOCAL (symp))
945 {
946 assert (S_GET_VALUE (symp) == 0);
947 S_SET_EXTERNAL (symp);
948 }
949 else if (S_GET_STORAGE_CLASS (symp) == C_NULL)
950 {
951 if (S_GET_SEGMENT (symp) == text_section
952 && symp != seg_info (text_section)->sym)
953 S_SET_STORAGE_CLASS (symp, C_LABEL);
954 else
955 S_SET_STORAGE_CLASS (symp, C_STAT);
956 }
957 if (SF_GET_PROCESS (symp))
958 {
959 if (S_GET_STORAGE_CLASS (symp) == C_BLOCK)
960 {
961 if (!strcmp (S_GET_NAME (symp), ".bb"))
962 stack_push (block_stack, (char *) &symp);
963 else
964 {
965 symbolS *begin;
966 begin = *(symbolS **) stack_pop (block_stack);
967 if (begin == 0)
968 as_warn ("mismatched .eb");
969 else
970 set_end = begin;
971 }
972 }
973 if (coff_last_function == 0 && SF_GET_FUNCTION (symp))
974 {
975 union internal_auxent *auxp;
976 coff_last_function = symp;
977 if (S_GET_NUMBER_AUXILIARY (symp) < 1)
978 S_SET_NUMBER_AUXILIARY (symp, 1);
979 auxp = &coffsymbol (symp->bsym)->native[1].u.auxent;
980 memset (auxp->x_sym.x_fcnary.x_ary.x_dimen, 0,
981 sizeof (auxp->x_sym.x_fcnary.x_ary.x_dimen));
982 }
983 if (S_GET_STORAGE_CLASS (symp) == C_EFCN)
984 {
985 if (coff_last_function == 0)
986 as_fatal ("C_EFCN symbol out of scope");
987 SA_SET_SYM_FSIZE (coff_last_function,
988 (long) (S_GET_VALUE (symp)
989 - S_GET_VALUE (coff_last_function)));
990 set_end = coff_last_function;
991 coff_last_function = 0;
992 }
993 }
994 else if (SF_GET_TAG (symp))
995 last_tagP = symp;
996 else if (S_GET_STORAGE_CLASS (symp) == C_EOS)
997 set_end = last_tagP;
998 else if (S_GET_STORAGE_CLASS (symp) == C_FILE)
999 {
1000 if (S_GET_VALUE (symp))
1001 {
1002 S_SET_VALUE ((symbolS *) S_GET_VALUE (symp), 0xdeadbeef);
1003 S_SET_VALUE (symp, 0);
1004 }
1005 }
1006 if (S_IS_EXTERNAL (symp))
1007 S_SET_STORAGE_CLASS (symp, C_EXT);
1008 else if (SF_GET_LOCAL (symp))
1009 *punt = 1;
1010 /* more ... */
1011 }
1012
1013 if (set_end != (symbolS *) NULL
1014 && ! *punt)
1015 {
1016 SA_SET_SYM_ENDNDX (set_end, symp);
1017 set_end = NULL;
1018 }
1019
1020 if (coffsymbol (symp->bsym)->lineno)
1021 {
1022 int i;
1023 struct line_no *lptr;
1024 alent *l;
1025
1026 lptr = (struct line_no *) coffsymbol (symp->bsym)->lineno;
1027 for (i = 0; lptr; lptr = lptr->next)
1028 i++;
1029 lptr = (struct line_no *) coffsymbol (symp->bsym)->lineno;
1030
1031 /* We need i entries for line numbers, plus 1 for the first
1032 entry which BFD will override, plus 1 for the last zero
1033 entry (a marker for BFD). */
1034 l = (alent *) bfd_alloc_by_size_t (stdoutput, (i + 2) * sizeof (alent));
1035 coffsymbol (symp->bsym)->lineno = l;
1036 l[i + 1].line_number = 0;
1037 l[i + 1].u.sym = NULL;
1038 for (; i > 0; i--)
1039 {
1040 if (lptr->frag)
1041 lptr->l.u.offset += lptr->frag->fr_address;
1042 l[i] = lptr->l;
1043 lptr = lptr->next;
1044 }
1045 }
1046 }
1047
1048 void
1049 coff_adjust_section_syms (abfd, sec, x)
1050 bfd *abfd;
1051 asection *sec;
1052 PTR x;
1053 {
1054 symbolS *secsym;
1055 segment_info_type *seginfo = seg_info (sec);
1056 int nlnno, nrelocs = 0;
1057
1058 /* RS/6000 gas creates a .debug section manually in ppc_frob_file in
1059 tc-ppc.c. Do not get confused by it. */
1060 if (seginfo == NULL)
1061 return;
1062
1063 if (!strcmp (sec->name, ".text"))
1064 nlnno = n_line_nos;
1065 else
1066 nlnno = 0;
1067 {
1068 /* @@ Hope that none of the fixups expand to more than one reloc
1069 entry... */
1070 fixS *fixp = seginfo->fix_root;
1071 while (fixp)
1072 {
1073 fixp = fixp->fx_next;
1074 nrelocs++;
1075 }
1076 }
1077 if (bfd_get_section_size_before_reloc (sec) == 0
1078 && nrelocs == 0 && nlnno == 0)
1079 return;
1080 secsym = section_symbol (sec);
1081 SA_SET_SCN_NRELOC (secsym, nrelocs);
1082 SA_SET_SCN_NLINNO (secsym, nlnno);
1083 }
1084
1085 void
1086 coff_frob_file ()
1087 {
1088 bfd_map_over_sections (stdoutput, coff_adjust_section_syms, (char*) 0);
1089 }
1090
1091 /*
1092 * implement the .section pseudo op:
1093 * .section name {, "flags"}
1094 * ^ ^
1095 * | +--- optional flags: 'b' for bss
1096 * | 'i' for info
1097 * +-- section name 'l' for lib
1098 * 'n' for noload
1099 * 'o' for over
1100 * 'w' for data
1101 * 'd' (apparently m88k for data)
1102 * 'x' for text
1103 * But if the argument is not a quoted string, treat it as a
1104 * subsegment number.
1105 */
1106
1107 void
1108 obj_coff_section (ignore)
1109 int ignore;
1110 {
1111 /* Strip out the section name */
1112 char *section_name;
1113 char c;
1114 char *name;
1115 unsigned int exp;
1116 flagword flags;
1117 asection *sec;
1118
1119 section_name = input_line_pointer;
1120 c = get_symbol_end ();
1121
1122 name = xmalloc (input_line_pointer - section_name + 1);
1123 strcpy (name, section_name);
1124
1125 *input_line_pointer = c;
1126
1127 SKIP_WHITESPACE ();
1128
1129 exp = 0;
1130 flags = SEC_NO_FLAGS;
1131
1132 if (*input_line_pointer == ',')
1133 {
1134 ++input_line_pointer;
1135 SKIP_WHITESPACE ();
1136 if (*input_line_pointer != '"')
1137 exp = get_absolute_expression ();
1138 else
1139 {
1140 ++input_line_pointer;
1141 while (*input_line_pointer != '"'
1142 && ! is_end_of_line[(unsigned char) *input_line_pointer])
1143 {
1144 switch (*input_line_pointer)
1145 {
1146 case 'b': flags |= SEC_ALLOC; flags &=~ SEC_LOAD; break;
1147 case 'n': flags &=~ SEC_LOAD; break;
1148 case 'd':
1149 case 'w': flags &=~ SEC_READONLY; break;
1150 case 'x': flags |= SEC_CODE; break;
1151
1152 case 'i': /* STYP_INFO */
1153 case 'l': /* STYP_LIB */
1154 case 'o': /* STYP_OVER */
1155 as_warn ("unsupported section attribute '%c'",
1156 *input_line_pointer);
1157 break;
1158
1159 default:
1160 as_warn("unknown section attribute '%c'",
1161 *input_line_pointer);
1162 break;
1163 }
1164 ++input_line_pointer;
1165 }
1166 if (*input_line_pointer == '"')
1167 ++input_line_pointer;
1168 }
1169 }
1170
1171 sec = subseg_new (name, (subsegT) exp);
1172
1173 if (flags != SEC_NO_FLAGS)
1174 {
1175 if (! bfd_set_section_flags (stdoutput, sec, flags))
1176 as_warn ("error setting flags for \"%s\": %s",
1177 bfd_section_name (stdoutput, sec),
1178 bfd_errmsg (bfd_get_error ()));
1179 }
1180 }
1181
1182 void
1183 coff_adjust_symtab ()
1184 {
1185 if (symbol_rootP == NULL
1186 || S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
1187 {
1188 assert (previous_file_symbol == 0);
1189 c_dot_file_symbol ("fake");
1190 }
1191 }
1192
1193 void
1194 coff_frob_section (sec)
1195 segT sec;
1196 {
1197 segT strsec;
1198 char *strname, *p;
1199 fragS *fragp;
1200 bfd_vma size, n_entries, mask;
1201
1202 /* The COFF back end in BFD requires that all section sizes be
1203 rounded up to multiples of the corresponding section alignments.
1204 Seems kinda silly to me, but that's the way it is. */
1205 size = bfd_get_section_size_before_reloc (sec);
1206 mask = ((bfd_vma) 1 << (bfd_vma) sec->alignment_power) - 1;
1207 if (size & mask)
1208 {
1209 size = (size + mask) & ~mask;
1210 bfd_set_section_size (stdoutput, sec, size);
1211 }
1212
1213 /* If the section size is non-zero, the section symbol needs an aux
1214 entry associated with it, indicating the size. We don't know
1215 all the values yet; coff_frob_symbol will fill them in later. */
1216 if (size)
1217 {
1218 symbolS *secsym = section_symbol (sec);
1219
1220 S_SET_STORAGE_CLASS (secsym, C_STAT);
1221 S_SET_NUMBER_AUXILIARY (secsym, 1);
1222 SF_SET_STATICS (secsym);
1223 SA_SET_SCN_SCNLEN (secsym, size);
1224 }
1225
1226 /* @@ these should be in a "stabs.h" file, or maybe as.h */
1227 #ifndef STAB_SECTION_NAME
1228 #define STAB_SECTION_NAME ".stab"
1229 #endif
1230 #ifndef STAB_STRING_SECTION_NAME
1231 #define STAB_STRING_SECTION_NAME ".stabstr"
1232 #endif
1233 if (strcmp (STAB_STRING_SECTION_NAME, sec->name))
1234 return;
1235
1236 strsec = sec;
1237 sec = subseg_get (STAB_SECTION_NAME, 0);
1238 /* size is already rounded up, since other section will be listed first */
1239 size = bfd_get_section_size_before_reloc (strsec);
1240
1241 n_entries = bfd_get_section_size_before_reloc (sec) / 12 - 1;
1242
1243 /* Find first non-empty frag. It should be large enough. */
1244 fragp = seg_info (sec)->frchainP->frch_root;
1245 while (fragp && fragp->fr_fix == 0)
1246 fragp = fragp->fr_next;
1247 assert (fragp != 0 && fragp->fr_fix >= 12);
1248
1249 /* Store the values. */
1250 p = fragp->fr_literal;
1251 bfd_h_put_16 (stdoutput, n_entries, (bfd_byte *) p + 6);
1252 bfd_h_put_32 (stdoutput, size, (bfd_byte *) p + 8);
1253 }
1254
1255 void
1256 obj_coff_init_stab_section (seg)
1257 segT seg;
1258 {
1259 char *file;
1260 char *p;
1261 char *stabstr_name;
1262 unsigned int stroff;
1263
1264 /* Make space for this first symbol. */
1265 p = frag_more (12);
1266 /* Zero it out. */
1267 memset (p, 0, 12);
1268 as_where (&file, (unsigned int *) NULL);
1269 stabstr_name = (char *) alloca (strlen (seg->name) + 4);
1270 strcpy (stabstr_name, seg->name);
1271 strcat (stabstr_name, "str");
1272 stroff = get_stab_string_offset (file, stabstr_name);
1273 know (stroff == 1);
1274 md_number_to_chars (p, stroff, 4);
1275 }
1276
1277 #ifdef DEBUG
1278 /* for debugging */
1279 const char *
1280 s_get_name (s)
1281 symbolS *s;
1282 {
1283 return ((s == NULL) ? "(NULL)" : S_GET_NAME (s));
1284 }
1285
1286 void
1287 symbol_dump ()
1288 {
1289 symbolS *symbolP;
1290
1291 for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
1292 {
1293 printf("0x%lx: \"%s\" type = %ld, class = %d, segment = %d\n",
1294 (unsigned long) symbolP,
1295 S_GET_NAME(symbolP),
1296 (long) S_GET_DATA_TYPE(symbolP),
1297 S_GET_STORAGE_CLASS(symbolP),
1298 (int) S_GET_SEGMENT(symbolP));
1299 }
1300 }
1301
1302 #endif /* DEBUG */
1303
1304 #else /* not BFD_ASSEMBLER */
1305
1306 #include "frags.h"
1307 /* This is needed because we include internal bfd things. */
1308 #include <time.h>
1309 #include "bfd/libbfd.h"
1310 #include "bfd/libcoff.h"
1311
1312 /* The NOP_OPCODE is for the alignment fill value. Fill with nop so
1313 that we can stick sections together without causing trouble. */
1314 #ifndef NOP_OPCODE
1315 #define NOP_OPCODE 0x00
1316 #endif
1317
1318 /* The zeroes if symbol name is longer than 8 chars */
1319 #define S_SET_ZEROES(s,v) ((s)->sy_symbol.ost_entry.n_zeroes = (v))
1320
1321 #define MIN(a,b) ((a) < (b)? (a) : (b))
1322 /* This vector is used to turn an internal segment into a section #
1323 suitable for insertion into a coff symbol table
1324 */
1325
1326 const short seg_N_TYPE[] =
1327 { /* in: segT out: N_TYPE bits */
1328 C_ABS_SECTION,
1329 1,
1330 2,
1331 3,
1332 4,
1333 5,
1334 6,
1335 7,
1336 8,
1337 9,
1338 10,
1339 C_UNDEF_SECTION, /* SEG_UNKNOWN */
1340 C_UNDEF_SECTION, /* SEG_GOOF */
1341 C_UNDEF_SECTION, /* SEG_EXPR */
1342 C_DEBUG_SECTION, /* SEG_DEBUG */
1343 C_NTV_SECTION, /* SEG_NTV */
1344 C_PTV_SECTION, /* SEG_PTV */
1345 C_REGISTER_SECTION, /* SEG_REGISTER */
1346 };
1347
1348 int function_lineoff = -1; /* Offset in line#s where the last function
1349 started (the odd entry for line #0) */
1350
1351 static symbolS *last_line_symbol;
1352
1353 /* Add 4 to the real value to get the index and compensate the
1354 negatives. This vector is used by S_GET_SEGMENT to turn a coff
1355 section number into a segment number
1356 */
1357 static symbolS *previous_file_symbol;
1358 void c_symbol_merge ();
1359 static int line_base;
1360
1361 symbolS *c_section_symbol ();
1362 bfd *abfd;
1363
1364 static void fixup_segment PARAMS ((segment_info_type *segP,
1365 segT this_segment_type));
1366
1367
1368 static void fixup_mdeps PARAMS ((fragS *,
1369 object_headers *,
1370 segT));
1371
1372
1373 static void fill_section PARAMS ((bfd * abfd,
1374 object_headers *,
1375 unsigned long *));
1376
1377
1378 static int c_line_new PARAMS ((symbolS * symbol, long paddr,
1379 int line_number,
1380 fragS * frag));
1381
1382
1383 static void w_symbols PARAMS ((bfd * abfd, char *where,
1384 symbolS * symbol_rootP));
1385
1386 static void adjust_stab_section PARAMS ((bfd *abfd, segT seg));
1387
1388 static void obj_coff_lcomm PARAMS ((int));
1389 static void obj_coff_text PARAMS ((int));
1390 static void obj_coff_data PARAMS ((int));
1391 static void obj_coff_bss PARAMS ((int));
1392 static void obj_coff_ident PARAMS ((int));
1393 void obj_coff_section PARAMS ((int));
1394
1395 /* Section stuff
1396
1397 We allow more than just the standard 3 sections, infact, we allow
1398 10 sections, (though the usual three have to be there).
1399
1400 This structure performs the mappings for us:
1401
1402 */
1403
1404 #define N_SEG 32
1405 typedef struct
1406 {
1407 segT seg_t;
1408 int i;
1409 } seg_info_type;
1410
1411 static const seg_info_type seg_info_off_by_4[N_SEG] =
1412 {
1413 {SEG_PTV, },
1414 {SEG_NTV, },
1415 {SEG_DEBUG, },
1416 {SEG_ABSOLUTE, },
1417 {SEG_UNKNOWN, },
1418 {SEG_E0},
1419 {SEG_E1},
1420 {SEG_E2},
1421 {SEG_E3},
1422 {SEG_E4},
1423 {SEG_E5},
1424 {SEG_E6},
1425 {SEG_E7},
1426 {SEG_E8},
1427 {SEG_E9},
1428 {(segT)15},
1429 {(segT)16},
1430 {(segT)17},
1431 {(segT)18},
1432 {(segT)19},
1433 {(segT)20},
1434 {(segT)0},
1435 {(segT)0},
1436 {(segT)0},
1437 {SEG_REGISTER}
1438 };
1439
1440
1441
1442 #define SEG_INFO_FROM_SECTION_NUMBER(x) (seg_info_off_by_4[(x)+4])
1443
1444 static relax_addressT
1445 relax_align (address, alignment)
1446 relax_addressT address;
1447 long alignment;
1448 {
1449 relax_addressT mask;
1450 relax_addressT new_address;
1451
1452 mask = ~((~0) << alignment);
1453 new_address = (address + mask) & (~mask);
1454 return (new_address - address);
1455 }
1456
1457
1458 segT
1459 s_get_segment (x)
1460 symbolS * x;
1461 {
1462 return SEG_INFO_FROM_SECTION_NUMBER (x->sy_symbol.ost_entry.n_scnum).seg_t;
1463 }
1464
1465
1466
1467 /* calculate the size of the frag chain and fill in the section header
1468 to contain all of it, also fill in the addr of the sections */
1469 static unsigned int
1470 size_section (abfd, idx)
1471 bfd * abfd;
1472 unsigned int idx;
1473 {
1474
1475 unsigned int size = 0;
1476 fragS *frag = segment_info[idx].frchainP->frch_root;
1477 while (frag)
1478 {
1479 size = frag->fr_address;
1480 if (frag->fr_address != size)
1481 {
1482 fprintf (stderr, "Out of step\n");
1483 size = frag->fr_address;
1484 }
1485
1486 switch (frag->fr_type)
1487 {
1488 #ifdef TC_COFF_SIZEMACHDEP
1489 case rs_machine_dependent:
1490 size += TC_COFF_SIZEMACHDEP (frag);
1491 break;
1492 #endif
1493 case rs_space:
1494 assert (frag->fr_symbol == 0);
1495 case rs_fill:
1496 case rs_org:
1497 size += frag->fr_fix;
1498 size += frag->fr_offset * frag->fr_var;
1499 break;
1500 case rs_align:
1501 size += frag->fr_fix;
1502 size += relax_align (size, frag->fr_offset);
1503 break;
1504 default:
1505 BAD_CASE (frag->fr_type);
1506 break;
1507 }
1508 frag = frag->fr_next;
1509 }
1510 segment_info[idx].scnhdr.s_size = size;
1511 return size;
1512 }
1513
1514
1515 static unsigned int
1516 count_entries_in_chain (idx)
1517 unsigned int idx;
1518 {
1519 unsigned int nrelocs;
1520 fixS *fixup_ptr;
1521
1522 /* Count the relocations */
1523 fixup_ptr = segment_info[idx].fix_root;
1524 nrelocs = 0;
1525 while (fixup_ptr != (fixS *) NULL)
1526 {
1527 if (TC_COUNT_RELOC (fixup_ptr))
1528 {
1529 #ifdef TC_A29K
1530 if (fixup_ptr->fx_r_type == RELOC_CONSTH)
1531 nrelocs += 2;
1532 else
1533 nrelocs++;
1534 #else
1535 nrelocs++;
1536 #endif
1537 }
1538
1539 fixup_ptr = fixup_ptr->fx_next;
1540 }
1541 return nrelocs;
1542 }
1543
1544 /* output all the relocations for a section */
1545 void
1546 do_relocs_for (abfd, h, file_cursor)
1547 bfd * abfd;
1548 object_headers * h;
1549 unsigned long *file_cursor;
1550 {
1551 unsigned int nrelocs;
1552 unsigned int idx;
1553 unsigned long reloc_start = *file_cursor;
1554
1555 for (idx = SEG_E0; idx < SEG_E9; idx++)
1556 {
1557 if (segment_info[idx].scnhdr.s_name[0])
1558 {
1559 struct external_reloc *ext_ptr;
1560 struct external_reloc *external_reloc_vec;
1561 unsigned int external_reloc_size;
1562 unsigned int base = segment_info[idx].scnhdr.s_paddr;
1563 fixS *fix_ptr = segment_info[idx].fix_root;
1564 nrelocs = count_entries_in_chain (idx);
1565
1566 if (nrelocs)
1567 /* Bypass this stuff if no relocs. This also incidentally
1568 avoids a SCO bug, where free(malloc(0)) tends to crash. */
1569 {
1570 external_reloc_size = nrelocs * RELSZ;
1571 external_reloc_vec =
1572 (struct external_reloc *) malloc (external_reloc_size);
1573
1574 ext_ptr = external_reloc_vec;
1575
1576 /* Fill in the internal coff style reloc struct from the
1577 internal fix list. */
1578 while (fix_ptr)
1579 {
1580 struct internal_reloc intr;
1581
1582 /* Only output some of the relocations */
1583 if (TC_COUNT_RELOC (fix_ptr))
1584 {
1585 #ifdef TC_RELOC_MANGLE
1586 TC_RELOC_MANGLE (fix_ptr, &intr, base);
1587
1588 #else
1589 symbolS *dot;
1590 symbolS *symbol_ptr = fix_ptr->fx_addsy;
1591
1592 intr.r_type = TC_COFF_FIX2RTYPE (fix_ptr);
1593 intr.r_vaddr =
1594 base + fix_ptr->fx_frag->fr_address + fix_ptr->fx_where;
1595
1596 #ifdef TC_KEEP_FX_OFFSET
1597 intr.r_offset = fix_ptr->fx_offset;
1598 #else
1599 intr.r_offset = 0;
1600 #endif
1601
1602 /* Turn the segment of the symbol into an offset. */
1603 if (symbol_ptr)
1604 {
1605 dot = segment_info[S_GET_SEGMENT (symbol_ptr)].dot;
1606 if (dot)
1607 {
1608 intr.r_symndx = dot->sy_number;
1609 }
1610 else
1611 {
1612 intr.r_symndx = symbol_ptr->sy_number;
1613 }
1614
1615 }
1616 else
1617 {
1618 intr.r_symndx = -1;
1619 }
1620 #endif
1621
1622 (void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
1623 ext_ptr++;
1624
1625 #if defined(TC_A29K)
1626
1627 /* The 29k has a special kludge for the high 16 bit
1628 reloc. Two relocations are emited, R_IHIHALF,
1629 and R_IHCONST. The second one doesn't contain a
1630 symbol, but uses the value for offset. */
1631
1632 if (intr.r_type == R_IHIHALF)
1633 {
1634 /* now emit the second bit */
1635 intr.r_type = R_IHCONST;
1636 intr.r_symndx = fix_ptr->fx_addnumber;
1637 (void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
1638 ext_ptr++;
1639 }
1640 #endif
1641 }
1642
1643 fix_ptr = fix_ptr->fx_next;
1644 }
1645
1646 /* Write out the reloc table */
1647 bfd_write ((PTR) external_reloc_vec, 1, external_reloc_size,
1648 abfd);
1649 free (external_reloc_vec);
1650
1651 /* Fill in section header info. */
1652 segment_info[idx].scnhdr.s_relptr = *file_cursor;
1653 *file_cursor += external_reloc_size;
1654 segment_info[idx].scnhdr.s_nreloc = nrelocs;
1655 }
1656 else
1657 {
1658 /* No relocs */
1659 segment_info[idx].scnhdr.s_relptr = 0;
1660 }
1661 }
1662 }
1663 /* Set relocation_size field in file headers */
1664 H_SET_RELOCATION_SIZE (h, *file_cursor - reloc_start, 0);
1665 }
1666
1667
1668 /* run through a frag chain and write out the data to go with it, fill
1669 in the scnhdrs with the info on the file postions
1670 */
1671 static void
1672 fill_section (abfd, h, file_cursor)
1673 bfd * abfd;
1674 object_headers *h;
1675 unsigned long *file_cursor;
1676 {
1677
1678 unsigned int i;
1679 unsigned int paddr = 0;
1680
1681 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
1682 {
1683 unsigned int offset = 0;
1684
1685 struct internal_scnhdr *s = &(segment_info[i].scnhdr);
1686
1687 if (s->s_name[0])
1688 {
1689 fragS *frag = segment_info[i].frchainP->frch_root;
1690 char *buffer;
1691
1692 if (s->s_size == 0)
1693 s->s_scnptr = 0;
1694 else
1695 {
1696 buffer = xmalloc (s->s_size);
1697 s->s_scnptr = *file_cursor;
1698 }
1699 know (s->s_paddr == paddr);
1700
1701 if (strcmp (s->s_name, ".text") == 0)
1702 s->s_flags |= STYP_TEXT;
1703 else if (strcmp (s->s_name, ".data") == 0)
1704 s->s_flags |= STYP_DATA;
1705 else if (strcmp (s->s_name, ".bss") == 0)
1706 {
1707 s->s_scnptr = 0;
1708 s->s_flags |= STYP_BSS;
1709
1710 /* @@ Should make the i386 and a29k coff targets define
1711 COFF_NOLOAD_PROBLEM, and have only one test here. */
1712 #ifndef TC_I386
1713 #ifndef TC_A29K
1714 #ifndef COFF_NOLOAD_PROBLEM
1715 /* Apparently the SVR3 linker (and exec syscall) and UDI
1716 mondfe progrem are confused by noload sections. */
1717 s->s_flags |= STYP_NOLOAD;
1718 #endif
1719 #endif
1720 #endif
1721 }
1722 else if (strcmp (s->s_name, ".lit") == 0)
1723 s->s_flags = STYP_LIT | STYP_TEXT;
1724 else if (strcmp (s->s_name, ".init") == 0)
1725 s->s_flags |= STYP_TEXT;
1726 else if (strcmp (s->s_name, ".fini") == 0)
1727 s->s_flags |= STYP_TEXT;
1728 else if (strncmp (s->s_name, ".comment", 8) == 0)
1729 s->s_flags |= STYP_INFO;
1730
1731 while (frag)
1732 {
1733 unsigned int fill_size;
1734 switch (frag->fr_type)
1735 {
1736 case rs_machine_dependent:
1737 if (frag->fr_fix)
1738 {
1739 memcpy (buffer + frag->fr_address,
1740 frag->fr_literal,
1741 (unsigned int) frag->fr_fix);
1742 offset += frag->fr_fix;
1743 }
1744
1745 break;
1746 case rs_space:
1747 assert (frag->fr_symbol == 0);
1748 case rs_fill:
1749 case rs_align:
1750 case rs_org:
1751 if (frag->fr_fix)
1752 {
1753 memcpy (buffer + frag->fr_address,
1754 frag->fr_literal,
1755 (unsigned int) frag->fr_fix);
1756 offset += frag->fr_fix;
1757 }
1758
1759 fill_size = frag->fr_var;
1760 if (fill_size && frag->fr_offset > 0)
1761 {
1762 unsigned int count;
1763 unsigned int off = frag->fr_fix;
1764 for (count = frag->fr_offset; count; count--)
1765 {
1766 if (fill_size + frag->fr_address + off <= s->s_size)
1767 {
1768 memcpy (buffer + frag->fr_address + off,
1769 frag->fr_literal + frag->fr_fix,
1770 fill_size);
1771 off += fill_size;
1772 offset += fill_size;
1773 }
1774 }
1775 }
1776 break;
1777 case rs_broken_word:
1778 break;
1779 default:
1780 abort ();
1781 }
1782 frag = frag->fr_next;
1783 }
1784
1785 if (s->s_size != 0)
1786 {
1787 if (s->s_scnptr != 0)
1788 {
1789 bfd_write (buffer, s->s_size, 1, abfd);
1790 *file_cursor += s->s_size;
1791 }
1792 free (buffer);
1793 }
1794 paddr += s->s_size;
1795 }
1796 }
1797 }
1798
1799 /* Coff file generation & utilities */
1800
1801 static void
1802 coff_header_append (abfd, h)
1803 bfd * abfd;
1804 object_headers * h;
1805 {
1806 unsigned int i;
1807 char buffer[1000];
1808 char buffero[1000];
1809
1810 bfd_seek (abfd, 0, 0);
1811
1812 #ifndef OBJ_COFF_OMIT_OPTIONAL_HEADER
1813 H_SET_MAGIC_NUMBER (h, COFF_MAGIC);
1814 H_SET_VERSION_STAMP (h, 0);
1815 H_SET_ENTRY_POINT (h, 0);
1816 H_SET_TEXT_START (h, segment_info[SEG_E0].frchainP->frch_root->fr_address);
1817 H_SET_DATA_START (h, segment_info[SEG_E1].frchainP->frch_root->fr_address);
1818 H_SET_SIZEOF_OPTIONAL_HEADER (h, bfd_coff_swap_aouthdr_out(abfd, &h->aouthdr,
1819 buffero));
1820 #else /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
1821 H_SET_SIZEOF_OPTIONAL_HEADER (h, 0);
1822 #endif /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
1823
1824 i = bfd_coff_swap_filehdr_out (abfd, &h->filehdr, buffer);
1825
1826 bfd_write (buffer, i, 1, abfd);
1827 bfd_write (buffero, H_GET_SIZEOF_OPTIONAL_HEADER (h), 1, abfd);
1828
1829 for (i = SEG_E0; i < SEG_E9; i++)
1830 {
1831 if (segment_info[i].scnhdr.s_name[0])
1832 {
1833 unsigned int size =
1834 bfd_coff_swap_scnhdr_out (abfd,
1835 &(segment_info[i].scnhdr),
1836 buffer);
1837 bfd_write (buffer, size, 1, abfd);
1838 }
1839 }
1840 }
1841
1842
1843 char *
1844 symbol_to_chars (abfd, where, symbolP)
1845 bfd * abfd;
1846 char *where;
1847 symbolS * symbolP;
1848 {
1849 unsigned int numaux = symbolP->sy_symbol.ost_entry.n_numaux;
1850 unsigned int i;
1851 valueT val;
1852
1853 /* Turn any symbols with register attributes into abs symbols */
1854 if (S_GET_SEGMENT (symbolP) == reg_section)
1855 {
1856 S_SET_SEGMENT (symbolP, absolute_section);
1857 }
1858 /* At the same time, relocate all symbols to their output value */
1859
1860 val = (segment_info[S_GET_SEGMENT (symbolP)].scnhdr.s_paddr
1861 + S_GET_VALUE (symbolP));
1862
1863 S_SET_VALUE (symbolP, val);
1864
1865 symbolP->sy_symbol.ost_entry.n_value = val;
1866
1867 where += bfd_coff_swap_sym_out (abfd, &symbolP->sy_symbol.ost_entry,
1868 where);
1869
1870 for (i = 0; i < numaux; i++)
1871 {
1872 where += bfd_coff_swap_aux_out (abfd,
1873 &symbolP->sy_symbol.ost_auxent[i],
1874 S_GET_DATA_TYPE (symbolP),
1875 S_GET_STORAGE_CLASS (symbolP),
1876 i, numaux, where);
1877 }
1878 return where;
1879
1880 }
1881
1882 void
1883 obj_symbol_new_hook (symbolP)
1884 symbolS *symbolP;
1885 {
1886 char underscore = 0; /* Symbol has leading _ */
1887
1888 /* Effective symbol */
1889 /* Store the pointer in the offset. */
1890 S_SET_ZEROES (symbolP, 0L);
1891 S_SET_DATA_TYPE (symbolP, T_NULL);
1892 S_SET_STORAGE_CLASS (symbolP, 0);
1893 S_SET_NUMBER_AUXILIARY (symbolP, 0);
1894 /* Additional information */
1895 symbolP->sy_symbol.ost_flags = 0;
1896 /* Auxiliary entries */
1897 memset ((char *) &symbolP->sy_symbol.ost_auxent[0], 0, AUXESZ);
1898
1899 if (S_IS_STRING (symbolP))
1900 SF_SET_STRING (symbolP);
1901 if (!underscore && S_IS_LOCAL (symbolP))
1902 SF_SET_LOCAL (symbolP);
1903 }
1904
1905 /*
1906 * Handle .ln directives.
1907 */
1908
1909 static void
1910 obj_coff_ln (appline)
1911 int appline;
1912 {
1913 int l;
1914
1915 if (! appline && def_symbol_in_progress != NULL)
1916 {
1917 as_warn (".ln pseudo-op inside .def/.endef: ignored.");
1918 demand_empty_rest_of_line ();
1919 return;
1920 } /* wrong context */
1921
1922 l = get_absolute_expression ();
1923 c_line_new (0, frag_now_fix (), l, frag_now);
1924 #ifndef NO_LISTING
1925 {
1926 extern int listing;
1927
1928 if (listing)
1929 {
1930 if (! appline)
1931 l += line_base - 1;
1932 listing_source_line ((unsigned int) l);
1933 }
1934
1935 }
1936 #endif
1937 demand_empty_rest_of_line ();
1938 }
1939
1940 /*
1941 * def()
1942 *
1943 * Handle .def directives.
1944 *
1945 * One might ask : why can't we symbol_new if the symbol does not
1946 * already exist and fill it with debug information. Because of
1947 * the C_EFCN special symbol. It would clobber the value of the
1948 * function symbol before we have a chance to notice that it is
1949 * a C_EFCN. And a second reason is that the code is more clear this
1950 * way. (at least I think it is :-).
1951 *
1952 */
1953
1954 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
1955 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
1956 *input_line_pointer == '\t') \
1957 input_line_pointer++;
1958
1959 static void
1960 obj_coff_def (what)
1961 int what;
1962 {
1963 char name_end; /* Char after the end of name */
1964 char *symbol_name; /* Name of the debug symbol */
1965 char *symbol_name_copy; /* Temporary copy of the name */
1966 unsigned int symbol_name_length;
1967
1968 if (def_symbol_in_progress != NULL)
1969 {
1970 as_warn (".def pseudo-op used inside of .def/.endef: ignored.");
1971 demand_empty_rest_of_line ();
1972 return;
1973 } /* if not inside .def/.endef */
1974
1975 SKIP_WHITESPACES ();
1976
1977 def_symbol_in_progress = (symbolS *) obstack_alloc (&notes, sizeof (*def_symbol_in_progress));
1978 memset (def_symbol_in_progress, 0, sizeof (*def_symbol_in_progress));
1979
1980 symbol_name = input_line_pointer;
1981 name_end = get_symbol_end ();
1982 symbol_name_length = strlen (symbol_name);
1983 symbol_name_copy = xmalloc (symbol_name_length + 1);
1984 strcpy (symbol_name_copy, symbol_name);
1985
1986 /* Initialize the new symbol */
1987 #ifdef STRIP_UNDERSCORE
1988 S_SET_NAME (def_symbol_in_progress, (*symbol_name_copy == '_'
1989 ? symbol_name_copy + 1
1990 : symbol_name_copy));
1991 #else /* STRIP_UNDERSCORE */
1992 S_SET_NAME (def_symbol_in_progress, symbol_name_copy);
1993 #endif /* STRIP_UNDERSCORE */
1994 /* free(symbol_name_copy); */
1995 def_symbol_in_progress->sy_name_offset = (unsigned long) ~0;
1996 def_symbol_in_progress->sy_number = ~0;
1997 def_symbol_in_progress->sy_frag = &zero_address_frag;
1998 S_SET_VALUE (def_symbol_in_progress, 0);
1999
2000 if (S_IS_STRING (def_symbol_in_progress))
2001 SF_SET_STRING (def_symbol_in_progress);
2002
2003 *input_line_pointer = name_end;
2004
2005 demand_empty_rest_of_line ();
2006 }
2007
2008 unsigned int dim_index;
2009
2010
2011 static void
2012 obj_coff_endef (ignore)
2013 int ignore;
2014 {
2015 symbolS *symbolP = 0;
2016 /* DIM BUG FIX sac@cygnus.com */
2017 dim_index = 0;
2018 if (def_symbol_in_progress == NULL)
2019 {
2020 as_warn (".endef pseudo-op used outside of .def/.endef: ignored.");
2021 demand_empty_rest_of_line ();
2022 return;
2023 } /* if not inside .def/.endef */
2024
2025 /* Set the section number according to storage class. */
2026 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))
2027 {
2028 case C_STRTAG:
2029 case C_ENTAG:
2030 case C_UNTAG:
2031 SF_SET_TAG (def_symbol_in_progress);
2032 /* intentional fallthrough */
2033 case C_FILE:
2034 case C_TPDEF:
2035 SF_SET_DEBUG (def_symbol_in_progress);
2036 S_SET_SEGMENT (def_symbol_in_progress, SEG_DEBUG);
2037 break;
2038
2039 case C_EFCN:
2040 SF_SET_LOCAL (def_symbol_in_progress); /* Do not emit this symbol. */
2041 /* intentional fallthrough */
2042 case C_BLOCK:
2043 SF_SET_PROCESS (def_symbol_in_progress); /* Will need processing before writing */
2044 /* intentional fallthrough */
2045 case C_FCN:
2046 S_SET_SEGMENT (def_symbol_in_progress, SEG_E0);
2047
2048 if (strcmp (S_GET_NAME (def_symbol_in_progress), ".bf") == 0)
2049 { /* .bf */
2050 if (function_lineoff < 0)
2051 {
2052 fprintf (stderr, "`.bf' symbol without preceding function\n");
2053 } /* missing function symbol */
2054 SA_GET_SYM_LNNOPTR (last_line_symbol) = function_lineoff;
2055
2056 SF_SET_PROCESS (last_line_symbol);
2057 function_lineoff = -1;
2058 }
2059 /* Value is always set to . */
2060 def_symbol_in_progress->sy_frag = frag_now;
2061 S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
2062 break;
2063
2064 #ifdef C_AUTOARG
2065 case C_AUTOARG:
2066 #endif /* C_AUTOARG */
2067 case C_AUTO:
2068 case C_REG:
2069 case C_MOS:
2070 case C_MOE:
2071 case C_MOU:
2072 case C_ARG:
2073 case C_REGPARM:
2074 case C_FIELD:
2075 case C_EOS:
2076 SF_SET_DEBUG (def_symbol_in_progress);
2077 S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
2078 break;
2079
2080 case C_EXT:
2081 case C_STAT:
2082 case C_LABEL:
2083 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
2084 break;
2085
2086 case C_USTATIC:
2087 case C_EXTDEF:
2088 case C_ULABEL:
2089 as_warn ("unexpected storage class %d", S_GET_STORAGE_CLASS (def_symbol_in_progress));
2090 break;
2091 } /* switch on storage class */
2092
2093 /* Now that we have built a debug symbol, try to find if we should
2094 merge with an existing symbol or not. If a symbol is C_EFCN or
2095 absolute_section or untagged SEG_DEBUG it never merges. We also
2096 don't merge labels, which are in a different namespace, nor
2097 symbols which have not yet been defined since they are typically
2098 unique, nor do we merge tags with non-tags. */
2099
2100 /* Two cases for functions. Either debug followed by definition or
2101 definition followed by debug. For definition first, we will
2102 merge the debug symbol into the definition. For debug first, the
2103 lineno entry MUST point to the definition function or else it
2104 will point off into space when crawl_symbols() merges the debug
2105 symbol into the real symbol. Therefor, let's presume the debug
2106 symbol is a real function reference. */
2107
2108 /* FIXME-SOON If for some reason the definition label/symbol is
2109 never seen, this will probably leave an undefined symbol at link
2110 time. */
2111
2112 if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN
2113 || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_LABEL
2114 || (S_GET_SEGMENT (def_symbol_in_progress) == SEG_DEBUG
2115 && !SF_GET_TAG (def_symbol_in_progress))
2116 || S_GET_SEGMENT (def_symbol_in_progress) == absolute_section
2117 || def_symbol_in_progress->sy_value.X_op != O_constant
2118 || (symbolP = symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP)) == NULL
2119 || (SF_GET_TAG (def_symbol_in_progress) != SF_GET_TAG (symbolP)))
2120 {
2121 symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP,
2122 &symbol_lastP);
2123 }
2124 else
2125 {
2126 /* This symbol already exists, merge the newly created symbol
2127 into the old one. This is not mandatory. The linker can
2128 handle duplicate symbols correctly. But I guess that it save
2129 a *lot* of space if the assembly file defines a lot of
2130 symbols. [loic] */
2131
2132 /* The debug entry (def_symbol_in_progress) is merged into the
2133 previous definition. */
2134
2135 c_symbol_merge (def_symbol_in_progress, symbolP);
2136 /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
2137 def_symbol_in_progress = symbolP;
2138
2139 if (SF_GET_FUNCTION (def_symbol_in_progress)
2140 || SF_GET_TAG (def_symbol_in_progress))
2141 {
2142 /* For functions, and tags, the symbol *must* be where the
2143 debug symbol appears. Move the existing symbol to the
2144 current place. */
2145 /* If it already is at the end of the symbol list, do nothing */
2146 if (def_symbol_in_progress != symbol_lastP)
2147 {
2148 symbol_remove (def_symbol_in_progress, &symbol_rootP,
2149 &symbol_lastP);
2150 symbol_append (def_symbol_in_progress, symbol_lastP,
2151 &symbol_rootP, &symbol_lastP);
2152 } /* if not already in place */
2153 } /* if function */
2154 } /* normal or mergable */
2155
2156 if (SF_GET_TAG (def_symbol_in_progress)
2157 && symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP) == NULL)
2158 {
2159 tag_insert (S_GET_NAME (def_symbol_in_progress), def_symbol_in_progress);
2160 }
2161
2162 if (SF_GET_FUNCTION (def_symbol_in_progress))
2163 {
2164 know (sizeof (def_symbol_in_progress) <= sizeof (long));
2165 function_lineoff
2166 = c_line_new (def_symbol_in_progress, 0, 0, &zero_address_frag);
2167
2168 SF_SET_PROCESS (def_symbol_in_progress);
2169
2170 if (symbolP == NULL)
2171 {
2172 /* That is, if this is the first time we've seen the
2173 function... */
2174 symbol_table_insert (def_symbol_in_progress);
2175 } /* definition follows debug */
2176 } /* Create the line number entry pointing to the function being defined */
2177
2178 def_symbol_in_progress = NULL;
2179 demand_empty_rest_of_line ();
2180 }
2181
2182 static void
2183 obj_coff_dim (ignore)
2184 int ignore;
2185 {
2186 int dim_index;
2187
2188 if (def_symbol_in_progress == NULL)
2189 {
2190 as_warn (".dim pseudo-op used outside of .def/.endef: ignored.");
2191 demand_empty_rest_of_line ();
2192 return;
2193 } /* if not inside .def/.endef */
2194
2195 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2196
2197 for (dim_index = 0; dim_index < DIMNUM; dim_index++)
2198 {
2199 SKIP_WHITESPACES ();
2200 SA_SET_SYM_DIMEN (def_symbol_in_progress, dim_index,
2201 get_absolute_expression ());
2202
2203 switch (*input_line_pointer)
2204 {
2205 case ',':
2206 input_line_pointer++;
2207 break;
2208
2209 default:
2210 as_warn ("badly formed .dim directive ignored");
2211 /* intentional fallthrough */
2212 case '\n':
2213 case ';':
2214 dim_index = DIMNUM;
2215 break;
2216 }
2217 }
2218
2219 demand_empty_rest_of_line ();
2220 }
2221
2222 static void
2223 obj_coff_line (ignore)
2224 int ignore;
2225 {
2226 int this_base;
2227 const char *name;
2228
2229 if (def_symbol_in_progress == NULL)
2230 {
2231 obj_coff_ln (0);
2232 return;
2233 }
2234
2235 name = S_GET_NAME (def_symbol_in_progress);
2236 this_base = get_absolute_expression ();
2237
2238 /* Only .bf symbols indicate the use of a new base line number; the
2239 line numbers associated with .ef, .bb, .eb are relative to the
2240 start of the containing function. */
2241 if (!strcmp (".bf", name))
2242 {
2243 #if 0 /* XXX Can we ever have line numbers going backwards? */
2244 if (this_base > line_base)
2245 #endif
2246 {
2247 line_base = this_base;
2248 }
2249
2250 #ifndef NO_LISTING
2251 {
2252 extern int listing;
2253 if (listing && 0)
2254 {
2255 listing_source_line ((unsigned int) line_base);
2256 }
2257 }
2258 #endif
2259 }
2260
2261 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2262 SA_SET_SYM_LNNO (def_symbol_in_progress, this_base);
2263
2264 demand_empty_rest_of_line ();
2265 }
2266
2267 static void
2268 obj_coff_size (ignore)
2269 int ignore;
2270 {
2271 if (def_symbol_in_progress == NULL)
2272 {
2273 as_warn (".size pseudo-op used outside of .def/.endef ignored.");
2274 demand_empty_rest_of_line ();
2275 return;
2276 } /* if not inside .def/.endef */
2277
2278 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2279 SA_SET_SYM_SIZE (def_symbol_in_progress, get_absolute_expression ());
2280 demand_empty_rest_of_line ();
2281 }
2282
2283 static void
2284 obj_coff_scl (ignore)
2285 int ignore;
2286 {
2287 if (def_symbol_in_progress == NULL)
2288 {
2289 as_warn (".scl pseudo-op used outside of .def/.endef ignored.");
2290 demand_empty_rest_of_line ();
2291 return;
2292 } /* if not inside .def/.endef */
2293
2294 S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ());
2295 demand_empty_rest_of_line ();
2296 }
2297
2298 static void
2299 obj_coff_tag (ignore)
2300 int ignore;
2301 {
2302 char *symbol_name;
2303 char name_end;
2304
2305 if (def_symbol_in_progress == NULL)
2306 {
2307 as_warn (".tag pseudo-op used outside of .def/.endef ignored.");
2308 demand_empty_rest_of_line ();
2309 return;
2310 }
2311
2312 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2313 symbol_name = input_line_pointer;
2314 name_end = get_symbol_end ();
2315
2316 /* Assume that the symbol referred to by .tag is always defined.
2317 This was a bad assumption. I've added find_or_make. xoxorich. */
2318 SA_SET_SYM_TAGNDX (def_symbol_in_progress,
2319 (long) tag_find_or_make (symbol_name));
2320 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L)
2321 {
2322 as_warn ("tag not found for .tag %s", symbol_name);
2323 } /* not defined */
2324
2325 SF_SET_TAGGED (def_symbol_in_progress);
2326 *input_line_pointer = name_end;
2327
2328 demand_empty_rest_of_line ();
2329 }
2330
2331 static void
2332 obj_coff_type (ignore)
2333 int ignore;
2334 {
2335 if (def_symbol_in_progress == NULL)
2336 {
2337 as_warn (".type pseudo-op used outside of .def/.endef ignored.");
2338 demand_empty_rest_of_line ();
2339 return;
2340 } /* if not inside .def/.endef */
2341
2342 S_SET_DATA_TYPE (def_symbol_in_progress, get_absolute_expression ());
2343
2344 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress)) &&
2345 S_GET_STORAGE_CLASS (def_symbol_in_progress) != C_TPDEF)
2346 {
2347 SF_SET_FUNCTION (def_symbol_in_progress);
2348 } /* is a function */
2349
2350 demand_empty_rest_of_line ();
2351 }
2352
2353 static void
2354 obj_coff_val (ignore)
2355 int ignore;
2356 {
2357 if (def_symbol_in_progress == NULL)
2358 {
2359 as_warn (".val pseudo-op used outside of .def/.endef ignored.");
2360 demand_empty_rest_of_line ();
2361 return;
2362 } /* if not inside .def/.endef */
2363
2364 if (is_name_beginner (*input_line_pointer))
2365 {
2366 char *symbol_name = input_line_pointer;
2367 char name_end = get_symbol_end ();
2368
2369 if (!strcmp (symbol_name, "."))
2370 {
2371 def_symbol_in_progress->sy_frag = frag_now;
2372 S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
2373 /* If the .val is != from the .def (e.g. statics) */
2374 }
2375 else if (strcmp (S_GET_NAME (def_symbol_in_progress), symbol_name))
2376 {
2377 def_symbol_in_progress->sy_value.X_op = O_symbol;
2378 def_symbol_in_progress->sy_value.X_add_symbol =
2379 symbol_find_or_make (symbol_name);
2380 def_symbol_in_progress->sy_value.X_op_symbol = NULL;
2381 def_symbol_in_progress->sy_value.X_add_number = 0;
2382
2383 /* If the segment is undefined when the forward reference is
2384 resolved, then copy the segment id from the forward
2385 symbol. */
2386 SF_SET_GET_SEGMENT (def_symbol_in_progress);
2387
2388 /* FIXME: gcc can generate address expressions
2389 here in unusual cases (search for "obscure"
2390 in sdbout.c). We just ignore the offset
2391 here, thus generating incorrect debugging
2392 information. We ignore the rest of the
2393 line just below. */
2394 }
2395 /* Otherwise, it is the name of a non debug symbol and
2396 its value will be calculated later. */
2397 *input_line_pointer = name_end;
2398
2399 /* FIXME: this is to avoid an error message in the
2400 FIXME case mentioned just above. */
2401 while (! is_end_of_line[(unsigned char) *input_line_pointer])
2402 ++input_line_pointer;
2403 }
2404 else
2405 {
2406 S_SET_VALUE (def_symbol_in_progress,
2407 (valueT) get_absolute_expression ());
2408 } /* if symbol based */
2409
2410 demand_empty_rest_of_line ();
2411 }
2412
2413 void
2414 obj_read_begin_hook ()
2415 {
2416 /* These had better be the same. Usually 18 bytes. */
2417 #ifndef BFD_HEADERS
2418 know (sizeof (SYMENT) == sizeof (AUXENT));
2419 know (SYMESZ == AUXESZ);
2420 #endif
2421 tag_init ();
2422 }
2423
2424 /* This function runs through the symbol table and puts all the
2425 externals onto another chain */
2426
2427 /* The chain of externals */
2428 symbolS *symbol_externP;
2429 symbolS *symbol_extern_lastP;
2430
2431 stack *block_stack;
2432 symbolS *last_functionP;
2433 symbolS *last_tagP;
2434
2435 static unsigned int
2436 yank_symbols ()
2437 {
2438 symbolS *symbolP;
2439 unsigned int symbol_number = 0;
2440 unsigned int last_file_symno = 0;
2441
2442 for (symbolP = symbol_rootP;
2443 symbolP;
2444 symbolP = symbolP ? symbol_next (symbolP) : symbol_rootP)
2445 {
2446 if (!SF_GET_DEBUG (symbolP))
2447 {
2448 /* Debug symbols do not need all this rubbish */
2449 symbolS *real_symbolP;
2450
2451 /* L* and C_EFCN symbols never merge. */
2452 if (!SF_GET_LOCAL (symbolP)
2453 && S_GET_STORAGE_CLASS (symbolP) != C_LABEL
2454 && symbolP->sy_value.X_op == O_constant
2455 && (real_symbolP = symbol_find_base (S_GET_NAME (symbolP), DO_NOT_STRIP))
2456 && real_symbolP != symbolP)
2457 {
2458 /* FIXME-SOON: where do dups come from?
2459 Maybe tag references before definitions? xoxorich. */
2460 /* Move the debug data from the debug symbol to the
2461 real symbol. Do NOT do the oposite (i.e. move from
2462 real symbol to debug symbol and remove real symbol from the
2463 list.) Because some pointers refer to the real symbol
2464 whereas no pointers refer to the debug symbol. */
2465 c_symbol_merge (symbolP, real_symbolP);
2466 /* Replace the current symbol by the real one */
2467 /* The symbols will never be the last or the first
2468 because : 1st symbol is .file and 3 last symbols are
2469 .text, .data, .bss */
2470 symbol_remove (real_symbolP, &symbol_rootP, &symbol_lastP);
2471 symbol_insert (real_symbolP, symbolP, &symbol_rootP, &symbol_lastP);
2472 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2473 symbolP = real_symbolP;
2474 } /* if not local but dup'd */
2475
2476 if (flag_readonly_data_in_text && (S_GET_SEGMENT (symbolP) == SEG_E1))
2477 {
2478 S_SET_SEGMENT (symbolP, SEG_E0);
2479 } /* push data into text */
2480
2481 resolve_symbol_value (symbolP);
2482
2483 if (S_GET_STORAGE_CLASS (symbolP) == C_NULL)
2484 {
2485 if (!S_IS_DEFINED (symbolP) && !SF_GET_LOCAL (symbolP))
2486 {
2487 S_SET_EXTERNAL (symbolP);
2488 }
2489 else if (S_GET_SEGMENT (symbolP) == SEG_E0)
2490 {
2491 S_SET_STORAGE_CLASS (symbolP, C_LABEL);
2492 }
2493 else
2494 {
2495 S_SET_STORAGE_CLASS (symbolP, C_STAT);
2496 }
2497 }
2498
2499 /* Mainly to speed up if not -g */
2500 if (SF_GET_PROCESS (symbolP))
2501 {
2502 /* Handle the nested blocks auxiliary info. */
2503 if (S_GET_STORAGE_CLASS (symbolP) == C_BLOCK)
2504 {
2505 if (!strcmp (S_GET_NAME (symbolP), ".bb"))
2506 stack_push (block_stack, (char *) &symbolP);
2507 else
2508 { /* .eb */
2509 register symbolS *begin_symbolP;
2510 begin_symbolP = *(symbolS **) stack_pop (block_stack);
2511 if (begin_symbolP == (symbolS *) 0)
2512 as_warn ("mismatched .eb");
2513 else
2514 SA_SET_SYM_ENDNDX (begin_symbolP, symbol_number + 2);
2515 }
2516 }
2517 /* If we are able to identify the type of a function, and we
2518 are out of a function (last_functionP == 0) then, the
2519 function symbol will be associated with an auxiliary
2520 entry. */
2521 if (last_functionP == (symbolS *) 0 &&
2522 SF_GET_FUNCTION (symbolP))
2523 {
2524 last_functionP = symbolP;
2525
2526 if (S_GET_NUMBER_AUXILIARY (symbolP) < 1)
2527 {
2528 S_SET_NUMBER_AUXILIARY (symbolP, 1);
2529 } /* make it at least 1 */
2530
2531 /* Clobber possible stale .dim information. */
2532 #if 0
2533 /* Iffed out by steve - this fries the lnnoptr info too */
2534 bzero (symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen,
2535 sizeof (symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen));
2536 #endif
2537 }
2538 /* The C_FCN doesn't need any additional information. I
2539 don't even know if this is needed for sdb. But the
2540 standard assembler generates it, so... */
2541 if (S_GET_STORAGE_CLASS (symbolP) == C_EFCN)
2542 {
2543 if (last_functionP == (symbolS *) 0)
2544 as_fatal ("C_EFCN symbol out of scope");
2545 SA_SET_SYM_FSIZE (last_functionP,
2546 (long) (S_GET_VALUE (symbolP) -
2547 S_GET_VALUE (last_functionP)));
2548 SA_SET_SYM_ENDNDX (last_functionP, symbol_number);
2549 last_functionP = (symbolS *) 0;
2550 }
2551 }
2552 }
2553 else if (SF_GET_TAG (symbolP))
2554 {
2555 /* First descriptor of a structure must point to
2556 the first slot after the structure description. */
2557 last_tagP = symbolP;
2558
2559 }
2560 else if (S_GET_STORAGE_CLASS (symbolP) == C_EOS)
2561 {
2562 /* +2 take in account the current symbol */
2563 SA_SET_SYM_ENDNDX (last_tagP, symbol_number + 2);
2564 }
2565 else if (S_GET_STORAGE_CLASS (symbolP) == C_FILE)
2566 {
2567 if (S_GET_VALUE (symbolP))
2568 {
2569 S_SET_VALUE (symbolP, last_file_symno);
2570 last_file_symno = symbol_number;
2571 } /* no one points at the first .file symbol */
2572 } /* if debug or tag or eos or file */
2573
2574 /* We must put the external symbols apart. The loader
2575 does not bomb if we do not. But the references in
2576 the endndx field for a .bb symbol are not corrected
2577 if an external symbol is removed between .bb and .be.
2578 I.e in the following case :
2579 [20] .bb endndx = 22
2580 [21] foo external
2581 [22] .be
2582 ld will move the symbol 21 to the end of the list but
2583 endndx will still be 22 instead of 21. */
2584
2585
2586 if (SF_GET_LOCAL (symbolP))
2587 {
2588 /* remove C_EFCN and LOCAL (L...) symbols */
2589 /* next pointer remains valid */
2590 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2591
2592 }
2593 else if (!S_IS_DEFINED (symbolP)
2594 && !S_IS_DEBUG (symbolP)
2595 && !SF_GET_STATICS (symbolP) &&
2596 S_GET_STORAGE_CLASS (symbolP) == C_EXT)
2597 { /* C_EXT && !SF_GET_FUNCTION(symbolP)) */
2598 /* if external, Remove from the list */
2599 symbolS *hold = symbol_previous (symbolP);
2600
2601 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2602 symbol_clear_list_pointers (symbolP);
2603 symbol_append (symbolP, symbol_extern_lastP, &symbol_externP, &symbol_extern_lastP);
2604 symbolP = hold;
2605 }
2606 else
2607 {
2608 if (SF_GET_STRING (symbolP))
2609 {
2610 symbolP->sy_name_offset = string_byte_count;
2611 string_byte_count += strlen (S_GET_NAME (symbolP)) + 1;
2612 }
2613 else
2614 {
2615 symbolP->sy_name_offset = 0;
2616 } /* fix "long" names */
2617
2618 symbolP->sy_number = symbol_number;
2619 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (symbolP);
2620 } /* if local symbol */
2621 } /* traverse the symbol list */
2622 return symbol_number;
2623
2624 }
2625
2626
2627 static unsigned int
2628 glue_symbols ()
2629 {
2630 unsigned int symbol_number = 0;
2631 symbolS *symbolP;
2632 for (symbolP = symbol_externP; symbol_externP;)
2633 {
2634 symbolS *tmp = symbol_externP;
2635
2636 /* append */
2637 symbol_remove (tmp, &symbol_externP, &symbol_extern_lastP);
2638 symbol_append (tmp, symbol_lastP, &symbol_rootP, &symbol_lastP);
2639
2640 /* and process */
2641 if (SF_GET_STRING (tmp))
2642 {
2643 tmp->sy_name_offset = string_byte_count;
2644 string_byte_count += strlen (S_GET_NAME (tmp)) + 1;
2645 }
2646 else
2647 {
2648 tmp->sy_name_offset = 0;
2649 } /* fix "long" names */
2650
2651 tmp->sy_number = symbol_number;
2652 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (tmp);
2653 } /* append the entire extern chain */
2654 return symbol_number;
2655
2656 }
2657
2658 static unsigned int
2659 tie_tags ()
2660 {
2661 unsigned int symbol_number = 0;
2662
2663 symbolS *symbolP;
2664 for (symbolP = symbol_rootP; symbolP; symbolP =
2665 symbol_next (symbolP))
2666 {
2667 symbolP->sy_number = symbol_number;
2668
2669
2670
2671 if (SF_GET_TAGGED (symbolP))
2672 {
2673 SA_SET_SYM_TAGNDX
2674 (symbolP,
2675 ((symbolS *) SA_GET_SYM_TAGNDX (symbolP))->sy_number);
2676 }
2677
2678 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (symbolP);
2679 }
2680 return symbol_number;
2681
2682 }
2683
2684 static void
2685 crawl_symbols (h, abfd)
2686 object_headers *h;
2687 bfd * abfd;
2688 {
2689 unsigned int i;
2690
2691 /* Initialize the stack used to keep track of the matching .bb .be */
2692
2693 block_stack = stack_init (512, sizeof (symbolS *));
2694
2695 /* The symbol list should be ordered according to the following sequence
2696 * order :
2697 * . .file symbol
2698 * . debug entries for functions
2699 * . fake symbols for the sections, including.text .data and .bss
2700 * . defined symbols
2701 * . undefined symbols
2702 * But this is not mandatory. The only important point is to put the
2703 * undefined symbols at the end of the list.
2704 */
2705
2706 if (symbol_rootP == NULL
2707 || S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
2708 {
2709 c_dot_file_symbol ("fake");
2710 }
2711 /* Is there a .file symbol ? If not insert one at the beginning. */
2712
2713 /*
2714 * Build up static symbols for the sections, they are filled in later
2715 */
2716
2717
2718 for (i = SEG_E0; i < SEG_E9; i++)
2719 {
2720 if (segment_info[i].scnhdr.s_name[0])
2721 {
2722 char name[9];
2723
2724 strncpy (name, segment_info[i].scnhdr.s_name, 8);
2725 name[8] = '\0';
2726 segment_info[i].dot = c_section_symbol (name, i - SEG_E0 + 1);
2727 }
2728 }
2729
2730
2731 /* Take all the externals out and put them into another chain */
2732 H_SET_SYMBOL_TABLE_SIZE (h, yank_symbols ());
2733 /* Take the externals and glue them onto the end.*/
2734 H_SET_SYMBOL_TABLE_SIZE (h, H_GET_SYMBOL_COUNT (h) + glue_symbols ());
2735
2736 H_SET_SYMBOL_TABLE_SIZE (h, tie_tags ());
2737 know (symbol_externP == NULL);
2738 know (symbol_extern_lastP == NULL);
2739 }
2740
2741 /*
2742 * Find strings by crawling along symbol table chain.
2743 */
2744
2745 void
2746 w_strings (where)
2747 char *where;
2748 {
2749 symbolS *symbolP;
2750
2751 /* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
2752 md_number_to_chars (where, (valueT) string_byte_count, 4);
2753 where += 4;
2754 for (symbolP = symbol_rootP;
2755 symbolP;
2756 symbolP = symbol_next (symbolP))
2757 {
2758 unsigned int size;
2759
2760 if (SF_GET_STRING (symbolP))
2761 {
2762 size = strlen (S_GET_NAME (symbolP)) + 1;
2763
2764 memcpy (where, S_GET_NAME (symbolP), size);
2765 where += size;
2766
2767 }
2768 }
2769 }
2770
2771 static void
2772 do_linenos_for (abfd, h, file_cursor)
2773 bfd * abfd;
2774 object_headers * h;
2775 unsigned long *file_cursor;
2776 {
2777 unsigned int idx;
2778 unsigned long start = *file_cursor;
2779
2780 for (idx = SEG_E0; idx < SEG_E9; idx++)
2781 {
2782 segment_info_type *s = segment_info + idx;
2783
2784
2785 if (s->scnhdr.s_nlnno != 0)
2786 {
2787 struct lineno_list *line_ptr;
2788
2789 struct external_lineno *buffer =
2790 (struct external_lineno *) xmalloc (s->scnhdr.s_nlnno * LINESZ);
2791
2792 struct external_lineno *dst = buffer;
2793
2794 /* Run through the table we've built and turn it into its external
2795 form, take this chance to remove duplicates */
2796
2797 for (line_ptr = s->lineno_list_head;
2798 line_ptr != (struct lineno_list *) NULL;
2799 line_ptr = line_ptr->next)
2800 {
2801
2802 if (line_ptr->line.l_lnno == 0)
2803 {
2804 /* Turn a pointer to a symbol into the symbols' index */
2805 line_ptr->line.l_addr.l_symndx =
2806 ((symbolS *) line_ptr->line.l_addr.l_symndx)->sy_number;
2807 }
2808 else
2809 {
2810 line_ptr->line.l_addr.l_paddr += ((struct frag *) (line_ptr->frag))->fr_address;
2811 }
2812
2813
2814 (void) bfd_coff_swap_lineno_out (abfd, &(line_ptr->line), dst);
2815 dst++;
2816
2817 }
2818
2819 s->scnhdr.s_lnnoptr = *file_cursor;
2820
2821 bfd_write (buffer, 1, s->scnhdr.s_nlnno * LINESZ, abfd);
2822 free (buffer);
2823
2824 *file_cursor += s->scnhdr.s_nlnno * LINESZ;
2825 }
2826 }
2827 H_SET_LINENO_SIZE (h, *file_cursor - start);
2828 }
2829
2830
2831 /* Now we run through the list of frag chains in a segment and
2832 make all the subsegment frags appear at the end of the
2833 list, as if the seg 0 was extra long */
2834
2835 static void
2836 remove_subsegs ()
2837 {
2838 unsigned int i;
2839
2840 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
2841 {
2842 frchainS *head = segment_info[i].frchainP;
2843 fragS dummy;
2844 fragS *prev_frag = &dummy;
2845
2846 while (head && head->frch_seg == i)
2847 {
2848 prev_frag->fr_next = head->frch_root;
2849 prev_frag = head->frch_last;
2850 head = head->frch_next;
2851 }
2852 prev_frag->fr_next = 0;
2853 }
2854 }
2855
2856 unsigned long machine;
2857 int coff_flags;
2858 extern void
2859 write_object_file ()
2860 {
2861 int i;
2862 char *name;
2863 struct frchain *frchain_ptr;
2864
2865 object_headers headers;
2866 unsigned long file_cursor;
2867 bfd *abfd;
2868 unsigned int addr;
2869 abfd = bfd_openw (out_file_name, TARGET_FORMAT);
2870
2871
2872 if (abfd == 0)
2873 {
2874 as_perror ("FATAL: Can't create %s", out_file_name);
2875 exit (EXIT_FAILURE);
2876 }
2877 bfd_set_format (abfd, bfd_object);
2878 bfd_set_arch_mach (abfd, BFD_ARCH, machine);
2879
2880 string_byte_count = 4;
2881
2882 for (frchain_ptr = frchain_root;
2883 frchain_ptr != (struct frchain *) NULL;
2884 frchain_ptr = frchain_ptr->frch_next)
2885 {
2886 /* Run through all the sub-segments and align them up. Also
2887 close any open frags. We tack a .fill onto the end of the
2888 frag chain so that any .align's size can be worked by looking
2889 at the next frag. */
2890
2891 subseg_set (frchain_ptr->frch_seg, frchain_ptr->frch_subseg);
2892 #ifndef SUB_SEGMENT_ALIGN
2893 #define SUB_SEGMENT_ALIGN(SEG) 1
2894 #endif
2895 frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE);
2896 frag_wane (frag_now);
2897 frag_now->fr_fix = 0;
2898 know (frag_now->fr_next == NULL);
2899 }
2900
2901
2902 remove_subsegs ();
2903
2904
2905 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
2906 {
2907 relax_segment (segment_info[i].frchainP->frch_root, i);
2908 }
2909
2910 H_SET_NUMBER_OF_SECTIONS (&headers, 0);
2911
2912 /* Find out how big the sections are, and set the addresses. */
2913 addr = 0;
2914 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
2915 {
2916 long size;
2917
2918 segment_info[i].scnhdr.s_paddr = addr;
2919 segment_info[i].scnhdr.s_vaddr = addr;
2920
2921 if (segment_info[i].scnhdr.s_name[0])
2922 {
2923 H_SET_NUMBER_OF_SECTIONS (&headers,
2924 H_GET_NUMBER_OF_SECTIONS (&headers) + 1);
2925 }
2926
2927 size = size_section (abfd, (unsigned int) i);
2928 addr += size;
2929
2930 /* I think the section alignment is only used on the i960; the
2931 i960 needs it, and it should do no harm on other targets. */
2932 segment_info[i].scnhdr.s_align = section_alignment[i];
2933
2934 if (i == SEG_E0)
2935 H_SET_TEXT_SIZE (&headers, size);
2936 else if (i == SEG_E1)
2937 H_SET_DATA_SIZE (&headers, size);
2938 else if (i == SEG_E2)
2939 H_SET_BSS_SIZE (&headers, size);
2940 }
2941
2942 /* Turn the gas native symbol table shape into a coff symbol table */
2943 crawl_symbols (&headers, abfd);
2944
2945 if (string_byte_count == 4)
2946 string_byte_count = 0;
2947
2948 H_SET_STRING_SIZE (&headers, string_byte_count);
2949
2950 #if !defined(TC_H8300) && !defined(TC_Z8K)
2951 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
2952 {
2953 fixup_mdeps (segment_info[i].frchainP->frch_root, &headers, i);
2954 fixup_segment (&segment_info[i], i);
2955 }
2956 #endif
2957
2958 /* Look for ".stab" segments and fill in their initial symbols
2959 correctly. */
2960 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
2961 {
2962 name = segment_info[i].scnhdr.s_name;
2963
2964 if (name != NULL
2965 && strncmp (".stab", name, 5) == 0
2966 && strncmp (".stabstr", name, 8) != 0)
2967 adjust_stab_section (abfd, i);
2968 }
2969
2970 file_cursor = H_GET_TEXT_FILE_OFFSET (&headers);
2971
2972 bfd_seek (abfd, (file_ptr) file_cursor, 0);
2973
2974 /* Plant the data */
2975
2976 fill_section (abfd, &headers, &file_cursor);
2977
2978 do_relocs_for (abfd, &headers, &file_cursor);
2979
2980 do_linenos_for (abfd, &headers, &file_cursor);
2981
2982 H_SET_FILE_MAGIC_NUMBER (&headers, COFF_MAGIC);
2983 #ifndef OBJ_COFF_OMIT_TIMESTAMP
2984 H_SET_TIME_STAMP (&headers, (long)time((long*)0));
2985 #else
2986 H_SET_TIME_STAMP (&headers, 0);
2987 #endif
2988 #ifdef TC_COFF_SET_MACHINE
2989 TC_COFF_SET_MACHINE (&headers);
2990 #endif
2991
2992 #ifndef COFF_FLAGS
2993 #define COFF_FLAGS 0
2994 #endif
2995
2996 #ifdef KEEP_RELOC_INFO
2997 H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
2998 COFF_FLAGS | coff_flags));
2999 #else
3000 H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
3001 (H_GET_RELOCATION_SIZE(&headers) ? 0 : F_RELFLG) |
3002 COFF_FLAGS | coff_flags));
3003 #endif
3004
3005 {
3006 unsigned int symtable_size = H_GET_SYMBOL_TABLE_SIZE (&headers);
3007 char *buffer1 = xmalloc (symtable_size + string_byte_count + 1);
3008
3009 H_SET_SYMBOL_TABLE_POINTER (&headers, bfd_tell (abfd));
3010 w_symbols (abfd, buffer1, symbol_rootP);
3011 if (string_byte_count > 0)
3012 w_strings (buffer1 + symtable_size);
3013 bfd_write (buffer1, 1, symtable_size + string_byte_count, abfd);
3014 free (buffer1);
3015 }
3016
3017 coff_header_append (abfd, &headers);
3018 #if 0
3019 /* Recent changes to write need this, but where it should
3020 go is up to Ken.. */
3021 if (bfd_close_all_done (abfd) == false)
3022 as_fatal ("Can't close %s: %s", out_file_name,
3023 bfd_errmsg (bfd_get_error ()));
3024 #else
3025 {
3026 extern bfd *stdoutput;
3027 stdoutput = abfd;
3028 }
3029 #endif
3030
3031 }
3032
3033 /* Add a new segment. This is called from subseg_new via the
3034 obj_new_segment macro. */
3035
3036 segT
3037 obj_coff_add_segment (name)
3038 const char *name;
3039 {
3040 unsigned int len;
3041 unsigned int i;
3042
3043 /* Find out if we've already got a section of this name. */
3044 len = strlen (name);
3045 if (len < sizeof (segment_info[i].scnhdr.s_name))
3046 ++len;
3047 else
3048 len = sizeof (segment_info[i].scnhdr.s_name);
3049 for (i = SEG_E0; i < SEG_E9 && segment_info[i].scnhdr.s_name[0]; i++)
3050 if (strncmp (segment_info[i].scnhdr.s_name, name, len) == 0
3051 && (len == sizeof (segment_info[i].scnhdr.s_name)
3052 || segment_info[i].scnhdr.s_name[len] == '\0'))
3053 return (segT) i;
3054
3055 if (i == SEG_E9)
3056 {
3057 as_bad ("Too many new sections; can't add \"%s\"", name);
3058 return now_seg;
3059 }
3060
3061 /* Add a new section. */
3062 strncpy (segment_info[i].scnhdr.s_name, name,
3063 sizeof (segment_info[i].scnhdr.s_name));
3064 segment_info[i].scnhdr.s_flags = STYP_REG;
3065
3066 return (segT) i;
3067 }
3068
3069 /*
3070 * implement the .section pseudo op:
3071 * .section name {, "flags"}
3072 * ^ ^
3073 * | +--- optional flags: 'b' for bss
3074 * | 'i' for info
3075 * +-- section name 'l' for lib
3076 * 'n' for noload
3077 * 'o' for over
3078 * 'w' for data
3079 * 'd' (apparently m88k for data)
3080 * 'x' for text
3081 * But if the argument is not a quoted string, treat it as a
3082 * subsegment number.
3083 */
3084
3085 void
3086 obj_coff_section (ignore)
3087 int ignore;
3088 {
3089 /* Strip out the section name */
3090 char *section_name;
3091 char *section_name_end;
3092 char c;
3093 int argp;
3094 unsigned int len;
3095 unsigned int exp;
3096 long flags;
3097
3098 section_name = input_line_pointer;
3099 c = get_symbol_end ();
3100 section_name_end = input_line_pointer;
3101
3102 len = section_name_end - section_name;
3103 input_line_pointer++;
3104 SKIP_WHITESPACE ();
3105
3106 argp = 0;
3107 if (c == ',')
3108 argp = 1;
3109 else if (*input_line_pointer == ',')
3110 {
3111 argp = 1;
3112 ++input_line_pointer;
3113 SKIP_WHITESPACE ();
3114 }
3115
3116 exp = 0;
3117 flags = 0;
3118 if (argp)
3119 {
3120 if (*input_line_pointer != '"')
3121 exp = get_absolute_expression ();
3122 else
3123 {
3124 ++input_line_pointer;
3125 while (*input_line_pointer != '"'
3126 && ! is_end_of_line[(unsigned char) *input_line_pointer])
3127 {
3128 switch (*input_line_pointer)
3129 {
3130 case 'b': flags |= STYP_BSS; break;
3131 case 'i': flags |= STYP_INFO; break;
3132 case 'l': flags |= STYP_LIB; break;
3133 case 'n': flags |= STYP_NOLOAD; break;
3134 case 'o': flags |= STYP_OVER; break;
3135 case 'd':
3136 case 'w': flags |= STYP_DATA; break;
3137 case 'x': flags |= STYP_TEXT; break;
3138 default:
3139 as_warn("unknown section attribute '%c'",
3140 *input_line_pointer);
3141 break;
3142 }
3143 ++input_line_pointer;
3144 }
3145 if (*input_line_pointer == '"')
3146 ++input_line_pointer;
3147 }
3148 }
3149
3150 subseg_new (section_name, (subsegT) exp);
3151
3152 segment_info[now_seg].scnhdr.s_flags |= flags;
3153
3154 *section_name_end = c;
3155 }
3156
3157
3158 static void
3159 obj_coff_text (ignore)
3160 int ignore;
3161 {
3162 subseg_new (".text", get_absolute_expression ());
3163 }
3164
3165
3166 static void
3167 obj_coff_data (ignore)
3168 int ignore;
3169 {
3170 if (flag_readonly_data_in_text)
3171 subseg_new (".text", get_absolute_expression () + 1000);
3172 else
3173 subseg_new (".data", get_absolute_expression ());
3174 }
3175
3176 static void
3177 obj_coff_bss (ignore)
3178 int ignore;
3179 {
3180 if (*input_line_pointer == '\n') /* .bss */
3181 subseg_new(".bss", get_absolute_expression());
3182 else /* .bss id,expr */
3183 obj_coff_lcomm(0);
3184 }
3185
3186 static void
3187 obj_coff_ident (ignore)
3188 int ignore;
3189 {
3190 segT current_seg = now_seg; /* save current seg */
3191 subsegT current_subseg = now_subseg;
3192 subseg_new (".comment", 0); /* .comment seg */
3193 stringer (1); /* read string */
3194 subseg_set (current_seg, current_subseg); /* restore current seg */
3195 }
3196
3197 void
3198 c_symbol_merge (debug, normal)
3199 symbolS *debug;
3200 symbolS *normal;
3201 {
3202 S_SET_DATA_TYPE (normal, S_GET_DATA_TYPE (debug));
3203 S_SET_STORAGE_CLASS (normal, S_GET_STORAGE_CLASS (debug));
3204
3205 if (S_GET_NUMBER_AUXILIARY (debug) > S_GET_NUMBER_AUXILIARY (normal))
3206 {
3207 S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));
3208 } /* take the most we have */
3209
3210 if (S_GET_NUMBER_AUXILIARY (debug) > 0)
3211 {
3212 memcpy ((char *) &normal->sy_symbol.ost_auxent[0],
3213 (char *) &debug->sy_symbol.ost_auxent[0],
3214 (unsigned int) (S_GET_NUMBER_AUXILIARY (debug) * AUXESZ));
3215 } /* Move all the auxiliary information */
3216
3217 /* Move the debug flags. */
3218 SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
3219 } /* c_symbol_merge() */
3220
3221 static int
3222 c_line_new (symbol, paddr, line_number, frag)
3223 symbolS * symbol;
3224 long paddr;
3225 int line_number;
3226 fragS * frag;
3227 {
3228 struct lineno_list *new_line =
3229 (struct lineno_list *) xmalloc (sizeof (struct lineno_list));
3230
3231 segment_info_type *s = segment_info + now_seg;
3232 new_line->line.l_lnno = line_number;
3233
3234 if (line_number == 0)
3235 {
3236 last_line_symbol = symbol;
3237 new_line->line.l_addr.l_symndx = (long) symbol;
3238 }
3239 else
3240 {
3241 new_line->line.l_addr.l_paddr = paddr;
3242 }
3243
3244 new_line->frag = (char *) frag;
3245 new_line->next = (struct lineno_list *) NULL;
3246
3247
3248 if (s->lineno_list_head == (struct lineno_list *) NULL)
3249 {
3250 s->lineno_list_head = new_line;
3251 }
3252 else
3253 {
3254 s->lineno_list_tail->next = new_line;
3255 }
3256 s->lineno_list_tail = new_line;
3257 return LINESZ * s->scnhdr.s_nlnno++;
3258 }
3259
3260 void
3261 c_dot_file_symbol (filename)
3262 char *filename;
3263 {
3264 symbolS *symbolP;
3265
3266 symbolP = symbol_new (".file",
3267 SEG_DEBUG,
3268 0,
3269 &zero_address_frag);
3270
3271 S_SET_STORAGE_CLASS (symbolP, C_FILE);
3272 S_SET_NUMBER_AUXILIARY (symbolP, 1);
3273 SA_SET_FILE_FNAME (symbolP, filename);
3274 #ifndef NO_LISTING
3275 {
3276 extern int listing;
3277 if (listing)
3278 {
3279 listing_source_file (filename);
3280 }
3281
3282 }
3283
3284 #endif
3285 SF_SET_DEBUG (symbolP);
3286 S_SET_VALUE (symbolP, (valueT) previous_file_symbol);
3287
3288 previous_file_symbol = symbolP;
3289
3290 /* Make sure that the symbol is first on the symbol chain */
3291 if (symbol_rootP != symbolP)
3292 {
3293 if (symbolP == symbol_lastP)
3294 {
3295 symbol_lastP = symbol_lastP->sy_previous;
3296 } /* if it was the last thing on the list */
3297
3298 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3299 symbol_insert (symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
3300 symbol_rootP = symbolP;
3301 } /* if not first on the list */
3302
3303 } /* c_dot_file_symbol() */
3304
3305 /*
3306 * Build a 'section static' symbol.
3307 */
3308
3309 symbolS *
3310 c_section_symbol (name, idx)
3311 char *name;
3312 int idx;
3313 {
3314 symbolS *symbolP;
3315
3316 symbolP = symbol_new (name, idx,
3317 0,
3318 &zero_address_frag);
3319
3320 S_SET_STORAGE_CLASS (symbolP, C_STAT);
3321 S_SET_NUMBER_AUXILIARY (symbolP, 1);
3322
3323 SF_SET_STATICS (symbolP);
3324
3325 return symbolP;
3326 } /* c_section_symbol() */
3327
3328 static void
3329 w_symbols (abfd, where, symbol_rootP)
3330 bfd * abfd;
3331 char *where;
3332 symbolS * symbol_rootP;
3333 {
3334 symbolS *symbolP;
3335 unsigned int i;
3336
3337 /* First fill in those values we have only just worked out */
3338 for (i = SEG_E0; i < SEG_E9; i++)
3339 {
3340 symbolP = segment_info[i].dot;
3341 if (symbolP)
3342 {
3343 SA_SET_SCN_SCNLEN (symbolP, segment_info[i].scnhdr.s_size);
3344 SA_SET_SCN_NRELOC (symbolP, segment_info[i].scnhdr.s_nreloc);
3345 SA_SET_SCN_NLINNO (symbolP, segment_info[i].scnhdr.s_nlnno);
3346 }
3347 }
3348
3349 /*
3350 * Emit all symbols left in the symbol chain.
3351 */
3352 for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
3353 {
3354 /* Used to save the offset of the name. It is used to point
3355 to the string in memory but must be a file offset. */
3356 register char *temp;
3357
3358 tc_coff_symbol_emit_hook (symbolP);
3359
3360 temp = S_GET_NAME (symbolP);
3361 if (SF_GET_STRING (symbolP))
3362 {
3363 S_SET_OFFSET (symbolP, symbolP->sy_name_offset);
3364 S_SET_ZEROES (symbolP, 0);
3365 }
3366 else
3367 {
3368 memset (symbolP->sy_symbol.ost_entry.n_name, 0, SYMNMLEN);
3369 strncpy (symbolP->sy_symbol.ost_entry.n_name, temp, SYMNMLEN);
3370 }
3371 where = symbol_to_chars (abfd, where, symbolP);
3372 S_SET_NAME (symbolP, temp);
3373 }
3374
3375 } /* w_symbols() */
3376
3377 static void
3378 obj_coff_lcomm (ignore)
3379 int ignore;
3380 {
3381 s_lcomm(0);
3382 return;
3383 #if 0
3384 char *name;
3385 char c;
3386 int temp;
3387 char *p;
3388
3389 symbolS *symbolP;
3390
3391 name = input_line_pointer;
3392
3393 c = get_symbol_end ();
3394 p = input_line_pointer;
3395 *p = c;
3396 SKIP_WHITESPACE ();
3397 if (*input_line_pointer != ',')
3398 {
3399 as_bad ("Expected comma after name");
3400 ignore_rest_of_line ();
3401 return;
3402 }
3403 if (*input_line_pointer == '\n')
3404 {
3405 as_bad ("Missing size expression");
3406 return;
3407 }
3408 input_line_pointer++;
3409 if ((temp = get_absolute_expression ()) < 0)
3410 {
3411 as_warn ("lcomm length (%d.) <0! Ignored.", temp);
3412 ignore_rest_of_line ();
3413 return;
3414 }
3415 *p = 0;
3416
3417 symbolP = symbol_find_or_make(name);
3418
3419 if (S_GET_SEGMENT(symbolP) == SEG_UNKNOWN &&
3420 S_GET_VALUE(symbolP) == 0)
3421 {
3422 if (! need_pass_2)
3423 {
3424 char *p;
3425 segT current_seg = now_seg; /* save current seg */
3426 subsegT current_subseg = now_subseg;
3427
3428 subseg_set (SEG_E2, 1);
3429 symbolP->sy_frag = frag_now;
3430 p = frag_var(rs_org, 1, 1, (relax_substateT)0, symbolP,
3431 temp, (char *)0);
3432 *p = 0;
3433 subseg_set (current_seg, current_subseg); /* restore current seg */
3434 S_SET_SEGMENT(symbolP, SEG_E2);
3435 S_SET_STORAGE_CLASS(symbolP, C_STAT);
3436 }
3437 }
3438 else
3439 as_bad("Symbol %s already defined", name);
3440
3441 demand_empty_rest_of_line();
3442 #endif
3443 }
3444
3445 static void
3446 fixup_mdeps (frags, h, this_segment)
3447 fragS * frags;
3448 object_headers * h;
3449 segT this_segment;
3450 {
3451 subseg_change (this_segment, 0);
3452 while (frags)
3453 {
3454 switch (frags->fr_type)
3455 {
3456 case rs_align:
3457 case rs_org:
3458 frags->fr_type = rs_fill;
3459 frags->fr_offset =
3460 (frags->fr_next->fr_address - frags->fr_address - frags->fr_fix);
3461 break;
3462 case rs_machine_dependent:
3463 md_convert_frag (h, frags);
3464 frag_wane (frags);
3465 break;
3466 default:
3467 ;
3468 }
3469 frags = frags->fr_next;
3470 }
3471 }
3472
3473 #if 1
3474 static void
3475 fixup_segment (segP, this_segment_type)
3476 segment_info_type * segP;
3477 segT this_segment_type;
3478 {
3479 register fixS * fixP;
3480 register symbolS *add_symbolP;
3481 register symbolS *sub_symbolP;
3482 register long add_number;
3483 register int size;
3484 register char *place;
3485 register long where;
3486 register char pcrel;
3487 register fragS *fragP;
3488 register segT add_symbol_segment = absolute_section;
3489
3490
3491 for (fixP = segP->fix_root; fixP; fixP = fixP->fx_next)
3492 {
3493 fragP = fixP->fx_frag;
3494 know (fragP);
3495 where = fixP->fx_where;
3496 place = fragP->fr_literal + where;
3497 size = fixP->fx_size;
3498 add_symbolP = fixP->fx_addsy;
3499 #ifdef TC_I960
3500 if (fixP->fx_tcbit && SF_GET_CALLNAME (add_symbolP))
3501 {
3502 /* Relocation should be done via the associated 'bal' entry
3503 point symbol. */
3504
3505 if (!SF_GET_BALNAME (tc_get_bal_of_call (add_symbolP)))
3506 {
3507 as_bad_where (fixP->fx_file, fixP->fx_line,
3508 "No 'bal' entry point for leafproc %s",
3509 S_GET_NAME (add_symbolP));
3510 continue;
3511 }
3512 fixP->fx_addsy = add_symbolP = tc_get_bal_of_call (add_symbolP);
3513 }
3514 #endif
3515 sub_symbolP = fixP->fx_subsy;
3516 add_number = fixP->fx_offset;
3517 pcrel = fixP->fx_pcrel;
3518
3519 if (add_symbolP)
3520 {
3521 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
3522 } /* if there is an addend */
3523
3524 if (sub_symbolP)
3525 {
3526 if (!add_symbolP)
3527 {
3528 /* Its just -sym */
3529 if (S_GET_SEGMENT (sub_symbolP) != absolute_section)
3530 {
3531 as_bad_where (fixP->fx_file, fixP->fx_line,
3532 "Negative of non-absolute symbol %s",
3533 S_GET_NAME (sub_symbolP));
3534 } /* not absolute */
3535
3536 add_number -= S_GET_VALUE (sub_symbolP);
3537 fixP->fx_subsy = 0;
3538
3539 /* if sub_symbol is in the same segment that add_symbol
3540 and add_symbol is either in DATA, TEXT, BSS or ABSOLUTE */
3541 }
3542 else if ((S_GET_SEGMENT (sub_symbolP) == add_symbol_segment)
3543 && (SEG_NORMAL (add_symbol_segment)
3544 || (add_symbol_segment == absolute_section)))
3545 {
3546 /* Difference of 2 symbols from same segment. Can't
3547 make difference of 2 undefineds: 'value' means
3548 something different for N_UNDF. */
3549 #ifdef TC_I960
3550 /* Makes no sense to use the difference of 2 arbitrary symbols
3551 as the target of a call instruction. */
3552 if (fixP->fx_tcbit)
3553 {
3554 as_bad_where (fixP->fx_file, fixP->fx_line,
3555 "callj to difference of 2 symbols");
3556 }
3557 #endif /* TC_I960 */
3558 add_number += S_GET_VALUE (add_symbolP) -
3559 S_GET_VALUE (sub_symbolP);
3560
3561 add_symbolP = NULL;
3562 fixP->fx_addsy = NULL;
3563 fixP->fx_subsy = NULL;
3564 fixP->fx_done = 1;
3565 }
3566 else
3567 {
3568 /* Different segments in subtraction. */
3569 know (!(S_IS_EXTERNAL (sub_symbolP) && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
3570
3571 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
3572 {
3573 add_number -= S_GET_VALUE (sub_symbolP);
3574 }
3575 #ifdef DIFF_EXPR_OK
3576 else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
3577 #if 0 /* Okay for 68k, at least... */
3578 && !pcrel
3579 #endif
3580 )
3581 {
3582 /* Make it pc-relative. */
3583 add_number += (md_pcrel_from (fixP)
3584 - S_GET_VALUE (sub_symbolP));
3585 pcrel = 1;
3586 fixP->fx_pcrel = 1;
3587 sub_symbolP = 0;
3588 fixP->fx_subsy = 0;
3589 }
3590 #endif
3591 else
3592 {
3593 as_bad_where (fixP->fx_file, fixP->fx_line,
3594 "Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %ld.",
3595 segment_name (S_GET_SEGMENT (sub_symbolP)),
3596 S_GET_NAME (sub_symbolP),
3597 (long) (fragP->fr_address + where));
3598 } /* if absolute */
3599 }
3600 } /* if sub_symbolP */
3601
3602 if (add_symbolP)
3603 {
3604 if (add_symbol_segment == this_segment_type && pcrel)
3605 {
3606 /*
3607 * This fixup was made when the symbol's segment was
3608 * SEG_UNKNOWN, but it is now in the local segment.
3609 * So we know how to do the address without relocation.
3610 */
3611 #ifdef TC_I960
3612 /* reloc_callj() may replace a 'call' with a 'calls' or a 'bal',
3613 * in which cases it modifies *fixP as appropriate. In the case
3614 * of a 'calls', no further work is required, and *fixP has been
3615 * set up to make the rest of the code below a no-op.
3616 */
3617 reloc_callj (fixP);
3618 #endif /* TC_I960 */
3619
3620 add_number += S_GET_VALUE (add_symbolP);
3621 add_number -= md_pcrel_from (fixP);
3622 #if defined (TC_I386) || defined (TE_LYNX)
3623 /* On the 386 we must adjust by the segment
3624 vaddr as well. Ian Taylor. */
3625 add_number -= segP->scnhdr.s_vaddr;
3626 #endif
3627 pcrel = 0; /* Lie. Don't want further pcrel processing. */
3628 fixP->fx_addsy = NULL;
3629 fixP->fx_done = 1;
3630 }
3631 else
3632 {
3633 switch (add_symbol_segment)
3634 {
3635 case absolute_section:
3636 #ifdef TC_I960
3637 reloc_callj (fixP); /* See comment about reloc_callj() above*/
3638 #endif /* TC_I960 */
3639 add_number += S_GET_VALUE (add_symbolP);
3640 fixP->fx_addsy = NULL;
3641 fixP->fx_done = 1;
3642 add_symbolP = NULL;
3643 break;
3644 default:
3645
3646 #ifdef TC_A29K
3647 /* This really should be handled in the linker, but
3648 backward compatibility forbids. */
3649 add_number += S_GET_VALUE (add_symbolP);
3650 #else
3651 add_number += S_GET_VALUE (add_symbolP) +
3652 segment_info[S_GET_SEGMENT (add_symbolP)].scnhdr.s_paddr;
3653 #endif
3654 break;
3655
3656 case SEG_UNKNOWN:
3657 #ifdef TC_I960
3658 if ((int) fixP->fx_bit_fixP == 13)
3659 {
3660 /* This is a COBR instruction. They have only a
3661 * 13-bit displacement and are only to be used
3662 * for local branches: flag as error, don't generate
3663 * relocation.
3664 */
3665 as_bad_where (fixP->fx_file, fixP->fx_line,
3666 "can't use COBR format with external label");
3667 fixP->fx_addsy = NULL;
3668 fixP->fx_done = 1;
3669 continue;
3670 } /* COBR */
3671 #endif /* TC_I960 */
3672 #if defined (TC_I386) || defined (TE_LYNX)
3673 /* 386 COFF uses a peculiar format in
3674 which the value of a common symbol is
3675 stored in the .text segment (I've
3676 checked this on SVR3.2 and SCO 3.2.2)
3677 Ian Taylor <ian@cygnus.com>. */
3678 if (S_IS_COMMON (add_symbolP))
3679 add_number += S_GET_VALUE (add_symbolP);
3680 #endif
3681 break;
3682
3683
3684 } /* switch on symbol seg */
3685 } /* if not in local seg */
3686 } /* if there was a + symbol */
3687
3688 if (pcrel)
3689 {
3690 #ifndef TC_M88K
3691 /* This adjustment is not correct on the m88k, for which the
3692 linker does all the computation. */
3693 add_number -= md_pcrel_from (fixP);
3694 #endif
3695 if (add_symbolP == 0)
3696 {
3697 fixP->fx_addsy = &abs_symbol;
3698 } /* if there's an add_symbol */
3699 #if defined (TC_I386) || defined (TE_LYNX)
3700 /* On the 386 we must adjust by the segment vaddr
3701 as well. Ian Taylor. */
3702 add_number -= segP->scnhdr.s_vaddr;
3703 #endif
3704 } /* if pcrel */
3705
3706 if (!fixP->fx_bit_fixP)
3707 {
3708 #ifndef TC_M88K
3709 /* The m88k uses the offset field of the reloc to get around
3710 this problem. */
3711 if ((size == 1
3712 && (add_number & ~0xFF)
3713 && ((add_number & ~0xFF) != (-1 & ~0xFF)))
3714 || (size == 2
3715 && (add_number & ~0xFFFF)
3716 && ((add_number & ~0xFFFF) != (-1 & ~0xFFFF))))
3717 {
3718 as_bad_where (fixP->fx_file, fixP->fx_line,
3719 "Value of %ld too large for field of %d bytes at 0x%lx",
3720 (long) add_number, size,
3721 (unsigned long) (fragP->fr_address + where));
3722 }
3723 #endif
3724 #ifdef WARN_SIGNED_OVERFLOW_WORD
3725 /* Warn if a .word value is too large when treated as
3726 a signed number. We already know it is not too
3727 negative. This is to catch over-large switches
3728 generated by gcc on the 68k. */
3729 if (!flag_signed_overflow_ok
3730 && size == 2
3731 && add_number > 0x7fff)
3732 as_bad_where (fixP->fx_file, fixP->fx_line,
3733 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
3734 (long) add_number,
3735 (unsigned long) (fragP->fr_address + where));
3736 #endif
3737 } /* not a bit fix */
3738 /* once this fix has been applied, we don't have to output anything
3739 nothing more need be done -*/
3740 md_apply_fix (fixP, add_number);
3741 } /* For each fixS in this segment. */
3742 } /* fixup_segment() */
3743
3744 #endif
3745
3746 /* The first entry in a .stab section is special. */
3747
3748 void
3749 obj_coff_init_stab_section (seg)
3750 segT seg;
3751 {
3752 char *file;
3753 char *p;
3754 char *stabstr_name;
3755 unsigned int stroff;
3756
3757 /* Make space for this first symbol. */
3758 p = frag_more (12);
3759 /* Zero it out. */
3760 memset (p, 0, 12);
3761 as_where (&file, (unsigned int *) NULL);
3762 stabstr_name = (char *) alloca (strlen (segment_info[seg].scnhdr.s_name) + 4);
3763 strcpy (stabstr_name, segment_info[seg].scnhdr.s_name);
3764 strcat (stabstr_name, "str");
3765 stroff = get_stab_string_offset (file, stabstr_name);
3766 know (stroff == 1);
3767 md_number_to_chars (p, stroff, 4);
3768 }
3769
3770 /* Fill in the counts in the first entry in a .stab section. */
3771
3772 static void
3773 adjust_stab_section(abfd, seg)
3774 bfd *abfd;
3775 segT seg;
3776 {
3777 segT stabstrseg = SEG_UNKNOWN;
3778 char *secname, *name, *name2;
3779 char *p = NULL;
3780 int i, strsz = 0, nsyms;
3781 fragS *frag = segment_info[seg].frchainP->frch_root;
3782
3783 /* Look for the associated string table section. */
3784
3785 secname = segment_info[seg].scnhdr.s_name;
3786 name = (char *) alloca (strlen (secname) + 4);
3787 strcpy (name, secname);
3788 strcat (name, "str");
3789
3790 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3791 {
3792 name2 = segment_info[i].scnhdr.s_name;
3793 if (name2 != NULL && strncmp(name2, name, 8) == 0)
3794 {
3795 stabstrseg = i;
3796 break;
3797 }
3798 }
3799
3800 /* If we found the section, get its size. */
3801 if (stabstrseg != SEG_UNKNOWN)
3802 strsz = size_section (abfd, stabstrseg);
3803
3804 nsyms = size_section (abfd, seg) / 12 - 1;
3805
3806 /* Look for the first frag of sufficient size for the initial stab
3807 symbol, and collect a pointer to it. */
3808 while (frag && frag->fr_fix < 12)
3809 frag = frag->fr_next;
3810 assert (frag != 0);
3811 p = frag->fr_literal;
3812 assert (p != 0);
3813
3814 /* Write in the number of stab symbols and the size of the string
3815 table. */
3816 bfd_h_put_16 (abfd, (bfd_vma) nsyms, (bfd_byte *) p + 6);
3817 bfd_h_put_32 (abfd, (bfd_vma) strsz, (bfd_byte *) p + 8);
3818 }
3819
3820 #endif /* not BFD_ASSEMBLER */
3821
3822 const pseudo_typeS obj_pseudo_table[] =
3823 {
3824 {"def", obj_coff_def, 0},
3825 {"dim", obj_coff_dim, 0},
3826 {"endef", obj_coff_endef, 0},
3827 {"line", obj_coff_line, 0},
3828 {"ln", obj_coff_ln, 0},
3829 {"appline", obj_coff_ln, 1},
3830 {"scl", obj_coff_scl, 0},
3831 {"size", obj_coff_size, 0},
3832 {"tag", obj_coff_tag, 0},
3833 {"type", obj_coff_type, 0},
3834 {"val", obj_coff_val, 0},
3835 {"section", obj_coff_section, 0},
3836 #ifndef BFD_ASSEMBLER
3837 {"use", obj_coff_section, 0},
3838 {"sect", obj_coff_section, 0},
3839 {"text", obj_coff_text, 0},
3840 {"data", obj_coff_data, 0},
3841 {"bss", obj_coff_bss, 0},
3842 {"lcomm", obj_coff_lcomm, 0},
3843 {"ident", obj_coff_ident, 0},
3844 #else
3845 {"optim", s_ignore, 0}, /* For sun386i cc (?) */
3846 {"ident", s_ignore, 0}, /* we don't yet handle this. */
3847 #endif
3848 {"ABORT", s_abort, 0},
3849 #ifdef TC_M88K
3850 /* The m88k uses sdef instead of def. */
3851 {"sdef", obj_coff_def, 0},
3852 #endif
3853 {NULL} /* end sentinel */
3854 }; /* obj_pseudo_table */
GDB Binutils - Deliverables
This page took 0.107136 seconds and 5 git commands to generate.