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