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