gas/config/tc-xtensa.c

   1 /* tc-xtensa.c -- Assemble Xtensa instructions.
   2    Copyright 2003, 2004, 2005 Free Software Foundation, Inc.
   3
   4    This file is part of GAS, the GNU Assembler.
   5
   6    GAS is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    GAS is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with GAS; see the file COPYING.  If not, write to
  18    the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
  19    MA 02111-1307, USA.  */
  20
  21 #include <string.h>
  22 #include <limits.h>
  23 #include "as.h"
  24 #include "sb.h"
  25 #include "safe-ctype.h"
  26 #include "tc-xtensa.h"
  27 #include "frags.h"
  28 #include "subsegs.h"
  29 #include "xtensa-relax.h"
  30 #include "xtensa-istack.h"
  31 #include "dwarf2dbg.h"
  32 #include "struc-symbol.h"
  33 #include "xtensa-config.h"
  34
  35 #ifndef uint32
  36 #define uint32 unsigned int
  37 #endif
  38 #ifndef int32
  39 #define int32 signed int
  40 #endif
  41
  42 /* Notes:
  43
  44    Naming conventions (used somewhat inconsistently):
  45       The xtensa_ functions are exported
  46       The xg_ functions are internal
  47
  48    We also have a couple of different extensibility mechanisms.
  49    1) The idiom replacement:
  50       This is used when a line is first parsed to
  51       replace an instruction pattern with another instruction
  52       It is currently limited to replacements of instructions
  53       with constant operands.
  54    2) The xtensa-relax.c mechanism that has stronger instruction
  55       replacement patterns.  When an instruction's immediate field
  56       does not fit the next instruction sequence is attempted.
  57       In addition, "narrow" opcodes are supported this way.  */
  58
  59
  60 /* Define characters with special meanings to GAS.  */
  61 const char comment_chars[] = "#";
  62 const char line_comment_chars[] = "#";
  63 const char line_separator_chars[] = ";";
  64 const char EXP_CHARS[] = "eE";
  65 const char FLT_CHARS[] = "rRsSfFdDxXpP";
  66
  67
  68 /* Flags to indicate whether the hardware supports the density and
  69    absolute literals options.  */
  70
  71 bfd_boolean density_supported = XCHAL_HAVE_DENSITY;
  72 bfd_boolean absolute_literals_supported = XSHAL_USE_ABSOLUTE_LITERALS;
  73
  74 /* Maximum width we would pad an unreachable frag to get alignment.  */
  75 #define UNREACHABLE_MAX_WIDTH  8
  76
  77 static vliw_insn cur_vinsn;
  78
  79 unsigned xtensa_fetch_width = XCHAL_INST_FETCH_WIDTH;
  80
  81 static enum debug_info_type xt_saved_debug_type = DEBUG_NONE;
  82
  83 /* Some functions are only valid in the front end.  This variable
  84    allows us to assert that we haven't crossed over into the
  85    back end.  */
  86 static bfd_boolean past_xtensa_end = FALSE;
  87
  88 /* Flags for properties of the last instruction in a segment.  */
  89 #define FLAG_IS_A0_WRITER       0x1
  90 #define FLAG_IS_BAD_LOOPEND     0x2
  91
  92
  93 /* We define a special segment names ".literal" to place literals
  94    into.  The .fini and .init sections are special because they
  95    contain code that is moved together by the linker.  We give them
  96    their own special .fini.literal and .init.literal sections.  */
  97
  98 #define LITERAL_SECTION_NAME            xtensa_section_rename (".literal")
  99 #define LIT4_SECTION_NAME               xtensa_section_rename (".lit4")
 100 #define FINI_SECTION_NAME               xtensa_section_rename (".fini")
 101 #define INIT_SECTION_NAME               xtensa_section_rename (".init")
 102 #define FINI_LITERAL_SECTION_NAME       xtensa_section_rename (".fini.literal")
 103 #define INIT_LITERAL_SECTION_NAME       xtensa_section_rename (".init.literal")
 104
 105
 106 /* This type is used for the directive_stack to keep track of the
 107    state of the literal collection pools.  */
 108
 109 typedef struct lit_state_struct
 110 {
 111   const char *lit_seg_name;
 112   const char *lit4_seg_name;
 113   const char *init_lit_seg_name;
 114   const char *fini_lit_seg_name;
 115   segT lit_seg;
 116   segT lit4_seg;
 117   segT init_lit_seg;
 118   segT fini_lit_seg;
 119 } lit_state;
 120
 121 static lit_state default_lit_sections;
 122
 123
 124 /* We keep lists of literal segments.  The seg_list type is the node
 125    for such a list.  The *_literal_head locals are the heads of the
 126    various lists.  All of these lists have a dummy node at the start.  */
 127
 128 typedef struct seg_list_struct
 129 {
 130   struct seg_list_struct *next;
 131   segT seg;
 132 } seg_list;
 133
 134 static seg_list literal_head_h;
 135 static seg_list *literal_head = &literal_head_h;
 136 static seg_list init_literal_head_h;
 137 static seg_list *init_literal_head = &init_literal_head_h;
 138 static seg_list fini_literal_head_h;
 139 static seg_list *fini_literal_head = &fini_literal_head_h;
 140
 141
 142 /* Lists of symbols.  We keep a list of symbols that label the current
 143    instruction, so that we can adjust the symbols when inserting alignment
 144    for various instructions.  We also keep a list of all the symbols on
 145    literals, so that we can fix up those symbols when the literals are
 146    later moved into the text sections.  */
 147
 148 typedef struct sym_list_struct
 149 {
 150   struct sym_list_struct *next;
 151   symbolS *sym;
 152 } sym_list;
 153
 154 static sym_list *insn_labels = NULL;
 155 static sym_list *free_insn_labels = NULL;
 156 static sym_list *saved_insn_labels = NULL;
 157
 158 static sym_list *literal_syms;
 159
 160
 161 /* Flags to determine whether to prefer const16 or l32r
 162    if both options are available.  */
 163 int prefer_const16 = 0;
 164 int prefer_l32r = 0;
 165
 166 /* Global flag to indicate when we are emitting literals.  */
 167 int generating_literals = 0;
 168
 169 /* The following PROPERTY table definitions are copied from
 170    <elf/xtensa.h> and must be kept in sync with the code there.  */
 171
 172 /* Flags in the property tables to specify whether blocks of memory
 173    are literals, instructions, data, or unreachable.  For
 174    instructions, blocks that begin loop targets and branch targets are
 175    designated.  Blocks that do not allow density, instruction
 176    reordering or transformation are also specified.  Finally, for
 177    branch targets, branch target alignment priority is included.
 178    Alignment of the next block is specified in the current block
 179    and the size of the current block does not include any fill required
 180    to align to the next block.  */
 181
 182 #define XTENSA_PROP_LITERAL             0x00000001
 183 #define XTENSA_PROP_INSN                0x00000002
 184 #define XTENSA_PROP_DATA                0x00000004
 185 #define XTENSA_PROP_UNREACHABLE         0x00000008
 186 /* Instruction only properties at beginning of code.  */
 187 #define XTENSA_PROP_INSN_LOOP_TARGET    0x00000010
 188 #define XTENSA_PROP_INSN_BRANCH_TARGET  0x00000020
 189 /* Instruction only properties about code.  */
 190 #define XTENSA_PROP_INSN_NO_DENSITY     0x00000040
 191 #define XTENSA_PROP_INSN_NO_REORDER     0x00000080
 192 #define XTENSA_PROP_INSN_NO_TRANSFORM   0x00000100
 193
 194 /*  Branch target alignment information.  This transmits information
 195     to the linker optimization about the priority of aligning a
 196     particular block for branch target alignment: None, low priority,
 197     high priority, or required.  These only need to be checked in
 198     instruction blocks marked as XTENSA_PROP_INSN_BRANCH_TARGET.
 199     Common usage is
 200
 201     switch (GET_XTENSA_PROP_BT_ALIGN (flags))
 202     case XTENSA_PROP_BT_ALIGN_NONE:
 203     case XTENSA_PROP_BT_ALIGN_LOW:
 204     case XTENSA_PROP_BT_ALIGN_HIGH:
 205     case XTENSA_PROP_BT_ALIGN_REQUIRE:
 206 */
 207 #define XTENSA_PROP_BT_ALIGN_MASK       0x00000600
 208
 209 /* No branch target alignment.  */
 210 #define XTENSA_PROP_BT_ALIGN_NONE       0x0
 211 /* Low priority branch target alignment.  */
 212 #define XTENSA_PROP_BT_ALIGN_LOW        0x1
 213 /* High priority branch target alignment.  */
 214 #define XTENSA_PROP_BT_ALIGN_HIGH       0x2
 215 /* Required branch target alignment.  */
 216 #define XTENSA_PROP_BT_ALIGN_REQUIRE    0x3
 217
 218 #define GET_XTENSA_PROP_BT_ALIGN(flag) \
 219   (((unsigned) ((flag) & (XTENSA_PROP_BT_ALIGN_MASK))) >> 9)
 220 #define SET_XTENSA_PROP_BT_ALIGN(flag, align) \
 221   (((flag) & (~XTENSA_PROP_BT_ALIGN_MASK)) | \
 222     (((align) << 9) & XTENSA_PROP_BT_ALIGN_MASK))
 223
 224
 225 /* Alignment is specified in the block BEFORE the one that needs
 226    alignment.  Up to 5 bits.  Use GET_XTENSA_PROP_ALIGNMENT(flags) to
 227    get the required alignment specified as a power of 2.  Use
 228    SET_XTENSA_PROP_ALIGNMENT(flags, pow2) to set the required
 229    alignment.  Be careful of side effects since the SET will evaluate
 230    flags twice.  Also, note that the SIZE of a block in the property
 231    table does not include the alignment size, so the alignment fill
 232    must be calculated to determine if two blocks are contiguous.
 233    TEXT_ALIGN is not currently implemented but is a placeholder for a
 234    possible future implementation.  */
 235
 236 #define XTENSA_PROP_ALIGN               0x00000800
 237
 238 #define XTENSA_PROP_ALIGNMENT_MASK      0x0001f000
 239
 240 #define GET_XTENSA_PROP_ALIGNMENT(flag) \
 241   (((unsigned) ((flag) & (XTENSA_PROP_ALIGNMENT_MASK))) >> 12)
 242 #define SET_XTENSA_PROP_ALIGNMENT(flag, align) \
 243   (((flag) & (~XTENSA_PROP_ALIGNMENT_MASK)) | \
 244     (((align) << 12) & XTENSA_PROP_ALIGNMENT_MASK))
 245
 246 #define XTENSA_PROP_INSN_ABSLIT 0x00020000
 247
 248
 249 /* Structure for saving instruction and alignment per-fragment data
 250    that will be written to the object file.  This structure is
 251    equivalent to the actual data that will be written out to the file
 252    but is easier to use.   We provide a conversion to file flags
 253    in frag_flags_to_number.  */
 254
 255 typedef struct frag_flags_struct frag_flags;
 256
 257 struct frag_flags_struct
 258 {
 259   /* is_literal should only be used after xtensa_move_literals.
 260      If you need to check if you are generating a literal fragment,
 261      then use the generating_literals global.  */
 262
 263   unsigned is_literal : 1;
 264   unsigned is_insn : 1;
 265   unsigned is_data : 1;
 266   unsigned is_unreachable : 1;
 267
 268   struct
 269   {
 270     unsigned is_loop_target : 1;
 271     unsigned is_branch_target : 1; /* Branch targets have a priority.  */
 272     unsigned bt_align_priority : 2;
 273
 274     unsigned is_no_density : 1;
 275     /* no_longcalls flag does not need to be placed in the object file.  */
 276     /* is_specific_opcode implies no_transform.  */
 277     unsigned is_no_transform : 1;
 278
 279     unsigned is_no_reorder : 1;
 280
 281     /* Uses absolute literal addressing for l32r.  */
 282     unsigned is_abslit : 1;
 283   } insn;
 284   unsigned is_align : 1;
 285   unsigned alignment : 5;
 286 };
 287
 288
 289 /* Structure for saving information about a block of property data
 290    for frags that have the same flags.  */
 291 struct xtensa_block_info_struct
 292 {
 293   segT sec;
 294   bfd_vma offset;
 295   size_t size;
 296   frag_flags flags;
 297   struct xtensa_block_info_struct *next;
 298 };
 299
 300
 301 /* Structure for saving the current state before emitting literals.  */
 302 typedef struct emit_state_struct
 303 {
 304   const char *name;
 305   segT now_seg;
 306   subsegT now_subseg;
 307   int generating_literals;
 308 } emit_state;
 309
 310
 311 /* Opcode placement information */
 312
 313 typedef unsigned long long bitfield;
 314 #define bit_is_set(bit, bf)     ((bf) & (0x01ll << (bit)))
 315 #define set_bit(bit, bf)        ((bf) |= (0x01ll << (bit)))
 316 #define clear_bit(bit, bf)      ((bf) &= ~(0x01ll << (bit)))
 317
 318 #define MAX_FORMATS 32
 319
 320 typedef struct op_placement_info_struct
 321 {
 322   int num_formats;
 323   /* A number describing how restrictive the issue is for this
 324      opcode.  For example, an opcode that fits lots of different
 325      formats has a high freedom, as does an opcode that fits
 326      only one format but many slots in that format.  The most
 327      restrictive is the opcode that fits only one slot in one
 328      format.  */
 329   int issuef;
 330   /* The single format (i.e., if the op can live in a bundle by itself),
 331      narrowest format, and widest format the op can be bundled in
 332      and their sizes:  */
 333   xtensa_format single;
 334   xtensa_format narrowest;
 335   xtensa_format widest;
 336   char narrowest_size;
 337   char widest_size;
 338   char single_size;
 339
 340   /* formats is a bitfield with the Nth bit set
 341      if the opcode fits in the Nth xtensa_format.  */
 342   bitfield formats;
 343
 344   /* slots[N]'s Mth bit is set if the op fits in the
 345      Mth slot of the Nth xtensa_format.  */
 346   bitfield slots[MAX_FORMATS];
 347
 348   /* A count of the number of slots in a given format
 349      an op can fit (i.e., the bitcount of the slot field above).  */
 350   char slots_in_format[MAX_FORMATS];
 351
 352 } op_placement_info, *op_placement_info_table;
 353
 354 op_placement_info_table op_placement_table;
 355
 356
 357 /* Extra expression types.  */
 358
 359 #define O_pltrel        O_md1   /* like O_symbol but use a PLT reloc */
 360 #define O_hi16          O_md2   /* use high 16 bits of symbolic value */
 361 #define O_lo16          O_md3   /* use low 16 bits of symbolic value */
 362
 363
 364 /* Directives.  */
 365
 366 typedef enum
 367 {
 368   directive_none = 0,
 369   directive_literal,
 370   directive_density,
 371   directive_transform,
 372   directive_freeregs,
 373   directive_longcalls,
 374   directive_literal_prefix,
 375   directive_schedule,
 376   directive_absolute_literals,
 377   directive_last_directive
 378 } directiveE;
 379
 380 typedef struct
 381 {
 382   const char *name;
 383   bfd_boolean can_be_negated;
 384 } directive_infoS;
 385
 386 const directive_infoS directive_info[] =
 387 {
 388   { "none",             FALSE },
 389   { "literal",          FALSE },
 390   { "density",          TRUE },
 391   { "transform",        TRUE },
 392   { "freeregs",         FALSE },
 393   { "longcalls",        TRUE },
 394   { "literal_prefix",   FALSE },
 395   { "schedule",         TRUE },
 396   { "absolute-literals", TRUE }
 397 };
 398
 399 bfd_boolean directive_state[] =
 400 {
 401   FALSE,                        /* none */
 402   FALSE,                        /* literal */
 403 #if !XCHAL_HAVE_DENSITY
 404   FALSE,                        /* density */
 405 #else
 406   TRUE,                         /* density */
 407 #endif
 408   TRUE,                         /* transform */
 409   FALSE,                        /* freeregs */
 410   FALSE,                        /* longcalls */
 411   FALSE,                        /* literal_prefix */
 412   TRUE,                         /* schedule */
 413 #if XSHAL_USE_ABSOLUTE_LITERALS
 414   TRUE                          /* absolute_literals */
 415 #else
 416   FALSE                         /* absolute_literals */
 417 #endif
 418 };
 419
 420
 421 /* Directive functions.  */
 422
 423 static void xtensa_begin_directive (int);
 424 static void xtensa_end_directive (int);
 425 static void xtensa_dwarf2_directive_loc (int);
 426 static void xtensa_literal_prefix (char const *, int);
 427 static void xtensa_literal_position (int);
 428 static void xtensa_literal_pseudo (int);
 429 static void xtensa_frequency_pseudo (int);
 430 static void xtensa_elf_cons (int);
 431
 432 /* Parsing and Idiom Translation.  */
 433
 434 static bfd_reloc_code_real_type xtensa_elf_suffix (char **, expressionS *);
 435
 436 /* Various Other Internal Functions.  */
 437
 438 extern bfd_boolean xg_is_single_relaxable_insn (TInsn *, TInsn *, bfd_boolean);
 439 static bfd_boolean xg_build_to_insn (TInsn *, TInsn *, BuildInstr *);
 440 static void xtensa_mark_literal_pool_location (void);
 441 static addressT get_expanded_loop_offset (xtensa_opcode);
 442 static fragS *get_literal_pool_location (segT);
 443 static void set_literal_pool_location (segT, fragS *);
 444 static void xtensa_set_frag_assembly_state (fragS *);
 445 static void finish_vinsn (vliw_insn *);
 446 static bfd_boolean emit_single_op (TInsn *);
 447 static int total_frag_text_expansion (fragS *);
 448
 449 /* Alignment Functions.  */
 450
 451 static int get_text_align_power (unsigned);
 452 static int get_text_align_max_fill_size (int, bfd_boolean, bfd_boolean);
 453 static int branch_align_power (segT);
 454
 455 /* Helpers for xtensa_relax_frag().  */
 456
 457 static long relax_frag_add_nop (fragS *);
 458
 459 /* Accessors for additional per-subsegment information.  */
 460
 461 static unsigned get_last_insn_flags (segT, subsegT);
 462 static void set_last_insn_flags (segT, subsegT, unsigned, bfd_boolean);
 463 static float get_subseg_total_freq (segT, subsegT);
 464 static float get_subseg_target_freq (segT, subsegT);
 465 static void set_subseg_freq (segT, subsegT, float, float);
 466
 467 /* Segment list functions.  */
 468
 469 static void xtensa_move_literals (void);
 470 static void xtensa_reorder_segments (void);
 471 static void xtensa_switch_to_literal_fragment (emit_state *);
 472 static void xtensa_switch_to_non_abs_literal_fragment (emit_state *);
 473 static void xtensa_switch_section_emit_state (emit_state *, segT, subsegT);
 474 static void xtensa_restore_emit_state (emit_state *);
 475 static void cache_literal_section
 476   (seg_list *, const char *, segT *, bfd_boolean);
 477
 478 /* Import from elf32-xtensa.c in BFD library.  */
 479
 480 extern char *xtensa_get_property_section_name (asection *, const char *);
 481
 482 /* op_placement_info functions.  */
 483
 484 static void init_op_placement_info_table (void);
 485 extern bfd_boolean opcode_fits_format_slot (xtensa_opcode, xtensa_format, int);
 486 static int xg_get_single_size (xtensa_opcode);
 487 static xtensa_format xg_get_single_format (xtensa_opcode);
 488
 489 /* TInsn and IStack functions.  */
 490
 491 static bfd_boolean tinsn_has_symbolic_operands (const TInsn *);
 492 static bfd_boolean tinsn_has_invalid_symbolic_operands (const TInsn *);
 493 static bfd_boolean tinsn_has_complex_operands (const TInsn *);
 494 static bfd_boolean tinsn_to_insnbuf (TInsn *, xtensa_insnbuf);
 495 static bfd_boolean tinsn_check_arguments (const TInsn *);
 496 static void tinsn_from_chars (TInsn *, char *, int);
 497 static void tinsn_immed_from_frag (TInsn *, fragS *, int);
 498 static int get_num_stack_text_bytes (IStack *);
 499 static int get_num_stack_literal_bytes (IStack *);
 500
 501 /* vliw_insn functions.  */
 502
 503 static void xg_init_vinsn (vliw_insn *);
 504 static void xg_clear_vinsn (vliw_insn *);
 505 static bfd_boolean vinsn_has_specific_opcodes (vliw_insn *);
 506 static void xg_free_vinsn (vliw_insn *);
 507 static bfd_boolean vinsn_to_insnbuf
 508   (vliw_insn *, char *, fragS *, bfd_boolean);
 509 static void vinsn_from_chars (vliw_insn *, char *);
 510
 511 /* Expression Utilities.  */
 512
 513 bfd_boolean expr_is_const (const expressionS *);
 514 offsetT get_expr_const (const expressionS *);
 515 void set_expr_const (expressionS *, offsetT);
 516 bfd_boolean expr_is_register (const expressionS *);
 517 offsetT get_expr_register (const expressionS *);
 518 void set_expr_symbol_offset (expressionS *, symbolS *, offsetT);
 519 static void set_expr_symbol_offset_diff
 520   (expressionS *, symbolS *, symbolS *, offsetT);
 521 bfd_boolean expr_is_equal (expressionS *, expressionS *);
 522 static void copy_expr (expressionS *, const expressionS *);
 523
 524 /* Section renaming.  */
 525
 526 static void build_section_rename (const char *);
 527
 528
 529 /* ISA imported from bfd.  */
 530 extern xtensa_isa xtensa_default_isa;
 531
 532 extern int target_big_endian;
 533
 534 static xtensa_opcode xtensa_addi_opcode;
 535 static xtensa_opcode xtensa_addmi_opcode;
 536 static xtensa_opcode xtensa_call0_opcode;
 537 static xtensa_opcode xtensa_call4_opcode;
 538 static xtensa_opcode xtensa_call8_opcode;
 539 static xtensa_opcode xtensa_call12_opcode;
 540 static xtensa_opcode xtensa_callx0_opcode;
 541 static xtensa_opcode xtensa_callx4_opcode;
 542 static xtensa_opcode xtensa_callx8_opcode;
 543 static xtensa_opcode xtensa_callx12_opcode;
 544 static xtensa_opcode xtensa_const16_opcode;
 545 static xtensa_opcode xtensa_entry_opcode;
 546 static xtensa_opcode xtensa_movi_opcode;
 547 static xtensa_opcode xtensa_movi_n_opcode;
 548 static xtensa_opcode xtensa_isync_opcode;
 549 static xtensa_opcode xtensa_jx_opcode;
 550 static xtensa_opcode xtensa_l32r_opcode;
 551 static xtensa_opcode xtensa_loop_opcode;
 552 static xtensa_opcode xtensa_loopnez_opcode;
 553 static xtensa_opcode xtensa_loopgtz_opcode;
 554 static xtensa_opcode xtensa_nop_opcode;
 555 static xtensa_opcode xtensa_nop_n_opcode;
 556 static xtensa_opcode xtensa_or_opcode;
 557 static xtensa_opcode xtensa_ret_opcode;
 558 static xtensa_opcode xtensa_ret_n_opcode;
 559 static xtensa_opcode xtensa_retw_opcode;
 560 static xtensa_opcode xtensa_retw_n_opcode;
 561 static xtensa_opcode xtensa_rsr_lcount_opcode;
 562 static xtensa_opcode xtensa_waiti_opcode;
 563
 564 \f
 565 /* Command-line Options.  */
 566
 567 bfd_boolean use_literal_section = TRUE;
 568 static bfd_boolean align_targets = TRUE;
 569 static bfd_boolean warn_unaligned_branch_targets = FALSE;
 570 static bfd_boolean has_a0_b_retw = FALSE;
 571 static bfd_boolean workaround_a0_b_retw = FALSE;
 572 static bfd_boolean workaround_b_j_loop_end = FALSE;
 573 static bfd_boolean workaround_short_loop = FALSE;
 574 static bfd_boolean maybe_has_short_loop = FALSE;
 575 static bfd_boolean workaround_close_loop_end = FALSE;
 576 static bfd_boolean maybe_has_close_loop_end = FALSE;
 577
 578 /* When workaround_short_loops is TRUE, all loops with early exits must
 579    have at least 3 instructions.  workaround_all_short_loops is a modifier
 580    to the workaround_short_loop flag.  In addition to the
 581    workaround_short_loop actions, all straightline loopgtz and loopnez
 582    must have at least 3 instructions.  */
 583
 584 static bfd_boolean workaround_all_short_loops = FALSE;
 585
 586
 587 static void
 588 xtensa_setup_hw_workarounds (int earliest, int latest)
 589 {
 590   if (earliest > latest)
 591     as_fatal (_("illegal range of target hardware versions"));
 592
 593   /* Enable all workarounds for pre-T1050.0 hardware.  */
 594   if (earliest < 105000 || latest < 105000)
 595     {
 596       workaround_a0_b_retw |= TRUE;
 597       workaround_b_j_loop_end |= TRUE;
 598       workaround_short_loop |= TRUE;
 599       workaround_close_loop_end |= TRUE;
 600       workaround_all_short_loops |= TRUE;
 601     }
 602 }
 603
 604
 605 enum
 606 {
 607   option_density = OPTION_MD_BASE,
 608   option_no_density,
 609
 610   option_relax,
 611   option_no_relax,
 612
 613   option_link_relax,
 614   option_no_link_relax,
 615
 616   option_generics,
 617   option_no_generics,
 618
 619   option_transform,
 620   option_no_transform,
 621
 622   option_text_section_literals,
 623   option_no_text_section_literals,
 624
 625   option_absolute_literals,
 626   option_no_absolute_literals,
 627
 628   option_align_targets,
 629   option_no_align_targets,
 630
 631   option_warn_unaligned_targets,
 632
 633   option_longcalls,
 634   option_no_longcalls,
 635
 636   option_workaround_a0_b_retw,
 637   option_no_workaround_a0_b_retw,
 638
 639   option_workaround_b_j_loop_end,
 640   option_no_workaround_b_j_loop_end,
 641
 642   option_workaround_short_loop,
 643   option_no_workaround_short_loop,
 644
 645   option_workaround_all_short_loops,
 646   option_no_workaround_all_short_loops,
 647
 648   option_workaround_close_loop_end,
 649   option_no_workaround_close_loop_end,
 650
 651   option_no_workarounds,
 652
 653   option_rename_section_name,
 654
 655   option_prefer_l32r,
 656   option_prefer_const16,
 657
 658   option_target_hardware
 659 };
 660
 661 const char *md_shortopts = "";
 662
 663 struct option md_longopts[] =
 664 {
 665   { "density", no_argument, NULL, option_density },
 666   { "no-density", no_argument, NULL, option_no_density },
 667
 668   /* Both "relax" and "generics" are deprecated and treated as equivalent
 669      to the "transform" option.  */
 670   { "relax", no_argument, NULL, option_relax },
 671   { "no-relax", no_argument, NULL, option_no_relax },
 672   { "generics", no_argument, NULL, option_generics },
 673   { "no-generics", no_argument, NULL, option_no_generics },
 674
 675   { "transform", no_argument, NULL, option_transform },
 676   { "no-transform", no_argument, NULL, option_no_transform },
 677   { "text-section-literals", no_argument, NULL, option_text_section_literals },
 678   { "no-text-section-literals", no_argument, NULL,
 679     option_no_text_section_literals },
 680   { "absolute-literals", no_argument, NULL, option_absolute_literals },
 681   { "no-absolute-literals", no_argument, NULL, option_no_absolute_literals },
 682   /* This option was changed from -align-target to -target-align
 683      because it conflicted with the "-al" option.  */
 684   { "target-align", no_argument, NULL, option_align_targets },
 685   { "no-target-align", no_argument, NULL, option_no_align_targets },
 686   { "warn-unaligned-targets", no_argument, NULL,
 687     option_warn_unaligned_targets },
 688   { "longcalls", no_argument, NULL, option_longcalls },
 689   { "no-longcalls", no_argument, NULL, option_no_longcalls },
 690
 691   { "no-workaround-a0-b-retw", no_argument, NULL,
 692     option_no_workaround_a0_b_retw },
 693   { "workaround-a0-b-retw", no_argument, NULL, option_workaround_a0_b_retw },
 694
 695   { "no-workaround-b-j-loop-end", no_argument, NULL,
 696     option_no_workaround_b_j_loop_end },
 697   { "workaround-b-j-loop-end", no_argument, NULL,
 698     option_workaround_b_j_loop_end },
 699
 700   { "no-workaround-short-loops", no_argument, NULL,
 701     option_no_workaround_short_loop },
 702   { "workaround-short-loops", no_argument, NULL,
 703     option_workaround_short_loop },
 704
 705   { "no-workaround-all-short-loops", no_argument, NULL,
 706     option_no_workaround_all_short_loops },
 707   { "workaround-all-short-loop", no_argument, NULL,
 708     option_workaround_all_short_loops },
 709
 710   { "prefer-l32r", no_argument, NULL, option_prefer_l32r },
 711   { "prefer-const16", no_argument, NULL, option_prefer_const16 },
 712
 713   { "no-workarounds", no_argument, NULL, option_no_workarounds },
 714
 715   { "no-workaround-close-loop-end", no_argument, NULL,
 716     option_no_workaround_close_loop_end },
 717   { "workaround-close-loop-end", no_argument, NULL,
 718     option_workaround_close_loop_end },
 719
 720   { "rename-section", required_argument, NULL, option_rename_section_name },
 721
 722   { "link-relax", no_argument, NULL, option_link_relax },
 723   { "no-link-relax", no_argument, NULL, option_no_link_relax },
 724
 725   { "target-hardware", required_argument, NULL, option_target_hardware },
 726
 727   { NULL, no_argument, NULL, 0 }
 728 };
 729
 730 size_t md_longopts_size = sizeof md_longopts;
 731
 732
 733 int
 734 md_parse_option (int c, char *arg)
 735 {
 736   switch (c)
 737     {
 738     case option_density:
 739       as_warn (_("--density option is ignored"));
 740       return 1;
 741     case option_no_density:
 742       as_warn (_("--no-density option is ignored"));
 743       return 1;
 744     case option_link_relax:
 745       linkrelax = 1;
 746       return 1;
 747     case option_no_link_relax:
 748       linkrelax = 0;
 749       return 1;
 750     case option_generics:
 751       as_warn (_("--generics is deprecated; use --transform instead"));
 752       return md_parse_option (option_transform, arg);
 753     case option_no_generics:
 754       as_warn (_("--no-generics is deprecated; use --no-transform instead"));
 755       return md_parse_option (option_no_transform, arg);
 756     case option_relax:
 757       as_warn (_("--relax is deprecated; use --transform instead"));
 758       return md_parse_option (option_transform, arg);
 759     case option_no_relax:
 760       as_warn (_("--no-relax is deprecated; use --no-transform instead"));
 761       return md_parse_option (option_no_transform, arg);
 762     case option_longcalls:
 763       directive_state[directive_longcalls] = TRUE;
 764       return 1;
 765     case option_no_longcalls:
 766       directive_state[directive_longcalls] = FALSE;
 767       return 1;
 768     case option_text_section_literals:
 769       use_literal_section = FALSE;
 770       return 1;
 771     case option_no_text_section_literals:
 772       use_literal_section = TRUE;
 773       return 1;
 774     case option_absolute_literals:
 775       if (!absolute_literals_supported)
 776         {
 777           as_fatal (_("--absolute-literals option not supported in this Xtensa configuration"));
 778           return 0;
 779         }
 780       directive_state[directive_absolute_literals] = TRUE;
 781       return 1;
 782     case option_no_absolute_literals:
 783       directive_state[directive_absolute_literals] = FALSE;
 784       return 1;
 785
 786     case option_workaround_a0_b_retw:
 787       workaround_a0_b_retw = TRUE;
 788       return 1;
 789     case option_no_workaround_a0_b_retw:
 790       workaround_a0_b_retw = FALSE;
 791       return 1;
 792     case option_workaround_b_j_loop_end:
 793       workaround_b_j_loop_end = TRUE;
 794       return 1;
 795     case option_no_workaround_b_j_loop_end:
 796       workaround_b_j_loop_end = FALSE;
 797       return 1;
 798
 799     case option_workaround_short_loop:
 800       workaround_short_loop = TRUE;
 801       return 1;
 802     case option_no_workaround_short_loop:
 803       workaround_short_loop = FALSE;
 804       return 1;
 805
 806     case option_workaround_all_short_loops:
 807       workaround_all_short_loops = TRUE;
 808       return 1;
 809     case option_no_workaround_all_short_loops:
 810       workaround_all_short_loops = FALSE;
 811       return 1;
 812
 813     case option_workaround_close_loop_end:
 814       workaround_close_loop_end = TRUE;
 815       return 1;
 816     case option_no_workaround_close_loop_end:
 817       workaround_close_loop_end = FALSE;
 818       return 1;
 819
 820     case option_no_workarounds:
 821       workaround_a0_b_retw = FALSE;
 822       workaround_b_j_loop_end = FALSE;
 823       workaround_short_loop = FALSE;
 824       workaround_all_short_loops = FALSE;
 825       workaround_close_loop_end = FALSE;
 826       return 1;
 827
 828     case option_align_targets:
 829       align_targets = TRUE;
 830       return 1;
 831     case option_no_align_targets:
 832       align_targets = FALSE;
 833       return 1;
 834
 835     case option_warn_unaligned_targets:
 836       warn_unaligned_branch_targets = TRUE;
 837       return 1;
 838
 839     case option_rename_section_name:
 840       build_section_rename (arg);
 841       return 1;
 842
 843     case 'Q':
 844       /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
 845          should be emitted or not.  FIXME: Not implemented.  */
 846       return 1;
 847
 848     case option_prefer_l32r:
 849       if (prefer_const16)
 850         as_fatal (_("prefer-l32r conflicts with prefer-const16"));
 851       prefer_l32r = 1;
 852       return 1;
 853
 854     case option_prefer_const16:
 855       if (prefer_l32r)
 856         as_fatal (_("prefer-const16 conflicts with prefer-l32r"));
 857       prefer_const16 = 1;
 858       return 1;
 859
 860     case option_target_hardware:
 861       {
 862         int earliest, latest = 0;
 863         if (*arg == 0 || *arg == '-')
 864           as_fatal (_("invalid target hardware version"));
 865
 866         earliest = strtol (arg, &arg, 0);
 867
 868         if (*arg == 0)
 869           latest = earliest;
 870         else if (*arg == '-')
 871           {
 872             if (*++arg == 0)
 873               as_fatal (_("invalid target hardware version"));
 874             latest = strtol (arg, &arg, 0);
 875           }
 876         if (*arg != 0)
 877           as_fatal (_("invalid target hardware version"));
 878
 879         xtensa_setup_hw_workarounds (earliest, latest);
 880         return 1;
 881       }
 882
 883     case option_transform:
 884       /* This option has no affect other than to use the defaults,
 885          which are already set.  */
 886       return 1;
 887
 888     case option_no_transform:
 889       /* This option turns off all transformations of any kind.
 890          However, because we want to preserve the state of other
 891          directives, we only change its own field.  Thus, before
 892          you perform any transformation, always check if transform
 893          is available.  If you use the functions we provide for this
 894          purpose, you will be ok.  */
 895       directive_state[directive_transform] = FALSE;
 896       return 1;
 897
 898     default:
 899       return 0;
 900     }
 901 }
 902
 903
 904 void
 905 md_show_usage (FILE *stream)
 906 {
 907   fputs ("\n\
 908 Xtensa options:\n\
 909   --[no-]text-section-literals\n\
 910                           [Do not] put literals in the text section\n\
 911   --[no-]absolute-literals\n\
 912                           [Do not] default to use non-PC-relative literals\n\
 913   --[no-]target-align     [Do not] try to align branch targets\n\
 914   --[no-]longcalls        [Do not] emit 32-bit call sequences\n\
 915   --[no-]transform        [Do not] transform instructions\n\
 916   --rename-section old=new Rename section 'old' to 'new'\n", stream);
 917 }
 918
 919 \f
 920 /* Functions related to the list of current label symbols.  */
 921
 922 static void
 923 xtensa_add_insn_label (symbolS *sym)
 924 {
 925   sym_list *l;
 926
 927   if (!free_insn_labels)
 928     l = (sym_list *) xmalloc (sizeof (sym_list));
 929   else
 930     {
 931       l = free_insn_labels;
 932       free_insn_labels = l->next;
 933     }
 934
 935   l->sym = sym;
 936   l->next = insn_labels;
 937   insn_labels = l;
 938 }
 939
 940
 941 static void
 942 xtensa_clear_insn_labels (void)
 943 {
 944   sym_list **pl;
 945
 946   for (pl = &free_insn_labels; *pl != NULL; pl = &(*pl)->next)
 947     ;
 948   *pl = insn_labels;
 949   insn_labels = NULL;
 950 }
 951
 952
 953 /* The "loops_ok" argument is provided to allow ignoring labels that
 954    define loop ends.  This fixes a bug where the NOPs to align a
 955    loop opcode were included in a previous zero-cost loop:
 956
 957    loop a0, loopend
 958      <loop1 body>
 959    loopend:
 960
 961    loop a2, loopend2
 962      <loop2 body>
 963
 964    would become:
 965
 966    loop a0, loopend
 967      <loop1 body>
 968      nop.n <===== bad!
 969    loopend:
 970
 971    loop a2, loopend2
 972      <loop2 body>
 973
 974    This argument is used to prevent moving the NOP to before the
 975    loop-end label, which is what you want in this special case.  */
 976
 977 static void
 978 xtensa_move_labels (fragS *new_frag, valueT new_offset, bfd_boolean loops_ok)
 979 {
 980   sym_list *lit;
 981
 982   for (lit = insn_labels; lit; lit = lit->next)
 983     {
 984       symbolS *lit_sym = lit->sym;
 985       if (loops_ok || ! symbol_get_tc (lit_sym)->is_loop_target)
 986         {
 987           S_SET_VALUE (lit_sym, new_offset);
 988           symbol_set_frag (lit_sym, new_frag);
 989         }
 990     }
 991 }
 992
 993 \f
 994 /* Directive data and functions.  */
 995
 996 typedef struct state_stackS_struct
 997 {
 998   directiveE directive;
 999   bfd_boolean negated;
1000   bfd_boolean old_state;
1001   const char *file;
1002   unsigned int line;
1003   const void *datum;
1004   struct state_stackS_struct *prev;
1005 } state_stackS;
1006
1007 state_stackS *directive_state_stack;
1008
1009 const pseudo_typeS md_pseudo_table[] =
1010 {
1011   { "align", s_align_bytes, 0 }, /* Defaulting is invalid (0).  */
1012   { "literal_position", xtensa_literal_position, 0 },
1013   { "frame", s_ignore, 0 },     /* Formerly used for STABS debugging.  */
1014   { "long", xtensa_elf_cons, 4 },
1015   { "word", xtensa_elf_cons, 4 },
1016   { "short", xtensa_elf_cons, 2 },
1017   { "begin", xtensa_begin_directive, 0 },
1018   { "end", xtensa_end_directive, 0 },
1019   { "loc", xtensa_dwarf2_directive_loc, 0 },
1020   { "literal", xtensa_literal_pseudo, 0 },
1021   { "frequency", xtensa_frequency_pseudo, 0 },
1022   { NULL, 0, 0 },
1023 };
1024
1025
1026 static bfd_boolean
1027 use_transform (void)
1028 {
1029   /* After md_end, you should be checking frag by frag, rather
1030      than state directives.  */
1031   assert (!past_xtensa_end);
1032   return directive_state[directive_transform];
1033 }
1034
1035
1036 static bfd_boolean
1037 do_align_targets (void)
1038 {
1039   /* Do not use this function after md_end; just look at align_targets
1040      instead.  There is no target-align directive, so alignment is either
1041      enabled for all frags or not done at all.  */
1042   assert (!past_xtensa_end);
1043   return align_targets && use_transform ();
1044 }
1045
1046
1047 static void
1048 directive_push (directiveE directive, bfd_boolean negated, const void *datum)
1049 {
1050   char *file;
1051   unsigned int line;
1052   state_stackS *stack = (state_stackS *) xmalloc (sizeof (state_stackS));
1053
1054   as_where (&file, &line);
1055
1056   stack->directive = directive;
1057   stack->negated = negated;
1058   stack->old_state = directive_state[directive];
1059   stack->file = file;
1060   stack->line = line;
1061   stack->datum = datum;
1062   stack->prev = directive_state_stack;
1063   directive_state_stack = stack;
1064
1065   directive_state[directive] = !negated;
1066 }
1067
1068
1069 static void
1070 directive_pop (directiveE *directive,
1071                bfd_boolean *negated,
1072                const char **file,
1073                unsigned int *line,
1074                const void **datum)
1075 {
1076   state_stackS *top = directive_state_stack;
1077
1078   if (!directive_state_stack)
1079     {
1080       as_bad (_("unmatched end directive"));
1081       *directive = directive_none;
1082       return;
1083     }
1084
1085   directive_state[directive_state_stack->directive] = top->old_state;
1086   *directive = top->directive;
1087   *negated = top->negated;
1088   *file = top->file;
1089   *line = top->line;
1090   *datum = top->datum;
1091   directive_state_stack = top->prev;
1092   free (top);
1093 }
1094
1095
1096 static void
1097 directive_balance (void)
1098 {
1099   while (directive_state_stack)
1100     {
1101       directiveE directive;
1102       bfd_boolean negated;
1103       const char *file;
1104       unsigned int line;
1105       const void *datum;
1106
1107       directive_pop (&directive, &negated, &file, &line, &datum);
1108       as_warn_where ((char *) file, line,
1109                      _(".begin directive with no matching .end directive"));
1110     }
1111 }
1112
1113
1114 static bfd_boolean
1115 inside_directive (directiveE dir)
1116 {
1117   state_stackS *top = directive_state_stack;
1118
1119   while (top && top->directive != dir)
1120     top = top->prev;
1121
1122   return (top != NULL);
1123 }
1124
1125
1126 static void
1127 get_directive (directiveE *directive, bfd_boolean *negated)
1128 {
1129   int len;
1130   unsigned i;
1131   char *directive_string;
1132
1133   if (strncmp (input_line_pointer, "no-", 3) != 0)
1134     *negated = FALSE;
1135   else
1136     {
1137       *negated = TRUE;
1138       input_line_pointer += 3;
1139     }
1140
1141   len = strspn (input_line_pointer,
1142                 "abcdefghijklmnopqrstuvwxyz_-/0123456789.");
1143
1144   /* This code is a hack to make .begin [no-][generics|relax] exactly
1145      equivalent to .begin [no-]transform.  We should remove it when
1146      we stop accepting those options.  */
1147
1148   if (strncmp (input_line_pointer, "generics", strlen ("generics")) == 0)
1149     {
1150       as_warn (_("[no-]generics is deprecated; use [no-]transform instead"));
1151       directive_string = "transform";
1152     }
1153   else if (strncmp (input_line_pointer, "relax", strlen ("relax")) == 0)
1154     {
1155       as_warn (_("[no-]relax is deprecated; use [no-]transform instead"));
1156       directive_string = "transform";
1157     }
1158   else
1159     directive_string = input_line_pointer;
1160
1161   for (i = 0; i < sizeof (directive_info) / sizeof (*directive_info); ++i)
1162     {
1163       if (strncmp (directive_string, directive_info[i].name, len) == 0)
1164         {
1165           input_line_pointer += len;
1166           *directive = (directiveE) i;
1167           if (*negated && !directive_info[i].can_be_negated)
1168             as_bad (_("directive %s cannot be negated"),
1169                     directive_info[i].name);
1170           return;
1171         }
1172     }
1173
1174   as_bad (_("unknown directive"));
1175   *directive = (directiveE) XTENSA_UNDEFINED;
1176 }
1177
1178
1179 static void
1180 xtensa_begin_directive (int ignore ATTRIBUTE_UNUSED)
1181 {
1182   directiveE directive;
1183   bfd_boolean negated;
1184   emit_state *state;
1185   int len;
1186   lit_state *ls;
1187
1188   get_directive (&directive, &negated);
1189   if (directive == (directiveE) XTENSA_UNDEFINED)
1190     {
1191       discard_rest_of_line ();
1192       return;
1193     }
1194
1195   if (cur_vinsn.inside_bundle)
1196     as_bad (_("directives are not valid inside bundles"));
1197
1198   switch (directive)
1199     {
1200     case directive_literal:
1201       if (!inside_directive (directive_literal))
1202         {
1203           /* Previous labels go with whatever follows this directive, not with
1204              the literal, so save them now.  */
1205           saved_insn_labels = insn_labels;
1206           insn_labels = NULL;
1207         }
1208       as_warn (_(".begin literal is deprecated; use .literal instead"));
1209       state = (emit_state *) xmalloc (sizeof (emit_state));
1210       xtensa_switch_to_literal_fragment (state);
1211       directive_push (directive_literal, negated, state);
1212       break;
1213
1214     case directive_literal_prefix:
1215       /* Have to flush pending output because a movi relaxed to an l32r
1216          might produce a literal.  */
1217       md_flush_pending_output ();
1218       /* Check to see if the current fragment is a literal
1219          fragment.  If it is, then this operation is not allowed.  */
1220       if (generating_literals)
1221         {
1222           as_bad (_("cannot set literal_prefix inside literal fragment"));
1223           return;
1224         }
1225
1226       /* Allocate the literal state for this section and push
1227          onto the directive stack.  */
1228       ls = xmalloc (sizeof (lit_state));
1229       assert (ls);
1230
1231       *ls = default_lit_sections;
1232
1233       directive_push (directive_literal_prefix, negated, ls);
1234
1235       /* Parse the new prefix from the input_line_pointer.  */
1236       SKIP_WHITESPACE ();
1237       len = strspn (input_line_pointer,
1238                     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1239                     "abcdefghijklmnopqrstuvwxyz_/0123456789.$");
1240
1241       /* Process the new prefix.  */
1242       xtensa_literal_prefix (input_line_pointer, len);
1243
1244       /* Skip the name in the input line.  */
1245       input_line_pointer += len;
1246       break;
1247
1248     case directive_freeregs:
1249       /* This information is currently unused, but we'll accept the statement
1250          and just discard the rest of the line.  This won't check the syntax,
1251          but it will accept every correct freeregs directive.  */
1252       input_line_pointer += strcspn (input_line_pointer, "\n");
1253       directive_push (directive_freeregs, negated, 0);
1254       break;
1255
1256     case directive_schedule:
1257       md_flush_pending_output ();
1258       frag_var (rs_fill, 0, 0, frag_now->fr_subtype,
1259                 frag_now->fr_symbol, frag_now->fr_offset, NULL);
1260       directive_push (directive_schedule, negated, 0);
1261       xtensa_set_frag_assembly_state (frag_now);
1262       break;
1263
1264     case directive_density:
1265       as_warn (_(".begin [no-]density is ignored"));
1266       break;
1267
1268     case directive_absolute_literals:
1269       md_flush_pending_output ();
1270       if (!absolute_literals_supported && !negated)
1271         {
1272           as_warn (_("Xtensa absolute literals option not supported; ignored"));
1273           break;
1274         }
1275       xtensa_set_frag_assembly_state (frag_now);
1276       directive_push (directive, negated, 0);
1277       break;
1278
1279     default:
1280       md_flush_pending_output ();
1281       xtensa_set_frag_assembly_state (frag_now);
1282       directive_push (directive, negated, 0);
1283       break;
1284     }
1285
1286   demand_empty_rest_of_line ();
1287 }
1288
1289
1290 static void
1291 xtensa_end_directive (int ignore ATTRIBUTE_UNUSED)
1292 {
1293   directiveE begin_directive, end_directive;
1294   bfd_boolean begin_negated, end_negated;
1295   const char *file;
1296   unsigned int line;
1297   emit_state *state;
1298   emit_state **state_ptr;
1299   lit_state *s;
1300
1301   if (cur_vinsn.inside_bundle)
1302     as_bad (_("directives are not valid inside bundles"));
1303
1304   get_directive (&end_directive, &end_negated);
1305
1306   md_flush_pending_output ();
1307
1308   switch (end_directive)
1309     {
1310     case (directiveE) XTENSA_UNDEFINED:
1311       discard_rest_of_line ();
1312       return;
1313
1314     case directive_density:
1315       as_warn (_(".end [no-]density is ignored"));
1316       demand_empty_rest_of_line ();
1317       break;
1318
1319     case directive_absolute_literals:
1320       if (!absolute_literals_supported && !end_negated)
1321         {
1322           as_warn (_("Xtensa absolute literals option not supported; ignored"));
1323           demand_empty_rest_of_line ();
1324           return;
1325         }
1326       break;
1327
1328     default:
1329       break;
1330     }
1331
1332   state_ptr = &state; /* use state_ptr to avoid type-punning warning */
1333   directive_pop (&begin_directive, &begin_negated, &file, &line,
1334                  (const void **) state_ptr);
1335
1336   if (begin_directive != directive_none)
1337     {
1338       if (begin_directive != end_directive || begin_negated != end_negated)
1339         {
1340           as_bad (_("does not match begin %s%s at %s:%d"),
1341                   begin_negated ? "no-" : "",
1342                   directive_info[begin_directive].name, file, line);
1343         }
1344       else
1345         {
1346           switch (end_directive)
1347             {
1348             case directive_literal:
1349               frag_var (rs_fill, 0, 0, 0, NULL, 0, NULL);
1350               xtensa_restore_emit_state (state);
1351               xtensa_set_frag_assembly_state (frag_now);
1352               free (state);
1353               if (!inside_directive (directive_literal))
1354                 {
1355                   /* Restore the list of current labels.  */
1356                   xtensa_clear_insn_labels ();
1357                   insn_labels = saved_insn_labels;
1358                 }
1359               break;
1360
1361             case directive_literal_prefix:
1362               /* Restore the default collection sections from saved state.  */
1363               s = (lit_state *) state;
1364               assert (s);
1365
1366               if (use_literal_section)
1367                 default_lit_sections = *s;
1368
1369               /* free the state storage */
1370               free (s);
1371               break;
1372
1373             case directive_schedule:
1374             case directive_freeregs:
1375               break;
1376
1377             default:
1378               xtensa_set_frag_assembly_state (frag_now);
1379               break;
1380             }
1381         }
1382     }
1383
1384   demand_empty_rest_of_line ();
1385 }
1386
1387
1388 /* Wrap dwarf2 functions so that we correctly support the .loc directive.  */
1389
1390 static bfd_boolean xtensa_loc_directive_seen = FALSE;
1391
1392 static void
1393 xtensa_dwarf2_directive_loc (int x)
1394 {
1395   xtensa_loc_directive_seen = TRUE;
1396   dwarf2_directive_loc (x);
1397 }
1398
1399
1400 static void
1401 xtensa_dwarf2_emit_insn (int size, struct dwarf2_line_info *loc)
1402 {
1403   if (debug_type != DEBUG_DWARF2 && ! xtensa_loc_directive_seen)
1404     return;
1405   xtensa_loc_directive_seen = FALSE;
1406   dwarf2_gen_line_info (frag_now_fix () - size, loc);
1407 }
1408
1409
1410 /* Place an aligned literal fragment at the current location.  */
1411
1412 static void
1413 xtensa_literal_position (int ignore ATTRIBUTE_UNUSED)
1414 {
1415   md_flush_pending_output ();
1416
1417   if (inside_directive (directive_literal))
1418     as_warn (_(".literal_position inside literal directive; ignoring"));
1419   xtensa_mark_literal_pool_location ();
1420
1421   demand_empty_rest_of_line ();
1422   xtensa_clear_insn_labels ();
1423 }
1424
1425
1426 /* Support .literal label, expr, ...  */
1427
1428 static void
1429 xtensa_literal_pseudo (int ignored ATTRIBUTE_UNUSED)
1430 {
1431   emit_state state;
1432   char *p, *base_name;
1433   char c;
1434   segT dest_seg;
1435
1436   if (inside_directive (directive_literal))
1437     {
1438       as_bad (_(".literal not allowed inside .begin literal region"));
1439       ignore_rest_of_line ();
1440       return;
1441     }
1442
1443   md_flush_pending_output ();
1444
1445   /* Previous labels go with whatever follows this directive, not with
1446      the literal, so save them now.  */
1447   saved_insn_labels = insn_labels;
1448   insn_labels = NULL;
1449
1450   /* If we are using text-section literals, then this is the right value... */
1451   dest_seg = now_seg;
1452
1453   base_name = input_line_pointer;
1454
1455   xtensa_switch_to_literal_fragment (&state);
1456
1457   /* ...but if we aren't using text-section-literals, then we
1458      need to put them in the section we just switched to.  */
1459   if (use_literal_section || directive_state[directive_absolute_literals])
1460     dest_seg = now_seg;
1461
1462   /* All literals are aligned to four-byte boundaries.  */
1463   frag_align (2, 0, 0);
1464   record_alignment (now_seg, 2);
1465
1466   c = get_symbol_end ();
1467   /* Just after name is now '\0'.  */
1468   p = input_line_pointer;
1469   *p = c;
1470   SKIP_WHITESPACE ();
1471
1472   if (*input_line_pointer != ',' && *input_line_pointer != ':')
1473     {
1474       as_bad (_("expected comma or colon after symbol name; "
1475                 "rest of line ignored"));
1476       ignore_rest_of_line ();
1477       xtensa_restore_emit_state (&state);
1478       return;
1479     }
1480   *p = 0;
1481
1482   colon (base_name);
1483
1484   *p = c;
1485   input_line_pointer++;         /* skip ',' or ':' */
1486
1487   xtensa_elf_cons (4);
1488
1489   xtensa_restore_emit_state (&state);
1490
1491   /* Restore the list of current labels.  */
1492   xtensa_clear_insn_labels ();
1493   insn_labels = saved_insn_labels;
1494 }
1495
1496
1497 static void
1498 xtensa_literal_prefix (char const *start, int len)
1499 {
1500   char *name, *linkonce_suffix;
1501   char *newname, *newname4;
1502   size_t linkonce_len;
1503
1504   /* Get a null-terminated copy of the name.  */
1505   name = xmalloc (len + 1);
1506   assert (name);
1507
1508   strncpy (name, start, len);
1509   name[len] = 0;
1510
1511   /* Allocate the sections (interesting note: the memory pointing to
1512      the name is actually used for the name by the new section). */
1513
1514   newname = xmalloc (len + strlen (".literal") + 1);
1515   newname4 = xmalloc (len + strlen (".lit4") + 1);
1516
1517   linkonce_len = sizeof (".gnu.linkonce.") - 1;
1518   if (strncmp (name, ".gnu.linkonce.", linkonce_len) == 0
1519       && (linkonce_suffix = strchr (name + linkonce_len, '.')) != 0)
1520     {
1521       strcpy (newname, ".gnu.linkonce.literal");
1522       strcpy (newname4, ".gnu.linkonce.lit4");
1523
1524       strcat (newname, linkonce_suffix);
1525       strcat (newname4, linkonce_suffix);
1526     }
1527   else
1528     {
1529       int suffix_pos = len;
1530
1531       /* If the section name ends with ".text", then replace that suffix
1532          instead of appending an additional suffix.  */
1533       if (len >= 5 && strcmp (name + len - 5, ".text") == 0)
1534         suffix_pos -= 5;
1535
1536       strcpy (newname, name);
1537       strcpy (newname4, name);
1538
1539       strcpy (newname + suffix_pos, ".literal");
1540       strcpy (newname4 + suffix_pos, ".lit4");
1541     }
1542
1543   /* Note that cache_literal_section does not create a segment if
1544      it already exists.  */
1545   default_lit_sections.lit_seg = NULL;
1546   default_lit_sections.lit4_seg = NULL;
1547
1548   /* Canonicalizing section names allows renaming literal
1549      sections to occur correctly.  */
1550   default_lit_sections.lit_seg_name = tc_canonicalize_symbol_name (newname);
1551   default_lit_sections.lit4_seg_name = tc_canonicalize_symbol_name (newname4);
1552
1553   free (name);
1554 }
1555
1556
1557 /* Support ".frequency branch_target_frequency fall_through_frequency".  */
1558
1559 static void
1560 xtensa_frequency_pseudo (int ignored ATTRIBUTE_UNUSED)
1561 {
1562   float fall_through_f, target_f;
1563
1564   fall_through_f = (float) strtod (input_line_pointer, &input_line_pointer);
1565   if (fall_through_f < 0)
1566     {
1567       as_bad (_("fall through frequency must be greater than 0"));
1568       ignore_rest_of_line ();
1569       return;
1570     }
1571
1572   target_f = (float) strtod (input_line_pointer, &input_line_pointer);
1573   if (target_f < 0)
1574     {
1575       as_bad (_("branch target frequency must be greater than 0"));
1576       ignore_rest_of_line ();
1577       return;
1578     }
1579
1580   set_subseg_freq (now_seg, now_subseg, target_f + fall_through_f, target_f);
1581
1582   demand_empty_rest_of_line ();
1583 }
1584
1585
1586 /* Like normal .long/.short/.word, except support @plt, etc.
1587    Clobbers input_line_pointer, checks end-of-line.  */
1588
1589 static void
1590 xtensa_elf_cons (int nbytes)
1591 {
1592   expressionS exp;
1593   bfd_reloc_code_real_type reloc;
1594
1595   md_flush_pending_output ();
1596
1597   if (cur_vinsn.inside_bundle)
1598     as_bad (_("directives are not valid inside bundles"));
1599
1600   if (is_it_end_of_statement ())
1601     {
1602       demand_empty_rest_of_line ();
1603       return;
1604     }
1605
1606   do
1607     {
1608       expression (&exp);
1609       if (exp.X_op == O_symbol
1610           && *input_line_pointer == '@'
1611           && ((reloc = xtensa_elf_suffix (&input_line_pointer, &exp))
1612               != BFD_RELOC_NONE))
1613         {
1614           reloc_howto_type *reloc_howto =
1615             bfd_reloc_type_lookup (stdoutput, reloc);
1616
1617           if (reloc == BFD_RELOC_UNUSED || !reloc_howto)
1618             as_bad (_("unsupported relocation"));
1619           else if ((reloc >= BFD_RELOC_XTENSA_SLOT0_OP
1620                     && reloc <= BFD_RELOC_XTENSA_SLOT14_OP)
1621                    || (reloc >= BFD_RELOC_XTENSA_SLOT0_ALT
1622                        && reloc <= BFD_RELOC_XTENSA_SLOT14_ALT))
1623             as_bad (_("opcode-specific %s relocation used outside "
1624                       "an instruction"), reloc_howto->name);
1625           else if (nbytes != (int) bfd_get_reloc_size (reloc_howto))
1626             as_bad (_("%s relocations do not fit in %d bytes"),
1627                     reloc_howto->name, nbytes);
1628           else
1629             {
1630               char *p = frag_more ((int) nbytes);
1631               xtensa_set_frag_assembly_state (frag_now);
1632               fix_new_exp (frag_now, p - frag_now->fr_literal,
1633                            nbytes, &exp, 0, reloc);
1634             }
1635         }
1636       else
1637         emit_expr (&exp, (unsigned int) nbytes);
1638     }
1639   while (*input_line_pointer++ == ',');
1640
1641   input_line_pointer--;         /* Put terminator back into stream.  */
1642   demand_empty_rest_of_line ();
1643 }
1644
1645 \f
1646 /* Parsing and Idiom Translation.  */
1647
1648 /* Parse @plt, etc. and return the desired relocation.  */
1649 static bfd_reloc_code_real_type
1650 xtensa_elf_suffix (char **str_p, expressionS *exp_p)
1651 {
1652   struct map_bfd
1653   {
1654     char *string;
1655     int length;
1656     bfd_reloc_code_real_type reloc;
1657   };
1658
1659   char ident[20];
1660   char *str = *str_p;
1661   char *str2;
1662   int ch;
1663   int len;
1664   struct map_bfd *ptr;
1665
1666 #define MAP(str,reloc) { str, sizeof (str) - 1, reloc }
1667
1668   static struct map_bfd mapping[] =
1669   {
1670     MAP ("l",           BFD_RELOC_LO16),
1671     MAP ("h",           BFD_RELOC_HI16),
1672     MAP ("plt",         BFD_RELOC_XTENSA_PLT),
1673     { (char *) 0, 0,    BFD_RELOC_UNUSED }
1674   };
1675
1676   if (*str++ != '@')
1677     return BFD_RELOC_NONE;
1678
1679   for (ch = *str, str2 = ident;
1680        (str2 < ident + sizeof (ident) - 1
1681         && (ISALNUM (ch) || ch == '@'));
1682        ch = *++str)
1683     {
1684       *str2++ = (ISLOWER (ch)) ? ch : TOLOWER (ch);
1685     }
1686
1687   *str2 = '\0';
1688   len = str2 - ident;
1689
1690   ch = ident[0];
1691   for (ptr = &mapping[0]; ptr->length > 0; ptr++)
1692     if (ch == ptr->string[0]
1693         && len == ptr->length
1694         && memcmp (ident, ptr->string, ptr->length) == 0)
1695       {
1696         /* Now check for "identifier@suffix+constant".  */
1697         if (*str == '-' || *str == '+')
1698           {
1699             char *orig_line = input_line_pointer;
1700             expressionS new_exp;
1701
1702             input_line_pointer = str;
1703             expression (&new_exp);
1704             if (new_exp.X_op == O_constant)
1705               {
1706                 exp_p->X_add_number += new_exp.X_add_number;
1707                 str = input_line_pointer;
1708               }
1709
1710             if (&input_line_pointer != str_p)
1711               input_line_pointer = orig_line;
1712           }
1713
1714         *str_p = str;
1715         return ptr->reloc;
1716       }
1717
1718   return BFD_RELOC_UNUSED;
1719 }
1720
1721
1722 static const char *
1723 expression_end (const char *name)
1724 {
1725   while (1)
1726     {
1727       switch (*name)
1728         {
1729         case '}':
1730         case ';':
1731         case '\0':
1732         case ',':
1733         case ':':
1734           return name;
1735         case ' ':
1736         case '\t':
1737           ++name;
1738           continue;
1739         default:
1740           return 0;
1741         }
1742     }
1743 }
1744
1745
1746 #define ERROR_REG_NUM ((unsigned) -1)
1747
1748 static unsigned
1749 tc_get_register (const char *prefix)
1750 {
1751   unsigned reg;
1752   const char *next_expr;
1753   const char *old_line_pointer;
1754
1755   SKIP_WHITESPACE ();
1756   old_line_pointer = input_line_pointer;
1757
1758   if (*input_line_pointer == '$')
1759     ++input_line_pointer;
1760
1761   /* Accept "sp" as a synonym for "a1".  */
1762   if (input_line_pointer[0] == 's' && input_line_pointer[1] == 'p'
1763       && expression_end (input_line_pointer + 2))
1764     {
1765       input_line_pointer += 2;
1766       return 1;  /* AR[1] */
1767     }
1768
1769   while (*input_line_pointer++ == *prefix++)
1770     ;
1771   --input_line_pointer;
1772   --prefix;
1773
1774   if (*prefix)
1775     {
1776       as_bad (_("bad register name: %s"), old_line_pointer);
1777       return ERROR_REG_NUM;
1778     }
1779
1780   if (!ISDIGIT ((unsigned char) *input_line_pointer))
1781     {
1782       as_bad (_("bad register number: %s"), input_line_pointer);
1783       return ERROR_REG_NUM;
1784     }
1785
1786   reg = 0;
1787
1788   while (ISDIGIT ((int) *input_line_pointer))
1789     reg = reg * 10 + *input_line_pointer++ - '0';
1790
1791   if (!(next_expr = expression_end (input_line_pointer)))
1792     {
1793       as_bad (_("bad register name: %s"), old_line_pointer);
1794       return ERROR_REG_NUM;
1795     }
1796
1797   input_line_pointer = (char *) next_expr;
1798
1799   return reg;
1800 }
1801
1802
1803 static void
1804 expression_maybe_register (xtensa_opcode opc, int opnd, expressionS *tok)
1805 {
1806   xtensa_isa isa = xtensa_default_isa;
1807
1808   /* Check if this is an immediate operand.  */
1809   if (xtensa_operand_is_register (isa, opc, opnd) == 0)
1810     {
1811       bfd_reloc_code_real_type reloc;
1812       segT t = expression (tok);
1813       if (t == absolute_section
1814           && xtensa_operand_is_PCrelative (isa, opc, opnd) == 1)
1815         {
1816           assert (tok->X_op == O_constant);
1817           tok->X_op = O_symbol;
1818           tok->X_add_symbol = &abs_symbol;
1819         }
1820
1821       if ((tok->X_op == O_constant || tok->X_op == O_symbol)
1822           && (reloc = xtensa_elf_suffix (&input_line_pointer, tok))
1823           && (reloc != BFD_RELOC_NONE))
1824         {
1825           switch (reloc)
1826             {
1827               default:
1828               case BFD_RELOC_UNUSED:
1829                 as_bad (_("unsupported relocation"));
1830                 break;
1831
1832               case BFD_RELOC_XTENSA_PLT:
1833                 tok->X_op = O_pltrel;
1834                 break;
1835
1836               case BFD_RELOC_LO16:
1837                 if (tok->X_op == O_constant)
1838                   tok->X_add_number &= 0xffff;
1839                 else
1840                   tok->X_op = O_lo16;
1841                 break;
1842
1843               case BFD_RELOC_HI16:
1844                 if (tok->X_op == O_constant)
1845                   tok->X_add_number = ((unsigned) tok->X_add_number) >> 16;
1846                 else
1847                   tok->X_op = O_hi16;
1848                 break;
1849             }
1850         }
1851     }
1852   else
1853     {
1854       xtensa_regfile opnd_rf = xtensa_operand_regfile (isa, opc, opnd);
1855       unsigned reg = tc_get_register (xtensa_regfile_shortname (isa, opnd_rf));
1856
1857       if (reg != ERROR_REG_NUM) /* Already errored */
1858         {
1859           uint32 buf = reg;
1860           if (xtensa_operand_encode (isa, opc, opnd, &buf))
1861             as_bad (_("register number out of range"));
1862         }
1863
1864       tok->X_op = O_register;
1865       tok->X_add_symbol = 0;
1866       tok->X_add_number = reg;
1867     }
1868 }
1869
1870
1871 /* Split up the arguments for an opcode or pseudo-op.  */
1872
1873 static int
1874 tokenize_arguments (char **args, char *str)
1875 {
1876   char *old_input_line_pointer;
1877   bfd_boolean saw_comma = FALSE;
1878   bfd_boolean saw_arg = FALSE;
1879   bfd_boolean saw_colon = FALSE;
1880   int num_args = 0;
1881   char *arg_end, *arg;
1882   int arg_len;
1883
1884   /* Save and restore input_line_pointer around this function.  */
1885   old_input_line_pointer = input_line_pointer;
1886   input_line_pointer = str;
1887
1888   while (*input_line_pointer)
1889     {
1890       SKIP_WHITESPACE ();
1891       switch (*input_line_pointer)
1892         {
1893         case '\0':
1894         case '}':
1895           goto fini;
1896
1897         case ':':
1898           input_line_pointer++;
1899           if (saw_comma || saw_colon || !saw_arg)
1900             goto err;
1901           saw_colon = TRUE;
1902           break;
1903
1904         case ',':
1905           input_line_pointer++;
1906           if (saw_comma || saw_colon || !saw_arg)
1907             goto err;
1908           saw_comma = TRUE;
1909           break;
1910
1911         default:
1912           if (!saw_comma && !saw_colon && saw_arg)
1913             goto err;
1914
1915           arg_end = input_line_pointer + 1;
1916           while (!expression_end (arg_end))
1917             arg_end += 1;
1918
1919           arg_len = arg_end - input_line_pointer;
1920           arg = (char *) xmalloc ((saw_colon ? 1 : 0) + arg_len + 1);
1921           args[num_args] = arg;
1922
1923           if (saw_colon)
1924             *arg++ = ':';
1925           strncpy (arg, input_line_pointer, arg_len);
1926           arg[arg_len] = '\0';
1927
1928           input_line_pointer = arg_end;
1929           num_args += 1;
1930           saw_comma = FALSE;
1931           saw_colon = FALSE;
1932           saw_arg = TRUE;
1933           break;
1934         }
1935     }
1936
1937 fini:
1938   if (saw_comma || saw_colon)
1939     goto err;
1940   input_line_pointer = old_input_line_pointer;
1941   return num_args;
1942
1943 err:
1944   if (saw_comma)
1945     as_bad (_("extra comma"));
1946   else if (saw_colon)
1947     as_bad (_("extra colon"));
1948   else if (!saw_arg)
1949     as_bad (_("missing argument"));
1950   else
1951     as_bad (_("missing comma or colon"));
1952   input_line_pointer = old_input_line_pointer;
1953   return -1;
1954 }
1955
1956
1957 /* Parse the arguments to an opcode.  Return TRUE on error.  */
1958
1959 static bfd_boolean
1960 parse_arguments (TInsn *insn, int num_args, char **arg_strings)
1961 {
1962   expressionS *tok, *last_tok;
1963   xtensa_opcode opcode = insn->opcode;
1964   bfd_boolean had_error = TRUE;
1965   xtensa_isa isa = xtensa_default_isa;
1966   int n, num_regs = 0;
1967   int opcode_operand_count;
1968   int opnd_cnt, last_opnd_cnt;
1969   unsigned int next_reg = 0;
1970   char *old_input_line_pointer;
1971
1972   if (insn->insn_type == ITYPE_LITERAL)
1973     opcode_operand_count = 1;
1974   else
1975     opcode_operand_count = xtensa_opcode_num_operands (isa, opcode);
1976
1977   tok = insn->tok;
1978   memset (tok, 0, sizeof (*tok) * MAX_INSN_ARGS);
1979
1980   /* Save and restore input_line_pointer around this function.  */
1981   old_input_line_pointer = input_line_pointer;
1982
1983   last_tok = 0;
1984   last_opnd_cnt = -1;
1985   opnd_cnt = 0;
1986
1987   /* Skip invisible operands.  */
1988   while (xtensa_operand_is_visible (isa, opcode, opnd_cnt) == 0)
1989     {
1990       opnd_cnt += 1;
1991       tok++;
1992     }
1993
1994   for (n = 0; n < num_args; n++)
1995     {
1996       input_line_pointer = arg_strings[n];
1997       if (*input_line_pointer == ':')
1998         {
1999           xtensa_regfile opnd_rf;
2000           input_line_pointer++;
2001           if (num_regs == 0)
2002             goto err;
2003           assert (opnd_cnt > 0);
2004           num_regs--;
2005           opnd_rf = xtensa_operand_regfile (isa, opcode, last_opnd_cnt);
2006           if (next_reg
2007               != tc_get_register (xtensa_regfile_shortname (isa, opnd_rf)))
2008             as_warn (_("incorrect register number, ignoring"));
2009           next_reg++;
2010         }
2011       else
2012         {
2013           if (opnd_cnt >= opcode_operand_count)
2014             {
2015               as_warn (_("too many arguments"));
2016               goto err;
2017             }
2018           assert (opnd_cnt < MAX_INSN_ARGS);
2019
2020           expression_maybe_register (opcode, opnd_cnt, tok);
2021           next_reg = tok->X_add_number + 1;
2022
2023           if (tok->X_op == O_illegal || tok->X_op == O_absent)
2024             goto err;
2025           if (xtensa_operand_is_register (isa, opcode, opnd_cnt) == 1)
2026             {
2027               num_regs = xtensa_operand_num_regs (isa, opcode, opnd_cnt) - 1;
2028               /* minus 1 because we are seeing one right now */
2029             }
2030           else
2031             num_regs = 0;
2032
2033           last_tok = tok;
2034           last_opnd_cnt = opnd_cnt;
2035
2036           do
2037             {
2038               opnd_cnt += 1;
2039               tok++;
2040             }
2041           while (xtensa_operand_is_visible (isa, opcode, opnd_cnt) == 0);
2042         }
2043     }
2044
2045   if (num_regs > 0 && ((int) next_reg != last_tok->X_add_number + 1))
2046     goto err;
2047
2048   insn->ntok = tok - insn->tok;
2049   had_error = FALSE;
2050
2051  err:
2052   input_line_pointer = old_input_line_pointer;
2053   return had_error;
2054 }
2055
2056
2057 static int
2058 get_invisible_operands (TInsn *insn)
2059 {
2060   xtensa_isa isa = xtensa_default_isa;
2061   static xtensa_insnbuf slotbuf = NULL;
2062   xtensa_format fmt;
2063   xtensa_opcode opc = insn->opcode;
2064   int slot, opnd, fmt_found;
2065   unsigned val;
2066
2067   if (!slotbuf)
2068     slotbuf = xtensa_insnbuf_alloc (isa);
2069
2070   /* Find format/slot where this can be encoded.  */
2071   fmt_found = 0;
2072   slot = 0;
2073   for (fmt = 0; fmt < xtensa_isa_num_formats (isa); fmt++)
2074     {
2075       for (slot = 0; slot < xtensa_format_num_slots (isa, fmt); slot++)
2076         {
2077           if (xtensa_opcode_encode (isa, fmt, slot, slotbuf, opc) == 0)
2078             {
2079               fmt_found = 1;
2080               break;
2081             }
2082         }
2083       if (fmt_found) break;
2084     }
2085
2086   if (!fmt_found)
2087     {
2088       as_bad (_("cannot encode opcode \"%s\""), xtensa_opcode_name (isa, opc));
2089       return -1;
2090     }
2091
2092   /* First encode all the visible operands
2093      (to deal with shared field operands).  */
2094   for (opnd = 0; opnd < insn->ntok; opnd++)
2095     {
2096       if (xtensa_operand_is_visible (isa, opc, opnd) == 1
2097           && (insn->tok[opnd].X_op == O_register
2098               || insn->tok[opnd].X_op == O_constant))
2099         {
2100           val = insn->tok[opnd].X_add_number;
2101           xtensa_operand_encode (isa, opc, opnd, &val);
2102           xtensa_operand_set_field (isa, opc, opnd, fmt, slot, slotbuf, val);
2103         }
2104     }
2105
2106   /* Then pull out the values for the invisible ones.  */
2107   for (opnd = 0; opnd < insn->ntok; opnd++)
2108     {
2109       if (xtensa_operand_is_visible (isa, opc, opnd) == 0)
2110         {
2111           xtensa_operand_get_field (isa, opc, opnd, fmt, slot, slotbuf, &val);
2112           xtensa_operand_decode (isa, opc, opnd, &val);
2113           insn->tok[opnd].X_add_number = val;
2114           if (xtensa_operand_is_register (isa, opc, opnd) == 1)
2115             insn->tok[opnd].X_op = O_register;
2116           else
2117             insn->tok[opnd].X_op = O_constant;
2118         }
2119     }
2120
2121   return 0;
2122 }
2123
2124
2125 static void
2126 xg_reverse_shift_count (char **cnt_argp)
2127 {
2128   char *cnt_arg, *new_arg;
2129   cnt_arg = *cnt_argp;
2130
2131   /* replace the argument with "31-(argument)" */
2132   new_arg = (char *) xmalloc (strlen (cnt_arg) + 6);
2133   sprintf (new_arg, "31-(%s)", cnt_arg);
2134
2135   free (cnt_arg);
2136   *cnt_argp = new_arg;
2137 }
2138
2139
2140 /* If "arg" is a constant expression, return non-zero with the value
2141    in *valp.  */
2142
2143 static int
2144 xg_arg_is_constant (char *arg, offsetT *valp)
2145 {
2146   expressionS exp;
2147   char *save_ptr = input_line_pointer;
2148
2149   input_line_pointer = arg;
2150   expression (&exp);
2151   input_line_pointer = save_ptr;
2152
2153   if (exp.X_op == O_constant)
2154     {
2155       *valp = exp.X_add_number;
2156       return 1;
2157     }
2158
2159   return 0;
2160 }
2161
2162
2163 static void
2164 xg_replace_opname (char **popname, char *newop)
2165 {
2166   free (*popname);
2167   *popname = (char *) xmalloc (strlen (newop) + 1);
2168   strcpy (*popname, newop);
2169 }
2170
2171
2172 static int
2173 xg_check_num_args (int *pnum_args,
2174                    int expected_num,
2175                    char *opname,
2176                    char **arg_strings)
2177 {
2178   int num_args = *pnum_args;
2179
2180   if (num_args < expected_num)
2181     {
2182       as_bad (_("not enough operands (%d) for '%s'; expected %d"),
2183               num_args, opname, expected_num);
2184       return -1;
2185     }
2186
2187   if (num_args > expected_num)
2188     {
2189       as_warn (_("too many operands (%d) for '%s'; expected %d"),
2190                num_args, opname, expected_num);
2191       while (num_args-- > expected_num)
2192         {
2193           free (arg_strings[num_args]);
2194           arg_strings[num_args] = 0;
2195         }
2196       *pnum_args = expected_num;
2197       return -1;
2198     }
2199
2200   return 0;
2201 }
2202
2203
2204 /* If the register is not specified as part of the opcode,
2205    then get it from the operand and move it to the opcode.  */
2206
2207 static int
2208 xg_translate_sysreg_op (char **popname, int *pnum_args, char **arg_strings)
2209 {
2210   xtensa_isa isa = xtensa_default_isa;
2211   xtensa_sysreg sr;
2212   char *opname, *new_opname;
2213   const char *sr_name;
2214   int is_user, is_write;
2215   bfd_boolean has_underbar = FALSE;
2216
2217   opname = *popname;
2218   if (*opname == '_')
2219     {
2220       has_underbar = TRUE;
2221       opname += 1;
2222     }
2223   is_user = (opname[1] == 'u');
2224   is_write = (opname[0] == 'w');
2225
2226   /* Opname == [rw]ur or [rwx]sr... */
2227
2228   if (xg_check_num_args (pnum_args, 2, opname, arg_strings))
2229     return -1;
2230
2231   /* Check if the argument is a symbolic register name.  */
2232   sr = xtensa_sysreg_lookup_name (isa, arg_strings[1]);
2233   /* Handle WSR to "INTSET" as a special case.  */
2234   if (sr == XTENSA_UNDEFINED && is_write && !is_user
2235       && !strcasecmp (arg_strings[1], "intset"))
2236     sr = xtensa_sysreg_lookup_name (isa, "interrupt");
2237   if (sr == XTENSA_UNDEFINED
2238       || (xtensa_sysreg_is_user (isa, sr) == 1) != is_user)
2239     {
2240       /* Maybe it's a register number.... */
2241       offsetT val;
2242       if (!xg_arg_is_constant (arg_strings[1], &val))
2243         {
2244           as_bad (_("invalid register '%s' for '%s' instruction"),
2245                   arg_strings[1], opname);
2246           return -1;
2247         }
2248       sr = xtensa_sysreg_lookup (isa, val, is_user);
2249       if (sr == XTENSA_UNDEFINED)
2250         {
2251           as_bad (_("invalid register number (%ld) for '%s' instruction"),
2252                   (long) val, opname);
2253           return -1;
2254         }
2255     }
2256
2257   /* Remove the last argument, which is now part of the opcode.  */
2258   free (arg_strings[1]);
2259   arg_strings[1] = 0;
2260   *pnum_args = 1;
2261
2262   /* Translate the opcode.  */
2263   sr_name = xtensa_sysreg_name (isa, sr);
2264   /* Another special case for "WSR.INTSET"....  */
2265   if (is_write && !is_user && !strcasecmp ("interrupt", sr_name))
2266     sr_name = "intset";
2267   new_opname = (char *) xmalloc (strlen (sr_name) + 6);
2268   sprintf (new_opname, "%s%s.%s", (has_underbar ? "_" : ""),
2269            *popname, sr_name);
2270   free (*popname);
2271   *popname = new_opname;
2272
2273   return 0;
2274 }
2275
2276
2277 static int
2278 xtensa_translate_old_userreg_ops (char **popname)
2279 {
2280   xtensa_isa isa = xtensa_default_isa;
2281   xtensa_sysreg sr;
2282   char *opname, *new_opname;
2283   const char *sr_name;
2284   bfd_boolean has_underbar = FALSE;
2285
2286   opname = *popname;
2287   if (opname[0] == '_')
2288     {
2289       has_underbar = TRUE;
2290       opname += 1;
2291     }
2292
2293   sr = xtensa_sysreg_lookup_name (isa, opname + 1);
2294   if (sr != XTENSA_UNDEFINED)
2295     {
2296       /* The new default name ("nnn") is different from the old default
2297          name ("URnnn").  The old default is handled below, and we don't
2298          want to recognize [RW]nnn, so do nothing if the name is the (new)
2299          default.  */
2300       static char namebuf[10];
2301       sprintf (namebuf, "%d", xtensa_sysreg_number (isa, sr));
2302       if (strcmp (namebuf, opname + 1) == 0)
2303         return 0;
2304     }
2305   else
2306     {
2307       offsetT val;
2308       char *end;
2309
2310       /* Only continue if the reg name is "URnnn".  */
2311       if (opname[1] != 'u' || opname[2] != 'r')
2312         return 0;
2313       val = strtoul (opname + 3, &end, 10);
2314       if (*end != '\0')
2315         return 0;
2316
2317       sr = xtensa_sysreg_lookup (isa, val, 1);
2318       if (sr == XTENSA_UNDEFINED)
2319         {
2320           as_bad (_("invalid register number (%ld) for '%s'"),
2321                   (long) val, opname);
2322           return -1;
2323         }
2324     }
2325
2326   /* Translate the opcode.  */
2327   sr_name = xtensa_sysreg_name (isa, sr);
2328   new_opname = (char *) xmalloc (strlen (sr_name) + 6);
2329   sprintf (new_opname, "%s%cur.%s", (has_underbar ? "_" : ""),
2330            opname[0], sr_name);
2331   free (*popname);
2332   *popname = new_opname;
2333
2334   return 0;
2335 }
2336
2337
2338 static int
2339 xtensa_translate_zero_immed (char *old_op,
2340                              char *new_op,
2341                              char **popname,
2342                              int *pnum_args,
2343                              char **arg_strings)
2344 {
2345   char *opname;
2346   offsetT val;
2347
2348   opname = *popname;
2349   assert (opname[0] != '_');
2350
2351   if (strcmp (opname, old_op) != 0)
2352     return 0;
2353
2354   if (xg_check_num_args (pnum_args, 3, opname, arg_strings))
2355     return -1;
2356   if (xg_arg_is_constant (arg_strings[1], &val) && val == 0)
2357     {
2358       xg_replace_opname (popname, new_op);
2359       free (arg_strings[1]);
2360       arg_strings[1] = arg_strings[2];
2361       arg_strings[2] = 0;
2362       *pnum_args = 2;
2363     }
2364
2365   return 0;
2366 }
2367
2368
2369 /* If the instruction is an idiom (i.e., a built-in macro), translate it.
2370    Returns non-zero if an error was found.  */
2371
2372 static int
2373 xg_translate_idioms (char **popname, int *pnum_args, char **arg_strings)
2374 {
2375   char *opname = *popname;
2376   bfd_boolean has_underbar = FALSE;
2377
2378   if (cur_vinsn.inside_bundle)
2379     return 0;
2380
2381   if (*opname == '_')
2382     {
2383       has_underbar = TRUE;
2384       opname += 1;
2385     }
2386
2387   if (strcmp (opname, "mov") == 0)
2388     {
2389       if (use_transform () && !has_underbar && density_supported)
2390         xg_replace_opname (popname, "mov.n");
2391       else
2392         {
2393           if (xg_check_num_args (pnum_args, 2, opname, arg_strings))
2394             return -1;
2395           xg_replace_opname (popname, (has_underbar ? "_or" : "or"));
2396           arg_strings[2] = (char *) xmalloc (strlen (arg_strings[1]) + 1);
2397           strcpy (arg_strings[2], arg_strings[1]);
2398           *pnum_args = 3;
2399         }
2400       return 0;
2401     }
2402
2403   if (strcmp (opname, "bbsi.l") == 0)
2404     {
2405       if (xg_check_num_args (pnum_args, 3, opname, arg_strings))
2406         return -1;
2407       xg_replace_opname (popname, (has_underbar ? "_bbsi" : "bbsi"));
2408       if (target_big_endian)
2409         xg_reverse_shift_count (&arg_strings[1]);
2410       return 0;
2411     }
2412
2413   if (strcmp (opname, "bbci.l") == 0)
2414     {
2415       if (xg_check_num_args (pnum_args, 3, opname, arg_strings))
2416         return -1;
2417       xg_replace_opname (popname, (has_underbar ? "_bbci" : "bbci"));
2418       if (target_big_endian)
2419         xg_reverse_shift_count (&arg_strings[1]);
2420       return 0;
2421     }
2422
2423   if (xtensa_nop_opcode == XTENSA_UNDEFINED
2424       && strcmp (opname, "nop") == 0)
2425     {
2426       if (use_transform () && !has_underbar && density_supported)
2427         xg_replace_opname (popname, "nop.n");
2428       else
2429         {
2430           if (xg_check_num_args (pnum_args, 0, opname, arg_strings))
2431             return -1;
2432           xg_replace_opname (popname, (has_underbar ? "_or" : "or"));
2433           arg_strings[0] = (char *) xmalloc (3);
2434           arg_strings[1] = (char *) xmalloc (3);
2435           arg_strings[2] = (char *) xmalloc (3);
2436           strcpy (arg_strings[0], "a1");
2437           strcpy (arg_strings[1], "a1");
2438           strcpy (arg_strings[2], "a1");
2439           *pnum_args = 3;
2440         }
2441       return 0;
2442     }
2443
2444   /* Recognize [RW]UR and [RWX]SR.  */
2445   if ((((opname[0] == 'r' || opname[0] == 'w')
2446         && (opname[1] == 'u' || opname[1] == 's'))
2447        || (opname[0] == 'x' && opname[1] == 's'))
2448       && opname[2] == 'r'
2449       && opname[3] == '\0')
2450     return xg_translate_sysreg_op (popname, pnum_args, arg_strings);
2451
2452   /* Backward compatibility for RUR and WUR: Recognize [RW]UR<nnn> and
2453      [RW]<name> if <name> is the non-default name of a user register.  */
2454   if ((opname[0] == 'r' || opname[0] == 'w')
2455       && xtensa_opcode_lookup (xtensa_default_isa, opname) == XTENSA_UNDEFINED)
2456     return xtensa_translate_old_userreg_ops (popname);
2457
2458   /* Relax branches that don't allow comparisons against an immediate value
2459      of zero to the corresponding branches with implicit zero immediates.  */
2460   if (!has_underbar && use_transform ())
2461     {
2462       if (xtensa_translate_zero_immed ("bnei", "bnez", popname,
2463                                        pnum_args, arg_strings))
2464         return -1;
2465
2466       if (xtensa_translate_zero_immed ("beqi", "beqz", popname,
2467                                        pnum_args, arg_strings))
2468         return -1;
2469
2470       if (xtensa_translate_zero_immed ("bgei", "bgez", popname,
2471                                        pnum_args, arg_strings))
2472         return -1;
2473
2474       if (xtensa_translate_zero_immed ("blti", "bltz", popname,
2475                                        pnum_args, arg_strings))
2476         return -1;
2477     }
2478
2479   return 0;
2480 }
2481
2482 \f
2483 /* Functions for dealing with the Xtensa ISA.  */
2484
2485 /* Currently the assembler only allows us to use a single target per
2486    fragment.  Because of this, only one operand for a given
2487    instruction may be symbolic.  If there is a PC-relative operand,
2488    the last one is chosen.  Otherwise, the result is the number of the
2489    last immediate operand, and if there are none of those, we fail and
2490    return -1.  */
2491
2492 static int
2493 get_relaxable_immed (xtensa_opcode opcode)
2494 {
2495   int last_immed = -1;
2496   int noperands, opi;
2497
2498   if (opcode == XTENSA_UNDEFINED)
2499     return -1;
2500
2501   noperands = xtensa_opcode_num_operands (xtensa_default_isa, opcode);
2502   for (opi = noperands - 1; opi >= 0; opi--)
2503     {
2504       if (xtensa_operand_is_visible (xtensa_default_isa, opcode, opi) == 0)
2505         continue;
2506       if (xtensa_operand_is_PCrelative (xtensa_default_isa, opcode, opi) == 1)
2507         return opi;
2508       if (last_immed == -1
2509           && xtensa_operand_is_register (xtensa_default_isa, opcode, opi) == 0)
2510         last_immed = opi;
2511     }
2512   return last_immed;
2513 }
2514
2515
2516 static xtensa_opcode
2517 get_opcode_from_buf (const char *buf, int slot)
2518 {
2519   static xtensa_insnbuf insnbuf = NULL;
2520   static xtensa_insnbuf slotbuf = NULL;
2521   xtensa_isa isa = xtensa_default_isa;
2522   xtensa_format fmt;
2523
2524   if (!insnbuf)
2525     {
2526       insnbuf = xtensa_insnbuf_alloc (isa);
2527       slotbuf = xtensa_insnbuf_alloc (isa);
2528     }
2529
2530   xtensa_insnbuf_from_chars (isa, insnbuf, (const unsigned char *) buf, 0);
2531   fmt = xtensa_format_decode (isa, insnbuf);
2532   if (fmt == XTENSA_UNDEFINED)
2533     return XTENSA_UNDEFINED;
2534
2535   if (slot >= xtensa_format_num_slots (isa, fmt))
2536     return XTENSA_UNDEFINED;
2537
2538   xtensa_format_get_slot (isa, fmt, slot, insnbuf, slotbuf);
2539   return xtensa_opcode_decode (isa, fmt, slot, slotbuf);
2540 }
2541
2542
2543 #ifdef TENSILICA_DEBUG
2544
2545 /* For debugging, print out the mapping of opcode numbers to opcodes.  */
2546
2547 static void
2548 xtensa_print_insn_table (void)
2549 {
2550   int num_opcodes, num_operands;
2551   xtensa_opcode opcode;
2552   xtensa_isa isa = xtensa_default_isa;
2553
2554   num_opcodes = xtensa_isa_num_opcodes (xtensa_default_isa);
2555   for (opcode = 0; opcode < num_opcodes; opcode++)
2556     {
2557       int opn;
2558       fprintf (stderr, "%d: %s: ", opcode, xtensa_opcode_name (isa, opcode));
2559       num_operands = xtensa_opcode_num_operands (isa, opcode);
2560       for (opn = 0; opn < num_operands; opn++)
2561         {
2562           if (xtensa_operand_is_visible (isa, opcode, opn) == 0)
2563             continue;
2564           if (xtensa_operand_is_register (isa, opcode, opn) == 1)
2565             {
2566               xtensa_regfile opnd_rf =
2567                 xtensa_operand_regfile (isa, opcode, opn);
2568               fprintf (stderr, "%s ", xtensa_regfile_shortname (isa, opnd_rf));
2569             }
2570           else if (xtensa_operand_is_PCrelative (isa, opcode, opn) == 1)
2571             fputs ("[lLr] ", stderr);
2572           else
2573             fputs ("i ", stderr);
2574         }
2575       fprintf (stderr, "\n");
2576     }
2577 }
2578
2579
2580 static void
2581 print_vliw_insn (xtensa_insnbuf vbuf)
2582 {
2583   xtensa_isa isa = xtensa_default_isa;
2584   xtensa_format f = xtensa_format_decode (isa, vbuf);
2585   xtensa_insnbuf sbuf = xtensa_insnbuf_alloc (isa);
2586   int op;
2587
2588   fprintf (stderr, "format = %d\n", f);
2589
2590   for (op = 0; op < xtensa_format_num_slots (isa, f); op++)
2591     {
2592       xtensa_opcode opcode;
2593       const char *opname;
2594       int operands;
2595
2596       xtensa_format_get_slot (isa, f, op, vbuf, sbuf);
2597       opcode = xtensa_opcode_decode (isa, f, op, sbuf);
2598       opname = xtensa_opcode_name (isa, opcode);
2599
2600       fprintf (stderr, "op in slot %i is %s;\n", op, opname);
2601       fprintf (stderr, "   operands = ");
2602       for (operands = 0;
2603            operands < xtensa_opcode_num_operands (isa, opcode);
2604            operands++)
2605         {
2606           unsigned int val;
2607           if (xtensa_operand_is_visible (isa, opcode, operands) == 0)
2608             continue;
2609           xtensa_operand_get_field (isa, opcode, operands, f, op, sbuf, &val);
2610           xtensa_operand_decode (isa, opcode, operands, &val);
2611           fprintf (stderr, "%d ", val);
2612         }
2613       fprintf (stderr, "\n");
2614     }
2615   xtensa_insnbuf_free (isa, sbuf);
2616 }
2617
2618 #endif /* TENSILICA_DEBUG */
2619
2620
2621 static bfd_boolean
2622 is_direct_call_opcode (xtensa_opcode opcode)
2623 {
2624   xtensa_isa isa = xtensa_default_isa;
2625   int n, num_operands;
2626
2627   if (xtensa_opcode_is_call (isa, opcode) == 0)
2628     return FALSE;
2629
2630   num_operands = xtensa_opcode_num_operands (isa, opcode);
2631   for (n = 0; n < num_operands; n++)
2632     {
2633       if (xtensa_operand_is_register (isa, opcode, n) == 0
2634           && xtensa_operand_is_PCrelative (isa, opcode, n) == 1)
2635         return TRUE;
2636     }
2637   return FALSE;
2638 }
2639
2640
2641 /* Convert from BFD relocation type code to slot and operand number.
2642    Returns non-zero on failure.  */
2643
2644 static int
2645 decode_reloc (bfd_reloc_code_real_type reloc, int *slot, bfd_boolean *is_alt)
2646 {
2647   if (reloc >= BFD_RELOC_XTENSA_SLOT0_OP
2648       && reloc <= BFD_RELOC_XTENSA_SLOT14_OP)
2649     {
2650       *slot = reloc - BFD_RELOC_XTENSA_SLOT0_OP;
2651       *is_alt = FALSE;
2652     }
2653   else if (reloc >= BFD_RELOC_XTENSA_SLOT0_ALT
2654       && reloc <= BFD_RELOC_XTENSA_SLOT14_ALT)
2655     {
2656       *slot = reloc - BFD_RELOC_XTENSA_SLOT0_ALT;
2657       *is_alt = TRUE;
2658     }
2659   else
2660     return -1;
2661
2662   return 0;
2663 }
2664
2665
2666 /* Convert from slot number to BFD relocation type code for the
2667    standard PC-relative relocations.  Return BFD_RELOC_NONE on
2668    failure.  */
2669
2670 static bfd_reloc_code_real_type
2671 encode_reloc (int slot)
2672 {
2673   if (slot < 0 || slot > 14)
2674     return BFD_RELOC_NONE;
2675
2676   return BFD_RELOC_XTENSA_SLOT0_OP + slot;
2677 }
2678
2679
2680 /* Convert from slot numbers to BFD relocation type code for the
2681    "alternate" relocations.  Return BFD_RELOC_NONE on failure.  */
2682
2683 static bfd_reloc_code_real_type
2684 encode_alt_reloc (int slot)
2685 {
2686   if (slot < 0 || slot > 14)
2687     return BFD_RELOC_NONE;
2688
2689   return BFD_RELOC_XTENSA_SLOT0_ALT + slot;
2690 }
2691
2692
2693 static void
2694 xtensa_insnbuf_set_operand (xtensa_insnbuf slotbuf,
2695                             xtensa_format fmt,
2696                             int slot,
2697                             xtensa_opcode opcode,
2698                             int operand,
2699                             uint32 value,
2700                             const char *file,
2701                             unsigned int line)
2702 {
2703   uint32 valbuf = value;
2704
2705   if (xtensa_operand_encode (xtensa_default_isa, opcode, operand, &valbuf))
2706     {
2707       if (xtensa_operand_is_PCrelative (xtensa_default_isa, opcode, operand)
2708           == 1)
2709         as_bad_where ((char *) file, line,
2710                       _("operand %u is out of range for '%s'"), value,
2711                       xtensa_opcode_name (xtensa_default_isa, opcode));
2712       else
2713         as_bad_where ((char *) file, line,
2714                       _("operand %u is invalid for '%s'"), value,
2715                       xtensa_opcode_name (xtensa_default_isa, opcode));
2716       return;
2717     }
2718
2719   xtensa_operand_set_field (xtensa_default_isa, opcode, operand, fmt, slot,
2720                             slotbuf, valbuf);
2721 }
2722
2723
2724 static uint32
2725 xtensa_insnbuf_get_operand (xtensa_insnbuf slotbuf,
2726                             xtensa_format fmt,
2727                             int slot,
2728                             xtensa_opcode opcode,
2729                             int opnum)
2730 {
2731   uint32 val = 0;
2732   (void) xtensa_operand_get_field (xtensa_default_isa, opcode, opnum,
2733                                    fmt, slot, slotbuf, &val);
2734   (void) xtensa_operand_decode (xtensa_default_isa, opcode, opnum, &val);
2735   return val;
2736 }
2737
2738 \f
2739 /* Checks for rules from xtensa-relax tables.  */
2740
2741 /* The routine xg_instruction_matches_option_term must return TRUE
2742    when a given option term is true.  The meaning of all of the option
2743    terms is given interpretation by this function.  This is needed when
2744    an option depends on the state of a directive, but there are no such
2745    options in use right now.  */
2746
2747 static bfd_boolean
2748 xg_instruction_matches_option_term (TInsn *insn ATTRIBUTE_UNUSED,
2749                                     const ReqOrOption *option)
2750 {
2751   if (strcmp (option->option_name, "realnop") == 0
2752       || strncmp (option->option_name, "IsaUse", 6) == 0)
2753     {
2754       /* These conditions were evaluated statically when building the
2755          relaxation table.  There's no need to reevaluate them now.  */
2756       return TRUE;
2757     }
2758   else
2759     {
2760       as_fatal (_("internal error: unknown option name '%s'"),
2761                 option->option_name);
2762     }
2763 }
2764
2765
2766 static bfd_boolean
2767 xg_instruction_matches_or_options (TInsn *insn,
2768                                    const ReqOrOptionList *or_option)
2769 {
2770   const ReqOrOption *option;
2771   /* Must match each of the AND terms.  */
2772   for (option = or_option; option != NULL; option = option->next)
2773     {
2774       if (xg_instruction_matches_option_term (insn, option))
2775         return TRUE;
2776     }
2777   return FALSE;
2778 }
2779
2780
2781 static bfd_boolean
2782 xg_instruction_matches_options (TInsn *insn, const ReqOptionList *options)
2783 {
2784   const ReqOption *req_options;
2785   /* Must match each of the AND terms.  */
2786   for (req_options = options;
2787        req_options != NULL;
2788        req_options = req_options->next)
2789     {
2790       /* Must match one of the OR clauses.  */
2791       if (!xg_instruction_matches_or_options (insn,
2792                                               req_options->or_option_terms))
2793         return FALSE;
2794     }
2795   return TRUE;
2796 }
2797
2798
2799 /* Return the transition rule that matches or NULL if none matches.  */
2800
2801 static bfd_boolean
2802 xg_instruction_matches_rule (TInsn *insn, TransitionRule *rule)
2803 {
2804   PreconditionList *condition_l;
2805
2806   if (rule->opcode != insn->opcode)
2807     return FALSE;
2808
2809   for (condition_l = rule->conditions;
2810        condition_l != NULL;
2811        condition_l = condition_l->next)
2812     {
2813       expressionS *exp1;
2814       expressionS *exp2;
2815       Precondition *cond = condition_l->precond;
2816
2817       switch (cond->typ)
2818         {
2819         case OP_CONSTANT:
2820           /* The expression must be the constant.  */
2821           assert (cond->op_num < insn->ntok);
2822           exp1 = &insn->tok[cond->op_num];
2823           if (expr_is_const (exp1))
2824             {
2825               switch (cond->cmp)
2826                 {
2827                 case OP_EQUAL:
2828                   if (get_expr_const (exp1) != cond->op_data)
2829                     return FALSE;
2830                   break;
2831                 case OP_NOTEQUAL:
2832                   if (get_expr_const (exp1) == cond->op_data)
2833                     return FALSE;
2834                   break;
2835                 default:
2836                   return FALSE;
2837                 }
2838             }
2839           else if (expr_is_register (exp1))
2840             {
2841               switch (cond->cmp)
2842                 {
2843                 case OP_EQUAL:
2844                   if (get_expr_register (exp1) != cond->op_data)
2845                     return FALSE;
2846                   break;
2847                 case OP_NOTEQUAL:
2848                   if (get_expr_register (exp1) == cond->op_data)
2849                     return FALSE;
2850                   break;
2851                 default:
2852                   return FALSE;
2853                 }
2854             }
2855           else
2856             return FALSE;
2857           break;
2858
2859         case OP_OPERAND:
2860           assert (cond->op_num < insn->ntok);
2861           assert (cond->op_data < insn->ntok);
2862           exp1 = &insn->tok[cond->op_num];
2863           exp2 = &insn->tok[cond->op_data];
2864
2865           switch (cond->cmp)
2866             {
2867             case OP_EQUAL:
2868               if (!expr_is_equal (exp1, exp2))
2869                 return FALSE;
2870               break;
2871             case OP_NOTEQUAL:
2872               if (expr_is_equal (exp1, exp2))
2873                 return FALSE;
2874               break;
2875             }
2876           break;
2877
2878         case OP_LITERAL:
2879         case OP_LABEL:
2880         default:
2881           return FALSE;
2882         }
2883     }
2884   if (!xg_instruction_matches_options (insn, rule->options))
2885     return FALSE;
2886
2887   return TRUE;
2888 }
2889
2890
2891 static int
2892 transition_rule_cmp (const TransitionRule *a, const TransitionRule *b)
2893 {
2894   bfd_boolean a_greater = FALSE;
2895   bfd_boolean b_greater = FALSE;
2896
2897   ReqOptionList *l_a = a->options;
2898   ReqOptionList *l_b = b->options;
2899
2900   /* We only care if they both are the same except for
2901      a const16 vs. an l32r.  */
2902
2903   while (l_a && l_b && ((l_a->next == NULL) == (l_b->next == NULL)))
2904     {
2905       ReqOrOptionList *l_or_a = l_a->or_option_terms;
2906       ReqOrOptionList *l_or_b = l_b->or_option_terms;
2907       while (l_or_a && l_or_b && ((l_a->next == NULL) == (l_b->next == NULL)))
2908         {
2909           if (l_or_a->is_true != l_or_b->is_true)
2910             return 0;
2911           if (strcmp (l_or_a->option_name, l_or_b->option_name) != 0)
2912             {
2913               /* This is the case we care about.  */
2914               if (strcmp (l_or_a->option_name, "IsaUseConst16") == 0
2915                   && strcmp (l_or_b->option_name, "IsaUseL32R") == 0)
2916                 {
2917                   if (prefer_const16)
2918                     a_greater = TRUE;
2919                   else
2920                     b_greater = TRUE;
2921                 }
2922               else if (strcmp (l_or_a->option_name, "IsaUseL32R") == 0
2923                        && strcmp (l_or_b->option_name, "IsaUseConst16") == 0)
2924                 {
2925                   if (prefer_const16)
2926                     b_greater = TRUE;
2927                   else
2928                     a_greater = TRUE;
2929                 }
2930               else
2931                 return 0;
2932             }
2933           l_or_a = l_or_a->next;
2934           l_or_b = l_or_b->next;
2935         }
2936       if (l_or_a || l_or_b)
2937         return 0;
2938
2939       l_a = l_a->next;
2940       l_b = l_b->next;
2941     }
2942   if (l_a || l_b)
2943     return 0;
2944
2945   /* Incomparable if the substitution was used differently in two cases.  */
2946   if (a_greater && b_greater)
2947     return 0;
2948
2949   if (b_greater)
2950     return 1;
2951   if (a_greater)
2952     return -1;
2953
2954   return 0;
2955 }
2956
2957
2958 static TransitionRule *
2959 xg_instruction_match (TInsn *insn)
2960 {
2961   TransitionTable *table = xg_build_simplify_table (&transition_rule_cmp);
2962   TransitionList *l;
2963   assert (insn->opcode < table->num_opcodes);
2964
2965   /* Walk through all of the possible transitions.  */
2966   for (l = table->table[insn->opcode]; l != NULL; l = l->next)
2967     {
2968       TransitionRule *rule = l->rule;
2969       if (xg_instruction_matches_rule (insn, rule))
2970         return rule;
2971     }
2972   return NULL;
2973 }
2974
2975 \f
2976 /* Various Other Internal Functions.  */
2977
2978 static bfd_boolean
2979 is_unique_insn_expansion (TransitionRule *r)
2980 {
2981   if (!r->to_instr || r->to_instr->next != NULL)
2982     return FALSE;
2983   if (r->to_instr->typ != INSTR_INSTR)
2984     return FALSE;
2985   return TRUE;
2986 }
2987
2988
2989 /* Check if there is exactly one relaxation for INSN that converts it to
2990    another instruction of equal or larger size.  If so, and if TARG is
2991    non-null, go ahead and generate the relaxed instruction into TARG.  If
2992    NARROW_ONLY is true, then only consider relaxations that widen a narrow
2993    instruction, i.e., ignore relaxations that convert to an instruction of
2994    equal size.  In some contexts where this function is used, only
2995    a single widening is allowed and the NARROW_ONLY argument is used to
2996    exclude cases like ADDI being "widened" to an ADDMI, which may
2997    later be relaxed to an ADDMI/ADDI pair.  */
2998
2999 bfd_boolean
3000 xg_is_single_relaxable_insn (TInsn *insn, TInsn *targ, bfd_boolean narrow_only)
3001 {
3002   TransitionTable *table = xg_build_widen_table (&transition_rule_cmp);
3003   TransitionList *l;
3004   TransitionRule *match = 0;
3005
3006   assert (insn->insn_type == ITYPE_INSN);
3007   assert (insn->opcode < table->num_opcodes);
3008
3009   for (l = table->table[insn->opcode]; l != NULL; l = l->next)
3010     {
3011       TransitionRule *rule = l->rule;
3012
3013       if (xg_instruction_matches_rule (insn, rule)
3014           && is_unique_insn_expansion (rule)
3015           && (xg_get_single_size (insn->opcode) + (narrow_only ? 1 : 0)
3016               <= xg_get_single_size (rule->to_instr->opcode)))
3017         {
3018           if (match)
3019             return FALSE;
3020           match = rule;
3021         }
3022     }
3023   if (!match)
3024     return FALSE;
3025
3026   if (targ)
3027     xg_build_to_insn (targ, insn, match->to_instr);
3028   return TRUE;
3029 }
3030
3031
3032 /* Return the maximum number of bytes this opcode can expand to.  */
3033
3034 static int
3035 xg_get_max_insn_widen_size (xtensa_opcode opcode)
3036 {
3037   TransitionTable *table = xg_build_widen_table (&transition_rule_cmp);
3038   TransitionList *l;
3039   int max_size = xg_get_single_size (opcode);
3040
3041   assert (opcode < table->num_opcodes);
3042
3043   for (l = table->table[opcode]; l != NULL; l = l->next)
3044     {
3045       TransitionRule *rule = l->rule;
3046       BuildInstr *build_list;
3047       int this_size = 0;
3048
3049       if (!rule)
3050         continue;
3051       build_list = rule->to_instr;
3052       if (is_unique_insn_expansion (rule))
3053         {
3054           assert (build_list->typ == INSTR_INSTR);
3055           this_size = xg_get_max_insn_widen_size (build_list->opcode);
3056         }
3057       else
3058         for (; build_list != NULL; build_list = build_list->next)
3059           {
3060             switch (build_list->typ)
3061               {
3062               case INSTR_INSTR:
3063                 this_size += xg_get_single_size (build_list->opcode);
3064                 break;
3065               case INSTR_LITERAL_DEF:
3066               case INSTR_LABEL_DEF:
3067               default:
3068                 break;
3069               }
3070           }
3071       if (this_size > max_size)
3072         max_size = this_size;
3073     }
3074   return max_size;
3075 }
3076
3077
3078 /* Return the maximum number of literal bytes this opcode can generate.  */
3079
3080 static int
3081 xg_get_max_insn_widen_literal_size (xtensa_opcode opcode)
3082 {
3083   TransitionTable *table = xg_build_widen_table (&transition_rule_cmp);
3084   TransitionList *l;
3085   int max_size = 0;
3086
3087   assert (opcode < table->num_opcodes);
3088
3089   for (l = table->table[opcode]; l != NULL; l = l->next)
3090     {
3091       TransitionRule *rule = l->rule;
3092       BuildInstr *build_list;
3093       int this_size = 0;
3094
3095       if (!rule)
3096         continue;
3097       build_list = rule->to_instr;
3098       if (is_unique_insn_expansion (rule))
3099         {
3100           assert (build_list->typ == INSTR_INSTR);
3101           this_size = xg_get_max_insn_widen_literal_size (build_list->opcode);
3102         }
3103       else
3104         for (; build_list != NULL; build_list = build_list->next)
3105           {
3106             switch (build_list->typ)
3107               {
3108               case INSTR_LITERAL_DEF:
3109                 /* Hard-coded 4-byte literal.  */
3110                 this_size += 4;
3111                 break;
3112               case INSTR_INSTR:
3113               case INSTR_LABEL_DEF:
3114               default:
3115                 break;
3116               }
3117           }
3118       if (this_size > max_size)
3119         max_size = this_size;
3120     }
3121   return max_size;
3122 }
3123
3124
3125 static bfd_boolean
3126 xg_is_relaxable_insn (TInsn *insn, int lateral_steps)
3127 {
3128   int steps_taken = 0;
3129   TransitionTable *table = xg_build_widen_table (&transition_rule_cmp);
3130   TransitionList *l;
3131
3132   assert (insn->insn_type == ITYPE_INSN);
3133   assert (insn->opcode < table->num_opcodes);
3134
3135   for (l = table->table[insn->opcode]; l != NULL; l = l->next)
3136     {
3137       TransitionRule *rule = l->rule;
3138
3139       if (xg_instruction_matches_rule (insn, rule))
3140         {
3141           if (steps_taken == lateral_steps)
3142             return TRUE;
3143           steps_taken++;
3144         }
3145     }
3146   return FALSE;
3147 }
3148
3149
3150 static symbolS *
3151 get_special_literal_symbol (void)
3152 {
3153   static symbolS *sym = NULL;
3154
3155   if (sym == NULL)
3156     sym = symbol_find_or_make ("SPECIAL_LITERAL0\001");
3157   return sym;
3158 }
3159
3160
3161 static symbolS *
3162 get_special_label_symbol (void)
3163 {
3164   static symbolS *sym = NULL;
3165
3166   if (sym == NULL)
3167     sym = symbol_find_or_make ("SPECIAL_LABEL0\001");
3168   return sym;
3169 }
3170
3171
3172 static bfd_boolean
3173 xg_valid_literal_expression (const expressionS *exp)
3174 {
3175   switch (exp->X_op)
3176     {
3177     case O_constant:
3178     case O_symbol:
3179     case O_big:
3180     case O_uminus:
3181     case O_subtract:
3182     case O_pltrel:
3183       return TRUE;
3184     default:
3185       return FALSE;
3186     }
3187 }
3188
3189
3190 /* This will check to see if the value can be converted into the
3191    operand type.  It will return TRUE if it does not fit.  */
3192
3193 static bfd_boolean
3194 xg_check_operand (int32 value, xtensa_opcode opcode, int operand)
3195 {
3196   uint32 valbuf = value;
3197   if (xtensa_operand_encode (xtensa_default_isa, opcode, operand, &valbuf))
3198     return TRUE;
3199   return FALSE;
3200 }
3201
3202
3203 /* Assumes: All immeds are constants.  Check that all constants fit
3204    into their immeds; return FALSE if not.  */
3205
3206 static bfd_boolean
3207 xg_immeds_fit (const TInsn *insn)
3208 {
3209   xtensa_isa isa = xtensa_default_isa;
3210   int i;
3211
3212   int n = insn->ntok;
3213   assert (insn->insn_type == ITYPE_INSN);
3214   for (i = 0; i < n; ++i)
3215     {
3216       const expressionS *expr = &insn->tok[i];
3217       if (xtensa_operand_is_register (isa, insn->opcode, i) == 1)
3218         continue;
3219
3220       switch (expr->X_op)
3221         {
3222         case O_register:
3223         case O_constant:
3224           if (xg_check_operand (expr->X_add_number, insn->opcode, i))
3225             return FALSE;
3226           break;
3227
3228         default:
3229           /* The symbol should have a fixup associated with it.  */
3230           assert (FALSE);
3231           break;
3232         }
3233     }
3234   return TRUE;
3235 }
3236
3237
3238 /* This should only be called after we have an initial
3239    estimate of the addresses.  */
3240
3241 static bfd_boolean
3242 xg_symbolic_immeds_fit (const TInsn *insn,
3243                         segT pc_seg,
3244                         fragS *pc_frag,
3245                         offsetT pc_offset,
3246                         long stretch)
3247 {
3248   xtensa_isa isa = xtensa_default_isa;
3249   symbolS *symbolP;
3250   fragS *sym_frag;
3251   offsetT target, pc;
3252   uint32 new_offset;
3253   int i;
3254   int n = insn->ntok;
3255
3256   assert (insn->insn_type == ITYPE_INSN);
3257
3258   for (i = 0; i < n; ++i)
3259     {
3260       const expressionS *expr = &insn->tok[i];
3261       if (xtensa_operand_is_register (isa, insn->opcode, i) == 1)
3262         continue;
3263
3264       switch (expr->X_op)
3265         {
3266         case O_register:
3267         case O_constant:
3268           if (xg_check_operand (expr->X_add_number, insn->opcode, i))
3269             return FALSE;
3270           break;
3271
3272         case O_lo16:
3273         case O_hi16:
3274           /* Check for the worst case.  */
3275           if (xg_check_operand (0xffff, insn->opcode, i))
3276             return FALSE;
3277           break;
3278
3279         case O_symbol:
3280           /* We only allow symbols for PC-relative references.
3281              If pc_frag == 0, then we don't have frag locations yet.  */
3282           if (pc_frag == 0
3283               || xtensa_operand_is_PCrelative (isa, insn->opcode, i) == 0)
3284             return FALSE;
3285
3286           /* If it is a weak symbol, then assume it won't reach.  */
3287           if (S_IS_WEAK (expr->X_add_symbol))
3288             return FALSE;
3289
3290           if (is_direct_call_opcode (insn->opcode)
3291               && ! pc_frag->tc_frag_data.use_longcalls)
3292             {
3293               /* If callee is undefined or in a different segment, be
3294                  optimistic and assume it will be in range.  */
3295               if (S_GET_SEGMENT (expr->X_add_symbol) != pc_seg)
3296                 return TRUE;
3297             }
3298
3299           /* Only references within a segment can be known to fit in the
3300              operands at assembly time.  */
3301           if (S_GET_SEGMENT (expr->X_add_symbol) != pc_seg)
3302             return FALSE;
3303
3304           symbolP = expr->X_add_symbol;
3305           sym_frag = symbol_get_frag (symbolP);
3306           target = S_GET_VALUE (symbolP) + expr->X_add_number;
3307           pc = pc_frag->fr_address + pc_offset;
3308
3309           /* If frag has yet to be reached on this pass, assume it
3310              will move by STRETCH just as we did.  If this is not so,
3311              it will be because some frag between grows, and that will
3312              force another pass.  Beware zero-length frags.  There
3313              should be a faster way to do this.  */
3314
3315           if (stretch != 0
3316               && sym_frag->relax_marker != pc_frag->relax_marker
3317               && S_GET_SEGMENT (symbolP) == pc_seg)
3318             {
3319               target += stretch;
3320             }
3321
3322           new_offset = target;
3323           xtensa_operand_do_reloc (isa, insn->opcode, i, &new_offset, pc);
3324           if (xg_check_operand (new_offset, insn->opcode, i))
3325             return FALSE;
3326           break;
3327
3328         default:
3329           /* The symbol should have a fixup associated with it.  */
3330           return FALSE;
3331         }
3332     }
3333
3334   return TRUE;
3335 }
3336
3337
3338 /* Return TRUE on success.  */
3339
3340 static bfd_boolean
3341 xg_build_to_insn (TInsn *targ, TInsn *insn, BuildInstr *bi)
3342 {
3343   BuildOp *op;
3344   symbolS *sym;
3345
3346   memset (targ, 0, sizeof (TInsn));
3347   targ->loc = insn->loc;
3348   switch (bi->typ)
3349     {
3350     case INSTR_INSTR:
3351       op = bi->ops;
3352       targ->opcode = bi->opcode;
3353       targ->insn_type = ITYPE_INSN;
3354       targ->is_specific_opcode = FALSE;
3355
3356       for (; op != NULL; op = op->next)
3357         {
3358           int op_num = op->op_num;
3359           int op_data = op->op_data;
3360
3361           assert (op->op_num < MAX_INSN_ARGS);
3362
3363           if (targ->ntok <= op_num)
3364             targ->ntok = op_num + 1;
3365
3366           switch (op->typ)
3367             {
3368             case OP_CONSTANT:
3369               set_expr_const (&targ->tok[op_num], op_data);
3370               break;
3371             case OP_OPERAND:
3372               assert (op_data < insn->ntok);
3373               copy_expr (&targ->tok[op_num], &insn->tok[op_data]);
3374               break;
3375             case OP_LITERAL:
3376               sym = get_special_literal_symbol ();
3377               set_expr_symbol_offset (&targ->tok[op_num], sym, 0);
3378               break;
3379             case OP_LABEL:
3380               sym = get_special_label_symbol ();
3381               set_expr_symbol_offset (&targ->tok[op_num], sym, 0);
3382               break;
3383             case OP_OPERAND_HI16U:
3384             case OP_OPERAND_LOW16U:
3385               assert (op_data < insn->ntok);
3386               if (expr_is_const (&insn->tok[op_data]))
3387                 {
3388                   long val;
3389                   copy_expr (&targ->tok[op_num], &insn->tok[op_data]);
3390                   val = xg_apply_userdef_op_fn (op->typ,
3391                                                 targ->tok[op_num].
3392                                                 X_add_number);
3393                   targ->tok[op_num].X_add_number = val;
3394                 }
3395               else
3396                 {
3397                   /* For const16 we can create relocations for these.  */
3398                   if (targ->opcode == XTENSA_UNDEFINED
3399                       || (targ->opcode != xtensa_const16_opcode))
3400                     return FALSE;
3401                   assert (op_data < insn->ntok);
3402                   /* Need to build a O_lo16 or O_hi16.  */
3403                   copy_expr (&targ->tok[op_num], &insn->tok[op_data]);
3404                   if (targ->tok[op_num].X_op == O_symbol)
3405                     {
3406                       if (op->typ == OP_OPERAND_HI16U)
3407                         targ->tok[op_num].X_op = O_hi16;
3408                       else if (op->typ == OP_OPERAND_LOW16U)
3409                         targ->tok[op_num].X_op = O_lo16;
3410                       else
3411                         return FALSE;
3412                     }
3413                 }
3414               break;
3415             default:
3416               /* currently handles:
3417                  OP_OPERAND_LOW8
3418                  OP_OPERAND_HI24S
3419                  OP_OPERAND_F32MINUS */
3420               if (xg_has_userdef_op_fn (op->typ))
3421                 {
3422                   assert (op_data < insn->ntok);
3423                   if (expr_is_const (&insn->tok[op_data]))
3424                     {
3425                       long val;
3426                       copy_expr (&targ->tok[op_num], &insn->tok[op_data]);
3427                       val = xg_apply_userdef_op_fn (op->typ,
3428                                                     targ->tok[op_num].
3429                                                     X_add_number);
3430                       targ->tok[op_num].X_add_number = val;
3431                     }
3432                   else
3433                     return FALSE; /* We cannot use a relocation for this.  */
3434                   break;
3435                 }
3436               assert (0);
3437               break;
3438             }
3439         }
3440       break;
3441
3442     case INSTR_LITERAL_DEF:
3443       op = bi->ops;
3444       targ->opcode = XTENSA_UNDEFINED;
3445       targ->insn_type = ITYPE_LITERAL;
3446       targ->is_specific_opcode = FALSE;
3447       for (; op != NULL; op = op->next)
3448         {
3449           int op_num = op->op_num;
3450           int op_data = op->op_data;
3451           assert (op->op_num < MAX_INSN_ARGS);
3452
3453           if (targ->ntok <= op_num)
3454             targ->ntok = op_num + 1;
3455
3456           switch (op->typ)
3457             {
3458             case OP_OPERAND:
3459               assert (op_data < insn->ntok);
3460               /* We can only pass resolvable literals through.  */
3461               if (!xg_valid_literal_expression (&insn->tok[op_data]))
3462                 return FALSE;
3463               copy_expr (&targ->tok[op_num], &insn->tok[op_data]);
3464               break;
3465             case OP_LITERAL:
3466             case OP_CONSTANT:
3467             case OP_LABEL:
3468             default:
3469               assert (0);
3470               break;
3471             }
3472         }
3473       break;
3474
3475     case INSTR_LABEL_DEF:
3476       op = bi->ops;
3477       targ->opcode = XTENSA_UNDEFINED;
3478       targ->insn_type = ITYPE_LABEL;
3479       targ->is_specific_opcode = FALSE;
3480       /* Literal with no ops is a label?  */
3481       assert (op == NULL);
3482       break;
3483
3484     default:
3485       assert (0);
3486     }
3487
3488   return TRUE;
3489 }
3490
3491
3492 /* Return TRUE on success.  */
3493
3494 static bfd_boolean
3495 xg_build_to_stack (IStack *istack, TInsn *insn, BuildInstr *bi)
3496 {
3497   for (; bi != NULL; bi = bi->next)
3498     {
3499       TInsn *next_insn = istack_push_space (istack);
3500
3501       if (!xg_build_to_insn (next_insn, insn, bi))
3502         return FALSE;
3503     }
3504   return TRUE;
3505 }
3506
3507
3508 /* Return TRUE on valid expansion.  */
3509
3510 static bfd_boolean
3511 xg_expand_to_stack (IStack *istack, TInsn *insn, int lateral_steps)
3512 {
3513   int stack_size = istack->ninsn;
3514   int steps_taken = 0;
3515   TransitionTable *table = xg_build_widen_table (&transition_rule_cmp);
3516   TransitionList *l;
3517
3518   assert (insn->insn_type == ITYPE_INSN);
3519   assert (insn->opcode < table->num_opcodes);
3520
3521   for (l = table->table[insn->opcode]; l != NULL; l = l->next)
3522     {
3523       TransitionRule *rule = l->rule;
3524
3525       if (xg_instruction_matches_rule (insn, rule))
3526         {
3527           if (lateral_steps == steps_taken)
3528             {
3529               int i;
3530
3531               /* This is it.  Expand the rule to the stack.  */
3532               if (!xg_build_to_stack (istack, insn, rule->to_instr))
3533                 return FALSE;
3534
3535               /* Check to see if it fits.  */
3536               for (i = stack_size; i < istack->ninsn; i++)
3537                 {
3538                   TInsn *insn = &istack->insn[i];
3539
3540                   if (insn->insn_type == ITYPE_INSN
3541                       && !tinsn_has_symbolic_operands (insn)
3542                       && !xg_immeds_fit (insn))
3543                     {
3544                       istack->ninsn = stack_size;
3545                       return FALSE;
3546                     }
3547                 }
3548               return TRUE;
3549             }
3550           steps_taken++;
3551         }
3552     }
3553   return FALSE;
3554 }
3555
3556 \f
3557 /* Relax the assembly instruction at least "min_steps".
3558    Return the number of steps taken.  */
3559
3560 static int
3561 xg_assembly_relax (IStack *istack,
3562                    TInsn *insn,
3563                    segT pc_seg,
3564                    fragS *pc_frag,      /* if pc_frag == 0, not pc-relative */
3565                    offsetT pc_offset,   /* offset in fragment */
3566                    int min_steps,       /* minimum conversion steps */
3567                    long stretch)        /* number of bytes stretched so far */
3568 {
3569   int steps_taken = 0;
3570
3571   /* assert (has no symbolic operands)
3572      Some of its immeds don't fit.
3573      Try to build a relaxed version.
3574      This may go through a couple of stages
3575      of single instruction transformations before
3576      we get there.  */
3577
3578   TInsn single_target;
3579   TInsn current_insn;
3580   int lateral_steps = 0;
3581   int istack_size = istack->ninsn;
3582
3583   if (xg_symbolic_immeds_fit (insn, pc_seg, pc_frag, pc_offset, stretch)
3584       && steps_taken >= min_steps)
3585     {
3586       istack_push (istack, insn);
3587       return steps_taken;
3588     }
3589   current_insn = *insn;
3590
3591   /* Walk through all of the single instruction expansions.  */
3592   while (xg_is_single_relaxable_insn (&current_insn, &single_target, FALSE))
3593     {
3594       if (xg_symbolic_immeds_fit (&single_target, pc_seg, pc_frag, pc_offset,
3595                                   stretch))
3596         {
3597           steps_taken++;
3598           if (steps_taken >= min_steps)
3599             {
3600               istack_push (istack, &single_target);
3601               return steps_taken;
3602             }
3603         }
3604       current_insn = single_target;
3605     }
3606
3607   /* Now check for a multi-instruction expansion.  */
3608   while (xg_is_relaxable_insn (&current_insn, lateral_steps))
3609     {
3610       if (xg_symbolic_immeds_fit (&current_insn, pc_seg, pc_frag, pc_offset,
3611                                   stretch))
3612         {
3613           if (steps_taken >= min_steps)
3614             {
3615               istack_push (istack, &current_insn);
3616               return steps_taken;
3617             }
3618         }
3619       steps_taken++;
3620       if (xg_expand_to_stack (istack, &current_insn, lateral_steps))
3621         {
3622           if (steps_taken >= min_steps)
3623             return steps_taken;
3624         }
3625       lateral_steps++;
3626       istack->ninsn = istack_size;
3627     }
3628
3629   /* It's not going to work -- use the original.  */
3630   istack_push (istack, insn);
3631   return steps_taken;
3632 }
3633
3634
3635 static void
3636 xg_force_frag_space (int size)
3637 {
3638   /* This may have the side effect of creating a new fragment for the
3639      space to go into.  I just do not like the name of the "frag"
3640      functions.  */
3641   frag_grow (size);
3642 }
3643
3644
3645 static void
3646 xg_finish_frag (char *last_insn,
3647                 enum xtensa_relax_statesE frag_state,
3648                 enum xtensa_relax_statesE slot0_state,
3649                 int max_growth,
3650                 bfd_boolean is_insn)
3651 {
3652   /* Finish off this fragment so that it has at LEAST the desired
3653      max_growth.  If it doesn't fit in this fragment, close this one
3654      and start a new one.  In either case, return a pointer to the
3655      beginning of the growth area.  */
3656
3657   fragS *old_frag;
3658
3659   xg_force_frag_space (max_growth);
3660
3661   old_frag = frag_now;
3662
3663   frag_now->fr_opcode = last_insn;
3664   if (is_insn)
3665     frag_now->tc_frag_data.is_insn = TRUE;
3666
3667   frag_var (rs_machine_dependent, max_growth, max_growth,
3668             frag_state, frag_now->fr_symbol, frag_now->fr_offset, last_insn);
3669
3670   old_frag->tc_frag_data.slot_subtypes[0] = slot0_state;
3671   xtensa_set_frag_assembly_state (frag_now);
3672
3673   /* Just to make sure that we did not split it up.  */
3674   assert (old_frag->fr_next == frag_now);
3675 }
3676
3677
3678 /* Return TRUE if the target frag is one of the next non-empty frags.  */
3679
3680 static bfd_boolean
3681 is_next_frag_target (const fragS *fragP, const fragS *target)
3682 {
3683   if (fragP == NULL)
3684     return FALSE;
3685
3686   for (; fragP; fragP = fragP->fr_next)
3687     {
3688       if (fragP == target)
3689         return TRUE;
3690       if (fragP->fr_fix != 0)
3691         return FALSE;
3692       if (fragP->fr_type == rs_fill && fragP->fr_offset != 0)
3693         return FALSE;
3694       if ((fragP->fr_type == rs_align || fragP->fr_type == rs_align_code)
3695           && ((fragP->fr_address % (1 << fragP->fr_offset)) != 0))
3696         return FALSE;
3697       if (fragP->fr_type == rs_space)
3698         return FALSE;
3699     }
3700   return FALSE;
3701 }
3702
3703
3704 static bfd_boolean
3705 is_branch_jmp_to_next (TInsn *insn, fragS *fragP)
3706 {
3707   xtensa_isa isa = xtensa_default_isa;
3708   int i;
3709   int num_ops = xtensa_opcode_num_operands (isa, insn->opcode);
3710   int target_op = -1;
3711   symbolS *sym;
3712   fragS *target_frag;
3713
3714   if (xtensa_opcode_is_branch (isa, insn->opcode) == 0
3715       && xtensa_opcode_is_jump (isa, insn->opcode) == 0)
3716     return FALSE;
3717
3718   for (i = 0; i < num_ops; i++)
3719     {
3720       if (xtensa_operand_is_PCrelative (isa, insn->opcode, i) == 1)
3721         {
3722           target_op = i;
3723           break;
3724         }
3725     }
3726   if (target_op == -1)
3727     return FALSE;
3728
3729   if (insn->ntok <= target_op)
3730     return FALSE;
3731
3732   if (insn->tok[target_op].X_op != O_symbol)
3733     return FALSE;
3734
3735   sym = insn->tok[target_op].X_add_symbol;
3736   if (sym == NULL)
3737     return FALSE;
3738
3739   if (insn->tok[target_op].X_add_number != 0)
3740     return FALSE;
3741
3742   target_frag = symbol_get_frag (sym);
3743   if (target_frag == NULL)
3744     return FALSE;
3745
3746   if (is_next_frag_target (fragP->fr_next, target_frag)
3747       && S_GET_VALUE (sym) == target_frag->fr_address)
3748     return TRUE;
3749
3750   return FALSE;
3751 }
3752
3753
3754 static void
3755 xg_add_branch_and_loop_targets (TInsn *insn)
3756 {
3757   xtensa_isa isa = xtensa_default_isa;
3758   int num_ops = xtensa_opcode_num_operands (isa, insn->opcode);
3759
3760   if (xtensa_opcode_is_loop (isa, insn->opcode) == 1)
3761     {
3762       int i = 1;
3763       if (xtensa_operand_is_PCrelative (isa, insn->opcode, i) == 1
3764           && insn->tok[i].X_op == O_symbol)
3765         symbol_get_tc (insn->tok[i].X_add_symbol)->is_loop_target = TRUE;
3766       return;
3767     }
3768
3769   if (xtensa_opcode_is_branch (isa, insn->opcode) == 1
3770       || xtensa_opcode_is_loop (isa, insn->opcode) == 1)
3771     {
3772       int i;
3773
3774       for (i = 0; i < insn->ntok && i < num_ops; i++)
3775         {
3776           if (xtensa_operand_is_PCrelative (isa, insn->opcode, i) == 1
3777               && insn->tok[i].X_op == O_symbol)
3778             {
3779               symbolS *sym = insn->tok[i].X_add_symbol;
3780               symbol_get_tc (sym)->is_branch_target = TRUE;
3781               if (S_IS_DEFINED (sym))
3782                 symbol_get_frag (sym)->tc_frag_data.is_branch_target = TRUE;
3783             }
3784         }
3785     }
3786 }
3787
3788
3789 /* Return FALSE if no error.  */
3790
3791 static bfd_boolean
3792 xg_build_token_insn (BuildInstr *instr_spec, TInsn *old_insn, TInsn *new_insn)
3793 {
3794   int num_ops = 0;
3795   BuildOp *b_op;
3796
3797   switch (instr_spec->typ)
3798     {
3799     case INSTR_INSTR:
3800       new_insn->insn_type = ITYPE_INSN;
3801       new_insn->opcode = instr_spec->opcode;
3802       new_insn->is_specific_opcode = FALSE;
3803       new_insn->loc = old_insn->loc;
3804       break;
3805     case INSTR_LITERAL_DEF:
3806       new_insn->insn_type = ITYPE_LITERAL;
3807       new_insn->opcode = XTENSA_UNDEFINED;
3808       new_insn->is_specific_opcode = FALSE;
3809       new_insn->loc = old_insn->loc;
3810       break;
3811     case INSTR_LABEL_DEF:
3812       as_bad (_("INSTR_LABEL_DEF not supported yet"));
3813       break;
3814     }
3815
3816   for (b_op = instr_spec->ops; b_op != NULL; b_op = b_op->next)
3817     {
3818       expressionS *exp;
3819       const expressionS *src_exp;
3820
3821       num_ops++;
3822       switch (b_op->typ)
3823         {
3824         case OP_CONSTANT:
3825           /* The expression must be the constant.  */
3826           assert (b_op->op_num < MAX_INSN_ARGS);
3827           exp = &new_insn->tok[b_op->op_num];
3828           set_expr_const (exp, b_op->op_data);
3829           break;
3830
3831         case OP_OPERAND:
3832           assert (b_op->op_num < MAX_INSN_ARGS);
3833           assert (b_op->op_data < (unsigned) old_insn->ntok);
3834           src_exp = &old_insn->tok[b_op->op_data];
3835           exp = &new_insn->tok[b_op->op_num];
3836           copy_expr (exp, src_exp);
3837           break;
3838
3839         case OP_LITERAL:
3840         case OP_LABEL:
3841           as_bad (_("can't handle generation of literal/labels yet"));
3842           assert (0);
3843
3844         default:
3845           as_bad (_("can't handle undefined OP TYPE"));
3846           assert (0);
3847         }
3848     }
3849
3850   new_insn->ntok = num_ops;
3851   return FALSE;
3852 }
3853
3854
3855 /* Return TRUE if it was simplified.  */
3856
3857 static bfd_boolean
3858 xg_simplify_insn (TInsn *old_insn, TInsn *new_insn)
3859 {
3860   TransitionRule *rule;
3861   BuildInstr *insn_spec;
3862
3863   if (old_insn->is_specific_opcode || !density_supported)
3864     return FALSE;
3865
3866   rule = xg_instruction_match (old_insn);
3867   if (rule == NULL)
3868     return FALSE;
3869
3870   insn_spec = rule->to_instr;
3871   /* There should only be one.  */
3872   assert (insn_spec != NULL);
3873   assert (insn_spec->next == NULL);
3874   if (insn_spec->next != NULL)
3875     return FALSE;
3876
3877   xg_build_token_insn (insn_spec, old_insn, new_insn);
3878
3879   return TRUE;
3880 }
3881
3882
3883 /* xg_expand_assembly_insn: (1) Simplify the instruction, i.e., l32i ->
3884    l32i.n. (2) Check the number of operands.  (3) Place the instruction
3885    tokens into the stack or relax it and place multiple
3886    instructions/literals onto the stack.  Return FALSE if no error.  */
3887
3888 static bfd_boolean
3889 xg_expand_assembly_insn (IStack *istack, TInsn *orig_insn)
3890 {
3891   int noperands;
3892   TInsn new_insn;
3893   bfd_boolean do_expand;
3894
3895   memset (&new_insn, 0, sizeof (TInsn));
3896
3897   /* Narrow it if we can.  xg_simplify_insn now does all the
3898      appropriate checking (e.g., for the density option).  */
3899   if (xg_simplify_insn (orig_insn, &new_insn))
3900     orig_insn = &new_insn;
3901
3902   noperands = xtensa_opcode_num_operands (xtensa_default_isa,
3903                                           orig_insn->opcode);
3904   if (orig_insn->ntok < noperands)
3905     {
3906       as_bad (_("found %d operands for '%s':  Expected %d"),
3907               orig_insn->ntok,
3908               xtensa_opcode_name (xtensa_default_isa, orig_insn->opcode),
3909               noperands);
3910       return TRUE;
3911     }
3912   if (orig_insn->ntok > noperands)
3913     as_warn (_("found too many (%d) operands for '%s':  Expected %d"),
3914              orig_insn->ntok,
3915              xtensa_opcode_name (xtensa_default_isa, orig_insn->opcode),
3916              noperands);
3917
3918   /* If there are not enough operands, we will assert above.  If there
3919      are too many, just cut out the extras here.  */
3920   orig_insn->ntok = noperands;
3921
3922   if (tinsn_has_invalid_symbolic_operands (orig_insn))
3923     return TRUE;
3924
3925   /* If the instruction will definitely need to be relaxed, it is better
3926      to expand it now for better scheduling.  Decide whether to expand
3927      now....  */
3928   do_expand = (!orig_insn->is_specific_opcode && use_transform ());
3929
3930   /* Calls should be expanded to longcalls only in the backend relaxation
3931      so that the assembly scheduler will keep the L32R/CALLX instructions
3932      adjacent.  */
3933   if (is_direct_call_opcode (orig_insn->opcode))
3934     do_expand = FALSE;
3935
3936   if (tinsn_has_symbolic_operands (orig_insn))
3937     {
3938       /* The values of symbolic operands are not known yet, so only expand
3939          now if an operand is "complex" (e.g., difference of symbols) and
3940          will have to be stored as a literal regardless of the value.  */
3941       if (!tinsn_has_complex_operands (orig_insn))
3942         do_expand = FALSE;
3943     }
3944   else if (xg_immeds_fit (orig_insn))
3945     do_expand = FALSE;
3946
3947   if (do_expand)
3948     xg_assembly_relax (istack, orig_insn, 0, 0, 0, 0, 0);
3949   else
3950     istack_push (istack, orig_insn);
3951
3952   return FALSE;
3953 }
3954
3955
3956 /* Return TRUE if the section flags are marked linkonce
3957    or the name is .gnu.linkonce*.  */
3958
3959 static bfd_boolean
3960 get_is_linkonce_section (bfd *abfd ATTRIBUTE_UNUSED, segT sec)
3961 {
3962   flagword flags, link_once_flags;
3963
3964   flags = bfd_get_section_flags (abfd, sec);
3965   link_once_flags = (flags & SEC_LINK_ONCE);
3966
3967   /* Flags might not be set yet.  */
3968   if (!link_once_flags)
3969     {
3970       static size_t len = sizeof ".gnu.linkonce.t.";
3971
3972       if (strncmp (segment_name (sec), ".gnu.linkonce.t.", len - 1) == 0)
3973         link_once_flags = SEC_LINK_ONCE;
3974     }
3975   return (link_once_flags != 0);
3976 }
3977
3978
3979 static void
3980 xtensa_add_literal_sym (symbolS *sym)
3981 {
3982   sym_list *l;
3983
3984   l = (sym_list *) xmalloc (sizeof (sym_list));
3985   l->sym = sym;
3986   l->next = literal_syms;
3987   literal_syms = l;
3988 }
3989
3990
3991 static symbolS *
3992 xtensa_create_literal_symbol (segT sec, fragS *frag)
3993 {
3994   static int lit_num = 0;
3995   static char name[256];
3996   symbolS *symbolP;
3997
3998   sprintf (name, ".L_lit_sym%d", lit_num);
3999
4000   /* Create a local symbol.  If it is in a linkonce section, we have to
4001      be careful to make sure that if it is used in a relocation that the
4002      symbol will be in the output file.  */
4003   if (get_is_linkonce_section (stdoutput, sec))
4004     {
4005       symbolP = symbol_new (name, sec, 0, frag);
4006       S_CLEAR_EXTERNAL (symbolP);
4007       /* symbolP->local = 1; */
4008     }
4009   else
4010     symbolP = symbol_new (name, sec, 0, frag);
4011
4012   xtensa_add_literal_sym (symbolP);
4013
4014   frag->tc_frag_data.is_literal = TRUE;
4015   lit_num++;
4016   return symbolP;
4017 }
4018
4019
4020 /* Currently all literals that are generated here are 32-bit L32R targets.  */
4021
4022 static symbolS *
4023 xg_assemble_literal (/* const */ TInsn *insn)
4024 {
4025   emit_state state;
4026   symbolS *lit_sym = NULL;
4027
4028   /* size = 4 for L32R.  It could easily be larger when we move to
4029      larger constants.  Add a parameter later.  */
4030   offsetT litsize = 4;
4031   offsetT litalign = 2;         /* 2^2 = 4 */
4032   expressionS saved_loc;
4033   expressionS * emit_val;
4034
4035   set_expr_symbol_offset (&saved_loc, frag_now->fr_symbol, frag_now_fix ());
4036
4037   assert (insn->insn_type == ITYPE_LITERAL);
4038   assert (insn->ntok == 1);     /* must be only one token here */
4039
4040   xtensa_switch_to_literal_fragment (&state);
4041
4042   emit_val = &insn->tok[0];
4043   if (emit_val->X_op == O_big)
4044     {
4045       int size = emit_val->X_add_number * CHARS_PER_LITTLENUM;
4046       if (size > litsize)
4047         {
4048           /* This happens when someone writes a "movi a2, big_number".  */
4049           as_bad_where (frag_now->fr_file, frag_now->fr_line,
4050                         _("invalid immediate"));
4051           xtensa_restore_emit_state (&state);
4052           return NULL;
4053         }
4054     }
4055
4056   /* Force a 4-byte align here.  Note that this opens a new frag, so all
4057      literals done with this function have a frag to themselves.  That's
4058      important for the way text section literals work.  */
4059   frag_align (litalign, 0, 0);
4060   record_alignment (now_seg, litalign);
4061
4062   if (emit_val->X_op == O_pltrel)
4063     {
4064       char *p = frag_more (litsize);
4065       xtensa_set_frag_assembly_state (frag_now);
4066       if (emit_val->X_add_symbol)
4067         emit_val->X_op = O_symbol;
4068       else
4069         emit_val->X_op = O_constant;
4070       fix_new_exp (frag_now, p - frag_now->fr_literal,
4071                    litsize, emit_val, 0, BFD_RELOC_XTENSA_PLT);
4072     }
4073   else
4074     emit_expr (emit_val, litsize);
4075
4076   assert (frag_now->tc_frag_data.literal_frag == NULL);
4077   frag_now->tc_frag_data.literal_frag = get_literal_pool_location (now_seg);
4078   frag_now->fr_symbol = xtensa_create_literal_symbol (now_seg, frag_now);
4079   lit_sym = frag_now->fr_symbol;
4080   frag_now->tc_frag_data.is_literal = TRUE;
4081
4082   /* Go back.  */
4083   xtensa_restore_emit_state (&state);
4084   return lit_sym;
4085 }
4086
4087
4088 static void
4089 xg_assemble_literal_space (/* const */ int size, int slot)
4090 {
4091   emit_state state;
4092   /* We might have to do something about this alignment.  It only
4093      takes effect if something is placed here.  */
4094   offsetT litalign = 2;         /* 2^2 = 4 */
4095   fragS *lit_saved_frag;
4096
4097   assert (size % 4 == 0);
4098
4099   xtensa_switch_to_literal_fragment (&state);
4100
4101   /* Force a 4-byte align here.  */
4102   frag_align (litalign, 0, 0);
4103   record_alignment (now_seg, litalign);
4104
4105   xg_force_frag_space (size);
4106
4107   lit_saved_frag = frag_now;
4108   frag_now->tc_frag_data.literal_frag = get_literal_pool_location (now_seg);
4109   frag_now->tc_frag_data.is_literal = TRUE;
4110   frag_now->fr_symbol = xtensa_create_literal_symbol (now_seg, frag_now);
4111   xg_finish_frag (0, RELAX_LITERAL, 0, size, FALSE);
4112
4113   /* Go back.  */
4114   xtensa_restore_emit_state (&state);
4115   frag_now->tc_frag_data.literal_frags[slot] = lit_saved_frag;
4116 }
4117
4118
4119 /* Put in a fixup record based on the opcode.
4120    Return TRUE on success.  */
4121
4122 static bfd_boolean
4123 xg_add_opcode_fix (TInsn *tinsn,
4124                    int opnum,
4125                    xtensa_format fmt,
4126                    int slot,
4127                    expressionS *expr,
4128                    fragS *fragP,
4129                    offsetT offset)
4130 {
4131   xtensa_opcode opcode = tinsn->opcode;
4132   bfd_reloc_code_real_type reloc;
4133   reloc_howto_type *howto;
4134   int fmt_length;
4135   fixS *the_fix;
4136
4137   reloc = BFD_RELOC_NONE;
4138
4139   /* First try the special cases for "alternate" relocs.  */
4140   if (opcode == xtensa_l32r_opcode)
4141     {
4142       if (fragP->tc_frag_data.use_absolute_literals)
4143         reloc = encode_alt_reloc (slot);
4144     }
4145   else if (opcode == xtensa_const16_opcode)
4146     {
4147       if (expr->X_op == O_lo16)
4148         {
4149           reloc = encode_reloc (slot);
4150           expr->X_op = O_symbol;
4151         }
4152       else if (expr->X_op == O_hi16)
4153         {
4154           reloc = encode_alt_reloc (slot);
4155           expr->X_op = O_symbol;
4156         }
4157     }
4158
4159   if (opnum != get_relaxable_immed (opcode))
4160     {
4161       as_bad (_("invalid relocation for operand %i of '%s'"),
4162               opnum, xtensa_opcode_name (xtensa_default_isa, opcode));
4163       return FALSE;
4164     }
4165
4166   /* Handle erroneous "@h" and "@l" expressions here before they propagate
4167      into the symbol table where the generic portions of the assembler
4168      won't know what to do with them.  */
4169   if (expr->X_op == O_lo16 || expr->X_op == O_hi16)
4170     {
4171       as_bad (_("invalid expression for operand %i of '%s'"),
4172               opnum, xtensa_opcode_name (xtensa_default_isa, opcode));
4173       return FALSE;
4174     }
4175
4176   /* Next try the generic relocs.  */
4177   if (reloc == BFD_RELOC_NONE)
4178     reloc = encode_reloc (slot);
4179   if (reloc == BFD_RELOC_NONE)
4180     {
4181       as_bad (_("invalid relocation in instruction slot %i"), slot);
4182       return FALSE;
4183     }
4184
4185   howto = bfd_reloc_type_lookup (stdoutput, reloc);
4186   if (!howto)
4187     {
4188       as_bad (_("undefined symbol for opcode \"%s\""),
4189               xtensa_opcode_name (xtensa_default_isa, opcode));
4190       return FALSE;
4191     }
4192
4193   fmt_length = xtensa_format_length (xtensa_default_isa, fmt);
4194   the_fix = fix_new_exp (fragP, offset, fmt_length, expr,
4195                          howto->pc_relative, reloc);
4196   the_fix->fx_no_overflow = 1;
4197
4198   if (expr->X_add_symbol
4199       && (S_IS_EXTERNAL (expr->X_add_symbol)
4200           || S_IS_WEAK (expr->X_add_symbol)))
4201     the_fix->fx_plt = TRUE;
4202
4203   the_fix->tc_fix_data.X_add_symbol = expr->X_add_symbol;
4204   the_fix->tc_fix_data.X_add_number = expr->X_add_number;
4205   the_fix->tc_fix_data.slot = slot;
4206
4207   return TRUE;
4208 }
4209
4210
4211 static bfd_boolean
4212 xg_emit_insn_to_buf (TInsn *tinsn,
4213                      xtensa_format fmt,
4214                      char *buf,
4215                      fragS *fragP,
4216                      offsetT offset,
4217                      bfd_boolean build_fix)
4218 {
4219   static xtensa_insnbuf insnbuf = NULL;
4220   bfd_boolean has_symbolic_immed = FALSE;
4221   bfd_boolean ok = TRUE;
4222   if (!insnbuf)
4223     insnbuf = xtensa_insnbuf_alloc (xtensa_default_isa);
4224
4225   has_symbolic_immed = tinsn_to_insnbuf (tinsn, insnbuf);
4226   if (has_symbolic_immed && build_fix)
4227     {
4228       /* Add a fixup.  */
4229       int opnum = get_relaxable_immed (tinsn->opcode);
4230       expressionS *exp = &tinsn->tok[opnum];
4231
4232       if (!xg_add_opcode_fix (tinsn, opnum, fmt, 0, exp, fragP, offset))
4233         ok = FALSE;
4234     }
4235   fragP->tc_frag_data.is_insn = TRUE;
4236   xtensa_insnbuf_to_chars (xtensa_default_isa, insnbuf,
4237                            (unsigned char *) buf, 0);
4238   return ok;
4239 }
4240
4241
4242 static void
4243 xg_resolve_literals (TInsn *insn, symbolS *lit_sym)
4244 {
4245   symbolS *sym = get_special_literal_symbol ();
4246   int i;
4247   if (lit_sym == 0)
4248     return;
4249   assert (insn->insn_type == ITYPE_INSN);
4250   for (i = 0; i < insn->ntok; i++)
4251     if (insn->tok[i].X_add_symbol == sym)
4252       insn->tok[i].X_add_symbol = lit_sym;
4253
4254 }
4255
4256
4257 static void
4258 xg_resolve_labels (TInsn *insn, symbolS *label_sym)
4259 {
4260   symbolS *sym = get_special_label_symbol ();
4261   int i;
4262   /* assert (!insn->is_literal); */
4263   for (i = 0; i < insn->ntok; i++)
4264     if (insn->tok[i].X_add_symbol == sym)
4265       insn->tok[i].X_add_symbol = label_sym;
4266
4267 }
4268
4269
4270 /* Return TRUE if the instruction can write to the specified
4271    integer register.  */
4272
4273 static bfd_boolean
4274 is_register_writer (const TInsn *insn, const char *regset, int regnum)
4275 {
4276   int i;
4277   int num_ops;
4278   xtensa_isa isa = xtensa_default_isa;
4279
4280   num_ops = xtensa_opcode_num_operands (isa, insn->opcode);
4281
4282   for (i = 0; i < num_ops; i++)
4283     {
4284       char inout;
4285       inout = xtensa_operand_inout (isa, insn->opcode, i);
4286       if ((inout == 'o' || inout == 'm')
4287           && xtensa_operand_is_register (isa, insn->opcode, i) == 1)
4288         {
4289           xtensa_regfile opnd_rf =
4290             xtensa_operand_regfile (isa, insn->opcode, i);
4291           if (!strcmp (xtensa_regfile_shortname (isa, opnd_rf), regset))
4292             {
4293               if ((insn->tok[i].X_op == O_register)
4294                   && (insn->tok[i].X_add_number == regnum))
4295                 return TRUE;
4296             }
4297         }
4298     }
4299   return FALSE;
4300 }
4301
4302
4303 static bfd_boolean
4304 is_bad_loopend_opcode (const TInsn *tinsn)
4305 {
4306   xtensa_opcode opcode = tinsn->opcode;
4307
4308   if (opcode == XTENSA_UNDEFINED)
4309     return FALSE;
4310
4311   if (opcode == xtensa_call0_opcode
4312       || opcode == xtensa_callx0_opcode
4313       || opcode == xtensa_call4_opcode
4314       || opcode == xtensa_callx4_opcode
4315       || opcode == xtensa_call8_opcode
4316       || opcode == xtensa_callx8_opcode
4317       || opcode == xtensa_call12_opcode
4318       || opcode == xtensa_callx12_opcode
4319       || opcode == xtensa_isync_opcode
4320       || opcode == xtensa_ret_opcode
4321       || opcode == xtensa_ret_n_opcode
4322       || opcode == xtensa_retw_opcode
4323       || opcode == xtensa_retw_n_opcode
4324       || opcode == xtensa_waiti_opcode
4325       || opcode == xtensa_rsr_lcount_opcode)
4326     return TRUE;
4327
4328   return FALSE;
4329 }
4330
4331
4332 /* Labels that begin with ".Ln" or ".LM"  are unaligned.
4333    This allows the debugger to add unaligned labels.
4334    Also, the assembler generates stabs labels that need
4335    not be aligned:  FAKE_LABEL_NAME . {"F", "L", "endfunc"}.  */
4336
4337 static bfd_boolean
4338 is_unaligned_label (symbolS *sym)
4339 {
4340   const char *name = S_GET_NAME (sym);
4341   static size_t fake_size = 0;
4342
4343   if (name
4344       && name[0] == '.'
4345       && name[1] == 'L' && (name[2] == 'n' || name[2] == 'M'))
4346     return TRUE;
4347
4348   /* FAKE_LABEL_NAME followed by "F", "L" or "endfunc" */
4349   if (fake_size == 0)
4350     fake_size = strlen (FAKE_LABEL_NAME);
4351
4352   if (name
4353       && strncmp (FAKE_LABEL_NAME, name, fake_size) == 0
4354       && (name[fake_size] == 'F'
4355           || name[fake_size] == 'L'
4356           || (name[fake_size] == 'e'
4357               && strncmp ("endfunc", name+fake_size, 7) == 0)))
4358     return TRUE;
4359
4360   return FALSE;
4361 }
4362
4363
4364 static fragS *
4365 next_non_empty_frag (const fragS *fragP)
4366 {
4367   fragS *next_fragP = fragP->fr_next;
4368
4369   /* Sometimes an empty will end up here due storage allocation issues.
4370      So we have to skip until we find something legit.  */
4371   while (next_fragP && next_fragP->fr_fix == 0)
4372     next_fragP = next_fragP->fr_next;
4373
4374   if (next_fragP == NULL || next_fragP->fr_fix == 0)
4375     return NULL;
4376
4377   return next_fragP;
4378 }
4379
4380
4381 static bfd_boolean
4382 next_frag_opcode_is_loop (const fragS *fragP, xtensa_opcode *opcode)
4383 {
4384   xtensa_opcode out_opcode;
4385   const fragS *next_fragP = next_non_empty_frag (fragP);
4386
4387   if (next_fragP == NULL)
4388     return FALSE;
4389
4390   out_opcode = get_opcode_from_buf (next_fragP->fr_literal, 0);
4391   if (xtensa_opcode_is_loop (xtensa_default_isa, out_opcode) == 1)
4392     {
4393       *opcode = out_opcode;
4394       return TRUE;
4395     }
4396   return FALSE;
4397 }
4398
4399
4400 static int
4401 frag_format_size (const fragS *fragP)
4402 {
4403   static xtensa_insnbuf insnbuf = NULL;
4404   xtensa_isa isa = xtensa_default_isa;
4405   xtensa_format fmt;
4406   int fmt_size;
4407
4408   if (!insnbuf)
4409     insnbuf = xtensa_insnbuf_alloc (isa);
4410
4411   if (fragP == NULL)
4412     return XTENSA_UNDEFINED;
4413
4414   xtensa_insnbuf_from_chars (isa, insnbuf,
4415                              (unsigned char *) fragP->fr_literal, 0);
4416
4417   fmt = xtensa_format_decode (isa, insnbuf);
4418   if (fmt == XTENSA_UNDEFINED)
4419     return XTENSA_UNDEFINED;
4420   fmt_size = xtensa_format_length (isa, fmt);
4421
4422   /* If the next format won't be changing due to relaxation, just
4423      return the length of the first format.  */
4424   if (fragP->fr_opcode != fragP->fr_literal)
4425     return fmt_size;
4426
4427   /* If during relaxation we have to pull an instruction out of a
4428      multi-slot instruction, we will return the more conservative
4429      number.  This works because alignment on bigger instructions
4430      is more restrictive than alignment on smaller instructions.
4431      This is more conservative than we would like, but it happens
4432      infrequently.  */
4433
4434   if (xtensa_format_num_slots (xtensa_default_isa, fmt) > 1)
4435     return fmt_size;
4436
4437   /* If we aren't doing one of our own relaxations or it isn't
4438      slot-based, then the insn size won't change.  */
4439   if (fragP->fr_type != rs_machine_dependent)
4440     return fmt_size;
4441   if (fragP->fr_subtype != RELAX_SLOTS)
4442     return fmt_size;
4443
4444   /* If an instruction is about to grow, return the longer size.  */
4445   if (fragP->tc_frag_data.slot_subtypes[0] == RELAX_IMMED_STEP1
4446       || fragP->tc_frag_data.slot_subtypes[0] == RELAX_IMMED_STEP2)
4447     return 3;
4448
4449   if (fragP->tc_frag_data.slot_subtypes[0] == RELAX_NARROW)
4450     return 2 + fragP->tc_frag_data.text_expansion[0];
4451
4452   return fmt_size;
4453 }
4454
4455
4456 static int
4457 next_frag_format_size (const fragS *fragP)
4458 {
4459   const fragS *next_fragP = next_non_empty_frag (fragP);
4460   return frag_format_size (next_fragP);
4461 }
4462
4463
4464 /* If the next legit fragment is an end-of-loop marker,
4465    switch its state so it will instantiate a NOP.  */
4466
4467 static void
4468 update_next_frag_state (fragS *fragP)
4469 {
4470   fragS *next_fragP = fragP->fr_next;
4471   fragS *new_target = NULL;
4472
4473   if (align_targets)
4474     {
4475       /* We are guaranteed there will be one of these...   */
4476       while (!(next_fragP->fr_type == rs_machine_dependent
4477                && (next_fragP->fr_subtype == RELAX_MAYBE_UNREACHABLE
4478                    || next_fragP->fr_subtype == RELAX_UNREACHABLE)))
4479         next_fragP = next_fragP->fr_next;
4480
4481       assert (next_fragP->fr_type == rs_machine_dependent
4482               && (next_fragP->fr_subtype == RELAX_MAYBE_UNREACHABLE
4483                   || next_fragP->fr_subtype == RELAX_UNREACHABLE));
4484
4485       /* ...and one of these.  */
4486       new_target = next_fragP->fr_next;
4487       while (!(new_target->fr_type == rs_machine_dependent
4488                && (new_target->fr_subtype == RELAX_MAYBE_DESIRE_ALIGN
4489                    || new_target->fr_subtype == RELAX_DESIRE_ALIGN)))
4490         new_target = new_target->fr_next;
4491
4492       assert (new_target->fr_type == rs_machine_dependent
4493               && (new_target->fr_subtype == RELAX_MAYBE_DESIRE_ALIGN
4494                   || new_target->fr_subtype == RELAX_DESIRE_ALIGN));
4495     }
4496
4497   while (next_fragP && next_fragP->fr_fix == 0)
4498     {
4499       if (next_fragP->fr_type == rs_machine_dependent
4500           && next_fragP->fr_subtype == RELAX_LOOP_END)
4501         {
4502           next_fragP->fr_subtype = RELAX_LOOP_END_ADD_NOP;
4503           return;
4504         }
4505
4506       next_fragP = next_fragP->fr_next;
4507     }
4508 }
4509
4510
4511 static bfd_boolean
4512 next_frag_is_branch_target (const fragS *fragP)
4513 {
4514   /* Sometimes an empty will end up here due to storage allocation issues,
4515      so we have to skip until we find something legit.  */
4516   for (fragP = fragP->fr_next; fragP; fragP = fragP->fr_next)
4517     {
4518       if (fragP->tc_frag_data.is_branch_target)
4519         return TRUE;
4520       if (fragP->fr_fix != 0)
4521         break;
4522     }
4523   return FALSE;
4524 }
4525
4526
4527 static bfd_boolean
4528 next_frag_is_loop_target (const fragS *fragP)
4529 {
4530   /* Sometimes an empty will end up here due storage allocation issues.
4531      So we have to skip until we find something legit. */
4532   for (fragP = fragP->fr_next; fragP; fragP = fragP->fr_next)
4533     {
4534       if (fragP->tc_frag_data.is_loop_target)
4535         return TRUE;
4536       if (fragP->fr_fix != 0)
4537         break;
4538     }
4539   return FALSE;
4540 }
4541
4542
4543 static addressT
4544 next_frag_pre_opcode_bytes (const fragS *fragp)
4545 {
4546   const fragS *next_fragp = fragp->fr_next;
4547   xtensa_opcode next_opcode;
4548
4549   if (!next_frag_opcode_is_loop (fragp, &next_opcode))
4550     return 0;
4551
4552   /* Sometimes an empty will end up here due to storage allocation issues,
4553      so we have to skip until we find something legit.  */
4554   while (next_fragp->fr_fix == 0)
4555     next_fragp = next_fragp->fr_next;
4556
4557   if (next_fragp->fr_type != rs_machine_dependent)
4558     return 0;
4559
4560   /* There is some implicit knowledge encoded in here.
4561      The LOOP instructions that are NOT RELAX_IMMED have
4562      been relaxed.  Note that we can assume that the LOOP
4563      instruction is in slot 0 because loops aren't bundleable.  */
4564   if (next_fragp->tc_frag_data.slot_subtypes[0] > RELAX_IMMED)
4565       return get_expanded_loop_offset (next_opcode);
4566
4567   return 0;
4568 }
4569
4570
4571 /* Mark a location where we can later insert literal frags.  Update
4572    the section's literal_pool_loc, so subsequent literals can be
4573    placed nearest to their use.  */
4574
4575 static void
4576 xtensa_mark_literal_pool_location (void)
4577 {
4578   /* Any labels pointing to the current location need
4579      to be adjusted to after the literal pool.  */
4580   emit_state s;
4581   fragS *pool_location;
4582
4583   if (use_literal_section && !directive_state[directive_absolute_literals])
4584     return;
4585
4586   frag_align (2, 0, 0);
4587   record_alignment (now_seg, 2);
4588
4589   /* We stash info in these frags so we can later move the literal's
4590      fixes into this frchain's fix list.  */
4591   pool_location = frag_now;
4592   frag_now->tc_frag_data.lit_frchain = frchain_now;
4593   frag_variant (rs_machine_dependent, 0, 0,
4594                 RELAX_LITERAL_POOL_BEGIN, NULL, 0, NULL);
4595   xtensa_set_frag_assembly_state (frag_now);
4596   frag_now->tc_frag_data.lit_seg = now_seg;
4597   frag_variant (rs_machine_dependent, 0, 0,
4598                 RELAX_LITERAL_POOL_END, NULL, 0, NULL);
4599   xtensa_set_frag_assembly_state (frag_now);
4600
4601   /* Now put a frag into the literal pool that points to this location.  */
4602   set_literal_pool_location (now_seg, pool_location);
4603   xtensa_switch_to_non_abs_literal_fragment (&s);
4604   frag_align (2, 0, 0);
4605   record_alignment (now_seg, 2);
4606
4607   /* Close whatever frag is there.  */
4608   frag_variant (rs_fill, 0, 0, 0, NULL, 0, NULL);
4609   xtensa_set_frag_assembly_state (frag_now);
4610   frag_now->tc_frag_data.literal_frag = pool_location;
4611   frag_variant (rs_fill, 0, 0, 0, NULL, 0, NULL);
4612   xtensa_restore_emit_state (&s);
4613   xtensa_set_frag_assembly_state (frag_now);
4614 }
4615
4616
4617 /* Build a nop of the correct size into tinsn.  */
4618
4619 static void
4620 build_nop (TInsn *tinsn, int size)
4621 {
4622   tinsn_init (tinsn);
4623   switch (size)
4624     {
4625     case 2:
4626       tinsn->opcode = xtensa_nop_n_opcode;
4627       tinsn->ntok = 0;
4628       if (tinsn->opcode == XTENSA_UNDEFINED)
4629         as_fatal (_("opcode 'NOP.N' unavailable in this configuration"));
4630       break;
4631
4632     case 3:
4633       if (xtensa_nop_opcode == XTENSA_UNDEFINED)
4634         {
4635           tinsn->opcode = xtensa_or_opcode;
4636           set_expr_const (&tinsn->tok[0], 1);
4637           set_expr_const (&tinsn->tok[1], 1);
4638           set_expr_const (&tinsn->tok[2], 1);
4639           tinsn->ntok = 3;
4640         }
4641       else
4642         tinsn->opcode = xtensa_nop_opcode;
4643
4644       assert (tinsn->opcode != XTENSA_UNDEFINED);
4645     }
4646 }
4647
4648
4649 /* Assemble a NOP of the requested size in the buffer.  User must have
4650    allocated "buf" with at least "size" bytes.  */
4651
4652 static void
4653 assemble_nop (int size, char *buf)
4654 {
4655   static xtensa_insnbuf insnbuf = NULL;
4656   TInsn tinsn;
4657
4658   build_nop (&tinsn, size);
4659
4660   if (!insnbuf)
4661     insnbuf = xtensa_insnbuf_alloc (xtensa_default_isa);
4662
4663   tinsn_to_insnbuf (&tinsn, insnbuf);
4664   xtensa_insnbuf_to_chars (xtensa_default_isa, insnbuf,
4665                            (unsigned char *) buf, 0);
4666 }
4667
4668
4669 /* Return the number of bytes for the offset of the expanded loop
4670    instruction.  This should be incorporated into the relaxation
4671    specification but is hard-coded here.  This is used to auto-align
4672    the loop instruction.  It is invalid to call this function if the
4673    configuration does not have loops or if the opcode is not a loop
4674    opcode.  */
4675
4676 static addressT
4677 get_expanded_loop_offset (xtensa_opcode opcode)
4678 {
4679   /* This is the OFFSET of the loop instruction in the expanded loop.
4680      This MUST correspond directly to the specification of the loop
4681      expansion.  It will be validated on fragment conversion.  */
4682   assert (opcode != XTENSA_UNDEFINED);
4683   if (opcode == xtensa_loop_opcode)
4684     return 0;
4685   if (opcode == xtensa_loopnez_opcode)
4686     return 3;
4687   if (opcode == xtensa_loopgtz_opcode)
4688     return 6;
4689   as_fatal (_("get_expanded_loop_offset: invalid opcode"));
4690   return 0;
4691 }
4692
4693
4694 static fragS *
4695 get_literal_pool_location (segT seg)
4696 {
4697   return seg_info (seg)->tc_segment_info_data.literal_pool_loc;
4698 }
4699
4700
4701 static void
4702 set_literal_pool_location (segT seg, fragS *literal_pool_loc)
4703 {
4704   seg_info (seg)->tc_segment_info_data.literal_pool_loc = literal_pool_loc;
4705 }
4706
4707
4708 /* Set frag assembly state should be called when a new frag is
4709    opened and after a frag has been closed.  */
4710
4711 static void
4712 xtensa_set_frag_assembly_state (fragS *fragP)
4713 {
4714   if (!density_supported)
4715     fragP->tc_frag_data.is_no_density = TRUE;
4716
4717   /* This function is called from subsegs_finish, which is called
4718      after xtensa_end, so we can't use "use_transform" or
4719      "use_schedule" here.  */
4720   if (!directive_state[directive_transform])
4721     fragP->tc_frag_data.is_no_transform = TRUE;
4722   if (directive_state[directive_longcalls])
4723     fragP->tc_frag_data.use_longcalls = TRUE;
4724   fragP->tc_frag_data.use_absolute_literals =
4725     directive_state[directive_absolute_literals];
4726   fragP->tc_frag_data.is_assembly_state_set = TRUE;
4727 }
4728
4729
4730 static bfd_boolean
4731 relaxable_section (asection *sec)
4732 {
4733   return (sec->flags & SEC_DEBUGGING) == 0;
4734 }
4735
4736
4737 static void
4738 xtensa_find_unmarked_state_frags (void)
4739 {
4740   segT *seclist;
4741
4742   /* Walk over each fragment of all of the current segments.  For each
4743      unmarked fragment, mark it with the same info as the previous
4744      fragment.  */
4745   for (seclist = &stdoutput->sections;
4746        seclist && *seclist;
4747        seclist = &(*seclist)->next)
4748     {
4749       segT sec = *seclist;
4750       segment_info_type *seginfo;
4751       fragS *fragP;
4752       flagword flags;
4753       flags = bfd_get_section_flags (stdoutput, sec);
4754       if (flags & SEC_DEBUGGING)
4755         continue;
4756       if (!(flags & SEC_ALLOC))
4757         continue;
4758
4759       seginfo = seg_info (sec);
4760       if (seginfo && seginfo->frchainP)
4761         {
4762           fragS *last_fragP = 0;
4763           for (fragP = seginfo->frchainP->frch_root; fragP;
4764                fragP = fragP->fr_next)
4765             {
4766               if (fragP->fr_fix != 0
4767                   && !fragP->tc_frag_data.is_assembly_state_set)
4768                 {
4769                   if (last_fragP == 0)
4770                     {
4771                       as_warn_where (fragP->fr_file, fragP->fr_line,
4772                                      _("assembly state not set for first frag in section %s"),
4773                                      sec->name);
4774                     }
4775                   else
4776                     {
4777                       fragP->tc_frag_data.is_assembly_state_set = TRUE;
4778                       fragP->tc_frag_data.is_no_density =
4779                         last_fragP->tc_frag_data.is_no_density;
4780                       fragP->tc_frag_data.is_no_transform =
4781                         last_fragP->tc_frag_data.is_no_transform;
4782                       fragP->tc_frag_data.use_longcalls =
4783                         last_fragP->tc_frag_data.use_longcalls;
4784                       fragP->tc_frag_data.use_absolute_literals =
4785                         last_fragP->tc_frag_data.use_absolute_literals;
4786                     }
4787                 }
4788               if (fragP->tc_frag_data.is_assembly_state_set)
4789                 last_fragP = fragP;
4790             }
4791         }
4792     }
4793 }
4794
4795
4796 static void
4797 xtensa_find_unaligned_branch_targets (bfd *abfd ATTRIBUTE_UNUSED,
4798                                       asection *sec,
4799                                       void *unused ATTRIBUTE_UNUSED)
4800 {
4801   flagword flags = bfd_get_section_flags (abfd, sec);
4802   segment_info_type *seginfo = seg_info (sec);
4803   fragS *frag = seginfo->frchainP->frch_root;
4804
4805   if (flags & SEC_CODE)
4806     {
4807       xtensa_isa isa = xtensa_default_isa;
4808       xtensa_insnbuf insnbuf = xtensa_insnbuf_alloc (isa);
4809       while (frag != NULL)
4810         {
4811           if (frag->tc_frag_data.is_branch_target)
4812             {
4813               int op_size;
4814               addressT branch_align, frag_addr;
4815               xtensa_format fmt;
4816
4817               xtensa_insnbuf_from_chars
4818                 (isa, insnbuf, (unsigned char *) frag->fr_literal, 0);
4819               fmt = xtensa_format_decode (isa, insnbuf);
4820               op_size = xtensa_format_length (isa, fmt);
4821               branch_align = 1 << branch_align_power (sec);
4822               frag_addr = frag->fr_address % branch_align;
4823               if (frag_addr + op_size > branch_align)
4824                 as_warn_where (frag->fr_file, frag->fr_line,
4825                                _("unaligned branch target: %d bytes at 0x%lx"),
4826                                op_size, (long) frag->fr_address);
4827             }
4828           frag = frag->fr_next;
4829         }
4830       xtensa_insnbuf_free (isa, insnbuf);
4831     }
4832 }
4833
4834
4835 static void
4836 xtensa_find_unaligned_loops (bfd *abfd ATTRIBUTE_UNUSED,
4837                              asection *sec,
4838                              void *unused ATTRIBUTE_UNUSED)
4839 {
4840   flagword flags = bfd_get_section_flags (abfd, sec);
4841   segment_info_type *seginfo = seg_info (sec);
4842   fragS *frag = seginfo->frchainP->frch_root;
4843   xtensa_isa isa = xtensa_default_isa;
4844
4845   if (flags & SEC_CODE)
4846     {
4847       xtensa_insnbuf insnbuf = xtensa_insnbuf_alloc (isa);
4848       while (frag != NULL)
4849         {
4850           if (frag->tc_frag_data.is_first_loop_insn)
4851             {
4852               int op_size;
4853               addressT frag_addr;
4854               xtensa_format fmt;
4855
4856               xtensa_insnbuf_from_chars
4857                 (isa, insnbuf, (unsigned char *) frag->fr_literal, 0);
4858               fmt = xtensa_format_decode (isa, insnbuf);
4859               op_size = xtensa_format_length (isa, fmt);
4860               frag_addr = frag->fr_address % xtensa_fetch_width;
4861
4862               if (frag_addr + op_size > xtensa_fetch_width)
4863                 as_warn_where (frag->fr_file, frag->fr_line,
4864                                _("unaligned loop: %d bytes at 0x%lx"),
4865                                op_size, (long) frag->fr_address);
4866             }
4867           frag = frag->fr_next;
4868         }
4869       xtensa_insnbuf_free (isa, insnbuf);
4870     }
4871 }
4872
4873
4874 static int
4875 xg_apply_fix_value (fixS *fixP, valueT val)
4876 {
4877   xtensa_isa isa = xtensa_default_isa;
4878   static xtensa_insnbuf insnbuf = NULL;
4879   static xtensa_insnbuf slotbuf = NULL;
4880   xtensa_format fmt;
4881   int slot;
4882   bfd_boolean alt_reloc;
4883   xtensa_opcode opcode;
4884   char *const fixpos = fixP->fx_frag->fr_literal + fixP->fx_where;
4885
4886   (void) decode_reloc (fixP->fx_r_type, &slot, &alt_reloc);
4887   if (alt_reloc)
4888     as_fatal (_("unexpected fix"));
4889
4890   if (!insnbuf)
4891     {
4892       insnbuf = xtensa_insnbuf_alloc (isa);
4893       slotbuf = xtensa_insnbuf_alloc (isa);
4894     }
4895
4896   xtensa_insnbuf_from_chars (isa, insnbuf, (unsigned char *) fixpos, 0);
4897   fmt = xtensa_format_decode (isa, insnbuf);
4898   if (fmt == XTENSA_UNDEFINED)
4899     as_fatal (_("undecodable fix"));
4900   xtensa_format_get_slot (isa, fmt, slot, insnbuf, slotbuf);
4901   opcode = xtensa_opcode_decode (isa, fmt, slot, slotbuf);
4902   if (opcode == XTENSA_UNDEFINED)
4903     as_fatal (_("undecodable fix"));
4904
4905   /* CONST16 immediates are not PC-relative, despite the fact that we
4906      reuse the normal PC-relative operand relocations for the low part
4907      of a CONST16 operand.  */
4908   if (opcode == xtensa_const16_opcode)
4909     return 0;
4910
4911   xtensa_insnbuf_set_operand (slotbuf, fmt, slot, opcode,
4912                               get_relaxable_immed (opcode), val,
4913                               fixP->fx_file, fixP->fx_line);
4914
4915   xtensa_format_set_slot (isa, fmt, slot, insnbuf, slotbuf);
4916   xtensa_insnbuf_to_chars (isa, insnbuf, (unsigned char *) fixpos, 0);
4917
4918   return 1;
4919 }
4920
4921 \f
4922 /* External Functions and Other GAS Hooks.  */
4923
4924 const char *
4925 xtensa_target_format (void)
4926 {
4927   return (target_big_endian ? "elf32-xtensa-be" : "elf32-xtensa-le");
4928 }
4929
4930
4931 void
4932 xtensa_file_arch_init (bfd *abfd)
4933 {
4934   bfd_set_private_flags (abfd, 0x100 | 0x200);
4935 }
4936
4937
4938 void
4939 md_number_to_chars (char *buf, valueT val, int n)
4940 {
4941   if (target_big_endian)
4942     number_to_chars_bigendian (buf, val, n);
4943   else
4944     number_to_chars_littleendian (buf, val, n);
4945 }
4946
4947
4948 /* This function is called once, at assembler startup time.  It should
4949    set up all the tables, etc. that the MD part of the assembler will
4950    need.  */
4951
4952 void
4953 md_begin (void)
4954 {
4955   segT current_section = now_seg;
4956   int current_subsec = now_subseg;
4957   xtensa_isa isa;
4958
4959   xtensa_default_isa = xtensa_isa_init (0, 0);
4960   isa = xtensa_default_isa;
4961
4962   linkrelax = 1;
4963
4964   /* Set up the .literal, .fini.literal and .init.literal sections.  */
4965   memset (&default_lit_sections, 0, sizeof (default_lit_sections));
4966   default_lit_sections.init_lit_seg_name = INIT_LITERAL_SECTION_NAME;
4967   default_lit_sections.fini_lit_seg_name = FINI_LITERAL_SECTION_NAME;
4968   default_lit_sections.lit_seg_name = LITERAL_SECTION_NAME;
4969   default_lit_sections.lit4_seg_name = LIT4_SECTION_NAME;
4970
4971   subseg_set (current_section, current_subsec);
4972
4973   xg_init_vinsn (&cur_vinsn);
4974
4975   xtensa_addi_opcode = xtensa_opcode_lookup (isa, "addi");
4976   xtensa_addmi_opcode = xtensa_opcode_lookup (isa, "addmi");
4977   xtensa_call0_opcode = xtensa_opcode_lookup (isa, "call0");
4978   xtensa_call4_opcode = xtensa_opcode_lookup (isa, "call4");
4979   xtensa_call8_opcode = xtensa_opcode_lookup (isa, "call8");
4980   xtensa_call12_opcode = xtensa_opcode_lookup (isa, "call12");
4981   xtensa_callx0_opcode = xtensa_opcode_lookup (isa, "callx0");
4982   xtensa_callx4_opcode = xtensa_opcode_lookup (isa, "callx4");
4983   xtensa_callx8_opcode = xtensa_opcode_lookup (isa, "callx8");
4984   xtensa_callx12_opcode = xtensa_opcode_lookup (isa, "callx12");
4985   xtensa_const16_opcode = xtensa_opcode_lookup (isa, "const16");
4986   xtensa_entry_opcode = xtensa_opcode_lookup (isa, "entry");
4987   xtensa_movi_opcode = xtensa_opcode_lookup (isa, "movi");
4988   xtensa_movi_n_opcode = xtensa_opcode_lookup (isa, "movi.n");
4989   xtensa_isync_opcode = xtensa_opcode_lookup (isa, "isync");
4990   xtensa_jx_opcode = xtensa_opcode_lookup (isa, "jx");
4991   xtensa_l32r_opcode = xtensa_opcode_lookup (isa, "l32r");
4992   xtensa_loop_opcode = xtensa_opcode_lookup (isa, "loop");
4993   xtensa_loopnez_opcode = xtensa_opcode_lookup (isa, "loopnez");
4994   xtensa_loopgtz_opcode = xtensa_opcode_lookup (isa, "loopgtz");
4995   xtensa_nop_opcode = xtensa_opcode_lookup (isa, "nop");
4996   xtensa_nop_n_opcode = xtensa_opcode_lookup (isa, "nop.n");
4997   xtensa_or_opcode = xtensa_opcode_lookup (isa, "or");
4998   xtensa_ret_opcode = xtensa_opcode_lookup (isa, "ret");
4999   xtensa_ret_n_opcode = xtensa_opcode_lookup (isa, "ret.n");
5000   xtensa_retw_opcode = xtensa_opcode_lookup (isa, "retw");
5001   xtensa_retw_n_opcode = xtensa_opcode_lookup (isa, "retw.n");
5002   xtensa_rsr_lcount_opcode = xtensa_opcode_lookup (isa, "rsr.lcount");
5003   xtensa_waiti_opcode = xtensa_opcode_lookup (isa, "waiti");
5004
5005   init_op_placement_info_table ();
5006
5007   /* Set up the assembly state.  */
5008   if (!frag_now->tc_frag_data.is_assembly_state_set)
5009     xtensa_set_frag_assembly_state (frag_now);
5010 }
5011
5012
5013 /* TC_INIT_FIX_DATA hook */
5014
5015 void
5016 xtensa_init_fix_data (fixS *x)
5017 {
5018   x->tc_fix_data.slot = 0;
5019   x->tc_fix_data.X_add_symbol = NULL;
5020   x->tc_fix_data.X_add_number = 0;
5021 }
5022
5023
5024 /* tc_frob_label hook */
5025
5026 void
5027 xtensa_frob_label (symbolS *sym)
5028 {
5029   float freq = get_subseg_target_freq (now_seg, now_subseg);
5030
5031   /* Since the label was already attached to a frag associated with the
5032      previous basic block, it now needs to be reset to the current frag.  */
5033   symbol_set_frag (sym, frag_now);
5034   S_SET_VALUE (sym, (valueT) frag_now_fix ());
5035
5036   if (generating_literals)
5037     xtensa_add_literal_sym (sym);
5038   else
5039     xtensa_add_insn_label (sym);
5040
5041   if (symbol_get_tc (sym)->is_loop_target)
5042     {
5043       if ((get_last_insn_flags (now_seg, now_subseg)
5044           & FLAG_IS_BAD_LOOPEND) != 0)
5045         as_bad (_("invalid last instruction for a zero-overhead loop"));
5046
5047       xtensa_set_frag_assembly_state (frag_now);
5048       frag_var (rs_machine_dependent, 4, 4, RELAX_LOOP_END,
5049                 frag_now->fr_symbol, frag_now->fr_offset, NULL);
5050
5051       xtensa_set_frag_assembly_state (frag_now);
5052       xtensa_move_labels (frag_now, 0, TRUE);
5053   }
5054
5055   /* No target aligning in the absolute section.  */
5056   if (now_seg != absolute_section
5057       && do_align_targets ()
5058       && !is_unaligned_label (sym)
5059       && !generating_literals)
5060     {
5061       xtensa_set_frag_assembly_state (frag_now);
5062
5063       frag_var (rs_machine_dependent,
5064                 0, (int) freq,
5065                 RELAX_DESIRE_ALIGN_IF_TARGET,
5066                 frag_now->fr_symbol, frag_now->fr_offset, NULL);
5067       xtensa_set_frag_assembly_state (frag_now);
5068       xtensa_move_labels (frag_now, 0, TRUE);
5069     }
5070
5071   /* We need to mark the following properties even if we aren't aligning.  */
5072
5073   /* If the label is already known to be a branch target, i.e., a
5074      forward branch, mark the frag accordingly.  Backward branches
5075      are handled by xg_add_branch_and_loop_targets.  */
5076   if (symbol_get_tc (sym)->is_branch_target)
5077     symbol_get_frag (sym)->tc_frag_data.is_branch_target = TRUE;
5078
5079   /* Loops only go forward, so they can be identified here.  */
5080   if (symbol_get_tc (sym)->is_loop_target)
5081     symbol_get_frag (sym)->tc_frag_data.is_loop_target = TRUE;
5082 }
5083
5084
5085 /* tc_unrecognized_line hook */
5086
5087 int
5088 xtensa_unrecognized_line (int ch)
5089 {
5090   switch (ch)
5091     {
5092     case '{' :
5093       if (cur_vinsn.inside_bundle == 0)
5094         {
5095           /* PR8110: Cannot emit line number info inside a FLIX bundle
5096              when using --gstabs.  Temporarily disable debug info.  */
5097           generate_lineno_debug ();
5098           if (debug_type == DEBUG_STABS)
5099             {
5100               xt_saved_debug_type = debug_type;
5101               debug_type = DEBUG_NONE;
5102             }
5103
5104           cur_vinsn.inside_bundle = 1;
5105         }
5106       else
5107         {
5108           as_bad (_("extra opening brace"));
5109           return 0;
5110         }
5111       break;
5112
5113     case '}' :
5114       if (cur_vinsn.inside_bundle)
5115         finish_vinsn (&cur_vinsn);
5116       else
5117         {
5118           as_bad (_("extra closing brace"));
5119           return 0;
5120         }
5121       break;
5122     default:
5123       as_bad (_("syntax error"));
5124       return 0;
5125     }
5126   return 1;
5127 }
5128
5129
5130 /* md_flush_pending_output hook */
5131
5132 void
5133 xtensa_flush_pending_output (void)
5134 {
5135   if (cur_vinsn.inside_bundle)
5136     as_bad (_("missing closing brace"));
5137
5138   /* If there is a non-zero instruction fragment, close it.  */
5139   if (frag_now_fix () != 0 && frag_now->tc_frag_data.is_insn)
5140     {
5141       frag_wane (frag_now);
5142       frag_new (0);
5143       xtensa_set_frag_assembly_state (frag_now);
5144     }
5145   frag_now->tc_frag_data.is_insn = FALSE;
5146
5147   xtensa_clear_insn_labels ();
5148 }
5149
5150
5151 /* We had an error while parsing an instruction.  The string might look
5152    like this: "insn arg1, arg2 }".  If so, we need to see the closing
5153    brace and reset some fields.  Otherwise, the vinsn never gets closed
5154    and the num_slots field will grow past the end of the array of slots,
5155    and bad things happen.  */
5156
5157 static void
5158 error_reset_cur_vinsn (void)
5159 {
5160   if (cur_vinsn.inside_bundle)
5161     {
5162       if (*input_line_pointer == '}'
5163           || *(input_line_pointer - 1) == '}'
5164           || *(input_line_pointer - 2) == '}')
5165         xg_clear_vinsn (&cur_vinsn);
5166     }
5167 }
5168
5169
5170 void
5171 md_assemble (char *str)
5172 {
5173   xtensa_isa isa = xtensa_default_isa;
5174   char *opname;
5175   unsigned opnamelen;
5176   bfd_boolean has_underbar = FALSE;
5177   char *arg_strings[MAX_INSN_ARGS];
5178   int num_args;
5179   TInsn orig_insn;              /* Original instruction from the input.  */
5180
5181   tinsn_init (&orig_insn);
5182
5183   /* Split off the opcode.  */
5184   opnamelen = strspn (str, "abcdefghijklmnopqrstuvwxyz_/0123456789.");
5185   opname = xmalloc (opnamelen + 1);
5186   memcpy (opname, str, opnamelen);
5187   opname[opnamelen] = '\0';
5188
5189   num_args = tokenize_arguments (arg_strings, str + opnamelen);
5190   if (num_args == -1)
5191     {
5192       as_bad (_("syntax error"));
5193       return;
5194     }
5195
5196   if (xg_translate_idioms (&opname, &num_args, arg_strings))
5197     return;
5198
5199   /* Check for an underbar prefix.  */
5200   if (*opname == '_')
5201     {
5202       has_underbar = TRUE;
5203       opname += 1;
5204     }
5205
5206   orig_insn.insn_type = ITYPE_INSN;
5207   orig_insn.ntok = 0;
5208   orig_insn.is_specific_opcode = (has_underbar || !use_transform ());
5209
5210   orig_insn.opcode = xtensa_opcode_lookup (isa, opname);
5211   if (orig_insn.opcode == XTENSA_UNDEFINED)
5212     {
5213       xtensa_format fmt = xtensa_format_lookup (isa, opname);
5214       if (fmt == XTENSA_UNDEFINED)
5215         {
5216           as_bad (_("unknown opcode or format name '%s'"), opname);
5217           error_reset_cur_vinsn ();
5218           return;
5219         }
5220       if (!cur_vinsn.inside_bundle)
5221         {
5222           as_bad (_("format names only valid inside bundles"));
5223           error_reset_cur_vinsn ();
5224           return;
5225         }
5226       if (cur_vinsn.format != XTENSA_UNDEFINED)
5227         as_warn (_("multiple formats specified for one bundle; using '%s'"),
5228                  opname);
5229       cur_vinsn.format = fmt;
5230       free (has_underbar ? opname - 1 : opname);
5231       error_reset_cur_vinsn ();
5232       return;
5233     }
5234
5235   /* Parse the arguments.  */
5236   if (parse_arguments (&orig_insn, num_args, arg_strings))
5237     {
5238       as_bad (_("syntax error"));
5239       error_reset_cur_vinsn ();
5240       return;
5241     }
5242
5243   /* Free the opcode and argument strings, now that they've been parsed.  */
5244   free (has_underbar ? opname - 1 : opname);
5245   opname = 0;
5246   while (num_args-- > 0)
5247     free (arg_strings[num_args]);
5248
5249   /* Get expressions for invisible operands.  */
5250   if (get_invisible_operands (&orig_insn))
5251     {
5252       error_reset_cur_vinsn ();
5253       return;
5254     }
5255
5256   /* Check for the right number and type of arguments.  */
5257   if (tinsn_check_arguments (&orig_insn))
5258     {
5259       error_reset_cur_vinsn ();
5260       return;
5261     }
5262
5263   dwarf2_where (&orig_insn.loc);
5264
5265   xg_add_branch_and_loop_targets (&orig_insn);
5266
5267   /* Special-case for "entry" instruction.  */
5268   if (orig_insn.opcode == xtensa_entry_opcode)
5269     {
5270       /* Check that the third opcode (#2) is >= 16.  */
5271       if (orig_insn.ntok >= 3)
5272         {
5273           expressionS *exp = &orig_insn.tok[2];
5274           switch (exp->X_op)
5275             {
5276             case O_constant:
5277               if (exp->X_add_number < 16)
5278                 as_warn (_("entry instruction with stack decrement < 16"));
5279               break;
5280
5281             default:
5282               as_warn (_("entry instruction with non-constant decrement"));
5283             }
5284         }
5285     }
5286
5287   /* Finish it off:
5288      assemble_tokens (opcode, tok, ntok);
5289      expand the tokens from the orig_insn into the
5290      stack of instructions that will not expand
5291      unless required at relaxation time.  */
5292
5293   if (!cur_vinsn.inside_bundle)
5294     emit_single_op (&orig_insn);
5295   else /* We are inside a bundle.  */
5296     {
5297       cur_vinsn.slots[cur_vinsn.num_slots] = orig_insn;
5298       cur_vinsn.num_slots++;
5299       if (*input_line_pointer == '}'
5300           || *(input_line_pointer - 1) == '}'
5301           || *(input_line_pointer - 2) == '}')
5302         finish_vinsn (&cur_vinsn);
5303     }
5304
5305   /* We've just emitted a new instruction so clear the list of labels.  */
5306   xtensa_clear_insn_labels ();
5307 }
5308
5309
5310 /* HANDLE_ALIGN hook */
5311
5312 /* For a .align directive, we mark the previous block with the alignment
5313    information.  This will be placed in the object file in the
5314    property section corresponding to this section.  */
5315
5316 void
5317 xtensa_handle_align (fragS *fragP)
5318 {
5319   if (linkrelax
5320       && ! fragP->tc_frag_data.is_literal
5321       && (fragP->fr_type == rs_align
5322           || fragP->fr_type == rs_align_code)
5323       && fragP->fr_address + fragP->fr_fix > 0
5324       && fragP->fr_offset > 0
5325       && now_seg != bss_section)
5326     {
5327       fragP->tc_frag_data.is_align = TRUE;
5328       fragP->tc_frag_data.alignment = fragP->fr_offset;
5329     }
5330
5331   if (fragP->fr_type == rs_align_test)
5332     {
5333       int count;
5334       count = fragP->fr_next->fr_address - fragP->fr_address - fragP->fr_fix;
5335       if (count != 0)
5336         as_bad_where (fragP->fr_file, fragP->fr_line,
5337                       _("unaligned entry instruction"));
5338     }
5339 }
5340
5341
5342 /* TC_FRAG_INIT hook */
5343
5344 void
5345 xtensa_frag_init (fragS *frag)
5346 {
5347   xtensa_set_frag_assembly_state (frag);
5348 }
5349
5350
5351 symbolS *
5352 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
5353 {
5354   return NULL;
5355 }
5356
5357
5358 /* Round up a section size to the appropriate boundary.  */
5359
5360 valueT
5361 md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size)
5362 {
5363   return size;                  /* Byte alignment is fine.  */
5364 }
5365
5366
5367 long
5368 md_pcrel_from (fixS *fixP)
5369 {
5370   char *insn_p;
5371   static xtensa_insnbuf insnbuf = NULL;
5372   static xtensa_insnbuf slotbuf = NULL;
5373   int opnum;
5374   uint32 opnd_value;
5375   xtensa_opcode opcode;
5376   xtensa_format fmt;
5377   int slot;
5378   xtensa_isa isa = xtensa_default_isa;
5379   valueT addr = fixP->fx_where + fixP->fx_frag->fr_address;
5380   bfd_boolean alt_reloc;
5381
5382   if (fixP->fx_r_type == BFD_RELOC_XTENSA_ASM_EXPAND)
5383     return 0;
5384
5385   if (!insnbuf)
5386     {
5387       insnbuf = xtensa_insnbuf_alloc (isa);
5388       slotbuf = xtensa_insnbuf_alloc (isa);
5389     }
5390
5391   insn_p = &fixP->fx_frag->fr_literal[fixP->fx_where];
5392   xtensa_insnbuf_from_chars (isa, insnbuf, (unsigned char *) insn_p, 0);
5393   fmt = xtensa_format_decode (isa, insnbuf);
5394
5395   if (fmt == XTENSA_UNDEFINED)
5396     as_fatal (_("bad instruction format"));
5397
5398   if (decode_reloc (fixP->fx_r_type, &slot, &alt_reloc) != 0)
5399     as_fatal (_("invalid relocation"));
5400
5401   xtensa_format_get_slot (isa, fmt, slot, insnbuf, slotbuf);
5402   opcode = xtensa_opcode_decode (isa, fmt, slot, slotbuf);
5403
5404   /* Check for "alternate" relocations (operand not specified).  None
5405      of the current uses for these are really PC-relative.  */
5406   if (alt_reloc || opcode == xtensa_const16_opcode)
5407     {
5408       if (opcode != xtensa_l32r_opcode
5409           && opcode != xtensa_const16_opcode)
5410         as_fatal (_("invalid relocation for '%s' instruction"),
5411                   xtensa_opcode_name (isa, opcode));
5412       return 0;
5413     }
5414
5415   opnum = get_relaxable_immed (opcode);
5416   opnd_value = 0;
5417   if (xtensa_operand_is_PCrelative (isa, opcode, opnum) != 1
5418       || xtensa_operand_do_reloc (isa, opcode, opnum, &opnd_value, addr))
5419     {
5420       as_bad_where (fixP->fx_file,
5421                     fixP->fx_line,
5422                     _("invalid relocation for operand %d of '%s'"),
5423                     opnum, xtensa_opcode_name (isa, opcode));
5424       return 0;
5425     }
5426   return 0 - opnd_value;
5427 }
5428
5429
5430 /* TC_FORCE_RELOCATION hook */
5431
5432 int
5433 xtensa_force_relocation (fixS *fix)
5434 {
5435   switch (fix->fx_r_type)
5436     {
5437     case BFD_RELOC_XTENSA_ASM_EXPAND:
5438     case BFD_RELOC_XTENSA_SLOT0_ALT:
5439     case BFD_RELOC_XTENSA_SLOT1_ALT:
5440     case BFD_RELOC_XTENSA_SLOT2_ALT:
5441     case BFD_RELOC_XTENSA_SLOT3_ALT:
5442     case BFD_RELOC_XTENSA_SLOT4_ALT:
5443     case BFD_RELOC_XTENSA_SLOT5_ALT:
5444     case BFD_RELOC_XTENSA_SLOT6_ALT:
5445     case BFD_RELOC_XTENSA_SLOT7_ALT:
5446     case BFD_RELOC_XTENSA_SLOT8_ALT:
5447     case BFD_RELOC_XTENSA_SLOT9_ALT:
5448     case BFD_RELOC_XTENSA_SLOT10_ALT:
5449     case BFD_RELOC_XTENSA_SLOT11_ALT:
5450     case BFD_RELOC_XTENSA_SLOT12_ALT:
5451     case BFD_RELOC_XTENSA_SLOT13_ALT:
5452     case BFD_RELOC_XTENSA_SLOT14_ALT:
5453       return 1;
5454     default:
5455       break;
5456     }
5457
5458   if (linkrelax && fix->fx_addsy
5459       && relaxable_section (S_GET_SEGMENT (fix->fx_addsy)))
5460     return 1;
5461
5462   return generic_force_reloc (fix);
5463 }
5464
5465
5466 /* TC_VALIDATE_FIX_SUB hook */
5467
5468 int
5469 xtensa_validate_fix_sub (fixS *fix)
5470 {
5471   segT add_symbol_segment, sub_symbol_segment;
5472
5473   /* The difference of two symbols should be resolved by the assembler when
5474      linkrelax is not set.  If the linker may relax the section containing
5475      the symbols, then an Xtensa DIFF relocation must be generated so that
5476      the linker knows to adjust the difference value.  */
5477   if (!linkrelax || fix->fx_addsy == NULL)
5478     return 0;
5479
5480   /* Make sure both symbols are in the same segment, and that segment is
5481      "normal" and relaxable.  If the segment is not "normal", then the
5482      fix is not valid.  If the segment is not "relaxable", then the fix
5483      should have been handled earlier.  */
5484   add_symbol_segment = S_GET_SEGMENT (fix->fx_addsy);
5485   if (! SEG_NORMAL (add_symbol_segment) ||
5486       ! relaxable_section (add_symbol_segment))
5487     return 0;
5488   sub_symbol_segment = S_GET_SEGMENT (fix->fx_subsy);
5489   return (sub_symbol_segment == add_symbol_segment);
5490 }
5491
5492
5493 /* NO_PSEUDO_DOT hook */
5494
5495 /* This function has nothing to do with pseudo dots, but this is the
5496    nearest macro to where the check needs to take place.  FIXME: This
5497    seems wrong.  */
5498
5499 bfd_boolean
5500 xtensa_check_inside_bundle (void)
5501 {
5502   if (cur_vinsn.inside_bundle && input_line_pointer[-1] == '.')
5503     as_bad (_("directives are not valid inside bundles"));
5504
5505   /* This function must always return FALSE because it is called via a
5506      macro that has nothing to do with bundling.  */
5507   return FALSE;
5508 }
5509
5510
5511 /* md_elf_section_change_hook */
5512
5513 void
5514 xtensa_elf_section_change_hook (void)
5515 {
5516   /* Set up the assembly state.  */
5517   if (!frag_now->tc_frag_data.is_assembly_state_set)
5518     xtensa_set_frag_assembly_state (frag_now);
5519 }
5520
5521
5522 /* tc_fix_adjustable hook */
5523
5524 bfd_boolean
5525 xtensa_fix_adjustable (fixS *fixP)
5526 {
5527   /* An offset is not allowed in combination with the difference of two
5528      symbols, but that cannot be easily detected after a local symbol
5529      has been adjusted to a (section+offset) form.  Return 0 so that such
5530      an fix will not be adjusted.  */
5531   if (fixP->fx_subsy && fixP->fx_addsy && fixP->fx_offset
5532       && relaxable_section (S_GET_SEGMENT (fixP->fx_subsy)))
5533     return 0;
5534
5535   /* We need the symbol name for the VTABLE entries.  */
5536   if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
5537       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
5538     return 0;
5539
5540   return 1;
5541 }
5542
5543
5544 void
5545 md_apply_fix3 (fixS *fixP, valueT *valP, segT seg)
5546 {
5547   char *const fixpos = fixP->fx_frag->fr_literal + fixP->fx_where;
5548   valueT val;
5549
5550   switch (fixP->fx_r_type)
5551     {
5552     case BFD_RELOC_32:
5553     case BFD_RELOC_16:
5554     case BFD_RELOC_8:
5555       if (linkrelax && fixP->fx_subsy)
5556         {
5557           switch (fixP->fx_r_type)
5558             {
5559             case BFD_RELOC_8:
5560               fixP->fx_r_type = BFD_RELOC_XTENSA_DIFF8;
5561               break;
5562             case BFD_RELOC_16:
5563               fixP->fx_r_type = BFD_RELOC_XTENSA_DIFF16;
5564               break;
5565             case BFD_RELOC_32:
5566               fixP->fx_r_type = BFD_RELOC_XTENSA_DIFF32;
5567               break;
5568             default:
5569               break;
5570             }
5571
5572           /* An offset is only allowed when it results from adjusting a
5573              local symbol into a section-relative offset.  If the offset
5574              came from the original expression, tc_fix_adjustable will have
5575              prevented the fix from being converted to a section-relative
5576              form so that we can flag the error here.  */
5577           if (fixP->fx_offset != 0 && !symbol_section_p (fixP->fx_addsy))
5578             as_bad_where (fixP->fx_file, fixP->fx_line,
5579                           _("cannot represent subtraction with an offset"));
5580
5581           val = (S_GET_VALUE (fixP->fx_addsy) + fixP->fx_offset
5582                  - S_GET_VALUE (fixP->fx_subsy));
5583
5584           /* The difference value gets written out, and the DIFF reloc
5585              identifies the address of the subtracted symbol (i.e., the one
5586              with the lowest address).  */
5587           *valP = val;
5588           fixP->fx_offset -= val;
5589           fixP->fx_subsy = NULL;
5590         }
5591       else if (! fixP->fx_addsy)
5592         {
5593           val = *valP;
5594           fixP->fx_done = 1;
5595         }
5596       else
5597         break;
5598       md_number_to_chars (fixpos, val, fixP->fx_size);
5599       fixP->fx_no_overflow = 0; /* Use the standard overflow check.  */
5600       break;
5601
5602     case BFD_RELOC_XTENSA_SLOT0_OP:
5603     case BFD_RELOC_XTENSA_SLOT1_OP:
5604     case BFD_RELOC_XTENSA_SLOT2_OP:
5605     case BFD_RELOC_XTENSA_SLOT3_OP:
5606     case BFD_RELOC_XTENSA_SLOT4_OP:
5607     case BFD_RELOC_XTENSA_SLOT5_OP:
5608     case BFD_RELOC_XTENSA_SLOT6_OP:
5609     case BFD_RELOC_XTENSA_SLOT7_OP:
5610     case BFD_RELOC_XTENSA_SLOT8_OP:
5611     case BFD_RELOC_XTENSA_SLOT9_OP:
5612     case BFD_RELOC_XTENSA_SLOT10_OP:
5613     case BFD_RELOC_XTENSA_SLOT11_OP:
5614     case BFD_RELOC_XTENSA_SLOT12_OP:
5615     case BFD_RELOC_XTENSA_SLOT13_OP:
5616     case BFD_RELOC_XTENSA_SLOT14_OP:
5617       if (linkrelax)
5618         {
5619           /* Write the tentative value of a PC-relative relocation to a
5620              local symbol into the instruction.  The value will be ignored
5621              by the linker, and it makes the object file disassembly
5622              readable when all branch targets are encoded in relocations.  */
5623
5624           assert (fixP->fx_addsy);
5625           if (S_GET_SEGMENT (fixP->fx_addsy) == seg && !fixP->fx_plt
5626               && !S_FORCE_RELOC (fixP->fx_addsy, 1))
5627             {
5628               val = (S_GET_VALUE (fixP->fx_addsy) + fixP->fx_offset
5629                      - md_pcrel_from (fixP));
5630               (void) xg_apply_fix_value (fixP, val);
5631             }
5632         }
5633       else if (! fixP->fx_addsy)
5634         {
5635           val = *valP;
5636           if (xg_apply_fix_value (fixP, val))
5637             fixP->fx_done = 1;
5638         }
5639       break;
5640
5641     case BFD_RELOC_XTENSA_PLT:
5642     case BFD_RELOC_XTENSA_ASM_EXPAND:
5643     case BFD_RELOC_XTENSA_SLOT0_ALT:
5644     case BFD_RELOC_XTENSA_SLOT1_ALT:
5645     case BFD_RELOC_XTENSA_SLOT2_ALT:
5646     case BFD_RELOC_XTENSA_SLOT3_ALT:
5647     case BFD_RELOC_XTENSA_SLOT4_ALT:
5648     case BFD_RELOC_XTENSA_SLOT5_ALT:
5649     case BFD_RELOC_XTENSA_SLOT6_ALT:
5650     case BFD_RELOC_XTENSA_SLOT7_ALT:
5651     case BFD_RELOC_XTENSA_SLOT8_ALT:
5652     case BFD_RELOC_XTENSA_SLOT9_ALT:
5653     case BFD_RELOC_XTENSA_SLOT10_ALT:
5654     case BFD_RELOC_XTENSA_SLOT11_ALT:
5655     case BFD_RELOC_XTENSA_SLOT12_ALT:
5656     case BFD_RELOC_XTENSA_SLOT13_ALT:
5657     case BFD_RELOC_XTENSA_SLOT14_ALT:
5658       /* These all need to be resolved at link-time.  Do nothing now.  */
5659       break;
5660
5661     case BFD_RELOC_VTABLE_INHERIT:
5662     case BFD_RELOC_VTABLE_ENTRY:
5663       fixP->fx_done = 0;
5664       break;
5665
5666     default:
5667       as_bad (_("unhandled local relocation fix %s"),
5668               bfd_get_reloc_code_name (fixP->fx_r_type));
5669     }
5670 }
5671
5672
5673 char *
5674 md_atof (int type, char *litP, int *sizeP)
5675 {
5676   int prec;
5677   LITTLENUM_TYPE words[4];
5678   char *t;
5679   int i;
5680
5681   switch (type)
5682     {
5683     case 'f':
5684       prec = 2;
5685       break;
5686
5687     case 'd':
5688       prec = 4;
5689       break;
5690
5691     default:
5692       *sizeP = 0;
5693       return "bad call to md_atof";
5694     }
5695
5696   t = atof_ieee (input_line_pointer, type, words);
5697   if (t)
5698     input_line_pointer = t;
5699
5700   *sizeP = prec * 2;
5701
5702   for (i = prec - 1; i >= 0; i--)
5703     {
5704       int idx = i;
5705       if (target_big_endian)
5706         idx = (prec - 1 - i);
5707
5708       md_number_to_chars (litP, (valueT) words[idx], 2);
5709       litP += 2;
5710     }
5711
5712   return NULL;
5713 }
5714
5715
5716 int
5717 md_estimate_size_before_relax (fragS *fragP, segT seg ATTRIBUTE_UNUSED)
5718 {
5719   return total_frag_text_expansion (fragP);
5720 }
5721
5722
5723 /* Translate internal representation of relocation info to BFD target
5724    format.  */
5725
5726 arelent *
5727 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
5728 {
5729   arelent *reloc;
5730
5731   reloc = (arelent *) xmalloc (sizeof (arelent));
5732   reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
5733   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
5734   reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
5735
5736   /* Make sure none of our internal relocations make it this far.
5737      They'd better have been fully resolved by this point.  */
5738   assert ((int) fixp->fx_r_type > 0);
5739
5740   reloc->addend = fixp->fx_offset;
5741
5742   reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
5743   if (reloc->howto == NULL)
5744     {
5745       as_bad_where (fixp->fx_file, fixp->fx_line,
5746                     _("cannot represent `%s' relocation in object file"),
5747                     bfd_get_reloc_code_name (fixp->fx_r_type));
5748       free (reloc->sym_ptr_ptr);
5749       free (reloc);
5750       return NULL;
5751     }
5752
5753   if (!fixp->fx_pcrel != !reloc->howto->pc_relative)
5754     as_fatal (_("internal error? cannot generate `%s' relocation"),
5755               bfd_get_reloc_code_name (fixp->fx_r_type));
5756
5757   return reloc;
5758 }
5759
5760 \f
5761 /* Checks for resource conflicts between instructions.  */
5762
5763 /* The func unit stuff could be implemented as bit-vectors rather
5764    than the iterative approach here.  If it ends up being too
5765    slow, we will switch it.  */
5766
5767 resource_table *
5768 new_resource_table (void *data,
5769                     int cycles,
5770                     int nu,
5771                     unit_num_copies_func uncf,
5772                     opcode_num_units_func onuf,
5773                     opcode_funcUnit_use_unit_func ouuf,
5774                     opcode_funcUnit_use_stage_func ousf)
5775 {
5776   int i;
5777   resource_table *rt = (resource_table *) xmalloc (sizeof (resource_table));
5778   rt->data = data;
5779   rt->cycles = cycles;
5780   rt->allocated_cycles = cycles;
5781   rt->num_units = nu;
5782   rt->unit_num_copies = uncf;
5783   rt->opcode_num_units = onuf;
5784   rt->opcode_unit_use = ouuf;
5785   rt->opcode_unit_stage = ousf;
5786
5787   rt->units = (char **) xcalloc (cycles, sizeof (char *));
5788   for (i = 0; i < cycles; i++)
5789     rt->units[i] = (char *) xcalloc (nu, sizeof (char));
5790
5791   return rt;
5792 }
5793
5794
5795 void
5796 clear_resource_table (resource_table *rt)
5797 {
5798   int i, j;
5799   for (i = 0; i < rt->allocated_cycles; i++)
5800     for (j = 0; j < rt->num_units; j++)
5801       rt->units[i][j] = 0;
5802 }
5803
5804
5805 /* We never shrink it, just fake it into thinking so.  */
5806
5807 void
5808 resize_resource_table (resource_table *rt, int cycles)
5809 {
5810   int i, old_cycles;
5811
5812   rt->cycles = cycles;
5813   if (cycles <= rt->allocated_cycles)
5814     return;
5815
5816   old_cycles = rt->allocated_cycles;
5817   rt->allocated_cycles = cycles;
5818
5819   rt->units = xrealloc (rt->units, sizeof (char *) * rt->allocated_cycles);
5820   for (i = 0; i < old_cycles; i++)
5821     rt->units[i] = xrealloc (rt->units[i], sizeof (char) * rt->num_units);
5822   for (i = old_cycles; i < cycles; i++)
5823     rt->units[i] = xcalloc (rt->num_units, sizeof (char));
5824 }
5825
5826
5827 bfd_boolean
5828 resources_available (resource_table *rt, xtensa_opcode opcode, int cycle)
5829 {
5830   int i;
5831   int uses = (rt->opcode_num_units) (rt->data, opcode);
5832
5833   for (i = 0; i < uses; i++)
5834     {
5835       xtensa_funcUnit unit = (rt->opcode_unit_use) (rt->data, opcode, i);
5836       int stage = (rt->opcode_unit_stage) (rt->data, opcode, i);
5837       int copies_in_use = rt->units[stage + cycle][unit];
5838       int copies = (rt->unit_num_copies) (rt->data, unit);
5839       if (copies_in_use >= copies)
5840         return FALSE;
5841     }
5842   return TRUE;
5843 }
5844
5845
5846 void
5847 reserve_resources (resource_table *rt, xtensa_opcode opcode, int cycle)
5848 {
5849   int i;
5850   int uses = (rt->opcode_num_units) (rt->data, opcode);
5851
5852   for (i = 0; i < uses; i++)
5853     {
5854       xtensa_funcUnit unit = (rt->opcode_unit_use) (rt->data, opcode, i);
5855       int stage = (rt->opcode_unit_stage) (rt->data, opcode, i);
5856       /* Note that this allows resources to be oversubscribed.  That's
5857          essential to the way the optional scheduler works.
5858          resources_available reports when a resource is over-subscribed,
5859          so it's easy to tell.  */
5860       rt->units[stage + cycle][unit]++;
5861     }
5862 }
5863
5864
5865 void
5866 release_resources (resource_table *rt, xtensa_opcode opcode, int cycle)
5867 {
5868   int i;
5869   int uses = (rt->opcode_num_units) (rt->data, opcode);
5870
5871   for (i = 0; i < uses; i++)
5872     {
5873       xtensa_funcUnit unit = (rt->opcode_unit_use) (rt->data, opcode, i);
5874       int stage = (rt->opcode_unit_stage) (rt->data, opcode, i);
5875       rt->units[stage + cycle][unit]--;
5876       assert (rt->units[stage + cycle][unit] >= 0);
5877     }
5878 }
5879
5880
5881 /* Wrapper functions make parameterized resource reservation
5882    more convenient.  */
5883
5884 int
5885 opcode_funcUnit_use_unit (void *data, xtensa_opcode opcode, int idx)
5886 {
5887   xtensa_funcUnit_use *use = xtensa_opcode_funcUnit_use (data, opcode, idx);
5888   return use->unit;
5889 }
5890
5891
5892 int
5893 opcode_funcUnit_use_stage (void *data, xtensa_opcode opcode, int idx)
5894 {
5895   xtensa_funcUnit_use *use = xtensa_opcode_funcUnit_use (data, opcode, idx);
5896   return use->stage;
5897 }
5898
5899
5900 /* Note that this function does not check issue constraints, but
5901    solely whether the hardware is available to execute the given
5902    instructions together.  It also doesn't check if the tinsns
5903    write the same state, or access the same tieports.  That is
5904    checked by check_t1_t2_reads_and_writes.  */
5905
5906 static bfd_boolean
5907 resources_conflict (vliw_insn *vinsn)
5908 {
5909   int i;
5910   static resource_table *rt = NULL;
5911
5912   /* This is the most common case by far.  Optimize it.  */
5913   if (vinsn->num_slots == 1)
5914     return FALSE;
5915
5916   if (rt == NULL)
5917     {
5918       xtensa_isa isa = xtensa_default_isa;
5919       rt = new_resource_table
5920         (isa, xtensa_isa_num_pipe_stages (isa),
5921          xtensa_isa_num_funcUnits (isa),
5922          (unit_num_copies_func) xtensa_funcUnit_num_copies,
5923          (opcode_num_units_func) xtensa_opcode_num_funcUnit_uses,
5924          opcode_funcUnit_use_unit,
5925          opcode_funcUnit_use_stage);
5926     }
5927
5928   clear_resource_table (rt);
5929
5930   for (i = 0; i < vinsn->num_slots; i++)
5931     {
5932       if (!resources_available (rt, vinsn->slots[i].opcode, 0))
5933         return TRUE;
5934       reserve_resources (rt, vinsn->slots[i].opcode, 0);
5935     }
5936
5937   return FALSE;
5938 }
5939
5940 \f
5941 /* finish_vinsn, emit_single_op and helper functions.  */
5942
5943 static bfd_boolean find_vinsn_conflicts (vliw_insn *);
5944 static xtensa_format xg_find_narrowest_format (vliw_insn *);
5945 static void bundle_single_op (TInsn *);
5946 static void xg_assemble_vliw_tokens (vliw_insn *);
5947
5948
5949 /* We have reached the end of a bundle; emit into the frag.  */
5950
5951 static void
5952 finish_vinsn (vliw_insn *vinsn)
5953 {
5954   IStack slotstack;
5955   int i;
5956   char *file_name;
5957   unsigned line;
5958
5959   if (find_vinsn_conflicts (vinsn))
5960     {
5961       xg_clear_vinsn (vinsn);
5962       return;
5963     }
5964
5965   /* First, find a format that works.  */
5966   if (vinsn->format == XTENSA_UNDEFINED)
5967     vinsn->format = xg_find_narrowest_format (vinsn);
5968
5969   if (vinsn->format == XTENSA_UNDEFINED)
5970     {
5971       as_where (&file_name, &line);
5972       as_bad_where (file_name, line,
5973                     _("couldn't find a valid instruction format"));
5974       fprintf (stderr, _("    ops were: "));
5975       for (i = 0; i < vinsn->num_slots; i++)
5976         fprintf (stderr, _(" %s;"),
5977                  xtensa_opcode_name (xtensa_default_isa,
5978                                      vinsn->slots[i].opcode));
5979       fprintf (stderr, _("\n"));
5980       xg_clear_vinsn (vinsn);
5981       return;
5982     }
5983
5984   if (vinsn->num_slots
5985       != xtensa_format_num_slots (xtensa_default_isa, vinsn->format))
5986     {
5987       as_bad (_("format '%s' allows %d slots, but there are %d opcodes"),
5988               xtensa_format_name (xtensa_default_isa, vinsn->format),
5989               xtensa_format_num_slots (xtensa_default_isa, vinsn->format),
5990               vinsn->num_slots);
5991       xg_clear_vinsn (vinsn);
5992       return;
5993     }
5994
5995   if (resources_conflict (vinsn))
5996     {
5997       as_where (&file_name, &line);
5998       as_bad_where (file_name, line, _("illegal resource usage in bundle"));
5999       fprintf (stderr, "    ops were: ");
6000       for (i = 0; i < vinsn->num_slots; i++)
6001         fprintf (stderr, " %s;",
6002                  xtensa_opcode_name (xtensa_default_isa,
6003                                      vinsn->slots[i].opcode));
6004       fprintf (stderr, "\n");
6005       xg_clear_vinsn (vinsn);
6006       return;
6007     }
6008
6009   for (i = 0; i < vinsn->num_slots; i++)
6010     {
6011       if (vinsn->slots[i].opcode != XTENSA_UNDEFINED)
6012         {
6013           symbolS *lit_sym = NULL;
6014           int j;
6015           bfd_boolean e = FALSE;
6016           bfd_boolean saved_density = density_supported;
6017
6018           /* We don't want to narrow ops inside multi-slot bundles.  */
6019           if (vinsn->num_slots > 1)
6020             density_supported = FALSE;
6021
6022           istack_init (&slotstack);
6023           if (vinsn->slots[i].opcode == xtensa_nop_opcode)
6024             {
6025               vinsn->slots[i].opcode =
6026                 xtensa_format_slot_nop_opcode (xtensa_default_isa,
6027                                                vinsn->format, i);
6028               vinsn->slots[i].ntok = 0;
6029             }
6030
6031           if (xg_expand_assembly_insn (&slotstack, &vinsn->slots[i]))
6032             {
6033               e = TRUE;
6034               continue;
6035             }
6036
6037           density_supported = saved_density;
6038
6039           if (e)
6040             {
6041               xg_clear_vinsn (vinsn);
6042               return;
6043             }
6044
6045           for (j = 0; j < slotstack.ninsn; j++)
6046             {
6047               TInsn *insn = &slotstack.insn[j];
6048               if (insn->insn_type == ITYPE_LITERAL)
6049                 {
6050                   assert (lit_sym == NULL);
6051                   lit_sym = xg_assemble_literal (insn);
6052                 }
6053               else
6054                 {
6055                   assert (insn->insn_type == ITYPE_INSN);
6056                   if (lit_sym)
6057                     xg_resolve_literals (insn, lit_sym);
6058                   if (j != slotstack.ninsn - 1)
6059                     emit_single_op (insn);
6060                 }
6061             }
6062
6063           if (vinsn->num_slots > 1)
6064             {
6065               if (opcode_fits_format_slot
6066                   (slotstack.insn[slotstack.ninsn - 1].opcode,
6067                    vinsn->format, i))
6068                 {
6069                   vinsn->slots[i] = slotstack.insn[slotstack.ninsn - 1];
6070                 }
6071               else
6072                 {
6073                   bundle_single_op (&slotstack.insn[slotstack.ninsn - 1]);
6074                   if (vinsn->format == XTENSA_UNDEFINED)
6075                     vinsn->slots[i].opcode = xtensa_nop_opcode;
6076                   else
6077                     vinsn->slots[i].opcode
6078                       = xtensa_format_slot_nop_opcode (xtensa_default_isa,
6079                                                        vinsn->format, i);
6080
6081                   vinsn->slots[i].ntok = 0;
6082                 }
6083             }
6084           else
6085             {
6086               vinsn->slots[0] = slotstack.insn[slotstack.ninsn - 1];
6087               vinsn->format = XTENSA_UNDEFINED;
6088             }
6089         }
6090     }
6091
6092   /* Now check resource conflicts on the modified bundle.  */
6093   if (resources_conflict (vinsn))
6094     {
6095       as_where (&file_name, &line);
6096       as_bad_where (file_name, line, _("illegal resource usage in bundle"));
6097       fprintf (stderr, "    ops were: ");
6098       for (i = 0; i < vinsn->num_slots; i++)
6099         fprintf (stderr, " %s;",
6100                  xtensa_opcode_name (xtensa_default_isa,
6101                                      vinsn->slots[i].opcode));
6102       fprintf (stderr, "\n");
6103       xg_clear_vinsn (vinsn);
6104       return;
6105     }
6106
6107   /* First, find a format that works.  */
6108   if (vinsn->format == XTENSA_UNDEFINED)
6109       vinsn->format = xg_find_narrowest_format (vinsn);
6110
6111   xg_assemble_vliw_tokens (vinsn);
6112
6113   xg_clear_vinsn (vinsn);
6114 }
6115
6116
6117 /* Given an vliw instruction, what conflicts are there in register
6118    usage and in writes to states and queues?
6119
6120    This function does two things:
6121    1. Reports an error when a vinsn contains illegal combinations
6122       of writes to registers states or queues.
6123    2. Marks individual tinsns as not relaxable if the combination
6124       contains antidependencies.
6125
6126    Job 2 handles things like swap semantics in instructions that need
6127    to be relaxed.  For example,
6128
6129         addi a0, a1, 100000
6130
6131    normally would be relaxed to
6132
6133         l32r a0, some_label
6134         add a0, a1, a0
6135
6136    _but_, if the above instruction is bundled with an a0 reader, e.g.,
6137
6138         { addi a0, a1, 10000 ; add a2, a0, a4 ; }
6139
6140    then we can't relax it into
6141
6142         l32r a0, some_label
6143         { add a0, a1, a0 ; add a2, a0, a4 ; }
6144
6145    because the value of a0 is trashed before the second add can read it.  */
6146
6147 static char check_t1_t2_reads_and_writes (TInsn *, TInsn *);
6148
6149 static bfd_boolean
6150 find_vinsn_conflicts (vliw_insn *vinsn)
6151 {
6152   int i, j;
6153   int branches = 0;
6154   xtensa_isa isa = xtensa_default_isa;
6155
6156   assert (!past_xtensa_end);
6157
6158   for (i = 0 ; i < vinsn->num_slots; i++)
6159     {
6160       TInsn *op1 = &vinsn->slots[i];
6161       if (op1->is_specific_opcode)
6162         op1->keep_wide = TRUE;
6163       else
6164         op1->keep_wide = FALSE;
6165     }
6166
6167   for (i = 0 ; i < vinsn->num_slots; i++)
6168     {
6169       TInsn *op1 = &vinsn->slots[i];
6170
6171       if (xtensa_opcode_is_branch (isa, op1->opcode) == 1)
6172         branches++;
6173
6174       for (j = 0; j < vinsn->num_slots; j++)
6175         {
6176           if (i != j)
6177             {
6178               TInsn *op2 = &vinsn->slots[j];
6179               char conflict_type = check_t1_t2_reads_and_writes (op1, op2);
6180               switch (conflict_type)
6181                 {
6182                 case 'c':
6183                   as_bad (_("opcodes '%s' (slot %d) and '%s' (slot %d) write the same register"),
6184                           xtensa_opcode_name (isa, op1->opcode), i,
6185                           xtensa_opcode_name (isa, op2->opcode), j);
6186                   return TRUE;
6187                 case 'd':
6188                   as_bad (_("opcodes '%s' (slot %d) and '%s' (slot %d) write the same state"),
6189                           xtensa_opcode_name (isa, op1->opcode), i,
6190                           xtensa_opcode_name (isa, op2->opcode), j);
6191                   return TRUE;
6192                 case 'e':
6193                   as_bad (_("opcodes '%s' (slot %d) and '%s' (slot %d) write the same queue"),
6194                           xtensa_opcode_name (isa, op1->opcode), i,
6195                           xtensa_opcode_name (isa, op2->opcode), j);
6196                   return TRUE;
6197                 case 'f':
6198                   as_bad (_("opcodes '%s' (slot %d) and '%s' (slot %d) both have volatile queue accesses"),
6199                           xtensa_opcode_name (isa, op1->opcode), i,
6200                           xtensa_opcode_name (isa, op2->opcode), j);
6201                   return TRUE;
6202                 default:
6203                   /* Everything is OK.  */
6204                   break;
6205                 }
6206               op2->is_specific_opcode = (op2->is_specific_opcode
6207                                          || conflict_type == 'a');
6208             }
6209         }
6210     }
6211
6212   if (branches > 1)
6213     {
6214       as_bad (_("multiple branches or jumps in the same bundle"));
6215       return TRUE;
6216     }
6217
6218   return FALSE;
6219 }
6220
6221
6222 /* Check how the state used by t1 and t2 relate.
6223    Cases found are:
6224
6225    case A: t1 reads a register t2 writes (an antidependency within a bundle)
6226    case B: no relationship between what is read and written (both could
6227            read the same reg though)
6228    case C: t1 writes a register t2 writes (a register conflict within a
6229            bundle)
6230    case D: t1 writes a state that t2 also writes
6231    case E: t1 writes a tie queue that t2 also writes
6232    case F: two volatile queue accesses
6233 */
6234
6235 static char
6236 check_t1_t2_reads_and_writes (TInsn *t1, TInsn *t2)
6237 {
6238   xtensa_isa isa = xtensa_default_isa;
6239   xtensa_regfile t1_regfile, t2_regfile;
6240   int t1_reg, t2_reg;
6241   int t1_base_reg, t1_last_reg;
6242   int t2_base_reg, t2_last_reg;
6243   char t1_inout, t2_inout;
6244   int i, j;
6245   char conflict = 'b';
6246   int t1_states;
6247   int t2_states;
6248   int t1_interfaces;
6249   int t2_interfaces;
6250   bfd_boolean t1_volatile = FALSE;
6251   bfd_boolean t2_volatile = FALSE;
6252
6253   /* Check registers.  */
6254   for (j = 0; j < t2->ntok; j++)
6255     {
6256       if (xtensa_operand_is_register (isa, t2->opcode, j) != 1)
6257         continue;
6258
6259       t2_regfile = xtensa_operand_regfile (isa, t2->opcode, j);
6260       t2_base_reg = t2->tok[j].X_add_number;
6261       t2_last_reg = t2_base_reg + xtensa_operand_num_regs (isa, t2->opcode, j);
6262
6263       for (i = 0; i < t1->ntok; i++)
6264         {
6265           if (xtensa_operand_is_register (isa, t1->opcode, i) != 1)
6266             continue;
6267
6268           t1_regfile = xtensa_operand_regfile (isa, t1->opcode, i);
6269
6270           if (t1_regfile != t2_regfile)
6271             continue;
6272
6273           t1_inout = xtensa_operand_inout (isa, t1->opcode, i);
6274           t2_inout = xtensa_operand_inout (isa, t2->opcode, j);
6275
6276           if (xtensa_operand_is_known_reg (isa, t1->opcode, i) == 0
6277               || xtensa_operand_is_known_reg (isa, t2->opcode, j) == 0)
6278             {
6279               if (t1_inout == 'm' || t1_inout == 'o'
6280                   || t2_inout == 'm' || t2_inout == 'o')
6281                 {
6282                   conflict = 'a';
6283                   continue;
6284                 }
6285             }
6286
6287           t1_base_reg = t1->tok[i].X_add_number;
6288           t1_last_reg = (t1_base_reg
6289                          + xtensa_operand_num_regs (isa, t1->opcode, i));
6290
6291           for (t1_reg = t1_base_reg; t1_reg < t1_last_reg; t1_reg++)
6292             {
6293               for (t2_reg = t2_base_reg; t2_reg < t2_last_reg; t2_reg++)
6294                 {
6295                   if (t1_reg != t2_reg)
6296                     continue;
6297
6298                   if (t2_inout == 'i' && (t1_inout == 'm' || t1_inout == 'o'))
6299                     {
6300                       conflict = 'a';
6301                       continue;
6302                     }
6303
6304                   if (t1_inout == 'i' && (t2_inout == 'm' || t2_inout == 'o'))
6305                     {
6306                       conflict = 'a';
6307                       continue;
6308                     }
6309
6310                   if (t1_inout != 'i' && t2_inout != 'i')
6311                     return 'c';
6312                 }
6313             }
6314         }
6315     }
6316
6317   /* Check states.  */
6318   t1_states = xtensa_opcode_num_stateOperands (isa, t1->opcode);
6319   t2_states = xtensa_opcode_num_stateOperands (isa, t2->opcode);
6320   for (j = 0; j < t2_states; j++)
6321     {
6322       xtensa_state t2_so = xtensa_stateOperand_state (isa, t2->opcode, j);
6323       t2_inout = xtensa_stateOperand_inout (isa, t2->opcode, j);
6324       for (i = 0; i < t1_states; i++)
6325         {
6326           xtensa_state t1_so = xtensa_stateOperand_state (isa, t1->opcode, i);
6327           t1_inout = xtensa_stateOperand_inout (isa, t1->opcode, i);
6328           if (t1_so != t2_so)
6329             continue;
6330
6331           if (t2_inout == 'i' && (t1_inout == 'm' || t1_inout == 'o'))
6332             {
6333               conflict = 'a';
6334               continue;
6335             }
6336
6337           if (t1_inout == 'i' && (t2_inout == 'm' || t2_inout == 'o'))
6338             {
6339               conflict = 'a';
6340               continue;
6341             }
6342
6343           if (t1_inout != 'i' && t2_inout != 'i')
6344             return 'd';
6345         }
6346     }
6347
6348   /* Check tieports.  */
6349   t1_interfaces = xtensa_opcode_num_interfaceOperands (isa, t1->opcode);
6350   t2_interfaces = xtensa_opcode_num_interfaceOperands (isa, t2->opcode);
6351   for (j = 0; j < t2_interfaces; j++)
6352     {
6353       xtensa_interface t2_int
6354         = xtensa_interfaceOperand_interface (isa, t2->opcode, j);
6355       int t2_class = xtensa_interface_class_id (isa, t2_int);
6356
6357       t2_inout = xtensa_interface_inout (isa, j);
6358       if (xtensa_interface_has_side_effect (isa, t2_int) == 1)
6359         t2_volatile = TRUE;
6360
6361       for (i = 0; i < t1_interfaces; i++)
6362         {
6363           xtensa_interface t1_int
6364             = xtensa_interfaceOperand_interface (isa, t1->opcode, j);
6365           int t1_class = xtensa_interface_class_id (isa, t1_int);
6366
6367           t1_inout = xtensa_interface_inout (isa, i);
6368           if (xtensa_interface_has_side_effect (isa, t1_int) == 1)
6369             t1_volatile = TRUE;
6370
6371           if (t1_volatile && t2_volatile && (t1_class == t2_class))
6372             return 'f';
6373
6374           if (t1_int != t2_int)
6375             continue;
6376
6377           if (t2_inout == 'i' && t1_inout == 'o')
6378             {
6379               conflict = 'a';
6380               continue;
6381             }
6382
6383           if (t1_inout == 'i' && t2_inout == 'o')
6384             {
6385               conflict = 'a';
6386               continue;
6387             }
6388
6389           if (t1_inout != 'i' && t2_inout != 'i')
6390             return 'e';
6391         }
6392     }
6393
6394   return conflict;
6395 }
6396
6397
6398 static xtensa_format
6399 xg_find_narrowest_format (vliw_insn *vinsn)
6400 {
6401   /* Right now we assume that the ops within the vinsn are properly
6402      ordered for the slots that the programmer wanted them in.  In
6403      other words, we don't rearrange the ops in hopes of finding a
6404      better format.  The scheduler handles that.  */
6405
6406   xtensa_isa isa = xtensa_default_isa;
6407   xtensa_format format;
6408   vliw_insn v_copy = *vinsn;
6409   xtensa_opcode nop_opcode = xtensa_nop_opcode;
6410
6411   for (format = 0; format < xtensa_isa_num_formats (isa); format++)
6412     {
6413       v_copy = *vinsn;
6414       if (xtensa_format_num_slots (isa, format) == v_copy.num_slots)
6415         {
6416           int slot;
6417           int fit = 0;
6418           for (slot = 0; slot < v_copy.num_slots; slot++)
6419             {
6420               if (v_copy.slots[slot].opcode == nop_opcode)
6421                 {
6422                   v_copy.slots[slot].opcode =
6423                     xtensa_format_slot_nop_opcode (isa, format, slot);
6424                   v_copy.slots[slot].ntok = 0;
6425                 }
6426
6427               if (opcode_fits_format_slot (v_copy.slots[slot].opcode,
6428                                            format, slot))
6429                 fit++;
6430               else if (v_copy.num_slots > 1)
6431                 {
6432                   TInsn widened;
6433                   /* Try the widened version.  */
6434                   if (!v_copy.slots[slot].keep_wide
6435                       && !v_copy.slots[slot].is_specific_opcode
6436                       && xg_is_single_relaxable_insn (&v_copy.slots[slot],
6437                                                       &widened, TRUE)
6438                       && opcode_fits_format_slot (widened.opcode,
6439                                                   format, slot))
6440                     {
6441                       v_copy.slots[slot] = widened;
6442                       fit++;
6443                     }
6444                 }
6445             }
6446           if (fit == v_copy.num_slots)
6447             {
6448               *vinsn = v_copy;
6449               xtensa_format_encode (isa, format, vinsn->insnbuf);
6450               vinsn->format = format;
6451               break;
6452             }
6453         }
6454     }
6455
6456   if (format == xtensa_isa_num_formats (isa))
6457     return XTENSA_UNDEFINED;
6458
6459   return format;
6460 }
6461
6462
6463 /* Return the additional space needed in a frag
6464    for possible relaxations of any ops in a VLIW insn.
6465    Also fill out the relaxations that might be required of
6466    each tinsn in the vinsn.  */
6467
6468 static int
6469 relaxation_requirements (vliw_insn *vinsn)
6470 {
6471   int extra_space = 0;
6472   int slot;
6473
6474   for (slot = 0; slot < vinsn->num_slots; slot++)
6475     {
6476       TInsn *tinsn = &vinsn->slots[slot];
6477       if (!tinsn_has_symbolic_operands (tinsn))
6478         {
6479           /* A narrow instruction could be widened later to help
6480              alignment issues.  */
6481           if (xg_is_single_relaxable_insn (tinsn, 0, TRUE)
6482               && !tinsn->is_specific_opcode
6483               && vinsn->num_slots == 1)
6484             {
6485               /* Difference in bytes between narrow and wide insns...  */
6486               extra_space += 1;
6487               tinsn->subtype = RELAX_NARROW;
6488               tinsn->record_fix = TRUE;
6489               break;
6490             }
6491           else
6492             {
6493               tinsn->record_fix = FALSE;
6494               /* No extra_space needed.  */
6495             }
6496         }
6497       else
6498         {
6499           if (workaround_b_j_loop_end
6500               && tinsn->opcode == xtensa_jx_opcode
6501               && use_transform ())
6502             {
6503               /* Add 2 of these.  */
6504               extra_space += 3; /* for the nop size */
6505               tinsn->subtype = RELAX_ADD_NOP_IF_PRE_LOOP_END;
6506             }
6507
6508           /* Need to assemble it with space for the relocation.  */
6509           if (xg_is_relaxable_insn (tinsn, 0)
6510               && !tinsn->is_specific_opcode)
6511             {
6512               int max_size = xg_get_max_insn_widen_size (tinsn->opcode);
6513               int max_literal_size =
6514                 xg_get_max_insn_widen_literal_size (tinsn->opcode);
6515
6516               tinsn->literal_space = max_literal_size;
6517
6518               tinsn->subtype = RELAX_IMMED;
6519               tinsn->record_fix = FALSE;
6520               extra_space += max_size;
6521             }
6522           else
6523             {
6524               tinsn->record_fix = TRUE;
6525               /* No extra space needed.  */
6526             }
6527         }
6528     }
6529   return extra_space;
6530 }
6531
6532
6533 static void
6534 bundle_single_op (TInsn *orig_insn)
6535 {
6536   xtensa_isa isa = xtensa_default_isa;
6537   vliw_insn v;
6538   int slot;
6539
6540   xg_init_vinsn (&v);
6541   v.format = op_placement_table[orig_insn->opcode].narrowest;
6542   assert (v.format != XTENSA_UNDEFINED);
6543   v.num_slots = xtensa_format_num_slots (isa, v.format);
6544
6545   for (slot = 0;
6546        !opcode_fits_format_slot (orig_insn->opcode, v.format, slot);
6547        slot++)
6548     {
6549       v.slots[slot].opcode =
6550         xtensa_format_slot_nop_opcode (isa, v.format, slot);
6551       v.slots[slot].ntok = 0;
6552       v.slots[slot].insn_type = ITYPE_INSN;
6553     }
6554
6555   v.slots[slot] = *orig_insn;
6556   slot++;
6557
6558   for ( ; slot < v.num_slots; slot++)
6559     {
6560       v.slots[slot].opcode =
6561         xtensa_format_slot_nop_opcode (isa, v.format, slot);
6562       v.slots[slot].ntok = 0;
6563       v.slots[slot].insn_type = ITYPE_INSN;
6564     }
6565
6566   finish_vinsn (&v);
6567   xg_free_vinsn (&v);
6568 }
6569
6570
6571 static bfd_boolean
6572 emit_single_op (TInsn *orig_insn)
6573 {
6574   int i;
6575   IStack istack;                /* put instructions into here */
6576   symbolS *lit_sym = NULL;
6577   symbolS *label_sym = NULL;
6578
6579   istack_init (&istack);
6580
6581   /* Special-case for "movi aX, foo" which is guaranteed to need relaxing.
6582      Because the scheduling and bundling characteristics of movi and
6583      l32r or const16 are so different, we can do much better if we relax
6584      it prior to scheduling and bundling, rather than after.  */
6585   if ((orig_insn->opcode == xtensa_movi_opcode
6586        || orig_insn->opcode == xtensa_movi_n_opcode)
6587       && !cur_vinsn.inside_bundle
6588       && (orig_insn->tok[1].X_op == O_symbol
6589           || orig_insn->tok[1].X_op == O_pltrel))
6590     xg_assembly_relax (&istack, orig_insn, now_seg, frag_now, 0, 1, 0);
6591   else
6592     if (xg_expand_assembly_insn (&istack, orig_insn))
6593       return TRUE;
6594
6595   for (i = 0; i < istack.ninsn; i++)
6596     {
6597       TInsn *insn = &istack.insn[i];
6598       switch (insn->insn_type)
6599         {
6600         case ITYPE_LITERAL:
6601           assert (lit_sym == NULL);
6602           lit_sym = xg_assemble_literal (insn);
6603           break;
6604         case ITYPE_LABEL:
6605           {
6606             static int relaxed_sym_idx = 0;
6607             char *label = xmalloc (strlen (FAKE_LABEL_NAME) + 12);
6608             sprintf (label, "%s_rl_%x", FAKE_LABEL_NAME, relaxed_sym_idx++);
6609             colon (label);
6610             assert (label_sym == NULL);
6611             label_sym = symbol_find_or_make (label);
6612             assert (label_sym);
6613             free (label);
6614           }
6615           break;
6616         case ITYPE_INSN:
6617           if (lit_sym)
6618             xg_resolve_literals (insn, lit_sym);
6619           if (label_sym)
6620             xg_resolve_labels (insn, label_sym);
6621           bundle_single_op (insn);
6622           break;
6623         default:
6624           assert (0);
6625           break;
6626         }
6627     }
6628   return FALSE;
6629 }
6630
6631
6632 static int
6633 total_frag_text_expansion (fragS *fragP)
6634 {
6635   int slot;
6636   int total_expansion = 0;
6637
6638   for (slot = 0; slot < MAX_SLOTS; slot++)
6639     total_expansion += fragP->tc_frag_data.text_expansion[slot];
6640
6641   return total_expansion;
6642 }
6643
6644
6645 /* Emit a vliw instruction to the current fragment.  */
6646
6647 static void
6648 xg_assemble_vliw_tokens (vliw_insn *vinsn)
6649 {
6650   bfd_boolean finish_frag = FALSE;
6651   bfd_boolean is_jump = FALSE;
6652   bfd_boolean is_branch = FALSE;
6653   xtensa_isa isa = xtensa_default_isa;
6654   int i;
6655   int insn_size;
6656   int extra_space;
6657   char *f = NULL;
6658   int slot;
6659   struct dwarf2_line_info best_loc;
6660
6661   best_loc.line = INT_MAX;
6662
6663   if (generating_literals)
6664     {
6665       static int reported = 0;
6666       if (reported < 4)
6667         as_bad_where (frag_now->fr_file, frag_now->fr_line,
6668                       _("cannot assemble into a literal fragment"));
6669       if (reported == 3)
6670         as_bad (_("..."));
6671       reported++;
6672       return;
6673     }
6674
6675   if (frag_now_fix () != 0
6676       && (! frag_now->tc_frag_data.is_insn
6677           || (vinsn_has_specific_opcodes (vinsn) && use_transform ())
6678           || !use_transform () != frag_now->tc_frag_data.is_no_transform
6679           || (directive_state[directive_longcalls]
6680               != frag_now->tc_frag_data.use_longcalls)
6681           || (directive_state[directive_absolute_literals]
6682               != frag_now->tc_frag_data.use_absolute_literals)))
6683     {
6684       frag_wane (frag_now);
6685       frag_new (0);
6686       xtensa_set_frag_assembly_state (frag_now);
6687     }
6688
6689   if (workaround_a0_b_retw
6690       && vinsn->num_slots == 1
6691       && (get_last_insn_flags (now_seg, now_subseg) & FLAG_IS_A0_WRITER) != 0
6692       && xtensa_opcode_is_branch (isa, vinsn->slots[0].opcode) == 1
6693       && use_transform ())
6694     {
6695       has_a0_b_retw = TRUE;
6696
6697       /* Mark this fragment with the special RELAX_ADD_NOP_IF_A0_B_RETW.
6698          After the first assembly pass we will check all of them and
6699          add a nop if needed.  */
6700       frag_now->tc_frag_data.is_insn = TRUE;
6701       frag_var (rs_machine_dependent, 4, 4,
6702                 RELAX_ADD_NOP_IF_A0_B_RETW,
6703                 frag_now->fr_symbol,
6704                 frag_now->fr_offset,
6705                 NULL);
6706       xtensa_set_frag_assembly_state (frag_now);
6707       frag_now->tc_frag_data.is_insn = TRUE;
6708       frag_var (rs_machine_dependent, 4, 4,
6709                 RELAX_ADD_NOP_IF_A0_B_RETW,
6710                 frag_now->fr_symbol,
6711                 frag_now->fr_offset,
6712                 NULL);
6713       xtensa_set_frag_assembly_state (frag_now);
6714     }
6715
6716   for (i = 0; i < vinsn->num_slots; i++)
6717     {
6718       /* See if the instruction implies an aligned section.  */
6719       if (xtensa_opcode_is_loop (isa, vinsn->slots[i].opcode) == 1)
6720         record_alignment (now_seg, 2);
6721
6722       /* Also determine the best line number for debug info.  */
6723       best_loc = vinsn->slots[i].loc.line < best_loc.line
6724         ? vinsn->slots[i].loc : best_loc;
6725     }
6726
6727   /* Special cases for instructions that force an alignment... */
6728   /* None of these opcodes are bundle-able.  */
6729   if (xtensa_opcode_is_loop (isa, vinsn->slots[0].opcode) == 1)
6730     {
6731       int max_fill;
6732
6733       xtensa_set_frag_assembly_state (frag_now);
6734       frag_now->tc_frag_data.is_insn = TRUE;
6735
6736       max_fill = get_text_align_max_fill_size
6737         (get_text_align_power (xtensa_fetch_width),
6738          TRUE, frag_now->tc_frag_data.is_no_density);
6739
6740       if (use_transform ())
6741         frag_var (rs_machine_dependent, max_fill, max_fill,
6742                   RELAX_ALIGN_NEXT_OPCODE,
6743                   frag_now->fr_symbol,
6744                   frag_now->fr_offset,
6745                   NULL);
6746       else
6747         frag_var (rs_machine_dependent, 0, 0,
6748                   RELAX_CHECK_ALIGN_NEXT_OPCODE, 0, 0, NULL);
6749       xtensa_set_frag_assembly_state (frag_now);
6750
6751       xtensa_move_labels (frag_now, 0, FALSE);
6752     }
6753
6754   if (vinsn->slots[0].opcode == xtensa_entry_opcode
6755       && !vinsn->slots[0].is_specific_opcode)
6756     {
6757       xtensa_mark_literal_pool_location ();
6758       xtensa_move_labels (frag_now, 0, TRUE);
6759       frag_var (rs_align_test, 1, 1, 0, NULL, 2, NULL);
6760     }
6761
6762   if (vinsn->num_slots == 1)
6763     {
6764       if (workaround_a0_b_retw && use_transform ())
6765         set_last_insn_flags (now_seg, now_subseg, FLAG_IS_A0_WRITER,
6766                              is_register_writer (&vinsn->slots[0], "a", 0));
6767
6768       set_last_insn_flags (now_seg, now_subseg, FLAG_IS_BAD_LOOPEND,
6769                            is_bad_loopend_opcode (&vinsn->slots[0]));
6770     }
6771   else
6772     set_last_insn_flags (now_seg, now_subseg, FLAG_IS_BAD_LOOPEND, FALSE);
6773
6774   insn_size = xtensa_format_length (isa, vinsn->format);
6775
6776   extra_space = relaxation_requirements (vinsn);
6777
6778   /* vinsn_to_insnbuf will produce the error.  */
6779   if (vinsn->format != XTENSA_UNDEFINED)
6780     {
6781       f = frag_more (insn_size + extra_space);
6782       xtensa_set_frag_assembly_state (frag_now);
6783       frag_now->tc_frag_data.is_insn = TRUE;
6784     }
6785
6786   vinsn_to_insnbuf (vinsn, f, frag_now, TRUE);
6787   if (vinsn->format == XTENSA_UNDEFINED)
6788     return;
6789
6790   xtensa_insnbuf_to_chars (isa, vinsn->insnbuf, (unsigned char *) f, 0);
6791
6792   xtensa_dwarf2_emit_insn (insn_size - extra_space, &best_loc);
6793
6794   for (slot = 0; slot < vinsn->num_slots; slot++)
6795     {
6796       TInsn *tinsn = &vinsn->slots[slot];
6797       frag_now->tc_frag_data.slot_subtypes[slot] = tinsn->subtype;
6798       frag_now->tc_frag_data.slot_symbols[slot] = tinsn->symbol;
6799       frag_now->tc_frag_data.slot_sub_symbols[slot] = tinsn->sub_symbol;
6800       frag_now->tc_frag_data.slot_offsets[slot] = tinsn->offset;
6801       frag_now->tc_frag_data.literal_frags[slot] = tinsn->literal_frag;
6802       if (tinsn->literal_space != 0)
6803         xg_assemble_literal_space (tinsn->literal_space, slot);
6804
6805       if (tinsn->subtype == RELAX_NARROW)
6806         assert (vinsn->num_slots == 1);
6807       if (xtensa_opcode_is_jump (isa, tinsn->opcode) == 1)
6808         is_jump = TRUE;
6809       if (xtensa_opcode_is_branch (isa, tinsn->opcode) == 1)
6810         is_branch = TRUE;
6811
6812       if (tinsn->subtype || tinsn->symbol || tinsn->record_fix
6813           || tinsn->offset || tinsn->literal_frag || is_jump || is_branch)
6814         finish_frag = TRUE;
6815     }
6816
6817   if (vinsn_has_specific_opcodes (vinsn) && use_transform ())
6818     frag_now->tc_frag_data.is_specific_opcode = TRUE;
6819
6820   if (finish_frag)
6821     {
6822       frag_variant (rs_machine_dependent,
6823                     extra_space, extra_space, RELAX_SLOTS,
6824                     frag_now->fr_symbol, frag_now->fr_offset, f);
6825       xtensa_set_frag_assembly_state (frag_now);
6826     }
6827
6828   /* Special cases for loops:
6829      close_loop_end should be inserted AFTER short_loop.
6830      Make sure that CLOSE loops are processed BEFORE short_loops
6831      when converting them.  */
6832
6833   /* "short_loop": Add a NOP if the loop is < 4 bytes.  */
6834   if (xtensa_opcode_is_loop (isa, vinsn->slots[0].opcode)
6835       && !vinsn->slots[0].is_specific_opcode)
6836     {
6837       if (workaround_short_loop && use_transform ())
6838         {
6839           maybe_has_short_loop = TRUE;
6840           frag_now->tc_frag_data.is_insn = TRUE;
6841           frag_var (rs_machine_dependent, 4, 4,
6842                     RELAX_ADD_NOP_IF_SHORT_LOOP,
6843                     frag_now->fr_symbol, frag_now->fr_offset, NULL);
6844           frag_now->tc_frag_data.is_insn = TRUE;
6845           frag_var (rs_machine_dependent, 4, 4,
6846                     RELAX_ADD_NOP_IF_SHORT_LOOP,
6847                     frag_now->fr_symbol, frag_now->fr_offset, NULL);
6848         }
6849
6850       /* "close_loop_end": Add up to 12 bytes of NOPs to keep a
6851          loop at least 12 bytes away from another loop's end.  */
6852       if (workaround_close_loop_end && use_transform ())
6853         {
6854           maybe_has_close_loop_end = TRUE;
6855           frag_now->tc_frag_data.is_insn = TRUE;
6856           frag_var (rs_machine_dependent, 12, 12,
6857                     RELAX_ADD_NOP_IF_CLOSE_LOOP_END,
6858                     frag_now->fr_symbol, frag_now->fr_offset, NULL);
6859         }
6860     }
6861
6862   if (use_transform ())
6863     {
6864       if (is_jump)
6865         {
6866           assert (finish_frag);
6867           frag_var (rs_machine_dependent,
6868                     UNREACHABLE_MAX_WIDTH, UNREACHABLE_MAX_WIDTH,
6869                     RELAX_UNREACHABLE,
6870                     frag_now->fr_symbol, frag_now->fr_offset, NULL);
6871           xtensa_set_frag_assembly_state (frag_now);
6872         }
6873       else if (is_branch && do_align_targets ())
6874         {
6875           assert (finish_frag);
6876           frag_var (rs_machine_dependent,
6877                     UNREACHABLE_MAX_WIDTH, UNREACHABLE_MAX_WIDTH,
6878                     RELAX_MAYBE_UNREACHABLE,
6879                     frag_now->fr_symbol, frag_now->fr_offset, NULL);
6880           xtensa_set_frag_assembly_state (frag_now);
6881           frag_var (rs_machine_dependent,
6882                     0, 0,
6883                     RELAX_MAYBE_DESIRE_ALIGN,
6884                     frag_now->fr_symbol, frag_now->fr_offset, NULL);
6885           xtensa_set_frag_assembly_state (frag_now);
6886         }
6887     }
6888
6889   /* Now, if the original opcode was a call...  */
6890   if (do_align_targets ()
6891       && xtensa_opcode_is_call (isa, vinsn->slots[0].opcode) == 1)
6892     {
6893       float freq = get_subseg_total_freq (now_seg, now_subseg);
6894       frag_now->tc_frag_data.is_insn = TRUE;
6895       frag_var (rs_machine_dependent, 4, (int) freq, RELAX_DESIRE_ALIGN,
6896                 frag_now->fr_symbol, frag_now->fr_offset, NULL);
6897       xtensa_set_frag_assembly_state (frag_now);
6898     }
6899
6900   if (vinsn_has_specific_opcodes (vinsn) && use_transform ())
6901     {
6902       frag_wane (frag_now);
6903       frag_new (0);
6904       xtensa_set_frag_assembly_state (frag_now);
6905     }
6906 }
6907
6908 \f
6909 /* xtensa_end and helper functions.  */
6910
6911 static void xtensa_cleanup_align_frags (void);
6912 static void xtensa_fix_target_frags (void);
6913 static void xtensa_mark_narrow_branches (void);
6914 static void xtensa_mark_zcl_first_insns (void);
6915 static void xtensa_fix_a0_b_retw_frags (void);
6916 static void xtensa_fix_b_j_loop_end_frags (void);
6917 static void xtensa_fix_close_loop_end_frags (void);
6918 static void xtensa_fix_short_loop_frags (void);
6919 static void xtensa_sanity_check (void);
6920
6921 void
6922 xtensa_end (void)
6923 {
6924   directive_balance ();
6925   xtensa_flush_pending_output ();
6926
6927   past_xtensa_end = TRUE;
6928
6929   xtensa_move_literals ();
6930
6931   xtensa_reorder_segments ();
6932   xtensa_cleanup_align_frags ();
6933   xtensa_fix_target_frags ();
6934   if (workaround_a0_b_retw && has_a0_b_retw)
6935     xtensa_fix_a0_b_retw_frags ();
6936   if (workaround_b_j_loop_end)
6937     xtensa_fix_b_j_loop_end_frags ();
6938
6939   /* "close_loop_end" should be processed BEFORE "short_loop".  */
6940   if (workaround_close_loop_end && maybe_has_close_loop_end)
6941     xtensa_fix_close_loop_end_frags ();
6942
6943   if (workaround_short_loop && maybe_has_short_loop)
6944     xtensa_fix_short_loop_frags ();
6945   xtensa_mark_narrow_branches ();
6946   xtensa_mark_zcl_first_insns ();
6947
6948   xtensa_sanity_check ();
6949 }
6950
6951
6952 static void
6953 xtensa_cleanup_align_frags (void)
6954 {
6955   frchainS *frchP;
6956
6957   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
6958     {
6959       fragS *fragP;
6960       /* Walk over all of the fragments in a subsection.  */
6961       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
6962         {
6963           if ((fragP->fr_type == rs_align
6964                || fragP->fr_type == rs_align_code
6965                || (fragP->fr_type == rs_machine_dependent
6966                    && (fragP->fr_subtype == RELAX_DESIRE_ALIGN
6967                        || fragP->fr_subtype == RELAX_DESIRE_ALIGN_IF_TARGET)))
6968               && fragP->fr_fix == 0)
6969             {
6970               fragS *next = fragP->fr_next;
6971
6972               while (next
6973                      && next->fr_fix == 0
6974                      && next->fr_type == rs_machine_dependent
6975                      && next->fr_subtype == RELAX_DESIRE_ALIGN_IF_TARGET)
6976                 {
6977                   frag_wane (next);
6978                   next = next->fr_next;
6979                 }
6980             }
6981           /* If we don't widen branch targets, then they
6982              will be easier to align.  */
6983           if (fragP->tc_frag_data.is_branch_target
6984               && fragP->fr_opcode == fragP->fr_literal
6985               && fragP->fr_type == rs_machine_dependent
6986               && fragP->fr_subtype == RELAX_SLOTS
6987               && fragP->tc_frag_data.slot_subtypes[0] == RELAX_NARROW)
6988             frag_wane (fragP);
6989           if (fragP->fr_type == rs_machine_dependent
6990               && fragP->fr_subtype == RELAX_UNREACHABLE)
6991             fragP->tc_frag_data.is_unreachable = TRUE;
6992         }
6993     }
6994 }
6995
6996
6997 /* Re-process all of the fragments looking to convert all of the
6998    RELAX_DESIRE_ALIGN_IF_TARGET fragments.  If there is a branch
6999    target in the next fragment, convert this to RELAX_DESIRE_ALIGN.
7000    Otherwise, convert to a .fill 0.  */
7001
7002 static void
7003 xtensa_fix_target_frags (void)
7004 {
7005   frchainS *frchP;
7006
7007   /* When this routine is called, all of the subsections are still intact
7008      so we walk over subsections instead of sections.  */
7009   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
7010     {
7011       fragS *fragP;
7012
7013       /* Walk over all of the fragments in a subsection.  */
7014       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
7015         {
7016           if (fragP->fr_type == rs_machine_dependent
7017               && fragP->fr_subtype == RELAX_DESIRE_ALIGN_IF_TARGET)
7018             {
7019               if (next_frag_is_branch_target (fragP))
7020                 fragP->fr_subtype = RELAX_DESIRE_ALIGN;
7021               else
7022                 frag_wane (fragP);
7023             }
7024         }
7025     }
7026 }
7027
7028
7029 static bfd_boolean is_narrow_branch_guaranteed_in_range (fragS *, TInsn *);
7030
7031 static void
7032 xtensa_mark_narrow_branches (void)
7033 {
7034   frchainS *frchP;
7035
7036   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
7037     {
7038       fragS *fragP;
7039       /* Walk over all of the fragments in a subsection.  */
7040       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
7041         {
7042           if (fragP->fr_type == rs_machine_dependent
7043               && fragP->fr_subtype == RELAX_SLOTS
7044               && fragP->tc_frag_data.slot_subtypes[0] == RELAX_IMMED)
7045             {
7046               vliw_insn vinsn;
7047               const expressionS *expr;
7048               symbolS *symbolP;
7049
7050               vinsn_from_chars (&vinsn, fragP->fr_opcode);
7051               tinsn_immed_from_frag (&vinsn.slots[0], fragP, 0);
7052
7053               expr = &vinsn.slots[0].tok[1];
7054               symbolP = expr->X_add_symbol;
7055
7056               if (vinsn.num_slots == 1
7057                   && xtensa_opcode_is_branch (xtensa_default_isa,
7058                                               vinsn.slots[0].opcode)
7059                   && xg_get_single_size (vinsn.slots[0].opcode) == 2
7060                   && is_narrow_branch_guaranteed_in_range (fragP,
7061                                                            &vinsn.slots[0]))
7062                 {
7063                   fragP->fr_subtype = RELAX_SLOTS;
7064                   fragP->tc_frag_data.slot_subtypes[0] = RELAX_NARROW;
7065                 }
7066             }
7067         }
7068     }
7069 }
7070
7071
7072 /* A branch is typically widened only when its target is out of
7073    range.  However, we would like to widen them to align a subsequent
7074    branch target when possible.
7075
7076    Because the branch relaxation code is so convoluted, the optimal solution
7077    (combining the two cases) is difficult to get right in all circumstances.
7078    We therefore go with an "almost as good" solution, where we only
7079    use for alignment narrow branches that definitely will not expand to a
7080    jump and a branch.  These functions find and mark these cases.  */
7081
7082 /* The range in bytes of BNEZ.N and BEQZ.N.  The target operand is encoded
7083    as PC + 4 + imm6, where imm6 is a 6-bit immediate ranging from 0 to 63.
7084    We start counting beginning with the frag after the 2-byte branch, so the
7085    maximum offset is (4 - 2) + 63 = 65.  */
7086 #define MAX_IMMED6 65
7087
7088 static offsetT unrelaxed_frag_max_size (fragS *);
7089
7090 static bfd_boolean
7091 is_narrow_branch_guaranteed_in_range (fragS *fragP, TInsn *tinsn)
7092 {
7093   const expressionS *expr = &tinsn->tok[1];
7094   symbolS *symbolP = expr->X_add_symbol;
7095   fragS *target_frag = symbol_get_frag (symbolP);
7096   offsetT max_distance = expr->X_add_number;
7097   max_distance += (S_GET_VALUE (symbolP) - target_frag->fr_address);
7098   if (is_branch_jmp_to_next (tinsn, fragP))
7099     return FALSE;
7100
7101   /* The branch doesn't branch over it's own frag,
7102      but over the subsequent ones.  */
7103   fragP = fragP->fr_next;
7104   while (fragP != NULL && fragP != target_frag && max_distance <= MAX_IMMED6)
7105     {
7106       max_distance += unrelaxed_frag_max_size (fragP);
7107       fragP = fragP->fr_next;
7108     }
7109   if (max_distance <= MAX_IMMED6 && fragP == target_frag)
7110     return TRUE;
7111   return FALSE;
7112 }
7113
7114
7115 static void
7116 xtensa_mark_zcl_first_insns (void)
7117 {
7118   frchainS *frchP;
7119
7120   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
7121     {
7122       fragS *fragP;
7123       /* Walk over all of the fragments in a subsection.  */
7124       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
7125         {
7126           if (fragP->fr_type == rs_machine_dependent
7127               && (fragP->fr_subtype == RELAX_ALIGN_NEXT_OPCODE
7128                   || fragP->fr_subtype == RELAX_CHECK_ALIGN_NEXT_OPCODE))
7129             {
7130               /* Find the loop frag.  */
7131               fragS *targ_frag = next_non_empty_frag (fragP);
7132               /* Find the first insn frag.  */
7133               targ_frag = next_non_empty_frag (targ_frag);
7134
7135               /* Of course, sometimes (mostly for toy test cases) a
7136                  zero-cost loop instruction is the last in a section.  */
7137               if (targ_frag)
7138                 {
7139                   targ_frag->tc_frag_data.is_first_loop_insn = TRUE;
7140                   if (fragP->fr_subtype == RELAX_CHECK_ALIGN_NEXT_OPCODE)
7141                     frag_wane (fragP);
7142                 }
7143             }
7144         }
7145     }
7146 }
7147
7148
7149 /* Re-process all of the fragments looking to convert all of the
7150    RELAX_ADD_NOP_IF_A0_B_RETW.  If the next instruction is a
7151    conditional branch or a retw/retw.n, convert this frag to one that
7152    will generate a NOP.  In any case close it off with a .fill 0.  */
7153
7154 static bfd_boolean next_instrs_are_b_retw (fragS *);
7155
7156 static void
7157 xtensa_fix_a0_b_retw_frags (void)
7158 {
7159   frchainS *frchP;
7160
7161   /* When this routine is called, all of the subsections are still intact
7162      so we walk over subsections instead of sections.  */
7163   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
7164     {
7165       fragS *fragP;
7166
7167       /* Walk over all of the fragments in a subsection.  */
7168       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
7169         {
7170           if (fragP->fr_type == rs_machine_dependent
7171               && fragP->fr_subtype == RELAX_ADD_NOP_IF_A0_B_RETW)
7172             {
7173               if (next_instrs_are_b_retw (fragP))
7174                 {
7175                   if (fragP->tc_frag_data.is_no_transform)
7176                     as_bad (_("instruction sequence (write a0, branch, retw) may trigger hardware errata"));
7177                   else
7178                     relax_frag_add_nop (fragP);
7179                 }
7180               frag_wane (fragP);
7181             }
7182         }
7183     }
7184 }
7185
7186
7187 static bfd_boolean
7188 next_instrs_are_b_retw (fragS *fragP)
7189 {
7190   xtensa_opcode opcode;
7191   xtensa_format fmt;
7192   const fragS *next_fragP = next_non_empty_frag (fragP);
7193   static xtensa_insnbuf insnbuf = NULL;
7194   static xtensa_insnbuf slotbuf = NULL;
7195   xtensa_isa isa = xtensa_default_isa;
7196   int offset = 0;
7197   int slot;
7198   bfd_boolean branch_seen = FALSE;
7199
7200   if (!insnbuf)
7201     {
7202       insnbuf = xtensa_insnbuf_alloc (isa);
7203       slotbuf = xtensa_insnbuf_alloc (isa);
7204     }
7205
7206   if (next_fragP == NULL)
7207     return FALSE;
7208
7209   /* Check for the conditional branch.  */
7210   xtensa_insnbuf_from_chars
7211     (isa, insnbuf, (unsigned char *) &next_fragP->fr_literal[offset], 0);
7212   fmt = xtensa_format_decode (isa, insnbuf);
7213   if (fmt == XTENSA_UNDEFINED)
7214     return FALSE;
7215
7216   for (slot = 0; slot < xtensa_format_num_slots (isa, fmt); slot++)
7217     {
7218       xtensa_format_get_slot (isa, fmt, slot, insnbuf, slotbuf);
7219       opcode = xtensa_opcode_decode (isa, fmt, slot, slotbuf);
7220
7221       branch_seen = (branch_seen
7222                      || xtensa_opcode_is_branch (isa, opcode) == 1);
7223     }
7224
7225   if (!branch_seen)
7226     return FALSE;
7227
7228   offset += xtensa_format_length (isa, fmt);
7229   if (offset == next_fragP->fr_fix)
7230     {
7231       next_fragP = next_non_empty_frag (next_fragP);
7232       offset = 0;
7233     }
7234
7235   if (next_fragP == NULL)
7236     return FALSE;
7237
7238   /* Check for the retw/retw.n.  */
7239   xtensa_insnbuf_from_chars
7240     (isa, insnbuf, (unsigned char *) &next_fragP->fr_literal[offset], 0);
7241   fmt = xtensa_format_decode (isa, insnbuf);
7242
7243   /* Because RETW[.N] is not bundleable, a VLIW bundle here means that we
7244      have no problems.  */
7245   if (fmt == XTENSA_UNDEFINED
7246       || xtensa_format_num_slots (isa, fmt) != 1)
7247     return FALSE;
7248
7249   xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf);
7250   opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
7251
7252   if (opcode == xtensa_retw_opcode || opcode == xtensa_retw_n_opcode)
7253     return TRUE;
7254
7255   return FALSE;
7256 }
7257
7258
7259 /* Re-process all of the fragments looking to convert all of the
7260    RELAX_ADD_NOP_IF_PRE_LOOP_END.  If there is one instruction and a
7261    loop end label, convert this frag to one that will generate a NOP.
7262    In any case close it off with a .fill 0.  */
7263
7264 static bfd_boolean next_instr_is_loop_end (fragS *);
7265
7266 static void
7267 xtensa_fix_b_j_loop_end_frags (void)
7268 {
7269   frchainS *frchP;
7270
7271   /* When this routine is called, all of the subsections are still intact
7272      so we walk over subsections instead of sections.  */
7273   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
7274     {
7275       fragS *fragP;
7276
7277       /* Walk over all of the fragments in a subsection.  */
7278       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
7279         {
7280           if (fragP->fr_type == rs_machine_dependent
7281               && fragP->fr_subtype == RELAX_ADD_NOP_IF_PRE_LOOP_END)
7282             {
7283               if (next_instr_is_loop_end (fragP))
7284                 {
7285                   if (fragP->tc_frag_data.is_no_transform)
7286                     as_bad (_("branching or jumping to a loop end may trigger hardware errata"));
7287                   else
7288                     relax_frag_add_nop (fragP);
7289                 }
7290               frag_wane (fragP);
7291             }
7292         }
7293     }
7294 }
7295
7296
7297 static bfd_boolean
7298 next_instr_is_loop_end (fragS *fragP)
7299 {
7300   const fragS *next_fragP;
7301
7302   if (next_frag_is_loop_target (fragP))
7303     return FALSE;
7304
7305   next_fragP = next_non_empty_frag (fragP);
7306   if (next_fragP == NULL)
7307     return FALSE;
7308
7309   if (!next_frag_is_loop_target (next_fragP))
7310     return FALSE;
7311
7312   /* If the size is >= 3 then there is more than one instruction here.
7313      The hardware bug will not fire.  */
7314   if (next_fragP->fr_fix > 3)
7315     return FALSE;
7316
7317   return TRUE;
7318 }
7319
7320
7321 /* Re-process all of the fragments looking to convert all of the
7322    RELAX_ADD_NOP_IF_CLOSE_LOOP_END.  If there is an loop end that is
7323    not MY loop's loop end within 12 bytes, add enough nops here to
7324    make it at least 12 bytes away.  In any case close it off with a
7325    .fill 0.  */
7326
7327 static offsetT min_bytes_to_other_loop_end
7328   (fragS *, fragS *, offsetT, offsetT);
7329
7330 static void
7331 xtensa_fix_close_loop_end_frags (void)
7332 {
7333   frchainS *frchP;
7334
7335   /* When this routine is called, all of the subsections are still intact
7336      so we walk over subsections instead of sections.  */
7337   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
7338     {
7339       fragS *fragP;
7340
7341       fragS *current_target = NULL;
7342       offsetT current_offset = 0;
7343
7344       /* Walk over all of the fragments in a subsection.  */
7345       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
7346         {
7347           if (fragP->fr_type == rs_machine_dependent
7348               && ((fragP->fr_subtype == RELAX_IMMED)
7349                   || ((fragP->fr_subtype == RELAX_SLOTS)
7350                       && (fragP->tc_frag_data.slot_subtypes[0]
7351                           == RELAX_IMMED))))
7352             {
7353               /* Read it.  If the instruction is a loop, get the target.  */
7354               TInsn t_insn;
7355               tinsn_from_chars (&t_insn, fragP->fr_opcode, 0);
7356               if (xtensa_opcode_is_loop (xtensa_default_isa,
7357                                          t_insn.opcode) == 1)
7358                 {
7359                   /* Get the current fragment target.  */
7360                   if (fragP->tc_frag_data.slot_symbols[0])
7361                     {
7362                       symbolS *sym = fragP->tc_frag_data.slot_symbols[0];
7363                       current_target = symbol_get_frag (sym);
7364                       current_offset = fragP->fr_offset;
7365                     }
7366                 }
7367             }
7368
7369           if (current_target
7370               && fragP->fr_type == rs_machine_dependent
7371               && fragP->fr_subtype == RELAX_ADD_NOP_IF_CLOSE_LOOP_END)
7372             {
7373               offsetT min_bytes;
7374               int bytes_added = 0;
7375
7376 #define REQUIRED_LOOP_DIVIDING_BYTES 12
7377               /* Max out at 12.  */
7378               min_bytes = min_bytes_to_other_loop_end
7379                 (fragP->fr_next, current_target, current_offset,
7380                  REQUIRED_LOOP_DIVIDING_BYTES);
7381
7382               if (min_bytes < REQUIRED_LOOP_DIVIDING_BYTES)
7383                 {
7384                   if (fragP->tc_frag_data.is_no_transform)
7385                     as_bad (_("loop end too close to another loop end may trigger hardware errata"));
7386                   else
7387                     {
7388                       while (min_bytes + bytes_added
7389                              < REQUIRED_LOOP_DIVIDING_BYTES)
7390                         {
7391                           int length = 3;
7392
7393                           if (fragP->fr_var < length)
7394                             as_fatal (_("fr_var %lu < length %d"),
7395                                       (long) fragP->fr_var, length);
7396                           else
7397                             {
7398                               assemble_nop (length,
7399                                             fragP->fr_literal + fragP->fr_fix);
7400                               fragP->fr_fix += length;
7401                               fragP->fr_var -= length;
7402                             }
7403                           bytes_added += length;
7404                         }
7405                     }
7406                 }
7407               frag_wane (fragP);
7408             }
7409           assert (fragP->fr_type != rs_machine_dependent
7410                   || fragP->fr_subtype != RELAX_ADD_NOP_IF_CLOSE_LOOP_END);
7411         }
7412     }
7413 }
7414
7415
7416 static offsetT unrelaxed_frag_min_size (fragS *);
7417
7418 static offsetT
7419 min_bytes_to_other_loop_end (fragS *fragP,
7420                              fragS *current_target,
7421                              offsetT current_offset,
7422                              offsetT max_size)
7423 {
7424   offsetT offset = 0;
7425   fragS *current_fragP;
7426
7427   for (current_fragP = fragP;
7428        current_fragP;
7429        current_fragP = current_fragP->fr_next)
7430     {
7431       if (current_fragP->tc_frag_data.is_loop_target
7432           && current_fragP != current_target)
7433         return offset + current_offset;
7434
7435       offset += unrelaxed_frag_min_size (current_fragP);
7436
7437       if (offset + current_offset >= max_size)
7438         return max_size;
7439     }
7440   return max_size;
7441 }
7442
7443
7444 static offsetT
7445 unrelaxed_frag_min_size (fragS *fragP)
7446 {
7447   offsetT size = fragP->fr_fix;
7448
7449   /* Add fill size.  */
7450   if (fragP->fr_type == rs_fill)
7451     size += fragP->fr_offset;
7452
7453   return size;
7454 }
7455
7456
7457 static offsetT
7458 unrelaxed_frag_max_size (fragS *fragP)
7459 {
7460   offsetT size = fragP->fr_fix;
7461   switch (fragP->fr_type)
7462     {
7463     case 0:
7464       /* Empty frags created by the obstack allocation scheme
7465          end up with type 0.  */
7466       break;
7467     case rs_fill:
7468     case rs_org:
7469     case rs_space:
7470       size += fragP->fr_offset;
7471       break;
7472     case rs_align:
7473     case rs_align_code:
7474     case rs_align_test:
7475     case rs_leb128:
7476     case rs_cfa:
7477     case rs_dwarf2dbg:
7478       /* No further adjustments needed.  */
7479       break;
7480     case rs_machine_dependent:
7481       if (fragP->fr_subtype != RELAX_DESIRE_ALIGN)
7482         size += fragP->fr_var;
7483       break;
7484     default:
7485       /* We had darn well better know how big it is.  */
7486       assert (0);
7487       break;
7488     }
7489
7490   return size;
7491 }
7492
7493
7494 /* Re-process all of the fragments looking to convert all
7495    of the RELAX_ADD_NOP_IF_SHORT_LOOP.  If:
7496
7497    A)
7498      1) the instruction size count to the loop end label
7499         is too short (<= 2 instructions),
7500      2) loop has a jump or branch in it
7501
7502    or B)
7503      1) workaround_all_short_loops is TRUE
7504      2) The generating loop was a  'loopgtz' or 'loopnez'
7505      3) the instruction size count to the loop end label is too short
7506         (<= 2 instructions)
7507    then convert this frag (and maybe the next one) to generate a NOP.
7508    In any case close it off with a .fill 0.  */
7509
7510 static int count_insns_to_loop_end (fragS *, bfd_boolean, int);
7511 static bfd_boolean branch_before_loop_end (fragS *);
7512
7513 static void
7514 xtensa_fix_short_loop_frags (void)
7515 {
7516   frchainS *frchP;
7517
7518   /* When this routine is called, all of the subsections are still intact
7519      so we walk over subsections instead of sections.  */
7520   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
7521     {
7522       fragS *fragP;
7523       fragS *current_target = NULL;
7524       offsetT current_offset = 0;
7525       xtensa_opcode current_opcode = XTENSA_UNDEFINED;
7526
7527       /* Walk over all of the fragments in a subsection.  */
7528       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
7529         {
7530           /* Check on the current loop.  */
7531           if (fragP->fr_type == rs_machine_dependent
7532               && ((fragP->fr_subtype == RELAX_IMMED)
7533                   || ((fragP->fr_subtype == RELAX_SLOTS)
7534                       && (fragP->tc_frag_data.slot_subtypes[0]
7535                           == RELAX_IMMED))))
7536             {
7537               TInsn t_insn;
7538
7539               /* Read it.  If the instruction is a loop, get the target.  */
7540               tinsn_from_chars (&t_insn, fragP->fr_opcode, 0);
7541               if (xtensa_opcode_is_loop (xtensa_default_isa,
7542                                          t_insn.opcode) == 1)
7543                 {
7544                   /* Get the current fragment target.  */
7545                   if (fragP->tc_frag_data.slot_symbols[0])
7546                     {
7547                       symbolS *sym = fragP->tc_frag_data.slot_symbols[0];
7548                       current_target = symbol_get_frag (sym);
7549                       current_offset = fragP->fr_offset;
7550                       current_opcode = t_insn.opcode;
7551                     }
7552                 }
7553             }
7554
7555           if (fragP->fr_type == rs_machine_dependent
7556               && fragP->fr_subtype == RELAX_ADD_NOP_IF_SHORT_LOOP)
7557             {
7558               if (count_insns_to_loop_end (fragP->fr_next, TRUE, 3) < 3
7559                   && (branch_before_loop_end (fragP->fr_next)
7560                       || (workaround_all_short_loops
7561                           && current_opcode != XTENSA_UNDEFINED
7562                           && current_opcode != xtensa_loop_opcode)))
7563                 {
7564                   if (fragP->tc_frag_data.is_no_transform)
7565                     as_bad (_("loop containing less than three instructions may trigger hardware errata"));
7566                   else
7567                     relax_frag_add_nop (fragP);
7568                 }
7569               frag_wane (fragP);
7570             }
7571         }
7572     }
7573 }
7574
7575
7576 static int unrelaxed_frag_min_insn_count (fragS *);
7577
7578 static int
7579 count_insns_to_loop_end (fragS *base_fragP,
7580                          bfd_boolean count_relax_add,
7581                          int max_count)
7582 {
7583   fragS *fragP = NULL;
7584   int insn_count = 0;
7585
7586   fragP = base_fragP;
7587
7588   for (; fragP && !fragP->tc_frag_data.is_loop_target; fragP = fragP->fr_next)
7589     {
7590       insn_count += unrelaxed_frag_min_insn_count (fragP);
7591       if (insn_count >= max_count)
7592         return max_count;
7593
7594       if (count_relax_add)
7595         {
7596           if (fragP->fr_type == rs_machine_dependent
7597               && fragP->fr_subtype == RELAX_ADD_NOP_IF_SHORT_LOOP)
7598             {
7599               /* In order to add the appropriate number of
7600                  NOPs, we count an instruction for downstream
7601                  occurrences.  */
7602               insn_count++;
7603               if (insn_count >= max_count)
7604                 return max_count;
7605             }
7606         }
7607     }
7608   return insn_count;
7609 }
7610
7611
7612 static int
7613 unrelaxed_frag_min_insn_count (fragS *fragP)
7614 {
7615   xtensa_isa isa = xtensa_default_isa;
7616   static xtensa_insnbuf insnbuf = NULL;
7617   int insn_count = 0;
7618   int offset = 0;
7619
7620   if (!fragP->tc_frag_data.is_insn)
7621     return insn_count;
7622
7623   if (!insnbuf)
7624     insnbuf = xtensa_insnbuf_alloc (isa);
7625
7626   /* Decode the fixed instructions.  */
7627   while (offset < fragP->fr_fix)
7628     {
7629       xtensa_format fmt;
7630
7631       xtensa_insnbuf_from_chars
7632         (isa, insnbuf, (unsigned char *) fragP->fr_literal + offset, 0);
7633       fmt = xtensa_format_decode (isa, insnbuf);
7634
7635       if (fmt == XTENSA_UNDEFINED)
7636         {
7637           as_fatal (_("undecodable instruction in instruction frag"));
7638           return insn_count;
7639         }
7640       offset += xtensa_format_length (isa, fmt);
7641       insn_count++;
7642     }
7643
7644   return insn_count;
7645 }
7646
7647
7648 static bfd_boolean unrelaxed_frag_has_b_j (fragS *);
7649
7650 static bfd_boolean
7651 branch_before_loop_end (fragS *base_fragP)
7652 {
7653   fragS *fragP;
7654
7655   for (fragP = base_fragP;
7656        fragP && !fragP->tc_frag_data.is_loop_target;
7657        fragP = fragP->fr_next)
7658     {
7659       if (unrelaxed_frag_has_b_j (fragP))
7660         return TRUE;
7661     }
7662   return FALSE;
7663 }
7664
7665
7666 static bfd_boolean
7667 unrelaxed_frag_has_b_j (fragS *fragP)
7668 {
7669   static xtensa_insnbuf insnbuf = NULL;
7670   xtensa_isa isa = xtensa_default_isa;
7671   int offset = 0;
7672
7673   if (!fragP->tc_frag_data.is_insn)
7674     return FALSE;
7675
7676   if (!insnbuf)
7677     insnbuf = xtensa_insnbuf_alloc (isa);
7678
7679   /* Decode the fixed instructions.  */
7680   while (offset < fragP->fr_fix)
7681     {
7682       xtensa_format fmt;
7683       int slot;
7684
7685       xtensa_insnbuf_from_chars
7686         (isa, insnbuf, (unsigned char *) fragP->fr_literal + offset, 0);
7687       fmt = xtensa_format_decode (isa, insnbuf);
7688       if (fmt == XTENSA_UNDEFINED)
7689         return FALSE;
7690
7691       for (slot = 0; slot < xtensa_format_num_slots (isa, fmt); slot++)
7692         {
7693           xtensa_opcode opcode =
7694             get_opcode_from_buf (fragP->fr_literal + offset, slot);
7695           if (xtensa_opcode_is_branch (isa, opcode) == 1
7696               || xtensa_opcode_is_jump (isa, opcode) == 1)
7697             return TRUE;
7698         }
7699       offset += xtensa_format_length (isa, fmt);
7700     }
7701   return FALSE;
7702 }
7703
7704
7705 /* Checks to be made after initial assembly but before relaxation.  */
7706
7707 static bfd_boolean is_empty_loop (const TInsn *, fragS *);
7708 static bfd_boolean is_local_forward_loop (const TInsn *, fragS *);
7709
7710 static void
7711 xtensa_sanity_check (void)
7712 {
7713   char *file_name;
7714   unsigned line;
7715
7716   frchainS *frchP;
7717
7718   as_where (&file_name, &line);
7719   for (frchP = frchain_root; frchP; frchP = frchP->frch_next)
7720     {
7721       fragS *fragP;
7722
7723       /* Walk over all of the fragments in a subsection.  */
7724       for (fragP = frchP->frch_root; fragP; fragP = fragP->fr_next)
7725         {
7726           /* Currently we only check for empty loops here.  */
7727           if (fragP->fr_type == rs_machine_dependent
7728               && fragP->fr_subtype == RELAX_IMMED)
7729             {
7730               static xtensa_insnbuf insnbuf = NULL;
7731               TInsn t_insn;
7732
7733               if (fragP->fr_opcode != NULL)
7734                 {
7735                   if (!insnbuf)
7736                     insnbuf = xtensa_insnbuf_alloc (xtensa_default_isa);
7737                   tinsn_from_chars (&t_insn, fragP->fr_opcode, 0);
7738                   tinsn_immed_from_frag (&t_insn, fragP, 0);
7739
7740                   if (xtensa_opcode_is_loop (xtensa_default_isa,
7741                                              t_insn.opcode) == 1)
7742                     {
7743                       if (is_empty_loop (&t_insn, fragP))
7744                         {
7745                           new_logical_line (fragP->fr_file, fragP->fr_line);
7746                           as_bad (_("invalid empty loop"));
7747                         }
7748                       if (!is_local_forward_loop (&t_insn, fragP))
7749                         {
7750                           new_logical_line (fragP->fr_file, fragP->fr_line);
7751                           as_bad (_("loop target does not follow "
7752                                     "loop instruction in section"));
7753                         }
7754                     }
7755                 }
7756             }
7757         }
7758     }
7759   new_logical_line (file_name, line);
7760 }
7761
7762
7763 #define LOOP_IMMED_OPN 1
7764
7765 /* Return TRUE if the loop target is the next non-zero fragment.  */
7766
7767 static bfd_boolean
7768 is_empty_loop (const TInsn *insn, fragS *fragP)
7769 {
7770   const expressionS *expr;
7771   symbolS *symbolP;
7772   fragS *next_fragP;
7773
7774   if (insn->insn_type != ITYPE_INSN)
7775     return FALSE;
7776
7777   if (xtensa_opcode_is_loop (xtensa_default_isa, insn->opcode) != 1)
7778     return FALSE;
7779
7780   if (insn->ntok <= LOOP_IMMED_OPN)
7781     return FALSE;
7782
7783   expr = &insn->tok[LOOP_IMMED_OPN];
7784
7785   if (expr->X_op != O_symbol)
7786     return FALSE;
7787
7788   symbolP = expr->X_add_symbol;
7789   if (!symbolP)
7790     return FALSE;
7791
7792   if (symbol_get_frag (symbolP) == NULL)
7793     return FALSE;
7794
7795   if (S_GET_VALUE (symbolP) != 0)
7796     return FALSE;
7797
7798   /* Walk through the zero-size fragments from this one.  If we find
7799      the target fragment, then this is a zero-size loop.  */
7800
7801   for (next_fragP = fragP->fr_next;
7802        next_fragP != NULL;
7803        next_fragP = next_fragP->fr_next)
7804     {
7805       if (next_fragP == symbol_get_frag (symbolP))
7806         return TRUE;
7807       if (next_fragP->fr_fix != 0)
7808         return FALSE;
7809     }
7810   return FALSE;
7811 }
7812
7813
7814 static bfd_boolean
7815 is_local_forward_loop (const TInsn *insn, fragS *fragP)
7816 {
7817   const expressionS *expr;
7818   symbolS *symbolP;
7819   fragS *next_fragP;
7820
7821   if (insn->insn_type != ITYPE_INSN)
7822     return FALSE;
7823
7824   if (xtensa_opcode_is_loop (xtensa_default_isa, insn->opcode) == 0)
7825     return FALSE;
7826
7827   if (insn->ntok <= LOOP_IMMED_OPN)
7828     return FALSE;
7829
7830   expr = &insn->tok[LOOP_IMMED_OPN];
7831
7832   if (expr->X_op != O_symbol)
7833     return FALSE;
7834
7835   symbolP = expr->X_add_symbol;
7836   if (!symbolP)
7837     return FALSE;
7838
7839   if (symbol_get_frag (symbolP) == NULL)
7840     return FALSE;
7841
7842   /* Walk through fragments until we find the target.
7843      If we do not find the target, then this is an invalid loop.  */
7844
7845   for (next_fragP = fragP->fr_next;
7846        next_fragP != NULL;
7847        next_fragP = next_fragP->fr_next)
7848     {
7849       if (next_fragP == symbol_get_frag (symbolP))
7850         return TRUE;
7851     }
7852
7853   return FALSE;
7854 }
7855
7856 \f
7857 /* Alignment Functions.  */
7858
7859 static int
7860 get_text_align_power (unsigned target_size)
7861 {
7862   int i = 0;
7863   unsigned power = 1;
7864
7865   assert (target_size <= INT_MAX);
7866   while (target_size > power)
7867     {
7868       power <<= 1;
7869       i += 1;
7870     }
7871   return i;
7872 }
7873
7874
7875 static int
7876 get_text_align_max_fill_size (int align_pow,
7877                               bfd_boolean use_nops,
7878                               bfd_boolean use_no_density)
7879 {
7880   if (!use_nops)
7881     return (1 << align_pow);
7882   if (use_no_density)
7883     return 3 * (1 << align_pow);
7884
7885   return 1 + (1 << align_pow);
7886 }
7887
7888
7889 /* Calculate the minimum bytes of fill needed at "address" to align a
7890    target instruction of size "target_size" so that it does not cross a
7891    power-of-two boundary specified by "align_pow".  If "use_nops" is FALSE,
7892    the fill can be an arbitrary number of bytes.  Otherwise, the space must
7893    be filled by NOP instructions.  */
7894
7895 static int
7896 get_text_align_fill_size (addressT address,
7897                           int align_pow,
7898                           int target_size,
7899                           bfd_boolean use_nops,
7900                           bfd_boolean use_no_density)
7901 {
7902   addressT alignment, fill, fill_limit, fill_step;
7903   bfd_boolean skip_one = FALSE;
7904
7905   alignment = (1 << align_pow);
7906   assert (target_size > 0 && alignment >= (addressT) target_size);
7907
7908   if (!use_nops)
7909     {
7910       fill_limit = alignment;
7911       fill_step = 1;
7912     }
7913   else if (!use_no_density)
7914     {
7915       /* Combine 2- and 3-byte NOPs to fill anything larger than one.  */
7916       fill_limit = alignment * 2;
7917       fill_step = 1;
7918       skip_one = TRUE;
7919     }
7920   else
7921     {
7922       /* Fill with 3-byte NOPs -- can only fill multiples of 3.  */
7923       fill_limit = alignment * 3;
7924       fill_step = 3;
7925     }
7926
7927   /* Try all fill sizes until finding one that works.  */
7928   for (fill = 0; fill < fill_limit; fill += fill_step)
7929     {
7930       if (skip_one && fill == 1)
7931         continue;
7932       if ((address + fill) >> align_pow
7933           == (address + fill + target_size - 1) >> align_pow)
7934         return fill;
7935     }
7936   assert (0);
7937   return 0;
7938 }
7939
7940
7941 static int
7942 branch_align_power (segT sec)
7943 {
7944   /* If the Xtensa processor has a fetch width of 8 bytes, and the section
7945      is aligned to at least an 8-byte boundary, then a branch target need
7946      only fit within an 8-byte aligned block of memory to avoid a stall.
7947      Otherwise, try to fit branch targets within 4-byte aligned blocks
7948      (which may be insufficient, e.g., if the section has no alignment, but
7949      it's good enough).  */
7950   if (xtensa_fetch_width == 8)
7951     {
7952       if (get_recorded_alignment (sec) >= 3)
7953         return 3;
7954     }
7955   else
7956     assert (xtensa_fetch_width == 4);
7957
7958   return 2;
7959 }
7960
7961
7962 /* This will assert if it is not possible.  */
7963
7964 static int
7965 get_text_align_nop_count (offsetT fill_size, bfd_boolean use_no_density)
7966 {
7967   int count = 0;
7968
7969   if (use_no_density)
7970     {
7971       assert (fill_size % 3 == 0);
7972       return (fill_size / 3);
7973     }
7974
7975   assert (fill_size != 1);      /* Bad argument.  */
7976
7977   while (fill_size > 1)
7978     {
7979       int insn_size = 3;
7980       if (fill_size == 2 || fill_size == 4)
7981         insn_size = 2;
7982       fill_size -= insn_size;
7983       count++;
7984     }
7985   assert (fill_size != 1);      /* Bad algorithm.  */
7986   return count;
7987 }
7988
7989
7990 static int
7991 get_text_align_nth_nop_size (offsetT fill_size,
7992                              int n,
7993                              bfd_boolean use_no_density)
7994 {
7995   int count = 0;
7996
7997   if (use_no_density)
7998     return 3;
7999
8000   assert (fill_size != 1);      /* Bad argument.  */
8001
8002   while (fill_size > 1)
8003     {
8004       int insn_size = 3;
8005       if (fill_size == 2 || fill_size == 4)
8006         insn_size = 2;
8007       fill_size -= insn_size;
8008       count++;
8009       if (n + 1 == count)
8010         return insn_size;
8011     }
8012   assert (0);
8013   return 0;
8014 }
8015
8016
8017 /* For the given fragment, find the appropriate address
8018    for it to begin at if we are using NOPs to align it.  */
8019
8020 static addressT
8021 get_noop_aligned_address (fragS *fragP, addressT address)
8022 {
8023   /* The rule is: get next fragment's FIRST instruction.  Find
8024      the smallest number of bytes that need to be added to
8025      ensure that the next fragment's FIRST instruction will fit
8026      in a single word.
8027
8028      E.G.,   2 bytes : 0, 1, 2 mod 4
8029              3 bytes: 0, 1 mod 4
8030
8031      If the FIRST instruction MIGHT be relaxed,
8032      assume that it will become a 3-byte instruction.
8033
8034      Note again here that LOOP instructions are not bundleable,
8035      and this relaxation only applies to LOOP opcodes.  */
8036
8037   int fill_size = 0;
8038   int first_insn_size;
8039   int loop_insn_size;
8040   addressT pre_opcode_bytes;
8041   int align_power;
8042   fragS *first_insn;
8043   xtensa_opcode opcode;
8044   bfd_boolean is_loop;
8045
8046   assert (fragP->fr_type == rs_machine_dependent);
8047   assert (fragP->fr_subtype == RELAX_ALIGN_NEXT_OPCODE);
8048
8049   /* Find the loop frag.  */
8050   first_insn = next_non_empty_frag (fragP);
8051   /* Now find the first insn frag.  */
8052   first_insn = next_non_empty_frag (first_insn);
8053
8054   is_loop = next_frag_opcode_is_loop (fragP, &opcode);
8055   assert (is_loop);
8056   loop_insn_size = xg_get_single_size (opcode);
8057
8058   pre_opcode_bytes = next_frag_pre_opcode_bytes (fragP);
8059   pre_opcode_bytes += loop_insn_size;
8060
8061   /* For loops, the alignment depends on the size of the
8062      instruction following the loop, not the LOOP instruction.  */
8063
8064   if (first_insn == NULL)
8065     return address;
8066
8067   assert (first_insn->tc_frag_data.is_first_loop_insn);
8068
8069   first_insn_size = frag_format_size (first_insn);
8070
8071   if (first_insn_size == 2 || first_insn_size == XTENSA_UNDEFINED)
8072     first_insn_size = 3;        /* ISA specifies this */
8073
8074   /* If it was 8, then we'll need a larger alignment for the section.  */
8075   align_power = get_text_align_power (first_insn_size);
8076   record_alignment (now_seg, align_power);
8077
8078   fill_size = get_text_align_fill_size
8079     (address + pre_opcode_bytes, align_power, first_insn_size, TRUE,
8080      fragP->tc_frag_data.is_no_density);
8081
8082   return address + fill_size;
8083 }
8084
8085
8086 /* 3 mechanisms for relaxing an alignment:
8087
8088    Align to a power of 2.
8089    Align so the next fragment's instruction does not cross a word boundary.
8090    Align the current instruction so that if the next instruction
8091        were 3 bytes, it would not cross a word boundary.
8092
8093    We can align with:
8094
8095    zeros    - This is easy; always insert zeros.
8096    nops     - 3-byte and 2-byte instructions
8097               2 - 2-byte nop
8098               3 - 3-byte nop
8099               4 - 2 2-byte nops
8100               >=5 : 3-byte instruction + fn (n-3)
8101    widening - widen previous instructions.  */
8102
8103 static offsetT
8104 get_aligned_diff (fragS *fragP, addressT address, offsetT *max_diff)
8105 {
8106   addressT target_address, loop_insn_offset;
8107   int target_size;
8108   xtensa_opcode loop_opcode;
8109   bfd_boolean is_loop;
8110   int align_power;
8111   offsetT opt_diff;
8112   offsetT branch_align;
8113
8114   assert (fragP->fr_type == rs_machine_dependent);
8115   switch (fragP->fr_subtype)
8116     {
8117     case RELAX_DESIRE_ALIGN:
8118       target_size = next_frag_format_size (fragP);
8119       if (target_size == XTENSA_UNDEFINED)
8120         target_size = 3;
8121       align_power = branch_align_power (now_seg);
8122       branch_align = 1 << align_power;
8123       /* Don't count on the section alignment being as large as the target.  */
8124       if (target_size > branch_align)
8125         target_size = branch_align;
8126       opt_diff = get_text_align_fill_size (address, align_power,
8127                                            target_size, FALSE, FALSE);
8128
8129       *max_diff = (opt_diff + branch_align
8130                    - (target_size + ((address + opt_diff) % branch_align)));
8131       assert (*max_diff >= opt_diff);
8132       return opt_diff;
8133
8134     case RELAX_ALIGN_NEXT_OPCODE:
8135       target_size = next_frag_format_size (fragP);
8136       loop_insn_offset = 0;
8137       is_loop = next_frag_opcode_is_loop (fragP, &loop_opcode);
8138       assert (is_loop);
8139
8140       /* If the loop has been expanded then the LOOP instruction
8141          could be at an offset from this fragment.  */
8142       if (next_non_empty_frag(fragP)->tc_frag_data.slot_subtypes[0]
8143           != RELAX_IMMED)
8144         loop_insn_offset = get_expanded_loop_offset (loop_opcode);
8145
8146       if (target_size == 2)
8147         target_size = 3; /* ISA specifies this */
8148
8149       /* In an ideal world, which is what we are shooting for here,
8150          we wouldn't need to use any NOPs immediately prior to the
8151          LOOP instruction.  If this approach fails, relax_frag_loop_align
8152          will call get_noop_aligned_address.  */
8153       target_address =
8154         address + loop_insn_offset + xg_get_single_size (loop_opcode);
8155       align_power = get_text_align_power (target_size),
8156       opt_diff = get_text_align_fill_size (target_address, align_power,
8157                                            target_size, FALSE, FALSE);
8158
8159       *max_diff = xtensa_fetch_width
8160         - ((target_address + opt_diff) % xtensa_fetch_width)
8161         - target_size + opt_diff;
8162       assert (*max_diff >= opt_diff);
8163       return opt_diff;
8164
8165     default:
8166       break;
8167     }
8168   assert (0);
8169   return 0;
8170 }
8171
8172 \f
8173 /* md_relax_frag Hook and Helper Functions.  */
8174
8175 static long relax_frag_loop_align (fragS *, long);
8176 static long relax_frag_for_align (fragS *, long);
8177 static long relax_frag_immed
8178   (segT, fragS *, long, int, xtensa_format, int, int *, bfd_boolean);
8179
8180
8181 /* Return the number of bytes added to this fragment, given that the
8182    input has been stretched already by "stretch".  */
8183
8184 long
8185 xtensa_relax_frag (fragS *fragP, long stretch, int *stretched_p)
8186 {
8187   xtensa_isa isa = xtensa_default_isa;
8188   int unreported = fragP->tc_frag_data.unreported_expansion;
8189   long new_stretch = 0;
8190   char *file_name;
8191   unsigned line;
8192   int lit_size;
8193   static xtensa_insnbuf vbuf = NULL;
8194   int slot, num_slots;
8195   xtensa_format fmt;
8196
8197   as_where (&file_name, &line);
8198   new_logical_line (fragP->fr_file, fragP->fr_line);
8199
8200   fragP->tc_frag_data.unreported_expansion = 0;
8201
8202   switch (fragP->fr_subtype)
8203     {
8204     case RELAX_ALIGN_NEXT_OPCODE:
8205       /* Always convert.  */
8206       if (fragP->tc_frag_data.relax_seen)
8207         new_stretch = relax_frag_loop_align (fragP, stretch);
8208       break;
8209
8210     case RELAX_LOOP_END:
8211       /* Do nothing.  */
8212       break;
8213
8214     case RELAX_LOOP_END_ADD_NOP:
8215       /* Add a NOP and switch to .fill 0.  */
8216       new_stretch = relax_frag_add_nop (fragP);
8217       frag_wane (fragP);
8218       break;
8219
8220     case RELAX_DESIRE_ALIGN:
8221       /* Do nothing. The narrowing before this frag will either align
8222          it or not.  */
8223       break;
8224
8225     case RELAX_LITERAL:
8226     case RELAX_LITERAL_FINAL:
8227       return 0;
8228
8229     case RELAX_LITERAL_NR:
8230       lit_size = 4;
8231       fragP->fr_subtype = RELAX_LITERAL_FINAL;
8232       assert (unreported == lit_size);
8233       memset (&fragP->fr_literal[fragP->fr_fix], 0, 4);
8234       fragP->fr_var -= lit_size;
8235       fragP->fr_fix += lit_size;
8236       new_stretch = 4;
8237       break;
8238
8239     case RELAX_SLOTS:
8240       if (vbuf == NULL)
8241         vbuf = xtensa_insnbuf_alloc (isa);
8242
8243       xtensa_insnbuf_from_chars
8244         (isa, vbuf, (unsigned char *) fragP->fr_opcode, 0);
8245       fmt = xtensa_format_decode (isa, vbuf);
8246       num_slots = xtensa_format_num_slots (isa, fmt);
8247
8248       for (slot = 0; slot < num_slots; slot++)
8249         {
8250           switch (fragP->tc_frag_data.slot_subtypes[slot])
8251             {
8252             case RELAX_NARROW:
8253               if (fragP->tc_frag_data.relax_seen)
8254                 new_stretch += relax_frag_for_align (fragP, stretch);
8255               break;
8256
8257             case RELAX_IMMED:
8258             case RELAX_IMMED_STEP1:
8259             case RELAX_IMMED_STEP2:
8260               /* Place the immediate.  */
8261               new_stretch += relax_frag_immed
8262                 (now_seg, fragP, stretch,
8263                  fragP->tc_frag_data.slot_subtypes[slot] - RELAX_IMMED,
8264                  fmt, slot, stretched_p, FALSE);
8265               break;
8266
8267             default:
8268               /* This is OK; see the note in xg_assemble_vliw_tokens.  */
8269               break;
8270             }
8271         }
8272       break;
8273
8274     case RELAX_LITERAL_POOL_BEGIN:
8275     case RELAX_LITERAL_POOL_END:
8276     case RELAX_MAYBE_UNREACHABLE:
8277     case RELAX_MAYBE_DESIRE_ALIGN:
8278       /* No relaxation required.  */
8279       break;
8280
8281     case RELAX_FILL_NOP:
8282     case RELAX_UNREACHABLE:
8283       if (fragP->tc_frag_data.relax_seen)
8284         new_stretch += relax_frag_for_align (fragP, stretch);
8285       break;
8286
8287     default:
8288       as_bad (_("bad relaxation state"));
8289     }
8290
8291   /* Tell gas we need another relaxation pass.  */
8292   if (! fragP->tc_frag_data.relax_seen)
8293     {
8294       fragP->tc_frag_data.relax_seen = TRUE;
8295       *stretched_p = 1;
8296     }
8297
8298   new_logical_line (file_name, line);
8299   return new_stretch;
8300 }
8301
8302
8303 static long
8304 relax_frag_loop_align (fragS *fragP, long stretch)
8305 {
8306   addressT old_address, old_next_address, old_size;
8307   addressT new_address, new_next_address, new_size;
8308   addressT growth;
8309
8310   /* All the frags with relax_frag_for_alignment prior to this one in the
8311      section have been done, hopefully eliminating the need for a NOP here.
8312      But, this will put it in if necessary.  */
8313
8314   /* Calculate the old address of this fragment and the next fragment.  */
8315   old_address = fragP->fr_address - stretch;
8316   old_next_address = (fragP->fr_address - stretch + fragP->fr_fix +
8317                       fragP->tc_frag_data.text_expansion[0]);
8318   old_size = old_next_address - old_address;
8319
8320   /* Calculate the new address of this fragment and the next fragment.  */
8321   new_address = fragP->fr_address;
8322   new_next_address =
8323     get_noop_aligned_address (fragP, fragP->fr_address + fragP->fr_fix);
8324   new_size = new_next_address - new_address;
8325
8326   growth = new_size - old_size;
8327
8328   /* Fix up the text_expansion field and return the new growth.  */
8329   fragP->tc_frag_data.text_expansion[0] += growth;
8330   return growth;
8331 }
8332
8333
8334 /* Add a NOP instruction.  */
8335
8336 static long
8337 relax_frag_add_nop (fragS *fragP)
8338 {
8339   char *nop_buf = fragP->fr_literal + fragP->fr_fix;
8340   int length = fragP->tc_frag_data.is_no_density ? 3 : 2;
8341   assemble_nop (length, nop_buf);
8342   fragP->tc_frag_data.is_insn = TRUE;
8343
8344   if (fragP->fr_var < length)
8345     {
8346       as_fatal (_("fr_var (%ld) < length (%d)"), (long) fragP->fr_var, length);
8347       return 0;
8348     }
8349
8350   fragP->fr_fix += length;
8351   fragP->fr_var -= length;
8352   return length;
8353 }
8354
8355
8356 static long future_alignment_required (fragS *, long);
8357
8358 static long
8359 relax_frag_for_align (fragS *fragP, long stretch)
8360 {
8361   /* Overview of the relaxation procedure for alignment:
8362      We can widen with NOPs or by widening instructions or by filling
8363      bytes after jump instructions.  Find the opportune places and widen
8364      them if necessary.  */
8365
8366   long stretch_me;
8367   long diff;
8368
8369   assert (fragP->fr_subtype == RELAX_FILL_NOP
8370           || fragP->fr_subtype == RELAX_UNREACHABLE
8371           || (fragP->fr_subtype == RELAX_SLOTS
8372               && fragP->tc_frag_data.slot_subtypes[0] == RELAX_NARROW));
8373
8374   stretch_me = future_alignment_required (fragP, stretch);
8375   diff = stretch_me - fragP->tc_frag_data.text_expansion[0];
8376   if (diff == 0)
8377     return 0;
8378
8379   if (diff < 0)
8380     {
8381       /* We expanded on a previous pass.  Can we shrink now?  */
8382       long shrink = fragP->tc_frag_data.text_expansion[0] - stretch_me;
8383       if (shrink <= stretch && stretch > 0)
8384         {
8385           fragP->tc_frag_data.text_expansion[0] = stretch_me;
8386           return -shrink;
8387         }
8388       return 0;
8389     }
8390
8391   /* Below here, diff > 0.  */
8392   fragP->tc_frag_data.text_expansion[0] = stretch_me;
8393
8394   return diff;
8395 }
8396
8397
8398 /* Return the address of the next frag that should be aligned.
8399
8400    By "address" we mean the address it _would_ be at if there
8401    is no action taken to align it between here and the target frag.
8402    In other words, if no narrows and no fill nops are used between
8403    here and the frag to align, _even_if_ some of the frags we use
8404    to align targets have already expanded on a previous relaxation
8405    pass.
8406
8407    Also, count each frag that may be used to help align the target.
8408
8409    Return 0 if there are no frags left in the chain that need to be
8410    aligned.  */
8411
8412 static addressT
8413 find_address_of_next_align_frag (fragS **fragPP,
8414                                  int *wide_nops,
8415                                  int *narrow_nops,
8416                                  int *widens,
8417                                  bfd_boolean *paddable)
8418 {
8419   fragS *fragP = *fragPP;
8420   addressT address = fragP->fr_address;
8421
8422   /* Do not reset the counts to 0.  */
8423
8424   while (fragP)
8425     {
8426       /* Limit this to a small search.  */
8427       if (*widens > 8)
8428         {
8429           *fragPP = fragP;
8430           return 0;
8431         }
8432       address += fragP->fr_fix;
8433
8434       if (fragP->fr_type == rs_fill)
8435         address += fragP->fr_offset * fragP->fr_var;
8436       else if (fragP->fr_type == rs_machine_dependent)
8437         {
8438           switch (fragP->fr_subtype)
8439             {
8440             case RELAX_UNREACHABLE:
8441               *paddable = TRUE;
8442               break;
8443
8444             case RELAX_FILL_NOP:
8445               (*wide_nops)++;
8446               if (!fragP->tc_frag_data.is_no_density)
8447                 (*narrow_nops)++;
8448               break;
8449
8450             case RELAX_SLOTS:
8451               if (fragP->tc_frag_data.slot_subtypes[0] == RELAX_NARROW)
8452                 {
8453                   (*widens)++;
8454                   break;
8455                 }
8456               address += total_frag_text_expansion (fragP);;
8457               break;
8458
8459             case RELAX_IMMED:
8460               address += fragP->tc_frag_data.text_expansion[0];
8461               break;
8462
8463             case RELAX_ALIGN_NEXT_OPCODE:
8464             case RELAX_DESIRE_ALIGN:
8465               *fragPP = fragP;
8466               return address;
8467
8468             case RELAX_MAYBE_UNREACHABLE:
8469             case RELAX_MAYBE_DESIRE_ALIGN:
8470               /* Do nothing.  */
8471               break;
8472
8473             default:
8474               /* Just punt if we don't know the type.  */
8475               *fragPP = fragP;
8476               return 0;
8477             }
8478         }
8479       else
8480         {
8481           /* Just punt if we don't know the type.  */
8482           *fragPP = fragP;
8483           return 0;
8484         }
8485       fragP = fragP->fr_next;
8486     }
8487
8488   *fragPP = fragP;
8489   return 0;
8490 }
8491
8492
8493 static long bytes_to_stretch (fragS *, int, int, int, int);
8494
8495 static long
8496 future_alignment_required (fragS *fragP, long stretch ATTRIBUTE_UNUSED)
8497 {
8498   fragS *this_frag = fragP;
8499   long address;
8500   int num_widens = 0;
8501   int wide_nops = 0;
8502   int narrow_nops = 0;
8503   bfd_boolean paddable = FALSE;
8504   offsetT local_opt_diff;
8505   offsetT opt_diff;
8506   offsetT max_diff;
8507   int stretch_amount = 0;
8508   int local_stretch_amount;
8509   int global_stretch_amount;
8510
8511   address = find_address_of_next_align_frag
8512     (&fragP, &wide_nops, &narrow_nops, &num_widens, &paddable);
8513
8514   if (address)
8515     {
8516       local_opt_diff = get_aligned_diff (fragP, address, &max_diff);
8517       opt_diff = local_opt_diff;
8518       assert (opt_diff >= 0);
8519       assert (max_diff >= opt_diff);
8520       if (max_diff == 0)
8521         return 0;
8522
8523       if (fragP)
8524         fragP = fragP->fr_next;
8525
8526       while (fragP && opt_diff < max_diff && address)
8527         {
8528           /* We only use these to determine if we can exit early
8529              because there will be plenty of ways to align future
8530              align frags.  */
8531           int glob_widens = 0;
8532           int dnn = 0;
8533           int dw = 0;
8534           bfd_boolean glob_pad = 0;
8535           address = find_address_of_next_align_frag
8536             (&fragP, &glob_widens, &dnn, &dw, &glob_pad);
8537           /* If there is a padable portion, then skip.  */
8538           if (glob_pad || glob_widens >= (1 << branch_align_power (now_seg)))
8539             break;
8540
8541           if (address)
8542             {
8543               offsetT next_m_diff;
8544               offsetT next_o_diff;
8545
8546               /* Downrange frags haven't had stretch added to them yet.  */
8547               address += stretch;
8548
8549               /* The address also includes any text expansion from this
8550                  frag in a previous pass, but we don't want that.  */
8551               address -= this_frag->tc_frag_data.text_expansion[0];
8552
8553               /* Assume we are going to move at least opt_diff.  In
8554                  reality, we might not be able to, but assuming that
8555                  we will helps catch cases where moving opt_diff pushes
8556                  the next target from aligned to unaligned.  */
8557               address += opt_diff;
8558
8559               next_o_diff = get_aligned_diff (fragP, address, &next_m_diff);
8560
8561               /* Now cleanup for the adjustments to address.  */
8562               next_o_diff += opt_diff;
8563               next_m_diff += opt_diff;
8564               if (next_o_diff <= max_diff && next_o_diff > opt_diff)
8565                 opt_diff = next_o_diff;
8566               if (next_m_diff < max_diff)
8567                 max_diff = next_m_diff;
8568               fragP = fragP->fr_next;
8569             }
8570         }
8571
8572       /* If there are enough wideners in between, do it.  */
8573       if (paddable)
8574         {
8575           if (this_frag->fr_subtype == RELAX_UNREACHABLE)
8576             {
8577               assert (opt_diff <= UNREACHABLE_MAX_WIDTH);
8578               return opt_diff;
8579             }
8580           return 0;
8581         }
8582       local_stretch_amount
8583         = bytes_to_stretch (this_frag, wide_nops, narrow_nops,
8584                             num_widens, local_opt_diff);
8585       global_stretch_amount
8586         = bytes_to_stretch (this_frag, wide_nops, narrow_nops,
8587                             num_widens, opt_diff);
8588       /* If the condition below is true, then the frag couldn't
8589          stretch the correct amount for the global case, so we just
8590          optimize locally.  We'll rely on the subsequent frags to get
8591          the correct alignment in the global case.  */
8592       if (global_stretch_amount < local_stretch_amount)
8593         stretch_amount = local_stretch_amount;
8594       else
8595         stretch_amount = global_stretch_amount;
8596
8597       if (this_frag->fr_subtype == RELAX_SLOTS
8598           && this_frag->tc_frag_data.slot_subtypes[0] == RELAX_NARROW)
8599         assert (stretch_amount <= 1);
8600       else if (this_frag->fr_subtype == RELAX_FILL_NOP)
8601         {
8602           if (this_frag->tc_frag_data.is_no_density)
8603             assert (stretch_amount == 3 || stretch_amount == 0);
8604           else
8605             assert (stretch_amount <= 3);
8606         }
8607     }
8608   return stretch_amount;
8609 }
8610
8611
8612 /* The idea: widen everything you can to get a target or loop aligned,
8613    then start using NOPs.
8614
8615    When we must have a NOP, here is a table of how we decide
8616    (so you don't have to fight through the control flow below):
8617
8618    wide_nops   = the number of wide NOPs available for aligning
8619    narrow_nops = the number of narrow NOPs available for aligning
8620                  (a subset of wide_nops)
8621    widens      = the number of narrow instructions that should be widened
8622
8623    Desired   wide   narrow
8624    Diff      nop    nop      widens
8625    1           0      0         1
8626    2           0      1         0
8627    3a          1      0         0
8628     b          0      1         1 (case 3a makes this case unnecessary)
8629    4a          1      0         1
8630     b          0      2         0
8631     c          0      1         2 (case 4a makes this case unnecessary)
8632    5a          1      0         2
8633     b          1      1         0
8634     c          0      2         1 (case 5b makes this case unnecessary)
8635    6a          2      0         0
8636     b          1      0         3
8637     c          0      1         4 (case 6b makes this case unneccesary)
8638     d          1      1         1 (case 6a makes this case unnecessary)
8639     e          0      2         2 (case 6a makes this case unnecessary)
8640     f          0      3         0 (case 6a makes this case unnecessary)
8641    7a          1      0         4
8642     b          2      0         1
8643     c          1      1         2 (case 7b makes this case unnecessary)
8644     d          0      1         5 (case 7a makes this case unnecessary)
8645     e          0      2         3 (case 7b makes this case unnecessary)
8646     f          0      3         1 (case 7b makes this case unnecessary)
8647     g          1      2         1 (case 7b makes this case unnecessary)
8648 */
8649
8650 static long
8651 bytes_to_stretch (fragS *this_frag,
8652                   int wide_nops,
8653                   int narrow_nops,
8654                   int num_widens,
8655                   int desired_diff)
8656 {
8657   int bytes_short = desired_diff - num_widens;
8658
8659   assert (desired_diff >= 0 && desired_diff < 8);
8660   if (desired_diff == 0)
8661     return 0;
8662
8663   assert (wide_nops > 0 || num_widens > 0);
8664
8665   /* Always prefer widening to NOP-filling.  */
8666   if (bytes_short < 0)
8667     {
8668       /* There are enough RELAX_NARROW frags after this one
8669          to align the target without widening this frag in any way.  */
8670       return 0;
8671     }
8672
8673   if (bytes_short == 0)
8674     {
8675       /* Widen every narrow between here and the align target
8676          and the align target will be properly aligned.  */
8677       if (this_frag->fr_subtype == RELAX_FILL_NOP)
8678         return 0;
8679       else
8680         return 1;
8681     }
8682
8683   /* From here we will need at least one NOP to get an alignment.
8684      However, we may not be able to align at all, in which case,
8685      don't widen.  */
8686   if (this_frag->fr_subtype == RELAX_FILL_NOP)
8687     {
8688       switch (desired_diff)
8689         {
8690         case 1:
8691           return 0;
8692         case 2:
8693           if (!this_frag->tc_frag_data.is_no_density && narrow_nops == 1)
8694             return 2; /* case 2 */
8695           return 0;
8696         case 3:
8697           if (wide_nops > 1)
8698             return 0;
8699           else
8700             return 3; /* case 3a */
8701         case 4:
8702           if (num_widens >= 1 && wide_nops == 1)
8703             return 3; /* case 4a */
8704           if (!this_frag->tc_frag_data.is_no_density && narrow_nops == 2)
8705             return 2; /* case 4b */
8706           return 0;
8707         case 5:
8708           if (num_widens >= 2 && wide_nops == 1)
8709             return 3; /* case 5a */
8710           /* We will need two nops.  Are there enough nops
8711              between here and the align target?  */
8712           if (wide_nops < 2 || narrow_nops == 0)
8713             return 0;
8714           /* Are there other nops closer that can serve instead?  */
8715           if (wide_nops > 2 && narrow_nops > 1)
8716             return 0;
8717           /* Take the density one first, because there might not be
8718              another density one available.  */
8719           if (!this_frag->tc_frag_data.is_no_density)
8720             return 2; /* case 5b narrow */
8721           else
8722             return 3; /* case 5b wide */
8723           return 0;
8724         case 6:
8725           if (wide_nops == 2)
8726             return 3; /* case 6a */
8727           else if (num_widens >= 3 && wide_nops == 1)
8728             return 3; /* case 6b */
8729           return 0;
8730         case 7:
8731           if (wide_nops == 1 && num_widens >= 4)
8732             return 3; /* case 7a */
8733           else if (wide_nops == 2 && num_widens >= 1)
8734             return 3; /* case 7b */
8735           return 0;
8736         default:
8737           assert (0);
8738         }
8739     }
8740   else
8741     {
8742       /* We will need a NOP no matter what, but should we widen
8743          this instruction to help?
8744
8745          This is a RELAX_FRAG_NARROW frag.  */
8746       switch (desired_diff)
8747         {
8748         case 1:
8749           assert (0);
8750           return 0;
8751         case 2:
8752         case 3:
8753           return 0;
8754         case 4:
8755           if (wide_nops >= 1 && num_widens == 1)
8756             return 1; /* case 4a */
8757           return 0;
8758         case 5:
8759           if (wide_nops >= 1 && num_widens == 2)
8760             return 1; /* case 5a */
8761           return 0;
8762         case 6:
8763           if (wide_nops >= 2)
8764             return 0; /* case 6a */
8765           else if (wide_nops >= 1 && num_widens == 3)
8766             return 1; /* case 6b */
8767           return 0;
8768         case 7:
8769           if (wide_nops >= 1 && num_widens == 4)
8770             return 1; /* case 7a */
8771           else if (wide_nops >= 2 && num_widens == 1)
8772             return 1; /* case 7b */
8773           return 0;
8774         default:
8775           assert (0);
8776           return 0;
8777         }
8778     }
8779   assert (0);
8780   return 0;
8781 }
8782
8783
8784 static long
8785 relax_frag_immed (segT segP,
8786                   fragS *fragP,
8787                   long stretch,
8788                   int min_steps,
8789                   xtensa_format fmt,
8790                   int slot,
8791                   int *stretched_p,
8792                   bfd_boolean estimate_only)
8793 {
8794   TInsn tinsn;
8795   vliw_insn orig_vinsn;
8796   int old_size;
8797   bfd_boolean negatable_branch = FALSE;
8798   bfd_boolean branch_jmp_to_next = FALSE;
8799   bfd_boolean wide_insn = FALSE;
8800   xtensa_isa isa = xtensa_default_isa;
8801   IStack istack;
8802   offsetT frag_offset;
8803   int num_steps;
8804   fragS *lit_fragP;
8805   int num_text_bytes, num_literal_bytes;
8806   int literal_diff, total_text_diff, this_text_diff, first;
8807
8808   assert (fragP->fr_opcode != NULL);
8809
8810   xg_init_vinsn (&orig_vinsn);
8811   vinsn_from_chars (&orig_vinsn, fragP->fr_opcode);
8812   if (xtensa_format_num_slots (isa, fmt) > 1)
8813     wide_insn = TRUE;
8814
8815   tinsn = orig_vinsn.slots[slot];
8816   tinsn_immed_from_frag (&tinsn, fragP, slot);
8817
8818   if (estimate_only && xtensa_opcode_is_loop (isa, tinsn.opcode))
8819     return 0;
8820
8821   if (workaround_b_j_loop_end && ! fragP->tc_frag_data.is_no_transform)
8822     branch_jmp_to_next = is_branch_jmp_to_next (&tinsn, fragP);
8823
8824   negatable_branch = (xtensa_opcode_is_branch (isa, tinsn.opcode) == 1);
8825
8826   old_size = xtensa_format_length (isa, fmt);
8827
8828   /* Special case: replace a branch to the next instruction with a NOP.
8829      This is required to work around a hardware bug in T1040.0 and also
8830      serves as an optimization.  */
8831
8832   if (branch_jmp_to_next
8833       && ((old_size == 2) || (old_size == 3))
8834       && !next_frag_is_loop_target (fragP))
8835     return 0;
8836
8837   /* Here is the fun stuff: Get the immediate field from this
8838      instruction.  If it fits, we are done.  If not, find the next
8839      instruction sequence that fits.  */
8840
8841   frag_offset = fragP->fr_opcode - fragP->fr_literal;
8842   istack_init (&istack);
8843   num_steps = xg_assembly_relax (&istack, &tinsn, segP, fragP, frag_offset,
8844                                  min_steps, stretch);
8845   if (num_steps < min_steps)
8846     {
8847       as_fatal (_("internal error: relaxation failed"));
8848       return 0;
8849     }
8850
8851   if (num_steps > RELAX_IMMED_MAXSTEPS)
8852     {
8853       as_fatal (_("internal error: relaxation requires too many steps"));
8854       return 0;
8855     }
8856
8857   fragP->tc_frag_data.slot_subtypes[slot] = (int) RELAX_IMMED + num_steps;
8858
8859   /* Figure out the number of bytes needed.  */
8860   lit_fragP = 0;
8861   num_literal_bytes = get_num_stack_literal_bytes (&istack);
8862   literal_diff =
8863     num_literal_bytes - fragP->tc_frag_data.literal_expansion[slot];
8864   first = 0;
8865   while (istack.insn[first].opcode == XTENSA_UNDEFINED)
8866     first++;
8867   num_text_bytes = get_num_stack_text_bytes (&istack);
8868   if (wide_insn)
8869     {
8870       num_text_bytes += old_size;
8871       if (opcode_fits_format_slot (istack.insn[first].opcode, fmt, slot))
8872         num_text_bytes -= xg_get_single_size (istack.insn[first].opcode);
8873     }
8874   total_text_diff = num_text_bytes - old_size;
8875   this_text_diff = total_text_diff - fragP->tc_frag_data.text_expansion[slot];
8876
8877   /* It MUST get larger.  If not, we could get an infinite loop.  */
8878   assert (num_text_bytes >= 0);
8879   assert (literal_diff >= 0);
8880   assert (total_text_diff >= 0);
8881
8882   fragP->tc_frag_data.text_expansion[slot] = total_text_diff;
8883   fragP->tc_frag_data.literal_expansion[slot] = num_literal_bytes;
8884   assert (fragP->tc_frag_data.text_expansion[slot] >= 0);
8885   assert (fragP->tc_frag_data.literal_expansion[slot] >= 0);
8886
8887   /* Find the associated expandable literal for this.  */
8888   if (literal_diff != 0)
8889     {
8890       lit_fragP = fragP->tc_frag_data.literal_frags[slot];
8891       if (lit_fragP)
8892         {
8893           assert (literal_diff == 4);
8894           lit_fragP->tc_frag_data.unreported_expansion += literal_diff;
8895
8896           /* We expect that the literal section state has NOT been
8897              modified yet.  */
8898           assert (lit_fragP->fr_type == rs_machine_dependent
8899                   && lit_fragP->fr_subtype == RELAX_LITERAL);
8900           lit_fragP->fr_subtype = RELAX_LITERAL_NR;
8901
8902           /* We need to mark this section for another iteration
8903              of relaxation.  */
8904           (*stretched_p)++;
8905         }
8906     }
8907
8908   if (negatable_branch && istack.ninsn > 1)
8909     update_next_frag_state (fragP);
8910
8911   return this_text_diff;
8912 }
8913
8914 \f
8915 /* md_convert_frag Hook and Helper Functions.  */
8916
8917 static void convert_frag_align_next_opcode (fragS *);
8918 static void convert_frag_narrow (segT, fragS *, xtensa_format, int);
8919 static void convert_frag_fill_nop (fragS *);
8920 static void convert_frag_immed (segT, fragS *, int, xtensa_format, int);
8921
8922 void
8923 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, segT sec, fragS *fragp)
8924 {
8925   static xtensa_insnbuf vbuf = NULL;
8926   xtensa_isa isa = xtensa_default_isa;
8927   int slot;
8928   int num_slots;
8929   xtensa_format fmt;
8930   char *file_name;
8931   unsigned line;
8932
8933   as_where (&file_name, &line);
8934   new_logical_line (fragp->fr_file, fragp->fr_line);
8935
8936   switch (fragp->fr_subtype)
8937     {
8938     case RELAX_ALIGN_NEXT_OPCODE:
8939       /* Always convert.  */
8940       convert_frag_align_next_opcode (fragp);
8941       break;
8942
8943     case RELAX_DESIRE_ALIGN:
8944       /* Do nothing.  If not aligned already, too bad.  */
8945       break;
8946
8947     case RELAX_LITERAL:
8948     case RELAX_LITERAL_FINAL:
8949       break;
8950
8951     case RELAX_SLOTS:
8952       if (vbuf == NULL)
8953         vbuf = xtensa_insnbuf_alloc (isa);
8954
8955       xtensa_insnbuf_from_chars
8956         (isa, vbuf, (unsigned char *) fragp->fr_opcode, 0);
8957       fmt = xtensa_format_decode (isa, vbuf);
8958       num_slots = xtensa_format_num_slots (isa, fmt);
8959
8960       for (slot = 0; slot < num_slots; slot++)
8961         {
8962           switch (fragp->tc_frag_data.slot_subtypes[slot])
8963             {
8964             case RELAX_NARROW:
8965               convert_frag_narrow (sec, fragp, fmt, slot);
8966               break;
8967
8968             case RELAX_IMMED:
8969             case RELAX_IMMED_STEP1:
8970             case RELAX_IMMED_STEP2:
8971               /* Place the immediate.  */
8972               convert_frag_immed
8973                 (sec, fragp,
8974                  fragp->tc_frag_data.slot_subtypes[slot] - RELAX_IMMED,
8975                  fmt, slot);
8976               break;
8977
8978             default:
8979               /* This is OK because some slots could have
8980                  relaxations and others have none.  */
8981               break;
8982             }
8983         }
8984       break;
8985
8986     case RELAX_UNREACHABLE:
8987       memset (&fragp->fr_literal[fragp->fr_fix], 0, fragp->fr_var);
8988       fragp->fr_fix += fragp->tc_frag_data.text_expansion[0];
8989       fragp->fr_var -= fragp->tc_frag_data.text_expansion[0];
8990       frag_wane (fragp);
8991       break;
8992
8993     case RELAX_MAYBE_UNREACHABLE:
8994     case RELAX_MAYBE_DESIRE_ALIGN:
8995       frag_wane (fragp);
8996       break;
8997
8998     case RELAX_FILL_NOP:
8999       convert_frag_fill_nop (fragp);
9000       break;
9001
9002     case RELAX_LITERAL_NR:
9003       if (use_literal_section)
9004         {
9005           /* This should have been handled during relaxation.  When
9006              relaxing a code segment, literals sometimes need to be
9007              added to the corresponding literal segment.  If that
9008              literal segment has already been relaxed, then we end up
9009              in this situation.  Marking the literal segments as data
9010              would make this happen less often (since GAS always relaxes
9011              code before data), but we could still get into trouble if
9012              there are instructions in a segment that is not marked as
9013              containing code.  Until we can implement a better solution,
9014              cheat and adjust the addresses of all the following frags.
9015              This could break subsequent alignments, but the linker's
9016              literal coalescing will do that anyway.  */
9017
9018           fragS *f;
9019           fragp->fr_subtype = RELAX_LITERAL_FINAL;
9020           assert (fragp->tc_frag_data.unreported_expansion == 4);
9021           memset (&fragp->fr_literal[fragp->fr_fix], 0, 4);
9022           fragp->fr_var -= 4;
9023           fragp->fr_fix += 4;
9024           for (f = fragp->fr_next; f; f = f->fr_next)
9025             f->fr_address += 4;
9026         }
9027       else
9028         as_bad (_("invalid relaxation fragment result"));
9029       break;
9030     }
9031
9032   fragp->fr_var = 0;
9033   new_logical_line (file_name, line);
9034 }
9035
9036
9037 static void
9038 convert_frag_align_next_opcode (fragS *fragp)
9039 {
9040   char *nop_buf;                /* Location for Writing.  */
9041   bfd_boolean use_no_density = fragp->tc_frag_data.is_no_density;
9042   addressT aligned_address;
9043   offsetT fill_size;
9044   int nop, nop_count;
9045
9046   aligned_address = get_noop_aligned_address (fragp, fragp->fr_address +
9047                                               fragp->fr_fix);
9048   fill_size = aligned_address - (fragp->fr_address + fragp->fr_fix);
9049   nop_count = get_text_align_nop_count (fill_size, use_no_density);
9050   nop_buf = fragp->fr_literal + fragp->fr_fix;
9051
9052   for (nop = 0; nop < nop_count; nop++)
9053     {
9054       int nop_size;
9055       nop_size = get_text_align_nth_nop_size (fill_size, nop, use_no_density);
9056
9057       assemble_nop (nop_size, nop_buf);
9058       nop_buf += nop_size;
9059     }
9060
9061   fragp->fr_fix += fill_size;
9062   fragp->fr_var -= fill_size;
9063 }
9064
9065
9066 static void
9067 convert_frag_narrow (segT segP, fragS *fragP, xtensa_format fmt, int slot)
9068 {
9069   TInsn tinsn, single_target;
9070   xtensa_format single_fmt;
9071   int size, old_size, diff;
9072   offsetT frag_offset;
9073
9074   assert (slot == 0);
9075   tinsn_from_chars (&tinsn, fragP->fr_opcode, 0);
9076
9077   if (xtensa_opcode_is_branch (xtensa_default_isa, tinsn.opcode) == 1)
9078     {
9079       assert (fragP->tc_frag_data.text_expansion[0] == 1
9080               || fragP->tc_frag_data.text_expansion[0] == 0);
9081       convert_frag_immed (segP, fragP, fragP->tc_frag_data.text_expansion[0],
9082                           fmt, slot);
9083       return;
9084     }
9085
9086   if (fragP->tc_frag_data.text_expansion[0] == 0)
9087     {
9088       /* No conversion.  */
9089       fragP->fr_var = 0;
9090       return;
9091     }
9092
9093   assert (fragP->fr_opcode != NULL);
9094
9095   /* Frags in this relaxation state should only contain
9096      single instruction bundles.  */
9097   tinsn_immed_from_frag (&tinsn, fragP, 0);
9098
9099   /* Just convert it to a wide form....  */
9100   size = 0;
9101   old_size = xg_get_single_size (tinsn.opcode);
9102
9103   tinsn_init (&single_target);
9104   frag_offset = fragP->fr_opcode - fragP->fr_literal;
9105
9106   if (! xg_is_single_relaxable_insn (&tinsn, &single_target, FALSE))
9107     {
9108       as_bad (_("unable to widen instruction"));
9109       return;
9110     }
9111
9112   size = xg_get_single_size (single_target.opcode);
9113   single_fmt = xg_get_single_format (single_target.opcode);
9114
9115   xg_emit_insn_to_buf (&single_target, single_fmt, fragP->fr_opcode,
9116                        fragP, frag_offset, TRUE);
9117
9118   diff = size - old_size;
9119   assert (diff >= 0);
9120   assert (diff <= fragP->fr_var);
9121   fragP->fr_var -= diff;
9122   fragP->fr_fix += diff;
9123
9124   /* clean it up */
9125   fragP->fr_var = 0;
9126 }
9127
9128
9129 static void
9130 convert_frag_fill_nop (fragS *fragP)
9131 {
9132   char *loc = &fragP->fr_literal[fragP->fr_fix];
9133   int size = fragP->tc_frag_data.text_expansion[0];
9134   assert ((unsigned) size == (fragP->fr_next->fr_address
9135                               - fragP->fr_address - fragP->fr_fix));
9136   if (size == 0)
9137     {
9138       /* No conversion.  */
9139       fragP->fr_var = 0;
9140       return;
9141     }
9142   assemble_nop (size, loc);
9143   fragP->tc_frag_data.is_insn = TRUE;
9144   fragP->fr_var -= size;
9145   fragP->fr_fix += size;
9146   frag_wane (fragP);
9147 }
9148
9149
9150 static fixS *fix_new_exp_in_seg
9151   (segT, subsegT, fragS *, int, int, expressionS *, int,
9152    bfd_reloc_code_real_type);
9153 static void convert_frag_immed_finish_loop (segT, fragS *, TInsn *);
9154
9155 static void
9156 convert_frag_immed (segT segP,
9157                     fragS *fragP,
9158                     int min_steps,
9159                     xtensa_format fmt,
9160                     int slot)
9161 {
9162   char *immed_instr = fragP->fr_opcode;
9163   TInsn orig_tinsn;
9164   bfd_boolean expanded = FALSE;
9165   bfd_boolean branch_jmp_to_next = FALSE;
9166   char *fr_opcode = fragP->fr_opcode;
9167   vliw_insn orig_vinsn;
9168   xtensa_isa isa = xtensa_default_isa;
9169   bfd_boolean wide_insn = FALSE;
9170   int bytes;
9171   bfd_boolean is_loop;
9172
9173   assert (fr_opcode != NULL);
9174
9175   xg_init_vinsn (&orig_vinsn);
9176
9177   vinsn_from_chars (&orig_vinsn, fr_opcode);
9178   if (xtensa_format_num_slots (isa, fmt) > 1)
9179     wide_insn = TRUE;
9180
9181   orig_tinsn = orig_vinsn.slots[slot];
9182   tinsn_immed_from_frag (&orig_tinsn, fragP, slot);
9183
9184   is_loop = xtensa_opcode_is_loop (xtensa_default_isa, orig_tinsn.opcode) == 1;
9185
9186   if (workaround_b_j_loop_end && ! fragP->tc_frag_data.is_no_transform)
9187     branch_jmp_to_next = is_branch_jmp_to_next (&orig_tinsn, fragP);
9188
9189   if (branch_jmp_to_next && !next_frag_is_loop_target (fragP))
9190     {
9191       /* Conversion just inserts a NOP and marks the fix as completed.  */
9192       bytes = xtensa_format_length (isa, fmt);
9193       if (bytes >= 4)
9194         {
9195           orig_vinsn.slots[slot].opcode =
9196             xtensa_format_slot_nop_opcode (isa, orig_vinsn.format, slot);
9197           orig_vinsn.slots[slot].ntok = 0;
9198         }
9199       else
9200         {
9201           bytes += fragP->tc_frag_data.text_expansion[0];
9202           assert (bytes == 2 || bytes == 3);
9203           build_nop (&orig_vinsn.slots[0], bytes);
9204           fragP->fr_fix += fragP->tc_frag_data.text_expansion[0];
9205         }
9206       vinsn_to_insnbuf (&orig_vinsn, fr_opcode, frag_now, FALSE);
9207       xtensa_insnbuf_to_chars
9208         (isa, orig_vinsn.insnbuf, (unsigned char *) fr_opcode, 0);
9209       fragP->fr_var = 0;
9210     }
9211   else
9212     {
9213       /* Here is the fun stuff:  Get the immediate field from this
9214          instruction.  If it fits, we're done.  If not, find the next
9215          instruction sequence that fits.  */
9216
9217       IStack istack;
9218       int i;
9219       symbolS *lit_sym = NULL;
9220       int total_size = 0;
9221       int target_offset = 0;
9222       int old_size;
9223       int diff;
9224       symbolS *gen_label = NULL;
9225       offsetT frag_offset;
9226       bfd_boolean first = TRUE;
9227       bfd_boolean last_is_jump;
9228
9229       /* It does not fit.  Find something that does and
9230          convert immediately.  */
9231       frag_offset = fr_opcode - fragP->fr_literal;
9232       istack_init (&istack);
9233       xg_assembly_relax (&istack, &orig_tinsn,
9234                          segP, fragP, frag_offset, min_steps, 0);
9235
9236       old_size = xtensa_format_length (isa, fmt);
9237
9238       /* Assemble this right inline.  */
9239
9240       /* First, create the mapping from a label name to the REAL label.  */
9241       target_offset = 0;
9242       for (i = 0; i < istack.ninsn; i++)
9243         {
9244           TInsn *tinsn = &istack.insn[i];
9245           fragS *lit_frag;
9246
9247           switch (tinsn->insn_type)
9248             {
9249             case ITYPE_LITERAL:
9250               if (lit_sym != NULL)
9251                 as_bad (_("multiple literals in expansion"));
9252               /* First find the appropriate space in the literal pool.  */
9253               lit_frag = fragP->tc_frag_data.literal_frags[slot];
9254               if (lit_frag == NULL)
9255                 as_bad (_("no registered fragment for literal"));
9256               if (tinsn->ntok != 1)
9257                 as_bad (_("number of literal tokens != 1"));
9258
9259               /* Set the literal symbol and add a fixup.  */
9260               lit_sym = lit_frag->fr_symbol;
9261               break;
9262
9263             case ITYPE_LABEL:
9264               if (align_targets && !is_loop)
9265                 {
9266                   fragS *unreach = fragP->fr_next;
9267                   while (!(unreach->fr_type == rs_machine_dependent
9268                            && (unreach->fr_subtype == RELAX_MAYBE_UNREACHABLE
9269                                || unreach->fr_subtype == RELAX_UNREACHABLE)))
9270                     {
9271                       unreach = unreach->fr_next;
9272                     }
9273
9274                   assert (unreach->fr_type == rs_machine_dependent
9275                           && (unreach->fr_subtype == RELAX_MAYBE_UNREACHABLE
9276                               || unreach->fr_subtype == RELAX_UNREACHABLE));
9277
9278                   target_offset += unreach->tc_frag_data.text_expansion[0];
9279                 }
9280               assert (gen_label == NULL);
9281               gen_label = symbol_new (FAKE_LABEL_NAME, now_seg,
9282                                       fr_opcode - fragP->fr_literal
9283                                       + target_offset, fragP);
9284               break;
9285
9286             case ITYPE_INSN:
9287               if (first && wide_insn)
9288                 {
9289                   target_offset += xtensa_format_length (isa, fmt);
9290                   first = FALSE;
9291                   if (!opcode_fits_format_slot (tinsn->opcode, fmt, slot))
9292                     target_offset += xg_get_single_size (tinsn->opcode);
9293                 }
9294               else
9295                 target_offset += xg_get_single_size (tinsn->opcode);
9296               break;
9297             }
9298         }
9299
9300       total_size = 0;
9301       first = TRUE;
9302       last_is_jump = FALSE;
9303       for (i = 0; i < istack.ninsn; i++)
9304         {
9305           TInsn *tinsn = &istack.insn[i];
9306           fragS *lit_frag;
9307           int size;
9308           segT target_seg;
9309           bfd_reloc_code_real_type reloc_type;
9310
9311           switch (tinsn->insn_type)
9312             {
9313             case ITYPE_LITERAL:
9314               lit_frag = fragP->tc_frag_data.literal_frags[slot];
9315               /* Already checked.  */
9316               assert (lit_frag != NULL);
9317               assert (lit_sym != NULL);
9318               assert (tinsn->ntok == 1);
9319               /* Add a fixup.  */
9320               target_seg = S_GET_SEGMENT (lit_sym);
9321               assert (target_seg);
9322               if (tinsn->tok[0].X_op == O_pltrel)
9323                 reloc_type = BFD_RELOC_XTENSA_PLT;
9324               else
9325                 reloc_type = BFD_RELOC_32;
9326               fix_new_exp_in_seg (target_seg, 0, lit_frag, 0, 4,
9327                                   &tinsn->tok[0], FALSE, reloc_type);
9328               break;
9329
9330             case ITYPE_LABEL:
9331               break;
9332
9333             case ITYPE_INSN:
9334               xg_resolve_labels (tinsn, gen_label);
9335               xg_resolve_literals (tinsn, lit_sym);
9336               if (wide_insn && first)
9337                 {
9338                   first = FALSE;
9339                   if (opcode_fits_format_slot (tinsn->opcode, fmt, slot))
9340                     {
9341                       tinsn->record_fix = TRUE;
9342                       orig_vinsn.slots[slot] = *tinsn;
9343                     }
9344                   else
9345                     {
9346                       orig_vinsn.slots[slot].opcode =
9347                         xtensa_format_slot_nop_opcode (isa, fmt, slot);
9348                       orig_vinsn.slots[slot].ntok = 0;
9349                       orig_vinsn.slots[slot].record_fix = FALSE;
9350                     }
9351                   vinsn_to_insnbuf (&orig_vinsn, immed_instr, fragP, TRUE);
9352                   xtensa_insnbuf_to_chars (isa, orig_vinsn.insnbuf,
9353                                            (unsigned char *) immed_instr, 0);
9354                   fragP->tc_frag_data.is_insn = TRUE;
9355                   size = xtensa_format_length (isa, fmt);
9356                   if (!opcode_fits_format_slot (tinsn->opcode, fmt, slot))
9357                     {
9358                       xtensa_format single_fmt =
9359                         xg_get_single_format (tinsn->opcode);
9360
9361                       xg_emit_insn_to_buf
9362                         (tinsn, single_fmt, immed_instr + size, fragP,
9363                          immed_instr - fragP->fr_literal + size, TRUE);
9364                       size += xg_get_single_size (tinsn->opcode);
9365                     }
9366                 }
9367               else
9368                 {
9369                   xtensa_format single_format;
9370                   size = xg_get_single_size (tinsn->opcode);
9371                   single_format = xg_get_single_format (tinsn->opcode);
9372                   xg_emit_insn_to_buf (tinsn, single_format, immed_instr,
9373                                        fragP,
9374                                        immed_instr - fragP->fr_literal, TRUE);
9375                 }
9376               immed_instr += size;
9377               total_size += size;
9378               break;
9379             }
9380         }
9381
9382       diff = total_size - old_size;
9383       assert (diff >= 0);
9384       if (diff != 0)
9385         expanded = TRUE;
9386       assert (diff <= fragP->fr_var);
9387       fragP->fr_var -= diff;
9388       fragP->fr_fix += diff;
9389     }
9390
9391   /* Clean it up.  */
9392   xg_free_vinsn (&orig_vinsn);
9393
9394   /* Check for undefined immediates in LOOP instructions.  */
9395   if (is_loop)
9396     {
9397       symbolS *sym;
9398       sym = orig_tinsn.tok[1].X_add_symbol;
9399       if (sym != NULL && !S_IS_DEFINED (sym))
9400         {
9401           as_bad (_("unresolved loop target symbol: %s"), S_GET_NAME (sym));
9402           return;
9403         }
9404       sym = orig_tinsn.tok[1].X_op_symbol;
9405       if (sym != NULL && !S_IS_DEFINED (sym))
9406         {
9407           as_bad (_("unresolved loop target symbol: %s"), S_GET_NAME (sym));
9408           return;
9409         }
9410     }
9411
9412   if (expanded && xtensa_opcode_is_loop (isa, orig_tinsn.opcode) == 1)
9413     convert_frag_immed_finish_loop (segP, fragP, &orig_tinsn);
9414
9415   if (expanded && is_direct_call_opcode (orig_tinsn.opcode))
9416     {
9417       /* Add an expansion note on the expanded instruction.  */
9418       fix_new_exp_in_seg (now_seg, 0, fragP, fr_opcode - fragP->fr_literal, 4,
9419                           &orig_tinsn.tok[0], TRUE,
9420                           BFD_RELOC_XTENSA_ASM_EXPAND);
9421     }
9422 }
9423
9424
9425 /* Add a new fix expression into the desired segment.  We have to
9426    switch to that segment to do this.  */
9427
9428 static fixS *
9429 fix_new_exp_in_seg (segT new_seg,
9430                     subsegT new_subseg,
9431                     fragS *frag,
9432                     int where,
9433                     int size,
9434                     expressionS *exp,
9435                     int pcrel,
9436                     bfd_reloc_code_real_type r_type)
9437 {
9438   fixS *new_fix;
9439   segT seg = now_seg;
9440   subsegT subseg = now_subseg;
9441
9442   assert (new_seg != 0);
9443   subseg_set (new_seg, new_subseg);
9444
9445   new_fix = fix_new_exp (frag, where, size, exp, pcrel, r_type);
9446   subseg_set (seg, subseg);
9447   return new_fix;
9448 }
9449
9450
9451 /* Relax a loop instruction so that it can span loop >256 bytes.
9452
9453                   loop    as, .L1
9454           .L0:
9455                   rsr     as, LEND
9456                   wsr     as, LBEG
9457                   addi    as, as, lo8 (label-.L1)
9458                   addmi   as, as, mid8 (label-.L1)
9459                   wsr     as, LEND
9460                   isync
9461                   rsr     as, LCOUNT
9462                   addi    as, as, 1
9463           .L1:
9464                   <<body>>
9465           label:
9466 */
9467
9468 static void
9469 convert_frag_immed_finish_loop (segT segP, fragS *fragP, TInsn *tinsn)
9470 {
9471   TInsn loop_insn;
9472   TInsn addi_insn;
9473   TInsn addmi_insn;
9474   unsigned long target;
9475   static xtensa_insnbuf insnbuf = NULL;
9476   unsigned int loop_length, loop_length_hi, loop_length_lo;
9477   xtensa_isa isa = xtensa_default_isa;
9478   addressT loop_offset;
9479   addressT addi_offset = 9;
9480   addressT addmi_offset = 12;
9481   fragS *next_fragP;
9482   int target_count;
9483
9484   if (!insnbuf)
9485     insnbuf = xtensa_insnbuf_alloc (isa);
9486
9487   /* Get the loop offset.  */
9488   loop_offset = get_expanded_loop_offset (tinsn->opcode);
9489
9490   /* Validate that there really is a LOOP at the loop_offset.  Because
9491      loops are not bundleable, we can assume that the instruction will be
9492      in slot 0.  */
9493   tinsn_from_chars (&loop_insn, fragP->fr_opcode + loop_offset, 0);
9494   tinsn_immed_from_frag (&loop_insn, fragP, 0);
9495
9496   assert (xtensa_opcode_is_loop (isa, loop_insn.opcode) == 1);
9497   addi_offset += loop_offset;
9498   addmi_offset += loop_offset;
9499
9500   assert (tinsn->ntok == 2);
9501   if (tinsn->tok[1].X_op == O_constant)
9502     target = tinsn->tok[1].X_add_number;
9503   else if (tinsn->tok[1].X_op == O_symbol)
9504     {
9505       /* Find the fragment.  */
9506       symbolS *sym = tinsn->tok[1].X_add_symbol;
9507       assert (S_GET_SEGMENT (sym) == segP
9508               || S_GET_SEGMENT (sym) == absolute_section);
9509       target = (S_GET_VALUE (sym) + tinsn->tok[1].X_add_number);
9510     }
9511   else
9512     {
9513       as_bad (_("invalid expression evaluation type %d"), tinsn->tok[1].X_op);
9514       target = 0;
9515     }
9516
9517   know (symbolP);
9518   know (symbolP->sy_frag);
9519   know (!(S_GET_SEGMENT (symbolP) == absolute_section)
9520         || symbol_get_frag (symbolP) == &zero_address_frag);
9521
9522   loop_length = target - (fragP->fr_address + fragP->fr_fix);
9523   loop_length_hi = loop_length & ~0x0ff;
9524   loop_length_lo = loop_length & 0x0ff;
9525   if (loop_length_lo >= 128)
9526     {
9527       loop_length_lo -= 256;
9528       loop_length_hi += 256;
9529     }
9530
9531   /* Because addmi sign-extends the immediate, 'loop_length_hi' can be at most
9532      32512.  If the loop is larger than that, then we just fail.  */
9533   if (loop_length_hi > 32512)
9534     as_bad_where (fragP->fr_file, fragP->fr_line,
9535                   _("loop too long for LOOP instruction"));
9536
9537   tinsn_from_chars (&addi_insn, fragP->fr_opcode + addi_offset, 0);
9538   assert (addi_insn.opcode == xtensa_addi_opcode);
9539
9540   tinsn_from_chars (&addmi_insn, fragP->fr_opcode + addmi_offset, 0);
9541   assert (addmi_insn.opcode == xtensa_addmi_opcode);
9542
9543   set_expr_const (&addi_insn.tok[2], loop_length_lo);
9544   tinsn_to_insnbuf (&addi_insn, insnbuf);
9545
9546   fragP->tc_frag_data.is_insn = TRUE;
9547   xtensa_insnbuf_to_chars
9548     (isa, insnbuf, (unsigned char *) fragP->fr_opcode + addi_offset, 0);
9549
9550   set_expr_const (&addmi_insn.tok[2], loop_length_hi);
9551   tinsn_to_insnbuf (&addmi_insn, insnbuf);
9552   xtensa_insnbuf_to_chars
9553     (isa, insnbuf, (unsigned char *) fragP->fr_opcode + addmi_offset, 0);
9554
9555   /* Walk through all of the frags from here to the loop end
9556      and mark them as no_transform to keep them from being modified
9557      by the linker.  If we ever have a relocation for the
9558      addi/addmi of the difference of two symbols we can remove this.  */
9559
9560   target_count = 0;
9561   for (next_fragP = fragP; next_fragP != NULL;
9562        next_fragP = next_fragP->fr_next)
9563     {
9564       next_fragP->tc_frag_data.is_no_transform = TRUE;
9565       if (next_fragP->tc_frag_data.is_loop_target)
9566         target_count++;
9567       if (target_count == 2)
9568         break;
9569     }
9570 }
9571
9572 \f
9573 /* A map that keeps information on a per-subsegment basis.  This is
9574    maintained during initial assembly, but is invalid once the
9575    subsegments are smashed together.  I.E., it cannot be used during
9576    the relaxation.  */
9577
9578 typedef struct subseg_map_struct
9579 {
9580   /* the key */
9581   segT seg;
9582   subsegT subseg;
9583
9584   /* the data */
9585   unsigned flags;
9586   float total_freq;     /* fall-through + branch target frequency */
9587   float target_freq;    /* branch target frequency alone */
9588
9589   struct subseg_map_struct *next;
9590 } subseg_map;
9591
9592
9593 static subseg_map *sseg_map = NULL;
9594
9595 static subseg_map *
9596 get_subseg_info (segT seg, subsegT subseg)
9597 {
9598   subseg_map *subseg_e;
9599
9600   for (subseg_e = sseg_map; subseg_e; subseg_e = subseg_e->next)
9601     {
9602       if (seg == subseg_e->seg && subseg == subseg_e->subseg)
9603         break;
9604     }
9605   return subseg_e;
9606 }
9607
9608
9609 static subseg_map *
9610 add_subseg_info (segT seg, subsegT subseg)
9611 {
9612   subseg_map *subseg_e = (subseg_map *) xmalloc (sizeof (subseg_map));
9613   memset (subseg_e, 0, sizeof (subseg_map));
9614   subseg_e->seg = seg;
9615   subseg_e->subseg = subseg;
9616   subseg_e->flags = 0;
9617   /* Start off considering every branch target very important.  */
9618   subseg_e->target_freq = 1.0;
9619   subseg_e->total_freq = 1.0;
9620   subseg_e->next = sseg_map;
9621   sseg_map = subseg_e;
9622   return subseg_e;
9623 }
9624
9625
9626 static unsigned
9627 get_last_insn_flags (segT seg, subsegT subseg)
9628 {
9629   subseg_map *subseg_e = get_subseg_info (seg, subseg);
9630   if (subseg_e)
9631     return subseg_e->flags;
9632   return 0;
9633 }
9634
9635
9636 static void
9637 set_last_insn_flags (segT seg,
9638                      subsegT subseg,
9639                      unsigned fl,
9640                      bfd_boolean val)
9641 {
9642   subseg_map *subseg_e = get_subseg_info (seg, subseg);
9643   if (! subseg_e)
9644     subseg_e = add_subseg_info (seg, subseg);
9645   if (val)
9646     subseg_e->flags |= fl;
9647   else
9648     subseg_e->flags &= ~fl;
9649 }
9650
9651
9652 static float
9653 get_subseg_total_freq (segT seg, subsegT subseg)
9654 {
9655   subseg_map *subseg_e = get_subseg_info (seg, subseg);
9656   if (subseg_e)
9657     return subseg_e->total_freq;
9658   return 1.0;
9659 }
9660
9661
9662 static float
9663 get_subseg_target_freq (segT seg, subsegT subseg)
9664 {
9665   subseg_map *subseg_e = get_subseg_info (seg, subseg);
9666   if (subseg_e)
9667     return subseg_e->target_freq;
9668   return 1.0;
9669 }
9670
9671
9672 static void
9673 set_subseg_freq (segT seg, subsegT subseg, float total_f, float target_f)
9674 {
9675   subseg_map *subseg_e = get_subseg_info (seg, subseg);
9676   if (! subseg_e)
9677     subseg_e = add_subseg_info (seg, subseg);
9678   subseg_e->total_freq = total_f;
9679   subseg_e->target_freq = target_f;
9680 }
9681
9682 \f
9683 /* Segment Lists and emit_state Stuff.  */
9684
9685 /* Remove the segment from the global sections list.  */
9686
9687 static void
9688 xtensa_remove_section (segT sec)
9689 {
9690   /* Handle brain-dead bfd_section_list_remove macro, which
9691      expect the address of the prior section's "next" field, not
9692      just the address of the section to remove.  */
9693
9694   segT *ps_next_ptr = &stdoutput->sections;
9695   while (*ps_next_ptr != sec && *ps_next_ptr != NULL)
9696     ps_next_ptr = &(*ps_next_ptr)->next;
9697
9698   assert (*ps_next_ptr != NULL);
9699
9700   bfd_section_list_remove (stdoutput, ps_next_ptr);
9701 }
9702
9703
9704 static void
9705 xtensa_insert_section (segT after_sec, segT sec)
9706 {
9707   segT *after_sec_next;
9708   if (after_sec == NULL)
9709     after_sec_next = &stdoutput->sections;
9710   else
9711     after_sec_next = &after_sec->next;
9712
9713   bfd_section_list_insert (stdoutput, after_sec_next, sec);
9714 }
9715
9716
9717 static void
9718 xtensa_move_seg_list_to_beginning (seg_list *head)
9719 {
9720   head = head->next;
9721   while (head)
9722     {
9723       segT literal_section = head->seg;
9724
9725       /* Move the literal section to the front of the section list.  */
9726       assert (literal_section);
9727       xtensa_remove_section (literal_section);
9728       xtensa_insert_section (NULL, literal_section);
9729
9730       head = head->next;
9731     }
9732 }
9733
9734
9735 static void mark_literal_frags (seg_list *);
9736
9737 static void
9738 xtensa_move_literals (void)
9739 {
9740   seg_list *segment;
9741   frchainS *frchain_from, *frchain_to;
9742   fragS *search_frag, *next_frag, *last_frag, *literal_pool, *insert_after;
9743   fragS **frag_splice;
9744   emit_state state;
9745   segT dest_seg;
9746   fixS *fix, *next_fix, **fix_splice;
9747   sym_list *lit;
9748
9749   mark_literal_frags (literal_head->next);
9750   mark_literal_frags (init_literal_head->next);
9751   mark_literal_frags (fini_literal_head->next);
9752
9753   if (use_literal_section)
9754     return;
9755
9756   segment = literal_head->next;
9757   while (segment)
9758     {
9759       frchain_from = seg_info (segment->seg)->frchainP;
9760       search_frag = frchain_from->frch_root;
9761       literal_pool = NULL;
9762       frchain_to = NULL;
9763       frag_splice = &(frchain_from->frch_root);
9764
9765       while (!search_frag->tc_frag_data.literal_frag)
9766         {
9767           assert (search_frag->fr_fix == 0
9768                   || search_frag->fr_type == rs_align);
9769           search_frag = search_frag->fr_next;
9770         }
9771
9772       assert (search_frag->tc_frag_data.literal_frag->fr_subtype
9773               == RELAX_LITERAL_POOL_BEGIN);
9774       xtensa_switch_section_emit_state (&state, segment->seg, 0);
9775
9776       /* Make sure that all the frags in this series are closed, and
9777          that there is at least one left over of zero-size.  This
9778          prevents us from making a segment with an frchain without any
9779          frags in it.  */
9780       frag_variant (rs_fill, 0, 0, 0, NULL, 0, NULL);
9781       xtensa_set_frag_assembly_state (frag_now);
9782       last_frag = frag_now;
9783       frag_variant (rs_fill, 0, 0, 0, NULL, 0, NULL);
9784       xtensa_set_frag_assembly_state (frag_now);
9785
9786       while (search_frag != frag_now)
9787         {
9788           next_frag = search_frag->fr_next;
9789
9790           /* First, move the frag out of the literal section and
9791              to the appropriate place.  */
9792           if (search_frag->tc_frag_data.literal_frag)
9793             {
9794               literal_pool = search_frag->tc_frag_data.literal_frag;
9795               assert (literal_pool->fr_subtype == RELAX_LITERAL_POOL_BEGIN);
9796               frchain_to = literal_pool->tc_frag_data.lit_frchain;
9797               assert (frchain_to);
9798             }
9799           insert_after = literal_pool;
9800
9801           while (insert_after->fr_next->fr_subtype != RELAX_LITERAL_POOL_END)
9802             insert_after = insert_after->fr_next;
9803
9804           dest_seg = insert_after->fr_next->tc_frag_data.lit_seg;
9805
9806           *frag_splice = next_frag;
9807           search_frag->fr_next = insert_after->fr_next;
9808           insert_after->fr_next = search_frag;
9809           search_frag->tc_frag_data.lit_seg = dest_seg;
9810
9811           /* Now move any fixups associated with this frag to the
9812              right section.  */
9813           fix = frchain_from->fix_root;
9814           fix_splice = &(frchain_from->fix_root);
9815           while (fix)
9816             {
9817               next_fix = fix->fx_next;
9818               if (fix->fx_frag == search_frag)
9819                 {
9820                   *fix_splice = next_fix;
9821                   fix->fx_next = frchain_to->fix_root;
9822                   frchain_to->fix_root = fix;
9823                   if (frchain_to->fix_tail == NULL)
9824                     frchain_to->fix_tail = fix;
9825                 }
9826               else
9827                 fix_splice = &(fix->fx_next);
9828               fix = next_fix;
9829             }
9830           search_frag = next_frag;
9831         }
9832
9833       if (frchain_from->fix_root != NULL)
9834         {
9835           frchain_from = seg_info (segment->seg)->frchainP;
9836           as_warn (_("fixes not all moved from %s"), segment->seg->name);
9837
9838           assert (frchain_from->fix_root == NULL);
9839         }
9840       frchain_from->fix_tail = NULL;
9841       xtensa_restore_emit_state (&state);
9842       segment = segment->next;
9843     }
9844
9845   /* Now fix up the SEGMENT value for all the literal symbols.  */
9846   for (lit = literal_syms; lit; lit = lit->next)
9847     {
9848       symbolS *lit_sym = lit->sym;
9849       segT dest_seg = symbol_get_frag (lit_sym)->tc_frag_data.lit_seg;
9850       if (dest_seg)
9851         S_SET_SEGMENT (lit_sym, dest_seg);
9852     }
9853 }
9854
9855
9856 /* Walk over all the frags for segments in a list and mark them as
9857    containing literals.  As clunky as this is, we can't rely on frag_var
9858    and frag_variant to get called in all situations.  */
9859
9860 static void
9861 mark_literal_frags (seg_list *segment)
9862 {
9863   frchainS *frchain_from;
9864   fragS *search_frag;
9865
9866   while (segment)
9867     {
9868       frchain_from = seg_info (segment->seg)->frchainP;
9869       search_frag = frchain_from->frch_root;
9870       while (search_frag)
9871         {
9872           search_frag->tc_frag_data.is_literal = TRUE;
9873           search_frag = search_frag->fr_next;
9874         }
9875       segment = segment->next;
9876     }
9877 }
9878
9879
9880 static void
9881 xtensa_reorder_seg_list (seg_list *head, segT after)
9882 {
9883   /* Move all of the sections in the section list to come
9884      after "after" in the gnu segment list.  */
9885
9886   head = head->next;
9887   while (head)
9888     {
9889       segT literal_section = head->seg;
9890
9891       /* Move the literal section after "after".  */
9892       assert (literal_section);
9893       if (literal_section != after)
9894         {
9895           xtensa_remove_section (literal_section);
9896           xtensa_insert_section (after, literal_section);
9897         }
9898
9899       head = head->next;
9900     }
9901 }
9902
9903
9904 /* Push all the literal segments to the end of the gnu list.  */
9905
9906 static void
9907 xtensa_reorder_segments (void)
9908 {
9909   segT sec;
9910   segT last_sec = 0;
9911   int old_count = 0;
9912   int new_count = 0;
9913
9914   for (sec = stdoutput->sections; sec != NULL; sec = sec->next)
9915     {
9916       last_sec = sec;
9917       old_count++;
9918     }
9919
9920   /* Now that we have the last section, push all the literal
9921      sections to the end.  */
9922   xtensa_reorder_seg_list (literal_head, last_sec);
9923   xtensa_reorder_seg_list (init_literal_head, last_sec);
9924   xtensa_reorder_seg_list (fini_literal_head, last_sec);
9925
9926   /* Now perform the final error check.  */
9927   for (sec = stdoutput->sections; sec != NULL; sec = sec->next)
9928     new_count++;
9929   assert (new_count == old_count);
9930 }
9931
9932
9933 /* Change the emit state (seg, subseg, and frag related stuff) to the
9934    correct location.  Return a emit_state which can be passed to
9935    xtensa_restore_emit_state to return to current fragment.  */
9936
9937 static void
9938 xtensa_switch_to_literal_fragment (emit_state *result)
9939 {
9940   if (directive_state[directive_absolute_literals])
9941     {
9942       cache_literal_section (0, default_lit_sections.lit4_seg_name,
9943                              &default_lit_sections.lit4_seg, FALSE);
9944       xtensa_switch_section_emit_state (result,
9945                                         default_lit_sections.lit4_seg, 0);
9946     }
9947   else
9948     xtensa_switch_to_non_abs_literal_fragment (result);
9949
9950   /* Do a 4-byte align here.  */
9951   frag_align (2, 0, 0);
9952   record_alignment (now_seg, 2);
9953 }
9954
9955
9956 static void
9957 xtensa_switch_to_non_abs_literal_fragment (emit_state *result)
9958 {
9959   /* When we mark a literal pool location, we want to put a frag in
9960      the literal pool that points to it.  But to do that, we want to
9961      switch_to_literal_fragment.  But literal sections don't have
9962      literal pools, so their location is always null, so we would
9963      recurse forever.  This is kind of hacky, but it works.  */
9964
9965   static bfd_boolean recursive = FALSE;
9966   fragS *pool_location = get_literal_pool_location (now_seg);
9967   bfd_boolean is_init =
9968     (now_seg && !strcmp (segment_name (now_seg), INIT_SECTION_NAME));
9969
9970   bfd_boolean is_fini =
9971     (now_seg && !strcmp (segment_name (now_seg), FINI_SECTION_NAME));
9972
9973   if (pool_location == NULL
9974       && !use_literal_section
9975       && !recursive
9976       && !is_init && ! is_fini)
9977     {
9978       as_bad (_("literal pool location required for text-section-literals; specify with .literal_position"));
9979       recursive = TRUE;
9980       xtensa_mark_literal_pool_location ();
9981       recursive = FALSE;
9982     }
9983
9984   /* Special case: If we are in the ".fini" or ".init" section, then
9985      we will ALWAYS be generating to the ".fini.literal" and
9986      ".init.literal" sections.  */
9987
9988   if (is_init)
9989     {
9990       cache_literal_section (init_literal_head,
9991                              default_lit_sections.init_lit_seg_name,
9992                              &default_lit_sections.init_lit_seg, TRUE);
9993       xtensa_switch_section_emit_state (result,
9994                                         default_lit_sections.init_lit_seg, 0);
9995     }
9996   else if (is_fini)
9997     {
9998       cache_literal_section (fini_literal_head,
9999                              default_lit_sections.fini_lit_seg_name,
10000                              &default_lit_sections.fini_lit_seg, TRUE);
10001       xtensa_switch_section_emit_state (result,
10002                                         default_lit_sections.fini_lit_seg, 0);
10003     }
10004   else
10005     {
10006       cache_literal_section (literal_head,
10007                              default_lit_sections.lit_seg_name,
10008                              &default_lit_sections.lit_seg, TRUE);
10009       xtensa_switch_section_emit_state (result,
10010                                         default_lit_sections.lit_seg, 0);
10011     }
10012
10013   if (!use_literal_section
10014       && !is_init && !is_fini
10015       && get_literal_pool_location (now_seg) != pool_location)
10016     {
10017       /* Close whatever frag is there.  */
10018       frag_variant (rs_fill, 0, 0, 0, NULL, 0, NULL);
10019       xtensa_set_frag_assembly_state (frag_now);
10020       frag_now->tc_frag_data.literal_frag = pool_location;
10021       frag_variant (rs_fill, 0, 0, 0, NULL, 0, NULL);
10022       xtensa_set_frag_assembly_state (frag_now);
10023     }
10024 }
10025
10026
10027 /* Call this function before emitting data into the literal section.
10028    This is a helper function for xtensa_switch_to_literal_fragment.
10029    This is similar to a .section new_now_seg subseg. */
10030
10031 static void
10032 xtensa_switch_section_emit_state (emit_state *state,
10033                                   segT new_now_seg,
10034                                   subsegT new_now_subseg)
10035 {
10036   state->name = now_seg->name;
10037   state->now_seg = now_seg;
10038   state->now_subseg = now_subseg;
10039   state->generating_literals = generating_literals;
10040   generating_literals++;
10041   subseg_set (new_now_seg, new_now_subseg);
10042 }
10043
10044
10045 /* Use to restore the emitting into the normal place.  */
10046
10047 static void
10048 xtensa_restore_emit_state (emit_state *state)
10049 {
10050   generating_literals = state->generating_literals;
10051   subseg_set (state->now_seg, state->now_subseg);
10052 }
10053
10054
10055 /* Get a segment of a given name.  If the segment is already
10056    present, return it; otherwise, create a new one.  */
10057
10058 static void
10059 cache_literal_section (seg_list *head,
10060                        const char *name,
10061                        segT *pseg,
10062                        bfd_boolean is_code)
10063 {
10064   segT current_section = now_seg;
10065   int current_subsec = now_subseg;
10066   segT seg;
10067
10068   if (*pseg != 0)
10069     return;
10070
10071   /* Check if the named section exists.  */
10072   for (seg = stdoutput->sections; seg; seg = seg->next)
10073     {
10074       if (!strcmp (segment_name (seg), name))
10075         break;
10076     }
10077
10078   if (!seg)
10079     {
10080       /* Create a new literal section.  */
10081       seg = subseg_new (name, (subsegT) 0);
10082       if (head)
10083         {
10084           /* Add the newly created literal segment to the specified list.  */
10085           seg_list *n = (seg_list *) xmalloc (sizeof (seg_list));
10086           n->seg = seg;
10087           n->next = head->next;
10088           head->next = n;
10089         }
10090       bfd_set_section_flags (stdoutput, seg, SEC_HAS_CONTENTS |
10091                              SEC_READONLY | SEC_ALLOC | SEC_LOAD
10092                              | (is_code ? SEC_CODE : SEC_DATA));
10093       bfd_set_section_alignment (stdoutput, seg, 2);
10094     }
10095
10096   *pseg = seg;
10097   subseg_set (current_section, current_subsec);
10098 }
10099
10100 \f
10101 /* Property Tables Stuff.  */
10102
10103 #define XTENSA_INSN_SEC_NAME ".xt.insn"
10104 #define XTENSA_LIT_SEC_NAME ".xt.lit"
10105 #define XTENSA_PROP_SEC_NAME ".xt.prop"
10106
10107 typedef bfd_boolean (*frag_predicate) (const fragS *);
10108 typedef void (*frag_flags_fn) (const fragS *, frag_flags *);
10109
10110 static bfd_boolean get_frag_is_literal (const fragS *);
10111 static void xtensa_create_property_segments
10112   (frag_predicate, frag_predicate, const char *, xt_section_type);
10113 static void xtensa_create_xproperty_segments
10114   (frag_flags_fn, const char *, xt_section_type);
10115 static segment_info_type *retrieve_segment_info (segT);
10116 static segT retrieve_xtensa_section (char *);
10117 static bfd_boolean section_has_property (segT, frag_predicate);
10118 static bfd_boolean section_has_xproperty (segT, frag_flags_fn);
10119 static void add_xt_block_frags
10120   (segT, segT, xtensa_block_info **, frag_predicate, frag_predicate);
10121 static bfd_boolean xtensa_frag_flags_is_empty (const frag_flags *);
10122 static void xtensa_frag_flags_init (frag_flags *);
10123 static void get_frag_property_flags (const fragS *, frag_flags *);
10124 static bfd_vma frag_flags_to_number (const frag_flags *);
10125 static void add_xt_prop_frags
10126   (segT, segT, xtensa_block_info **, frag_flags_fn);
10127
10128 /* Set up property tables after relaxation.  */
10129
10130 void
10131 xtensa_post_relax_hook (void)
10132 {
10133   xtensa_move_seg_list_to_beginning (literal_head);
10134   xtensa_move_seg_list_to_beginning (init_literal_head);
10135   xtensa_move_seg_list_to_beginning (fini_literal_head);
10136
10137   xtensa_find_unmarked_state_frags ();
10138
10139   if (use_literal_section)
10140     xtensa_create_property_segments (get_frag_is_literal,
10141                                      NULL,
10142                                      XTENSA_LIT_SEC_NAME,
10143                                      xt_literal_sec);
10144   xtensa_create_xproperty_segments (get_frag_property_flags,
10145                                     XTENSA_PROP_SEC_NAME,
10146                                     xt_prop_sec);
10147
10148   if (warn_unaligned_branch_targets)
10149     bfd_map_over_sections (stdoutput, xtensa_find_unaligned_branch_targets, 0);
10150   bfd_map_over_sections (stdoutput, xtensa_find_unaligned_loops, 0);
10151 }
10152
10153
10154 /* This function is only meaningful after xtensa_move_literals.  */
10155
10156 static bfd_boolean
10157 get_frag_is_literal (const fragS *fragP)
10158 {
10159   assert (fragP != NULL);
10160   return fragP->tc_frag_data.is_literal;
10161 }
10162
10163
10164 static void
10165 xtensa_create_property_segments (frag_predicate property_function,
10166                                  frag_predicate end_property_function,
10167                                  const char *section_name_base,
10168                                  xt_section_type sec_type)
10169 {
10170   segT *seclist;
10171
10172   /* Walk over all of the current segments.
10173      Walk over each fragment
10174      For each non-empty fragment,
10175      Build a property record (append where possible).  */
10176
10177   for (seclist = &stdoutput->sections;
10178        seclist && *seclist;
10179        seclist = &(*seclist)->next)
10180     {
10181       segT sec = *seclist;
10182       flagword flags;
10183
10184       flags = bfd_get_section_flags (stdoutput, sec);
10185       if (flags & SEC_DEBUGGING)
10186         continue;
10187       if (!(flags & SEC_ALLOC))
10188         continue;
10189
10190       if (section_has_property (sec, property_function))
10191         {
10192           char *property_section_name =
10193             xtensa_get_property_section_name (sec, section_name_base);
10194           segT insn_sec = retrieve_xtensa_section (property_section_name);
10195           segment_info_type *xt_seg_info = retrieve_segment_info (insn_sec);
10196           xtensa_block_info **xt_blocks =
10197             &xt_seg_info->tc_segment_info_data.blocks[sec_type];
10198           /* Walk over all of the frchains here and add new sections.  */
10199           add_xt_block_frags (sec, insn_sec, xt_blocks, property_function,
10200                               end_property_function);
10201         }
10202     }
10203
10204   /* Now we fill them out....  */
10205
10206   for (seclist = &stdoutput->sections;
10207        seclist && *seclist;
10208        seclist = &(*seclist)->next)
10209     {
10210       segment_info_type *seginfo;
10211       xtensa_block_info *block;
10212       segT sec = *seclist;
10213
10214       seginfo = seg_info (sec);
10215       block = seginfo->tc_segment_info_data.blocks[sec_type];
10216
10217       if (block)
10218         {
10219           xtensa_block_info *cur_block;
10220           /* This is a section with some data.  */
10221           int num_recs = 0;
10222           bfd_size_type rec_size;
10223
10224           for (cur_block = block; cur_block; cur_block = cur_block->next)
10225             num_recs++;
10226
10227           rec_size = num_recs * 8;
10228           bfd_set_section_size (stdoutput, sec, rec_size);
10229
10230           /* In order to make this work with the assembler, we have to
10231              build some frags and then build the "fixups" for it.  It
10232              would be easier to just set the contents then set the
10233              arlents.  */
10234
10235           if (num_recs)
10236             {
10237               /* Allocate a fragment and leak it.  */
10238               fragS *fragP;
10239               bfd_size_type frag_size;
10240               fixS *fixes;
10241               frchainS *frchainP;
10242               int i;
10243               char *frag_data;
10244
10245               frag_size = sizeof (fragS) + rec_size;
10246               fragP = (fragS *) xmalloc (frag_size);
10247
10248               memset (fragP, 0, frag_size);
10249               fragP->fr_address = 0;
10250               fragP->fr_next = NULL;
10251               fragP->fr_fix = rec_size;
10252               fragP->fr_var = 0;
10253               fragP->fr_type = rs_fill;
10254               /* The rest are zeros.  */
10255
10256               frchainP = seginfo->frchainP;
10257               frchainP->frch_root = fragP;
10258               frchainP->frch_last = fragP;
10259
10260               fixes = (fixS *) xmalloc (sizeof (fixS) * num_recs);
10261               memset (fixes, 0, sizeof (fixS) * num_recs);
10262
10263               seginfo->fix_root = fixes;
10264               seginfo->fix_tail = &fixes[num_recs - 1];
10265               cur_block = block;
10266               frag_data = &fragP->fr_literal[0];
10267               for (i = 0; i < num_recs; i++)
10268                 {
10269                   fixS *fix = &fixes[i];
10270                   assert (cur_block);
10271
10272                   /* Write the fixup.  */
10273                   if (i != num_recs - 1)
10274                     fix->fx_next = &fixes[i + 1];
10275                   else
10276                     fix->fx_next = NULL;
10277                   fix->fx_size = 4;
10278                   fix->fx_done = 0;
10279                   fix->fx_frag = fragP;
10280                   fix->fx_where = i * 8;
10281                   fix->fx_addsy = section_symbol (cur_block->sec);
10282                   fix->fx_offset = cur_block->offset;
10283                   fix->fx_r_type = BFD_RELOC_32;
10284                   fix->fx_file = "Internal Assembly";
10285                   fix->fx_line = 0;
10286
10287                   /* Write the length.  */
10288                   md_number_to_chars (&frag_data[4 + 8 * i],
10289                                       cur_block->size, 4);
10290                   cur_block = cur_block->next;
10291                 }
10292             }
10293         }
10294     }
10295 }
10296
10297
10298 static void
10299 xtensa_create_xproperty_segments (frag_flags_fn flag_fn,
10300                                   const char *section_name_base,
10301                                   xt_section_type sec_type)
10302 {
10303   segT *seclist;
10304
10305   /* Walk over all of the current segments.
10306      Walk over each fragment.
10307      For each fragment that has instructions,
10308      build an instruction record (append where possible).  */
10309
10310   for (seclist = &stdoutput->sections;
10311        seclist && *seclist;
10312        seclist = &(*seclist)->next)
10313     {
10314       segT sec = *seclist;
10315       flagword flags;
10316
10317       flags = bfd_get_section_flags (stdoutput, sec);
10318       if ((flags & SEC_DEBUGGING)
10319           || !(flags & SEC_ALLOC)
10320           || (flags & SEC_MERGE))
10321         continue;
10322
10323       if (section_has_xproperty (sec, flag_fn))
10324         {
10325           char *property_section_name =
10326             xtensa_get_property_section_name (sec, section_name_base);
10327           segT insn_sec = retrieve_xtensa_section (property_section_name);
10328           segment_info_type *xt_seg_info = retrieve_segment_info (insn_sec);
10329           xtensa_block_info **xt_blocks =
10330             &xt_seg_info->tc_segment_info_data.blocks[sec_type];
10331           /* Walk over all of the frchains here and add new sections.  */
10332           add_xt_prop_frags (sec, insn_sec, xt_blocks, flag_fn);
10333         }
10334     }
10335
10336   /* Now we fill them out....  */
10337
10338   for (seclist = &stdoutput->sections;
10339        seclist && *seclist;
10340        seclist = &(*seclist)->next)
10341     {
10342       segment_info_type *seginfo;
10343       xtensa_block_info *block;
10344       segT sec = *seclist;
10345
10346       seginfo = seg_info (sec);
10347       block = seginfo->tc_segment_info_data.blocks[sec_type];
10348
10349       if (block)
10350         {
10351           xtensa_block_info *cur_block;
10352           /* This is a section with some data.  */
10353           int num_recs = 0;
10354           bfd_size_type rec_size;
10355
10356           for (cur_block = block; cur_block; cur_block = cur_block->next)
10357             num_recs++;
10358
10359           rec_size = num_recs * (8 + 4);
10360           bfd_set_section_size (stdoutput, sec, rec_size);
10361
10362           /* elf_section_data (sec)->this_hdr.sh_entsize = 12; */
10363
10364           /* In order to make this work with the assembler, we have to build
10365              some frags then build the "fixups" for it.  It would be easier to
10366              just set the contents then set the arlents.  */
10367
10368           if (num_recs)
10369             {
10370               /* Allocate a fragment and (unfortunately) leak it.  */
10371               fragS *fragP;
10372               bfd_size_type frag_size;
10373               fixS *fixes;
10374               frchainS *frchainP;
10375               int i;
10376               char *frag_data;
10377
10378               frag_size = sizeof (fragS) + rec_size;
10379               fragP = (fragS *) xmalloc (frag_size);
10380
10381               memset (fragP, 0, frag_size);
10382               fragP->fr_address = 0;
10383               fragP->fr_next = NULL;
10384               fragP->fr_fix = rec_size;
10385               fragP->fr_var = 0;
10386               fragP->fr_type = rs_fill;
10387               /* The rest are zeros.  */
10388
10389               frchainP = seginfo->frchainP;
10390               frchainP->frch_root = fragP;
10391               frchainP->frch_last = fragP;
10392
10393               fixes = (fixS *) xmalloc (sizeof (fixS) * num_recs);
10394               memset (fixes, 0, sizeof (fixS) * num_recs);
10395
10396               seginfo->fix_root = fixes;
10397               seginfo->fix_tail = &fixes[num_recs - 1];
10398               cur_block = block;
10399               frag_data = &fragP->fr_literal[0];
10400               for (i = 0; i < num_recs; i++)
10401                 {
10402                   fixS *fix = &fixes[i];
10403                   assert (cur_block);
10404
10405                   /* Write the fixup.  */
10406                   if (i != num_recs - 1)
10407                     fix->fx_next = &fixes[i + 1];
10408                   else
10409                     fix->fx_next = NULL;
10410                   fix->fx_size = 4;
10411                   fix->fx_done = 0;
10412                   fix->fx_frag = fragP;
10413                   fix->fx_where = i * (8 + 4);
10414                   fix->fx_addsy = section_symbol (cur_block->sec);
10415                   fix->fx_offset = cur_block->offset;
10416                   fix->fx_r_type = BFD_RELOC_32;
10417                   fix->fx_file = "Internal Assembly";
10418                   fix->fx_line = 0;
10419
10420                   /* Write the length.  */
10421                   md_number_to_chars (&frag_data[4 + (8+4) * i],
10422                                       cur_block->size, 4);
10423                   md_number_to_chars (&frag_data[8 + (8+4) * i],
10424                                       frag_flags_to_number (&cur_block->flags),
10425                                       4);
10426                   cur_block = cur_block->next;
10427                 }
10428             }
10429         }
10430     }
10431 }
10432
10433
10434 static segment_info_type *
10435 retrieve_segment_info (segT seg)
10436 {
10437   segment_info_type *seginfo;
10438   seginfo = (segment_info_type *) bfd_get_section_userdata (stdoutput, seg);
10439   if (!seginfo)
10440     {
10441       frchainS *frchainP;
10442
10443       seginfo = (segment_info_type *) xmalloc (sizeof (*seginfo));
10444       memset ((void *) seginfo, 0, sizeof (*seginfo));
10445       seginfo->fix_root = NULL;
10446       seginfo->fix_tail = NULL;
10447       seginfo->bfd_section = seg;
10448       seginfo->sym = 0;
10449       /* We will not be dealing with these, only our special ones.  */
10450       bfd_set_section_userdata (stdoutput, seg, (void *) seginfo);
10451
10452       frchainP = (frchainS *) xmalloc (sizeof (frchainS));
10453       frchainP->frch_root = NULL;
10454       frchainP->frch_last = NULL;
10455       frchainP->frch_next = NULL;
10456       frchainP->frch_seg = seg;
10457       frchainP->frch_subseg = 0;
10458       frchainP->fix_root = NULL;
10459       frchainP->fix_tail = NULL;
10460       /* Do not init the objstack.  */
10461       /* obstack_begin (&frchainP->frch_obstack, chunksize); */
10462       /* frchainP->frch_frag_now = fragP; */
10463       frchainP->frch_frag_now = NULL;
10464
10465       seginfo->frchainP = frchainP;
10466     }
10467
10468   return seginfo;
10469 }
10470
10471
10472 static segT
10473 retrieve_xtensa_section (char *sec_name)
10474 {
10475   bfd *abfd = stdoutput;
10476   flagword flags, out_flags, link_once_flags;
10477   segT s;
10478
10479   flags = bfd_get_section_flags (abfd, now_seg);
10480   link_once_flags = (flags & SEC_LINK_ONCE);
10481   if (link_once_flags)
10482     link_once_flags |= (flags & SEC_LINK_DUPLICATES);
10483   out_flags = (SEC_RELOC | SEC_HAS_CONTENTS | SEC_READONLY | link_once_flags);
10484
10485   s = bfd_make_section_old_way (abfd, sec_name);
10486   if (s == NULL)
10487     as_bad (_("could not create section %s"), sec_name);
10488   if (!bfd_set_section_flags (abfd, s, out_flags))
10489     as_bad (_("invalid flag combination on section %s"), sec_name);
10490
10491   return s;
10492 }
10493
10494
10495 static bfd_boolean
10496 section_has_property (segT sec, frag_predicate property_function)
10497 {
10498   segment_info_type *seginfo = seg_info (sec);
10499   fragS *fragP;
10500
10501   if (seginfo && seginfo->frchainP)
10502     {
10503       for (fragP = seginfo->frchainP->frch_root; fragP; fragP = fragP->fr_next)
10504         {
10505           if (property_function (fragP)
10506               && (fragP->fr_type != rs_fill || fragP->fr_fix != 0))
10507             return TRUE;
10508         }
10509     }
10510   return FALSE;
10511 }
10512
10513
10514 static bfd_boolean
10515 section_has_xproperty (segT sec, frag_flags_fn property_function)
10516 {
10517   segment_info_type *seginfo = seg_info (sec);
10518   fragS *fragP;
10519
10520   if (seginfo && seginfo->frchainP)
10521     {
10522       for (fragP = seginfo->frchainP->frch_root; fragP; fragP = fragP->fr_next)
10523         {
10524           frag_flags prop_flags;
10525           property_function (fragP, &prop_flags);
10526           if (!xtensa_frag_flags_is_empty (&prop_flags))
10527             return TRUE;
10528         }
10529     }
10530   return FALSE;
10531 }
10532
10533
10534 /* Two types of block sections exist right now: literal and insns.  */
10535
10536 static void
10537 add_xt_block_frags (segT sec,
10538                     segT xt_block_sec,
10539                     xtensa_block_info **xt_block,
10540                     frag_predicate property_function,
10541                     frag_predicate end_property_function)
10542 {
10543   segment_info_type *seg_info;
10544   segment_info_type *xt_seg_info;
10545   bfd_vma seg_offset;
10546   fragS *fragP;
10547
10548   xt_seg_info = retrieve_segment_info (xt_block_sec);
10549   seg_info = retrieve_segment_info (sec);
10550
10551   /* Build it if needed.  */
10552   while (*xt_block != NULL)
10553     xt_block = &(*xt_block)->next;
10554   /* We are either at NULL at the beginning or at the end.  */
10555
10556   /* Walk through the frags.  */
10557   seg_offset = 0;
10558
10559   if (seg_info->frchainP)
10560     {
10561       for (fragP = seg_info->frchainP->frch_root;
10562            fragP;
10563            fragP = fragP->fr_next)
10564         {
10565           if (property_function (fragP)
10566               && (fragP->fr_type != rs_fill || fragP->fr_fix != 0))
10567             {
10568               if (*xt_block != NULL)
10569                 {
10570                   if ((*xt_block)->offset + (*xt_block)->size
10571                       == fragP->fr_address)
10572                     (*xt_block)->size += fragP->fr_fix;
10573                   else
10574                     xt_block = &((*xt_block)->next);
10575                 }
10576               if (*xt_block == NULL)
10577                 {
10578                   xtensa_block_info *new_block = (xtensa_block_info *)
10579                     xmalloc (sizeof (xtensa_block_info));
10580                   new_block->sec = sec;
10581                   new_block->offset = fragP->fr_address;
10582                   new_block->size = fragP->fr_fix;
10583                   new_block->next = NULL;
10584                   xtensa_frag_flags_init (&new_block->flags);
10585                   *xt_block = new_block;
10586                 }
10587               if (end_property_function
10588                   && end_property_function (fragP))
10589                 {
10590                   xt_block = &((*xt_block)->next);
10591                 }
10592             }
10593         }
10594     }
10595 }
10596
10597
10598 /* Break the encapsulation of add_xt_prop_frags here.  */
10599
10600 static bfd_boolean
10601 xtensa_frag_flags_is_empty (const frag_flags *prop_flags)
10602 {
10603   if (prop_flags->is_literal
10604       || prop_flags->is_insn
10605       || prop_flags->is_data
10606       || prop_flags->is_unreachable)
10607     return FALSE;
10608   return TRUE;
10609 }
10610
10611
10612 static void
10613 xtensa_frag_flags_init (frag_flags *prop_flags)
10614 {
10615   memset (prop_flags, 0, sizeof (frag_flags));
10616 }
10617
10618
10619 static void
10620 get_frag_property_flags (const fragS *fragP, frag_flags *prop_flags)
10621 {
10622   xtensa_frag_flags_init (prop_flags);
10623   if (fragP->tc_frag_data.is_literal)
10624     prop_flags->is_literal = TRUE;
10625   if (fragP->tc_frag_data.is_unreachable)
10626     prop_flags->is_unreachable = TRUE;
10627   else if (fragP->tc_frag_data.is_insn)
10628     {
10629       prop_flags->is_insn = TRUE;
10630       if (fragP->tc_frag_data.is_loop_target)
10631         prop_flags->insn.is_loop_target = TRUE;
10632       if (fragP->tc_frag_data.is_branch_target)
10633         prop_flags->insn.is_branch_target = TRUE;
10634       if (fragP->tc_frag_data.is_specific_opcode
10635           || fragP->tc_frag_data.is_no_transform)
10636         prop_flags->insn.is_no_transform = TRUE;
10637       if (fragP->tc_frag_data.is_no_density)
10638         prop_flags->insn.is_no_density = TRUE;
10639       if (fragP->tc_frag_data.use_absolute_literals)
10640         prop_flags->insn.is_abslit = TRUE;
10641     }
10642   if (fragP->tc_frag_data.is_align)
10643     {
10644       prop_flags->is_align = TRUE;
10645       prop_flags->alignment = fragP->tc_frag_data.alignment;
10646       if (xtensa_frag_flags_is_empty (prop_flags))
10647         prop_flags->is_data = TRUE;
10648     }
10649 }
10650
10651
10652 static bfd_vma
10653 frag_flags_to_number (const frag_flags *prop_flags)
10654 {
10655   bfd_vma num = 0;
10656   if (prop_flags->is_literal)
10657     num |= XTENSA_PROP_LITERAL;
10658   if (prop_flags->is_insn)
10659     num |= XTENSA_PROP_INSN;
10660   if (prop_flags->is_data)
10661     num |= XTENSA_PROP_DATA;
10662   if (prop_flags->is_unreachable)
10663     num |= XTENSA_PROP_UNREACHABLE;
10664   if (prop_flags->insn.is_loop_target)
10665     num |= XTENSA_PROP_INSN_LOOP_TARGET;
10666   if (prop_flags->insn.is_branch_target)
10667     {
10668       num |= XTENSA_PROP_INSN_BRANCH_TARGET;
10669       num = SET_XTENSA_PROP_BT_ALIGN (num, prop_flags->insn.bt_align_priority);
10670     }
10671
10672   if (prop_flags->insn.is_no_density)
10673     num |= XTENSA_PROP_INSN_NO_DENSITY;
10674   if (prop_flags->insn.is_no_transform)
10675     num |= XTENSA_PROP_INSN_NO_TRANSFORM;
10676   if (prop_flags->insn.is_no_reorder)
10677     num |= XTENSA_PROP_INSN_NO_REORDER;
10678   if (prop_flags->insn.is_abslit)
10679     num |= XTENSA_PROP_INSN_ABSLIT;
10680
10681   if (prop_flags->is_align)
10682     {
10683       num |= XTENSA_PROP_ALIGN;
10684       num = SET_XTENSA_PROP_ALIGNMENT (num, prop_flags->alignment);
10685     }
10686
10687   return num;
10688 }
10689
10690
10691 static bfd_boolean
10692 xtensa_frag_flags_combinable (const frag_flags *prop_flags_1,
10693                               const frag_flags *prop_flags_2)
10694 {
10695   /* Cannot combine with an end marker.  */
10696
10697   if (prop_flags_1->is_literal != prop_flags_2->is_literal)
10698     return FALSE;
10699   if (prop_flags_1->is_insn != prop_flags_2->is_insn)
10700     return FALSE;
10701   if (prop_flags_1->is_data != prop_flags_2->is_data)
10702     return FALSE;
10703
10704   if (prop_flags_1->is_insn)
10705     {
10706       /* Properties of the beginning of the frag.  */
10707       if (prop_flags_2->insn.is_loop_target)
10708         return FALSE;
10709       if (prop_flags_2->insn.is_branch_target)
10710         return FALSE;
10711       if (prop_flags_1->insn.is_no_density !=
10712           prop_flags_2->insn.is_no_density)
10713         return FALSE;
10714       if (prop_flags_1->insn.is_no_transform !=
10715           prop_flags_2->insn.is_no_transform)
10716         return FALSE;
10717       if (prop_flags_1->insn.is_no_reorder !=
10718           prop_flags_2->insn.is_no_reorder)
10719         return FALSE;
10720       if (prop_flags_1->insn.is_abslit !=
10721           prop_flags_2->insn.is_abslit)
10722         return FALSE;
10723     }
10724
10725   if (prop_flags_1->is_align)
10726     return FALSE;
10727
10728   return TRUE;
10729 }
10730
10731
10732 static bfd_vma
10733 xt_block_aligned_size (const xtensa_block_info *xt_block)
10734 {
10735   bfd_vma end_addr;
10736   unsigned align_bits;
10737
10738   if (!xt_block->flags.is_align)
10739     return xt_block->size;
10740
10741   end_addr = xt_block->offset + xt_block->size;
10742   align_bits = xt_block->flags.alignment;
10743   end_addr = ((end_addr + ((1 << align_bits) -1)) >> align_bits) << align_bits;
10744   return end_addr - xt_block->offset;
10745 }
10746
10747
10748 static bfd_boolean
10749 xtensa_xt_block_combine (xtensa_block_info *xt_block,
10750                          const xtensa_block_info *xt_block_2)
10751 {
10752   if (xt_block->sec != xt_block_2->sec)
10753     return FALSE;
10754   if (xt_block->offset + xt_block_aligned_size (xt_block)
10755       != xt_block_2->offset)
10756     return FALSE;
10757
10758   if (xt_block_2->size == 0
10759       && (!xt_block_2->flags.is_unreachable
10760           || xt_block->flags.is_unreachable))
10761     {
10762       if (xt_block_2->flags.is_align
10763           && xt_block->flags.is_align)
10764         {
10765           /* Nothing needed.  */
10766           if (xt_block->flags.alignment >= xt_block_2->flags.alignment)
10767             return TRUE;
10768         }
10769       else
10770         {
10771           if (xt_block_2->flags.is_align)
10772             {
10773               /* Push alignment to previous entry.  */
10774               xt_block->flags.is_align = xt_block_2->flags.is_align;
10775               xt_block->flags.alignment = xt_block_2->flags.alignment;
10776             }
10777           return TRUE;
10778         }
10779     }
10780   if (!xtensa_frag_flags_combinable (&xt_block->flags,
10781                                      &xt_block_2->flags))
10782     return FALSE;
10783
10784   xt_block->size += xt_block_2->size;
10785
10786   if (xt_block_2->flags.is_align)
10787     {
10788       xt_block->flags.is_align = TRUE;
10789       xt_block->flags.alignment = xt_block_2->flags.alignment;
10790     }
10791
10792   return TRUE;
10793 }
10794
10795
10796 static void
10797 add_xt_prop_frags (segT sec,
10798                    segT xt_block_sec,
10799                    xtensa_block_info **xt_block,
10800                    frag_flags_fn property_function)
10801 {
10802   segment_info_type *seg_info;
10803   segment_info_type *xt_seg_info;
10804   bfd_vma seg_offset;
10805   fragS *fragP;
10806
10807   xt_seg_info = retrieve_segment_info (xt_block_sec);
10808   seg_info = retrieve_segment_info (sec);
10809   /* Build it if needed.  */
10810   while (*xt_block != NULL)
10811     {
10812       xt_block = &(*xt_block)->next;
10813     }
10814   /* We are either at NULL at the beginning or at the end.  */
10815
10816   /* Walk through the frags.  */
10817   seg_offset = 0;
10818
10819   if (seg_info->frchainP)
10820     {
10821       for (fragP = seg_info->frchainP->frch_root; fragP;
10822            fragP = fragP->fr_next)
10823         {
10824           xtensa_block_info tmp_block;
10825           tmp_block.sec = sec;
10826           tmp_block.offset = fragP->fr_address;
10827           tmp_block.size = fragP->fr_fix;
10828           tmp_block.next = NULL;
10829           property_function (fragP, &tmp_block.flags);
10830
10831           if (!xtensa_frag_flags_is_empty (&tmp_block.flags))
10832             /* && fragP->fr_fix != 0) */
10833             {
10834               if ((*xt_block) == NULL
10835                   || !xtensa_xt_block_combine (*xt_block, &tmp_block))
10836                 {
10837                   xtensa_block_info *new_block;
10838                   if ((*xt_block) != NULL)
10839                     xt_block = &(*xt_block)->next;
10840                   new_block = (xtensa_block_info *)
10841                     xmalloc (sizeof (xtensa_block_info));
10842                   *new_block = tmp_block;
10843                   *xt_block = new_block;
10844                 }
10845             }
10846         }
10847     }
10848 }
10849
10850 \f
10851 /* op_placement_info_table */
10852
10853 /* op_placement_info makes it easier to determine which
10854    ops can go in which slots.  */
10855
10856 static void
10857 init_op_placement_info_table (void)
10858 {
10859   xtensa_isa isa = xtensa_default_isa;
10860   xtensa_insnbuf ibuf = xtensa_insnbuf_alloc (isa);
10861   xtensa_opcode opcode;
10862   xtensa_format fmt;
10863   int slot;
10864   int num_opcodes = xtensa_isa_num_opcodes (isa);
10865
10866   op_placement_table = (op_placement_info_table)
10867     xmalloc (sizeof (op_placement_info) * num_opcodes);
10868   assert (xtensa_isa_num_formats (isa) < MAX_FORMATS);
10869
10870   for (opcode = 0; opcode < num_opcodes; opcode++)
10871     {
10872       op_placement_info *opi = &op_placement_table[opcode];
10873       /* FIXME: Make tinsn allocation dynamic.  */
10874       if (xtensa_opcode_num_operands (isa, opcode) >= MAX_INSN_ARGS)
10875         as_fatal (_("too many operands in instruction"));
10876       opi->single = XTENSA_UNDEFINED;
10877       opi->single_size = 0;
10878       opi->widest = XTENSA_UNDEFINED;
10879       opi->widest_size = 0;
10880       opi->narrowest = XTENSA_UNDEFINED;
10881       opi->narrowest_size = 0x7F;
10882       opi->formats = 0;
10883       opi->num_formats = 0;
10884       opi->issuef = 0;
10885       for (fmt = 0; fmt < xtensa_isa_num_formats (isa); fmt++)
10886         {
10887           opi->slots[fmt] = 0;
10888           for (slot = 0; slot < xtensa_format_num_slots (isa, fmt); slot++)
10889             {
10890               if (xtensa_opcode_encode (isa, fmt, slot, ibuf, opcode) == 0)
10891                 {
10892                   int fmt_length = xtensa_format_length (isa, fmt);
10893                   opi->issuef++;
10894                   set_bit (fmt, opi->formats);
10895                   set_bit (slot, opi->slots[fmt]);
10896                   /* opi->slot_count[fmt]++; */
10897                   if (fmt_length < opi->narrowest_size)
10898                     {
10899                       opi->narrowest = fmt;
10900                       opi->narrowest_size = fmt_length;
10901                     }
10902                   if (fmt_length > opi->widest_size)
10903                     {
10904                       opi->widest = fmt;
10905                       opi->widest_size = fmt_length;
10906                     }
10907                   if (xtensa_format_num_slots (isa, fmt) == 1)
10908                     {
10909                       if (opi->single_size == 0
10910                           || fmt_length < opi->single_size)
10911                         {
10912                           opi->single = fmt;
10913                           opi->single_size = fmt_length;
10914                         }
10915                     }
10916                 }
10917             }
10918           if (opi->formats)
10919             opi->num_formats++;
10920         }
10921     }
10922   xtensa_insnbuf_free (isa, ibuf);
10923 }
10924
10925
10926 bfd_boolean
10927 opcode_fits_format_slot (xtensa_opcode opcode, xtensa_format fmt, int slot)
10928 {
10929   return bit_is_set (slot, op_placement_table[opcode].slots[fmt]);
10930 }
10931
10932
10933 /* If the opcode is available in a single slot format, return its size.  */
10934
10935 static int
10936 xg_get_single_size (xtensa_opcode opcode)
10937 {
10938   assert (op_placement_table[opcode].single != XTENSA_UNDEFINED);
10939   return op_placement_table[opcode].single_size;
10940 }
10941
10942
10943 static xtensa_format
10944 xg_get_single_format (xtensa_opcode opcode)
10945 {
10946   return op_placement_table[opcode].single;
10947 }
10948
10949 \f
10950 /* Instruction Stack Functions (from "xtensa-istack.h").  */
10951
10952 void
10953 istack_init (IStack *stack)
10954 {
10955   memset (stack, 0, sizeof (IStack));
10956   stack->ninsn = 0;
10957 }
10958
10959
10960 bfd_boolean
10961 istack_empty (IStack *stack)
10962 {
10963   return (stack->ninsn == 0);
10964 }
10965
10966
10967 bfd_boolean
10968 istack_full (IStack *stack)
10969 {
10970   return (stack->ninsn == MAX_ISTACK);
10971 }
10972
10973
10974 /* Return a pointer to the top IStack entry.
10975    It is an error to call this if istack_empty () is TRUE. */
10976
10977 TInsn *
10978 istack_top (IStack *stack)
10979 {
10980   int rec = stack->ninsn - 1;
10981   assert (!istack_empty (stack));
10982   return &stack->insn[rec];
10983 }
10984
10985
10986 /* Add a new TInsn to an IStack.
10987    It is an error to call this if istack_full () is TRUE.  */
10988
10989 void
10990 istack_push (IStack *stack, TInsn *insn)
10991 {
10992   int rec = stack->ninsn;
10993   assert (!istack_full (stack));
10994   stack->insn[rec] = *insn;
10995   stack->ninsn++;
10996 }
10997
10998
10999 /* Clear space for the next TInsn on the IStack and return a pointer
11000    to it.  It is an error to call this if istack_full () is TRUE.  */
11001
11002 TInsn *
11003 istack_push_space (IStack *stack)
11004 {
11005   int rec = stack->ninsn;
11006   TInsn *insn;
11007   assert (!istack_full (stack));
11008   insn = &stack->insn[rec];
11009   memset (insn, 0, sizeof (TInsn));
11010   stack->ninsn++;
11011   return insn;
11012 }
11013
11014
11015 /* Remove the last pushed instruction.  It is an error to call this if
11016    istack_empty () returns TRUE.  */
11017
11018 void
11019 istack_pop (IStack *stack)
11020 {
11021   int rec = stack->ninsn - 1;
11022   assert (!istack_empty (stack));
11023   stack->ninsn--;
11024   memset (&stack->insn[rec], 0, sizeof (TInsn));
11025 }
11026
11027 \f
11028 /* TInsn functions.  */
11029
11030 void
11031 tinsn_init (TInsn *dst)
11032 {
11033   memset (dst, 0, sizeof (TInsn));
11034 }
11035
11036
11037 /* Get the ``num''th token of the TInsn.
11038    It is illegal to call this if num > insn->ntoks.  */
11039
11040 expressionS *
11041 tinsn_get_tok (TInsn *insn, int num)
11042 {
11043   assert (num < insn->ntok);
11044   return &insn->tok[num];
11045 }
11046
11047
11048 /* Return TRUE if ANY of the operands in the insn are symbolic.  */
11049
11050 static bfd_boolean
11051 tinsn_has_symbolic_operands (const TInsn *insn)
11052 {
11053   int i;
11054   int n = insn->ntok;
11055
11056   assert (insn->insn_type == ITYPE_INSN);
11057
11058   for (i = 0; i < n; ++i)
11059     {
11060       switch (insn->tok[i].X_op)
11061         {
11062         case O_register:
11063         case O_constant:
11064           break;
11065         default:
11066           return TRUE;
11067         }
11068     }
11069   return FALSE;
11070 }
11071
11072
11073 bfd_boolean
11074 tinsn_has_invalid_symbolic_operands (const TInsn *insn)
11075 {
11076   xtensa_isa isa = xtensa_default_isa;
11077   int i;
11078   int n = insn->ntok;
11079
11080   assert (insn->insn_type == ITYPE_INSN);
11081
11082   for (i = 0; i < n; ++i)
11083     {
11084       switch (insn->tok[i].X_op)
11085         {
11086         case O_register:
11087         case O_constant:
11088           break;
11089         case O_big:
11090         case O_illegal:
11091         case O_absent:
11092           /* Errors for these types are caught later.  */
11093           break;
11094         case O_hi16:
11095         case O_lo16:
11096         default:
11097           /* Symbolic immediates are only allowed on the last immediate
11098              operand.  At this time, CONST16 is the only opcode where we
11099              support non-PC-relative relocations.  (It isn't necessary
11100              to complain about non-PC-relative relocations here, but
11101              otherwise, no error is reported until the relocations are
11102              generated, and the assembler won't get that far if there
11103              are any other errors.  It's nice to see all the problems
11104              at once.)  */
11105           if (i != get_relaxable_immed (insn->opcode)
11106               || (xtensa_operand_is_PCrelative (isa, insn->opcode, i) != 1
11107                   && insn->opcode != xtensa_const16_opcode))
11108             {
11109               as_bad (_("invalid symbolic operand %d on '%s'"),
11110                       i, xtensa_opcode_name (isa, insn->opcode));
11111               return TRUE;
11112             }
11113         }
11114     }
11115   return FALSE;
11116 }
11117
11118
11119 /* For assembly code with complex expressions (e.g. subtraction),
11120    we have to build them in the literal pool so that
11121    their results are calculated correctly after relaxation.
11122    The relaxation only handles expressions that
11123    boil down to SYMBOL + OFFSET.  */
11124
11125 static bfd_boolean
11126 tinsn_has_complex_operands (const TInsn *insn)
11127 {
11128   int i;
11129   int n = insn->ntok;
11130   assert (insn->insn_type == ITYPE_INSN);
11131   for (i = 0; i < n; ++i)
11132     {
11133       switch (insn->tok[i].X_op)
11134         {
11135         case O_register:
11136         case O_constant:
11137         case O_symbol:
11138         case O_lo16:
11139         case O_hi16:
11140           break;
11141         default:
11142           return TRUE;
11143         }
11144     }
11145   return FALSE;
11146 }
11147
11148
11149 /* Convert the constant operands in the tinsn to insnbuf.
11150    Return TRUE if there is a symbol in the immediate field.
11151
11152    Before this is called,
11153    1) the number of operands are correct
11154    2) the tinsn is a ITYPE_INSN
11155    3) ONLY the relaxable_ is built
11156    4) All operands are O_constant, O_symbol.  All constants fit
11157    The return value tells whether there are any remaining O_symbols.  */
11158
11159 static bfd_boolean
11160 tinsn_to_insnbuf (TInsn *tinsn, xtensa_insnbuf insnbuf)
11161 {
11162   static xtensa_insnbuf slotbuf = 0;
11163   xtensa_isa isa = xtensa_default_isa;
11164   xtensa_opcode opcode = tinsn->opcode;
11165   xtensa_format fmt = xg_get_single_format (opcode);
11166   bfd_boolean has_fixup = FALSE;
11167   int noperands = xtensa_opcode_num_operands (isa, opcode);
11168   int i;
11169   uint32 opnd_value;
11170   char *file_name;
11171   unsigned line;
11172
11173   if (!slotbuf)
11174     slotbuf = xtensa_insnbuf_alloc (isa);
11175
11176   assert (tinsn->insn_type == ITYPE_INSN);
11177   if (noperands != tinsn->ntok)
11178     as_fatal (_("operand number mismatch"));
11179
11180   if (xtensa_opcode_encode (isa, fmt, 0, slotbuf, opcode))
11181     as_fatal (_("cannot encode opcode"));
11182
11183   for (i = 0; i < noperands; ++i)
11184     {
11185       expressionS *expr = &tinsn->tok[i];
11186       switch (expr->X_op)
11187         {
11188         case O_register:
11189           if (xtensa_operand_is_visible (isa, opcode, i) == 0)
11190             break;
11191           /* The register number has already been checked in
11192              expression_maybe_register, so we don't need to check here.  */
11193           opnd_value = expr->X_add_number;
11194           (void) xtensa_operand_encode (isa, opcode, i, &opnd_value);
11195           xtensa_operand_set_field (isa, opcode, i, fmt, 0,
11196                                     slotbuf, opnd_value);
11197           break;
11198
11199         case O_constant:
11200           if (xtensa_operand_is_visible (isa, opcode, i) == 0)
11201             break;
11202           as_where (&file_name, &line);
11203           /* It is a constant and we called this function,
11204              then we have to try to fit it.  */
11205           xtensa_insnbuf_set_operand (slotbuf, fmt, 0, opcode, i,
11206                                       expr->X_add_number, file_name, line);
11207           break;
11208
11209         default:
11210           has_fixup = TRUE;
11211           break;
11212         }
11213     }
11214
11215   xtensa_format_encode (isa, fmt, insnbuf);
11216   xtensa_format_set_slot (isa, fmt, 0, insnbuf, slotbuf);
11217
11218   return has_fixup;
11219 }
11220
11221
11222 /* Convert the constant operands in the tinsn to slotbuf.
11223    Return TRUE if there is a symbol in the immediate field.
11224    (Eventually this should replace tinsn_to_insnbuf.)  */
11225
11226 /* Before this is called,
11227    1) the number of operands are correct
11228    2) the tinsn is a ITYPE_INSN
11229    3) ONLY the relaxable_ is built
11230    4) All operands are
11231        O_constant, O_symbol
11232       All constants fit
11233
11234    The return value tells whether there are any remaining O_symbols.  */
11235
11236 static bfd_boolean
11237 tinsn_to_slotbuf (xtensa_format fmt,
11238                   int slot,
11239                   TInsn *tinsn,
11240                   xtensa_insnbuf slotbuf)
11241 {
11242   xtensa_isa isa = xtensa_default_isa;
11243   xtensa_opcode opcode = tinsn->opcode;
11244   bfd_boolean has_fixup = FALSE;
11245   int noperands = xtensa_opcode_num_operands (isa, opcode);
11246   int i;
11247
11248   *((int *) &slotbuf[0]) = 0;
11249   *((int *) &slotbuf[1]) = 0;
11250   assert (tinsn->insn_type == ITYPE_INSN);
11251   if (noperands != tinsn->ntok)
11252     as_fatal (_("operand number mismatch"));
11253
11254   if (xtensa_opcode_encode (isa, fmt, slot, slotbuf, opcode))
11255     {
11256       as_bad (_("cannot encode opcode \"%s\" in the given format \"%s\""),
11257               xtensa_opcode_name (isa, opcode), xtensa_format_name (isa, fmt));
11258       return FALSE;
11259     }
11260
11261   for (i = 0; i < noperands; i++)
11262     {
11263       expressionS *expr = &tinsn->tok[i];
11264       int rc;
11265       unsigned line;
11266       char *file_name;
11267       uint32 opnd_value;
11268
11269       switch (expr->X_op)
11270         {
11271         case O_register:
11272           if (xtensa_operand_is_visible (isa, opcode, i) == 0)
11273             break;
11274           /* The register number has already been checked in
11275              expression_maybe_register, so we don't need to check here.  */
11276           opnd_value = expr->X_add_number;
11277           (void) xtensa_operand_encode (isa, opcode, i, &opnd_value);
11278           rc = xtensa_operand_set_field (isa, opcode, i, fmt, slot, slotbuf,
11279                                          opnd_value);
11280           if (rc != 0)
11281             as_warn (_("xtensa-isa failure: %s"), xtensa_isa_error_msg (isa));
11282           break;
11283
11284         case O_constant:
11285           if (xtensa_operand_is_visible (isa, opcode, i) == 0)
11286             break;
11287           as_where (&file_name, &line);
11288           /* It is a constant and we called this function
11289              then we have to try to fit it.  */
11290           xtensa_insnbuf_set_operand (slotbuf, fmt, slot, opcode, i,
11291                                       expr->X_add_number, file_name, line);
11292           break;
11293
11294         default:
11295           has_fixup = TRUE;
11296           break;
11297         }
11298     }
11299
11300   return has_fixup;
11301 }
11302
11303
11304 /* Check the instruction arguments.  Return TRUE on failure.  */
11305
11306 static bfd_boolean
11307 tinsn_check_arguments (const TInsn *insn)
11308 {
11309   xtensa_isa isa = xtensa_default_isa;
11310   xtensa_opcode opcode = insn->opcode;
11311
11312   if (opcode == XTENSA_UNDEFINED)
11313     {
11314       as_bad (_("invalid opcode"));
11315       return TRUE;
11316     }
11317
11318   if (xtensa_opcode_num_operands (isa, opcode) > insn->ntok)
11319     {
11320       as_bad (_("too few operands"));
11321       return TRUE;
11322     }
11323
11324   if (xtensa_opcode_num_operands (isa, opcode) < insn->ntok)
11325     {
11326       as_bad (_("too many operands"));
11327       return TRUE;
11328     }
11329   return FALSE;
11330 }
11331
11332
11333 /* Load an instruction from its encoded form.  */
11334
11335 static void
11336 tinsn_from_chars (TInsn *tinsn, char *f, int slot)
11337 {
11338   vliw_insn vinsn;
11339
11340   xg_init_vinsn (&vinsn);
11341   vinsn_from_chars (&vinsn, f);
11342
11343   *tinsn = vinsn.slots[slot];
11344   xg_free_vinsn (&vinsn);
11345 }
11346
11347
11348 static void
11349 tinsn_from_insnbuf (TInsn *tinsn,
11350                     xtensa_insnbuf slotbuf,
11351                     xtensa_format fmt,
11352                     int slot)
11353 {
11354   int i;
11355   xtensa_isa isa = xtensa_default_isa;
11356
11357   /* Find the immed.  */
11358   tinsn_init (tinsn);
11359   tinsn->insn_type = ITYPE_INSN;
11360   tinsn->is_specific_opcode = FALSE;    /* must not be specific */
11361   tinsn->opcode = xtensa_opcode_decode (isa, fmt, slot, slotbuf);
11362   tinsn->ntok = xtensa_opcode_num_operands (isa, tinsn->opcode);
11363   for (i = 0; i < tinsn->ntok; i++)
11364     {
11365       set_expr_const (&tinsn->tok[i],
11366                       xtensa_insnbuf_get_operand (slotbuf, fmt, slot,
11367                                                   tinsn->opcode, i));
11368     }
11369 }
11370
11371
11372 /* Read the value of the relaxable immed from the fr_symbol and fr_offset.  */
11373
11374 static void
11375 tinsn_immed_from_frag (TInsn *tinsn, fragS *fragP, int slot)
11376 {
11377   xtensa_opcode opcode = tinsn->opcode;
11378   int opnum;
11379
11380   if (fragP->tc_frag_data.slot_symbols[slot])
11381     {
11382       opnum = get_relaxable_immed (opcode);
11383       assert (opnum >= 0);
11384       if (fragP->tc_frag_data.slot_sub_symbols[slot])
11385         {
11386           set_expr_symbol_offset_diff
11387             (&tinsn->tok[opnum],
11388              fragP->tc_frag_data.slot_symbols[slot],
11389              fragP->tc_frag_data.slot_sub_symbols[slot],
11390              fragP->tc_frag_data.slot_offsets[slot]);
11391         }
11392       else
11393         {
11394           set_expr_symbol_offset
11395             (&tinsn->tok[opnum],
11396              fragP->tc_frag_data.slot_symbols[slot],
11397              fragP->tc_frag_data.slot_offsets[slot]);
11398         }
11399     }
11400 }
11401
11402
11403 static int
11404 get_num_stack_text_bytes (IStack *istack)
11405 {
11406   int i;
11407   int text_bytes = 0;
11408
11409   for (i = 0; i < istack->ninsn; i++)
11410     {
11411       TInsn *tinsn = &istack->insn[i];
11412       if (tinsn->insn_type == ITYPE_INSN)
11413         text_bytes += xg_get_single_size (tinsn->opcode);
11414     }
11415   return text_bytes;
11416 }
11417
11418
11419 static int
11420 get_num_stack_literal_bytes (IStack *istack)
11421 {
11422   int i;
11423   int lit_bytes = 0;
11424
11425   for (i = 0; i < istack->ninsn; i++)
11426     {
11427       TInsn *tinsn = &istack->insn[i];
11428       if (tinsn->insn_type == ITYPE_LITERAL && tinsn->ntok == 1)
11429         lit_bytes += 4;
11430     }
11431   return lit_bytes;
11432 }
11433
11434 \f
11435 /* vliw_insn functions.  */
11436
11437 static void
11438 xg_init_vinsn (vliw_insn *v)
11439 {
11440   int i;
11441   xtensa_isa isa = xtensa_default_isa;
11442
11443   xg_clear_vinsn (v);
11444
11445   v->insnbuf = xtensa_insnbuf_alloc (isa);
11446   if (v->insnbuf == NULL)
11447     as_fatal (_("out of memory"));
11448
11449   for (i = 0; i < MAX_SLOTS; i++)
11450     {
11451       tinsn_init (&v->slots[i]);
11452       v->slots[i].opcode = XTENSA_UNDEFINED;
11453       v->slotbuf[i] = xtensa_insnbuf_alloc (isa);
11454       if (v->slotbuf[i] == NULL)
11455         as_fatal (_("out of memory"));
11456     }
11457 }
11458
11459
11460 static void
11461 xg_clear_vinsn (vliw_insn *v)
11462 {
11463   int i;
11464   v->format = XTENSA_UNDEFINED;
11465   v->num_slots = 0;
11466   v->inside_bundle = FALSE;
11467
11468   if (xt_saved_debug_type != DEBUG_NONE)
11469     debug_type = xt_saved_debug_type;
11470
11471   for (i = 0; i < MAX_SLOTS; i++)
11472     {
11473       memset (&v->slots[i], 0, sizeof (TInsn));
11474       v->slots[i].opcode = XTENSA_UNDEFINED;
11475     }
11476 }
11477
11478
11479 static bfd_boolean
11480 vinsn_has_specific_opcodes (vliw_insn *v)
11481 {
11482   int i;
11483
11484   for (i = 0; i < v->num_slots; i++)
11485     {
11486       if (v->slots[i].is_specific_opcode)
11487         return TRUE;
11488     }
11489   return FALSE;
11490 }
11491
11492
11493 static void
11494 xg_free_vinsn (vliw_insn *v)
11495 {
11496   int i;
11497   xtensa_insnbuf_free (xtensa_default_isa, v->insnbuf);
11498   for (i = 0; i < MAX_SLOTS; i++)
11499     xtensa_insnbuf_free (xtensa_default_isa, v->slotbuf[i]);
11500 }
11501
11502
11503 /* Before this is called, we should have
11504    filled out the following fields:
11505
11506    1) the number of operands for each opcode are correct
11507    2) the tinsn in the slots are ITYPE_INSN
11508    3) ONLY the relaxable_ is built
11509    4) All operands are
11510        O_constant, O_symbol
11511       All constants fit
11512
11513    The return value tells whether there are any remaining O_symbols.  */
11514
11515 static bfd_boolean
11516 vinsn_to_insnbuf (vliw_insn *vinsn,
11517                   char *frag_offset,
11518                   fragS *fragP,
11519                   bfd_boolean record_fixup)
11520 {
11521   xtensa_isa isa = xtensa_default_isa;
11522   xtensa_format fmt = vinsn->format;
11523   xtensa_insnbuf insnbuf = vinsn->insnbuf;
11524   int slot;
11525   bfd_boolean has_fixup = FALSE;
11526
11527   xtensa_format_encode (isa, fmt, insnbuf);
11528
11529   for (slot = 0; slot < vinsn->num_slots; slot++)
11530     {
11531       TInsn *tinsn = &vinsn->slots[slot];
11532       bfd_boolean tinsn_has_fixup =
11533         tinsn_to_slotbuf (vinsn->format, slot, tinsn,
11534                           vinsn->slotbuf[slot]);
11535
11536       xtensa_format_set_slot (isa, fmt, slot,
11537                               insnbuf, vinsn->slotbuf[slot]);
11538       /* tinsn_has_fixup tracks if there is a fixup at all.
11539          record_fixup controls globally.  I.E., we use this
11540          function from several places, some of which are after
11541          fixups have already been recorded.  Finally,
11542          tinsn->record_fixup controls based on the individual ops,
11543          which may or may not need it based on the relaxation
11544          requirements.  */
11545       if (tinsn_has_fixup && record_fixup)
11546         {
11547           int i;
11548           xtensa_opcode opcode = tinsn->opcode;
11549           int noperands = xtensa_opcode_num_operands (isa, opcode);
11550           has_fixup = TRUE;
11551
11552           for (i = 0; i < noperands; i++)
11553             {
11554               expressionS* expr = &tinsn->tok[i];
11555               switch (expr->X_op)
11556                 {
11557                 case O_symbol:
11558                 case O_lo16:
11559                 case O_hi16:
11560                   if (get_relaxable_immed (opcode) == i)
11561                     {
11562                       if (tinsn->record_fix || expr->X_op != O_symbol)
11563                         {
11564                           if (!xg_add_opcode_fix
11565                               (tinsn, i, fmt, slot, expr, fragP,
11566                                frag_offset - fragP->fr_literal))
11567                             as_bad (_("instruction with constant operands does not fit"));
11568                         }
11569                       else
11570                         {
11571                           tinsn->symbol = expr->X_add_symbol;
11572                           tinsn->offset = expr->X_add_number;
11573                         }
11574                     }
11575                   else
11576                     as_bad (_("invalid operand %d on '%s'"),
11577                             i, xtensa_opcode_name (isa, opcode));
11578                   break;
11579
11580                 case O_constant:
11581                 case O_register:
11582                   break;
11583
11584                 case O_subtract:
11585                   if (get_relaxable_immed (opcode) == i)
11586                     {
11587                       if (tinsn->record_fix)
11588                           as_bad (_("invalid subtract operand"));
11589                       else
11590                         {
11591                           tinsn->symbol = expr->X_add_symbol;
11592                           tinsn->sub_symbol = expr->X_op_symbol;
11593                           tinsn->offset = expr->X_add_number;
11594                         }
11595                     }
11596                   else
11597                     as_bad (_("invalid operand %d on '%s'"),
11598                             i, xtensa_opcode_name (isa, opcode));
11599                   break;
11600
11601                 default:
11602                   as_bad (_("invalid expression for operand %d on '%s'"),
11603                           i, xtensa_opcode_name (isa, opcode));
11604                   break;
11605                 }
11606             }
11607         }
11608     }
11609
11610   return has_fixup;
11611 }
11612
11613
11614 static void
11615 vinsn_from_chars (vliw_insn *vinsn, char *f)
11616 {
11617   static xtensa_insnbuf insnbuf = NULL;
11618   static xtensa_insnbuf slotbuf = NULL;
11619   int i;
11620   xtensa_format fmt;
11621   xtensa_isa isa = xtensa_default_isa;
11622
11623   if (!insnbuf)
11624     {
11625       insnbuf = xtensa_insnbuf_alloc (isa);
11626       slotbuf = xtensa_insnbuf_alloc (isa);
11627     }
11628
11629   xtensa_insnbuf_from_chars (isa, insnbuf, (unsigned char *) f, 0);
11630   fmt = xtensa_format_decode (isa, insnbuf);
11631   if (fmt == XTENSA_UNDEFINED)
11632     as_fatal (_("cannot decode instruction format"));
11633   vinsn->format = fmt;
11634   vinsn->num_slots = xtensa_format_num_slots (isa, fmt);
11635
11636   for (i = 0; i < vinsn->num_slots; i++)
11637     {
11638       TInsn *tinsn = &vinsn->slots[i];
11639       xtensa_format_get_slot (isa, fmt, i, insnbuf, slotbuf);
11640       tinsn_from_insnbuf (tinsn, slotbuf, fmt, i);
11641     }
11642 }
11643
11644 \f
11645 /* Expression utilities.  */
11646
11647 /* Return TRUE if the expression is an integer constant.  */
11648
11649 bfd_boolean
11650 expr_is_const (const expressionS *s)
11651 {
11652   return (s->X_op == O_constant);
11653 }
11654
11655
11656 /* Get the expression constant.
11657    Calling this is illegal if expr_is_const () returns TRUE.  */
11658
11659 offsetT
11660 get_expr_const (const expressionS *s)
11661 {
11662   assert (expr_is_const (s));
11663   return s->X_add_number;
11664 }
11665
11666
11667 /* Set the expression to a constant value.  */
11668
11669 void
11670 set_expr_const (expressionS *s, offsetT val)
11671 {
11672   s->X_op = O_constant;
11673   s->X_add_number = val;
11674   s->X_add_symbol = NULL;
11675   s->X_op_symbol = NULL;
11676 }
11677
11678
11679 bfd_boolean
11680 expr_is_register (const expressionS *s)
11681 {
11682   return (s->X_op == O_register);
11683 }
11684
11685
11686 /* Get the expression constant.
11687    Calling this is illegal if expr_is_const () returns TRUE.  */
11688
11689 offsetT
11690 get_expr_register (const expressionS *s)
11691 {
11692   assert (expr_is_register (s));
11693   return s->X_add_number;
11694 }
11695
11696
11697 /* Set the expression to a symbol + constant offset.  */
11698
11699 void
11700 set_expr_symbol_offset (expressionS *s, symbolS *sym, offsetT offset)
11701 {
11702   s->X_op = O_symbol;
11703   s->X_add_symbol = sym;
11704   s->X_op_symbol = NULL;        /* unused */
11705   s->X_add_number = offset;
11706 }
11707
11708
11709 /* Set the expression to symbol - minus_sym + offset.  */
11710
11711 static void
11712 set_expr_symbol_offset_diff (expressionS *s,
11713                              symbolS *sym,
11714                              symbolS *minus_sym,
11715                              offsetT offset)
11716 {
11717   s->X_op = O_subtract;
11718   s->X_add_symbol = sym;
11719   s->X_op_symbol = minus_sym;   /* unused */
11720   s->X_add_number = offset;
11721 }
11722
11723
11724 /* Return TRUE if the two expressions are equal.  */
11725
11726 bfd_boolean
11727 expr_is_equal (expressionS *s1, expressionS *s2)
11728 {
11729   if (s1->X_op != s2->X_op)
11730     return FALSE;
11731   if (s1->X_add_symbol != s2->X_add_symbol)
11732     return FALSE;
11733   if (s1->X_op_symbol != s2->X_op_symbol)
11734     return FALSE;
11735   if (s1->X_add_number != s2->X_add_number)
11736     return FALSE;
11737   return TRUE;
11738 }
11739
11740
11741 static void
11742 copy_expr (expressionS *dst, const expressionS *src)
11743 {
11744   memcpy (dst, src, sizeof (expressionS));
11745 }
11746
11747 \f
11748 /* Support for the "--rename-section" option.  */
11749
11750 struct rename_section_struct
11751 {
11752   char *old_name;
11753   char *new_name;
11754   struct rename_section_struct *next;
11755 };
11756
11757 static struct rename_section_struct *section_rename;
11758
11759
11760 /* Parse the string "oldname=new_name(:oldname2=new_name2)*" and add
11761    entries to the section_rename list.  Note: Specifying multiple
11762    renamings separated by colons is not documented and is retained only
11763    for backward compatibility.  */
11764
11765 static void
11766 build_section_rename (const char *arg)
11767 {
11768   struct rename_section_struct *r;
11769   char *this_arg = NULL;
11770   char *next_arg = NULL;
11771
11772   for (this_arg = xstrdup (arg); this_arg != NULL; this_arg = next_arg)
11773     {
11774       char *old_name, *new_name;
11775
11776       if (this_arg)
11777         {
11778           next_arg = strchr (this_arg, ':');
11779           if (next_arg)
11780             {
11781               *next_arg = '\0';
11782               next_arg++;
11783             }
11784         }
11785
11786       old_name = this_arg;
11787       new_name = strchr (this_arg, '=');
11788
11789       if (*old_name == '\0')
11790         {
11791           as_warn (_("ignoring extra '-rename-section' delimiter ':'"));
11792           continue;
11793         }
11794       if (!new_name || new_name[1] == '\0')
11795         {
11796           as_warn (_("ignoring invalid '-rename-section' specification: '%s'"),
11797                    old_name);
11798           continue;
11799         }
11800       *new_name = '\0';
11801       new_name++;
11802
11803       /* Check for invalid section renaming.  */
11804       for (r = section_rename; r != NULL; r = r->next)
11805         {
11806           if (strcmp (r->old_name, old_name) == 0)
11807             as_bad (_("section %s renamed multiple times"), old_name);
11808           if (strcmp (r->new_name, new_name) == 0)
11809             as_bad (_("multiple sections remapped to output section %s"),
11810                     new_name);
11811         }
11812
11813       /* Now add it.  */
11814       r = (struct rename_section_struct *)
11815         xmalloc (sizeof (struct rename_section_struct));
11816       r->old_name = xstrdup (old_name);
11817       r->new_name = xstrdup (new_name);
11818       r->next = section_rename;
11819       section_rename = r;
11820     }
11821 }
11822
11823
11824 char *
11825 xtensa_section_rename (char *name)
11826 {
11827   struct rename_section_struct *r = section_rename;
11828
11829   for (r = section_rename; r != NULL; r = r->next)
11830     {
11831       if (strcmp (r->old_name, name) == 0)
11832         return r->new_name;
11833     }
11834
11835   return name;
11836 }