projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
This commit was generated by cvs2svn to track changes on a CVS vendor
[deliverable/binutils-gdb.git] / gas / config / tc-ppc.c
1 /* tc-ppc.c -- Assemble for the PowerPC or POWER (RS/6000)
2 Copyright (C) 1994, 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor, Cygnus Support.
4
5 This file is part of GAS, the GNU Assembler.
6
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA. */
21
22 #include <stdio.h>
23 #include <ctype.h>
24 #include "as.h"
25 #include "subsegs.h"
26
27 #include "opcode/ppc.h"
28
29 #ifdef OBJ_ELF
30 #include "elf/ppc.h"
31 #endif
32
33 #ifdef TE_PE
34 #include "coff/pe.h"
35 #endif
36
37 /* This is the assembler for the PowerPC or POWER (RS/6000) chips. */
38
39 /* Tell the main code what the endianness is. */
40 extern int target_big_endian;
41
42 /* Whether or not, we've set target_big_endian. */
43 static int set_target_endian = 0;
44
45 /* Whether to use user friendly register names. */
46 #ifndef TARGET_REG_NAMES_P
47 #ifdef TE_PE
48 #define TARGET_REG_NAMES_P true
49 #else
50 #define TARGET_REG_NAMES_P false
51 #endif
52 #endif
53
54 static boolean reg_names_p = TARGET_REG_NAMES_P;
55
56 static boolean register_name PARAMS ((expressionS *));
57 static void ppc_set_cpu PARAMS ((void));
58 static unsigned long ppc_insert_operand
59 PARAMS ((unsigned long insn, const struct powerpc_operand *operand,
60 offsetT val, char *file, unsigned int line));
61 static void ppc_macro PARAMS ((char *str, const struct powerpc_macro *macro));
62 static void ppc_byte PARAMS ((int));
63 static int ppc_is_toc_sym PARAMS ((symbolS *sym));
64 static void ppc_tc PARAMS ((int));
65
66 #ifdef OBJ_XCOFF
67 static void ppc_comm PARAMS ((int));
68 static void ppc_bb PARAMS ((int));
69 static void ppc_bc PARAMS ((int));
70 static void ppc_bf PARAMS ((int));
71 static void ppc_biei PARAMS ((int));
72 static void ppc_bs PARAMS ((int));
73 static void ppc_eb PARAMS ((int));
74 static void ppc_ec PARAMS ((int));
75 static void ppc_ef PARAMS ((int));
76 static void ppc_es PARAMS ((int));
77 static void ppc_csect PARAMS ((int));
78 static void ppc_change_csect PARAMS ((symbolS *));
79 static void ppc_function PARAMS ((int));
80 static void ppc_extern PARAMS ((int));
81 static void ppc_lglobl PARAMS ((int));
82 static void ppc_section PARAMS ((int));
83 static void ppc_stabx PARAMS ((int));
84 static void ppc_rename PARAMS ((int));
85 static void ppc_toc PARAMS ((int));
86 static void ppc_xcoff_cons PARAMS ((int));
87 #endif
88
89 #ifdef OBJ_ELF
90 static bfd_reloc_code_real_type ppc_elf_suffix PARAMS ((char **, expressionS *));
91 static void ppc_elf_cons PARAMS ((int));
92 static void ppc_elf_rdata PARAMS ((int));
93 static void ppc_elf_lcomm PARAMS ((int));
94 static void ppc_elf_validate_fix PARAMS ((fixS *, segT));
95 #endif
96
97 #ifdef TE_PE
98 static void ppc_set_current_section PARAMS ((segT));
99 static void ppc_previous PARAMS ((int));
100 static void ppc_pdata PARAMS ((int));
101 static void ppc_ydata PARAMS ((int));
102 static void ppc_reldata PARAMS ((int));
103 static void ppc_rdata PARAMS ((int));
104 static void ppc_ualong PARAMS ((int));
105 static void ppc_znop PARAMS ((int));
106 static void ppc_pe_comm PARAMS ((int));
107 static void ppc_pe_section PARAMS ((int));
108 static void ppc_pe_function PARAMS ((int));
109 static void ppc_pe_tocd PARAMS ((int));
110 #endif
111 \f
112 /* Generic assembler global variables which must be defined by all
113 targets. */
114
115 #ifdef OBJ_ELF
116 /* This string holds the chars that always start a comment. If the
117 pre-processor is disabled, these aren't very useful. The macro
118 tc_comment_chars points to this. We use this, rather than the
119 usual comment_chars, so that we can switch for Solaris conventions. */
120 static const char ppc_solaris_comment_chars[] = "#!";
121 static const char ppc_eabi_comment_chars[] = "#";
122
123 #ifdef TARGET_SOLARIS_COMMENT
124 const char *ppc_comment_chars = ppc_solaris_comment_chars;
125 #else
126 const char *ppc_comment_chars = ppc_eabi_comment_chars;
127 #endif
128 #else
129 const char comment_chars[] = "#";
130 #endif
131
132 /* Characters which start a comment at the beginning of a line. */
133 const char line_comment_chars[] = "#";
134
135 /* Characters which may be used to separate multiple commands on a
136 single line. */
137 const char line_separator_chars[] = ";";
138
139 /* Characters which are used to indicate an exponent in a floating
140 point number. */
141 const char EXP_CHARS[] = "eE";
142
143 /* Characters which mean that a number is a floating point constant,
144 as in 0d1.0. */
145 const char FLT_CHARS[] = "dD";
146 \f
147 /* The target specific pseudo-ops which we support. */
148
149 const pseudo_typeS md_pseudo_table[] =
150 {
151 /* Pseudo-ops which must be overridden. */
152 { "byte", ppc_byte, 0 },
153
154 #ifdef OBJ_XCOFF
155 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
156 legitimately belong in the obj-*.c file. However, XCOFF is based
157 on COFF, and is only implemented for the RS/6000. We just use
158 obj-coff.c, and add what we need here. */
159 { "comm", ppc_comm, 0 },
160 { "lcomm", ppc_comm, 1 },
161 { "bb", ppc_bb, 0 },
162 { "bc", ppc_bc, 0 },
163 { "bf", ppc_bf, 0 },
164 { "bi", ppc_biei, 0 },
165 { "bs", ppc_bs, 0 },
166 { "csect", ppc_csect, 0 },
167 { "data", ppc_section, 'd' },
168 { "eb", ppc_eb, 0 },
169 { "ec", ppc_ec, 0 },
170 { "ef", ppc_ef, 0 },
171 { "ei", ppc_biei, 1 },
172 { "es", ppc_es, 0 },
173 { "extern", ppc_extern, 0 },
174 { "function", ppc_function, 0 },
175 { "lglobl", ppc_lglobl, 0 },
176 { "rename", ppc_rename, 0 },
177 { "stabx", ppc_stabx, 0 },
178 { "text", ppc_section, 't' },
179 { "toc", ppc_toc, 0 },
180 { "long", ppc_xcoff_cons, 2 },
181 { "word", ppc_xcoff_cons, 1 },
182 { "short", ppc_xcoff_cons, 1 },
183 #endif
184
185 #ifdef OBJ_ELF
186 { "long", ppc_elf_cons, 4 },
187 { "word", ppc_elf_cons, 2 },
188 { "short", ppc_elf_cons, 2 },
189 { "rdata", ppc_elf_rdata, 0 },
190 { "rodata", ppc_elf_rdata, 0 },
191 { "lcomm", ppc_elf_lcomm, 0 },
192 #endif
193
194 #ifdef TE_PE
195 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format */
196 { "previous", ppc_previous, 0 },
197 { "pdata", ppc_pdata, 0 },
198 { "ydata", ppc_ydata, 0 },
199 { "reldata", ppc_reldata, 0 },
200 { "rdata", ppc_rdata, 0 },
201 { "ualong", ppc_ualong, 0 },
202 { "znop", ppc_znop, 0 },
203 { "comm", ppc_pe_comm, 0 },
204 { "lcomm", ppc_pe_comm, 1 },
205 { "section", ppc_pe_section, 0 },
206 { "function", ppc_pe_function,0 },
207 { "tocd", ppc_pe_tocd, 0 },
208 #endif
209
210 /* This pseudo-op is used even when not generating XCOFF output. */
211 { "tc", ppc_tc, 0 },
212
213 { NULL, NULL, 0 }
214 };
215
216 \f
217 /* Predefined register names if -mregnames (or default for Windows NT). */
218 /* In general, there are lots of them, in an attempt to be compatible */
219 /* with a number of other Windows NT assemblers. */
220
221 /* Structure to hold information about predefined registers. */
222 struct pd_reg
223 {
224 char *name;
225 int value;
226 };
227
228 /* List of registers that are pre-defined:
229
230 Each general register has predefined names of the form:
231 1. r<reg_num> which has the value <reg_num>.
232 2. r.<reg_num> which has the value <reg_num>.
233
234
235 Each floating point register has predefined names of the form:
236 1. f<reg_num> which has the value <reg_num>.
237 2. f.<reg_num> which has the value <reg_num>.
238
239 Each condition register has predefined names of the form:
240 1. cr<reg_num> which has the value <reg_num>.
241 2. cr.<reg_num> which has the value <reg_num>.
242
243 There are individual registers as well:
244 sp or r.sp has the value 1
245 rtoc or r.toc has the value 2
246 fpscr has the value 0
247 xer has the value 1
248 lr has the value 8
249 ctr has the value 9
250 pmr has the value 0
251 dar has the value 19
252 dsisr has the value 18
253 dec has the value 22
254 sdr1 has the value 25
255 srr0 has the value 26
256 srr1 has the value 27
257
258 The table is sorted. Suitable for searching by a binary search. */
259
260 static const struct pd_reg pre_defined_registers[] =
261 {
262 { "cr.0", 0 }, /* Condition Registers */
263 { "cr.1", 1 },
264 { "cr.2", 2 },
265 { "cr.3", 3 },
266 { "cr.4", 4 },
267 { "cr.5", 5 },
268 { "cr.6", 6 },
269 { "cr.7", 7 },
270
271 { "cr0", 0 },
272 { "cr1", 1 },
273 { "cr2", 2 },
274 { "cr3", 3 },
275 { "cr4", 4 },
276 { "cr5", 5 },
277 { "cr6", 6 },
278 { "cr7", 7 },
279
280 { "ctr", 9 },
281
282 { "dar", 19 }, /* Data Access Register */
283 { "dec", 22 }, /* Decrementer */
284 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
285
286 { "f.0", 0 }, /* Floating point registers */
287 { "f.1", 1 },
288 { "f.10", 10 },
289 { "f.11", 11 },
290 { "f.12", 12 },
291 { "f.13", 13 },
292 { "f.14", 14 },
293 { "f.15", 15 },
294 { "f.16", 16 },
295 { "f.17", 17 },
296 { "f.18", 18 },
297 { "f.19", 19 },
298 { "f.2", 2 },
299 { "f.20", 20 },
300 { "f.21", 21 },
301 { "f.22", 22 },
302 { "f.23", 23 },
303 { "f.24", 24 },
304 { "f.25", 25 },
305 { "f.26", 26 },
306 { "f.27", 27 },
307 { "f.28", 28 },
308 { "f.29", 29 },
309 { "f.3", 3 },
310 { "f.30", 30 },
311 { "f.31", 31 },
312 { "f.4", 4 },
313 { "f.5", 5 },
314 { "f.6", 6 },
315 { "f.7", 7 },
316 { "f.8", 8 },
317 { "f.9", 9 },
318
319 { "f0", 0 },
320 { "f1", 1 },
321 { "f10", 10 },
322 { "f11", 11 },
323 { "f12", 12 },
324 { "f13", 13 },
325 { "f14", 14 },
326 { "f15", 15 },
327 { "f16", 16 },
328 { "f17", 17 },
329 { "f18", 18 },
330 { "f19", 19 },
331 { "f2", 2 },
332 { "f20", 20 },
333 { "f21", 21 },
334 { "f22", 22 },
335 { "f23", 23 },
336 { "f24", 24 },
337 { "f25", 25 },
338 { "f26", 26 },
339 { "f27", 27 },
340 { "f28", 28 },
341 { "f29", 29 },
342 { "f3", 3 },
343 { "f30", 30 },
344 { "f31", 31 },
345 { "f4", 4 },
346 { "f5", 5 },
347 { "f6", 6 },
348 { "f7", 7 },
349 { "f8", 8 },
350 { "f9", 9 },
351
352 { "fpscr", 0 },
353
354 { "lr", 8 }, /* Link Register */
355
356 { "pmr", 0 },
357
358 { "r.0", 0 }, /* General Purpose Registers */
359 { "r.1", 1 },
360 { "r.10", 10 },
361 { "r.11", 11 },
362 { "r.12", 12 },
363 { "r.13", 13 },
364 { "r.14", 14 },
365 { "r.15", 15 },
366 { "r.16", 16 },
367 { "r.17", 17 },
368 { "r.18", 18 },
369 { "r.19", 19 },
370 { "r.2", 2 },
371 { "r.20", 20 },
372 { "r.21", 21 },
373 { "r.22", 22 },
374 { "r.23", 23 },
375 { "r.24", 24 },
376 { "r.25", 25 },
377 { "r.26", 26 },
378 { "r.27", 27 },
379 { "r.28", 28 },
380 { "r.29", 29 },
381 { "r.3", 3 },
382 { "r.30", 30 },
383 { "r.31", 31 },
384 { "r.4", 4 },
385 { "r.5", 5 },
386 { "r.6", 6 },
387 { "r.7", 7 },
388 { "r.8", 8 },
389 { "r.9", 9 },
390
391 { "r.sp", 1 }, /* Stack Pointer */
392
393 { "r.toc", 2 }, /* Pointer to the table of contents */
394
395 { "r0", 0 }, /* More general purpose registers */
396 { "r1", 1 },
397 { "r10", 10 },
398 { "r11", 11 },
399 { "r12", 12 },
400 { "r13", 13 },
401 { "r14", 14 },
402 { "r15", 15 },
403 { "r16", 16 },
404 { "r17", 17 },
405 { "r18", 18 },
406 { "r19", 19 },
407 { "r2", 2 },
408 { "r20", 20 },
409 { "r21", 21 },
410 { "r22", 22 },
411 { "r23", 23 },
412 { "r24", 24 },
413 { "r25", 25 },
414 { "r26", 26 },
415 { "r27", 27 },
416 { "r28", 28 },
417 { "r29", 29 },
418 { "r3", 3 },
419 { "r30", 30 },
420 { "r31", 31 },
421 { "r4", 4 },
422 { "r5", 5 },
423 { "r6", 6 },
424 { "r7", 7 },
425 { "r8", 8 },
426 { "r9", 9 },
427
428 { "rtoc", 2 }, /* Table of contents */
429
430 { "sdr1", 25 }, /* Storage Description Register 1 */
431
432 { "sp", 1 },
433
434 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
435 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
436
437 { "xer", 1 },
438
439 };
440
441 #define REG_NAME_CNT (sizeof(pre_defined_registers) / sizeof(struct pd_reg))
442
443 /* Given NAME, find the register number associated with that name, return
444 the integer value associated with the given name or -1 on failure. */
445
446 static int reg_name_search
447 PARAMS ((const struct pd_reg *, int, const char * name));
448
449 static int
450 reg_name_search (regs, regcount, name)
451 const struct pd_reg *regs;
452 int regcount;
453 const char *name;
454 {
455 int middle, low, high;
456 int cmp;
457
458 low = 0;
459 high = regcount - 1;
460
461 do
462 {
463 middle = (low + high) / 2;
464 cmp = strcasecmp (name, regs[middle].name);
465 if (cmp < 0)
466 high = middle - 1;
467 else if (cmp > 0)
468 low = middle + 1;
469 else
470 return regs[middle].value;
471 }
472 while (low <= high);
473
474 return -1;
475 }
476
477 /*
478 * Summary of register_name().
479 *
480 * in: Input_line_pointer points to 1st char of operand.
481 *
482 * out: A expressionS.
483 * The operand may have been a register: in this case, X_op == O_register,
484 * X_add_number is set to the register number, and truth is returned.
485 * Input_line_pointer->(next non-blank) char after operand, or is in its
486 * original state.
487 */
488
489 static boolean
490 register_name (expressionP)
491 expressionS *expressionP;
492 {
493 int reg_number;
494 char *name;
495 char *start;
496 char c;
497
498 /* Find the spelling of the operand */
499 start = name = input_line_pointer;
500 if (name[0] == '%' && isalpha (name[1]))
501 name = ++input_line_pointer;
502
503 else if (!reg_names_p || !isalpha (name[0]))
504 return false;
505
506 c = get_symbol_end ();
507 reg_number = reg_name_search (pre_defined_registers, REG_NAME_CNT, name);
508
509 /* look to see if it's in the register table */
510 if (reg_number >= 0)
511 {
512 expressionP->X_op = O_register;
513 expressionP->X_add_number = reg_number;
514
515 /* make the rest nice */
516 expressionP->X_add_symbol = NULL;
517 expressionP->X_op_symbol = NULL;
518 *input_line_pointer = c; /* put back the delimiting char */
519 return true;
520 }
521 else
522 {
523 /* reset the line as if we had not done anything */
524 *input_line_pointer = c; /* put back the delimiting char */
525 input_line_pointer = start; /* reset input_line pointer */
526 return false;
527 }
528 }
529 \f
530 /* This function is called for each symbol seen in an expression. It
531 handles the special parsing which PowerPC assemblers are supposed
532 to use for condition codes. */
533
534 /* Whether to do the special parsing. */
535 static boolean cr_operand;
536
537 /* Names to recognize in a condition code. This table is sorted. */
538 static const struct pd_reg cr_names[] =
539 {
540 { "cr0", 0 },
541 { "cr1", 1 },
542 { "cr2", 2 },
543 { "cr3", 3 },
544 { "cr4", 4 },
545 { "cr5", 5 },
546 { "cr6", 6 },
547 { "cr7", 7 },
548 { "eq", 2 },
549 { "gt", 1 },
550 { "lt", 0 },
551 { "so", 3 },
552 { "un", 3 }
553 };
554
555 /* Parsing function. This returns non-zero if it recognized an
556 expression. */
557
558 int
559 ppc_parse_name (name, expr)
560 const char *name;
561 expressionS *expr;
562 {
563 int val;
564
565 if (! cr_operand)
566 return 0;
567
568 val = reg_name_search (cr_names, sizeof cr_names / sizeof cr_names[0],
569 name);
570 if (val < 0)
571 return 0;
572
573 expr->X_op = O_constant;
574 expr->X_add_number = val;
575
576 return 1;
577 }
578 \f
579 /* Local variables. */
580
581 /* The type of processor we are assembling for. This is one or more
582 of the PPC_OPCODE flags defined in opcode/ppc.h. */
583 static int ppc_cpu = 0;
584
585 /* The size of the processor we are assembling for. This is either
586 PPC_OPCODE_32 or PPC_OPCODE_64. */
587 static int ppc_size = PPC_OPCODE_32;
588
589 /* Opcode hash table. */
590 static struct hash_control *ppc_hash;
591
592 /* Macro hash table. */
593 static struct hash_control *ppc_macro_hash;
594
595 #ifdef OBJ_ELF
596 /* What type of shared library support to use */
597 static enum { SHLIB_NONE, SHLIB_PIC, SHILB_MRELOCATABLE } shlib = SHLIB_NONE;
598
599 /* Flags to set in the elf header */
600 static flagword ppc_flags = 0;
601
602 /* Whether this is Solaris or not. */
603 #ifdef TARGET_SOLARIS_COMMENT
604 #define SOLARIS_P true
605 #else
606 #define SOLARIS_P false
607 #endif
608
609 static boolean msolaris = SOLARIS_P;
610 #endif
611
612 #ifdef OBJ_XCOFF
613
614 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
615 using a bunch of different sections. These assembler sections,
616 however, are all encompassed within the .text or .data sections of
617 the final output file. We handle this by using different
618 subsegments within these main segments. */
619
620 /* Next subsegment to allocate within the .text segment. */
621 static subsegT ppc_text_subsegment = 2;
622
623 /* Linked list of csects in the text section. */
624 static symbolS *ppc_text_csects;
625
626 /* Next subsegment to allocate within the .data segment. */
627 static subsegT ppc_data_subsegment = 2;
628
629 /* Linked list of csects in the data section. */
630 static symbolS *ppc_data_csects;
631
632 /* The current csect. */
633 static symbolS *ppc_current_csect;
634
635 /* The RS/6000 assembler uses a TOC which holds addresses of functions
636 and variables. Symbols are put in the TOC with the .tc pseudo-op.
637 A special relocation is used when accessing TOC entries. We handle
638 the TOC as a subsegment within the .data segment. We set it up if
639 we see a .toc pseudo-op, and save the csect symbol here. */
640 static symbolS *ppc_toc_csect;
641
642 /* The first frag in the TOC subsegment. */
643 static fragS *ppc_toc_frag;
644
645 /* The first frag in the first subsegment after the TOC in the .data
646 segment. NULL if there are no subsegments after the TOC. */
647 static fragS *ppc_after_toc_frag;
648
649 /* The current static block. */
650 static symbolS *ppc_current_block;
651
652 /* The COFF debugging section; set by md_begin. This is not the
653 .debug section, but is instead the secret BFD section which will
654 cause BFD to set the section number of a symbol to N_DEBUG. */
655 static asection *ppc_coff_debug_section;
656
657 #endif /* OBJ_XCOFF */
658
659 #ifdef TE_PE
660
661 /* Various sections that we need for PE coff support. */
662 static segT ydata_section;
663 static segT pdata_section;
664 static segT reldata_section;
665 static segT rdata_section;
666 static segT tocdata_section;
667
668 /* The current section and the previous section. See ppc_previous. */
669 static segT ppc_previous_section;
670 static segT ppc_current_section;
671
672 #endif /* TE_PE */
673
674 #ifdef OBJ_ELF
675 symbolS *GOT_symbol; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
676 #endif /* OBJ_ELF */
677
678 #ifndef WORKING_DOT_WORD
679 const int md_short_jump_size = 4;
680 const int md_long_jump_size = 4;
681 #endif
682 \f
683 #ifdef OBJ_ELF
684 CONST char *md_shortopts = "b:l:usm:K:VQ:";
685 #else
686 CONST char *md_shortopts = "um:";
687 #endif
688 struct option md_longopts[] = {
689 {NULL, no_argument, NULL, 0}
690 };
691 size_t md_longopts_size = sizeof(md_longopts);
692
693 int
694 md_parse_option (c, arg)
695 int c;
696 char *arg;
697 {
698 switch (c)
699 {
700 case 'u':
701 /* -u means that any undefined symbols should be treated as
702 external, which is the default for gas anyhow. */
703 break;
704
705 #ifdef OBJ_ELF
706 case 'l':
707 /* Solaris as takes -le (presumably for little endian). For completeness
708 sake, recognize -be also. */
709 if (strcmp (arg, "e") == 0)
710 {
711 target_big_endian = 0;
712 set_target_endian = 1;
713 }
714 else
715 return 0;
716
717 break;
718
719 case 'b':
720 if (strcmp (arg, "e") == 0)
721 {
722 target_big_endian = 1;
723 set_target_endian = 1;
724 }
725 else
726 return 0;
727
728 break;
729
730 case 'K':
731 /* Recognize -K PIC */
732 if (strcmp (arg, "PIC") == 0 || strcmp (arg, "pic") == 0)
733 {
734 shlib = SHLIB_PIC;
735 ppc_flags |= EF_PPC_RELOCATABLE_LIB;
736 }
737 else
738 return 0;
739
740 break;
741 #endif
742
743 case 'm':
744 /* -mpwrx and -mpwr2 mean to assemble for the IBM POWER/2
745 (RIOS2). */
746 if (strcmp (arg, "pwrx") == 0 || strcmp (arg, "pwr2") == 0)
747 ppc_cpu = PPC_OPCODE_POWER | PPC_OPCODE_POWER2;
748 /* -mpwr means to assemble for the IBM POWER (RIOS1). */
749 else if (strcmp (arg, "pwr") == 0)
750 ppc_cpu = PPC_OPCODE_POWER;
751 /* -m601 means to assemble for the Motorola PowerPC 601, which includes
752 instructions that are holdovers from the Power. */
753 else if (strcmp (arg, "601") == 0)
754 ppc_cpu = PPC_OPCODE_PPC | PPC_OPCODE_601;
755 /* -mppc, -mppc32, -m603, and -m604 mean to assemble for the
756 Motorola PowerPC 603/604. */
757 else if (strcmp (arg, "ppc") == 0
758 || strcmp (arg, "ppc32") == 0
759 || strcmp (arg, "403") == 0
760 || strcmp (arg, "603") == 0
761 || strcmp (arg, "604") == 0)
762 ppc_cpu = PPC_OPCODE_PPC;
763 /* -mppc64 and -m620 mean to assemble for the 64-bit PowerPC
764 620. */
765 else if (strcmp (arg, "ppc64") == 0 || strcmp (arg, "620") == 0)
766 {
767 ppc_cpu = PPC_OPCODE_PPC;
768 ppc_size = PPC_OPCODE_64;
769 }
770 /* -mcom means assemble for the common intersection between Power
771 and PowerPC. At present, we just allow the union, rather
772 than the intersection. */
773 else if (strcmp (arg, "com") == 0)
774 ppc_cpu = PPC_OPCODE_COMMON;
775 /* -many means to assemble for any architecture (PWR/PWRX/PPC). */
776 else if (strcmp (arg, "any") == 0)
777 ppc_cpu = PPC_OPCODE_ANY;
778
779 else if (strcmp (arg, "regnames") == 0)
780 reg_names_p = true;
781
782 else if (strcmp (arg, "no-regnames") == 0)
783 reg_names_p = false;
784
785 #ifdef OBJ_ELF
786 /* -mrelocatable/-mrelocatable-lib -- warn about initializations that require relocation */
787 else if (strcmp (arg, "relocatable") == 0)
788 {
789 shlib = SHILB_MRELOCATABLE;
790 ppc_flags |= EF_PPC_RELOCATABLE;
791 }
792
793 else if (strcmp (arg, "relocatable-lib") == 0)
794 {
795 shlib = SHILB_MRELOCATABLE;
796 ppc_flags |= EF_PPC_RELOCATABLE_LIB;
797 }
798
799 /* -memb, set embedded bit */
800 else if (strcmp (arg, "emb") == 0)
801 ppc_flags |= EF_PPC_EMB;
802
803 /* -mlittle/-mbig set the endianess */
804 else if (strcmp (arg, "little") == 0 || strcmp (arg, "little-endian") == 0)
805 {
806 target_big_endian = 0;
807 set_target_endian = 1;
808 }
809
810 else if (strcmp (arg, "big") == 0 || strcmp (arg, "big-endian") == 0)
811 {
812 target_big_endian = 1;
813 set_target_endian = 1;
814 }
815
816 else if (strcmp (arg, "solaris") == 0)
817 {
818 msolaris = true;
819 ppc_comment_chars = ppc_solaris_comment_chars;
820 }
821
822 else if (strcmp (arg, "no-solaris") == 0)
823 {
824 msolaris = false;
825 ppc_comment_chars = ppc_eabi_comment_chars;
826 }
827 #endif
828 else
829 {
830 as_bad ("invalid switch -m%s", arg);
831 return 0;
832 }
833 break;
834
835 #ifdef OBJ_ELF
836 /* -V: SVR4 argument to print version ID. */
837 case 'V':
838 print_version_id ();
839 break;
840
841 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
842 should be emitted or not. FIXME: Not implemented. */
843 case 'Q':
844 break;
845
846 /* Solaris takes -s to specify that .stabs go in a .stabs section,
847 rather than .stabs.excl, which is ignored by the linker.
848 FIXME: Not implemented. */
849 case 's':
850 if (arg)
851 return 0;
852
853 break;
854 #endif
855
856 default:
857 return 0;
858 }
859
860 return 1;
861 }
862
863 void
864 md_show_usage (stream)
865 FILE *stream;
866 {
867 fprintf(stream, "\
868 PowerPC options:\n\
869 -u ignored\n\
870 -mpwrx, -mpwr2 generate code for IBM POWER/2 (RIOS2)\n\
871 -mpwr generate code for IBM POWER (RIOS1)\n\
872 -m601 generate code for Motorola PowerPC 601\n\
873 -mppc, -mppc32, -m403, -m603, -m604\n\
874 generate code for Motorola PowerPC 603/604\n\
875 -mppc64, -m620 generate code for Motorola PowerPC 620\n\
876 -mcom generate code Power/PowerPC common instructions\n\
877 -many generate code for any architecture (PWR/PWRX/PPC)\n\
878 -mregnames Allow symbolic names for registers\n\
879 -mno-regnames Do not allow symbolic names for registers\n");
880 #ifdef OBJ_ELF
881 fprintf(stream, "\
882 -mrelocatable support for GCC's -mrelocatble option\n\
883 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
884 -memb set PPC_EMB bit in ELF flags\n\
885 -mlittle, -mlittle-endian\n\
886 generate code for a little endian machine\n\
887 -mbig, -mbig-endian generate code for a big endian machine\n\
888 -msolaris generate code for Solaris\n\
889 -mno-solaris do not generate code for Solaris\n\
890 -V print assembler version number\n\
891 -Qy, -Qn ignored\n");
892 #endif
893 }
894 \f
895 /* Set ppc_cpu if it is not already set. */
896
897 static void
898 ppc_set_cpu ()
899 {
900 const char *default_os = TARGET_OS;
901 const char *default_cpu = TARGET_CPU;
902
903 if (ppc_cpu == 0)
904 {
905 if (strncmp (default_os, "aix", 3) == 0
906 && default_os[3] >= '4' && default_os[3] <= '9')
907 ppc_cpu = PPC_OPCODE_COMMON;
908 else if (strncmp (default_os, "aix3", 4) == 0)
909 ppc_cpu = PPC_OPCODE_POWER;
910 else if (strcmp (default_cpu, "rs6000") == 0)
911 ppc_cpu = PPC_OPCODE_POWER;
912 else if (strcmp (default_cpu, "powerpc") == 0
913 || strcmp (default_cpu, "powerpcle") == 0)
914 ppc_cpu = PPC_OPCODE_PPC;
915 else
916 as_fatal ("Unknown default cpu = %s, os = %s", default_cpu, default_os);
917 }
918 }
919
920 /* Figure out the BFD architecture to use. */
921
922 enum bfd_architecture
923 ppc_arch ()
924 {
925 const char *default_cpu = TARGET_CPU;
926 ppc_set_cpu ();
927
928 if ((ppc_cpu & PPC_OPCODE_PPC) != 0)
929 return bfd_arch_powerpc;
930 else if ((ppc_cpu & PPC_OPCODE_POWER) != 0)
931 return bfd_arch_rs6000;
932 else if ((ppc_cpu & (PPC_OPCODE_COMMON | PPC_OPCODE_ANY)) != 0)
933 {
934 if (strcmp (default_cpu, "rs6000") == 0)
935 return bfd_arch_rs6000;
936 else if (strcmp (default_cpu, "powerpc") == 0
937 || strcmp (default_cpu, "powerpcle") == 0)
938 return bfd_arch_powerpc;
939 }
940
941 as_fatal ("Neither Power nor PowerPC opcodes were selected.");
942 return bfd_arch_unknown;
943 }
944
945 /* This function is called when the assembler starts up. It is called
946 after the options have been parsed and the output file has been
947 opened. */
948
949 void
950 md_begin ()
951 {
952 register const struct powerpc_opcode *op;
953 const struct powerpc_opcode *op_end;
954 const struct powerpc_macro *macro;
955 const struct powerpc_macro *macro_end;
956 boolean dup_insn = false;
957
958 ppc_set_cpu ();
959
960 #ifdef OBJ_ELF
961 /* Set the ELF flags if desired. */
962 if (ppc_flags && !msolaris)
963 bfd_set_private_flags (stdoutput, ppc_flags);
964 #endif
965
966 /* Insert the opcodes into a hash table. */
967 ppc_hash = hash_new ();
968
969 op_end = powerpc_opcodes + powerpc_num_opcodes;
970 for (op = powerpc_opcodes; op < op_end; op++)
971 {
972 know ((op->opcode & op->mask) == op->opcode);
973
974 if ((op->flags & ppc_cpu) != 0
975 && ((op->flags & (PPC_OPCODE_32 | PPC_OPCODE_64)) == 0
976 || (op->flags & (PPC_OPCODE_32 | PPC_OPCODE_64)) == ppc_size))
977 {
978 const char *retval;
979
980 retval = hash_insert (ppc_hash, op->name, (PTR) op);
981 if (retval != (const char *) NULL)
982 {
983 /* Ignore Power duplicates for -m601 */
984 if ((ppc_cpu & PPC_OPCODE_601) != 0
985 && (op->flags & PPC_OPCODE_POWER) != 0)
986 continue;
987
988 as_bad ("Internal assembler error for instruction %s", op->name);
989 dup_insn = true;
990 }
991 }
992 }
993
994 /* Insert the macros into a hash table. */
995 ppc_macro_hash = hash_new ();
996
997 macro_end = powerpc_macros + powerpc_num_macros;
998 for (macro = powerpc_macros; macro < macro_end; macro++)
999 {
1000 if ((macro->flags & ppc_cpu) != 0)
1001 {
1002 const char *retval;
1003
1004 retval = hash_insert (ppc_macro_hash, macro->name, (PTR) macro);
1005 if (retval != (const char *) NULL)
1006 {
1007 as_bad ("Internal assembler error for macro %s", macro->name);
1008 dup_insn = true;
1009 }
1010 }
1011 }
1012
1013 if (dup_insn)
1014 abort ();
1015
1016 /* Tell the main code what the endianness is if it is not overidden by the user. */
1017 if (!set_target_endian)
1018 {
1019 set_target_endian = 1;
1020 target_big_endian = PPC_BIG_ENDIAN;
1021 }
1022
1023 #ifdef OBJ_XCOFF
1024 ppc_coff_debug_section = coff_section_from_bfd_index (stdoutput, N_DEBUG);
1025
1026 /* Create dummy symbols to serve as initial csects. This forces the
1027 text csects to precede the data csects. These symbols will not
1028 be output. */
1029 ppc_text_csects = symbol_make ("dummy\001");
1030 ppc_text_csects->sy_tc.within = ppc_text_csects;
1031 ppc_data_csects = symbol_make ("dummy\001");
1032 ppc_data_csects->sy_tc.within = ppc_data_csects;
1033 #endif
1034
1035 #ifdef TE_PE
1036
1037 ppc_current_section = text_section;
1038 ppc_previous_section = 0;
1039
1040 #endif
1041 }
1042
1043 /* Insert an operand value into an instruction. */
1044
1045 static unsigned long
1046 ppc_insert_operand (insn, operand, val, file, line)
1047 unsigned long insn;
1048 const struct powerpc_operand *operand;
1049 offsetT val;
1050 char *file;
1051 unsigned int line;
1052 {
1053 if (operand->bits != 32)
1054 {
1055 long min, max;
1056 offsetT test;
1057
1058 if ((operand->flags & PPC_OPERAND_SIGNED) != 0)
1059 {
1060 if ((operand->flags & PPC_OPERAND_SIGNOPT) != 0
1061 && ppc_size == PPC_OPCODE_32)
1062 max = (1 << operand->bits) - 1;
1063 else
1064 max = (1 << (operand->bits - 1)) - 1;
1065 min = - (1 << (operand->bits - 1));
1066
1067 if (ppc_size == PPC_OPCODE_32)
1068 {
1069 /* Some people write 32 bit hex constants with the sign
1070 extension done by hand. This shouldn't really be
1071 valid, but, to permit this code to assemble on a 64
1072 bit host, we sign extend the 32 bit value. */
1073 if (val > 0
1074 && (val & 0x80000000) != 0
1075 && (val & 0xffffffff) == val)
1076 {
1077 val -= 0x80000000;
1078 val -= 0x80000000;
1079 }
1080 }
1081 }
1082 else
1083 {
1084 max = (1 << operand->bits) - 1;
1085 min = 0;
1086 }
1087
1088 if ((operand->flags & PPC_OPERAND_NEGATIVE) != 0)
1089 test = - val;
1090 else
1091 test = val;
1092
1093 if (test < (offsetT) min || test > (offsetT) max)
1094 {
1095 const char *err =
1096 "operand out of range (%s not between %ld and %ld)";
1097 char buf[100];
1098
1099 sprint_value (buf, test);
1100 if (file == (char *) NULL)
1101 as_bad (err, buf, min, max);
1102 else
1103 as_bad_where (file, line, err, buf, min, max);
1104 }
1105 }
1106
1107 if (operand->insert)
1108 {
1109 const char *errmsg;
1110
1111 errmsg = NULL;
1112 insn = (*operand->insert) (insn, (long) val, &errmsg);
1113 if (errmsg != (const char *) NULL)
1114 as_bad (errmsg);
1115 }
1116 else
1117 insn |= (((long) val & ((1 << operand->bits) - 1))
1118 << operand->shift);
1119
1120 return insn;
1121 }
1122
1123 \f
1124 #ifdef OBJ_ELF
1125 /* Parse @got, etc. and return the desired relocation. */
1126 static bfd_reloc_code_real_type
1127 ppc_elf_suffix (str_p, exp_p)
1128 char **str_p;
1129 expressionS *exp_p;
1130 {
1131 struct map_bfd {
1132 char *string;
1133 int length;
1134 bfd_reloc_code_real_type reloc;
1135 };
1136
1137 char ident[20];
1138 char *str = *str_p;
1139 char *str2;
1140 int ch;
1141 int len;
1142 struct map_bfd *ptr;
1143
1144 #define MAP(str,reloc) { str, sizeof(str)-1, reloc }
1145
1146 static struct map_bfd mapping[] = {
1147 MAP ("l", BFD_RELOC_LO16),
1148 MAP ("h", BFD_RELOC_HI16),
1149 MAP ("ha", BFD_RELOC_HI16_S),
1150 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN),
1151 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN),
1152 MAP ("got", BFD_RELOC_16_GOTOFF),
1153 MAP ("got@l", BFD_RELOC_LO16_GOTOFF),
1154 MAP ("got@h", BFD_RELOC_HI16_GOTOFF),
1155 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF),
1156 MAP ("fixup", BFD_RELOC_CTOR), /* warnings with -mrelocatable */
1157 MAP ("plt", BFD_RELOC_24_PLT_PCREL),
1158 MAP ("pltrel24", BFD_RELOC_24_PLT_PCREL),
1159 MAP ("copy", BFD_RELOC_PPC_COPY),
1160 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT),
1161 MAP ("local24pc", BFD_RELOC_PPC_LOCAL24PC),
1162 MAP ("local", BFD_RELOC_PPC_LOCAL24PC),
1163 MAP ("pltrel", BFD_RELOC_32_PLT_PCREL),
1164 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF),
1165 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF),
1166 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF),
1167 MAP ("sdarel", BFD_RELOC_GPREL16),
1168 MAP ("sectoff", BFD_RELOC_32_BASEREL),
1169 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL),
1170 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL),
1171 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL),
1172 MAP ("naddr", BFD_RELOC_PPC_EMB_NADDR32),
1173 MAP ("naddr16", BFD_RELOC_PPC_EMB_NADDR16),
1174 MAP ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO),
1175 MAP ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI),
1176 MAP ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA),
1177 MAP ("sdai16", BFD_RELOC_PPC_EMB_SDAI16),
1178 MAP ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL),
1179 MAP ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16),
1180 MAP ("sda21", BFD_RELOC_PPC_EMB_SDA21),
1181 MAP ("mrkref", BFD_RELOC_PPC_EMB_MRKREF),
1182 MAP ("relsect", BFD_RELOC_PPC_EMB_RELSEC16),
1183 MAP ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO),
1184 MAP ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI),
1185 MAP ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA),
1186 MAP ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD),
1187 MAP ("relsda", BFD_RELOC_PPC_EMB_RELSDA),
1188 MAP ("xgot", BFD_RELOC_PPC_TOC16),
1189
1190 { (char *)0, 0, BFD_RELOC_UNUSED }
1191 };
1192
1193 if (*str++ != '@')
1194 return BFD_RELOC_UNUSED;
1195
1196 for (ch = *str, str2 = ident;
1197 (str2 < ident + sizeof (ident) - 1
1198 && (isalnum (ch) || ch == '@'));
1199 ch = *++str)
1200 {
1201 *str2++ = (islower (ch)) ? ch : tolower (ch);
1202 }
1203
1204 *str2 = '\0';
1205 len = str2 - ident;
1206
1207 ch = ident[0];
1208 for (ptr = &mapping[0]; ptr->length > 0; ptr++)
1209 if (ch == ptr->string[0]
1210 && len == ptr->length
1211 && memcmp (ident, ptr->string, ptr->length) == 0)
1212 {
1213 if (exp_p->X_add_number != 0
1214 && (ptr->reloc == BFD_RELOC_16_GOTOFF
1215 || ptr->reloc == BFD_RELOC_LO16_GOTOFF
1216 || ptr->reloc == BFD_RELOC_HI16_GOTOFF
1217 || ptr->reloc == BFD_RELOC_HI16_S_GOTOFF))
1218 as_warn ("identifier+constant@got means identifier@got+constant");
1219
1220 /* Now check for identifier@suffix+constant */
1221 if (*str == '-' || *str == '+')
1222 {
1223 char *orig_line = input_line_pointer;
1224 expressionS new_exp;
1225
1226 input_line_pointer = str;
1227 expression (&new_exp);
1228 if (new_exp.X_op == O_constant)
1229 {
1230 exp_p->X_add_number += new_exp.X_add_number;
1231 str = input_line_pointer;
1232 }
1233
1234 if (&input_line_pointer != str_p)
1235 input_line_pointer = orig_line;
1236 }
1237
1238 *str_p = str;
1239 return ptr->reloc;
1240 }
1241
1242 return BFD_RELOC_UNUSED;
1243 }
1244
1245 /* Like normal .long/.short/.word, except support @got, etc. */
1246 /* clobbers input_line_pointer, checks */
1247 /* end-of-line. */
1248 static void
1249 ppc_elf_cons (nbytes)
1250 register int nbytes; /* 1=.byte, 2=.word, 4=.long */
1251 {
1252 expressionS exp;
1253 bfd_reloc_code_real_type reloc;
1254
1255 if (is_it_end_of_statement ())
1256 {
1257 demand_empty_rest_of_line ();
1258 return;
1259 }
1260
1261 do
1262 {
1263 expression (&exp);
1264 if (exp.X_op == O_symbol
1265 && *input_line_pointer == '@'
1266 && (reloc = ppc_elf_suffix (&input_line_pointer, &exp)) != BFD_RELOC_UNUSED)
1267 {
1268 reloc_howto_type *reloc_howto = bfd_reloc_type_lookup (stdoutput, reloc);
1269 int size = bfd_get_reloc_size (reloc_howto);
1270
1271 if (size > nbytes)
1272 as_bad ("%s relocations do not fit in %d bytes\n", reloc_howto->name, nbytes);
1273
1274 else
1275 {
1276 register char *p = frag_more ((int) nbytes);
1277 int offset = nbytes - size;
1278
1279 fix_new_exp (frag_now, p - frag_now->fr_literal + offset, size, &exp, 0, reloc);
1280 }
1281 }
1282 else
1283 emit_expr (&exp, (unsigned int) nbytes);
1284 }
1285 while (*input_line_pointer++ == ',');
1286
1287 input_line_pointer--; /* Put terminator back into stream. */
1288 demand_empty_rest_of_line ();
1289 }
1290
1291 /* Solaris pseduo op to change to the .rodata section. */
1292 static void
1293 ppc_elf_rdata (xxx)
1294 int xxx;
1295 {
1296 char *save_line = input_line_pointer;
1297 static char section[] = ".rodata\n";
1298
1299 /* Just pretend this is .section .rodata */
1300 input_line_pointer = section;
1301 obj_elf_section (xxx);
1302
1303 input_line_pointer = save_line;
1304 }
1305
1306 /* Pseudo op to make file scope bss items */
1307 static void
1308 ppc_elf_lcomm(xxx)
1309 int xxx;
1310 {
1311 register char *name;
1312 register char c;
1313 register char *p;
1314 offsetT size;
1315 register symbolS *symbolP;
1316 offsetT align;
1317 segT old_sec;
1318 int old_subsec;
1319 char *pfrag;
1320 int align2;
1321
1322 name = input_line_pointer;
1323 c = get_symbol_end ();
1324
1325 /* just after name is now '\0' */
1326 p = input_line_pointer;
1327 *p = c;
1328 SKIP_WHITESPACE ();
1329 if (*input_line_pointer != ',')
1330 {
1331 as_bad ("Expected comma after symbol-name: rest of line ignored.");
1332 ignore_rest_of_line ();
1333 return;
1334 }
1335
1336 input_line_pointer++; /* skip ',' */
1337 if ((size = get_absolute_expression ()) < 0)
1338 {
1339 as_warn (".COMMon length (%ld.) <0! Ignored.", (long) size);
1340 ignore_rest_of_line ();
1341 return;
1342 }
1343
1344 /* The third argument to .lcomm is the alignment. */
1345 if (*input_line_pointer != ',')
1346 align = 8;
1347 else
1348 {
1349 ++input_line_pointer;
1350 align = get_absolute_expression ();
1351 if (align <= 0)
1352 {
1353 as_warn ("ignoring bad alignment");
1354 align = 8;
1355 }
1356 }
1357
1358 *p = 0;
1359 symbolP = symbol_find_or_make (name);
1360 *p = c;
1361
1362 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
1363 {
1364 as_bad ("Ignoring attempt to re-define symbol `%s'.",
1365 S_GET_NAME (symbolP));
1366 ignore_rest_of_line ();
1367 return;
1368 }
1369
1370 if (S_GET_VALUE (symbolP) && S_GET_VALUE (symbolP) != (valueT) size)
1371 {
1372 as_bad ("Length of .lcomm \"%s\" is already %ld. Not changed to %ld.",
1373 S_GET_NAME (symbolP),
1374 (long) S_GET_VALUE (symbolP),
1375 (long) size);
1376
1377 ignore_rest_of_line ();
1378 return;
1379 }
1380
1381 /* allocate_bss: */
1382 old_sec = now_seg;
1383 old_subsec = now_subseg;
1384 if (align)
1385 {
1386 /* convert to a power of 2 alignment */
1387 for (align2 = 0; (align & 1) == 0; align >>= 1, ++align2);
1388 if (align != 1)
1389 {
1390 as_bad ("Common alignment not a power of 2");
1391 ignore_rest_of_line ();
1392 return;
1393 }
1394 }
1395 else
1396 align2 = 0;
1397
1398 record_alignment (bss_section, align2);
1399 subseg_set (bss_section, 0);
1400 if (align2)
1401 frag_align (align2, 0, 0);
1402 if (S_GET_SEGMENT (symbolP) == bss_section)
1403 symbolP->sy_frag->fr_symbol = 0;
1404 symbolP->sy_frag = frag_now;
1405 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP, size,
1406 (char *) 0);
1407 *pfrag = 0;
1408 S_SET_SIZE (symbolP, size);
1409 S_SET_SEGMENT (symbolP, bss_section);
1410 subseg_set (old_sec, old_subsec);
1411 demand_empty_rest_of_line ();
1412 }
1413
1414 /* Validate any relocations emitted for -mrelocatable, possibly adding
1415 fixups for word relocations in writable segments, so we can adjust
1416 them at runtime. */
1417 static void
1418 ppc_elf_validate_fix (fixp, seg)
1419 fixS *fixp;
1420 segT seg;
1421 {
1422 if (fixp->fx_done || fixp->fx_pcrel)
1423 return;
1424
1425 switch (shlib)
1426 {
1427 case SHLIB_NONE:
1428 case SHLIB_PIC:
1429 return;
1430
1431 case SHILB_MRELOCATABLE:
1432 if (fixp->fx_r_type <= BFD_RELOC_UNUSED
1433 && fixp->fx_r_type != BFD_RELOC_16_GOTOFF
1434 && fixp->fx_r_type != BFD_RELOC_HI16_GOTOFF
1435 && fixp->fx_r_type != BFD_RELOC_LO16_GOTOFF
1436 && fixp->fx_r_type != BFD_RELOC_HI16_S_GOTOFF
1437 && fixp->fx_r_type != BFD_RELOC_32_BASEREL
1438 && fixp->fx_r_type != BFD_RELOC_LO16_BASEREL
1439 && fixp->fx_r_type != BFD_RELOC_HI16_BASEREL
1440 && fixp->fx_r_type != BFD_RELOC_HI16_S_BASEREL
1441 && strcmp (segment_name (seg), ".got2") != 0
1442 && strcmp (segment_name (seg), ".dtors") != 0
1443 && strcmp (segment_name (seg), ".ctors") != 0
1444 && strcmp (segment_name (seg), ".fixup") != 0
1445 && strcmp (segment_name (seg), ".stab") != 0
1446 && strcmp (segment_name (seg), ".gcc_except_table") != 0
1447 && strcmp (segment_name (seg), ".ex_shared") != 0)
1448 {
1449 if ((seg->flags & (SEC_READONLY | SEC_CODE)) != 0
1450 || fixp->fx_r_type != BFD_RELOC_CTOR)
1451 {
1452 as_bad_where (fixp->fx_file, fixp->fx_line,
1453 "Relocation cannot be done when using -mrelocatable");
1454 }
1455 }
1456 return;
1457 }
1458 }
1459 #endif /* OBJ_ELF */
1460 \f
1461 #ifdef TE_PE
1462
1463 /*
1464 * Summary of parse_toc_entry().
1465 *
1466 * in: Input_line_pointer points to the '[' in one of:
1467 *
1468 * [toc] [tocv] [toc32] [toc64]
1469 *
1470 * Anything else is an error of one kind or another.
1471 *
1472 * out:
1473 * return value: success or failure
1474 * toc_kind: kind of toc reference
1475 * input_line_pointer:
1476 * success: first char after the ']'
1477 * failure: unchanged
1478 *
1479 * settings:
1480 *
1481 * [toc] - rv == success, toc_kind = default_toc
1482 * [tocv] - rv == success, toc_kind = data_in_toc
1483 * [toc32] - rv == success, toc_kind = must_be_32
1484 * [toc64] - rv == success, toc_kind = must_be_64
1485 *
1486 */
1487
1488 enum toc_size_qualifier
1489 {
1490 default_toc, /* The toc cell constructed should be the system default size */
1491 data_in_toc, /* This is a direct reference to a toc cell */
1492 must_be_32, /* The toc cell constructed must be 32 bits wide */
1493 must_be_64 /* The toc cell constructed must be 64 bits wide */
1494 };
1495
1496 static int
1497 parse_toc_entry(toc_kind)
1498 enum toc_size_qualifier *toc_kind;
1499 {
1500 char *start;
1501 char *toc_spec;
1502 char c;
1503 enum toc_size_qualifier t;
1504
1505 /* save the input_line_pointer */
1506 start = input_line_pointer;
1507
1508 /* skip over the '[' , and whitespace */
1509 ++input_line_pointer;
1510 SKIP_WHITESPACE ();
1511
1512 /* find the spelling of the operand */
1513 toc_spec = input_line_pointer;
1514 c = get_symbol_end ();
1515
1516 if (strcmp(toc_spec, "toc") == 0)
1517 {
1518 t = default_toc;
1519 }
1520 else if (strcmp(toc_spec, "tocv") == 0)
1521 {
1522 t = data_in_toc;
1523 }
1524 else if (strcmp(toc_spec, "toc32") == 0)
1525 {
1526 t = must_be_32;
1527 }
1528 else if (strcmp(toc_spec, "toc64") == 0)
1529 {
1530 t = must_be_64;
1531 }
1532 else
1533 {
1534 as_bad ("syntax error: invalid toc specifier `%s'", toc_spec);
1535 *input_line_pointer = c; /* put back the delimiting char */
1536 input_line_pointer = start; /* reset input_line pointer */
1537 return 0;
1538 }
1539
1540 /* now find the ']' */
1541 *input_line_pointer = c; /* put back the delimiting char */
1542
1543 SKIP_WHITESPACE (); /* leading whitespace could be there. */
1544 c = *input_line_pointer++; /* input_line_pointer->past char in c. */
1545
1546 if (c != ']')
1547 {
1548 as_bad ("syntax error: expected `]', found `%c'", c);
1549 input_line_pointer = start; /* reset input_line pointer */
1550 return 0;
1551 }
1552
1553 *toc_kind = t; /* set return value */
1554 return 1;
1555 }
1556 #endif
1557 \f
1558
1559 /* We need to keep a list of fixups. We can't simply generate them as
1560 we go, because that would require us to first create the frag, and
1561 that would screw up references to ``.''. */
1562
1563 struct ppc_fixup
1564 {
1565 expressionS exp;
1566 int opindex;
1567 bfd_reloc_code_real_type reloc;
1568 };
1569
1570 #define MAX_INSN_FIXUPS (5)
1571
1572 /* This routine is called for each instruction to be assembled. */
1573
1574 void
1575 md_assemble (str)
1576 char *str;
1577 {
1578 char *s;
1579 const struct powerpc_opcode *opcode;
1580 unsigned long insn;
1581 const unsigned char *opindex_ptr;
1582 int skip_optional;
1583 int need_paren;
1584 int next_opindex;
1585 struct ppc_fixup fixups[MAX_INSN_FIXUPS];
1586 int fc;
1587 char *f;
1588 int i;
1589 #ifdef OBJ_ELF
1590 bfd_reloc_code_real_type reloc;
1591 #endif
1592
1593 /* Get the opcode. */
1594 for (s = str; *s != '\0' && ! isspace (*s); s++)
1595 ;
1596 if (*s != '\0')
1597 *s++ = '\0';
1598
1599 /* Look up the opcode in the hash table. */
1600 opcode = (const struct powerpc_opcode *) hash_find (ppc_hash, str);
1601 if (opcode == (const struct powerpc_opcode *) NULL)
1602 {
1603 const struct powerpc_macro *macro;
1604
1605 macro = (const struct powerpc_macro *) hash_find (ppc_macro_hash, str);
1606 if (macro == (const struct powerpc_macro *) NULL)
1607 as_bad ("Unrecognized opcode: `%s'", str);
1608 else
1609 ppc_macro (s, macro);
1610
1611 return;
1612 }
1613
1614 insn = opcode->opcode;
1615
1616 str = s;
1617 while (isspace (*str))
1618 ++str;
1619
1620 /* PowerPC operands are just expressions. The only real issue is
1621 that a few operand types are optional. All cases which might use
1622 an optional operand separate the operands only with commas (in
1623 some cases parentheses are used, as in ``lwz 1,0(1)'' but such
1624 cases never have optional operands). There is never more than
1625 one optional operand for an instruction. So, before we start
1626 seriously parsing the operands, we check to see if we have an
1627 optional operand, and, if we do, we count the number of commas to
1628 see whether the operand should be omitted. */
1629 skip_optional = 0;
1630 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
1631 {
1632 const struct powerpc_operand *operand;
1633
1634 operand = &powerpc_operands[*opindex_ptr];
1635 if ((operand->flags & PPC_OPERAND_OPTIONAL) != 0)
1636 {
1637 unsigned int opcount;
1638
1639 /* There is an optional operand. Count the number of
1640 commas in the input line. */
1641 if (*str == '\0')
1642 opcount = 0;
1643 else
1644 {
1645 opcount = 1;
1646 s = str;
1647 while ((s = strchr (s, ',')) != (char *) NULL)
1648 {
1649 ++opcount;
1650 ++s;
1651 }
1652 }
1653
1654 /* If there are fewer operands in the line then are called
1655 for by the instruction, we want to skip the optional
1656 operand. */
1657 if (opcount < strlen (opcode->operands))
1658 skip_optional = 1;
1659
1660 break;
1661 }
1662 }
1663
1664 /* Gather the operands. */
1665 need_paren = 0;
1666 next_opindex = 0;
1667 fc = 0;
1668 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
1669 {
1670 const struct powerpc_operand *operand;
1671 const char *errmsg;
1672 char *hold;
1673 expressionS ex;
1674 char endc;
1675
1676 if (next_opindex == 0)
1677 operand = &powerpc_operands[*opindex_ptr];
1678 else
1679 {
1680 operand = &powerpc_operands[next_opindex];
1681 next_opindex = 0;
1682 }
1683
1684 errmsg = NULL;
1685
1686 /* If this is a fake operand, then we do not expect anything
1687 from the input. */
1688 if ((operand->flags & PPC_OPERAND_FAKE) != 0)
1689 {
1690 insn = (*operand->insert) (insn, 0L, &errmsg);
1691 if (errmsg != (const char *) NULL)
1692 as_bad (errmsg);
1693 continue;
1694 }
1695
1696 /* If this is an optional operand, and we are skipping it, just
1697 insert a zero. */
1698 if ((operand->flags & PPC_OPERAND_OPTIONAL) != 0
1699 && skip_optional)
1700 {
1701 if (operand->insert)
1702 {
1703 insn = (*operand->insert) (insn, 0L, &errmsg);
1704 if (errmsg != (const char *) NULL)
1705 as_bad (errmsg);
1706 }
1707 if ((operand->flags & PPC_OPERAND_NEXT) != 0)
1708 next_opindex = *opindex_ptr + 1;
1709 continue;
1710 }
1711
1712 /* Gather the operand. */
1713 hold = input_line_pointer;
1714 input_line_pointer = str;
1715
1716 #ifdef TE_PE
1717 if (*input_line_pointer == '[')
1718 {
1719 /* We are expecting something like the second argument here:
1720
1721 lwz r4,[toc].GS.0.static_int(rtoc)
1722 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
1723 The argument following the `]' must be a symbol name, and the
1724 register must be the toc register: 'rtoc' or '2'
1725
1726 The effect is to 0 as the displacement field
1727 in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
1728 the appropriate variation) reloc against it based on the symbol.
1729 The linker will build the toc, and insert the resolved toc offset.
1730
1731 Note:
1732 o The size of the toc entry is currently assumed to be
1733 32 bits. This should not be assumed to be a hard coded
1734 number.
1735 o In an effort to cope with a change from 32 to 64 bits,
1736 there are also toc entries that are specified to be
1737 either 32 or 64 bits:
1738 lwz r4,[toc32].GS.0.static_int(rtoc)
1739 lwz r4,[toc64].GS.0.static_int(rtoc)
1740 These demand toc entries of the specified size, and the
1741 instruction probably requires it.
1742 */
1743
1744 int valid_toc;
1745 enum toc_size_qualifier toc_kind;
1746 bfd_reloc_code_real_type toc_reloc;
1747
1748 /* go parse off the [tocXX] part */
1749 valid_toc = parse_toc_entry(&toc_kind);
1750
1751 if (!valid_toc)
1752 {
1753 /* Note: message has already been issued. */
1754 /* FIXME: what sort of recovery should we do? */
1755 /* demand_rest_of_line(); return; ? */
1756 }
1757
1758 /* Now get the symbol following the ']' */
1759 expression(&ex);
1760
1761 switch (toc_kind)
1762 {
1763 case default_toc:
1764 /* In this case, we may not have seen the symbol yet, since */
1765 /* it is allowed to appear on a .extern or .globl or just be */
1766 /* a label in the .data section. */
1767 toc_reloc = BFD_RELOC_PPC_TOC16;
1768 break;
1769 case data_in_toc:
1770 /* 1. The symbol must be defined and either in the toc */
1771 /* section, or a global. */
1772 /* 2. The reloc generated must have the TOCDEFN flag set in */
1773 /* upper bit mess of the reloc type. */
1774 /* FIXME: It's a little confusing what the tocv qualifier can */
1775 /* be used for. At the very least, I've seen three */
1776 /* uses, only one of which I'm sure I can explain. */
1777 if (ex.X_op == O_symbol)
1778 {
1779 assert (ex.X_add_symbol != NULL);
1780 if (ex.X_add_symbol->bsym->section != tocdata_section)
1781 {
1782 as_bad("[tocv] symbol is not a toc symbol");
1783 }
1784 }
1785
1786 toc_reloc = BFD_RELOC_PPC_TOC16;
1787 break;
1788 case must_be_32:
1789 /* FIXME: these next two specifically specify 32/64 bit toc */
1790 /* entries. We don't support them today. Is this the */
1791 /* right way to say that? */
1792 toc_reloc = BFD_RELOC_UNUSED;
1793 as_bad ("Unimplemented toc32 expression modifier");
1794 break;
1795 case must_be_64:
1796 /* FIXME: see above */
1797 toc_reloc = BFD_RELOC_UNUSED;
1798 as_bad ("Unimplemented toc64 expression modifier");
1799 break;
1800 default:
1801 fprintf(stderr,
1802 "Unexpected return value [%d] from parse_toc_entry!\n",
1803 toc_kind);
1804 abort();
1805 break;
1806 }
1807
1808 /* We need to generate a fixup for this expression. */
1809 if (fc >= MAX_INSN_FIXUPS)
1810 as_fatal ("too many fixups");
1811
1812 fixups[fc].reloc = toc_reloc;
1813 fixups[fc].exp = ex;
1814 fixups[fc].opindex = *opindex_ptr;
1815 ++fc;
1816
1817 /* Ok. We've set up the fixup for the instruction. Now make it
1818 look like the constant 0 was found here */
1819 ex.X_unsigned = 1;
1820 ex.X_op = O_constant;
1821 ex.X_add_number = 0;
1822 ex.X_add_symbol = NULL;
1823 ex.X_op_symbol = NULL;
1824 }
1825
1826 else
1827 #endif /* TE_PE */
1828 {
1829 if (! register_name (&ex))
1830 {
1831 if ((operand->flags & PPC_OPERAND_CR) != 0)
1832 cr_operand = true;
1833 expression (&ex);
1834 cr_operand = false;
1835 }
1836 }
1837
1838 str = input_line_pointer;
1839 input_line_pointer = hold;
1840
1841 if (ex.X_op == O_illegal)
1842 as_bad ("illegal operand");
1843 else if (ex.X_op == O_absent)
1844 as_bad ("missing operand");
1845 else if (ex.X_op == O_register)
1846 {
1847 insn = ppc_insert_operand (insn, operand, ex.X_add_number,
1848 (char *) NULL, 0);
1849 }
1850 else if (ex.X_op == O_constant)
1851 {
1852 #ifdef OBJ_ELF
1853 /* Allow @HA, @L, @H on constants. */
1854 char *orig_str = str;
1855
1856 if ((reloc = ppc_elf_suffix (&str, &ex)) != BFD_RELOC_UNUSED)
1857 switch (reloc)
1858 {
1859 default:
1860 str = orig_str;
1861 break;
1862
1863 case BFD_RELOC_LO16:
1864 /* X_unsigned is the default, so if the user has done
1865 something which cleared it, we always produce a
1866 signed value. */
1867 if (ex.X_unsigned
1868 && (operand->flags & PPC_OPERAND_SIGNED) == 0)
1869 ex.X_add_number &= 0xffff;
1870 else
1871 ex.X_add_number = (((ex.X_add_number & 0xffff)
1872 ^ 0x8000)
1873 - 0x8000);
1874 break;
1875
1876 case BFD_RELOC_HI16:
1877 ex.X_add_number = (ex.X_add_number >> 16) & 0xffff;
1878 break;
1879
1880 case BFD_RELOC_HI16_S:
1881 ex.X_add_number = (((ex.X_add_number >> 16) & 0xffff)
1882 + ((ex.X_add_number >> 15) & 1));
1883 break;
1884 }
1885 #endif
1886 insn = ppc_insert_operand (insn, operand, ex.X_add_number,
1887 (char *) NULL, 0);
1888 }
1889 #ifdef OBJ_ELF
1890 else if ((reloc = ppc_elf_suffix (&str, &ex)) != BFD_RELOC_UNUSED)
1891 {
1892 /* For the absoulte forms of branchs, convert the PC relative form back into
1893 the absolute. */
1894 if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0)
1895 {
1896 switch (reloc)
1897 {
1898 case BFD_RELOC_PPC_B26:
1899 reloc = BFD_RELOC_PPC_BA26;
1900 break;
1901 case BFD_RELOC_PPC_B16:
1902 reloc = BFD_RELOC_PPC_BA16;
1903 break;
1904 case BFD_RELOC_PPC_B16_BRTAKEN:
1905 reloc = BFD_RELOC_PPC_BA16_BRTAKEN;
1906 break;
1907 case BFD_RELOC_PPC_B16_BRNTAKEN:
1908 reloc = BFD_RELOC_PPC_BA16_BRNTAKEN;
1909 break;
1910 default:
1911 break;
1912 }
1913 }
1914
1915 /* We need to generate a fixup for this expression. */
1916 if (fc >= MAX_INSN_FIXUPS)
1917 as_fatal ("too many fixups");
1918 fixups[fc].exp = ex;
1919 fixups[fc].opindex = 0;
1920 fixups[fc].reloc = reloc;
1921 ++fc;
1922 }
1923 #endif /* OBJ_ELF */
1924
1925 else
1926 {
1927 /* We need to generate a fixup for this expression. */
1928 if (fc >= MAX_INSN_FIXUPS)
1929 as_fatal ("too many fixups");
1930 fixups[fc].exp = ex;
1931 fixups[fc].opindex = *opindex_ptr;
1932 fixups[fc].reloc = BFD_RELOC_UNUSED;
1933 ++fc;
1934 }
1935
1936 if (need_paren)
1937 {
1938 endc = ')';
1939 need_paren = 0;
1940 }
1941 else if ((operand->flags & PPC_OPERAND_PARENS) != 0)
1942 {
1943 endc = '(';
1944 need_paren = 1;
1945 }
1946 else
1947 endc = ',';
1948
1949 /* The call to expression should have advanced str past any
1950 whitespace. */
1951 if (*str != endc
1952 && (endc != ',' || *str != '\0'))
1953 {
1954 as_bad ("syntax error; found `%c' but expected `%c'", *str, endc);
1955 break;
1956 }
1957
1958 if (*str != '\0')
1959 ++str;
1960 }
1961
1962 while (isspace (*str))
1963 ++str;
1964
1965 if (*str != '\0')
1966 as_bad ("junk at end of line: `%s'", str);
1967
1968 /* Write out the instruction. */
1969 f = frag_more (4);
1970 md_number_to_chars (f, insn, 4);
1971
1972 /* Create any fixups. At this point we do not use a
1973 bfd_reloc_code_real_type, but instead just use the
1974 BFD_RELOC_UNUSED plus the operand index. This lets us easily
1975 handle fixups for any operand type, although that is admittedly
1976 not a very exciting feature. We pick a BFD reloc type in
1977 md_apply_fix. */
1978 for (i = 0; i < fc; i++)
1979 {
1980 const struct powerpc_operand *operand;
1981
1982 operand = &powerpc_operands[fixups[i].opindex];
1983 if (fixups[i].reloc != BFD_RELOC_UNUSED)
1984 {
1985 reloc_howto_type *reloc_howto = bfd_reloc_type_lookup (stdoutput, fixups[i].reloc);
1986 int size;
1987 int offset;
1988 fixS *fixP;
1989
1990 if (!reloc_howto)
1991 abort ();
1992
1993 size = bfd_get_reloc_size (reloc_howto);
1994 offset = target_big_endian ? (4 - size) : 0;
1995
1996 if (size < 1 || size > 4)
1997 abort();
1998
1999 fixP = fix_new_exp (frag_now, f - frag_now->fr_literal + offset, size,
2000 &fixups[i].exp, reloc_howto->pc_relative,
2001 fixups[i].reloc);
2002
2003 /* Turn off complaints that the addend is too large for things like
2004 foo+100000@ha. */
2005 switch (fixups[i].reloc)
2006 {
2007 case BFD_RELOC_16_GOTOFF:
2008 case BFD_RELOC_PPC_TOC16:
2009 case BFD_RELOC_LO16:
2010 case BFD_RELOC_HI16:
2011 case BFD_RELOC_HI16_S:
2012 fixP->fx_no_overflow = 1;
2013 break;
2014 default:
2015 break;
2016 }
2017 }
2018 else
2019 fix_new_exp (frag_now, f - frag_now->fr_literal, 4,
2020 &fixups[i].exp,
2021 (operand->flags & PPC_OPERAND_RELATIVE) != 0,
2022 ((bfd_reloc_code_real_type)
2023 (fixups[i].opindex + (int) BFD_RELOC_UNUSED)));
2024 }
2025 }
2026
2027 #ifndef WORKING_DOT_WORD
2028 /* Handle long and short jumps */
2029 void
2030 md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
2031 char *ptr;
2032 addressT from_addr, to_addr;
2033 fragS *frag;
2034 symbolS *to_symbol;
2035 {
2036 abort ();
2037 }
2038
2039 void
2040 md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
2041 char *ptr;
2042 addressT from_addr, to_addr;
2043 fragS *frag;
2044 symbolS *to_symbol;
2045 {
2046 abort ();
2047 }
2048 #endif
2049
2050 /* Handle a macro. Gather all the operands, transform them as
2051 described by the macro, and call md_assemble recursively. All the
2052 operands are separated by commas; we don't accept parentheses
2053 around operands here. */
2054
2055 static void
2056 ppc_macro (str, macro)
2057 char *str;
2058 const struct powerpc_macro *macro;
2059 {
2060 char *operands[10];
2061 unsigned int count;
2062 char *s;
2063 unsigned int len;
2064 const char *format;
2065 int arg;
2066 char *send;
2067 char *complete;
2068
2069 /* Gather the users operands into the operands array. */
2070 count = 0;
2071 s = str;
2072 while (1)
2073 {
2074 if (count >= sizeof operands / sizeof operands[0])
2075 break;
2076 operands[count++] = s;
2077 s = strchr (s, ',');
2078 if (s == (char *) NULL)
2079 break;
2080 *s++ = '\0';
2081 }
2082
2083 if (count != macro->operands)
2084 {
2085 as_bad ("wrong number of operands");
2086 return;
2087 }
2088
2089 /* Work out how large the string must be (the size is unbounded
2090 because it includes user input). */
2091 len = 0;
2092 format = macro->format;
2093 while (*format != '\0')
2094 {
2095 if (*format != '%')
2096 {
2097 ++len;
2098 ++format;
2099 }
2100 else
2101 {
2102 arg = strtol (format + 1, &send, 10);
2103 know (send != format && arg >= 0 && arg < count);
2104 len += strlen (operands[arg]);
2105 format = send;
2106 }
2107 }
2108
2109 /* Put the string together. */
2110 complete = s = (char *) alloca (len + 1);
2111 format = macro->format;
2112 while (*format != '\0')
2113 {
2114 if (*format != '%')
2115 *s++ = *format++;
2116 else
2117 {
2118 arg = strtol (format + 1, &send, 10);
2119 strcpy (s, operands[arg]);
2120 s += strlen (s);
2121 format = send;
2122 }
2123 }
2124 *s = '\0';
2125
2126 /* Assemble the constructed instruction. */
2127 md_assemble (complete);
2128 }
2129 \f
2130 #ifdef OBJ_ELF
2131 /* For ELF, add support for SHF_EXCLUDE and SHT_ORDERED */
2132
2133 int
2134 ppc_section_letter (letter, ptr_msg)
2135 int letter;
2136 char **ptr_msg;
2137 {
2138 if (letter == 'e')
2139 return SHF_EXCLUDE;
2140
2141 *ptr_msg = "Bad .section directive: want a,w,x,e in string";
2142 return 0;
2143 }
2144
2145 int
2146 ppc_section_word (ptr_str)
2147 char **ptr_str;
2148 {
2149 if (strncmp (*ptr_str, "exclude", sizeof ("exclude")-1) == 0)
2150 {
2151 *ptr_str += sizeof ("exclude")-1;
2152 return SHF_EXCLUDE;
2153 }
2154
2155 return 0;
2156 }
2157
2158 int
2159 ppc_section_type (ptr_str)
2160 char **ptr_str;
2161 {
2162 if (strncmp (*ptr_str, "ordered", sizeof ("ordered")-1) == 0)
2163 {
2164 *ptr_str += sizeof ("ordered")-1;
2165 return SHT_ORDERED;
2166 }
2167
2168 return 0;
2169 }
2170
2171 int
2172 ppc_section_flags (flags, attr, type)
2173 int flags;
2174 int attr;
2175 int type;
2176 {
2177 if (type == SHT_ORDERED)
2178 flags |= SEC_ALLOC | SEC_LOAD | SEC_SORT_ENTRIES;
2179
2180 if (attr & SHF_EXCLUDE)
2181 flags |= SEC_EXCLUDE;
2182
2183 return flags;
2184 }
2185 #endif /* OBJ_ELF */
2186
2187 \f
2188 /* Pseudo-op handling. */
2189
2190 /* The .byte pseudo-op. This is similar to the normal .byte
2191 pseudo-op, but it can also take a single ASCII string. */
2192
2193 static void
2194 ppc_byte (ignore)
2195 int ignore;
2196 {
2197 if (*input_line_pointer != '\"')
2198 {
2199 cons (1);
2200 return;
2201 }
2202
2203 /* Gather characters. A real double quote is doubled. Unusual
2204 characters are not permitted. */
2205 ++input_line_pointer;
2206 while (1)
2207 {
2208 char c;
2209
2210 c = *input_line_pointer++;
2211
2212 if (c == '\"')
2213 {
2214 if (*input_line_pointer != '\"')
2215 break;
2216 ++input_line_pointer;
2217 }
2218
2219 FRAG_APPEND_1_CHAR (c);
2220 }
2221
2222 demand_empty_rest_of_line ();
2223 }
2224 \f
2225 #ifdef OBJ_XCOFF
2226
2227 /* XCOFF specific pseudo-op handling. */
2228
2229 /* This is set if we are creating a .stabx symbol, since we don't want
2230 to handle symbol suffixes for such symbols. */
2231 static boolean ppc_stab_symbol;
2232
2233 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
2234 symbols in the .bss segment as though they were local common
2235 symbols, and uses a different smclas. */
2236
2237 static void
2238 ppc_comm (lcomm)
2239 int lcomm;
2240 {
2241 asection *current_seg = now_seg;
2242 subsegT current_subseg = now_subseg;
2243 char *name;
2244 char endc;
2245 char *end_name;
2246 offsetT size;
2247 offsetT align;
2248 symbolS *lcomm_sym = NULL;
2249 symbolS *sym;
2250 char *pfrag;
2251
2252 name = input_line_pointer;
2253 endc = get_symbol_end ();
2254 end_name = input_line_pointer;
2255 *end_name = endc;
2256
2257 if (*input_line_pointer != ',')
2258 {
2259 as_bad ("missing size");
2260 ignore_rest_of_line ();
2261 return;
2262 }
2263 ++input_line_pointer;
2264
2265 size = get_absolute_expression ();
2266 if (size < 0)
2267 {
2268 as_bad ("negative size");
2269 ignore_rest_of_line ();
2270 return;
2271 }
2272
2273 if (! lcomm)
2274 {
2275 /* The third argument to .comm is the alignment. */
2276 if (*input_line_pointer != ',')
2277 align = 3;
2278 else
2279 {
2280 ++input_line_pointer;
2281 align = get_absolute_expression ();
2282 if (align <= 0)
2283 {
2284 as_warn ("ignoring bad alignment");
2285 align = 3;
2286 }
2287 }
2288 }
2289 else
2290 {
2291 char *lcomm_name;
2292 char lcomm_endc;
2293
2294 if (size <= 1)
2295 align = 0;
2296 else if (size <= 2)
2297 align = 1;
2298 else if (size <= 4)
2299 align = 2;
2300 else
2301 align = 3;
2302
2303 /* The third argument to .lcomm appears to be the real local
2304 common symbol to create. References to the symbol named in
2305 the first argument are turned into references to the third
2306 argument. */
2307 if (*input_line_pointer != ',')
2308 {
2309 as_bad ("missing real symbol name");
2310 ignore_rest_of_line ();
2311 return;
2312 }
2313 ++input_line_pointer;
2314
2315 lcomm_name = input_line_pointer;
2316 lcomm_endc = get_symbol_end ();
2317
2318 lcomm_sym = symbol_find_or_make (lcomm_name);
2319
2320 *input_line_pointer = lcomm_endc;
2321 }
2322
2323 *end_name = '\0';
2324 sym = symbol_find_or_make (name);
2325 *end_name = endc;
2326
2327 if (S_IS_DEFINED (sym)
2328 || S_GET_VALUE (sym) != 0)
2329 {
2330 as_bad ("attempt to redefine symbol");
2331 ignore_rest_of_line ();
2332 return;
2333 }
2334
2335 record_alignment (bss_section, align);
2336
2337 if (! lcomm
2338 || ! S_IS_DEFINED (lcomm_sym))
2339 {
2340 symbolS *def_sym;
2341 offsetT def_size;
2342
2343 if (! lcomm)
2344 {
2345 def_sym = sym;
2346 def_size = size;
2347 S_SET_EXTERNAL (sym);
2348 }
2349 else
2350 {
2351 lcomm_sym->sy_tc.output = 1;
2352 def_sym = lcomm_sym;
2353 def_size = 0;
2354 }
2355
2356 subseg_set (bss_section, 1);
2357 frag_align (align, 0, 0);
2358
2359 def_sym->sy_frag = frag_now;
2360 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, def_sym,
2361 def_size, (char *) NULL);
2362 *pfrag = 0;
2363 S_SET_SEGMENT (def_sym, bss_section);
2364 def_sym->sy_tc.align = align;
2365 }
2366 else if (lcomm)
2367 {
2368 /* Align the size of lcomm_sym. */
2369 lcomm_sym->sy_frag->fr_offset =
2370 ((lcomm_sym->sy_frag->fr_offset + (1 << align) - 1)
2371 &~ ((1 << align) - 1));
2372 if (align > lcomm_sym->sy_tc.align)
2373 lcomm_sym->sy_tc.align = align;
2374 }
2375
2376 if (lcomm)
2377 {
2378 /* Make sym an offset from lcomm_sym. */
2379 S_SET_SEGMENT (sym, bss_section);
2380 sym->sy_frag = lcomm_sym->sy_frag;
2381 S_SET_VALUE (sym, lcomm_sym->sy_frag->fr_offset);
2382 lcomm_sym->sy_frag->fr_offset += size;
2383 }
2384
2385 subseg_set (current_seg, current_subseg);
2386
2387 demand_empty_rest_of_line ();
2388 }
2389
2390 /* The .csect pseudo-op. This switches us into a different
2391 subsegment. The first argument is a symbol whose value is the
2392 start of the .csect. In COFF, csect symbols get special aux
2393 entries defined by the x_csect field of union internal_auxent. The
2394 optional second argument is the alignment (the default is 2). */
2395
2396 static void
2397 ppc_csect (ignore)
2398 int ignore;
2399 {
2400 char *name;
2401 char endc;
2402 symbolS *sym;
2403
2404 name = input_line_pointer;
2405 endc = get_symbol_end ();
2406
2407 sym = symbol_find_or_make (name);
2408
2409 *input_line_pointer = endc;
2410
2411 if (S_GET_NAME (sym)[0] == '\0')
2412 {
2413 /* An unnamed csect is assumed to be [PR]. */
2414 sym->sy_tc.class = XMC_PR;
2415 }
2416
2417 ppc_change_csect (sym);
2418
2419 if (*input_line_pointer == ',')
2420 {
2421 ++input_line_pointer;
2422 sym->sy_tc.align = get_absolute_expression ();
2423 }
2424
2425 demand_empty_rest_of_line ();
2426 }
2427
2428 /* Change to a different csect. */
2429
2430 static void
2431 ppc_change_csect (sym)
2432 symbolS *sym;
2433 {
2434 if (S_IS_DEFINED (sym))
2435 subseg_set (S_GET_SEGMENT (sym), sym->sy_tc.subseg);
2436 else
2437 {
2438 symbolS **list_ptr;
2439 int after_toc;
2440 int hold_chunksize;
2441 symbolS *list;
2442
2443 /* This is a new csect. We need to look at the symbol class to
2444 figure out whether it should go in the text section or the
2445 data section. */
2446 after_toc = 0;
2447 switch (sym->sy_tc.class)
2448 {
2449 case XMC_PR:
2450 case XMC_RO:
2451 case XMC_DB:
2452 case XMC_GL:
2453 case XMC_XO:
2454 case XMC_SV:
2455 case XMC_TI:
2456 case XMC_TB:
2457 S_SET_SEGMENT (sym, text_section);
2458 sym->sy_tc.subseg = ppc_text_subsegment;
2459 ++ppc_text_subsegment;
2460 list_ptr = &ppc_text_csects;
2461 break;
2462 case XMC_RW:
2463 case XMC_TC0:
2464 case XMC_TC:
2465 case XMC_DS:
2466 case XMC_UA:
2467 case XMC_BS:
2468 case XMC_UC:
2469 if (ppc_toc_csect != NULL
2470 && ppc_toc_csect->sy_tc.subseg + 1 == ppc_data_subsegment)
2471 after_toc = 1;
2472 S_SET_SEGMENT (sym, data_section);
2473 sym->sy_tc.subseg = ppc_data_subsegment;
2474 ++ppc_data_subsegment;
2475 list_ptr = &ppc_data_csects;
2476 break;
2477 default:
2478 abort ();
2479 }
2480
2481 /* We set the obstack chunk size to a small value before
2482 changing subsegments, so that we don't use a lot of memory
2483 space for what may be a small section. */
2484 hold_chunksize = chunksize;
2485 chunksize = 64;
2486
2487 subseg_new (segment_name (S_GET_SEGMENT (sym)), sym->sy_tc.subseg);
2488
2489 chunksize = hold_chunksize;
2490
2491 if (after_toc)
2492 ppc_after_toc_frag = frag_now;
2493
2494 sym->sy_frag = frag_now;
2495 S_SET_VALUE (sym, (valueT) frag_now_fix ());
2496
2497 sym->sy_tc.align = 2;
2498 sym->sy_tc.output = 1;
2499 sym->sy_tc.within = sym;
2500
2501 for (list = *list_ptr;
2502 list->sy_tc.next != (symbolS *) NULL;
2503 list = list->sy_tc.next)
2504 ;
2505 list->sy_tc.next = sym;
2506
2507 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
2508 symbol_append (sym, list->sy_tc.within, &symbol_rootP, &symbol_lastP);
2509 }
2510
2511 ppc_current_csect = sym;
2512 }
2513
2514 /* This function handles the .text and .data pseudo-ops. These
2515 pseudo-ops aren't really used by XCOFF; we implement them for the
2516 convenience of people who aren't used to XCOFF. */
2517
2518 static void
2519 ppc_section (type)
2520 int type;
2521 {
2522 const char *name;
2523 symbolS *sym;
2524
2525 if (type == 't')
2526 name = ".text[PR]";
2527 else if (type == 'd')
2528 name = ".data[RW]";
2529 else
2530 abort ();
2531
2532 sym = symbol_find_or_make (name);
2533
2534 ppc_change_csect (sym);
2535
2536 demand_empty_rest_of_line ();
2537 }
2538
2539 /* The .extern pseudo-op. We create an undefined symbol. */
2540
2541 static void
2542 ppc_extern (ignore)
2543 int ignore;
2544 {
2545 char *name;
2546 char endc;
2547
2548 name = input_line_pointer;
2549 endc = get_symbol_end ();
2550
2551 (void) symbol_find_or_make (name);
2552
2553 *input_line_pointer = endc;
2554
2555 demand_empty_rest_of_line ();
2556 }
2557
2558 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
2559
2560 static void
2561 ppc_lglobl (ignore)
2562 int ignore;
2563 {
2564 char *name;
2565 char endc;
2566 symbolS *sym;
2567
2568 name = input_line_pointer;
2569 endc = get_symbol_end ();
2570
2571 sym = symbol_find_or_make (name);
2572
2573 *input_line_pointer = endc;
2574
2575 sym->sy_tc.output = 1;
2576
2577 demand_empty_rest_of_line ();
2578 }
2579
2580 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
2581 although I don't know why it bothers. */
2582
2583 static void
2584 ppc_rename (ignore)
2585 int ignore;
2586 {
2587 char *name;
2588 char endc;
2589 symbolS *sym;
2590 int len;
2591
2592 name = input_line_pointer;
2593 endc = get_symbol_end ();
2594
2595 sym = symbol_find_or_make (name);
2596
2597 *input_line_pointer = endc;
2598
2599 if (*input_line_pointer != ',')
2600 {
2601 as_bad ("missing rename string");
2602 ignore_rest_of_line ();
2603 return;
2604 }
2605 ++input_line_pointer;
2606
2607 sym->sy_tc.real_name = demand_copy_C_string (&len);
2608
2609 demand_empty_rest_of_line ();
2610 }
2611
2612 /* The .stabx pseudo-op. This is similar to a normal .stabs
2613 pseudo-op, but slightly different. A sample is
2614 .stabx "main:F-1",.main,142,0
2615 The first argument is the symbol name to create. The second is the
2616 value, and the third is the storage class. The fourth seems to be
2617 always zero, and I am assuming it is the type. */
2618
2619 static void
2620 ppc_stabx (ignore)
2621 int ignore;
2622 {
2623 char *name;
2624 int len;
2625 symbolS *sym;
2626 expressionS exp;
2627
2628 name = demand_copy_C_string (&len);
2629
2630 if (*input_line_pointer != ',')
2631 {
2632 as_bad ("missing value");
2633 return;
2634 }
2635 ++input_line_pointer;
2636
2637 ppc_stab_symbol = true;
2638 sym = symbol_make (name);
2639 ppc_stab_symbol = false;
2640
2641 sym->sy_tc.real_name = name;
2642
2643 (void) expression (&exp);
2644
2645 switch (exp.X_op)
2646 {
2647 case O_illegal:
2648 case O_absent:
2649 case O_big:
2650 as_bad ("illegal .stabx expression; zero assumed");
2651 exp.X_add_number = 0;
2652 /* Fall through. */
2653 case O_constant:
2654 S_SET_VALUE (sym, (valueT) exp.X_add_number);
2655 sym->sy_frag = &zero_address_frag;
2656 break;
2657
2658 case O_symbol:
2659 if (S_GET_SEGMENT (exp.X_add_symbol) == undefined_section)
2660 sym->sy_value = exp;
2661 else
2662 {
2663 S_SET_VALUE (sym,
2664 exp.X_add_number + S_GET_VALUE (exp.X_add_symbol));
2665 sym->sy_frag = exp.X_add_symbol->sy_frag;
2666 }
2667 break;
2668
2669 default:
2670 /* The value is some complex expression. This will probably
2671 fail at some later point, but this is probably the right
2672 thing to do here. */
2673 sym->sy_value = exp;
2674 break;
2675 }
2676
2677 S_SET_SEGMENT (sym, ppc_coff_debug_section);
2678 sym->bsym->flags |= BSF_DEBUGGING;
2679
2680 if (*input_line_pointer != ',')
2681 {
2682 as_bad ("missing class");
2683 return;
2684 }
2685 ++input_line_pointer;
2686
2687 S_SET_STORAGE_CLASS (sym, get_absolute_expression ());
2688
2689 if (*input_line_pointer != ',')
2690 {
2691 as_bad ("missing type");
2692 return;
2693 }
2694 ++input_line_pointer;
2695
2696 S_SET_DATA_TYPE (sym, get_absolute_expression ());
2697
2698 sym->sy_tc.output = 1;
2699
2700 if (S_GET_STORAGE_CLASS (sym) == C_STSYM)
2701 sym->sy_tc.within = ppc_current_block;
2702
2703 if (exp.X_op != O_symbol
2704 || ! S_IS_EXTERNAL (exp.X_add_symbol)
2705 || S_GET_SEGMENT (exp.X_add_symbol) != bss_section)
2706 ppc_frob_label (sym);
2707 else
2708 {
2709 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
2710 symbol_append (sym, exp.X_add_symbol, &symbol_rootP, &symbol_lastP);
2711 if (ppc_current_csect->sy_tc.within == exp.X_add_symbol)
2712 ppc_current_csect->sy_tc.within = sym;
2713 }
2714
2715 demand_empty_rest_of_line ();
2716 }
2717
2718 /* The .function pseudo-op. This takes several arguments. The first
2719 argument seems to be the external name of the symbol. The second
2720 argment seems to be the label for the start of the function. gcc
2721 uses the same name for both. I have no idea what the third and
2722 fourth arguments are meant to be. The optional fifth argument is
2723 an expression for the size of the function. In COFF this symbol
2724 gets an aux entry like that used for a csect. */
2725
2726 static void
2727 ppc_function (ignore)
2728 int ignore;
2729 {
2730 char *name;
2731 char endc;
2732 char *s;
2733 symbolS *ext_sym;
2734 symbolS *lab_sym;
2735
2736 name = input_line_pointer;
2737 endc = get_symbol_end ();
2738
2739 /* Ignore any [PR] suffix. */
2740 name = ppc_canonicalize_symbol_name (name);
2741 s = strchr (name, '[');
2742 if (s != (char *) NULL
2743 && strcmp (s + 1, "PR]") == 0)
2744 *s = '\0';
2745
2746 ext_sym = symbol_find_or_make (name);
2747
2748 *input_line_pointer = endc;
2749
2750 if (*input_line_pointer != ',')
2751 {
2752 as_bad ("missing symbol name");
2753 ignore_rest_of_line ();
2754 return;
2755 }
2756 ++input_line_pointer;
2757
2758 name = input_line_pointer;
2759 endc = get_symbol_end ();
2760
2761 lab_sym = symbol_find_or_make (name);
2762
2763 *input_line_pointer = endc;
2764
2765 if (ext_sym != lab_sym)
2766 {
2767 ext_sym->sy_value.X_op = O_symbol;
2768 ext_sym->sy_value.X_add_symbol = lab_sym;
2769 ext_sym->sy_value.X_op_symbol = NULL;
2770 ext_sym->sy_value.X_add_number = 0;
2771 }
2772
2773 if (ext_sym->sy_tc.class == -1)
2774 ext_sym->sy_tc.class = XMC_PR;
2775 ext_sym->sy_tc.output = 1;
2776
2777 if (*input_line_pointer == ',')
2778 {
2779 expressionS ignore;
2780
2781 /* Ignore the third argument. */
2782 ++input_line_pointer;
2783 expression (&ignore);
2784 if (*input_line_pointer == ',')
2785 {
2786 /* Ignore the fourth argument. */
2787 ++input_line_pointer;
2788 expression (&ignore);
2789 if (*input_line_pointer == ',')
2790 {
2791 /* The fifth argument is the function size. */
2792 ++input_line_pointer;
2793 ext_sym->sy_tc.size = symbol_new ("L0\001",
2794 absolute_section,
2795 (valueT) 0,
2796 &zero_address_frag);
2797 pseudo_set (ext_sym->sy_tc.size);
2798 }
2799 }
2800 }
2801
2802 S_SET_DATA_TYPE (ext_sym, DT_FCN << N_BTSHFT);
2803 SF_SET_FUNCTION (ext_sym);
2804 SF_SET_PROCESS (ext_sym);
2805 coff_add_linesym (ext_sym);
2806
2807 demand_empty_rest_of_line ();
2808 }
2809
2810 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
2811 ".bf". */
2812
2813 static void
2814 ppc_bf (ignore)
2815 int ignore;
2816 {
2817 symbolS *sym;
2818
2819 sym = symbol_make (".bf");
2820 S_SET_SEGMENT (sym, text_section);
2821 sym->sy_frag = frag_now;
2822 S_SET_VALUE (sym, frag_now_fix ());
2823 S_SET_STORAGE_CLASS (sym, C_FCN);
2824
2825 coff_line_base = get_absolute_expression ();
2826
2827 S_SET_NUMBER_AUXILIARY (sym, 1);
2828 SA_SET_SYM_LNNO (sym, coff_line_base);
2829
2830 sym->sy_tc.output = 1;
2831
2832 ppc_frob_label (sym);
2833
2834 demand_empty_rest_of_line ();
2835 }
2836
2837 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
2838 ".ef", except that the line number is absolute, not relative to the
2839 most recent ".bf" symbol. */
2840
2841 static void
2842 ppc_ef (ignore)
2843 int ignore;
2844 {
2845 symbolS *sym;
2846
2847 sym = symbol_make (".ef");
2848 S_SET_SEGMENT (sym, text_section);
2849 sym->sy_frag = frag_now;
2850 S_SET_VALUE (sym, frag_now_fix ());
2851 S_SET_STORAGE_CLASS (sym, C_FCN);
2852 S_SET_NUMBER_AUXILIARY (sym, 1);
2853 SA_SET_SYM_LNNO (sym, get_absolute_expression ());
2854 sym->sy_tc.output = 1;
2855
2856 ppc_frob_label (sym);
2857
2858 demand_empty_rest_of_line ();
2859 }
2860
2861 /* The .bi and .ei pseudo-ops. These take a string argument and
2862 generates a C_BINCL or C_EINCL symbol, which goes at the start of
2863 the symbol list. */
2864
2865 static void
2866 ppc_biei (ei)
2867 int ei;
2868 {
2869 static symbolS *last_biei;
2870
2871 char *name;
2872 int len;
2873 symbolS *sym;
2874 symbolS *look;
2875
2876 name = demand_copy_C_string (&len);
2877
2878 /* The value of these symbols is actually file offset. Here we set
2879 the value to the index into the line number entries. In
2880 ppc_frob_symbols we set the fix_line field, which will cause BFD
2881 to do the right thing. */
2882
2883 sym = symbol_make (name);
2884 /* obj-coff.c currently only handles line numbers correctly in the
2885 .text section. */
2886 S_SET_SEGMENT (sym, text_section);
2887 S_SET_VALUE (sym, coff_n_line_nos);
2888 sym->bsym->flags |= BSF_DEBUGGING;
2889
2890 S_SET_STORAGE_CLASS (sym, ei ? C_EINCL : C_BINCL);
2891 sym->sy_tc.output = 1;
2892
2893 for (look = last_biei ? last_biei : symbol_rootP;
2894 (look != (symbolS *) NULL
2895 && (S_GET_STORAGE_CLASS (look) == C_FILE
2896 || S_GET_STORAGE_CLASS (look) == C_BINCL
2897 || S_GET_STORAGE_CLASS (look) == C_EINCL));
2898 look = symbol_next (look))
2899 ;
2900 if (look != (symbolS *) NULL)
2901 {
2902 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
2903 symbol_insert (sym, look, &symbol_rootP, &symbol_lastP);
2904 last_biei = sym;
2905 }
2906
2907 demand_empty_rest_of_line ();
2908 }
2909
2910 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
2911 There is one argument, which is a csect symbol. The value of the
2912 .bs symbol is the index of this csect symbol. */
2913
2914 static void
2915 ppc_bs (ignore)
2916 int ignore;
2917 {
2918 char *name;
2919 char endc;
2920 symbolS *csect;
2921 symbolS *sym;
2922
2923 if (ppc_current_block != NULL)
2924 as_bad ("nested .bs blocks");
2925
2926 name = input_line_pointer;
2927 endc = get_symbol_end ();
2928
2929 csect = symbol_find_or_make (name);
2930
2931 *input_line_pointer = endc;
2932
2933 sym = symbol_make (".bs");
2934 S_SET_SEGMENT (sym, now_seg);
2935 S_SET_STORAGE_CLASS (sym, C_BSTAT);
2936 sym->bsym->flags |= BSF_DEBUGGING;
2937 sym->sy_tc.output = 1;
2938
2939 sym->sy_tc.within = csect;
2940
2941 ppc_frob_label (sym);
2942
2943 ppc_current_block = sym;
2944
2945 demand_empty_rest_of_line ();
2946 }
2947
2948 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
2949
2950 static void
2951 ppc_es (ignore)
2952 int ignore;
2953 {
2954 symbolS *sym;
2955
2956 if (ppc_current_block == NULL)
2957 as_bad (".es without preceding .bs");
2958
2959 sym = symbol_make (".es");
2960 S_SET_SEGMENT (sym, now_seg);
2961 S_SET_STORAGE_CLASS (sym, C_ESTAT);
2962 sym->bsym->flags |= BSF_DEBUGGING;
2963 sym->sy_tc.output = 1;
2964
2965 ppc_frob_label (sym);
2966
2967 ppc_current_block = NULL;
2968
2969 demand_empty_rest_of_line ();
2970 }
2971
2972 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
2973 line number. */
2974
2975 static void
2976 ppc_bb (ignore)
2977 int ignore;
2978 {
2979 symbolS *sym;
2980
2981 sym = symbol_make (".bb");
2982 S_SET_SEGMENT (sym, text_section);
2983 sym->sy_frag = frag_now;
2984 S_SET_VALUE (sym, frag_now_fix ());
2985 S_SET_STORAGE_CLASS (sym, C_BLOCK);
2986
2987 S_SET_NUMBER_AUXILIARY (sym, 1);
2988 SA_SET_SYM_LNNO (sym, get_absolute_expression ());
2989
2990 sym->sy_tc.output = 1;
2991
2992 SF_SET_PROCESS (sym);
2993
2994 ppc_frob_label (sym);
2995
2996 demand_empty_rest_of_line ();
2997 }
2998
2999 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
3000 line number. */
3001
3002 static void
3003 ppc_eb (ignore)
3004 int ignore;
3005 {
3006 symbolS *sym;
3007
3008 sym = symbol_make (".eb");
3009 S_SET_SEGMENT (sym, text_section);
3010 sym->sy_frag = frag_now;
3011 S_SET_VALUE (sym, frag_now_fix ());
3012 S_SET_STORAGE_CLASS (sym, C_BLOCK);
3013 S_SET_NUMBER_AUXILIARY (sym, 1);
3014 SA_SET_SYM_LNNO (sym, get_absolute_expression ());
3015 sym->sy_tc.output = 1;
3016
3017 SF_SET_PROCESS (sym);
3018
3019 ppc_frob_label (sym);
3020
3021 demand_empty_rest_of_line ();
3022 }
3023
3024 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
3025 specified name. */
3026
3027 static void
3028 ppc_bc (ignore)
3029 int ignore;
3030 {
3031 char *name;
3032 int len;
3033 symbolS *sym;
3034
3035 name = demand_copy_C_string (&len);
3036 sym = symbol_make (name);
3037 S_SET_SEGMENT (sym, ppc_coff_debug_section);
3038 sym->bsym->flags |= BSF_DEBUGGING;
3039 S_SET_STORAGE_CLASS (sym, C_BCOMM);
3040 S_SET_VALUE (sym, 0);
3041 sym->sy_tc.output = 1;
3042
3043 ppc_frob_label (sym);
3044
3045 demand_empty_rest_of_line ();
3046 }
3047
3048 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
3049
3050 static void
3051 ppc_ec (ignore)
3052 int ignore;
3053 {
3054 symbolS *sym;
3055
3056 sym = symbol_make (".ec");
3057 S_SET_SEGMENT (sym, ppc_coff_debug_section);
3058 sym->bsym->flags |= BSF_DEBUGGING;
3059 S_SET_STORAGE_CLASS (sym, C_ECOMM);
3060 S_SET_VALUE (sym, 0);
3061 sym->sy_tc.output = 1;
3062
3063 ppc_frob_label (sym);
3064
3065 demand_empty_rest_of_line ();
3066 }
3067
3068 /* The .toc pseudo-op. Switch to the .toc subsegment. */
3069
3070 static void
3071 ppc_toc (ignore)
3072 int ignore;
3073 {
3074 if (ppc_toc_csect != (symbolS *) NULL)
3075 subseg_set (data_section, ppc_toc_csect->sy_tc.subseg);
3076 else
3077 {
3078 subsegT subseg;
3079 symbolS *sym;
3080 symbolS *list;
3081
3082 subseg = ppc_data_subsegment;
3083 ++ppc_data_subsegment;
3084
3085 subseg_new (segment_name (data_section), subseg);
3086 ppc_toc_frag = frag_now;
3087
3088 sym = symbol_find_or_make ("TOC[TC0]");
3089 sym->sy_frag = frag_now;
3090 S_SET_SEGMENT (sym, data_section);
3091 S_SET_VALUE (sym, (valueT) frag_now_fix ());
3092 sym->sy_tc.subseg = subseg;
3093 sym->sy_tc.output = 1;
3094 sym->sy_tc.within = sym;
3095
3096 ppc_toc_csect = sym;
3097
3098 for (list = ppc_data_csects;
3099 list->sy_tc.next != (symbolS *) NULL;
3100 list = list->sy_tc.next)
3101 ;
3102 list->sy_tc.next = sym;
3103
3104 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
3105 symbol_append (sym, list->sy_tc.within, &symbol_rootP, &symbol_lastP);
3106 }
3107
3108 ppc_current_csect = ppc_toc_csect;
3109
3110 demand_empty_rest_of_line ();
3111 }
3112
3113 /* The AIX assembler automatically aligns the operands of a .long or
3114 .short pseudo-op, and we want to be compatible. */
3115
3116 static void
3117 ppc_xcoff_cons (log_size)
3118 int log_size;
3119 {
3120 frag_align (log_size, 0, 0);
3121 record_alignment (now_seg, log_size);
3122 cons (1 << log_size);
3123 }
3124
3125 #endif /* OBJ_XCOFF */
3126 \f
3127 /* The .tc pseudo-op. This is used when generating either XCOFF or
3128 ELF. This takes two or more arguments.
3129
3130 When generating XCOFF output, the first argument is the name to
3131 give to this location in the toc; this will be a symbol with class
3132 TC. The rest of the arguments are 4 byte values to actually put at
3133 this location in the TOC; often there is just one more argument, a
3134 relocateable symbol reference.
3135
3136 When not generating XCOFF output, the arguments are the same, but
3137 the first argument is simply ignored. */
3138
3139 static void
3140 ppc_tc (ignore)
3141 int ignore;
3142 {
3143 #ifdef OBJ_XCOFF
3144
3145 /* Define the TOC symbol name. */
3146 {
3147 char *name;
3148 char endc;
3149 symbolS *sym;
3150
3151 if (ppc_toc_csect == (symbolS *) NULL
3152 || ppc_toc_csect != ppc_current_csect)
3153 {
3154 as_bad (".tc not in .toc section");
3155 ignore_rest_of_line ();
3156 return;
3157 }
3158
3159 name = input_line_pointer;
3160 endc = get_symbol_end ();
3161
3162 sym = symbol_find_or_make (name);
3163
3164 *input_line_pointer = endc;
3165
3166 if (S_IS_DEFINED (sym))
3167 {
3168 symbolS *label;
3169
3170 label = ppc_current_csect->sy_tc.within;
3171 if (label->sy_tc.class != XMC_TC0)
3172 {
3173 as_bad (".tc with no label");
3174 ignore_rest_of_line ();
3175 return;
3176 }
3177
3178 S_SET_SEGMENT (label, S_GET_SEGMENT (sym));
3179 label->sy_frag = sym->sy_frag;
3180 S_SET_VALUE (label, S_GET_VALUE (sym));
3181
3182 while (! is_end_of_line[(unsigned char) *input_line_pointer])
3183 ++input_line_pointer;
3184
3185 return;
3186 }
3187
3188 S_SET_SEGMENT (sym, now_seg);
3189 sym->sy_frag = frag_now;
3190 S_SET_VALUE (sym, (valueT) frag_now_fix ());
3191 sym->sy_tc.class = XMC_TC;
3192 sym->sy_tc.output = 1;
3193
3194 ppc_frob_label (sym);
3195 }
3196
3197 #else /* ! defined (OBJ_XCOFF) */
3198
3199 /* Skip the TOC symbol name. */
3200 while (is_part_of_name (*input_line_pointer)
3201 || *input_line_pointer == '['
3202 || *input_line_pointer == ']'
3203 || *input_line_pointer == '{'
3204 || *input_line_pointer == '}')
3205 ++input_line_pointer;
3206
3207 /* Align to a four byte boundary. */
3208 frag_align (2, 0, 0);
3209 record_alignment (now_seg, 2);
3210
3211 #endif /* ! defined (OBJ_XCOFF) */
3212
3213 if (*input_line_pointer != ',')
3214 demand_empty_rest_of_line ();
3215 else
3216 {
3217 ++input_line_pointer;
3218 cons (4);
3219 }
3220 }
3221 \f
3222 #ifdef TE_PE
3223
3224 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format */
3225
3226 /* Set the current section. */
3227 static void
3228 ppc_set_current_section (new)
3229 segT new;
3230 {
3231 ppc_previous_section = ppc_current_section;
3232 ppc_current_section = new;
3233 }
3234
3235 /* pseudo-op: .previous
3236 behaviour: toggles the current section with the previous section.
3237 errors: None
3238 warnings: "No previous section"
3239 */
3240 static void
3241 ppc_previous(ignore)
3242 int ignore;
3243 {
3244 symbolS *tmp;
3245
3246 if (ppc_previous_section == NULL)
3247 {
3248 as_warn("No previous section to return to. Directive ignored.");
3249 return;
3250 }
3251
3252 subseg_set(ppc_previous_section, 0);
3253
3254 ppc_set_current_section(ppc_previous_section);
3255 }
3256
3257 /* pseudo-op: .pdata
3258 behaviour: predefined read only data section
3259 double word aligned
3260 errors: None
3261 warnings: None
3262 initial: .section .pdata "adr3"
3263 a - don't know -- maybe a misprint
3264 d - initialized data
3265 r - readable
3266 3 - double word aligned (that would be 4 byte boundary)
3267
3268 commentary:
3269 Tag index tables (also known as the function table) for exception
3270 handling, debugging, etc.
3271
3272 */
3273 static void
3274 ppc_pdata(ignore)
3275 int ignore;
3276 {
3277 if (pdata_section == 0)
3278 {
3279 pdata_section = subseg_new (".pdata", 0);
3280
3281 bfd_set_section_flags (stdoutput, pdata_section,
3282 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
3283 | SEC_READONLY | SEC_DATA ));
3284
3285 bfd_set_section_alignment (stdoutput, pdata_section, 2);
3286 }
3287 else
3288 {
3289 pdata_section = subseg_new(".pdata", 0);
3290 }
3291 ppc_set_current_section(pdata_section);
3292 }
3293
3294 /* pseudo-op: .ydata
3295 behaviour: predefined read only data section
3296 double word aligned
3297 errors: None
3298 warnings: None
3299 initial: .section .ydata "drw3"
3300 a - don't know -- maybe a misprint
3301 d - initialized data
3302 r - readable
3303 3 - double word aligned (that would be 4 byte boundary)
3304 commentary:
3305 Tag tables (also known as the scope table) for exception handling,
3306 debugging, etc.
3307 */
3308 static void
3309 ppc_ydata(ignore)
3310 int ignore;
3311 {
3312 if (ydata_section == 0)
3313 {
3314 ydata_section = subseg_new (".ydata", 0);
3315 bfd_set_section_flags (stdoutput, ydata_section,
3316 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
3317 | SEC_READONLY | SEC_DATA ));
3318
3319 bfd_set_section_alignment (stdoutput, ydata_section, 3);
3320 }
3321 else
3322 {
3323 ydata_section = subseg_new (".ydata", 0);
3324 }
3325 ppc_set_current_section(ydata_section);
3326 }
3327
3328 /* pseudo-op: .reldata
3329 behaviour: predefined read write data section
3330 double word aligned (4-byte)
3331 FIXME: relocation is applied to it
3332 FIXME: what's the difference between this and .data?
3333 errors: None
3334 warnings: None
3335 initial: .section .reldata "drw3"
3336 d - initialized data
3337 r - readable
3338 w - writeable
3339 3 - double word aligned (that would be 8 byte boundary)
3340
3341 commentary:
3342 Like .data, but intended to hold data subject to relocation, such as
3343 function descriptors, etc.
3344 */
3345 static void
3346 ppc_reldata(ignore)
3347 int ignore;
3348 {
3349 if (reldata_section == 0)
3350 {
3351 reldata_section = subseg_new (".reldata", 0);
3352
3353 bfd_set_section_flags (stdoutput, reldata_section,
3354 ( SEC_ALLOC | SEC_LOAD | SEC_RELOC
3355 | SEC_DATA ));
3356
3357 bfd_set_section_alignment (stdoutput, reldata_section, 2);
3358 }
3359 else
3360 {
3361 reldata_section = subseg_new (".reldata", 0);
3362 }
3363 ppc_set_current_section(reldata_section);
3364 }
3365
3366 /* pseudo-op: .rdata
3367 behaviour: predefined read only data section
3368 double word aligned
3369 errors: None
3370 warnings: None
3371 initial: .section .rdata "dr3"
3372 d - initialized data
3373 r - readable
3374 3 - double word aligned (that would be 4 byte boundary)
3375 */
3376 static void
3377 ppc_rdata(ignore)
3378 int ignore;
3379 {
3380 if (rdata_section == 0)
3381 {
3382 rdata_section = subseg_new (".rdata", 0);
3383 bfd_set_section_flags (stdoutput, rdata_section,
3384 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
3385 | SEC_READONLY | SEC_DATA ));
3386
3387 bfd_set_section_alignment (stdoutput, rdata_section, 2);
3388 }
3389 else
3390 {
3391 rdata_section = subseg_new (".rdata", 0);
3392 }
3393 ppc_set_current_section(rdata_section);
3394 }
3395
3396 /* pseudo-op: .ualong
3397 behaviour: much like .int, with the exception that no alignment is
3398 performed.
3399 FIXME: test the alignment statement
3400 errors: None
3401 warnings: None
3402 */
3403 static void
3404 ppc_ualong(ignore)
3405 int ignore;
3406 {
3407 /* try for long */
3408 cons ( 4 );
3409 }
3410
3411 /* pseudo-op: .znop <symbol name>
3412 behaviour: Issue a nop instruction
3413 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
3414 the supplied symbol name.
3415 errors: None
3416 warnings: Missing symbol name
3417 */
3418 static void
3419 ppc_znop(ignore)
3420 int ignore;
3421 {
3422 unsigned long insn;
3423 const struct powerpc_opcode *opcode;
3424 expressionS ex;
3425 char *f;
3426
3427 symbolS *sym;
3428
3429 /* Strip out the symbol name */
3430 char *symbol_name;
3431 char c;
3432 char *name;
3433 unsigned int exp;
3434 flagword flags;
3435 asection *sec;
3436
3437 symbol_name = input_line_pointer;
3438 c = get_symbol_end ();
3439
3440 name = xmalloc (input_line_pointer - symbol_name + 1);
3441 strcpy (name, symbol_name);
3442
3443 sym = symbol_find_or_make (name);
3444
3445 *input_line_pointer = c;
3446
3447 SKIP_WHITESPACE ();
3448
3449 /* Look up the opcode in the hash table. */
3450 opcode = (const struct powerpc_opcode *) hash_find (ppc_hash, "nop");
3451
3452 /* stick in the nop */
3453 insn = opcode->opcode;
3454
3455 /* Write out the instruction. */
3456 f = frag_more (4);
3457 md_number_to_chars (f, insn, 4);
3458 fix_new (frag_now,
3459 f - frag_now->fr_literal,
3460 4,
3461 sym,
3462 0,
3463 0,
3464 BFD_RELOC_16_GOT_PCREL);
3465
3466 }
3467
3468 /* pseudo-op:
3469 behaviour:
3470 errors:
3471 warnings:
3472 */
3473 static void
3474 ppc_pe_comm(lcomm)
3475 int lcomm;
3476 {
3477 register char *name;
3478 register char c;
3479 register char *p;
3480 offsetT temp;
3481 register symbolS *symbolP;
3482 offsetT align;
3483
3484 name = input_line_pointer;
3485 c = get_symbol_end ();
3486
3487 /* just after name is now '\0' */
3488 p = input_line_pointer;
3489 *p = c;
3490 SKIP_WHITESPACE ();
3491 if (*input_line_pointer != ',')
3492 {
3493 as_bad ("Expected comma after symbol-name: rest of line ignored.");
3494 ignore_rest_of_line ();
3495 return;
3496 }
3497
3498 input_line_pointer++; /* skip ',' */
3499 if ((temp = get_absolute_expression ()) < 0)
3500 {
3501 as_warn (".COMMon length (%ld.) <0! Ignored.", (long) temp);
3502 ignore_rest_of_line ();
3503 return;
3504 }
3505
3506 if (! lcomm)
3507 {
3508 /* The third argument to .comm is the alignment. */
3509 if (*input_line_pointer != ',')
3510 align = 3;
3511 else
3512 {
3513 ++input_line_pointer;
3514 align = get_absolute_expression ();
3515 if (align <= 0)
3516 {
3517 as_warn ("ignoring bad alignment");
3518 align = 3;
3519 }
3520 }
3521 }
3522
3523 *p = 0;
3524 symbolP = symbol_find_or_make (name);
3525
3526 *p = c;
3527 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
3528 {
3529 as_bad ("Ignoring attempt to re-define symbol `%s'.",
3530 S_GET_NAME (symbolP));
3531 ignore_rest_of_line ();
3532 return;
3533 }
3534
3535 if (S_GET_VALUE (symbolP))
3536 {
3537 if (S_GET_VALUE (symbolP) != (valueT) temp)
3538 as_bad ("Length of .comm \"%s\" is already %ld. Not changed to %ld.",
3539 S_GET_NAME (symbolP),
3540 (long) S_GET_VALUE (symbolP),
3541 (long) temp);
3542 }
3543 else
3544 {
3545 S_SET_VALUE (symbolP, (valueT) temp);
3546 S_SET_EXTERNAL (symbolP);
3547 }
3548
3549 demand_empty_rest_of_line ();
3550 }
3551
3552 /*
3553 * implement the .section pseudo op:
3554 * .section name {, "flags"}
3555 * ^ ^
3556 * | +--- optional flags: 'b' for bss
3557 * | 'i' for info
3558 * +-- section name 'l' for lib
3559 * 'n' for noload
3560 * 'o' for over
3561 * 'w' for data
3562 * 'd' (apparently m88k for data)
3563 * 'x' for text
3564 * But if the argument is not a quoted string, treat it as a
3565 * subsegment number.
3566 *
3567 * FIXME: this is a copy of the section processing from obj-coff.c, with
3568 * additions/changes for the moto-pas assembler support. There are three
3569 * categories:
3570 *
3571 * FIXME: I just noticed this. This doesn't work at all really. It it
3572 * setting bits that bfd probably neither understands or uses. The
3573 * correct approach (?) will have to incorporate extra fields attached
3574 * to the section to hold the system specific stuff. (krk)
3575 *
3576 * Section Contents:
3577 * 'a' - unknown - referred to in documentation, but no definition supplied
3578 * 'c' - section has code
3579 * 'd' - section has initialized data
3580 * 'u' - section has uninitialized data
3581 * 'i' - section contains directives (info)
3582 * 'n' - section can be discarded
3583 * 'R' - remove section at link time
3584 *
3585 * Section Protection:
3586 * 'r' - section is readable
3587 * 'w' - section is writeable
3588 * 'x' - section is executable
3589 * 's' - section is sharable
3590 *
3591 * Section Alignment:
3592 * '0' - align to byte boundary
3593 * '1' - align to halfword undary
3594 * '2' - align to word boundary
3595 * '3' - align to doubleword boundary
3596 * '4' - align to quadword boundary
3597 * '5' - align to 32 byte boundary
3598 * '6' - align to 64 byte boundary
3599 *
3600 */
3601
3602 void
3603 ppc_pe_section (ignore)
3604 int ignore;
3605 {
3606 /* Strip out the section name */
3607 char *section_name;
3608 char c;
3609 char *name;
3610 unsigned int exp;
3611 flagword flags;
3612 segT sec;
3613 int align;
3614
3615 section_name = input_line_pointer;
3616 c = get_symbol_end ();
3617
3618 name = xmalloc (input_line_pointer - section_name + 1);
3619 strcpy (name, section_name);
3620
3621 *input_line_pointer = c;
3622
3623 SKIP_WHITESPACE ();
3624
3625 exp = 0;
3626 flags = SEC_NO_FLAGS;
3627
3628 if (strcmp (name, ".idata$2") == 0)
3629 {
3630 align = 0;
3631 }
3632 else if (strcmp (name, ".idata$3") == 0)
3633 {
3634 align = 0;
3635 }
3636 else if (strcmp (name, ".idata$4") == 0)
3637 {
3638 align = 2;
3639 }
3640 else if (strcmp (name, ".idata$5") == 0)
3641 {
3642 align = 2;
3643 }
3644 else if (strcmp (name, ".idata$6") == 0)
3645 {
3646 align = 1;
3647 }
3648 else
3649 align = 4; /* default alignment to 16 byte boundary */
3650
3651 if (*input_line_pointer == ',')
3652 {
3653 ++input_line_pointer;
3654 SKIP_WHITESPACE ();
3655 if (*input_line_pointer != '"')
3656 exp = get_absolute_expression ();
3657 else
3658 {
3659 ++input_line_pointer;
3660 while (*input_line_pointer != '"'
3661 && ! is_end_of_line[(unsigned char) *input_line_pointer])
3662 {
3663 switch (*input_line_pointer)
3664 {
3665 /* Section Contents */
3666 case 'a': /* unknown */
3667 as_bad ("Unsupported section attribute -- 'a'");
3668 break;
3669 case 'c': /* code section */
3670 flags |= SEC_CODE;
3671 break;
3672 case 'd': /* section has initialized data */
3673 flags |= SEC_DATA;
3674 break;
3675 case 'u': /* section has uninitialized data */
3676 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
3677 in winnt.h */
3678 flags |= SEC_ROM;
3679 break;
3680 case 'i': /* section contains directives (info) */
3681 /* FIXME: This is IMAGE_SCN_LNK_INFO
3682 in winnt.h */
3683 flags |= SEC_HAS_CONTENTS;
3684 break;
3685 case 'n': /* section can be discarded */
3686 flags &=~ SEC_LOAD;
3687 break;
3688 case 'R': /* Remove section at link time */
3689 flags |= SEC_NEVER_LOAD;
3690 break;
3691
3692 /* Section Protection */
3693 case 'r': /* section is readable */
3694 flags |= IMAGE_SCN_MEM_READ;
3695 break;
3696 case 'w': /* section is writeable */
3697 flags |= IMAGE_SCN_MEM_WRITE;
3698 break;
3699 case 'x': /* section is executable */
3700 flags |= IMAGE_SCN_MEM_EXECUTE;
3701 break;
3702 case 's': /* section is sharable */
3703 flags |= IMAGE_SCN_MEM_SHARED;
3704 break;
3705
3706 /* Section Alignment */
3707 case '0': /* align to byte boundary */
3708 flags |= IMAGE_SCN_ALIGN_1BYTES;
3709 align = 0;
3710 break;
3711 case '1': /* align to halfword boundary */
3712 flags |= IMAGE_SCN_ALIGN_2BYTES;
3713 align = 1;
3714 break;
3715 case '2': /* align to word boundary */
3716 flags |= IMAGE_SCN_ALIGN_4BYTES;
3717 align = 2;
3718 break;
3719 case '3': /* align to doubleword boundary */
3720 flags |= IMAGE_SCN_ALIGN_8BYTES;
3721 align = 3;
3722 break;
3723 case '4': /* align to quadword boundary */
3724 flags |= IMAGE_SCN_ALIGN_16BYTES;
3725 align = 4;
3726 break;
3727 case '5': /* align to 32 byte boundary */
3728 flags |= IMAGE_SCN_ALIGN_32BYTES;
3729 align = 5;
3730 break;
3731 case '6': /* align to 64 byte boundary */
3732 flags |= IMAGE_SCN_ALIGN_64BYTES;
3733 align = 6;
3734 break;
3735
3736 default:
3737 as_bad("unknown section attribute '%c'",
3738 *input_line_pointer);
3739 break;
3740 }
3741 ++input_line_pointer;
3742 }
3743 if (*input_line_pointer == '"')
3744 ++input_line_pointer;
3745 }
3746 }
3747
3748 sec = subseg_new (name, (subsegT) exp);
3749
3750 ppc_set_current_section(sec);
3751
3752 if (flags != SEC_NO_FLAGS)
3753 {
3754 if (! bfd_set_section_flags (stdoutput, sec, flags))
3755 as_bad ("error setting flags for \"%s\": %s",
3756 bfd_section_name (stdoutput, sec),
3757 bfd_errmsg (bfd_get_error ()));
3758 }
3759
3760 bfd_set_section_alignment(stdoutput, sec, align);
3761
3762 }
3763
3764 static void
3765 ppc_pe_function (ignore)
3766 int ignore;
3767 {
3768 char *name;
3769 char endc;
3770 symbolS *ext_sym;
3771
3772 name = input_line_pointer;
3773 endc = get_symbol_end ();
3774
3775 ext_sym = symbol_find_or_make (name);
3776
3777 *input_line_pointer = endc;
3778
3779 S_SET_DATA_TYPE (ext_sym, DT_FCN << N_BTSHFT);
3780 SF_SET_FUNCTION (ext_sym);
3781 SF_SET_PROCESS (ext_sym);
3782 coff_add_linesym (ext_sym);
3783
3784 demand_empty_rest_of_line ();
3785 }
3786
3787 static void
3788 ppc_pe_tocd (ignore)
3789 int ignore;
3790 {
3791 if (tocdata_section == 0)
3792 {
3793 tocdata_section = subseg_new (".tocd", 0);
3794 /* FIXME: section flags won't work */
3795 bfd_set_section_flags (stdoutput, tocdata_section,
3796 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
3797 | SEC_READONLY | SEC_DATA ));
3798
3799 bfd_set_section_alignment (stdoutput, tocdata_section, 2);
3800 }
3801 else
3802 {
3803 rdata_section = subseg_new (".tocd", 0);
3804 }
3805
3806 ppc_set_current_section(tocdata_section);
3807
3808 demand_empty_rest_of_line ();
3809 }
3810
3811 /* Don't adjust TOC relocs to use the section symbol. */
3812
3813 int
3814 ppc_pe_fix_adjustable (fix)
3815 fixS *fix;
3816 {
3817 return fix->fx_r_type != BFD_RELOC_PPC_TOC16;
3818 }
3819
3820 #endif
3821 \f
3822 #ifdef OBJ_XCOFF
3823
3824 /* XCOFF specific symbol and file handling. */
3825
3826 /* Canonicalize the symbol name. We use the to force the suffix, if
3827 any, to use square brackets, and to be in upper case. */
3828
3829 char *
3830 ppc_canonicalize_symbol_name (name)
3831 char *name;
3832 {
3833 char *s;
3834
3835 if (ppc_stab_symbol)
3836 return name;
3837
3838 for (s = name; *s != '\0' && *s != '{' && *s != '['; s++)
3839 ;
3840 if (*s != '\0')
3841 {
3842 char brac;
3843
3844 if (*s == '[')
3845 brac = ']';
3846 else
3847 {
3848 *s = '[';
3849 brac = '}';
3850 }
3851
3852 for (s++; *s != '\0' && *s != brac; s++)
3853 if (islower (*s))
3854 *s = toupper (*s);
3855
3856 if (*s == '\0' || s[1] != '\0')
3857 as_bad ("bad symbol suffix");
3858
3859 *s = ']';
3860 }
3861
3862 return name;
3863 }
3864
3865 /* Set the class of a symbol based on the suffix, if any. This is
3866 called whenever a new symbol is created. */
3867
3868 void
3869 ppc_symbol_new_hook (sym)
3870 symbolS *sym;
3871 {
3872 const char *s;
3873
3874 sym->sy_tc.next = NULL;
3875 sym->sy_tc.output = 0;
3876 sym->sy_tc.class = -1;
3877 sym->sy_tc.real_name = NULL;
3878 sym->sy_tc.subseg = 0;
3879 sym->sy_tc.align = 0;
3880 sym->sy_tc.size = NULL;
3881 sym->sy_tc.within = NULL;
3882
3883 if (ppc_stab_symbol)
3884 return;
3885
3886 s = strchr (S_GET_NAME (sym), '[');
3887 if (s == (const char *) NULL)
3888 {
3889 /* There is no suffix. */
3890 return;
3891 }
3892
3893 ++s;
3894
3895 switch (s[0])
3896 {
3897 case 'B':
3898 if (strcmp (s, "BS]") == 0)
3899 sym->sy_tc.class = XMC_BS;
3900 break;
3901 case 'D':
3902 if (strcmp (s, "DB]") == 0)
3903 sym->sy_tc.class = XMC_DB;
3904 else if (strcmp (s, "DS]") == 0)
3905 sym->sy_tc.class = XMC_DS;
3906 break;
3907 case 'G':
3908 if (strcmp (s, "GL]") == 0)
3909 sym->sy_tc.class = XMC_GL;
3910 break;
3911 case 'P':
3912 if (strcmp (s, "PR]") == 0)
3913 sym->sy_tc.class = XMC_PR;
3914 break;
3915 case 'R':
3916 if (strcmp (s, "RO]") == 0)
3917 sym->sy_tc.class = XMC_RO;
3918 else if (strcmp (s, "RW]") == 0)
3919 sym->sy_tc.class = XMC_RW;
3920 break;
3921 case 'S':
3922 if (strcmp (s, "SV]") == 0)
3923 sym->sy_tc.class = XMC_SV;
3924 break;
3925 case 'T':
3926 if (strcmp (s, "TC]") == 0)
3927 sym->sy_tc.class = XMC_TC;
3928 else if (strcmp (s, "TI]") == 0)
3929 sym->sy_tc.class = XMC_TI;
3930 else if (strcmp (s, "TB]") == 0)
3931 sym->sy_tc.class = XMC_TB;
3932 else if (strcmp (s, "TC0]") == 0 || strcmp (s, "T0]") == 0)
3933 sym->sy_tc.class = XMC_TC0;
3934 break;
3935 case 'U':
3936 if (strcmp (s, "UA]") == 0)
3937 sym->sy_tc.class = XMC_UA;
3938 else if (strcmp (s, "UC]") == 0)
3939 sym->sy_tc.class = XMC_UC;
3940 break;
3941 case 'X':
3942 if (strcmp (s, "XO]") == 0)
3943 sym->sy_tc.class = XMC_XO;
3944 break;
3945 }
3946
3947 if (sym->sy_tc.class == -1)
3948 as_bad ("Unrecognized symbol suffix");
3949 }
3950
3951 /* Set the class of a label based on where it is defined. This
3952 handles symbols without suffixes. Also, move the symbol so that it
3953 follows the csect symbol. */
3954
3955 void
3956 ppc_frob_label (sym)
3957 symbolS *sym;
3958 {
3959 if (ppc_current_csect != (symbolS *) NULL)
3960 {
3961 if (sym->sy_tc.class == -1)
3962 sym->sy_tc.class = ppc_current_csect->sy_tc.class;
3963
3964 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
3965 symbol_append (sym, ppc_current_csect->sy_tc.within, &symbol_rootP,
3966 &symbol_lastP);
3967 ppc_current_csect->sy_tc.within = sym;
3968 }
3969 }
3970
3971 /* This variable is set by ppc_frob_symbol if any absolute symbols are
3972 seen. It tells ppc_adjust_symtab whether it needs to look through
3973 the symbols. */
3974
3975 static boolean ppc_saw_abs;
3976
3977 /* Change the name of a symbol just before writing it out. Set the
3978 real name if the .rename pseudo-op was used. Otherwise, remove any
3979 class suffix. Return 1 if the symbol should not be included in the
3980 symbol table. */
3981
3982 int
3983 ppc_frob_symbol (sym)
3984 symbolS *sym;
3985 {
3986 static symbolS *ppc_last_function;
3987 static symbolS *set_end;
3988
3989 /* Discard symbols that should not be included in the output symbol
3990 table. */
3991 if (! sym->sy_used_in_reloc
3992 && ((sym->bsym->flags & BSF_SECTION_SYM) != 0
3993 || (! S_IS_EXTERNAL (sym)
3994 && ! sym->sy_tc.output
3995 && S_GET_STORAGE_CLASS (sym) != C_FILE)))
3996 return 1;
3997
3998 if (sym->sy_tc.real_name != (char *) NULL)
3999 S_SET_NAME (sym, sym->sy_tc.real_name);
4000 else
4001 {
4002 const char *name;
4003 const char *s;
4004
4005 name = S_GET_NAME (sym);
4006 s = strchr (name, '[');
4007 if (s != (char *) NULL)
4008 {
4009 unsigned int len;
4010 char *snew;
4011
4012 len = s - name;
4013 snew = xmalloc (len + 1);
4014 memcpy (snew, name, len);
4015 snew[len] = '\0';
4016
4017 S_SET_NAME (sym, snew);
4018 }
4019 }
4020
4021 if (set_end != (symbolS *) NULL)
4022 {
4023 SA_SET_SYM_ENDNDX (set_end, sym);
4024 set_end = NULL;
4025 }
4026
4027 if (SF_GET_FUNCTION (sym))
4028 {
4029 if (ppc_last_function != (symbolS *) NULL)
4030 as_bad ("two .function pseudo-ops with no intervening .ef");
4031 ppc_last_function = sym;
4032 if (sym->sy_tc.size != (symbolS *) NULL)
4033 {
4034 resolve_symbol_value (sym->sy_tc.size, 1);
4035 SA_SET_SYM_FSIZE (sym, (long) S_GET_VALUE (sym->sy_tc.size));
4036 }
4037 }
4038 else if (S_GET_STORAGE_CLASS (sym) == C_FCN
4039 && strcmp (S_GET_NAME (sym), ".ef") == 0)
4040 {
4041 if (ppc_last_function == (symbolS *) NULL)
4042 as_bad (".ef with no preceding .function");
4043 else
4044 {
4045 set_end = ppc_last_function;
4046 ppc_last_function = NULL;
4047
4048 /* We don't have a C_EFCN symbol, but we need to force the
4049 COFF backend to believe that it has seen one. */
4050 coff_last_function = NULL;
4051 }
4052 }
4053
4054 if (! S_IS_EXTERNAL (sym)
4055 && (sym->bsym->flags & BSF_SECTION_SYM) == 0
4056 && S_GET_STORAGE_CLASS (sym) != C_FILE
4057 && S_GET_STORAGE_CLASS (sym) != C_FCN
4058 && S_GET_STORAGE_CLASS (sym) != C_BLOCK
4059 && S_GET_STORAGE_CLASS (sym) != C_BSTAT
4060 && S_GET_STORAGE_CLASS (sym) != C_ESTAT
4061 && S_GET_STORAGE_CLASS (sym) != C_BINCL
4062 && S_GET_STORAGE_CLASS (sym) != C_EINCL
4063 && S_GET_SEGMENT (sym) != ppc_coff_debug_section)
4064 S_SET_STORAGE_CLASS (sym, C_HIDEXT);
4065
4066 if (S_GET_STORAGE_CLASS (sym) == C_EXT
4067 || S_GET_STORAGE_CLASS (sym) == C_HIDEXT)
4068 {
4069 int i;
4070 union internal_auxent *a;
4071
4072 /* Create a csect aux. */
4073 i = S_GET_NUMBER_AUXILIARY (sym);
4074 S_SET_NUMBER_AUXILIARY (sym, i + 1);
4075 a = &coffsymbol (sym->bsym)->native[i + 1].u.auxent;
4076 if (sym->sy_tc.class == XMC_TC0)
4077 {
4078 /* This is the TOC table. */
4079 know (strcmp (S_GET_NAME (sym), "TOC") == 0);
4080 a->x_csect.x_scnlen.l = 0;
4081 a->x_csect.x_smtyp = (2 << 3) | XTY_SD;
4082 }
4083 else if (sym->sy_tc.subseg != 0)
4084 {
4085 /* This is a csect symbol. x_scnlen is the size of the
4086 csect. */
4087 if (sym->sy_tc.next == (symbolS *) NULL)
4088 a->x_csect.x_scnlen.l = (bfd_section_size (stdoutput,
4089 S_GET_SEGMENT (sym))
4090 - S_GET_VALUE (sym));
4091 else
4092 {
4093 resolve_symbol_value (sym->sy_tc.next, 1);
4094 a->x_csect.x_scnlen.l = (S_GET_VALUE (sym->sy_tc.next)
4095 - S_GET_VALUE (sym));
4096 }
4097 a->x_csect.x_smtyp = (sym->sy_tc.align << 3) | XTY_SD;
4098 }
4099 else if (S_GET_SEGMENT (sym) == bss_section)
4100 {
4101 /* This is a common symbol. */
4102 a->x_csect.x_scnlen.l = sym->sy_frag->fr_offset;
4103 a->x_csect.x_smtyp = (sym->sy_tc.align << 3) | XTY_CM;
4104 if (S_IS_EXTERNAL (sym))
4105 sym->sy_tc.class = XMC_RW;
4106 else
4107 sym->sy_tc.class = XMC_BS;
4108 }
4109 else if (S_GET_SEGMENT (sym) == absolute_section)
4110 {
4111 /* This is an absolute symbol. The csect will be created by
4112 ppc_adjust_symtab. */
4113 ppc_saw_abs = true;
4114 a->x_csect.x_smtyp = XTY_LD;
4115 if (sym->sy_tc.class == -1)
4116 sym->sy_tc.class = XMC_XO;
4117 }
4118 else if (! S_IS_DEFINED (sym))
4119 {
4120 /* This is an external symbol. */
4121 a->x_csect.x_scnlen.l = 0;
4122 a->x_csect.x_smtyp = XTY_ER;
4123 }
4124 else if (sym->sy_tc.class == XMC_TC)
4125 {
4126 symbolS *next;
4127
4128 /* This is a TOC definition. x_scnlen is the size of the
4129 TOC entry. */
4130 next = symbol_next (sym);
4131 while (next->sy_tc.class == XMC_TC0)
4132 next = symbol_next (next);
4133 if (next == (symbolS *) NULL
4134 || next->sy_tc.class != XMC_TC)
4135 {
4136 if (ppc_after_toc_frag == (fragS *) NULL)
4137 a->x_csect.x_scnlen.l = (bfd_section_size (stdoutput,
4138 data_section)
4139 - S_GET_VALUE (sym));
4140 else
4141 a->x_csect.x_scnlen.l = (ppc_after_toc_frag->fr_address
4142 - S_GET_VALUE (sym));
4143 }
4144 else
4145 {
4146 resolve_symbol_value (next, 1);
4147 a->x_csect.x_scnlen.l = (S_GET_VALUE (next)
4148 - S_GET_VALUE (sym));
4149 }
4150 a->x_csect.x_smtyp = (2 << 3) | XTY_SD;
4151 }
4152 else
4153 {
4154 symbolS *csect;
4155
4156 /* This is a normal symbol definition. x_scnlen is the
4157 symbol index of the containing csect. */
4158 if (S_GET_SEGMENT (sym) == text_section)
4159 csect = ppc_text_csects;
4160 else if (S_GET_SEGMENT (sym) == data_section)
4161 csect = ppc_data_csects;
4162 else
4163 abort ();
4164
4165 /* Skip the initial dummy symbol. */
4166 csect = csect->sy_tc.next;
4167
4168 if (csect == (symbolS *) NULL)
4169 {
4170 as_warn ("warning: symbol %s has no csect", S_GET_NAME (sym));
4171 a->x_csect.x_scnlen.l = 0;
4172 }
4173 else
4174 {
4175 while (csect->sy_tc.next != (symbolS *) NULL)
4176 {
4177 resolve_symbol_value (csect->sy_tc.next, 1);
4178 if (S_GET_VALUE (csect->sy_tc.next) > S_GET_VALUE (sym))
4179 break;
4180 csect = csect->sy_tc.next;
4181 }
4182
4183 a->x_csect.x_scnlen.p = coffsymbol (csect->bsym)->native;
4184 coffsymbol (sym->bsym)->native[i + 1].fix_scnlen = 1;
4185 }
4186 a->x_csect.x_smtyp = XTY_LD;
4187 }
4188
4189 a->x_csect.x_parmhash = 0;
4190 a->x_csect.x_snhash = 0;
4191 if (sym->sy_tc.class == -1)
4192 a->x_csect.x_smclas = XMC_PR;
4193 else
4194 a->x_csect.x_smclas = sym->sy_tc.class;
4195 a->x_csect.x_stab = 0;
4196 a->x_csect.x_snstab = 0;
4197
4198 /* Don't let the COFF backend resort these symbols. */
4199 sym->bsym->flags |= BSF_NOT_AT_END;
4200 }
4201 else if (S_GET_STORAGE_CLASS (sym) == C_BSTAT)
4202 {
4203 /* We want the value to be the symbol index of the referenced
4204 csect symbol. BFD will do that for us if we set the right
4205 flags. */
4206 S_SET_VALUE (sym,
4207 (valueT) coffsymbol (sym->sy_tc.within->bsym)->native);
4208 coffsymbol (sym->bsym)->native->fix_value = 1;
4209 }
4210 else if (S_GET_STORAGE_CLASS (sym) == C_STSYM)
4211 {
4212 symbolS *block;
4213 symbolS *csect;
4214
4215 /* The value is the offset from the enclosing csect. */
4216 block = sym->sy_tc.within;
4217 csect = block->sy_tc.within;
4218 resolve_symbol_value (csect, 1);
4219 S_SET_VALUE (sym, S_GET_VALUE (sym) - S_GET_VALUE (csect));
4220 }
4221 else if (S_GET_STORAGE_CLASS (sym) == C_BINCL
4222 || S_GET_STORAGE_CLASS (sym) == C_EINCL)
4223 {
4224 /* We want the value to be a file offset into the line numbers.
4225 BFD will do that for us if we set the right flags. We have
4226 already set the value correctly. */
4227 coffsymbol (sym->bsym)->native->fix_line = 1;
4228 }
4229
4230 return 0;
4231 }
4232
4233 /* Adjust the symbol table. This creates csect symbols for all
4234 absolute symbols. */
4235
4236 void
4237 ppc_adjust_symtab ()
4238 {
4239 symbolS *sym;
4240
4241 if (! ppc_saw_abs)
4242 return;
4243
4244 for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
4245 {
4246 symbolS *csect;
4247 int i;
4248 union internal_auxent *a;
4249
4250 if (S_GET_SEGMENT (sym) != absolute_section)
4251 continue;
4252
4253 csect = symbol_create (".abs[XO]", absolute_section,
4254 S_GET_VALUE (sym), &zero_address_frag);
4255 csect->bsym->value = S_GET_VALUE (sym);
4256 S_SET_STORAGE_CLASS (csect, C_HIDEXT);
4257 i = S_GET_NUMBER_AUXILIARY (csect);
4258 S_SET_NUMBER_AUXILIARY (csect, i + 1);
4259 a = &coffsymbol (csect->bsym)->native[i + 1].u.auxent;
4260 a->x_csect.x_scnlen.l = 0;
4261 a->x_csect.x_smtyp = XTY_SD;
4262 a->x_csect.x_parmhash = 0;
4263 a->x_csect.x_snhash = 0;
4264 a->x_csect.x_smclas = XMC_XO;
4265 a->x_csect.x_stab = 0;
4266 a->x_csect.x_snstab = 0;
4267
4268 symbol_insert (csect, sym, &symbol_rootP, &symbol_lastP);
4269
4270 i = S_GET_NUMBER_AUXILIARY (sym);
4271 a = &coffsymbol (sym->bsym)->native[i].u.auxent;
4272 a->x_csect.x_scnlen.p = coffsymbol (csect->bsym)->native;
4273 coffsymbol (sym->bsym)->native[i].fix_scnlen = 1;
4274 }
4275
4276 ppc_saw_abs = false;
4277 }
4278
4279 /* Set the VMA for a section. This is called on all the sections in
4280 turn. */
4281
4282 void
4283 ppc_frob_section (sec)
4284 asection *sec;
4285 {
4286 static bfd_size_type vma = 0;
4287
4288 bfd_set_section_vma (stdoutput, sec, vma);
4289 vma += bfd_section_size (stdoutput, sec);
4290 }
4291
4292 #endif /* OBJ_XCOFF */
4293 \f
4294 /* Turn a string in input_line_pointer into a floating point constant
4295 of type type, and store the appropriate bytes in *litp. The number
4296 of LITTLENUMS emitted is stored in *sizep . An error message is
4297 returned, or NULL on OK. */
4298
4299 char *
4300 md_atof (type, litp, sizep)
4301 int type;
4302 char *litp;
4303 int *sizep;
4304 {
4305 int prec;
4306 LITTLENUM_TYPE words[4];
4307 char *t;
4308 int i;
4309
4310 switch (type)
4311 {
4312 case 'f':
4313 prec = 2;
4314 break;
4315
4316 case 'd':
4317 prec = 4;
4318 break;
4319
4320 default:
4321 *sizep = 0;
4322 return "bad call to md_atof";
4323 }
4324
4325 t = atof_ieee (input_line_pointer, type, words);
4326 if (t)
4327 input_line_pointer = t;
4328
4329 *sizep = prec * 2;
4330
4331 if (target_big_endian)
4332 {
4333 for (i = 0; i < prec; i++)
4334 {
4335 md_number_to_chars (litp, (valueT) words[i], 2);
4336 litp += 2;
4337 }
4338 }
4339 else
4340 {
4341 for (i = prec - 1; i >= 0; i--)
4342 {
4343 md_number_to_chars (litp, (valueT) words[i], 2);
4344 litp += 2;
4345 }
4346 }
4347
4348 return NULL;
4349 }
4350
4351 /* Write a value out to the object file, using the appropriate
4352 endianness. */
4353
4354 void
4355 md_number_to_chars (buf, val, n)
4356 char *buf;
4357 valueT val;
4358 int n;
4359 {
4360 if (target_big_endian)
4361 number_to_chars_bigendian (buf, val, n);
4362 else
4363 number_to_chars_littleendian (buf, val, n);
4364 }
4365
4366 /* Align a section (I don't know why this is machine dependent). */
4367
4368 valueT
4369 md_section_align (seg, addr)
4370 asection *seg;
4371 valueT addr;
4372 {
4373 int align = bfd_get_section_alignment (stdoutput, seg);
4374
4375 return ((addr + (1 << align) - 1) & (-1 << align));
4376 }
4377
4378 /* We don't have any form of relaxing. */
4379
4380 int
4381 md_estimate_size_before_relax (fragp, seg)
4382 fragS *fragp;
4383 asection *seg;
4384 {
4385 abort ();
4386 return 0;
4387 }
4388
4389 /* Convert a machine dependent frag. We never generate these. */
4390
4391 void
4392 md_convert_frag (abfd, sec, fragp)
4393 bfd *abfd;
4394 asection *sec;
4395 fragS *fragp;
4396 {
4397 abort ();
4398 }
4399
4400 /* We have no need to default values of symbols. */
4401
4402 /*ARGSUSED*/
4403 symbolS *
4404 md_undefined_symbol (name)
4405 char *name;
4406 {
4407 return 0;
4408 }
4409 \f
4410 /* Functions concerning relocs. */
4411
4412 /* The location from which a PC relative jump should be calculated,
4413 given a PC relative reloc. */
4414
4415 long
4416 md_pcrel_from_section (fixp, sec)
4417 fixS *fixp;
4418 segT sec;
4419 {
4420 return fixp->fx_frag->fr_address + fixp->fx_where;
4421 }
4422
4423 #ifdef OBJ_XCOFF
4424
4425 /* This is called to see whether a fixup should be adjusted to use a
4426 section symbol. We take the opportunity to change a fixup against
4427 a symbol in the TOC subsegment into a reloc against the
4428 corresponding .tc symbol. */
4429
4430 int
4431 ppc_fix_adjustable (fix)
4432 fixS *fix;
4433 {
4434 valueT val;
4435
4436 resolve_symbol_value (fix->fx_addsy, 1);
4437 val = S_GET_VALUE (fix->fx_addsy);
4438 if (ppc_toc_csect != (symbolS *) NULL
4439 && fix->fx_addsy != (symbolS *) NULL
4440 && fix->fx_addsy != ppc_toc_csect
4441 && S_GET_SEGMENT (fix->fx_addsy) == data_section
4442 && val >= ppc_toc_frag->fr_address
4443 && (ppc_after_toc_frag == (fragS *) NULL
4444 || val < ppc_after_toc_frag->fr_address))
4445 {
4446 symbolS *sy;
4447
4448 for (sy = symbol_next (ppc_toc_csect);
4449 sy != (symbolS *) NULL;
4450 sy = symbol_next (sy))
4451 {
4452 if (sy->sy_tc.class == XMC_TC0)
4453 continue;
4454 if (sy->sy_tc.class != XMC_TC)
4455 break;
4456 resolve_symbol_value (sy, 1);
4457 if (val == S_GET_VALUE (sy))
4458 {
4459 fix->fx_addsy = sy;
4460 fix->fx_addnumber = val - ppc_toc_frag->fr_address;
4461 return 0;
4462 }
4463 }
4464
4465 as_bad_where (fix->fx_file, fix->fx_line,
4466 "symbol in .toc does not match any .tc");
4467 }
4468
4469 /* Possibly adjust the reloc to be against the csect. */
4470 if (fix->fx_addsy != (symbolS *) NULL
4471 && fix->fx_addsy->sy_tc.subseg == 0
4472 && fix->fx_addsy->sy_tc.class != XMC_TC0
4473 && fix->fx_addsy->sy_tc.class != XMC_TC
4474 && S_GET_SEGMENT (fix->fx_addsy) != bss_section
4475 /* Don't adjust if this is a reloc in the toc section. */
4476 && (S_GET_SEGMENT (fix->fx_addsy) != data_section
4477 || ppc_toc_csect == NULL
4478 || fix->fx_frag->fr_address < ppc_toc_frag->fr_address
4479 || (ppc_after_toc_frag != NULL
4480 && fix->fx_frag->fr_address >= ppc_after_toc_frag->fr_address)))
4481 {
4482 symbolS *csect;
4483
4484 if (S_GET_SEGMENT (fix->fx_addsy) == text_section)
4485 csect = ppc_text_csects;
4486 else if (S_GET_SEGMENT (fix->fx_addsy) == data_section)
4487 csect = ppc_data_csects;
4488 else
4489 abort ();
4490
4491 /* Skip the initial dummy symbol. */
4492 csect = csect->sy_tc.next;
4493
4494 if (csect != (symbolS *) NULL)
4495 {
4496 while (csect->sy_tc.next != (symbolS *) NULL
4497 && (csect->sy_tc.next->sy_frag->fr_address
4498 <= fix->fx_addsy->sy_frag->fr_address))
4499 {
4500 /* If the csect address equals the symbol value, then we
4501 have to look through the full symbol table to see
4502 whether this is the csect we want. Note that we will
4503 only get here if the csect has zero length. */
4504 if ((csect->sy_frag->fr_address
4505 == fix->fx_addsy->sy_frag->fr_address)
4506 && S_GET_VALUE (csect) == S_GET_VALUE (fix->fx_addsy))
4507 {
4508 symbolS *scan;
4509
4510 for (scan = csect->sy_next;
4511 scan != NULL;
4512 scan = scan->sy_next)
4513 {
4514 if (scan->sy_tc.subseg != 0)
4515 break;
4516 if (scan == fix->fx_addsy)
4517 break;
4518 }
4519
4520 /* If we found the symbol before the next csect
4521 symbol, then this is the csect we want. */
4522 if (scan == fix->fx_addsy)
4523 break;
4524 }
4525
4526 csect = csect->sy_tc.next;
4527 }
4528
4529 fix->fx_offset += (S_GET_VALUE (fix->fx_addsy)
4530 - csect->sy_frag->fr_address);
4531 fix->fx_addsy = csect;
4532 }
4533 }
4534
4535 /* Adjust a reloc against a .lcomm symbol to be against the base
4536 .lcomm. */
4537 if (fix->fx_addsy != (symbolS *) NULL
4538 && S_GET_SEGMENT (fix->fx_addsy) == bss_section
4539 && ! S_IS_EXTERNAL (fix->fx_addsy))
4540 {
4541 resolve_symbol_value (fix->fx_addsy->sy_frag->fr_symbol, 1);
4542 fix->fx_offset += (S_GET_VALUE (fix->fx_addsy)
4543 - S_GET_VALUE (fix->fx_addsy->sy_frag->fr_symbol));
4544 fix->fx_addsy = fix->fx_addsy->sy_frag->fr_symbol;
4545 }
4546
4547 return 0;
4548 }
4549
4550 /* A reloc from one csect to another must be kept. The assembler
4551 will, of course, keep relocs between sections, and it will keep
4552 absolute relocs, but we need to force it to keep PC relative relocs
4553 between two csects in the same section. */
4554
4555 int
4556 ppc_force_relocation (fix)
4557 fixS *fix;
4558 {
4559 /* At this point fix->fx_addsy should already have been converted to
4560 a csect symbol. If the csect does not include the fragment, then
4561 we need to force the relocation. */
4562 if (fix->fx_pcrel
4563 && fix->fx_addsy != NULL
4564 && fix->fx_addsy->sy_tc.subseg != 0
4565 && (fix->fx_addsy->sy_frag->fr_address > fix->fx_frag->fr_address
4566 || (fix->fx_addsy->sy_tc.next != NULL
4567 && (fix->fx_addsy->sy_tc.next->sy_frag->fr_address
4568 <= fix->fx_frag->fr_address))))
4569 return 1;
4570
4571 return 0;
4572 }
4573
4574 #endif /* OBJ_XCOFF */
4575
4576 /* See whether a symbol is in the TOC section. */
4577
4578 static int
4579 ppc_is_toc_sym (sym)
4580 symbolS *sym;
4581 {
4582 #ifdef OBJ_XCOFF
4583 return sym->sy_tc.class == XMC_TC;
4584 #else
4585 return strcmp (segment_name (S_GET_SEGMENT (sym)), ".got") == 0;
4586 #endif
4587 }
4588
4589 /* Apply a fixup to the object code. This is called for all the
4590 fixups we generated by the call to fix_new_exp, above. In the call
4591 above we used a reloc code which was the largest legal reloc code
4592 plus the operand index. Here we undo that to recover the operand
4593 index. At this point all symbol values should be fully resolved,
4594 and we attempt to completely resolve the reloc. If we can not do
4595 that, we determine the correct reloc code and put it back in the
4596 fixup. */
4597
4598 int
4599 md_apply_fix3 (fixp, valuep, seg)
4600 fixS *fixp;
4601 valueT *valuep;
4602 segT seg;
4603 {
4604 valueT value;
4605
4606 #ifdef OBJ_ELF
4607 value = *valuep;
4608 if (fixp->fx_addsy != NULL)
4609 {
4610 /* `*valuep' may contain the value of the symbol on which the reloc
4611 will be based; we have to remove it. */
4612 if (fixp->fx_addsy->sy_used_in_reloc
4613 && S_GET_SEGMENT (fixp->fx_addsy) != absolute_section
4614 && S_GET_SEGMENT (fixp->fx_addsy) != undefined_section
4615 && ! bfd_is_com_section (S_GET_SEGMENT (fixp->fx_addsy)))
4616 value -= S_GET_VALUE (fixp->fx_addsy);
4617
4618 /* FIXME: Why '+'? Better yet, what exactly is '*valuep'
4619 supposed to be? I think this is related to various similar
4620 FIXMEs in tc-i386.c and tc-sparc.c. */
4621 if (fixp->fx_pcrel)
4622 value += fixp->fx_frag->fr_address + fixp->fx_where;
4623 }
4624 else
4625 {
4626 fixp->fx_done = 1;
4627 }
4628 #else
4629 /* FIXME FIXME FIXME: The value we are passed in *valuep includes
4630 the symbol values. Since we are using BFD_ASSEMBLER, if we are
4631 doing this relocation the code in write.c is going to call
4632 bfd_install_relocation, which is also going to use the symbol
4633 value. That means that if the reloc is fully resolved we want to
4634 use *valuep since bfd_install_relocation is not being used.
4635 However, if the reloc is not fully resolved we do not want to use
4636 *valuep, and must use fx_offset instead. However, if the reloc
4637 is PC relative, we do want to use *valuep since it includes the
4638 result of md_pcrel_from. This is confusing. */
4639 if (fixp->fx_addsy == (symbolS *) NULL)
4640 {
4641 value = *valuep;
4642 fixp->fx_done = 1;
4643 }
4644 else if (fixp->fx_pcrel)
4645 value = *valuep;
4646 else
4647 {
4648 value = fixp->fx_offset;
4649 if (fixp->fx_subsy != (symbolS *) NULL)
4650 {
4651 if (S_GET_SEGMENT (fixp->fx_subsy) == absolute_section)
4652 value -= S_GET_VALUE (fixp->fx_subsy);
4653 else
4654 {
4655 /* We can't actually support subtracting a symbol. */
4656 as_bad_where (fixp->fx_file, fixp->fx_line,
4657 "expression too complex");
4658 }
4659 }
4660 }
4661 #endif
4662
4663 if ((int) fixp->fx_r_type >= (int) BFD_RELOC_UNUSED)
4664 {
4665 int opindex;
4666 const struct powerpc_operand *operand;
4667 char *where;
4668 unsigned long insn;
4669
4670 opindex = (int) fixp->fx_r_type - (int) BFD_RELOC_UNUSED;
4671
4672 operand = &powerpc_operands[opindex];
4673
4674 #ifdef OBJ_XCOFF
4675 /* It appears that an instruction like
4676 l 9,LC..1(30)
4677 when LC..1 is not a TOC symbol does not generate a reloc. It
4678 uses the offset of LC..1 within its csect. However, .long
4679 LC..1 will generate a reloc. I can't find any documentation
4680 on how these cases are to be distinguished, so this is a wild
4681 guess. These cases are generated by gcc -mminimal-toc. */
4682 if ((operand->flags & PPC_OPERAND_PARENS) != 0
4683 && operand->bits == 16
4684 && operand->shift == 0
4685 && operand->insert == NULL
4686 && fixp->fx_addsy != NULL
4687 && fixp->fx_addsy->sy_tc.subseg != 0
4688 && fixp->fx_addsy->sy_tc.class != XMC_TC
4689 && fixp->fx_addsy->sy_tc.class != XMC_TC0
4690 && S_GET_SEGMENT (fixp->fx_addsy) != bss_section)
4691 {
4692 value = fixp->fx_offset;
4693 fixp->fx_done = 1;
4694 }
4695 #endif
4696
4697 /* Fetch the instruction, insert the fully resolved operand
4698 value, and stuff the instruction back again. */
4699 where = fixp->fx_frag->fr_literal + fixp->fx_where;
4700 if (target_big_endian)
4701 insn = bfd_getb32 ((unsigned char *) where);
4702 else
4703 insn = bfd_getl32 ((unsigned char *) where);
4704 insn = ppc_insert_operand (insn, operand, (offsetT) value,
4705 fixp->fx_file, fixp->fx_line);
4706 if (target_big_endian)
4707 bfd_putb32 ((bfd_vma) insn, (unsigned char *) where);
4708 else
4709 bfd_putl32 ((bfd_vma) insn, (unsigned char *) where);
4710
4711 if (fixp->fx_done)
4712 {
4713 /* Nothing else to do here. */
4714 return 1;
4715 }
4716
4717 /* Determine a BFD reloc value based on the operand information.
4718 We are only prepared to turn a few of the operands into
4719 relocs.
4720 FIXME: We need to handle the DS field at the very least.
4721 FIXME: Selecting the reloc type is a bit haphazard; perhaps
4722 there should be a new field in the operand table. */
4723 if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
4724 && operand->bits == 26
4725 && operand->shift == 0)
4726 fixp->fx_r_type = BFD_RELOC_PPC_B26;
4727 else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
4728 && operand->bits == 16
4729 && operand->shift == 0)
4730 fixp->fx_r_type = BFD_RELOC_PPC_B16;
4731 else if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0
4732 && operand->bits == 26
4733 && operand->shift == 0)
4734 fixp->fx_r_type = BFD_RELOC_PPC_BA26;
4735 else if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0
4736 && operand->bits == 16
4737 && operand->shift == 0)
4738 fixp->fx_r_type = BFD_RELOC_PPC_BA16;
4739 else if ((operand->flags & PPC_OPERAND_PARENS) != 0
4740 && operand->bits == 16
4741 && operand->shift == 0
4742 && operand->insert == NULL
4743 && fixp->fx_addsy != NULL
4744 && ppc_is_toc_sym (fixp->fx_addsy))
4745 {
4746 fixp->fx_size = 2;
4747 if (target_big_endian)
4748 fixp->fx_where += 2;
4749 fixp->fx_r_type = BFD_RELOC_PPC_TOC16;
4750 }
4751 else
4752 {
4753 char *sfile;
4754 unsigned int sline;
4755
4756 /* Use expr_symbol_where to see if this is an expression
4757 symbol. */
4758 if (expr_symbol_where (fixp->fx_addsy, &sfile, &sline))
4759 as_bad_where (fixp->fx_file, fixp->fx_line,
4760 "unresolved expression that must be resolved");
4761 else
4762 as_bad_where (fixp->fx_file, fixp->fx_line,
4763 "unsupported relocation type");
4764 fixp->fx_done = 1;
4765 return 1;
4766 }
4767 }
4768 else
4769 {
4770 #ifdef OBJ_ELF
4771 ppc_elf_validate_fix (fixp, seg);
4772 #endif
4773 switch (fixp->fx_r_type)
4774 {
4775 case BFD_RELOC_32:
4776 case BFD_RELOC_CTOR:
4777 if (fixp->fx_pcrel)
4778 fixp->fx_r_type = BFD_RELOC_32_PCREL;
4779 /* fall through */
4780
4781 case BFD_RELOC_RVA:
4782 case BFD_RELOC_32_PCREL:
4783 case BFD_RELOC_32_BASEREL:
4784 case BFD_RELOC_PPC_EMB_NADDR32:
4785 md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where,
4786 value, 4);
4787 break;
4788
4789 case BFD_RELOC_LO16:
4790 case BFD_RELOC_16:
4791 case BFD_RELOC_GPREL16:
4792 case BFD_RELOC_16_GOT_PCREL:
4793 case BFD_RELOC_16_GOTOFF:
4794 case BFD_RELOC_LO16_GOTOFF:
4795 case BFD_RELOC_HI16_GOTOFF:
4796 case BFD_RELOC_HI16_S_GOTOFF:
4797 case BFD_RELOC_LO16_BASEREL:
4798 case BFD_RELOC_HI16_BASEREL:
4799 case BFD_RELOC_HI16_S_BASEREL:
4800 case BFD_RELOC_PPC_EMB_NADDR16:
4801 case BFD_RELOC_PPC_EMB_NADDR16_LO:
4802 case BFD_RELOC_PPC_EMB_NADDR16_HI:
4803 case BFD_RELOC_PPC_EMB_NADDR16_HA:
4804 case BFD_RELOC_PPC_EMB_SDAI16:
4805 case BFD_RELOC_PPC_EMB_SDA2REL:
4806 case BFD_RELOC_PPC_EMB_SDA2I16:
4807 case BFD_RELOC_PPC_EMB_RELSEC16:
4808 case BFD_RELOC_PPC_EMB_RELST_LO:
4809 case BFD_RELOC_PPC_EMB_RELST_HI:
4810 case BFD_RELOC_PPC_EMB_RELST_HA:
4811 case BFD_RELOC_PPC_EMB_RELSDA:
4812 case BFD_RELOC_PPC_TOC16:
4813 if (fixp->fx_pcrel)
4814 as_bad_where (fixp->fx_file, fixp->fx_line,
4815 "cannot emit PC relative %s relocation%s%s",
4816 bfd_get_reloc_code_name (fixp->fx_r_type),
4817 fixp->fx_addsy != NULL ? " against " : "",
4818 (fixp->fx_addsy != NULL
4819 ? S_GET_NAME (fixp->fx_addsy)
4820 : ""));
4821
4822 md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where,
4823 value, 2);
4824 break;
4825
4826 /* This case happens when you write, for example,
4827 lis %r3,(L1-L2)@ha
4828 where L1 and L2 are defined later. */
4829 case BFD_RELOC_HI16:
4830 if (fixp->fx_pcrel)
4831 abort ();
4832 md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where,
4833 value >> 16, 2);
4834 break;
4835 case BFD_RELOC_HI16_S:
4836 if (fixp->fx_pcrel)
4837 abort ();
4838 md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where,
4839 value + 0x8000 >> 16, 2);
4840 break;
4841
4842 /* Because SDA21 modifies the register field, the size is set to 4
4843 bytes, rather than 2, so offset it here appropriately */
4844 case BFD_RELOC_PPC_EMB_SDA21:
4845 if (fixp->fx_pcrel)
4846 abort ();
4847
4848 md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where
4849 + ((target_big_endian) ? 2 : 0),
4850 value, 2);
4851 break;
4852
4853 case BFD_RELOC_8:
4854 if (fixp->fx_pcrel)
4855 abort ();
4856
4857 md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where,
4858 value, 1);
4859 break;
4860
4861 case BFD_RELOC_24_PLT_PCREL:
4862 case BFD_RELOC_PPC_LOCAL24PC:
4863 if (!fixp->fx_pcrel && !fixp->fx_done)
4864 abort ();
4865
4866 if (fixp->fx_done)
4867 {
4868 char *where;
4869 unsigned long insn;
4870
4871 /* Fetch the instruction, insert the fully resolved operand
4872 value, and stuff the instruction back again. */
4873 where = fixp->fx_frag->fr_literal + fixp->fx_where;
4874 if (target_big_endian)
4875 insn = bfd_getb32 ((unsigned char *) where);
4876 else
4877 insn = bfd_getl32 ((unsigned char *) where);
4878 if ((value & 3) != 0)
4879 as_bad_where (fixp->fx_file, fixp->fx_line,
4880 "must branch to an address a multiple of 4");
4881 if ((offsetT) value < -0x40000000
4882 || (offsetT) value >= 0x40000000)
4883 as_bad_where (fixp->fx_file, fixp->fx_line,
4884 "@local or @plt branch destination is too far "
4885 "away, %ld bytes",
4886 value);
4887 insn = insn | (value & 0x03fffffc);
4888 if (target_big_endian)
4889 bfd_putb32 ((bfd_vma) insn, (unsigned char *) where);
4890 else
4891 bfd_putl32 ((bfd_vma) insn, (unsigned char *) where);
4892 }
4893 break;
4894
4895 default:
4896 fprintf(stderr,
4897 "Gas failure, reloc value %d\n", fixp->fx_r_type);
4898 fflush(stderr);
4899 abort ();
4900 }
4901 }
4902
4903 #ifdef OBJ_ELF
4904 fixp->fx_addnumber = value;
4905 #else
4906 if (fixp->fx_r_type != BFD_RELOC_PPC_TOC16)
4907 fixp->fx_addnumber = 0;
4908 else
4909 {
4910 #ifdef TE_PE
4911 fixp->fx_addnumber = 0;
4912 #else
4913 /* We want to use the offset within the data segment of the
4914 symbol, not the actual VMA of the symbol. */
4915 fixp->fx_addnumber =
4916 - bfd_get_section_vma (stdoutput, S_GET_SEGMENT (fixp->fx_addsy));
4917 #endif
4918 }
4919 #endif
4920
4921 return 1;
4922 }
4923
4924 /* Generate a reloc for a fixup. */
4925
4926 arelent *
4927 tc_gen_reloc (seg, fixp)
4928 asection *seg;
4929 fixS *fixp;
4930 {
4931 arelent *reloc;
4932
4933 reloc = (arelent *) xmalloc (sizeof (arelent));
4934
4935 reloc->sym_ptr_ptr = &fixp->fx_addsy->bsym;
4936 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
4937 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
4938 if (reloc->howto == (reloc_howto_type *) NULL)
4939 {
4940 as_bad_where (fixp->fx_file, fixp->fx_line,
4941 "reloc %d not supported by object file format", (int)fixp->fx_r_type);
4942 return NULL;
4943 }
4944 reloc->addend = fixp->fx_addnumber;
4945
4946 return reloc;
4947 }
GDB Binutils - Deliverables
This page took 0.163737 seconds and 5 git commands to generate.