Commit | Line | Data |
---|---|---|
3b16e843 | 1 | /* Assembly backend for the OpenRISC 1000. |
aef6203b | 2 | Copyright (C) 2002, 2003, 2005 Free Software Foundation, Inc. |
3b16e843 NC |
3 | Contributed by Damjan Lampret <lampret@opencores.org>. |
4 | Modified bu Johan Rydberg, <johan.rydberg@netinsight.se>. | |
5 | Based upon a29k port. | |
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 2, 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 | |
4b4da160 NC |
21 | the Free Software Foundation, 51 Franklin Street - Fifth Floor, |
22 | Boston, MA 02110-1301, USA. */ | |
3b16e843 NC |
23 | |
24 | /* tc-a29k.c used as a template. */ | |
25 | ||
26 | #include "safe-ctype.h" | |
27 | #include "as.h" | |
28 | #include "opcode/or32.h" | |
29 | ||
30 | #ifdef BFD_ASSEMBLER | |
5d6255fe | 31 | #include "elf/or32.h" |
3b16e843 NC |
32 | #endif |
33 | ||
34 | #define DEBUG 0 | |
35 | ||
36 | #ifndef REGISTER_PREFIX | |
37 | #define REGISTER_PREFIX '%' | |
38 | #endif | |
39 | ||
40 | /* Make it easier to clone this machine desc into another one. */ | |
41 | #define machine_opcode or32_opcode | |
42 | #define machine_opcodes or32_opcodes | |
43 | #define machine_ip or32_ip | |
44 | #define machine_it or32_it | |
45 | ||
46 | /* Handle of the OPCODE hash table. */ | |
47 | static struct hash_control *op_hash = NULL; | |
48 | ||
49 | struct machine_it | |
ea1562b3 NC |
50 | { |
51 | char * error; | |
52 | unsigned long opcode; | |
53 | struct nlist * nlistp; | |
54 | expressionS exp; | |
55 | int pcrel; | |
56 | int reloc_offset; /* Offset of reloc within insn. */ | |
57 | int reloc; | |
58 | } | |
3b16e843 NC |
59 | the_insn; |
60 | ||
3b16e843 | 61 | const pseudo_typeS md_pseudo_table[] = |
ea1562b3 NC |
62 | { |
63 | {"align", s_align_bytes, 4 }, | |
64 | {"space", s_space, 0 }, | |
65 | {"cputype", s_ignore, 0 }, | |
66 | {"reg", s_lsym, 0 }, /* Register equate, same as equ. */ | |
67 | {"sect", s_ignore, 0 }, /* Creation of coff sections. */ | |
68 | {"proc", s_ignore, 0 }, /* Start of a function. */ | |
69 | {"endproc", s_ignore, 0 }, /* Function end. */ | |
70 | {"word", cons, 4 }, | |
71 | {NULL, 0, 0 }, | |
72 | }; | |
3b16e843 NC |
73 | |
74 | int md_short_jump_size = 4; | |
75 | int md_long_jump_size = 4; | |
76 | ||
77 | #if defined(BFD_HEADERS) | |
78 | #ifdef RELSZ | |
79 | const int md_reloc_size = RELSZ; /* Coff headers. */ | |
80 | #else | |
81 | const int md_reloc_size = 12; /* Something else headers. */ | |
82 | #endif | |
83 | #else | |
84 | const int md_reloc_size = 12; /* Not bfdized. */ | |
85 | #endif | |
86 | ||
87 | /* This array holds the chars that always start a comment. | |
88 | If the pre-processor is disabled, these aren't very useful. */ | |
89 | const char comment_chars[] = "#"; | |
90 | ||
91 | /* This array holds the chars that only start a comment at the beginning of | |
92 | a line. If the line seems to have the form '# 123 filename' | |
93 | .line and .file directives will appear in the pre-processed output. */ | |
94 | /* Note that input_file.c hand checks for '#' at the beginning of the | |
95 | first line of the input file. This is because the compiler outputs | |
96 | #NO_APP at the beginning of its output. */ | |
97 | /* Also note that comments like this one will always work. */ | |
98 | const char line_comment_chars[] = "#"; | |
99 | ||
100 | /* We needed an unused char for line separation to work around the | |
101 | lack of macros, using sed and such. */ | |
102 | const char line_separator_chars[] = ";"; | |
103 | ||
104 | /* Chars that can be used to separate mant from exp in floating point nums. */ | |
105 | const char EXP_CHARS[] = "eE"; | |
106 | ||
107 | /* Chars that mean this number is a floating point constant. | |
108 | As in 0f12.456 | |
109 | or 0d1.2345e12. */ | |
110 | const char FLT_CHARS[] = "rRsSfFdDxXpP"; | |
111 | ||
112 | /* "l.jalr r9" precalculated opcode. */ | |
113 | static unsigned long jalr_r9_opcode; | |
114 | ||
ea1562b3 | 115 | static void machine_ip (char *); |
3b16e843 | 116 | |
3b16e843 NC |
117 | |
118 | /* Set bits in machine opcode according to insn->encoding | |
5d6255fe | 119 | description and passed operand. */ |
3b16e843 | 120 | |
5d6255fe | 121 | static void |
ea1562b3 NC |
122 | encode (const struct machine_opcode *insn, |
123 | unsigned long *opcode, | |
124 | signed long param_val, | |
125 | char param_ch) | |
3b16e843 NC |
126 | { |
127 | int opc_pos = 0; | |
128 | int param_pos = 0; | |
129 | char *enc; | |
130 | ||
131 | #if DEBUG | |
132 | printf (" encode: opcode=%.8lx param_val=%.8lx abs=%.8lx param_ch=%c\n", | |
133 | *opcode, param_val, abs (param_val), param_ch); | |
134 | #endif | |
135 | for (enc = insn->encoding; *enc != '\0'; enc++) | |
136 | if (*enc == param_ch) | |
137 | { | |
138 | if (enc - 2 >= insn->encoding && (*(enc - 2) == '0') && (*(enc - 1) == 'x')) | |
139 | continue; | |
140 | else | |
141 | param_pos ++; | |
142 | } | |
143 | ||
144 | opc_pos = 32; | |
145 | ||
146 | for (enc = insn->encoding; *enc != '\0';) | |
147 | { | |
5d6255fe | 148 | if ((*enc == '0') && (*(enc + 1) == 'x')) |
3b16e843 NC |
149 | { |
150 | int tmp = strtol (enc, NULL, 16); | |
151 | ||
152 | opc_pos -= 4; | |
153 | *opcode |= tmp << opc_pos; | |
154 | enc += 3; | |
155 | } | |
5d6255fe | 156 | else if ((*enc == '0') || (*enc == '-')) |
3b16e843 NC |
157 | { |
158 | opc_pos--; | |
159 | enc++; | |
160 | } | |
5d6255fe | 161 | else if (*enc == '1') |
3b16e843 NC |
162 | { |
163 | opc_pos--; | |
164 | *opcode |= 1 << opc_pos; | |
165 | enc++; | |
166 | } | |
5d6255fe | 167 | else if (*enc == param_ch) |
3b16e843 NC |
168 | { |
169 | opc_pos--; | |
170 | param_pos--; | |
171 | *opcode |= ((param_val >> param_pos) & 0x1) << opc_pos; | |
172 | enc++; | |
173 | } | |
5d6255fe | 174 | else if (ISALPHA (*enc)) |
3b16e843 NC |
175 | { |
176 | opc_pos--; | |
177 | enc++; | |
178 | } | |
179 | else | |
180 | enc++; | |
181 | } | |
5d6255fe | 182 | |
3b16e843 NC |
183 | #if DEBUG |
184 | printf (" opcode=%.8lx\n", *opcode); | |
185 | #endif | |
186 | } | |
187 | ||
188 | /* This function is called once, at assembler startup time. It should | |
189 | set up all the tables, etc., that the MD part of the assembler will | |
190 | need. */ | |
191 | ||
192 | void | |
ea1562b3 | 193 | md_begin (void) |
3b16e843 NC |
194 | { |
195 | const char *retval = NULL; | |
196 | int lose = 0; | |
197 | int skipnext = 0; | |
198 | unsigned int i; | |
199 | ||
200 | /* Hash up all the opcodes for fast use later. */ | |
201 | op_hash = hash_new (); | |
202 | ||
203 | for (i = 0; i < or32_num_opcodes; i++) | |
204 | { | |
205 | const char *name = machine_opcodes[i].name; | |
206 | ||
207 | if (skipnext) | |
208 | { | |
209 | skipnext = 0; | |
210 | continue; | |
211 | } | |
212 | ||
ea1562b3 | 213 | retval = hash_insert (op_hash, name, (void *) &machine_opcodes[i]); |
3b16e843 NC |
214 | if (retval != NULL) |
215 | { | |
216 | fprintf (stderr, "internal error: can't hash `%s': %s\n", | |
217 | machine_opcodes[i].name, retval); | |
218 | lose = 1; | |
219 | } | |
220 | } | |
221 | ||
222 | if (lose) | |
223 | as_fatal (_("Broken assembler. No assembly attempted.")); | |
224 | ||
225 | encode (&machine_opcodes[insn_index ("l.jalr")], &jalr_r9_opcode, 9, 'B'); | |
226 | } | |
227 | ||
67c1ffbe | 228 | /* Returns non zero if instruction is to be used. */ |
3b16e843 NC |
229 | |
230 | static int | |
ea1562b3 | 231 | check_invalid_opcode (unsigned long opcode) |
3b16e843 NC |
232 | { |
233 | return opcode == jalr_r9_opcode; | |
234 | } | |
235 | ||
236 | /* Assemble a single instruction. Its label has already been handled | |
237 | by the generic front end. We just parse opcode and operands, and | |
238 | produce the bytes of data and relocation. */ | |
239 | ||
240 | void | |
ea1562b3 | 241 | md_assemble (char *str) |
3b16e843 NC |
242 | { |
243 | char *toP; | |
244 | ||
245 | #if DEBUG | |
246 | printf ("NEW INSTRUCTION\n"); | |
247 | #endif | |
248 | ||
249 | know (str); | |
250 | machine_ip (str); | |
251 | toP = frag_more (4); | |
252 | ||
253 | /* Put out the opcode. */ | |
254 | md_number_to_chars (toP, the_insn.opcode, 4); | |
255 | ||
256 | /* Put out the symbol-dependent stuff. */ | |
257 | #ifdef BFD_ASSEMBLER | |
258 | if (the_insn.reloc != BFD_RELOC_NONE) | |
259 | #else | |
260 | if (the_insn.reloc != NO_RELOC) | |
261 | #endif | |
262 | { | |
263 | fix_new_exp (frag_now, | |
264 | (toP - frag_now->fr_literal + the_insn.reloc_offset), | |
265 | 4, /* size */ | |
266 | &the_insn.exp, | |
267 | the_insn.pcrel, | |
268 | the_insn.reloc); | |
269 | } | |
270 | } | |
271 | ||
272 | /* This is true of the we have issued a "lo(" or "hi"(. */ | |
273 | static int waiting_for_shift = 0; | |
274 | ||
275 | static int mask_or_shift = 0; | |
276 | ||
277 | #ifdef BFD_ASSEMBLER | |
278 | static char * | |
ea1562b3 | 279 | parse_operand (char *s, expressionS *operandp, int opt) |
3b16e843 NC |
280 | { |
281 | char *save = input_line_pointer; | |
282 | char *new; | |
283 | ||
284 | #if DEBUG | |
285 | printf (" PROCESS NEW OPERAND(%s) == %c (%d)\n", s, opt ? opt : '!', opt); | |
286 | #endif | |
287 | ||
288 | input_line_pointer = s; | |
289 | ||
290 | if (strncasecmp (s, "HI(", 3) == 0) | |
291 | { | |
292 | waiting_for_shift = 1; | |
293 | mask_or_shift = BFD_RELOC_HI16; | |
294 | ||
295 | input_line_pointer += 3; | |
296 | } | |
297 | else if (strncasecmp (s, "LO(", 3) == 0) | |
298 | { | |
299 | mask_or_shift = BFD_RELOC_LO16; | |
300 | ||
301 | input_line_pointer += 3; | |
302 | } | |
303 | else | |
304 | mask_or_shift = 0; | |
305 | ||
306 | if ((*s == '(') && (*(s+1) == 'r')) | |
307 | s++; | |
308 | ||
5d6255fe | 309 | if ((*s == 'r') && ISDIGIT (*(s + 1))) |
3b16e843 NC |
310 | { |
311 | operandp->X_add_number = strtol (s + 1, NULL, 10); | |
312 | operandp->X_op = O_register; | |
313 | for (; (*s != ',') && (*s != '\0');) | |
5d6255fe | 314 | s++; |
3b16e843 | 315 | input_line_pointer = save; |
5d6255fe | 316 | return s; |
3b16e843 NC |
317 | } |
318 | ||
319 | expression (operandp); | |
320 | ||
321 | if (operandp->X_op == O_absent) | |
322 | { | |
323 | if (! opt) | |
324 | as_bad (_("missing operand")); | |
325 | else | |
326 | { | |
327 | operandp->X_add_number = 0; | |
328 | operandp->X_op = O_constant; | |
329 | } | |
330 | } | |
5d6255fe | 331 | |
3b16e843 NC |
332 | new = input_line_pointer; |
333 | input_line_pointer = save; | |
5d6255fe | 334 | |
3b16e843 NC |
335 | #if DEBUG |
336 | printf (" %s=parse_operand(%s): operandp->X_op = %u\n", new, s, operandp->X_op); | |
337 | #endif | |
338 | ||
339 | return new; | |
340 | } | |
341 | #else | |
342 | ||
717acf4b | 343 | static char * |
ea1562b3 | 344 | parse_operand (char *s, expressionS *operandp, int opt) |
3b16e843 NC |
345 | { |
346 | char *save = input_line_pointer; | |
347 | char *new; | |
348 | ||
349 | #if DEBUG | |
350 | printf (" PROCESS NEW OPERAND(%s) == %c (%d)\n", s, opt ? opt : '!', opt); | |
351 | #endif | |
352 | ||
353 | input_line_pointer = s; | |
354 | ||
355 | if (strncasecmp (s, "HI(", 3) == 0) | |
356 | { | |
357 | waiting_for_shift = 1; | |
358 | mask_or_shift = RELOC_CONSTH; | |
359 | ||
360 | input_line_pointer += 3; | |
361 | } | |
362 | else if (strncasecmp (s, "LO(", 3) == 0) | |
363 | { | |
364 | mask_or_shift = RELOC_CONST; | |
365 | ||
366 | input_line_pointer += 3; | |
367 | } | |
368 | else | |
369 | mask_or_shift = 0; | |
370 | ||
3b16e843 NC |
371 | expression (operandp); |
372 | ||
373 | if (operandp->X_op == O_absent) | |
374 | { | |
375 | if (! opt) | |
376 | as_bad (_("missing operand")); | |
377 | else | |
378 | { | |
379 | operandp->X_add_number = 0; | |
380 | operandp->X_op = O_constant; | |
381 | } | |
382 | } | |
5d6255fe | 383 | |
3b16e843 NC |
384 | new = input_line_pointer; |
385 | input_line_pointer = save; | |
5d6255fe KH |
386 | |
387 | if ((operandp->X_op == O_symbol) && (*s != '_')) | |
3b16e843 NC |
388 | { |
389 | #if DEBUG | |
390 | printf ("symbol: '%s'\n", save); | |
391 | #endif | |
392 | ||
393 | for (save = s; s < new; s++) | |
394 | if ((*s == REGISTER_PREFIX) && (*(s + 1) == 'r')) /* Register prefix. */ | |
395 | s++; | |
396 | ||
5d6255fe | 397 | if ((*s == 'r') && ISDIGIT (*(s + 1))) |
3b16e843 NC |
398 | { |
399 | operandp->X_add_number = strtol (s + 1, NULL, 10); | |
400 | operandp->X_op = O_register; | |
401 | } | |
402 | s = save; | |
403 | } | |
404 | ||
405 | #if DEBUG | |
406 | printf (" %s=parse_operand(%s): operandp->X_op = %u\n", new, s, operandp->X_op); | |
407 | #endif | |
408 | ||
409 | return new; | |
410 | } | |
411 | #endif | |
412 | ||
413 | /* Instruction parsing. Takes a string containing the opcode. | |
414 | Operands are at input_line_pointer. Output is in the_insn. | |
415 | Warnings or errors are generated. */ | |
416 | ||
417 | #ifdef BFD_ASSEMBLER | |
418 | static void | |
ea1562b3 | 419 | machine_ip (char *str) |
3b16e843 NC |
420 | { |
421 | char *s; | |
422 | const char *args; | |
423 | const struct machine_opcode *insn; | |
424 | char *argsStart; | |
425 | unsigned long opcode; | |
426 | expressionS the_operand; | |
427 | expressionS *operand = &the_operand; | |
428 | unsigned int regno; | |
429 | int reloc = BFD_RELOC_NONE; | |
430 | ||
431 | #if DEBUG | |
432 | printf ("machine_ip(%s)\n", str); | |
433 | #endif | |
434 | ||
435 | s = str; | |
436 | for (; ISALNUM (*s) || *s == '.'; ++s) | |
437 | if (ISUPPER (*s)) | |
438 | *s = TOLOWER (*s); | |
439 | ||
440 | switch (*s) | |
441 | { | |
442 | case '\0': | |
443 | break; | |
444 | ||
445 | case ' ': /* FIXME-SOMEDAY more whitespace. */ | |
446 | *s++ = '\0'; | |
447 | break; | |
448 | ||
449 | default: | |
450 | as_bad (_("unknown opcode1: `%s'"), str); | |
451 | return; | |
452 | } | |
453 | ||
454 | if ((insn = (struct machine_opcode *) hash_find (op_hash, str)) == NULL) | |
455 | { | |
456 | as_bad (_("unknown opcode2 `%s'."), str); | |
457 | return; | |
458 | } | |
459 | ||
460 | argsStart = s; | |
461 | opcode = 0; | |
462 | memset (&the_insn, '\0', sizeof (the_insn)); | |
463 | the_insn.reloc = BFD_RELOC_NONE; | |
464 | ||
465 | reloc = BFD_RELOC_NONE; | |
466 | ||
467 | /* Build the opcode, checking as we go to make sure that the | |
468 | operands match. | |
5d6255fe | 469 | |
3b16e843 NC |
470 | If an operand matches, we modify the_insn or opcode appropriately, |
471 | and do a "continue". If an operand fails to match, we "break". */ | |
472 | if (insn->args[0] != '\0') | |
ea1562b3 NC |
473 | /* Prime the pump. */ |
474 | s = parse_operand (s, operand, insn->args[0] == 'I'); | |
3b16e843 NC |
475 | |
476 | for (args = insn->args;; ++args) | |
477 | { | |
478 | #if DEBUG | |
479 | printf (" args = %s\n", args); | |
480 | #endif | |
481 | switch (*args) | |
482 | { | |
483 | case '\0': /* End of args. */ | |
484 | /* We have have 0 args, do the bazoooka! */ | |
485 | if (args == insn->args) | |
486 | encode (insn, &opcode, 0, 0); | |
487 | ||
488 | if (*s == '\0') | |
489 | { | |
490 | /* We are truly done. */ | |
491 | the_insn.opcode = opcode; | |
492 | if (check_invalid_opcode (opcode)) | |
5d6255fe | 493 | as_bad (_("instruction not allowed: %s"), str); |
3b16e843 NC |
494 | return; |
495 | } | |
496 | as_bad (_("too many operands: %s"), s); | |
497 | break; | |
498 | ||
499 | case ',': /* Must match a comma. */ | |
500 | if (*s++ == ',') | |
501 | { | |
502 | reloc = BFD_RELOC_NONE; | |
503 | ||
504 | /* Parse next operand. */ | |
505 | s = parse_operand (s, operand, args[1] == 'I'); | |
506 | #if DEBUG | |
507 | printf (" ',' case: operand->X_add_number = %d, *args = %s, *s = %s\n", | |
508 | operand->X_add_number, args, s); | |
5d6255fe | 509 | #endif |
3b16e843 NC |
510 | continue; |
511 | } | |
512 | break; | |
513 | ||
514 | case '(': /* Must match a (. */ | |
515 | s = parse_operand (s, operand, args[1] == 'I'); | |
516 | continue; | |
5d6255fe | 517 | |
3b16e843 NC |
518 | case ')': /* Must match a ). */ |
519 | continue; | |
520 | ||
521 | case 'r': /* A general register. */ | |
522 | args++; | |
523 | ||
524 | if (operand->X_op != O_register) | |
525 | break; /* Only registers. */ | |
5d6255fe | 526 | |
3b16e843 NC |
527 | know (operand->X_add_symbol == 0); |
528 | know (operand->X_op_symbol == 0); | |
529 | regno = operand->X_add_number; | |
530 | encode (insn, &opcode, regno, *args); | |
531 | #if DEBUG | |
532 | printf (" r: operand->X_op = %d\n", operand->X_op); | |
533 | #endif | |
534 | continue; | |
535 | ||
536 | default: | |
537 | /* if (! ISALPHA (*args)) | |
538 | break; */ /* Only immediate values. */ | |
5d6255fe | 539 | |
3b16e843 NC |
540 | if (mask_or_shift) |
541 | { | |
542 | #if DEBUG | |
543 | printf ("mask_or_shift = %d\n", mask_or_shift); | |
544 | #endif | |
545 | reloc = mask_or_shift; | |
546 | } | |
547 | mask_or_shift = 0; | |
5d6255fe KH |
548 | |
549 | if (strncasecmp (args, "LO(", 3) == 0) | |
3b16e843 NC |
550 | { |
551 | #if DEBUG | |
552 | printf ("reloc_const\n"); | |
553 | #endif | |
554 | reloc = BFD_RELOC_LO16; | |
555 | } | |
5d6255fe | 556 | else if (strncasecmp (args, "HI(", 3) == 0) |
3b16e843 NC |
557 | { |
558 | #if DEBUG | |
559 | printf ("reloc_consth\n"); | |
560 | #endif | |
561 | reloc = BFD_RELOC_HI16; | |
562 | } | |
5d6255fe KH |
563 | |
564 | if (*s == '(') | |
ea1562b3 | 565 | operand->X_op = O_constant; |
3b16e843 NC |
566 | else if (*s == ')') |
567 | s += 1; | |
568 | #if DEBUG | |
569 | printf (" default case: operand->X_add_number = %d, *args = %s, *s = %s\n", operand->X_add_number, args, s); | |
570 | #endif | |
571 | if (operand->X_op == O_constant) | |
572 | { | |
573 | if (reloc == BFD_RELOC_NONE) | |
574 | { | |
575 | bfd_vma v, mask; | |
576 | ||
577 | mask = 0x3ffffff; | |
578 | v = abs (operand->X_add_number) & ~ mask; | |
579 | if (v) | |
580 | as_bad (_("call/jmp target out of range (1)")); | |
581 | } | |
582 | ||
583 | if (reloc == BFD_RELOC_HI16) | |
584 | operand->X_add_number = ((operand->X_add_number >> 16) & 0xffff); | |
585 | ||
586 | the_insn.pcrel = 0; | |
587 | encode (insn, &opcode, operand->X_add_number, *args); | |
588 | /* the_insn.reloc = BFD_RELOC_NONE; */ | |
5d6255fe | 589 | continue; |
3b16e843 NC |
590 | } |
591 | ||
592 | if (reloc == BFD_RELOC_NONE) | |
593 | the_insn.reloc = BFD_RELOC_32_GOT_PCREL; | |
594 | else | |
595 | the_insn.reloc = reloc; | |
596 | ||
597 | /* the_insn.reloc = insn->reloc; */ | |
598 | #if DEBUG | |
599 | printf (" reloc sym=%d\n", the_insn.reloc); | |
600 | printf (" BFD_RELOC_NONE=%d\n", BFD_RELOC_NONE); | |
601 | #endif | |
602 | the_insn.exp = *operand; | |
5d6255fe | 603 | |
3b16e843 NC |
604 | /* the_insn.reloc_offset = 1; */ |
605 | the_insn.pcrel = 1; /* Assume PC-relative jump. */ | |
606 | ||
607 | /* FIXME-SOON, Do we figure out whether abs later, after | |
608 | know sym val? */ | |
609 | if (reloc == BFD_RELOC_LO16 || reloc == BFD_RELOC_HI16) | |
610 | the_insn.pcrel = 0; | |
611 | ||
612 | encode (insn, &opcode, operand->X_add_number, *args); | |
613 | continue; | |
614 | } | |
5d6255fe | 615 | |
3b16e843 NC |
616 | /* Types or values of args don't match. */ |
617 | as_bad (_("invalid operands")); | |
618 | return; | |
619 | } | |
620 | } | |
621 | ||
622 | #else | |
623 | ||
624 | static void | |
ea1562b3 | 625 | machine_ip (char *str) |
3b16e843 NC |
626 | { |
627 | char *s; | |
628 | const char *args; | |
629 | const struct machine_opcode *insn; | |
630 | char *argsStart; | |
631 | unsigned long opcode; | |
632 | expressionS the_operand; | |
633 | expressionS *operand = &the_operand; | |
634 | unsigned int regno; | |
635 | int reloc = NO_RELOC; | |
636 | ||
637 | #if DEBUG | |
638 | printf ("machine_ip(%s)\n", str); | |
639 | #endif | |
640 | ||
641 | s = str; | |
642 | for (; ISALNUM (*s) || *s == '.'; ++s) | |
643 | if (ISUPPER (*s)) | |
644 | *s = TOLOWER (*s); | |
645 | ||
646 | switch (*s) | |
647 | { | |
648 | case '\0': | |
649 | break; | |
650 | ||
651 | case ' ': /* FIXME-SOMEDAY more whitespace. */ | |
652 | *s++ = '\0'; | |
653 | break; | |
654 | ||
655 | default: | |
656 | as_bad (_("unknown opcode1: `%s'"), str); | |
657 | return; | |
658 | } | |
659 | ||
660 | if ((insn = (struct machine_opcode *) hash_find (op_hash, str)) == NULL) | |
661 | { | |
662 | as_bad (_("unknown opcode2 `%s'."), str); | |
663 | return; | |
664 | } | |
665 | ||
666 | argsStart = s; | |
667 | opcode = 0; | |
668 | memset (&the_insn, '\0', sizeof (the_insn)); | |
669 | the_insn.reloc = NO_RELOC; | |
670 | ||
671 | reloc = NO_RELOC; | |
672 | ||
673 | /* Build the opcode, checking as we go to make sure that the | |
674 | operands match. | |
5d6255fe | 675 | |
3b16e843 NC |
676 | If an operand matches, we modify the_insn or opcode appropriately, |
677 | and do a "continue". If an operand fails to match, we "break". */ | |
678 | if (insn->args[0] != '\0') | |
5d6255fe | 679 | /* Prime the pump. */ |
3b16e843 NC |
680 | s = parse_operand (s, operand, |
681 | insn->args[0] == 'I' | |
682 | || strcmp (insn->name, "l.nop") == 0); | |
683 | ||
684 | for (args = insn->args;; ++args) | |
685 | { | |
686 | #if DEBUG | |
687 | printf (" args = %s\n", args); | |
688 | #endif | |
689 | switch (*args) | |
690 | { | |
691 | case '\0': /* End of args. */ | |
692 | /* We have have 0 args, do the bazoooka! */ | |
693 | if (args == insn->args) | |
694 | encode (insn, &opcode, 0, 0); | |
695 | ||
696 | if (*s == '\0') | |
697 | { | |
698 | /* We are truly done. */ | |
699 | the_insn.opcode = opcode; | |
700 | if (check_invalid_opcode (opcode)) | |
5d6255fe | 701 | as_bad (_("instruction not allowed: %s"), str); |
3b16e843 NC |
702 | return; |
703 | } | |
704 | as_bad (_("too many operands: %s"), s); | |
705 | break; | |
706 | ||
707 | case ',': /* Must match a comma. */ | |
708 | if (*s++ == ',') | |
709 | { | |
710 | reloc = NO_RELOC; | |
711 | ||
712 | /* Parse next operand. */ | |
713 | s = parse_operand (s, operand, args[1] == 'I'); | |
714 | #if DEBUG | |
715 | printf (" ',' case: operand->X_add_number = %d, *args = %s, *s = %s\n", | |
716 | operand->X_add_number, args, s); | |
5d6255fe | 717 | #endif |
3b16e843 NC |
718 | continue; |
719 | } | |
720 | break; | |
721 | ||
722 | case '(': /* Must match a (. */ | |
723 | s = parse_operand (s, operand, args[1] == 'I'); | |
724 | continue; | |
5d6255fe | 725 | |
3b16e843 NC |
726 | case ')': /* Must match a ). */ |
727 | continue; | |
728 | ||
729 | case 'r': /* A general register. */ | |
730 | args++; | |
731 | ||
732 | if (operand->X_op != O_register) | |
733 | break; /* Only registers. */ | |
5d6255fe | 734 | |
3b16e843 NC |
735 | know (operand->X_add_symbol == 0); |
736 | know (operand->X_op_symbol == 0); | |
737 | regno = operand->X_add_number; | |
738 | encode (insn, &opcode, regno, *args); | |
739 | #if DEBUG | |
740 | printf (" r: operand->X_op = %d\n", operand->X_op); | |
741 | #endif | |
742 | continue; | |
743 | ||
744 | default: | |
745 | /* if (! ISALPHA (*args)) | |
746 | break; */ /* Only immediate values. */ | |
5d6255fe | 747 | |
3b16e843 NC |
748 | if (mask_or_shift) |
749 | { | |
750 | #if DEBUG | |
751 | printf ("mask_or_shift = %d\n", mask_or_shift); | |
752 | #endif | |
753 | reloc = mask_or_shift; | |
754 | } | |
755 | mask_or_shift = 0; | |
5d6255fe KH |
756 | |
757 | if (strncasecmp (args, "LO(", 3) == 0) | |
3b16e843 NC |
758 | { |
759 | #if DEBUG | |
760 | printf ("reloc_const\n"); | |
761 | #endif | |
762 | reloc = RELOC_CONST; | |
763 | } | |
5d6255fe | 764 | else if (strncasecmp (args, "HI(", 3) == 0) |
3b16e843 NC |
765 | { |
766 | #if DEBUG | |
767 | printf ("reloc_consth\n"); | |
768 | #endif | |
769 | reloc = RELOC_CONSTH; | |
770 | } | |
5d6255fe KH |
771 | |
772 | if (*s == '(') | |
ea1562b3 | 773 | operand->X_op = O_constant; |
3b16e843 NC |
774 | else if (*s == ')') |
775 | s += 1; | |
776 | #if DEBUG | |
777 | printf (" default case: operand->X_add_number = %d, *args = %s, *s = %s\n", | |
778 | operand->X_add_number, args, s); | |
779 | #endif | |
780 | if (operand->X_op == O_constant) | |
781 | { | |
782 | if (reloc == NO_RELOC) | |
783 | { | |
784 | unsigned long v, mask; | |
785 | ||
786 | mask = 0x3ffffff; | |
787 | v = abs (operand->X_add_number) & ~ mask; | |
788 | if (v) | |
789 | as_bad (_("call/jmp target out of range (1)")); | |
790 | } | |
791 | ||
792 | if (reloc == RELOC_CONSTH) | |
793 | operand->X_add_number = ((operand->X_add_number>>16) & 0xffff); | |
794 | ||
795 | the_insn.pcrel = 0; | |
796 | encode (insn, &opcode, operand->X_add_number, *args); | |
797 | /* the_insn.reloc = NO_RELOC; */ | |
5d6255fe | 798 | continue; |
3b16e843 NC |
799 | } |
800 | ||
801 | if (reloc == NO_RELOC) | |
802 | the_insn.reloc = RELOC_JUMPTARG; | |
803 | else | |
804 | the_insn.reloc = reloc; | |
805 | #if DEBUG | |
806 | printf (" reloc sym=%d\n", the_insn.reloc); | |
807 | printf (" NO_RELOC=%d\n", NO_RELOC); | |
808 | #endif | |
809 | the_insn.exp = *operand; | |
5d6255fe | 810 | |
3b16e843 NC |
811 | /* the_insn.reloc_offset = 1; */ |
812 | the_insn.pcrel = 1; /* Assume PC-relative jump. */ | |
813 | ||
814 | /* FIXME-SOON, Do we figure out whether abs later, after | |
815 | know sym val? */ | |
816 | if (reloc == RELOC_CONST || reloc == RELOC_CONSTH) | |
817 | the_insn.pcrel = 0; | |
818 | ||
819 | encode (insn, &opcode, operand->X_add_number, *args); | |
820 | continue; | |
821 | } | |
5d6255fe | 822 | |
3b16e843 NC |
823 | /* Types or values of args don't match. */ |
824 | as_bad (_("invalid operands")); | |
825 | return; | |
826 | } | |
827 | } | |
828 | #endif | |
829 | ||
830 | /* This is identical to the md_atof in m68k.c. I think this is right, | |
831 | but I'm not sure. | |
832 | ||
833 | Turn a string in input_line_pointer into a floating point constant | |
834 | of type type, and store the appropriate bytes in *litP. The number | |
835 | of LITTLENUMS emitted is stored in *sizeP . An error message is | |
836 | returned, or NULL on OK. */ | |
837 | ||
838 | /* Equal to MAX_PRECISION in atof-ieee.c. */ | |
839 | #define MAX_LITTLENUMS 6 | |
840 | ||
841 | char * | |
ea1562b3 | 842 | md_atof (int type, char * litP, int * sizeP) |
3b16e843 NC |
843 | { |
844 | int prec; | |
845 | LITTLENUM_TYPE words[MAX_LITTLENUMS]; | |
846 | LITTLENUM_TYPE *wordP; | |
847 | char *t; | |
848 | ||
849 | switch (type) | |
850 | { | |
851 | case 'f': | |
852 | case 'F': | |
853 | case 's': | |
854 | case 'S': | |
855 | prec = 2; | |
856 | break; | |
857 | ||
858 | case 'd': | |
859 | case 'D': | |
860 | case 'r': | |
861 | case 'R': | |
862 | prec = 4; | |
863 | break; | |
864 | ||
865 | case 'x': | |
866 | case 'X': | |
867 | prec = 6; | |
868 | break; | |
869 | ||
870 | case 'p': | |
871 | case 'P': | |
872 | prec = 6; | |
873 | break; | |
874 | ||
875 | default: | |
876 | *sizeP = 0; | |
877 | return _("Bad call to MD_ATOF()"); | |
878 | } | |
879 | ||
880 | t = atof_ieee (input_line_pointer, type, words); | |
881 | if (t) | |
882 | input_line_pointer = t; | |
883 | ||
884 | *sizeP = prec * sizeof (LITTLENUM_TYPE); | |
885 | ||
886 | for (wordP = words; prec--;) | |
887 | { | |
888 | md_number_to_chars (litP, (valueT) (*wordP++), sizeof (LITTLENUM_TYPE)); | |
889 | litP += sizeof (LITTLENUM_TYPE); | |
890 | } | |
891 | ||
892 | return NULL; | |
893 | } | |
894 | ||
895 | /* Write out big-endian. */ | |
896 | ||
897 | void | |
ea1562b3 | 898 | md_number_to_chars (char *buf, valueT val, int n) |
3b16e843 NC |
899 | { |
900 | number_to_chars_bigendian (buf, val, n); | |
901 | } | |
902 | ||
903 | #ifdef BFD_ASSEMBLER | |
904 | void | |
ea1562b3 | 905 | md_apply_fix3 (fixS * fixP, valueT * val, segT seg ATTRIBUTE_UNUSED) |
3b16e843 NC |
906 | { |
907 | char *buf = fixP->fx_where + fixP->fx_frag->fr_literal; | |
908 | long t_val; | |
909 | ||
910 | t_val = (long) *val; | |
911 | ||
912 | #if DEBUG | |
913 | printf ("md_apply_fix val:%x\n", t_val); | |
914 | #endif | |
915 | ||
916 | fixP->fx_addnumber = t_val; /* Remember value for emit_reloc. */ | |
917 | ||
918 | know (fixP->fx_size == 4); | |
919 | know (fixP->fx_r_type < BFD_RELOC_NONE); | |
920 | ||
921 | switch (fixP->fx_r_type) | |
922 | { | |
923 | case BFD_RELOC_32: /* XXXXXXXX pattern in a word. */ | |
924 | #if DEBUG | |
925 | printf ("reloc_const: val=%x\n", t_val); | |
926 | #endif | |
927 | buf[0] = t_val >> 24; | |
928 | buf[1] = t_val >> 16; | |
929 | buf[2] = t_val >> 8; | |
930 | buf[3] = t_val; | |
931 | break; | |
932 | ||
933 | case BFD_RELOC_16: /* XXXX0000 pattern in a word. */ | |
934 | #if DEBUG | |
935 | printf ("reloc_const: val=%x\n", t_val); | |
936 | #endif | |
937 | buf[0] = t_val >> 8; | |
938 | buf[1] = t_val; | |
939 | break; | |
940 | ||
941 | case BFD_RELOC_8: /* XX000000 pattern in a word. */ | |
942 | #if DEBUG | |
943 | printf ("reloc_const: val=%x\n", t_val); | |
944 | #endif | |
945 | buf[0] = t_val; | |
946 | break; | |
947 | ||
948 | case BFD_RELOC_LO16: /* 0000XXXX pattern in a word. */ | |
949 | #if DEBUG | |
950 | printf ("reloc_const: val=%x\n", t_val); | |
951 | #endif | |
952 | buf[2] = t_val >> 8; /* Holds bits 0000XXXX. */ | |
953 | buf[3] = t_val; | |
954 | break; | |
955 | ||
956 | case BFD_RELOC_HI16: /* 0000XXXX pattern in a word. */ | |
957 | #if DEBUG | |
958 | printf ("reloc_consth: val=%x\n", t_val); | |
959 | #endif | |
960 | buf[2] = t_val >> 24; /* Holds bits XXXX0000. */ | |
961 | buf[3] = t_val >> 16; | |
962 | break; | |
963 | ||
964 | case BFD_RELOC_32_GOT_PCREL: /* 0000XXXX pattern in a word. */ | |
965 | if (!fixP->fx_done) | |
65ec77d2 | 966 | ; |
3b16e843 NC |
967 | else if (fixP->fx_pcrel) |
968 | { | |
969 | long v = t_val >> 28; | |
970 | ||
971 | if (v != 0 && v != -1) | |
972 | as_bad_where (fixP->fx_file, fixP->fx_line, | |
973 | _("call/jmp target out of range (2)")); | |
974 | } | |
975 | else | |
976 | /* This case was supposed to be handled in machine_ip. */ | |
977 | abort (); | |
978 | ||
979 | buf[0] |= (t_val >> 26) & 0x03; /* Holds bits 0FFFFFFC of address. */ | |
980 | buf[1] = t_val >> 18; | |
981 | buf[2] = t_val >> 10; | |
982 | buf[3] = t_val >> 2; | |
983 | break; | |
984 | ||
985 | case BFD_RELOC_VTABLE_INHERIT: | |
986 | case BFD_RELOC_VTABLE_ENTRY: | |
987 | fixP->fx_done = 0; | |
988 | break; | |
989 | ||
990 | case BFD_RELOC_NONE: | |
991 | default: | |
992 | as_bad (_("bad relocation type: 0x%02x"), fixP->fx_r_type); | |
993 | break; | |
994 | } | |
995 | ||
996 | if (fixP->fx_addsy == (symbolS *) NULL) | |
997 | fixP->fx_done = 1; | |
998 | } | |
999 | #else | |
1000 | void | |
ea1562b3 | 1001 | md_apply_fix3 (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED) |
3b16e843 | 1002 | { |
a161fe53 | 1003 | long val = *valP; |
3b16e843 NC |
1004 | char *buf = fixP->fx_where + fixP->fx_frag->fr_literal; |
1005 | ||
1006 | #if DEBUG | |
1007 | printf ("md_apply_fix val:%x\n", val); | |
1008 | #endif | |
1009 | ||
1010 | fixP->fx_addnumber = val; /* Remember value for emit_reloc. */ | |
1011 | ||
1012 | know (fixP->fx_size == 4); | |
1013 | know (fixP->fx_r_type < NO_RELOC); | |
1014 | ||
1015 | /* This is a hack. There should be a better way to handle this. */ | |
1016 | if (fixP->fx_r_type == RELOC_WDISP30 && fixP->fx_addsy) | |
1017 | val += fixP->fx_where + fixP->fx_frag->fr_address; | |
1018 | ||
1019 | switch (fixP->fx_r_type) | |
1020 | { | |
1021 | case RELOC_32: | |
1022 | buf[0] = val >> 24; | |
1023 | buf[1] = val >> 16; | |
1024 | buf[2] = val >> 8; | |
1025 | buf[3] = val; | |
1026 | break; | |
1027 | ||
1028 | case RELOC_8: | |
1029 | buf[0] = val; | |
1030 | break; | |
1031 | ||
1032 | case RELOC_WDISP30: | |
717acf4b | 1033 | val = (val >> 2) + 1; |
3b16e843 NC |
1034 | buf[0] |= (val >> 24) & 0x3f; |
1035 | buf[1] = (val >> 16); | |
1036 | buf[2] = val >> 8; | |
1037 | buf[3] = val; | |
1038 | break; | |
1039 | ||
1040 | case RELOC_HI22: | |
1041 | buf[1] |= (val >> 26) & 0x3f; | |
1042 | buf[2] = val >> 18; | |
1043 | buf[3] = val >> 10; | |
1044 | break; | |
1045 | ||
1046 | case RELOC_LO10: | |
1047 | buf[2] |= (val >> 8) & 0x03; | |
1048 | buf[3] = val; | |
1049 | break; | |
1050 | ||
1051 | case RELOC_BASE13: | |
1052 | buf[2] |= (val >> 8) & 0x1f; | |
1053 | buf[3] = val; | |
1054 | break; | |
1055 | ||
1056 | case RELOC_WDISP22: | |
717acf4b | 1057 | val = (val >> 2) + 1; |
3b16e843 NC |
1058 | /* FALLTHROUGH */ |
1059 | case RELOC_BASE22: | |
1060 | buf[1] |= (val >> 16) & 0x3f; | |
1061 | buf[2] = val >> 8; | |
1062 | buf[3] = val; | |
1063 | break; | |
1064 | ||
1065 | case RELOC_JUMPTARG: /* 0000XXXX pattern in a word. */ | |
1066 | if (!fixP->fx_done) | |
1067 | { | |
1068 | /* The linker tries to support both AMD and old GNU style | |
1069 | R_IREL relocs. That means that if the addend is exactly | |
1070 | the negative of the address within the section, the | |
1071 | linker will not handle it correctly. */ | |
3b16e843 NC |
1072 | } |
1073 | else if (fixP->fx_pcrel) | |
1074 | { | |
1075 | long v = val >> 28; | |
3b16e843 NC |
1076 | if (v != 0 && v != -1) |
1077 | as_bad_where (fixP->fx_file, fixP->fx_line, | |
1078 | _("call/jmp target out of range (2)")); | |
3b16e843 NC |
1079 | } |
1080 | else | |
1081 | /* This case was supposed to be handled in machine_ip. */ | |
1082 | abort (); | |
1083 | ||
1084 | buf[0] |= (val >> 26) & 0x03; /* Holds bits 0FFFFFFC of address. */ | |
1085 | buf[1] = val >> 18; | |
1086 | buf[2] = val >> 10; | |
1087 | buf[3] = val >> 2; | |
1088 | break; | |
1089 | ||
1090 | case RELOC_CONST: /* 0000XXXX pattern in a word. */ | |
1091 | #if DEBUG | |
1092 | printf ("reloc_const: val=%x\n", val); | |
1093 | #endif | |
1094 | buf[2] = val >> 8; /* Holds bits 0000XXXX. */ | |
1095 | buf[3] = val; | |
1096 | break; | |
1097 | ||
1098 | case RELOC_CONSTH: /* 0000XXXX pattern in a word. */ | |
1099 | #if DEBUG | |
1100 | printf ("reloc_consth: val=%x\n", val); | |
1101 | #endif | |
1102 | buf[2] = val >> 24; /* Holds bits XXXX0000. */ | |
1103 | buf[3] = val >> 16; | |
1104 | break; | |
1105 | ||
1106 | case BFD_RELOC_VTABLE_INHERIT: | |
1107 | case BFD_RELOC_VTABLE_ENTRY: | |
1108 | fixP->fx_done = 0; | |
1109 | break; | |
1110 | ||
1111 | case NO_RELOC: | |
1112 | default: | |
1113 | as_bad (_("bad relocation type: 0x%02x"), fixP->fx_r_type); | |
1114 | break; | |
1115 | } | |
1116 | ||
1117 | if (fixP->fx_addsy == (symbolS *) NULL) | |
1118 | fixP->fx_done = 1; | |
1119 | } | |
1120 | #endif | |
1121 | ||
1122 | #ifdef OBJ_COFF | |
1123 | short | |
ea1562b3 | 1124 | tc_coff_fix2rtype (fixS *fixP) |
3b16e843 NC |
1125 | { |
1126 | #if DEBUG | |
1127 | printf ("tc_coff_fix2rtype\n"); | |
1128 | #endif | |
1129 | ||
1130 | switch (fixP->fx_r_type) | |
1131 | { | |
ea1562b3 NC |
1132 | case RELOC_32: return R_WORD; |
1133 | case RELOC_8: return R_BYTE; | |
1134 | case RELOC_CONST: return R_ILOHALF; | |
1135 | case RELOC_CONSTH: return R_IHIHALF; | |
1136 | case RELOC_JUMPTARG: return R_IREL; | |
3b16e843 NC |
1137 | default: |
1138 | printf ("need %d\n", fixP->fx_r_type); | |
1139 | abort (); | |
1140 | } | |
1141 | ||
1142 | return 0; | |
1143 | } | |
1144 | ||
1145 | #endif /* OBJ_COFF */ | |
1146 | ||
1147 | /* Should never be called for or32. */ | |
1148 | ||
1149 | void | |
ea1562b3 NC |
1150 | md_create_short_jump (char * ptr ATTRIBUTE_UNUSED, |
1151 | addressT from_addr ATTRIBUTE_UNUSED, | |
1152 | addressT to_addr ATTRIBUTE_UNUSED, | |
1153 | fragS * frag ATTRIBUTE_UNUSED, | |
1154 | symbolS * to_symbol ATTRIBUTE_UNUSED) | |
3b16e843 NC |
1155 | { |
1156 | as_fatal ("or32_create_short_jmp\n"); | |
1157 | } | |
1158 | ||
1159 | /* Should never be called for or32. */ | |
1160 | ||
1161 | #ifndef BFD_ASSEMBLER | |
1162 | void | |
ea1562b3 NC |
1163 | md_convert_frag (object_headers * headers ATTRIBUTE_UNUSED, |
1164 | segT seg ATTRIBUTE_UNUSED, | |
1165 | register fragS * fragP ATTRIBUTE_UNUSED) | |
3b16e843 NC |
1166 | { |
1167 | as_fatal ("or32_convert_frag\n"); | |
1168 | } | |
1169 | ||
1170 | #else | |
1171 | void | |
ea1562b3 NC |
1172 | md_convert_frag (bfd * headers ATTRIBUTE_UNUSED, |
1173 | segT seg ATTRIBUTE_UNUSED, | |
1174 | fragS * fragP ATTRIBUTE_UNUSED) | |
3b16e843 NC |
1175 | { |
1176 | as_fatal ("or32_convert_frag\n"); | |
5d6255fe | 1177 | } |
3b16e843 NC |
1178 | #endif |
1179 | ||
1180 | /* Should never be called for or32. */ | |
1181 | ||
1182 | void | |
ea1562b3 NC |
1183 | md_create_long_jump (char * ptr ATTRIBUTE_UNUSED, |
1184 | addressT from_addr ATTRIBUTE_UNUSED, | |
1185 | addressT to_addr ATTRIBUTE_UNUSED, | |
1186 | fragS * frag ATTRIBUTE_UNUSED, | |
1187 | symbolS * to_symbol ATTRIBUTE_UNUSED) | |
3b16e843 NC |
1188 | { |
1189 | as_fatal ("or32_create_long_jump\n"); | |
1190 | } | |
1191 | ||
1192 | /* Should never be called for or32. */ | |
1193 | ||
1194 | int | |
ea1562b3 NC |
1195 | md_estimate_size_before_relax (fragS * fragP ATTRIBUTE_UNUSED, |
1196 | segT segtype ATTRIBUTE_UNUSED) | |
3b16e843 NC |
1197 | { |
1198 | as_fatal ("or32_estimate_size_before_relax\n"); | |
1199 | return 0; | |
1200 | } | |
1201 | ||
1202 | /* Translate internal representation of relocation info to target format. | |
1203 | ||
1204 | On sparc/29k: first 4 bytes are normal unsigned long address, next three | |
1205 | bytes are index, most sig. byte first. Byte 7 is broken up with | |
1206 | bit 7 as external, bits 6 & 5 unused, and the lower | |
1207 | five bits as relocation type. Next 4 bytes are long addend. */ | |
1208 | /* Thanx and a tip of the hat to Michael Bloom, mb@ttidca.tti.com. */ | |
1209 | ||
1210 | #ifdef OBJ_AOUT | |
1211 | void | |
ea1562b3 NC |
1212 | tc_aout_fix_to_chars (char *where, |
1213 | fixS *fixP, | |
1214 | relax_addressT segment_address_in_file) | |
3b16e843 NC |
1215 | { |
1216 | long r_symbolnum; | |
1217 | ||
1218 | #if DEBUG | |
1219 | printf ("tc_aout_fix_to_chars\n"); | |
5d6255fe | 1220 | #endif |
3b16e843 NC |
1221 | |
1222 | know (fixP->fx_r_type < BFD_RELOC_NONE); | |
1223 | know (fixP->fx_addsy != NULL); | |
1224 | ||
1225 | md_number_to_chars | |
1226 | (where, | |
1227 | fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file, | |
1228 | 4); | |
1229 | ||
1230 | r_symbolnum = (S_IS_DEFINED (fixP->fx_addsy) | |
1231 | ? S_GET_TYPE (fixP->fx_addsy) | |
1232 | : fixP->fx_addsy->sy_number); | |
1233 | ||
1234 | where[4] = (r_symbolnum >> 16) & 0x0ff; | |
1235 | where[5] = (r_symbolnum >> 8) & 0x0ff; | |
1236 | where[6] = r_symbolnum & 0x0ff; | |
1237 | where[7] = (((!S_IS_DEFINED (fixP->fx_addsy)) << 7) & 0x80) | (0 & 0x60) | (fixP->fx_r_type & 0x1F); | |
1238 | ||
1239 | /* Also easy. */ | |
1240 | md_number_to_chars (&where[8], fixP->fx_addnumber, 4); | |
1241 | } | |
1242 | ||
1243 | #endif /* OBJ_AOUT */ | |
1244 | \f | |
1245 | const char *md_shortopts = ""; | |
1246 | ||
1247 | struct option md_longopts[] = | |
ea1562b3 NC |
1248 | { |
1249 | { NULL, no_argument, NULL, 0 } | |
1250 | }; | |
3b16e843 NC |
1251 | size_t md_longopts_size = sizeof (md_longopts); |
1252 | ||
1253 | int | |
ea1562b3 | 1254 | md_parse_option (int c ATTRIBUTE_UNUSED, char * arg ATTRIBUTE_UNUSED) |
3b16e843 NC |
1255 | { |
1256 | return 0; | |
1257 | } | |
1258 | ||
1259 | void | |
ea1562b3 | 1260 | md_show_usage (FILE * stream ATTRIBUTE_UNUSED) |
3b16e843 NC |
1261 | { |
1262 | } | |
1263 | \f | |
1264 | /* This is called when a line is unrecognized. This is used to handle | |
1265 | definitions of or32 style local labels. */ | |
1266 | ||
1267 | int | |
ea1562b3 | 1268 | or32_unrecognized_line (int c) |
3b16e843 NC |
1269 | { |
1270 | int lab; | |
1271 | char *s; | |
1272 | ||
1273 | if (c != '$' | |
1274 | || ! ISDIGIT ((unsigned char) input_line_pointer[0])) | |
1275 | return 0; | |
1276 | ||
1277 | s = input_line_pointer; | |
1278 | ||
1279 | lab = 0; | |
1280 | while (ISDIGIT ((unsigned char) *s)) | |
1281 | { | |
1282 | lab = lab * 10 + *s - '0'; | |
1283 | ++s; | |
1284 | } | |
1285 | ||
1286 | if (*s != ':') | |
1287 | /* Not a label definition. */ | |
1288 | return 0; | |
1289 | ||
1290 | if (dollar_label_defined (lab)) | |
1291 | { | |
1292 | as_bad (_("label \"$%d\" redefined"), lab); | |
1293 | return 0; | |
1294 | } | |
1295 | ||
1296 | define_dollar_label (lab); | |
1297 | colon (dollar_label_name (lab, 0)); | |
1298 | input_line_pointer = s + 1; | |
1299 | ||
1300 | return 1; | |
1301 | } | |
1302 | ||
3b16e843 NC |
1303 | /* Default the values of symbols known that should be "predefined". We |
1304 | don't bother to predefine them unless you actually use one, since there | |
1305 | are a lot of them. */ | |
1306 | ||
1307 | symbolS * | |
ea1562b3 | 1308 | md_undefined_symbol (char *name ATTRIBUTE_UNUSED) |
3b16e843 NC |
1309 | { |
1310 | #ifndef BFD_ASSEMBLER | |
1311 | long regnum; | |
1312 | char testbuf[5 + /*SLOP*/ 5]; | |
1313 | ||
1314 | #if DEBUG | |
1315 | printf ("md_undefined_symbol(%s)\n", name); | |
1316 | #endif | |
1317 | ||
1318 | /* Register name. */ | |
5d6255fe KH |
1319 | if (name[0] == 'r' || name[0] == 'R' || name[0] == 'a' || name[0] == 'b') |
1320 | { | |
3b16e843 NC |
1321 | /* Parse the number, make sure it has no extra zeroes or |
1322 | trailing chars. */ | |
1323 | regnum = atol (& name[1]); | |
1324 | ||
1325 | if (regnum > 31) | |
1326 | as_fatal (_("register out of range")); | |
1327 | ||
1328 | sprintf (testbuf, "%ld", regnum); | |
1329 | ||
1330 | if (strcmp (testbuf, &name[1]) != 0) | |
1331 | return NULL; /* gr007 or lr7foo or whatever. */ | |
1332 | ||
1333 | /* We have a wiener! Define and return a new symbol for it. */ | |
1334 | return (symbol_new (name, SEG_REGISTER, (valueT) regnum, | |
1335 | &zero_address_frag)); | |
1336 | } | |
1337 | #endif | |
1338 | return NULL; | |
1339 | } | |
1340 | ||
1341 | /* Parse an operand that is machine-specific. */ | |
1342 | ||
1343 | void | |
ea1562b3 | 1344 | md_operand (expressionS *expressionP) |
3b16e843 NC |
1345 | { |
1346 | #if DEBUG | |
1347 | printf (" md_operand(input_line_pointer = %s)\n", input_line_pointer); | |
1348 | #endif | |
1349 | ||
1350 | if (input_line_pointer[0] == REGISTER_PREFIX && input_line_pointer[1] == 'r') | |
1351 | { | |
1352 | /* We have a numeric register expression. No biggy. */ | |
1353 | input_line_pointer += 2; /* Skip %r */ | |
1354 | (void) expression (expressionP); | |
1355 | ||
1356 | if (expressionP->X_op != O_constant | |
1357 | || expressionP->X_add_number > 255) | |
1358 | as_bad (_("Invalid expression after %%%%\n")); | |
1359 | expressionP->X_op = O_register; | |
1360 | } | |
1361 | else if (input_line_pointer[0] == '&') | |
1362 | { | |
1363 | /* We are taking the 'address' of a register...this one is not | |
1364 | in the manual, but it *is* in traps/fpsymbol.h! What they | |
1365 | seem to want is the register number, as an absolute number. */ | |
1366 | input_line_pointer++; /* Skip & */ | |
1367 | (void) expression (expressionP); | |
1368 | ||
1369 | if (expressionP->X_op != O_register) | |
1370 | as_bad (_("invalid register in & expression")); | |
1371 | else | |
1372 | expressionP->X_op = O_constant; | |
1373 | } | |
1374 | else if (input_line_pointer[0] == '$' | |
1375 | && ISDIGIT ((unsigned char) input_line_pointer[1])) | |
1376 | { | |
1377 | long lab; | |
1378 | char *name; | |
1379 | symbolS *sym; | |
5d6255fe | 1380 | |
3b16e843 NC |
1381 | /* This is a local label. */ |
1382 | ++input_line_pointer; | |
1383 | lab = (long) get_absolute_expression (); | |
1384 | ||
1385 | if (dollar_label_defined (lab)) | |
1386 | { | |
1387 | name = dollar_label_name (lab, 0); | |
1388 | sym = symbol_find (name); | |
1389 | } | |
1390 | else | |
1391 | { | |
1392 | name = dollar_label_name (lab, 1); | |
1393 | sym = symbol_find_or_make (name); | |
1394 | } | |
1395 | ||
1396 | expressionP->X_op = O_symbol; | |
1397 | expressionP->X_add_symbol = sym; | |
1398 | expressionP->X_add_number = 0; | |
1399 | } | |
1400 | else if (input_line_pointer[0] == '$') | |
1401 | { | |
1402 | char *s; | |
1403 | char type; | |
1404 | int fieldnum, fieldlimit; | |
1405 | LITTLENUM_TYPE floatbuf[8]; | |
1406 | ||
1407 | /* $float(), $doubleN(), or $extendN() convert floating values | |
1408 | to integers. */ | |
1409 | s = input_line_pointer; | |
1410 | ||
1411 | ++s; | |
1412 | ||
1413 | fieldnum = 0; | |
1414 | if (strncmp (s, "double", sizeof "double" - 1) == 0) | |
1415 | { | |
1416 | s += sizeof "double" - 1; | |
1417 | type = 'd'; | |
1418 | fieldlimit = 2; | |
1419 | } | |
1420 | else if (strncmp (s, "float", sizeof "float" - 1) == 0) | |
1421 | { | |
1422 | s += sizeof "float" - 1; | |
1423 | type = 'f'; | |
1424 | fieldlimit = 1; | |
1425 | } | |
1426 | else if (strncmp (s, "extend", sizeof "extend" - 1) == 0) | |
1427 | { | |
1428 | s += sizeof "extend" - 1; | |
1429 | type = 'x'; | |
1430 | fieldlimit = 4; | |
1431 | } | |
5d6255fe | 1432 | else |
3b16e843 NC |
1433 | return; |
1434 | ||
1435 | if (ISDIGIT (*s)) | |
1436 | { | |
1437 | fieldnum = *s - '0'; | |
1438 | ++s; | |
1439 | } | |
1440 | if (fieldnum >= fieldlimit) | |
1441 | return; | |
1442 | ||
1443 | SKIP_WHITESPACE (); | |
1444 | if (*s != '(') | |
1445 | return; | |
1446 | ++s; | |
1447 | SKIP_WHITESPACE (); | |
1448 | ||
1449 | s = atof_ieee (s, type, floatbuf); | |
1450 | if (s == NULL) | |
1451 | return; | |
1452 | s = s; | |
1453 | ||
1454 | SKIP_WHITESPACE (); | |
1455 | if (*s != ')') | |
1456 | return; | |
1457 | ++s; | |
1458 | SKIP_WHITESPACE (); | |
1459 | ||
1460 | input_line_pointer = s; | |
5d6255fe | 1461 | expressionP->X_op = O_constant; |
3b16e843 NC |
1462 | expressionP->X_unsigned = 1; |
1463 | expressionP->X_add_number = ((floatbuf[fieldnum * 2] | |
1464 | << LITTLENUM_NUMBER_OF_BITS) | |
1465 | + floatbuf[fieldnum * 2 + 1]); | |
1466 | } | |
1467 | } | |
1468 | ||
1469 | /* Round up a section size to the appropriate boundary. */ | |
1470 | ||
1471 | valueT | |
ea1562b3 | 1472 | md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size ATTRIBUTE_UNUSED) |
3b16e843 NC |
1473 | { |
1474 | return size; /* Byte alignment is fine. */ | |
1475 | } | |
1476 | ||
1477 | /* Exactly what point is a PC-relative offset relative TO? | |
1478 | On the 29000, they're relative to the address of the instruction, | |
1479 | which we have set up as the address of the fixup too. */ | |
1480 | ||
1481 | long | |
ea1562b3 | 1482 | md_pcrel_from (fixS *fixP) |
3b16e843 NC |
1483 | { |
1484 | return fixP->fx_where + fixP->fx_frag->fr_address; | |
1485 | } | |
1486 | ||
1487 | /* Generate a reloc for a fixup. */ | |
1488 | ||
1489 | #ifdef BFD_ASSEMBLER | |
1490 | arelent * | |
ea1562b3 | 1491 | tc_gen_reloc (asection *seg ATTRIBUTE_UNUSED, fixS *fixp) |
3b16e843 NC |
1492 | { |
1493 | arelent *reloc; | |
1494 | ||
ea1562b3 NC |
1495 | reloc = xmalloc (sizeof (arelent)); |
1496 | reloc->sym_ptr_ptr = xmalloc (sizeof (asymbol *)); | |
3b16e843 NC |
1497 | *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy); |
1498 | reloc->address = fixp->fx_frag->fr_address + fixp->fx_where; | |
1499 | /* reloc->address = fixp->fx_frag->fr_address + fixp->fx_where + fixp->fx_addnumber;*/ | |
1500 | reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type); | |
1501 | ||
1502 | if (reloc->howto == (reloc_howto_type *) NULL) | |
1503 | { | |
1504 | as_bad_where (fixp->fx_file, fixp->fx_line, | |
1505 | _("reloc %d not supported by object file format"), | |
1506 | (int) fixp->fx_r_type); | |
1507 | return NULL; | |
1508 | } | |
1509 | ||
a161fe53 AM |
1510 | if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY) |
1511 | reloc->address = fixp->fx_offset; | |
3b16e843 | 1512 | |
a161fe53 | 1513 | reloc->addend = fixp->fx_addnumber; |
3b16e843 NC |
1514 | return reloc; |
1515 | } | |
1516 | #endif |