2000-06-06 Michael Snyder <msnyder@seadog.cygnus.com>
[binutils.git] / gas / config / tc-a29k.c
blob600fec58857cbf2c0c1d0bb00823cb6c24ab3266
1 /* tc-a29k.c -- Assemble for the AMD 29000.
2 Copyright (C) 1989, 90, 91, 92, 93, 94, 95, 1998
3 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA. */
22 /* John Gilmore has reorganized this module somewhat, to make it easier
23 to convert it to new machines' assemblers as desired. There was too
24 much bloody rewriting required before. There still probably is. */
26 #include <ctype.h>
27 #include "as.h"
29 #include "opcode/a29k.h"
31 /* Make it easier to clone this machine desc into another one. */
32 #define machine_opcode a29k_opcode
33 #define machine_opcodes a29k_opcodes
34 #define machine_ip a29k_ip
35 #define machine_it a29k_it
37 #define IMMEDIATE_BIT 0x01000000 /* Turns RB into Immediate */
38 #define ABSOLUTE_BIT 0x01000000 /* Turns PC-relative to Absolute */
39 #define CE_BIT 0x00800000 /* Coprocessor enable in LOAD */
40 #define UI_BIT 0x00000080 /* Unsigned integer in CONVERT */
42 /* handle of the OPCODE hash table */
43 static struct hash_control *op_hash = NULL;
45 struct machine_it
47 char *error;
48 unsigned long opcode;
49 struct nlist *nlistp;
50 expressionS exp;
51 int pcrel;
52 int reloc_offset; /* Offset of reloc within insn */
54 int reloc;
56 the_insn;
58 static void machine_ip PARAMS ((char *str));
59 /* static void print_insn PARAMS ((struct machine_it *insn)); */
60 #ifndef OBJ_COFF
61 static void s_data1 PARAMS ((void));
62 static void s_use PARAMS ((int));
63 #endif
65 const pseudo_typeS
66 md_pseudo_table[] =
68 {"align", s_align_bytes, 4},
69 {"block", s_space, 0},
70 {"cputype", s_ignore, 0}, /* CPU as 29000 or 29050 */
71 {"reg", s_lsym, 0}, /* Register equate, same as equ */
72 {"space", s_ignore, 0}, /* Listing control */
73 {"sect", s_ignore, 0}, /* Creation of coff sections */
74 #ifndef OBJ_COFF
75 /* We can do this right with coff. */
76 {"use", s_use, 0},
77 #endif
78 {"word", cons, 4},
79 {NULL, 0, 0},
82 #if defined(BFD_HEADERS)
83 #ifdef RELSZ
84 const int md_reloc_size = RELSZ; /* Coff headers */
85 #else
86 const int md_reloc_size = 12; /* something else headers */
87 #endif
88 #else
89 const int md_reloc_size = 12; /* Not bfdized*/
90 #endif
92 /* This array holds the chars that always start a comment. If the
93 pre-processor is disabled, these aren't very useful */
94 const char comment_chars[] = ";";
96 /* This array holds the chars that only start a comment at the beginning of
97 a line. If the line seems to have the form '# 123 filename'
98 .line and .file directives will appear in the pre-processed output */
99 /* Note that input_file.c hand checks for '#' at the beginning of the
100 first line of the input file. This is because the compiler outputs
101 #NO_APP at the beginning of its output. */
102 /* Also note that comments like this one will always work */
103 const char line_comment_chars[] = "#";
105 /* We needed an unused char for line separation to work around the
106 lack of macros, using sed and such. */
107 const char line_separator_chars[] = "@";
109 /* Chars that can be used to separate mant from exp in floating point nums */
110 const char EXP_CHARS[] = "eE";
112 /* Chars that mean this number is a floating point constant */
113 /* As in 0f12.456 */
114 /* or 0d1.2345e12 */
115 const char FLT_CHARS[] = "rRsSfFdDxXpP";
117 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
118 changed in read.c. Ideally it shouldn't have to know about it at
119 all, but nothing is ideal around here. */
122 * anull bit - causes the branch delay slot instructions to not be executed
124 #define ANNUL (1 << 29)
126 #ifndef OBJ_COFF
128 static void
129 s_use (ignore)
130 int ignore;
132 if (strncmp (input_line_pointer, ".text", 5) == 0)
134 input_line_pointer += 5;
135 s_text (0);
136 return;
138 if (strncmp (input_line_pointer, ".data", 5) == 0)
140 input_line_pointer += 5;
141 s_data (0);
142 return;
144 if (strncmp (input_line_pointer, ".data1", 6) == 0)
146 input_line_pointer += 6;
147 s_data1 ();
148 return;
150 /* Literals can't go in the text segment because you can't read from
151 instruction memory on some 29k's. So, into initialized data. */
152 if (strncmp (input_line_pointer, ".lit", 4) == 0)
154 input_line_pointer += 4;
155 subseg_set (SEG_DATA, 200);
156 demand_empty_rest_of_line ();
157 return;
160 as_bad (_("Unknown segment type"));
161 demand_empty_rest_of_line ();
164 static void
165 s_data1 ()
167 subseg_set (SEG_DATA, 1);
168 demand_empty_rest_of_line ();
171 #endif /* OBJ_COFF */
173 /* Install symbol definition that maps REGNAME to REGNO.
174 FIXME-SOON: These are not recognized in mixed case. */
176 static void
177 insert_sreg (regname, regnum)
178 char *regname;
179 int regnum;
181 /* FIXME-SOON, put something in these syms so they won't be output
182 to the symbol table of the resulting object file. */
184 /* Must be large enough to hold the names of the special registers. */
185 char buf[80];
186 int i;
188 symbol_table_insert (symbol_new (regname, SEG_REGISTER, (valueT) regnum,
189 &zero_address_frag));
190 for (i = 0; regname[i]; i++)
191 buf[i] = islower (regname[i]) ? toupper (regname[i]) : regname[i];
192 buf[i] = '\0';
194 symbol_table_insert (symbol_new (buf, SEG_REGISTER, (valueT) regnum,
195 &zero_address_frag));
198 /* Install symbol definitions for assorted special registers.
199 See ASM29K Ref page 2-9. */
201 void
202 define_some_regs ()
204 #define SREG 256
206 /* Protected special-purpose register names */
207 insert_sreg ("vab", SREG + 0);
208 insert_sreg ("ops", SREG + 1);
209 insert_sreg ("cps", SREG + 2);
210 insert_sreg ("cfg", SREG + 3);
211 insert_sreg ("cha", SREG + 4);
212 insert_sreg ("chd", SREG + 5);
213 insert_sreg ("chc", SREG + 6);
214 insert_sreg ("rbp", SREG + 7);
215 insert_sreg ("tmc", SREG + 8);
216 insert_sreg ("tmr", SREG + 9);
217 insert_sreg ("pc0", SREG + 10);
218 insert_sreg ("pc1", SREG + 11);
219 insert_sreg ("pc2", SREG + 12);
220 insert_sreg ("mmu", SREG + 13);
221 insert_sreg ("lru", SREG + 14);
223 /* Additional protected special-purpose registers for the 29050 */
224 insert_sreg ("rsn", SREG + 15);
225 insert_sreg ("rma0", SREG + 16);
226 insert_sreg ("rmc0", SREG + 17);
227 insert_sreg ("rma1", SREG + 18);
228 insert_sreg ("rmc1", SREG + 19);
229 insert_sreg ("spc0", SREG + 20);
230 insert_sreg ("spc1", SREG + 21);
231 insert_sreg ("spc2", SREG + 22);
232 insert_sreg ("iba0", SREG + 23);
233 insert_sreg ("ibc0", SREG + 24);
234 insert_sreg ("iba1", SREG + 25);
235 insert_sreg ("ibc1", SREG + 26);
237 /* Additional registers for the 29040. */
238 insert_sreg ("dba", SREG + 27);
239 insert_sreg ("dbc", SREG + 28);
240 insert_sreg ("cir", SREG + 29);
241 insert_sreg ("cdr", SREG + 30);
243 /* Unprotected special-purpose register names */
244 insert_sreg ("ipc", SREG + 128);
245 insert_sreg ("ipa", SREG + 129);
246 insert_sreg ("ipb", SREG + 130);
247 insert_sreg ("q", SREG + 131);
248 insert_sreg ("alu", SREG + 132);
249 insert_sreg ("bp", SREG + 133);
250 insert_sreg ("fc", SREG + 134);
251 insert_sreg ("cr", SREG + 135);
252 insert_sreg ("fpe", SREG + 160);
253 insert_sreg ("inte", SREG + 161);
254 insert_sreg ("fps", SREG + 162);
255 /* "", SREG+163); Reserved */
256 insert_sreg ("exop", SREG + 164);
259 /* This function is called once, at assembler startup time. It should
260 set up all the tables, etc., that the MD part of the assembler will
261 need. */
262 void
263 md_begin ()
265 register const char *retval = NULL;
266 int lose = 0;
267 register int skipnext = 0;
268 register unsigned int i;
269 register char *strend, *strend2;
271 /* Hash up all the opcodes for fast use later. */
273 op_hash = hash_new ();
275 for (i = 0; i < num_opcodes; i++)
277 const char *name = machine_opcodes[i].name;
279 if (skipnext)
281 skipnext = 0;
282 continue;
285 /* Hack to avoid multiple opcode entries. We pre-locate all the
286 variations (b/i field and P/A field) and handle them. */
288 if (!strcmp (name, machine_opcodes[i + 1].name))
290 if ((machine_opcodes[i].opcode & 0x01000000) != 0
291 || (machine_opcodes[i + 1].opcode & 0x01000000) == 0
292 || ((machine_opcodes[i].opcode | 0x01000000)
293 != machine_opcodes[i + 1].opcode))
294 goto bad_table;
295 strend = machine_opcodes[i].args + strlen (machine_opcodes[i].args) - 1;
296 strend2 = machine_opcodes[i + 1].args + strlen (machine_opcodes[i + 1].args) - 1;
297 switch (*strend)
299 case 'b':
300 if (*strend2 != 'i')
301 goto bad_table;
302 break;
303 case 'P':
304 if (*strend2 != 'A')
305 goto bad_table;
306 break;
307 default:
308 bad_table:
309 fprintf (stderr, "internal error: can't handle opcode %s\n",
310 name);
311 lose = 1;
314 /* OK, this is an i/b or A/P pair. We skip the
315 higher-valued one, and let the code for operand checking
316 handle OR-ing in the bit. */
317 skipnext = 1;
320 retval = hash_insert (op_hash, name, (PTR) &machine_opcodes[i]);
321 if (retval != NULL)
323 fprintf (stderr, "internal error: can't hash `%s': %s\n",
324 machine_opcodes[i].name, retval);
325 lose = 1;
329 if (lose)
330 as_fatal (_("Broken assembler. No assembly attempted."));
332 define_some_regs ();
335 /* Assemble a single instruction. Its label has already been handled
336 by the generic front end. We just parse opcode and operands, and
337 produce the bytes of data and relocation. */
339 void
340 md_assemble (str)
341 char *str;
343 char *toP;
345 know (str);
346 machine_ip (str);
347 toP = frag_more (4);
348 /* put out the opcode */
349 md_number_to_chars (toP, the_insn.opcode, 4);
351 /* put out the symbol-dependent stuff */
352 if (the_insn.reloc != NO_RELOC)
354 fix_new_exp (frag_now,
355 (toP - frag_now->fr_literal + the_insn.reloc_offset),
356 4, /* size */
357 &the_insn.exp,
358 the_insn.pcrel,
359 the_insn.reloc);
363 char *
364 parse_operand (s, operandp, opt)
365 char *s;
366 expressionS *operandp;
367 int opt;
369 char *save = input_line_pointer;
370 char *new;
372 input_line_pointer = s;
373 expression (operandp);
374 if (operandp->X_op == O_absent && ! opt)
375 as_bad (_("missing operand"));
376 new = input_line_pointer;
377 input_line_pointer = save;
378 return new;
381 /* Instruction parsing. Takes a string containing the opcode.
382 Operands are at input_line_pointer. Output is in the_insn.
383 Warnings or errors are generated. */
385 static void
386 machine_ip (str)
387 char *str;
389 char *s;
390 const char *args;
391 struct machine_opcode *insn;
392 char *argsStart;
393 unsigned long opcode;
394 expressionS the_operand;
395 expressionS *operand = &the_operand;
396 unsigned int reg;
398 /* Must handle `div0' opcode. */
399 s = str;
400 if (isalpha (*s))
401 for (; isalnum (*s); ++s)
402 if (isupper (*s))
403 *s = tolower (*s);
405 switch (*s)
407 case '\0':
408 break;
410 case ' ': /* FIXME-SOMEDAY more whitespace */
411 *s++ = '\0';
412 break;
414 default:
415 as_bad (_("Unknown opcode: `%s'"), str);
416 return;
418 if ((insn = (struct machine_opcode *) hash_find (op_hash, str)) == NULL)
420 as_bad (_("Unknown opcode `%s'."), str);
421 return;
423 argsStart = s;
424 opcode = insn->opcode;
425 memset (&the_insn, '\0', sizeof (the_insn));
426 the_insn.reloc = NO_RELOC;
428 /* Build the opcode, checking as we go to make sure that the
429 operands match.
431 If an operand matches, we modify the_insn or opcode appropriately,
432 and do a "continue". If an operand fails to match, we "break". */
434 if (insn->args[0] != '\0')
436 /* Prime the pump. */
437 s = parse_operand (s, operand, insn->args[0] == 'I');
440 for (args = insn->args;; ++args)
442 switch (*args)
445 case '\0': /* end of args */
446 if (*s == '\0')
448 /* We are truly done. */
449 the_insn.opcode = opcode;
450 return;
452 as_bad (_("Too many operands: %s"), s);
453 break;
455 case ',': /* Must match a comma */
456 if (*s++ == ',')
458 /* Parse next operand. */
459 s = parse_operand (s, operand, args[1] == 'I');
460 continue;
462 break;
464 case 'v': /* Trap numbers (immediate field) */
465 if (operand->X_op == O_constant)
467 if (operand->X_add_number < 256)
469 opcode |= (operand->X_add_number << 16);
470 continue;
472 else
474 as_bad (_("Immediate value of %ld is too large"),
475 (long) operand->X_add_number);
476 continue;
479 the_insn.reloc = RELOC_8;
480 the_insn.reloc_offset = 1; /* BIG-ENDIAN Byte 1 of insn */
481 the_insn.exp = *operand;
482 continue;
484 case 'b': /* A general register or 8-bit immediate */
485 case 'i':
486 /* We treat the two cases identically since we mashed
487 them together in the opcode table. */
488 if (operand->X_op == O_register)
489 goto general_reg;
491 /* Make sure the 'i' case really exists. */
492 if ((insn->opcode | IMMEDIATE_BIT) != (insn + 1)->opcode)
493 break;
495 opcode |= IMMEDIATE_BIT;
496 if (operand->X_op == O_constant)
498 if (operand->X_add_number < 256)
500 opcode |= operand->X_add_number;
501 continue;
503 else
505 as_bad (_("Immediate value of %ld is too large"),
506 (long) operand->X_add_number);
507 continue;
510 the_insn.reloc = RELOC_8;
511 the_insn.reloc_offset = 3; /* BIG-ENDIAN Byte 3 of insn */
512 the_insn.exp = *operand;
513 continue;
515 case 'a': /* next operand must be a register */
516 case 'c':
517 general_reg:
518 /* lrNNN or grNNN or %%expr or a user-def register name */
519 if (operand->X_op != O_register)
520 break; /* Only registers */
521 know (operand->X_add_symbol == 0);
522 know (operand->X_op_symbol == 0);
523 reg = operand->X_add_number;
524 if (reg >= SREG)
525 break; /* No special registers */
527 /* Got the register, now figure out where it goes in the
528 opcode. */
529 switch (*args)
531 case 'a':
532 opcode |= reg << 8;
533 continue;
535 case 'b':
536 case 'i':
537 opcode |= reg;
538 continue;
540 case 'c':
541 opcode |= reg << 16;
542 continue;
544 as_fatal (_("failed sanity check."));
545 break;
547 case 'x': /* 16 bit constant, zero-extended */
548 case 'X': /* 16 bit constant, one-extended */
549 if (operand->X_op == O_constant)
551 opcode |= (operand->X_add_number & 0xFF) << 0 |
552 ((operand->X_add_number & 0xFF00) << 8);
553 continue;
555 the_insn.reloc = RELOC_CONST;
556 the_insn.exp = *operand;
557 continue;
559 case 'h':
560 if (operand->X_op == O_constant)
562 opcode |= (operand->X_add_number & 0x00FF0000) >> 16 |
563 (((unsigned long) operand->X_add_number
564 /* avoid sign ext */ & 0xFF000000) >> 8);
565 continue;
567 the_insn.reloc = RELOC_CONSTH;
568 the_insn.exp = *operand;
569 continue;
571 case 'P': /* PC-relative jump address */
572 case 'A': /* Absolute jump address */
573 /* These two are treated together since we folded the
574 opcode table entries together. */
575 if (operand->X_op == O_constant)
577 /* Make sure the 'A' case really exists. */
578 if ((insn->opcode | ABSOLUTE_BIT) != (insn + 1)->opcode)
579 break;
581 bfd_vma v, mask;
582 mask = 0x1ffff;
583 v = operand->X_add_number & ~ mask;
584 if (v)
585 as_bad ("call/jmp target out of range");
587 opcode |= ABSOLUTE_BIT |
588 (operand->X_add_number & 0x0003FC00) << 6 |
589 ((operand->X_add_number & 0x000003FC) >> 2);
590 continue;
592 the_insn.reloc = RELOC_JUMPTARG;
593 the_insn.exp = *operand;
594 the_insn.pcrel = 1; /* Assume PC-relative jump */
595 /* FIXME-SOON, Do we figure out whether abs later, after
596 know sym val? */
597 continue;
599 case 'e': /* Coprocessor enable bit for LOAD/STORE insn */
600 if (operand->X_op == O_constant)
602 if (operand->X_add_number == 0)
603 continue;
604 if (operand->X_add_number == 1)
606 opcode |= CE_BIT;
607 continue;
610 break;
612 case 'n': /* Control bits for LOAD/STORE instructions */
613 if (operand->X_op == O_constant &&
614 operand->X_add_number < 128)
616 opcode |= (operand->X_add_number << 16);
617 continue;
619 break;
621 case 's': /* Special register number */
622 if (operand->X_op != O_register)
623 break; /* Only registers */
624 if (operand->X_add_number < SREG)
625 break; /* Not a special register */
626 opcode |= (operand->X_add_number & 0xFF) << 8;
627 continue;
629 case 'u': /* UI bit of CONVERT */
630 if (operand->X_op == O_constant)
632 if (operand->X_add_number == 0)
633 continue;
634 if (operand->X_add_number == 1)
636 opcode |= UI_BIT;
637 continue;
640 break;
642 case 'r': /* RND bits of CONVERT */
643 if (operand->X_op == O_constant &&
644 operand->X_add_number < 8)
646 opcode |= operand->X_add_number << 4;
647 continue;
649 break;
651 case 'I': /* ID bits of INV and IRETINV. */
652 /* This operand is optional. */
653 if (operand->X_op == O_absent)
654 continue;
655 else if (operand->X_op == O_constant
656 && operand->X_add_number < 4)
658 opcode |= operand->X_add_number << 16;
659 continue;
661 break;
663 case 'd': /* FD bits of CONVERT */
664 if (operand->X_op == O_constant &&
665 operand->X_add_number < 4)
667 opcode |= operand->X_add_number << 2;
668 continue;
670 break;
673 case 'f': /* FS bits of CONVERT */
674 if (operand->X_op == O_constant &&
675 operand->X_add_number < 4)
677 opcode |= operand->X_add_number << 0;
678 continue;
680 break;
682 case 'C':
683 if (operand->X_op == O_constant &&
684 operand->X_add_number < 4)
686 opcode |= operand->X_add_number << 16;
687 continue;
689 break;
691 case 'F':
692 if (operand->X_op == O_constant &&
693 operand->X_add_number < 16)
695 opcode |= operand->X_add_number << 18;
696 continue;
698 break;
700 default:
701 BAD_CASE (*args);
703 /* Types or values of args don't match. */
704 as_bad ("Invalid operands");
705 return;
709 /* This is identical to the md_atof in m68k.c. I think this is right,
710 but I'm not sure.
712 Turn a string in input_line_pointer into a floating point constant
713 of type type, and store the appropriate bytes in *litP. The number
714 of LITTLENUMS emitted is stored in *sizeP . An error message is
715 returned, or NULL on OK. */
717 /* Equal to MAX_PRECISION in atof-ieee.c */
718 #define MAX_LITTLENUMS 6
720 char *
721 md_atof (type, litP, sizeP)
722 char type;
723 char *litP;
724 int *sizeP;
726 int prec;
727 LITTLENUM_TYPE words[MAX_LITTLENUMS];
728 LITTLENUM_TYPE *wordP;
729 char *t;
731 switch (type)
734 case 'f':
735 case 'F':
736 case 's':
737 case 'S':
738 prec = 2;
739 break;
741 case 'd':
742 case 'D':
743 case 'r':
744 case 'R':
745 prec = 4;
746 break;
748 case 'x':
749 case 'X':
750 prec = 6;
751 break;
753 case 'p':
754 case 'P':
755 prec = 6;
756 break;
758 default:
759 *sizeP = 0;
760 return "Bad call to MD_ATOF()";
762 t = atof_ieee (input_line_pointer, type, words);
763 if (t)
764 input_line_pointer = t;
765 *sizeP = prec * sizeof (LITTLENUM_TYPE);
766 for (wordP = words; prec--;)
768 md_number_to_chars (litP, (valueT) (*wordP++), sizeof (LITTLENUM_TYPE));
769 litP += sizeof (LITTLENUM_TYPE);
771 return 0;
775 * Write out big-endian.
777 void
778 md_number_to_chars (buf, val, n)
779 char *buf;
780 valueT val;
781 int n;
783 number_to_chars_bigendian (buf, val, n);
786 void
787 md_apply_fix (fixP, val)
788 fixS *fixP;
789 long val;
791 char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
793 fixP->fx_addnumber = val; /* Remember value for emit_reloc */
796 know (fixP->fx_size == 4);
797 know (fixP->fx_r_type < NO_RELOC);
799 /* This is a hack. There should be a better way to handle this. */
800 if (fixP->fx_r_type == RELOC_WDISP30 && fixP->fx_addsy)
802 val += fixP->fx_where + fixP->fx_frag->fr_address;
805 switch (fixP->fx_r_type)
808 case RELOC_32:
809 buf[0] = val >> 24;
810 buf[1] = val >> 16;
811 buf[2] = val >> 8;
812 buf[3] = val;
813 break;
815 case RELOC_8:
816 buf[0] = val;
817 break;
819 case RELOC_WDISP30:
820 val = (val >>= 2) + 1;
821 buf[0] |= (val >> 24) & 0x3f;
822 buf[1] = (val >> 16);
823 buf[2] = val >> 8;
824 buf[3] = val;
825 break;
827 case RELOC_HI22:
828 buf[1] |= (val >> 26) & 0x3f;
829 buf[2] = val >> 18;
830 buf[3] = val >> 10;
831 break;
833 case RELOC_LO10:
834 buf[2] |= (val >> 8) & 0x03;
835 buf[3] = val;
836 break;
838 case RELOC_BASE13:
839 buf[2] |= (val >> 8) & 0x1f;
840 buf[3] = val;
841 break;
843 case RELOC_WDISP22:
844 val = (val >>= 2) + 1;
845 /* FALLTHROUGH */
846 case RELOC_BASE22:
847 buf[1] |= (val >> 16) & 0x3f;
848 buf[2] = val >> 8;
849 buf[3] = val;
850 break;
852 case RELOC_JUMPTARG: /* 00XX00XX pattern in a word */
853 if (!fixP->fx_done)
855 /* The linker tries to support both AMD and old GNU style
856 R_IREL relocs. That means that if the addend is exactly
857 the negative of the address within the section, the
858 linker will not handle it correctly. */
859 if (fixP->fx_pcrel
860 && val != 0
861 && val == - (fixP->fx_frag->fr_address + fixP->fx_where))
862 as_bad_where
863 (fixP->fx_file, fixP->fx_line,
864 "the linker will not handle this relocation correctly");
866 else if (fixP->fx_pcrel)
868 long v = val >> 17;
869 if (v != 0 && v != -1)
870 as_bad_where (fixP->fx_file, fixP->fx_line,
871 "call/jmp target out of range");
873 else
874 /* this case was supposed to be handled in machine_ip */
875 abort ();
876 buf[1] = val >> 10; /* Holds bits 0003FFFC of address */
877 buf[3] = val >> 2;
878 break;
880 case RELOC_CONST: /* 00XX00XX pattern in a word */
881 buf[1] = val >> 8; /* Holds bits 0000XXXX */
882 buf[3] = val;
883 break;
885 case RELOC_CONSTH: /* 00XX00XX pattern in a word */
886 buf[1] = val >> 24; /* Holds bits XXXX0000 */
887 buf[3] = val >> 16;
888 break;
890 case NO_RELOC:
891 default:
892 as_bad (_("bad relocation type: 0x%02x"), fixP->fx_r_type);
893 break;
897 #ifdef OBJ_COFF
898 short
899 tc_coff_fix2rtype (fixP)
900 fixS *fixP;
903 switch (fixP->fx_r_type)
905 case RELOC_32:
906 return (R_WORD);
907 case RELOC_8:
908 return (R_BYTE);
909 case RELOC_CONST:
910 return (R_ILOHALF);
911 case RELOC_CONSTH:
912 return (R_IHIHALF);
913 case RELOC_JUMPTARG:
914 return (R_IREL);
915 default:
916 printf (_("need %o3\n"), fixP->fx_r_type);
917 abort ();
918 } /* switch on type */
920 return (0);
923 #endif /* OBJ_COFF */
925 /* should never be called for 29k */
926 void
927 md_convert_frag (headers, seg, fragP)
928 object_headers *headers;
929 segT seg;
930 register fragS *fragP;
932 as_fatal (_("a29k_convert_frag\n"));
935 /* should never be called for a29k */
937 md_estimate_size_before_relax (fragP, segtype)
938 register fragS *fragP;
939 segT segtype;
941 as_fatal (_("a29k_estimate_size_before_relax\n"));
942 return 0;
945 #if 0
946 /* for debugging only */
947 static void
948 print_insn (insn)
949 struct machine_it *insn;
951 char *Reloc[] =
953 "RELOC_8",
954 "RELOC_16",
955 "RELOC_32",
956 "RELOC_DISP8",
957 "RELOC_DISP16",
958 "RELOC_DISP32",
959 "RELOC_WDISP30",
960 "RELOC_WDISP22",
961 "RELOC_HI22",
962 "RELOC_22",
963 "RELOC_13",
964 "RELOC_LO10",
965 "RELOC_SFA_BASE",
966 "RELOC_SFA_OFF13",
967 "RELOC_BASE10",
968 "RELOC_BASE13",
969 "RELOC_BASE22",
970 "RELOC_PC10",
971 "RELOC_PC22",
972 "RELOC_JMP_TBL",
973 "RELOC_SEGOFF16",
974 "RELOC_GLOB_DAT",
975 "RELOC_JMP_SLOT",
976 "RELOC_RELATIVE",
977 "NO_RELOC"
980 if (insn->error)
982 fprintf (stderr, "ERROR: %s\n");
984 fprintf (stderr, "opcode=0x%08x\n", insn->opcode);
985 fprintf (stderr, "reloc = %s\n", Reloc[insn->reloc]);
986 fprintf (stderr, "exp = {\n");
987 fprintf (stderr, "\t\tX_add_symbol = %s\n",
988 insn->exp.X_add_symbol ?
989 (S_GET_NAME (insn->exp.X_add_symbol) ?
990 S_GET_NAME (insn->exp.X_add_symbol) : "???") : "0");
991 fprintf (stderr, "\t\tX_op_symbol = %s\n",
992 insn->exp.X_op_symbol ?
993 (S_GET_NAME (insn->exp.X_op_symbol) ?
994 S_GET_NAME (insn->exp.X_op_symbol) : "???") : "0");
995 fprintf (stderr, "\t\tX_add_number = %d\n",
996 insn->exp.X_add_number);
997 fprintf (stderr, "}\n");
1000 #endif
1002 /* Translate internal representation of relocation info to target format.
1004 On sparc/29k: first 4 bytes are normal unsigned long address, next three
1005 bytes are index, most sig. byte first. Byte 7 is broken up with
1006 bit 7 as external, bits 6 & 5 unused, and the lower
1007 five bits as relocation type. Next 4 bytes are long addend. */
1008 /* Thanx and a tip of the hat to Michael Bloom, mb@ttidca.tti.com */
1010 #ifdef OBJ_AOUT
1012 void
1013 tc_aout_fix_to_chars (where, fixP, segment_address_in_file)
1014 char *where;
1015 fixS *fixP;
1016 relax_addressT segment_address_in_file;
1018 long r_symbolnum;
1020 know (fixP->fx_r_type < NO_RELOC);
1021 know (fixP->fx_addsy != NULL);
1023 md_number_to_chars (where,
1024 fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file,
1027 r_symbolnum = (S_IS_DEFINED (fixP->fx_addsy)
1028 ? S_GET_TYPE (fixP->fx_addsy)
1029 : fixP->fx_addsy->sy_number);
1031 where[4] = (r_symbolnum >> 16) & 0x0ff;
1032 where[5] = (r_symbolnum >> 8) & 0x0ff;
1033 where[6] = r_symbolnum & 0x0ff;
1034 where[7] = (((!S_IS_DEFINED (fixP->fx_addsy)) << 7) & 0x80) | (0 & 0x60) | (fixP->fx_r_type & 0x1F);
1035 /* Also easy */
1036 md_number_to_chars (&where[8], fixP->fx_addnumber, 4);
1039 #endif /* OBJ_AOUT */
1041 CONST char *md_shortopts = "";
1042 struct option md_longopts[] = {
1043 {NULL, no_argument, NULL, 0}
1045 size_t md_longopts_size = sizeof(md_longopts);
1048 md_parse_option (c, arg)
1049 int c;
1050 char *arg;
1052 return 0;
1055 void
1056 md_show_usage (stream)
1057 FILE *stream;
1061 /* This is called when a line is unrecognized. This is used to handle
1062 definitions of a29k style local labels. */
1065 a29k_unrecognized_line (c)
1066 int c;
1068 int lab;
1069 char *s;
1071 if (c != '$'
1072 || ! isdigit ((unsigned char) input_line_pointer[0]))
1073 return 0;
1075 s = input_line_pointer;
1077 lab = 0;
1078 while (isdigit ((unsigned char) *s))
1080 lab = lab * 10 + *s - '0';
1081 ++s;
1084 if (*s != ':')
1086 /* Not a label definition. */
1087 return 0;
1090 if (dollar_label_defined (lab))
1092 as_bad (_("label \"$%d\" redefined"), lab);
1093 return 0;
1096 define_dollar_label (lab);
1097 colon (dollar_label_name (lab, 0));
1098 input_line_pointer = s + 1;
1100 return 1;
1103 /* Default the values of symbols known that should be "predefined". We
1104 don't bother to predefine them unless you actually use one, since there
1105 are a lot of them. */
1107 symbolS *
1108 md_undefined_symbol (name)
1109 char *name;
1111 long regnum;
1112 char testbuf[5 + /*SLOP*/ 5];
1114 if (name[0] == 'g' || name[0] == 'G'
1115 || name[0] == 'l' || name[0] == 'L'
1116 || name[0] == 's' || name[0] == 'S')
1118 /* Perhaps a global or local register name */
1119 if (name[1] == 'r' || name[1] == 'R')
1121 long maxreg;
1123 /* Parse the number, make sure it has no extra zeroes or
1124 trailing chars. */
1125 regnum = atol (&name[2]);
1127 if (name[0] == 's' || name[0] == 'S')
1128 maxreg = 255;
1129 else
1130 maxreg = 127;
1131 if (regnum > maxreg)
1132 return NULL;
1134 sprintf (testbuf, "%ld", regnum);
1135 if (strcmp (testbuf, &name[2]) != 0)
1136 return NULL; /* gr007 or lr7foo or whatever */
1138 /* We have a wiener! Define and return a new symbol for it. */
1139 if (name[0] == 'l' || name[0] == 'L')
1140 regnum += 128;
1141 else if (name[0] == 's' || name[0] == 'S')
1142 regnum += SREG;
1143 return (symbol_new (name, SEG_REGISTER, (valueT) regnum,
1144 &zero_address_frag));
1148 return NULL;
1151 /* Parse an operand that is machine-specific. */
1153 void
1154 md_operand (expressionP)
1155 expressionS *expressionP;
1158 if (input_line_pointer[0] == '%' && input_line_pointer[1] == '%')
1160 /* We have a numeric register expression. No biggy. */
1161 input_line_pointer += 2; /* Skip %% */
1162 (void) expression (expressionP);
1163 if (expressionP->X_op != O_constant
1164 || expressionP->X_add_number > 255)
1165 as_bad (_("Invalid expression after %%%%\n"));
1166 expressionP->X_op = O_register;
1168 else if (input_line_pointer[0] == '&')
1170 /* We are taking the 'address' of a register...this one is not
1171 in the manual, but it *is* in traps/fpsymbol.h! What they
1172 seem to want is the register number, as an absolute number. */
1173 input_line_pointer++; /* Skip & */
1174 (void) expression (expressionP);
1175 if (expressionP->X_op != O_register)
1176 as_bad (_("Invalid register in & expression"));
1177 else
1178 expressionP->X_op = O_constant;
1180 else if (input_line_pointer[0] == '$'
1181 && isdigit ((unsigned char) input_line_pointer[1]))
1183 long lab;
1184 char *name;
1185 symbolS *sym;
1187 /* This is a local label. */
1188 ++input_line_pointer;
1189 lab = (long) get_absolute_expression ();
1190 if (dollar_label_defined (lab))
1192 name = dollar_label_name (lab, 0);
1193 sym = symbol_find (name);
1195 else
1197 name = dollar_label_name (lab, 1);
1198 sym = symbol_find_or_make (name);
1201 expressionP->X_op = O_symbol;
1202 expressionP->X_add_symbol = sym;
1203 expressionP->X_add_number = 0;
1205 else if (input_line_pointer[0] == '$')
1207 char *s;
1208 char type;
1209 int fieldnum, fieldlimit;
1210 LITTLENUM_TYPE floatbuf[8];
1212 /* $float(), $doubleN(), or $extendN() convert floating values
1213 to integers. */
1215 s = input_line_pointer;
1217 ++s;
1219 fieldnum = 0;
1220 if (strncmp (s, "double", sizeof "double" - 1) == 0)
1222 s += sizeof "double" - 1;
1223 type = 'd';
1224 fieldlimit = 2;
1226 else if (strncmp (s, "float", sizeof "float" - 1) == 0)
1228 s += sizeof "float" - 1;
1229 type = 'f';
1230 fieldlimit = 1;
1232 else if (strncmp (s, "extend", sizeof "extend" - 1) == 0)
1234 s += sizeof "extend" - 1;
1235 type = 'x';
1236 fieldlimit = 4;
1238 else
1240 return;
1243 if (isdigit (*s))
1245 fieldnum = *s - '0';
1246 ++s;
1248 if (fieldnum >= fieldlimit)
1249 return;
1251 SKIP_WHITESPACE ();
1252 if (*s != '(')
1253 return;
1254 ++s;
1255 SKIP_WHITESPACE ();
1257 s = atof_ieee (s, type, floatbuf);
1258 if (s == NULL)
1259 return;
1260 s = s;
1262 SKIP_WHITESPACE ();
1263 if (*s != ')')
1264 return;
1265 ++s;
1266 SKIP_WHITESPACE ();
1268 input_line_pointer = s;
1269 expressionP->X_op = O_constant;
1270 expressionP->X_unsigned = 1;
1271 expressionP->X_add_number = ((floatbuf[fieldnum * 2]
1272 << LITTLENUM_NUMBER_OF_BITS)
1273 + floatbuf[fieldnum * 2 + 1]);
1277 /* Round up a section size to the appropriate boundary. */
1278 valueT
1279 md_section_align (segment, size)
1280 segT segment;
1281 valueT size;
1283 return size; /* Byte alignment is fine */
1286 /* Exactly what point is a PC-relative offset relative TO?
1287 On the 29000, they're relative to the address of the instruction,
1288 which we have set up as the address of the fixup too. */
1289 long
1290 md_pcrel_from (fixP)
1291 fixS *fixP;
1293 return fixP->fx_where + fixP->fx_frag->fr_address;
1296 /* end of tc-a29k.c */