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