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