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