1 /* tc-arc.c -- Assembler for the ARC
2 Copyright 1994, 1995, 1997, 1999, 2000, 2001
3 Free Software Foundation, Inc.
4 Contributed by Doug Evans (dje@cygnus.com).
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 #include "libiberty.h"
28 #include "opcode/arc.h"
29 #include "../opcodes/arc-ext.h"
32 extern int arc_get_mach
PARAMS ((char *));
33 extern int arc_operand_type
PARAMS ((int));
34 extern int arc_insn_not_jl
PARAMS ((arc_insn
));
35 extern int arc_limm_fixup_adjust
PARAMS ((arc_insn
));
36 extern int arc_get_noshortcut_flag
PARAMS ((void));
37 extern int arc_set_ext_seg
PARAMS ((void));
38 extern void arc_code_symbol
PARAMS ((expressionS
*));
40 static arc_insn arc_insert_operand
PARAMS ((arc_insn
,
41 const struct arc_operand
*, int,
42 const struct arc_operand_value
*,
43 offsetT
, char *, unsigned int));
44 static void arc_common
PARAMS ((int));
45 static void arc_extinst
PARAMS ((int));
46 static void arc_extoper
PARAMS ((int));
47 static void arc_option
PARAMS ((int));
48 static int get_arc_exp_reloc_type
PARAMS ((int, int, expressionS
*,
51 const struct suffix_classes
{
55 { "SUFFIX_COND|SUFFIX_FLAG",23 },
56 { "SUFFIX_FLAG", 11 },
57 { "SUFFIX_COND", 11 },
61 #define MAXSUFFIXCLASS (sizeof (suffixclass) / sizeof (struct suffix_classes))
63 const struct syntax_classes
{
68 { "SYNTAX_3OP|OP1_MUST_BE_IMM", 26, SYNTAX_3OP
|OP1_MUST_BE_IMM
|SYNTAX_VALID
},
69 { "OP1_MUST_BE_IMM|SYNTAX_3OP", 26, OP1_MUST_BE_IMM
|SYNTAX_3OP
|SYNTAX_VALID
},
70 { "SYNTAX_2OP|OP1_IMM_IMPLIED", 26, SYNTAX_2OP
|OP1_IMM_IMPLIED
|SYNTAX_VALID
},
71 { "OP1_IMM_IMPLIED|SYNTAX_2OP", 26, OP1_IMM_IMPLIED
|SYNTAX_2OP
|SYNTAX_VALID
},
72 { "SYNTAX_3OP", 10, SYNTAX_3OP
|SYNTAX_VALID
},
73 { "SYNTAX_2OP", 10, SYNTAX_2OP
|SYNTAX_VALID
}
76 #define MAXSYNTAXCLASS (sizeof (syntaxclass) / sizeof (struct syntax_classes))
78 const pseudo_typeS md_pseudo_table
[] = {
79 { "align", s_align_bytes
, 0 }, /* Defaulting is invalid (0) */
80 { "comm", arc_common
, 0 },
81 { "common", arc_common
, 0 },
82 { "lcomm", arc_common
, 1 },
83 { "lcommon", arc_common
, 1 },
90 { "option", arc_option
, 0 },
91 { "block", s_space
, 0 },
92 { "extcondcode", arc_extoper
, 0 },
93 { "extcoreregister", arc_extoper
, 1 },
94 { "extauxregister", arc_extoper
, 2 },
95 { "extinstruction", arc_extinst
, 0 },
99 /* This array holds the chars that always start a comment. If the
100 pre-processor is disabled, these aren't very useful */
101 const char comment_chars
[] = "#;";
103 /* This array holds the chars that only start a comment at the beginning of
104 a line. If the line seems to have the form '# 123 filename'
105 .line and .file directives will appear in the pre-processed output */
106 /* Note that input_file.c hand checks for '#' at the beginning of the
107 first line of the input file. This is because the compiler outputs
108 #NO_APP at the beginning of its output. */
109 /* Also note that comments started like this one will always
110 work if '/' isn't otherwise defined. */
111 const char line_comment_chars
[] = "#";
113 const char line_separator_chars
[] = "";
115 /* Chars that can be used to separate mant from exp in floating point nums */
116 const char EXP_CHARS
[] = "eE";
118 /* Chars that mean this number is a floating point constant */
121 const char FLT_CHARS
[] = "rRsSfFdD";
124 extern int target_big_endian
;
125 const char *arc_target_format
= DEFAULT_TARGET_FORMAT
;
126 static int byte_order
= DEFAULT_BYTE_ORDER
;
128 static segT arcext_section
;
130 /* One of bfd_mach_arc_n. */
131 static int arc_mach_type
= bfd_mach_arc_5
;
133 /* Non-zero if the cpu type has been explicitly specified. */
134 static int mach_type_specified_p
= 0;
136 /* Non-zero if opcode tables have been initialized.
137 A .cpu command must appear before any instructions. */
138 static int cpu_tables_init_p
= 0;
140 static struct hash_control
*arc_suffix_hash
= NULL
;
142 const char *md_shortopts
= "";
143 struct option md_longopts
[] = {
144 #define OPTION_EB (OPTION_MD_BASE + 0)
145 {"EB", no_argument
, NULL
, OPTION_EB
},
146 #define OPTION_EL (OPTION_MD_BASE + 1)
147 {"EL", no_argument
, NULL
, OPTION_EL
},
148 #define OPTION_ARC5 (OPTION_MD_BASE + 2)
149 {"marc5", no_argument
, NULL
, OPTION_ARC5
},
150 #define OPTION_ARC6 (OPTION_MD_BASE + 3)
151 {"marc6", no_argument
, NULL
, OPTION_ARC6
},
152 #define OPTION_ARC7 (OPTION_MD_BASE + 4)
153 {"marc7", no_argument
, NULL
, OPTION_ARC7
},
154 #define OPTION_ARC8 (OPTION_MD_BASE + 5)
155 {"marc8", no_argument
, NULL
, OPTION_ARC8
},
156 #define OPTION_ARC (OPTION_MD_BASE + 6)
157 {"marc", no_argument
, NULL
, OPTION_ARC
},
158 { NULL
, no_argument
, NULL
, 0 }
160 size_t md_longopts_size
= sizeof (md_longopts
);
162 #define IS_SYMBOL_OPERAND(o) \
163 ((o) == 'b' || (o) == 'c' || (o) == 's' || (o) == 'o' || (o) == 'O')
165 struct arc_operand_value
*get_ext_suffix (char *s
);
167 /* Invocation line includes a switch not recognized by the base assembler.
168 See if it's a processor-specific option. */
171 md_parse_option (c
, arg
)
173 char *arg ATTRIBUTE_UNUSED
;
179 arc_mach_type
= bfd_mach_arc_5
;
182 arc_mach_type
= bfd_mach_arc_6
;
185 arc_mach_type
= bfd_mach_arc_7
;
188 arc_mach_type
= bfd_mach_arc_8
;
191 byte_order
= BIG_ENDIAN
;
192 arc_target_format
= "elf32-bigarc";
195 byte_order
= LITTLE_ENDIAN
;
196 arc_target_format
= "elf32-littlearc";
205 md_show_usage (stream
)
210 -marc[5|6|7|8] select processor variant (default arc%d)\n\
211 -EB assemble code for a big endian cpu\n\
212 -EL assemble code for a little endian cpu\n", arc_mach_type
+ 5);
215 /* This function is called once, at assembler startup time. It should
216 set up all the tables, etc. that the MD part of the assembler will need.
217 Opcode selection is defered until later because we might see a .cpu
223 /* The endianness can be chosen "at the factory". */
224 target_big_endian
= byte_order
== BIG_ENDIAN
;
226 if (!bfd_set_arch_mach (stdoutput
, bfd_arch_arc
, arc_mach_type
))
227 as_warn ("could not set architecture and machine");
229 /* This call is necessary because we need to
230 initialize `arc_operand_map' which may be needed before we see the
232 arc_opcode_init_tables (arc_get_opcode_mach (arc_mach_type
,
236 /* Initialize the various opcode and operand tables.
237 MACH is one of bfd_mach_arc_xxx. */
240 init_opcode_tables (mach
)
246 if ((arc_suffix_hash
= hash_new ()) == NULL
)
247 as_fatal ("virtual memory exhausted");
249 if (!bfd_set_arch_mach (stdoutput
, bfd_arch_arc
, mach
))
250 as_warn ("could not set architecture and machine");
252 /* This initializes a few things in arc-opc.c that we need.
253 This must be called before the various arc_xxx_supported fns. */
254 arc_opcode_init_tables (arc_get_opcode_mach (mach
, target_big_endian
));
256 /* Only put the first entry of each equivalently named suffix in the
259 for (i
= 0; i
< arc_suffixes_count
; i
++)
261 if (strcmp (arc_suffixes
[i
].name
, last
) != 0)
262 hash_insert (arc_suffix_hash
, arc_suffixes
[i
].name
, (PTR
) (arc_suffixes
+ i
));
263 last
= arc_suffixes
[i
].name
;
266 /* Since registers don't have a prefix, we put them in the symbol table so
267 they can't be used as symbols. This also simplifies argument parsing as
268 we can let gas parse registers for us. The recorded register number is
269 the address of the register's entry in arc_reg_names.
271 If the register name is already in the table, then the existing
272 definition is assumed to be from an .ExtCoreRegister pseudo-op. */
274 for (i
= 0; i
< arc_reg_names_count
; i
++)
276 if (symbol_find (arc_reg_names
[i
].name
))
278 /* Use symbol_create here instead of symbol_new so we don't try to
279 output registers into the object file's symbol table. */
280 symbol_table_insert (symbol_create (arc_reg_names
[i
].name
, reg_section
,
281 (int) &arc_reg_names
[i
], &zero_address_frag
));
284 /* Tell `.option' it's too late. */
285 cpu_tables_init_p
= 1;
288 /* Insert an operand value into an instruction.
289 If REG is non-NULL, it is a register number and ignore VAL. */
292 arc_insert_operand (insn
, operand
, mods
, reg
, val
, file
, line
)
294 const struct arc_operand
*operand
;
296 const struct arc_operand_value
*reg
;
301 if (operand
->bits
!= 32)
306 if ((operand
->flags
& ARC_OPERAND_SIGNED
) != 0)
308 if ((operand
->flags
& ARC_OPERAND_SIGNOPT
) != 0)
309 max
= (1 << operand
->bits
) - 1;
311 max
= (1 << (operand
->bits
- 1)) - 1;
312 min
= - (1 << (operand
->bits
- 1));
316 max
= (1 << operand
->bits
) - 1;
320 if ((operand
->flags
& ARC_OPERAND_NEGATIVE
) != 0)
325 if (test
< (offsetT
) min
|| test
> (offsetT
) max
)
328 "operand out of range (%s not between %ld and %ld)";
331 sprint_value (buf
, test
);
332 if (file
== (char *) NULL
)
333 as_warn (err
, buf
, min
, max
);
335 as_warn_where (file
, line
, err
, buf
, min
, max
);
344 insn
= (*operand
->insert
) (insn
, operand
, mods
, reg
, (long) val
, &errmsg
);
345 if (errmsg
!= (const char *) NULL
)
349 insn
|= (((long) val
& ((1 << operand
->bits
) - 1))
355 /* We need to keep a list of fixups. We can't simply generate them as
356 we go, because that would require us to first create the frag, and
357 that would screw up references to ``.''. */
360 /* index into `arc_operands' */
367 #define MAX_SUFFIXES 5
369 /* This routine is called for each instruction to be assembled. */
375 const struct arc_opcode
*opcode
;
376 const struct arc_opcode
*std_opcode
;
377 struct arc_opcode
*ext_opcode
;
379 const char *last_errmsg
= 0;
381 static int init_tables_p
= 0;
383 /* Opcode table initialization is deferred until here because we have to
384 wait for a possible .cpu command. */
387 init_opcode_tables (arc_mach_type
);
391 /* Skip leading white space. */
392 while (isspace (*str
))
395 /* The instructions are stored in lists hashed by the first letter (though
396 we needn't care how they're hashed). Get the first in the list. */
398 ext_opcode
= arc_ext_opcodes
;
399 std_opcode
= arc_opcode_lookup_asm (str
);
401 /* Keep looking until we find a match. */
404 for (opcode
= (ext_opcode
? ext_opcode
: std_opcode
);
406 opcode
= (ARC_OPCODE_NEXT_ASM (opcode
)
407 ? ARC_OPCODE_NEXT_ASM (opcode
)
408 : (ext_opcode
? ext_opcode
= NULL
, std_opcode
: NULL
)))
410 int past_opcode_p
, fc
, num_suffixes
;
413 struct arc_fixup fixups
[MAX_FIXUPS
];
414 /* Used as a sanity check. If we need a limm reloc, make sure we ask
415 for an extra 4 bytes from frag_more. */
418 const struct arc_operand_value
*insn_suffixes
[MAX_SUFFIXES
];
420 /* Is this opcode supported by the selected cpu? */
421 if (! arc_opcode_supported (opcode
))
424 /* Scan the syntax string. If it doesn't match, try the next one. */
426 arc_opcode_init_insert ();
427 insn
= opcode
->value
;
434 /* We don't check for (*str != '\0') here because we want to parse
435 any trailing fake arguments in the syntax string. */
436 for (str
= start
, syn
= opcode
->syntax
; *syn
!= '\0';)
439 const struct arc_operand
*operand
;
441 /* Non operand chars must match exactly. */
442 if (*syn
!= '%' || *++syn
== '%')
444 /* Handle '+' specially as we want to allow "ld r0,[sp-4]". */
445 /* ??? The syntax has changed to [sp,-4]. */
446 if (0 && *syn
== '+' && *str
== '-')
448 /* Skip over syn's +, but leave str's - alone.
449 That makes the case identical to "ld r0,[sp+-4]". */
452 else if (*str
== *syn
)
464 /* We have an operand. Pick out any modifiers. */
466 while (ARC_MOD_P (arc_operands
[arc_operand_map
[(int) *syn
]].flags
))
468 mods
|= arc_operands
[arc_operand_map
[(int) *syn
]].flags
& ARC_MOD_BITS
;
471 operand
= arc_operands
+ arc_operand_map
[(int) *syn
];
472 if (operand
->fmt
== 0)
473 as_fatal ("unknown syntax format character `%c'", *syn
);
475 if (operand
->flags
& ARC_OPERAND_FAKE
)
477 const char *errmsg
= NULL
;
480 insn
= (*operand
->insert
) (insn
, operand
, mods
, NULL
, 0, &errmsg
);
481 if (errmsg
!= (const char *) NULL
)
483 last_errmsg
= errmsg
;
484 if (operand
->flags
& ARC_OPERAND_ERROR
)
489 else if (operand
->flags
& ARC_OPERAND_WARN
)
494 && (operand
->flags
&& operand
->flags
& ARC_OPERAND_LIMM
)
496 (ARC_OPERAND_ABSOLUTE_BRANCH
| ARC_OPERAND_ADDRESS
)))
498 fixups
[fix_up_at
].opindex
= arc_operand_map
[operand
->fmt
];
503 /* Are we finished with suffixes? */
504 else if (!past_opcode_p
)
509 const struct arc_operand_value
*suf
, *suffix_end
;
510 const struct arc_operand_value
*suffix
= NULL
;
512 if (!(operand
->flags
& ARC_OPERAND_SUFFIX
))
515 /* If we're at a space in the input string, we want to skip the
516 remaining suffixes. There may be some fake ones though, so
517 just go on to try the next one. */
525 if (mods
& ARC_MOD_DOT
)
533 /* This can happen in "b.nd foo" and we're currently looking
534 for "%q" (ie: a condition code suffix). */
542 /* Pick the suffix out and look it up via the hash table. */
543 for (t
= s
; *t
&& isalnum (*t
); ++t
)
547 if ((suf
= get_ext_suffix (s
)))
550 suf
= hash_find (arc_suffix_hash
, s
);
553 /* This can happen in "blle foo" and we're currently using
554 the template "b%q%.n %j". The "bl" insn occurs later in
555 the table so "lle" isn't an illegal suffix. */
560 /* Is it the right type? Note that the same character is used
561 several times, so we have to examine all of them. This is
562 relatively efficient as equivalent entries are kept
563 together. If it's not the right type, don't increment `str'
564 so we try the next one in the series. */
566 if (ext_suffix_p
&& arc_operands
[suf
->type
].fmt
== *syn
)
568 /* Insert the suffix's value into the insn. */
571 insn
= (*operand
->insert
) (insn
, operand
,
572 mods
, NULL
, suf
->value
,
575 insn
|= suf
->value
<< operand
->shift
;
583 suffix_end
= arc_suffixes
+ arc_suffixes_count
;
585 suffix
< suffix_end
&& strcmp (suffix
->name
, suf
->name
) == 0;
588 if (arc_operands
[suffix
->type
].fmt
== *syn
)
590 /* Insert the suffix's value into the insn. */
592 insn
= (*operand
->insert
) (insn
, operand
,
593 mods
, NULL
, suffix
->value
,
596 insn
|= suffix
->value
<< operand
->shift
;
606 /* Wrong type. Just go on to try next insn entry. */
610 if (num_suffixes
== MAX_SUFFIXES
)
611 as_bad ("too many suffixes");
613 insn_suffixes
[num_suffixes
++] = suffix
;
617 /* This is either a register or an expression of some kind. */
620 const struct arc_operand_value
*reg
= NULL
;
624 if (operand
->flags
& ARC_OPERAND_SUFFIX
)
627 /* Is there anything left to parse?
628 We don't check for this at the top because we want to parse
629 any trailing fake arguments in the syntax string. */
633 /* Parse the operand. */
634 hold
= input_line_pointer
;
635 input_line_pointer
= str
;
637 str
= input_line_pointer
;
638 input_line_pointer
= hold
;
640 if (exp
.X_op
== O_illegal
)
641 as_bad ("illegal operand");
642 else if (exp
.X_op
== O_absent
)
643 as_bad ("missing operand");
644 else if (exp
.X_op
== O_constant
)
646 value
= exp
.X_add_number
;
648 else if (exp
.X_op
== O_register
)
650 reg
= (struct arc_operand_value
*) exp
.X_add_number
;
652 #define IS_REG_DEST_OPERAND(o) ((o) == 'a')
653 else if (IS_REG_DEST_OPERAND (*syn
))
654 as_bad ("symbol as destination register");
657 if (!strncmp (str
, "@h30", 4))
659 arc_code_symbol (&exp
);
662 /* We need to generate a fixup for this expression. */
663 if (fc
>= MAX_FIXUPS
)
664 as_fatal ("too many fixups");
665 fixups
[fc
].exp
= exp
;
666 /* We don't support shimm relocs. break here to force
667 the assembler to output a limm. */
668 #define IS_REG_SHIMM_OFFSET(o) ((o) == 'd')
669 if (IS_REG_SHIMM_OFFSET (*syn
))
671 /* If this is a register constant (IE: one whose
672 register value gets stored as 61-63) then this
674 /* ??? This bit could use some cleaning up.
675 Referencing the format chars like this goes
677 if (IS_SYMBOL_OPERAND (*syn
))
681 /* Save this, we don't yet know what reloc to use. */
683 /* Tell insert_reg we need a limm. This is
684 needed because the value at this point is
686 /* ??? We need a cleaner interface than this. */
687 (*arc_operands
[arc_operand_map
['Q']].insert
)
688 (insn
, operand
, mods
, reg
, 0L, &junk
);
691 fixups
[fc
].opindex
= arc_operand_map
[(int) *syn
];
696 /* Insert the register or expression into the instruction. */
699 const char *errmsg
= NULL
;
700 insn
= (*operand
->insert
) (insn
, operand
, mods
,
701 reg
, (long) value
, &errmsg
);
702 if (errmsg
!= (const char *) NULL
)
704 last_errmsg
= errmsg
;
705 if (operand
->flags
& ARC_OPERAND_ERROR
)
710 else if (operand
->flags
& ARC_OPERAND_WARN
)
716 insn
|= (value
& ((1 << operand
->bits
) - 1)) << operand
->shift
;
722 /* If we're at the end of the syntax string, we're done. */
723 /* FIXME: try to move this to a separate function. */
730 /* For the moment we assume a valid `str' can only contain blanks
731 now. IE: We needn't try again with a longer version of the
732 insn and it is assumed that longer versions of insns appear
733 before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3). */
735 while (isspace (*str
))
739 as_bad ("junk at end of line: `%s'", str
);
741 /* Is there a limm value? */
742 limm_p
= arc_opcode_limm_p (&limm
);
744 /* Perform various error and warning tests. */
747 static int in_delay_slot_p
= 0;
748 static int prev_insn_needs_cc_nop_p
= 0;
749 /* delay slot type seen */
750 int delay_slot_type
= ARC_DELAY_NONE
;
751 /* conditional execution flag seen */
753 /* 1 if condition codes are being set */
755 /* 1 if conditional branch, including `b' "branch always" */
756 int cond_branch_p
= opcode
->flags
& ARC_OPCODE_COND_BRANCH
;
758 for (i
= 0; i
< num_suffixes
; ++i
)
760 switch (arc_operands
[insn_suffixes
[i
]->type
].fmt
)
763 delay_slot_type
= insn_suffixes
[i
]->value
;
766 conditional
= insn_suffixes
[i
]->value
;
774 /* Putting an insn with a limm value in a delay slot is supposed to
775 be legal, but let's warn the user anyway. Ditto for 8 byte
776 jumps with delay slots. */
777 if (in_delay_slot_p
&& limm_p
)
778 as_warn ("8 byte instruction in delay slot");
779 if (delay_slot_type
!= ARC_DELAY_NONE
780 && limm_p
&& arc_insn_not_jl (insn
)) /* except for jl addr */
781 as_warn ("8 byte jump instruction with delay slot");
782 in_delay_slot_p
= (delay_slot_type
!= ARC_DELAY_NONE
) && !limm_p
;
784 /* Warn when a conditional branch immediately follows a set of
785 the condition codes. Note that this needn't be done if the
786 insn that sets the condition codes uses a limm. */
787 if (cond_branch_p
&& conditional
!= 0 /* 0 = "always" */
788 && prev_insn_needs_cc_nop_p
&& arc_mach_type
== bfd_mach_arc_5
)
789 as_warn ("conditional branch follows set of flags");
790 prev_insn_needs_cc_nop_p
=
791 /* FIXME: ??? not required:
792 (delay_slot_type != ARC_DELAY_NONE) && */
796 /* Write out the instruction.
797 It is important to fetch enough space in one call to `frag_more'.
798 We use (f - frag_now->fr_literal) to compute where we are and we
799 don't want frag_now to change between calls. */
803 md_number_to_chars (f
, insn
, 4);
804 md_number_to_chars (f
+ 4, limm
, 4);
806 else if (limm_reloc_p
)
808 /* We need a limm reloc, but the tables think we don't. */
814 md_number_to_chars (f
, insn
, 4);
817 /* Create any fixups. */
818 for (i
= 0; i
< fc
; ++i
)
820 int op_type
, reloc_type
;
822 const struct arc_operand
*operand
;
824 /* Create a fixup for this operand.
825 At this point we do not use a bfd_reloc_code_real_type for
826 operands residing in the insn, but instead just use the
827 operand index. This lets us easily handle fixups for any
828 operand type, although that is admittedly not a very exciting
829 feature. We pick a BFD reloc type in md_apply_fix.
831 Limm values (4 byte immediate "constants") must be treated
832 normally because they're not part of the actual insn word
833 and thus the insertion routines don't handle them. */
835 if (arc_operands
[fixups
[i
].opindex
].flags
& ARC_OPERAND_LIMM
)
837 /* Modify the fixup addend as required by the cpu. */
838 fixups
[i
].exp
.X_add_number
+= arc_limm_fixup_adjust (insn
);
839 op_type
= fixups
[i
].opindex
;
840 /* FIXME: can we add this data to the operand table? */
841 if (op_type
== arc_operand_map
['L']
842 || op_type
== arc_operand_map
['s']
843 || op_type
== arc_operand_map
['o']
844 || op_type
== arc_operand_map
['O'])
845 reloc_type
= BFD_RELOC_32
;
846 else if (op_type
== arc_operand_map
['J'])
847 reloc_type
= BFD_RELOC_ARC_B26
;
850 reloc_type
= get_arc_exp_reloc_type (1, reloc_type
,
856 op_type
= get_arc_exp_reloc_type (0, fixups
[i
].opindex
,
857 &fixups
[i
].exp
, &exptmp
);
858 reloc_type
= op_type
+ (int) BFD_RELOC_UNUSED
;
860 operand
= &arc_operands
[op_type
];
861 fix_new_exp (frag_now
,
862 ((f
- frag_now
->fr_literal
)
863 + (operand
->flags
& ARC_OPERAND_LIMM
? 4 : 0)), 4,
865 (operand
->flags
& ARC_OPERAND_RELATIVE_BRANCH
) != 0,
866 (bfd_reloc_code_real_type
) reloc_type
);
873 /* Try the next entry. */
876 if (NULL
== last_errmsg
)
877 as_bad ("bad instruction `%s'", start
);
879 as_bad (last_errmsg
);
883 arc_extoper (opertype
)
892 struct arc_ext_operand_value
*ext_oper
;
898 name
= input_line_pointer
;
899 c
= get_symbol_end ();
900 name
= xstrdup (name
);
903 ignore_rest_of_line ();
915 /* just after name is now '\0' */
916 p
= input_line_pointer
;
920 if (*input_line_pointer
!= ',')
922 as_bad ("expected comma after operand name");
923 ignore_rest_of_line ();
928 input_line_pointer
++; /* skip ',' */
929 number
= get_absolute_expression ();
933 as_bad ("negative operand number %d", number
);
934 ignore_rest_of_line ();
943 if (*input_line_pointer
!= ',')
945 as_bad ("expected comma after register-number");
946 ignore_rest_of_line ();
951 input_line_pointer
++; /* skip ',' */
952 mode
= input_line_pointer
;
954 if (!strncmp (mode
, "r|w", 3))
957 input_line_pointer
+= 3;
961 if (!strncmp (mode
, "r", 1))
963 imode
= ARC_REGISTER_READONLY
;
964 input_line_pointer
+= 1;
968 if (strncmp (mode
, "w", 1))
970 as_bad ("invalid mode");
971 ignore_rest_of_line ();
977 imode
= ARC_REGISTER_WRITEONLY
;
978 input_line_pointer
+= 1;
985 if (*input_line_pointer
!= ',')
987 as_bad ("expected comma after register-mode");
988 ignore_rest_of_line ();
993 input_line_pointer
++; /* skip ',' */
995 if (!strncmp (input_line_pointer
, "cannot_shortcut", 15))
997 imode
|= arc_get_noshortcut_flag ();
998 input_line_pointer
+= 15;
1002 if (strncmp (input_line_pointer
, "can_shortcut", 12))
1004 as_bad ("shortcut designator invalid");
1005 ignore_rest_of_line ();
1011 input_line_pointer
+= 12;
1017 if ((opertype
== 1) && number
> 60)
1019 as_bad ("core register value (%d) too large", number
);
1020 ignore_rest_of_line ();
1025 if ((opertype
== 0) && number
> 31)
1027 as_bad ("condition code value (%d) too large", number
);
1028 ignore_rest_of_line ();
1033 ext_oper
= (struct arc_ext_operand_value
*) \
1034 xmalloc (sizeof (struct arc_ext_operand_value
));
1038 /* If the symbol already exists, point it at the new definition. */
1039 if ((symbolP
= symbol_find (name
)))
1041 if (S_GET_SEGMENT (symbolP
) == reg_section
)
1042 S_SET_VALUE (symbolP
, (int) &ext_oper
->operand
);
1045 as_bad ("attempt to override symbol: %s", name
);
1046 ignore_rest_of_line ();
1054 /* If its not there, add it. */
1055 symbol_table_insert (symbol_create (name
, reg_section
,
1056 (int) &ext_oper
->operand
, &zero_address_frag
));
1060 ext_oper
->operand
.name
= name
;
1061 ext_oper
->operand
.value
= number
;
1062 ext_oper
->operand
.type
= arc_operand_type (opertype
);
1063 ext_oper
->operand
.flags
= imode
;
1065 ext_oper
->next
= arc_ext_operands
;
1066 arc_ext_operands
= ext_oper
;
1068 /* OK, now that we know what this operand is, put a description in
1069 the arc extension section of the output file. */
1072 old_subsec
= now_subseg
;
1080 *p
= 3 + strlen (name
) + 1;
1085 p
= frag_more (strlen (name
) + 1);
1090 *p
= 3 + strlen (name
) + 1;
1092 *p
= EXT_CORE_REGISTER
;
1095 p
= frag_more (strlen (name
) + 1);
1100 *p
= 6 + strlen (name
) + 1;
1102 *p
= EXT_AUX_REGISTER
;
1104 *p
= number
>> 24 & 0xff;
1106 *p
= number
>> 16 & 0xff;
1108 *p
= number
>> 8 & 0xff;
1111 p
= frag_more (strlen (name
) + 1);
1115 as_bad ("invalid opertype");
1116 ignore_rest_of_line ();
1122 subseg_set (old_sec
, old_subsec
);
1124 /* Enter all registers into the symbol table. */
1126 demand_empty_rest_of_line ();
1130 arc_extinst (ignore
)
1131 int ignore ATTRIBUTE_UNUSED
;
1133 unsigned char syntax
[129];
1137 int suffixcode
= -1;
1138 int opcode
, subopcode
;
1142 struct arc_opcode
*ext_op
;
1147 name
= input_line_pointer
;
1148 c
= get_symbol_end ();
1149 name
= xstrdup (name
);
1152 ignore_rest_of_line ();
1155 strcpy (syntax
, name
);
1156 name_len
= strlen (name
);
1158 /* just after name is now '\0' */
1159 p
= input_line_pointer
;
1164 if (*input_line_pointer
!= ',')
1166 as_bad ("expected comma after operand name");
1167 ignore_rest_of_line ();
1171 input_line_pointer
++; /* skip ',' */
1172 opcode
= get_absolute_expression ();
1176 if (*input_line_pointer
!= ',')
1178 as_bad ("expected comma after opcode");
1179 ignore_rest_of_line ();
1183 input_line_pointer
++; /* skip ',' */
1184 subopcode
= get_absolute_expression ();
1188 as_bad ("negative subopcode %d", subopcode
);
1189 ignore_rest_of_line ();
1197 as_bad ("subcode value found when opcode not equal 0x03");
1198 ignore_rest_of_line ();
1203 if (subopcode
< 0x09 || subopcode
== 0x3f)
1205 as_bad ("invalid subopcode %d", subopcode
);
1206 ignore_rest_of_line ();
1214 if (*input_line_pointer
!= ',')
1216 as_bad ("expected comma after subopcode");
1217 ignore_rest_of_line ();
1221 input_line_pointer
++; /* skip ',' */
1223 for (i
= 0; i
< (int) MAXSUFFIXCLASS
; i
++)
1225 if (!strncmp (suffixclass
[i
].name
,input_line_pointer
, suffixclass
[i
].len
))
1228 input_line_pointer
+= suffixclass
[i
].len
;
1233 if (-1 == suffixcode
)
1235 as_bad ("invalid suffix class");
1236 ignore_rest_of_line ();
1242 if (*input_line_pointer
!= ',')
1244 as_bad ("expected comma after suffix class");
1245 ignore_rest_of_line ();
1249 input_line_pointer
++; /* skip ',' */
1251 for (i
= 0; i
< (int) MAXSYNTAXCLASS
; i
++)
1253 if (!strncmp (syntaxclass
[i
].name
,input_line_pointer
, syntaxclass
[i
].len
))
1255 class = syntaxclass
[i
].class;
1256 input_line_pointer
+= syntaxclass
[i
].len
;
1261 if (0 == (SYNTAX_VALID
& class))
1263 as_bad ("invalid syntax class");
1264 ignore_rest_of_line ();
1268 if ((0x3 == opcode
) & (class & SYNTAX_3OP
))
1270 as_bad ("opcode 0x3 and SYNTAX_3OP invalid");
1271 ignore_rest_of_line ();
1278 strcat (syntax
, "%.q%.f ");
1281 strcat (syntax
, "%.f ");
1284 strcat (syntax
, "%.q ");
1287 strcat (syntax
, " ");
1290 as_bad ("unknown suffix class");
1291 ignore_rest_of_line ();
1296 strcat (syntax
, ((opcode
== 0x3) ? "%a,%b" : ((class & SYNTAX_3OP
) ? "%a,%b,%c" : "%b,%c")));
1298 strcat (syntax
, "%F");
1299 strcat (syntax
, "%S%L");
1301 ext_op
= (struct arc_opcode
*) xmalloc (sizeof (struct arc_opcode
));
1304 ignore_rest_of_line ();
1308 ext_op
->syntax
= xstrdup (syntax
);
1309 if (NULL
== ext_op
->syntax
)
1311 ignore_rest_of_line ();
1315 ext_op
->mask
= I (-1) | ((0x3 == opcode
) ? C (-1) : 0);
1316 ext_op
->value
= I (opcode
) | ((0x3 == opcode
) ? C (subopcode
) : 0);
1317 ext_op
->flags
= class;
1318 ext_op
->next_asm
= arc_ext_opcodes
;
1319 ext_op
->next_dis
= arc_ext_opcodes
;
1320 arc_ext_opcodes
= ext_op
;
1322 /* OK, now that we know what this inst is, put a description in the
1323 arc extension section of the output file. */
1326 old_subsec
= now_subseg
;
1331 *p
= 5 + name_len
+ 1;
1333 *p
= EXT_INSTRUCTION
;
1339 *p
= (class & (OP1_MUST_BE_IMM
| OP1_IMM_IMPLIED
) ? IGNORE_FIRST_OPD
: 0);
1340 p
= frag_more (name_len
);
1341 strncpy (p
, syntax
, name_len
);
1345 subseg_set (old_sec
, old_subsec
);
1347 demand_empty_rest_of_line ();
1353 if (!arcext_section
)
1355 arcext_section
= subseg_new (".arcextmap", 0);
1356 bfd_set_section_flags (stdoutput
, arcext_section
,
1357 SEC_READONLY
| SEC_HAS_CONTENTS
);
1360 subseg_set (arcext_section
, 0);
1365 arc_common (localScope
)
1374 name
= input_line_pointer
;
1375 c
= get_symbol_end ();
1376 /* just after name is now '\0' */
1377 p
= input_line_pointer
;
1381 if (*input_line_pointer
!= ',')
1383 as_bad ("expected comma after symbol name");
1384 ignore_rest_of_line ();
1388 input_line_pointer
++; /* skip ',' */
1389 size
= get_absolute_expression ();
1393 as_bad ("negative symbol length");
1394 ignore_rest_of_line ();
1399 symbolP
= symbol_find_or_make (name
);
1402 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
1404 as_bad ("ignoring attempt to re-define symbol");
1405 ignore_rest_of_line ();
1408 if (((int) S_GET_VALUE (symbolP
) != 0) \
1409 && ((int) S_GET_VALUE (symbolP
) != size
))
1411 as_warn ("length of symbol \"%s\" already %ld, ignoring %d",
1412 S_GET_NAME (symbolP
), (long) S_GET_VALUE (symbolP
), size
);
1414 assert (symbolP
->sy_frag
== &zero_address_frag
);
1416 /* Now parse the alignment field. This field is optional for
1417 local and global symbols. Default alignment is zero. */
1418 if (*input_line_pointer
== ',')
1420 input_line_pointer
++;
1421 align
= get_absolute_expression ();
1425 as_warn ("assuming symbol alignment of zero");
1431 if (localScope
!= 0)
1438 old_subsec
= now_subseg
;
1439 record_alignment (bss_section
, align
);
1440 subseg_set (bss_section
, 0); /* ??? subseg_set (bss_section, 1); ??? */
1444 frag_align (align
, 0, 0);
1446 /* Detach from old frag. */
1447 if (S_GET_SEGMENT (symbolP
) == bss_section
)
1448 symbolP
->sy_frag
->fr_symbol
= NULL
;
1450 symbolP
->sy_frag
= frag_now
;
1451 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
) 0, symbolP
,
1452 (offsetT
) size
, (char *) 0);
1455 S_SET_SIZE (symbolP
, size
);
1456 S_SET_SEGMENT (symbolP
, bss_section
);
1457 S_CLEAR_EXTERNAL (symbolP
);
1459 subseg_set (old_sec
, old_subsec
);
1463 S_SET_VALUE (symbolP
, (valueT
) size
);
1464 S_SET_ALIGN (symbolP
, align
);
1465 S_SET_EXTERNAL (symbolP
);
1466 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
1469 symbolP
->bsym
->flags
|= BSF_OBJECT
;
1471 demand_empty_rest_of_line ();
1475 /* Select the cpu we're assembling for. */
1479 int ignore ATTRIBUTE_UNUSED
;
1485 cpu
= input_line_pointer
;
1486 c
= get_symbol_end ();
1487 mach
= arc_get_mach (cpu
);
1488 *input_line_pointer
= c
;
1490 /* If an instruction has already been seen, it's too late. */
1491 if (cpu_tables_init_p
)
1493 as_bad ("\".option\" directive must appear before any instructions");
1494 ignore_rest_of_line ();
1501 if (mach_type_specified_p
&& mach
!= arc_mach_type
)
1503 as_bad ("\".option\" directive conflicts with initial definition");
1504 ignore_rest_of_line ();
1509 /* The cpu may have been selected on the command line. */
1510 if (mach
!= arc_mach_type
)
1511 as_warn ("\".option\" directive overrides command-line (default) value");
1512 arc_mach_type
= mach
;
1513 if (!bfd_set_arch_mach (stdoutput
, bfd_arch_arc
, mach
))
1514 as_fatal ("could not set architecture and machine");
1515 mach_type_specified_p
= 1;
1517 demand_empty_rest_of_line ();
1521 as_bad ("invalid identifier for \".option\"");
1522 ignore_rest_of_line ();
1525 /* Turn a string in input_line_pointer into a floating point constant
1526 of type TYPE, and store the appropriate bytes in *LITP. The number
1527 of LITTLENUMS emitted is stored in *SIZEP. An error message is
1528 returned, or NULL on OK. */
1530 /* Equal to MAX_PRECISION in atof-ieee.c */
1531 #define MAX_LITTLENUMS 6
1534 md_atof (type
, litP
, sizeP
)
1540 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
1541 LITTLENUM_TYPE
*wordP
;
1559 return "bad call to md_atof";
1562 t
= atof_ieee (input_line_pointer
, type
, words
);
1564 input_line_pointer
= t
;
1565 *sizeP
= prec
* sizeof (LITTLENUM_TYPE
);
1566 for (wordP
= words
; prec
--;)
1568 md_number_to_chars (litP
, (valueT
) (*wordP
++), sizeof (LITTLENUM_TYPE
));
1569 litP
+= sizeof (LITTLENUM_TYPE
);
1575 /* Write a value out to the object file, using the appropriate
1579 md_number_to_chars (buf
, val
, n
)
1584 if (target_big_endian
)
1585 number_to_chars_bigendian (buf
, val
, n
);
1587 number_to_chars_littleendian (buf
, val
, n
);
1590 /* Round up a section size to the appropriate boundary. */
1593 md_section_align (segment
, size
)
1597 int align
= bfd_get_section_alignment (stdoutput
, segment
);
1599 return ((size
+ (1 << align
) - 1) & (-1 << align
));
1602 /* We don't have any form of relaxing. */
1605 md_estimate_size_before_relax (fragp
, seg
)
1606 fragS
*fragp ATTRIBUTE_UNUSED
;
1607 asection
*seg ATTRIBUTE_UNUSED
;
1609 as_fatal (_("md_estimate_size_before_relax\n"));
1613 /* Convert a machine dependent frag. We never generate these. */
1616 md_convert_frag (abfd
, sec
, fragp
)
1617 bfd
*abfd ATTRIBUTE_UNUSED
;
1618 asection
*sec ATTRIBUTE_UNUSED
;
1619 fragS
*fragp ATTRIBUTE_UNUSED
;
1621 as_fatal (_("md_convert_frag\n"));
1625 arc_code_symbol (expressionP
)
1626 expressionS
*expressionP
;
1628 if (expressionP
->X_op
== O_symbol
&& expressionP
->X_add_number
== 0
1629 /* I think this test is unnecessary but just as a sanity check... */
1630 && expressionP
->X_op_symbol
== NULL
)
1633 expressionP
->X_op
= O_right_shift
;
1634 two
.X_op
= O_constant
;
1635 two
.X_add_symbol
= two
.X_op_symbol
= NULL
;
1636 two
.X_add_number
= 2;
1637 expressionP
->X_op_symbol
= make_expr_symbol (&two
);
1639 /* Allow %st(sym1-sym2) */
1640 else if (expressionP
->X_op
== O_subtract
1641 && expressionP
->X_add_symbol
!= NULL
1642 && expressionP
->X_op_symbol
!= NULL
1643 && expressionP
->X_add_number
== 0)
1646 expressionP
->X_add_symbol
= make_expr_symbol (expressionP
);
1647 expressionP
->X_op
= O_right_shift
;
1648 two
.X_op
= O_constant
;
1649 two
.X_add_symbol
= two
.X_op_symbol
= NULL
;
1650 two
.X_add_number
= 2;
1651 expressionP
->X_op_symbol
= make_expr_symbol (&two
);
1655 as_bad ("expression too complex code symbol");
1660 /* Parse an operand that is machine-specific.
1662 The ARC has a special %-op to adjust addresses so they're usable in
1663 branches. The "st" is short for the STatus register.
1664 ??? Later expand this to take a flags value too.
1666 ??? We can't create new expression types so we map the %-op's onto the
1667 existing syntax. This means that the user could use the chosen syntax
1668 to achieve the same effect. */
1671 md_operand (expressionP
)
1672 expressionS
*expressionP
;
1674 char *p
= input_line_pointer
;
1677 if (strncmp (p
, "%st(", 4) == 0)
1679 input_line_pointer
+= 4;
1680 expression (expressionP
);
1681 if (*input_line_pointer
!= ')')
1683 as_bad ("missing ')' in %%-op");
1686 ++input_line_pointer
;
1687 arc_code_symbol (expressionP
);
1690 { /* It could be a register. */
1692 struct arc_ext_operand_value
*ext_oper
= arc_ext_operands
;
1697 l
= strlen (ext_oper
->operand
.name
);
1698 if (!strncmp (p
, ext_oper
->operand
.name
, l
) && !isalnum(*(p
+ l
)))
1700 input_line_pointer
+= l
+ 1;
1701 expressionP
->X_op
= O_register
;
1702 expressionP
->X_add_number
= (int) &ext_oper
->operand
;
1705 ext_oper
= ext_oper
->next
;
1707 for (i
= 0; i
< arc_reg_names_count
; i
++)
1709 l
= strlen (arc_reg_names
[i
].name
);
1710 if (!strncmp (p
, arc_reg_names
[i
].name
, l
) && !isalnum (*(p
+ l
)))
1712 input_line_pointer
+= l
+ 1;
1713 expressionP
->X_op
= O_register
;
1714 expressionP
->X_add_number
= (int) &arc_reg_names
[i
];
1721 /* We have no need to default values of symbols.
1722 We could catch register names here, but that is handled by inserting
1723 them all in the symbol table to begin with. */
1726 md_undefined_symbol (name
)
1727 char *name ATTRIBUTE_UNUSED
;
1732 /* Functions concerning expressions. */
1734 /* Parse a .byte, .word, etc. expression.
1736 Values for the status register are specified with %st(label).
1737 `label' will be right shifted by 2. */
1740 arc_parse_cons_expression (exp
, nbytes
)
1742 unsigned int nbytes ATTRIBUTE_UNUSED
;
1744 char *p
= input_line_pointer
;
1745 int code_symbol_fix
= 0;
1747 for (; ! is_end_of_line
[(unsigned char) *p
]; p
++)
1748 if (*p
== '@' && !strncmp (p
, "@h30", 4))
1750 code_symbol_fix
= 1;
1754 if (code_symbol_fix
)
1756 arc_code_symbol (exp
);
1757 input_line_pointer
= p
;
1761 /* Record a fixup for a cons expression. */
1764 arc_cons_fix_new (frag
, where
, nbytes
, exp
)
1775 /* This may be a special ARC reloc (eg: %st()). */
1776 reloc_type
= get_arc_exp_reloc_type (1, BFD_RELOC_32
, exp
, &exptmp
);
1777 fix_new_exp (frag
, where
, nbytes
, &exptmp
, 0, reloc_type
);
1781 fix_new_exp (frag
, where
, nbytes
, exp
, 0,
1782 nbytes
== 2 ? BFD_RELOC_16
1783 : nbytes
== 8 ? BFD_RELOC_64
1788 /* Functions concerning relocs. */
1790 /* The location from which a PC relative jump should be calculated,
1791 given a PC relative reloc. */
1794 md_pcrel_from (fixP
)
1797 if (fixP
->fx_addsy
!= (symbolS
*) NULL
1798 && ! S_IS_DEFINED (fixP
->fx_addsy
))
1800 /* The symbol is undefined. Let the linker figure it out. */
1804 /* Return the address of the delay slot. */
1805 return fixP
->fx_frag
->fr_address
+ fixP
->fx_where
+ fixP
->fx_size
;
1808 /* Compute the reloc type of an expression.
1809 The possibly modified expression is stored in EXPNEW.
1811 This is used to convert the expressions generated by the %-op's into
1812 the appropriate operand type. It is called for both data in instructions
1813 (operands) and data outside instructions (variables, debugging info, etc.).
1815 Currently supported %-ops:
1817 %st(symbol): represented as "symbol >> 2"
1818 "st" is short for STatus as in the status register (pc)
1820 DEFAULT_TYPE is the type to use if no special processing is required.
1822 DATA_P is non-zero for data or limm values, zero for insn operands.
1823 Remember that the opcode "insertion fns" cannot be used on data, they're
1824 only for inserting operands into insns. They also can't be used for limm
1825 values as the insertion routines don't handle limm values. When called for
1826 insns we return fudged reloc types (real_value - BFD_RELOC_UNUSED). When
1827 called for data or limm values we use real reloc types. */
1830 get_arc_exp_reloc_type (data_p
, default_type
, exp
, expnew
)
1834 expressionS
*expnew
;
1836 /* If the expression is "symbol >> 2" we must change it to just "symbol",
1837 as fix_new_exp can't handle it. Similarily for (symbol - symbol) >> 2.
1838 That's ok though. What's really going on here is that we're using
1839 ">> 2" as a special syntax for specifying BFD_RELOC_ARC_B26. */
1841 if (exp
->X_op
== O_right_shift
1842 && exp
->X_op_symbol
!= NULL
1843 && exp
->X_op_symbol
->sy_value
.X_op
== O_constant
1844 && exp
->X_op_symbol
->sy_value
.X_add_number
== 2
1845 && exp
->X_add_number
== 0)
1847 if (exp
->X_add_symbol
!= NULL
1848 && (exp
->X_add_symbol
->sy_value
.X_op
== O_constant
1849 || exp
->X_add_symbol
->sy_value
.X_op
== O_symbol
))
1852 expnew
->X_op
= O_symbol
;
1853 expnew
->X_op_symbol
= NULL
;
1854 return data_p
? BFD_RELOC_ARC_B26
: arc_operand_map
['J'];
1856 else if (exp
->X_add_symbol
!= NULL
1857 && exp
->X_add_symbol
->sy_value
.X_op
== O_subtract
)
1859 *expnew
= exp
->X_add_symbol
->sy_value
;
1860 return data_p
? BFD_RELOC_ARC_B26
: arc_operand_map
['J'];
1865 return default_type
;
1868 /* Apply a fixup to the object code. This is called for all the
1869 fixups we generated by the call to fix_new_exp, above. In the call
1870 above we used a reloc code which was the largest legal reloc code
1871 plus the operand index. Here we undo that to recover the operand
1872 index. At this point all symbol values should be fully resolved,
1873 and we attempt to completely resolve the reloc. If we can not do
1874 that, we determine the correct reloc code and put it back in the fixup. */
1877 md_apply_fix3 (fixP
, valueP
, seg
)
1883 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
1887 /* FIXME FIXME FIXME: The value we are passed in *valueP includes
1888 the symbol values. Since we are using BFD_ASSEMBLER, if we are
1889 doing this relocation the code in write.c is going to call
1890 bfd_perform_relocation, which is also going to use the symbol
1891 value. That means that if the reloc is fully resolved we want to
1892 use *valueP since bfd_perform_relocation is not being used.
1893 However, if the reloc is not fully resolved we do not want to use
1894 *valueP, and must use fx_offset instead. However, if the reloc
1895 is PC relative, we do want to use *valueP since it includes the
1896 result of md_pcrel_from. This is confusing. */
1898 if (fixP
->fx_addsy
== (symbolS
*) NULL
)
1903 else if (fixP
->fx_pcrel
)
1906 /* ELF relocations are against symbols.
1907 If this symbol is in a different section then we need to leave it for
1908 the linker to deal with. Unfortunately, md_pcrel_from can't tell,
1909 so we have to undo it's effects here. */
1910 if (S_IS_DEFINED (fixP
->fx_addsy
)
1911 && S_GET_SEGMENT (fixP
->fx_addsy
) != seg
)
1912 value
+= md_pcrel_from (fixP
);
1916 value
= fixP
->fx_offset
;
1917 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
1919 if (S_GET_SEGMENT (fixP
->fx_subsy
) == absolute_section
)
1920 value
-= S_GET_VALUE (fixP
->fx_subsy
);
1923 /* We can't actually support subtracting a symbol. */
1924 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1925 "expression too complex");
1930 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
1933 const struct arc_operand
*operand
;
1937 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
1939 operand
= &arc_operands
[opindex
];
1941 /* Fetch the instruction, insert the fully resolved operand
1942 value, and stuff the instruction back again. */
1943 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
1944 if (target_big_endian
)
1945 insn
= bfd_getb32 ((unsigned char *) where
);
1947 insn
= bfd_getl32 ((unsigned char *) where
);
1948 insn
= arc_insert_operand (insn
, operand
, -1, NULL
, (offsetT
) value
,
1949 fixP
->fx_file
, fixP
->fx_line
);
1950 if (target_big_endian
)
1951 bfd_putb32 ((bfd_vma
) insn
, (unsigned char *) where
);
1953 bfd_putl32 ((bfd_vma
) insn
, (unsigned char *) where
);
1957 /* Nothing else to do here. */
1961 /* Determine a BFD reloc value based on the operand information.
1962 We are only prepared to turn a few of the operands into relocs.
1963 !!! Note that we can't handle limm values here. Since we're using
1964 implicit addends the addend must be inserted into the instruction,
1965 however, the opcode insertion routines currently do nothing with
1967 if (operand
->fmt
== 'B')
1969 assert ((operand
->flags
& ARC_OPERAND_RELATIVE_BRANCH
) != 0
1970 && operand
->bits
== 20
1971 && operand
->shift
== 7);
1972 fixP
->fx_r_type
= BFD_RELOC_ARC_B22_PCREL
;
1974 else if (operand
->fmt
== 'J')
1976 assert ((operand
->flags
& ARC_OPERAND_ABSOLUTE_BRANCH
) != 0
1977 && operand
->bits
== 24
1978 && operand
->shift
== 32);
1979 fixP
->fx_r_type
= BFD_RELOC_ARC_B26
;
1981 else if (operand
->fmt
== 'L')
1983 assert ((operand
->flags
& ARC_OPERAND_LIMM
) != 0
1984 && operand
->bits
== 32
1985 && operand
->shift
== 32);
1986 fixP
->fx_r_type
= BFD_RELOC_32
;
1990 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1991 "unresolved expression that must be resolved");
1998 switch (fixP
->fx_r_type
)
2001 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
2005 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
2009 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
2014 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
2018 case BFD_RELOC_ARC_B26
:
2019 /* If !fixP->fx_done then `value' is an implicit addend.
2020 We must shift it right by 2 in this case as well because the
2021 linker performs the relocation and then adds this in (as opposed
2022 to adding this in and then shifting right by 2). */
2024 md_number_to_chars (fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
,
2032 fixP
->fx_addnumber
= value
;
2037 /* Translate internal representation of relocation info to BFD target
2041 tc_gen_reloc (section
, fixP
)
2042 asection
*section ATTRIBUTE_UNUSED
;
2047 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
2049 reloc
->sym_ptr_ptr
= &fixP
->fx_addsy
->bsym
;
2050 reloc
->address
= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
2051 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixP
->fx_r_type
);
2052 if (reloc
->howto
== (reloc_howto_type
*) NULL
)
2054 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2055 "internal error: can't export reloc type %d (`%s')",
2057 bfd_get_reloc_code_name (fixP
->fx_r_type
));
2061 assert (!fixP
->fx_pcrel
== !reloc
->howto
->pc_relative
);
2063 /* Set addend to account for PC being advanced one insn before the
2064 target address is computed, drop fx_addnumber as it is handled
2067 reloc
->addend
= (fixP
->fx_pcrel
? -4 : 0);