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