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