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