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 (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     /* Absolute relocs for 16-bit fields.  */
 742     { M32C_OPERAND_IMM_16_HI,  BFD_RELOC_16, 2 },
 743     { M32C_OPERAND_IMM_24_HI,  BFD_RELOC_16, 3 },
 744     { M32C_OPERAND_IMM_32_HI,  BFD_RELOC_16, 4 },
 745     { M32C_OPERAND_DSP_16_S16, BFD_RELOC_16, 2 },
 746     { M32C_OPERAND_DSP_24_S16, BFD_RELOC_16, 3 },
 747     { M32C_OPERAND_DSP_32_S16, BFD_RELOC_16, 4 },
 748     { M32C_OPERAND_DSP_40_S16, BFD_RELOC_16, 5 },
 749     { M32C_OPERAND_DSP_8_U16,  BFD_RELOC_16, 1 },
 750     { M32C_OPERAND_DSP_16_U16, BFD_RELOC_16, 2 },
 751     { M32C_OPERAND_DSP_24_U16, BFD_RELOC_16, 3 },
 752     { M32C_OPERAND_DSP_32_U16, BFD_RELOC_16, 4 },
 753
 754     /* Absolute relocs for 24-bit fields.  */
 755     { M32C_OPERAND_LAB_8_24,   BFD_RELOC_24, 1 },
 756     { M32C_OPERAND_DSP_16_U24, BFD_RELOC_24, 2 },
 757     { M32C_OPERAND_DSP_24_U24, BFD_RELOC_24, 3 },
 758     { M32C_OPERAND_DSP_32_U24, BFD_RELOC_24, 4 },
 759     { M32C_OPERAND_DSP_40_U24, BFD_RELOC_24, 5 },
 760     { M32C_OPERAND_DSP_8_U24,  BFD_RELOC_24, 1 },
 761
 762     /* Absolute relocs for 32-bit fields.  */
 763     { M32C_OPERAND_IMM_16_SI,  BFD_RELOC_32, 2 },
 764     { M32C_OPERAND_IMM_24_SI,  BFD_RELOC_32, 3 },
 765     { M32C_OPERAND_IMM_32_SI,  BFD_RELOC_32, 4 },
 766     { M32C_OPERAND_IMM_40_SI,  BFD_RELOC_32, 5 },
 767
 768   };
 769
 770   int i;
 771
 772   for (i = ARRAY_SIZE (op_reloc_table); --i >= 0; )
 773     {
 774       const struct op_reloc *or = &op_reloc_table[i];
 775
 776       if (or->operand == operand->type)
 777         {
 778           fixP->fx_where += or->offset;
 779           fixP->fx_size -= or->offset;
 780           return or->reloc;
 781         }
 782     }
 783
 784   fprintf
 785     (stderr,
 786      "Error: tc-m32c.c:md_cgen_lookup_reloc Unimplemented relocation for operand %d\n",
 787      operand->type);
 788
 789   return BFD_RELOC_NONE;
 790 }
 791
 792 /* See whether we need to force a relocation into the output file.
 793    This is used to force out switch and PC relative relocations when
 794    relaxing.  */
 795
 796 int
 797 m32c_force_relocation (fixS * fixp)
 798 {
 799   int reloc = fixp->fx_r_type;
 800
 801   if (reloc > (int)BFD_RELOC_UNUSED)
 802     {
 803       reloc -= (int)BFD_RELOC_UNUSED;
 804       switch (reloc)
 805         {
 806         case M32C_OPERAND_DSP_32_S16:
 807         case M32C_OPERAND_DSP_32_U16:
 808         case M32C_OPERAND_IMM_32_HI:
 809         case M32C_OPERAND_DSP_16_S16:
 810         case M32C_OPERAND_DSP_16_U16:
 811         case M32C_OPERAND_IMM_16_HI:
 812         case M32C_OPERAND_DSP_24_S16:
 813         case M32C_OPERAND_DSP_24_U16:
 814         case M32C_OPERAND_IMM_24_HI:
 815           return 1;
 816         }
 817     }
 818   else
 819     {
 820       if (fixp->fx_r_type == BFD_RELOC_16)
 821         return 1;
 822     }
 823
 824   return generic_force_reloc (fixp);
 825 }
 826 \f
 827 /* Write a value out to the object file, using the appropriate endianness.  */
 828
 829 void
 830 md_number_to_chars (char * buf, valueT val, int n)
 831 {
 832   number_to_chars_littleendian (buf, val, n);
 833 }
 834
 835 /* Turn a string in input_line_pointer into a floating point constant of type
 836    type, and store the appropriate bytes in *litP.  The number of LITTLENUMS
 837    emitted is stored in *sizeP .  An error message is returned, or NULL on OK.  */
 838
 839 /* Equal to MAX_PRECISION in atof-ieee.c.  */
 840 #define MAX_LITTLENUMS 6
 841
 842 char *
 843 md_atof (int type, char * litP, int * sizeP)
 844 {
 845   int              i;
 846   int              prec;
 847   LITTLENUM_TYPE   words [MAX_LITTLENUMS];
 848   char *           t;
 849
 850   switch (type)
 851     {
 852     case 'f':
 853     case 'F':
 854     case 's':
 855     case 'S':
 856       prec = 2;
 857       break;
 858
 859     case 'd':
 860     case 'D':
 861     case 'r':
 862     case 'R':
 863       prec = 4;
 864       break;
 865
 866    /* FIXME: Some targets allow other format chars for bigger sizes here.  */
 867
 868     default:
 869       * sizeP = 0;
 870       return _("Bad call to md_atof()");
 871     }
 872
 873   t = atof_ieee (input_line_pointer, type, words);
 874   if (t)
 875     input_line_pointer = t;
 876   * sizeP = prec * sizeof (LITTLENUM_TYPE);
 877
 878   for (i = 0; i < prec; i++)
 879     {
 880       md_number_to_chars (litP, (valueT) words[i],
 881                           sizeof (LITTLENUM_TYPE));
 882       litP += sizeof (LITTLENUM_TYPE);
 883     }
 884
 885   return 0;
 886 }
 887
 888 bfd_boolean
 889 m32c_fix_adjustable (fixS * fixP)
 890 {
 891   int reloc;
 892   if (fixP->fx_addsy == NULL)
 893     return 1;
 894
 895   /* We need the symbol name for the VTABLE entries.  */
 896   reloc = fixP->fx_r_type;
 897   if (reloc > (int)BFD_RELOC_UNUSED)
 898     {
 899       reloc -= (int)BFD_RELOC_UNUSED;
 900       switch (reloc)
 901         {
 902         case M32C_OPERAND_DSP_32_S16:
 903         case M32C_OPERAND_DSP_32_U16:
 904         case M32C_OPERAND_IMM_32_HI:
 905         case M32C_OPERAND_DSP_16_S16:
 906         case M32C_OPERAND_DSP_16_U16:
 907         case M32C_OPERAND_IMM_16_HI:
 908         case M32C_OPERAND_DSP_24_S16:
 909         case M32C_OPERAND_DSP_24_U16:
 910         case M32C_OPERAND_IMM_24_HI:
 911           return 0;
 912         }
 913     }
 914   else
 915     {
 916       if (fixP->fx_r_type == BFD_RELOC_16)
 917         return 0;
 918     }
 919
 920   /* Do not adjust relocations involving symbols in merged sections.
 921
 922      A reloc patching in the value of some symbol S plus some addend A
 923      can be produced in different ways:
 924
 925      1) It might simply be a reference to the data at S + A.  Clearly,
 926         if linker merging shift that data around, the value patched in
 927         by the reloc needs to be adjusted accordingly.
 928
 929      2) Or, it might be a reference to S, with A added in as a constant
 930         bias.  For example, given code like this:
 931
 932           static int S[100];
 933
 934           ... S[i - 8] ...
 935
 936         it would be reasonable for the compiler to rearrange the array
 937         reference to something like:
 938
 939           ... (S-8)[i] ...
 940
 941         and emit assembly code that refers to S - (8 * sizeof (int)),
 942         so the subtraction is done entirely at compile-time.  In this
 943         case, the reloc's addend A would be -(8 * sizeof (int)), and
 944         shifting around code or data at S + A should not affect the
 945         reloc: the reloc isn't referring to that code or data at all.
 946
 947      The linker has no way of knowing which case it has in hand.  So,
 948      to disambiguate, we have the linker always treat reloc addends as
 949      in case 2): they're constants that should be simply added to the
 950      symbol value, just like the reloc says.  And we express case 1)
 951      in different way: we have the compiler place a label at the real
 952      target, and reference that label with an addend of zero.  (The
 953      compiler is unlikely to reference code using a label plus an
 954      offset anyway, since it doesn't know the sizes of the
 955      instructions.)
 956
 957      The simplification being done by gas/write.c:adjust_reloc_syms,
 958      however, turns the explicit-label usage into the label-plus-
 959      offset usage, re-introducing the ambiguity the compiler avoided.
 960      So we need to disable that simplification for symbols referring
 961      to merged data.
 962
 963      This only affects object size a little bit.  */
 964   if (S_GET_SEGMENT (fixP->fx_addsy)->flags & SEC_MERGE)
 965     return 0;
 966
 967   return 1;
 968 }
 969
 970 /* Worker function for m32c_is_colon_insn().  */
 971 static char restore_colon PARAMS ((int));
 972
 973 static char
 974 restore_colon (int advance_i_l_p_by)
 975 {
 976   char c;
 977
 978   /* Restore the colon, and advance input_line_pointer to
 979      the end of the new symbol.  */
 980   * input_line_pointer = ':';
 981   input_line_pointer += advance_i_l_p_by;
 982   c = * input_line_pointer;
 983   * input_line_pointer = 0;
 984
 985   return c;
 986 }
 987
 988 /* Determines if the symbol starting at START and ending in
 989    a colon that was at the location pointed to by INPUT_LINE_POINTER
 990    (but which has now been replaced bu a NUL) is in fact an
 991    :Z, :S, :Q, or :G suffix.
 992    If it is, then it restores the colon, advances INPUT_LINE_POINTER
 993    to the real end of the instruction/symbol, and returns the character
 994    that really terminated the symbol.  Otherwise it returns 0.  */
 995 char
 996 m32c_is_colon_insn (char *start ATTRIBUTE_UNUSED)
 997 {
 998   char * i_l_p = input_line_pointer;
 999
1000   /* Check to see if the text following the colon is 'G' */
1001   if (TOLOWER (i_l_p[1]) == 'g' && (i_l_p[2] == ' ' || i_l_p[2] == '\t'))
1002     return restore_colon (2);
1003
1004   /* Check to see if the text following the colon is 'Q' */
1005   if (TOLOWER (i_l_p[1]) == 'q' && (i_l_p[2] == ' ' || i_l_p[2] == '\t'))
1006     return restore_colon (2);
1007
1008   /* Check to see if the text following the colon is 'S' */
1009   if (TOLOWER (i_l_p[1]) == 's' && (i_l_p[2] == ' ' || i_l_p[2] == '\t'))
1010     return restore_colon (2);
1011
1012   /* Check to see if the text following the colon is 'Z' */
1013   if (TOLOWER (i_l_p[1]) == 'z' && (i_l_p[2] == ' ' || i_l_p[2] == '\t'))
1014     return restore_colon (2);
1015
1016   return 0;
1017 }