projects / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
gcc -Wall lint.
[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 /* @@ Try this unconditionally for now. Let me know if you encounter
2951 cases that don't work. -- Ken */
2952 #if 1 /* !defined(TC_H8300) && !defined(TC_Z8K) */
2953 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
2954 {
2955 fixup_mdeps (segment_info[i].frchainP->frch_root, &headers, i);
2956 fixup_segment (&segment_info[i], i);
2957 }
2958 #endif
2959
2960 /* Look for ".stab" segments and fill in their initial symbols
2961 correctly. */
2962 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
2963 {
2964 name = segment_info[i].scnhdr.s_name;
2965
2966 if (name != NULL
2967 && strncmp (".stab", name, 5) == 0
2968 && strncmp (".stabstr", name, 8) != 0)
2969 adjust_stab_section (abfd, i);
2970 }
2971
2972 file_cursor = H_GET_TEXT_FILE_OFFSET (&headers);
2973
2974 bfd_seek (abfd, (file_ptr) file_cursor, 0);
2975
2976 /* Plant the data */
2977
2978 fill_section (abfd, &headers, &file_cursor);
2979
2980 do_relocs_for (abfd, &headers, &file_cursor);
2981
2982 do_linenos_for (abfd, &headers, &file_cursor);
2983
2984 H_SET_FILE_MAGIC_NUMBER (&headers, COFF_MAGIC);
2985 #ifndef OBJ_COFF_OMIT_TIMESTAMP
2986 H_SET_TIME_STAMP (&headers, (long)time((long*)0));
2987 #else
2988 H_SET_TIME_STAMP (&headers, 0);
2989 #endif
2990 #ifdef TC_COFF_SET_MACHINE
2991 TC_COFF_SET_MACHINE (&headers);
2992 #endif
2993
2994 #ifdef KEEP_RELOC_INFO
2995 H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
2996 COFF_FLAGS | coff_flags));
2997 #else
2998 H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
2999 (H_GET_RELOCATION_SIZE(&headers) ? 0 : F_RELFLG) |
3000 COFF_FLAGS | coff_flags));
3001 #endif
3002
3003 {
3004 unsigned int symtable_size = H_GET_SYMBOL_TABLE_SIZE (&headers);
3005 char *buffer1 = xmalloc (symtable_size + string_byte_count + 1);
3006
3007 H_SET_SYMBOL_TABLE_POINTER (&headers, bfd_tell (abfd));
3008 w_symbols (abfd, buffer1, symbol_rootP);
3009 if (string_byte_count > 0)
3010 w_strings (buffer1 + symtable_size);
3011 bfd_write (buffer1, 1, symtable_size + string_byte_count, abfd);
3012 free (buffer1);
3013 }
3014
3015 coff_header_append (abfd, &headers);
3016 #if 0
3017 /* Recent changes to write need this, but where it should
3018 go is up to Ken.. */
3019 if (bfd_close_all_done (abfd) == false)
3020 as_fatal ("Can't close %s: %s", out_file_name,
3021 bfd_errmsg (bfd_get_error ()));
3022 #else
3023 {
3024 extern bfd *stdoutput;
3025 stdoutput = abfd;
3026 }
3027 #endif
3028
3029 }
3030
3031 /* Add a new segment. This is called from subseg_new via the
3032 obj_new_segment macro. */
3033
3034 segT
3035 obj_coff_add_segment (name)
3036 const char *name;
3037 {
3038 unsigned int len;
3039 unsigned int i;
3040
3041 /* Find out if we've already got a section of this name. */
3042 len = strlen (name);
3043 if (len < sizeof (segment_info[i].scnhdr.s_name))
3044 ++len;
3045 else
3046 len = sizeof (segment_info[i].scnhdr.s_name);
3047 for (i = SEG_E0; i < SEG_E9 && segment_info[i].scnhdr.s_name[0]; i++)
3048 if (strncmp (segment_info[i].scnhdr.s_name, name, len) == 0
3049 && (len == sizeof (segment_info[i].scnhdr.s_name)
3050 || segment_info[i].scnhdr.s_name[len] == '\0'))
3051 return (segT) i;
3052
3053 if (i == SEG_E9)
3054 {
3055 as_bad ("Too many new sections; can't add \"%s\"", name);
3056 return now_seg;
3057 }
3058
3059 /* Add a new section. */
3060 strncpy (segment_info[i].scnhdr.s_name, name,
3061 sizeof (segment_info[i].scnhdr.s_name));
3062 segment_info[i].scnhdr.s_flags = STYP_REG;
3063
3064 return (segT) i;
3065 }
3066
3067 /*
3068 * implement the .section pseudo op:
3069 * .section name {, "flags"}
3070 * ^ ^
3071 * | +--- optional flags: 'b' for bss
3072 * | 'i' for info
3073 * +-- section name 'l' for lib
3074 * 'n' for noload
3075 * 'o' for over
3076 * 'w' for data
3077 * 'd' (apparently m88k for data)
3078 * 'x' for text
3079 * But if the argument is not a quoted string, treat it as a
3080 * subsegment number.
3081 */
3082
3083 void
3084 obj_coff_section (ignore)
3085 int ignore;
3086 {
3087 /* Strip out the section name */
3088 char *section_name;
3089 char *section_name_end;
3090 char c;
3091 int argp;
3092 unsigned int len;
3093 unsigned int exp;
3094 long flags;
3095
3096 section_name = input_line_pointer;
3097 c = get_symbol_end ();
3098 section_name_end = input_line_pointer;
3099
3100 len = section_name_end - section_name;
3101 input_line_pointer++;
3102 SKIP_WHITESPACE ();
3103
3104 argp = 0;
3105 if (c == ',')
3106 argp = 1;
3107 else if (*input_line_pointer == ',')
3108 {
3109 argp = 1;
3110 ++input_line_pointer;
3111 SKIP_WHITESPACE ();
3112 }
3113
3114 exp = 0;
3115 flags = 0;
3116 if (argp)
3117 {
3118 if (*input_line_pointer != '"')
3119 exp = get_absolute_expression ();
3120 else
3121 {
3122 ++input_line_pointer;
3123 while (*input_line_pointer != '"'
3124 && ! is_end_of_line[(unsigned char) *input_line_pointer])
3125 {
3126 switch (*input_line_pointer)
3127 {
3128 case 'b': flags |= STYP_BSS; break;
3129 case 'i': flags |= STYP_INFO; break;
3130 case 'l': flags |= STYP_LIB; break;
3131 case 'n': flags |= STYP_NOLOAD; break;
3132 case 'o': flags |= STYP_OVER; break;
3133 case 'd':
3134 case 'w': flags |= STYP_DATA; break;
3135 case 'x': flags |= STYP_TEXT; break;
3136 default:
3137 as_warn("unknown section attribute '%c'",
3138 *input_line_pointer);
3139 break;
3140 }
3141 ++input_line_pointer;
3142 }
3143 if (*input_line_pointer == '"')
3144 ++input_line_pointer;
3145 }
3146 }
3147
3148 subseg_new (section_name, (subsegT) exp);
3149
3150 segment_info[now_seg].scnhdr.s_flags |= flags;
3151
3152 *section_name_end = c;
3153 }
3154
3155
3156 static void
3157 obj_coff_text (ignore)
3158 int ignore;
3159 {
3160 subseg_new (".text", get_absolute_expression ());
3161 }
3162
3163
3164 static void
3165 obj_coff_data (ignore)
3166 int ignore;
3167 {
3168 if (flag_readonly_data_in_text)
3169 subseg_new (".text", get_absolute_expression () + 1000);
3170 else
3171 subseg_new (".data", get_absolute_expression ());
3172 }
3173
3174 static void
3175 obj_coff_bss (ignore)
3176 int ignore;
3177 {
3178 if (*input_line_pointer == '\n') /* .bss */
3179 subseg_new(".bss", get_absolute_expression());
3180 else /* .bss id,expr */
3181 obj_coff_lcomm(0);
3182 }
3183
3184 static void
3185 obj_coff_ident (ignore)
3186 int ignore;
3187 {
3188 segT current_seg = now_seg; /* save current seg */
3189 subsegT current_subseg = now_subseg;
3190 subseg_new (".comment", 0); /* .comment seg */
3191 stringer (1); /* read string */
3192 subseg_set (current_seg, current_subseg); /* restore current seg */
3193 }
3194
3195 void
3196 c_symbol_merge (debug, normal)
3197 symbolS *debug;
3198 symbolS *normal;
3199 {
3200 S_SET_DATA_TYPE (normal, S_GET_DATA_TYPE (debug));
3201 S_SET_STORAGE_CLASS (normal, S_GET_STORAGE_CLASS (debug));
3202
3203 if (S_GET_NUMBER_AUXILIARY (debug) > S_GET_NUMBER_AUXILIARY (normal))
3204 {
3205 S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));
3206 } /* take the most we have */
3207
3208 if (S_GET_NUMBER_AUXILIARY (debug) > 0)
3209 {
3210 memcpy ((char *) &normal->sy_symbol.ost_auxent[0],
3211 (char *) &debug->sy_symbol.ost_auxent[0],
3212 (unsigned int) (S_GET_NUMBER_AUXILIARY (debug) * AUXESZ));
3213 } /* Move all the auxiliary information */
3214
3215 /* Move the debug flags. */
3216 SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
3217 } /* c_symbol_merge() */
3218
3219 static int
3220 c_line_new (symbol, paddr, line_number, frag)
3221 symbolS * symbol;
3222 long paddr;
3223 int line_number;
3224 fragS * frag;
3225 {
3226 struct lineno_list *new_line =
3227 (struct lineno_list *) xmalloc (sizeof (struct lineno_list));
3228
3229 segment_info_type *s = segment_info + now_seg;
3230 new_line->line.l_lnno = line_number;
3231
3232 if (line_number == 0)
3233 {
3234 last_line_symbol = symbol;
3235 new_line->line.l_addr.l_symndx = (long) symbol;
3236 }
3237 else
3238 {
3239 new_line->line.l_addr.l_paddr = paddr;
3240 }
3241
3242 new_line->frag = (char *) frag;
3243 new_line->next = (struct lineno_list *) NULL;
3244
3245
3246 if (s->lineno_list_head == (struct lineno_list *) NULL)
3247 {
3248 s->lineno_list_head = new_line;
3249 }
3250 else
3251 {
3252 s->lineno_list_tail->next = new_line;
3253 }
3254 s->lineno_list_tail = new_line;
3255 return LINESZ * s->scnhdr.s_nlnno++;
3256 }
3257
3258 void
3259 c_dot_file_symbol (filename)
3260 char *filename;
3261 {
3262 symbolS *symbolP;
3263
3264 symbolP = symbol_new (".file",
3265 SEG_DEBUG,
3266 0,
3267 &zero_address_frag);
3268
3269 S_SET_STORAGE_CLASS (symbolP, C_FILE);
3270 S_SET_NUMBER_AUXILIARY (symbolP, 1);
3271 SA_SET_FILE_FNAME (symbolP, filename);
3272 #ifndef NO_LISTING
3273 {
3274 extern int listing;
3275 if (listing)
3276 {
3277 listing_source_file (filename);
3278 }
3279
3280 }
3281
3282 #endif
3283 SF_SET_DEBUG (symbolP);
3284 S_SET_VALUE (symbolP, (valueT) previous_file_symbol);
3285
3286 previous_file_symbol = symbolP;
3287
3288 /* Make sure that the symbol is first on the symbol chain */
3289 if (symbol_rootP != symbolP)
3290 {
3291 if (symbolP == symbol_lastP)
3292 {
3293 symbol_lastP = symbol_lastP->sy_previous;
3294 } /* if it was the last thing on the list */
3295
3296 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3297 symbol_insert (symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
3298 symbol_rootP = symbolP;
3299 } /* if not first on the list */
3300
3301 } /* c_dot_file_symbol() */
3302
3303 /*
3304 * Build a 'section static' symbol.
3305 */
3306
3307 symbolS *
3308 c_section_symbol (name, idx)
3309 char *name;
3310 int idx;
3311 {
3312 symbolS *symbolP;
3313
3314 symbolP = symbol_new (name, idx,
3315 0,
3316 &zero_address_frag);
3317
3318 S_SET_STORAGE_CLASS (symbolP, C_STAT);
3319 S_SET_NUMBER_AUXILIARY (symbolP, 1);
3320
3321 SF_SET_STATICS (symbolP);
3322
3323 return symbolP;
3324 } /* c_section_symbol() */
3325
3326 static void
3327 w_symbols (abfd, where, symbol_rootP)
3328 bfd * abfd;
3329 char *where;
3330 symbolS * symbol_rootP;
3331 {
3332 symbolS *symbolP;
3333 unsigned int i;
3334
3335 /* First fill in those values we have only just worked out */
3336 for (i = SEG_E0; i < SEG_E9; i++)
3337 {
3338 symbolP = segment_info[i].dot;
3339 if (symbolP)
3340 {
3341 SA_SET_SCN_SCNLEN (symbolP, segment_info[i].scnhdr.s_size);
3342 SA_SET_SCN_NRELOC (symbolP, segment_info[i].scnhdr.s_nreloc);
3343 SA_SET_SCN_NLINNO (symbolP, segment_info[i].scnhdr.s_nlnno);
3344 }
3345 }
3346
3347 /*
3348 * Emit all symbols left in the symbol chain.
3349 */
3350 for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
3351 {
3352 /* Used to save the offset of the name. It is used to point
3353 to the string in memory but must be a file offset. */
3354 register char *temp;
3355
3356 tc_coff_symbol_emit_hook (symbolP);
3357
3358 temp = S_GET_NAME (symbolP);
3359 if (SF_GET_STRING (symbolP))
3360 {
3361 S_SET_OFFSET (symbolP, symbolP->sy_name_offset);
3362 S_SET_ZEROES (symbolP, 0);
3363 }
3364 else
3365 {
3366 memset (symbolP->sy_symbol.ost_entry.n_name, 0, SYMNMLEN);
3367 strncpy (symbolP->sy_symbol.ost_entry.n_name, temp, SYMNMLEN);
3368 }
3369 where = symbol_to_chars (abfd, where, symbolP);
3370 S_SET_NAME (symbolP, temp);
3371 }
3372
3373 } /* w_symbols() */
3374
3375 static void
3376 obj_coff_lcomm (ignore)
3377 int ignore;
3378 {
3379 s_lcomm(0);
3380 return;
3381 #if 0
3382 char *name;
3383 char c;
3384 int temp;
3385 char *p;
3386
3387 symbolS *symbolP;
3388
3389 name = input_line_pointer;
3390
3391 c = get_symbol_end ();
3392 p = input_line_pointer;
3393 *p = c;
3394 SKIP_WHITESPACE ();
3395 if (*input_line_pointer != ',')
3396 {
3397 as_bad ("Expected comma after name");
3398 ignore_rest_of_line ();
3399 return;
3400 }
3401 if (*input_line_pointer == '\n')
3402 {
3403 as_bad ("Missing size expression");
3404 return;
3405 }
3406 input_line_pointer++;
3407 if ((temp = get_absolute_expression ()) < 0)
3408 {
3409 as_warn ("lcomm length (%d.) <0! Ignored.", temp);
3410 ignore_rest_of_line ();
3411 return;
3412 }
3413 *p = 0;
3414
3415 symbolP = symbol_find_or_make(name);
3416
3417 if (S_GET_SEGMENT(symbolP) == SEG_UNKNOWN &&
3418 S_GET_VALUE(symbolP) == 0)
3419 {
3420 if (! need_pass_2)
3421 {
3422 char *p;
3423 segT current_seg = now_seg; /* save current seg */
3424 subsegT current_subseg = now_subseg;
3425
3426 subseg_set (SEG_E2, 1);
3427 symbolP->sy_frag = frag_now;
3428 p = frag_var(rs_org, 1, 1, (relax_substateT)0, symbolP,
3429 temp, (char *)0);
3430 *p = 0;
3431 subseg_set (current_seg, current_subseg); /* restore current seg */
3432 S_SET_SEGMENT(symbolP, SEG_E2);
3433 S_SET_STORAGE_CLASS(symbolP, C_STAT);
3434 }
3435 }
3436 else
3437 as_bad("Symbol %s already defined", name);
3438
3439 demand_empty_rest_of_line();
3440 #endif
3441 }
3442
3443 static void
3444 fixup_mdeps (frags, h, this_segment)
3445 fragS * frags;
3446 object_headers * h;
3447 segT this_segment;
3448 {
3449 subseg_change (this_segment, 0);
3450 while (frags)
3451 {
3452 switch (frags->fr_type)
3453 {
3454 case rs_align:
3455 case rs_org:
3456 frags->fr_type = rs_fill;
3457 frags->fr_offset =
3458 (frags->fr_next->fr_address - frags->fr_address - frags->fr_fix);
3459 break;
3460 case rs_machine_dependent:
3461 md_convert_frag (h, frags);
3462 frag_wane (frags);
3463 break;
3464 default:
3465 ;
3466 }
3467 frags = frags->fr_next;
3468 }
3469 }
3470
3471 #if 1
3472 static void
3473 fixup_segment (segP, this_segment_type)
3474 segment_info_type * segP;
3475 segT this_segment_type;
3476 {
3477 register fixS * fixP;
3478 register symbolS *add_symbolP;
3479 register symbolS *sub_symbolP;
3480 register long add_number;
3481 register int size;
3482 register char *place;
3483 register long where;
3484 register char pcrel;
3485 register fragS *fragP;
3486 register segT add_symbol_segment = absolute_section;
3487
3488
3489 for (fixP = segP->fix_root; fixP; fixP = fixP->fx_next)
3490 {
3491 fragP = fixP->fx_frag;
3492 know (fragP);
3493 where = fixP->fx_where;
3494 place = fragP->fr_literal + where;
3495 size = fixP->fx_size;
3496 add_symbolP = fixP->fx_addsy;
3497 #ifdef TC_I960
3498 if (fixP->fx_tcbit && SF_GET_CALLNAME (add_symbolP))
3499 {
3500 /* Relocation should be done via the associated 'bal' entry
3501 point symbol. */
3502
3503 if (!SF_GET_BALNAME (tc_get_bal_of_call (add_symbolP)))
3504 {
3505 as_bad_where (fixP->fx_file, fixP->fx_line,
3506 "No 'bal' entry point for leafproc %s",
3507 S_GET_NAME (add_symbolP));
3508 continue;
3509 }
3510 fixP->fx_addsy = add_symbolP = tc_get_bal_of_call (add_symbolP);
3511 }
3512 #endif
3513 sub_symbolP = fixP->fx_subsy;
3514 add_number = fixP->fx_offset;
3515 pcrel = fixP->fx_pcrel;
3516
3517 if (add_symbolP)
3518 {
3519 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
3520 } /* if there is an addend */
3521
3522 if (sub_symbolP)
3523 {
3524 if (!add_symbolP)
3525 {
3526 /* Its just -sym */
3527 if (S_GET_SEGMENT (sub_symbolP) != absolute_section)
3528 {
3529 as_bad_where (fixP->fx_file, fixP->fx_line,
3530 "Negative of non-absolute symbol %s",
3531 S_GET_NAME (sub_symbolP));
3532 } /* not absolute */
3533
3534 add_number -= S_GET_VALUE (sub_symbolP);
3535 fixP->fx_subsy = 0;
3536
3537 /* if sub_symbol is in the same segment that add_symbol
3538 and add_symbol is either in DATA, TEXT, BSS or ABSOLUTE */
3539 }
3540 else if ((S_GET_SEGMENT (sub_symbolP) == add_symbol_segment)
3541 && (SEG_NORMAL (add_symbol_segment)
3542 || (add_symbol_segment == absolute_section)))
3543 {
3544 /* Difference of 2 symbols from same segment. Can't
3545 make difference of 2 undefineds: 'value' means
3546 something different for N_UNDF. */
3547 #ifdef TC_I960
3548 /* Makes no sense to use the difference of 2 arbitrary symbols
3549 as the target of a call instruction. */
3550 if (fixP->fx_tcbit)
3551 {
3552 as_bad_where (fixP->fx_file, fixP->fx_line,
3553 "callj to difference of 2 symbols");
3554 }
3555 #endif /* TC_I960 */
3556 add_number += S_GET_VALUE (add_symbolP) -
3557 S_GET_VALUE (sub_symbolP);
3558
3559 add_symbolP = NULL;
3560 fixP->fx_addsy = NULL;
3561 fixP->fx_subsy = NULL;
3562 fixP->fx_done = 1;
3563 }
3564 else
3565 {
3566 /* Different segments in subtraction. */
3567 know (!(S_IS_EXTERNAL (sub_symbolP) && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
3568
3569 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
3570 {
3571 add_number -= S_GET_VALUE (sub_symbolP);
3572 }
3573 #ifdef DIFF_EXPR_OK
3574 else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
3575 #if 0 /* Okay for 68k, at least... */
3576 && !pcrel
3577 #endif
3578 )
3579 {
3580 /* Make it pc-relative. */
3581 add_number += (md_pcrel_from (fixP)
3582 - S_GET_VALUE (sub_symbolP));
3583 pcrel = 1;
3584 fixP->fx_pcrel = 1;
3585 sub_symbolP = 0;
3586 fixP->fx_subsy = 0;
3587 }
3588 #endif
3589 else
3590 {
3591 as_bad_where (fixP->fx_file, fixP->fx_line,
3592 "Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %ld.",
3593 segment_name (S_GET_SEGMENT (sub_symbolP)),
3594 S_GET_NAME (sub_symbolP),
3595 (long) (fragP->fr_address + where));
3596 } /* if absolute */
3597 }
3598 } /* if sub_symbolP */
3599
3600 if (add_symbolP)
3601 {
3602 if (add_symbol_segment == this_segment_type && pcrel)
3603 {
3604 /*
3605 * This fixup was made when the symbol's segment was
3606 * SEG_UNKNOWN, but it is now in the local segment.
3607 * So we know how to do the address without relocation.
3608 */
3609 #ifdef TC_I960
3610 /* reloc_callj() may replace a 'call' with a 'calls' or a 'bal',
3611 * in which cases it modifies *fixP as appropriate. In the case
3612 * of a 'calls', no further work is required, and *fixP has been
3613 * set up to make the rest of the code below a no-op.
3614 */
3615 reloc_callj (fixP);
3616 #endif /* TC_I960 */
3617
3618 add_number += S_GET_VALUE (add_symbolP);
3619 add_number -= md_pcrel_from (fixP);
3620 #if defined (TC_I386) || defined (TE_LYNX)
3621 /* On the 386 we must adjust by the segment
3622 vaddr as well. Ian Taylor. */
3623 add_number -= segP->scnhdr.s_vaddr;
3624 #endif
3625 pcrel = 0; /* Lie. Don't want further pcrel processing. */
3626 fixP->fx_addsy = NULL;
3627 fixP->fx_done = 1;
3628 }
3629 else
3630 {
3631 switch (add_symbol_segment)
3632 {
3633 case absolute_section:
3634 #ifdef TC_I960
3635 reloc_callj (fixP); /* See comment about reloc_callj() above*/
3636 #endif /* TC_I960 */
3637 add_number += S_GET_VALUE (add_symbolP);
3638 fixP->fx_addsy = NULL;
3639 fixP->fx_done = 1;
3640 add_symbolP = NULL;
3641 break;
3642 default:
3643
3644 #ifdef TC_A29K
3645 /* This really should be handled in the linker, but
3646 backward compatibility forbids. */
3647 add_number += S_GET_VALUE (add_symbolP);
3648 #else
3649 add_number += S_GET_VALUE (add_symbolP) +
3650 segment_info[S_GET_SEGMENT (add_symbolP)].scnhdr.s_paddr;
3651 #endif
3652 break;
3653
3654 case SEG_UNKNOWN:
3655 #ifdef TC_I960
3656 if ((int) fixP->fx_bit_fixP == 13)
3657 {
3658 /* This is a COBR instruction. They have only a
3659 * 13-bit displacement and are only to be used
3660 * for local branches: flag as error, don't generate
3661 * relocation.
3662 */
3663 as_bad_where (fixP->fx_file, fixP->fx_line,
3664 "can't use COBR format with external label");
3665 fixP->fx_addsy = NULL;
3666 fixP->fx_done = 1;
3667 continue;
3668 } /* COBR */
3669 #endif /* TC_I960 */
3670 #if defined (TC_I386) || defined (TE_LYNX)
3671 /* 386 COFF uses a peculiar format in
3672 which the value of a common symbol is
3673 stored in the .text segment (I've
3674 checked this on SVR3.2 and SCO 3.2.2)
3675 Ian Taylor <ian@cygnus.com>. */
3676 if (S_IS_COMMON (add_symbolP))
3677 add_number += S_GET_VALUE (add_symbolP);
3678 #endif
3679 break;
3680
3681
3682 } /* switch on symbol seg */
3683 } /* if not in local seg */
3684 } /* if there was a + symbol */
3685
3686 if (pcrel)
3687 {
3688 #ifndef TC_M88K
3689 /* This adjustment is not correct on the m88k, for which the
3690 linker does all the computation. */
3691 add_number -= md_pcrel_from (fixP);
3692 #endif
3693 if (add_symbolP == 0)
3694 {
3695 fixP->fx_addsy = &abs_symbol;
3696 } /* if there's an add_symbol */
3697 #if defined (TC_I386) || defined (TE_LYNX)
3698 /* On the 386 we must adjust by the segment vaddr
3699 as well. Ian Taylor. */
3700 add_number -= segP->scnhdr.s_vaddr;
3701 #endif
3702 } /* if pcrel */
3703
3704 if (!fixP->fx_bit_fixP)
3705 {
3706 #ifndef TC_M88K
3707 /* The m88k uses the offset field of the reloc to get around
3708 this problem. */
3709 if ((size == 1
3710 && (add_number & ~0xFF)
3711 && ((add_number & ~0xFF) != (-1 & ~0xFF)))
3712 || (size == 2
3713 && (add_number & ~0xFFFF)
3714 && ((add_number & ~0xFFFF) != (-1 & ~0xFFFF))))
3715 {
3716 as_bad_where (fixP->fx_file, fixP->fx_line,
3717 "Value of %ld too large for field of %d bytes at 0x%lx",
3718 (long) add_number, size,
3719 (unsigned long) (fragP->fr_address + where));
3720 }
3721 #endif
3722 #ifdef WARN_SIGNED_OVERFLOW_WORD
3723 /* Warn if a .word value is too large when treated as
3724 a signed number. We already know it is not too
3725 negative. This is to catch over-large switches
3726 generated by gcc on the 68k. */
3727 if (!flag_signed_overflow_ok
3728 && size == 2
3729 && add_number > 0x7fff)
3730 as_bad_where (fixP->fx_file, fixP->fx_line,
3731 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
3732 (long) add_number,
3733 (unsigned long) (fragP->fr_address + where));
3734 #endif
3735 } /* not a bit fix */
3736 /* once this fix has been applied, we don't have to output anything
3737 nothing more need be done -*/
3738 md_apply_fix (fixP, add_number);
3739 } /* For each fixS in this segment. */
3740 } /* fixup_segment() */
3741
3742 #endif
3743
3744 /* The first entry in a .stab section is special. */
3745
3746 void
3747 obj_coff_init_stab_section (seg)
3748 segT seg;
3749 {
3750 char *file;
3751 char *p;
3752 char *stabstr_name;
3753 unsigned int stroff;
3754
3755 /* Make space for this first symbol. */
3756 p = frag_more (12);
3757 /* Zero it out. */
3758 memset (p, 0, 12);
3759 as_where (&file, (unsigned int *) NULL);
3760 stabstr_name = (char *) alloca (strlen (segment_info[seg].scnhdr.s_name) + 4);
3761 strcpy (stabstr_name, segment_info[seg].scnhdr.s_name);
3762 strcat (stabstr_name, "str");
3763 stroff = get_stab_string_offset (file, stabstr_name);
3764 know (stroff == 1);
3765 md_number_to_chars (p, stroff, 4);
3766 }
3767
3768 /* Fill in the counts in the first entry in a .stab section. */
3769
3770 static void
3771 adjust_stab_section(abfd, seg)
3772 bfd *abfd;
3773 segT seg;
3774 {
3775 segT stabstrseg = SEG_UNKNOWN;
3776 char *secname, *name, *name2;
3777 char *p = NULL;
3778 int i, strsz = 0, nsyms;
3779 fragS *frag = segment_info[seg].frchainP->frch_root;
3780
3781 /* Look for the associated string table section. */
3782
3783 secname = segment_info[seg].scnhdr.s_name;
3784 name = (char *) alloca (strlen (secname) + 4);
3785 strcpy (name, secname);
3786 strcat (name, "str");
3787
3788 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3789 {
3790 name2 = segment_info[i].scnhdr.s_name;
3791 if (name2 != NULL && strncmp(name2, name, 8) == 0)
3792 {
3793 stabstrseg = i;
3794 break;
3795 }
3796 }
3797
3798 /* If we found the section, get its size. */
3799 if (stabstrseg != SEG_UNKNOWN)
3800 strsz = size_section (abfd, stabstrseg);
3801
3802 nsyms = size_section (abfd, seg) / 12 - 1;
3803
3804 /* Look for the first frag of sufficient size for the initial stab
3805 symbol, and collect a pointer to it. */
3806 while (frag && frag->fr_fix < 12)
3807 frag = frag->fr_next;
3808 assert (frag != 0);
3809 p = frag->fr_literal;
3810 assert (p != 0);
3811
3812 /* Write in the number of stab symbols and the size of the string
3813 table. */
3814 bfd_h_put_16 (abfd, (bfd_vma) nsyms, (bfd_byte *) p + 6);
3815 bfd_h_put_32 (abfd, (bfd_vma) strsz, (bfd_byte *) p + 8);
3816 }
3817
3818 #endif /* not BFD_ASSEMBLER */
3819
3820 const pseudo_typeS obj_pseudo_table[] =
3821 {
3822 {"def", obj_coff_def, 0},
3823 {"dim", obj_coff_dim, 0},
3824 {"endef", obj_coff_endef, 0},
3825 {"line", obj_coff_line, 0},
3826 {"ln", obj_coff_ln, 0},
3827 {"appline", obj_coff_ln, 1},
3828 {"scl", obj_coff_scl, 0},
3829 {"size", obj_coff_size, 0},
3830 {"tag", obj_coff_tag, 0},
3831 {"type", obj_coff_type, 0},
3832 {"val", obj_coff_val, 0},
3833 {"section", obj_coff_section, 0},
3834 #ifndef BFD_ASSEMBLER
3835 {"use", obj_coff_section, 0},
3836 {"sect", obj_coff_section, 0},
3837 {"text", obj_coff_text, 0},
3838 {"data", obj_coff_data, 0},
3839 {"bss", obj_coff_bss, 0},
3840 {"lcomm", obj_coff_lcomm, 0},
3841 {"ident", obj_coff_ident, 0},
3842 #else
3843 {"optim", s_ignore, 0}, /* For sun386i cc (?) */
3844 {"ident", s_ignore, 0}, /* we don't yet handle this. */
3845 #endif
3846 {"ABORT", s_abort, 0},
3847 #ifdef TC_M88K
3848 /* The m88k uses sdef instead of def. */
3849 {"sdef", obj_coff_def, 0},
3850 #endif
3851 {NULL} /* end sentinel */
3852 }; /* obj_pseudo_table */