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