?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
daily update
[binutils.git] / gas / config / tc-sparc.c
blob10a1411b5260f677576f78e3d5729bc8181f7ad3
1 /* tc-sparc.c -- Assemble for the SPARC
2 Copyright 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005
4 Free Software Foundation, Inc.
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
18 License along with GAS; see the file COPYING. If not, write
19 to the Free Software Foundation, 51 Franklin Street - Fifth Floor,
20 Boston, MA 02110-1301, USA. */
21
22 #include <stdio.h>
23
24 #include "as.h"
25 #include "safe-ctype.h"
26 #include "subsegs.h"
27
28 #include "opcode/sparc.h"
29 #include "dw2gencfi.h"
30
31 #ifdef OBJ_ELF
32 #include "elf/sparc.h"
33 #include "dwarf2dbg.h"
34 #endif
35
36 /* Some ancient Sun C compilers would not take such hex constants as
37 unsigned, and would end up sign-extending them to form an offsetT,
38 so use these constants instead. */
39 #define U0xffffffff ((((unsigned long) 1 << 16) << 16) - 1)
40 #define U0x80000000 ((((unsigned long) 1 << 16) << 15))
41
42 static struct sparc_arch *lookup_arch PARAMS ((char *));
43 static void init_default_arch PARAMS ((void));
44 static int sparc_ip PARAMS ((char *, const struct sparc_opcode **));
45 static int in_signed_range PARAMS ((bfd_signed_vma, bfd_signed_vma));
46 static int in_unsigned_range PARAMS ((bfd_vma, bfd_vma));
47 static int in_bitfield_range PARAMS ((bfd_signed_vma, bfd_signed_vma));
48 static int sparc_ffs PARAMS ((unsigned int));
49 static void synthetize_setuw PARAMS ((const struct sparc_opcode *));
50 static void synthetize_setsw PARAMS ((const struct sparc_opcode *));
51 static void synthetize_setx PARAMS ((const struct sparc_opcode *));
52 static bfd_vma BSR PARAMS ((bfd_vma, int));
53 static int cmp_reg_entry PARAMS ((const PTR, const PTR));
54 static int parse_keyword_arg PARAMS ((int (*) (const char *), char **, int *));
55 static int parse_const_expr_arg PARAMS ((char **, int *));
56 static int get_expression PARAMS ((char *str));
57
58 /* Default architecture. */
59 /* ??? The default value should be V8, but sparclite support was added
60 by making it the default. GCC now passes -Asparclite, so maybe sometime in
61 the future we can set this to V8. */
62 #ifndef DEFAULT_ARCH
63 #define DEFAULT_ARCH "sparclite"
64 #endif
65 static char *default_arch = DEFAULT_ARCH;
66
67 /* Non-zero if the initial values of `max_architecture' and `sparc_arch_size'
68 have been set. */
69 static int default_init_p;
70
71 /* Current architecture. We don't bump up unless necessary. */
72 static enum sparc_opcode_arch_val current_architecture = SPARC_OPCODE_ARCH_V6;
73
74 /* The maximum architecture level we can bump up to.
75 In a 32 bit environment, don't allow bumping up to v9 by default.
76 The native assembler works this way. The user is required to pass
77 an explicit argument before we'll create v9 object files. However, if
78 we don't see any v9 insns, a v8plus object file is not created. */
79 static enum sparc_opcode_arch_val max_architecture;
80
81 /* Either 32 or 64, selects file format. */
82 static int sparc_arch_size;
83 /* Initial (default) value, recorded separately in case a user option
84 changes the value before md_show_usage is called. */
85 static int default_arch_size;
86
87 #ifdef OBJ_ELF
88 /* The currently selected v9 memory model. Currently only used for
89 ELF. */
90 static enum { MM_TSO, MM_PSO, MM_RMO } sparc_memory_model = MM_RMO;
91 #endif
92
93 static int architecture_requested;
94 static int warn_on_bump;
95
96 /* If warn_on_bump and the needed architecture is higher than this
97 architecture, issue a warning. */
98 static enum sparc_opcode_arch_val warn_after_architecture;
99
100 /* Non-zero if as should generate error if an undeclared g[23] register
101 has been used in -64. */
102 static int no_undeclared_regs;
103
104 /* Non-zero if we should try to relax jumps and calls. */
105 static int sparc_relax;
106
107 /* Non-zero if we are generating PIC code. */
108 int sparc_pic_code;
109
110 /* Non-zero if we should give an error when misaligned data is seen. */
111 static int enforce_aligned_data;
112
113 extern int target_big_endian;
114
115 static int target_little_endian_data;
116
117 /* Symbols for global registers on v9. */
118 static symbolS *globals[8];
119
120 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
121 int sparc_cie_data_alignment;
122
123 /* V9 and 86x have big and little endian data, but instructions are always big
124 endian. The sparclet has bi-endian support but both data and insns have
125 the same endianness. Global `target_big_endian' is used for data.
126 The following macro is used for instructions. */
127 #ifndef INSN_BIG_ENDIAN
128 #define INSN_BIG_ENDIAN (target_big_endian \
129 || default_arch_type == sparc86x \
130 || SPARC_OPCODE_ARCH_V9_P (max_architecture))
131 #endif
132
133 /* Handle of the OPCODE hash table. */
134 static struct hash_control *op_hash;
135
136 static int mylog2 PARAMS ((int));
137 static void s_data1 PARAMS ((void));
138 static void s_seg PARAMS ((int));
139 static void s_proc PARAMS ((int));
140 static void s_reserve PARAMS ((int));
141 static void s_common PARAMS ((int));
142 static void s_empty PARAMS ((int));
143 static void s_uacons PARAMS ((int));
144 static void s_ncons PARAMS ((int));
145 #ifdef OBJ_ELF
146 static void s_register PARAMS ((int));
147 #endif
148
149 const pseudo_typeS md_pseudo_table[] =
150 {
151 {"align", s_align_bytes, 0}, /* Defaulting is invalid (0). */
152 {"common", s_common, 0},
153 {"empty", s_empty, 0},
154 {"global", s_globl, 0},
155 {"half", cons, 2},
156 {"nword", s_ncons, 0},
157 {"optim", s_ignore, 0},
158 {"proc", s_proc, 0},
159 {"reserve", s_reserve, 0},
160 {"seg", s_seg, 0},
161 {"skip", s_space, 0},
162 {"word", cons, 4},
163 {"xword", cons, 8},
164 {"uahalf", s_uacons, 2},
165 {"uaword", s_uacons, 4},
166 {"uaxword", s_uacons, 8},
167 #ifdef OBJ_ELF
168 /* These are specific to sparc/svr4. */
169 {"2byte", s_uacons, 2},
170 {"4byte", s_uacons, 4},
171 {"8byte", s_uacons, 8},
172 {"register", s_register, 0},
173 #endif
174 {NULL, 0, 0},
175 };
176
177 /* This array holds the chars that always start a comment. If the
178 pre-processor is disabled, these aren't very useful. */
179 const char comment_chars[] = "!"; /* JF removed '|' from
180 comment_chars. */
181
182 /* This array holds the chars that only start a comment at the beginning of
183 a line. If the line seems to have the form '# 123 filename'
184 .line and .file directives will appear in the pre-processed output. */
185 /* Note that input_file.c hand checks for '#' at the beginning of the
186 first line of the input file. This is because the compiler outputs
187 #NO_APP at the beginning of its output. */
188 /* Also note that comments started like this one will always
189 work if '/' isn't otherwise defined. */
190 const char line_comment_chars[] = "#";
191
192 const char line_separator_chars[] = ";";
193
194 /* Chars that can be used to separate mant from exp in floating point
195 nums. */
196 const char EXP_CHARS[] = "eE";
197
198 /* Chars that mean this number is a floating point constant.
199 As in 0f12.456
200 or 0d1.2345e12 */
201 const char FLT_CHARS[] = "rRsSfFdDxXpP";
202
203 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
204 changed in read.c. Ideally it shouldn't have to know about it at all,
205 but nothing is ideal around here. */
206
207 #define isoctal(c) ((unsigned) ((c) - '0') < 8)
208
209 struct sparc_it
210 {
211 char *error;
212 unsigned long opcode;
213 struct nlist *nlistp;
214 expressionS exp;
215 expressionS exp2;
216 int pcrel;
217 bfd_reloc_code_real_type reloc;
218 };
219
220 struct sparc_it the_insn, set_insn;
221
222 static void output_insn
223 PARAMS ((const struct sparc_opcode *, struct sparc_it *));
224 \f
225 /* Table of arguments to -A.
226 The sparc_opcode_arch table in sparc-opc.c is insufficient and incorrect
227 for this use. That table is for opcodes only. This table is for opcodes
228 and file formats. */
229
230 enum sparc_arch_types {v6, v7, v8, sparclet, sparclite, sparc86x, v8plus,
231 v8plusa, v9, v9a, v9b, v9_64};
232
233 static struct sparc_arch {
234 char *name;
235 char *opcode_arch;
236 enum sparc_arch_types arch_type;
237 /* Default word size, as specified during configuration.
238 A value of zero means can't be used to specify default architecture. */
239 int default_arch_size;
240 /* Allowable arg to -A? */
241 int user_option_p;
242 } sparc_arch_table[] = {
243 { "v6", "v6", v6, 0, 1 },
244 { "v7", "v7", v7, 0, 1 },
245 { "v8", "v8", v8, 32, 1 },
246 { "sparclet", "sparclet", sparclet, 32, 1 },
247 { "sparclite", "sparclite", sparclite, 32, 1 },
248 { "sparc86x", "sparclite", sparc86x, 32, 1 },
249 { "v8plus", "v9", v9, 0, 1 },
250 { "v8plusa", "v9a", v9, 0, 1 },
251 { "v8plusb", "v9b", v9, 0, 1 },
252 { "v9", "v9", v9, 0, 1 },
253 { "v9a", "v9a", v9, 0, 1 },
254 { "v9b", "v9b", v9, 0, 1 },
255 /* This exists to allow configure.in/Makefile.in to pass one
256 value to specify both the default machine and default word size. */
257 { "v9-64", "v9", v9, 64, 0 },
258 { NULL, NULL, v8, 0, 0 }
259 };
260
261 /* Variant of default_arch */
262 static enum sparc_arch_types default_arch_type;
263
264 static struct sparc_arch *
265 lookup_arch (name)
266 char *name;
267 {
268 struct sparc_arch *sa;
269
270 for (sa = &sparc_arch_table[0]; sa->name != NULL; sa++)
271 if (strcmp (sa->name, name) == 0)
272 break;
273 if (sa->name == NULL)
274 return NULL;
275 return sa;
276 }
277
278 /* Initialize the default opcode arch and word size from the default
279 architecture name. */
280
281 static void
282 init_default_arch ()
283 {
284 struct sparc_arch *sa = lookup_arch (default_arch);
285
286 if (sa == NULL
287 || sa->default_arch_size == 0)
288 as_fatal (_("Invalid default architecture, broken assembler."));
289
290 max_architecture = sparc_opcode_lookup_arch (sa->opcode_arch);
291 if (max_architecture == SPARC_OPCODE_ARCH_BAD)
292 as_fatal (_("Bad opcode table, broken assembler."));
293 default_arch_size = sparc_arch_size = sa->default_arch_size;
294 default_init_p = 1;
295 default_arch_type = sa->arch_type;
296 }
297
298 /* Called by TARGET_FORMAT. */
299
300 const char *
301 sparc_target_format ()
302 {
303 /* We don't get a chance to initialize anything before we're called,
304 so handle that now. */
305 if (! default_init_p)
306 init_default_arch ();
307
308 #ifdef OBJ_AOUT
309 #ifdef TE_NetBSD
310 return "a.out-sparc-netbsd";
311 #else
312 #ifdef TE_SPARCAOUT
313 if (target_big_endian)
314 return "a.out-sunos-big";
315 else if (default_arch_type == sparc86x && target_little_endian_data)
316 return "a.out-sunos-big";
317 else
318 return "a.out-sparc-little";
319 #else
320 return "a.out-sunos-big";
321 #endif
322 #endif
323 #endif
324
325 #ifdef OBJ_BOUT
326 return "b.out.big";
327 #endif
328
329 #ifdef OBJ_COFF
330 #ifdef TE_LYNX
331 return "coff-sparc-lynx";
332 #else
333 return "coff-sparc";
334 #endif
335 #endif
336
337 #ifdef TE_VXWORKS
338 return "elf32-sparc-vxworks";
339 #endif
340
341 #ifdef OBJ_ELF
342 return sparc_arch_size == 64 ? "elf64-sparc" : "elf32-sparc";
343 #endif
344
345 abort ();
346 }
347 \f
348 /* md_parse_option
349 * Invocation line includes a switch not recognized by the base assembler.
350 * See if it's a processor-specific option. These are:
351 *
352 * -bump
353 * Warn on architecture bumps. See also -A.
354 *
355 * -Av6, -Av7, -Av8, -Asparclite, -Asparclet
356 * Standard 32 bit architectures.
357 * -Av9, -Av9a, -Av9b
358 * Sparc64 in either a 32 or 64 bit world (-32/-64 says which).
359 * This used to only mean 64 bits, but properly specifying it
360 * complicated gcc's ASM_SPECs, so now opcode selection is
361 * specified orthogonally to word size (except when specifying
362 * the default, but that is an internal implementation detail).
363 * -Av8plus, -Av8plusa, -Av8plusb
364 * Same as -Av9{,a,b}.
365 * -xarch=v8plus, -xarch=v8plusa, -xarch=v8plusb
366 * Same as -Av8plus{,a,b} -32, for compatibility with Sun's
367 * assembler.
368 * -xarch=v9, -xarch=v9a, -xarch=v9b
369 * Same as -Av9{,a,b} -64, for compatibility with Sun's
370 * assembler.
371 *
372 * Select the architecture and possibly the file format.
373 * Instructions or features not supported by the selected
374 * architecture cause fatal errors.
375 *
376 * The default is to start at v6, and bump the architecture up
377 * whenever an instruction is seen at a higher level. In 32 bit
378 * environments, v9 is not bumped up to, the user must pass
379 * -Av8plus{,a,b}.
380 *
381 * If -bump is specified, a warning is printing when bumping to
382 * higher levels.
383 *
384 * If an architecture is specified, all instructions must match
385 * that architecture. Any higher level instructions are flagged
386 * as errors. Note that in the 32 bit environment specifying
387 * -Av8plus does not automatically create a v8plus object file, a
388 * v9 insn must be seen.
389 *
390 * If both an architecture and -bump are specified, the
391 * architecture starts at the specified level, but bumps are
392 * warnings. Note that we can't set `current_architecture' to
393 * the requested level in this case: in the 32 bit environment,
394 * we still must avoid creating v8plus object files unless v9
395 * insns are seen.
396 *
397 * Note:
398 * Bumping between incompatible architectures is always an
399 * error. For example, from sparclite to v9.
400 */
401
402 #ifdef OBJ_ELF
403 const char *md_shortopts = "A:K:VQ:sq";
404 #else
405 #ifdef OBJ_AOUT
406 const char *md_shortopts = "A:k";
407 #else
408 const char *md_shortopts = "A:";
409 #endif
410 #endif
411 struct option md_longopts[] = {
412 #define OPTION_BUMP (OPTION_MD_BASE)
413 {"bump", no_argument, NULL, OPTION_BUMP},
414 #define OPTION_SPARC (OPTION_MD_BASE + 1)
415 {"sparc", no_argument, NULL, OPTION_SPARC},
416 #define OPTION_XARCH (OPTION_MD_BASE + 2)
417 {"xarch", required_argument, NULL, OPTION_XARCH},
418 #ifdef OBJ_ELF
419 #define OPTION_32 (OPTION_MD_BASE + 3)
420 {"32", no_argument, NULL, OPTION_32},
421 #define OPTION_64 (OPTION_MD_BASE + 4)
422 {"64", no_argument, NULL, OPTION_64},
423 #define OPTION_TSO (OPTION_MD_BASE + 5)
424 {"TSO", no_argument, NULL, OPTION_TSO},
425 #define OPTION_PSO (OPTION_MD_BASE + 6)
426 {"PSO", no_argument, NULL, OPTION_PSO},
427 #define OPTION_RMO (OPTION_MD_BASE + 7)
428 {"RMO", no_argument, NULL, OPTION_RMO},
429 #endif
430 #ifdef SPARC_BIENDIAN
431 #define OPTION_LITTLE_ENDIAN (OPTION_MD_BASE + 8)
432 {"EL", no_argument, NULL, OPTION_LITTLE_ENDIAN},
433 #define OPTION_BIG_ENDIAN (OPTION_MD_BASE + 9)
434 {"EB", no_argument, NULL, OPTION_BIG_ENDIAN},
435 #endif
436 #define OPTION_ENFORCE_ALIGNED_DATA (OPTION_MD_BASE + 10)
437 {"enforce-aligned-data", no_argument, NULL, OPTION_ENFORCE_ALIGNED_DATA},
438 #define OPTION_LITTLE_ENDIAN_DATA (OPTION_MD_BASE + 11)
439 {"little-endian-data", no_argument, NULL, OPTION_LITTLE_ENDIAN_DATA},
440 #ifdef OBJ_ELF
441 #define OPTION_NO_UNDECLARED_REGS (OPTION_MD_BASE + 12)
442 {"no-undeclared-regs", no_argument, NULL, OPTION_NO_UNDECLARED_REGS},
443 #define OPTION_UNDECLARED_REGS (OPTION_MD_BASE + 13)
444 {"undeclared-regs", no_argument, NULL, OPTION_UNDECLARED_REGS},
445 #endif
446 #define OPTION_RELAX (OPTION_MD_BASE + 14)
447 {"relax", no_argument, NULL, OPTION_RELAX},
448 #define OPTION_NO_RELAX (OPTION_MD_BASE + 15)
449 {"no-relax", no_argument, NULL, OPTION_NO_RELAX},
450 {NULL, no_argument, NULL, 0}
451 };
452
453 size_t md_longopts_size = sizeof (md_longopts);
454
455 int
456 md_parse_option (c, arg)
457 int c;
458 char *arg;
459 {
460 /* We don't get a chance to initialize anything before we're called,
461 so handle that now. */
462 if (! default_init_p)
463 init_default_arch ();
464
465 switch (c)
466 {
467 case OPTION_BUMP:
468 warn_on_bump = 1;
469 warn_after_architecture = SPARC_OPCODE_ARCH_V6;
470 break;
471
472 case OPTION_XARCH:
473 #ifdef OBJ_ELF
474 if (strncmp (arg, "v9", 2) != 0)
475 md_parse_option (OPTION_32, NULL);
476 else
477 md_parse_option (OPTION_64, NULL);
478 #endif
479 /* Fall through. */
480
481 case 'A':
482 {
483 struct sparc_arch *sa;
484 enum sparc_opcode_arch_val opcode_arch;
485
486 sa = lookup_arch (arg);
487 if (sa == NULL
488 || ! sa->user_option_p)
489 {
490 if (c == OPTION_XARCH)
491 as_bad (_("invalid architecture -xarch=%s"), arg);
492 else
493 as_bad (_("invalid architecture -A%s"), arg);
494 return 0;
495 }
496
497 opcode_arch = sparc_opcode_lookup_arch (sa->opcode_arch);
498 if (opcode_arch == SPARC_OPCODE_ARCH_BAD)
499 as_fatal (_("Bad opcode table, broken assembler."));
500
501 max_architecture = opcode_arch;
502 architecture_requested = 1;
503 }
504 break;
505
506 case OPTION_SPARC:
507 /* Ignore -sparc, used by SunOS make default .s.o rule. */
508 break;
509
510 case OPTION_ENFORCE_ALIGNED_DATA:
511 enforce_aligned_data = 1;
512 break;
513
514 #ifdef SPARC_BIENDIAN
515 case OPTION_LITTLE_ENDIAN:
516 target_big_endian = 0;
517 if (default_arch_type != sparclet)
518 as_fatal ("This target does not support -EL");
519 break;
520 case OPTION_LITTLE_ENDIAN_DATA:
521 target_little_endian_data = 1;
522 target_big_endian = 0;
523 if (default_arch_type != sparc86x
524 && default_arch_type != v9)
525 as_fatal ("This target does not support --little-endian-data");
526 break;
527 case OPTION_BIG_ENDIAN:
528 target_big_endian = 1;
529 break;
530 #endif
531
532 #ifdef OBJ_AOUT
533 case 'k':
534 sparc_pic_code = 1;
535 break;
536 #endif
537
538 #ifdef OBJ_ELF
539 case OPTION_32:
540 case OPTION_64:
541 {
542 const char **list, **l;
543
544 sparc_arch_size = c == OPTION_32 ? 32 : 64;
545 list = bfd_target_list ();
546 for (l = list; *l != NULL; l++)
547 {
548 if (sparc_arch_size == 32)
549 {
550 if (strcmp (*l, "elf32-sparc") == 0)
551 break;
552 }
553 else
554 {
555 if (strcmp (*l, "elf64-sparc") == 0)
556 break;
557 }
558 }
559 if (*l == NULL)
560 as_fatal (_("No compiled in support for %d bit object file format"),
561 sparc_arch_size);
562 free (list);
563 }
564 break;
565
566 case OPTION_TSO:
567 sparc_memory_model = MM_TSO;
568 break;
569
570 case OPTION_PSO:
571 sparc_memory_model = MM_PSO;
572 break;
573
574 case OPTION_RMO:
575 sparc_memory_model = MM_RMO;
576 break;
577
578 case 'V':
579 print_version_id ();
580 break;
581
582 case 'Q':
583 /* Qy - do emit .comment
584 Qn - do not emit .comment. */
585 break;
586
587 case 's':
588 /* Use .stab instead of .stab.excl. */
589 break;
590
591 case 'q':
592 /* quick -- Native assembler does fewer checks. */
593 break;
594
595 case 'K':
596 if (strcmp (arg, "PIC") != 0)
597 as_warn (_("Unrecognized option following -K"));
598 else
599 sparc_pic_code = 1;
600 break;
601
602 case OPTION_NO_UNDECLARED_REGS:
603 no_undeclared_regs = 1;
604 break;
605
606 case OPTION_UNDECLARED_REGS:
607 no_undeclared_regs = 0;
608 break;
609 #endif
610
611 case OPTION_RELAX:
612 sparc_relax = 1;
613 break;
614
615 case OPTION_NO_RELAX:
616 sparc_relax = 0;
617 break;
618
619 default:
620 return 0;
621 }
622
623 return 1;
624 }
625
626 void
627 md_show_usage (stream)
628 FILE *stream;
629 {
630 const struct sparc_arch *arch;
631 int column;
632
633 /* We don't get a chance to initialize anything before we're called,
634 so handle that now. */
635 if (! default_init_p)
636 init_default_arch ();
637
638 fprintf (stream, _("SPARC options:\n"));
639 column = 0;
640 for (arch = &sparc_arch_table[0]; arch->name; arch++)
641 {
642 if (!arch->user_option_p)
643 continue;
644 if (arch != &sparc_arch_table[0])
645 fprintf (stream, " | ");
646 if (column + strlen (arch->name) > 70)
647 {
648 column = 0;
649 fputc ('\n', stream);
650 }
651 column += 5 + 2 + strlen (arch->name);
652 fprintf (stream, "-A%s", arch->name);
653 }
654 for (arch = &sparc_arch_table[0]; arch->name; arch++)
655 {
656 if (!arch->user_option_p)
657 continue;
658 fprintf (stream, " | ");
659 if (column + strlen (arch->name) > 65)
660 {
661 column = 0;
662 fputc ('\n', stream);
663 }
664 column += 5 + 7 + strlen (arch->name);
665 fprintf (stream, "-xarch=%s", arch->name);
666 }
667 fprintf (stream, _("\n\
668 specify variant of SPARC architecture\n\
669 -bump warn when assembler switches architectures\n\
670 -sparc ignored\n\
671 --enforce-aligned-data force .long, etc., to be aligned correctly\n\
672 -relax relax jumps and branches (default)\n\
673 -no-relax avoid changing any jumps and branches\n"));
674 #ifdef OBJ_AOUT
675 fprintf (stream, _("\
676 -k generate PIC\n"));
677 #endif
678 #ifdef OBJ_ELF
679 fprintf (stream, _("\
680 -32 create 32 bit object file\n\
681 -64 create 64 bit object file\n"));
682 fprintf (stream, _("\
683 [default is %d]\n"), default_arch_size);
684 fprintf (stream, _("\
685 -TSO use Total Store Ordering\n\
686 -PSO use Partial Store Ordering\n\
687 -RMO use Relaxed Memory Ordering\n"));
688 fprintf (stream, _("\
689 [default is %s]\n"), (default_arch_size == 64) ? "RMO" : "TSO");
690 fprintf (stream, _("\
691 -KPIC generate PIC\n\
692 -V print assembler version number\n\
693 -undeclared-regs ignore application global register usage without\n\
694 appropriate .register directive (default)\n\
695 -no-undeclared-regs force error on application global register usage\n\
696 without appropriate .register directive\n\
697 -q ignored\n\
698 -Qy, -Qn ignored\n\
699 -s ignored\n"));
700 #endif
701 #ifdef SPARC_BIENDIAN
702 fprintf (stream, _("\
703 -EL generate code for a little endian machine\n\
704 -EB generate code for a big endian machine\n\
705 --little-endian-data generate code for a machine having big endian\n\
706 instructions and little endian data.\n"));
707 #endif
708 }
709 \f
710 /* Native operand size opcode translation. */
711 struct
712 {
713 char *name;
714 char *name32;
715 char *name64;
716 } native_op_table[] =
717 {
718 {"ldn", "ld", "ldx"},
719 {"ldna", "lda", "ldxa"},
720 {"stn", "st", "stx"},
721 {"stna", "sta", "stxa"},
722 {"slln", "sll", "sllx"},
723 {"srln", "srl", "srlx"},
724 {"sran", "sra", "srax"},
725 {"casn", "cas", "casx"},
726 {"casna", "casa", "casxa"},
727 {"clrn", "clr", "clrx"},
728 {NULL, NULL, NULL},
729 };
730 \f
731 /* sparc64 privileged and hyperprivileged registers. */
732
733 struct priv_reg_entry
734 {
735 char *name;
736 int regnum;
737 };
738
739 struct priv_reg_entry priv_reg_table[] =
740 {
741 {"tpc", 0},
742 {"tnpc", 1},
743 {"tstate", 2},
744 {"tt", 3},
745 {"tick", 4},
746 {"tba", 5},
747 {"pstate", 6},
748 {"tl", 7},
749 {"pil", 8},
750 {"cwp", 9},
751 {"cansave", 10},
752 {"canrestore", 11},
753 {"cleanwin", 12},
754 {"otherwin", 13},
755 {"wstate", 14},
756 {"fq", 15},
757 {"gl", 16},
758 {"ver", 31},
759 {"", -1}, /* End marker. */
760 };
761
762 struct priv_reg_entry hpriv_reg_table[] =
763 {
764 {"hpstate", 0},
765 {"htstate", 1},
766 {"hintp", 3},
767 {"htba", 5},
768 {"hver", 6},
769 {"hstick_cmpr", 31},
770 {"", -1}, /* End marker. */
771 };
772
773 /* v9a specific asrs. */
774
775 struct priv_reg_entry v9a_asr_table[] =
776 {
777 {"tick_cmpr", 23},
778 {"sys_tick_cmpr", 25},
779 {"sys_tick", 24},
780 {"softint", 22},
781 {"set_softint", 20},
782 {"pic", 17},
783 {"pcr", 16},
784 {"gsr", 19},
785 {"dcr", 18},
786 {"clear_softint", 21},
787 {"", -1}, /* End marker. */
788 };
789
790 static int
791 cmp_reg_entry (parg, qarg)
792 const PTR parg;
793 const PTR qarg;
794 {
795 const struct priv_reg_entry *p = (const struct priv_reg_entry *) parg;
796 const struct priv_reg_entry *q = (const struct priv_reg_entry *) qarg;
797
798 return strcmp (q->name, p->name);
799 }
800 \f
801 /* This function is called once, at assembler startup time. It should
802 set up all the tables, etc. that the MD part of the assembler will
803 need. */
804
805 void
806 md_begin ()
807 {
808 register const char *retval = NULL;
809 int lose = 0;
810 register unsigned int i = 0;
811
812 /* We don't get a chance to initialize anything before md_parse_option
813 is called, and it may not be called, so handle default initialization
814 now if not already done. */
815 if (! default_init_p)
816 init_default_arch ();
817
818 sparc_cie_data_alignment = sparc_arch_size == 64 ? -8 : -4;
819 op_hash = hash_new ();
820
821 while (i < (unsigned int) sparc_num_opcodes)
822 {
823 const char *name = sparc_opcodes[i].name;
824 retval = hash_insert (op_hash, name, (PTR) &sparc_opcodes[i]);
825 if (retval != NULL)
826 {
827 as_bad (_("Internal error: can't hash `%s': %s\n"),
828 sparc_opcodes[i].name, retval);
829 lose = 1;
830 }
831 do
832 {
833 if (sparc_opcodes[i].match & sparc_opcodes[i].lose)
834 {
835 as_bad (_("Internal error: losing opcode: `%s' \"%s\"\n"),
836 sparc_opcodes[i].name, sparc_opcodes[i].args);
837 lose = 1;
838 }
839 ++i;
840 }
841 while (i < (unsigned int) sparc_num_opcodes
842 && !strcmp (sparc_opcodes[i].name, name));
843 }
844
845 for (i = 0; native_op_table[i].name; i++)
846 {
847 const struct sparc_opcode *insn;
848 char *name = ((sparc_arch_size == 32)
849 ? native_op_table[i].name32
850 : native_op_table[i].name64);
851 insn = (struct sparc_opcode *) hash_find (op_hash, name);
852 if (insn == NULL)
853 {
854 as_bad (_("Internal error: can't find opcode `%s' for `%s'\n"),
855 name, native_op_table[i].name);
856 lose = 1;
857 }
858 else
859 {
860 retval = hash_insert (op_hash, native_op_table[i].name, (PTR) insn);
861 if (retval != NULL)
862 {
863 as_bad (_("Internal error: can't hash `%s': %s\n"),
864 sparc_opcodes[i].name, retval);
865 lose = 1;
866 }
867 }
868 }
869
870 if (lose)
871 as_fatal (_("Broken assembler. No assembly attempted."));
872
873 qsort (priv_reg_table, sizeof (priv_reg_table) / sizeof (priv_reg_table[0]),
874 sizeof (priv_reg_table[0]), cmp_reg_entry);
875
876 /* If -bump, record the architecture level at which we start issuing
877 warnings. The behaviour is different depending upon whether an
878 architecture was explicitly specified. If it wasn't, we issue warnings
879 for all upwards bumps. If it was, we don't start issuing warnings until
880 we need to bump beyond the requested architecture or when we bump between
881 conflicting architectures. */
882
883 if (warn_on_bump
884 && architecture_requested)
885 {
886 /* `max_architecture' records the requested architecture.
887 Issue warnings if we go above it. */
888 warn_after_architecture = max_architecture;
889
890 /* Find the highest architecture level that doesn't conflict with
891 the requested one. */
892 for (max_architecture = SPARC_OPCODE_ARCH_MAX;
893 max_architecture > warn_after_architecture;
894 --max_architecture)
895 if (! SPARC_OPCODE_CONFLICT_P (max_architecture,
896 warn_after_architecture))
897 break;
898 }
899 }
900
901 /* Called after all assembly has been done. */
902
903 void
904 sparc_md_end ()
905 {
906 unsigned long mach = bfd_mach_sparc;
907
908 if (sparc_arch_size == 64)
909 switch (current_architecture)
910 {
911 case SPARC_OPCODE_ARCH_V9A: mach = bfd_mach_sparc_v9a; break;
912 case SPARC_OPCODE_ARCH_V9B: mach = bfd_mach_sparc_v9b; break;
913 default: mach = bfd_mach_sparc_v9; break;
914 }
915 else
916 switch (current_architecture)
917 {
918 case SPARC_OPCODE_ARCH_SPARCLET: mach = bfd_mach_sparc_sparclet; break;
919 case SPARC_OPCODE_ARCH_V9: mach = bfd_mach_sparc_v8plus; break;
920 case SPARC_OPCODE_ARCH_V9A: mach = bfd_mach_sparc_v8plusa; break;
921 case SPARC_OPCODE_ARCH_V9B: mach = bfd_mach_sparc_v8plusb; break;
922 /* The sparclite is treated like a normal sparc. Perhaps it shouldn't
923 be but for now it is (since that's the way it's always been
924 treated). */
925 default: break;
926 }
927 bfd_set_arch_mach (stdoutput, bfd_arch_sparc, mach);
928 }
929 \f
930 /* Return non-zero if VAL is in the range -(MAX+1) to MAX. */
931
932 static INLINE int
933 in_signed_range (val, max)
934 bfd_signed_vma val, max;
935 {
936 if (max <= 0)
937 abort ();
938 /* Sign-extend the value from the architecture word size, so that
939 0xffffffff is always considered -1 on sparc32. */
940 if (sparc_arch_size == 32)
941 {
942 bfd_signed_vma sign = (bfd_signed_vma) 1 << 31;
943 val = ((val & U0xffffffff) ^ sign) - sign;
944 }
945 if (val > max)
946 return 0;
947 if (val < ~max)
948 return 0;
949 return 1;
950 }
951
952 /* Return non-zero if VAL is in the range 0 to MAX. */
953
954 static INLINE int
955 in_unsigned_range (val, max)
956 bfd_vma val, max;
957 {
958 if (val > max)
959 return 0;
960 return 1;
961 }
962
963 /* Return non-zero if VAL is in the range -(MAX/2+1) to MAX.
964 (e.g. -15 to +31). */
965
966 static INLINE int
967 in_bitfield_range (val, max)
968 bfd_signed_vma val, max;
969 {
970 if (max <= 0)
971 abort ();
972 if (val > max)
973 return 0;
974 if (val < ~(max >> 1))
975 return 0;
976 return 1;
977 }
978
979 static int
980 sparc_ffs (mask)
981 unsigned int mask;
982 {
983 int i;
984
985 if (mask == 0)
986 return -1;
987
988 for (i = 0; (mask & 1) == 0; ++i)
989 mask >>= 1;
990 return i;
991 }
992
993 /* Implement big shift right. */
994 static bfd_vma
995 BSR (val, amount)
996 bfd_vma val;
997 int amount;
998 {
999 if (sizeof (bfd_vma) <= 4 && amount >= 32)
1000 as_fatal (_("Support for 64-bit arithmetic not compiled in."));
1001 return val >> amount;
1002 }
1003 \f
1004 /* For communication between sparc_ip and get_expression. */
1005 static char *expr_end;
1006
1007 /* Values for `special_case'.
1008 Instructions that require wierd handling because they're longer than
1009 4 bytes. */
1010 #define SPECIAL_CASE_NONE 0
1011 #define SPECIAL_CASE_SET 1
1012 #define SPECIAL_CASE_SETSW 2
1013 #define SPECIAL_CASE_SETX 3
1014 /* FIXME: sparc-opc.c doesn't have necessary "S" trigger to enable this. */
1015 #define SPECIAL_CASE_FDIV 4
1016
1017 /* Bit masks of various insns. */
1018 #define NOP_INSN 0x01000000
1019 #define OR_INSN 0x80100000
1020 #define XOR_INSN 0x80180000
1021 #define FMOVS_INSN 0x81A00020
1022 #define SETHI_INSN 0x01000000
1023 #define SLLX_INSN 0x81281000
1024 #define SRA_INSN 0x81380000
1025
1026 /* The last instruction to be assembled. */
1027 static const struct sparc_opcode *last_insn;
1028 /* The assembled opcode of `last_insn'. */
1029 static unsigned long last_opcode;
1030 \f
1031 /* Handle the set and setuw synthetic instructions. */
1032
1033 static void
1034 synthetize_setuw (insn)
1035 const struct sparc_opcode *insn;
1036 {
1037 int need_hi22_p = 0;
1038 int rd = (the_insn.opcode & RD (~0)) >> 25;
1039
1040 if (the_insn.exp.X_op == O_constant)
1041 {
1042 if (SPARC_OPCODE_ARCH_V9_P (max_architecture))
1043 {
1044 if (sizeof (offsetT) > 4
1045 && (the_insn.exp.X_add_number < 0
1046 || the_insn.exp.X_add_number > (offsetT) U0xffffffff))
1047 as_warn (_("set: number not in 0..4294967295 range"));
1048 }
1049 else
1050 {
1051 if (sizeof (offsetT) > 4
1052 && (the_insn.exp.X_add_number < -(offsetT) U0x80000000
1053 || the_insn.exp.X_add_number > (offsetT) U0xffffffff))
1054 as_warn (_("set: number not in -2147483648..4294967295 range"));
1055 the_insn.exp.X_add_number = (int) the_insn.exp.X_add_number;
1056 }
1057 }
1058
1059 /* See if operand is absolute and small; skip sethi if so. */
1060 if (the_insn.exp.X_op != O_constant
1061 || the_insn.exp.X_add_number >= (1 << 12)
1062 || the_insn.exp.X_add_number < -(1 << 12))
1063 {
1064 the_insn.opcode = (SETHI_INSN | RD (rd)
1065 | ((the_insn.exp.X_add_number >> 10)
1066 & (the_insn.exp.X_op == O_constant
1067 ? 0x3fffff : 0)));
1068 the_insn.reloc = (the_insn.exp.X_op != O_constant
1069 ? BFD_RELOC_HI22 : BFD_RELOC_NONE);
1070 output_insn (insn, &the_insn);
1071 need_hi22_p = 1;
1072 }
1073
1074 /* See if operand has no low-order bits; skip OR if so. */
1075 if (the_insn.exp.X_op != O_constant
1076 || (need_hi22_p && (the_insn.exp.X_add_number & 0x3FF) != 0)
1077 || ! need_hi22_p)
1078 {
1079 the_insn.opcode = (OR_INSN | (need_hi22_p ? RS1 (rd) : 0)
1080 | RD (rd) | IMMED
1081 | (the_insn.exp.X_add_number
1082 & (the_insn.exp.X_op != O_constant
1083 ? 0 : need_hi22_p ? 0x3ff : 0x1fff)));
1084 the_insn.reloc = (the_insn.exp.X_op != O_constant
1085 ? BFD_RELOC_LO10 : BFD_RELOC_NONE);
1086 output_insn (insn, &the_insn);
1087 }
1088 }
1089
1090 /* Handle the setsw synthetic instruction. */
1091
1092 static void
1093 synthetize_setsw (insn)
1094 const struct sparc_opcode *insn;
1095 {
1096 int low32, rd, opc;
1097
1098 rd = (the_insn.opcode & RD (~0)) >> 25;
1099
1100 if (the_insn.exp.X_op != O_constant)
1101 {
1102 synthetize_setuw (insn);
1103
1104 /* Need to sign extend it. */
1105 the_insn.opcode = (SRA_INSN | RS1 (rd) | RD (rd));
1106 the_insn.reloc = BFD_RELOC_NONE;
1107 output_insn (insn, &the_insn);
1108 return;
1109 }
1110
1111 if (sizeof (offsetT) > 4
1112 && (the_insn.exp.X_add_number < -(offsetT) U0x80000000
1113 || the_insn.exp.X_add_number > (offsetT) U0xffffffff))
1114 as_warn (_("setsw: number not in -2147483648..4294967295 range"));
1115
1116 low32 = the_insn.exp.X_add_number;
1117
1118 if (low32 >= 0)
1119 {
1120 synthetize_setuw (insn);
1121 return;
1122 }
1123
1124 opc = OR_INSN;
1125
1126 the_insn.reloc = BFD_RELOC_NONE;
1127 /* See if operand is absolute and small; skip sethi if so. */
1128 if (low32 < -(1 << 12))
1129 {
1130 the_insn.opcode = (SETHI_INSN | RD (rd)
1131 | (((~the_insn.exp.X_add_number) >> 10) & 0x3fffff));
1132 output_insn (insn, &the_insn);
1133 low32 = 0x1c00 | (low32 & 0x3ff);
1134 opc = RS1 (rd) | XOR_INSN;
1135 }
1136
1137 the_insn.opcode = (opc | RD (rd) | IMMED
1138 | (low32 & 0x1fff));
1139 output_insn (insn, &the_insn);
1140 }
1141
1142 /* Handle the setsw synthetic instruction. */
1143
1144 static void
1145 synthetize_setx (insn)
1146 const struct sparc_opcode *insn;
1147 {
1148 int upper32, lower32;
1149 int tmpreg = (the_insn.opcode & RS1 (~0)) >> 14;
1150 int dstreg = (the_insn.opcode & RD (~0)) >> 25;
1151 int upper_dstreg;
1152 int need_hh22_p = 0, need_hm10_p = 0, need_hi22_p = 0, need_lo10_p = 0;
1153 int need_xor10_p = 0;
1154
1155 #define SIGNEXT32(x) ((((x) & U0xffffffff) ^ U0x80000000) - U0x80000000)
1156 lower32 = SIGNEXT32 (the_insn.exp.X_add_number);
1157 upper32 = SIGNEXT32 (BSR (the_insn.exp.X_add_number, 32));
1158 #undef SIGNEXT32
1159
1160 upper_dstreg = tmpreg;
1161 /* The tmp reg should not be the dst reg. */
1162 if (tmpreg == dstreg)
1163 as_warn (_("setx: temporary register same as destination register"));
1164
1165 /* ??? Obviously there are other optimizations we can do
1166 (e.g. sethi+shift for 0x1f0000000) and perhaps we shouldn't be
1167 doing some of these. Later. If you do change things, try to
1168 change all of this to be table driven as well. */
1169 /* What to output depends on the number if it's constant.
1170 Compute that first, then output what we've decided upon. */
1171 if (the_insn.exp.X_op != O_constant)
1172 {
1173 if (sparc_arch_size == 32)
1174 {
1175 /* When arch size is 32, we want setx to be equivalent
1176 to setuw for anything but constants. */
1177 the_insn.exp.X_add_number &= 0xffffffff;
1178 synthetize_setuw (insn);
1179 return;
1180 }
1181 need_hh22_p = need_hm10_p = need_hi22_p = need_lo10_p = 1;
1182 lower32 = 0;
1183 upper32 = 0;
1184 }
1185 else
1186 {
1187 /* Reset X_add_number, we've extracted it as upper32/lower32.
1188 Otherwise fixup_segment will complain about not being able to
1189 write an 8 byte number in a 4 byte field. */
1190 the_insn.exp.X_add_number = 0;
1191
1192 /* Only need hh22 if `or' insn can't handle constant. */
1193 if (upper32 < -(1 << 12) || upper32 >= (1 << 12))
1194 need_hh22_p = 1;
1195
1196 /* Does bottom part (after sethi) have bits? */
1197 if ((need_hh22_p && (upper32 & 0x3ff) != 0)
1198 /* No hh22, but does upper32 still have bits we can't set
1199 from lower32? */
1200 || (! need_hh22_p && upper32 != 0 && upper32 != -1))
1201 need_hm10_p = 1;
1202
1203 /* If the lower half is all zero, we build the upper half directly
1204 into the dst reg. */
1205 if (lower32 != 0
1206 /* Need lower half if number is zero or 0xffffffff00000000. */
1207 || (! need_hh22_p && ! need_hm10_p))
1208 {
1209 /* No need for sethi if `or' insn can handle constant. */
1210 if (lower32 < -(1 << 12) || lower32 >= (1 << 12)
1211 /* Note that we can't use a negative constant in the `or'
1212 insn unless the upper 32 bits are all ones. */
1213 || (lower32 < 0 && upper32 != -1)
1214 || (lower32 >= 0 && upper32 == -1))
1215 need_hi22_p = 1;
1216
1217 if (need_hi22_p && upper32 == -1)
1218 need_xor10_p = 1;
1219
1220 /* Does bottom part (after sethi) have bits? */
1221 else if ((need_hi22_p && (lower32 & 0x3ff) != 0)
1222 /* No sethi. */
1223 || (! need_hi22_p && (lower32 & 0x1fff) != 0)
1224 /* Need `or' if we didn't set anything else. */
1225 || (! need_hi22_p && ! need_hh22_p && ! need_hm10_p))
1226 need_lo10_p = 1;
1227 }
1228 else
1229 /* Output directly to dst reg if lower 32 bits are all zero. */
1230 upper_dstreg = dstreg;
1231 }
1232
1233 if (!upper_dstreg && dstreg)
1234 as_warn (_("setx: illegal temporary register g0"));
1235
1236 if (need_hh22_p)
1237 {
1238 the_insn.opcode = (SETHI_INSN | RD (upper_dstreg)
1239 | ((upper32 >> 10) & 0x3fffff));
1240 the_insn.reloc = (the_insn.exp.X_op != O_constant
1241 ? BFD_RELOC_SPARC_HH22 : BFD_RELOC_NONE);
1242 output_insn (insn, &the_insn);
1243 }
1244
1245 if (need_hi22_p)
1246 {
1247 the_insn.opcode = (SETHI_INSN | RD (dstreg)
1248 | (((need_xor10_p ? ~lower32 : lower32)
1249 >> 10) & 0x3fffff));
1250 the_insn.reloc = (the_insn.exp.X_op != O_constant
1251 ? BFD_RELOC_SPARC_LM22 : BFD_RELOC_NONE);
1252 output_insn (insn, &the_insn);
1253 }
1254
1255 if (need_hm10_p)
1256 {
1257 the_insn.opcode = (OR_INSN
1258 | (need_hh22_p ? RS1 (upper_dstreg) : 0)
1259 | RD (upper_dstreg)
1260 | IMMED
1261 | (upper32 & (need_hh22_p ? 0x3ff : 0x1fff)));
1262 the_insn.reloc = (the_insn.exp.X_op != O_constant
1263 ? BFD_RELOC_SPARC_HM10 : BFD_RELOC_NONE);
1264 output_insn (insn, &the_insn);
1265 }
1266
1267 if (need_lo10_p)
1268 {
1269 /* FIXME: One nice optimization to do here is to OR the low part
1270 with the highpart if hi22 isn't needed and the low part is
1271 positive. */
1272 the_insn.opcode = (OR_INSN | (need_hi22_p ? RS1 (dstreg) : 0)
1273 | RD (dstreg)
1274 | IMMED
1275 | (lower32 & (need_hi22_p ? 0x3ff : 0x1fff)));
1276 the_insn.reloc = (the_insn.exp.X_op != O_constant
1277 ? BFD_RELOC_LO10 : BFD_RELOC_NONE);
1278 output_insn (insn, &the_insn);
1279 }
1280
1281 /* If we needed to build the upper part, shift it into place. */
1282 if (need_hh22_p || need_hm10_p)
1283 {
1284 the_insn.opcode = (SLLX_INSN | RS1 (upper_dstreg) | RD (upper_dstreg)
1285 | IMMED | 32);
1286 the_insn.reloc = BFD_RELOC_NONE;
1287 output_insn (insn, &the_insn);
1288 }
1289
1290 /* To get -1 in upper32, we do sethi %hi(~x), r; xor r, -0x400 | x, r. */
1291 if (need_xor10_p)
1292 {
1293 the_insn.opcode = (XOR_INSN | RS1 (dstreg) | RD (dstreg) | IMMED
1294 | 0x1c00 | (lower32 & 0x3ff));
1295 the_insn.reloc = BFD_RELOC_NONE;
1296 output_insn (insn, &the_insn);
1297 }
1298
1299 /* If we needed to build both upper and lower parts, OR them together. */
1300 else if ((need_hh22_p || need_hm10_p) && (need_hi22_p || need_lo10_p))
1301 {
1302 the_insn.opcode = (OR_INSN | RS1 (dstreg) | RS2 (upper_dstreg)
1303 | RD (dstreg));
1304 the_insn.reloc = BFD_RELOC_NONE;
1305 output_insn (insn, &the_insn);
1306 }
1307 }
1308 \f
1309 /* Main entry point to assemble one instruction. */
1310
1311 void
1312 md_assemble (str)
1313 char *str;
1314 {
1315 const struct sparc_opcode *insn;
1316 int special_case;
1317
1318 know (str);
1319 special_case = sparc_ip (str, &insn);
1320 if (insn == NULL)
1321 return;
1322
1323 /* We warn about attempts to put a floating point branch in a delay slot,
1324 unless the delay slot has been annulled. */
1325 if (last_insn != NULL
1326 && (insn->flags & F_FBR) != 0
1327 && (last_insn->flags & F_DELAYED) != 0
1328 /* ??? This test isn't completely accurate. We assume anything with
1329 F_{UNBR,CONDBR,FBR} set is annullable. */
1330 && ((last_insn->flags & (F_UNBR | F_CONDBR | F_FBR)) == 0
1331 || (last_opcode & ANNUL) == 0))
1332 as_warn (_("FP branch in delay slot"));
1333
1334 /* SPARC before v9 requires a nop instruction between a floating
1335 point instruction and a floating point branch. We insert one
1336 automatically, with a warning. */
1337 if (max_architecture < SPARC_OPCODE_ARCH_V9
1338 && last_insn != NULL
1339 && (insn->flags & F_FBR) != 0
1340 && (last_insn->flags & F_FLOAT) != 0)
1341 {
1342 struct sparc_it nop_insn;
1343
1344 nop_insn.opcode = NOP_INSN;
1345 nop_insn.reloc = BFD_RELOC_NONE;
1346 output_insn (insn, &nop_insn);
1347 as_warn (_("FP branch preceded by FP instruction; NOP inserted"));
1348 }
1349
1350 switch (special_case)
1351 {
1352 case SPECIAL_CASE_NONE:
1353 /* Normal insn. */
1354 output_insn (insn, &the_insn);
1355 break;
1356
1357 case SPECIAL_CASE_SETSW:
1358 synthetize_setsw (insn);
1359 break;
1360
1361 case SPECIAL_CASE_SET:
1362 synthetize_setuw (insn);
1363 break;
1364
1365 case SPECIAL_CASE_SETX:
1366 synthetize_setx (insn);
1367 break;
1368
1369 case SPECIAL_CASE_FDIV:
1370 {
1371 int rd = (the_insn.opcode >> 25) & 0x1f;
1372
1373 output_insn (insn, &the_insn);
1374
1375 /* According to information leaked from Sun, the "fdiv" instructions
1376 on early SPARC machines would produce incorrect results sometimes.
1377 The workaround is to add an fmovs of the destination register to
1378 itself just after the instruction. This was true on machines
1379 with Weitek 1165 float chips, such as the Sun-4/260 and /280. */
1380 assert (the_insn.reloc == BFD_RELOC_NONE);
1381 the_insn.opcode = FMOVS_INSN | rd | RD (rd);
1382 output_insn (insn, &the_insn);
1383 return;
1384 }
1385
1386 default:
1387 as_fatal (_("failed special case insn sanity check"));
1388 }
1389 }
1390
1391 /* Subroutine of md_assemble to do the actual parsing. */
1392
1393 static int
1394 sparc_ip (str, pinsn)
1395 char *str;
1396 const struct sparc_opcode **pinsn;
1397 {
1398 char *error_message = "";
1399 char *s;
1400 const char *args;
1401 char c;
1402 const struct sparc_opcode *insn;
1403 char *argsStart;
1404 unsigned long opcode;
1405 unsigned int mask = 0;
1406 int match = 0;
1407 int comma = 0;
1408 int v9_arg_p;
1409 int special_case = SPECIAL_CASE_NONE;
1410
1411 s = str;
1412 if (ISLOWER (*s))
1413 {
1414 do
1415 ++s;
1416 while (ISLOWER (*s) || ISDIGIT (*s));
1417 }
1418
1419 switch (*s)
1420 {
1421 case '\0':
1422 break;
1423
1424 case ',':
1425 comma = 1;
1426 /* Fall through. */
1427
1428 case ' ':
1429 *s++ = '\0';
1430 break;
1431
1432 default:
1433 as_bad (_("Unknown opcode: `%s'"), str);
1434 *pinsn = NULL;
1435 return special_case;
1436 }
1437 insn = (struct sparc_opcode *) hash_find (op_hash, str);
1438 *pinsn = insn;
1439 if (insn == NULL)
1440 {
1441 as_bad (_("Unknown opcode: `%s'"), str);
1442 return special_case;
1443 }
1444 if (comma)
1445 {
1446 *--s = ',';
1447 }
1448
1449 argsStart = s;
1450 for (;;)
1451 {
1452 opcode = insn->match;
1453 memset (&the_insn, '\0', sizeof (the_insn));
1454 the_insn.reloc = BFD_RELOC_NONE;
1455 v9_arg_p = 0;
1456
1457 /* Build the opcode, checking as we go to make sure that the
1458 operands match. */
1459 for (args = insn->args;; ++args)
1460 {
1461 switch (*args)
1462 {
1463 case 'K':
1464 {
1465 int kmask = 0;
1466
1467 /* Parse a series of masks. */
1468 if (*s == '#')
1469 {
1470 while (*s == '#')
1471 {
1472 int mask;
1473
1474 if (! parse_keyword_arg (sparc_encode_membar, &s,
1475 &mask))
1476 {
1477 error_message = _(": invalid membar mask name");
1478 goto error;
1479 }
1480 kmask |= mask;
1481 while (*s == ' ')
1482 ++s;
1483 if (*s == '|' || *s == '+')
1484 ++s;
1485 while (*s == ' ')
1486 ++s;
1487 }
1488 }
1489 else
1490 {
1491 if (! parse_const_expr_arg (&s, &kmask))
1492 {
1493 error_message = _(": invalid membar mask expression");
1494 goto error;
1495 }
1496 if (kmask < 0 || kmask > 127)
1497 {
1498 error_message = _(": invalid membar mask number");
1499 goto error;
1500 }
1501 }
1502
1503 opcode |= MEMBAR (kmask);
1504 continue;
1505 }
1506
1507 case '3':
1508 {
1509 int smask = 0;
1510
1511 if (! parse_const_expr_arg (&s, &smask))
1512 {
1513 error_message = _(": invalid siam mode expression");
1514 goto error;
1515 }
1516 if (smask < 0 || smask > 7)
1517 {
1518 error_message = _(": invalid siam mode number");
1519 goto error;
1520 }
1521 opcode |= smask;
1522 continue;
1523 }
1524
1525 case '*':
1526 {
1527 int fcn = 0;
1528
1529 /* Parse a prefetch function. */
1530 if (*s == '#')
1531 {
1532 if (! parse_keyword_arg (sparc_encode_prefetch, &s, &fcn))
1533 {
1534 error_message = _(": invalid prefetch function name");
1535 goto error;
1536 }
1537 }
1538 else
1539 {
1540 if (! parse_const_expr_arg (&s, &fcn))
1541 {
1542 error_message = _(": invalid prefetch function expression");
1543 goto error;
1544 }
1545 if (fcn < 0 || fcn > 31)
1546 {
1547 error_message = _(": invalid prefetch function number");
1548 goto error;
1549 }
1550 }
1551 opcode |= RD (fcn);
1552 continue;
1553 }
1554
1555 case '!':
1556 case '?':
1557 /* Parse a sparc64 privileged register. */
1558 if (*s == '%')
1559 {
1560 struct priv_reg_entry *p = priv_reg_table;
1561 unsigned int len = 9999999; /* Init to make gcc happy. */
1562
1563 s += 1;
1564 while (p->name[0] > s[0])
1565 p++;
1566 while (p->name[0] == s[0])
1567 {
1568 len = strlen (p->name);
1569 if (strncmp (p->name, s, len) == 0)
1570 break;
1571 p++;
1572 }
1573 if (p->name[0] != s[0])
1574 {
1575 error_message = _(": unrecognizable privileged register");
1576 goto error;
1577 }
1578 if (*args == '?')
1579 opcode |= (p->regnum << 14);
1580 else
1581 opcode |= (p->regnum << 25);
1582 s += len;
1583 continue;
1584 }
1585 else
1586 {
1587 error_message = _(": unrecognizable privileged register");
1588 goto error;
1589 }
1590
1591 case '$':
1592 case '%':
1593 /* Parse a sparc64 hyperprivileged register. */
1594 if (*s == '%')
1595 {
1596 struct priv_reg_entry *p = hpriv_reg_table;
1597 unsigned int len = 9999999; /* Init to make gcc happy. */
1598
1599 s += 1;
1600 while (p->name[0] > s[0])
1601 p++;
1602 while (p->name[0] == s[0])
1603 {
1604 len = strlen (p->name);
1605 if (strncmp (p->name, s, len) == 0)
1606 break;
1607 p++;
1608 }
1609 if (p->name[0] != s[0])
1610 {
1611 error_message = _(": unrecognizable hyperprivileged register");
1612 goto error;
1613 }
1614 if (*args == '$')
1615 opcode |= (p->regnum << 14);
1616 else
1617 opcode |= (p->regnum << 25);
1618 s += len;
1619 continue;
1620 }
1621 else
1622 {
1623 error_message = _(": unrecognizable hyperprivileged register");
1624 goto error;
1625 }
1626
1627 case '_':
1628 case '/':
1629 /* Parse a v9a/v9b ancillary state register. */
1630 if (*s == '%')
1631 {
1632 struct priv_reg_entry *p = v9a_asr_table;
1633 unsigned int len = 9999999; /* Init to make gcc happy. */
1634
1635 s += 1;
1636 while (p->name[0] > s[0])
1637 p++;
1638 while (p->name[0] == s[0])
1639 {
1640 len = strlen (p->name);
1641 if (strncmp (p->name, s, len) == 0)
1642 break;
1643 p++;
1644 }
1645 if (p->name[0] != s[0])
1646 {
1647 error_message = _(": unrecognizable v9a or v9b ancillary state register");
1648 goto error;
1649 }
1650 if (*args == '/' && (p->regnum == 20 || p->regnum == 21))
1651 {
1652 error_message = _(": rd on write only ancillary state register");
1653 goto error;
1654 }
1655 if (p->regnum >= 24
1656 && (insn->architecture
1657 & SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V9A)))
1658 {
1659 /* %sys_tick and %sys_tick_cmpr are v9bnotv9a */
1660 error_message = _(": unrecognizable v9a ancillary state register");
1661 goto error;
1662 }
1663 if (*args == '/')
1664 opcode |= (p->regnum << 14);
1665 else
1666 opcode |= (p->regnum << 25);
1667 s += len;
1668 continue;
1669 }
1670 else
1671 {
1672 error_message = _(": unrecognizable v9a or v9b ancillary state register");
1673 goto error;
1674 }
1675
1676 case 'M':
1677 case 'm':
1678 if (strncmp (s, "%asr", 4) == 0)
1679 {
1680 s += 4;
1681
1682 if (ISDIGIT (*s))
1683 {
1684 long num = 0;
1685
1686 while (ISDIGIT (*s))
1687 {
1688 num = num * 10 + *s - '0';
1689 ++s;
1690 }
1691
1692 if (current_architecture >= SPARC_OPCODE_ARCH_V9)
1693 {
1694 if (num < 16 || 31 < num)
1695 {
1696 error_message = _(": asr number must be between 16 and 31");
1697 goto error;
1698 }
1699 }
1700 else
1701 {
1702 if (num < 0 || 31 < num)
1703 {
1704 error_message = _(": asr number must be between 0 and 31");
1705 goto error;
1706 }
1707 }
1708
1709 opcode |= (*args == 'M' ? RS1 (num) : RD (num));
1710 continue;
1711 }
1712 else
1713 {
1714 error_message = _(": expecting %asrN");
1715 goto error;
1716 }
1717 } /* if %asr */
1718 break;
1719
1720 case 'I':
1721 the_insn.reloc = BFD_RELOC_SPARC_11;
1722 goto immediate;
1723
1724 case 'j':
1725 the_insn.reloc = BFD_RELOC_SPARC_10;
1726 goto immediate;
1727
1728 case 'X':
1729 /* V8 systems don't understand BFD_RELOC_SPARC_5. */
1730 if (SPARC_OPCODE_ARCH_V9_P (max_architecture))
1731 the_insn.reloc = BFD_RELOC_SPARC_5;
1732 else
1733 the_insn.reloc = BFD_RELOC_SPARC13;
1734 /* These fields are unsigned, but for upward compatibility,
1735 allow negative values as well. */
1736 goto immediate;
1737
1738 case 'Y':
1739 /* V8 systems don't understand BFD_RELOC_SPARC_6. */
1740 if (SPARC_OPCODE_ARCH_V9_P (max_architecture))
1741 the_insn.reloc = BFD_RELOC_SPARC_6;
1742 else
1743 the_insn.reloc = BFD_RELOC_SPARC13;
1744 /* These fields are unsigned, but for upward compatibility,
1745 allow negative values as well. */
1746 goto immediate;
1747
1748 case 'k':
1749 the_insn.reloc = /* RELOC_WDISP2_14 */ BFD_RELOC_SPARC_WDISP16;
1750 the_insn.pcrel = 1;
1751 goto immediate;
1752
1753 case 'G':
1754 the_insn.reloc = BFD_RELOC_SPARC_WDISP19;
1755 the_insn.pcrel = 1;
1756 goto immediate;
1757
1758 case 'N':
1759 if (*s == 'p' && s[1] == 'n')
1760 {
1761 s += 2;
1762 continue;
1763 }
1764 break;
1765
1766 case 'T':
1767 if (*s == 'p' && s[1] == 't')
1768 {
1769 s += 2;
1770 continue;
1771 }
1772 break;
1773
1774 case 'z':
1775 if (*s == ' ')
1776 {
1777 ++s;
1778 }
1779 if (strncmp (s, "%icc", 4) == 0)
1780 {
1781 s += 4;
1782 continue;
1783 }
1784 break;
1785
1786 case 'Z':
1787 if (*s == ' ')
1788 {
1789 ++s;
1790 }
1791 if (strncmp (s, "%xcc", 4) == 0)
1792 {
1793 s += 4;
1794 continue;
1795 }
1796 break;
1797
1798 case '6':
1799 if (*s == ' ')
1800 {
1801 ++s;
1802 }
1803 if (strncmp (s, "%fcc0", 5) == 0)
1804 {
1805 s += 5;
1806 continue;
1807 }
1808 break;
1809
1810 case '7':
1811 if (*s == ' ')
1812 {
1813 ++s;
1814 }
1815 if (strncmp (s, "%fcc1", 5) == 0)
1816 {
1817 s += 5;
1818 continue;
1819 }
1820 break;
1821
1822 case '8':
1823 if (*s == ' ')
1824 {
1825 ++s;
1826 }
1827 if (strncmp (s, "%fcc2", 5) == 0)
1828 {
1829 s += 5;
1830 continue;
1831 }
1832 break;
1833
1834 case '9':
1835 if (*s == ' ')
1836 {
1837 ++s;
1838 }
1839 if (strncmp (s, "%fcc3", 5) == 0)
1840 {
1841 s += 5;
1842 continue;
1843 }
1844 break;
1845
1846 case 'P':
1847 if (strncmp (s, "%pc", 3) == 0)
1848 {
1849 s += 3;
1850 continue;
1851 }
1852 break;
1853
1854 case 'W':
1855 if (strncmp (s, "%tick", 5) == 0)
1856 {
1857 s += 5;
1858 continue;
1859 }
1860 break;
1861
1862 case '\0': /* End of args. */
1863 if (s[0] == ',' && s[1] == '%')
1864 {
1865 static const struct tls_ops {
1866 /* The name as it appears in assembler. */
1867 char *name;
1868 /* strlen (name), precomputed for speed */
1869 int len;
1870 /* The reloc this pseudo-op translates to. */
1871 int reloc;
1872 /* 1 if call. */
1873 int call;
1874 } tls_ops[] = {
1875 { "tgd_add", 7, BFD_RELOC_SPARC_TLS_GD_ADD, 0 },
1876 { "tgd_call", 8, BFD_RELOC_SPARC_TLS_GD_CALL, 1 },
1877 { "tldm_add", 8, BFD_RELOC_SPARC_TLS_LDM_ADD, 0 },
1878 { "tldm_call", 9, BFD_RELOC_SPARC_TLS_LDM_CALL, 1 },
1879 { "tldo_add", 8, BFD_RELOC_SPARC_TLS_LDO_ADD, 0 },
1880 { "tie_ldx", 7, BFD_RELOC_SPARC_TLS_IE_LDX, 0 },
1881 { "tie_ld", 6, BFD_RELOC_SPARC_TLS_IE_LD, 0 },
1882 { "tie_add", 7, BFD_RELOC_SPARC_TLS_IE_ADD, 0 }
1883 };
1884 const struct tls_ops *o;
1885 char *s1;
1886 int npar = 0;
1887
1888 for (o = tls_ops; o->name; o++)
1889 if (strncmp (s + 2, o->name, o->len) == 0)
1890 break;
1891 if (o->name == NULL)
1892 break;
1893
1894 if (s[o->len + 2] != '(')
1895 {
1896 as_bad (_("Illegal operands: %%%s requires arguments in ()"), o->name);
1897 return special_case;
1898 }
1899
1900 if (! o->call && the_insn.reloc != BFD_RELOC_NONE)
1901 {
1902 as_bad (_("Illegal operands: %%%s cannot be used together with other relocs in the insn ()"),
1903 o->name);
1904 return special_case;
1905 }
1906
1907 if (o->call
1908 && (the_insn.reloc != BFD_RELOC_32_PCREL_S2
1909 || the_insn.exp.X_add_number != 0
1910 || the_insn.exp.X_add_symbol
1911 != symbol_find_or_make ("__tls_get_addr")))
1912 {
1913 as_bad (_("Illegal operands: %%%s can be only used with call __tls_get_addr"),
1914 o->name);
1915 return special_case;
1916 }
1917
1918 the_insn.reloc = o->reloc;
1919 memset (&the_insn.exp, 0, sizeof (the_insn.exp));
1920 s += o->len + 3;
1921
1922 for (s1 = s; *s1 && *s1 != ',' && *s1 != ']'; s1++)
1923 if (*s1 == '(')
1924 npar++;
1925 else if (*s1 == ')')
1926 {
1927 if (!npar)
1928 break;
1929 npar--;
1930 }
1931
1932 if (*s1 != ')')
1933 {
1934 as_bad (_("Illegal operands: %%%s requires arguments in ()"), o->name);
1935 return special_case;
1936 }
1937
1938 *s1 = '\0';
1939 (void) get_expression (s);
1940 *s1 = ')';
1941 s = s1 + 1;
1942 }
1943 if (*s == '\0')
1944 match = 1;
1945 break;
1946
1947 case '+':
1948 if (*s == '+')
1949 {
1950 ++s;
1951 continue;
1952 }
1953 if (*s == '-')
1954 {
1955 continue;
1956 }
1957 break;
1958
1959 case '[': /* These must match exactly. */
1960 case ']':
1961 case ',':
1962 case ' ':
1963 if (*s++ == *args)
1964 continue;
1965 break;
1966
1967 case '#': /* Must be at least one digit. */
1968 if (ISDIGIT (*s++))
1969 {
1970 while (ISDIGIT (*s))
1971 {
1972 ++s;
1973 }
1974 continue;
1975 }
1976 break;
1977
1978 case 'C': /* Coprocessor state register. */
1979 if (strncmp (s, "%csr", 4) == 0)
1980 {
1981 s += 4;
1982 continue;
1983 }
1984 break;
1985
1986 case 'b': /* Next operand is a coprocessor register. */
1987 case 'c':
1988 case 'D':
1989 if (*s++ == '%' && *s++ == 'c' && ISDIGIT (*s))
1990 {
1991 mask = *s++;
1992 if (ISDIGIT (*s))
1993 {
1994 mask = 10 * (mask - '0') + (*s++ - '0');
1995 if (mask >= 32)
1996 {
1997 break;
1998 }
1999 }
2000 else
2001 {
2002 mask -= '0';
2003 }
2004 switch (*args)
2005 {
2006
2007 case 'b':
2008 opcode |= mask << 14;
2009 continue;
2010
2011 case 'c':
2012 opcode |= mask;
2013 continue;
2014
2015 case 'D':
2016 opcode |= mask << 25;
2017 continue;
2018 }
2019 }
2020 break;
2021
2022 case 'r': /* next operand must be a register */
2023 case 'O':
2024 case '1':
2025 case '2':
2026 case 'd':
2027 if (*s++ == '%')
2028 {
2029 switch (c = *s++)
2030 {
2031
2032 case 'f': /* frame pointer */
2033 if (*s++ == 'p')
2034 {
2035 mask = 0x1e;
2036 break;
2037 }
2038 goto error;
2039
2040 case 'g': /* global register */
2041 c = *s++;
2042 if (isoctal (c))
2043 {
2044 mask = c - '0';
2045 break;
2046 }
2047 goto error;
2048
2049 case 'i': /* in register */
2050 c = *s++;
2051 if (isoctal (c))
2052 {
2053 mask = c - '0' + 24;
2054 break;
2055 }
2056 goto error;
2057
2058 case 'l': /* local register */
2059 c = *s++;
2060 if (isoctal (c))
2061 {
2062 mask = (c - '0' + 16);
2063 break;
2064 }
2065 goto error;
2066
2067 case 'o': /* out register */
2068 c = *s++;
2069 if (isoctal (c))
2070 {
2071 mask = (c - '0' + 8);
2072 break;
2073 }
2074 goto error;
2075
2076 case 's': /* stack pointer */
2077 if (*s++ == 'p')
2078 {
2079 mask = 0xe;
2080 break;
2081 }
2082 goto error;
2083
2084 case 'r': /* any register */
2085 if (!ISDIGIT ((c = *s++)))
2086 {
2087 goto error;
2088 }
2089 /* FALLTHROUGH */
2090 case '0':
2091 case '1':
2092 case '2':
2093 case '3':
2094 case '4':
2095 case '5':
2096 case '6':
2097 case '7':
2098 case '8':
2099 case '9':
2100 if (ISDIGIT (*s))
2101 {
2102 if ((c = 10 * (c - '0') + (*s++ - '0')) >= 32)
2103 {
2104 goto error;
2105 }
2106 }
2107 else
2108 {
2109 c -= '0';
2110 }
2111 mask = c;
2112 break;
2113
2114 default:
2115 goto error;
2116 }
2117
2118 if ((mask & ~1) == 2 && sparc_arch_size == 64
2119 && no_undeclared_regs && ! globals[mask])
2120 as_bad (_("detected global register use not covered by .register pseudo-op"));
2121
2122 /* Got the register, now figure out where
2123 it goes in the opcode. */
2124 switch (*args)
2125 {
2126 case '1':
2127 opcode |= mask << 14;
2128 continue;
2129
2130 case '2':
2131 opcode |= mask;
2132 continue;
2133
2134 case 'd':
2135 opcode |= mask << 25;
2136 continue;
2137
2138 case 'r':
2139 opcode |= (mask << 25) | (mask << 14);
2140 continue;
2141
2142 case 'O':
2143 opcode |= (mask << 25) | (mask << 0);
2144 continue;
2145 }
2146 }
2147 break;
2148
2149 case 'e': /* next operand is a floating point register */
2150 case 'v':
2151 case 'V':
2152
2153 case 'f':
2154 case 'B':
2155 case 'R':
2156
2157 case 'g':
2158 case 'H':
2159 case 'J':
2160 {
2161 char format;
2162
2163 if (*s++ == '%'
2164 && ((format = *s) == 'f')
2165 && ISDIGIT (*++s))
2166 {
2167 for (mask = 0; ISDIGIT (*s); ++s)
2168 {
2169 mask = 10 * mask + (*s - '0');
2170 } /* read the number */
2171
2172 if ((*args == 'v'
2173 || *args == 'B'
2174 || *args == 'H')
2175 && (mask & 1))
2176 {
2177 break;
2178 } /* register must be even numbered */
2179
2180 if ((*args == 'V'
2181 || *args == 'R'
2182 || *args == 'J')
2183 && (mask & 3))
2184 {
2185 break;
2186 } /* register must be multiple of 4 */
2187
2188 if (mask >= 64)
2189 {
2190 if (SPARC_OPCODE_ARCH_V9_P (max_architecture))
2191 error_message = _(": There are only 64 f registers; [0-63]");
2192 else
2193 error_message = _(": There are only 32 f registers; [0-31]");
2194 goto error;
2195 } /* on error */
2196 else if (mask >= 32)
2197 {
2198 if (SPARC_OPCODE_ARCH_V9_P (max_architecture))
2199 {
2200 if (*args == 'e' || *args == 'f' || *args == 'g')
2201 {
2202 error_message
2203 = _(": There are only 32 single precision f registers; [0-31]");
2204 goto error;
2205 }
2206 v9_arg_p = 1;
2207 mask -= 31; /* wrap high bit */
2208 }
2209 else
2210 {
2211 error_message = _(": There are only 32 f registers; [0-31]");
2212 goto error;
2213 }
2214 }
2215 }
2216 else
2217 {
2218 break;
2219 } /* if not an 'f' register. */
2220
2221 switch (*args)
2222 {
2223 case 'v':
2224 case 'V':
2225 case 'e':
2226 opcode |= RS1 (mask);
2227 continue;
2228
2229 case 'f':
2230 case 'B':
2231 case 'R':
2232 opcode |= RS2 (mask);
2233 continue;
2234
2235 case 'g':
2236 case 'H':
2237 case 'J':
2238 opcode |= RD (mask);
2239 continue;
2240 } /* Pack it in. */
2241
2242 know (0);
2243 break;
2244 } /* float arg */
2245
2246 case 'F':
2247 if (strncmp (s, "%fsr", 4) == 0)
2248 {
2249 s += 4;
2250 continue;
2251 }
2252 break;
2253
2254 case '0': /* 64 bit immediate (set, setsw, setx insn) */
2255 the_insn.reloc = BFD_RELOC_NONE; /* reloc handled elsewhere */
2256 goto immediate;
2257
2258 case 'l': /* 22 bit PC relative immediate */
2259 the_insn.reloc = BFD_RELOC_SPARC_WDISP22;
2260 the_insn.pcrel = 1;
2261 goto immediate;
2262
2263 case 'L': /* 30 bit immediate */
2264 the_insn.reloc = BFD_RELOC_32_PCREL_S2;
2265 the_insn.pcrel = 1;
2266 goto immediate;
2267
2268 case 'h':
2269 case 'n': /* 22 bit immediate */
2270 the_insn.reloc = BFD_RELOC_SPARC22;
2271 goto immediate;
2272
2273 case 'i': /* 13 bit immediate */
2274 the_insn.reloc = BFD_RELOC_SPARC13;
2275
2276 /* fallthrough */
2277
2278 immediate:
2279 if (*s == ' ')
2280 s++;
2281
2282 {
2283 char *s1;
2284 char *op_arg = NULL;
2285 static expressionS op_exp;
2286 bfd_reloc_code_real_type old_reloc = the_insn.reloc;
2287
2288 /* Check for %hi, etc. */
2289 if (*s == '%')
2290 {
2291 static const struct ops {
2292 /* The name as it appears in assembler. */
2293 char *name;
2294 /* strlen (name), precomputed for speed */
2295 int len;
2296 /* The reloc this pseudo-op translates to. */
2297 int reloc;
2298 /* Non-zero if for v9 only. */
2299 int v9_p;
2300 /* Non-zero if can be used in pc-relative contexts. */
2301 int pcrel_p;/*FIXME:wip*/
2302 } ops[] = {
2303 /* hix/lox must appear before hi/lo so %hix won't be
2304 mistaken for %hi. */
2305 { "hix", 3, BFD_RELOC_SPARC_HIX22, 1, 0 },
2306 { "lox", 3, BFD_RELOC_SPARC_LOX10, 1, 0 },
2307 { "hi", 2, BFD_RELOC_HI22, 0, 1 },
2308 { "lo", 2, BFD_RELOC_LO10, 0, 1 },
2309 { "hh", 2, BFD_RELOC_SPARC_HH22, 1, 1 },
2310 { "hm", 2, BFD_RELOC_SPARC_HM10, 1, 1 },
2311 { "lm", 2, BFD_RELOC_SPARC_LM22, 1, 1 },
2312 { "h44", 3, BFD_RELOC_SPARC_H44, 1, 0 },
2313 { "m44", 3, BFD_RELOC_SPARC_M44, 1, 0 },
2314 { "l44", 3, BFD_RELOC_SPARC_L44, 1, 0 },
2315 { "uhi", 3, BFD_RELOC_SPARC_HH22, 1, 0 },
2316 { "ulo", 3, BFD_RELOC_SPARC_HM10, 1, 0 },
2317 { "tgd_hi22", 8, BFD_RELOC_SPARC_TLS_GD_HI22, 0, 0 },
2318 { "tgd_lo10", 8, BFD_RELOC_SPARC_TLS_GD_LO10, 0, 0 },
2319 { "tldm_hi22", 9, BFD_RELOC_SPARC_TLS_LDM_HI22, 0, 0 },
2320 { "tldm_lo10", 9, BFD_RELOC_SPARC_TLS_LDM_LO10, 0, 0 },
2321 { "tldo_hix22", 10, BFD_RELOC_SPARC_TLS_LDO_HIX22, 0,
2322 0 },
2323 { "tldo_lox10", 10, BFD_RELOC_SPARC_TLS_LDO_LOX10, 0,
2324 0 },
2325 { "tie_hi22", 8, BFD_RELOC_SPARC_TLS_IE_HI22, 0, 0 },
2326 { "tie_lo10", 8, BFD_RELOC_SPARC_TLS_IE_LO10, 0, 0 },
2327 { "tle_hix22", 9, BFD_RELOC_SPARC_TLS_LE_HIX22, 0, 0 },
2328 { "tle_lox10", 9, BFD_RELOC_SPARC_TLS_LE_LOX10, 0, 0 },
2329 { NULL, 0, 0, 0, 0 }
2330 };
2331 const struct ops *o;
2332
2333 for (o = ops; o->name; o++)
2334 if (strncmp (s + 1, o->name, o->len) == 0)
2335 break;
2336 if (o->name == NULL)
2337 break;
2338
2339 if (s[o->len + 1] != '(')
2340 {
2341 as_bad (_("Illegal operands: %%%s requires arguments in ()"), o->name);
2342 return special_case;
2343 }
2344
2345 op_arg = o->name;
2346 the_insn.reloc = o->reloc;
2347 s += o->len + 2;
2348 v9_arg_p = o->v9_p;
2349 }
2350
2351 /* Note that if the get_expression() fails, we will still
2352 have created U entries in the symbol table for the
2353 'symbols' in the input string. Try not to create U
2354 symbols for registers, etc. */
2355
2356 /* This stuff checks to see if the expression ends in
2357 +%reg. If it does, it removes the register from
2358 the expression, and re-sets 's' to point to the
2359 right place. */
2360
2361 if (op_arg)
2362 {
2363 int npar = 0;
2364
2365 for (s1 = s; *s1 && *s1 != ',' && *s1 != ']'; s1++)
2366 if (*s1 == '(')
2367 npar++;
2368 else if (*s1 == ')')
2369 {
2370 if (!npar)
2371 break;
2372 npar--;
2373 }
2374
2375 if (*s1 != ')')
2376 {
2377 as_bad (_("Illegal operands: %%%s requires arguments in ()"), op_arg);
2378 return special_case;
2379 }
2380
2381 *s1 = '\0';
2382 (void) get_expression (s);
2383 *s1 = ')';
2384 s = s1 + 1;
2385 if (*s == ',' || *s == ']' || !*s)
2386 continue;
2387 if (*s != '+' && *s != '-')
2388 {
2389 as_bad (_("Illegal operands: Can't do arithmetics other than + and - involving %%%s()"), op_arg);
2390 return special_case;
2391 }
2392 *s1 = '0';
2393 s = s1;
2394 op_exp = the_insn.exp;
2395 memset (&the_insn.exp, 0, sizeof (the_insn.exp));
2396 }
2397
2398 for (s1 = s; *s1 && *s1 != ',' && *s1 != ']'; s1++)
2399 ;
2400
2401 if (s1 != s && ISDIGIT (s1[-1]))
2402 {
2403 if (s1[-2] == '%' && s1[-3] == '+')
2404 s1 -= 3;
2405 else if (strchr ("goli0123456789", s1[-2]) && s1[-3] == '%' && s1[-4] == '+')
2406 s1 -= 4;
2407 else
2408 s1 = NULL;
2409 if (s1)
2410 {
2411 *s1 = '\0';
2412 if (op_arg && s1 == s + 1)
2413 the_insn.exp.X_op = O_absent;
2414 else
2415 (void) get_expression (s);
2416 *s1 = '+';
2417 if (op_arg)
2418 *s = ')';
2419 s = s1;
2420 }
2421 }
2422 else
2423 s1 = NULL;
2424
2425 if (!s1)
2426 {
2427 (void) get_expression (s);
2428 if (op_arg)
2429 *s = ')';
2430 s = expr_end;
2431 }
2432
2433 if (op_arg)
2434 {
2435 the_insn.exp2 = the_insn.exp;
2436 the_insn.exp = op_exp;
2437 if (the_insn.exp2.X_op == O_absent)
2438 the_insn.exp2.X_op = O_illegal;
2439 else if (the_insn.exp.X_op == O_absent)
2440 {
2441 the_insn.exp = the_insn.exp2;
2442 the_insn.exp2.X_op = O_illegal;
2443 }
2444 else if (the_insn.exp.X_op == O_constant)
2445 {
2446 valueT val = the_insn.exp.X_add_number;
2447 switch (the_insn.reloc)
2448 {
2449 default:
2450 break;
2451
2452 case BFD_RELOC_SPARC_HH22:
2453 val = BSR (val, 32);
2454 /* Fall through. */
2455
2456 case BFD_RELOC_SPARC_LM22:
2457 case BFD_RELOC_HI22:
2458 val = (val >> 10) & 0x3fffff;
2459 break;
2460
2461 case BFD_RELOC_SPARC_HM10:
2462 val = BSR (val, 32);
2463 /* Fall through. */
2464
2465 case BFD_RELOC_LO10:
2466 val &= 0x3ff;
2467 break;
2468
2469 case BFD_RELOC_SPARC_H44:
2470 val >>= 22;
2471 val &= 0x3fffff;
2472 break;
2473
2474 case BFD_RELOC_SPARC_M44:
2475 val >>= 12;
2476 val &= 0x3ff;
2477 break;
2478
2479 case BFD_RELOC_SPARC_L44:
2480 val &= 0xfff;
2481 break;
2482
2483 case BFD_RELOC_SPARC_HIX22:
2484 val = ~val;
2485 val = (val >> 10) & 0x3fffff;
2486 break;
2487
2488 case BFD_RELOC_SPARC_LOX10:
2489 val = (val & 0x3ff) | 0x1c00;
2490 break;
2491 }
2492 the_insn.exp = the_insn.exp2;
2493 the_insn.exp.X_add_number += val;
2494 the_insn.exp2.X_op = O_illegal;
2495 the_insn.reloc = old_reloc;
2496 }
2497 else if (the_insn.exp2.X_op != O_constant)
2498 {
2499 as_bad (_("Illegal operands: Can't add non-constant expression to %%%s()"), op_arg);
2500 return special_case;
2501 }
2502 else
2503 {
2504 if (old_reloc != BFD_RELOC_SPARC13
2505 || the_insn.reloc != BFD_RELOC_LO10
2506 || sparc_arch_size != 64
2507 || sparc_pic_code)
2508 {
2509 as_bad (_("Illegal operands: Can't do arithmetics involving %%%s() of a relocatable symbol"), op_arg);
2510 return special_case;
2511 }
2512 the_insn.reloc = BFD_RELOC_SPARC_OLO10;
2513 }
2514 }
2515 }
2516 /* Check for constants that don't require emitting a reloc. */
2517 if (the_insn.exp.X_op == O_constant
2518 && the_insn.exp.X_add_symbol == 0
2519 && the_insn.exp.X_op_symbol == 0)
2520 {
2521 /* For pc-relative call instructions, we reject
2522 constants to get better code. */
2523 if (the_insn.pcrel
2524 && the_insn.reloc == BFD_RELOC_32_PCREL_S2
2525 && in_signed_range (the_insn.exp.X_add_number, 0x3fff))
2526 {
2527 error_message = _(": PC-relative operand can't be a constant");
2528 goto error;
2529 }
2530
2531 if (the_insn.reloc >= BFD_RELOC_SPARC_TLS_GD_HI22
2532 && the_insn.reloc <= BFD_RELOC_SPARC_TLS_TPOFF64)
2533 {
2534 error_message = _(": TLS operand can't be a constant");
2535 goto error;
2536 }
2537
2538 /* Constants that won't fit are checked in md_apply_fix
2539 and bfd_install_relocation.
2540 ??? It would be preferable to install the constants
2541 into the insn here and save having to create a fixS
2542 for each one. There already exists code to handle
2543 all the various cases (e.g. in md_apply_fix and
2544 bfd_install_relocation) so duplicating all that code
2545 here isn't right. */
2546 }
2547
2548 continue;
2549
2550 case 'a':
2551 if (*s++ == 'a')
2552 {
2553 opcode |= ANNUL;
2554 continue;
2555 }
2556 break;
2557
2558 case 'A':
2559 {
2560 int asi = 0;
2561
2562 /* Parse an asi. */
2563 if (*s == '#')
2564 {
2565 if (! parse_keyword_arg (sparc_encode_asi, &s, &asi))
2566 {
2567 error_message = _(": invalid ASI name");
2568 goto error;
2569 }
2570 }
2571 else
2572 {
2573 if (! parse_const_expr_arg (&s, &asi))
2574 {
2575 error_message = _(": invalid ASI expression");
2576 goto error;
2577 }
2578 if (asi < 0 || asi > 255)
2579 {
2580 error_message = _(": invalid ASI number");
2581 goto error;
2582 }
2583 }
2584 opcode |= ASI (asi);
2585 continue;
2586 } /* Alternate space. */
2587
2588 case 'p':
2589 if (strncmp (s, "%psr", 4) == 0)
2590 {
2591 s += 4;
2592 continue;
2593 }
2594 break;
2595
2596 case 'q': /* Floating point queue. */
2597 if (strncmp (s, "%fq", 3) == 0)
2598 {
2599 s += 3;
2600 continue;
2601 }
2602 break;
2603
2604 case 'Q': /* Coprocessor queue. */
2605 if (strncmp (s, "%cq", 3) == 0)
2606 {
2607 s += 3;
2608 continue;
2609 }
2610 break;
2611
2612 case 'S':
2613 if (strcmp (str, "set") == 0
2614 || strcmp (str, "setuw") == 0)
2615 {
2616 special_case = SPECIAL_CASE_SET;
2617 continue;
2618 }
2619 else if (strcmp (str, "setsw") == 0)
2620 {
2621 special_case = SPECIAL_CASE_SETSW;
2622 continue;
2623 }
2624 else if (strcmp (str, "setx") == 0)
2625 {
2626 special_case = SPECIAL_CASE_SETX;
2627 continue;
2628 }
2629 else if (strncmp (str, "fdiv", 4) == 0)
2630 {
2631 special_case = SPECIAL_CASE_FDIV;
2632 continue;
2633 }
2634 break;
2635
2636 case 'o':
2637 if (strncmp (s, "%asi", 4) != 0)
2638 break;
2639 s += 4;
2640 continue;
2641
2642 case 's':
2643 if (strncmp (s, "%fprs", 5) != 0)
2644 break;
2645 s += 5;
2646 continue;
2647
2648 case 'E':
2649 if (strncmp (s, "%ccr", 4) != 0)
2650 break;
2651 s += 4;
2652 continue;
2653
2654 case 't':
2655 if (strncmp (s, "%tbr", 4) != 0)
2656 break;
2657 s += 4;
2658 continue;
2659
2660 case 'w':
2661 if (strncmp (s, "%wim", 4) != 0)
2662 break;
2663 s += 4;
2664 continue;
2665
2666 case 'x':
2667 {
2668 char *push = input_line_pointer;
2669 expressionS e;
2670
2671 input_line_pointer = s;
2672 expression (&e);
2673 if (e.X_op == O_constant)
2674 {
2675 int n = e.X_add_number;
2676 if (n != e.X_add_number || (n & ~0x1ff) != 0)
2677 as_bad (_("OPF immediate operand out of range (0-0x1ff)"));
2678 else
2679 opcode |= e.X_add_number << 5;
2680 }
2681 else
2682 as_bad (_("non-immediate OPF operand, ignored"));
2683 s = input_line_pointer;
2684 input_line_pointer = push;
2685 continue;
2686 }
2687
2688 case 'y':
2689 if (strncmp (s, "%y", 2) != 0)
2690 break;
2691 s += 2;
2692 continue;
2693
2694 case 'u':
2695 case 'U':
2696 {
2697 /* Parse a sparclet cpreg. */
2698 int cpreg;
2699 if (! parse_keyword_arg (sparc_encode_sparclet_cpreg, &s, &cpreg))
2700 {
2701 error_message = _(": invalid cpreg name");
2702 goto error;
2703 }
2704 opcode |= (*args == 'U' ? RS1 (cpreg) : RD (cpreg));
2705 continue;
2706 }
2707
2708 default:
2709 as_fatal (_("failed sanity check."));
2710 } /* switch on arg code. */
2711
2712 /* Break out of for() loop. */
2713 break;
2714 } /* For each arg that we expect. */
2715
2716 error:
2717 if (match == 0)
2718 {
2719 /* Args don't match. */
2720 if (&insn[1] - sparc_opcodes < sparc_num_opcodes
2721 && (insn->name == insn[1].name
2722 || !strcmp (insn->name, insn[1].name)))
2723 {
2724 ++insn;
2725 s = argsStart;
2726 continue;
2727 }
2728 else
2729 {
2730 as_bad (_("Illegal operands%s"), error_message);
2731 return special_case;
2732 }
2733 }
2734 else
2735 {
2736 /* We have a match. Now see if the architecture is OK. */
2737 int needed_arch_mask = insn->architecture;
2738
2739 if (v9_arg_p)
2740 {
2741 needed_arch_mask &=
2742 ~(SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V9) - 1);
2743 if (! needed_arch_mask)
2744 needed_arch_mask =
2745 SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V9);
2746 }
2747
2748 if (needed_arch_mask
2749 & SPARC_OPCODE_SUPPORTED (current_architecture))
2750 /* OK. */
2751 ;
2752 /* Can we bump up the architecture? */
2753 else if (needed_arch_mask
2754 & SPARC_OPCODE_SUPPORTED (max_architecture))
2755 {
2756 enum sparc_opcode_arch_val needed_architecture =
2757 sparc_ffs (SPARC_OPCODE_SUPPORTED (max_architecture)
2758 & needed_arch_mask);
2759
2760 assert (needed_architecture <= SPARC_OPCODE_ARCH_MAX);
2761 if (warn_on_bump
2762 && needed_architecture > warn_after_architecture)
2763 {
2764 as_warn (_("architecture bumped from \"%s\" to \"%s\" on \"%s\""),
2765 sparc_opcode_archs[current_architecture].name,
2766 sparc_opcode_archs[needed_architecture].name,
2767 str);
2768 warn_after_architecture = needed_architecture;
2769 }
2770 current_architecture = needed_architecture;
2771 }
2772 /* Conflict. */
2773 /* ??? This seems to be a bit fragile. What if the next entry in
2774 the opcode table is the one we want and it is supported?
2775 It is possible to arrange the table today so that this can't
2776 happen but what about tomorrow? */
2777 else
2778 {
2779 int arch, printed_one_p = 0;
2780 char *p;
2781 char required_archs[SPARC_OPCODE_ARCH_MAX * 16];
2782
2783 /* Create a list of the architectures that support the insn. */
2784 needed_arch_mask &= ~SPARC_OPCODE_SUPPORTED (max_architecture);
2785 p = required_archs;
2786 arch = sparc_ffs (needed_arch_mask);
2787 while ((1 << arch) <= needed_arch_mask)
2788 {
2789 if ((1 << arch) & needed_arch_mask)
2790 {
2791 if (printed_one_p)
2792 *p++ = '|';
2793 strcpy (p, sparc_opcode_archs[arch].name);
2794 p += strlen (p);
2795 printed_one_p = 1;
2796 }
2797 ++arch;
2798 }
2799
2800 as_bad (_("Architecture mismatch on \"%s\"."), str);
2801 as_tsktsk (_(" (Requires %s; requested architecture is %s.)"),
2802 required_archs,
2803 sparc_opcode_archs[max_architecture].name);
2804 return special_case;
2805 }
2806 } /* If no match. */
2807
2808 break;
2809 } /* Forever looking for a match. */
2810
2811 the_insn.opcode = opcode;
2812 return special_case;
2813 }
2814
2815 /* Parse an argument that can be expressed as a keyword.
2816 (eg: #StoreStore or %ccfr).
2817 The result is a boolean indicating success.
2818 If successful, INPUT_POINTER is updated. */
2819
2820 static int
2821 parse_keyword_arg (lookup_fn, input_pointerP, valueP)
2822 int (*lookup_fn) PARAMS ((const char *));
2823 char **input_pointerP;
2824 int *valueP;
2825 {
2826 int value;
2827 char c, *p, *q;
2828
2829 p = *input_pointerP;
2830 for (q = p + (*p == '#' || *p == '%');
2831 ISALNUM (*q) || *q == '_';
2832 ++q)
2833 continue;
2834 c = *q;
2835 *q = 0;
2836 value = (*lookup_fn) (p);
2837 *q = c;
2838 if (value == -1)
2839 return 0;
2840 *valueP = value;
2841 *input_pointerP = q;
2842 return 1;
2843 }
2844
2845 /* Parse an argument that is a constant expression.
2846 The result is a boolean indicating success. */
2847
2848 static int
2849 parse_const_expr_arg (input_pointerP, valueP)
2850 char **input_pointerP;
2851 int *valueP;
2852 {
2853 char *save = input_line_pointer;
2854 expressionS exp;
2855
2856 input_line_pointer = *input_pointerP;
2857 /* The next expression may be something other than a constant
2858 (say if we're not processing the right variant of the insn).
2859 Don't call expression unless we're sure it will succeed as it will
2860 signal an error (which we want to defer until later). */
2861 /* FIXME: It might be better to define md_operand and have it recognize
2862 things like %asi, etc. but continuing that route through to the end
2863 is a lot of work. */
2864 if (*input_line_pointer == '%')
2865 {
2866 input_line_pointer = save;
2867 return 0;
2868 }
2869 expression (&exp);
2870 *input_pointerP = input_line_pointer;
2871 input_line_pointer = save;
2872 if (exp.X_op != O_constant)
2873 return 0;
2874 *valueP = exp.X_add_number;
2875 return 1;
2876 }
2877
2878 /* Subroutine of sparc_ip to parse an expression. */
2879
2880 static int
2881 get_expression (str)
2882 char *str;
2883 {
2884 char *save_in;
2885 segT seg;
2886
2887 save_in = input_line_pointer;
2888 input_line_pointer = str;
2889 seg = expression (&the_insn.exp);
2890 if (seg != absolute_section
2891 && seg != text_section
2892 && seg != data_section
2893 && seg != bss_section
2894 && seg != undefined_section)
2895 {
2896 the_insn.error = _("bad segment");
2897 expr_end = input_line_pointer;
2898 input_line_pointer = save_in;
2899 return 1;
2900 }
2901 expr_end = input_line_pointer;
2902 input_line_pointer = save_in;
2903 return 0;
2904 }
2905
2906 /* Subroutine of md_assemble to output one insn. */
2907
2908 static void
2909 output_insn (insn, the_insn)
2910 const struct sparc_opcode *insn;
2911 struct sparc_it *the_insn;
2912 {
2913 char *toP = frag_more (4);
2914
2915 /* Put out the opcode. */
2916 if (INSN_BIG_ENDIAN)
2917 number_to_chars_bigendian (toP, (valueT) the_insn->opcode, 4);
2918 else
2919 number_to_chars_littleendian (toP, (valueT) the_insn->opcode, 4);
2920
2921 /* Put out the symbol-dependent stuff. */
2922 if (the_insn->reloc != BFD_RELOC_NONE)
2923 {
2924 fixS *fixP = fix_new_exp (frag_now, /* Which frag. */
2925 (toP - frag_now->fr_literal), /* Where. */
2926 4, /* Size. */
2927 &the_insn->exp,
2928 the_insn->pcrel,
2929 the_insn->reloc);
2930 /* Turn off overflow checking in fixup_segment. We'll do our
2931 own overflow checking in md_apply_fix. This is necessary because
2932 the insn size is 4 and fixup_segment will signal an overflow for
2933 large 8 byte quantities. */
2934 fixP->fx_no_overflow = 1;
2935 if (the_insn->reloc == BFD_RELOC_SPARC_OLO10)
2936 fixP->tc_fix_data = the_insn->exp2.X_add_number;
2937 }
2938
2939 last_insn = insn;
2940 last_opcode = the_insn->opcode;
2941
2942 #ifdef OBJ_ELF
2943 dwarf2_emit_insn (4);
2944 #endif
2945 }
2946 \f
2947 /* This is identical to the md_atof in m68k.c. I think this is right,
2948 but I'm not sure.
2949
2950 Turn a string in input_line_pointer into a floating point constant
2951 of type TYPE, and store the appropriate bytes in *LITP. The number
2952 of LITTLENUMS emitted is stored in *SIZEP. An error message is
2953 returned, or NULL on OK. */
2954
2955 /* Equal to MAX_PRECISION in atof-ieee.c. */
2956 #define MAX_LITTLENUMS 6
2957
2958 char *
2959 md_atof (type, litP, sizeP)
2960 char type;
2961 char *litP;
2962 int *sizeP;
2963 {
2964 int i, prec;
2965 LITTLENUM_TYPE words[MAX_LITTLENUMS];
2966 char *t;
2967
2968 switch (type)
2969 {
2970 case 'f':
2971 case 'F':
2972 case 's':
2973 case 'S':
2974 prec = 2;
2975 break;
2976
2977 case 'd':
2978 case 'D':
2979 case 'r':
2980 case 'R':
2981 prec = 4;
2982 break;
2983
2984 case 'x':
2985 case 'X':
2986 prec = 6;
2987 break;
2988
2989 case 'p':
2990 case 'P':
2991 prec = 6;
2992 break;
2993
2994 default:
2995 *sizeP = 0;
2996 return _("Bad call to MD_ATOF()");
2997 }
2998
2999 t = atof_ieee (input_line_pointer, type, words);
3000 if (t)
3001 input_line_pointer = t;
3002 *sizeP = prec * sizeof (LITTLENUM_TYPE);
3003
3004 if (target_big_endian)
3005 {
3006 for (i = 0; i < prec; i++)
3007 {
3008 md_number_to_chars (litP, (valueT) words[i],
3009 sizeof (LITTLENUM_TYPE));
3010 litP += sizeof (LITTLENUM_TYPE);
3011 }
3012 }
3013 else
3014 {
3015 for (i = prec - 1; i >= 0; i--)
3016 {
3017 md_number_to_chars (litP, (valueT) words[i],
3018 sizeof (LITTLENUM_TYPE));
3019 litP += sizeof (LITTLENUM_TYPE);
3020 }
3021 }
3022
3023 return 0;
3024 }
3025
3026 /* Write a value out to the object file, using the appropriate
3027 endianness. */
3028
3029 void
3030 md_number_to_chars (buf, val, n)
3031 char *buf;
3032 valueT val;
3033 int n;
3034 {
3035 if (target_big_endian)
3036 number_to_chars_bigendian (buf, val, n);
3037 else if (target_little_endian_data
3038 && ((n == 4 || n == 2) && ~now_seg->flags & SEC_ALLOC))
3039 /* Output debug words, which are not in allocated sections, as big
3040 endian. */
3041 number_to_chars_bigendian (buf, val, n);
3042 else if (target_little_endian_data || ! target_big_endian)
3043 number_to_chars_littleendian (buf, val, n);
3044 }
3045 \f
3046 /* Apply a fixS to the frags, now that we know the value it ought to
3047 hold. */
3048
3049 void
3050 md_apply_fix (fixP, valP, segment)
3051 fixS *fixP;
3052 valueT *valP;
3053 segT segment ATTRIBUTE_UNUSED;
3054 {
3055 char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
3056 offsetT val = * (offsetT *) valP;
3057 long insn;
3058
3059 assert (fixP->fx_r_type < BFD_RELOC_UNUSED);
3060
3061 fixP->fx_addnumber = val; /* Remember value for emit_reloc. */
3062
3063 #ifdef OBJ_ELF
3064 /* SPARC ELF relocations don't use an addend in the data field. */
3065 if (fixP->fx_addsy != NULL)
3066 {
3067 switch (fixP->fx_r_type)
3068 {
3069 case BFD_RELOC_SPARC_TLS_GD_HI22:
3070 case BFD_RELOC_SPARC_TLS_GD_LO10:
3071 case BFD_RELOC_SPARC_TLS_GD_ADD:
3072 case BFD_RELOC_SPARC_TLS_GD_CALL:
3073 case BFD_RELOC_SPARC_TLS_LDM_HI22:
3074 case BFD_RELOC_SPARC_TLS_LDM_LO10:
3075 case BFD_RELOC_SPARC_TLS_LDM_ADD:
3076 case BFD_RELOC_SPARC_TLS_LDM_CALL:
3077 case BFD_RELOC_SPARC_TLS_LDO_HIX22:
3078 case BFD_RELOC_SPARC_TLS_LDO_LOX10:
3079 case BFD_RELOC_SPARC_TLS_LDO_ADD:
3080 case BFD_RELOC_SPARC_TLS_IE_HI22:
3081 case BFD_RELOC_SPARC_TLS_IE_LO10:
3082 case BFD_RELOC_SPARC_TLS_IE_LD:
3083 case BFD_RELOC_SPARC_TLS_IE_LDX:
3084 case BFD_RELOC_SPARC_TLS_IE_ADD:
3085 case BFD_RELOC_SPARC_TLS_LE_HIX22:
3086 case BFD_RELOC_SPARC_TLS_LE_LOX10:
3087 case BFD_RELOC_SPARC_TLS_DTPMOD32:
3088 case BFD_RELOC_SPARC_TLS_DTPMOD64:
3089 case BFD_RELOC_SPARC_TLS_DTPOFF32:
3090 case BFD_RELOC_SPARC_TLS_DTPOFF64:
3091 case BFD_RELOC_SPARC_TLS_TPOFF32:
3092 case BFD_RELOC_SPARC_TLS_TPOFF64:
3093 S_SET_THREAD_LOCAL (fixP->fx_addsy);
3094
3095 default:
3096 break;
3097 }
3098
3099 return;
3100 }
3101 #endif
3102
3103 /* This is a hack. There should be a better way to
3104 handle this. Probably in terms of howto fields, once
3105 we can look at these fixups in terms of howtos. */
3106 if (fixP->fx_r_type == BFD_RELOC_32_PCREL_S2 && fixP->fx_addsy)
3107 val += fixP->fx_where + fixP->fx_frag->fr_address;
3108
3109 #ifdef OBJ_AOUT
3110 /* FIXME: More ridiculous gas reloc hacking. If we are going to
3111 generate a reloc, then we just want to let the reloc addend set
3112 the value. We do not want to also stuff the addend into the
3113 object file. Including the addend in the object file works when
3114 doing a static link, because the linker will ignore the object
3115 file contents. However, the dynamic linker does not ignore the
3116 object file contents. */
3117 if (fixP->fx_addsy != NULL
3118 && fixP->fx_r_type != BFD_RELOC_32_PCREL_S2)
3119 val = 0;
3120
3121 /* When generating PIC code, we do not want an addend for a reloc
3122 against a local symbol. We adjust fx_addnumber to cancel out the
3123 value already included in val, and to also cancel out the
3124 adjustment which bfd_install_relocation will create. */
3125 if (sparc_pic_code
3126 && fixP->fx_r_type != BFD_RELOC_32_PCREL_S2
3127 && fixP->fx_addsy != NULL
3128 && ! S_IS_COMMON (fixP->fx_addsy)
3129 && symbol_section_p (fixP->fx_addsy))
3130 fixP->fx_addnumber -= 2 * S_GET_VALUE (fixP->fx_addsy);
3131
3132 /* When generating PIC code, we need to fiddle to get
3133 bfd_install_relocation to do the right thing for a PC relative
3134 reloc against a local symbol which we are going to keep. */
3135 if (sparc_pic_code
3136 && fixP->fx_r_type == BFD_RELOC_32_PCREL_S2
3137 && fixP->fx_addsy != NULL
3138 && (S_IS_EXTERNAL (fixP->fx_addsy)
3139 || S_IS_WEAK (fixP->fx_addsy))
3140 && S_IS_DEFINED (fixP->fx_addsy)
3141 && ! S_IS_COMMON (fixP->fx_addsy))
3142 {
3143 val = 0;
3144 fixP->fx_addnumber -= 2 * S_GET_VALUE (fixP->fx_addsy);
3145 }
3146 #endif
3147
3148 /* If this is a data relocation, just output VAL. */
3149
3150 if (fixP->fx_r_type == BFD_RELOC_16
3151 || fixP->fx_r_type == BFD_RELOC_SPARC_UA16)
3152 {
3153 md_number_to_chars (buf, val, 2);
3154 }
3155 else if (fixP->fx_r_type == BFD_RELOC_32
3156 || fixP->fx_r_type == BFD_RELOC_SPARC_UA32
3157 || fixP->fx_r_type == BFD_RELOC_SPARC_REV32)
3158 {
3159 md_number_to_chars (buf, val, 4);
3160 }
3161 else if (fixP->fx_r_type == BFD_RELOC_64
3162 || fixP->fx_r_type == BFD_RELOC_SPARC_UA64)
3163 {
3164 md_number_to_chars (buf, val, 8);
3165 }
3166 else if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
3167 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
3168 {
3169 fixP->fx_done = 0;
3170 return;
3171 }
3172 else
3173 {
3174 /* It's a relocation against an instruction. */
3175
3176 if (INSN_BIG_ENDIAN)
3177 insn = bfd_getb32 ((unsigned char *) buf);
3178 else
3179 insn = bfd_getl32 ((unsigned char *) buf);
3180
3181 switch (fixP->fx_r_type)
3182 {
3183 case BFD_RELOC_32_PCREL_S2:
3184 val = val >> 2;
3185 /* FIXME: This increment-by-one deserves a comment of why it's
3186 being done! */
3187 if (! sparc_pic_code
3188 || fixP->fx_addsy == NULL
3189 || symbol_section_p (fixP->fx_addsy))
3190 ++val;
3191
3192 insn |= val & 0x3fffffff;
3193
3194 /* See if we have a delay slot. */
3195 if (sparc_relax && fixP->fx_where + 8 <= fixP->fx_frag->fr_fix)
3196 {
3197 #define G0 0
3198 #define O7 15
3199 #define XCC (2 << 20)
3200 #define COND(x) (((x)&0xf)<<25)
3201 #define CONDA COND(0x8)
3202 #define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
3203 #define INSN_BA (F2(0,2) | CONDA)
3204 #define INSN_OR F3(2, 0x2, 0)
3205 #define INSN_NOP F2(0,4)
3206
3207 long delay;
3208
3209 /* If the instruction is a call with either:
3210 restore
3211 arithmetic instruction with rd == %o7
3212 where rs1 != %o7 and rs2 if it is register != %o7
3213 then we can optimize if the call destination is near
3214 by changing the call into a branch always. */
3215 if (INSN_BIG_ENDIAN)
3216 delay = bfd_getb32 ((unsigned char *) buf + 4);
3217 else
3218 delay = bfd_getl32 ((unsigned char *) buf + 4);
3219 if ((insn & OP (~0)) != OP (1) || (delay & OP (~0)) != OP (2))
3220 break;
3221 if ((delay & OP3 (~0)) != OP3 (0x3d) /* Restore. */
3222 && ((delay & OP3 (0x28)) != 0 /* Arithmetic. */
3223 || ((delay & RD (~0)) != RD (O7))))
3224 break;
3225 if ((delay & RS1 (~0)) == RS1 (O7)
3226 || ((delay & F3I (~0)) == 0
3227 && (delay & RS2 (~0)) == RS2 (O7)))
3228 break;
3229 /* Ensure the branch will fit into simm22. */
3230 if ((val & 0x3fe00000)
3231 && (val & 0x3fe00000) != 0x3fe00000)
3232 break;
3233 /* Check if the arch is v9 and branch will fit
3234 into simm19. */
3235 if (((val & 0x3c0000) == 0
3236 || (val & 0x3c0000) == 0x3c0000)
3237 && (sparc_arch_size == 64
3238 || current_architecture >= SPARC_OPCODE_ARCH_V9))
3239 /* ba,pt %xcc */
3240 insn = INSN_BPA | (val & 0x7ffff);
3241 else
3242 /* ba */
3243 insn = INSN_BA | (val & 0x3fffff);
3244 if (fixP->fx_where >= 4
3245 && ((delay & (0xffffffff ^ RS1 (~0)))
3246 == (INSN_OR | RD (O7) | RS2 (G0))))
3247 {
3248 long setter;
3249 int reg;
3250
3251 if (INSN_BIG_ENDIAN)
3252 setter = bfd_getb32 ((unsigned char *) buf - 4);
3253 else
3254 setter = bfd_getl32 ((unsigned char *) buf - 4);
3255 if ((setter & (0xffffffff ^ RD (~0)))
3256 != (INSN_OR | RS1 (O7) | RS2 (G0)))
3257 break;
3258 /* The sequence was
3259 or %o7, %g0, %rN
3260 call foo
3261 or %rN, %g0, %o7
3262
3263 If call foo was replaced with ba, replace
3264 or %rN, %g0, %o7 with nop. */
3265 reg = (delay & RS1 (~0)) >> 14;
3266 if (reg != ((setter & RD (~0)) >> 25)
3267 || reg == G0 || reg == O7)
3268 break;
3269
3270 if (INSN_BIG_ENDIAN)
3271 bfd_putb32 (INSN_NOP, (unsigned char *) buf + 4);
3272 else
3273 bfd_putl32 (INSN_NOP, (unsigned char *) buf + 4);
3274 }
3275 }
3276 break;
3277
3278 case BFD_RELOC_SPARC_11:
3279 if (! in_signed_range (val, 0x7ff))
3280 as_bad_where (fixP->fx_file, fixP->fx_line,
3281 _("relocation overflow"));
3282 insn |= val & 0x7ff;
3283 break;
3284
3285 case BFD_RELOC_SPARC_10:
3286 if (! in_signed_range (val, 0x3ff))
3287 as_bad_where (fixP->fx_file, fixP->fx_line,
3288 _("relocation overflow"));
3289 insn |= val & 0x3ff;
3290 break;
3291
3292 case BFD_RELOC_SPARC_7:
3293 if (! in_bitfield_range (val, 0x7f))
3294 as_bad_where (fixP->fx_file, fixP->fx_line,
3295 _("relocation overflow"));
3296 insn |= val & 0x7f;
3297 break;
3298
3299 case BFD_RELOC_SPARC_6:
3300 if (! in_bitfield_range (val, 0x3f))
3301 as_bad_where (fixP->fx_file, fixP->fx_line,
3302 _("relocation overflow"));
3303 insn |= val & 0x3f;
3304 break;
3305
3306 case BFD_RELOC_SPARC_5:
3307 if (! in_bitfield_range (val, 0x1f))
3308 as_bad_where (fixP->fx_file, fixP->fx_line,
3309 _("relocation overflow"));
3310 insn |= val & 0x1f;
3311 break;
3312
3313 case BFD_RELOC_SPARC_WDISP16:
3314 /* FIXME: simplify. */
3315 if (((val > 0) && (val & ~0x3fffc))
3316 || ((val < 0) && (~(val - 1) & ~0x3fffc)))
3317 as_bad_where (fixP->fx_file, fixP->fx_line,
3318 _("relocation overflow"));
3319 /* FIXME: The +1 deserves a comment. */
3320 val = (val >> 2) + 1;
3321 insn |= ((val & 0xc000) << 6) | (val & 0x3fff);
3322 break;
3323
3324 case BFD_RELOC_SPARC_WDISP19:
3325 /* FIXME: simplify. */
3326 if (((val > 0) && (val & ~0x1ffffc))
3327 || ((val < 0) && (~(val - 1) & ~0x1ffffc)))
3328 as_bad_where (fixP->fx_file, fixP->fx_line,
3329 _("relocation overflow"));
3330 /* FIXME: The +1 deserves a comment. */
3331 val = (val >> 2) + 1;
3332 insn |= val & 0x7ffff;
3333 break;
3334
3335 case BFD_RELOC_SPARC_HH22:
3336 val = BSR (val, 32);
3337 /* Fall through. */
3338
3339 case BFD_RELOC_SPARC_LM22:
3340 case BFD_RELOC_HI22:
3341 if (!fixP->fx_addsy)
3342 insn |= (val >> 10) & 0x3fffff;
3343 else
3344 /* FIXME: Need comment explaining why we do this. */
3345 insn &= ~0xffff;
3346 break;
3347
3348 case BFD_RELOC_SPARC22:
3349 if (val & ~0x003fffff)
3350 as_bad_where (fixP->fx_file, fixP->fx_line,
3351 _("relocation overflow"));
3352 insn |= (val & 0x3fffff);
3353 break;
3354
3355 case BFD_RELOC_SPARC_HM10:
3356 val = BSR (val, 32);
3357 /* Fall through. */
3358
3359 case BFD_RELOC_LO10:
3360 if (!fixP->fx_addsy)
3361 insn |= val & 0x3ff;
3362 else
3363 /* FIXME: Need comment explaining why we do this. */
3364 insn &= ~0xff;
3365 break;
3366
3367 case BFD_RELOC_SPARC_OLO10:
3368 val &= 0x3ff;
3369 val += fixP->tc_fix_data;
3370 /* Fall through. */
3371
3372 case BFD_RELOC_SPARC13:
3373 if (! in_signed_range (val, 0x1fff))
3374 as_bad_where (fixP->fx_file, fixP->fx_line,
3375 _("relocation overflow"));
3376 insn |= val & 0x1fff;
3377 break;
3378
3379 case BFD_RELOC_SPARC_WDISP22:
3380 val = (val >> 2) + 1;
3381 /* Fall through. */
3382 case BFD_RELOC_SPARC_BASE22:
3383 insn |= val & 0x3fffff;
3384 break;
3385
3386 case BFD_RELOC_SPARC_H44:
3387 if (!fixP->fx_addsy)
3388 {
3389 bfd_vma tval = val;
3390 tval >>= 22;
3391 insn |= tval & 0x3fffff;
3392 }
3393 break;
3394
3395 case BFD_RELOC_SPARC_M44:
3396 if (!fixP->fx_addsy)
3397 insn |= (val >> 12) & 0x3ff;
3398 break;
3399
3400 case BFD_RELOC_SPARC_L44:
3401 if (!fixP->fx_addsy)
3402 insn |= val & 0xfff;
3403 break;
3404
3405 case BFD_RELOC_SPARC_HIX22:
3406 if (!fixP->fx_addsy)
3407 {
3408 val ^= ~(offsetT) 0;
3409 insn |= (val >> 10) & 0x3fffff;
3410 }
3411 break;
3412
3413 case BFD_RELOC_SPARC_LOX10:
3414 if (!fixP->fx_addsy)
3415 insn |= 0x1c00 | (val & 0x3ff);
3416 break;
3417
3418 case BFD_RELOC_NONE:
3419 default:
3420 as_bad_where (fixP->fx_file, fixP->fx_line,
3421 _("bad or unhandled relocation type: 0x%02x"),
3422 fixP->fx_r_type);
3423 break;
3424 }
3425
3426 if (INSN_BIG_ENDIAN)
3427 bfd_putb32 (insn, (unsigned char *) buf);
3428 else
3429 bfd_putl32 (insn, (unsigned char *) buf);
3430 }
3431
3432 /* Are we finished with this relocation now? */
3433 if (fixP->fx_addsy == 0 && !fixP->fx_pcrel)
3434 fixP->fx_done = 1;
3435 }
3436
3437 /* Translate internal representation of relocation info to BFD target
3438 format. */
3439
3440 arelent **
3441 tc_gen_reloc (section, fixp)
3442 asection *section ATTRIBUTE_UNUSED;
3443 fixS *fixp;
3444 {
3445 static arelent *relocs[3];
3446 arelent *reloc;
3447 bfd_reloc_code_real_type code;
3448
3449 relocs[0] = reloc = (arelent *) xmalloc (sizeof (arelent));
3450 relocs[1] = NULL;
3451
3452 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
3453 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
3454 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
3455
3456 switch (fixp->fx_r_type)
3457 {
3458 case BFD_RELOC_16:
3459 case BFD_RELOC_32:
3460 case BFD_RELOC_HI22:
3461 case BFD_RELOC_LO10:
3462 case BFD_RELOC_32_PCREL_S2:
3463 case BFD_RELOC_SPARC13:
3464 case BFD_RELOC_SPARC22:
3465 case BFD_RELOC_SPARC_BASE13:
3466 case BFD_RELOC_SPARC_WDISP16:
3467 case BFD_RELOC_SPARC_WDISP19:
3468 case BFD_RELOC_SPARC_WDISP22:
3469 case BFD_RELOC_64:
3470 case BFD_RELOC_SPARC_5:
3471 case BFD_RELOC_SPARC_6:
3472 case BFD_RELOC_SPARC_7:
3473 case BFD_RELOC_SPARC_10:
3474 case BFD_RELOC_SPARC_11:
3475 case BFD_RELOC_SPARC_HH22:
3476 case BFD_RELOC_SPARC_HM10:
3477 case BFD_RELOC_SPARC_LM22:
3478 case BFD_RELOC_SPARC_PC_HH22:
3479 case BFD_RELOC_SPARC_PC_HM10:
3480 case BFD_RELOC_SPARC_PC_LM22:
3481 case BFD_RELOC_SPARC_H44:
3482 case BFD_RELOC_SPARC_M44:
3483 case BFD_RELOC_SPARC_L44:
3484 case BFD_RELOC_SPARC_HIX22:
3485 case BFD_RELOC_SPARC_LOX10:
3486 case BFD_RELOC_SPARC_REV32:
3487 case BFD_RELOC_SPARC_OLO10:
3488 case BFD_RELOC_SPARC_UA16:
3489 case BFD_RELOC_SPARC_UA32:
3490 case BFD_RELOC_SPARC_UA64:
3491 case BFD_RELOC_8_PCREL:
3492 case BFD_RELOC_16_PCREL:
3493 case BFD_RELOC_32_PCREL:
3494 case BFD_RELOC_64_PCREL:
3495 case BFD_RELOC_SPARC_PLT32:
3496 case BFD_RELOC_SPARC_PLT64:
3497 case BFD_RELOC_VTABLE_ENTRY:
3498 case BFD_RELOC_VTABLE_INHERIT:
3499 case BFD_RELOC_SPARC_TLS_GD_HI22:
3500 case BFD_RELOC_SPARC_TLS_GD_LO10:
3501 case BFD_RELOC_SPARC_TLS_GD_ADD:
3502 case BFD_RELOC_SPARC_TLS_GD_CALL:
3503 case BFD_RELOC_SPARC_TLS_LDM_HI22:
3504 case BFD_RELOC_SPARC_TLS_LDM_LO10:
3505 case BFD_RELOC_SPARC_TLS_LDM_ADD:
3506 case BFD_RELOC_SPARC_TLS_LDM_CALL:
3507 case BFD_RELOC_SPARC_TLS_LDO_HIX22:
3508 case BFD_RELOC_SPARC_TLS_LDO_LOX10:
3509 case BFD_RELOC_SPARC_TLS_LDO_ADD:
3510 case BFD_RELOC_SPARC_TLS_IE_HI22:
3511 case BFD_RELOC_SPARC_TLS_IE_LO10:
3512 case BFD_RELOC_SPARC_TLS_IE_LD:
3513 case BFD_RELOC_SPARC_TLS_IE_LDX:
3514 case BFD_RELOC_SPARC_TLS_IE_ADD:
3515 case BFD_RELOC_SPARC_TLS_LE_HIX22:
3516 case BFD_RELOC_SPARC_TLS_LE_LOX10:
3517 case BFD_RELOC_SPARC_TLS_DTPOFF32:
3518 case BFD_RELOC_SPARC_TLS_DTPOFF64:
3519 code = fixp->fx_r_type;
3520 break;
3521 default:
3522 abort ();
3523 return NULL;
3524 }
3525
3526 #if defined (OBJ_ELF) || defined (OBJ_AOUT)
3527 /* If we are generating PIC code, we need to generate a different
3528 set of relocs. */
3529
3530 #ifdef OBJ_ELF
3531 #define GOT_NAME "_GLOBAL_OFFSET_TABLE_"
3532 #else
3533 #define GOT_NAME "__GLOBAL_OFFSET_TABLE_"
3534 #endif
3535 #ifdef TE_VXWORKS
3536 #define GOTT_BASE "__GOTT_BASE__"
3537 #define GOTT_INDEX "__GOTT_INDEX__"
3538 #endif
3539
3540 /* This code must be parallel to the OBJ_ELF tc_fix_adjustable. */
3541
3542 if (sparc_pic_code)
3543 {
3544 switch (code)
3545 {
3546 case BFD_RELOC_32_PCREL_S2:
3547 if (generic_force_reloc (fixp))
3548 code = BFD_RELOC_SPARC_WPLT30;
3549 break;
3550 case BFD_RELOC_HI22:
3551 code = BFD_RELOC_SPARC_GOT22;
3552 if (fixp->fx_addsy != NULL)
3553 {
3554 if (strcmp (S_GET_NAME (fixp->fx_addsy), GOT_NAME) == 0)
3555 code = BFD_RELOC_SPARC_PC22;
3556 #ifdef TE_VXWORKS
3557 if (strcmp (S_GET_NAME (fixp->fx_addsy), GOTT_BASE) == 0
3558 || strcmp (S_GET_NAME (fixp->fx_addsy), GOTT_INDEX) == 0)
3559 code = BFD_RELOC_HI22; /* Unchanged. */
3560 #endif
3561 }
3562 break;
3563 case BFD_RELOC_LO10:
3564 code = BFD_RELOC_SPARC_GOT10;
3565 if (fixp->fx_addsy != NULL)
3566 {
3567 if (strcmp (S_GET_NAME (fixp->fx_addsy), GOT_NAME) == 0)
3568 code = BFD_RELOC_SPARC_PC10;
3569 #ifdef TE_VXWORKS
3570 if (strcmp (S_GET_NAME (fixp->fx_addsy), GOTT_BASE) == 0
3571 || strcmp (S_GET_NAME (fixp->fx_addsy), GOTT_INDEX) == 0)
3572 code = BFD_RELOC_LO10; /* Unchanged. */
3573 #endif
3574 }
3575 break;
3576 case BFD_RELOC_SPARC13:
3577 code = BFD_RELOC_SPARC_GOT13;
3578 break;
3579 default:
3580 break;
3581 }
3582 }
3583 #endif /* defined (OBJ_ELF) || defined (OBJ_AOUT) */
3584
3585 if (code == BFD_RELOC_SPARC_OLO10)
3586 reloc->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_LO10);
3587 else
3588 reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
3589 if (reloc->howto == 0)
3590 {
3591 as_bad_where (fixp->fx_file, fixp->fx_line,
3592 _("internal error: can't export reloc type %d (`%s')"),
3593 fixp->fx_r_type, bfd_get_reloc_code_name (code));
3594 xfree (reloc);
3595 relocs[0] = NULL;
3596 return relocs;
3597 }
3598
3599 /* @@ Why fx_addnumber sometimes and fx_offset other times? */
3600 #ifdef OBJ_AOUT
3601
3602 if (reloc->howto->pc_relative == 0
3603 || code == BFD_RELOC_SPARC_PC10
3604 || code == BFD_RELOC_SPARC_PC22)
3605 reloc->addend = fixp->fx_addnumber;
3606 else if (sparc_pic_code
3607 && fixp->fx_r_type == BFD_RELOC_32_PCREL_S2
3608 && fixp->fx_addsy != NULL
3609 && (S_IS_EXTERNAL (fixp->fx_addsy)
3610 || S_IS_WEAK (fixp->fx_addsy))
3611 && S_IS_DEFINED (fixp->fx_addsy)
3612 && ! S_IS_COMMON (fixp->fx_addsy))
3613 reloc->addend = fixp->fx_addnumber;
3614 else
3615 reloc->addend = fixp->fx_offset - reloc->address;
3616
3617 #else /* elf or coff */
3618
3619 if (code != BFD_RELOC_32_PCREL_S2
3620 && code != BFD_RELOC_SPARC_WDISP22
3621 && code != BFD_RELOC_SPARC_WDISP16
3622 && code != BFD_RELOC_SPARC_WDISP19
3623 && code != BFD_RELOC_SPARC_WPLT30
3624 && code != BFD_RELOC_SPARC_TLS_GD_CALL
3625 && code != BFD_RELOC_SPARC_TLS_LDM_CALL)
3626 reloc->addend = fixp->fx_addnumber;
3627 else if (symbol_section_p (fixp->fx_addsy))
3628 reloc->addend = (section->vma
3629 + fixp->fx_addnumber
3630 + md_pcrel_from (fixp));
3631 else
3632 reloc->addend = fixp->fx_offset;
3633 #endif
3634
3635 /* We expand R_SPARC_OLO10 to R_SPARC_LO10 and R_SPARC_13
3636 on the same location. */
3637 if (code == BFD_RELOC_SPARC_OLO10)
3638 {
3639 relocs[1] = reloc = (arelent *) xmalloc (sizeof (arelent));
3640 relocs[2] = NULL;
3641
3642 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
3643 *reloc->sym_ptr_ptr
3644 = symbol_get_bfdsym (section_symbol (absolute_section));
3645 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
3646 reloc->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_SPARC13);
3647 reloc->addend = fixp->tc_fix_data;
3648 }
3649
3650 return relocs;
3651 }
3652 \f
3653 /* We have no need to default values of symbols. */
3654
3655 symbolS *
3656 md_undefined_symbol (name)
3657 char *name ATTRIBUTE_UNUSED;
3658 {
3659 return 0;
3660 }
3661
3662 /* Round up a section size to the appropriate boundary. */
3663
3664 valueT
3665 md_section_align (segment, size)
3666 segT segment ATTRIBUTE_UNUSED;
3667 valueT size;
3668 {
3669 #ifndef OBJ_ELF
3670 /* This is not right for ELF; a.out wants it, and COFF will force
3671 the alignment anyways. */
3672 valueT align = ((valueT) 1
3673 << (valueT) bfd_get_section_alignment (stdoutput, segment));
3674 valueT newsize;
3675
3676 /* Turn alignment value into a mask. */
3677 align--;
3678 newsize = (size + align) & ~align;
3679 return newsize;
3680 #else
3681 return size;
3682 #endif
3683 }
3684
3685 /* Exactly what point is a PC-relative offset relative TO?
3686 On the sparc, they're relative to the address of the offset, plus
3687 its size. This gets us to the following instruction.
3688 (??? Is this right? FIXME-SOON) */
3689 long
3690 md_pcrel_from (fixP)
3691 fixS *fixP;
3692 {
3693 long ret;
3694
3695 ret = fixP->fx_where + fixP->fx_frag->fr_address;
3696 if (! sparc_pic_code
3697 || fixP->fx_addsy == NULL
3698 || symbol_section_p (fixP->fx_addsy))
3699 ret += fixP->fx_size;
3700 return ret;
3701 }
3702 \f
3703 /* Return log2 (VALUE), or -1 if VALUE is not an exact positive power
3704 of two. */
3705
3706 static int
3707 mylog2 (value)
3708 int value;
3709 {
3710 int shift;
3711
3712 if (value <= 0)
3713 return -1;
3714
3715 for (shift = 0; (value & 1) == 0; value >>= 1)
3716 ++shift;
3717
3718 return (value == 1) ? shift : -1;
3719 }
3720
3721 /* Sort of like s_lcomm. */
3722
3723 #ifndef OBJ_ELF
3724 static int max_alignment = 15;
3725 #endif
3726
3727 static void
3728 s_reserve (ignore)
3729 int ignore ATTRIBUTE_UNUSED;
3730 {
3731 char *name;
3732 char *p;
3733 char c;
3734 int align;
3735 int size;
3736 int temp;
3737 symbolS *symbolP;
3738
3739 name = input_line_pointer;
3740 c = get_symbol_end ();
3741 p = input_line_pointer;
3742 *p = c;
3743 SKIP_WHITESPACE ();
3744
3745 if (*input_line_pointer != ',')
3746 {
3747 as_bad (_("Expected comma after name"));
3748 ignore_rest_of_line ();
3749 return;
3750 }
3751
3752 ++input_line_pointer;
3753
3754 if ((size = get_absolute_expression ()) < 0)
3755 {
3756 as_bad (_("BSS length (%d.) <0! Ignored."), size);
3757 ignore_rest_of_line ();
3758 return;
3759 } /* Bad length. */
3760
3761 *p = 0;
3762 symbolP = symbol_find_or_make (name);
3763 *p = c;
3764
3765 if (strncmp (input_line_pointer, ",\"bss\"", 6) != 0
3766 && strncmp (input_line_pointer, ",\".bss\"", 7) != 0)
3767 {
3768 as_bad (_("bad .reserve segment -- expected BSS segment"));
3769 return;
3770 }
3771
3772 if (input_line_pointer[2] == '.')
3773 input_line_pointer += 7;
3774 else
3775 input_line_pointer += 6;
3776 SKIP_WHITESPACE ();
3777
3778 if (*input_line_pointer == ',')
3779 {
3780 ++input_line_pointer;
3781
3782 SKIP_WHITESPACE ();
3783 if (*input_line_pointer == '\n')
3784 {
3785 as_bad (_("missing alignment"));
3786 ignore_rest_of_line ();
3787 return;
3788 }
3789
3790 align = (int) get_absolute_expression ();
3791
3792 #ifndef OBJ_ELF
3793 if (align > max_alignment)
3794 {
3795 align = max_alignment;
3796 as_warn (_("alignment too large; assuming %d"), align);
3797 }
3798 #endif
3799
3800 if (align < 0)
3801 {
3802 as_bad (_("negative alignment"));
3803 ignore_rest_of_line ();
3804 return;
3805 }
3806
3807 if (align != 0)
3808 {
3809 temp = mylog2 (align);
3810 if (temp < 0)
3811 {
3812 as_bad (_("alignment not a power of 2"));
3813 ignore_rest_of_line ();
3814 return;
3815 }
3816
3817 align = temp;
3818 }
3819
3820 record_alignment (bss_section, align);
3821 }
3822 else
3823 align = 0;
3824
3825 if (!S_IS_DEFINED (symbolP)
3826 #ifdef OBJ_AOUT
3827 && S_GET_OTHER (symbolP) == 0
3828 && S_GET_DESC (symbolP) == 0
3829 #endif
3830 )
3831 {
3832 if (! need_pass_2)
3833 {
3834 char *pfrag;
3835 segT current_seg = now_seg;
3836 subsegT current_subseg = now_subseg;
3837
3838 /* Switch to bss. */
3839 subseg_set (bss_section, 1);
3840
3841 if (align)
3842 /* Do alignment. */
3843 frag_align (align, 0, 0);
3844
3845 /* Detach from old frag. */
3846 if (S_GET_SEGMENT (symbolP) == bss_section)
3847 symbol_get_frag (symbolP)->fr_symbol = NULL;
3848
3849 symbol_set_frag (symbolP, frag_now);
3850 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP,
3851 (offsetT) size, (char *) 0);
3852 *pfrag = 0;
3853
3854 S_SET_SEGMENT (symbolP, bss_section);
3855
3856 subseg_set (current_seg, current_subseg);
3857
3858 #ifdef OBJ_ELF
3859 S_SET_SIZE (symbolP, size);
3860 #endif
3861 }
3862 }
3863 else
3864 {
3865 as_warn ("Ignoring attempt to re-define symbol %s",
3866 S_GET_NAME (symbolP));
3867 } /* if not redefining. */
3868
3869 demand_empty_rest_of_line ();
3870 }
3871
3872 static void
3873 s_common (ignore)
3874 int ignore ATTRIBUTE_UNUSED;
3875 {
3876 char *name;
3877 char c;
3878 char *p;
3879 offsetT temp, size;
3880 symbolS *symbolP;
3881
3882 name = input_line_pointer;
3883 c = get_symbol_end ();
3884 /* Just after name is now '\0'. */
3885 p = input_line_pointer;
3886 *p = c;
3887 SKIP_WHITESPACE ();
3888 if (*input_line_pointer != ',')
3889 {
3890 as_bad (_("Expected comma after symbol-name"));
3891 ignore_rest_of_line ();
3892 return;
3893 }
3894
3895 /* Skip ','. */
3896 input_line_pointer++;
3897
3898 if ((temp = get_absolute_expression ()) < 0)
3899 {
3900 as_bad (_(".COMMon length (%lu) out of range ignored"),
3901 (unsigned long) temp);
3902 ignore_rest_of_line ();
3903 return;
3904 }
3905 size = temp;
3906 *p = 0;
3907 symbolP = symbol_find_or_make (name);
3908 *p = c;
3909 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
3910 {
3911 as_bad (_("Ignoring attempt to re-define symbol"));
3912 ignore_rest_of_line ();
3913 return;
3914 }
3915 if (S_GET_VALUE (symbolP) != 0)
3916 {
3917 if (S_GET_VALUE (symbolP) != (valueT) size)
3918 {
3919 as_warn (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
3920 S_GET_NAME (symbolP), (long) S_GET_VALUE (symbolP), (long) size);
3921 }
3922 }
3923 else
3924 {
3925 #ifndef OBJ_ELF
3926 S_SET_VALUE (symbolP, (valueT) size);
3927 S_SET_EXTERNAL (symbolP);
3928 #endif
3929 }
3930 know (symbol_get_frag (symbolP) == &zero_address_frag);
3931 if (*input_line_pointer != ',')
3932 {
3933 as_bad (_("Expected comma after common length"));
3934 ignore_rest_of_line ();
3935 return;
3936 }
3937 input_line_pointer++;
3938 SKIP_WHITESPACE ();
3939 if (*input_line_pointer != '"')
3940 {
3941 temp = get_absolute_expression ();
3942
3943 #ifndef OBJ_ELF
3944 if (temp > max_alignment)
3945 {
3946 temp = max_alignment;
3947 as_warn (_("alignment too large; assuming %ld"), (long) temp);
3948 }
3949 #endif
3950
3951 if (temp < 0)
3952 {
3953 as_bad (_("negative alignment"));
3954 ignore_rest_of_line ();
3955 return;
3956 }
3957
3958 #ifdef OBJ_ELF
3959 if (symbol_get_obj (symbolP)->local)
3960 {
3961 segT old_sec;
3962 int old_subsec;
3963 char *p;
3964 int align;
3965
3966 old_sec = now_seg;
3967 old_subsec = now_subseg;
3968
3969 if (temp == 0)
3970 align = 0;
3971 else
3972 align = mylog2 (temp);
3973
3974 if (align < 0)
3975 {
3976 as_bad (_("alignment not a power of 2"));
3977 ignore_rest_of_line ();
3978 return;
3979 }
3980
3981 record_alignment (bss_section, align);
3982 subseg_set (bss_section, 0);
3983 if (align)
3984 frag_align (align, 0, 0);
3985 if (S_GET_SEGMENT (symbolP) == bss_section)
3986 symbol_get_frag (symbolP)->fr_symbol = 0;
3987 symbol_set_frag (symbolP, frag_now);
3988 p = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP,
3989 (offsetT) size, (char *) 0);
3990 *p = 0;
3991 S_SET_SEGMENT (symbolP, bss_section);
3992 S_CLEAR_EXTERNAL (symbolP);
3993 S_SET_SIZE (symbolP, size);
3994 subseg_set (old_sec, old_subsec);
3995 }
3996 else
3997 #endif /* OBJ_ELF */
3998 {
3999 allocate_common:
4000 S_SET_VALUE (symbolP, (valueT) size);
4001 #ifdef OBJ_ELF
4002 S_SET_ALIGN (symbolP, temp);
4003 S_SET_SIZE (symbolP, size);
4004 #endif
4005 S_SET_EXTERNAL (symbolP);
4006 S_SET_SEGMENT (symbolP, bfd_com_section_ptr);
4007 }
4008 }
4009 else
4010 {
4011 input_line_pointer++;
4012 /* @@ Some use the dot, some don't. Can we get some consistency?? */
4013 if (*input_line_pointer == '.')
4014 input_line_pointer++;
4015 /* @@ Some say data, some say bss. */
4016 if (strncmp (input_line_pointer, "bss\"", 4)
4017 && strncmp (input_line_pointer, "data\"", 5))
4018 {
4019 while (*--input_line_pointer != '"')
4020 ;
4021 input_line_pointer--;
4022 goto bad_common_segment;
4023 }
4024 while (*input_line_pointer++ != '"')
4025 ;
4026 goto allocate_common;
4027 }
4028
4029 symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT;
4030
4031 demand_empty_rest_of_line ();
4032 return;
4033
4034 {
4035 bad_common_segment:
4036 p = input_line_pointer;
4037 while (*p && *p != '\n')
4038 p++;
4039 c = *p;
4040 *p = '\0';
4041 as_bad (_("bad .common segment %s"), input_line_pointer + 1);
4042 *p = c;
4043 input_line_pointer = p;
4044 ignore_rest_of_line ();
4045 return;
4046 }
4047 }
4048
4049 /* Handle the .empty pseudo-op. This suppresses the warnings about
4050 invalid delay slot usage. */
4051
4052 static void
4053 s_empty (ignore)
4054 int ignore ATTRIBUTE_UNUSED;
4055 {
4056 /* The easy way to implement is to just forget about the last
4057 instruction. */
4058 last_insn = NULL;
4059 }
4060
4061 static void
4062 s_seg (ignore)
4063 int ignore ATTRIBUTE_UNUSED;
4064 {
4065
4066 if (strncmp (input_line_pointer, "\"text\"", 6) == 0)
4067 {
4068 input_line_pointer += 6;
4069 s_text (0);
4070 return;
4071 }
4072 if (strncmp (input_line_pointer, "\"data\"", 6) == 0)
4073 {
4074 input_line_pointer += 6;
4075 s_data (0);
4076 return;
4077 }
4078 if (strncmp (input_line_pointer, "\"data1\"", 7) == 0)
4079 {
4080 input_line_pointer += 7;
4081 s_data1 ();
4082 return;
4083 }
4084 if (strncmp (input_line_pointer, "\"bss\"", 5) == 0)
4085 {
4086 input_line_pointer += 5;
4087 /* We only support 2 segments -- text and data -- for now, so
4088 things in the "bss segment" will have to go into data for now.
4089 You can still allocate SEG_BSS stuff with .lcomm or .reserve. */
4090 subseg_set (data_section, 255); /* FIXME-SOMEDAY. */
4091 return;
4092 }
4093 as_bad (_("Unknown segment type"));
4094 demand_empty_rest_of_line ();
4095 }
4096
4097 static void
4098 s_data1 ()
4099 {
4100 subseg_set (data_section, 1);
4101 demand_empty_rest_of_line ();
4102 }
4103
4104 static void
4105 s_proc (ignore)
4106 int ignore ATTRIBUTE_UNUSED;
4107 {
4108 while (!is_end_of_line[(unsigned char) *input_line_pointer])
4109 {
4110 ++input_line_pointer;
4111 }
4112 ++input_line_pointer;
4113 }
4114
4115 /* This static variable is set by s_uacons to tell sparc_cons_align
4116 that the expression does not need to be aligned. */
4117
4118 static int sparc_no_align_cons = 0;
4119
4120 /* This static variable is set by sparc_cons to emit requested types
4121 of relocations in cons_fix_new_sparc. */
4122
4123 static const char *sparc_cons_special_reloc;
4124
4125 /* This handles the unaligned space allocation pseudo-ops, such as
4126 .uaword. .uaword is just like .word, but the value does not need
4127 to be aligned. */
4128
4129 static void
4130 s_uacons (bytes)
4131 int bytes;
4132 {
4133 /* Tell sparc_cons_align not to align this value. */
4134 sparc_no_align_cons = 1;
4135 cons (bytes);
4136 sparc_no_align_cons = 0;
4137 }
4138
4139 /* This handles the native word allocation pseudo-op .nword.
4140 For sparc_arch_size 32 it is equivalent to .word, for
4141 sparc_arch_size 64 it is equivalent to .xword. */
4142
4143 static void
4144 s_ncons (bytes)
4145 int bytes ATTRIBUTE_UNUSED;
4146 {
4147 cons (sparc_arch_size == 32 ? 4 : 8);
4148 }
4149
4150 #ifdef OBJ_ELF
4151 /* Handle the SPARC ELF .register pseudo-op. This sets the binding of a
4152 global register.
4153 The syntax is:
4154
4155 .register %g[2367],{#scratch|symbolname|#ignore}
4156 */
4157
4158 static void
4159 s_register (ignore)
4160 int ignore ATTRIBUTE_UNUSED;
4161 {
4162 char c;
4163 int reg;
4164 int flags;
4165 const char *regname;
4166
4167 if (input_line_pointer[0] != '%'
4168 || input_line_pointer[1] != 'g'
4169 || ((input_line_pointer[2] & ~1) != '2'
4170 && (input_line_pointer[2] & ~1) != '6')
4171 || input_line_pointer[3] != ',')
4172 as_bad (_("register syntax is .register %%g[2367],{#scratch|symbolname|#ignore}"));
4173 reg = input_line_pointer[2] - '0';
4174 input_line_pointer += 4;
4175
4176 if (*input_line_pointer == '#')
4177 {
4178 ++input_line_pointer;
4179 regname = input_line_pointer;
4180 c = get_symbol_end ();
4181 if (strcmp (regname, "scratch") && strcmp (regname, "ignore"))
4182 as_bad (_("register syntax is .register %%g[2367],{#scratch|symbolname|#ignore}"));
4183 if (regname[0] == 'i')
4184 regname = NULL;
4185 else
4186 regname = "";
4187 }
4188 else
4189 {
4190 regname = input_line_pointer;
4191 c = get_symbol_end ();
4192 }
4193 if (sparc_arch_size == 64)
4194 {
4195 if (globals[reg])
4196 {
4197 if ((regname && globals[reg] != (symbolS *) 1
4198 && strcmp (S_GET_NAME (globals[reg]), regname))
4199 || ((regname != NULL) ^ (globals[reg] != (symbolS *) 1)))
4200 as_bad (_("redefinition of global register"));
4201 }
4202 else
4203 {
4204 if (regname == NULL)
4205 globals[reg] = (symbolS *) 1;
4206 else
4207 {
4208 if (*regname)
4209 {
4210 if (symbol_find (regname))
4211 as_bad (_("Register symbol %s already defined."),
4212 regname);
4213 }
4214 globals[reg] = symbol_make (regname);
4215 flags = symbol_get_bfdsym (globals[reg])->flags;
4216 if (! *regname)
4217 flags = flags & ~(BSF_GLOBAL|BSF_LOCAL|BSF_WEAK);
4218 if (! (flags & (BSF_GLOBAL|BSF_LOCAL|BSF_WEAK)))
4219 flags |= BSF_GLOBAL;
4220 symbol_get_bfdsym (globals[reg])->flags = flags;
4221 S_SET_VALUE (globals[reg], (valueT) reg);
4222 S_SET_ALIGN (globals[reg], reg);
4223 S_SET_SIZE (globals[reg], 0);
4224 /* Although we actually want undefined_section here,
4225 we have to use absolute_section, because otherwise
4226 generic as code will make it a COM section.
4227 We fix this up in sparc_adjust_symtab. */
4228 S_SET_SEGMENT (globals[reg], absolute_section);
4229 S_SET_OTHER (globals[reg], 0);
4230 elf_symbol (symbol_get_bfdsym (globals[reg]))
4231 ->internal_elf_sym.st_info =
4232 ELF_ST_INFO(STB_GLOBAL, STT_REGISTER);
4233 elf_symbol (symbol_get_bfdsym (globals[reg]))
4234 ->internal_elf_sym.st_shndx = SHN_UNDEF;
4235 }
4236 }
4237 }
4238
4239 *input_line_pointer = c;
4240
4241 demand_empty_rest_of_line ();
4242 }
4243
4244 /* Adjust the symbol table. We set undefined sections for STT_REGISTER
4245 symbols which need it. */
4246
4247 void
4248 sparc_adjust_symtab ()
4249 {
4250 symbolS *sym;
4251
4252 for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
4253 {
4254 if (ELF_ST_TYPE (elf_symbol (symbol_get_bfdsym (sym))
4255 ->internal_elf_sym.st_info) != STT_REGISTER)
4256 continue;
4257
4258 if (ELF_ST_TYPE (elf_symbol (symbol_get_bfdsym (sym))
4259 ->internal_elf_sym.st_shndx != SHN_UNDEF))
4260 continue;
4261
4262 S_SET_SEGMENT (sym, undefined_section);
4263 }
4264 }
4265 #endif
4266
4267 /* If the --enforce-aligned-data option is used, we require .word,
4268 et. al., to be aligned correctly. We do it by setting up an
4269 rs_align_code frag, and checking in HANDLE_ALIGN to make sure that
4270 no unexpected alignment was introduced.
4271
4272 The SunOS and Solaris native assemblers enforce aligned data by
4273 default. We don't want to do that, because gcc can deliberately
4274 generate misaligned data if the packed attribute is used. Instead,
4275 we permit misaligned data by default, and permit the user to set an
4276 option to check for it. */
4277
4278 void
4279 sparc_cons_align (nbytes)
4280 int nbytes;
4281 {
4282 int nalign;
4283 char *p;
4284
4285 /* Only do this if we are enforcing aligned data. */
4286 if (! enforce_aligned_data)
4287 return;
4288
4289 /* Don't align if this is an unaligned pseudo-op. */
4290 if (sparc_no_align_cons)
4291 return;
4292
4293 nalign = mylog2 (nbytes);
4294 if (nalign == 0)
4295 return;
4296
4297 assert (nalign > 0);
4298
4299 if (now_seg == absolute_section)
4300 {
4301 if ((abs_section_offset & ((1 << nalign) - 1)) != 0)
4302 as_bad (_("misaligned data"));
4303 return;
4304 }
4305
4306 p = frag_var (rs_align_test, 1, 1, (relax_substateT) 0,
4307 (symbolS *) NULL, (offsetT) nalign, (char *) NULL);
4308
4309 record_alignment (now_seg, nalign);
4310 }
4311
4312 /* This is called from HANDLE_ALIGN in tc-sparc.h. */
4313
4314 void
4315 sparc_handle_align (fragp)
4316 fragS *fragp;
4317 {
4318 int count, fix;
4319 char *p;
4320
4321 count = fragp->fr_next->fr_address - fragp->fr_address - fragp->fr_fix;
4322
4323 switch (fragp->fr_type)
4324 {
4325 case rs_align_test:
4326 if (count != 0)
4327 as_bad_where (fragp->fr_file, fragp->fr_line, _("misaligned data"));
4328 break;
4329
4330 case rs_align_code:
4331 p = fragp->fr_literal + fragp->fr_fix;
4332 fix = 0;
4333
4334 if (count & 3)
4335 {
4336 fix = count & 3;
4337 memset (p, 0, fix);
4338 p += fix;
4339 count -= fix;
4340 }
4341
4342 if (SPARC_OPCODE_ARCH_V9_P (max_architecture) && count > 8)
4343 {
4344 unsigned wval = (0x30680000 | count >> 2); /* ba,a,pt %xcc, 1f */
4345 if (INSN_BIG_ENDIAN)
4346 number_to_chars_bigendian (p, wval, 4);
4347 else
4348 number_to_chars_littleendian (p, wval, 4);
4349 p += 4;
4350 count -= 4;
4351 fix += 4;
4352 }
4353
4354 if (INSN_BIG_ENDIAN)
4355 number_to_chars_bigendian (p, 0x01000000, 4);
4356 else
4357 number_to_chars_littleendian (p, 0x01000000, 4);
4358
4359 fragp->fr_fix += fix;
4360 fragp->fr_var = 4;
4361 break;
4362
4363 default:
4364 break;
4365 }
4366 }
4367
4368 #ifdef OBJ_ELF
4369 /* Some special processing for a Sparc ELF file. */
4370
4371 void
4372 sparc_elf_final_processing ()
4373 {
4374 /* Set the Sparc ELF flag bits. FIXME: There should probably be some
4375 sort of BFD interface for this. */
4376 if (sparc_arch_size == 64)
4377 {
4378 switch (sparc_memory_model)
4379 {
4380 case MM_RMO:
4381 elf_elfheader (stdoutput)->e_flags |= EF_SPARCV9_RMO;
4382 break;
4383 case MM_PSO:
4384 elf_elfheader (stdoutput)->e_flags |= EF_SPARCV9_PSO;
4385 break;
4386 default:
4387 break;
4388 }
4389 }
4390 else if (current_architecture >= SPARC_OPCODE_ARCH_V9)
4391 elf_elfheader (stdoutput)->e_flags |= EF_SPARC_32PLUS;
4392 if (current_architecture == SPARC_OPCODE_ARCH_V9A)
4393 elf_elfheader (stdoutput)->e_flags |= EF_SPARC_SUN_US1;
4394 else if (current_architecture == SPARC_OPCODE_ARCH_V9B)
4395 elf_elfheader (stdoutput)->e_flags |= EF_SPARC_SUN_US1|EF_SPARC_SUN_US3;
4396 }
4397
4398 void
4399 sparc_cons (exp, size)
4400 expressionS *exp;
4401 int size;
4402 {
4403 char *save;
4404
4405 SKIP_WHITESPACE ();
4406 sparc_cons_special_reloc = NULL;
4407 save = input_line_pointer;
4408 if (input_line_pointer[0] == '%'
4409 && input_line_pointer[1] == 'r'
4410 && input_line_pointer[2] == '_')
4411 {
4412 if (strncmp (input_line_pointer + 3, "disp", 4) == 0)
4413 {
4414 input_line_pointer += 7;
4415 sparc_cons_special_reloc = "disp";
4416 }
4417 else if (strncmp (input_line_pointer + 3, "plt", 3) == 0)
4418 {
4419 if (size != 4 && size != 8)
4420 as_bad (_("Illegal operands: %%r_plt in %d-byte data field"), size);
4421 else
4422 {
4423 input_line_pointer += 6;
4424 sparc_cons_special_reloc = "plt";
4425 }
4426 }
4427 else if (strncmp (input_line_pointer + 3, "tls_dtpoff", 10) == 0)
4428 {
4429 if (size != 4 && size != 8)
4430 as_bad (_("Illegal operands: %%r_tls_dtpoff in %d-byte data field"), size);
4431 else
4432 {
4433 input_line_pointer += 13;
4434 sparc_cons_special_reloc = "tls_dtpoff";
4435 }
4436 }
4437 if (sparc_cons_special_reloc)
4438 {
4439 int bad = 0;
4440
4441 switch (size)
4442 {
4443 case 1:
4444 if (*input_line_pointer != '8')
4445 bad = 1;
4446 input_line_pointer--;
4447 break;
4448 case 2:
4449 if (input_line_pointer[0] != '1' || input_line_pointer[1] != '6')
4450 bad = 1;
4451 break;
4452 case 4:
4453 if (input_line_pointer[0] != '3' || input_line_pointer[1] != '2')
4454 bad = 1;
4455 break;
4456 case 8:
4457 if (input_line_pointer[0] != '6' || input_line_pointer[1] != '4')
4458 bad = 1;
4459 break;
4460 default:
4461 bad = 1;
4462 break;
4463 }
4464
4465 if (bad)
4466 {
4467 as_bad (_("Illegal operands: Only %%r_%s%d allowed in %d-byte data fields"),
4468 sparc_cons_special_reloc, size * 8, size);
4469 }
4470 else
4471 {
4472 input_line_pointer += 2;
4473 if (*input_line_pointer != '(')
4474 {
4475 as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"),
4476 sparc_cons_special_reloc, size * 8);
4477 bad = 1;
4478 }
4479 }
4480
4481 if (bad)
4482 {
4483 input_line_pointer = save;
4484 sparc_cons_special_reloc = NULL;
4485 }
4486 else
4487 {
4488 int c;
4489 char *end = ++input_line_pointer;
4490 int npar = 0;
4491
4492 while (! is_end_of_line[(c = *end)])
4493 {
4494 if (c == '(')
4495 npar++;
4496 else if (c == ')')
4497 {
4498 if (!npar)
4499 break;
4500 npar--;
4501 }
4502 end++;
4503 }
4504
4505 if (c != ')')
4506 as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"),
4507 sparc_cons_special_reloc, size * 8);
4508 else
4509 {
4510 *end = '\0';
4511 expression (exp);
4512 *end = c;
4513 if (input_line_pointer != end)
4514 {
4515 as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"),
4516 sparc_cons_special_reloc, size * 8);
4517 }
4518 else
4519 {
4520 input_line_pointer++;
4521 SKIP_WHITESPACE ();
4522 c = *input_line_pointer;
4523 if (! is_end_of_line[c] && c != ',')
4524 as_bad (_("Illegal operands: garbage after %%r_%s%d()"),
4525 sparc_cons_special_reloc, size * 8);
4526 }
4527 }
4528 }
4529 }
4530 }
4531 if (sparc_cons_special_reloc == NULL)
4532 expression (exp);
4533 }
4534
4535 #endif
4536
4537 /* This is called by emit_expr via TC_CONS_FIX_NEW when creating a
4538 reloc for a cons. We could use the definition there, except that
4539 we want to handle little endian relocs specially. */
4540
4541 void
4542 cons_fix_new_sparc (frag, where, nbytes, exp)
4543 fragS *frag;
4544 int where;
4545 unsigned int nbytes;
4546 expressionS *exp;
4547 {
4548 bfd_reloc_code_real_type r;
4549
4550 r = (nbytes == 1 ? BFD_RELOC_8 :
4551 (nbytes == 2 ? BFD_RELOC_16 :
4552 (nbytes == 4 ? BFD_RELOC_32 : BFD_RELOC_64)));
4553
4554 if (target_little_endian_data
4555 && nbytes == 4
4556 && now_seg->flags & SEC_ALLOC)
4557 r = BFD_RELOC_SPARC_REV32;
4558
4559 if (sparc_cons_special_reloc)
4560 {
4561 if (*sparc_cons_special_reloc == 'd')
4562 switch (nbytes)
4563 {
4564 case 1: r = BFD_RELOC_8_PCREL; break;
4565 case 2: r = BFD_RELOC_16_PCREL; break;
4566 case 4: r = BFD_RELOC_32_PCREL; break;
4567 case 8: r = BFD_RELOC_64_PCREL; break;
4568 default: abort ();
4569 }
4570 else if (*sparc_cons_special_reloc == 'p')
4571 switch (nbytes)
4572 {
4573 case 4: r = BFD_RELOC_SPARC_PLT32; break;
4574 case 8: r = BFD_RELOC_SPARC_PLT64; break;
4575 }
4576 else
4577 switch (nbytes)
4578 {
4579 case 4: r = BFD_RELOC_SPARC_TLS_DTPOFF32; break;
4580 case 8: r = BFD_RELOC_SPARC_TLS_DTPOFF64; break;
4581 }
4582 }
4583 else if (sparc_no_align_cons)
4584 {
4585 switch (nbytes)
4586 {
4587 case 2: r = BFD_RELOC_SPARC_UA16; break;
4588 case 4: r = BFD_RELOC_SPARC_UA32; break;
4589 case 8: r = BFD_RELOC_SPARC_UA64; break;
4590 default: abort ();
4591 }
4592 }
4593
4594 fix_new_exp (frag, where, (int) nbytes, exp, 0, r);
4595 sparc_cons_special_reloc = NULL;
4596 }
4597
4598 void
4599 sparc_cfi_frame_initial_instructions ()
4600 {
4601 cfi_add_CFA_def_cfa (14, sparc_arch_size == 64 ? 0x7ff : 0);
4602 }
4603
4604 int
4605 sparc_regname_to_dw2regnum (const char *regname)
4606 {
4607 char *p, *q;
4608
4609 if (!regname[0])
4610 return -1;
4611
4612 q = "goli";
4613 p = strchr (q, regname[0]);
4614 if (p)
4615 {
4616 if (regname[1] < '0' || regname[1] > '8' || regname[2])
4617 return -1;
4618 return (p - q) * 8 + regname[1] - '0';
4619 }
4620 if (regname[0] == 's' && regname[1] == 'p' && !regname[2])
4621 return 14;
4622 if (regname[0] == 'f' && regname[1] == 'p' && !regname[2])
4623 return 30;
4624 if (regname[0] == 'f' || regname[0] == 'r')
4625 {
4626 unsigned int regnum;
4627
4628 regnum = strtoul (regname + 1, &q, 10);
4629 if (p == q || *q)
4630 return -1;
4631 if (regnum >= ((regname[0] == 'f'
4632 && SPARC_OPCODE_ARCH_V9_P (max_architecture))
4633 ? 64 : 32))
4634 return -1;
4635 if (regname[0] == 'f')
4636 {
4637 regnum += 32;
4638 if (regnum >= 64 && (regnum & 1))
4639 return -1;
4640 }
4641 return regnum;
4642 }
4643 return -1;
4644 }
4645
4646 void
4647 sparc_cfi_emit_pcrel_expr (expressionS *exp, unsigned int nbytes)
4648 {
4649 sparc_cons_special_reloc = "disp";
4650 sparc_no_align_cons = 1;
4651 emit_expr (exp, nbytes);
4652 sparc_no_align_cons = 0;
4653 sparc_cons_special_reloc = NULL;
4654 }
git-cvsimport of binutils cvsroot