projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* config/tc-sparc.c (md_shortopts): Add "K:" if OBJ_ELF.
[deliverable/binutils-gdb.git] / gas / config / tc-sparc.c
1 /* tc-sparc.c -- Assemble for the SPARC
2 Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
3
4 This file is part of GAS, the GNU Assembler.
5
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19
20 #include <stdio.h>
21 #include <ctype.h>
22
23 #include "as.h"
24 #include "subsegs.h"
25
26 /* careful, this file includes data *declarations* */
27 #include "opcode/sparc.h"
28
29 static void sparc_ip PARAMS ((char *));
30
31 #ifdef sparcv9
32 static enum sparc_architecture current_architecture = v9;
33 #else
34 static enum sparc_architecture current_architecture = v6;
35 #endif
36 static int architecture_requested;
37 static int warn_on_bump;
38
39 extern int target_big_endian;
40
41 /* handle of the OPCODE hash table */
42 static struct hash_control *op_hash;
43
44 static void s_data1 PARAMS ((void));
45 static void s_seg PARAMS ((int));
46 static void s_proc PARAMS ((int));
47 static void s_reserve PARAMS ((int));
48 static void s_common PARAMS ((int));
49
50 const pseudo_typeS md_pseudo_table[] =
51 {
52 {"align", s_align_bytes, 0}, /* Defaulting is invalid (0) */
53 {"common", s_common, 0},
54 {"global", s_globl, 0},
55 {"half", cons, 2},
56 {"optim", s_ignore, 0},
57 {"proc", s_proc, 0},
58 {"reserve", s_reserve, 0},
59 {"seg", s_seg, 0},
60 {"skip", s_space, 0},
61 {"word", cons, 4},
62 #ifndef NO_V9
63 {"xword", cons, 8},
64 #ifdef OBJ_ELF
65 {"uaxword", cons, 8},
66 #endif
67 #endif
68 #ifdef OBJ_ELF
69 /* these are specific to sparc/svr4 */
70 {"pushsection", obj_elf_section, 0},
71 {"popsection", obj_elf_previous, 0},
72 {"uaword", cons, 4},
73 {"uahalf", cons, 2},
74 #endif
75 {NULL, 0, 0},
76 };
77
78 const int md_reloc_size = 12; /* Size of relocation record */
79
80 /* This array holds the chars that always start a comment. If the
81 pre-processor is disabled, these aren't very useful */
82 const char comment_chars[] = "!"; /* JF removed '|' from comment_chars */
83
84 /* This array holds the chars that only start a comment at the beginning of
85 a line. If the line seems to have the form '# 123 filename'
86 .line and .file directives will appear in the pre-processed output */
87 /* Note that input_file.c hand checks for '#' at the beginning of the
88 first line of the input file. This is because the compiler outputs
89 #NO_APP at the beginning of its output. */
90 /* Also note that comments started like this one will always
91 work if '/' isn't otherwise defined. */
92 const char line_comment_chars[] = "#";
93
94 const char line_separator_chars[] = "";
95
96 /* Chars that can be used to separate mant from exp in floating point nums */
97 const char EXP_CHARS[] = "eE";
98
99 /* Chars that mean this number is a floating point constant */
100 /* As in 0f12.456 */
101 /* or 0d1.2345e12 */
102 const char FLT_CHARS[] = "rRsSfFdDxXpP";
103
104 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
105 changed in read.c. Ideally it shouldn't have to know about it at all,
106 but nothing is ideal around here. */
107
108 static unsigned char octal[256];
109 #define isoctal(c) octal[(unsigned char) (c)]
110 static unsigned char toHex[256];
111
112 struct sparc_it
113 {
114 char *error;
115 unsigned long opcode;
116 struct nlist *nlistp;
117 expressionS exp;
118 int pcrel;
119 bfd_reloc_code_real_type reloc;
120 };
121
122 struct sparc_it the_insn, set_insn;
123
124 static INLINE int
125 in_signed_range (val, max)
126 bfd_signed_vma val, max;
127 {
128 if (max <= 0)
129 abort ();
130 if (val > max)
131 return 0;
132 if (val < ~max)
133 return 0;
134 return 1;
135 }
136
137 #if 0
138 static void print_insn PARAMS ((struct sparc_it *insn));
139 #endif
140 static int getExpression PARAMS ((char *str));
141
142 static char *expr_end;
143 static int special_case;
144
145 /*
146 * Instructions that require wierd handling because they're longer than
147 * 4 bytes.
148 */
149 #define SPECIAL_CASE_SET 1
150 #define SPECIAL_CASE_FDIV 2
151
152 /*
153 * sort of like s_lcomm
154 *
155 */
156 #ifndef OBJ_ELF
157 static int max_alignment = 15;
158 #endif
159
160 static void
161 s_reserve (ignore)
162 int ignore;
163 {
164 char *name;
165 char *p;
166 char c;
167 int align;
168 int size;
169 int temp;
170 symbolS *symbolP;
171
172 name = input_line_pointer;
173 c = get_symbol_end ();
174 p = input_line_pointer;
175 *p = c;
176 SKIP_WHITESPACE ();
177
178 if (*input_line_pointer != ',')
179 {
180 as_bad ("Expected comma after name");
181 ignore_rest_of_line ();
182 return;
183 }
184
185 ++input_line_pointer;
186
187 if ((size = get_absolute_expression ()) < 0)
188 {
189 as_bad ("BSS length (%d.) <0! Ignored.", size);
190 ignore_rest_of_line ();
191 return;
192 } /* bad length */
193
194 *p = 0;
195 symbolP = symbol_find_or_make (name);
196 *p = c;
197
198 if (strncmp (input_line_pointer, ",\"bss\"", 6) != 0
199 && strncmp (input_line_pointer, ",\".bss\"", 7) != 0)
200 {
201 as_bad ("bad .reserve segment -- expected BSS segment");
202 return;
203 }
204
205 if (input_line_pointer[2] == '.')
206 input_line_pointer += 7;
207 else
208 input_line_pointer += 6;
209 SKIP_WHITESPACE ();
210
211 if (*input_line_pointer == ',')
212 {
213 ++input_line_pointer;
214
215 SKIP_WHITESPACE ();
216 if (*input_line_pointer == '\n')
217 {
218 as_bad ("Missing alignment");
219 return;
220 }
221
222 align = get_absolute_expression ();
223 #ifndef OBJ_ELF
224 if (align > max_alignment)
225 {
226 align = max_alignment;
227 as_warn ("Alignment too large: %d. assumed.", align);
228 }
229 #endif
230 if (align < 0)
231 {
232 align = 0;
233 as_warn ("Alignment negative. 0 assumed.");
234 }
235
236 record_alignment (bss_section, align);
237
238 /* convert to a power of 2 alignment */
239 for (temp = 0; (align & 1) == 0; align >>= 1, ++temp);;
240
241 if (align != 1)
242 {
243 as_bad ("Alignment not a power of 2");
244 ignore_rest_of_line ();
245 return;
246 } /* not a power of two */
247
248 align = temp;
249 } /* if has optional alignment */
250 else
251 align = 0;
252
253 if ((S_GET_SEGMENT (symbolP) == bss_section
254 || !S_IS_DEFINED (symbolP))
255 #ifdef OBJ_AOUT
256 && S_GET_OTHER (symbolP) == 0
257 && S_GET_DESC (symbolP) == 0
258 #endif
259 )
260 {
261 if (! need_pass_2)
262 {
263 char *pfrag;
264 segT current_seg = now_seg;
265 subsegT current_subseg = now_subseg;
266
267 subseg_set (bss_section, 1); /* switch to bss */
268
269 if (align)
270 frag_align (align, 0); /* do alignment */
271
272 /* detach from old frag */
273 if (S_GET_SEGMENT(symbolP) == bss_section)
274 symbolP->sy_frag->fr_symbol = NULL;
275
276 symbolP->sy_frag = frag_now;
277 pfrag = frag_var (rs_org, 1, 1, (relax_substateT)0, symbolP,
278 size, (char *)0);
279 *pfrag = 0;
280
281 S_SET_SEGMENT (symbolP, bss_section);
282
283 subseg_set (current_seg, current_subseg);
284 }
285 }
286 else
287 {
288 as_warn("Ignoring attempt to re-define symbol %s.", name);
289 } /* if not redefining */
290
291 demand_empty_rest_of_line ();
292 }
293
294 static void
295 s_common (ignore)
296 int ignore;
297 {
298 char *name;
299 char c;
300 char *p;
301 int temp, size;
302 symbolS *symbolP;
303
304 name = input_line_pointer;
305 c = get_symbol_end ();
306 /* just after name is now '\0' */
307 p = input_line_pointer;
308 *p = c;
309 SKIP_WHITESPACE ();
310 if (*input_line_pointer != ',')
311 {
312 as_bad ("Expected comma after symbol-name");
313 ignore_rest_of_line ();
314 return;
315 }
316 input_line_pointer++; /* skip ',' */
317 if ((temp = get_absolute_expression ()) < 0)
318 {
319 as_bad (".COMMon length (%d.) <0! Ignored.", temp);
320 ignore_rest_of_line ();
321 return;
322 }
323 size = temp;
324 *p = 0;
325 symbolP = symbol_find_or_make (name);
326 *p = c;
327 if (S_IS_DEFINED (symbolP))
328 {
329 as_bad ("Ignoring attempt to re-define symbol");
330 ignore_rest_of_line ();
331 return;
332 }
333 if (S_GET_VALUE (symbolP) != 0)
334 {
335 if (S_GET_VALUE (symbolP) != size)
336 {
337 as_warn ("Length of .comm \"%s\" is already %ld. Not changed to %d.",
338 S_GET_NAME (symbolP), (long) S_GET_VALUE (symbolP), size);
339 }
340 }
341 else
342 {
343 #ifndef OBJ_ELF
344 S_SET_VALUE (symbolP, (valueT) size);
345 S_SET_EXTERNAL (symbolP);
346 #endif
347 }
348 know (symbolP->sy_frag == &zero_address_frag);
349 if (*input_line_pointer != ',')
350 {
351 as_bad ("Expected comma after common length");
352 ignore_rest_of_line ();
353 return;
354 }
355 input_line_pointer++;
356 SKIP_WHITESPACE ();
357 if (*input_line_pointer != '"')
358 {
359 temp = get_absolute_expression ();
360 #ifndef OBJ_ELF
361 if (temp > max_alignment)
362 {
363 temp = max_alignment;
364 as_warn ("Common alignment too large: %d. assumed", temp);
365 }
366 #endif
367 if (temp < 0)
368 {
369 temp = 0;
370 as_warn ("Common alignment negative; 0 assumed");
371 }
372 #ifdef OBJ_ELF
373 if (symbolP->local)
374 {
375 segT old_sec;
376 int old_subsec;
377 char *p;
378 int align;
379
380 allocate_bss:
381 old_sec = now_seg;
382 old_subsec = now_subseg;
383 align = temp;
384 record_alignment (bss_section, align);
385 subseg_set (bss_section, 0);
386 if (align)
387 frag_align (align, 0);
388 if (S_GET_SEGMENT (symbolP) == bss_section)
389 symbolP->sy_frag->fr_symbol = 0;
390 symbolP->sy_frag = frag_now;
391 p = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP, size,
392 (char *) 0);
393 *p = 0;
394 S_SET_SEGMENT (symbolP, bss_section);
395 S_CLEAR_EXTERNAL (symbolP);
396 subseg_set (old_sec, old_subsec);
397 }
398 else
399 #endif
400 {
401 allocate_common:
402 S_SET_VALUE (symbolP, (valueT) size);
403 #ifdef OBJ_ELF
404 S_SET_ALIGN (symbolP, temp);
405 #endif
406 S_SET_EXTERNAL (symbolP);
407 /* should be common, but this is how gas does it for now */
408 S_SET_SEGMENT (symbolP, bfd_und_section_ptr);
409 }
410 }
411 else
412 {
413 input_line_pointer++;
414 /* @@ Some use the dot, some don't. Can we get some consistency?? */
415 if (*input_line_pointer == '.')
416 input_line_pointer++;
417 /* @@ Some say data, some say bss. */
418 if (strncmp (input_line_pointer, "bss\"", 4)
419 && strncmp (input_line_pointer, "data\"", 5))
420 {
421 while (*--input_line_pointer != '"')
422 ;
423 input_line_pointer--;
424 goto bad_common_segment;
425 }
426 while (*input_line_pointer++ != '"')
427 ;
428 goto allocate_common;
429 }
430 demand_empty_rest_of_line ();
431 return;
432
433 {
434 bad_common_segment:
435 p = input_line_pointer;
436 while (*p && *p != '\n')
437 p++;
438 c = *p;
439 *p = '\0';
440 as_bad ("bad .common segment %s", input_line_pointer + 1);
441 *p = c;
442 input_line_pointer = p;
443 ignore_rest_of_line ();
444 return;
445 }
446 }
447
448 static void
449 s_seg (ignore)
450 int ignore;
451 {
452
453 if (strncmp (input_line_pointer, "\"text\"", 6) == 0)
454 {
455 input_line_pointer += 6;
456 s_text (0);
457 return;
458 }
459 if (strncmp (input_line_pointer, "\"data\"", 6) == 0)
460 {
461 input_line_pointer += 6;
462 s_data (0);
463 return;
464 }
465 if (strncmp (input_line_pointer, "\"data1\"", 7) == 0)
466 {
467 input_line_pointer += 7;
468 s_data1 ();
469 return;
470 }
471 if (strncmp (input_line_pointer, "\"bss\"", 5) == 0)
472 {
473 input_line_pointer += 5;
474 /* We only support 2 segments -- text and data -- for now, so
475 things in the "bss segment" will have to go into data for now.
476 You can still allocate SEG_BSS stuff with .lcomm or .reserve. */
477 subseg_set (data_section, 255); /* FIXME-SOMEDAY */
478 return;
479 }
480 as_bad ("Unknown segment type");
481 demand_empty_rest_of_line ();
482 }
483
484 static void
485 s_data1 ()
486 {
487 subseg_set (data_section, 1);
488 demand_empty_rest_of_line ();
489 }
490
491 static void
492 s_proc (ignore)
493 int ignore;
494 {
495 while (!is_end_of_line[(unsigned char) *input_line_pointer])
496 {
497 ++input_line_pointer;
498 }
499 ++input_line_pointer;
500 }
501
502 #ifndef NO_V9
503
504 struct priv_reg_entry
505 {
506 char *name;
507 int regnum;
508 };
509
510 struct priv_reg_entry priv_reg_table[] =
511 {
512 {"tpc", 0},
513 {"tnpc", 1},
514 {"tstate", 2},
515 {"tt", 3},
516 {"tick", 4},
517 {"tba", 5},
518 {"pstate", 6},
519 {"tl", 7},
520 {"pil", 8},
521 {"cwp", 9},
522 {"cansave", 10},
523 {"canrestore", 11},
524 {"cleanwin", 12},
525 {"otherwin", 13},
526 {"wstate", 14},
527 {"fq", 15},
528 {"ver", 31},
529 {"", -1}, /* end marker */
530 };
531
532 struct membar_masks
533 {
534 char *name;
535 unsigned int len;
536 unsigned int mask;
537 };
538
539 #define MEMBAR_MASKS_SIZE 7
540
541 static const struct membar_masks membar_masks[MEMBAR_MASKS_SIZE] =
542 {
543 {"Sync", 4, 0x40},
544 {"MemIssue", 8, 0x20},
545 {"Lookaside", 9, 0x10},
546 {"StoreStore", 10, 0x08},
547 {"LoadStore", 9, 0x04},
548 {"StoreLoad", 9, 0x02},
549 {"LoadLoad", 8, 0x01},
550 };
551
552 static int
553 cmp_reg_entry (p, q)
554 struct priv_reg_entry *p, *q;
555 {
556 return strcmp (q->name, p->name);
557 }
558
559 #endif
560
561 /* This function is called once, at assembler startup time. It should
562 set up all the tables, etc. that the MD part of the assembler will need. */
563 void
564 md_begin ()
565 {
566 register const char *retval = NULL;
567 int lose = 0;
568 register unsigned int i = 0;
569
570 op_hash = hash_new ();
571
572 while (i < NUMOPCODES)
573 {
574 const char *name = sparc_opcodes[i].name;
575 retval = hash_insert (op_hash, name, &sparc_opcodes[i]);
576 if (retval != NULL)
577 {
578 fprintf (stderr, "internal error: can't hash `%s': %s\n",
579 sparc_opcodes[i].name, retval);
580 lose = 1;
581 }
582 do
583 {
584 if (sparc_opcodes[i].match & sparc_opcodes[i].lose)
585 {
586 fprintf (stderr, "internal error: losing opcode: `%s' \"%s\"\n",
587 sparc_opcodes[i].name, sparc_opcodes[i].args);
588 lose = 1;
589 }
590 ++i;
591 }
592 while (i < NUMOPCODES
593 && !strcmp (sparc_opcodes[i].name, name));
594 }
595
596 if (lose)
597 as_fatal ("Broken assembler. No assembly attempted.");
598
599 for (i = '0'; i < '8'; ++i)
600 octal[i] = 1;
601 for (i = '0'; i <= '9'; ++i)
602 toHex[i] = i - '0';
603 for (i = 'a'; i <= 'f'; ++i)
604 toHex[i] = i + 10 - 'a';
605 for (i = 'A'; i <= 'F'; ++i)
606 toHex[i] = i + 10 - 'A';
607
608 #ifndef NO_V9
609 qsort (priv_reg_table, sizeof (priv_reg_table) / sizeof (priv_reg_table[0]),
610 sizeof (priv_reg_table[0]), cmp_reg_entry);
611 #endif
612
613 target_big_endian = 1;
614 }
615
616 void
617 md_assemble (str)
618 char *str;
619 {
620 char *toP;
621 int rsd;
622
623 know (str);
624 sparc_ip (str);
625
626 /* See if "set" operand is absolute and small; skip sethi if so. */
627 if (special_case == SPECIAL_CASE_SET
628 && the_insn.exp.X_op == O_constant)
629 {
630 if (the_insn.exp.X_add_number >= -(1 << 12)
631 && the_insn.exp.X_add_number < (1 << 12))
632 {
633 the_insn.opcode = 0x80102000 /* or %g0,imm,... */
634 | (the_insn.opcode & 0x3E000000) /* dest reg */
635 | (the_insn.exp.X_add_number & 0x1FFF); /* imm */
636 special_case = 0; /* No longer special */
637 the_insn.reloc = BFD_RELOC_NONE; /* No longer relocated */
638 }
639 }
640
641 toP = frag_more (4);
642 /* put out the opcode */
643 md_number_to_chars (toP, (valueT) the_insn.opcode, 4);
644
645 /* put out the symbol-dependent stuff */
646 if (the_insn.reloc != BFD_RELOC_NONE)
647 {
648 fix_new_exp (frag_now, /* which frag */
649 (toP - frag_now->fr_literal), /* where */
650 4, /* size */
651 &the_insn.exp,
652 the_insn.pcrel,
653 the_insn.reloc);
654 }
655
656 switch (special_case)
657 {
658 case SPECIAL_CASE_SET:
659 special_case = 0;
660 assert (the_insn.reloc == BFD_RELOC_HI22);
661 /* See if "set" operand has no low-order bits; skip OR if so. */
662 if (the_insn.exp.X_op == O_constant
663 && ((the_insn.exp.X_add_number & 0x3FF) == 0))
664 return;
665 toP = frag_more (4);
666 rsd = (the_insn.opcode >> 25) & 0x1f;
667 the_insn.opcode = 0x80102000 | (rsd << 25) | (rsd << 14);
668 md_number_to_chars (toP, (valueT) the_insn.opcode, 4);
669 fix_new_exp (frag_now, /* which frag */
670 (toP - frag_now->fr_literal), /* where */
671 4, /* size */
672 &the_insn.exp,
673 the_insn.pcrel,
674 BFD_RELOC_LO10);
675 return;
676
677 case SPECIAL_CASE_FDIV:
678 /* According to information leaked from Sun, the "fdiv" instructions
679 on early SPARC machines would produce incorrect results sometimes.
680 The workaround is to add an fmovs of the destination register to
681 itself just after the instruction. This was true on machines
682 with Weitek 1165 float chips, such as the Sun-4/260 and /280. */
683 special_case = 0;
684 assert (the_insn.reloc == BFD_RELOC_NONE);
685 toP = frag_more (4);
686 rsd = (the_insn.opcode >> 25) & 0x1f;
687 the_insn.opcode = 0x81A00020 | (rsd << 25) | rsd; /* fmovs dest,dest */
688 md_number_to_chars (toP, (valueT) the_insn.opcode, 4);
689 return;
690
691 case 0:
692 return;
693
694 default:
695 as_fatal ("failed sanity check.");
696 }
697 }
698
699 /* Implement big shift right. */
700 static bfd_vma
701 BSR (val, amount)
702 bfd_vma val;
703 int amount;
704 {
705 if (sizeof (bfd_vma) <= 4 && amount >= 32)
706 as_fatal ("Support for 64-bit arithmetic not compiled in.");
707 return val >> amount;
708 }
709
710 static void
711 sparc_ip (str)
712 char *str;
713 {
714 char *error_message = "";
715 char *s;
716 const char *args;
717 char c;
718 const struct sparc_opcode *insn;
719 char *argsStart;
720 unsigned long opcode;
721 unsigned int mask = 0;
722 int match = 0;
723 int comma = 0;
724 long immediate_max = 0;
725
726 for (s = str; islower (*s) || (*s >= '0' && *s <= '3'); ++s)
727 ;
728 switch (*s)
729 {
730
731 case '\0':
732 break;
733
734 case ',':
735 comma = 1;
736
737 /*FALLTHROUGH */
738
739 case ' ':
740 *s++ = '\0';
741 break;
742
743 default:
744 as_fatal ("Unknown opcode: `%s'", str);
745 }
746 insn = (struct sparc_opcode *) hash_find (op_hash, str);
747 if (insn == NULL)
748 {
749 as_bad ("Unknown opcode: `%s'", str);
750 return;
751 }
752 if (comma)
753 {
754 *--s = ',';
755 }
756 argsStart = s;
757 for (;;)
758 {
759 opcode = insn->match;
760 memset (&the_insn, '\0', sizeof (the_insn));
761 the_insn.reloc = BFD_RELOC_NONE;
762
763 /*
764 * Build the opcode, checking as we go to make
765 * sure that the operands match
766 */
767 for (args = insn->args;; ++args)
768 {
769 switch (*args)
770 {
771 #ifndef NO_V9
772 case 'K':
773 {
774 int kmask = 0;
775 int i;
776
777 /* Parse a series of masks. */
778 if (*s == '#')
779 {
780 while (*s == '#')
781 {
782 ++s;
783 for (i = 0; i < MEMBAR_MASKS_SIZE; i++)
784 if (!strncmp (s, membar_masks[i].name,
785 membar_masks[i].len))
786 break;
787 if (i < MEMBAR_MASKS_SIZE)
788 {
789 kmask |= membar_masks[i].mask;
790 s += membar_masks[i].len;
791 }
792 else
793 {
794 error_message = ": invalid membar mask name";
795 goto error;
796 }
797 if (*s == '|')
798 ++s;
799 }
800 }
801 else
802 {
803 expressionS exp;
804 char *hold;
805 char *send;
806
807 hold = input_line_pointer;
808 input_line_pointer = s;
809 expression (&exp);
810 send = input_line_pointer;
811 input_line_pointer = hold;
812
813 kmask = exp.X_add_number;
814 if (exp.X_op != O_constant
815 || kmask < 0
816 || kmask > 127)
817 {
818 error_message = ": invalid membar mask number";
819 goto error;
820 }
821
822 s = send;
823 }
824
825 opcode |= SIMM13 (kmask);
826 continue;
827 }
828
829 case '*':
830 {
831 int prefetch_fcn = 0;
832
833 /* Parse a prefetch function. */
834 if (*s == '#')
835 {
836 s += 1;
837 if (!strncmp (s, "n_reads", 7))
838 prefetch_fcn = 0, s += 7;
839 else if (!strncmp (s, "one_read", 8))
840 prefetch_fcn = 1, s += 8;
841 else if (!strncmp (s, "n_writes", 8))
842 prefetch_fcn = 2, s += 8;
843 else if (!strncmp (s, "one_write", 9))
844 prefetch_fcn = 3, s += 9;
845 else if (!strncmp (s, "page", 4))
846 prefetch_fcn = 4, s += 4;
847 else
848 {
849 error_message = ": invalid prefetch function name";
850 goto error;
851 }
852 }
853 else if (isdigit (*s))
854 {
855 while (isdigit (*s))
856 {
857 prefetch_fcn = prefetch_fcn * 10 + *s - '0';
858 ++s;
859 }
860
861 if (prefetch_fcn < 0 || prefetch_fcn > 31)
862 {
863 error_message = ": invalid prefetch function number";
864 goto error;
865 }
866 }
867 else
868 {
869 error_message = ": unrecognizable prefetch function";
870 goto error;
871 }
872 opcode |= RD (prefetch_fcn);
873 continue;
874 }
875
876 case '!':
877 case '?':
878 /* Parse a privileged register. */
879 if (*s == '%')
880 {
881 struct priv_reg_entry *p = priv_reg_table;
882 unsigned int len = 9999999; /* init to make gcc happy */
883
884 s += 1;
885 while (p->name[0] > s[0])
886 p++;
887 while (p->name[0] == s[0])
888 {
889 len = strlen (p->name);
890 if (strncmp (p->name, s, len) == 0)
891 break;
892 p++;
893 }
894 if (p->name[0] != s[0])
895 {
896 error_message = ": unrecognizable privileged register";
897 goto error;
898 }
899 if (*args == '?')
900 opcode |= (p->regnum << 14);
901 else
902 opcode |= (p->regnum << 25);
903 s += len;
904 continue;
905 }
906 else
907 {
908 error_message = ": unrecognizable privileged register";
909 goto error;
910 }
911 #endif
912
913 case 'M':
914 case 'm':
915 if (strncmp (s, "%asr", 4) == 0)
916 {
917 s += 4;
918
919 if (isdigit (*s))
920 {
921 long num = 0;
922
923 while (isdigit (*s))
924 {
925 num = num * 10 + *s - '0';
926 ++s;
927 }
928
929 if (num < 16 || 31 < num)
930 {
931 error_message = ": asr number must be between 15 and 31";
932 goto error;
933 } /* out of range */
934
935 opcode |= (*args == 'M' ? RS1 (num) : RD (num));
936 continue;
937 }
938 else
939 {
940 error_message = ": expecting %asrN";
941 goto error;
942 } /* if %asr followed by a number. */
943
944 } /* if %asr */
945 break;
946
947 #ifndef NO_V9
948 case 'I':
949 the_insn.reloc = BFD_RELOC_SPARC_11;
950 immediate_max = 0x03FF;
951 goto immediate;
952
953 case 'j':
954 the_insn.reloc = BFD_RELOC_SPARC_10;
955 immediate_max = 0x01FF;
956 goto immediate;
957
958 case 'k':
959 the_insn.reloc = /* RELOC_WDISP2_14 */ BFD_RELOC_SPARC_WDISP16;
960 the_insn.pcrel = 1;
961 goto immediate;
962
963 case 'G':
964 the_insn.reloc = BFD_RELOC_SPARC_WDISP19;
965 the_insn.pcrel = 1;
966 goto immediate;
967
968 case 'N':
969 if (*s == 'p' && s[1] == 'n')
970 {
971 s += 2;
972 continue;
973 }
974 break;
975
976 case 'T':
977 if (*s == 'p' && s[1] == 't')
978 {
979 s += 2;
980 continue;
981 }
982 break;
983
984 case 'z':
985 if (*s == ' ')
986 {
987 ++s;
988 }
989 if (strncmp (s, "%icc", 4) == 0)
990 {
991 s += 4;
992 continue;
993 }
994 break;
995
996 case 'Z':
997 if (*s == ' ')
998 {
999 ++s;
1000 }
1001 if (strncmp (s, "%xcc", 4) == 0)
1002 {
1003 s += 4;
1004 continue;
1005 }
1006 break;
1007
1008 case '6':
1009 if (*s == ' ')
1010 {
1011 ++s;
1012 }
1013 if (strncmp (s, "%fcc0", 5) == 0)
1014 {
1015 s += 5;
1016 continue;
1017 }
1018 break;
1019
1020 case '7':
1021 if (*s == ' ')
1022 {
1023 ++s;
1024 }
1025 if (strncmp (s, "%fcc1", 5) == 0)
1026 {
1027 s += 5;
1028 continue;
1029 }
1030 break;
1031
1032 case '8':
1033 if (*s == ' ')
1034 {
1035 ++s;
1036 }
1037 if (strncmp (s, "%fcc2", 5) == 0)
1038 {
1039 s += 5;
1040 continue;
1041 }
1042 break;
1043
1044 case '9':
1045 if (*s == ' ')
1046 {
1047 ++s;
1048 }
1049 if (strncmp (s, "%fcc3", 5) == 0)
1050 {
1051 s += 5;
1052 continue;
1053 }
1054 break;
1055
1056 case 'P':
1057 if (strncmp (s, "%pc", 3) == 0)
1058 {
1059 s += 3;
1060 continue;
1061 }
1062 break;
1063
1064 case 'W':
1065 if (strncmp (s, "%tick", 5) == 0)
1066 {
1067 s += 5;
1068 continue;
1069 }
1070 break;
1071 #endif /* NO_V9 */
1072
1073 case '\0': /* end of args */
1074 if (*s == '\0')
1075 {
1076 match = 1;
1077 }
1078 break;
1079
1080 case '+':
1081 if (*s == '+')
1082 {
1083 ++s;
1084 continue;
1085 }
1086 if (*s == '-')
1087 {
1088 continue;
1089 }
1090 break;
1091
1092 case '[': /* these must match exactly */
1093 case ']':
1094 case ',':
1095 case ' ':
1096 if (*s++ == *args)
1097 continue;
1098 break;
1099
1100 case '#': /* must be at least one digit */
1101 if (isdigit (*s++))
1102 {
1103 while (isdigit (*s))
1104 {
1105 ++s;
1106 }
1107 continue;
1108 }
1109 break;
1110
1111 case 'C': /* coprocessor state register */
1112 if (strncmp (s, "%csr", 4) == 0)
1113 {
1114 s += 4;
1115 continue;
1116 }
1117 break;
1118
1119 case 'b': /* next operand is a coprocessor register */
1120 case 'c':
1121 case 'D':
1122 if (*s++ == '%' && *s++ == 'c' && isdigit (*s))
1123 {
1124 mask = *s++;
1125 if (isdigit (*s))
1126 {
1127 mask = 10 * (mask - '0') + (*s++ - '0');
1128 if (mask >= 32)
1129 {
1130 break;
1131 }
1132 }
1133 else
1134 {
1135 mask -= '0';
1136 }
1137 switch (*args)
1138 {
1139
1140 case 'b':
1141 opcode |= mask << 14;
1142 continue;
1143
1144 case 'c':
1145 opcode |= mask;
1146 continue;
1147
1148 case 'D':
1149 opcode |= mask << 25;
1150 continue;
1151 }
1152 }
1153 break;
1154
1155 case 'r': /* next operand must be a register */
1156 case '1':
1157 case '2':
1158 case 'd':
1159 if (*s++ == '%')
1160 {
1161 switch (c = *s++)
1162 {
1163
1164 case 'f': /* frame pointer */
1165 if (*s++ == 'p')
1166 {
1167 mask = 0x1e;
1168 break;
1169 }
1170 goto error;
1171
1172 case 'g': /* global register */
1173 if (isoctal (c = *s++))
1174 {
1175 mask = c - '0';
1176 break;
1177 }
1178 goto error;
1179
1180 case 'i': /* in register */
1181 if (isoctal (c = *s++))
1182 {
1183 mask = c - '0' + 24;
1184 break;
1185 }
1186 goto error;
1187
1188 case 'l': /* local register */
1189 if (isoctal (c = *s++))
1190 {
1191 mask = (c - '0' + 16);
1192 break;
1193 }
1194 goto error;
1195
1196 case 'o': /* out register */
1197 if (isoctal (c = *s++))
1198 {
1199 mask = (c - '0' + 8);
1200 break;
1201 }
1202 goto error;
1203
1204 case 's': /* stack pointer */
1205 if (*s++ == 'p')
1206 {
1207 mask = 0xe;
1208 break;
1209 }
1210 goto error;
1211
1212 case 'r': /* any register */
1213 if (!isdigit (c = *s++))
1214 {
1215 goto error;
1216 }
1217 /* FALLTHROUGH */
1218 case '0':
1219 case '1':
1220 case '2':
1221 case '3':
1222 case '4':
1223 case '5':
1224 case '6':
1225 case '7':
1226 case '8':
1227 case '9':
1228 if (isdigit (*s))
1229 {
1230 if ((c = 10 * (c - '0') + (*s++ - '0')) >= 32)
1231 {
1232 goto error;
1233 }
1234 }
1235 else
1236 {
1237 c -= '0';
1238 }
1239 mask = c;
1240 break;
1241
1242 default:
1243 goto error;
1244 }
1245 /*
1246 * Got the register, now figure out where
1247 * it goes in the opcode.
1248 */
1249 switch (*args)
1250 {
1251
1252 case '1':
1253 opcode |= mask << 14;
1254 continue;
1255
1256 case '2':
1257 opcode |= mask;
1258 continue;
1259
1260 case 'd':
1261 opcode |= mask << 25;
1262 continue;
1263
1264 case 'r':
1265 opcode |= (mask << 25) | (mask << 14);
1266 continue;
1267 }
1268 }
1269 break;
1270
1271 case 'e': /* next operand is a floating point register */
1272 case 'v':
1273 case 'V':
1274
1275 case 'f':
1276 case 'B':
1277 case 'R':
1278
1279 case 'g':
1280 case 'H':
1281 case 'J':
1282 {
1283 char format;
1284
1285 if (*s++ == '%'
1286 && ((format = *s) == 'f')
1287 && isdigit (*++s))
1288 {
1289 for (mask = 0; isdigit (*s); ++s)
1290 {
1291 mask = 10 * mask + (*s - '0');
1292 } /* read the number */
1293
1294 if ((*args == 'v'
1295 || *args == 'B'
1296 || *args == 'H')
1297 && (mask & 1))
1298 {
1299 break;
1300 } /* register must be even numbered */
1301
1302 if ((*args == 'V'
1303 || *args == 'R'
1304 || *args == 'J')
1305 && (mask & 3))
1306 {
1307 break;
1308 } /* register must be multiple of 4 */
1309
1310 #ifndef NO_V9
1311 if (mask >= 64)
1312 {
1313 error_message = ": There are only 64 f registers; [0-63]";
1314 goto error;
1315 } /* on error */
1316 if (mask >= 32)
1317 {
1318 mask -= 31;
1319 } /* wrap high bit */
1320 #else
1321 if (mask >= 32)
1322 {
1323 error_message = ": There are only 32 f registers; [0-31]";
1324 goto error;
1325 } /* on error */
1326 #endif
1327 }
1328 else
1329 {
1330 break;
1331 } /* if not an 'f' register. */
1332
1333 switch (*args)
1334 {
1335
1336 case 'v':
1337 case 'V':
1338 case 'e':
1339 opcode |= RS1 (mask);
1340 continue;
1341
1342
1343 case 'f':
1344 case 'B':
1345 case 'R':
1346 opcode |= RS2 (mask);
1347 continue;
1348
1349 case 'g':
1350 case 'H':
1351 case 'J':
1352 opcode |= RD (mask);
1353 continue;
1354 } /* pack it in. */
1355
1356 know (0);
1357 break;
1358 } /* float arg */
1359
1360 case 'F':
1361 if (strncmp (s, "%fsr", 4) == 0)
1362 {
1363 s += 4;
1364 continue;
1365 }
1366 break;
1367
1368 case 'h': /* high 22 bits */
1369 the_insn.reloc = BFD_RELOC_HI22;
1370 goto immediate;
1371
1372 case 'l': /* 22 bit PC relative immediate */
1373 the_insn.reloc = BFD_RELOC_SPARC_WDISP22;
1374 the_insn.pcrel = 1;
1375 goto immediate;
1376
1377 case 'L': /* 30 bit immediate */
1378 the_insn.reloc = BFD_RELOC_32_PCREL_S2;
1379 the_insn.pcrel = 1;
1380 goto immediate;
1381
1382 case 'n': /* 22 bit immediate */
1383 the_insn.reloc = BFD_RELOC_SPARC22;
1384 goto immediate;
1385
1386 case 'i': /* 13 bit immediate */
1387 the_insn.reloc = BFD_RELOC_SPARC13;
1388 immediate_max = 0x0FFF;
1389
1390 /*FALLTHROUGH */
1391
1392 immediate:
1393 if (*s == ' ')
1394 s++;
1395 if (*s == '%')
1396 {
1397 if ((c = s[1]) == 'h' && s[2] == 'i')
1398 {
1399 the_insn.reloc = BFD_RELOC_HI22;
1400 s += 3;
1401 }
1402 else if (c == 'l' && s[2] == 'o')
1403 {
1404 the_insn.reloc = BFD_RELOC_LO10;
1405 s += 3;
1406 }
1407 #ifndef NO_V9
1408 else if (c == 'u'
1409 && s[2] == 'h'
1410 && s[3] == 'i')
1411 {
1412 the_insn.reloc = BFD_RELOC_SPARC_HH22;
1413 s += 4;
1414 }
1415 else if (c == 'u'
1416 && s[2] == 'l'
1417 && s[3] == 'o')
1418 {
1419 the_insn.reloc = BFD_RELOC_SPARC_HM10;
1420 s += 4;
1421 }
1422 #endif /* NO_V9 */
1423 else
1424 break;
1425 }
1426 /* Note that if the getExpression() fails, we will still
1427 have created U entries in the symbol table for the
1428 'symbols' in the input string. Try not to create U
1429 symbols for registers, etc. */
1430 {
1431 /* This stuff checks to see if the expression ends in
1432 +%reg. If it does, it removes the register from
1433 the expression, and re-sets 's' to point to the
1434 right place. */
1435
1436 char *s1;
1437
1438 for (s1 = s; *s1 && *s1 != ',' && *s1 != ']'; s1++);;
1439
1440 if (s1 != s && isdigit (s1[-1]))
1441 {
1442 if (s1[-2] == '%' && s1[-3] == '+')
1443 {
1444 s1 -= 3;
1445 *s1 = '\0';
1446 (void) getExpression (s);
1447 *s1 = '+';
1448 s = s1;
1449 continue;
1450 }
1451 else if (strchr ("goli0123456789", s1[-2]) && s1[-3] == '%' && s1[-4] == '+')
1452 {
1453 s1 -= 4;
1454 *s1 = '\0';
1455 (void) getExpression (s);
1456 *s1 = '+';
1457 s = s1;
1458 continue;
1459 }
1460 }
1461 }
1462 (void) getExpression (s);
1463 s = expr_end;
1464
1465 if (the_insn.exp.X_op == O_constant
1466 && the_insn.exp.X_add_symbol == 0
1467 && the_insn.exp.X_op_symbol == 0)
1468 {
1469 #ifndef NO_V9
1470 /* Handle %uhi/%ulo by moving the upper word to the lower
1471 one and pretending it's %hi/%lo. We also need to watch
1472 for %hi/%lo: the top word needs to be zeroed otherwise
1473 fixup_segment will complain the value is too big. */
1474 switch (the_insn.reloc)
1475 {
1476 case BFD_RELOC_SPARC_HH22:
1477 the_insn.reloc = BFD_RELOC_HI22;
1478 the_insn.exp.X_add_number = BSR (the_insn.exp.X_add_number, 32);
1479 break;
1480 case BFD_RELOC_SPARC_HM10:
1481 the_insn.reloc = BFD_RELOC_LO10;
1482 the_insn.exp.X_add_number = BSR (the_insn.exp.X_add_number, 32);
1483 break;
1484 default:
1485 break;
1486 case BFD_RELOC_HI22:
1487 case BFD_RELOC_LO10:
1488 the_insn.exp.X_add_number &= 0xffffffff;
1489 break;
1490 }
1491 #endif
1492 /* For pc-relative call instructions, we reject
1493 constants to get better code. */
1494 if (the_insn.pcrel
1495 && the_insn.reloc == BFD_RELOC_32_PCREL_S2
1496 && in_signed_range (the_insn.exp.X_add_number, 0x3fff)
1497 )
1498 {
1499 error_message = ": PC-relative operand can't be a constant";
1500 goto error;
1501 }
1502 /* Check for invalid constant values. Don't warn if
1503 constant was inside %hi or %lo, since these
1504 truncate the constant to fit. */
1505 if (immediate_max != 0
1506 && the_insn.reloc != BFD_RELOC_LO10
1507 && the_insn.reloc != BFD_RELOC_HI22
1508 && !in_signed_range (the_insn.exp.X_add_number,
1509 immediate_max)
1510 )
1511 {
1512 if (the_insn.pcrel)
1513 /* Who knows? After relocation, we may be within
1514 range. Let the linker figure it out. */
1515 {
1516 the_insn.exp.X_op = O_symbol;
1517 the_insn.exp.X_add_symbol = section_symbol (absolute_section);
1518 }
1519 else
1520 /* Immediate value is non-pcrel, and out of
1521 range. */
1522 as_bad ("constant value %ld out of range (%ld .. %ld)",
1523 the_insn.exp.X_add_number,
1524 ~immediate_max, immediate_max);
1525 }
1526 }
1527
1528 /* Reset to prevent extraneous range check. */
1529 immediate_max = 0;
1530
1531 continue;
1532
1533 case 'a':
1534 if (*s++ == 'a')
1535 {
1536 opcode |= ANNUL;
1537 continue;
1538 }
1539 break;
1540
1541 case 'A':
1542 {
1543 int asi = 0;
1544
1545 /* Parse an asi. */
1546 if (*s == '#')
1547 {
1548 s += 1;
1549 if (!strncmp (s, "ASI_AIUP", 8))
1550 asi = 0x10, s += 8;
1551 else if (!strncmp (s, "ASI_AIUS", 8))
1552 asi = 0x11, s += 8;
1553 else if (!strncmp (s, "ASI_PNF", 7))
1554 asi = 0x82, s += 7;
1555 else if (!strncmp (s, "ASI_SNF", 7))
1556 asi = 0x83, s += 7;
1557 else if (!strncmp (s, "ASI_P", 5))
1558 asi = 0x80, s += 5;
1559 else if (!strncmp (s, "ASI_S", 5))
1560 asi = 0x81, s += 5;
1561 else
1562 {
1563 error_message = ": invalid asi name";
1564 goto error;
1565 }
1566 }
1567 else
1568 {
1569 char *push = input_line_pointer;
1570 expressionS e;
1571 input_line_pointer = s;
1572
1573 expression (&e);
1574 if (e.X_op != O_constant)
1575 {
1576 error_message = ": constant required for ASI";
1577 goto error;
1578 }
1579 asi = e.X_add_number;
1580 s = input_line_pointer;
1581 input_line_pointer = push;
1582
1583 if (asi < 0 || asi > 255)
1584 {
1585 error_message = ": invalid asi number";
1586 goto error;
1587 }
1588 }
1589 opcode |= ASI (asi);
1590 continue;
1591 } /* alternate space */
1592
1593 case 'p':
1594 if (strncmp (s, "%psr", 4) == 0)
1595 {
1596 s += 4;
1597 continue;
1598 }
1599 break;
1600
1601 case 'q': /* floating point queue */
1602 if (strncmp (s, "%fq", 3) == 0)
1603 {
1604 s += 3;
1605 continue;
1606 }
1607 break;
1608
1609 case 'Q': /* coprocessor queue */
1610 if (strncmp (s, "%cq", 3) == 0)
1611 {
1612 s += 3;
1613 continue;
1614 }
1615 break;
1616
1617 case 'S':
1618 if (strcmp (str, "set") == 0)
1619 {
1620 special_case = SPECIAL_CASE_SET;
1621 continue;
1622 }
1623 else if (strncmp (str, "fdiv", 4) == 0)
1624 {
1625 special_case = SPECIAL_CASE_FDIV;
1626 continue;
1627 }
1628 break;
1629
1630 #ifndef NO_V9
1631 case 'o':
1632 if (strncmp (s, "%asi", 4) != 0)
1633 break;
1634 s += 4;
1635 continue;
1636
1637 case 's':
1638 if (strncmp (s, "%fprs", 5) != 0)
1639 break;
1640 s += 5;
1641 continue;
1642
1643 case 'E':
1644 if (strncmp (s, "%ccr", 4) != 0)
1645 break;
1646 s += 4;
1647 continue;
1648 #endif /* NO_V9 */
1649
1650 case 't':
1651 if (strncmp (s, "%tbr", 4) != 0)
1652 break;
1653 s += 4;
1654 continue;
1655
1656 case 'w':
1657 if (strncmp (s, "%wim", 4) != 0)
1658 break;
1659 s += 4;
1660 continue;
1661
1662 #ifndef NO_V9
1663 case 'x':
1664 {
1665 char *push = input_line_pointer;
1666 expressionS e;
1667
1668 input_line_pointer = s;
1669 expression (&e);
1670 if (e.X_op == O_constant)
1671 {
1672 int n = e.X_add_number;
1673 if (n != e.X_add_number || (n & ~0x1ff) != 0)
1674 as_bad ("OPF immediate operand out of range (0-0x1ff)");
1675 else
1676 opcode |= e.X_add_number << 5;
1677 }
1678 else
1679 as_bad ("non-immediate OPF operand, ignored");
1680 s = input_line_pointer;
1681 input_line_pointer = push;
1682 continue;
1683 }
1684 #endif
1685
1686 case 'y':
1687 if (strncmp (s, "%y", 2) != 0)
1688 break;
1689 s += 2;
1690 continue;
1691
1692 default:
1693 as_fatal ("failed sanity check.");
1694 } /* switch on arg code */
1695 break;
1696 } /* for each arg that we expect */
1697 error:
1698 if (match == 0)
1699 {
1700 /* Args don't match. */
1701 if (((unsigned) (&insn[1] - sparc_opcodes)) < NUMOPCODES
1702 && (insn->name == insn[1].name
1703 || !strcmp (insn->name, insn[1].name)))
1704 {
1705 ++insn;
1706 s = argsStart;
1707 continue;
1708 }
1709 else
1710 {
1711 as_bad ("Illegal operands%s", error_message);
1712 return;
1713 }
1714 }
1715 else
1716 {
1717 if (insn->architecture > current_architecture
1718 || (insn->architecture != current_architecture
1719 && current_architecture > v8))
1720 {
1721 if ((!architecture_requested || warn_on_bump)
1722 && !ARCHITECTURES_CONFLICT_P (current_architecture,
1723 insn->architecture)
1724 && !ARCHITECTURES_CONFLICT_P (insn->architecture,
1725 current_architecture))
1726 {
1727 if (warn_on_bump)
1728 {
1729 as_warn ("architecture bumped from \"%s\" to \"%s\" on \"%s\"",
1730 architecture_pname[current_architecture],
1731 architecture_pname[insn->architecture],
1732 str);
1733 } /* if warning */
1734
1735 current_architecture = insn->architecture;
1736 }
1737 else
1738 {
1739 as_bad ("Architecture mismatch on \"%s\".", str);
1740 as_tsktsk (" (Requires %s; current architecture is %s.)",
1741 architecture_pname[insn->architecture],
1742 architecture_pname[current_architecture]);
1743 return;
1744 } /* if bump ok else error */
1745 } /* if architecture higher */
1746 } /* if no match */
1747
1748 break;
1749 } /* forever looking for a match */
1750
1751 the_insn.opcode = opcode;
1752 }
1753
1754 static int
1755 getExpression (str)
1756 char *str;
1757 {
1758 char *save_in;
1759 segT seg;
1760
1761 save_in = input_line_pointer;
1762 input_line_pointer = str;
1763 seg = expression (&the_insn.exp);
1764 if (seg != absolute_section
1765 && seg != text_section
1766 && seg != data_section
1767 && seg != bss_section
1768 && seg != undefined_section)
1769 {
1770 the_insn.error = "bad segment";
1771 expr_end = input_line_pointer;
1772 input_line_pointer = save_in;
1773 return 1;
1774 }
1775 expr_end = input_line_pointer;
1776 input_line_pointer = save_in;
1777 return 0;
1778 } /* getExpression() */
1779
1780
1781 /*
1782 This is identical to the md_atof in m68k.c. I think this is right,
1783 but I'm not sure.
1784
1785 Turn a string in input_line_pointer into a floating point constant of type
1786 type, and store the appropriate bytes in *litP. The number of LITTLENUMS
1787 emitted is stored in *sizeP . An error message is returned, or NULL on OK.
1788 */
1789
1790 /* Equal to MAX_PRECISION in atof-ieee.c */
1791 #define MAX_LITTLENUMS 6
1792
1793 char *
1794 md_atof (type, litP, sizeP)
1795 char type;
1796 char *litP;
1797 int *sizeP;
1798 {
1799 int prec;
1800 LITTLENUM_TYPE words[MAX_LITTLENUMS];
1801 LITTLENUM_TYPE *wordP;
1802 char *t;
1803 char *atof_ieee ();
1804
1805 switch (type)
1806 {
1807
1808 case 'f':
1809 case 'F':
1810 case 's':
1811 case 'S':
1812 prec = 2;
1813 break;
1814
1815 case 'd':
1816 case 'D':
1817 case 'r':
1818 case 'R':
1819 prec = 4;
1820 break;
1821
1822 case 'x':
1823 case 'X':
1824 prec = 6;
1825 break;
1826
1827 case 'p':
1828 case 'P':
1829 prec = 6;
1830 break;
1831
1832 default:
1833 *sizeP = 0;
1834 return "Bad call to MD_ATOF()";
1835 }
1836 t = atof_ieee (input_line_pointer, type, words);
1837 if (t)
1838 input_line_pointer = t;
1839 *sizeP = prec * sizeof (LITTLENUM_TYPE);
1840 for (wordP = words; prec--;)
1841 {
1842 md_number_to_chars (litP, (valueT) (*wordP++), sizeof (LITTLENUM_TYPE));
1843 litP += sizeof (LITTLENUM_TYPE);
1844 }
1845 return 0;
1846 }
1847
1848 /*
1849 * Write out big-endian.
1850 */
1851 void
1852 md_number_to_chars (buf, val, n)
1853 char *buf;
1854 valueT val;
1855 int n;
1856 {
1857 number_to_chars_bigendian (buf, val, n);
1858 }
1859
1860 /* Apply a fixS to the frags, now that we know the value it ought to
1861 hold. */
1862
1863 int
1864 md_apply_fix (fixP, value)
1865 fixS *fixP;
1866 valueT *value;
1867 {
1868 char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
1869 offsetT val;
1870
1871 val = *value;
1872
1873 assert (fixP->fx_r_type < BFD_RELOC_UNUSED);
1874
1875 fixP->fx_addnumber = val; /* Remember value for emit_reloc */
1876
1877 #ifdef OBJ_ELF
1878 /* FIXME: SPARC ELF relocations don't use an addend in the data
1879 field itself. This whole approach should be somehow combined
1880 with the calls to bfd_perform_relocation. Also, the value passed
1881 in by fixup_segment includes the value of a defined symbol. We
1882 don't want to include the value of an externally visible symbol. */
1883 if (fixP->fx_addsy != NULL)
1884 {
1885 if (S_IS_EXTERN (fixP->fx_addsy)
1886 && S_GET_SEGMENT (fixP->fx_addsy) != absolute_section
1887 && S_GET_SEGMENT (fixP->fx_addsy) != undefined_section
1888 && ! bfd_is_com_section (S_GET_SEGMENT (fixP->fx_addsy)))
1889 fixP->fx_addnumber -= S_GET_VALUE (fixP->fx_addsy);
1890 return 1;
1891 }
1892 #endif
1893
1894 /* This is a hack. There should be a better way to
1895 handle this. Probably in terms of howto fields, once
1896 we can look at these fixups in terms of howtos. */
1897 if (fixP->fx_r_type == BFD_RELOC_32_PCREL_S2 && fixP->fx_addsy)
1898 val += fixP->fx_where + fixP->fx_frag->fr_address;
1899
1900 #ifdef OBJ_AOUT
1901 /* FIXME: More ridiculous gas reloc hacking. If we are going to
1902 generate a reloc, then we just want to let the reloc addend set
1903 the value. We do not want to also stuff the addend into the
1904 object file. Including the addend in the object file works when
1905 doing a static link, because the linker will ignore the object
1906 file contents. However, the dynamic linker does not ignore the
1907 object file contents. */
1908 if (fixP->fx_addsy != NULL
1909 && fixP->fx_r_type != BFD_RELOC_32_PCREL_S2)
1910 val = 0;
1911 #endif
1912
1913 switch (fixP->fx_r_type)
1914 {
1915 case BFD_RELOC_16:
1916 buf[0] = val >> 8;
1917 buf[1] = val;
1918 break;
1919
1920 case BFD_RELOC_32:
1921 buf[0] = val >> 24;
1922 buf[1] = val >> 16;
1923 buf[2] = val >> 8;
1924 buf[3] = val;
1925 break;
1926
1927 case BFD_RELOC_32_PCREL_S2:
1928 val = (val >>= 2) + 1;
1929 buf[0] |= (val >> 24) & 0x3f;
1930 buf[1] = (val >> 16);
1931 buf[2] = val >> 8;
1932 buf[3] = val;
1933 break;
1934
1935 #ifndef NO_V9
1936 case BFD_RELOC_64:
1937 {
1938 bfd_vma valh = BSR (val, 32);
1939 buf[0] = valh >> 24;
1940 buf[1] = valh >> 16;
1941 buf[2] = valh >> 8;
1942 buf[3] = valh;
1943 buf[4] = val >> 24;
1944 buf[5] = val >> 16;
1945 buf[6] = val >> 8;
1946 buf[7] = val;
1947 }
1948 break;
1949
1950 case BFD_RELOC_SPARC_11:
1951 if (((val > 0) && (val & ~0x7ff))
1952 || ((val < 0) && (~(val - 1) & ~0x7ff)))
1953 {
1954 as_bad ("relocation overflow.");
1955 } /* on overflow */
1956
1957 buf[2] |= (val >> 8) & 0x7;
1958 buf[3] = val & 0xff;
1959 break;
1960
1961 case BFD_RELOC_SPARC_10:
1962 if (((val > 0) && (val & ~0x3ff))
1963 || ((val < 0) && (~(val - 1) & ~0x3ff)))
1964 {
1965 as_bad ("relocation overflow.");
1966 } /* on overflow */
1967
1968 buf[2] |= (val >> 8) & 0x3;
1969 buf[3] = val & 0xff;
1970 break;
1971
1972 case BFD_RELOC_SPARC_WDISP16:
1973 if (((val > 0) && (val & ~0x3fffc))
1974 || ((val < 0) && (~(val - 1) & ~0x3fffc)))
1975 {
1976 as_bad ("relocation overflow.");
1977 } /* on overflow */
1978
1979 val = (val >>= 2) + 1;
1980 buf[1] |= ((val >> 14) & 0x3) << 4;
1981 buf[2] |= (val >> 8) & 0x3f;
1982 buf[3] = val & 0xff;
1983 break;
1984
1985 case BFD_RELOC_SPARC_WDISP19:
1986 if (((val > 0) && (val & ~0x1ffffc))
1987 || ((val < 0) && (~(val - 1) & ~0x1ffffc)))
1988 {
1989 as_bad ("relocation overflow.");
1990 } /* on overflow */
1991
1992 val = (val >>= 2) + 1;
1993 buf[1] |= (val >> 16) & 0x7;
1994 buf[2] = (val >> 8) & 0xff;
1995 buf[3] = val & 0xff;
1996 break;
1997
1998 case BFD_RELOC_SPARC_HH22:
1999 val = BSR (val, 32);
2000 /* intentional fallthrough */
2001 #endif /* NO_V9 */
2002
2003 #ifndef NO_V9
2004 case BFD_RELOC_SPARC_LM22:
2005 #endif
2006 case BFD_RELOC_HI22:
2007 if (!fixP->fx_addsy)
2008 {
2009 buf[1] |= (val >> 26) & 0x3f;
2010 buf[2] = val >> 18;
2011 buf[3] = val >> 10;
2012 }
2013 else
2014 {
2015 buf[2] = 0;
2016 buf[3] = 0;
2017 }
2018 break;
2019
2020 case BFD_RELOC_SPARC22:
2021 if (val & ~0x003fffff)
2022 {
2023 as_bad ("relocation overflow");
2024 } /* on overflow */
2025 buf[1] |= (val >> 16) & 0x3f;
2026 buf[2] = val >> 8;
2027 buf[3] = val & 0xff;
2028 break;
2029
2030 #ifndef NO_V9
2031 case BFD_RELOC_SPARC_HM10:
2032 val = BSR (val, 32);
2033 /* intentional fallthrough */
2034 #endif /* NO_V9 */
2035
2036 case BFD_RELOC_LO10:
2037 if (!fixP->fx_addsy)
2038 {
2039 buf[2] |= (val >> 8) & 0x03;
2040 buf[3] = val;
2041 }
2042 else
2043 buf[3] = 0;
2044 break;
2045
2046 case BFD_RELOC_SPARC13:
2047 if (! in_signed_range (val, 0x1fff))
2048 as_bad ("relocation overflow");
2049
2050 buf[2] |= (val >> 8) & 0x1f;
2051 buf[3] = val;
2052 break;
2053
2054 case BFD_RELOC_SPARC_WDISP22:
2055 val = (val >> 2) + 1;
2056 /* FALLTHROUGH */
2057 case BFD_RELOC_SPARC_BASE22:
2058 buf[1] |= (val >> 16) & 0x3f;
2059 buf[2] = val >> 8;
2060 buf[3] = val;
2061 break;
2062
2063 case BFD_RELOC_NONE:
2064 default:
2065 as_bad ("bad or unhandled relocation type: 0x%02x", fixP->fx_r_type);
2066 break;
2067 }
2068
2069 /* Are we finished with this relocation now? */
2070 if (fixP->fx_addsy == 0 && !fixP->fx_pcrel)
2071 fixP->fx_done = 1;
2072
2073 return 1;
2074 }
2075
2076 /* Translate internal representation of relocation info to BFD target
2077 format. */
2078 arelent *
2079 tc_gen_reloc (section, fixp)
2080 asection *section;
2081 fixS *fixp;
2082 {
2083 arelent *reloc;
2084 bfd_reloc_code_real_type code;
2085
2086 reloc = (arelent *) bfd_alloc_by_size_t (stdoutput, sizeof (arelent));
2087 assert (reloc != 0);
2088
2089 reloc->sym_ptr_ptr = &fixp->fx_addsy->bsym;
2090 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
2091
2092 switch (fixp->fx_r_type)
2093 {
2094 case BFD_RELOC_16:
2095 case BFD_RELOC_32:
2096 case BFD_RELOC_HI22:
2097 case BFD_RELOC_LO10:
2098 case BFD_RELOC_32_PCREL_S2:
2099 case BFD_RELOC_SPARC13:
2100 case BFD_RELOC_SPARC_BASE13:
2101 case BFD_RELOC_SPARC_WDISP16:
2102 case BFD_RELOC_SPARC_WDISP19:
2103 case BFD_RELOC_SPARC_WDISP22:
2104 case BFD_RELOC_64:
2105 case BFD_RELOC_SPARC_10:
2106 case BFD_RELOC_SPARC_11:
2107 case BFD_RELOC_SPARC_HH22:
2108 case BFD_RELOC_SPARC_HM10:
2109 case BFD_RELOC_SPARC_LM22:
2110 case BFD_RELOC_SPARC_PC_HH22:
2111 case BFD_RELOC_SPARC_PC_HM10:
2112 case BFD_RELOC_SPARC_PC_LM22:
2113 code = fixp->fx_r_type;
2114 break;
2115 default:
2116 abort ();
2117 }
2118 reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
2119 if (reloc->howto == 0)
2120 {
2121 as_bad_where (fixp->fx_file, fixp->fx_line,
2122 "internal error: can't export reloc type %d (`%s')",
2123 fixp->fx_r_type, bfd_get_reloc_code_name (code));
2124 return 0;
2125 }
2126 assert (!fixp->fx_pcrel == !reloc->howto->pc_relative);
2127
2128 /* @@ Why fx_addnumber sometimes and fx_offset other times? */
2129 #ifdef OBJ_AOUT
2130
2131 if (reloc->howto->pc_relative == 0)
2132 reloc->addend = fixp->fx_addnumber;
2133 else
2134 reloc->addend = fixp->fx_offset - reloc->address;
2135
2136 #else /* elf or coff */
2137
2138 if (reloc->howto->pc_relative == 0)
2139 reloc->addend = fixp->fx_addnumber;
2140 else if ((fixp->fx_addsy->bsym->flags & BSF_SECTION_SYM) != 0)
2141 reloc->addend = (section->vma
2142 + fixp->fx_addnumber
2143 + md_pcrel_from (fixp));
2144 else
2145 reloc->addend = fixp->fx_offset;
2146
2147 #endif
2148
2149 return reloc;
2150 }
2151
2152
2153 #if 0
2154 /* for debugging only */
2155 static void
2156 print_insn (insn)
2157 struct sparc_it *insn;
2158 {
2159 const char *const Reloc[] = {
2160 "RELOC_8",
2161 "RELOC_16",
2162 "RELOC_32",
2163 "RELOC_DISP8",
2164 "RELOC_DISP16",
2165 "RELOC_DISP32",
2166 "RELOC_WDISP30",
2167 "RELOC_WDISP22",
2168 "RELOC_HI22",
2169 "RELOC_22",
2170 "RELOC_13",
2171 "RELOC_LO10",
2172 "RELOC_SFA_BASE",
2173 "RELOC_SFA_OFF13",
2174 "RELOC_BASE10",
2175 "RELOC_BASE13",
2176 "RELOC_BASE22",
2177 "RELOC_PC10",
2178 "RELOC_PC22",
2179 "RELOC_JMP_TBL",
2180 "RELOC_SEGOFF16",
2181 "RELOC_GLOB_DAT",
2182 "RELOC_JMP_SLOT",
2183 "RELOC_RELATIVE",
2184 "NO_RELOC"
2185 };
2186
2187 if (insn->error)
2188 fprintf (stderr, "ERROR: %s\n");
2189 fprintf (stderr, "opcode=0x%08x\n", insn->opcode);
2190 fprintf (stderr, "reloc = %s\n", Reloc[insn->reloc]);
2191 fprintf (stderr, "exp = {\n");
2192 fprintf (stderr, "\t\tX_add_symbol = %s\n",
2193 ((insn->exp.X_add_symbol != NULL)
2194 ? ((S_GET_NAME (insn->exp.X_add_symbol) != NULL)
2195 ? S_GET_NAME (insn->exp.X_add_symbol)
2196 : "???")
2197 : "0"));
2198 fprintf (stderr, "\t\tX_sub_symbol = %s\n",
2199 ((insn->exp.X_op_symbol != NULL)
2200 ? (S_GET_NAME (insn->exp.X_op_symbol)
2201 ? S_GET_NAME (insn->exp.X_op_symbol)
2202 : "???")
2203 : "0"));
2204 fprintf (stderr, "\t\tX_add_number = %d\n",
2205 insn->exp.X_add_number);
2206 fprintf (stderr, "}\n");
2207 }
2208 #endif
2209 \f
2210 /*
2211 * md_parse_option
2212 * Invocation line includes a switch not recognized by the base assembler.
2213 * See if it's a processor-specific option. These are:
2214 *
2215 * -bump
2216 * Warn on architecture bumps. See also -A.
2217 *
2218 * -Av6, -Av7, -Av8, -Av9, -Asparclite
2219 * Select the architecture. Instructions or features not
2220 * supported by the selected architecture cause fatal errors.
2221 *
2222 * The default is to start at v6, and bump the architecture up
2223 * whenever an instruction is seen at a higher level.
2224 *
2225 * If -bump is specified, a warning is printing when bumping to
2226 * higher levels.
2227 *
2228 * If an architecture is specified, all instructions must match
2229 * that architecture. Any higher level instructions are flagged
2230 * as errors.
2231 *
2232 * if both an architecture and -bump are specified, the
2233 * architecture starts at the specified level, but bumps are
2234 * warnings.
2235 *
2236 * Note:
2237 * Bumping between incompatible architectures is always an
2238 * error. For example, from sparclite to v9.
2239 */
2240
2241 #ifdef OBJ_ELF
2242 CONST char *md_shortopts = "A:K:VQ:sq";
2243 #else
2244 CONST char *md_shortopts = "A:";
2245 #endif
2246 struct option md_longopts[] = {
2247 #define OPTION_BUMP (OPTION_MD_BASE)
2248 {"bump", no_argument, NULL, OPTION_BUMP},
2249 #define OPTION_SPARC (OPTION_MD_BASE + 1)
2250 {"sparc", no_argument, NULL, OPTION_SPARC},
2251 {NULL, no_argument, NULL, 0}
2252 };
2253 size_t md_longopts_size = sizeof(md_longopts);
2254
2255 int
2256 md_parse_option (c, arg)
2257 int c;
2258 char *arg;
2259 {
2260 switch (c)
2261 {
2262 case OPTION_BUMP:
2263 warn_on_bump = 1;
2264 break;
2265
2266 case 'A':
2267 {
2268 char *p = arg;
2269 const char **arch;
2270
2271 for (arch = architecture_pname; *arch != NULL; ++arch)
2272 {
2273 if (strcmp (p, *arch) == 0)
2274 break;
2275 }
2276
2277 if (*arch == NULL)
2278 {
2279 as_bad ("invalid architecture -A%s", p);
2280 return 0;
2281 }
2282 else
2283 {
2284 enum sparc_architecture new_arch = arch - architecture_pname;
2285 #ifdef NO_V9
2286 if (new_arch == v9)
2287 {
2288 as_error ("v9 support not compiled in");
2289 return 0;
2290 }
2291 #endif
2292 current_architecture = new_arch;
2293 architecture_requested = 1;
2294 }
2295 }
2296 break;
2297
2298 case OPTION_SPARC:
2299 /* Ignore -sparc, used by SunOS make default .s.o rule. */
2300 break;
2301
2302 #ifdef OBJ_ELF
2303 case 'V':
2304 print_version_id ();
2305 break;
2306
2307 case 'Q':
2308 /* Qy - do emit .comment
2309 Qn - do not emit .comment */
2310 break;
2311
2312 case 's':
2313 /* use .stab instead of .stab.excl */
2314 break;
2315
2316 case 'q':
2317 /* quick -- native assembler does fewer checks */
2318 break;
2319
2320 case 'K':
2321 if (strcmp (arg, "PIC") != 0)
2322 as_warn ("Unrecognized option following -K");
2323 else
2324 {
2325 as_warn ("gas does not currently support PIC code for the SPARC");
2326 as_fatal ("use /usr/ccs/bin/as instead");
2327 }
2328 #endif
2329
2330 default:
2331 return 0;
2332 }
2333
2334 return 1;
2335 }
2336
2337 void
2338 md_show_usage (stream)
2339 FILE *stream;
2340 {
2341 const char **arch;
2342 fprintf(stream, "SPARC options:\n");
2343 for (arch = architecture_pname; *arch; arch++)
2344 {
2345 if (arch != architecture_pname)
2346 fprintf (stream, " | ");
2347 fprintf (stream, "-A%s", *arch);
2348 }
2349 fprintf (stream, "\n\
2350 specify variant of SPARC architecture\n\
2351 -bump warn when assembler switches architectures\n\
2352 -sparc ignored\n");
2353 #ifdef OBJ_ELF
2354 fprintf(stream, "\
2355 -V print assembler version number\n\
2356 -q ignored\n\
2357 -Qy, -Qn ignored\n\
2358 -s ignored\n");
2359 #endif
2360 }
2361 \f
2362 /* We have no need to default values of symbols. */
2363
2364 /* ARGSUSED */
2365 symbolS *
2366 md_undefined_symbol (name)
2367 char *name;
2368 {
2369 return 0;
2370 } /* md_undefined_symbol() */
2371
2372 /* Round up a section size to the appropriate boundary. */
2373 valueT
2374 md_section_align (segment, size)
2375 segT segment;
2376 valueT size;
2377 {
2378 #ifndef OBJ_ELF
2379 /* This is not right for ELF; a.out wants it, and COFF will force
2380 the alignment anyways. */
2381 valueT align = ((valueT) 1
2382 << (valueT) bfd_get_section_alignment (stdoutput, segment));
2383 valueT newsize;
2384 /* turn alignment value into a mask */
2385 align--;
2386 newsize = (size + align) & ~align;
2387 return newsize;
2388 #else
2389 return size;
2390 #endif
2391 }
2392
2393 /* Exactly what point is a PC-relative offset relative TO?
2394 On the sparc, they're relative to the address of the offset, plus
2395 its size. This gets us to the following instruction.
2396 (??? Is this right? FIXME-SOON) */
2397 long
2398 md_pcrel_from (fixP)
2399 fixS *fixP;
2400 {
2401 return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
2402 }
2403
2404 /* end of tc-sparc.c */
GDB Binutils - Deliverables
This page took 0.104274 seconds and 5 git commands to generate.