]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - gas/config/tc-csky.c
projects / thirdparty / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Update year range in copyright notice of binutils files
[thirdparty/binutils-gdb.git] / gas / config / tc-csky.c
1 /* tc-csky.c -- Assembler for C-SKY
2 Copyright (C) 1989-2023 Free Software Foundation, Inc.
3 Created by Lifang Xia (lifang_xia@c-sky.com)
4 Contributed by C-SKY Microsystems and Mentor Graphics.
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 3, 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, 51 Franklin Street - Fifth Floor, Boston, MA
21 02110-1301, USA. */
22
23 #include "as.h"
24 #include <limits.h>
25 #include <stdint.h>
26 #include <stdarg.h>
27 #include <ctype.h>
28 #include "safe-ctype.h"
29 #include "subsegs.h"
30 #include "obstack.h"
31 #include "libiberty.h"
32
33 #ifdef OBJ_ELF
34 #include "elf/csky.h"
35 #include "dw2gencfi.h"
36 #endif
37 #include "tc-csky.h"
38 #include "dwarf2dbg.h"
39
40 #define BUILD_AS 1
41
42 #define OPCODE_MAX_LEN 20
43 #define HAS_SUB_OPERAND 0xfffffffful
44
45 /* This value is just for lrw to distinguish "[]" label. */
46 #define NEED_OUTPUT_LITERAL 1
47
48 #define IS_EXTERNAL_SYM(sym, sec) (S_GET_SEGMENT (sym) != sec)
49 #define IS_SUPPORT_OPCODE16(opcode) (opcode->isa_flag16 | isa_flag)
50 #define IS_SUPPORT_OPCODE32(opcode) (opcode->isa_flag32 | isa_flag)
51
52
53 #define KB * 1024
54 #define MB KB * 1024
55 #define GB MB * 1024
56
57 /* Define DSP version flags. For different CPU, the version of DSP
58 instructions may be different. */
59 #define CSKY_DSP_FLAG_V1 (1 << 0) /* Normal DSP instructions. */
60 #define CSKY_DSP_FLAG_V2 (1 << 1) /* CK803S enhanced DSP. */
61
62 /* Literal pool related macros. */
63 /* 1024 - 1 entry - 2 byte rounding. */
64 #define v1_SPANPANIC (998)
65 #define v1_SPANCLOSE (900)
66 #define v1_SPANEXIT (600)
67 #define v2_SPANPANIC (1024 - 4)
68
69 /* 1024 is flrw offset.
70 24 is the biggest size for single instruction.
71 for lrw16 (3+7, 512 bytes). */
72 #define v2_SPANCLOSE (512 - 24)
73
74 /* For lrw16, 112 average size for a function. */
75 #define v2_SPANEXIT (512 - 112)
76
77 /* For lrw16 (3+7, 512 bytes). */
78 #define v2_SPANCLOSE_ELRW (1016 - 24)
79
80 /* For lrw16, 112 average size for a function. */
81 #define v2_SPANEXIT_ELRW (1016 - 112)
82 #define MAX_POOL_SIZE (1024 / 4)
83 #define POOL_END_LABEL ".LE"
84 #define POOL_START_LABEL ".LS"
85
86 /* Used in v1_relax_table. */
87 /* These are the two types of relaxable instruction. */
88 #define COND_JUMP 1
89 #define UNCD_JUMP 2
90 #define COND_JUMP_PIC 3
91 #define UNCD_JUMP_PIC 4
92
93 #define UNDEF_DISP 0
94 #define DISP12 1
95 #define DISP32 2
96 #define UNDEF_WORD_DISP 3
97
98 #define C12_LEN 2
99 /* Allow for align: bt/jmpi/.long + align. */
100 #define C32_LEN 10
101 /* Allow for align: bt/subi/stw/bsr/lrw/add/ld/addi/jmp/.long + align. */
102 #define C32_LEN_PIC 24
103 #define U12_LEN 2
104 /* Allow for align: jmpi/.long + align. */
105 #define U32_LEN 8
106 /* Allow for align: subi/stw/bsr/lrw/add/ld/addi/jmp/.long + align. */
107 #define U32_LEN_PIC 22
108
109 #define C(what,length) (((what) << 2) + (length))
110 #define UNCD_JUMP_S (do_pic ? UNCD_JUMP_PIC : UNCD_JUMP)
111 #define COND_JUMP_S (do_pic ? COND_JUMP_PIC : COND_JUMP)
112 #define U32_LEN_S (do_pic ? U32_LEN_PIC : U32_LEN)
113 #define C32_LEN_S (do_pic ? C32_LEN_PIC : C32_LEN)
114
115 /* Used in v2_relax_table. */
116 #define COND_DISP10_LEN 2 /* bt/bf_16. */
117 #define COND_DISP16_LEN 4 /* bt/bf_32. */
118
119 #define SCOND_DISP10_LEN 2 /* bt/bf_16, for CK801 only. */
120 #define SCOND_DISP16_LEN 6 /* !(bt/bf_16) + br_32. */
121
122 #define UNCD_DISP10_LEN 2 /* br_16. */
123 #define UNCD_DISP16_LEN 4 /* br_32. */
124 #define UNCD_DISP26_LEN 4 /* br32_old. */
125
126 #define JCOND_DISP10_LEN 2 /* bt/bf_16. */
127 #define JCOND_DISP16_LEN 4 /* bt/bf_32. */
128 #define JCOND_DISP32_LEN 12 /* !(bt/bf_16)/jmpi 32/.align 2/literal 4. */
129 #define JCOND_DISP26_LEN 8 /* bt/bf_32/br_32 old. */
130
131 #define JUNCD_DISP26_LEN 4 /* bt/bf_32 old. */
132 #define JUNCD_DISP10_LEN 2 /* br_16. */
133 #define JUNCD_DISP16_LEN 4 /* bt/bf_32. */
134 #define JUNCD_DISP32_LEN 10 /* jmpi_32/.align 2/literal 4/ CHANGED!. */
135 #define JCOMP_DISP26_LEN 8 /* bne_32/br_32 old. */
136
137 #define JCOMP_DISP16_LEN 4 /* bne_32 old. */
138 #define JCOMPZ_DISP16_LEN 4 /* bhlz_32. */
139 #define JCOMPZ_DISP32_LEN 14 /* bsz_32/jmpi 32/.align 2/literal 4. */
140 #define JCOMPZ_DISP26_LEN 8 /* bsz_32/br_32 old. */
141 #define JCOMP_DISP32_LEN 14 /* be_32/jmpi_32/.align 2/literal old. */
142
143 #define BSR_DISP10_LEN 2 /* bsr_16. */
144 #define BSR_DISP26_LEN 4 /* bsr_32. */
145 #define LRW_DISP7_LEN 2 /* lrw16. */
146 #define LRW_DISP16_LEN 4 /* lrw32. */
147
148 /* Declare worker functions. */
149 bool v1_work_lrw (void);
150 bool v1_work_jbsr (void);
151 bool v1_work_fpu_fo (void);
152 bool v1_work_fpu_fo_fc (void);
153 bool v1_work_fpu_write (void);
154 bool v1_work_fpu_read (void);
155 bool v1_work_fpu_writed (void);
156 bool v1_work_fpu_readd (void);
157 bool v2_work_istack (void);
158 bool v2_work_btsti (void);
159 bool v2_work_addi (void);
160 bool v2_work_subi (void);
161 bool v2_work_add_sub (void);
162 bool v2_work_rotlc (void);
163 bool v2_work_bgeni (void);
164 bool v2_work_not (void);
165 bool v2_work_jbtf (void);
166 bool v2_work_jbr (void);
167 bool v2_work_lrw (void);
168 bool v2_work_lrsrsw (void);
169 bool v2_work_jbsr (void);
170 bool v2_work_jsri (void);
171 bool v2_work_movih (void);
172 bool v2_work_ori (void);
173 bool float_work_fmovi (void);
174 bool dsp_work_bloop (void);
175 bool float_work_fpuv3_fmovi (void);
176 bool float_work_fpuv3_fstore (void);
177 bool v2_work_addc (void);
178
179 /* csky-opc.h must be included after workers are declared. */
180 #include "opcodes/csky-opc.h"
181 #include "opcode/csky.h"
182
183 enum
184 {
185 RELAX_NONE = 0,
186 RELAX_OVERFLOW,
187
188 COND_DISP10 = 20, /* bt/bf_16. */
189 COND_DISP16, /* bt/bf_32. */
190
191 SCOND_DISP10, /* br_16 */
192 SCOND_DISP16, /* !(bt/bf_32) + br_32. */
193
194 UNCD_DISP10, /* br_16. */
195 UNCD_DISP16, /* br_32. */
196
197 JCOND_DISP10, /* bt/bf_16. */
198 JCOND_DISP16, /* bt/bf_32. */
199 JCOND_DISP32, /* !(bt/bf_32)/jmpi + literal. */
200
201 JUNCD_DISP10, /* br_16. */
202 JUNCD_DISP16, /* br_32. */
203 JUNCD_DISP32, /* jmpi + literal. */
204
205 JCOMPZ_DISP16, /* bez/bnez/bhz/blsz/blz/bhsz. */
206 JCOMPZ_DISP32, /* !(jbez/jbnez/jblsz/jblz/jbhsz) + jmpi + literal. */
207
208 BSR_DISP26, /* bsr_32. */
209
210 LRW_DISP7, /* lrw16. */
211 LRW2_DISP8, /* lrw16, -mno-bsr16,8 bit offset. */
212 LRW_DISP16, /* lrw32. */
213 };
214
215 unsigned int mach_flag = 0;
216 unsigned int arch_flag = 0;
217 unsigned int other_flag = 0;
218 uint64_t isa_flag = 0;
219 unsigned int dsp_flag = 0;
220
221 typedef struct stack_size_entry
222 {
223 struct stack_size_entry *next;
224 symbolS *function;
225 unsigned int stack_size;
226 } stack_size_entry;
227
228 struct csky_arch_info
229 {
230 const char *name;
231 unsigned int arch_flag;
232 unsigned int bfd_mach_flag;
233 };
234
235 typedef enum
236 {
237 INSN_OPCODE,
238 INSN_OPCODE16F,
239 INSN_OPCODE32F,
240 } inst_flag;
241
242 /* Macro information. */
243 struct csky_macro_info
244 {
245 const char *name;
246 /* How many operands : if operands == 5, all of 1,2,3,4 are ok. */
247 long oprnd_num;
248 uint64_t isa_flag;
249 /* Do the work. */
250 void (*handle_func)(void);
251 };
252
253 struct csky_insn_info
254 {
255 /* Name of the opcode. */
256 char *name;
257 /* Output instruction. */
258 unsigned int inst;
259 /* Pointer for frag. */
260 char *output;
261 /* End of instruction. */
262 char *opcode_end;
263 /* CPU infomations. */
264 const struct csky_cpu_info *cpu;
265 /* Flag for INSN_OPCODE16F, INSN_OPCODE32F, INSN_OPCODE, INSN_MACRO. */
266 inst_flag flag_force;
267 /* Operand number. */
268 int number;
269 struct csky_opcode *opcode;
270 struct csky_macro_info *macro;
271 /* Insn size for check_literal. */
272 unsigned int isize;
273 unsigned int last_isize;
274 /* Max size of insn for relax frag_var. */
275 unsigned int max;
276 /* Indicates which element is in csky_opcode_info op[] array. */
277 int opcode_idx;
278 /* The value of each operand in instruction when layout. */
279 int idx;
280 int val[MAX_OPRND_NUM];
281 struct relax_info
282 {
283 int max;
284 int var;
285 int subtype;
286 } relax;
287 /* The following are used for constant expressions. */
288 expressionS e1;
289 expressionS e2;
290 };
291
292 /* Literal pool data structures. */
293 struct literal
294 {
295 unsigned short refcnt;
296 unsigned int offset;
297 unsigned char ispcrel;
298 unsigned char unused;
299 bfd_reloc_code_real_type r_type;
300 expressionS e;
301 struct tls_addend tls_addend;
302 unsigned char isdouble;
303 uint64_t dbnum;
304 LITTLENUM_TYPE bignum[SIZE_OF_LARGE_NUMBER + 6];
305 };
306
307 static void csky_idly (void);
308 static void csky_rolc (void);
309 static void csky_sxtrb (void);
310 static void csky_movtf (void);
311 static void csky_addc64 (void);
312 static void csky_subc64 (void);
313 static void csky_or64 (void);
314 static void csky_xor64 (void);
315 static void csky_neg (void);
316 static void csky_rsubi (void);
317 static void csky_arith (void);
318 static void csky_decne (void);
319 static void csky_lrw (void);
320
321 static enum bfd_reloc_code_real insn_reloc;
322
323 /* Assembler operand parse errors use these identifiers. */
324
325 enum error_number
326 {
327 /* The following are errors. */
328 ERROR_CREG_ILLEGAL = 0,
329 ERROR_REG_OVER_RANGE,
330 ERROR_FREG_OVER_RANGE,
331 ERROR_VREG_OVER_RANGE,
332 ERROR_GREG_ILLEGAL,
333 ERROR_802J_REG_OVER_RANGE,
334 ERROR_REG_FORMAT,
335 ERROR_REG_LIST,
336 ERROR_IMM_ILLEGAL,
337 ERROR_IMM_OVERFLOW, /* 5 */
338 ERROR_IMM_POWER,
339 ERROR_JMPIX_OVER_RANGE,
340 ERROR_EXP_CREG,
341 ERROR_EXP_GREG,
342 ERROR_EXP_CONSTANT,
343 ERROR_EXP_EVEN_FREG,
344 ERROR_RELOC_ILLEGAL,
345 ERROR_MISSING_OPERAND, /* 10 */
346 ERROR_MISSING_COMMA,
347 ERROR_MISSING_LBRACKET,
348 ERROR_MISSING_RBRACKET,
349 ERROR_MISSING_LSQUARE_BRACKETS,
350 ERROR_MISSING_RSQUARE_BRACKETS, /* 15 */
351 ERROR_MISSING_LANGLE_BRACKETS,
352 ERROR_MISSING_RANGLE_BRACKETS,
353 ERROR_OFFSET_UNALIGNED,
354 ERROR_BAD_END,
355 ERROR_UNDEFINE,
356 ERROR_CPREG_ILLEGAL, /* 20 */
357 ERROR_OPCODE_PSRBIT,
358 ERROR_OPERANDS_ILLEGAL,
359 ERROR_OPERANDS_NUMBER,
360 ERROR_OPCODE_ILLEGAL,
361
362 /* The following are warnings. */
363 WARNING_OPTIONS,
364 WARNING_IDLY,
365
366 /* Error and warning end. */
367 ERROR_NONE,
368 };
369
370 /* Global error state. ARG1 and ARG2 are opaque data interpreted
371 as appropriate for the error code. */
372
373 struct csky_error_state
374 {
375 enum error_number err_num;
376 int opnum;
377 int arg_int;
378 const void *arg1;
379 const void *arg2;
380 } error_state;
381
382 /* This macro is used to set error number and arg1 in the global state. */
383
384 #define SET_ERROR_STRING(err, msg) \
385 do { \
386 if (error_state.err_num > err) \
387 { \
388 error_state.err_num = err; \
389 error_state.arg1 = (void *)msg; \
390 } \
391 } while (0)
392
393 #define SET_ERROR_INTEGER(err, integer) \
394 do { \
395 if (error_state.err_num > err) \
396 { \
397 error_state.err_num = err; \
398 error_state.arg_int = integer; \
399 } \
400 } while (0)
401
402 /* Map error identifiers onto a format string, which will use
403 arg1 and arg2 from the global error state. */
404 struct csky_error_format_map
405 {
406 enum error_number num;
407 const char *fmt;
408 };
409
410 static const struct csky_error_format_map err_formats[] =
411 {
412 {ERROR_CREG_ILLEGAL, "Operand %d error: control register is illegal."},
413 {ERROR_REG_OVER_RANGE, "Operand %d error: r%d register is over range."},
414 {ERROR_FREG_OVER_RANGE, "Operand %d error: vr%d register is over range."},
415 {ERROR_VREG_OVER_RANGE, "Operand %d error: vr%d register is out of range."},
416 {ERROR_GREG_ILLEGAL, "Operand %d error: general register is illegal."},
417 {ERROR_802J_REG_OVER_RANGE, "Operand %d register %s out of range (802j only has registers:0-15,23,24,25,30)"},
418 {ERROR_REG_FORMAT, "Operand %d error: %s."},
419 {ERROR_REG_LIST, "Register list format is illegal."},
420 {ERROR_IMM_ILLEGAL, "Operand %d is not an immediate."},
421 {ERROR_IMM_OVERFLOW, "Operand %d immediate is overflow."},
422 {ERROR_IMM_POWER, "immediate %d is not a power of two"},
423 {ERROR_JMPIX_OVER_RANGE, "The second operand must be 16/24/32/40"},
424 {ERROR_EXP_CREG, "Operand %d error: control register is expected."},
425 {ERROR_EXP_GREG, "Operand %d error: general register is expected."},
426 {ERROR_EXP_CONSTANT, "Operand %d error: constant is expected."},
427 {ERROR_EXP_EVEN_FREG, "Operand %d error: even float register is expected."},
428 {ERROR_RELOC_ILLEGAL, "@%s reloc is not supported"},
429 {ERROR_MISSING_OPERAND, "Operand %d is missing."},
430 {ERROR_MISSING_COMMA, "Missing ','"},
431 {ERROR_MISSING_LBRACKET, "Missing '('"},
432 {ERROR_MISSING_RBRACKET, "Missing ')'"},
433 {ERROR_MISSING_LSQUARE_BRACKETS, "Missing '['"},
434 {ERROR_MISSING_RSQUARE_BRACKETS, "Missing ']'"},
435 {ERROR_MISSING_LANGLE_BRACKETS, "Missing '<'"},
436 {ERROR_MISSING_RANGLE_BRACKETS, "Missing '>'"},
437 {ERROR_OFFSET_UNALIGNED, "Operand %d is unaligned. It must be %d aligned!"},
438 {ERROR_BAD_END, "Operands mismatch, it has a bad end: %s"},
439 {ERROR_UNDEFINE, NULL},
440 {ERROR_CPREG_ILLEGAL, "Operand %d illegal, expect a cpreg(cpr0-cpr63)."},
441 {ERROR_OPCODE_PSRBIT, "The operands must be 'ie'/'ee'/'fe'."},
442 {ERROR_OPERANDS_ILLEGAL, "Operands mismatch: %s."},
443 {ERROR_OPERANDS_NUMBER, "Operands number mismatch, %d operands expected."},
444 {ERROR_OPCODE_ILLEGAL, "The instruction is not recognized."},
445 {WARNING_OPTIONS, "Option %s is not support in %s."},
446 {WARNING_IDLY, "idly %d is encoded to: idly 4 "},
447 {ERROR_NONE, "There is no error."},
448 };
449
450 static int do_pic = 0; /* for jbr/jbf/jbt relax jmpi reloc. */
451 static int do_pff = -1; /* for insert two br ahead of literals. */
452 static int do_force2bsr = -1; /* for jbsr->bsr. */
453 static int do_jsri2bsr = 1; /* for jsri->bsr. */
454 static int do_nolrw = 0; /* lrw to movih & ori, only for V2. */
455 static int do_long_jump = -1; /* control if jbf,jbt,jbr relax to jmpi. */
456 static int do_extend_lrw = -1; /* delete bsr16 in both two options,
457 add btesti16, lrw offset +1 in -melrw. */
458 static int do_func_dump = 0; /* dump literals after every function. */
459 static int do_br_dump = 1; /* work for -mabr/-mno-abr, control the literals dump. */
460 static int do_intr_stack = -1; /* control interrupt stack module, 801&802&803
461 default on, 807&810, default off. */
462 static int float_abi = 0;
463
464 #ifdef INCLUDE_BRANCH_STUB
465 static int do_use_branchstub = -1;
466 #else
467 static int do_use_branchstub = 0;
468 #endif
469
470 /* These are only used for options parsing. Values are bitmasks and are
471 OR'ed into the processor flag bits in md_begin. */
472 static int do_opt_mmp = 0;
473 static int do_opt_mcp = 0;
474 static int do_opt_mcache = 0;
475 static int do_opt_msecurity = 0;
476 static int do_opt_mhard_float = 0;
477 static int do_opt_mtrust = 0;
478 static int do_opt_mdsp = 0;
479 static int do_opt_medsp = 0;
480 static int do_opt_mvdsp = 0;
481
482 const relax_typeS *md_relax_table = NULL;
483 struct literal *literal_insn_offset;
484 static struct literal litpool[MAX_POOL_SIZE];
485 static unsigned poolsize = 0;
486 static unsigned poolnumber = 0;
487 static unsigned long poolspan = 0;
488 static unsigned int SPANPANIC;
489 static unsigned int SPANCLOSE;
490 static unsigned int SPANEXIT;
491
492 static stack_size_entry *all_stack_size_data = NULL;
493 static stack_size_entry **last_stack_size_data = &all_stack_size_data;
494
495 /* Control by ".no_literal_dump N"
496 * 1 : don't dump literal pool between insn1 and insnN+1
497 * 0 : do nothing. */
498 static int do_noliteraldump = 0;
499
500 /* Label for current pool. */
501 static symbolS * poolsym;
502 static char poolname[8];
503
504 static bool mov_r1_before;
505 static bool mov_r1_after;
506
507 const relax_typeS csky_relax_table [] =
508 {
509 /* C-SKY V1 relax table. */
510 {0, 0, 0, 0}, /* RELAX_NONE */
511 {0, 0, 0, 0}, /* RELAX_OVERFLOW */
512 {0, 0, 0, 0},
513 {0, 0, 0, 0},
514
515 /* COND_JUMP */
516 { 0, 0, 0, 0 }, /* UNDEF_DISP */
517 { 2048, -2046, C12_LEN, C (COND_JUMP, DISP32) }, /* DISP12 */
518 { 0, 0, C32_LEN, 0 }, /* DISP32 */
519 { 0, 0, C32_LEN, 0 }, /* UNDEF_WORD_DISP */
520
521 /* UNCD_JUMP */
522 { 0, 0, 0, 0 }, /* UNDEF_DISP */
523 { 2048, -2046, U12_LEN, C (UNCD_JUMP, DISP32) }, /* DISP12 */
524 { 0, 0, U32_LEN, 0 }, /* DISP32 */
525 { 0, 0, U32_LEN, 0 }, /* UNDEF_WORD_DISP */
526
527 /* COND_JUMP_PIC */
528 { 0, 0, 0, 0 }, /* UNDEF_DISP */
529 { 2048, -2046, C12_LEN, C (COND_JUMP_PIC, DISP32) }, /* DISP12 */
530 { 0, 0, C32_LEN_PIC, 0 }, /* DISP32 */
531 { 0, 0, C32_LEN_PIC, 0 }, /* UNDEF_WORD_DISP */
532
533 /* UNCD_JUMP_PIC */
534 { 0, 0, 0, 0 }, /* UNDEF_DISP */
535 { 2048, -2046, U12_LEN, C (UNCD_JUMP_PIC, DISP32) }, /* DISP12 */
536 { 0, 0, U32_LEN_PIC, 0 }, /* DISP32 */
537 { 0, 0, U32_LEN_PIC, 0 }, /* UNDEF_WORD_DISP */
538
539 /* C-SKY V2 relax table. */
540 /* forward backward length more */
541 { 1 KB - 2, -1 KB, COND_DISP10_LEN, COND_DISP16 }, /* COND_DISP10 */
542 { 64 KB - 2, -64 KB, COND_DISP16_LEN, RELAX_OVERFLOW }, /* COND_DISP16 */
543
544 { 1 KB - 2, -1 KB, SCOND_DISP10_LEN, SCOND_DISP16 }, /* SCOND_DISP10 */
545 { 64 KB - 2, -64 KB, SCOND_DISP16_LEN, RELAX_OVERFLOW }, /* SCOND_DISP16 */
546
547 { 1 KB - 2, -1 KB, UNCD_DISP10_LEN, UNCD_DISP16 }, /* UNCD_DISP10 */
548 { 64 KB - 2, -64 KB, UNCD_DISP16_LEN, RELAX_OVERFLOW }, /* UNCD_DISP16 */
549
550 { 1 KB - 2, -1 KB, JCOND_DISP10_LEN, JCOND_DISP16 }, /* JCOND_DISP10 */
551 { 64 KB - 2, -64 KB, JCOND_DISP16_LEN, JCOND_DISP32 }, /* JCOND_DISP16 */
552 { 0, 0, JCOND_DISP32_LEN, RELAX_NONE }, /* JCOND_DISP32 */
553
554 { 1 KB - 2, -1 KB, JUNCD_DISP10_LEN, JUNCD_DISP16 }, /* JUNCD_DISP10 */
555 { 64 KB - 2, -64 KB, JUNCD_DISP16_LEN, JUNCD_DISP32 }, /* JUNCD_DISP16 */
556 { 0, 0, JUNCD_DISP32_LEN, RELAX_NONE }, /* JUNCD_DISP32 */
557
558 { 64 KB - 2, -64 KB, JCOMPZ_DISP16_LEN, JCOMPZ_DISP32 }, /* JCOMPZ_DISP16 */
559 { 0, 0, JCOMPZ_DISP32_LEN, RELAX_NONE }, /* JCOMPZ_DISP32 */
560
561 { 64 MB - 2, -64 MB, BSR_DISP26_LEN, RELAX_OVERFLOW }, /* BSR_DISP26 */
562
563 { 508, 0, LRW_DISP7_LEN, LRW_DISP16 }, /* LRW_DISP7 */
564 { 1016, 0, LRW_DISP7_LEN, LRW_DISP16 }, /* LRW2_DISP8 */
565 { 64 KB, 0, LRW_DISP16_LEN, RELAX_OVERFLOW }, /* LRW_DISP16 */
566
567 };
568
569 static void csky_write_insn (char *ptr, valueT use, int nbytes);
570 void md_number_to_chars (char * buf, valueT val, int n);
571 long md_pcrel_from_section (fixS * fixP, segT seg);
572
573 /* C-SKY architecture table. */
574 const struct csky_arch_info csky_archs[] =
575 {
576 {"ck510", CSKY_ARCH_510, bfd_mach_ck510},
577 {"ck610", CSKY_ARCH_610, bfd_mach_ck610},
578 {"ck801", CSKY_ARCH_801, bfd_mach_ck801},
579 {"ck802", CSKY_ARCH_802, bfd_mach_ck802},
580 {"ck803", CSKY_ARCH_803, bfd_mach_ck803},
581 {"ck807", CSKY_ARCH_807, bfd_mach_ck807},
582 {"ck810", CSKY_ARCH_810, bfd_mach_ck810},
583 {"ck860", CSKY_ARCH_860, bfd_mach_ck860},
584 {NULL, 0, 0}
585 };
586
587 #define CSKY_ARCH_807_BASE CSKY_ARCH_807 | CSKY_ARCH_DSP
588 #define CSKY_ARCH_810_BASE CSKY_ARCH_810 | CSKY_ARCH_DSP
589
590 struct csky_cpu_feature
591 {
592 const char unique;
593 unsigned int arch_flag;
594 uint64_t isa_flag;
595 };
596
597 struct csky_cpu_version
598 {
599 int r;
600 int p;
601 uint64_t isa_flag;
602 };
603
604 #define CSKY_FEATURE_MAX 10
605 #define CSKY_CPU_REVERISON_MAX 10
606
607 struct csky_cpu_info
608 {
609 const char *name;
610 unsigned int arch_flag;
611 uint64_t isa_flag;
612 struct csky_cpu_feature features[CSKY_FEATURE_MAX];
613 struct csky_cpu_version ver[CSKY_CPU_REVERISON_MAX];
614 };
615
616 #define FEATURE_DSP_EXT(isa) \
617 {'e', CSKY_ARCH_DSP, isa}
618 #define FEATURE_DSP(isa) \
619 {'d', CSKY_ARCH_DSP, isa}
620 #define FEATURE_MMU() \
621 {'m', 0, 0}
622 #define FEATURE_VDSP(isa) \
623 {'v', CSKY_ARCH_DSP, isa}
624 #define FEATURE_FLOAT(isa) \
625 {'f', CSKY_ARCH_FLOAT, isa}
626 #define FEATURE_TRUST(isa) \
627 {'t', 0, isa}
628 #define FEATURE_JAVA(isa) \
629 {'j', CSKY_ARCH_JAVA, isa}
630 #define FEATURE_SHIELD(isa) \
631 {'h', 0, isa}
632
633
634 #define CSKY_FEATURES_DEF_NULL() \
635 {{0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}}
636
637 #define CSKY_FEATURES_DEF_e(isa_e) \
638 {FEATURE_DSP_EXT(isa_e), \
639 {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}}
640
641 #define CSKY_FEATURES_DEF_t(isa_t) \
642 {FEATURE_TRUST(isa_t), \
643 {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}}
644
645 #define CSKY_FEATURES_DEF_f(isa_f) \
646 {FEATURE_FLOAT(isa_f), \
647 {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}}
648
649 #define CSKY_FEATURES_DEF_v(isa_v) \
650 {FEATURE_VDSP(isa_v), \
651 {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}}
652
653 #define CSKY_FEATURES_DEF_ef(isa_e, isa_f) \
654 {FEATURE_DSP_EXT(isa_e), \
655 FEATURE_FLOAT(isa_f), \
656 {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}}
657
658 #define CSKY_FEATURES_DEF_jt(isa_j, isa_t) \
659 {FEATURE_JAVA(isa_j), \
660 FEATURE_TRUST(isa_t), \
661 {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}}
662
663 #define CSKY_FEATURES_DEF_efht(isa_e, isa_f, isa_h, isa_t) \
664 {FEATURE_DSP_EXT(isa_e), \
665 FEATURE_FLOAT(isa_f), \
666 FEATURE_SHIELD(isa_h), \
667 FEATURE_TRUST(isa_t), \
668 {0}, {0}, {0}, {0}, {0}, {0}}
669
670 #define CSKY_FEATURES_DEF_efv(isa_e, isa_f, isa_v) \
671 {FEATURE_DSP_EXT(isa_e), \
672 FEATURE_FLOAT(isa_f), \
673 FEATURE_VDSP(isa_v), \
674 {0}, {0}, {0}, {0}, {0}, {0}, {0}}
675
676 #define CSKY_FEATURES_DEF_eft(isa_e, isa_f, isa_t) \
677 {FEATURE_DSP_EXT(isa_e), \
678 FEATURE_FLOAT(isa_f), \
679 FEATURE_TRUST(isa_t), \
680 {0}, {0}, {0}, {0}, {0}, {0}, {0}}
681
682 #define CSKY_FEATURES_DEF_d(isa_d) \
683 {FEATURE_DSP(isa_d), \
684 {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}}
685
686 #define CSKY_FEATURES_DEF_df(isa_d, isa_f) \
687 {FEATURE_DSP(isa_d), \
688 FEATURE_FLOAT(isa_f), \
689 {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}}
690
691 #define CSKY_FEATURES_DEF_ft(isa_f, isa_t) \
692 {FEATURE_FLOAT(isa_f), \
693 FEATURE_TRUST(isa_t), \
694 {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}}
695
696 #define CSKY_FEATURES_DEF_tv(isa_t, isa_v) \
697 {FEATURE_TRUST(isa_t), \
698 FEATURE_VDSP(isa_v), \
699 {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}}
700
701 #define CSKY_FEATURES_DEF_fv(isa_f, isa_v) \
702 {FEATURE_FLOAT(isa_f), \
703 FEATURE_VDSP(isa_v), \
704 {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}}
705
706
707 #define CSKY_FEATURES_DEF_dft(isa_d, isa_f, isa_t) \
708 {FEATURE_DSP(isa_d), \
709 FEATURE_FLOAT(isa_f), \
710 FEATURE_TRUST(isa_t), \
711 {0}, {0}, {0}, {0}, {0}, {0}, {0}}
712
713 #define CSKY_FEATURES_DEF_dfv(isa_d, isa_f, isa_v) \
714 {FEATURE_DSP(isa_d), \
715 FEATURE_FLOAT(isa_f), \
716 FEATURE_VDSP(isa_v), \
717 {0}, {0}, {0}, {0}, {0}, {0}, {0}}
718
719 #define CSKY_FEATURES_DEF_ftv(isa_f, isa_t, isa_v) \
720 {FEATURE_FLOAT(isa_f), \
721 FEATURE_TRUST(isa_t), \
722 FEATURE_VDSP(isa_v), \
723 {0}, {0}, {0}, {0}, {0}, {0}, {0}}
724
725 #define CSKY_FEATURES_DEF_eftv(isa_e, isa_f, isa_t, isa_v) \
726 {FEATURE_DSP_EXT(isa_e), \
727 FEATURE_FLOAT(isa_f), \
728 FEATURE_TRUST(isa_t), \
729 FEATURE_VDSP(isa_v), \
730 {0}, {0}, {0}, {0}, {0}, {0}}
731
732
733 #define CSKY_CPU_REVERISON_r0p0(isa) \
734 {0, 0, 0}
735 #define CSKY_CPU_REVERISON_r1p0(isa) \
736 {1, 0, isa}
737 #define CSKY_CPU_REVERISON_r2p0(isa) \
738 {2, 0, isa}
739 #define CSKY_CPU_REVERISON_r3p0(isa) \
740 {3, 0, isa}
741
742 #define CSKY_CPU_REVERISON_RESERVED() \
743 {{0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}}
744
745 #define CSKY_CPU_REVERISON_R3(isa1, isa2, isa3) \
746 {CSKY_CPU_REVERISON_r1p0(isa1), \
747 CSKY_CPU_REVERISON_r2p0(isa2), \
748 CSKY_CPU_REVERISON_r3p0(isa3), \
749 {0}, {0}, {0}, {0}, {0}, {0}, {0}}
750
751 /* CSKY cpus table. */
752 const struct csky_cpu_info csky_cpus[] =
753 {
754 #define CSKYV1_ISA_DSP (CSKY_ISA_DSP | CSKY_ISA_MAC_DSP)
755 #define CSKY_ISA_510 (CSKYV1_ISA_E1)
756 #define CSKY_ISA_610 (CSKYV1_ISA_E1 | CSKY_ISA_CP)
757 {"ck510",
758 CSKY_ARCH_510,
759 CSKY_ISA_510,
760 CSKY_FEATURES_DEF_e(CSKYV1_ISA_DSP),
761 CSKY_CPU_REVERISON_RESERVED()},
762 {"ck520",
763 CSKY_ARCH_510 | CSKY_ARCH_MAC,
764 CSKY_ISA_510 | CSKY_ISA_MAC | CSKY_ISA_MAC_DSP,
765 CSKY_FEATURES_DEF_NULL(),
766 CSKY_CPU_REVERISON_RESERVED()},
767 {"ck610", CSKY_ARCH_610, CSKY_ISA_610,
768 CSKY_FEATURES_DEF_ef(CSKYV1_ISA_DSP, CSKY_ISA_FLOAT_E1),
769 CSKY_CPU_REVERISON_RESERVED()},
770 {"ck620",
771 CSKY_ARCH_610 | CSKY_ARCH_MAC,
772 CSKY_ISA_610 | CSKY_ISA_MAC | CSKY_ISA_MAC_DSP,
773 CSKY_FEATURES_DEF_NULL(),
774 CSKY_CPU_REVERISON_RESERVED()},
775
776 #define CSKY_ISA_801 (CSKYV2_ISA_E1 | CSKY_ISA_TRUST)
777 #define CSKYV2_ISA_DSP (CSKY_ISA_DSP | CSKY_ISA_DSP_1E2 | CSKY_ISA_DSPE60)
778 {"ck801",
779 CSKY_ARCH_801,
780 CSKY_ISA_801,
781 CSKY_FEATURES_DEF_t(0),
782 CSKY_CPU_REVERISON_RESERVED()},
783 #define CSKY_ISA_802 (CSKY_ISA_801 | CSKYV2_ISA_1E2 | CSKY_ISA_NVIC)
784 {"ck802",
785 CSKY_ARCH_802,
786 CSKY_ISA_802,
787 CSKY_FEATURES_DEF_jt(CSKY_ISA_JAVA, 0),
788 CSKY_CPU_REVERISON_RESERVED()},
789 #define CSKY_ISA_803 (CSKY_ISA_802 | CSKYV2_ISA_2E3 | CSKY_ISA_MP)
790 #define CSKY_ISA_803R1 (CSKYV2_ISA_3E3R1)
791 #define CSKY_ISA_803R2 (CSKYV2_ISA_3E3R1 | CSKYV2_ISA_3E3R2)
792 #define CSKY_ISA_803R3 (CSKYV2_ISA_3E3R1 | CSKYV2_ISA_3E3R2 | CSKYV2_ISA_3E3R3)
793 #define CSKY_ISA_FLOAT_803 (CSKY_ISA_FLOAT_E1 | CSKY_ISA_FLOAT_1E3)
794 #define CSKY_ISA_EDSP (CSKYV2_ISA_3E3R1 | CSKYV2_ISA_3E3R3 | CSKY_ISA_DSP_ENHANCE)
795 {"ck803s",
796 CSKY_ARCH_803,
797 CSKY_ISA_803 | CSKY_ISA_803R1,
798 CSKY_FEATURES_DEF_eft(CSKYV2_ISA_DSP, CSKY_ISA_FLOAT_803, 0),
799 CSKY_CPU_REVERISON_RESERVED()},
800 {"ck803",
801 CSKY_ARCH_803,
802 CSKY_ISA_803,
803 CSKY_FEATURES_DEF_efht(CSKYV2_ISA_DSP, CSKY_ISA_FLOAT_803, 0, 0),
804 CSKY_CPU_REVERISON_R3(CSKY_ISA_803R1, CSKY_ISA_803R2, CSKY_ISA_803R3)},
805 #define CSKY_ISA_804 (CSKY_ISA_803 | CSKY_ISA_803R3)
806 {"ck804",
807 CSKY_ARCH_804,
808 CSKY_ISA_804,
809 CSKY_FEATURES_DEF_efht(CSKY_ISA_EDSP, CSKY_ISA_FLOAT_803, 0, 0),
810 CSKY_CPU_REVERISON_RESERVED()},
811 #define CSKY_ISA_805 (CSKY_ISA_804 | CSKY_ISA_VDSP_2)
812 #define CSKY_ARCH_805V (CSKY_ARCH_805 | CSKY_ARCH_DSP)
813 #define CSKY_ISA_FLOAT_805 CSKY_ISA_FLOAT_803
814 {"ck805",
815 CSKY_ARCH_805,
816 CSKY_ISA_805,
817 CSKY_FEATURES_DEF_eft(CSKY_ISA_EDSP, CSKY_ISA_FLOAT_805, 0),
818 CSKY_CPU_REVERISON_RESERVED()},
819 #define CSKY_ISA_807 (CSKY_ISA_803 | CSKYV2_ISA_3E7 | CSKY_ISA_MP_1E2 | CSKY_ISA_CACHE | CSKYV2_ISA_DSP)
820 #define CSKY_ISA_FLOAT_807 (CSKY_ISA_FLOAT_803 | CSKY_ISA_FLOAT_3E4 | CSKY_ISA_FLOAT_1E2)
821 {"ck807",
822 CSKY_ARCH_807,
823 CSKY_ISA_807,
824 CSKY_FEATURES_DEF_ef(CSKYV2_ISA_DSP, CSKY_ISA_FLOAT_807),
825 CSKY_CPU_REVERISON_RESERVED()},
826 #define CSKY_ISA_810 (CSKY_ISA_807 | CSKYV2_ISA_7E10)
827 #define CSKY_ISA_FLOAT_810 (CSKY_ISA_FLOAT_E1 | CSKY_ISA_FLOAT_1E2)
828 {"ck810v",
829 CSKY_ARCH_810 | CSKY_ARCH_DSP,
830 CSKY_ISA_810 | CSKY_ISA_VDSP,
831 CSKY_FEATURES_DEF_NULL (),
832 CSKY_CPU_REVERISON_RESERVED()},
833 {"ck810",
834 CSKY_ARCH_810,
835 CSKY_ISA_810,
836 CSKY_FEATURES_DEF_eftv(0, CSKY_ISA_FLOAT_810, 0, CSKY_ISA_VDSP),
837 CSKY_CPU_REVERISON_RESERVED()},
838 #define CSKY_ISA_860 ((CSKY_ISA_810 & ~(CSKYV2_ISA_DSP)) | CSKYV2_ISA_10E60 | CSKY_ISA_803R3 | CSKY_ISA_DSPE60)
839 #define CSKY_ISA_860F (CSKY_ISA_860 | CSKY_ISA_FLOAT_7E60)
840 #define CSKY_ISA_VDSP_860 (CSKY_ISA_VDSP_2)
841 {"ck860v",
842 CSKY_ARCH_860 | CSKY_ARCH_DSP,
843 CSKY_ISA_860 | CSKY_ISA_VDSP_860,
844 CSKY_FEATURES_DEF_f(CSKY_ISA_FLOAT_7E60),
845 CSKY_CPU_REVERISON_RESERVED()},
846 {"ck860",
847 CSKY_ARCH_860,
848 CSKY_ISA_860,
849 CSKY_FEATURES_DEF_fv(CSKY_ISA_FLOAT_7E60, CSKY_ISA_VDSP_860),
850 CSKY_CPU_REVERISON_RESERVED()},
851
852 /* It is a special cpu, support all instructions. */
853 #define CSKY_ISA_800 (CSKY_ISA_860 | CSKY_ISA_810 | CSKY_ISA_807 | CSKY_ISA_803)
854 {"ck800",
855 CSKY_ARCH_800,
856 CSKY_ISA_800,
857 CSKY_FEATURES_DEF_NULL(),
858 CSKY_CPU_REVERISON_RESERVED()},
859
860
861 #define CSKY_ISA_E801 (CSKY_ISA_801)
862 #define CSKY_ISA_E802 (CSKY_ISA_E801 | CSKYV2_ISA_1E2 | CSKY_ISA_NVIC)
863 #define CSKY_ISA_E803 (CSKY_ISA_E802 | CSKYV2_ISA_2E3 | CSKY_ISA_MP | CSKYV2_ISA_3E3R1 | CSKYV2_ISA_3E3R2 | CSKYV2_ISA_3E3R3)
864 #define CSKY_ISA_E804 (CSKY_ISA_E803)
865 #define CSKY_ISA_FLOAT_V1 (CSKY_ISA_FLOAT_E1 | CSKY_ISA_FLOAT_1E3)
866 {"e801",
867 CSKY_ARCH_801,
868 CSKY_ISA_E801,
869 CSKY_FEATURES_DEF_NULL(),
870 CSKY_CPU_REVERISON_RESERVED()},
871 {"e802",
872 CSKY_ARCH_802,
873 CSKY_ISA_E802,
874 CSKY_FEATURES_DEF_t(0),
875 CSKY_CPU_REVERISON_RESERVED()},
876 {"e803",
877 CSKY_ARCH_803,
878 CSKY_ISA_E803,
879 CSKY_FEATURES_DEF_t(0),
880 CSKY_CPU_REVERISON_RESERVED()},
881 {"e804",
882 CSKY_ARCH_804,
883 CSKY_ISA_E804,
884 CSKY_FEATURES_DEF_dft(CSKY_ISA_EDSP, CSKY_ISA_FLOAT_V1, 0),
885 CSKY_CPU_REVERISON_RESERVED()},
886
887 #define CSKY_ISA_S802 (CSKY_ISA_E801 | CSKYV2_ISA_1E2 | CSKY_ISA_NVIC | CSKY_ISA_TRUST)
888 #define CSKY_ISA_S803 (CSKY_ISA_S802 | CSKYV2_ISA_2E3 | CSKY_ISA_MP | CSKYV2_ISA_3E3R1 | CSKYV2_ISA_3E3R2 | CSKYV2_ISA_3E3R3)
889 {"s802",
890 CSKY_ARCH_802,
891 CSKY_ISA_S802,
892 CSKY_FEATURES_DEF_t(0),
893 CSKY_CPU_REVERISON_RESERVED()},
894 {"s803",
895 CSKY_ARCH_803,
896 CSKY_ISA_S803,
897 CSKY_FEATURES_DEF_t(0),
898 CSKY_CPU_REVERISON_RESERVED()},
899 #define CSKY_ISA_I805 (CSKY_ISA_S803)
900 {"i805",
901 CSKY_ARCH_805 | CSKY_ARCH_DSP,
902 CSKY_ISA_I805 | CSKY_ISA_VDSP_2,
903 CSKY_FEATURES_DEF_ft(CSKY_ISA_FLOAT_V1, 0),
904 CSKY_CPU_REVERISON_RESERVED()},
905 #define CSKYV2_ISA_DSP (CSKY_ISA_DSP | CSKY_ISA_DSP_1E2 | CSKY_ISA_DSPE60)
906 #define CSKY_ISA_C807 (CSKY_ISA_E802 | CSKYV2_ISA_2E3 | CSKY_ISA_MP | CSKYV2_ISA_3E7 | CSKY_ISA_MP_1E2 | CSKY_ISA_CACHE | CSKYV2_ISA_DSP)
907 #define CSKY_ISA_FLOAT_C807 (CSKY_ISA_FLOAT_V1 | CSKY_ISA_FLOAT_3E4 | CSKY_ISA_FLOAT_1E2)
908 #define CSKY_ISA_FLOAT_C810 (CSKY_ISA_FLOAT_E1 | CSKY_ISA_FLOAT_1E2)
909 #define CSKY_ARCH_C810 (CSKY_ARCH_810 | CSKY_ARCH_FLOAT)
910 #define CSKY_ISA_C810 (CSKY_ISA_C807 | CSKYV2_ISA_7E10 | CSKY_ISA_FLOAT_C810)
911 #define CSKY_ARCH_C860 (CSKY_ARCH_860 | CSKY_ARCH_FLOAT)
912 #define CSKY_ISA_C860 (CSKY_ISA_860 | CSKY_ISA_FLOAT_7E60)
913 {"c807",
914 CSKY_ARCH_807,
915 CSKY_ISA_C807,
916 CSKY_FEATURES_DEF_fv(CSKY_ISA_FLOAT_C807, CSKY_ISA_VDSP),
917 CSKY_CPU_REVERISON_RESERVED()},
918 {"c810",
919 CSKY_ARCH_C810,
920 CSKY_ISA_C810,
921 CSKY_FEATURES_DEF_tv(0, CSKY_ISA_VDSP),
922 CSKY_CPU_REVERISON_RESERVED()},
923 {"c860",
924 CSKY_ARCH_C860,
925 CSKY_ISA_C860,
926 CSKY_FEATURES_DEF_v(CSKY_ISA_VDSP_2),
927 CSKY_CPU_REVERISON_RESERVED()},
928 #define CSKY_ISA_R807 (CSKY_ISA_E802 | CSKYV2_ISA_2E3 | CSKY_ISA_MP | CSKYV2_ISA_3E7 | CSKY_ISA_MP_1E2 | CSKY_ISA_CACHE | CSKYV2_ISA_DSP)
929 #define CSKY_ISA_FLOAT_R807 (CSKY_ISA_FLOAT_V1 | CSKY_ISA_FLOAT_3E4 | CSKY_ISA_FLOAT_1E2)
930 {"r807",
931 CSKY_ARCH_807,
932 CSKY_ISA_R807,
933 CSKY_FEATURES_DEF_f(CSKY_ISA_FLOAT_R807),
934 CSKY_CPU_REVERISON_RESERVED()},
935
936 /* Start of private CPUs. */
937 /* End of private CPUs. */
938
939 {NULL},
940 };
941
942 int md_short_jump_size = 2;
943 int md_long_jump_size = 4;
944
945 /* This array holds the chars that always start a comment. If the
946 pre-processor is disabled, these aren't very useful. */
947 const char comment_chars[] = "#";
948
949 /* This array holds the chars that only start a comment at the beginning of
950 a line. If the line seems to have the form '# 123 filename'
951 .line and .file directives will appear in the pre-processed output. */
952 /* Note that input_file.c hand checks for '#' at the beginning of the
953 first line of the input file. This is because the compiler outputs
954 #NO_APP at the beginning of its output. */
955 /* Also note that comments like this one will always work. */
956 const char line_comment_chars[] = "#";
957
958 const char line_separator_chars[] = ";";
959
960 /* Chars that can be used to separate mant
961 from exp in floating point numbers. */
962 const char EXP_CHARS[] = "eE";
963
964 /* Chars that mean this number is a floating point constant.
965 As in 0f12.456
966 or 0d1.2345e12 */
967
968 const char FLT_CHARS[] = "rRsSfFdDxXeEpP";
969
970 const char *md_shortopts = "";
971
972 struct option md_longopts[] = {
973 #define OPTION_MARCH (OPTION_MD_BASE + 0)
974 {"march", required_argument, NULL, OPTION_MARCH},
975 #define OPTION_MCPU (OPTION_MD_BASE + 1)
976 {"mcpu", required_argument, NULL, OPTION_MCPU},
977 #define OPTION_FLOAT_ABI (OPTION_MD_BASE + 2)
978 {"mfloat-abi", required_argument, NULL, OPTION_FLOAT_ABI},
979
980 /* Remaining options just set boolean flags. */
981 {"EL", no_argument, &target_big_endian, 0},
982 {"mlittle-endian", no_argument, &target_big_endian, 0},
983 {"EB", no_argument, &target_big_endian, 1},
984 {"mbig-endian", no_argument, &target_big_endian, 1},
985 {"fpic", no_argument, &do_pic, 1},
986 {"pic", no_argument, &do_pic, 1},
987 {"mljump", no_argument, &do_long_jump, 1},
988 {"mno-ljump", no_argument, &do_long_jump, 0},
989 {"force2bsr", no_argument, &do_force2bsr, 1},
990 {"mforce2bsr", no_argument, &do_force2bsr, 1},
991 {"no-force2bsr", no_argument, &do_force2bsr, 0},
992 {"mno-force2bsr", no_argument, &do_force2bsr, 0},
993 {"jsri2bsr", no_argument, &do_jsri2bsr, 1},
994 {"mjsri2bsr", no_argument, &do_jsri2bsr, 1},
995 {"no-jsri2bsr", no_argument, &do_jsri2bsr, 0},
996 {"mno-jsri2bsr", no_argument, &do_jsri2bsr, 0},
997 {"mnolrw", no_argument, &do_nolrw, 1},
998 {"mno-lrw", no_argument, &do_nolrw, 1},
999 {"melrw", no_argument, &do_extend_lrw, 1},
1000 {"mno-elrw", no_argument, &do_extend_lrw, 0},
1001 {"mlaf", no_argument, &do_func_dump, 1},
1002 {"mliterals-after-func", no_argument, &do_func_dump, 1},
1003 {"mno-laf", no_argument, &do_func_dump, 0},
1004 {"mno-literals-after-func", no_argument, &do_func_dump, 0},
1005 {"mlabr", no_argument, &do_br_dump, 1},
1006 {"mliterals-after-br", no_argument, &do_br_dump, 1},
1007 {"mno-labr", no_argument, &do_br_dump, 0},
1008 {"mnoliterals-after-br", no_argument, &do_br_dump, 0},
1009 {"mistack", no_argument, &do_intr_stack, 1},
1010 {"mno-istack", no_argument, &do_intr_stack, 0},
1011 #ifdef INCLUDE_BRANCH_STUB
1012 {"mbranch-stub", no_argument, &do_use_branchstub, 1},
1013 {"mno-branch-stub", no_argument, &do_use_branchstub, 0},
1014 #endif
1015 {"mhard-float", no_argument, &do_opt_mhard_float, CSKY_ARCH_FLOAT},
1016 {"mmp", no_argument, &do_opt_mmp, CSKY_ARCH_MP},
1017 {"mcp", no_argument, &do_opt_mcp, CSKY_ARCH_CP},
1018 {"mcache", no_argument, &do_opt_mcache, CSKY_ARCH_CACHE},
1019 {"msecurity", no_argument, &do_opt_msecurity, CSKY_ARCH_MAC},
1020 {"mtrust", no_argument, &do_opt_mtrust, CSKY_ISA_TRUST},
1021 {"mdsp", no_argument, &do_opt_mdsp, CSKY_DSP_FLAG_V1},
1022 {"medsp", no_argument, &do_opt_medsp, CSKY_DSP_FLAG_V2},
1023 {"mvdsp", no_argument, &do_opt_mvdsp, CSKY_ISA_VDSP},
1024 };
1025
1026 size_t md_longopts_size = sizeof (md_longopts);
1027
1028 static struct csky_insn_info csky_insn;
1029
1030 static htab_t csky_opcodes_hash;
1031 static htab_t csky_macros_hash;
1032
1033 static struct csky_macro_info v1_macros_table[] =
1034 {
1035 {"idly", 1, CSKYV1_ISA_E1, csky_idly},
1036 {"rolc", 2, CSKYV1_ISA_E1, csky_rolc},
1037 {"rotlc", 2, CSKYV1_ISA_E1, csky_rolc},
1038 {"sxtrb0", 2, CSKYV1_ISA_E1, csky_sxtrb},
1039 {"sxtrb1", 2, CSKYV1_ISA_E1, csky_sxtrb},
1040 {"sxtrb2", 2, CSKYV1_ISA_E1, csky_sxtrb},
1041 {"movtf", 3, CSKYV1_ISA_E1, csky_movtf},
1042 {"addc64", 3, CSKYV1_ISA_E1, csky_addc64},
1043 {"subc64", 3, CSKYV1_ISA_E1, csky_subc64},
1044 {"or64", 3, CSKYV1_ISA_E1, csky_or64},
1045 {"xor64", 3, CSKYV1_ISA_E1, csky_xor64},
1046 {NULL,0,0,0}
1047 };
1048
1049 static struct csky_macro_info v2_macros_table[] =
1050 {
1051 {"neg", 1, CSKYV2_ISA_E1, csky_neg},
1052 {"rsubi", 2, CSKYV2_ISA_1E2, csky_rsubi},
1053 {"incf", 1, CSKYV2_ISA_1E2, csky_arith},
1054 {"inct", 1, CSKYV2_ISA_1E2, csky_arith},
1055 {"decf", 1, CSKYV2_ISA_2E3, csky_arith},
1056 {"decgt", 1, CSKYV2_ISA_2E3, csky_arith},
1057 {"declt", 1, CSKYV2_ISA_2E3, csky_arith},
1058 {"decne", 1, CSKYV2_ISA_1E2, csky_decne},
1059 {"dect", 1, CSKYV2_ISA_1E2, csky_arith},
1060 {"lslc", 1, CSKYV2_ISA_1E2, csky_arith},
1061 {"lsrc", 1, CSKYV2_ISA_1E2, csky_arith},
1062 {"xsr", 1, CSKYV2_ISA_1E2, csky_arith},
1063 {NULL,0,0,0}
1064 };
1065
1066 /* For option -mnolrw, replace lrw by movih & ori. */
1067 static struct csky_macro_info v2_lrw_macro_opcode =
1068 {"lrw", 2, CSKYV2_ISA_1E2, csky_lrw};
1069
1070 /* This function is used to show errors or warnings. */
1071
1072 static void
1073 csky_show_error (enum error_number err, int idx, void *arg1, void *arg2)
1074 {
1075 if (err == ERROR_NONE)
1076 return;
1077
1078 switch (err)
1079 {
1080 case ERROR_REG_LIST:
1081 case ERROR_OPCODE_PSRBIT:
1082 case ERROR_OPCODE_ILLEGAL:
1083 case ERROR_JMPIX_OVER_RANGE:
1084 case ERROR_MISSING_COMMA:
1085 case ERROR_MISSING_LBRACKET:
1086 case ERROR_MISSING_RBRACKET:
1087 case ERROR_MISSING_LSQUARE_BRACKETS:
1088 case ERROR_MISSING_RSQUARE_BRACKETS:
1089 case ERROR_MISSING_LANGLE_BRACKETS:
1090 case ERROR_MISSING_RANGLE_BRACKETS:
1091 /* Add NULL to fix warnings. */
1092 as_bad (_(err_formats[err].fmt), NULL);
1093 break;
1094 case ERROR_CREG_ILLEGAL:
1095 case ERROR_GREG_ILLEGAL:
1096 case ERROR_IMM_ILLEGAL:
1097 case ERROR_IMM_OVERFLOW:
1098 case ERROR_EXP_CREG:
1099 case ERROR_EXP_GREG:
1100 case ERROR_EXP_CONSTANT:
1101 case ERROR_EXP_EVEN_FREG:
1102 case ERROR_MISSING_OPERAND:
1103 case ERROR_CPREG_ILLEGAL:
1104 as_bad (_(err_formats[err].fmt), idx);
1105 break;
1106 case ERROR_OPERANDS_NUMBER:
1107 case ERROR_IMM_POWER:
1108 as_bad (_(err_formats[err].fmt), error_state.arg_int);
1109 break;
1110
1111 case ERROR_OFFSET_UNALIGNED:
1112 as_bad (_(err_formats[err].fmt), idx, error_state.arg_int);
1113 break;
1114 case ERROR_RELOC_ILLEGAL:
1115 case ERROR_BAD_END:
1116 case ERROR_OPERANDS_ILLEGAL:
1117 as_bad (_(err_formats[err].fmt), (char *)arg1);
1118 break;
1119 case ERROR_REG_OVER_RANGE:
1120 case ERROR_FREG_OVER_RANGE:
1121 case ERROR_VREG_OVER_RANGE:
1122 as_bad (_(err_formats[err].fmt), idx, error_state.arg_int);
1123 break;
1124 case ERROR_802J_REG_OVER_RANGE:
1125 case ERROR_REG_FORMAT:
1126 as_bad (_(err_formats[err].fmt), idx, (char *)arg1);
1127 break;
1128 case ERROR_UNDEFINE:
1129 /* Add NULL to fix warnings. */
1130 as_bad ((char *)arg1, NULL);
1131 break;
1132 case WARNING_IDLY:
1133 as_warn (_(err_formats[err].fmt), (long)arg1);
1134 break;
1135 case WARNING_OPTIONS:
1136 as_warn (_(err_formats[err].fmt), (char *)arg1, (char *)arg2);
1137 break;
1138 default:
1139 break;
1140 }
1141 }
1142
1143 /* Handle errors in branch relaxation. */
1144
1145 static void
1146 csky_branch_report_error (const char* file, unsigned int line,
1147 symbolS* sym, offsetT val)
1148 {
1149 as_bad_where (file ? file : _("unknown"),
1150 line,
1151 _("pcrel offset for branch to %s too far (0x%lx)"),
1152 sym ? S_GET_NAME (sym) : _("<unknown>"),
1153 (long) val);
1154 }
1155
1156 /* Set appropriate flags for the cpu matching STR. */
1157
1158 static void
1159 parse_cpu (const char *str)
1160 {
1161 int i = 0;
1162
1163 for (; csky_cpus[i].name != NULL; i++)
1164 if (strncasecmp (str, csky_cpus[i].name, strlen (csky_cpus[i].name)) == 0)
1165 {
1166 csky_insn.cpu = &csky_cpus[i];
1167 mach_flag |= csky_cpus[i].arch_flag;
1168 isa_flag = csky_cpus[i].isa_flag;
1169 const char *s = str + strlen (csky_cpus[i].name);
1170 while (*s)
1171 {
1172 const struct csky_cpu_feature *feature = csky_cpus[i].features;
1173 const struct csky_cpu_version *version = csky_cpus[i].ver;
1174 char *next;
1175
1176 if (*s == 'r')
1177 {
1178 s++;
1179 while (version->r)
1180 {
1181 if (version->r == strtol (s, &next, 10))
1182 break;
1183 version++;
1184 }
1185 if (version->r)
1186 {
1187 isa_flag |= version->isa_flag;
1188 s = next;
1189 }
1190 else
1191 goto unknown_cpu;
1192 isa_flag = isa_flag & ~CSKYV2_ISA_DSP;
1193 isa_flag |= CSKY_ISA_EDSP;
1194 continue;
1195 }
1196
1197 /* Parse csky features. */
1198 while (feature->unique)
1199 {
1200 if (feature->unique == *s)
1201 break;
1202 feature++;
1203 }
1204 if (feature->unique)
1205 {
1206 isa_flag |= feature->isa_flag;
1207 mach_flag |= feature->arch_flag;
1208 }
1209 else
1210 goto unknown_cpu;
1211
1212 s++;
1213 }
1214 return;
1215 }
1216
1217 unknown_cpu:
1218 as_bad (_("unknown cpu `%s'"), str);
1219 }
1220
1221 /* Set appropriate flags for the arch matching STR. */
1222
1223 static void
1224 parse_arch (const char *str)
1225 {
1226 int i = 0;
1227 for (; csky_cpus[i].name != NULL; i++)
1228 if (strcasecmp (str, csky_cpus[i].name) == 0)
1229 {
1230 csky_insn.cpu = &csky_cpus[i];
1231 arch_flag |= csky_cpus[i].arch_flag;
1232 isa_flag |= csky_cpus[i].isa_flag;
1233 return;
1234 }
1235 as_bad (_("unknown architecture `%s'"), str);
1236 }
1237
1238 struct csky_option_value_table
1239 {
1240 const char *name;
1241 long value;
1242 };
1243
1244 static const struct csky_option_value_table csky_float_abis[] =
1245 {
1246 {"hard", VAL_CSKY_FPU_ABI_HARD},
1247 {"softfp", VAL_CSKY_FPU_ABI_SOFTFP},
1248 {"soft", VAL_CSKY_FPU_ABI_SOFT},
1249 {NULL, 0}
1250 };
1251
1252 static bool
1253 parse_float_abi (const char *str)
1254 {
1255 const struct csky_option_value_table * opt;
1256
1257 for (opt = csky_float_abis; opt->name != NULL; opt++)
1258 if (strcasecmp (opt->name, str) == 0)
1259 {
1260 float_abi = opt->value;
1261 return true;
1262 }
1263
1264 as_bad (_("unknown floating point abi `%s'\n"), str);
1265 return false;
1266 }
1267
1268 #ifdef OBJ_ELF
1269 /* Implement the TARGET_FORMAT macro. */
1270
1271 const char *
1272 elf32_csky_target_format (void)
1273 {
1274 return (target_big_endian
1275 ? "elf32-csky-big"
1276 : "elf32-csky-little");
1277 }
1278 #endif
1279
1280 /* Turn an integer of n bytes (in val) into a stream of bytes appropriate
1281 for use in the a.out file, and stores them in the array pointed to by buf.
1282 This knows about the endian-ness of the target machine and does
1283 THE RIGHT THING, whatever it is. Possible values for n are 1 (byte)
1284 2 (short) and 4 (long) Floating numbers are put out as a series of
1285 LITTLENUMS (shorts, here at least). */
1286
1287 void
1288 md_number_to_chars (char * buf, valueT val, int n)
1289 {
1290 if (target_big_endian)
1291 number_to_chars_bigendian (buf, val, n);
1292 else
1293 number_to_chars_littleendian (buf, val, n);
1294 }
1295
1296 /* Get a log2(val). */
1297
1298 static int
1299 csky_log_2 (unsigned int val)
1300 {
1301 int log = -1;
1302 if ((val & (val - 1)) == 0)
1303 for (; val; val >>= 1)
1304 log ++;
1305 else
1306 csky_show_error (ERROR_IMM_POWER, 0, (void *)(long)val, NULL);
1307 return log;
1308 }
1309
1310 /* Output one instruction to the buffer at PTR. */
1311
1312 static void
1313 csky_write_insn (char *ptr, valueT use, int nbytes)
1314 {
1315 if (nbytes == 2)
1316 md_number_to_chars (ptr, use, nbytes);
1317 else /* 32-bit instruction. */
1318 {
1319 /* Significant figures are in low bits. */
1320 md_number_to_chars (ptr, use >> 16, 2);
1321 md_number_to_chars (ptr + 2, use & 0xFFFF, 2);
1322 }
1323 }
1324
1325 /* Read an NBYTES instruction from the buffer at PTR. NBYTES should
1326 be either 2 or 4. This function is used in branch relaxation. */
1327
1328 static valueT
1329 csky_read_insn (char *ptr, int nbytes)
1330 {
1331 unsigned char *uptr = (unsigned char *)ptr;
1332 valueT v = 0;
1333 int lo, hi; /* hi/lo byte index in binary stream. */
1334
1335 if (target_big_endian)
1336 {
1337 hi = 0;
1338 lo = 1;
1339 }
1340 else
1341 {
1342 hi = 1;
1343 lo = 0;
1344 }
1345 v = uptr[lo] | (uptr[hi] << 8);
1346 if (nbytes == 4)
1347 {
1348 v <<= 16;
1349 v |= uptr[lo + 2] | (uptr[hi + 2] << 8);
1350 }
1351 return v;
1352 }
1353
1354 /* Construct a label name into S from the 3-character prefix P and
1355 number N formatted as a 4-digit hex number. */
1356
1357 static void
1358 make_internal_label (char *s, const char *p, int n)
1359 {
1360 static const char hex[] = "0123456789ABCDEF";
1361
1362 s[0] = p[0];
1363 s[1] = p[1];
1364 s[2] = p[2];
1365 s[3] = hex[(n >> 12) & 0xF];
1366 s[4] = hex[(n >> 8) & 0xF];
1367 s[5] = hex[(n >> 4) & 0xF];
1368 s[6] = hex[(n) & 0xF];
1369 s[7] = 0;
1370 }
1371
1372 /* md_operand is a no-op on C-SKY; we do everything elsewhere. */
1373
1374 void
1375 md_operand (expressionS *expressionP ATTRIBUTE_UNUSED)
1376 {
1377 return;
1378 }
1379
1380 /* Under ELF we need to default _GLOBAL_OFFSET_TABLE.
1381 Otherwise we have no need to default values of symbols. */
1382
1383 symbolS *
1384 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
1385 {
1386 #ifdef OBJ_ELF
1387 /* TODO: */
1388 #endif
1389 return NULL;
1390 }
1391
1392 /* Use IEEE format for floating-point constants. */
1393
1394 const char *
1395 md_atof (int type, char *litP, int *sizeP)
1396 {
1397 return ieee_md_atof (type, litP, sizeP, target_big_endian);
1398 }
1399
1400 /* Print option help to FP. */
1401
1402 void
1403 md_show_usage (FILE *fp)
1404 {
1405 int i, n;
1406 const int margin = 48;
1407
1408 fprintf (fp, _("C-SKY assembler options:\n"));
1409
1410 fprintf (fp, _("\
1411 -march=ARCH select architecture ARCH:"));
1412 for (i = 0, n = margin; csky_archs[i].name != NULL; i++)
1413 {
1414 int l = strlen (csky_archs[i].name);
1415 if (n + l >= margin)
1416 {
1417 fprintf (fp, "\n\t\t\t\t");
1418 n = l;
1419 }
1420 else
1421 {
1422 fprintf (fp, " ");
1423 n += l + 1;
1424 }
1425 fprintf (fp, "%s", csky_archs[i].name);
1426 }
1427 fprintf (fp, "\n");
1428
1429 fprintf (fp, _("\
1430 -mcpu=CPU select processor CPU:"));
1431 const struct csky_cpu_feature *feature = NULL;
1432 const struct csky_cpu_version *version = NULL;
1433 for (i = 0; csky_cpus[i].name != NULL; i++)
1434 {
1435 fprintf (fp, "\t\t\t\t%s", csky_cpus[i].name);
1436 feature = csky_cpus[i].features;
1437 version = csky_cpus[i].ver;
1438 while (feature->unique)
1439 {
1440 if ((feature + 1)->unique)
1441 fprintf (fp, "[%c]", feature->unique);
1442 feature++;
1443 }
1444 while (version->r)
1445 {
1446 if (csky_cpus[i].name[0] == 'c'
1447 && csky_cpus[i].name[1] == 'k')
1448 fprintf (fp, "[r%d]", version->r);
1449 else
1450 fprintf (fp, "[-r%dp%d]", version->r, version->p);
1451 version++;
1452 }
1453 }
1454 fprintf (fp, "\n");
1455
1456 fprintf (fp, _("\
1457 -mfloat-abi=ABI select float ABI:"));
1458 for (i = 0, n = margin; csky_float_abis[i].name != NULL; i++)
1459 {
1460 int l = strlen (csky_float_abis[i].name);
1461 if (n + l >= margin)
1462 {
1463 fprintf (fp, "\n\t\t\t\t");
1464 n = l;
1465 }
1466 else
1467 {
1468 fprintf (fp, " ");
1469 n += l + 1;
1470 }
1471 fprintf (fp, "%s", csky_float_abis[i].name);
1472 }
1473 fprintf (fp, "\n");
1474
1475 fprintf (fp, _("\
1476 -EL -mlittle-endian generate little-endian output\n"));
1477 fprintf (fp, _("\
1478 -EB -mbig-endian generate big-endian output\n"));
1479 fprintf (fp, _("\
1480 -fpic -pic generate position-independent code\n"));
1481
1482 fprintf (fp, _("\
1483 -mljump transform jbf, jbt, jbr to jmpi (CK800 only)\n"));
1484 fprintf (fp, _("\
1485 -mno-ljump\n"));
1486
1487 #ifdef INCLUDE_BRANCH_STUB
1488 fprintf (fp, _("\
1489 -mbranch-stub enable branch stubs for PC-relative calls\n"));
1490 fprintf (fp, _("\
1491 -mno-branch-stub\n"));
1492 #endif
1493
1494 fprintf (fp, _("\
1495 -force2bsr -mforce2bsr transform jbsr to bsr\n"));
1496 fprintf (fp, _("\
1497 -no-force2bsr -mno-force2bsr\n"));
1498 fprintf (fp, _("\
1499 -jsri2bsr -mjsri2bsr transform jsri to bsr\n"));
1500 fprintf (fp, _("\
1501 -no-jsri2bsr -mno-jsri2bsr\n"));
1502
1503 fprintf (fp, _("\
1504 -mnolrw -mno-lrw implement lrw as movih + ori\n"));
1505 fprintf (fp, _("\
1506 -melrw enable extended lrw (CK800 only)\n"));
1507 fprintf (fp, _("\
1508 -mno-elrw\n"));
1509
1510 fprintf (fp, _("\
1511 -mlaf -mliterals-after-func emit literals after each function\n"));
1512 fprintf (fp, _("\
1513 -mno-laf -mno-literals-after-func\n"));
1514 fprintf (fp, _("\
1515 -mlabr -mliterals-after-br emit literals after branch instructions\n"));
1516 fprintf (fp, _("\
1517 -mno-labr -mnoliterals-after-br\n"));
1518
1519 fprintf (fp, _("\
1520 -mistack enable interrupt stack instructions\n"));
1521 fprintf (fp, _("\
1522 -mno-istack\n"));
1523
1524 fprintf (fp, _("\
1525 -mhard-float enable hard float instructions\n"));
1526 fprintf (fp, _("\
1527 -mmp enable multiprocessor instructions\n"));
1528 fprintf (fp, _("\
1529 -mcp enable coprocessor instructions\n"));
1530 fprintf (fp, _("\
1531 -mcache enable cache prefetch instruction\n"));
1532 fprintf (fp, _("\
1533 -msecurity enable security instructions\n"));
1534 fprintf (fp, _("\
1535 -mtrust enable trust instructions\n"));
1536 fprintf (fp, _("\
1537 -mdsp enable DSP instructions\n"));
1538 fprintf (fp, _("\
1539 -medsp enable enhanced DSP instructions\n"));
1540 fprintf (fp, _("\
1541 -mvdsp enable vector DSP instructions\n"));
1542 }
1543
1544 static void set_csky_attribute (void)
1545 {
1546 if (mach_flag & CSKY_ARCH_DSP)
1547 {
1548 if (dsp_flag & CSKY_DSP_FLAG_V2)
1549 {
1550 /* Set DSPV2. */
1551 bfd_elf_add_obj_attr_int (stdoutput, OBJ_ATTR_PROC,
1552 Tag_CSKY_DSP_VERSION,
1553 VAL_CSKY_DSP_VERSION_2);
1554 }
1555 else if (isa_flag & CSKY_ISA_DSP)
1556 {
1557 /* Set DSP extension. */
1558 bfd_elf_add_obj_attr_int (stdoutput, OBJ_ATTR_PROC,
1559 Tag_CSKY_DSP_VERSION,
1560 VAL_CSKY_DSP_VERSION_EXTENSION);
1561 }
1562 /* Set VDSP attribute. */
1563 if (isa_flag & CSKY_ISA_VDSP)
1564 bfd_elf_add_obj_attr_int (stdoutput, OBJ_ATTR_PROC,
1565 Tag_CSKY_VDSP_VERSION,
1566 VAL_CSKY_VDSP_VERSION_1);
1567
1568 else if (isa_flag & CSKY_ISA_VDSP_2)
1569 bfd_elf_add_obj_attr_int (stdoutput, OBJ_ATTR_PROC,
1570 Tag_CSKY_VDSP_VERSION,
1571 VAL_CSKY_VDSP_VERSION_2);
1572
1573 }
1574
1575 if (mach_flag & CSKY_ARCH_FLOAT)
1576 {
1577 unsigned int val = VAL_CSKY_FPU_HARDFP_SINGLE;
1578 if (IS_CSKY_ARCH_V1 (mach_flag)) {
1579 bfd_elf_add_obj_attr_int (stdoutput, OBJ_ATTR_PROC,
1580 Tag_CSKY_FPU_VERSION,
1581 VAL_CSKY_FPU_VERSION_1);
1582 }
1583 else
1584 {
1585 if (isa_flag & CSKY_ISA_FLOAT_3E4)
1586 {
1587 bfd_elf_add_obj_attr_int (stdoutput, OBJ_ATTR_PROC,
1588 Tag_CSKY_FPU_VERSION,
1589 VAL_CSKY_FPU_VERSION_2);
1590 val |= VAL_CSKY_FPU_HARDFP_DOUBLE;
1591 }
1592 else
1593 {
1594 bfd_elf_add_obj_attr_int (stdoutput, OBJ_ATTR_PROC,
1595 Tag_CSKY_FPU_VERSION,
1596 VAL_CSKY_FPU_VERSION_2);
1597 }
1598
1599 bfd_elf_add_obj_attr_int (stdoutput, OBJ_ATTR_PROC,
1600 Tag_CSKY_FPU_HARDFP,
1601 val);
1602 bfd_elf_add_obj_attr_string (stdoutput, OBJ_ATTR_PROC,
1603 Tag_CSKY_FPU_NUMBER_MODULE,
1604 "IEEE 754");
1605 bfd_elf_add_obj_attr_int (stdoutput, OBJ_ATTR_PROC,
1606 Tag_CSKY_FPU_ABI,
1607 float_abi);
1608 }
1609 }
1610
1611
1612 bfd_elf_add_obj_attr_int (stdoutput, OBJ_ATTR_PROC,
1613 Tag_CSKY_ISA_FLAGS, isa_flag);
1614
1615 bfd_elf_add_obj_attr_int (stdoutput, OBJ_ATTR_PROC,
1616 Tag_CSKY_ISA_EXT_FLAGS, (isa_flag >> 32));
1617 }
1618
1619 /* Target-specific initialization and option handling. */
1620
1621 void
1622 md_begin (void)
1623 {
1624 unsigned int bfd_mach_flag = 0;
1625 struct csky_opcode const *opcode;
1626 struct csky_macro_info const *macro;
1627 struct csky_arch_info const *p_arch;
1628 struct csky_cpu_info const *p_cpu;
1629 other_flag = (do_opt_mmp | do_opt_mcp | do_opt_mcache
1630 | do_opt_msecurity | do_opt_mhard_float);
1631 dsp_flag |= do_opt_mdsp | do_opt_medsp;
1632 isa_flag |= do_opt_mtrust | do_opt_mvdsp;
1633
1634 if (dsp_flag)
1635 other_flag |= CSKY_ARCH_DSP;
1636
1637 if (mach_flag != 0)
1638 {
1639 if (((mach_flag & CSKY_ARCH_MASK)
1640 != (arch_flag & CSKY_ARCH_MASK))
1641 && arch_flag != 0)
1642 as_warn ("-mcpu conflict with -march option, actually use -mcpu");
1643 }
1644 else if (arch_flag != 0)
1645 mach_flag |= arch_flag | other_flag;
1646 else
1647 {
1648 #ifdef TARGET_WITH_CPU
1649 parse_cpu (TARGET_WITH_CPU);
1650 #else
1651 #if _CSKY_ABI==1
1652 parse_cpu ("ck610");
1653 #else
1654 parse_cpu ("ck810");
1655 #endif
1656 mach_flag |= other_flag;
1657 #endif
1658 }
1659
1660 if (IS_CSKY_ARCH_610 (mach_flag) || IS_CSKY_ARCH_510 (mach_flag))
1661 {
1662 if ((mach_flag & CSKY_ARCH_MP) && (mach_flag & CSKY_ARCH_MAC))
1663 as_fatal ("520/620 conflicts with -mmp option");
1664 else if ((mach_flag & CSKY_ARCH_MP) && (mach_flag & CSKY_ARCH_DSP))
1665 as_fatal ("510e/610e conflicts with -mmp option");
1666 else if ((mach_flag & CSKY_ARCH_DSP) && (mach_flag & CSKY_ARCH_MAC))
1667 as_fatal ("520/620 conflicts with 510e/610e or -mdsp option");
1668 }
1669 if (IS_CSKY_ARCH_510 (mach_flag) && (mach_flag & CSKY_ARCH_FLOAT))
1670 {
1671 mach_flag = (mach_flag & (~CSKY_ARCH_MASK));
1672 mach_flag |= CSKY_ARCH_610;
1673 }
1674
1675 /* Find bfd_mach_flag, it will set to bfd backend data. */
1676 for (p_arch = csky_archs; p_arch->arch_flag != 0; p_arch++)
1677 if ((mach_flag & CSKY_ARCH_MASK) == (p_arch->arch_flag & CSKY_ARCH_MASK))
1678 {
1679 bfd_elf_add_obj_attr_string (stdoutput, OBJ_ATTR_PROC,
1680 Tag_CSKY_ARCH_NAME, p_arch->name);
1681 bfd_mach_flag = p_arch->bfd_mach_flag;
1682 break;
1683 }
1684
1685 /* Find isa_flag. */
1686 for (p_cpu = csky_cpus; p_cpu->arch_flag != 0; p_cpu++)
1687 if ((mach_flag & CPU_ARCH_MASK) == p_cpu->arch_flag)
1688 {
1689 bfd_elf_add_obj_attr_string (stdoutput, OBJ_ATTR_PROC,
1690 Tag_CSKY_CPU_NAME, p_cpu->name);
1691 isa_flag |= p_cpu->isa_flag;
1692 break;
1693 }
1694
1695 /* Check if -mdsp and -medsp conflict. If cpu is ck803, we will
1696 use enhanced dsp instruction. Otherwise, we will use normal dsp. */
1697 if (dsp_flag)
1698 {
1699 if (IS_CSKY_ARCH_803 (mach_flag))
1700 {
1701 if ((dsp_flag & CSKY_DSP_FLAG_V1))
1702 {
1703 if (isa_flag & CSKY_ISA_DSP_ENHANCE)
1704 {
1705 /* Option -mdsp conflicts with -mcpu=ck803ern,
1706 CPU already indicates the dsp version. */
1707 as_warn ("Option -mdsp conflicts with -mcpu=ck803ern which "
1708 "has indicated DSP version, ignoring -mdsp.");
1709 isa_flag &= ~(CSKY_ISA_MAC_DSP | CSKY_ISA_DSP);
1710 isa_flag |= CSKY_ISA_DSP_ENHANCE;
1711 }
1712 else
1713 {
1714 isa_flag |= (CSKY_ISA_MAC_DSP | CSKY_ISA_DSP);
1715 isa_flag &= ~CSKY_ISA_DSP_ENHANCE;
1716 }
1717 }
1718
1719 if ((dsp_flag & CSKY_DSP_FLAG_V2))
1720 {
1721 isa_flag &= ~(CSKY_ISA_MAC_DSP | CSKY_ISA_DSP);
1722 isa_flag |= CSKY_ISA_DSP_ENHANCE;
1723 }
1724
1725 if ((dsp_flag & CSKY_DSP_FLAG_V1)
1726 && (dsp_flag & CSKY_DSP_FLAG_V2))
1727 {
1728 /* In 803, dspv1 is conflict with dspv2. We keep dspv2. */
1729 as_warn ("option -mdsp conflicts with -medsp, only enabling -medsp");
1730 dsp_flag &= ~CSKY_DSP_FLAG_V1;
1731 isa_flag &= ~(CSKY_ISA_MAC_DSP | CSKY_ISA_DSP);
1732 isa_flag |= CSKY_ISA_DSP_ENHANCE;
1733 }
1734 }
1735 else
1736 {
1737 if (dsp_flag & CSKY_DSP_FLAG_V2)
1738 {
1739 dsp_flag &= ~CSKY_DSP_FLAG_V2;
1740 isa_flag &= ~CSKY_ISA_DSP_ENHANCE;
1741 as_warn ("-medsp option is only supported by ck803s, ignoring -medsp");
1742 }
1743 }
1744 ;
1745 }
1746
1747 if (do_use_branchstub == -1)
1748 do_use_branchstub = !IS_CSKY_ARCH_V1 (mach_flag);
1749 else if (do_use_branchstub == 1)
1750 {
1751 if (IS_CSKY_ARCH_V1 (mach_flag))
1752 {
1753 as_warn (_("C-SKY ABI v1 (ck510/ck610) does not support -mbranch-stub"));
1754 do_use_branchstub = 0;
1755 }
1756 else if (do_force2bsr == 0)
1757 {
1758 as_warn (_("-mno-force2bsr is ignored with -mbranch-stub"));
1759 do_force2bsr = 1;
1760 }
1761 }
1762
1763 if (IS_CSKY_ARCH_801 (mach_flag) || IS_CSKY_ARCH_802 (mach_flag))
1764 {
1765 if (!do_force2bsr)
1766 as_warn (_("-mno-force2bsr is ignored for ck801/ck802"));
1767 do_force2bsr = 1;
1768 }
1769 else if (do_force2bsr == -1)
1770 do_force2bsr = do_use_branchstub;
1771
1772 if (do_pff == -1)
1773 {
1774 if (IS_CSKY_ARCH_V1 (mach_flag))
1775 do_pff = 1;
1776 else
1777 do_pff = 0;
1778 }
1779
1780 if (do_extend_lrw == -1)
1781 {
1782 if ((mach_flag & CSKY_ARCH_MASK) == CSKY_ARCH_801
1783 || (mach_flag & CSKY_ARCH_MASK) == CSKY_ARCH_802
1784 || (mach_flag & CSKY_ARCH_MASK) == CSKY_ARCH_803
1785 || (mach_flag & CSKY_ARCH_MASK) == CSKY_ARCH_860)
1786 do_extend_lrw = 1;
1787 else
1788 do_extend_lrw = 0;
1789 }
1790 if (IS_CSKY_ARCH_801 (mach_flag) || IS_CSKY_ARCH_802 (mach_flag))
1791 {
1792 if (do_long_jump > 0)
1793 as_warn (_("-mljump is ignored for ck801/ck802"));
1794 do_long_jump = 0;
1795 }
1796 else if (do_long_jump == -1)
1797 do_long_jump = 1;
1798 if (do_intr_stack == -1)
1799 {
1800 /* control interrupt stack module, 801&802&803 default on
1801 807&810, default off. */
1802 if (IS_CSKY_ARCH_807 (mach_flag) || IS_CSKY_ARCH_810 (mach_flag))
1803 do_intr_stack = 0;
1804 else
1805 do_intr_stack = 1;
1806 }
1807 /* Add isa_flag(SIMP/CACHE/APS). */
1808 isa_flag |= (mach_flag & CSKY_ARCH_MAC) ? CSKY_ISA_MAC : 0;
1809 isa_flag |= (mach_flag & CSKY_ARCH_MP) ? CSKY_ISA_MP : 0;
1810 isa_flag |= (mach_flag & CSKY_ARCH_CP) ? CSKY_ISA_CP : 0;
1811
1812 /* Set abi flag and get table address. */
1813 if (IS_CSKY_ARCH_V1 (mach_flag))
1814 {
1815 mach_flag = mach_flag | CSKY_ABI_V1;
1816 opcode = csky_v1_opcodes;
1817 macro = v1_macros_table;
1818 SPANPANIC = v1_SPANPANIC;
1819 SPANCLOSE = v1_SPANCLOSE;
1820 SPANEXIT = v1_SPANEXIT;
1821 md_relax_table = csky_relax_table;
1822 }
1823 else
1824 {
1825 mach_flag = mach_flag | CSKY_ABI_V2;
1826 opcode = csky_v2_opcodes;
1827 macro = v2_macros_table;
1828 SPANPANIC = v2_SPANPANIC;
1829 if (do_extend_lrw)
1830 {
1831 SPANCLOSE = v2_SPANCLOSE_ELRW;
1832 SPANEXIT = v2_SPANEXIT_ELRW;
1833 }
1834 else
1835 {
1836 SPANCLOSE = v2_SPANCLOSE;
1837 SPANEXIT = v2_SPANEXIT;
1838 }
1839 md_relax_table = csky_relax_table;
1840 }
1841
1842 /* Establish hash table for opcodes and macros. */
1843 csky_macros_hash = str_htab_create ();
1844 csky_opcodes_hash = str_htab_create ();
1845 for ( ; opcode->mnemonic != NULL; opcode++)
1846 if ((isa_flag & (opcode->isa_flag16 | opcode->isa_flag32)) != 0)
1847 str_hash_insert (csky_opcodes_hash, opcode->mnemonic, opcode, 0);
1848 for ( ; macro->name != NULL; macro++)
1849 if ((isa_flag & macro->isa_flag) != 0)
1850 str_hash_insert (csky_macros_hash, macro->name, macro, 0);
1851 if (do_nolrw && (isa_flag & CSKYV2_ISA_1E2) != 0)
1852 str_hash_insert (csky_macros_hash,
1853 v2_lrw_macro_opcode.name, &v2_lrw_macro_opcode, 0);
1854 /* Set e_flag to ELF Head. */
1855 bfd_set_private_flags (stdoutput, mach_flag | CSKY_VERSION_V1);
1856 /* Set bfd_mach to bfd backend data. */
1857 bfd_set_arch_mach (stdoutput, bfd_arch_csky, bfd_mach_flag);
1858
1859 set_csky_attribute ();
1860 }
1861
1862 /* The C-SKY assembler emits mapping symbols $t and $d to mark the
1863 beginning of a sequence of instructions and data (such as a constant pool),
1864 respectively. This is similar to what ARM does. */
1865
1866 static void
1867 make_mapping_symbol (map_state state, valueT value, fragS *frag)
1868 {
1869 symbolS * symbolP;
1870 const char * symname;
1871 int type;
1872 switch (state)
1873 {
1874 case MAP_DATA:
1875 symname = "$d";
1876 type = BSF_NO_FLAGS;
1877 break;
1878 case MAP_TEXT:
1879 symname = "$t";
1880 type = BSF_NO_FLAGS;
1881 break;
1882 default:
1883 abort ();
1884 }
1885
1886 symbolP = symbol_new (symname, now_seg, frag, value);
1887 symbol_get_bfdsym (symbolP)->flags |= type | BSF_LOCAL;
1888 }
1889
1890 /* We need to keep track of whether we are emitting code or data; this
1891 function switches state and emits a mapping symbol if necessary. */
1892
1893 static void
1894 mapping_state (map_state state)
1895 {
1896 map_state current_state
1897 = seg_info (now_seg)->tc_segment_info_data.current_state;
1898
1899 if (current_state == state)
1900 return;
1901 else if (current_state == MAP_UNDEFINED && state == MAP_DATA)
1902 return;
1903 else if (current_state == MAP_UNDEFINED && state == MAP_TEXT)
1904 {
1905 struct frag * const frag_first = seg_info (now_seg)->frchainP->frch_root;
1906 if (frag_now != frag_first || frag_now_fix () > 0)
1907 make_mapping_symbol (MAP_DATA, (valueT) 0, frag_first);
1908 }
1909
1910 seg_info (now_seg)->tc_segment_info_data.current_state = state;
1911 make_mapping_symbol (state, (valueT) frag_now_fix (), frag_now);
1912 }
1913
1914 /* Dump the literal pool. */
1915
1916 static void
1917 dump_literals (int isforce)
1918 {
1919 #define CSKYV1_BR_INSN 0xF000
1920 #define CSKYV2_BR_INSN 0x0400
1921 unsigned int i;
1922 struct literal * p;
1923 symbolS * brarsym = NULL;
1924
1925 /* V1 nop encoding: 0x1200 : mov r0, r0. */
1926 static char v1_nop_insn_big[2] = {0x12, 0x00};
1927 static char v1_nop_insn_little[2] = {0x00, 0x12};
1928
1929 if (poolsize == 0)
1930 return;
1931
1932 /* Must we branch around the literal table? */
1933 if (isforce)
1934 {
1935 char brarname[8];
1936 make_internal_label (brarname, POOL_END_LABEL, poolnumber);
1937 brarsym = symbol_make (brarname);
1938 symbol_table_insert (brarsym);
1939 mapping_state (MAP_TEXT);
1940 if (IS_CSKY_ARCH_V1 (mach_flag))
1941 {
1942 csky_insn.output
1943 = frag_var (rs_machine_dependent,
1944 csky_relax_table[C (UNCD_JUMP_S, DISP32)].rlx_length,
1945 csky_relax_table[C (UNCD_JUMP_S, DISP12)].rlx_length,
1946 C (UNCD_JUMP_S, 0), brarsym, 0, 0);
1947 md_number_to_chars (csky_insn.output, CSKYV1_BR_INSN, 2);
1948 }
1949 else
1950 {
1951 csky_insn.output
1952 = frag_var (rs_machine_dependent,
1953 UNCD_DISP16_LEN,
1954 UNCD_DISP10_LEN,
1955 UNCD_DISP10,
1956 brarsym, 0, 0);
1957 md_number_to_chars (csky_insn.output, CSKYV2_BR_INSN, 2);
1958 }
1959 }
1960 /* Make sure that the section is sufficiently aligned and that
1961 the literal table is aligned within it. */
1962 if (do_pff)
1963 {
1964 valueT br_self;
1965 csky_insn.output = frag_more (2);
1966 /* .Lxx: br .Lxx */
1967 if (IS_CSKY_V1 (mach_flag))
1968 br_self = CSKYV1_BR_INSN | 0x7ff;
1969 else
1970 br_self = CSKYV2_BR_INSN;
1971 md_number_to_chars (csky_insn.output, br_self, 2);
1972 if (!isforce)
1973 {
1974 csky_insn.output = frag_more (2);
1975 /* .Lxx: br .Lxx */
1976 md_number_to_chars (csky_insn.output, br_self, 2);
1977 }
1978 }
1979 mapping_state (MAP_DATA);
1980
1981 record_alignment (now_seg, 2);
1982 if (IS_CSKY_ARCH_V1 (mach_flag))
1983 frag_align_pattern (2,
1984 (target_big_endian
1985 ? v1_nop_insn_big : v1_nop_insn_little),
1986 2, 0);
1987 else
1988 frag_align (2, 0, 3);
1989
1990 colon (S_GET_NAME (poolsym));
1991
1992 for (i = 0, p = litpool; i < poolsize; p++)
1993 {
1994 insn_reloc = p->r_type;
1995 if (insn_reloc == BFD_RELOC_CKCORE_TLS_IE32
1996 || insn_reloc == BFD_RELOC_CKCORE_TLS_LDM32
1997 || insn_reloc == BFD_RELOC_CKCORE_TLS_GD32)
1998 literal_insn_offset = p;
1999 if (p->isdouble)
2000 {
2001 if (target_big_endian)
2002 {
2003 p->e.X_add_number = p->dbnum >> 32;
2004 emit_expr (& p->e, 4);
2005 p->e.X_add_number = p->dbnum & 0xffffffff;
2006 emit_expr (& p->e, 4);
2007 }
2008 else
2009 {
2010 p->e.X_add_number = p->dbnum & 0xffffffff;
2011 emit_expr (& p->e, 4);
2012 p->e.X_add_number = p->dbnum >> 32;
2013 emit_expr (& p->e, 4);
2014 }
2015 }
2016 else if (p->e.X_op == O_big)
2017 {
2018 memcpy (generic_bignum, p->bignum, sizeof (p->bignum));
2019 emit_expr (& p->e, p->e.X_add_number * CHARS_PER_LITTLENUM);
2020 }
2021 else
2022 emit_expr (& p->e, 4);
2023
2024 if (p->e.X_op == O_big)
2025 i += (p->e.X_add_number & 1) +
2026 ((p->e.X_add_number * CHARS_PER_LITTLENUM) >> 2);
2027 else
2028 i += (p->isdouble ? 2 : 1);
2029 }
2030
2031 if (isforce && IS_CSKY_ARCH_V2 (mach_flag))
2032 {
2033 /* Add one nop insn at end of literal for disassembler. */
2034 mapping_state (MAP_TEXT);
2035 csky_insn.output = frag_more (2);
2036 md_number_to_chars (csky_insn.output, CSKYV2_INST_NOP, 2);
2037 }
2038
2039 insn_reloc = BFD_RELOC_NONE;
2040
2041 if (brarsym != NULL)
2042 colon (S_GET_NAME (brarsym));
2043 poolsize = 0;
2044 }
2045
2046 static struct literal *
2047 enter_literal (expressionS *e,
2048 int ispcrel,
2049 unsigned char isdouble,
2050 uint64_t dbnum)
2051 {
2052 unsigned int i;
2053 struct literal * p;
2054 if (poolsize >= MAX_POOL_SIZE - 2)
2055 {
2056 /* The literal pool is as full as we can handle. We have
2057 to be 2 entries shy of the 1024/4=256 entries because we
2058 have to allow for the branch (2 bytes) and the alignment
2059 (2 bytes before the first insn referencing the pool and
2060 2 bytes before the pool itself) == 6 bytes, rounds up
2061 to 2 entries. */
2062
2063 /* Save the parsed symbol's reloc. */
2064 enum bfd_reloc_code_real last_reloc_before_dump = insn_reloc;
2065 dump_literals (1);
2066 insn_reloc = last_reloc_before_dump;
2067 }
2068
2069 if (poolsize == 0)
2070 {
2071 /* Create new literal pool. */
2072 if (++ poolnumber > 0xFFFF)
2073 as_fatal (_("more than 65K literal pools"));
2074
2075 make_internal_label (poolname, POOL_START_LABEL, poolnumber);
2076 poolsym = symbol_make (poolname);
2077 symbol_table_insert (poolsym);
2078 poolspan = 0;
2079 }
2080
2081 /* Search pool for value so we don't have duplicates. */
2082 for (p = litpool,i = 0; i < poolsize; p++)
2083 {
2084 if (e->X_op == p->e.X_op
2085 && e->X_add_symbol == p->e.X_add_symbol
2086 && e->X_add_number == p->e.X_add_number
2087 && ispcrel == p->ispcrel
2088 && insn_reloc == p->r_type
2089 && isdouble == p->isdouble
2090 && insn_reloc != BFD_RELOC_CKCORE_TLS_GD32
2091 && insn_reloc != BFD_RELOC_CKCORE_TLS_LDM32
2092 && insn_reloc != BFD_RELOC_CKCORE_TLS_LDO32
2093 && insn_reloc != BFD_RELOC_CKCORE_TLS_IE32
2094 && insn_reloc != BFD_RELOC_CKCORE_TLS_LE32
2095 && (e->X_op != O_big
2096 || (memcmp (generic_bignum, p->bignum,
2097 p->e.X_add_number * sizeof (LITTLENUM_TYPE)) == 0)))
2098 {
2099 p->refcnt ++;
2100 return p;
2101 }
2102 if (p->e.X_op == O_big)
2103 {
2104 i += (p->e.X_add_number >> 1);
2105 i += (p->e.X_add_number & 0x1);
2106 }
2107 else
2108 i += (p->isdouble ? 2 : 1);
2109 }
2110 p->refcnt = 1;
2111 p->ispcrel = ispcrel;
2112 p->e = *e;
2113 p->r_type = insn_reloc;
2114 p->isdouble = isdouble;
2115 p->offset = i;
2116 if (isdouble)
2117 p->dbnum = dbnum;
2118 if (e->X_op == O_big)
2119 memcpy (p->bignum, generic_bignum, sizeof (p->bignum));
2120
2121 if (insn_reloc == BFD_RELOC_CKCORE_TLS_GD32
2122 || insn_reloc == BFD_RELOC_CKCORE_TLS_LDM32
2123 || insn_reloc == BFD_RELOC_CKCORE_TLS_IE32)
2124 {
2125 p->tls_addend.frag = frag_now;
2126 p->tls_addend.offset = csky_insn.output - frag_now->fr_literal;
2127 literal_insn_offset = p;
2128 }
2129 if (p->e.X_op == O_big) {
2130 poolsize += (p->e.X_add_number >> 1);
2131 poolsize += (p->e.X_add_number & 0x1);
2132 } else
2133 poolsize += (p->isdouble ? 2 : 1);
2134
2135 return p;
2136 }
2137
2138 /* Check whether we must dump the literal pool here.
2139 kind == 0 is any old instruction.
2140 kind > 0 means we just had a control transfer instruction.
2141 kind == 1 means within a function.
2142 kind == 2 means we just left a function.
2143
2144 OFFSET is the length of the insn being processed.
2145
2146 SPANCLOSE and SPANEXIT are smaller numbers than SPANPANIC.
2147 SPANPANIC means that we must dump now.
2148 The dump_literals (1) call inserts a branch around the table, so
2149 we first look to see if its a situation where we won't have to
2150 insert a branch (e.g., the previous instruction was an unconditional
2151 branch).
2152
2153 SPANPANIC is the point where we must dump a single-entry pool.
2154 it accounts for alignments and an inserted branch.
2155 the 'poolsize*2' accounts for the scenario where we do:
2156 lrw r1,lit1; lrw r2,lit2; lrw r3,lit3
2157 Note that the 'lit2' reference is 2 bytes further along
2158 but the literal it references will be 4 bytes further along,
2159 so we must consider the poolsize into this equation.
2160 This is slightly over-cautious, but guarantees that we won't
2161 panic because a relocation is too distant. */
2162
2163 static void
2164 check_literals (int kind, int offset)
2165 {
2166 poolspan += offset;
2167
2168 if ((poolspan > SPANEXIT || do_func_dump)
2169 && kind > 1
2170 && (do_br_dump || do_func_dump))
2171 dump_literals (0);
2172 else if (poolspan > SPANCLOSE && (kind > 0) && do_br_dump)
2173 dump_literals (0);
2174 else if (poolspan
2175 >= (SPANPANIC - (IS_CSKY_ARCH_V1 (mach_flag) ? poolsize * 2 : 0)))
2176 dump_literals (1);
2177 /* We have not dumped literal pool before insn1,
2178 and will not dump literal pool between insn1 and insnN+1,
2179 so reset poolspan to original length. */
2180 else if (do_noliteraldump == 1)
2181 poolspan -= offset;
2182
2183 if (do_noliteraldump == 1)
2184 do_noliteraldump = 0;
2185 }
2186
2187 /* The next group of functions are helpers for parsing various kinds
2188 of instruction operand syntax. */
2189
2190 /* Parse operands of the form
2191 <symbol>@GOTOFF+<nnn>
2192 and similar .plt or .got references.
2193
2194 If we find one, set up the correct relocation in RELOC and copy the
2195 input string, minus the `@GOTOFF' into a malloc'd buffer for
2196 parsing by the calling routine. Return this buffer, and if ADJUST
2197 is non-null set it to the length of the string we removed from the
2198 input line. Otherwise return NULL. */
2199
2200 static char *
2201 lex_got (enum bfd_reloc_code_real *reloc,
2202 int *adjust)
2203 {
2204 struct _gotrel
2205 {
2206 const char *str;
2207 const enum bfd_reloc_code_real rel;
2208 };
2209 static const struct _gotrel gotrel[] =
2210 {
2211 { "GOTOFF", BFD_RELOC_CKCORE_GOTOFF },
2212 { "GOTPC", BFD_RELOC_CKCORE_GOTPC },
2213 { "GOTTPOFF", BFD_RELOC_CKCORE_TLS_IE32 },
2214 { "GOT", BFD_RELOC_CKCORE_GOT32 },
2215 { "PLT", BFD_RELOC_CKCORE_PLT32 },
2216 { "BTEXT", BFD_RELOC_CKCORE_TOFFSET_LO16},
2217 { "BDATA", BFD_RELOC_CKCORE_DOFFSET_LO16},
2218 { "TLSGD32", BFD_RELOC_CKCORE_TLS_GD32 },
2219 { "TLSLDM32", BFD_RELOC_CKCORE_TLS_LDM32 },
2220 { "TLSLDO32", BFD_RELOC_CKCORE_TLS_LDO32 },
2221 { "TPOFF", BFD_RELOC_CKCORE_TLS_LE32 }
2222 };
2223
2224 char *cp;
2225 unsigned int j;
2226
2227 for (cp = input_line_pointer; *cp != '@'; cp++)
2228 if (is_end_of_line[(unsigned char) *cp])
2229 return NULL;
2230
2231 for (j = 0; j < sizeof (gotrel) / sizeof (gotrel[0]); j++)
2232 {
2233 int len = strlen (gotrel[j].str);
2234
2235 if (strncasecmp (cp + 1, gotrel[j].str, len) == 0)
2236 {
2237 if (gotrel[j].rel != 0)
2238 {
2239 *reloc = gotrel[j].rel;
2240 if (adjust)
2241 *adjust = len;
2242
2243 /* input_line_pointer is the str pointer after relocation
2244 token like @GOTOFF. */
2245 input_line_pointer += len + 1;
2246 return input_line_pointer;
2247 }
2248
2249 csky_show_error (ERROR_RELOC_ILLEGAL, 0,
2250 (void *)gotrel[j].str, NULL);
2251 return NULL;
2252 }
2253 }
2254
2255 /* Might be a symbol version string. Don't as_bad here. */
2256 return NULL;
2257 }
2258
2259 /* Parse an expression, returning it in E. */
2260
2261 static char *
2262 parse_exp (char *s, expressionS *e)
2263 {
2264 char *save;
2265 char *new;
2266
2267 /* Skip whitespace. */
2268 while (ISSPACE (*s))
2269 ++s;
2270
2271 save = input_line_pointer;
2272 input_line_pointer = s;
2273
2274 insn_reloc = BFD_RELOC_NONE;
2275 expression (e);
2276 lex_got (&insn_reloc, NULL);
2277
2278 if (e->X_op == O_absent)
2279 SET_ERROR_STRING (ERROR_MISSING_OPERAND, NULL);
2280
2281 new = input_line_pointer;
2282 input_line_pointer = save;
2283
2284 return new;
2285 }
2286
2287 /* Parse a floating-point number from S into its target representation.
2288 If ISDOUBLE is true, return the result in *DBNUM; otherwise
2289 it's returned in E->X_add_number. Returns the result of advancing
2290 S past the constant. */
2291
2292 static char *
2293 parse_fexp (char *s, expressionS *e, unsigned char isdouble, uint64_t *dbnum)
2294 {
2295 int length; /* Number of chars in an object. */
2296 const char *err = NULL; /* Error from scanning float literal. */
2297 unsigned char temp[8];
2298
2299 /* input_line_pointer->1st char of a flonum (we hope!). */
2300 input_line_pointer = s;
2301
2302 if (input_line_pointer[0] == '0'
2303 && ISALPHA (input_line_pointer[1]))
2304 input_line_pointer += 2;
2305
2306 if (isdouble)
2307 err = md_atof ('d', (char *) temp, &length);
2308 else
2309 err = md_atof ('f', (char *) temp, &length);
2310 know (length <= 8);
2311 know (err != NULL || length > 0);
2312
2313 if (!is_end_of_line[(unsigned char) *input_line_pointer])
2314 as_bad (_("immediate operand required"));
2315 while (!is_end_of_line[(unsigned char) *input_line_pointer])
2316 input_line_pointer++;
2317
2318 if (err)
2319 {
2320 as_bad (_("bad floating literal: %s"), err);
2321 while (!is_end_of_line[(unsigned char) *input_line_pointer])
2322 input_line_pointer++;
2323 know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
2324 return input_line_pointer;
2325 }
2326
2327 e->X_add_symbol = 0x0;
2328 e->X_op_symbol = 0x0;
2329 e->X_op = O_constant;
2330 e->X_unsigned = 1;
2331 e->X_md = 0x0;
2332
2333 if (!isdouble)
2334 {
2335 uint32_t fnum;
2336 if (target_big_endian)
2337 fnum = (((uint32_t) temp[0] << 24)
2338 | (temp[1] << 16)
2339 | (temp[2] << 8)
2340 | temp[3]);
2341 else
2342 fnum = (((uint32_t) temp[3] << 24)
2343 | (temp[2] << 16)
2344 | (temp[1] << 8)
2345 | temp[0]);
2346 e->X_add_number = fnum;
2347 }
2348 else
2349 {
2350 if (target_big_endian)
2351 {
2352 *dbnum = (((uint32_t) temp[0] << 24)
2353 | (temp[1] << 16)
2354 | (temp[2] << 8)
2355 | temp[3]);
2356 *dbnum <<= 32;
2357 *dbnum |= (((uint32_t) temp[4] << 24)
2358 | (temp[5] << 16)
2359 | (temp[6] << 8)
2360 | temp[7]);
2361 }
2362 else
2363 {
2364 *dbnum = (((uint32_t) temp[7] << 24)
2365 | (temp[6] << 16)
2366 | (temp[5] << 8)
2367 | temp[4]);
2368 *dbnum <<= 32;
2369 *dbnum |= (((uint32_t) temp[3] << 24)
2370 | (temp[2] << 16)
2371 | (temp[1] << 8)
2372 | temp[0]);
2373 }
2374 }
2375 return input_line_pointer;
2376 }
2377
2378 static char *
2379 parse_rt (char *s,
2380 int ispcrel,
2381 expressionS *ep,
2382 long reg ATTRIBUTE_UNUSED)
2383 {
2384 expressionS e;
2385
2386 if (ep)
2387 /* Indicate nothing there. */
2388 ep->X_op = O_absent;
2389
2390 if (*s == '[')
2391 {
2392 s = parse_exp (s + 1, &e);
2393
2394 if (*s == ']')
2395 s++;
2396 else
2397 SET_ERROR_STRING (ERROR_MISSING_RSQUARE_BRACKETS, NULL);
2398
2399 if (ep)
2400 *ep = e;
2401 }
2402 else
2403 {
2404 s = parse_exp (s, &e);
2405 if (BFD_RELOC_CKCORE_DOFFSET_LO16 == insn_reloc
2406 || BFD_RELOC_CKCORE_TOFFSET_LO16 == insn_reloc)
2407 {
2408 if (ep)
2409 *ep = e;
2410 return s;
2411 }
2412 if (ep)
2413 *ep = e;
2414 /* If the instruction has work, literal handling is in the work. */
2415 if (!csky_insn.opcode->work)
2416 {
2417 struct literal *p = enter_literal (&e, ispcrel, 0, 0);
2418 if (ep)
2419 *ep = e;
2420
2421 /* Create a reference to pool entry. */
2422 ep->X_op = O_symbol;
2423 ep->X_add_symbol = poolsym;
2424 ep->X_add_number = p->offset << 2;
2425 }
2426 }
2427 return s;
2428 }
2429
2430 static int float_to_half (void *f, void *h)
2431 {
2432 int imm_e;
2433 int imm_f;
2434 unsigned int value_f = *(unsigned int *)f;
2435 unsigned short value_h;
2436
2437 imm_e = ((value_f >> 23) & 0xff);
2438 imm_f = ((value_f & 0x7fffff));
2439
2440 imm_e = ((imm_e - 127 + 15) << 10);
2441 imm_f = ((imm_f & 0x7fe000) >> 13);
2442
2443 value_h = (value_f & 0x80000000 ? 0x8000 : 0x0) | imm_e | imm_f;
2444
2445 if (h)
2446 *(unsigned short *)h = value_h;
2447
2448 return value_h;
2449 }
2450
2451 static char *
2452 parse_rtf (char *s, int ispcrel, expressionS *ep)
2453 {
2454 expressionS e;
2455 struct literal *p = NULL;
2456
2457 if (ep)
2458 /* Indicate nothing there. */
2459 ep->X_op = O_absent;
2460
2461 if (*s == '[')
2462 {
2463 s = parse_exp (s + 1, & e);
2464
2465 if (*s == ']')
2466 s++;
2467 else
2468 as_bad (_("missing ']'"));
2469
2470 if (ep)
2471 *ep = e;
2472 }
2473 else
2474 {
2475 uint64_t dbnum;
2476 if (strstr(csky_insn.opcode->mnemonic, "flrws")
2477 || strstr(csky_insn.opcode->mnemonic, "flrw.32"))
2478 {
2479 s = parse_fexp (s, &e, 0, &dbnum);
2480 p = enter_literal (& e, ispcrel, 0, dbnum);
2481 }
2482 else if (strstr(csky_insn.opcode->mnemonic, "flrwd")
2483 || strstr(csky_insn.opcode->mnemonic, "flrw.64"))
2484 {
2485 s = parse_fexp (s, &e, 1, &dbnum);
2486 p = enter_literal (& e, ispcrel, 1, dbnum);
2487 }
2488 else if (strstr(csky_insn.opcode->mnemonic, "flrwh")
2489 || strstr(csky_insn.opcode->mnemonic, "flrw.16"))
2490 {
2491 s = parse_fexp (s, &e, 0, NULL);
2492 e.X_add_number = float_to_half (&e.X_add_number, &e.X_add_number);
2493 p = enter_literal (& e, ispcrel, 0, 0);
2494 }
2495 else
2496 as_bad (_("unrecognized opcode"));
2497
2498 if (ep)
2499 *ep = e;
2500
2501 /* Create a reference to pool entry. */
2502 ep->X_op = O_symbol;
2503 ep->X_add_symbol = poolsym;
2504 ep->X_add_number = p->offset << 2;
2505 }
2506 return s;
2507 }
2508
2509 static bool
2510 parse_type_ctrlreg (char** oper)
2511 {
2512 int i = -1;
2513 int group = 0;
2514 int crx;
2515 int sel;
2516 char *s = *oper;
2517 expressionS e;
2518
2519 if (TOLOWER (*(*oper + 0)) == 'c'
2520 && TOLOWER (*(*oper + 1)) == 'r'
2521 && ISDIGIT (*(*oper + 2)))
2522 {
2523 /* The control registers are named crxx. */
2524 s = *oper+2;
2525 s = parse_exp (s, &e);
2526 if (e.X_op == O_constant)
2527 {
2528 i = e.X_add_number;
2529 *oper = s;
2530 }
2531 }
2532
2533 if (IS_CSKY_V2 (mach_flag))
2534 {
2535
2536 s = *oper;
2537 if (i != -1)
2538 {
2539 crx = i;
2540 sel = group;
2541 }
2542 else if (TOLOWER (*(*oper + 0)) == 'c'
2543 && TOLOWER (*(*oper + 1)) == 'r')
2544 {
2545 s += 2;
2546 if (*s != '<')
2547 {
2548 SET_ERROR_STRING (ERROR_CREG_ILLEGAL, s);
2549 return false;
2550 }
2551 s++;
2552 crx = strtol(s, &s, 10);
2553 if (crx < 0 || crx > 31 || *s != ',')
2554 {
2555 SET_ERROR_STRING (ERROR_CREG_ILLEGAL, s);
2556 return false;
2557 }
2558 s++;
2559 sel = strtol(s, &s, 10);
2560 if (sel < 0 || sel > 31 || *s != '>')
2561 {
2562 SET_ERROR_STRING (ERROR_CREG_ILLEGAL, s);
2563 return false;
2564 }
2565 s++;
2566 }
2567 else
2568 {
2569 crx = csky_get_control_regno (mach_flag, s, &s, &sel);
2570 if (crx < 0)
2571 {
2572 SET_ERROR_STRING (ERROR_CREG_ILLEGAL, s);
2573 return false;
2574 }
2575 }
2576 i = (sel << 5) | crx;
2577 }
2578 else if (i == -1)
2579 {
2580 i = csky_get_control_regno (mach_flag, s, &s, &sel);
2581 if (i < 0)
2582 {
2583 SET_ERROR_STRING (ERROR_CREG_ILLEGAL, s);
2584 return false;
2585 }
2586 }
2587 *oper = s;
2588 csky_insn.val[csky_insn.idx++] = i;
2589 return true;
2590 }
2591
2592 static int
2593 csky_get_reg_val (char *str, int *len)
2594 {
2595 int regno = 0;
2596 char *s = str;
2597 regno = csky_get_general_regno (mach_flag, str, &s);
2598 *len = (s - str);
2599 return regno;
2600 }
2601
2602 static bool
2603 is_reg_sp_with_bracket (char **oper)
2604 {
2605 int reg;
2606 int sp_idx;
2607 int len;
2608
2609 if (IS_CSKY_V1 (mach_flag))
2610 sp_idx = 0;
2611 else
2612 sp_idx = 14;
2613
2614 if (**oper != '(')
2615 return false;
2616 *oper += 1;
2617 reg = csky_get_reg_val (*oper, &len);
2618 *oper += len;
2619 if (reg == sp_idx)
2620 {
2621 if (**oper != ')')
2622 {
2623 SET_ERROR_STRING (ERROR_UNDEFINE,
2624 "Operand format is error. '(sp)' expected");
2625 return false;
2626 }
2627 *oper += 1;
2628 csky_insn.val[csky_insn.idx++] = sp_idx;
2629 return true;
2630 }
2631
2632 SET_ERROR_STRING (ERROR_UNDEFINE,
2633 "Operand format is error. '(sp)' expected");
2634 return false;
2635 }
2636
2637 static bool
2638 is_reg_sp (char **oper)
2639 {
2640 char sp_name[16];
2641 int sp_idx;
2642 int len;
2643 if (IS_CSKY_V1 (mach_flag))
2644 sp_idx = 0;
2645 else
2646 sp_idx = 14;
2647
2648 /* ABI names: "sp". */
2649 if (memcmp (*oper, "sp", 2) == 0)
2650 {
2651 *oper += 2;
2652 csky_insn.val[csky_insn.idx++] = sp_idx;
2653 return true;
2654 }
2655
2656 len = sprintf (sp_name, "r%d", sp_idx);
2657 if (memcmp (*oper, sp_name, len) == 0)
2658 {
2659 *oper += len;
2660 csky_insn.val[csky_insn.idx++] = sp_idx;
2661 return true;
2662 }
2663
2664 return false;
2665 }
2666
2667 static int
2668 csky_get_freg_val (char *str, int *len)
2669 {
2670 int reg = 0;
2671 char *s = NULL;
2672 if ((TOLOWER(str[0]) == 'v' || TOLOWER(str[0]) == 'f')
2673 && (TOLOWER(str[1]) == 'r'))
2674 {
2675 /* It is fpu register. */
2676 s = &str[2];
2677 while (ISDIGIT (*s))
2678 {
2679 reg = reg * 10 + (*s) - '0';
2680 s++;
2681 }
2682 if (reg > 31)
2683 return -1;
2684 }
2685 else
2686 return -1;
2687 *len = s - str;
2688 return reg;
2689 }
2690
2691 static bool
2692 is_reglist_legal (char **oper)
2693 {
2694 int reg1 = -1;
2695 int reg2 = -1;
2696 int len = 0;
2697 reg1 = csky_get_reg_val (*oper, &len);
2698 *oper += len;
2699
2700 if (reg1 == -1 || (IS_CSKY_V1 (mach_flag) && (reg1 == 0 || reg1 == 15)))
2701 {
2702 SET_ERROR_STRING (ERROR_REG_FORMAT,
2703 "The first reg must not be r0/r15");
2704 return false;
2705 }
2706
2707 if (**oper != '-')
2708 {
2709 SET_ERROR_STRING (ERROR_REG_FORMAT,
2710 "The operand format must be rx-ry");
2711 return false;
2712 }
2713 *oper += 1;
2714
2715 reg2 = csky_get_reg_val (*oper, &len);
2716 *oper += len;
2717
2718 if (reg2 == -1 || (IS_CSKY_V1 (mach_flag) && reg1 == 15))
2719 {
2720 SET_ERROR_STRING (ERROR_REG_FORMAT,
2721 "The operand format must be r15 in C-SKY V1");
2722 return false;
2723 }
2724 if (IS_CSKY_V2 (mach_flag))
2725 {
2726 if (reg2 < reg1)
2727 {
2728 SET_ERROR_STRING (ERROR_REG_FORMAT,
2729 "The operand format must be rx-ry (rx < ry)");
2730 return false;
2731 }
2732 reg2 = reg2 - reg1;
2733 reg1 <<= 5;
2734 reg1 |= reg2;
2735 }
2736 csky_insn.val[csky_insn.idx++] = reg1;
2737 return true;
2738 }
2739
2740 static bool
2741 is_freglist_legal (char **oper)
2742 {
2743 int reg1 = -1;
2744 int reg2 = -1;
2745 int len = 0;
2746 int shift = 0;
2747 reg1 = csky_get_freg_val (*oper, &len);
2748 *oper += len;
2749
2750 if (reg1 == -1)
2751 {
2752 SET_ERROR_STRING (ERROR_REG_FORMAT,
2753 "The fpu register format is not recognized.");
2754 return false;
2755 }
2756
2757 if (**oper != '-')
2758 {
2759 SET_ERROR_STRING (ERROR_REG_FORMAT,
2760 "The operand format must be vrx-vry/frx-fry.");
2761 return false;
2762 }
2763 *oper += 1;
2764
2765 reg2 = csky_get_freg_val (*oper, &len);
2766 *oper += len;
2767
2768 if (reg2 == -1)
2769 {
2770 SET_ERROR_STRING (ERROR_REG_FORMAT,
2771 "The fpu register format is not recognized.");
2772 return false;
2773 }
2774 if (reg2 < reg1)
2775 {
2776 SET_ERROR_STRING (ERROR_REG_FORMAT,
2777 "The operand format must be rx-ry(rx < ry)");
2778 return false;
2779 }
2780
2781 reg2 = reg2 - reg1;
2782 /* The fldm/fstm in CSKY_ISA_FLOAT_7E60 has 5 bits frz(reg1). */
2783 shift = 4;
2784 if (startswith (csky_insn.opcode->mnemonic, "fstm")
2785 || startswith (csky_insn.opcode->mnemonic, "fldm"))
2786 {
2787 if ((!(isa_flag & CSKY_ISA_FLOAT_7E60)
2788 && (reg2 > (int)15 || reg1 > 15))
2789 || ((isa_flag & CSKY_ISA_FLOAT_7E60)
2790 && (reg2 > (int)31 || reg1 > (int)31)))
2791 {
2792 /* ISA_FLOAT_E1 fstm/fldm fry-frx is within 15.
2793 ISA_FLOAT_7E60 fstm(u)/fldm(u) frx-fry is within 31. */
2794 SET_ERROR_STRING(ERROR_REG_FORMAT, (void *)"frx-fry is over range");
2795 return false;
2796 }
2797 if ((mach_flag & CSKY_ARCH_MASK) == CSKY_ARCH_860)
2798 {
2799 shift = 5;
2800 }
2801 }
2802 else
2803 {
2804 if (reg2 > (int)0x3) {
2805 SET_ERROR_STRING(ERROR_REG_FORMAT, (void *)"vry-vrx is over range");
2806 return false;
2807 }
2808 }
2809 reg2 <<= shift;
2810 reg1 |= reg2;
2811 csky_insn.val[csky_insn.idx++] = reg1;
2812 return true;
2813 }
2814
2815 static bool
2816 is_reglist_dash_comma_legal (char **oper, struct operand *oprnd)
2817 {
2818 int reg1 = -1;
2819 int reg2 = -1;
2820 int len = 0;
2821 int list = 0;
2822 int flag = 0;
2823 int temp = 0;
2824 while (**oper != '\n' && **oper != '\0')
2825 {
2826 reg1 = csky_get_reg_val (*oper, &len);
2827 if (reg1 == -1)
2828 {
2829 SET_ERROR_STRING (ERROR_REG_LIST, NULL);
2830 return false;
2831 }
2832 flag |= (1 << reg1);
2833 *oper += len;
2834 if (**oper == '-')
2835 {
2836 *oper += 1;
2837 reg2 = csky_get_reg_val (*oper, &len);
2838 if (reg2 == -1)
2839 {
2840 SET_ERROR_STRING (ERROR_REG_LIST, NULL);
2841 return false;
2842 }
2843 *oper += len;
2844 if (reg1 > reg2)
2845 {
2846 SET_ERROR_STRING (ERROR_REG_LIST, NULL);
2847 return false;
2848 }
2849 while (reg2 >= reg1)
2850 {
2851 flag |= (1 << reg2);
2852 reg2--;
2853 }
2854 }
2855 if (**oper == ',')
2856 *oper += 1;
2857 }
2858 /* The reglist: r4-r11, r15, r16-r17, r28. */
2859 #define REGLIST_BITS 0x10038ff0
2860 if (flag & ~(REGLIST_BITS))
2861 {
2862 SET_ERROR_STRING (ERROR_REG_LIST, NULL);
2863 return false;
2864 }
2865 /* Check r4-r11. */
2866 int i = 4;
2867 while (i <= 11)
2868 {
2869 if (flag & (1 << i))
2870 temp = i - 4 + 1;
2871 i++;
2872 }
2873 list |= temp;
2874
2875 /* Check r15. */
2876 if (flag & (1 << 15))
2877 list |= (1 << 4);
2878
2879 /* Check r16-r17. */
2880 i = 16;
2881 temp = 0;
2882 while (i <= 17)
2883 {
2884 if (flag & (1 << i))
2885 temp = i - 16 + 1;
2886 i++;
2887 }
2888 list |= (temp << 5);
2889
2890 /* Check r28. */
2891 if (flag & (1 << 28))
2892 list |= (1 << 8);
2893 if (oprnd->mask == OPRND_MASK_0_4 && (list & ~OPRND_MASK_0_4))
2894 {
2895 SET_ERROR_STRING (ERROR_REG_LIST, NULL);
2896 return false;
2897 }
2898 csky_insn.val[csky_insn.idx++] = list;
2899 return true;
2900 }
2901
2902 static bool
2903 is_reg_lshift_illegal (char **oper, int is_float)
2904 {
2905 int value;
2906 int len;
2907 int reg;
2908 reg = csky_get_reg_val (*oper, &len);
2909 if (reg == -1)
2910 {
2911 SET_ERROR_STRING (ERROR_REG_FORMAT, "The register must be r0-r31.");
2912 return false;
2913 }
2914
2915 *oper += len;
2916 if ((*oper)[0] != '<' || (*oper)[1] != '<')
2917 {
2918 SET_ERROR_STRING (ERROR_UNDEFINE,
2919 "Operand format error; should be (rx, ry << n)");
2920 return false;
2921 }
2922 *oper += 2;
2923
2924 expressionS e;
2925 char *new_oper = parse_exp (*oper, &e);
2926 if (e.X_op == O_constant)
2927 {
2928 *oper = new_oper;
2929 /* The immediate must be in [0, 3]. */
2930 if (e.X_add_number < 0 || e.X_add_number > 3)
2931 {
2932 SET_ERROR_STRING (ERROR_IMM_OVERFLOW, NULL);
2933 return false;
2934 }
2935 }
2936 else
2937 {
2938 SET_ERROR_STRING (ERROR_EXP_CONSTANT, NULL);
2939 return false;
2940 }
2941 if (is_float)
2942 value = (reg << 2) | e.X_add_number;
2943 else
2944 value = (reg << 5) | (1 << e.X_add_number);
2945 csky_insn.val[csky_insn.idx++] = value;
2946
2947 return true;
2948 }
2949
2950 static bool
2951 is_imm_within_range (char **oper, int min, int max)
2952 {
2953 expressionS e;
2954 bool ret = false;
2955 char *new_oper = parse_exp (*oper, &e);
2956 if (e.X_op == O_constant)
2957 {
2958 ret = true;
2959 *oper = new_oper;
2960 if (e.X_add_number < min || e.X_add_number > max)
2961 {
2962 ret = false;
2963 SET_ERROR_STRING (ERROR_IMM_OVERFLOW, NULL);
2964 }
2965 if (!e.X_unsigned)
2966 e.X_add_number |= 0x80000000;
2967 csky_insn.val[csky_insn.idx++] = e.X_add_number;
2968 }
2969 else
2970 SET_ERROR_STRING(ERROR_IMM_ILLEGAL, NULL);
2971
2972 return ret;
2973 }
2974
2975 static bool
2976 is_imm_within_range_ext (char **oper, int min, int max, int ext)
2977 {
2978 expressionS e;
2979 bool ret = false;
2980 char *new_oper = parse_exp (*oper, &e);
2981 if (e.X_op == O_constant)
2982 {
2983 ret = true;
2984 *oper = new_oper;
2985 if ((int)e.X_add_number != ext
2986 && (e.X_add_number < min || e.X_add_number > max))
2987 {
2988 ret = false;
2989 SET_ERROR_STRING (ERROR_IMM_OVERFLOW, NULL);
2990 }
2991 csky_insn.val[csky_insn.idx++] = e.X_add_number;
2992 }
2993
2994 else
2995 SET_ERROR_STRING(ERROR_IMM_ILLEGAL, NULL);
2996
2997 return ret;
2998 }
2999
3000 static bool
3001 is_oimm_within_range (char **oper, int min, int max)
3002 {
3003 expressionS e;
3004 bool ret = false;
3005 char *new_oper = parse_exp (*oper, &e);
3006 if (e.X_op == O_constant)
3007 {
3008 ret = true;
3009 *oper = new_oper;
3010 if (e.X_add_number < min || e.X_add_number > max)
3011 {
3012 ret = false;
3013 SET_ERROR_STRING (ERROR_IMM_OVERFLOW, NULL);
3014 }
3015 csky_insn.val[csky_insn.idx++] = e.X_add_number - 1;
3016 }
3017 else
3018 SET_ERROR_STRING (ERROR_IMM_ILLEGAL, NULL);
3019
3020 return ret;
3021 }
3022
3023 static bool
3024 is_psr_bit (char **oper)
3025 {
3026 const struct psrbit *bits;
3027 int i = 0;
3028
3029 if (IS_CSKY_V1 (mach_flag))
3030 bits = cskyv1_psr_bits;
3031 else
3032 bits = cskyv2_psr_bits;
3033
3034 while (bits[i].name != NULL)
3035 {
3036 if (bits[i].isa && !(bits[i].isa & isa_flag))
3037 {
3038 i++;
3039 continue;
3040 }
3041 if (strncasecmp (*oper, bits[i].name, strlen (bits[i].name)) == 0)
3042 {
3043 *oper += strlen (bits[i].name);
3044 csky_insn.val[csky_insn.idx] |= bits[i].value;
3045 return true;
3046 }
3047 i++;
3048 }
3049 SET_ERROR_STRING (ERROR_OPCODE_PSRBIT, NULL);
3050 return false;
3051 }
3052
3053 static bool
3054 parse_type_cpidx (char** oper)
3055 {
3056 char *s = *oper;
3057 int idx;
3058 if (s[0] == 'c' && s[1] == 'p')
3059 {
3060 if (ISDIGIT (s[2]) && ISDIGIT (s[3]) && ! ISDIGIT (s[4]))
3061 {
3062 idx = (s[2] - '0') * 10 + s[3] - '0';
3063 *oper += 4;
3064 }
3065 else if (ISDIGIT (s[2]) && !ISDIGIT (s[3]))
3066 {
3067 idx = s[2] - '0';
3068 *oper += 3;
3069 }
3070 else
3071 return false;
3072 }
3073 else
3074 {
3075 expressionS e;
3076 *oper = parse_exp (*oper, &e);
3077 if (e.X_op != O_constant)
3078 {
3079 /* Can not recognize the operand. */
3080 return false;
3081 }
3082 idx = e.X_add_number;
3083 }
3084
3085 csky_insn.val[csky_insn.idx++] = idx;
3086
3087 return true;
3088 }
3089
3090 static bool
3091 parse_type_cpreg (char** oper)
3092 {
3093 expressionS e;
3094
3095 if (strncasecmp (*oper, "cpr", 3) != 0)
3096 {
3097 SET_ERROR_STRING(ERROR_CPREG_ILLEGAL, *oper);
3098 return false;
3099 }
3100
3101 *oper += 3;
3102
3103 *oper = parse_exp (*oper, &e);
3104 if (e.X_op != O_constant)
3105 {
3106 SET_ERROR_STRING(ERROR_CPREG_ILLEGAL, *oper);
3107 return false;
3108 }
3109
3110 csky_insn.val[csky_insn.idx++] = e.X_add_number;
3111
3112 return true;
3113 }
3114
3115 static bool
3116 parse_type_cpcreg (char** oper)
3117 {
3118 expressionS e;
3119
3120 if (strncasecmp (*oper, "cpcr", 4) != 0)
3121 {
3122 SET_ERROR_STRING(ERROR_CPREG_ILLEGAL, *oper);
3123 return false;
3124 }
3125
3126 *oper += 4;
3127
3128 *oper = parse_exp (*oper, &e);
3129 if (e.X_op != O_constant)
3130 {
3131 SET_ERROR_STRING(ERROR_CPREG_ILLEGAL, *oper);
3132 return false;
3133 }
3134
3135 csky_insn.val[csky_insn.idx++] = e.X_add_number;
3136
3137 return true;
3138 }
3139
3140 static bool
3141 parse_type_areg (char** oper)
3142 {
3143 int i = 0;
3144 int len = 0;
3145 i = csky_get_reg_val (*oper, &len);
3146 if (i == -1)
3147 {
3148 SET_ERROR_STRING (ERROR_GREG_ILLEGAL, NULL);
3149 return false;
3150 }
3151 *oper += len;
3152 csky_insn.val[csky_insn.idx++] = i;
3153
3154 return true;
3155 }
3156
3157 static bool
3158 parse_type_freg (char** oper, int even)
3159 {
3160 int reg;
3161 int len;
3162 reg = csky_get_freg_val (*oper, &len);
3163 if (reg == -1)
3164 {
3165 SET_ERROR_STRING (ERROR_REG_FORMAT,
3166 (void *)"The fpu register format is not recognized.");
3167 return false;
3168 }
3169 *oper += len;
3170 csky_insn.opcode_end = *oper;
3171 if (even && reg & 0x1)
3172 {
3173 SET_ERROR_STRING (ERROR_EXP_EVEN_FREG, NULL);
3174 return false;
3175 }
3176
3177 if (IS_CSKY_V2 (mach_flag)
3178 && ((csky_insn.opcode->isa_flag32 & CSKY_ISA_VDSP_2)
3179 || !(csky_insn.opcode->isa_flag32 & CSKY_ISA_FLOAT_7E60))
3180 && reg > 15)
3181 {
3182 if ((csky_insn.opcode->isa_flag32 & CSKY_ISA_VDSP_2))
3183 {
3184 SET_ERROR_INTEGER (ERROR_VREG_OVER_RANGE, reg);
3185 }
3186 else
3187 {
3188 SET_ERROR_INTEGER (ERROR_FREG_OVER_RANGE, reg);
3189 }
3190 return false;
3191 }
3192 /* TODO: recognize vreg or freg. */
3193 if (reg > 31)
3194 {
3195 SET_ERROR_INTEGER (ERROR_VREG_OVER_RANGE, reg);
3196 }
3197 csky_insn.val[csky_insn.idx++] = reg;
3198 return true;
3199 }
3200
3201 static bool
3202 parse_ldst_imm (char **oper, struct csky_opcode_info *op ATTRIBUTE_UNUSED,
3203 struct operand *oprnd)
3204 {
3205 unsigned int mask = oprnd->mask;
3206 int max = 1;
3207 int shift = 0;
3208
3209 shift = oprnd->shift;
3210
3211 while (mask)
3212 {
3213 if (mask & 1)
3214 max <<= 1;
3215 mask >>= 1;
3216 }
3217 max = max << shift;
3218
3219 if (**oper == '\0' || **oper == ')')
3220 {
3221 csky_insn.val[csky_insn.idx++] = 0;
3222 return true;
3223 }
3224
3225 expressionS e;
3226 *oper = parse_exp (*oper, &e);
3227 if (e.X_op != O_constant)
3228 {
3229 /* Not a constant. */
3230 SET_ERROR_STRING(ERROR_UNDEFINE, (void *)"Operand format is error. eg. \"ld rz, (rx, n)\"");
3231 return false;
3232 }
3233 else if (e.X_add_number < 0 || e.X_add_number >= max)
3234 {
3235 /* Out of range. */
3236 SET_ERROR_STRING(ERROR_IMM_OVERFLOW, NULL);
3237 return false;
3238 }
3239 if ((e.X_add_number % (1 << shift)) != 0)
3240 {
3241 /* Not aligned. */
3242 SET_ERROR_INTEGER (ERROR_OFFSET_UNALIGNED, ((unsigned long)1 << shift));
3243 return false;
3244 }
3245
3246 csky_insn.val[csky_insn.idx++] = e.X_add_number >> shift;
3247
3248 return true;
3249
3250 }
3251
3252 static unsigned int
3253 csky_count_operands (char *str)
3254 {
3255 char *oper_end = str;
3256 unsigned int oprnd_num;
3257 int bracket_cnt = 0;
3258
3259 if (is_end_of_line[(unsigned char) *oper_end])
3260 oprnd_num = 0;
3261 else
3262 oprnd_num = 1;
3263
3264 /* Count how many operands. */
3265 if (oprnd_num)
3266 while (!is_end_of_line[(unsigned char) *oper_end])
3267 {
3268 if (*oper_end == '(' || *oper_end == '<')
3269 {
3270 bracket_cnt++;
3271 oper_end++;
3272 continue;
3273 }
3274 if (*oper_end == ')' || *oper_end == '>')
3275 {
3276 bracket_cnt--;
3277 oper_end++;
3278 continue;
3279 }
3280 if (!bracket_cnt && *oper_end == ',')
3281 oprnd_num++;
3282 oper_end++;
3283 }
3284 return oprnd_num;
3285 }
3286
3287 /* End of the operand parsing helper functions. */
3288
3289 /* Parse the opcode part of an instruction. Fill in the csky_insn
3290 state and return true on success, false otherwise. */
3291
3292 static bool
3293 parse_opcode (char *str)
3294 {
3295 #define IS_OPCODE32F(a) (*(a - 2) == '3' && *(a - 1) == '2')
3296 #define IS_OPCODE16F(a) (*(a - 2) == '1' && *(a - 1) == '6')
3297
3298 /* TRUE if this opcode has a suffix, like 'lrw.h'. */
3299 unsigned int has_suffix = false;
3300 unsigned int nlen = 0;
3301 char *opcode_end;
3302 char name[OPCODE_MAX_LEN + 1];
3303 char macro_name[OPCODE_MAX_LEN + 1];
3304
3305 /* Remove space ahead of string. */
3306 while (ISSPACE (*str))
3307 str++;
3308 opcode_end = str;
3309
3310 /* Find the opcode end. */
3311 while (nlen < OPCODE_MAX_LEN
3312 && !is_end_of_line [(unsigned char) *opcode_end]
3313 && *opcode_end != ' ')
3314 {
3315 /* Is csky force 32 or 16 instruction? */
3316 if (IS_CSKY_V2 (mach_flag)
3317 && *opcode_end == '.' && !has_suffix)
3318 {
3319 has_suffix = true;
3320 if (IS_OPCODE32F (opcode_end))
3321 {
3322 csky_insn.flag_force = INSN_OPCODE32F;
3323 nlen -= 2;
3324 }
3325 else if (IS_OPCODE16F (opcode_end))
3326 {
3327 csky_insn.flag_force = INSN_OPCODE16F;
3328 nlen -= 2;
3329 }
3330 }
3331 name[nlen] = *opcode_end;
3332 nlen++;
3333 opcode_end++;
3334 }
3335
3336 /* Is csky force 32 or 16 instruction? */
3337 if (!has_suffix)
3338 {
3339 if (IS_CSKY_V2 (mach_flag) && IS_OPCODE32F (opcode_end))
3340 {
3341 csky_insn.flag_force = INSN_OPCODE32F;
3342 nlen -= 2;
3343 }
3344 else if (IS_OPCODE16F (opcode_end))
3345 {
3346 csky_insn.flag_force = INSN_OPCODE16F;
3347 nlen -= 2;
3348 }
3349 }
3350 name[nlen] = '\0';
3351
3352 /* Generate macro_name for finding hash in macro hash_table. */
3353 if (has_suffix)
3354 nlen += 2;
3355 strncpy (macro_name, str, nlen);
3356 macro_name[nlen] = '\0';
3357
3358 /* Get csky_insn.opcode_end. */
3359 while (ISSPACE (*opcode_end))
3360 opcode_end++;
3361 csky_insn.opcode_end = opcode_end;
3362
3363 /* Count the operands. */
3364 csky_insn.number = csky_count_operands (opcode_end);
3365
3366 /* Find hash by name in csky_macros_hash and csky_opcodes_hash. */
3367 csky_insn.macro = (struct csky_macro_info *) str_hash_find (csky_macros_hash,
3368 macro_name);
3369 csky_insn.opcode = (struct csky_opcode *) str_hash_find (csky_opcodes_hash,
3370 name);
3371
3372 if (csky_insn.macro == NULL && csky_insn.opcode == NULL)
3373 return false;
3374 return true;
3375 }
3376
3377 /* Main dispatch routine to parse operand OPRND for opcode OP from string
3378 *OPER. */
3379
3380 static bool
3381 get_operand_value (struct csky_opcode_info *op,
3382 char **oper, struct operand *oprnd)
3383 {
3384 struct soperand *soprnd = NULL;
3385 if (oprnd->mask == HAS_SUB_OPERAND)
3386 {
3387 /* It has sub operand, it must be like:
3388 (oprnd1, oprnd2)
3389 or
3390 <oprnd1, oprnd2>
3391 We will check the format here. */
3392 soprnd = (struct soperand *) oprnd;
3393 char lc = 0;
3394 char rc = 0;
3395 char *s = *oper;
3396 int bracket_cnt = 0;
3397 if (oprnd->type == OPRND_TYPE_BRACKET)
3398 {
3399 lc = '(';
3400 rc = ')';
3401 }
3402 else if (oprnd->type == OPRND_TYPE_ABRACKET)
3403 {
3404 lc = '<';
3405 rc = '>';
3406 }
3407
3408 if (**oper == lc)
3409 {
3410 *oper += 1;
3411 s += 1;
3412 }
3413 else
3414 {
3415 SET_ERROR_STRING ((oprnd->type == OPRND_TYPE_BRACKET
3416 ? ERROR_MISSING_LBRACKET
3417 : ERROR_MISSING_LANGLE_BRACKETS), NULL);
3418 return false;
3419 }
3420
3421 /* If the oprnd2 is an immediate, it can not be parsed
3422 that end with ')'/'>'. Modify ')'/'>' to '\0'. */
3423 while ((*s != rc || bracket_cnt != 0) && (*s != '\n' && *s != '\0'))
3424 {
3425 if (*s == lc)
3426 bracket_cnt++;
3427 else if (*s == rc)
3428 bracket_cnt--;
3429 s++;
3430 }
3431
3432 if (*s == rc)
3433 *s = '\0';
3434 else
3435 {
3436 SET_ERROR_STRING ((oprnd->type == OPRND_TYPE_BRACKET
3437 ? ERROR_MISSING_RBRACKET
3438 : ERROR_MISSING_RANGLE_BRACKETS), NULL);
3439 return false;
3440 }
3441
3442 if (!get_operand_value (op, oper, &soprnd->subs[0]))
3443 {
3444 *s = rc;
3445 return false;
3446 }
3447 if (**oper == ',')
3448 *oper += 1;
3449 else if (**oper != '\0')
3450 {
3451 SET_ERROR_STRING (ERROR_MISSING_COMMA, NULL);
3452 return false;
3453 }
3454
3455 if (!get_operand_value (op, oper, &soprnd->subs[1]))
3456 {
3457 *s = rc;
3458 return false;
3459 }
3460
3461 *s = rc;
3462 *oper += 1;
3463 return true;
3464 }
3465
3466 switch (oprnd->type)
3467 {
3468 /* TODO: add opcode type here, log errors in the function.
3469 If REGLIST, then j = csky_insn.number - 1.
3470 If there is needed to parse expressions, it will be
3471 handled here. */
3472 case OPRND_TYPE_CTRLREG:
3473 /* some parse. */
3474 return parse_type_ctrlreg (oper);
3475 case OPRND_TYPE_AREG:
3476 return parse_type_areg (oper);
3477 case OPRND_TYPE_FREG:
3478 case OPRND_TYPE_VREG:
3479 return parse_type_freg (oper, 0);
3480 case OPRND_TYPE_FEREG:
3481 return parse_type_freg (oper, 1);
3482 case OPRND_TYPE_CPCREG:
3483 return parse_type_cpcreg (oper);
3484 case OPRND_TYPE_CPREG:
3485 return parse_type_cpreg (oper);
3486 case OPRND_TYPE_CPIDX:
3487 return parse_type_cpidx (oper);
3488 case OPRND_TYPE_GREG0_7:
3489 case OPRND_TYPE_GREG0_15:
3490 {
3491 int len;
3492 long reg;
3493 reg = csky_get_reg_val (*oper, &len);
3494
3495 if (reg == -1)
3496 {
3497 SET_ERROR_STRING (ERROR_GREG_ILLEGAL, NULL);
3498 return false;
3499 }
3500 else if ((oprnd->type == OPRND_TYPE_GREG0_7 && reg > 7)
3501 || (oprnd->type == OPRND_TYPE_GREG0_15 && reg > 15))
3502 {
3503 SET_ERROR_INTEGER (ERROR_REG_OVER_RANGE, reg);
3504 return false;
3505 }
3506 *oper += len;
3507 csky_insn.val[csky_insn.idx++] = reg;
3508 return true;
3509 }
3510 case OPRND_TYPE_REGnsplr:
3511 {
3512 int len;
3513 long reg;
3514 reg = csky_get_reg_val (*oper, &len);
3515
3516 if (reg == -1
3517 || (IS_CSKY_V1 (mach_flag)
3518 && (reg == V1_REG_SP || reg == V1_REG_LR)))
3519 {
3520 SET_ERROR_STRING (ERROR_REG_OVER_RANGE, reg);
3521 return false;
3522 }
3523 csky_insn.val[csky_insn.idx++] = reg;
3524 *oper += len;
3525 return true;;
3526 }
3527 case OPRND_TYPE_REGnr4_r7:
3528 {
3529 int len;
3530 int reg;
3531 if (**oper == '(')
3532 *oper += 1;
3533 reg = csky_get_reg_val (*oper, &len);
3534 if (reg == -1 || (reg <= 7 && reg >= 4))
3535 return false;
3536
3537 csky_insn.val[csky_insn.idx++] = reg;
3538 *oper += len;
3539
3540 if (**oper == ')')
3541 *oper += 1;
3542 return true;;
3543 }
3544 case OPRND_TYPE_REGr4_r7:
3545 if (memcmp (*oper, "r4-r7", sizeof ("r4-r7") - 1) == 0)
3546 {
3547 *oper += sizeof ("r4-r7") - 1;
3548 csky_insn.val[csky_insn.idx++] = 0;
3549 return true;
3550 }
3551 SET_ERROR_STRING (ERROR_OPCODE_ILLEGAL, NULL);
3552 return false;
3553 case OPRND_TYPE_IMM_LDST:
3554 return parse_ldst_imm (oper, op, oprnd);
3555 case OPRND_TYPE_IMM_FLDST:
3556 return parse_ldst_imm (oper, op, oprnd);
3557 case OPRND_TYPE_IMM1b:
3558 return is_imm_within_range (oper, 0, 1);
3559 case OPRND_TYPE_IMM2b:
3560 return is_imm_within_range (oper, 0, 3);
3561 case OPRND_TYPE_IMM2b_JMPIX:
3562 /* ck802j support jmpix16, but not support jmpix32. */
3563 if (IS_CSKY_ARCH_802 (mach_flag)
3564 && (op->opcode & 0xffff0000) != 0)
3565 {
3566 SET_ERROR_STRING (ERROR_OPCODE_ILLEGAL, NULL);
3567 return false;
3568 }
3569 *oper = parse_exp (*oper, &csky_insn.e1);
3570 if (csky_insn.e1.X_op == O_constant)
3571 {
3572 csky_insn.opcode_end = *oper;
3573 if (csky_insn.e1.X_add_number & 0x7)
3574 {
3575 SET_ERROR_STRING (ERROR_JMPIX_OVER_RANGE, NULL);
3576 return false;
3577 }
3578 csky_insn.val[csky_insn.idx++]
3579 = (csky_insn.e1.X_add_number >> 3) - 2;
3580 }
3581 return true;
3582 case OPRND_TYPE_IMM4b:
3583 return is_imm_within_range (oper, 0, 15);
3584 case OPRND_TYPE_IMM5b:
3585 return is_imm_within_range (oper, 0, 31);
3586 /* This type for "bgeni" in csky v1 ISA. */
3587 case OPRND_TYPE_IMM5b_7_31:
3588 if (is_imm_within_range (oper, 0, 31))
3589 {
3590 int val = csky_insn.val[csky_insn.idx - 1];
3591 /* immediate values of 0 -> 6 translate to movi. */
3592 if (val <= 6)
3593 {
3594 const char *name = "movi";
3595 csky_insn.opcode = (struct csky_opcode *)
3596 str_hash_find (csky_opcodes_hash, name);
3597 csky_insn.val[csky_insn.idx - 1] = 1 << val;
3598 }
3599 return true;
3600 }
3601 else
3602 return false;
3603
3604 case OPRND_TYPE_IMM5b_1_31:
3605 return is_imm_within_range (oper, 1, 31);
3606 case OPRND_TYPE_IMM5b_POWER:
3607 if (is_imm_within_range_ext (oper, 1, (1u << 31) - 1, 1u << 31))
3608 {
3609 int log;
3610 int val = csky_insn.val[csky_insn.idx - 1];
3611 log = csky_log_2 (val);
3612 csky_insn.val[csky_insn.idx - 1] = log;
3613 return log != -1;
3614 }
3615 else
3616 return false;
3617
3618 /* This type for "mgeni" in csky v1 ISA. */
3619 case OPRND_TYPE_IMM5b_7_31_POWER:
3620 if (is_imm_within_range_ext (oper, 1, (1u << 31) - 1, 1u << 31))
3621 {
3622 int log;
3623 int val = csky_insn.val[csky_insn.idx - 1];
3624 log = csky_log_2 (val);
3625 /* Immediate values of 0 -> 6 translate to movi. */
3626 if (log <= 6)
3627 {
3628 const char *name = "movi";
3629 csky_insn.opcode = (struct csky_opcode *)
3630 str_hash_find (csky_opcodes_hash, name);
3631 as_warn (_("translating mgeni to movi"));
3632 }
3633 else
3634 csky_insn.val[csky_insn.idx - 1] = log;
3635 return log != -1;
3636 }
3637 else
3638 return false;
3639
3640 case OPRND_TYPE_IMM5b_LS:
3641 return is_imm_within_range (oper,
3642 0,
3643 csky_insn.val[csky_insn.idx - 1]);
3644 case OPRND_TYPE_IMM5b_RORI:
3645 {
3646 unsigned max_shift = IS_CSKY_V1 (mach_flag) ? 31 : 32;
3647
3648 if (is_imm_within_range (oper, 1, max_shift))
3649 {
3650 int i = csky_insn.idx - 1;
3651 csky_insn.val[i] = 32 - csky_insn.val[i];
3652 return true;
3653 }
3654 else
3655 return false;
3656 }
3657
3658 case OPRND_TYPE_IMM5b_BMASKI:
3659 /* For csky v1 bmask inst. */
3660
3661 if (!is_imm_within_range_ext (oper, 8, 31, 0))
3662 {
3663 unsigned int mask_val = csky_insn.val[csky_insn.idx - 1];
3664 if (mask_val > 0 && mask_val < 8)
3665 {
3666 const char *op_movi = "movi";
3667 csky_insn.opcode = (struct csky_opcode *)
3668 str_hash_find (csky_opcodes_hash, op_movi);
3669 if (csky_insn.opcode == NULL)
3670 return false;
3671 csky_insn.val[csky_insn.idx - 1] = (1 << mask_val) - 1;
3672 return true;
3673 }
3674 }
3675 return true;
3676
3677 case OPRND_TYPE_IMM5b_VSH:
3678 /* For vshri.T and vshli.T. */
3679 if (is_imm_within_range (oper, 0, 31))
3680 {
3681 int val = csky_insn.val[csky_insn.idx - 1];
3682 val = (val << 1) | (val >> 4);
3683 val &= 0x1f;
3684 csky_insn.val[csky_insn.idx - 1] = val;
3685 return true;
3686 }
3687 return false;
3688 case OPRND_TYPE_IMM8b_BMASKI:
3689 /* For csky v2 bmask, which will transfer to 16bits movi. */
3690 if (is_imm_within_range (oper, 1, 8))
3691 {
3692 unsigned int mask_val = csky_insn.val[csky_insn.idx - 1];
3693 csky_insn.val[csky_insn.idx - 1] = (1 << mask_val) - 1;
3694 return true;
3695 }
3696 return false;
3697 case OPRND_TYPE_OIMM4b:
3698 return is_oimm_within_range (oper, 1, 16);
3699 case OPRND_TYPE_OIMM5b:
3700 return is_oimm_within_range (oper, 1, 32);
3701 case OPRND_TYPE_OIMM5b_IDLY:
3702 if (is_imm_within_range (oper, 0, 32))
3703 {
3704 /* imm5b for idly n: 0<=n<4, imm5b=3; 4<=n<=32, imm5b=n-1. */
3705 unsigned long imm = csky_insn.val[csky_insn.idx - 1];
3706 if (imm < 4)
3707 {
3708 csky_show_error (WARNING_IDLY, 0, (void *)imm, NULL);
3709 imm = 3;
3710 }
3711 else imm--;
3712 csky_insn.val[csky_insn.idx - 1] = imm;
3713 return true;
3714 }
3715 else
3716 return false;
3717
3718 /* For csky v2 bmask inst. */
3719 case OPRND_TYPE_OIMM5b_BMASKI:
3720 if (!is_oimm_within_range (oper, 17, 32))
3721 {
3722 int mask_val = csky_insn.val[csky_insn.idx - 1];
3723 if (mask_val + 1 == 0)
3724 return true;
3725 if (mask_val > 0 && mask_val < 16)
3726 {
3727 const char *op_movi = "movi";
3728 csky_insn.opcode = (struct csky_opcode *)
3729 str_hash_find (csky_opcodes_hash, op_movi);
3730 if (csky_insn.opcode == NULL)
3731 return false;
3732 csky_insn.val[csky_insn.idx - 1] = (1 << (mask_val + 1)) - 1;
3733 return true;
3734 }
3735 }
3736 return true;
3737 case OPRND_TYPE_IMM7b:
3738 return is_imm_within_range (oper, 0, 127);
3739 case OPRND_TYPE_IMM8b:
3740 return is_imm_within_range (oper, 0, 255);
3741 case OPRND_TYPE_IMM9b:
3742 return is_imm_within_range (oper, -256, 255);
3743 case OPRND_TYPE_IMM12b:
3744 return is_imm_within_range (oper, 0, 4095);
3745 case OPRND_TYPE_IMM15b:
3746 return is_imm_within_range (oper, 0, 0xfffff);
3747 case OPRND_TYPE_IMM16b:
3748 return is_imm_within_range (oper, 0, 65535);
3749 case OPRND_TYPE_OIMM16b:
3750 return is_oimm_within_range (oper, 1, 65536);
3751 case OPRND_TYPE_IMM32b:
3752 {
3753 expressionS e;
3754 char *new_oper = parse_exp (*oper, &e);
3755 if (e.X_op == O_constant)
3756 {
3757 *oper = new_oper;
3758 csky_insn.val[csky_insn.idx++] = e.X_add_number;
3759 return true;
3760 }
3761 return false;
3762 }
3763 case OPRND_TYPE_IMM16b_MOVIH:
3764 case OPRND_TYPE_IMM16b_ORI:
3765 {
3766 bfd_reloc_code_real_type r = BFD_RELOC_NONE;
3767 int len;
3768 char *curr = *oper;
3769 char * save = input_line_pointer;
3770 /* get the reloc type, and set "@GOTxxx" as ' ' */
3771 while (**oper != '@' && **oper != '\0')
3772 *oper += 1;
3773 if (**oper != '\0')
3774 {
3775 input_line_pointer = *oper;
3776 lex_got (&r, &len);
3777 while (*(*oper + len + 1) != '\0')
3778 {
3779 **oper = *(*oper + len + 1);
3780 *(*oper + len + 1) = '\0';
3781 *oper += 1;
3782 }
3783 **oper = '\0';
3784 }
3785 input_line_pointer = save;
3786 *oper = parse_exp (curr, &csky_insn.e1);
3787 return true;
3788 }
3789 case OPRND_TYPE_PSR_BITS_LIST:
3790 {
3791 int ret = true;
3792 if (csky_insn.number == 0)
3793 ret = false;
3794 else
3795 {
3796 csky_insn.val[csky_insn.idx] = 0;
3797 if (is_psr_bit (oper))
3798 while (**oper == ',')
3799 {
3800 *oper += 1;
3801 if (!is_psr_bit (oper))
3802 {
3803 ret = false;
3804 break;
3805 }
3806 }
3807 else
3808 ret = false;
3809 if (ret && IS_CSKY_V1 (mach_flag)
3810 && csky_insn.val[csky_insn.idx] > 8)
3811 ret = false;
3812 }
3813 if (!ret)
3814 SET_ERROR_STRING (ERROR_OPERANDS_ILLEGAL, csky_insn.opcode_end);
3815 return ret;
3816 }
3817 case OPRND_TYPE_RM:
3818 {
3819 /* FPU round mode. */
3820 static const char *round_mode[] =
3821 {
3822 "rm_nearest",
3823 "rm_zero",
3824 "rm_posinf",
3825 "rm_neginf",
3826 NULL
3827 };
3828 int i;
3829 for (i = 0; round_mode[i]; i++)
3830 if (strncasecmp (*oper, round_mode[i], strlen (round_mode[i])) == 0)
3831 {
3832 *oper += strlen (round_mode[i]);
3833 csky_insn.val[csky_insn.idx++] = i;
3834 return true;
3835 }
3836 return false;
3837 }
3838
3839 case OPRND_TYPE_REGLIST_COMMA:
3840 case OPRND_TYPE_BRACKET:
3841 /* TODO: using sub operand union. */
3842 case OPRND_TYPE_ABRACKET:
3843 /* TODO: using sub operand union. */
3844 case OPRND_TYPE_REGLIST_DASH:
3845 return is_reglist_legal (oper);
3846 case OPRND_TYPE_FREGLIST_DASH:
3847 return is_freglist_legal (oper);
3848 case OPRND_TYPE_AREG_WITH_BRACKET:
3849 {
3850 int len;
3851 int reg;
3852 if (**oper != '(')
3853 {
3854 SET_ERROR_STRING (ERROR_MISSING_LBRACKET, NULL);
3855 return false;
3856 }
3857 *oper += 1;
3858 reg = csky_get_reg_val (*oper, &len);
3859 if (reg == -1)
3860 {
3861 SET_ERROR_STRING (ERROR_EXP_GREG, NULL);
3862 return false;
3863 }
3864 *oper += len;
3865 if (**oper != ')')
3866 {
3867 SET_ERROR_STRING (ERROR_MISSING_RBRACKET, NULL);
3868 return false;
3869 }
3870 *oper += 1;
3871 csky_insn.val[csky_insn.idx++] = reg;
3872 return true;
3873 }
3874 case OPRND_TYPE_REGsp:
3875 return is_reg_sp (oper);
3876 case OPRND_TYPE_REGbsp:
3877 return is_reg_sp_with_bracket (oper);
3878 /* For jmpi. */
3879 case OPRND_TYPE_OFF8b:
3880 case OPRND_TYPE_OFF16b:
3881 *oper = parse_rt (*oper, 1, &csky_insn.e1, -1);
3882 csky_insn.val[csky_insn.idx++] = 0;
3883 return true;
3884 case OPRND_TYPE_LABEL_WITH_BRACKET:
3885 case OPRND_TYPE_CONSTANT:
3886 case OPRND_TYPE_ELRW_CONSTANT:
3887 if (**oper == '[')
3888 csky_insn.val[csky_insn.idx++] = 0;
3889 else
3890 csky_insn.val[csky_insn.idx++] = NEED_OUTPUT_LITERAL;
3891 *oper = parse_rt (*oper, 0, &csky_insn.e1, -1);
3892 return true;
3893 case OPRND_TYPE_FCONSTANT:
3894 *oper = parse_rtf (*oper, 0, &csky_insn.e1);
3895 return true;
3896
3897 case OPRND_TYPE_SFLOAT:
3898 case OPRND_TYPE_DFLOAT:
3899 /* For fmovis and fmovid, which accept a constant float with
3900 a limited range. */
3901 {
3902 uint64_t dbnum;
3903 int imm4, imm8;
3904
3905 *oper = parse_fexp (*oper, &csky_insn.e1, 1, &dbnum);
3906 if (csky_insn.e1.X_op == O_absent)
3907 return false;
3908
3909 /* Convert the representation from IEEE double to the 13-bit
3910 encoding used internally for fmovis and fmovid. */
3911 imm4 = 11 - (((dbnum & 0x7ff0000000000000ULL) >> 52) - 1023);
3912 /* Check float range. */
3913 if ((dbnum & 0x00000fffffffffffULL) || imm4 < 0 || imm4 > 15)
3914 {
3915 csky_show_error (ERROR_IMM_OVERFLOW, 2, NULL, NULL);
3916 return false;
3917 }
3918 imm8 = (dbnum & 0x000ff00000000000ULL) >> 44;
3919 csky_insn.e1.X_add_number
3920 = (((imm8 & 0xf) << 4)
3921 | ((imm8 & 0xf0) << 17)
3922 | ((imm4 & 0xf) << 16)
3923 | ((dbnum & 0x8000000000000000ULL) >> 43));
3924 return true;
3925 }
3926 case OPRND_TYPE_HFLOAT_FMOVI:
3927 case OPRND_TYPE_SFLOAT_FMOVI:
3928 case OPRND_TYPE_DFLOAT_FMOVI:
3929 /* For fpuv3 fmovis and fmovid, which accept a constant
3930 float with a limited range. */
3931 {
3932 uint64_t dbnum;
3933 int imm4, imm8, sign;
3934
3935 *oper = parse_fexp (*oper, &csky_insn.e1, 1, &dbnum);
3936 if (csky_insn.e1.X_op == O_absent)
3937 return false;
3938
3939 /* Convert the representation from IEEE double to the 13-bit
3940 encoding used internally for fmovis and fmovid. */
3941 imm4 = 11 - (((dbnum & 0x7ff0000000000000ULL) >> 52) - 1023);
3942 /* Check float range. */
3943 if ((dbnum & 0x00000fffffffffffULL) || imm4 < 0 || imm4 > 15)
3944 {
3945 csky_show_error (ERROR_IMM_OVERFLOW, 2, NULL, NULL);
3946 return true;
3947 }
3948 imm8 = (dbnum & 0x000ff00000000000ULL) >> 44;
3949 sign = (dbnum & 0x8000000000000000ULL) >> 58;
3950 csky_insn.e1.X_add_number
3951 = (((imm8 & 0x3) << 8)
3952 | ((imm8 & 0xfc) << 18)
3953 | ((imm4 & 0xf) << 16)
3954 | sign);
3955 return true;
3956 }
3957 /* For grs v2. */
3958 case OPRND_TYPE_IMM_OFF18b:
3959 *oper = parse_exp (*oper, &csky_insn.e1);
3960 return true;
3961
3962 case OPRND_TYPE_BLOOP_OFF4b:
3963 *oper = parse_exp (*oper, &csky_insn.e2);
3964 if (csky_insn.e2.X_op == O_symbol)
3965 {
3966 csky_insn.opcode_end = *oper;
3967 return true;
3968 }
3969 else
3970 return false;
3971
3972 case OPRND_TYPE_BLOOP_OFF12b:
3973 case OPRND_TYPE_OFF10b:
3974 case OPRND_TYPE_OFF11b:
3975 case OPRND_TYPE_OFF16b_LSL1:
3976 case OPRND_TYPE_OFF26b:
3977 *oper = parse_exp (*oper, &csky_insn.e1);
3978 if (csky_insn.e1.X_op == O_symbol)
3979 {
3980 csky_insn.opcode_end = *oper;
3981 return true;
3982 }
3983 else
3984 return false;
3985 /* For xtrb0(1)(2)(3) and div in csky v1 ISA. */
3986 case OPRND_TYPE_REG_r1a:
3987 {
3988 int reg = 0;
3989 int len = 0;
3990 reg = csky_get_reg_val (*oper, &len);
3991 if (reg == -1)
3992 {
3993 SET_ERROR_STRING (ERROR_REG_FORMAT,
3994 "The first operand must be register r1.");
3995 return false;
3996 }
3997 if (reg != 1)
3998 mov_r1_after = true;
3999 *oper += len;
4000 csky_insn.opcode_end = *oper;
4001 csky_insn.val[csky_insn.idx++] = reg;
4002 return true;
4003 }
4004 case OPRND_TYPE_REG_r1b:
4005 {
4006 int reg = 0;
4007 int len = 0;
4008 reg = csky_get_reg_val (*oper, &len);
4009 if (reg == -1)
4010 {
4011 SET_ERROR_STRING (ERROR_REG_FORMAT,
4012 "The second operand must be register r1.");
4013 return false;
4014 }
4015 if (reg != 1)
4016 {
4017 unsigned int mov_insn = CSKYV1_INST_MOV_R1_RX;
4018 mov_insn |= reg << 4;
4019 mov_r1_before = true;
4020 csky_insn.output = frag_more (2);
4021 dwarf2_emit_insn (0);
4022 md_number_to_chars (csky_insn.output, mov_insn, 2);
4023 }
4024 *oper += len;
4025 csky_insn.opcode_end = *oper;
4026 csky_insn.val[csky_insn.idx++] = reg;
4027 return true;
4028 }
4029 case OPRND_TYPE_DUMMY_REG:
4030 {
4031 int reg = 0;
4032 int len = 0;
4033 reg = csky_get_reg_val (*oper, &len);
4034 if (reg == -1)
4035 {
4036 SET_ERROR_STRING (ERROR_GREG_ILLEGAL, NULL);
4037 return false;
4038 }
4039 if (reg != csky_insn.val[0])
4040 {
4041 SET_ERROR_STRING (ERROR_REG_FORMAT,
4042 "The second register must be the same as the first.");
4043 return false;
4044 }
4045 *oper += len;
4046 csky_insn.opcode_end = *oper;
4047 csky_insn.val[csky_insn.idx++] = reg;
4048 return true;
4049 }
4050 case OPRND_TYPE_2IN1_DUMMY:
4051 {
4052 int reg = 0;
4053 int len = 0;
4054 int max = 0;
4055 int min = 0;
4056 reg = csky_get_reg_val (*oper, &len);
4057 if (reg == -1)
4058 {
4059 SET_ERROR_STRING (ERROR_GREG_ILLEGAL, NULL);
4060 return false;
4061 }
4062 /* dummy reg's real type should be same with first operand. */
4063 if (op->oprnd.oprnds[0].type == OPRND_TYPE_GREG0_15)
4064 max = 15;
4065 else if (op->oprnd.oprnds[0].type == OPRND_TYPE_GREG0_7)
4066 max = 7;
4067 else
4068 return false;
4069 if (reg < min || reg > max)
4070 return false;
4071 csky_insn.val[csky_insn.idx++] = reg;
4072 /* if it is the last operands. */
4073 if (csky_insn.idx > 2)
4074 {
4075 /* For "insn rz, rx, ry", if rx or ry is equal to rz,
4076 we can output the insn like "insn rz, rx". */
4077 if (csky_insn.val[0] == csky_insn.val[1])
4078 csky_insn.val[1] = 0;
4079 else if (csky_insn.val[0] == csky_insn.val[2])
4080 csky_insn.val[2] = 0;
4081 else
4082 return false;
4083 }
4084 *oper += len;
4085 csky_insn.opcode_end = *oper;
4086 return true;
4087 }
4088 case OPRND_TYPE_DUP_GREG0_7:
4089 case OPRND_TYPE_DUP_GREG0_15:
4090 case OPRND_TYPE_DUP_AREG:
4091 {
4092 long reg = 0;
4093 int len = 0;
4094 long max_reg;
4095 unsigned int shift_num;
4096 if (oprnd->type == OPRND_TYPE_DUP_GREG0_7)
4097 {
4098 max_reg = 7;
4099 shift_num = 3;
4100 }
4101 else if (oprnd->type == OPRND_TYPE_DUP_GREG0_15)
4102 {
4103 max_reg = 15;
4104 shift_num = 4;
4105 }
4106 else
4107 {
4108 max_reg = 31;
4109 shift_num = 5;
4110 }
4111 reg = csky_get_reg_val (*oper, &len);
4112 if (reg == -1)
4113 {
4114 if (max_reg == 31)
4115 SET_ERROR_STRING (ERROR_REG_FORMAT,
4116 "The register must be r0-r31");
4117 else
4118 SET_ERROR_STRING (ERROR_REG_FORMAT,
4119 "The register must be r0-r15");
4120 return false;
4121 }
4122 if (reg > max_reg)
4123 {
4124 SET_ERROR_STRING (ERROR_REG_OVER_RANGE, reg);
4125 return false;
4126 }
4127 reg |= reg << shift_num;
4128 *oper += len;
4129 csky_insn.opcode_end = *oper;
4130 csky_insn.val[csky_insn.idx++] = reg;
4131 return true;
4132 }
4133 case OPRND_TYPE_CONST1:
4134 *oper = parse_exp (*oper, &csky_insn.e1);
4135 if (csky_insn.e1.X_op == O_constant)
4136 {
4137 csky_insn.opcode_end = *oper;
4138 if (csky_insn.e1.X_add_number != 1)
4139 return false;
4140 csky_insn.val[csky_insn.idx++] = 1;
4141 return true;
4142 }
4143 return false;
4144 case OPRND_TYPE_UNCOND10b:
4145 case OPRND_TYPE_UNCOND16b:
4146 *oper = parse_exp (*oper, &csky_insn.e1);
4147 if (csky_insn.e1.X_op == O_constant)
4148 return false;
4149 input_line_pointer = *oper;
4150 csky_insn.opcode_end = *oper;
4151 csky_insn.relax.max = UNCD_DISP16_LEN;
4152 csky_insn.relax.var = UNCD_DISP10_LEN;
4153 csky_insn.relax.subtype = UNCD_DISP10;
4154 csky_insn.val[csky_insn.idx++] = 0;
4155 return true;
4156 case OPRND_TYPE_COND10b:
4157 case OPRND_TYPE_COND16b:
4158 *oper = parse_exp (*oper, &csky_insn.e1);
4159 if (csky_insn.e1.X_op == O_constant)
4160 return false;
4161 input_line_pointer = *oper;
4162 csky_insn.opcode_end = *oper;
4163 /* CK801 doesn't have 32-bit bt/bf insns; relax to a short
4164 jump around a 32-bit unconditional branch instead. */
4165 if (IS_CSKY_ARCH_801 (mach_flag))
4166 {
4167 csky_insn.relax.max = SCOND_DISP16_LEN;
4168 csky_insn.relax.var = SCOND_DISP10_LEN;
4169 csky_insn.relax.subtype = SCOND_DISP10;
4170 }
4171 else
4172 {
4173 csky_insn.relax.max = COND_DISP16_LEN;
4174 csky_insn.relax.var = COND_DISP10_LEN;
4175 csky_insn.relax.subtype = COND_DISP10;
4176 }
4177 csky_insn.val[csky_insn.idx++] = 0;
4178 return true;
4179 case OPRND_TYPE_JCOMPZ:
4180 *oper = parse_exp (*oper, &csky_insn.e1);
4181 if (csky_insn.e1.X_op == O_constant)
4182 return false;
4183 input_line_pointer = *oper;
4184 csky_insn.opcode_end = *oper;
4185 csky_insn.relax.max = JCOMPZ_DISP32_LEN;
4186 csky_insn.relax.var = JCOMPZ_DISP16_LEN;
4187 csky_insn.relax.subtype = JCOMPZ_DISP16;
4188 csky_insn.max = JCOMPZ_DISP32_LEN;
4189 csky_insn.val[csky_insn.idx++] = 0;
4190 return true;
4191 case OPRND_TYPE_JBTF:
4192 *oper = parse_exp (*oper, &csky_insn.e1);
4193 input_line_pointer = *oper;
4194 csky_insn.opcode_end = *oper;
4195 csky_insn.relax.max = csky_relax_table[C (COND_JUMP_S, DISP32)].rlx_length;
4196 csky_insn.relax.var = csky_relax_table[C (COND_JUMP_S, DISP12)].rlx_length;
4197 csky_insn.relax.subtype = C (COND_JUMP_S, 0);
4198 csky_insn.val[csky_insn.idx++] = 0;
4199 csky_insn.max = C32_LEN_S + 2;
4200 return true;
4201 case OPRND_TYPE_JBR:
4202 *oper = parse_exp (*oper, &csky_insn.e1);
4203 input_line_pointer = *oper;
4204 csky_insn.opcode_end = *oper;
4205 csky_insn.relax.max = csky_relax_table[C (UNCD_JUMP_S, DISP32)].rlx_length;
4206 csky_insn.relax.var = csky_relax_table[C (UNCD_JUMP_S, DISP12)].rlx_length;
4207 csky_insn.relax.subtype = C (UNCD_JUMP_S, 0);
4208 csky_insn.val[csky_insn.idx++] = 0;
4209 csky_insn.max = U32_LEN_S + 2;
4210 return true;
4211 case OPRND_TYPE_JBSR:
4212 if (do_force2bsr)
4213 *oper = parse_exp (*oper, &csky_insn.e1);
4214 else
4215 *oper = parse_rt (*oper, 1, &csky_insn.e1, -1);
4216 input_line_pointer = *oper;
4217 csky_insn.opcode_end = *oper;
4218 csky_insn.val[csky_insn.idx++] = 0;
4219 return true;
4220 case OPRND_TYPE_REGLIST_DASH_COMMA:
4221 return is_reglist_dash_comma_legal (oper, oprnd);
4222
4223 case OPRND_TYPE_MSB2SIZE:
4224 case OPRND_TYPE_LSB2SIZE:
4225 {
4226 expressionS e;
4227 char *new_oper = parse_exp (*oper, &e);
4228 if (e.X_op == O_constant)
4229 {
4230 *oper = new_oper;
4231 if (e.X_add_number > 31)
4232 {
4233 SET_ERROR_STRING (ERROR_IMM_OVERFLOW, NULL);
4234 return false;
4235 }
4236 csky_insn.val[csky_insn.idx++] = e.X_add_number;
4237 if (oprnd->type == OPRND_TYPE_LSB2SIZE)
4238 {
4239 if (csky_insn.val[csky_insn.idx - 1] > csky_insn.val[csky_insn.idx - 2])
4240 {
4241 SET_ERROR_STRING (ERROR_IMM_OVERFLOW, NULL);
4242 return false;
4243 }
4244 csky_insn.val[csky_insn.idx - 2] -= e.X_add_number;
4245 }
4246 return true;
4247 }
4248 return false;
4249 }
4250 case OPRND_TYPE_AREG_WITH_LSHIFT:
4251 return is_reg_lshift_illegal (oper, 0);
4252 case OPRND_TYPE_AREG_WITH_LSHIFT_FPU:
4253 return is_reg_lshift_illegal (oper, 1);
4254 case OPRND_TYPE_FREG_WITH_INDEX:
4255 case OPRND_TYPE_VREG_WITH_INDEX:
4256 if (parse_type_freg (oper, 0))
4257 {
4258 if (**oper == '[')
4259 {
4260 (*oper)++;
4261 if (is_imm_within_range (oper, 0, 0xf))
4262 {
4263 if (**oper == ']')
4264 {
4265 unsigned int idx = --csky_insn.idx;
4266 unsigned int val = csky_insn.val[idx];
4267 (*oper)++;
4268 csky_insn.val[idx - 1] |= val << 4;
4269 return true;
4270 }
4271 else
4272 SET_ERROR_STRING (ERROR_MISSING_RSQUARE_BRACKETS, NULL);
4273 }
4274 }
4275 else
4276 SET_ERROR_STRING (ERROR_MISSING_LSQUARE_BRACKETS, NULL);
4277 }
4278 return false;
4279
4280 default:
4281 break;
4282 /* error code. */
4283 }
4284 return false;
4285 }
4286
4287 /* Subroutine of parse_operands. */
4288
4289 static bool
4290 parse_operands_op (char *str, struct csky_opcode_info *op)
4291 {
4292 int i;
4293 int j;
4294 char *oper = str;
4295 int flag_pass;
4296
4297 for (i = 0; i < OP_TABLE_NUM && op[i].operand_num != -2; i++)
4298 {
4299 flag_pass = true;
4300 csky_insn.idx = 0;
4301 oper = str;
4302 /* if operand_num = -1, it is a insn with a REGLIST type operand.i. */
4303 if (!(op[i].operand_num == csky_insn.number
4304 || (op[i].operand_num == -1 && csky_insn.number != 0)))
4305 {
4306 /* The smaller err_num is more serious. */
4307 SET_ERROR_INTEGER (ERROR_OPERANDS_NUMBER, op[i].operand_num);
4308 flag_pass = false;
4309 continue;
4310 }
4311
4312 for (j = 0; j < csky_insn.number; j++)
4313 {
4314 while (ISSPACE (*oper))
4315 oper++;
4316 flag_pass = get_operand_value (&op[i], &oper,
4317 &op[i].oprnd.oprnds[j]);
4318 if (!flag_pass)
4319 break;
4320 while (ISSPACE (*oper))
4321 oper++;
4322 /* Skip the ','. */
4323 if (j < csky_insn.number - 1 && op[i].operand_num != -1)
4324 {
4325 if (*oper == ',')
4326 oper++;
4327 else
4328 {
4329 SET_ERROR_STRING (ERROR_MISSING_COMMA, NULL);
4330 flag_pass = false;
4331 break;
4332 }
4333 }
4334 else if (!is_end_of_line[(unsigned char) *oper])
4335 {
4336 SET_ERROR_STRING (ERROR_BAD_END, NULL);
4337 flag_pass = false;
4338 break;
4339 }
4340 else
4341 break;
4342 }
4343 /* Parse operands in one table end. */
4344
4345 if (flag_pass)
4346 {
4347 /* Parse operands success, set opcode_idx. */
4348 csky_insn.opcode_idx = i;
4349 return true;
4350 }
4351 else
4352 error_state.opnum = j + 1;
4353 }
4354 /* Parse operands in ALL tables end. */
4355 return false;
4356 }
4357
4358 /* Parse the operands according to operand type. */
4359
4360 static bool
4361 parse_operands (char *str)
4362 {
4363 char *oper = str;
4364
4365 /* Parse operands according to flag_force. */
4366 if (csky_insn.flag_force == INSN_OPCODE16F
4367 && (csky_insn.opcode->isa_flag16 & isa_flag) != 0)
4368 {
4369 if (parse_operands_op (oper, csky_insn.opcode->op16))
4370 {
4371 csky_insn.isize = 2;
4372 return true;
4373 }
4374 return false;
4375 }
4376 else if (csky_insn.flag_force == INSN_OPCODE32F
4377 && (csky_insn.opcode->isa_flag32 & isa_flag) != 0)
4378 {
4379 if (parse_operands_op (oper, csky_insn.opcode->op32))
4380 {
4381 csky_insn.isize = 4;
4382 return true;
4383 }
4384 return false;
4385 }
4386 else
4387 {
4388 if ((csky_insn.opcode->isa_flag16 & isa_flag) != 0
4389 && parse_operands_op (oper, csky_insn.opcode->op16))
4390 {
4391 csky_insn.isize = 2;
4392 return true;
4393 }
4394 if ((csky_insn.opcode->isa_flag32 & isa_flag) != 0
4395 && parse_operands_op (oper, csky_insn.opcode->op32))
4396 {
4397 csky_insn.isize = 4;
4398 return true;
4399 }
4400 return false;
4401 }
4402 }
4403
4404 static bool
4405 csky_generate_frags (void)
4406 {
4407 /* frag more relax reloc. */
4408 if (csky_insn.flag_force == INSN_OPCODE16F
4409 || !IS_SUPPORT_OPCODE32 (csky_insn.opcode))
4410 {
4411 csky_insn.output = frag_more (csky_insn.isize);
4412 if (csky_insn.opcode->reloc16)
4413 {
4414 /* 16 bits opcode force, should generate fixup. */
4415 reloc_howto_type *howto;
4416 howto = bfd_reloc_type_lookup (stdoutput,
4417 csky_insn.opcode->reloc16);
4418 fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
4419 2, &csky_insn.e1, howto->pc_relative,
4420 csky_insn.opcode->reloc16);
4421 }
4422 }
4423 else if (csky_insn.flag_force == INSN_OPCODE32F)
4424 {
4425 csky_insn.output = frag_more (csky_insn.isize);
4426 if (csky_insn.opcode->reloc32)
4427 {
4428 reloc_howto_type *howto;
4429 howto = bfd_reloc_type_lookup (stdoutput,
4430 csky_insn.opcode->reloc32);
4431 fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
4432 4, &csky_insn.e1, howto->pc_relative,
4433 csky_insn.opcode->reloc32);
4434 }
4435 }
4436 else if (csky_insn.opcode->relax)
4437 /* Generate the relax information. */
4438 csky_insn.output = frag_var (rs_machine_dependent,
4439 csky_insn.relax.max,
4440 csky_insn.relax.var,
4441 csky_insn.relax.subtype,
4442 csky_insn.e1.X_add_symbol,
4443 csky_insn.e1.X_add_number, 0);
4444 else
4445 {
4446 csky_insn.output = frag_more (csky_insn.isize);
4447 if (csky_insn.opcode->reloc16 && csky_insn.isize == 2)
4448 {
4449 reloc_howto_type *howto;
4450 howto = bfd_reloc_type_lookup (stdoutput,
4451 csky_insn.opcode->reloc16);
4452 fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
4453 2, &csky_insn.e1, howto->pc_relative,
4454 csky_insn.opcode->reloc16);
4455 }
4456 else if (csky_insn.opcode->reloc32 && csky_insn.isize == 4)
4457 {
4458 reloc_howto_type *howto;
4459 howto = bfd_reloc_type_lookup (stdoutput,
4460 csky_insn.opcode->reloc32);
4461 fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
4462 4, &csky_insn.e1, howto->pc_relative,
4463 csky_insn.opcode->reloc32);
4464 }
4465 }
4466 return true;
4467 }
4468
4469 /* Return the bits of VAL shifted according to MASK. The bits of MASK
4470 need not be contiguous. */
4471
4472 static int
4473 generate_masked_value (int mask, int val)
4474 {
4475 int ret = 0;
4476 int bit;
4477
4478 for (bit = 1; mask; bit = bit << 1)
4479 if (mask & bit)
4480 {
4481 if (val & 0x1)
4482 ret |= bit;
4483 val = val >> 1;
4484 mask &= ~bit;
4485 }
4486 return ret;
4487 }
4488
4489 /* Return the result of masking operand number OPRND_IDX into the
4490 instruction word according to the information in OPRND. */
4491
4492 static int
4493 generate_masked_operand (struct operand *oprnd, int *oprnd_idx)
4494 {
4495 struct soperand *soprnd = NULL;
4496 int mask;
4497 int val;
4498 if ((unsigned int)oprnd->mask == HAS_SUB_OPERAND)
4499 {
4500 soprnd = (struct soperand *) oprnd;
4501 generate_masked_operand (&soprnd->subs[0], oprnd_idx);
4502 generate_masked_operand (&soprnd->subs[1], oprnd_idx);
4503 return 0;
4504 }
4505 mask = oprnd->mask;
4506 val = csky_insn.val[*oprnd_idx];
4507 (*oprnd_idx)++;
4508 val = generate_masked_value (mask, val);
4509 csky_insn.inst |= val;
4510
4511 return 0;
4512 }
4513
4514 static bool
4515 csky_generate_insn (void)
4516 {
4517 int i = 0;
4518 struct csky_opcode_info *opinfo = NULL;
4519
4520 if (csky_insn.isize == 4)
4521 opinfo = &csky_insn.opcode->op32[csky_insn.opcode_idx];
4522 else if (csky_insn.isize == 2)
4523 opinfo = &csky_insn.opcode->op16[csky_insn.opcode_idx];
4524
4525 int sidx = 0;
4526 csky_insn.inst = opinfo->opcode;
4527 if (opinfo->operand_num == -1)
4528 {
4529 generate_masked_operand (&opinfo->oprnd.oprnds[i], &sidx);
4530 return 0;
4531 }
4532 else
4533 for (i = 0; i < opinfo->operand_num; i++)
4534 generate_masked_operand (&opinfo->oprnd.oprnds[i], &sidx);
4535 return 0;
4536 }
4537
4538 /* Main entry point for assembling a single instruction. */
4539
4540 void
4541 md_assemble (char *str)
4542 {
4543 bool must_check_literals = true;
4544 csky_insn.isize = 0;
4545 csky_insn.idx = 0;
4546 csky_insn.max = 0;
4547 csky_insn.flag_force = INSN_OPCODE;
4548 csky_insn.macro = NULL;
4549 csky_insn.opcode = NULL;
4550 memset (csky_insn.val, 0, sizeof (int) * MAX_OPRND_NUM);
4551 /* Initialize err_num. */
4552 error_state.err_num = ERROR_NONE;
4553 mov_r1_before = false;
4554 mov_r1_after = false;
4555
4556 mapping_state (MAP_TEXT);
4557 /* Tie dwarf2 debug info to every insn if set option --gdwarf2. */
4558 dwarf2_emit_insn (0);
4559 while (ISSPACE (* str))
4560 str++;
4561 /* Get opcode from str. */
4562 if (!parse_opcode (str))
4563 {
4564 csky_show_error (ERROR_OPCODE_ILLEGAL, 0, NULL, NULL);
4565 return;
4566 }
4567
4568 /* If it is a macro instruction, handle it. */
4569 if (csky_insn.macro != NULL)
4570 {
4571 if (csky_insn.number == csky_insn.macro->oprnd_num)
4572 {
4573 csky_insn.macro->handle_func ();
4574 return;
4575 }
4576 else if (error_state.err_num > ERROR_OPERANDS_NUMBER)
4577 SET_ERROR_STRING (ERROR_OPERANDS_NUMBER, csky_insn.macro->oprnd_num);
4578 }
4579
4580 if (csky_insn.opcode == NULL)
4581 {
4582 SET_ERROR_STRING (ERROR_OPCODE_ILLEGAL, NULL);
4583 csky_show_error (error_state.err_num, error_state.opnum,
4584 (void *)error_state.arg1, (void *)error_state.arg1);
4585 return;
4586 }
4587
4588 /* Parse the operands according to operand type. */
4589 if (!parse_operands (csky_insn.opcode_end))
4590 {
4591 csky_show_error (error_state.err_num, error_state.opnum,
4592 (void *)error_state.arg1, (void *)error_state.arg1);
4593 return;
4594 }
4595 error_state.err_num = ERROR_NONE;
4596
4597 /* if this insn has work in opcode table, then do it. */
4598 if (csky_insn.opcode->work != NULL)
4599 must_check_literals = csky_insn.opcode->work ();
4600 else
4601 {
4602 /* Generate relax or reloc if necessary. */
4603 csky_generate_frags ();
4604 /* Generate the insn by mask. */
4605 csky_generate_insn ();
4606 /* Write inst to frag. */
4607 csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
4608 }
4609
4610 /* Adjust for xtrb0/xtrb1/xtrb2/xtrb3/divs/divu in csky v1 ISA. */
4611 if (mov_r1_after)
4612 {
4613 unsigned int mov_insn = CSKYV1_INST_MOV_RX_R1;
4614 mov_insn |= csky_insn.val[0];
4615 mov_r1_before = true;
4616 csky_insn.output = frag_more (2);
4617 dwarf2_emit_insn (0);
4618 md_number_to_chars (csky_insn.output, mov_insn, 2);
4619 csky_insn.isize += 2;
4620 }
4621 if (mov_r1_before)
4622 csky_insn.isize += 2;
4623
4624 /* Check literal. */
4625 if (must_check_literals)
4626 {
4627 if (csky_insn.max == 0)
4628 check_literals (csky_insn.opcode->transfer, csky_insn.isize);
4629 else
4630 check_literals (csky_insn.opcode->transfer, csky_insn.max);
4631 }
4632
4633 csky_insn.last_isize = csky_insn.isize;
4634 insn_reloc = BFD_RELOC_NONE;
4635 }
4636
4637 /* Attempt to handle option with value C, returning non-zero on success. */
4638
4639 int
4640 md_parse_option (int c, const char *arg)
4641 {
4642 switch (c)
4643 {
4644 case 0:
4645 break;
4646 case OPTION_MARCH:
4647 parse_arch (arg);
4648 break;
4649 case OPTION_MCPU:
4650 parse_cpu (arg);
4651 break;
4652 case OPTION_FLOAT_ABI:
4653 parse_float_abi (arg);
4654 break;
4655 default:
4656 return 0;
4657 }
4658 return 1;
4659 }
4660
4661 /* Convert a machine dependent frag. */
4662 #define PAD_LITERAL_LENGTH 6
4663 #define opposite_of_stored_comp(insn) (insn ^ 0x04000000)
4664 #define opposite_of_stored_compz(insn) (insn ^ 0x00200000)
4665 #define make_insn(total_length, opcode, operand, operand_length) \
4666 do { \
4667 if (total_length > 0) \
4668 { \
4669 csky_write_insn (buf, \
4670 opcode | (operand & ((1 << operand_length) - 1)), \
4671 total_length); \
4672 buf += total_length; \
4673 fragp->fr_fix += total_length; \
4674 } \
4675 } while (0)
4676
4677 #define make_literal(fragp, literal_offset) \
4678 do { \
4679 make_insn (literal_offset, PAD_FILL_CONTENT, 0, 0); \
4680 fix_new (fragp, fragp->fr_fix, 4, fragp->fr_symbol, \
4681 fragp->fr_offset, 0, BFD_RELOC_CKCORE_ADDR32); \
4682 make_insn (4, 0, 0, 0); \
4683 make_insn (2 - literal_offset, PAD_FILL_CONTENT, 0, 0); \
4684 } while (0)
4685
4686 void
4687 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, segT asec, fragS *fragp)
4688 {
4689 offsetT disp;
4690 char *buf = fragp->fr_fix + &fragp->fr_literal[0];
4691
4692 gas_assert (fragp->fr_symbol);
4693 if (IS_EXTERNAL_SYM (fragp->fr_symbol, asec))
4694 disp = 0;
4695 else
4696 disp = (S_GET_VALUE (fragp->fr_symbol)
4697 + fragp->fr_offset
4698 - fragp->fr_address
4699 - fragp->fr_fix);
4700
4701 switch (fragp->fr_subtype)
4702 {
4703 /* generate new insn. */
4704 case C (COND_JUMP, DISP12):
4705 case C (UNCD_JUMP, DISP12):
4706 case C (COND_JUMP_PIC, DISP12):
4707 case C (UNCD_JUMP_PIC, DISP12):
4708 {
4709 #define CSKY_V1_B_MASK 0xf8
4710 unsigned char t0;
4711 disp -= 2;
4712 if (disp & 1)
4713 {
4714 /* Error. odd displacement at %x, next_inst-2. */
4715 ;
4716 }
4717 disp >>= 1;
4718
4719 if (!target_big_endian)
4720 {
4721 t0 = buf[1] & CSKY_V1_B_MASK;
4722 md_number_to_chars (buf, disp, 2);
4723 buf[1] = (buf[1] & ~CSKY_V1_B_MASK) | t0;
4724 }
4725 else
4726 {
4727 t0 = buf[0] & CSKY_V1_B_MASK;
4728 md_number_to_chars (buf, disp, 2);
4729 buf[0] = (buf[0] & ~CSKY_V1_B_MASK) | t0;
4730 }
4731 fragp->fr_fix += 2;
4732 break;
4733 }
4734 case C (COND_JUMP, DISP32):
4735 case C (COND_JUMP, UNDEF_WORD_DISP):
4736 {
4737 /* A conditional branch wont fit into 12 bits:
4738 b!cond 1f
4739 jmpi 0f
4740 .align 2
4741 0: .long disp
4742 1:
4743 */
4744 int first_inst = fragp->fr_fix + fragp->fr_address;
4745 int is_unaligned = (first_inst & 3);
4746
4747 if (!target_big_endian)
4748 {
4749 /* b!cond instruction. */
4750 buf[1] ^= 0x08;
4751 /* jmpi instruction. */
4752 buf[2] = CSKYV1_INST_JMPI & 0xff;
4753 buf[3] = CSKYV1_INST_JMPI >> 8;
4754 }
4755 else
4756 {
4757 /* b!cond instruction. */
4758 buf[0] ^= 0x08;
4759 /* jmpi instruction. */
4760 buf[2] = CSKYV1_INST_JMPI >> 8;
4761 buf[3] = CSKYV1_INST_JMPI & 0xff;
4762 }
4763
4764 if (is_unaligned)
4765 {
4766 if (!target_big_endian)
4767 {
4768 /* bt/bf: jump to pc + 2 + (4 << 1). */
4769 buf[0] = 4;
4770 /* jmpi: jump to MEM (pc + 2 + (1 << 2)). */
4771 buf[2] = 1;
4772 }
4773 else
4774 {
4775 /* bt/bf: jump to pc + 2 + (4 << 1). */
4776 buf[1] = 4;
4777 /* jmpi: jump to MEM (pc + 2 + (1 << 2)). */
4778 buf[3] = 1;
4779 }
4780 /* Aligned 4 bytes. */
4781 buf[4] = 0;
4782 buf[5] = 0;
4783 /* .long */
4784 buf[6] = 0;
4785 buf[7] = 0;
4786 buf[8] = 0;
4787 buf[9] = 0;
4788
4789 /* Make reloc for the long disp. */
4790 fix_new (fragp, fragp->fr_fix + 6, 4,
4791 fragp->fr_symbol, fragp->fr_offset, 0, BFD_RELOC_32);
4792 fragp->fr_fix += C32_LEN;
4793 }
4794 else
4795 {
4796 if (!target_big_endian)
4797 {
4798 /* bt/bf: jump to pc + 2 + (3 << 1). */
4799 buf[0] = 3;
4800 /* jmpi: jump to MEM (pc + 2 + (0 << 2)). */
4801 buf[2] = 0;
4802 }
4803 else
4804 {
4805 /* bt/bf: jump to pc + 2 + (3 << 1). */
4806 buf[1] = 3;
4807 /* jmpi: jump to MEM (pc + 2 + (0 << 2)). */
4808 buf[3] = 0;
4809 }
4810 /* .long */
4811 buf[4] = 0;
4812 buf[5] = 0;
4813 buf[6] = 0;
4814 buf[7] = 0;
4815
4816 /* Make reloc for the long disp. */
4817 fix_new (fragp, fragp->fr_fix + 4, 4,
4818 fragp->fr_symbol, fragp->fr_offset, 0, BFD_RELOC_32);
4819 fragp->fr_fix += C32_LEN;
4820
4821 /* Frag is actually shorter (see the other side of this ifdef)
4822 but gas isn't prepared for that. We have to re-adjust
4823 the branch displacement so that it goes beyond the
4824 full length of the fragment, not just what we actually
4825 filled in. */
4826 if (!target_big_endian)
4827 buf[0] = 4;
4828 else
4829 buf[1] = 4;
4830 }
4831 }
4832 break;
4833
4834 case C (COND_JUMP_PIC, DISP32):
4835 case C (COND_JUMP_PIC, UNDEF_WORD_DISP):
4836 {
4837 #define BYTE_1(a) (target_big_endian ? ((a) & 0xff) : ((a) >> 8))
4838 #define BYTE_0(a) (target_big_endian ? ((a) >> 8) : ((a) & 0xff))
4839 /* b!cond 1f
4840 subi sp, 8
4841 stw r15, (sp, 0)
4842 bsr .L0
4843 .L0:
4844 lrw r1, 0f
4845 add r1, r15
4846 addi sp, 8
4847 jmp r1
4848 .align 2
4849 0: .long (tar_addr - pc)
4850 1:
4851 */
4852 int first_inst = fragp->fr_fix + fragp->fr_address;
4853 int is_unaligned = (first_inst & 3);
4854 disp -= 8;
4855 /* Toggle T/F bit. */
4856 if (! target_big_endian)
4857 buf[1] ^= 0x08;
4858 else
4859 buf[0] ^= 0x08;
4860 buf[2] = BYTE_0 (CSKYV1_INST_SUBI | (7 << 4)); /* subi r0, 8. */
4861 buf[3] = BYTE_1 (CSKYV1_INST_SUBI | (7 << 4));
4862 buf[4] = BYTE_0 (CSKYV1_INST_STW | (15 << 8)); /* stw r15, r0. */
4863 buf[5] = BYTE_1 (CSKYV1_INST_STW | (15 << 8));
4864 buf[6] = BYTE_0 (CSKYV1_INST_BSR); /* bsr pc + 2. */
4865 buf[7] = BYTE_1 (CSKYV1_INST_BSR);
4866 buf[8] = BYTE_0 (CSKYV1_INST_LRW | (1 << 8)); /* lrw r1, (tar_addr - pc). */
4867 buf[9] = BYTE_1 (CSKYV1_INST_LRW | (1 << 8));
4868 buf[10] = BYTE_0 (CSKYV1_INST_ADDU | (15 << 4) | 1); /* add r1, r15. */
4869 buf[11] = BYTE_1 (CSKYV1_INST_ADDU | (15 << 4) | 1);
4870 buf[12] = BYTE_0 (CSKYV1_INST_LDW | (15 << 8)); /* ldw r15, r0. */
4871 buf[13] = BYTE_1 (CSKYV1_INST_LDW | (15 << 8));
4872 buf[14] = BYTE_0 (CSKYV1_INST_ADDI | (7 << 4)); /* addi r0, 8. */
4873 buf[15] = BYTE_1 (CSKYV1_INST_ADDI | (7 << 4));
4874 buf[16] = BYTE_0 (CSKYV1_INST_JMP | 1); /* jmp r1. */
4875 buf[17] = BYTE_1 (CSKYV1_INST_JMP | 1);
4876
4877 if (!is_unaligned)
4878 {
4879 if (!target_big_endian)
4880 {
4881 buf[0] = 11;
4882 buf[8] = 3;
4883 buf[20] = disp & 0xff;
4884 buf[21] = (disp >> 8) & 0xff;
4885 buf[22] = (disp >> 16) & 0xff;
4886 buf[23] = (disp >> 24) & 0xff;
4887 }
4888 else /* if !target_big_endian. */
4889 {
4890 buf[1] = 11;
4891 buf[9] = 3;
4892 buf[20] = (disp >> 24) & 0xff;
4893 buf[21] = (disp >> 16) & 0xff;
4894 buf[22] = (disp >> 8) & 0xff;
4895 buf[23] = disp & 0xff;
4896 }
4897 buf[18] = 0; /* alignment. */
4898 buf[19] = 0;
4899 fragp->fr_fix += C32_LEN_PIC;
4900 }
4901 else /* if !is_unaligned. */
4902 {
4903 if (!target_big_endian)
4904 {
4905 buf[0] = 11;
4906 buf[8] = 2;
4907 buf[18] = disp & 0xff;
4908 buf[19] = (disp >> 8) & 0xff;
4909 buf[20] = (disp >> 16) & 0xff;
4910 buf[21] = (disp >> 24) & 0xff;
4911 }
4912 else /* if !target_big_endian. */
4913 {
4914 buf[1] = 11;
4915 buf[9] = 2;
4916 buf[18] = (disp >> 24) & 0xff;
4917 buf[19] = (disp >> 16) & 0xff;
4918 buf[20] = (disp >> 8) & 0xff;
4919 buf[21] = disp & 0xff;
4920 }
4921 buf[22] = 0; /* initialise. */
4922 buf[23] = 0;
4923 fragp->fr_fix += C32_LEN_PIC;
4924
4925 } /* end if is_unaligned. */
4926 } /* end case C (COND_JUMP_PIC, DISP32)/C (COND_JUMP_PIC, UNDEF_WORD_DISP). */
4927 break;
4928 case C (UNCD_JUMP, DISP32):
4929 case C (UNCD_JUMP, UNDEF_WORD_DISP):
4930 {
4931 /* jmpi 0f
4932 .align 2
4933 0: .long disp. */
4934 int first_inst = fragp->fr_fix + fragp->fr_address;
4935 int is_unaligned = (first_inst & 3);
4936 /* Build jmpi. */
4937 buf[0] = BYTE_0 (CSKYV1_INST_JMPI);
4938 buf[1] = BYTE_1 (CSKYV1_INST_JMPI);
4939 if (!is_unaligned)
4940 {
4941 if (!target_big_endian)
4942 buf[0] = 1;
4943 else
4944 buf[1] = 1;
4945 /* Alignment. */
4946 buf[2] = 0;
4947 buf[3] = 0;
4948 /* .long */
4949 buf[4] = 0;
4950 buf[5] = 0;
4951 buf[6] = 0;
4952 buf[7] = 0;
4953 fix_new (fragp, fragp->fr_fix + 4, 4,
4954 fragp->fr_symbol, fragp->fr_offset, 0, BFD_RELOC_32);
4955 fragp->fr_fix += U32_LEN;
4956 }
4957 else /* if is_unaligned. */
4958 {
4959 if (!target_big_endian)
4960 buf[0] = 0;
4961 else
4962 buf[1] = 0;
4963 /* .long */
4964 buf[2] = 0;
4965 buf[3] = 0;
4966 buf[4] = 0;
4967 buf[5] = 0;
4968 fix_new (fragp, fragp->fr_fix + 2, 4,
4969 fragp->fr_symbol, fragp->fr_offset, 0, BFD_RELOC_32);
4970 fragp->fr_fix += U32_LEN;
4971
4972 }
4973 }
4974 break;
4975 case C (UNCD_JUMP_PIC, DISP32):
4976 case C (UNCD_JUMP_PIC, UNDEF_WORD_DISP):
4977 {
4978 /* subi sp, 8
4979 stw r15, (sp)
4980 bsr .L0
4981 .L0:
4982 lrw r1, 0f
4983 add r1, r15
4984 ldw r15, (sp)
4985 addi sp, 8
4986 jmp r1
4987 .align 2
4988 0: .long (tar_add - pc)
4989 1:
4990 */
4991 /* If the b!cond is 4 byte aligned, the literal which would
4992 go at x+4 will also be aligned. */
4993 int first_inst = fragp->fr_fix + fragp->fr_address;
4994 int is_unaligned = (first_inst & 3);
4995 disp -= 6;
4996
4997 buf[0] = BYTE_0 (CSKYV1_INST_SUBI | (7 << 4)); /* subi r0, 8. */
4998 buf[1] = BYTE_1 (CSKYV1_INST_SUBI | (7 << 4));
4999 buf[2] = BYTE_0 (CSKYV1_INST_STW | (15 << 8)); /* stw r15, r0. */
5000 buf[3] = BYTE_1 (CSKYV1_INST_STW | (15 << 8));
5001 buf[4] = BYTE_0 (CSKYV1_INST_BSR); /* bsr pc + 2. */
5002 buf[5] = BYTE_1 (CSKYV1_INST_BSR);
5003 buf[6] = BYTE_0 (CSKYV1_INST_LRW | (1 << 8)); /* lrw r1, (tar_addr - pc). */
5004 buf[7] = BYTE_1 (CSKYV1_INST_LRW | (1 << 8));
5005 buf[8] = BYTE_0 (CSKYV1_INST_ADDU | (15 << 4) | 1); /* add r1, r15. */
5006 buf[9] = BYTE_1 (CSKYV1_INST_ADDU | (15 << 4) | 1);
5007 buf[10] = BYTE_0 (CSKYV1_INST_LDW | (15 << 8)); /* ldw r15, r0. */
5008 buf[11] = BYTE_1 (CSKYV1_INST_LDW | (15 << 8));
5009 buf[12] = BYTE_0 (CSKYV1_INST_ADDI | (7 << 4)); /* addi r0, 8. */
5010 buf[13] = BYTE_1 (CSKYV1_INST_ADDI | (7 << 4));
5011 buf[14] = BYTE_0 (CSKYV1_INST_JMP | 1); /* jmp r1. */
5012 buf[15] = BYTE_1 (CSKYV1_INST_JMP | 1);
5013
5014 if (is_unaligned)
5015 {
5016 if (!target_big_endian)
5017 {
5018 buf[6] = 3;
5019 buf[18] = disp & 0xff;
5020 buf[19] = (disp >> 8) & 0xff;
5021 buf[20] = (disp >> 16) & 0xff;
5022 buf[21] = (disp >> 24) & 0xff;
5023 }
5024 else
5025 {
5026 buf[7] = 3;
5027 buf[18] = (disp >> 24) & 0xff;
5028 buf[19] = (disp >> 16) & 0xff;
5029 buf[20] = (disp >> 8) & 0xff;
5030 buf[21] = disp & 0xff;
5031 }
5032 buf[16] = 0;
5033 buf[17] = 0;
5034 fragp->fr_fix += U32_LEN_PIC;
5035 }
5036 else
5037 {
5038 if (!target_big_endian)
5039 {
5040 buf[6] = 2;
5041 buf[16] = disp & 0xff;
5042 buf[17] = (disp >> 8) & 0xff;
5043 buf[18] = (disp >> 16) & 0xff;
5044 buf[19] = (disp >> 24) & 0xff;
5045 }
5046 else
5047 {
5048 buf[7] = 2;
5049 buf[16] = (disp >> 24) & 0xff;
5050 buf[17] = (disp >> 16) & 0xff;
5051 buf[18] = (disp >> 8) & 0xff;
5052 buf[19] = disp & 0xff;
5053 }
5054 fragp->fr_fix += U32_LEN_PIC;
5055 }
5056 }
5057 break;
5058 case COND_DISP10:
5059 case SCOND_DISP10:
5060 case UNCD_DISP10:
5061 case JCOND_DISP10:
5062 case JUNCD_DISP10:
5063 {
5064 unsigned int inst = csky_read_insn (buf, 2);
5065 inst |= (disp >> 1) & ((1 << 10) - 1);
5066 csky_write_insn (buf, inst, 2);
5067 fragp->fr_fix += 2;
5068 break;
5069 }
5070 case SCOND_DISP16:
5071 {
5072 unsigned int inst = csky_read_insn (buf, 2);
5073
5074 if (inst == CSKYV2_INST_BT16)
5075 inst = CSKYV2_INST_BF16;
5076 else
5077 inst = CSKYV2_INST_BT16;
5078 make_insn (2, inst, (2 + 4) >> 1, 10);
5079 if (IS_EXTERNAL_SYM (fragp->fr_symbol, asec))
5080 fix_new (fragp, fragp->fr_fix, 4,
5081 fragp->fr_symbol, fragp->fr_offset, 1,
5082 BFD_RELOC_CKCORE_PCREL_IMM16BY2);
5083 disp -= 2;
5084 inst = CSKYV2_INST_BR32 | ((disp >> 1) & ((1 << 16) - 1));
5085 csky_write_insn (buf, inst, 4);
5086 fragp->fr_fix += 4;
5087 break;
5088 }
5089 case COND_DISP16:
5090 case JCOND_DISP16:
5091 {
5092 unsigned int inst = csky_read_insn (buf, 2);
5093
5094 if (inst == CSKYV2_INST_BT16)
5095 inst = CSKYV2_INST_BT32;
5096 else
5097 inst = CSKYV2_INST_BF32;
5098 if (IS_EXTERNAL_SYM (fragp->fr_symbol, asec))
5099 fix_new (fragp, fragp->fr_fix, 4,
5100 fragp->fr_symbol, fragp->fr_offset, 1,
5101 BFD_RELOC_CKCORE_PCREL_IMM16BY2);
5102 inst |= (disp >> 1) & ((1 << 16) - 1);
5103 csky_write_insn (buf, inst, 4);
5104 fragp->fr_fix += 4;
5105 break;
5106 }
5107 case LRW_DISP7:
5108 {
5109 unsigned int inst = csky_read_insn (buf, 2);
5110 int imm;
5111 imm = (disp + 2) >> 2;
5112 inst |= (imm >> 5) << 8;
5113 make_insn (2, inst, (imm & 0x1f), 5);
5114 break;
5115 }
5116 case LRW2_DISP8:
5117 {
5118 unsigned int inst = csky_read_insn (buf, 2);
5119 int imm = (disp + 2) >> 2;
5120 if (imm >= 0x80)
5121 {
5122 inst &= 0xe0;
5123 inst |= (~((imm >> 5) << 8)) & 0x300;
5124 make_insn (2, inst, (~imm & 0x1f), 5);
5125 }
5126 else
5127 {
5128 inst |= (imm >> 5) << 8;
5129 make_insn (2, inst, (imm & 0x1f), 5);
5130 }
5131 break;
5132 }
5133 case LRW_DISP16:
5134 {
5135 unsigned int inst = csky_read_insn (buf, 2);
5136 inst = CSKYV2_INST_LRW32 | (((inst & 0xe0) >> 5) << 16);
5137 if (IS_EXTERNAL_SYM (fragp->fr_symbol, asec))
5138 fix_new (fragp, fragp->fr_fix, 4,
5139 fragp->fr_symbol, fragp->fr_offset, 1,
5140 BFD_RELOC_CKCORE_PCREL_IMM16BY4);
5141 make_insn (4, inst, ((disp + 2) >> 2), 16);
5142 break;
5143 }
5144 case JCOMPZ_DISP16:
5145 {
5146 unsigned int inst = csky_read_insn (buf, 4);
5147 make_insn (4, inst, disp >> 1, 16);
5148 }
5149 break;
5150 case JCOMPZ_DISP32:
5151 {
5152 unsigned int inst = csky_read_insn (buf, 4);
5153 int literal_offset;
5154 make_insn (4, opposite_of_stored_compz (inst),
5155 (4 + 4 + PAD_LITERAL_LENGTH) >> 1, 16);
5156 literal_offset = ((fragp->fr_address + fragp->fr_fix) % 4 == 0
5157 ? 0 : 2);
5158 make_insn (4, CSKYV2_INST_JMPI32, (4 + literal_offset + 2) >> 2, 10);
5159 make_literal (fragp, literal_offset);
5160 }
5161 break;
5162 case JUNCD_DISP16:
5163 case UNCD_DISP16:
5164 {
5165 if (IS_EXTERNAL_SYM (fragp->fr_symbol, asec))
5166 fix_new (fragp, fragp->fr_fix, 4,
5167 fragp->fr_symbol, fragp->fr_offset, 1,
5168 BFD_RELOC_CKCORE_PCREL_IMM16BY2);
5169 make_insn (4, CSKYV2_INST_BR32, disp >> 1, 16);
5170 }
5171 break;
5172 case JCOND_DISP32:
5173 {
5174 /* 'jbt'/'jbf'-> <bf16/bt16>; jmpi32; [pad16]+literal32 */
5175 unsigned int inst = csky_read_insn (buf, 2);
5176 int literal_offset;
5177
5178 if (inst == CSKYV2_INST_BT16)
5179 inst = CSKYV2_INST_BF16;
5180 else
5181 inst = CSKYV2_INST_BT16;
5182 make_insn (2, inst, (2 + 4 + PAD_LITERAL_LENGTH) >> 1, 10);
5183 literal_offset = ((fragp->fr_address + fragp->fr_fix) % 4 == 0
5184 ? 0 : 2);
5185 make_insn (4, CSKYV2_INST_JMPI32, (4 + literal_offset + 2) >> 2, 10);
5186 make_literal (fragp, literal_offset);
5187 break;
5188 }
5189 case JUNCD_DISP32:
5190 {
5191 int literal_offset;
5192 literal_offset = ((fragp->fr_address + fragp->fr_fix) % 4 == 0
5193 ? 0 : 2);
5194 make_insn (4, CSKYV2_INST_JMPI32, (4 + literal_offset + 2) >> 2, 10);
5195 make_literal (fragp, literal_offset);
5196 }
5197 break;
5198 case RELAX_OVERFLOW:
5199 csky_branch_report_error (fragp->fr_file, fragp->fr_line,
5200 fragp->fr_symbol, disp);
5201 break;
5202 default:
5203 abort ();
5204 break;
5205 }
5206 }
5207
5208 /* Round up a section size to the appropriate boundary. */
5209
5210 valueT
5211 md_section_align (segT segment ATTRIBUTE_UNUSED,
5212 valueT size)
5213 {
5214 return size;
5215 }
5216
5217 /* MD interface: Symbol and relocation handling. */
5218
5219 void csky_md_finish (void)
5220 {
5221 dump_literals (0);
5222 }
5223
5224 /* Return the address within the segment that a PC-relative fixup is
5225 relative to. */
5226
5227 long
5228 md_pcrel_from_section (fixS * fixP, segT seg)
5229 {
5230 /* If the symbol is undefined or defined in another section
5231 we leave the add number alone for the linker to fix it later. */
5232 if (fixP->fx_addsy != (symbolS *) NULL
5233 && (! S_IS_DEFINED (fixP->fx_addsy)
5234 || S_GET_SEGMENT (fixP->fx_addsy) != seg))
5235 return fixP->fx_size;
5236
5237 /* The case where we are going to resolve things. */
5238 return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
5239 }
5240
5241 /* csky_cons_fix_new is called via the expression parsing code when a
5242 reloc is needed. We use this hook to get the correct .got reloc. */
5243
5244 void
5245 csky_cons_fix_new (fragS *frag,
5246 unsigned int off,
5247 unsigned int len,
5248 expressionS *exp,
5249 bfd_reloc_code_real_type reloc)
5250 {
5251 fixS *fixP;
5252
5253 if (BFD_RELOC_CKCORE_GOTOFF == insn_reloc
5254 || BFD_RELOC_CKCORE_GOTPC == insn_reloc
5255 || BFD_RELOC_CKCORE_GOT32 == insn_reloc
5256 || BFD_RELOC_CKCORE_PLT32 == insn_reloc
5257 || BFD_RELOC_CKCORE_TLS_LE32 == insn_reloc
5258 || BFD_RELOC_CKCORE_TLS_GD32 == insn_reloc
5259 || BFD_RELOC_CKCORE_TLS_LDM32 == insn_reloc
5260 || BFD_RELOC_CKCORE_TLS_LDO32 == insn_reloc
5261 || BFD_RELOC_CKCORE_TLS_IE32 == insn_reloc)
5262 reloc = insn_reloc;
5263 else
5264 switch (len)
5265 {
5266 case 1:
5267 reloc = BFD_RELOC_8;
5268 break;
5269 case 2:
5270 reloc = BFD_RELOC_16;
5271 break;
5272 case 4:
5273 reloc = BFD_RELOC_32;
5274 break;
5275 case 8:
5276 reloc = BFD_RELOC_64;
5277 break;
5278 default:
5279 as_bad (_("unsupported BFD relocation size %d"), len);
5280 reloc = BFD_RELOC_32;
5281 break;
5282 }
5283 fixP = fix_new_exp (frag, off, (int) len, exp, 0, reloc);
5284 if (BFD_RELOC_CKCORE_TLS_IE32 == insn_reloc
5285 || BFD_RELOC_CKCORE_TLS_GD32 == insn_reloc
5286 || BFD_RELOC_CKCORE_TLS_LDM32 == insn_reloc)
5287 {
5288 fixP->tc_fix_data.frag = literal_insn_offset->tls_addend.frag;
5289 fixP->tc_fix_data.offset = literal_insn_offset->tls_addend.offset;
5290 }
5291 }
5292
5293 /* See whether we need to force a relocation into the output file.
5294 This is used to force out switch and PC relative relocations when
5295 relaxing. */
5296
5297 int
5298 csky_force_relocation (fixS * fix)
5299 {
5300 if (fix->fx_r_type == BFD_RELOC_VTABLE_INHERIT
5301 || fix->fx_r_type == BFD_RELOC_VTABLE_ENTRY
5302 || fix->fx_r_type == BFD_RELOC_RVA
5303 || fix->fx_r_type == BFD_RELOC_CKCORE_ADDR_HI16
5304 || fix->fx_r_type == BFD_RELOC_CKCORE_ADDR_LO16
5305 || fix->fx_r_type == BFD_RELOC_CKCORE_TOFFSET_LO16
5306 || fix->fx_r_type == BFD_RELOC_CKCORE_DOFFSET_LO16)
5307 return 1;
5308
5309 if (fix->fx_addsy == NULL)
5310 return 0;
5311
5312 if (do_use_branchstub
5313 && fix->fx_r_type == BFD_RELOC_CKCORE_PCREL_IMM26BY2
5314 && (symbol_get_bfdsym (fix->fx_addsy)->flags & BSF_FUNCTION))
5315 return 1;
5316 return S_FORCE_RELOC (fix->fx_addsy, fix->fx_subsy == NULL);
5317 }
5318
5319 /* Return true if the fix can be handled by GAS, false if it must
5320 be passed through to the linker. */
5321
5322 bool
5323 csky_fix_adjustable (fixS * fixP)
5324 {
5325 if (fixP->fx_addsy == NULL)
5326 return 1;
5327
5328 /* We need the symbol name for the VTABLE entries. */
5329 if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
5330 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY
5331 || fixP->fx_r_type == BFD_RELOC_CKCORE_PLT32
5332 || fixP->fx_r_type == BFD_RELOC_CKCORE_GOT32
5333 || fixP->fx_r_type == BFD_RELOC_CKCORE_PLT12
5334 || fixP->fx_r_type == BFD_RELOC_CKCORE_GOT12
5335 || fixP->fx_r_type == BFD_RELOC_CKCORE_GOT_HI16
5336 || fixP->fx_r_type == BFD_RELOC_CKCORE_GOT_LO16
5337 || fixP->fx_r_type == BFD_RELOC_CKCORE_PLT_HI16
5338 || fixP->fx_r_type == BFD_RELOC_CKCORE_PLT_LO16
5339 || fixP->fx_r_type == BFD_RELOC_CKCORE_GOTOFF
5340 || fixP->fx_r_type == BFD_RELOC_CKCORE_GOTOFF_HI16
5341 || fixP->fx_r_type == BFD_RELOC_CKCORE_GOTOFF_LO16
5342 || fixP->fx_r_type == BFD_RELOC_CKCORE_ADDR_HI16
5343 || fixP->fx_r_type == BFD_RELOC_CKCORE_ADDR_LO16
5344 || fixP->fx_r_type == BFD_RELOC_CKCORE_GOT_IMM18BY4
5345 || fixP->fx_r_type == BFD_RELOC_CKCORE_PLT_IMM18BY4
5346 || fixP->fx_r_type == BFD_RELOC_CKCORE_GOTOFF_IMM18
5347 || fixP->fx_r_type == BFD_RELOC_CKCORE_TLS_LE32
5348 || fixP->fx_r_type == BFD_RELOC_CKCORE_TLS_IE32
5349 || fixP->fx_r_type == BFD_RELOC_CKCORE_TLS_GD32
5350 || fixP->fx_r_type == BFD_RELOC_CKCORE_TLS_LDM32
5351 || fixP->fx_r_type == BFD_RELOC_CKCORE_TLS_LDO32)
5352 return 0;
5353
5354 if (do_use_branchstub
5355 && fixP->fx_r_type == BFD_RELOC_CKCORE_PCREL_IMM26BY2
5356 && (symbol_get_bfdsym (fixP->fx_addsy)->flags & BSF_FUNCTION))
5357 return 0;
5358
5359 return 1;
5360 }
5361
5362 void
5363 md_apply_fix (fixS *fixP,
5364 valueT *valP,
5365 segT seg)
5366 {
5367 reloc_howto_type *howto;
5368 /* Note: use offsetT because it is signed, valueT is unsigned. */
5369 offsetT val = *valP;
5370 char *buf = fixP->fx_frag->fr_literal + fixP->fx_where;
5371
5372 /* if fx_done = 0, fixup will also be processed in
5373 * tc_gen_reloc() after md_apply_fix(). */
5374 fixP->fx_done = 0;
5375
5376 /* If the fix is relative to a symbol which is not defined, or not
5377 in the same segment as the fix, we cannot resolve it here. */
5378 if (IS_CSKY_V1 (mach_flag) && fixP->fx_addsy != NULL
5379 && (! S_IS_DEFINED (fixP->fx_addsy)
5380 || S_GET_SEGMENT (fixP->fx_addsy) != seg))
5381 {
5382 switch (fixP->fx_r_type)
5383 {
5384 /* Data fx_addnumber is greater than 16 bits,
5385 so fx_addnumber is assigned zero. */
5386 case BFD_RELOC_CKCORE_PCREL_JSR_IMM11BY2:
5387 *valP = 0;
5388 break;
5389 case BFD_RELOC_CKCORE_TLS_IE32:
5390 case BFD_RELOC_CKCORE_TLS_LDM32:
5391 case BFD_RELOC_CKCORE_TLS_GD32:
5392 {
5393 struct tls_addend *ta = &(fixP->tc_fix_data);
5394 fixP->fx_offset = (fixP->fx_frag->fr_address + fixP->fx_where
5395 - (ta->frag->fr_address + ta->offset));
5396 *valP = fixP->fx_offset;
5397 }
5398 /* Fall through. */
5399 case BFD_RELOC_CKCORE_TLS_LE32:
5400 case BFD_RELOC_CKCORE_TLS_LDO32:
5401 S_SET_THREAD_LOCAL (fixP->fx_addsy);
5402 break;
5403 default:
5404 break;
5405 }
5406 #ifdef OBJ_ELF
5407 /* For ELF we can just return and let the reloc that will be generated
5408 take care of everything. For COFF we still have to insert 'val'
5409 into the insn since the addend field will be ignored. */
5410 return;
5411 #endif
5412 }
5413
5414 /* We can handle these relocs. */
5415 switch (fixP->fx_r_type)
5416 {
5417 case BFD_RELOC_32_PCREL:
5418 case BFD_RELOC_CKCORE_PCREL32:
5419 fixP->fx_r_type = BFD_RELOC_CKCORE_PCREL32;
5420 break;
5421 case BFD_RELOC_VTABLE_INHERIT:
5422 fixP->fx_r_type = BFD_RELOC_CKCORE_GNU_VTINHERIT;
5423 if (fixP->fx_addsy && !S_IS_DEFINED (fixP->fx_addsy)
5424 && !S_IS_WEAK (fixP->fx_addsy))
5425 S_SET_WEAK (fixP->fx_addsy);
5426 break;
5427 case BFD_RELOC_VTABLE_ENTRY:
5428 fixP->fx_r_type = BFD_RELOC_CKCORE_GNU_VTENTRY;
5429 break;
5430 case BFD_RELOC_CKCORE_GOT12:
5431 case BFD_RELOC_CKCORE_PLT12:
5432 case BFD_RELOC_CKCORE_ADDR_HI16:
5433 case BFD_RELOC_CKCORE_ADDR_LO16:
5434 case BFD_RELOC_CKCORE_TOFFSET_LO16:
5435 case BFD_RELOC_CKCORE_DOFFSET_LO16:
5436 case BFD_RELOC_CKCORE_GOT_HI16:
5437 case BFD_RELOC_CKCORE_GOT_LO16:
5438 case BFD_RELOC_CKCORE_PLT_HI16:
5439 case BFD_RELOC_CKCORE_PLT_LO16:
5440 case BFD_RELOC_CKCORE_GOTPC_HI16:
5441 case BFD_RELOC_CKCORE_GOTPC_LO16:
5442 case BFD_RELOC_CKCORE_GOTOFF_HI16:
5443 case BFD_RELOC_CKCORE_GOTOFF_LO16:
5444 case BFD_RELOC_CKCORE_DOFFSET_IMM18:
5445 case BFD_RELOC_CKCORE_DOFFSET_IMM18BY2:
5446 case BFD_RELOC_CKCORE_DOFFSET_IMM18BY4:
5447 case BFD_RELOC_CKCORE_GOTOFF_IMM18:
5448 case BFD_RELOC_CKCORE_GOT_IMM18BY4:
5449 case BFD_RELOC_CKCORE_PLT_IMM18BY4:
5450 break;
5451 case BFD_RELOC_CKCORE_TLS_IE32:
5452 case BFD_RELOC_CKCORE_TLS_LDM32:
5453 case BFD_RELOC_CKCORE_TLS_GD32:
5454 {
5455 struct tls_addend *ta = &(fixP->tc_fix_data);
5456 fixP->fx_offset = (fixP->fx_frag->fr_address + fixP->fx_where
5457 - (ta->frag->fr_address + ta->offset));
5458 *valP = fixP->fx_offset;
5459 }
5460 /* Fall through. */
5461 case BFD_RELOC_CKCORE_TLS_LE32:
5462 case BFD_RELOC_CKCORE_TLS_LDO32:
5463 S_SET_THREAD_LOCAL (fixP->fx_addsy);
5464 break;
5465 case BFD_RELOC_32:
5466 fixP->fx_r_type = BFD_RELOC_CKCORE_ADDR32;
5467 /* Fall through. */
5468 case BFD_RELOC_16:
5469 case BFD_RELOC_8:
5470 if (fixP->fx_addsy == NULL)
5471 {
5472 if (fixP->fx_size == 4)
5473 ;
5474 else if (fixP->fx_size == 2 && val >= -32768 && val <= 32767)
5475 ;
5476 else if (fixP->fx_size == 1 && val >= -256 && val <= 255)
5477 ;
5478 else
5479 break;
5480
5481 md_number_to_chars (buf, val, fixP->fx_size);
5482 fixP->fx_done = 1;
5483 }
5484 break;
5485 case BFD_RELOC_CKCORE_PCREL_JSR_IMM11BY2:
5486 if (fixP->fx_addsy == 0 && val > -2 KB && val < 2 KB)
5487 {
5488 long nval = (val >> 1) & 0x7ff;
5489 nval |= CSKYV1_INST_BSR;
5490 csky_write_insn (buf, nval, 2);
5491 fixP->fx_done = 1;
5492 }
5493 else
5494 *valP = 0;
5495 break;
5496 case BFD_RELOC_CKCORE_PCREL_JSR_IMM26BY2:
5497 if (fixP->fx_addsy == 0)
5498 {
5499 if (val >= -(1 << 26) && val < (1 << 26))
5500 {
5501 unsigned int nval = ((val + fixP->fx_size) >> 1) & 0x3ffffff;
5502 nval |= CSKYV2_INST_BSR32;
5503
5504 csky_write_insn (buf, nval, 4);
5505 }
5506 /* If bsr32 cannot reach,
5507 generate 'lrw r25,label;jsr r25' instead of 'jsri label'. */
5508 else if (IS_CSKY_ARCH_810 (mach_flag))
5509 {
5510 howto = bfd_reloc_type_lookup (stdoutput, fixP->fx_r_type);
5511 valueT opcode = csky_read_insn (buf, 4);
5512 opcode = (opcode & howto->dst_mask) | CSKYV2_INST_JSRI_TO_LRW;
5513 csky_write_insn (buf, opcode, 4);
5514 opcode = CSKYV2_INST_JSR_R26;
5515 csky_write_insn (buf + 4, opcode, 4);
5516 }
5517 fixP->fx_done = 1;
5518 }
5519 break;
5520
5521 default:
5522 {
5523 valueT opcode;
5524 offsetT min, max;
5525 unsigned int issigned = 0;
5526
5527 if (fixP->fx_addsy)
5528 break;
5529
5530 howto = bfd_reloc_type_lookup (stdoutput, fixP->fx_r_type);
5531 if (howto == NULL)
5532 {
5533 if (fixP->fx_size == 4
5534 || (fixP->fx_size == 2 && val >= -32768 && val <= 32767)
5535 || (fixP->fx_size == 1 && val >= -256 && val <= 255))
5536 {
5537 md_number_to_chars (buf, val, fixP->fx_size);
5538 fixP->fx_done = 1;
5539 break;
5540 }
5541 else
5542 abort ();
5543 }
5544
5545 if (IS_CSKY_V2 (mach_flag))
5546 val += fixP->fx_size;
5547
5548 if (howto->rightshift == 2)
5549 val += 2;
5550
5551 val >>= howto->rightshift;
5552
5553 switch (fixP->fx_r_type)
5554 {
5555 /* Offset is unsigned. */
5556 case BFD_RELOC_CKCORE_PCREL_IMM8BY4:
5557 case BFD_RELOC_CKCORE_PCREL_IMM10BY4:
5558 case BFD_RELOC_CKCORE_PCREL_IMM16BY4:
5559 max = (offsetT) howto->dst_mask;
5560 min = 0;
5561 break;
5562 /* lrw16. */
5563 case BFD_RELOC_CKCORE_PCREL_IMM7BY4:
5564 if (do_extend_lrw)
5565 max = (offsetT)((1 << (howto->bitsize + 1)) - 2);
5566 else
5567 max = (offsetT)((1 << howto->bitsize) - 1);
5568 min = 0;
5569 break;
5570 /* flrws, flrwd: the offset bits are divided in two parts. */
5571 case BFD_RELOC_CKCORE_PCREL_FLRW_IMM8BY4:
5572 max = (offsetT)((1 << howto->bitsize) - 1);
5573 min = 0;
5574 break;
5575 /* Offset is signed. */
5576 default:
5577 max = (offsetT)(howto->dst_mask >> 1);
5578 min = - max - 1;
5579 issigned = 1;
5580 }
5581 if (val < min || val > max)
5582 {
5583 csky_branch_report_error (fixP->fx_file, fixP->fx_line,
5584 fixP->fx_addsy, val);
5585 return;
5586 }
5587 opcode = csky_read_insn (buf, fixP->fx_size);
5588 /* Clear redundant bits brought from the last
5589 operation if there is any. */
5590 if (do_extend_lrw && (opcode & 0xfc00) == CSKYV2_INST_LRW16)
5591 val &= 0xff;
5592 else
5593 val &= issigned ? (offsetT)(howto->dst_mask) : max;
5594
5595 if (fixP->fx_r_type == BFD_RELOC_CKCORE_PCREL_BLOOP_IMM4BY4)
5596 val = (val & 0xf) << 12;
5597
5598 if (fixP->fx_size == 2 && (opcode & 0xfc00) == CSKYV2_INST_LRW16)
5599 {
5600 /* 8 bit offset lrw16. */
5601 if (val >= 0x80)
5602 csky_write_insn (buf,
5603 ((~val & 0x1f)
5604 | ((~val & 0x60) << 3) | (opcode & 0xe0)),
5605 fixP->fx_size);
5606 /* 7 bit offset lrw16. */
5607 else
5608 csky_write_insn (buf,
5609 (val & 0x1f) | ((val & 0x60) << 3) | opcode,
5610 fixP->fx_size);
5611 }
5612 else if (fixP->fx_size == 4
5613 && (opcode & 0xfe1ffe00) == CSKYV2_INST_FLRW)
5614 csky_write_insn (buf,
5615 ((val & 0xf) << 4) | ((val & 0xf0) << 17) | opcode,
5616 fixP->fx_size);
5617 else
5618 csky_write_insn (buf, val | opcode, fixP->fx_size);
5619 fixP->fx_done = 1;
5620 break;
5621 }
5622 }
5623 fixP->fx_addnumber = val;
5624 }
5625
5626 /* Translate internal representation of relocation info to BFD target
5627 format. */
5628
5629 arelent *
5630 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixP)
5631 {
5632 arelent *rel;
5633
5634 if (fixP->fx_pcrel
5635 && fixP->fx_r_type == BFD_RELOC_CKCORE_ADDR32)
5636 fixP->fx_r_type = BFD_RELOC_CKCORE_PCREL32;
5637
5638 rel = xmalloc (sizeof (arelent));
5639 rel->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
5640 *rel->sym_ptr_ptr = symbol_get_bfdsym (fixP->fx_addsy);
5641 rel->howto = bfd_reloc_type_lookup (stdoutput, fixP->fx_r_type);
5642 rel->addend = fixP->fx_offset;
5643 if (rel->howto == NULL)
5644 {
5645 as_bad_where (fixP->fx_file, fixP->fx_line,
5646 _("cannot represent `%s' relocation in object file"),
5647 bfd_get_reloc_code_name (fixP->fx_r_type));
5648
5649 /* Set howto to a garbage value so that we can keep going. */
5650 rel->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32);
5651 }
5652 gas_assert (rel->howto != NULL);
5653 rel->address = fixP->fx_frag->fr_address + fixP->fx_where;
5654 return rel;
5655 }
5656
5657 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
5658
5659 long
5660 csky_relax_frag (segT segment, fragS *fragP, long stretch)
5661 {
5662 const relax_typeS *this_type;
5663 const relax_typeS *start_type;
5664 relax_substateT next_state;
5665 relax_substateT this_state;
5666 offsetT growth;
5667 offsetT aim;
5668 addressT target;
5669 addressT address;
5670 symbolS *symbolP;
5671 const relax_typeS *table;
5672
5673 target = fragP->fr_offset;
5674 address = fragP->fr_address;
5675 table = TC_GENERIC_RELAX_TABLE;
5676 this_state = fragP->fr_subtype;
5677 start_type = this_type = table + this_state;
5678 symbolP = fragP->fr_symbol;
5679
5680 if (symbolP)
5681 {
5682 fragS *sym_frag;
5683
5684 sym_frag = symbol_get_frag (symbolP);
5685
5686 #ifndef DIFF_EXPR_OK
5687 know (sym_frag != NULL);
5688 #endif
5689 know (S_GET_SEGMENT (symbolP) != absolute_section
5690 || sym_frag == &zero_address_frag);
5691 target += S_GET_VALUE (symbolP);
5692
5693 /* If SYM_FRAG has yet to be reached on this pass, assume it
5694 will move by STRETCH just as we did, unless there is an
5695 alignment frag between here and SYM_FRAG. An alignment may
5696 well absorb any STRETCH, and we don't want to choose a larger
5697 branch insn by overestimating the needed reach of this
5698 branch. It isn't critical to calculate TARGET exactly; We
5699 know we'll be doing another pass if STRETCH is non-zero. */
5700
5701 if (stretch != 0
5702 && sym_frag->relax_marker != fragP->relax_marker
5703 && S_GET_SEGMENT (symbolP) == segment)
5704 {
5705 fragS *f;
5706
5707 /* Adjust stretch for any alignment frag. Note that if have
5708 been expanding the earlier code, the symbol may be
5709 defined in what appears to be an earlier frag. FIXME:
5710 This doesn't handle the fr_subtype field, which specifies
5711 a maximum number of bytes to skip when doing an
5712 alignment. */
5713 for (f = fragP; f != NULL && f != sym_frag; f = f->fr_next)
5714 {
5715 if (f->fr_type == rs_align || f->fr_type == rs_align_code)
5716 {
5717 if (stretch < 0)
5718 stretch = -((-stretch)
5719 & ~((1 << (int) f->fr_offset) - 1));
5720 else
5721 stretch &= ~((1 << (int) f->fr_offset) - 1);
5722 }
5723 if (stretch == 0)
5724 break;
5725 }
5726 if (f != 0)
5727 target += stretch;
5728 }
5729 }
5730
5731 aim = target - address - fragP->fr_fix;
5732
5733 /* If the fragP->fr_symbol is extern symbol, aim should be 0. */
5734 if (fragP->fr_symbol && S_GET_SEGMENT (symbolP) != segment)
5735 aim = 0;
5736
5737 if (aim < 0)
5738 {
5739 /* Look backwards. */
5740 for (next_state = this_type->rlx_more; next_state;)
5741 if (aim >= this_type->rlx_backward)
5742 next_state = 0;
5743 else
5744 {
5745 /* Grow to next state. */
5746 this_state = next_state;
5747 this_type = table + this_state;
5748 next_state = this_type->rlx_more;
5749 }
5750 }
5751 else
5752 {
5753 /* Look forwards. */
5754 for (next_state = this_type->rlx_more; next_state;)
5755 if (aim <= this_type->rlx_forward)
5756 next_state = 0;
5757 else
5758 {
5759 /* Grow to next state. */
5760 this_state = next_state;
5761 this_type = table + this_state;
5762 next_state = this_type->rlx_more;
5763 }
5764 }
5765
5766 growth = this_type->rlx_length - start_type->rlx_length;
5767 if (growth != 0)
5768 fragP->fr_subtype = this_state;
5769 return growth;
5770 }
5771
5772 int
5773 md_estimate_size_before_relax (fragS * fragp,
5774 segT segtype)
5775 {
5776 switch (fragp->fr_subtype)
5777 {
5778 case COND_DISP10:
5779 case COND_DISP16:
5780 case SCOND_DISP10:
5781 case SCOND_DISP16:
5782 case UNCD_DISP10:
5783 case UNCD_DISP16:
5784 case JCOND_DISP10:
5785 case JCOND_DISP16:
5786 case JCOND_DISP32:
5787 case JUNCD_DISP10:
5788 case JUNCD_DISP16:
5789 case JUNCD_DISP32:
5790 case JCOMPZ_DISP16:
5791 case JCOMPZ_DISP32:
5792 case BSR_DISP26:
5793 case LRW_DISP7:
5794 case LRW2_DISP8:
5795 case LRW_DISP16:
5796 gas_assert (fragp->fr_symbol);
5797 if (IS_EXTERNAL_SYM (fragp->fr_symbol, segtype))
5798 while (csky_relax_table[fragp->fr_subtype].rlx_more > RELAX_OVERFLOW)
5799 fragp->fr_subtype = csky_relax_table[fragp->fr_subtype].rlx_more;
5800 return csky_relax_table[fragp->fr_subtype].rlx_length;
5801
5802 /* C-SKY V1 relaxes. */
5803 case C (UNCD_JUMP, UNDEF_DISP):
5804 case C (UNCD_JUMP_PIC, UNDEF_DISP):
5805 if (!fragp->fr_symbol)
5806 fragp->fr_subtype = C (UNCD_JUMP_S, DISP12);
5807 else if (S_GET_SEGMENT (fragp->fr_symbol) == segtype)
5808 fragp->fr_subtype = C (UNCD_JUMP_S, DISP12);
5809 else
5810 fragp->fr_subtype = C (UNCD_JUMP_S, UNDEF_WORD_DISP);
5811 break;
5812
5813 case C (COND_JUMP, UNDEF_DISP):
5814 case C (COND_JUMP_PIC, UNDEF_DISP):
5815 if (fragp->fr_symbol
5816 && S_GET_SEGMENT (fragp->fr_symbol) == segtype)
5817 /* Got a symbol and it's defined in this segment, become byte
5818 sized. Maybe it will fix up. */
5819 fragp->fr_subtype = C (COND_JUMP_S, DISP12);
5820 else if (fragp->fr_symbol)
5821 /* It's got a segment, but it's not ours, so it will always be
5822 long. */
5823 fragp->fr_subtype = C (COND_JUMP_S, UNDEF_WORD_DISP);
5824 else
5825 /* We know the abs value. */
5826 fragp->fr_subtype = C (COND_JUMP_S, DISP12);
5827 break;
5828
5829 case C (UNCD_JUMP, DISP12):
5830 case C (UNCD_JUMP, DISP32):
5831 case C (UNCD_JUMP, UNDEF_WORD_DISP):
5832 case C (COND_JUMP, DISP12):
5833 case C (COND_JUMP, DISP32):
5834 case C (COND_JUMP, UNDEF_WORD_DISP):
5835 case C (UNCD_JUMP_PIC, DISP12):
5836 case C (UNCD_JUMP_PIC, DISP32):
5837 case C (UNCD_JUMP_PIC, UNDEF_WORD_DISP):
5838 case C (COND_JUMP_PIC, DISP12):
5839 case C (COND_JUMP_PIC, DISP32):
5840 case C (COND_JUMP_PIC, UNDEF_WORD_DISP):
5841 case RELAX_OVERFLOW:
5842 break;
5843
5844 default:
5845 abort ();
5846 }
5847 return csky_relax_table[fragp->fr_subtype].rlx_length;
5848 }
5849
5850 /* Parse opcode like: "op oprnd1, oprnd2, oprnd3". */
5851
5852 static void
5853 csky_macro_md_assemble (const char *op,
5854 const char *oprnd1,
5855 const char *oprnd2,
5856 const char *oprnd3)
5857 {
5858 char str[80];
5859 str[0] = '\0';
5860 strcat (str, op);
5861 if (oprnd1 != NULL)
5862 {
5863 strcat (str, " ");
5864 strcat (str, oprnd1);
5865 if (oprnd2 != NULL)
5866 {
5867 strcat (str, ",");
5868 strcat (str, oprnd2);
5869 if (oprnd3 != NULL)
5870 {
5871 strcat (str, ",");
5872 strcat (str, oprnd3);
5873 }
5874 }
5875 }
5876 md_assemble (str);
5877 return;
5878 }
5879
5880 /* Get the string of operand. */
5881
5882 static int
5883 csky_get_macro_operand (char *src_s, char *dst_s, char end_sym)
5884 {
5885 int nlen = 0;
5886 while (ISSPACE (*src_s))
5887 ++src_s;
5888 while (*src_s != end_sym)
5889 dst_s[nlen++] = *(src_s++);
5890 dst_s[nlen] = '\0';
5891 return nlen;
5892 }
5893
5894 /* idly 4 -> idly4. */
5895
5896 static void
5897 csky_idly (void)
5898 {
5899 char *s = csky_insn.opcode_end;
5900 if (!is_imm_within_range (&s, 4, 4))
5901 {
5902 as_bad (_("second operand must be 4"));
5903 return;
5904 }
5905 csky_macro_md_assemble ("idly4", NULL, NULL, NULL);
5906 return;
5907 }
5908
5909 /* rolc rd, 1 or roltc rd, 1 -> addc rd, rd. */
5910
5911 static void
5912 csky_rolc (void)
5913 {
5914 char reg[10];
5915 char *s = csky_insn.opcode_end;
5916
5917 s += csky_get_macro_operand (s, reg, ',');
5918 ++s;
5919
5920 if (is_imm_within_range (&s, 1, 1))
5921 {
5922 csky_macro_md_assemble ("addc", reg, reg, NULL);
5923 return;
5924 }
5925 else
5926 as_bad (_("second operand must be 1"));
5927 }
5928
5929 /* sxtrb0(1)(2) r1, rx -> xtbr0(1)(2) r1,rx; sextb r1. */
5930
5931 static void
5932 csky_sxtrb (void)
5933 {
5934 char reg1[10];
5935 char reg2[10];
5936
5937 char *s = csky_insn.opcode_end;
5938 s += csky_get_macro_operand (s, reg1, ',');
5939 ++s;
5940 csky_get_macro_operand (s, reg2, '\0');
5941
5942 csky_macro_md_assemble (csky_insn.macro->name + 1, reg1, reg2, NULL);
5943 csky_macro_md_assemble ("sextb", reg1, NULL, NULL);
5944 return;
5945 }
5946
5947 static void
5948 csky_movtf (void)
5949 {
5950 char reg1[10];
5951 char reg2[10];
5952 char reg3[10];
5953
5954 char *s = csky_insn.opcode_end;
5955 s += csky_get_macro_operand (s, reg1, ',');
5956 ++s;
5957
5958 s += csky_get_macro_operand (s, reg2, ',');
5959 ++s;
5960
5961 s += csky_get_macro_operand (s, reg3, '\0');
5962 ++s;
5963 csky_macro_md_assemble ("movt", reg1, reg2, NULL);
5964 csky_macro_md_assemble ("movf", reg1, reg3, NULL);
5965 return;
5966 }
5967
5968 static bool
5969 get_macro_reg_vals (int *reg1, int *reg2, int *reg3)
5970 {
5971 int nlen;
5972 char *s = csky_insn.opcode_end;
5973
5974 *reg1 = csky_get_reg_val (s, &nlen);
5975 s += nlen;
5976 if (*s != ',')
5977 {
5978 csky_show_error (ERROR_MISSING_COMMA, 0, NULL, NULL);
5979 return false;
5980 }
5981 s++;
5982 *reg2 = csky_get_reg_val (s, &nlen);
5983 s += nlen;
5984 if (*s != ',')
5985 {
5986 csky_show_error (ERROR_MISSING_COMMA, 0, NULL, NULL);
5987 return false;
5988 }
5989 s++;
5990 *reg3 = csky_get_reg_val (s, &nlen);
5991 s += nlen;
5992 if (*s != '\0')
5993 {
5994 csky_show_error (ERROR_BAD_END, 0, s, NULL);
5995 return false;
5996 }
5997 if (*reg1 == -1 || *reg2 == -1 || *reg3 == -1)
5998 {
5999 as_bad (_("register number out of range"));
6000 return false;
6001 }
6002 if (*reg1 != *reg2)
6003 {
6004 as_bad (_("dest and source1 must be the same register"));
6005 return false;
6006 }
6007 if (*reg1 >= 15 || *reg3 >= 15)
6008 {
6009 as_bad (_("64-bit operator src/dst register must be less than 15"));
6010 return false;
6011 }
6012 return true;
6013 }
6014
6015 /* addc64 rx, rx, ry -> cmplt rx, rx, addc rx, ry, addc rx+1, ry+1. */
6016
6017 static void
6018 csky_addc64 (void)
6019 {
6020 int reg1;
6021 int reg2;
6022 int reg3;
6023 char reg1_name[16] = {0};
6024 char reg3_name[16] = {0};
6025
6026 if (!get_macro_reg_vals (&reg1, &reg2, &reg3))
6027 return;
6028
6029 sprintf (reg1_name, "r%d", reg1);
6030 csky_macro_md_assemble ("cmplt", reg1_name, reg1_name, NULL);
6031 if (error_state.err_num != ERROR_NONE)
6032 return;
6033
6034 sprintf (reg1_name, "r%d", reg1 + (target_big_endian ? 1 : 0));
6035 sprintf (reg3_name, "r%d", reg3 + (target_big_endian ? 1 : 0));
6036 csky_macro_md_assemble ("addc", reg1_name, reg3_name, NULL);
6037 if (error_state.err_num != ERROR_NONE)
6038 return;
6039
6040 sprintf (reg1_name, "r%d", reg1 + (target_big_endian ? 0 : 1));
6041 sprintf (reg3_name, "r%d", reg3 + (target_big_endian ? 0 : 1));
6042 csky_macro_md_assemble ("addc", reg1_name, reg3_name, NULL);
6043 return;
6044 }
6045
6046 /* subc64 rx, rx, ry -> cmphs rx, rx, subc rx, ry, subc rx+1, ry+1. */
6047
6048 static void
6049 csky_subc64 (void)
6050 {
6051 int reg1;
6052 int reg2;
6053 int reg3;
6054 char reg1_name[16] = {0};
6055 char reg3_name[16] = {0};
6056
6057 if (!get_macro_reg_vals (&reg1, &reg2, &reg3))
6058 return;
6059
6060 sprintf (reg1_name, "r%d", reg1);
6061 csky_macro_md_assemble ("cmphs", reg1_name, reg1_name, NULL);
6062 if (error_state.err_num != ERROR_NONE)
6063 return;
6064
6065 sprintf (reg1_name, "r%d", reg1 + (target_big_endian ? 1 : 0));
6066 sprintf (reg3_name, "r%d", reg3 + (target_big_endian ? 1 : 0));
6067 csky_macro_md_assemble ("subc", reg1_name, reg3_name, NULL);
6068 if (error_state.err_num != ERROR_NONE)
6069 return;
6070
6071 sprintf (reg1_name, "r%d", reg1 + (target_big_endian ? 0 : 1));
6072 sprintf (reg3_name, "r%d", reg3 + (target_big_endian ? 0 : 1));
6073 csky_macro_md_assemble ("subc", reg1_name, reg3_name, NULL);
6074 return;
6075 }
6076
6077 /* or64 rx, rx, ry -> or rx, ry, or rx+1, ry+1. */
6078
6079 static void
6080 csky_or64 (void)
6081 {
6082 int reg1;
6083 int reg2;
6084 int reg3;
6085 char reg1_name[16] = {0};
6086 char reg3_name[16] = {0};
6087
6088 if (!get_macro_reg_vals (&reg1, &reg2, &reg3))
6089 return;
6090 sprintf (reg1_name, "r%d", reg1 + (target_big_endian ? 1 : 0));
6091 sprintf (reg3_name, "r%d", reg3 + (target_big_endian ? 1 : 0));
6092 csky_macro_md_assemble ("or", reg1_name, reg3_name, NULL);
6093
6094 if (error_state.err_num != ERROR_NONE)
6095 return;
6096 sprintf (reg1_name, "r%d", reg1 + (target_big_endian ? 0 : 1));
6097 sprintf (reg3_name, "r%d", reg3 + (target_big_endian ? 0 : 1));
6098 csky_macro_md_assemble ("or", reg1_name, reg3_name, NULL);
6099 return;
6100 }
6101
6102 /* xor64 rx, rx, ry -> xor rx, ry, xor rx+1, ry+1. */
6103
6104 static void
6105 csky_xor64 (void)
6106 {
6107 int reg1;
6108 int reg2;
6109 int reg3;
6110 char reg1_name[16] = {0};
6111 char reg3_name[16] = {0};
6112
6113 if (!get_macro_reg_vals (&reg1, &reg2, &reg3))
6114 return;
6115
6116 sprintf (reg1_name, "r%d", reg1 + (target_big_endian ? 1 : 0));
6117 sprintf (reg3_name, "r%d", reg3 + (target_big_endian ? 1 : 0));
6118 csky_macro_md_assemble ("xor", reg1_name, reg3_name, NULL);
6119 if (error_state.err_num != ERROR_NONE)
6120 return;
6121
6122 sprintf (reg1_name, "r%d", reg1 + (target_big_endian ? 0 : 1));
6123 sprintf (reg3_name, "r%d", reg3 + (target_big_endian ? 0 : 1));
6124 csky_macro_md_assemble ("xor", reg1_name, reg3_name, NULL);
6125 return;
6126 }
6127
6128 /* The following are V2 macro instructions. */
6129
6130 /* neg rd -> not rd, rd; addi rd, 1. */
6131
6132 static void
6133 csky_neg (void)
6134 {
6135 char reg1[10];
6136
6137 char *s = csky_insn.opcode_end;
6138 s += csky_get_macro_operand (s, reg1, '\0');
6139 ++s;
6140
6141 csky_macro_md_assemble ("not", reg1, reg1, NULL);
6142 csky_macro_md_assemble ("addi", reg1, "1", NULL);
6143 return;
6144 }
6145
6146 /* rsubi rd, imm16 -> not rd; addi rd, imm16 + 1 */
6147
6148 static void
6149 csky_rsubi (void)
6150 {
6151 char reg1[10];
6152 char str_imm16[20];
6153 unsigned int imm16 = 0;
6154 expressionS e;
6155 char *s = csky_insn.opcode_end;
6156 s += csky_get_macro_operand (s, reg1, ',');
6157 ++s;
6158
6159 s = parse_exp (s, &e);
6160 if (e.X_op == O_constant)
6161 imm16 = e.X_add_number;
6162 else
6163 csky_show_error (ERROR_IMM_ILLEGAL, 2, NULL, NULL);
6164
6165 sprintf (str_imm16, "%d", imm16 + 1);
6166
6167 csky_macro_md_assemble ("not", reg1, reg1, NULL);
6168 csky_macro_md_assemble ("addi", reg1, str_imm16, NULL);
6169 return;
6170 }
6171
6172 /* Such as: asrc rd -> asrc rd, rd, 1. */
6173
6174 static void
6175 csky_arith (void)
6176 {
6177 char reg1[10];
6178 char *s = csky_insn.opcode_end;
6179 s += csky_get_macro_operand (s, reg1, '\0');
6180 ++s;
6181 csky_macro_md_assemble (csky_insn.macro->name, reg1, reg1, "1");
6182 return;
6183 }
6184
6185 /* decne rd -> if ck802: subi rd, 1; cmpnei rd, 0.
6186 else: decne rd, rd, 1 */
6187
6188 static void
6189 csky_decne (void)
6190 {
6191 char reg1[10];
6192 char *s = csky_insn.opcode_end;
6193 s += csky_get_macro_operand (s, reg1, '\0');
6194 ++s;
6195 if (IS_CSKY_ARCH_802 (mach_flag))
6196 {
6197 csky_macro_md_assemble ("subi", reg1, "1", NULL);
6198 csky_macro_md_assemble ("cmpnei", reg1, "0", NULL);
6199 }
6200 else
6201 csky_macro_md_assemble ("decne", reg1, reg1, "1");
6202 return;
6203 }
6204
6205 /* If -mnolrw, lrw rd, imm -> movih rd, imm_hi16; ori rd, imm_lo16. */
6206
6207 static void
6208 csky_lrw (void)
6209 {
6210 char reg1[10];
6211 char imm[40];
6212 char imm_hi16[40];
6213 char imm_lo16[40];
6214
6215 char *s = csky_insn.opcode_end;
6216 s += csky_get_macro_operand (s, reg1, ',');
6217 ++s;
6218 s += csky_get_macro_operand (s, imm, '\0');
6219 ++s;
6220
6221 imm_hi16[0] = '\0';
6222 strcat (imm_hi16, "(");
6223 strcat (imm_hi16, imm);
6224 strcat (imm_hi16, ") >> 16");
6225 imm_lo16[0] = '\0';
6226 strcat (imm_lo16, "(");
6227 strcat (imm_lo16, imm);
6228 strcat (imm_lo16, ") & 0xffff");
6229
6230 csky_macro_md_assemble ("movih", reg1, imm_hi16, NULL);
6231 csky_macro_md_assemble ("ori", reg1, reg1, imm_lo16);
6232
6233 return;
6234 }
6235
6236 /* The following are worker functions for C-SKY v1. */
6237
6238 bool
6239 v1_work_lrw (void)
6240 {
6241 int reg;
6242 int output_literal = csky_insn.val[1];
6243
6244 reg = csky_insn.val[0];
6245 csky_insn.isize = 2;
6246 csky_insn.output = frag_more (2);
6247 if (csky_insn.e1.X_op == O_constant
6248 && csky_insn.e1.X_add_number <= 0x7f
6249 && csky_insn.e1.X_add_number >= 0)
6250 /* lrw to movi. */
6251 csky_insn.inst = 0x6000 | reg | (csky_insn.e1.X_add_number << 4);
6252 else
6253 {
6254 csky_insn.inst = csky_insn.opcode->op16[0].opcode;
6255 csky_insn.inst |= reg << 8;
6256 if (output_literal)
6257 {
6258 struct literal *p = enter_literal (&csky_insn.e1, 0, 0, 0);
6259
6260 /* Create a reference to pool entry. */
6261 csky_insn.e1.X_op = O_symbol;
6262 csky_insn.e1.X_add_symbol = poolsym;
6263 csky_insn.e1.X_add_number = p->offset << 2;
6264 }
6265
6266 if (insn_reloc == BFD_RELOC_CKCORE_TLS_GD32
6267 || insn_reloc == BFD_RELOC_CKCORE_TLS_LDM32
6268 || insn_reloc == BFD_RELOC_CKCORE_TLS_IE32)
6269 {
6270 literal_insn_offset->tls_addend.frag = frag_now;
6271 literal_insn_offset->tls_addend.offset
6272 = (csky_insn.output
6273 - literal_insn_offset->tls_addend.frag->fr_literal);
6274 }
6275 fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal, 2,
6276 &csky_insn.e1, 1, BFD_RELOC_CKCORE_PCREL_IMM8BY4);
6277 }
6278 csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6279
6280 return true;
6281 }
6282
6283 bool
6284 v1_work_fpu_fo (void)
6285 {
6286 int i = 0;
6287 int inst;
6288 int greg = -1;
6289 char buff[50];
6290 struct csky_opcode_info *opinfo = NULL;
6291
6292 if (csky_insn.isize == 4)
6293 opinfo = &csky_insn.opcode->op32[csky_insn.opcode_idx];
6294 else if (csky_insn.isize == 2)
6295 opinfo = &csky_insn.opcode->op16[csky_insn.opcode_idx];
6296
6297 /* Firstly, get general reg. */
6298 for (i = 0;i < opinfo->operand_num; i++)
6299 if (opinfo->oprnd.oprnds[i].type == OPRND_TYPE_GREG0_15)
6300 greg = csky_insn.val[i];
6301 gas_assert (greg != -1);
6302
6303 /* Secondly, get float inst. */
6304 csky_generate_insn ();
6305 inst = csky_insn.inst;
6306
6307 /* Now get greg and inst, we can write instruction to floating unit. */
6308 sprintf (buff, "lrw r%d,0x%x", greg, inst);
6309 md_assemble (buff);
6310 sprintf (buff, "cpwir r%d", greg);
6311 md_assemble (buff);
6312 return false;
6313 }
6314
6315 bool
6316 v1_work_fpu_fo_fc (void)
6317 {
6318 int i = 0;
6319 int inst;
6320 int greg = -1;
6321 char buff[50];
6322 struct csky_opcode_info *opinfo = NULL;
6323
6324 if (csky_insn.isize == 4)
6325 opinfo = &csky_insn.opcode->op32[csky_insn.opcode_idx];
6326 else if (csky_insn.isize == 2)
6327 opinfo = &csky_insn.opcode->op16[csky_insn.opcode_idx];
6328
6329 /* Firstly, get general reg. */
6330 for (i = 0;i < opinfo->operand_num; i++)
6331 if (opinfo->oprnd.oprnds[i].type == OPRND_TYPE_GREG0_15)
6332 greg = csky_insn.val[i];
6333 gas_assert (greg != -1);
6334
6335 /* Secondly, get float inst. */
6336 csky_generate_insn ();
6337 inst = csky_insn.inst;
6338
6339 /* Now get greg and inst, we can write instruction to floating unit. */
6340 sprintf (buff, "lrw r%d,0x%x", greg, inst);
6341 md_assemble (buff);
6342 sprintf (buff, "cpwir r%d", greg);
6343 md_assemble (buff);
6344 sprintf (buff, "cprc");
6345 md_assemble (buff);
6346
6347 return false;
6348 }
6349
6350 bool
6351 v1_work_fpu_write (void)
6352 {
6353 int greg;
6354 int freg;
6355 char buff[50];
6356
6357 greg = csky_insn.val[0];
6358 freg = csky_insn.val[1];
6359
6360 /* Now get greg and freg, we can write instruction to floating unit. */
6361 sprintf (buff, "cpwgr r%d,cpr%d", greg, freg);
6362 md_assemble (buff);
6363
6364 return false;
6365 }
6366
6367 bool
6368 v1_work_fpu_read (void)
6369 {
6370 int greg;
6371 int freg;
6372 char buff[50];
6373
6374 greg = csky_insn.val[0];
6375 freg = csky_insn.val[1];
6376 /* Now get greg and freg, we can write instruction to floating unit. */
6377 sprintf (buff, "cprgr r%d,cpr%d", greg, freg);
6378 md_assemble (buff);
6379
6380 return false;
6381 }
6382
6383 bool
6384 v1_work_fpu_writed (void)
6385 {
6386 int greg;
6387 int freg;
6388 char buff[50];
6389
6390 greg = csky_insn.val[0];
6391 freg = csky_insn.val[1];
6392
6393 if (greg & 0x1)
6394 {
6395 as_bad (_("even register number required"));
6396 return false;
6397 }
6398 /* Now get greg and freg, we can write instruction to floating unit. */
6399 if (target_big_endian)
6400 sprintf (buff, "cpwgr r%d,cpr%d", greg + 1, freg);
6401 else
6402 sprintf (buff, "cpwgr r%d,cpr%d", greg, freg);
6403 md_assemble (buff);
6404 if (target_big_endian)
6405 sprintf (buff, "cpwgr r%d,cpr%d", greg, freg + 1);
6406 else
6407 sprintf (buff, "cpwgr r%d,cpr%d", greg+1, freg + 1);
6408 md_assemble (buff);
6409 return false;
6410 }
6411
6412 bool
6413 v1_work_fpu_readd (void)
6414 {
6415 int greg;
6416 int freg;
6417 char buff[50];
6418
6419 greg = csky_insn.val[0];
6420 freg = csky_insn.val[1];
6421
6422 if (greg & 0x1)
6423 {
6424 as_bad (_("even register number required"));
6425 return false;
6426 }
6427 /* Now get greg and freg, we can write instruction to floating unit. */
6428 if (target_big_endian)
6429 sprintf (buff, "cprgr r%d,cpr%d", greg+1, freg);
6430 else
6431 sprintf (buff, "cprgr r%d,cpr%d", greg, freg);
6432 md_assemble (buff);
6433 if (target_big_endian)
6434 sprintf (buff, "cprgr r%d,cpr%d", greg, freg + 1);
6435 else
6436 sprintf (buff, "cprgr r%d,cpr%d", greg+1, freg + 1);
6437 md_assemble (buff);
6438
6439 return false;
6440 }
6441
6442 /* The following are for csky pseudo handling. */
6443
6444 bool
6445 v1_work_jbsr (void)
6446 {
6447 csky_insn.output = frag_more (2);
6448 if (do_force2bsr)
6449 /* Generate fixup BFD_RELOC_CKCORE_PCREL_IMM11BY2. */
6450 fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
6451 2, & csky_insn.e1, 1, BFD_RELOC_CKCORE_PCREL_IMM11BY2);
6452 else
6453 {
6454 /* Using jsri instruction. */
6455 const char *name = "jsri";
6456 csky_insn.opcode = (struct csky_opcode *)
6457 str_hash_find (csky_opcodes_hash, name);
6458 csky_insn.opcode_idx = 0;
6459 csky_insn.isize = 2;
6460
6461 struct literal *p = enter_literal (&csky_insn.e1, 1, 0, 0);
6462
6463 /* Create a reference to pool entry. */
6464 csky_insn.e1.X_op = O_symbol;
6465 csky_insn.e1.X_add_symbol = poolsym;
6466 csky_insn.e1.X_add_number = p->offset << 2;
6467
6468 /* Generate fixup BFD_RELOC_CKCORE_PCREL_IMM8BY4. */
6469 fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
6470 2, & csky_insn.e1, 1, BFD_RELOC_CKCORE_PCREL_IMM8BY4);
6471
6472 if (csky_insn.e1.X_op != O_absent && do_jsri2bsr)
6473 /* Generate fixup BFD_RELOC_CKCORE_PCREL_JSR_IMM11BY2. */
6474 fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
6475 2, &p->e,
6476 1, BFD_RELOC_CKCORE_PCREL_JSR_IMM11BY2);
6477 }
6478 csky_generate_insn ();
6479
6480 csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6481
6482 return true;
6483 }
6484
6485 /* The following are worker functions for csky v2 instruction handling. */
6486
6487 /* For nie/nir/ipush/ipop. */
6488
6489 bool
6490 v2_work_istack (void)
6491 {
6492 if (!do_intr_stack)
6493 {
6494 csky_show_error (ERROR_OPCODE_ILLEGAL, 0, NULL, NULL);
6495 return false;
6496 }
6497 csky_insn.output = frag_more (csky_insn.isize);
6498 csky_insn.inst = csky_insn.opcode->op16[0].opcode;
6499 csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6500 return true;
6501 }
6502
6503 bool
6504 v2_work_btsti (void)
6505 {
6506 if (!do_extend_lrw
6507 && (csky_insn.flag_force == INSN_OPCODE16F
6508 || IS_CSKY_ARCH_801 (mach_flag)))
6509 {
6510 csky_show_error (ERROR_OPCODE_ILLEGAL, 0, NULL, NULL);
6511 return false;
6512 }
6513 if (!do_extend_lrw && csky_insn.isize == 2)
6514 csky_insn.isize = 4;
6515 /* Generate relax or reloc if necessary. */
6516 csky_generate_frags ();
6517 /* Generate the insn by mask. */
6518 csky_generate_insn ();
6519 /* Write inst to frag. */
6520 csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6521 return true;
6522 }
6523
6524 bool
6525 v2_work_addi (void)
6526 {
6527 csky_insn.isize = 2;
6528 if (csky_insn.number == 2)
6529 {
6530 if (csky_insn.val[0] == 14
6531 && csky_insn.val[1] >= 0 && csky_insn.val[1] <= 0x1fc
6532 && (csky_insn.val[1] & 0x3) == 0
6533 && csky_insn.flag_force != INSN_OPCODE32F)
6534 {
6535 /* addi sp, sp, imm. */
6536 csky_insn.inst = 0x1400 | ((csky_insn.val[1] >> 2) & 0x1f);
6537 csky_insn.inst |= (csky_insn.val[1] << 1) & 0x300;
6538 csky_insn.output = frag_more (2);
6539 }
6540 else if (csky_insn.val[0] < 8
6541 && csky_insn.val[1] >= 1 && csky_insn.val[1] <= 0x100
6542 && csky_insn.flag_force != INSN_OPCODE32F)
6543 {
6544 csky_insn.inst = 0x2000 | (csky_insn.val[0] << 8);
6545 csky_insn.inst |= (csky_insn.val[1] - 1);
6546 csky_insn.output = frag_more (2);
6547 }
6548 else if (csky_insn.val[1] >= 1 && csky_insn.val[1] <= 0x10000
6549 && csky_insn.flag_force != INSN_OPCODE16F
6550 && !IS_CSKY_ARCH_801 (mach_flag))
6551 {
6552 csky_insn.inst = 0xe4000000 | (csky_insn.val[0] << 21);
6553 csky_insn.inst |= csky_insn.val[0] << 16;
6554 csky_insn.inst |= (csky_insn.val[1] - 1);
6555 csky_insn.isize = 4;
6556 csky_insn.output = frag_more (4);
6557 }
6558 else
6559 {
6560 csky_show_error (ERROR_OPERANDS_ILLEGAL, 0,
6561 csky_insn.opcode_end, NULL);
6562 return false;
6563 }
6564 }
6565 else if (csky_insn.number == 3)
6566 {
6567 if (csky_insn.val[0] == 14
6568 && csky_insn.val[1] == 14
6569 && csky_insn.val[2] >= 0 && csky_insn.val[2] <= 0x1fc
6570 && (csky_insn.val[2] & 0x3) == 0
6571 && csky_insn.flag_force != INSN_OPCODE32F)
6572 {
6573 csky_insn.inst = 0x1400 | ((csky_insn.val[2] >> 2) & 0x1f);
6574 csky_insn.inst |= (csky_insn.val[2] << 1) & 0x300;
6575 csky_insn.output = frag_more (2);
6576 }
6577 else if (csky_insn.val[0] < 8
6578 && csky_insn.val[1] == 14
6579 && csky_insn.val[2] >= 0 && csky_insn.val[2] <= 0x3fc
6580 && (csky_insn.val[2] & 0x3) == 0
6581 && csky_insn.flag_force != INSN_OPCODE32F)
6582 {
6583 csky_insn.inst = 0x1800 | (csky_insn.val[0] << 8);
6584 csky_insn.inst |= csky_insn.val[2] >> 2;
6585 csky_insn.output = frag_more (2);
6586 }
6587 else if (csky_insn.val[0] < 8
6588 && csky_insn.val[0] == csky_insn.val[1]
6589 && csky_insn.val[2] >= 1 && csky_insn.val[2] <= 0x100
6590 && csky_insn.flag_force != INSN_OPCODE32F)
6591 {
6592 csky_insn.inst = 0x2000 | (csky_insn.val[0] << 8);
6593 csky_insn.inst |= (csky_insn.val[2] - 1);
6594 csky_insn.output = frag_more (2);
6595 }
6596 else if (csky_insn.val[0] < 8
6597 && csky_insn.val[1] < 8
6598 && csky_insn.val[2] >= 1 && csky_insn.val[2] <= 0x8
6599 && csky_insn.flag_force != INSN_OPCODE32F)
6600 {
6601 csky_insn.inst = 0x5802 | (csky_insn.val[0] << 5);
6602 csky_insn.inst |= csky_insn.val[1] << 8;
6603 csky_insn.inst |= (csky_insn.val[2] - 1) << 2;
6604 csky_insn.output = frag_more (2);
6605 }
6606 else if (csky_insn.val[1] == 28
6607 && csky_insn.val[2] >= 1 && csky_insn.val[2] <= 0x40000
6608 && csky_insn.flag_force != INSN_OPCODE16F
6609 && !IS_CSKY_ARCH_801 (mach_flag))
6610 {
6611 csky_insn.inst = 0xcc1c0000 | (csky_insn.val[0] << 21);
6612 csky_insn.isize = 4;
6613 csky_insn.output = frag_more (4);
6614 if (insn_reloc == BFD_RELOC_CKCORE_GOTOFF)
6615 {
6616 fix_new_exp (frag_now, csky_insn.output-frag_now->fr_literal,
6617 4, &csky_insn.e1, 0, BFD_RELOC_CKCORE_GOTOFF_IMM18);
6618 }
6619 else
6620 csky_insn.inst |= (csky_insn.val[2] - 1);
6621 }
6622 else if (csky_insn.val[2] >= 1 && csky_insn.val[2] <= 0x1000
6623 && csky_insn.flag_force != INSN_OPCODE16F
6624 && !IS_CSKY_ARCH_801 (mach_flag))
6625 {
6626 csky_insn.inst = 0xe4000000 | (csky_insn.val[0] << 21);
6627 csky_insn.inst |= csky_insn.val[1] << 16;
6628 csky_insn.inst |= (csky_insn.val[2] - 1);
6629 csky_insn.isize = 4;
6630 csky_insn.output = frag_more (4);
6631 }
6632 else
6633 {
6634 csky_show_error (ERROR_OPERANDS_ILLEGAL, 0,
6635 (char *)csky_insn.opcode_end, NULL);
6636 return false;
6637 }
6638 }
6639 csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6640
6641 return true;
6642 }
6643
6644 bool
6645 v2_work_subi (void)
6646 {
6647 csky_insn.isize = 2;
6648 if (csky_insn.number == 2)
6649 {
6650 if (csky_insn.val[0] == 14
6651 && csky_insn.val[1] >= 0 && csky_insn.val[2] <= 0x1fc
6652 && (csky_insn.val[1] & 0x3) == 0
6653 && csky_insn.flag_force != INSN_OPCODE32F)
6654 {
6655 csky_insn.inst = 0x1420 | ((csky_insn.val[1] >> 2) & 0x1f);
6656 csky_insn.inst |= (csky_insn.val[1] << 1) & 0x300;
6657 }
6658 else if (csky_insn.val[0] < 8
6659 && csky_insn.val[1] >= 1 && csky_insn.val[1] <= 0x100
6660 && csky_insn.flag_force != INSN_OPCODE32F)
6661 {
6662 csky_insn.inst = 0x2800 | (csky_insn.val[0] << 8);
6663 csky_insn.inst |= (csky_insn.val[1] - 1);
6664 }
6665 else if (csky_insn.val[1] >= 1 && csky_insn.val[1] <= 0x10000
6666 && csky_insn.flag_force != INSN_OPCODE16F
6667 && !IS_CSKY_ARCH_801 (mach_flag))
6668 {
6669 csky_insn.inst = 0xe4001000 | (csky_insn.val[0] << 21);
6670 csky_insn.inst |= csky_insn.val[0] << 16;
6671 csky_insn.inst |= (csky_insn.val[1] - 1);
6672 csky_insn.isize = 4;
6673 }
6674 else
6675 {
6676 csky_show_error (ERROR_OPERANDS_ILLEGAL, 0,
6677 (char *)csky_insn.opcode_end, NULL);
6678 return false;
6679 }
6680 }
6681 else if (csky_insn.number == 3)
6682 {
6683 if (csky_insn.val[0] == 14
6684 && csky_insn.val[1] == 14
6685 && csky_insn.val[2] >= 0 && csky_insn.val[2] <= 0x1fc
6686 && (csky_insn.val[2] & 0x3) == 0
6687 && csky_insn.flag_force != INSN_OPCODE32F)
6688 {
6689 csky_insn.inst = 0x1420 | ((csky_insn.val[2] >> 2) & 0x1f);
6690 csky_insn.inst |= (csky_insn.val[2] << 1) & 0x300;
6691 }
6692
6693 else if (csky_insn.val[0] < 8
6694 && csky_insn.val[0] == csky_insn.val[1]
6695 && csky_insn.val[2] >= 1 && csky_insn.val[2] <= 0x100
6696 && csky_insn.flag_force != INSN_OPCODE32F)
6697 {
6698 csky_insn.inst = 0x2800 | (csky_insn.val[0] << 8);
6699 csky_insn.inst |= (csky_insn.val[2] - 1);
6700 }
6701 else if (csky_insn.val[0] < 8
6702 && csky_insn.val[1] < 8
6703 && csky_insn.val[2] >= 1 && csky_insn.val[2] <= 0x8
6704 && csky_insn.flag_force != INSN_OPCODE32F)
6705 {
6706 csky_insn.inst = 0x5803 | (csky_insn.val[0] << 5);
6707 csky_insn.inst |= csky_insn.val[1] << 8;
6708 csky_insn.inst |= (csky_insn.val[2] - 1) << 2;
6709 }
6710 else if (csky_insn.val[2] >= 1 && csky_insn.val[2] <= 0x1000
6711 && csky_insn.flag_force != INSN_OPCODE16F
6712 && !IS_CSKY_ARCH_801 (mach_flag))
6713 {
6714 csky_insn.inst = 0xe4001000 | (csky_insn.val[0] << 21);
6715 csky_insn.inst |= csky_insn.val[1] << 16;
6716 csky_insn.inst |= (csky_insn.val[2] - 1);
6717 csky_insn.isize = 4;
6718 }
6719 else
6720 {
6721 csky_show_error (ERROR_OPERANDS_ILLEGAL, 0,
6722 (char *)csky_insn.opcode_end, NULL);
6723 return false;
6724 }
6725 }
6726 csky_insn.output = frag_more (csky_insn.isize);
6727 csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6728
6729 return true;
6730 }
6731
6732 bool
6733 v2_work_add_sub (void)
6734 {
6735 if (csky_insn.number == 3
6736 && (csky_insn.val[0] == csky_insn.val[1]
6737 || csky_insn.val[0] == csky_insn.val[2])
6738 && csky_insn.val[0] <= 15
6739 && csky_insn.val[1] <= 15
6740 && csky_insn.val[2] <= 15)
6741 {
6742 if (!strstr (csky_insn.opcode->mnemonic, "sub")
6743 || csky_insn.val[0] == csky_insn.val[1])
6744 {
6745 csky_insn.opcode_idx = 0;
6746 csky_insn.isize = 2;
6747 if (csky_insn.val[0] == csky_insn.val[1])
6748 csky_insn.val[1] = csky_insn.val[2];
6749
6750 csky_insn.number = 2;
6751
6752 }
6753 }
6754 if (csky_insn.isize == 4
6755 && IS_CSKY_ARCH_801 (mach_flag))
6756 {
6757 if (csky_insn.number == 3)
6758 {
6759 if (csky_insn.val[0] > 7)
6760 {
6761 SET_ERROR_INTEGER (ERROR_REG_OVER_RANGE, csky_insn.val[0]);
6762 csky_show_error (ERROR_REG_OVER_RANGE, 1, NULL, NULL);
6763 }
6764 if (csky_insn.val[1] > 7)
6765 {
6766 SET_ERROR_INTEGER (ERROR_REG_OVER_RANGE, csky_insn.val[1]);
6767 csky_show_error (ERROR_REG_OVER_RANGE, 2, NULL, NULL);
6768 }
6769 if (csky_insn.val[2] > 7)
6770 {
6771 SET_ERROR_INTEGER (ERROR_REG_OVER_RANGE, csky_insn.val[2]);
6772 csky_show_error (ERROR_REG_OVER_RANGE, 3, NULL, NULL);
6773 }
6774 }
6775 else
6776 {
6777 if (csky_insn.val[0] > 15)
6778 {
6779 SET_ERROR_INTEGER (ERROR_REG_OVER_RANGE, csky_insn.val[0]);
6780 csky_show_error (ERROR_REG_OVER_RANGE, 1, NULL, NULL);
6781 }
6782 if (csky_insn.val[1] > 15)
6783 {
6784 SET_ERROR_INTEGER (ERROR_REG_OVER_RANGE, csky_insn.val[1]);
6785 csky_show_error (ERROR_REG_OVER_RANGE, 2, NULL, NULL);
6786 }
6787 }
6788 return false;
6789 }
6790 /* sub rz, rx. */
6791 /* Generate relax or reloc if necessary. */
6792 csky_generate_frags ();
6793 /* Generate the insn by mask. */
6794 csky_generate_insn ();
6795 /* Write inst to frag. */
6796 csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6797 return true;
6798 }
6799
6800 bool
6801 v2_work_rotlc (void)
6802 {
6803 const char *name = "addc";
6804 csky_insn.opcode
6805 = (struct csky_opcode *) str_hash_find (csky_opcodes_hash, name);
6806 csky_insn.opcode_idx = 0;
6807 if (csky_insn.isize == 2)
6808 {
6809 /* addc rz, rx. */
6810 csky_insn.number = 2;
6811 csky_insn.val[1] = csky_insn.val[0];
6812 }
6813 else
6814 {
6815 csky_insn.number = 3;
6816 /* addc rz, rx, ry. */
6817 csky_insn.val[1] = csky_insn.val[0];
6818 csky_insn.val[2] = csky_insn.val[0];
6819 }
6820 /* Generate relax or reloc if necessary. */
6821 csky_generate_frags ();
6822 /* Generate the insn by mask. */
6823 csky_generate_insn ();
6824 /* Write inst to frag. */
6825 csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6826 return true;
6827 }
6828
6829 bool
6830 v2_work_bgeni (void)
6831 {
6832 const char *name = NULL;
6833 int imm = csky_insn.val[1];
6834 int val = 1 << imm;
6835 if (imm < 16)
6836 name = "movi";
6837 else
6838 {
6839 name = "movih";
6840 val >>= 16;
6841 }
6842 csky_insn.opcode
6843 = (struct csky_opcode *) str_hash_find (csky_opcodes_hash, name);
6844 csky_insn.opcode_idx = 0;
6845 csky_insn.val[1] = val;
6846
6847 /* Generate relax or reloc if necessary. */
6848 csky_generate_frags ();
6849 /* Generate the insn by mask. */
6850 csky_generate_insn ();
6851 /* Write inst to frag. */
6852 csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6853 return true;
6854 }
6855
6856 bool
6857 v2_work_not (void)
6858 {
6859 const char *name = "nor";
6860 csky_insn.opcode
6861 = (struct csky_opcode *) str_hash_find (csky_opcodes_hash, name);
6862 csky_insn.opcode_idx = 0;
6863 if (csky_insn.number == 1)
6864 {
6865 csky_insn.val[1] = csky_insn.val[0];
6866 if (csky_insn.val[0] < 16)
6867 {
6868 /* 16 bits nor rz, rz. */
6869 csky_insn.number = 2;
6870 csky_insn.isize = 2;
6871 }
6872 else
6873 {
6874 csky_insn.val[2] = csky_insn.val[0];
6875 csky_insn.number = 3;
6876 csky_insn.isize = 4;
6877 }
6878 }
6879 if (csky_insn.number == 2)
6880 {
6881 if (csky_insn.val[0] == csky_insn.val[1]
6882 && csky_insn.val[0] < 16)
6883 {
6884 /* 16 bits nor rz, rz. */
6885 csky_insn.number = 2;
6886 csky_insn.isize = 2;
6887 }
6888 else
6889 {
6890 csky_insn.val[2] = csky_insn.val[1];
6891 csky_insn.number = 3;
6892 csky_insn.isize = 4;
6893 }
6894 }
6895
6896 /* Generate relax or reloc if necessary. */
6897 csky_generate_frags ();
6898 /* Generate the insn by mask. */
6899 csky_generate_insn ();
6900 /* Write inst to frag. */
6901 csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6902 return true;
6903 }
6904
6905 bool
6906 v2_work_jbtf (void)
6907 {
6908 if (csky_insn.e1.X_add_symbol == NULL || csky_insn.e1.X_op == O_constant)
6909 {
6910 csky_show_error (ERROR_UNDEFINE, 0, (void *)"operand is invalid", NULL);
6911 return false;
6912 }
6913
6914 if (IS_CSKY_ARCH_801 (mach_flag))
6915 {
6916 /* CK801 doesn't have 32-bit bt/bf insns or a jump insn with a
6917 range larger than SCOND_DISP16. Relax to a short jump around
6918 an unconditional branch, and give up if that overflows too. */
6919 csky_insn.output = frag_var (rs_machine_dependent,
6920 SCOND_DISP16_LEN,
6921 SCOND_DISP10_LEN,
6922 SCOND_DISP10,
6923 csky_insn.e1.X_add_symbol,
6924 csky_insn.e1.X_add_number,
6925 0);
6926 csky_insn.isize = 2;
6927 csky_insn.max = SCOND_DISP16_LEN;
6928 csky_insn.inst = csky_insn.opcode->op16[0].opcode;
6929 }
6930 else if (do_long_jump && !IS_CSKY_ARCH_802 (mach_flag))
6931 {
6932 /* Generate relax with jcondition.
6933 Note that CK802 doesn't support the JMPI instruction so
6934 we cannot relax to a jump with a 32-bit offset. */
6935 csky_insn.output = frag_var (rs_machine_dependent,
6936 JCOND_DISP32_LEN,
6937 JCOND_DISP10_LEN,
6938 JCOND_DISP10,
6939 csky_insn.e1.X_add_symbol,
6940 csky_insn.e1.X_add_number,
6941 0);
6942 csky_insn.isize = 2;
6943 csky_insn.max = JCOND_DISP32_LEN;
6944 csky_insn.inst = csky_insn.opcode->op16[0].opcode;
6945 }
6946 else
6947 {
6948 /* Generate relax with condition. */
6949 csky_insn.output = frag_var (rs_machine_dependent,
6950 COND_DISP16_LEN,
6951 COND_DISP10_LEN,
6952 COND_DISP10,
6953 csky_insn.e1.X_add_symbol,
6954 csky_insn.e1.X_add_number,
6955 0);
6956 csky_insn.isize = 2;
6957 csky_insn.max = COND_DISP16_LEN;
6958 csky_insn.inst = csky_insn.opcode->op16[0].opcode;
6959 }
6960 csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
6961
6962 return true;
6963 }
6964
6965 bool
6966 v2_work_jbr (void)
6967 {
6968 if (csky_insn.e1.X_add_symbol == NULL || csky_insn.e1.X_op == O_constant)
6969 {
6970 csky_show_error (ERROR_UNDEFINE, 0, (void *)"operand is invalid", NULL);
6971 return false;
6972 }
6973
6974 if (do_long_jump
6975 && !IS_CSKY_ARCH_801 (mach_flag)
6976 && !IS_CSKY_ARCH_802 (mach_flag))
6977 {
6978 csky_insn.output = frag_var (rs_machine_dependent,
6979 JUNCD_DISP32_LEN,
6980 JUNCD_DISP10_LEN,
6981 JUNCD_DISP10,
6982 csky_insn.e1.X_add_symbol,
6983 csky_insn.e1.X_add_number,
6984 0);
6985
6986 csky_insn.inst = csky_insn.opcode->op16[0].opcode;
6987 csky_insn.max = JUNCD_DISP32_LEN;
6988 csky_insn.isize = 2;
6989 }
6990 else
6991 {
6992 /* Generate relax with condition. */
6993 csky_insn.output = frag_var (rs_machine_dependent,
6994 UNCD_DISP16_LEN,
6995 UNCD_DISP10_LEN,
6996 UNCD_DISP10,
6997 csky_insn.e1.X_add_symbol,
6998 csky_insn.e1.X_add_number,
6999 0);
7000 csky_insn.isize = 2;
7001 csky_insn.max = UNCD_DISP16_LEN;
7002 csky_insn.inst = csky_insn.opcode->op16[0].opcode;
7003
7004 }
7005 csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
7006 return true;
7007 }
7008
7009 #define SIZE_V2_MOVI16(x) ((addressT)x <= 0xff)
7010 #define SIZE_V2_MOVI32(x) ((addressT)x <= 0xffff)
7011 #define SIZE_V2_MOVIH(x) ((addressT)x <= 0xffffffff && (((addressT)x & 0xffff) == 0))
7012
7013 bool
7014 v2_work_lrw (void)
7015 {
7016 int reg = csky_insn.val[0];
7017 int output_literal = csky_insn.val[1];
7018 int is_done = 0;
7019
7020 /* If the second operand is O_constant, We can use movi/movih
7021 instead of lrw. */
7022 if (csky_insn.e1.X_op == O_constant)
7023 {
7024 /* 801 only has movi16. */
7025 if (SIZE_V2_MOVI16 (csky_insn.e1.X_add_number) && reg < 8)
7026 {
7027 /* movi16 instead. */
7028 csky_insn.output = frag_more (2);
7029 csky_insn.inst = (CSKYV2_INST_MOVI16 | (reg << 8)
7030 | (csky_insn.e1.X_add_number));
7031 csky_insn.isize = 2;
7032 is_done = 1;
7033 }
7034 else if (SIZE_V2_MOVI32 (csky_insn.e1.X_add_number)
7035 && !IS_CSKY_ARCH_801 (mach_flag))
7036 {
7037 /* movi32 instead. */
7038 csky_insn.output = frag_more (4);
7039 csky_insn.inst = (CSKYV2_INST_MOVI32 | (reg << 16)
7040 | (csky_insn.e1.X_add_number));
7041 csky_insn.isize = 4;
7042 is_done = 1;
7043 }
7044 else if (SIZE_V2_MOVIH (csky_insn.e1.X_add_number)
7045 && !IS_CSKY_ARCH_801 (mach_flag))
7046 {
7047 /* movih instead. */
7048 csky_insn.output = frag_more (4);
7049 csky_insn.inst = (CSKYV2_INST_MOVIH | (reg << 16)
7050 | ((csky_insn.e1.X_add_number >> 16) & 0xffff));
7051 csky_insn.isize = 4;
7052 is_done = 1;
7053 }
7054 }
7055
7056 if (is_done)
7057 {
7058 csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
7059 return true;
7060 }
7061
7062 if (output_literal)
7063 {
7064 struct literal *p = enter_literal (&csky_insn.e1, 0, 0, 0);
7065 /* Create a reference to pool entry. */
7066 csky_insn.e1.X_op = O_symbol;
7067 csky_insn.e1.X_add_symbol = poolsym;
7068 csky_insn.e1.X_add_number = p->offset << 2;
7069 }
7070 /* If 16bit force. */
7071 if (csky_insn.flag_force == INSN_OPCODE16F)
7072 {
7073 /* Generate fixup. */
7074 if (reg > 7)
7075 {
7076 csky_show_error (ERROR_UNDEFINE, 0,
7077 (void *)"The register is out of range.", NULL);
7078 return false;
7079 }
7080 csky_insn.isize = 2;
7081 csky_insn.output = frag_more (2);
7082
7083 if (insn_reloc == BFD_RELOC_CKCORE_TLS_GD32
7084 || insn_reloc == BFD_RELOC_CKCORE_TLS_LDM32
7085 || insn_reloc == BFD_RELOC_CKCORE_TLS_IE32)
7086 {
7087 literal_insn_offset->tls_addend.frag = frag_now;
7088 literal_insn_offset->tls_addend.offset
7089 = csky_insn.output - frag_now->fr_literal;
7090 }
7091 csky_insn.inst = csky_insn.opcode->op16[0].opcode | (reg << 5);
7092 csky_insn.max = 4;
7093 fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
7094 2, &csky_insn.e1, 1, BFD_RELOC_CKCORE_PCREL_IMM7BY4);
7095 }
7096 else if (csky_insn.flag_force == INSN_OPCODE32F)
7097 {
7098 csky_insn.isize = 4;
7099 csky_insn.output = frag_more (4);
7100 if (insn_reloc == BFD_RELOC_CKCORE_TLS_GD32
7101 || insn_reloc == BFD_RELOC_CKCORE_TLS_LDM32
7102 || insn_reloc == BFD_RELOC_CKCORE_TLS_IE32)
7103 {
7104 literal_insn_offset->tls_addend.frag = frag_now;
7105 literal_insn_offset->tls_addend.offset
7106 = csky_insn.output - frag_now->fr_literal;
7107 }
7108 csky_insn.inst = csky_insn.opcode->op32[0].opcode | (reg << 16);
7109 fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
7110 4, &csky_insn.e1, 1, BFD_RELOC_CKCORE_PCREL_IMM16BY4);
7111 }
7112 else if (!is_done)
7113 {
7114 if (reg < 8)
7115 {
7116 csky_insn.isize = 2;
7117
7118 if (insn_reloc == BFD_RELOC_CKCORE_TLS_GD32
7119 || insn_reloc == BFD_RELOC_CKCORE_TLS_LDM32
7120 || insn_reloc == BFD_RELOC_CKCORE_TLS_IE32)
7121 literal_insn_offset->tls_addend.frag = frag_now;
7122
7123 csky_insn.output = frag_var (rs_machine_dependent,
7124 LRW_DISP16_LEN,
7125 LRW_DISP7_LEN,
7126 (do_extend_lrw
7127 ? LRW2_DISP8 : LRW_DISP7),
7128 csky_insn.e1.X_add_symbol,
7129 csky_insn.e1.X_add_number, 0);
7130 if (insn_reloc == BFD_RELOC_CKCORE_TLS_GD32
7131 || insn_reloc == BFD_RELOC_CKCORE_TLS_LDM32
7132 || insn_reloc == BFD_RELOC_CKCORE_TLS_IE32)
7133 {
7134 if (literal_insn_offset->tls_addend.frag->fr_next != frag_now)
7135 literal_insn_offset->tls_addend.frag
7136 = literal_insn_offset->tls_addend.frag->fr_next;
7137 literal_insn_offset->tls_addend.offset
7138 = (csky_insn.output
7139 - literal_insn_offset->tls_addend.frag->fr_literal);
7140 }
7141 csky_insn.inst = csky_insn.opcode->op16[0].opcode | (reg << 5);
7142 csky_insn.max = LRW_DISP16_LEN;
7143 csky_insn.isize = 2;
7144 }
7145 else
7146 {
7147 csky_insn.isize = 4;
7148 csky_insn.output = frag_more (4);
7149 if (insn_reloc == BFD_RELOC_CKCORE_TLS_GD32
7150 || insn_reloc == BFD_RELOC_CKCORE_TLS_LDM32
7151 || insn_reloc == BFD_RELOC_CKCORE_TLS_IE32)
7152 {
7153 literal_insn_offset->tls_addend.frag = frag_now;
7154 literal_insn_offset->tls_addend.offset
7155 = csky_insn.output - frag_now->fr_literal;
7156 }
7157 csky_insn.inst = csky_insn.opcode->op32[0].opcode | (reg << 16);
7158 fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
7159 4, &csky_insn.e1, 1, BFD_RELOC_CKCORE_PCREL_IMM16BY4);
7160 }
7161 }
7162
7163 csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
7164 return true;
7165 }
7166
7167 bool
7168 v2_work_lrsrsw (void)
7169 {
7170 int reg = csky_insn.val[0];
7171 csky_insn.output = frag_more (4);
7172 csky_insn.inst = csky_insn.opcode->op32[0].opcode | (reg << 21);
7173 csky_insn.isize = 4;
7174
7175 switch (insn_reloc)
7176 {
7177 case BFD_RELOC_CKCORE_GOT32:
7178 fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
7179 4, &csky_insn.e1, 0, BFD_RELOC_CKCORE_GOT_IMM18BY4);
7180 break;
7181 case BFD_RELOC_CKCORE_PLT32:
7182 fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
7183 4, &csky_insn.e1, 0, BFD_RELOC_CKCORE_PLT_IMM18BY4);
7184 break;
7185 default:
7186 fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
7187 4, &csky_insn.e1, 1, BFD_RELOC_CKCORE_DOFFSET_IMM18BY4);
7188 break;
7189 }
7190 csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
7191 return true;
7192 }
7193
7194 bool
7195 v2_work_jbsr (void)
7196 {
7197 if (do_force2bsr
7198 || IS_CSKY_ARCH_801 (mach_flag)
7199 || IS_CSKY_ARCH_802 (mach_flag))
7200 {
7201 csky_insn.output = frag_more (4);
7202 fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
7203 4, &csky_insn.e1, 1, BFD_RELOC_CKCORE_PCREL_IMM26BY2);
7204 csky_insn.isize = 4;
7205 csky_insn.inst = CSKYV2_INST_BSR32;
7206 }
7207 else
7208 {
7209 struct literal *p = enter_literal (&csky_insn.e1, 0, 0, 0);
7210 csky_insn.output = frag_more (4);
7211 csky_insn.e1.X_op = O_symbol;
7212 csky_insn.e1.X_add_symbol = poolsym;
7213 csky_insn.e1.X_add_number = p->offset << 2;
7214 fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
7215 4, &csky_insn.e1, 1, BFD_RELOC_CKCORE_PCREL_IMM16BY4);
7216 if (do_jsri2bsr || IS_CSKY_ARCH_810 (mach_flag))
7217 fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
7218 4,
7219 &(litpool + (csky_insn.e1.X_add_number >> 2))->e,
7220 1,
7221 BFD_RELOC_CKCORE_PCREL_JSR_IMM26BY2);
7222 csky_insn.inst = CSKYV2_INST_JSRI32;
7223 csky_insn.isize = 4;
7224 if (IS_CSKY_ARCH_810 (mach_flag))
7225 {
7226 csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
7227 csky_insn.output = frag_more (4);
7228 dwarf2_emit_insn (0);
7229 /* Insert "mov r0, r0". */
7230 csky_insn.inst = CSKYV2_INST_MOV_R0_R0;
7231 csky_insn.max = 8;
7232 }
7233 }
7234 csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
7235
7236 return true;
7237 }
7238
7239 bool
7240 v2_work_jsri (void)
7241 {
7242 /* dump literal. */
7243 struct literal *p = enter_literal (&csky_insn.e1, 1, 0, 0);
7244 csky_insn.e1.X_op = O_symbol;
7245 csky_insn.e1.X_add_symbol = poolsym;
7246 csky_insn.e1.X_add_number = p->offset << 2;
7247
7248 /* Generate relax or reloc if necessary. */
7249 csky_generate_frags ();
7250 /* Generate the insn by mask. */
7251 csky_generate_insn ();
7252 /* Write inst to frag. */
7253 csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
7254 /* Control 810 not to generate jsri. */
7255 if (IS_CSKY_ARCH_810 (mach_flag))
7256 {
7257 /* Look at adding the R_PCREL_JSRIMM26BY2.
7258 For 'jbsr .L1', this reloc type's symbol
7259 is bound to '.L1', isn't bound to literal pool. */
7260 fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
7261 4, &p->e, 1,
7262 BFD_RELOC_CKCORE_PCREL_JSR_IMM26BY2);
7263 csky_insn.output = frag_more (4);
7264 dwarf2_emit_insn (0);
7265 /* The opcode of "mov32 r0,r0". */
7266 csky_insn.inst = CSKYV2_INST_MOV_R0_R0;
7267 /* The effect of this value is to check literal. */
7268 csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
7269 csky_insn.max = 8;
7270 }
7271 return true;
7272 }
7273
7274 bool
7275 v2_work_movih (void)
7276 {
7277 int rz = csky_insn.val[0];
7278 csky_insn.output = frag_more (4);
7279 csky_insn.inst = csky_insn.opcode->op32[0].opcode | (rz << 16);
7280 if (csky_insn.e1.X_op == O_constant)
7281 {
7282 if (csky_insn.e1.X_unsigned == 1 && csky_insn.e1.X_add_number > 0xffff)
7283 {
7284 csky_show_error (ERROR_IMM_OVERFLOW, 2, NULL, NULL);
7285 return false;
7286 }
7287 else if (csky_insn.e1.X_unsigned == 0 && csky_insn.e1.X_add_number < 0)
7288 {
7289 csky_show_error (ERROR_IMM_OVERFLOW, 2, NULL, NULL);
7290 return false;
7291 }
7292 else
7293 csky_insn.inst |= (csky_insn.e1.X_add_number & 0xffff);
7294 }
7295 else if (csky_insn.e1.X_op == O_right_shift
7296 || (csky_insn.e1.X_op == O_symbol && insn_reloc != BFD_RELOC_NONE))
7297 {
7298 if (csky_insn.e1.X_op_symbol != 0
7299 && symbol_constant_p (csky_insn.e1.X_op_symbol)
7300 && S_GET_SEGMENT (csky_insn.e1.X_op_symbol) == absolute_section
7301 && 16 == S_GET_VALUE (csky_insn.e1.X_op_symbol))
7302 {
7303 csky_insn.e1.X_op = O_symbol;
7304 if (insn_reloc == BFD_RELOC_CKCORE_GOT32)
7305 insn_reloc = BFD_RELOC_CKCORE_GOT_HI16;
7306 else if (insn_reloc == BFD_RELOC_CKCORE_PLT32)
7307 insn_reloc = BFD_RELOC_CKCORE_PLT_HI16;
7308 else if (insn_reloc == BFD_RELOC_CKCORE_GOTPC)
7309 insn_reloc = BFD_RELOC_CKCORE_GOTPC_HI16;
7310 else if (insn_reloc == BFD_RELOC_CKCORE_GOTOFF)
7311 insn_reloc = BFD_RELOC_CKCORE_GOTOFF_HI16;
7312 else
7313 insn_reloc = BFD_RELOC_CKCORE_ADDR_HI16;
7314 fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
7315 4, &csky_insn.e1, 0, insn_reloc);
7316 }
7317 else
7318 {
7319 void *arg = (void *)"the second operand must be \"SYMBOL >> 16\"";
7320 csky_show_error (ERROR_UNDEFINE, 0, arg, NULL);
7321 return false;
7322 }
7323 }
7324 csky_insn.isize = 4;
7325 csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
7326
7327 return true;
7328 }
7329
7330 bool
7331 v2_work_ori (void)
7332 {
7333 int rz = csky_insn.val[0];
7334 int rx = csky_insn.val[1];
7335 csky_insn.output = frag_more (4);
7336 csky_insn.inst = csky_insn.opcode->op32[0].opcode | (rz << 21) | (rx << 16);
7337 if (csky_insn.e1.X_op == O_constant)
7338 {
7339 if (csky_insn.e1.X_add_number <= 0xffff
7340 && csky_insn.e1.X_add_number >= 0)
7341 csky_insn.inst |= csky_insn.e1.X_add_number;
7342 else
7343 {
7344 csky_show_error (ERROR_IMM_OVERFLOW, 3, NULL, NULL);
7345 return false;
7346 }
7347 }
7348 else if (csky_insn.e1.X_op == O_bit_and)
7349 {
7350 if (symbol_constant_p (csky_insn.e1.X_op_symbol)
7351 && S_GET_SEGMENT (csky_insn.e1.X_op_symbol) == absolute_section
7352 && 0xffff == S_GET_VALUE (csky_insn.e1.X_op_symbol))
7353 {
7354 csky_insn.e1.X_op = O_symbol;
7355 if (insn_reloc == BFD_RELOC_CKCORE_GOT32)
7356 insn_reloc = BFD_RELOC_CKCORE_GOT_LO16;
7357 else if (insn_reloc == BFD_RELOC_CKCORE_PLT32)
7358 insn_reloc = BFD_RELOC_CKCORE_PLT_LO16;
7359 else if (insn_reloc == BFD_RELOC_CKCORE_GOTPC)
7360 insn_reloc = BFD_RELOC_CKCORE_GOTPC_LO16;
7361 else if (insn_reloc == BFD_RELOC_CKCORE_GOTOFF)
7362 insn_reloc = BFD_RELOC_CKCORE_GOTOFF_LO16;
7363 else
7364 insn_reloc = BFD_RELOC_CKCORE_ADDR_LO16;
7365 fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
7366 4, &csky_insn.e1, 0, insn_reloc);
7367 }
7368 else
7369 {
7370 void *arg = (void *)"the third operand must be \"SYMBOL & 0xffff\"";
7371 csky_show_error (ERROR_UNDEFINE, 0, arg, NULL);
7372 return false;
7373 }
7374 }
7375 csky_insn.isize = 4;
7376 csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
7377 return true;
7378 }
7379
7380 /* Helper function to encode a single/double floating point constant
7381 into the instruction word for fmovis and fmovid instructions.
7382 The constant is in its IEEE single/double precision representation
7383 and is repacked into the internal 13-bit representation for these
7384 instructions with a diagnostic for overflow. Note that there is no
7385 rounding when converting to the smaller format, just an error if there
7386 is excess precision or the number is too small/large to be represented. */
7387
7388 bool
7389 float_work_fmovi (void)
7390 {
7391 int rx = csky_insn.val[0];
7392
7393 /* We already converted the float constant to the internal 13-bit
7394 representation so we just need to OR it in here. */
7395 csky_insn.inst = csky_insn.opcode->op32[0].opcode | rx;
7396 csky_insn.inst |= (uint32_t) csky_insn.e1.X_add_number;
7397
7398 csky_insn.output = frag_more (4);
7399 csky_insn.isize = 4;
7400 csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
7401 return true;
7402 }
7403
7404 /* Like float_work_fmovi, but for FPUV3 fmovi.16, fmovi.32 and fmovi.64
7405 instructions. */
7406
7407 bool
7408 float_work_fpuv3_fmovi (void)
7409 {
7410 int rx = csky_insn.val[0];
7411 int idx = csky_insn.opcode_idx;
7412 int imm4 = 0;
7413 int imm8 = 0;
7414 int sign = 0;
7415
7416 csky_insn.inst = csky_insn.opcode->op32[idx].opcode | rx;
7417
7418 if (csky_insn.opcode->op32[idx].operand_num == 3)
7419 {
7420 /* fmovi.xx frz, imm9, imm4. */
7421 imm8 = csky_insn.val[1];
7422 imm4 = csky_insn.val[2];
7423 if (imm8 < 0 || (imm8 & 0x80000000))
7424 {
7425 sign = (1 << 5);
7426 imm8 = 0 - imm8;
7427 }
7428
7429 if (imm8 > 255)
7430 {
7431 csky_show_error (ERROR_IMM_OVERFLOW, 2, NULL, NULL);
7432 return false;
7433 }
7434
7435 /* imm8 store at bit [25:20] and [9:8]. */
7436 /* imm4 store at bit [19:16]. */
7437 /* sign store at bit [5]. */
7438 csky_insn.inst = csky_insn.inst
7439 | ((imm8 & 0x3) << 8)
7440 | ((imm8 & 0xfc) << 18)
7441 | ((imm4 & 0xf) << 16)
7442 | sign;
7443 }
7444 else
7445 {
7446 csky_insn.inst |= (uint32_t) csky_insn.e1.X_add_number;
7447 }
7448
7449 csky_insn.output = frag_more(4);
7450 csky_insn.isize = 4;
7451 csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
7452 return true;
7453 }
7454
7455 bool
7456 dsp_work_bloop (void)
7457 {
7458 int reg = csky_insn.val[0];
7459 csky_insn.output = frag_more (4);
7460 csky_insn.inst = csky_insn.opcode->op32[0].opcode | (reg << 16);
7461 csky_insn.isize = 4;
7462
7463 if (csky_insn.number == 3
7464 && csky_insn.e1.X_op == O_symbol
7465 && csky_insn.e2.X_op == O_symbol)
7466 {
7467 fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
7468 4, &csky_insn.e1, 1,
7469 BFD_RELOC_CKCORE_PCREL_BLOOP_IMM12BY4);
7470 fix_new_exp (frag_now, csky_insn.output - frag_now->fr_literal,
7471 4, &csky_insn.e2, 1,
7472 BFD_RELOC_CKCORE_PCREL_BLOOP_IMM4BY4);
7473 }
7474 else if (csky_insn.number == 2
7475 && csky_insn.e1.X_op == O_symbol)
7476 {
7477 fix_new_exp (frag_now, csky_insn.output-frag_now->fr_literal,
7478 4, &csky_insn.e1, 1,
7479 BFD_RELOC_CKCORE_PCREL_BLOOP_IMM12BY4);
7480 if (csky_insn.last_isize == 2)
7481 csky_insn.inst |= (0xf << 12);
7482 else if (csky_insn.last_isize != 0)
7483 csky_insn.inst |= (0xe << 12);
7484 else
7485 {
7486 void *arg = (void *)"bloop can not be the first instruction"\
7487 "when the end label is not specified.\n";
7488 csky_show_error (ERROR_UNDEFINE, 0, arg, NULL);
7489 }
7490 }
7491
7492 csky_write_insn (csky_insn.output, csky_insn.inst, csky_insn.isize);
7493 return true;
7494 }
7495
7496 bool
7497 float_work_fpuv3_fstore(void)
7498 {
7499 /* Generate relax or reloc if necessary. */
7500 csky_generate_frags ();
7501 /* Generate the insn by mask. */
7502 csky_generate_insn ();
7503 /* Write inst to frag. */
7504 csky_write_insn (csky_insn.output,
7505 csky_insn.inst,
7506 csky_insn.isize);
7507
7508
7509 return true;
7510 }
7511
7512 bool
7513 v2_work_addc (void)
7514 {
7515 int reg1;
7516 int reg2;
7517 int reg3 = 0;
7518 int is_16_bit = 0;
7519
7520 reg1 = csky_insn.val[0];
7521 reg2 = csky_insn.val[1];
7522 if (csky_insn.number == 2)
7523 {
7524 if (reg1 > 15 || reg2 > 15)
7525 {
7526 is_16_bit = 0;
7527 reg3 = reg1;
7528 }
7529 else
7530 is_16_bit = 1;
7531 }
7532 else
7533 {
7534 reg3 = csky_insn.val[2];
7535 if (reg1 > 15 || reg2 > 15 || reg3 > 15)
7536 is_16_bit = 0;
7537 else if (reg1 == reg2 || reg1 == reg3)
7538 {
7539 is_16_bit = 1;
7540 reg2 = (reg1 == reg2) ? reg3 : reg2;
7541 }
7542 else
7543 is_16_bit = 0;
7544 }
7545
7546 if (is_16_bit
7547 && csky_insn.flag_force != INSN_OPCODE32F)
7548 {
7549 csky_insn.isize = 2;
7550 csky_insn.inst = csky_insn.opcode->op16[0].opcode
7551 | (reg1 << 6) | (reg2 << 2);
7552 }
7553 else if (csky_insn.flag_force != INSN_OPCODE16F)
7554 {
7555 csky_insn.isize = 4;
7556 csky_insn.inst = csky_insn.opcode->op32[0].opcode
7557 | (reg1 << 0) | (reg2 << 16) | (reg3 << 21);
7558 }
7559 else
7560 {
7561 SET_ERROR_INTEGER (ERROR_REG_OVER_RANGE, reg1 > 15 ? reg1 : reg2);
7562 csky_show_error (ERROR_REG_OVER_RANGE, 0, 0, NULL);
7563 }
7564
7565 /* Generate relax or reloc if necessary. */
7566 csky_generate_frags ();
7567 /* Write inst to frag. */
7568 csky_write_insn (csky_insn.output,
7569 csky_insn.inst,
7570 csky_insn.isize);
7571
7572 return true;
7573 }
7574
7575 /* The following are for assembler directive handling. */
7576
7577 /* Helper function to adjust constant pool counts when we emit a
7578 data directive in the text section. FUNC is one of the standard
7579 gas functions to handle these directives, like "stringer" for the
7580 .string directive, and ARG is the argument to FUNC. csky_pool_count
7581 essentially wraps the call with the constant pool magic. */
7582
7583 static void
7584 csky_pool_count (void (*func) (int), int arg)
7585 {
7586 const fragS *curr_frag = frag_now;
7587 offsetT added = -frag_now_fix_octets ();
7588
7589 (*func) (arg);
7590
7591 while (curr_frag != frag_now)
7592 {
7593 added += curr_frag->fr_fix;
7594 curr_frag = curr_frag->fr_next;
7595 }
7596
7597 added += frag_now_fix_octets ();
7598 poolspan += added;
7599 }
7600
7601 /* Support the .literals directive. */
7602 static void
7603 csky_s_literals (int ignore ATTRIBUTE_UNUSED)
7604 {
7605 dump_literals (0);
7606 demand_empty_rest_of_line ();
7607 }
7608
7609 /* Support the .string, etc directives. */
7610 static void
7611 csky_stringer (int append_zero)
7612 {
7613 if (now_seg == text_section)
7614 csky_pool_count (stringer, append_zero);
7615 else
7616 stringer (append_zero);
7617
7618 /* We call check_literals here in case a large number of strings are
7619 being placed into the text section with a sequence of stringer
7620 directives. In theory we could be upsetting something if these
7621 strings are actually in an indexed table instead of referenced by
7622 individual labels. Let us hope that that never happens. */
7623 check_literals (2, 0);
7624 }
7625
7626 /* Support integer-mode constructors like .word, .byte, etc. */
7627
7628 static void
7629 csky_cons (int nbytes)
7630 {
7631 mapping_state (MAP_DATA);
7632 if (nbytes == 4) /* @GOT. */
7633 {
7634 do
7635 {
7636 bfd_reloc_code_real_type reloc;
7637 expressionS exp;
7638
7639 reloc = BFD_RELOC_NONE;
7640 expression (&exp);
7641 lex_got (&reloc, NULL);
7642
7643 if (exp.X_op == O_symbol && reloc != BFD_RELOC_NONE)
7644 {
7645 reloc_howto_type *howto
7646 = bfd_reloc_type_lookup (stdoutput, reloc);
7647 int size = bfd_get_reloc_size (howto);
7648
7649 if (size > nbytes)
7650 as_bad (ngettext ("%s relocations do not fit in %d byte",
7651 "%s relocations do not fit in %d bytes",
7652 nbytes),
7653 howto->name, nbytes);
7654 else
7655 {
7656 register char *p = frag_more ((int) nbytes);
7657 int offset = nbytes - size;
7658
7659 fix_new_exp (frag_now,
7660 p - frag_now->fr_literal + offset,
7661 size, &exp, 0, reloc);
7662 }
7663 }
7664 else
7665 emit_expr (&exp, (unsigned int) nbytes);
7666 if (now_seg == text_section)
7667 poolspan += nbytes;
7668 }
7669 while (*input_line_pointer++ == ',');
7670
7671 /* Put terminator back into stream. */
7672 input_line_pointer --;
7673 demand_empty_rest_of_line ();
7674
7675 return;
7676 }
7677
7678 if (now_seg == text_section)
7679 csky_pool_count (cons, nbytes);
7680 else
7681 cons (nbytes);
7682
7683 /* In theory we ought to call check_literals (2,0) here in case
7684 we need to dump the literal table. We cannot do this however,
7685 as the directives that we are intercepting may be being used
7686 to build a switch table, and we must not interfere with its
7687 contents. Instead we cross our fingers and pray... */
7688 }
7689
7690 /* Support floating-mode constant directives like .float and .double. */
7691
7692 static void
7693 csky_float_cons (int float_type)
7694 {
7695 mapping_state (MAP_DATA);
7696 if (now_seg == text_section)
7697 csky_pool_count (float_cons, float_type);
7698 else
7699 float_cons (float_type);
7700
7701 /* See the comment in csky_cons () about calling check_literals.
7702 It is unlikely that a switch table will be constructed using
7703 floating point values, but it is still likely that an indexed
7704 table of floating point constants is being created by these
7705 directives, so again we must not interfere with their placement. */
7706 }
7707
7708 /* Support the .fill directive. */
7709
7710 static void
7711 csky_fill (int ignore)
7712 {
7713 if (now_seg == text_section)
7714 csky_pool_count (s_fill, ignore);
7715 else
7716 s_fill (ignore);
7717
7718 check_literals (2, 0);
7719 }
7720
7721 /* Handle the section changing pseudo-ops. These call through to the
7722 normal implementations, but they dump the literal pool first. */
7723
7724 static void
7725 csky_s_text (int ignore)
7726 {
7727 dump_literals (0);
7728
7729 #ifdef OBJ_ELF
7730 obj_elf_text (ignore);
7731 #else
7732 s_text (ignore);
7733 #endif
7734 }
7735
7736 static void
7737 csky_s_data (int ignore)
7738 {
7739 dump_literals (0);
7740
7741 #ifdef OBJ_ELF
7742 obj_elf_data (ignore);
7743 #else
7744 s_data (ignore);
7745 #endif
7746 }
7747
7748 static void
7749 csky_s_section (int ignore)
7750 {
7751 /* Scan forwards to find the name of the section. If the section
7752 being switched to is ".line" then this is a DWARF1 debug section
7753 which is arbitrarily placed inside generated code. In this case
7754 do not dump the literal pool because it is a) inefficient and
7755 b) would require the generation of extra code to jump around the
7756 pool. */
7757 char * ilp = input_line_pointer;
7758
7759 while (*ilp != 0 && ISSPACE (*ilp))
7760 ++ ilp;
7761
7762 if (startswith (ilp, ".line")
7763 && (ISSPACE (ilp[5]) || *ilp == '\n' || *ilp == '\r'))
7764 ;
7765 else
7766 dump_literals (0);
7767
7768 #ifdef OBJ_ELF
7769 obj_elf_section (ignore);
7770 #endif
7771 #ifdef OBJ_COFF
7772 obj_coff_section (ignore);
7773 #endif
7774 }
7775
7776 static void
7777 csky_s_bss (int needs_align)
7778 {
7779 dump_literals (0);
7780 s_lcomm_bytes (needs_align);
7781 }
7782
7783 #ifdef OBJ_ELF
7784 static void
7785 csky_s_comm (int needs_align)
7786 {
7787 dump_literals (0);
7788 obj_elf_common (needs_align);
7789 }
7790 #endif
7791
7792 /* Handle the .no_literal_dump directive. */
7793
7794 static void
7795 csky_noliteraldump (int ignore ATTRIBUTE_UNUSED)
7796 {
7797 do_noliteraldump = 1;
7798 int insn_num = get_absolute_expression ();
7799 /* The insn after '.no_literal_dump insn_num' is insn1,
7800 Don't dump literal pool between insn1 and insn(insn_num+1)
7801 The insn cannot be the insn generate literal, like lrw & jsri. */
7802 check_literals (0, insn_num * 2);
7803 }
7804
7805 /* Handle the .align directive.
7806 We must check literals before doing alignment. For example, if
7807 '.align n', add (2^n-1) to poolspan and check literals. */
7808
7809 static void
7810 csky_s_align_ptwo (int arg)
7811 {
7812 /* Get the .align's first absolute number. */
7813 char * temp_pointer = input_line_pointer;
7814 int align = get_absolute_expression ();
7815 check_literals (0, (1 << align) - 1);
7816 input_line_pointer = temp_pointer;
7817
7818 /* Do alignment. */
7819 s_align_ptwo (arg);
7820 }
7821
7822 /* Handle the .stack_size directive. */
7823
7824 static void
7825 csky_stack_size (int arg ATTRIBUTE_UNUSED)
7826 {
7827 expressionS exp;
7828 stack_size_entry *sse
7829 = (stack_size_entry *) xcalloc (1, sizeof (stack_size_entry));
7830
7831 expression (&exp);
7832 if (exp.X_op == O_symbol)
7833 sse->function = exp.X_add_symbol;
7834 else
7835 {
7836 as_bad (_("the first operand must be a symbol"));
7837 ignore_rest_of_line ();
7838 free (sse);
7839 return;
7840 }
7841
7842 SKIP_WHITESPACE ();
7843 if (*input_line_pointer != ',')
7844 {
7845 as_bad (_("missing stack size"));
7846 ignore_rest_of_line ();
7847 free (sse);
7848 return;
7849 }
7850
7851 ++input_line_pointer;
7852 expression (&exp);
7853 if (exp.X_op == O_constant)
7854 {
7855 if (exp.X_add_number < 0 || exp.X_add_number > (offsetT)0xffffffff)
7856 {
7857
7858 as_bad (_("value not in range [0, 0xffffffff]"));
7859 ignore_rest_of_line ();
7860 free (sse);
7861 return;
7862 }
7863 else
7864 sse->stack_size = exp.X_add_number;
7865 }
7866 else
7867 {
7868 as_bad (_("operand must be a constant"));
7869 ignore_rest_of_line ();
7870 free (sse);
7871 return;
7872 }
7873
7874 if (*last_stack_size_data != NULL)
7875 last_stack_size_data = &((*last_stack_size_data)->next);
7876
7877 *last_stack_size_data = sse;
7878 }
7879
7880 /* This table describes all the machine specific pseudo-ops the assembler
7881 has to support. The fields are:
7882 pseudo-op name without dot
7883 function to call to execute this pseudo-op
7884 Integer arg to pass to the function. */
7885
7886 const pseudo_typeS md_pseudo_table[] =
7887 {
7888 { "export", s_globl, 0 },
7889 { "import", s_ignore, 0 },
7890 { "literals", csky_s_literals, 0 },
7891 { "page", listing_eject, 0 },
7892
7893 /* The following are to intercept the placement of data into the text
7894 section (eg addresses for a switch table), so that the space they
7895 occupy can be taken into account when deciding whether or not to
7896 dump the current literal pool.
7897 XXX - currently we do not cope with the .space and .dcb.d directives. */
7898 { "ascii", csky_stringer, 8 + 0 },
7899 { "asciz", csky_stringer, 8 + 1 },
7900 { "byte", csky_cons, 1 },
7901 { "dc", csky_cons, 2 },
7902 { "dc.b", csky_cons, 1 },
7903 { "dc.d", csky_float_cons, 'd'},
7904 { "dc.l", csky_cons, 4 },
7905 { "dc.s", csky_float_cons, 'f'},
7906 { "dc.w", csky_cons, 2 },
7907 { "dc.x", csky_float_cons, 'x'},
7908 { "double", csky_float_cons, 'd'},
7909 { "float", csky_float_cons, 'f'},
7910 { "hword", csky_cons, 2 },
7911 { "int", csky_cons, 4 },
7912 { "long", csky_cons, 4 },
7913 { "octa", csky_cons, 16 },
7914 { "quad", csky_cons, 8 },
7915 { "short", csky_cons, 2 },
7916 { "single", csky_float_cons, 'f'},
7917 { "string", csky_stringer, 8 + 1 },
7918 { "word", csky_cons, 4 },
7919 { "fill", csky_fill, 0 },
7920
7921 /* Allow for the effect of section changes. */
7922 { "text", csky_s_text, 0 },
7923 { "data", csky_s_data, 0 },
7924 { "bss", csky_s_bss, 1 },
7925 #ifdef OBJ_ELF
7926 { "comm", csky_s_comm, 0 },
7927 #endif
7928 { "section", csky_s_section, 0 },
7929 { "section.s", csky_s_section, 0 },
7930 { "sect", csky_s_section, 0 },
7931 { "sect.s", csky_s_section, 0 },
7932 /* When ".no_literal_dump N" is in front of insn1,
7933 and instruction sequence is:
7934 insn1
7935 insn2
7936 ......
7937 insnN+1
7938 it means literals will not dump between insn1 and insnN+1
7939 The insn cannot itself generate literal, like lrw & jsri. */
7940 { "no_literal_dump", csky_noliteraldump, 0 },
7941 { "align", csky_s_align_ptwo, 0 },
7942 { "stack_size", csky_stack_size, 0 },
7943 {0, 0, 0}
7944 };
7945
7946 /* Implement tc_cfi_frame_initial_instructions. */
7947
7948 void
7949 csky_cfi_frame_initial_instructions (void)
7950 {
7951 int sp_reg = IS_CSKY_V1 (mach_flag) ? 0 : 14;
7952 cfi_add_CFA_def_cfa_register (sp_reg);
7953 }
7954
7955 /* Implement tc_regname_to_dw2regnum. */
7956
7957 int
7958 tc_csky_regname_to_dw2regnum (char *regname)
7959 {
7960 int reg_num = -1;
7961 int len;
7962
7963 /* FIXME the reg should be parsed according to
7964 the abi version. */
7965 reg_num = csky_get_reg_val (regname, &len);
7966 return reg_num;
7967 }
A mirror of the official binutils-gdb repository