1 /* tc-sparc.c -- Assemble for the SPARC
2 Copyright (C) 1989, 90-95, 1996 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
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)
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.
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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26 /* careful, this file includes data *declarations* */
27 #include "opcode/sparc.h"
29 static void sparc_ip
PARAMS ((char *));
31 /* Current architecture. We don't bump up unless necessary. */
32 static enum sparc_opcode_arch_val current_architecture
= SPARC_OPCODE_ARCH_V6
;
34 /* The maximum architecture level we can bump up to.
35 In a 32 bit environment, don't allow bumping up to v9 by default.
36 The native assembler works this way. The user is required to pass
37 an explicit argument before we'll create v9 object files. However, if
38 we don't see any v9 insns, a v9 object file is not created. */
40 static enum sparc_opcode_arch_val max_architecture
= SPARC_OPCODE_ARCH_V9
;
42 /* ??? This should be V8, but sparclite support was added by making it the
43 default. GCC now passes -Asparclite, so maybe sometime in the future
44 we can set this to V8. */
45 static enum sparc_opcode_arch_val max_architecture
= SPARC_OPCODE_ARCH_SPARCLITE
;
48 static int architecture_requested
;
49 static int warn_on_bump
;
51 /* If warn_on_bump and the needed architecture is higher than this
52 architecture, issue a warning. */
53 static enum sparc_opcode_arch_val warn_after_architecture
;
55 /* Non-zero if we are generating PIC code. */
58 extern int target_big_endian
;
60 /* handle of the OPCODE hash table */
61 static struct hash_control
*op_hash
;
63 static void s_data1
PARAMS ((void));
64 static void s_seg
PARAMS ((int));
65 static void s_proc
PARAMS ((int));
66 static void s_reserve
PARAMS ((int));
67 static void s_common
PARAMS ((int));
69 const pseudo_typeS md_pseudo_table
[] =
71 {"align", s_align_bytes
, 0}, /* Defaulting is invalid (0) */
72 {"common", s_common
, 0},
73 {"global", s_globl
, 0},
75 {"optim", s_ignore
, 0},
77 {"reserve", s_reserve
, 0},
86 /* these are specific to sparc/svr4 */
87 {"pushsection", obj_elf_section
, 0},
88 {"popsection", obj_elf_previous
, 0},
95 const int md_reloc_size
= 12; /* Size of relocation record */
97 /* This array holds the chars that always start a comment. If the
98 pre-processor is disabled, these aren't very useful */
99 const char comment_chars
[] = "!"; /* JF removed '|' from comment_chars */
101 /* This array holds the chars that only start a comment at the beginning of
102 a line. If the line seems to have the form '# 123 filename'
103 .line and .file directives will appear in the pre-processed output */
104 /* Note that input_file.c hand checks for '#' at the beginning of the
105 first line of the input file. This is because the compiler outputs
106 #NO_APP at the beginning of its output. */
107 /* Also note that comments started like this one will always
108 work if '/' isn't otherwise defined. */
109 const char line_comment_chars
[] = "#";
111 const char line_separator_chars
[] = "";
113 /* Chars that can be used to separate mant from exp in floating point nums */
114 const char EXP_CHARS
[] = "eE";
116 /* Chars that mean this number is a floating point constant */
119 const char FLT_CHARS
[] = "rRsSfFdDxXpP";
121 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
122 changed in read.c. Ideally it shouldn't have to know about it at all,
123 but nothing is ideal around here. */
125 static unsigned char octal
[256];
126 #define isoctal(c) octal[(unsigned char) (c)]
127 static unsigned char toHex
[256];
132 unsigned long opcode
;
133 struct nlist
*nlistp
;
136 bfd_reloc_code_real_type reloc
;
139 struct sparc_it the_insn
, set_insn
;
142 in_signed_range (val
, max
)
143 bfd_signed_vma val
, max
;
163 for (i
= 0; (mask
& 1) == 0; ++i
)
169 static void print_insn
PARAMS ((struct sparc_it
*insn
));
171 static int getExpression
PARAMS ((char *str
));
173 static char *expr_end
;
174 static int special_case
;
177 * Instructions that require wierd handling because they're longer than
180 #define SPECIAL_CASE_SET 1
181 #define SPECIAL_CASE_FDIV 2
184 * sort of like s_lcomm
188 static int max_alignment
= 15;
203 name
= input_line_pointer
;
204 c
= get_symbol_end ();
205 p
= input_line_pointer
;
209 if (*input_line_pointer
!= ',')
211 as_bad ("Expected comma after name");
212 ignore_rest_of_line ();
216 ++input_line_pointer
;
218 if ((size
= get_absolute_expression ()) < 0)
220 as_bad ("BSS length (%d.) <0! Ignored.", size
);
221 ignore_rest_of_line ();
226 symbolP
= symbol_find_or_make (name
);
229 if (strncmp (input_line_pointer
, ",\"bss\"", 6) != 0
230 && strncmp (input_line_pointer
, ",\".bss\"", 7) != 0)
232 as_bad ("bad .reserve segment -- expected BSS segment");
236 if (input_line_pointer
[2] == '.')
237 input_line_pointer
+= 7;
239 input_line_pointer
+= 6;
242 if (*input_line_pointer
== ',')
244 ++input_line_pointer
;
247 if (*input_line_pointer
== '\n')
249 as_bad ("Missing alignment");
253 align
= get_absolute_expression ();
255 if (align
> max_alignment
)
257 align
= max_alignment
;
258 as_warn ("Alignment too large: %d. assumed.", align
);
264 as_warn ("Alignment negative. 0 assumed.");
267 record_alignment (bss_section
, align
);
269 /* convert to a power of 2 alignment */
270 for (temp
= 0; (align
& 1) == 0; align
>>= 1, ++temp
);;
274 as_bad ("Alignment not a power of 2");
275 ignore_rest_of_line ();
277 } /* not a power of two */
280 } /* if has optional alignment */
284 if (!S_IS_DEFINED (symbolP
)
286 && S_GET_OTHER (symbolP
) == 0
287 && S_GET_DESC (symbolP
) == 0
294 segT current_seg
= now_seg
;
295 subsegT current_subseg
= now_subseg
;
297 subseg_set (bss_section
, 1); /* switch to bss */
300 frag_align (align
, 0); /* do alignment */
302 /* detach from old frag */
303 if (S_GET_SEGMENT(symbolP
) == bss_section
)
304 symbolP
->sy_frag
->fr_symbol
= NULL
;
306 symbolP
->sy_frag
= frag_now
;
307 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
)0, symbolP
,
311 S_SET_SEGMENT (symbolP
, bss_section
);
313 subseg_set (current_seg
, current_subseg
);
318 as_warn("Ignoring attempt to re-define symbol %s",
319 S_GET_NAME (symbolP
));
320 } /* if not redefining */
322 demand_empty_rest_of_line ();
335 name
= input_line_pointer
;
336 c
= get_symbol_end ();
337 /* just after name is now '\0' */
338 p
= input_line_pointer
;
341 if (*input_line_pointer
!= ',')
343 as_bad ("Expected comma after symbol-name");
344 ignore_rest_of_line ();
347 input_line_pointer
++; /* skip ',' */
348 if ((temp
= get_absolute_expression ()) < 0)
350 as_bad (".COMMon length (%d.) <0! Ignored.", temp
);
351 ignore_rest_of_line ();
356 symbolP
= symbol_find_or_make (name
);
358 if (S_IS_DEFINED (symbolP
))
360 as_bad ("Ignoring attempt to re-define symbol");
361 ignore_rest_of_line ();
364 if (S_GET_VALUE (symbolP
) != 0)
366 if (S_GET_VALUE (symbolP
) != size
)
368 as_warn ("Length of .comm \"%s\" is already %ld. Not changed to %d.",
369 S_GET_NAME (symbolP
), (long) S_GET_VALUE (symbolP
), size
);
375 S_SET_VALUE (symbolP
, (valueT
) size
);
376 S_SET_EXTERNAL (symbolP
);
379 know (symbolP
->sy_frag
== &zero_address_frag
);
380 if (*input_line_pointer
!= ',')
382 as_bad ("Expected comma after common length");
383 ignore_rest_of_line ();
386 input_line_pointer
++;
388 if (*input_line_pointer
!= '"')
390 temp
= get_absolute_expression ();
392 if (temp
> max_alignment
)
394 temp
= max_alignment
;
395 as_warn ("Common alignment too large: %d. assumed", temp
);
401 as_warn ("Common alignment negative; 0 assumed");
413 old_subsec
= now_subseg
;
415 record_alignment (bss_section
, align
);
416 subseg_set (bss_section
, 0);
418 frag_align (align
, 0);
419 if (S_GET_SEGMENT (symbolP
) == bss_section
)
420 symbolP
->sy_frag
->fr_symbol
= 0;
421 symbolP
->sy_frag
= frag_now
;
422 p
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
, size
,
425 S_SET_SEGMENT (symbolP
, bss_section
);
426 S_CLEAR_EXTERNAL (symbolP
);
427 subseg_set (old_sec
, old_subsec
);
433 S_SET_VALUE (symbolP
, (valueT
) size
);
435 S_SET_ALIGN (symbolP
, temp
);
437 S_SET_EXTERNAL (symbolP
);
438 /* should be common, but this is how gas does it for now */
439 S_SET_SEGMENT (symbolP
, bfd_und_section_ptr
);
444 input_line_pointer
++;
445 /* @@ Some use the dot, some don't. Can we get some consistency?? */
446 if (*input_line_pointer
== '.')
447 input_line_pointer
++;
448 /* @@ Some say data, some say bss. */
449 if (strncmp (input_line_pointer
, "bss\"", 4)
450 && strncmp (input_line_pointer
, "data\"", 5))
452 while (*--input_line_pointer
!= '"')
454 input_line_pointer
--;
455 goto bad_common_segment
;
457 while (*input_line_pointer
++ != '"')
459 goto allocate_common
;
461 demand_empty_rest_of_line ();
466 p
= input_line_pointer
;
467 while (*p
&& *p
!= '\n')
471 as_bad ("bad .common segment %s", input_line_pointer
+ 1);
473 input_line_pointer
= p
;
474 ignore_rest_of_line ();
484 if (strncmp (input_line_pointer
, "\"text\"", 6) == 0)
486 input_line_pointer
+= 6;
490 if (strncmp (input_line_pointer
, "\"data\"", 6) == 0)
492 input_line_pointer
+= 6;
496 if (strncmp (input_line_pointer
, "\"data1\"", 7) == 0)
498 input_line_pointer
+= 7;
502 if (strncmp (input_line_pointer
, "\"bss\"", 5) == 0)
504 input_line_pointer
+= 5;
505 /* We only support 2 segments -- text and data -- for now, so
506 things in the "bss segment" will have to go into data for now.
507 You can still allocate SEG_BSS stuff with .lcomm or .reserve. */
508 subseg_set (data_section
, 255); /* FIXME-SOMEDAY */
511 as_bad ("Unknown segment type");
512 demand_empty_rest_of_line ();
518 subseg_set (data_section
, 1);
519 demand_empty_rest_of_line ();
526 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
528 ++input_line_pointer
;
530 ++input_line_pointer
;
533 /* sparc64 priviledged registers */
535 struct priv_reg_entry
541 struct priv_reg_entry priv_reg_table
[] =
560 {"", -1}, /* end marker */
565 struct priv_reg_entry
*p
, *q
;
567 return strcmp (q
->name
, p
->name
);
570 /* This function is called once, at assembler startup time. It should
571 set up all the tables, etc. that the MD part of the assembler will need. */
576 register const char *retval
= NULL
;
578 register unsigned int i
= 0;
580 op_hash
= hash_new ();
582 while (i
< sparc_num_opcodes
)
584 const char *name
= sparc_opcodes
[i
].name
;
585 retval
= hash_insert (op_hash
, name
, &sparc_opcodes
[i
]);
588 fprintf (stderr
, "internal error: can't hash `%s': %s\n",
589 sparc_opcodes
[i
].name
, retval
);
594 if (sparc_opcodes
[i
].match
& sparc_opcodes
[i
].lose
)
596 fprintf (stderr
, "internal error: losing opcode: `%s' \"%s\"\n",
597 sparc_opcodes
[i
].name
, sparc_opcodes
[i
].args
);
602 while (i
< sparc_num_opcodes
603 && !strcmp (sparc_opcodes
[i
].name
, name
));
607 as_fatal ("Broken assembler. No assembly attempted.");
609 for (i
= '0'; i
< '8'; ++i
)
611 for (i
= '0'; i
<= '9'; ++i
)
613 for (i
= 'a'; i
<= 'f'; ++i
)
614 toHex
[i
] = i
+ 10 - 'a';
615 for (i
= 'A'; i
<= 'F'; ++i
)
616 toHex
[i
] = i
+ 10 - 'A';
618 qsort (priv_reg_table
, sizeof (priv_reg_table
) / sizeof (priv_reg_table
[0]),
619 sizeof (priv_reg_table
[0]), cmp_reg_entry
);
621 target_big_endian
= 1;
623 /* If -bump, record the architecture level at which we start issuing
624 warnings. The behaviour is different depending upon whether an
625 architecture was explicitly specified. If it wasn't, we issue warnings
626 for all upwards bumps. If it was, we don't start issuing warnings until
627 we need to bump beyond the requested architecture or when we bump between
628 conflicting architectures. */
631 && architecture_requested
)
633 /* `max_architecture' records the requested architecture.
634 Issue warnings if we go above it. */
635 warn_after_architecture
= max_architecture
;
637 /* Find the highest architecture level that doesn't conflict with
638 the requested one. */
639 for (max_architecture
= SPARC_OPCODE_ARCH_MAX
;
640 max_architecture
> warn_after_architecture
;
642 if (! SPARC_OPCODE_CONFLICT_P (max_architecture
,
643 warn_after_architecture
))
648 /* Called after all assembly has been done. */
654 if (current_architecture
== SPARC_OPCODE_ARCH_V9A
)
655 bfd_set_arch_mach (stdoutput
, bfd_arch_sparc
, bfd_mach_sparc_v9a
);
657 bfd_set_arch_mach (stdoutput
, bfd_arch_sparc
, bfd_mach_sparc_v9
);
659 if (current_architecture
== SPARC_OPCODE_ARCH_V9
)
660 bfd_set_arch_mach (stdoutput
, bfd_arch_sparc
, bfd_mach_sparc_v8plus
);
661 else if (current_architecture
== SPARC_OPCODE_ARCH_V9A
)
662 bfd_set_arch_mach (stdoutput
, bfd_arch_sparc
, bfd_mach_sparc_v8plusa
);
664 bfd_set_arch_mach (stdoutput
, bfd_arch_sparc
, bfd_mach_sparc
);
678 /* See if "set" operand is absolute and small; skip sethi if so. */
679 if (special_case
== SPECIAL_CASE_SET
680 && the_insn
.exp
.X_op
== O_constant
)
682 if (the_insn
.exp
.X_add_number
>= -(1 << 12)
683 && the_insn
.exp
.X_add_number
< (1 << 12))
685 the_insn
.opcode
= 0x80102000 /* or %g0,imm,... */
686 | (the_insn
.opcode
& 0x3E000000) /* dest reg */
687 | (the_insn
.exp
.X_add_number
& 0x1FFF); /* imm */
688 special_case
= 0; /* No longer special */
689 the_insn
.reloc
= BFD_RELOC_NONE
; /* No longer relocated */
694 /* put out the opcode */
695 md_number_to_chars (toP
, (valueT
) the_insn
.opcode
, 4);
697 /* put out the symbol-dependent stuff */
698 if (the_insn
.reloc
!= BFD_RELOC_NONE
)
700 fix_new_exp (frag_now
, /* which frag */
701 (toP
- frag_now
->fr_literal
), /* where */
708 switch (special_case
)
710 case SPECIAL_CASE_SET
:
712 assert (the_insn
.reloc
== BFD_RELOC_HI22
);
713 /* See if "set" operand has no low-order bits; skip OR if so. */
714 if (the_insn
.exp
.X_op
== O_constant
715 && ((the_insn
.exp
.X_add_number
& 0x3FF) == 0))
718 rsd
= (the_insn
.opcode
>> 25) & 0x1f;
719 the_insn
.opcode
= 0x80102000 | (rsd
<< 25) | (rsd
<< 14);
720 md_number_to_chars (toP
, (valueT
) the_insn
.opcode
, 4);
721 fix_new_exp (frag_now
, /* which frag */
722 (toP
- frag_now
->fr_literal
), /* where */
729 case SPECIAL_CASE_FDIV
:
730 /* According to information leaked from Sun, the "fdiv" instructions
731 on early SPARC machines would produce incorrect results sometimes.
732 The workaround is to add an fmovs of the destination register to
733 itself just after the instruction. This was true on machines
734 with Weitek 1165 float chips, such as the Sun-4/260 and /280. */
736 assert (the_insn
.reloc
== BFD_RELOC_NONE
);
738 rsd
= (the_insn
.opcode
>> 25) & 0x1f;
739 the_insn
.opcode
= 0x81A00020 | (rsd
<< 25) | rsd
; /* fmovs dest,dest */
740 md_number_to_chars (toP
, (valueT
) the_insn
.opcode
, 4);
747 as_fatal ("failed sanity check.");
751 /* Implement big shift right. */
757 if (sizeof (bfd_vma
) <= 4 && amount
>= 32)
758 as_fatal ("Support for 64-bit arithmetic not compiled in.");
759 return val
>> amount
;
762 /* Parse an argument that can be expressed as a keyword.
764 The result is a boolean indicating success.
765 If successful, INPUT_POINTER is updated. */
768 parse_keyword_arg (lookup_fn
, input_pointerP
, valueP
)
770 char **input_pointerP
;
777 for (q
= p
+ (*p
== '#'); isalpha (*q
) || *q
== '_'; ++q
)
781 value
= (*lookup_fn
) (p
);
790 /* Parse an argument that is a constant expression.
791 The result is a boolean indicating success. */
794 parse_const_expr_arg (input_pointerP
, valueP
)
795 char **input_pointerP
;
798 char *save
= input_line_pointer
;
801 input_line_pointer
= *input_pointerP
;
802 /* The next expression may be something other than a constant
803 (say if we're not processing the right variant of the insn).
804 Don't call expression unless we're sure it will succeed as it will
805 signal an error (which we want to defer until later). */
806 /* FIXME: It might be better to define md_operand and have it recognize
807 things like %asi, etc. but continuing that route through to the end
809 if (*input_line_pointer
== '%')
811 input_line_pointer
= save
;
815 *input_pointerP
= input_line_pointer
;
816 input_line_pointer
= save
;
817 if (exp
.X_op
!= O_constant
)
819 *valueP
= exp
.X_add_number
;
827 char *error_message
= "";
831 const struct sparc_opcode
*insn
;
833 unsigned long opcode
;
834 unsigned int mask
= 0;
837 long immediate_max
= 0;
840 for (s
= str
; islower (*s
) || (*s
>= '0' && *s
<= '3'); ++s
)
858 as_fatal ("Unknown opcode: `%s'", str
);
860 insn
= (struct sparc_opcode
*) hash_find (op_hash
, str
);
863 as_bad ("Unknown opcode: `%s'", str
);
874 opcode
= insn
->match
;
875 memset (&the_insn
, '\0', sizeof (the_insn
));
876 the_insn
.reloc
= BFD_RELOC_NONE
;
880 * Build the opcode, checking as we go to make
881 * sure that the operands match
883 for (args
= insn
->args
;; ++args
)
891 /* Parse a series of masks. */
898 if (! parse_keyword_arg (sparc_encode_membar
, &s
,
901 error_message
= ": invalid membar mask name";
905 while (*s
== ' ') { ++s
; continue; }
906 if (*s
== '|' || *s
== '+')
908 while (*s
== ' ') { ++s
; continue; }
913 if (! parse_const_expr_arg (&s
, &kmask
))
915 error_message
= ": invalid membar mask expression";
918 if (kmask
< 0 || kmask
> 127)
920 error_message
= ": invalid membar mask number";
925 opcode
|= MEMBAR (kmask
);
933 /* Parse a prefetch function. */
936 if (! parse_keyword_arg (sparc_encode_prefetch
, &s
, &fcn
))
938 error_message
= ": invalid prefetch function name";
944 if (! parse_const_expr_arg (&s
, &fcn
))
946 error_message
= ": invalid prefetch function expression";
949 if (fcn
< 0 || fcn
> 31)
951 error_message
= ": invalid prefetch function number";
961 /* Parse a sparc64 privileged register. */
964 struct priv_reg_entry
*p
= priv_reg_table
;
965 unsigned int len
= 9999999; /* init to make gcc happy */
968 while (p
->name
[0] > s
[0])
970 while (p
->name
[0] == s
[0])
972 len
= strlen (p
->name
);
973 if (strncmp (p
->name
, s
, len
) == 0)
977 if (p
->name
[0] != s
[0])
979 error_message
= ": unrecognizable privileged register";
983 opcode
|= (p
->regnum
<< 14);
985 opcode
|= (p
->regnum
<< 25);
991 error_message
= ": unrecognizable privileged register";
997 if (strncmp (s
, "%asr", 4) == 0)
1005 while (isdigit (*s
))
1007 num
= num
* 10 + *s
- '0';
1011 if (num
< 16 || 31 < num
)
1013 error_message
= ": asr number must be between 15 and 31";
1015 } /* out of range */
1017 opcode
|= (*args
== 'M' ? RS1 (num
) : RD (num
));
1022 error_message
= ": expecting %asrN";
1024 } /* if %asr followed by a number. */
1030 the_insn
.reloc
= BFD_RELOC_SPARC_11
;
1031 immediate_max
= 0x03FF;
1035 the_insn
.reloc
= BFD_RELOC_SPARC_10
;
1036 immediate_max
= 0x01FF;
1040 the_insn
.reloc
= /* RELOC_WDISP2_14 */ BFD_RELOC_SPARC_WDISP16
;
1045 the_insn
.reloc
= BFD_RELOC_SPARC_WDISP19
;
1050 if (*s
== 'p' && s
[1] == 'n')
1058 if (*s
== 'p' && s
[1] == 't')
1070 if (strncmp (s
, "%icc", 4) == 0)
1082 if (strncmp (s
, "%xcc", 4) == 0)
1094 if (strncmp (s
, "%fcc0", 5) == 0)
1106 if (strncmp (s
, "%fcc1", 5) == 0)
1118 if (strncmp (s
, "%fcc2", 5) == 0)
1130 if (strncmp (s
, "%fcc3", 5) == 0)
1138 if (strncmp (s
, "%pc", 3) == 0)
1146 if (strncmp (s
, "%tick", 5) == 0)
1153 case '\0': /* end of args */
1172 case '[': /* these must match exactly */
1180 case '#': /* must be at least one digit */
1183 while (isdigit (*s
))
1191 case 'C': /* coprocessor state register */
1192 if (strncmp (s
, "%csr", 4) == 0)
1199 case 'b': /* next operand is a coprocessor register */
1202 if (*s
++ == '%' && *s
++ == 'c' && isdigit (*s
))
1207 mask
= 10 * (mask
- '0') + (*s
++ - '0');
1221 opcode
|= mask
<< 14;
1229 opcode
|= mask
<< 25;
1235 case 'r': /* next operand must be a register */
1244 case 'f': /* frame pointer */
1252 case 'g': /* global register */
1253 if (isoctal (c
= *s
++))
1260 case 'i': /* in register */
1261 if (isoctal (c
= *s
++))
1263 mask
= c
- '0' + 24;
1268 case 'l': /* local register */
1269 if (isoctal (c
= *s
++))
1271 mask
= (c
- '0' + 16);
1276 case 'o': /* out register */
1277 if (isoctal (c
= *s
++))
1279 mask
= (c
- '0' + 8);
1284 case 's': /* stack pointer */
1292 case 'r': /* any register */
1293 if (!isdigit (c
= *s
++))
1310 if ((c
= 10 * (c
- '0') + (*s
++ - '0')) >= 32)
1326 /* Got the register, now figure out where
1327 it goes in the opcode. */
1332 opcode
|= mask
<< 14;
1340 opcode
|= mask
<< 25;
1344 opcode
|= (mask
<< 25) | (mask
<< 14);
1350 case 'e': /* next operand is a floating point register */
1365 && ((format
= *s
) == 'f')
1368 for (mask
= 0; isdigit (*s
); ++s
)
1370 mask
= 10 * mask
+ (*s
- '0');
1371 } /* read the number */
1379 } /* register must be even numbered */
1387 } /* register must be multiple of 4 */
1391 if (max_architecture
>= SPARC_OPCODE_ARCH_V9
)
1392 error_message
= ": There are only 64 f registers; [0-63]";
1394 error_message
= ": There are only 32 f registers; [0-31]";
1397 else if (mask
>= 32)
1399 if (max_architecture
>= SPARC_OPCODE_ARCH_V9
)
1402 mask
-= 31; /* wrap high bit */
1406 error_message
= ": There are only 32 f registers; [0-31]";
1414 } /* if not an 'f' register. */
1421 opcode
|= RS1 (mask
);
1428 opcode
|= RS2 (mask
);
1434 opcode
|= RD (mask
);
1443 if (strncmp (s
, "%fsr", 4) == 0)
1450 case 'h': /* high 22 bits */
1451 the_insn
.reloc
= BFD_RELOC_HI22
;
1454 case 'l': /* 22 bit PC relative immediate */
1455 the_insn
.reloc
= BFD_RELOC_SPARC_WDISP22
;
1459 case 'L': /* 30 bit immediate */
1460 the_insn
.reloc
= BFD_RELOC_32_PCREL_S2
;
1464 case 'n': /* 22 bit immediate */
1465 the_insn
.reloc
= BFD_RELOC_SPARC22
;
1468 case 'i': /* 13 bit immediate */
1469 the_insn
.reloc
= BFD_RELOC_SPARC13
;
1470 immediate_max
= 0x0FFF;
1479 if ((c
= s
[1]) == 'h' && s
[2] == 'i')
1481 the_insn
.reloc
= BFD_RELOC_HI22
;
1484 else if (c
== 'l' && s
[2] == 'o')
1486 the_insn
.reloc
= BFD_RELOC_LO10
;
1493 the_insn
.reloc
= BFD_RELOC_SPARC_HH22
;
1501 the_insn
.reloc
= BFD_RELOC_SPARC_HM10
;
1508 /* Note that if the getExpression() fails, we will still
1509 have created U entries in the symbol table for the
1510 'symbols' in the input string. Try not to create U
1511 symbols for registers, etc. */
1513 /* This stuff checks to see if the expression ends in
1514 +%reg. If it does, it removes the register from
1515 the expression, and re-sets 's' to point to the
1520 for (s1
= s
; *s1
&& *s1
!= ',' && *s1
!= ']'; s1
++);;
1522 if (s1
!= s
&& isdigit (s1
[-1]))
1524 if (s1
[-2] == '%' && s1
[-3] == '+')
1528 (void) getExpression (s
);
1533 else if (strchr ("goli0123456789", s1
[-2]) && s1
[-3] == '%' && s1
[-4] == '+')
1537 (void) getExpression (s
);
1544 (void) getExpression (s
);
1547 if (the_insn
.exp
.X_op
== O_constant
1548 && the_insn
.exp
.X_add_symbol
== 0
1549 && the_insn
.exp
.X_op_symbol
== 0)
1551 /* Handle %uhi/%ulo by moving the upper word to the lower
1552 one and pretending it's %hi/%lo. We also need to watch
1553 for %hi/%lo: the top word needs to be zeroed otherwise
1554 fixup_segment will complain the value is too big. */
1555 switch (the_insn
.reloc
)
1557 case BFD_RELOC_SPARC_HH22
:
1558 the_insn
.reloc
= BFD_RELOC_HI22
;
1559 the_insn
.exp
.X_add_number
= BSR (the_insn
.exp
.X_add_number
, 32);
1561 case BFD_RELOC_SPARC_HM10
:
1562 the_insn
.reloc
= BFD_RELOC_LO10
;
1563 the_insn
.exp
.X_add_number
= BSR (the_insn
.exp
.X_add_number
, 32);
1565 case BFD_RELOC_HI22
:
1566 case BFD_RELOC_LO10
:
1567 the_insn
.exp
.X_add_number
&= 0xffffffff;
1573 /* For pc-relative call instructions, we reject
1574 constants to get better code. */
1576 && the_insn
.reloc
== BFD_RELOC_32_PCREL_S2
1577 && in_signed_range (the_insn
.exp
.X_add_number
, 0x3fff)
1580 error_message
= ": PC-relative operand can't be a constant";
1583 /* Check for invalid constant values. Don't warn if
1584 constant was inside %hi or %lo, since these
1585 truncate the constant to fit. */
1586 if (immediate_max
!= 0
1587 && the_insn
.reloc
!= BFD_RELOC_LO10
1588 && the_insn
.reloc
!= BFD_RELOC_HI22
1589 && !in_signed_range (the_insn
.exp
.X_add_number
,
1594 /* Who knows? After relocation, we may be within
1595 range. Let the linker figure it out. */
1597 the_insn
.exp
.X_op
= O_symbol
;
1598 the_insn
.exp
.X_add_symbol
= section_symbol (absolute_section
);
1601 /* Immediate value is non-pcrel, and out of
1603 as_bad ("constant value %ld out of range (%ld .. %ld)",
1604 the_insn
.exp
.X_add_number
,
1605 ~immediate_max
, immediate_max
);
1609 /* Reset to prevent extraneous range check. */
1629 if (! parse_keyword_arg (sparc_encode_asi
, &s
, &asi
))
1631 error_message
= ": invalid ASI name";
1637 if (! parse_const_expr_arg (&s
, &asi
))
1639 error_message
= ": invalid ASI expression";
1642 if (asi
< 0 || asi
> 255)
1644 error_message
= ": invalid ASI number";
1648 opcode
|= ASI (asi
);
1650 } /* alternate space */
1653 if (strncmp (s
, "%psr", 4) == 0)
1660 case 'q': /* floating point queue */
1661 if (strncmp (s
, "%fq", 3) == 0)
1668 case 'Q': /* coprocessor queue */
1669 if (strncmp (s
, "%cq", 3) == 0)
1677 if (strcmp (str
, "set") == 0)
1679 special_case
= SPECIAL_CASE_SET
;
1682 else if (strncmp (str
, "fdiv", 4) == 0)
1684 special_case
= SPECIAL_CASE_FDIV
;
1690 if (strncmp (s
, "%asi", 4) != 0)
1696 if (strncmp (s
, "%fprs", 5) != 0)
1702 if (strncmp (s
, "%ccr", 4) != 0)
1708 if (strncmp (s
, "%tbr", 4) != 0)
1714 if (strncmp (s
, "%wim", 4) != 0)
1721 char *push
= input_line_pointer
;
1724 input_line_pointer
= s
;
1726 if (e
.X_op
== O_constant
)
1728 int n
= e
.X_add_number
;
1729 if (n
!= e
.X_add_number
|| (n
& ~0x1ff) != 0)
1730 as_bad ("OPF immediate operand out of range (0-0x1ff)");
1732 opcode
|= e
.X_add_number
<< 5;
1735 as_bad ("non-immediate OPF operand, ignored");
1736 s
= input_line_pointer
;
1737 input_line_pointer
= push
;
1742 if (strncmp (s
, "%y", 2) != 0)
1748 as_fatal ("failed sanity check.");
1749 } /* switch on arg code */
1751 /* Break out of for() loop. */
1753 } /* for each arg that we expect */
1758 /* Args don't match. */
1759 if (((unsigned) (&insn
[1] - sparc_opcodes
)) < sparc_num_opcodes
1760 && (insn
->name
== insn
[1].name
1761 || !strcmp (insn
->name
, insn
[1].name
)))
1769 as_bad ("Illegal operands%s", error_message
);
1775 /* We have a match. Now see if the architecture is ok. */
1776 int needed_arch_mask
= insn
->architecture
;
1780 needed_arch_mask
&= ~ ((1 << SPARC_OPCODE_ARCH_V9
)
1781 | (1 << SPARC_OPCODE_ARCH_V9A
));
1782 needed_arch_mask
|= (1 << SPARC_OPCODE_ARCH_V9
);
1785 if (needed_arch_mask
& SPARC_OPCODE_SUPPORTED (current_architecture
))
1787 /* Can we bump up the architecture? */
1788 else if (needed_arch_mask
& SPARC_OPCODE_SUPPORTED (max_architecture
))
1790 enum sparc_opcode_arch_val needed_architecture
=
1791 sparc_ffs (SPARC_OPCODE_SUPPORTED (max_architecture
)
1792 & needed_arch_mask
);
1794 assert (needed_architecture
<= SPARC_OPCODE_ARCH_MAX
);
1796 && needed_architecture
> warn_after_architecture
)
1798 as_warn ("architecture bumped from \"%s\" to \"%s\" on \"%s\"",
1799 sparc_opcode_archs
[current_architecture
].name
,
1800 sparc_opcode_archs
[needed_architecture
].name
,
1802 warn_after_architecture
= needed_architecture
;
1804 current_architecture
= needed_architecture
;
1809 enum sparc_opcode_arch_val needed_architecture
=
1810 sparc_ffs (~ SPARC_OPCODE_SUPPORTED (max_architecture
)
1811 & needed_arch_mask
);
1813 assert (needed_architecture
<= SPARC_OPCODE_ARCH_MAX
);
1814 as_bad ("Architecture mismatch on \"%s\".", str
);
1815 as_tsktsk (" (Requires %s; requested architecture is %s.)",
1816 sparc_opcode_archs
[needed_architecture
].name
,
1817 sparc_opcode_archs
[max_architecture
].name
);
1823 } /* forever looking for a match */
1825 the_insn
.opcode
= opcode
;
1835 save_in
= input_line_pointer
;
1836 input_line_pointer
= str
;
1837 seg
= expression (&the_insn
.exp
);
1838 if (seg
!= absolute_section
1839 && seg
!= text_section
1840 && seg
!= data_section
1841 && seg
!= bss_section
1842 && seg
!= undefined_section
)
1844 the_insn
.error
= "bad segment";
1845 expr_end
= input_line_pointer
;
1846 input_line_pointer
= save_in
;
1849 expr_end
= input_line_pointer
;
1850 input_line_pointer
= save_in
;
1852 } /* getExpression() */
1856 This is identical to the md_atof in m68k.c. I think this is right,
1859 Turn a string in input_line_pointer into a floating point constant of type
1860 type, and store the appropriate bytes in *litP. The number of LITTLENUMS
1861 emitted is stored in *sizeP . An error message is returned, or NULL on OK.
1864 /* Equal to MAX_PRECISION in atof-ieee.c */
1865 #define MAX_LITTLENUMS 6
1868 md_atof (type
, litP
, sizeP
)
1874 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
1875 LITTLENUM_TYPE
*wordP
;
1908 return "Bad call to MD_ATOF()";
1910 t
= atof_ieee (input_line_pointer
, type
, words
);
1912 input_line_pointer
= t
;
1913 *sizeP
= prec
* sizeof (LITTLENUM_TYPE
);
1914 for (wordP
= words
; prec
--;)
1916 md_number_to_chars (litP
, (valueT
) (*wordP
++), sizeof (LITTLENUM_TYPE
));
1917 litP
+= sizeof (LITTLENUM_TYPE
);
1923 * Write out big-endian.
1926 md_number_to_chars (buf
, val
, n
)
1931 number_to_chars_bigendian (buf
, val
, n
);
1934 /* Apply a fixS to the frags, now that we know the value it ought to
1938 md_apply_fix (fixP
, value
)
1942 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
1947 assert (fixP
->fx_r_type
< BFD_RELOC_UNUSED
);
1949 fixP
->fx_addnumber
= val
; /* Remember value for emit_reloc */
1952 /* FIXME: SPARC ELF relocations don't use an addend in the data
1953 field itself. This whole approach should be somehow combined
1954 with the calls to bfd_perform_relocation. Also, the value passed
1955 in by fixup_segment includes the value of a defined symbol. We
1956 don't want to include the value of an externally visible symbol. */
1957 if (fixP
->fx_addsy
!= NULL
)
1959 if ((S_IS_EXTERNAL (fixP
->fx_addsy
)
1960 || S_IS_WEAK (fixP
->fx_addsy
)
1961 || (sparc_pic_code
&& ! fixP
->fx_pcrel
))
1962 && S_GET_SEGMENT (fixP
->fx_addsy
) != absolute_section
1963 && S_GET_SEGMENT (fixP
->fx_addsy
) != undefined_section
1964 && ! bfd_is_com_section (S_GET_SEGMENT (fixP
->fx_addsy
)))
1965 fixP
->fx_addnumber
-= S_GET_VALUE (fixP
->fx_addsy
);
1970 /* This is a hack. There should be a better way to
1971 handle this. Probably in terms of howto fields, once
1972 we can look at these fixups in terms of howtos. */
1973 if (fixP
->fx_r_type
== BFD_RELOC_32_PCREL_S2
&& fixP
->fx_addsy
)
1974 val
+= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
1977 /* FIXME: More ridiculous gas reloc hacking. If we are going to
1978 generate a reloc, then we just want to let the reloc addend set
1979 the value. We do not want to also stuff the addend into the
1980 object file. Including the addend in the object file works when
1981 doing a static link, because the linker will ignore the object
1982 file contents. However, the dynamic linker does not ignore the
1983 object file contents. */
1984 if (fixP
->fx_addsy
!= NULL
1985 && fixP
->fx_r_type
!= BFD_RELOC_32_PCREL_S2
)
1988 /* When generating PIC code, we do not want an addend for a reloc
1989 against a local symbol. We adjust fx_addnumber to cancel out the
1990 value already included in val, and to also cancel out the
1991 adjustment which bfd_install_relocation will create. */
1993 && fixP
->fx_r_type
!= BFD_RELOC_32_PCREL_S2
1994 && fixP
->fx_addsy
!= NULL
1995 && ! S_IS_COMMON (fixP
->fx_addsy
)
1996 && (fixP
->fx_addsy
->bsym
->flags
& BSF_SECTION_SYM
) == 0)
1997 fixP
->fx_addnumber
-= 2 * S_GET_VALUE (fixP
->fx_addsy
);
2000 switch (fixP
->fx_r_type
)
2014 case BFD_RELOC_32_PCREL_S2
:
2016 if (! sparc_pic_code
2017 || fixP
->fx_addsy
== NULL
2018 || (fixP
->fx_addsy
->bsym
->flags
& BSF_SECTION_SYM
) != 0)
2020 buf
[0] |= (val
>> 24) & 0x3f;
2021 buf
[1] = (val
>> 16);
2028 bfd_vma valh
= BSR (val
, 32);
2029 buf
[0] = valh
>> 24;
2030 buf
[1] = valh
>> 16;
2040 case BFD_RELOC_SPARC_11
:
2041 if (((val
> 0) && (val
& ~0x7ff))
2042 || ((val
< 0) && (~(val
- 1) & ~0x7ff)))
2044 as_bad ("relocation overflow.");
2047 buf
[2] |= (val
>> 8) & 0x7;
2048 buf
[3] = val
& 0xff;
2051 case BFD_RELOC_SPARC_10
:
2052 if (((val
> 0) && (val
& ~0x3ff))
2053 || ((val
< 0) && (~(val
- 1) & ~0x3ff)))
2055 as_bad ("relocation overflow.");
2058 buf
[2] |= (val
>> 8) & 0x3;
2059 buf
[3] = val
& 0xff;
2062 case BFD_RELOC_SPARC_WDISP16
:
2063 if (((val
> 0) && (val
& ~0x3fffc))
2064 || ((val
< 0) && (~(val
- 1) & ~0x3fffc)))
2066 as_bad ("relocation overflow.");
2069 val
= (val
>>= 2) + 1;
2070 buf
[1] |= ((val
>> 14) & 0x3) << 4;
2071 buf
[2] |= (val
>> 8) & 0x3f;
2072 buf
[3] = val
& 0xff;
2075 case BFD_RELOC_SPARC_WDISP19
:
2076 if (((val
> 0) && (val
& ~0x1ffffc))
2077 || ((val
< 0) && (~(val
- 1) & ~0x1ffffc)))
2079 as_bad ("relocation overflow.");
2082 val
= (val
>>= 2) + 1;
2083 buf
[1] |= (val
>> 16) & 0x7;
2084 buf
[2] = (val
>> 8) & 0xff;
2085 buf
[3] = val
& 0xff;
2088 case BFD_RELOC_SPARC_HH22
:
2089 val
= BSR (val
, 32);
2090 /* intentional fallthrough */
2092 case BFD_RELOC_SPARC_LM22
:
2093 case BFD_RELOC_HI22
:
2094 if (!fixP
->fx_addsy
)
2096 buf
[1] |= (val
>> 26) & 0x3f;
2107 case BFD_RELOC_SPARC22
:
2108 if (val
& ~0x003fffff)
2110 as_bad ("relocation overflow");
2112 buf
[1] |= (val
>> 16) & 0x3f;
2114 buf
[3] = val
& 0xff;
2117 case BFD_RELOC_SPARC_HM10
:
2118 val
= BSR (val
, 32);
2119 /* intentional fallthrough */
2121 case BFD_RELOC_LO10
:
2122 if (!fixP
->fx_addsy
)
2124 buf
[2] |= (val
>> 8) & 0x03;
2131 case BFD_RELOC_SPARC13
:
2132 if (! in_signed_range (val
, 0x1fff))
2133 as_bad ("relocation overflow");
2135 buf
[2] |= (val
>> 8) & 0x1f;
2139 case BFD_RELOC_SPARC_WDISP22
:
2140 val
= (val
>> 2) + 1;
2142 case BFD_RELOC_SPARC_BASE22
:
2143 buf
[1] |= (val
>> 16) & 0x3f;
2148 case BFD_RELOC_NONE
:
2150 as_bad ("bad or unhandled relocation type: 0x%02x", fixP
->fx_r_type
);
2154 /* Are we finished with this relocation now? */
2155 if (fixP
->fx_addsy
== 0 && !fixP
->fx_pcrel
)
2161 /* Translate internal representation of relocation info to BFD target
2164 tc_gen_reloc (section
, fixp
)
2169 bfd_reloc_code_real_type code
;
2171 reloc
= (arelent
*) bfd_alloc_by_size_t (stdoutput
, sizeof (arelent
));
2172 assert (reloc
!= 0);
2174 reloc
->sym_ptr_ptr
= &fixp
->fx_addsy
->bsym
;
2175 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2177 switch (fixp
->fx_r_type
)
2181 case BFD_RELOC_HI22
:
2182 case BFD_RELOC_LO10
:
2183 case BFD_RELOC_32_PCREL_S2
:
2184 case BFD_RELOC_SPARC13
:
2185 case BFD_RELOC_SPARC_BASE13
:
2186 case BFD_RELOC_SPARC_WDISP16
:
2187 case BFD_RELOC_SPARC_WDISP19
:
2188 case BFD_RELOC_SPARC_WDISP22
:
2190 case BFD_RELOC_SPARC_10
:
2191 case BFD_RELOC_SPARC_11
:
2192 case BFD_RELOC_SPARC_HH22
:
2193 case BFD_RELOC_SPARC_HM10
:
2194 case BFD_RELOC_SPARC_LM22
:
2195 case BFD_RELOC_SPARC_PC_HH22
:
2196 case BFD_RELOC_SPARC_PC_HM10
:
2197 case BFD_RELOC_SPARC_PC_LM22
:
2198 code
= fixp
->fx_r_type
;
2204 #if defined (OBJ_ELF) || defined (OBJ_AOUT)
2205 /* If we are generating PIC code, we need to generate a different
2209 #define GOT_NAME "_GLOBAL_OFFSET_TABLE_"
2211 #define GOT_NAME "__GLOBAL_OFFSET_TABLE_"
2218 case BFD_RELOC_32_PCREL_S2
:
2219 if (! S_IS_DEFINED (fixp
->fx_addsy
)
2220 || S_IS_EXTERNAL (fixp
->fx_addsy
)
2221 || S_IS_WEAK (fixp
->fx_addsy
))
2222 code
= BFD_RELOC_SPARC_WPLT30
;
2224 case BFD_RELOC_HI22
:
2225 if (fixp
->fx_addsy
!= NULL
2226 && strcmp (S_GET_NAME (fixp
->fx_addsy
), GOT_NAME
) == 0)
2227 code
= BFD_RELOC_SPARC_PC22
;
2229 code
= BFD_RELOC_SPARC_GOT22
;
2231 case BFD_RELOC_LO10
:
2232 if (fixp
->fx_addsy
!= NULL
2233 && strcmp (S_GET_NAME (fixp
->fx_addsy
), GOT_NAME
) == 0)
2234 code
= BFD_RELOC_SPARC_PC10
;
2236 code
= BFD_RELOC_SPARC_GOT10
;
2238 case BFD_RELOC_SPARC13
:
2239 code
= BFD_RELOC_SPARC_GOT13
;
2245 #endif /* defined (OBJ_ELF) || defined (OBJ_AOUT) */
2247 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
2248 if (reloc
->howto
== 0)
2250 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2251 "internal error: can't export reloc type %d (`%s')",
2252 fixp
->fx_r_type
, bfd_get_reloc_code_name (code
));
2256 /* @@ Why fx_addnumber sometimes and fx_offset other times? */
2259 if (reloc
->howto
->pc_relative
== 0
2260 || code
== BFD_RELOC_SPARC_PC10
2261 || code
== BFD_RELOC_SPARC_PC22
)
2262 reloc
->addend
= fixp
->fx_addnumber
;
2264 reloc
->addend
= fixp
->fx_offset
- reloc
->address
;
2266 #else /* elf or coff */
2268 if (reloc
->howto
->pc_relative
== 0
2269 || code
== BFD_RELOC_SPARC_PC10
2270 || code
== BFD_RELOC_SPARC_PC22
)
2271 reloc
->addend
= fixp
->fx_addnumber
;
2272 else if ((fixp
->fx_addsy
->bsym
->flags
& BSF_SECTION_SYM
) != 0)
2273 reloc
->addend
= (section
->vma
2274 + fixp
->fx_addnumber
2275 + md_pcrel_from (fixp
));
2277 reloc
->addend
= fixp
->fx_offset
;
2285 /* for debugging only */
2288 struct sparc_it
*insn
;
2290 const char *const Reloc
[] = {
2319 fprintf (stderr
, "ERROR: %s\n");
2320 fprintf (stderr
, "opcode=0x%08x\n", insn
->opcode
);
2321 fprintf (stderr
, "reloc = %s\n", Reloc
[insn
->reloc
]);
2322 fprintf (stderr
, "exp = {\n");
2323 fprintf (stderr
, "\t\tX_add_symbol = %s\n",
2324 ((insn
->exp
.X_add_symbol
!= NULL
)
2325 ? ((S_GET_NAME (insn
->exp
.X_add_symbol
) != NULL
)
2326 ? S_GET_NAME (insn
->exp
.X_add_symbol
)
2329 fprintf (stderr
, "\t\tX_sub_symbol = %s\n",
2330 ((insn
->exp
.X_op_symbol
!= NULL
)
2331 ? (S_GET_NAME (insn
->exp
.X_op_symbol
)
2332 ? S_GET_NAME (insn
->exp
.X_op_symbol
)
2335 fprintf (stderr
, "\t\tX_add_number = %d\n",
2336 insn
->exp
.X_add_number
);
2337 fprintf (stderr
, "}\n");
2343 * Invocation line includes a switch not recognized by the base assembler.
2344 * See if it's a processor-specific option. These are:
2347 * Warn on architecture bumps. See also -A.
2349 * -Av6, -Av7, -Av8, -Av9, -Av9a, -Asparclite
2350 * -xarch=v8plus, -xarch=v8plusa
2351 * Select the architecture. Instructions or features not
2352 * supported by the selected architecture cause fatal errors.
2354 * The default is to start at v6, and bump the architecture up
2355 * whenever an instruction is seen at a higher level. If 32 bit
2356 * environments, v9 is not bumped up to, the user must pass -Av9.
2358 * -xarch=v8plus{,a} is for compatibility with the Sun assembler.
2360 * If -bump is specified, a warning is printing when bumping to
2363 * If an architecture is specified, all instructions must match
2364 * that architecture. Any higher level instructions are flagged
2365 * as errors. Note that in the 32 bit environment specifying
2366 * -Av9 does not automatically create a v9 object file, a v9
2367 * insn must be seen.
2369 * If both an architecture and -bump are specified, the
2370 * architecture starts at the specified level, but bumps are
2371 * warnings. Note that we can't set `current_architecture' to
2372 * the requested level in this case: in the 32 bit environment,
2373 * we still must avoid creating v9 object files unless v9 insns
2377 * Bumping between incompatible architectures is always an
2378 * error. For example, from sparclite to v9.
2382 CONST
char *md_shortopts
= "A:K:VQ:sq";
2385 CONST
char *md_shortopts
= "A:k";
2387 CONST
char *md_shortopts
= "A:";
2390 struct option md_longopts
[] = {
2391 #define OPTION_BUMP (OPTION_MD_BASE)
2392 {"bump", no_argument
, NULL
, OPTION_BUMP
},
2393 #define OPTION_SPARC (OPTION_MD_BASE + 1)
2394 {"sparc", no_argument
, NULL
, OPTION_SPARC
},
2395 #define OPTION_XARCH (OPTION_MD_BASE + 2)
2396 {"xarch", required_argument
, NULL
, OPTION_XARCH
},
2397 {NULL
, no_argument
, NULL
, 0}
2399 size_t md_longopts_size
= sizeof(md_longopts
);
2402 md_parse_option (c
, arg
)
2410 warn_after_architecture
= SPARC_OPCODE_ARCH_V6
;
2414 /* ??? We could add v8plus and v8plusa to sparc_opcode_archs.
2415 But we might want v8plus to mean something different than v9
2416 someday, and we'd recognize more -xarch options than Sun's
2417 assembler does (which may lead to a conflict someday). */
2418 if (strcmp (arg
, "v8plus") == 0)
2420 else if (strcmp (arg
, "v8plusa") == 0)
2424 as_bad ("invalid architecture -xarch=%s", arg
);
2432 enum sparc_opcode_arch_val new_arch
= sparc_opcode_lookup_arch (arg
);
2434 if (new_arch
== SPARC_OPCODE_ARCH_BAD
)
2436 as_bad ("invalid architecture -A%s", arg
);
2441 max_architecture
= new_arch
;
2442 architecture_requested
= 1;
2448 /* Ignore -sparc, used by SunOS make default .s.o rule. */
2459 print_version_id ();
2463 /* Qy - do emit .comment
2464 Qn - do not emit .comment */
2468 /* use .stab instead of .stab.excl */
2472 /* quick -- native assembler does fewer checks */
2476 if (strcmp (arg
, "PIC") != 0)
2477 as_warn ("Unrecognized option following -K");
2491 md_show_usage (stream
)
2494 const struct sparc_opcode_arch
*arch
;
2496 fprintf(stream
, "SPARC options:\n");
2497 for (arch
= &sparc_opcode_archs
[0]; arch
->name
; arch
++)
2499 if (arch
!= &sparc_opcode_archs
[0])
2500 fprintf (stream
, " | ");
2501 fprintf (stream
, "-A%s", arch
->name
);
2503 fprintf (stream
, "\n-xarch=v8plus | -xarch=v8plusa\n");
2505 specify variant of SPARC architecture\n\
2506 -bump warn when assembler switches architectures\n\
2510 -k generate PIC\n");
2514 -KPIC generate PIC\n\
2515 -V print assembler version number\n\
2522 /* We have no need to default values of symbols. */
2526 md_undefined_symbol (name
)
2530 } /* md_undefined_symbol() */
2532 /* Round up a section size to the appropriate boundary. */
2534 md_section_align (segment
, size
)
2539 /* This is not right for ELF; a.out wants it, and COFF will force
2540 the alignment anyways. */
2541 valueT align
= ((valueT
) 1
2542 << (valueT
) bfd_get_section_alignment (stdoutput
, segment
));
2544 /* turn alignment value into a mask */
2546 newsize
= (size
+ align
) & ~align
;
2553 /* Exactly what point is a PC-relative offset relative TO?
2554 On the sparc, they're relative to the address of the offset, plus
2555 its size. This gets us to the following instruction.
2556 (??? Is this right? FIXME-SOON) */
2558 md_pcrel_from (fixP
)
2563 ret
= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
2564 if (! sparc_pic_code
2565 || fixP
->fx_addsy
== NULL
2566 || (fixP
->fx_addsy
->bsym
->flags
& BSF_SECTION_SYM
) != 0)
2567 ret
+= fixP
->fx_size
;
2571 /* end of tc-sparc.c */