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