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