projects / deliverable / binutils-gdb.git / blob
? search:


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