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