gas/config/tc-ip2k.c

   1 /* tc-ip2k.c -- Assembler for the Scenix IP2xxx.
   2    Copyright (C) 2000, 2002, 2003, 2005 Free Software Foundation.
   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, 51 Franklin Street - Fifth Floor,
  19    Boston, MA 02110-1301, USA.  */
  20
  21 #include <stdio.h>
  22 #include "as.h"
  23 #include "subsegs.h"
  24 #include "symcat.h"
  25 #include "opcodes/ip2k-desc.h"
  26 #include "opcodes/ip2k-opc.h"
  27 #include "cgen.h"
  28 #include "elf/common.h"
  29 #include "elf/ip2k.h"
  30 #include "libbfd.h"
  31
  32 /* Structure to hold all of the different components describing
  33    an individual instruction.  */
  34 typedef struct
  35 {
  36   const CGEN_INSN *     insn;
  37   const CGEN_INSN *     orig_insn;
  38   CGEN_FIELDS           fields;
  39 #if CGEN_INT_INSN_P
  40   CGEN_INSN_INT         buffer [1];
  41 #define INSN_VALUE(buf) (*(buf))
  42 #else
  43   unsigned char         buffer [CGEN_MAX_INSN_SIZE];
  44 #define INSN_VALUE(buf) (buf)
  45 #endif
  46   char *                addr;
  47   fragS *               frag;
  48   int                   num_fixups;
  49   fixS *                fixups [GAS_CGEN_MAX_FIXUPS];
  50   int                   indices [MAX_OPERAND_INSTANCES];
  51 }
  52 ip2k_insn;
  53
  54 const char comment_chars[]        = ";";
  55 const char line_comment_chars[]   = "#";
  56 const char line_separator_chars[] = "";
  57 const char EXP_CHARS[]            = "eE";
  58 const char FLT_CHARS[]            = "dD";
  59
  60 /* Flag to detect when switching to code section where insn alignment is
  61    implied.  */
  62 static int force_code_align = 0;
  63
  64 /* Mach selected from command line.  */
  65 static int ip2k_mach = 0;
  66 static unsigned ip2k_mach_bitmask = 0;
  67
  68
  69 static void
  70 ip2k_elf_section_rtn (int i)
  71 {
  72   obj_elf_section(i);
  73
  74   if (force_code_align)
  75     {
  76       /* The s_align_ptwo function expects that we are just after a .align
  77          directive and it will either try and read the align value or stop
  78          if end of line so we must fake it out so it thinks we are at the
  79          end of the line.  */
  80       char *old_input_line_pointer = input_line_pointer;
  81       input_line_pointer = "\n";
  82       s_align_ptwo (1);
  83       force_code_align = 0;
  84       /* Restore.  */
  85       input_line_pointer = old_input_line_pointer;
  86     }
  87 }
  88
  89 static void
  90 ip2k_elf_section_text (int i)
  91 {
  92   char *old_input_line_pointer;
  93   obj_elf_text(i);
  94
  95   /* the s_align_ptwo function expects that we are just after a .align
  96      directive and it will either try and read the align value or stop if
  97      end of line so we must fake it out so it thinks we are at the end of
  98      the line.  */
  99   old_input_line_pointer = input_line_pointer;
 100   input_line_pointer = "\n";
 101   s_align_ptwo (1);
 102   force_code_align = 0;
 103   /* Restore.  */
 104   input_line_pointer = old_input_line_pointer;
 105 }
 106
 107 /* The target specific pseudo-ops which we support.  */
 108 const pseudo_typeS md_pseudo_table[] =
 109 {
 110     { "text",   ip2k_elf_section_text,  0 },
 111     { "sect",   ip2k_elf_section_rtn,   0 },
 112     { NULL,     NULL,                   0 }
 113 };
 114
 115 \f
 116
 117 enum options
 118 {
 119   OPTION_CPU_IP2022 = OPTION_MD_BASE,
 120   OPTION_CPU_IP2022EXT
 121 };
 122
 123 struct option md_longopts[] =
 124 {
 125   { "mip2022",     no_argument, NULL, OPTION_CPU_IP2022 },
 126   { "mip2022ext",  no_argument, NULL, OPTION_CPU_IP2022EXT },
 127   { NULL,           no_argument, NULL, 0 },
 128 };
 129 size_t md_longopts_size = sizeof (md_longopts);
 130
 131 const char * md_shortopts = "";
 132
 133 int
 134 md_parse_option (int c ATTRIBUTE_UNUSED, char * arg ATTRIBUTE_UNUSED)
 135 {
 136   switch (c)
 137     {
 138     case OPTION_CPU_IP2022:
 139       ip2k_mach = bfd_mach_ip2022;
 140       ip2k_mach_bitmask = 1 << MACH_IP2022;
 141       break;
 142
 143     case OPTION_CPU_IP2022EXT:
 144       ip2k_mach = bfd_mach_ip2022ext;
 145       ip2k_mach_bitmask = 1 << MACH_IP2022EXT;
 146       break;
 147
 148     default:
 149       return 0;
 150     }
 151
 152   return 1;
 153 }
 154
 155 void
 156 md_show_usage (FILE * stream)
 157 {
 158   fprintf (stream, _("IP2K specific command line options:\n"));
 159   fprintf (stream, _("  -mip2022               restrict to IP2022 insns \n"));
 160   fprintf (stream, _("  -mip2022ext            permit extended IP2022 insn\n"));
 161 }
 162
 163 \f
 164 void
 165 md_begin (void)
 166 {
 167   /* Initialize the `cgen' interface.  */
 168
 169   /* Set the machine number and endian.  */
 170   gas_cgen_cpu_desc = ip2k_cgen_cpu_open (CGEN_CPU_OPEN_MACHS,
 171                                           ip2k_mach_bitmask,
 172                                           CGEN_CPU_OPEN_ENDIAN,
 173                                           CGEN_ENDIAN_BIG,
 174                                           CGEN_CPU_OPEN_END);
 175   ip2k_cgen_init_asm (gas_cgen_cpu_desc);
 176
 177   /* This is a callback from cgen to gas to parse operands.  */
 178   cgen_set_parse_operand_fn (gas_cgen_cpu_desc, gas_cgen_parse_operand);
 179
 180   /* Set the machine type.  */
 181   bfd_default_set_arch_mach (stdoutput, bfd_arch_ip2k, ip2k_mach);
 182 }
 183
 184
 185 void
 186 md_assemble (char * str)
 187 {
 188   ip2k_insn insn;
 189   char * errmsg;
 190
 191   /* Initialize GAS's cgen interface for a new instruction.  */
 192   gas_cgen_init_parse ();
 193
 194   insn.insn = ip2k_cgen_assemble_insn
 195       (gas_cgen_cpu_desc, str, & insn.fields, insn.buffer, & errmsg);
 196
 197   if (!insn.insn)
 198     {
 199       as_bad ("%s", errmsg);
 200       return;
 201     }
 202
 203   /* Check for special relocation required by SKIP instructions.  */
 204   if (CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_SKIPA))
 205     /* Unconditional skip has a 1-bit relocation of the current pc, so
 206        that we emit either sb pcl.0 or snb pcl.0 depending on whether
 207        the PCL (pc + 2) >> 1 is odd or even.  */
 208     {
 209       enum cgen_parse_operand_result result_type;
 210       bfd_vma value;
 211       const char *curpc_plus_2 = ".+2";
 212       const char *err;
 213
 214       err = cgen_parse_address (gas_cgen_cpu_desc, & curpc_plus_2,
 215                                 IP2K_OPERAND_ADDR16CJP,
 216                                 BFD_RELOC_IP2K_PC_SKIP,
 217                                 & result_type, & value);
 218       if (err)
 219         {
 220           as_bad ("%s", err);
 221           return;
 222         }
 223     }
 224
 225   /* Doesn't really matter what we pass for RELAX_P here.  */
 226   gas_cgen_finish_insn (insn.insn, insn.buffer,
 227                         CGEN_FIELDS_BITSIZE (& insn.fields), 1, NULL);
 228 }
 229
 230 valueT
 231 md_section_align (segT segment, valueT size)
 232 {
 233   int align = bfd_get_section_alignment (stdoutput, segment);
 234
 235   return ((size + (1 << align) - 1) & (-1 << align));
 236 }
 237
 238
 239 symbolS *
 240 md_undefined_symbol (char * name ATTRIBUTE_UNUSED)
 241 {
 242     return 0;
 243 }
 244 \f
 245 int
 246 md_estimate_size_before_relax (fragS * fragP ATTRIBUTE_UNUSED,
 247                                segT    segment ATTRIBUTE_UNUSED)
 248 {
 249   as_fatal (_("md_estimate_size_before_relax\n"));
 250   return 1;
 251 }
 252
 253
 254 /* *fragP has been relaxed to its final size, and now needs to have
 255    the bytes inside it modified to conform to the new size.
 256
 257    Called after relaxation is finished.
 258    fragP->fr_type == rs_machine_dependent.
 259    fragP->fr_subtype is the subtype of what the address relaxed to.  */
 260
 261 void
 262 md_convert_frag (bfd   * abfd  ATTRIBUTE_UNUSED,
 263                  segT    sec   ATTRIBUTE_UNUSED,
 264                  fragS * fragP ATTRIBUTE_UNUSED)
 265 {
 266 }
 267
 268 \f
 269 /* Functions concerning relocs.  */
 270
 271 long
 272 md_pcrel_from (fixS *fixP)
 273 {
 274   as_fatal (_("md_pcrel_from\n"));
 275
 276   /* Return the address of the delay slot. */
 277   return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
 278 }
 279
 280
 281 /* Return the bfd reloc type for OPERAND of INSN at fixup FIXP.
 282    Returns BFD_RELOC_NONE if no reloc type can be found.
 283    *FIXP may be modified if desired.  */
 284
 285 bfd_reloc_code_real_type
 286 md_cgen_lookup_reloc (const CGEN_INSN *    insn     ATTRIBUTE_UNUSED,
 287                       const CGEN_OPERAND * operand,
 288                       fixS *               fixP     ATTRIBUTE_UNUSED)
 289 {
 290   bfd_reloc_code_real_type result;
 291
 292   result = BFD_RELOC_NONE;
 293
 294   switch (operand->type)
 295     {
 296     case IP2K_OPERAND_FR:
 297     case IP2K_OPERAND_ADDR16L:
 298     case IP2K_OPERAND_ADDR16H:
 299     case IP2K_OPERAND_LIT8:
 300       /* These may have been processed at parse time.  */
 301       if (fixP->fx_cgen.opinfo != 0)
 302         result = fixP->fx_cgen.opinfo;
 303       fixP->fx_no_overflow = 1;
 304       break;
 305
 306     case IP2K_OPERAND_ADDR16CJP:
 307       result = fixP->fx_cgen.opinfo;
 308       if (result == 0 || result == BFD_RELOC_NONE)
 309         result = BFD_RELOC_IP2K_ADDR16CJP;
 310       fixP->fx_no_overflow = 1;
 311       break;
 312
 313     case IP2K_OPERAND_ADDR16P:
 314       result = BFD_RELOC_IP2K_PAGE3;
 315       fixP->fx_no_overflow = 1;
 316       break;
 317
 318     default:
 319       result = BFD_RELOC_NONE;
 320       break;
 321     }
 322
 323   return result;
 324 }
 325
 326
 327 /* Write a value out to the object file, using the appropriate endianness.  */
 328
 329 void
 330 md_number_to_chars (char * buf, valueT val, int n)
 331 {
 332   number_to_chars_bigendian (buf, val, n);
 333 }
 334
 335 /* Turn a string in input_line_pointer into a floating point constant of type
 336    type, and store the appropriate bytes in *litP.  The number of LITTLENUMS
 337    emitted is stored in *sizeP .  An error message is returned, or NULL on
 338    OK.  */
 339
 340 /* Equal to MAX_PRECISION in atof-ieee.c  */
 341 #define MAX_LITTLENUMS 6
 342
 343 char *
 344 md_atof (int type, char * litP, int *  sizeP)
 345 {
 346   int              prec;
 347   LITTLENUM_TYPE   words [MAX_LITTLENUMS];
 348   LITTLENUM_TYPE  *wordP;
 349   char *           t;
 350
 351   switch (type)
 352     {
 353     case 'f':
 354     case 'F':
 355     case 's':
 356     case 'S':
 357       prec = 2;
 358       break;
 359
 360     case 'd':
 361     case 'D':
 362     case 'r':
 363     case 'R':
 364       prec = 4;
 365       break;
 366
 367    /* FIXME: Some targets allow other format chars for bigger sizes here.  */
 368
 369     default:
 370       * sizeP = 0;
 371       return _("Bad call to md_atof()");
 372     }
 373
 374   t = atof_ieee (input_line_pointer, type, words);
 375   if (t)
 376     input_line_pointer = t;
 377   * sizeP = prec * sizeof (LITTLENUM_TYPE);
 378
 379   /* This loops outputs the LITTLENUMs in REVERSE order; in accord with
 380      the ip2k endianness.  */
 381   for (wordP = words; prec--;)
 382     {
 383       md_number_to_chars (litP, (valueT) (*wordP++), sizeof (LITTLENUM_TYPE));
 384       litP += sizeof (LITTLENUM_TYPE);
 385     }
 386
 387   return 0;
 388 }
 389
 390
 391 /* See whether we need to force a relocation into the output file.
 392    Force most of them, since the linker's bfd relocation engine
 393    understands range limits better than gas' cgen fixup engine.
 394    Consider the case of a fixup intermediate value being larger than
 395    the instruction it will be eventually encoded within.  */
 396
 397 int
 398 ip2k_force_relocation (fixS * fix)
 399 {
 400   switch (fix->fx_r_type)
 401     {
 402     case BFD_RELOC_IP2K_FR9:
 403     case BFD_RELOC_IP2K_FR_OFFSET:
 404     case BFD_RELOC_IP2K_BANK:
 405     case BFD_RELOC_IP2K_ADDR16CJP:
 406     case BFD_RELOC_IP2K_PAGE3:
 407     case BFD_RELOC_IP2K_LO8DATA:
 408     case BFD_RELOC_IP2K_HI8DATA:
 409     case BFD_RELOC_IP2K_EX8DATA:
 410     case BFD_RELOC_IP2K_LO8INSN:
 411     case BFD_RELOC_IP2K_HI8INSN:
 412     case BFD_RELOC_IP2K_PC_SKIP:
 413     case BFD_RELOC_IP2K_TEXT:
 414       return 1;
 415
 416     case BFD_RELOC_16:
 417       if (fix->fx_subsy && S_IS_DEFINED (fix->fx_subsy)
 418           && fix->fx_addsy && S_IS_DEFINED (fix->fx_addsy)
 419           && (S_GET_SEGMENT (fix->fx_addsy)->flags & SEC_CODE))
 420         {
 421           fix->fx_r_type = BFD_RELOC_IP2K_TEXT;
 422           return 0;
 423         }
 424       break;
 425
 426     default:
 427       break;
 428     }
 429
 430   return generic_force_reloc (fix);
 431 }
 432
 433 void
 434 ip2k_apply_fix (fixS *fixP, valueT *valueP, segT seg)
 435 {
 436   if (fixP->fx_r_type == BFD_RELOC_IP2K_TEXT
 437       && ! fixP->fx_addsy
 438       && ! fixP->fx_subsy)
 439     {
 440       *valueP = ((int)(* valueP)) / 2;
 441       fixP->fx_r_type = BFD_RELOC_16;
 442     }
 443   else if (fixP->fx_r_type == BFD_RELOC_UNUSED + IP2K_OPERAND_FR)
 444     {
 445       /* Must be careful when we are fixing up an FR.  We could be
 446          fixing up an offset to (SP) or (DP) in which case we don't
 447          want to step on the top 2 bits of the FR operand.  The
 448          gas_cgen_md_apply_fix doesn't know any better and overwrites
 449          the entire operand.  We counter this by adding the bits
 450          to the new value.  */
 451       char *where = fixP->fx_frag->fr_literal + fixP->fx_where;
 452
 453       /* Canonical name, since used a lot.  */
 454       CGEN_CPU_DESC cd = gas_cgen_cpu_desc;
 455       CGEN_INSN_INT insn_value
 456         = cgen_get_insn_value (cd, (unsigned char *) where,
 457                                CGEN_INSN_BITSIZE (fixP->fx_cgen.insn));
 458       /* Preserve (DP) or (SP) specification.  */
 459       *valueP += (insn_value & 0x180);
 460     }
 461
 462   gas_cgen_md_apply_fix (fixP, valueP, seg);
 463 }
 464
 465 int
 466 ip2k_elf_section_flags (int flags,
 467                         int attr ATTRIBUTE_UNUSED,
 468                         int type ATTRIBUTE_UNUSED)
 469 {
 470   /* This is used to detect when the section changes to an executable section.
 471      This function is called by the elf section processing.  When we note an
 472      executable section specifier we set an internal flag to denote when
 473      word alignment should be forced.  */
 474   if (flags & SEC_CODE)
 475     force_code_align = 1;
 476
 477   return flags;
 478 }
 479