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