gas/config/tc-tic6x.c

   1 /* TI C6X assembler.
   2    Copyright 2010, 2011
   3    Free Software Foundation, Inc.
   4    Contributed by Joseph Myers <joseph@codesourcery.com>
   5                   Bernd Schmidt  <bernds@codesourcery.com>
   6
   7    This file is part of GAS, the GNU Assembler.
   8
   9    GAS is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3, or (at your option)
  12    any later version.
  13
  14    GAS is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with GAS; see the file COPYING.  If not, write to the Free
  21    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
  22    02110-1301, USA.  */
  23
  24 #include "as.h"
  25 #include "dwarf2dbg.h"
  26 #include "dw2gencfi.h"
  27 #include "safe-ctype.h"
  28 #include "subsegs.h"
  29 #include "opcode/tic6x.h"
  30 #include "elf/tic6x.h"
  31 #include "elf32-tic6x.h"
  32
  33 /* Truncate and sign-extend at 32 bits, so that building on a 64-bit
  34    host gives identical results to a 32-bit host.  */
  35 #define TRUNC(X)        ((valueT) (X) & 0xffffffffU)
  36 #define SEXT(X)         ((TRUNC (X) ^ 0x80000000U) - 0x80000000U)
  37
  38 #define streq(a, b)           (strcmp (a, b) == 0)
  39
  40 /* Stuff for .scomm symbols.  */
  41 static segT sbss_section;
  42 static asection scom_section;
  43 static asymbol scom_symbol;
  44
  45 const char comment_chars[] = ";";
  46 const char line_comment_chars[] = "#*;";
  47 const char line_separator_chars[] = "@";
  48
  49 const char EXP_CHARS[] = "eE";
  50 const char FLT_CHARS[] = "dDfF";
  51
  52 const char *md_shortopts = "";
  53
  54 enum
  55   {
  56     OPTION_MARCH = OPTION_MD_BASE,
  57     OPTION_MBIG_ENDIAN,
  58     OPTION_MLITTLE_ENDIAN,
  59     OPTION_MDSBT,
  60     OPTION_MNO_DSBT,
  61     OPTION_MPID,
  62     OPTION_MPIC,
  63     OPTION_MNO_PIC,
  64     OPTION_MGENERATE_REL
  65   };
  66
  67 struct option md_longopts[] =
  68   {
  69     { "march", required_argument, NULL, OPTION_MARCH },
  70     { "mbig-endian", no_argument, NULL, OPTION_MBIG_ENDIAN },
  71     { "mlittle-endian", no_argument, NULL, OPTION_MLITTLE_ENDIAN },
  72     { "mdsbt", no_argument, NULL, OPTION_MDSBT },
  73     { "mno-dsbt", no_argument, NULL, OPTION_MNO_DSBT },
  74     { "mpid", required_argument, NULL, OPTION_MPID },
  75     { "mpic", no_argument, NULL, OPTION_MPIC },
  76     { "mno-pic", no_argument, NULL, OPTION_MNO_PIC },
  77     { "mgenerate-rel", no_argument, NULL, OPTION_MGENERATE_REL },
  78     { NULL, no_argument, NULL, 0 }
  79   };
  80 size_t md_longopts_size = sizeof (md_longopts);
  81
  82 /* The instructions enabled based only on the selected architecture
  83    (all instructions, if no architecture specified).  */
  84 static unsigned short tic6x_arch_enable = (TIC6X_INSN_C62X
  85                                            | TIC6X_INSN_C64X
  86                                            | TIC6X_INSN_C64XP
  87                                            | TIC6X_INSN_C67X
  88                                            | TIC6X_INSN_C67XP
  89                                            | TIC6X_INSN_C674X);
  90
  91 /* The instructions enabled based on the current set of features
  92    (architecture, as modified by other options).  */
  93 static unsigned short tic6x_features;
  94
  95 /* The architecture attribute value, or C6XABI_Tag_ISA_none if
  96    not yet set.  */
  97 static int tic6x_arch_attribute = C6XABI_Tag_ISA_none;
  98
  99 /* Whether any instructions at all have been seen.  Once any
 100    instructions have been seen, architecture attributes merge into the
 101    previous attribute value rather than replacing it.  */
 102 static bfd_boolean tic6x_seen_insns = FALSE;
 103
 104 /* The number of registers in each register file supported by the
 105    current architecture.  */
 106 static unsigned int tic6x_num_registers;
 107
 108 /* Whether predication on A0 is possible.  */
 109 static bfd_boolean tic6x_predicate_a0;
 110
 111 /* Whether execute packets can cross fetch packet boundaries.  */
 112 static bfd_boolean tic6x_can_cross_fp_boundary;
 113
 114 /* Whether there are constraints on simultaneous reads and writes of
 115    40-bit data.  */
 116 static bfd_boolean tic6x_long_data_constraints;
 117
 118 /* Whether compact instructions are available.  */
 119 static bfd_boolean tic6x_compact_insns;
 120
 121 /* Whether to generate RELA relocations.  */
 122 static bfd_boolean tic6x_generate_rela = TRUE;
 123
 124 /* Whether the code uses DSBT addressing.  */
 125 static bfd_boolean tic6x_dsbt;
 126
 127 /* Types of position-independent data (attribute values for
 128    Tag_ABI_PID).  */
 129 typedef enum
 130   {
 131     tic6x_pid_no = 0,
 132     tic6x_pid_near = 1,
 133     tic6x_pid_far = 2
 134   } tic6x_pid_type;
 135
 136 /* The type of data addressing used in this code.  */
 137 static tic6x_pid_type tic6x_pid;
 138
 139 /* Whether the code uses position-independent code.  */
 140 static bfd_boolean tic6x_pic;
 141
 142 /* Table of supported architecture variants.  */
 143 typedef struct
 144 {
 145   const char *arch;
 146   int attr;
 147   unsigned short features;
 148 } tic6x_arch_table;
 149 static const tic6x_arch_table tic6x_arches[] =
 150   {
 151     { "c62x", C6XABI_Tag_ISA_C62X, TIC6X_INSN_C62X },
 152     { "c64x", C6XABI_Tag_ISA_C64X, TIC6X_INSN_C62X | TIC6X_INSN_C64X },
 153     { "c64x+", C6XABI_Tag_ISA_C64XP, (TIC6X_INSN_C62X
 154                                       | TIC6X_INSN_C64X
 155                                       | TIC6X_INSN_C64XP) },
 156     { "c67x", C6XABI_Tag_ISA_C67X, TIC6X_INSN_C62X | TIC6X_INSN_C67X },
 157     { "c67x+", C6XABI_Tag_ISA_C67XP, (TIC6X_INSN_C62X
 158                                       | TIC6X_INSN_C67X
 159                                       | TIC6X_INSN_C67XP) },
 160     { "c674x", C6XABI_Tag_ISA_C674X, (TIC6X_INSN_C62X
 161                                       | TIC6X_INSN_C64X
 162                                       | TIC6X_INSN_C64XP
 163                                       | TIC6X_INSN_C67X
 164                                       | TIC6X_INSN_C67XP
 165                                       | TIC6X_INSN_C674X) }
 166   };
 167
 168 /* Caller saved register encodings.  The standard frame layout uses this
 169    order, starting from the highest address.  There must be
 170    TIC6X_NUM_UNWIND_REGS values.  */
 171 enum
 172 {
 173   UNWIND_A15,
 174   UNWIND_B15,
 175   UNWIND_B14,
 176   UNWIND_B13,
 177   UNWIND_B12,
 178   UNWIND_B11,
 179   UNWIND_B10,
 180   UNWIND_B3,
 181   UNWIND_A14,
 182   UNWIND_A13,
 183   UNWIND_A12,
 184   UNWIND_A11,
 185   UNWIND_A10
 186 };
 187
 188 static void tic6x_output_unwinding (bfd_boolean need_extab);
 189
 190 /* Return the frame unwind state for the current function, allocating
 191    as necessary.  */
 192
 193 static tic6x_unwind_info *tic6x_get_unwind (void)
 194 {
 195   tic6x_unwind_info *unwind;
 196
 197   unwind = seg_info (now_seg)->tc_segment_info_data.unwind;
 198   if (unwind)
 199     return unwind;
 200
 201   unwind = seg_info (now_seg)->tc_segment_info_data.text_unwind;
 202   if (unwind)
 203     return unwind;
 204
 205   unwind = (tic6x_unwind_info *)xmalloc (sizeof (tic6x_unwind_info));
 206   seg_info (now_seg)->tc_segment_info_data.unwind = unwind;
 207   memset (unwind, 0, sizeof (*unwind));
 208   return unwind;
 209 }
 210
 211 /* Update the selected architecture based on ARCH, giving an error if
 212    ARCH is an invalid value.  Does not call tic6x_update_features; the
 213    caller must do that if necessary.  */
 214
 215 static void
 216 tic6x_use_arch (const char *arch)
 217 {
 218   unsigned int i;
 219
 220   for (i = 0; i < ARRAY_SIZE (tic6x_arches); i++)
 221     if (strcmp (arch, tic6x_arches[i].arch) == 0)
 222       {
 223         tic6x_arch_enable = tic6x_arches[i].features;
 224         if (tic6x_seen_insns)
 225           tic6x_arch_attribute
 226             = elf32_tic6x_merge_arch_attributes (tic6x_arch_attribute,
 227                                                  tic6x_arches[i].attr);
 228         else
 229           tic6x_arch_attribute = tic6x_arches[i].attr;
 230         return;
 231       }
 232
 233   as_bad (_("unknown architecture '%s'"), arch);
 234 }
 235
 236 /* Table of supported -mpid arguments.  */
 237 typedef struct
 238 {
 239   const char *arg;
 240   tic6x_pid_type attr;
 241 } tic6x_pid_type_table;
 242 static const tic6x_pid_type_table tic6x_pid_types[] =
 243   {
 244     { "no", tic6x_pid_no },
 245     { "near", tic6x_pid_near },
 246     { "far", tic6x_pid_far }
 247   };
 248
 249 /* Handle -mpid=ARG.  */
 250
 251 static void
 252 tic6x_use_pid (const char *arg)
 253 {
 254   unsigned int i;
 255
 256   for (i = 0; i < ARRAY_SIZE (tic6x_pid_types); i++)
 257     if (strcmp (arg, tic6x_pid_types[i].arg) == 0)
 258       {
 259         tic6x_pid = tic6x_pid_types[i].attr;
 260         return;
 261       }
 262
 263   as_bad (_("unknown -mpid= argument '%s'"), arg);
 264 }
 265
 266 /* Parse a target-specific option.  */
 267
 268 int
 269 md_parse_option (int c, char *arg)
 270 {
 271   switch (c)
 272     {
 273     case OPTION_MARCH:
 274       tic6x_use_arch (arg);
 275       break;
 276
 277     case OPTION_MBIG_ENDIAN:
 278       target_big_endian = 1;
 279       break;
 280
 281     case OPTION_MLITTLE_ENDIAN:
 282       target_big_endian = 0;
 283       break;
 284
 285     case OPTION_MDSBT:
 286       tic6x_dsbt = 1;
 287       break;
 288
 289     case OPTION_MNO_DSBT:
 290       tic6x_dsbt = 0;
 291       break;
 292
 293     case OPTION_MPID:
 294       tic6x_use_pid (arg);
 295       break;
 296
 297     case OPTION_MPIC:
 298       tic6x_pic = 1;
 299       break;
 300
 301     case OPTION_MNO_PIC:
 302       tic6x_pic = 0;
 303       break;
 304
 305     case OPTION_MGENERATE_REL:
 306       tic6x_generate_rela = FALSE;
 307       break;
 308
 309     default:
 310       return 0;
 311     }
 312   return 1;
 313 }
 314
 315 void
 316 md_show_usage (FILE *stream ATTRIBUTE_UNUSED)
 317 {
 318   unsigned int i;
 319
 320   fputc ('\n', stream);
 321   fprintf (stream, _("TMS320C6000 options:\n"));
 322   fprintf (stream, _("  -march=ARCH             enable instructions from architecture ARCH\n"));
 323   fprintf (stream, _("  -mbig-endian            generate big-endian code\n"));
 324   fprintf (stream, _("  -mlittle-endian         generate little-endian code\n"));
 325   fprintf (stream, _("  -mdsbt                  code uses DSBT addressing\n"));
 326   fprintf (stream, _("  -mno-dsbt               code does not use DSBT addressing\n"));
 327   fprintf (stream, _("  -mpid=no                code uses position-dependent data addressing\n"));
 328   fprintf (stream, _("  -mpid=near              code uses position-independent data addressing,\n"
 329                      "                            GOT accesses use near DP addressing\n"));
 330   fprintf (stream, _("  -mpid=far               code uses position-independent data addressing,\n"
 331                      "                            GOT accesses use far DP addressing\n"));
 332   fprintf (stream, _("  -mpic                   code addressing is position-independent\n"));
 333   fprintf (stream, _("  -mno-pic                code addressing is position-dependent\n"));
 334   /* -mgenerate-rel is only for testsuite use and is deliberately
 335       undocumented.  */
 336
 337   fputc ('\n', stream);
 338   fprintf (stream, _("Supported ARCH values are:"));
 339   for (i = 0; i < ARRAY_SIZE (tic6x_arches); i++)
 340     fprintf (stream, " %s", tic6x_arches[i].arch);
 341   fputc ('\n', stream);
 342 }
 343
 344 /* Update enabled features based on the current architecture and
 345    related settings.  */
 346 static void
 347 tic6x_update_features (void)
 348 {
 349   tic6x_features = tic6x_arch_enable;
 350
 351   tic6x_num_registers
 352     = (tic6x_arch_enable & (TIC6X_INSN_C64X | TIC6X_INSN_C67XP)) ? 32 : 16;
 353
 354   tic6x_predicate_a0 = (tic6x_arch_enable & TIC6X_INSN_C64X) ? TRUE : FALSE;
 355
 356   tic6x_can_cross_fp_boundary
 357     = (tic6x_arch_enable
 358        & (TIC6X_INSN_C64X | TIC6X_INSN_C67XP)) ? TRUE : FALSE;
 359
 360   tic6x_long_data_constraints
 361     = (tic6x_arch_enable & TIC6X_INSN_C64X) ? FALSE : TRUE;
 362
 363   tic6x_compact_insns = (tic6x_arch_enable & TIC6X_INSN_C64XP) ? TRUE : FALSE;
 364 }
 365
 366 /* Do configuration after all options have been parsed.  */
 367
 368 void
 369 tic6x_after_parse_args (void)
 370 {
 371   tic6x_update_features ();
 372 }
 373
 374 /* Parse a .cantunwind directive.  */
 375 static void
 376 s_tic6x_cantunwind (int ignored ATTRIBUTE_UNUSED)
 377 {
 378   tic6x_unwind_info *unwind = tic6x_get_unwind ();
 379
 380   /* GCC sometimes spits out superfluous .cantunwind directives, so ignore
 381      them.  */
 382   if (unwind->data_bytes == 0)
 383     return;
 384
 385   if (unwind->data_bytes != -1)
 386     {
 387       as_bad (_("unexpected .cantunwind directive"));
 388       return;
 389     }
 390
 391   demand_empty_rest_of_line ();
 392
 393   if (unwind->personality_routine || unwind->personality_index != -1)
 394     as_bad (_("personality routine specified for cantunwind frame"));
 395
 396   unwind->personality_index = -2;
 397 }
 398
 399 /* Parse a .handlerdata directive.  */
 400 static void
 401 s_tic6x_handlerdata (int ignored ATTRIBUTE_UNUSED)
 402 {
 403   tic6x_unwind_info *unwind = tic6x_get_unwind ();
 404
 405   if (!unwind->saved_seg)
 406     {
 407       as_bad (_("unexpected .handlerdata directive"));
 408       return;
 409     }
 410
 411   if (unwind->table_entry || unwind->personality_index == -2)
 412     {
 413       as_bad (_("duplicate .handlerdata directive"));
 414       return;
 415     }
 416
 417   if (unwind->personality_index == -1 && unwind->personality_routine == NULL)
 418     {
 419       as_bad (_("personality routine required before .handlerdata directive"));
 420       return;
 421     }
 422
 423   tic6x_output_unwinding (TRUE);
 424 }
 425
 426 /* Parse a .endp directive.  */
 427 static void
 428 s_tic6x_endp (int ignored ATTRIBUTE_UNUSED)
 429 {
 430   tic6x_unwind_info *unwind = tic6x_get_unwind ();
 431
 432   if (unwind->data_bytes != 0)
 433     {
 434       /* Output a .exidx entry if we have not already done so.
 435          Then switch back to the text section.  */
 436       if (!unwind->table_entry)
 437         tic6x_output_unwinding (FALSE);
 438
 439       subseg_set (unwind->saved_seg, unwind->saved_subseg);
 440     }
 441
 442   unwind->saved_seg = NULL;
 443   unwind->table_entry = NULL;
 444   unwind->data_bytes = 0;
 445 }
 446
 447 /* Parse a .personalityindex directive.  */
 448 static void
 449 s_tic6x_personalityindex (int ignored ATTRIBUTE_UNUSED)
 450 {
 451   tic6x_unwind_info *unwind = tic6x_get_unwind ();
 452   expressionS exp;
 453
 454   if (unwind->personality_routine || unwind->personality_index != -1)
 455     as_bad (_("duplicate .personalityindex directive"));
 456
 457   expression (&exp);
 458
 459   if (exp.X_op != O_constant
 460       || exp.X_add_number < 0 || exp.X_add_number > 15)
 461     {
 462       as_bad (_("bad personality routine number"));
 463       ignore_rest_of_line ();
 464       return;
 465     }
 466
 467   unwind->personality_index = exp.X_add_number;
 468
 469   demand_empty_rest_of_line ();
 470 }
 471
 472 static void
 473 s_tic6x_personality (int ignored ATTRIBUTE_UNUSED)
 474 {
 475   char *name, *p, c;
 476   tic6x_unwind_info *unwind = tic6x_get_unwind ();
 477
 478   if (unwind->personality_routine || unwind->personality_index != -1)
 479     as_bad (_("duplicate .personality directive"));
 480
 481   name = input_line_pointer;
 482   c = get_symbol_end ();
 483   p = input_line_pointer;
 484   unwind->personality_routine = symbol_find_or_make (name);
 485   *p = c;
 486   demand_empty_rest_of_line ();
 487 }
 488
 489 /* Parse a .arch directive.  */
 490 static void
 491 s_tic6x_arch (int ignored ATTRIBUTE_UNUSED)
 492 {
 493   char c;
 494   char *arch;
 495
 496   arch = input_line_pointer;
 497   while (*input_line_pointer && !ISSPACE (*input_line_pointer))
 498     input_line_pointer++;
 499   c = *input_line_pointer;
 500   *input_line_pointer = 0;
 501
 502   tic6x_use_arch (arch);
 503   tic6x_update_features ();
 504   *input_line_pointer = c;
 505   demand_empty_rest_of_line ();
 506 }
 507
 508 /* Parse a .ehtype directive.  */
 509
 510 static void
 511 s_tic6x_ehtype (int ignored ATTRIBUTE_UNUSED)
 512 {
 513   expressionS exp;
 514   char *p;
 515
 516 #ifdef md_flush_pending_output
 517   md_flush_pending_output ();
 518 #endif
 519
 520   if (is_it_end_of_statement ())
 521     {
 522       demand_empty_rest_of_line ();
 523       return;
 524     }
 525
 526 #ifdef md_cons_align
 527   md_cons_align (4);
 528 #endif
 529
 530
 531   expression (&exp);
 532
 533   if (exp.X_op != O_symbol)
 534     {
 535       as_bad (_("expected symbol"));
 536       return;
 537     }
 538
 539   p = frag_more (4);
 540   fix_new_exp (frag_now, p - frag_now->fr_literal, 4,
 541                &exp, 0, BFD_RELOC_C6000_EHTYPE);
 542
 543   demand_empty_rest_of_line ();
 544 }
 545
 546 /* Parse a .nocmp directive.  */
 547
 548 static void
 549 s_tic6x_nocmp (int ignored ATTRIBUTE_UNUSED)
 550 {
 551   seg_info (now_seg)->tc_segment_info_data.nocmp = TRUE;
 552   demand_empty_rest_of_line ();
 553 }
 554
 555 /* .scomm pseudo-op handler.
 556
 557    This is a new pseudo-op to handle putting objects in .scommon.
 558    By doing this the linker won't need to do any work,
 559    and more importantly it removes the implicit -G arg necessary to
 560    correctly link the object file.  */
 561
 562 static void
 563 s_tic6x_scomm (int ignore ATTRIBUTE_UNUSED)
 564 {
 565   char *name;
 566   char c;
 567   char *p;
 568   offsetT size;
 569   symbolS *symbolP;
 570   offsetT align;
 571   int align2;
 572
 573   name = input_line_pointer;
 574   c = get_symbol_end ();
 575
 576   /* Just after name is now '\0'.  */
 577   p = input_line_pointer;
 578   *p = c;
 579   SKIP_WHITESPACE ();
 580   if (*input_line_pointer != ',')
 581     {
 582       as_bad (_("expected comma after symbol name"));
 583       ignore_rest_of_line ();
 584       return;
 585     }
 586
 587   /* Skip ','.  */
 588   input_line_pointer++;
 589   if ((size = get_absolute_expression ()) < 0)
 590     {
 591       /* xgettext:c-format  */
 592       as_warn (_("invalid length for .scomm directive"));
 593       ignore_rest_of_line ();
 594       return;
 595     }
 596
 597   /* The third argument to .scomm is the alignment.  */
 598   if (*input_line_pointer != ',')
 599     align = 8;
 600   else
 601     {
 602       ++input_line_pointer;
 603       align = get_absolute_expression ();
 604       if (align <= 0)
 605         {
 606           as_warn (_("alignment is not a positive number"));
 607           align = 8;
 608         }
 609     }
 610
 611   /* Convert to a power of 2 alignment.  */
 612   if (align)
 613     {
 614       for (align2 = 0; (align & 1) == 0; align >>= 1, ++align2)
 615         continue;
 616       if (align != 1)
 617         {
 618           as_bad (_("alignment is not a power of 2"));
 619           ignore_rest_of_line ();
 620           return;
 621         }
 622     }
 623   else
 624     align2 = 0;
 625
 626   *p = 0;
 627   symbolP = symbol_find_or_make (name);
 628   *p = c;
 629
 630   if (S_IS_DEFINED (symbolP))
 631     {
 632       /* xgettext:c-format  */
 633       as_bad (_("attempt to re-define symbol `%s'"),
 634               S_GET_NAME (symbolP));
 635       ignore_rest_of_line ();
 636       return;
 637     }
 638
 639   if (S_GET_VALUE (symbolP) && S_GET_VALUE (symbolP) != (valueT) size)
 640     {
 641       /* xgettext:c-format  */
 642       as_bad (_("attempt to redefine `%s' with a different length"),
 643               S_GET_NAME (symbolP));
 644
 645       ignore_rest_of_line ();
 646       return;
 647     }
 648
 649   if (symbol_get_obj (symbolP)->local)
 650     {
 651       segT old_sec = now_seg;
 652       int old_subsec = now_subseg;
 653       char *pfrag;
 654
 655       record_alignment (sbss_section, align2);
 656       subseg_set (sbss_section, 0);
 657
 658       if (align2)
 659         frag_align (align2, 0, 0);
 660
 661       if (S_GET_SEGMENT (symbolP) == sbss_section)
 662         symbol_get_frag (symbolP)->fr_symbol = 0;
 663
 664       symbol_set_frag (symbolP, frag_now);
 665
 666       pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP, size,
 667                         (char *) 0);
 668       *pfrag = 0;
 669       S_SET_SIZE (symbolP, size);
 670       S_SET_SEGMENT (symbolP, sbss_section);
 671       S_CLEAR_EXTERNAL (symbolP);
 672       subseg_set (old_sec, old_subsec);
 673     }
 674   else
 675     {
 676       S_SET_VALUE (symbolP, (valueT) size);
 677       S_SET_ALIGN (symbolP, 1 << align2);
 678       S_SET_EXTERNAL (symbolP);
 679       S_SET_SEGMENT (symbolP, &scom_section);
 680     }
 681
 682   symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT;
 683
 684   demand_empty_rest_of_line ();
 685 }
 686
 687 /* Track for each attribute whether it has been set explicitly (and so
 688    should not have a default value set by the assembler).  */
 689 static bfd_boolean tic6x_attributes_set_explicitly[NUM_KNOWN_OBJ_ATTRIBUTES];
 690
 691 /* Parse a .c6xabi_attribute directive.  */
 692
 693 static void
 694 s_tic6x_c6xabi_attribute (int ignored ATTRIBUTE_UNUSED)
 695 {
 696   int tag = s_vendor_attribute (OBJ_ATTR_PROC);
 697
 698   if (tag < NUM_KNOWN_OBJ_ATTRIBUTES)
 699     tic6x_attributes_set_explicitly[tag] = TRUE;
 700 }
 701
 702 typedef struct
 703 {
 704   const char *name;
 705   int tag;
 706 } tic6x_attribute_table;
 707
 708 static const tic6x_attribute_table tic6x_attributes[] =
 709   {
 710 #define TAG(tag, value) { #tag, tag },
 711 #include "elf/tic6x-attrs.h"
 712 #undef TAG
 713   };
 714
 715 /* Convert an attribute name to a number.  */
 716
 717 int
 718 tic6x_convert_symbolic_attribute (const char *name)
 719 {
 720   unsigned int i;
 721
 722   for (i = 0; i < ARRAY_SIZE (tic6x_attributes); i++)
 723     if (strcmp (name, tic6x_attributes[i].name) == 0)
 724       return tic6x_attributes[i].tag;
 725
 726   return -1;
 727 }
 728
 729 const pseudo_typeS md_pseudo_table[] =
 730   {
 731     { "arch", s_tic6x_arch, 0 },
 732     { "c6xabi_attribute", s_tic6x_c6xabi_attribute, 0 },
 733     { "nocmp", s_tic6x_nocmp, 0 },
 734     { "scomm",  s_tic6x_scomm, 0 },
 735     { "word", cons, 4 },
 736     { "ehtype", s_tic6x_ehtype, 0 },
 737     { "endp", s_tic6x_endp, 0 },
 738     { "handlerdata", s_tic6x_handlerdata, 0 },
 739     { "personalityindex", s_tic6x_personalityindex, 0 },
 740     { "personality", s_tic6x_personality, 0 },
 741     { "cantunwind", s_tic6x_cantunwind, 0 },
 742     { 0, 0, 0 }
 743   };
 744
 745 /* Hash table of opcodes.  For each opcode name, this stores a pointer
 746    to a tic6x_opcode_list listing (in an arbitrary order) all opcode
 747    table entries with that name.  */
 748 static struct hash_control *opcode_hash;
 749
 750 /* Initialize the assembler (called once at assembler startup).  */
 751
 752 void
 753 md_begin (void)
 754 {
 755   tic6x_opcode_id id;
 756   flagword applicable;
 757   segT seg;
 758   subsegT subseg;
 759
 760   bfd_set_arch_mach (stdoutput, TARGET_ARCH, 0);
 761
 762   /* Insert opcodes into the hash table.  */
 763   opcode_hash = hash_new ();
 764   for (id = 0; id < tic6x_opcode_max; id++)
 765     {
 766       const char *errmsg;
 767       tic6x_opcode_list *opc = xmalloc (sizeof (tic6x_opcode_list));
 768
 769       opc->id = id;
 770       opc->next = hash_find (opcode_hash, tic6x_opcode_table[id].name);
 771       if ((errmsg = hash_jam (opcode_hash, tic6x_opcode_table[id].name, opc))
 772           != NULL)
 773         as_fatal ("%s", _(errmsg));
 774     }
 775
 776   /* Save the current subseg so we can restore it [it's the default one and
 777      we don't want the initial section to be .sbss].  */
 778   seg = now_seg;
 779   subseg = now_subseg;
 780
 781   /* The sbss section is for local .scomm symbols.  */
 782   sbss_section = subseg_new (".bss", 0);
 783   seg_info (sbss_section)->bss = 1;
 784
 785   /* This is copied from perform_an_assembly_pass.  */
 786   applicable = bfd_applicable_section_flags (stdoutput);
 787   bfd_set_section_flags (stdoutput, sbss_section, applicable & SEC_ALLOC);
 788
 789   subseg_set (seg, subseg);
 790
 791   /* We must construct a fake section similar to bfd_com_section
 792      but with the name .scommon.  */
 793   scom_section                = bfd_com_section;
 794   scom_section.name           = ".scommon";
 795   scom_section.output_section = & scom_section;
 796   scom_section.symbol         = & scom_symbol;
 797   scom_section.symbol_ptr_ptr = & scom_section.symbol;
 798   scom_symbol                 = * bfd_com_section.symbol;
 799   scom_symbol.name            = ".scommon";
 800   scom_symbol.section         = & scom_section;
 801 }
 802
 803 /* Whether the current line being parsed had the "||" parallel bars.  */
 804 static bfd_boolean tic6x_line_parallel;
 805
 806 /* Whether the current line being parsed started "||^" to indicate an
 807    SPMASKed parallel instruction.  */
 808 static bfd_boolean tic6x_line_spmask;
 809
 810 /* If the current line being parsed had an instruction predicate, the
 811    creg value for that predicate (which must be nonzero); otherwise
 812    0.  */
 813 static unsigned int tic6x_line_creg;
 814
 815 /* If the current line being parsed had an instruction predicate, the
 816    z value for that predicate; otherwise 0.  */
 817 static unsigned int tic6x_line_z;
 818
 819 /* Return 1 (updating input_line_pointer as appropriate) if the line
 820    starting with C (immediately before input_line_pointer) starts with
 821    pre-opcode text appropriate for this target, 0 otherwise.  */
 822
 823 int
 824 tic6x_unrecognized_line (int c)
 825 {
 826   char *p, *endp;
 827   unsigned int z;
 828   bfd_boolean areg;
 829   bfd_boolean bad_predicate;
 830
 831   switch (c)
 832     {
 833     case '|':
 834       if (input_line_pointer[0] == '|')
 835         {
 836           if (input_line_pointer[1] == '^')
 837             {
 838               tic6x_line_spmask = TRUE;
 839               input_line_pointer += 2;
 840             }
 841           else
 842             input_line_pointer += 1;
 843           if (tic6x_line_parallel)
 844             as_bad (_("multiple '||' on same line"));
 845           tic6x_line_parallel = TRUE;
 846           if (tic6x_line_creg)
 847             as_bad (_("'||' after predicate"));
 848           return 1;
 849         }
 850       return 0;
 851
 852     case '[':
 853       /* If it doesn't look like a predicate at all, just return 0.
 854          If it looks like one but not a valid one, give a better
 855          error.  */
 856       p = input_line_pointer;
 857       while (*p != ']' && !is_end_of_line[(unsigned char) *p])
 858         p++;
 859       if (*p != ']')
 860         return 0;
 861       endp = p + 1;
 862       p = input_line_pointer;
 863       z = 0;
 864       bad_predicate = FALSE;
 865       if (*p == '!')
 866         {
 867           z = 1;
 868           p++;
 869         }
 870       if (*p == 'A' || *p == 'a')
 871         areg = TRUE;
 872       else if (*p == 'B' || *p == 'b')
 873         areg = FALSE;
 874       else
 875         {
 876           areg = TRUE; /* Avoid uninitialized warning.  */
 877           bad_predicate = TRUE;
 878         }
 879       if (!bad_predicate)
 880         {
 881           p++;
 882           if (*p != '0' && *p != '1' && *p != '2')
 883             bad_predicate = TRUE;
 884           else if (p[1] != ']')
 885             bad_predicate = TRUE;
 886           else
 887             input_line_pointer = p + 2;
 888         }
 889
 890       if (tic6x_line_creg)
 891         as_bad (_("multiple predicates on same line"));
 892
 893       if (bad_predicate)
 894         {
 895           char ctmp = *endp;
 896           *endp = 0;
 897           as_bad (_("bad predicate '%s'"), input_line_pointer - 1);
 898           *endp = ctmp;
 899           input_line_pointer = endp;
 900           return 1;
 901         }
 902
 903       switch (*p)
 904         {
 905         case '0':
 906           tic6x_line_creg = (areg ? 6 : 1);
 907           if (areg && !tic6x_predicate_a0)
 908             as_bad (_("predication on A0 not supported on this architecture"));
 909           break;
 910
 911         case '1':
 912           tic6x_line_creg = (areg ? 4 : 2);
 913           break;
 914
 915         case '2':
 916           tic6x_line_creg = (areg ? 5 : 3);
 917           break;
 918
 919         default:
 920           abort ();
 921         }
 922
 923       tic6x_line_z = z;
 924       return 1;
 925
 926     default:
 927       return 0;
 928     }
 929 }
 930
 931 /* Do any target-specific handling of a label required.  */
 932
 933 void
 934 tic6x_frob_label (symbolS *sym)
 935 {
 936   segment_info_type *si;
 937   tic6x_label_list *list;
 938
 939   if (tic6x_line_parallel)
 940     {
 941       as_bad (_("label after '||'"));
 942       tic6x_line_parallel = FALSE;
 943       tic6x_line_spmask = FALSE;
 944     }
 945   if (tic6x_line_creg)
 946     {
 947       as_bad (_("label after predicate"));
 948       tic6x_line_creg = 0;
 949       tic6x_line_z = 0;
 950     }
 951
 952   si = seg_info (now_seg);
 953   list = si->tc_segment_info_data.label_list;
 954   si->tc_segment_info_data.label_list = xmalloc (sizeof (tic6x_label_list));
 955   si->tc_segment_info_data.label_list->next = list;
 956   si->tc_segment_info_data.label_list->label = sym;
 957
 958   /* Defining tc_frob_label overrides the ELF definition of
 959      obj_frob_label, so we need to apply its effects here.  */
 960   dwarf2_emit_label (sym);
 961 }
 962
 963 /* At end-of-line, give errors for start-of-line decorations that
 964    needed an instruction but were not followed by one.  */
 965
 966 static void
 967 tic6x_end_of_line (void)
 968 {
 969   if (tic6x_line_parallel)
 970     {
 971       as_bad (_("'||' not followed by instruction"));
 972       tic6x_line_parallel = FALSE;
 973       tic6x_line_spmask = FALSE;
 974     }
 975   if (tic6x_line_creg)
 976     {
 977       as_bad (_("predicate not followed by instruction"));
 978       tic6x_line_creg = 0;
 979       tic6x_line_z = 0;
 980     }
 981 }
 982
 983 /* Do any target-specific handling of the start of a logical line.  */
 984
 985 void
 986 tic6x_start_line_hook (void)
 987 {
 988   tic6x_end_of_line ();
 989 }
 990
 991 /* Do target-specific handling immediately after an input file from
 992    the command line, and any other inputs it includes, have been
 993    read.  */
 994
 995 void
 996 tic6x_cleanup (void)
 997 {
 998   tic6x_end_of_line ();
 999 }
1000
1001 /* Do target-specific initialization after arguments have been
1002    processed and the output file created.  */
1003
1004 void
1005 tic6x_init_after_args (void)
1006 {
1007   elf32_tic6x_set_use_rela_p (stdoutput, tic6x_generate_rela);
1008 }
1009
1010 /* Free LIST of labels (possibly NULL).  */
1011
1012 static void
1013 tic6x_free_label_list (tic6x_label_list *list)
1014 {
1015   while (list)
1016     {
1017       tic6x_label_list *old = list;
1018
1019       list = list->next;
1020       free (old);
1021     }
1022 }
1023
1024 /* Handle a data alignment of N bytes.  */
1025
1026 void
1027 tic6x_cons_align (int n ATTRIBUTE_UNUSED)
1028 {
1029   segment_info_type *seginfo = seg_info (now_seg);
1030
1031   /* Data means there is no current execute packet, and that any label
1032      applies to that data rather than a subsequent instruction.  */
1033   tic6x_free_label_list (seginfo->tc_segment_info_data.label_list);
1034   seginfo->tc_segment_info_data.label_list = NULL;
1035   seginfo->tc_segment_info_data.execute_packet_frag = NULL;
1036   seginfo->tc_segment_info_data.last_insn_lsb = NULL;
1037   seginfo->tc_segment_info_data.spmask_addr = NULL;
1038   seginfo->tc_segment_info_data.func_units_used = 0;
1039 }
1040
1041 /* Handle an alignment directive.  Return TRUE if the
1042    machine-independent frag generation should be skipped.  */
1043
1044 bfd_boolean
1045 tic6x_do_align (int n, char *fill, int len ATTRIBUTE_UNUSED, int max)
1046 {
1047   /* Given code alignments of 4, 8, 16 or 32 bytes, we try to handle
1048      them in the md_end pass by inserting NOPs in parallel with
1049      previous instructions.  We only do this in sections containing
1050      nothing but instructions.  Code alignments of 1 or 2 bytes have
1051      no effect in such sections (but we record them with
1052      machine-dependent frags anyway so they can be skipped or
1053      converted to machine-independent), while those of more than 64
1054      bytes cannot reliably be handled in this way.  */
1055   if (n > 0
1056       && max >= 0
1057       && max < (1 << n)
1058       && !need_pass_2
1059       && fill == NULL
1060       && subseg_text_p (now_seg))
1061     {
1062       fragS *align_frag;
1063       char *p;
1064
1065       if (n > 5)
1066         return FALSE;
1067
1068       /* Machine-independent code would generate a frag here, but we
1069          wish to handle it in a machine-dependent way.  */
1070       if (frag_now_fix () != 0)
1071         {
1072           if (frag_now->fr_type != rs_machine_dependent)
1073             frag_wane (frag_now);
1074
1075           frag_new (0);
1076         }
1077       frag_grow (32);
1078       align_frag = frag_now;
1079       p = frag_var (rs_machine_dependent, 32, 32, max, NULL, n, NULL);
1080       /* This must be the same as the frag to which a pointer was just
1081          saved.  */
1082       if (p != align_frag->fr_literal)
1083         abort ();
1084       align_frag->tc_frag_data.is_insns = FALSE;
1085       return TRUE;
1086     }
1087   else
1088     return FALSE;
1089 }
1090
1091 /* Types of operand for parsing purposes.  These are used as bit-masks
1092    to tell tic6x_parse_operand what forms of operand are
1093    permitted.  */
1094 #define TIC6X_OP_EXP            0x0001u
1095 #define TIC6X_OP_REG            0x0002u
1096 #define TIC6X_OP_REGPAIR        0x0004u
1097 #define TIC6X_OP_IRP            0x0008u
1098 #define TIC6X_OP_NRP            0x0010u
1099 /* With TIC6X_OP_MEM_NOUNREG, the contents of a () offset are always
1100    interpreted as an expression, which may be a symbol with the same
1101    name as a register that ends up being implicitly DP-relative.  With
1102    TIC6X_OP_MEM_UNREG, the contents of a () offset are interpreted as
1103    a register if they match one, and failing that as an expression,
1104    which must be constant.  */
1105 #define TIC6X_OP_MEM_NOUNREG    0x0020u
1106 #define TIC6X_OP_MEM_UNREG      0x0040u
1107 #define TIC6X_OP_CTRL           0x0080u
1108 #define TIC6X_OP_FUNC_UNIT      0x0100u
1109
1110 /* A register or register pair read by the assembler.  */
1111 typedef struct
1112 {
1113   /* The side the register is on (1 or 2).  */
1114   unsigned int side;
1115   /* The register number (0 to 31).  */
1116   unsigned int num;
1117 } tic6x_register;
1118
1119 /* Types of modification of a base address.  */
1120 typedef enum
1121   {
1122     tic6x_mem_mod_none,
1123     tic6x_mem_mod_plus,
1124     tic6x_mem_mod_minus,
1125     tic6x_mem_mod_preinc,
1126     tic6x_mem_mod_predec,
1127     tic6x_mem_mod_postinc,
1128     tic6x_mem_mod_postdec
1129   } tic6x_mem_mod;
1130
1131 /* Scaled [] or unscaled () nature of an offset.  */
1132 typedef enum
1133   {
1134     tic6x_offset_none,
1135     tic6x_offset_scaled,
1136     tic6x_offset_unscaled
1137   } tic6x_mem_scaling;
1138
1139 /* A memory operand read by the assembler.  */
1140 typedef struct
1141 {
1142   /* The base register.  */
1143   tic6x_register base_reg;
1144   /* How the base register is modified.  */
1145   tic6x_mem_mod mod;
1146   /* Whether there is an offset (required with plain "+" and "-"), and
1147      whether it is scaled or unscaled if so.  */
1148   tic6x_mem_scaling scaled;
1149   /* Whether the offset is a register (TRUE) or an expression
1150      (FALSE).  */
1151   bfd_boolean offset_is_reg;
1152   /* The offset.  */
1153   union
1154   {
1155     expressionS exp;
1156     tic6x_register reg;
1157   } offset;
1158 } tic6x_mem_ref;
1159
1160 /* A functional unit in SPMASK operands read by the assembler.  */
1161 typedef struct
1162 {
1163   /* The basic unit.  */
1164   tic6x_func_unit_base base;
1165   /* The side (1 or 2).  */
1166   unsigned int side;
1167 } tic6x_func_unit_operand;
1168
1169 /* An operand read by the assembler.  */
1170 typedef struct
1171 {
1172   /* The syntactic form of the operand, as one of the bit-masks
1173      above.  */
1174   unsigned int form;
1175   /* The operand value.  */
1176   union
1177   {
1178     /* An expression: TIC6X_OP_EXP.  */
1179     expressionS exp;
1180     /* A register: TIC6X_OP_REG, TIC6X_OP_REGPAIR.  */
1181     tic6x_register reg;
1182     /* A memory reference: TIC6X_OP_MEM_NOUNREG,
1183        TIC6X_OP_MEM_UNREG.  */
1184     tic6x_mem_ref mem;
1185     /* A control register: TIC6X_OP_CTRL.  */
1186     tic6x_ctrl_id ctrl;
1187     /* A functional unit: TIC6X_OP_FUNC_UNIT.  */
1188     tic6x_func_unit_operand func_unit;
1189   } value;
1190 } tic6x_operand;
1191
1192 #define skip_whitespace(str)  do { if (*(str) == ' ') ++(str); } while (0)
1193
1194 /* Parse a register operand, or part of an operand, starting at *P.
1195    If syntactically OK (including that the number is in the range 0 to
1196    31, but not necessarily in range for this architecture), return
1197    TRUE, putting the register side and number in *REG and update *P to
1198    point immediately after the register number; otherwise return FALSE
1199    without changing *P (but possibly changing *REG).  Do not print any
1200    diagnostics.  */
1201
1202 static bfd_boolean
1203 tic6x_parse_register (char **p, tic6x_register *reg)
1204 {
1205   char *r = *p;
1206
1207   switch (*r)
1208     {
1209     case 'a':
1210     case 'A':
1211       reg->side = 1;
1212       break;
1213
1214     case 'b':
1215     case 'B':
1216       reg->side = 2;
1217       break;
1218
1219     default:
1220       return FALSE;
1221     }
1222   r++;
1223
1224   if (*r >= '0' && *r <= '9')
1225     {
1226       reg->num = *r - '0';
1227       r++;
1228     }
1229   else
1230     return FALSE;
1231
1232   if (reg->num > 0 && *r >= '0' && *r <= '9')
1233     {
1234       reg->num = reg->num * 10 + (*r - '0');
1235       r++;
1236     }
1237
1238   if (*r >= '0' && *r <= '9')
1239     return FALSE;
1240
1241   if (reg->num >= 32)
1242     return FALSE;
1243   *p = r;
1244   return TRUE;
1245 }
1246
1247 /* Parse the initial two characters of a functional unit name starting
1248    at *P.  If OK, set *BASE and *SIDE and return TRUE; otherwise,
1249    return FALSE.  */
1250
1251 static bfd_boolean
1252 tic6x_parse_func_unit_base (char *p, tic6x_func_unit_base *base,
1253                             unsigned int *side)
1254 {
1255   bfd_boolean good_func_unit = TRUE;
1256   tic6x_func_unit_base maybe_base = tic6x_func_unit_nfu;
1257   unsigned int maybe_side = 0;
1258
1259   switch (p[0])
1260     {
1261     case 'd':
1262     case 'D':
1263       maybe_base = tic6x_func_unit_d;
1264       break;
1265
1266     case 'l':
1267     case 'L':
1268       maybe_base = tic6x_func_unit_l;
1269       break;
1270
1271     case 'm':
1272     case 'M':
1273       maybe_base = tic6x_func_unit_m;
1274       break;
1275
1276     case 's':
1277     case 'S':
1278       maybe_base = tic6x_func_unit_s;
1279       break;
1280
1281     default:
1282       good_func_unit = FALSE;
1283       break;
1284     }
1285
1286   if (good_func_unit)
1287     switch (p[1])
1288       {
1289       case '1':
1290         maybe_side = 1;
1291         break;
1292
1293       case '2':
1294         maybe_side = 2;
1295         break;
1296
1297       default:
1298         good_func_unit = FALSE;
1299         break;
1300       }
1301
1302   if (good_func_unit)
1303     {
1304       *base = maybe_base;
1305       *side = maybe_side;
1306     }
1307
1308   return good_func_unit;
1309 }
1310
1311 /* Parse an operand starting at *P.  If the operand parses OK, return
1312    TRUE and store the value in *OP; otherwise return FALSE (possibly
1313    changing *OP).  In any case, update *P to point to the following
1314    comma or end of line.  The possible operand forms are given by
1315    OP_FORMS.  For diagnostics, this is operand OPNO of an opcode
1316    starting at STR, length OPC_LEN.  */
1317
1318 static bfd_boolean
1319 tic6x_parse_operand (char **p, tic6x_operand *op, unsigned int op_forms,
1320                      char *str, int opc_len, unsigned int opno)
1321 {
1322   bfd_boolean operand_parsed = FALSE;
1323   char *q = *p;
1324
1325   if ((op_forms & (TIC6X_OP_MEM_NOUNREG | TIC6X_OP_MEM_UNREG))
1326       == (TIC6X_OP_MEM_NOUNREG | TIC6X_OP_MEM_UNREG))
1327     abort ();
1328
1329   /* Check for functional unit names for SPMASK and SPMASKR.  */
1330   if (!operand_parsed && (op_forms & TIC6X_OP_FUNC_UNIT))
1331     {
1332       tic6x_func_unit_base base = tic6x_func_unit_nfu;
1333       unsigned int side = 0;
1334
1335       if (tic6x_parse_func_unit_base (q, &base, &side))
1336         {
1337           char *rq = q + 2;
1338
1339           skip_whitespace (rq);
1340           if (is_end_of_line[(unsigned char) *rq] || *rq == ',')
1341             {
1342               op->form = TIC6X_OP_FUNC_UNIT;
1343               op->value.func_unit.base = base;
1344               op->value.func_unit.side = side;
1345               operand_parsed = TRUE;
1346               q = rq;
1347             }
1348         }
1349     }
1350
1351   /* Check for literal "irp".  */
1352   if (!operand_parsed && (op_forms & TIC6X_OP_IRP))
1353     {
1354       if ((q[0] == 'i' || q[0] == 'I')
1355           && (q[1] == 'r' || q[1] == 'R')
1356           && (q[2] == 'p' || q[2] == 'P'))
1357         {
1358           char *rq = q + 3;
1359
1360           skip_whitespace (rq);
1361           if (is_end_of_line[(unsigned char) *rq] || *rq == ',')
1362             {
1363               op->form = TIC6X_OP_IRP;
1364               operand_parsed = TRUE;
1365               q = rq;
1366             }
1367         }
1368     }
1369
1370   /* Check for literal "nrp".  */
1371   if (!operand_parsed && (op_forms & TIC6X_OP_NRP))
1372     {
1373       if ((q[0] == 'n' || q[0] == 'N')
1374           && (q[1] == 'r' || q[1] == 'R')
1375           && (q[2] == 'p' || q[2] == 'P'))
1376         {
1377           char *rq = q + 3;
1378
1379           skip_whitespace (rq);
1380           if (is_end_of_line[(unsigned char) *rq] || *rq == ',')
1381             {
1382               op->form = TIC6X_OP_NRP;
1383               operand_parsed = TRUE;
1384               q = rq;
1385             }
1386         }
1387     }
1388
1389   /* Check for control register names.  */
1390   if (!operand_parsed && (op_forms & TIC6X_OP_CTRL))
1391     {
1392       tic6x_ctrl_id crid;
1393
1394       for (crid = 0; crid < tic6x_ctrl_max; crid++)
1395         {
1396           size_t len = strlen (tic6x_ctrl_table[crid].name);
1397
1398           if (strncasecmp (tic6x_ctrl_table[crid].name, q, len) == 0)
1399             {
1400               char *rq = q + len;
1401
1402               skip_whitespace (rq);
1403               if (is_end_of_line[(unsigned char) *rq] || *rq == ',')
1404                 {
1405                   op->form = TIC6X_OP_CTRL;
1406                   op->value.ctrl = crid;
1407                   operand_parsed = TRUE;
1408                   q = rq;
1409                   if (!(tic6x_ctrl_table[crid].isa_variants & tic6x_features))
1410                     as_bad (_("control register '%s' not supported "
1411                               "on this architecture"),
1412                             tic6x_ctrl_table[crid].name);
1413                 }
1414             }
1415         }
1416     }
1417
1418   /* See if this looks like a memory reference.  */
1419   if (!operand_parsed
1420       && (op_forms & (TIC6X_OP_MEM_NOUNREG | TIC6X_OP_MEM_UNREG)))
1421     {
1422       bfd_boolean mem_ok = TRUE;
1423       char *mq = q;
1424       tic6x_mem_mod mem_mod = tic6x_mem_mod_none;
1425       tic6x_register base_reg;
1426       bfd_boolean require_offset, permit_offset;
1427       tic6x_mem_scaling scaled;
1428       bfd_boolean offset_is_reg;
1429       expressionS offset_exp;
1430       tic6x_register offset_reg;
1431
1432       if (*mq == '*')
1433         mq++;
1434       else
1435         mem_ok = FALSE;
1436
1437       if (mem_ok)
1438         {
1439           skip_whitespace (mq);
1440           switch (*mq)
1441             {
1442             case '+':
1443               if (mq[1] == '+')
1444                 {
1445                   mem_mod = tic6x_mem_mod_preinc;
1446                   mq += 2;
1447                 }
1448               else
1449                 {
1450                   mem_mod = tic6x_mem_mod_plus;
1451                   mq++;
1452                 }
1453               break;
1454
1455             case '-':
1456               if (mq[1] == '-')
1457                 {
1458                   mem_mod = tic6x_mem_mod_predec;
1459                   mq += 2;
1460                 }
1461               else
1462                 {
1463                   mem_mod = tic6x_mem_mod_minus;
1464                   mq++;
1465                 }
1466               break;
1467
1468             default:
1469               break;
1470             }
1471         }
1472
1473       if (mem_ok)
1474         {
1475           skip_whitespace (mq);
1476           mem_ok = tic6x_parse_register (&mq, &base_reg);
1477         }
1478
1479       if (mem_ok && mem_mod == tic6x_mem_mod_none)
1480         {
1481           skip_whitespace (mq);
1482           if (mq[0] == '+' && mq[1] == '+')
1483             {
1484               mem_mod = tic6x_mem_mod_postinc;
1485               mq += 2;
1486             }
1487           else if (mq[0] == '-' && mq[1] == '-')
1488             {
1489               mem_mod = tic6x_mem_mod_postdec;
1490               mq += 2;
1491             }
1492         }
1493
1494       if (mem_mod == tic6x_mem_mod_none)
1495         permit_offset = FALSE;
1496       else
1497         permit_offset = TRUE;
1498       if (mem_mod == tic6x_mem_mod_plus || mem_mod == tic6x_mem_mod_minus)
1499         require_offset = TRUE;
1500       else
1501         require_offset = FALSE;
1502       scaled = tic6x_offset_none;
1503       offset_is_reg = FALSE;
1504
1505       if (mem_ok && permit_offset)
1506         {
1507           char endc = 0;
1508
1509           skip_whitespace (mq);
1510           switch (*mq)
1511             {
1512             case '[':
1513               scaled = tic6x_offset_scaled;
1514               mq++;
1515               endc = ']';
1516               break;
1517
1518             case '(':
1519               scaled = tic6x_offset_unscaled;
1520               mq++;
1521               endc = ')';
1522               break;
1523
1524             default:
1525               break;
1526             }
1527           if (scaled != tic6x_offset_none)
1528             {
1529               skip_whitespace (mq);
1530               if (scaled == tic6x_offset_scaled
1531                   || (op_forms & TIC6X_OP_MEM_UNREG))
1532                 {
1533                   bfd_boolean reg_ok;
1534                   char *rq = mq;
1535
1536                   reg_ok = tic6x_parse_register (&rq, &offset_reg);
1537                   if (reg_ok)
1538                     {
1539                       skip_whitespace (rq);
1540                       if (*rq == endc)
1541                         {
1542                           mq = rq;
1543                           offset_is_reg = TRUE;
1544                         }
1545                     }
1546                 }
1547               if (!offset_is_reg)
1548                 {
1549                   char *save_input_line_pointer;
1550
1551                   save_input_line_pointer = input_line_pointer;
1552                   input_line_pointer = mq;
1553                   expression (&offset_exp);
1554                   mq = input_line_pointer;
1555                   input_line_pointer = save_input_line_pointer;
1556                 }
1557               skip_whitespace (mq);
1558               if (*mq == endc)
1559                 mq++;
1560               else
1561                 mem_ok = FALSE;
1562             }
1563         }
1564
1565       if (mem_ok && require_offset && scaled == tic6x_offset_none)
1566         mem_ok = FALSE;
1567
1568       if (mem_ok)
1569         {
1570           skip_whitespace (mq);
1571           if (!is_end_of_line[(unsigned char) *mq] && *mq != ',')
1572             mem_ok = FALSE;
1573         }
1574
1575       if (mem_ok)
1576         {
1577           op->form = op_forms & (TIC6X_OP_MEM_NOUNREG | TIC6X_OP_MEM_UNREG);
1578           op->value.mem.base_reg = base_reg;
1579           op->value.mem.mod = mem_mod;
1580           op->value.mem.scaled = scaled;
1581           op->value.mem.offset_is_reg = offset_is_reg;
1582           if (offset_is_reg)
1583             op->value.mem.offset.reg = offset_reg;
1584           else
1585             op->value.mem.offset.exp = offset_exp;
1586           operand_parsed = TRUE;
1587           q = mq;
1588           if (base_reg.num >= tic6x_num_registers)
1589             as_bad (_("register number %u not supported on this architecture"),
1590                     base_reg.num);
1591           if (offset_is_reg && offset_reg.num >= tic6x_num_registers)
1592             as_bad (_("register number %u not supported on this architecture"),
1593                     offset_reg.num);
1594         }
1595     }
1596
1597   /* See if this looks like a register or register pair.  */
1598   if (!operand_parsed && (op_forms & (TIC6X_OP_REG | TIC6X_OP_REGPAIR)))
1599     {
1600       tic6x_register first_reg, second_reg;
1601       bfd_boolean reg_ok;
1602       char *rq = q;
1603
1604       reg_ok = tic6x_parse_register (&rq, &first_reg);
1605
1606       if (reg_ok)
1607         {
1608           if (*rq == ':' && (op_forms & TIC6X_OP_REGPAIR))
1609             {
1610               rq++;
1611               reg_ok = tic6x_parse_register (&rq, &second_reg);
1612               if (reg_ok)
1613                 {
1614                   skip_whitespace (rq);
1615                   if (is_end_of_line[(unsigned char) *rq] || *rq == ',')
1616                     {
1617                       if ((second_reg.num & 1)
1618                           || (first_reg.num != second_reg.num + 1)
1619                           || (first_reg.side != second_reg.side))
1620                         as_bad (_("register pair for operand %u of '%.*s'"
1621                                   " not a valid even/odd pair"), opno,
1622                                 opc_len, str);
1623                       op->form = TIC6X_OP_REGPAIR;
1624                       op->value.reg = second_reg;
1625                       operand_parsed = TRUE;
1626                       q = rq;
1627                     }
1628                 }
1629             }
1630           else if (op_forms & TIC6X_OP_REG)
1631             {
1632               skip_whitespace (rq);
1633               if (is_end_of_line[(unsigned char) *rq] || *rq == ',')
1634                 {
1635                   op->form = TIC6X_OP_REG;
1636                   op->value.reg = first_reg;
1637                   operand_parsed = TRUE;
1638                   q = rq;
1639                 }
1640             }
1641         }
1642       if (operand_parsed)
1643         {
1644           if (first_reg.num >= tic6x_num_registers)
1645             as_bad (_("register number %u not supported on this architecture"),
1646                     first_reg.num);
1647           if (op->form == TIC6X_OP_REGPAIR
1648               && second_reg.num >= tic6x_num_registers)
1649             as_bad (_("register number %u not supported on this architecture"),
1650                     second_reg.num);
1651         }
1652     }
1653
1654   /* Otherwise, parse it as an expression.  */
1655   if (!operand_parsed && (op_forms & TIC6X_OP_EXP))
1656     {
1657       char *save_input_line_pointer;
1658
1659       save_input_line_pointer = input_line_pointer;
1660       input_line_pointer = q;
1661       op->form = TIC6X_OP_EXP;
1662       expression (&op->value.exp);
1663       q = input_line_pointer;
1664       input_line_pointer = save_input_line_pointer;
1665       operand_parsed = TRUE;
1666     }
1667
1668   if (operand_parsed)
1669     {
1670       /* Now the operand has been parsed, there must be nothing more
1671          before the comma or end of line.  */
1672       skip_whitespace (q);
1673       if (!is_end_of_line[(unsigned char) *q] && *q != ',')
1674         {
1675           operand_parsed = FALSE;
1676           as_bad (_("junk after operand %u of '%.*s'"), opno,
1677                   opc_len, str);
1678           while (!is_end_of_line[(unsigned char) *q] && *q != ',')
1679             q++;
1680         }
1681     }
1682   else
1683     {
1684       /* This could not be parsed as any acceptable form of
1685          operand.  */
1686       switch (op_forms)
1687         {
1688         case TIC6X_OP_REG | TIC6X_OP_REGPAIR:
1689           as_bad (_("bad register or register pair for operand %u of '%.*s'"),
1690                   opno, opc_len, str);
1691           break;
1692
1693         case TIC6X_OP_REG | TIC6X_OP_CTRL:
1694         case TIC6X_OP_REG:
1695           as_bad (_("bad register for operand %u of '%.*s'"),
1696                   opno, opc_len, str);
1697           break;
1698
1699         case TIC6X_OP_REGPAIR:
1700           as_bad (_("bad register pair for operand %u of '%.*s'"),
1701                   opno, opc_len, str);
1702           break;
1703
1704         case TIC6X_OP_FUNC_UNIT:
1705           as_bad (_("bad functional unit for operand %u of '%.*s'"),
1706                   opno, opc_len, str);
1707           break;
1708
1709         default:
1710           as_bad (_("bad operand %u of '%.*s'"),
1711                   opno, opc_len, str);
1712           break;
1713
1714         }
1715       while (!is_end_of_line[(unsigned char) *q] && *q != ',')
1716         q++;
1717     }
1718   *p = q;
1719   return operand_parsed;
1720 }
1721
1722 /* Table of assembler operators and associated O_* values.  */
1723 typedef struct
1724 {
1725   const char *name;
1726   operatorT op;
1727 } tic6x_operator_table;
1728 static const tic6x_operator_table tic6x_operators[] = {
1729 #define O_dsbt_index O_md1
1730   { "dsbt_index", O_dsbt_index },
1731 #define O_got O_md2
1732   { "got", O_got },
1733 #define O_dpr_got O_md3
1734   { "dpr_got", O_dpr_got },
1735 #define O_dpr_byte O_md4
1736   { "dpr_byte", O_dpr_byte },
1737 #define O_dpr_hword O_md5
1738   { "dpr_hword", O_dpr_hword },
1739 #define O_dpr_word O_md6
1740   { "dpr_word", O_dpr_word },
1741 #define O_pcr_offset O_md7
1742   { "pcr_offset", O_pcr_offset }
1743 };
1744
1745 /* Parse a name in some machine-specific way.  Used on C6X to handle
1746    assembler operators.  */
1747
1748 int
1749 tic6x_parse_name (const char *name, expressionS *exprP,
1750                   enum expr_mode mode ATTRIBUTE_UNUSED, char *nextchar)
1751 {
1752   char *p = input_line_pointer;
1753   char c, *name_start, *name_end;
1754   const char *inner_name;
1755   unsigned int i;
1756   operatorT op = O_illegal;
1757   symbolS *sym, *op_sym = NULL;
1758
1759   if (*name != '$')
1760     return 0;
1761
1762   for (i = 0; i < ARRAY_SIZE (tic6x_operators); i++)
1763     if (strcasecmp (name + 1, tic6x_operators[i].name) == 0)
1764       {
1765         op = tic6x_operators[i].op;
1766         break;
1767       }
1768
1769   if (op == O_illegal)
1770     return 0;
1771
1772   *input_line_pointer = *nextchar;
1773   skip_whitespace (p);
1774
1775   if (*p != '(')
1776     {
1777       *input_line_pointer = 0;
1778       return 0;
1779     }
1780   p++;
1781   skip_whitespace (p);
1782
1783   if (!is_name_beginner (*p))
1784     {
1785       *input_line_pointer = 0;
1786       return 0;
1787     }
1788
1789   name_start = p;
1790   p++;
1791   while (is_part_of_name (*p))
1792     p++;
1793   name_end = p;
1794   skip_whitespace (p);
1795
1796   if (op == O_pcr_offset)
1797     {
1798       char *op_name_start, *op_name_end;
1799
1800       if (*p != ',')
1801         {
1802           *input_line_pointer = 0;
1803           return 0;
1804         }
1805       p++;
1806       skip_whitespace (p);
1807
1808       if (!is_name_beginner (*p))
1809         {
1810           *input_line_pointer = 0;
1811           return 0;
1812         }
1813
1814       op_name_start = p;
1815       p++;
1816       while (is_part_of_name (*p))
1817         p++;
1818       op_name_end = p;
1819       skip_whitespace (p);
1820
1821       c = *op_name_end;
1822       *op_name_end = 0;
1823       op_sym = symbol_find_or_make (op_name_start);
1824       *op_name_end = c;
1825     }
1826
1827   if (*p != ')')
1828     {
1829       *input_line_pointer = 0;
1830       return 0;
1831     }
1832
1833   input_line_pointer = p + 1;
1834   *nextchar = *input_line_pointer;
1835   *input_line_pointer = 0;
1836
1837   c = *name_end;
1838   *name_end = 0;
1839   inner_name = name_start;
1840   if (op == O_dsbt_index && strcmp (inner_name, "__c6xabi_DSBT_BASE") != 0)
1841     {
1842       as_bad (_("$DSBT_INDEX must be used with __c6xabi_DSBT_BASE"));
1843       inner_name = "__c6xabi_DSBT_BASE";
1844     }
1845   sym = symbol_find_or_make (inner_name);
1846   *name_end = c;
1847
1848   exprP->X_op = op;
1849   exprP->X_add_symbol = sym;
1850   exprP->X_add_number = 0;
1851   exprP->X_op_symbol = op_sym;
1852   exprP->X_md = 0;
1853
1854   return 1;
1855 }
1856
1857 /* Create a fixup for an expression.  Same arguments as fix_new_exp,
1858    plus FIX_ADDA which is TRUE for ADDA instructions (to indicate that
1859    fixes resolving to constants should have those constants implicitly
1860    shifted) and FALSE otherwise, but look for C6X-specific expression
1861    types and adjust the relocations or give errors accordingly.  */
1862
1863 static void
1864 tic6x_fix_new_exp (fragS *frag, int where, int size, expressionS *exp,
1865                    int pcrel, bfd_reloc_code_real_type r_type,
1866                    bfd_boolean fix_adda)
1867 {
1868   bfd_reloc_code_real_type new_reloc = BFD_RELOC_UNUSED;
1869   symbolS *subsy = NULL;
1870   fixS *fix;
1871
1872   switch (exp->X_op)
1873     {
1874     case O_dsbt_index:
1875       switch (r_type)
1876         {
1877         case BFD_RELOC_C6000_SBR_U15_W:
1878           new_reloc = BFD_RELOC_C6000_DSBT_INDEX;
1879           break;
1880
1881         default:
1882           as_bad (_("$DSBT_INDEX not supported in this context"));
1883           return;
1884         }
1885       break;
1886
1887     case O_got:
1888       switch (r_type)
1889         {
1890         case BFD_RELOC_C6000_SBR_U15_W:
1891           new_reloc = BFD_RELOC_C6000_SBR_GOT_U15_W;
1892           break;
1893
1894         default:
1895           as_bad (_("$GOT not supported in this context"));
1896           return;
1897         }
1898       break;
1899
1900     case O_dpr_got:
1901       switch (r_type)
1902         {
1903         case BFD_RELOC_C6000_ABS_L16:
1904           new_reloc = BFD_RELOC_C6000_SBR_GOT_L16_W;
1905           break;
1906
1907         case BFD_RELOC_C6000_ABS_H16:
1908           new_reloc = BFD_RELOC_C6000_SBR_GOT_H16_W;
1909           break;
1910
1911         default:
1912           as_bad (_("$DPR_GOT not supported in this context"));
1913           return;
1914         }
1915       break;
1916
1917     case O_dpr_byte:
1918       switch (r_type)
1919         {
1920         case BFD_RELOC_C6000_ABS_S16:
1921           new_reloc = BFD_RELOC_C6000_SBR_S16;
1922           break;
1923
1924         case BFD_RELOC_C6000_ABS_L16:
1925           new_reloc = BFD_RELOC_C6000_SBR_L16_B;
1926           break;
1927
1928         case BFD_RELOC_C6000_ABS_H16:
1929           new_reloc = BFD_RELOC_C6000_SBR_H16_B;
1930           break;
1931
1932         default:
1933           as_bad (_("$DPR_BYTE not supported in this context"));
1934           return;
1935         }
1936       break;
1937
1938     case O_dpr_hword:
1939       switch (r_type)
1940         {
1941         case BFD_RELOC_C6000_ABS_L16:
1942           new_reloc = BFD_RELOC_C6000_SBR_L16_H;
1943           break;
1944
1945         case BFD_RELOC_C6000_ABS_H16:
1946           new_reloc = BFD_RELOC_C6000_SBR_H16_H;
1947           break;
1948
1949         default:
1950           as_bad (_("$DPR_HWORD not supported in this context"));
1951           return;
1952         }
1953       break;
1954
1955     case O_dpr_word:
1956       switch (r_type)
1957         {
1958         case BFD_RELOC_C6000_ABS_L16:
1959           new_reloc = BFD_RELOC_C6000_SBR_L16_W;
1960           break;
1961
1962         case BFD_RELOC_C6000_ABS_H16:
1963           new_reloc = BFD_RELOC_C6000_SBR_H16_W;
1964           break;
1965
1966         default:
1967           as_bad (_("$DPR_WORD not supported in this context"));
1968           return;
1969         }
1970       break;
1971
1972     case O_pcr_offset:
1973       subsy = exp->X_op_symbol;
1974       switch (r_type)
1975         {
1976         case BFD_RELOC_C6000_ABS_S16:
1977         case BFD_RELOC_C6000_ABS_L16:
1978           new_reloc = BFD_RELOC_C6000_PCR_L16;
1979           break;
1980
1981         case BFD_RELOC_C6000_ABS_H16:
1982           new_reloc = BFD_RELOC_C6000_PCR_H16;
1983           break;
1984
1985         default:
1986           as_bad (_("$PCR_OFFSET not supported in this context"));
1987           return;
1988         }
1989       break;
1990
1991     case O_symbol:
1992       break;
1993
1994     default:
1995       if (pcrel)
1996         {
1997           as_bad (_("invalid PC-relative operand"));
1998           return;
1999         }
2000       break;
2001     }
2002
2003   if (new_reloc == BFD_RELOC_UNUSED)
2004     fix = fix_new_exp (frag, where, size, exp, pcrel, r_type);
2005   else
2006     fix = fix_new (frag, where, size, exp->X_add_symbol, exp->X_add_number,
2007                    pcrel, new_reloc);
2008   fix->tc_fix_data.fix_subsy = subsy;
2009   fix->tc_fix_data.fix_adda = fix_adda;
2010 }
2011
2012 /* Generate a fix for a constant (.word etc.).  Needed to ensure these
2013    go through the error checking in tic6x_fix_new_exp.  */
2014
2015 void
2016 tic6x_cons_fix_new (fragS *frag, int where, int size, expressionS *exp)
2017 {
2018   bfd_reloc_code_real_type r_type;
2019
2020   switch (size)
2021     {
2022     case 1:
2023       r_type = BFD_RELOC_8;
2024       break;
2025
2026     case 2:
2027       r_type = BFD_RELOC_16;
2028       break;
2029
2030     case 4:
2031       r_type = BFD_RELOC_32;
2032       break;
2033
2034     default:
2035       as_bad (_("no %d-byte relocations available"), size);
2036       return;
2037     }
2038
2039   tic6x_fix_new_exp (frag, where, size, exp, 0, r_type, FALSE);
2040 }
2041
2042 /* Initialize target-specific fix data.  */
2043
2044 void
2045 tic6x_init_fix_data (fixS *fixP)
2046 {
2047   fixP->tc_fix_data.fix_adda = FALSE;
2048   fixP->tc_fix_data.fix_subsy = NULL;
2049 }
2050
2051 /* Return true if the fix can be handled by GAS, false if it must
2052    be passed through to the linker.  */
2053
2054 bfd_boolean
2055 tic6x_fix_adjustable (fixS *fixP)
2056 {
2057   switch (fixP->fx_r_type)
2058     {
2059       /* Adjust_reloc_syms doesn't know about the GOT.  */
2060     case BFD_RELOC_C6000_SBR_GOT_U15_W:
2061     case BFD_RELOC_C6000_SBR_GOT_H16_W:
2062     case BFD_RELOC_C6000_SBR_GOT_L16_W:
2063     case BFD_RELOC_C6000_EHTYPE:
2064       return 0;
2065
2066     case BFD_RELOC_C6000_PREL31:
2067       return 0;
2068
2069     case BFD_RELOC_C6000_PCR_H16:
2070     case BFD_RELOC_C6000_PCR_L16:
2071       return 0;
2072
2073     default:
2074       return 1;
2075     }
2076 }
2077
2078 /* Given the fine-grained form of an operand, return the coarse
2079    (bit-mask) form.  */
2080
2081 static unsigned int
2082 tic6x_coarse_operand_form (tic6x_operand_form form)
2083 {
2084   switch (form)
2085     {
2086     case tic6x_operand_asm_const:
2087     case tic6x_operand_link_const:
2088       return TIC6X_OP_EXP;
2089
2090     case tic6x_operand_reg:
2091     case tic6x_operand_xreg:
2092     case tic6x_operand_dreg:
2093     case tic6x_operand_areg:
2094     case tic6x_operand_retreg:
2095       return TIC6X_OP_REG;
2096
2097     case tic6x_operand_regpair:
2098     case tic6x_operand_xregpair:
2099     case tic6x_operand_dregpair:
2100       return TIC6X_OP_REGPAIR;
2101
2102     case tic6x_operand_irp:
2103       return TIC6X_OP_IRP;
2104
2105     case tic6x_operand_nrp:
2106       return TIC6X_OP_NRP;
2107
2108     case tic6x_operand_ctrl:
2109       return TIC6X_OP_CTRL;
2110
2111     case tic6x_operand_mem_short:
2112     case tic6x_operand_mem_long:
2113     case tic6x_operand_mem_deref:
2114       return TIC6X_OP_MEM_NOUNREG;
2115
2116     case tic6x_operand_mem_ndw:
2117       return TIC6X_OP_MEM_UNREG;
2118
2119     case tic6x_operand_func_unit:
2120       return TIC6X_OP_FUNC_UNIT;
2121
2122     default:
2123       abort ();
2124     }
2125 }
2126
2127 /* How an operand may match or not match a desired form.  If different
2128    instruction alternatives fail in different ways, the first failure
2129    in this list determines the diagnostic.  */
2130 typedef enum
2131   {
2132     /* Matches.  */
2133     tic6x_match_matches,
2134     /* Bad coarse form.  */
2135     tic6x_match_coarse,
2136     /* Not constant.  */
2137     tic6x_match_non_const,
2138     /* Register on wrong side.  */
2139     tic6x_match_wrong_side,
2140     /* Not a valid address register.  */
2141     tic6x_match_bad_address,
2142     /* Not a valid return address register.  */
2143     tic6x_match_bad_return,
2144     /* Control register not readable.  */
2145     tic6x_match_ctrl_write_only,
2146     /* Control register not writable.  */
2147     tic6x_match_ctrl_read_only,
2148     /* Not a valid memory reference for this instruction.  */
2149     tic6x_match_bad_mem
2150   } tic6x_operand_match;
2151
2152 /* Return whether an operand matches the given fine-grained form and
2153    read/write usage, and, if it does not match, how it fails to match.
2154    The main functional unit side is SIDE; the cross-path side is CROSS
2155    (the same as SIDE if a cross path not used); the data side is
2156    DATA_SIDE.  */
2157 static tic6x_operand_match
2158 tic6x_operand_matches_form (const tic6x_operand *op, tic6x_operand_form form,
2159                             tic6x_rw rw, unsigned int side, unsigned int cross,
2160                             unsigned int data_side)
2161 {
2162   unsigned int coarse = tic6x_coarse_operand_form (form);
2163
2164   if (coarse != op->form)
2165     return tic6x_match_coarse;
2166
2167   switch (form)
2168     {
2169     case tic6x_operand_asm_const:
2170       if (op->value.exp.X_op == O_constant)
2171         return tic6x_match_matches;
2172       else
2173         return tic6x_match_non_const;
2174
2175     case tic6x_operand_link_const:
2176     case tic6x_operand_irp:
2177     case tic6x_operand_nrp:
2178     case tic6x_operand_func_unit:
2179       /* All expressions are link-time constants, although there may
2180          not be relocations to express them in the output file.  "irp"
2181          and "nrp" are unique operand values.  All parsed functional
2182          unit names are valid.  */
2183       return tic6x_match_matches;
2184
2185     case tic6x_operand_reg:
2186     case tic6x_operand_regpair:
2187       if (op->value.reg.side == side)
2188         return tic6x_match_matches;
2189       else
2190         return tic6x_match_wrong_side;
2191
2192     case tic6x_operand_xreg:
2193     case tic6x_operand_xregpair:
2194       if (op->value.reg.side == cross)
2195         return tic6x_match_matches;
2196       else
2197         return tic6x_match_wrong_side;
2198
2199     case tic6x_operand_dreg:
2200     case tic6x_operand_dregpair:
2201       if (op->value.reg.side == data_side)
2202         return tic6x_match_matches;
2203       else
2204         return tic6x_match_wrong_side;
2205
2206     case tic6x_operand_areg:
2207       if (op->value.reg.side != cross)
2208         return tic6x_match_wrong_side;
2209       else if (op->value.reg.side == 2
2210                && (op->value.reg.num == 14 || op->value.reg.num == 15))
2211         return tic6x_match_matches;
2212       else
2213         return tic6x_match_bad_address;
2214
2215     case tic6x_operand_retreg:
2216       if (op->value.reg.side != side)
2217         return tic6x_match_wrong_side;
2218       else if (op->value.reg.num != 3)
2219         return tic6x_match_bad_return;
2220       else
2221         return tic6x_match_matches;
2222
2223     case tic6x_operand_ctrl:
2224       switch (rw)
2225         {
2226         case tic6x_rw_read:
2227           if (tic6x_ctrl_table[op->value.ctrl].rw == tic6x_rw_read
2228               || tic6x_ctrl_table[op->value.ctrl].rw == tic6x_rw_read_write)
2229             return tic6x_match_matches;
2230           else
2231             return tic6x_match_ctrl_write_only;
2232
2233         case tic6x_rw_write:
2234           if (tic6x_ctrl_table[op->value.ctrl].rw == tic6x_rw_write
2235               || tic6x_ctrl_table[op->value.ctrl].rw == tic6x_rw_read_write)
2236             return tic6x_match_matches;
2237           else
2238             return tic6x_match_ctrl_read_only;
2239
2240         default:
2241           abort ();
2242         }
2243
2244     case tic6x_operand_mem_deref:
2245       if (op->value.mem.mod != tic6x_mem_mod_none)
2246         return tic6x_match_bad_mem;
2247       else if (op->value.mem.scaled != tic6x_offset_none)
2248         abort ();
2249       else if (op->value.mem.base_reg.side != side)
2250         return tic6x_match_bad_mem;
2251       else
2252         return tic6x_match_matches;
2253
2254     case tic6x_operand_mem_short:
2255     case tic6x_operand_mem_ndw:
2256       if (op->value.mem.base_reg.side != side)
2257         return tic6x_match_bad_mem;
2258       if (op->value.mem.mod == tic6x_mem_mod_none)
2259         {
2260           if (op->value.mem.scaled != tic6x_offset_none)
2261             abort ();
2262           return tic6x_match_matches;
2263         }
2264       if (op->value.mem.scaled == tic6x_offset_none)
2265         {
2266           if (op->value.mem.mod == tic6x_mem_mod_plus
2267               || op->value.mem.mod == tic6x_mem_mod_minus)
2268             abort ();
2269           return tic6x_match_matches;
2270         }
2271       if (op->value.mem.offset_is_reg)
2272         {
2273           if (op->value.mem.scaled == tic6x_offset_unscaled
2274               && form != tic6x_operand_mem_ndw)
2275             abort ();
2276           if (op->value.mem.offset.reg.side == side)
2277             return tic6x_match_matches;
2278           else
2279             return tic6x_match_bad_mem;
2280         }
2281       else
2282         {
2283           if (op->value.mem.offset.exp.X_op == O_constant)
2284             return tic6x_match_matches;
2285           else
2286             return tic6x_match_bad_mem;
2287         }
2288
2289     case tic6x_operand_mem_long:
2290       if (op->value.mem.base_reg.side == 2
2291           && (op->value.mem.base_reg.num == 14
2292               || op->value.mem.base_reg.num == 15))
2293         {
2294           switch (op->value.mem.mod)
2295             {
2296             case tic6x_mem_mod_none:
2297               if (op->value.mem.scaled != tic6x_offset_none)
2298                 abort ();
2299               return tic6x_match_matches;
2300
2301             case tic6x_mem_mod_plus:
2302               if (op->value.mem.scaled == tic6x_offset_none)
2303                 abort ();
2304               if (op->value.mem.offset_is_reg)
2305                 return tic6x_match_bad_mem;
2306               else if (op->value.mem.scaled == tic6x_offset_scaled
2307                        && op->value.mem.offset.exp.X_op != O_constant)
2308                 return tic6x_match_bad_mem;
2309               else
2310                 return tic6x_match_matches;
2311
2312             case tic6x_mem_mod_minus:
2313             case tic6x_mem_mod_preinc:
2314             case tic6x_mem_mod_predec:
2315             case tic6x_mem_mod_postinc:
2316             case tic6x_mem_mod_postdec:
2317               return tic6x_match_bad_mem;
2318
2319             default:
2320               abort ();
2321             }
2322
2323         }
2324       else
2325         return tic6x_match_bad_mem;
2326
2327     default:
2328       abort ();
2329     }
2330 }
2331
2332 /* Return the number of bits shift used with DP-relative coding method
2333    CODING.  */
2334
2335 static unsigned int
2336 tic6x_dpr_shift (tic6x_coding_method coding)
2337 {
2338   switch (coding)
2339     {
2340     case tic6x_coding_ulcst_dpr_byte:
2341       return 0;
2342
2343     case tic6x_coding_ulcst_dpr_half:
2344       return 1;
2345
2346     case tic6x_coding_ulcst_dpr_word:
2347       return 2;
2348
2349     default:
2350       abort ();
2351     }
2352 }
2353
2354 /* Return the relocation used with DP-relative coding method
2355    CODING.  */
2356
2357 static bfd_reloc_code_real_type
2358 tic6x_dpr_reloc (tic6x_coding_method coding)
2359 {
2360   switch (coding)
2361     {
2362     case tic6x_coding_ulcst_dpr_byte:
2363       return BFD_RELOC_C6000_SBR_U15_B;
2364
2365     case tic6x_coding_ulcst_dpr_half:
2366       return BFD_RELOC_C6000_SBR_U15_H;
2367
2368     case tic6x_coding_ulcst_dpr_word:
2369       return BFD_RELOC_C6000_SBR_U15_W;
2370
2371     default:
2372       abort ();
2373     }
2374 }
2375
2376 /* Given a memory reference *MEM_REF as originally parsed, fill in
2377    defaults for missing offsets.  */
2378
2379 static void
2380 tic6x_default_mem_ref (tic6x_mem_ref *mem_ref)
2381 {
2382   switch (mem_ref->mod)
2383     {
2384     case tic6x_mem_mod_none:
2385       if (mem_ref->scaled != tic6x_offset_none)
2386         abort ();
2387       mem_ref->mod = tic6x_mem_mod_plus;
2388       mem_ref->scaled = tic6x_offset_unscaled;
2389       mem_ref->offset_is_reg = FALSE;
2390       memset (&mem_ref->offset.exp, 0, sizeof mem_ref->offset.exp);
2391       mem_ref->offset.exp.X_op = O_constant;
2392       mem_ref->offset.exp.X_add_number = 0;
2393       mem_ref->offset.exp.X_unsigned = 0;
2394       break;
2395
2396     case tic6x_mem_mod_plus:
2397     case tic6x_mem_mod_minus:
2398       if (mem_ref->scaled == tic6x_offset_none)
2399         abort ();
2400       break;
2401
2402     case tic6x_mem_mod_preinc:
2403     case tic6x_mem_mod_predec:
2404     case tic6x_mem_mod_postinc:
2405     case tic6x_mem_mod_postdec:
2406       if (mem_ref->scaled != tic6x_offset_none)
2407         break;
2408       mem_ref->scaled = tic6x_offset_scaled;
2409       mem_ref->offset_is_reg = FALSE;
2410       memset (&mem_ref->offset.exp, 0, sizeof mem_ref->offset.exp);
2411       mem_ref->offset.exp.X_op = O_constant;
2412       mem_ref->offset.exp.X_add_number = 1;
2413       mem_ref->offset.exp.X_unsigned = 0;
2414       break;
2415
2416     default:
2417       abort ();
2418     }
2419 }
2420
2421 /* Return the encoding in the 8-bit field of an SPMASK or SPMASKR
2422    instruction of the specified UNIT, side SIDE.  */
2423
2424 static unsigned int
2425 tic6x_encode_spmask (tic6x_func_unit_base unit, unsigned int side)
2426 {
2427   switch (unit)
2428     {
2429     case tic6x_func_unit_l:
2430       return 1 << (side - 1);
2431
2432     case tic6x_func_unit_s:
2433       return 1 << (side + 1);
2434
2435     case tic6x_func_unit_d:
2436       return 1 << (side + 3);
2437
2438     case tic6x_func_unit_m:
2439       return 1 << (side + 5);
2440
2441     default:
2442       abort ();
2443     }
2444 }
2445
2446 /* Try to encode the instruction with opcode number ID and operands
2447    OPERANDS (number NUM_OPERANDS), creg value THIS_LINE_CREG and z
2448    value THIS_LINE_Z; FUNC_UNIT_SIDE, FUNC_UNIT_CROSS and
2449    FUNC_UNIT_DATA_SIDE describe the functional unit specification;
2450    SPLOOP_II is the ii value from the previous SPLOOP-family
2451    instruction, or 0 if not in such a loop; the only possible problems
2452    are operands being out of range (they already match the
2453    fine-grained form), and inappropriate predication.  If this
2454    succeeds, return the encoding and set *OK to TRUE; otherwise return
2455    0 and set *OK to FALSE.  If a fix is needed, set *FIX_NEEDED to
2456    true and fill in *FIX_EXP, *FIX_PCREL, *FX_R_TYPE and *FIX_ADDA.
2457    Print error messages for failure if PRINT_ERRORS is TRUE; the
2458    opcode starts at STR and has length OPC_LEN.  */
2459
2460 static unsigned int
2461 tic6x_try_encode (tic6x_opcode_id id, tic6x_operand *operands,
2462                   unsigned int num_operands, unsigned int this_line_creg,
2463                   unsigned int this_line_z, unsigned int func_unit_side,
2464                   unsigned int func_unit_cross,
2465                   unsigned int func_unit_data_side, int sploop_ii,
2466                   expressionS **fix_exp, int *fix_pcrel,
2467                   bfd_reloc_code_real_type *fx_r_type, bfd_boolean *fix_adda,
2468                   bfd_boolean *fix_needed, bfd_boolean *ok,
2469                   bfd_boolean print_errors, char *str, int opc_len)
2470 {
2471   const tic6x_opcode *opct;
2472   const tic6x_insn_format *fmt;
2473   unsigned int opcode_value;
2474   unsigned int fld;
2475
2476   opct = &tic6x_opcode_table[id];
2477   fmt = &tic6x_insn_format_table[opct->format];
2478   opcode_value = fmt->cst_bits;
2479
2480   for (fld = 0; fld < opct->num_fixed_fields; fld++)
2481     {
2482       if (opct->fixed_fields[fld].min_val == opct->fixed_fields[fld].max_val)
2483         {
2484           const tic6x_insn_field *fldd;
2485           fldd = tic6x_field_from_fmt (fmt, opct->fixed_fields[fld].field_id);
2486           if (fldd == NULL)
2487             abort ();
2488           opcode_value |= opct->fixed_fields[fld].min_val << fldd->low_pos;
2489         }
2490     }
2491
2492   for (fld = 0; fld < opct->num_variable_fields; fld++)
2493     {
2494       const tic6x_insn_field *fldd;
2495       unsigned int value;
2496       unsigned int opno;
2497       unsigned int ffld;
2498       offsetT sign_value;
2499       unsigned int bits;
2500       unsigned int fcyc_bits;
2501       expressionS *expp;
2502       expressionS ucexp;
2503       tic6x_mem_ref mem;
2504
2505       fldd = tic6x_field_from_fmt (fmt, opct->variable_fields[fld].field_id);
2506       if (fldd == NULL)
2507         abort ();
2508       opno = opct->variable_fields[fld].operand_num;
2509       switch (opct->variable_fields[fld].coding_method)
2510         {
2511         case tic6x_coding_ucst:
2512           if (operands[opno].form != TIC6X_OP_EXP)
2513             abort ();
2514           if (operands[opno].value.exp.X_op != O_constant)
2515             abort ();
2516           ucexp = operands[opno].value.exp;
2517         unsigned_constant:
2518           if (ucexp.X_add_number < 0
2519               || ucexp.X_add_number >= (1 << fldd->width))
2520             {
2521               if (print_errors)
2522                 as_bad (_("operand %u of '%.*s' out of range"), opno + 1,
2523                         opc_len, str);
2524               *ok = FALSE;
2525               return 0;
2526             }
2527           value = ucexp.X_add_number;
2528           break;
2529
2530         case tic6x_coding_scst:
2531           if (operands[opno].form != TIC6X_OP_EXP)
2532             abort ();
2533           if (operands[opno].value.exp.X_op != O_constant)
2534             {
2535               value = 0;
2536               /* Opcode table should not permit non-constants without
2537                  a known relocation for them.  */
2538               if (fldd->low_pos != 7 || fldd->width != 16)
2539                 abort ();
2540               *fix_needed = TRUE;
2541               *fix_exp = &operands[opno].value.exp;
2542               *fix_pcrel = 0;
2543               *fx_r_type = BFD_RELOC_C6000_ABS_S16;
2544               *fix_adda = FALSE;
2545               break;
2546             }
2547           sign_value = SEXT (operands[opno].value.exp.X_add_number);
2548         signed_constant:
2549           if (sign_value < -(1 << (fldd->width - 1))
2550               || (sign_value >= (1 << (fldd->width - 1))))
2551             {
2552               if (print_errors)
2553                 as_bad (_("operand %u of '%.*s' out of range"), opno + 1,
2554                         opc_len, str);
2555               *ok = FALSE;
2556               return 0;
2557             }
2558           value = sign_value + (1 << (fldd->width - 1));
2559           value ^= (1 << (fldd->width - 1));
2560           break;
2561
2562         case tic6x_coding_ucst_minus_one:
2563           if (operands[opno].form != TIC6X_OP_EXP)
2564             abort ();
2565           if (operands[opno].value.exp.X_op != O_constant)
2566             abort ();
2567           if (operands[opno].value.exp.X_add_number <= 0
2568               || operands[opno].value.exp.X_add_number > (1 << fldd->width))
2569             {
2570               if (print_errors)
2571                 as_bad (_("operand %u of '%.*s' out of range"), opno + 1,
2572                         opc_len, str);
2573               *ok = FALSE;
2574               return 0;
2575             }
2576           value = operands[opno].value.exp.X_add_number - 1;
2577           break;
2578
2579         case tic6x_coding_scst_negate:
2580           if (operands[opno].form != TIC6X_OP_EXP)
2581             abort ();
2582           if (operands[opno].value.exp.X_op != O_constant)
2583             abort ();
2584           sign_value = SEXT (-operands[opno].value.exp.X_add_number);
2585           goto signed_constant;
2586
2587         case tic6x_coding_ulcst_dpr_byte:
2588         case tic6x_coding_ulcst_dpr_half:
2589         case tic6x_coding_ulcst_dpr_word:
2590           bits = tic6x_dpr_shift (opct->variable_fields[fld].coding_method);
2591           switch (operands[opno].form)
2592             {
2593             case TIC6X_OP_EXP:
2594               if (operands[opno].value.exp.X_op == O_constant)
2595                 {
2596                   ucexp = operands[opno].value.exp;
2597                   goto unsigned_constant;
2598                 }
2599               expp = &operands[opno].value.exp;
2600               break;
2601
2602             case TIC6X_OP_MEM_NOUNREG:
2603               mem = operands[opno].value.mem;
2604               tic6x_default_mem_ref (&mem);
2605               if (mem.offset_is_reg)
2606                 abort ();
2607               if (mem.offset.exp.X_op == O_constant)
2608                 {
2609                   ucexp = mem.offset.exp;
2610                   if (mem.scaled == tic6x_offset_unscaled)
2611                     {
2612                       if (ucexp.X_add_number & ((1 << bits) - 1))
2613                         {
2614                           if (print_errors)
2615                             as_bad (_("offset in operand %u of '%.*s' not "
2616                                       "divisible by %u"), opno + 1, opc_len,
2617                                     str, 1u << bits);
2618                           *ok = FALSE;
2619                           return 0;
2620                         }
2621                       ucexp.X_add_number >>= bits;
2622                     }
2623                   goto unsigned_constant;
2624                 }
2625               if (mem.scaled != tic6x_offset_unscaled)
2626                 abort ();
2627               if (operands[opno].value.mem.mod == tic6x_mem_mod_none
2628                   || operands[opno].value.mem.scaled != tic6x_offset_unscaled
2629                   || operands[opno].value.mem.offset_is_reg)
2630                 abort ();
2631               expp = &operands[opno].value.mem.offset.exp;
2632               break;
2633
2634             default:
2635               abort ();
2636             }
2637           value = 0;
2638           /* Opcode table should not use this encoding without a known
2639              relocation.  */
2640           if (fldd->low_pos != 8 || fldd->width != 15)
2641             abort ();
2642           /* We do not check for offset divisibility here; such a
2643              check is not needed at this point to encode the value,
2644              and if there is eventually a problem it will be detected
2645              either in md_apply_fix or at link time.  */
2646           *fix_needed = TRUE;
2647           *fix_exp = expp;
2648           *fix_pcrel = 0;
2649           *fx_r_type
2650             = tic6x_dpr_reloc (opct->variable_fields[fld].coding_method);
2651           if (operands[opno].form == TIC6X_OP_EXP)
2652             *fix_adda = TRUE;
2653           else
2654             *fix_adda = FALSE;
2655           break;
2656
2657         case tic6x_coding_lcst_low16:
2658           if (operands[opno].form != TIC6X_OP_EXP)
2659             abort ();
2660           if (operands[opno].value.exp.X_op == O_constant)
2661             value = operands[opno].value.exp.X_add_number & 0xffff;
2662           else
2663             {
2664               value = 0;
2665               /* Opcode table should not use this encoding without a
2666                  known relocation.  */
2667               if (fldd->low_pos != 7 || fldd->width != 16)
2668                 abort ();
2669               *fix_needed = TRUE;
2670               *fix_exp = &operands[opno].value.exp;
2671               *fix_pcrel = 0;
2672               *fx_r_type = BFD_RELOC_C6000_ABS_L16;
2673               *fix_adda = FALSE;
2674             }
2675           break;
2676
2677         case tic6x_coding_lcst_high16:
2678           if (operands[opno].form != TIC6X_OP_EXP)
2679             abort ();
2680           if (operands[opno].value.exp.X_op == O_constant)
2681             value = (operands[opno].value.exp.X_add_number >> 16) & 0xffff;
2682           else
2683             {
2684               value = 0;
2685               /* Opcode table should not use this encoding without a
2686                  known relocation.  */
2687               if (fldd->low_pos != 7 || fldd->width != 16)
2688                 abort ();
2689               *fix_needed = TRUE;
2690               *fix_exp = &operands[opno].value.exp;
2691               *fix_pcrel = 0;
2692               *fx_r_type = BFD_RELOC_C6000_ABS_H16;
2693               *fix_adda = FALSE;
2694             }
2695           break;
2696
2697         case tic6x_coding_pcrel:
2698         case tic6x_coding_pcrel_half:
2699           if (operands[opno].form != TIC6X_OP_EXP)
2700             abort ();
2701           value = 0;
2702           *fix_needed = TRUE;
2703           *fix_exp = &operands[opno].value.exp;
2704           *fix_pcrel = 1;
2705           if (fldd->low_pos == 7 && fldd->width == 21)
2706             *fx_r_type = BFD_RELOC_C6000_PCR_S21;
2707           else if (fldd->low_pos == 16 && fldd->width == 12)
2708             *fx_r_type = BFD_RELOC_C6000_PCR_S12;
2709           else if (fldd->low_pos == 13 && fldd->width == 10)
2710             *fx_r_type = BFD_RELOC_C6000_PCR_S10;
2711           else if (fldd->low_pos == 16 && fldd->width == 7)
2712             *fx_r_type = BFD_RELOC_C6000_PCR_S7;
2713           else
2714             /* Opcode table should not use this encoding without a
2715                known relocation.  */
2716             abort ();
2717           *fix_adda = FALSE;
2718           break;
2719
2720         case tic6x_coding_reg:
2721           switch (operands[opno].form)
2722             {
2723             case TIC6X_OP_REG:
2724             case TIC6X_OP_REGPAIR:
2725               value = operands[opno].value.reg.num;
2726               break;
2727
2728             case TIC6X_OP_MEM_NOUNREG:
2729             case TIC6X_OP_MEM_UNREG:
2730               value = operands[opno].value.mem.base_reg.num;
2731               break;
2732
2733             default:
2734               abort ();
2735             }
2736           break;
2737
2738         case tic6x_coding_areg:
2739           switch (operands[opno].form)
2740             {
2741             case TIC6X_OP_REG:
2742               value = (operands[opno].value.reg.num == 15 ? 1 : 0);
2743               break;
2744
2745             case TIC6X_OP_MEM_NOUNREG:
2746               value = (operands[opno].value.mem.base_reg.num == 15 ? 1 : 0);
2747               break;
2748
2749             default:
2750               abort ();
2751             }
2752           break;
2753
2754         case tic6x_coding_crlo:
2755           if (operands[opno].form != TIC6X_OP_CTRL)
2756             abort ();
2757           value = tic6x_ctrl_table[operands[opno].value.ctrl].crlo;
2758           break;
2759
2760         case tic6x_coding_crhi:
2761           if (operands[opno].form != TIC6X_OP_CTRL)
2762             abort ();
2763           value = 0;
2764           break;
2765
2766         case tic6x_coding_reg_shift:
2767           if (operands[opno].form != TIC6X_OP_REGPAIR)
2768             abort ();
2769           value = operands[opno].value.reg.num >> 1;
2770           break;
2771
2772         case tic6x_coding_mem_offset:
2773           if (operands[opno].form != TIC6X_OP_MEM_NOUNREG)
2774             abort ();
2775           mem = operands[opno].value.mem;
2776           tic6x_default_mem_ref (&mem);
2777           if (mem.offset_is_reg)
2778             {
2779               if (mem.scaled != tic6x_offset_scaled)
2780                 abort ();
2781               value = mem.offset.reg.num;
2782             }
2783           else
2784             {
2785               int scale;
2786
2787               if (mem.offset.exp.X_op != O_constant)
2788                 abort ();
2789               switch (mem.scaled)
2790                 {
2791                 case tic6x_offset_scaled:
2792                   scale = 1;
2793                   break;
2794
2795                 case tic6x_offset_unscaled:
2796                   scale = opct->operand_info[opno].size;
2797                   if (scale != 1 && scale != 2 && scale != 4 && scale != 8)
2798                     abort ();
2799                   break;
2800
2801                 default:
2802                   abort ();
2803                 }
2804               if (mem.offset.exp.X_add_number < 0
2805                   || mem.offset.exp.X_add_number >= (1 << fldd->width) * scale)
2806                 {
2807                   if (print_errors)
2808                     as_bad (_("offset in operand %u of '%.*s' out of range"),
2809                             opno + 1, opc_len, str);
2810                   *ok = FALSE;
2811                   return 0;
2812                 }
2813               if (mem.offset.exp.X_add_number % scale)
2814                 {
2815                   if (print_errors)
2816                     as_bad (_("offset in operand %u of '%.*s' not "
2817                               "divisible by %u"),
2818                             opno + 1, opc_len, str, scale);
2819                   *ok = FALSE;
2820                   return 0;
2821                 }
2822               value = mem.offset.exp.X_add_number / scale;
2823             }
2824           break;
2825
2826         case tic6x_coding_mem_offset_noscale:
2827           if (operands[opno].form != TIC6X_OP_MEM_UNREG)
2828             abort ();
2829           mem = operands[opno].value.mem;
2830           tic6x_default_mem_ref (&mem);
2831           if (mem.offset_is_reg)
2832             value = mem.offset.reg.num;
2833           else
2834             {
2835               if (mem.offset.exp.X_op != O_constant)
2836                 abort ();
2837               if (mem.offset.exp.X_add_number < 0
2838                   || mem.offset.exp.X_add_number >= (1 << fldd->width))
2839                 {
2840                   if (print_errors)
2841                     as_bad (_("offset in operand %u of '%.*s' out of range"),
2842                             opno + 1, opc_len, str);
2843                   *ok = FALSE;
2844                   return 0;
2845                 }
2846               value = mem.offset.exp.X_add_number;
2847             }
2848           break;
2849
2850         case tic6x_coding_mem_mode:
2851           if (operands[opno].form != TIC6X_OP_MEM_NOUNREG
2852               && operands[opno].form != TIC6X_OP_MEM_UNREG)
2853             abort ();
2854           mem = operands[opno].value.mem;
2855           tic6x_default_mem_ref (&mem);
2856           switch (mem.mod)
2857             {
2858             case tic6x_mem_mod_plus:
2859               value = 1;
2860               break;
2861
2862             case tic6x_mem_mod_minus:
2863               value = 0;
2864               break;
2865
2866             case tic6x_mem_mod_preinc:
2867               value = 9;
2868               break;
2869
2870             case tic6x_mem_mod_predec:
2871               value = 8;
2872               break;
2873
2874             case tic6x_mem_mod_postinc:
2875               value = 11;
2876               break;
2877
2878             case tic6x_mem_mod_postdec:
2879               value = 10;
2880               break;
2881
2882             default:
2883               abort ();
2884             }
2885           value += (mem.offset_is_reg ? 4 : 0);
2886           break;
2887
2888         case tic6x_coding_scaled:
2889           if (operands[opno].form != TIC6X_OP_MEM_UNREG)
2890             abort ();
2891           mem = operands[opno].value.mem;
2892           tic6x_default_mem_ref (&mem);
2893           switch (mem.scaled)
2894             {
2895             case tic6x_offset_unscaled:
2896               value = 0;
2897               break;
2898
2899             case tic6x_offset_scaled:
2900               value = 1;
2901               break;
2902
2903             default:
2904               abort ();
2905             }
2906           break;
2907
2908         case tic6x_coding_spmask:
2909           /* The position of such a field is hardcoded in the handling
2910              of "||^".  */
2911           if (fldd->low_pos != 18)
2912             abort ();
2913           value = 0;
2914           for (opno = 0; opno < num_operands; opno++)
2915             {
2916               unsigned int v;
2917
2918               v = tic6x_encode_spmask (operands[opno].value.func_unit.base,
2919                                        operands[opno].value.func_unit.side);
2920               if (value & v)
2921                 {
2922                   if (print_errors)
2923                     as_bad (_("functional unit already masked for operand "
2924                               "%u of '%.*s'"), opno + 1, opc_len, str);
2925                   *ok = FALSE;
2926                   return 0;
2927                 }
2928               value |= v;
2929             }
2930           break;
2931
2932         case tic6x_coding_reg_unused:
2933           /* This is a placeholder; correct handling goes along with
2934              resource constraint checks.  */
2935           value = 0;
2936           break;
2937
2938         case tic6x_coding_fstg:
2939         case tic6x_coding_fcyc:
2940           if (operands[opno].form != TIC6X_OP_EXP)
2941             abort ();
2942           if (operands[opno].value.exp.X_op != O_constant)
2943             abort ();
2944           if (!sploop_ii)
2945             {
2946               if (print_errors)
2947                 as_bad (_("'%.*s' instruction not in a software "
2948                           "pipelined loop"),
2949                         opc_len, str);
2950               *ok = FALSE;
2951               return 0;
2952             }
2953
2954           if (sploop_ii <= 1)
2955             fcyc_bits = 0;
2956           else if (sploop_ii <= 2)
2957             fcyc_bits = 1;
2958           else if (sploop_ii <= 4)
2959             fcyc_bits = 2;
2960           else if (sploop_ii <= 8)
2961             fcyc_bits = 3;
2962           else if (sploop_ii <= 14)
2963             fcyc_bits = 4;
2964           else
2965             abort ();
2966           if (fcyc_bits > fldd->width)
2967             abort ();
2968
2969           if (opct->variable_fields[fld].coding_method == tic6x_coding_fstg)
2970             {
2971               int i, t;
2972               if (operands[opno].value.exp.X_add_number < 0
2973                   || (operands[opno].value.exp.X_add_number
2974                       >= (1 << (fldd->width - fcyc_bits))))
2975                 {
2976                   if (print_errors)
2977                     as_bad (_("operand %u of '%.*s' out of range"), opno + 1,
2978                             opc_len, str);
2979                   *ok = FALSE;
2980                   return 0;
2981                 }
2982               value = operands[opno].value.exp.X_add_number;
2983               for (t = 0, i = fcyc_bits; i < fldd->width; i++)
2984                 {
2985                   t = (t << 1) | (value & 1);
2986                   value >>= 1;
2987                 }
2988               value = t << fcyc_bits;
2989             }
2990           else
2991             {
2992               if (operands[opno].value.exp.X_add_number < 0
2993                   || (operands[opno].value.exp.X_add_number >= sploop_ii))
2994                 {
2995                   if (print_errors)
2996                     as_bad (_("operand %u of '%.*s' out of range"), opno + 1,
2997                             opc_len, str);
2998                   *ok = FALSE;
2999                   return 0;
3000                 }
3001               value = operands[opno].value.exp.X_add_number;
3002             }
3003           break;
3004
3005         case tic6x_coding_fu:
3006           value = func_unit_side == 2 ? 1 : 0;
3007           break;
3008
3009         case tic6x_coding_data_fu:
3010           value = func_unit_data_side == 2 ? 1 : 0;
3011           break;
3012
3013         case tic6x_coding_xpath:
3014           value = func_unit_cross;
3015           break;
3016
3017         default:
3018           abort ();
3019         }
3020
3021       for (ffld = 0; ffld < opct->num_fixed_fields; ffld++)
3022         if ((opct->fixed_fields[ffld].field_id
3023              == opct->variable_fields[fld].field_id)
3024             && (value < opct->fixed_fields[ffld].min_val
3025                 || value > opct->fixed_fields[ffld].max_val))
3026           {
3027             if (print_errors)
3028               as_bad (_("operand %u of '%.*s' out of range"), opno + 1,
3029                       opc_len, str);
3030             *ok = FALSE;
3031             return 0;
3032           }
3033
3034       opcode_value |= value << fldd->low_pos;
3035     }
3036
3037   if (this_line_creg)
3038     {
3039       const tic6x_insn_field *creg;
3040       const tic6x_insn_field *z;
3041
3042       creg = tic6x_field_from_fmt (fmt, tic6x_field_creg);
3043       if (creg == NULL)
3044         {
3045           if (print_errors)
3046             as_bad (_("instruction '%.*s' cannot be predicated"),
3047                     opc_len, str);
3048           *ok = FALSE;
3049           return 0;
3050         }
3051       z = tic6x_field_from_fmt (fmt, tic6x_field_z);
3052       /* If there is a creg field, there must be a z field; otherwise
3053          there is an error in the format table.  */
3054       if (z == NULL)
3055         abort ();
3056
3057       opcode_value |= this_line_creg << creg->low_pos;
3058       opcode_value |= this_line_z << z->low_pos;
3059     }
3060
3061   *ok = TRUE;
3062   return opcode_value;
3063 }
3064
3065 /* Convert the target integer stored in N bytes in BUF to a host
3066    integer, returning that value.  */
3067
3068 static valueT
3069 md_chars_to_number (char *buf, int n)
3070 {
3071   valueT result = 0;
3072   unsigned char *p = (unsigned char *) buf;
3073
3074   if (target_big_endian)
3075     {
3076       while (n--)
3077         {
3078           result <<= 8;
3079           result |= (*p++ & 0xff);
3080         }
3081     }
3082   else
3083     {
3084       while (n--)
3085         {
3086           result <<= 8;
3087           result |= (p[n] & 0xff);
3088         }
3089     }
3090
3091   return result;
3092 }
3093
3094 /* Assemble the instruction starting at STR (an opcode, with the
3095    opcode name all-lowercase).  */
3096
3097 void
3098 md_assemble (char *str)
3099 {
3100   char *p;
3101   int opc_len;
3102   bfd_boolean this_line_parallel;
3103   bfd_boolean this_line_spmask;
3104   unsigned int this_line_creg;
3105   unsigned int this_line_z;
3106   tic6x_label_list *this_insn_label_list;
3107   segment_info_type *seginfo;
3108   tic6x_opcode_list *opc_list, *opc;
3109   tic6x_func_unit_base func_unit_base = tic6x_func_unit_nfu;
3110   unsigned int func_unit_side = 0;
3111   unsigned int func_unit_cross = 0;
3112   unsigned int cross_side = 0;
3113   unsigned int func_unit_data_side = 0;
3114   unsigned int max_matching_opcodes, num_matching_opcodes;
3115   tic6x_opcode_id *opcm = NULL;
3116   unsigned int opc_rank[TIC6X_NUM_PREFER];
3117   const tic6x_opcode *opct = NULL;
3118   int min_rank, try_rank, max_rank;
3119   bfd_boolean num_operands_permitted[TIC6X_MAX_SOURCE_OPERANDS + 1]
3120     = { FALSE };
3121   unsigned int operand_forms[TIC6X_MAX_SOURCE_OPERANDS] = { 0 };
3122   tic6x_operand operands[TIC6X_MAX_SOURCE_OPERANDS];
3123   unsigned int max_num_operands;
3124   unsigned int num_operands_read;
3125   bfd_boolean ok_this_arch, ok_this_fu, ok_this_arch_fu;
3126   bfd_boolean bad_operands = FALSE;
3127   unsigned int opcode_value;
3128   bfd_boolean encoded_ok;
3129   bfd_boolean fix_needed = FALSE;
3130   expressionS *fix_exp = NULL;
3131   int fix_pcrel = 0;
3132   bfd_reloc_code_real_type fx_r_type = BFD_RELOC_UNUSED;
3133   bfd_boolean fix_adda = FALSE;
3134   fragS *insn_frag;
3135   char *output;
3136
3137   p = str;
3138   while (*p && !is_end_of_line[(unsigned char) *p] && *p != ' ')
3139     p++;
3140
3141   /* This function should only have been called when there is actually
3142      an instruction to assemble.  */
3143   if (p == str)
3144     abort ();
3145
3146   /* Now an instruction has been seen, architecture attributes from
3147      .arch directives merge with rather than overriding the previous
3148      value.  */
3149   tic6x_seen_insns = TRUE;
3150   /* If no .arch directives or -march options have been seen, we are
3151      assessing instruction validity based on the C674X default, so set
3152      the attribute accordingly.  */
3153   if (tic6x_arch_attribute == C6XABI_Tag_ISA_none)
3154     tic6x_arch_attribute = C6XABI_Tag_ISA_C674X;
3155
3156   /* Reset global settings for parallel bars and predicates now to
3157      avoid extra errors if there are problems with this opcode.  */
3158   this_line_parallel = tic6x_line_parallel;
3159   this_line_spmask = tic6x_line_spmask;
3160   this_line_creg = tic6x_line_creg;
3161   this_line_z = tic6x_line_z;
3162   tic6x_line_parallel = FALSE;
3163   tic6x_line_spmask = FALSE;
3164   tic6x_line_creg = 0;
3165   tic6x_line_z = 0;
3166   seginfo = seg_info (now_seg);
3167   this_insn_label_list = seginfo->tc_segment_info_data.label_list;
3168   seginfo->tc_segment_info_data.label_list = NULL;
3169
3170   opc_list = hash_find_n (opcode_hash, str, p - str);
3171   if (opc_list == NULL)
3172     {
3173       char c = *p;
3174       *p = 0;
3175       as_bad (_("unknown opcode '%s'"), str);
3176       *p = c;
3177       return;
3178     }
3179
3180   opc_len = p - str;
3181   skip_whitespace (p);
3182
3183   /* See if there is something that looks like a functional unit
3184      specifier.  */
3185   if (*p == '.')
3186     {
3187       bfd_boolean good_func_unit;
3188       tic6x_func_unit_base maybe_base = tic6x_func_unit_nfu;
3189       unsigned int maybe_side = 0;
3190       unsigned int maybe_cross = 0;
3191       unsigned int maybe_data_side = 0;
3192
3193       good_func_unit = tic6x_parse_func_unit_base (p + 1, &maybe_base,
3194                                                    &maybe_side);
3195
3196       if (good_func_unit)
3197         {
3198           if (p[3] == ' ' || is_end_of_line[(unsigned char) p[3]])
3199             p += 3;
3200           else if ((p[3] == 'x' || p[3] == 'X')
3201                    && (p[4] == ' ' || is_end_of_line[(unsigned char) p[4]]))
3202             {
3203               maybe_cross = 1;
3204               p += 4;
3205             }
3206           else if (maybe_base == tic6x_func_unit_d
3207                    && (p[3] == 't' || p[3] == 'T')
3208                    && (p[4] == '1' || p[4] == '2')
3209                    && (p[5] == ' ' || is_end_of_line[(unsigned char) p[5]]))
3210             {
3211               maybe_data_side = p[4] - '0';
3212               p += 5;
3213             }
3214           else
3215             good_func_unit = FALSE;
3216         }
3217
3218       if (good_func_unit)
3219         {
3220           func_unit_base = maybe_base;
3221           func_unit_side = maybe_side;
3222           func_unit_cross = maybe_cross;
3223           cross_side = (func_unit_cross ? 3 - func_unit_side : func_unit_side);
3224           func_unit_data_side = maybe_data_side;
3225         }
3226
3227       skip_whitespace (p);
3228     }
3229
3230   /* Determine which entries in the opcode table match, and the
3231      associated permitted forms of operands.  */
3232   max_matching_opcodes = 0;
3233   for (opc = opc_list; opc; opc = opc->next)
3234     max_matching_opcodes++;
3235   num_matching_opcodes = 0;
3236   opcm = xmalloc (max_matching_opcodes * sizeof (*opcm));
3237   max_num_operands = 0;
3238   ok_this_arch = FALSE;
3239   ok_this_fu = FALSE;
3240   ok_this_arch_fu = FALSE;
3241   for (opc = opc_list; opc; opc = opc->next)
3242     {
3243       unsigned int num_operands;
3244       unsigned int i;
3245       bfd_boolean this_opc_arch_ok = TRUE;
3246       bfd_boolean this_opc_fu_ok = TRUE;
3247
3248       if (tic6x_insn_format_table[tic6x_opcode_table[opc->id].format].num_bits
3249           != 32)
3250         continue;
3251       if (!(tic6x_opcode_table[opc->id].isa_variants & tic6x_features))
3252         this_opc_arch_ok = FALSE;
3253       if (tic6x_opcode_table[opc->id].func_unit != func_unit_base)
3254         this_opc_fu_ok = FALSE;
3255       if (func_unit_side == 1
3256           && (tic6x_opcode_table[opc->id].flags & TIC6X_FLAG_SIDE_B_ONLY))
3257         this_opc_fu_ok = FALSE;
3258       if (func_unit_cross
3259           && (tic6x_opcode_table[opc->id].flags & TIC6X_FLAG_NO_CROSS))
3260         this_opc_fu_ok = FALSE;
3261       if (!func_unit_data_side
3262           && (tic6x_opcode_table[opc->id].flags
3263               & (TIC6X_FLAG_LOAD | TIC6X_FLAG_STORE)))
3264         this_opc_fu_ok = FALSE;
3265       if (func_unit_data_side
3266           && !(tic6x_opcode_table[opc->id].flags
3267                & (TIC6X_FLAG_LOAD | TIC6X_FLAG_STORE)))
3268         this_opc_fu_ok = FALSE;
3269       if (func_unit_data_side == 1
3270           && (tic6x_opcode_table[opc->id].flags & TIC6X_FLAG_SIDE_T2_ONLY))
3271         this_opc_fu_ok = FALSE;
3272       if (this_opc_arch_ok)
3273         ok_this_arch = TRUE;
3274       if (this_opc_fu_ok)
3275         ok_this_fu = TRUE;
3276       if (!this_opc_arch_ok || !this_opc_fu_ok)
3277         continue;
3278       ok_this_arch_fu = TRUE;
3279       opcm[num_matching_opcodes] = opc->id;
3280       num_matching_opcodes++;
3281       num_operands = tic6x_opcode_table[opc->id].num_operands;
3282
3283       if (tic6x_opcode_table[opc->id].flags & TIC6X_FLAG_SPMASK)
3284         {
3285           if (num_operands != 1
3286               || (tic6x_opcode_table[opc->id].operand_info[0].form
3287                   != tic6x_operand_func_unit))
3288             abort ();
3289           num_operands = 8;
3290           for (i = 0; i < num_operands; i++)
3291             {
3292               operand_forms[i]
3293                 |= tic6x_coarse_operand_form (tic6x_operand_func_unit);
3294               num_operands_permitted[i] = TRUE;
3295             }
3296         }
3297       else
3298         {
3299           for (i = 0; i < num_operands; i++)
3300             {
3301               tic6x_operand_form f
3302                 = tic6x_opcode_table[opc->id].operand_info[i].form;
3303
3304               operand_forms[i] |= tic6x_coarse_operand_form (f);
3305             }
3306         }
3307       num_operands_permitted[num_operands] = TRUE;
3308       if (num_operands > max_num_operands)
3309         max_num_operands = num_operands;
3310     }
3311
3312   if (!ok_this_arch)
3313     {
3314       as_bad (_("'%.*s' instruction not supported on this architecture"),
3315               opc_len, str);
3316       free (opcm);
3317       return;
3318     }
3319
3320   if (!ok_this_fu)
3321     {
3322       as_bad (_("'%.*s' instruction not supported on this functional unit"),
3323               opc_len, str);
3324       free (opcm);
3325       return;
3326     }
3327
3328   if (!ok_this_arch_fu)
3329     {
3330       as_bad (_("'%.*s' instruction not supported on this functional unit"
3331                 " for this architecture"),
3332               opc_len, str);
3333       free (opcm);
3334       return;
3335     }
3336
3337   /* If there were no instructions matching the above availability
3338      checks, we should now have given an error and returned.  */
3339   if (num_matching_opcodes == 0)
3340     abort ();
3341
3342   num_operands_read = 0;
3343   while (TRUE)
3344     {
3345       skip_whitespace (p);
3346       if (is_end_of_line[(unsigned char) *p])
3347         {
3348           if (num_operands_read > 0)
3349             {
3350               as_bad (_("missing operand after comma"));
3351               bad_operands = TRUE;
3352             }
3353           break;
3354         }
3355
3356       if (max_num_operands == 0)
3357         {
3358           as_bad (_("too many operands to '%.*s'"), opc_len, str);
3359           bad_operands = TRUE;
3360           break;
3361         }
3362
3363       if (!tic6x_parse_operand (&p, &operands[num_operands_read],
3364                                 operand_forms[num_operands_read], str, opc_len,
3365                                 num_operands_read + 1))
3366         bad_operands = TRUE;
3367       num_operands_read++;
3368
3369       if (is_end_of_line[(unsigned char) *p])
3370         break;
3371       else if (*p == ',')
3372         {
3373           p++;
3374           if (num_operands_read == max_num_operands)
3375             {
3376               as_bad (_("too many operands to '%.*s'"), opc_len, str);
3377               bad_operands = TRUE;
3378               break;
3379             }
3380           continue;
3381         }
3382       else
3383         /* Operand parsing should consume whole operands.  */
3384         abort ();
3385     }
3386
3387   if (!bad_operands && !num_operands_permitted[num_operands_read])
3388     {
3389       as_bad (_("bad number of operands to '%.*s'"), opc_len, str);
3390       bad_operands = TRUE;
3391     }
3392
3393   if (!bad_operands)
3394     {
3395       /* Each operand is of the right syntactic form for some opcode
3396          choice, and the number of operands is valid.  Check that each
3397          operand is OK in detail for some opcode choice with the right
3398          number of operands.  */
3399       unsigned int i;
3400
3401       for (i = 0; i < num_operands_read; i++)
3402         {
3403           bfd_boolean coarse_ok = FALSE;
3404           bfd_boolean fine_ok = FALSE;
3405           tic6x_operand_match fine_failure = tic6x_match_matches;
3406           unsigned int j;
3407
3408           for (j = 0; j < num_matching_opcodes; j++)
3409             {
3410               tic6x_operand_form f;
3411               tic6x_rw rw;
3412               unsigned int cf;
3413               tic6x_operand_match this_fine_failure;
3414
3415               if (tic6x_opcode_table[opcm[j]].flags & TIC6X_FLAG_SPMASK)
3416                 {
3417                   f = tic6x_operand_func_unit;
3418                   rw = tic6x_rw_none;
3419                 }
3420               else
3421                 {
3422                   if (tic6x_opcode_table[opcm[j]].num_operands
3423                       != num_operands_read)
3424                     continue;
3425
3426                   f = tic6x_opcode_table[opcm[j]].operand_info[i].form;
3427                   rw = tic6x_opcode_table[opcm[j]].operand_info[i].rw;
3428                 }
3429               cf = tic6x_coarse_operand_form (f);
3430
3431               if (operands[i].form != cf)
3432                 continue;
3433
3434               coarse_ok = TRUE;
3435               this_fine_failure
3436                 = tic6x_operand_matches_form (&operands[i], f, rw,
3437                                               func_unit_side,
3438                                               cross_side,
3439                                               func_unit_data_side);
3440               if (this_fine_failure == tic6x_match_matches)
3441                 {
3442                   fine_ok = TRUE;
3443                   break;
3444                 }
3445               if (fine_failure == tic6x_match_matches
3446                   || fine_failure > this_fine_failure)
3447                 fine_failure = this_fine_failure;
3448             }
3449
3450           /* No instructions should have operand syntactic forms only
3451              acceptable with certain numbers of operands, so no
3452              diagnostic for this case.  */
3453           if (!coarse_ok)
3454             abort ();
3455
3456           if (!fine_ok)
3457             {
3458               switch (fine_failure)
3459                 {
3460                 case tic6x_match_non_const:
3461                   as_bad (_("operand %u of '%.*s' not constant"),
3462                           i + 1, opc_len, str);
3463                   break;
3464
3465                 case tic6x_match_wrong_side:
3466                   as_bad (_("operand %u of '%.*s' on wrong side"),
3467                           i + 1, opc_len, str);
3468                   break;
3469
3470                 case tic6x_match_bad_return:
3471                   as_bad (_("operand %u of '%.*s' not a valid return "
3472                             "address register"),
3473                           i + 1, opc_len, str);
3474                   break;
3475
3476                 case tic6x_match_ctrl_write_only:
3477                   as_bad (_("operand %u of '%.*s' is write-only"),
3478                           i + 1, opc_len, str);
3479                   break;
3480
3481                 case tic6x_match_ctrl_read_only:
3482                   as_bad (_("operand %u of '%.*s' is read-only"),
3483                           i + 1, opc_len, str);
3484                   break;
3485
3486                 case tic6x_match_bad_mem:
3487                   as_bad (_("operand %u of '%.*s' not a valid memory "
3488                             "reference"),
3489                           i + 1, opc_len, str);
3490                   break;
3491
3492                 case tic6x_match_bad_address:
3493                   as_bad (_("operand %u of '%.*s' not a valid base "
3494                             "address register"),
3495                           i + 1, opc_len, str);
3496                   break;
3497
3498                 default:
3499                   abort ();
3500                 }
3501               bad_operands = TRUE;
3502               break;
3503             }
3504         }
3505     }
3506
3507   if (!bad_operands)
3508     {
3509       /* Each operand is OK for some opcode choice, and the number of
3510          operands is valid.  Check whether there is an opcode choice
3511          for which all operands are simultaneously valid.  */
3512       unsigned int i;
3513       bfd_boolean found_match = FALSE;
3514
3515       for (i = 0; i < TIC6X_NUM_PREFER; i++)
3516         opc_rank[i] = (unsigned int) -1;
3517
3518       min_rank = TIC6X_NUM_PREFER - 1;
3519       max_rank = 0;
3520
3521       for (i = 0; i < num_matching_opcodes; i++)
3522         {
3523           unsigned int j;
3524           bfd_boolean this_matches = TRUE;
3525
3526           if (!(tic6x_opcode_table[opcm[i]].flags & TIC6X_FLAG_SPMASK)
3527               && tic6x_opcode_table[opcm[i]].num_operands != num_operands_read)
3528             continue;
3529
3530           for (j = 0; j < num_operands_read; j++)
3531             {
3532               tic6x_operand_form f;
3533               tic6x_rw rw;
3534
3535               if (tic6x_opcode_table[opcm[i]].flags & TIC6X_FLAG_SPMASK)
3536                 {
3537                   f = tic6x_operand_func_unit;
3538                   rw = tic6x_rw_none;
3539                 }
3540               else
3541                 {
3542                   f = tic6x_opcode_table[opcm[i]].operand_info[j].form;
3543                   rw = tic6x_opcode_table[opcm[i]].operand_info[j].rw;
3544                 }
3545               if (tic6x_operand_matches_form (&operands[j], f, rw,
3546                                               func_unit_side,
3547                                               cross_side,
3548                                               func_unit_data_side)
3549                   != tic6x_match_matches)
3550                 {
3551                   this_matches = FALSE;
3552                   break;
3553                 }
3554             }
3555
3556           if (this_matches)
3557             {
3558               int rank = TIC6X_PREFER_VAL (tic6x_opcode_table[opcm[i]].flags);
3559
3560               if (rank < min_rank)
3561                 min_rank = rank;
3562               if (rank > max_rank)
3563                 max_rank = rank;
3564
3565               if (opc_rank[rank] == (unsigned int) -1)
3566                 opc_rank[rank] = i;
3567               else
3568                 /* The opcode table should provide a total ordering
3569                    for all cases where multiple matches may get
3570                    here.  */
3571                 abort ();
3572
3573               found_match = TRUE;
3574             }
3575         }
3576
3577       if (!found_match)
3578         {
3579           as_bad (_("bad operand combination for '%.*s'"), opc_len, str);
3580           bad_operands = TRUE;
3581         }
3582     }
3583
3584   if (bad_operands)
3585     {
3586       free (opcm);
3587       return;
3588     }
3589
3590   opcode_value = 0;
3591   encoded_ok = FALSE;
3592   for (try_rank = max_rank; try_rank >= min_rank; try_rank--)
3593     {
3594       fix_needed = FALSE;
3595
3596       if (opc_rank[try_rank] == (unsigned int) -1)
3597         continue;
3598
3599       opcode_value = tic6x_try_encode (opcm[opc_rank[try_rank]], operands,
3600                                        num_operands_read, this_line_creg,
3601                                        this_line_z, func_unit_side,
3602                                        func_unit_cross, func_unit_data_side,
3603                                        seginfo->tc_segment_info_data.sploop_ii,
3604                                        &fix_exp, &fix_pcrel, &fx_r_type,
3605                                        &fix_adda, &fix_needed, &encoded_ok,
3606                                        (try_rank == min_rank ? TRUE : FALSE),
3607                                        str, opc_len);
3608       if (encoded_ok)
3609         {
3610           opct = &tic6x_opcode_table[opcm[opc_rank[try_rank]]];
3611           break;
3612         }
3613     }
3614
3615   free (opcm);
3616
3617   if (!encoded_ok)
3618     return;
3619
3620   if (this_line_parallel)
3621     {
3622       insn_frag = seginfo->tc_segment_info_data.execute_packet_frag;
3623       if (insn_frag == NULL)
3624         {
3625           as_bad (_("parallel instruction not following another instruction"));
3626           return;
3627         }
3628
3629       if (insn_frag->fr_fix >= 32)
3630         {
3631           as_bad (_("too many instructions in execute packet"));
3632           return;
3633         }
3634
3635       if (this_insn_label_list != NULL)
3636         as_bad (_("label not at start of execute packet"));
3637
3638       if (opct->flags & TIC6X_FLAG_FIRST)
3639         as_bad (_("'%.*s' instruction not at start of execute packet"),
3640                 opc_len, str);
3641
3642       *seginfo->tc_segment_info_data.last_insn_lsb |= 0x1;
3643       output = insn_frag->fr_literal + insn_frag->fr_fix;
3644     }
3645   else
3646     {
3647       tic6x_label_list *l;
3648
3649       seginfo->tc_segment_info_data.spmask_addr = NULL;
3650       seginfo->tc_segment_info_data.func_units_used = 0;
3651
3652       /* Start a new frag for this execute packet.  */
3653       if (frag_now_fix () != 0)
3654         {
3655           if (frag_now->fr_type != rs_machine_dependent)
3656             frag_wane (frag_now);
3657
3658           frag_new (0);
3659         }
3660       frag_grow (32);
3661       insn_frag = seginfo->tc_segment_info_data.execute_packet_frag = frag_now;
3662       for (l = this_insn_label_list; l; l = l->next)
3663         {
3664           symbol_set_frag (l->label, frag_now);
3665           S_SET_VALUE (l->label, 0);
3666           S_SET_SEGMENT (l->label, now_seg);
3667         }
3668       tic6x_free_label_list (this_insn_label_list);
3669       dwarf2_emit_insn (0);
3670       output = frag_var (rs_machine_dependent, 32, 32, 0, NULL, 0, NULL);
3671       /* This must be the same as the frag to which a pointer was just
3672          saved.  */
3673       if (output != insn_frag->fr_literal)
3674         abort ();
3675       insn_frag->tc_frag_data.is_insns = TRUE;
3676       insn_frag->tc_frag_data.can_cross_fp_boundary
3677         = tic6x_can_cross_fp_boundary;
3678     }
3679
3680   if (func_unit_base != tic6x_func_unit_nfu)
3681     {
3682       unsigned int func_unit_enc;
3683
3684       func_unit_enc = tic6x_encode_spmask (func_unit_base, func_unit_side);
3685
3686       if (seginfo->tc_segment_info_data.func_units_used & func_unit_enc)
3687         as_bad (_("functional unit already used in this execute packet"));
3688
3689       seginfo->tc_segment_info_data.func_units_used |= func_unit_enc;
3690     }
3691
3692   if (opct->flags & TIC6X_FLAG_SPLOOP)
3693     {
3694       if (seginfo->tc_segment_info_data.sploop_ii)
3695         as_bad (_("nested software pipelined loop"));
3696       if (num_operands_read != 1
3697           || operands[0].form != TIC6X_OP_EXP
3698           || operands[0].value.exp.X_op != O_constant)
3699         abort ();
3700       seginfo->tc_segment_info_data.sploop_ii
3701         = operands[0].value.exp.X_add_number;
3702     }
3703   else if (opct->flags & TIC6X_FLAG_SPKERNEL)
3704     {
3705       if (!seginfo->tc_segment_info_data.sploop_ii)
3706         as_bad (_("'%.*s' instruction not in a software pipelined loop"),
3707                 opc_len, str);
3708       seginfo->tc_segment_info_data.sploop_ii = 0;
3709     }
3710
3711   if (this_line_spmask)
3712     {
3713       if (seginfo->tc_segment_info_data.spmask_addr == NULL)
3714         as_bad (_("'||^' without previous SPMASK"));
3715       else if (func_unit_base == tic6x_func_unit_nfu)
3716         as_bad (_("cannot mask instruction using no functional unit"));
3717       else
3718         {
3719           unsigned int spmask_opcode;
3720           unsigned int mask_bit;
3721
3722           spmask_opcode
3723             = md_chars_to_number (seginfo->tc_segment_info_data.spmask_addr,
3724                                   4);
3725           mask_bit = tic6x_encode_spmask (func_unit_base, func_unit_side);
3726           mask_bit <<= 18;
3727           if (spmask_opcode & mask_bit)
3728             as_bad (_("functional unit already masked"));
3729           spmask_opcode |= mask_bit;
3730           md_number_to_chars (seginfo->tc_segment_info_data.spmask_addr,
3731                               spmask_opcode, 4);
3732         }
3733     }
3734
3735   record_alignment (now_seg, 5);
3736   md_number_to_chars (output, opcode_value, 4);
3737   if (fix_needed)
3738     tic6x_fix_new_exp (insn_frag, output - insn_frag->fr_literal, 4, fix_exp,
3739                        fix_pcrel, fx_r_type, fix_adda);
3740   insn_frag->fr_fix += 4;
3741   insn_frag->fr_var -= 4;
3742   seginfo->tc_segment_info_data.last_insn_lsb
3743     = (target_big_endian ? output + 3 : output);
3744   if (opct->flags & TIC6X_FLAG_SPMASK)
3745     seginfo->tc_segment_info_data.spmask_addr = output;
3746 }
3747
3748 /* Modify NEWVAL (32-bit) by inserting VALUE, shifted right by SHIFT
3749    and the least significant BITS bits taken, at position POS.  */
3750 #define MODIFY_VALUE(NEWVAL, VALUE, SHIFT, POS, BITS)                   \
3751   do {                                                                  \
3752     (NEWVAL) &= 0xffffffffU & ~(((1U << (BITS)) - 1) << (POS));         \
3753     (NEWVAL) |= (((VALUE) >> (SHIFT)) & ((1U << (BITS)) - 1)) << (POS); \
3754   } while (0)
3755
3756 /* Apply a fixup to the object file.  */
3757
3758 void
3759 md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED)
3760 {
3761   offsetT value = *valP;
3762   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
3763
3764   value = SEXT (value);
3765   *valP = value;
3766
3767   fixP->fx_offset = SEXT (fixP->fx_offset);
3768
3769   if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
3770     fixP->fx_done = 1;
3771
3772   /* We do our own overflow checks.  */
3773   fixP->fx_no_overflow = 1;
3774
3775   switch (fixP->fx_r_type)
3776     {
3777     case BFD_RELOC_NONE:
3778     case BFD_RELOC_C6000_EHTYPE:
3779       /* Force output to the object file.  */
3780       fixP->fx_done = 0;
3781       break;
3782
3783     case BFD_RELOC_32:
3784       if (fixP->fx_done || !seg->use_rela_p)
3785         md_number_to_chars (buf, value, 4);
3786       break;
3787
3788     case BFD_RELOC_16:
3789       if (fixP->fx_done || !seg->use_rela_p)
3790         {
3791           if (value < -0x8000 || value > 0xffff)
3792             as_bad_where (fixP->fx_file, fixP->fx_line,
3793                           _("value too large for 2-byte field"));
3794           md_number_to_chars (buf, value, 2);
3795         }
3796       break;
3797
3798     case BFD_RELOC_8:
3799       if (fixP->fx_done || !seg->use_rela_p)
3800         {
3801           if (value < -0x80 || value > 0xff)
3802             as_bad_where (fixP->fx_file, fixP->fx_line,
3803                           _("value too large for 1-byte field"));
3804           md_number_to_chars (buf, value, 1);
3805         }
3806       break;
3807
3808     case BFD_RELOC_C6000_ABS_S16:
3809     case BFD_RELOC_C6000_ABS_L16:
3810     case BFD_RELOC_C6000_SBR_S16:
3811     case BFD_RELOC_C6000_SBR_L16_B:
3812     case BFD_RELOC_C6000_SBR_L16_H:
3813     case BFD_RELOC_C6000_SBR_L16_W:
3814     case BFD_RELOC_C6000_SBR_GOT_L16_W:
3815       if (fixP->fx_done || !seg->use_rela_p)
3816         {
3817           offsetT newval = md_chars_to_number (buf, 4);
3818           int shift;
3819
3820           switch (fixP->fx_r_type)
3821             {
3822             case BFD_RELOC_C6000_SBR_L16_H:
3823               shift = 1;
3824               break;
3825
3826             case BFD_RELOC_C6000_SBR_L16_W:
3827             case BFD_RELOC_C6000_SBR_GOT_L16_W:
3828               shift = 2;
3829               break;
3830
3831             default:
3832               shift = 0;
3833               break;
3834             }
3835
3836           MODIFY_VALUE (newval, value, shift, 7, 16);
3837           if ((value < -0x8000 || value > 0x7fff)
3838               && (fixP->fx_r_type == BFD_RELOC_C6000_ABS_S16
3839                   || fixP->fx_r_type == BFD_RELOC_C6000_SBR_S16))
3840             as_bad_where (fixP->fx_file, fixP->fx_line,
3841                           _("immediate offset out of range"));
3842
3843           md_number_to_chars (buf, newval, 4);
3844         }
3845       if (fixP->fx_done
3846           && fixP->fx_r_type != BFD_RELOC_C6000_ABS_S16
3847           && fixP->fx_r_type != BFD_RELOC_C6000_ABS_L16)
3848         abort ();
3849       break;
3850
3851     case BFD_RELOC_C6000_ABS_H16:
3852     case BFD_RELOC_C6000_SBR_H16_B:
3853     case BFD_RELOC_C6000_SBR_H16_H:
3854     case BFD_RELOC_C6000_SBR_H16_W:
3855     case BFD_RELOC_C6000_SBR_GOT_H16_W:
3856       if (fixP->fx_done || !seg->use_rela_p)
3857         {
3858           offsetT newval = md_chars_to_number (buf, 4);
3859           int shift;
3860
3861           switch (fixP->fx_r_type)
3862             {
3863             case BFD_RELOC_C6000_SBR_H16_H:
3864               shift = 17;
3865               break;
3866
3867             case BFD_RELOC_C6000_SBR_H16_W:
3868             case BFD_RELOC_C6000_SBR_GOT_H16_W:
3869               shift = 18;
3870               break;
3871
3872             default:
3873               shift = 16;
3874               break;
3875             }
3876
3877           MODIFY_VALUE (newval, value, shift, 7, 16);
3878
3879           md_number_to_chars (buf, newval, 4);
3880         }
3881       if (fixP->fx_done && fixP->fx_r_type != BFD_RELOC_C6000_ABS_H16)
3882         abort ();
3883       break;
3884
3885     case BFD_RELOC_C6000_PCR_H16:
3886     case BFD_RELOC_C6000_PCR_L16:
3887       if (fixP->fx_done || !seg->use_rela_p)
3888         {
3889           offsetT newval = md_chars_to_number (buf, 4);
3890           int shift = fixP->fx_r_type == BFD_RELOC_C6000_PCR_H16 ? 16 : 0;
3891
3892           MODIFY_VALUE (newval, value, shift, 7, 16);
3893
3894           md_number_to_chars (buf, newval, 4);
3895         }
3896       break;
3897
3898     case BFD_RELOC_C6000_SBR_U15_B:
3899       if (fixP->fx_done || !seg->use_rela_p)
3900         {
3901           offsetT newval = md_chars_to_number (buf, 4);
3902
3903           MODIFY_VALUE (newval, value, 0, 8, 15);
3904           if (value < 0 || value > 0x7fff)
3905             as_bad_where (fixP->fx_file, fixP->fx_line,
3906                           _("immediate offset out of range"));
3907
3908           md_number_to_chars (buf, newval, 4);
3909         }
3910       break;
3911
3912     case BFD_RELOC_C6000_SBR_U15_H:
3913       if (fixP->fx_done || !seg->use_rela_p)
3914         {
3915           offsetT newval = md_chars_to_number (buf, 4);
3916
3917           /* Constant ADDA operands, processed as constant when the
3918              instruction is parsed, are encoded as-is rather than
3919              shifted.  If the operand of an ADDA instruction is now
3920              constant (for example, the difference between two labels
3921              found after the instruction), ensure it is encoded the
3922              same way it would have been if the constant value had
3923              been known when the instruction was parsed.  */
3924           if (fixP->tc_fix_data.fix_adda && fixP->fx_done)
3925             value <<= 1;
3926
3927           MODIFY_VALUE (newval, value, 1, 8, 15);
3928           if (value & 1)
3929             as_bad_where (fixP->fx_file, fixP->fx_line,
3930                           _("immediate offset not 2-byte-aligned"));
3931           if (value < 0 || value > 0xfffe)
3932             as_bad_where (fixP->fx_file, fixP->fx_line,
3933                           _("immediate offset out of range"));
3934
3935           md_number_to_chars (buf, newval, 4);
3936         }
3937       break;
3938
3939     case BFD_RELOC_C6000_SBR_U15_W:
3940     case BFD_RELOC_C6000_SBR_GOT_U15_W:
3941       if (fixP->fx_done || !seg->use_rela_p)
3942         {
3943           offsetT newval = md_chars_to_number (buf, 4);
3944
3945           /* Constant ADDA operands, processed as constant when the
3946              instruction is parsed, are encoded as-is rather than
3947              shifted.  If the operand of an ADDA instruction is now
3948              constant (for example, the difference between two labels
3949              found after the instruction), ensure it is encoded the
3950              same way it would have been if the constant value had
3951              been known when the instruction was parsed.  */
3952           if (fixP->tc_fix_data.fix_adda && fixP->fx_done)
3953             value <<= 2;
3954
3955           MODIFY_VALUE (newval, value, 2, 8, 15);
3956           if (value & 3)
3957             as_bad_where (fixP->fx_file, fixP->fx_line,
3958                           _("immediate offset not 4-byte-aligned"));
3959           if (value < 0 || value > 0x1fffc)
3960             as_bad_where (fixP->fx_file, fixP->fx_line,
3961                           _("immediate offset out of range"));
3962
3963           md_number_to_chars (buf, newval, 4);
3964         }
3965       if (fixP->fx_done && fixP->fx_r_type != BFD_RELOC_C6000_SBR_U15_W)
3966         abort ();
3967       break;
3968
3969     case BFD_RELOC_C6000_DSBT_INDEX:
3970       if (value != 0)
3971         as_bad_where (fixP->fx_file, fixP->fx_line,
3972                       _("addend used with $DSBT_INDEX"));
3973       if (fixP->fx_done)
3974         abort ();
3975       break;
3976
3977     case BFD_RELOC_C6000_PCR_S21:
3978       if (fixP->fx_done || !seg->use_rela_p)
3979         {
3980           offsetT newval = md_chars_to_number (buf, 4);
3981
3982           MODIFY_VALUE (newval, value, 2, 7, 21);
3983
3984           if (value & 3)
3985             as_bad_where (fixP->fx_file, fixP->fx_line,
3986                           _("PC-relative offset not 4-byte-aligned"));
3987           if (value < -0x400000 || value > 0x3ffffc)
3988             as_bad_where (fixP->fx_file, fixP->fx_line,
3989                           _("PC-relative offset out of range"));
3990
3991           md_number_to_chars (buf, newval, 4);
3992         }
3993       break;
3994
3995     case BFD_RELOC_C6000_PCR_S12:
3996       if (fixP->fx_done || !seg->use_rela_p)
3997         {
3998           offsetT newval = md_chars_to_number (buf, 4);
3999
4000           MODIFY_VALUE (newval, value, 2, 16, 12);
4001
4002           if (value & 3)
4003             as_bad_where (fixP->fx_file, fixP->fx_line,
4004                           _("PC-relative offset not 4-byte-aligned"));
4005           if (value < -0x2000 || value > 0x1ffc)
4006             as_bad_where (fixP->fx_file, fixP->fx_line,
4007                           _("PC-relative offset out of range"));
4008
4009           md_number_to_chars (buf, newval, 4);
4010         }
4011       break;
4012
4013     case BFD_RELOC_C6000_PCR_S10:
4014       if (fixP->fx_done || !seg->use_rela_p)
4015         {
4016           offsetT newval = md_chars_to_number (buf, 4);
4017
4018           MODIFY_VALUE (newval, value, 2, 13, 10);
4019
4020           if (value & 3)
4021             as_bad_where (fixP->fx_file, fixP->fx_line,
4022                           _("PC-relative offset not 4-byte-aligned"));
4023           if (value < -0x800 || value > 0x7fc)
4024             as_bad_where (fixP->fx_file, fixP->fx_line,
4025                           _("PC-relative offset out of range"));
4026
4027           md_number_to_chars (buf, newval, 4);
4028         }
4029       break;
4030
4031     case BFD_RELOC_C6000_PCR_S7:
4032       if (fixP->fx_done || !seg->use_rela_p)
4033         {
4034           offsetT newval = md_chars_to_number (buf, 4);
4035
4036           MODIFY_VALUE (newval, value, 2, 16, 7);
4037
4038           if (value & 3)
4039             as_bad_where (fixP->fx_file, fixP->fx_line,
4040                           _("PC-relative offset not 4-byte-aligned"));
4041           if (value < -0x100 || value > 0xfc)
4042             as_bad_where (fixP->fx_file, fixP->fx_line,
4043                           _("PC-relative offset out of range"));
4044
4045           md_number_to_chars (buf, newval, 4);
4046         }
4047       break;
4048
4049     case BFD_RELOC_C6000_PREL31:
4050       /* Force output to the object file.  */
4051       fixP->fx_done = 0;
4052       break;
4053
4054     default:
4055       abort ();
4056     }
4057 }
4058
4059 /* Convert a floating-point number to target (IEEE) format.  */
4060
4061 char *
4062 md_atof (int type, char *litP, int *sizeP)
4063 {
4064   return ieee_md_atof (type, litP, sizeP, target_big_endian);
4065 }
4066
4067 /* Adjust the frags in SECTION (see tic6x_end).  */
4068
4069 static void
4070 tic6x_adjust_section (bfd *abfd ATTRIBUTE_UNUSED, segT section,
4071                       void *dummy ATTRIBUTE_UNUSED)
4072 {
4073   segment_info_type *info;
4074   frchainS *frchp;
4075   fragS *fragp;
4076   bfd_boolean have_code = FALSE;
4077   bfd_boolean have_non_code = FALSE;
4078
4079   info = seg_info (section);
4080   if (info == NULL)
4081     return;
4082
4083   for (frchp = info->frchainP; frchp; frchp = frchp->frch_next)
4084     for (fragp = frchp->frch_root; fragp; fragp = fragp->fr_next)
4085       switch (fragp->fr_type)
4086         {
4087         case rs_machine_dependent:
4088           if (fragp->tc_frag_data.is_insns)
4089             have_code = TRUE;
4090           break;
4091
4092         case rs_dummy:
4093         case rs_fill:
4094           if (fragp->fr_fix > 0)
4095             have_non_code = TRUE;
4096           break;
4097
4098         default:
4099           have_non_code = TRUE;
4100           break;
4101         }
4102
4103   /* Process alignment requirements in a code-only section.  */
4104   if (have_code && !have_non_code)
4105     {
4106       /* If we need to insert an odd number of instructions to meet an
4107          alignment requirement, there must have been an odd number of
4108          instructions since the last 8-byte-aligned execute packet
4109          boundary.  So there must have been an execute packet with an
4110          odd number (and so a number fewer than 8) of instructions
4111          into which we can insert a NOP without breaking any previous
4112          alignments.
4113
4114          If then we need to insert a number 2 mod 4 of instructions,
4115          the number of instructions since the last 16-byte-aligned
4116          execute packet boundary must be 2 mod 4.  So between that
4117          boundary and the following 8-byte-aligned boundary there must
4118          either be at least one execute packet with 2-mod-4
4119          instructions, or at least two with an odd number of
4120          instructions; again, greedily inserting NOPs as soon as
4121          possible suffices to meet the alignment requirement.
4122
4123          If then we need to insert 4 instructions, we look between the
4124          last 32-byte-aligned boundary and the following
4125          16-byte-aligned boundary.  The sizes of the execute packets
4126          in this range total 4 instructions mod 8, so again there is
4127          room for greedy insertion of NOPs to meet the alignment
4128          requirement, and before any intermediate point with 8-byte
4129          (2-instruction) alignment requirement the sizes of execute
4130          packets (and so the room for NOPs) will total 2 instructions
4131          mod 4 so greedy insertion will not break such alignments.
4132
4133          So we can always meet these alignment requirements by
4134          inserting NOPs in parallel with existing execute packets, and
4135          by induction the approach described above inserts the minimum
4136          number of such NOPs.  */
4137
4138       /* The number of NOPs we are currently looking to insert, if we
4139          have gone back to insert NOPs.  */
4140       unsigned int want_insert = 0;
4141
4142       /* Out of that number, the number inserted so far in the current
4143          stage of the above algorithm.  */
4144       unsigned int want_insert_done_so_far = 0;
4145
4146       /* The position mod 32 at the start of the current frag.  */
4147       unsigned int pos = 0;
4148
4149       /* The locations in the frag chain of the most recent frags at
4150          the start of which there is the given alignment.  */
4151       frchainS *frchp_last32, *frchp_last16, *frchp_last8;
4152       fragS *fragp_last32, *fragp_last16, *fragp_last8;
4153       unsigned int pos_last32, pos_last16, pos_last8;
4154
4155       frchp_last32 = frchp_last16 = frchp_last8 = info->frchainP;
4156       fragp_last32 = fragp_last16 = fragp_last8 = info->frchainP->frch_root;
4157       pos_last32 = pos_last16 = pos_last8 = 0;
4158
4159       for (frchp = info->frchainP; frchp; frchp = frchp->frch_next)
4160         for (fragp = frchp->frch_root; fragp; fragp = fragp->fr_next)
4161         look_at_frag:
4162           {
4163             bfd_boolean go_back = FALSE;
4164             frchainS *frchp_next;
4165             fragS *fragp_next;
4166
4167             if (fragp->fr_type != rs_machine_dependent)
4168               continue;
4169
4170             if (fragp->tc_frag_data.is_insns
4171                 && pos + fragp->fr_fix > 32
4172                 && !fragp->tc_frag_data.can_cross_fp_boundary)
4173               {
4174                 /* As described above, we should always have met an
4175                    alignment requirement by the time we come back to
4176                    it.  */
4177                 if (want_insert)
4178                   abort ();
4179
4180                 if (pos & 3)
4181                   abort ();
4182                 want_insert = (32 - pos) >> 2;
4183                 if (want_insert > 7)
4184                   abort ();
4185                 want_insert_done_so_far = 0;
4186                 go_back = TRUE;
4187               }
4188
4189             if (!fragp->tc_frag_data.is_insns)
4190               {
4191                 unsigned int would_insert_bytes;
4192
4193                 if (!(pos & ((1 << fragp->fr_offset) - 1)))
4194                   /* This alignment requirement is already met.  */
4195                   continue;
4196
4197                 /* As described above, we should always have met an
4198                    alignment requirement by the time we come back to
4199                    it.  */
4200                 if (want_insert)
4201                   abort ();
4202
4203                 /* We may not be able to meet this requirement within
4204                    the given number of characters.  */
4205                 would_insert_bytes
4206                   = ((1 << fragp->fr_offset)
4207                      - (pos & ((1 << fragp->fr_offset) - 1)));
4208
4209                 if (fragp->fr_subtype != 0
4210                     && would_insert_bytes > fragp->fr_subtype)
4211                   continue;
4212
4213                 /* An unmet alignment must be 8, 16 or 32 bytes;
4214                    smaller ones must always be met within code-only
4215                    sections and larger ones cause the section not to
4216                    be code-only.  */
4217                 if (fragp->fr_offset != 3
4218                     && fragp->fr_offset != 4
4219                     && fragp->fr_offset != 5)
4220                   abort ();
4221
4222                 if (would_insert_bytes & 3)
4223                   abort ();
4224                 want_insert = would_insert_bytes >> 2;
4225                 if (want_insert > 7)
4226                   abort ();
4227                 want_insert_done_so_far = 0;
4228                 go_back = TRUE;
4229               }
4230             else if (want_insert && !go_back)
4231               {
4232                 unsigned int num_insns = fragp->fr_fix >> 2;
4233                 unsigned int max_poss_nops = 8 - num_insns;
4234
4235                 if (max_poss_nops)
4236                   {
4237                     unsigned int cur_want_nops, max_want_nops, do_nops, i;
4238
4239                     if (want_insert & 1)
4240                       cur_want_nops = 1;
4241                     else if (want_insert & 2)
4242                       cur_want_nops = 2;
4243                     else if (want_insert & 4)
4244                       cur_want_nops = 4;
4245                     else
4246                       abort ();
4247
4248                     max_want_nops = cur_want_nops - want_insert_done_so_far;
4249
4250                     do_nops = (max_poss_nops < max_want_nops
4251                                ? max_poss_nops
4252                                : max_want_nops);
4253                     for (i = 0; i < do_nops; i++)
4254                       {
4255                         md_number_to_chars (fragp->fr_literal + fragp->fr_fix,
4256                                             0, 4);
4257                         if (target_big_endian)
4258                           fragp->fr_literal[fragp->fr_fix - 1] |= 0x1;
4259                         else
4260                           fragp->fr_literal[fragp->fr_fix - 4] |= 0x1;
4261                         fragp->fr_fix += 4;
4262                         fragp->fr_var -= 4;
4263                       }
4264                     want_insert_done_so_far += do_nops;
4265                     if (want_insert_done_so_far == cur_want_nops)
4266                       {
4267                         want_insert -= want_insert_done_so_far;
4268                         want_insert_done_so_far = 0;
4269                         if (want_insert)
4270                           go_back = TRUE;
4271                       }
4272                   }
4273               }
4274             if (go_back)
4275               {
4276                 if (want_insert & 1)
4277                   {
4278                     frchp = frchp_last8;
4279                     fragp = fragp_last8;
4280                     pos = pos_last8;
4281                   }
4282                 else if (want_insert & 2)
4283                   {
4284                     frchp = frchp_last8 = frchp_last16;
4285                     fragp = fragp_last8 = fragp_last16;
4286                     pos = pos_last8 = pos_last16;
4287                   }
4288                 else if (want_insert & 4)
4289                   {
4290                     frchp = frchp_last8 = frchp_last16 = frchp_last32;
4291                     fragp = fragp_last8 = fragp_last16 = fragp_last32;
4292                     pos = pos_last8 = pos_last16 = pos_last32;
4293                   }
4294                 else
4295                   abort ();
4296
4297                 goto look_at_frag;
4298               }
4299
4300             /* Update current position for moving past a code
4301                frag.  */
4302             pos += fragp->fr_fix;
4303             pos &= 31;
4304             frchp_next = frchp;
4305             fragp_next = fragp->fr_next;
4306             if (fragp_next == NULL)
4307               {
4308                 frchp_next = frchp->frch_next;
4309                 if (frchp_next != NULL)
4310                   fragp_next = frchp_next->frch_root;
4311               }
4312             if (!(pos & 7))
4313               {
4314                 frchp_last8 = frchp_next;
4315                 fragp_last8 = fragp_next;
4316                 pos_last8 = pos;
4317               }
4318             if (!(pos & 15))
4319               {
4320                 frchp_last16 = frchp_next;
4321                 fragp_last16 = fragp_next;
4322                 pos_last16 = pos;
4323               }
4324             if (!(pos & 31))
4325               {
4326                 frchp_last32 = frchp_next;
4327                 fragp_last32 = fragp_next;
4328                 pos_last32 = pos;
4329               }
4330           }
4331     }
4332
4333   /* Now convert the machine-dependent frags to machine-independent
4334      ones.  */
4335   for (frchp = info->frchainP; frchp; frchp = frchp->frch_next)
4336     for (fragp = frchp->frch_root; fragp; fragp = fragp->fr_next)
4337       {
4338         if (fragp->fr_type == rs_machine_dependent)
4339           {
4340             if (fragp->tc_frag_data.is_insns)
4341               frag_wane (fragp);
4342             else
4343               {
4344                 fragp->fr_type = rs_align_code;
4345                 fragp->fr_var = 1;
4346                 *fragp->fr_literal = 0;
4347               }
4348           }
4349       }
4350 }
4351
4352 /* Initialize the machine-dependent parts of a frag.  */
4353
4354 void
4355 tic6x_frag_init (fragS *fragp)
4356 {
4357   fragp->tc_frag_data.is_insns = FALSE;
4358   fragp->tc_frag_data.can_cross_fp_boundary = FALSE;
4359 }
4360
4361 /* Set an attribute if it has not already been set by the user.  */
4362
4363 static void
4364 tic6x_set_attribute_int (int tag, int value)
4365 {
4366   if (tag < 1
4367       || tag >= NUM_KNOWN_OBJ_ATTRIBUTES)
4368     abort ();
4369   if (!tic6x_attributes_set_explicitly[tag])
4370     bfd_elf_add_proc_attr_int (stdoutput, tag, value);
4371 }
4372
4373 /* Set object attributes deduced from the input file and command line
4374    rather than given explicitly.  */
4375 static void
4376 tic6x_set_attributes (void)
4377 {
4378   if (tic6x_arch_attribute == C6XABI_Tag_ISA_none)
4379     tic6x_arch_attribute = C6XABI_Tag_ISA_C674X;
4380
4381   tic6x_set_attribute_int (Tag_ISA, tic6x_arch_attribute);
4382   tic6x_set_attribute_int (Tag_ABI_DSBT, tic6x_dsbt);
4383   tic6x_set_attribute_int (Tag_ABI_PID, tic6x_pid);
4384   tic6x_set_attribute_int (Tag_ABI_PIC, tic6x_pic);
4385 }
4386
4387 /* Do machine-dependent manipulations of the frag chains after all
4388    input has been read and before the machine-independent sizing and
4389    relaxing.  */
4390
4391 void
4392 tic6x_end (void)
4393 {
4394   /* Set object attributes at this point if not explicitly set.  */
4395   tic6x_set_attributes ();
4396
4397   /* Meeting alignment requirements may require inserting NOPs in
4398      parallel in execute packets earlier in the segment.  Future
4399      16-bit instruction generation involves whole-segment optimization
4400      to determine the best choice and ordering of 32-bit or 16-bit
4401      instructions.  This doesn't fit will in the general relaxation
4402      framework, so handle alignment and 16-bit instruction generation
4403      here.  */
4404   bfd_map_over_sections (stdoutput, tic6x_adjust_section, NULL);
4405 }
4406
4407 /* No machine-dependent frags at this stage; all converted in
4408    tic6x_end.  */
4409
4410 void
4411 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, segT asec ATTRIBUTE_UNUSED,
4412                  fragS *fragp ATTRIBUTE_UNUSED)
4413 {
4414   abort ();
4415 }
4416
4417 /* No machine-dependent frags at this stage; all converted in
4418    tic6x_end.  */
4419
4420 int
4421 md_estimate_size_before_relax (fragS *fragp ATTRIBUTE_UNUSED,
4422                                segT seg ATTRIBUTE_UNUSED)
4423 {
4424   abort ();
4425 }
4426
4427 /* Put a number into target byte order.  */
4428
4429 void
4430 md_number_to_chars (char *buf, valueT val, int n)
4431 {
4432   if (target_big_endian)
4433     number_to_chars_bigendian (buf, val, n);
4434   else
4435     number_to_chars_littleendian (buf, val, n);
4436 }
4437
4438 /* Machine-dependent operand parsing not currently needed.  */
4439
4440 void
4441 md_operand (expressionS *op ATTRIBUTE_UNUSED)
4442 {
4443 }
4444
4445 /* PC-relative operands are relative to the start of the fetch
4446    packet.  */
4447
4448 long
4449 tic6x_pcrel_from_section (fixS *fixp, segT sec)
4450 {
4451   if (fixp->fx_addsy != NULL
4452       && (!S_IS_DEFINED (fixp->fx_addsy)
4453           || S_GET_SEGMENT (fixp->fx_addsy) != sec))
4454     return 0;
4455   return (fixp->fx_where + fixp->fx_frag->fr_address) & ~(long) 0x1f;
4456 }
4457
4458 /* Round up a section size to the appropriate boundary.  */
4459
4460 valueT
4461 md_section_align (segT segment ATTRIBUTE_UNUSED,
4462                   valueT size)
4463 {
4464   /* Round up section sizes to ensure that text sections consist of
4465      whole fetch packets.  */
4466   int align = bfd_get_section_alignment (stdoutput, segment);
4467   return ((size + (1 << align) - 1) & ((valueT) -1 << align));
4468 }
4469
4470 /* No special undefined symbol handling needed for now.  */
4471
4472 symbolS *
4473 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
4474 {
4475   return NULL;
4476 }
4477
4478 /* Translate internal representation of relocation info to BFD target
4479    format.  */
4480
4481 arelent *
4482 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
4483 {
4484   arelent *reloc;
4485   asymbol *symbol;
4486   bfd_reloc_code_real_type r_type;
4487
4488   reloc = xmalloc (sizeof (arelent));
4489   reloc->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
4490   symbol = symbol_get_bfdsym (fixp->fx_addsy);
4491   *reloc->sym_ptr_ptr = symbol;
4492   reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
4493   reloc->addend = (tic6x_generate_rela ? fixp->fx_offset : 0);
4494   r_type = fixp->fx_r_type;
4495   reloc->howto = bfd_reloc_type_lookup (stdoutput, r_type);
4496
4497   if (reloc->howto == NULL)
4498     {
4499       as_bad_where (fixp->fx_file, fixp->fx_line,
4500                     _("Cannot represent relocation type %s"),
4501                     bfd_get_reloc_code_name (r_type));
4502       return NULL;
4503     }
4504
4505   /* Correct for adjustments bfd_install_relocation will make.  */
4506   if (reloc->howto->pcrel_offset && reloc->howto->partial_inplace)
4507     {
4508       reloc->addend += reloc->address;
4509       if (!bfd_is_com_section (symbol))
4510         reloc->addend -= symbol->value;
4511     }
4512   if (r_type == BFD_RELOC_C6000_PCR_H16
4513       || r_type == BFD_RELOC_C6000_PCR_L16)
4514     {
4515       symbolS *t = fixp->tc_fix_data.fix_subsy;
4516       segT sub_symbol_segment;
4517
4518       resolve_symbol_value (t);
4519       sub_symbol_segment = S_GET_SEGMENT (t);
4520       if (sub_symbol_segment == undefined_section)
4521         as_bad_where (fixp->fx_file, fixp->fx_line,
4522                       _("undefined symbol %s in PCR relocation"),
4523                       S_GET_NAME (t));
4524       else
4525         {
4526           reloc->addend = reloc->address & ~0x1F;
4527           reloc->addend -= S_GET_VALUE (t);
4528         }
4529     }
4530   return reloc;
4531 }
4532
4533 /* Convert REGNAME to a DWARF-2 register number.  */
4534
4535 int
4536 tic6x_regname_to_dw2regnum (char *regname)
4537 {
4538   bfd_boolean reg_ok;
4539   tic6x_register reg;
4540   char *rq = regname;
4541
4542   reg_ok = tic6x_parse_register (&rq, &reg);
4543
4544   if (!reg_ok)
4545     return -1;
4546
4547   switch (reg.side)
4548     {
4549     case 1: /* A regs.  */
4550       if (reg.num < 16)
4551         return reg.num;
4552       else if (reg.num < 32)
4553         return (reg.num - 16) + 37;
4554       else
4555         return -1;
4556
4557     case 2: /* B regs.  */
4558       if (reg.num < 16)
4559         return reg.num + 16;
4560       else if (reg.num < 32)
4561         return (reg.num - 16) + 53;
4562       else
4563         return -1;
4564
4565     default:
4566       return -1;
4567     }
4568 }
4569
4570 /* Initialize the DWARF-2 unwind information for this procedure.  */
4571
4572 void
4573 tic6x_frame_initial_instructions (void)
4574 {
4575   /* CFA is initial stack pointer (B15).  */
4576   cfi_add_CFA_def_cfa (31, 0);
4577 }
4578
4579 /* Start an exception table entry.  If idx is nonzero this is an index table
4580    entry.  */
4581
4582 static void
4583 tic6x_start_unwind_section (const segT text_seg, int idx)
4584 {
4585   tic6x_unwind_info *unwind = tic6x_get_unwind ();
4586   const char * text_name;
4587   const char * prefix;
4588   const char * prefix_once;
4589   const char * group_name;
4590   size_t prefix_len;
4591   size_t text_len;
4592   char * sec_name;
4593   size_t sec_name_len;
4594   int type;
4595   int flags;
4596   int linkonce;
4597
4598   if (idx)
4599     {
4600       prefix = ELF_STRING_C6000_unwind;
4601       prefix_once = ELF_STRING_C6000_unwind_once;
4602       type = SHT_C6000_UNWIND;
4603     }
4604   else
4605     {
4606       prefix = ELF_STRING_C6000_unwind_info;
4607       prefix_once = ELF_STRING_C6000_unwind_info_once;
4608       type = SHT_PROGBITS;
4609     }
4610
4611   text_name = segment_name (text_seg);
4612   if (streq (text_name, ".text"))
4613     text_name = "";
4614
4615   if (strncmp (text_name, ".gnu.linkonce.t.",
4616                strlen (".gnu.linkonce.t.")) == 0)
4617     {
4618       prefix = prefix_once;
4619       text_name += strlen (".gnu.linkonce.t.");
4620     }
4621
4622   prefix_len = strlen (prefix);
4623   text_len = strlen (text_name);
4624   sec_name_len = prefix_len + text_len;
4625   sec_name = (char *) xmalloc (sec_name_len + 1);
4626   memcpy (sec_name, prefix, prefix_len);
4627   memcpy (sec_name + prefix_len, text_name, text_len);
4628   sec_name[prefix_len + text_len] = '\0';
4629
4630   flags = SHF_ALLOC;
4631   linkonce = 0;
4632   group_name = 0;
4633
4634   /* Handle COMDAT group.  */
4635   if (prefix != prefix_once && (text_seg->flags & SEC_LINK_ONCE) != 0)
4636     {
4637       group_name = elf_group_name (text_seg);
4638       if (group_name == NULL)
4639         {
4640           as_bad (_("group section `%s' has no group signature"),
4641                   segment_name (text_seg));
4642           ignore_rest_of_line ();
4643           return;
4644         }
4645       flags |= SHF_GROUP;
4646       linkonce = 1;
4647     }
4648
4649   obj_elf_change_section (sec_name, type, flags, 0, group_name, linkonce, 0);
4650
4651   /* Set the section link for index tables.  */
4652   if (idx)
4653     elf_linked_to_section (now_seg) = text_seg;
4654
4655   seg_info (now_seg)->tc_segment_info_data.text_unwind = unwind;
4656 }
4657
4658
4659 static const int
4660 tic6x_unwind_frame_regs[TIC6X_NUM_UNWIND_REGS] =
4661 /* A15 B15 B14 B13 B12 B11 B10  B3 A14 A13 A12 A11 A10.  */
4662   { 15, 31, 30, 29, 28, 27, 26, 19, 14, 13, 12, 11, 10 };
4663
4664 /* Register save offsets for __c6xabi_push_rts.  */
4665 static const int
4666 tic6x_pop_rts_offset_little[TIC6X_NUM_UNWIND_REGS] =
4667 /* A15 B15 B14 B13 B12 B11 B10  B3 A14 A13 A12 A11 A10.  */
4668   { -1,  1,  0, -3, -4, -7, -8,-11, -2, -5, -6, -9,-10};
4669
4670 static const int
4671 tic6x_pop_rts_offset_big[TIC6X_NUM_UNWIND_REGS] =
4672 /* A15 B15 B14 B13 B12 B11 B10  B3 A14 A13 A12 A11 A10.  */
4673   { -2,  1,  0, -4, -3, -8, -7,-12, -1, -6, -5,-10, -9};
4674
4675 /* Map from dwarf register number to unwind frame register number.  */
4676 static int
4677 tic6x_unwind_reg_from_dwarf (int dwarf)
4678 {
4679   int reg;
4680
4681   for (reg = 0; reg < TIC6X_NUM_UNWIND_REGS; reg++)
4682     {
4683       if (tic6x_unwind_frame_regs[reg] == dwarf)
4684         return reg;
4685     }
4686
4687   return -1;
4688 }
4689
4690 /* Unwinding bytecode definitions.  */
4691 #define UNWIND_OP_ADD_SP  0x00
4692 #define UNWIND_OP_ADD_SP2 0xd2
4693 #define UNWIND_OP2_POP 0x8000
4694 #define UNWIND_OP2_POP_COMPACT 0xa000
4695 #define UNWIND_OP_POP_REG 0xc0
4696 #define UNWIND_OP_MV_FP 0xd0
4697 #define UNWIND_OP_POP_RTS 0xd1
4698 #define UNWIND_OP_RET 0xe0
4699
4700 /* Maximum stack adjustment for __c6xabi_unwind_cpp_pr3/4 */
4701 #define MAX_COMPACT_SP_OFFSET (0x7f << 3)
4702
4703 static void
4704 tic6x_flush_unwind_word (valueT data)
4705 {
4706   tic6x_unwind_info *unwind = tic6x_get_unwind ();
4707   char *ptr;
4708
4709   /* Create EXTAB entry if it does not exist.  */
4710   if (unwind->table_entry == NULL)
4711     {
4712       tic6x_start_unwind_section (unwind->saved_seg, 0);
4713       frag_align (2, 0, 0);
4714       record_alignment (now_seg, 2);
4715       unwind->table_entry = expr_build_dot ();
4716       ptr = frag_more (4);
4717       unwind->frag_start = ptr;
4718     }
4719   else
4720     {
4721       /* Append additional word of data.  */
4722       ptr = frag_more (4);
4723     }
4724
4725   md_number_to_chars (ptr, data, 4);
4726 }
4727
4728 /* Add a single byte of unwinding data.  */
4729
4730 static void
4731 tic6x_unwind_byte (int byte)
4732 {
4733   tic6x_unwind_info *unwind = tic6x_get_unwind ();
4734
4735   unwind->data_bytes++;
4736   /* Only flush the first word after we know multiple words are required.  */
4737   if (unwind->data_bytes == 5)
4738     {
4739       if (unwind->personality_index == -1)
4740         {
4741           /* At this point we know we are too big for pr0.  */
4742           unwind->personality_index = 1;
4743           tic6x_flush_unwind_word (0x81000000 | ((unwind->data >> 8) & 0xffff));
4744           unwind->data = ((unwind->data & 0xff) << 8) | byte;
4745           unwind->data_bytes++;
4746         }
4747       else
4748         {
4749           tic6x_flush_unwind_word (unwind->data);
4750           unwind->data = byte;
4751         }
4752     }
4753   else
4754     {
4755       unwind->data = (unwind->data << 8) | byte;
4756       if ((unwind->data_bytes & 3) == 0 && unwind->data_bytes > 4)
4757         {
4758           tic6x_flush_unwind_word (unwind->data);
4759           unwind->data = 0;
4760         }
4761     }
4762 }
4763
4764 /* Add a two-byte unwinding opcode.  */
4765 static void
4766 tic6x_unwind_2byte (int bytes)
4767 {
4768   tic6x_unwind_byte (bytes >> 8);
4769   tic6x_unwind_byte (bytes & 0xff);
4770 }
4771
4772 static void
4773 tic6x_unwind_uleb (offsetT offset)
4774 {
4775   while (offset > 0x7f)
4776     {
4777       tic6x_unwind_byte ((offset & 0x7f) | 0x80);
4778       offset >>= 7;
4779     }
4780   tic6x_unwind_byte (offset);
4781 }
4782
4783 void
4784 tic6x_cfi_startproc (void)
4785 {
4786   tic6x_unwind_info *unwind = tic6x_get_unwind ();
4787
4788   unwind->personality_index = -1;
4789   unwind->personality_routine = NULL;
4790   if (unwind->table_entry)
4791     as_bad (_("missing .endp before .cfi_startproc"));
4792
4793   unwind->table_entry = NULL;
4794   unwind->data_bytes = -1;
4795 }
4796
4797 static void
4798 tic6x_output_exidx_entry (void)
4799 {
4800   char *ptr;
4801   long where;
4802   unsigned int marked_pr_dependency;
4803   segT old_seg;
4804   subsegT old_subseg;
4805   tic6x_unwind_info *unwind = tic6x_get_unwind ();
4806
4807   old_seg = now_seg;
4808   old_subseg = now_subseg;
4809
4810   /* Add index table entry.  This is two words.  */
4811   tic6x_start_unwind_section (unwind->saved_seg, 1);
4812   frag_align (2, 0, 0);
4813   record_alignment (now_seg, 2);
4814
4815   ptr = frag_more (8);
4816   where = frag_now_fix () - 8;
4817
4818   /* Self relative offset of the function start.  */
4819   fix_new (frag_now, where, 4, unwind->function_start, 0, 1,
4820            BFD_RELOC_C6000_PREL31);
4821
4822   /* Indicate dependency on ABI-defined personality routines to the
4823      linker, if it hasn't been done already.  */
4824   marked_pr_dependency
4825     = seg_info (now_seg)->tc_segment_info_data.marked_pr_dependency;
4826   if (unwind->personality_index >= 0 && unwind->personality_index < 5
4827       && !(marked_pr_dependency & (1 << unwind->personality_index)))
4828     {
4829       static const char *const name[] =
4830         {
4831           "__c6xabi_unwind_cpp_pr0",
4832           "__c6xabi_unwind_cpp_pr1",
4833           "__c6xabi_unwind_cpp_pr2",
4834           "__c6xabi_unwind_cpp_pr3",
4835           "__c6xabi_unwind_cpp_pr4"
4836         };
4837       symbolS *pr = symbol_find_or_make (name[unwind->personality_index]);
4838       fix_new (frag_now, where, 0, pr, 0, 1, BFD_RELOC_NONE);
4839       seg_info (now_seg)->tc_segment_info_data.marked_pr_dependency
4840         |= 1 << unwind->personality_index;
4841     }
4842
4843   if (unwind->table_entry)
4844     {
4845       /* Self relative offset of the table entry.        */
4846       fix_new (frag_now, where + 4, 4, unwind->table_entry, 0, 1,
4847                BFD_RELOC_C6000_PREL31);
4848     }
4849   else
4850     {
4851       /* Inline exception table entry.  */
4852       md_number_to_chars (ptr + 4, unwind->data, 4);
4853     }
4854
4855   /* Restore the original section.  */
4856   subseg_set (old_seg, old_subseg);
4857 }
4858
4859 static void
4860 tic6x_output_unwinding (bfd_boolean need_extab)
4861 {
4862   tic6x_unwind_info *unwind = tic6x_get_unwind ();
4863   unsigned safe_mask = unwind->safe_mask;
4864   unsigned compact_mask = unwind->compact_mask;
4865   unsigned reg_saved_mask = unwind->reg_saved_mask;
4866   offsetT cfa_offset = unwind->cfa_offset;
4867   long where;
4868   int reg;
4869
4870   if (unwind->personality_index == -2)
4871     {
4872       /* Function can not be unwound.  */
4873       unwind->data = 1;
4874       tic6x_output_exidx_entry ();
4875       return;
4876     }
4877
4878   if (unwind->personality_index == -1 && unwind->personality_routine == NULL)
4879     {
4880       /* Auto-select a personality routine if none specified.  */
4881       if (reg_saved_mask || cfa_offset >= MAX_COMPACT_SP_OFFSET)
4882         unwind->personality_index = -1;
4883       else if (safe_mask)
4884         unwind->personality_index = 3;
4885       else
4886         unwind->personality_index = 4;
4887     }
4888
4889   /* Calculate unwinding opcodes, and emit to EXTAB if necessary.  */
4890   unwind->table_entry = NULL;
4891   if (unwind->personality_index == 3 || unwind->personality_index == 4)
4892     {
4893       if (cfa_offset >= MAX_COMPACT_SP_OFFSET)
4894         {
4895           as_bad (_("stack pointer offset too large for personality routine"));
4896           return;
4897         }
4898       if (reg_saved_mask
4899           || (unwind->personality_index == 3 && compact_mask != 0)
4900           || (unwind->personality_index == 4 && safe_mask != 0))
4901         {
4902           as_bad (_("stack frame layout does not match personality routine"));
4903           return;
4904         }
4905
4906       unwind->data = (1u << 31) | (unwind->personality_index << 24);
4907       if (unwind->cfa_reg == 15)
4908         unwind->data |= 0x7f << 17;
4909       else
4910         unwind->data |= cfa_offset << (17 - 3);
4911
4912       if (unwind->personality_index == 3)
4913         unwind->data |= safe_mask << 4;
4914       else
4915         unwind->data |= compact_mask << 4;
4916       unwind->data |= unwind->return_reg;
4917       unwind->data_bytes = 4;
4918     }
4919   else
4920     {
4921       if (unwind->personality_routine)
4922         {
4923           unwind->data = 0;
4924           unwind->data_bytes = 5;
4925           tic6x_flush_unwind_word (0);
4926           /* First word is personality routine.  */
4927           where = frag_now_fix () - 4;
4928           fix_new (frag_now, where, 4, unwind->personality_routine, 0, 1,
4929                    BFD_RELOC_C6000_PREL31);
4930         }
4931       else if (unwind->personality_index > 0)
4932         {
4933           unwind->data = 0x8000 | (unwind->personality_index << 8);
4934           unwind->data_bytes = 2;
4935         }
4936       else /* pr0 or undecided */
4937         {
4938           unwind->data = 0x80;
4939           unwind->data_bytes = 1;
4940         }
4941
4942       if (unwind->return_reg != UNWIND_B3)
4943         {
4944           tic6x_unwind_byte (UNWIND_OP_RET | unwind->return_reg);
4945         }
4946
4947       if (unwind->cfa_reg == 15)
4948         {
4949           tic6x_unwind_byte (UNWIND_OP_MV_FP);
4950         }
4951       else if (cfa_offset != 0)
4952         {
4953           cfa_offset >>= 3;
4954           if (cfa_offset > 0x80)
4955             {
4956               tic6x_unwind_byte (UNWIND_OP_ADD_SP2);
4957               tic6x_unwind_uleb (cfa_offset - 0x81);
4958             }
4959           else if (cfa_offset > 0x40)
4960             {
4961               tic6x_unwind_byte (UNWIND_OP_ADD_SP | 0x3f);
4962               tic6x_unwind_byte (UNWIND_OP_ADD_SP | (cfa_offset - 0x40));
4963             }
4964           else
4965             {
4966               tic6x_unwind_byte (UNWIND_OP_ADD_SP | (cfa_offset - 1));
4967             }
4968         }
4969
4970       if (safe_mask)
4971         tic6x_unwind_2byte (UNWIND_OP2_POP | unwind->safe_mask);
4972       else if (unwind->pop_rts)
4973         tic6x_unwind_byte (UNWIND_OP_POP_RTS);
4974       else if (compact_mask)
4975         tic6x_unwind_2byte (UNWIND_OP2_POP_COMPACT | unwind->compact_mask);
4976       else if (reg_saved_mask)
4977         {
4978           offsetT cur_offset;
4979           int val;
4980           int last_val;
4981
4982           tic6x_unwind_byte (UNWIND_OP_POP_REG | unwind->saved_reg_count);
4983           last_val = 0;
4984           for (cur_offset = 0; unwind->saved_reg_count > 0; cur_offset -= 4)
4985             {
4986               val = 0xf;
4987               for (reg = 0; reg < TIC6X_NUM_UNWIND_REGS; reg++)
4988                 {
4989                   if (!unwind->reg_saved[reg])
4990                     continue;
4991
4992                   if (unwind->reg_offset[reg] == cur_offset)
4993                     {
4994                       unwind->saved_reg_count--;
4995                       val = reg;
4996                       break;
4997                     }
4998                 }
4999               if ((cur_offset & 4) == 4)
5000                 tic6x_unwind_byte ((last_val << 4) | val);
5001               else
5002                 last_val = val;
5003             }
5004           if ((cur_offset & 4) == 4)
5005             tic6x_unwind_byte ((last_val << 4) | 0xf);
5006         }
5007
5008       /* Pad with RETURN opcodes.  */
5009       while ((unwind->data_bytes & 3) != 0)
5010         tic6x_unwind_byte (UNWIND_OP_RET | UNWIND_B3);
5011
5012       if (unwind->personality_index == -1 && unwind->personality_routine == NULL)
5013         unwind->personality_index = 0;
5014     }
5015
5016   /* Force creation of an EXTAB entry if an LSDA is required.  */
5017   if (need_extab && !unwind->table_entry)
5018     {
5019       if (unwind->data_bytes != 4)
5020         abort ();
5021
5022       tic6x_flush_unwind_word (unwind->data);
5023     }
5024   else if (unwind->table_entry && !need_extab)
5025     {
5026       /* Add an empty descriptor if there is no user-specified data.   */
5027       char *ptr = frag_more (4);
5028       md_number_to_chars (ptr, 0, 4);
5029     }
5030
5031   /* Fill in length of unwinding bytecode.  */
5032   if (unwind->table_entry)
5033     {
5034       valueT tmp;
5035       if (unwind->data_bytes > 0x400)
5036         as_bad (_("too many unwinding instructions"));
5037
5038       if (unwind->personality_index == -1)
5039         {
5040           tmp = md_chars_to_number (unwind->frag_start + 4, 4);
5041           tmp |= ((unwind->data_bytes - 8) >> 2) << 24;
5042           md_number_to_chars (unwind->frag_start + 4, tmp, 4);
5043         }
5044       else if (unwind->personality_index == 1 || unwind->personality_index == 2)
5045         {
5046           tmp = md_chars_to_number (unwind->frag_start, 4);
5047           tmp |= ((unwind->data_bytes - 4) >> 2) << 16;
5048           md_number_to_chars (unwind->frag_start, tmp, 4);
5049         }
5050     }
5051   tic6x_output_exidx_entry ();
5052 }
5053
5054 /* FIXME: This will get horribly confused if cfi directives are emitted for
5055    function epilogue.  */
5056 void
5057 tic6x_cfi_endproc (struct fde_entry *fde)
5058 {
5059   tic6x_unwind_info *unwind = tic6x_get_unwind ();
5060   struct cfi_insn_data *insn;
5061   int reg;
5062   unsigned safe_mask = 0;
5063   unsigned compact_mask = 0;
5064   unsigned reg_saved_mask = 0;
5065   offsetT cfa_offset = 0;
5066   offsetT save_offset = 0;
5067
5068   unwind->cfa_reg = 31;
5069   unwind->return_reg = UNWIND_B3;
5070   unwind->saved_reg_count = 0;
5071   unwind->pop_rts = FALSE;
5072
5073   unwind->saved_seg = now_seg;
5074   unwind->saved_subseg = now_subseg;
5075
5076   for (reg = 0; reg < TIC6X_NUM_UNWIND_REGS; reg++)
5077     unwind->reg_saved[reg] = FALSE;
5078
5079   /* Scan FDE instructions to build up stack frame layout.  */
5080   for (insn = fde->data; insn; insn = insn->next)
5081     {
5082       switch (insn->insn)
5083         {
5084         case DW_CFA_advance_loc:
5085           break;
5086
5087         case DW_CFA_def_cfa:
5088           unwind->cfa_reg = insn->u.ri.reg;
5089           cfa_offset = insn->u.ri.offset;
5090           break;
5091
5092         case DW_CFA_def_cfa_register:
5093           unwind->cfa_reg = insn->u.r;
5094           break;
5095
5096         case DW_CFA_def_cfa_offset:
5097           cfa_offset = insn->u.i;
5098           break;
5099
5100         case DW_CFA_undefined:
5101         case DW_CFA_same_value:
5102           reg = tic6x_unwind_reg_from_dwarf (insn->u.r);
5103           if (reg >= 0)
5104             unwind->reg_saved[reg] = FALSE;
5105           break;
5106
5107         case DW_CFA_offset:
5108           reg = tic6x_unwind_reg_from_dwarf (insn->u.ri.reg);
5109           if (reg < 0)
5110             {
5111               as_bad (_("unable to generate unwinding opcode for reg %d"),
5112                       insn->u.ri.reg);
5113               return;
5114             }
5115           unwind->reg_saved[reg] = TRUE;
5116           unwind->reg_offset[reg] = insn->u.ri.offset;
5117           if (insn->u.ri.reg == UNWIND_B3)
5118             unwind->return_reg = UNWIND_B3;
5119           break;
5120
5121         case DW_CFA_register:
5122           if (insn->u.rr.reg1 != 19)
5123             {
5124               as_bad (_("unable to generate unwinding opcode for reg %d"),
5125                       insn->u.rr.reg1);
5126               return;
5127             }
5128
5129           reg = tic6x_unwind_reg_from_dwarf (insn->u.rr.reg2);
5130           if (reg < 0)
5131             {
5132               as_bad (_("unable to generate unwinding opcode for reg %d"),
5133                       insn->u.rr.reg2);
5134               return;
5135             }
5136
5137           unwind->return_reg = reg;
5138           unwind->reg_saved[UNWIND_B3] = FALSE;
5139           if (unwind->reg_saved[reg])
5140             {
5141               as_bad (_("unable to restore return address from "
5142                         "previously restored reg"));
5143               return;
5144             }
5145           break;
5146
5147         case DW_CFA_restore:
5148         case DW_CFA_remember_state:
5149         case DW_CFA_restore_state:
5150         case DW_CFA_GNU_window_save:
5151         case CFI_escape:
5152         case CFI_val_encoded_addr:
5153           as_bad (_("unhandled CFA insn for unwinding (%d)"), insn->insn);
5154           break;
5155
5156         default:
5157           abort ();
5158         }
5159     }
5160
5161   if (unwind->cfa_reg != 15 && unwind->cfa_reg != 31)
5162     {
5163       as_bad (_("unable to generate unwinding opcode for frame pointer reg %d"),
5164               unwind->cfa_reg);
5165       return;
5166     }
5167
5168   if (unwind->cfa_reg == 15)
5169     {
5170       if (cfa_offset != 0)
5171         {
5172           as_bad (_("unable to generate unwinding opcode for "
5173                     "frame pointer offset"));
5174           return;
5175         }
5176     }
5177   else
5178     {
5179       if ((cfa_offset & 7) != 0)
5180         {
5181           as_bad (_("unwound stack pointer not doubleword aligned"));
5182           return;
5183         }
5184     }
5185
5186   for (reg = 0; reg < TIC6X_NUM_UNWIND_REGS; reg++)
5187     {
5188       if (unwind->reg_saved[reg])
5189         reg_saved_mask |= 1 << (TIC6X_NUM_UNWIND_REGS - (reg + 1));
5190     }
5191
5192   /* Check for standard "safe debug" frame layout */
5193   if (reg_saved_mask)
5194     {
5195       save_offset = 0;
5196       for (reg = 0; reg < TIC6X_NUM_UNWIND_REGS; reg++)
5197         {
5198           if (!unwind->reg_saved[reg])
5199             continue;
5200
5201           if (target_big_endian
5202               && reg < TIC6X_NUM_UNWIND_REGS - 1
5203               && unwind->reg_saved[reg + 1]
5204               && tic6x_unwind_frame_regs[reg]
5205                   == tic6x_unwind_frame_regs[reg + 1] + 1
5206               && (tic6x_unwind_frame_regs[reg] & 1) == 1
5207               && (save_offset & 4) == 4)
5208             {
5209               /* Swapped pair */
5210               if (save_offset != unwind->reg_offset[reg + 1]
5211                   || save_offset - 4 != unwind->reg_offset[reg])
5212                 break;
5213               save_offset -= 8;
5214               reg++;
5215             }
5216           else
5217             {
5218               if (save_offset != unwind->reg_offset[reg])
5219                 break;
5220               save_offset -= 4;
5221             }
5222         }
5223       if (reg == TIC6X_NUM_UNWIND_REGS)
5224         {
5225           safe_mask = reg_saved_mask;
5226           reg_saved_mask = 0;
5227         }
5228     }
5229
5230   /* Check for compact frame layout.  */
5231   if (reg_saved_mask)
5232     {
5233       save_offset = 0;
5234       for (reg = 0; reg < TIC6X_NUM_UNWIND_REGS; reg++)
5235         {
5236           int reg2;
5237
5238           if (!unwind->reg_saved[reg])
5239             continue;
5240
5241           if (reg < TIC6X_NUM_UNWIND_REGS - 1)
5242             {
5243               reg2 = reg + 1;
5244
5245               if (!unwind->reg_saved[reg2]
5246                   || tic6x_unwind_frame_regs[reg]
5247                       != tic6x_unwind_frame_regs[reg2] + 1
5248                   || (tic6x_unwind_frame_regs[reg2] & 1) != 0
5249                   || save_offset == 0)
5250                 reg2 = -1;
5251             }
5252           else
5253             reg2 = -1;
5254
5255           if (reg2 >= 0)
5256             {
5257               int high_offset;
5258               if (target_big_endian)
5259                 high_offset = 4; /* lower address = positive stack offset.  */
5260               else
5261                 high_offset = 0;
5262
5263               if (save_offset + 4 - high_offset != unwind->reg_offset[reg]
5264                   || save_offset + high_offset != unwind->reg_offset[reg2])
5265                 {
5266                   break;
5267                 }
5268               reg++;
5269             }
5270           else
5271             {
5272               if (save_offset != unwind->reg_offset[reg])
5273                 break;
5274             }
5275           save_offset -= 8;
5276         }
5277
5278       if (reg == TIC6X_NUM_UNWIND_REGS)
5279         {
5280           compact_mask = reg_saved_mask;
5281           reg_saved_mask = 0;
5282         }
5283     }
5284
5285   /* Check for __c6xabi_pop_rts format */
5286   if (reg_saved_mask == 0x17ff)
5287     {
5288       const int *pop_rts_offset = target_big_endian
5289                                 ? tic6x_pop_rts_offset_big
5290                                 : tic6x_pop_rts_offset_little;
5291
5292       save_offset = 0;
5293       for (reg = 0; reg < TIC6X_NUM_UNWIND_REGS; reg++)
5294         {
5295           if (reg == UNWIND_B15)
5296             continue;
5297
5298           if (unwind->reg_offset[reg] != pop_rts_offset[reg] * 4)
5299             break;
5300         }
5301
5302       if (reg == TIC6X_NUM_UNWIND_REGS)
5303         {
5304           unwind->pop_rts = TRUE;
5305           reg_saved_mask = 0;
5306         }
5307     }
5308   /* If all else fails then describe the frame manually.  */
5309   if (reg_saved_mask)
5310     {
5311       save_offset = 0;
5312
5313       for (reg = 0; reg < TIC6X_NUM_UNWIND_REGS; reg++)
5314         {
5315           if (!unwind->reg_saved[reg])
5316             continue;
5317
5318           unwind->saved_reg_count++;
5319           /* Encoding uses 4 bits per word, so size of unwinding opcode data
5320              limits the save area size.  The exact cap will be figured out
5321              later due to overflow, the 0x800 here is just a quick sanity
5322              check to weed out obviously excessive offsets.  */
5323           if (unwind->reg_offset[reg] > 0 || unwind->reg_offset[reg] < -0x800
5324               || (unwind->reg_offset[reg] & 3) != 0)
5325             {
5326               as_bad (_("stack frame layout too complex for unwinder"));
5327               return;
5328             }
5329
5330           if (unwind->reg_offset[reg] < save_offset)
5331             save_offset = unwind->reg_offset[reg] - 4;
5332         }
5333     }
5334
5335   /* Align to 8-byte boundary (stack grows towards negative offsets).  */
5336   save_offset &= ~7;
5337
5338   if (unwind->cfa_reg == 31 && !reg_saved_mask)
5339     {
5340       cfa_offset += save_offset;
5341       if (cfa_offset < 0)
5342         {
5343           as_bad (_("unwound frame has negative size"));
5344           return;
5345         }
5346     }
5347
5348   unwind->safe_mask = safe_mask;
5349   unwind->compact_mask = compact_mask;
5350   unwind->reg_saved_mask = reg_saved_mask;
5351   unwind->cfa_offset = cfa_offset;
5352   unwind->function_start = fde->start_address;
5353 }