?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* Makefile.tpl: Use "-exec rm {}" rather than "-delete" to delete
[binutils/dougsmingw.git] / gas / config / tc-score7.c
blob9edd699d4d6ec029e6c770ca2a16d649b3faf221
1 /* tc-score7.c -- Assembler for Score7
2 Copyright 2009 Free Software Foundation, Inc.
3 Contributed by:
4 Brain.lin (brain.lin@sunplusct.com)
5 Mei Ligang (ligang@sunnorth.com.cn)
6 Pei-Lin Tsai (pltsai@sunplus.com)
7
8 This file is part of GAS, the GNU Assembler.
9
10 GAS is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
13 any later version.
14
15 GAS is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with GAS; see the file COPYING. If not, write to the Free
22 Software Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
23 MA 02110-1301, USA. */
24
25 #include "as.h"
26 #include "config.h"
27 #include "subsegs.h"
28 #include "safe-ctype.h"
29 #include "opcode/score-inst.h"
30 #include "struc-symbol.h"
31 #include "libiberty.h"
32
33 #ifdef OBJ_ELF
34 #include "elf/score.h"
35 #include "dwarf2dbg.h"
36 #endif
37
38 static void s7_do_ldst_insn (char *);
39 static void s7_do_crdcrscrsimm5 (char *);
40 static void s7_do_ldst_unalign (char *);
41 static void s7_do_ldst_atomic (char *);
42 static void s7_do_ldst_cop (char *);
43 static void s7_do_macro_li_rdi32 (char *);
44 static void s7_do_macro_la_rdi32 (char *);
45 static void s7_do_macro_rdi32hi (char *);
46 static void s7_do_macro_rdi32lo (char *);
47 static void s7_do_macro_mul_rdrsrs (char *);
48 static void s7_do_macro_ldst_label (char *);
49 static void s7_do_branch (char *);
50 static void s7_do_jump (char *);
51 static void s7_do_empty (char *);
52 static void s7_do_rdrsrs (char *);
53 static void s7_do_rdsi16 (char *);
54 static void s7_do_rdrssi14 (char *);
55 static void s7_do_sub_rdsi16 (char *);
56 static void s7_do_sub_rdrssi14 (char *);
57 static void s7_do_rdrsi5 (char *);
58 static void s7_do_rdrsi14 (char *);
59 static void s7_do_rdi16 (char *);
60 static void s7_do_xrsi5 (char *);
61 static void s7_do_rdrs (char *);
62 static void s7_do_rdxrs (char *);
63 static void s7_do_rsrs (char *);
64 static void s7_do_rdcrs (char *);
65 static void s7_do_rdsrs (char *);
66 static void s7_do_rd (char *);
67 static void s7_do_rs (char *);
68 static void s7_do_i15 (char *);
69 static void s7_do_xi5x (char *);
70 static void s7_do_ceinst (char *);
71 static void s7_do_cache (char *);
72 static void s7_do16_rdrs (char *);
73 static void s7_do16_rs (char *);
74 static void s7_do16_xrs (char *);
75 static void s7_do16_mv_rdrs (char *);
76 static void s7_do16_hrdrs (char *);
77 static void s7_do16_rdhrs (char *);
78 static void s7_do16_rdi4 (char *);
79 static void s7_do16_rdi5 (char *);
80 static void s7_do16_xi5 (char *);
81 static void s7_do16_ldst_insn (char *);
82 static void s7_do16_ldst_imm_insn (char *);
83 static void s7_do16_push_pop (char *);
84 static void s7_do16_branch (char *);
85 static void s7_do16_jump (char *);
86 static void s7_do_rdi16_pic (char *);
87 static void s7_do_addi_s_pic (char *);
88 static void s7_do_addi_u_pic (char *);
89 static void s7_do_lw_pic (char *);
90
91 #define s7_GP 28
92 #define s7_PIC_CALL_REG 29
93 #define s7_MAX_LITERAL_POOL_SIZE 1024
94 #define s7_FAIL 0x80000000
95 #define s7_SUCCESS 0
96 #define s7_INSN_SIZE 4
97 #define s7_INSN16_SIZE 2
98 #define s7_RELAX_INST_NUM 3
99
100 /* For score5u : div/mul will pop warning message, mmu/alw/asw will pop error message. */
101 #define s7_BAD_ARGS _("bad arguments to instruction")
102 #define s7_ERR_FOR_SCORE5U_MUL_DIV _("div / mul are reserved instructions")
103 #define s7_ERR_FOR_SCORE5U_MMU _("This architecture doesn't support mmu")
104 #define s7_ERR_FOR_SCORE5U_ATOMIC _("This architecture doesn't support atomic instruction")
105 #define s7_BAD_SKIP_COMMA s7_BAD_ARGS
106 #define s7_BAD_GARBAGE _("garbage following instruction");
107
108 #define s7_skip_whitespace(str) while (*(str) == ' ') ++(str)
109
110 /* The name of the readonly data section. */
111 #define s7_RDATA_SECTION_NAME (OUTPUT_FLAVOR == bfd_target_aout_flavour \
112 ? ".data" \
113 : OUTPUT_FLAVOR == bfd_target_ecoff_flavour \
114 ? ".rdata" \
115 : OUTPUT_FLAVOR == bfd_target_coff_flavour \
116 ? ".rdata" \
117 : OUTPUT_FLAVOR == bfd_target_elf_flavour \
118 ? ".rodata" \
119 : (abort (), ""))
120
121 #define s7_RELAX_ENCODE(old, new, type, reloc1, reloc2, opt) \
122 ((relax_substateT) \
123 (((old) << 23) \
124 | ((new) << 16) \
125 | ((type) << 9) \
126 | ((reloc1) << 5) \
127 | ((reloc2) << 1) \
128 | ((opt) ? 1 : 0)))
129
130 #define s7_RELAX_OLD(i) (((i) >> 23) & 0x7f)
131 #define s7_RELAX_NEW(i) (((i) >> 16) & 0x7f)
132 #define s7_RELAX_TYPE(i) (((i) >> 9) & 0x7f)
133 #define s7_RELAX_RELOC1(i) ((valueT) ((i) >> 5) & 0xf)
134 #define s7_RELAX_RELOC2(i) ((valueT) ((i) >> 1) & 0xf)
135 #define s7_RELAX_OPT(i) ((i) & 1)
136 #define s7_RELAX_OPT_CLEAR(i) ((i) & ~1)
137
138 #define s7_SET_INSN_ERROR(s) (s7_inst.error = (s))
139 #define s7_INSN_IS_PCE_P(s) (strstr (str, "||") != NULL)
140
141 #define s7_GET_INSN_CLASS(type) (s7_get_insn_class_from_type (type))
142
143 #define s7_GET_INSN_SIZE(type) ((s7_GET_INSN_CLASS (type) == INSN_CLASS_16) \
144 ? s7_INSN16_SIZE : s7_INSN_SIZE)
145
146 #define s7_MAX_LITTLENUMS 6
147 #define s7_INSN_NAME_LEN 16
148
149 /* Relax will need some padding for alignment. */
150 #define s7_RELAX_PAD_BYTE 3
151
152 #define s7_USE_GLOBAL_POINTER_OPT 1
153
154 \f
155
156 /* Enumeration matching entries in table above. */
157 enum s7_score_reg_type
158 {
159 s7_REG_TYPE_SCORE = 0,
160 #define REG_TYPE_FIRST s7_REG_TYPE_SCORE
161 s7_REG_TYPE_SCORE_SR = 1,
162 s7_REG_TYPE_SCORE_CR = 2,
163 s7_REG_TYPE_MAX = 3
164 };
165
166 enum s7_score_pic_level
167 {
168 s7_NO_PIC,
169 s7_PIC
170 };
171 static enum s7_score_pic_level s7_score_pic = s7_NO_PIC;
172
173 enum s7_insn_type_for_dependency
174 {
175 s7_D_pce,
176 s7_D_cond_br,
177 s7_D_cond_mv,
178 s7_D_cached,
179 s7_D_cachei,
180 s7_D_ldst,
181 s7_D_ldcombine,
182 s7_D_mtcr,
183 s7_D_mfcr,
184 s7_D_mfsr,
185 s7_D_mftlb,
186 s7_D_mtptlb,
187 s7_D_mtrtlb,
188 s7_D_stlb,
189 s7_D_all_insn
190 };
191
192 struct s7_insn_to_dependency
193 {
194 char *insn_name;
195 enum s7_insn_type_for_dependency type;
196 };
197
198 struct s7_data_dependency
199 {
200 enum s7_insn_type_for_dependency pre_insn_type;
201 char pre_reg[6];
202 enum s7_insn_type_for_dependency cur_insn_type;
203 char cur_reg[6];
204 int bubblenum_7;
205 int bubblenum_5;
206 int warn_or_error; /* warning - 0; error - 1 */
207 };
208
209 static const struct s7_insn_to_dependency s7_insn_to_dependency_table[] =
210 {
211 /* pce instruction. */
212 {"pce", s7_D_pce},
213 /* conditional branch instruction. */
214 {"bcs", s7_D_cond_br},
215 {"bcc", s7_D_cond_br},
216 {"bgtu", s7_D_cond_br},
217 {"bleu", s7_D_cond_br},
218 {"beq", s7_D_cond_br},
219 {"bne", s7_D_cond_br},
220 {"bgt", s7_D_cond_br},
221 {"ble", s7_D_cond_br},
222 {"bge", s7_D_cond_br},
223 {"blt", s7_D_cond_br},
224 {"bmi", s7_D_cond_br},
225 {"bpl", s7_D_cond_br},
226 {"bvs", s7_D_cond_br},
227 {"bvc", s7_D_cond_br},
228 {"bcsl", s7_D_cond_br},
229 {"bccl", s7_D_cond_br},
230 {"bgtul", s7_D_cond_br},
231 {"bleul", s7_D_cond_br},
232 {"beql", s7_D_cond_br},
233 {"bnel", s7_D_cond_br},
234 {"bgtl", s7_D_cond_br},
235 {"blel", s7_D_cond_br},
236 {"bgel", s7_D_cond_br},
237 {"bltl", s7_D_cond_br},
238 {"bmil", s7_D_cond_br},
239 {"bpll", s7_D_cond_br},
240 {"bvsl", s7_D_cond_br},
241 {"bvcl", s7_D_cond_br},
242 {"bcs!", s7_D_cond_br},
243 {"bcc!", s7_D_cond_br},
244 {"bgtu!", s7_D_cond_br},
245 {"bleu!", s7_D_cond_br},
246 {"beq!", s7_D_cond_br},
247 {"bne!", s7_D_cond_br},
248 {"bgt!", s7_D_cond_br},
249 {"ble!", s7_D_cond_br},
250 {"bge!", s7_D_cond_br},
251 {"blt!", s7_D_cond_br},
252 {"bmi!", s7_D_cond_br},
253 {"bpl!", s7_D_cond_br},
254 {"bvs!", s7_D_cond_br},
255 {"bvc!", s7_D_cond_br},
256 {"brcs", s7_D_cond_br},
257 {"brcc", s7_D_cond_br},
258 {"brgtu", s7_D_cond_br},
259 {"brleu", s7_D_cond_br},
260 {"breq", s7_D_cond_br},
261 {"brne", s7_D_cond_br},
262 {"brgt", s7_D_cond_br},
263 {"brle", s7_D_cond_br},
264 {"brge", s7_D_cond_br},
265 {"brlt", s7_D_cond_br},
266 {"brmi", s7_D_cond_br},
267 {"brpl", s7_D_cond_br},
268 {"brvs", s7_D_cond_br},
269 {"brvc", s7_D_cond_br},
270 {"brcsl", s7_D_cond_br},
271 {"brccl", s7_D_cond_br},
272 {"brgtul", s7_D_cond_br},
273 {"brleul", s7_D_cond_br},
274 {"breql", s7_D_cond_br},
275 {"brnel", s7_D_cond_br},
276 {"brgtl", s7_D_cond_br},
277 {"brlel", s7_D_cond_br},
278 {"brgel", s7_D_cond_br},
279 {"brltl", s7_D_cond_br},
280 {"brmil", s7_D_cond_br},
281 {"brpll", s7_D_cond_br},
282 {"brvsl", s7_D_cond_br},
283 {"brvcl", s7_D_cond_br},
284 {"brcs!", s7_D_cond_br},
285 {"brcc!", s7_D_cond_br},
286 {"brgtu!", s7_D_cond_br},
287 {"brleu!", s7_D_cond_br},
288 {"breq!", s7_D_cond_br},
289 {"brne!", s7_D_cond_br},
290 {"brgt!", s7_D_cond_br},
291 {"brle!", s7_D_cond_br},
292 {"brge!", s7_D_cond_br},
293 {"brlt!", s7_D_cond_br},
294 {"brmi!", s7_D_cond_br},
295 {"brpl!", s7_D_cond_br},
296 {"brvs!", s7_D_cond_br},
297 {"brvc!", s7_D_cond_br},
298 {"brcsl!", s7_D_cond_br},
299 {"brccl!", s7_D_cond_br},
300 {"brgtul!", s7_D_cond_br},
301 {"brleul!", s7_D_cond_br},
302 {"breql!", s7_D_cond_br},
303 {"brnel!", s7_D_cond_br},
304 {"brgtl!", s7_D_cond_br},
305 {"brlel!", s7_D_cond_br},
306 {"brgel!", s7_D_cond_br},
307 {"brltl!", s7_D_cond_br},
308 {"brmil!", s7_D_cond_br},
309 {"brpll!", s7_D_cond_br},
310 {"brvsl!", s7_D_cond_br},
311 {"brvcl!", s7_D_cond_br},
312 /* conditional move instruction. */
313 {"mvcs", s7_D_cond_mv},
314 {"mvcc", s7_D_cond_mv},
315 {"mvgtu", s7_D_cond_mv},
316 {"mvleu", s7_D_cond_mv},
317 {"mveq", s7_D_cond_mv},
318 {"mvne", s7_D_cond_mv},
319 {"mvgt", s7_D_cond_mv},
320 {"mvle", s7_D_cond_mv},
321 {"mvge", s7_D_cond_mv},
322 {"mvlt", s7_D_cond_mv},
323 {"mvmi", s7_D_cond_mv},
324 {"mvpl", s7_D_cond_mv},
325 {"mvvs", s7_D_cond_mv},
326 {"mvvc", s7_D_cond_mv},
327 /* move spectial instruction. */
328 {"mtcr", s7_D_mtcr},
329 {"mftlb", s7_D_mftlb},
330 {"mtptlb", s7_D_mtptlb},
331 {"mtrtlb", s7_D_mtrtlb},
332 {"stlb", s7_D_stlb},
333 {"mfcr", s7_D_mfcr},
334 {"mfsr", s7_D_mfsr},
335 /* cache instruction. */
336 {"cache 8", s7_D_cached},
337 {"cache 9", s7_D_cached},
338 {"cache 10", s7_D_cached},
339 {"cache 11", s7_D_cached},
340 {"cache 12", s7_D_cached},
341 {"cache 13", s7_D_cached},
342 {"cache 14", s7_D_cached},
343 {"cache 24", s7_D_cached},
344 {"cache 26", s7_D_cached},
345 {"cache 27", s7_D_cached},
346 {"cache 29", s7_D_cached},
347 {"cache 30", s7_D_cached},
348 {"cache 31", s7_D_cached},
349 {"cache 0", s7_D_cachei},
350 {"cache 1", s7_D_cachei},
351 {"cache 2", s7_D_cachei},
352 {"cache 3", s7_D_cachei},
353 {"cache 4", s7_D_cachei},
354 {"cache 16", s7_D_cachei},
355 {"cache 17", s7_D_cachei},
356 /* load/store instruction. */
357 {"lb", s7_D_ldst},
358 {"lbu", s7_D_ldst},
359 {"lbu!", s7_D_ldst},
360 {"lbup!", s7_D_ldst},
361 {"lh", s7_D_ldst},
362 {"lhu", s7_D_ldst},
363 {"lh!", s7_D_ldst},
364 {"lhp!", s7_D_ldst},
365 {"lw", s7_D_ldst},
366 {"lw!", s7_D_ldst},
367 {"lwp!", s7_D_ldst},
368 {"sb", s7_D_ldst},
369 {"sb!", s7_D_ldst},
370 {"sbp!", s7_D_ldst},
371 {"sh", s7_D_ldst},
372 {"sh!", s7_D_ldst},
373 {"shp!", s7_D_ldst},
374 {"sw", s7_D_ldst},
375 {"sw!", s7_D_ldst},
376 {"swp!", s7_D_ldst},
377 {"alw", s7_D_ldst},
378 {"asw", s7_D_ldst},
379 {"push!", s7_D_ldst},
380 {"pushhi!", s7_D_ldst},
381 {"pop!", s7_D_ldst},
382 {"pophi!", s7_D_ldst},
383 {"ldc1", s7_D_ldst},
384 {"ldc2", s7_D_ldst},
385 {"ldc3", s7_D_ldst},
386 {"stc1", s7_D_ldst},
387 {"stc2", s7_D_ldst},
388 {"stc3", s7_D_ldst},
389 {"scb", s7_D_ldst},
390 {"scw", s7_D_ldst},
391 {"sce", s7_D_ldst},
392 /* load combine instruction. */
393 {"lcb", s7_D_ldcombine},
394 {"lcw", s7_D_ldcombine},
395 {"lce", s7_D_ldcombine},
396 };
397
398 static const struct s7_data_dependency s7_data_dependency_table[] =
399 {
400 /* Condition register. */
401 {s7_D_mtcr, "cr1", s7_D_pce, "", 2, 1, 0},
402 {s7_D_mtcr, "cr1", s7_D_cond_br, "", 1, 0, 1},
403 {s7_D_mtcr, "cr1", s7_D_cond_mv, "", 1, 0, 1},
404 /* Status regiser. */
405 {s7_D_mtcr, "cr0", s7_D_all_insn, "", 5, 4, 0},
406 /* CCR regiser. */
407 {s7_D_mtcr, "cr4", s7_D_all_insn, "", 6, 5, 0},
408 /* EntryHi/EntryLo register. */
409 {s7_D_mftlb, "", s7_D_mtptlb, "", 1, 1, 1},
410 {s7_D_mftlb, "", s7_D_mtrtlb, "", 1, 1, 1},
411 {s7_D_mftlb, "", s7_D_stlb, "", 1, 1,1},
412 {s7_D_mftlb, "", s7_D_mfcr, "cr11", 1, 1, 1},
413 {s7_D_mftlb, "", s7_D_mfcr, "cr12", 1, 1, 1},
414 /* Index register. */
415 {s7_D_stlb, "", s7_D_mtptlb, "", 1, 1, 1},
416 {s7_D_stlb, "", s7_D_mftlb, "", 1, 1, 1},
417 {s7_D_stlb, "", s7_D_mfcr, "cr8", 2, 2, 1},
418 /* Cache. */
419 {s7_D_cached, "", s7_D_ldst, "", 1, 1, 0},
420 {s7_D_cached, "", s7_D_ldcombine, "", 1, 1, 0},
421 {s7_D_cachei, "", s7_D_all_insn, "", 5, 4, 0},
422 /* Load combine. */
423 {s7_D_ldcombine, "", s7_D_mfsr, "sr1", 3, 3, 1},
424 };
425
426 \f
427
428 /* Used to contain constructed error messages. */
429 static char s7_err_msg[255];
430 static int s7_fix_data_dependency = 0;
431 static int s7_warn_fix_data_dependency = 1;
432
433 static int s7_in_my_get_expression = 0;
434
435 /* Default, pop warning message when using r1. */
436 static int s7_nor1 = 1;
437
438 /* Default will do instruction relax, -O0 will set s7_g_opt = 0. */
439 static unsigned int s7_g_opt = 1;
440
441 /* The size of the small data section. */
442 static unsigned int s7_g_switch_value = 8;
443
444 static segT s7_pdr_seg;
445
446 struct s7_score_it
447 {
448 char name[s7_INSN_NAME_LEN];
449 unsigned long instruction;
450 unsigned long relax_inst;
451 int size;
452 int relax_size;
453 enum score_insn_type type;
454 char str[s7_MAX_LITERAL_POOL_SIZE];
455 const char *error;
456 int bwarn;
457 char reg[s7_INSN_NAME_LEN];
458 struct
459 {
460 bfd_reloc_code_real_type type;
461 expressionS exp;
462 int pc_rel;
463 }reloc;
464 };
465 static struct s7_score_it s7_inst;
466
467 typedef struct proc
468 {
469 symbolS *isym;
470 unsigned long reg_mask;
471 unsigned long reg_offset;
472 unsigned long fpreg_mask;
473 unsigned long leaf;
474 unsigned long frame_offset;
475 unsigned long frame_reg;
476 unsigned long pc_reg;
477 } s7_procS;
478 static s7_procS s7_cur_proc;
479 static s7_procS *s7_cur_proc_ptr;
480 static int s7_numprocs;
481
482 /* Structure for a hash table entry for a register. */
483 struct s7_reg_entry
484 {
485 const char *name;
486 int number;
487 };
488
489 static const struct s7_reg_entry s7_score_rn_table[] =
490 {
491 {"r0", 0}, {"r1", 1}, {"r2", 2}, {"r3", 3},
492 {"r4", 4}, {"r5", 5}, {"r6", 6}, {"r7", 7},
493 {"r8", 8}, {"r9", 9}, {"r10", 10}, {"r11", 11},
494 {"r12", 12}, {"r13", 13}, {"r14", 14}, {"r15", 15},
495 {"r16", 16}, {"r17", 17}, {"r18", 18}, {"r19", 19},
496 {"r20", 20}, {"r21", 21}, {"r22", 22}, {"r23", 23},
497 {"r24", 24}, {"r25", 25}, {"r26", 26}, {"r27", 27},
498 {"r28", 28}, {"r29", 29}, {"r30", 30}, {"r31", 31},
499 {NULL, 0}
500 };
501
502 static const struct s7_reg_entry s7_score_srn_table[] =
503 {
504 {"sr0", 0}, {"sr1", 1}, {"sr2", 2},
505 {NULL, 0}
506 };
507
508 static const struct s7_reg_entry s7_score_crn_table[] =
509 {
510 {"cr0", 0}, {"cr1", 1}, {"cr2", 2}, {"cr3", 3},
511 {"cr4", 4}, {"cr5", 5}, {"cr6", 6}, {"cr7", 7},
512 {"cr8", 8}, {"cr9", 9}, {"cr10", 10}, {"cr11", 11},
513 {"cr12", 12}, {"cr13", 13}, {"cr14", 14}, {"cr15", 15},
514 {"cr16", 16}, {"cr17", 17}, {"cr18", 18}, {"cr19", 19},
515 {"cr20", 20}, {"cr21", 21}, {"cr22", 22}, {"cr23", 23},
516 {"cr24", 24}, {"cr25", 25}, {"cr26", 26}, {"cr27", 27},
517 {"cr28", 28}, {"cr29", 29}, {"cr30", 30}, {"cr31", 31},
518 {NULL, 0}
519 };
520
521 struct s7_reg_map
522 {
523 const struct s7_reg_entry *names;
524 int max_regno;
525 struct hash_control *htab;
526 const char *expected;
527 };
528
529 static struct s7_reg_map s7_all_reg_maps[] =
530 {
531 {s7_score_rn_table, 31, NULL, N_("S+core register expected")},
532 {s7_score_srn_table, 2, NULL, N_("S+core special-register expected")},
533 {s7_score_crn_table, 31, NULL, N_("S+core co-processor register expected")},
534 };
535
536 static struct hash_control *s7_score_ops_hsh = NULL;
537 static struct hash_control *s7_dependency_insn_hsh = NULL;
538
539 \f
540 struct s7_datafield_range
541 {
542 int data_type;
543 int bits;
544 int range[2];
545 };
546
547 static struct s7_datafield_range s7_score_df_range[] =
548 {
549 {_IMM4, 4, {0, (1 << 4) - 1}}, /* ( 0 ~ 15 ) */
550 {_IMM5, 5, {0, (1 << 5) - 1}}, /* ( 0 ~ 31 ) */
551 {_IMM8, 8, {0, (1 << 8) - 1}}, /* ( 0 ~ 255 ) */
552 {_IMM14, 14, {0, (1 << 14) - 1}}, /* ( 0 ~ 16383) */
553 {_IMM15, 15, {0, (1 << 15) - 1}}, /* ( 0 ~ 32767) */
554 {_IMM16, 16, {0, (1 << 16) - 1}}, /* ( 0 ~ 65535) */
555 {_SIMM10, 10, {-(1 << 9), (1 << 9) - 1}}, /* ( -512 ~ 511 ) */
556 {_SIMM12, 12, {-(1 << 11), (1 << 11) - 1}}, /* ( -2048 ~ 2047 ) */
557 {_SIMM14, 14, {-(1 << 13), (1 << 13) - 1}}, /* ( -8192 ~ 8191 ) */
558 {_SIMM15, 15, {-(1 << 14), (1 << 14) - 1}}, /* (-16384 ~ 16383) */
559 {_SIMM16, 16, {-(1 << 15), (1 << 15) - 1}}, /* (-32768 ~ 32767) */
560 {_SIMM14_NEG, 14, {-(1 << 13), (1 << 13) - 1}}, /* ( -8191 ~ 8192 ) */
561 {_IMM16_NEG, 16, {0, (1 << 16) - 1}}, /* (-65535 ~ 0 ) */
562 {_SIMM16_NEG, 16, {-(1 << 15), (1 << 15) - 1}}, /* (-32768 ~ 32767) */
563 {_IMM20, 20, {0, (1 << 20) - 1}},
564 {_IMM25, 25, {0, (1 << 25) - 1}},
565 {_DISP8div2, 8, {-(1 << 8), (1 << 8) - 1}}, /* ( -256 ~ 255 ) */
566 {_DISP11div2, 11, {0, 0}},
567 {_DISP19div2, 19, {-(1 << 19), (1 << 19) - 1}}, /* (-524288 ~ 524287) */
568 {_DISP24div2, 24, {0, 0}},
569 {_VALUE, 32, {0, ((unsigned int)1 << 31) - 1}},
570 {_VALUE_HI16, 16, {0, (1 << 16) - 1}},
571 {_VALUE_LO16, 16, {0, (1 << 16) - 1}},
572 {_VALUE_LDST_LO16, 16, {0, (1 << 16) - 1}},
573 {_SIMM16_LA, 16, {-(1 << 15), (1 << 15) - 1}}, /* (-32768 ~ 32767) */
574 {_IMM5_RSHIFT_1, 5, {0, (1 << 6) - 1}}, /* ( 0 ~ 63 ) */
575 {_IMM5_RSHIFT_2, 5, {0, (1 << 7) - 1}}, /* ( 0 ~ 127 ) */
576 {_SIMM16_LA_POS, 16, {0, (1 << 15) - 1}}, /* ( 0 ~ 32767) */
577 {_IMM5_RANGE_8_31, 5, {8, 31}}, /* But for cop0 the valid data : (8 ~ 31). */
578 {_IMM10_RSHIFT_2, 10, {-(1 << 11), (1 << 11) - 1}}, /* For ldc#, stc#. */
579 {_SIMM10, 10, {0, (1 << 10) - 1}}, /* ( -1024 ~ 1023 ) */
580 {_SIMM12, 12, {0, (1 << 12) - 1}}, /* ( -2048 ~ 2047 ) */
581 {_SIMM14, 14, {0, (1 << 14) - 1}}, /* ( -8192 ~ 8191 ) */
582 {_SIMM15, 15, {0, (1 << 15) - 1}}, /* (-16384 ~ 16383) */
583 {_SIMM16, 16, {0, (1 << 16) - 1}}, /* (-65536 ~ 65536) */
584 {_SIMM14_NEG, 14, {0, (1 << 16) - 1}}, /* ( -8191 ~ 8192 ) */
585 {_IMM16_NEG, 16, {0, (1 << 16) - 1}}, /* ( 65535 ~ 0 ) */
586 {_SIMM16_NEG, 16, {0, (1 << 16) - 1}}, /* ( 65535 ~ 0 ) */
587 {_IMM20, 20, {0, (1 << 20) - 1}}, /* (-32768 ~ 32767) */
588 {_IMM25, 25, {0, (1 << 25) - 1}}, /* (-32768 ~ 32767) */
589 {_GP_IMM15, 15, {0, (1 << 15) - 1}}, /* ( 0 ~ 65535) */
590 {_GP_IMM14, 14, {0, (1 << 14) - 1}}, /* ( 0 ~ 65535) */
591 {_SIMM16_pic, 16, {-(1 << 15), (1 << 15) - 1}}, /* (-32768 ~ 32767) */
592 {_IMM16_LO16_pic, 16, {0, (1 << 16) - 1}}, /* ( 65535 ~ 0 ) */
593 {_IMM16_pic, 16, {0, (1 << 16) - 1}}, /* ( 0 ~ 65535) */
594 };
595
596 \f
597 struct s7_asm_opcode
598 {
599 /* Instruction name. */
600 const char *template_name;
601
602 /* Instruction Opcode. */
603 bfd_vma value;
604
605 /* Instruction bit mask. */
606 bfd_vma bitmask;
607
608 /* Relax instruction opcode. 0x8000 imply no relaxation. */
609 bfd_vma relax_value;
610
611 /* Instruction type. */
612 enum score_insn_type type;
613
614 /* Function to call to parse args. */
615 void (*parms) (char *);
616 };
617
618 static const struct s7_asm_opcode s7_score_ldst_insns[] =
619 {
620 {"lw", 0x20000000, 0x3e000000, 0x2008, Rd_rvalueRs_SI15, s7_do_ldst_insn},
621 {"lw", 0x06000000, 0x3e000007, 0x8000, Rd_rvalueRs_preSI12, s7_do_ldst_insn},
622 {"lw", 0x0e000000, 0x3e000007, 0x200a, Rd_rvalueRs_postSI12, s7_do_ldst_insn},
623 {"lh", 0x22000000, 0x3e000000, 0x2009, Rd_rvalueRs_SI15, s7_do_ldst_insn},
624 {"lh", 0x06000001, 0x3e000007, 0x8000, Rd_rvalueRs_preSI12, s7_do_ldst_insn},
625 {"lh", 0x0e000001, 0x3e000007, 0x8000, Rd_rvalueRs_postSI12, s7_do_ldst_insn},
626 {"lhu", 0x24000000, 0x3e000000, 0x8000, Rd_rvalueRs_SI15, s7_do_ldst_insn},
627 {"lhu", 0x06000002, 0x3e000007, 0x8000, Rd_rvalueRs_preSI12, s7_do_ldst_insn},
628 {"lhu", 0x0e000002, 0x3e000007, 0x8000, Rd_rvalueRs_postSI12, s7_do_ldst_insn},
629 {"lb", 0x26000000, 0x3e000000, 0x8000, Rd_rvalueRs_SI15, s7_do_ldst_insn},
630 {"lb", 0x06000003, 0x3e000007, 0x8000, Rd_rvalueRs_preSI12, s7_do_ldst_insn},
631 {"lb", 0x0e000003, 0x3e000007, 0x8000, Rd_rvalueRs_postSI12, s7_do_ldst_insn},
632 {"sw", 0x28000000, 0x3e000000, 0x200c, Rd_lvalueRs_SI15, s7_do_ldst_insn},
633 {"sw", 0x06000004, 0x3e000007, 0x200e, Rd_lvalueRs_preSI12, s7_do_ldst_insn},
634 {"sw", 0x0e000004, 0x3e000007, 0x8000, Rd_lvalueRs_postSI12, s7_do_ldst_insn},
635 {"sh", 0x2a000000, 0x3e000000, 0x200d, Rd_lvalueRs_SI15, s7_do_ldst_insn},
636 {"sh", 0x06000005, 0x3e000007, 0x8000, Rd_lvalueRs_preSI12, s7_do_ldst_insn},
637 {"sh", 0x0e000005, 0x3e000007, 0x8000, Rd_lvalueRs_postSI12, s7_do_ldst_insn},
638 {"lbu", 0x2c000000, 0x3e000000, 0x200b, Rd_rvalueRs_SI15, s7_do_ldst_insn},
639 {"lbu", 0x06000006, 0x3e000007, 0x8000, Rd_rvalueRs_preSI12, s7_do_ldst_insn},
640 {"lbu", 0x0e000006, 0x3e000007, 0x8000, Rd_rvalueRs_postSI12, s7_do_ldst_insn},
641 {"sb", 0x2e000000, 0x3e000000, 0x200f, Rd_lvalueRs_SI15, s7_do_ldst_insn},
642 {"sb", 0x06000007, 0x3e000007, 0x8000, Rd_lvalueRs_preSI12, s7_do_ldst_insn},
643 {"sb", 0x0e000007, 0x3e000007, 0x8000, Rd_lvalueRs_postSI12, s7_do_ldst_insn},
644 };
645
646 static const struct s7_asm_opcode s7_score_insns[] =
647 {
648 {"abs", 0x3800000a, 0x3e007fff, 0x8000, Rd_Rs_x, s7_do_rdrs},
649 {"abs.s", 0x3800004b, 0x3e007fff, 0x8000, Rd_Rs_x, s7_do_rdrs},
650 {"add", 0x00000010, 0x3e0003ff, 0x8000, Rd_Rs_Rs, s7_do_rdrsrs},
651 {"add.c", 0x00000011, 0x3e0003ff, 0x2000, Rd_Rs_Rs, s7_do_rdrsrs},
652 {"add.s", 0x38000048, 0x3e0003ff, 0x8000, Rd_Rs_Rs, s7_do_rdrsrs},
653 {"addc", 0x00000012, 0x3e0003ff, 0x8000, Rd_Rs_Rs, s7_do_rdrsrs},
654 {"addc.c", 0x00000013, 0x3e0003ff, 0x0009, Rd_Rs_Rs, s7_do_rdrsrs},
655 {"addi", 0x02000000, 0x3e0e0001, 0x8000, Rd_SI16, s7_do_rdsi16},
656 {"addi.c", 0x02000001, 0x3e0e0001, 0x8000, Rd_SI16, s7_do_rdsi16},
657 {"addis", 0x0a000000, 0x3e0e0001, 0x8000, Rd_SI16, s7_do_rdi16},
658 {"addis.c", 0x0a000001, 0x3e0e0001, 0x8000, Rd_SI16, s7_do_rdi16},
659 {"addri", 0x10000000, 0x3e000001, 0x8000, Rd_Rs_SI14, s7_do_rdrssi14},
660 {"addri.c", 0x10000001, 0x3e000001, 0x8000, Rd_Rs_SI14, s7_do_rdrssi14},
661 {"addc!", 0x0009, 0x700f, 0x00000013, Rd_Rs, s7_do16_rdrs},
662 {"add!", 0x2000, 0x700f, 0x00000011, Rd_Rs, s7_do16_rdrs},
663 {"addei!", 0x6000 , 0x7087, 0x02000001, Rd_I4, s7_do16_rdi4},
664 {"subi", 0x02000000, 0x3e0e0001, 0x8000, Rd_SI16, s7_do_sub_rdsi16},
665 {"subi.c", 0x02000001, 0x3e0e0001, 0x8000, Rd_SI16, s7_do_sub_rdsi16},
666 {"subri", 0x10000000, 0x3e000001, 0x8000, Rd_Rs_SI14, s7_do_sub_rdrssi14},
667 {"subri.c", 0x10000001, 0x3e000001, 0x8000, Rd_Rs_SI14, s7_do_sub_rdrssi14},
668 {"and", 0x00000020, 0x3e0003ff, 0x8000, Rd_Rs_Rs, s7_do_rdrsrs},
669 {"and.c", 0x00000021, 0x3e0003ff, 0x2004, Rd_Rs_Rs, s7_do_rdrsrs},
670 {"andi", 0x02080000, 0x3e0e0001, 0x8000, Rd_I16, s7_do_rdi16},
671 {"andi.c", 0x02080001, 0x3e0e0001, 0x8000, Rd_I16, s7_do_rdi16},
672 {"andis", 0x0a080000, 0x3e0e0001, 0x8000, Rd_I16, s7_do_rdi16},
673 {"andis.c", 0x0a080001, 0x3e0e0001, 0x8000, Rd_I16, s7_do_rdi16},
674 {"andri", 0x18000000, 0x3e000001, 0x8000, Rd_Rs_I14, s7_do_rdrsi14},
675 {"andri.c", 0x18000001, 0x3e000001, 0x8000, Rd_Rs_I14, s7_do_rdrsi14},
676 {"and!", 0x2004, 0x700f, 0x00000021, Rd_Rs, s7_do16_rdrs},
677 {"bcs", 0x08000000, 0x3e007c01, 0x4000, PC_DISP19div2, s7_do_branch},
678 {"bcc", 0x08000400, 0x3e007c01, 0x4000, PC_DISP19div2, s7_do_branch},
679 {"bcnz", 0x08003800, 0x3e007c01, 0x4000, PC_DISP19div2, s7_do_branch},
680 {"bcsl", 0x08000001, 0x3e007c01, 0x8000, PC_DISP19div2, s7_do_branch},
681 {"bccl", 0x08000401, 0x3e007c01, 0x8000, PC_DISP19div2, s7_do_branch},
682 {"bcnzl", 0x08003801, 0x3e007c01, 0x8000, PC_DISP19div2, s7_do_branch},
683 {"bcs!", 0x4000, 0x7f00, 0x08000000, PC_DISP8div2, s7_do16_branch},
684 {"bcc!", 0x4100, 0x7f00, 0x08000400, PC_DISP8div2, s7_do16_branch},
685 {"bcnz!", 0x4e00, 0x7f00, 0x08003800, PC_DISP8div2, s7_do16_branch},
686 {"beq", 0x08001000, 0x3e007c01, 0x4000, PC_DISP19div2, s7_do_branch},
687 {"beql", 0x08001001, 0x3e007c01, 0x8000, PC_DISP19div2, s7_do_branch},
688 {"beq!", 0x4400, 0x7f00, 0x08001000, PC_DISP8div2, s7_do16_branch},
689 {"bgtu", 0x08000800, 0x3e007c01, 0x4000, PC_DISP19div2, s7_do_branch},
690 {"bgt", 0x08001800, 0x3e007c01, 0x4000, PC_DISP19div2, s7_do_branch},
691 {"bge", 0x08002000, 0x3e007c01, 0x4000, PC_DISP19div2, s7_do_branch},
692 {"bgtul", 0x08000801, 0x3e007c01, 0x8000, PC_DISP19div2, s7_do_branch},
693 {"bgtl", 0x08001801, 0x3e007c01, 0x8000, PC_DISP19div2, s7_do_branch},
694 {"bgel", 0x08002001, 0x3e007c01, 0x8000, PC_DISP19div2, s7_do_branch},
695 {"bgtu!", 0x4200, 0x7f00, 0x08000800, PC_DISP8div2, s7_do16_branch},
696 {"bgt!", 0x4600, 0x7f00, 0x08001800, PC_DISP8div2, s7_do16_branch},
697 {"bge!", 0x4800, 0x7f00, 0x08002000, PC_DISP8div2, s7_do16_branch},
698 {"bitclr.c", 0x00000029, 0x3e0003ff, 0x6004, Rd_Rs_I5, s7_do_rdrsi5},
699 {"bitrev", 0x3800000c, 0x3e0003ff, 0x8000, Rd_Rs_Rs, s7_do_rdrsrs},
700 {"bitset.c", 0x0000002b, 0x3e0003ff, 0x6005, Rd_Rs_I5, s7_do_rdrsi5},
701 {"bittst.c", 0x0000002d, 0x3e0003ff, 0x6006, x_Rs_I5, s7_do_xrsi5},
702 {"bittgl.c", 0x0000002f, 0x3e0003ff, 0x6007, Rd_Rs_I5, s7_do_rdrsi5},
703 {"bitclr!", 0x6004, 0x7007, 0x00000029, Rd_I5, s7_do16_rdi5},
704 {"bitset!", 0x6005, 0x7007, 0x0000002b, Rd_I5, s7_do16_rdi5},
705 {"bittst!", 0x6006, 0x7007, 0x0000002d, Rd_I5, s7_do16_rdi5},
706 {"bittgl!", 0x6007, 0x7007, 0x0000002f, Rd_I5, s7_do16_rdi5},
707 {"bleu", 0x08000c00, 0x3e007c01, 0x4000, PC_DISP19div2, s7_do_branch},
708 {"ble", 0x08001c00, 0x3e007c01, 0x4000, PC_DISP19div2, s7_do_branch},
709 {"blt", 0x08002400, 0x3e007c01, 0x4000, PC_DISP19div2, s7_do_branch},
710 {"bleul", 0x08000c01, 0x3e007c01, 0x8000, PC_DISP19div2, s7_do_branch},
711 {"blel", 0x08001c01, 0x3e007c01, 0x8000, PC_DISP19div2, s7_do_branch},
712 {"bltl", 0x08002401, 0x3e007c01, 0x8000, PC_DISP19div2, s7_do_branch},
713 {"bl", 0x08003c01, 0x3e007c01, 0x8000, PC_DISP19div2, s7_do_branch},
714 {"bleu!", 0x4300, 0x7f00, 0x08000c00, PC_DISP8div2, s7_do16_branch},
715 {"ble!", 0x4700, 0x7f00, 0x08001c00, PC_DISP8div2, s7_do16_branch},
716 {"blt!", 0x4900, 0x7f00, 0x08002400, PC_DISP8div2, s7_do16_branch},
717 {"bmi", 0x08002800, 0x3e007c01, 0x4000, PC_DISP19div2, s7_do_branch},
718 {"bmil", 0x08002801, 0x3e007c01, 0x8000, PC_DISP19div2, s7_do_branch},
719 {"bmi!", 0x00004a00, 0x00007f00, 0x08002800, PC_DISP8div2, s7_do16_branch},
720 {"bne", 0x08001400, 0x3e007c01, 0x4000, PC_DISP19div2, s7_do_branch},
721 {"bnel", 0x08001401, 0x3e007c01, 0x8000, PC_DISP19div2, s7_do_branch},
722 {"bne!", 0x4500, 0x7f00, 0x08001400, PC_DISP8div2, s7_do16_branch},
723 {"bpl", 0x08002c00, 0x3e007c01, 0x4000, PC_DISP19div2, s7_do_branch},
724 {"bpll", 0x08002c01, 0x3e007c01, 0x8000, PC_DISP19div2, s7_do_branch},
725 {"bpl!", 0x4b00, 0x7f00, 0x08002c00, PC_DISP8div2, s7_do16_branch},
726 {"brcs", 0x00000008, 0x3e007fff, 0x0004, x_Rs_x, s7_do_rs},
727 {"brcc", 0x00000408, 0x3e007fff, 0x0104, x_Rs_x, s7_do_rs},
728 {"brgtu", 0x00000808, 0x3e007fff, 0x0204, x_Rs_x, s7_do_rs},
729 {"brleu", 0x00000c08, 0x3e007fff, 0x0304, x_Rs_x, s7_do_rs},
730 {"breq", 0x00001008, 0x3e007fff, 0x0404, x_Rs_x, s7_do_rs},
731 {"brne", 0x00001408, 0x3e007fff, 0x0504, x_Rs_x, s7_do_rs},
732 {"brgt", 0x00001808, 0x3e007fff, 0x0604, x_Rs_x, s7_do_rs},
733 {"brle", 0x00001c08, 0x3e007fff, 0x0704, x_Rs_x, s7_do_rs},
734 {"brge", 0x00002008, 0x3e007fff, 0x0804, x_Rs_x, s7_do_rs},
735 {"brlt", 0x00002408, 0x3e007fff, 0x0904, x_Rs_x, s7_do_rs},
736 {"brmi", 0x00002808, 0x3e007fff, 0x0a04, x_Rs_x, s7_do_rs},
737 {"brpl", 0x00002c08, 0x3e007fff, 0x0b04, x_Rs_x, s7_do_rs},
738 {"brvs", 0x00003008, 0x3e007fff, 0x0c04, x_Rs_x, s7_do_rs},
739 {"brvc", 0x00003408, 0x3e007fff, 0x0d04, x_Rs_x, s7_do_rs},
740 {"brcnz", 0x00003808, 0x3e007fff, 0x0e04, x_Rs_x, s7_do_rs},
741 {"br", 0x00003c08, 0x3e007fff, 0x0f04, x_Rs_x, s7_do_rs},
742 {"brcsl", 0x00000009, 0x3e007fff, 0x000c, x_Rs_x, s7_do_rs},
743 {"brccl", 0x00000409, 0x3e007fff, 0x010c, x_Rs_x, s7_do_rs},
744 {"brgtul", 0x00000809, 0x3e007fff, 0x020c, x_Rs_x, s7_do_rs},
745 {"brleul", 0x00000c09, 0x3e007fff, 0x030c, x_Rs_x, s7_do_rs},
746 {"breql", 0x00001009, 0x3e007fff, 0x040c, x_Rs_x, s7_do_rs},
747 {"brnel", 0x00001409, 0x3e007fff, 0x050c, x_Rs_x, s7_do_rs},
748 {"brgtl", 0x00001809, 0x3e007fff, 0x060c, x_Rs_x, s7_do_rs},
749 {"brlel", 0x00001c09, 0x3e007fff, 0x070c, x_Rs_x, s7_do_rs},
750 {"brgel", 0x00002009, 0x3e007fff, 0x080c, x_Rs_x, s7_do_rs},
751 {"brltl", 0x00002409, 0x3e007fff, 0x090c, x_Rs_x, s7_do_rs},
752 {"brmil", 0x00002809, 0x3e007fff, 0x0a0c, x_Rs_x, s7_do_rs},
753 {"brpll", 0x00002c09, 0x3e007fff, 0x0b0c, x_Rs_x, s7_do_rs},
754 {"brvsl", 0x00003009, 0x3e007fff, 0x0c0c, x_Rs_x, s7_do_rs},
755 {"brvcl", 0x00003409, 0x3e007fff, 0x0d0c, x_Rs_x, s7_do_rs},
756 {"brcnzl", 0x00003809, 0x3e007fff, 0x0e0c, x_Rs_x, s7_do_rs},
757 {"brl", 0x00003c09, 0x3e007fff, 0x0f0c, x_Rs_x, s7_do_rs},
758 {"brcs!", 0x0004, 0x7f0f, 0x00000008, x_Rs, s7_do16_xrs},
759 {"brcc!", 0x0104, 0x7f0f, 0x00000408, x_Rs, s7_do16_xrs},
760 {"brgtu!", 0x0204, 0x7f0f, 0x00000808, x_Rs, s7_do16_xrs},
761 {"brleu!", 0x0304, 0x7f0f, 0x00000c08, x_Rs, s7_do16_xrs},
762 {"breq!", 0x0404, 0x7f0f, 0x00001008, x_Rs, s7_do16_xrs},
763 {"brne!", 0x0504, 0x7f0f, 0x00001408, x_Rs, s7_do16_xrs},
764 {"brgt!", 0x0604, 0x7f0f, 0x00001808, x_Rs, s7_do16_xrs},
765 {"brle!", 0x0704, 0x7f0f, 0x00001c08, x_Rs, s7_do16_xrs},
766 {"brge!", 0x0804, 0x7f0f, 0x00002008, x_Rs, s7_do16_xrs},
767 {"brlt!", 0x0904, 0x7f0f, 0x00002408, x_Rs, s7_do16_xrs},
768 {"brmi!", 0x0a04, 0x7f0f, 0x00002808, x_Rs, s7_do16_xrs},
769 {"brpl!", 0x0b04, 0x7f0f, 0x00002c08, x_Rs, s7_do16_xrs},
770 {"brvs!", 0x0c04, 0x7f0f, 0x00003008, x_Rs, s7_do16_xrs},
771 {"brvc!", 0x0d04, 0x7f0f, 0x00003408, x_Rs, s7_do16_xrs},
772 {"brcnz!", 0x0e04, 0x7f0f, 0x00003808, x_Rs, s7_do16_xrs},
773 {"br!", 0x0f04, 0x7f0f, 0x00003c08, x_Rs, s7_do16_xrs},
774 {"brcsl!", 0x000c, 0x7f0f, 0x00000009, x_Rs, s7_do16_xrs},
775 {"brccl!", 0x010c, 0x7f0f, 0x00000409, x_Rs, s7_do16_xrs},
776 {"brgtul!", 0x020c, 0x7f0f, 0x00000809, x_Rs, s7_do16_xrs},
777 {"brleul!", 0x030c, 0x7f0f, 0x00000c09, x_Rs, s7_do16_xrs},
778 {"breql!", 0x040c, 0x7f0f, 0x00001009, x_Rs, s7_do16_xrs},
779 {"brnel!", 0x050c, 0x7f0f, 0x00001409, x_Rs, s7_do16_xrs},
780 {"brgtl!", 0x060c, 0x7f0f, 0x00001809, x_Rs, s7_do16_xrs},
781 {"brlel!", 0x070c, 0x7f0f, 0x00001c09, x_Rs, s7_do16_xrs},
782 {"brgel!", 0x080c, 0x7f0f, 0x00002009, x_Rs, s7_do16_xrs},
783 {"brltl!", 0x090c, 0x7f0f, 0x00002409, x_Rs, s7_do16_xrs},
784 {"brmil!", 0x0a0c, 0x7f0f, 0x00002809, x_Rs, s7_do16_xrs},
785 {"brpll!", 0x0b0c, 0x7f0f, 0x00002c09, x_Rs, s7_do16_xrs},
786 {"brvsl!", 0x0c0c, 0x7f0f, 0x00003009, x_Rs, s7_do16_xrs},
787 {"brvcl!", 0x0d0c, 0x7f0f, 0x00003409, x_Rs, s7_do16_xrs},
788 {"brcnzl!", 0x0e0c, 0x7f0f, 0x00003809, x_Rs, s7_do16_xrs},
789 {"brl!", 0x0f0c, 0x7f0f, 0x00003c09, x_Rs, s7_do16_xrs},
790 {"bvs", 0x08003000, 0x3e007c01, 0x4000, PC_DISP19div2, s7_do_branch},
791 {"bvc", 0x08003400, 0x3e007c01, 0x4000, PC_DISP19div2, s7_do_branch},
792 {"bvsl", 0x08003001, 0x3e007c01, 0x8000, PC_DISP19div2, s7_do_branch},
793 {"bvcl", 0x08003401, 0x3e007c01, 0x8000, PC_DISP19div2, s7_do_branch},
794 {"bvs!", 0x4c00, 0x7f00, 0x08003000, PC_DISP8div2, s7_do16_branch},
795 {"bvc!", 0x4d00, 0x7f00, 0x08003400, PC_DISP8div2, s7_do16_branch},
796 {"b!", 0x4f00, 0x7f00, 0x08003c00, PC_DISP8div2, s7_do16_branch},
797 {"b", 0x08003c00, 0x3e007c01, 0x4000, PC_DISP19div2, s7_do_branch},
798 {"cache", 0x30000000, 0x3ff00000, 0x8000, OP5_rvalueRs_SI15, s7_do_cache},
799 {"ceinst", 0x38000000, 0x3e000000, 0x8000, I5_Rs_Rs_I5_OP5, s7_do_ceinst},
800 {"clz", 0x3800000d, 0x3e007fff, 0x8000, Rd_Rs_x, s7_do_rdrs},
801 {"cmpteq.c", 0x00000019, 0x3ff003ff, 0x8000, x_Rs_Rs, s7_do_rsrs},
802 {"cmptmi.c", 0x00100019, 0x3ff003ff, 0x8000, x_Rs_Rs, s7_do_rsrs},
803 {"cmp.c", 0x00300019, 0x3ff003ff, 0x2003, x_Rs_Rs, s7_do_rsrs},
804 {"cmpzteq.c", 0x0000001b, 0x3ff07fff, 0x8000, x_Rs_x, s7_do_rs},
805 {"cmpztmi.c", 0x0010001b, 0x3ff07fff, 0x8000, x_Rs_x, s7_do_rs},
806 {"cmpz.c", 0x0030001b, 0x3ff07fff, 0x8000, x_Rs_x, s7_do_rs},
807 {"cmpi.c", 0x02040001, 0x3e0e0001, 0x8000, Rd_SI16, s7_do_rdsi16},
808 {"cmp!", 0x2003, 0x700f, 0x00300019, Rd_Rs, s7_do16_rdrs},
809 {"cop1", 0x0c00000c, 0x3e00001f, 0x8000, Rd_Rs_Rs_imm, s7_do_crdcrscrsimm5},
810 {"cop2", 0x0c000014, 0x3e00001f, 0x8000, Rd_Rs_Rs_imm, s7_do_crdcrscrsimm5},
811 {"cop3", 0x0c00001c, 0x3e00001f, 0x8000, Rd_Rs_Rs_imm, s7_do_crdcrscrsimm5},
812 {"drte", 0x0c0000a4, 0x3e0003ff, 0x8000, NO_OPD, s7_do_empty},
813 {"extsb", 0x00000058, 0x3e0003ff, 0x8000, Rd_Rs_x, s7_do_rdrs},
814 {"extsb.c", 0x00000059, 0x3e0003ff, 0x8000, Rd_Rs_x, s7_do_rdrs},
815 {"extsh", 0x0000005a, 0x3e0003ff, 0x8000, Rd_Rs_x, s7_do_rdrs},
816 {"extsh.c", 0x0000005b, 0x3e0003ff, 0x8000, Rd_Rs_x, s7_do_rdrs},
817 {"extzb", 0x0000005c, 0x3e0003ff, 0x8000, Rd_Rs_x, s7_do_rdrs},
818 {"extzb.c", 0x0000005d, 0x3e0003ff, 0x8000, Rd_Rs_x, s7_do_rdrs},
819 {"extzh", 0x0000005e, 0x3e0003ff, 0x8000, Rd_Rs_x, s7_do_rdrs},
820 {"extzh.c", 0x0000005f, 0x3e0003ff, 0x8000, Rd_Rs_x, s7_do_rdrs},
821 {"jl", 0x04000001, 0x3e000001, 0x8000, PC_DISP24div2, s7_do_jump},
822 {"jl!", 0x3001, 0x7001, 0x04000001, PC_DISP11div2, s7_do16_jump},
823 {"j!", 0x3000, 0x7001, 0x04000000, PC_DISP11div2, s7_do16_jump},
824 {"j", 0x04000000, 0x3e000001, 0x8000, PC_DISP24div2, s7_do_jump},
825 {"lbu!", 0x200b, 0x0000700f, 0x2c000000, Rd_rvalueRs, s7_do16_ldst_insn},
826 {"lbup!", 0x7003, 0x7007, 0x2c000000, Rd_rvalueBP_I5, s7_do16_ldst_imm_insn},
827 {"alw", 0x0000000c, 0x3e0003ff, 0x8000, Rd_rvalue32Rs, s7_do_ldst_atomic},
828 {"lcb", 0x00000060, 0x3e0003ff, 0x8000, x_rvalueRs_post4, s7_do_ldst_unalign},
829 {"lcw", 0x00000062, 0x3e0003ff, 0x8000, Rd_rvalueRs_post4, s7_do_ldst_unalign},
830 {"lce", 0x00000066, 0x3e0003ff, 0x8000, Rd_rvalueRs_post4, s7_do_ldst_unalign},
831 {"ldc1", 0x0c00000a, 0x3e00001f, 0x8000, Rd_rvalueRs_SI10, s7_do_ldst_cop},
832 {"ldc2", 0x0c000012, 0x3e00001f, 0x8000, Rd_rvalueRs_SI10, s7_do_ldst_cop},
833 {"ldc3", 0x0c00001a, 0x3e00001f, 0x8000, Rd_rvalueRs_SI10, s7_do_ldst_cop},
834 {"lh!", 0x2009, 0x700f, 0x22000000, Rd_rvalueRs, s7_do16_ldst_insn},
835 {"lhp!", 0x7001, 0x7007, 0x22000000, Rd_rvalueBP_I5, s7_do16_ldst_imm_insn},
836 {"ldi", 0x020c0000, 0x3e0e0000, 0x5000, Rd_SI16, s7_do_rdsi16},
837 {"ldis", 0x0a0c0000, 0x3e0e0000, 0x8000, Rd_I16, s7_do_rdi16},
838 {"ldiu!", 0x5000, 0x7000, 0x020c0000, Rd_I8, s7_do16_ldst_imm_insn},
839 {"lw!", 0x2008, 0x700f, 0x20000000, Rd_rvalueRs, s7_do16_ldst_insn},
840 {"lwp!", 0x7000, 0x7007, 0x20000000, Rd_rvalueBP_I5, s7_do16_ldst_imm_insn},
841 {"mfcel", 0x00000448, 0x3e007fff, 0x8000, Rd_x_x, s7_do_rd},
842 {"mfcel!", 0x1001, 0x7f0f, 0x00000448, x_Rs, s7_do16_rs},
843 {"mad", 0x38000000, 0x3ff003ff, 0x8000, x_Rs_Rs, s7_do_rsrs},
844 {"mad.f!", 0x1004, 0x700f, 0x38000080, Rd_Rs, s7_do16_rdrs},
845 {"madh", 0x38000203, 0x3ff003ff, 0x8000, x_Rs_Rs, s7_do_rsrs},
846 {"madh.fs", 0x380002c3, 0x3ff003ff, 0x8000, x_Rs_Rs, s7_do_rsrs},
847 {"madh.fs!", 0x100b, 0x700f, 0x380002c3, Rd_Rs, s7_do16_rdrs},
848 {"madl", 0x38000002, 0x3ff003ff, 0x8000, x_Rs_Rs, s7_do_rsrs},
849 {"madl.fs", 0x380000c2, 0x3ff003ff, 0x8000, x_Rs_Rs, s7_do_rsrs},
850 {"madl.fs!", 0x100a, 0x700f, 0x380000c2, Rd_Rs, s7_do16_rdrs},
851 {"madu", 0x38000020, 0x3ff003ff, 0x8000, x_Rs_Rs, s7_do_rsrs},
852 {"madu!", 0x1005, 0x700f, 0x38000020, Rd_Rs, s7_do16_rdrs},
853 {"mad.f", 0x38000080, 0x3ff003ff, 0x8000, x_Rs_Rs, s7_do_rsrs},
854 {"max", 0x38000007, 0x3e0003ff, 0x8000, Rd_Rs_Rs, s7_do_rdrsrs},
855 {"mazh", 0x38000303, 0x3ff003ff, 0x8000, x_Rs_Rs, s7_do_rsrs},
856 {"mazh.f", 0x38000383, 0x3ff003ff, 0x8000, x_Rs_Rs, s7_do_rsrs},
857 {"mazh.f!", 0x1009, 0x700f, 0x38000383, Rd_Rs, s7_do16_rdrs},
858 {"mazl", 0x38000102, 0x3ff003ff, 0x8000, x_Rs_Rs, s7_do_rsrs},
859 {"mazl.f", 0x38000182, 0x3ff003ff, 0x8000, x_Rs_Rs, s7_do_rsrs},
860 {"mazl.f!", 0x1008, 0x700f, 0x38000182, Rd_Rs, s7_do16_rdrs},
861 {"mfceh", 0x00000848, 0x3e007fff, 0x8000, Rd_x_x, s7_do_rd},
862 {"mfceh!", 0x1101, 0x7f0f, 0x00000848, x_Rs, s7_do16_rs},
863 {"mfcehl", 0x00000c48, 0x3e007fff, 0x8000, Rd_Rs_x, s7_do_rdrs},
864 {"mfsr", 0x00000050, 0x3e0003ff, 0x8000, Rd_x_I5, s7_do_rdsrs},
865 {"mfcr", 0x0c000001, 0x3e00001f, 0x8000, Rd_Rs_x, s7_do_rdcrs},
866 {"mfc1", 0x0c000009, 0x3e00001f, 0x8000, Rd_Rs_x, s7_do_rdcrs},
867 {"mfc2", 0x0c000011, 0x3e00001f, 0x8000, Rd_Rs_x, s7_do_rdcrs},
868 {"mfc3", 0x0c000019, 0x3e00001f, 0x8000, Rd_Rs_x, s7_do_rdcrs},
869 {"mfcc1", 0x0c00000f, 0x3e00001f, 0x8000, Rd_Rs_x, s7_do_rdcrs},
870 {"mfcc2", 0x0c000017, 0x3e00001f, 0x8000, Rd_Rs_x, s7_do_rdcrs},
871 {"mfcc3", 0x0c00001f, 0x3e00001f, 0x8000, Rd_Rs_x, s7_do_rdcrs},
872 {"mhfl!", 0x0002, 0x700f, 0x00003c56, Rd_LowRs, s7_do16_hrdrs},
873 {"min", 0x38000006, 0x3e0003ff, 0x8000, Rd_Rs_Rs, s7_do_rdrsrs},
874 {"mlfh!", 0x0001, 0x700f, 0x00003c56, Rd_HighRs, s7_do16_rdhrs},
875 {"msb", 0x38000001, 0x3ff003ff, 0x8000, x_Rs_Rs, s7_do_rsrs},
876 {"msb.f!", 0x1006, 0x700f, 0x38000081, Rd_Rs, s7_do16_rdrs},
877 {"msbh", 0x38000205, 0x3ff003ff, 0x8000, x_Rs_Rs, s7_do_rsrs},
878 {"msbh.fs", 0x380002c5, 0x3ff003ff, 0x8000, x_Rs_Rs, s7_do_rsrs},
879 {"msbh.fs!", 0x100f, 0x700f, 0x380002c5, Rd_Rs, s7_do16_rdrs},
880 {"msbl", 0x38000004, 0x3ff003ff, 0x8000, x_Rs_Rs, s7_do_rsrs},
881 {"msbl.fs", 0x380000c4, 0x3ff003ff, 0x8000, x_Rs_Rs, s7_do_rsrs},
882 {"msbl.fs!", 0x100e, 0x700f, 0x380000c4, Rd_Rs, s7_do16_rdrs},
883 {"msbu", 0x38000021, 0x3ff003ff, 0x8000, x_Rs_Rs, s7_do_rsrs},
884 {"msbu!", 0x1007, 0x700f, 0x38000021, Rd_Rs, s7_do16_rdrs},
885 {"msb.f", 0x38000081, 0x3ff003ff, 0x8000, x_Rs_Rs, s7_do_rsrs},
886 {"mszh", 0x38000305, 0x3ff003ff, 0x8000, x_Rs_Rs, s7_do_rsrs},
887 {"mszh.f", 0x38000385, 0x3ff003ff, 0x8000, x_Rs_Rs, s7_do_rsrs},
888 {"mszh.f!", 0x100d, 0x700f, 0x38000385, Rd_Rs, s7_do16_rdrs},
889 {"mszl", 0x38000104, 0x3ff003ff, 0x8000, x_Rs_Rs, s7_do_rsrs},
890 {"mszl.f", 0x38000184, 0x3ff003ff, 0x8000, x_Rs_Rs, s7_do_rsrs},
891 {"mszl.f!", 0x100c, 0x700f, 0x38000184, Rd_Rs, s7_do16_rdrs},
892 {"mtcel!", 0x1000, 0x7f0f, 0x0000044a, x_Rs, s7_do16_rs},
893 {"mtcel", 0x0000044a, 0x3e007fff, 0x8000, Rd_x_x, s7_do_rd},
894 {"mtceh", 0x0000084a, 0x3e007fff, 0x8000, Rd_x_x, s7_do_rd},
895 {"mtceh!", 0x1100, 0x7f0f, 0x0000084a, x_Rs, s7_do16_rs},
896 {"mtcehl", 0x00000c4a, 0x3e007fff, 0x8000, Rd_Rs_x, s7_do_rdrs},
897 {"mtsr", 0x00000052, 0x3e0003ff, 0x8000, x_Rs_I5, s7_do_rdsrs},
898 {"mtcr", 0x0c000000, 0x3e00001f, 0x8000, Rd_Rs_x, s7_do_rdcrs},
899 {"mtc1", 0x0c000008, 0x3e00001f, 0x8000, Rd_Rs_x, s7_do_rdcrs},
900 {"mtc2", 0x0c000010, 0x3e00001f, 0x8000, Rd_Rs_x, s7_do_rdcrs},
901 {"mtc3", 0x0c000018, 0x3e00001f, 0x8000, Rd_Rs_x, s7_do_rdcrs},
902 {"mtcc1", 0x0c00000e, 0x3e00001f, 0x8000, Rd_Rs_x, s7_do_rdcrs},
903 {"mtcc2", 0x0c000016, 0x3e00001f, 0x8000, Rd_Rs_x, s7_do_rdcrs},
904 {"mtcc3", 0x0c00001e, 0x3e00001f, 0x8000, Rd_Rs_x, s7_do_rdcrs},
905 {"mul.f!", 0x1002, 0x700f, 0x00000041, Rd_Rs, s7_do16_rdrs},
906 {"mulu!", 0x1003, 0x700f, 0x00000042, Rd_Rs, s7_do16_rdrs},
907 {"mvcs", 0x00000056, 0x3e007fff, 0x8000, Rd_Rs_x, s7_do_rdrs},
908 {"mvcc", 0x00000456, 0x3e007fff, 0x8000, Rd_Rs_x, s7_do_rdrs},
909 {"mvgtu", 0x00000856, 0x3e007fff, 0x8000, Rd_Rs_x, s7_do_rdrs},
910 {"mvleu", 0x00000c56, 0x3e007fff, 0x8000, Rd_Rs_x, s7_do_rdrs},
911 {"mveq", 0x00001056, 0x3e007fff, 0x8000, Rd_Rs_x, s7_do_rdrs},
912 {"mvne", 0x00001456, 0x3e007fff, 0x8000, Rd_Rs_x, s7_do_rdrs},
913 {"mvgt", 0x00001856, 0x3e007fff, 0x8000, Rd_Rs_x, s7_do_rdrs},
914 {"mvle", 0x00001c56, 0x3e007fff, 0x8000, Rd_Rs_x, s7_do_rdrs},
915 {"mvge", 0x00002056, 0x3e007fff, 0x8000, Rd_Rs_x, s7_do_rdrs},
916 {"mvlt", 0x00002456, 0x3e007fff, 0x8000, Rd_Rs_x, s7_do_rdrs},
917 {"mvmi", 0x00002856, 0x3e007fff, 0x8000, Rd_Rs_x, s7_do_rdrs},
918 {"mvpl", 0x00002c56, 0x3e007fff, 0x8000, Rd_Rs_x, s7_do_rdrs},
919 {"mvvs", 0x00003056, 0x3e007fff, 0x8000, Rd_Rs_x, s7_do_rdrs},
920 {"mvvc", 0x00003456, 0x3e007fff, 0x8000, Rd_Rs_x, s7_do_rdrs},
921 {"mv", 0x00003c56, 0x3e007fff, 0x0003, Rd_Rs_x, s7_do_rdrs},
922 {"mv!", 0x0003, 0x700f, 0x00003c56, Rd_Rs, s7_do16_mv_rdrs},
923 {"neg", 0x0000001e, 0x3e0003ff, 0x8000, Rd_x_Rs, s7_do_rdxrs},
924 {"neg.c", 0x0000001f, 0x3e0003ff, 0x2002, Rd_x_Rs, s7_do_rdxrs},
925 {"neg!", 0x2002, 0x700f, 0x0000001f, Rd_Rs, s7_do16_rdrs},
926 {"nop", 0x00000000, 0x3e0003ff, 0x0000, NO_OPD, s7_do_empty},
927 {"not", 0x00000024, 0x3e0003ff, 0x8000, Rd_Rs_x, s7_do_rdrs},
928 {"not.c", 0x00000025, 0x3e0003ff, 0x2006, Rd_Rs_x, s7_do_rdrs},
929 {"nop!", 0x0000, 0x700f, 0x00000000, NO16_OPD, s7_do_empty},
930 {"not!", 0x2006, 0x700f, 0x00000025, Rd_Rs, s7_do16_rdrs},
931 {"or", 0x00000022, 0x3e0003ff, 0x8000, Rd_Rs_Rs, s7_do_rdrsrs},
932 {"or.c", 0x00000023, 0x3e0003ff, 0x2005, Rd_Rs_Rs, s7_do_rdrsrs},
933 {"ori", 0x020a0000, 0x3e0e0001, 0x8000, Rd_I16, s7_do_rdi16},
934 {"ori.c", 0x020a0001, 0x3e0e0001, 0x8000, Rd_I16, s7_do_rdi16},
935 {"oris", 0x0a0a0000, 0x3e0e0001, 0x8000, Rd_I16, s7_do_rdi16},
936 {"oris.c", 0x0a0a0001, 0x3e0e0001, 0x8000, Rd_I16, s7_do_rdi16},
937 {"orri", 0x1a000000, 0x3e000001, 0x8000, Rd_Rs_I14, s7_do_rdrsi14},
938 {"orri.c", 0x1a000001, 0x3e000001, 0x8000, Rd_Rs_I14, s7_do_rdrsi14},
939 {"or!", 0x2005, 0x700f, 0x00000023, Rd_Rs, s7_do16_rdrs},
940 {"pflush", 0x0000000a, 0x3e0003ff, 0x8000, NO_OPD, s7_do_empty},
941 {"pop!", 0x200a, 0x700f, 0x0e000000, Rd_rvalueRs, s7_do16_push_pop},
942 {"push!", 0x200e, 0x700f, 0x06000004, Rd_lvalueRs, s7_do16_push_pop},
943 {"ror", 0x00000038, 0x3e0003ff, 0x8000, Rd_Rs_Rs, s7_do_rdrsrs},
944 {"ror.c", 0x00000039, 0x3e0003ff, 0x8000, Rd_Rs_Rs, s7_do_rdrsrs},
945 {"rorc.c", 0x0000003b, 0x3e0003ff, 0x8000, Rd_Rs_Rs, s7_do_rdrsrs},
946 {"rol", 0x0000003c, 0x3e0003ff, 0x8000, Rd_Rs_Rs, s7_do_rdrsrs},
947 {"rol.c", 0x0000003d, 0x3e0003ff, 0x8000, Rd_Rs_Rs, s7_do_rdrsrs},
948 {"rolc.c", 0x0000003f, 0x3e0003ff, 0x8000, Rd_Rs_Rs, s7_do_rdrsrs},
949 {"rori", 0x00000078, 0x3e0003ff, 0x8000, Rd_Rs_I5, s7_do_rdrsi5},
950 {"rori.c", 0x00000079, 0x3e0003ff, 0x8000, Rd_Rs_I5, s7_do_rdrsi5},
951 {"roric.c", 0x0000007b, 0x3e0003ff, 0x8000, Rd_Rs_I5, s7_do_rdrsi5},
952 {"roli", 0x0000007c, 0x3e0003ff, 0x8000, Rd_Rs_I5, s7_do_rdrsi5},
953 {"roli.c", 0x0000007d, 0x3e0003ff, 0x8000, Rd_Rs_I5, s7_do_rdrsi5},
954 {"rolic.c", 0x0000007f, 0x3e0003ff, 0x8000, Rd_Rs_I5, s7_do_rdrsi5},
955 {"rte", 0x0c000084, 0x3e0003ff, 0x8000, NO_OPD, s7_do_empty},
956 {"sb!", 0x200f, 0x700f, 0x2e000000, Rd_lvalueRs, s7_do16_ldst_insn},
957 {"sbp!", 0x7007, 0x7007, 0x2e000000, Rd_lvalueBP_I5, s7_do16_ldst_imm_insn},
958 {"asw", 0x0000000e, 0x3e0003ff, 0x8000, Rd_lvalue32Rs, s7_do_ldst_atomic},
959 {"scb", 0x00000068, 0x3e0003ff, 0x8000, Rd_lvalueRs_post4, s7_do_ldst_unalign},
960 {"scw", 0x0000006a, 0x3e0003ff, 0x8000, Rd_lvalueRs_post4, s7_do_ldst_unalign},
961 {"sce", 0x0000006e, 0x3e0003ff, 0x8000, x_lvalueRs_post4, s7_do_ldst_unalign},
962 {"sdbbp", 0x00000006, 0x3e0003ff, 0x6002, x_I5_x, s7_do_xi5x},
963 {"sdbbp!", 0x6002, 0x7007, 0x00000006, Rd_I5, s7_do16_xi5},
964 {"sh!", 0x200d, 0x700f, 0x2a000000, Rd_lvalueRs, s7_do16_ldst_insn},
965 {"shp!", 0x7005, 0x7007, 0x2a000000, Rd_lvalueBP_I5, s7_do16_ldst_imm_insn},
966 {"sleep", 0x0c0000c4, 0x3e0003ff, 0x8000, NO_OPD, s7_do_empty},
967 {"sll", 0x00000030, 0x3e0003ff, 0x8000, Rd_Rs_Rs, s7_do_rdrsrs},
968 {"sll.c", 0x00000031, 0x3e0003ff, 0x0008, Rd_Rs_Rs, s7_do_rdrsrs},
969 {"sll.s", 0x3800004e, 0x3e0003ff, 0x8000, Rd_Rs_Rs, s7_do_rdrsrs},
970 {"slli", 0x00000070, 0x3e0003ff, 0x8000, Rd_Rs_I5, s7_do_rdrsi5},
971 {"slli.c", 0x00000071, 0x3e0003ff, 0x6001, Rd_Rs_I5, s7_do_rdrsi5},
972 {"sll!", 0x0008, 0x700f, 0x00000031, Rd_Rs, s7_do16_rdrs},
973 {"slli!", 0x6001, 0x7007, 0x00000071, Rd_I5, s7_do16_rdi5},
974 {"srl", 0x00000034, 0x3e0003ff, 0x8000, Rd_Rs_Rs, s7_do_rdrsrs},
975 {"srl.c", 0x00000035, 0x3e0003ff, 0x000a, Rd_Rs_Rs, s7_do_rdrsrs},
976 {"sra", 0x00000036, 0x3e0003ff, 0x8000, Rd_Rs_Rs, s7_do_rdrsrs},
977 {"sra.c", 0x00000037, 0x3e0003ff, 0x000b, Rd_Rs_Rs, s7_do_rdrsrs},
978 {"srli", 0x00000074, 0x3e0003ff, 0x8000, Rd_Rs_I5, s7_do_rdrsi5},
979 {"srli.c", 0x00000075, 0x3e0003ff, 0x6003, Rd_Rs_I5, s7_do_rdrsi5},
980 {"srai", 0x00000076, 0x3e0003ff, 0x8000, Rd_Rs_I5, s7_do_rdrsi5},
981 {"srai.c", 0x00000077, 0x3e0003ff, 0x8000, Rd_Rs_I5, s7_do_rdrsi5},
982 {"srl!", 0x000a, 0x700f, 0x00000035, Rd_Rs, s7_do16_rdrs},
983 {"sra!", 0x000b, 0x700f, 0x00000037, Rd_Rs, s7_do16_rdrs},
984 {"srli!", 0x6003, 0x7007, 0x00000075, Rd_Rs, s7_do16_rdi5},
985 {"stc1", 0x0c00000b, 0x3e00001f, 0x8000, Rd_lvalueRs_SI10, s7_do_ldst_cop},
986 {"stc2", 0x0c000013, 0x3e00001f, 0x8000, Rd_lvalueRs_SI10, s7_do_ldst_cop},
987 {"stc3", 0x0c00001b, 0x3e00001f, 0x8000, Rd_lvalueRs_SI10, s7_do_ldst_cop},
988 {"sub", 0x00000014, 0x3e0003ff, 0x8000, Rd_Rs_Rs, s7_do_rdrsrs},
989 {"sub.c", 0x00000015, 0x3e0003ff, 0x2001, Rd_Rs_Rs, s7_do_rdrsrs},
990 {"sub.s", 0x38000049, 0x3e0003ff, 0x8000, Rd_Rs_Rs, s7_do_rdrsrs},
991 {"subc", 0x00000016, 0x3e0003ff, 0x8000, Rd_Rs_Rs, s7_do_rdrsrs},
992 {"subc.c", 0x00000017, 0x3e0003ff, 0x8000, Rd_Rs_Rs, s7_do_rdrsrs},
993 {"sub!", 0x2001, 0x700f, 0x00000015, Rd_Rs, s7_do16_rdrs},
994 {"subei!", 0x6080, 0x7087, 0x02000001, Rd_I4, s7_do16_rdi4},
995 {"sw!", 0x200c, 0x700f, 0x28000000, Rd_lvalueRs, s7_do16_ldst_insn},
996 {"swp!", 0x7004, 0x7007, 0x28000000, Rd_lvalueBP_I5, s7_do16_ldst_imm_insn},
997 {"syscall", 0x00000002, 0x3e0003ff, 0x8000, I15, s7_do_i15},
998 {"tcs", 0x00000054, 0x3e007fff, 0x0005, NO_OPD, s7_do_empty},
999 {"tcc", 0x00000454, 0x3e007fff, 0x0105, NO_OPD, s7_do_empty},
1000 {"tcnz", 0x00003854, 0x3e007fff, 0x0e05, NO_OPD, s7_do_empty},
1001 {"tcs!", 0x0005, 0x7f0f, 0x00000054, NO16_OPD, s7_do_empty},
1002 {"tcc!", 0x0105, 0x7f0f, 0x00000454, NO16_OPD, s7_do_empty},
1003 {"tcnz!", 0x0e05, 0x7f0f, 0x00003854, NO16_OPD, s7_do_empty},
1004 {"teq", 0x00001054, 0x3e007fff, 0x0405, NO_OPD, s7_do_empty},
1005 {"teq!", 0x0405, 0x7f0f, 0x00001054, NO16_OPD, s7_do_empty},
1006 {"tgtu", 0x00000854, 0x3e007fff, 0x0205, NO_OPD, s7_do_empty},
1007 {"tgt", 0x00001854, 0x3e007fff, 0x0605, NO_OPD, s7_do_empty},
1008 {"tge", 0x00002054, 0x3e007fff, 0x0805, NO_OPD, s7_do_empty},
1009 {"tgtu!", 0x0205, 0x7f0f, 0x00000854, NO16_OPD, s7_do_empty},
1010 {"tgt!", 0x0605, 0x7f0f, 0x00001854, NO16_OPD, s7_do_empty},
1011 {"tge!", 0x0805, 0x7f0f, 0x00002054, NO16_OPD, s7_do_empty},
1012 {"tleu", 0x00000c54, 0x3e007fff, 0x0305, NO_OPD, s7_do_empty},
1013 {"tle", 0x00001c54, 0x3e007fff, 0x0705, NO_OPD, s7_do_empty},
1014 {"tlt", 0x00002454, 0x3e007fff, 0x0905, NO_OPD, s7_do_empty},
1015 {"stlb", 0x0c000004, 0x3e0003ff, 0x8000, NO_OPD, s7_do_empty},
1016 {"mftlb", 0x0c000024, 0x3e0003ff, 0x8000, NO_OPD, s7_do_empty},
1017 {"mtptlb", 0x0c000044, 0x3e0003ff, 0x8000, NO_OPD, s7_do_empty},
1018 {"mtrtlb", 0x0c000064, 0x3e0003ff, 0x8000, NO_OPD, s7_do_empty},
1019 {"tleu!", 0x0305, 0x7f0f, 0x00000c54, NO16_OPD, s7_do_empty},
1020 {"tle!", 0x0705, 0x7f0f, 0x00001c54, NO16_OPD, s7_do_empty},
1021 {"tlt!", 0x0905, 0x7f0f, 0x00002454, NO16_OPD, s7_do_empty},
1022 {"tmi", 0x00002854, 0x3e007fff, 0x0a05, NO_OPD, s7_do_empty},
1023 {"tmi!", 0x0a05, 0x7f0f, 0x00002854, NO16_OPD, s7_do_empty},
1024 {"tne", 0x00001454, 0x3e007fff, 0x0505, NO_OPD, s7_do_empty},
1025 {"tne!", 0x0505, 0x7f0f, 0x00001454, NO16_OPD, s7_do_empty},
1026 {"tpl", 0x00002c54, 0x3e007fff, 0x0b05, NO_OPD, s7_do_empty},
1027 {"tpl!", 0x0b05, 0x7f0f, 0x00002c54, NO16_OPD, s7_do_empty},
1028 {"trapcs", 0x00000004, 0x3e007fff, 0x8000, x_I5_x, s7_do_xi5x},
1029 {"trapcc", 0x00000404, 0x3e007fff, 0x8000, x_I5_x, s7_do_xi5x},
1030 {"trapgtu", 0x00000804, 0x3e007fff, 0x8000, x_I5_x, s7_do_xi5x},
1031 {"trapleu", 0x00000c04, 0x3e007fff, 0x8000, x_I5_x, s7_do_xi5x},
1032 {"trapeq", 0x00001004, 0x3e007fff, 0x8000, x_I5_x, s7_do_xi5x},
1033 {"trapne", 0x00001404, 0x3e007fff, 0x8000, x_I5_x, s7_do_xi5x},
1034 {"trapgt", 0x00001804, 0x3e007fff, 0x8000, x_I5_x, s7_do_xi5x},
1035 {"traple", 0x00001c04, 0x3e007fff, 0x8000, x_I5_x, s7_do_xi5x},
1036 {"trapge", 0x00002004, 0x3e007fff, 0x8000, x_I5_x, s7_do_xi5x},
1037 {"traplt", 0x00002404, 0x3e007fff, 0x8000, x_I5_x, s7_do_xi5x},
1038 {"trapmi", 0x00002804, 0x3e007fff, 0x8000, x_I5_x, s7_do_xi5x},
1039 {"trappl", 0x00002c04, 0x3e007fff, 0x8000, x_I5_x, s7_do_xi5x},
1040 {"trapvs", 0x00003004, 0x3e007fff, 0x8000, x_I5_x, s7_do_xi5x},
1041 {"trapvc", 0x00003404, 0x3e007fff, 0x8000, x_I5_x, s7_do_xi5x},
1042 {"trap", 0x00003c04, 0x3e007fff, 0x8000, x_I5_x, s7_do_xi5x},
1043 {"tset", 0x00003c54, 0x3e007fff, 0x0f05, NO_OPD, s7_do_empty},
1044 {"tset!", 0x0f05, 0x00007f0f, 0x00003c54, NO16_OPD, s7_do_empty},
1045 {"tvs", 0x00003054, 0x3e007fff, 0x0c05, NO_OPD, s7_do_empty},
1046 {"tvc", 0x00003454, 0x3e007fff, 0x0d05, NO_OPD, s7_do_empty},
1047 {"tvs!", 0x0c05, 0x7f0f, 0x00003054, NO16_OPD, s7_do_empty},
1048 {"tvc!", 0x0d05, 0x7f0f, 0x00003454, NO16_OPD, s7_do_empty},
1049 {"xor", 0x00000026, 0x3e0003ff, 0x8000, Rd_Rs_Rs, s7_do_rdrsrs},
1050 {"xor.c", 0x00000027, 0x3e0003ff, 0x2007, Rd_Rs_Rs, s7_do_rdrsrs},
1051 {"xor!", 0x2007, 0x700f, 0x00000027, Rd_Rs, s7_do16_rdrs},
1052 /* Macro instruction. */
1053 {"li", 0x020c0000, 0x3e0e0000, 0x8000, Insn_Type_SYN, s7_do_macro_li_rdi32},
1054 /* la reg, imm32 -->(1) ldi reg, simm16
1055 (2) ldis reg, %HI(imm32)
1056 ori reg, %LO(imm32)
1057
1058 la reg, symbol -->(1) lis reg, %HI(imm32)
1059 ori reg, %LO(imm32) */
1060 {"la", 0x020c0000, 0x3e0e0000, 0x8000, Insn_Type_SYN, s7_do_macro_la_rdi32},
1061 {"div", 0x00000044, 0x3e0003ff, 0x8000, Insn_Type_SYN, s7_do_macro_mul_rdrsrs},
1062 {"divu", 0x00000046, 0x3e0003ff, 0x8000, Insn_Type_SYN, s7_do_macro_mul_rdrsrs},
1063 {"rem", 0x00000044, 0x3e0003ff, 0x8000, Insn_Type_SYN, s7_do_macro_mul_rdrsrs},
1064 {"remu", 0x00000046, 0x3e0003ff, 0x8000, Insn_Type_SYN, s7_do_macro_mul_rdrsrs},
1065 {"mul", 0x00000040, 0x3e0003ff, 0x8000, Insn_Type_SYN, s7_do_macro_mul_rdrsrs},
1066 {"mulu", 0x00000042, 0x3e0003ff, 0x8000, Insn_Type_SYN, s7_do_macro_mul_rdrsrs},
1067 {"maz", 0x00000040, 0x3e0003ff, 0x8000, Insn_Type_SYN, s7_do_macro_mul_rdrsrs},
1068 {"mazu", 0x00000042, 0x3e0003ff, 0x8000, Insn_Type_SYN, s7_do_macro_mul_rdrsrs},
1069 {"mul.f", 0x00000041, 0x3e0003ff, 0x8000, Insn_Type_SYN, s7_do_macro_mul_rdrsrs},
1070 {"maz.f", 0x00000041, 0x3e0003ff, 0x8000, Insn_Type_SYN, s7_do_macro_mul_rdrsrs},
1071 {"lb", INSN_LB, 0x00000000, 0x8000, Insn_Type_SYN, s7_do_macro_ldst_label},
1072 {"lbu", INSN_LBU, 0x00000000, 0x200b, Insn_Type_SYN, s7_do_macro_ldst_label},
1073 {"lh", INSN_LH, 0x00000000, 0x2009, Insn_Type_SYN, s7_do_macro_ldst_label},
1074 {"lhu", INSN_LHU, 0x00000000, 0x8000, Insn_Type_SYN, s7_do_macro_ldst_label},
1075 {"lw", INSN_LW, 0x00000000, 0x2008, Insn_Type_SYN, s7_do_macro_ldst_label},
1076 {"sb", INSN_SB, 0x00000000, 0x200f, Insn_Type_SYN, s7_do_macro_ldst_label},
1077 {"sh", INSN_SH, 0x00000000, 0x200d, Insn_Type_SYN, s7_do_macro_ldst_label},
1078 {"sw", INSN_SW, 0x00000000, 0x200c, Insn_Type_SYN, s7_do_macro_ldst_label},
1079 /* Assembler use internal. */
1080 {"ld_i32hi", 0x0a0c0000, 0x3e0e0000, 0x8000, Insn_internal, s7_do_macro_rdi32hi},
1081 {"ld_i32lo", 0x020a0000, 0x3e0e0001, 0x8000, Insn_internal, s7_do_macro_rdi32lo},
1082 {"ldis_pic", 0x0a0c0000, 0x3e0e0000, 0x5000, Insn_internal, s7_do_rdi16_pic},
1083 {"addi_s_pic",0x02000000, 0x3e0e0001, 0x8000, Insn_internal, s7_do_addi_s_pic},
1084 {"addi_u_pic",0x02000000, 0x3e0e0001, 0x8000, Insn_internal, s7_do_addi_u_pic},
1085 {"lw_pic", 0x20000000, 0x3e000000, 0x8000, Insn_internal, s7_do_lw_pic},
1086 };
1087
1088 #define s7_SCORE5_PIPELINE 5
1089 #define s7_SCORE7_PIPELINE 7
1090
1091 static int s7_university_version = 0;
1092 static int s7_vector_size = s7_SCORE7_PIPELINE;
1093 static struct s7_score_it s7_dependency_vector[s7_SCORE7_PIPELINE];
1094
1095 static int s7_score7d = 1;
1096
1097 \f
1098
1099 static int
1100 s7_end_of_line (char *str)
1101 {
1102 int retval = s7_SUCCESS;
1103
1104 s7_skip_whitespace (str);
1105 if (*str != '\0')
1106 {
1107 retval = (int) s7_FAIL;
1108
1109 if (!s7_inst.error)
1110 s7_inst.error = s7_BAD_GARBAGE;
1111 }
1112
1113 return retval;
1114 }
1115
1116 static int
1117 s7_score_reg_parse (char **ccp, struct hash_control *htab)
1118 {
1119 char *start = *ccp;
1120 char c;
1121 char *p;
1122 struct s7_reg_entry *reg;
1123
1124 p = start;
1125 if (!ISALPHA (*p) || !is_name_beginner (*p))
1126 return (int) s7_FAIL;
1127
1128 c = *p++;
1129
1130 while (ISALPHA (c) || ISDIGIT (c) || c == '_')
1131 c = *p++;
1132
1133 *--p = 0;
1134 reg = (struct s7_reg_entry *) hash_find (htab, start);
1135 *p = c;
1136
1137 if (reg)
1138 {
1139 *ccp = p;
1140 return reg->number;
1141 }
1142 return (int) s7_FAIL;
1143 }
1144
1145 /* If shift <= 0, only return reg. */
1146 static int
1147 s7_reg_required_here (char **str, int shift, enum s7_score_reg_type reg_type)
1148 {
1149 static char buff[s7_MAX_LITERAL_POOL_SIZE];
1150 int reg = (int) s7_FAIL;
1151 char *start = *str;
1152
1153 if ((reg = s7_score_reg_parse (str, s7_all_reg_maps[reg_type].htab)) != (int) s7_FAIL)
1154 {
1155 if (reg_type == s7_REG_TYPE_SCORE)
1156 {
1157 if ((reg == 1) && (s7_nor1 == 1) && (s7_inst.bwarn == 0))
1158 {
1159 as_warn (_("Using temp register(r1)"));
1160 s7_inst.bwarn = 1;
1161 }
1162 }
1163 if (shift >= 0)
1164 {
1165 if (reg_type == s7_REG_TYPE_SCORE_CR)
1166 strcpy (s7_inst.reg, s7_score_crn_table[reg].name);
1167 else if (reg_type == s7_REG_TYPE_SCORE_SR)
1168 strcpy (s7_inst.reg, s7_score_srn_table[reg].name);
1169 else
1170 strcpy (s7_inst.reg, "");
1171
1172 s7_inst.instruction |= reg << shift;
1173 }
1174 }
1175 else
1176 {
1177 *str = start;
1178 sprintf (buff, _("register expected, not '%.100s'"), start);
1179 s7_inst.error = buff;
1180 }
1181
1182 return reg;
1183 }
1184
1185 static int
1186 s7_skip_past_comma (char **str)
1187 {
1188 char *p = *str;
1189 char c;
1190 int comma = 0;
1191
1192 while ((c = *p) == ' ' || c == ',')
1193 {
1194 p++;
1195 if (c == ',' && comma++)
1196 {
1197 s7_inst.error = s7_BAD_SKIP_COMMA;
1198 return (int) s7_FAIL;
1199 }
1200 }
1201
1202 if ((c == '\0') || (comma == 0))
1203 {
1204 s7_inst.error = s7_BAD_SKIP_COMMA;
1205 return (int) s7_FAIL;
1206 }
1207
1208 *str = p;
1209 return comma ? s7_SUCCESS : (int) s7_FAIL;
1210 }
1211
1212 static void
1213 s7_do_rdrsrs (char *str)
1214 {
1215 s7_skip_whitespace (str);
1216
1217 if (s7_reg_required_here (&str, 20, s7_REG_TYPE_SCORE) == (int) s7_FAIL
1218 || s7_skip_past_comma (&str) == (int) s7_FAIL
1219 || s7_reg_required_here (&str, 15, s7_REG_TYPE_SCORE) == (int) s7_FAIL
1220 || s7_skip_past_comma (&str) == (int) s7_FAIL
1221 || s7_reg_required_here (&str, 10, s7_REG_TYPE_SCORE) == (int) s7_FAIL
1222 || s7_end_of_line (str) == (int) s7_FAIL)
1223 {
1224 return;
1225 }
1226 else
1227 {
1228 if ((((s7_inst.instruction >> 15) & 0x10) == 0)
1229 && (((s7_inst.instruction >> 10) & 0x10) == 0)
1230 && (((s7_inst.instruction >> 20) & 0x10) == 0)
1231 && (s7_inst.relax_inst != 0x8000)
1232 && (((s7_inst.instruction >> 20) & 0xf) == ((s7_inst.instruction >> 15) & 0xf)))
1233 {
1234 s7_inst.relax_inst |= (((s7_inst.instruction >> 10) & 0xf) << 4)
1235 | (((s7_inst.instruction >> 15) & 0xf) << 8);
1236 s7_inst.relax_size = 2;
1237 }
1238 else
1239 {
1240 s7_inst.relax_inst = 0x8000;
1241 }
1242 }
1243 }
1244
1245 static int
1246 s7_walk_no_bignums (symbolS * sp)
1247 {
1248 if (symbol_get_value_expression (sp)->X_op == O_big)
1249 return 1;
1250
1251 if (symbol_get_value_expression (sp)->X_add_symbol)
1252 return (s7_walk_no_bignums (symbol_get_value_expression (sp)->X_add_symbol)
1253 || (symbol_get_value_expression (sp)->X_op_symbol
1254 && s7_walk_no_bignums (symbol_get_value_expression (sp)->X_op_symbol)));
1255
1256 return 0;
1257 }
1258
1259 static int
1260 s7_my_get_expression (expressionS * ep, char **str)
1261 {
1262 char *save_in;
1263 segT seg;
1264
1265 save_in = input_line_pointer;
1266 input_line_pointer = *str;
1267 s7_in_my_get_expression = 1;
1268 seg = expression (ep);
1269 s7_in_my_get_expression = 0;
1270
1271 if (ep->X_op == O_illegal)
1272 {
1273 *str = input_line_pointer;
1274 input_line_pointer = save_in;
1275 s7_inst.error = _("illegal expression");
1276 return (int) s7_FAIL;
1277 }
1278 /* Get rid of any bignums now, so that we don't generate an error for which
1279 we can't establish a line number later on. Big numbers are never valid
1280 in instructions, which is where this routine is always called. */
1281 if (ep->X_op == O_big
1282 || (ep->X_add_symbol
1283 && (s7_walk_no_bignums (ep->X_add_symbol)
1284 || (ep->X_op_symbol && s7_walk_no_bignums (ep->X_op_symbol)))))
1285 {
1286 s7_inst.error = _("invalid constant");
1287 *str = input_line_pointer;
1288 input_line_pointer = save_in;
1289 return (int) s7_FAIL;
1290 }
1291
1292 if ((ep->X_add_symbol != NULL)
1293 && (s7_inst.type != PC_DISP19div2)
1294 && (s7_inst.type != PC_DISP8div2)
1295 && (s7_inst.type != PC_DISP24div2)
1296 && (s7_inst.type != PC_DISP11div2)
1297 && (s7_inst.type != Insn_Type_SYN)
1298 && (s7_inst.type != Rd_rvalueRs_SI15)
1299 && (s7_inst.type != Rd_lvalueRs_SI15)
1300 && (s7_inst.type != Insn_internal))
1301 {
1302 s7_inst.error = s7_BAD_ARGS;
1303 *str = input_line_pointer;
1304 input_line_pointer = save_in;
1305 return (int) s7_FAIL;
1306 }
1307
1308 *str = input_line_pointer;
1309 input_line_pointer = save_in;
1310 return s7_SUCCESS;
1311 }
1312
1313 /* Check if an immediate is valid. If so, convert it to the right format. */
1314
1315 static bfd_signed_vma
1316 s7_validate_immediate (bfd_signed_vma val, unsigned int data_type, int hex_p)
1317 {
1318 switch (data_type)
1319 {
1320 case _VALUE_HI16:
1321 {
1322 int val_hi = ((val & 0xffff0000) >> 16);
1323
1324 if (s7_score_df_range[data_type].range[0] <= val_hi
1325 && val_hi <= s7_score_df_range[data_type].range[1])
1326 return val_hi;
1327 }
1328 break;
1329
1330 case _VALUE_LO16:
1331 {
1332 int val_lo = (val & 0xffff);
1333
1334 if (s7_score_df_range[data_type].range[0] <= val_lo
1335 && val_lo <= s7_score_df_range[data_type].range[1])
1336 return val_lo;
1337 }
1338 break;
1339
1340 case _SIMM12:
1341 if (hex_p == 1)
1342 {
1343 if (!(val >= -0x800 && val <= 0xfff))
1344 {
1345 return (int) s7_FAIL;
1346 }
1347 }
1348 else
1349 {
1350 if (!(val >= -2048 && val <= 2047))
1351 {
1352 return (int) s7_FAIL;
1353 }
1354 }
1355
1356 return val;
1357 break;
1358
1359 case _SIMM14:
1360 if (hex_p == 1)
1361 {
1362 if (!(val >= -0x2000 && val <= 0x3fff))
1363 {
1364 return (int) s7_FAIL;
1365 }
1366 }
1367 else
1368 {
1369 if (!(val >= -8192 && val <= 8191))
1370 {
1371 return (int) s7_FAIL;
1372 }
1373 }
1374
1375 return val;
1376 break;
1377
1378 case _SIMM15:
1379 if (hex_p == 1)
1380 {
1381 if (!(val >= -0x4000 && val <= 0x7fff))
1382 {
1383 return (int) s7_FAIL;
1384 }
1385 }
1386 else
1387 {
1388 if (!(val >= -16384 && val <= 16383))
1389 {
1390 return (int) s7_FAIL;
1391 }
1392 }
1393
1394 return val;
1395 break;
1396
1397 case _SIMM16:
1398 if (hex_p == 1)
1399 {
1400 if (!(val >= -0x8000 && val <= 0xffff))
1401 {
1402 return (int) s7_FAIL;
1403 }
1404 }
1405 else
1406 {
1407 if (!(val >= -32768 && val <= 32767))
1408 {
1409 return (int) s7_FAIL;
1410 }
1411 }
1412
1413 return val;
1414 break;
1415
1416 case _SIMM16_NEG:
1417 if (hex_p == 1)
1418 {
1419 if (!(val >= -0x7fff && val <= 0xffff && val != 0x8000))
1420 {
1421 return (int) s7_FAIL;
1422 }
1423 }
1424 else
1425 {
1426 if (!(val >= -32767 && val <= 32768))
1427 {
1428 return (int) s7_FAIL;
1429 }
1430 }
1431
1432 val = -val;
1433 return val;
1434 break;
1435
1436 case _IMM32:
1437 if (val >= 0 && val <= 0xffffffff)
1438 {
1439 return val;
1440 }
1441 else
1442 {
1443 return (int) s7_FAIL;
1444 }
1445
1446 default:
1447 if (data_type == _SIMM14_NEG || data_type == _IMM16_NEG)
1448 val = -val;
1449
1450 if (s7_score_df_range[data_type].range[0] <= val
1451 && val <= s7_score_df_range[data_type].range[1])
1452 return val;
1453
1454 break;
1455 }
1456
1457 return (int) s7_FAIL;
1458 }
1459
1460 static int
1461 s7_data_op2 (char **str, int shift, enum score_data_type data_type)
1462 {
1463 int value;
1464 char data_exp[s7_MAX_LITERAL_POOL_SIZE];
1465 char *dataptr;
1466 int cnt = 0;
1467 char *pp = NULL;
1468
1469 s7_skip_whitespace (*str);
1470 s7_inst.error = NULL;
1471 dataptr = * str;
1472
1473 /* Set hex_p to zero. */
1474 int hex_p = 0;
1475
1476 while ((*dataptr != '\0') && (*dataptr != '|') && (cnt <= s7_MAX_LITERAL_POOL_SIZE)) /* 0x7c = ='|' */
1477 {
1478 data_exp[cnt] = *dataptr;
1479 dataptr++;
1480 cnt++;
1481 }
1482
1483 data_exp[cnt] = '\0';
1484 pp = (char *)&data_exp;
1485
1486 if (*dataptr == '|') /* process PCE */
1487 {
1488 if (s7_my_get_expression (&s7_inst.reloc.exp, &pp) == (int) s7_FAIL)
1489 return (int) s7_FAIL;
1490 s7_end_of_line (pp);
1491 if (s7_inst.error != 0)
1492 return (int) s7_FAIL; /* to ouptut_inst to printf out the error */
1493 *str = dataptr;
1494 }
1495 else /* process 16 bit */
1496 {
1497 if (s7_my_get_expression (&s7_inst.reloc.exp, str) == (int) s7_FAIL)
1498 {
1499 return (int) s7_FAIL;
1500 }
1501
1502 dataptr = (char *) data_exp;
1503 for (; *dataptr != '\0'; dataptr++)
1504 {
1505 *dataptr = TOLOWER (*dataptr);
1506 if (*dataptr == '!' || *dataptr == ' ')
1507 break;
1508 }
1509 dataptr = (char *) data_exp;
1510
1511 if ((dataptr != NULL)
1512 && (((strstr (dataptr, "0x")) != NULL)
1513 || ((strstr (dataptr, "0X")) != NULL)))
1514 {
1515 hex_p = 1;
1516 if ((data_type != _SIMM16_LA)
1517 && (data_type != _VALUE_HI16)
1518 && (data_type != _VALUE_LO16)
1519 && (data_type != _IMM16)
1520 && (data_type != _IMM15)
1521 && (data_type != _IMM14)
1522 && (data_type != _IMM4)
1523 && (data_type != _IMM5)
1524 && (data_type != _IMM8)
1525 && (data_type != _IMM5_RSHIFT_1)
1526 && (data_type != _IMM5_RSHIFT_2)
1527 && (data_type != _SIMM14)
1528 && (data_type != _SIMM16)
1529 && (data_type != _SIMM14_NEG)
1530 && (data_type != _SIMM16_NEG)
1531 && (data_type != _IMM10_RSHIFT_2)
1532 && (data_type != _GP_IMM15))
1533 {
1534 data_type += 24;
1535 }
1536 }
1537
1538 if ((s7_inst.reloc.exp.X_add_number == 0)
1539 /* for "addi r0,-((((((32*4)+4)+4)+4)+4)&0xf)". */
1540 && (s7_inst.type != Rd_SI16)
1541 && (s7_inst.type != Insn_Type_SYN)
1542 && (s7_inst.type != Rd_rvalueRs_SI15)
1543 && (s7_inst.type != Rd_lvalueRs_SI15)
1544 && (s7_inst.type != Insn_internal)
1545 && (((*dataptr >= 'a') && (*dataptr <= 'z'))
1546 || ((*dataptr == '0') && (*(dataptr + 1) == 'x') && (*(dataptr + 2) != '0'))
1547 || ((*dataptr == '+') && (*(dataptr + 1) != '0'))
1548 || ((*dataptr == '-') && (*(dataptr + 1) != '0'))))
1549 {
1550 s7_inst.error = s7_BAD_ARGS;
1551 return (int) s7_FAIL;
1552 }
1553 }
1554
1555 if ((s7_inst.reloc.exp.X_add_symbol)
1556 && ((data_type == _SIMM16)
1557 || (data_type == _SIMM16_NEG)
1558 || (data_type == _IMM16_NEG)
1559 || (data_type == _SIMM14)
1560 || (data_type == _SIMM14_NEG)
1561 || (data_type == _IMM5)
1562 || (data_type == _IMM14)
1563 || (data_type == _IMM20)
1564 || (data_type == _IMM16)
1565 || (data_type == _IMM15)
1566 || (data_type == _IMM4)))
1567 {
1568 s7_inst.error = s7_BAD_ARGS;
1569 return (int) s7_FAIL;
1570 }
1571
1572 if (s7_inst.reloc.exp.X_add_symbol)
1573 {
1574 switch (data_type)
1575 {
1576 case _SIMM16_LA:
1577 return (int) s7_FAIL;
1578 case _VALUE_HI16:
1579 s7_inst.reloc.type = BFD_RELOC_HI16_S;
1580 s7_inst.reloc.pc_rel = 0;
1581 break;
1582 case _VALUE_LO16:
1583 s7_inst.reloc.type = BFD_RELOC_LO16;
1584 s7_inst.reloc.pc_rel = 0;
1585 break;
1586 case _GP_IMM15:
1587 s7_inst.reloc.type = BFD_RELOC_SCORE_GPREL15;
1588 s7_inst.reloc.pc_rel = 0;
1589 break;
1590 case _SIMM16_pic:
1591 case _IMM16_LO16_pic:
1592 s7_inst.reloc.type = BFD_RELOC_SCORE_GOT_LO16;
1593 s7_inst.reloc.pc_rel = 0;
1594 break;
1595 default:
1596 s7_inst.reloc.type = BFD_RELOC_32;
1597 s7_inst.reloc.pc_rel = 0;
1598 break;
1599 }
1600 }
1601 else
1602 {
1603 if (data_type == _IMM16_pic)
1604 {
1605 s7_inst.reloc.type = BFD_RELOC_SCORE_DUMMY_HI16;
1606 s7_inst.reloc.pc_rel = 0;
1607 }
1608
1609 if (data_type == _SIMM16_LA && s7_inst.reloc.exp.X_unsigned == 1)
1610 {
1611 value = s7_validate_immediate (s7_inst.reloc.exp.X_add_number, _SIMM16_LA_POS, hex_p);
1612 if (value == (int) s7_FAIL) /* for advance to check if this is ldis */
1613 if ((s7_inst.reloc.exp.X_add_number & 0xffff) == 0)
1614 {
1615 s7_inst.instruction |= 0x8000000;
1616 s7_inst.instruction |= ((s7_inst.reloc.exp.X_add_number >> 16) << 1) & 0x1fffe;
1617 return s7_SUCCESS;
1618 }
1619 }
1620 else
1621 {
1622 value = s7_validate_immediate (s7_inst.reloc.exp.X_add_number, data_type, hex_p);
1623 }
1624
1625 if (value == (int) s7_FAIL)
1626 {
1627 if ((data_type != _SIMM14_NEG) && (data_type != _SIMM16_NEG) && (data_type != _IMM16_NEG))
1628 {
1629 sprintf (s7_err_msg,
1630 _("invalid constant: %d bit expression not in range %d..%d"),
1631 s7_score_df_range[data_type].bits,
1632 s7_score_df_range[data_type].range[0], s7_score_df_range[data_type].range[1]);
1633 }
1634 else
1635 {
1636 sprintf (s7_err_msg,
1637 _("invalid constant: %d bit expression not in range %d..%d"),
1638 s7_score_df_range[data_type].bits,
1639 -s7_score_df_range[data_type].range[1], -s7_score_df_range[data_type].range[0]);
1640 }
1641
1642 s7_inst.error = s7_err_msg;
1643 return (int) s7_FAIL;
1644 }
1645
1646 if ((s7_score_df_range[data_type].range[0] != 0) || (data_type == _IMM5_RANGE_8_31))
1647 {
1648 value &= (1 << s7_score_df_range[data_type].bits) - 1;
1649 }
1650
1651 s7_inst.instruction |= value << shift;
1652 }
1653
1654 if ((s7_inst.instruction & 0x3e000000) == 0x30000000)
1655 {
1656 if ((((s7_inst.instruction >> 20) & 0x1F) != 0)
1657 && (((s7_inst.instruction >> 20) & 0x1F) != 1)
1658 && (((s7_inst.instruction >> 20) & 0x1F) != 2)
1659 && (((s7_inst.instruction >> 20) & 0x1F) != 3)
1660 && (((s7_inst.instruction >> 20) & 0x1F) != 4)
1661 && (((s7_inst.instruction >> 20) & 0x1F) != 8)
1662 && (((s7_inst.instruction >> 20) & 0x1F) != 9)
1663 && (((s7_inst.instruction >> 20) & 0x1F) != 0xa)
1664 && (((s7_inst.instruction >> 20) & 0x1F) != 0xb)
1665 && (((s7_inst.instruction >> 20) & 0x1F) != 0xc)
1666 && (((s7_inst.instruction >> 20) & 0x1F) != 0xd)
1667 && (((s7_inst.instruction >> 20) & 0x1F) != 0xe)
1668 && (((s7_inst.instruction >> 20) & 0x1F) != 0x10)
1669 && (((s7_inst.instruction >> 20) & 0x1F) != 0x11)
1670 && (((s7_inst.instruction >> 20) & 0x1F) != 0x18)
1671 && (((s7_inst.instruction >> 20) & 0x1F) != 0x1A)
1672 && (((s7_inst.instruction >> 20) & 0x1F) != 0x1B)
1673 && (((s7_inst.instruction >> 20) & 0x1F) != 0x1d)
1674 && (((s7_inst.instruction >> 20) & 0x1F) != 0x1e)
1675 && (((s7_inst.instruction >> 20) & 0x1F) != 0x1f))
1676 {
1677 s7_inst.error = _("invalid constant: bit expression not defined");
1678 return (int) s7_FAIL;
1679 }
1680 }
1681
1682 return s7_SUCCESS;
1683 }
1684
1685 /* Handle addi/addi.c/addis.c/cmpi.c/addis.c/ldi. */
1686
1687 static void
1688 s7_do_rdsi16 (char *str)
1689 {
1690 s7_skip_whitespace (str);
1691
1692 if (s7_reg_required_here (&str, 20, s7_REG_TYPE_SCORE) == (int) s7_FAIL
1693 || s7_skip_past_comma (&str) == (int) s7_FAIL
1694 || s7_data_op2 (&str, 1, _SIMM16) == (int) s7_FAIL
1695 || s7_end_of_line (str) == (int) s7_FAIL)
1696 return;
1697
1698 /* ldi. */
1699 if ((s7_inst.instruction & 0x20c0000) == 0x20c0000)
1700 {
1701 if ((((s7_inst.instruction >> 20) & 0x10) == 0x10) || ((s7_inst.instruction & 0x1fe00) != 0))
1702 {
1703 s7_inst.relax_inst = 0x8000;
1704 }
1705 else
1706 {
1707 s7_inst.relax_inst |= (s7_inst.instruction >> 1) & 0xff;
1708 s7_inst.relax_inst |= (((s7_inst.instruction >> 20) & 0xf) << 8);
1709 s7_inst.relax_size = 2;
1710 }
1711 }
1712 else if (((s7_inst.instruction >> 20) & 0x10) == 0x10)
1713 {
1714 s7_inst.relax_inst = 0x8000;
1715 }
1716 }
1717
1718 /* Handle subi/subi.c. */
1719
1720 static void
1721 s7_do_sub_rdsi16 (char *str)
1722 {
1723 s7_skip_whitespace (str);
1724
1725 if (s7_reg_required_here (&str, 20, s7_REG_TYPE_SCORE) != (int) s7_FAIL
1726 && s7_skip_past_comma (&str) != (int) s7_FAIL
1727 && s7_data_op2 (&str, 1, _SIMM16_NEG) != (int) s7_FAIL)
1728 s7_end_of_line (str);
1729 }
1730
1731
1732 /* Handle addri/addri.c. */
1733
1734 static void
1735 s7_do_rdrssi14 (char *str) /* -(2^13)~((2^13)-1) */
1736 {
1737 s7_skip_whitespace (str);
1738
1739 if (s7_reg_required_here (&str, 20, s7_REG_TYPE_SCORE) != (int) s7_FAIL
1740 && s7_skip_past_comma (&str) != (int) s7_FAIL
1741 && s7_reg_required_here (&str, 15, s7_REG_TYPE_SCORE) != (int) s7_FAIL
1742 && s7_skip_past_comma (&str) != (int) s7_FAIL)
1743 s7_data_op2 (&str, 1, _SIMM14);
1744 }
1745
1746 /* Handle subri.c/subri. */
1747
1748 static void
1749 s7_do_sub_rdrssi14 (char *str) /* -(2^13)~((2^13)-1) */
1750 {
1751 s7_skip_whitespace (str);
1752
1753 if (s7_reg_required_here (&str, 20, s7_REG_TYPE_SCORE) != (int) s7_FAIL
1754 && s7_skip_past_comma (&str) != (int) s7_FAIL
1755 && s7_reg_required_here (&str, 15, s7_REG_TYPE_SCORE) != (int) s7_FAIL
1756 && s7_skip_past_comma (&str) != (int) s7_FAIL
1757 && s7_data_op2 (&str, 1, _SIMM14_NEG) != (int) s7_FAIL)
1758 s7_end_of_line (str);
1759 }
1760
1761 /* Handle bitclr.c/bitset.c/bittgl.c/slli.c/srai.c/srli.c/roli.c/rori.c/rolic.c. */
1762
1763 static void
1764 s7_do_rdrsi5 (char *str) /* 0~((2^14)-1) */
1765 {
1766 s7_skip_whitespace (str);
1767
1768 if (s7_reg_required_here (&str, 20, s7_REG_TYPE_SCORE) == (int) s7_FAIL
1769 || s7_skip_past_comma (&str) == (int) s7_FAIL
1770 || s7_reg_required_here (&str, 15, s7_REG_TYPE_SCORE) == (int) s7_FAIL
1771 || s7_skip_past_comma (&str) == (int) s7_FAIL
1772 || s7_data_op2 (&str, 10, _IMM5) == (int) s7_FAIL
1773 || s7_end_of_line (str) == (int) s7_FAIL)
1774 return;
1775
1776 if ((((s7_inst.instruction >> 20) & 0x1f) == ((s7_inst.instruction >> 15) & 0x1f))
1777 && (s7_inst.relax_inst != 0x8000) && (((s7_inst.instruction >> 15) & 0x10) == 0))
1778 {
1779 s7_inst.relax_inst |= (((s7_inst.instruction >> 10) & 0x1f) << 3) | (((s7_inst.instruction >> 15) & 0xf) << 8);
1780 s7_inst.relax_size = 2;
1781 }
1782 else
1783 s7_inst.relax_inst = 0x8000;
1784 }
1785
1786 /* Handle andri/orri/andri.c/orri.c. */
1787
1788 static void
1789 s7_do_rdrsi14 (char *str) /* 0 ~ ((2^14)-1) */
1790 {
1791 s7_skip_whitespace (str);
1792
1793 if (s7_reg_required_here (&str, 20, s7_REG_TYPE_SCORE) != (int) s7_FAIL
1794 && s7_skip_past_comma (&str) != (int) s7_FAIL
1795 && s7_reg_required_here (&str, 15, s7_REG_TYPE_SCORE) != (int) s7_FAIL
1796 && s7_skip_past_comma (&str) != (int) s7_FAIL
1797 && s7_data_op2 (&str, 1, _IMM14) != (int) s7_FAIL)
1798 s7_end_of_line (str);
1799 }
1800
1801 /* Handle bittst.c. */
1802
1803 static void
1804 s7_do_xrsi5 (char *str)
1805 {
1806 s7_skip_whitespace (str);
1807
1808 if (s7_reg_required_here (&str, 15, s7_REG_TYPE_SCORE) == (int) s7_FAIL
1809 || s7_skip_past_comma (&str) == (int) s7_FAIL
1810 || s7_data_op2 (&str, 10, _IMM5) == (int) s7_FAIL
1811 || s7_end_of_line (str) == (int) s7_FAIL)
1812 return;
1813
1814 if ((s7_inst.relax_inst != 0x8000) && (((s7_inst.instruction >> 15) & 0x10) == 0))
1815 {
1816 s7_inst.relax_inst |= (((s7_inst.instruction >> 10) & 0x1f) << 3) | (((s7_inst.instruction >> 15) & 0xf) << 8);
1817 s7_inst.relax_size = 2;
1818 }
1819 else
1820 s7_inst.relax_inst = 0x8000;
1821 }
1822
1823 /* Handle addis/andi/ori/andis/oris/ldis. */
1824
1825 static void
1826 s7_do_rdi16 (char *str)
1827 {
1828 s7_skip_whitespace (str);
1829
1830 if (s7_reg_required_here (&str, 20, s7_REG_TYPE_SCORE) == (int) s7_FAIL
1831 || s7_skip_past_comma (&str) == (int) s7_FAIL
1832 || s7_data_op2 (&str, 1, _IMM16) == (int) s7_FAIL
1833 || s7_end_of_line (str) == (int) s7_FAIL)
1834 return;
1835 }
1836
1837 static void
1838 s7_do_macro_rdi32hi (char *str)
1839 {
1840 s7_skip_whitespace (str);
1841
1842 /* Do not handle s7_end_of_line(). */
1843 if (s7_reg_required_here (&str, 20, s7_REG_TYPE_SCORE) != (int) s7_FAIL
1844 && s7_skip_past_comma (&str) != (int) s7_FAIL)
1845 s7_data_op2 (&str, 1, _VALUE_HI16);
1846 }
1847
1848 static void
1849 s7_do_macro_rdi32lo (char *str)
1850 {
1851 s7_skip_whitespace (str);
1852
1853 /* Do not handle s7_end_of_line(). */
1854 if (s7_reg_required_here (&str, 20, s7_REG_TYPE_SCORE) != (int) s7_FAIL
1855 && s7_skip_past_comma (&str) != (int) s7_FAIL)
1856 s7_data_op2 (&str, 1, _VALUE_LO16);
1857 }
1858
1859 /* Handle ldis_pic. */
1860
1861 static void
1862 s7_do_rdi16_pic (char *str)
1863 {
1864 s7_skip_whitespace (str);
1865
1866 if (s7_reg_required_here (&str, 20, s7_REG_TYPE_SCORE) != (int) s7_FAIL
1867 && s7_skip_past_comma (&str) != (int) s7_FAIL
1868 && s7_data_op2 (&str, 1, _IMM16_pic) != (int) s7_FAIL)
1869 s7_end_of_line (str);
1870 }
1871
1872 /* Handle addi_s_pic to generate R_SCORE_GOT_LO16 . */
1873
1874 static void
1875 s7_do_addi_s_pic (char *str)
1876 {
1877 s7_skip_whitespace (str);
1878
1879 if (s7_reg_required_here (&str, 20, s7_REG_TYPE_SCORE) != (int) s7_FAIL
1880 && s7_skip_past_comma (&str) != (int) s7_FAIL
1881 && s7_data_op2 (&str, 1, _SIMM16_pic) != (int) s7_FAIL)
1882 s7_end_of_line (str);
1883 }
1884
1885 /* Handle addi_u_pic to generate R_SCORE_GOT_LO16 . */
1886
1887 static void
1888 s7_do_addi_u_pic (char *str)
1889 {
1890 s7_skip_whitespace (str);
1891
1892 if (s7_reg_required_here (&str, 20, s7_REG_TYPE_SCORE) != (int) s7_FAIL
1893 && s7_skip_past_comma (&str) != (int) s7_FAIL
1894 && s7_data_op2 (&str, 1, _IMM16_LO16_pic) != (int) s7_FAIL)
1895 s7_end_of_line (str);
1896 }
1897
1898 /* Handle mfceh/mfcel/mtceh/mtchl. */
1899
1900 static void
1901 s7_do_rd (char *str)
1902 {
1903 s7_skip_whitespace (str);
1904
1905 if (s7_reg_required_here (&str, 20, s7_REG_TYPE_SCORE) != (int) s7_FAIL)
1906 s7_end_of_line (str);
1907 }
1908
1909 static void
1910 s7_do_rs (char *str)
1911 {
1912 s7_skip_whitespace (str);
1913
1914 if (s7_reg_required_here (&str, 15, s7_REG_TYPE_SCORE) == (int) s7_FAIL
1915 || s7_end_of_line (str) == (int) s7_FAIL)
1916 return;
1917
1918 if ((s7_inst.relax_inst != 0x8000) && (((s7_inst.instruction >> 15) & 0x10) == 0))
1919 {
1920 s7_inst.relax_inst |= (((s7_inst.instruction >> 10) & 0xf) << 8) | (((s7_inst.instruction >> 15) & 0xf) << 4);
1921 s7_inst.relax_size = 2;
1922 }
1923 else
1924 s7_inst.relax_inst = 0x8000;
1925 }
1926
1927 static void
1928 s7_do_i15 (char *str)
1929 {
1930 s7_skip_whitespace (str);
1931
1932 if (s7_data_op2 (&str, 10, _IMM15) != (int) s7_FAIL)
1933 s7_end_of_line (str);
1934 }
1935
1936 static void
1937 s7_do_xi5x (char *str)
1938 {
1939 s7_skip_whitespace (str);
1940
1941 if (s7_data_op2 (&str, 15, _IMM5) == (int) s7_FAIL || s7_end_of_line (str) == (int) s7_FAIL)
1942 return;
1943
1944 if (s7_inst.relax_inst != 0x8000)
1945 {
1946 s7_inst.relax_inst |= (((s7_inst.instruction >> 15) & 0x1f) << 3);
1947 s7_inst.relax_size = 2;
1948 }
1949 }
1950
1951 static void
1952 s7_do_rdrs (char *str)
1953 {
1954 s7_skip_whitespace (str);
1955
1956 if (s7_reg_required_here (&str, 20, s7_REG_TYPE_SCORE) == (int) s7_FAIL
1957 || s7_skip_past_comma (&str) == (int) s7_FAIL
1958 || s7_reg_required_here (&str, 15, s7_REG_TYPE_SCORE) == (int) s7_FAIL
1959 || s7_end_of_line (str) == (int) s7_FAIL)
1960 return;
1961
1962 if (s7_inst.relax_inst != 0x8000)
1963 {
1964 if (((s7_inst.instruction & 0x7f) == 0x56)) /* adjust mv -> mv! / mlfh! / mhfl! */
1965 {
1966 /* mlfh */
1967 if ((((s7_inst.instruction >> 15) & 0x10) != 0x0) && (((s7_inst.instruction >> 20) & 0x10) == 0))
1968 {
1969 s7_inst.relax_inst = 0x00000001 | (((s7_inst.instruction >> 15) & 0xf) << 4)
1970 | (((s7_inst.instruction >> 20) & 0xf) << 8);
1971 s7_inst.relax_size = 2;
1972 }
1973 /* mhfl */
1974 else if ((((s7_inst.instruction >> 15) & 0x10) == 0x0) && ((s7_inst.instruction >> 20) & 0x10) != 0)
1975 {
1976 s7_inst.relax_inst = 0x00000002 | (((s7_inst.instruction >> 15) & 0xf) << 4)
1977 | (((s7_inst.instruction >> 20) & 0xf) << 8);
1978 s7_inst.relax_size = 2;
1979 }
1980 else if ((((s7_inst.instruction >> 15) & 0x10) == 0x0) && (((s7_inst.instruction >> 20) & 0x10) == 0))
1981 {
1982 s7_inst.relax_inst |= (((s7_inst.instruction >> 15) & 0xf) << 4)
1983 | (((s7_inst.instruction >> 20) & 0xf) << 8);
1984 s7_inst.relax_size = 2;
1985 }
1986 else
1987 {
1988 s7_inst.relax_inst = 0x8000;
1989 }
1990 }
1991 else if ((((s7_inst.instruction >> 15) & 0x10) == 0x0) && (((s7_inst.instruction >> 20) & 0x10) == 0))
1992 {
1993 s7_inst.relax_inst |= (((s7_inst.instruction >> 15) & 0xf) << 4)
1994 | (((s7_inst.instruction >> 20) & 0xf) << 8);
1995 s7_inst.relax_size = 2;
1996 }
1997 else
1998 {
1999 s7_inst.relax_inst = 0x8000;
2000 }
2001 }
2002 }
2003
2004 /* Handle mfcr/mtcr. */
2005 static void
2006 s7_do_rdcrs (char *str)
2007 {
2008 s7_skip_whitespace (str);
2009
2010 if (s7_reg_required_here (&str, 20, s7_REG_TYPE_SCORE) != (int) s7_FAIL
2011 && s7_skip_past_comma (&str) != (int) s7_FAIL
2012 && s7_reg_required_here (&str, 15, s7_REG_TYPE_SCORE_CR) != (int) s7_FAIL)
2013 s7_end_of_line (str);
2014 }
2015
2016 /* Handle mfsr/mtsr. */
2017
2018 static void
2019 s7_do_rdsrs (char *str)
2020 {
2021 s7_skip_whitespace (str);
2022
2023 /* mfsr */
2024 if ((s7_inst.instruction & 0xff) == 0x50)
2025 {
2026 if (s7_reg_required_here (&str, 20, s7_REG_TYPE_SCORE) != (int) s7_FAIL
2027 && s7_skip_past_comma (&str) != (int) s7_FAIL
2028 && s7_reg_required_here (&str, 10, s7_REG_TYPE_SCORE_SR) != (int) s7_FAIL)
2029 s7_end_of_line (str);
2030 }
2031 else
2032 {
2033 if (s7_reg_required_here (&str, 15, s7_REG_TYPE_SCORE) != (int) s7_FAIL
2034 && s7_skip_past_comma (&str) != (int) s7_FAIL)
2035 s7_reg_required_here (&str, 10, s7_REG_TYPE_SCORE_SR);
2036 }
2037 }
2038
2039 /* Handle neg. */
2040
2041 static void
2042 s7_do_rdxrs (char *str)
2043 {
2044 s7_skip_whitespace (str);
2045
2046 if (s7_reg_required_here (&str, 20, s7_REG_TYPE_SCORE) == (int) s7_FAIL
2047 || s7_skip_past_comma (&str) == (int) s7_FAIL
2048 || s7_reg_required_here (&str, 10, s7_REG_TYPE_SCORE) == (int) s7_FAIL
2049 || s7_end_of_line (str) == (int) s7_FAIL)
2050 return;
2051
2052 if ((s7_inst.relax_inst != 0x8000) && (((s7_inst.instruction >> 10) & 0x10) == 0)
2053 && (((s7_inst.instruction >> 20) & 0x10) == 0))
2054 {
2055 s7_inst.relax_inst |= (((s7_inst.instruction >> 10) & 0xf) << 4) | (((s7_inst.instruction >> 20) & 0xf) << 8);
2056 s7_inst.relax_size = 2;
2057 }
2058 else
2059 s7_inst.relax_inst = 0x8000;
2060 }
2061
2062 /* Handle cmp.c/cmp<cond>. */
2063 static void
2064 s7_do_rsrs (char *str)
2065 {
2066 s7_skip_whitespace (str);
2067
2068 if (s7_reg_required_here (&str, 15, s7_REG_TYPE_SCORE) == (int) s7_FAIL
2069 || s7_skip_past_comma (&str) == (int) s7_FAIL
2070 || s7_reg_required_here (&str, 10, s7_REG_TYPE_SCORE) == (int) s7_FAIL
2071 || s7_end_of_line (str) == (int) s7_FAIL)
2072 return;
2073
2074 if ((s7_inst.relax_inst != 0x8000) && (((s7_inst.instruction >> 20) & 0x1f) == 3)
2075 && (((s7_inst.instruction >> 10) & 0x10) == 0) && (((s7_inst.instruction >> 15) & 0x10) == 0))
2076 {
2077 s7_inst.relax_inst |= (((s7_inst.instruction >> 10) & 0xf) << 4) | (((s7_inst.instruction >> 15) & 0xf) << 8);
2078 s7_inst.relax_size = 2;
2079 }
2080 else
2081 s7_inst.relax_inst = 0x8000;
2082 }
2083
2084 static void
2085 s7_do_ceinst (char *str)
2086 {
2087 char *strbak;
2088
2089 strbak = str;
2090 s7_skip_whitespace (str);
2091
2092 if (s7_data_op2 (&str, 20, _IMM5) == (int) s7_FAIL
2093 || s7_skip_past_comma (&str) == (int) s7_FAIL
2094 || s7_reg_required_here (&str, 15, s7_REG_TYPE_SCORE) == (int) s7_FAIL
2095 || s7_skip_past_comma (&str) == (int) s7_FAIL
2096 || s7_reg_required_here (&str, 10, s7_REG_TYPE_SCORE) == (int) s7_FAIL
2097 || s7_skip_past_comma (&str) == (int) s7_FAIL
2098 || s7_data_op2 (&str, 5, _IMM5) == (int) s7_FAIL
2099 || s7_skip_past_comma (&str) == (int) s7_FAIL
2100 || s7_data_op2 (&str, 0, _IMM5) == (int) s7_FAIL
2101 || s7_end_of_line (str) == (int) s7_FAIL)
2102 {
2103 return;
2104 }
2105 else
2106 {
2107 str = strbak;
2108 if (s7_data_op2 (&str, 0, _IMM25) == (int) s7_FAIL)
2109 return;
2110 }
2111 }
2112
2113 static int
2114 s7_reglow_required_here (char **str, int shift)
2115 {
2116 static char buff[s7_MAX_LITERAL_POOL_SIZE];
2117 int reg;
2118 char *start = *str;
2119
2120 if ((reg = s7_score_reg_parse (str, s7_all_reg_maps[s7_REG_TYPE_SCORE].htab)) != (int) s7_FAIL)
2121 {
2122 if ((reg == 1) && (s7_nor1 == 1) && (s7_inst.bwarn == 0))
2123 {
2124 as_warn (_("Using temp register(r1)"));
2125 s7_inst.bwarn = 1;
2126 }
2127 if (reg < 16)
2128 {
2129 if (shift >= 0)
2130 s7_inst.instruction |= reg << shift;
2131
2132 return reg;
2133 }
2134 }
2135
2136 /* Restore the start point, we may have got a reg of the wrong class. */
2137 *str = start;
2138 sprintf (buff, _("low register(r0-r15)expected, not '%.100s'"), start);
2139 s7_inst.error = buff;
2140 return (int) s7_FAIL;
2141 }
2142
2143 /* Handle addc!/add!/and!/cmp!/neg!/not!/or!/sll!/srl!/sra!/xor!/sub!. */
2144
2145 static void
2146 s7_do16_rdrs (char *str)
2147 {
2148 s7_skip_whitespace (str);
2149
2150 if (s7_reglow_required_here (&str, 8) == (int) s7_FAIL
2151 || s7_skip_past_comma (&str) == (int) s7_FAIL
2152 || s7_reglow_required_here (&str, 4) == (int) s7_FAIL
2153 || s7_end_of_line (str) == (int) s7_FAIL)
2154 {
2155 return;
2156 }
2157 else
2158 {
2159 if ((s7_inst.instruction & 0x700f) == 0x2003) /* cmp! */
2160 {
2161 s7_inst.relax_inst |= (((s7_inst.instruction >> 8) & 0xf) << 15)
2162 | (((s7_inst.instruction >> 4) & 0xf) << 10);
2163 }
2164 else if ((s7_inst.instruction & 0x700f) == 0x2006) /* not! */
2165 {
2166 s7_inst.relax_inst |= (((s7_inst.instruction >> 8) & 0xf) << 20)
2167 | (((s7_inst.instruction >> 4) & 0xf) << 15);
2168 }
2169 else if ((s7_inst.instruction & 0x700f) == 0x1009) /* mazh.f! */
2170 {
2171 s7_inst.relax_inst |= (((s7_inst.instruction >> 8) & 0xf) << 15)
2172 | (((s7_inst.instruction >> 4) & 0xf) << 10);
2173 }
2174 else
2175 {
2176 s7_inst.relax_inst |= (((s7_inst.instruction >> 8) & 0xf) << 20)
2177 | (((s7_inst.instruction >> 8) & 0xf) << 15) | (((s7_inst.instruction >> 4) & 0xf) << 10);
2178 }
2179 s7_inst.relax_size = 4;
2180 }
2181 }
2182
2183 static void
2184 s7_do16_rs (char *str)
2185 {
2186 int rd = 0;
2187
2188 s7_skip_whitespace (str);
2189
2190 if ((rd = s7_reglow_required_here (&str, 4)) == (int) s7_FAIL
2191 || s7_end_of_line (str) == (int) s7_FAIL)
2192 {
2193 return;
2194 }
2195 else
2196 {
2197 s7_inst.relax_inst |= rd << 20;
2198 s7_inst.relax_size = 4;
2199 }
2200 }
2201
2202 /* Handle br!/brl!. */
2203
2204 static void
2205 s7_do16_xrs (char *str)
2206 {
2207 s7_skip_whitespace (str);
2208
2209 if (s7_reglow_required_here (&str, 4) == (int) s7_FAIL || s7_end_of_line (str) == (int) s7_FAIL)
2210 {
2211 return;
2212 }
2213 else
2214 {
2215 s7_inst.relax_inst |= (((s7_inst.instruction >> 8) & 0xf) << 10)
2216 | (((s7_inst.instruction >> 4) & 0xf) << 15);
2217 s7_inst.relax_size = 4;
2218 }
2219 }
2220
2221 static int
2222 s7_reghigh_required_here (char **str, int shift)
2223 {
2224 static char buff[s7_MAX_LITERAL_POOL_SIZE];
2225 int reg;
2226 char *start = *str;
2227
2228 if ((reg = s7_score_reg_parse (str, s7_all_reg_maps[s7_REG_TYPE_SCORE].htab)) != (int) s7_FAIL)
2229 {
2230 if (15 < reg && reg < 32)
2231 {
2232 if (shift >= 0)
2233 s7_inst.instruction |= (reg & 0xf) << shift;
2234
2235 return reg;
2236 }
2237 }
2238
2239 *str = start;
2240 sprintf (buff, _("high register(r16-r31)expected, not '%.100s'"), start);
2241 s7_inst.error = buff;
2242 return (int) s7_FAIL;
2243 }
2244
2245 /* Handle mhfl!. */
2246
2247 static void
2248 s7_do16_hrdrs (char *str)
2249 {
2250 s7_skip_whitespace (str);
2251
2252 if (s7_reghigh_required_here (&str, 8) != (int) s7_FAIL
2253 && s7_skip_past_comma (&str) != (int) s7_FAIL
2254 && s7_reglow_required_here (&str, 4) != (int) s7_FAIL
2255 && s7_end_of_line (str) != (int) s7_FAIL)
2256 {
2257 s7_inst.relax_inst |= ((((s7_inst.instruction >> 8) & 0xf) | 0x10) << 20)
2258 | (((s7_inst.instruction >> 4) & 0xf) << 15) | (0xf << 10);
2259 s7_inst.relax_size = 4;
2260 }
2261 }
2262
2263 /* Handle mlfh!. */
2264
2265 static void
2266 s7_do16_rdhrs (char *str)
2267 {
2268 s7_skip_whitespace (str);
2269
2270 if (s7_reglow_required_here (&str, 8) != (int) s7_FAIL
2271 && s7_skip_past_comma (&str) != (int) s7_FAIL
2272 && s7_reghigh_required_here (&str, 4) != (int) s7_FAIL
2273 && s7_end_of_line (str) != (int) s7_FAIL)
2274 {
2275 s7_inst.relax_inst |= (((s7_inst.instruction >> 8) & 0xf) << 20)
2276 | ((((s7_inst.instruction >> 4) & 0xf) | 0x10) << 15) | (0xf << 10);
2277 s7_inst.relax_size = 4;
2278 }
2279 }
2280
2281 /* We need to be able to fix up arbitrary expressions in some statements.
2282 This is so that we can handle symbols that are an arbitrary distance from
2283 the pc. The most common cases are of the form ((+/-sym -/+ . - 8) & mask),
2284 which returns part of an address in a form which will be valid for
2285 a data instruction. We do this by pushing the expression into a symbol
2286 in the expr_section, and creating a fix for that. */
2287
2288 static fixS *
2289 s7_fix_new_score (fragS * frag, int where, short int size, expressionS * exp, int pc_rel, int reloc)
2290 {
2291 fixS *new_fix;
2292
2293 switch (exp->X_op)
2294 {
2295 case O_constant:
2296 case O_symbol:
2297 case O_add:
2298 case O_subtract:
2299 new_fix = fix_new_exp (frag, where, size, exp, pc_rel, reloc);
2300 break;
2301 default:
2302 new_fix = fix_new (frag, where, size, make_expr_symbol (exp), 0, pc_rel, reloc);
2303 break;
2304 }
2305 return new_fix;
2306 }
2307
2308 static void
2309 s7_init_dependency_vector (void)
2310 {
2311 int i;
2312
2313 for (i = 0; i < s7_vector_size; i++)
2314 memset (&s7_dependency_vector[i], '\0', sizeof (s7_dependency_vector[i]));
2315
2316 return;
2317 }
2318
2319 static enum s7_insn_type_for_dependency
2320 s7_dependency_type_from_insn (char *insn_name)
2321 {
2322 char name[s7_INSN_NAME_LEN];
2323 const struct s7_insn_to_dependency *tmp;
2324
2325 strcpy (name, insn_name);
2326 tmp = (const struct s7_insn_to_dependency *) hash_find (s7_dependency_insn_hsh, name);
2327
2328 if (tmp)
2329 return tmp->type;
2330
2331 return s7_D_all_insn;
2332 }
2333
2334 static int
2335 s7_check_dependency (char *pre_insn, char *pre_reg,
2336 char *cur_insn, char *cur_reg, int *warn_or_error)
2337 {
2338 int bubbles = 0;
2339 unsigned int i;
2340 enum s7_insn_type_for_dependency pre_insn_type;
2341 enum s7_insn_type_for_dependency cur_insn_type;
2342
2343 pre_insn_type = s7_dependency_type_from_insn (pre_insn);
2344 cur_insn_type = s7_dependency_type_from_insn (cur_insn);
2345
2346 for (i = 0; i < sizeof (s7_data_dependency_table) / sizeof (s7_data_dependency_table[0]); i++)
2347 {
2348 if ((pre_insn_type == s7_data_dependency_table[i].pre_insn_type)
2349 && (s7_D_all_insn == s7_data_dependency_table[i].cur_insn_type
2350 || cur_insn_type == s7_data_dependency_table[i].cur_insn_type)
2351 && (strcmp (s7_data_dependency_table[i].pre_reg, "") == 0
2352 || strcmp (s7_data_dependency_table[i].pre_reg, pre_reg) == 0)
2353 && (strcmp (s7_data_dependency_table[i].cur_reg, "") == 0
2354 || strcmp (s7_data_dependency_table[i].cur_reg, cur_reg) == 0))
2355 {
2356 if (s7_vector_size == s7_SCORE5_PIPELINE)
2357 bubbles = s7_data_dependency_table[i].bubblenum_5;
2358 else
2359 bubbles = s7_data_dependency_table[i].bubblenum_7;
2360 *warn_or_error = s7_data_dependency_table[i].warn_or_error;
2361 break;
2362 }
2363 }
2364
2365 return bubbles;
2366 }
2367
2368 /* Turn an integer of n bytes (in val) into a stream of bytes appropriate
2369 for use in the a.out file, and stores them in the array pointed to by buf.
2370 This knows about the endian-ness of the target machine and does
2371 THE RIGHT THING, whatever it is. Possible values for n are 1 (byte)
2372 2 (short) and 4 (long) Floating numbers are put out as a series of
2373 LITTLENUMS (shorts, here at least). */
2374
2375 static void
2376 s7_number_to_chars (char *buf, valueT val, int n)
2377 {
2378 if (target_big_endian)
2379 number_to_chars_bigendian (buf, val, n);
2380 else
2381 number_to_chars_littleendian (buf, val, n);
2382 }
2383
2384 static void
2385 s7_build_one_frag (struct s7_score_it one_inst)
2386 {
2387 char *p;
2388 int relaxable_p = s7_g_opt;
2389 int relax_size = 0;
2390
2391 /* Start a new frag if frag_now is not empty. */
2392 if (frag_now_fix () != 0)
2393 {
2394 if (!frag_now->tc_frag_data.is_insn)
2395 frag_wane (frag_now);
2396
2397 frag_new (0);
2398 }
2399 frag_grow (20);
2400
2401 p = frag_more (one_inst.size);
2402 s7_number_to_chars (p, one_inst.instruction, one_inst.size);
2403
2404 #ifdef OBJ_ELF
2405 dwarf2_emit_insn (one_inst.size);
2406 #endif
2407
2408 relaxable_p &= (one_inst.relax_size != 0);
2409 relax_size = relaxable_p ? one_inst.relax_size : 0;
2410
2411 p = frag_var (rs_machine_dependent, relax_size + s7_RELAX_PAD_BYTE, 0,
2412 s7_RELAX_ENCODE (one_inst.size, one_inst.relax_size,
2413 one_inst.type, 0, 0, relaxable_p),
2414 NULL, 0, NULL);
2415
2416 if (relaxable_p)
2417 s7_number_to_chars (p, one_inst.relax_inst, relax_size);
2418 }
2419
2420 static void
2421 s7_handle_dependency (struct s7_score_it *theinst)
2422 {
2423 int i;
2424 int warn_or_error = 0; /* warn - 0; error - 1 */
2425 int bubbles = 0;
2426 int remainder_bubbles = 0;
2427 char cur_insn[s7_INSN_NAME_LEN];
2428 char pre_insn[s7_INSN_NAME_LEN];
2429 struct s7_score_it nop_inst;
2430 struct s7_score_it pflush_inst;
2431
2432 nop_inst.instruction = 0x0000;
2433 nop_inst.size = 2;
2434 nop_inst.relax_inst = 0x80008000;
2435 nop_inst.relax_size = 4;
2436 nop_inst.type = NO16_OPD;
2437
2438 pflush_inst.instruction = 0x8000800a;
2439 pflush_inst.size = 4;
2440 pflush_inst.relax_inst = 0x8000;
2441 pflush_inst.relax_size = 0;
2442 pflush_inst.type = NO_OPD;
2443
2444 /* pflush will clear all data dependency. */
2445 if (strcmp (theinst->name, "pflush") == 0)
2446 {
2447 s7_init_dependency_vector ();
2448 return;
2449 }
2450
2451 /* Push current instruction to s7_dependency_vector[0]. */
2452 for (i = s7_vector_size - 1; i > 0; i--)
2453 memcpy (&s7_dependency_vector[i], &s7_dependency_vector[i - 1], sizeof (s7_dependency_vector[i]));
2454
2455 memcpy (&s7_dependency_vector[0], theinst, sizeof (s7_dependency_vector[i]));
2456
2457 /* There is no dependency between nop and any instruction. */
2458 if (strcmp (s7_dependency_vector[0].name, "nop") == 0
2459 || strcmp (s7_dependency_vector[0].name, "nop!") == 0)
2460 return;
2461
2462 /* "pce" is defined in s7_insn_to_dependency_table. */
2463 #define PCE_NAME "pce"
2464
2465 if (s7_dependency_vector[0].type == Insn_Type_PCE)
2466 strcpy (cur_insn, PCE_NAME);
2467 else
2468 strcpy (cur_insn, s7_dependency_vector[0].name);
2469
2470 for (i = 1; i < s7_vector_size; i++)
2471 {
2472 /* The element of s7_dependency_vector is NULL. */
2473 if (s7_dependency_vector[i].name[0] == '\0')
2474 continue;
2475
2476 if (s7_dependency_vector[i].type == Insn_Type_PCE)
2477 strcpy (pre_insn, PCE_NAME);
2478 else
2479 strcpy (pre_insn, s7_dependency_vector[i].name);
2480
2481 bubbles = s7_check_dependency (pre_insn, s7_dependency_vector[i].reg,
2482 cur_insn, s7_dependency_vector[0].reg, &warn_or_error);
2483 remainder_bubbles = bubbles - i + 1;
2484
2485 if (remainder_bubbles > 0)
2486 {
2487 int j;
2488
2489 if (s7_fix_data_dependency == 1)
2490 {
2491 if (remainder_bubbles <= 2)
2492 {
2493 if (s7_warn_fix_data_dependency)
2494 as_warn (_("Fix data dependency: %s %s -- %s %s (insert %d nop!/%d)"),
2495 s7_dependency_vector[i].name, s7_dependency_vector[i].reg,
2496 s7_dependency_vector[0].name, s7_dependency_vector[0].reg,
2497 remainder_bubbles, bubbles);
2498
2499 for (j = (s7_vector_size - 1); (j - remainder_bubbles) > 0; j--)
2500 memcpy (&s7_dependency_vector[j], &s7_dependency_vector[j - remainder_bubbles],
2501 sizeof (s7_dependency_vector[j]));
2502
2503 for (j = 1; j <= remainder_bubbles; j++)
2504 {
2505 memset (&s7_dependency_vector[j], '\0', sizeof (s7_dependency_vector[j]));
2506 /* Insert nop!. */
2507 s7_build_one_frag (nop_inst);
2508 }
2509 }
2510 else
2511 {
2512 if (s7_warn_fix_data_dependency)
2513 as_warn (_("Fix data dependency: %s %s -- %s %s (insert 1 pflush/%d)"),
2514 s7_dependency_vector[i].name, s7_dependency_vector[i].reg,
2515 s7_dependency_vector[0].name, s7_dependency_vector[0].reg,
2516 bubbles);
2517
2518 for (j = 1; j < s7_vector_size; j++)
2519 memset (&s7_dependency_vector[j], '\0', sizeof (s7_dependency_vector[j]));
2520
2521 /* Insert pflush. */
2522 s7_build_one_frag (pflush_inst);
2523 }
2524 }
2525 else
2526 {
2527 if (warn_or_error)
2528 {
2529 as_bad (_("data dependency: %s %s -- %s %s (%d/%d bubble)"),
2530 s7_dependency_vector[i].name, s7_dependency_vector[i].reg,
2531 s7_dependency_vector[0].name, s7_dependency_vector[0].reg,
2532 remainder_bubbles, bubbles);
2533 }
2534 else
2535 {
2536 as_warn (_("data dependency: %s %s -- %s %s (%d/%d bubble)"),
2537 s7_dependency_vector[i].name, s7_dependency_vector[i].reg,
2538 s7_dependency_vector[0].name, s7_dependency_vector[0].reg,
2539 remainder_bubbles, bubbles);
2540 }
2541 }
2542 }
2543 }
2544 }
2545
2546 static enum insn_class
2547 s7_get_insn_class_from_type (enum score_insn_type type)
2548 {
2549 enum insn_class retval = (int) s7_FAIL;
2550
2551 switch (type)
2552 {
2553 case Rd_I4:
2554 case Rd_I5:
2555 case Rd_rvalueBP_I5:
2556 case Rd_lvalueBP_I5:
2557 case Rd_I8:
2558 case PC_DISP8div2:
2559 case PC_DISP11div2:
2560 case Rd_Rs:
2561 case Rd_HighRs:
2562 case Rd_lvalueRs:
2563 case Rd_rvalueRs:
2564 case x_Rs:
2565 case Rd_LowRs:
2566 case NO16_OPD:
2567 retval = INSN_CLASS_16;
2568 break;
2569 case Rd_Rs_I5:
2570 case x_Rs_I5:
2571 case x_I5_x:
2572 case Rd_Rs_I14:
2573 case I15:
2574 case Rd_I16:
2575 case Rd_SI16:
2576 case Rd_rvalueRs_SI10:
2577 case Rd_lvalueRs_SI10:
2578 case Rd_rvalueRs_preSI12:
2579 case Rd_rvalueRs_postSI12:
2580 case Rd_lvalueRs_preSI12:
2581 case Rd_lvalueRs_postSI12:
2582 case Rd_Rs_SI14:
2583 case Rd_rvalueRs_SI15:
2584 case Rd_lvalueRs_SI15:
2585 case PC_DISP19div2:
2586 case PC_DISP24div2:
2587 case Rd_Rs_Rs:
2588 case x_Rs_x:
2589 case x_Rs_Rs:
2590 case Rd_Rs_x:
2591 case Rd_x_Rs:
2592 case Rd_x_x:
2593 case OP5_rvalueRs_SI15:
2594 case I5_Rs_Rs_I5_OP5:
2595 case x_rvalueRs_post4:
2596 case Rd_rvalueRs_post4:
2597 case Rd_x_I5:
2598 case Rd_lvalueRs_post4:
2599 case x_lvalueRs_post4:
2600 case Rd_Rs_Rs_imm:
2601 case NO_OPD:
2602 case Rd_lvalue32Rs:
2603 case Rd_rvalue32Rs:
2604 case Insn_GP:
2605 case Insn_PIC:
2606 case Insn_internal:
2607 retval = INSN_CLASS_32;
2608 break;
2609 case Insn_Type_PCE:
2610 retval = INSN_CLASS_PCE;
2611 break;
2612 case Insn_Type_SYN:
2613 retval = INSN_CLASS_SYN;
2614 break;
2615 default:
2616 abort ();
2617 break;
2618 }
2619 return retval;
2620 }
2621
2622 static unsigned long
2623 s7_adjust_paritybit (unsigned long m_code, enum insn_class i_class)
2624 {
2625 unsigned long result = 0;
2626 unsigned long m_code_high = 0;
2627 unsigned long m_code_low = 0;
2628 unsigned long pb_high = 0;
2629 unsigned long pb_low = 0;
2630
2631 if (i_class == INSN_CLASS_32)
2632 {
2633 pb_high = 0x80000000;
2634 pb_low = 0x00008000;
2635 }
2636 else if (i_class == INSN_CLASS_16)
2637 {
2638 pb_high = 0;
2639 pb_low = 0;
2640 }
2641 else if (i_class == INSN_CLASS_PCE)
2642 {
2643 pb_high = 0;
2644 pb_low = 0x00008000;
2645 }
2646 else if (i_class == INSN_CLASS_SYN)
2647 {
2648 /* FIXME. at this time, INSN_CLASS_SYN must be 32 bit, but, instruction type should
2649 be changed if macro instruction has been expanded. */
2650 pb_high = 0x80000000;
2651 pb_low = 0x00008000;
2652 }
2653 else
2654 {
2655 abort ();
2656 }
2657
2658 m_code_high = m_code & 0x3fff8000;
2659 m_code_low = m_code & 0x00007fff;
2660 result = pb_high | (m_code_high << 1) | pb_low | m_code_low;
2661 return result;
2662
2663 }
2664
2665 static void
2666 s7_gen_insn_frag (struct s7_score_it *part_1, struct s7_score_it *part_2)
2667 {
2668 char *p;
2669 bfd_boolean pce_p = FALSE;
2670 int relaxable_p = s7_g_opt;
2671 int relax_size = 0;
2672 struct s7_score_it *inst1 = part_1;
2673 struct s7_score_it *inst2 = part_2;
2674 struct s7_score_it backup_inst1;
2675
2676 pce_p = (inst2) ? TRUE : FALSE;
2677 memcpy (&backup_inst1, inst1, sizeof (struct s7_score_it));
2678
2679 /* Adjust instruction opcode and to be relaxed instruction opcode. */
2680 if (pce_p)
2681 {
2682 backup_inst1.instruction = ((backup_inst1.instruction & 0x7FFF) << 15)
2683 | (inst2->instruction & 0x7FFF);
2684 backup_inst1.instruction = s7_adjust_paritybit (backup_inst1.instruction, INSN_CLASS_PCE);
2685 if (!target_big_endian)
2686 {
2687 unsigned long tmp = backup_inst1.instruction;
2688 backup_inst1.instruction = ((tmp & 0xffff) << 16)
2689 | (tmp >> 16);
2690 }
2691 backup_inst1.relax_inst = 0x8000;
2692 backup_inst1.size = s7_INSN_SIZE;
2693 backup_inst1.relax_size = 0;
2694 backup_inst1.type = Insn_Type_PCE;
2695 }
2696 else
2697 {
2698 backup_inst1.instruction = s7_adjust_paritybit (backup_inst1.instruction,
2699 s7_GET_INSN_CLASS (backup_inst1.type));
2700 }
2701
2702 if (backup_inst1.relax_size != 0)
2703 {
2704 enum insn_class tmp;
2705
2706 tmp = (backup_inst1.size == s7_INSN_SIZE) ? INSN_CLASS_16 : INSN_CLASS_32;
2707 backup_inst1.relax_inst = s7_adjust_paritybit (backup_inst1.relax_inst, tmp);
2708 }
2709
2710 /* Check data dependency. */
2711 s7_handle_dependency (&backup_inst1);
2712
2713 /* Start a new frag if frag_now is not empty and is not instruction frag, maybe it contains
2714 data produced by .ascii etc. Doing this is to make one instruction per frag. */
2715 if (frag_now_fix () != 0)
2716 {
2717 if (!frag_now->tc_frag_data.is_insn)
2718 frag_wane (frag_now);
2719
2720 frag_new (0);
2721 }
2722
2723 /* Here, we must call frag_grow in order to keep the instruction frag type is
2724 rs_machine_dependent.
2725 For, frag_var may change frag_now->fr_type to rs_fill by calling frag_grow which
2726 acturally will call frag_wane.
2727 Calling frag_grow first will create a new frag_now which free size is 20 that is enough
2728 for frag_var. */
2729 frag_grow (20);
2730
2731 p = frag_more (backup_inst1.size);
2732 s7_number_to_chars (p, backup_inst1.instruction, backup_inst1.size);
2733
2734 #ifdef OBJ_ELF
2735 dwarf2_emit_insn (backup_inst1.size);
2736 #endif
2737
2738 /* Generate fixup structure. */
2739 if (pce_p)
2740 {
2741 if (inst1->reloc.type != BFD_RELOC_NONE)
2742 s7_fix_new_score (frag_now, p - frag_now->fr_literal,
2743 inst1->size, &inst1->reloc.exp,
2744 inst1->reloc.pc_rel, inst1->reloc.type);
2745
2746 if (inst2->reloc.type != BFD_RELOC_NONE)
2747 s7_fix_new_score (frag_now, p - frag_now->fr_literal + 2,
2748 inst2->size, &inst2->reloc.exp, inst2->reloc.pc_rel, inst2->reloc.type);
2749 }
2750 else
2751 {
2752 if (backup_inst1.reloc.type != BFD_RELOC_NONE)
2753 s7_fix_new_score (frag_now, p - frag_now->fr_literal,
2754 backup_inst1.size, &backup_inst1.reloc.exp,
2755 backup_inst1.reloc.pc_rel, backup_inst1.reloc.type);
2756 }
2757
2758 /* relax_size may be 2, 4, 12 or 0, 0 indicates no relaxation. */
2759 relaxable_p &= (backup_inst1.relax_size != 0);
2760 relax_size = relaxable_p ? backup_inst1.relax_size : 0;
2761
2762 p = frag_var (rs_machine_dependent, relax_size + s7_RELAX_PAD_BYTE, 0,
2763 s7_RELAX_ENCODE (backup_inst1.size, backup_inst1.relax_size,
2764 backup_inst1.type, 0, 0, relaxable_p),
2765 backup_inst1.reloc.exp.X_add_symbol, 0, NULL);
2766
2767 if (relaxable_p)
2768 s7_number_to_chars (p, backup_inst1.relax_inst, relax_size);
2769
2770 memcpy (inst1, &backup_inst1, sizeof (struct s7_score_it));
2771 }
2772
2773 static void
2774 s7_parse_16_32_inst (char *insnstr, bfd_boolean gen_frag_p)
2775 {
2776 char c;
2777 char *p;
2778 char *operator = insnstr;
2779 const struct s7_asm_opcode *opcode;
2780
2781 /* Parse operator and operands. */
2782 s7_skip_whitespace (operator);
2783
2784 for (p = operator; *p != '\0'; p++)
2785 if ((*p == ' ') || (*p == '!'))
2786 break;
2787
2788 if (*p == '!')
2789 p++;
2790
2791 c = *p;
2792 *p = '\0';
2793
2794 opcode = (const struct s7_asm_opcode *) hash_find (s7_score_ops_hsh, operator);
2795 *p = c;
2796
2797 memset (&s7_inst, '\0', sizeof (s7_inst));
2798 sprintf (s7_inst.str, "%s", insnstr);
2799 if (opcode)
2800 {
2801 s7_inst.instruction = opcode->value;
2802 s7_inst.relax_inst = opcode->relax_value;
2803 s7_inst.type = opcode->type;
2804 s7_inst.size = s7_GET_INSN_SIZE (s7_inst.type);
2805 s7_inst.relax_size = 0;
2806 s7_inst.bwarn = 0;
2807 sprintf (s7_inst.name, "%s", opcode->template_name);
2808 strcpy (s7_inst.reg, "");
2809 s7_inst.error = NULL;
2810 s7_inst.reloc.type = BFD_RELOC_NONE;
2811
2812 (*opcode->parms) (p);
2813
2814 /* It indicates current instruction is a macro instruction if s7_inst.bwarn equals -1. */
2815 if ((s7_inst.bwarn != -1) && (!s7_inst.error) && (gen_frag_p))
2816 s7_gen_insn_frag (&s7_inst, NULL);
2817 }
2818 else
2819 s7_inst.error = _("unrecognized opcode");
2820 }
2821
2822 static int
2823 s7_append_insn (char *str, bfd_boolean gen_frag_p)
2824 {
2825 int retval = s7_SUCCESS;
2826
2827 s7_parse_16_32_inst (str, gen_frag_p);
2828
2829 if (s7_inst.error)
2830 {
2831 retval = (int) s7_FAIL;
2832 as_bad (_("%s -- `%s'"), s7_inst.error, s7_inst.str);
2833 s7_inst.error = NULL;
2834 }
2835
2836 return retval;
2837 }
2838
2839 /* Handle mv! reg_high, reg_low;
2840 mv! reg_low, reg_high;
2841 mv! reg_low, reg_low; */
2842 static void
2843 s7_do16_mv_rdrs (char *str)
2844 {
2845 int reg_rd;
2846 int reg_rs;
2847 char *backupstr = NULL;
2848
2849 backupstr = str;
2850 s7_skip_whitespace (str);
2851
2852 if ((reg_rd = s7_reg_required_here (&str, 8, s7_REG_TYPE_SCORE)) == (int) s7_FAIL
2853 || s7_skip_past_comma (&str) == (int) s7_FAIL
2854 || (reg_rs = s7_reg_required_here (&str, 4, s7_REG_TYPE_SCORE)) == (int) s7_FAIL
2855 || s7_end_of_line (str) == (int) s7_FAIL)
2856 {
2857 return;
2858 }
2859 else
2860 {
2861 /* Case 1 : mv! or mlfh!. */
2862 if (reg_rd < 16)
2863 {
2864 if (reg_rs < 16)
2865 {
2866 s7_inst.relax_inst |= (((s7_inst.instruction >> 8) & 0xf) << 20)
2867 | (((s7_inst.instruction >> 4) & 0xf) << 15) | (0xf << 10);
2868 s7_inst.relax_size = 4;
2869 }
2870 else
2871 {
2872 char append_str[s7_MAX_LITERAL_POOL_SIZE];
2873
2874 sprintf (append_str, "mlfh! %s", backupstr);
2875 if (s7_append_insn (append_str, TRUE) == (int) s7_FAIL)
2876 return;
2877 /* Set bwarn as -1, so macro instruction itself will not be generated frag. */
2878 s7_inst.bwarn = -1;
2879 }
2880 }
2881 /* Case 2 : mhfl!. */
2882 else
2883 {
2884 if (reg_rs > 16)
2885 {
2886 s7_SET_INSN_ERROR (s7_BAD_ARGS);
2887 return;
2888 }
2889 else
2890 {
2891 char append_str[s7_MAX_LITERAL_POOL_SIZE];
2892
2893 sprintf (append_str, "mhfl! %s", backupstr);
2894 if (s7_append_insn (append_str, TRUE) == (int) s7_FAIL)
2895 return;
2896
2897 /* Set bwarn as -1, so macro instruction itself will not be generated frag. */
2898 s7_inst.bwarn = -1;
2899 }
2900 }
2901 }
2902 }
2903
2904 static void
2905 s7_do16_rdi4 (char *str)
2906 {
2907 s7_skip_whitespace (str);
2908
2909 if (s7_reglow_required_here (&str, 8) == (int) s7_FAIL
2910 || s7_skip_past_comma (&str) == (int) s7_FAIL
2911 || s7_data_op2 (&str, 3, _IMM4) == (int) s7_FAIL
2912 || s7_end_of_line (str) == (int) s7_FAIL)
2913 {
2914 return;
2915 }
2916 else
2917 {
2918 if (((s7_inst.instruction >> 3) & 0x10) == 0) /* for judge is addei or subei : bit 5 =0 : addei */
2919 {
2920 if (((s7_inst.instruction >> 3) & 0xf) != 0xf)
2921 {
2922 s7_inst.relax_inst |= (((s7_inst.instruction >> 8) & 0xf) << 20)
2923 | ((1 << ((s7_inst.instruction >> 3) & 0xf)) << 1);
2924 s7_inst.relax_size = 4;
2925 }
2926 else
2927 {
2928 s7_inst.relax_inst = 0x8000;
2929 }
2930 }
2931 else
2932 {
2933 if (((s7_inst.instruction >> 3) & 0xf) != 0xf)
2934 {
2935 s7_inst.relax_inst |= (((s7_inst.instruction >> 8) & 0xf) << 20)
2936 | (((-(1 << ((s7_inst.instruction >> 3) & 0xf))) & 0xffff) << 1);
2937 s7_inst.relax_size = 4;
2938 }
2939 else
2940 {
2941 s7_inst.relax_inst = 0x8000;
2942 }
2943 }
2944 }
2945 }
2946
2947 static void
2948 s7_do16_rdi5 (char *str)
2949 {
2950 s7_skip_whitespace (str);
2951
2952 if (s7_reglow_required_here (&str, 8) == (int) s7_FAIL
2953 || s7_skip_past_comma (&str) == (int) s7_FAIL
2954 || s7_data_op2 (&str, 3, _IMM5) == (int) s7_FAIL
2955 || s7_end_of_line (str) == (int) s7_FAIL)
2956 return;
2957 else
2958 {
2959 s7_inst.relax_inst |= (((s7_inst.instruction >> 8) & 0xf) << 20)
2960 | (((s7_inst.instruction >> 8) & 0xf) << 15) | (((s7_inst.instruction >> 3) & 0x1f) << 10);
2961 s7_inst.relax_size = 4;
2962 }
2963 }
2964
2965 /* Handle sdbbp. */
2966
2967 static void
2968 s7_do16_xi5 (char *str)
2969 {
2970 s7_skip_whitespace (str);
2971
2972 if (s7_data_op2 (&str, 3, _IMM5) == (int) s7_FAIL || s7_end_of_line (str) == (int) s7_FAIL)
2973 return;
2974 else
2975 {
2976 s7_inst.relax_inst |= (((s7_inst.instruction >> 3) & 0x1f) << 15);
2977 s7_inst.relax_size = 4;
2978 }
2979 }
2980
2981 /* Check that an immediate is word alignment or half word alignment.
2982 If so, convert it to the right format. */
2983
2984 static int
2985 s7_validate_immediate_align (int val, unsigned int data_type)
2986 {
2987 if (data_type == _IMM5_RSHIFT_1)
2988 {
2989 if (val % 2)
2990 {
2991 s7_inst.error = _("address offset must be half word alignment");
2992 return (int) s7_FAIL;
2993 }
2994 }
2995 else if ((data_type == _IMM5_RSHIFT_2) || (data_type == _IMM10_RSHIFT_2))
2996 {
2997 if (val % 4)
2998 {
2999 s7_inst.error = _("address offset must be word alignment");
3000 return (int) s7_FAIL;
3001 }
3002 }
3003
3004 return s7_SUCCESS;
3005 }
3006
3007 static int
3008 s7_exp_ldst_offset (char **str, int shift, unsigned int data_type)
3009 {
3010 char *dataptr;
3011 int hex_p = 0;
3012
3013 dataptr = * str;
3014
3015 if ((dataptr != NULL)
3016 && (((strstr (dataptr, "0x")) != NULL)
3017 || ((strstr (dataptr, "0X")) != NULL)))
3018 {
3019 hex_p = 1;
3020 if ((data_type != _SIMM16_LA)
3021 && (data_type != _VALUE_HI16)
3022 && (data_type != _VALUE_LO16)
3023 && (data_type != _IMM16)
3024 && (data_type != _IMM15)
3025 && (data_type != _IMM14)
3026 && (data_type != _IMM4)
3027 && (data_type != _IMM5)
3028 && (data_type != _IMM8)
3029 && (data_type != _IMM5_RSHIFT_1)
3030 && (data_type != _IMM5_RSHIFT_2)
3031 && (data_type != _SIMM12)
3032 && (data_type != _SIMM15)
3033 && (data_type != _SIMM14_NEG)
3034 && (data_type != _IMM10_RSHIFT_2))
3035 {
3036 data_type += 24;
3037 }
3038 }
3039
3040 if (s7_my_get_expression (&s7_inst.reloc.exp, str) == (int) s7_FAIL)
3041 return (int) s7_FAIL;
3042
3043 if (s7_inst.reloc.exp.X_op == O_constant)
3044 {
3045 /* Need to check the immediate align. */
3046 int value = s7_validate_immediate_align (s7_inst.reloc.exp.X_add_number, data_type);
3047
3048 if (value == (int) s7_FAIL)
3049 return (int) s7_FAIL;
3050
3051 value = s7_validate_immediate (s7_inst.reloc.exp.X_add_number, data_type, hex_p);
3052 if (value == (int) s7_FAIL)
3053 {
3054 if (data_type < 30)
3055 sprintf (s7_err_msg,
3056 _("invalid constant: %d bit expression not in range %d..%d"),
3057 s7_score_df_range[data_type].bits,
3058 s7_score_df_range[data_type].range[0], s7_score_df_range[data_type].range[1]);
3059 else
3060 sprintf (s7_err_msg,
3061 _("invalid constant: %d bit expression not in range %d..%d"),
3062 s7_score_df_range[data_type - 24].bits,
3063 s7_score_df_range[data_type - 24].range[0], s7_score_df_range[data_type - 24].range[1]);
3064 s7_inst.error = s7_err_msg;
3065 return (int) s7_FAIL;
3066 }
3067
3068 if (data_type == _IMM5_RSHIFT_1)
3069 {
3070 value >>= 1;
3071 }
3072 else if ((data_type == _IMM5_RSHIFT_2) || (data_type == _IMM10_RSHIFT_2))
3073 {
3074 value >>= 2;
3075 }
3076
3077 if (s7_score_df_range[data_type].range[0] != 0)
3078 {
3079 value &= (1 << s7_score_df_range[data_type].bits) - 1;
3080 }
3081
3082 s7_inst.instruction |= value << shift;
3083 }
3084 else
3085 {
3086 s7_inst.reloc.pc_rel = 0;
3087 }
3088
3089 return s7_SUCCESS;
3090 }
3091
3092 static void
3093 s7_do_ldst_insn (char *str)
3094 {
3095 int pre_inc = 0;
3096 int conflict_reg;
3097 int value;
3098 char * temp;
3099 char *strbak;
3100 char *dataptr;
3101 int reg;
3102 int ldst_idx = 0;
3103
3104 int hex_p = 0;
3105
3106 strbak = str;
3107 s7_skip_whitespace (str);
3108
3109 if (((conflict_reg = s7_reg_required_here (&str, 20, s7_REG_TYPE_SCORE)) == (int) s7_FAIL)
3110 || (s7_skip_past_comma (&str) == (int) s7_FAIL))
3111 return;
3112
3113 /* ld/sw rD, [rA, simm15] ld/sw rD, [rA]+, simm12 ld/sw rD, [rA, simm12]+. */
3114 if (*str == '[')
3115 {
3116 str++;
3117 s7_skip_whitespace (str);
3118
3119 if ((reg = s7_reg_required_here (&str, 15, s7_REG_TYPE_SCORE)) == (int) s7_FAIL)
3120 return;
3121
3122 /* Conflicts can occur on stores as well as loads. */
3123 conflict_reg = (conflict_reg == reg);
3124 s7_skip_whitespace (str);
3125 temp = str + 1; /* The latter will process decimal/hex expression. */
3126
3127 /* ld/sw rD, [rA]+, simm12 ld/sw rD, [rA]+. */
3128 if (*str == ']')
3129 {
3130 str++;
3131 if (*str == '+')
3132 {
3133 str++;
3134 /* ld/sw rD, [rA]+, simm12. */
3135 if (s7_skip_past_comma (&str) == s7_SUCCESS)
3136 {
3137 if ((s7_exp_ldst_offset (&str, 3, _SIMM12) == (int) s7_FAIL)
3138 || (s7_end_of_line (str) == (int) s7_FAIL))
3139 return;
3140
3141 if (conflict_reg)
3142 {
3143 unsigned int ldst_func = s7_inst.instruction & OPC_PSEUDOLDST_MASK;
3144
3145 if ((ldst_func == INSN_LH)
3146 || (ldst_func == INSN_LHU)
3147 || (ldst_func == INSN_LW)
3148 || (ldst_func == INSN_LB)
3149 || (ldst_func == INSN_LBU))
3150 {
3151 s7_inst.error = _("register same as write-back base");
3152 return;
3153 }
3154 }
3155
3156 ldst_idx = s7_inst.instruction & OPC_PSEUDOLDST_MASK;
3157 s7_inst.instruction &= ~OPC_PSEUDOLDST_MASK;
3158 s7_inst.instruction |= s7_score_ldst_insns[ldst_idx * 3 + LDST_POST].value;
3159
3160 /* lw rD, [rA]+, 4 convert to pop rD, [rA]. */
3161 if ((s7_inst.instruction & 0x3e000007) == 0x0e000000)
3162 {
3163 /* rs = r0-r7, offset = 4 */
3164 if ((((s7_inst.instruction >> 15) & 0x18) == 0)
3165 && (((s7_inst.instruction >> 3) & 0xfff) == 4))
3166 {
3167 /* Relax to pophi. */
3168 if ((((s7_inst.instruction >> 20) & 0x10) == 0x10))
3169 {
3170 s7_inst.relax_inst = 0x0000200a | (((s7_inst.instruction >> 20) & 0xf)
3171 << 8) | 1 << 7 |
3172 (((s7_inst.instruction >> 15) & 0x7) << 4);
3173 }
3174 /* Relax to pop. */
3175 else
3176 {
3177 s7_inst.relax_inst = 0x0000200a | (((s7_inst.instruction >> 20) & 0xf)
3178 << 8) | 0 << 7 |
3179 (((s7_inst.instruction >> 15) & 0x7) << 4);
3180 }
3181 s7_inst.relax_size = 2;
3182 }
3183 }
3184 return;
3185 }
3186 /* ld/sw rD, [rA]+ convert to ld/sw rD, [rA, 0]+. */
3187 else
3188 {
3189 s7_SET_INSN_ERROR (NULL);
3190 if (s7_end_of_line (str) == (int) s7_FAIL)
3191 {
3192 return;
3193 }
3194
3195 pre_inc = 1;
3196 value = s7_validate_immediate (s7_inst.reloc.exp.X_add_number, _SIMM12, 0);
3197 value &= (1 << s7_score_df_range[_SIMM12].bits) - 1;
3198 ldst_idx = s7_inst.instruction & OPC_PSEUDOLDST_MASK;
3199 s7_inst.instruction &= ~OPC_PSEUDOLDST_MASK;
3200 s7_inst.instruction |= s7_score_ldst_insns[ldst_idx * 3 + pre_inc].value;
3201 s7_inst.instruction |= value << 3;
3202 s7_inst.relax_inst = 0x8000;
3203 return;
3204 }
3205 }
3206 /* ld/sw rD, [rA] convert to ld/sw rD, [rA, simm15]. */
3207 else
3208 {
3209 if (s7_end_of_line (str) == (int) s7_FAIL)
3210 return;
3211
3212 ldst_idx = s7_inst.instruction & OPC_PSEUDOLDST_MASK;
3213 s7_inst.instruction &= ~OPC_PSEUDOLDST_MASK;
3214 s7_inst.instruction |= s7_score_ldst_insns[ldst_idx * 3 + LDST_NOUPDATE].value;
3215
3216 /* lbu rd, [rs] -> lbu! rd, [rs] */
3217 if (ldst_idx == INSN_LBU)
3218 {
3219 s7_inst.relax_inst = INSN16_LBU;
3220 }
3221 else if (ldst_idx == INSN_LH)
3222 {
3223 s7_inst.relax_inst = INSN16_LH;
3224 }
3225 else if (ldst_idx == INSN_LW)
3226 {
3227 s7_inst.relax_inst = INSN16_LW;
3228 }
3229 else if (ldst_idx == INSN_SB)
3230 {
3231 s7_inst.relax_inst = INSN16_SB;
3232 }
3233 else if (ldst_idx == INSN_SH)
3234 {
3235 s7_inst.relax_inst = INSN16_SH;
3236 }
3237 else if (ldst_idx == INSN_SW)
3238 {
3239 s7_inst.relax_inst = INSN16_SW;
3240 }
3241 else
3242 {
3243 s7_inst.relax_inst = 0x8000;
3244 }
3245
3246 /* lw/lh/lbu/sw/sh/sb, offset = 0, relax to 16 bit instruction. */
3247 if ((ldst_idx == INSN_LBU)
3248 || (ldst_idx == INSN_LH)
3249 || (ldst_idx == INSN_LW)
3250 || (ldst_idx == INSN_SB) || (ldst_idx == INSN_SH) || (ldst_idx == INSN_SW))
3251 {
3252 if ((((s7_inst.instruction >> 15) & 0x10) == 0) && (((s7_inst.instruction >> 20) & 0x10) == 0))
3253 {
3254 s7_inst.relax_inst |= (2 << 12) | (((s7_inst.instruction >> 20) & 0xf) << 8) |
3255 (((s7_inst.instruction >> 15) & 0xf) << 4);
3256 s7_inst.relax_size = 2;
3257 }
3258 }
3259
3260 return;
3261 }
3262 }
3263 /* ld/sw rD, [rA, simm15] ld/sw rD, [rA, simm12]+. */
3264 else
3265 {
3266 if (s7_skip_past_comma (&str) == (int) s7_FAIL)
3267 {
3268 s7_inst.error = _("pre-indexed expression expected");
3269 return;
3270 }
3271
3272 if (s7_my_get_expression (&s7_inst.reloc.exp, &str) == (int) s7_FAIL)
3273 return;
3274
3275 s7_skip_whitespace (str);
3276 if (*str++ != ']')
3277 {
3278 s7_inst.error = _("missing ]");
3279 return;
3280 }
3281
3282 s7_skip_whitespace (str);
3283 /* ld/sw rD, [rA, simm12]+. */
3284 if (*str == '+')
3285 {
3286 str++;
3287 pre_inc = 1;
3288 if (conflict_reg)
3289 {
3290 unsigned int ldst_func = s7_inst.instruction & OPC_PSEUDOLDST_MASK;
3291
3292 if ((ldst_func == INSN_LH)
3293 || (ldst_func == INSN_LHU)
3294 || (ldst_func == INSN_LW)
3295 || (ldst_func == INSN_LB)
3296 || (ldst_func == INSN_LBU))
3297 {
3298 s7_inst.error = _("register same as write-back base");
3299 return;
3300 }
3301 }
3302 }
3303
3304 if (s7_end_of_line (str) == (int) s7_FAIL)
3305 return;
3306
3307 if (s7_inst.reloc.exp.X_op == O_constant)
3308 {
3309 unsigned int data_type;
3310
3311 if (pre_inc == 1)
3312 data_type = _SIMM12;
3313 else
3314 data_type = _SIMM15;
3315 dataptr = temp;
3316
3317 if ((dataptr != NULL)
3318 && (((strstr (dataptr, "0x")) != NULL)
3319 || ((strstr (dataptr, "0X")) != NULL)))
3320 {
3321 hex_p = 1;
3322 if ((data_type != _SIMM16_LA)
3323 && (data_type != _VALUE_HI16)
3324 && (data_type != _VALUE_LO16)
3325 && (data_type != _IMM16)
3326 && (data_type != _IMM15)
3327 && (data_type != _IMM14)
3328 && (data_type != _IMM4)
3329 && (data_type != _IMM5)
3330 && (data_type != _IMM8)
3331 && (data_type != _SIMM12)
3332 && (data_type != _SIMM15)
3333 && (data_type != _IMM5_RSHIFT_1)
3334 && (data_type != _IMM5_RSHIFT_2)
3335 && (data_type != _SIMM14_NEG)
3336 && (data_type != _IMM10_RSHIFT_2))
3337 {
3338 data_type += 24;
3339 }
3340 }
3341
3342 value = s7_validate_immediate (s7_inst.reloc.exp.X_add_number, data_type, hex_p);
3343 if (value == (int) s7_FAIL)
3344 {
3345 if (data_type < 30)
3346 sprintf (s7_err_msg,
3347 _("invalid constant: %d bit expression not in range %d..%d"),
3348 s7_score_df_range[data_type].bits,
3349 s7_score_df_range[data_type].range[0], s7_score_df_range[data_type].range[1]);
3350 else
3351 sprintf (s7_err_msg,
3352 _("invalid constant: %d bit expression not in range %d..%d"),
3353 s7_score_df_range[data_type - 24].bits,
3354 s7_score_df_range[data_type - 24].range[0],
3355 s7_score_df_range[data_type - 24].range[1]);
3356 s7_inst.error = s7_err_msg;
3357 return;
3358 }
3359
3360 value &= (1 << s7_score_df_range[data_type].bits) - 1;
3361 ldst_idx = s7_inst.instruction & OPC_PSEUDOLDST_MASK;
3362 s7_inst.instruction &= ~OPC_PSEUDOLDST_MASK;
3363 s7_inst.instruction |= s7_score_ldst_insns[ldst_idx * 3 + pre_inc].value;
3364 if (pre_inc == 1)
3365 s7_inst.instruction |= value << 3;
3366 else
3367 s7_inst.instruction |= value;
3368
3369 /* lw rD, [rA, simm15] */
3370 if ((s7_inst.instruction & 0x3e000000) == 0x20000000)
3371 {
3372 /* Both rD and rA are in [r0 - r15]. */
3373 if ((((s7_inst.instruction >> 15) & 0x10) == 0)
3374 && (((s7_inst.instruction >> 20) & 0x10) == 0))
3375 {
3376 /* simm15 = 0, lw -> lw!. */
3377 if ((s7_inst.instruction & 0x7fff) == 0)
3378 {
3379 s7_inst.relax_inst |= (((s7_inst.instruction >> 15) & 0xf) << 4)
3380 | (((s7_inst.instruction >> 20) & 0xf) << 8);
3381 s7_inst.relax_size = 2;
3382 }
3383 /* rA = r2, lw -> lwp!. */
3384 else if ((((s7_inst.instruction >> 15) & 0xf) == 2)
3385 && ((s7_inst.instruction & 0x3) == 0)
3386 && ((s7_inst.instruction & 0x7fff) < 128))
3387 {
3388 s7_inst.relax_inst = 0x7000 | (((s7_inst.instruction >> 20) & 0xf) << 8)
3389 | (((s7_inst.instruction & 0x7fff) >> 2) << 3);
3390 s7_inst.relax_size = 2;
3391 }
3392 else
3393 {
3394 s7_inst.relax_inst = 0x8000;
3395 }
3396 }
3397 else
3398 {
3399 s7_inst.relax_inst = 0x8000;
3400 }
3401 }
3402 /* sw rD, [rA, simm15] */
3403 else if ((s7_inst.instruction & 0x3e000000) == 0x28000000)
3404 {
3405 /* Both rD and rA are in [r0 - r15]. */
3406 if ((((s7_inst.instruction >> 15) & 0x10) == 0) && (((s7_inst.instruction >> 20) & 0x10) == 0))
3407 {
3408 /* simm15 = 0, sw -> sw!. */
3409 if ((s7_inst.instruction & 0x7fff) == 0)
3410 {
3411 s7_inst.relax_inst |= (((s7_inst.instruction >> 15) & 0xf) << 4)
3412 | (((s7_inst.instruction >> 20) & 0xf) << 8);
3413 s7_inst.relax_size = 2;
3414 }
3415 /* rA = r2, sw -> swp!. */
3416 else if ((((s7_inst.instruction >> 15) & 0xf) == 2)
3417 && ((s7_inst.instruction & 0x3) == 0)
3418 && ((s7_inst.instruction & 0x7fff) < 128))
3419 {
3420 s7_inst.relax_inst = 0x7004 | (((s7_inst.instruction >> 20) & 0xf) << 8)
3421 | (((s7_inst.instruction & 0x7fff) >> 2) << 3);
3422 s7_inst.relax_size = 2;
3423 }
3424 else
3425 {
3426 s7_inst.relax_inst = 0x8000;
3427 }
3428 }
3429 else
3430 {
3431 s7_inst.relax_inst = 0x8000;
3432 }
3433 }
3434 /* sw rD, [rA, simm15]+ sw pre. */
3435 else if ((s7_inst.instruction & 0x3e000007) == 0x06000004)
3436 {
3437 /* rA is in [r0 - r7], and simm15 = -4. */
3438 if ((((s7_inst.instruction >> 15) & 0x18) == 0)
3439 && (((s7_inst.instruction >> 3) & 0xfff) == 0xffc))
3440 {
3441 /* sw -> pushhi!. */
3442 if ((((s7_inst.instruction >> 20) & 0x10) == 0x10))
3443 {
3444 s7_inst.relax_inst = 0x0000200e | (((s7_inst.instruction >> 20) & 0xf) << 8)
3445 | 1 << 7 | (((s7_inst.instruction >> 15) & 0x7) << 4);
3446 s7_inst.relax_size = 2;
3447 }
3448 /* sw -> push!. */
3449 else
3450 {
3451 s7_inst.relax_inst = 0x0000200e | (((s7_inst.instruction >> 20) & 0xf) << 8)
3452 | 0 << 7 | (((s7_inst.instruction >> 15) & 0x7) << 4);
3453 s7_inst.relax_size = 2;
3454 }
3455 }
3456 else
3457 {
3458 s7_inst.relax_inst = 0x8000;
3459 }
3460 }
3461 /* lh rD, [rA, simm15] */
3462 else if ((s7_inst.instruction & 0x3e000000) == 0x22000000)
3463 {
3464 /* Both rD and rA are in [r0 - r15]. */
3465 if ((((s7_inst.instruction >> 15) & 0x10) == 0) && (((s7_inst.instruction >> 20) & 0x10) == 0))
3466 {
3467 /* simm15 = 0, lh -> lh!. */
3468 if ((s7_inst.instruction & 0x7fff) == 0)
3469 {
3470 s7_inst.relax_inst |= (((s7_inst.instruction >> 15) & 0xf) << 4)
3471 | (((s7_inst.instruction >> 20) & 0xf) << 8);
3472 s7_inst.relax_size = 2;
3473 }
3474 /* rA = r2, lh -> lhp!. */
3475 else if ((((s7_inst.instruction >> 15) & 0xf) == 2)
3476 && ((s7_inst.instruction & 0x1) == 0)
3477 && ((s7_inst.instruction & 0x7fff) < 64))
3478 {
3479 s7_inst.relax_inst = 0x7001 | (((s7_inst.instruction >> 20) & 0xf) << 8)
3480 | (((s7_inst.instruction & 0x7fff) >> 1) << 3);
3481 s7_inst.relax_size = 2;
3482 }
3483 else
3484 {
3485 s7_inst.relax_inst = 0x8000;
3486 }
3487 }
3488 else
3489 {
3490 s7_inst.relax_inst = 0x8000;
3491 }
3492 }
3493 /* sh rD, [rA, simm15] */
3494 else if ((s7_inst.instruction & 0x3e000000) == 0x2a000000)
3495 {
3496 /* Both rD and rA are in [r0 - r15]. */
3497 if ((((s7_inst.instruction >> 15) & 0x10) == 0) && (((s7_inst.instruction >> 20) & 0x10) == 0))
3498 {
3499 /* simm15 = 0, sh -> sh!. */
3500 if ((s7_inst.instruction & 0x7fff) == 0)
3501 {
3502 s7_inst.relax_inst |= (((s7_inst.instruction >> 15) & 0xf) << 4)
3503 | (((s7_inst.instruction >> 20) & 0xf) << 8);
3504 s7_inst.relax_size = 2;
3505 }
3506 /* rA = r2, sh -> shp!. */
3507 else if ((((s7_inst.instruction >> 15) & 0xf) == 2)
3508 && ((s7_inst.instruction & 0x1) == 0)
3509 && ((s7_inst.instruction & 0x7fff) < 64))
3510 {
3511 s7_inst.relax_inst = 0x7005 | (((s7_inst.instruction >> 20) & 0xf) << 8)
3512 | (((s7_inst.instruction & 0x7fff) >> 1) << 3);
3513 s7_inst.relax_size = 2;
3514 }
3515 else
3516 {
3517 s7_inst.relax_inst = 0x8000;
3518 }
3519 }
3520 else
3521 {
3522 s7_inst.relax_inst = 0x8000;
3523 }
3524 }
3525 /* lbu rD, [rA, simm15] */
3526 else if ((s7_inst.instruction & 0x3e000000) == 0x2c000000)
3527 {
3528 /* Both rD and rA are in [r0 - r15]. */
3529 if ((((s7_inst.instruction >> 15) & 0x10) == 0) && (((s7_inst.instruction >> 20) & 0x10) == 0))
3530 {
3531 /* simm15 = 0, lbu -> lbu!. */
3532 if ((s7_inst.instruction & 0x7fff) == 0)
3533 {
3534 s7_inst.relax_inst |= (((s7_inst.instruction >> 15) & 0xf) << 4)
3535 | (((s7_inst.instruction >> 20) & 0xf) << 8);
3536 s7_inst.relax_size = 2;
3537 }
3538 /* rA = r2, lbu -> lbup!. */
3539 else if ((((s7_inst.instruction >> 15) & 0xf) == 2)
3540 && ((s7_inst.instruction & 0x7fff) < 32))
3541 {
3542 s7_inst.relax_inst = 0x7003 | (((s7_inst.instruction >> 20) & 0xf) << 8)
3543 | ((s7_inst.instruction & 0x7fff) << 3);
3544 s7_inst.relax_size = 2;
3545 }
3546 else
3547 {
3548 s7_inst.relax_inst = 0x8000;
3549 }
3550 }
3551 else
3552 {
3553 s7_inst.relax_inst = 0x8000;
3554 }
3555 }
3556 /* sb rD, [rA, simm15] */
3557 else if ((s7_inst.instruction & 0x3e000000) == 0x2e000000)
3558 {
3559 /* Both rD and rA are in [r0 - r15]. */
3560 if ((((s7_inst.instruction >> 15) & 0x10) == 0) && (((s7_inst.instruction >> 20) & 0x10) == 0))
3561 {
3562 /* simm15 = 0, sb -> sb!. */
3563 if ((s7_inst.instruction & 0x7fff) == 0)
3564 {
3565 s7_inst.relax_inst |= (((s7_inst.instruction >> 15) & 0xf) << 4)
3566 | (((s7_inst.instruction >> 20) & 0xf) << 8);
3567 s7_inst.relax_size = 2;
3568 }
3569 /* rA = r2, sb -> sb!. */
3570 else if ((((s7_inst.instruction >> 15) & 0xf) == 2)
3571 && ((s7_inst.instruction & 0x7fff) < 32))
3572 {
3573 s7_inst.relax_inst = 0x7007 | (((s7_inst.instruction >> 20) & 0xf) << 8)
3574 | ((s7_inst.instruction & 0x7fff) << 3);
3575 s7_inst.relax_size = 2;
3576 }
3577 else
3578 {
3579 s7_inst.relax_inst = 0x8000;
3580 }
3581 }
3582 else
3583 {
3584 s7_inst.relax_inst = 0x8000;
3585 }
3586 }
3587 else
3588 {
3589 s7_inst.relax_inst = 0x8000;
3590 }
3591
3592 return;
3593 }
3594 else
3595 {
3596 /* FIXME: may set error, for there is no ld/sw rD, [rA, label] */
3597 s7_inst.reloc.pc_rel = 0;
3598 }
3599 }
3600 }
3601 else
3602 {
3603 s7_inst.error = s7_BAD_ARGS;
3604 }
3605 }
3606
3607 /* Handle cache. */
3608 static void
3609 s7_do_cache (char *str)
3610 {
3611 s7_skip_whitespace (str);
3612
3613 if ((s7_data_op2 (&str, 20, _IMM5) == (int) s7_FAIL) || (s7_skip_past_comma (&str) == (int) s7_FAIL))
3614 {
3615 return;
3616 }
3617 else
3618 {
3619 int cache_op;
3620
3621 cache_op = (s7_inst.instruction >> 20) & 0x1F;
3622 sprintf (s7_inst.name, "cache %d", cache_op);
3623 }
3624
3625 if (*str == '[')
3626 {
3627 str++;
3628 s7_skip_whitespace (str);
3629
3630 if (s7_reg_required_here (&str, 15, s7_REG_TYPE_SCORE) == (int) s7_FAIL)
3631 return;
3632
3633 s7_skip_whitespace (str);
3634
3635 /* cache op, [rA] */
3636 if (s7_skip_past_comma (&str) == (int) s7_FAIL)
3637 {
3638 s7_SET_INSN_ERROR (NULL);
3639 if (*str != ']')
3640 {
3641 s7_inst.error = _("missing ]");
3642 return;
3643 }
3644 str++;
3645 }
3646 /* cache op, [rA, simm15] */
3647 else
3648 {
3649 if (s7_exp_ldst_offset (&str, 0, _SIMM15) == (int) s7_FAIL)
3650 {
3651 return;
3652 }
3653
3654 s7_skip_whitespace (str);
3655 if (*str++ != ']')
3656 {
3657 s7_inst.error = _("missing ]");
3658 return;
3659 }
3660 }
3661
3662 if (s7_end_of_line (str) == (int) s7_FAIL)
3663 return;
3664 }
3665 else
3666 {
3667 s7_inst.error = s7_BAD_ARGS;
3668 }
3669 }
3670
3671 static void
3672 s7_do_crdcrscrsimm5 (char *str)
3673 {
3674 char *strbak;
3675
3676 strbak = str;
3677 s7_skip_whitespace (str);
3678
3679 if (s7_reg_required_here (&str, 20, s7_REG_TYPE_SCORE_CR) == (int) s7_FAIL
3680 || s7_skip_past_comma (&str) == (int) s7_FAIL
3681 || s7_reg_required_here (&str, 15, s7_REG_TYPE_SCORE_CR) == (int) s7_FAIL
3682 || s7_skip_past_comma (&str) == (int) s7_FAIL
3683 || s7_reg_required_here (&str, 10, s7_REG_TYPE_SCORE_CR) == (int) s7_FAIL
3684 || s7_skip_past_comma (&str) == (int) s7_FAIL)
3685 {
3686 str = strbak;
3687 /* cop1 cop_code20. */
3688 if (s7_data_op2 (&str, 5, _IMM20) == (int) s7_FAIL)
3689 return;
3690 }
3691 else
3692 {
3693 if (s7_data_op2 (&str, 5, _IMM5) == (int) s7_FAIL)
3694 return;
3695 }
3696
3697 s7_end_of_line (str);
3698 }
3699
3700 /* Handle ldc/stc. */
3701 static void
3702 s7_do_ldst_cop (char *str)
3703 {
3704 s7_skip_whitespace (str);
3705
3706 if ((s7_reg_required_here (&str, 15, s7_REG_TYPE_SCORE_CR) == (int) s7_FAIL)
3707 || (s7_skip_past_comma (&str) == (int) s7_FAIL))
3708 return;
3709
3710 if (*str == '[')
3711 {
3712 str++;
3713 s7_skip_whitespace (str);
3714
3715 if (s7_reg_required_here (&str, 20, s7_REG_TYPE_SCORE) == (int) s7_FAIL)
3716 return;
3717
3718 s7_skip_whitespace (str);
3719
3720 if (*str++ != ']')
3721 {
3722 if (s7_exp_ldst_offset (&str, 5, _IMM10_RSHIFT_2) == (int) s7_FAIL)
3723 return;
3724
3725 s7_skip_whitespace (str);
3726 if (*str++ != ']')
3727 {
3728 s7_inst.error = _("missing ]");
3729 return;
3730 }
3731 }
3732
3733 s7_end_of_line (str);
3734 }
3735 else
3736 s7_inst.error = s7_BAD_ARGS;
3737 }
3738
3739 static void
3740 s7_do16_ldst_insn (char *str)
3741 {
3742 s7_skip_whitespace (str);
3743
3744 if ((s7_reglow_required_here (&str, 8) == (int) s7_FAIL) || (s7_skip_past_comma (&str) == (int) s7_FAIL))
3745 return;
3746
3747 if (*str == '[')
3748 {
3749 int reg;
3750
3751 str++;
3752 s7_skip_whitespace (str);
3753
3754 if ((reg = s7_reglow_required_here (&str, 4)) == (int) s7_FAIL)
3755 return;
3756
3757 s7_skip_whitespace (str);
3758 if (*str++ == ']')
3759 {
3760 if (s7_end_of_line (str) == (int) s7_FAIL)
3761 return;
3762 else
3763 {
3764 s7_inst.relax_inst |= (((s7_inst.instruction >> 8) & 0xf) << 20)
3765 | (((s7_inst.instruction >> 4) & 0xf) << 15);
3766 s7_inst.relax_size = 4;
3767 }
3768 }
3769 else
3770 {
3771 s7_inst.error = _("missing ]");
3772 }
3773 }
3774 else
3775 {
3776 s7_inst.error = s7_BAD_ARGS;
3777 }
3778 }
3779
3780 /* Handle lbup!/lhp!/ldiu!/lwp!/sbp!/shp!/swp!. */
3781
3782 static void
3783 s7_do16_ldst_imm_insn (char *str)
3784 {
3785 char data_exp[s7_MAX_LITERAL_POOL_SIZE];
3786 int reg_rd;
3787 char *dataptr = NULL, *pp = NULL;
3788 int cnt = 0;
3789 int assign_data = (int) s7_FAIL;
3790 unsigned int ldst_func;
3791
3792 s7_skip_whitespace (str);
3793
3794 if (((reg_rd = s7_reglow_required_here (&str, 8)) == (int) s7_FAIL)
3795 || (s7_skip_past_comma (&str) == (int) s7_FAIL))
3796 return;
3797
3798 s7_skip_whitespace (str);
3799 dataptr = str;
3800
3801 while ((*dataptr != '\0') && (*dataptr != '|') && (cnt <= s7_MAX_LITERAL_POOL_SIZE))
3802 {
3803 data_exp[cnt] = *dataptr;
3804 dataptr++;
3805 cnt++;
3806 }
3807
3808 data_exp[cnt] = '\0';
3809 pp = &data_exp[0];
3810
3811 str = dataptr;
3812
3813 ldst_func = s7_inst.instruction & LDST16_RI_MASK;
3814 if (ldst_func == N16_LIU)
3815 assign_data = s7_exp_ldst_offset (&pp, 0, _IMM8);
3816 else if (ldst_func == N16_LHP || ldst_func == N16_SHP)
3817 assign_data = s7_exp_ldst_offset (&pp, 3, _IMM5_RSHIFT_1);
3818 else if (ldst_func == N16_LWP || ldst_func == N16_SWP)
3819 assign_data = s7_exp_ldst_offset (&pp, 3, _IMM5_RSHIFT_2);
3820 else
3821 assign_data = s7_exp_ldst_offset (&pp, 3, _IMM5);
3822
3823 if ((assign_data == (int) s7_FAIL) || (s7_end_of_line (pp) == (int) s7_FAIL))
3824 return;
3825 else
3826 {
3827 if ((s7_inst.instruction & 0x7000) == N16_LIU)
3828 {
3829 s7_inst.relax_inst |= ((s7_inst.instruction >> 8) & 0xf) << 20
3830 | ((s7_inst.instruction & 0xff) << 1);
3831 }
3832 else if (((s7_inst.instruction & 0x7007) == N16_LHP)
3833 || ((s7_inst.instruction & 0x7007) == N16_SHP))
3834 {
3835 s7_inst.relax_inst |= ((s7_inst.instruction >> 8) & 0xf) << 20 | 2 << 15
3836 | (((s7_inst.instruction >> 3) & 0x1f) << 1);
3837 }
3838 else if (((s7_inst.instruction & 0x7007) == N16_LWP)
3839 || ((s7_inst.instruction & 0x7007) == N16_SWP))
3840 {
3841 s7_inst.relax_inst |= ((s7_inst.instruction >> 8) & 0xf) << 20 | 2 << 15
3842 | (((s7_inst.instruction >> 3) & 0x1f) << 2);
3843 }
3844 else if (((s7_inst.instruction & 0x7007) == N16_LBUP)
3845 || ((s7_inst.instruction & 0x7007) == N16_SBP))
3846 {
3847 s7_inst.relax_inst |= ((s7_inst.instruction >> 8) & 0xf) << 20 | 2 << 15
3848 | (((s7_inst.instruction >> 3) & 0x1f));
3849 }
3850
3851 s7_inst.relax_size = 4;
3852 }
3853 }
3854
3855 static void
3856 s7_do16_push_pop (char *str)
3857 {
3858 int reg_rd;
3859 int H_bit_mask = 0;
3860
3861 s7_skip_whitespace (str);
3862 if (((reg_rd = s7_reg_required_here (&str, 8, s7_REG_TYPE_SCORE)) == (int) s7_FAIL)
3863 || (s7_skip_past_comma (&str) == (int) s7_FAIL))
3864 return;
3865
3866 if (reg_rd >= 16)
3867 H_bit_mask = 1;
3868
3869 /* s7_reg_required_here will change bit 12 of opcode, so we must restore bit 12. */
3870 s7_inst.instruction &= ~(1 << 12);
3871
3872 s7_inst.instruction |= H_bit_mask << 7;
3873
3874 if (*str == '[')
3875 {
3876 int reg;
3877
3878 str++;
3879 s7_skip_whitespace (str);
3880 if ((reg = s7_reg_required_here (&str, 4, s7_REG_TYPE_SCORE)) == (int) s7_FAIL)
3881 return;
3882 else if (reg > 7)
3883 {
3884 if (!s7_inst.error)
3885 s7_inst.error = _("base register nums are over 3 bit");
3886
3887 return;
3888 }
3889
3890 s7_skip_whitespace (str);
3891 if ((*str++ != ']') || (s7_end_of_line (str) == (int) s7_FAIL))
3892 {
3893 if (!s7_inst.error)
3894 s7_inst.error = _("missing ]");
3895
3896 return;
3897 }
3898
3899 /* pop! */
3900 if ((s7_inst.instruction & 0xf) == 0xa)
3901 {
3902 if (H_bit_mask)
3903 {
3904 s7_inst.relax_inst |= ((((s7_inst.instruction >> 8) & 0xf) | 0x10) << 20)
3905 | (((s7_inst.instruction >> 4) & 0x7) << 15) | (4 << 3);
3906 }
3907 else
3908 {
3909 s7_inst.relax_inst |= (((s7_inst.instruction >> 8) & 0xf) << 20)
3910 | (((s7_inst.instruction >> 4) & 0x7) << 15) | (4 << 3);
3911 }
3912 }
3913 /* push! */
3914 else
3915 {
3916 if (H_bit_mask)
3917 {
3918 s7_inst.relax_inst |= ((((s7_inst.instruction >> 8) & 0xf) | 0x10) << 20)
3919 | (((s7_inst.instruction >> 4) & 0x7) << 15) | (((-4) & 0xfff) << 3);
3920 }
3921 else
3922 {
3923 s7_inst.relax_inst |= (((s7_inst.instruction >> 8) & 0xf) << 20)
3924 | (((s7_inst.instruction >> 4) & 0x7) << 15) | (((-4) & 0xfff) << 3);
3925 }
3926 }
3927 s7_inst.relax_size = 4;
3928 }
3929 else
3930 {
3931 s7_inst.error = s7_BAD_ARGS;
3932 }
3933 }
3934
3935 /* Handle lcb/lcw/lce/scb/scw/sce. */
3936 static void
3937 s7_do_ldst_unalign (char *str)
3938 {
3939 int conflict_reg;
3940
3941 if (s7_university_version == 1)
3942 {
3943 s7_inst.error = s7_ERR_FOR_SCORE5U_ATOMIC;
3944 return;
3945 }
3946
3947 s7_skip_whitespace (str);
3948
3949 /* lcb/scb [rA]+. */
3950 if (*str == '[')
3951 {
3952 str++;
3953 s7_skip_whitespace (str);
3954
3955 if (s7_reg_required_here (&str, 15, s7_REG_TYPE_SCORE) == (int) s7_FAIL)
3956 return;
3957
3958 if (*str++ == ']')
3959 {
3960 if (*str++ != '+')
3961 {
3962 s7_inst.error = _("missing +");
3963 return;
3964 }
3965 }
3966 else
3967 {
3968 s7_inst.error = _("missing ]");
3969 return;
3970 }
3971
3972 if (s7_end_of_line (str) == (int) s7_FAIL)
3973 return;
3974 }
3975 /* lcw/lce/scb/sce rD, [rA]+. */
3976 else
3977 {
3978 if (((conflict_reg = s7_reg_required_here (&str, 20, s7_REG_TYPE_SCORE)) == (int) s7_FAIL)
3979 || (s7_skip_past_comma (&str) == (int) s7_FAIL))
3980 {
3981 return;
3982 }
3983
3984 s7_skip_whitespace (str);
3985 if (*str++ == '[')
3986 {
3987 int reg;
3988
3989 s7_skip_whitespace (str);
3990 if ((reg = s7_reg_required_here (&str, 15, s7_REG_TYPE_SCORE)) == (int) s7_FAIL)
3991 {
3992 return;
3993 }
3994
3995 /* Conflicts can occur on stores as well as loads. */
3996 conflict_reg = (conflict_reg == reg);
3997 s7_skip_whitespace (str);
3998 if (*str++ == ']')
3999 {
4000 unsigned int ldst_func = s7_inst.instruction & LDST_UNALIGN_MASK;
4001
4002 if (*str++ == '+')
4003 {
4004 if (conflict_reg)
4005 {
4006 as_warn (_("%s register same as write-back base"),
4007 ((ldst_func & UA_LCE) || (ldst_func & UA_LCW)
4008 ? _("destination") : _("source")));
4009 }
4010 }
4011 else
4012 {
4013 s7_inst.error = _("missing +");
4014 return;
4015 }
4016
4017 if (s7_end_of_line (str) == (int) s7_FAIL)
4018 return;
4019 }
4020 else
4021 {
4022 s7_inst.error = _("missing ]");
4023 return;
4024 }
4025 }
4026 else
4027 {
4028 s7_inst.error = s7_BAD_ARGS;
4029 return;
4030 }
4031 }
4032 }
4033
4034 /* Handle alw/asw. */
4035
4036 static void
4037 s7_do_ldst_atomic (char *str)
4038 {
4039 if (s7_university_version == 1)
4040 {
4041 s7_inst.error = s7_ERR_FOR_SCORE5U_ATOMIC;
4042 return;
4043 }
4044
4045 s7_skip_whitespace (str);
4046
4047 if ((s7_reg_required_here (&str, 20, s7_REG_TYPE_SCORE) == (int) s7_FAIL)
4048 || (s7_skip_past_comma (&str) == (int) s7_FAIL))
4049 {
4050 return;
4051 }
4052 else
4053 {
4054
4055 s7_skip_whitespace (str);
4056 if (*str++ == '[')
4057 {
4058 int reg;
4059
4060 s7_skip_whitespace (str);
4061 if ((reg = s7_reg_required_here (&str, 15, s7_REG_TYPE_SCORE)) == (int) s7_FAIL)
4062 {
4063 return;
4064 }
4065
4066 s7_skip_whitespace (str);
4067 if (*str++ != ']')
4068 {
4069 s7_inst.error = _("missing ]");
4070 return;
4071 }
4072
4073 s7_end_of_line (str);
4074 }
4075 else
4076 s7_inst.error = s7_BAD_ARGS;
4077 }
4078 }
4079
4080 static void
4081 s7_build_relax_frag (struct s7_score_it fix_insts[s7_RELAX_INST_NUM],
4082 int fix_num ATTRIBUTE_UNUSED,
4083 struct s7_score_it var_insts[s7_RELAX_INST_NUM], int var_num,
4084 symbolS *add_symbol)
4085 {
4086 int i;
4087 char *p;
4088 fixS *fixp = NULL;
4089 fixS *cur_fixp = NULL;
4090 long where;
4091 struct s7_score_it inst_main;
4092
4093 memcpy (&inst_main, &fix_insts[0], sizeof (struct s7_score_it));
4094
4095 /* Adjust instruction opcode and to be relaxed instruction opcode. */
4096 inst_main.instruction = s7_adjust_paritybit (inst_main.instruction, s7_GET_INSN_CLASS (inst_main.type));
4097 inst_main.type = Insn_PIC;
4098
4099 for (i = 0; i < var_num; i++)
4100 {
4101 inst_main.relax_size += var_insts[i].size;
4102 var_insts[i].instruction = s7_adjust_paritybit (var_insts[i].instruction,
4103 s7_GET_INSN_CLASS (var_insts[i].type));
4104 }
4105
4106 /* Check data dependency. */
4107 s7_handle_dependency (&inst_main);
4108
4109 /* Start a new frag if frag_now is not empty. */
4110 if (frag_now_fix () != 0)
4111 {
4112 if (!frag_now->tc_frag_data.is_insn)
4113 {
4114 frag_wane (frag_now);
4115 }
4116 frag_new (0);
4117 }
4118 frag_grow (20);
4119
4120 /* Write fr_fix part. */
4121 p = frag_more (inst_main.size);
4122 s7_number_to_chars (p, inst_main.instruction, inst_main.size);
4123
4124 if (inst_main.reloc.type != BFD_RELOC_NONE)
4125 fixp = s7_fix_new_score (frag_now, p - frag_now->fr_literal, inst_main.size,
4126 &inst_main.reloc.exp, inst_main.reloc.pc_rel, inst_main.reloc.type);
4127
4128 frag_now->tc_frag_data.fixp = fixp;
4129 cur_fixp = frag_now->tc_frag_data.fixp;
4130
4131 #ifdef OBJ_ELF
4132 dwarf2_emit_insn (inst_main.size);
4133 #endif
4134
4135 where = p - frag_now->fr_literal + inst_main.size;
4136 for (i = 0; i < var_num; i++)
4137 {
4138 if (i > 0)
4139 where += var_insts[i - 1].size;
4140
4141 if (var_insts[i].reloc.type != BFD_RELOC_NONE)
4142 {
4143 fixp = s7_fix_new_score (frag_now, where, var_insts[i].size,
4144 &var_insts[i].reloc.exp, var_insts[i].reloc.pc_rel,
4145 var_insts[i].reloc.type);
4146 if (fixp)
4147 {
4148 if (cur_fixp)
4149 {
4150 cur_fixp->fx_next = fixp;
4151 cur_fixp = cur_fixp->fx_next;
4152 }
4153 else
4154 {
4155 frag_now->tc_frag_data.fixp = fixp;
4156 cur_fixp = frag_now->tc_frag_data.fixp;
4157 }
4158 }
4159 }
4160 }
4161
4162 p = frag_var (rs_machine_dependent, inst_main.relax_size + s7_RELAX_PAD_BYTE, 0,
4163 s7_RELAX_ENCODE (inst_main.size, inst_main.relax_size, inst_main.type,
4164 0, inst_main.size, 0), add_symbol, 0, NULL);
4165
4166 /* Write fr_var part.
4167 no calling s7_gen_insn_frag, no fixS will be generated. */
4168 for (i = 0; i < var_num; i++)
4169 {
4170 s7_number_to_chars (p, var_insts[i].instruction, var_insts[i].size);
4171 p += var_insts[i].size;
4172 }
4173 /* Set bwarn as -1, so macro instruction itself will not be generated frag. */
4174 s7_inst.bwarn = -1;
4175 }
4176
4177 /* Build a relax frag for la instruction when generating s7_PIC,
4178 external symbol first and local symbol second. */
4179
4180 static void
4181 s7_build_la_pic (int reg_rd, expressionS exp)
4182 {
4183 symbolS *add_symbol = exp.X_add_symbol;
4184 offsetT add_number = exp.X_add_number;
4185 struct s7_score_it fix_insts[s7_RELAX_INST_NUM];
4186 struct s7_score_it var_insts[s7_RELAX_INST_NUM];
4187 int fix_num = 0;
4188 int var_num = 0;
4189 char tmp[s7_MAX_LITERAL_POOL_SIZE];
4190 int r1_bak;
4191
4192 r1_bak = s7_nor1;
4193 s7_nor1 = 0;
4194
4195 if (add_number == 0)
4196 {
4197 fix_num = 1;
4198 var_num = 2;
4199
4200 /* For an external symbol, only one insn is generated;
4201 For a local symbol, two insns are generated. */
4202 /* Fix part
4203 For an external symbol: lw rD, <sym>($gp)
4204 (BFD_RELOC_SCORE_GOT15 or BFD_RELOC_SCORE_CALL15) */
4205 sprintf (tmp, "lw_pic r%d, %s", reg_rd, add_symbol->bsym->name);
4206 if (s7_append_insn (tmp, FALSE) == (int) s7_FAIL)
4207 return;
4208
4209 if (reg_rd == s7_PIC_CALL_REG)
4210 s7_inst.reloc.type = BFD_RELOC_SCORE_CALL15;
4211 memcpy (&fix_insts[0], &s7_inst, sizeof (struct s7_score_it));
4212
4213 /* Var part
4214 For a local symbol :
4215 lw rD, <sym>($gp) (BFD_RELOC_SCORE_GOT15)
4216 addi rD, <sym> (BFD_RELOC_GOT_LO16) */
4217 s7_inst.reloc.type = BFD_RELOC_SCORE_GOT15;
4218 memcpy (&var_insts[0], &s7_inst, sizeof (struct s7_score_it));
4219 sprintf (tmp, "addi_s_pic r%d, %s", reg_rd, add_symbol->bsym->name);
4220 if (s7_append_insn (tmp, FALSE) == (int) s7_FAIL)
4221 return;
4222
4223 memcpy (&var_insts[1], &s7_inst, sizeof (struct s7_score_it));
4224 s7_build_relax_frag (fix_insts, fix_num, var_insts, var_num, add_symbol);
4225 }
4226 else if (add_number >= -0x8000 && add_number <= 0x7fff)
4227 {
4228 /* Insn 1: lw rD, <sym>($gp) (BFD_RELOC_SCORE_GOT15) */
4229 sprintf (tmp, "lw_pic r%d, %s", reg_rd, add_symbol->bsym->name);
4230 if (s7_append_insn (tmp, TRUE) == (int) s7_FAIL)
4231 return;
4232
4233 /* Insn 2 */
4234 fix_num = 1;
4235 var_num = 1;
4236 /* Fix part
4237 For an external symbol: addi rD, <constant> */
4238 sprintf (tmp, "addi r%d, %d", reg_rd, (int) add_number);
4239 if (s7_append_insn (tmp, FALSE) == (int) s7_FAIL)
4240 return;
4241
4242 memcpy (&fix_insts[0], &s7_inst, sizeof (struct s7_score_it));
4243
4244 /* Var part
4245 For a local symbol: addi rD, <sym>+<constant> (BFD_RELOC_GOT_LO16) */
4246 sprintf (tmp, "addi_s_pic r%d, %s + %d", reg_rd, add_symbol->bsym->name, (int) add_number);
4247 if (s7_append_insn (tmp, FALSE) == (int) s7_FAIL)
4248 return;
4249
4250 memcpy (&var_insts[0], &s7_inst, sizeof (struct s7_score_it));
4251 s7_build_relax_frag (fix_insts, fix_num, var_insts, var_num, add_symbol);
4252 }
4253 else
4254 {
4255 int hi = (add_number >> 16) & 0x0000FFFF;
4256 int lo = add_number & 0x0000FFFF;
4257
4258 /* Insn 1: lw rD, <sym>($gp) (BFD_RELOC_SCORE_GOT15) */
4259 sprintf (tmp, "lw_pic r%d, %s", reg_rd, add_symbol->bsym->name);
4260 if (s7_append_insn (tmp, TRUE) == (int) s7_FAIL)
4261 return;
4262
4263 /* Insn 2 */
4264 fix_num = 1;
4265 var_num = 1;
4266 /* Fix part
4267 For an external symbol: ldis r1, HI%<constant> */
4268 sprintf (tmp, "ldis r1, %d", hi);
4269 if (s7_append_insn (tmp, FALSE) == (int) s7_FAIL)
4270 return;
4271
4272 memcpy (&fix_insts[0], &s7_inst, sizeof (struct s7_score_it));
4273
4274 /* Var part
4275 For a local symbol: ldis r1, HI%<constant>
4276 but, if lo is outof 16 bit, make hi plus 1 */
4277 if ((lo < -0x8000) || (lo > 0x7fff))
4278 {
4279 hi += 1;
4280 }
4281 sprintf (tmp, "ldis_pic r1, %d", hi);
4282 if (s7_append_insn (tmp, FALSE) == (int) s7_FAIL)
4283 return;
4284
4285 memcpy (&var_insts[0], &s7_inst, sizeof (struct s7_score_it));
4286 s7_build_relax_frag (fix_insts, fix_num, var_insts, var_num, add_symbol);
4287
4288 /* Insn 3 */
4289 fix_num = 1;
4290 var_num = 1;
4291 /* Fix part
4292 For an external symbol: ori r1, LO%<constant> */
4293 sprintf (tmp, "ori r1, %d", lo);
4294 if (s7_append_insn (tmp, FALSE) == (int) s7_FAIL)
4295 return;
4296
4297 memcpy (&fix_insts[0], &s7_inst, sizeof (struct s7_score_it));
4298
4299 /* Var part
4300 For a local symbol: addi r1, <sym>+LO%<constant> (BFD_RELOC_GOT_LO16) */
4301 sprintf (tmp, "addi_u_pic r1, %s + %d", add_symbol->bsym->name, lo);
4302 if (s7_append_insn (tmp, FALSE) == (int) s7_FAIL)
4303 return;
4304
4305 memcpy (&var_insts[0], &s7_inst, sizeof (struct s7_score_it));
4306 s7_build_relax_frag (fix_insts, fix_num, var_insts, var_num, add_symbol);
4307
4308 /* Insn 4: add rD, rD, r1 */
4309 sprintf (tmp, "add r%d, r%d, r1", reg_rd, reg_rd);
4310 if (s7_append_insn (tmp, TRUE) == (int) s7_FAIL)
4311 return;
4312
4313 /* Set bwarn as -1, so macro instruction itself will not be generated frag. */
4314 s7_inst.bwarn = -1;
4315 }
4316
4317 s7_nor1 = r1_bak;
4318 }
4319
4320 /* Handle la. */
4321
4322 static void
4323 s7_do_macro_la_rdi32 (char *str)
4324 {
4325 int reg_rd;
4326
4327 s7_skip_whitespace (str);
4328 if ((reg_rd = s7_reg_required_here (&str, 20, s7_REG_TYPE_SCORE)) == (int) s7_FAIL
4329 || s7_skip_past_comma (&str) == (int) s7_FAIL)
4330 {
4331 return;
4332 }
4333 else
4334 {
4335 char append_str[s7_MAX_LITERAL_POOL_SIZE];
4336 char *keep_data = str;
4337
4338 /* Check immediate value. */
4339 if (s7_my_get_expression (&s7_inst.reloc.exp, &str) == (int) s7_FAIL)
4340 {
4341 s7_inst.error = _("expression error");
4342 return;
4343 }
4344 else if ((s7_inst.reloc.exp.X_add_symbol == NULL)
4345 && (s7_validate_immediate (s7_inst.reloc.exp.X_add_number, _IMM32, 0) == (int) s7_FAIL))
4346 {
4347 s7_inst.error = _("value not in range [0, 0xffffffff]");
4348 return;
4349 }
4350
4351 /* Reset str. */
4352 str = keep_data;
4353
4354 /* la rd, simm16. */
4355 if (s7_data_op2 (&str, 1, _SIMM16_LA) != (int) s7_FAIL)
4356 {
4357 s7_end_of_line (str);
4358 return;
4359 }
4360 /* la rd, imm32 or la rd, label. */
4361 else
4362 {
4363 s7_SET_INSN_ERROR (NULL);
4364 str = keep_data;
4365 if ((s7_data_op2 (&str, 1, _VALUE_HI16) == (int) s7_FAIL)
4366 || (s7_end_of_line (str) == (int) s7_FAIL))
4367 {
4368 return;
4369 }
4370 else
4371 {
4372 if ((s7_score_pic == s7_NO_PIC) || (!s7_inst.reloc.exp.X_add_symbol))
4373 {
4374 sprintf (append_str, "ld_i32hi r%d, %s", reg_rd, keep_data);
4375 if (s7_append_insn (append_str, TRUE) == (int) s7_FAIL)
4376 return;
4377
4378 sprintf (append_str, "ld_i32lo r%d, %s", reg_rd, keep_data);
4379 if (s7_append_insn (append_str, TRUE) == (int) s7_FAIL)
4380 return;
4381 }
4382 else
4383 {
4384 gas_assert (s7_inst.reloc.exp.X_add_symbol);
4385 s7_build_la_pic (reg_rd, s7_inst.reloc.exp);
4386 }
4387
4388 /* Set bwarn as -1, so macro instruction itself will not be generated frag. */
4389 s7_inst.bwarn = -1;
4390 }
4391 }
4392 }
4393 }
4394
4395 /* Handle li. */
4396
4397 static void
4398 s7_do_macro_li_rdi32 (char *str)
4399 {
4400 int reg_rd;
4401
4402 s7_skip_whitespace (str);
4403 if ((reg_rd = s7_reg_required_here (&str, 20, s7_REG_TYPE_SCORE)) == (int) s7_FAIL
4404 || s7_skip_past_comma (&str) == (int) s7_FAIL)
4405 {
4406 return;
4407 }
4408 else
4409 {
4410 char *keep_data = str;
4411
4412 /* Check immediate value. */
4413 if (s7_my_get_expression (&s7_inst.reloc.exp, &str) == (int) s7_FAIL)
4414 {
4415 s7_inst.error = _("expression error");
4416 return;
4417 }
4418 else if (!(s7_inst.reloc.exp.X_add_number >= -0xffffffffLL
4419 && s7_inst.reloc.exp.X_add_number <= 0xffffffffLL))
4420 {
4421 s7_inst.error = _("value not in range [-0xffffffff, 0xffffffff]");
4422 return;
4423 }
4424
4425 /* Reset str. */
4426 str = keep_data;
4427
4428 /* li rd, simm16. */
4429 if (s7_data_op2 (&str, 1, _SIMM16_LA) != (int) s7_FAIL)
4430 {
4431 s7_end_of_line (str);
4432 return;
4433 }
4434 /* li rd, imm32. */
4435 else
4436 {
4437 char append_str[s7_MAX_LITERAL_POOL_SIZE];
4438
4439 str = keep_data;
4440
4441 if ((s7_data_op2 (&str, 1, _VALUE_HI16) == (int) s7_FAIL)
4442 || (s7_end_of_line (str) == (int) s7_FAIL))
4443 {
4444 return;
4445 }
4446 else if (s7_inst.reloc.exp.X_add_symbol)
4447 {
4448 s7_inst.error = _("li rd label isn't correct instruction form");
4449 return;
4450 }
4451 else
4452 {
4453 sprintf (append_str, "ld_i32hi r%d, %s", reg_rd, keep_data);
4454
4455 if (s7_append_insn (append_str, TRUE) == (int) s7_FAIL)
4456 return;
4457 else
4458 {
4459 sprintf (append_str, "ld_i32lo r%d, %s", reg_rd, keep_data);
4460 if (s7_append_insn (append_str, TRUE) == (int) s7_FAIL)
4461 return;
4462
4463 /* Set bwarn as -1, so macro instruction itself will not be generated frag. */
4464 s7_inst.bwarn = -1;
4465 }
4466 }
4467 }
4468 }
4469 }
4470
4471 /* Handle mul/mulu/div/divu/rem/remu. */
4472
4473 static void
4474 s7_do_macro_mul_rdrsrs (char *str)
4475 {
4476 int reg_rd;
4477 int reg_rs1;
4478 int reg_rs2;
4479 char *backupstr;
4480 char append_str[s7_MAX_LITERAL_POOL_SIZE];
4481
4482 if (s7_university_version == 1)
4483 as_warn ("%s", s7_ERR_FOR_SCORE5U_MUL_DIV);
4484
4485 strcpy (append_str, str);
4486 backupstr = append_str;
4487 s7_skip_whitespace (backupstr);
4488 if (((reg_rd = s7_reg_required_here (&backupstr, -1, s7_REG_TYPE_SCORE)) == (int) s7_FAIL)
4489 || (s7_skip_past_comma (&backupstr) == (int) s7_FAIL)
4490 || ((reg_rs1 = s7_reg_required_here (&backupstr, -1, s7_REG_TYPE_SCORE)) == (int) s7_FAIL))
4491 {
4492 s7_inst.error = s7_BAD_ARGS;
4493 return;
4494 }
4495
4496 if (s7_skip_past_comma (&backupstr) == (int) s7_FAIL)
4497 {
4498 /* rem/remu rA, rB is error format. */
4499 if (strcmp (s7_inst.name, "rem") == 0 || strcmp (s7_inst.name, "remu") == 0)
4500 {
4501 s7_SET_INSN_ERROR (s7_BAD_ARGS);
4502 }
4503 else
4504 {
4505 s7_SET_INSN_ERROR (NULL);
4506 s7_do_rsrs (str);
4507 }
4508 return;
4509 }
4510 else
4511 {
4512 s7_SET_INSN_ERROR (NULL);
4513 if (((reg_rs2 = s7_reg_required_here (&backupstr, -1, s7_REG_TYPE_SCORE)) == (int) s7_FAIL)
4514 || (s7_end_of_line (backupstr) == (int) s7_FAIL))
4515 {
4516 return;
4517 }
4518 else
4519 {
4520 char append_str1[s7_MAX_LITERAL_POOL_SIZE];
4521
4522 if (strcmp (s7_inst.name, "rem") == 0)
4523 {
4524 sprintf (append_str, "mul r%d, r%d", reg_rs1, reg_rs2);
4525 sprintf (append_str1, "mfceh r%d", reg_rd);
4526 }
4527 else if (strcmp (s7_inst.name, "remu") == 0)
4528 {
4529 sprintf (append_str, "mulu r%d, r%d", reg_rs1, reg_rs2);
4530 sprintf (append_str1, "mfceh r%d", reg_rd);
4531 }
4532 else
4533 {
4534 sprintf (append_str, "%s r%d, r%d", s7_inst.name, reg_rs1, reg_rs2);
4535 sprintf (append_str1, "mfcel r%d", reg_rd);
4536 }
4537
4538 /* Output mul/mulu or div/divu or rem/remu. */
4539 if (s7_append_insn (append_str, TRUE) == (int) s7_FAIL)
4540 return;
4541
4542 /* Output mfcel or mfceh. */
4543 if (s7_append_insn (append_str1, TRUE) == (int) s7_FAIL)
4544 return;
4545
4546 /* Set bwarn as -1, so macro instruction itself will not be generated frag. */
4547 s7_inst.bwarn = -1;
4548 }
4549 }
4550 }
4551
4552 static void
4553 s7_exp_macro_ldst_abs (char *str)
4554 {
4555 int reg_rd;
4556 char *backupstr, *tmp;
4557 char append_str[s7_MAX_LITERAL_POOL_SIZE];
4558 char verifystr[s7_MAX_LITERAL_POOL_SIZE];
4559 struct s7_score_it inst_backup;
4560 int r1_bak = 0;
4561
4562 r1_bak = s7_nor1;
4563 s7_nor1 = 0;
4564 memcpy (&inst_backup, &s7_inst, sizeof (struct s7_score_it));
4565
4566 strcpy (verifystr, str);
4567 backupstr = verifystr;
4568 s7_skip_whitespace (backupstr);
4569 if ((reg_rd = s7_reg_required_here (&backupstr, -1, s7_REG_TYPE_SCORE)) == (int) s7_FAIL)
4570 return;
4571
4572 tmp = backupstr;
4573 if (s7_skip_past_comma (&backupstr) == (int) s7_FAIL)
4574 return;
4575
4576 backupstr = tmp;
4577 sprintf (append_str, "li r1 %s", backupstr);
4578 s7_append_insn (append_str, TRUE);
4579
4580 memcpy (&s7_inst, &inst_backup, sizeof (struct s7_score_it));
4581 sprintf (append_str, " r%d, [r1,0]", reg_rd);
4582 s7_do_ldst_insn (append_str);
4583
4584 s7_nor1 = r1_bak;
4585 }
4586
4587 static int
4588 s7_nopic_need_relax (symbolS * sym, int before_relaxing)
4589 {
4590 if (sym == NULL)
4591 return 0;
4592 else if (s7_USE_GLOBAL_POINTER_OPT && s7_g_switch_value > 0)
4593 {
4594 const char *symname;
4595 const char *segname;
4596
4597 /* Find out whether this symbol can be referenced off the $gp
4598 register. It can be if it is smaller than the -G size or if
4599 it is in the .sdata or .sbss section. Certain symbols can
4600 not be referenced off the $gp, although it appears as though
4601 they can. */
4602 symname = S_GET_NAME (sym);
4603 if (symname != NULL
4604 && (strcmp (symname, "eprol") == 0
4605 || strcmp (symname, "etext") == 0
4606 || strcmp (symname, "_gp") == 0
4607 || strcmp (symname, "edata") == 0
4608 || strcmp (symname, "_fbss") == 0
4609 || strcmp (symname, "_fdata") == 0
4610 || strcmp (symname, "_ftext") == 0
4611 || strcmp (symname, "end") == 0
4612 || strcmp (symname, GP_DISP_LABEL) == 0))
4613 {
4614 return 1;
4615 }
4616 else if ((!S_IS_DEFINED (sym) || S_IS_COMMON (sym)) && (0
4617 /* We must defer this decision until after the whole file has been read,
4618 since there might be a .extern after the first use of this symbol. */
4619 || (before_relaxing
4620 && S_GET_VALUE (sym) == 0)
4621 || (S_GET_VALUE (sym) != 0
4622 && S_GET_VALUE (sym) <= s7_g_switch_value)))
4623 {
4624 return 0;
4625 }
4626
4627 segname = segment_name (S_GET_SEGMENT (sym));
4628 return (strcmp (segname, ".sdata") != 0
4629 && strcmp (segname, ".sbss") != 0
4630 && strncmp (segname, ".sdata.", 7) != 0
4631 && strncmp (segname, ".gnu.linkonce.s.", 16) != 0);
4632 }
4633 /* We are not optimizing for the $gp register. */
4634 else
4635 return 1;
4636 }
4637
4638 /* Build a relax frag for lw/st instruction when generating s7_PIC,
4639 external symbol first and local symbol second. */
4640
4641 static void
4642 s7_build_lwst_pic (int reg_rd, expressionS exp, const char *insn_name)
4643 {
4644 symbolS *add_symbol = exp.X_add_symbol;
4645 int add_number = exp.X_add_number;
4646 struct s7_score_it fix_insts[s7_RELAX_INST_NUM];
4647 struct s7_score_it var_insts[s7_RELAX_INST_NUM];
4648 int fix_num = 0;
4649 int var_num = 0;
4650 char tmp[s7_MAX_LITERAL_POOL_SIZE];
4651 int r1_bak;
4652
4653 r1_bak = s7_nor1;
4654 s7_nor1 = 0;
4655
4656 if ((add_number == 0) || (add_number >= -0x8000 && add_number <= 0x7fff))
4657 {
4658 fix_num = 1;
4659 var_num = 2;
4660
4661 /* For an external symbol, two insns are generated;
4662 For a local symbol, three insns are generated. */
4663 /* Fix part
4664 For an external symbol: lw rD, <sym>($gp)
4665 (BFD_RELOC_SCORE_GOT15) */
4666 sprintf (tmp, "lw_pic r1, %s", add_symbol->bsym->name);
4667 if (s7_append_insn (tmp, FALSE) == (int) s7_FAIL)
4668 return;
4669
4670 memcpy (&fix_insts[0], &s7_inst, sizeof (struct s7_score_it));
4671
4672 /* Var part
4673 For a local symbol :
4674 lw rD, <sym>($gp) (BFD_RELOC_SCORE_GOT15)
4675 addi rD, <sym> (BFD_RELOC_GOT_LO16) */
4676 s7_inst.reloc.type = BFD_RELOC_SCORE_GOT15;
4677 memcpy (&var_insts[0], &s7_inst, sizeof (struct s7_score_it));
4678 sprintf (tmp, "addi_s_pic r1, %s", add_symbol->bsym->name);
4679 if (s7_append_insn (tmp, FALSE) == (int) s7_FAIL)
4680 return;
4681
4682 memcpy (&var_insts[1], &s7_inst, sizeof (struct s7_score_it));
4683 s7_build_relax_frag (fix_insts, fix_num, var_insts, var_num, add_symbol);
4684
4685 /* Insn 2 or Insn 3: lw/st rD, [r1, constant] */
4686 sprintf (tmp, "%s r%d, [r1, %d]", insn_name, reg_rd, add_number);
4687 if (s7_append_insn (tmp, TRUE) == (int) s7_FAIL)
4688 return;
4689
4690 /* Set bwarn as -1, so macro instruction itself will not be generated frag. */
4691 s7_inst.bwarn = -1;
4692 }
4693 else
4694 {
4695 s7_inst.error = _("PIC code offset overflow (max 16 signed bits)");
4696 return;
4697 }
4698
4699 s7_nor1 = r1_bak;
4700 }
4701
4702 static void
4703 s7_do_macro_ldst_label (char *str)
4704 {
4705 int i;
4706 int ldst_gp_p = 0;
4707 int reg_rd;
4708 int r1_bak;
4709 char *backup_str;
4710 char *label_str;
4711 char *absolute_value;
4712 char append_str[3][s7_MAX_LITERAL_POOL_SIZE];
4713 char verifystr[s7_MAX_LITERAL_POOL_SIZE];
4714 struct s7_score_it inst_backup;
4715 struct s7_score_it inst_expand[3];
4716 struct s7_score_it inst_main;
4717
4718 memcpy (&inst_backup, &s7_inst, sizeof (struct s7_score_it));
4719 strcpy (verifystr, str);
4720 backup_str = verifystr;
4721
4722 s7_skip_whitespace (backup_str);
4723 if ((reg_rd = s7_reg_required_here (&backup_str, -1, s7_REG_TYPE_SCORE)) == (int) s7_FAIL)
4724 return;
4725
4726 if (s7_skip_past_comma (&backup_str) == (int) s7_FAIL)
4727 return;
4728
4729 label_str = backup_str;
4730
4731 /* Ld/st rD, [rA, imm] ld/st rD, [rA]+, imm ld/st rD, [rA, imm]+. */
4732 if (*backup_str == '[')
4733 {
4734 s7_inst.type = Rd_rvalueRs_preSI12;
4735 s7_do_ldst_insn (str);
4736 return;
4737 }
4738
4739 /* Ld/st rD, imm. */
4740 absolute_value = backup_str;
4741 s7_inst.type = Rd_rvalueRs_SI15;
4742
4743 if (s7_my_get_expression (&s7_inst.reloc.exp, &backup_str) == (int) s7_FAIL)
4744 {
4745 s7_inst.error = _("expression error");
4746 return;
4747 }
4748 else if ((s7_inst.reloc.exp.X_add_symbol == NULL)
4749 && (s7_validate_immediate (s7_inst.reloc.exp.X_add_number, _VALUE, 0) == (int) s7_FAIL))
4750 {
4751 s7_inst.error = _("value not in range [0, 0x7fffffff]");
4752 return;
4753 }
4754 else if (s7_end_of_line (backup_str) == (int) s7_FAIL)
4755 {
4756 s7_inst.error = _("end on line error");
4757 return;
4758 }
4759 else
4760 {
4761 if (s7_inst.reloc.exp.X_add_symbol == 0)
4762 {
4763 memcpy (&s7_inst, &inst_backup, sizeof (struct s7_score_it));
4764 s7_exp_macro_ldst_abs (str);
4765 return;
4766 }
4767 }
4768
4769 /* Ld/st rD, label. */
4770 s7_inst.type = Rd_rvalueRs_SI15;
4771 backup_str = absolute_value;
4772 if ((s7_data_op2 (&backup_str, 1, _GP_IMM15) == (int) s7_FAIL)
4773 || (s7_end_of_line (backup_str) == (int) s7_FAIL))
4774 {
4775 return;
4776 }
4777 else
4778 {
4779 if (s7_inst.reloc.exp.X_add_symbol == 0)
4780 {
4781 if (!s7_inst.error)
4782 s7_inst.error = s7_BAD_ARGS;
4783
4784 return;
4785 }
4786
4787 if (s7_score_pic == s7_PIC)
4788 {
4789 int ldst_idx = 0;
4790 ldst_idx = s7_inst.instruction & OPC_PSEUDOLDST_MASK;
4791 s7_build_lwst_pic (reg_rd, s7_inst.reloc.exp,
4792 s7_score_ldst_insns[ldst_idx * 3 + 0].template_name);
4793 return;
4794 }
4795 else
4796 {
4797 if ((s7_inst.reloc.exp.X_add_number <= 0x3fff)
4798 && (s7_inst.reloc.exp.X_add_number >= -0x4000)
4799 && (!s7_nopic_need_relax (s7_inst.reloc.exp.X_add_symbol, 1)))
4800 {
4801 int ldst_idx = 0;
4802
4803 /* Assign the real opcode. */
4804 ldst_idx = s7_inst.instruction & OPC_PSEUDOLDST_MASK;
4805 s7_inst.instruction &= ~OPC_PSEUDOLDST_MASK;
4806 s7_inst.instruction |= s7_score_ldst_insns[ldst_idx * 3 + 0].value;
4807 s7_inst.instruction |= reg_rd << 20;
4808 s7_inst.instruction |= s7_GP << 15;
4809 s7_inst.relax_inst = 0x8000;
4810 s7_inst.relax_size = 0;
4811 ldst_gp_p = 1;
4812 }
4813 }
4814 }
4815
4816 /* Backup s7_inst. */
4817 memcpy (&inst_main, &s7_inst, sizeof (struct s7_score_it));
4818 r1_bak = s7_nor1;
4819 s7_nor1 = 0;
4820
4821 /* Determine which instructions should be output. */
4822 sprintf (append_str[0], "ld_i32hi r1, %s", label_str);
4823 sprintf (append_str[1], "ld_i32lo r1, %s", label_str);
4824 sprintf (append_str[2], "%s r%d, [r1, 0]", inst_backup.name, reg_rd);
4825
4826 /* Generate three instructions.
4827 la r1, label
4828 ld/st rd, [r1, 0] */
4829 for (i = 0; i < 3; i++)
4830 {
4831 if (s7_append_insn (append_str[i], FALSE) == (int) s7_FAIL)
4832 return;
4833
4834 memcpy (&inst_expand[i], &s7_inst, sizeof (struct s7_score_it));
4835 }
4836
4837 if (ldst_gp_p)
4838 {
4839 char *p;
4840
4841 /* Adjust instruction opcode and to be relaxed instruction opcode. */
4842 inst_main.instruction = s7_adjust_paritybit (inst_main.instruction, s7_GET_INSN_CLASS (inst_main.type));
4843 inst_main.relax_size = inst_expand[0].size + inst_expand[1].size + inst_expand[2].size;
4844 inst_main.type = Insn_GP;
4845
4846 for (i = 0; i < 3; i++)
4847 inst_expand[i].instruction = s7_adjust_paritybit (inst_expand[i].instruction
4848 , s7_GET_INSN_CLASS (inst_expand[i].type));
4849
4850 /* Check data dependency. */
4851 s7_handle_dependency (&inst_main);
4852
4853 /* Start a new frag if frag_now is not empty. */
4854 if (frag_now_fix () != 0)
4855 {
4856 if (!frag_now->tc_frag_data.is_insn)
4857 frag_wane (frag_now);
4858
4859 frag_new (0);
4860 }
4861 frag_grow (20);
4862
4863 /* Write fr_fix part. */
4864 p = frag_more (inst_main.size);
4865 s7_number_to_chars (p, inst_main.instruction, inst_main.size);
4866
4867 if (inst_main.reloc.type != BFD_RELOC_NONE)
4868 {
4869 s7_fix_new_score (frag_now, p - frag_now->fr_literal, inst_main.size,
4870 &inst_main.reloc.exp, inst_main.reloc.pc_rel, inst_main.reloc.type);
4871 }
4872
4873 #ifdef OBJ_ELF
4874 dwarf2_emit_insn (inst_main.size);
4875 #endif
4876
4877 /* s7_GP instruction can not do optimization, only can do relax between
4878 1 instruction and 3 instructions. */
4879 p = frag_var (rs_machine_dependent, inst_main.relax_size + s7_RELAX_PAD_BYTE, 0,
4880 s7_RELAX_ENCODE (inst_main.size, inst_main.relax_size, inst_main.type, 0, 4, 0),
4881 inst_main.reloc.exp.X_add_symbol, 0, NULL);
4882
4883 /* Write fr_var part.
4884 no calling s7_gen_insn_frag, no fixS will be generated. */
4885 s7_number_to_chars (p, inst_expand[0].instruction, inst_expand[0].size);
4886 p += inst_expand[0].size;
4887 s7_number_to_chars (p, inst_expand[1].instruction, inst_expand[1].size);
4888 p += inst_expand[1].size;
4889 s7_number_to_chars (p, inst_expand[2].instruction, inst_expand[2].size);
4890 }
4891 else
4892 {
4893 s7_gen_insn_frag (&inst_expand[0], NULL);
4894 s7_gen_insn_frag (&inst_expand[1], NULL);
4895 s7_gen_insn_frag (&inst_expand[2], NULL);
4896 }
4897 s7_nor1 = r1_bak;
4898
4899 /* Set bwarn as -1, so macro instruction itself will not be generated frag. */
4900 s7_inst.bwarn = -1;
4901 }
4902
4903 static void
4904 s7_do_lw_pic (char *str)
4905 {
4906 int reg_rd;
4907
4908 s7_skip_whitespace (str);
4909 if (((reg_rd = s7_reg_required_here (&str, 20, s7_REG_TYPE_SCORE)) == (int) s7_FAIL)
4910 || (s7_skip_past_comma (&str) == (int) s7_FAIL)
4911 || (s7_my_get_expression (&s7_inst.reloc.exp, &str) == (int) s7_FAIL)
4912 || (s7_end_of_line (str) == (int) s7_FAIL))
4913 {
4914 return;
4915 }
4916 else
4917 {
4918 if (s7_inst.reloc.exp.X_add_symbol == 0)
4919 {
4920 if (!s7_inst.error)
4921 s7_inst.error = s7_BAD_ARGS;
4922
4923 return;
4924 }
4925
4926 s7_inst.instruction |= s7_GP << 15;
4927 s7_inst.reloc.type = BFD_RELOC_SCORE_GOT15;
4928 }
4929 }
4930
4931 static void
4932 s7_do_empty (char *str)
4933 {
4934 str = str;
4935 if (s7_university_version == 1)
4936 {
4937 if (((s7_inst.instruction & 0x3e0003ff) == 0x0c000004)
4938 || ((s7_inst.instruction & 0x3e0003ff) == 0x0c000024)
4939 || ((s7_inst.instruction & 0x3e0003ff) == 0x0c000044)
4940 || ((s7_inst.instruction & 0x3e0003ff) == 0x0c000064))
4941 {
4942 s7_inst.error = s7_ERR_FOR_SCORE5U_MMU;
4943 return;
4944 }
4945 }
4946 if (s7_end_of_line (str) == (int) s7_FAIL)
4947 return;
4948
4949 if (s7_inst.relax_inst != 0x8000)
4950 {
4951 if (s7_inst.type == NO_OPD)
4952 {
4953 s7_inst.relax_size = 2;
4954 }
4955 else
4956 {
4957 s7_inst.relax_size = 4;
4958 }
4959 }
4960 }
4961
4962 static void
4963 s7_do_jump (char *str)
4964 {
4965 char *save_in;
4966
4967 s7_skip_whitespace (str);
4968 if (s7_my_get_expression (&s7_inst.reloc.exp, &str) == (int) s7_FAIL
4969 || s7_end_of_line (str) == (int) s7_FAIL)
4970 return;
4971
4972 if (s7_inst.reloc.exp.X_add_symbol == 0)
4973 {
4974 s7_inst.error = _("lacking label ");
4975 return;
4976 }
4977
4978 if (!(s7_inst.reloc.exp.X_add_number >= -16777216
4979 && s7_inst.reloc.exp.X_add_number <= 16777215))
4980 {
4981 s7_inst.error = _("invalid constant: 25 bit expression not in range [-16777216, 16777215]");
4982 return;
4983 }
4984
4985 save_in = input_line_pointer;
4986 input_line_pointer = str;
4987 s7_inst.reloc.type = BFD_RELOC_SCORE_JMP;
4988 s7_inst.reloc.pc_rel = 1;
4989 input_line_pointer = save_in;
4990 }
4991
4992 static void
4993 s7_do16_jump (char *str)
4994 {
4995 s7_skip_whitespace (str);
4996 if (s7_my_get_expression (&s7_inst.reloc.exp, &str) == (int) s7_FAIL
4997 || s7_end_of_line (str) == (int) s7_FAIL)
4998 {
4999 return;
5000 }
5001 else if (s7_inst.reloc.exp.X_add_symbol == 0)
5002 {
5003 s7_inst.error = _("lacking label ");
5004 return;
5005 }
5006 else if (!(s7_inst.reloc.exp.X_add_number >= 0
5007 && s7_inst.reloc.exp.X_add_number <= 4095))
5008 {
5009 s7_inst.error = _("invalid constant: 12 bit expression not in range [0, 4095]");
5010 return;
5011 }
5012
5013 s7_inst.reloc.type = BFD_RELOC_SCORE16_JMP;
5014 s7_inst.reloc.pc_rel = 1;
5015 }
5016
5017 static void
5018 s7_do_branch (char *str)
5019 {
5020 unsigned long abs_value = 0;
5021
5022 if (s7_my_get_expression (&s7_inst.reloc.exp, &str) == (int) s7_FAIL
5023 || s7_end_of_line (str) == (int) s7_FAIL)
5024 {
5025 return;
5026 }
5027 else if (s7_inst.reloc.exp.X_add_symbol == 0)
5028 {
5029 s7_inst.error = _("lacking label ");
5030 return;
5031 }
5032 else if (!(s7_inst.reloc.exp.X_add_number >= -524288
5033 && s7_inst.reloc.exp.X_add_number <= 524287))
5034 {
5035 s7_inst.error = _("invalid constant: 20 bit expression not in range -2^19..2^19");
5036 return;
5037 }
5038
5039 s7_inst.reloc.type = BFD_RELOC_SCORE_BRANCH;
5040 s7_inst.reloc.pc_rel = 1;
5041
5042 /* Branch 32 offset field : 20 bit, 16 bit branch offset field : 8 bit. */
5043 s7_inst.instruction |= (s7_inst.reloc.exp.X_add_number & 0x3fe) | ((s7_inst.reloc.exp.X_add_number & 0xffc00) << 5);
5044
5045 /* Compute 16 bit branch instruction. */
5046 if ((s7_inst.relax_inst != 0x8000) && (abs_value & 0xfffffe00) == 0)
5047 {
5048 s7_inst.relax_inst |= (((s7_inst.instruction >> 10) & 0xf) << 8);
5049 s7_inst.relax_inst |= ((s7_inst.reloc.exp.X_add_number >> 1) & 0xff);
5050 s7_inst.relax_size = 2;
5051 }
5052 else
5053 {
5054 s7_inst.relax_inst = 0x8000;
5055 }
5056 }
5057
5058 static void
5059 s7_do16_branch (char *str)
5060 {
5061 if ((s7_my_get_expression (&s7_inst.reloc.exp, &str) == (int) s7_FAIL
5062 || s7_end_of_line (str) == (int) s7_FAIL))
5063 {
5064 ;
5065 }
5066 else if (s7_inst.reloc.exp.X_add_symbol == 0)
5067 {
5068 s7_inst.error = _("lacking label");
5069 }
5070 else if (!(s7_inst.reloc.exp.X_add_number >= -512
5071 && s7_inst.reloc.exp.X_add_number <= 511))
5072 {
5073 s7_inst.error = _("invalid constant: 10 bit expression not in range [-2^9, 2^9-1]");
5074 }
5075 else
5076 {
5077 s7_inst.reloc.type = BFD_RELOC_SCORE16_BRANCH;
5078 s7_inst.reloc.pc_rel = 1;
5079 s7_inst.instruction |= ((s7_inst.reloc.exp.X_add_number >> 1) & 0xff);
5080 }
5081 }
5082
5083 /* Iterate over the base tables to create the instruction patterns. */
5084
5085 static void
5086 s7_build_score_ops_hsh (void)
5087 {
5088 unsigned int i;
5089 static struct obstack insn_obstack;
5090
5091 obstack_begin (&insn_obstack, 4000);
5092 for (i = 0; i < sizeof (s7_score_insns) / sizeof (struct s7_asm_opcode); i++)
5093 {
5094 const struct s7_asm_opcode *insn = s7_score_insns + i;
5095 unsigned len = strlen (insn->template_name);
5096 struct s7_asm_opcode *new_opcode;
5097 char *template_name;
5098 new_opcode = (struct s7_asm_opcode *)
5099 obstack_alloc (&insn_obstack, sizeof (struct s7_asm_opcode));
5100 template_name = (char *) obstack_alloc (&insn_obstack, len + 1);
5101
5102 strcpy (template_name, insn->template_name);
5103 new_opcode->template_name = template_name;
5104 new_opcode->parms = insn->parms;
5105 new_opcode->value = insn->value;
5106 new_opcode->relax_value = insn->relax_value;
5107 new_opcode->type = insn->type;
5108 new_opcode->bitmask = insn->bitmask;
5109 hash_insert (s7_score_ops_hsh, new_opcode->template_name,
5110 (void *) new_opcode);
5111 }
5112 }
5113
5114 static void
5115 s7_build_dependency_insn_hsh (void)
5116 {
5117 unsigned int i;
5118 static struct obstack dependency_obstack;
5119
5120 obstack_begin (&dependency_obstack, 4000);
5121 for (i = 0; i < ARRAY_SIZE (s7_insn_to_dependency_table); i++)
5122 {
5123 const struct s7_insn_to_dependency *tmp = s7_insn_to_dependency_table + i;
5124 unsigned len = strlen (tmp->insn_name);
5125 struct s7_insn_to_dependency *new_i2d;
5126
5127 new_i2d = (struct s7_insn_to_dependency *)
5128 obstack_alloc (&dependency_obstack,
5129 sizeof (struct s7_insn_to_dependency));
5130 new_i2d->insn_name = (char *) obstack_alloc (&dependency_obstack,
5131 len + 1);
5132
5133 strcpy (new_i2d->insn_name, tmp->insn_name);
5134 new_i2d->type = tmp->type;
5135 hash_insert (s7_dependency_insn_hsh, new_i2d->insn_name,
5136 (void *) new_i2d);
5137 }
5138 }
5139
5140 static valueT
5141 s7_md_chars_to_number (char *buf, int n)
5142 {
5143 valueT result = 0;
5144 unsigned char *where = (unsigned char *) buf;
5145
5146 if (target_big_endian)
5147 {
5148 while (n--)
5149 {
5150 result <<= 8;
5151 result |= (*where++ & 255);
5152 }
5153 }
5154 else
5155 {
5156 while (n--)
5157 {
5158 result <<= 8;
5159 result |= (where[n] & 255);
5160 }
5161 }
5162
5163 return result;
5164 }
5165
5166 /* Return true if the given symbol should be considered local for s7_PIC. */
5167
5168 static bfd_boolean
5169 s7_pic_need_relax (symbolS *sym, asection *segtype)
5170 {
5171 asection *symsec;
5172 bfd_boolean linkonce;
5173
5174 /* Handle the case of a symbol equated to another symbol. */
5175 while (symbol_equated_reloc_p (sym))
5176 {
5177 symbolS *n;
5178
5179 /* It's possible to get a loop here in a badly written
5180 program. */
5181 n = symbol_get_value_expression (sym)->X_add_symbol;
5182 if (n == sym)
5183 break;
5184 sym = n;
5185 }
5186
5187 symsec = S_GET_SEGMENT (sym);
5188
5189 /* Duplicate the test for LINK_ONCE sections as in adjust_reloc_syms */
5190 linkonce = FALSE;
5191 if (symsec != segtype && ! S_IS_LOCAL (sym))
5192 {
5193 if ((bfd_get_section_flags (stdoutput, symsec) & SEC_LINK_ONCE) != 0)
5194 linkonce = TRUE;
5195
5196 /* The GNU toolchain uses an extension for ELF: a section
5197 beginning with the magic string .gnu.linkonce is a linkonce
5198 section. */
5199 if (strncmp (segment_name (symsec), ".gnu.linkonce",
5200 sizeof ".gnu.linkonce" - 1) == 0)
5201 linkonce = TRUE;
5202 }
5203
5204 /* This must duplicate the test in adjust_reloc_syms. */
5205 return (symsec != &bfd_und_section
5206 && symsec != &bfd_abs_section
5207 && ! bfd_is_com_section (symsec)
5208 && !linkonce
5209 #ifdef OBJ_ELF
5210 /* A global or weak symbol is treated as external. */
5211 && (OUTPUT_FLAVOR != bfd_target_elf_flavour
5212 || (! S_IS_WEAK (sym) && ! S_IS_EXTERNAL (sym)))
5213 #endif
5214 );
5215 }
5216
5217 static int
5218 s7_judge_size_before_relax (fragS * fragp, asection *sec)
5219 {
5220 int change = 0;
5221
5222 if (s7_score_pic == s7_NO_PIC)
5223 change = s7_nopic_need_relax (fragp->fr_symbol, 0);
5224 else
5225 change = s7_pic_need_relax (fragp->fr_symbol, sec);
5226
5227 if (change == 1)
5228 {
5229 /* Only at the first time determining whether s7_GP instruction relax should be done,
5230 return the difference between insntruction size and instruction relax size. */
5231 if (fragp->fr_opcode == NULL)
5232 {
5233 fragp->fr_fix = s7_RELAX_NEW (fragp->fr_subtype);
5234 fragp->fr_opcode = fragp->fr_literal + s7_RELAX_RELOC1 (fragp->fr_subtype);
5235 return s7_RELAX_NEW (fragp->fr_subtype) - s7_RELAX_OLD (fragp->fr_subtype);
5236 }
5237 }
5238
5239 return 0;
5240 }
5241
5242 static int
5243 s7_b32_relax_to_b16 (fragS * fragp)
5244 {
5245 int grows = 0;
5246 int relaxable_p = 0;
5247 int r_old;
5248 int r_new;
5249 int frag_addr = fragp->fr_address + fragp->insn_addr;
5250
5251 addressT symbol_address = 0;
5252 symbolS *s;
5253 offsetT offset;
5254 unsigned long value;
5255 unsigned long abs_value;
5256
5257 /* FIXME : here may be able to modify better .
5258 I don't know how to get the fragp's section ,
5259 so in relax stage , it may be wrong to calculate the symbol's offset when the frag's section
5260 is different from the symbol's. */
5261
5262 r_old = s7_RELAX_OLD (fragp->fr_subtype);
5263 r_new = s7_RELAX_NEW (fragp->fr_subtype);
5264 relaxable_p = s7_RELAX_OPT (fragp->fr_subtype);
5265
5266 s = fragp->fr_symbol;
5267 /* b/bl immediate */
5268 if (s == NULL)
5269 frag_addr = 0;
5270 else
5271 {
5272 if (s->bsym != 0)
5273 symbol_address = (addressT) s->sy_frag->fr_address;
5274 }
5275
5276 value = s7_md_chars_to_number (fragp->fr_literal, s7_INSN_SIZE);
5277
5278 /* b 32's offset : 20 bit, b 16's tolerate field : 0xff. */
5279 offset = ((value & 0x3ff0000) >> 6) | (value & 0x3fe);
5280 if ((offset & 0x80000) == 0x80000)
5281 offset |= 0xfff00000;
5282
5283 abs_value = offset + symbol_address - frag_addr;
5284 if ((abs_value & 0x80000000) == 0x80000000)
5285 abs_value = 0xffffffff - abs_value + 1;
5286
5287 /* Relax branch 32 to branch 16. */
5288 if (relaxable_p && (s->bsym != NULL) && ((abs_value & 0xffffff00) == 0)
5289 && (S_IS_DEFINED (s) && !S_IS_COMMON (s) && !S_IS_EXTERNAL (s)))
5290 {
5291 /* do nothing. */
5292 }
5293 else
5294 {
5295 /* Branch 32 can not be relaxed to b 16, so clear OPT bit. */
5296 fragp->fr_opcode = NULL;
5297 fragp->fr_subtype = s7_RELAX_OPT_CLEAR (fragp->fr_subtype);
5298 }
5299
5300 return grows;
5301 }
5302
5303 static void
5304 s7_parse_pce_inst (char *insnstr)
5305 {
5306 char c;
5307 char *p;
5308 char *q;
5309 char first[s7_MAX_LITERAL_POOL_SIZE];
5310 char second[s7_MAX_LITERAL_POOL_SIZE];
5311 struct s7_score_it pec_part_1;
5312
5313 /* Get first part string of PCE. */
5314 p = strstr (insnstr, "||");
5315 c = *p;
5316 *p = '\0';
5317 sprintf (first, "%s", insnstr);
5318
5319 /* Get second part string of PCE. */
5320 *p = c;
5321 p += 2;
5322 sprintf (second, "%s", p);
5323
5324 s7_parse_16_32_inst (first, FALSE);
5325 if (s7_inst.error)
5326 return;
5327
5328 memcpy (&pec_part_1, &s7_inst, sizeof (s7_inst));
5329
5330 q = second;
5331 while (q && *q)
5332 {
5333 *q = TOLOWER (*q);
5334 q++;
5335 }
5336
5337 s7_parse_16_32_inst (second, FALSE);
5338 if (s7_inst.error)
5339 return;
5340
5341 if ( ((pec_part_1.size == s7_INSN_SIZE) && (s7_inst.size == s7_INSN_SIZE))
5342 || ((pec_part_1.size == s7_INSN_SIZE) && (s7_inst.size == s7_INSN16_SIZE))
5343 || ((pec_part_1.size == s7_INSN16_SIZE) && (s7_inst.size == s7_INSN_SIZE)))
5344 {
5345 s7_inst.error = _("pce instruction error (16 bit || 16 bit)'");
5346 sprintf (s7_inst.str, insnstr);
5347 return;
5348 }
5349
5350 if (!s7_inst.error)
5351 s7_gen_insn_frag (&pec_part_1, &s7_inst);
5352 }
5353
5354 \f
5355
5356 static void
5357 s7_insert_reg (const struct s7_reg_entry *r, struct hash_control *htab)
5358 {
5359 int i = 0;
5360 int len = strlen (r->name) + 2;
5361 char *buf = xmalloc (len);
5362 char *buf2 = xmalloc (len);
5363
5364 strcpy (buf + i, r->name);
5365 for (i = 0; buf[i]; i++)
5366 {
5367 buf2[i] = TOUPPER (buf[i]);
5368 }
5369 buf2[i] = '\0';
5370
5371 hash_insert (htab, buf, (void *) r);
5372 hash_insert (htab, buf2, (void *) r);
5373 }
5374
5375 static void
5376 s7_build_reg_hsh (struct s7_reg_map *map)
5377 {
5378 const struct s7_reg_entry *r;
5379
5380 if ((map->htab = hash_new ()) == NULL)
5381 {
5382 as_fatal (_("virtual memory exhausted"));
5383 }
5384 for (r = map->names; r->name != NULL; r++)
5385 {
5386 s7_insert_reg (r, map->htab);
5387 }
5388 }
5389
5390 \f
5391
5392 /* If we change section we must dump the literal pool first. */
5393 static void
5394 s7_s_score_bss (int ignore ATTRIBUTE_UNUSED)
5395 {
5396 subseg_set (bss_section, (subsegT) get_absolute_expression ());
5397 demand_empty_rest_of_line ();
5398 }
5399
5400 static void
5401 s7_s_score_text (int ignore)
5402 {
5403 obj_elf_text (ignore);
5404 record_alignment (now_seg, 2);
5405 }
5406
5407 static void
5408 s7_s_section (int ignore)
5409 {
5410 obj_elf_section (ignore);
5411 if ((bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE) != 0)
5412 record_alignment (now_seg, 2);
5413
5414 }
5415
5416 static void
5417 s7_s_change_sec (int sec)
5418 {
5419 segT seg;
5420
5421 #ifdef OBJ_ELF
5422 /* The ELF backend needs to know that we are changing sections, so
5423 that .previous works correctly. We could do something like check
5424 for an obj_section_change_hook macro, but that might be confusing
5425 as it would not be appropriate to use it in the section changing
5426 functions in read.c, since obj-elf.c intercepts those. FIXME:
5427 This should be cleaner, somehow. */
5428 obj_elf_section_change_hook ();
5429 #endif
5430 switch (sec)
5431 {
5432 case 'r':
5433 seg = subseg_new (s7_RDATA_SECTION_NAME, (subsegT) get_absolute_expression ());
5434 bfd_set_section_flags (stdoutput, seg, (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_RELOC | SEC_DATA));
5435 if (strcmp (TARGET_OS, "elf") != 0)
5436 record_alignment (seg, 4);
5437 demand_empty_rest_of_line ();
5438 break;
5439 case 's':
5440 seg = subseg_new (".sdata", (subsegT) get_absolute_expression ());
5441 bfd_set_section_flags (stdoutput, seg, SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_DATA);
5442 if (strcmp (TARGET_OS, "elf") != 0)
5443 record_alignment (seg, 4);
5444 demand_empty_rest_of_line ();
5445 break;
5446 }
5447 }
5448
5449 static void
5450 s7_s_score_mask (int reg_type ATTRIBUTE_UNUSED)
5451 {
5452 long mask, off;
5453
5454 if (s7_cur_proc_ptr == NULL)
5455 {
5456 as_warn (_(".mask outside of .ent"));
5457 demand_empty_rest_of_line ();
5458 return;
5459 }
5460 if (get_absolute_expression_and_terminator (&mask) != ',')
5461 {
5462 as_warn (_("Bad .mask directive"));
5463 --input_line_pointer;
5464 demand_empty_rest_of_line ();
5465 return;
5466 }
5467 off = get_absolute_expression ();
5468 s7_cur_proc_ptr->reg_mask = mask;
5469 s7_cur_proc_ptr->reg_offset = off;
5470 demand_empty_rest_of_line ();
5471 }
5472
5473 static symbolS *
5474 s7_get_symbol (void)
5475 {
5476 int c;
5477 char *name;
5478 symbolS *p;
5479
5480 name = input_line_pointer;
5481 c = get_symbol_end ();
5482 p = (symbolS *) symbol_find_or_make (name);
5483 *input_line_pointer = c;
5484 return p;
5485 }
5486
5487 static long
5488 s7_get_number (void)
5489 {
5490 int negative = 0;
5491 long val = 0;
5492
5493 if (*input_line_pointer == '-')
5494 {
5495 ++input_line_pointer;
5496 negative = 1;
5497 }
5498 if (!ISDIGIT (*input_line_pointer))
5499 as_bad (_("expected simple number"));
5500 if (input_line_pointer[0] == '0')
5501 {
5502 if (input_line_pointer[1] == 'x')
5503 {
5504 input_line_pointer += 2;
5505 while (ISXDIGIT (*input_line_pointer))
5506 {
5507 val <<= 4;
5508 val |= hex_value (*input_line_pointer++);
5509 }
5510 return negative ? -val : val;
5511 }
5512 else
5513 {
5514 ++input_line_pointer;
5515 while (ISDIGIT (*input_line_pointer))
5516 {
5517 val <<= 3;
5518 val |= *input_line_pointer++ - '0';
5519 }
5520 return negative ? -val : val;
5521 }
5522 }
5523 if (!ISDIGIT (*input_line_pointer))
5524 {
5525 printf (_(" *input_line_pointer == '%c' 0x%02x\n"), *input_line_pointer, *input_line_pointer);
5526 as_warn (_("invalid number"));
5527 return -1;
5528 }
5529 while (ISDIGIT (*input_line_pointer))
5530 {
5531 val *= 10;
5532 val += *input_line_pointer++ - '0';
5533 }
5534 return negative ? -val : val;
5535 }
5536
5537 /* The .aent and .ent directives. */
5538
5539 static void
5540 s7_s_score_ent (int aent)
5541 {
5542 symbolS *symbolP;
5543 int maybe_text;
5544
5545 symbolP = s7_get_symbol ();
5546 if (*input_line_pointer == ',')
5547 ++input_line_pointer;
5548 SKIP_WHITESPACE ();
5549 if (ISDIGIT (*input_line_pointer) || *input_line_pointer == '-')
5550 s7_get_number ();
5551
5552 #ifdef BFD_ASSEMBLER
5553 if ((bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE) != 0)
5554 maybe_text = 1;
5555 else
5556 maybe_text = 0;
5557 #else
5558 if (now_seg != data_section && now_seg != bss_section)
5559 maybe_text = 1;
5560 else
5561 maybe_text = 0;
5562 #endif
5563 if (!maybe_text)
5564 as_warn (_(".ent or .aent not in text section."));
5565 if (!aent && s7_cur_proc_ptr)
5566 as_warn (_("missing .end"));
5567 if (!aent)
5568 {
5569 s7_cur_proc_ptr = &s7_cur_proc;
5570 s7_cur_proc_ptr->reg_mask = 0xdeadbeaf;
5571 s7_cur_proc_ptr->reg_offset = 0xdeadbeaf;
5572 s7_cur_proc_ptr->fpreg_mask = 0xdeafbeaf;
5573 s7_cur_proc_ptr->leaf = 0xdeafbeaf;
5574 s7_cur_proc_ptr->frame_offset = 0xdeafbeaf;
5575 s7_cur_proc_ptr->frame_reg = 0xdeafbeaf;
5576 s7_cur_proc_ptr->pc_reg = 0xdeafbeaf;
5577 s7_cur_proc_ptr->isym = symbolP;
5578 symbol_get_bfdsym (symbolP)->flags |= BSF_FUNCTION;
5579 ++s7_numprocs;
5580 if (debug_type == DEBUG_STABS)
5581 stabs_generate_asm_func (S_GET_NAME (symbolP), S_GET_NAME (symbolP));
5582 }
5583 demand_empty_rest_of_line ();
5584 }
5585
5586 static void
5587 s7_s_score_frame (int ignore ATTRIBUTE_UNUSED)
5588 {
5589 char *backupstr;
5590 char str[30];
5591 long val;
5592 int i = 0;
5593
5594 backupstr = input_line_pointer;
5595
5596 #ifdef OBJ_ELF
5597 if (s7_cur_proc_ptr == NULL)
5598 {
5599 as_warn (_(".frame outside of .ent"));
5600 demand_empty_rest_of_line ();
5601 return;
5602 }
5603 s7_cur_proc_ptr->frame_reg = s7_reg_required_here ((&backupstr), 0, s7_REG_TYPE_SCORE);
5604 SKIP_WHITESPACE ();
5605 s7_skip_past_comma (&backupstr);
5606 while (*backupstr != ',')
5607 {
5608 str[i] = *backupstr;
5609 i++;
5610 backupstr++;
5611 }
5612 str[i] = '\0';
5613 val = atoi (str);
5614
5615 SKIP_WHITESPACE ();
5616 s7_skip_past_comma (&backupstr);
5617 s7_cur_proc_ptr->frame_offset = val;
5618 s7_cur_proc_ptr->pc_reg = s7_reg_required_here ((&backupstr), 0, s7_REG_TYPE_SCORE);
5619
5620 SKIP_WHITESPACE ();
5621 s7_skip_past_comma (&backupstr);
5622 i = 0;
5623 while (*backupstr != '\n')
5624 {
5625 str[i] = *backupstr;
5626 i++;
5627 backupstr++;
5628 }
5629 str[i] = '\0';
5630 val = atoi (str);
5631 s7_cur_proc_ptr->leaf = val;
5632 SKIP_WHITESPACE ();
5633 s7_skip_past_comma (&backupstr);
5634
5635 #endif /* OBJ_ELF */
5636 while (input_line_pointer != backupstr)
5637 input_line_pointer++;
5638 }
5639
5640 /* The .end directive. */
5641
5642 static void
5643 s7_s_score_end (int x ATTRIBUTE_UNUSED)
5644 {
5645 symbolS *p;
5646 int maybe_text;
5647
5648 /* Generate a .pdr section. */
5649 segT saved_seg = now_seg;
5650 subsegT saved_subseg = now_subseg;
5651 valueT dot;
5652 expressionS exp;
5653 char *fragp;
5654
5655 if (!is_end_of_line[(unsigned char)*input_line_pointer])
5656 {
5657 p = s7_get_symbol ();
5658 demand_empty_rest_of_line ();
5659 }
5660 else
5661 p = NULL;
5662
5663 #ifdef BFD_ASSEMBLER
5664 if ((bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE) != 0)
5665 maybe_text = 1;
5666 else
5667 maybe_text = 0;
5668 #else
5669 if (now_seg != data_section && now_seg != bss_section)
5670 maybe_text = 1;
5671 else
5672 maybe_text = 0;
5673 #endif
5674
5675 if (!maybe_text)
5676 as_warn (_(".end not in text section"));
5677 if (!s7_cur_proc_ptr)
5678 {
5679 as_warn (_(".end directive without a preceding .ent directive."));
5680 demand_empty_rest_of_line ();
5681 return;
5682 }
5683 if (p != NULL)
5684 {
5685 gas_assert (S_GET_NAME (p));
5686 if (strcmp (S_GET_NAME (p), S_GET_NAME (s7_cur_proc_ptr->isym)))
5687 as_warn (_(".end symbol does not match .ent symbol."));
5688 if (debug_type == DEBUG_STABS)
5689 stabs_generate_asm_endfunc (S_GET_NAME (p), S_GET_NAME (p));
5690 }
5691 else
5692 as_warn (_(".end directive missing or unknown symbol"));
5693
5694 if ((s7_cur_proc_ptr->reg_mask == 0xdeadbeaf) ||
5695 (s7_cur_proc_ptr->reg_offset == 0xdeadbeaf) ||
5696 (s7_cur_proc_ptr->leaf == 0xdeafbeaf) ||
5697 (s7_cur_proc_ptr->frame_offset == 0xdeafbeaf) ||
5698 (s7_cur_proc_ptr->frame_reg == 0xdeafbeaf) || (s7_cur_proc_ptr->pc_reg == 0xdeafbeaf));
5699
5700 else
5701 {
5702 dot = frag_now_fix ();
5703 gas_assert (s7_pdr_seg);
5704 subseg_set (s7_pdr_seg, 0);
5705 /* Write the symbol. */
5706 exp.X_op = O_symbol;
5707 exp.X_add_symbol = p;
5708 exp.X_add_number = 0;
5709 emit_expr (&exp, 4);
5710 fragp = frag_more (7 * 4);
5711 s7_number_to_chars (fragp, (valueT) s7_cur_proc_ptr->reg_mask, 4);
5712 s7_number_to_chars (fragp + 4, (valueT) s7_cur_proc_ptr->reg_offset, 4);
5713 s7_number_to_chars (fragp + 8, (valueT) s7_cur_proc_ptr->fpreg_mask, 4);
5714 s7_number_to_chars (fragp + 12, (valueT) s7_cur_proc_ptr->leaf, 4);
5715 s7_number_to_chars (fragp + 16, (valueT) s7_cur_proc_ptr->frame_offset, 4);
5716 s7_number_to_chars (fragp + 20, (valueT) s7_cur_proc_ptr->frame_reg, 4);
5717 s7_number_to_chars (fragp + 24, (valueT) s7_cur_proc_ptr->pc_reg, 4);
5718 subseg_set (saved_seg, saved_subseg);
5719
5720 }
5721 s7_cur_proc_ptr = NULL;
5722 }
5723
5724 /* Handle the .set pseudo-op. */
5725
5726 static void
5727 s7_s_score_set (int x ATTRIBUTE_UNUSED)
5728 {
5729 int i = 0;
5730 char name[s7_MAX_LITERAL_POOL_SIZE];
5731 char * orig_ilp = input_line_pointer;
5732
5733 while (!is_end_of_line[(unsigned char)*input_line_pointer])
5734 {
5735 name[i] = (char) * input_line_pointer;
5736 i++;
5737 ++input_line_pointer;
5738 }
5739
5740 name[i] = '\0';
5741
5742 if (strcmp (name, "nwarn") == 0)
5743 {
5744 s7_warn_fix_data_dependency = 0;
5745 }
5746 else if (strcmp (name, "fixdd") == 0)
5747 {
5748 s7_fix_data_dependency = 1;
5749 }
5750 else if (strcmp (name, "nofixdd") == 0)
5751 {
5752 s7_fix_data_dependency = 0;
5753 }
5754 else if (strcmp (name, "r1") == 0)
5755 {
5756 s7_nor1 = 0;
5757 }
5758 else if (strcmp (name, "nor1") == 0)
5759 {
5760 s7_nor1 = 1;
5761 }
5762 else if (strcmp (name, "optimize") == 0)
5763 {
5764 s7_g_opt = 1;
5765 }
5766 else if (strcmp (name, "volatile") == 0)
5767 {
5768 s7_g_opt = 0;
5769 }
5770 else if (strcmp (name, "pic") == 0)
5771 {
5772 s7_score_pic = s7_PIC;
5773 }
5774 else
5775 {
5776 input_line_pointer = orig_ilp;
5777 s_set (0);
5778 }
5779 }
5780
5781 /* Handle the .cpload pseudo-op. This is used when generating s7_PIC code. It sets the
5782 $gp register for the function based on the function address, which is in the register
5783 named in the argument. This uses a relocation against GP_DISP_LABEL, which is handled
5784 specially by the linker. The result is:
5785 ldis gp, %hi(GP_DISP_LABEL)
5786 ori gp, %low(GP_DISP_LABEL)
5787 add gp, gp, .cpload argument
5788 The .cpload argument is normally r29. */
5789
5790 static void
5791 s7_s_score_cpload (int ignore ATTRIBUTE_UNUSED)
5792 {
5793 int reg;
5794 char insn_str[s7_MAX_LITERAL_POOL_SIZE];
5795
5796 /* If we are not generating s7_PIC code, .cpload is ignored. */
5797 if (s7_score_pic == s7_NO_PIC)
5798 {
5799 s_ignore (0);
5800 return;
5801 }
5802
5803 if ((reg = s7_reg_required_here (&input_line_pointer, -1, s7_REG_TYPE_SCORE)) == (int) s7_FAIL)
5804 return;
5805
5806 demand_empty_rest_of_line ();
5807
5808 sprintf (insn_str, "ld_i32hi r%d, %s", s7_GP, GP_DISP_LABEL);
5809 if (s7_append_insn (insn_str, TRUE) == (int) s7_FAIL)
5810 return;
5811
5812 sprintf (insn_str, "ld_i32lo r%d, %s", s7_GP, GP_DISP_LABEL);
5813 if (s7_append_insn (insn_str, TRUE) == (int) s7_FAIL)
5814 return;
5815
5816 sprintf (insn_str, "add r%d, r%d, r%d", s7_GP, s7_GP, reg);
5817 if (s7_append_insn (insn_str, TRUE) == (int) s7_FAIL)
5818 return;
5819 }
5820
5821 /* Handle the .cprestore pseudo-op. This stores $gp into a given
5822 offset from $sp. The offset is remembered, and after making a s7_PIC
5823 call $gp is restored from that location. */
5824
5825 static void
5826 s7_s_score_cprestore (int ignore ATTRIBUTE_UNUSED)
5827 {
5828 int reg;
5829 int cprestore_offset;
5830 char insn_str[s7_MAX_LITERAL_POOL_SIZE];
5831
5832 /* If we are not generating s7_PIC code, .cprestore is ignored. */
5833 if (s7_score_pic == s7_NO_PIC)
5834 {
5835 s_ignore (0);
5836 return;
5837 }
5838
5839 if ((reg = s7_reg_required_here (&input_line_pointer, -1, s7_REG_TYPE_SCORE)) == (int) s7_FAIL
5840 || s7_skip_past_comma (&input_line_pointer) == (int) s7_FAIL)
5841 {
5842 return;
5843 }
5844
5845 cprestore_offset = get_absolute_expression ();
5846
5847 if (cprestore_offset <= 0x3fff)
5848 {
5849 sprintf (insn_str, "sw r%d, [r%d, %d]", s7_GP, reg, cprestore_offset);
5850 if (s7_append_insn (insn_str, TRUE) == (int) s7_FAIL)
5851 return;
5852 }
5853 else
5854 {
5855 int r1_bak;
5856
5857 r1_bak = s7_nor1;
5858 s7_nor1 = 0;
5859
5860 sprintf (insn_str, "li r1, %d", cprestore_offset);
5861 if (s7_append_insn (insn_str, TRUE) == (int) s7_FAIL)
5862 return;
5863
5864 sprintf (insn_str, "add r1, r1, r%d", reg);
5865 if (s7_append_insn (insn_str, TRUE) == (int) s7_FAIL)
5866 return;
5867
5868 sprintf (insn_str, "sw r%d, [r1]", s7_GP);
5869 if (s7_append_insn (insn_str, TRUE) == (int) s7_FAIL)
5870 return;
5871
5872 s7_nor1 = r1_bak;
5873 }
5874
5875 demand_empty_rest_of_line ();
5876 }
5877
5878 /* Handle the .gpword pseudo-op. This is used when generating s7_PIC
5879 code. It generates a 32 bit s7_GP relative reloc. */
5880
5881 static void
5882 s7_s_score_gpword (int ignore ATTRIBUTE_UNUSED)
5883 {
5884 expressionS ex;
5885 char *p;
5886
5887 /* When not generating s7_PIC code, this is treated as .word. */
5888 if (s7_score_pic == s7_NO_PIC)
5889 {
5890 cons (4);
5891 return;
5892 }
5893 expression (&ex);
5894 if (ex.X_op != O_symbol || ex.X_add_number != 0)
5895 {
5896 as_bad (_("Unsupported use of .gpword"));
5897 ignore_rest_of_line ();
5898 }
5899 p = frag_more (4);
5900 s7_number_to_chars (p, (valueT) 0, 4);
5901 fix_new_exp (frag_now, p - frag_now->fr_literal, 4, &ex, FALSE, BFD_RELOC_GPREL32);
5902 demand_empty_rest_of_line ();
5903 }
5904
5905 /* Handle the .cpadd pseudo-op. This is used when dealing with switch
5906 tables in s7_PIC code. */
5907
5908 static void
5909 s7_s_score_cpadd (int ignore ATTRIBUTE_UNUSED)
5910 {
5911 int reg;
5912 char insn_str[s7_MAX_LITERAL_POOL_SIZE];
5913
5914 /* If we are not generating s7_PIC code, .cpload is ignored. */
5915 if (s7_score_pic == s7_NO_PIC)
5916 {
5917 s_ignore (0);
5918 return;
5919 }
5920
5921 if ((reg = s7_reg_required_here (&input_line_pointer, -1, s7_REG_TYPE_SCORE)) == (int) s7_FAIL)
5922 {
5923 return;
5924 }
5925 demand_empty_rest_of_line ();
5926
5927 /* Add $gp to the register named as an argument. */
5928 sprintf (insn_str, "add r%d, r%d, r%d", reg, reg, s7_GP);
5929 if (s7_append_insn (insn_str, TRUE) == (int) s7_FAIL)
5930 return;
5931 }
5932
5933 #ifndef TC_IMPLICIT_LCOMM_ALIGNMENT
5934 #define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR) \
5935 do \
5936 { \
5937 if ((SIZE) >= 8) \
5938 (P2VAR) = 3; \
5939 else if ((SIZE) >= 4) \
5940 (P2VAR) = 2; \
5941 else if ((SIZE) >= 2) \
5942 (P2VAR) = 1; \
5943 else \
5944 (P2VAR) = 0; \
5945 } \
5946 while (0)
5947 #endif
5948
5949 static void
5950 s7_s_score_lcomm (int bytes_p)
5951 {
5952 char *name;
5953 char c;
5954 char *p;
5955 int temp;
5956 symbolS *symbolP;
5957 segT current_seg = now_seg;
5958 subsegT current_subseg = now_subseg;
5959 const int max_alignment = 15;
5960 int align = 0;
5961 segT bss_seg = bss_section;
5962 int needs_align = 0;
5963
5964 name = input_line_pointer;
5965 c = get_symbol_end ();
5966 p = input_line_pointer;
5967 *p = c;
5968
5969 if (name == p)
5970 {
5971 as_bad (_("expected symbol name"));
5972 discard_rest_of_line ();
5973 return;
5974 }
5975
5976 SKIP_WHITESPACE ();
5977
5978 /* Accept an optional comma after the name. The comma used to be
5979 required, but Irix 5 cc does not generate it. */
5980 if (*input_line_pointer == ',')
5981 {
5982 ++input_line_pointer;
5983 SKIP_WHITESPACE ();
5984 }
5985
5986 if (is_end_of_line[(unsigned char)*input_line_pointer])
5987 {
5988 as_bad (_("missing size expression"));
5989 return;
5990 }
5991
5992 if ((temp = get_absolute_expression ()) < 0)
5993 {
5994 as_warn (_("BSS length (%d) < 0 ignored"), temp);
5995 ignore_rest_of_line ();
5996 return;
5997 }
5998
5999 #if defined (TC_SCORE)
6000 if (OUTPUT_FLAVOR == bfd_target_ecoff_flavour || OUTPUT_FLAVOR == bfd_target_elf_flavour)
6001 {
6002 /* For Score and Alpha ECOFF or ELF, small objects are put in .sbss. */
6003 if ((unsigned) temp <= bfd_get_gp_size (stdoutput))
6004 {
6005 bss_seg = subseg_new (".sbss", 1);
6006 seg_info (bss_seg)->bss = 1;
6007 #ifdef BFD_ASSEMBLER
6008 if (!bfd_set_section_flags (stdoutput, bss_seg, SEC_ALLOC))
6009 as_warn (_("error setting flags for \".sbss\": %s"), bfd_errmsg (bfd_get_error ()));
6010 #endif
6011 }
6012 }
6013 #endif
6014
6015 SKIP_WHITESPACE ();
6016 if (*input_line_pointer == ',')
6017 {
6018 ++input_line_pointer;
6019 SKIP_WHITESPACE ();
6020
6021 if (is_end_of_line[(unsigned char)*input_line_pointer])
6022 {
6023 as_bad (_("missing alignment"));
6024 return;
6025 }
6026 else
6027 {
6028 align = get_absolute_expression ();
6029 needs_align = 1;
6030 }
6031 }
6032
6033 if (!needs_align)
6034 {
6035 TC_IMPLICIT_LCOMM_ALIGNMENT (temp, align);
6036
6037 /* Still zero unless TC_IMPLICIT_LCOMM_ALIGNMENT set it. */
6038 if (align)
6039 record_alignment (bss_seg, align);
6040 }
6041
6042 if (needs_align)
6043 {
6044 if (bytes_p)
6045 {
6046 /* Convert to a power of 2. */
6047 if (align != 0)
6048 {
6049 unsigned int i;
6050
6051 for (i = 0; align != 0; align >>= 1, ++i)
6052 ;
6053 align = i - 1;
6054 }
6055 }
6056
6057 if (align > max_alignment)
6058 {
6059 align = max_alignment;
6060 as_warn (_("alignment too large; %d assumed"), align);
6061 }
6062 else if (align < 0)
6063 {
6064 align = 0;
6065 as_warn (_("alignment negative; 0 assumed"));
6066 }
6067
6068 record_alignment (bss_seg, align);
6069 }
6070 else
6071 {
6072 /* Assume some objects may require alignment on some systems. */
6073 #if defined (TC_ALPHA) && ! defined (VMS)
6074 if (temp > 1)
6075 {
6076 align = ffs (temp) - 1;
6077 if (temp % (1 << align))
6078 abort ();
6079 }
6080 #endif
6081 }
6082
6083 *p = 0;
6084 symbolP = symbol_find_or_make (name);
6085 *p = c;
6086
6087 if (
6088 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT) \
6089 || defined (OBJ_BOUT) || defined (OBJ_MAYBE_BOUT))
6090 #ifdef BFD_ASSEMBLER
6091 (OUTPUT_FLAVOR != bfd_target_aout_flavour
6092 || (S_GET_OTHER (symbolP) == 0 && S_GET_DESC (symbolP) == 0)) &&
6093 #else
6094 (S_GET_OTHER (symbolP) == 0 && S_GET_DESC (symbolP) == 0) &&
6095 #endif
6096 #endif
6097 (S_GET_SEGMENT (symbolP) == bss_seg || (!S_IS_DEFINED (symbolP) && S_GET_VALUE (symbolP) == 0)))
6098 {
6099 char *pfrag;
6100
6101 subseg_set (bss_seg, 1);
6102
6103 if (align)
6104 frag_align (align, 0, 0);
6105
6106 /* Detach from old frag. */
6107 if (S_GET_SEGMENT (symbolP) == bss_seg)
6108 symbol_get_frag (symbolP)->fr_symbol = NULL;
6109
6110 symbol_set_frag (symbolP, frag_now);
6111 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP, (offsetT) temp, NULL);
6112 *pfrag = 0;
6113
6114
6115 S_SET_SEGMENT (symbolP, bss_seg);
6116
6117 #ifdef OBJ_COFF
6118 /* The symbol may already have been created with a preceding
6119 ".globl" directive -- be careful not to step on storage class
6120 in that case. Otherwise, set it to static. */
6121 if (S_GET_STORAGE_CLASS (symbolP) != C_EXT)
6122 {
6123 S_SET_STORAGE_CLASS (symbolP, C_STAT);
6124 }
6125 #endif /* OBJ_COFF */
6126
6127 #ifdef S_SET_SIZE
6128 S_SET_SIZE (symbolP, temp);
6129 #endif
6130 }
6131 else
6132 as_bad (_("symbol `%s' is already defined"), S_GET_NAME (symbolP));
6133
6134 subseg_set (current_seg, current_subseg);
6135
6136 demand_empty_rest_of_line ();
6137 }
6138
6139 \f
6140
6141 static void
6142 s7_begin (void)
6143 {
6144 unsigned int i;
6145 segT seg;
6146 subsegT subseg;
6147
6148 if ((s7_score_ops_hsh = hash_new ()) == NULL)
6149 as_fatal (_("virtual memory exhausted"));
6150
6151 s7_build_score_ops_hsh ();
6152
6153 if ((s7_dependency_insn_hsh = hash_new ()) == NULL)
6154 as_fatal (_("virtual memory exhausted"));
6155
6156 s7_build_dependency_insn_hsh ();
6157
6158 for (i = (int) REG_TYPE_FIRST; i < (int) s7_REG_TYPE_MAX; i++)
6159 s7_build_reg_hsh (s7_all_reg_maps + i);
6160
6161 /* Initialize dependency vector. */
6162 s7_init_dependency_vector ();
6163
6164 bfd_set_arch_mach (stdoutput, TARGET_ARCH, 0);
6165 seg = now_seg;
6166 subseg = now_subseg;
6167 s7_pdr_seg = subseg_new (".pdr", (subsegT) 0);
6168 (void) bfd_set_section_flags (stdoutput, s7_pdr_seg, SEC_READONLY | SEC_RELOC | SEC_DEBUGGING);
6169 (void) bfd_set_section_alignment (stdoutput, s7_pdr_seg, 2);
6170 subseg_set (seg, subseg);
6171
6172 if (s7_USE_GLOBAL_POINTER_OPT)
6173 bfd_set_gp_size (stdoutput, s7_g_switch_value);
6174 }
6175
6176 static void
6177 s7_assemble (char *str)
6178 {
6179 know (str);
6180 know (strlen (str) < s7_MAX_LITERAL_POOL_SIZE);
6181
6182 memset (&s7_inst, '\0', sizeof (s7_inst));
6183 if (s7_INSN_IS_PCE_P (str))
6184 s7_parse_pce_inst (str);
6185 else
6186 s7_parse_16_32_inst (str, TRUE);
6187
6188 if (s7_inst.error)
6189 as_bad (_("%s -- `%s'"), s7_inst.error, s7_inst.str);
6190 }
6191
6192 /* We handle all bad expressions here, so that we can report the faulty
6193 instruction in the error message. */
6194
6195 static void
6196 s7_operand (expressionS * exp)
6197 {
6198 if (s7_in_my_get_expression)
6199 {
6200 exp->X_op = O_illegal;
6201 if (s7_inst.error == NULL)
6202 {
6203 s7_inst.error = _("bad expression");
6204 }
6205 }
6206 }
6207
6208 /* Turn a string in input_line_pointer into a floating point constant
6209 of type TYPE, and store the appropriate bytes in *LITP. The number
6210 of LITTLENUMS emitted is stored in *SIZEP. An error message is
6211 returned, or NULL on OK.
6212
6213 Note that fp constants aren't represent in the normal way on the ARM.
6214 In big endian mode, things are as expected. However, in little endian
6215 mode fp constants are big-endian word-wise, and little-endian byte-wise
6216 within the words. For example, (double) 1.1 in big endian mode is
6217 the byte sequence 3f f1 99 99 99 99 99 9a, and in little endian mode is
6218 the byte sequence 99 99 f1 3f 9a 99 99 99. */
6219
6220 static char *
6221 s7_atof (int type, char *litP, int *sizeP)
6222 {
6223 int prec;
6224 LITTLENUM_TYPE words[s7_MAX_LITTLENUMS];
6225 char *t;
6226 int i;
6227
6228 switch (type)
6229 {
6230 case 'f':
6231 case 'F':
6232 case 's':
6233 case 'S':
6234 prec = 2;
6235 break;
6236 case 'd':
6237 case 'D':
6238 case 'r':
6239 case 'R':
6240 prec = 4;
6241 break;
6242 case 'x':
6243 case 'X':
6244 case 'p':
6245 case 'P':
6246 prec = 6;
6247 break;
6248 default:
6249 *sizeP = 0;
6250 return _("bad call to MD_ATOF()");
6251 }
6252
6253 t = atof_ieee (input_line_pointer, type, words);
6254 if (t)
6255 input_line_pointer = t;
6256 *sizeP = prec * 2;
6257
6258 if (target_big_endian)
6259 {
6260 for (i = 0; i < prec; i++)
6261 {
6262 s7_number_to_chars (litP, (valueT) words[i], 2);
6263 litP += 2;
6264 }
6265 }
6266 else
6267 {
6268 for (i = 0; i < prec; i += 2)
6269 {
6270 s7_number_to_chars (litP, (valueT) words[i + 1], 2);
6271 s7_number_to_chars (litP + 2, (valueT) words[i], 2);
6272 litP += 4;
6273 }
6274 }
6275
6276 return 0;
6277 }
6278
6279 /* Implementation of md_frag_check.
6280 Called after md_convert_frag(). */
6281
6282 static void
6283 s7_frag_check (fragS * fragp)
6284 {
6285 know (fragp->insn_addr <= s7_RELAX_PAD_BYTE);
6286 }
6287
6288 /* Implementation of TC_VALIDATE_FIX.
6289 Called before md_apply_fix() and after md_convert_frag(). */
6290
6291 static void
6292 s7_validate_fix (fixS *fixP)
6293 {
6294 fixP->fx_where += fixP->fx_frag->insn_addr;
6295 }
6296
6297 static int
6298 s7_force_relocation (struct fix *fixp)
6299 {
6300 int retval = 0;
6301
6302 if (fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
6303 || fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY
6304 || fixp->fx_r_type == BFD_RELOC_SCORE_JMP
6305 || fixp->fx_r_type == BFD_RELOC_SCORE_BRANCH
6306 || fixp->fx_r_type == BFD_RELOC_SCORE16_JMP
6307 || fixp->fx_r_type == BFD_RELOC_SCORE16_BRANCH)
6308 {
6309 retval = 1;
6310 }
6311
6312 return retval;
6313 }
6314
6315 static bfd_boolean
6316 s7_fix_adjustable (fixS * fixP)
6317 {
6318 if (fixP->fx_addsy == NULL)
6319 {
6320 return 1;
6321 }
6322 else if (OUTPUT_FLAVOR == bfd_target_elf_flavour
6323 && (S_IS_EXTERNAL (fixP->fx_addsy) || S_IS_WEAK (fixP->fx_addsy)))
6324 {
6325 return 0;
6326 }
6327 else if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
6328 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY
6329 || fixP->fx_r_type == BFD_RELOC_SCORE_JMP
6330 || fixP->fx_r_type == BFD_RELOC_SCORE16_JMP)
6331 {
6332 return 0;
6333 }
6334
6335 return 1;
6336 }
6337
6338 static void
6339 s7_elf_final_processing (void)
6340 {
6341 unsigned long val = E_SCORE_MACH_SCORE7;
6342
6343 elf_elfheader (stdoutput)->e_machine = EM_SCORE;
6344 elf_elfheader (stdoutput)->e_flags &= ~EF_SCORE_MACH;
6345 elf_elfheader (stdoutput)->e_flags |= val;
6346
6347 if (s7_fix_data_dependency == 1)
6348 {
6349 elf_elfheader (stdoutput)->e_flags |= EF_SCORE_FIXDEP;
6350 }
6351 if (s7_score_pic == s7_PIC)
6352 {
6353 elf_elfheader (stdoutput)->e_flags |= EF_SCORE_PIC;
6354 }
6355 }
6356
6357 /* In this function, we determine whether s7_GP instruction should do relaxation,
6358 for the label being against was known now.
6359 Doing this here but not in md_relax_frag() can induce iteration times
6360 in stage of doing relax. */
6361
6362 static int
6363 s7_estimate_size_before_relax (fragS * fragp, asection * sec)
6364 {
6365 if ((s7_RELAX_TYPE (fragp->fr_subtype) == Insn_GP)
6366 || (s7_RELAX_TYPE (fragp->fr_subtype) == Insn_PIC))
6367 return s7_judge_size_before_relax (fragp, sec);
6368
6369 return 0;
6370 }
6371
6372 static int
6373 s7_relax_frag (asection * sec ATTRIBUTE_UNUSED,
6374 fragS * fragp,
6375 long stretch ATTRIBUTE_UNUSED)
6376 {
6377 int grows = 0;
6378 int insn_size;
6379 int insn_relax_size;
6380 int do_relax_p = 0; /* Indicate doing relaxation for this frag. */
6381 int relaxable_p = 0;
6382 bfd_boolean word_align_p = FALSE;
6383 fragS *next_fragp;
6384
6385 /* If the instruction address is odd, make it half word align first. */
6386 if ((fragp->fr_address) % 2 != 0)
6387 {
6388 if ((fragp->fr_address + fragp->insn_addr) % 2 != 0)
6389 {
6390 fragp->insn_addr = 1;
6391 grows += 1;
6392 }
6393 }
6394
6395 word_align_p = ((fragp->fr_address + fragp->insn_addr) % 4 == 0) ? TRUE : FALSE;
6396
6397 /* Get instruction size and relax size after the last relaxation. */
6398 if (fragp->fr_opcode)
6399 {
6400 insn_size = s7_RELAX_NEW (fragp->fr_subtype);
6401 insn_relax_size = s7_RELAX_OLD (fragp->fr_subtype);
6402 }
6403 else
6404 {
6405 insn_size = s7_RELAX_OLD (fragp->fr_subtype);
6406 insn_relax_size = s7_RELAX_NEW (fragp->fr_subtype);
6407 }
6408
6409 /* Handle specially for s7_GP instruction. for, s7_judge_size_before_relax() has already determine
6410 whether the s7_GP instruction should do relax. */
6411 if ((s7_RELAX_TYPE (fragp->fr_subtype) == Insn_GP)
6412 || (s7_RELAX_TYPE (fragp->fr_subtype) == Insn_PIC))
6413 {
6414 if (!word_align_p)
6415 {
6416 if (fragp->insn_addr < 2)
6417 {
6418 fragp->insn_addr += 2;
6419 grows += 2;
6420 }
6421 else
6422 {
6423 fragp->insn_addr -= 2;
6424 grows -= 2;
6425 }
6426 }
6427
6428 if (fragp->fr_opcode)
6429 fragp->fr_fix = s7_RELAX_NEW (fragp->fr_subtype) + fragp->insn_addr;
6430 else
6431 fragp->fr_fix = s7_RELAX_OLD (fragp->fr_subtype) + fragp->insn_addr;
6432 }
6433 else
6434 {
6435 if (s7_RELAX_TYPE (fragp->fr_subtype) == PC_DISP19div2)
6436 s7_b32_relax_to_b16 (fragp);
6437
6438 relaxable_p = s7_RELAX_OPT (fragp->fr_subtype);
6439 next_fragp = fragp->fr_next;
6440 while ((next_fragp) && (next_fragp->fr_type != rs_machine_dependent))
6441 {
6442 next_fragp = next_fragp->fr_next;
6443 }
6444
6445 if (next_fragp)
6446 {
6447 int n_insn_size;
6448 int n_relaxable_p = 0;
6449
6450 if (next_fragp->fr_opcode)
6451 {
6452 n_insn_size = s7_RELAX_NEW (next_fragp->fr_subtype);
6453 }
6454 else
6455 {
6456 n_insn_size = s7_RELAX_OLD (next_fragp->fr_subtype);
6457 }
6458
6459 if (s7_RELAX_TYPE (next_fragp->fr_subtype) == PC_DISP19div2)
6460 s7_b32_relax_to_b16 (next_fragp);
6461 n_relaxable_p = s7_RELAX_OPT (next_fragp->fr_subtype);
6462
6463 if (word_align_p)
6464 {
6465 if (insn_size == 4)
6466 {
6467 /* 32 -> 16. */
6468 if (relaxable_p && ((n_insn_size == 2) || n_relaxable_p))
6469 {
6470 grows -= 2;
6471 do_relax_p = 1;
6472 }
6473 }
6474 else if (insn_size == 2)
6475 {
6476 /* 16 -> 32. */
6477 if (relaxable_p && (((n_insn_size == 4) && !n_relaxable_p) || (n_insn_size > 4)))
6478 {
6479 grows += 2;
6480 do_relax_p = 1;
6481 }
6482 }
6483 else
6484 {
6485 abort ();
6486 }
6487 }
6488 else
6489 {
6490 if (insn_size == 4)
6491 {
6492 /* 32 -> 16. */
6493 if (relaxable_p)
6494 {
6495 grows -= 2;
6496 do_relax_p = 1;
6497 }
6498 /* Make the 32 bit insturction word align. */
6499 else
6500 {
6501 fragp->insn_addr += 2;
6502 grows += 2;
6503 }
6504 }
6505 else if (insn_size == 2)
6506 {
6507 /* Do nothing. */
6508 }
6509 else
6510 {
6511 abort ();
6512 }
6513 }
6514 }
6515 else
6516 {
6517 /* Here, try best to do relax regardless fragp->fr_next->fr_type. */
6518 if (word_align_p == FALSE)
6519 {
6520 if (insn_size % 4 == 0)
6521 {
6522 /* 32 -> 16. */
6523 if (relaxable_p)
6524 {
6525 grows -= 2;
6526 do_relax_p = 1;
6527 }
6528 else
6529 {
6530 fragp->insn_addr += 2;
6531 grows += 2;
6532 }
6533 }
6534 }
6535 else
6536 {
6537 /* Do nothing. */
6538 }
6539 }
6540
6541 /* fragp->fr_opcode indicates whether this frag should be relaxed. */
6542 if (do_relax_p)
6543 {
6544 if (fragp->fr_opcode)
6545 {
6546 fragp->fr_opcode = NULL;
6547 /* Guarantee estimate stage is correct. */
6548 fragp->fr_fix = s7_RELAX_OLD (fragp->fr_subtype);
6549 fragp->fr_fix += fragp->insn_addr;
6550 }
6551 else
6552 {
6553 fragp->fr_opcode = fragp->fr_literal + s7_RELAX_RELOC1 (fragp->fr_subtype);
6554 /* Guarantee estimate stage is correct. */
6555 fragp->fr_fix = s7_RELAX_NEW (fragp->fr_subtype);
6556 fragp->fr_fix += fragp->insn_addr;
6557 }
6558 }
6559 else
6560 {
6561 if (fragp->fr_opcode)
6562 {
6563 /* Guarantee estimate stage is correct. */
6564 fragp->fr_fix = s7_RELAX_NEW (fragp->fr_subtype);
6565 fragp->fr_fix += fragp->insn_addr;
6566 }
6567 else
6568 {
6569 /* Guarantee estimate stage is correct. */
6570 fragp->fr_fix = s7_RELAX_OLD (fragp->fr_subtype);
6571 fragp->fr_fix += fragp->insn_addr;
6572 }
6573 }
6574 }
6575
6576 return grows;
6577 }
6578
6579 static void
6580 s7_convert_frag (bfd * abfd ATTRIBUTE_UNUSED,
6581 segT sec ATTRIBUTE_UNUSED,
6582 fragS * fragp)
6583 {
6584 int r_old;
6585 int r_new;
6586 char backup[20];
6587 fixS *fixp;
6588
6589 r_old = s7_RELAX_OLD (fragp->fr_subtype);
6590 r_new = s7_RELAX_NEW (fragp->fr_subtype);
6591
6592 /* fragp->fr_opcode indicates whether this frag should be relaxed. */
6593 if (fragp->fr_opcode == NULL)
6594 {
6595 memcpy (backup, fragp->fr_literal, r_old);
6596 fragp->fr_fix = r_old;
6597 }
6598 else
6599 {
6600 memcpy (backup, fragp->fr_literal + r_old, r_new);
6601 fragp->fr_fix = r_new;
6602 }
6603
6604 fixp = fragp->tc_frag_data.fixp;
6605 while (fixp && fixp->fx_frag == fragp && fixp->fx_where < r_old)
6606 {
6607 if (fragp->fr_opcode)
6608 fixp->fx_done = 1;
6609 fixp = fixp->fx_next;
6610 }
6611 while (fixp && fixp->fx_frag == fragp)
6612 {
6613 if (fragp->fr_opcode)
6614 fixp->fx_where -= r_old + fragp->insn_addr;
6615 else
6616 fixp->fx_done = 1;
6617 fixp = fixp->fx_next;
6618 }
6619
6620 if (fragp->insn_addr)
6621 {
6622 s7_number_to_chars (fragp->fr_literal, 0x0, fragp->insn_addr);
6623 }
6624 memcpy (fragp->fr_literal + fragp->insn_addr, backup, fragp->fr_fix);
6625 fragp->fr_fix += fragp->insn_addr;
6626 }
6627
6628 static long
6629 s7_pcrel_from (fixS * fixP)
6630 {
6631 long retval = 0;
6632
6633 if (fixP->fx_addsy
6634 && (S_GET_SEGMENT (fixP->fx_addsy) == undefined_section)
6635 && (fixP->fx_subsy == NULL))
6636 {
6637 retval = 0;
6638 }
6639 else
6640 {
6641 retval = fixP->fx_where + fixP->fx_frag->fr_address;
6642 }
6643
6644 return retval;
6645 }
6646
6647 /* Round up a section size to the appropriate boundary. */
6648 static valueT
6649 s7_section_align (segT segment, valueT size)
6650 {
6651 int align = bfd_get_section_alignment (stdoutput, segment);
6652
6653 return ((size + (1 << align) - 1) & (-1 << align));
6654 }
6655
6656 static void
6657 s7_apply_fix (fixS *fixP, valueT *valP, segT seg)
6658 {
6659 offsetT value = *valP;
6660 offsetT abs_value = 0;
6661 offsetT newval;
6662 offsetT content;
6663 unsigned short HI, LO;
6664
6665 char *buf = fixP->fx_frag->fr_literal + fixP->fx_where;
6666
6667 gas_assert (fixP->fx_r_type < BFD_RELOC_UNUSED);
6668 if (fixP->fx_addsy == 0 && !fixP->fx_pcrel)
6669 {
6670 if (fixP->fx_r_type != BFD_RELOC_SCORE_DUMMY_HI16)
6671 fixP->fx_done = 1;
6672 }
6673
6674 /* If this symbol is in a different section then we need to leave it for
6675 the linker to deal with. Unfortunately, md_pcrel_from can't tell,
6676 so we have to undo it's effects here. */
6677 if (fixP->fx_pcrel)
6678 {
6679 if (fixP->fx_addsy != NULL
6680 && S_IS_DEFINED (fixP->fx_addsy)
6681 && S_GET_SEGMENT (fixP->fx_addsy) != seg)
6682 value += md_pcrel_from (fixP);
6683 }
6684
6685 /* Remember value for emit_reloc. */
6686 fixP->fx_addnumber = value;
6687
6688 switch (fixP->fx_r_type)
6689 {
6690 case BFD_RELOC_HI16_S:
6691 if (fixP->fx_done)
6692 { /* For la rd, imm32. */
6693 newval = s7_md_chars_to_number (buf, s7_INSN_SIZE);
6694 HI = (value) >> 16; /* mul to 2, then take the hi 16 bit. */
6695 newval |= (HI & 0x3fff) << 1;
6696 newval |= ((HI >> 14) & 0x3) << 16;
6697 s7_number_to_chars (buf, newval, s7_INSN_SIZE);
6698 }
6699 break;
6700 case BFD_RELOC_LO16:
6701 if (fixP->fx_done) /* For la rd, imm32. */
6702 {
6703 newval = s7_md_chars_to_number (buf, s7_INSN_SIZE);
6704 LO = (value) & 0xffff;
6705 newval |= (LO & 0x3fff) << 1; /* 16 bit: imm -> 14 bit in lo, 2 bit in hi. */
6706 newval |= ((LO >> 14) & 0x3) << 16;
6707 s7_number_to_chars (buf, newval, s7_INSN_SIZE);
6708 }
6709 break;
6710 case BFD_RELOC_SCORE_JMP:
6711 {
6712 content = s7_md_chars_to_number (buf, s7_INSN_SIZE);
6713 value = fixP->fx_offset;
6714 if (!(value >= 0 && value <= 0x1ffffff))
6715 {
6716 as_bad_where (fixP->fx_file, fixP->fx_line,
6717 _("j or jl truncate (0x%x) [0 ~ 2^25-1]"), (unsigned int) value);
6718 return;
6719 }
6720 content = (content & ~0x3ff7ffe) | ((value << 1) & 0x3ff0000) | (value & 0x7fff);
6721 s7_number_to_chars (buf, content, s7_INSN_SIZE);
6722 }
6723 break;
6724 case BFD_RELOC_SCORE_BRANCH:
6725 if ((S_GET_SEGMENT (fixP->fx_addsy) != seg) || (fixP->fx_addsy != NULL && S_IS_EXTERNAL (fixP->fx_addsy)))
6726 value = fixP->fx_offset;
6727 else
6728 fixP->fx_done = 1;
6729
6730 content = s7_md_chars_to_number (buf, s7_INSN_SIZE);
6731 if ((fixP->fx_frag->fr_opcode != 0) && ((content & 0x80008000) != 0x80008000))
6732 {
6733 if ((value & 0x80000000) == 0x80000000)
6734 abs_value = 0xffffffff - value + 1;
6735 if ((abs_value & 0xffffff00) != 0)
6736 {
6737 as_bad_where (fixP->fx_file, fixP->fx_line,
6738 _(" branch relocation truncate (0x%x) [-2^8 ~ 2^8]"), (unsigned int) value);
6739 return;
6740 }
6741 content = s7_md_chars_to_number (buf, s7_INSN16_SIZE);
6742 content &= 0xff00;
6743 content = (content & 0xff00) | ((value >> 1) & 0xff);
6744 s7_number_to_chars (buf, content, s7_INSN16_SIZE);
6745 fixP->fx_r_type = BFD_RELOC_SCORE16_BRANCH;
6746 fixP->fx_size = 2;
6747 }
6748 else
6749 {
6750 if ((value & 0x80000000) == 0x80000000)
6751 abs_value = 0xffffffff - value + 1;
6752 if ((abs_value & 0xfff80000) != 0)
6753 {
6754 as_bad_where (fixP->fx_file, fixP->fx_line,
6755 _(" branch relocation truncate (0x%x) [-2^19 ~ 2^19]"),
6756 (unsigned int) value);
6757 return;
6758 }
6759 content = s7_md_chars_to_number (buf, s7_INSN_SIZE);
6760 content &= 0xfc00fc01;
6761 content = (content & 0xfc00fc01) | (value & 0x3fe) | ((value << 6) & 0x3ff0000);
6762 s7_number_to_chars (buf, content, s7_INSN_SIZE);
6763 }
6764 break;
6765 case BFD_RELOC_SCORE16_JMP:
6766 content = s7_md_chars_to_number (buf, s7_INSN16_SIZE);
6767 content &= 0xf001;
6768 value = fixP->fx_offset;
6769 if (!(value >= 0 && value <= 0xfff))
6770 {
6771 as_bad_where (fixP->fx_file, fixP->fx_line,
6772 _("j! or jl! truncate (0x%x) [0 ~ 2^12-1]"), (unsigned int) value);
6773 return;
6774 }
6775 value = fixP->fx_offset & 0xfff;
6776 content = (content & 0xfc01) | (value & 0xffe);
6777 s7_number_to_chars (buf, content, s7_INSN16_SIZE);
6778 break;
6779 case BFD_RELOC_SCORE16_BRANCH:
6780 content = s7_md_chars_to_number (buf, s7_INSN_SIZE);
6781 if ((fixP->fx_frag->fr_opcode != 0) && ((content & 0x80008000) == 0x80008000))
6782 {
6783 if ((S_GET_SEGMENT (fixP->fx_addsy) != seg) ||
6784 (fixP->fx_addsy != NULL && S_IS_EXTERNAL (fixP->fx_addsy)))
6785 value = fixP->fx_offset;
6786 else
6787 fixP->fx_done = 1;
6788
6789 if ((value & 0xfff80000) != 0 && (value & 0xfff80000) != 0xfff80000)
6790 {
6791 as_bad_where (fixP->fx_file, fixP->fx_line,
6792 _(" branch relocation truncate (0x%x) [-2^19 ~ 2^19]"),
6793 (unsigned int) value);
6794 return;
6795 }
6796 content = s7_md_chars_to_number (buf, s7_INSN_SIZE);
6797 content = (content & 0xfc00fc01) | (value & 0x3fe) | ((value << 6) & 0x3ff0000);
6798 s7_number_to_chars (buf, content, s7_INSN_SIZE);
6799 fixP->fx_r_type = BFD_RELOC_SCORE_BRANCH;
6800 fixP->fx_size = 4;
6801 break;
6802 }
6803 else
6804 {
6805 /* In differnt section. */
6806 if ((S_GET_SEGMENT (fixP->fx_addsy) != seg) ||
6807 (fixP->fx_addsy != NULL && S_IS_EXTERNAL (fixP->fx_addsy)))
6808 value = fixP->fx_offset;
6809 else
6810 fixP->fx_done = 1;
6811
6812 if ((value & 0xffffff00) != 0 && (value & 0xffffff00) != 0xffffff00)
6813 {
6814 as_bad_where (fixP->fx_file, fixP->fx_line,
6815 _(" branch relocation truncate (0x%x) [-2^8 ~ 2^8]"),
6816 (unsigned int) value);
6817 return;
6818 }
6819 content = s7_md_chars_to_number (buf, s7_INSN16_SIZE);
6820 content = (content & 0xff00) | ((value >> 1) & 0xff);
6821 s7_number_to_chars (buf, content, s7_INSN16_SIZE);
6822 break;
6823 }
6824 case BFD_RELOC_8:
6825 if (fixP->fx_done || fixP->fx_pcrel)
6826 s7_number_to_chars (buf, value, 1);
6827 #ifdef OBJ_ELF
6828 else
6829 {
6830 value = fixP->fx_offset;
6831 s7_number_to_chars (buf, value, 1);
6832 }
6833 #endif
6834 break;
6835
6836 case BFD_RELOC_16:
6837 if (fixP->fx_done || fixP->fx_pcrel)
6838 s7_number_to_chars (buf, value, 2);
6839 #ifdef OBJ_ELF
6840 else
6841 {
6842 value = fixP->fx_offset;
6843 s7_number_to_chars (buf, value, 2);
6844 }
6845 #endif
6846 break;
6847 case BFD_RELOC_RVA:
6848 case BFD_RELOC_32:
6849 if (fixP->fx_done || fixP->fx_pcrel)
6850 s7_number_to_chars (buf, value, 4);
6851 #ifdef OBJ_ELF
6852 else
6853 {
6854 value = fixP->fx_offset;
6855 s7_number_to_chars (buf, value, 4);
6856 }
6857 #endif
6858 break;
6859 case BFD_RELOC_VTABLE_INHERIT:
6860 fixP->fx_done = 0;
6861 if (fixP->fx_addsy && !S_IS_DEFINED (fixP->fx_addsy) && !S_IS_WEAK (fixP->fx_addsy))
6862 S_SET_WEAK (fixP->fx_addsy);
6863 break;
6864 case BFD_RELOC_VTABLE_ENTRY:
6865 fixP->fx_done = 0;
6866 break;
6867 case BFD_RELOC_SCORE_GPREL15:
6868 content = s7_md_chars_to_number (buf, s7_INSN_SIZE);
6869 if ((fixP->fx_frag->fr_opcode != 0) && ((content & 0xfc1c8000) != 0x94188000))
6870 fixP->fx_r_type = BFD_RELOC_NONE;
6871 fixP->fx_done = 0;
6872 break;
6873 case BFD_RELOC_SCORE_GOT15:
6874 case BFD_RELOC_SCORE_DUMMY_HI16:
6875 case BFD_RELOC_SCORE_GOT_LO16:
6876 case BFD_RELOC_SCORE_CALL15:
6877 case BFD_RELOC_GPREL32:
6878 break;
6879 case BFD_RELOC_NONE:
6880 default:
6881 as_bad_where (fixP->fx_file, fixP->fx_line, _("bad relocation fixup type (%d)"), fixP->fx_r_type);
6882 }
6883 }
6884
6885 /* Translate internal representation of relocation info to BFD target format. */
6886
6887 static arelent **
6888 s7_gen_reloc (asection * section ATTRIBUTE_UNUSED, fixS * fixp)
6889 {
6890 static arelent *retval[MAX_RELOC_EXPANSION + 1]; /* MAX_RELOC_EXPANSION equals 2. */
6891 arelent *reloc;
6892 bfd_reloc_code_real_type code;
6893 char *type;
6894 fragS *f;
6895 symbolS *s;
6896 expressionS e;
6897
6898 reloc = retval[0] = xmalloc (sizeof (arelent));
6899 retval[1] = NULL;
6900
6901 reloc->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
6902 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
6903 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
6904 reloc->addend = fixp->fx_offset;
6905
6906 /* If this is a variant frag, we may need to adjust the existing
6907 reloc and generate a new one. */
6908 if (fixp->fx_frag->fr_opcode != NULL && (fixp->fx_r_type == BFD_RELOC_SCORE_GPREL15))
6909 {
6910 /* Update instruction imm bit. */
6911 offsetT newval;
6912 unsigned short off;
6913 char *buf;
6914
6915 buf = fixp->fx_frag->fr_literal + fixp->fx_frag->insn_addr;
6916 newval = s7_md_chars_to_number (buf, s7_INSN_SIZE);
6917 off = fixp->fx_offset >> 16;
6918 newval |= (off & 0x3fff) << 1;
6919 newval |= ((off >> 14) & 0x3) << 16;
6920 s7_number_to_chars (buf, newval, s7_INSN_SIZE);
6921
6922 buf += s7_INSN_SIZE;
6923 newval = s7_md_chars_to_number (buf, s7_INSN_SIZE);
6924 off = fixp->fx_offset & 0xffff;
6925 newval |= ((off & 0x3fff) << 1);
6926 newval |= (((off >> 14) & 0x3) << 16);
6927 s7_number_to_chars (buf, newval, s7_INSN_SIZE);
6928
6929 retval[1] = xmalloc (sizeof (arelent));
6930 retval[2] = NULL;
6931 retval[1]->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
6932 *retval[1]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
6933 retval[1]->address = (reloc->address + s7_RELAX_RELOC2 (fixp->fx_frag->fr_subtype));
6934
6935 f = fixp->fx_frag;
6936 s = f->fr_symbol;
6937 e = s->sy_value;
6938
6939 retval[1]->addend = 0;
6940 retval[1]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_LO16);
6941 gas_assert (retval[1]->howto != NULL);
6942
6943 fixp->fx_r_type = BFD_RELOC_HI16_S;
6944 }
6945
6946 code = fixp->fx_r_type;
6947 switch (fixp->fx_r_type)
6948 {
6949 case BFD_RELOC_32:
6950 if (fixp->fx_pcrel)
6951 {
6952 code = BFD_RELOC_32_PCREL;
6953 break;
6954 }
6955 case BFD_RELOC_HI16_S:
6956 case BFD_RELOC_LO16:
6957 case BFD_RELOC_SCORE_JMP:
6958 case BFD_RELOC_SCORE_BRANCH:
6959 case BFD_RELOC_SCORE16_JMP:
6960 case BFD_RELOC_SCORE16_BRANCH:
6961 case BFD_RELOC_VTABLE_ENTRY:
6962 case BFD_RELOC_VTABLE_INHERIT:
6963 case BFD_RELOC_SCORE_GPREL15:
6964 case BFD_RELOC_SCORE_GOT15:
6965 case BFD_RELOC_SCORE_DUMMY_HI16:
6966 case BFD_RELOC_SCORE_GOT_LO16:
6967 case BFD_RELOC_SCORE_CALL15:
6968 case BFD_RELOC_GPREL32:
6969 case BFD_RELOC_NONE:
6970 code = fixp->fx_r_type;
6971 break;
6972 default:
6973 type = _("<unknown>");
6974 as_bad_where (fixp->fx_file, fixp->fx_line,
6975 _("cannot represent %s relocation in this object file format"), type);
6976 return NULL;
6977 }
6978
6979 reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
6980 if (reloc->howto == NULL)
6981 {
6982 as_bad_where (fixp->fx_file, fixp->fx_line,
6983 _("cannot represent %s relocation in this object file format1"),
6984 bfd_get_reloc_code_name (code));
6985 return NULL;
6986 }
6987 /* HACK: Since arm ELF uses Rel instead of Rela, encode the
6988 vtable entry to be used in the relocation's section offset. */
6989 if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
6990 reloc->address = fixp->fx_offset;
6991
6992 return retval;
6993 }
Patches to binutils for mingw-w64