gas/config/tc-a29k.c

   1 /* tc-a29k.c -- Assemble for the AMD 29000.
   2    Copyright (C) 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
   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
  18    the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 /* John Gilmore has reorganized this module somewhat, to make it easier
  21    to convert it to new machines' assemblers as desired.  There was too
  22    much bloody rewriting required before.  There still probably is.  */
  23
  24 #include "ctype.h"
  25 #include "as.h"
  26
  27 #include "opcode/a29k.h"
  28
  29 /* Make it easier to clone this machine desc into another one.  */
  30 #define machine_opcode  a29k_opcode
  31 #define machine_opcodes a29k_opcodes
  32 #define machine_ip      a29k_ip
  33 #define machine_it      a29k_it
  34
  35 const relax_typeS md_relax_table[] =
  36 {
  37   { 0, 0, 0, 0 }
  38 };
  39
  40 #define IMMEDIATE_BIT   0x01000000      /* Turns RB into Immediate */
  41 #define ABSOLUTE_BIT    0x01000000      /* Turns PC-relative to Absolute */
  42 #define CE_BIT          0x00800000      /* Coprocessor enable in LOAD */
  43 #define UI_BIT          0x00000080      /* Unsigned integer in CONVERT */
  44
  45 /* handle of the OPCODE hash table */
  46 static struct hash_control *op_hash = NULL;
  47
  48 struct machine_it
  49   {
  50     char *error;
  51     unsigned long opcode;
  52     struct nlist *nlistp;
  53     expressionS exp;
  54     int pcrel;
  55     int reloc_offset;           /* Offset of reloc within insn */
  56
  57     int reloc;
  58   }
  59 the_insn;
  60
  61 static void machine_ip PARAMS ((char *str));
  62 /* static void print_insn PARAMS ((struct machine_it *insn)); */
  63 #ifndef OBJ_COFF
  64 static void s_data1 PARAMS ((void));
  65 static void s_use PARAMS ((int));
  66 #endif
  67
  68 const pseudo_typeS
  69 md_pseudo_table[] =
  70 {
  71   {"align", s_align_bytes, 4},
  72   {"block", s_space, 0},
  73   {"cputype", s_ignore, 0},     /* CPU as 29000 or 29050 */
  74   {"reg", s_lsym, 0},           /* Register equate, same as equ */
  75   {"space", s_ignore, 0},       /* Listing control */
  76   {"sect", s_ignore, 0},        /* Creation of coff sections */
  77 #ifndef OBJ_COFF
  78   /* We can do this right with coff.  */
  79   {"use", s_use, 0},
  80 #endif
  81   {"word", cons, 4},
  82   {NULL, 0, 0},
  83 };
  84
  85 int md_short_jump_size = 4;
  86 int md_long_jump_size = 4;
  87 #if defined(BFD_HEADERS)
  88 #ifdef RELSZ
  89 const int md_reloc_size = RELSZ;        /* Coff headers */
  90 #else
  91 const int md_reloc_size = 12;           /* something else headers */
  92 #endif
  93 #else
  94 const int md_reloc_size = 12;           /* Not bfdized*/
  95 #endif
  96
  97 /* This array holds the chars that always start a comment.  If the
  98    pre-processor is disabled, these aren't very useful */
  99 const char comment_chars[] = ";";
 100
 101 /* This array holds the chars that only start a comment at the beginning of
 102    a line.  If the line seems to have the form '# 123 filename'
 103    .line and .file directives will appear in the pre-processed output */
 104 /* Note that input_file.c hand checks for '#' at the beginning of the
 105    first line of the input file.  This is because the compiler outputs
 106    #NO_APP at the beginning of its output. */
 107 /* Also note that comments like this one will always work */
 108 const char line_comment_chars[] = "#";
 109
 110 /* We needed an unused char for line separation to work around the
 111    lack of macros, using sed and such.  */
 112 const char line_separator_chars[] = "@";
 113
 114 /* Chars that can be used to separate mant from exp in floating point nums */
 115 const char EXP_CHARS[] = "eE";
 116
 117 /* Chars that mean this number is a floating point constant */
 118 /* As in 0f12.456 */
 119 /* or    0d1.2345e12 */
 120 const char FLT_CHARS[] = "rRsSfFdDxXpP";
 121
 122 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
 123    changed in read.c.  Ideally it shouldn't have to know about it at
 124    all, but nothing is ideal around here.  */
 125
 126 static unsigned char octal[256];
 127 #define isoctal(c)  octal[c]
 128 static unsigned char toHex[256];
 129
 130 /*
 131  *  anull bit - causes the branch delay slot instructions to not be executed
 132  */
 133 #define ANNUL       (1 << 29)
 134
 135 #ifndef OBJ_COFF
 136
 137 static void
 138 s_use (ignore)
 139      int ignore;
 140 {
 141   if (strncmp (input_line_pointer, ".text", 5) == 0)
 142     {
 143       input_line_pointer += 5;
 144       s_text (0);
 145       return;
 146     }
 147   if (strncmp (input_line_pointer, ".data", 5) == 0)
 148     {
 149       input_line_pointer += 5;
 150       s_data (0);
 151       return;
 152     }
 153   if (strncmp (input_line_pointer, ".data1", 6) == 0)
 154     {
 155       input_line_pointer += 6;
 156       s_data1 ();
 157       return;
 158     }
 159   /* Literals can't go in the text segment because you can't read from
 160      instruction memory on some 29k's.  So, into initialized data. */
 161   if (strncmp (input_line_pointer, ".lit", 4) == 0)
 162     {
 163       input_line_pointer += 4;
 164       subseg_set (SEG_DATA, 200);
 165       demand_empty_rest_of_line ();
 166       return;
 167     }
 168
 169   as_bad ("Unknown segment type");
 170   demand_empty_rest_of_line ();
 171 }
 172
 173 static void
 174 s_data1 ()
 175 {
 176   subseg_set (SEG_DATA, 1);
 177   demand_empty_rest_of_line ();
 178 }
 179
 180 #endif /* OBJ_COFF */
 181
 182 /* Install symbol definition that maps REGNAME to REGNO.
 183    FIXME-SOON:  These are not recognized in mixed case.  */
 184
 185 static void
 186 insert_sreg (regname, regnum)
 187      char *regname;
 188      int regnum;
 189 {
 190   /* FIXME-SOON, put something in these syms so they won't be output
 191      to the symbol table of the resulting object file.  */
 192
 193   /* Must be large enough to hold the names of the special registers.  */
 194   char buf[80];
 195   int i;
 196
 197   symbol_table_insert (symbol_new (regname, SEG_REGISTER, (valueT) regnum,
 198                                    &zero_address_frag));
 199   for (i = 0; regname[i]; i++)
 200     buf[i] = islower (regname[i]) ? toupper (regname[i]) : regname[i];
 201   buf[i] = '\0';
 202
 203   symbol_table_insert (symbol_new (buf, SEG_REGISTER, (valueT) regnum,
 204                                    &zero_address_frag));
 205 }
 206
 207 /* Install symbol definitions for assorted special registers.
 208    See ASM29K Ref page 2-9.  */
 209
 210 void
 211 define_some_regs ()
 212 {
 213 #define SREG    256
 214
 215   /* Protected special-purpose register names */
 216   insert_sreg ("vab", SREG + 0);
 217   insert_sreg ("ops", SREG + 1);
 218   insert_sreg ("cps", SREG + 2);
 219   insert_sreg ("cfg", SREG + 3);
 220   insert_sreg ("cha", SREG + 4);
 221   insert_sreg ("chd", SREG + 5);
 222   insert_sreg ("chc", SREG + 6);
 223   insert_sreg ("rbp", SREG + 7);
 224   insert_sreg ("tmc", SREG + 8);
 225   insert_sreg ("tmr", SREG + 9);
 226   insert_sreg ("pc0", SREG + 10);
 227   insert_sreg ("pc1", SREG + 11);
 228   insert_sreg ("pc2", SREG + 12);
 229   insert_sreg ("mmu", SREG + 13);
 230   insert_sreg ("lru", SREG + 14);
 231
 232   /* Additional protected special-purpose registers for the 29050 */
 233   insert_sreg ("rsn",  SREG + 15);
 234   insert_sreg ("rma0", SREG + 16);
 235   insert_sreg ("rmc0", SREG + 17);
 236   insert_sreg ("rma1", SREG + 18);
 237   insert_sreg ("rmc1", SREG + 19);
 238   insert_sreg ("spc0", SREG + 20);
 239   insert_sreg ("spc1", SREG + 21);
 240   insert_sreg ("spc2", SREG + 22);
 241   insert_sreg ("iba0", SREG + 23);
 242   insert_sreg ("ibc0", SREG + 24);
 243   insert_sreg ("iba1", SREG + 25);
 244   insert_sreg ("ibc1", SREG + 26);
 245
 246   /* Unprotected special-purpose register names */
 247   insert_sreg ("ipc", SREG + 128);
 248   insert_sreg ("ipa", SREG + 129);
 249   insert_sreg ("ipb", SREG + 130);
 250   insert_sreg ("q", SREG + 131);
 251   insert_sreg ("alu", SREG + 132);
 252   insert_sreg ("bp", SREG + 133);
 253   insert_sreg ("fc", SREG + 134);
 254   insert_sreg ("cr", SREG + 135);
 255   insert_sreg ("fpe", SREG + 160);
 256   insert_sreg ("inte", SREG + 161);
 257   insert_sreg ("fps", SREG + 162);
 258   /*  "",    SREG+163);   Reserved */
 259   insert_sreg ("exop", SREG + 164);
 260 }
 261
 262 /* This function is called once, at assembler startup time.  It should
 263    set up all the tables, etc., that the MD part of the assembler will
 264    need.  */
 265 void
 266 md_begin ()
 267 {
 268   register const char *retval = NULL;
 269   int lose = 0;
 270   register int skipnext = 0;
 271   register unsigned int i;
 272   register char *strend, *strend2;
 273
 274   /* Hash up all the opcodes for fast use later.  */
 275
 276   op_hash = hash_new ();
 277
 278   for (i = 0; i < num_opcodes; i++)
 279     {
 280       const char *name = machine_opcodes[i].name;
 281
 282       if (skipnext)
 283         {
 284           skipnext = 0;
 285           continue;
 286         }
 287
 288       /* Hack to avoid multiple opcode entries.  We pre-locate all the
 289          variations (b/i field and P/A field) and handle them. */
 290
 291       if (!strcmp (name, machine_opcodes[i + 1].name))
 292         {
 293           if ((machine_opcodes[i].opcode & 0x01000000) != 0
 294               || (machine_opcodes[i + 1].opcode & 0x01000000) == 0
 295               || ((machine_opcodes[i].opcode | 0x01000000)
 296                   != machine_opcodes[i + 1].opcode))
 297             goto bad_table;
 298           strend = machine_opcodes[i].args + strlen (machine_opcodes[i].args) - 1;
 299           strend2 = machine_opcodes[i + 1].args + strlen (machine_opcodes[i + 1].args) - 1;
 300           switch (*strend)
 301             {
 302             case 'b':
 303               if (*strend2 != 'i')
 304                 goto bad_table;
 305               break;
 306             case 'P':
 307               if (*strend2 != 'A')
 308                 goto bad_table;
 309               break;
 310             default:
 311             bad_table:
 312               fprintf (stderr, "internal error: can't handle opcode %s\n",
 313                        name);
 314               lose = 1;
 315             }
 316
 317           /* OK, this is an i/b or A/P pair.  We skip the
 318              higher-valued one, and let the code for operand checking
 319              handle OR-ing in the bit.  */
 320           skipnext = 1;
 321         }
 322
 323       retval = hash_insert (op_hash, name, (PTR) &machine_opcodes[i]);
 324       if (retval != NULL)
 325         {
 326           fprintf (stderr, "internal error: can't hash `%s': %s\n",
 327                    machine_opcodes[i].name, retval);
 328           lose = 1;
 329         }
 330     }
 331
 332   if (lose)
 333     as_fatal ("Broken assembler.  No assembly attempted.");
 334
 335   for (i = '0'; i < '8'; ++i)
 336     octal[i] = 1;
 337   for (i = '0'; i <= '9'; ++i)
 338     toHex[i] = i - '0';
 339   for (i = 'a'; i <= 'f'; ++i)
 340     toHex[i] = i + 10 - 'a';
 341   for (i = 'A'; i <= 'F'; ++i)
 342     toHex[i] = i + 10 - 'A';
 343
 344   define_some_regs ();
 345 }
 346
 347 /* Assemble a single instruction.  Its label has already been handled
 348    by the generic front end.  We just parse opcode and operands, and
 349    produce the bytes of data and relocation.  */
 350
 351 void
 352 md_assemble (str)
 353      char *str;
 354 {
 355   char *toP;
 356
 357   know (str);
 358   machine_ip (str);
 359   toP = frag_more (4);
 360   /* put out the opcode */
 361   md_number_to_chars (toP, the_insn.opcode, 4);
 362
 363   /* put out the symbol-dependent stuff */
 364   if (the_insn.reloc != NO_RELOC)
 365     {
 366       fix_new_exp (frag_now,
 367                    (toP - frag_now->fr_literal + the_insn.reloc_offset),
 368                    4,           /* size */
 369                    &the_insn.exp,
 370                    the_insn.pcrel,
 371                    the_insn.reloc);
 372     }
 373 }
 374
 375 char *
 376 parse_operand (s, operandp)
 377      char *s;
 378      expressionS *operandp;
 379 {
 380   char *save = input_line_pointer;
 381   char *new;
 382
 383   input_line_pointer = s;
 384   expression (operandp);
 385   if (operandp->X_op == O_absent)
 386     as_bad ("missing operand");
 387   new = input_line_pointer;
 388   input_line_pointer = save;
 389   return new;
 390 }
 391
 392 /* Instruction parsing.  Takes a string containing the opcode.
 393    Operands are at input_line_pointer.  Output is in the_insn.
 394    Warnings or errors are generated.  */
 395
 396 static void
 397 machine_ip (str)
 398      char *str;
 399 {
 400   char *s;
 401   const char *args;
 402   struct machine_opcode *insn;
 403   char *argsStart;
 404   unsigned long opcode;
 405   expressionS the_operand;
 406   expressionS *operand = &the_operand;
 407   unsigned int reg;
 408
 409   /* Must handle `div0' opcode.  */
 410   s = str;
 411   if (isalpha (*s))
 412     for (; isalnum (*s); ++s)
 413       if (isupper (*s))
 414         *s = tolower (*s);
 415
 416   switch (*s)
 417     {
 418     case '\0':
 419       break;
 420
 421     case ' ':                   /* FIXME-SOMEDAY more whitespace */
 422       *s++ = '\0';
 423       break;
 424
 425     default:
 426       as_bad ("Unknown opcode: `%s'", str);
 427       return;
 428     }
 429   if ((insn = (struct machine_opcode *) hash_find (op_hash, str)) == NULL)
 430     {
 431       as_bad ("Unknown opcode `%s'.", str);
 432       return;
 433     }
 434   argsStart = s;
 435   opcode = insn->opcode;
 436   memset (&the_insn, '\0', sizeof (the_insn));
 437   the_insn.reloc = NO_RELOC;
 438
 439   /* Build the opcode, checking as we go to make sure that the
 440      operands match.
 441
 442      If an operand matches, we modify the_insn or opcode appropriately,
 443      and do a "continue".  If an operand fails to match, we "break".  */
 444
 445   if (insn->args[0] != '\0')
 446     s = parse_operand (s, operand);     /* Prime the pump */
 447
 448   for (args = insn->args;; ++args)
 449     {
 450       switch (*args)
 451         {
 452
 453         case '\0':              /* end of args */
 454           if (*s == '\0')
 455             {
 456               /* We are truly done. */
 457               the_insn.opcode = opcode;
 458               return;
 459             }
 460           as_bad ("Too many operands: %s", s);
 461           break;
 462
 463         case ',':               /* Must match a comma */
 464           if (*s++ == ',')
 465             {
 466               s = parse_operand (s, operand);   /* Parse next opnd */
 467               continue;
 468             }
 469           break;
 470
 471         case 'v':               /* Trap numbers (immediate field) */
 472           if (operand->X_op == O_constant)
 473             {
 474               if (operand->X_add_number < 256)
 475                 {
 476                   opcode |= (operand->X_add_number << 16);
 477                   continue;
 478                 }
 479               else
 480                 {
 481                   as_bad ("Immediate value of %ld is too large",
 482                           (long) operand->X_add_number);
 483                   continue;
 484                 }
 485             }
 486           the_insn.reloc = RELOC_8;
 487           the_insn.reloc_offset = 1;    /* BIG-ENDIAN Byte 1 of insn */
 488           the_insn.exp = *operand;
 489           continue;
 490
 491         case 'b':               /* A general register or 8-bit immediate */
 492         case 'i':
 493           /* We treat the two cases identically since we mashed
 494              them together in the opcode table.  */
 495           if (operand->X_op == O_register)
 496             goto general_reg;
 497
 498           /* Make sure the 'i' case really exists.  */
 499           if ((insn->opcode | IMMEDIATE_BIT) != (insn + 1)->opcode)
 500             break;
 501
 502           opcode |= IMMEDIATE_BIT;
 503           if (operand->X_op == O_constant)
 504             {
 505               if (operand->X_add_number < 256)
 506                 {
 507                   opcode |= operand->X_add_number;
 508                   continue;
 509                 }
 510               else
 511                 {
 512                   as_bad ("Immediate value of %ld is too large",
 513                           (long) operand->X_add_number);
 514                   continue;
 515                 }
 516             }
 517           the_insn.reloc = RELOC_8;
 518           the_insn.reloc_offset = 3;    /* BIG-ENDIAN Byte 3 of insn */
 519           the_insn.exp = *operand;
 520           continue;
 521
 522         case 'a':               /* next operand must be a register */
 523         case 'c':
 524         general_reg:
 525           /* lrNNN or grNNN or %%expr or a user-def register name */
 526           if (operand->X_op != O_register)
 527             break;              /* Only registers */
 528           know (operand->X_add_symbol == 0);
 529           know (operand->X_op_symbol == 0);
 530           reg = operand->X_add_number;
 531           if (reg >= SREG)
 532             break;              /* No special registers */
 533
 534           /* Got the register, now figure out where it goes in the
 535              opcode.  */
 536           switch (*args)
 537             {
 538             case 'a':
 539               opcode |= reg << 8;
 540               continue;
 541
 542             case 'b':
 543             case 'i':
 544               opcode |= reg;
 545               continue;
 546
 547             case 'c':
 548               opcode |= reg << 16;
 549               continue;
 550             }
 551           as_fatal ("failed sanity check.");
 552           break;
 553
 554         case 'x':               /* 16 bit constant, zero-extended */
 555         case 'X':               /* 16 bit constant, one-extended */
 556           if (operand->X_op == O_constant)
 557             {
 558               opcode |= (operand->X_add_number & 0xFF) << 0 |
 559                 ((operand->X_add_number & 0xFF00) << 8);
 560               continue;
 561             }
 562           the_insn.reloc = RELOC_CONST;
 563           the_insn.exp = *operand;
 564           continue;
 565
 566         case 'h':
 567           if (operand->X_op == O_constant)
 568             {
 569               opcode |= (operand->X_add_number & 0x00FF0000) >> 16 |
 570                 (((unsigned long) operand->X_add_number
 571                   /* avoid sign ext */  & 0xFF000000) >> 8);
 572               continue;
 573             }
 574           the_insn.reloc = RELOC_CONSTH;
 575           the_insn.exp = *operand;
 576           continue;
 577
 578         case 'P':               /* PC-relative jump address */
 579         case 'A':               /* Absolute jump address */
 580           /* These two are treated together since we folded the
 581              opcode table entries together.  */
 582           if (operand->X_op == O_constant)
 583             {
 584               /* Make sure the 'A' case really exists.  */
 585               if ((insn->opcode | ABSOLUTE_BIT) != (insn + 1)->opcode)
 586                 break;
 587               opcode |= ABSOLUTE_BIT |
 588                 (operand->X_add_number & 0x0003FC00) << 6 |
 589                 ((operand->X_add_number & 0x000003FC) >> 2);
 590               continue;
 591             }
 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;
 598
 599         case 'e':               /* Coprocessor enable bit for LOAD/STORE insn */
 600           if (operand->X_op == O_constant)
 601             {
 602               if (operand->X_add_number == 0)
 603                 continue;
 604               if (operand->X_add_number == 1)
 605                 {
 606                   opcode |= CE_BIT;
 607                   continue;
 608                 }
 609             }
 610           break;
 611
 612         case 'n':               /* Control bits for LOAD/STORE instructions */
 613           if (operand->X_op == O_constant &&
 614               operand->X_add_number < 128)
 615             {
 616               opcode |= (operand->X_add_number << 16);
 617               continue;
 618             }
 619           break;
 620
 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;
 628
 629         case 'u':               /* UI bit of CONVERT */
 630           if (operand->X_op == O_constant)
 631             {
 632               if (operand->X_add_number == 0)
 633                 continue;
 634               if (operand->X_add_number == 1)
 635                 {
 636                   opcode |= UI_BIT;
 637                   continue;
 638                 }
 639             }
 640           break;
 641
 642         case 'r':               /* RND bits of CONVERT */
 643           if (operand->X_op == O_constant &&
 644               operand->X_add_number < 8)
 645             {
 646               opcode |= operand->X_add_number << 4;
 647               continue;
 648             }
 649           break;
 650
 651         case 'd':               /* FD bits of CONVERT */
 652           if (operand->X_op == O_constant &&
 653               operand->X_add_number < 4)
 654             {
 655               opcode |= operand->X_add_number << 2;
 656               continue;
 657             }
 658           break;
 659
 660
 661         case 'f':               /* FS bits of CONVERT */
 662           if (operand->X_op == O_constant &&
 663               operand->X_add_number < 4)
 664             {
 665               opcode |= operand->X_add_number << 0;
 666               continue;
 667             }
 668           break;
 669
 670         case 'C':
 671           if (operand->X_op == O_constant &&
 672               operand->X_add_number < 4)
 673             {
 674               opcode |= operand->X_add_number << 16;
 675               continue;
 676             }
 677           break;
 678
 679         case 'F':
 680           if (operand->X_op == O_constant &&
 681               operand->X_add_number < 16)
 682             {
 683               opcode |= operand->X_add_number << 18;
 684               continue;
 685             }
 686           break;
 687
 688         default:
 689           BAD_CASE (*args);
 690         }
 691       /* Types or values of args don't match.  */
 692       as_bad ("Invalid operands");
 693       return;
 694     }
 695 }
 696
 697 /* This is identical to the md_atof in m68k.c.  I think this is right,
 698    but I'm not sure.
 699
 700    Turn a string in input_line_pointer into a floating point constant
 701    of type type, and store the appropriate bytes in *litP.  The number
 702    of LITTLENUMS emitted is stored in *sizeP .  An error message is
 703    returned, or NULL on OK.  */
 704
 705 /* Equal to MAX_PRECISION in atof-ieee.c */
 706 #define MAX_LITTLENUMS 6
 707
 708 char *
 709 md_atof (type, litP, sizeP)
 710      char type;
 711      char *litP;
 712      int *sizeP;
 713 {
 714   int prec;
 715   LITTLENUM_TYPE words[MAX_LITTLENUMS];
 716   LITTLENUM_TYPE *wordP;
 717   char *t;
 718
 719   switch (type)
 720     {
 721
 722     case 'f':
 723     case 'F':
 724     case 's':
 725     case 'S':
 726       prec = 2;
 727       break;
 728
 729     case 'd':
 730     case 'D':
 731     case 'r':
 732     case 'R':
 733       prec = 4;
 734       break;
 735
 736     case 'x':
 737     case 'X':
 738       prec = 6;
 739       break;
 740
 741     case 'p':
 742     case 'P':
 743       prec = 6;
 744       break;
 745
 746     default:
 747       *sizeP = 0;
 748       return "Bad call to MD_ATOF()";
 749     }
 750   t = atof_ieee (input_line_pointer, type, words);
 751   if (t)
 752     input_line_pointer = t;
 753   *sizeP = prec * sizeof (LITTLENUM_TYPE);
 754   for (wordP = words; prec--;)
 755     {
 756       md_number_to_chars (litP, (valueT) (*wordP++), sizeof (LITTLENUM_TYPE));
 757       litP += sizeof (LITTLENUM_TYPE);
 758     }
 759   return 0;
 760 }
 761
 762 /*
 763  * Write out big-endian.
 764  */
 765 void
 766 md_number_to_chars (buf, val, n)
 767      char *buf;
 768      valueT val;
 769      int n;
 770 {
 771   number_to_chars_bigendian (buf, val, n);
 772 }
 773
 774 void
 775 md_apply_fix (fixP, val)
 776      fixS *fixP;
 777      long val;
 778 {
 779   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
 780
 781   fixP->fx_addnumber = val;     /* Remember value for emit_reloc */
 782
 783
 784   know (fixP->fx_size == 4);
 785   know (fixP->fx_r_type < NO_RELOC);
 786
 787   /* This is a hack.  There should be a better way to handle this.  */
 788   if (fixP->fx_r_type == RELOC_WDISP30 && fixP->fx_addsy)
 789     {
 790       val += fixP->fx_where + fixP->fx_frag->fr_address;
 791     }
 792
 793   switch (fixP->fx_r_type)
 794     {
 795
 796     case RELOC_32:
 797       buf[0] = val >> 24;
 798       buf[1] = val >> 16;
 799       buf[2] = val >> 8;
 800       buf[3] = val;
 801       break;
 802
 803     case RELOC_8:
 804       buf[0] = val;
 805       break;
 806
 807     case RELOC_WDISP30:
 808       val = (val >>= 2) + 1;
 809       buf[0] |= (val >> 24) & 0x3f;
 810       buf[1] = (val >> 16);
 811       buf[2] = val >> 8;
 812       buf[3] = val;
 813       break;
 814
 815     case RELOC_HI22:
 816       buf[1] |= (val >> 26) & 0x3f;
 817       buf[2] = val >> 18;
 818       buf[3] = val >> 10;
 819       break;
 820
 821     case RELOC_LO10:
 822       buf[2] |= (val >> 8) & 0x03;
 823       buf[3] = val;
 824       break;
 825
 826     case RELOC_BASE13:
 827       buf[2] |= (val >> 8) & 0x1f;
 828       buf[3] = val;
 829       break;
 830
 831     case RELOC_WDISP22:
 832       val = (val >>= 2) + 1;
 833       /* FALLTHROUGH */
 834     case RELOC_BASE22:
 835       buf[1] |= (val >> 16) & 0x3f;
 836       buf[2] = val >> 8;
 837       buf[3] = val;
 838       break;
 839
 840 #if 0
 841     case RELOC_PC10:
 842     case RELOC_PC22:
 843     case RELOC_JMP_TBL:
 844     case RELOC_SEGOFF16:
 845     case RELOC_GLOB_DAT:
 846     case RELOC_JMP_SLOT:
 847     case RELOC_RELATIVE:
 848 #endif
 849     case RELOC_JUMPTARG:        /* 00XX00XX pattern in a word */
 850       buf[1] = val >> 10;       /* Holds bits 0003FFFC of address */
 851       buf[3] = val >> 2;
 852       break;
 853
 854     case RELOC_CONST:           /* 00XX00XX pattern in a word */
 855       buf[1] = val >> 8;        /* Holds bits 0000XXXX */
 856       buf[3] = val;
 857       break;
 858
 859     case RELOC_CONSTH:          /* 00XX00XX pattern in a word */
 860       buf[1] = val >> 24;       /* Holds bits XXXX0000 */
 861       buf[3] = val >> 16;
 862       break;
 863
 864     case NO_RELOC:
 865     default:
 866       as_bad ("bad relocation type: 0x%02x", fixP->fx_r_type);
 867       break;
 868     }
 869 }
 870
 871 #ifdef OBJ_COFF
 872 short
 873 tc_coff_fix2rtype (fixP)
 874      fixS *fixP;
 875 {
 876
 877   switch (fixP->fx_r_type)
 878     {
 879     case RELOC_32:
 880       return (R_WORD);
 881     case RELOC_8:
 882       return (R_BYTE);
 883     case RELOC_CONST:
 884       return (R_ILOHALF);
 885     case RELOC_CONSTH:
 886       return (R_IHIHALF);
 887     case RELOC_JUMPTARG:
 888       return (R_IREL);
 889     default:
 890       printf ("need %o3\n", fixP->fx_r_type);
 891       abort ();
 892     }                           /* switch on type */
 893
 894   return (0);
 895 }
 896
 897 #endif /* OBJ_COFF */
 898
 899 /* should never be called for 29k */
 900 void
 901 md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
 902      char *ptr;
 903      addressT from_addr, to_addr;
 904      fragS *frag;
 905      symbolS *to_symbol;
 906 {
 907   as_fatal ("a29k_create_short_jmp\n");
 908 }
 909
 910 /* should never be called for 29k */
 911 void
 912 md_convert_frag (headers, fragP)
 913      object_headers *headers;
 914      register fragS *fragP;
 915 {
 916   as_fatal ("a29k_convert_frag\n");
 917 }
 918
 919 /* should never be called for 29k */
 920 void
 921 md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
 922      char *ptr;
 923      addressT from_addr;
 924      addressT to_addr;
 925      fragS *frag;
 926      symbolS *to_symbol;
 927 {
 928   as_fatal ("a29k_create_long_jump\n");
 929 }
 930
 931 /* should never be called for a29k */
 932 int
 933 md_estimate_size_before_relax (fragP, segtype)
 934      register fragS *fragP;
 935      segT segtype;
 936 {
 937   as_fatal ("a29k_estimate_size_before_relax\n");
 938   return 0;
 939 }
 940
 941 #if 0
 942 /* for debugging only */
 943 static void
 944 print_insn (insn)
 945      struct machine_it *insn;
 946 {
 947   char *Reloc[] =
 948   {
 949     "RELOC_8",
 950     "RELOC_16",
 951     "RELOC_32",
 952     "RELOC_DISP8",
 953     "RELOC_DISP16",
 954     "RELOC_DISP32",
 955     "RELOC_WDISP30",
 956     "RELOC_WDISP22",
 957     "RELOC_HI22",
 958     "RELOC_22",
 959     "RELOC_13",
 960     "RELOC_LO10",
 961     "RELOC_SFA_BASE",
 962     "RELOC_SFA_OFF13",
 963     "RELOC_BASE10",
 964     "RELOC_BASE13",
 965     "RELOC_BASE22",
 966     "RELOC_PC10",
 967     "RELOC_PC22",
 968     "RELOC_JMP_TBL",
 969     "RELOC_SEGOFF16",
 970     "RELOC_GLOB_DAT",
 971     "RELOC_JMP_SLOT",
 972     "RELOC_RELATIVE",
 973     "NO_RELOC"
 974   };
 975
 976   if (insn->error)
 977     {
 978       fprintf (stderr, "ERROR: %s\n");
 979     }
 980   fprintf (stderr, "opcode=0x%08x\n", insn->opcode);
 981   fprintf (stderr, "reloc = %s\n", Reloc[insn->reloc]);
 982   fprintf (stderr, "exp =  {\n");
 983   fprintf (stderr, "\t\tX_add_symbol = %s\n",
 984            insn->exp.X_add_symbol ?
 985            (S_GET_NAME (insn->exp.X_add_symbol) ?
 986             S_GET_NAME (insn->exp.X_add_symbol) : "???") : "0");
 987   fprintf (stderr, "\t\tX_op_symbol = %s\n",
 988            insn->exp.X_op_symbol ?
 989            (S_GET_NAME (insn->exp.X_op_symbol) ?
 990             S_GET_NAME (insn->exp.X_op_symbol) : "???") : "0");
 991   fprintf (stderr, "\t\tX_add_number = %d\n",
 992            insn->exp.X_add_number);
 993   fprintf (stderr, "}\n");
 994 }
 995
 996 #endif
 997
 998 /* Translate internal representation of relocation info to target format.
 999
1000    On sparc/29k: first 4 bytes are normal unsigned long address, next three
1001    bytes are index, most sig. byte first.  Byte 7 is broken up with
1002    bit 7 as external, bits 6 & 5 unused, and the lower
1003    five bits as relocation type.  Next 4 bytes are long addend. */
1004 /* Thanx and a tip of the hat to Michael Bloom, [email protected] */
1005
1006 #ifdef OBJ_AOUT
1007
1008 void
1009 tc_aout_fix_to_chars (where, fixP, segment_address_in_file)
1010      char *where;
1011      fixS *fixP;
1012      relax_addressT segment_address_in_file;
1013 {
1014   long r_symbolnum;
1015
1016   know (fixP->fx_r_type < NO_RELOC);
1017   know (fixP->fx_addsy != NULL);
1018
1019   md_number_to_chars (where,
1020        fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file,
1021                       4);
1022
1023   r_symbolnum = (S_IS_DEFINED (fixP->fx_addsy)
1024                  ? S_GET_TYPE (fixP->fx_addsy)
1025                  : fixP->fx_addsy->sy_number);
1026
1027   where[4] = (r_symbolnum >> 16) & 0x0ff;
1028   where[5] = (r_symbolnum >> 8) & 0x0ff;
1029   where[6] = r_symbolnum & 0x0ff;
1030   where[7] = (((!S_IS_DEFINED (fixP->fx_addsy)) << 7) & 0x80) | (0 & 0x60) | (fixP->fx_r_type & 0x1F);
1031   /* Also easy */
1032   md_number_to_chars (&where[8], fixP->fx_addnumber, 4);
1033 }
1034
1035 #endif /* OBJ_AOUT */
1036
1037 int
1038 md_parse_option (argP, cntP, vecP)
1039      char **argP;
1040      int *cntP;
1041      char ***vecP;
1042 {
1043   return 0;
1044 }
1045
1046
1047 /* Default the values of symbols known that should be "predefined".  We
1048    don't bother to predefine them unless you actually use one, since there
1049    are a lot of them.  */
1050
1051 symbolS *
1052 md_undefined_symbol (name)
1053      char *name;
1054 {
1055   long regnum;
1056   char testbuf[5 + /*SLOP*/ 5];
1057
1058   if (name[0] == 'g' || name[0] == 'G' || name[0] == 'l' || name[0] == 'L')
1059     {
1060       /* Perhaps a global or local register name */
1061       if (name[1] == 'r' || name[1] == 'R')
1062         {
1063           /* Parse the number, make sure it has no extra zeroes or trailing
1064                                    chars */
1065           regnum = atol (&name[2]);
1066           if (regnum > 127)
1067             return 0;
1068           sprintf (testbuf, "%ld", regnum);
1069           if (strcmp (testbuf, &name[2]) != 0)
1070             return 0;           /* gr007 or lr7foo or whatever */
1071
1072           /* We have a wiener!  Define and return a new symbol for it.  */
1073           if (name[0] == 'l' || name[0] == 'L')
1074             regnum += 128;
1075           return (symbol_new (name, SEG_REGISTER, (valueT) regnum,
1076                               &zero_address_frag));
1077         }
1078     }
1079
1080   return 0;
1081 }
1082
1083 /* Parse an operand that is machine-specific.  */
1084
1085 void
1086 md_operand (expressionP)
1087      expressionS *expressionP;
1088 {
1089
1090   if (input_line_pointer[0] == '%' && input_line_pointer[1] == '%')
1091     {
1092       /* We have a numeric register expression.  No biggy.  */
1093       input_line_pointer += 2;  /* Skip %% */
1094       (void) expression (expressionP);
1095       if (expressionP->X_op != O_constant
1096           || expressionP->X_add_number > 255)
1097         as_bad ("Invalid expression after %%%%\n");
1098       expressionP->X_op = O_register;
1099     }
1100   else if (input_line_pointer[0] == '&')
1101     {
1102       /* We are taking the 'address' of a register...this one is not
1103          in the manual, but it *is* in traps/fpsymbol.h!  What they
1104          seem to want is the register number, as an absolute number.  */
1105       input_line_pointer++;     /* Skip & */
1106       (void) expression (expressionP);
1107       if (expressionP->X_op != O_register)
1108         as_bad ("Invalid register in & expression");
1109       else
1110         expressionP->X_op = O_constant;
1111     }
1112 }
1113
1114 /* Round up a section size to the appropriate boundary.  */
1115 valueT
1116 md_section_align (segment, size)
1117      segT segment;
1118      valueT size;
1119 {
1120   return size;                  /* Byte alignment is fine */
1121 }
1122
1123 /* Exactly what point is a PC-relative offset relative TO?
1124    On the 29000, they're relative to the address of the instruction,
1125    which we have set up as the address of the fixup too.  */
1126 long
1127 md_pcrel_from (fixP)
1128      fixS *fixP;
1129 {
1130   return fixP->fx_where + fixP->fx_frag->fr_address;
1131 }
1132
1133 /* end of tc-a29k.c */