gas/config/tc-ip2k.c

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