home *** CD-ROM | disk | FTP | other *** search
/ OpenStep 4.2J (Developer) / os42jdev.iso / NextDeveloper / Source / GNU / cctools / as / sparc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-06-24  |  30.5 KB  |  1,411 lines
  1. /* tc-sparc.c -- Assemble for the SPARC
  2.    Copyright (C) 1989, 1990, 1991, 1992 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. /* relocation type for internal assembler use only */
  21. #define SPARC_RELOC_13 (127)
  22. #define SPARC_RELOC_22 (126)
  23. #define SPARC_RELOC_NONE (125)
  24.  
  25. #define cypress 1234
  26.  
  27. #undef DEBUGINSN
  28.  
  29. #include <stdio.h>
  30. #include <ctype.h>
  31. #include "as.h"
  32. #include "libc.h"
  33. #include "md.h"
  34. #include "messages.h"
  35. #include "symbols.h"
  36. #include "sections.h"
  37.  
  38. /* careful, this file includes data *declarations* */
  39. #include "sparc-opcode.h"
  40. #include <mach-o/sparc/reloc.h>
  41.  
  42. /* From GNU ansidecl.h */
  43. #define PARAMS(paramlist)        paramlist
  44.  
  45. typedef long    offsetT;
  46.  
  47. /*
  48.  * These are the default cputype and cpusubtype for the Sparc architecture.
  49.  */
  50. const cpu_type_t md_cputype = CPU_TYPE_SPARC;
  51. cpu_subtype_t md_cpusubtype = CPU_SUBTYPE_SPARC_ALL;
  52.  
  53. /* This is the byte sex for the Sparc architecture */
  54. const enum byte_sex md_target_byte_sex = BIG_ENDIAN_BYTE_SEX;
  55.  
  56. /* These characters start a comment anywhere on the line */
  57. const char md_comment_chars[] = ";!";
  58.  
  59. /* These characters only start a comment at the beginning of a line */
  60. const char md_line_comment_chars[] = "#";
  61.  
  62. /*
  63.  * These characters can be used to separate mantissa decimal digits from 
  64.  * exponent decimal digits in floating point numbers.
  65.  */
  66. const char md_EXP_CHARS[] = "eE";
  67.  
  68. /*
  69.  * The characters after a leading 0 that means this number is a floating point
  70.  * constant as in 0f123.456 or 0d1.234E-12 (see md_EXP_CHARS above).
  71.  */
  72. const char md_FLT_CHARS[] = "dDfF";
  73.  
  74. static void sparc_ip PARAMS ((char *));
  75.  
  76. static enum sparc_architecture current_architecture = v6;
  77. static int architecture_requested;
  78. static int warn_on_bump;
  79.  
  80. const relax_typeS md_relax_table[1];
  81.  
  82. /* handle of the OPCODE hash table */
  83. static struct hash_control *op_hash = NULL;
  84.  
  85. #ifdef    NeXT
  86. static void s_proc PARAMS ((int));
  87. static void s_ignore PARAMS ((int));
  88. extern void s_seg PARAMS ((int));
  89. #else    NeXT
  90. static void s_data1 PARAMS ((void));
  91. static void s_seg PARAMS ((int));
  92. static void s_proc PARAMS ((int));
  93. static void s_reserve PARAMS ((int));
  94. static void s_common PARAMS ((int));
  95. #endif    NeXT
  96.  
  97. const pseudo_typeS md_pseudo_table[] =
  98. {
  99. #ifdef    NeXT
  100.   {"global", s_globl, 0},    /* Maybe we should fix compiler to use globl */
  101.   {"proc", s_proc, 0},        /* nop??? */
  102.   /* These are to handle SUN assembler files and point to existing handlers */
  103.   {"empty", s_ignore, 0},
  104.   {"ident", s_ignore, 0},
  105.   {"optim", s_ignore, 0},
  106.   {"skip", s_space, 0},
  107.   {"type", s_ignore, 0},
  108.   {"word", cons, 4},
  109.   {"half", cons, 2},
  110.   /* these are custom handlers for SUN SPARC assembler only */
  111.  
  112. #else    NeXT
  113.   {"seg", s_seg, 0},
  114.   {"align", s_align_bytes, 0},    /* Defaulting is invalid (0) */
  115.   {"common", s_common, 0},
  116.   {"global", s_globl, 0},
  117.   {"half", cons, 2},
  118.   {"optim", s_ignore, 0},
  119.   {"proc", s_proc, 0},
  120.   {"reserve", s_reserve, 0},
  121.   {"seg", s_seg, 0},
  122.   {"skip", s_space, 0},
  123.   {"word", cons, 4},
  124. #endif    NeXT
  125.   {NULL, 0, 0},
  126. };
  127.  
  128. const int md_short_jump_size = 4;
  129. const int md_long_jump_size = 4;
  130. const int md_reloc_size = 12;    /* Size of relocation record */
  131.  
  132. /* This array holds the chars that always start a comment.  If the
  133.    pre-processor is disabled, these aren't very useful */
  134. const char comment_chars[] = "!";    /* JF removed '|' from comment_chars */
  135.  
  136. /* This array holds the chars that only start a comment at the beginning of
  137.    a line.  If the line seems to have the form '# 123 filename'
  138.    .line and .file directives will appear in the pre-processed output */
  139. /* Note that input_file.c hand checks for '#' at the beginning of the
  140.    first line of the input file.  This is because the compiler outputs
  141.    #NO_APP at the beginning of its output. */
  142. /* Also note that comments started like this one will always
  143.    work if '/' isn't otherwise defined. */
  144. const char line_comment_chars[] = "#";
  145.  
  146. const char line_separator_chars[] = "";
  147.  
  148. /* Chars that can be used to separate mant from exp in floating point nums */
  149. const char EXP_CHARS[] = "eE";
  150.  
  151. /* Chars that mean this number is a floating point constant */
  152. /* As in 0f12.456 */
  153. /* or    0d1.2345e12 */
  154. const char FLT_CHARS[] = "rRsSfFdDxXpP";
  155.  
  156. /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
  157.    changed in read.c.  Ideally it shouldn't have to know about it at all,
  158.    but nothing is ideal around here.  */
  159.  
  160. static unsigned char octal[256];
  161. #define isoctal(c)  octal[(unsigned char) (c)]
  162. static unsigned char toHex[256];
  163.  
  164. struct sparc_it
  165.   {
  166.     char *error;
  167.     unsigned long opcode;
  168.     struct nlist *nlistp;
  169.     expressionS exp;
  170.     int pcrel;
  171.     char pcrel_reloc;    /* do relocation? */
  172.     enum reloc_type_sparc reloc;
  173.   };
  174.  
  175. struct sparc_it the_insn;
  176.  
  177. #ifdef DEBUGINSN
  178. static void print_insn PARAMS ((struct sparc_it *insn));
  179. #endif
  180. static int getExpression PARAMS ((char *str));
  181.  
  182. static char *expr_end;
  183.  
  184.  
  185. /*
  186.  * Indicates a 'set' instruction which may require a either
  187.  * of the following instructions depending on the size of the 
  188.  * value argument:
  189.  *
  190.  * sethi %hi(value),reg
  191.  *
  192.  * or    %g0,value,reg
  193.  *
  194.  * sethi %hi(value),reg
  195.  * or    reg,%lo(value),reg
  196.  *
  197.  */
  198. static int special_case_set = 0;
  199.  
  200. /* s_proc and s_ignore are included for rudimentary 
  201.    compatibility with the Sun assembler only */
  202.  
  203. static void
  204. s_proc (ignore)
  205.      int ignore;
  206. {
  207.   totally_ignore_line();
  208. }
  209.  
  210. /* we simply ignore the rest of this statement */
  211. static void
  212. s_ignore (ignore)
  213.      int ignore;
  214. {
  215.   totally_ignore_line();
  216. }
  217.  
  218. /* This function is called once, at assembler startup time.  It should
  219.    set up all the tables, etc. that the MD part of the assembler will need. */
  220. void
  221. md_begin ()
  222. {
  223.   register const char *retval = NULL;
  224.   int lose = 0;
  225.   register unsigned int i = 0;
  226.  
  227.   op_hash = hash_new ();
  228.  
  229.   while (i < NUMOPCODES)
  230.     {
  231.       const char *name = sparc_opcodes[i].name;
  232.       retval = hash_insert (op_hash, (char *)name, (char *)&sparc_opcodes[i]);
  233.  
  234.       if(retval != NULL && *retval != '\0') {
  235.     fprintf (stderr, "internal error: can't hash `%s': %s\n",
  236.          sparc_opcodes[i].name, retval);
  237.     lose = 1;
  238.       } do {
  239.     if (sparc_opcodes[i].match & sparc_opcodes[i].lose)
  240.       {
  241.         fprintf (stderr, "internal error: losing opcode: `%s' \"%s\"\n",
  242.              sparc_opcodes[i].name, sparc_opcodes[i].args);
  243.         lose = 1;
  244.       }
  245.     ++i;
  246.       }
  247.       while (i < NUMOPCODES
  248.          && !strcmp (sparc_opcodes[i].name, name));
  249.     }
  250.  
  251.   if (lose)
  252.     as_fatal ("Broken assembler.  No assembly attempted.");
  253.  
  254.   for (i = '0'; i < '8'; ++i)
  255.     octal[i] = 1;
  256.   for (i = '0'; i <= '9'; ++i)
  257.     toHex[i] = i - '0';
  258.   for (i = 'a'; i <= 'f'; ++i)
  259.     toHex[i] = i + 10 - 'a';
  260.   for (i = 'A'; i <= 'F'; ++i)
  261.     toHex[i] = i + 10 - 'A';
  262. }
  263.  
  264. void
  265. md_end(
  266. void)
  267. {
  268.     return;
  269. }
  270.  
  271. void
  272. md_assemble (str)
  273.      char *str;
  274. {
  275.   char *toP;
  276.   int rsd;
  277.  
  278.   know (str);
  279.   sparc_ip (str);
  280.  
  281. #ifdef DEBUGINSN
  282.   print_insn(&the_insn);
  283. #endif
  284.  
  285.   /* See if "set" operand is absolute and small; skip sethi if so. */
  286.   if (special_case_set && the_insn.exp.X_seg == SEG_ABSOLUTE)
  287.     {
  288.       if (the_insn.exp.X_add_number >= -(1 << 12)
  289.       && the_insn.exp.X_add_number < (1 << 12))
  290.     {
  291.       the_insn.opcode = 0x80102000    /* or %g0,imm,... */
  292.         | (the_insn.opcode & 0x3E000000)    /* dest reg */
  293.         | (the_insn.exp.X_add_number & 0x1FFF);    /* imm */
  294.       special_case_set = 0;    /* No longer special */
  295.       the_insn.reloc = SPARC_RELOC_NONE;    /* No longer relocated */
  296.     }
  297.     }
  298.  
  299. #ifdef NeXT    /* mark sections containing instructions */
  300.   /*
  301.    * We are putting a machine instruction in this section so mark it as
  302.    * containg some machine instructions.
  303.    */
  304.   frchain_now->frch_section.flags |= S_ATTR_SOME_INSTRUCTIONS;
  305. #endif /* NeXT */
  306.  
  307.   toP = frag_more (4);
  308.   /* put out the opcode */
  309.   md_number_to_chars (toP, (valueT) the_insn.opcode, 4);
  310.  
  311.   /* put out the symbol-dependent stuff */
  312.   if (the_insn.reloc != SPARC_RELOC_NONE)
  313.     {
  314.     fix_new(frag_now,
  315.         (toP - frag_now->fr_literal),
  316.         4,
  317.         the_insn.exp.X_add_symbol,
  318.         the_insn.exp.X_subtract_symbol,
  319.         the_insn.exp.X_add_number,
  320.         the_insn.pcrel,
  321.         the_insn.pcrel_reloc,    /* 1 for local labels due to scatter loading */
  322.         the_insn.reloc);
  323.     }
  324.  
  325.   if (special_case_set) {
  326.     special_case_set = 0;
  327.     assert (the_insn.reloc == SPARC_RELOC_HI22);
  328.     /* See if "set" operand has no low-order bits; skip OR if so. */
  329.     if ((the_insn.exp.X_seg == SEG_ABSOLUTE) && 
  330.     ((the_insn.exp.X_add_number & 0x3FF) == 0))
  331.       return;
  332.  
  333.     toP = frag_more (4);
  334.     rsd = (the_insn.opcode >> 25) & 0x1f;
  335.     the_insn.opcode = 0x80102000 | (rsd << 25) | (rsd << 14);
  336.     md_number_to_chars (toP, (valueT) the_insn.opcode, 4);
  337.     the_insn.pcrel_reloc = 0;
  338.  
  339.     fix_new(frag_now,
  340.     (toP - frag_now->fr_literal),
  341.     4,
  342.     the_insn.exp.X_add_symbol,
  343.     the_insn.exp.X_subtract_symbol,
  344.     the_insn.exp.X_add_number,
  345.     the_insn.pcrel,
  346.     the_insn.pcrel_reloc,
  347.     SPARC_RELOC_LO10);
  348.     return;
  349.   }
  350. }
  351.  
  352. static void
  353. sparc_ip (str)
  354.      char *str;
  355. {
  356.   char *error_message = "";
  357.   char *s;
  358.   const char *args;
  359.   char c;
  360.   struct sparc_opcode *insn;
  361.   char *argsStart;
  362.   unsigned long opcode;
  363.   unsigned int mask = 0;
  364.   int match = 0;
  365.   int comma = 0;
  366.   long immediate_max = 0;
  367.  
  368.   for (s = str; islower (*s) || (*s >= '0' && *s <= '3'); ++s)
  369.     ;
  370.   switch (*s)
  371.     {
  372.  
  373.     case '\0':
  374.       break;
  375.  
  376.     case ',':
  377.       comma = 1;
  378.  
  379.       /*FALLTHROUGH */
  380.  
  381.     case ' ':
  382.       *s++ = '\0';
  383.       break;
  384.  
  385.     default:
  386.       as_bad ("Unknown opcode: `%s'", str);
  387.       exit (1);
  388.     }
  389.   if ((insn = (struct sparc_opcode *) hash_find (op_hash, str)) == NULL)
  390.     {
  391.       as_bad ("Unknown opcode: `%s'", str);
  392.       return;
  393.     }
  394.   if (comma)
  395.     {
  396.       *--s = ',';
  397.     }
  398.   argsStart = s;
  399.   for (;;)
  400.     {
  401.       opcode = insn->match;
  402.       memset (&the_insn, '\0', sizeof (the_insn));
  403.       the_insn.reloc = SPARC_RELOC_NONE;
  404.       the_insn.pcrel_reloc = 1; /* default, reloc, for scatter loading */
  405.  
  406.       /*
  407.        * Build the opcode, checking as we go to make
  408.        * sure that the operands match
  409.        */
  410.       for (args = insn->args;; ++args)
  411.     {
  412.       switch (*args)
  413.         {
  414.         case 'M':
  415.         case 'm':
  416.           if (strncmp (s, "%asr", 4) == 0)
  417.         {
  418.           s += 4;
  419.  
  420.           if (isdigit (*s))
  421.             {
  422.               long num = 0;
  423.  
  424.               while (isdigit (*s))
  425.             {
  426.               num = num * 10 + *s - '0';
  427.               ++s;
  428.             }
  429.  
  430.               if (num < 16 || 31 < num)
  431.             {
  432.               error_message = ": asr number must be between 15 and 31";
  433.               goto error;
  434.             }    /* out of range */
  435.  
  436.               opcode |= (*args == 'M' ? RS1 (num) : RD (num));
  437.               continue;
  438.             }
  439.           else
  440.             {
  441.               error_message = ": expecting %asrN";
  442.               goto error;
  443.             }        /* if %asr followed by a number. */
  444.  
  445.         }        /* if %asr */
  446.           break;
  447.  
  448.  
  449.         case '\0':        /* end of args */
  450.           if (*s == '\0')
  451.         {
  452.           match = 1;
  453.         }
  454.           break;
  455.  
  456.         case '+':
  457.           if (*s == '+')
  458.         {
  459.           ++s;
  460.           continue;
  461.         }
  462.           if (*s == '-')
  463.         {
  464.           continue;
  465.         }
  466.           break;
  467.  
  468.         case '[':        /* these must match exactly */
  469.         case ']':
  470.         case ',':
  471.         case ' ':
  472.           if (*s++ == *args)
  473.         continue;
  474.           break;
  475.  
  476.         case '#':        /* must be at least one digit */
  477.           if (isdigit (*s++))
  478.         {
  479.           while (isdigit (*s))
  480.             {
  481.               ++s;
  482.             }
  483.           continue;
  484.         }
  485.           break;
  486.  
  487.         case 'C':        /* coprocessor state register */
  488.           if (strncmp (s, "%csr", 4) == 0)
  489.         {
  490.           s += 4;
  491.           continue;
  492.         }
  493.           break;
  494.  
  495.         case 'b':        /* next operand is a coprocessor register */
  496.         case 'c':
  497.         case 'D':
  498.           if (*s++ == '%' && *s++ == 'c' && isdigit (*s))
  499.         {
  500.           mask = *s++;
  501.           if (isdigit (*s))
  502.             {
  503.               mask = 10 * (mask - '0') + (*s++ - '0');
  504.               if (mask >= 32)
  505.             {
  506.               break;
  507.             }
  508.             }
  509.           else
  510.             {
  511.               mask -= '0';
  512.             }
  513.           switch (*args)
  514.             {
  515.  
  516.             case 'b':
  517.               opcode |= mask << 14;
  518.               continue;
  519.  
  520.             case 'c':
  521.               opcode |= mask;
  522.               continue;
  523.  
  524.             case 'D':
  525.               opcode |= mask << 25;
  526.               continue;
  527.             }
  528.         }
  529.           break;
  530.  
  531.         case 'r':        /* next operand must be a register */
  532.         case 'u':
  533.         case '1':
  534.         case '2':
  535.         case 'd':
  536.           if (*s++ == '%')
  537.         {
  538.           switch (c = *s++)
  539.             {
  540.  
  541.             case 'f':    /* frame pointer */
  542.               if (*s++ == 'p')
  543.             {
  544.               mask = 0x1e;
  545.               break;
  546.             }
  547.               error_message = ": register not fp";
  548.               goto error;
  549.  
  550.             case 'g':    /* global register */
  551.               if (isoctal (c = *s++))
  552.             {
  553.               mask = c - '0';
  554.               break;
  555.             }
  556.               error_message = ": invalid global register";
  557.               goto error;
  558.  
  559.             case 'i':    /* in register */
  560.               if (isoctal (c = *s++))
  561.             {
  562.               mask = c - '0' + 24;
  563.               break;
  564.             }
  565.               error_message = ": invalid in register";
  566.               goto error;
  567.  
  568.             case 'l':    /* local register */
  569.               if (isoctal (c = *s++))
  570.             {
  571.               mask = (c - '0' + 16);
  572.               break;
  573.             }
  574.               error_message = ": invalid local register";
  575.               goto error;
  576.  
  577.             case 'o':    /* out register */
  578.               if (isoctal (c = *s++))
  579.             {
  580.               mask = (c - '0' + 8);
  581.               break;
  582.             }
  583.               error_message = ": invalid out register";
  584.               goto error;
  585.  
  586.             case 's':    /* stack pointer */
  587.               if (*s++ == 'p')
  588.             {
  589.               mask = 0xe;
  590.               break;
  591.             }
  592.               error_message = ": register is not sp";
  593.               goto error;
  594.  
  595.             case 'r':    /* any register */
  596.               if (!isdigit (c = *s++))
  597.             {
  598.               error_message = ": invalid register";
  599.               goto error;
  600.             }
  601.               /* FALLTHROUGH */
  602.             case '0':
  603.             case '1':
  604.             case '2':
  605.             case '3':
  606.             case '4':
  607.             case '5':
  608.             case '6':
  609.             case '7':
  610.             case '8':
  611.             case '9':
  612.               if (isdigit (*s))
  613.             {
  614.               if ((c = 10 * (c - '0') + (*s++ - '0')) >= 32)
  615.                 {
  616.                   error_message = ": register # out of range";
  617.                   goto error;
  618.                 }
  619.             }
  620.               else
  621.             {
  622.               c -= '0';
  623.             }
  624.               mask = c;
  625.               break;
  626.  
  627.             default:
  628.               error_message = ": invalid resgiter #";
  629.               goto error;
  630.             }
  631.          /*
  632.          * Got the register, now figure out where
  633.          * it goes in the opcode.
  634.          */
  635.           switch (*args)
  636.             {
  637.  
  638.             case '1':
  639.               opcode |= mask << 14;
  640.               continue;
  641.  
  642.             case '2':
  643.               opcode |= mask;
  644.               continue;
  645.  
  646.             case 'd':
  647.               opcode |= mask << 25;
  648.               continue;
  649.  
  650.             case 'r':
  651.               opcode |= (mask << 25) | (mask << 14);
  652.               continue;
  653.  
  654.             case 'u':
  655.               opcode |= (mask << 25) | mask;
  656.               continue;
  657.             }
  658.         }
  659.           break;
  660.  
  661.         case 'e':        /* next operand is a floating point register */
  662.         case 'v':
  663.         case 'V':
  664.  
  665.         case 'f':
  666.         case 'B':
  667.         case 'R':
  668.  
  669.         case 'g':
  670.         case 'H':
  671.         case 'J':
  672.           {
  673.         char format;
  674.  
  675.         if (*s++ == '%'
  676.             && ((format = *s) == 'f')
  677.             && isdigit (*++s))
  678.           {
  679.             for (mask = 0; isdigit (*s); ++s)
  680.               {
  681.             mask = 10 * mask + (*s - '0');
  682.               }        /* read the number */
  683.  
  684.             if ((*args == 'v'
  685.              || *args == 'B'
  686.              || *args == 'H')
  687.             && (mask & 1))
  688.               {
  689.             break;
  690.               }        /* register must be even numbered */
  691.  
  692.             if ((*args == 'V'
  693.              || *args == 'R'
  694.              || *args == 'J')
  695.             && (mask & 3))
  696.               {
  697.             break;
  698.               }        /* register must be multiple of 4 */
  699.  
  700.             if (mask >= 32)
  701.               {
  702.             error_message = ": There are only 32 f registers; [0-31]";
  703.             goto error;
  704.               }    /* on error */
  705.           }
  706.         else
  707.           {
  708.             break;
  709.           }    /* if not an 'f' register. */
  710.  
  711.         switch (*args)
  712.           {
  713.  
  714.           case 'v':
  715.           case 'V':
  716.           case 'e':
  717.             opcode |= RS1 (mask);
  718.             continue;
  719.  
  720.  
  721.           case 'f':
  722.           case 'B':
  723.           case 'R':
  724.             opcode |= RS2 (mask);
  725.             continue;
  726.  
  727.           case 'g':
  728.           case 'H':
  729.           case 'J':
  730.             opcode |= RD (mask);
  731.             continue;
  732.           }        /* pack it in. */
  733.  
  734.         know (0);
  735.         break;
  736.           }            /* float arg */
  737.  
  738.         case 'F':
  739.           if (strncmp (s, "%fsr", 4) == 0)
  740.         {
  741.           s += 4;
  742.           continue;
  743.         }
  744.           break;
  745.  
  746.         case 'h':        /* high 22 bits */
  747.           the_insn.reloc = SPARC_RELOC_HI22;
  748.           goto immediate;
  749.  
  750.         case 'l':        /* 22 bit PC relative immediate */
  751.           the_insn.reloc = SPARC_RELOC_WDISP22;
  752.           the_insn.pcrel = 1;
  753.           goto immediate;
  754.  
  755.         case 'L':        /* 30 bit immediate for call insn */
  756.           the_insn.reloc = SPARC_RELOC_WDISP30;
  757.           the_insn.pcrel = 1;
  758.           goto immediate;
  759.  
  760.         case 'n':        /* 22 bit immediate */
  761.           the_insn.reloc = SPARC_RELOC_22;
  762.           goto immediate;
  763.  
  764.         case 'i':        /* 13 bit immediate */
  765.           /* What's the difference between base13 and 13?  
  766.              13-bit immediate and 13-bit immediate+register */
  767.           the_insn.reloc = SPARC_RELOC_13;
  768.           immediate_max = 0x1FFF;
  769.  
  770.           /*FALLTHROUGH */
  771.  
  772.         immediate:
  773.           if (*s == ' ')
  774.         s++;
  775.           if (*s == '%')
  776.         {
  777.           if ((c = s[1]) == 'h' && s[2] == 'i')
  778.             {
  779.               the_insn.reloc = SPARC_RELOC_HI22;
  780.               s += 3;
  781.             }
  782.           else if (c == 'l' && s[2] == 'o')
  783.             {
  784.               the_insn.reloc = SPARC_RELOC_LO10;
  785.               s += 3;
  786.             }
  787.           else
  788.             break;
  789.         }
  790.           /* Note that if the getExpression() fails, we will still
  791.          have created U entries in the symbol table for the
  792.          'symbols' in the input string.  Try not to create U
  793.          symbols for registers, etc.  */
  794.           {
  795.         /* This stuff checks to see if the expression ends in
  796.            +%reg.  If it does, it removes the register from
  797.            the expression, and re-sets 's' to point to the
  798.            right place.  */
  799.  
  800.         char *s1;
  801.  
  802.         for (s1 = s; *s1 && *s1 != ',' && *s1 != ']'; s1++);
  803.  
  804.         if (s1 != s && isdigit (s1[-1]))
  805.           {
  806.             if (s1[-2] == '%' && s1[-3] == '+')
  807.               {
  808.             s1 -= 3;
  809.             *s1 = '\0';
  810.             (void) getExpression (s);
  811.             *s1 = '+';
  812.             s = s1;
  813.             continue;
  814.               }
  815.             else if (strchr ("goli0123456789", 
  816.                      s1[-2]) && s1[-3] == '%' && s1[-4] == '+')
  817.               {
  818.             s1 -= 4;
  819.             *s1 = '\0';
  820.             (void) getExpression (s);
  821.             *s1 = '+';
  822.             s = s1;
  823.             continue;
  824.               }
  825.           }
  826.           }
  827.           (void) getExpression (s);
  828.           s = expr_end;
  829.     /* The Next linker has the ability to scatter blocks of sections between
  830.      * labels.  This requires that branches to labels that survive to the
  831.      * link phase be relocatable.  These labels are those that are not L*
  832.      */
  833.          if (the_insn.exp.X_add_symbol != NULL && !flagseen['L']
  834.         && the_insn.exp.X_add_symbol->sy_nlist.n_un.n_name[0] == 'L') {
  835.         /* local symbol which will be thrown away.  Don't bother
  836.          * to reloc it.
  837.          */
  838.         the_insn.pcrel_reloc = 0;
  839.          }
  840.  
  841.           if ((the_insn.exp.X_seg == SEG_ABSOLUTE || 
  842.            the_insn.exp.X_seg == SEG_BIG)
  843.           && the_insn.exp.X_add_symbol == 0)
  844.         {
  845.  
  846.           /* Check for invalid constant values.  Don't warn if
  847.              constant was inside %hi or %lo, since these
  848.              truncate the constant to fit.  */
  849.           if (immediate_max != 0
  850.               && the_insn.reloc != SPARC_RELOC_LO10
  851.               && the_insn.reloc != SPARC_RELOC_HI22
  852.               && (the_insn.exp.X_add_number > immediate_max
  853.               || the_insn.exp.X_add_number < ~immediate_max))
  854.             as_bad ("constant value must be between %ld and %ld",
  855.                 ~immediate_max, immediate_max);
  856.  
  857.           if ((the_insn.reloc == SPARC_RELOC_WDISP22 ||
  858.               the_insn.reloc == SPARC_RELOC_WDISP30) &&
  859.               the_insn.exp.X_add_number & 3) 
  860.             as_bad ("displacement is not long aligned");
  861.  
  862.            /* plug absolutes directly into opcode */
  863.  
  864.           switch(the_insn.reloc) {
  865.           case SPARC_RELOC_13:
  866.             if (the_insn.exp.X_seg == SEG_BIG)
  867.               opcode |= (*(int *) generic_bignum) & 0x1fff;
  868.             else
  869.               opcode |= the_insn.exp.X_add_number & 0x1fff;
  870.             the_insn.reloc = SPARC_RELOC_NONE;
  871.             break;
  872.           case SPARC_RELOC_22:
  873.             if (the_insn.exp.X_seg == SEG_BIG)
  874.               opcode |= (*(int *) generic_bignum) & 0x3fffff;
  875.             else
  876.               opcode |= the_insn.exp.X_add_number & 0x3fffff;
  877.             the_insn.reloc = SPARC_RELOC_NONE;
  878.             break;
  879.           case SPARC_RELOC_HI22:
  880.             /* extract upper 22 bits from constant */
  881.             opcode |= (the_insn.exp.X_add_number >> 10) & 0x3fffff;
  882.             the_insn.reloc = SPARC_RELOC_NONE;
  883.             break;
  884.           case SPARC_RELOC_LO10:
  885.             opcode |= the_insn.exp.X_add_number & 0x3ff;
  886.             break;
  887.           
  888.             /* the PC relative displacements are plugged in
  889.                if the argument is absolute, but retain
  890.                relocatability */
  891.           case SPARC_RELOC_WDISP22:
  892.             opcode |= (the_insn.exp.X_add_number >> 2) & 0x3fffff;
  893.             break;
  894.           case SPARC_RELOC_WDISP30:
  895.             opcode |= (the_insn.exp.X_add_number >> 2) & 0x3fffffff;
  896.             break;
  897.           default:
  898.             printf("Unknown reloc entry\n");
  899.           }
  900.         }
  901.  
  902.           /* Reset to prevent extraneous range check.  */
  903.           immediate_max = 0;
  904.  
  905.           continue;
  906.  
  907.         case 'a':
  908.           if (*s++ == 'a')
  909.         {
  910.           opcode |= ANNUL;
  911.           continue;
  912.         }
  913.           break;
  914.  
  915.         case 'A':
  916.           {
  917.         char *push = input_line_pointer;
  918.         expressionS e;
  919.  
  920.         input_line_pointer = s;
  921.  
  922.         expression (&e);
  923.  
  924.         if (e.X_seg == SEG_ABSOLUTE)
  925.           {
  926.             opcode |= e.X_add_number << 5;
  927.             s = input_line_pointer;
  928.             input_line_pointer = push;
  929.             continue;
  930.           }        /* if absolute */
  931.  
  932.         break;
  933.           }            /* alternate space */
  934.  
  935.         case 'p':
  936.           if (strncmp (s, "%psr", 4) == 0)
  937.         {
  938.           s += 4;
  939.           continue;
  940.         }
  941.           break;
  942.  
  943.         case 'q':        /* floating point queue */
  944.           if (strncmp (s, "%fq", 3) == 0)
  945.         {
  946.           s += 3;
  947.           continue;
  948.         }
  949.           break;
  950.  
  951.         case 'Q':        /* coprocessor queue */
  952.           if (strncmp (s, "%cq", 3) == 0)
  953.         {
  954.           s += 3;
  955.           continue;
  956.         }
  957.           break;
  958.  
  959.         case 'S':
  960.           if (strcmp (str, "set") == 0)
  961.         {
  962.           special_case_set = 1;
  963.           continue;
  964.         }
  965.           break;
  966.  
  967.  
  968.         case 't':
  969.           if (strncmp (s, "%tbr", 4) != 0)
  970.         break;
  971.           s += 4;
  972.           continue;
  973.  
  974.         case 'w':
  975.           if (strncmp (s, "%wim", 4) != 0)
  976.         break;
  977.           s += 4;
  978.           continue;
  979.  
  980.         case 'y':
  981.           if (strncmp (s, "%y", 2) != 0)
  982.         break;
  983.           s += 2;
  984.           continue;
  985.  
  986.         default:
  987.           as_fatal ("failed sanity check.");
  988.         }            /* switch on arg code */
  989.       break;
  990.     }            /* for each arg that we expect */
  991.     error:
  992.       if (match == 0)
  993.     {
  994.       /* Args don't match. */
  995.       if (((unsigned) (&insn[1] - sparc_opcodes)) < NUMOPCODES
  996.           && !strcmp (insn->name, insn[1].name))
  997.         {
  998.           ++insn;
  999.           s = argsStart;
  1000.           continue;
  1001.         }
  1002.       else
  1003.         {
  1004.           as_bad ("Illegal operands%s", error_message);
  1005.           return;
  1006.         }
  1007.     }
  1008.       else
  1009.     {
  1010.       if (insn->architecture > current_architecture)
  1011.         {
  1012.           if ((!architecture_requested || warn_on_bump)
  1013.           &&
  1014.           1
  1015.         )
  1016.         {
  1017.           if (warn_on_bump)
  1018.             {
  1019.               as_warn ("architecture bumped from \"%s\" to \"%s\" on \"%s\"",
  1020.                    architecture_pname[current_architecture],
  1021.                    architecture_pname[insn->architecture],
  1022.                    str);
  1023.             }        /* if warning */
  1024.  
  1025.           current_architecture = insn->architecture;
  1026.         }
  1027.           else
  1028.         {
  1029.           as_bad ("architecture mismatch on \"%s\" (\"%s\").  current architecture is \"%s\"",
  1030.               str,
  1031.               architecture_pname[insn->architecture],
  1032.               architecture_pname[current_architecture]);
  1033.           return;
  1034.         }        /* if bump ok else error */
  1035.         }            /* if architecture higher */
  1036.     }            /* if no match */
  1037.  
  1038.       break;
  1039.     }                /* forever looking for a match */
  1040.  
  1041.   the_insn.opcode = opcode;
  1042. }
  1043.  
  1044. static int
  1045. getExpression (str)
  1046.      char *str;
  1047. {
  1048.   char *save_in;
  1049.   segT seg;
  1050.  
  1051.   save_in = input_line_pointer;
  1052.   input_line_pointer = str;
  1053.   seg = expression (&the_insn.exp);
  1054.  
  1055.   if (seg != SEG_ABSOLUTE
  1056.       && seg != SEG_SECT
  1057.       && seg != SEG_DIFFSECT
  1058.       && seg != SEG_UNKNOWN
  1059.       && seg != SEG_NONE
  1060.       && seg != SEG_BIG) {
  1061.     the_insn.error = "bad segment";
  1062.     expr_end = input_line_pointer;
  1063.     input_line_pointer = save_in;
  1064.     return 1;
  1065.   }
  1066.   expr_end = input_line_pointer;
  1067.   input_line_pointer = save_in;
  1068.   return 0;
  1069. }                /* getExpression() */
  1070.  
  1071.  
  1072. /*
  1073.   This is identical to the md_atof in m68k.c.  I think this is right,
  1074.   but I'm not sure.
  1075.  
  1076.   Turn a string in input_line_pointer into a floating point constant of type
  1077.   type, and store the appropriate bytes in *litP.  The number of LITTLENUMS
  1078.   emitted is stored in *sizeP .  An error message is returned, or NULL on OK.
  1079.   */
  1080.  
  1081. /* Equal to MAX_PRECISION in atof-ieee.c */
  1082. #define MAX_LITTLENUMS 6
  1083.  
  1084. char *
  1085. md_atof (type, litP, sizeP)
  1086.      char type;
  1087.      char *litP;
  1088.      int *sizeP;
  1089. {
  1090.   int prec;
  1091.   LITTLENUM_TYPE words[MAX_LITTLENUMS];
  1092.   LITTLENUM_TYPE *wordP;
  1093.   char *t;
  1094.   char *atof_ieee ();
  1095.  
  1096.   switch (type)
  1097.     {
  1098.     case 'f':
  1099.     case 'F':
  1100.     case 's':
  1101.     case 'S':
  1102.       prec = 2;
  1103.       break;
  1104.  
  1105.     case 'd':
  1106.     case 'D':
  1107.     case 'r':
  1108.     case 'R':
  1109.       prec = 4;
  1110.       break;
  1111.  
  1112.     case 'x':
  1113.     case 'X':
  1114.       prec = 6;
  1115.       break;
  1116.  
  1117.     case 'p':
  1118.     case 'P':
  1119.       prec = 6;
  1120.       break;
  1121.  
  1122.     default:
  1123.       *sizeP = 0;
  1124.       return "Bad call to MD_ATOF()";
  1125.     }
  1126.   t = atof_ieee (input_line_pointer, type, words);
  1127.   if (t)
  1128.     input_line_pointer = t;
  1129.   *sizeP = prec * sizeof (LITTLENUM_TYPE);
  1130.   for (wordP = words; prec--;)
  1131.     {
  1132.       md_number_to_chars (litP, (valueT) (*wordP++), sizeof (LITTLENUM_TYPE));
  1133.       litP += sizeof (LITTLENUM_TYPE);
  1134.     }
  1135.   return "";
  1136. }
  1137.  
  1138. /*
  1139.  * Write out big-endian.
  1140.  */
  1141. void
  1142. md_number_to_chars (buf, val, n)
  1143.      char *buf;
  1144.      long val;
  1145.      int n;
  1146. {
  1147.   // sigh, all architectures do this..,
  1148.   switch(n) {
  1149.     
  1150.   case 4:
  1151.     *buf++ = val >> 24;
  1152.     *buf++ = val >> 16;
  1153.   case 2:
  1154.     *buf++ = val >> 8;
  1155.   case 1:
  1156.     *buf = val;
  1157.     break;
  1158.     
  1159.   default:
  1160.     abort();
  1161.   }
  1162. }
  1163.  
  1164. /* Apply a fixS to the frags, now that we know the value it ought to
  1165.    hold. */
  1166.  
  1167.  
  1168. void
  1169. md_number_to_imm(unsigned char *buf, long val, int size, fixS *fixP, int nsect)
  1170. {
  1171.  
  1172.   /* handle the most common case quickly */
  1173.   if ((fixP->fx_r_type == NO_RELOC) ||
  1174.       (fixP->fx_r_type == SPARC_RELOC_NONE) ||
  1175.       (fixP->fx_r_type == SPARC_RELOC_VANILLA)) {
  1176.     switch(size){
  1177.     case 4:
  1178.       *buf++ = val >> 24;
  1179.       *buf++ = val >> 16;
  1180.     case 2:
  1181.       *buf++ = val >> 8;
  1182.     case 1:
  1183.       *buf = val;
  1184.       break;
  1185.     default:
  1186.       abort();
  1187.     }
  1188.     return;
  1189.   }
  1190.  
  1191.   switch (fixP->fx_r_type) {
  1192.   case SPARC_RELOC_WDISP30:
  1193.     val = (val >> 2) + 1;    /* adjust for word displacement */
  1194.     buf[0] |= (val >> 24) & 0x3f;
  1195.     buf[1] = (val >> 16);
  1196.     buf[2] = val >> 8;
  1197.     buf[3] = val;
  1198.     break;
  1199.   case SPARC_RELOC_WDISP22:
  1200.     val = (val >>= 2) + 1;
  1201.     buf[1] |= (val >> 16) & 0x3f;
  1202.     buf[2] = val >> 8;
  1203.     buf[3] = val;
  1204.     break;
  1205.   case SPARC_RELOC_HI22:
  1206.     buf[1] |= (val >> 26) & 0x3f;
  1207.     buf[2] = val >> 18;
  1208.     buf[3] = val >> 10;
  1209.     break;
  1210.   case SPARC_RELOC_LO10:
  1211.     buf[2] |= (val >> 8) & 0x03;
  1212.     buf[3] = val;
  1213.     break;
  1214.  
  1215.   /* special cases that need to be handled internally by the as */
  1216.   case SPARC_RELOC_22:
  1217.     if (!fixP->fx_addsy) {
  1218.       if (val & ~0x003fffff) {
  1219.     as_bad ("relocation overflow");
  1220.       }            /* on overflow */
  1221.       buf[1] |= (val >> 16) & 0x3f;
  1222.       buf[2] = val >> 8;
  1223.       buf[3] = val & 0xff;
  1224.     } else
  1225.       as_bad ("Undefined symbolic 22-bit immediate reference: %s", 
  1226.           fixP->fx_addsy->sy_name);
  1227.     break;
  1228.   case SPARC_RELOC_13:
  1229.     if (!fixP->fx_addsy) {
  1230.       if (((val > 0) && (val & ~(offsetT)0x00001fff))
  1231.       || ((val < 0) && (~(val - 1) & ~(offsetT)0x00001fff))) {
  1232.     as_bad ("relocation overflow");
  1233.       }
  1234.       buf[2] |= (val >> 8) & 0x1f;
  1235.       buf[3] = val;
  1236.     } else
  1237.       as_bad ("Undefined symbolic 13-bit immediate reference: %s", 
  1238.           fixP->fx_addsy->sy_name);
  1239.     break;
  1240.   case SPARC_RELOC_NONE:
  1241.   default:
  1242.     as_bad ("bad or unhandled relocation type: 0x%02x", fixP->fx_r_type);
  1243.     break;
  1244.   }
  1245. }
  1246.  
  1247.  
  1248. /*
  1249.  * md_parse_option
  1250.  *    Invocation line includes a switch not recognized by the base assembler.
  1251.  *    See if it's a processor-specific option.  These are:
  1252.  *
  1253.  *    -bump
  1254.  *        Warn on architecture bumps.  See also -A.
  1255.  *
  1256.  *    -Av6, -Av7, -Av8, -Asparclite
  1257.  *        Select the architecture.  Instructions or features not
  1258.  *        supported by the selected architecture cause fatal errors.
  1259.  *
  1260.  *        The default is to start at v6, and bump the architecture up
  1261.  *        whenever an instruction is seen at a higher level.
  1262.  *
  1263.  *        If -bump is specified, a warning is printing when bumping to
  1264.  *        higher levels.
  1265.  *
  1266.  *        If an architecture is specified, all instructions must match
  1267.  *        that architecture.  Any higher level instructions are flagged
  1268.  *        as errors.
  1269.  *
  1270.  *        if both an architecture and -bump are specified, the
  1271.  *        architecture starts at the specified level, but bumps are
  1272.  *        warnings.
  1273.  *
  1274.  */
  1275.  
  1276. int 
  1277. md_parse_option (argP, cntP, vecP)
  1278.      char **argP;
  1279.      int *cntP;
  1280.      char ***vecP;
  1281. {
  1282.   char *p;
  1283.   const char **arch;
  1284.  
  1285.   if (!strcmp (*argP, "bump"))
  1286.     {
  1287.       warn_on_bump = 1;
  1288.     }
  1289.   else if (**argP == 'A')
  1290.     {
  1291.       p = (*argP) + 1;
  1292.  
  1293.       for (arch = architecture_pname; *arch != NULL; ++arch)
  1294.     {
  1295.       if (strcmp (p, *arch) == 0)
  1296.         {
  1297.           break;
  1298.         }            /* found a match */
  1299.     }            /* walk the pname table */
  1300.  
  1301.       if (*arch == NULL)
  1302.     {
  1303.       as_bad ("unknown architecture: %s", p);
  1304.     }
  1305.       else
  1306.     {
  1307.       current_architecture = (enum sparc_architecture) (arch - architecture_pname);
  1308.       architecture_requested = 1;
  1309.     }
  1310.     }
  1311. #ifndef NeXT
  1312. #ifdef OBJ_ELF
  1313.   else if (**argP == 'V')
  1314.     {
  1315.       print_version_id ();
  1316.     }
  1317.   else if (**argP == 'Q')
  1318.     {
  1319.       /* Qy - do emit .comment
  1320.      Qn - do not emit .comment */
  1321.     }
  1322.   else if (**argP == 's')
  1323.     {
  1324.       /* use .stab instead of .stab.excl */
  1325.     }
  1326. #endif
  1327.   else if (strcmp (*argP, "sparc") == 0)
  1328.     {
  1329.       /* Ignore -sparc, used by SunOS make default .s.o rule.  */
  1330.     }
  1331. #endif /* NeXT */
  1332.   else
  1333.     {
  1334.       /* Unknown option */
  1335.       (*argP)++;
  1336.       return 0;
  1337.     }
  1338.   **argP = '\0';        /* Done parsing this switch */
  1339.   return 1;
  1340. }                /* md_parse_option() */
  1341.  
  1342.  
  1343. int
  1344. md_estimate_size_before_relax(
  1345. fragS *fragP,
  1346. int segment_type)
  1347. {
  1348.     as_fatal("internal error: Relaxation should never occur");
  1349.     return(0);
  1350. }
  1351.  
  1352. void
  1353. md_convert_frag(
  1354. fragS *fragP)
  1355. {
  1356.     as_fatal("internal error: Relaxation should never occur");
  1357. }
  1358.  
  1359.  
  1360. #ifdef DEBUGINSN
  1361.  
  1362. char *
  1363. S_GET_NAME(sym)
  1364.      symbolS *sym;
  1365. {
  1366.   return (sym->sy_nlist.n_un.n_name);
  1367. }
  1368.  
  1369. /* for debugging only */
  1370. static void
  1371. print_insn (insn)
  1372.      struct sparc_it *insn;
  1373. {
  1374.   const char *const Reloc[] = {
  1375.     "VANILLA",
  1376.     "PAIR",
  1377.     "HI22",
  1378.     "LO10",
  1379.     "DISP22",
  1380.     "PCREL",
  1381.     "22",
  1382.     "13",
  1383.     "SECTDIFF",
  1384.     "HI22_SECTDIFF",
  1385.     "LO10_SECTDIFF",
  1386.     "NONE",
  1387.     "UNUSED"
  1388.   };
  1389.  
  1390.   const char *const InternalReloc[] = {
  1391.     "13",
  1392.     "22"
  1393.   };
  1394.  
  1395.   if (insn->error)
  1396.     fprintf (stderr, "ERROR: %s\n", insn->error);
  1397.   fprintf (stderr, "opcode=0x%08x\n", (unsigned int)insn->opcode);
  1398.   if (insn->reloc >= 127)
  1399.     fprintf (stderr, "internal reloc = %s\n", InternalReloc[insn->reloc-127]);
  1400.   else
  1401.     fprintf (stderr, "reloc = %s\n", Reloc[insn->reloc]);
  1402.   fprintf (stderr, "X_add_number = 0x%x\n",
  1403.        insn->exp.X_add_number);
  1404.  
  1405.   if (insn->exp.X_add_symbol != NULL)
  1406.     fprintf(stderr, "Add symbol: %s\n", S_GET_NAME(insn->exp.X_add_symbol));
  1407.   if (insn->exp.X_subtract_symbol != NULL)
  1408.     fprintf(stderr, "Subtract symbol: %s\n", S_GET_NAME(insn->exp.X_subtract_symbol));
  1409. }
  1410. #endif
  1411.