gas/config/tc-a29k.c

   1 /* tc-a29k.c -- Assemble for the AMD 29000.
   2    Copyright 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1998, 2000, 2001, 2002
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GAS, the GNU Assembler.
   6
   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.
  11
  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.
  16
  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.  */
  21
  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.  */
  25
  26 #include "as.h"
  27 #include "safe-ctype.h"
  28
  29 #include "opcode/a29k.h"
  30
  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
  36
  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 */
  41
  42 /* handle of the OPCODE hash table */
  43 static struct hash_control *op_hash = NULL;
  44
  45 struct machine_it
  46   {
  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 */
  53
  54     int reloc;
  55   }
  56 the_insn;
  57
  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
  64 static void insert_sreg PARAMS ((char *, int));
  65 static void define_some_regs PARAMS ((void));
  66 static char *parse_operand PARAMS ((char *, expressionS *, int));
  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 #if defined(BFD_HEADERS)
  86 #ifdef RELSZ
  87 const int md_reloc_size = RELSZ;        /* Coff headers */
  88 #else
  89 const int md_reloc_size = 12;           /* something else headers */
  90 #endif
  91 #else
  92 const int md_reloc_size = 12;           /* Not bfdized*/
  93 #endif
  94
  95 /* This array holds the chars that always start a comment.  If the
  96    pre-processor is disabled, these aren't very useful */
  97 const char comment_chars[] = ";";
  98
  99 /* This array holds the chars that only start a comment at the beginning of
 100    a line.  If the line seems to have the form '# 123 filename'
 101    .line and .file directives will appear in the pre-processed output */
 102 /* Note that input_file.c hand checks for '#' at the beginning of the
 103    first line of the input file.  This is because the compiler outputs
 104    #NO_APP at the beginning of its output.  */
 105 /* Also note that comments like this one will always work */
 106 const char line_comment_chars[] = "#";
 107
 108 /* We needed an unused char for line separation to work around the
 109    lack of macros, using sed and such.  */
 110 const char line_separator_chars[] = "@";
 111
 112 /* Chars that can be used to separate mant from exp in floating point nums */
 113 const char EXP_CHARS[] = "eE";
 114
 115 /* Chars that mean this number is a floating point constant */
 116 /* As in 0f12.456 */
 117 /* or    0d1.2345e12 */
 118 const char FLT_CHARS[] = "rRsSfFdDxXpP";
 119
 120 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
 121    changed in read.c.  Ideally it shouldn't have to know about it at
 122    all, but nothing is ideal around here.  */
 123
 124 /*
 125  *  anull bit - causes the branch delay slot instructions to not be executed
 126  */
 127 #define ANNUL       (1 << 29)
 128
 129 #ifndef OBJ_COFF
 130
 131 static void
 132 s_use (ignore)
 133      int ignore;
 134 {
 135   if (strncmp (input_line_pointer, ".text", 5) == 0)
 136     {
 137       input_line_pointer += 5;
 138       s_text (0);
 139       return;
 140     }
 141   if (strncmp (input_line_pointer, ".data", 5) == 0)
 142     {
 143       input_line_pointer += 5;
 144       s_data (0);
 145       return;
 146     }
 147   if (strncmp (input_line_pointer, ".data1", 6) == 0)
 148     {
 149       input_line_pointer += 6;
 150       s_data1 ();
 151       return;
 152     }
 153   /* Literals can't go in the text segment because you can't read from
 154      instruction memory on some 29k's.  So, into initialized data.  */
 155   if (strncmp (input_line_pointer, ".lit", 4) == 0)
 156     {
 157       input_line_pointer += 4;
 158       subseg_set (SEG_DATA, 200);
 159       demand_empty_rest_of_line ();
 160       return;
 161     }
 162
 163   as_bad (_("Unknown segment type"));
 164   demand_empty_rest_of_line ();
 165 }
 166
 167 static void
 168 s_data1 ()
 169 {
 170   subseg_set (SEG_DATA, 1);
 171   demand_empty_rest_of_line ();
 172 }
 173
 174 #endif /* OBJ_COFF */
 175
 176 /* Install symbol definition that maps REGNAME to REGNO.
 177    FIXME-SOON:  These are not recognized in mixed case.  */
 178
 179 static void
 180 insert_sreg (regname, regnum)
 181      char *regname;
 182      int regnum;
 183 {
 184   /* FIXME-SOON, put something in these syms so they won't be output
 185      to the symbol table of the resulting object file.  */
 186
 187   /* Must be large enough to hold the names of the special registers.  */
 188   char buf[80];
 189   int i;
 190
 191   symbol_table_insert (symbol_new (regname, SEG_REGISTER, (valueT) regnum,
 192                                    &zero_address_frag));
 193   for (i = 0; regname[i]; i++)
 194     buf[i] = TOUPPER (regname[i]);
 195   buf[i] = '\0';
 196
 197   symbol_table_insert (symbol_new (buf, SEG_REGISTER, (valueT) regnum,
 198                                    &zero_address_frag));
 199 }
 200
 201 /* Install symbol definitions for assorted special registers.
 202    See ASM29K Ref page 2-9.  */
 203
 204 static void
 205 define_some_regs ()
 206 {
 207 #define SREG    256
 208
 209   /* Protected special-purpose register names */
 210   insert_sreg ("vab", SREG + 0);
 211   insert_sreg ("ops", SREG + 1);
 212   insert_sreg ("cps", SREG + 2);
 213   insert_sreg ("cfg", SREG + 3);
 214   insert_sreg ("cha", SREG + 4);
 215   insert_sreg ("chd", SREG + 5);
 216   insert_sreg ("chc", SREG + 6);
 217   insert_sreg ("rbp", SREG + 7);
 218   insert_sreg ("tmc", SREG + 8);
 219   insert_sreg ("tmr", SREG + 9);
 220   insert_sreg ("pc0", SREG + 10);
 221   insert_sreg ("pc1", SREG + 11);
 222   insert_sreg ("pc2", SREG + 12);
 223   insert_sreg ("mmu", SREG + 13);
 224   insert_sreg ("lru", SREG + 14);
 225
 226   /* Additional protected special-purpose registers for the 29050 */
 227   insert_sreg ("rsn",  SREG + 15);
 228   insert_sreg ("rma0", SREG + 16);
 229   insert_sreg ("rmc0", SREG + 17);
 230   insert_sreg ("rma1", SREG + 18);
 231   insert_sreg ("rmc1", SREG + 19);
 232   insert_sreg ("spc0", SREG + 20);
 233   insert_sreg ("spc1", SREG + 21);
 234   insert_sreg ("spc2", SREG + 22);
 235   insert_sreg ("iba0", SREG + 23);
 236   insert_sreg ("ibc0", SREG + 24);
 237   insert_sreg ("iba1", SREG + 25);
 238   insert_sreg ("ibc1", SREG + 26);
 239
 240   /* Additional registers for the 29040.  */
 241   insert_sreg ("dba", SREG + 27);
 242   insert_sreg ("dbc", SREG + 28);
 243   insert_sreg ("cir", SREG + 29);
 244   insert_sreg ("cdr", SREG + 30);
 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   define_some_regs ();
 336 }
 337
 338 /* Assemble a single instruction.  Its label has already been handled
 339    by the generic front end.  We just parse opcode and operands, and
 340    produce the bytes of data and relocation.  */
 341
 342 void
 343 md_assemble (str)
 344      char *str;
 345 {
 346   char *toP;
 347
 348   know (str);
 349   machine_ip (str);
 350   toP = frag_more (4);
 351   /* put out the opcode */
 352   md_number_to_chars (toP, the_insn.opcode, 4);
 353
 354   /* put out the symbol-dependent stuff */
 355   if (the_insn.reloc != NO_RELOC)
 356     {
 357       fix_new_exp (frag_now,
 358                    (toP - frag_now->fr_literal + the_insn.reloc_offset),
 359                    4,           /* size */
 360                    &the_insn.exp,
 361                    the_insn.pcrel,
 362                    the_insn.reloc);
 363     }
 364 }
 365
 366 static char *
 367 parse_operand (s, operandp, opt)
 368      char *s;
 369      expressionS *operandp;
 370      int opt;
 371 {
 372   char *save = input_line_pointer;
 373   char *new;
 374
 375   input_line_pointer = s;
 376   expression (operandp);
 377   if (operandp->X_op == O_absent && ! opt)
 378     as_bad (_("missing operand"));
 379   new = input_line_pointer;
 380   input_line_pointer = save;
 381   return new;
 382 }
 383
 384 /* Instruction parsing.  Takes a string containing the opcode.
 385    Operands are at input_line_pointer.  Output is in the_insn.
 386    Warnings or errors are generated.  */
 387
 388 static void
 389 machine_ip (str)
 390      char *str;
 391 {
 392   char *s;
 393   const char *args;
 394   struct machine_opcode *insn;
 395   char *argsStart;
 396   unsigned long opcode;
 397   expressionS the_operand;
 398   expressionS *operand = &the_operand;
 399   unsigned int reg;
 400
 401   /* Must handle `div0' opcode.  */
 402   s = str;
 403   if (ISALPHA (*s))
 404     for (; ISALNUM (*s); ++s)
 405       *s = TOLOWER (*s);
 406
 407   switch (*s)
 408     {
 409     case '\0':
 410       break;
 411
 412     case ' ':                   /* FIXME-SOMEDAY more whitespace */
 413       *s++ = '\0';
 414       break;
 415
 416     default:
 417       as_bad (_("Unknown opcode: `%s'"), str);
 418       return;
 419     }
 420   if ((insn = (struct machine_opcode *) hash_find (op_hash, str)) == NULL)
 421     {
 422       as_bad (_("Unknown opcode `%s'."), str);
 423       return;
 424     }
 425   argsStart = s;
 426   opcode = insn->opcode;
 427   memset (&the_insn, '\0', sizeof (the_insn));
 428   the_insn.reloc = NO_RELOC;
 429
 430   /* Build the opcode, checking as we go to make sure that the
 431      operands match.
 432
 433      If an operand matches, we modify the_insn or opcode appropriately,
 434      and do a "continue".  If an operand fails to match, we "break".  */
 435
 436   if (insn->args[0] != '\0')
 437     {
 438       /* Prime the pump.  */
 439       s = parse_operand (s, operand, insn->args[0] == 'I');
 440     }
 441
 442   for (args = insn->args;; ++args)
 443     {
 444       switch (*args)
 445         {
 446
 447         case '\0':              /* end of args */
 448           if (*s == '\0')
 449             {
 450               /* We are truly done.  */
 451               the_insn.opcode = opcode;
 452               return;
 453             }
 454           as_bad (_("Too many operands: %s"), s);
 455           break;
 456
 457         case ',':               /* Must match a comma */
 458           if (*s++ == ',')
 459             {
 460               /* Parse next operand.  */
 461               s = parse_operand (s, operand, args[1] == 'I');
 462               continue;
 463             }
 464           break;
 465
 466         case 'v':               /* Trap numbers (immediate field) */
 467           if (operand->X_op == O_constant)
 468             {
 469               if (operand->X_add_number < 256)
 470                 {
 471                   opcode |= (operand->X_add_number << 16);
 472                   continue;
 473                 }
 474               else
 475                 {
 476                   as_bad (_("Immediate value of %ld is too large"),
 477                           (long) operand->X_add_number);
 478                   continue;
 479                 }
 480             }
 481           the_insn.reloc = RELOC_8;
 482           the_insn.reloc_offset = 1;    /* BIG-ENDIAN Byte 1 of insn */
 483           the_insn.exp = *operand;
 484           continue;
 485
 486         case 'b':               /* A general register or 8-bit immediate */
 487         case 'i':
 488           /* We treat the two cases identically since we mashed
 489              them together in the opcode table.  */
 490           if (operand->X_op == O_register)
 491             goto general_reg;
 492
 493           /* Make sure the 'i' case really exists.  */
 494           if ((insn->opcode | IMMEDIATE_BIT) != (insn + 1)->opcode)
 495             break;
 496
 497           opcode |= IMMEDIATE_BIT;
 498           if (operand->X_op == O_constant)
 499             {
 500               if (operand->X_add_number < 256)
 501                 {
 502                   opcode |= operand->X_add_number;
 503                   continue;
 504                 }
 505               else
 506                 {
 507                   as_bad (_("Immediate value of %ld is too large"),
 508                           (long) operand->X_add_number);
 509                   continue;
 510                 }
 511             }
 512           the_insn.reloc = RELOC_8;
 513           the_insn.reloc_offset = 3;    /* BIG-ENDIAN Byte 3 of insn */
 514           the_insn.exp = *operand;
 515           continue;
 516
 517         case 'a':               /* next operand must be a register */
 518         case 'c':
 519         general_reg:
 520           /* lrNNN or grNNN or %%expr or a user-def register name */
 521           if (operand->X_op != O_register)
 522             break;              /* Only registers */
 523           know (operand->X_add_symbol == 0);
 524           know (operand->X_op_symbol == 0);
 525           reg = operand->X_add_number;
 526           if (reg >= SREG)
 527             break;              /* No special registers */
 528
 529           /* Got the register, now figure out where it goes in the
 530              opcode.  */
 531           switch (*args)
 532             {
 533             case 'a':
 534               opcode |= reg << 8;
 535               continue;
 536
 537             case 'b':
 538             case 'i':
 539               opcode |= reg;
 540               continue;
 541
 542             case 'c':
 543               opcode |= reg << 16;
 544               continue;
 545             }
 546           as_fatal (_("failed sanity check."));
 547           break;
 548
 549         case 'x':               /* 16 bit constant, zero-extended */
 550         case 'X':               /* 16 bit constant, one-extended */
 551           if (operand->X_op == O_constant)
 552             {
 553               opcode |= (operand->X_add_number & 0xFF) << 0 |
 554                 ((operand->X_add_number & 0xFF00) << 8);
 555               continue;
 556             }
 557           the_insn.reloc = RELOC_CONST;
 558           the_insn.exp = *operand;
 559           continue;
 560
 561         case 'h':
 562           if (operand->X_op == O_constant)
 563             {
 564               opcode |= (operand->X_add_number & 0x00FF0000) >> 16 |
 565                 (((unsigned long) operand->X_add_number
 566                   /* avoid sign ext */  & 0xFF000000) >> 8);
 567               continue;
 568             }
 569           the_insn.reloc = RELOC_CONSTH;
 570           the_insn.exp = *operand;
 571           continue;
 572
 573         case 'P':               /* PC-relative jump address */
 574         case 'A':               /* Absolute jump address */
 575           /* These two are treated together since we folded the
 576              opcode table entries together.  */
 577           if (operand->X_op == O_constant)
 578             {
 579               /* Make sure the 'A' case really exists.  */
 580               if ((insn->opcode | ABSOLUTE_BIT) != (insn + 1)->opcode)
 581                 break;
 582               {
 583                 bfd_vma v, mask;
 584                 mask = 0x1ffff;
 585                 v = operand->X_add_number & ~ mask;
 586                 if (v)
 587                   as_bad ("call/jmp target out of range");
 588               }
 589               opcode |= ABSOLUTE_BIT |
 590                 (operand->X_add_number & 0x0003FC00) << 6 |
 591                 ((operand->X_add_number & 0x000003FC) >> 2);
 592               continue;
 593             }
 594           the_insn.reloc = RELOC_JUMPTARG;
 595           the_insn.exp = *operand;
 596           the_insn.pcrel = 1;   /* Assume PC-relative jump */
 597           /* FIXME-SOON, Do we figure out whether abs later, after
 598              know sym val? */
 599           continue;
 600
 601         case 'e':               /* Coprocessor enable bit for LOAD/STORE insn */
 602           if (operand->X_op == O_constant)
 603             {
 604               if (operand->X_add_number == 0)
 605                 continue;
 606               if (operand->X_add_number == 1)
 607                 {
 608                   opcode |= CE_BIT;
 609                   continue;
 610                 }
 611             }
 612           break;
 613
 614         case 'n':               /* Control bits for LOAD/STORE instructions */
 615           if (operand->X_op == O_constant &&
 616               operand->X_add_number < 128)
 617             {
 618               opcode |= (operand->X_add_number << 16);
 619               continue;
 620             }
 621           break;
 622
 623         case 's':               /* Special register number */
 624           if (operand->X_op != O_register)
 625             break;              /* Only registers */
 626           if (operand->X_add_number < SREG)
 627             break;              /* Not a special register */
 628           opcode |= (operand->X_add_number & 0xFF) << 8;
 629           continue;
 630
 631         case 'u':               /* UI bit of CONVERT */
 632           if (operand->X_op == O_constant)
 633             {
 634               if (operand->X_add_number == 0)
 635                 continue;
 636               if (operand->X_add_number == 1)
 637                 {
 638                   opcode |= UI_BIT;
 639                   continue;
 640                 }
 641             }
 642           break;
 643
 644         case 'r':               /* RND bits of CONVERT */
 645           if (operand->X_op == O_constant &&
 646               operand->X_add_number < 8)
 647             {
 648               opcode |= operand->X_add_number << 4;
 649               continue;
 650             }
 651           break;
 652
 653         case 'I':               /* ID bits of INV and IRETINV.  */
 654           /* This operand is optional.  */
 655           if (operand->X_op == O_absent)
 656             continue;
 657           else if (operand->X_op == O_constant
 658                    && operand->X_add_number < 4)
 659             {
 660               opcode |= operand->X_add_number << 16;
 661               continue;
 662             }
 663           break;
 664
 665         case 'd':               /* FD bits of CONVERT */
 666           if (operand->X_op == O_constant &&
 667               operand->X_add_number < 4)
 668             {
 669               opcode |= operand->X_add_number << 2;
 670               continue;
 671             }
 672           break;
 673
 674         case 'f':               /* FS bits of CONVERT */
 675           if (operand->X_op == O_constant &&
 676               operand->X_add_number < 4)
 677             {
 678               opcode |= operand->X_add_number << 0;
 679               continue;
 680             }
 681           break;
 682
 683         case 'C':
 684           if (operand->X_op == O_constant &&
 685               operand->X_add_number < 4)
 686             {
 687               opcode |= operand->X_add_number << 16;
 688               continue;
 689             }
 690           break;
 691
 692         case 'F':
 693           if (operand->X_op == O_constant &&
 694               operand->X_add_number < 16)
 695             {
 696               opcode |= operand->X_add_number << 18;
 697               continue;
 698             }
 699           break;
 700
 701         default:
 702           BAD_CASE (*args);
 703         }
 704       /* Types or values of args don't match.  */
 705       as_bad ("Invalid operands");
 706       return;
 707     }
 708 }
 709
 710 /* This is identical to the md_atof in m68k.c.  I think this is right,
 711    but I'm not sure.
 712
 713    Turn a string in input_line_pointer into a floating point constant
 714    of type TYPE, and store the appropriate bytes in *LITP.  The number
 715    of LITTLENUMS emitted is stored in *SIZEP.  An error message is
 716    returned, or NULL on OK.  */
 717
 718 /* Equal to MAX_PRECISION in atof-ieee.c */
 719 #define MAX_LITTLENUMS 6
 720
 721 char *
 722 md_atof (type, litP, sizeP)
 723      char type;
 724      char *litP;
 725      int *sizeP;
 726 {
 727   int prec;
 728   LITTLENUM_TYPE words[MAX_LITTLENUMS];
 729   LITTLENUM_TYPE *wordP;
 730   char *t;
 731
 732   switch (type)
 733     {
 734
 735     case 'f':
 736     case 'F':
 737     case 's':
 738     case 'S':
 739       prec = 2;
 740       break;
 741
 742     case 'd':
 743     case 'D':
 744     case 'r':
 745     case 'R':
 746       prec = 4;
 747       break;
 748
 749     case 'x':
 750     case 'X':
 751       prec = 6;
 752       break;
 753
 754     case 'p':
 755     case 'P':
 756       prec = 6;
 757       break;
 758
 759     default:
 760       *sizeP = 0;
 761       return "Bad call to MD_ATOF()";
 762     }
 763   t = atof_ieee (input_line_pointer, type, words);
 764   if (t)
 765     input_line_pointer = t;
 766   *sizeP = prec * sizeof (LITTLENUM_TYPE);
 767   for (wordP = words; prec--;)
 768     {
 769       md_number_to_chars (litP, (valueT) (*wordP++), sizeof (LITTLENUM_TYPE));
 770       litP += sizeof (LITTLENUM_TYPE);
 771     }
 772   return 0;
 773 }
 774
 775 /*
 776  * Write out big-endian.
 777  */
 778 void
 779 md_number_to_chars (buf, val, n)
 780      char *buf;
 781      valueT val;
 782      int n;
 783 {
 784   number_to_chars_bigendian (buf, val, n);
 785 }
 786
 787 void
 788 md_apply_fix3 (fixP, valP, seg)
 789      fixS *fixP;
 790      valueT * valP;
 791      segT seg ATTRIBUTE_UNUSED;
 792 {
 793   long val = *valP;
 794   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
 795
 796   fixP->fx_addnumber = val;     /* Remember value for emit_reloc.  */
 797
 798   know (fixP->fx_size == 4);
 799   know (fixP->fx_r_type < NO_RELOC);
 800
 801   /* This is a hack.  There should be a better way to handle this.  */
 802   if (fixP->fx_r_type == RELOC_WDISP30 && fixP->fx_addsy)
 803     val += fixP->fx_where + fixP->fx_frag->fr_address;
 804
 805   switch (fixP->fx_r_type)
 806     {
 807     case RELOC_32:
 808       buf[0] = val >> 24;
 809       buf[1] = val >> 16;
 810       buf[2] = val >> 8;
 811       buf[3] = val;
 812       break;
 813
 814     case RELOC_8:
 815       buf[0] = val;
 816       break;
 817
 818     case RELOC_WDISP30:
 819       val = (val >> 2) + 1;
 820       buf[0] |= (val >> 24) & 0x3f;
 821       buf[1] = (val >> 16);
 822       buf[2] = val >> 8;
 823       buf[3] = val;
 824       break;
 825
 826     case RELOC_HI22:
 827       buf[1] |= (val >> 26) & 0x3f;
 828       buf[2] = val >> 18;
 829       buf[3] = val >> 10;
 830       break;
 831
 832     case RELOC_LO10:
 833       buf[2] |= (val >> 8) & 0x03;
 834       buf[3] = val;
 835       break;
 836
 837     case RELOC_BASE13:
 838       buf[2] |= (val >> 8) & 0x1f;
 839       buf[3] = val;
 840       break;
 841
 842     case RELOC_WDISP22:
 843       val = (val >> 2) + 1;
 844       /* FALLTHROUGH */
 845     case RELOC_BASE22:
 846       buf[1] |= (val >> 16) & 0x3f;
 847       buf[2] = val >> 8;
 848       buf[3] = val;
 849       break;
 850
 851     case RELOC_JUMPTARG:        /* 00XX00XX pattern in a word */
 852       if (!fixP->fx_done)
 853         {
 854           /* The linker tries to support both AMD and old GNU style
 855              R_IREL relocs.  That means that if the addend is exactly
 856              the negative of the address within the section, the
 857              linker will not handle it correctly.  */
 858           if (fixP->fx_pcrel
 859               && val != 0
 860               && val == - (fixP->fx_frag->fr_address + fixP->fx_where))
 861             as_bad_where
 862               (fixP->fx_file, fixP->fx_line,
 863                "the linker will not handle this relocation correctly");
 864         }
 865       else if (fixP->fx_pcrel)
 866         {
 867           long v = val >> 17;
 868
 869           if (v != 0 && v != -1)
 870             as_bad_where (fixP->fx_file, fixP->fx_line,
 871                           "call/jmp target out of range");
 872         }
 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;
 879
 880     case RELOC_CONST:           /* 00XX00XX pattern in a word */
 881       buf[1] = val >> 8;        /* Holds bits 0000XXXX */
 882       buf[3] = val;
 883       break;
 884
 885     case RELOC_CONSTH:          /* 00XX00XX pattern in a word */
 886       buf[1] = val >> 24;       /* Holds bits XXXX0000 */
 887       buf[3] = val >> 16;
 888       break;
 889
 890     case NO_RELOC:
 891     default:
 892       as_bad (_("bad relocation type: 0x%02x"), fixP->fx_r_type);
 893       break;
 894     }
 895
 896   if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
 897     fixP->fx_done = 1;
 898 }
 899
 900 #ifdef OBJ_COFF
 901 short
 902 tc_coff_fix2rtype (fixP)
 903      fixS *fixP;
 904 {
 905
 906   switch (fixP->fx_r_type)
 907     {
 908     case RELOC_32:
 909       return (R_WORD);
 910     case RELOC_8:
 911       return (R_BYTE);
 912     case RELOC_CONST:
 913       return (R_ILOHALF);
 914     case RELOC_CONSTH:
 915       return (R_IHIHALF);
 916     case RELOC_JUMPTARG:
 917       return (R_IREL);
 918     default:
 919       printf (_("need %o3\n"), fixP->fx_r_type);
 920       abort ();
 921     }                           /* switch on type */
 922
 923   return (0);
 924 }
 925
 926 #endif /* OBJ_COFF */
 927
 928 /* should never be called for 29k */
 929 void
 930 md_convert_frag (headers, seg, fragP)
 931      object_headers *headers ATTRIBUTE_UNUSED;
 932      segT seg ATTRIBUTE_UNUSED;
 933      register fragS *fragP ATTRIBUTE_UNUSED;
 934 {
 935   as_fatal (_("a29k_convert_frag\n"));
 936 }
 937
 938 /* should never be called for a29k */
 939 int
 940 md_estimate_size_before_relax (fragP, segtype)
 941      register fragS *fragP ATTRIBUTE_UNUSED;
 942      segT segtype ATTRIBUTE_UNUSED;
 943 {
 944   as_fatal (_("a29k_estimate_size_before_relax\n"));
 945   return 0;
 946 }
 947
 948 #if 0
 949 /* for debugging only */
 950 static void
 951 print_insn (insn)
 952      struct machine_it *insn;
 953 {
 954   char *Reloc[] =
 955   {
 956     "RELOC_8",
 957     "RELOC_16",
 958     "RELOC_32",
 959     "RELOC_DISP8",
 960     "RELOC_DISP16",
 961     "RELOC_DISP32",
 962     "RELOC_WDISP30",
 963     "RELOC_WDISP22",
 964     "RELOC_HI22",
 965     "RELOC_22",
 966     "RELOC_13",
 967     "RELOC_LO10",
 968     "RELOC_SFA_BASE",
 969     "RELOC_SFA_OFF13",
 970     "RELOC_BASE10",
 971     "RELOC_BASE13",
 972     "RELOC_BASE22",
 973     "RELOC_PC10",
 974     "RELOC_PC22",
 975     "RELOC_JMP_TBL",
 976     "RELOC_SEGOFF16",
 977     "RELOC_GLOB_DAT",
 978     "RELOC_JMP_SLOT",
 979     "RELOC_RELATIVE",
 980     "NO_RELOC"
 981   };
 982
 983   if (insn->error)
 984     {
 985       fprintf (stderr, "ERROR: %s\n");
 986     }
 987   fprintf (stderr, "opcode=0x%08x\n", insn->opcode);
 988   fprintf (stderr, "reloc = %s\n", Reloc[insn->reloc]);
 989   fprintf (stderr, "exp =  {\n");
 990   fprintf (stderr, "\t\tX_add_symbol = %s\n",
 991            insn->exp.X_add_symbol ?
 992            (S_GET_NAME (insn->exp.X_add_symbol) ?
 993             S_GET_NAME (insn->exp.X_add_symbol) : "???") : "0");
 994   fprintf (stderr, "\t\tX_op_symbol = %s\n",
 995            insn->exp.X_op_symbol ?
 996            (S_GET_NAME (insn->exp.X_op_symbol) ?
 997             S_GET_NAME (insn->exp.X_op_symbol) : "???") : "0");
 998   fprintf (stderr, "\t\tX_add_number = %d\n",
 999            insn->exp.X_add_number);
1000   fprintf (stderr, "}\n");
1001 }
1002
1003 #endif
1004
1005 /* Translate internal representation of relocation info to target format.
1006
1007    On sparc/29k: first 4 bytes are normal unsigned long address, next three
1008    bytes are index, most sig. byte first.  Byte 7 is broken up with
1009    bit 7 as external, bits 6 & 5 unused, and the lower
1010    five bits as relocation type.  Next 4 bytes are long addend.  */
1011 /* Thanx and a tip of the hat to Michael Bloom, mb@ttidca.tti.com */
1012
1013 #ifdef OBJ_AOUT
1014
1015 void
1016 tc_aout_fix_to_chars (where, fixP, segment_address_in_file)
1017      char *where;
1018      fixS *fixP;
1019      relax_addressT segment_address_in_file;
1020 {
1021   long r_symbolnum;
1022
1023   know (fixP->fx_r_type < NO_RELOC);
1024   know (fixP->fx_addsy != NULL);
1025
1026   md_number_to_chars (where,
1027        fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file,
1028                       4);
1029
1030   r_symbolnum = (S_IS_DEFINED (fixP->fx_addsy)
1031                  ? S_GET_TYPE (fixP->fx_addsy)
1032                  : fixP->fx_addsy->sy_number);
1033
1034   where[4] = (r_symbolnum >> 16) & 0x0ff;
1035   where[5] = (r_symbolnum >> 8) & 0x0ff;
1036   where[6] = r_symbolnum & 0x0ff;
1037   where[7] = (((!S_IS_DEFINED (fixP->fx_addsy)) << 7) & 0x80) | (0 & 0x60) | (fixP->fx_r_type & 0x1F);
1038   /* Also easy */
1039   md_number_to_chars (&where[8], fixP->fx_addnumber, 4);
1040 }
1041
1042 #endif /* OBJ_AOUT */
1043 \f
1044 const char *md_shortopts = "";
1045 struct option md_longopts[] = {
1046   {NULL, no_argument, NULL, 0}
1047 };
1048 size_t md_longopts_size = sizeof (md_longopts);
1049
1050 int
1051 md_parse_option (c, arg)
1052      int c ATTRIBUTE_UNUSED;
1053      char *arg ATTRIBUTE_UNUSED;
1054 {
1055   return 0;
1056 }
1057
1058 void
1059 md_show_usage (stream)
1060      FILE *stream ATTRIBUTE_UNUSED;
1061 {
1062 }
1063 \f
1064 /* This is called when a line is unrecognized.  This is used to handle
1065    definitions of a29k style local labels.  */
1066
1067 int
1068 a29k_unrecognized_line (c)
1069      int c;
1070 {
1071   int lab;
1072   char *s;
1073
1074   if (c != '$'
1075       || ! ISDIGIT (input_line_pointer[0]))
1076     return 0;
1077
1078   s = input_line_pointer;
1079
1080   lab = 0;
1081   while (ISDIGIT (*s))
1082     {
1083       lab = lab * 10 + *s - '0';
1084       ++s;
1085     }
1086
1087   if (*s != ':')
1088     {
1089       /* Not a label definition.  */
1090       return 0;
1091     }
1092
1093   if (dollar_label_defined (lab))
1094     {
1095       as_bad (_("label \"$%d\" redefined"), lab);
1096       return 0;
1097     }
1098
1099   define_dollar_label (lab);
1100   colon (dollar_label_name (lab, 0));
1101   input_line_pointer = s + 1;
1102
1103   return 1;
1104 }
1105
1106 /* Default the values of symbols known that should be "predefined".  We
1107    don't bother to predefine them unless you actually use one, since there
1108    are a lot of them.  */
1109
1110 symbolS *
1111 md_undefined_symbol (name)
1112      char *name;
1113 {
1114   long regnum;
1115   char testbuf[5 + /*SLOP*/ 5];
1116
1117   if (name[0] == 'g' || name[0] == 'G'
1118       || name[0] == 'l' || name[0] == 'L'
1119       || name[0] == 's' || name[0] == 'S')
1120     {
1121       /* Perhaps a global or local register name */
1122       if (name[1] == 'r' || name[1] == 'R')
1123         {
1124           long maxreg;
1125
1126           /* Parse the number, make sure it has no extra zeroes or
1127              trailing chars.  */
1128           regnum = atol (&name[2]);
1129
1130           if (name[0] == 's' || name[0] == 'S')
1131             maxreg = 255;
1132           else
1133             maxreg = 127;
1134           if (regnum > maxreg)
1135             return NULL;
1136
1137           sprintf (testbuf, "%ld", regnum);
1138           if (strcmp (testbuf, &name[2]) != 0)
1139             return NULL;        /* gr007 or lr7foo or whatever */
1140
1141           /* We have a wiener!  Define and return a new symbol for it.  */
1142           if (name[0] == 'l' || name[0] == 'L')
1143             regnum += 128;
1144           else if (name[0] == 's' || name[0] == 'S')
1145             regnum += SREG;
1146           return (symbol_new (name, SEG_REGISTER, (valueT) regnum,
1147                               &zero_address_frag));
1148         }
1149     }
1150
1151   return NULL;
1152 }
1153
1154 /* Parse an operand that is machine-specific.  */
1155
1156 void
1157 md_operand (expressionP)
1158      expressionS *expressionP;
1159 {
1160
1161   if (input_line_pointer[0] == '%' && input_line_pointer[1] == '%')
1162     {
1163       /* We have a numeric register expression.  No biggy.  */
1164       input_line_pointer += 2;  /* Skip %% */
1165       (void) expression (expressionP);
1166       if (expressionP->X_op != O_constant
1167           || expressionP->X_add_number > 255)
1168         as_bad (_("Invalid expression after %%%%\n"));
1169       expressionP->X_op = O_register;
1170     }
1171   else if (input_line_pointer[0] == '&')
1172     {
1173       /* We are taking the 'address' of a register...this one is not
1174          in the manual, but it *is* in traps/fpsymbol.h!  What they
1175          seem to want is the register number, as an absolute number.  */
1176       input_line_pointer++;     /* Skip & */
1177       (void) expression (expressionP);
1178       if (expressionP->X_op != O_register)
1179         as_bad (_("Invalid register in & expression"));
1180       else
1181         expressionP->X_op = O_constant;
1182     }
1183   else if (input_line_pointer[0] == '$'
1184            && ISDIGIT (input_line_pointer[1]))
1185     {
1186       long lab;
1187       char *name;
1188       symbolS *sym;
1189
1190       /* This is a local label.  */
1191       ++input_line_pointer;
1192       lab = (long) get_absolute_expression ();
1193       if (dollar_label_defined (lab))
1194         {
1195           name = dollar_label_name (lab, 0);
1196           sym = symbol_find (name);
1197         }
1198       else
1199         {
1200           name = dollar_label_name (lab, 1);
1201           sym = symbol_find_or_make (name);
1202         }
1203
1204       expressionP->X_op = O_symbol;
1205       expressionP->X_add_symbol = sym;
1206       expressionP->X_add_number = 0;
1207     }
1208   else if (input_line_pointer[0] == '$')
1209     {
1210       char *s;
1211       char type;
1212       int fieldnum, fieldlimit;
1213       LITTLENUM_TYPE floatbuf[8];
1214
1215       /* $float(), $doubleN(), or $extendN() convert floating values
1216          to integers.  */
1217
1218       s = input_line_pointer;
1219
1220       ++s;
1221
1222       fieldnum = 0;
1223       if (strncmp (s, "double", sizeof "double" - 1) == 0)
1224         {
1225           s += sizeof "double" - 1;
1226           type = 'd';
1227           fieldlimit = 2;
1228         }
1229       else if (strncmp (s, "float", sizeof "float" - 1) == 0)
1230         {
1231           s += sizeof "float" - 1;
1232           type = 'f';
1233           fieldlimit = 1;
1234         }
1235       else if (strncmp (s, "extend", sizeof "extend" - 1) == 0)
1236         {
1237           s += sizeof "extend" - 1;
1238           type = 'x';
1239           fieldlimit = 4;
1240         }
1241       else
1242         {
1243           return;
1244         }
1245
1246       if (ISDIGIT (*s))
1247         {
1248           fieldnum = *s - '0';
1249           ++s;
1250         }
1251       if (fieldnum >= fieldlimit)
1252         return;
1253
1254       SKIP_WHITESPACE ();
1255       if (*s != '(')
1256         return;
1257       ++s;
1258       SKIP_WHITESPACE ();
1259
1260       s = atof_ieee (s, type, floatbuf);
1261       if (s == NULL)
1262         return;
1263       s = s;
1264
1265       SKIP_WHITESPACE ();
1266       if (*s != ')')
1267         return;
1268       ++s;
1269       SKIP_WHITESPACE ();
1270
1271       input_line_pointer = s;
1272       expressionP->X_op = O_constant;
1273       expressionP->X_unsigned = 1;
1274       expressionP->X_add_number = ((floatbuf[fieldnum * 2]
1275                                     << LITTLENUM_NUMBER_OF_BITS)
1276                                    + floatbuf[fieldnum * 2 + 1]);
1277     }
1278 }
1279
1280 /* Round up a section size to the appropriate boundary.  */
1281 valueT
1282 md_section_align (segment, size)
1283      segT segment ATTRIBUTE_UNUSED;
1284      valueT size;
1285 {
1286   return size;                  /* Byte alignment is fine */
1287 }
1288
1289 /* Exactly what point is a PC-relative offset relative TO?
1290    On the 29000, they're relative to the address of the instruction,
1291    which we have set up as the address of the fixup too.  */
1292 long
1293 md_pcrel_from (fixP)
1294      fixS *fixP;
1295 {
1296   return fixP->fx_where + fixP->fx_frag->fr_address;
1297 }