projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
slight code improvement over previous delta
[deliverable/binutils-gdb.git] / gas / config / tc-arm.c
1 /* tc-arm.c -- Assemble for the ARM
2 Copyright (C) 1994, 95, 96, 97, 98, 1999 Free Software Foundation, Inc.
3 Contributed by Richard Earnshaw (rwe@pegasus.esprit.ec.org)
4 Modified by David Taylor (dtaylor@armltd.co.uk)
5
6 This file is part of GAS, the GNU Assembler.
7
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)
11 any later version.
12
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.
17
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
21 02111-1307, USA. */
22
23 #include <ctype.h>
24 #include <string.h>
25 #define NO_RELOC 0
26 #include "as.h"
27
28 /* need TARGET_CPU */
29 #include "config.h"
30 #include "subsegs.h"
31 #include "obstack.h"
32 #include "symbols.h"
33 #include "listing.h"
34
35 #ifdef OBJ_ELF
36 #include "elf/arm.h"
37 #endif
38
39 /* Types of processor to assemble for. */
40 #define ARM_1 0x00000001
41 #define ARM_2 0x00000002
42 #define ARM_3 0x00000004
43 #define ARM_250 ARM_3
44 #define ARM_6 0x00000008
45 #define ARM_7 ARM_6 /* same core instruction set */
46 #define ARM_8 ARM_6 /* same core instruction set */
47 #define ARM_9 ARM_6 /* same core instruction set */
48 #define ARM_CPU_MASK 0x0000000f
49
50 /* The following bitmasks control CPU extensions (ARM7 onwards): */
51 #define ARM_LONGMUL 0x00000010 /* allow long multiplies */
52 #define ARM_HALFWORD 0x00000020 /* allow half word loads */
53 #define ARM_THUMB 0x00000040 /* allow BX instruction */
54 #define ARM_EXT_V5 0x00000080 /* allow CLZ etc */
55
56 /* Architectures are the sum of the base and extensions */
57 #define ARM_ARCH_V4 (ARM_7 | ARM_LONGMUL | ARM_HALFWORD)
58 #define ARM_ARCH_V4T (ARM_ARCH_V4 | ARM_THUMB)
59 #define ARM_ARCH_V5 (ARM_ARCH_V4 | ARM_EXT_V5)
60 #define ARM_ARCH_V5T (ARM_ARCH_V5 | ARM_THUMB)
61
62 /* Some useful combinations: */
63 #define ARM_ANY 0x00ffffff
64 #define ARM_2UP (ARM_ANY - ARM_1)
65 #define ARM_ALL ARM_2UP /* Not arm1 only */
66 #define ARM_3UP 0x00fffffc
67 #define ARM_6UP 0x00fffff8 /* Includes ARM7 */
68
69 #define FPU_CORE 0x80000000
70 #define FPU_FPA10 0x40000000
71 #define FPU_FPA11 0x40000000
72 #define FPU_NONE 0
73
74 /* Some useful combinations */
75 #define FPU_ALL 0xff000000 /* Note this is ~ARM_ANY */
76 #define FPU_MEMMULTI 0x7f000000 /* Not fpu_core */
77
78
79 #ifndef CPU_DEFAULT
80 #if defined __thumb__
81 #define CPU_DEFAULT (ARM_ARCH_V4 | ARM_THUMB)
82 #else
83 #define CPU_DEFAULT ARM_ALL
84 #endif
85 #endif
86
87 #ifndef FPU_DEFAULT
88 #define FPU_DEFAULT FPU_ALL
89 #endif
90
91 #define streq(a, b) (strcmp (a, b) == 0)
92 #define skip_whitespace(str) while (* (str) == ' ') ++ (str)
93
94 static unsigned long cpu_variant = CPU_DEFAULT | FPU_DEFAULT;
95 static int target_oabi = 0;
96
97 #if defined OBJ_COFF || defined OBJ_ELF
98 /* Flags stored in private area of BFD structure */
99 static boolean uses_apcs_26 = false;
100 static boolean support_interwork = false;
101 static boolean uses_apcs_float = false;
102 static boolean pic_code = false;
103 #endif
104
105 /* This array holds the chars that always start a comment. If the
106 pre-processor is disabled, these aren't very useful */
107 CONST char comment_chars[] = "@";
108
109 /* This array holds the chars that only start a comment at the beginning of
110 a line. If the line seems to have the form '# 123 filename'
111 .line and .file directives will appear in the pre-processed output */
112 /* Note that input_file.c hand checks for '#' at the beginning of the
113 first line of the input file. This is because the compiler outputs
114 #NO_APP at the beginning of its output. */
115 /* Also note that comments like this one will always work. */
116 CONST char line_comment_chars[] = "#";
117
118 #ifdef TE_LINUX
119 CONST char line_separator_chars[] = ";";
120 #else
121 CONST char line_separator_chars[] = "";
122 #endif
123
124 /* Chars that can be used to separate mant from exp in floating point nums */
125 CONST char EXP_CHARS[] = "eE";
126
127 /* Chars that mean this number is a floating point constant */
128 /* As in 0f12.456 */
129 /* or 0d1.2345e12 */
130
131 CONST char FLT_CHARS[] = "rRsSfFdDxXeEpP";
132
133 /* Prefix characters that indicate the start of an immediate
134 value. */
135 #define is_immediate_prefix(C) ((C) == '#' || (C) == '$')
136
137 #ifdef OBJ_ELF
138 symbolS * GOT_symbol; /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
139 #endif
140
141 CONST int md_reloc_size = 8; /* Size of relocation record */
142
143 static int thumb_mode = 0; /* non-zero if assembling thumb instructions */
144
145 typedef struct arm_fix
146 {
147 int thumb_mode;
148 } arm_fix_data;
149
150 struct arm_it
151 {
152 CONST char * error;
153 unsigned long instruction;
154 int suffix;
155 int size;
156 struct
157 {
158 bfd_reloc_code_real_type type;
159 expressionS exp;
160 int pc_rel;
161 } reloc;
162 };
163
164 struct arm_it inst;
165
166 struct asm_shift
167 {
168 CONST char * template;
169 unsigned long value;
170 };
171
172 static CONST struct asm_shift shift[] =
173 {
174 {"asl", 0},
175 {"lsl", 0},
176 {"lsr", 0x00000020},
177 {"asr", 0x00000040},
178 {"ror", 0x00000060},
179 {"rrx", 0x00000060},
180 {"ASL", 0},
181 {"LSL", 0},
182 {"LSR", 0x00000020},
183 {"ASR", 0x00000040},
184 {"ROR", 0x00000060},
185 {"RRX", 0x00000060}
186 };
187
188 #define NO_SHIFT_RESTRICT 1
189 #define SHIFT_RESTRICT 0
190
191 #define NUM_FLOAT_VALS 8
192
193 CONST char * fp_const[] =
194 {
195 "0.0", "1.0", "2.0", "3.0", "4.0", "5.0", "0.5", "10.0", 0
196 };
197
198 /* Number of littlenums required to hold an extended precision number */
199 #define MAX_LITTLENUMS 6
200
201 LITTLENUM_TYPE fp_values[NUM_FLOAT_VALS][MAX_LITTLENUMS];
202
203 #define FAIL (-1)
204 #define SUCCESS (0)
205
206 #define SUFF_S 1
207 #define SUFF_D 2
208 #define SUFF_E 3
209 #define SUFF_P 4
210
211 #define CP_T_X 0x00008000
212 #define CP_T_Y 0x00400000
213 #define CP_T_Pre 0x01000000
214 #define CP_T_UD 0x00800000
215 #define CP_T_WB 0x00200000
216
217 #define CONDS_BIT (0x00100000)
218 #define LOAD_BIT (0x00100000)
219 #define TRANS_BIT (0x00200000)
220
221 struct asm_cond
222 {
223 CONST char * template;
224 unsigned long value;
225 };
226
227 /* This is to save a hash look-up in the common case */
228 #define COND_ALWAYS 0xe0000000
229
230 static CONST struct asm_cond conds[] =
231 {
232 {"eq", 0x00000000},
233 {"ne", 0x10000000},
234 {"cs", 0x20000000}, {"hs", 0x20000000},
235 {"cc", 0x30000000}, {"ul", 0x30000000}, {"lo", 0x30000000},
236 {"mi", 0x40000000},
237 {"pl", 0x50000000},
238 {"vs", 0x60000000},
239 {"vc", 0x70000000},
240 {"hi", 0x80000000},
241 {"ls", 0x90000000},
242 {"ge", 0xa0000000},
243 {"lt", 0xb0000000},
244 {"gt", 0xc0000000},
245 {"le", 0xd0000000},
246 {"al", 0xe0000000},
247 {"nv", 0xf0000000}
248 };
249
250 /* Warning: If the top bit of the set_bits is set, then the standard
251 instruction bitmask is ignored, and the new bitmask is taken from
252 the set_bits: */
253 struct asm_flg
254 {
255 CONST char * template; /* Basic flag string */
256 unsigned long set_bits; /* Bits to set */
257 };
258
259 static CONST struct asm_flg s_flag[] =
260 {
261 {"s", CONDS_BIT},
262 {NULL, 0}
263 };
264
265 static CONST struct asm_flg ldr_flags[] =
266 {
267 {"b", 0x00400000},
268 {"t", TRANS_BIT},
269 {"bt", 0x00400000 | TRANS_BIT},
270 {"h", 0x801000b0},
271 {"sh", 0x801000f0},
272 {"sb", 0x801000d0},
273 {NULL, 0}
274 };
275
276 static CONST struct asm_flg str_flags[] =
277 {
278 {"b", 0x00400000},
279 {"t", TRANS_BIT},
280 {"bt", 0x00400000 | TRANS_BIT},
281 {"h", 0x800000b0},
282 {NULL, 0}
283 };
284
285 static CONST struct asm_flg byte_flag[] =
286 {
287 {"b", 0x00400000},
288 {NULL, 0}
289 };
290
291 static CONST struct asm_flg cmp_flags[] =
292 {
293 {"s", CONDS_BIT},
294 {"p", 0x0010f000},
295 {NULL, 0}
296 };
297
298 static CONST struct asm_flg ldm_flags[] =
299 {
300 {"ed", 0x01800000},
301 {"fd", 0x00800000},
302 {"ea", 0x01000000},
303 {"fa", 0x08000000},
304 {"ib", 0x01800000},
305 {"ia", 0x00800000},
306 {"db", 0x01000000},
307 {"da", 0x08000000},
308 {NULL, 0}
309 };
310
311 static CONST struct asm_flg stm_flags[] =
312 {
313 {"ed", 0x08000000},
314 {"fd", 0x01000000},
315 {"ea", 0x00800000},
316 {"fa", 0x01800000},
317 {"ib", 0x01800000},
318 {"ia", 0x00800000},
319 {"db", 0x01000000},
320 {"da", 0x08000000},
321 {NULL, 0}
322 };
323
324 static CONST struct asm_flg lfm_flags[] =
325 {
326 {"fd", 0x00800000},
327 {"ea", 0x01000000},
328 {NULL, 0}
329 };
330
331 static CONST struct asm_flg sfm_flags[] =
332 {
333 {"fd", 0x01000000},
334 {"ea", 0x00800000},
335 {NULL, 0}
336 };
337
338 static CONST struct asm_flg round_flags[] =
339 {
340 {"p", 0x00000020},
341 {"m", 0x00000040},
342 {"z", 0x00000060},
343 {NULL, 0}
344 };
345
346 /* The implementation of the FIX instruction is broken on some assemblers,
347 in that it accepts a precision specifier as well as a rounding specifier,
348 despite the fact that this is meaningless. To be more compatible, we
349 accept it as well, though of course it does not set any bits. */
350 static CONST struct asm_flg fix_flags[] =
351 {
352 {"p", 0x00000020},
353 {"m", 0x00000040},
354 {"z", 0x00000060},
355 {"sp", 0x00000020},
356 {"sm", 0x00000040},
357 {"sz", 0x00000060},
358 {"dp", 0x00000020},
359 {"dm", 0x00000040},
360 {"dz", 0x00000060},
361 {"ep", 0x00000020},
362 {"em", 0x00000040},
363 {"ez", 0x00000060},
364 {NULL, 0}
365 };
366
367 static CONST struct asm_flg except_flag[] =
368 {
369 {"e", 0x00400000},
370 {NULL, 0}
371 };
372
373 static CONST struct asm_flg cplong_flag[] =
374 {
375 {"l", 0x00400000},
376 {NULL, 0}
377 };
378
379 struct asm_psr
380 {
381 CONST char * template;
382 unsigned long number;
383 };
384
385 #define PSR_FIELD_MASK 0x000f0000
386
387 #define PSR_FLAGS 0x00080000
388 #define PSR_CONTROL 0x00010000 /* Undocumented instruction, its use is discouraged by ARM */
389 #define PSR_ALL 0x00090000
390
391 #define CPSR_ALL 0
392 #define SPSR_ALL 1
393 #define CPSR_FLG 2
394 #define SPSR_FLG 3
395 #define CPSR_CTL 4
396 #define SPSR_CTL 5
397
398 static CONST struct asm_psr psrs[] =
399 {
400 /* Valid <psr>'s */
401 {"cpsr", CPSR_ALL},
402 {"cpsr_all", CPSR_ALL},
403 {"spsr", SPSR_ALL},
404 {"spsr_all", SPSR_ALL},
405
406 /* Valid <psrf>'s */
407 {"cpsr_flg", CPSR_FLG},
408 {"spsr_flg", SPSR_FLG},
409
410 /* Valid <psrc>'s */
411 {"cpsr_c", CPSR_CTL},
412 {"cpsr_ctl", CPSR_CTL},
413 {"spsr_c", SPSR_CTL},
414 {"spsr_ctl", SPSR_CTL}
415 };
416
417 /* Functions called by parser */
418 /* ARM instructions */
419 static void do_arit PARAMS ((char *, unsigned long));
420 static void do_cmp PARAMS ((char *, unsigned long));
421 static void do_mov PARAMS ((char *, unsigned long));
422 static void do_ldst PARAMS ((char *, unsigned long));
423 static void do_ldmstm PARAMS ((char *, unsigned long));
424 static void do_branch PARAMS ((char *, unsigned long));
425 static void do_swi PARAMS ((char *, unsigned long));
426 /* Pseudo Op codes */
427 static void do_adr PARAMS ((char *, unsigned long));
428 static void do_adrl PARAMS ((char *, unsigned long));
429 static void do_nop PARAMS ((char *, unsigned long));
430 /* ARM 2 */
431 static void do_mul PARAMS ((char *, unsigned long));
432 static void do_mla PARAMS ((char *, unsigned long));
433 /* ARM 3 */
434 static void do_swap PARAMS ((char *, unsigned long));
435 /* ARM 6 */
436 static void do_msr PARAMS ((char *, unsigned long));
437 static void do_mrs PARAMS ((char *, unsigned long));
438 /* ARM 7M */
439 static void do_mull PARAMS ((char *, unsigned long));
440 /* ARM THUMB */
441 static void do_bx PARAMS ((char *, unsigned long));
442
443 /* Coprocessor Instructions */
444 static void do_cdp PARAMS ((char *, unsigned long));
445 static void do_lstc PARAMS ((char *, unsigned long));
446 static void do_co_reg PARAMS ((char *, unsigned long));
447 static void do_fp_ctrl PARAMS ((char *, unsigned long));
448 static void do_fp_ldst PARAMS ((char *, unsigned long));
449 static void do_fp_ldmstm PARAMS ((char *, unsigned long));
450 static void do_fp_dyadic PARAMS ((char *, unsigned long));
451 static void do_fp_monadic PARAMS ((char *, unsigned long));
452 static void do_fp_cmp PARAMS ((char *, unsigned long));
453 static void do_fp_from_reg PARAMS ((char *, unsigned long));
454 static void do_fp_to_reg PARAMS ((char *, unsigned long));
455
456 static void fix_new_arm PARAMS ((fragS *, int, short, expressionS *, int, int));
457 static int arm_reg_parse PARAMS ((char **));
458 static int arm_psr_parse PARAMS ((char **));
459 static void symbol_locate PARAMS ((symbolS *, CONST char *, segT, valueT, fragS *));
460 static int add_to_lit_pool PARAMS ((void));
461 static unsigned validate_immediate PARAMS ((unsigned));
462 static unsigned validate_immediate_twopart PARAMS ((unsigned int, unsigned int *));
463 static int validate_offset_imm PARAMS ((unsigned int, int));
464 static void opcode_select PARAMS ((int));
465 static void end_of_line PARAMS ((char *));
466 static int reg_required_here PARAMS ((char **, int));
467 static int psr_required_here PARAMS ((char **, int, int));
468 static int co_proc_number PARAMS ((char **));
469 static int cp_opc_expr PARAMS ((char **, int, int));
470 static int cp_reg_required_here PARAMS ((char **, int));
471 static int fp_reg_required_here PARAMS ((char **, int));
472 static int cp_address_offset PARAMS ((char **));
473 static int cp_address_required_here PARAMS ((char **));
474 static int my_get_float_expression PARAMS ((char **));
475 static int skip_past_comma PARAMS ((char **));
476 static int walk_no_bignums PARAMS ((symbolS *));
477 static int negate_data_op PARAMS ((unsigned long *, unsigned long));
478 static int data_op2 PARAMS ((char **));
479 static int fp_op2 PARAMS ((char **));
480 static long reg_list PARAMS ((char **));
481 static void thumb_load_store PARAMS ((char *, int, int));
482 static int decode_shift PARAMS ((char **, int));
483 static int ldst_extend PARAMS ((char **, int));
484 static void thumb_add_sub PARAMS ((char *, int));
485 static void insert_reg PARAMS ((int));
486 static void thumb_shift PARAMS ((char *, int));
487 static void thumb_mov_compare PARAMS ((char *, int));
488 static void set_constant_flonums PARAMS ((void));
489 static valueT md_chars_to_number PARAMS ((char *, int));
490 static void insert_reg_alias PARAMS ((char *, int));
491 static void output_inst PARAMS ((void));
492 #ifdef OBJ_ELF
493 static bfd_reloc_code_real_type arm_parse_reloc PARAMS ((void));
494 #endif
495
496 /* ARM instructions take 4bytes in the object file, Thumb instructions
497 take 2: */
498 #define INSN_SIZE 4
499
500 /* LONGEST_INST is the longest basic instruction name without conditions or
501 * flags.
502 * ARM7M has 4 of length 5
503 */
504
505 #define LONGEST_INST 5
506
507 struct asm_opcode
508 {
509 CONST char * template; /* Basic string to match */
510 unsigned long value; /* Basic instruction code */
511 CONST char * comp_suffix; /* Compulsory suffix that must follow conds */
512 CONST struct asm_flg * flags; /* Bits to toggle if flag 'n' set */
513 unsigned long variants; /* Which CPU variants this exists for */
514 /* Function to call to parse args */
515 void (* parms) PARAMS ((char *, unsigned long));
516 };
517
518 static CONST struct asm_opcode insns[] =
519 {
520 /* ARM Instructions */
521 {"and", 0x00000000, NULL, s_flag, ARM_ANY, do_arit},
522 {"eor", 0x00200000, NULL, s_flag, ARM_ANY, do_arit},
523 {"sub", 0x00400000, NULL, s_flag, ARM_ANY, do_arit},
524 {"rsb", 0x00600000, NULL, s_flag, ARM_ANY, do_arit},
525 {"add", 0x00800000, NULL, s_flag, ARM_ANY, do_arit},
526 {"adc", 0x00a00000, NULL, s_flag, ARM_ANY, do_arit},
527 {"sbc", 0x00c00000, NULL, s_flag, ARM_ANY, do_arit},
528 {"rsc", 0x00e00000, NULL, s_flag, ARM_ANY, do_arit},
529 {"orr", 0x01800000, NULL, s_flag, ARM_ANY, do_arit},
530 {"bic", 0x01c00000, NULL, s_flag, ARM_ANY, do_arit},
531 {"tst", 0x01000000, NULL, cmp_flags, ARM_ANY, do_cmp},
532 {"teq", 0x01200000, NULL, cmp_flags, ARM_ANY, do_cmp},
533 {"cmp", 0x01400000, NULL, cmp_flags, ARM_ANY, do_cmp},
534 {"cmn", 0x01600000, NULL, cmp_flags, ARM_ANY, do_cmp},
535 {"mov", 0x01a00000, NULL, s_flag, ARM_ANY, do_mov},
536 {"mvn", 0x01e00000, NULL, s_flag, ARM_ANY, do_mov},
537 {"str", 0x04000000, NULL, str_flags, ARM_ANY, do_ldst},
538 {"ldr", 0x04100000, NULL, ldr_flags, ARM_ANY, do_ldst},
539 {"stm", 0x08000000, NULL, stm_flags, ARM_ANY, do_ldmstm},
540 {"ldm", 0x08100000, NULL, ldm_flags, ARM_ANY, do_ldmstm},
541 {"swi", 0x0f000000, NULL, NULL, ARM_ANY, do_swi},
542 {"bl", 0x0bfffffe, NULL, NULL, ARM_ANY, do_branch},
543 {"b", 0x0afffffe, NULL, NULL, ARM_ANY, do_branch},
544
545 /* Pseudo ops */
546 {"adr", 0x028f0000, NULL, NULL, ARM_ANY, do_adr},
547 {"adrl", 0x028f0000, NULL, NULL, ARM_ANY, do_adrl},
548 {"nop", 0x01a00000, NULL, NULL, ARM_ANY, do_nop},
549
550 /* ARM 2 multiplies */
551 {"mul", 0x00000090, NULL, s_flag, ARM_2UP, do_mul},
552 {"mla", 0x00200090, NULL, s_flag, ARM_2UP, do_mla},
553
554 /* ARM 3 - swp instructions */
555 {"swp", 0x01000090, NULL, byte_flag, ARM_3UP, do_swap},
556
557 /* ARM 6 Coprocessor instructions */
558 {"mrs", 0x010f0000, NULL, NULL, ARM_6UP, do_mrs},
559 {"msr", 0x0120f000, NULL, NULL, ARM_6UP, do_msr},
560 /* ScottB: our code uses 0x0128f000 for msr.
561 NickC: but this is wrong because the bits 16 and 19 are handled
562 by the PSR_xxx defines above. */
563
564 /* ARM 7M long multiplies - need signed/unsigned flags! */
565 {"smull", 0x00c00090, NULL, s_flag, ARM_LONGMUL, do_mull},
566 {"umull", 0x00800090, NULL, s_flag, ARM_LONGMUL, do_mull},
567 {"smlal", 0x00e00090, NULL, s_flag, ARM_LONGMUL, do_mull},
568 {"umlal", 0x00a00090, NULL, s_flag, ARM_LONGMUL, do_mull},
569
570 /* ARM THUMB interworking */
571 {"bx", 0x012fff10, NULL, NULL, ARM_THUMB, do_bx},
572
573 /* Floating point instructions */
574 {"wfs", 0x0e200110, NULL, NULL, FPU_ALL, do_fp_ctrl},
575 {"rfs", 0x0e300110, NULL, NULL, FPU_ALL, do_fp_ctrl},
576 {"wfc", 0x0e400110, NULL, NULL, FPU_ALL, do_fp_ctrl},
577 {"rfc", 0x0e500110, NULL, NULL, FPU_ALL, do_fp_ctrl},
578 {"ldf", 0x0c100100, "sdep", NULL, FPU_ALL, do_fp_ldst},
579 {"stf", 0x0c000100, "sdep", NULL, FPU_ALL, do_fp_ldst},
580 {"lfm", 0x0c100200, NULL, lfm_flags, FPU_MEMMULTI, do_fp_ldmstm},
581 {"sfm", 0x0c000200, NULL, sfm_flags, FPU_MEMMULTI, do_fp_ldmstm},
582 {"mvf", 0x0e008100, "sde", round_flags, FPU_ALL, do_fp_monadic},
583 {"mnf", 0x0e108100, "sde", round_flags, FPU_ALL, do_fp_monadic},
584 {"abs", 0x0e208100, "sde", round_flags, FPU_ALL, do_fp_monadic},
585 {"rnd", 0x0e308100, "sde", round_flags, FPU_ALL, do_fp_monadic},
586 {"sqt", 0x0e408100, "sde", round_flags, FPU_ALL, do_fp_monadic},
587 {"log", 0x0e508100, "sde", round_flags, FPU_ALL, do_fp_monadic},
588 {"lgn", 0x0e608100, "sde", round_flags, FPU_ALL, do_fp_monadic},
589 {"exp", 0x0e708100, "sde", round_flags, FPU_ALL, do_fp_monadic},
590 {"sin", 0x0e808100, "sde", round_flags, FPU_ALL, do_fp_monadic},
591 {"cos", 0x0e908100, "sde", round_flags, FPU_ALL, do_fp_monadic},
592 {"tan", 0x0ea08100, "sde", round_flags, FPU_ALL, do_fp_monadic},
593 {"asn", 0x0eb08100, "sde", round_flags, FPU_ALL, do_fp_monadic},
594 {"acs", 0x0ec08100, "sde", round_flags, FPU_ALL, do_fp_monadic},
595 {"atn", 0x0ed08100, "sde", round_flags, FPU_ALL, do_fp_monadic},
596 {"urd", 0x0ee08100, "sde", round_flags, FPU_ALL, do_fp_monadic},
597 {"nrm", 0x0ef08100, "sde", round_flags, FPU_ALL, do_fp_monadic},
598 {"adf", 0x0e000100, "sde", round_flags, FPU_ALL, do_fp_dyadic},
599 {"suf", 0x0e200100, "sde", round_flags, FPU_ALL, do_fp_dyadic},
600 {"rsf", 0x0e300100, "sde", round_flags, FPU_ALL, do_fp_dyadic},
601 {"muf", 0x0e100100, "sde", round_flags, FPU_ALL, do_fp_dyadic},
602 {"dvf", 0x0e400100, "sde", round_flags, FPU_ALL, do_fp_dyadic},
603 {"rdf", 0x0e500100, "sde", round_flags, FPU_ALL, do_fp_dyadic},
604 {"pow", 0x0e600100, "sde", round_flags, FPU_ALL, do_fp_dyadic},
605 {"rpw", 0x0e700100, "sde", round_flags, FPU_ALL, do_fp_dyadic},
606 {"rmf", 0x0e800100, "sde", round_flags, FPU_ALL, do_fp_dyadic},
607 {"fml", 0x0e900100, "sde", round_flags, FPU_ALL, do_fp_dyadic},
608 {"fdv", 0x0ea00100, "sde", round_flags, FPU_ALL, do_fp_dyadic},
609 {"frd", 0x0eb00100, "sde", round_flags, FPU_ALL, do_fp_dyadic},
610 {"pol", 0x0ec00100, "sde", round_flags, FPU_ALL, do_fp_dyadic},
611 {"cmf", 0x0e90f110, NULL, except_flag, FPU_ALL, do_fp_cmp},
612 {"cnf", 0x0eb0f110, NULL, except_flag, FPU_ALL, do_fp_cmp},
613 /* The FPA10 data sheet suggests that the 'E' of cmfe/cnfe should not
614 be an optional suffix, but part of the instruction. To be compatible,
615 we accept either. */
616 {"cmfe", 0x0ed0f110, NULL, NULL, FPU_ALL, do_fp_cmp},
617 {"cnfe", 0x0ef0f110, NULL, NULL, FPU_ALL, do_fp_cmp},
618 {"flt", 0x0e000110, "sde", round_flags, FPU_ALL, do_fp_from_reg},
619 {"fix", 0x0e100110, NULL, fix_flags, FPU_ALL, do_fp_to_reg},
620
621 /* Generic copressor instructions */
622 {"cdp", 0x0e000000, NULL, NULL, ARM_2UP, do_cdp},
623 {"ldc", 0x0c100000, NULL, cplong_flag, ARM_2UP, do_lstc},
624 {"stc", 0x0c000000, NULL, cplong_flag, ARM_2UP, do_lstc},
625 {"mcr", 0x0e000010, NULL, NULL, ARM_2UP, do_co_reg},
626 {"mrc", 0x0e100010, NULL, NULL, ARM_2UP, do_co_reg},
627 };
628
629 /* defines for various bits that we will want to toggle */
630
631 #define INST_IMMEDIATE 0x02000000
632 #define OFFSET_REG 0x02000000
633 #define HWOFFSET_IMM 0x00400000
634 #define SHIFT_BY_REG 0x00000010
635 #define PRE_INDEX 0x01000000
636 #define INDEX_UP 0x00800000
637 #define WRITE_BACK 0x00200000
638 #define MULTI_SET_PSR 0x00400000
639
640 #define LITERAL_MASK 0xf000f000
641 #define COND_MASK 0xf0000000
642 #define OPCODE_MASK 0xfe1fffff
643 #define DATA_OP_SHIFT 21
644
645 /* Codes to distinguish the arithmetic instructions */
646
647 #define OPCODE_AND 0
648 #define OPCODE_EOR 1
649 #define OPCODE_SUB 2
650 #define OPCODE_RSB 3
651 #define OPCODE_ADD 4
652 #define OPCODE_ADC 5
653 #define OPCODE_SBC 6
654 #define OPCODE_RSC 7
655 #define OPCODE_TST 8
656 #define OPCODE_TEQ 9
657 #define OPCODE_CMP 10
658 #define OPCODE_CMN 11
659 #define OPCODE_ORR 12
660 #define OPCODE_MOV 13
661 #define OPCODE_BIC 14
662 #define OPCODE_MVN 15
663
664 static void do_t_nop PARAMS ((char *));
665 static void do_t_arit PARAMS ((char *));
666 static void do_t_add PARAMS ((char *));
667 static void do_t_asr PARAMS ((char *));
668 static void do_t_branch9 PARAMS ((char *));
669 static void do_t_branch12 PARAMS ((char *));
670 static void do_t_branch23 PARAMS ((char *));
671 static void do_t_bx PARAMS ((char *));
672 static void do_t_compare PARAMS ((char *));
673 static void do_t_ldmstm PARAMS ((char *));
674 static void do_t_ldr PARAMS ((char *));
675 static void do_t_ldrb PARAMS ((char *));
676 static void do_t_ldrh PARAMS ((char *));
677 static void do_t_lds PARAMS ((char *));
678 static void do_t_lsl PARAMS ((char *));
679 static void do_t_lsr PARAMS ((char *));
680 static void do_t_mov PARAMS ((char *));
681 static void do_t_push_pop PARAMS ((char *));
682 static void do_t_str PARAMS ((char *));
683 static void do_t_strb PARAMS ((char *));
684 static void do_t_strh PARAMS ((char *));
685 static void do_t_sub PARAMS ((char *));
686 static void do_t_swi PARAMS ((char *));
687 static void do_t_adr PARAMS ((char *));
688
689 #define T_OPCODE_MUL 0x4340
690 #define T_OPCODE_TST 0x4200
691 #define T_OPCODE_CMN 0x42c0
692 #define T_OPCODE_NEG 0x4240
693 #define T_OPCODE_MVN 0x43c0
694
695 #define T_OPCODE_ADD_R3 0x1800
696 #define T_OPCODE_SUB_R3 0x1a00
697 #define T_OPCODE_ADD_HI 0x4400
698 #define T_OPCODE_ADD_ST 0xb000
699 #define T_OPCODE_SUB_ST 0xb080
700 #define T_OPCODE_ADD_SP 0xa800
701 #define T_OPCODE_ADD_PC 0xa000
702 #define T_OPCODE_ADD_I8 0x3000
703 #define T_OPCODE_SUB_I8 0x3800
704 #define T_OPCODE_ADD_I3 0x1c00
705 #define T_OPCODE_SUB_I3 0x1e00
706
707 #define T_OPCODE_ASR_R 0x4100
708 #define T_OPCODE_LSL_R 0x4080
709 #define T_OPCODE_LSR_R 0x40c0
710 #define T_OPCODE_ASR_I 0x1000
711 #define T_OPCODE_LSL_I 0x0000
712 #define T_OPCODE_LSR_I 0x0800
713
714 #define T_OPCODE_MOV_I8 0x2000
715 #define T_OPCODE_CMP_I8 0x2800
716 #define T_OPCODE_CMP_LR 0x4280
717 #define T_OPCODE_MOV_HR 0x4600
718 #define T_OPCODE_CMP_HR 0x4500
719
720 #define T_OPCODE_LDR_PC 0x4800
721 #define T_OPCODE_LDR_SP 0x9800
722 #define T_OPCODE_STR_SP 0x9000
723 #define T_OPCODE_LDR_IW 0x6800
724 #define T_OPCODE_STR_IW 0x6000
725 #define T_OPCODE_LDR_IH 0x8800
726 #define T_OPCODE_STR_IH 0x8000
727 #define T_OPCODE_LDR_IB 0x7800
728 #define T_OPCODE_STR_IB 0x7000
729 #define T_OPCODE_LDR_RW 0x5800
730 #define T_OPCODE_STR_RW 0x5000
731 #define T_OPCODE_LDR_RH 0x5a00
732 #define T_OPCODE_STR_RH 0x5200
733 #define T_OPCODE_LDR_RB 0x5c00
734 #define T_OPCODE_STR_RB 0x5400
735
736 #define T_OPCODE_PUSH 0xb400
737 #define T_OPCODE_POP 0xbc00
738
739 #define T_OPCODE_BRANCH 0xe7fe
740
741 static int thumb_reg PARAMS ((char ** str, int hi_lo));
742
743 #define THUMB_SIZE 2 /* Size of thumb instruction */
744 #define THUMB_REG_LO 0x1
745 #define THUMB_REG_HI 0x2
746 #define THUMB_REG_ANY 0x3
747
748 #define THUMB_H1 0x0080
749 #define THUMB_H2 0x0040
750
751 #define THUMB_ASR 0
752 #define THUMB_LSL 1
753 #define THUMB_LSR 2
754
755 #define THUMB_MOVE 0
756 #define THUMB_COMPARE 1
757
758 #define THUMB_LOAD 0
759 #define THUMB_STORE 1
760
761 #define THUMB_PP_PC_LR 0x0100
762
763 /* These three are used for immediate shifts, do not alter */
764 #define THUMB_WORD 2
765 #define THUMB_HALFWORD 1
766 #define THUMB_BYTE 0
767
768 struct thumb_opcode
769 {
770 CONST char * template; /* Basic string to match */
771 unsigned long value; /* Basic instruction code */
772 int size;
773 void (* parms) PARAMS ((char *)); /* Function to call to parse args */
774 };
775
776 static CONST struct thumb_opcode tinsns[] =
777 {
778 {"adc", 0x4140, 2, do_t_arit},
779 {"add", 0x0000, 2, do_t_add},
780 {"and", 0x4000, 2, do_t_arit},
781 {"asr", 0x0000, 2, do_t_asr},
782 {"b", T_OPCODE_BRANCH, 2, do_t_branch12},
783 {"beq", 0xd0fe, 2, do_t_branch9},
784 {"bne", 0xd1fe, 2, do_t_branch9},
785 {"bcs", 0xd2fe, 2, do_t_branch9},
786 {"bhs", 0xd2fe, 2, do_t_branch9},
787 {"bcc", 0xd3fe, 2, do_t_branch9},
788 {"bul", 0xd3fe, 2, do_t_branch9},
789 {"blo", 0xd3fe, 2, do_t_branch9},
790 {"bmi", 0xd4fe, 2, do_t_branch9},
791 {"bpl", 0xd5fe, 2, do_t_branch9},
792 {"bvs", 0xd6fe, 2, do_t_branch9},
793 {"bvc", 0xd7fe, 2, do_t_branch9},
794 {"bhi", 0xd8fe, 2, do_t_branch9},
795 {"bls", 0xd9fe, 2, do_t_branch9},
796 {"bge", 0xdafe, 2, do_t_branch9},
797 {"blt", 0xdbfe, 2, do_t_branch9},
798 {"bgt", 0xdcfe, 2, do_t_branch9},
799 {"ble", 0xddfe, 2, do_t_branch9},
800 {"bic", 0x4380, 2, do_t_arit},
801 {"bl", 0xf7fffffe, 4, do_t_branch23},
802 {"bx", 0x4700, 2, do_t_bx},
803 {"cmn", T_OPCODE_CMN, 2, do_t_arit},
804 {"cmp", 0x0000, 2, do_t_compare},
805 {"eor", 0x4040, 2, do_t_arit},
806 {"ldmia", 0xc800, 2, do_t_ldmstm},
807 {"ldr", 0x0000, 2, do_t_ldr},
808 {"ldrb", 0x0000, 2, do_t_ldrb},
809 {"ldrh", 0x0000, 2, do_t_ldrh},
810 {"ldrsb", 0x5600, 2, do_t_lds},
811 {"ldrsh", 0x5e00, 2, do_t_lds},
812 {"ldsb", 0x5600, 2, do_t_lds},
813 {"ldsh", 0x5e00, 2, do_t_lds},
814 {"lsl", 0x0000, 2, do_t_lsl},
815 {"lsr", 0x0000, 2, do_t_lsr},
816 {"mov", 0x0000, 2, do_t_mov},
817 {"mul", T_OPCODE_MUL, 2, do_t_arit},
818 {"mvn", T_OPCODE_MVN, 2, do_t_arit},
819 {"neg", T_OPCODE_NEG, 2, do_t_arit},
820 {"orr", 0x4300, 2, do_t_arit},
821 {"pop", 0xbc00, 2, do_t_push_pop},
822 {"push", 0xb400, 2, do_t_push_pop},
823 {"ror", 0x41c0, 2, do_t_arit},
824 {"sbc", 0x4180, 2, do_t_arit},
825 {"stmia", 0xc000, 2, do_t_ldmstm},
826 {"str", 0x0000, 2, do_t_str},
827 {"strb", 0x0000, 2, do_t_strb},
828 {"strh", 0x0000, 2, do_t_strh},
829 {"swi", 0xdf00, 2, do_t_swi},
830 {"sub", 0x0000, 2, do_t_sub},
831 {"tst", T_OPCODE_TST, 2, do_t_arit},
832 /* Pseudo ops: */
833 {"adr", 0x0000, 2, do_t_adr},
834 {"nop", 0x46C0, 2, do_t_nop}, /* mov r8,r8 */
835 };
836
837 struct reg_entry
838 {
839 CONST char * name;
840 int number;
841 };
842
843 #define int_register(reg) ((reg) >= 0 && (reg) <= 15)
844 #define cp_register(reg) ((reg) >= 32 && (reg) <= 47)
845 #define fp_register(reg) ((reg) >= 16 && (reg) <= 23)
846
847 #define REG_PC 15
848 #define REG_LR 14
849 #define REG_SP 13
850
851 /* These are the standard names; Users can add aliases with .req */
852 static CONST struct reg_entry reg_table[] =
853 {
854 /* Processor Register Numbers */
855 {"r0", 0}, {"r1", 1}, {"r2", 2}, {"r3", 3},
856 {"r4", 4}, {"r5", 5}, {"r6", 6}, {"r7", 7},
857 {"r8", 8}, {"r9", 9}, {"r10", 10}, {"r11", 11},
858 {"r12", 12}, {"r13", REG_SP},{"r14", REG_LR},{"r15", REG_PC},
859 /* APCS conventions */
860 {"a1", 0}, {"a2", 1}, {"a3", 2}, {"a4", 3},
861 {"v1", 4}, {"v2", 5}, {"v3", 6}, {"v4", 7}, {"v5", 8},
862 {"v6", 9}, {"sb", 9}, {"v7", 10}, {"sl", 10},
863 {"fp", 11}, {"ip", 12}, {"sp", REG_SP},{"lr", REG_LR},{"pc", REG_PC},
864 /* FP Registers */
865 {"f0", 16}, {"f1", 17}, {"f2", 18}, {"f3", 19},
866 {"f4", 20}, {"f5", 21}, {"f6", 22}, {"f7", 23},
867 {"c0", 32}, {"c1", 33}, {"c2", 34}, {"c3", 35},
868 {"c4", 36}, {"c5", 37}, {"c6", 38}, {"c7", 39},
869 {"c8", 40}, {"c9", 41}, {"c10", 42}, {"c11", 43},
870 {"c12", 44}, {"c13", 45}, {"c14", 46}, {"c15", 47},
871 {"cr0", 32}, {"cr1", 33}, {"cr2", 34}, {"cr3", 35},
872 {"cr4", 36}, {"cr5", 37}, {"cr6", 38}, {"cr7", 39},
873 {"cr8", 40}, {"cr9", 41}, {"cr10", 42}, {"cr11", 43},
874 {"cr12", 44}, {"cr13", 45}, {"cr14", 46}, {"cr15", 47},
875 {NULL, 0}
876 };
877
878 #define bad_args _("Bad arguments to instruction");
879 #define bad_pc _("r15 not allowed here");
880
881 static struct hash_control * arm_ops_hsh = NULL;
882 static struct hash_control * arm_tops_hsh = NULL;
883 static struct hash_control * arm_cond_hsh = NULL;
884 static struct hash_control * arm_shift_hsh = NULL;
885 static struct hash_control * arm_reg_hsh = NULL;
886 static struct hash_control * arm_psr_hsh = NULL;
887
888 /* This table describes all the machine specific pseudo-ops the assembler
889 has to support. The fields are:
890 pseudo-op name without dot
891 function to call to execute this pseudo-op
892 Integer arg to pass to the function
893 */
894
895 static void s_req PARAMS ((int));
896 static void s_align PARAMS ((int));
897 static void s_bss PARAMS ((int));
898 static void s_even PARAMS ((int));
899 static void s_ltorg PARAMS ((int));
900 static void s_arm PARAMS ((int));
901 static void s_thumb PARAMS ((int));
902 static void s_code PARAMS ((int));
903 static void s_force_thumb PARAMS ((int));
904 static void s_thumb_func PARAMS ((int));
905 static void s_thumb_set PARAMS ((int));
906 static void arm_s_text PARAMS ((int));
907 static void arm_s_data PARAMS ((int));
908 #ifdef OBJ_ELF
909 static void arm_s_section PARAMS ((int));
910 static void s_arm_elf_cons PARAMS ((int));
911 #endif
912
913 static int my_get_expression PARAMS ((expressionS *, char **));
914
915 CONST pseudo_typeS md_pseudo_table[] =
916 {
917 { "req", s_req, 0 }, /* Never called becasue '.req' does not start line */
918 { "bss", s_bss, 0 },
919 { "align", s_align, 0 },
920 { "arm", s_arm, 0 },
921 { "thumb", s_thumb, 0 },
922 { "code", s_code, 0 },
923 { "force_thumb", s_force_thumb, 0 },
924 { "thumb_func", s_thumb_func, 0 },
925 { "thumb_set", s_thumb_set, 0 },
926 { "even", s_even, 0 },
927 { "ltorg", s_ltorg, 0 },
928 { "pool", s_ltorg, 0 },
929 /* Allow for the effect of section changes. */
930 { "text", arm_s_text, 0 },
931 { "data", arm_s_data, 0 },
932 #ifdef OBJ_ELF
933 { "section", arm_s_section, 0 },
934 { "section.s", arm_s_section, 0 },
935 { "sect", arm_s_section, 0 },
936 { "sect.s", arm_s_section, 0 },
937 { "word", s_arm_elf_cons, 4 },
938 { "long", s_arm_elf_cons, 4 },
939 #else
940 { "word", cons, 4},
941 #endif
942 { "extend", float_cons, 'x' },
943 { "ldouble", float_cons, 'x' },
944 { "packed", float_cons, 'p' },
945 { 0, 0, 0 }
946 };
947
948 /* Stuff needed to resolve the label ambiguity
949 As:
950 ...
951 label: <insn>
952 may differ from:
953 ...
954 label:
955 <insn>
956 */
957
958 symbolS * last_label_seen;
959 static int label_is_thumb_function_name = false;
960
961 /* Literal stuff */
962
963 #define MAX_LITERAL_POOL_SIZE 1024
964
965 typedef struct literalS
966 {
967 struct expressionS exp;
968 struct arm_it * inst;
969 } literalT;
970
971 literalT literals[MAX_LITERAL_POOL_SIZE];
972 int next_literal_pool_place = 0; /* Next free entry in the pool */
973 int lit_pool_num = 1; /* Next literal pool number */
974 symbolS * current_poolP = NULL;
975
976 static int
977 add_to_lit_pool ()
978 {
979 int lit_count = 0;
980
981 if (current_poolP == NULL)
982 current_poolP = symbol_create (FAKE_LABEL_NAME, undefined_section,
983 (valueT) 0, &zero_address_frag);
984
985 /* Check if this literal value is already in the pool: */
986 while (lit_count < next_literal_pool_place)
987 {
988 if (literals[lit_count].exp.X_op == inst.reloc.exp.X_op
989 && inst.reloc.exp.X_op == O_constant
990 && literals[lit_count].exp.X_add_number == inst.reloc.exp.X_add_number
991 && literals[lit_count].exp.X_unsigned == inst.reloc.exp.X_unsigned)
992 break;
993 lit_count++;
994 }
995
996 if (lit_count == next_literal_pool_place) /* new entry */
997 {
998 if (next_literal_pool_place > MAX_LITERAL_POOL_SIZE)
999 {
1000 inst.error = _("Literal Pool Overflow");
1001 return FAIL;
1002 }
1003
1004 literals[next_literal_pool_place].exp = inst.reloc.exp;
1005 lit_count = next_literal_pool_place++;
1006 }
1007
1008 inst.reloc.exp.X_op = O_symbol;
1009 inst.reloc.exp.X_add_number = (lit_count) * 4 - 8;
1010 inst.reloc.exp.X_add_symbol = current_poolP;
1011
1012 return SUCCESS;
1013 }
1014
1015 /* Can't use symbol_new here, so have to create a symbol and then at
1016 a later date assign it a value. Thats what these functions do. */
1017 static void
1018 symbol_locate (symbolP, name, segment, valu, frag)
1019 symbolS * symbolP;
1020 CONST char * name; /* It is copied, the caller can modify */
1021 segT segment; /* Segment identifier (SEG_<something>) */
1022 valueT valu; /* Symbol value */
1023 fragS * frag; /* Associated fragment */
1024 {
1025 unsigned int name_length;
1026 char * preserved_copy_of_name;
1027
1028 name_length = strlen (name) + 1; /* +1 for \0 */
1029 obstack_grow (&notes, name, name_length);
1030 preserved_copy_of_name = obstack_finish (&notes);
1031 #ifdef STRIP_UNDERSCORE
1032 if (preserved_copy_of_name[0] == '_')
1033 preserved_copy_of_name++;
1034 #endif
1035
1036 #ifdef tc_canonicalize_symbol_name
1037 preserved_copy_of_name =
1038 tc_canonicalize_symbol_name (preserved_copy_of_name);
1039 #endif
1040
1041 S_SET_NAME (symbolP, preserved_copy_of_name);
1042
1043 S_SET_SEGMENT (symbolP, segment);
1044 S_SET_VALUE (symbolP, valu);
1045 symbol_clear_list_pointers(symbolP);
1046
1047 symbol_set_frag (symbolP, frag);
1048
1049 /* Link to end of symbol chain. */
1050 {
1051 extern int symbol_table_frozen;
1052 if (symbol_table_frozen)
1053 abort ();
1054 }
1055
1056 symbol_append (symbolP, symbol_lastP, & symbol_rootP, & symbol_lastP);
1057
1058 obj_symbol_new_hook (symbolP);
1059
1060 #ifdef tc_symbol_new_hook
1061 tc_symbol_new_hook (symbolP);
1062 #endif
1063
1064 #ifdef DEBUG_SYMS
1065 verify_symbol_chain (symbol_rootP, symbol_lastP);
1066 #endif /* DEBUG_SYMS */
1067 }
1068
1069 /* Check that an immediate is valid, and if so, convert it to the right format. */
1070
1071 static unsigned int
1072 validate_immediate (val)
1073 unsigned int val;
1074 {
1075 unsigned int a;
1076 unsigned int i;
1077
1078 #define rotate_left(v, n) (v << n | v >> (32 - n))
1079
1080 for (i = 0; i < 32; i += 2)
1081 if ((a = rotate_left (val, i)) <= 0xff)
1082 return a | (i << 7); /* 12-bit pack: [shift-cnt,const] */
1083
1084 return FAIL;
1085 }
1086
1087 /* Check to see if an immediate can be computed as two seperate immediate
1088 values, added together. We already know that this value cannot be
1089 computed by just one ARM instruction. */
1090
1091 static unsigned int
1092 validate_immediate_twopart (val, highpart)
1093 unsigned int val;
1094 unsigned int * highpart;
1095 {
1096 unsigned int a;
1097 unsigned int i;
1098
1099 for (i = 0; i < 32; i += 2)
1100 if (((a = rotate_left (val, i)) & 0xff) != 0)
1101 {
1102 if (a & 0xff00)
1103 {
1104 if (a & ~ 0xffff)
1105 continue;
1106 * highpart = (a >> 8) | ((i + 24) << 7);
1107 }
1108 else if (a & 0xff0000)
1109 {
1110 if (a & 0xff000000)
1111 continue;
1112
1113 * highpart = (a >> 16) | ((i + 16) << 7);
1114 }
1115 else
1116 {
1117 assert (a & 0xff000000);
1118
1119 * highpart = (a >> 24) | ((i + 8) << 7);
1120 }
1121
1122 return (a & 0xff) | (i << 7);
1123 }
1124
1125 return FAIL;
1126 }
1127
1128 static int
1129 validate_offset_imm (val, hwse)
1130 unsigned int val;
1131 int hwse;
1132 {
1133 if ((hwse && val > 255) || val > 4095)
1134 return FAIL;
1135 return val;
1136 }
1137
1138
1139 static void
1140 s_req (a)
1141 int a;
1142 {
1143 as_bad (_("Invalid syntax for .req directive."));
1144 }
1145
1146 static void
1147 s_bss (ignore)
1148 int ignore;
1149 {
1150 /* We don't support putting frags in the BSS segment, we fake it by
1151 marking in_bss, then looking at s_skip for clues?.. */
1152 subseg_set (bss_section, 0);
1153 demand_empty_rest_of_line ();
1154 }
1155
1156 static void
1157 s_even (ignore)
1158 int ignore;
1159 {
1160 if (!need_pass_2) /* Never make frag if expect extra pass. */
1161 frag_align (1, 0, 0);
1162
1163 record_alignment (now_seg, 1);
1164
1165 demand_empty_rest_of_line ();
1166 }
1167
1168 static void
1169 s_ltorg (ignored)
1170 int ignored;
1171 {
1172 int lit_count = 0;
1173 char sym_name[20];
1174
1175 if (current_poolP == NULL)
1176 return;
1177
1178 /* Align pool as you have word accesses */
1179 /* Only make a frag if we have to ... */
1180 if (!need_pass_2)
1181 frag_align (2, 0, 0);
1182
1183 record_alignment (now_seg, 2);
1184
1185 sprintf (sym_name, "$$lit_\002%x", lit_pool_num++);
1186
1187 symbol_locate (current_poolP, sym_name, now_seg,
1188 (valueT) frag_now_fix (), frag_now);
1189 symbol_table_insert (current_poolP);
1190
1191 ARM_SET_THUMB (current_poolP, thumb_mode);
1192
1193 #if defined OBJ_COFF || defined OBJ_ELF
1194 ARM_SET_INTERWORK (current_poolP, support_interwork);
1195 #endif
1196
1197 while (lit_count < next_literal_pool_place)
1198 /* First output the expression in the instruction to the pool */
1199 emit_expr (&(literals[lit_count++].exp), 4); /* .word */
1200
1201 next_literal_pool_place = 0;
1202 current_poolP = NULL;
1203 }
1204
1205 static void
1206 s_align (unused) /* Same as s_align_ptwo but align 0 => align 2 */
1207 int unused;
1208 {
1209 register int temp;
1210 register long temp_fill;
1211 long max_alignment = 15;
1212
1213 temp = get_absolute_expression ();
1214 if (temp > max_alignment)
1215 as_bad (_("Alignment too large: %d. assumed."), temp = max_alignment);
1216 else if (temp < 0)
1217 {
1218 as_bad (_("Alignment negative. 0 assumed."));
1219 temp = 0;
1220 }
1221
1222 if (*input_line_pointer == ',')
1223 {
1224 input_line_pointer++;
1225 temp_fill = get_absolute_expression ();
1226 }
1227 else
1228 temp_fill = 0;
1229
1230 if (!temp)
1231 temp = 2;
1232
1233 /* Only make a frag if we HAVE to. . . */
1234 if (temp && !need_pass_2)
1235 frag_align (temp, (int) temp_fill, 0);
1236 demand_empty_rest_of_line ();
1237
1238 record_alignment (now_seg, temp);
1239 }
1240
1241 static void
1242 s_force_thumb (ignore)
1243 int ignore;
1244 {
1245 /* If we are not already in thumb mode go into it, EVEN if
1246 the target processor does not support thumb instructions.
1247 This is used by gcc/config/arm/lib1funcs.asm for example
1248 to compile interworking support functions even if the
1249 target processor should not support interworking. */
1250
1251 if (! thumb_mode)
1252 {
1253 thumb_mode = 1;
1254
1255 record_alignment (now_seg, 1);
1256 }
1257
1258 demand_empty_rest_of_line ();
1259 }
1260
1261 static void
1262 s_thumb_func (ignore)
1263 int ignore;
1264 {
1265 /* The following label is the name/address of the start of a Thumb function.
1266 We need to know this for the interworking support. */
1267
1268 label_is_thumb_function_name = true;
1269
1270 demand_empty_rest_of_line ();
1271 }
1272
1273 /* Perform a .set directive, but also mark the alias as
1274 being a thumb function. */
1275
1276 static void
1277 s_thumb_set (equiv)
1278 int equiv;
1279 {
1280 /* XXX the following is a duplicate of the code for s_set() in read.c
1281 We cannot just call that code as we need to get at the symbol that
1282 is created. */
1283 register char * name;
1284 register char delim;
1285 register char * end_name;
1286 register symbolS * symbolP;
1287
1288 /*
1289 * Especial apologies for the random logic:
1290 * this just grew, and could be parsed much more simply!
1291 * Dean in haste.
1292 */
1293 name = input_line_pointer;
1294 delim = get_symbol_end ();
1295 end_name = input_line_pointer;
1296 *end_name = delim;
1297
1298 SKIP_WHITESPACE ();
1299
1300 if (*input_line_pointer != ',')
1301 {
1302 *end_name = 0;
1303 as_bad (_("Expected comma after name \"%s\""), name);
1304 *end_name = delim;
1305 ignore_rest_of_line ();
1306 return;
1307 }
1308
1309 input_line_pointer++;
1310 *end_name = 0;
1311
1312 if (name[0] == '.' && name[1] == '\0')
1313 {
1314 /* XXX - this should not happen to .thumb_set */
1315 abort ();
1316 }
1317
1318 if ((symbolP = symbol_find (name)) == NULL
1319 && (symbolP = md_undefined_symbol (name)) == NULL)
1320 {
1321 #ifndef NO_LISTING
1322 /* When doing symbol listings, play games with dummy fragments living
1323 outside the normal fragment chain to record the file and line info
1324 for this symbol. */
1325 if (listing & LISTING_SYMBOLS)
1326 {
1327 extern struct list_info_struct * listing_tail;
1328 fragS * dummy_frag = (fragS *) xmalloc (sizeof(fragS));
1329 memset (dummy_frag, 0, sizeof(fragS));
1330 dummy_frag->fr_type = rs_fill;
1331 dummy_frag->line = listing_tail;
1332 symbolP = symbol_new (name, undefined_section, 0, dummy_frag);
1333 dummy_frag->fr_symbol = symbolP;
1334 }
1335 else
1336 #endif
1337 symbolP = symbol_new (name, undefined_section, 0, &zero_address_frag);
1338
1339 #ifdef OBJ_COFF
1340 /* "set" symbols are local unless otherwise specified. */
1341 SF_SET_LOCAL (symbolP);
1342 #endif /* OBJ_COFF */
1343 } /* make a new symbol */
1344
1345 symbol_table_insert (symbolP);
1346
1347 * end_name = delim;
1348
1349 if (equiv
1350 && S_IS_DEFINED (symbolP)
1351 && S_GET_SEGMENT (symbolP) != reg_section)
1352 as_bad (_("symbol `%s' already defined"), S_GET_NAME (symbolP));
1353
1354 pseudo_set (symbolP);
1355
1356 demand_empty_rest_of_line ();
1357
1358 /* XXX Now we come to the Thumb specific bit of code. */
1359
1360 THUMB_SET_FUNC (symbolP, 1);
1361 ARM_SET_THUMB (symbolP, 1);
1362 ARM_SET_INTERWORK (symbolP, support_interwork);
1363 }
1364
1365 /* If we change section we must dump the literal pool first. */
1366 static void
1367 arm_s_text (ignore)
1368 int ignore;
1369 {
1370 if (now_seg != text_section)
1371 s_ltorg (0);
1372
1373 s_text (ignore);
1374 }
1375
1376 static void
1377 arm_s_data (ignore)
1378 int ignore;
1379 {
1380 if (flag_readonly_data_in_text)
1381 {
1382 if (now_seg != text_section)
1383 s_ltorg (0);
1384 }
1385 else if (now_seg != data_section)
1386 s_ltorg (0);
1387
1388 s_data (ignore);
1389 }
1390
1391 #ifdef OBJ_ELF
1392 static void
1393 arm_s_section (ignore)
1394 int ignore;
1395 {
1396 s_ltorg (0);
1397
1398 obj_elf_section (ignore);
1399 }
1400 #endif
1401
1402 static void
1403 opcode_select (width)
1404 int width;
1405 {
1406 switch (width)
1407 {
1408 case 16:
1409 if (! thumb_mode)
1410 {
1411 if (! (cpu_variant & ARM_THUMB))
1412 as_bad (_("selected processor does not support THUMB opcodes"));
1413 thumb_mode = 1;
1414 /* No need to force the alignment, since we will have been
1415 coming from ARM mode, which is word-aligned. */
1416 record_alignment (now_seg, 1);
1417 }
1418 break;
1419
1420 case 32:
1421 if (thumb_mode)
1422 {
1423 if ((cpu_variant & ARM_ANY) == ARM_THUMB)
1424 as_bad (_("selected processor does not support ARM opcodes"));
1425 thumb_mode = 0;
1426 if (!need_pass_2)
1427 frag_align (2, 0, 0);
1428 record_alignment (now_seg, 1);
1429 }
1430 break;
1431
1432 default:
1433 as_bad (_("invalid instruction size selected (%d)"), width);
1434 }
1435 }
1436
1437 static void
1438 s_arm (ignore)
1439 int ignore;
1440 {
1441 opcode_select (32);
1442 demand_empty_rest_of_line ();
1443 }
1444
1445 static void
1446 s_thumb (ignore)
1447 int ignore;
1448 {
1449 opcode_select (16);
1450 demand_empty_rest_of_line ();
1451 }
1452
1453 static void
1454 s_code (unused)
1455 int unused;
1456 {
1457 register int temp;
1458
1459 temp = get_absolute_expression ();
1460 switch (temp)
1461 {
1462 case 16:
1463 case 32:
1464 opcode_select (temp);
1465 break;
1466
1467 default:
1468 as_bad (_("invalid operand to .code directive (%d) (expecting 16 or 32)"), temp);
1469 }
1470 }
1471
1472 static void
1473 end_of_line (str)
1474 char * str;
1475 {
1476 skip_whitespace (str);
1477
1478 if (* str != '\0')
1479 inst.error = _("Garbage following instruction");
1480 }
1481
1482 static int
1483 skip_past_comma (str)
1484 char ** str;
1485 {
1486 char *p = *str, c;
1487 int comma = 0;
1488
1489 while ((c = *p) == ' ' || c == ',')
1490 {
1491 p++;
1492 if (c == ',' && comma++)
1493 return FAIL;
1494 }
1495
1496 if (c == '\0')
1497 return FAIL;
1498
1499 *str = p;
1500 return comma ? SUCCESS : FAIL;
1501 }
1502
1503 /* A standard register must be given at this point. Shift is the place to
1504 put it in the instruction. */
1505
1506 static int
1507 reg_required_here (str, shift)
1508 char ** str;
1509 int shift;
1510 {
1511 static char buff [128]; /* XXX */
1512 int reg;
1513 char * start = *str;
1514
1515 if ((reg = arm_reg_parse (str)) != FAIL && int_register (reg))
1516 {
1517 if (shift >= 0)
1518 inst.instruction |= reg << shift;
1519 return reg;
1520 }
1521
1522 /* Restore the start point, we may have got a reg of the wrong class. */
1523 *str = start;
1524
1525 /* In the few cases where we might be able to accept something else
1526 this error can be overridden. */
1527 sprintf (buff, _("Register expected, not '%.100s'"), start);
1528 inst.error = buff;
1529
1530 return FAIL;
1531 }
1532
1533 static int
1534 psr_required_here (str, cpsr, spsr)
1535 char ** str;
1536 int cpsr;
1537 int spsr;
1538 {
1539 int psr;
1540 char * start = *str;
1541 psr = arm_psr_parse (str);
1542
1543 if (psr == cpsr || psr == spsr)
1544 {
1545 if (psr == spsr)
1546 inst.instruction |= 1 << 22;
1547
1548 return SUCCESS;
1549 }
1550
1551 /* In the few cases where we might be able to accept something else
1552 this error can be overridden. */
1553 inst.error = _("<psr(f)> expected");
1554
1555 /* Restore the start point. */
1556 *str = start;
1557 return FAIL;
1558 }
1559
1560 static int
1561 co_proc_number (str)
1562 char ** str;
1563 {
1564 int processor, pchar;
1565
1566 skip_whitespace (* str);
1567
1568 /* The data sheet seems to imply that just a number on its own is valid
1569 here, but the RISC iX assembler seems to accept a prefix 'p'. We will
1570 accept either. */
1571 if (**str == 'p' || **str == 'P')
1572 (*str)++;
1573
1574 pchar = *(*str)++;
1575 if (pchar >= '0' && pchar <= '9')
1576 {
1577 processor = pchar - '0';
1578 if (**str >= '0' && **str <= '9')
1579 {
1580 processor = processor * 10 + *(*str)++ - '0';
1581 if (processor > 15)
1582 {
1583 inst.error = _("Illegal co-processor number");
1584 return FAIL;
1585 }
1586 }
1587 }
1588 else
1589 {
1590 inst.error = _("Bad or missing co-processor number");
1591 return FAIL;
1592 }
1593
1594 inst.instruction |= processor << 8;
1595 return SUCCESS;
1596 }
1597
1598 static int
1599 cp_opc_expr (str, where, length)
1600 char ** str;
1601 int where;
1602 int length;
1603 {
1604 expressionS expr;
1605
1606 skip_whitespace (* str);
1607
1608 memset (&expr, '\0', sizeof (expr));
1609
1610 if (my_get_expression (&expr, str))
1611 return FAIL;
1612 if (expr.X_op != O_constant)
1613 {
1614 inst.error = _("bad or missing expression");
1615 return FAIL;
1616 }
1617
1618 if ((expr.X_add_number & ((1 << length) - 1)) != expr.X_add_number)
1619 {
1620 inst.error = _("immediate co-processor expression too large");
1621 return FAIL;
1622 }
1623
1624 inst.instruction |= expr.X_add_number << where;
1625 return SUCCESS;
1626 }
1627
1628 static int
1629 cp_reg_required_here (str, where)
1630 char ** str;
1631 int where;
1632 {
1633 int reg;
1634 char * start = *str;
1635
1636 if ((reg = arm_reg_parse (str)) != FAIL && cp_register (reg))
1637 {
1638 reg &= 15;
1639 inst.instruction |= reg << where;
1640 return reg;
1641 }
1642
1643 /* In the few cases where we might be able to accept something else
1644 this error can be overridden. */
1645 inst.error = _("Co-processor register expected");
1646
1647 /* Restore the start point. */
1648 *str = start;
1649 return FAIL;
1650 }
1651
1652 static int
1653 fp_reg_required_here (str, where)
1654 char ** str;
1655 int where;
1656 {
1657 int reg;
1658 char * start = *str;
1659
1660 if ((reg = arm_reg_parse (str)) != FAIL && fp_register (reg))
1661 {
1662 reg &= 7;
1663 inst.instruction |= reg << where;
1664 return reg;
1665 }
1666
1667 /* In the few cases where we might be able to accept something else
1668 this error can be overridden. */
1669 inst.error = _("Floating point register expected");
1670
1671 /* Restore the start point. */
1672 *str = start;
1673 return FAIL;
1674 }
1675
1676 static int
1677 cp_address_offset (str)
1678 char ** str;
1679 {
1680 int offset;
1681
1682 skip_whitespace (* str);
1683
1684 if (! is_immediate_prefix (**str))
1685 {
1686 inst.error = _("immediate expression expected");
1687 return FAIL;
1688 }
1689
1690 (*str)++;
1691
1692 if (my_get_expression (& inst.reloc.exp, str))
1693 return FAIL;
1694
1695 if (inst.reloc.exp.X_op == O_constant)
1696 {
1697 offset = inst.reloc.exp.X_add_number;
1698
1699 if (offset & 3)
1700 {
1701 inst.error = _("co-processor address must be word aligned");
1702 return FAIL;
1703 }
1704
1705 if (offset > 1023 || offset < -1023)
1706 {
1707 inst.error = _("offset too large");
1708 return FAIL;
1709 }
1710
1711 if (offset >= 0)
1712 inst.instruction |= INDEX_UP;
1713 else
1714 offset = -offset;
1715
1716 inst.instruction |= offset >> 2;
1717 }
1718 else
1719 inst.reloc.type = BFD_RELOC_ARM_CP_OFF_IMM;
1720
1721 return SUCCESS;
1722 }
1723
1724 static int
1725 cp_address_required_here (str)
1726 char ** str;
1727 {
1728 char * p = * str;
1729 int pre_inc = 0;
1730 int write_back = 0;
1731
1732 if (*p == '[')
1733 {
1734 int reg;
1735
1736 p++;
1737 skip_whitespace (p);
1738
1739 if ((reg = reg_required_here (& p, 16)) == FAIL)
1740 return FAIL;
1741
1742 skip_whitespace (p);
1743
1744 if (*p == ']')
1745 {
1746 p++;
1747
1748 if (skip_past_comma (& p) == SUCCESS)
1749 {
1750 /* [Rn], #expr */
1751 write_back = WRITE_BACK;
1752
1753 if (reg == REG_PC)
1754 {
1755 inst.error = _("pc may not be used in post-increment");
1756 return FAIL;
1757 }
1758
1759 if (cp_address_offset (& p) == FAIL)
1760 return FAIL;
1761 }
1762 else
1763 pre_inc = PRE_INDEX | INDEX_UP;
1764 }
1765 else
1766 {
1767 /* '['Rn, #expr']'[!] */
1768
1769 if (skip_past_comma (& p) == FAIL)
1770 {
1771 inst.error = _("pre-indexed expression expected");
1772 return FAIL;
1773 }
1774
1775 pre_inc = PRE_INDEX;
1776
1777 if (cp_address_offset (& p) == FAIL)
1778 return FAIL;
1779
1780 skip_whitespace (p);
1781
1782 if (*p++ != ']')
1783 {
1784 inst.error = _("missing ]");
1785 return FAIL;
1786 }
1787
1788 skip_whitespace (p);
1789
1790 if (*p == '!')
1791 {
1792 if (reg == REG_PC)
1793 {
1794 inst.error = _("pc may not be used with write-back");
1795 return FAIL;
1796 }
1797
1798 p++;
1799 write_back = WRITE_BACK;
1800 }
1801 }
1802 }
1803 else
1804 {
1805 if (my_get_expression (&inst.reloc.exp, &p))
1806 return FAIL;
1807
1808 inst.reloc.type = BFD_RELOC_ARM_CP_OFF_IMM;
1809 inst.reloc.exp.X_add_number -= 8; /* PC rel adjust */
1810 inst.reloc.pc_rel = 1;
1811 inst.instruction |= (REG_PC << 16);
1812 pre_inc = PRE_INDEX;
1813 }
1814
1815 inst.instruction |= write_back | pre_inc;
1816 *str = p;
1817 return SUCCESS;
1818 }
1819
1820 static void
1821 do_nop (str, flags)
1822 char * str;
1823 unsigned long flags;
1824 {
1825 /* Do nothing really. */
1826 inst.instruction |= flags; /* This is pointless. */
1827 end_of_line (str);
1828 return;
1829 }
1830
1831 static void
1832 do_mrs (str, flags)
1833 char *str;
1834 unsigned long flags;
1835 {
1836 /* Only one syntax. */
1837 skip_whitespace (str);
1838
1839 if (reg_required_here (&str, 12) == FAIL)
1840 {
1841 inst.error = bad_args;
1842 return;
1843 }
1844
1845 if (skip_past_comma (&str) == FAIL
1846 || psr_required_here (& str, CPSR_ALL, SPSR_ALL) == FAIL)
1847 {
1848 inst.error = _("<psr> expected");
1849 return;
1850 }
1851
1852 inst.instruction |= flags;
1853 end_of_line (str);
1854 return;
1855 }
1856
1857 /* Three possible forms: "<psr>, Rm", "<psrf>, Rm", "<psrf>, #expression". */
1858 static void
1859 do_msr (str, flags)
1860 char * str;
1861 unsigned long flags;
1862 {
1863 int reg;
1864
1865 skip_whitespace (str);
1866
1867 if (psr_required_here (&str, CPSR_ALL, SPSR_ALL) == SUCCESS)
1868 {
1869 inst.instruction |= PSR_ALL;
1870
1871 /* Sytax should be "<psr>, Rm" */
1872 if (skip_past_comma (&str) == FAIL
1873 || (reg = reg_required_here (&str, 0)) == FAIL)
1874 {
1875 inst.error = bad_args;
1876 return;
1877 }
1878 }
1879 else
1880 {
1881 if (psr_required_here (& str, CPSR_FLG, SPSR_FLG) == SUCCESS)
1882 inst.instruction |= PSR_FLAGS;
1883 else if (psr_required_here (& str, CPSR_CTL, SPSR_CTL) == SUCCESS)
1884 inst.instruction |= PSR_CONTROL;
1885 else
1886 {
1887 inst.error = bad_args;
1888 return;
1889 }
1890
1891 if (skip_past_comma (&str) == FAIL)
1892 {
1893 inst.error = bad_args;
1894 return;
1895 }
1896
1897 /* Syntax could be "<psrf>, rm", "<psrf>, #expression" */
1898
1899 if ((reg = reg_required_here (& str, 0)) != FAIL)
1900 ;
1901 /* Immediate expression. */
1902 else if (is_immediate_prefix (* str))
1903 {
1904 str ++;
1905 inst.error = NULL;
1906
1907 if (my_get_expression (& inst.reloc.exp, & str))
1908 {
1909 inst.error = _("Register or shift expression expected");
1910 return;
1911 }
1912
1913 if (inst.reloc.exp.X_add_symbol)
1914 {
1915 inst.reloc.type = BFD_RELOC_ARM_IMMEDIATE;
1916 inst.reloc.pc_rel = 0;
1917 }
1918 else
1919 {
1920 unsigned value = validate_immediate (inst.reloc.exp.X_add_number);
1921 if (value == FAIL)
1922 {
1923 inst.error = _("Invalid constant");
1924 return;
1925 }
1926
1927 inst.instruction |= value;
1928 }
1929
1930 flags |= INST_IMMEDIATE;
1931 }
1932 else
1933 {
1934 inst.error = _("Error: unrecognised syntax for second argument to msr instruction");
1935 return;
1936 }
1937 }
1938
1939 inst.error = NULL;
1940 inst.instruction |= flags;
1941 end_of_line (str);
1942 return;
1943 }
1944
1945 /* Long Multiply Parser
1946 UMULL RdLo, RdHi, Rm, Rs
1947 SMULL RdLo, RdHi, Rm, Rs
1948 UMLAL RdLo, RdHi, Rm, Rs
1949 SMLAL RdLo, RdHi, Rm, Rs
1950 */
1951 static void
1952 do_mull (str, flags)
1953 char * str;
1954 unsigned long flags;
1955 {
1956 int rdlo, rdhi, rm, rs;
1957
1958 /* Only one format "rdlo, rdhi, rm, rs" */
1959 skip_whitespace (str);
1960
1961 if ((rdlo = reg_required_here (&str, 12)) == FAIL)
1962 {
1963 inst.error = bad_args;
1964 return;
1965 }
1966
1967 if (skip_past_comma (&str) == FAIL
1968 || (rdhi = reg_required_here (&str, 16)) == FAIL)
1969 {
1970 inst.error = bad_args;
1971 return;
1972 }
1973
1974 if (skip_past_comma (&str) == FAIL
1975 || (rm = reg_required_here (&str, 0)) == FAIL)
1976 {
1977 inst.error = bad_args;
1978 return;
1979 }
1980
1981 /* rdhi, rdlo and rm must all be different */
1982 if (rdlo == rdhi || rdlo == rm || rdhi == rm)
1983 as_tsktsk (_("rdhi, rdlo and rm must all be different"));
1984
1985 if (skip_past_comma (&str) == FAIL
1986 || (rs = reg_required_here (&str, 8)) == FAIL)
1987 {
1988 inst.error = bad_args;
1989 return;
1990 }
1991
1992 if (rdhi == REG_PC || rdhi == REG_PC || rdhi == REG_PC || rdhi == REG_PC)
1993 {
1994 inst.error = bad_pc;
1995 return;
1996 }
1997
1998 inst.instruction |= flags;
1999 end_of_line (str);
2000 return;
2001 }
2002
2003 static void
2004 do_mul (str, flags)
2005 char * str;
2006 unsigned long flags;
2007 {
2008 int rd, rm;
2009
2010 /* Only one format "rd, rm, rs" */
2011 skip_whitespace (str);
2012
2013 if ((rd = reg_required_here (&str, 16)) == FAIL)
2014 {
2015 inst.error = bad_args;
2016 return;
2017 }
2018
2019 if (rd == REG_PC)
2020 {
2021 inst.error = bad_pc;
2022 return;
2023 }
2024
2025 if (skip_past_comma (&str) == FAIL
2026 || (rm = reg_required_here (&str, 0)) == FAIL)
2027 {
2028 inst.error = bad_args;
2029 return;
2030 }
2031
2032 if (rm == REG_PC)
2033 {
2034 inst.error = bad_pc;
2035 return;
2036 }
2037
2038 if (rm == rd)
2039 as_tsktsk (_("rd and rm should be different in mul"));
2040
2041 if (skip_past_comma (&str) == FAIL
2042 || (rm = reg_required_here (&str, 8)) == FAIL)
2043 {
2044 inst.error = bad_args;
2045 return;
2046 }
2047
2048 if (rm == REG_PC)
2049 {
2050 inst.error = bad_pc;
2051 return;
2052 }
2053
2054 inst.instruction |= flags;
2055 end_of_line (str);
2056 return;
2057 }
2058
2059 static void
2060 do_mla (str, flags)
2061 char * str;
2062 unsigned long flags;
2063 {
2064 int rd, rm;
2065
2066 /* Only one format "rd, rm, rs, rn" */
2067 skip_whitespace (str);
2068
2069 if ((rd = reg_required_here (&str, 16)) == FAIL)
2070 {
2071 inst.error = bad_args;
2072 return;
2073 }
2074
2075 if (rd == REG_PC)
2076 {
2077 inst.error = bad_pc;
2078 return;
2079 }
2080
2081 if (skip_past_comma (&str) == FAIL
2082 || (rm = reg_required_here (&str, 0)) == FAIL)
2083 {
2084 inst.error = bad_args;
2085 return;
2086 }
2087
2088 if (rm == REG_PC)
2089 {
2090 inst.error = bad_pc;
2091 return;
2092 }
2093
2094 if (rm == rd)
2095 as_tsktsk (_("rd and rm should be different in mla"));
2096
2097 if (skip_past_comma (&str) == FAIL
2098 || (rd = reg_required_here (&str, 8)) == FAIL
2099 || skip_past_comma (&str) == FAIL
2100 || (rm = reg_required_here (&str, 12)) == FAIL)
2101 {
2102 inst.error = bad_args;
2103 return;
2104 }
2105
2106 if (rd == REG_PC || rm == REG_PC)
2107 {
2108 inst.error = bad_pc;
2109 return;
2110 }
2111
2112 inst.instruction |= flags;
2113 end_of_line (str);
2114 return;
2115 }
2116
2117 /* Returns the index into fp_values of a floating point number, or -1 if
2118 not in the table. */
2119 static int
2120 my_get_float_expression (str)
2121 char ** str;
2122 {
2123 LITTLENUM_TYPE words[MAX_LITTLENUMS];
2124 char * save_in;
2125 expressionS exp;
2126 int i;
2127 int j;
2128
2129 memset (words, 0, MAX_LITTLENUMS * sizeof (LITTLENUM_TYPE));
2130 /* Look for a raw floating point number */
2131 if ((save_in = atof_ieee (*str, 'x', words)) != NULL
2132 && (is_end_of_line [(int)(*save_in)] || *save_in == '\0'))
2133 {
2134 for (i = 0; i < NUM_FLOAT_VALS; i++)
2135 {
2136 for (j = 0; j < MAX_LITTLENUMS; j++)
2137 {
2138 if (words[j] != fp_values[i][j])
2139 break;
2140 }
2141
2142 if (j == MAX_LITTLENUMS)
2143 {
2144 *str = save_in;
2145 return i;
2146 }
2147 }
2148 }
2149
2150 /* Try and parse a more complex expression, this will probably fail
2151 unless the code uses a floating point prefix (eg "0f") */
2152 save_in = input_line_pointer;
2153 input_line_pointer = *str;
2154 if (expression (&exp) == absolute_section
2155 && exp.X_op == O_big
2156 && exp.X_add_number < 0)
2157 {
2158 /* FIXME: 5 = X_PRECISION, should be #define'd where we can use it.
2159 Ditto for 15. */
2160 if (gen_to_words (words, 5, (long)15) == 0)
2161 {
2162 for (i = 0; i < NUM_FLOAT_VALS; i++)
2163 {
2164 for (j = 0; j < MAX_LITTLENUMS; j++)
2165 {
2166 if (words[j] != fp_values[i][j])
2167 break;
2168 }
2169
2170 if (j == MAX_LITTLENUMS)
2171 {
2172 *str = input_line_pointer;
2173 input_line_pointer = save_in;
2174 return i;
2175 }
2176 }
2177 }
2178 }
2179
2180 *str = input_line_pointer;
2181 input_line_pointer = save_in;
2182 return -1;
2183 }
2184
2185 /* Return true if anything in the expression is a bignum */
2186 static int
2187 walk_no_bignums (sp)
2188 symbolS * sp;
2189 {
2190 if (symbol_get_value_expression (sp)->X_op == O_big)
2191 return 1;
2192
2193 if (symbol_get_value_expression (sp)->X_add_symbol)
2194 {
2195 return (walk_no_bignums (symbol_get_value_expression (sp)->X_add_symbol)
2196 || (symbol_get_value_expression (sp)->X_op_symbol
2197 && walk_no_bignums (symbol_get_value_expression (sp)->X_op_symbol)));
2198 }
2199
2200 return 0;
2201 }
2202
2203 static int
2204 my_get_expression (ep, str)
2205 expressionS * ep;
2206 char ** str;
2207 {
2208 char * save_in;
2209 segT seg;
2210
2211 save_in = input_line_pointer;
2212 input_line_pointer = *str;
2213 seg = expression (ep);
2214
2215 #ifdef OBJ_AOUT
2216 if (seg != absolute_section
2217 && seg != text_section
2218 && seg != data_section
2219 && seg != bss_section
2220 && seg != undefined_section)
2221 {
2222 inst.error = _("bad_segment");
2223 *str = input_line_pointer;
2224 input_line_pointer = save_in;
2225 return 1;
2226 }
2227 #endif
2228
2229 /* Get rid of any bignums now, so that we don't generate an error for which
2230 we can't establish a line number later on. Big numbers are never valid
2231 in instructions, which is where this routine is always called. */
2232 if (ep->X_op == O_big
2233 || (ep->X_add_symbol
2234 && (walk_no_bignums (ep->X_add_symbol)
2235 || (ep->X_op_symbol
2236 && walk_no_bignums (ep->X_op_symbol)))))
2237 {
2238 inst.error = _("Invalid constant");
2239 *str = input_line_pointer;
2240 input_line_pointer = save_in;
2241 return 1;
2242 }
2243
2244 *str = input_line_pointer;
2245 input_line_pointer = save_in;
2246 return 0;
2247 }
2248
2249 /* unrestrict should be one if <shift> <register> is permitted for this
2250 instruction */
2251
2252 static int
2253 decode_shift (str, unrestrict)
2254 char ** str;
2255 int unrestrict;
2256 {
2257 struct asm_shift * shft;
2258 char * p;
2259 char c;
2260
2261 skip_whitespace (* str);
2262
2263 for (p = *str; isalpha (*p); p++)
2264 ;
2265
2266 if (p == *str)
2267 {
2268 inst.error = _("Shift expression expected");
2269 return FAIL;
2270 }
2271
2272 c = *p;
2273 *p = '\0';
2274 shft = (struct asm_shift *) hash_find (arm_shift_hsh, *str);
2275 *p = c;
2276 if (shft)
2277 {
2278 if (!strncmp (*str, "rrx", 3)
2279 || !strncmp (*str, "RRX", 3))
2280 {
2281 *str = p;
2282 inst.instruction |= shft->value;
2283 return SUCCESS;
2284 }
2285
2286 skip_whitespace (p);
2287
2288 if (unrestrict && reg_required_here (&p, 8) != FAIL)
2289 {
2290 inst.instruction |= shft->value | SHIFT_BY_REG;
2291 *str = p;
2292 return SUCCESS;
2293 }
2294 else if (is_immediate_prefix (* p))
2295 {
2296 inst.error = NULL;
2297 p++;
2298 if (my_get_expression (&inst.reloc.exp, &p))
2299 return FAIL;
2300
2301 /* Validate some simple #expressions */
2302 if (inst.reloc.exp.X_op == O_constant)
2303 {
2304 unsigned num = inst.reloc.exp.X_add_number;
2305
2306 /* Reject operations greater than 32, or lsl #32 */
2307 if (num > 32 || (num == 32 && shft->value == 0))
2308 {
2309 inst.error = _("Invalid immediate shift");
2310 return FAIL;
2311 }
2312
2313 /* Shifts of zero should be converted to lsl (which is zero)*/
2314 if (num == 0)
2315 {
2316 *str = p;
2317 return SUCCESS;
2318 }
2319
2320 /* Shifts of 32 are encoded as 0, for those shifts that
2321 support it. */
2322 if (num == 32)
2323 num = 0;
2324
2325 inst.instruction |= (num << 7) | shft->value;
2326 *str = p;
2327 return SUCCESS;
2328 }
2329
2330 inst.reloc.type = BFD_RELOC_ARM_SHIFT_IMM;
2331 inst.reloc.pc_rel = 0;
2332 inst.instruction |= shft->value;
2333 *str = p;
2334 return SUCCESS;
2335 }
2336 else
2337 {
2338 inst.error = unrestrict ? _("shift requires register or #expression")
2339 : _("shift requires #expression");
2340 *str = p;
2341 return FAIL;
2342 }
2343 }
2344
2345 inst.error = _("Shift expression expected");
2346 return FAIL;
2347 }
2348
2349 /* Do those data_ops which can take a negative immediate constant */
2350 /* by altering the instuction. A bit of a hack really */
2351 /* MOV <-> MVN
2352 AND <-> BIC
2353 ADC <-> SBC
2354 by inverting the second operand, and
2355 ADD <-> SUB
2356 CMP <-> CMN
2357 by negating the second operand.
2358 */
2359 static int
2360 negate_data_op (instruction, value)
2361 unsigned long * instruction;
2362 unsigned long value;
2363 {
2364 int op, new_inst;
2365 unsigned long negated, inverted;
2366
2367 negated = validate_immediate (-value);
2368 inverted = validate_immediate (~value);
2369
2370 op = (*instruction >> DATA_OP_SHIFT) & 0xf;
2371 switch (op)
2372 {
2373 /* First negates */
2374 case OPCODE_SUB: /* ADD <-> SUB */
2375 new_inst = OPCODE_ADD;
2376 value = negated;
2377 break;
2378
2379 case OPCODE_ADD:
2380 new_inst = OPCODE_SUB;
2381 value = negated;
2382 break;
2383
2384 case OPCODE_CMP: /* CMP <-> CMN */
2385 new_inst = OPCODE_CMN;
2386 value = negated;
2387 break;
2388
2389 case OPCODE_CMN:
2390 new_inst = OPCODE_CMP;
2391 value = negated;
2392 break;
2393
2394 /* Now Inverted ops */
2395 case OPCODE_MOV: /* MOV <-> MVN */
2396 new_inst = OPCODE_MVN;
2397 value = inverted;
2398 break;
2399
2400 case OPCODE_MVN:
2401 new_inst = OPCODE_MOV;
2402 value = inverted;
2403 break;
2404
2405 case OPCODE_AND: /* AND <-> BIC */
2406 new_inst = OPCODE_BIC;
2407 value = inverted;
2408 break;
2409
2410 case OPCODE_BIC:
2411 new_inst = OPCODE_AND;
2412 value = inverted;
2413 break;
2414
2415 case OPCODE_ADC: /* ADC <-> SBC */
2416 new_inst = OPCODE_SBC;
2417 value = inverted;
2418 break;
2419
2420 case OPCODE_SBC:
2421 new_inst = OPCODE_ADC;
2422 value = inverted;
2423 break;
2424
2425 /* We cannot do anything */
2426 default:
2427 return FAIL;
2428 }
2429
2430 if (value == FAIL)
2431 return FAIL;
2432
2433 *instruction &= OPCODE_MASK;
2434 *instruction |= new_inst << DATA_OP_SHIFT;
2435 return value;
2436 }
2437
2438 static int
2439 data_op2 (str)
2440 char ** str;
2441 {
2442 int value;
2443 expressionS expr;
2444
2445 skip_whitespace (* str);
2446
2447 if (reg_required_here (str, 0) != FAIL)
2448 {
2449 if (skip_past_comma (str) == SUCCESS)
2450 /* Shift operation on register. */
2451 return decode_shift (str, NO_SHIFT_RESTRICT);
2452
2453 return SUCCESS;
2454 }
2455 else
2456 {
2457 /* Immediate expression */
2458 if (is_immediate_prefix (**str))
2459 {
2460 (*str)++;
2461 inst.error = NULL;
2462
2463 if (my_get_expression (&inst.reloc.exp, str))
2464 return FAIL;
2465
2466 if (inst.reloc.exp.X_add_symbol)
2467 {
2468 inst.reloc.type = BFD_RELOC_ARM_IMMEDIATE;
2469 inst.reloc.pc_rel = 0;
2470 }
2471 else
2472 {
2473 if (skip_past_comma (str) == SUCCESS)
2474 {
2475 /* #x, y -- ie explicit rotation by Y */
2476 if (my_get_expression (&expr, str))
2477 return FAIL;
2478
2479 if (expr.X_op != O_constant)
2480 {
2481 inst.error = _("Constant expression expected");
2482 return FAIL;
2483 }
2484
2485 /* Rotate must be a multiple of 2 */
2486 if (((unsigned) expr.X_add_number) > 30
2487 || (expr.X_add_number & 1) != 0
2488 || ((unsigned) inst.reloc.exp.X_add_number) > 255)
2489 {
2490 inst.error = _("Invalid constant");
2491 return FAIL;
2492 }
2493 inst.instruction |= INST_IMMEDIATE;
2494 inst.instruction |= inst.reloc.exp.X_add_number;
2495 inst.instruction |= expr.X_add_number << 7;
2496 return SUCCESS;
2497 }
2498
2499 /* Implicit rotation, select a suitable one */
2500 value = validate_immediate (inst.reloc.exp.X_add_number);
2501
2502 if (value == FAIL)
2503 {
2504 /* Can't be done, perhaps the code reads something like
2505 "add Rd, Rn, #-n", where "sub Rd, Rn, #n" would be ok */
2506 if ((value = negate_data_op (&inst.instruction,
2507 inst.reloc.exp.X_add_number))
2508 == FAIL)
2509 {
2510 inst.error = _("Invalid constant");
2511 return FAIL;
2512 }
2513 }
2514
2515 inst.instruction |= value;
2516 }
2517
2518 inst.instruction |= INST_IMMEDIATE;
2519 return SUCCESS;
2520 }
2521
2522 (*str)++;
2523 inst.error = _("Register or shift expression expected");
2524 return FAIL;
2525 }
2526 }
2527
2528 static int
2529 fp_op2 (str)
2530 char ** str;
2531 {
2532 skip_whitespace (* str);
2533
2534 if (fp_reg_required_here (str, 0) != FAIL)
2535 return SUCCESS;
2536 else
2537 {
2538 /* Immediate expression */
2539 if (*((*str)++) == '#')
2540 {
2541 int i;
2542
2543 inst.error = NULL;
2544
2545 skip_whitespace (* str);
2546
2547 /* First try and match exact strings, this is to guarantee that
2548 some formats will work even for cross assembly */
2549
2550 for (i = 0; fp_const[i]; i++)
2551 {
2552 if (strncmp (*str, fp_const[i], strlen (fp_const[i])) == 0)
2553 {
2554 char *start = *str;
2555
2556 *str += strlen (fp_const[i]);
2557 if (is_end_of_line[(int)**str] || **str == '\0')
2558 {
2559 inst.instruction |= i + 8;
2560 return SUCCESS;
2561 }
2562 *str = start;
2563 }
2564 }
2565
2566 /* Just because we didn't get a match doesn't mean that the
2567 constant isn't valid, just that it is in a format that we
2568 don't automatically recognize. Try parsing it with
2569 the standard expression routines. */
2570 if ((i = my_get_float_expression (str)) >= 0)
2571 {
2572 inst.instruction |= i + 8;
2573 return SUCCESS;
2574 }
2575
2576 inst.error = _("Invalid floating point immediate expression");
2577 return FAIL;
2578 }
2579 inst.error = _("Floating point register or immediate expression expected");
2580 return FAIL;
2581 }
2582 }
2583
2584 static void
2585 do_arit (str, flags)
2586 char * str;
2587 unsigned long flags;
2588 {
2589 skip_whitespace (str);
2590
2591 if (reg_required_here (&str, 12) == FAIL
2592 || skip_past_comma (&str) == FAIL
2593 || reg_required_here (&str, 16) == FAIL
2594 || skip_past_comma (&str) == FAIL
2595 || data_op2 (&str) == FAIL)
2596 {
2597 if (!inst.error)
2598 inst.error = bad_args;
2599 return;
2600 }
2601
2602 inst.instruction |= flags;
2603 end_of_line (str);
2604 return;
2605 }
2606
2607 static void
2608 do_adr (str, flags)
2609 char * str;
2610 unsigned long flags;
2611 {
2612 /* This is a pseudo-op of the form "adr rd, label" to be converted
2613 into a relative address of the form "add rd, pc, #label-.-8" */
2614
2615 skip_whitespace (str);
2616
2617 if (reg_required_here (&str, 12) == FAIL
2618 || skip_past_comma (&str) == FAIL
2619 || my_get_expression (&inst.reloc.exp, &str))
2620 {
2621 if (!inst.error)
2622 inst.error = bad_args;
2623 return;
2624 }
2625 /* Frag hacking will turn this into a sub instruction if the offset turns
2626 out to be negative. */
2627 inst.reloc.type = BFD_RELOC_ARM_IMMEDIATE;
2628 inst.reloc.exp.X_add_number -= 8; /* PC relative adjust */
2629 inst.reloc.pc_rel = 1;
2630 inst.instruction |= flags;
2631 end_of_line (str);
2632 return;
2633 }
2634
2635 static void
2636 do_adrl (str, flags)
2637 char * str;
2638 unsigned long flags;
2639 {
2640 /* This is a pseudo-op of the form "adrl rd, label" to be converted
2641 into a relative address of the form:
2642 add rd, pc, #low(label-.-8)"
2643 add rd, rd, #high(label-.-8)" */
2644
2645 skip_whitespace (str);
2646
2647 if (reg_required_here (& str, 12) == FAIL
2648 || skip_past_comma (& str) == FAIL
2649 || my_get_expression (& inst.reloc.exp, & str))
2650 {
2651 if (!inst.error)
2652 inst.error = bad_args;
2653 return;
2654 }
2655
2656 end_of_line (str);
2657
2658 /* Frag hacking will turn this into a sub instruction if the offset turns
2659 out to be negative. */
2660 inst.reloc.type = BFD_RELOC_ARM_ADRL_IMMEDIATE;
2661 inst.reloc.exp.X_add_number -= 8; /* PC relative adjust */
2662 inst.reloc.pc_rel = 1;
2663 inst.instruction |= flags;
2664 inst.size = INSN_SIZE * 2;
2665
2666 return;
2667 }
2668
2669 static void
2670 do_cmp (str, flags)
2671 char * str;
2672 unsigned long flags;
2673 {
2674 skip_whitespace (str);
2675
2676 if (reg_required_here (&str, 16) == FAIL)
2677 {
2678 if (!inst.error)
2679 inst.error = bad_args;
2680 return;
2681 }
2682
2683 if (skip_past_comma (&str) == FAIL
2684 || data_op2 (&str) == FAIL)
2685 {
2686 if (!inst.error)
2687 inst.error = bad_args;
2688 return;
2689 }
2690
2691 inst.instruction |= flags;
2692 if ((flags & 0x0000f000) == 0)
2693 inst.instruction |= CONDS_BIT;
2694
2695 end_of_line (str);
2696 return;
2697 }
2698
2699 static void
2700 do_mov (str, flags)
2701 char * str;
2702 unsigned long flags;
2703 {
2704 skip_whitespace (str);
2705
2706 if (reg_required_here (&str, 12) == FAIL)
2707 {
2708 if (!inst.error)
2709 inst.error = bad_args;
2710 return;
2711 }
2712
2713 if (skip_past_comma (&str) == FAIL
2714 || data_op2 (&str) == FAIL)
2715 {
2716 if (!inst.error)
2717 inst.error = bad_args;
2718 return;
2719 }
2720
2721 inst.instruction |= flags;
2722 end_of_line (str);
2723 return;
2724 }
2725
2726 static int
2727 ldst_extend (str, hwse)
2728 char ** str;
2729 int hwse;
2730 {
2731 int add = INDEX_UP;
2732
2733 switch (**str)
2734 {
2735 case '#':
2736 case '$':
2737 (*str)++;
2738 if (my_get_expression (& inst.reloc.exp, str))
2739 return FAIL;
2740
2741 if (inst.reloc.exp.X_op == O_constant)
2742 {
2743 int value = inst.reloc.exp.X_add_number;
2744
2745 if ((hwse && (value < -255 || value > 255))
2746 || (value < -4095 || value > 4095))
2747 {
2748 inst.error = _("address offset too large");
2749 return FAIL;
2750 }
2751
2752 if (value < 0)
2753 {
2754 value = -value;
2755 add = 0;
2756 }
2757
2758 /* Halfword and signextension instructions have the
2759 immediate value split across bits 11..8 and bits 3..0 */
2760 if (hwse)
2761 inst.instruction |= add | HWOFFSET_IMM | ((value >> 4) << 8) | (value & 0xF);
2762 else
2763 inst.instruction |= add | value;
2764 }
2765 else
2766 {
2767 if (hwse)
2768 {
2769 inst.instruction |= HWOFFSET_IMM;
2770 inst.reloc.type = BFD_RELOC_ARM_OFFSET_IMM8;
2771 }
2772 else
2773 inst.reloc.type = BFD_RELOC_ARM_OFFSET_IMM;
2774 inst.reloc.pc_rel = 0;
2775 }
2776 return SUCCESS;
2777
2778 case '-':
2779 add = 0; /* and fall through */
2780 case '+':
2781 (*str)++; /* and fall through */
2782 default:
2783 if (reg_required_here (str, 0) == FAIL)
2784 return FAIL;
2785
2786 if (hwse)
2787 inst.instruction |= add;
2788 else
2789 {
2790 inst.instruction |= add | OFFSET_REG;
2791 if (skip_past_comma (str) == SUCCESS)
2792 return decode_shift (str, SHIFT_RESTRICT);
2793 }
2794
2795 return SUCCESS;
2796 }
2797 }
2798
2799 static void
2800 do_ldst (str, flags)
2801 char * str;
2802 unsigned long flags;
2803 {
2804 int halfword = 0;
2805 int pre_inc = 0;
2806 int conflict_reg;
2807 int value;
2808
2809 /* This is not ideal, but it is the simplest way of dealing with the
2810 ARM7T halfword instructions (since they use a different
2811 encoding, but the same mnemonic): */
2812 halfword = (flags & 0x80000000) != 0;
2813 if (halfword)
2814 {
2815 /* This is actually a load/store of a halfword, or a
2816 signed-extension load */
2817 if ((cpu_variant & ARM_HALFWORD) == 0)
2818 {
2819 inst.error
2820 = _("Processor does not support halfwords or signed bytes");
2821 return;
2822 }
2823
2824 inst.instruction = (inst.instruction & COND_MASK)
2825 | (flags & ~COND_MASK);
2826
2827 flags = 0;
2828 }
2829
2830 skip_whitespace (str);
2831
2832 if ((conflict_reg = reg_required_here (& str, 12)) == FAIL)
2833 {
2834 if (!inst.error)
2835 inst.error = bad_args;
2836 return;
2837 }
2838
2839 if (skip_past_comma (& str) == FAIL)
2840 {
2841 inst.error = _("Address expected");
2842 return;
2843 }
2844
2845 if (*str == '[')
2846 {
2847 int reg;
2848
2849 str++;
2850
2851 skip_whitespace (str);
2852
2853 if ((reg = reg_required_here (&str, 16)) == FAIL)
2854 return;
2855
2856 /* Conflicts can occur on stores as well as loads. */
2857 conflict_reg = (conflict_reg == reg);
2858
2859 skip_whitespace (str);
2860
2861 if (*str == ']')
2862 {
2863 str ++;
2864
2865 if (skip_past_comma (&str) == SUCCESS)
2866 {
2867 /* [Rn],... (post inc) */
2868 if (ldst_extend (&str, halfword) == FAIL)
2869 return;
2870 if (conflict_reg)
2871 as_warn (_("%s register same as write-back base"),
2872 (inst.instruction & LOAD_BIT) ? _("destination") : _("source") );
2873 }
2874 else
2875 {
2876 /* [Rn] */
2877 if (halfword)
2878 inst.instruction |= HWOFFSET_IMM;
2879
2880 skip_whitespace (str);
2881
2882 if (*str == '!')
2883 {
2884 if (conflict_reg)
2885 as_warn (_("%s register same as write-back base"),
2886 (inst.instruction & LOAD_BIT) ? _("destination") : _("source") );
2887 str++;
2888 inst.instruction |= WRITE_BACK;
2889 }
2890
2891 flags |= INDEX_UP;
2892 if (! (flags & TRANS_BIT))
2893 pre_inc = 1;
2894 }
2895 }
2896 else
2897 {
2898 /* [Rn,...] */
2899 if (skip_past_comma (&str) == FAIL)
2900 {
2901 inst.error = _("pre-indexed expression expected");
2902 return;
2903 }
2904
2905 pre_inc = 1;
2906 if (ldst_extend (&str, halfword) == FAIL)
2907 return;
2908
2909 skip_whitespace (str);
2910
2911 if (*str++ != ']')
2912 {
2913 inst.error = _("missing ]");
2914 return;
2915 }
2916
2917 skip_whitespace (str);
2918
2919 if (*str == '!')
2920 {
2921 if (conflict_reg)
2922 as_warn (_("%s register same as write-back base"),
2923 (inst.instruction & LOAD_BIT) ? _("destination") : _("source") );
2924 str++;
2925 inst.instruction |= WRITE_BACK;
2926 }
2927 }
2928 }
2929 else if (*str == '=')
2930 {
2931 /* Parse an "ldr Rd, =expr" instruction; this is another pseudo op */
2932 str++;
2933
2934 skip_whitespace (str);
2935
2936 if (my_get_expression (&inst.reloc.exp, &str))
2937 return;
2938
2939 if (inst.reloc.exp.X_op != O_constant
2940 && inst.reloc.exp.X_op != O_symbol)
2941 {
2942 inst.error = _("Constant expression expected");
2943 return;
2944 }
2945
2946 if (inst.reloc.exp.X_op == O_constant
2947 && (value = validate_immediate(inst.reloc.exp.X_add_number)) != FAIL)
2948 {
2949 /* This can be done with a mov instruction */
2950 inst.instruction &= LITERAL_MASK;
2951 inst.instruction |= INST_IMMEDIATE | (OPCODE_MOV << DATA_OP_SHIFT);
2952 inst.instruction |= (flags & COND_MASK) | (value & 0xfff);
2953 end_of_line(str);
2954 return;
2955 }
2956 else
2957 {
2958 /* Insert into literal pool */
2959 if (add_to_lit_pool () == FAIL)
2960 {
2961 if (!inst.error)
2962 inst.error = _("literal pool insertion failed");
2963 return;
2964 }
2965
2966 /* Change the instruction exp to point to the pool */
2967 if (halfword)
2968 {
2969 inst.instruction |= HWOFFSET_IMM;
2970 inst.reloc.type = BFD_RELOC_ARM_HWLITERAL;
2971 }
2972 else
2973 inst.reloc.type = BFD_RELOC_ARM_LITERAL;
2974 inst.reloc.pc_rel = 1;
2975 inst.instruction |= (REG_PC << 16);
2976 pre_inc = 1;
2977 }
2978 }
2979 else
2980 {
2981 if (my_get_expression (&inst.reloc.exp, &str))
2982 return;
2983
2984 if (halfword)
2985 {
2986 inst.instruction |= HWOFFSET_IMM;
2987 inst.reloc.type = BFD_RELOC_ARM_OFFSET_IMM8;
2988 }
2989 else
2990 inst.reloc.type = BFD_RELOC_ARM_OFFSET_IMM;
2991 inst.reloc.exp.X_add_number -= 8; /* PC rel adjust */
2992 inst.reloc.pc_rel = 1;
2993 inst.instruction |= (REG_PC << 16);
2994 pre_inc = 1;
2995 }
2996
2997 if (pre_inc && (flags & TRANS_BIT))
2998 inst.error = _("Pre-increment instruction with translate");
2999
3000 inst.instruction |= flags | (pre_inc ? PRE_INDEX : 0);
3001 end_of_line (str);
3002 return;
3003 }
3004
3005 static long
3006 reg_list (strp)
3007 char ** strp;
3008 {
3009 char * str = *strp;
3010 long range = 0;
3011 int another_range;
3012
3013 /* We come back here if we get ranges concatenated by '+' or '|' */
3014 do
3015 {
3016 another_range = 0;
3017
3018 if (*str == '{')
3019 {
3020 int in_range = 0;
3021 int cur_reg = -1;
3022
3023 str++;
3024 do
3025 {
3026 int reg;
3027
3028 skip_whitespace (str);
3029
3030 if ((reg = reg_required_here (& str, -1)) == FAIL)
3031 return FAIL;
3032
3033 if (in_range)
3034 {
3035 int i;
3036
3037 if (reg <= cur_reg)
3038 {
3039 inst.error = _("Bad range in register list");
3040 return FAIL;
3041 }
3042
3043 for (i = cur_reg + 1; i < reg; i++)
3044 {
3045 if (range & (1 << i))
3046 as_tsktsk
3047 (_("Warning: Duplicated register (r%d) in register list"),
3048 i);
3049 else
3050 range |= 1 << i;
3051 }
3052 in_range = 0;
3053 }
3054
3055 if (range & (1 << reg))
3056 as_tsktsk (_("Warning: Duplicated register (r%d) in register list"),
3057 reg);
3058 else if (reg <= cur_reg)
3059 as_tsktsk (_("Warning: Register range not in ascending order"));
3060
3061 range |= 1 << reg;
3062 cur_reg = reg;
3063 } while (skip_past_comma (&str) != FAIL
3064 || (in_range = 1, *str++ == '-'));
3065 str--;
3066 skip_whitespace (str);
3067
3068 if (*str++ != '}')
3069 {
3070 inst.error = _("Missing `}'");
3071 return FAIL;
3072 }
3073 }
3074 else
3075 {
3076 expressionS expr;
3077
3078 if (my_get_expression (&expr, &str))
3079 return FAIL;
3080
3081 if (expr.X_op == O_constant)
3082 {
3083 if (expr.X_add_number
3084 != (expr.X_add_number & 0x0000ffff))
3085 {
3086 inst.error = _("invalid register mask");
3087 return FAIL;
3088 }
3089
3090 if ((range & expr.X_add_number) != 0)
3091 {
3092 int regno = range & expr.X_add_number;
3093
3094 regno &= -regno;
3095 regno = (1 << regno) - 1;
3096 as_tsktsk
3097 (_("Warning: Duplicated register (r%d) in register list"),
3098 regno);
3099 }
3100
3101 range |= expr.X_add_number;
3102 }
3103 else
3104 {
3105 if (inst.reloc.type != 0)
3106 {
3107 inst.error = _("expression too complex");
3108 return FAIL;
3109 }
3110
3111 memcpy (&inst.reloc.exp, &expr, sizeof (expressionS));
3112 inst.reloc.type = BFD_RELOC_ARM_MULTI;
3113 inst.reloc.pc_rel = 0;
3114 }
3115 }
3116
3117 skip_whitespace (str);
3118
3119 if (*str == '|' || *str == '+')
3120 {
3121 str++;
3122 another_range = 1;
3123 }
3124 } while (another_range);
3125
3126 *strp = str;
3127 return range;
3128 }
3129
3130 static void
3131 do_ldmstm (str, flags)
3132 char * str;
3133 unsigned long flags;
3134 {
3135 int base_reg;
3136 long range;
3137
3138 skip_whitespace (str);
3139
3140 if ((base_reg = reg_required_here (&str, 16)) == FAIL)
3141 return;
3142
3143 if (base_reg == REG_PC)
3144 {
3145 inst.error = _("r15 not allowed as base register");
3146 return;
3147 }
3148
3149 skip_whitespace (str);
3150
3151 if (*str == '!')
3152 {
3153 flags |= WRITE_BACK;
3154 str++;
3155 }
3156
3157 if (skip_past_comma (&str) == FAIL
3158 || (range = reg_list (&str)) == FAIL)
3159 {
3160 if (! inst.error)
3161 inst.error = bad_args;
3162 return;
3163 }
3164
3165 if (*str == '^')
3166 {
3167 str++;
3168 flags |= MULTI_SET_PSR;
3169 }
3170
3171 inst.instruction |= flags | range;
3172 end_of_line (str);
3173 return;
3174 }
3175
3176 static void
3177 do_swi (str, flags)
3178 char * str;
3179 unsigned long flags;
3180 {
3181 skip_whitespace (str);
3182
3183 /* Allow optional leading '#'. */
3184 if (is_immediate_prefix (*str))
3185 str++;
3186
3187 if (my_get_expression (& inst.reloc.exp, & str))
3188 return;
3189
3190 inst.reloc.type = BFD_RELOC_ARM_SWI;
3191 inst.reloc.pc_rel = 0;
3192 inst.instruction |= flags;
3193
3194 end_of_line (str);
3195
3196 return;
3197 }
3198
3199 static void
3200 do_swap (str, flags)
3201 char * str;
3202 unsigned long flags;
3203 {
3204 int reg;
3205
3206 skip_whitespace (str);
3207
3208 if ((reg = reg_required_here (&str, 12)) == FAIL)
3209 return;
3210
3211 if (reg == REG_PC)
3212 {
3213 inst.error = _("r15 not allowed in swap");
3214 return;
3215 }
3216
3217 if (skip_past_comma (&str) == FAIL
3218 || (reg = reg_required_here (&str, 0)) == FAIL)
3219 {
3220 if (!inst.error)
3221 inst.error = bad_args;
3222 return;
3223 }
3224
3225 if (reg == REG_PC)
3226 {
3227 inst.error = _("r15 not allowed in swap");
3228 return;
3229 }
3230
3231 if (skip_past_comma (&str) == FAIL
3232 || *str++ != '[')
3233 {
3234 inst.error = bad_args;
3235 return;
3236 }
3237
3238 skip_whitespace (str);
3239
3240 if ((reg = reg_required_here (&str, 16)) == FAIL)
3241 return;
3242
3243 if (reg == REG_PC)
3244 {
3245 inst.error = bad_pc;
3246 return;
3247 }
3248
3249 skip_whitespace (str);
3250
3251 if (*str++ != ']')
3252 {
3253 inst.error = _("missing ]");
3254 return;
3255 }
3256
3257 inst.instruction |= flags;
3258 end_of_line (str);
3259 return;
3260 }
3261
3262 static void
3263 do_branch (str, flags)
3264 char * str;
3265 unsigned long flags;
3266 {
3267 if (my_get_expression (&inst.reloc.exp, &str))
3268 return;
3269
3270 #ifdef OBJ_ELF
3271 {
3272 char * save_in;
3273
3274 /* ScottB: February 5, 1998 */
3275 /* Check to see of PLT32 reloc required for the instruction. */
3276
3277 /* arm_parse_reloc() works on input_line_pointer.
3278 We actually want to parse the operands to the branch instruction
3279 passed in 'str'. Save the input pointer and restore it later. */
3280 save_in = input_line_pointer;
3281 input_line_pointer = str;
3282 if (inst.reloc.exp.X_op == O_symbol
3283 && *str == '('
3284 && arm_parse_reloc () == BFD_RELOC_ARM_PLT32)
3285 {
3286 inst.reloc.type = BFD_RELOC_ARM_PLT32;
3287 inst.reloc.pc_rel = 0;
3288 /* Modify str to point to after parsed operands, otherwise
3289 end_of_line() will complain about the (PLT) left in str. */
3290 str = input_line_pointer;
3291 }
3292 else
3293 {
3294 inst.reloc.type = BFD_RELOC_ARM_PCREL_BRANCH;
3295 inst.reloc.pc_rel = 1;
3296 }
3297 input_line_pointer = save_in;
3298 }
3299 #else
3300 inst.reloc.type = BFD_RELOC_ARM_PCREL_BRANCH;
3301 inst.reloc.pc_rel = 1;
3302 #endif /* OBJ_ELF */
3303
3304 end_of_line (str);
3305 return;
3306 }
3307
3308 static void
3309 do_bx (str, flags)
3310 char * str;
3311 unsigned long flags;
3312 {
3313 int reg;
3314
3315 skip_whitespace (str);
3316
3317 if ((reg = reg_required_here (&str, 0)) == FAIL)
3318 return;
3319
3320 if (reg == REG_PC)
3321 as_tsktsk (_("Use of r15 in bx has undefined behaviour"));
3322
3323 end_of_line (str);
3324 return;
3325 }
3326
3327 static void
3328 do_cdp (str, flags)
3329 char * str;
3330 unsigned long flags;
3331 {
3332 /* Co-processor data operation.
3333 Format: CDP{cond} CP#,<expr>,CRd,CRn,CRm{,<expr>} */
3334 skip_whitespace (str);
3335
3336 if (co_proc_number (&str) == FAIL)
3337 {
3338 if (!inst.error)
3339 inst.error = bad_args;
3340 return;
3341 }
3342
3343 if (skip_past_comma (&str) == FAIL
3344 || cp_opc_expr (&str, 20,4) == FAIL)
3345 {
3346 if (!inst.error)
3347 inst.error = bad_args;
3348 return;
3349 }
3350
3351 if (skip_past_comma (&str) == FAIL
3352 || cp_reg_required_here (&str, 12) == FAIL)
3353 {
3354 if (!inst.error)
3355 inst.error = bad_args;
3356 return;
3357 }
3358
3359 if (skip_past_comma (&str) == FAIL
3360 || cp_reg_required_here (&str, 16) == FAIL)
3361 {
3362 if (!inst.error)
3363 inst.error = bad_args;
3364 return;
3365 }
3366
3367 if (skip_past_comma (&str) == FAIL
3368 || cp_reg_required_here (&str, 0) == FAIL)
3369 {
3370 if (!inst.error)
3371 inst.error = bad_args;
3372 return;
3373 }
3374
3375 if (skip_past_comma (&str) == SUCCESS)
3376 {
3377 if (cp_opc_expr (&str, 5, 3) == FAIL)
3378 {
3379 if (!inst.error)
3380 inst.error = bad_args;
3381 return;
3382 }
3383 }
3384
3385 end_of_line (str);
3386 return;
3387 }
3388
3389 static void
3390 do_lstc (str, flags)
3391 char * str;
3392 unsigned long flags;
3393 {
3394 /* Co-processor register load/store.
3395 Format: <LDC|STC{cond}[L] CP#,CRd,<address> */
3396
3397 skip_whitespace (str);
3398
3399 if (co_proc_number (&str) == FAIL)
3400 {
3401 if (!inst.error)
3402 inst.error = bad_args;
3403 return;
3404 }
3405
3406 if (skip_past_comma (&str) == FAIL
3407 || cp_reg_required_here (&str, 12) == FAIL)
3408 {
3409 if (!inst.error)
3410 inst.error = bad_args;
3411 return;
3412 }
3413
3414 if (skip_past_comma (&str) == FAIL
3415 || cp_address_required_here (&str) == FAIL)
3416 {
3417 if (! inst.error)
3418 inst.error = bad_args;
3419 return;
3420 }
3421
3422 inst.instruction |= flags;
3423 end_of_line (str);
3424 return;
3425 }
3426
3427 static void
3428 do_co_reg (str, flags)
3429 char * str;
3430 unsigned long flags;
3431 {
3432 /* Co-processor register transfer.
3433 Format: <MCR|MRC>{cond} CP#,<expr1>,Rd,CRn,CRm{,<expr2>} */
3434
3435 skip_whitespace (str);
3436
3437 if (co_proc_number (&str) == FAIL)
3438 {
3439 if (!inst.error)
3440 inst.error = bad_args;
3441 return;
3442 }
3443
3444 if (skip_past_comma (&str) == FAIL
3445 || cp_opc_expr (&str, 21, 3) == FAIL)
3446 {
3447 if (!inst.error)
3448 inst.error = bad_args;
3449 return;
3450 }
3451
3452 if (skip_past_comma (&str) == FAIL
3453 || reg_required_here (&str, 12) == FAIL)
3454 {
3455 if (!inst.error)
3456 inst.error = bad_args;
3457 return;
3458 }
3459
3460 if (skip_past_comma (&str) == FAIL
3461 || cp_reg_required_here (&str, 16) == FAIL)
3462 {
3463 if (!inst.error)
3464 inst.error = bad_args;
3465 return;
3466 }
3467
3468 if (skip_past_comma (&str) == FAIL
3469 || cp_reg_required_here (&str, 0) == FAIL)
3470 {
3471 if (!inst.error)
3472 inst.error = bad_args;
3473 return;
3474 }
3475
3476 if (skip_past_comma (&str) == SUCCESS)
3477 {
3478 if (cp_opc_expr (&str, 5, 3) == FAIL)
3479 {
3480 if (!inst.error)
3481 inst.error = bad_args;
3482 return;
3483 }
3484 }
3485
3486 end_of_line (str);
3487 return;
3488 }
3489
3490 static void
3491 do_fp_ctrl (str, flags)
3492 char * str;
3493 unsigned long flags;
3494 {
3495 /* FP control registers.
3496 Format: <WFS|RFS|WFC|RFC>{cond} Rn */
3497
3498 skip_whitespace (str);
3499
3500 if (reg_required_here (&str, 12) == FAIL)
3501 {
3502 if (!inst.error)
3503 inst.error = bad_args;
3504 return;
3505 }
3506
3507 end_of_line (str);
3508 return;
3509 }
3510
3511 static void
3512 do_fp_ldst (str, flags)
3513 char * str;
3514 unsigned long flags;
3515 {
3516 skip_whitespace (str);
3517
3518 switch (inst.suffix)
3519 {
3520 case SUFF_S:
3521 break;
3522 case SUFF_D:
3523 inst.instruction |= CP_T_X;
3524 break;
3525 case SUFF_E:
3526 inst.instruction |= CP_T_Y;
3527 break;
3528 case SUFF_P:
3529 inst.instruction |= CP_T_X | CP_T_Y;
3530 break;
3531 default:
3532 abort ();
3533 }
3534
3535 if (fp_reg_required_here (&str, 12) == FAIL)
3536 {
3537 if (!inst.error)
3538 inst.error = bad_args;
3539 return;
3540 }
3541
3542 if (skip_past_comma (&str) == FAIL
3543 || cp_address_required_here (&str) == FAIL)
3544 {
3545 if (!inst.error)
3546 inst.error = bad_args;
3547 return;
3548 }
3549
3550 end_of_line (str);
3551 }
3552
3553 static void
3554 do_fp_ldmstm (str, flags)
3555 char * str;
3556 unsigned long flags;
3557 {
3558 int num_regs;
3559
3560 skip_whitespace (str);
3561
3562 if (fp_reg_required_here (&str, 12) == FAIL)
3563 {
3564 if (! inst.error)
3565 inst.error = bad_args;
3566 return;
3567 }
3568
3569 /* Get Number of registers to transfer */
3570 if (skip_past_comma (&str) == FAIL
3571 || my_get_expression (&inst.reloc.exp, &str))
3572 {
3573 if (! inst.error)
3574 inst.error = _("constant expression expected");
3575 return;
3576 }
3577
3578 if (inst.reloc.exp.X_op != O_constant)
3579 {
3580 inst.error = _("Constant value required for number of registers");
3581 return;
3582 }
3583
3584 num_regs = inst.reloc.exp.X_add_number;
3585
3586 if (num_regs < 1 || num_regs > 4)
3587 {
3588 inst.error = _("number of registers must be in the range [1:4]");
3589 return;
3590 }
3591
3592 switch (num_regs)
3593 {
3594 case 1:
3595 inst.instruction |= CP_T_X;
3596 break;
3597 case 2:
3598 inst.instruction |= CP_T_Y;
3599 break;
3600 case 3:
3601 inst.instruction |= CP_T_Y | CP_T_X;
3602 break;
3603 case 4:
3604 break;
3605 default:
3606 abort ();
3607 }
3608
3609 if (flags)
3610 {
3611 int reg;
3612 int write_back;
3613 int offset;
3614
3615 /* The instruction specified "ea" or "fd", so we can only accept
3616 [Rn]{!}. The instruction does not really support stacking or
3617 unstacking, so we have to emulate these by setting appropriate
3618 bits and offsets. */
3619 if (skip_past_comma (&str) == FAIL
3620 || *str != '[')
3621 {
3622 if (! inst.error)
3623 inst.error = bad_args;
3624 return;
3625 }
3626
3627 str++;
3628 skip_whitespace (str);
3629
3630 if ((reg = reg_required_here (&str, 16)) == FAIL)
3631 return;
3632
3633 skip_whitespace (str);
3634
3635 if (*str != ']')
3636 {
3637 inst.error = bad_args;
3638 return;
3639 }
3640
3641 str++;
3642 if (*str == '!')
3643 {
3644 write_back = 1;
3645 str++;
3646 if (reg == REG_PC)
3647 {
3648 inst.error = _("R15 not allowed as base register with write-back");
3649 return;
3650 }
3651 }
3652 else
3653 write_back = 0;
3654
3655 if (flags & CP_T_Pre)
3656 {
3657 /* Pre-decrement */
3658 offset = 3 * num_regs;
3659 if (write_back)
3660 flags |= CP_T_WB;
3661 }
3662 else
3663 {
3664 /* Post-increment */
3665 if (write_back)
3666 {
3667 flags |= CP_T_WB;
3668 offset = 3 * num_regs;
3669 }
3670 else
3671 {
3672 /* No write-back, so convert this into a standard pre-increment
3673 instruction -- aesthetically more pleasing. */
3674 flags = CP_T_Pre | CP_T_UD;
3675 offset = 0;
3676 }
3677 }
3678
3679 inst.instruction |= flags | offset;
3680 }
3681 else if (skip_past_comma (&str) == FAIL
3682 || cp_address_required_here (&str) == FAIL)
3683 {
3684 if (! inst.error)
3685 inst.error = bad_args;
3686 return;
3687 }
3688
3689 end_of_line (str);
3690 }
3691
3692 static void
3693 do_fp_dyadic (str, flags)
3694 char * str;
3695 unsigned long flags;
3696 {
3697 skip_whitespace (str);
3698
3699 switch (inst.suffix)
3700 {
3701 case SUFF_S:
3702 break;
3703 case SUFF_D:
3704 inst.instruction |= 0x00000080;
3705 break;
3706 case SUFF_E:
3707 inst.instruction |= 0x00080000;
3708 break;
3709 default:
3710 abort ();
3711 }
3712
3713 if (fp_reg_required_here (&str, 12) == FAIL)
3714 {
3715 if (! inst.error)
3716 inst.error = bad_args;
3717 return;
3718 }
3719
3720 if (skip_past_comma (&str) == FAIL
3721 || fp_reg_required_here (&str, 16) == FAIL)
3722 {
3723 if (! inst.error)
3724 inst.error = bad_args;
3725 return;
3726 }
3727
3728 if (skip_past_comma (&str) == FAIL
3729 || fp_op2 (&str) == FAIL)
3730 {
3731 if (! inst.error)
3732 inst.error = bad_args;
3733 return;
3734 }
3735
3736 inst.instruction |= flags;
3737 end_of_line (str);
3738 return;
3739 }
3740
3741 static void
3742 do_fp_monadic (str, flags)
3743 char * str;
3744 unsigned long flags;
3745 {
3746 skip_whitespace (str);
3747
3748 switch (inst.suffix)
3749 {
3750 case SUFF_S:
3751 break;
3752 case SUFF_D:
3753 inst.instruction |= 0x00000080;
3754 break;
3755 case SUFF_E:
3756 inst.instruction |= 0x00080000;
3757 break;
3758 default:
3759 abort ();
3760 }
3761
3762 if (fp_reg_required_here (&str, 12) == FAIL)
3763 {
3764 if (! inst.error)
3765 inst.error = bad_args;
3766 return;
3767 }
3768
3769 if (skip_past_comma (&str) == FAIL
3770 || fp_op2 (&str) == FAIL)
3771 {
3772 if (! inst.error)
3773 inst.error = bad_args;
3774 return;
3775 }
3776
3777 inst.instruction |= flags;
3778 end_of_line (str);
3779 return;
3780 }
3781
3782 static void
3783 do_fp_cmp (str, flags)
3784 char * str;
3785 unsigned long flags;
3786 {
3787 skip_whitespace (str);
3788
3789 if (fp_reg_required_here (&str, 16) == FAIL)
3790 {
3791 if (! inst.error)
3792 inst.error = bad_args;
3793 return;
3794 }
3795
3796 if (skip_past_comma (&str) == FAIL
3797 || fp_op2 (&str) == FAIL)
3798 {
3799 if (! inst.error)
3800 inst.error = bad_args;
3801 return;
3802 }
3803
3804 inst.instruction |= flags;
3805 end_of_line (str);
3806 return;
3807 }
3808
3809 static void
3810 do_fp_from_reg (str, flags)
3811 char * str;
3812 unsigned long flags;
3813 {
3814 skip_whitespace (str);
3815
3816 switch (inst.suffix)
3817 {
3818 case SUFF_S:
3819 break;
3820 case SUFF_D:
3821 inst.instruction |= 0x00000080;
3822 break;
3823 case SUFF_E:
3824 inst.instruction |= 0x00080000;
3825 break;
3826 default:
3827 abort ();
3828 }
3829
3830 if (fp_reg_required_here (&str, 16) == FAIL)
3831 {
3832 if (! inst.error)
3833 inst.error = bad_args;
3834 return;
3835 }
3836
3837 if (skip_past_comma (&str) == FAIL
3838 || reg_required_here (&str, 12) == FAIL)
3839 {
3840 if (! inst.error)
3841 inst.error = bad_args;
3842 return;
3843 }
3844
3845 inst.instruction |= flags;
3846 end_of_line (str);
3847 return;
3848 }
3849
3850 static void
3851 do_fp_to_reg (str, flags)
3852 char * str;
3853 unsigned long flags;
3854 {
3855 skip_whitespace (str);
3856
3857 if (reg_required_here (&str, 12) == FAIL)
3858 return;
3859
3860 if (skip_past_comma (&str) == FAIL
3861 || fp_reg_required_here (&str, 0) == FAIL)
3862 {
3863 if (! inst.error)
3864 inst.error = bad_args;
3865 return;
3866 }
3867
3868 inst.instruction |= flags;
3869 end_of_line (str);
3870 return;
3871 }
3872
3873 /* Thumb specific routines */
3874
3875 /* Parse and validate that a register is of the right form, this saves
3876 repeated checking of this information in many similar cases.
3877 Unlike the 32-bit case we do not insert the register into the opcode
3878 here, since the position is often unknown until the full instruction
3879 has been parsed. */
3880 static int
3881 thumb_reg (strp, hi_lo)
3882 char ** strp;
3883 int hi_lo;
3884 {
3885 int reg;
3886
3887 if ((reg = reg_required_here (strp, -1)) == FAIL)
3888 return FAIL;
3889
3890 switch (hi_lo)
3891 {
3892 case THUMB_REG_LO:
3893 if (reg > 7)
3894 {
3895 inst.error = _("lo register required");
3896 return FAIL;
3897 }
3898 break;
3899
3900 case THUMB_REG_HI:
3901 if (reg < 8)
3902 {
3903 inst.error = _("hi register required");
3904 return FAIL;
3905 }
3906 break;
3907
3908 default:
3909 break;
3910 }
3911
3912 return reg;
3913 }
3914
3915 /* Parse an add or subtract instruction, SUBTRACT is non-zero if the opcode
3916 was SUB. */
3917 static void
3918 thumb_add_sub (str, subtract)
3919 char * str;
3920 int subtract;
3921 {
3922 int Rd, Rs, Rn = FAIL;
3923
3924 skip_whitespace (str);
3925
3926 if ((Rd = thumb_reg (&str, THUMB_REG_ANY)) == FAIL
3927 || skip_past_comma (&str) == FAIL)
3928 {
3929 if (! inst.error)
3930 inst.error = bad_args;
3931 return;
3932 }
3933
3934 if (is_immediate_prefix (*str))
3935 {
3936 Rs = Rd;
3937 str++;
3938 if (my_get_expression (&inst.reloc.exp, &str))
3939 return;
3940 }
3941 else
3942 {
3943 if ((Rs = thumb_reg (&str, THUMB_REG_ANY)) == FAIL)
3944 return;
3945
3946 if (skip_past_comma (&str) == FAIL)
3947 {
3948 /* Two operand format, shuffle the registers and pretend there
3949 are 3 */
3950 Rn = Rs;
3951 Rs = Rd;
3952 }
3953 else if (is_immediate_prefix (*str))
3954 {
3955 str++;
3956 if (my_get_expression (&inst.reloc.exp, &str))
3957 return;
3958 }
3959 else if ((Rn = thumb_reg (&str, THUMB_REG_ANY)) == FAIL)
3960 return;
3961 }
3962
3963 /* We now have Rd and Rs set to registers, and Rn set to a register or FAIL;
3964 for the latter case, EXPR contains the immediate that was found. */
3965 if (Rn != FAIL)
3966 {
3967 /* All register format. */
3968 if (Rd > 7 || Rs > 7 || Rn > 7)
3969 {
3970 if (Rs != Rd)
3971 {
3972 inst.error = _("dest and source1 must be the same register");
3973 return;
3974 }
3975
3976 /* Can't do this for SUB */
3977 if (subtract)
3978 {
3979 inst.error = _("subtract valid only on lo regs");
3980 return;
3981 }
3982
3983 inst.instruction = (T_OPCODE_ADD_HI
3984 | (Rd > 7 ? THUMB_H1 : 0)
3985 | (Rn > 7 ? THUMB_H2 : 0));
3986 inst.instruction |= (Rd & 7) | ((Rn & 7) << 3);
3987 }
3988 else
3989 {
3990 inst.instruction = subtract ? T_OPCODE_SUB_R3 : T_OPCODE_ADD_R3;
3991 inst.instruction |= Rd | (Rs << 3) | (Rn << 6);
3992 }
3993 }
3994 else
3995 {
3996 /* Immediate expression, now things start to get nasty. */
3997
3998 /* First deal with HI regs, only very restricted cases allowed:
3999 Adjusting SP, and using PC or SP to get an address. */
4000 if ((Rd > 7 && (Rd != REG_SP || Rs != REG_SP))
4001 || (Rs > 7 && Rs != REG_SP && Rs != REG_PC))
4002 {
4003 inst.error = _("invalid Hi register with immediate");
4004 return;
4005 }
4006
4007 if (inst.reloc.exp.X_op != O_constant)
4008 {
4009 /* Value isn't known yet, all we can do is store all the fragments
4010 we know about in the instruction and let the reloc hacking
4011 work it all out. */
4012 inst.instruction = (subtract ? 0x8000 : 0) | (Rd << 4) | Rs;
4013 inst.reloc.type = BFD_RELOC_ARM_THUMB_ADD;
4014 }
4015 else
4016 {
4017 int offset = inst.reloc.exp.X_add_number;
4018
4019 if (subtract)
4020 offset = -offset;
4021
4022 if (offset < 0)
4023 {
4024 offset = -offset;
4025 subtract = 1;
4026
4027 /* Quick check, in case offset is MIN_INT */
4028 if (offset < 0)
4029 {
4030 inst.error = _("immediate value out of range");
4031 return;
4032 }
4033 }
4034 else
4035 subtract = 0;
4036
4037 if (Rd == REG_SP)
4038 {
4039 if (offset & ~0x1fc)
4040 {
4041 inst.error = _("invalid immediate value for stack adjust");
4042 return;
4043 }
4044 inst.instruction = subtract ? T_OPCODE_SUB_ST : T_OPCODE_ADD_ST;
4045 inst.instruction |= offset >> 2;
4046 }
4047 else if (Rs == REG_PC || Rs == REG_SP)
4048 {
4049 if (subtract
4050 || (offset & ~0x3fc))
4051 {
4052 inst.error = _("invalid immediate for address calculation");
4053 return;
4054 }
4055 inst.instruction = (Rs == REG_PC ? T_OPCODE_ADD_PC
4056 : T_OPCODE_ADD_SP);
4057 inst.instruction |= (Rd << 8) | (offset >> 2);
4058 }
4059 else if (Rs == Rd)
4060 {
4061 if (offset & ~0xff)
4062 {
4063 inst.error = _("immediate value out of range");
4064 return;
4065 }
4066 inst.instruction = subtract ? T_OPCODE_SUB_I8 : T_OPCODE_ADD_I8;
4067 inst.instruction |= (Rd << 8) | offset;
4068 }
4069 else
4070 {
4071 if (offset & ~0x7)
4072 {
4073 inst.error = _("immediate value out of range");
4074 return;
4075 }
4076 inst.instruction = subtract ? T_OPCODE_SUB_I3 : T_OPCODE_ADD_I3;
4077 inst.instruction |= Rd | (Rs << 3) | (offset << 6);
4078 }
4079 }
4080 }
4081 end_of_line (str);
4082 }
4083
4084 static void
4085 thumb_shift (str, shift)
4086 char * str;
4087 int shift;
4088 {
4089 int Rd, Rs, Rn = FAIL;
4090
4091 skip_whitespace (str);
4092
4093 if ((Rd = thumb_reg (&str, THUMB_REG_LO)) == FAIL
4094 || skip_past_comma (&str) == FAIL)
4095 {
4096 if (! inst.error)
4097 inst.error = bad_args;
4098 return;
4099 }
4100
4101 if (is_immediate_prefix (*str))
4102 {
4103 /* Two operand immediate format, set Rs to Rd. */
4104 Rs = Rd;
4105 str++;
4106 if (my_get_expression (&inst.reloc.exp, &str))
4107 return;
4108 }
4109 else
4110 {
4111 if ((Rs = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
4112 return;
4113
4114 if (skip_past_comma (&str) == FAIL)
4115 {
4116 /* Two operand format, shuffle the registers and pretend there
4117 are 3 */
4118 Rn = Rs;
4119 Rs = Rd;
4120 }
4121 else if (is_immediate_prefix (*str))
4122 {
4123 str++;
4124 if (my_get_expression (&inst.reloc.exp, &str))
4125 return;
4126 }
4127 else if ((Rn = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
4128 return;
4129 }
4130
4131 /* We now have Rd and Rs set to registers, and Rn set to a register or FAIL;
4132 for the latter case, EXPR contains the immediate that was found. */
4133
4134 if (Rn != FAIL)
4135 {
4136 if (Rs != Rd)
4137 {
4138 inst.error = _("source1 and dest must be same register");
4139 return;
4140 }
4141
4142 switch (shift)
4143 {
4144 case THUMB_ASR: inst.instruction = T_OPCODE_ASR_R; break;
4145 case THUMB_LSL: inst.instruction = T_OPCODE_LSL_R; break;
4146 case THUMB_LSR: inst.instruction = T_OPCODE_LSR_R; break;
4147 }
4148
4149 inst.instruction |= Rd | (Rn << 3);
4150 }
4151 else
4152 {
4153 switch (shift)
4154 {
4155 case THUMB_ASR: inst.instruction = T_OPCODE_ASR_I; break;
4156 case THUMB_LSL: inst.instruction = T_OPCODE_LSL_I; break;
4157 case THUMB_LSR: inst.instruction = T_OPCODE_LSR_I; break;
4158 }
4159
4160 if (inst.reloc.exp.X_op != O_constant)
4161 {
4162 /* Value isn't known yet, create a dummy reloc and let reloc
4163 hacking fix it up */
4164
4165 inst.reloc.type = BFD_RELOC_ARM_THUMB_SHIFT;
4166 }
4167 else
4168 {
4169 unsigned shift_value = inst.reloc.exp.X_add_number;
4170
4171 if (shift_value > 32 || (shift_value == 32 && shift == THUMB_LSL))
4172 {
4173 inst.error = _("Invalid immediate for shift");
4174 return;
4175 }
4176
4177 /* Shifts of zero are handled by converting to LSL */
4178 if (shift_value == 0)
4179 inst.instruction = T_OPCODE_LSL_I;
4180
4181 /* Shifts of 32 are encoded as a shift of zero */
4182 if (shift_value == 32)
4183 shift_value = 0;
4184
4185 inst.instruction |= shift_value << 6;
4186 }
4187
4188 inst.instruction |= Rd | (Rs << 3);
4189 }
4190 end_of_line (str);
4191 }
4192
4193 static void
4194 thumb_mov_compare (str, move)
4195 char * str;
4196 int move;
4197 {
4198 int Rd, Rs = FAIL;
4199
4200 skip_whitespace (str);
4201
4202 if ((Rd = thumb_reg (&str, THUMB_REG_ANY)) == FAIL
4203 || skip_past_comma (&str) == FAIL)
4204 {
4205 if (! inst.error)
4206 inst.error = bad_args;
4207 return;
4208 }
4209
4210 if (is_immediate_prefix (*str))
4211 {
4212 str++;
4213 if (my_get_expression (&inst.reloc.exp, &str))
4214 return;
4215 }
4216 else if ((Rs = thumb_reg (&str, THUMB_REG_ANY)) == FAIL)
4217 return;
4218
4219 if (Rs != FAIL)
4220 {
4221 if (Rs < 8 && Rd < 8)
4222 {
4223 if (move == THUMB_MOVE)
4224 /* A move of two lowregs is encoded as ADD Rd, Rs, #0
4225 since a MOV instruction produces unpredictable results */
4226 inst.instruction = T_OPCODE_ADD_I3;
4227 else
4228 inst.instruction = T_OPCODE_CMP_LR;
4229 inst.instruction |= Rd | (Rs << 3);
4230 }
4231 else
4232 {
4233 if (move == THUMB_MOVE)
4234 inst.instruction = T_OPCODE_MOV_HR;
4235 else
4236 inst.instruction = T_OPCODE_CMP_HR;
4237
4238 if (Rd > 7)
4239 inst.instruction |= THUMB_H1;
4240
4241 if (Rs > 7)
4242 inst.instruction |= THUMB_H2;
4243
4244 inst.instruction |= (Rd & 7) | ((Rs & 7) << 3);
4245 }
4246 }
4247 else
4248 {
4249 if (Rd > 7)
4250 {
4251 inst.error = _("only lo regs allowed with immediate");
4252 return;
4253 }
4254
4255 if (move == THUMB_MOVE)
4256 inst.instruction = T_OPCODE_MOV_I8;
4257 else
4258 inst.instruction = T_OPCODE_CMP_I8;
4259
4260 inst.instruction |= Rd << 8;
4261
4262 if (inst.reloc.exp.X_op != O_constant)
4263 inst.reloc.type = BFD_RELOC_ARM_THUMB_IMM;
4264 else
4265 {
4266 unsigned value = inst.reloc.exp.X_add_number;
4267
4268 if (value > 255)
4269 {
4270 inst.error = _("invalid immediate");
4271 return;
4272 }
4273
4274 inst.instruction |= value;
4275 }
4276 }
4277
4278 end_of_line (str);
4279 }
4280
4281 static void
4282 thumb_load_store (str, load_store, size)
4283 char * str;
4284 int load_store;
4285 int size;
4286 {
4287 int Rd, Rb, Ro = FAIL;
4288
4289 skip_whitespace (str);
4290
4291 if ((Rd = thumb_reg (&str, THUMB_REG_LO)) == FAIL
4292 || skip_past_comma (&str) == FAIL)
4293 {
4294 if (! inst.error)
4295 inst.error = bad_args;
4296 return;
4297 }
4298
4299 if (*str == '[')
4300 {
4301 str++;
4302 if ((Rb = thumb_reg (&str, THUMB_REG_ANY)) == FAIL)
4303 return;
4304
4305 if (skip_past_comma (&str) != FAIL)
4306 {
4307 if (is_immediate_prefix (*str))
4308 {
4309 str++;
4310 if (my_get_expression (&inst.reloc.exp, &str))
4311 return;
4312 }
4313 else if ((Ro = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
4314 return;
4315 }
4316 else
4317 {
4318 inst.reloc.exp.X_op = O_constant;
4319 inst.reloc.exp.X_add_number = 0;
4320 }
4321
4322 if (*str != ']')
4323 {
4324 inst.error = _("expected ']'");
4325 return;
4326 }
4327 str++;
4328 }
4329 else if (*str == '=')
4330 {
4331 /* Parse an "ldr Rd, =expr" instruction; this is another pseudo op */
4332 str++;
4333
4334 skip_whitespace (str);
4335
4336 if (my_get_expression (& inst.reloc.exp, & str))
4337 return;
4338
4339 end_of_line (str);
4340
4341 if ( inst.reloc.exp.X_op != O_constant
4342 && inst.reloc.exp.X_op != O_symbol)
4343 {
4344 inst.error = "Constant expression expected";
4345 return;
4346 }
4347
4348 if (inst.reloc.exp.X_op == O_constant
4349 && ((inst.reloc.exp.X_add_number & ~0xFF) == 0))
4350 {
4351 /* This can be done with a mov instruction */
4352
4353 inst.instruction = T_OPCODE_MOV_I8 | (Rd << 8);
4354 inst.instruction |= inst.reloc.exp.X_add_number;
4355 return;
4356 }
4357
4358 /* Insert into literal pool */
4359 if (add_to_lit_pool () == FAIL)
4360 {
4361 if (!inst.error)
4362 inst.error = "literal pool insertion failed";
4363 return;
4364 }
4365
4366 inst.reloc.type = BFD_RELOC_ARM_THUMB_OFFSET;
4367 inst.reloc.pc_rel = 1;
4368 inst.instruction = T_OPCODE_LDR_PC | (Rd << 8);
4369 inst.reloc.exp.X_add_number += 4; /* Adjust ARM pipeline offset to Thumb */
4370
4371 return;
4372 }
4373 else
4374 {
4375 if (my_get_expression (&inst.reloc.exp, &str))
4376 return;
4377
4378 inst.instruction = T_OPCODE_LDR_PC | (Rd << 8);
4379 inst.reloc.pc_rel = 1;
4380 inst.reloc.exp.X_add_number -= 4; /* Pipeline offset */
4381 inst.reloc.type = BFD_RELOC_ARM_THUMB_OFFSET;
4382 end_of_line (str);
4383 return;
4384 }
4385
4386 if (Rb == REG_PC || Rb == REG_SP)
4387 {
4388 if (size != THUMB_WORD)
4389 {
4390 inst.error = _("byte or halfword not valid for base register");
4391 return;
4392 }
4393 else if (Rb == REG_PC && load_store != THUMB_LOAD)
4394 {
4395 inst.error = _("R15 based store not allowed");
4396 return;
4397 }
4398 else if (Ro != FAIL)
4399 {
4400 inst.error = _("Invalid base register for register offset");
4401 return;
4402 }
4403
4404 if (Rb == REG_PC)
4405 inst.instruction = T_OPCODE_LDR_PC;
4406 else if (load_store == THUMB_LOAD)
4407 inst.instruction = T_OPCODE_LDR_SP;
4408 else
4409 inst.instruction = T_OPCODE_STR_SP;
4410
4411 inst.instruction |= Rd << 8;
4412 if (inst.reloc.exp.X_op == O_constant)
4413 {
4414 unsigned offset = inst.reloc.exp.X_add_number;
4415
4416 if (offset & ~0x3fc)
4417 {
4418 inst.error = _("invalid offset");
4419 return;
4420 }
4421
4422 inst.instruction |= offset >> 2;
4423 }
4424 else
4425 inst.reloc.type = BFD_RELOC_ARM_THUMB_OFFSET;
4426 }
4427 else if (Rb > 7)
4428 {
4429 inst.error = _("invalid base register in load/store");
4430 return;
4431 }
4432 else if (Ro == FAIL)
4433 {
4434 /* Immediate offset */
4435 if (size == THUMB_WORD)
4436 inst.instruction = (load_store == THUMB_LOAD
4437 ? T_OPCODE_LDR_IW : T_OPCODE_STR_IW);
4438 else if (size == THUMB_HALFWORD)
4439 inst.instruction = (load_store == THUMB_LOAD
4440 ? T_OPCODE_LDR_IH : T_OPCODE_STR_IH);
4441 else
4442 inst.instruction = (load_store == THUMB_LOAD
4443 ? T_OPCODE_LDR_IB : T_OPCODE_STR_IB);
4444
4445 inst.instruction |= Rd | (Rb << 3);
4446
4447 if (inst.reloc.exp.X_op == O_constant)
4448 {
4449 unsigned offset = inst.reloc.exp.X_add_number;
4450
4451 if (offset & ~(0x1f << size))
4452 {
4453 inst.error = _("Invalid offset");
4454 return;
4455 }
4456 inst.instruction |= (offset >> size) << 6;
4457 }
4458 else
4459 inst.reloc.type = BFD_RELOC_ARM_THUMB_OFFSET;
4460 }
4461 else
4462 {
4463 /* Register offset */
4464 if (size == THUMB_WORD)
4465 inst.instruction = (load_store == THUMB_LOAD
4466 ? T_OPCODE_LDR_RW : T_OPCODE_STR_RW);
4467 else if (size == THUMB_HALFWORD)
4468 inst.instruction = (load_store == THUMB_LOAD
4469 ? T_OPCODE_LDR_RH : T_OPCODE_STR_RH);
4470 else
4471 inst.instruction = (load_store == THUMB_LOAD
4472 ? T_OPCODE_LDR_RB : T_OPCODE_STR_RB);
4473
4474 inst.instruction |= Rd | (Rb << 3) | (Ro << 6);
4475 }
4476
4477 end_of_line (str);
4478 }
4479
4480 static void
4481 do_t_nop (str)
4482 char * str;
4483 {
4484 /* Do nothing */
4485 end_of_line (str);
4486 return;
4487 }
4488
4489 /* Handle the Format 4 instructions that do not have equivalents in other
4490 formats. That is, ADC, AND, EOR, SBC, ROR, TST, NEG, CMN, ORR, MUL,
4491 BIC and MVN. */
4492 static void
4493 do_t_arit (str)
4494 char * str;
4495 {
4496 int Rd, Rs, Rn;
4497
4498 skip_whitespace (str);
4499
4500 if ((Rd = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
4501 return;
4502
4503 if (skip_past_comma (&str) == FAIL
4504 || (Rs = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
4505 {
4506 if (! inst.error)
4507 inst.error = bad_args;
4508 return;
4509 }
4510
4511 if (skip_past_comma (&str) != FAIL)
4512 {
4513 /* Three operand format not allowed for TST, CMN, NEG and MVN.
4514 (It isn't allowed for CMP either, but that isn't handled by this
4515 function.) */
4516 if (inst.instruction == T_OPCODE_TST
4517 || inst.instruction == T_OPCODE_CMN
4518 || inst.instruction == T_OPCODE_NEG
4519 || inst.instruction == T_OPCODE_MVN)
4520 {
4521 inst.error = bad_args;
4522 return;
4523 }
4524
4525 if ((Rn = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
4526 return;
4527
4528 if (Rs != Rd)
4529 {
4530 inst.error = _("dest and source1 one must be the same register");
4531 return;
4532 }
4533 Rs = Rn;
4534 }
4535
4536 if (inst.instruction == T_OPCODE_MUL
4537 && Rs == Rd)
4538 as_tsktsk (_("Rs and Rd must be different in MUL"));
4539
4540 inst.instruction |= Rd | (Rs << 3);
4541 end_of_line (str);
4542 }
4543
4544 static void
4545 do_t_add (str)
4546 char * str;
4547 {
4548 thumb_add_sub (str, 0);
4549 }
4550
4551 static void
4552 do_t_asr (str)
4553 char * str;
4554 {
4555 thumb_shift (str, THUMB_ASR);
4556 }
4557
4558 static void
4559 do_t_branch9 (str)
4560 char * str;
4561 {
4562 if (my_get_expression (&inst.reloc.exp, &str))
4563 return;
4564 inst.reloc.type = BFD_RELOC_THUMB_PCREL_BRANCH9;
4565 inst.reloc.pc_rel = 1;
4566 end_of_line (str);
4567 }
4568
4569 static void
4570 do_t_branch12 (str)
4571 char * str;
4572 {
4573 if (my_get_expression (&inst.reloc.exp, &str))
4574 return;
4575 inst.reloc.type = BFD_RELOC_THUMB_PCREL_BRANCH12;
4576 inst.reloc.pc_rel = 1;
4577 end_of_line (str);
4578 }
4579
4580 /* Find the real, Thumb encoded start of a Thumb function. */
4581
4582 static symbolS *
4583 find_real_start (symbolP)
4584 symbolS * symbolP;
4585 {
4586 char * real_start;
4587 const char * name = S_GET_NAME (symbolP);
4588 symbolS * new_target;
4589
4590 /* This definiton must agree with the one in gcc/config/arm/thumb.c */
4591 #define STUB_NAME ".real_start_of"
4592
4593 if (name == NULL)
4594 abort();
4595
4596 /* Names that start with '.' are local labels, not function entry points.
4597 The compiler may generate BL instructions to these labels because it
4598 needs to perform a branch to a far away location. */
4599 if (name[0] == '.')
4600 return symbolP;
4601
4602 real_start = malloc (strlen (name) + strlen (STUB_NAME) + 1);
4603 sprintf (real_start, "%s%s", STUB_NAME, name);
4604
4605 new_target = symbol_find (real_start);
4606
4607 if (new_target == NULL)
4608 {
4609 as_warn ("Failed to find real start of function: %s\n", name);
4610 new_target = symbolP;
4611 }
4612
4613 free (real_start);
4614
4615 return new_target;
4616 }
4617
4618
4619 static void
4620 do_t_branch23 (str)
4621 char * str;
4622 {
4623 if (my_get_expression (& inst.reloc.exp, & str))
4624 return;
4625
4626 inst.reloc.type = BFD_RELOC_THUMB_PCREL_BRANCH23;
4627 inst.reloc.pc_rel = 1;
4628 end_of_line (str);
4629
4630 /* If the destination of the branch is a defined symbol which does not have
4631 the THUMB_FUNC attribute, then we must be calling a function which has
4632 the (interfacearm) attribute. We look for the Thumb entry point to that
4633 function and change the branch to refer to that function instead. */
4634 if ( inst.reloc.exp.X_op == O_symbol
4635 && inst.reloc.exp.X_add_symbol != NULL
4636 && S_IS_DEFINED (inst.reloc.exp.X_add_symbol)
4637 && ! THUMB_IS_FUNC (inst.reloc.exp.X_add_symbol))
4638 inst.reloc.exp.X_add_symbol = find_real_start (inst.reloc.exp.X_add_symbol);
4639 }
4640
4641 static void
4642 do_t_bx (str)
4643 char * str;
4644 {
4645 int reg;
4646
4647 skip_whitespace (str);
4648
4649 if ((reg = thumb_reg (&str, THUMB_REG_ANY)) == FAIL)
4650 return;
4651
4652 /* This sets THUMB_H2 from the top bit of reg. */
4653 inst.instruction |= reg << 3;
4654
4655 /* ??? FIXME: Should add a hacky reloc here if reg is REG_PC. The reloc
4656 should cause the alignment to be checked once it is known. This is
4657 because BX PC only works if the instruction is word aligned. */
4658
4659 end_of_line (str);
4660 }
4661
4662 static void
4663 do_t_compare (str)
4664 char * str;
4665 {
4666 thumb_mov_compare (str, THUMB_COMPARE);
4667 }
4668
4669 static void
4670 do_t_ldmstm (str)
4671 char * str;
4672 {
4673 int Rb;
4674 long range;
4675
4676 skip_whitespace (str);
4677
4678 if ((Rb = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
4679 return;
4680
4681 if (*str != '!')
4682 as_warn (_("Inserted missing '!': load/store multiple always writes back base register"));
4683 else
4684 str++;
4685
4686 if (skip_past_comma (&str) == FAIL
4687 || (range = reg_list (&str)) == FAIL)
4688 {
4689 if (! inst.error)
4690 inst.error = bad_args;
4691 return;
4692 }
4693
4694 if (inst.reloc.type != BFD_RELOC_NONE)
4695 {
4696 /* This really doesn't seem worth it. */
4697 inst.reloc.type = BFD_RELOC_NONE;
4698 inst.error = _("Expression too complex");
4699 return;
4700 }
4701
4702 if (range & ~0xff)
4703 {
4704 inst.error = _("only lo-regs valid in load/store multiple");
4705 return;
4706 }
4707
4708 inst.instruction |= (Rb << 8) | range;
4709 end_of_line (str);
4710 }
4711
4712 static void
4713 do_t_ldr (str)
4714 char * str;
4715 {
4716 thumb_load_store (str, THUMB_LOAD, THUMB_WORD);
4717 }
4718
4719 static void
4720 do_t_ldrb (str)
4721 char * str;
4722 {
4723 thumb_load_store (str, THUMB_LOAD, THUMB_BYTE);
4724 }
4725
4726 static void
4727 do_t_ldrh (str)
4728 char * str;
4729 {
4730 thumb_load_store (str, THUMB_LOAD, THUMB_HALFWORD);
4731 }
4732
4733 static void
4734 do_t_lds (str)
4735 char * str;
4736 {
4737 int Rd, Rb, Ro;
4738
4739 skip_whitespace (str);
4740
4741 if ((Rd = thumb_reg (&str, THUMB_REG_LO)) == FAIL
4742 || skip_past_comma (&str) == FAIL
4743 || *str++ != '['
4744 || (Rb = thumb_reg (&str, THUMB_REG_LO)) == FAIL
4745 || skip_past_comma (&str) == FAIL
4746 || (Ro = thumb_reg (&str, THUMB_REG_LO)) == FAIL
4747 || *str++ != ']')
4748 {
4749 if (! inst.error)
4750 inst.error = _("Syntax: ldrs[b] Rd, [Rb, Ro]");
4751 return;
4752 }
4753
4754 inst.instruction |= Rd | (Rb << 3) | (Ro << 6);
4755 end_of_line (str);
4756 }
4757
4758 static void
4759 do_t_lsl (str)
4760 char * str;
4761 {
4762 thumb_shift (str, THUMB_LSL);
4763 }
4764
4765 static void
4766 do_t_lsr (str)
4767 char * str;
4768 {
4769 thumb_shift (str, THUMB_LSR);
4770 }
4771
4772 static void
4773 do_t_mov (str)
4774 char * str;
4775 {
4776 thumb_mov_compare (str, THUMB_MOVE);
4777 }
4778
4779 static void
4780 do_t_push_pop (str)
4781 char * str;
4782 {
4783 long range;
4784
4785 skip_whitespace (str);
4786
4787 if ((range = reg_list (&str)) == FAIL)
4788 {
4789 if (! inst.error)
4790 inst.error = bad_args;
4791 return;
4792 }
4793
4794 if (inst.reloc.type != BFD_RELOC_NONE)
4795 {
4796 /* This really doesn't seem worth it. */
4797 inst.reloc.type = BFD_RELOC_NONE;
4798 inst.error = _("Expression too complex");
4799 return;
4800 }
4801
4802 if (range & ~0xff)
4803 {
4804 if ((inst.instruction == T_OPCODE_PUSH
4805 && (range & ~0xff) == 1 << REG_LR)
4806 || (inst.instruction == T_OPCODE_POP
4807 && (range & ~0xff) == 1 << REG_PC))
4808 {
4809 inst.instruction |= THUMB_PP_PC_LR;
4810 range &= 0xff;
4811 }
4812 else
4813 {
4814 inst.error = _("invalid register list to push/pop instruction");
4815 return;
4816 }
4817 }
4818
4819 inst.instruction |= range;
4820 end_of_line (str);
4821 }
4822
4823 static void
4824 do_t_str (str)
4825 char * str;
4826 {
4827 thumb_load_store (str, THUMB_STORE, THUMB_WORD);
4828 }
4829
4830 static void
4831 do_t_strb (str)
4832 char * str;
4833 {
4834 thumb_load_store (str, THUMB_STORE, THUMB_BYTE);
4835 }
4836
4837 static void
4838 do_t_strh (str)
4839 char * str;
4840 {
4841 thumb_load_store (str, THUMB_STORE, THUMB_HALFWORD);
4842 }
4843
4844 static void
4845 do_t_sub (str)
4846 char * str;
4847 {
4848 thumb_add_sub (str, 1);
4849 }
4850
4851 static void
4852 do_t_swi (str)
4853 char * str;
4854 {
4855 skip_whitespace (str);
4856
4857 if (my_get_expression (&inst.reloc.exp, &str))
4858 return;
4859
4860 inst.reloc.type = BFD_RELOC_ARM_SWI;
4861 end_of_line (str);
4862 return;
4863 }
4864
4865 static void
4866 do_t_adr (str)
4867 char * str;
4868 {
4869 /* This is a pseudo-op of the form "adr rd, label" to be converted
4870 into a relative address of the form "add rd, pc, #label-.-4" */
4871 skip_whitespace (str);
4872
4873 if (reg_required_here (&str, 4) == FAIL /* Store Rd in temporary location inside instruction. */
4874 || skip_past_comma (&str) == FAIL
4875 || my_get_expression (&inst.reloc.exp, &str))
4876 {
4877 if (!inst.error)
4878 inst.error = bad_args;
4879 return;
4880 }
4881
4882 inst.reloc.type = BFD_RELOC_ARM_THUMB_ADD;
4883 inst.reloc.exp.X_add_number -= 4; /* PC relative adjust */
4884 inst.reloc.pc_rel = 1;
4885 inst.instruction |= REG_PC; /* Rd is already placed into the instruction */
4886 end_of_line (str);
4887 }
4888
4889 static void
4890 insert_reg (entry)
4891 int entry;
4892 {
4893 int len = strlen (reg_table[entry].name) + 2;
4894 char * buf = (char *) xmalloc (len);
4895 char * buf2 = (char *) xmalloc (len);
4896 int i = 0;
4897
4898 #ifdef REGISTER_PREFIX
4899 buf[i++] = REGISTER_PREFIX;
4900 #endif
4901
4902 strcpy (buf + i, reg_table[entry].name);
4903
4904 for (i = 0; buf[i]; i++)
4905 buf2[i] = islower (buf[i]) ? toupper (buf[i]) : buf[i];
4906
4907 buf2[i] = '\0';
4908
4909 hash_insert (arm_reg_hsh, buf, (PTR) &reg_table[entry]);
4910 hash_insert (arm_reg_hsh, buf2, (PTR) &reg_table[entry]);
4911 }
4912
4913 static void
4914 insert_reg_alias (str, regnum)
4915 char *str;
4916 int regnum;
4917 {
4918 struct reg_entry *new =
4919 (struct reg_entry *)xmalloc (sizeof (struct reg_entry));
4920 char *name = xmalloc (strlen (str) + 1);
4921 strcpy (name, str);
4922
4923 new->name = name;
4924 new->number = regnum;
4925
4926 hash_insert (arm_reg_hsh, name, (PTR) new);
4927 }
4928
4929 static void
4930 set_constant_flonums ()
4931 {
4932 int i;
4933
4934 for (i = 0; i < NUM_FLOAT_VALS; i++)
4935 if (atof_ieee ((char *)fp_const[i], 'x', fp_values[i]) == NULL)
4936 abort ();
4937 }
4938
4939 void
4940 md_begin ()
4941 {
4942 int i;
4943
4944 if ( (arm_ops_hsh = hash_new ()) == NULL
4945 || (arm_tops_hsh = hash_new ()) == NULL
4946 || (arm_cond_hsh = hash_new ()) == NULL
4947 || (arm_shift_hsh = hash_new ()) == NULL
4948 || (arm_reg_hsh = hash_new ()) == NULL
4949 || (arm_psr_hsh = hash_new ()) == NULL)
4950 as_fatal (_("Virtual memory exhausted"));
4951
4952 for (i = 0; i < sizeof (insns) / sizeof (struct asm_opcode); i++)
4953 hash_insert (arm_ops_hsh, insns[i].template, (PTR) (insns + i));
4954 for (i = 0; i < sizeof (tinsns) / sizeof (struct thumb_opcode); i++)
4955 hash_insert (arm_tops_hsh, tinsns[i].template, (PTR) (tinsns + i));
4956 for (i = 0; i < sizeof (conds) / sizeof (struct asm_cond); i++)
4957 hash_insert (arm_cond_hsh, conds[i].template, (PTR) (conds + i));
4958 for (i = 0; i < sizeof (shift) / sizeof (struct asm_shift); i++)
4959 hash_insert (arm_shift_hsh, shift[i].template, (PTR) (shift + i));
4960 for (i = 0; i < sizeof (psrs) / sizeof (struct asm_psr); i++)
4961 hash_insert (arm_psr_hsh, psrs[i].template, (PTR) (psrs + i));
4962
4963 for (i = 0; reg_table[i].name; i++)
4964 insert_reg (i);
4965
4966 set_constant_flonums ();
4967
4968 #if defined OBJ_COFF || defined OBJ_ELF
4969 {
4970 unsigned int flags = 0;
4971
4972 /* Set the flags in the private structure */
4973 if (uses_apcs_26) flags |= F_APCS26;
4974 if (support_interwork) flags |= F_INTERWORK;
4975 if (uses_apcs_float) flags |= F_APCS_FLOAT;
4976 if (pic_code) flags |= F_PIC;
4977 if ((cpu_variant & FPU_ALL) == FPU_NONE) flags |= F_SOFT_FLOAT;
4978
4979 bfd_set_private_flags (stdoutput, flags);
4980 }
4981 #endif
4982
4983 {
4984 unsigned mach;
4985
4986 /* Record the CPU type as well */
4987 switch (cpu_variant & ARM_CPU_MASK)
4988 {
4989 case ARM_2:
4990 mach = bfd_mach_arm_2;
4991 break;
4992
4993 case ARM_3: /* also ARM_250 */
4994 mach = bfd_mach_arm_2a;
4995 break;
4996
4997 default:
4998 case ARM_6 | ARM_3 | ARM_2: /* Actually no CPU type defined */
4999 mach = bfd_mach_arm_4;
5000 break;
5001
5002 case ARM_7: /* also ARM_6 */
5003 mach = bfd_mach_arm_3;
5004 break;
5005 }
5006
5007 /* Catch special cases. */
5008 if (cpu_variant != (FPU_DEFAULT | CPU_DEFAULT))
5009 {
5010 if (cpu_variant & (ARM_EXT_V5 & ARM_THUMB))
5011 mach = bfd_mach_arm_5T;
5012 else if (cpu_variant & ARM_EXT_V5)
5013 mach = bfd_mach_arm_5;
5014 else if (cpu_variant & ARM_THUMB)
5015 mach = bfd_mach_arm_4T;
5016 else if ((cpu_variant & ARM_ARCH_V4) == ARM_ARCH_V4)
5017 mach = bfd_mach_arm_4;
5018 else if (cpu_variant & ARM_LONGMUL)
5019 mach = bfd_mach_arm_3M;
5020 }
5021
5022 bfd_set_arch_mach (stdoutput, TARGET_ARCH, mach);
5023 }
5024 }
5025
5026 /* Turn an integer of n bytes (in val) into a stream of bytes appropriate
5027 for use in the a.out file, and stores them in the array pointed to by buf.
5028 This knows about the endian-ness of the target machine and does
5029 THE RIGHT THING, whatever it is. Possible values for n are 1 (byte)
5030 2 (short) and 4 (long) Floating numbers are put out as a series of
5031 LITTLENUMS (shorts, here at least). */
5032 void
5033 md_number_to_chars (buf, val, n)
5034 char * buf;
5035 valueT val;
5036 int n;
5037 {
5038 if (target_big_endian)
5039 number_to_chars_bigendian (buf, val, n);
5040 else
5041 number_to_chars_littleendian (buf, val, n);
5042 }
5043
5044 static valueT
5045 md_chars_to_number (buf, n)
5046 char * buf;
5047 int n;
5048 {
5049 valueT result = 0;
5050 unsigned char * where = (unsigned char *) buf;
5051
5052 if (target_big_endian)
5053 {
5054 while (n--)
5055 {
5056 result <<= 8;
5057 result |= (*where++ & 255);
5058 }
5059 }
5060 else
5061 {
5062 while (n--)
5063 {
5064 result <<= 8;
5065 result |= (where[n] & 255);
5066 }
5067 }
5068
5069 return result;
5070 }
5071
5072 /* Turn a string in input_line_pointer into a floating point constant
5073 of type TYPE, and store the appropriate bytes in *litP. The number
5074 of LITTLENUMS emitted is stored in *sizeP . An error message is
5075 returned, or NULL on OK.
5076
5077 Note that fp constants aren't represent in the normal way on the ARM.
5078 In big endian mode, things are as expected. However, in little endian
5079 mode fp constants are big-endian word-wise, and little-endian byte-wise
5080 within the words. For example, (double) 1.1 in big endian mode is
5081 the byte sequence 3f f1 99 99 99 99 99 9a, and in little endian mode is
5082 the byte sequence 99 99 f1 3f 9a 99 99 99.
5083
5084 ??? The format of 12 byte floats is uncertain according to gcc's arm.h. */
5085
5086 char *
5087 md_atof (type, litP, sizeP)
5088 char type;
5089 char * litP;
5090 int * sizeP;
5091 {
5092 int prec;
5093 LITTLENUM_TYPE words[MAX_LITTLENUMS];
5094 char *t;
5095 int i;
5096
5097 switch (type)
5098 {
5099 case 'f':
5100 case 'F':
5101 case 's':
5102 case 'S':
5103 prec = 2;
5104 break;
5105
5106 case 'd':
5107 case 'D':
5108 case 'r':
5109 case 'R':
5110 prec = 4;
5111 break;
5112
5113 case 'x':
5114 case 'X':
5115 prec = 6;
5116 break;
5117
5118 case 'p':
5119 case 'P':
5120 prec = 6;
5121 break;
5122
5123 default:
5124 *sizeP = 0;
5125 return _("Bad call to MD_ATOF()");
5126 }
5127
5128 t = atof_ieee (input_line_pointer, type, words);
5129 if (t)
5130 input_line_pointer = t;
5131 *sizeP = prec * 2;
5132
5133 if (target_big_endian)
5134 {
5135 for (i = 0; i < prec; i++)
5136 {
5137 md_number_to_chars (litP, (valueT) words[i], 2);
5138 litP += 2;
5139 }
5140 }
5141 else
5142 {
5143 /* For a 4 byte float the order of elements in `words' is 1 0. For an
5144 8 byte float the order is 1 0 3 2. */
5145 for (i = 0; i < prec; i += 2)
5146 {
5147 md_number_to_chars (litP, (valueT) words[i + 1], 2);
5148 md_number_to_chars (litP + 2, (valueT) words[i], 2);
5149 litP += 4;
5150 }
5151 }
5152
5153 return 0;
5154 }
5155
5156 /* The knowledge of the PC's pipeline offset is built into the insns themselves. */
5157 long
5158 md_pcrel_from (fixP)
5159 fixS * fixP;
5160 {
5161 if ( fixP->fx_addsy
5162 && S_GET_SEGMENT (fixP->fx_addsy) == undefined_section
5163 && fixP->fx_subsy == NULL)
5164 return 0;
5165
5166 if (fixP->fx_pcrel && (fixP->fx_r_type == BFD_RELOC_ARM_THUMB_ADD))
5167 {
5168 /* PC relative addressing on the Thumb is slightly odd
5169 as the bottom two bits of the PC are forced to zero
5170 for the calculation. */
5171 return (fixP->fx_where + fixP->fx_frag->fr_address) & ~3;
5172 }
5173
5174 return fixP->fx_where + fixP->fx_frag->fr_address;
5175 }
5176
5177 /* Round up a section size to the appropriate boundary. */
5178 valueT
5179 md_section_align (segment, size)
5180 segT segment;
5181 valueT size;
5182 {
5183 #ifdef OBJ_ELF
5184 return size;
5185 #else
5186 /* Round all sects to multiple of 4 */
5187 return (size + 3) & ~3;
5188 #endif
5189 }
5190
5191 /* Under ELF we need to default _GLOBAL_OFFSET_TABLE. Otherwise
5192 we have no need to default values of symbols. */
5193
5194 /* ARGSUSED */
5195 symbolS *
5196 md_undefined_symbol (name)
5197 char * name;
5198 {
5199 #ifdef OBJ_ELF
5200 if (name[0] == '_' && name[1] == 'G'
5201 && streq (name, GLOBAL_OFFSET_TABLE_NAME))
5202 {
5203 if (!GOT_symbol)
5204 {
5205 if (symbol_find (name))
5206 as_bad ("GOT already in the symbol table");
5207
5208 GOT_symbol = symbol_new (name, undefined_section,
5209 (valueT)0, & zero_address_frag);
5210 }
5211
5212 return GOT_symbol;
5213 }
5214 #endif
5215
5216 return 0;
5217 }
5218
5219 /* arm_reg_parse () := if it looks like a register, return its token and
5220 advance the pointer. */
5221
5222 static int
5223 arm_reg_parse (ccp)
5224 register char ** ccp;
5225 {
5226 char * start = * ccp;
5227 char c;
5228 char * p;
5229 struct reg_entry * reg;
5230
5231 #ifdef REGISTER_PREFIX
5232 if (*start != REGISTER_PREFIX)
5233 return FAIL;
5234 p = start + 1;
5235 #else
5236 p = start;
5237 #ifdef OPTIONAL_REGISTER_PREFIX
5238 if (*p == OPTIONAL_REGISTER_PREFIX)
5239 p++, start++;
5240 #endif
5241 #endif
5242 if (!isalpha (*p) || !is_name_beginner (*p))
5243 return FAIL;
5244
5245 c = *p++;
5246 while (isalpha (c) || isdigit (c) || c == '_')
5247 c = *p++;
5248
5249 *--p = 0;
5250 reg = (struct reg_entry *) hash_find (arm_reg_hsh, start);
5251 *p = c;
5252
5253 if (reg)
5254 {
5255 *ccp = p;
5256 return reg->number;
5257 }
5258
5259 return FAIL;
5260 }
5261
5262 static int
5263 arm_psr_parse (ccp)
5264 register char ** ccp;
5265 {
5266 char * start = * ccp;
5267 char c;
5268 char * p;
5269 CONST struct asm_psr * psr;
5270
5271 p = start;
5272 c = *p++;
5273 while (isalpha (c) || c == '_')
5274 c = *p++;
5275
5276 *--p = 0;
5277 psr = (CONST struct asm_psr *) hash_find (arm_psr_hsh, start);
5278 *p = c;
5279
5280 if (psr)
5281 {
5282 *ccp = p;
5283 return psr->number;
5284 }
5285
5286 return FAIL;
5287 }
5288
5289 int
5290 md_apply_fix3 (fixP, val, seg)
5291 fixS * fixP;
5292 valueT * val;
5293 segT seg;
5294 {
5295 offsetT value = * val;
5296 offsetT newval;
5297 unsigned int newimm;
5298 unsigned long temp;
5299 int sign;
5300 char * buf = fixP->fx_where + fixP->fx_frag->fr_literal;
5301 arm_fix_data * arm_data = (arm_fix_data *) fixP->tc_fix_data;
5302
5303 assert (fixP->fx_r_type < BFD_RELOC_UNUSED);
5304
5305 /* Note whether this will delete the relocation. */
5306 #if 0 /* patch from REarnshaw to JDavis (disabled for the moment, since it doesn't work fully) */
5307 if ((fixP->fx_addsy == 0 || symbol_constant_p (fixP->fx_addsy))
5308 && !fixP->fx_pcrel)
5309 #else
5310 if (fixP->fx_addsy == 0 && !fixP->fx_pcrel)
5311 #endif
5312 fixP->fx_done = 1;
5313
5314 /* If this symbol is in a different section then we need to leave it for
5315 the linker to deal with. Unfortunately, md_pcrel_from can't tell,
5316 so we have to undo it's effects here. */
5317 if (fixP->fx_pcrel)
5318 {
5319 if (fixP->fx_addsy != NULL
5320 && S_IS_DEFINED (fixP->fx_addsy)
5321 && S_GET_SEGMENT (fixP->fx_addsy) != seg)
5322 {
5323 if (target_oabi
5324 && fixP->fx_r_type == BFD_RELOC_ARM_PCREL_BRANCH)
5325 value = 0;
5326 else
5327 value += md_pcrel_from (fixP);
5328 }
5329 }
5330
5331 fixP->fx_addnumber = value; /* Remember value for emit_reloc. */
5332
5333 switch (fixP->fx_r_type)
5334 {
5335 case BFD_RELOC_ARM_IMMEDIATE:
5336 newimm = validate_immediate (value);
5337 temp = md_chars_to_number (buf, INSN_SIZE);
5338
5339 /* If the instruction will fail, see if we can fix things up by
5340 changing the opcode. */
5341 if (newimm == (unsigned int) FAIL
5342 && (newimm = negate_data_op (&temp, value)) == (unsigned int) FAIL)
5343 {
5344 as_bad_where (fixP->fx_file, fixP->fx_line,
5345 _("invalid constant (%lx) after fixup"),
5346 (unsigned long) value);
5347 break;
5348 }
5349
5350 newimm |= (temp & 0xfffff000);
5351 md_number_to_chars (buf, (valueT) newimm, INSN_SIZE);
5352 break;
5353
5354 case BFD_RELOC_ARM_ADRL_IMMEDIATE:
5355 {
5356 unsigned int highpart = 0;
5357 unsigned int newinsn = 0xe1a00000; /* nop */
5358 newimm = validate_immediate (value);
5359 temp = md_chars_to_number (buf, INSN_SIZE);
5360
5361 /* If the instruction will fail, see if we can fix things up by
5362 changing the opcode. */
5363 if (newimm == (unsigned int) FAIL
5364 && (newimm = negate_data_op (& temp, value)) == (unsigned int) FAIL)
5365 {
5366 /* No ? OK - try using two ADD instructions to generate the value. */
5367 newimm = validate_immediate_twopart (value, & highpart);
5368
5369 /* Yes - then make sure that the second instruction is also an add. */
5370 if (newimm != (unsigned int) FAIL)
5371 newinsn = temp;
5372 /* Still No ? Try using a negated value. */
5373 else if (validate_immediate_twopart (- value, & highpart) != (unsigned int) FAIL)
5374 temp = newinsn = (temp & OPCODE_MASK) | OPCODE_SUB << DATA_OP_SHIFT;
5375 /* Otherwise - give up. */
5376 else
5377 {
5378 as_bad_where (fixP->fx_file, fixP->fx_line,
5379 _("Unable to compute ADRL instructions for PC offset of 0x%x"), value);
5380 break;
5381 }
5382
5383 /* Replace the first operand in the 2nd instruction (which is the PC)
5384 with the destination register. We have already added in the PC in the
5385 first instruction and we do not want to do it again. */
5386 newinsn &= ~ 0xf0000;
5387 newinsn |= ((newinsn & 0x0f000) << 4);
5388 }
5389
5390 newimm |= (temp & 0xfffff000);
5391 md_number_to_chars (buf, (valueT) newimm, INSN_SIZE);
5392
5393 highpart |= (newinsn & 0xfffff000);
5394 md_number_to_chars (buf + INSN_SIZE, (valueT) highpart, INSN_SIZE);
5395 }
5396 break;
5397
5398 case BFD_RELOC_ARM_OFFSET_IMM:
5399 sign = value >= 0;
5400
5401 if (value < 0)
5402 value = - value;
5403
5404 if (validate_offset_imm (value, 0) == FAIL)
5405 {
5406 as_bad_where (fixP->fx_file, fixP->fx_line,
5407 _("bad immediate value for offset (%ld)"), (long) value);
5408 break;
5409 }
5410
5411 newval = md_chars_to_number (buf, INSN_SIZE);
5412 newval &= 0xff7ff000;
5413 newval |= value | (sign ? INDEX_UP : 0);
5414 md_number_to_chars (buf, newval, INSN_SIZE);
5415 break;
5416
5417 case BFD_RELOC_ARM_OFFSET_IMM8:
5418 case BFD_RELOC_ARM_HWLITERAL:
5419 sign = value >= 0;
5420
5421 if (value < 0)
5422 value = - value;
5423
5424 if (validate_offset_imm (value, 1) == FAIL)
5425 {
5426 if (fixP->fx_r_type == BFD_RELOC_ARM_HWLITERAL)
5427 as_bad_where (fixP->fx_file, fixP->fx_line,
5428 _("invalid literal constant: pool needs to be closer"));
5429 else
5430 as_bad (_("bad immediate value for half-word offset (%ld)"),
5431 (long) value);
5432 break;
5433 }
5434
5435 newval = md_chars_to_number (buf, INSN_SIZE);
5436 newval &= 0xff7ff0f0;
5437 newval |= ((value >> 4) << 8) | (value & 0xf) | (sign ? INDEX_UP : 0);
5438 md_number_to_chars (buf, newval, INSN_SIZE);
5439 break;
5440
5441 case BFD_RELOC_ARM_LITERAL:
5442 sign = value >= 0;
5443
5444 if (value < 0)
5445 value = - value;
5446
5447 if (validate_offset_imm (value, 0) == FAIL)
5448 {
5449 as_bad_where (fixP->fx_file, fixP->fx_line,
5450 _("invalid literal constant: pool needs to be closer"));
5451 break;
5452 }
5453
5454 newval = md_chars_to_number (buf, INSN_SIZE);
5455 newval &= 0xff7ff000;
5456 newval |= value | (sign ? INDEX_UP : 0);
5457 md_number_to_chars (buf, newval, INSN_SIZE);
5458 break;
5459
5460 case BFD_RELOC_ARM_SHIFT_IMM:
5461 newval = md_chars_to_number (buf, INSN_SIZE);
5462 if (((unsigned long) value) > 32
5463 || (value == 32
5464 && (((newval & 0x60) == 0) || (newval & 0x60) == 0x60)))
5465 {
5466 as_bad_where (fixP->fx_file, fixP->fx_line,
5467 _("shift expression is too large"));
5468 break;
5469 }
5470
5471 if (value == 0)
5472 newval &= ~0x60; /* Shifts of zero must be done as lsl */
5473 else if (value == 32)
5474 value = 0;
5475 newval &= 0xfffff07f;
5476 newval |= (value & 0x1f) << 7;
5477 md_number_to_chars (buf, newval , INSN_SIZE);
5478 break;
5479
5480 case BFD_RELOC_ARM_SWI:
5481 if (arm_data->thumb_mode)
5482 {
5483 if (((unsigned long) value) > 0xff)
5484 as_bad_where (fixP->fx_file, fixP->fx_line,
5485 _("Invalid swi expression"));
5486 newval = md_chars_to_number (buf, THUMB_SIZE) & 0xff00;
5487 newval |= value;
5488 md_number_to_chars (buf, newval, THUMB_SIZE);
5489 }
5490 else
5491 {
5492 if (((unsigned long) value) > 0x00ffffff)
5493 as_bad_where (fixP->fx_file, fixP->fx_line,
5494 _("Invalid swi expression"));
5495 newval = md_chars_to_number (buf, INSN_SIZE) & 0xff000000;
5496 newval |= value;
5497 md_number_to_chars (buf, newval , INSN_SIZE);
5498 }
5499 break;
5500
5501 case BFD_RELOC_ARM_MULTI:
5502 if (((unsigned long) value) > 0xffff)
5503 as_bad_where (fixP->fx_file, fixP->fx_line,
5504 _("Invalid expression in load/store multiple"));
5505 newval = value | md_chars_to_number (buf, INSN_SIZE);
5506 md_number_to_chars (buf, newval, INSN_SIZE);
5507 break;
5508
5509 case BFD_RELOC_ARM_PCREL_BRANCH:
5510 newval = md_chars_to_number (buf, INSN_SIZE);
5511
5512 #ifdef OBJ_ELF
5513 if (! target_oabi)
5514 value = fixP->fx_offset;
5515 #endif
5516 value = (value >> 2) & 0x00ffffff;
5517 value = (value + (newval & 0x00ffffff)) & 0x00ffffff;
5518 newval = value | (newval & 0xff000000);
5519 md_number_to_chars (buf, newval, INSN_SIZE);
5520 break;
5521
5522 case BFD_RELOC_THUMB_PCREL_BRANCH9: /* conditional branch */
5523 newval = md_chars_to_number (buf, THUMB_SIZE);
5524 {
5525 addressT diff = (newval & 0xff) << 1;
5526 if (diff & 0x100)
5527 diff |= ~0xff;
5528
5529 value += diff;
5530 if ((value & ~0xff) && ((value & ~0xff) != ~0xff))
5531 as_bad_where (fixP->fx_file, fixP->fx_line,
5532 _("Branch out of range"));
5533 newval = (newval & 0xff00) | ((value & 0x1ff) >> 1);
5534 }
5535 md_number_to_chars (buf, newval, THUMB_SIZE);
5536 break;
5537
5538 case BFD_RELOC_THUMB_PCREL_BRANCH12: /* unconditional branch */
5539 newval = md_chars_to_number (buf, THUMB_SIZE);
5540 {
5541 addressT diff = (newval & 0x7ff) << 1;
5542 if (diff & 0x800)
5543 diff |= ~0x7ff;
5544
5545 value += diff;
5546 if ((value & ~0x7ff) && ((value & ~0x7ff) != ~0x7ff))
5547 as_bad_where (fixP->fx_file, fixP->fx_line,
5548 _("Branch out of range"));
5549 newval = (newval & 0xf800) | ((value & 0xfff) >> 1);
5550 }
5551 md_number_to_chars (buf, newval, THUMB_SIZE);
5552 break;
5553
5554 case BFD_RELOC_THUMB_PCREL_BRANCH23:
5555 {
5556 offsetT newval2;
5557 addressT diff;
5558
5559 newval = md_chars_to_number (buf, THUMB_SIZE);
5560 newval2 = md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
5561 diff = ((newval & 0x7ff) << 12) | ((newval2 & 0x7ff) << 1);
5562 if (diff & 0x400000)
5563 diff |= ~0x3fffff;
5564 #ifdef OBJ_ELF
5565 value = fixP->fx_offset;
5566 #endif
5567 value += diff;
5568 if ((value & ~0x3fffff) && ((value & ~0x3fffff) != ~0x3fffff))
5569 as_bad_where (fixP->fx_file, fixP->fx_line,
5570 _("Branch with link out of range"));
5571
5572 newval = (newval & 0xf800) | ((value & 0x7fffff) >> 12);
5573 newval2 = (newval2 & 0xf800) | ((value & 0xfff) >> 1);
5574 md_number_to_chars (buf, newval, THUMB_SIZE);
5575 md_number_to_chars (buf + THUMB_SIZE, newval2, THUMB_SIZE);
5576 }
5577 break;
5578
5579 case BFD_RELOC_8:
5580 if (fixP->fx_done || fixP->fx_pcrel)
5581 md_number_to_chars (buf, value, 1);
5582 #ifdef OBJ_ELF
5583 else if (!target_oabi)
5584 {
5585 value = fixP->fx_offset;
5586 md_number_to_chars (buf, value, 1);
5587 }
5588 #endif
5589 break;
5590
5591 case BFD_RELOC_16:
5592 if (fixP->fx_done || fixP->fx_pcrel)
5593 md_number_to_chars (buf, value, 2);
5594 #ifdef OBJ_ELF
5595 else if (!target_oabi)
5596 {
5597 value = fixP->fx_offset;
5598 md_number_to_chars (buf, value, 2);
5599 }
5600 #endif
5601 break;
5602
5603 #ifdef OBJ_ELF
5604 case BFD_RELOC_ARM_GOT32:
5605 case BFD_RELOC_ARM_GOTOFF:
5606 md_number_to_chars (buf, 0, 4);
5607 break;
5608 #endif
5609
5610 case BFD_RELOC_RVA:
5611 case BFD_RELOC_32:
5612 if (fixP->fx_done || fixP->fx_pcrel)
5613 md_number_to_chars (buf, value, 4);
5614 #ifdef OBJ_ELF
5615 else if (!target_oabi)
5616 {
5617 value = fixP->fx_offset;
5618 md_number_to_chars (buf, value, 4);
5619 }
5620 #endif
5621 break;
5622
5623 #ifdef OBJ_ELF
5624 case BFD_RELOC_ARM_PLT32:
5625 /* It appears the instruction is fully prepared at this point. */
5626 break;
5627 #endif
5628
5629 case BFD_RELOC_ARM_GOTPC:
5630 md_number_to_chars (buf, value, 4);
5631 break;
5632
5633 case BFD_RELOC_ARM_CP_OFF_IMM:
5634 sign = value >= 0;
5635 if (value < -1023 || value > 1023 || (value & 3))
5636 as_bad_where (fixP->fx_file, fixP->fx_line,
5637 _("Illegal value for co-processor offset"));
5638 if (value < 0)
5639 value = -value;
5640 newval = md_chars_to_number (buf, INSN_SIZE) & 0xff7fff00;
5641 newval |= (value >> 2) | (sign ? INDEX_UP : 0);
5642 md_number_to_chars (buf, newval , INSN_SIZE);
5643 break;
5644
5645 case BFD_RELOC_ARM_THUMB_OFFSET:
5646 newval = md_chars_to_number (buf, THUMB_SIZE);
5647 /* Exactly what ranges, and where the offset is inserted depends on
5648 the type of instruction, we can establish this from the top 4 bits */
5649 switch (newval >> 12)
5650 {
5651 case 4: /* PC load */
5652 /* Thumb PC loads are somewhat odd, bit 1 of the PC is
5653 forced to zero for these loads, so we will need to round
5654 up the offset if the instruction address is not word
5655 aligned (since the final address produced must be, and
5656 we can only describe word-aligned immediate offsets). */
5657
5658 if ((fixP->fx_frag->fr_address + fixP->fx_where + value) & 3)
5659 as_bad_where (fixP->fx_file, fixP->fx_line,
5660 _("Invalid offset, target not word aligned (0x%08X)"),
5661 (unsigned int)(fixP->fx_frag->fr_address + fixP->fx_where + value));
5662
5663 if ((value + 2) & ~0x3fe)
5664 as_bad_where (fixP->fx_file, fixP->fx_line,
5665 _("Invalid offset, value too big (0x%08X)"), value);
5666
5667 /* Round up, since pc will be rounded down. */
5668 newval |= (value + 2) >> 2;
5669 break;
5670
5671 case 9: /* SP load/store */
5672 if (value & ~0x3fc)
5673 as_bad_where (fixP->fx_file, fixP->fx_line,
5674 _("Invalid offset, value too big (0x%08X)"), value);
5675 newval |= value >> 2;
5676 break;
5677
5678 case 6: /* Word load/store */
5679 if (value & ~0x7c)
5680 as_bad_where (fixP->fx_file, fixP->fx_line,
5681 _("Invalid offset, value too big (0x%08X)"), value);
5682 newval |= value << 4; /* 6 - 2 */
5683 break;
5684
5685 case 7: /* Byte load/store */
5686 if (value & ~0x1f)
5687 as_bad_where (fixP->fx_file, fixP->fx_line,
5688 _("Invalid offset, value too big (0x%08X)"), value);
5689 newval |= value << 6;
5690 break;
5691
5692 case 8: /* Halfword load/store */
5693 if (value & ~0x3e)
5694 as_bad_where (fixP->fx_file, fixP->fx_line,
5695 _("Invalid offset, value too big (0x%08X)"), value);
5696 newval |= value << 5; /* 6 - 1 */
5697 break;
5698
5699 default:
5700 as_bad_where (fixP->fx_file, fixP->fx_line,
5701 "Unable to process relocation for thumb opcode: %lx",
5702 (unsigned long) newval);
5703 break;
5704 }
5705 md_number_to_chars (buf, newval, THUMB_SIZE);
5706 break;
5707
5708 case BFD_RELOC_ARM_THUMB_ADD:
5709 /* This is a complicated relocation, since we use it for all of
5710 the following immediate relocations:
5711 3bit ADD/SUB
5712 8bit ADD/SUB
5713 9bit ADD/SUB SP word-aligned
5714 10bit ADD PC/SP word-aligned
5715
5716 The type of instruction being processed is encoded in the
5717 instruction field:
5718 0x8000 SUB
5719 0x00F0 Rd
5720 0x000F Rs
5721 */
5722 newval = md_chars_to_number (buf, THUMB_SIZE);
5723 {
5724 int rd = (newval >> 4) & 0xf;
5725 int rs = newval & 0xf;
5726 int subtract = newval & 0x8000;
5727
5728 if (rd == REG_SP)
5729 {
5730 if (value & ~0x1fc)
5731 as_bad_where (fixP->fx_file, fixP->fx_line,
5732 _("Invalid immediate for stack address calculation"));
5733 newval = subtract ? T_OPCODE_SUB_ST : T_OPCODE_ADD_ST;
5734 newval |= value >> 2;
5735 }
5736 else if (rs == REG_PC || rs == REG_SP)
5737 {
5738 if (subtract ||
5739 value & ~0x3fc)
5740 as_bad_where (fixP->fx_file, fixP->fx_line,
5741 _("Invalid immediate for address calculation (value = 0x%08lX)"),
5742 (unsigned long) value);
5743 newval = (rs == REG_PC ? T_OPCODE_ADD_PC : T_OPCODE_ADD_SP);
5744 newval |= rd << 8;
5745 newval |= value >> 2;
5746 }
5747 else if (rs == rd)
5748 {
5749 if (value & ~0xff)
5750 as_bad_where (fixP->fx_file, fixP->fx_line,
5751 _("Invalid 8bit immediate"));
5752 newval = subtract ? T_OPCODE_SUB_I8 : T_OPCODE_ADD_I8;
5753 newval |= (rd << 8) | value;
5754 }
5755 else
5756 {
5757 if (value & ~0x7)
5758 as_bad_where (fixP->fx_file, fixP->fx_line,
5759 _("Invalid 3bit immediate"));
5760 newval = subtract ? T_OPCODE_SUB_I3 : T_OPCODE_ADD_I3;
5761 newval |= rd | (rs << 3) | (value << 6);
5762 }
5763 }
5764 md_number_to_chars (buf, newval , THUMB_SIZE);
5765 break;
5766
5767 case BFD_RELOC_ARM_THUMB_IMM:
5768 newval = md_chars_to_number (buf, THUMB_SIZE);
5769 switch (newval >> 11)
5770 {
5771 case 0x04: /* 8bit immediate MOV */
5772 case 0x05: /* 8bit immediate CMP */
5773 if (value < 0 || value > 255)
5774 as_bad_where (fixP->fx_file, fixP->fx_line,
5775 _("Invalid immediate: %ld is too large"),
5776 (long) value);
5777 newval |= value;
5778 break;
5779
5780 default:
5781 abort ();
5782 }
5783 md_number_to_chars (buf, newval , THUMB_SIZE);
5784 break;
5785
5786 case BFD_RELOC_ARM_THUMB_SHIFT:
5787 /* 5bit shift value (0..31) */
5788 if (value < 0 || value > 31)
5789 as_bad_where (fixP->fx_file, fixP->fx_line,
5790 _("Illegal Thumb shift value: %ld"), (long) value);
5791 newval = md_chars_to_number (buf, THUMB_SIZE) & 0xf03f;
5792 newval |= value << 6;
5793 md_number_to_chars (buf, newval , THUMB_SIZE);
5794 break;
5795
5796 case BFD_RELOC_VTABLE_INHERIT:
5797 case BFD_RELOC_VTABLE_ENTRY:
5798 fixP->fx_done = 0;
5799 return 1;
5800
5801 case BFD_RELOC_NONE:
5802 default:
5803 as_bad_where (fixP->fx_file, fixP->fx_line,
5804 _("Bad relocation fixup type (%d)"), fixP->fx_r_type);
5805 }
5806
5807 return 1;
5808 }
5809
5810 /* Translate internal representation of relocation info to BFD target
5811 format. */
5812 arelent *
5813 tc_gen_reloc (section, fixp)
5814 asection * section;
5815 fixS * fixp;
5816 {
5817 arelent * reloc;
5818 bfd_reloc_code_real_type code;
5819
5820 reloc = (arelent *) xmalloc (sizeof (arelent));
5821
5822 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
5823 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
5824 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
5825
5826 /* @@ Why fx_addnumber sometimes and fx_offset other times? */
5827 #ifndef OBJ_ELF
5828 if (fixp->fx_pcrel == 0)
5829 reloc->addend = fixp->fx_offset;
5830 else
5831 reloc->addend = fixp->fx_offset = reloc->address;
5832 #else /* OBJ_ELF */
5833 reloc->addend = fixp->fx_offset;
5834 #endif
5835
5836 switch (fixp->fx_r_type)
5837 {
5838 case BFD_RELOC_8:
5839 if (fixp->fx_pcrel)
5840 {
5841 code = BFD_RELOC_8_PCREL;
5842 break;
5843 }
5844
5845 case BFD_RELOC_16:
5846 if (fixp->fx_pcrel)
5847 {
5848 code = BFD_RELOC_16_PCREL;
5849 break;
5850 }
5851
5852 case BFD_RELOC_32:
5853 if (fixp->fx_pcrel)
5854 {
5855 code = BFD_RELOC_32_PCREL;
5856 break;
5857 }
5858
5859 case BFD_RELOC_ARM_PCREL_BRANCH:
5860 case BFD_RELOC_RVA:
5861 case BFD_RELOC_THUMB_PCREL_BRANCH9:
5862 case BFD_RELOC_THUMB_PCREL_BRANCH12:
5863 case BFD_RELOC_THUMB_PCREL_BRANCH23:
5864 case BFD_RELOC_VTABLE_ENTRY:
5865 case BFD_RELOC_VTABLE_INHERIT:
5866 code = fixp->fx_r_type;
5867 break;
5868
5869 case BFD_RELOC_ARM_LITERAL:
5870 case BFD_RELOC_ARM_HWLITERAL:
5871 /* If this is called then the a literal has been referenced across
5872 a section boundary - possibly due to an implicit dump */
5873 as_bad_where (fixp->fx_file, fixp->fx_line,
5874 _("Literal referenced across section boundary (Implicit dump?)"));
5875 return NULL;
5876
5877 #ifdef OBJ_ELF
5878 case BFD_RELOC_ARM_GOT32:
5879 case BFD_RELOC_ARM_GOTOFF:
5880 case BFD_RELOC_ARM_PLT32:
5881 code = fixp->fx_r_type;
5882 break;
5883 #endif
5884
5885 case BFD_RELOC_ARM_IMMEDIATE:
5886 as_bad_where (fixp->fx_file, fixp->fx_line,
5887 _("Internal_relocation (type %d) not fixed up (IMMEDIATE)"),
5888 fixp->fx_r_type);
5889 return NULL;
5890
5891 case BFD_RELOC_ARM_ADRL_IMMEDIATE:
5892 as_bad_where (fixp->fx_file, fixp->fx_line,
5893 _("ADRL used for a symbol not defined in the same file"),
5894 fixp->fx_r_type);
5895 return NULL;
5896
5897 case BFD_RELOC_ARM_OFFSET_IMM:
5898 as_bad_where (fixp->fx_file, fixp->fx_line,
5899 _("Internal_relocation (type %d) not fixed up (OFFSET_IMM)"),
5900 fixp->fx_r_type);
5901 return NULL;
5902
5903 default:
5904 {
5905 char * type;
5906 switch (fixp->fx_r_type)
5907 {
5908 case BFD_RELOC_ARM_IMMEDIATE: type = "IMMEDIATE"; break;
5909 case BFD_RELOC_ARM_OFFSET_IMM: type = "OFFSET_IMM"; break;
5910 case BFD_RELOC_ARM_OFFSET_IMM8: type = "OFFSET_IMM8"; break;
5911 case BFD_RELOC_ARM_SHIFT_IMM: type = "SHIFT_IMM"; break;
5912 case BFD_RELOC_ARM_SWI: type = "SWI"; break;
5913 case BFD_RELOC_ARM_MULTI: type = "MULTI"; break;
5914 case BFD_RELOC_ARM_CP_OFF_IMM: type = "CP_OFF_IMM"; break;
5915 case BFD_RELOC_ARM_THUMB_ADD: type = "THUMB_ADD"; break;
5916 case BFD_RELOC_ARM_THUMB_SHIFT: type = "THUMB_SHIFT"; break;
5917 case BFD_RELOC_ARM_THUMB_IMM: type = "THUMB_IMM"; break;
5918 case BFD_RELOC_ARM_THUMB_OFFSET: type = "THUMB_OFFSET"; break;
5919 default: type = _("<unknown>"); break;
5920 }
5921 as_bad_where (fixp->fx_file, fixp->fx_line,
5922 _("Can not represent %s relocation in this object file format (%d)"),
5923 type, fixp->fx_pcrel);
5924 return NULL;
5925 }
5926 }
5927
5928 #ifdef OBJ_ELF
5929 if (code == BFD_RELOC_32_PCREL
5930 && GOT_symbol
5931 && fixp->fx_addsy == GOT_symbol)
5932 {
5933 code = BFD_RELOC_ARM_GOTPC;
5934 reloc->addend = fixp->fx_offset = reloc->address;
5935 }
5936 #endif
5937
5938 reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
5939
5940 if (reloc->howto == NULL)
5941 {
5942 as_bad_where (fixp->fx_file, fixp->fx_line,
5943 _("Can not represent %s relocation in this object file format"),
5944 bfd_get_reloc_code_name (code));
5945 return NULL;
5946 }
5947
5948 /* HACK: Since arm ELF uses Rel instead of Rela, encode the
5949 vtable entry to be used in the relocation's section offset. */
5950 if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
5951 reloc->address = fixp->fx_offset;
5952
5953 return reloc;
5954 }
5955
5956 int
5957 md_estimate_size_before_relax (fragP, segtype)
5958 fragS * fragP;
5959 segT segtype;
5960 {
5961 as_fatal (_("md_estimate_size_before_relax\n"));
5962 return 1;
5963 }
5964
5965 static void
5966 output_inst PARAMS ((void))
5967 {
5968 char * to = NULL;
5969
5970 if (inst.error)
5971 {
5972 as_bad (inst.error);
5973 return;
5974 }
5975
5976 to = frag_more (inst.size);
5977
5978 if (thumb_mode && (inst.size > THUMB_SIZE))
5979 {
5980 assert (inst.size == (2 * THUMB_SIZE));
5981 md_number_to_chars (to, inst.instruction >> 16, THUMB_SIZE);
5982 md_number_to_chars (to + THUMB_SIZE, inst.instruction, THUMB_SIZE);
5983 }
5984 else if (inst.size > INSN_SIZE)
5985 {
5986 assert (inst.size == (2 * INSN_SIZE));
5987 md_number_to_chars (to, inst.instruction, INSN_SIZE);
5988 md_number_to_chars (to + INSN_SIZE, inst.instruction, INSN_SIZE);
5989 }
5990 else
5991 md_number_to_chars (to, inst.instruction, inst.size);
5992
5993 if (inst.reloc.type != BFD_RELOC_NONE)
5994 fix_new_arm (frag_now, to - frag_now->fr_literal,
5995 inst.size, & inst.reloc.exp, inst.reloc.pc_rel,
5996 inst.reloc.type);
5997
5998 return;
5999 }
6000
6001 void
6002 md_assemble (str)
6003 char * str;
6004 {
6005 char c;
6006 char * p;
6007 char * q;
6008 char * start;
6009
6010 /* Align the instruction.
6011 This may not be the right thing to do but ... */
6012 /* arm_align (2, 0); */
6013 listing_prev_line (); /* Defined in listing.h */
6014
6015 /* Align the previous label if needed. */
6016 if (last_label_seen != NULL)
6017 {
6018 symbol_set_frag (last_label_seen, frag_now);
6019 S_SET_VALUE (last_label_seen, (valueT) frag_now_fix ());
6020 S_SET_SEGMENT (last_label_seen, now_seg);
6021 }
6022
6023 memset (&inst, '\0', sizeof (inst));
6024 inst.reloc.type = BFD_RELOC_NONE;
6025
6026 skip_whitespace (str);
6027
6028 /* Scan up to the end of the op-code, which must end in white space or
6029 end of string. */
6030 for (start = p = str; *p != '\0'; p++)
6031 if (*p == ' ')
6032 break;
6033
6034 if (p == str)
6035 {
6036 as_bad (_("No operator -- statement `%s'\n"), str);
6037 return;
6038 }
6039
6040 if (thumb_mode)
6041 {
6042 CONST struct thumb_opcode * opcode;
6043
6044 c = *p;
6045 *p = '\0';
6046 opcode = (CONST struct thumb_opcode *) hash_find (arm_tops_hsh, str);
6047 *p = c;
6048
6049 if (opcode)
6050 {
6051 inst.instruction = opcode->value;
6052 inst.size = opcode->size;
6053 (*opcode->parms)(p);
6054 output_inst ();
6055 return;
6056 }
6057 }
6058 else
6059 {
6060 CONST struct asm_opcode * opcode;
6061
6062 inst.size = INSN_SIZE;
6063 /* p now points to the end of the opcode, probably white space, but we
6064 have to break the opcode up in case it contains condionals and flags;
6065 keep trying with progressively smaller basic instructions until one
6066 matches, or we run out of opcode. */
6067 q = (p - str > LONGEST_INST) ? str + LONGEST_INST : p;
6068 for (; q != str; q--)
6069 {
6070 c = *q;
6071 *q = '\0';
6072 opcode = (CONST struct asm_opcode *) hash_find (arm_ops_hsh, str);
6073 *q = c;
6074
6075 if (opcode && opcode->template)
6076 {
6077 unsigned long flag_bits = 0;
6078 char * r;
6079
6080 /* Check that this instruction is supported for this CPU. */
6081 if ((opcode->variants & cpu_variant) == 0)
6082 goto try_shorter;
6083
6084 inst.instruction = opcode->value;
6085 if (q == p) /* Just a simple opcode. */
6086 {
6087 if (opcode->comp_suffix != 0)
6088 as_bad (_("Opcode `%s' must have suffix from <%s>\n"), str,
6089 opcode->comp_suffix);
6090 else
6091 {
6092 inst.instruction |= COND_ALWAYS;
6093 (*opcode->parms)(q, 0);
6094 }
6095 output_inst ();
6096 return;
6097 }
6098
6099 /* Now check for a conditional. */
6100 r = q;
6101 if (p - r >= 2)
6102 {
6103 CONST struct asm_cond *cond;
6104 char d = *(r + 2);
6105
6106 *(r + 2) = '\0';
6107 cond = (CONST struct asm_cond *) hash_find (arm_cond_hsh, r);
6108 *(r + 2) = d;
6109 if (cond)
6110 {
6111 if (cond->value == 0xf0000000)
6112 as_tsktsk (
6113 _("Warning: Use of the 'nv' conditional is deprecated\n"));
6114
6115 inst.instruction |= cond->value;
6116 r += 2;
6117 }
6118 else
6119 inst.instruction |= COND_ALWAYS;
6120 }
6121 else
6122 inst.instruction |= COND_ALWAYS;
6123
6124 /* If there is a compulsory suffix, it should come here, before
6125 any optional flags. */
6126 if (opcode->comp_suffix)
6127 {
6128 CONST char *s = opcode->comp_suffix;
6129
6130 while (*s)
6131 {
6132 inst.suffix++;
6133 if (*r == *s)
6134 break;
6135 s++;
6136 }
6137
6138 if (*s == '\0')
6139 {
6140 as_bad (_("Opcode `%s' must have suffix from <%s>\n"), str,
6141 opcode->comp_suffix);
6142 return;
6143 }
6144
6145 r++;
6146 }
6147
6148 /* The remainder, if any should now be flags for the instruction;
6149 Scan these checking each one found with the opcode. */
6150 if (r != p)
6151 {
6152 char d;
6153 CONST struct asm_flg *flag = opcode->flags;
6154
6155 if (flag)
6156 {
6157 int flagno;
6158
6159 d = *p;
6160 *p = '\0';
6161
6162 for (flagno = 0; flag[flagno].template; flagno++)
6163 {
6164 if (streq (r, flag[flagno].template))
6165 {
6166 flag_bits |= flag[flagno].set_bits;
6167 break;
6168 }
6169 }
6170
6171 *p = d;
6172 if (! flag[flagno].template)
6173 goto try_shorter;
6174 }
6175 else
6176 goto try_shorter;
6177 }
6178
6179 (*opcode->parms) (p, flag_bits);
6180 output_inst ();
6181 return;
6182 }
6183
6184 try_shorter:
6185 ;
6186 }
6187 }
6188
6189 /* It wasn't an instruction, but it might be a register alias of the form
6190 alias .req reg */
6191 q = p;
6192 skip_whitespace (q);
6193
6194 c = *p;
6195 *p = '\0';
6196
6197 if (*q && !strncmp (q, ".req ", 4))
6198 {
6199 int reg;
6200 char * copy_of_str = str;
6201 char * r;
6202
6203 q += 4;
6204 skip_whitespace (q);
6205
6206 for (r = q; *r != '\0'; r++)
6207 if (*r == ' ')
6208 break;
6209
6210 if (r != q)
6211 {
6212 int regnum;
6213 char d = *r;
6214
6215 *r = '\0';
6216 regnum = arm_reg_parse (& q);
6217 *r = d;
6218
6219 reg = arm_reg_parse (& str);
6220
6221 if (reg == FAIL)
6222 {
6223 if (regnum != FAIL)
6224 insert_reg_alias (str, regnum);
6225 else
6226 as_warn (_("register '%s' does not exist"), q);
6227 }
6228 else if (regnum != FAIL)
6229 {
6230 if (reg != regnum)
6231 as_warn (_("ignoring redefinition of register alias '%s'"), copy_of_str );
6232
6233 /* Do not warn about redefinitions to the same alias. */
6234 }
6235 else
6236 as_warn (_("ignoring redefinition of register alias '%s' to non-existant register '%s'"),
6237 copy_of_str, q);
6238 }
6239 else
6240 as_warn (_("ignoring incomplete .req pseuso op"));
6241
6242 *p = c;
6243 return;
6244 }
6245
6246 *p = c;
6247 as_bad (_("bad instruction `%s'"), start);
6248 }
6249
6250 /*
6251 * md_parse_option
6252 * Invocation line includes a switch not recognized by the base assembler.
6253 * See if it's a processor-specific option. These are:
6254 * Cpu variants, the arm part is optional:
6255 * -m[arm]1 Currently not supported.
6256 * -m[arm]2, -m[arm]250 Arm 2 and Arm 250 processor
6257 * -m[arm]3 Arm 3 processor
6258 * -m[arm]6[xx], Arm 6 processors
6259 * -m[arm]7[xx][t][[d]m] Arm 7 processors
6260 * -m[arm]8[10] Arm 8 processors
6261 * -m[arm]9[20][tdmi] Arm 9 processors
6262 * -mstrongarm[110[0]] StrongARM processors
6263 * -m[arm]v[2345] Arm architecures
6264 * -mall All (except the ARM1)
6265 * FP variants:
6266 * -mfpa10, -mfpa11 FPA10 and 11 co-processor instructions
6267 * -mfpe-old (No float load/store multiples)
6268 * -mno-fpu Disable all floating point instructions
6269 * Run-time endian selection:
6270 * -EB big endian cpu
6271 * -EL little endian cpu
6272 * ARM Procedure Calling Standard:
6273 * -mapcs-32 32 bit APCS
6274 * -mapcs-26 26 bit APCS
6275 * -mapcs-float Pass floats in float regs
6276 * -mapcs-reentrant Position independent code
6277 * -mthumb-interwork Code supports Arm/Thumb interworking
6278 * -moabi Old ELF ABI
6279 */
6280
6281 CONST char * md_shortopts = "m:k";
6282 struct option md_longopts[] =
6283 {
6284 #ifdef ARM_BI_ENDIAN
6285 #define OPTION_EB (OPTION_MD_BASE + 0)
6286 {"EB", no_argument, NULL, OPTION_EB},
6287 #define OPTION_EL (OPTION_MD_BASE + 1)
6288 {"EL", no_argument, NULL, OPTION_EL},
6289 #ifdef OBJ_ELF
6290 #define OPTION_OABI (OPTION_MD_BASE +2)
6291 {"oabi", no_argument, NULL, OPTION_OABI},
6292 #endif
6293 #endif
6294 {NULL, no_argument, NULL, 0}
6295 };
6296 size_t md_longopts_size = sizeof (md_longopts);
6297
6298 int
6299 md_parse_option (c, arg)
6300 int c;
6301 char * arg;
6302 {
6303 char * str = arg;
6304
6305 switch (c)
6306 {
6307 #ifdef ARM_BI_ENDIAN
6308 case OPTION_EB:
6309 target_big_endian = 1;
6310 break;
6311 case OPTION_EL:
6312 target_big_endian = 0;
6313 break;
6314 #endif
6315
6316 case 'm':
6317 switch (*str)
6318 {
6319 case 'f':
6320 if (streq (str, "fpa10"))
6321 cpu_variant = (cpu_variant & ~FPU_ALL) | FPU_FPA10;
6322 else if (streq (str, "fpa11"))
6323 cpu_variant = (cpu_variant & ~FPU_ALL) | FPU_FPA11;
6324 else if (streq (str, "fpe-old"))
6325 cpu_variant = (cpu_variant & ~FPU_ALL) | FPU_CORE;
6326 else
6327 goto bad;
6328 break;
6329
6330 case 'n':
6331 if (streq (str, "no-fpu"))
6332 cpu_variant &= ~FPU_ALL;
6333 break;
6334
6335 #ifdef OBJ_ELF
6336 case 'o':
6337 if (streq (str, "oabi"))
6338 target_oabi = true;
6339 break;
6340 #endif
6341
6342 case 't':
6343 /* Limit assembler to generating only Thumb instructions: */
6344 if (streq (str, "thumb"))
6345 {
6346 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_THUMB;
6347 cpu_variant = (cpu_variant & ~FPU_ALL) | FPU_NONE;
6348 thumb_mode = 1;
6349 }
6350 else if (streq (str, "thumb-interwork"))
6351 {
6352 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_THUMB | ARM_ARCH_V4;
6353 #if defined OBJ_COFF || defined OBJ_ELF
6354 support_interwork = true;
6355 #endif
6356 }
6357 else
6358 goto bad;
6359 break;
6360
6361 default:
6362 if (streq (str, "all"))
6363 {
6364 cpu_variant = ARM_ALL | FPU_ALL;
6365 return 1;
6366 }
6367 #if defined OBJ_COFF || defined OBJ_ELF
6368 if (! strncmp (str, "apcs-", 5))
6369 {
6370 /* GCC passes on all command line options starting "-mapcs-..."
6371 to us, so we must parse them here. */
6372
6373 str += 5;
6374
6375 if (streq (str, "32"))
6376 {
6377 uses_apcs_26 = false;
6378 return 1;
6379 }
6380 else if (streq (str, "26"))
6381 {
6382 uses_apcs_26 = true;
6383 return 1;
6384 }
6385 else if (streq (str, "frame"))
6386 {
6387 /* Stack frames are being generated - does not affect
6388 linkage of code. */
6389 return 1;
6390 }
6391 else if (streq (str, "stack-check"))
6392 {
6393 /* Stack checking is being performed - does not affect
6394 linkage, but does require that the functions
6395 __rt_stkovf_split_small and __rt_stkovf_split_big be
6396 present in the final link. */
6397
6398 return 1;
6399 }
6400 else if (streq (str, "float"))
6401 {
6402 /* Floating point arguments are being passed in the floating
6403 point registers. This does affect linking, since this
6404 version of the APCS is incompatible with the version that
6405 passes floating points in the integer registers. */
6406
6407 uses_apcs_float = true;
6408 return 1;
6409 }
6410 else if (streq (str, "reentrant"))
6411 {
6412 /* Reentrant code has been generated. This does affect
6413 linking, since there is no point in linking reentrant/
6414 position independent code with absolute position code. */
6415 pic_code = true;
6416 return 1;
6417 }
6418
6419 as_bad (_("Unrecognised APCS switch -m%s"), arg);
6420 return 0;
6421 }
6422 #endif
6423 /* Strip off optional "arm" */
6424 if (! strncmp (str, "arm", 3))
6425 str += 3;
6426
6427 switch (*str)
6428 {
6429 case '1':
6430 if (streq (str, "1"))
6431 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_1;
6432 else
6433 goto bad;
6434 break;
6435
6436 case '2':
6437 if (streq (str, "2"))
6438 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_2;
6439 else if (streq (str, "250"))
6440 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_250;
6441 else
6442 goto bad;
6443 break;
6444
6445 case '3':
6446 if (streq (str, "3"))
6447 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_3;
6448 else
6449 goto bad;
6450 break;
6451
6452 case '6':
6453 switch (strtol (str, NULL, 10))
6454 {
6455 case 6:
6456 case 60:
6457 case 600:
6458 case 610:
6459 case 620:
6460 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_6;
6461 break;
6462 default:
6463 goto bad;
6464 }
6465 break;
6466
6467 case '7':
6468 switch (strtol (str, & str, 10)) /* Eat the processor name */
6469 {
6470 case 7:
6471 case 70:
6472 case 700:
6473 case 710:
6474 case 7100:
6475 case 7500:
6476 break;
6477 default:
6478 goto bad;
6479 }
6480 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_7;
6481 for (; *str; str++)
6482 {
6483 switch (* str)
6484 {
6485 case 't':
6486 cpu_variant |= (ARM_THUMB | ARM_ARCH_V4);
6487 break;
6488
6489 case 'm':
6490 cpu_variant |= ARM_LONGMUL;
6491 break;
6492
6493 case 'f': /* fe => fp enabled cpu. */
6494 if (str[1] == 'e')
6495 ++ str;
6496 else
6497 goto bad;
6498
6499 case 'c': /* Left over from 710c processor name. */
6500 case 'd': /* Debug */
6501 case 'i': /* Embedded ICE */
6502 /* Included for completeness in ARM processor naming. */
6503 break;
6504
6505 default:
6506 goto bad;
6507 }
6508 }
6509 break;
6510
6511 case '8':
6512 if (streq (str, "8") || streq (str, "810"))
6513 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_8 | ARM_ARCH_V4 | ARM_LONGMUL;
6514 else
6515 goto bad;
6516 break;
6517
6518 case '9':
6519 if (streq (str, "9"))
6520 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_9 | ARM_ARCH_V4 | ARM_LONGMUL | ARM_THUMB;
6521 else if (streq (str, "920"))
6522 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_9 | ARM_ARCH_V4 | ARM_LONGMUL;
6523 else if (streq (str, "920t"))
6524 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_9 | ARM_ARCH_V4 | ARM_LONGMUL | ARM_THUMB;
6525 else if (streq (str, "9tdmi"))
6526 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_9 | ARM_ARCH_V4 | ARM_LONGMUL | ARM_THUMB;
6527 else
6528 goto bad;
6529 break;
6530
6531 case 's':
6532 if (streq (str, "strongarm")
6533 || streq (str, "strongarm110")
6534 || streq (str, "strongarm1100"))
6535 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_8 | ARM_ARCH_V4 | ARM_LONGMUL;
6536 else
6537 goto bad;
6538 break;
6539
6540 case 'v':
6541 /* Select variant based on architecture rather than processor */
6542 switch (*++str)
6543 {
6544 case '2':
6545 switch (*++str)
6546 {
6547 case 'a': cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_3; break;
6548 case 0: cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_2; break;
6549 default: as_bad (_("Invalid architecture variant -m%s"), arg); break;
6550 }
6551 break;
6552
6553 case '3':
6554 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_7;
6555
6556 switch (*++str)
6557 {
6558 case 'm': cpu_variant |= ARM_LONGMUL; break;
6559 case 0: break;
6560 default: as_bad (_("Invalid architecture variant -m%s"), arg); break;
6561 }
6562 break;
6563
6564 case '4':
6565 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_ARCH_V4;
6566
6567 switch (*++str)
6568 {
6569 case 't': cpu_variant |= ARM_THUMB; break;
6570 case 0: break;
6571 default: as_bad (_("Invalid architecture variant -m%s"), arg); break;
6572 }
6573 break;
6574
6575 case '5':
6576 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_ARCH_V5;
6577
6578 switch (*++str)
6579 {
6580 case 't': cpu_variant |= ARM_THUMB; break;
6581 case 0: break;
6582 default: as_bad (_("Invalid architecture variant -m%s"), arg); break;
6583 }
6584 break;
6585
6586 default:
6587 as_bad (_("Invalid architecture variant -m%s"), arg);
6588 break;
6589 }
6590 break;
6591
6592 default:
6593 bad:
6594 as_bad (_("Invalid processor variant -m%s"), arg);
6595 return 0;
6596 }
6597 }
6598 break;
6599
6600 case 'k':
6601 pic_code = 1;
6602 break;
6603
6604 default:
6605 return 0;
6606 }
6607
6608 return 1;
6609 }
6610
6611 void
6612 md_show_usage (fp)
6613 FILE * fp;
6614 {
6615 fprintf (fp,
6616 _("\
6617 ARM Specific Assembler Options:\n\
6618 -m[arm][<processor name>] select processor variant\n\
6619 -m[arm]v[2|2a|3|3m|4|4t|5]select architecture variant\n\
6620 -mthumb only allow Thumb instructions\n\
6621 -mthumb-interwork mark the assembled code as supporting interworking\n\
6622 -mall allow any instruction\n\
6623 -mfpa10, -mfpa11 select floating point architecture\n\
6624 -mfpe-old don't allow floating-point multiple instructions\n\
6625 -mno-fpu don't allow any floating-point instructions.\n"));
6626 fprintf (fp,
6627 _("\
6628 -k generate PIC code.\n"));
6629 #if defined OBJ_COFF || defined OBJ_ELF
6630 fprintf (fp,
6631 _("\
6632 -mapcs-32, -mapcs-26 specify which ARM Procedure Calling Standard to use\n"));
6633 fprintf (fp,
6634 _("\
6635 -mapcs-float floating point args are passed in FP regs\n"));
6636 fprintf (fp,
6637 _("\
6638 -mapcs-reentrant the code is position independent/reentrant\n"));
6639 #endif
6640 #ifdef OBJ_ELF
6641 fprintf (fp,
6642 _("\
6643 -moabi support the old ELF ABI\n"));
6644 #endif
6645 #ifdef ARM_BI_ENDIAN
6646 fprintf (fp,
6647 _("\
6648 -EB assemble code for a big endian cpu\n\
6649 -EL assemble code for a little endian cpu\n"));
6650 #endif
6651 }
6652
6653 /* We need to be able to fix up arbitrary expressions in some statements.
6654 This is so that we can handle symbols that are an arbitrary distance from
6655 the pc. The most common cases are of the form ((+/-sym -/+ . - 8) & mask),
6656 which returns part of an address in a form which will be valid for
6657 a data instruction. We do this by pushing the expression into a symbol
6658 in the expr_section, and creating a fix for that. */
6659
6660 static void
6661 fix_new_arm (frag, where, size, exp, pc_rel, reloc)
6662 fragS * frag;
6663 int where;
6664 short int size;
6665 expressionS * exp;
6666 int pc_rel;
6667 int reloc;
6668 {
6669 fixS * new_fix;
6670 arm_fix_data * arm_data;
6671
6672 switch (exp->X_op)
6673 {
6674 case O_constant:
6675 case O_symbol:
6676 case O_add:
6677 case O_subtract:
6678 new_fix = fix_new_exp (frag, where, size, exp, pc_rel, reloc);
6679 break;
6680
6681 default:
6682 new_fix = fix_new (frag, where, size, make_expr_symbol (exp), 0,
6683 pc_rel, reloc);
6684 break;
6685 }
6686
6687 /* Mark whether the fix is to a THUMB instruction, or an ARM instruction */
6688 arm_data = (arm_fix_data *) obstack_alloc (& notes, sizeof (arm_fix_data));
6689 new_fix->tc_fix_data = (PTR) arm_data;
6690 arm_data->thumb_mode = thumb_mode;
6691
6692 return;
6693 }
6694
6695
6696 /* This fix_new is called by cons via TC_CONS_FIX_NEW. */
6697 void
6698 cons_fix_new_arm (frag, where, size, exp)
6699 fragS * frag;
6700 int where;
6701 int size;
6702 expressionS * exp;
6703 {
6704 bfd_reloc_code_real_type type;
6705 int pcrel = 0;
6706
6707 /* Pick a reloc ...
6708 *
6709 * @@ Should look at CPU word size.
6710 */
6711 switch (size)
6712 {
6713 case 2:
6714 type = BFD_RELOC_16;
6715 break;
6716 case 4:
6717 default:
6718 type = BFD_RELOC_32;
6719 break;
6720 case 8:
6721 type = BFD_RELOC_64;
6722 break;
6723 }
6724
6725 fix_new_exp (frag, where, (int) size, exp, pcrel, type);
6726 }
6727
6728 /* A good place to do this, although this was probably not intended
6729 for this kind of use. We need to dump the literal pool before
6730 references are made to a null symbol pointer. */
6731 void
6732 arm_cleanup ()
6733 {
6734 if (current_poolP == NULL)
6735 return;
6736
6737 subseg_set (text_section, 0); /* Put it at the end of text section. */
6738 s_ltorg (0);
6739 listing_prev_line ();
6740 }
6741
6742 void
6743 arm_start_line_hook ()
6744 {
6745 last_label_seen = NULL;
6746 }
6747
6748 void
6749 arm_frob_label (sym)
6750 symbolS * sym;
6751 {
6752 last_label_seen = sym;
6753
6754 ARM_SET_THUMB (sym, thumb_mode);
6755
6756 #if defined OBJ_COFF || defined OBJ_ELF
6757 ARM_SET_INTERWORK (sym, support_interwork);
6758 #endif
6759
6760 if (label_is_thumb_function_name)
6761 {
6762 /* When the address of a Thumb function is taken the bottom
6763 bit of that address should be set. This will allow
6764 interworking between Arm and Thumb functions to work
6765 correctly. */
6766
6767 THUMB_SET_FUNC (sym, 1);
6768
6769 label_is_thumb_function_name = false;
6770 }
6771 }
6772
6773 /* Adjust the symbol table. This marks Thumb symbols as distinct from
6774 ARM ones. */
6775
6776 void
6777 arm_adjust_symtab ()
6778 {
6779 #ifdef OBJ_COFF
6780 symbolS * sym;
6781
6782 for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
6783 {
6784 if (ARM_IS_THUMB (sym))
6785 {
6786 if (THUMB_IS_FUNC (sym))
6787 {
6788 /* Mark the symbol as a Thumb function. */
6789 if ( S_GET_STORAGE_CLASS (sym) == C_STAT
6790 || S_GET_STORAGE_CLASS (sym) == C_LABEL) /* This can happen! */
6791 S_SET_STORAGE_CLASS (sym, C_THUMBSTATFUNC);
6792
6793 else if (S_GET_STORAGE_CLASS (sym) == C_EXT)
6794 S_SET_STORAGE_CLASS (sym, C_THUMBEXTFUNC);
6795 else
6796 as_bad (_("%s: unexpected function type: %d"),
6797 S_GET_NAME (sym), S_GET_STORAGE_CLASS (sym));
6798 }
6799 else switch (S_GET_STORAGE_CLASS (sym))
6800 {
6801 case C_EXT:
6802 S_SET_STORAGE_CLASS (sym, C_THUMBEXT);
6803 break;
6804 case C_STAT:
6805 S_SET_STORAGE_CLASS (sym, C_THUMBSTAT);
6806 break;
6807 case C_LABEL:
6808 S_SET_STORAGE_CLASS (sym, C_THUMBLABEL);
6809 break;
6810 default: /* do nothing */
6811 break;
6812 }
6813 }
6814
6815 if (ARM_IS_INTERWORK (sym))
6816 coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_flags = 0xFF;
6817 }
6818 #endif
6819 #ifdef OBJ_ELF
6820 symbolS * sym;
6821 elf_symbol_type * elf_sym;
6822 char bind;
6823
6824 for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
6825 {
6826 if (ARM_IS_THUMB (sym))
6827 {
6828 if (THUMB_IS_FUNC (sym))
6829 {
6830 elf_sym = elf_symbol (symbol_get_bfdsym (sym));
6831 bind = ELF_ST_BIND (elf_sym);
6832 elf_sym->internal_elf_sym.st_info = ELF_ST_INFO (bind, STT_ARM_TFUNC);
6833 }
6834 }
6835 }
6836 #endif
6837 }
6838
6839 int
6840 arm_data_in_code ()
6841 {
6842 if (thumb_mode && ! strncmp (input_line_pointer + 1, "data:", 5))
6843 {
6844 *input_line_pointer = '/';
6845 input_line_pointer += 5;
6846 *input_line_pointer = 0;
6847 return 1;
6848 }
6849
6850 return 0;
6851 }
6852
6853 char *
6854 arm_canonicalize_symbol_name (name)
6855 char * name;
6856 {
6857 int len;
6858
6859 if (thumb_mode && (len = strlen (name)) > 5
6860 && streq (name + len - 5, "/data"))
6861 *(name + len - 5) = 0;
6862
6863 return name;
6864 }
6865
6866 boolean
6867 arm_validate_fix (fixP)
6868 fixS * fixP;
6869 {
6870 /* If the destination of the branch is a defined symbol which does not have
6871 the THUMB_FUNC attribute, then we must be calling a function which has
6872 the (interfacearm) attribute. We look for the Thumb entry point to that
6873 function and change the branch to refer to that function instead. */
6874 if ( fixP->fx_r_type == BFD_RELOC_THUMB_PCREL_BRANCH23
6875 && fixP->fx_addsy != NULL
6876 && S_IS_DEFINED (fixP->fx_addsy)
6877 && ! THUMB_IS_FUNC (fixP->fx_addsy))
6878 {
6879 fixP->fx_addsy = find_real_start (fixP->fx_addsy);
6880 return true;
6881 }
6882
6883 return false;
6884 }
6885
6886 #ifdef OBJ_ELF
6887 /* Relocations against Thumb function names must be left unadjusted,
6888 so that the linker can use this information to correctly set the
6889 bottom bit of their addresses. The MIPS version of this function
6890 also prevents relocations that are mips-16 specific, but I do not
6891 know why it does this.
6892
6893 FIXME:
6894 There is one other problem that ought to be addressed here, but
6895 which currently is not: Taking the address of a label (rather
6896 than a function) and then later jumping to that address. Such
6897 addresses also ought to have their bottom bit set (assuming that
6898 they reside in Thumb code), but at the moment they will not. */
6899
6900 boolean
6901 arm_fix_adjustable (fixP)
6902 fixS * fixP;
6903 {
6904 if (fixP->fx_addsy == NULL)
6905 return 1;
6906
6907 /* Prevent all adjustments to global symbols. */
6908 if (S_IS_EXTERN (fixP->fx_addsy))
6909 return 0;
6910
6911 if (S_IS_WEAK (fixP->fx_addsy))
6912 return 0;
6913
6914 if (THUMB_IS_FUNC (fixP->fx_addsy)
6915 && fixP->fx_subsy == NULL)
6916 return 0;
6917
6918 /* We need the symbol name for the VTABLE entries */
6919 if ( fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
6920 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
6921 return 0;
6922
6923 return 1;
6924 }
6925
6926 const char *
6927 elf32_arm_target_format ()
6928 {
6929 if (target_big_endian)
6930 if (target_oabi)
6931 return "elf32-bigarm-oabi";
6932 else
6933 return "elf32-bigarm";
6934 else
6935 if (target_oabi)
6936 return "elf32-littlearm-oabi";
6937 else
6938 return "elf32-littlearm";
6939 }
6940
6941 void
6942 armelf_frob_symbol (symp, puntp)
6943 symbolS * symp;
6944 int * puntp;
6945 {
6946 elf_frob_symbol (symp, puntp);
6947 }
6948
6949 int
6950 arm_force_relocation (fixp)
6951 struct fix * fixp;
6952 {
6953 if ( fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
6954 || fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY
6955 || fixp->fx_r_type == BFD_RELOC_ARM_PCREL_BRANCH
6956 || fixp->fx_r_type == BFD_RELOC_THUMB_PCREL_BRANCH23)
6957 return 1;
6958
6959 return 0;
6960 }
6961
6962 static bfd_reloc_code_real_type
6963 arm_parse_reloc ()
6964 {
6965 char id[16];
6966 char * ip;
6967 int i;
6968 static struct
6969 {
6970 char * str;
6971 int len;
6972 bfd_reloc_code_real_type reloc;
6973 }
6974 reloc_map[] =
6975 {
6976 #define MAP(str,reloc) { str, sizeof (str)-1, reloc }
6977 MAP ("(got)", BFD_RELOC_ARM_GOT32),
6978 MAP ("(gotoff)", BFD_RELOC_ARM_GOTOFF),
6979 /* ScottB: Jan 30, 1998 */
6980 /* Added support for parsing "var(PLT)" branch instructions */
6981 /* generated by GCC for PLT relocs */
6982 MAP ("(plt)", BFD_RELOC_ARM_PLT32),
6983 NULL, 0, BFD_RELOC_UNUSED
6984 #undef MAP
6985 };
6986
6987 for (i = 0, ip = input_line_pointer;
6988 i < sizeof (id) && (isalnum (*ip) || ispunct (*ip));
6989 i++, ip++)
6990 id[i] = tolower (*ip);
6991
6992 for (i = 0; reloc_map[i].str; i++)
6993 if (strncmp (id, reloc_map[i].str, reloc_map[i].len) == 0)
6994 break;
6995
6996 input_line_pointer += reloc_map[i].len;
6997
6998 return reloc_map[i].reloc;
6999 }
7000
7001 static void
7002 s_arm_elf_cons (nbytes)
7003 int nbytes;
7004 {
7005 expressionS exp;
7006
7007 #ifdef md_flush_pending_output
7008 md_flush_pending_output ();
7009 #endif
7010
7011 if (is_it_end_of_statement ())
7012 {
7013 demand_empty_rest_of_line ();
7014 return;
7015 }
7016
7017 #ifdef md_cons_align
7018 md_cons_align (nbytes);
7019 #endif
7020
7021 do
7022 {
7023 bfd_reloc_code_real_type reloc;
7024
7025 expression (& exp);
7026
7027 if (exp.X_op == O_symbol
7028 && * input_line_pointer == '('
7029 && (reloc = arm_parse_reloc()) != BFD_RELOC_UNUSED)
7030 {
7031 reloc_howto_type * howto = bfd_reloc_type_lookup (stdoutput, reloc);
7032 int size = bfd_get_reloc_size (howto);
7033
7034 if (size > nbytes)
7035 as_bad ("%s relocations do not fit in %d bytes", howto->name, nbytes);
7036 else
7037 {
7038 register char * p = frag_more ((int) nbytes);
7039 int offset = nbytes - size;
7040
7041 fix_new_exp (frag_now, p - frag_now->fr_literal + offset, size,
7042 & exp, 0, reloc);
7043 }
7044 }
7045 else
7046 emit_expr (& exp, (unsigned int) nbytes);
7047 }
7048 while (*input_line_pointer++ == ',');
7049
7050 input_line_pointer--; /* Put terminator back into stream. */
7051 demand_empty_rest_of_line ();
7052 }
7053
7054 #endif /* OBJ_ELF */
GDB Binutils - Deliverables
This page took 0.171085 seconds and 5 git commands to generate.