gas/config/tc-m32c.c

   1 /* tc-m32c.c -- Assembler for the Renesas M32C.
   2    Copyright (C) 2005 Free Software Foundation.
   3    Contributed by RedHat.
   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
  19    the Free Software Foundation, 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include <stdio.h>
  23 #include "as.h"
  24 #include "subsegs.h"
  25 #include "symcat.h"
  26 #include "opcodes/m32c-desc.h"
  27 #include "opcodes/m32c-opc.h"
  28 #include "cgen.h"
  29 #include "elf/common.h"
  30 #include "elf/m32c.h"
  31 #include "libbfd.h"
  32 #include "libiberty.h"
  33 #include "safe-ctype.h"
  34
  35 /* Structure to hold all of the different components
  36    describing an individual instruction.  */
  37 typedef struct
  38 {
  39   const CGEN_INSN *     insn;
  40   const CGEN_INSN *     orig_insn;
  41   CGEN_FIELDS           fields;
  42 #if CGEN_INT_INSN_P
  43   CGEN_INSN_INT         buffer [1];
  44 #define INSN_VALUE(buf) (*(buf))
  45 #else
  46   unsigned char         buffer [CGEN_MAX_INSN_SIZE];
  47 #define INSN_VALUE(buf) (buf)
  48 #endif
  49   char *                addr;
  50   fragS *               frag;
  51   int                   num_fixups;
  52   fixS *                fixups [GAS_CGEN_MAX_FIXUPS];
  53   int                   indices [MAX_OPERAND_INSTANCES];
  54 }
  55 m32c_insn;
  56
  57 const char comment_chars[]        = ";";
  58 const char line_comment_chars[]   = "#";
  59 const char line_separator_chars[] = "|";
  60 const char EXP_CHARS[]            = "eE";
  61 const char FLT_CHARS[]            = "dD";
  62 \f
  63 #define M32C_SHORTOPTS ""
  64 const char * md_shortopts = M32C_SHORTOPTS;
  65
  66 /* assembler options */
  67 #define OPTION_CPU_M16C        (OPTION_MD_BASE)
  68 #define OPTION_CPU_M32C        (OPTION_MD_BASE + 1)
  69
  70 struct option md_longopts[] =
  71 {
  72   { "m16c",       no_argument,        NULL, OPTION_CPU_M16C   },
  73   { "m32c",       no_argument,        NULL, OPTION_CPU_M32C   },
  74   {NULL, no_argument, NULL, 0}
  75 };
  76 size_t md_longopts_size = sizeof (md_longopts);
  77
  78 /* Default machine */
  79
  80 #define DEFAULT_MACHINE bfd_mach_m16c
  81 #define DEFAULT_FLAGS   EF_M32C_CPU_M16C
  82
  83 static unsigned long m32c_mach = bfd_mach_m16c;
  84 static int cpu_mach = (1 << MACH_M16C);
  85 static int insn_size;
  86
  87 /* Flags to set in the elf header */
  88 static flagword m32c_flags = DEFAULT_FLAGS;
  89
  90 static unsigned int m32c_isa = (1 << ISA_M16C);
  91
  92 static void
  93 set_isa (enum isa_attr isa_num)
  94 {
  95   m32c_isa = (1 << isa_num);
  96 }
  97
  98 static void s_bss (int);
  99
 100 int
 101 md_parse_option (int c, char * arg ATTRIBUTE_UNUSED)
 102 {
 103   switch (c)
 104     {
 105     case OPTION_CPU_M16C:
 106       m32c_flags = (m32c_flags & ~EF_M32C_CPU_MASK) | EF_M32C_CPU_M16C;
 107       m32c_mach = bfd_mach_m16c;
 108       cpu_mach = (1 << MACH_M16C);
 109       set_isa (ISA_M16C);
 110       break;
 111
 112     case OPTION_CPU_M32C:
 113       m32c_flags = (m32c_flags & ~EF_M32C_CPU_MASK) | EF_M32C_CPU_M32C;
 114       m32c_mach = bfd_mach_m32c;
 115       cpu_mach = (1 << MACH_M32C);
 116       set_isa (ISA_M32C);
 117       break;
 118
 119     default:
 120       return 0;
 121     }
 122   return 1;
 123 }
 124
 125 void
 126 md_show_usage (FILE * stream)
 127 {
 128   fprintf (stream, _(" M32C specific command line options:\n"));
 129 }
 130
 131 static void
 132 s_bss (int ignore ATTRIBUTE_UNUSED)
 133 {
 134   int temp;
 135
 136   temp = get_absolute_expression ();
 137   subseg_set (bss_section, (subsegT) temp);
 138   demand_empty_rest_of_line ();
 139 }
 140
 141 /* The target specific pseudo-ops which we support.  */
 142 const pseudo_typeS md_pseudo_table[] =
 143 {
 144   { "bss",      s_bss,          0},
 145   { "word",     cons,           4 },
 146   { NULL,       NULL,           0 }
 147 };
 148
 149 \f
 150 void
 151 md_begin (void)
 152 {
 153   /* Initialize the `cgen' interface.  */
 154
 155   /* Set the machine number and endian.  */
 156   gas_cgen_cpu_desc = m32c_cgen_cpu_open (CGEN_CPU_OPEN_MACHS, cpu_mach,
 157                                           CGEN_CPU_OPEN_ENDIAN,
 158                                           CGEN_ENDIAN_BIG,
 159                                           CGEN_CPU_OPEN_ISAS, m32c_isa,
 160                                           CGEN_CPU_OPEN_END);
 161
 162   m32c_cgen_init_asm (gas_cgen_cpu_desc);
 163
 164   /* This is a callback from cgen to gas to parse operands.  */
 165   cgen_set_parse_operand_fn (gas_cgen_cpu_desc, gas_cgen_parse_operand);
 166
 167   /* Set the ELF flags if desired. */
 168   if (m32c_flags)
 169     bfd_set_private_flags (stdoutput, m32c_flags);
 170
 171   /* Set the machine type */
 172   bfd_default_set_arch_mach (stdoutput, bfd_arch_m32c, m32c_mach);
 173
 174   insn_size = 0;
 175 }
 176
 177 void
 178 m32c_md_end (void)
 179 {
 180   int i, n_nops;
 181
 182   /* Pad with nops for objdump.  */
 183   n_nops = (32 - ((insn_size) % 32)) / 8;
 184   for (i = 1; i <= n_nops; i++)
 185     md_assemble ("nop");
 186 }
 187
 188 void
 189 m32c_start_line_hook (void)
 190 {
 191 #if 0 /* not necessary....handled in the .cpu file */
 192   char *s = input_line_pointer;
 193   char *sg;
 194
 195   for (s = input_line_pointer ; s && s[0] != '\n'; s++)
 196     {
 197       if (s[0] == ':')
 198         {
 199           /* Remove :g suffix.  Squeeze out blanks.  */
 200           if (s[1] == 'g')
 201             {
 202               for (sg = s - 1; sg && sg >= input_line_pointer; sg--)
 203                 {
 204                   sg[2] = sg[0];
 205                 }
 206               sg[1] = ' ';
 207               sg[2] = ' ';
 208               input_line_pointer += 2;
 209             }
 210         }
 211     }
 212 #endif
 213 }
 214
 215 /* Process [[indirect-operands]] in instruction str.  */
 216
 217 static bfd_boolean
 218 m32c_indirect_operand (char *str)
 219 {
 220   char *new_str;
 221   char *s;
 222   char *ns;
 223   int ns_len;
 224   char *ns_end;
 225   enum indirect_type {none, relative, absolute} ;
 226   enum indirect_type indirection [3] = { none, none, none };
 227   int brace_n [3] = { 0, 0, 0 };
 228   int operand;
 229
 230   s = str;
 231   operand = 1;
 232   for (s = str; *s; s++)
 233     {
 234       if (s[0] == ',')
 235         operand = 2;
 236       /* [abs] where abs is not a0 or a1  */
 237       if (s[1] == '[' && ! (s[2] == 'a' && (s[3] == '0' || s[3] == '1'))
 238           && (ISBLANK (s[0]) || s[0] == ','))
 239         indirection[operand] = absolute;
 240       if (s[0] == ']' && s[1] == ']')
 241         indirection[operand] = relative;
 242       if (s[0] == '[' && s[1] == '[')
 243         indirection[operand] = relative;
 244     }
 245
 246   if (indirection[1] == none && indirection[2] == none)
 247     return FALSE;
 248
 249   operand = 1;
 250   ns_len = strlen (str);
 251   new_str = (char*) xmalloc (ns_len);
 252   ns = new_str;
 253   ns_end = ns + ns_len;
 254
 255   for (s = str; *s; s++)
 256     {
 257       if (s[0] == ',')
 258         operand = 2;
 259
 260       if (s[0] == '[' && ! brace_n[operand])
 261         {
 262           brace_n[operand] += 1;
 263           /* Squeeze [[ to [ if this is an indirect operand.  */
 264           if (indirection[operand] != none)
 265             continue;
 266         }
 267
 268       else if (s[0] == '[' && brace_n[operand])
 269         {
 270           brace_n[operand] += 1;
 271         }
 272       else if (s[0] == ']' && s[1] == ']' && indirection[operand] == relative)
 273         {
 274           s += 1;               /* skip one ].  */
 275           brace_n[operand] -= 2; /* allow for 2 [.  */
 276         }
 277       else if (s[0] == ']' && indirection[operand] == absolute)
 278         {
 279           brace_n[operand] -= 1;
 280           continue;             /* skip closing ].  */
 281         }
 282       else if (s[0] == ']')
 283         {
 284           brace_n[operand] -= 1;
 285         }
 286       *ns = s[0];
 287       ns += 1;
 288       if (ns >= ns_end)
 289         return FALSE;
 290       if (s[0] == 0)
 291         break;
 292     }
 293   *ns = '\0';
 294   for (operand = 1; operand <= 2; operand++)
 295     if (brace_n[operand])
 296       {
 297         fprintf (stderr, "Unmatched [[operand-%d]] %d\n", operand, brace_n[operand]);
 298       }
 299
 300   if (indirection[1] != none && indirection[2] != none)
 301     md_assemble ("src-dest-indirect");
 302   else if (indirection[1] != none)
 303     md_assemble ("src-indirect");
 304   else if (indirection[2] != none)
 305     md_assemble ("dest-indirect");
 306
 307   md_assemble (new_str);
 308   free (new_str);
 309   return TRUE;
 310 }
 311
 312 void
 313 md_assemble (char * str)
 314 {
 315   static int last_insn_had_delay_slot = 0;
 316   m32c_insn insn;
 317   char *    errmsg;
 318
 319   if (m32c_mach == bfd_mach_m32c && m32c_indirect_operand (str))
 320     return;
 321
 322   /* Initialize GAS's cgen interface for a new instruction.  */
 323   gas_cgen_init_parse ();
 324
 325   insn.insn = m32c_cgen_assemble_insn
 326     (gas_cgen_cpu_desc, str, & insn.fields, insn.buffer, & errmsg);
 327
 328   if (!insn.insn)
 329     {
 330       as_bad ("%s", errmsg);
 331       return;
 332     }
 333
 334   /* Doesn't really matter what we pass for RELAX_P here.  */
 335   gas_cgen_finish_insn (insn.insn, insn.buffer,
 336                         CGEN_FIELDS_BITSIZE (& insn.fields), 1, NULL);
 337
 338   last_insn_had_delay_slot
 339     = CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_DELAY_SLOT);
 340   insn_size = CGEN_INSN_BITSIZE(insn.insn);
 341 }
 342
 343 /* The syntax in the manual says constants begin with '#'.
 344    We just ignore it.  */
 345
 346 void
 347 md_operand (expressionS * exp)
 348 {
 349   /* In case of a syntax error, escape back to try next syntax combo. */
 350   if (exp->X_op == O_absent)
 351     gas_cgen_md_operand (exp);
 352 }
 353
 354 valueT
 355 md_section_align (segT segment, valueT size)
 356 {
 357   int align = bfd_get_section_alignment (stdoutput, segment);
 358   return ((size + (1 << align) - 1) & (-1 << align));
 359 }
 360
 361 symbolS *
 362 md_undefined_symbol (char * name ATTRIBUTE_UNUSED)
 363 {
 364   return 0;
 365 }
 366 \f
 367 const relax_typeS md_relax_table[] =
 368 {
 369   /* The fields are:
 370      1) most positive reach of this state,
 371      2) most negative reach of this state,
 372      3) how many bytes this mode will have in the variable part of the frag
 373      4) which index into the table to try if we can't fit into this one.  */
 374
 375   /* 0 */ {     0,      0, 0,  0 }, /* unused */
 376   /* 1 */ {     0,      0, 0,  0 }, /* marker for "don't know yet" */
 377
 378   /* 2 */ {   127,   -128, 2,  3 }, /* jcnd16_5.b */
 379   /* 3 */ { 32767, -32768, 5,  4 }, /* jcnd16_5.w */
 380   /* 4 */ {     0,      0, 6,  0 }, /* jcnd16_5.a */
 381
 382   /* 5 */ {   127,   -128, 2,  6 }, /* jcnd16.b */
 383   /* 6 */ { 32767, -32768, 5,  7 }, /* jcnd16.w */
 384   /* 7 */ {     0,      0, 6,  0 }, /* jcnd16.a */
 385
 386   /* 8 */ {     8,      1, 1,  9 }, /* jmp16.s */
 387   /* 9 */ {   127,   -128, 2, 10 }, /* jmp16.b */
 388  /* 10 */ { 32767, -32768, 3, 11 }, /* jmp16.w */
 389  /* 11 */ {     0,      0, 4,  0 }, /* jmp16.a */
 390
 391  /* 12 */ {   127,   -128, 2, 13 }, /* jcnd32.b */
 392  /* 13 */ { 32767, -32768, 5, 14 }, /* jcnd32.w */
 393  /* 14 */ {     0,      0, 6,  0 }, /* jcnd32.a */
 394
 395  /* 15 */ {     8,      1, 1, 16 }, /* jmp32.s */
 396  /* 16 */ {   127,   -128, 2, 17 }, /* jmp32.b */
 397  /* 17 */ { 32767, -32768, 3, 18 }, /* jmp32.w */
 398  /* 18 */ {     0,      0, 4,  0 }  /* jmp32.a */
 399 };
 400
 401 enum {
 402   M32C_MACRO_JCND16_5_W,
 403   M32C_MACRO_JCND16_5_A,
 404   M32C_MACRO_JCND16_W,
 405   M32C_MACRO_JCND16_A,
 406   M32C_MACRO_JCND32_W,
 407   M32C_MACRO_JCND32_A,
 408 } M32C_Macros;
 409
 410 static struct {
 411   int insn;
 412   int bytes;
 413   int insn_for_extern;
 414   int pcrel_aim_offset;
 415 } subtype_mappings[] = {
 416   /* 0 */ { 0, 0, 0, 0 },
 417   /* 1 */ { 0, 0, 0, 0 },
 418
 419   /* 2 */ {  M32C_INSN_JCND16_5,    2, -M32C_MACRO_JCND16_5_A, 1 },
 420   /* 3 */ { -M32C_MACRO_JCND16_5_W, 5, -M32C_MACRO_JCND16_5_A, 4 },
 421   /* 4 */ { -M32C_MACRO_JCND16_5_A, 6, -M32C_MACRO_JCND16_5_A, 0 },
 422
 423   /* 5 */ {  M32C_INSN_JCND16,      3, -M32C_MACRO_JCND16_A,   1 },
 424   /* 6 */ { -M32C_MACRO_JCND16_W,   6, -M32C_MACRO_JCND16_A,   4 },
 425   /* 7 */ { -M32C_MACRO_JCND16_A,   7, -M32C_MACRO_JCND16_A,   0 },
 426
 427   /* 8 */ {  M32C_INSN_JMP16_S,     1, M32C_INSN_JMP16_A,     0 },
 428   /* 9 */ {  M32C_INSN_JMP16_B,     2, M32C_INSN_JMP16_A,     1 },
 429  /* 10 */ {  M32C_INSN_JMP16_W,     3, M32C_INSN_JMP16_A,     2 },
 430  /* 11 */ {  M32C_INSN_JMP16_A,     4, M32C_INSN_JMP16_A,     0 },
 431
 432  /* 12 */ {  M32C_INSN_JCND32,      2, -M32C_MACRO_JCND32_A,   1 },
 433  /* 13 */ { -M32C_MACRO_JCND32_W,   5, -M32C_MACRO_JCND32_A,   4 },
 434  /* 14 */ { -M32C_MACRO_JCND32_A,   6, -M32C_MACRO_JCND32_A,   0 },
 435
 436  /* 15 */ {  M32C_INSN_JMP32_S,     1, M32C_INSN_JMP32_A,     0 },
 437  /* 16 */ {  M32C_INSN_JMP32_B,     2, M32C_INSN_JMP32_A,     1 },
 438  /* 17 */ {  M32C_INSN_JMP32_W,     3, M32C_INSN_JMP32_A,     2 },
 439  /* 18 */ {  M32C_INSN_JMP32_A,     4, M32C_INSN_JMP32_A,     0 }
 440 };
 441 #define NUM_MAPPINGS (sizeof (subtype_mappings) / sizeof (subtype_mappings[0]))
 442
 443 void
 444 m32c_prepare_relax_scan (fragS *fragP, offsetT *aim, relax_substateT this_state)
 445 {
 446   symbolS *symbolP = fragP->fr_symbol;
 447   if (symbolP && !S_IS_DEFINED (symbolP))
 448     *aim = 0;
 449   /* Adjust for m32c pcrel not being relative to the next opcode.  */
 450   *aim += subtype_mappings[this_state].pcrel_aim_offset;
 451 }
 452
 453 static int
 454 insn_to_subtype (int insn)
 455 {
 456   unsigned int i;
 457   for (i=0; i<NUM_MAPPINGS; i++)
 458     if (insn == subtype_mappings[i].insn)
 459       {
 460         /*printf("mapping %d used\n", i);*/
 461         return i;
 462       }
 463   abort ();
 464 }
 465
 466 /* Return an initial guess of the length by which a fragment must grow to
 467    hold a branch to reach its destination.
 468    Also updates fr_type/fr_subtype as necessary.
 469
 470    Called just before doing relaxation.
 471    Any symbol that is now undefined will not become defined.
 472    The guess for fr_var is ACTUALLY the growth beyond fr_fix.
 473    Whatever we do to grow fr_fix or fr_var contributes to our returned value.
 474    Although it may not be explicit in the frag, pretend fr_var starts with a
 475    0 value.  */
 476
 477 int
 478 md_estimate_size_before_relax (fragS * fragP, segT segment ATTRIBUTE_UNUSED)
 479 {
 480   int where = fragP->fr_opcode - fragP->fr_literal;
 481
 482   if (fragP->fr_subtype == 1)
 483     fragP->fr_subtype = insn_to_subtype (fragP->fr_cgen.insn->base->num);
 484
 485   if (S_GET_SEGMENT (fragP->fr_symbol) != segment)
 486     {
 487       int new_insn;
 488
 489       new_insn = subtype_mappings[fragP->fr_subtype].insn_for_extern;
 490       fragP->fr_subtype = insn_to_subtype (new_insn);
 491     }
 492
 493   if (fragP->fr_cgen.insn->base
 494       && fragP->fr_cgen.insn->base->num
 495          != subtype_mappings[fragP->fr_subtype].insn
 496       && subtype_mappings[fragP->fr_subtype].insn > 0)
 497     {
 498       int new_insn= subtype_mappings[fragP->fr_subtype].insn;
 499       if (new_insn >= 0)
 500         {
 501           fragP->fr_cgen.insn = (fragP->fr_cgen.insn
 502                                  - fragP->fr_cgen.insn->base->num
 503                                  + new_insn);
 504         }
 505     }
 506
 507   return subtype_mappings[fragP->fr_subtype].bytes - (fragP->fr_fix - where);
 508 }
 509
 510 /* *fragP has been relaxed to its final size, and now needs to have
 511    the bytes inside it modified to conform to the new size.
 512
 513    Called after relaxation is finished.
 514    fragP->fr_type == rs_machine_dependent.
 515    fragP->fr_subtype is the subtype of what the address relaxed to.  */
 516
 517 static int
 518 target_address_for (fragS *frag)
 519 {
 520   int rv = frag->fr_offset;
 521   symbolS *sym = frag->fr_symbol;
 522
 523   if (sym)
 524     rv += S_GET_VALUE (sym);
 525
 526   /*printf("target_address_for returns %d\n", rv);*/
 527   return rv;
 528 }
 529
 530 void
 531 md_convert_frag (bfd *   abfd ATTRIBUTE_UNUSED,
 532                  segT    sec ATTRIBUTE_UNUSED,
 533                  fragS * fragP ATTRIBUTE_UNUSED)
 534 {
 535   int addend;
 536   int operand;
 537   int new_insn;
 538   int where = fragP->fr_opcode - fragP->fr_literal;
 539   unsigned char *op = (unsigned char *)fragP->fr_opcode;
 540
 541   addend = target_address_for (fragP) - (fragP->fr_address + where);
 542   new_insn = subtype_mappings[fragP->fr_subtype].insn;
 543
 544   fragP->fr_fix = where + subtype_mappings[fragP->fr_subtype].bytes;
 545
 546   switch (subtype_mappings[fragP->fr_subtype].insn)
 547     {
 548     case M32C_INSN_JCND16_5:
 549       op[1] = addend - 1;
 550       operand = M32C_OPERAND_LAB_8_8;
 551       break;
 552
 553     case -M32C_MACRO_JCND16_5_W:
 554       op[0] ^= 0x04;
 555       op[1] = 4;
 556       op[2] = 0xf4;
 557       op[3] = addend - 3;
 558       op[4] = (addend - 3) >> 8;
 559       operand = M32C_OPERAND_LAB_8_16;
 560       where += 2;
 561       new_insn = M32C_INSN_JMP16_W;
 562       break;
 563
 564     case -M32C_MACRO_JCND16_5_A:
 565       op[0] ^= 0x04;
 566       op[1] = 5;
 567       op[2] = 0xfc;
 568       operand = M32C_OPERAND_LAB_8_24;
 569       where += 2;
 570       new_insn = M32C_INSN_JMP16_A;
 571       break;
 572
 573
 574     case M32C_INSN_JCND16:
 575       op[2] = addend - 2;
 576       operand = M32C_OPERAND_LAB_16_8;
 577       break;
 578
 579     case -M32C_MACRO_JCND16_W:
 580       op[1] ^= 0x04;
 581       op[2] = 4;
 582       op[3] = 0xf4;
 583       op[4] = addend - 4;
 584       op[5] = (addend - 4) >> 8;
 585       operand = M32C_OPERAND_LAB_8_16;
 586       where += 3;
 587       new_insn = M32C_INSN_JMP16_W;
 588       break;
 589
 590     case -M32C_MACRO_JCND16_A:
 591       op[1] ^= 0x04;
 592       op[2] = 5;
 593       op[3] = 0xfc;
 594       operand = M32C_OPERAND_LAB_8_24;
 595       where += 3;
 596       new_insn = M32C_INSN_JMP16_A;
 597       break;
 598
 599     case M32C_INSN_JMP16_S:
 600       op[0] = 0x60 | ((addend-2) & 0x07);
 601       operand = M32C_OPERAND_LAB_5_3;
 602       break;
 603
 604     case M32C_INSN_JMP16_B:
 605       op[0] = 0xfe;
 606       op[1] = addend - 1;
 607       operand = M32C_OPERAND_LAB_8_8;
 608       break;
 609
 610     case M32C_INSN_JMP16_W:
 611       op[0] = 0xf4;
 612       op[1] = addend - 1;
 613       op[2] = (addend - 1) >> 8;
 614       operand = M32C_OPERAND_LAB_8_16;
 615       break;
 616
 617     case M32C_INSN_JMP16_A:
 618       op[0] = 0xfc;
 619       op[1] = 0;
 620       op[2] = 0;
 621       op[3] = 0;
 622       operand = M32C_OPERAND_LAB_8_24;
 623       break;
 624
 625     case M32C_INSN_JCND32:
 626       op[1] = addend - 1;
 627       operand = M32C_OPERAND_LAB_8_8;
 628       break;
 629
 630     case -M32C_MACRO_JCND32_W:
 631       op[0] ^= 0x40;
 632       op[1] = 4;
 633       op[2] = 0xce;
 634       op[3] = addend - 3;
 635       op[4] = (addend - 3) >> 8;
 636       operand = M32C_OPERAND_LAB_8_16;
 637       where += 2;
 638       new_insn = M32C_INSN_JMP32_W;
 639       break;
 640
 641     case -M32C_MACRO_JCND32_A:
 642       op[0] ^= 0x40;
 643       op[1] = 5;
 644       op[2] = 0xcc;
 645       operand = M32C_OPERAND_LAB_8_24;
 646       where += 2;
 647       new_insn = M32C_INSN_JMP32_A;
 648       break;
 649
 650
 651
 652     case M32C_INSN_JMP32_S:
 653       addend = ((addend-2) & 0x07);
 654       op[0] = 0x4a | (addend & 0x01) | ((addend << 3) & 0x30);
 655       operand = M32C_OPERAND_LAB32_JMP_S;
 656       break;
 657
 658     case M32C_INSN_JMP32_B:
 659       op[0] = 0xbb;
 660       op[1] = addend - 1;
 661       operand = M32C_OPERAND_LAB_8_8;
 662       break;
 663
 664     case M32C_INSN_JMP32_W:
 665       op[0] = 0xce;
 666       op[1] = addend - 1;
 667       op[2] = (addend - 1) >> 8;
 668       operand = M32C_OPERAND_LAB_8_16;
 669       break;
 670
 671     case M32C_INSN_JMP32_A:
 672       op[0] = 0xcc;
 673       op[1] = 0;
 674       op[2] = 0;
 675       op[3] = 0;
 676       operand = M32C_OPERAND_LAB_8_24;
 677       break;
 678
 679
 680     default:
 681       printf("\nHey!  Need more opcode converters! missing: %d %s\n\n",
 682              fragP->fr_subtype,
 683              fragP->fr_cgen.insn->base->name);
 684       abort();
 685     }
 686
 687   if (S_GET_SEGMENT (fragP->fr_symbol) != sec
 688       || operand == M32C_OPERAND_LAB_8_24)
 689     {
 690       assert (fragP->fr_cgen.insn != 0);
 691       gas_cgen_record_fixup (fragP,
 692                              where,
 693                              fragP->fr_cgen.insn,
 694                              (fragP->fr_fix - where) * 8,
 695                              cgen_operand_lookup_by_num (gas_cgen_cpu_desc,
 696                                                          operand),
 697                              fragP->fr_cgen.opinfo,
 698                              fragP->fr_symbol, fragP->fr_offset);
 699     }
 700 }
 701 \f
 702 /* Functions concerning relocs.  */
 703
 704 /* The location from which a PC relative jump should be calculated,
 705    given a PC relative reloc.  */
 706
 707 long
 708 md_pcrel_from_section (fixS * fixP, segT sec)
 709 {
 710   if (fixP->fx_addsy != (symbolS *) NULL
 711       && (! S_IS_DEFINED (fixP->fx_addsy)
 712           || S_GET_SEGMENT (fixP->fx_addsy) != sec))
 713     /* The symbol is undefined (or is defined but not in this section).
 714        Let the linker figure it out.  */
 715     return 0;
 716
 717   return (fixP->fx_frag->fr_address + fixP->fx_where);
 718 }
 719
 720 /* Return the bfd reloc type for OPERAND of INSN at fixup FIXP.
 721    Returns BFD_RELOC_NONE if no reloc type can be found.
 722    *FIXP may be modified if desired.  */
 723
 724 bfd_reloc_code_real_type
 725 md_cgen_lookup_reloc (const CGEN_INSN *    insn ATTRIBUTE_UNUSED,
 726                       const CGEN_OPERAND * operand,
 727                       fixS *               fixP ATTRIBUTE_UNUSED)
 728 {
 729   static const struct op_reloc {
 730     /* A CGEN operand type that can be a relocatable expression.  */
 731     CGEN_OPERAND_TYPE operand;
 732
 733     /* The appropriate BFD reloc type to use for that.  */
 734     bfd_reloc_code_real_type reloc;
 735
 736     /* The offset from the start of the instruction to the field to be
 737        relocated, in bytes.  */
 738     int offset;
 739   } op_reloc_table[] = {
 740
 741     /* PC-REL relocs for 8-bit fields.  */
 742     { M32C_OPERAND_LAB_16_8,   BFD_RELOC_8_PCREL, 2 },
 743     { M32C_OPERAND_LAB_24_8,   BFD_RELOC_8_PCREL, 3 },
 744     { M32C_OPERAND_LAB_32_8,   BFD_RELOC_8_PCREL, 4 },
 745     { M32C_OPERAND_LAB_40_8,   BFD_RELOC_8_PCREL, 5 },
 746
 747     /* Absolute relocs for 8-bit fields.  */
 748     { M32C_OPERAND_IMM_8_QI,   BFD_RELOC_8, 1 },
 749     { M32C_OPERAND_IMM_16_QI,  BFD_RELOC_8, 2 },
 750     { M32C_OPERAND_IMM_24_QI,  BFD_RELOC_8, 3 },
 751     { M32C_OPERAND_IMM_32_QI,  BFD_RELOC_8, 4 },
 752     { M32C_OPERAND_IMM_40_QI,  BFD_RELOC_8, 5 },
 753     { M32C_OPERAND_IMM_48_QI,  BFD_RELOC_8, 6 },
 754     { M32C_OPERAND_IMM_56_QI,  BFD_RELOC_8, 7 },
 755     { M32C_OPERAND_DSP_8_S8,   BFD_RELOC_8, 1 },
 756     { M32C_OPERAND_DSP_16_S8,  BFD_RELOC_8, 2 },
 757     { M32C_OPERAND_DSP_24_S8,  BFD_RELOC_8, 3 },
 758     { M32C_OPERAND_DSP_32_S8,  BFD_RELOC_8, 4 },
 759     { M32C_OPERAND_DSP_40_S8,  BFD_RELOC_8, 5 },
 760     { M32C_OPERAND_DSP_48_S8,  BFD_RELOC_8, 6 },
 761     { M32C_OPERAND_DSP_8_U8,   BFD_RELOC_8, 1 },
 762     { M32C_OPERAND_DSP_16_U8,  BFD_RELOC_8, 2 },
 763     { M32C_OPERAND_DSP_24_U8,  BFD_RELOC_8, 3 },
 764     { M32C_OPERAND_DSP_32_U8,  BFD_RELOC_8, 4 },
 765     { M32C_OPERAND_DSP_40_U8,  BFD_RELOC_8, 5 },
 766     { M32C_OPERAND_DSP_48_U8,  BFD_RELOC_8, 6 },
 767     { M32C_OPERAND_BITBASE32_16_S11_UNPREFIXED, BFD_RELOC_8, 2 },
 768     { M32C_OPERAND_BITBASE32_16_U11_UNPREFIXED, BFD_RELOC_8, 2 },
 769     { M32C_OPERAND_BITBASE32_24_S11_PREFIXED, BFD_RELOC_8, 3 },
 770     { M32C_OPERAND_BITBASE32_24_U11_PREFIXED, BFD_RELOC_8, 3 },
 771
 772     /* Absolute relocs for 16-bit fields.  */
 773     { M32C_OPERAND_IMM_8_HI,   BFD_RELOC_16, 1 },
 774     { M32C_OPERAND_IMM_16_HI,  BFD_RELOC_16, 2 },
 775     { M32C_OPERAND_IMM_24_HI,  BFD_RELOC_16, 3 },
 776     { M32C_OPERAND_IMM_32_HI,  BFD_RELOC_16, 4 },
 777     { M32C_OPERAND_IMM_40_HI,  BFD_RELOC_16, 5 },
 778     { M32C_OPERAND_IMM_48_HI,  BFD_RELOC_16, 6 },
 779     { M32C_OPERAND_IMM_56_HI,  BFD_RELOC_16, 7 },
 780     { M32C_OPERAND_IMM_64_HI,  BFD_RELOC_16, 8 },
 781     { M32C_OPERAND_DSP_16_S16, BFD_RELOC_16, 2 },
 782     { M32C_OPERAND_DSP_24_S16, BFD_RELOC_16, 3 },
 783     { M32C_OPERAND_DSP_32_S16, BFD_RELOC_16, 4 },
 784     { M32C_OPERAND_DSP_40_S16, BFD_RELOC_16, 5 },
 785     { M32C_OPERAND_DSP_8_U16,  BFD_RELOC_16, 1 },
 786     { M32C_OPERAND_DSP_16_U16, BFD_RELOC_16, 2 },
 787     { M32C_OPERAND_DSP_24_U16, BFD_RELOC_16, 3 },
 788     { M32C_OPERAND_DSP_32_U16, BFD_RELOC_16, 4 },
 789     { M32C_OPERAND_DSP_40_U16, BFD_RELOC_16, 5 },
 790     { M32C_OPERAND_DSP_48_U16, BFD_RELOC_16, 6 },
 791     { M32C_OPERAND_BITBASE32_16_S19_UNPREFIXED, BFD_RELOC_16, 2 },
 792     { M32C_OPERAND_BITBASE32_16_U19_UNPREFIXED, BFD_RELOC_16, 2 },
 793     { M32C_OPERAND_BITBASE32_24_S19_PREFIXED, BFD_RELOC_16, 3 },
 794     { M32C_OPERAND_BITBASE32_24_U19_PREFIXED, BFD_RELOC_16, 3 },
 795
 796     /* Absolute relocs for 24-bit fields.  */
 797     { M32C_OPERAND_LAB_8_24,   BFD_RELOC_24, 1 },
 798     { M32C_OPERAND_DSP_8_S24,  BFD_RELOC_24, 1 },
 799     { M32C_OPERAND_DSP_8_U24,  BFD_RELOC_24, 1 },
 800     { M32C_OPERAND_DSP_16_U24, BFD_RELOC_24, 2 },
 801     { M32C_OPERAND_DSP_24_U24, BFD_RELOC_24, 3 },
 802     { M32C_OPERAND_DSP_32_U24, BFD_RELOC_24, 4 },
 803     { M32C_OPERAND_DSP_40_U24, BFD_RELOC_24, 5 },
 804     { M32C_OPERAND_DSP_48_U24, BFD_RELOC_24, 6 },
 805     { M32C_OPERAND_DSP_16_U20, BFD_RELOC_24, 2 },
 806     { M32C_OPERAND_DSP_24_U20, BFD_RELOC_24, 3 },
 807     { M32C_OPERAND_DSP_32_U20, BFD_RELOC_24, 4 },
 808     { M32C_OPERAND_BITBASE32_16_U27_UNPREFIXED, BFD_RELOC_24, 2 },
 809     { M32C_OPERAND_BITBASE32_24_U27_PREFIXED, BFD_RELOC_24, 3 },
 810
 811     /* Absolute relocs for 32-bit fields.  */
 812     { M32C_OPERAND_IMM_16_SI,  BFD_RELOC_32, 2 },
 813     { M32C_OPERAND_IMM_24_SI,  BFD_RELOC_32, 3 },
 814     { M32C_OPERAND_IMM_32_SI,  BFD_RELOC_32, 4 },
 815     { M32C_OPERAND_IMM_40_SI,  BFD_RELOC_32, 5 },
 816
 817   };
 818
 819   int i;
 820
 821   for (i = ARRAY_SIZE (op_reloc_table); --i >= 0; )
 822     {
 823       const struct op_reloc *or = &op_reloc_table[i];
 824
 825       if (or->operand == operand->type)
 826         {
 827           fixP->fx_where += or->offset;
 828           fixP->fx_size -= or->offset;
 829
 830           if (fixP->fx_cgen.opinfo
 831               && fixP->fx_cgen.opinfo != BFD_RELOC_NONE)
 832             return fixP->fx_cgen.opinfo;
 833
 834           return or->reloc;
 835         }
 836     }
 837
 838   fprintf
 839     (stderr,
 840      "Error: tc-m32c.c:md_cgen_lookup_reloc Unimplemented relocation for operand %s\n",
 841      operand->name);
 842
 843   return BFD_RELOC_NONE;
 844 }
 845
 846 /* See whether we need to force a relocation into the output file.
 847    This is used to force out switch and PC relative relocations when
 848    relaxing.  */
 849
 850 int
 851 m32c_force_relocation (fixS * fixp)
 852 {
 853   int reloc = fixp->fx_r_type;
 854
 855   if (reloc > (int)BFD_RELOC_UNUSED)
 856     {
 857       reloc -= (int)BFD_RELOC_UNUSED;
 858       switch (reloc)
 859         {
 860         case M32C_OPERAND_DSP_32_S16:
 861         case M32C_OPERAND_DSP_32_U16:
 862         case M32C_OPERAND_IMM_32_HI:
 863         case M32C_OPERAND_DSP_16_S16:
 864         case M32C_OPERAND_DSP_16_U16:
 865         case M32C_OPERAND_IMM_16_HI:
 866         case M32C_OPERAND_DSP_24_S16:
 867         case M32C_OPERAND_DSP_24_U16:
 868         case M32C_OPERAND_IMM_24_HI:
 869           return 1;
 870         }
 871     }
 872   else
 873     {
 874       if (fixp->fx_r_type == BFD_RELOC_16)
 875         return 1;
 876     }
 877
 878   return generic_force_reloc (fixp);
 879 }
 880 \f
 881 /* Write a value out to the object file, using the appropriate endianness.  */
 882
 883 void
 884 md_number_to_chars (char * buf, valueT val, int n)
 885 {
 886   number_to_chars_littleendian (buf, val, n);
 887 }
 888
 889 /* Turn a string in input_line_pointer into a floating point constant of type
 890    type, and store the appropriate bytes in *litP.  The number of LITTLENUMS
 891    emitted is stored in *sizeP .  An error message is returned, or NULL on OK.  */
 892
 893 /* Equal to MAX_PRECISION in atof-ieee.c.  */
 894 #define MAX_LITTLENUMS 6
 895
 896 char *
 897 md_atof (int type, char * litP, int * sizeP)
 898 {
 899   int              i;
 900   int              prec;
 901   LITTLENUM_TYPE   words [MAX_LITTLENUMS];
 902   char *           t;
 903
 904   switch (type)
 905     {
 906     case 'f':
 907     case 'F':
 908     case 's':
 909     case 'S':
 910       prec = 2;
 911       break;
 912
 913     case 'd':
 914     case 'D':
 915     case 'r':
 916     case 'R':
 917       prec = 4;
 918       break;
 919
 920    /* FIXME: Some targets allow other format chars for bigger sizes here.  */
 921
 922     default:
 923       * sizeP = 0;
 924       return _("Bad call to md_atof()");
 925     }
 926
 927   t = atof_ieee (input_line_pointer, type, words);
 928   if (t)
 929     input_line_pointer = t;
 930   * sizeP = prec * sizeof (LITTLENUM_TYPE);
 931
 932   for (i = 0; i < prec; i++)
 933     {
 934       md_number_to_chars (litP, (valueT) words[i],
 935                           sizeof (LITTLENUM_TYPE));
 936       litP += sizeof (LITTLENUM_TYPE);
 937     }
 938
 939   return 0;
 940 }
 941
 942 bfd_boolean
 943 m32c_fix_adjustable (fixS * fixP)
 944 {
 945   int reloc;
 946   if (fixP->fx_addsy == NULL)
 947     return 1;
 948
 949   /* We need the symbol name for the VTABLE entries.  */
 950   reloc = fixP->fx_r_type;
 951   if (reloc > (int)BFD_RELOC_UNUSED)
 952     {
 953       reloc -= (int)BFD_RELOC_UNUSED;
 954       switch (reloc)
 955         {
 956         case M32C_OPERAND_DSP_32_S16:
 957         case M32C_OPERAND_DSP_32_U16:
 958         case M32C_OPERAND_IMM_32_HI:
 959         case M32C_OPERAND_DSP_16_S16:
 960         case M32C_OPERAND_DSP_16_U16:
 961         case M32C_OPERAND_IMM_16_HI:
 962         case M32C_OPERAND_DSP_24_S16:
 963         case M32C_OPERAND_DSP_24_U16:
 964         case M32C_OPERAND_IMM_24_HI:
 965           return 0;
 966         }
 967     }
 968   else
 969     {
 970       if (fixP->fx_r_type == BFD_RELOC_16)
 971         return 0;
 972     }
 973
 974   /* Do not adjust relocations involving symbols in merged sections.
 975
 976      A reloc patching in the value of some symbol S plus some addend A
 977      can be produced in different ways:
 978
 979      1) It might simply be a reference to the data at S + A.  Clearly,
 980         if linker merging shift that data around, the value patched in
 981         by the reloc needs to be adjusted accordingly.
 982
 983      2) Or, it might be a reference to S, with A added in as a constant
 984         bias.  For example, given code like this:
 985
 986           static int S[100];
 987
 988           ... S[i - 8] ...
 989
 990         it would be reasonable for the compiler to rearrange the array
 991         reference to something like:
 992
 993           ... (S-8)[i] ...
 994
 995         and emit assembly code that refers to S - (8 * sizeof (int)),
 996         so the subtraction is done entirely at compile-time.  In this
 997         case, the reloc's addend A would be -(8 * sizeof (int)), and
 998         shifting around code or data at S + A should not affect the
 999         reloc: the reloc isn't referring to that code or data at all.
1000
1001      The linker has no way of knowing which case it has in hand.  So,
1002      to disambiguate, we have the linker always treat reloc addends as
1003      in case 2): they're constants that should be simply added to the
1004      symbol value, just like the reloc says.  And we express case 1)
1005      in different way: we have the compiler place a label at the real
1006      target, and reference that label with an addend of zero.  (The
1007      compiler is unlikely to reference code using a label plus an
1008      offset anyway, since it doesn't know the sizes of the
1009      instructions.)
1010
1011      The simplification being done by gas/write.c:adjust_reloc_syms,
1012      however, turns the explicit-label usage into the label-plus-
1013      offset usage, re-introducing the ambiguity the compiler avoided.
1014      So we need to disable that simplification for symbols referring
1015      to merged data.
1016
1017      This only affects object size a little bit.  */
1018   if (S_GET_SEGMENT (fixP->fx_addsy)->flags & SEC_MERGE)
1019     return 0;
1020
1021   return 1;
1022 }
1023
1024 /* Worker function for m32c_is_colon_insn().  */
1025 static char restore_colon PARAMS ((int));
1026
1027 static char
1028 restore_colon (int advance_i_l_p_by)
1029 {
1030   char c;
1031
1032   /* Restore the colon, and advance input_line_pointer to
1033      the end of the new symbol.  */
1034   * input_line_pointer = ':';
1035   input_line_pointer += advance_i_l_p_by;
1036   c = * input_line_pointer;
1037   * input_line_pointer = 0;
1038
1039   return c;
1040 }
1041
1042 /* Determines if the symbol starting at START and ending in
1043    a colon that was at the location pointed to by INPUT_LINE_POINTER
1044    (but which has now been replaced bu a NUL) is in fact an
1045    :Z, :S, :Q, or :G suffix.
1046    If it is, then it restores the colon, advances INPUT_LINE_POINTER
1047    to the real end of the instruction/symbol, and returns the character
1048    that really terminated the symbol.  Otherwise it returns 0.  */
1049 char
1050 m32c_is_colon_insn (char *start ATTRIBUTE_UNUSED)
1051 {
1052   char * i_l_p = input_line_pointer;
1053
1054   /* Check to see if the text following the colon is 'G' */
1055   if (TOLOWER (i_l_p[1]) == 'g' && (i_l_p[2] == ' ' || i_l_p[2] == '\t'))
1056     return restore_colon (2);
1057
1058   /* Check to see if the text following the colon is 'Q' */
1059   if (TOLOWER (i_l_p[1]) == 'q' && (i_l_p[2] == ' ' || i_l_p[2] == '\t'))
1060     return restore_colon (2);
1061
1062   /* Check to see if the text following the colon is 'S' */
1063   if (TOLOWER (i_l_p[1]) == 's' && (i_l_p[2] == ' ' || i_l_p[2] == '\t'))
1064     return restore_colon (2);
1065
1066   /* Check to see if the text following the colon is 'Z' */
1067   if (TOLOWER (i_l_p[1]) == 'z' && (i_l_p[2] == ' ' || i_l_p[2] == '\t'))
1068     return restore_colon (2);
1069
1070   return 0;
1071 }