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