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