Commit | Line | Data |
---|---|---|
d172d4ba | 1 | /* tc-ldx.c -- Assemble for the DLX |
ae6063d4 | 2 | Copyright 2002, 2003 Free Software Foundation, Inc. |
d172d4ba NC |
3 | |
4 | This file is part of GAS, the GNU Assembler. | |
5 | ||
6 | GAS is free software; you can redistribute it and/or modify | |
7 | it under the terms of the GNU General Public License as published by | |
8 | the Free Software Foundation; either version 2, or (at your option) | |
9 | any later version. | |
10 | ||
11 | GAS is distributed in the hope that it will be useful, | |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | GNU General Public License for more details. | |
15 | ||
16 | You should have received a copy of the GNU General Public License | |
17 | along with GAS; see the file COPYING. If not, write to the Free | |
18 | Software Foundation, 59 Temple Place - Suite 330, Boston, MA | |
19 | 02111-1307, USA. */ | |
20 | ||
21 | /* Initially created by Kuang Hwa Lin, 3/20/2002. */ | |
22 | ||
23 | #include "safe-ctype.h" | |
24 | #include "as.h" | |
25 | #include "tc-dlx.h" | |
26 | #include "opcode/dlx.h" | |
27 | #if 0 | |
28 | #include "elf/dlx.h" | |
29 | #endif | |
30 | ||
31 | /* Make it easier to clone this machine desc into another one. */ | |
32 | #define machine_opcode dlx_opcode | |
33 | #define machine_opcodes dlx_opcodes | |
34 | #define machine_ip dlx_ip | |
35 | #define machine_it dlx_it | |
36 | ||
37 | #define NO_RELOC BFD_RELOC_NONE | |
38 | #define RELOC_DLX_REL26 BFD_RELOC_DLX_JMP26 | |
39 | #define RELOC_DLX_16 BFD_RELOC_16 | |
40 | #define RELOC_DLX_REL16 BFD_RELOC_16_PCREL_S2 | |
41 | #define RELOC_DLX_HI16 BFD_RELOC_HI16_S | |
42 | #define RELOC_DLX_LO16 BFD_RELOC_LO16 | |
43 | #define RELOC_DLX_VTINHERIT BFD_RELOC_VTABLE_INHERIT | |
44 | #define RELOC_DLX_VTENTRY BFD_RELOC_VTABLE_ENTRY | |
45 | ||
46 | /* handle of the OPCODE hash table */ | |
47 | static struct hash_control *op_hash = NULL; | |
48 | ||
49 | struct machine_it | |
50 | { | |
51 | char *error; | |
52 | unsigned long opcode; | |
53 | struct nlist *nlistp; | |
54 | expressionS exp; | |
55 | int pcrel; | |
56 | int size; | |
57 | int reloc_offset; /* Offset of reloc within insn. */ | |
58 | int reloc; | |
59 | int HI; | |
60 | int LO; | |
61 | } | |
62 | the_insn; | |
63 | ||
64 | /* static void print_insn PARAMS ((struct machine_it *)); */ | |
65 | char * parse_operand PARAMS ((char *, expressionS *)); | |
66 | int md_chars_to_number PARAMS ((unsigned char *, int)); | |
67 | ||
68 | static void machine_ip PARAMS ((char *)); | |
69 | static void s_proc PARAMS ((int)); | |
70 | static void insert_sreg PARAMS ((char *, int)); | |
71 | static int hilo_modifier_ok PARAMS ((char *)); | |
72 | static int is_ldst_registers PARAMS ((char *)); | |
73 | static int match_sft_register PARAMS ((char *)); | |
74 | static void define_some_regs PARAMS ((void)); | |
75 | static char * dlx_parse_loadop PARAMS ((char *)); | |
76 | static char * dlx_parse_storeop PARAMS ((char *)); | |
77 | static char * fix_ld_st_operand PARAMS ((unsigned long, char *)); | |
78 | ||
79 | const pseudo_typeS | |
80 | ||
81 | dlx_pseudo_table[] = | |
82 | { | |
83 | /* Some additional ops that are used by gcc-dlx. */ | |
84 | {"asciiz", stringer, 1}, | |
85 | {"half", cons, 2}, | |
86 | {"dword", cons, 8}, | |
87 | {"word", cons, 4}, | |
88 | {"proc", s_proc, 0}, | |
89 | {"endproc", s_proc, 1}, | |
90 | {NULL, 0, 0}, | |
91 | }; | |
92 | ||
93 | /* This array holds the chars that always start a comment. If the | |
94 | pre-processor is disabled, these aren't very useful. */ | |
95 | const char comment_chars[] = ";"; | |
96 | ||
97 | /* This array holds the chars that only start a comment at the beginning of | |
98 | a line. If the line seems to have the form '# 123 filename' | |
99 | .line and .file directives will appear in the pre-processed output. */ | |
100 | /* Note that input_file.c hand checks for '#' at the beginning of the | |
101 | first line of the input file. This is because the compiler outputs | |
102 | #NO_APP at the beginning of its output. */ | |
103 | /* Also note that comments like this one will always work. */ | |
104 | const char line_comment_chars[] = "#"; | |
105 | ||
106 | /* We needed an unused char for line separation to work around the | |
107 | lack of macros, using sed and such. */ | |
108 | const char line_separator_chars[] = "@"; | |
109 | ||
110 | /* Chars that can be used to separate mant from exp in floating point nums. */ | |
111 | const char EXP_CHARS[] = "eE"; | |
112 | ||
113 | /* Chars that mean this number is a floating point constant. | |
114 | As in 0f12.456 | |
115 | or 0d1.2345e12. */ | |
116 | const char FLT_CHARS[] = "rRsSfFdDxXpP"; | |
117 | ||
118 | static void | |
119 | insert_sreg (regname, regnum) | |
120 | char *regname; | |
121 | int regnum; | |
122 | { | |
123 | /* Must be large enough to hold the names of the special registers. */ | |
124 | char buf[80]; | |
125 | int i; | |
126 | ||
127 | symbol_table_insert (symbol_new (regname, reg_section, (valueT) regnum, | |
128 | &zero_address_frag)); | |
129 | for (i = 0; regname[i]; i++) | |
130 | buf[i] = ISLOWER (regname[i]) ? TOUPPER (regname[i]) : regname[i]; | |
131 | buf[i] = '\0'; | |
132 | ||
133 | symbol_table_insert (symbol_new (buf, reg_section, (valueT) regnum, | |
134 | &zero_address_frag)); | |
135 | } | |
136 | ||
137 | /* Install symbol definitions for assorted special registers. | |
138 | See MIPS Assembly Language Programmer's Guide page 1-4 */ | |
139 | ||
140 | static void | |
141 | define_some_regs () | |
142 | { | |
143 | #if 0 | |
144 | /* Hardware representation. */ | |
145 | insert_sreg ("r0", 0); | |
146 | insert_sreg ("r1", 1); | |
147 | insert_sreg ("r2", 2); | |
148 | insert_sreg ("r3", 3); | |
149 | insert_sreg ("r4", 4); | |
150 | insert_sreg ("r5", 5); | |
151 | insert_sreg ("r6", 6); | |
152 | insert_sreg ("r7", 7); | |
153 | insert_sreg ("r8", 8); | |
154 | insert_sreg ("r9", 9); | |
155 | insert_sreg ("r10", 10); | |
156 | insert_sreg ("r11", 11); | |
157 | insert_sreg ("r12", 12); | |
158 | insert_sreg ("r13", 13); | |
159 | insert_sreg ("r14", 14); | |
160 | insert_sreg ("r15", 15); | |
161 | insert_sreg ("r16", 16); | |
162 | insert_sreg ("r17", 17); | |
163 | insert_sreg ("r18", 18); | |
164 | insert_sreg ("r19", 19); | |
165 | insert_sreg ("r20", 20); | |
166 | insert_sreg ("r21", 21); | |
167 | insert_sreg ("r22", 22); | |
168 | insert_sreg ("r23", 23); | |
169 | insert_sreg ("r24", 24); | |
170 | insert_sreg ("r25", 25); | |
171 | insert_sreg ("r26", 26); | |
172 | insert_sreg ("r27", 27); | |
173 | insert_sreg ("r28", 28); | |
174 | insert_sreg ("r29", 29); | |
175 | insert_sreg ("r30", 30); | |
176 | insert_sreg ("r31", 31); | |
177 | #endif | |
178 | /* Software representation. */ | |
179 | insert_sreg ("zero", 0); | |
180 | insert_sreg ("at", 1); | |
181 | insert_sreg ("v0", 2); | |
182 | insert_sreg ("v1", 3); | |
183 | insert_sreg ("a0", 4); | |
184 | insert_sreg ("a1", 5); | |
185 | insert_sreg ("a2", 6); | |
186 | insert_sreg ("a3", 7); | |
187 | insert_sreg ("t0", 8); | |
188 | insert_sreg ("t1", 9); | |
189 | insert_sreg ("t2", 10); | |
190 | insert_sreg ("t3", 11); | |
191 | insert_sreg ("t4", 12); | |
192 | insert_sreg ("t5", 13); | |
193 | insert_sreg ("t6", 14); | |
194 | insert_sreg ("t7", 15); | |
195 | insert_sreg ("s0", 16); | |
196 | insert_sreg ("s1", 17); | |
197 | insert_sreg ("s2", 18); | |
198 | insert_sreg ("s3", 19); | |
199 | insert_sreg ("s4", 20); | |
200 | insert_sreg ("s5", 21); | |
201 | insert_sreg ("s6", 22); | |
202 | insert_sreg ("s7", 23); | |
203 | insert_sreg ("t8", 24); | |
204 | insert_sreg ("t9", 25); | |
205 | insert_sreg ("k0", 26); | |
206 | insert_sreg ("k1", 27); | |
207 | insert_sreg ("gp", 28); | |
208 | insert_sreg ("sp", 29); | |
209 | insert_sreg ("fp", 30); | |
210 | insert_sreg ("ra", 31); | |
211 | /* Special registers. */ | |
212 | insert_sreg ("pc", 0); | |
213 | insert_sreg ("npc", 1); | |
214 | insert_sreg ("iad", 2); | |
215 | } | |
216 | ||
217 | /* Subroutine check the string to match an register, */ | |
218 | ||
219 | static int | |
220 | match_sft_register (name) | |
221 | char *name; | |
222 | { | |
223 | #define MAX_REG_NO 35 | |
224 | /* Currently we have 35 software registers defined - | |
225 | we borrowed from MIPS. */ | |
226 | static char *soft_reg[] = | |
227 | { | |
228 | "zero", "at", "v0", "v1", "a0", "a1", "a2", "a3", | |
229 | "t0", "t1", "t2", "t3", "t4", "t5", "t6", "t7", "t8", "t9", | |
230 | "s0", "s1", "s2", "s3", "s4", "s5", "s7", "k0", "k1", | |
231 | "gp", "sp", "fp", "ra", "pc", "npc", "iad", | |
232 | "EndofTab" /* End of the Table indicator */ | |
233 | }; | |
234 | char low_name[21], *ptr; | |
235 | int idx; | |
236 | ||
237 | for (ptr = name,idx = 0; *ptr != '\0'; ptr++) | |
238 | low_name[idx++] = TOLOWER (*ptr); | |
239 | ||
240 | low_name[idx] = '\0'; | |
241 | idx = 0; | |
242 | ||
243 | while (idx < MAX_REG_NO && strcmp (soft_reg[idx], & low_name [0])) | |
244 | idx += 1; | |
245 | ||
246 | return idx < MAX_REG_NO; | |
247 | } | |
248 | ||
249 | /* Subroutine check the string to match an register. */ | |
250 | ||
251 | static int | |
252 | is_ldst_registers (name) | |
253 | char *name; | |
254 | { | |
255 | char *ptr = name; | |
256 | ||
257 | /* The first character of the register name got to be either %, $, r of R. */ | |
258 | if ((ptr[0] == '%' || ptr[0] == '$' || ptr[0] == 'r' || ptr[0] == 'R') | |
259 | && ISDIGIT ((unsigned char) ptr[1])) | |
260 | return 1; | |
261 | ||
262 | /* Now check the software register representation. */ | |
263 | return match_sft_register (ptr); | |
264 | } | |
265 | ||
266 | /* Subroutine of s_proc so targets can choose a different default prefix. | |
267 | If DEFAULT_PREFIX is NULL, use the target's "leading char". */ | |
268 | ||
269 | static void | |
270 | s_proc (end_p) | |
271 | int end_p; | |
272 | { | |
273 | /* Record the current function so that we can issue an error message for | |
274 | misplaced .func,.endfunc, and also so that .endfunc needs no | |
275 | arguments. */ | |
276 | static char *current_name; | |
277 | static char *current_label; | |
278 | ||
279 | if (end_p) | |
280 | { | |
281 | if (current_name == NULL) | |
282 | { | |
283 | as_bad (_("missing .proc")); | |
284 | ignore_rest_of_line (); | |
285 | return; | |
286 | } | |
287 | ||
288 | current_name = current_label = NULL; | |
289 | SKIP_WHITESPACE (); | |
290 | while (!is_end_of_line[(unsigned char) *input_line_pointer]) | |
291 | input_line_pointer++; | |
292 | } | |
293 | else | |
294 | { | |
295 | char *name, *label; | |
296 | char delim1, delim2; | |
297 | ||
298 | if (current_name != NULL) | |
299 | { | |
300 | as_bad (_(".endfunc missing for previous .proc")); | |
301 | ignore_rest_of_line (); | |
302 | return; | |
303 | } | |
304 | ||
305 | name = input_line_pointer; | |
306 | delim1 = get_symbol_end (); | |
307 | name = xstrdup (name); | |
308 | *input_line_pointer = delim1; | |
309 | SKIP_WHITESPACE (); | |
310 | ||
311 | if (*input_line_pointer != ',') | |
312 | { | |
313 | char leading_char = 0; | |
314 | ||
315 | leading_char = bfd_get_symbol_leading_char (stdoutput); | |
316 | /* Missing entry point, use function's name with the leading | |
317 | char prepended. */ | |
318 | if (leading_char) | |
319 | asprintf (&label, "%c%s", leading_char, name); | |
320 | else | |
321 | label = name; | |
322 | } | |
323 | else | |
324 | { | |
325 | ++input_line_pointer; | |
326 | SKIP_WHITESPACE (); | |
327 | label = input_line_pointer; | |
328 | delim2 = get_symbol_end (); | |
329 | label = xstrdup (label); | |
330 | *input_line_pointer = delim2; | |
331 | } | |
332 | ||
333 | current_name = name; | |
334 | current_label = label; | |
335 | } | |
336 | demand_empty_rest_of_line (); | |
337 | } | |
338 | ||
339 | /* This function is called once, at assembler startup time. It should | |
340 | set up all the tables, etc., that the MD part of the assembler will | |
341 | need. */ | |
342 | ||
343 | void | |
344 | md_begin () | |
345 | { | |
346 | const char *retval = NULL; | |
347 | int lose = 0; | |
348 | unsigned int i; | |
349 | ||
350 | /* Create a new hash table. */ | |
351 | op_hash = hash_new (); | |
352 | ||
353 | /* Hash up all the opcodes for fast use later. */ | |
354 | for (i = 0; i < num_dlx_opcodes; i++) | |
355 | { | |
356 | const char *name = machine_opcodes[i].name; | |
357 | ||
358 | retval = hash_insert (op_hash, name, (PTR) &machine_opcodes[i]); | |
359 | ||
360 | if (retval != NULL) | |
361 | { | |
362 | fprintf (stderr, "internal error: can't hash `%s': %s\n", | |
363 | machine_opcodes[i].name, retval); | |
364 | lose = 1; | |
365 | } | |
366 | } | |
367 | ||
368 | if (lose) | |
369 | as_fatal (_("Broken assembler. No assembly attempted.")); | |
370 | ||
371 | define_some_regs (); | |
d172d4ba NC |
372 | } |
373 | ||
374 | /* Assemble a single instruction. Its label has already been handled | |
375 | by the generic front end. We just parse opcode and operands, and | |
376 | produce the bytes of data and relocation. */ | |
377 | ||
378 | void | |
379 | md_assemble (str) | |
380 | char *str; | |
381 | { | |
382 | char *toP; | |
383 | fixS *fixP; | |
384 | bit_fixS *bitP; | |
385 | ||
386 | know (str); | |
387 | machine_ip (str); | |
388 | toP = frag_more (4); | |
389 | /* Put out the opcode. */ | |
390 | md_number_to_chars (toP, the_insn.opcode, 4); | |
391 | ||
392 | /* Put out the symbol-dependent stuff. */ | |
393 | if (the_insn.reloc != NO_RELOC) | |
394 | { | |
395 | fixP = fix_new_exp (frag_now, | |
396 | (toP - frag_now->fr_literal + the_insn.reloc_offset), | |
397 | the_insn.size, & the_insn.exp, the_insn.pcrel, | |
398 | the_insn.reloc); | |
399 | ||
400 | switch (fixP->fx_r_type) | |
401 | { | |
402 | case RELOC_DLX_REL26: | |
403 | bitP = malloc (sizeof (bit_fixS)); | |
404 | bitP->fx_bit_size = 26; | |
405 | bitP->fx_bit_offset = 25; | |
406 | bitP->fx_bit_base = the_insn.opcode & 0xFC000000; | |
407 | bitP->fx_bit_base_adj = 0; | |
408 | bitP->fx_bit_max = 0; | |
409 | bitP->fx_bit_min = 0; | |
410 | bitP->fx_bit_add = 0x03FFFFFF; | |
411 | fixP->fx_bit_fixP = bitP; | |
412 | break; | |
413 | case RELOC_DLX_REL16: | |
414 | bitP = malloc (sizeof (bit_fixS)); | |
415 | bitP->fx_bit_size = 16; | |
416 | bitP->fx_bit_offset = 15; | |
417 | bitP->fx_bit_base = the_insn.opcode & 0xFFFF0000; | |
418 | bitP->fx_bit_base_adj = 0; | |
419 | bitP->fx_bit_max = 0; | |
420 | bitP->fx_bit_min = 0; | |
421 | bitP->fx_bit_add = 0x0000FFFF; | |
422 | fixP->fx_bit_fixP = bitP; | |
423 | break; | |
424 | case RELOC_DLX_HI16: | |
425 | bitP = malloc (sizeof (bit_fixS)); | |
426 | bitP->fx_bit_size = 16; | |
427 | bitP->fx_bit_offset = 15; | |
428 | bitP->fx_bit_base = the_insn.opcode & 0xFFFF0000; | |
429 | bitP->fx_bit_base_adj = 0; | |
430 | bitP->fx_bit_max = 0; | |
431 | bitP->fx_bit_min = 0; | |
432 | bitP->fx_bit_add = 0x0000FFFF; | |
433 | fixP->fx_bit_fixP = bitP; | |
434 | break; | |
435 | default: | |
436 | fixP->fx_bit_fixP = (bit_fixS *)NULL; | |
437 | break; | |
438 | } | |
439 | } | |
440 | } | |
441 | ||
442 | static int | |
443 | hilo_modifier_ok (s) | |
444 | char *s; | |
445 | { | |
446 | char *ptr = s; | |
447 | int idx, count = 1; | |
448 | ||
449 | if (*ptr != '(') | |
450 | return 1; | |
451 | ||
452 | for (idx = 1; ptr[idx] != '\0' && ptr[idx] != '[' && idx < 73; idx += 1) | |
453 | { | |
454 | if (count == 0) | |
455 | return count; | |
456 | ||
457 | if (ptr[idx] == '(') | |
458 | count += 1; | |
459 | ||
460 | if (ptr[idx] == ')') | |
461 | count -= 1; | |
462 | } | |
463 | ||
464 | return (count == 0) ? 1:0; | |
465 | } | |
466 | ||
467 | char * | |
468 | parse_operand (s, operandp) | |
469 | char *s; | |
470 | expressionS *operandp; | |
471 | { | |
472 | char *save = input_line_pointer; | |
473 | char *new; | |
474 | ||
475 | the_insn.HI = the_insn.LO = 0; | |
476 | ||
477 | /* Search for %hi and %lo, make a mark and skip it. */ | |
478 | if (strncmp (s, "%hi", 3) == 0) | |
479 | { | |
480 | s += 3; | |
481 | the_insn.HI = 1; | |
482 | } | |
483 | else | |
484 | { | |
485 | if (strncmp (s, "%lo", 3) == 0) | |
486 | { | |
487 | s += 3; | |
488 | the_insn.LO = 1; | |
489 | } | |
490 | else | |
491 | the_insn.LO = 0; | |
492 | } | |
493 | ||
494 | if (the_insn.HI || the_insn.LO) | |
495 | { | |
496 | if (!hilo_modifier_ok (s)) | |
497 | as_bad (_("Expression Error for operand modifier %%hi/%%lo\n")); | |
498 | } | |
499 | ||
500 | /* Check for the % and $ register representation */ | |
501 | if ((s[0] == '%' || s[0] == '$' || s[0] == 'r' || s[0] == 'R') | |
502 | && ISDIGIT ((unsigned char) s[1])) | |
503 | { | |
504 | /* We have a numeric register expression. No biggy. */ | |
505 | s += 1; | |
506 | input_line_pointer = s; | |
507 | (void) expression (operandp); | |
508 | if (operandp->X_op != O_constant | |
509 | || operandp->X_add_number > 31) | |
510 | as_bad (_("Invalid expression after %%%%\n")); | |
511 | operandp->X_op = O_register; | |
512 | } | |
513 | else | |
514 | { | |
515 | /* Normal operand parsing. */ | |
516 | input_line_pointer = s; | |
517 | (void) expression (operandp); | |
518 | } | |
519 | ||
520 | new = input_line_pointer; | |
521 | input_line_pointer = save; | |
522 | return new; | |
523 | } | |
524 | ||
525 | /* This function will check the opcode and return 1 if the opcode is one | |
526 | of the load/store instruction, and it will fix the operand string to | |
527 | the standard form so we can use the standard parse_operand routine. */ | |
528 | ||
529 | #define READ_OP 0x100 | |
530 | #define WRITE_OP 0x200 | |
531 | static char iBuf[81]; | |
532 | ||
533 | static char * | |
534 | dlx_parse_loadop (str) | |
535 | char * str; | |
536 | { | |
537 | char *ptr = str; | |
538 | int idx = 0; | |
539 | ||
540 | /* The last pair of ()/[] is the register, all other are the | |
541 | reloc displacement, and if there is a register then it ought | |
542 | to have a pair of ()/[] | |
543 | This is not necessarily true, what if the load instruction come | |
544 | without the register and with %hi/%lo modifier? */ | |
545 | for (idx = 0; idx < 72 && ptr[idx] != '\0'; idx++) | |
546 | ; | |
547 | ||
548 | if (idx == 72) | |
549 | { | |
550 | badoperand_load: | |
551 | as_bad (_("Bad operand for a load instruction: <%s>"), str); | |
552 | return NULL; | |
553 | } | |
554 | else | |
555 | { | |
556 | int i, pb = 0; | |
557 | int m2 = 0; | |
558 | char rs1[7], rd[7], endm, match = '0'; | |
559 | char imm[72]; | |
560 | ||
561 | idx -= 1; | |
562 | switch (str[idx]) | |
563 | { | |
564 | case ')': | |
565 | match = '('; | |
566 | endm = ')'; | |
567 | break; | |
568 | case ']': | |
569 | match = '['; | |
570 | endm = ']'; | |
571 | break; | |
572 | default: | |
573 | /* No register indicated, fill in zero. */ | |
574 | rs1[0] = 'r'; | |
575 | rs1[1] = '0'; | |
576 | rs1[2] = '\0'; | |
577 | match = 0; | |
578 | endm = 0; | |
579 | m2 = 1; | |
580 | } | |
581 | ||
582 | if (!m2) | |
583 | { | |
584 | /* Searching for (/[ which will match the ]/). */ | |
585 | for (pb = idx - 1; str[pb] != match; pb -= 1) | |
586 | /* Match can only be either '[' or '(', if it is | |
c03099e6 | 587 | '(' then this can be a normal expression, we'll treat |
d172d4ba NC |
588 | it as an operand. */ |
589 | if (str[pb] == endm || pb < (idx - 5)) | |
590 | goto load_no_rs1; | |
591 | pb += 1; | |
592 | ||
593 | for (i = 0; (pb + i) < idx; i++) | |
594 | rs1[i] = str[pb+i]; | |
595 | ||
596 | rs1[i] = '\0'; | |
597 | ||
598 | if (is_ldst_registers (& rs1[0])) | |
599 | /* Point to the last character of the imm. */ | |
600 | pb -= 1; | |
601 | else | |
602 | { | |
603 | load_no_rs1: | |
604 | if (match == '[') | |
605 | goto badoperand_load; | |
606 | /* No register indicated, fill in zero and restore the imm. */ | |
607 | rs1[0] = 'r'; | |
608 | rs1[1] = '0'; | |
609 | rs1[2] = '\0'; | |
610 | m2 = 1; | |
611 | } | |
612 | } | |
613 | ||
614 | /* Duplicate the first register. */ | |
615 | for (i = 0; i < 7 && str[i] != ','; i++) | |
616 | rd[i] = ptr[i]; | |
617 | ||
618 | if (str[i] != ',') | |
619 | goto badoperand_load; | |
620 | else | |
621 | rd[i] = '\0'; | |
622 | ||
623 | /* Copy the immd. */ | |
624 | if (m2) | |
625 | /* Put the '\0' back in. */ | |
626 | pb = idx + 1; | |
627 | ||
628 | for (i++, m2 = 0; i < pb; m2++,i++) | |
629 | imm[m2] = ptr[i]; | |
630 | ||
631 | imm[m2] = '\0'; | |
632 | ||
2d2255b5 | 633 | /* Assemble the instruction to gas internal format. */ |
d172d4ba NC |
634 | for (i = 0; rd[i] != '\0'; i++) |
635 | iBuf[i] = rd[i]; | |
636 | ||
637 | iBuf[i++] = ','; | |
638 | ||
639 | for (pb = 0 ; rs1[pb] != '\0'; i++, pb++) | |
640 | iBuf[i] = rs1[pb]; | |
641 | ||
642 | iBuf[i++] = ','; | |
643 | ||
644 | for (pb = 0; imm[pb] != '\0'; i++, pb++) | |
645 | iBuf[i] = imm[pb]; | |
646 | ||
647 | iBuf[i] = '\0'; | |
648 | return iBuf; | |
649 | } | |
650 | } | |
651 | ||
652 | static char * | |
653 | dlx_parse_storeop (str) | |
654 | char * str; | |
655 | { | |
656 | char *ptr = str; | |
657 | int idx = 0; | |
658 | ||
659 | /* Search for the ','. */ | |
660 | for (idx = 0; idx < 72 && ptr[idx] != ','; idx++) | |
661 | ; | |
662 | ||
663 | if (idx == 72) | |
664 | { | |
665 | badoperand_store: | |
666 | as_bad (_("Bad operand for a store instruction: <%s>"), str); | |
667 | return NULL; | |
668 | } | |
669 | else | |
670 | { | |
671 | /* idx now points to the ','. */ | |
672 | int i, pb = 0; | |
673 | int comma = idx; | |
674 | int m2 = 0; | |
675 | char rs1[7], rd[7], endm, match = '0'; | |
676 | char imm[72]; | |
677 | ||
678 | /* Now parse the '(' and ')', and make idx point to ')'. */ | |
679 | idx -= 1; | |
680 | switch (str[idx]) | |
681 | { | |
682 | case ')': | |
683 | match = '('; | |
684 | endm = ')'; | |
685 | break; | |
686 | case ']': | |
687 | match = '['; | |
688 | endm = ']'; | |
689 | break; | |
690 | default: | |
691 | /* No register indicated, fill in zero. */ | |
692 | rs1[0] = 'r'; | |
693 | rs1[1] = '0'; | |
694 | rs1[2] = '\0'; | |
695 | match = 0; | |
696 | endm = 0; | |
697 | m2 = 1; | |
698 | } | |
699 | ||
700 | if (!m2) | |
701 | { | |
702 | /* Searching for (/[ which will match the ]/). */ | |
703 | for (pb = idx - 1; str[pb] != match; pb -= 1) | |
704 | if (pb < (idx - 5) || str[pb] == endm) | |
705 | goto store_no_rs1; | |
706 | pb += 1; | |
707 | ||
708 | for (i = 0; (pb + i) < idx; i++) | |
709 | rs1[i] = str[pb + i]; | |
710 | ||
711 | rs1[i] = '\0'; | |
712 | ||
713 | if (is_ldst_registers (& rs1[0])) | |
714 | /* Point to the last character of the imm. */ | |
715 | pb -= 1; | |
716 | else | |
717 | { | |
718 | store_no_rs1: | |
719 | if (match == '[') | |
720 | goto badoperand_store; | |
721 | ||
722 | /* No register indicated, fill in zero and restore the imm. */ | |
723 | rs1[0] = 'r'; | |
724 | rs1[1] = '0'; | |
725 | rs1[2] = '\0'; | |
726 | pb = comma; | |
727 | } | |
728 | } | |
729 | else | |
730 | /* No register was specified. */ | |
731 | pb = comma; | |
732 | ||
733 | /* Duplicate the first register. */ | |
734 | for (i = comma + 1; (str[i] == ' ' || str[i] == '\t'); i++) | |
735 | ; | |
736 | ||
737 | for (m2 = 0; (m2 < 7 && str[i] != '\0'); i++, m2++) | |
738 | { | |
739 | if (str[i] != ' ' && str[i] != '\t') | |
740 | rd[m2] = str[i]; | |
741 | else | |
742 | goto badoperand_store; | |
743 | } | |
744 | ||
745 | if (str[i] != '\0') | |
746 | goto badoperand_store; | |
747 | else | |
748 | rd[m2] = '\0'; | |
749 | ||
750 | /* Copy the immd. */ | |
751 | for (i = 0; i < pb; i++) | |
752 | imm[i] = ptr[i]; | |
753 | ||
754 | imm[i] = '\0'; | |
755 | ||
2d2255b5 | 756 | /* Assemble the instruction to gas internal format. */ |
d172d4ba NC |
757 | for (i = 0; rd[i] != '\0'; i++) |
758 | iBuf[i] = rd[i]; | |
759 | iBuf[i++] = ','; | |
760 | for (pb = 0 ; rs1[pb] != '\0'; i++, pb++) | |
761 | iBuf[i] = rs1[pb]; | |
762 | iBuf[i++] = ','; | |
763 | for (pb = 0; imm[pb] != '\0'; i++, pb++) | |
764 | iBuf[i] = imm[pb]; | |
765 | iBuf[i] = '\0'; | |
766 | return iBuf; | |
767 | } | |
768 | } | |
769 | ||
770 | static char * | |
771 | fix_ld_st_operand (opcode, str) | |
772 | unsigned long opcode; | |
773 | char* str; | |
774 | { | |
775 | /* Check the opcode. */ | |
776 | switch ((int) opcode) | |
777 | { | |
778 | case LBOP: | |
779 | case LBUOP: | |
780 | case LSBUOP: | |
781 | case LHOP: | |
782 | case LHUOP: | |
783 | case LSHUOP: | |
784 | case LWOP: | |
785 | case LSWOP: | |
786 | return dlx_parse_loadop (str); | |
787 | case SBOP: | |
788 | case SHOP: | |
789 | case SWOP: | |
790 | return dlx_parse_storeop (str); | |
791 | default: | |
792 | return str; | |
793 | } | |
794 | } | |
795 | ||
796 | /* Instruction parsing. Takes a string containing the opcode. | |
797 | Operands are at input_line_pointer. Output is in the_insn. | |
798 | Warnings or errors are generated. */ | |
799 | ||
800 | static void | |
801 | machine_ip (str) | |
802 | char *str; | |
803 | { | |
804 | char *s; | |
805 | const char *args; | |
806 | struct machine_opcode *insn; | |
807 | char *argsStart; | |
808 | unsigned long opcode; | |
809 | expressionS the_operand; | |
810 | expressionS *operand = &the_operand; | |
811 | unsigned int reg, reg_shift = 0; | |
812 | ||
813 | /* Fixup the opcode string to all lower cases, and also | |
814 | allow numerical digits. */ | |
815 | s = str; | |
816 | ||
817 | if (ISALPHA (*s)) | |
818 | for (; ISALNUM (*s); ++s) | |
819 | if (ISUPPER (*s)) | |
820 | *s = TOLOWER (*s); | |
821 | ||
822 | switch (*s) | |
823 | { | |
824 | case '\0': | |
825 | break; | |
826 | ||
827 | /* FIXME-SOMEDAY more whitespace. */ | |
828 | case ' ': | |
829 | *s++ = '\0'; | |
830 | break; | |
831 | ||
832 | default: | |
833 | as_bad (_("Unknown opcode: `%s'"), str); | |
834 | return; | |
835 | } | |
836 | ||
837 | /* Hash the opcode, insn will have the string from opcode table. | |
838 | also initialized the_insn struct. */ | |
839 | if ((insn = (struct machine_opcode *) hash_find (op_hash, str)) == NULL) | |
840 | { | |
841 | /* Handle the ret and return macro here. */ | |
842 | if ((strcmp (str, "ret") == 0) || (strcmp (str, "return") == 0)) | |
843 | { | |
844 | memset (&the_insn, '\0', sizeof (the_insn)); | |
845 | the_insn.reloc = NO_RELOC; | |
846 | the_insn.pcrel = 0; | |
847 | the_insn.opcode = | |
848 | (unsigned long)(JROP | 0x03e00000); /* 0x03e00000 = r31 << 21 */ | |
849 | } | |
850 | else | |
851 | as_bad (_("Unknown opcode `%s'."), str); | |
852 | ||
853 | return; | |
854 | } | |
855 | ||
856 | argsStart = s; | |
857 | opcode = insn->opcode; | |
858 | memset (&the_insn, '\0', sizeof (the_insn)); | |
859 | the_insn.reloc = NO_RELOC; | |
860 | the_insn.pcrel = 0; | |
861 | ||
862 | /* Set the sip reloc HI16 flag. */ | |
863 | if (!set_dlx_skip_hi16_flag (1)) | |
864 | as_bad (_("Can not set dlx_skip_hi16_flag")); | |
865 | ||
866 | /* Fix the operand string if it is one of load store instructions. */ | |
867 | s = fix_ld_st_operand (opcode, s); | |
868 | ||
869 | /* Build the opcode, checking as we go to make sure that the | |
870 | operands match. | |
871 | If an operand matches, we modify the_insn or opcode appropriately, | |
872 | and do a "continue". If an operand fails to match, we "break". */ | |
873 | if (insn->args[0] != '\0' && insn->args[0] != 'N') | |
874 | { | |
875 | /* Prime the pump. */ | |
876 | if (*s == '\0') | |
877 | { | |
878 | as_bad (_("Missing arguments for opcode <%s>."), str); | |
879 | return; | |
880 | } | |
881 | else | |
882 | s = parse_operand (s, operand); | |
883 | } | |
884 | else if (insn->args[0] == 'N') | |
885 | { | |
886 | /* Clean up the insn and done! */ | |
887 | the_insn.opcode = opcode; | |
888 | return; | |
889 | } | |
890 | ||
891 | /* Parse through the args (this is from opcode table), *s point to | |
892 | the current character of the instruction stream. */ | |
893 | for (args = insn->args;; ++args) | |
894 | { | |
895 | switch (*args) | |
896 | { | |
897 | /* End of Line. */ | |
898 | case '\0': | |
899 | /* End of args. */ | |
900 | if (*s == '\0') | |
901 | { | |
902 | /* We are truly done. */ | |
903 | the_insn.opcode = opcode; | |
904 | /* Clean up the HI and LO mark. */ | |
905 | the_insn.HI = 0; | |
906 | the_insn.LO = 0; | |
907 | return; | |
908 | } | |
909 | ||
910 | the_insn.HI = 0; | |
911 | the_insn.LO = 0; | |
912 | as_bad (_("Too many operands: %s"), s); | |
913 | break; | |
914 | ||
915 | /* ',' Args separator */ | |
916 | case ',': | |
917 | /* Must match a comma. */ | |
918 | if (*s++ == ',') | |
919 | { | |
920 | /* Parse next operand. */ | |
921 | s = parse_operand (s, operand); | |
922 | continue; | |
923 | } | |
924 | break; | |
925 | ||
926 | /* It can be a 'a' register or 'i' operand. */ | |
927 | case 'P': | |
928 | /* Macro move operand/reg. */ | |
929 | if (operand->X_op == O_register) | |
930 | { | |
931 | /* Its a register. */ | |
932 | reg_shift = 21; | |
933 | goto general_reg; | |
934 | } | |
935 | ||
936 | /* The immediate 16 bits literal, bit 0-15. */ | |
937 | case 'i': | |
938 | /* offset, unsigned. */ | |
939 | case 'I': | |
940 | /* offset, signed. */ | |
941 | if (operand->X_op == O_constant) | |
942 | { | |
943 | if (the_insn.HI) | |
944 | operand->X_add_number >>= 16; | |
945 | ||
946 | opcode |= operand->X_add_number & 0xFFFF; | |
947 | ||
948 | if (the_insn.HI && the_insn.LO) | |
949 | as_bad (_("Both the_insn.HI and the_insn.LO are set : %s"), s); | |
950 | else | |
951 | { | |
952 | the_insn.HI = 0; | |
953 | the_insn.LO = 0; | |
954 | } | |
955 | continue; | |
956 | } | |
957 | ||
958 | the_insn.reloc = (the_insn.HI) ? RELOC_DLX_HI16 : RELOC_DLX_16; | |
959 | the_insn.reloc_offset = 2; | |
960 | the_insn.size = 2; | |
961 | the_insn.pcrel = 0; | |
962 | the_insn.exp = * operand; | |
963 | the_insn.HI = 0; | |
964 | the_insn.LO = 0; | |
965 | continue; | |
966 | ||
967 | case 'd': | |
968 | /* offset, signed. */ | |
969 | if (operand->X_op == O_constant) | |
970 | { | |
971 | opcode |= operand->X_add_number & 0xFFFF; | |
972 | continue; | |
973 | } | |
974 | the_insn.reloc = RELOC_DLX_REL16; | |
975 | the_insn.reloc_offset = 0; /* BIG-ENDIAN Byte 3 of insn. */ | |
976 | the_insn.size = 4; | |
977 | the_insn.pcrel = 1; | |
978 | the_insn.exp = *operand; | |
979 | continue; | |
980 | ||
981 | /* The immediate 26 bits literal, bit 0-25. */ | |
982 | case 'D': | |
983 | /* offset, signed. */ | |
984 | if (operand->X_op == O_constant) | |
985 | { | |
986 | opcode |= operand->X_add_number & 0x3FFFFFF; | |
987 | continue; | |
988 | } | |
989 | the_insn.reloc = RELOC_DLX_REL26; | |
990 | the_insn.reloc_offset = 0; /* BIG-ENDIAN Byte 3 of insn. */ | |
991 | the_insn.size = 4; | |
992 | the_insn.pcrel = 1; | |
993 | the_insn.exp = *operand; | |
994 | continue; | |
995 | ||
996 | /* Type 'a' Register. */ | |
997 | case 'a': | |
998 | /* A general register at bits 21-25, rs1. */ | |
999 | know (operand->X_op != O_register); | |
1000 | reg_shift = 21; | |
1001 | goto general_reg; | |
1002 | ||
1003 | /* Type 'b' Register. */ | |
1004 | case 'b': | |
1005 | /* A general register at bits 16-20, rs2/rd. */ | |
1006 | know (operand->X_op != O_register); | |
1007 | reg_shift = 16; | |
1008 | goto general_reg; | |
1009 | ||
1010 | /* Type 'c' Register. */ | |
1011 | case 'c': | |
1012 | /* A general register at bits 11-15, rd. */ | |
1013 | know (operand->X_op != O_register); | |
1014 | reg_shift = 11; | |
1015 | ||
1016 | general_reg: | |
1017 | know (operand->X_add_symbol == 0); | |
1018 | know (operand->X_op_symbol == 0); | |
1019 | reg = operand->X_add_number; | |
1020 | if (reg & 0xffffffe0) | |
1021 | as_fatal (_("failed regnum sanity check.")); | |
1022 | else | |
1023 | /* Got the register, now figure out where it goes in the opcode. */ | |
1024 | opcode |= reg << reg_shift; | |
1025 | ||
1026 | switch (*args) | |
1027 | { | |
1028 | case 'a': | |
1029 | case 'b': | |
1030 | case 'c': | |
1031 | case 'P': | |
1032 | continue; | |
1033 | } | |
1034 | as_fatal (_("failed general register sanity check.")); | |
1035 | break; | |
1036 | ||
1037 | default: | |
1038 | BAD_CASE (*args); | |
1039 | } | |
1040 | ||
1041 | /* Types or values of args don't match. */ | |
1042 | as_bad ("Invalid operands"); | |
1043 | return; | |
1044 | } | |
1045 | } | |
1046 | ||
1047 | /* This is identical to the md_atof in m68k.c. I think this is right, | |
1048 | but I'm not sure. | |
1049 | ||
1050 | Turn a string in input_line_pointer into a floating point constant | |
1051 | of type TYPE, and store the appropriate bytes in *LITP. The number | |
1052 | of LITTLENUMS emitted is stored in *SIZEP. An error message is | |
1053 | returned, or NULL on OK. */ | |
1054 | /* Dlx will not use it anyway, so I just leave it here for now. */ | |
1055 | ||
1056 | /* Equal to MAX_PRECISION in atof-ieee.c. */ | |
1057 | #define MAX_LITTLENUMS 6 | |
1058 | ||
1059 | char * | |
1060 | md_atof (type, litP, sizeP) | |
1061 | char type; | |
1062 | char *litP; | |
1063 | int *sizeP; | |
1064 | { | |
1065 | int prec; | |
1066 | LITTLENUM_TYPE words[MAX_LITTLENUMS]; | |
1067 | LITTLENUM_TYPE *wordP; | |
1068 | char *t; | |
1069 | ||
1070 | switch (type) | |
1071 | { | |
1072 | case 'f': | |
1073 | case 'F': | |
1074 | case 's': | |
1075 | case 'S': | |
1076 | prec = 2; | |
1077 | break; | |
1078 | ||
1079 | case 'd': | |
1080 | case 'D': | |
1081 | case 'r': | |
1082 | case 'R': | |
1083 | prec = 4; | |
1084 | break; | |
1085 | ||
1086 | case 'x': | |
1087 | case 'X': | |
1088 | prec = 6; | |
1089 | break; | |
1090 | ||
1091 | case 'p': | |
1092 | case 'P': | |
1093 | prec = 6; | |
1094 | break; | |
1095 | ||
1096 | default: | |
1097 | *sizeP = 0; | |
1098 | return "Bad call to MD_ATOF()"; | |
1099 | } | |
1100 | ||
1101 | t = atof_ieee (input_line_pointer, type, words); | |
1102 | if (t) | |
1103 | input_line_pointer = t; | |
1104 | ||
1105 | *sizeP = prec * sizeof (LITTLENUM_TYPE); | |
1106 | ||
1107 | for (wordP = words; prec--;) | |
1108 | { | |
1109 | md_number_to_chars (litP, (valueT) (*wordP++), sizeof (LITTLENUM_TYPE)); | |
1110 | litP += sizeof (LITTLENUM_TYPE); | |
1111 | } | |
1112 | ||
1113 | return 0; | |
1114 | } | |
1115 | ||
1116 | /* Write out big-endian. */ | |
1117 | void | |
1118 | md_number_to_chars (buf, val, n) | |
1119 | char *buf; | |
1120 | valueT val; | |
1121 | int n; | |
1122 | { | |
1123 | number_to_chars_bigendian (buf, val, n); | |
1124 | } | |
1125 | ||
1126 | /* md_chars_to_number: convert from target byte order to host byte order. */ | |
1127 | ||
1128 | int | |
1129 | md_chars_to_number (val, n) | |
1130 | unsigned char *val; /* Value in target byte order. */ | |
1131 | int n; /* Number of bytes in the input. */ | |
1132 | { | |
1133 | int retval; | |
1134 | ||
1135 | for (retval = 0; n--;) | |
1136 | { | |
1137 | retval <<= 8; | |
1138 | retval |= val[n]; | |
1139 | } | |
1140 | ||
1141 | return retval; | |
1142 | } | |
1143 | ||
b34976b6 | 1144 | bfd_boolean |
d172d4ba NC |
1145 | md_dlx_fix_adjustable (fixP) |
1146 | fixS *fixP; | |
1147 | { | |
1148 | /* We need the symbol name for the VTABLE entries. */ | |
a161fe53 AM |
1149 | return (fixP->fx_r_type != BFD_RELOC_VTABLE_INHERIT |
1150 | && fixP->fx_r_type != BFD_RELOC_VTABLE_ENTRY); | |
d172d4ba NC |
1151 | } |
1152 | ||
1153 | void | |
1154 | md_apply_fix3 (fixP, valP, seg) | |
1155 | fixS *fixP; | |
a161fe53 | 1156 | valueT *valP; |
d172d4ba NC |
1157 | segT seg ATTRIBUTE_UNUSED; |
1158 | { | |
1159 | long val = *valP; | |
1160 | char *place = fixP->fx_where + fixP->fx_frag->fr_literal; | |
1161 | ||
1162 | know (fixP->fx_size == 4); | |
1163 | know (fixP->fx_r_type < NO_RELOC); | |
1164 | ||
1165 | switch (fixP->fx_r_type) | |
1166 | { | |
1167 | case RELOC_DLX_REL16: | |
1168 | if (fixP->fx_bit_fixP != (bit_fixS *) NULL) | |
1169 | { | |
1170 | val = (val & 0x0000FFFF) | fixP->fx_bit_fixP->fx_bit_base; | |
1171 | free (fixP->fx_bit_fixP); | |
1172 | fixP->fx_bit_fixP = (bit_fixS *) NULL; | |
1173 | } | |
1174 | #ifdef DEBUG | |
1175 | else | |
1176 | know ((fixP->fx_bit_fixP != (bit_fixS *) NULL)); | |
1177 | #endif | |
1178 | break; | |
1179 | ||
1180 | case RELOC_DLX_HI16: | |
1181 | if (fixP->fx_bit_fixP != (bit_fixS *) NULL) | |
1182 | { | |
1183 | val = (val >> 16) | fixP->fx_bit_fixP->fx_bit_base; | |
1184 | free (fixP->fx_bit_fixP); | |
1185 | fixP->fx_bit_fixP = (bit_fixS *)NULL; | |
1186 | } | |
1187 | #ifdef DEBUG | |
1188 | else | |
1189 | know ((fixP->fx_bit_fixP != (bit_fixS *) NULL)); | |
1190 | #endif | |
1191 | break; | |
1192 | ||
1193 | case RELOC_DLX_REL26: | |
1194 | if (fixP->fx_bit_fixP != (bit_fixS *) NULL) | |
1195 | { | |
1196 | val = (val & 0x03FFFFFF) | fixP->fx_bit_fixP->fx_bit_base; | |
1197 | free (fixP->fx_bit_fixP); | |
1198 | fixP->fx_bit_fixP = (bit_fixS *) NULL; | |
1199 | } | |
1200 | #ifdef DEBUG | |
1201 | else | |
1202 | know ((fixP->fx_bit_fixP != (bit_fixS *) NULL)); | |
1203 | #endif | |
1204 | break; | |
1205 | ||
1206 | case BFD_RELOC_VTABLE_INHERIT: | |
1207 | /* This borrowed from tc-ppc.c on a whim. */ | |
1208 | fixP->fx_done = 0; | |
1209 | if (fixP->fx_addsy | |
1210 | && !S_IS_DEFINED (fixP->fx_addsy) | |
1211 | && !S_IS_WEAK (fixP->fx_addsy)) | |
1212 | S_SET_WEAK (fixP->fx_addsy); | |
1213 | return; | |
1214 | ||
1215 | case BFD_RELOC_VTABLE_ENTRY: | |
1216 | fixP->fx_done = 0; | |
1217 | return; | |
1218 | ||
1219 | default: | |
1220 | break; | |
1221 | } | |
1222 | ||
1223 | number_to_chars_bigendian (place, val, fixP->fx_size); | |
a161fe53 | 1224 | if (fixP->fx_addsy == NULL) |
d172d4ba | 1225 | fixP->fx_done = 1; |
d172d4ba NC |
1226 | } |
1227 | ||
5a38dc70 | 1228 | const char *md_shortopts = ""; |
d172d4ba NC |
1229 | |
1230 | struct option md_longopts[] = | |
1231 | { | |
1232 | {NULL, no_argument, NULL, 0} | |
1233 | }; | |
1234 | ||
1235 | size_t md_longopts_size = sizeof (md_longopts); | |
1236 | ||
1237 | int | |
1238 | md_parse_option (c, arg) | |
1239 | int c ATTRIBUTE_UNUSED; | |
1240 | char *arg ATTRIBUTE_UNUSED; | |
1241 | { | |
1242 | return 0; | |
1243 | } | |
1244 | ||
1245 | void | |
1246 | md_show_usage (stream) | |
1247 | FILE *stream ATTRIBUTE_UNUSED; | |
1248 | { | |
d172d4ba NC |
1249 | } |
1250 | ||
1251 | /* This is called when a line is unrecognized. */ | |
1252 | ||
1253 | int | |
1254 | dlx_unrecognized_line (c) | |
1255 | int c; | |
1256 | { | |
1257 | int lab; | |
1258 | char *s; | |
1259 | ||
1260 | if (c != '$' || ! ISDIGIT ((unsigned char) input_line_pointer[0])) | |
1261 | return 0; | |
1262 | ||
1263 | s = input_line_pointer; | |
1264 | ||
1265 | lab = 0; | |
1266 | while (ISDIGIT ((unsigned char) *s)) | |
1267 | { | |
1268 | lab = lab * 10 + *s - '0'; | |
1269 | ++s; | |
1270 | } | |
1271 | ||
1272 | if (*s != ':') | |
1273 | { | |
1274 | /* Not a label definition. */ | |
1275 | return 0; | |
1276 | } | |
1277 | ||
1278 | if (dollar_label_defined (lab)) | |
1279 | { | |
1280 | as_bad (_("label \"$%d\" redefined"), lab); | |
1281 | return 0; | |
1282 | } | |
1283 | ||
1284 | define_dollar_label (lab); | |
1285 | colon (dollar_label_name (lab, 0)); | |
1286 | input_line_pointer = s + 1; | |
1287 | ||
1288 | return 1; | |
1289 | } | |
1290 | ||
1291 | /* Default the values of symbols known that should be "predefined". We | |
1292 | don't bother to predefine them unless you actually use one, since there | |
1293 | are a lot of them. */ | |
1294 | ||
1295 | symbolS * | |
1296 | md_undefined_symbol (name) | |
1297 | char *name ATTRIBUTE_UNUSED; | |
1298 | { | |
1299 | return NULL; | |
1300 | } | |
1301 | ||
1302 | ||
1303 | /* Parse an operand that is machine-specific, the function was called | |
2d2255b5 | 1304 | in expr.c by operand() function, when everything failed before it |
d172d4ba NC |
1305 | call a quit. */ |
1306 | ||
1307 | void | |
1308 | md_operand (expressionP) | |
1309 | expressionS* expressionP; | |
1310 | { | |
1311 | /* Check for the #number representation */ | |
1312 | if (input_line_pointer[0] == '#' && | |
1313 | ISDIGIT ((unsigned char) input_line_pointer[1])) | |
1314 | { | |
1315 | /* We have a numeric number expression. No biggy. */ | |
1316 | input_line_pointer += 1; /* Skip # */ | |
1317 | ||
1318 | (void) expression (expressionP); | |
1319 | ||
1320 | if (expressionP->X_op != O_constant) | |
1321 | as_bad (_("Invalid expression after # number\n")); | |
1322 | } | |
1323 | ||
1324 | return; | |
1325 | #if 0 | |
1326 | else if (input_line_pointer[0] == '$' | |
1327 | && ISDIGIT ((unsigned char) input_line_pointer[1])) | |
1328 | { | |
1329 | long lab; | |
1330 | char *name; | |
1331 | symbolS *sym; | |
1332 | ||
1333 | /* This is a local label. */ | |
1334 | ++input_line_pointer; | |
1335 | lab = (long) get_absolute_expression (); | |
1336 | if (dollar_label_defined (lab)) | |
1337 | { | |
1338 | name = dollar_label_name (lab, 0); | |
1339 | sym = symbol_find (name); | |
1340 | } | |
1341 | else | |
1342 | { | |
1343 | name = dollar_label_name (lab, 1); | |
1344 | sym = symbol_find_or_make (name); | |
1345 | } | |
1346 | ||
1347 | expressionP->X_op = O_symbol; | |
1348 | expressionP->X_add_symbol = sym; | |
1349 | expressionP->X_add_number = 0; | |
1350 | } | |
1351 | #endif | |
1352 | } | |
1353 | ||
1354 | /* Round up a section size to the appropriate boundary. */ | |
1355 | ||
1356 | valueT | |
1357 | md_section_align (segment, size) | |
1358 | segT segment ATTRIBUTE_UNUSED; | |
1359 | valueT size; | |
1360 | { | |
1361 | /* Byte alignment is fine. */ | |
1362 | return size; | |
1363 | } | |
1364 | ||
1365 | /* Exactly what point is a PC-relative offset relative TO? | |
1366 | On the 29000, they're relative to the address of the instruction, | |
1367 | which we have set up as the address of the fixup too. */ | |
1368 | ||
1369 | long | |
1370 | md_pcrel_from (fixP) | |
1371 | fixS* fixP; | |
1372 | { | |
1373 | return 4 + fixP->fx_where + fixP->fx_frag->fr_address; | |
1374 | } | |
1375 | ||
1376 | /* From cgen.c: */ | |
1377 | ||
1378 | #if 0 | |
1379 | static short | |
1380 | tc_bfd_fix2rtype (fixP) | |
1381 | fixS* fixP; | |
1382 | { | |
1383 | #if 0 | |
1384 | if (fixP->fx_bsr) | |
1385 | abort (); | |
1386 | #endif | |
1387 | ||
1388 | if (fixP->fx_pcrel == 0 && fixP->fx_size == 4) | |
1389 | return BFD_RELOC_32; | |
1390 | ||
1391 | if (fixP->fx_pcrel != 0 && fixP->fx_size == 4) | |
1392 | return BFD_RELOC_26_PCREL; | |
1393 | ||
1394 | abort (); | |
1395 | ||
1396 | return 0; | |
1397 | } | |
1398 | #endif | |
1399 | ||
1400 | /* Translate internal representation of relocation info to BFD target | |
1401 | format. | |
1402 | FIXME: To what extent can we get all relevant targets to use this? | |
1403 | The above FIXME is from a29k, but I think it is also needed here. */ | |
1404 | ||
1405 | arelent * | |
1406 | tc_gen_reloc (section, fixP) | |
1407 | asection *section ATTRIBUTE_UNUSED; | |
1408 | fixS *fixP; | |
1409 | { | |
1410 | arelent * reloc; | |
1411 | ||
1412 | reloc = (arelent *) xmalloc (sizeof (arelent)); | |
1413 | reloc->howto = bfd_reloc_type_lookup (stdoutput, fixP->fx_r_type); | |
1414 | ||
1415 | if (reloc->howto == (reloc_howto_type *) NULL) | |
1416 | { | |
1417 | as_bad_where (fixP->fx_file, fixP->fx_line, | |
1418 | "internal error: can't export reloc type %d (`%s')", | |
1419 | fixP->fx_r_type, | |
1420 | bfd_get_reloc_code_name (fixP->fx_r_type)); | |
1421 | return NULL; | |
1422 | } | |
1423 | ||
1424 | assert (!fixP->fx_pcrel == !reloc->howto->pc_relative); | |
1425 | ||
1426 | reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *)); | |
1427 | *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixP->fx_addsy); | |
1428 | reloc->address = fixP->fx_frag->fr_address + fixP->fx_where; | |
1429 | ||
a161fe53 AM |
1430 | if (fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY) |
1431 | reloc->address = fixP->fx_offset; | |
1432 | reloc->addend = 0; | |
1433 | ||
d172d4ba NC |
1434 | return reloc; |
1435 | } | |
1436 | ||
1437 | extern void pop_insert PARAMS ((const pseudo_typeS *)); | |
1438 | ||
1439 | void | |
1440 | dlx_pop_insert () | |
1441 | { | |
1442 | pop_insert (dlx_pseudo_table); | |
1443 | return ; | |
1444 | } |